diff --git a/.github/workflows/doc.yml b/.github/workflows/doc.yml new file mode 100644 index 0000000..37565a7 --- /dev/null +++ b/.github/workflows/doc.yml @@ -0,0 +1,34 @@ +name: Documentation deployement + +on: + pull_request_target: + types: + - closed + branches: + - main + release: + types: [published] +jobs: + build_publish_docs: + # Deploy to cloudflare + if: github.event_name == 'release' || github.event.pull_request.merged == true + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Build Document + run: | + pip install -r requirements-dev.txt + sudo apt update + sudo apt install -y pandoc + touch .env + echo "SPHINX_GITHUB_CHANGELOG_TOKEN=${{secrets.DOC_GH_API_TOKEN}}" > .env + sphinx-build -b html docs build + - name: Publish + uses: cloudflare/pages-action@1 + with: + apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }} + accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }} + projectName: mpqp + branch: main + directory: build diff --git a/.github/workflows/pypi.yml b/.github/workflows/pypi.yml new file mode 100644 index 0000000..de25c86 --- /dev/null +++ b/.github/workflows/pypi.yml @@ -0,0 +1,28 @@ +name: Pipy publishing + +on: + push: + tags: + - "*" + +jobs: + build_publish_package: + runs-on: ubuntu-latest + steps: + - name: Checkout Repository + uses: actions/checkout@v4 + - name: Install Dependencies + run: | + pip install -r requirements-dev.txt + - name: Build Package + run: python setup.py sdist bdist_wheel + - name: Install Twine + run: | + pip install twine + pip install -U packaging + - name: Publish to PyPI + run: | + twine upload dist/* + env: + TWINE_USERNAME: __token__ + TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }} diff --git a/.gitignore b/.gitignore index dac6ce7..fc6d166 100644 --- a/.gitignore +++ b/.gitignore @@ -141,7 +141,7 @@ cython_debug/ # that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore # and can be added to the global gitignore or merged into this file. However, if you prefer, # you could uncomment the following to ignore the entire vscode folder -.vscode/ +# .vscode/ # PyPI configuration file .pypirc @@ -151,3 +151,4 @@ marimo/_static/ marimo/_lsp/ __marimo__/ +ex/figures/ \ No newline at end of file diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..dd0cb6a --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,13 @@ +{ + "recommendations": [ + "ms-python.isort", + "ms-python.black-formatter", + "ms-python.vscode-pylance", + "streetsidesoftware.code-spell-checker", + "ms-toolsai.jupyter", + "James-Yu.latex-workshop", + "tecosaur.latex-utilities", + "mathematic.vscode-latex", + "esbenp.prettier-vscode" + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..abfd69c --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,30 @@ +{ + "[python]": { + "editor.defaultFormatter": "ms-python.black-formatter" + }, + "python.analysis.typeCheckingMode": "strict", + "editor.formatOnSave": true, + "python.analysis.autoImportCompletions": true, + "python.analysis.autoFormatStrings": true, + "python.analysis.diagnosticSeverityOverrides": { + "reportUnknownArgumentType": "none", + "reportUnknownVariableType": "none", + "reportUnknownMemberType": "none", + "reportUnknownLambdaType": "none", + "reportMissingTypeStubs": "none", + "reportUnknownParameterType": "none", + "reportUnnecessaryTypeIgnoreComment": "warning" + // "enableTypeIgnoreComments": "false" + // "reportGeneralTypeIssues": "none" + }, + "autoDocstring.docstringFormat": "google-notypes", + "isort.check": true, + "isort.args": ["--profile", "black"], + "editor.codeActionsOnSave": { + "source.organizeImports": "always" + }, + "editor.defaultFormatter": "esbenp.prettier-vscode", + "python-envs.defaultEnvManager": "ms-python.python:system", + "python-envs.defaultPackageManager": "ms-python.python:pip", + "python-envs.pythonProjects": [] +} diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..6416f2d --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,10 @@ +graft landscape_tools + +prune .github +prune .vscode +prune .idea + +global-exclude .DS_Store +global-exclude __pycache__ +global-exclude *.pyd +global-exclude .env \ No newline at end of file diff --git a/README.md b/README.md index 8424a45..133da8f 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,9 @@ -# Landscape Characterization +# Landscape Tools ## Installation ```bash -pip install --upgrade git+https://github.com/ColibrITD-SAS/landscape_tools +pip install landscape_tools ``` ```python @@ -11,22 +11,7 @@ from landscape_tools import landscape_visualization as lv from landscape_tools import barren_plateaus as bp ``` ---- - -update the documentation with - -```sh -sphinx-build -b html docs build -``` - -but of course, in order to do that, you need the lastest dev dependancies, -install them with - -```sh -pip install -r dependencies-dev.txt -``` - -# Landscape Tools +## Landscape Characterization This module provides utilities to analyze and visualize the optimization landscape of variational quantum algorithms (VQAs). @@ -41,8 +26,8 @@ The main purpose of this module is to: - study gradient magnitudes and barren plateau effects, - visualize trajectories and parameter influence. -Most algorithms implemented here only depend on a **generic cost -function interface**, not on circuits, observables, or backends. +Most algorithms implemented here only depend on a +**generic cost function interface**, not on circuits, observables, or backends. All landscape analysis functions expect a cost function of the form: @@ -64,326 +49,3 @@ wrapped_loss = lambda p: cost_function( hamiltonian=my_hamiltonian, ) ``` - -## Available functions - -### Loss landscape scans - -#### `loss_scan_1d` - -Evaluate the loss function along a **one-dimensional direction** in parameter -space. - -This utility scans a line in parameter space starting from a reference parameter -vector and evaluates the loss function at regularly spaced points along the -specified direction. It is commonly used to inspect the local geometry of the -loss landscape, such as flatness, curvature, or the presence of nearby minima. - -```python -lv.loss_scan_1d( - params, - direction, - loss_function, - n_steps=200, - end_points=None, - n_jobs=-1, -) -``` - -##### Parameters - -- **params** (`ParameterVector`) - Reference parameter vector used as the center of the scan. - -- **direction** (`ArrayLike`) - Direction in parameter space along which the scan is performed. - -- **loss_function** (`Callable[[ParameterVector], float]`) - Function returning the scalar loss value associated with a parameter vector. - -- **n_steps** (`int`, optional) - Number of evaluation points along the scan direction. - Default is `200`. - -- **end_points** (`tuple[float, float] | None`, optional) - Bounds of the scan parameter. If `None`, the default interval - `(-π, π)` is used. - -- **n_jobs** (`int`, optional) - Number of parallel jobs used during the scan evaluation. - Default is `-1` (use all available CPUs). - -#### `loss_scan_2d_3d` - -Evaluate the loss function on a **two-dimensional parameter plane**. - -This utility explores the loss landscape over a plane defined by two directions -in parameter space. The loss function is evaluated on a regular two-dimensional -grid, allowing visualization of local minima, valleys, saddle points, and -overall surface structure. Optionally, a 3D representation of the loss surface -can be generated. - -```python -lv.loss_scan_2d_3d( - params, - direction1, - direction2, - loss_function, - n_steps=100, - end_points_x=None, - end_points_y=None, - plot3D=True, - n_jobs=-1, -) -``` - -##### Parameters - -- **params** (`ParameterVector`) - Reference parameter vector used as the center of the scan. - -- **direction1** (`ArrayLike`) - First direction in parameter space defining the scan plane. - -- **direction2** (`ArrayLike`) - Second direction in parameter space defining the scan plane. - -- **loss_function** (`Callable[[ParameterVector], float]`) - Function returning the scalar loss value associated with a parameter vector. - -- **n_steps** (`int`, optional) - Number of evaluation points along each scan direction. - Default is `100`. - -- **end_points_x** (`tuple[float, float] | None`, optional) - Bounds of the scan parameter along the first direction. - If `None`, the default interval `(-π, π)` is used. - -- **end_points_y** (`tuple[float, float] | None`, optional) - Bounds of the scan parameter along the second direction. - If `None`, the default interval `(-π, π)` is used. - -- **plot3D** (`bool`, optional) - Whether to generate a 3D visualization of the loss surface. - Default is `True`. - -- **n_jobs** (`int`, optional) - Number of parallel jobs used during the scan evaluation. - Default is `-1` (use all available CPUs). - -### PCA-based landscape analysis - -#### `perform_pca_and_analysis` - -Run a **complete PCA-based loss landscape analysis pipeline**. - -This utility builds a low-dimensional representation of an optimization -trajectory using Principal Component Analysis (PCA), performs loss scans in the -resulting PCA subspace, and generates interpretability analyses of the dominant -optimization directions. - -The function is designed to help visualize and understand the geometry of the -optimization process and the most significant parameter variations. - -```python -lv.perform_pca_and_analysis( - params_history, - loss_function, - n_steps, - offset, - n_top, - circuit, - n_jobs=-1, -) -``` - -##### Parameters - -- **params_history** (`np.ndarray`) - Array containing the parameter vectors recorded during optimization. - -- **loss_function** (`Callable[[ParameterVector], float]`) - Function returning the scalar loss value associated with a parameter vector. - -- **n_steps** (`int`) - Number of evaluation points along each PCA direction. - -- **offset** (`float | tuple[float, float]`) - Margin added to the PCA scan bounds to enlarge the explored region. - -- **n_top** (`int`) - Number of top-ranked entries displayed in interpretability analyses. - -- **circuit** (`Any`) - Quantum circuit associated with the analyzed parameter space. - -- **n_jobs** (`int`, optional) - Number of parallel jobs used during the scan evaluation. - Default is `-1` (use all available CPUs). - -##### Returns - -- Mapping returned by `analyze_pca`. - ---- - -# Barren Plateau - -This module provides utilities to study **barren plateau phenomena** in -variational quantum algorithms (VQAs). - -It enables systematic scaling analyses of loss variances as a function of: - -- the number of qubits, -- the circuit depth, -- the observable structure, -- and padding strategies for growing operators. - -The implementation is designed to remain backend-agnostic and relies on generic -user-defined circuit generation, parameter initialization, and cost function -construction routines. - -### Main analysis function - -#### `barren_plateaus_analysis` - -Run a **complete barren plateau scaling analysis pipeline**. - -This utility automates the generation of variational circuits, parameter -sampling, variance estimation, bootstrap diagnostics, and visualization of the -loss variance scaling behavior across different system sizes and circuit depths. - -It can be used to investigate whether the variance of the cost function decays -exponentially with problem size, a characteristic signature of barren plateaus. - -```python -bp.barren_plateaus_analysis( - experiment, - cost_function_builder, - generate_params, - generate_circuits, - sampling=None, - execution=None, - variance_normalization=None, - **cost_kwargs, -) -``` - -##### Parameters - -- **experiment** (`ExperimentConfig`) - Configuration object defining the barren plateau experiment settings. - -- **cost_function_builder** (`Callable`) - Function used to construct the cost function evaluated during the analysis. - -- **generate_params** (`Callable`) - Function generating random parameter vectors for the variational circuits. - -- **generate_circuits** (`Callable`) - Function generating the quantum circuits associated with the experiment. - -- **sampling** (`SamplingConfig | None`, optional) - Configuration controlling adaptive sampling and bootstrap variance - estimation. - If `None`, default sampling settings are used. - -- **execution** (`ExecutionConfig | None`, optional) - Configuration controlling execution parameters such as parallelization and - verbosity. - If `None`, default execution settings are used. - -- **variance_normalization** (`Callable | None`, optional) - Optional normalization applied to the estimated variances before analysis. - -- **\*\*cost_kwargs** - Additional keyword arguments forwarded to the cost function builder. - -##### Returns - -- **dict** - Dictionary containing the computed variance statistics, diagnostics, and - analysis results. - -### Available analysis modes - -The behavior of the analysis is controlled through the -`experiment.analysis_type` field. - -Three main scaling studies are supported. - -#### 1. Qubit scaling analysis - -Study how the variance evolves as the number of qubits increases while keeping -the circuit depth fixed. - -This is the standard barren plateau analysis used to detect exponential decay -with system size. - -```python -experiment = bp.ExperimentConfig( - analysis_type="qubits", - N_qubits=[4, 6, 8, 10], - N_layers=[2, 4], - Ansatz="HardwareEfficient", -) -``` - -#### 2. Layer scaling analysis - -Study how the variance evolves as the circuit depth increases for fixed system -sizes. - -This analysis is useful for understanding how expressibility and depth impact -trainability. - -```python -experiment = bp.ExperimentConfig( - analysis_type="layers", - N_qubits=[6, 8], - N_layers=[1, 2, 4, 8], - Ansatz="HardwareEfficient", -) -``` - -#### 3. Padding scaling analysis - -Study how different Pauli-string growth strategies affect barren plateau -behavior when increasing the system size. - -This mode compares several operator padding schemes during qubit scaling. - -```python -experiment = bp.ExperimentConfig( - analysis_type="padding", - N_qubits=[4, 6, 8, 10], - N_layers=[2, 4], - Ansatz="HardwareEfficient", - initial_Pauli_string="ZZ", - padding_types=[ - "linear_half", - "linear_full", - "logarithmic", - ], -) -``` - -### Example - -```python -from landscape_characterization import barren_plateaus as bp - -experiment = bp.ExperimentConfig( - analysis_type="qubits", - N_qubits=[4, 6, 8], - N_layers=[2, 4], - Ansatz="HardwareEfficient", -) - -results = bp.barren_plateaus_analysis( - experiment=experiment, - cost_function_builder=build_cost_function, - generate_params=generate_params, - generate_circuits=generate_circuits, -) -``` diff --git a/docs/index.rst b/docs/index.rst index a05a36a..9ddf44f 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -13,7 +13,7 @@ Check each of the pages to have an overview. .. toctree:: - :maxdepth: 2 + :maxdepth: 1 :caption: Contents: barren_plateaus diff --git a/ex/barren_plateaus_tools.ipynb b/ex/barren_plateaus_tools.ipynb new file mode 100644 index 0000000..c589140 --- /dev/null +++ b/ex/barren_plateaus_tools.ipynb @@ -0,0 +1,1483 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "6b8a12b0", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install --upgrade git+https://github.com/ColibrITD-SAS/landscape_tools@dev\n", + "#!pip install landscape-tools" + ] + }, + { + "cell_type": "markdown", + "id": "bffaf128", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1442361a", + "metadata": {}, + "outputs": [], + "source": [ + "from landscape_tools import barren_plateaus as bp\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qiskit import QuantumCircuit\n", + "from qiskit.circuit import ParameterVector\n", + "from qiskit.quantum_info import Statevector\n", + "from qiskit.quantum_info import Pauli" + ] + }, + { + "cell_type": "markdown", + "id": "378b016f", + "metadata": {}, + "source": [ + "# Example of a problem" + ] + }, + { + "cell_type": "markdown", + "id": "9d2f7e3f", + "metadata": {}, + "source": [ + "## Probability distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0eedc226", + "metadata": {}, + "outputs": [], + "source": [ + "def get_prob_distribution(params, ansatz, theta_params):\n", + "\n", + " param_dict = dict(zip(theta_params, params)) \n", + " # param_dict = {\n", + " # θ0: 0.5,\n", + " # θ1: 1.2\n", + " # }\n", + "\n", + " bound_circuit = ansatz.assign_parameters(param_dict, inplace=False)\n", + "\n", + " state = Statevector.from_instruction(bound_circuit)\n", + " probs = state.probabilities()\n", + "\n", + " return np.asarray(probs, dtype=float)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f238d6b8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_qubits = 5\n", + "dim = 2 ** n_qubits\n", + "\n", + "p_target = np.zeros(dim)\n", + "\n", + "# index 0 -> |000>, index 1 -> |001>, ..., index 7 -> |111>\n", + "p_target[0] = 0.40 # |000>\n", + "p_target[3] = 0.25 # |011>\n", + "p_target[7] = 0.35 # |111>\n", + "\n", + "p_target = p_target / p_target.sum() # normalize to ensure probabilities sum to 1\n", + "\n", + "plt.bar(range(dim), p_target)\n", + "plt.xlabel(\"state |x>\")\n", + "plt.ylabel(\"target probability\")\n", + "plt.title(\"Target distribution\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5cd253a0", + "metadata": {}, + "source": [ + "## Quantum circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3a10899a", + "metadata": {}, + "outputs": [], + "source": [ + "def build_hea_ansatz(n_qubits, n_layers, Ansatz):\n", + " \"\"\"\n", + " Hardware Efficient Ansatz :\n", + " - RY + RZ on each qubit\n", + " - CNOT chain\n", + " \"\"\"\n", + " qc = QuantumCircuit(n_qubits)\n", + "\n", + " n_params = 2 * n_qubits * n_layers\n", + " theta = ParameterVector(\"θ\", n_params)\n", + "\n", + " k = 0\n", + " for _ in range(n_layers):\n", + " for q in range(n_qubits):\n", + " qc.ry(theta[k], q)\n", + " k += 1\n", + " qc.rz(theta[k], q)\n", + " k += 1\n", + "\n", + " for q in range(n_qubits - 1):\n", + " qc.cx(q, q + 1)\n", + "\n", + " qc.metadata = {\"parameters\": theta, \"ansatz_name\": Ansatz,}\n", + "\n", + " return qc" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c36868dd", + "metadata": {}, + "outputs": [], + "source": [ + "def generate_params_hea(n_qubits, n_layers):\n", + " \"\"\"\n", + " Generate random parameters for HEA ansatz (uniform distribution).\n", + " \"\"\"\n", + "\n", + " n_params = 2 * n_qubits * n_layers\n", + " params = np.random.uniform(0, 2 * np.pi, n_params)\n", + "\n", + " return params" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "eec3289f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of parameters: 20\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_layers = 2\n", + "\n", + "ansatz = build_hea_ansatz(n_qubits, n_layers, \"HEA_test\")\n", + "theta_params = ansatz.metadata[\"parameters\"]\n", + "\n", + "n_params = len(theta_params)\n", + "\n", + "print(\"Number of parameters:\", n_params)\n", + "ansatz.draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "id": "a6d9392e", + "metadata": {}, + "source": [ + "## Loss function" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8a6333cb", + "metadata": {}, + "outputs": [], + "source": [ + "def mse_loss(params, ansatz, theta_params, p_target):\n", + " p_model = get_prob_distribution(params, ansatz, theta_params)\n", + " return np.sum((p_model - p_target) ** 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "c2a1dd6d", + "metadata": {}, + "outputs": [], + "source": [ + "def circuit_mse_loss_builder(\n", + " context,\n", + " target=\"uniform\",\n", + "):\n", + " from qiskit.quantum_info import Statevector\n", + "\n", + " circuit = context[\"circuits\"]\n", + " n_qubits = context[\"n_qubits\"]\n", + "\n", + " if circuit.metadata is not None and \"parameters\" in circuit.metadata:\n", + " parameters = circuit.metadata[\"parameters\"]\n", + " else:\n", + " parameters = list(circuit.parameters)\n", + "\n", + " dim = 2 ** n_qubits\n", + "\n", + " if target == \"zero\":\n", + " p_target = np.zeros(dim)\n", + " p_target[0] = 1.0\n", + "\n", + " elif target == \"uniform\":\n", + " p_target = np.ones(dim) / dim\n", + "\n", + " else:\n", + " raise ValueError(\"target must be either 'zero' or 'uniform'.\")\n", + "\n", + " def loss(theta):\n", + " theta = np.asarray(theta, dtype=float)\n", + "\n", + " bound_circuit = circuit.assign_parameters(\n", + " dict(zip(parameters, theta)),\n", + " inplace=False,\n", + " )\n", + "\n", + " probs = Statevector.from_instruction(bound_circuit).probabilities()\n", + "\n", + " value = np.sum((probs - p_target) ** 2)\n", + "\n", + " return float(value)\n", + "\n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "id": "4571c78a", + "metadata": {}, + "source": [ + "# Barren Plateaus Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "80420598", + "metadata": {}, + "outputs": [], + "source": [ + "experiment1 = bp.ExperimentConfig(\n", + " analysis_type=\"layerwise_qubits_padding\",\n", + " N_qubits=[2,4,6,8],\n", + " N_layers=[2,4,8],\n", + " ansatz_name=\"HEA_test\",\n", + " initial_Pauli_string=None, #Pauli('IZ'),\n", + " padding_types=None #[\"I\",\"linear_half\"],\n", + ")\n", + "\n", + "experiment2 = bp.ExperimentConfig(\n", + " analysis_type=\"joint_scaling_padding\",\n", + " N_qubits=[2,4,6,8],\n", + " N_layers=[2,4,8],\n", + " ansatz_name=\"HEA_test\",\n", + " initial_Pauli_string=None, #Pauli('IZ'),\n", + " padding_types=None #[\"log\"],\n", + ")\n", + "\n", + "experiment3 = bp.ExperimentConfig(\n", + " analysis_type=\"layerwise_qubits\",\n", + " N_qubits=[2,4,6,8],\n", + " N_layers=[2,4,8],\n", + " ansatz_name=\"HEA_test\",\n", + " observables_list=None #[Pauli('IZ'),Pauli('IZIZ'),Pauli('IZZIZZ'),Pauli('IZZZZZZZ')]\n", + ")\n", + "\n", + "sampling = bp.SamplingConfig(\n", + " bootstrap_B=500,\n", + " rel_err_target=0.05,\n", + " N_max=20000,\n", + ")\n", + "\n", + "execution = bp.ExecutionConfig(\n", + " verbose=True,\n", + " n_jobs=8\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "f1aa52e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------\n", + "Number of qubits: 2\n", + "Number of layers: 2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 5.58%\n", + "[Adaptive sampling] Adding 444 samples (N: 900 -> 1344)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1344 | relative error = 4.71%\n", + "[Adaptive sampling] Target reached with N_samples = 1344 (relative error target reached)\n", + "var = 0.019981342426901118\n", + "--------------------\n", + "Number of qubits: 4\n", + "Number of layers: 2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 8.06%\n", + "[Adaptive sampling] Adding 1904 samples (N: 900 -> 2804)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 2804 | relative error = 5.04%\n", + "[Adaptive sampling] Adding 612 samples (N: 2804 -> 3416)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 3416 | relative error = 4.45%\n", + "[Adaptive sampling] Target reached with N_samples = 3416 (relative error target reached)\n", + "var = 0.005777166858097084\n", + "--------------------\n", + "Number of qubits: 6\n", + "Number of layers: 2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Adding samples: 4%|▎ | 32/900 [00:11<00:02, 307.25it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 12.23%\n", + "[Adaptive sampling] Adding 5559 samples (N: 900 -> 6459)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 6459 | relative error = 4.12%\n", + "[Adaptive sampling] Target reached with N_samples = 6459 (relative error target reached)\n", + "var = 0.0012681055457609092\n", + "--------------------\n", + "Number of qubits: 8\n", + "Number of layers: 2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 16.13%\n", + "[Adaptive sampling] Adding 10000 samples (N: 900 -> 10900)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 10900 | relative error = 3.80%\n", + "[Adaptive sampling] Target reached with N_samples = 10900 (relative error target reached)\n", + "var = 0.0002502996971651112\n", + "--------------------\n", + "Number of qubits: 2\n", + "Number of layers: 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 6.98%\n", + "[Adaptive sampling] Adding 1206 samples (N: 900 -> 2106)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 2106 | relative error = 4.52%\n", + "[Adaptive sampling] Target reached with N_samples = 2106 (relative error target reached)\n", + "var = 0.012281426710333531\n", + "--------------------\n", + "Number of qubits: 4\n", + "Number of layers: 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 11.20%\n", + "[Adaptive sampling] Adding 4518 samples (N: 900 -> 5418)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 5418 | relative error = 4.99%\n", + "[Adaptive sampling] Target reached with N_samples = 5418 (relative error target reached)\n", + "var = 0.0011747954502963726\n", + "--------------------\n", + "Number of qubits: 6\n", + "Number of layers: 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 8.55%\n", + "[Adaptive sampling] Adding 2256 samples (N: 900 -> 3156)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 3156 | relative error = 6.36%\n", + "[Adaptive sampling] Adding 2975 samples (N: 3156 -> 6131)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 6131 | relative error = 4.68%\n", + "[Adaptive sampling] Target reached with N_samples = 6131 (relative error target reached)\n", + "var = 0.0001030312185773902\n", + "--------------------\n", + "Number of qubits: 8\n", + "Number of layers: 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 9.97%\n", + "[Adaptive sampling] Adding 3398 samples (N: 900 -> 4298)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 4298 | relative error = 4.86%\n", + "[Adaptive sampling] Target reached with N_samples = 4298 (relative error target reached)\n", + "var = 1.0006494773597657e-05\n", + "--------------------\n", + "Number of qubits: 2\n", + "Number of layers: 8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 6.76%\n", + "[Adaptive sampling] Adding 1075 samples (N: 900 -> 1975)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1975 | relative error = 4.49%\n", + "[Adaptive sampling] Target reached with N_samples = 1975 (relative error target reached)\n", + "var = 0.011346918238286716\n", + "--------------------\n", + "Number of qubits: 4\n", + "Number of layers: 8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 6.54%\n", + "[Adaptive sampling] Adding 946 samples (N: 900 -> 1846)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1846 | relative error = 4.63%\n", + "[Adaptive sampling] Target reached with N_samples = 1846 (relative error target reached)\n", + "var = 0.0005911486740096183\n", + "--------------------\n", + "Number of qubits: 6\n", + "Number of layers: 8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 5.88%\n", + "[Adaptive sampling] Adding 593 samples (N: 900 -> 1493)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1493 | relative error = 4.65%\n", + "[Adaptive sampling] Target reached with N_samples = 1493 (relative error target reached)\n", + "var = 1.62798578110565e-05\n", + "--------------------\n", + "Number of qubits: 8\n", + "Number of layers: 8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 7.71%\n", + "[Adaptive sampling] Adding 1666 samples (N: 900 -> 2566)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 2566 | relative error = 5.49%\n", + "[Adaptive sampling] Adding 1153 samples (N: 2566 -> 3719)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 3719 | relative error = 5.64%\n", + "[Adaptive sampling] Adding 1964 samples (N: 3719 -> 5683)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 5683 | relative error = 3.87%\n", + "[Adaptive sampling] Target reached with N_samples = 5683 (relative error target reached)\n", + "var = 4.91280710279413e-07\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result1 = bp.barren_plateaus_analysis(\n", + " experiment=experiment1,\n", + " cost_function_builder=circuit_mse_loss_builder,\n", + " generate_params=generate_params_hea,\n", + " generate_circuits=build_hea_ansatz,\n", + " sampling=sampling,\n", + " execution=execution,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "933bcdf7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------\n", + "Number of qubits: 2\n", + "Number of layers: 2\n", + "Padding type: log\n", + "Pauli string: IZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 5.94%\n", + "[Adaptive sampling] Adding 624 samples (N: 900 -> 1524)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1524 | relative error = 4.46%\n", + "[Adaptive sampling] Target reached with N_samples = 1524 (relative error target reached)\n", + "var = 0.019593901279035743\n", + "--------------------\n", + "Number of qubits: 4\n", + "Number of layers: 4\n", + "Padding type: log\n", + "Pauli string: IZIZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 8.61%\n", + "[Adaptive sampling] Adding 2304 samples (N: 900 -> 3204)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 3204 | relative error = 6.08%\n", + "[Adaptive sampling] Adding 2481 samples (N: 3204 -> 5685)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 5685 | relative error = 3.95%\n", + "[Adaptive sampling] Target reached with N_samples = 5685 (relative error target reached)\n", + "var = 0.0011777822079395216\n", + "--------------------\n", + "Number of qubits: 6\n", + "Number of layers: 8\n", + "Padding type: log\n", + "Pauli string: IIZZIZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages/joblib/externals/loky/process_executor.py:782: UserWarning: A worker stopped while some jobs were given to the executor. This can be caused by a too short worker timeout or by a memory leak.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 6.79%\n", + "[Adaptive sampling] Adding 1094 samples (N: 900 -> 1994)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1994 | relative error = 4.59%\n", + "[Adaptive sampling] Target reached with N_samples = 1994 (relative error target reached)\n", + "var = 1.549042566919089e-05\n", + "--------------------\n", + "Number of qubits: 8\n", + "Number of layers: 8\n", + "Padding type: log\n", + "Pauli string: IIIIZZIZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 6.10%\n", + "[Adaptive sampling] Adding 706 samples (N: 900 -> 1606)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1606 | relative error = 5.36%\n", + "[Adaptive sampling] Adding 606 samples (N: 1606 -> 2212)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 2212 | relative error = 4.57%\n", + "[Adaptive sampling] Target reached with N_samples = 2212 (relative error target reached)\n", + "var = 4.7058411699374697e-07\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result2 = bp.barren_plateaus_analysis(\n", + " experiment=experiment2,\n", + " cost_function_builder=circuit_mse_loss_builder,\n", + " generate_params=generate_params_hea,\n", + " generate_circuits=build_hea_ansatz,\n", + " sampling=sampling,\n", + " execution=execution,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "a151c425", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------\n", + "Number of qubits: 2\n", + "Number of layers: 2\n", + "Pauli string: IZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 5.96%\n", + "[Adaptive sampling] Adding 637 samples (N: 900 -> 1537)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1537 | relative error = 4.16%\n", + "[Adaptive sampling] Target reached with N_samples = 1537 (relative error target reached)\n", + "var = 0.019938798625555313\n", + "--------------------\n", + "Number of qubits: 4\n", + "Number of layers: 2\n", + "Pauli string: IZIZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 9.16%\n", + "[Adaptive sampling] Adding 2724 samples (N: 900 -> 3624)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 3624 | relative error = 4.37%\n", + "[Adaptive sampling] Target reached with N_samples = 3624 (relative error target reached)\n", + "var = 0.005701945447274868\n", + "--------------------\n", + "Number of qubits: 6\n", + "Number of layers: 2\n", + "Pauli string: IZZIZZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 9.26%\n", + "[Adaptive sampling] Adding 2802 samples (N: 900 -> 3702)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 3702 | relative error = 5.57%\n", + "[Adaptive sampling] Adding 1819 samples (N: 3702 -> 5521)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 5521 | relative error = 4.59%\n", + "[Adaptive sampling] Target reached with N_samples = 5521 (relative error target reached)\n", + "var = 0.0013186624135084087\n", + "--------------------\n", + "Number of qubits: 8\n", + "Number of layers: 2\n", + "Pauli string: IZZZZZZZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 13.72%\n", + "[Adaptive sampling] Adding 7230 samples (N: 900 -> 8130)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 8130 | relative error = 4.90%\n", + "[Adaptive sampling] Target reached with N_samples = 8130 (relative error target reached)\n", + "var = 0.00026219347606878387\n", + "--------------------\n", + "Number of qubits: 2\n", + "Number of layers: 4\n", + "Pauli string: IZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 5.85%\n", + "[Adaptive sampling] Adding 576 samples (N: 900 -> 1476)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1476 | relative error = 5.14%\n", + "[Adaptive sampling] Adding 400 samples (N: 1476 -> 1876)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 1876 | relative error = 4.65%\n", + "[Adaptive sampling] Target reached with N_samples = 1876 (relative error target reached)\n", + "var = 0.012329583449296553\n", + "--------------------\n", + "Number of qubits: 4\n", + "Number of layers: 4\n", + "Pauli string: IZIZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 7.25%\n", + "[Adaptive sampling] Adding 1372 samples (N: 900 -> 2272)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 2272 | relative error = 5.58%\n", + "[Adaptive sampling] Adding 1124 samples (N: 2272 -> 3396)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 3396 | relative error = 5.46%\n", + "[Adaptive sampling] Adding 1458 samples (N: 3396 -> 4854)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 4854 | relative error = 4.53%\n", + "[Adaptive sampling] Target reached with N_samples = 4854 (relative error target reached)\n", + "var = 0.0011267756132317176\n", + "--------------------\n", + "Number of qubits: 6\n", + "Number of layers: 4\n", + "Pauli string: IZZIZZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 9.65%\n", + "[Adaptive sampling] Adding 3123 samples (N: 900 -> 4023)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 4023 | relative error = 5.59%\n", + "[Adaptive sampling] Adding 2022 samples (N: 4023 -> 6045)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 6045 | relative error = 4.55%\n", + "[Adaptive sampling] Target reached with N_samples = 6045 (relative error target reached)\n", + "var = 9.9048717053213e-05\n", + "--------------------\n", + "Number of qubits: 8\n", + "Number of layers: 4\n", + "Pauli string: IZZZZZZZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages/joblib/externals/loky/process_executor.py:782: UserWarning: A worker stopped while some jobs were given to the executor. This can be caused by a too short worker timeout or by a memory leak.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 9.61%\n", + "[Adaptive sampling] Adding 3087 samples (N: 900 -> 3987)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 3987 | relative error = 4.97%\n", + "[Adaptive sampling] Target reached with N_samples = 3987 (relative error target reached)\n", + "var = 8.936775092125117e-06\n", + "--------------------\n", + "Number of qubits: 2\n", + "Number of layers: 8\n", + "Pauli string: IZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 7.26%\n", + "[Adaptive sampling] Adding 1376 samples (N: 900 -> 2276)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 2276 | relative error = 4.82%\n", + "[Adaptive sampling] Target reached with N_samples = 2276 (relative error target reached)\n", + "var = 0.011856383504789458\n", + "--------------------\n", + "Number of qubits: 4\n", + "Number of layers: 8\n", + "Pauli string: IZIZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 7.41%\n", + "[Adaptive sampling] Adding 1470 samples (N: 900 -> 2370)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 2370 | relative error = 6.61%\n", + "[Adaptive sampling] Adding 2597 samples (N: 2370 -> 4967)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 4967 | relative error = 4.06%\n", + "[Adaptive sampling] Target reached with N_samples = 4967 (relative error target reached)\n", + "var = 0.0006665355475680662\n", + "--------------------\n", + "Number of qubits: 6\n", + "Number of layers: 8\n", + "Pauli string: IZZIZZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 8.13%\n", + "[Adaptive sampling] Adding 1959 samples (N: 900 -> 2859)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 2859 | relative error = 4.08%\n", + "[Adaptive sampling] Target reached with N_samples = 2859 (relative error target reached)\n", + "var = 1.5499255910080055e-05\n", + "--------------------\n", + "Number of qubits: 8\n", + "Number of layers: 8\n", + "Pauli string: IZZZZZZZ\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 900 | relative error = 8.26%\n", + "[Adaptive sampling] Adding 2048 samples (N: 900 -> 2948)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Adaptive sampling] N = 2948 | relative error = 4.96%\n", + "[Adaptive sampling] Target reached with N_samples = 2948 (relative error target reached)\n", + "var = 5.006067259950864e-07\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKYAAAKyCAYAAADvidZRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVzT9/0H8FcSSLhycIT7EkQxeKCoeAGKba2rrtfqeqy1tla7tlu3buva7rG13db117luXTu3au+7Xa29V3uICmo98QS8uc8ACeGGJN/fH4FoCCAogS/h9Xw8fLR8z883vPlA3vl83h+JIAgCiIiIiIiIiIiIhpl0pBtARERERERERERjExNTREREREREREQ0IpiYIiIiIiIiIiKiEcHEFBERERERERERjQgmpoiIiIiIiIiIaEQwMUVERERERERERCOCiSkiIiIiIiIiIhoRTEwREREREREREdGIYGKKiIiIiIiIiIhGBBNTREQ06jzxxBOQSCQjcu/XX38dEokERUVFI3J/ci9FRUWQSCR4/fXXR7opAyaRSPDEE08M+NgHHnjgku4zGl+by7F9+3ZIJBJs3759pJtC/RhM/BMR0cAwMUVERHbdSZcDBw6MdFOIhlVFRQWeeOIJHD582CXXf/fdd/Hcc8+55Nojbffu3XjiiSdgNBpHuik0CrS0tOCJJ55gAo6IiOw8RroBRERERCOtoqICTz75JGJjY5GcnDzk13/33Xdx/Phx/OIXv3DYHhMTg9bWVnh6eg75PV2ltbUVHh7n/4TcvXs3nnzySdx5553QaDRDdp/R+NpcjvT0dLS2tkIul490U1yqpaUFTz75JABg4cKFI9uYS9Az/omI6PJxxBQRERHRILW0tAzJdSQSCby8vCCTyYbkesPBy8trWN6Yj8RrY7Va0dbWNmz3u5BUKoWXlxekUv55LmbDFf9ERGMJf/MREdGgHTp0CEuXLoVKpYKfnx8WL16MPXv2OBzT2dmJJ598EgkJCfDy8kJgYCAWLFiAb7/91n5MVVUVVq1ahcjISCgUCoSFheHaa6+9pPpNr732GjIzMxEcHAyFQgGdTof//Oc/TsfFxsZi2bJl2LlzJ2bPng0vLy/ExcXhzTffdDo2Ly8PmZmZ8Pb2RmRkJP785z/DarU6HXfgwAEsWbIEQUFB8Pb2xrhx43DXXXc5HGO1WvHPf/4TU6ZMgZeXF7RaLa6++mqHaZODfYZvvvkGycnJ8PLygk6nw+bNm52ONRqN+MUvfoGoqCgoFAqMHz8ezzzzTK/P0ZuvvvoKGRkZUCqVUKlUmDVrFt59912HYz788EOkpKTA29sbQUFB+MlPfoLy8nKHY+688074+fmhvLwc1113Hfz8/KDVavHrX/8aFotl0K8VALz99tv2+wYEBODmm29GaWmpwzELFy7E5MmTkZ+fj0WLFsHHxwcRERH461//aj9m+/btmDVrFgBg1apVkEgkDrWNuq9x8OBBpKenw8fHB4899hgA4NNPP8U111yD8PBwKBQKxMfH409/+pPDMy1cuBBffvkliouL7deOjY0F0HcdpaysLKSlpcHX1xcajQbXXnstCgoKHI7prrV25swZ+2gltVqNVatWXTRx9vzzz0MmkzlMv3v22WchkUjw0EMP2bdZLBYolUr89re/tW+7sMbOE088gd/85jcAgHHjxtmfr+fP8CeffILJkydDoVAgKSkJW7Zs6bd9fb02Qx1H3TWw3nnnHSQlJUGhUNjbVl5ejrvuugshISH2dr/66qsO9+jo6MAf/vAHpKSkQK1Ww9fXF2lpadi2bZvT87z//vtISUmx/yxNmTIF//znP+37e6sxNZD47VZcXIwf/vCH8PX1RXBwMH75y1/i66+/HlDdqsbGRvziF79AbGwsFAoFgoODceWVVyI3NxcA8Pjjj8PT0xN6vd7p3DVr1kCj0dgTev31h0VFRdBqtQCAJ5980h4vF9ZsOnHiBH70ox8hICAAXl5emDlzJj777DOHe3ZPO9+5cyd+/vOfQ6vVQqPRYO3atejo6IDRaMQdd9wBf39/+Pv74+GHH4YgCP2+Bhdre7cL29sdo339u9DevXtx9dVXQ61Ww8fHBxkZGdi1a9dF20RENBYw3U9ERIOSl5eHtLQ0qFQqPPzww/D09MSGDRuwcOFC7NixA6mpqQBsb1iffvpprF69GrNnz4bJZMKBAweQm5uLK6+8EgBw4403Ii8vDz/72c8QGxuLmpoafPvttygpKbG/cR+o//znP0hKSsIPf/hDeHh44PPPP8d9990Hq9WK+++/3+HYM2fO4Ec/+hHuvvturFy5Eq+++iruvPNOpKSkICkpCYAtabZo0SKYzWY88sgj8PX1xcaNG+Ht7e1wrZqaGlx11VXQarV45JFHoNFoUFRU5JQkuvvuu/H6669j6dKlWL16NcxmM3JycrBnzx7MnDlz0M9w+vRp/PjHP8a9996LlStX4rXXXsNNN92ELVu22F/flpYWZGRkoLy8HGvXrkV0dDR2796NRx99FJWVlRetefT666/jrrvuQlJSEh599FFoNBocOnQIW7Zswa233mo/ZtWqVZg1axaefvppVFdX45///Cd27dqFQ4cOOUztslgsWLJkCVJTU/G3v/0N3333HZ599lnEx8fjpz/96aBeq6eeegq///3vsWLFCqxevRp6vR4vvPAC0tPTne5rMBhw9dVX44YbbsCKFSuwadMm/Pa3v8WUKVOwdOlSTJo0CX/84x/xhz/8AWvWrEFaWhoAYN68efZr1NXVYenSpbj55pvxk5/8BCEhIfbn9/Pzw0MPPQQ/Pz9kZWXhD3/4A0wmE9atWwcA+N3vfoeGhgaUlZXhH//4BwDAz8+vz9f9u+++w9KlSxEXF4cnnngCra2teOGFFzB//nzk5uY6/WysWLEC48aNw9NPP43c3Fy8/PLLCA4OxjPPPNPnPdLS0mC1WrFz504sW7YMAJCTkwOpVIqcnBz7cYcOHUJTUxPS09N7vc4NN9yAU6dO4b333sM//vEPBAUFAYA9+QAAO3fuxObNm3HfffdBqVTi+eefx4033oiSkhIEBgb22ca+DGUcAbYk4H//+1888MADCAoKQmxsLKqrqzFnzhx74kqr1eKrr77C3XffDZPJZJ+SaTKZ8PLLL+OWW27BPffcg8bGRrzyyitYsmQJ9u3bZ58W+u233+KWW27B4sWL7d+XgoIC7Nq1Cw8++GC/z3ux+AWA5uZmZGZmorKyEg8++CBCQ0Px7rvv9pog6829996LTZs24YEHHoBOp0NdXR127tyJgoICzJgxA7fffjv++Mc/4oMPPnAoZt/R0YFNmzbhxhtvhJeX10X7Q61Wi//85z/46U9/iuuvvx433HADAGDq1KkAbL9f5s+fj4iICHu/+9///hfXXXcdPvroI1x//fUO7f7Zz36G0NBQPPnkk9izZw82btwIjUaD3bt3Izo6Gn/5y1/wv//9D+vWrcPkyZNxxx139PkaDLQvv5BWq8Vbb73lsK2zsxO//OUvHaZkZmVlYenSpUhJScHjjz8OqVRq/yAiJycHs2fPHtD3iYjIbQlERERdXnvtNQGAsH///j6Pue666wS5XC6cPXvWvq2iokJQKpVCenq6fdu0adOEa665ps/rGAwGAYCwbt26Qbfz8ccfF3r+CmtpaXE6bsmSJUJcXJzDtpiYGAGAkJ2dbd9WU1MjKBQK4Ve/+pV92y9+8QsBgLB3716H49RqtQBAKCwsFARBED7++OOLvmZZWVkCAOHnP/+50z6r1XrJz/DRRx/ZtzU0NAhhYWHC9OnT7dv+9Kc/Cb6+vsKpU6cczn/kkUcEmUwmlJSU9Nlmo9EoKJVKITU1VWhtbe21zR0dHUJwcLAwefJkh2O++OILAYDwhz/8wb5t5cqVAgDhj3/8o8O1pk+fLqSkpNi/HshrVVRUJMhkMuGpp55y2H/s2DHBw8PDYXtGRoYAQHjzzTft29rb24XQ0FDhxhtvtG/bv3+/AEB47bXXnO7bfY0XX3zRaV9v37O1a9cKPj4+Qltbm33bNddcI8TExDgdW1hY6HTf5ORkITg4WKirq7NvO3LkiCCVSoU77rjDvq375+Cuu+5yuOb1118vBAYGOt3rQhaLRVCpVMLDDz8sCILttQ0MDBRuuukmQSaTCY2NjYIgCMLf//53QSqVCgaDwX4uAOHxxx+3f71u3TqHn4kLARDkcrlw5swZh2cBILzwwgv9trG312Yo46i7fVKpVMjLy3M45u677xbCwsKE2tpah+0333yzoFar7d93s9kstLe3OxxjMBiEkJAQh+/Lgw8+KKhUKsFsNvf5vNu2bRMACNu2bbNvG2j8PvvsswIA4ZNPPrFva21tFRITE52u2Ru1Wi3cf//9/R4zd+5cITU11WHb5s2bHa4/kP5Qr9c7xVC3xYsXC1OmTHH42bFarcK8efOEhIQE+7bu31VLlixx+H7OnTtXkEgkwr333mvfZjabhcjISCEjI6Pf5xtI2wXBOf57uu+++wSZTCZkZWXZ25+QkODU1paWFmHcuHHClVde2e/9iIjGAk7lIyKiAbNYLPjmm29w3XXXIS4uzr49LCwMt956K3bu3AmTyQQA0Gg0yMvLw+nTp3u9lre3N+RyObZv3w6DwXDZbbtwJFNDQwNqa2uRkZGBc+fOoaGhweFYnU5nHxUD2D71njhxIs6dO2ff9r///Q9z5sxx+CRbq9Xitttuc7hW98icL774Ap2dnb227aOPPoJEIsHjjz/utO/C6R6DeYbw8HCH0QMqlQp33HEHDh06hKqqKgC2KXZpaWnw9/dHbW2t/d8VV1wBi8WC7OzsXtsL2EZ4NDY24pFHHoGXl1evbT5w4ABqampw3333ORxzzTXXIDExEV9++aXTde+9916Hr9PS0hxe94G8Vps3b4bVasWKFSscnis0NBQJCQlOo0T8/Pzwk5/8xP61XC7H7NmzHe57MQqFAqtWrXLafuH3rLGxEbW1tUhLS0NLSwtOnDgx4Ot3q6ysxOHDh3HnnXciICDAvn3q1Km48sor8b///c/pnN5e07q6OvvPYm+kUinmzZtnj4GCggLU1dXhkUcegSAI+P777wHYRlFNnjz5soqaX3HFFYiPj3d4FpVKNajXv6ehiKNuGRkZ0Ol09q8FQcBHH32E5cuXQxAEhxhbsmQJGhoa7FPcZDKZfWSM1WpFfX09zGYzZs6caT8GsPUTzc3NDlOZB2og8btlyxZERETghz/8oX2bl5cX7rnnngHdQ6PRYO/evaioqOjzmDvuuAN79+7F2bNn7dveeecdREVFISMjw34doP/+sC/19fXIysrCihUr7D9LtbW1qKurw5IlS3D69GmnKcJ33323w/czNTUVgiDg7rvvtm+TyWSYOXPmRePtctre7c0338S///1v/PWvf8WiRYsAAIcPH8bp06dx6623oq6uzv5czc3NWLx4MbKzswc8tZqIyF0xMUVERAOm1+vR0tKCiRMnOu2bNGkSrFarvcbPH//4RxiNRkyYMAFTpkzBb37zGxw9etR+vEKhwDPPPIOvvvoKISEhSE9Px1//+ld7UmWwdu3ahSuuuMJek0er1drrAPVM6kRHRzud7+/v75AgKy4uRkJCgtNxPZ89IyMDN954I5588kkEBQXh2muvxWuvvYb29nb7MWfPnkV4eLhDouFyn2H8+PFOb7AnTJgAAPb6PqdPn8aWLVug1Wod/l1xxRUAbFNX+tL95nPy5Ml9HlNcXAzA+TUBgMTERPv+bt11fi7U83UfyGt1+vRpCIKAhIQEp2crKChweq7IyEin16rnfS8mIiKi19XS8vLycP3110OtVkOlUkGr1dqTCD2/ZwPR32s6adIk+xvaC/WMZ39/fwC46POlpaXh4MGDaG1tRU5ODsLCwjBjxgxMmzbNPp1v586dDkncSzGQn7fBGKo46jZu3DiHr/V6PYxGIzZu3OgUX93JyQtj7I033sDUqVPttfS0Wi2+/PJLh+//fffdhwkTJmDp0qWIjIzEXXfdNaA6W8DA4re4uBjx8fFOx40fP35A9/jrX/+K48ePIyoqCrNnz8YTTzzhlMj58Y9/DIVCgXfeeQeALb6/+OIL3Hbbbfb7DqQ/7MuZM2cgCAJ+//vfO73u3QnGnj/bPWNLrVYDAKKiopy2XyzeLqftgC0Bde+99+KWW25xqNPW/eHMypUrnZ7r5ZdfRnt7+yX1FURE7oQ1poiIyCXS09Nx9uxZfPrpp/jmm2/w8ssv4x//+AdefPFFrF69GgDwi1/8AsuXL8cnn3yCr7/+Gr///e/x9NNPIysrC9OnTx/wvc6ePYvFixcjMTERf//73xEVFQW5XI7//e9/+Mc//uH0aXRfq3wJAyiO25NEIsGmTZuwZ88efP755/j6669x11134dlnn8WePXv6rSV0Oc8wEFarFVdeeSUefvjhXvd3J7KGy1Ctrma1WiGRSPDVV1/1es2er/lQfL971hYDbIXlMzIyoFKp8Mc//hHx8fHw8vJCbm4ufvvb3w7bKIhLfb4FCxags7MT33//PXJycuwJqLS0NOTk5ODEiRPQ6/WXnZgayp+3/q53qXp+b7u/bz/5yU+wcuXKXs/pron09ttv484778R1112H3/zmNwgODoZMJsPTTz/tMLIoODgYhw8fxtdff42vvvoKX331FV577TXccccdeOONN/pt31C/fr1ZsWIF0tLS8PHHH+Obb77BunXr8Mwzz2Dz5s32Olb+/v5YtmwZ3nnnHfzhD3/Apk2b0N7e7jCa63L6w+7X/de//jWWLFnS6zE9E219vTa9bb/Y63U5bTcYDLjxxhsxYcIEvPzyy70+17p16+w1x3oa6O8JIiJ3xcQUERENmFarhY+PD06ePOm078SJE5BKpQ6fVAcEBGDVqlVYtWqVvYDyE088YU9MAUB8fDx+9atf4Ve/+hVOnz6N5ORkPPvss3j77bcH3K7PP/8c7e3t+Oyzzxw+QR9o4d/exMTE9DoNsbdnB4A5c+Zgzpw5eOqpp/Duu+/itttuw/vvv4/Vq1cjPj4eX3/9Nerr6/scwTHYZ+geXXDhCIlTp04BgL04dnx8PJqamuwjpAaje+rV8ePH+xx1ERMTA8D2mmRmZjrsO3nypH3/YO97sdcqPj4egiBg3LhxQ5Zc6znSZCC2b9+Ouro6bN682aE4eGFh4SVf/8LXtKcTJ04gKCgIvr6+g25rb2bPng25XI6cnBzk5OTYV9dLT0/HSy+9hK1bt9q/7s+lvHauNpA46otWq4VSqYTFYrnoz86mTZsQFxeHzZs3O7wOvU0hlMvlWL58OZYvXw6r1Yr77rsPGzZswO9///sBj2zqS0xMDPLz8536hDNnzgz4GmFhYbjvvvtw3333oaamBjNmzMBTTz1lT0wBtul81157Lfbv34933nkH06dPty8YcaH++sO+4qV7erinp+cl9VlDpb+298ZqteK2226D0WjEd999Bx8fH4f93X2pSqUa0eciIhIzTuUjIqIBk8lkuOqqq/Dpp586LAdfXV2Nd999FwsWLIBKpQJgW8XsQn5+fhg/frx9WkRLS4t9efFu8fHxUCqVA546cWG7AMdPxBsaGvDaa68N6joX+sEPfoA9e/Zg37599m16vd4+jaWbwWBw+iS++1Px7ue48cYbIQgCnnzySaf7dJ872GeoqKjAxx9/bP/aZDLhzTffRHJyMkJDQwHYRkF8//33+Prrr53ONxqNMJvNvT88gKuuugpKpRJPP/200/epu40zZ85EcHAwXnzxRYfv2VdffYWCggJcc801fV6/LwN5rW644QbIZDI8+eSTTq+9IAhOsTcQ3ckeo9E44HN6+551dHTg3//+d6/XH8h0nbCwMCQnJ+ONN95waMvx48fxzTff4Ac/+MGA23cxXl5emDVrFt577z2UlJQ4jJhqbW3F888/j/j4eISFhfV7nUt57VxtIHHUF5lMhhtvvBEfffQRjh8/7rRfr9c7HNvzmnv37rXX6OrWMyalUql91NVg+7veLFmyBOXl5fjss8/s29ra2vDSSy9d9FyLxeIUm8HBwQgPD3dq29KlSxEUFIRnnnkGO3bscBgtBQysP+xO3PSMl+DgYCxcuBAbNmxAZWWlUzsvfN1dYSBt782TTz6Jr7/+Gu+9957TtFAASElJQXx8PP72t7+hqanJab+rn4uIaDTgiCkiInLy6quv9lr/5MEHH8Sf//xnfPvtt1iwYAHuu+8+eHh4YMOGDWhvb8df//pX+7E6nQ4LFy5ESkoKAgICcODAAfty5IBtdM/ixYuxYsUK6HQ6eHh44OOPP0Z1dTVuvvnmQbX3qquuso9GWLt2LZqamvDSSy8hODi41zc4A/Hwww/jrbfewtVXX40HH3wQvr6+2LhxI2JiYhxqZb3xxhv497//jeuvvx7x8fFobGzESy+9BJVKZU8iLFq0CLfffjuef/55nD59GldffTWsVitycnKwaNEiPPDAA4N+hgkTJuDuu+/G/v37ERISgldffRXV1dUOiazf/OY3+Oyzz7Bs2TLceeedSElJQXNzM44dO4ZNmzahqKgIQUFBvT6/SqXCP/7xD6xevRqzZs3CrbfeCn9/fxw5cgQtLS1444034OnpiWeeeQarVq1CRkYGbrnlFlRXV+Of//wnYmNj8ctf/nLQr/tAXqv4+Hj8+c9/xqOPPoqioiJcd911UCqVKCwsxMcff4w1a9bg17/+9aDuGx8fD41GgxdffBFKpRK+vr5ITU3t9Y1mt3nz5sHf3x8rV67Ez3/+c0gkErz11lu9Jj5SUlLwwQcf4KGHHsKsWbPg5+eH5cuX93rddevWYenSpZg7dy7uvvtutLa24oUXXoBarcYTTzwxqOe6mLS0NPzf//0f1Go1pkyZAsCWIJg4cSJOnjyJO++886LXSElJAQD87ne/w8033wxPT08sX758yEZ2XYqBxFF//u///g/btm1Damoq7rnnHuh0OtTX1yM3Nxffffcd6uvrAQDLli3D5s2bcf311+Oaa65BYWEhXnzxReh0OockxOrVq1FfX4/MzExERkaiuLgYL7zwApKTkzFp0qTLft61a9fiX//6F2655RY8+OCDCAsLwzvvvGNflKC/UW2NjY2IjIzEj370I0ybNg1+fn747rvvsH//fjz77LMOx3p6euLmm2/Gv/71L8hkMtxyyy0O+wfSH3p7e0On0+GDDz7AhAkTEBAQgMmTJ2Py5MlYv349FixYgClTpuCee+5BXFwcqqur8f3336OsrAxHjhy57NeqLwNpe0/Hjh3Dn/70J6Snp6OmpsZppO9PfvITSKVSvPzyy1i6dCmSkpKwatUqREREoLy8HNu2bYNKpcLnn3/usuciIhoVXL/wHxERjRbdS3D39a+0tFQQBEHIzc0VlixZIvj5+Qk+Pj7CokWLhN27dztc689//rMwe/ZsQaPRCN7e3kJiYqLw1FNPCR0dHYIgCEJtba1w//33C4mJiYKvr6+gVquF1NRU4b///e9F2/n4448LPX+FffbZZ8LUqVMFLy8vITY2VnjmmWeEV1991WkZ+5iYGOGaa65xumZGRobTcuJHjx4VMjIyBC8vLyEiIkL405/+JLzyyisO18zNzRVuueUWITo6WlAoFEJwcLCwbNky4cCBAw7XMpvNwrp164TExERBLpcLWq1WWLp0qXDw4MFLfoavv/5amDp1qqBQKITExEThww8/dHquxsZG4dFHHxXGjx8vyOVyISgoSJg3b57wt7/9zf696M9nn30mzJs3T/D29hZUKpUwe/Zs4b333nM45oMPPhCmT58uKBQKISAgQLjtttuEsrIyh2NWrlwp+Pr6Ol2/t+/lQF4rQRCEjz76SFiwYIHg6+sr+Pr6ComJicL9998vnDx50n5MRkaGkJSU5HTflStXCjExMQ7bPv30U0Gn0wkeHh4CAOG1117r9xqCIAi7du0S5syZI3h7ewvh4eHCww8/LHz99dcCAGHbtm3245qamoRbb71V0Gg0AgD7vQsLCx3u1e27774T5s+fb3/dly9fLuTn5/f62un1eoft3T/HF8ZMX7788ksBgLB06VKH7atXrxYACK+88orTOQCExx9/3GHbn/70JyEiIkKQSqUO9wYg3H///U7XiImJEVauXNlv23p7bYY6jvpqnyAIQnV1tXD//fcLUVFRgqenpxAaGiosXrxY2Lhxo/0Yq9Uq/OUvfxFiYmIEhUIhTJ8+Xfjiiy+c4mvTpk3CVVddJQQHBwtyuVyIjo4W1q5dK1RWVtqP2bZtm1PcDCZ+z507J1xzzTWCt7e3oNVqhV/96lfCRx99JAAQ9uzZ0+szCoIgtLe3C7/5zW+EadOmCUqlUvD19RWmTZsm/Pvf/+71+H379gkAhKuuuspp30D7w927dwspKSmCXC53iqezZ88Kd9xxhxAaGip4enoKERERwrJly4RNmzbZj+mO8f379ztct6+fib7i5lLafmF7u79nff270KFDh4QbbrhBCAwMFBQKhRATEyOsWLFC2Lp1a7/tIiIaCySCMISVE4mIiMjlYmNjMXnyZHzxxRcj3RQiErHnnnsOv/zlL1FWVoaIiIghueaRI0eQnJyMN998E7fffvuQXJOIiMY21pgiIiIiIhrlWltbHb5ua2vDhg0bkJCQMGRJKQB46aWX4OfnhxtuuGHIrklERGMba0wREREREY1yN9xwA6Kjo5GcnIyGhga8/fbbOHHihNOCDZfq888/R35+PjZu3IgHHnhgRGuIERGRe2FiioiIiIholFuyZAlefvllvPPOO7BYLNDpdHj//ffx4x//eEiu/7Of/QzV1dX4wQ9+0Otqh0RERJeKNaaIiIiIiIiIiGhEsMYUERERERERERGNCCamiIiIiIiIiIhoRLDG1CBYrVZUVFRAqVRCIpGMdHOIiIiIiIiIiERHEAQ0NjYiPDwcUmn/Y6KYmBqEiooKREVFjXQziIiIiIiIiIhEr7S0FJGRkf0ew8TUICiVSgC2F1alUo1way6d1WpFaWkpoqKiLpq5JBpujE8SK8YmiRVjk8SKsUlixvgksXKX2DSZTIiKirLnUfrDxNQgdE/fU6lUoz4xpVQqoVKpRnWgk3tifJJYMTZJrBibJFaMTRIzxieJlbvF5kDKII3+pyQiIiIiIiIiolGJiSkiIiIiIiIiIhoRTEwREREREREREdGIYGKKiIiIiIiIiIhGBIufD8D69euxfv16WCyWkW4KERERERERkehZLBZ0dnaOdDNGHavVCovFgra2NtEWP/f09IRMJhuy6zExNQD3338/7r//fphMJqjV6pFuDhEREREREZEoCYKAqqoqGI3GkW7KqCQIAiwWC4qKiga0ot1I0Wg0CA0NHZI2MjFFREREREREREOiOykVHBwMHx8fUSdXxEgQBHR2dsLT01OUr50gCGhpaUFNTQ0AICws7LKvycQUEREREREREV02i8ViT0oFBgaOdHNGJUEQIJVKIZfLRZmYAgBvb28AQE1NDYKDgy97Wp84JywSERERERER0ajSXVPKx8dnhFtCrtb9PR6KOmJMTBERERERERHRkBHrSB8aOkP5PWZiioiIiIiIiIiIRgQTU0REREREREREw6h71b3Dhw+PdFNGHBNTRERERERERDSm3HnnnZBIJJBIJPD09ERISAiuvPJKvPrqq7BarUN+r+uuu25Ir+lOmJgiIiIiIiIiojHn6quvRmVlJYqKivDVV19h0aJFePDBB7Fs2TKYzeaRbt6YwcQUEREREREREY05CoUCoaGhiIiIwIwZM/DYY4/h008/xVdffYXXX38dAGA0GrF69WpotVqoVCpkZmbiyJEj9ms88cQTSE5OxoYNGxAVFQUfHx+sWLECDQ0N9v1vvPEGPv30U/sIre3bt9vPP3fuHBYtWgQfHx9MmzYN33///XC+BKLAxBQREREREREREYDMzExMmzYNmzdvBgDcdNNNqKmpwVdffYWDBw9ixowZWLx4Merr6+3nnDlzBv/973/x+eefY8uWLTh06BDuu+8+AMCvf/1rrFixwj46q7KyEvPmzbOf+7vf/Q6//vWvcfjwYUyYMAG33nrrmButxcQUEREREREREVGXxMREFBUVYefOndi3bx8+/PBDzJw5EwkJCfjb3/4GjUaDTZs22Y9va2vDm2++ieTkZKSnp+OFF17A+++/j6qqKvj5+cHb29s+Ois0NBRyudx+7q9//Wtcc801mDBhAp588kkUFxfj7NmzI/HYI8ZjpBtARERERERERCQWgiBAIpHgyJEjaGpqQmBgoMP+1tZWh+RRdHQ0IiIi7F/PnTsXVqsVJ0+eRGhoaL/3mjp1qv3/w8LCAAA1NTVD8RijBhNTRERERERERERdCgoKMG7cODQ1NSEsLMyhJlQ3jUYzJPfy9PS0/79EIgGAIV8VUOyYmCIiIiIiIiIiApCVlYVjx47hl7/8JSIjI1FVVQUPDw/Exsb2eU5JSQkqKioQHh4OANizZw+kUikmTpwIAJDL5bBYLMPR/FGJiSkiIiIiIiIiGnPa29tRVVUFi8WC6upqbNmyBU8//TSWLVuGO+64A1KpFHPnzsV1112Hv/71r5gwYQIqKirw5Zdf4vrrr8fMmTMBAF5eXli5ciX+9re/wWQy4ec//zlWrFhhn8YXGxuLr7/+GidPnkRgYCDUavVIPrboMDE1xhTWNuOD/SU4VV6LCRGt+PGsaIwL8h3pZhERERERERENqy1btiAsLAweHh7w9/fHtGnT8Pzzz2PlypWQSm1rxf3vf//D7373O6xatQp6vR6hoaFIT09HSEiI/Trjx4/HDTfcgB/84Aeor6/HsmXL8O9//9u+/5577sH27dsxc+ZMNDU1Ydu2bf2OwBprmJgaQ/57oBSPfHQUEkggQMCOc43YmH0Oz9w4FTfNjBrp5hERERERERENi9dffx2vv/76RY9TKpV4/vnn8fzzz/d73E9/+lP89Kc/7XWfVqvFN99847RdEASHrzUaDaxWKzo6Oi7aLnciHekG0PAorG3GIx8dhVUALIJg+6/V9t+HPzqK4+UNI91EIiIiIiIiIhpjOGJqANavX4/169eP6mJl/z1Qaqvw3yMjC9g2LXthJ6IDfDA5QoWkcDV04SokhasQrPQagdYSERERERER0VjAxNQA3H///bj//vthMplGbZGyMkOr0zDBnkrqW1BS34L/HauybwtWKpAUbktWJYWrMDlCjUh/b/sylkRERERERERj1RNPPIEnnnhipJsxqjExNUbYk0m9JKckALRKBUxtnWjrtDrsq2lsR81JPbad1Nu3qbw8ukZUqe0jrOKCfOEh48xQIiIiIiIiIho4JqbGiBUzo7Bhx9le90kkwH/XzkWkvzcKa5uRV2HC8fIG5FWYkFfRAFOb2eF4U5sZe87VY8+5evs2hYcUk8JUDqOrJoYq4eUpc+lzEREREREREdHoxcTUGDEuyBfP3DgVv/3oKCQSCQRBsK/O98yNUxEb5AsASAhRIiFEieumRwCwrRJQZmhFXkV3osqWrKo2tTtcv91sxeFSIw6XGu3bZFIJEoL9zo+uCldBF66C0stz2J6biIiIiIiIiMSLiakx5KaZUZgVG4D395fgVHktJkQE4eZZ0fakVG8kEgmiAnwQFeCDqyeH2bfrG9vtyar8ChOOVzSguK7F4VyLVcCJqkacqGrE5txy+/aYQB+HkVVJ4WpolYqhf2AiIiIiIiIiEjUmpsaY2CBfPLxkIkpKvBEdHQ2p9NLqQmmVCiycGIyFE4Pt20xtnSioMOF416iq/AoTTtc0wWJ1rGtVXNeC4jrnIuuTI7oTVbZkFYusExEREREREbk3JqZoyKi8PJEaF4jUuED7trZOC05WNdqnAOZVmFBQaUK72bnIetaJGmSdqLngeh7nR1VFqDA5XI04rR9kUiariIiIiIiIiNwBE1PkUl6eMkyL0mBalMa+zWyx4lxtsy1RVW6bBphXYUJjL0XWvz9Xh+/P1V1wPSkSQ1X21QCTwlWYEMIi60RERERERESjERNTNOw8ZFJMCFFiQogS10+3bbuwyPrx8vOjq2oaHYust3U6F1n3kEowPtjvgppVLLJORERERERENBowMUWi0FeR9ZrGNnuB9e6kVUm9Y5F18wVF1j/KPb89NtAHSeFq6MJV9vpVQX4ssk5ERERERETi9uijj+K5555DU1MTPDxcl7r58MMP8fbbb+PgwYMwGAxISEjAz3/+c6xatWrYaj4zMUWiFqz0QvBELyzqUWTdlqgyIa/cNrLqjN65yHpRXQuK6lrw5bFK+7YQlQKTu0ZW6br+yyLrREREREREJCbHjh3DpEmTXJqUAoC///3viI2NxbPPPgutVotvv/0W99xzD0pLS/H444+79N7dmJiiUUfl5Yk5cYGY00uR9e56VXkVJpzopch6takd1aYabL2gyLra29NhNcDJESqMC2KRdSIiIiIiIhoZR48eRWZmpsvv8/nnnyMoKMj+dWZmJurq6vD3v/8dv//97yGVSl3eBiamyC30VWT9rL7ZXq/qeHkD8iudi6w3tHZi99k67D57vsi6t6cMiWFKJIWrukZYqTEh1A8KDxZZJyIiIiIiItcxGAwoKyvDlClTXH6vC5NS3aZPn46XXnoJzc3NUCqVLm8DE1PktjxkUkwMVWJiqBI3zLBtEwQBpfVdRdYvGF2l71FkvbXTgkMlRhwqMZ6/XleR9e56Vd31q/wU/DEiIiIiIiKioXHs2DEAwNSpUy96rCAIsFgsFz1uMFMCd+7ciYiIiGFJSgFMTNEYI5FIEB3og+hAHyydckGRdVNbV5LqfLKqvyLrmw6e3z4uyBe6C6YCssg6ERERERHRectf2Ok0GGCs0CoV+PxnCwZ1zvHjxwEMLDH1xhtvYNWqVRc9rrCwELGxsRc9bufOnXj//ffx7LPPXvTYocLEFBGAYJUXglVeWJR4vsh6Q2unfTXA7qTVmZom9KixjsLaZhTWNuPLo+eLrIeqvGyJKvvoKhUiNCyyTkREREREY4++sR1VpraRbsaocezYMQQFBSE0NPSixy5fvhz79++/6HHh4eEXPaasrAw//vGPsWjRIvz85z8fUFuHAhNTRH1Qe3tibnwg5sY7Flk/UdWI412rAeZXNKCgqhEdPYqsV5naUGVqcyiyrvHxdBhVlRTOIutEREREROT+tMqxO6PkUp79+PHjAxotBQABAQFQq9UXPe5iU/mMRiOWLl2KwMBAfPTRR8NS9LwbE1NEg+DlKUNylAbJFxRZ77RYcVbfhLxyk31kVX6FCY3tjkXWjS2d2HWmDrvOOBZZnxSmtCerJkeokRDCIutEREREROQ+BjuVbSyzWq3Iz8/H6tWrB3T8UEzla21txbJly9DQ0IDvv/9+QImuocTEFNFl8pRJkRiqQmKoCjem2LZZrQJKDS32RNXxrqRVbZNzkfXcEiNyexRZTwjpXhHQNh1wUhiLrBMREREREbm7s2fPorm5ecAr8l3uVD6z2YwVK1agoKAAOTk5iIiIGFR7hwLf6RK5gFQqQUygL2ICffGDXoqsd08FzKtsQGl9q8O5ZquAgkoTCipN9iLrEgkwLrC7yPr5qYCBLLJORERERETkNo4ePQoAqKmpwSeffOKwLyEhAUlJSQ7bAgMDERgYiEt133334YsvvsCzzz4Lk8mEPXv22PdNnz4dCoXr33MyMTXGGCrLcSzrG1QWF6EkJhZTMq+Cf9jwZ0THql6LrLd0Iq+yoavQui1pdVbvWGRdEIBztc04V9uMLy4osh6mthVZ14Wr7aOrwtVeLLJOREREREQ0CnUnph577DGnfS+88IJTYupyffPNNwCAX/3qV077BrqS3+ViYmoMOb7tW3yz4XlAIoEgCCg/dggHPt+Mq+59EJMXXjHSzRuz1D6emBcfhHnxQfZtrR0WnKg6X7Mqr8KEE70UWa9saENlQxu+K3Ausj45XG0fYTUuyJdF1omIiIiIiETuySefxO9+9zvI5fJhGXBQVFTk8ntcDBNTY4ShshzfbHge9aoAHJs4Aw1Kf6gbDZhyMhffvPhPRCTq4B968eUjaXh4y2WYHu2P6dH+9m3dRdZt9apsyaqCARZZ95HLMClMZZ8CmBTOIutEREREREQ08piYGiOOb/sWxybOwJb0awEIACQABOxLTsPV2Z/geNY3SLv1zpFtJPXrwiLrP0qJBGArsl5S3+IwsiqvogG1TR0O57Z0WHCw2ICDxYYLridBQrDSvhpgUrgKk8JU8GWRdSIiIiIiIhomfAc6RpxqaMKW9GshSKWOOwQBW9KvQ8KWNxCWkIhx01Mg8/AcmUbSoEmlEsQG+SI2yBfXTLUVWRcEATWN7ResBmhLWJUZHIusd1oE5FeakF9pwocHywCcL7KeFKF2GF0V4Csf9mcjIiIiIiIi98fE1BixPzIBtpFSPUgkgGDF3tA4KP72Z3grVUicnwFdeiZC4saziPYoJJFIEKLyQojKC5mJIfbt3UXW8y5IVvVXZP3zIxX27eFqL+guWA1wcoQaYSyyTkRERERERJeJiakxoiMsGmho7XWfIJGiOCIOnTIPoNGEQ1s+x6EtnyMgIgq69Ezo0hZBGRjU67k0evRVZL2gq8h6ftcIq5NVjeiwOBZZr2hoQ0VDG74rqLZv8/fxRFJ3sqprhNW4QF9IWWSdiIiIiIiIBoiJqTEi3l8NSWNbb2OmAIkEVSFReHnVY5h2bA+mHt0Nv9Ym1JeXYud7b2Dn+28ievI0JKVnYvzsuZB7eQ9388lFvOUyzIj2x4weRdbP1DQhr8KE4+UNyK+wTfdr6lFk3dDSiZ1narHzTK19m49cBl3Y+SmAunAVJoQoIffoMYWUiIiIiIiICExMjRm3hAVifUlNv8c0ecixa3o69iWnYXp1ISZlf4ng+mpAEFBy7DBKjh2G58teSEidB116JqKSpkAq5apu7sZTJsWkMFsh9J5F1o/bC6ybkFfegLpm5yLrB4oNONCjyPqEEKU9WTU5wlbAnUXWiYiIiIiIaEy9MywtLcXtt9+OmpoaeHh44Pe//z1uuummkW7WsIjzUeDviVF46ERp13p8sP/3FzEhKGxtx2d6IywC0CmRYF9oHPat+BmmdDYj+cA2hBzZCwkEdLa3IT87C/nZWfALDIJuwULo0hcjMDJqZB+QXOrCIuvLpoYDsBVZrza12+tVHS+3/bfc6FxkvTuZBVxQZD3I15ao6kpYJYWr4M8i60RERERERGOKRBCEXmd3uaPKykpUV1cjOTkZVVVVSElJwalTp+Dr6zug800mE9RqNRoaGqBSqVzcWtcobGnHOxW1OFlvxMQADW4LD8I4HwUAoLytA6+W1+Ltijo0mC0O58V4SLCw4jRCtn4CocHodN2QuAQkZWRi4rx0+KjUw/EoJFLGlg7kV5gcRled61FkvS/hai8khasQ4Stg3qQoTI7QsMg6iYbVakVJSQmio6Mh7bnCKdEIYmySWDE2ScwYn67R1taGwsJCjBs3Dl5eXiPdnFFJEAR0dHRALpeL+n3Qxb7Xg8mfjKnEVE/Tpk3DF198gaiogY32cYfEFHDxTrjZbMEHVfV4qUyPwlbHqVpqDymWow1JB7bDsG8nBKtjkWypTIZx02chKT0T42bMgoenp0ufhUaHlg4zCiobkX9Bsqq3Iuu9CfCVIylcBV24CpO7RlbFssg6jQD+AUtixdgksWJskpgxPl2DianLNxYTU6KaypednY1169bh4MGDqKysxMcff4zrrrvO4Zj169dj3bp1qKqqwrRp0/DCCy9g9uzZg77XwYMHYbFYBpyUGkt8PWS4K1KLOyOC8G2dCRtK9dhtbAIANJiteBtyeEy/Ctcsuh6ZlWfQsWMLagrPAgCsFgvOHtiDswf2wMvXDxPnpSMpYzFCx08Q9Q8VuZaP3AMpMf5IiTlfZL3D3F1kvTtZZSu03tzhOFqvvrkDOadrkXP6fJF1X7kMk8JUmBxhK7CeFK5CQjCLrBMRERERkXt49NFH8dxzz6GpqQkeHsOTumlqakJiYiLKy8uxf/9+zJw5c1juK6rEVHNzM6ZNm4a77roLN9xwg9P+Dz74AA899BBefPFFpKam4rnnnsOSJUtw8uRJBAcHAwCSk5NhNpudzv3mm28QHm6rjVNfX4877rgDL730kmsfaJSTSiRYEqTGkiA1jjW2YGOZHp9UG9EpCDALwKeGZnzqFYY5Kx7ALd4CQnJ34WTONjQZ6gEAbc1NOPLt/3Dk2//BPywCuvRM6NIWQaUNHuEnIzGQe0ih6xoJ1V3pzWoVUFjbhB1Hz6G6Q478ShPyK0xORdabeymyLpdJMSHUD0lhaiRF2JJVk8JU8JGLqpsjIiIiIiK6qGPHjmHSpEnDlpQCgD/96U+95lNcTbRT+SQSidOIqdTUVMyaNQv/+te/ANiGX0ZFReFnP/sZHnnkkQFdt729HVdeeSXuuece3H777Rc9tr293f61yWRCVFQUDAaDW0/l609VeyfeqKjDmxV1MPSoQxXrJcdd4QGYX1+OopwsnNn/PcwdHU7XiNRNgS5tERJS50Hu7XNZz0Lup2d8CoKAKlMb8rumAOZXNuJ4RQMqjG0XvZZEAsQF+UIXpupaFdD2T+PDIus0eBzyT2LF2CSxYmySmDE+XaOtrQ1FRUWcyneZOjo6MH78eGRmZuL1118flnueOHECs2bNwt/+9jf89Kc/xb59+/odMdU9lS82NrbPqXz+/v6jbypffzo6OnDw4EE8+uij9m1SqRRXXHEFvv/++wFdQxAE3HnnncjMzLxoUgoAnn76aTz55JNO20tLS6FUKgfeeJERBAEGgwESieSSptfdIgOuj/DDlqYOvGdqR3GnrU5QUVsH/nCuCn5SGa5dsAzXL14Gc8ERlOTug/7sKfv5ZfnHUJZ/DFtf/Q/CJycjZsZsBI+fCAl/IRD6js8EXyAhQYHrEhQAgtDQZsaZ2jactv9rRamxA4LDtYCz+mac1Tfj86OV9u0hfp5ICPLq+ueN8UFe0Pp6cLop9ety+04iV2FsklgxNknMGJ+uYbFYYLFY0NnZyYTfZdDr9SgrK8OkSZPQ0ctgD1d44IEHcM899yAuLg4A0NnZ2e+9Ozs7YbFYUFlZCZlM5rS/sbFxwPceNYmp2tpaWCwWhISEOGwPCQnBiRMnBnSNXbt24YMPPsDUqVPxySefAADeeustTJkypdfjH330UTz00EP2r7tHTEVFRY36EVOCICAqKuqyOosJAB4QBGyvb8TG8lpkG2x1qJqswDsN7XgfwDWJqVhzxTKMb2/CiV3bkZ+9DYbKcgCApbMTpYf2o/TQfvj6ByBxfgZ06ZkIiooZgqek0Wow8TllguPXLR1mnKhqxPFyk30a4MnqRnRaHAeGVjd1orqpEzuLzneWgb5y29TCC0ZXxQT4sMg62Q1V30k01BibJFaMTRIzxqdrdI+Y8vT0hFzOWQqXqqCgAAAwffr0i76OgiDAYrH0ewyAfqcEbtq0CXl5edi8eTNyc3MB4KLfQ6vVCplMhrCwsD5HTA3UqElMDYUFCxbAar34KmDdFAoFFAqF03apVDrqO6/uZ7jc55ACuEKrwRVaDQqaWrGxTI/N1Qa0WwVYAHymb8Bn+gbMVPlg7YKrcfu1K1B77jTysrNwcnc22ppsiYFmQz0OfvExDn7xMYLHxSMpPROJ8zPgo9Zc9rPS6HOp8ennJcfM2EDMjA20b+swW3G6ptE2DbDChOPlDSiodC6yXtdLkXU/hQcmhSmR1LUaYFK4GgkhfvCUje6ff7p0Q9V3Eg01xiaJFWOTxIzxOfSkUql9FBpHol0aQRBw/PhxAMC0adMu+jq+8cYbWLVq1UWv2z3trqeWlhb86le/wl/+8heo1Wr7/S72Peze39fP0GB+rkZNYiooKAgymQzV1dUO26urqxEaGjpCraILTfLzxj8So/FYXBjeKK/Da+W1qOu0FU47YGrBgbwiRHp5YnWEFreuXIOFd6xG4aH9yM/OwrncA7BabMfWFJ5FTeFZbH/rFYxLToEufTHiU2bDgxl3ugRyD2lXYklt32a1Ciiqa0ZehQnHu1YDzKswob5HkfWmdjP2Fxmwv8i5yPrkrmSVLlyNSWFKFlknIiIiIurD24/+As1Gw8UPdEO+Gn/85OnnBnXOsWPHEBQUNKBcx/Lly7F///6LHte9GFxPf/7znxESEjKg5JarjJp3UnK5HCkpKdi6dau9ILrVasXWrVvxwAMPjGzjyIFW7olfjwvFA9HB2FxjwMZSPU402wpVl7V14omzFfhbURVuDQvE3VNScO3seWgxNeDk9znI37EVVWdPAwAEqxXncvfjXO5+KHx9MXFuGnTpixE+IZHZd7osUqkEcVo/xGn9sHyarYPuLrJ+vNyEvIoG+wircmOrw7kdFiuOl5twvPz80FSpBIjT+tmnAE4OV0PHIutERERERACAZqMBTfV1I92MUeP48eOYOnXqgI4NCAiAWq2+6HG9TeUrLi7Gs88+i48//hgNDQ0AgKamJvt/m5qa4OfnN4iWXxpRJaaamppw5swZ+9eFhYU4fPgwAgICEB0djYceeggrV67EzJkzMXv2bDz33HNobm52eWZv/fr1WL9+/YDmbdJ5XjIpbg0LxC2hAcgxNOHF0hpk1dum7jVZrNhYpsfLZXos1aqxNlKLWVddg+lLlqGurBT5OVnIz9mGpjrbtKr25mYc/W4Ljn63BZqQMOjSM6FLXwR1MEfL0dCQSCQIU3sjTO2NK3Xna9kZmjuQV2FLVh3v+m9hbTMuXM/UKgBnappwpqYJnx6usG+P0HjbElUR56cChqgUTKwSERER0Zjiq/Ef6SaMmME+u9VqRX5+PlavXj2g4y9nKl9hYSE6OjpwzTXXOB2/aNEipKamYs+ePQNqx+WQCIIgXPyw4bF9+3YsWrTIafvKlSvtSyT+61//wrp161BVVYXk5GQ8//zzSE1NHZb2mUwmqNXqAS13KGYjuTTqqeY2vFymx3+r6tFmdQy9ZKUP1kZpsUyrgadUAsFqRWn+MeRnZ+HUnl3obG9zul5EYhJ06ZmYOHcBFD6+w/UY5EKjYene5nYzTlSZHEZXneqlyHpvAn3lSLInqmzJKhZZHx1GQ2zS2MTYJLFibJKYMT5do62tDYWFhRg3blyvBbHp4k6dOoWJEyfi5Zdfxt13333R4+vq6lBYWHjR46ZOnepUzNxoNOLw4cMO2w4fPoxf/vKXePHFFzFr1izMmDGj1+td7Hs9mPyJqBJTYsfE1NCp6zDjrYpavFZei+oOs8O+cIUnVkUE4fbwQGg8bYP6OtvacHrfbuRlZ6Hk+BGgR9h6eMoRP2sOktIzETN1OqS9LFdJo4MY4vNSdJitOFXd2FWvqmsqYKUJLR0XH2npp/CALkwFXfdUwAg1xgezyLrYjNbYJPfH2CSxYmySmDE+XYOJqcu3adMm3HTTTfjLX/6CSZMmOexLSEhAUlKSS+/fPWBo//79mDlzZp/HDWViSlRT+WjsCJR74BexobgvOhif1hixoVSP4022Wj4V7Z146lwl/l5UjZvDAnBPpBZxPl5d0/cy0VhXi4Kd25G3Yyvqy0sBAObODpzcnY2Tu7Pho9Zg0oKF0KVnIjg2biQfk8YQuYcUkyPUmByhBhAFALBcUGQ9r6IBeV0jrAwtnQ7nNrWbsa+oHvuK6h2uNzFEickRtgLrSeEqTApVwVvOpCsRERERkbs6evQoAOCxxx5z2vfCCy+4PDE1EjhiahA4Ysp1BEHAbmMTNpbp8U2tCRcGpQTAVUEqrInUYp7Gz16fRxAE1BSeRd6OrTixawdaG01O19XGjIMuPROTFiwc0/OaRxMxxudQEgQBlQ1tOF7e0JWwMiG/ogEVDc5TVXuSSoB4e5H183Wr1D6ew9BycvfYpNGLsUlixdgkMWN8ugZHTF0+QRDQ0dEBuVwu6tq0HDFFbkcikWC+vxLz/ZU419KOl8r0eL+yHq1WKwQAX9ea8HWtCZP9vLE2SotrgzWQS6UIiRuPkLjxyLj9LhQezkV+9lacO7gPFrNteqC+uBA73noF2W+/hthp06FLz0T8rDnwlCtG9oFpzJJIJAjXeCNc442rks4X769v7rBPAcyrMCGvvAGFdc5F1k/XNOF0TRM+uaDIeqS/tz1JNTnC9t9gJYusExERERGR+DExRaIT56PA0xMi8dtxoXi7og6vlNeist029el4Uyt+VlCCP5+t6KpDFYRAuQdkHp4YPzMV42emorWpEae+z0Hejq2oPH0SACAIVhQePojCwwch9/bBxLkLoEvPRMREHST8hIREIMBXjrQELdIStPZtze1mFFTaElXdI6xO1zgXWS8ztKLM0Iqv86rt24L85NCFqzH5gtFV0SyyTkREREREIsPE1ACsX78e69evh8Vy8SLGNHQ0nh54ICYEa6OC8YXeiBdLa3Ck0VaHqrrDjP8rrMJzxdVYEWqrQ5Xgaxs+6O2nxLQrf4BpV/4A9RXlKMjJQn7ONpj0NQCAjtYWHMv6BseyvoE6OAST0jKhS18E/9DwEXtWot74KjwwMzYAM2MD7NvazRacrm5yGF1V0EuR9dqmDmSf0iP7lN6+TanwwKQLVgNMClexyDoREREREY0o1pgaBNaYGlmCIGBfQzM2lunxlb4B1h77MwOUWBsVjHR/P6cpTILVirITecjPzsKpPTvR0drqdP3wCZOgS8/ExLlp8PLzc+GTUH9Ga3yOJItVQGFtM/IqGpBfYcLxrqSVsUeR9d7IPaRIDFU6JKsSWWS9V4xNEivGJokVY5PEjPHpGqwxdflYY4pIxCQSCVI1fkjV+KG4tR2vlNXi3co6NFlsKaqs+kZk1Tdikq8X7onS4oZgf3h1jQSRSKWI0k1BlG4KMletxZn9e5CfnYXio4chCLbzK04VoOJUAba9vgHxKanQZSxG7LQZkHnwx4TETSaVYHywH8YH++Ha5AgAtl9oFQ1tyCtvwPGuAut5FSZU9iiy3mG24mhZA46WNQCwrXLZXWR9coQtUaXrLrLuzSLrREREREQ0tPiOm0alGG8F/pgQgV+PC8W7FXV4uVyPsjbb6JCC5jY8dKIUfzlbiTsjgrAyIhBa+fk31J4KL0xasBCTFixEU30dCnbtQP6OragtLQYAWMxmnNq7C6f27oK3So1J8zOgS89E8Lh4UWesiS4kkUgQofFGRI8i63VN7ecLrHeNsDpX2+xw7oVF1j8+VG7fHhXgjaSwrtUAI1SYHK5GsIqfhBERERER0aXjVL5B4FQ+8TJbBXxV24ANpTU4YGpx2KeQSnBDiD/WRGoxyc+71/MFQUBN0TnkZ2fhxK4daGkwOh0TGBkNXXomdGmL4BcQ6IrHILhnfIpdU3eR9a4C68crTDhd3Qiz9eK/HoL8FEgKV9lXA+wusu6OSVzGJokVY5PEirFJYsb4dA1O5bt8nMpHNEp5SCVYHqzB8mANchuasaFMjy/0RlgEoN0q4L3KerxXWY8MfyXWRGmxKEAJ6QU/5BKJBCHj4hEyLh7pt61C8dFDyMvOwtkDe2DptI3EqisrQc67r2Pne28ieso0JKVnYvysufBkh0ujnJ/CA7NiAzCrlyLr3asB5lU0oKCyEa2dPYust2PHKT129CiyrrugZlVShArjtX7wYJF1IiIiIiLqgYmpAeCqfKPLDLUvNqh9UdbWgVfK9Hinsg4ms62O1A5DI3YYGpHgo8A9kVr8KDQAPj3eLMs8PBA3YxbiZsxCW3MTTu3ZibwdWag4mQ8AEAQrio8eQvHRQ/D08saE1PnQpWciSjcZEn7aQm5C4SHD5Ag1Jkeo7dsuLLLenaw6Xm5CQ6tjkfXGdjP2FtZjb2H9BdezFVnXdSWrJkeokRiqhJcni6wTEREREY1lnMo3CJzKNzo1mS14v6oeL5XqUdzW4bAvwFOGO8KDsCoiCCGK/gs7G6sqkZ+ThfzsLDTUVDvtVwZpoUvLhC59EQLCI4f0GcaSsRafo50gCCg3tp6vW9U1wqrK1HbRc2VSCeK1vudHVoWroQtXibbIOmOTxIqxSWLF2CQxY3y6BqfyXb6xOJWPialBYGJqdLMIAr6pbcCGUj32NDgWe/aUSHBdiAZrI7WYrPTp9zqCIKD8ZD7ys7NwcncOOlpbnI4JGz8RuvRMTJyXBm/l6I2VkTBW49Pd1Da1I7/ChONdo6vyK0wo7FFkvS/RAT5diarz0wHFUGSdsUlixdgksWJskpgxPl2DianLNxYTU5zKR2OGTCLBUq0GS7UaHGlswUulenxSY4BZADoFAR9WGfBhlQHzNH64N0qLKwJVDnWoukkkEkQmJiEyMQmL7lyDcwf3IW/HVhQdyYVgtU0ZrDxzEpVnTmLbGy8hPmU2dOmZGDc9BTIPcY4EIRpqQX4KpE/QIn2C1r6tsa0TBZWN9qmAx8sbcKamyanIekl9C0rqW/DV8Sr7Nq1SYU9WTQ5XIylcjagAb1H/siYiIiIiulSPPvoonnvuOTQ1NcHDw7Wpm88++wxPPfUU8vPz4efnh7S0NPzf//0f4uLiXHrfbkxM0Zg0TemDf+li8Lv4MLxWVos3K+pgNNtqiO02NmG3sQlx3gqsjgzCj8MC4CvrvQ6Op1yBiXPTMHFuGpqNBpzYtQN52VnQF50DAFgtZpzetxun9+2Gl1KFxHnpSErPREh8At9Q05ij9PLE7HEBmD3ufJH1tk5bkfW8igb76KqCShPaOq0O5+ob27H9pB7bT15QZN3LA7owW72q7tFV8VpfFlknIiIiolHv2LFjmDRpksuTUtu3b8f111+PO+64A0899RTq6urwhz/8AVdddRWOHTsGb+/eV7YfSkxM0ZgWppDjsfhwPBgbgg+rDHipVI+zre0AgHOt7XjsdDmeKazCT8IDcXdEEMK95H1ey1fjj5RrrkPKNddBX1yI/JxtKMjZhmajAQDQ1mjC4a+/wOGvv0BARBR06ZmYtGAhVEHaPq9J5O68PGWYEqnGlMieRdabcLzcdEGh9V6KrLf1UWQ9TOUwFZBF1omIiIhotDl69CgyMzNdfp/3338fMTExePXVV+2DJ4KDg5GZmYkDBw4gLS3N5W1gYooIgK9MhjsjgnBHeCC21pmwsUyPHEMTAKDBbMH6khpsKK3Bcq0Ga6KCMV3Vfx0qbcw4ZMSMQ9otK1F87DDys7NwZt/3MHfaiq/Xl5di53tvYOf7byI6aSp06ZlISJ0HuZfrs9FEYieTSjA+WInxwUpcNz0CgG2ufZmhtateVddUwIoGVJvaHc5tN1txpNSII6VGx+tp/ZAUroKua0VAXbgKKi9OrSUiIiIi8TEYDCgrK8OUKVNcfq/Ozk4olUqHGT1qte1D4+EqSc7EFNEFpBIJrgxS48ogNfKaWrGxVI+Pqw3oEASYBeDjGiM+rjEiVe2LNVFaXB2khqyfKXlSmQzjklMwLjkF7S0tOLV3J/Kzs1CWf9x2gCCg5PgRlBw/gu9e+TcmzJ4HXfpiRE2eAqmUIzyIukkkEkQF+CAqwAdXTw61b69tarfXq8qvsI2wKqpzXJDAYhVwsroRJ6sbsflQuX17dIAPJkecXw0wKVyFYGXvRToLa5vxwf4SnCqvxYSIVvx4VjTGBfm65mGJiIiIaEw7duwYAGDq1KkXPVYQBFgslose19eUwDvvvBNvvvkm/v3vf+O2225DXV0dHnvsMUyfPh3z588fXMMvEVflG4D169dj/fr1sFgsOHXqFFflG2Nq2jvxWnkt3qioRX2n4w98tJccqyODcEtYIJQeA08kNdRUIz8nC/nZWTBWVTrt9wsMgm7BQujSFyMwMuqyn2E0YXzS5Wps6+xKUnX/a8DpmiZYrBf/dRdsL7Juq1s1OUKN78/W4pHNxyCRSCAIgv2/z9w4FTfNHFs/nyRO7DdJrBibJGaMT9fgqnyXTxAEPPfcc3jooYdQWVmJ0NDQfo9//fXXsWrVqotet7CwELGxsb3u++KLL3DrrbeisbERAJCcnIwtW7YgJCSkz+sN5ap8TEwNwmBeWDFjJ3xpWi1WbK42YEOpHqda2hz2KWVS3NpVhyraWzHgawqCgMrTJ5CfnYUTu7PR3tzsdExIXAJ06ZlInJ8OH5W6l6u4F8YnuUJbpwWnqhvtiarj5SacqHIusj4YUgmQ9auFiOXIKRph7DdJrBibJGaMT9foK1lx1YGT0HeYR7BlI0cr98A3MycO+HhBEHD33Xfj888/h16vv+jxdXV1KCwsvOhxU6dOhVzuXDN59+7duOaaa3DXXXdh2bJlqKurw5/+9Cd4enoiJyenz+LnTEyNECamCLB1FNvrG7GxTI9t9Y0O+6QArtFqsDZKi5nqwb1ZNXd04Nyh/cjbsRVFhw/C2mM4plQmw7jps5CUnolxM2bBw9M96+MwPmm4mC1WFNY226cCdietTG0D+6NJAmBuXCB+tWQiJkeooBjEqEmiocR+k8SKsUlixvh0jb6SFdN356GyvbOfM91XmMITh+YlDfh4QRCQmpoKpVKJrVu3Duj4y5nKN3PmTMTExOCjjz6ybysrK0N0dDRefPFFrFmzptfzhjIxxRpTRIMkkUiwKFCFRYEqnGxuw0ulenxYXY92qwArgM/1RnyuN2KGygdrIrVYptXAQ9p3HapuHnI5JqTOx4TU+WhpMOLE7mzkZ2eh+twZAIDVYsHZA3tw9sAeePn6YeK8dOjSMxGWMNGhUB0RDYyHTIqEECUSQnorsm5LVH2wvxQ1je29ni8A2H2uDrv/sxtymRSTI1RIifFHSow/ZkT7I1jF4etEREREgG3U0Fg12Ge3Wq3Iz8/H6tWrB3T8G2+8cVlT+fLz83Httdc6bIuMjERQUBDOnj07oDZcrrEbHURDYKKvF/6WGIVH4sLwZkUtXiuvtQ9RzTW14N78YkQoKnB3pBa3hQVA7TmwHzkftQYzlv4QM5b+ELWlxcjP2YaC7Cw0GeoBAG3NTTjy7f9w5Nv/wT8sArr0TOjSFkGlDXbZsxKNBY5F1sNgtgrYmH3uovWpOixW5JYYkVtixEs5tqHUkf7e9iRVSow/EkOV8JDxE1kiIiIaewYzlW2sO3v2LJqbmwe8It/y5cuxf//+ix4XHh7e6/aYmBjk5uY6bCsuLkZtbW2fNamGGhNTREMgSO6Bh2JDcX90MD6pNmJDaQ3ym211qMrbO/HHsxV4tqgKt4QFYHWkFrGDqEMVFBWD9FvvxIKbb0fJ8aPIz87C6X27YW63jeIwVJZj1wdvYdcHbyFKNwW69EwkpM6HwsfHJc9KNJasmBmFDTt6/6RIIgF+eUUCiupakFtscFoNsMzQijJDKz49XAEA8PaUYVqU2p6smhHtD39f53n+RERERDR2HT16FABQU1ODTz75xGFfQkICkpIcpwUGBgYiMDDwku9377334he/+AUefPBBLF++HHV1dfjzn/+M4OBgrFix4pKvOxhMTBENIYVUih+HBWBFqD92GZuwoVSPb+tMAIBmixUvl9XilbJaXB2kxpooLeaofQc8DU8qlSF26nTETp2Ojtaf4vS+75GfvRUleceArlJxpfnHUJp/DFtffRHjZ81BUnomoqcmQypl7RuiSzEuyBfP3DgVv/3o6PlV+SCBAOdV+Wqb2nGoxIiDxQbklhhwpNSIdvP54uqtnRbsOVePPefq7dvignwx44LpfwnBfpAOYOovEREREbmn7sTUY4895rTvhRdecEpMXa6f//znUCgU+M9//oNXXnkFSqUSc+fOxYcffnhZCa/BYPHzQWDxc7oUZ1psdaj+W1WP1h7Tgab6eWNtlBbLgzWQX+L3wlRbg4Kc7cjLzoKhosxpv69/ACYtWIik9EwERcde0j2GE+OTxKiothnv7y/BqfJaTIgIws2zoi+6Gl+nxYqCShMOFhtwsNiAQyVGlBtb+z1H6eWB6dH+mBGtQUqMP5KjNFB6uedCBzR02G+SWDE2ScwYn65xsYLYdHGCIKCjowNyuVzUtYS5Kt8IYWKKLkd9pxlvV9Th1bJaVHU4rkgRKvfEXZFBuD08EP4DrEPVkyAIqDp7CvnZWTixKxttTY1OxwTHxkOXnonE+enw1fhf0n1cjfFJYjUUsVnZ0IrcYiNyS2zJqryKBnRa+v41LJEAE0OUmHFBrarYQB9R/5FCw4/9JokVY5PEjPHpGkxMXT4mpqhfTEzRUOiwWvF5jREbyvQ42ug4esJbKsWKUH+sidIi3ufSO3KLuRPncvcjPzsL53IPwGoxO+yXSKUYl5wCXXom4lNS4SEXT50bxieJlStis63TguPlDfbpfweLjaht6n0VwG4BvnLMiNbYk1XTIjXwlnO67ljGfpPEirFJYsb4dA0mpi7fWExMscbUAKxfvx7r16+HxWIZ6aaQG5BLpbgxNAA3hPhjb0MzNpTqsaW2AQKAVqsVb1TU4Y2KOlwRqMK9UVrM1/gNukOSeXgiYfY8JMyehxZTA05+n4P87CxUnTkFABCsVpzL3Y9zufuh8PHFxLlp0KVnInziJFF3fkTuxstThpmxAZgZGwDA9odImaHVPv0vt8SAgkoTLpwFXN/cge8KavBdQQ0AwEMqwaQwla1OVYxtGmCExps/y0REREQ0KnDE1CBwxBS5SlFrO14u0+Pdynq0WKwO+3S+XlgTpcX1If5QXOb3q668FAU525CfvQ2NdXqn/ZqQMExKWwRdeiY0IaGXda9LxfgksRqp2GxuN+NI6fnpf7klRjS0dvZ7TohKcX71vxh/JIWroPDgqCp3xX6TxIqxSWLG+HQNjpi6fGNxxBQTU4PAxBS5WkOnGe9U1uOVMj3K2x3feGrlHlgVEYQ7woMQJL+8wY6C1YrS/OPIz96KU3t2obO9zemYiMQk6NIzMXHuAih8+i/yPJQYnyRWYolNq1XAudpm5Nqn/xlwuqap33PkHlJMiVB3Jas0mBHtj2AV/1h0F2KJTaKeGJskZoxP12Bi6vIxMUX9YmKKhovZKuALvREby/TINbU47POSSnBjiD/uidIi0df7su/V2daG0/u/R352FoqPHQZ6dAkennLEz0yFLiMTsVNnQCpz7agLxieJlZhjs6GlE4dKDV3JKiMOlRjQ3NH/9POoAG97QfUZ0f5IDFXCQyau56KBEXNs0tjG2CQxY3y6RneyIjY2Ft7el/9eZSwaLYmp1tZWFBUVscYUkbvykEpwXYg/rgvxx4GuOlRf6o2wAmizCninsh7vVNZjUYASayK1WBigvOROy9PLC7q0RdClLUJjXS0Kdm5HfnYW6spKAADmzg6c/D4HJ7/PgY9ag0kLFkKXnong2LghfGIiuhxqH08snBiMhRODAQAWq4CTVY3ILTHYR1YV1TkmuUvrW1Fa34pPD1cAAHzkMkyL1GBGjAYpMf6YHuUPf1/xLIxARERE4ufp6QkAaGlpYWLKzbW02P627P6eXw6OmBoEjpiikVTS2o5XymvxbkUdGnvUoZrg44W1UVrcEOIP7yEY8SAIAmoKzyIveytO7NyB1kaT0zHa6Fjo0jORuGAh/PwDLvue3RifJFajPTZrm9rtI6pyiw04UmZEu9na7zlxWl+kdNWpSonxx3itH6RS8X5yN1aN9tgk98XYJDFjfLpOZWUljEYjgoOD4ePjI+pRP2IkCAI6Ozvh6ekpytdOEAS0tLSgpqYGGo0GYWFhvR7HqXwuwsQUiUGj2YL3K+vxUpkeJW0dDvsCPGVYGR6EVRFBCFZcfuYaACxmM4qOHET+jiycPbgXFrPZYb9EIkXMtOlISs9E/Kw58JQrLut+jE8SK3eLzQ6zFQWVJvvqf7nFBlQ0ONebu5DSywPTo/2R0jUFcFqUGkqvoelr6NK5W2yS+2BskpgxPl1HEARUVVXBaDSOdFNGJUEQYLFYIJPJRJmY6qbRaBAaGtpnG5mYchEmpkhMLIKALbUN2Fiqx96GZod9cokE14f4Y22UFjq/oRtC29rUiFPf5yAvOwuVp0447Zd7+2DCnAVISs9ERKIOkkuIL8YnidVYiM3KhlbkFhvtyaq8igZ0Wvr+M0EiASaGKG0jqrqSVTGB/GR0uI2F2KTRibFJYsb4dD2LxYLOzv5XEiZnVqsVlZWVCAsLE21senp6QnaR2sNMTLkIE1MkVodMLdhYWoPP9UaYe/xEL9D4YW2UFosDVZAO4ZtFQ2U58nO2IT87CyZ9jdN+lTYEunRb7Sr/sIgBX5fxSWI1FmOzrdOCY+UNyC022JNVtU0d/Z4T4CvHjGh/W62qaH9MjdTAW+7aRRPGurEYmzQ6MDZJzBifJFbuEptMTLkIE1MkdhVtHXi1vBZvVdShwey4Itd4HwVWR2pxU6g/fIdwZT3BakX5iXzkZW/FqT070dHa6nRM+IRJ0KVnYuLcNHj5+fV7PcYniRVj0za0vLS+FQdL6u0jq05UmWDt5y8JD6kEunBVV7LKNqoqXO3FUVVDiLFJYsXYJDFjfJJYuUtsMjHlIkxM0WjRbLbggypbHarCVsfRDRoPGe4ID8SqyCCEKYZ2xa3O9jacObAX+dlZKD5yCILgWFhZ5uGB+JRU6DIyETstBTIP54VBGZ8kVozN3jW1m3G09Pz0v9wSIxpa+x+2H6rywowYDWZ0Tf9LCldD7sHX9FIxNkmsGJskZoxPEit3iU0mpobY+vXrsX79elgsFpw6dYqJKRo1rIKA7+pMeLFUj93GJod9HhLg2mB/rInSYprSZ8jv3WSox4md25GXnYXakiKn/d4qNSbNz4AuPRPB4+LtoycYnyRWjM2BsVoFnKttso+oOlhiwJmapn7PkXtIMTVCjZQYf0zvmgYYrPQaphaPfoxNEivGJokZ45PEyl1ik4kpF+GIKRrNjjW2YGOZHp9UG9HZ48d+jtoXa6O0uCpIDdkQT68RBAH64kLkZ29Fwc4daGkwOh0TGBkNXXomJqUthK8mgPFJosS+89I1tHQit9SAQ12JqsMlRjR3WPo9JyrA215QfXq0PxJDlfCQ8XXvDWOTxIqxSWLG+CSxcpfYZGLKRZiYIndQ3d6J18pr8WZFLeo7Hd8YxnrLsTpSi1tCA+DrMfTFiq0WC4qO5iJ/RxbOHNgDS89VOiQSRE+ehpCkaUhdcg0UPkM/kovoUrHvHDoWq4CTVY04WHI+WVVc19LvOT5yGaZFapAS052s0kDjM7TTkUcrxiaJFWOTxIzxSWLlLrHJxJSLMDFF7qTFYsVH1fXYWKrH6ZZ2h30qDyluCwvE3ZFaRHq55o1fW3MTTu3ZifzsLJSfyHfa7+nljQmp86FLz0SUbjIkjFUaYew7XUvf2I5DJbYkVW6xAUfLGtButvZ7TrzWFykx/vZaVfFaP0ilY6+oOmOTxIqxSWLG+CSxcpfYZGLKRZiYIndkFQRsq2/ExlI9dhgaHfbJJMAyrQZrI7WYofZ1WRuMVZXIz9mG/JwsNFRXOe1XBmmhS1sEXXomAsIjXdYOov6w7xxeHWYr8itNyC0+n6yqbGjr9xyVlwemdyWpZkT7IzlaAz+F8yIL7oaxSWLF2CQxY3ySWLlLbDIx5SJMTJG7K2hqxcYyPTZXG9DeY/33mSofrI0KxtIgNTxcNCJBEASUFeRh31efofL4EbS3NDsdEzZ+InTpmZg4Lw3eytH7c0ijD/vOkVdhbLWt/FdsxMESA/LKG2C29v1njFQCTAxVYUa0xp6sign0sS+24C4YmyRWjE0SM8YniZW7xCYTUy7CxBSNFfqOTrxRXofXy2tR22l22Bfp5YnVEVrcGh4IlSvqUHXFZ3hoCAoPHUB+dhYKDx+EYHWc0iOVeSBuxizoMjIRN30mZB6eQ94Wogux7xSftk4LjpU32Fb/KzbgUIkBtU0d/Z4T6CvHjAum/02NVMPLc+j7suHE2CSxYmySmDE+SazcJTaZmHIRJqZorGmzWLG5xoCNpXqcaHacQuMnk+LWsEDcHRmEGG/FkN2zt/hsNhpwYtcO5GVnQV90zukcL6UKifPSoEvPRGj8BLcbDUHiwL5T/ARBQEl9C3JLDF3JKiNOVpnQz6AqeEglSApXOSSrwjXew9foIcDYJLFibJKYMT5JrNwlNpmYchEmpmisEgQBOYYmvFhag6x6xzpUUgBLtWqsidRittr3spNCF4tPfXEh8nO2oSBnG5qNBqf9AeGR0KVnYlLaIqiCtJfVFqILse8cnZrazThSanSoVWVqM/d7TpjaCzOi/buSVRokhash9xDv95yxSWLF2CQxY3ySWLlLbDIx5SJMTBEBp5rb8HKZHh9W1aO1xzCEZKUP1kZpsUyrgecl1qEaaHxaLRaUHDuMvOwsnNm/B+YOx5UFIZEgOmkKdOmLkZA6D3Kv0TUCgsSHfad7sFoFnKttsk//yy0x4kxNU7/nKDykmBqpviBZ5Q+tcuhGil4uxiaJFWOTxIzxSWLlLrHJxJSLMDFFdF59pxlvldfh1XI9qjscRx+EKzyxKiIIt4cHQuM5uBWxLiU+21tacHrvLuRlb0VZ/nGn/R4KBSbMngdd+mJETZ4CqXR015OhkcG+030ZWzpwqHtUVbEBh0uNaOmw9HtOdIBPV0F1DWbE+GNiiBIespGJC8YmiRVjk8SM8Uli5S6xycSUizAxReSsw2rFpzVGbCzV41hTq8M+b6kUN4cF4J5ILeJ8Bja64HLjs6GmGgU525CfkwVDZYXTfr+AQExKW4Sk9EwERkYP+vo0drHvHDvMFitOVjcit2tE1cFiA0rqW/o9x0cuQ3LU+dX/pkdroPGRD0t7GZskVoxNEjPGJ4mVu8QmE1MuwsQUUd8EQcBuYxM2lunxTa0JF3YsEgBXBamwJlKLeRq/futQDVV8CoKAytMnkZ+dhZO7s9HW7DxVJyRuPHTpi5E4Px0+KvUl34vGBvadY5u+sR25XTWqcksMOFLWgA6ztd9zxgf7YUa0LVmVEuOPuCA/SC9xmnN/GJskVoxNEjPGJ4mVu8QmE1MuwsQU0cCca2nHS2V6vF9Zj1ar4xu3yX7eWBulxbXBGsh7iT9XxKe5sxPncvchPzsLhYcOwGpxnKIjlckwbvpM6NIzETdjNjw8PYfkvuRe2HfShTrMVuRXmmx1qrqmAFaZ2vo9R+Xl4bD637QoDfwUg5vu3BvGJokVY5PEjPFJYuUuscnElIswMUU0OMZOM96uqMOr5bWoaO902Bci9+iqQxWEQPn5N2aujs8WUwNO7MpGfnYWqs+ddtrv5euHifPSoEtfjLCEiZe9yiC5D/addDEVxtauguq2ZFVehQlma99/ZkklwMRQFVJiNPZkVXSAz6D7HcYmiRVjk8SM8Uli5S6xycTUEFu/fj3Wr18Pi8WCU6dOMTFFNEidVgFf6I3YUKrH4UbHOi1eUglWhNrqUCX4eg1rfNaWFiM/ZxsKcrahqb7Oab9/WDh0aZmYlLYI6uAQl7aFxI99Jw1WW6cFR8saHJJVdc0d/Z4T5CfH9K4k1Yxof0yNVMPLs/8FGxibJFaMTRIzxieJlbvEJhNTLsIRU0SXRxAE7G9oxoYyPb7SN6BndZbMACXuiQhCbGM9YmJihi0+rVYLSo8fQ372Vpzatxvm9nanYyJ1k6FLz8SE1AVQ+PgMS7tIXNh30uUSBAEl9S042DX1L7fEiJNVJvQzqAoeUgmSItQOtarC1N4OxzA2SawYmyRmjE8SK3eJTSamXISJKaKhU9zajlfKavFuZR2aLI4pqnhPKe4bF44bQwPgNczLr3e0teL03t3Iz96KkrxjQI8u0kOuwPhZc5CUnonoqcmQSvsfyUDug30nuUJTuxlHSo32ZNWhEgNMbeZ+zwlTe2FGjD9Sov0xI8YfiSF+qKooY2yS6LDfJDFjfJJYuUtsMjHlIkxMEQ09k9mCdyvq8HK5HmVtjnWogjw9cGdEEFZGBEIrH/6C5KbaGhTkbEdedhYMFWVO+339AzBpwULo0jOhjY4d9vbR8GLfScPBahVwVt9kn/53sNiAs/rmfs9ReEgxIcgLcyeEYGZMAGbE+CPITzFMLSbqG/tNEjPGJ4mVu8QmE1MuwsQUkeuYrQK+qm3AhtIaHDA51qFSSCW4IcQfayK1mOTn3ccVXEcQBFSfPY287Cyc2J2NtkaT0zHa2DgkpS9G4vx0+Gr8h72N5HrsO2mkGFs6cKjEaE9WHS41oqXD0u85MYE+mNE1oiol2h8TQ5WQSbmYAw0v9pskZoxPEit3iU0mplyEiSki17NarfjfqXP4zCzDl7UNsPTooTL8lVgTpcWiACWkI7BinsXciXOHDiB/RxbO5e6H1eI45UYilWJccgp06ZmIT0mFh1w+7G0k12DfSWJhtlhxoqoRh0oM9mRVSX1rv+f4ymVIjtbYk1Uzovyh9hn+kag0trDfJDFjfJJYuUtsMjHlIkxMEbnehfFZ0WHGq2W1eLuyFiazYx2qBB8F7onU4kehAfAZ5jpU3VobTTi5Owf52VmoPHPSab/CxxcT5i5AUvpihE+cNOgl4Elc2HeSWFmtVhw6cRY1Fl8cLrWtAni0vAEd5p5LTDgaH+yHlO4VAGM0iAvyg5SjqmgIsd8kMWN8kli5S2wyMeUiTEwRuV5v8dlktuD9qnq8XKZHUavjUusBnjLcER6EVRFBCFGM3Kf/deWlKMjZhvzsbWis0zvtV4eEQpeWCV16JjQhoSPQQrpc7DtJrHqLzQ6zFXkVDV0F1Y04UFyPapPziqMXUnt7YkbXqKqUGH9Mi9LAV+ExHI9Abor9JokZ45PEyl1ik4kpF2Fiisj1+otPiyDg21oTXiytwZ4Gx2LAnhIJrgvRYG2kFpOVPsPZZAeC1YrS/OPIz87Cqb270NnmPL0mIlEHXXomJs5Ng8LHdwRaSZeCfSeJ1UBiUxAEVDS0IfeC1f/yKkwwW/v+M1AqARJDVfYRVSnRAYgK8OboTxow9pskZoxPEit3iU0mplyEiSki1xtofB5tbMHGUj0+qTHA3KMXm6fxw9ooLa4MVI1IHapunW1tOL3/e+RnZ6H42GGgR3cr8/TE+JlzoMvIROzUGZDKZCPTUBoQ9p0kVpcam60dFhwtMyL3gsLq9c0d/Z4T5Ce3j6iaEeOPKRFqeHmy76Lesd8kMWN8kli5S2wyMeUiTEwRud5g47OyvQOvldXirYo6GMyOq1TFeSuwOjIIPw4LgO8IJ30a62tRkLMd+dlZqCsrcdrvo9Zg0oIM6NIXQxszjiMSRIh9J4nVUMWmIAgormuxJ6kOFhtwsrqxZ07dgadMgqRw9QXJKg3C1MO/eiqJE/tNEjPGJ4mVu8QmE1MuwsQUketdany2WKz4sKoeG0v1ONvqWEdF7SHDT8IDcXdEEMK9RnaVPEEQUFN4FvnZWSjYtQOtpganY4KiY6FLz8SkBQvh5x8wAq2k3rDvJLFyZWw2tnXiSFdB9dwS27/GNnO/54SrvWwr/3Ulq3ThKniO0CIVNLLYb5KYMT5JrNwlNpmYchEmpohc73Lj0yoI2FpnwsYyPXIMTQ77PCTAcq0Ga6KCMV01cnWoulnMZhQdyUX+jq04e3AvLGbHN3sSiRQx06ZDl56J8TNT4anwGqGWEsC+k8RrOGPTahVwRt9kr1WVW2LAWX1zv+coPKSYFqnpSlbZ/hvkp3BpO0kc2G+SmDE+SazcJTYHkz/hUitE5FakEgmuDFLjyiA18ppasbFUj4+rDegQBJgF4OMaIz6uMSJV7Ys1UVpcHaSGbISmzck8PBCfMhvxKbPR1tSEk9/nID87CxWnCgAAgmBF0eGDKDp8EHJvb0yYswC69ExEJiZBMop/SRHR6CWVSjAhRIkJIUrcPDsaAGBo7sChUgNyi221qg6XGtHaeX5qdbvZin1F9dhXVG/fFhPog5Rof/vIqomhSsiknMJMREQ0FnHE1CBwxBSR67kiPmvaO/F6RS1eL69FfadjHapoLzlWRwbhlrBAKD3EUcDXUFmO/BxbPSqTvtppv0obAl36IujSFsE/LGL4GzhGse8ksRJbbJotVpyoarRN/Ss24GCJAaX1ziuUXshP4YHkKI19RNX0aH+ovT2HqcXkKmKLTaILMT5JrNwlNjmVz0WYmCJyPVfGZ6vFis3VBmwo1eNUS5vDPqVMilu76lBFe4tjiolgtaL8RD7ysrNwak8OOlqd39iFTUhEUnomJsxNg7efcgRaOXaw7ySxGg2xWdPYhtxioz1ZdbS8AR1ma7/nJAT72Qqqd42sigvyhZSjqkaV0RCbNHYxPkms3CU2mZhyESamiFxvOOJTEATsMDRiQ6ke2+obHfZJAVyj1WBtlBYz1b4uuf+l6Gxvw9kDe5GfnYWiI4cgCI5v6GQeHohLmY2kjMWInZYCmQdnag819p0kVqMxNtvNFuRVmJB7wQqA1ab2fs/R+HhiepTGnqyaFqWBr4J9nZiNxtiksYPxSWLlLrHJGlNERP2QSCRYGKDCwgAVTja34aVSPTZV16PNKsAK4HO9EZ/rjZih8sGaSC2WaTXwGOFP6T0VXkicn4HE+RloMtTjxM7tyMvOQm1JEQBbIfXTe3fj9N7d8FaqkLggA0npixE8Lh6SEaqhRUTUF4WHzDYSKtofgO0Dg4qGNltB9a5kVV6FCRbr+c9PjS2d2HZSj20n9QAAqQSYFKayr/43I9ofUQHe7POIiIhGGY6YGgSOmCJyvZGKz9oOM96sqMVr5bXQdziujheh8MTdkVrcFhYAtae48vk1ReeQn52Fgp3b0dJgdNofGBkNXXomJqUthDIgaPgb6EbYd5JYuWtstnZYcLTMiIMl3ckqI+qbO/o9J8hPgZQYjT1ZNTlCDS9PcdQPHIvcNTbJPTA+SazcJTY5lc9FmJgicr2Rjs92qxWfVBuxobQG+c2Odah8ZFLcEhqAe6K0iBVJHapuVosFRUdzkb8jC2cO7IGls9PxAIkEMVOSoUvPRMKsufD08hqZho5iIx2bRH0ZK7EpCAKK6lrsBdVziw04Wd2I/v6S9ZRJkBSuRkrM+VFVoWr2f8NlrMQmjU6MTxIrd4lNJqZchIkpItcTS3wKgoBdxiZsKNXj2zqTwz4JgKuD1FgTpcUcta/opo20NTfh1J5dyM/OQvmJPKf9ngovTJgzH7r0TETppkDCfmBAxBKbRD2N5dhsbOvE4VIjcottI6sOFRvQ2G7u95wIjTemR2vsyapJYSp4ysbW6zZcxnJskvgxPkms3CU2WWNqiK1fvx7r16+HxWK5+MFE5BYkEgkW+CuxwF+JMy22OlT/rapHq1WAAOCr2gZ8VduAqX7eWBulxfJgDeQi+cXh5euHqYuXYOriJTBWV6EgZxvys7NgrK4EYCuknrdjK/J2bIUyUAtd+iJMSluEwIioEW45EdHgKL08kZagRVqCFgBgtQo4o2/CwWJbQfXcEgPO6Zsdzik3tqLc2Iovjtr6RC9PKaZGai6oVaVBoJ+4RsUSERG5M46YGgSOmCJyPTHHp6HTjLcr6vBKWS2qOhynyoXKPXFXZBBuDw+Ev8jqUAFdhYVPFiA/Owsnv89Be0uz0zGh4ydAl56JxHnp8FaO3j7OVcQcmzS2MTb7Z2juwKFSgz1ZdaS0Aa2d/X/YGBvogxldU/9SYvwxIUQJ2QgvgjEaMTZJzBifJFbuEpucyuciTEwRud5oiM8OqxWf1xixoUyPo42tDvu8pVKsCPXHmigt4n3EWcfE3NGBswf3IT97KwoPH4RgtTrsl8o8EDdjJnQZixE3fSZkHp4j1FJxGQ2xSWMTY3NwzBYrTlQ1IrfkfLKqzNDa7zl+Cg8kR2kwo2v6X3KUBmpv9o0Xw9gkMWN8kli5S2wyMeUiTEwRud5oik9BELC3oRkbSvXYUtuAnp3pFYEq3BulxXyNn+jqUHVrNhpwYlc28rOzUFN01mm/l58SifPToUvPRGj8BNE+x3AYTbFJYwtj8/LVmNrsiarcEiOOlTWgw2Lt83iJBEgI9kNKjD+md42qigsSX83BkcbYJDFjfJJYuUtsMjHlIkxMEbneaI3PotZ2vFymx3uV9Wju8WZG5+uFNVFaXB/iD4WIn0lfUoT87CwU7NyOZkO9037/8EgkpWdiUtpCqIKCR6CFI2u0xia5P8bm0Gs3W5BXYbKtANj1r6axvd9zND6e9ql/06M1mBapga9CfFO7hxNjk8SM8Uli5S6xycSUizAxReR6oz0+GzrNeKeyHq+U6VHe7liHSiv3wKqIINwRHoQguXjfrFitFpQcPYy87Cyc2b8H5o4eb8YkEkQnTYEufTESZs+F3NtnZBo6zEZ7bJL7Ymy6niAIKDe2IrfEaE9W5VeaYLH2/We0TCpBYqjSvvrfjGh/RPp7j6lRVYxNEjPGJ4mVu8QmE1MuwsQUkeu5S3yarQK+rDViQ6keuaYWh31eUgluDPHHPVFaJPp6j1ALB6a9pQWn9+5CfnYWSvOPOe33UCiQMHsedOmZiJ48FVKpbARaOTzcJTbJ/TA2R0ZLhxlHyxpwsNiAQ13TAA0tnf2eo1UqkBLtjxkxGqTE+CMpXA0vT/abRCOB8Uli5S6xycSUizAxReR67hifB7rqUH2pN6JnxZJFAUqsidRiYYBS9J+iN9RUo2DnduRnb4WhssJpv19AICalLUJSeiYCI6NHoIWu5Y6xSe6BsSkOgiCgqK7FPvXvUIkBJ6sb0d9f2nKZFEkRqq5klW1kVYhKnAtnXArGJokZ45PEyl1ik4kpF2Fiisj13Dk+S1rb8Up5Ld6tqENjjzpUE3y8sDZKixtC/OEtE/dzC4KAqjOnkLdjK07uzkZbc5PTMSFx46FLz0Ti/Az4qNQj0Mqh586xSaMbY1O8TG2dOFJqtCerDpcY0dhu7vecCI23LUkVbVsFcFKYCp4i/73QF8YmiRnjk8TKXWKTiSkXYWKKyPXGQnw2mS14r7IeL5XpUdLW4bAvwFOGleFBWBURhGCF+JciN3d2ojB3P/Kys1B4aD+sFovDfqlMhtjkFCSlZyJuxmx4yOUj1NLLNxZik0YnxuboYbEKOFPT1LX6nwG5xQacq23u9xwvTymmRWq6klW2kVUBvqOjL2VskpgxPkms3CU2mZhyESamiFxvLMWnRRCwpbYBG0v12Nvg+MZELpHg+hB/rI3SQucn7jpU3VpMDTi5Oxt5O7JQfe60036Fry8S56VDl56JsIRE0U9d7GksxSaNLozN0a2+ucNeoyq3xIAjpQ1o7bT0e864IF/MuKBWVUKwEjKp+PpUxiaJGeOTxMpdYpOJKRdhYorI9cZqfB42tWBjmR6f1Rhg7tErL9D4YW2UFosDVZCOkmROXVkJ8rOzkJ+zDU31dU77NaFh0KVnQpeWCXVwyAi0cPDGamyS+DE23UunxYoTlY3IvSBZVWZo7fccpcIDydGarmSVP5KjNFB7j/yoW8YmiRnjk8TKXWKTiSkXYWKKyPXGenxWtHXg1fJavFVRhwaz4yfm430UWB2pxU2h/vCVjY5VnKxWC0rzjiE/Owun9+5GZ3ub0zGRkyZDl5GJCakLoPDxGYFWDsxYj00SL8am+6s2tSG3K0l1sNiA4+UmdFh6LqdxnkQCTAhWYkbM+WRVXJDvsI9UZWySmDE+SazcJTaZmHIRJqaIXI/xadNstuCDKlsdqsJWxzpUGg8Z7ggPxKrIIIQpRkedEQDoaGvF6b27kZ+dhZK8o+i5VJWHpxzjZ8+FLj0TMVOSIRVZ8o2xSWLF2Bx72s0WHC83OSSrahrb+z3H38fTnqSaEe2PaVFq+Mg9XNpOxiaJGeOTxMpdYpOJKRdhYorI9RifjqyCgO/qTNhQqscuo+Pqdx4S4Npgf6yJ0mKaUrwjjXpjqtWjYOd25O/YivqKMqf9vhp/JC5YiKSMxdBGxw5/A3vB2CSxYmySIAgoN7bapv4VG5BbYkR+pQkWa99/5sukEkwKU9oLqs+I9kekv/eQjqpibJKYMT5JrNwlNpmYchEmpohcj/HZt+ONLdhQpscn1UZ09ui656h9sTZKi6uC1JCNkjpUgO3NVPXZ08jLzsKJ3dloazQ5HaONjUNSeiYS52fAV+M/Aq20YWySWDE2qTctHWYcKW2wr/6XW2KAoaWz33OClQrMiPZHSowtWTU5QgWFx6WPXmVskpgxPkms3CU2mZhyESamiFyP8Xlx1e2deL28Fm9U1KK+x8pNsd5yrI7U4pbQAPhexpuJkWAxd6Lw0EHkZ2fh7MF9sFrMDvslUilip82ALj0T8TNT4SlXDGv7GJskVoxNGghBEFBY29xVUN2I3GIDTtU09pxV7UAuk2JyhMohWRWi8hrwPRmbJGaMTxIrd4lNJqZchIkpItdjfA5ci8WKj6rrsbFUj9MtjrVFVB5S3BYWiLsjtYj0Gj11qLq1NppwcncO8rOzUHnmpNN+hY8vJsxdAF16JiIm6oaloC9jk8SKsUmXytTWicMlRvvqf4dLjGhsN/d7ToTG25akitYgJSYAiWFKeMqc466wthkf7C/BqfJaTIgIwo9nRWNckK+rHoVo0Nh3kli5S2wyMeUiTEwRuR7jc/CsgoDt9Y3YUKrHDkOjwz6ZBFim1WBtpBYz1KPzDUF9RRnys7chPycLjbV6p/3qkFDo0hZBl5YJTWiYy9rB2CSxYmzSULFYBZyuaURusS1ZdajEgHO1zf2e4+0pw9RIdVeyyjaq6ruCajzy0VFIJBIIgmD/7zM3TsVNM6OG6WmI+se+k8TKXWKTiSkXYWKKyPUYn5enoKkVL5Xp8VG1Ae09it7OVPlgbVQwlgap4SEdPXWouglWK8oKjiMvOwun9uxCZ1ur0zHhE3VIysjEhDkL4OXrN6T3Z2ySWDE2yZXqmtpxqMRoX/3vSJkRbZ3WS7qWVAJk/WohYjlyikSAfSeJlbvEJhNTLsLEFJHrMT6Hhr6jE2+U1+H18lrUdjpOy4j08sTqCC1uDQ+EapTVoerW2daGM/u/R152FkqOHYEgOL5Jknl6In7mHCSlZyJm6nTIPC5/SXTGJokVY5OGU6fFihOVjThYXI/crmmA5UbnDwp6I5EAP5oRiWdunArpKPyAhNwL+04SK3eJTSamXISJKSLXY3wOrTaLFZtrDNhYqseJ5jaHfX4yKW4NC8TdkUGI8R7eQuJDqbG+Fid27kDejq2oKytx2u+j1iBxfgaSMhZDGzPukutRMTZJrBibNNKqTW3ILbaNqPoot+yiq/+pvT0xe1wA5sQFInVcACaFqSBjooqGGftOEit3iU0mplyEiSki12N8uoYgCMgxNGFDqR5b600O+6QAlmrVWBOpxWy177AUEncFQRBQU3gW+dlZKNi1A62mBqdjgqJjoUvPxKT5GfALCBzU9RmbJFaMTRKTZ7acwMYd52AZxFsMlZfHBYmqQOjCmagi12PfSWLlLrHJxJSLMDFF5HqMT9c71dyGl8v0+LCqHq096lAlK32wNkqLZVoNPEfxmwKL2YyiI7nIz87C2QN7YDE7TmeUSKSImZoMXXomxs+aA0/FxZc/Z2ySWDE2SUwKa5ux+NntsPbyDkMCYP74QByvMMHYz6gqpZcHZscGIDXOlqzShang0cvKf0SXg30niZW7xCYTUy7CxBSR6zE+h099pxlvldfh1XI9qjscEzfhCk+sigjC7eGB0Hhefn2mkdTW1IST3+cgPzsLFacKnPbLvb0xYc4C6NIzEZmYBEkfccfYJLFibJLYfHigFL+9cFU+SCDg/Kp8VquAUzWN2HO2DnsL67G3sB71zR19Xs9P4YFZsf5IjQvEnLhATA5nooouH/tOEit3iU0mplyEiSki12N8Dr8OqxWf1hixsVSPY02OBWy9pVLcHBaAeyK1iPMZvXWouhmqKpCfvQ352Vkw6aud9qu0wdClLcKktEwEhEecP6+yHMeyvkFlcRHCYmIxJfMq+IdFOJ1PNBLYb5IYFdU24/39JThVXosJEUG4eVZ0n6vxWa0CzuibsOdcHfacq8Pec/Wo6ydR5SuXYWZs19S/uABMiVDDk4kqGiT2nSRW7hKbTEy5CBNTRK7H+Bw5giBgt7EJG8v0+KbWhAt/OUgAXBWkwppILeZp/EZtHapugtWK8pP5yM/Owsnvd6KjtcXpmLAJiUhKz4TFYsH21zcC3Z/8SySAIOCqex/E5IVXjEDriRyx3ySxutTYFAQBZ2qasKew3p6oqm1q7/N4H7kMKTH+mBMXiDlxAZgSoYHcgz8L1D/2nSRW7hKbTEy5CBNTRK7H+BSHcy3teLlMj/cq69FqtTrsm+znjbVRWlwbrIHcDb5HnR3tOHtgL/J3bEXRkUMQBOvFTwIgkUiw6rkN8A8Nd3ELifrHfpPEaqhiUxAEnNU325JUXckqfWPfiSpvTxlmxvojtaug+tRIJqrIGftOEit3iU0mplyEiSki12N8ioux04y3K+rwanktKtodC9WGyD266lAFIVA+uutQdWs2GlCwczvys7OgLy7s91iJVIpZy29A2q13Dk/jiPrAfpPEylWxKQgCCmubsedcPfYW2qb/VZv6TlR5eUqREuOP1HG2GlXTotRQeMiGrD00OrHvJLFyl9hkYqoPRqMRV1xxBcxmM8xmMx588EHcc889Az6fiSki12N8ilOnVcCXeiNeLNXjcKPjtDcvqQQ3hdrqUE3wvfjqdqNFTdE5fPHPv8JQUdbnMcGxcbjxsT/CR60ZvoYR9cB+k8RquGJTEAQU17XYa1TtOVePKlNbn8crPKSYEe1vr1GVHKWBlycTVWMN+04SK3eJTSam+mCxWNDe3g4fHx80Nzdj8uTJOHDgAAIDAwd0PhNTRK7H+BQ3QRCwv6EZG8r0+ErfgJ6T3jIDlFgbFYx0/9FfhwoAct59Hfs/3wzB2vf0PqlMhnHTZyIpfTHiUmZB5uE5jC0kYr9J4jVSsSkIAkrqW7D3XL09WVXR0HeiSu4hxfQojT1RNSPan4mqMYB9J4mVu8TmYPIn7jH3YoBkMhl8fHwAAO3t7RAEAWMoL0dEdNkkEglma/wwW+OH4tZ2vFJWi3cr69BksSVusuobkVXfiEm+XrgnSosbgv3hNYpXSpq86Ers/+yjfo+xWiw4e2Avzh7YCy+lCpPmZyApYzGCx8W7RXKOiGi0kUgkiAn0RUygL1bMioIgCCgztOL7rkLqe87Vodx4fhXaDrMVewvrsbewHtgKyGVSJEdrMKerRtX0aH94y5moIiJyFVGNmMrOzsa6detw8OBBVFZW4uOPP8Z1113ncMz69euxbt06VFVVYdq0aXjhhRcwe/bsAd/DaDQiIyMDp0+fxrp163D//fcP+FyOmCJyPcbn6NNotuDdyjq8VKZHWZtjHaogTw/cGRGElRGB0MpH50ii49u/wzcv/tNpVb75N9+OjtZW5Gdnoam+zum8oKgYJGUsxqS0RfDV+I9Ay2msYL9JYiXm2Cytb7Elo87VYU9hHUrrW/s81lMmQXKUxl6jakaMBj5uUltxLBNzfNLY5i6xOWqn8n311VfYtWsXUlJScMMNNzglpj744APccccdePHFF5GamornnnsOH374IU6ePIng4GAAQHJyMsxms9O1v/nmG4SHn185qbq6GjfccAM2b96MkJCQAbWPiSki12N8jl5mq4CvahuwsVSP/aZmh30KqQQ3hPhjTaQWk/y8R6iFl85QVYFjW79GZXERwmJiMWXxEvtqfFarBSXHjyJv+3c4s+97mDs7HM6VSKUYl5yCpIzFiEtJhYfn6EzQkXix3ySxGk2xWW5stSWpulb+K65r6fNYT5kEUyM1mBMXgNRxgUiJ8Yevgomq0WY0xSeNLe4Sm6M2MXUhiUTilJhKTU3FrFmz8K9//QuA7RsWFRWFn/3sZ3jkkUcGfY/77rsPmZmZ+NGPftTr/vb2drS3n1/hw2QyISoqCgaDgYkpIhdhfLqHXFMLNpbp8aW+AZYe+9L9/bAmIggLA5SQjqKpbgOJzfaWZpzaswv52VtRcbLAab/C1w+J89Khy1iMkLjxnOpHQ4L9JonVaI7NyobWrhFVtil+Rf0kqjykEkyJUCM1LgBzxgUwUTVKjOb4JPfmLrFpMpng7+/vXompjo4O+Pj4YNOmTQ7JqpUrV8JoNOLTTz+96DWrq6vh4+MDpVKJhoYGzJ8/H++99x6mTJnS6/FPPPEEnnzySaftR48ehVKpvKTnEgNBEFBfX4+AgAC+KSLRYXy6lyqzFR+a2vFpYzuaetQPj/GU4maVAkv95PCSiv97PdjYbKytQcnBfSg+uBetDQan/crgUMSkpCJ6xix4qzQuaDGNFew3SazcKTb1TZ04UtmMIxUtOFzRjNKGjj6PlUqAiVpvJIf7IDncF5NDfeDLGlWi407xSe7FXWKzsbERU6dOda/EVEVFBSIiIrB7927MnTvXftzDDz+MHTt2YO/evRe95r59+7BmzRp70fP7778fa9eu7fN4jpgiGn6MT/fUbLHg/SoDXimrRVGb4x/z/h4y3BEeiDvDAxGiEO80t0uNTcFqRWn+MeRnZ+H03l0wd/SY6ieRImZqMnQZixGfkgoPuXyom05ujv0miZU7x2aNqc1eMH1vYT3O6pv7PFYqASZHqJE6LgCp4wIwM9YfKi/x/r4bK9w5Pml0c5fYHMyIqTE1xnT27Nk4fPjwgI9XKBRQKBRO26VS6agOEOD8M4z25yD3xPh0P0qpFPdEBeOuSC2+rTXhxdIa7Gmw/RFvMFvwz5Ia/LtUj2uDNVgbpcUUpc8It7h3lxSbUilip05H7NTpaL/rpzi1dyfyd2ShrOA4AEAQrCg6kouiI7lQ+Ppi4tw0JGVcgbCEiaP6UzIaXuw3SazcNTZDNT64droPrp0eCQCoaWzDvkLbin97z9XjdE2T/VirABwta8DRsga8lFMIqQRIClfba1TNGhcAtTcTVSPBXeOTRj93iM3BtH3UJKaCgoIgk8lQXV3tsL26uhqhoaEj1CoiIhoMmUSCq7VqXK1V42hjCzaW6vFJjQFmAegUBGyqNmBTtQHzNH5YG6XFlYGqUVWH6mIUPj6YsugqTFl0FYxVlcjLzkJ+dhZMetvvtvbmZhz9bguOfrcF/uGRSErPhC49E8rAoBFuORER9SdY6YVlU8OxbKptYYzapnZ7omrPuTqcqnZMVB0rb8CxcluiSiIBdGEqzImzrfo3OzYAah8mqoho7Bg1iSm5XI6UlBRs3brVPr3ParVi69ateOCBB0a2cURENGhTlT74ly4Gv4sPw2tltXirog4Gs61U+m5jE3YbmxDnrcDqyCD8OCwAvjL3qs+hCQ3D/BW3Yd6PbkFZwXHk7diKU3t2obO9DQBgqCjDzvffxM4P3kLMlGQkZSzG+Flz4KnwGuGWExHRxQT5KfCDKWH4wZQwAEBdV6Jqb1ey6kRVo/1YQQDyKkzIqzDhlZ22RNWkUJWtmHpcIFLHBUDjw2neROS+RJWYampqwpkzZ+xfFxYW4vDhwwgICEB0dDQeeughrFy5EjNnzsTs2bPx3HPPobm5GatWrRrBVhMR0eUIU8jxWHw4fhEbig+r6vFSmR5nWmz1/c61tuOx0+V4prAKPwkPxN0RQQj3cq8/ziVSKaKSpiIqaSoy77oXp/fuRt7271Caf8x2gCCg+OghFB89BLm3DybOS0NS+mKET5zEqX5ERKNEoJ8CS6eEYWlXoqq+uaMrUVWHPefqcaLKhO7Kv4IA5FeakF9pwmu7igAAiaHKrhFVAZg9LhABvu71u5CIxjZRFT/fvn07Fi1a5LR95cqVeP311wEA//rXv7Bu3TpUVVUhOTkZzz//PFJTU13arvXr12P9+vWwWCw4derUgIp3iZm7FFMj98T4JKsgYGudCRvL9MgxNDns85AAy7UarIkKxnTV8NahGu7YbKipQn72NuTt+A4NNdVO+/3DwqFLXwxd+iKogoJd3h4SL/abJFaMzYEztnR0Tf2zJavyK88nqnozMURpq1HVNaIq0M+5Li71j/FJYuUusWkymaBWq0f3qnxiNJgXVszcJdDJPTE+6UJ5Ta3YWKrHx9UGdPT4dZWq9sWaKC2uDlJDNgwjh0YqNgWrFeUn8pGXvRUnv9+JzrZWxwMkEkQnTUXSwiuQMHsup/qNQew3SawYm5euoaUT+4u6alQV1iG/wgRrP+/aEoL9zteoGhcArZKJqothfJJYuUtsMjHlIkxMEbke45N6U9PeidcravF6eS3qOy0O+6K95FgdGYRbwgKh9HBdHSoxxGZnWxtO79uNvB1bUZJ3FD0/Tpd7e2PCnAVIyliMiMQkTvUbI8QQm0S9YWwOnYbWThwoOl+j6nh5Q7+JqvHBfkgd11WjKi4AwUp+aNET45PEyl1ik4kpF2Fiisj1GJ/Un1aLFZurDdhQqsepljaHfUqZFLd21aGK9h76T4rFFpsmfQ3ys7OQl70VxqpKp/2akDDoMjKRlL4YKi2n+rkzscUmUTfGpuuY2jpxsMjQNaKqHsfLG2DpJ1MVp/W1F1KfExeIEBUTVYxPEit3iU0mplyEiSki12N80kAIgoAdhkZsKNVjW32jwz4pgB9o1bg3Khgz1b5Ddk+xxqYgCKg4WYC8Hd/h5Pc56GhtdTomKmkqkjIWIyF1HuRe3iPQSnIlscYmEWNz+DS1m3Gg6HyNqqNl/SeqxgX52mpUjbNN/wtVj71EFeOTxMpdYpOJKRdhYorI9RifNFgnm9vwUqkem6rr0dbjj/AZKh+sidRimVYDD+nlTWsbDbHZ2d6GM/v3IG/HVhQfO+w01c9T4WWb6rdwMSITkyAR6XPQ4IyG2KSxibE5cprbzThY3DWi6pwtUWXuJ1EVE+iDOeNs0/7mxAUiXOP+H2IwPkms3CU2mZgaYlyVj2j4MD7pUtV2mPFmRS1eK6+FvsPssC9C4Ym7I7W4LSwAak+PS7r+aItNU60eBTnbkLdjKwyV5U77VdoQJGVkQpe+GJqQ0BFoIQ2V0RabNHYwNsWjpcOWqNp7zlaj6kiZEZ2Wvt8GRgf4ONSoivQf3pVwhwPjk8TKXWKTiSkX4YgpItdjfNLlarda8Um1ERvLapDX5FiHykcmxS2hAbgnSovYQdahGq2xKQgCKk+ftE31252D9pZmp2MiJ01GUsZiTJgzH3Jv93vz4e5Ga2yS+2NsildrhwW5JbYRVXvP1eNwqREdFmufx0f6e3dN+7Mlq6IC/p+9+w6vs67/P/48J3vvPZrRNKu7TdOZtEnZoIIIgmwVUdCv4kSZAu6fO18RvywFBUQREQFt0ibde+akaWbT7L33Oef3R0qglmJbmpyR1+O6vLi478PpO/jiTs4r9+dzO/73CuVT7JWzZFPF1BRRMSUy9ZRPuVCsVitbu/v57Yk2/t3Re8o5A3BpaAB3xoWxPMDnrJ5e5wzZHBsdoWrPzomlfgf3Y7We+iHE1cODOctWkrl2PXEZ87TUz0E4QzbFOSmbjmN47J2iqpOd1R3sr/vgoiom0Gti2d/JParigr0c7kmwyqfYK2fJpoqpKaJiSmTqKZ8yFSoHJ/aherm5k6H/2GNjvq8Xn4sL46rwQNw/IHPOls2+znbKNm+idNMGOhvrTzvvFxpGZk4eGbn5BEVGT/+ActacLZviPJRNxzU8ZmZ/XTc7ayb2qNpX183o+JmLqqgAz1Oe+jcrxNvuiyrlU+yVs2RTxdQUUTElMvWUT5lKXWPjPN/YwVP17TSPjp1yLtLdjTtiQ7k5OoSg99mHylmzabVaaa46RummQo5uK2Zk4PSlfjFpGWTk5JO6Yg0e3o6/fMPZOGs2xfEpm85jeMzMwRPd7KyZ2KNq7/EuRj6gqIr095zcSD07MZjE0LO7O3k6KZ9ir5wlmyqmpoiKKZGpp3zKdBi1WHi9tZvf1rdxqG/olHNeRgPXndyHarb3xOOzqwdH+GNjO+Wd3aQGB3JjdChJ3ue2R5UjGB8dpWrvLkqLN1B7YN/pS/3cPUhZtoKM3Hzi587HaHSx0aTyXrpuir1SNp3XyLiZQ/U97KjqYGdNJ3uOdzI8duaiKtzPg+ykd/eoSrKDokr5FHvlLNlUMTVFVEyJTD3lU6aT1WplZ88AT55o4832Hv7zG+L6EH/meHvwxIk2DIAVJv/607Q4PhkVMu0zT5f+rk7Ktkws9euorzvtvG9I6MRSv5x8gqNjbDChvEPXTbFXyubMMTpu4XBDNztOPvVvT20XQ2PmM74+1NeD5UnBZCeFsCIpmOQw32kvqpRPsVfOkk0VUxdYQUEBBQUFmM1mjh07pmJKZAopn2IrtUMj/F99G39q6mTgAzZ8fYcR2JqdTqIT3jn1XlarlZbqSkqLCzm6tZjh/r7TXhM1J425ueuZs2I1nj6+NphyZtN1U+yVsjlzjZktHKrvOblHVSd7ajsZHP2gosp98ql/2UkhpIRPfVGlfIq9cpZsqpiaIrpjSmTqKZ9iaz1j4/yxqZP/q2+jYWTsjK9zAb4QH853kmfOxuDjY2NU79tFaXEhNfv3YLWcWuC5uLkxO2sFc3PziZ+/UEv9pomum2KvlE15x5jZwpGGnsk9qnbXdDLwAUVViI87y05upJ6dFMyccD+MxgtbVCmfYq+cJZvn0p+cvruriIjIDBbg5srn48P5bGwYV++vYHfv4Pu+zgqcGB6d3uFszNXNjTnZq5iTvYqB7q6JpX7FhbTX1QJgHhujfFsJ5dtK8A0KJj0nj8ycfEJi42w7uIiI2JSbi5FF8UEsig/irtxkxs0WSht72VE9sUfV7ppO+kbGJ1/fMTDKm0eaefNIMwBB3m6TRdXypBBSIy58USUitqNiSkRE5H24Gg0sD/RlX+8g7/c7XQtQPjBM68gY4R5u0z2ezfkEBrH0yqtZcsXHaK2tprR4A0e3FDPU1wtM7FG1+7VX2P3aK0TNTiUjN5+0lTl4+mqpn4jITOfqYmRBXCAL4gL5XG4yZosV02RRNVFW9Q2/W1R1DY7xdmkLb5e2ABDo7cayhODJDdXTI/1VVIk4MC3lOwdayicy9ZRPsSfVgyOs3lnGB+045eti5CsJkXwmNhSPGZ5Z8/gY1fv3ULqpkJr9u7GYT630XNzcSF66nMzcPBLmL8booqV+F4Kum2KvlE05X2aLlbKmiaJqR3Unu2o66H1PUfWf/D1dWZb47lP/0qP8cfkvRZXyKfbKWbKpPaamiIopkamnfIq9ebGpg3uPnjjlqXwWwMNoYNjy7rfQRC93Hpkdw0Uh/jZ/BLY9GOzt4eiWTRwpLqSttvq08z6BQaSvWUdmbj6hcbNsMKHz0HVT7JWyKReK2WLlaHMvO08+9W9nTSc9Q2feB9LP05VlCe/uUZUR5Y+ry6kZVD7FXjlLNlVMTREVUyJTT/kUe1QzOMILje2Ud3aTGhzIp6JD8XN14Uc1TTzf2HHKHVVrg/x4JCWGVB9Pm81rb1prqzGVFGLavImh3p7TzkckpZC5dmKpn5ef435/tRVdN8VeKZsyVSwWK+UtfRMlVXUnO2s66Br8gKLKw5WsxGCyT+5TlRntj9GA8il2yVmunSqmpoiKKZGpp3yKvTpTNo/0DfJAZQPbuwcmj7kY4PaYUL6WEEmgm7ZzfId5fJyaA3sxFRdStXcXFvOpyzKMLq4kL11GZu56EhYsxsVV/+7Ohq6bYq+UTZkuFouVitb+k0v/Ju6o6hw48wNKfD1cWTIriNQgA5cuTmZebCBuLsqo2AdnuXaqmLrACgoKKCgowGw2c+zYMRVTIlNI+RR79UHZtFqt/KOth0eqGqgffvc3tsFuLnwjMYqbokJw1aaspxjs7eHo1hJMJYW0VFeedt47IJD01WvJXLuesPiE6R/Qgei6KfZK2RRbsVoniqqdJ/eo2lnTQXv/mYsqb3cXliYEszwpmOzEEObHBqioEptxlmuniqkpojumRKae8in26myyOWS28MSJVn55vJUhy7sL/NJ9PHk0JYbVQX7TNa5DaaurpbS4kLLNGxns6T7tfHhiMpm5+aStysXbP2D6B7Rzum6KvVI2xV5YrVaq2vrZXt05WVa194+c8fXe7i4smRU0sUdVYjDzYwNxd1WGZXo4y7VTxdQUUTElMvWUT7FX55LNxuFRHq9u4i8tXaccvyIsgAeTo5nl5TGVozosi9lM7cF9lG7aQNXenZjHT1/ql7Q4i8zcfBIXLdVSv5N03RR7pWyKvbJarVS19vHPvZVUdMPOmk5a+85cVHm6GVk66+QeVckTd1R5uOrJsjI1nOXaeS79iX6iExERucCiPd0pyJjFbTGh3F9Rz8G+IQDeaOthQ0cvd8WF86X4cHz0Q+0pjC4uJC3OImlxFkP9fZRvLaG0eAPNVRUAWMzjVO7eTuXu7Xj5B0ws9cvNJzwhycaTi4iIIzEYDCSF+fKRjGDi4+MxGAzUdgy+u0dVdSfNvcOTrx8es7Clsp0tle3wb/BwNbJkVhDZiSEsTwpmYXygiiqRD0F3TJ0D3TElMvWUT7FX55tNi9XKy82dPF7dRNvou3cARbi7cn9yNB+PCMJo0P5TH6Sjvo7S4kJMmzcy0NV52vmwWYlk5q4nfXUu3gGB0z+gjem6KfZK2RR79t/2jjzeMcjOmollfzuqO2jqGT7DO00UVYviA08u/QthUXwgnm4qquT8OMu1U0v5poiKKZGpp3yKvfqw2ewbN/OL4y08eaKN0fd8613s781js2NYHOBzIcd1ShazmeOH9lNaXEjlnh2Yx059NLjRxYXERUvJzM0naXEWLq5uNpp0eum6KfZK2RR7di75tFqtnOgcmrijqmbijqqG7qEzvt7d1cjCuImianliMItnBamokrPmLNdOFVNTRMWUyNRTPsVeXahs1gyO8EhVA2+1955y/BORQXwnKZpIj5lRpnxYw/39lG8vobS4kKaK8tPOe/r5k74qd2KpX2IyBie+K03XTbFXyqbYsw+bzxOdE0v/dtZM3FFV3/UBRZXLRFGVnRTM8qQQFscH4eWuokren7NcO1VMTREVUyJTT/kUe3Whs1nc2ccDFQ0cG3x3aYC3i5Evz4rgztgwPPWY6rPW0XAC08mlfv2dHaedD42bRWZuPulr1uETGGSDCaeWrptir5RNsWcXOp/1XYPsPLnsb2dNJ3Wdg2d8rZuLgQWx7xZVS2YF4e2u7Z9lgrNcO1VMTREVUyJTT/kUezUV2Ry3WHmusZ0f1zTTPW6ePB7v6c7Ds6O5LDTAqe/0udAsFjN1hw9OLPXbtZ3xsdFTzhuMRhIXLplY6rckG1c357g7TddNsVfKptizqc5nY/fQxB5VVZ3srOmgtuPMRZWr0cD82ICJPaqSQlg6KwgfDxVVM5WzXDtVTF1gBQUFFBQUYDabOXbsmIopkSmkfIq9mspsdo6N8+OaZp5raMfynuOrA315NCWGdF+vC/rnzQQjgwOUb99M6aZCGo+VnXbe08eX1FW5zM3NJyI5xaELQF03xV4pm2LPpjufTT1D7KzunNxQvaZ94IyvdTEamBczUVQtTwpmaUIwviqqZgxnuXaqmJoiumNKZOopn2KvpiObZf1DPFDRwJbu/sljRuCWmFC+kRhJsJt+KD0fnY0NmEqKKC0ppL+j/bTzIbHxk0v9fIOCbTDhh6PrptgrZVPsma3z2dI7fMoeVdVtH1xUzY0JYHnixNK/pQlB+Hk6x12/cjpbZ/NCUTE1RVRMiUw95VPs1XRl02q18lZ7Dw9XNnJ8+N2laIGuLnwtMZJbo0NxMzru3T22ZLGYOXHkMKUlhVTs3Mb46Mgp5w0GIwkLFpG5dj3JS7JxdXe30aTnRtdNsVfKptgze8tna+/wZEm1s6aTytb+M77WaIC5MQFkTxZVwQR4qahyFvaWzfOlYmqKqJgSmXrKp9ir6c7msNnC7+rb+NnxFgbN7y7wm+PtyaMpMeQG+035DM5sZHCQYzu2UFpcSMPR0tPOe/j4kLYyh8zc9UTOnmPXS/103RR7pWyKPbP3fLb1jbDrZFG1o7qDig8oqgwGyIz2JzsxhOVJISxLCCbAW0WVo7L3bJ4tFVNTRMWUyNRTPsVe2SqbzSNjfK+6kZebu045fkmoPw8nx5Do7TFtszirruZGTCVFmEqK6G1rPe18UHQsmbn5ZOSswy841AYTfjBdN8VeKZtizxwtn+39E0XVzuqJParKW/rO+FqDAdIj/U9uph5MdmIwgd6OcRewOF42z0TF1BRRMSUy9ZRPsVe2zua+3gHur2hgX++7T/VxMxi4My6ML8+KwM/VZdpncjZWi4UTpiOUFm/g2M6tjI+cvtQvft4CMteuZ3bWctzc7aMUtHU2Rc5E2RR75uj57BwYZdfJjdR3VHdwtPmDi6rUCL+Tm6mHkJ0YTJCPiip75ejZfIeKqSmiYkpk6imfYq/sIZsWq5W/tnTxWFUTzaNjk8fD3F35dlIU10cGY7TjJWeOZHRokGM7t1FavIF605HTzrt7eZO6cg2ZueuJnpNm06V+9pBNkfejbIo9c7Z8dg2Msqv25B5V1Z2UNffyQZ/00yL9JveoWpYYTIivffyyRZwnmyqmpoiKKZGpp3yKvbKnbA6Mm/lVXSu/OdHKiOXdb+Pz/bx4PCWWrAAfG07nfHpamyktLsJUUkhPa8tp54OiosnMXU/6mnX4h4ZN+3z2lE2R91I2xZ45ez57Bscmi6od1R2Ymj64qJoT4XvybqqJ5X+hKqpsxlmyqWJqiqiYEpl6yqfYK3vM5vGhEb5b1cgbbT2nHL8mIoj7k6KI9tRt+heS1WKh4aiJI8UbOLZ9C2Mjw6e+wGAgfu4C5ubmM3vZCtw8PKdlLnvMpggom2LfZlo+e4bG2F3Tyc6Ty/9KG3uwfEATMDvcl+VJwZNFVbjf9HxPE+fJpoqpKaJiSmTqKZ9ir+w5m1u6+nigooGygXeLEi+jkS/OCufzceF4udjXvM5gbHiYil0TS/3qjhw67by7lxdzlq8hc20+MakZU7rUz56zKTObsin2bKbns3d4jD21neyonthQ/XDDBxdVyWE+ZJ/co2p5YjDh/iqqpoqzZFPF1BRRMSUy9ZRPsVf2ns1xi5UXmjr4YU0TnWPmyeOxnm48mBzDVWEBNt0HyZn1trVSWlKIqbiI7pam084HRkSRkZtHZk4+/mHhF/zPt/dsysylbIo9Uz5P1Tc8xp7jXZN7VB1u6MH8AU1VUqgP2UnBk8v/IgNUVF0ozpJNFVNTRMWUyNRTPsVeOUo2u8fG+X+1zTzd0I75Pd/hlwf48FhKDHP9vG03nJOzWq00lJso3VTIsR2bGR0aOu01cZnzyczNZ072Ktw8L8wP8Y6STZl5lE2xZ8rnB+sfGWfvyaJqR3UHh+t7GP+AoiohxHuipDq5/C860Gsap3UuzpJNFVMXWEFBAQUFBZjNZo4dO6ZiSmQKKZ9irxwtm+UDwzxU0cCmrncfH20AbooO4ZuJUYS6u9puuBlgbGSYyl3bOVJcSN2Rg/znjrNunl7MyV5F5tp8YtMyMXyITDlaNmXmUDbFnimf52bgZFH1zh5VB090f2BRFR/sPblH1fLkEGJUVJ01Z8mmiqkpojumRKae8in2yhGzabVa+XdHLw9VNlAzNDp53N/VyFcTIrk9JhR3B/laHFlvextlmzdSWryBrqbG084HhEeQkZNHRk4+gRGR5/z+jphNmRmUTbFnyueHMzg6zr7j3RNL/2o6OHCimzHzmauFuGCviZIqKYTsxGDignUH95k4SzZVTE0RFVMiU0/5FHvlyNkcsVh4qr6dn9Y202+2TB6f7e3BI7NjyA9x3O9pjsRqtdJ47Cim4kKObithdGjwtNfEZswlMyefOctX4e51dj+0O3I2xbkpm2LPlM8La2jUzP66k0v/ajo5UNfN6Ht+5vhPMYFek3tUrUgKITbIS3thnuQs2VQxNUVUTIlMPeVT7JUzZLNtdIzvVzfxp6ZO3vvNPz/Yn0dSopntrY1Lp8vY6AiVu3dgKi6k9tD+05b6uXp4TCz1y80nLmPeBy71c4ZsinNSNsWeKZ9Ta3jMzL66LnZWd7KjuoP9J7oZHT9zURUd4Dm5R9XypBDig71nbFHlLNlUMTVFVEyJTD3lU+yVM2XzYN8gD1Q0sKtnYPKYqwE+HRvGVxMi8Xd1seF0M09fRzumzRsxFRfS2Vh/2nm/0DAyc/PJzMknMDLqtPPOlE1xLsqm2DPlc3oNj5k5cKJ7sqjaV9fFyAcUVZH+nhN7VCVNLP9LCJk5RZWzZFPF1BRRMSUy9ZRPsVfOlk2r1crfWrt5tKqRxpGxyeMhbq7clxTFDVHBuMyQHwDthdVqpbnyGKXFGzi6rYSRgYHTXhOTlkFm7nrmLF+Nh/fEUj9ny6Y4D2VT7JnyaVsj42YOnuiZ3KNq7/EuhsfOXFRF+Hu8u0dVUjBJoT5OW1Q5SzZVTE0RFVMiU0/5FHvlrNkcMJv537pWCupaGX7P03Xm+nrxaEoMKwJ9bTjdzDU+OkrV3p2UbtpA7cH9WK2n/rDu6u5ByrIVZOauJyYjk/r6BqfLpjg+Z71uinNQPu3L6LiFQ/XvbKbeyZ7aLobGzGd8fZifB9mJE8v+lieFkBzmPEWVs2RTxdQUUTElMvWUT7FXzp7NE8OjPFbVyGut3acc/0h4IA8kRxPn6W6bwYT+zg7KtmyitLiQjvq60877hYQSPX8xK666mpCYOBtMKPL+nP26KY5N+bRvo+MWDjd0s+Pk0r+9x7sYHD1zURXq6zGxP9XJsmp2uK/DFlXOkk0VU1NExZTI1FM+xV7NlGzu6O7ngYoGDvcPTR7zNBr4Qnw498RH4O3ivF+7vbNarbRUV04s9dtSzPBA/2mviZ6TTmZuPqkr1+Dh7WODKUXeNVOum+KYlE/HMma2cLihZ3KPqj21nQx8QFEV4uM+uZF6dmIIKeG+GI2OUVQ5SzZVTE0RFVMiU0/5FHs1k7Jptlp5samT71U30TE2Pnk82sONB5Oj+Wh4oMP+FtJZjI+NUb1vF6WbNlBzYC9Wy38s9XNzZ/ayFWTm5BE/fyFGoza0l+k3k66b4niUT8c2brZwpLF3YulfdQe7a7voHxk/4+uDfdxZlhA8uaF6aoSf3RZVzpJNFVNTRMWUyNRTPsVezcRs9oyN89PjLTxV38b4e35aWBbgw6MpMSzw87bdcDKpr7OD7f/4G42H9tFx4vhp532DQ8hYs46M3Hwt9ZNpNROvm+I4lE/nMm62YGp6p6jqZFdNJ30fUFQFerudLKom9qhKi7SfospZsqliaoqomBKZesqn2KuZnM3KwWEermxkQ0fv5DED8MmoYO5LjCLcw812w8lkNuPi4mg/XkNpcSFlW4sZ7us97bVRs1PJXJtP6oocPH21sb1MrZl83RT7p3w6N7PFiqmxl501Heyo7mBXTSe9w2cuqgK83FiWGDy5oXp6lD8uNiqqnCWbKqamiIopkamnfIq9UjahsKOXhyobqBwcmTzm62LkKwmRfCY2FI8Z+u/F1t4vm+bxMar37aa0uJCa/XuwmE/dh8PFzY3kpcuZm5vPrPmLMLpoqZ9ceLpuij1TPmcWs8VKWVMvO2s6J4uqnqGxM77ez9N1sqTKTgwhI3r6iipnyaaKqSmiYkpk6imfYq+UzQljFitPN7Tx/2qb6R1/d1+jRC93Hpkdw0Uh/tp/apr9t2wO9nRTtqWY0uINtB2vOe28T1Aw6avXkpmbT2jcrOkYWWYIXTfFnimfM5vFYuVoc9/E0r+aDnbWdNI9+AFFlYcrWYkn96hKDCEz2h/XKXogjLNkU8XUBVZQUEBBQQFms5ljx46pmBKZQsqn2Ctl81Rto2P8qKaZ5xs7eO8PEuuC/XhkdgxzfDxtNttMcy7ZbK2tnljqt3kjQ++z1C8yOYWM3HzSVuXi5es3VSPLDKHrptgz5VPey2Kxcqy1jx1VHeyo7mRXbSedA6NnfL2vhytLE4JO3lEVzLyYgAtWVDlLNlVMTRHdMSUy9ZRPsVfK5vs70jfI/RUN7OgZmDzmYoA7YkL5akIkgW6uNpxuZjifbJrHx6jZv5fS4kKq9+06famfqyvJS7LJyM0nceESLfWT86Lrptgz5VM+iMVipaK1f3KPqp3VnXR8QFHl4+7C0oRgspMmlv/NiwnA7TyLKmfJpoqpKaJiSmTqKZ9ir5TNM7NarfyjrYdHqhqoH373NvhgNxe+kRjFTVEhuNrJk26c0YfN5mBvD0e3FlNaXEhrTdVp570DAklfs47M3HzC4hMuwMQyU+i6KfZM+ZRzYbVaqWztZ8fJPap2VnfQ3n/mosrb3YUls4JOPvUvmHkxgbi7nl3OnCWbKqamiIopkamnfIq9Ujb/uyGzhd+caOVXx1sYsrz740WGjyffTYlhdZCWhk2FC5nNtnee6rdlE4M93aedD09MJjN3PWmrcvD2D/hQf5Y4P103xZ4pn/JhWK1WqtoGTu5RNVFWtfWNnPH1Xm7vFFXBZCeFMD82AA/X0+9Grmkf4KXddRxraGdOTCjXZ8WTGOozlV/KlFExNUVUTIlMPeVT7JWyefYahkd5vLqJv7Z0nXL8irAAHkyOZpaXh40mc05TkU3z+Di1B/dRWryB6r27MI+f+ohto4srSYuzyFy7nsSFS3Bx1ZJNOZ2um2LPlE+5kKxWKzXtA+yo7pzcUL2l98xFlaebkcXx7+5RtTA+kNcONPKtvxzCYDBgtVon//rDj8/nE0vjpvGruTBUTE0RFVMiU0/5FHulbJ67Xd393F/ZwKG+ocljHkYDn48L54vx4fi8z28K5dxNdTaH+no5uq2E0k2FtFRXnHbeyz9g8ql+4QlJF/zPF8el66bYM+VTppLVaqW2Y5Cd1RN7VO2o7qS5d/iMr3dzMTBmfv9qxmiAoq+uJcHB7pxSMTVFVEyJTD3lU+yVsnl+LFYrLzV38r3qJtpG373rJtLdjfuTo7gmIgijQftPfRjTmc32E8cnn+o30N112vmwhCQyc/JJX52Ld0DglM4i9k/XTbFnyqdMJ6vVSl3n4ORG6juqO2jsOXNR9V4uRgN35iTxzUvTpnjKC+tc+hPddy0iIiJTxmgwcENUCFeGBfKL4y08eaKNUauV5tEx7imr45mGdh5NiWGxv2P9FnCmCo2bRe5Nd7DmhlupPbSP0uIiqnZvn1zq11ZbzabaakpeeJrERVlk5uaRtDgLF1c3G08uIiJiOwaDgVkhPswK8eH6rHisViv1XUNsP1lU/fNwE0Nj5vf9Z995rTNTMSUiIiJTzs/VhfuTo/lUVAgPVzXwdnsvAHt7B7l8bwXXRQbxnaRoIjxUYDgCo4sLSYuySFqUxVB/H+XbNmMqLqSpshwAi9lM1Z4dVO3ZgaefP+mrc8nMySc8MRmD7pATEZEZzmAwEBfsTVywN9ctjSPc34Mni6t4v9V8BoOB2CCv6R9yGqmYEhERkWmT6O3Bc/OS2NTZy4MVjRwbnLiN/eXmLt5o6+HLsyL4bGwYni5aVuEovHz9WHjx5Sy8+HI66k9QWlJIWUkR/V2dAAz39bL/zdfZ/+brhMYnkJmbT/rqtfgEBtl4chEREftw3dI4fltc9b7nrFYr1zvg5ufnQj/1iYiIyLRbG+xPYVYqj6XEEHByE/QBs4XHq5vI3XWUN9u60TaYjickNo6cG2/js//7DB+/7xFSV+bg6uY+eb69rpbiPzzFbz9/K6/+8BGO7dzK+NiYDScWERGxvcRQH3748fkYDRN7ShkN4GKY+OsPPz7f4TY+P1e6Y0pERERsws1o4DOxYVwdHsSPa5v5fUM7FuD48Ci3H6llTZAv350dQ7qvc9++7oyMRhcSFi4hYeEShgf6ObZ9C0eKN9B07CgAVouF6n27qd63G09fP9JW5ZCZu56IpNla6iciIjPSJ5bGkZUQzIu76zjW0M6cmFA+mRXv9KUU6Kl850RP5ROZesqn2Ctlc+qV9Q9xf0UDW7v7J48ZgVtjQvl6YiTBbvp92vtxpGx2NtZjKimitKSI/o72086HxMZPLPVbsw7foGAbTCgXkiNlU2Ye5VPslbNk81z6E8f9KkVERMSppPt68crCZJ6em0C858TyLwvwTEM7K3eU8VR9G+MW/T7NkQVHx7L6k7fw2V8/xbXfeYz01WtxdfeYPN9RX0fJC8/w5Odv46/ff4jy7ZsZHx214cQiIiIy1fSrRxEREbEbBoOBy8MCyQv258n6Nn5+vIVBs4XucTPfqWjg940dPDo7hpxgP1uPKh+C0ejCrPkLmTV/ISODgxzbsYXS4g00HDUBYLVaqDmwl5oDe/Hw8SFt5cRSv8jZc7TUT0RExMmomBIRERG74+li5EuzIrguMpjHqxv5c3MXAOUDw1x3sIpLQ/15KDmGRG+P//JOYu88vL2Zl3cx8/Iupqu5EVNxIaUlRfS1twEwMjDAwX+/ycF/v0lwdCwZuflk5KzDLzjUxpOLiIjIhaBiSkREROxWpIcbv0qfxe3RoXynooH9fYMAvNXeS1FHH3fGhfHlWRH4nnyynzi2oMhoVl1/Mys/8SlOmA5TumkDx3ZtY3xkBJjYo2rLn55j64t/YNb8hWTm5pOctRw3dxWUIiIijkrFlIiIiNi9xQE+vLEkhb+0dPFYVSMto+OMWq38uq6Vl5s7+XZSFNdFBmPUMi+nYDAaiZ+7gPi5C8gf+jzHdmyltLiQ+rIjwMRSv9qD+6g9uA8Pbx9SV6whc20+USlpWuonIiLiYFRMiYiIiEMwGgx8IjKYy0MD+GVdK0+caGXEYqV1dJwvHz3BMw3tPJ4Sy9IA53+s8kzi7uXN3HUXMXfdRXS3NGMqKaS0uIjethYARgYHOFT4FocK3yIoKprM3PWkr1mHf2iYjScXERGRs6Gn8omIiIhD8XF14b6kKEqWpXFFWMDk8YN9Q1y5r4K7TcdpHNaT3JxRYEQkKz/xKT7zy99x3YPfIzN3PW4enpPnu5oa2fLi7/ndPXfw58fup2zzRsZGhm04sYiIiPw3umNKREREHNIsLw+empvIlq4+HqhooGxgooD4S0sX/2zr4UuzwrkrLhwvF/0eztkYjEbiMucTlzmfvDs+R8XObZQWF3Ki9NDEC6xW6g4foO7wAdy9vJizfGKpX0xqhpb6iYiI2BkVU2ehoKCAgoICzGazrUcRERGR/7A6yI9/L03l+aYOfljdRNe4mSGLhR/WNPNCUwcPJcdwZViACgkn5e7pRWZuPpm5+fS0tmAqKaK0pJCelmYARoeGOLLxXxzZ+C8CI6PIzMknIycP/7BwG08uIiIiAAar1Wq19RCOore3l4CAAHp6evD397f1OOfNYrFQV1dHfHw8RqN+iyz2RfkUe6VsOoausXH+X20zzzS0Y37PTzgrAn14LCWWTF8v2w03RZTN01mtVhqOllJaXEj59i2MDQ+d9pr4ufPJzF1PyrKVuHl6vs+7yIelbIo9Uz7FXjlLNs+lP9EdUyIiIuI0gtxceSwllpujQ3mwooHirj4AtncPcNHucm6KDuEbiVGEuutHIGdmMBiITZ9LbPpc8m77HBW7t1O6aQN1pYfg5O9k644cou7IITY89RvmLF/F3Nz1xKRlYHDgDwEiIiKOSD+ViYiIiNNJ9fHkxQVJ/Lujl4cqG6gZGsUC/L6xg7+1dvG1hEhujwnDzajlfc7OzdOTjDXryFizjt72VkwlGykt3kB3cxMAY8NDlG7aQOmmDQSER5CRk09mbh4B4ZE2nlxERGRmUDElIiIiTslgMHBxaAC5wX78X307P6ttpt9soXfcwoOVjfyhsYNHZseQF+K4y/Pl3PiHhrP8muvJvvo6Go8dpbR4A+XbNjM6NAhAT2sL21/5I9tf+SOxGXPJzF3PnOWrcPd0viWgIiIi9kLFlIiIiDg1D6ORu+PD+UREEN+vaeLFpk6sQMXgCDceqmZ9iD+PzI4m2Vv7DM0UBoOBmNR0YlLTWXfbnVTu3kHppg0cP3xgcqlfvekI9aYjFD39BCnZK8nMXU9cxlwt9RMREbnAVEyJiIjIjBDu4cbP0uK5NTqUByoa2N07AMCGjl6KO/v4dGwo9yZE4u/qYuNJZTq5uXuQviqX9FW59HW0n3yqXxFdjfUAjI0MYyopwlRShH9YOBk5eWTm5BMYGWXjyUVERJyDiikRERGZURb6e/P3xbP5W2s3j1Y10jgyxpjVyhMn2vhzcxffTorik1HBuBi0/9RM4xcSSvbV17HsY5+gqaJ8cqnfyOBEidnb1sqOv7zIjr+8SExaJpm5+cxZvhoPb28bTy4iIuK4VEyJiIjIjGMwGLg6IoiLQ/0pqGvlf+taGbZY6Rgb56vlJ3i2oZ1HU2JYHuhr61HFBgwGA9Fz0oiek8baWz9L1Z6dlBYXcvzgfqxWCwANR0tpOFpK0TO/nVjql5NP/Nz5WuonIiJyjlRMiYiIyIzl4+LCNxKjuCEqhEerGvl7azcAh/uH+Nj+Sj4aHsgDydHEerrbdlCxGTd3D9JW5pC2Mof+zg5MmzdSWlxIZ8MJAMZHRyjbvJGyzRvxCwmbWOqXm0dQVIyNJxcREXEMKqZERERkxovzdOfJzARuj+nngYoGjvQPAfBaazf/au/hC/Hh3B0fgbeL7oaZyXyDQ1j20WvJ+sjHaamq4EhxIeVbixke6Aegr6ONna++xM5XXyJ6TjqZa/NJXbEGD28fG08uIiJiv1RMiYiIiJy0ItCXt5fO4U9NnXyvupHOMTNDFiv/r7aFF5s6eSA5mo+GB2LQ/lMzmsFgIHL2HCJnz2HtLZ+heu/EUr+aA3uxWiaW+jUeK6PxWBkbn3mS2ctWkJmbT/y8BRiN2lxfRETkvVRMiYiIiLyHi8HATdEhXBUWwE+Pt/BUfRvjVmgYGeMu03GebmjnsZQY5vtpw2sBVzc35ixfzZzlq+nv6qRsyyZKN22go74OgPGxUY5uLebo1mJ8g0PIWLOOjNx8QmLibDy5iIiIfTjvYmpsbIzm5mYGBwcJCwsjODj4Qs4lIiIiYlMBbq48MjuGm6NDeLCigaLOPgB29QxwyZ5j3BgVzLeSoghzd7PxpGIvfIOCybrqGpZeeTWtNVUc2bSBo1uLGe6fyE5/Zwe7XnuFXa+9QlRKKpm5+aSuyMHTV5vsi4jIzHVOxVRfXx/PP/88L774Irt27WJ0dBSr1YrBYCA2NpaLL76YO++8k6ysrKmaV0RERGRazfb25I8LktnQ0ctDFQ1UDY1gBV5o6uTvrd18JSGSz8SG4q6nsclJBoOBiKTZRCTNJvfmT1OzbzdHijdQs3/P5FK/popymirK2fjc75i9dDmZa9cza/5CLfUTEZEZ56yLqZ/+9Kc8/vjjJCcnc9VVV/Htb3+b6OhovLy86Ozs5MiRI2zevJmLL76Y7OxsfvWrX5GSkjKVs4uIiIhMm/Uh/uQE+fJMQzs/qWmmz2yhz2zhu1WNPN/YwcOzo7koxF/7T8kpXN3cSMleSUr2Sga6uzi6tZgjmzbQXlcLgHlsjPLtmynfvhmfoGAy1qwjMzefkNh42w4uIiIyTQxWq9V6Ni+84YYbuP/++8nMzPzA142MjPDMM8/g7u7OHXfccUGGtBe9vb0EBATQ09ODv7+/rcc5bxaLhbq6OuLj4zHqt7tiZ5RPsVfKprxX2+gYP6pp5vnGDt77g9S6YD8emR3DHB/PaZtF2XQ8VquV1tpqTMWFlG3ZxFBf72mviUxOITN3PamrcvDy9bPBlB+esin2TPkUe+Us2TyX/uSsiylRMSUyHZRPsVfKpryfw32DPFDRwI6egcljLga4IyaUryZEEug29c+ZUTYdm3l8jOr9ezAVF1K9bzcWs/mU8y6uriQvySZz7XoSFizG6OI4S/2UTbFnyqfYK2fJ5rn0J3oqn4iIiMh5mufnzauLZvP3tm6+W9lIw8gYZiv8rr6dv7R08a3EKD4VHYKLlvfJGbi4upGStYKUrBUM9vZwdMsmSouLaK2tAsA8Ps6xnVs5tnMr3gGBpK9Zx9zcfELjE2w7uIiIyAVyQeu3iooKcnNzL+RbioiIiNg1g8HAR8OD2JydztcTIvEyTpRQnWNmvnGsnot2l7O1q8/GU4oj8PYPYPHlH+XmH/6Cm3/4S5Zc8VG8AwInzw/2dLP3H6/y3Nfv4fn7vsy+N19nsLfHdgOLiIhcABf0jqnR0VG2bNlyId9SRERExCF4uxj5amIkn4wK5vHqJv7a0gWAaWCYjx+o4oqwAB5MjmaWl4eNJxVHEJ6QRHhCEmtuvJ3ag3sp3VRI1d5dWMzjALRUV9JSXUnxH54ieckyMnLzSVy4BBdXLYgQERHHou9cIiIiIhdQjKc7/5sxi9uiQ7i/ooFD/UMAvNHWw4aOXj4fF84XZ4Xj40B7BYntvLPHVPKSbIb6ejm6tZjS4kJaqisBsJjHqdi1jYpd2/DyDyBjzVoycvIJT0iy8eQiIiJn55yKqbvuuoslS5awaNEi5s+fj7u7+1TNJSIiIuLQlgX68tbSObzY3Mn3qppoHxtnxGLl58dbeKm5k/uTorgmIgiD9p+Ss+Tl58+iS69i0aVX0V5XS2lJEaaSIgZ7ugEY6u1h7xuvsfeN1whLSGJubj5pq9fi7R9g28FFREQ+wDkVU4cPH+aFF15gYGAANzc3MjIyWLx4MUuWLGHx4sUOvWO8iIiIyIVmNBi4MSqEq8IC+VltC7+rb2PMaqVpZIy7y+p4pqGdR1NiWeTvbetRxcGExieQe9MdrLnhVmoP7ZtY6rdnB+bxiaV+bbXVbKytpvj5p0lclEXm2nySFi3FxdXNxpOLiIic6pyKqa1bt2K1WikvL2ffvn2T/3v11Vfp7u4G0G/9RERERP6Dn6sLD86O5qboEB6ubOBfHb0A7Okd5LK9x7g+MphvJ0UR4aHSQM6N0cWFpEVZJC3KYqi/j/Jtmykt3kBz5TEALGYzVXt2ULVnB15+/qStziUzdz3hCUn6uV1EROzCOe8xZTAYSEtLIy0tjRtvvHHyeHV1NXv37mX//v0XdEARERERZ5Hk7cHv5yexqbOXByoaqBgcAeCl5k7+0dbNl2dFcGdcGB66C13Og5evHwsvvpyFF19OR30dpcWFmDZvZKCrE4Chvl72v/k6+998ndD4BDJz80lfvRafwCAbTy4iIjOZwWq1Ws/mhXV1dcTHx5/1Gzc0NBATE3Peg9mj3t5eAgIC6Onpwd/f39bjnDeLxTL5/6eWX4q9UT7FXimbcqGNWaw819jOj2ua6Rk3Tx5P8HLn4eQYLgn1P6s7WpRN+SAWs5njhw9QumkDlXt2YB4bO+W8wWgkceESMteuJ2nxMlzdLtxde8qm2DPlU+yVs2TzXPqTs/4qs7Ky+NznPsfu3bvP+Jqenh5+97vfMXfuXP7yl7+c/cQiIiIiM4yb0cBnYsPYlp3OrdEhkz+U1Q6NctuRGq4/WEXZySf6iZwvo4sLiQuXcOWXv8ldT/yB9Z+5m6iU1MnzVouF6n27ef2n3+e3d91C4dO/obmqgrP83bWIiMiHdtZL+UwmE48//jgXXXQRnp6eLFmyhOjoaDw9Penq6sJkMlFaWsrixYv50Y9+xOWXXz6Vc4uIiIg4hRB3V36YGsetMaE8UNHA1u5+AEq6+lm/p5xbo0P5emIkQW7nvAODyCk8fX1ZcNFlLLjoMjob6yeW+pUU0d/ZAcBwfx8H3n6DA2+/QUhs/MRSvzXr8A0KtvHkIiLizM56Kd87hoaGeOONN9iyZQvHjx9naGiI0NBQFi1axCWXXMLcuXOnalab01I+kamnfIq9UjZlOlitVv7Z3sPDlY2cGB6dPB7k6sLXEyO5JToUV+Opy/uUTfkwLBYzdYcPUlpcSOWu7YyPjZ5y3mAwkrBwMZm560lesgxXd/dzeG9lU+yX8in2ylmyeS79yTn/6s3Ly4trr72Wa6+99rwHtLXBwUHS09P5xCc+wU9+8hNbjyMiIiICTDxk5oqwQPKD/fntiTZ+UdfCoNlC17iZb1c08FxjB4/NjmFNsJ+tRxUnYTS6kLBgMQkLFjMyOED59s2UFhfRWG4CwGq1ULN/DzX79+Dp40vqyhwy1+YTmTxHT/UTEZELYkbeE/7444+zfPlyW48hIiIi8r48XYz8T0IE10UF8XhVE6+0dAFQPjDMJw5WcVloAA/NjibBy8PGk4oz8fD2YX7+pczPv5SupgZKi4swlRTR19EGwPBAPwf//U8O/vufBMfEnVzqtxa/4FAbTy4iIo7sQxVT3d3dvPjii1RXVxMcHMyCBQtYt24dnp6eF2q+C66iooKjR49y1VVXceTIEVuPIyIiInJGUR7u/DpjFrfHhHJ/RQP7+wYBeLO9h8KOXj4XF8YX48JsPKU4o6CoGFZ/8mZWXfcp6koPUVpcSMXObYyPjgDQ2XCCzX98li1/+j2zFiwiMyeP5KzluLlPlKVdTQ0cLvoXTcdrqZuVwLy8iwmKcq4ndouIyIXxoRYsXnHFFTQ2NpKWlsYvf/lLfvWrX5GUlMQPfvCD83qSR0lJCVdddRXR0dEYDAb+9re/nfaagoICEhIS8PT0JDs7m127dp3Tn/G1r32N73//++c8m4iIiIitLAnw4Y0lKfwyPZ4I94nfK45arfyqrpXVu8t5o28Ui56iJlPAYDQya95CLr/nq9z12z9w8V1fIiYtc/K81Wqh9sBe3vjlj/nt527h37/7NVte/D3PfOUu9vzjVeoP7WPPP17lma/cxZFNG2z4lYiIiL36UMVUd3c33/3ud7njjjuIiIjgn//8J0ePHqWjo4Mvf/nL5/x+AwMDLFiwgIKCgvc9/9JLL3Hvvffy0EMPsW/fPhYsWMAll1xCa2vr5GsWLlzI3LlzT/tfY2Mjr732GnPmzGHOnDnn+yWLiIiI2ITRYOC6yGC2Zqfzpfhw3E/u79M6Os6j7YNcub+SvT0DNp5SnJmHtzfz1l3MJx/5IZ/+xe9Y/vEb8A8Lnzw/MjjAoQ1vsfPVl7FarVgtFjj5V6vVyr+e+AVdzY02/ApERMQenfNT+d7rzjvvJCcnh5tuuonFixezb9++yXOpqamUl5ef/2AGA6+++iof+9jHJo9lZ2eTlZXFr3/9a2Bit/q4uDi++MUv8q1vfeu/vud9993H888/j4uLC/39/YyNjfHVr36VBx988H1fPzIywsjIyOTf9/b2EhcXR1dXl57KJzJFlE+xV8qm2JvjQyN8t7qJN9t7Tzn+8fBAvp0URZSHm40mk5nEarFQf7QU08mlfmMjw2d8rcFoZOmVV7P6hluncUKR96fv62KvnCWbvb29BAUFndVT+T5UMTU2NsYjjzxCSUkJVVVV/OhHP8LDw4OdO3eyadMmdu/efb5vfVoxNTo6ire3N6+88sopZdWtt95Kd3c3r7322jm9/7PPPsuRI0c+8Kl8Dz/8MI888shpxw8dOoSfn+M+DcdqtdLZ2UlwcLCepiJ2R/kUe6Vsir3aNTjG/2vr57jl3Vx6GuDWQE9u8PfA06i8yvQYHxlh8+9+SeeJ42d8jXdQCEs/8SlCE2djcOAPXOL49H1d7JWzZLOvr4/58+efVTH1oTY/d3Nz47HHHqO3t5cNGzZw8OBBuru7mT17Nm+99daHeevTtLe3YzabiYiIOOV4REQER48evaB/1jvuu+8+7r333sm/f+eOqbi4OIe/Y8pqtRIXF+fQDaw4J+VT7JWyKfYq1mJhocdxNrv58pPjrXSNmxm2wm+7hvnnkJkHk6K5PNTfoX+4FcfRuGgpXQ0nJpbxvY/Brg5Knvwl/qHhpK9ZS/qaPIKioqd5ShF9Xxf75SzZ7O3t/e8vOumci6mxsTEuvfRSnnjiCVJSUgDw9/fnmmuu4ZprrjnXt7OZ22677b++xsPDAw+P0x/DbDQaHTog8O7X4Ohfhzgn5VPslbIp9srdxYXbY8O4JiqEn9Q082xjO2YrnBge47Om46wM9OWxlBgyfL1sPao4uXl5F7Pn9b/+19f1trey89WX2fnqy0TNSSMzJ5/UlWvw9PGdhilFJuj7utgrZ8jmucx+zl+lm5sbhw4dOtd/7EMLDQ3FxcWFlpaWU463tLQQGRk57fOIiIiI2JsgN1cenxNLYVYqOUHvfsDf1t3P+t3lfKP8BB2j4zacUJxdUFQMF9/1PxgMhomleif/ajAYWP/Zu7niS18nYeESDIZ3P4Y0HTvKhv8r4InP3czrP/sB1ft2YzGbbfhViIjIdDqvpXw33XQTTz31FD/4wQ8u9Dxn5O7uzpIlSygsLJzcY8pisVBYWMg999wzbXOIiIiI2Ls0Hy9eWpDMvzp6eaiygdqhUSzA7xs7eK21m68lRHJbTChu2n9KpsDcteuJScvgcOHbNB2vJWpWAvPyLyEocmLJXtqqXPo7OyjbWoypuJD2k3tSmcfGOLZjC8d2bME7IJD01blk5OQTnpBkyy9HRESm2HkVU+Pj4zz99NNs2LCBJUuW4OPjc8r5n/70p+c1TH9/P5WVlZN/X1NTw4EDBwgODiY+Pp57772XW2+9laVLl7Js2TJ+/vOfMzAwwO23335ef97ZKigooKCgALN+cyMiIiIOwmAwcEloAGuD/fjdiTZ+dryFAbOFnnEzD1Q28PvGdr47O4Z1IY67b6bYr6DIaFbfcOsZnyzlGxxC1lXXsPTKq2mtqcJUUkTZ1mKGensAGOzpZu8br7H3jdcIm5VIRk4e6avX4hMYZIsvR0REptB5PZVv3bp1Z35Dg4GioqLzGmbTpk3v+9633norzz77LAC//vWv+fGPf0xzczMLFy7kl7/8JdnZ2ef1552r3t5eAgICzmpXeXvmLI+fFOekfIq9UjbFXp1tNltHxvhedRMvNneecvyiEH8enh1NsrfnVI8qM8y5XjfN4+PUHNiLqaSQ6r27MI+fuuzUYDSSuHAJGTl5JC/JxtXdfapGlxlA39fFXjlLNs+lPzmvYmqmUjElMvWUT7FXyqbYq3PN5v7eQR6oqGdP7+DkMTeDgc/EhvKVhEj8XV2mclyZQT7MdXOov4/yrSWYSopoqiw/7byHtw+pK9aQkZtP9Jw0PXVSzpm+r4u9cpZsnkt/cl5L+d5hMpmoq6tjdHR08pjBYOCqq676MG8rIiIiIlNkkb83ry9O4dXWbh6taqRpZIwxq5XfnGjjz81dfDspiuujgnHRB32xIS9fPxZecgULL7mCjoYTmEqKMG3eSH9HOwAjgwMcKnyLQ4VvERgZRUZOHhlr8ggIj7Dx5CIicq7Oq5iqrq7m6quv5vDhwxgMBt656eqd31RoLyYRERER+2UwGLgmIohLQv359fFWfnOilWGLlfaxce4tP8GzDe08mhJDdqDvf38zkSkWEhPHmhtuZfX1N1NXeghTcSHHdm1jfGQEgO7mJra9/ALbXn6BuIx5ZOTkMWf5Kty9vG08uYiInI3zui/sf/7nf0hMTKS1tRVvb29KS0spKSlh6dKlbNq06QKPKCIiIiJTwcfFhW8mRVGyLI2rwgInjx/qH+Kj+yu5q7SW+uHRM7+ByDQyGI3MmreQy+75Kp9/8nku/cJXiMucf8prTpgO8/YTv+A3n7uZf/76/1F7aD8Wi35pLiJiz87rjqnt27dTVFREaGgoRqMRo9HI6tWr+f73v8+XvvQl9u/ff6HntCk9lU9EREScWbyXB7+bm8C2rn4eqKyntH8YgL+1dvN2ew93x0fwhfhwvF0cd68LcS7unl5k5uaTmZtPb1srps0bMZUU0tXUCMD4yAhlmzdStnkjviGhZKxeS0ZOPiGxcTaeXERE/tN5/XRhNpvx8/MDIDQ0lMbGiW8As2bNorz89M0JHd3dd9+NyWRi9+7dth5FREREZMqsDPLlX0tT+XFqLMFuE5ugD1ms/KS2mTU7y/hbSxd6bo7YG/+wcJZfcz23/+y33PDoT1hw0WV4+PhMnu/vaGfXa6/w7Fc/zwvf/gr73/4HQ329NpxYRETe67zumJo7dy4HDx4kMTGR7OxsfvSjH+Hu7s6TTz5JUlLShZ5RRERERKaJi8HAzdGhfCQskJ/WtvBUQxvjVmgYGeMu03GeObn/1Hw/7d8j9sVgMBA9J43oOWmsveWzVO/bRWlxITUH9mK1WABorqqguaqCTc/9H0mLs8jMzSdx0RJcXN1sPL2IyMx1XsXU/fffz8DAAADf/e53ufLKK1mzZg0hISG89NJLF3RAEREREZl+AW6uPJISw03RITxY2cDGzj4AdvYMcMmeY9wYFcy3kqIIc9cHerE/ru7uzFm+mjnLVzPY003ZlmJKSwppq60GwGIep3L3dip3b8fLz5+0Vblk5uYTnpg8+UAnERGZHgbrOdyPfeTIEebOnfu+5zo7OwkKCnLqC3lvby8BAQH09PTg7+9v63HOm8Vioa6ujvj4eIxG7RUh9kX5FHulbIq9mq5sbujo5aGKBqqGRiaP+bkYuTchkk/HhuKu/y7kP9jjdbPteA2lJUWUbd7IYE/3aedDYuPJyMkjY806fINDpn9AmTb2mE8RcJ5snkt/ck5f5fz588nOzuZ3v/sdfX19p5wLDg526lJKREREZCZbH+LPxmWpPJwcjd/JTdD7zBYeqWpk3a5yNnRozx6xf2GzEll786f53G+e45pvPUzqijW4uL17119HfR2b//gsT37hdl55/AHKtmxibGTYhhOLiDi/cyqmiouLyczM5Ktf/SpRUVHceuutbN68eapmExERERE74m40cld8ONuWp3NTVAjv/EqyamiEmw5Vc8PBKioG9CFe7J/RxYXERUu58svf5K7f/oGL7ryH6NSMyfNWq4Xjh/bzz1/9hCc+dzNvP/EL6k1HJveqEhGRC+eclvK9Y2BggJdffplnn32WzZs3M3v2bD796U9z6623EhkZORVz2lRBQQEFBQWYzWaOHTumpXwiU0j5FHulbIq9smU2D/cN8kBFAzt6BiaPuRrgjpgwvpoQQYDbeW1nKk7CEa+bXc2NmEo2Yioporet5bTzAeERpK/JIzMnj8DIKBtMKBeKI+ZTZgZnyea5LOU7r2LqvSorK3nmmWf4wx/+QHNzM5deeil///vfP8xb2i3tMSUy9ZRPsVfKptgrW2fTarXy97ZuvlvZSMPI2OTxYDcXvpUYxaeiQ3DRdg8zkq2z+WFYLRbqj5ZiKini2I4tjA4NnfaamLQMMnLySF2xBg9vHxtMKR+GI+dTnJuzZHNaiymYuIPqhRde4L777qO7uxuz2fxh39IuqZgSmXrKp9grZVPslb1kc9Bs4Td1rfy6roUhy7s/Xmb6evLo7FhWBvnabDaxDXvJ5oc1NjJM5e4dlBYXcvzwAfiPj0+ubu4kZy0nMyePWfMXYXRxsc2gck6cJZ/ifJwlm+fSn3yo+6tLSkp4+umn+ctf/oLRaOS6667j05/+9Id5SxERERFxQN4uRr6aGMn1UcE8VtXI31q7ASjtH+aaA5VcFRbIA8lRxHt52HZQkXPk5uFJ+uq1pK9eS19nO2WbN2EqKaKjvg6A8bFRyreVUL6tBJ/AINJWryUzN5+w+ASbzi0i4ijOuZhqbGzk2Wef5dlnn6WyspKVK1fyy1/+kuuuuw4fH93CKiIiIjKTxXq680RmArfH9PNARQOH+ieWQL3e1s2/O3r4fFw498wKx0d3lYgD8gsOZdlHryXrIx+npboSU0kRZVuLGe6beCrlQHcXe//xKnv/8SrhCclk5OSRvjoX74BA2w4uImLHzqmYuuyyy9iwYQOhoaHccsst3HHHHaSmpk7VbCIiIiLioLIDfXlz6Rxeau7ke1VNtI+NM2yx8rPjLbzY3Mn9SVFcExGEQftPiQMyGAxEJqcQmZxC7s13UL1/D6biIqr37cZiHgegtbaK1toqSl54moSFS8jMySNpSTaubm42nl5ExL6cUzHl5ubGK6+8wpVXXomLfsslIiIiIh/AxWDgxqgQrgoL5Ge1Lfyuvo0xq5WmkTHuLqvjmYZ2HkuJZaG/t61HFTlvLq5upGStICVrBYO9PZRvK8FUUkRzVQUAFrOZ6r27qN67C08fX1JX5pCRk0dUSqqKWRERzrGYctan7YmIiIjI1PFzdeHB2dHcFB3CQ5UN/LtjYtnTnt5BLt17jE9GBvPtpCjCPXQniTg2b/8AFl16FYsuvYqO+jpKS4oo27yR/s4OAIYH+jn4739y8N//JCg6lsycPNLXrMU/NNzGk4uI2I7jbvE+jQoKCsjIyCArK8vWo4iIiIg4rCRvD/4wP4k/zk8ixfvdTdBfbO5kxc4yfn28hRGLxYYTilw4IbHx5Nx4G58teJqPf+dR0levxdX93dx3Ndaz5cXf87t7Ps2fH/02pcWFjA4P2XBiERHbMFit//G8Uzmjc3ncoT1zlsdPinNSPsVeKZtirxw1m2MWK881tvPjmmZ6xs2TxxO83Hk4OYZLQv21zMnBOWo2p9Lo0CDHdmyltKSQetOR0867eXiSkr2SzNx84jLmYdC/tymjfIq9cpZsnkt/cs5P5RMRERER+bDcjAY+ExvG1eFB/KimiT80dmABaodGue1IDblBfjySEk2aj5etRxW5YNy9vJm77iLmrruIntYWTJuLMJUU0d3cBMDYyDCmkoljfiFhZOSsIyMnj+DoWBtPLiIydVRMiYiIiIjNhLi78sPUOG6NCeX+iga2dfcDUNzVR/7ucm6LDuVriZEEuenHVnEuAeERrPj4DSy/5pM0HjuKqbiQ8u2bGRkcAKCvo42dr77MzldfJmp2Khm5+aSuXIOXr5+NJxcRubD0HV5EREREbC7D14u/LEzmjbYeHqlq5MTwKGYrPNXQzl9buvhGUhQ3R4XgatTyPnEuBoOBmNR0YlLTWXfbnVTt3UlpcSG1B/dhPbnnWlNlOU2V5Wx67kmSliwjMzefhAVLcHHVxzkRcXy6komIiIiIXTAYDFwZHkh+iD+/PdHKL463MmSx0DVu5r5j9TzX0M6js2NYE6w7RsQ5ubq7k7piDakr1jDQ3UXZlk2Yigtpq6sFwDw+TsXObVTs3IaXfwDpq3LJyM0nPCFJe7KJiMNSMSUiIiIidsXLxciXEyK5PiqYx6uaeKWlC4CjA8N84mAVl4cG8NDsaGZ5efyXdxJxXD6BQSy98mqWXnk1rbXVmEoKKdtSzGBPNwBDvT3se/Pv7Hvz74TGzSIjN5/01WvxDQq27eAiIudIxZSIiIiI2KUoD3d+nTGL207uP3WgbxCAf7b3sKGjl7viwvjSrAh8XV1sPKnI1ApPSCI8IYk1N97O8UP7KS0upGrPDszj4wC0nzhOyfNPs/mFZ0lYsIiMnDySs5bj5q7yVkTsn4opEREREbFrSwN8+OeSFP7c3MXj1Y20jo4zarXyy7pWXmru5DvJ0VwbEYRRS5nEybm4upK0OIukxVkM9/dTvn0zpSWFNB07CoDVaqHmwF5qDuzFw9uHOStWk5GTR0xqhpb6iYjdUjF1FgoKCigoKMBsNtt6FBEREZEZyWgwcH1UMFeEBfCL4y389kQbo1YrLaPjfKmsjmfq23ksJYYlAT62HlVkWnj6+rLgostYcNFldDY2ULa5iNKSIvra2wAYGRzgcOHbHC58m4CISDLW5JGZm0dAeKSNJxcROZXBarVabT2Eo+jt7SUgIICenh78/f1tPc55s1gs1NXVER8fj9FotPU4IqdQPsVeKZtir2ZqNmuHRnikspE323tOOX5tRBDfSY4iysPdRpPJO2ZqNm3JarFwwnQEU0kRx3ZsYWxk+LTXxKbPJSMnjznLV+Ph7W2DKe2D8in2ylmyeS79ie6YEhERERGHk+DlwTPzEinp7OOBygbKByY+gL/S0sU/23v4n/gIPhcXhqeL4/5QL3KuDEYj8XPnEz93Pvl33EXFrm2UlhRRd+QgnLwfob7sCPVlRyh65rfMzlpOZk4e8fMXYjRqrzYRsQ0VUyIiIiLisHKC/ShcmsrvG9v5UU0z3eNmBs0Wvl/TxPNNHTw8O5rLQwO0v47MOG6enmTk5JGRk0dvextlWzZhKi6ks7EegPHREY5uLebo1mJ8g4JJX7OOjJw8QuNm2XhyEZlpVEyJiIiIiENzNRq4IzaMj0UE8ZOaZp5rbMdshRPDo3z6SC2rAn15NCWGDF8vW48qYhP+oWFkf+wTLPvotTRXHaO0uIjyrcUMD/QD0N/Vye6//4Xdf/8LEUmzycjJJ21VDt7+ATaeXERmAhVTIiIiIuIUgt1c+d6cWG6ODuHBygY2d0186N7a3c/63eXcHB3CNxKjCHHXj8AyMxkMBqJmpxI1O5W1t3yGmn27KS0pomb/biwnH/TUUl1JS3UlxX/4PxIXZZGZm0fS4ixcXN1sPL2IOCt9VxYRERERp5Lu68XLC5J5u72XhyobOD48igV4rrGDv7V28/XESG6NDsXNqOV9MnO5urmRkr2SlOyVDPb2cHRrMaaSIlqqKwGwmM1U7dlB1Z4dePr6kbYqh8ycfCKSU7Q0VkQuKBVTIiIiIuJ0DAYDl4YFsC7EjydPtPHz4y0MmC30jJu5v6KB5xraeTQlhrXBjvukZZELxds/gMWXfYTFl32E9rpaSkuKKNuyiYGuTgCG+/s48PYbHHj7DYJj4ib2rlqzDr+QUBtPLiLOQI8pERERERGn5WE08sVZEWzLTuf6yODJ4xWDI3zyYDW3HKqmenDEhhOK2JfQ+ARyb7qDOwue4eP3PULaqlxc3dwnz3c2nGDLn57jybtv58+P3Y9p80bGhodtOLGIODrdMSUiIiIiTi/Cw41fpMdzW0wo91fUs7d3EIB/dfSysbOPz8aG8ZWECPxcXWw8qYh9MLq4kLBwCQkLlzAyOMixHVsoLS6k4WjpxAusVuoOH6Du8AE2eHoxJ3sVmbl5xKbPxWDU/Q8icvZUTImIiIjIjLHI35t/LE7hry1dPFrVRPPoGGNWK/97opWXmzv5dnIUn4wMxqg9dEQmeXh7My/vYublXUx3SzOmkiJMm4voaWkGYGx4iNLiDZQWb8A/LJyMNevIyMkjKCrGxpOLiCNQMSUiIiIiM4rBYODjkcFcGhrAr+ta+d8TrYxYrLSPjXPv0RM829DOY7NjWBboa+tRRexOYEQkKz9xIyuuvYGGchOm4kLKt29hdGjiLsTetlZ2/PUldvz1JaLmpJGZk0/qyjV4+ui/JxF5fyqmzkJBQQEFBQWYTz5CVUREREQcn4+rC99MiuKTUcE8WtXIP9p6ADjUN8RH9ldydXgg9ydHE+Pp/l/eSWTmMRgMxKZlEpuWybrbP0fV7h2UlhRx/OB+rFYLAE3HjtJ07Cgbn3uS5CXZZObmk7BgMUYXLZkVkXcZrFar1dZDOIre3l4CAgLo6enB399xn+BisVioq6sjPj4eo9Z/i51RPsVeKZtir5TNC2drVx8PVDRgGnh3I2cvo4F74iP4fHw43i7693sulM2Zqb+zg7KtxZiKC2k/cfy0894BgaSvziUjJ5/whCQbTDhB+RR75SzZPJf+RHdMiYiIiIgAq4L8+HdWKi80dvCDmiY6x8wMWaz8uLaZPzZ18ODsaD4SFohB+0+JnJFvcAhZV13D0iuvprW2GlNxIWVbixnqnbgjcbCnm71vvMbeN14jbFYiGTl5pK9ei09gkI0nFxFbUTElIiIiInKSi8HALTGhfCQ8kJ/WtvB0QxvjVmgYGeNzpcd5JqCdR1NimOfnbetRReyawWAgIjGZiMRkcm66g5oDezGVFFK9dxfm8XEA2o7XUPyHpyh54RkSFy4hIyeP5CXZuLpr+azITKJiSkRERETkPwS6ufLdlBhuig7hocoGNnb2AbCjZ4CL9xzjU1EhfDMpkjB3NxtPKmL/XFxdmb00m9lLsxnq76N822ZMxYU0VZYDYLVYqN63m+p9u/Hw8SF1xRoycvKJnpOmOxRFZgAVUyIiIiIiZzDHx5M/zk9iQ0cvD1U2Uj00ghV4vqmD11q7+GpCJHfEhuLuwPuAiEwnL18/Fl58OQsvvpyOhhOUbd6IqWQjfR1tAIwMDHBow1sc2vAWQVHRZKzJIyMnD/+wcBtPLiJTRcWUiIiIiMgHMBgMXBQaQG6wH0/Vt/PT2mb6zBb6zBYermrkD40dPJISw/oQx304jogthMTEsfqTt7DqupuoKz2EqbiQY7u2MT4yAkBXUyNbX36erS8/T1zGPDJy85mTvRJ3Ly2lFXEmKqZERERERM6Cu9HI5+PDuTYyiB9UN/HHpk6sQNXQCDcdqiYv2I9HZseQ4uNp61FFHIrBaGTWvIXMmreQ/OEvULFzG6aSQupKD8PJh8ifMB3mhOkwhU//hpRlK8nIySN+7nyMRhcbTy8iH5aKKRERERGRcxDm7sb/S4vn1phQHqhoYGfPAABFnX2U7D7Kp2PCuDchggA3/agtcq7cPb3IzM0nMzef3vZWTCUbMZUU0tXUCMD4yAhlmzdStnkjviGhZKxeS0ZuPiExcTaeXETOl75bioiIiIich/l+3vxt0Wxea+3m0apGGkbGGLfCb+vb+HNLJ/clRXFjVAgu2rxZ5Lz4h4az/Jrryb76OpoqyjGVFHJ0WwkjAxNlcH9HO7tee4Vdr71CZHIKGbn5pK3MwctPy2pFHImKKRERERGR82QwGPhYRBAXhwbwv3WtFNS1MGSx0jlm5uvl9Tzb0M6js2NZGeRr61FFHJbBYCB6ThrRc9JYe+udVO/dSWlxITUH9mK1WABorqqguaqCTc/9H0mLs8jMzSdx0RJcXPXkTBF7p2JKRERERORD8nYx8rXESD4ZFcxjVY38rbUbgNL+Ya45UMlVYYE8ODuaOE932w4q4uBc3dyYs3w1c5avZrCnm7ItxZSWFNJWWw2AxTxO5e7tVO7ejpefP2mrcsnMzSc8MRmD7l4UsUsqpkRERERELpBYT3eeyEzgtph+Hqho4HD/EACvt3Xz744ePh8Xzj2zwvFx0YbNIh+Wd0AgS674KEuu+Chtx2soLSni6JZNDHR3ATDU18v+t15n/1uvExIbT0ZOHhlr1uEbHGLjyUXkvQxW68nHHMh/1dvbS0BAAD09Pfj7O+66ZYvFQl1dHfHx8RiNRluPI3IK5VPslbIp9krZtF9mq5WXmjr5XnUT7WPjk8ejPdy4Pzmaq8MDnfoODmVTbMFiNnP80H5Kiwup3LMD89jYKecNBiPx8xaQkZOHe0QMSbNnK59iV5zl2nku/YnumBIRERERmQIuBgM3RodwZXggP6tt5v/q2xmzWmkcGeMLpuM8U9/OoykxLPT3tvWoIk7D6OJC4qKlJC5ayvBAP8d2bKG0uIjGchMAVquF44f2c/zQflw9PEldsZq5ueuJScvA4MAlgIgjUzF1FgoKCigoKMBsNtt6FBERERFxMP6uLjw0O4abokN4uLKRf3f0ArC7d4DL9h7j+shgvp0URbiHNmkWuZA8fXyZn38p8/Mvpau5EVPJRkwlRfS2tQAwPjJM6aYNlG7aQEB4BOlr8sjMySMwMsrGk4vMLFrKdw60lE9k6imfYq+UTbFXyqbjKero5aHKBioGRyaP+boY+fKsCD4bF4aHk/z/qGyKPbJaLDQcNXGkeAPl27cwPjJ82mti0jLIyMkjdcUaPLx9bDClzGTOcu3UUj4RERERETuVF+LPmiA/nm1o58e1TfSOW+g3W3isuokXmjp4ZHYMF4X4O/X+UyK2YjAaic2YS3RaBrPzL2e0pQFTSRF1hw9itVoAaDhqouGoiY3PPEly1nIyc/KYNX8RRj20QGRKqJgSEREREZlmbkYDn40L4+qIIH5U08TzjR1YgJqhUW45XMPaID8eSYkh1cfT1qOKOC1Xd3eSVuWSsWYdfZ3tlG3ehKmkiI76OgDGx0Yp31ZC+bYSfAKDSF+zjoycPMLiE2w6t4izUTElIiIiImIjoe6u/Cg1jltjQrm/op7t3QMAbOrqI2/3UW6LDuVriZEEuenHdpGp5BccyrKPXkvWRz5OS3UlppIiyrYWM9w3sSfcQHcXe17/K3te/yvhCclk5uaRtioX74BA2w4u4gT0HU5ERERExMYyfb3468LZvNHWw8NVDdQPj2G2wlMN7bza2sU3EqO4KSoEV6OW94lMJYPBQGRyCpHJKeTefAfV+/dgKi6iet9uLOZxAFprq2itraL4+adJWLiEzJw8kpZk4+qmBxiInA8VUyIiIiIidsBgMHBleCD5If48caKVXx5vZchioXPMzLeO1fNcQzuPpsSwOsjP1qOKzAgurm6kZK0gJWsFg709lG8rwVRSRHNVBQAWs5nqvbuo3rsLTx9fUlfmkJGTR1RKqvaIEzkHKqZEREREROyIl4uRryREcn1kMI9XN/GXli4AygaGufZAFVeEBfBgcjSzvDxsPKnIzOHtH8CiS69i0aVX0VFfR2lJEWWbN9Lf2QHA8EA/B//9Tw7++58ERceSmZNH+pp1+IeG2XhyEfunYkpERERExA5Fe7pTkDGL207uP3WwbwiAN9p62NDRy11x4XwpPhwfVz0pTGQ6hcTGk3Pjbaz+5M3UHTmEqaSIip3bGB8dAaCrsZ4tL/6eLS/9gfjMeWTk5JOSvRJ3Ty8bTy5in1RMiYiIiIjYsawAH95cMoc/N3fxeHUjraPjjFis/OJ4Cy82dfCd5GiujQjCqKVDItPKaHQhYf4iEuYvYvTTn+fYjq2YSoo4YTo88QKrlbojh6g7cojCp35DSvZKMnPzicuYh8FotO3wInZExZSIiIiIiJ0zGgxcHxXMFWEB/OJ4C7890cao1UrL6DhfKqvj2YZ2Hpsdw+IAH1uPKjIjuXt5M3fdRcxddxE9rS2YNhdhKimiu7kJgLGRYUwlE8f8QsLIyFlHRk4ewdGxNp5cxPZUTImIiIiIOAhfVxe+kxzNp6JDeLiygbfaJx5lv693kMv3VfCJyCC+kxRNpIeeDiZiKwHhEaz4+A0sv+aTNB47iqm4kPLtmxkZHACgr6ONna++zM5XXyZqdioZufmkrlyDl68ebCAzk4opEREREREHk+DlwbPzkiju7OOBigaODQ4D8OfmLt5o6+HLsyK4MzYMTxctFxKxFYPBQExqOjGp6ay77U6q9u6ktLiQ2oP7sFosADRVltNUWc6m554kackyMnPzSViwBBdXfVSXmUNpFxERERFxULnBfhRlpfJcYzs/rmmme9zMoNnC96qbeL6xg4dnR3NZaIAeXS9iY67u7qSuWEPqijUMdHdRtmUTpuJC2upqATCPj1OxcxsVO7fh5R9A+qpcMnLzCU9I0n+/4vRUTImIiIiIODBXo4FPx4ZxdUQQP6lp5rnGdsxWqBse5Y4jtawO9OXRlBjSffVEMBF74BMYxNIrr2bplVfTWluNqaSQsi3FDPZ0AzDU28O+N//Ovjf/Tmh8Ahk5eaSvXotvULBtBxeZIiqmREREREScQLCbK9+bE8vN0SE8UNHAlu5+ALZ095O/u5xbYkL5RmIkwW76CCBiL8ITkghPSGLNjbdz/NB+SosLqdqzA/P4OADtdbWUPP80m194loQFi8jIySM5azlu7h42nlzkwtF3JRERERERJ5Lu68WfFybzVnsPD1c2cnx4FAvwbEM7f2vp4muJkdwaHYqbUcuDROyFi6srSYuzSFqcxXB/P+XbN1NaUkjTsaMAWK0Wag7spebAXjy8fZizYjUZOXnEpGZoqZ84PBVTIiIiIiJOxmAwcFlYIOuC/fldfRs/O97CoNlC97iZ+ysa+H1DB4+mxJAbrKeAidgbT19fFlx0GQsuuoyupgZMJUWUlhTR194GwMjgAIcL3+Zw4dsERkSRkZNHRs46AsIjbTy5yPlRMSUiIiIi4qQ8XYx8cVYEn4gM5nvVjbzc3AXAscFhrj9YxSWh/jycHEOit5YFidijoKgYVl1/Mys/8Snqy45QWlzEsZ1bGRseAqC7pYltf36BbX9+gdj0uWTk5DFn+Wo8vL1tPLnI2VMxJSIiIiLi5CI93Phl+ixuiwnl/ooG9vUOAvB2ey9FHX3cGRfGl2dF4OfqYuNJReT9GIxG4jLnE5c5n/w77qJi93ZKiwupO3IQrFYA6suOUF92hKJnfsvsrOVk5uQRP38hRqP+uxb7pmJKRERERGSGWOzvwz8Wp/DXli4eq2qieXSMMauVgrpWXm7u5NtJUVwfGYxRe9aI2C03T08y1qwjY806etvbKNuyCVNxIZ2N9QCMj45wdGsxR7cW4xsUTPqadWTk5BEaN8vGk4u8PxVTZ6GgoICCggLMZrOtRxERERER+VCMBgPXRgZzWWgAv6pr5TcnWhmxWGkbHecrR0/wTEM7j6fEkhXgY+tRReS/8A8NI/tjn2DZR6+lueoYppIijm4tYbi/D4D+rk52//0v7P77X4hImk1GTj5pq3Lw9g+w8eQi7zJYrSfv+5P/qre3l4CAAHp6evD397f1OOfNYrFQV1dHfHw8RqPR1uOInEL5FHulbIq9Ujblwzo+NMJ3qxp5o63nlOPXRARxf1IU0Z7u5/W+yqbYM2fO5/jYGDX7dlNaUkTN/t1Y/uMGC6OLC4mLssjMzSNpcRYurm42mlTej7Nk81z6E90xJSIiIiIyg83y8uCpuYls6erjwYoGTAPDAPy1pYs323r44qxwPh8XjpeL435AEplJXN3cSMleSUr2SgZ7ezi6tRhTSREt1ZUAWMxmqvbsoGrPDjx9/UhblUNmTj4RySkYtIxXbEDFlIiIiIiIsDrIj38tTeWFpg5+WNNE55iZIYuFH9U088emDh5MjuGqsAB9cBVxIN7+ASy+7CMsvuwjtNfVUlpSRNmWTQx0dQIw3N/Hgbff4MDbbxAcE0dGTh4Za9bhFxJq48llJtGvPUREREREBABXo4FbY0LZlp3OZ2NDcTnZQdUPj3FnaS1X76/kSN+gbYcUkfMSGp9A7k13cOf/PsPH73uEtFW5uLq9u1S3s+EEW/70HE/efTt/fux+TJs3MjY8bMOJZabQHVMiIiIiInKKQDdXHk2J5aboUB6qaGBT18RGyjt6BrhozzFuig7hm4lRhLrr44SIozEaXUhYuISEhUsYGRzk2I4tlBYX0nC0dOIFVit1hw9Qd/gAGzy9mJO9iszcPGLT52Jw4D2PxH7pO4mIiIiIiLyvVB9P/rQgiX939PJQZQM1Q6NYgT80dvBaaxdfTYjk9phQ3PVhVcQheXh7My/vYublXUx3SzOmkiJMm4voaWkGYGx4iNLiDZQWb8A/LJyMNevIyMkjKCrGxpOLM1ExJSIiIiIiZ2QwGLg4NIC1wX78X307P61tpt9soXfcwkOVjfyhsYNHZseQH+K4T60WEQiMiGTlJ25kxbU30FBuwlRcSPn2LYwOTSzf7W1rZcdfX2LHX18iek46GTl5pK5cg6ePr40nF0enYkpERERERP4rd6ORL8SH84nIIL5f3cSfmjqxApWDI3zqUDX5wf48khLNbG9PW48qIh+CwWAgNi2T2LRM1t3+Oap276C0pIjjB/djtVoAaDxWRuOxMjY+9yTJS7LJzM0nYcFijC4uNp5eHJGKKREREREROWth7m78NC2eW2NCeaCigV09AwAUdvZSvKuXT8eGcU14IK+3dlPeOUDqeBM3RoeS5O1h48lF5Fy5uXuQtiqXtFW59Hd1UrZlE6biQtpPHAfAPDbGsR1bOLZjC94BgaSvXktGTh7hCUk2nlwcicFqtVptPYSj6O3tJSAggJ6eHvz9HfdWZYvFQl1dHfHx8Ri1H4DYGeVT7JWyKfZK2RRbslqtvNbazXerGmkcGTvl3DtpNABW4KdpcXwyKmS6RxR5X7p2nj+r1UprbTWm4kLKthYz1Ntz2mvCZiWSmZtP2qpcfAKDbDCl43KWbJ5Lf6I7pkRERERE5LwYDAY+FhHExaEBFNS18KvjLYye/LW35T9ee+/RE2QH+JKoO6dEHJrBYCAiMZmIxGRybrqD2oN7KS0upHrvLszj4wC0Ha9h0+//j+LnnyZx4RIycvJIXpKNq7u7jacXe6RiSkREREREPhRvFyNfT4yifXSc3zd2cKYlGX9s6uA7ydHTOpuITB0XV1eSl2STvCSbof4+yrdtxlRcSFNlOQBWi4Xqfbup3rcbDx8fUlesITM3n6iUNAwGg42nF3uhYkpERERERC6InnHz5NK9/2QBXmnu4uORQaT5eE3zZCIy1bx8/Vh48eUsvPhyOhpOULZ5I6aSjfR1tAEwMjDAoQ1vcWjDWwRFRZOxJo+MnDz8w8JtPLnYmoopERERERG5IOI83fmgeyCaRsfI21XOtZFBfC0hkngvLesTcUYhMXGs/uQtrLruJupKD2EqKaJi5zbGRoYB6GpqZOvLz7P15eeJy5hHRm4+c7JX4u7lbePJxRZUTImIiIiIyAVxQ1QIBXWtH/gaC/BycxevtnRzS3QIX06IIMzdbXoGFJFpZTAamTVvIbPmLST/05+nYuc2TCWF1JUehpPPYTthOswJ02EKn/4NKctWkpmTT9zceRiNLjaeXqaLiikREREREbkgkrw9+GlaHPcePTG5pO+dv/5gTiy942Z+XddK97iZMauVpxra+VNzJ3fGhvGF+HD8XfVBVMRZuXt6kZmbT2ZuPr3trZRt3kRpcSFdTQ0AjI+MULZ5I2WbN+IbEkrG6rVk5OYTEhNn28FlyhmsVuuZ9iaU/3Aujzu0Z87y+ElxTsqn2CtlU+yVsin2qGZwhBca2ynv7CY1OJBPRYdOPo2vZ2yc35xo47cn2hiyvPvsvkBXF+6JD+eO2DC8XZRlmVq6dtoHq9VKU0U5ppIiyreVMDzQf9prIpNTyMjNJ21lDl5+jvs5/Gw5SzbPpT9RMXUOVEyJTD3lU+yVsin2StkUe/Xfstk2OsbPa1v4fWMHY+/5SBLp7sZXEiK4MSoEN6Oe2iVTQ9dO+zM+Nkb13p2UFhdSc2Av1vcU1wBGF1eSFmeRmZtP4qIluLg65xJgZ8nmufQnWsonIiIiIiLTLszdjcfnxPK5uDB+UtvMn5u7sALNo2N881g9vznRyjcSo/hYeCBGPVZexOm5urkxZ/lq5ixfzWBPN2VbijGVFNFaWwWAxTxO5e7tVO7ejpefP2mrcsnMzSc8MRmDrhEOTcWUiIiIiIjYTLyXB79Mn8UX4sP5YXUzb7b3AFA7NMoXTMcpqGvhW4lRrA/x14dPkRnCOyCQJVd8lCVXfJS2ulpKiws5umUTA91dAAz19bL/rdfZ/9brhMTGk5GTR8aadfgGh9h4cjkfKqZERERERMTm0ny8eGZeIvt6BvhedRNbuif2mintH+bmwzUsC/Dh20lRLA/0tfGkIjKdwuITWHvzp8m58TaOH9pPaXEhlXt2YB4bA6Cjvo7Nf3yWLX/6PbPmLyQjJ4/ZWctx8/C08eRytlRMiYiIiIiI3Vgc4MMri2ZT0tnH49WNHOwbAmBXzwAf219JXrAf306KYq6ft40nFZHpZHRxIXHRUhIXLWV4oJ9jO7ZQWlxEY7kJAKvVQu3BfdQe3Ie7lxdzlq8mMyefmLQMDA68V9NMoGJKRERERETsTk6wH2uC5vDP9h5+UN1ExeAIAEWdfRR19vHR8EC+mRhF0smn/YnIzOHp48v8/EuZn38p3c1NlJYUYSoporetBYDRoSGObPw3Rzb+m4DwiJNL/fIIjIyy8eTyflRMiYiIiIiIXTIYDFwRFsiloQH8ubmTH9c00zAysXzntdZu/tHWzQ2RIdybEEG0p7uNpxURWwiMjGLVdZ9i5bU30HDURGlJIcd2bGF0aOJuy57WFra/8ie2v/InYtIyyMjJI3XFGjy8fWw8ubxDxZSIiIiIiNg1F4OBT0aFcHVEEH9o7OBntS10jI1jtsLzTR38uaWT22NC+dKsCILd9BFHZCYyGI3EZswlNmMuebd/jsrdOygtLqTu8EGsVgsADUdNNBw1sfGZJ0nOWk5mTh6z5i/C6OJi4+lnNl21RURERETEIXgYjXwmNoxPRgbzZH0bv6lrpc9sYcRi5YkTbTzf2MHn48L5XFwYvq76oCkyU7l5eJK+ei3pq9fS19lO2eZNmEqK6KivA2B8bJTybSWUbyvBJzCI9DXryMjJIyw+waZzz1QqpkRERERExKH4urpwb0Ikt8WE8qvjLTzT0M6wxUq/2cKPa5t5uqGdL8+K4JaYEDy06bHIjOYXHMqyj15L1kc+Tkt1JaaSIsq2FjPc1wvAQHcXe17/K3te/yvhCclk5uaRtioX74BA2w4+g6iYEhERERERhxTs5spDs2O4My6Mn9a28MemDsxW6Bgb54HKBp440crXEiP5REQwrkaDrccVERsyGAxEJqcQmZxC7s13ULN/L6XFhVTv243FPA5Aa20VrbVVFD//NAkLl5CZm0/S4mW4urnZeHrnNuOKqYSEBPz9/TEajQQFBbFx40ZbjyQiIiIiIh9ClIc7P06N4/Nx4fyopom/tXYD0DAyxleOnuB/61r5ZmIUV4QFYDCooBKZ6Vxc3ZidtZzZWcsZ7O2hfFsJppIimqsqALCYzVTv3UX13l14+viSujKHzNx8ImfP0TVkCsy4Ygpg27Zt+Pr62noMERERERG5gJK8PXgiM4F74gf5fnUzhZ0TS3UqBkf4TGktC/y8+HZSNDlBvvpwKSIAePsHsOjSq1h06VV01NdhKinCtHkj/Z0dAAwP9HPw3//k4L//SVB0LJk5eaSvWYd/aJiNJ3ceM7KYEhERERER5zXXz5sXFiSxo7uf71c3sbNnAICDfUNcf7CKVYG+fCcpisUBely8iLwrJDaeNTfexqpP3kzdkUOYSoqo2LmN8dERALoa69ny4u/Z8tIfiM+cR0ZOPinZK3H39LLx5I7NrnYCLCkp4aqrriI6OhqDwcDf/va3015TUFBAQkICnp6eZGdns2vXrnP6MwwGA7m5uWRlZfHCCy9coMlFRERERMTeLA/05W+LZvP8/CQyfT0nj2/t7ufyfRXcdriaowNDNpxQROyR0ehCwvxFXH7PV/n8k3/gkrv+h7iMee++wGql7sgh3vrfn/HEnTfzZsFPqTtyEKvFYruhHZhd3TE1MDDAggULuOOOO7jmmmtOO//SSy9x77338sQTT5Cdnc3Pf/5zLrnkEsrLywkPDwdg4cKFjI+Pn/bP/utf/yI6OpotW7YQExNDU1MT69evZ968ecyfP3/KvzYREREREZl+BoOB9SH+5AX78VprNz+saaJ2aBSAt9p7ebu9l2sjg/h6QiTxXh42nlZE7I27lzdz113E3HUX0dPagmlzEaaSIrqbmwAYGxmeWP5XUoRfSBgZOevIyMkjODrWxpM7DoPVarXaeoj3YzAYePXVV/nYxz42eSw7O5usrCx+/etfA2CxWIiLi+OLX/wi3/rWt875z/j6179OZmYmt9122/ueHxkZYWRkZPLve3t7iYuLo6urC39//3P+8+yFxWKhrq6O+Ph4jHp8rtgZ5VPslbIp9krZFHtlr9kcs1h5sbmTnx1voXn03V9ouxkM3BQVzJdnhRPmridwOTt7zac4BqvVSlPFUUwlRRzbvoWRwYHTXhM5ew4ZOXmkrliDp6/fWb+3s2Szt7eXoKAgenp6/mt/Yld3TH2Q0dFR9u7dy3333Td5zGg0sn79erZv335W7zEwMIDFYsHPz4/+/n6Kioq47rrrzvj673//+zzyyCOnHT9x4gR+fmcfLHtjtVrp6urCYDBo00exO8qn2CtlU+yVsin2yp6zmQtkR/nwSu8Iv+8ZoddiZcxq5ZnGDv7U1MH1/h7cFOCBn4vjfiiUD2bP+RQH4enDnIuvInndpTSZDnN8305ajpVNLudrrjxGc+UxNj33f0RlzCN+8TIiUzMwurh84Ns6Szb7+vrO+rUOU0y1t7djNpuJiIg45XhERARHjx49q/doaWnh6quvBsBsNvPZz36WrKysM77+vvvu49577538+3fumIqLi3P4O6asVitxcXEO3cCKc1I+xV4pm2KvlE2xV46QzW8D94ybeeJEG0/WtzNosTBshed6RnhtYJwvxIVxR0wo3iqonI4j5FMcR2JyMiuv+hgD3V0c3VqMqaSI9rpaACzmcRoO76fh8H68/ANIW5lDRk4eYQlJ71s8OUs2e3t7z/q1DlNMXQhJSUkcPHjwrF/v4eGBh8fp68yNRqNDBwTe/Roc/esQ56R8ir1SNsVeKZtirxwhm4HuRr6VHM2n48L4xfEWft/QwajVSve4me/VNPNUQztfSYjkU1EhuBkd9+4FOZ0j5FMci19wCFlXXUPWVdfQWluNqaSQsi3FDPZ0AzDU28P+t15n/1uvExqfQEZOHumr1+IbFAxAV1MDh4v+RdPxWupnJTAv72KComJs+BWdv3P578phiqnQ0FBcXFxoaWk55XhLSwuRkZE2mkpERERERJxBmLsbj6XE8rm4cH5S08yfmzuxAC2j43zrWD2/qWvlG4mRXB0RhNGBl9eIyPQIT0giPCGJNTfezvFD+yktLqRqzw7MJx/W1l5XS8nzT7P5hWdJWLAIv9AwDhe+DQYDVquVhsP72fP6X7n4rv9h7tr1Nv5qppbDVMPu7u4sWbKEwsLCyWMWi4XCwkJWrFhhw8lERERERMRZxHm684v0eDYuS+Py0IDJ48eHR7m7rI783eX8q70HO32GlIjYGRdXV5IWZ3HVV77FXb99nvWfuZuoOWmT561WCzUH9nJow1tYrdaJPapO/tVqtfKvJ35BV3OjDb+CqWdXd0z19/dTWVk5+fc1NTUcOHCA4OBg4uPjuffee7n11ltZunQpy5Yt4+c//zkDAwPcfvvtNpxaREREREScTaqPJ0/PS2Rf7wDfr25ic1c/AGUDw9xyuIYsfx++nRzFikBfG08qIo7C09eXBRddxoKLLqOrqQFTSRGlJUX0tbed+R8yGDhS9C/W3HjbtM053ezqjqk9e/awaNEiFi1aBMC9997LokWLePDBBwG4/vrr+clPfsKDDz7IwoULOXDgAG+99dZpG6JfaAUFBWRkZHzgRukiIiIiIuJ8Fvv78OeFs/nzgmQW+nlPHt/dO8DV+yu54WAVh/sGbTihiDiioKgYVl1/M5/91VPEZc4/8wut0NPWOn2D2YBd3TG1du3a/3pL7D333MM999wzTRNNuPvuu7n77rvp7e0lICDgv/8DIiIiIiLiVNYE+/FmkC9vtvfwg+pmjg0OA7Cxs4+NnX18JDyQbyZGkuztaeNJRcSRGIxGombPob7syMQyvtNeAAFh4dM/2DSyqzumRERERERE7JXBYODysEA2LkvlF2nxxHq6TZ77e2s3ObuO8tWjdTQOj9pwShFxNHPXXQRnuknHamVu3sXTO9A0UzElIiIiIiJyDlwMBq6PCmZrdjqPpcQQ6jaxEMVshReaOlmxs4yHKhvoGB238aQi4giComK4+K7/wWAwYDAa4eRfDQYDF9/1PwRFRtt6xCllV0v5REREREREHIWH0chnYsO4ITKY39W3UVDXSp/ZwojFym9PtPFCYwd3xYVzV1wYvq4uth5XROzY3LXriUnL4HDh2zQdryVqVgLz8i9x+lIKVEyJiIiIiIh8KD6uLnw5IZJbYkL59fFWnm5oY9hipd9s4Se1zTzd0MaXZ0VwS3Qoni5atCIi7y8oMprVN9xKXV0d8fHxGI0z43oxM77KD0lP5RMRERERkf8m2M2VB2dHs315OrdEh+BimDjeOWbmwcpGVu0s449NHYxbPviBTyIiM4mKqbNw9913YzKZ2L17t61HEREREREROxfl4c6PUuPYsiydq8MDJ483jIxx79ETrNt9lNdbu//rE8lFRGYCFVMiIiIiIiJTINHbg99kJlCYlcr6EP/J4xWDI3y2tJZL9h5jU2evCioRmdFUTImIiIiIiEyhTF8vnp+fxGuLZrM8wGfy+KG+IT55sJqPH6hib8+ADScUEbEdFVMiIiIiIiLTIDvQl1cXzeaF+UnM9fWaPL6tu58r9lVw6+FqyvqHbDihiMj0UzElIiIiIiIyTQwGA/kh/vxr6RyeyJhFopf75Lm323vJ213OPabjHB8aseGUIiLTR8WUiIiIiIjINDMaDHwsIoiSZen8ODWWSHc3AKzAKy1drN55lPuO1dM6MmbbQUVEppiKqbNQUFBARkYGWVlZth5FRERERESciJvRwM3RoWxfns6DydEEuboAMGa18kxDO9k7yvheVSPdY+M2nlREZGqomDoLd999NyaTid27d9t6FBERERERcUJeLka+EB/OzhUZfGVWBN4uEx/VhiwWflnXSvaOMn51vIVBs8XGk4qIXFgqpkREREREROyEv6sL30yKYufydD4bG4q7wQBAz7iZx6ubWL7DxDMN7YxaVFCJiHNQMSUiIiIiImJnwtzdeDQllq3L0/lkZPDkB7fW0XHuO1bPmp1HeaW5E7PVatM5RUQ+LBVTIiIiIiIidirO052fp8ezaVkaV4QFTB4/PjzKPWV15O8u51/tPVhVUImIg1IxJSIiIiIiYufm+Hjy1NxE3lwyh5wg38njRweGueVwDVftq2BbV78NJxQROT8qpkRERERERBzEIn9vXl44m1cWJrPIz3vy+J7eQa45UMkNB6s41DdowwlFRM6NiqmzUFBQQEZGBllZWbYeRUREREREhNVBfvxzSQrPzE1gjrfn5PGNnX1cvOcYnz1SS+XgsA0nFBE5OyqmzsLdd9+NyWRi9+7dth5FREREREQEAIPBwGVhgWxclsov0+OJ83SfPPd6Wze5u45y79E6GoZHbTiliMgHUzElIiIiIiLiwFwMBq6LDGZLdhqPp8QQ5u4KgNkKf2zqZOXOMh6qaKB9dNzGk4qInE7FlIiIiIiIiBPwMBr5dGwYO5anc19iFP6uEx/3RixWflvfRvYOEz+uaaJv3GzjSUVE3qViSkRERERExIn4uLjwPwkR7Fyewd3x4XgaDQAMmC38v9oWsneY+O2JVobNFhtPKiKiYkpERERERMQpBbm58kByNDuWZ3BLdAiuE/0UnWNmHqpsZNXOMv7Y2MG4xWrbQUVkRlMxJSIiIiIi4sQiPdz4UWocm5elc01EECf7KRpGxri3/AS5u47y99ZuLFYVVCIy/VRMiYiIiIiIzACJ3h78b8YsCrNSuSjEf/J41dAId5bWcumeY2zs6MWqgkpEppGKKRERERERkRkkw9eLP8xP4u+LZrM8wGfy+KH+IW44VM01ByrZ0zNgwwlFZCZRMSUiIiIiIjIDLQv05dVFs/nj/CTm+XpNHt/ePcCV+yq45VA1Zf1DNpxQRGYCFVNnoaCggIyMDLKysmw9ioiIiIiIyAVjMBjIC/Hn7aVzeCJjFkleHpPn/tXRS97ucu42Hef40IgNpxQRZ6Zi6izcfffdmEwmdu/ebetRRERERERELjijwcDHIoIoXpbGT1LjiPJwA8AK/KWli1U7y/jWsXpaRsZsO6iIOB0VUyIiIiIiIgKAm9HATdEhbMtO56HkaILdXAAYt8KzDe0s32HisapGusfGbTypiDgLFVMiIiIiIiJyCi8XI5+PD2fn8gzuTYjAx2Xio+OQxcqv61rJ3lHGL4+3MGA223hSEXF0KqZERERERETkffm5uvCNxCh2Ls/gztgw3A0GAHrGzXyvuonlO8p4ur6NUYvFxpOKiKNSMSUiIiIiIiIfKNTdle+mcC94CQAAOAVJREFUxLBteTo3RAVPfpBsGx3n2xUNrN55lD83d2K2Wm06p4g4HhVTIiIiIiIiclZiPd35WVo8xcvSuDIsYPJ43fAoXyyrI393OW+19WBVQSUiZ0nFlIiIiIiIiJyTFB9P/m9uIm8tmUNukN/k8aMDw9x2pIYr91WwpavPhhOKiKNQMSUiIiIiIiLnZaG/Ny8tTOaVhcks9veePL63d5BrD1Rx/YEqDvQO2nBCEbF3KqZERERERETkQ1kd5Mcbi1N4dm4iqT6ek8eLu/q4dO8xPnOkhoqBYRtOKCL2SsWUiIiIiIiIfGgGg4FLwwIoykrlV+nxxHm6T577R1sPubuO8pWjddQPj9pwShGxNyqmzkJBQQEZGRlkZWXZehQRERERERG75mIw8InIYLZmp/G9lBjC3F0BsAB/aupk5Y4yHqxooH103LaDiohdUDF1Fu6++25MJhO7d++29SgiIiIiIiIOwd1o5I7YMHYsT+fbSVH4u058/By1Wnmyvo3sHSZ+VNNE37jZxpOKiC2pmBIREREREZEp4+PiwpdmRbBzeQb3xIfjZTQAMGC28NPaFrJ3mPhNXStDZouNJxURW1AxJSIiIiIiIlMuyM2V+5Oj2bE8g1ujQ3Cd6KfoHDPzSFUjK3eW8XxjB+MWq20HFZFppWJKREREREREpk2Ehxs/TI1jS3Y6H48I4mQ/RdPIGF8rP0HOrqO81tqFxaqCSmQmUDElIiIiIiIi0y7By4OCjFkUZaVycYj/5PHqoRE+V3qcS/Yco6ijF6sKKhGnpmJKREREREREbCbd14vfz0/i9cUprAj0mTx+uH+IGw9Vc/X+Snb3DNhwQhGZSiqmRERERERExOayAnz468LZ/Gl+EvN9vSaP7+gZ4Kp9Fdx8qBpT/5ANJxSRqaBiSkREREREROyCwWBgXYg/by2dw5OZCSR7eUye+3dHL/m7y/mC6Ti1QyM2nFJELiQVUyIiIiIiImJXjAYDHwkPpHhZGv8vNY5oDzcArMBfW7pYvbOMb5SfoHlkzLaDisiHpmJKRERERERE7JKr0cCnokPYlp3Ow8nRBLu5ADBuhd83drBih4lHqxrpGhu38aQicr5UTImIiIiIiIhd83Qxcld8ODuXZ/DVhAh8XCY+yg5ZrBTUtZK9w8QvalsYMJttPKmInCsVUyIiIiIiIuIQ/Fxd+HpiFDuXZ/C52DA8jAYAesctfL+mieU7yniqvo1Ri8XGk4rI2VIxJSIiIiIiIg4l1N2VR1Ji2Jadzo1RwZMfbNtGx/lORQOrdh7l5eZOzFarTecUkf9OxZSIiIiIiIg4pBhPd36aFk9JdhpXhQVOHj8xPMqXyurI213Om23dWFVQidgtFVNnoaCggIyMDLKysmw9ioiIiIiIiPyH2d6e/G5uAm8vncPaIL/J4+UDw9x+pJYr9lWwpavPhhOKyJmomDoLd999NyaTid27d9t6FBERERERETmDBX7evLgwmb8sTGaJv/fk8X29g1x7oIrrDlSyv3fQhhOKyH9SMSUiIiIiIiJOZVWQH/9YnMJz8xJJ8/GcPF7S1c9le4/x2dLj1IzqCX4i9kDFlIiIiIiIiDgdg8HAJaEBFGal8uv0eOI93SfPvdHew6ca+vhK+Qnqh0dtOKWIqJgSERERERERp+ViMHBtZDBbstP4/pxYwt1dAbAALzV3sXJHGQ9U1NM2OmbbQUVmKBVTIiIiIiIi4vTcjUZujwll+/J07kuMxM9oAGDUauV39e0s31HGD6ub6B3XEj+R6aRiSkRERERERGYMHxcXvhgfzl9i/bgnLgyvkwXVgNnCz463kL3dxP/WtTJktth4UpGZQcWUiIiIiIiIzDj+Lka+nRTFjuUZ3B4TipthoqDqGjfz3apGVu4s4w+N7YxZrDaeVMS5qZgSERERERGRGSvCw43vz4llS3Ya10YEYTh5vGlkjK+X15O76yh/a+nC8v/bu/O4qurE/+Pvy2WVTVkFAYFQFsMd12osTX9mjt+ZvjZZbumYJVlqOWlTqS1iOZl+jWwZS5uymnEymxZLK7XFBRdMBTdEQUXBhV1B7r2/PxzvDOGCppwLvJ6Px33k/Zxzz32f24ce8facz7VRUAHXA8UUAAAAAKDRa+nhplcTWurbpFj1C/Cxj+8/XaEHMw6q76Y9+uZEsWwUVMA1RTEFAAAAAMC/xXt5aHFitD7r2Eo9mnrZx3eUntZ9P+/X77bu08bCUgMTAg0LxRQAAAAAAL/Q2ddT/2x/gz5sF6223h728fVFZfrt1n0a+vN+7Sw9bWBCoGGgmAIAAAAA4AJMJpN6+fnoq06t9VabSMU0cbNvW3WiWL3TduuhnQeUXV5hYEqgfqOYAgAAAADgEkwmkwYGNdXqpDjNiQ1XqJuLfduy/ELdvDFTf9qdq6MVZw1MCdRPFFMAAAAAANSCs5NJ94b666eu8ZoREyo/F7MkqcomvXvkhLqtz9Cz+47o1Nkqg5MC9QfFFAAAAAAAV8Dd7KSx4UHa2C1Bj0c2l5f53K/WZ6w2vZabry7rMjT3wFGVVVkMTgo4PoopAAAAAACugpezWY9HNdeGbgkaGx4oNyeTJKnEYtWs7KPquj5Tfz1UoAqr1eCkgOOimAIAAAAA4Ffwd3XWjJgW+qlrvO4L8ZP5XD+l42er9NTew+q5IVMf5Z2UxWYzNijggCimAAAAAAC4Blq4u+rluAit6RKn3wY1tY8fOnNWj+7K0a0bd+uLgkLZKKgAO4opAAAAAACuoZgm7nqzTaS+7txat/p528f3lJ/RqB0HdMfmvfr+ZImBCQHHQTEFAAAAAMB10Na7iT5od4M+bh+jzj5N7ONbS8o1eFuWBqfv09bicgMTAsajmKqF1NRUJSQkKCkpyegoAAAAAIB6pkczL/2rYyu9mxileE93+/j3p0rVf/Mejdqerd1lZwxMCBiHYqoWkpOTlZGRobS0NKOjAAAAAADqIZPJpL4BvvomKVap8RFq6e5q3/bF8SLdunGXHs3MUe6ZSgNTAnWPYgoAAAAAgDriZDLpruZ++r5rnGa1DlOQq7MkySrpo6Mn1XN9pp7ae0gFlWeNDQrUEYopAAAAAADqmKuTk0a2CND6bgn6c3SIfJ3NkqRKm01/PXRcXddn6sX9eSqushicFLi+KKYAAAAAADBIE7OTxrcM1sZu8Xq0ZbA8nM79ml5useqVg8fUdV2GUnPyddpiNTgpcH1QTAEAAAAAYDBfF2dNjQ7Rhm7xGtUiQC4mkyTpVJVFz2UdUff1mXr38HGdtdoMTgpcWxRTAAAAAAA4iCA3F81sHaYfusZpcPNmMv17/GjlWf1pzyHdsjFTy46dktVGQYWGgWIKAAAAAAAH09LDTfPjW+rbpFj9vwAf+3j26Uo9lHFQt2/arVUnimWjoEI9RzEFAAAAAICDivfy0KLEaH3esZV6NvWyj+8sPaOhP+/X/2zdpw2FpQYmBH4diikAAAAAABxcJ19PLW1/gz5qd4PaenvYxzcUlWnQ1n26b9t+7SgpNzAhcHUopgAAAAAAqAdMJpN+4+etrzq11l/bRKpVEzf7tm9OFqvPpj16cOcB7S+vMDAlcGUopgAAAAAAqEdMJpPuDGqq75Li9EpcuFq4udi3fZJfqJs3Zmry7lzlVVQamBKoHYopAAAAAADqIWcnk4aE+OunbvF6LqaF/F2cJUkWm/S3IyfUfX2mZuw7rJNnqwxOClwcxRQAAAAAAPWYm5OTxoQHakO3eE2ObC4v87lf9c9YbVqQW6Cu6zL0yoGjKquyGJwUqIliCgAAAACABsDL2azHopprQ7cEPRgeKDcnkySpxGLVi9lH1XV9pv56qEAVVqvBSYH/oJgCAAAAAKAB8Xd11vSYFlrXNV5DQ/xlPtdP6fjZKj2197B6rM/Uh3knZLHZjA0KiGIKAAAAAIAGKdTdVX+JC9faLnEaFNTUPn644qwm7MpVr4279HlBoWwUVDAQxRQAAAAAAA3YDU3c9UabSK3s3Fq3+nnbx/eWV2j0jgPqv3mv1p4sMTAhGjOKKQAAAAAAGoFE7yb6oN0NWtYhRkk+nvbx9JJy3b0tS/+7dZ+2FJcZmBCNEcUUAAAAAACNSPemXvq0Y4z+lhilBE93+/gPhaW6Y/Ne3b89W7vKThuYEI0JxRQAAAAAAI2MyWTS7QG+WpUUq9cSWirSw9W+7cvjRbp1426NzzyonNMVBqZEY0AxBQAAAABAI+VkMun3wc30fZd4vdg6TMGuzpIkm6R/HD2lnht26ck9h1RQedbYoGiwKKYAAAAAAGjkXJxMGtEiQOu6Jeip6BA1dTZLks7abHr78HF1XZ+pWfvzVHS2yuCkaGgopgAAAAAAgCSpidlJD7cM1oZu8ZrQMlgeTudqg3KLVXMPHlPX9Zl69eAxlVusBidFQ0ExBQAAAAAAqvF1cdaU6BBt6Bav0S0C5GIySZIKqyx6fn+euq/P0OLDx3XWajM4Keo7iikAAAAAAHBBQW4ueqF1mH7sGqe7mzeT6d/jxyqr9MSeQ7p5Y6Y+PnZKVhsFFa4OxRQAAAAAALikCA83/V98S33XJVb9A3zt4wdOV2pcxkH1Sdutr48XyUZBhStEMQUAAAAAAGolztND7yRG6YuOrXRTUy/7eEbZGQ3fnq1BW/dpXWGpgQlR31BMAQAAAACAK9LR11NLO8To7+1uUDtvD/v4xqIy/W7rPg3ZlqXtJeUGJkR90eiKqezsbN16661KSEhQYmKiysrKjI4EAAAAAEC9dIuft1Z0aq2FN0aqVRM3+/h3J0t0+6Y9GrvzgPaXVxiYEI6u0RVTI0eO1LPPPquMjAytWbNGbm5ul38RAAAAAAC4IJPJpAGBTfVdUpzmxoWrhZuLfdvy/ELdvDFTj+/K1ZEzlQamhKNqVMXUzp075eLioptvvlmS5OfnJ2dnZ4NTAQAAAABQ/zk7mXRPiL9+6hav51u1kL/Lud+3LTbpvbwT6r4hU9P3HdaJyiqDk8KROFQxtXbtWg0cOFChoaEymUz65JNPauyTmpqqyMhIubu7q2vXrtq4cWOtj7937155eXlp4MCB6tixo2bOnHkN0wMAAAAAADcnJ/0xLFAbusXrT1HN5W0+Vz1UWG16PbdAXddn6OXsoyqtshicFI7AoYqpsrIytWvXTqmpqRfc/tFHH2nSpEmaNm2atmzZonbt2qlfv37Kz8+379O+fXvdeOONNR5HjhxRVVWVvv/+e7322mtat26dVq5cqZUrV9bV6QEAAAAA0Gh4OZs1KbK5NnRP0EPhgXJ3MkmSSi1WzT5wVF3XZ+rN3HydsVgNTgojOdR9bP3791f//v0vun3OnDkaM2aM7r//fknS66+/rs8//1xvv/22pkyZIklKT0+/6OtbtGihzp07Kzw8XJJ0xx13KD09Xbfffvu1OwkAAAAAAGDn5+KsaTEt9EB4oOYcOKYleSdksUknzlbpmX1H9EZugR6Laq67g/3k/O/yCo2HQxVTl1JZWanNmzdr6tSp9jEnJyf16dNH69atq9UxkpKSlJ+fr1OnTsnX11dr167V2LFjL7p/RUWFKir+8+0BxcXFkiSr1Sqrtf42uufz1+dzQMPF/ISjYm7CUTE34aiYm3BkzE9jBLs468VWLTS2RYBmHziq5QVFkqTDFWc1aVeuXsvJ1xORzXVHgI9MpsZZUDWUuXkl+etNMXX8+HFZLBYFBwdXGw8ODtauXbtqdQxnZ2fNnDlTt9xyi2w2m/r27as777zzovunpKRoxowZNcZzc3Pl7e19ZSfgQGw2m06dOiWTydRof9jhuJifcFTMTTgq5iYcFXMTjoz5aSxnSVO9TLrLxUuvnzqjn06fWwx9X3mFxmQcVLyrWQ/6uauLu3Oj+/fTUOZmSUlJrfetN8XUtXK52wX/29SpUzVp0iT78+LiYoWHhys8PFw+Pj7XK+J1Z7VaZbPZFB4eLicnh1pmDGB+wmExN+GomJtwVMxNODLmp2OIkNRH0obCMqVk52ljcbkkKbPSokePlqlnU09NiWquTj6ehuasSw1lbp6/46w26k0xFRAQILPZrGPHjlUbP3bsmJo3b35d3tPNzU1ubm41xp2cnOr1BJH+cw71/TzQMDE/4aiYm3BUzE04KuYmHBnz03F09/PW8mZe+uZkiVL2H9HO0jOSpB8LyzRwa5b+X4CPnogKUbyXh8FJ60ZDmJtXkr3enKWrq6s6deqkb775xj5mtVr1zTffqHv37gYmAwAAAAAAv4bJZFIffx+t7ByrBQktFenhat+24nixbkvbrYczDurg6YpLHAX1kUNdMVVaWqp9+/bZn2dnZys9PV1+fn6KiIjQpEmTNGLECHXu3FldunTR3LlzVVZWZv+WPgAAAAAAUH85mUz6XXAz3RnYVB/kndCcA8d0tPKsbJKWHjul5fmFGhrqr4ktgxXk5mJ0XFwDDlVMbdq0Sbfeeqv9+fn1nUaMGKFFixbpD3/4gwoKCvTMM8/o6NGjat++vVasWFFjQfRrLTU1VampqbJYLNf1fQAAAAAAgOTiZNLwFgEa3NxPbx8+rvkHj6mwyqKzNpveOXxcH+ad1APhgRoXHihfF4eqNnCFTDabzWZ0iPqiuLhYvr6+KioqqveLn+fk5CgiIqJe37OKhon5CUfF3ISjYm7CUTE34ciYn/VPcZVFC3Ly9cahApVbrPbxps5mJUcEaXRYoJqY6/+/y4YyN6+kP6FWdAA2m01Wq/XyO14jVqtVFotFFotFjtxLOjk51euvxwQAAAAAXBs+zmY9ER2iUWEBmnfwmN49fEKVNpsKqyx6YX+e/nqoQBMjm+veED+51uNCpzGimDLI+Rb06NGjV/Q1iteCzWZTWVmZ9u3b5/DFj5eXl4KDgxURESEXF+4fBgAAAIDGLNDVRc+3CtPY8CD9Jfuo/nH0pKySjlVWacqeQ1qQk68/RTXX74KbycnBf9/FORRTBrBarUpPT9eJEycUGBioFi1ayNnZuc5KIpvNptLSUnl5eTlsMWWz2WSxWHTq1CkdOHBABQUF6tSpE+UUAAAAAEDh7q6aFx+hcRFBenF/nr44XiRJOnimUsmZOXo1J19To0N0u7+Pw/7ei3MopgyQm5urEydOqGPHjvL396/z97fZbCouLpaPj+P/gIaFhamkpERpaWnKyspSXFyc0ZEAAAAAAA4i1tNdbydGaUtxmVL25+n7U6WSpMyyMxq+PVtJPp6aGh2iHs28DE6Ki+HGy1pITU1VQkKCkpKSrsnxjh49qoCAAENKqfrI29tboaGhOnbsmEOviQUAAAAAMEZHH0/9o32M/tHuBrX3bmIfTysu0+/T92nItiz9XFJuYEJcDMVULSQnJysjI0NpaWm/+ljnr1ailLoy/v7+qqioUEVFhdFRAAAAAAAO6mY/b33ZqZXevjFSrZq42ce/O1mivpv26IGdB5RVfsbAhPgliqk6ZrPZZLPZ5Ox84bsop0+fLi+vC19i+MttJpPpgg93d/cLvn7QoEEymUz629/+dsW5V69erZkzZ17x62pr+vTp+umnny66/fznZbFYrlsGAAAAAED9ZzKZdEdgU63uEqd5cREKc//PWsWf5hfqlo279NiuHB0+U2lgSpxHMVXPjR8/XuvWrav2WLt2bY39Tp48qRUrVkiSPvjggyt+n+tdTM2YMeOSxRQAAAAAAFfCbDLpDyF++rFrvJ5v1UIBLv++4MEmvZ93Uj02ZGravsM6UVllcNLGjcXP67mIiAh169btsvstXbpUlZWV6tOnj1atWqWCggL5+PjUQUIAAAAAAIzj5uSkP4YFakhzP711qECpOfkqsVhVYbXpjdwCvX/khB4MD9KD4YHycjYbHbfR4YqpRmLJkiWKiYnRnDlzVFVVpY8//rjWr50+fbpmzJihsrIy++2CvXr1sm/PzMzUoEGD5OvrK09PTw0YMEBZWVnVjvH222+rTZs28vDwkL+/v2666Sb7ml3nvxlw8uTJ9uOvXr36V58zAAAAAADneTqbNSGyuTZ0T9C48CC5O537XbTUYtVfDhxVl/UZeiM3X2csVoOTNi4UUw6qqqqqxsNqrfnDYbVaL7vfoUOHtHbtWt17771KTExUYmKili5dWussf/zjHzV69Gh5eHjYbxd87bXXJEn79+9Xjx49dPLkSS1atEhLlixRQUGBevfubV+ofO3atRo9erTuuOMOffHFF3r33XfVu3dvFRYWSpLWrVsnqfptiR07dryajw0AAAAAgEvyc3HWMzGhWtctXsND/WU+10/p5FmLpu07op4bMrXkyAlVWflW+LrArXy1kJqaqtTU1DpbeLusrEwuLi4X3Obp6Vnt+RNPPKEnnnii2ljv3r21atUq+/MPPvhANptN9957ryRpyJAhevLJJ5WVlaWYmJjL5gkLC1NYWJicnJxq3DY4Y8YM+fn5aeXKlfZF13v06KHo6GgtXLhQ48aN08aNG+Xn56fZs2fbXzdgwAD7n88fs7a3JQIAAAAA8GuFuLnqpdhwPRQepJey87Qsv1CSdLjirCbtztVrufl6IipEdwb62u/0wbXHFVO1kJycrIyMDPutZ9ebh4eH0tLSajzGjBlTY99HH320xn7nr2Y6b8mSJerYsaNiY2MlnSumTCaTlixZ8quzfv311/rtb38rZ2dn+xVbzZo1U4cOHeyfV8eOHXXy5EmNHDlSK1euVHl5+a9+XwAAAAAAroWoJm5a0CZS3yTFqo//f9Zi3ldeoTE7D6jf5j1afbJYNhtXUF0PFFMOyMnJSZ07d67xCA0NrbFvWFhYjf1at25t356Zman09HQNGjRIhYWFKiwslK+vrzp06HBV3873S8ePH9fcuXPl4uJS7fH9998rNzdXknTbbbfpb3/7m3bu3Kl+/fopICBAw4cP18mTJ3/1+wMAAAAAcC208fLQe22jtbxDjLr5/udupZ9LTuuebft1V3qWNheVGZiwYeJWvgbu/ffflyRNmzZN06ZNq7F9y5Ytv2o9Jz8/Pw0YMEDjxo2rsc3b29v+56FDh2ro0KE6fvy4li9frokTJ8rFxUULFy686vcGAAAAAOBa69rUS8s6xOjbkyVK2Z+nHaWnJUk/FZZqwJa96hfgoylRIYr38jA4acNAMdXAffDBB+rWrZtSUlLsYzabTYWFhbrnnnv0/vvv16qYcnV1tS9m/t/69OmjHTt2qEOHDjKbL/+1mgEBARo9erS++OILZWZm2sddXFx05syZWp4VAAAAAADXj8lkUm9/H93q561P8wv1Ynaesk9XSpK+Ol6sr48X667gZpoc1VwtPdwMTlu/UUzVczk5OVq/fn2N8Y4dO2rz5s3av3+/nnrqKfXq1cu+zWazqbi4WAMGDNCHH36o2bNny8np0nd1xsfHq6qqSvPmzVOPHj3k4+Oj2NhYzZgxQ0lJSerXr58eeOABBQcH6+jRo1qzZo1uvvlmDRkyRNOmTdOJEyfUq1cvBQUFafv27VqxYoUmTZpU7fjLly/XzTffLE9PT8XGxla74goAAAAAgLrmZDLpf4KbaUBgU3149IRezj6mo5VnZZO09NgpLc8v1H2h/prYMljBbhf+EjNcGmtM1XPz589X9+7dazzy8/O1ZMkSNWnSRP/7v/97wdcOHz5cR44c0erVqy/7PgMHDtS4ceOUkpKirl27auzYsZKkmJgYbdy4Uf7+/ho3bpz69eunKVOmqKysTG3btpUkJSUladeuXRo3bpz69u2rV155RZMnT652a2FqaqqsVqv69++vpKQkbd68+dd/OAAAAAAAXAMuTiYNCw3Qum7xeuaGUDVzPnfH0FmbTYsOH1e39RmamXVEhWerDE5a/5hsLCtfa8XFxfL19VVRUZF8fHwu/4ILsFqtWrVqlW688cYLLmZeF85fMeXj41NvvvLy1KlTSktLU8+ePeXp6Xn5F6DeslqtysnJUURExGWv5APqEnMTjoq5CUfF3IQjY37i1yqusmhBTr7eOFSgcovVPu7rbNbDEUEaFRYgz1osd/NLDWVuXkl/Un/Psg6lpqYqISFBSUlJRkcBAAAAAAAG83E264noEG3oFq8xYQFy/fdFH0VVFr2wP0/d12fq7UMFqrRaL3MkUEzVQnJysjIyMpSWlmZ0lOvCarWqqqrqog8uqgMAAAAAoKZAVxc91ypMP3aL1z3N/ewlS35llZ7ce1g3bdilpUdPysLv1RdFMQWNGjVKLi4uF32sWbPG6IgAAAAAADiscHdXzY2P0OoucRoQ6GsfzzlTqYczc9Q7bbe+Ol7EhR8XwLfyQdOnT9fDDz980e2xsbF1mAYAAAAAgPqptae7Ft4Ypa3F5UrZf0RrT5VKknaVndGI7dnq7NNEU6ND1LMZ30J/HsUUFBkZqcjISKNjAAAAAADQIHTwaaK/t4/RD6dK9EJWnraWlEuSNhWX6670LPVq5q2pN4SonXcTg5Maj1v5AAAAAAAAroObmnnri06t9M6NkWrdxN0+vvpUifpt2qM/7sjW3rIzkqT95RWauT9PT+eXaeb+PO0vrzAqdp3iiikAAAAAAIDrxGQyqX9gU/UN8NU/j53S7Oyjyj1TKUn6rKBIXxQUKcnXU2lFZTJJskn6tqxAr+UWaE5cuO4J8Tc0//XGFVO4YosWLZLJZKrxmDJlSrX99uzZo549e8rHx0cDBgxQfn5+te179+6Vn5+fDh06VJfxAQAAAACoc2aTSXc399MPXeP0QqsWCnQ9d62QVdKGojJZJVn+/fz8PyftylV2A79yimIKV23FihVat26d/ZGcnFxt+8iRIxUZGal//OMfys3N1aRJk6ptnzBhgh577DGFhYXVZWwAAAAAAAzj5uSk0WGBWt8tXlOjQuRquvi+JklL8k7UWTYjcCtfLaSmpio1NVUWi8XoKA6lU6dOCggIuOC20tJSrVu3TsuXL1dgYKAKCws1fvx4+/bPP/9cu3bt0scff1xXcQEAAAAAcBieZrMejQzWtpJyfXm8SLYL7GOT7Lf9NVRcMVULycnJysjIUFpaWp2835YtWzRo0CAFBgbK3d1dUVFRmj17dp2897VSWXnuB8fDw0OS1KRJE1VUVNi3TZw4UXPmzJGbm5thGQEAAAAAMNoNTdwuWs6YJIW7u9ZlnDpHMeVgcnNz9Zvf/EZhYWFasmSJvvrqK73wwgvq3LnzNXsPm82mqqqqyz4up02bNjKbzYqOjlZKSkq1K8r8/PwUHR2t+fPn6+TJk3rzzTeVlJQkSXrllVcUHR2tQYMGXbNzAgAAAACgPhoS4n/Bq6Wkc1dM3dvAFz/nVj4H8+233+rMmTMaNmyYOnToIBcXFzk5Xdv+cPHixRo1atRl98vOzlZkZGSN8ZCQEM2YMUNdu3aVyWTSp59+qqeeekqHDx/Wq6++at9vwYIFGjx4sJ588kmFhobqyy+/VF5enl566SX9+OOP1/KUAAAAAACol6KbuGlOXLgm7cq1fyvf+X/OiQtXVJOGfacRxZSDueWWWxQQEKDu3btLku699169//77V3WsvXv36g9/+IO2bNlSbXzgwIH67rvv5OnpKZPp4qushYaGXnC8X79+6tevn/1537595eHhoVdeeUV//vOfFRISYh8/evSocnJyFB0dLRcXFw0bNkwjR45UXFyc3n77bb3wwgsqLS3V0KFD9dJLL8lsNl/VuQIAAAAAUF/dE+Kvrr5eev/Ice0+WahYv6a6LzSgwZdSEsWUwzlz5owGDx6sLl26qHXr1hcthyTJYrFcssjZvHmzOnbsWGPcz89PiYmJ8vHxuWQx5exc++lx99136y9/+YvS09PtxZR0bo2p2NhYSdJPP/2kVatWaffu3dq+fbseeughffvtt4qKilLPnj3VunVrjR07ttbvCQAAAABAQxHVxE1PRocox/msIiJCrvndU46KYsqBnDhxQrfeeqtWrFih9u3bX3Cfhx9+WDabTRkZGXJzc9O7776rSZMmad++fSoqKtKUKVM0YsQISecWUe/UqVONY/zaW/muhtVq1SOPPKKZM2fKx8dH3333nRITE9WzZ09J0l133aWVK1dSTAEAAAAA0IhQTDmQb7/9Vvn5+WrVqtVF99m6dasiIyP19ddfy2w2q2/fvpo5c6a6dOmioqIixcfHa+jQoTKbzdq8ebPuuuuuGsf4tbfyXciHH34os9msDh06XHD7woULZTabNXLkSPtYeXm5/c9lZWWy2S623BsAAAAAAGiIKKYcSGBgoGw2m+6++26NGzdO7u7uysjIUFVVlSZOnCir1aodO3Zo2bJlcnFx0RdffKGtW7fqgQcesB/D2dnZXvBs375d7dq1q/E+/v7+6tChw2Vv5buYfv366bbbblNiYqIk6dNPP9Wbb76pRx99VM2bN6+xf2FhoZ566in961//sr9fr169NGHCBM2ePVuRkZH64IMPNHPmzCvOAgAAAAAA6i+KKQfSq1cvLViwQK+++qruvvtuOTs7q02bNpo+fbokad++fYqMjFRQUJCkc1dPPf7445o6dWqNY+3fv1/NmzeXu7v7Nc8ZFxenhQsX6tChQ7JarWrdurXmzp2r8ePHX3D/adOm6Y477lCXLl3sY23bttXrr7+u559/XmVlZRo2bFi1gg0AAAAAADR8FFMO5sEHH9SDDz54wW1bt26ttph5ixYttGjRIj322GNydXVVQUGBKioqFBYWdtH1pa6FefPmad68eVe0/4U88MADlFEAAAAAADRijWOJ9wbil8XUfffdp+joaCUkJKh9+/YaPHiwzp49K+ni38gHAAAAAADgKLhiqhZSU1OVmpoqi8ViaI5Zs2ZVe+7i4qK33377gvumpKTURSQAAAAAAICrxhVTtZCcnKyMjAylpaUZHQUAAAAAAKDBoJgCAAAAAACAISimUC/YbDZJkslkMjgJAAAAAAC4Viim6piTk5PMZrPOnDljdJR65fzn5eLiYnASAAAAAABwrVBMGSAgIEDHjh2zXwWEy8vPz5ePjw/FFAAAAAAADQjFlAFCQ0NVUlKi3bt3q6qqyug4Ds1qtSo7O1v5+flq0aKF0XEAAAAAAMA15Gx0gMYoMDBQ8fHxyszM1KFDh9S0aVM5OzvX2fpJNptNp0+floeHh8Ou2WSz2WSxWFRUVKSqqipFRUUpLCzM6FgAAAAAAOAaopgySHh4uP2WvvPlS12x2WwqKSmRi4uLwxZTkmQ2m9WyZUsFBwfLy8vL6DgAAAAAAOAao5gykIeHhyIjI+v8fa1Wq3JychQRESEnJ+7mBAAAAAAAxqCVAAAAAAAAgCEopgAAAAAAAGAIiikAAAAAAAAYgmIKAAAAAAAAhmDx8ytgs9kkScXFxQYn+XWsVqtKSkpUXFzM4udwOMxPOCrmJhwVcxOOirkJR8b8hKNqKHPzfG9yvke5FIqpWkhNTVVqaqoqKyslSeHh4QYnAgAAAAAAcGwlJSXy9fW95D4mW23qK0g611weOXJE3t7eMplMRse5asXFxQoPD1dubq58fHyMjgNUw/yEo2JuwlExN+GomJtwZMxPOKqGMjdtNptKSkoUGhp62Su/uGLqCjg5OSksLMzoGNeMj49PvZ7oaNiYn3BUzE04KuYmHBVzE46M+QlH1RDm5uWulDqv/t6wCAAAAAAAgHqNYgoAAAAAAACGoJhqhNzc3DRt2jS5ubkZHQWogfkJR8XchKNibsJRMTfhyJifcFSNcW6y+DkAAAAAAAAMwRVTAAAAAAAAMATFFAAAAAAAAAxBMQUAAAAAAABDUEwBAAAAAADAEBRTjUhKSoqSkpLk7e2toKAg/c///I92795tdCxACxYsUNu2beXj4yMfHx91795dX375pdGxgBpmzZolk8mkCRMmGB0F0PTp02Uymao94uLijI4FSJIOHz6soUOHyt/fXx4eHkpMTNSmTZuMjoVGLjIyssZ/N00mk5KTk42OhkbOYrHo6aefVlRUlDw8PHTDDTfoueeeU2P5rjpnowOg7qxZs0bJyclKSkpSVVWVnnzySfXt21cZGRny9PQ0Oh4asbCwMM2aNUutWrWSzWbT4sWLNWjQIG3dulVt2rQxOh4gSUpLS9Mbb7yhtm3bGh0FsGvTpo1WrVplf+7szP/awXinTp1Sz549deutt+rLL79UYGCg9u7dq2bNmhkdDY1cWlqaLBaL/fmOHTt0++23a/DgwQamAqQXX3xRCxYs0OLFi9WmTRtt2rRJ999/v3x9ffXII48YHe+6M9kaSwWHGgoKChQUFKQ1a9bolltuMToOUI2fn59mz56t0aNHGx0FUGlpqTp27KjXXntNzz//vNq3b6+5c+caHQuN3PTp0/XJJ58oPT3d6ChANVOmTNGPP/6o77//3ugowCVNmDBBn332mfbu3SuTyWR0HDRid955p4KDg7Vw4UL72F133SUPDw+99957BiarG9zK14gVFRVJOlcAAI7CYrHoww8/VFlZmbp37250HECSlJycrAEDBqhPnz5GRwGq2bt3r0JDQxUdHa377rtPOTk5RkcC9Omnn6pz584aPHiwgoKC1KFDB7311ltGxwKqqays1HvvvadRo0ZRSsFwPXr00DfffKM9e/ZIkrZt26YffvhB/fv3NzhZ3eB670bKarVqwoQJ6tmzp2688Uaj4wDavn27unfvrjNnzsjLy0vLli1TQkKC0bEAffjhh9qyZYvS0tKMjgJU07VrVy1atEixsbHKy8vTjBkzdPPNN2vHjh3y9vY2Oh4asf3792vBggWaNGmSnnzySaWlpemRRx6Rq6urRowYYXQ8QJL0ySefqLCwUCNHjjQ6CqApU6aouLhYcXFxMpvNslgseuGFF3TfffcZHa1OUEw1UsnJydqxY4d++OEHo6MAkqTY2Filp6erqKhIS5cu1YgRI7RmzRrKKRgqNzdXjz76qFauXCl3d3ej4wDV/PfforZt21Zdu3ZVy5Yt9fe//53boGEoq9Wqzp07a+bMmZKkDh06aMeOHXr99dcppuAwFi5cqP79+ys0NNToKID+/ve/6/3339eSJUvUpk0bpaena8KECQoNDW0U/92kmGqEHn74YX322Wdau3atwsLCjI4DSJJcXV0VExMjSerUqZPS0tI0b948vfHGGwYnQ2O2efNm5efnq2PHjvYxi8WitWvX6tVXX1VFRYXMZrOBCYH/aNq0qVq3bq19+/YZHQWNXEhISI2/WIqPj9c///lPgxIB1R08eFCrVq3Sxx9/bHQUQJI0efJkTZkyRffcc48kKTExUQcPHlRKSgrFFBoWm82m8ePHa9myZVq9erWioqKMjgRclNVqVUVFhdEx0Mj17t1b27dvrzZ2//33Ky4uTk888QSlFBxKaWmpsrKyNGzYMKOjoJHr2bOndu/eXW1sz549atmypUGJgOreeecdBQUFacCAAUZHASRJ5eXlcnKqvgS42WyW1Wo1KFHdophqRJKTk7VkyRItX75c3t7eOnr0qCTJ19dXHh4eBqdDYzZ16lT1799fERERKikp0ZIlS7R69Wp99dVXRkdDI+ft7V1jHT5PT0/5+/uzPh8M9/jjj2vgwIFq2bKljhw5omnTpslsNmvIkCFGR0MjN3HiRPXo0UMzZ87U3XffrY0bN+rNN9/Um2++aXQ0QFarVe+8845GjBghZ2d+HYZjGDhwoF544QVFRESoTZs22rp1q+bMmaNRo0YZHa1O8JPYiCxYsECS1KtXr2rj77zzDov+wVD5+fkaPny48vLy5Ovrq7Zt2+qrr77S7bffbnQ0AHBYhw4d0pAhQ3TixAkFBgbqpptu0vr16xUYGGh0NDRySUlJWrZsmaZOnapnn31WUVFRmjt3bqNZxBeObdWqVcrJyWk0v/Cjfpg/f76efvppjRs3Tvn5+QoNDdXYsWP1zDPPGB2tTphsNpvN6BAAAAAAAABofJwuvwsAAAAAAABw7VFMAQAAAAAAwBAUUwAAAAAAADAExRQAAAAAAAAMQTEFAAAAAAAAQ1BMAQAAAAAAwBAUUwAAAAAAADAExRQAAAAAAAAMQTEFAAAAAAAAQ1BMAQAAXIFevXppwoQJRsews9lseuCBB+Tn5yeTyaT09PTr9l61OXdH+3wAAIBjo5gCAAD1ysiRI2UymTRr1qxq45988olMJpNBqYyzYsUKLVq0SJ999pny8vJ04403Gprn448/1nPPPWd/TlEFAAAuhWIKAADUO+7u7nrxxRd16tQpo6NcM5WVlVf1uqysLIWEhKhHjx5q3ry5nJ2dr3GyK+Pn5ydvb29DMwAAgPqDYgoAANQ7ffr0UfPmzZWSknLRfSIjIzV37txqY+3bt9f06dPtz3v16qXx48drwoQJatasmYKDg/XWW2+prKxM999/v7y9vRUTE6Mvv/yy2nGqqqr08MMPy9fXVwEBAXr66adls9ns261Wq1JSUhQVFSUPDw+1a9dOS5curXaMXr166eGHH9aECRMUEBCgfv36XfA8Kioq9MgjjygoKEju7u666aablJaWJunc1WPjx49XTk6OTCaTIiMjL3iMsrIyDR8+XF5eXgoJCdHLL79c40qm2nxetTn3/z7uyJEjtWbNGs2bN08mk0kmk0kHDhzQ0qVLlZiYKA8PD/n7+6tPnz4qKyu7YHbpXPlmMpn02WefqXfv3mrSpIliY2O1YcOGi74GAADUDxRTAACg3jGbzZo5c6bmz5+vQ4cO/apjLV68WAEBAdq4caPGjx+vhx56SIMHD1aPHj20ZcsW9e3bV8OGDVN5eXm11zg7O2vjxo2aN2+e5syZo7/+9a/27SkpKXr33Xf1+uuva+fOnZo4caKGDh2qNWvW1HhvV1dX/fjjj3r99dcvmO9Pf/qT/vnPf2rx4sXasmWLYmJi1K9fP508eVLz5s3Ts88+q7CwMOXl5dkLq1+aPHmy1qxZo+XLl+vrr7/W6tWrtWXLlqv+vC517v9t3rx56t69u8aMGaO8vDzl5eXJxcVFQ4YM0ahRo5SZmanVq1fr97//fbVy65e2bdsmk8mkOXPm6Omnn9a2bdsUERGhKVOmXNU5AAAAx2Hstd4AAABX6Xe/+53at2+vadOmaeHChVd9nHbt2umpp56SJE2dOlWzZs1SQECAxowZI0l65plntGDBAv3888/q1q2bJCk8PFyvvPKKTCaTYmNjtX37dr3yyisaM2aMKioqNHPmTK1atUrdu3eXJEVHR+uHH37QG2+8od/85jf2927VqpVeeumli2YrKyvTggULtGjRIvXv31+S9NZbb2nlypVauHChJk+eLG9vb5nNZjVv3vyCxygtLdXChQv13nvvqXfv3pLOlUthYWFX9Xld6tx/ydfXV66urmrSpIk935YtW1RVVaXf//73atmypSQpMTHxku+5bds2NW3aVB999JECAwMlSb/97W/1xhtvXNU5AAAAx8EVUwAAoN568cUXtXjxYmVmZl71Mdq2bWv/s9lslr+/f7WiJDg4WJKUn59vH+vWrVu1hda7d++uvXv3ymKxaN++fSovL9ftt98uLy8v++Pdd99VVlZWtffu1KnTJbNlZWXp7Nmz6tmzp33MxcVFXbp0qfU5Z2VlqbKyUl27drWP+fn5KTY2tlav/6VLnXtttGvXTr1791ZiYqIGDx6st95667JrhW3btk2DBg2yl1KSlJ2drZiYmKs6BwAA4DgopgAAQL11yy23qF+/fpo6dWqNbU5OTjVuDzt79myN/VxcXKo9N5lM1cbOlzBWq7VWmUpLSyVJn3/+udLT0+2PjIyMGutMeXp61uqYdaG2n9evZTabtXLlSn355ZdKSEjQ/PnzFRsbq+zs7Iu+Ztu2bfarz85LT09X+/bt7c937typnj17qk2bNpo4caL96jAAAODYKKYAAEC9NmvWLP3rX//SunXrqo0HBgYqLy/P/ry4uPiS5ceV+OWi2+vXr1erVq1kNpuVkJAgNzc35eTkKCYmptojPDz8it7nhhtusK9Bdd7Zs2eVlpamhISEWh/DxcWlWuZTp05pz5491far7ed1qXO/EFdX1xpXU5lMJvXs2VMzZszQ1q1b5erqqmXLll3w9UVFRTpw4IA6dOhQbfy/i6mKigoNGTJEb731lnbu3Kns7OxqV8IBAADHxRpTAACgXktMTNR9992n//u//6s2ftttt2nRokUaOHCgmjZtqmeeeeai5cmVysnJ0aRJkzR27Fht2bJF8+fP18svvyxJ8vb21uOPP66JEyfKarXqpptuUlFRkX788Uf5+PhoxIgRtX4fT09PPfTQQ5o8ebL8/PwUERGhl156SeXl5Ro9enStjuHl5aXRo0dr8uTJ8vf3V1BQkP785z/Lyan630/W9vO61LlfSGRkpDZs2KADBw7Iy8tLWVlZ+uabb9S3b18FBQVpw4YNKigoUHx8/AVf//PPP8vZ2bna7ZUHDx7UqVOn7MXUJ598oltuucVe1sXGxl71rYoAAKBuUUwBAIB679lnn9VHH31UbWzq1KnKzs7WnXfeKV9fXz333HPX7Iqp4cOH6/Tp0+rSpYvMZrMeffRRPfDAA/btzz33nAIDA5WSkqL9+/eradOm6tixo5588skrfq9Zs2bJarVq2LBhKikpUefOnfXVV1+pWbNmtT7G7NmzVVpaqoEDB8rb21uPPfaYioqKqu1T28/rcuf+S48//rhGjBihhIQEnT59WhkZGVq7dq3mzp2r4uJitWzZUi+//LJ9cfdf2rZtm2JjY+Xu7m4f27p1q5o2barIyEhJ0vbt29WuXbtqrxk8eHCtPx8AAGAck+1S380LAACABqlXr15q37695s6da3SUX23OnDk6cuSI/vKXv+iLL77QoEGDVFxcLA8PD6OjAQCAy2CNKQAAANRrQ4cO1erVq9WuXTutW7dOMTExlFIAANQT3MoHAACAei0oKEibNm2SdG5x9szMTIMTAQCA2qKYAgAAaIRWr15tdITr4ueff+Yb+QAAqEdYYwoAAAAAAACGYI0pAAAAAAAAGIJiCgAAAAAAAIagmAIAAAAAAIAhKKYAAAAAAABgCIopAAAAAAAAGIJiCgAAAAAAAIagmAIAAAAAAIAhKKYAAAAAAABgCIopAAAAAAAAGIJiCgAAAAAAAIagmAIAAAAAAIAhKKYAAAAAAABgiP8PyzEmTJUYam4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result3 = bp.barren_plateaus_analysis(\n", + " experiment=experiment3,\n", + " cost_function_builder=circuit_mse_loss_builder,\n", + " generate_params=generate_params_hea,\n", + " generate_circuits=build_hea_ansatz,\n", + " sampling=sampling,\n", + " execution=execution,\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ex/visualization_tools.ipynb b/ex/visualization_tools.ipynb new file mode 100644 index 0000000..0b9e2da --- /dev/null +++ b/ex/visualization_tools.ipynb @@ -0,0 +1,701 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "fc6668db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/ColibrITD-SAS/landscape_tools@dev\n", + " Cloning https://github.com/ColibrITD-SAS/landscape_tools (to revision dev) to /tmp/pip-req-build-ow3qgz13\n", + " Running command git clone --filter=blob:none --quiet https://github.com/ColibrITD-SAS/landscape_tools /tmp/pip-req-build-ow3qgz13\n", + " Running command git checkout -b dev --track origin/dev\n", + " Switched to a new branch 'dev'\n", + " branch 'dev' set up to track 'origin/dev'.\n", + " Resolved https://github.com/ColibrITD-SAS/landscape_tools to commit 50e6c6bbf19b625f9540e7c5c686c800e0c75fb2\n", + " Installing build dependencies ... \u001b[?25ldone\n", + "\u001b[?25h Getting requirements to build wheel ... \u001b[?25ldone\n", + "\u001b[?25h Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25hRequirement already satisfied: numpy in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from landscape-tools==0.1.dev71+g50e6c6bbf) (2.4.6)\n", + "Requirement already satisfied: matplotlib in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from landscape-tools==0.1.dev71+g50e6c6bbf) (3.8.4)\n", + "Requirement already satisfied: scipy in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from landscape-tools==0.1.dev71+g50e6c6bbf) (1.17.1)\n", + "Requirement already satisfied: scikit-learn in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from landscape-tools==0.1.dev71+g50e6c6bbf) (1.9.0)\n", + "Requirement already satisfied: tqdm in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from landscape-tools==0.1.dev71+g50e6c6bbf) (4.68.2)\n", + "Requirement already satisfied: gudhi in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from landscape-tools==0.1.dev71+g50e6c6bbf) (3.12.0)\n", + "Requirement already satisfied: setuptools_scm in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from landscape-tools==0.1.dev71+g50e6c6bbf) (10.0.5)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from matplotlib->landscape-tools==0.1.dev71+g50e6c6bbf) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from matplotlib->landscape-tools==0.1.dev71+g50e6c6bbf) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from matplotlib->landscape-tools==0.1.dev71+g50e6c6bbf) (4.63.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from matplotlib->landscape-tools==0.1.dev71+g50e6c6bbf) (1.5.0)\n", + "Requirement already satisfied: packaging>=20.0 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from matplotlib->landscape-tools==0.1.dev71+g50e6c6bbf) (26.2)\n", + "Requirement already satisfied: pillow>=8 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from matplotlib->landscape-tools==0.1.dev71+g50e6c6bbf) (12.2.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from matplotlib->landscape-tools==0.1.dev71+g50e6c6bbf) (3.3.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from matplotlib->landscape-tools==0.1.dev71+g50e6c6bbf) (2.9.0.post0)\n", + "Requirement already satisfied: joblib>=1.4.0 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from scikit-learn->landscape-tools==0.1.dev71+g50e6c6bbf) (1.5.3)\n", + "Requirement already satisfied: narwhals>=2.0.1 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from scikit-learn->landscape-tools==0.1.dev71+g50e6c6bbf) (2.22.1)\n", + "Requirement already satisfied: threadpoolctl>=3.5.0 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from scikit-learn->landscape-tools==0.1.dev71+g50e6c6bbf) (3.6.0)\n", + "Requirement already satisfied: vcs-versioning>=1.0.0.dev0 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from setuptools_scm->landscape-tools==0.1.dev71+g50e6c6bbf) (1.1.1)\n", + "Requirement already satisfied: setuptools in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from setuptools_scm->landscape-tools==0.1.dev71+g50e6c6bbf) (82.0.1)\n", + "Requirement already satisfied: six>=1.5 in /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages (from python-dateutil>=2.7->matplotlib->landscape-tools==0.1.dev71+g50e6c6bbf) (1.17.0)\n", + "Building wheels for collected packages: landscape-tools\n", + " Building wheel for landscape-tools (pyproject.toml) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for landscape-tools: filename=landscape_tools-0.1.dev71+g50e6c6bbf-py3-none-any.whl size=42548 sha256=548272e3f1e54ab434ec86a404985e16c47a94a4ac9d908796dd368df0210302\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-srpbe1hu/wheels/5f/37/aa/638d6bbcebd7da1752c19f840e034c8dc424e871754710f71e\n", + "Successfully built landscape-tools\n", + "Installing collected packages: landscape-tools\n", + " Attempting uninstall: landscape-tools\n", + " Found existing installation: landscape-tools 0.1.dev66+g3e2f3722d\n", + " Uninstalling landscape-tools-0.1.dev66+g3e2f3722d:\n", + " Successfully uninstalled landscape-tools-0.1.dev66+g3e2f3722d\n", + "Successfully installed landscape-tools-0.1.dev71+g50e6c6bbf\n" + ] + } + ], + "source": [ + "!pip install --upgrade git+https://github.com/ColibrITD-SAS/landscape_tools@dev" + ] + }, + { + "cell_type": "markdown", + "id": "4766f58c", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b9b7e755", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "/home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages/vcs_versioning/_config.py:261: UserWarning: relative_to is expected to be a file, it's the directory /home/gabriel/Desktop/public/landscape_visualisation/.venv/lib/python3.12/site-packages\n", + "assuming the parent directory was passed\n", + " return _check_absolute_root(self.root, self.relative_to)\n" + ] + } + ], + "source": [ + "from landscape_tools import landscape_visualization as lv\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from qiskit import QuantumCircuit\n", + "from qiskit.circuit import ParameterVector\n", + "from qiskit.quantum_info import Statevector\n", + "\n", + "from scipy.optimize import minimize" + ] + }, + { + "cell_type": "markdown", + "id": "e19788a3", + "metadata": {}, + "source": [ + "# Example of a problem" + ] + }, + { + "cell_type": "markdown", + "id": "a78ee9da", + "metadata": {}, + "source": [ + "## Probability distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "87ffd646", + "metadata": {}, + "outputs": [], + "source": [ + "def get_prob_distribution(params, ansatz, theta_params):\n", + "\n", + " param_dict = dict(zip(theta_params, params)) \n", + " # param_dict = {\n", + " # θ_0: 0.5,\n", + " # θ_1: 1.2\n", + " # }\n", + "\n", + " bound_circuit = ansatz.assign_parameters(param_dict, inplace=False)\n", + "\n", + " state = Statevector.from_instruction(bound_circuit)\n", + " probs = state.probabilities()\n", + "\n", + " return np.asarray(probs, dtype=float)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d368b9cc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_qubits = 5\n", + "dim = 2 ** n_qubits\n", + "\n", + "p_target = np.zeros(dim)\n", + "\n", + "# index 0 -> |000>, index 1 -> |001>, ..., index 7 -> |111>\n", + "p_target[0] = 0.40 # |000>\n", + "p_target[3] = 0.25 # |011>\n", + "p_target[7] = 0.35 # |111>\n", + "\n", + "p_target = p_target / p_target.sum() # normalize to ensure probabilities sum to 1\n", + "\n", + "plt.bar(range(dim), p_target)\n", + "plt.xlabel(\"state |x>\")\n", + "plt.ylabel(\"target probability\")\n", + "plt.title(\"Target distribution\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9e566327", + "metadata": {}, + "source": [ + "## Quantum circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "42de136a", + "metadata": {}, + "outputs": [], + "source": [ + "def build_hea_ansatz(n_qubits, n_layers):\n", + " \"\"\"\n", + " Hardware Efficient Ansatz :\n", + " - RY + RZ on each qubit\n", + " - CNOT chain\n", + " \"\"\"\n", + " qc = QuantumCircuit(n_qubits)\n", + "\n", + " n_params = 2 * n_qubits * n_layers\n", + " theta = ParameterVector(\"θ\", n_params)\n", + "\n", + " k = 0\n", + " for _ in range(n_layers):\n", + " for q in range(n_qubits):\n", + " qc.ry(theta[k], q)\n", + " k += 1\n", + " qc.rz(theta[k], q)\n", + " k += 1\n", + "\n", + " for q in range(n_qubits - 1):\n", + " qc.cx(q, q + 1)\n", + "\n", + " return qc, theta" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ef5af215", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of parameters: 20\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_layers = 2\n", + "\n", + "ansatz, theta_params = build_hea_ansatz(n_qubits, n_layers)\n", + "\n", + "n_params = len(theta_params)\n", + "\n", + "print(\"Number of parameters:\", n_params)\n", + "ansatz.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4521394f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4.15733546e-02 4.79027262e-04 2.18155239e-02 2.58699642e-03\n", + " 3.18627740e-02 1.15789752e-03 4.74376622e-02 1.27015812e-02\n", + " 6.35063861e-02 6.16871848e-04 1.24594029e-04 1.86519929e-05\n", + " 1.38958465e-01 4.39509061e-03 2.76933548e-03 6.07373008e-04\n", + " 2.19354278e-02 2.71598660e-04 3.59414580e-02 4.23930927e-03\n", + " 6.44468459e-04 1.35939232e-05 6.81829126e-03 1.79047391e-03\n", + " 4.49730172e-01 4.25334428e-03 9.36537018e-03 9.47865071e-04\n", + " 8.45709466e-02 2.67229619e-03 5.03176102e-03 1.16203807e-03]\n", + "Sum = 0.9999999999999998\n" + ] + } + ], + "source": [ + "params_test = np.random.uniform(0, 2*np.pi, size=n_params)\n", + "\n", + "p_test = get_prob_distribution(params_test, ansatz, theta_params)\n", + "\n", + "print(p_test)\n", + "print(\"Sum =\", p_test.sum())" + ] + }, + { + "cell_type": "markdown", + "id": "7acef115", + "metadata": {}, + "source": [ + "## Loss function" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c7347407", + "metadata": {}, + "outputs": [], + "source": [ + "def mse_loss(params, ansatz, theta_params, p_target):\n", + " p_model = get_prob_distribution(params, ansatz, theta_params)\n", + " return np.sum((p_model - p_target) ** 2)" + ] + }, + { + "cell_type": "markdown", + "id": "7ef7f740", + "metadata": {}, + "source": [ + "## Optimization" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d2c9d25a", + "metadata": {}, + "outputs": [], + "source": [ + "theta_history = []\n", + "loss_history = []\n", + "\n", + "def objective(params):\n", + " loss = mse_loss(params, ansatz, theta_params, p_target)\n", + " return loss\n", + "\n", + "def callback(params):\n", + " theta_history.append(np.copy(params))\n", + " loss_history.append(objective(params))\n", + "\n", + "rng = np.random.default_rng(seed=42)\n", + "\n", + "initial_params = rng.uniform(\n", + " low=0.0,\n", + " high=2*np.pi,\n", + " size=n_params\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2fbd4af8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Return from COBYLA because the objective function has been evaluated MAXFUN times.\n", + "Number of function values = 3000 Least value of F = 0.141620402123945\n", + "The corresponding X is:\n", + "[3.96397799 5.37138149 5.96327055 3.11601968 1.03131752 5.19697268\n", + " 4.79735977 5.16748975 1.57076526 3.14163004 0.97168195 7.58971189\n", + " 4.00683035 4.66282188 1.77867564 1.18328303 3.3483333 0.15788304\n", + " 7.85394522 5.06004222]\n", + "\n" + ] + } + ], + "source": [ + "result = minimize(\n", + " objective,\n", + " initial_params,\n", + " method=\"COBYLA\",\n", + " callback=callback,\n", + " options={\n", + " \"maxiter\": 3000,\n", + " \"rhobeg\": 0.5,\n", + " \"tol\": 1e-6,\n", + " \"disp\": True\n", + " }\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4b3f4f95", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta_history shape: (2379, 20)\n", + "loss_history shape: (2379,)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "theta_history = np.array(theta_history)\n", + "loss_history = np.array(loss_history)\n", + "\n", + "print(\"theta_history shape:\", theta_history.shape)\n", + "print(\"loss_history shape:\", loss_history.shape)\n", + "plt.plot(loss_history)\n", + "plt.xlabel(\"iter\")\n", + "plt.ylabel(\"MSE Loss\")\n", + "plt.title(\"Loss evolution\")\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "86886cf2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_final = get_prob_distribution(result.x, ansatz, theta_params)\n", + "\n", + "x = np.arange(dim)\n", + "\n", + "plt.figure(figsize=(8, 4))\n", + "plt.bar(x - 0.2, p_target, width=0.4, label=\"Target\")\n", + "plt.bar(x + 0.2, p_final, width=0.4, label=\"Model\")\n", + "plt.xlabel(\"state |x>\")\n", + "plt.ylabel(\"probability\")\n", + "plt.title(\"Target vs learnt distribution\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ae7f56d1", + "metadata": {}, + "source": [ + "# Landscape visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "95352752", + "metadata": {}, + "outputs": [], + "source": [ + "def make_mse_objective(ansatz, theta_params, p_target):\n", + " \n", + " def objective(params):\n", + " return mse_loss(params, ansatz, theta_params, p_target)\n", + " \n", + " return objective\n", + "\n", + "objective = make_mse_objective(ansatz, theta_params, p_target)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f47a5de9", + "metadata": {}, + "outputs": [], + "source": [ + "d1, d2 = lv.random_mixed_directions(len(theta_history[-1]))\n", + "paramsf = theta_history[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8d73e31d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "1D scan progression: 100%|██████████| 3000/3000 [00:01<00:00, 2464.12it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lv.loss_scan_1d(\n", + " params=paramsf,\n", + " direction=d1,\n", + " loss_function=objective,\n", + " n_steps=3000,\n", + " end_points=(-0.01, 0.01),\n", + " n_jobs=-1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "35cd2306", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2D scan progression: 100%|██████████| 300/300 [00:16<00:00, 18.00it/s]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1oAAAJOCAYAAACuknanAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADf/ElEQVR4nOydeXxU5fXGn5lJZhLABFlDECFQNCyyCBqDWG2NRsEFNxRREFFbRUVxA4uAW3EpCq64Ai4UN6TWahSxahEEAelPERAEDVtYxBC2zCQz9/dHOiPDbHed+753nu/nM582M+97zr0xJPe55znnuhRFUUAIIYQQQgghxDTcdh8AIYQQQgghhDgNCi1CCCGEEEIIMRkKLUIIIYQQQggxGQotQgghhBBCCDEZCi1CCCGEEEIIMRkKLUIIIYQQQggxGQotQgghhBBCCDEZCi1CCCGEEEIIMRkKLUIIIYQQQggxGQotQgghjsTlcmHSpEl2HwYhhJAMhUKLEEI08PXXX+PGG29Et27d0LhxYxx99NEYPHgwfvjhh5i1p512GlwuF1wuF9xuN/Ly8nDsscfiyiuvxPz581XnvOqqq9CkSRMzT8MSTjvtNHTv3t3uwyCEEEKEIMvuAyCEEJl4+OGH8eWXX+KSSy5Bjx49UFVVhaeeegrHH388vvrqqxihcdRRR2Hy5MkAgP3792P9+vWYO3cuXnvtNQwePBivvfYasrOz7TgVQgghhFgIhRYhhGhgzJgxmD17Nrxeb+S9Sy+9FMcddxweeughvPbaa1Hr8/PzccUVV0S999BDD+Hmm2/GM888gw4dOuDhhx9Oy7ETQgghJH3QOkgIIRro169flMgCgM6dO6Nbt25YvXq1qhgejwdPPPEEunbtiqeeegp79uwx5djeeust9OnTB7m5uWjRogWuuOIKbNmyJWpNVVUVRowYgaOOOgo+nw9t2rTB+eefj59++imyZtmyZSgvL0eLFi2Qm5uLoqIiXH311aYc4//93//hqquuQseOHZGTk4OCggJcffXV+OWXX6LWTZo0CS6XC+vXr8dVV12Fpk2bIj8/HyNGjMCBAwei1vr9ftx6661o2bIljjjiCJx33nnYvHlzTO69e/filltuQYcOHeDz+dCqVSucccYZWLFiRdS6JUuWYMCAATjyyCPRuHFj9OjRA9OmTdN9DmvWrMHgwYORl5eH5s2bY/To0aitrY05vtdeey3y369Zs2a47LLLsGnTJs3fY0IIIWLAihYhhBhEURRs374d3bp1U73H4/FgyJAhuOeee7Bw4UIMHDjQ0DHMnDkTI0aMwAknnIDJkydj+/btmDZtGr788kt88803aNq0KQDgoosuwqpVq3DTTTehQ4cO2LFjB+bPn4/KysrI12eeeSZatmyJsWPHomnTpvjpp58wd+5cQ8cXZv78+diwYQNGjBiBgoICrFq1Cs8//zxWrVqFr776Ci6XK2r94MGDUVRUhMmTJ2PFihV48cUX0apVq6gq4DXXXIPXXnsNl19+Ofr164dPP/007vfzz3/+M95++23ceOON6Nq1K3755RcsXLgQq1evxvHHHx85vnPOOQdt2rTB6NGjUVBQgNWrV+P999/H6NGjdZ9Dhw4dMHnyZHz11Vd44okn8Ouvv+KVV16JrHnwwQdxzz33YPDgwbjmmmuwc+dOPPnkk/j9738f9d+PEEKIRCiEEEIM8eqrryoAlJdeeinq/VNPPVXp1q1bwn3vvvuuAkCZNm1a0vjDhw9XGjdunPDzQCCgtGrVSunevbty8ODByPvvv/++AkCZMGGCoiiK8uuvvyoAlEcffTTlMX399ddJjykeqc5XURTlwIEDMe/9/e9/VwAoX3zxReS9iRMnKgCUq6++OmrtBRdcoDRv3jzy9cqVKxUAyg033BC17vLLL1cAKBMnToy8l5+fr4waNSrhsdXX1ytFRUVK+/btlV9//TXqs1AopPsczjvvvKi1N9xwgwJA+e9//6soiqL89NNPisfjUR588MGodd9++62SlZUV8z4hhBA5oHWQEEIMsGbNGowaNQqlpaUYPny4pr3hSYJ79+41dAzLli3Djh07cMMNNyAnJyfy/sCBA1FcXIx//etfAIDc3Fx4vV589tln+PXXX+PGCldO3n//fdTV1Rk6rnjk5uZG/n9tbS127dqFk046CQBiLHxAQxXqUE455RT88ssvqKmpAQB88MEHAICbb745at0tt9wSE6tp06ZYsmQJtm7dGvfYvvnmG2zcuBG33HJLTAXp0CqV1nMYNWpU1Nc33XRT1LHPnTsXoVAIgwcPxq5duyKvgoICdO7cGf/+97/jHi8hhBCxodAihBCdVFVVYeDAgcjPz8fbb78Nj8ejaf++ffsAAEcccYSh4/j5558BAMcee2zMZ8XFxZHPfT4fHn74YXz44Ydo3bo1fv/73+ORRx5BVVVVZP2pp56Kiy66CPfeey9atGiB888/HzNmzIDf7zd0jGF2796N0aNHo3Xr1sjNzUXLli1RVFQEAHF71Y4++uior4888kgAiAjFn3/+GW63G506dYpaF+978cgjj+C7775Du3btcOKJJ2LSpEnYsGFD5PMff/wRAFKOqNd6Dp07d476ulOnTnC73ZG+uHXr1kFRFHTu3BktW7aMeq1evRo7duxIejyEyMgXX3yBc889F4WFhXC5XJg3b56l+cI9k4e+iouLdcerra3FVVddheOOOw5ZWVkYNGiQpv1+vx+9evWCy+XCypUrNcf1+/34y1/+gvbt28Pn86FDhw54+eWXdZ9PKrZt24bLL78cxxxzDNxud9ybWSQW9mgRQogO9uzZg7PPPhvV1dX4z3/+g8LCQs0xvvvuOwDA7373O7MPLyG33HILzj33XMybNw8fffQR7rnnHkyePBmffvopevfuDZfLhbfffhtfffUV/vnPf+Kjjz7C1VdfjSlTpuCrr74y/DyvwYMHY9GiRbjjjjvQq1cvNGnSBKFQCGeddRZCoVDM+kTiVVEUXblPOeUUvPvuu/j444/x6KOP4uGHH8bcuXNx9tlnW3YOh3N4D1coFILL5cKHH34Y93xleIYaIVrZv38/evbsiauvvhoXXnhhWnJ269YNn3zySeTrrKzkl8EulwsbN25Ehw4dYj4LBoPIzc3FzTffjHfeeUfzsdx5550oLCzEf//7X11xBw8ejO3bt+Oll17C7373O2zbtk3V7x+9+P1+tGzZEuPHj8fjjz9uWR6nQaFFCCEaqa2txbnnnosffvgBn3zyCbp27ao5RjAYxOzZs9GoUSP079/f0PG0b98eALB27Vr88Y9/jPps7dq1kc/DdOrUCbfddhtuu+02rFu3Dr169cKUKVOiRtOfdNJJOOmkk/Dggw9i9uzZGDp0KObMmYNrrrlG93H++uuvWLBgAe69915MmDAh8v66det0x2zfvj1CoRB+/PHHqCrW2rVr465v06YNbrjhBtxwww3YsWMHjj/+eDz44IM4++yzI1Wx7777DmVlZaadw7p16yIVLwBYv349QqFQ5OKtU6dOUBQFRUVFOOaYY1SfOyEyc/bZZye9wRGu2Pz9739HdXU1unfvjocffhinnXaa7pxZWVkoKCjQvf9QGjdujGeffRYA8OWXX6K6ulr13g8//BAff/wx3nnnHXz44Yea41ZUVODzzz/Hhg0b0KxZMwCIKwZffPFFTJkyJSIWb775Ztxwww2qj/NQOnToEJm+amXlzGnQOkgIIRoIBoO49NJLsXjxYrz11lsoLS3VFePmm2/G6tWrcfPNNyMvL8/QMfXt2xetWrXC9OnToyx+H374IVavXh2ZwHfgwIGYseKdOnXCEUccEdn366+/xlSLevXqBQCG7YPhas3h8adOnao7ZvhC7YknnkgaMxgMxtj6WrVqhcLCwsh5HX/88SgqKsLUqVNjLm7Cx6znHJ5++umor5988smoY7/wwgvh8Xhw7733xsRVFCVmbDwhmcCNN96IxYsXY86cOfi///s/XHLJJTjrrLMM3ZhZt24dCgsL0bFjRwwdOhSVlZUmHrE6tm/fjmuvvRavvvoqGjVqpCvGe++9h759++KRRx5B27Ztccwxx+D222/HwYMHI2tef/11TJgwAQ8++CBWr16Nv/71r7jnnnswa9Yss06FqIAVLUII0cBtt92G9957D+eeey52794d84Diwx9OvGfPnsiaAwcOYP369Zg7dy5+/PFHXHbZZbj//vtV5a2rq8MDDzwQ836zZs1www034OGHH8aIESNw6qmnYsiQIZHx7h06dMCtt94KAPjhhx9w+umnY/DgwejatSuysrLw7rvvYvv27bjssssAALNmzcIzzzyDCy64AJ06dcLevXvxwgsvIC8vDwMGDEh5nDt37ox7nEVFRRg6dGikL6yurg5t27bFxx9/jI0bN6r6HsSjV69eGDJkCJ555hns2bMH/fr1w4IFC7B+/fqodXv37sVRRx2Fiy++GD179kSTJk3wySef4Ouvv8aUKVMAAG63G88++yzOPfdc9OrVCyNGjECbNm2wZs0arFq1Ch999BHy8vI0n8PGjRtx3nnn4ayzzsLixYsjo+h79uwJoEHsPvDAAxg3bhx++uknDBo0CEcccQQ2btyId999F9dddx1uv/123d8jQmSjsrISM2bMQGVlZcSWffvtt6OiogIzZszAX//6V80xS0pKMHPmTBx77LHYtm0b7r33Xpxyyin47rvvDPfJqkVRFFx11VX485//jL59+0Y9v1ALGzZswMKFC5GTk4N3330Xu3btwg033IBffvkFM2bMAABMnDgRU6ZMidgyi4qK8P333+O5557TPLiJGMCucYeEECIjp556qgIg4SvZ2iZNmiidO3dWrrjiCuXjjz9WnXP48OEJ83Xq1Cmy7o033lB69+6t+Hw+pVmzZsrQoUOVzZs3Rz7ftWuXMmrUKKW4uFhp3Lixkp+fr5SUlChvvvlmZM2KFSuUIUOGKEcffbTi8/mUVq1aKeecc46ybNkyQ9+b008/XVEURdm8ebNywQUXKE2bNlXy8/OVSy65RNm6dWvMKPbwaPSdO3dG5ZgxY4YCQNm4cWPkvYMHDyo333yz0rx5c6Vx48bKueeeq2zatCkqpt/vV+644w6lZ8+eyhFHHKE0btxY6dmzp/LMM8/EnMfChQuVM844I7KuR48eypNPPhn5XOs5fP/998rFF1+sHHHEEcqRRx6p3HjjjVFj+MO88847Sv/+/ZXGjRsrjRs3VoqLi5VRo0Ypa9euTfm9J0RmACjvvvtu5OvwoynC/xbCr6ysLGXw4MGKoijK6tWrk/4uBqDcddddCXP++uuvSl5envLiiy9G3jvrrLOi8gFQGjVqFPm6a9eucWMNHz5cOf/881Oe57Rp05STTz5Zqa+vVxRFUTZu3KgAUL755htNcc844wwlJydHqa6ujrz3zjvvKC6XSzlw4ICyb98+BYCSm5sbdT7h3+lhWrdunfT7V1JSEve4Tj31VGX06NEpz5coiktRdHQUE0IIISQpkyZNwr333oudO3eiRYsWdh8OIcLicrnw7rvvRibsvfHGGxg6dChWrVoVMyCmSZMmKCgoQCAQiJoaGo/mzZujZcuWCT8/4YQTUFZWhsmTJwMAtmzZEmW/69y5Mz777DO0bdsWAJCdnR3T8woAV111Faqrq1NOThw0aBD++c9/Rg3ECQaD8Hg8GDp0aIytL1Hc4cOH48svv4yq3K9evRpdu3bFDz/8gLy8PBQUFOC1115DSUlJ1F6PxxPpGV2/fj3q6+sTHm9ubm7c8z3ttNPQq1cvQ7bvTIHWQUIIIYQQIgy9e/dGMBjEjh07cMopp8Rd4/V6DY1n37dvH3788UdceeWVkffCgupQ2rdvH3fQhB6eeOKJKGv11q1bUV5ejjfeeCNGECXj5JNPxltvvYV9+/ZFppL+8MMPcLvdOOqoo5Cbm4vCwkJs2LABQ4cOTRgnnRNvMxUKLUIIIYQQklb27dsXVZHZuHEjVq5ciWbNmuGYY47B0KFDMWzYMEyZMgW9e/fGzp07sWDBAvTo0SMy4EcLt99+O84991y0b98eW7duxcSJE+HxeDBkyBDd5/D9998jEAhg9+7d2Lt3b+R5WOEBQkuXLsWwYcOwYMECtG3bNua5gGGR1KlTJxx11FGq415++eW4//77MWLECNx7773YtWsX7rjjDlx99dWRB6rfe++9uPnmm5Gfn4+zzjoLfr8fy5Ytw6+//ooxY8boOt/wcezbtw87d+7EypUr4fV6dU3ezRQotAghhBBCSFpZtmwZ/vCHP0S+Dl/8Dx8+HDNnzsSMGTPwwAMP4LbbbsOWLVvQokULnHTSSTjnnHN05du8eTOGDBmCX375BS1btkT//v3x1VdfJbUWpmLAgAGRB8IDDZU44LeppAcOHMDatWtRV1dnatwmTZpg/vz5uOmmm9C3b180b94cgwcPjqqWXXPNNWjUqBEeffRR3HHHHWjcuDGOO+44Qw8aDh8HACxfvhyzZ89G+/btdQ/1yASk69F6+umn8eijj6Kqqgo9e/bEk08+iRNPPDHh+rfeegv33HMPfvrpJ3Tu3BkPP/xw1OSsuXPnYvr06Vi+fDl2796Nb775JnLHIExtbS1uu+02zJkzB36/H+Xl5XjmmWfQunXryJrKykpcf/31+Pe//40mTZpg+PDhmDx5csqH4RFCCCGEEEKch1TP0XrjjTcwZswYTJw4EStWrEDPnj1RXl6OHTt2xF2/aNEiDBkyBCNHjsQ333yDQYMGYdCgQfjuu+8ia/bv34/+/fvj4YcfTpj31ltvxT//+U+89dZb+Pzzz7F169aop5gHg0EMHDgQgUAAixYtwqxZszBz5syoh1kSQgghhBBCMgepKlolJSU44YQT8NRTTwEAQqEQ2rVrh5tuugljx46NWX/ppZdi//79eP/99yPvnXTSSejVqxemT58etfann35CUVFRTEVrz549aNmyJWbPno2LL74YALBmzRp06dIFixcvxkknnYQPP/wQ55xzDrZu3Rqpck2fPh133XUXdu7cCa/Xa/a3ghBCCCGEECIw0vjaAoEAli9fjnHjxkXec7vdKCsrw+LFi+PuWbx4cUzDX3l5ecrxm4eyfPly1NXVoaysLPJecXExjj766IjQWrx4MY477rgoK2F5eTmuv/56rFq1KsrTGsbv98Pv90e+DoVC2L17N5o3bx419pMQQgghhIiLoijYu3cvCgsL4XaLZxarra1FIBCwNIfX60VOTo6lOWREGqG1a9cuBIPBKDEDAK1bt8aaNWvi7qmqqoq7vqqqSnXeqqoqeL1eNG3aNGGcRHnCn8Vj8uTJuPfee1UfByGEEEIIEZdNmzZFTQ8UgdraWhS1b4KqHUFL8xQUFGDjxo0UW4chjdByGuPGjYuqtu3ZswdHH300Tm18CbJc2TYemTy4vD67D0EbOTZbSHPS8/1Ssq39+VVyzP21pWR7Ui/SQNBnTryQ11ickNfYXdWgV39lXe/eULbefdr36DnGkMYfPa3HpXV9UMOvFC3Hrqg8jpBXfeeB4lG3VlEZU8kOqVrnUrHOk63uAlTNOp+aNVmJHxAbJic7+ZS63KzUU+wap4jR2ONP+jkANM5KXgU5Iqs26edNPMk/z/McTPr5ESn257sT72+S5LOGvYlj57uTf++OOKxqtXdfCL367sARRxyRdJ8dBAIBVO0IYv2ydsg7wppqW83eEH7XdxMCgQCF1mFII7RatGgBj8eD7du3R72/fft2FBQUxN1TUFCgaX2iGIFAANXV1VFVrUPjFBQUYOnSpTF5wp/Fw+fzweeLvfDNcmUjy8WeLlXUNfxBdsX5PgpJAGkTO7bm/991huK1SHDVmSy2/ncdpnjNiZkVNElshQyKrf+dV8in7w9rlqJfMBnZC2jf64F2keJJQ550rFcrtrTGVrM2/JOlVnApWWKKrXA2jze5SFIAZKUQUvUAfNnJhVQ9fCnFVh18yPUmvtivQ8Pv8mSCyw8fmmQnFkoBNPzwNMlKLLjq4EXjJJ/7kY28JGKrDtlJxVIA2cj3HEj4eT2apNh/BJom2B9CwzOqjkgguOrRGE0TfBb83/e3aRLBdbjYAiB060feEW7LhBZJjDTfca/Xiz59+mDBggWR90KhEBYsWIDS0tK4e0pLS6PWA8D8+fMTro9Hnz59kJ2dHRVn7dq1qKysjMQpLS3Ft99+GzX9cP78+cjLy+ND3NKA4k99V04Yam0+1jTmdwW0PTdEU+za1HeENccMmBfT4zfHouEOGI/j9qu7GI2HJ6DAE9A3L8noXq246xpeWvNozaU1h9bj0rreo6HtQutxqF4bUHdx6apXuS7ggktFTFedG6661Jcxioo1ABAMpL6xUV+Xeo2/LvVNG3996jUHA6nV7sH65Gv21Xmxry65Gt9Xn/wG3P4Un9fU56CmPnEVY28wB3uDiT/fE2yEPcFGSfcnozrJXgDYG8pNvDfJZw2fJ/7+7g3p/91KMgdpKlpAw8Pshg8fjr59++LEE0/E1KlTsX//fowYMQIAMGzYMLRt2xaTJ08GAIwePRqnnnoqpkyZgoEDB2LOnDlYtmwZnn/++UjM3bt3o7KyElu3bgXQIKKAhkpUQUEB8vPzMXLkSIwZMwbNmjVDXl4ebrrpJpSWluKkk04CAJx55pno2rUrrrzySjzyyCOoqqrC+PHjMWrUqLhVK2I+YbElRXUrLHbsqm6lMb8rUGdZZSsstsysbrkC9aZVtsJiy2h1yx0IGrYRuv0h3ZUtoEGQ6K1Q6d2rd5+7Tkd1S2OusAjRkkfrcWlZHxZbaqpbWo5d09qAS1VlKyy21FS3XAGXquqWq86dsroVFlupqlvBgCdlZSsstpJVt8JiK1l1Kyy2klW3wmIrWXXrYH12Sivhvjpv0urWvnpf0spWWGwlq27V1OckrW7tDeYkrU7tCTZKWN0Ki61E+6uDjRJWtoAGsZWoshUWW4mqW9Wh7ISVLYotkgppKlpAw7j2v/3tb5gwYQJ69eqFlStXoqKiIjJ4orKyEtu2bYus79evH2bPno3nn38ePXv2xNtvv4158+ahe/fukTXvvfceevfujYEDBwIALrvsMvTu3Ttq/Pvjjz+Oc845BxdddBF+//vfo6CgAHPnzo187vF48P7778Pj8aC0tBRXXHEFhg0bhvvuu8/qbwk5DFa3xMvvCtRJVd1yBeqFq265A0HD1S0jlS1AX5XJ6F69VTGtVadwLqvzWL3e7uqWO+CypLqlap3KqpWa6paayhYgVnXrYH22qupW0s/rfaZUt5KRqjqVrLKVan91sFHS6layyhaQvLqVrLLVEJuCi8RHqudoOZmamhrk5+fj9CaXs0fLBKSobB2Knb1bacxtWd8WzB+SAZjXtwWIMyQD0N+3FcaOQRn6B2xYn0tPDisHZWgakmFy31Zkrcl9W4C63i0zh2QAqfu2gNR9W0Dqvi1A3ZCMZJWtyJoU1a1kla3ImiSVKyB5ZQtA0spWmGTVrWR9W6n2Akha3QIS920BiStbv30e+/3duzeEXl13YM+ePcjLy0u6P92Ery93rG1v6TCMVsf+LOT5241UFS1C1KL4/axuacmdxuqWZbFr6y2pbpmFxx80rbplOIak1S09pKO6pac/zMr1WitbqitWWtZqqGyZWd3S0rdlVnVLbWUrVXXLX5+Vsrp1MJCtqrqVDLP6tpJVt1L1bQHJq1Nq+rZSVbeS5k7Rt2WkukVSEwwGcc8996CoqAi5ubno1KkT7r//fqSq/fj9fvzlL39B+/bt4fP50KFDB7z88suRz2fOnAmXyxX1snsKolQ9WoRoRfH75alu1frtrWylKX9YbFnZu2V23xZgXnXL4w+a0rcFGKtusW/L/FxW9mFpXa+lb0trbLVrw2JLbe9Wuvu2gAbBla6+LaBBcKWqbvnrs1JWtw4GslP2bQHJq1tq+raA5NWt/fU+2/q2Uu0Pi61E1a1kfVtAg+DS07dFUvPwww/j2WefxaxZs9CtWzcsW7YMI0aMQH5+Pm6++eaE+wYPHozt27fjpZdewu9+9zts27YNocNsm3l5eZF5C4D9kyAptIjj4aAMjfnTlNvqQRlmWwnNHpRhhpXQ6KCMcGVLr+AKV37SKZr05tQrtrTm0iOeAG0iR8t6T8BesQVoG5QhstgCUlsJ6+s8wogtIPWgjFRiC1A3KENUsQUkH5QRrmwlG5SRTGwByUfAk/gsWrQI559/fmQ+QocOHfD3v/895lFJh1JRUYHPP/8cGzZsQLNmzSL7Dsflcml6jJPV0DpIMgZaCTXkppUwfkxaCePi5BHwenLRShhnrclWQieMgDfLSpiKTBkBTyuh/dTU1ES9/Amuu/r164cFCxbghx9+AAD897//xcKFC3H22WcnjP3ee++hb9++eOSRR9C2bVscc8wxuP3223HwYLQQ3rdvH9q3b4927drh/PPPx6pVq8w7QR2wokUyCloJxctPKyGthLQSWr9eFCuh2iEZdlS30j0CHjCnusUR8Or2W2kl3COB2Nqr+AHFmvrKXqXh30y7du2i3p84cSImTZoUs37s2LGoqalBcXExPB4PgsEgHnzwQQwdOjRhjg0bNmDhwoXIycnBu+++i127duGGG27AL7/8ghkzZgAAjj32WLz88svo0aMH9uzZg7/97W/o168fVq1ahaOOOsq8E9YApw4KAqcOph9pBBdgr+BKY35OJTSO3VMJ7ZhIqHev3msj0aYSao3vxKmEasQWwKmEgBxTCVNNFRRtKuG+vSGc2n2LkFP3wteXP64pwBEWTR3cuzeETsVV2LRpU9T5+3y+uM+TnTNnDu644w48+uij6NatG1auXIlbbrkFjz32GIYPHx43x5lnnon//Oc/qKqqQn5+PgBg7ty5uPjii7F//37k5sZWHevq6tClSxcMGTIE999/v0lnqw1aB0nGQiuhePlpJZTfSmjUDkgr4W97rIpvpZVQdVwLnrclu5Uw5RoTnrcFZI6VMBlGrYQkPnl5eVGveCILAO644w6MHTsWl112GY477jhceeWVuPXWWzF58uSEsdu0aYO2bdtGRBYAdOnSBYqiYPPmzXH3ZGdno3fv3li/fr2xEzMAhRbJaKQaA59BYosPODZGJj/gWA+Z+IBjT8CaBxzLMAIeUPeAY7NHwKcSXCKNgAfUPeA4GalGwAPWPuDYzr4tkpwDBw7A7Y7+t+XxeGImCB7KySefjK1bt2Lfvn2R93744Qe43e6EtsBgMIhvv/0Wbdq0MefAdUChRQgkqm6lcVCF3fllEluA+dUtMzBDbBmtbqV7r96qmF6xpae6JdJ6K8SWlrXugMuS6paqdSqrVmaJLUCs6tbB+mxV1a2kn9f7TKluJcOI2Eq1vzrYKKngSia2AFa39HLuuefiwQcfxL/+9S/89NNPePfdd/HYY4/hggsuiKwZN24chg0bFvn68ssvR/PmzTFixAh8//33+OKLL3DHHXfg6quvjtgG77vvPnz88cfYsGEDVqxYgSuuuAI///wzrrnmmrSfYxgKLUL+hzRiC8io6pZlsWklVB+DVkJTc2nNY/V6u8UW4AwrYTDgoZUwAWaIrVRWwlT7k5FKbNFKaC5PPvkkLr74Ytxwww3o0qULbr/9dvzpT3+K6qPatm0bKisrI183adIE8+fPR3V1Nfr27YuhQ4fi3HPPxRNPPBFZ8+uvv+Laa69Fly5dMGDAANTU1GDRokXo2rVrWs/vUDgMQxA4DEMspBmUkSFDMgAOyjADo4MyjAzJAOwZlKF3n54BFukYyGH1ersHZagdkgGIPSjDrCEZQPoGZaQakgGkHpSRakgGIPagDL1DMvbvDeK8Hj9m/DAMEc/fbljRIiQO0lS3aCU0JzathOr200qYMpfVeWgl/A3ZrYRq+rYAWgkPR2QrISGHQ6FFSAI4KEO8/JluJTQDWgnVo8dKmK6+LVoJGxBdbDnVSpgKmcUWYMxKSMihUGgRkgKpxJbd1a00kMlTCc3s2+JUQvWI2LcV3mPVeitHwNs1ldAJI+DNmkqYClH6tqweAW/VVEJCwlBoEaICacQWYL/Yckh1y/SYDqxu0UqYOpfVeWQcAa9lrehWwnSPgAfMqW5xBLy6/bQSEqNQaBGiEloJxctPK6FxaCVUD62E6mJbslZgsQU410rIvq0GUomtfRIIrr2hkKUvEh8KLUI0IpXYsru6lQZoJaSVkFbC3/ZYtd5KK6HquLQSRiFa35YTrITJSGUlJCQeFFqE6IDVLQ25HVLdMj2mA6tbsloJ9UAroXmxrejbAjLDSmhm3xathMb7tgg5HAotQgxAsSVWfoot42SilTDdfVsiWgm1YLeVUPS+LYBWwqSfS24lTNW3RcihUGgRYhCpxJbd1a00YKWV0Kq+LRGthIZjZIiVUI/FT08uq62E7NuilTCMTFbCZKixEqbanwyKLaIGCi1CTIBWQg25Wd2KH1Ow6hb7trRBK2HquDKMgAfEthKmItOshKn6toDkgsnqEfCEUGgRYiIUW2Llp9gyTqb2bTnNSmjlerurW06yEqYinSPgAVoJ1eyvDjbCHgmmDhJ7oNAixGSkElt2V7fSAK2E8lsJnT4CXk8uq0e600qozUqoBqf2bQHqrISpkFlsEZIICi1CLIBWQg25Wd2KH1Ow6hathNrIVCuhlrhOshKK3LdllpUwFaL0bVk9Ap6Ci2iBQosQC6HYEis/xZZxaCVUT6aKLburW6JbCdM9Ah4wp7olS98WwOoWEQcKLUIsRprqFq2ExmPTSqg+Bq2ESfOIOAKeVkKOgAfYt6V2PyEAkPpfFCHEFBS/Hy5f8j8MQlDrB3JsOs6w2EpDflegDoo39d1XXbFr66HkmPvr1RWoh+I1J6bHH0TQl/rCLBlhsRXy6o/j9ocQ8um/3+cJKAh61T/A1oy9eve564CQxh83rbnCIkRLHq3HpWW9JwAEU7fmROIC6mJrWhtwIeRNLVrDYkvJSr42LLaUFDHDYkvJTn5DQalzw5ViDdAguDze5Dc46us8yMpOvsZflwVfdvIbN/76LPiykq85GMhGrje56j1Yn43crMRrwmKrSXZiVb6v3ocmWYlvwu2v96Fxks/DYisvqzbu52GxdIQn/udhsZXvOZBwf6K9orEnlI1gyJr6yr6QMVu4k2FFi5A0IkVlC8io6pZlsWklVLefVsKUuazOkwlWQrVkgpUw00bAA9ZWt9i3RZJBoUVImpHGSghkjNiildAYtBKqh1ZCdbHNXit63xZAK2HSzyWwEhISDwotQmyCYktlbla34scUrLrFqYTaEHEEfHiPVeutnEqoOq6NI+BFnUqYcg1HwEeg2CJaodAixEakqW7RSmg8dgaILSBzrYR6oJXQvNgyjIAH7LESpkIkK6FZI+CTCS6rR8ATcigUWoQIgBRiC8gYsUUroTEy0UqY7r4tEa2EWqCVMDUyjoAHaCUk5FAotAgRBIotlblZ3YofU7DqFq2E6tFj8dOTy2oroWx9W4C9VkI1OLVvC6CVkGQGFFqECASthBrypwGKLePQSqgeWglTx3WSlVDkvi2zrISpSJeVMBlmWAlrgrlJc5DMhUKLEAGRQmwBGSO2ZLMSmgWthPKMgE+HldDK9XZXt0S3EqZ7BDxgTnUrk0bAExIPCi1CBIViS2VuVrdi45nYtwXQSijDCHg9uawe6U4rIUfAh8mUvi1CDodCixCBoZVQQ/40IJPYApxrJTQCrYTG88g6At4uKyFHwDeQKVZCQg4l9b8MQojtKH4/XL7kfxyEoNYP5Nh0nGnKHRZbijf1RYPm2P8TW0qOeb+aXYF6KF5z4nn8QQR9qS/MUuEOBBHy6o8TFlshn757hZ6AgqBX3cW0WXvDAkjrXncdENL4o6bnGLXmsXJ9WGwFU89C0Bxb7dqw2Ap5UwtXV70LSpaKdQEXFDXx6txQspPfUAiLLVeKdcGABx5v8psbYbGVlZ14XVhs+bIT37wJiy1fVuI1YbGV602seg/WZyM3K7kq3lfnRZPsxKp8X70PTbIS34ALi63GSdbU1OcgL6s24ed7gzk4wpP4c9HYE8pBfcj47+947A+ZcyPOibCiRYgkSFXdsjM3q1ux8QQdAW9ndcuOEfDhvVrRYyUUdQQ8rYS0EgK0EpLMgUKLEMmQRmzZLbjSgExiC6CVMB60EsbmyBQroeq4tBJGIZqVMBXpEFv7KLhIAii0CJEQKcQWkDFiK5OnEppBpo6AT+dUQqvziDICXktsK/q2AGdMJUyFmSPgjU4lNKtvK5ngStW3RUgiKLQIkRRaCVXmZnUrNp6gVkLDMWglTJpHRCuhFuy2Eoo+Ah5QbyVMRTpHwAPOsRIScjgUWoRIjjRiy27BlQZkEluAeNUtu/u2AFoJ4+WwslrFvi1tVkI1OLVvC5DDSkjIoVBoEeIAWN0SJzethMahlVA9tBKmjivDCHhAXXVL5L4ts6yEqZBhBDwhYSi0CHEQFFsqcrO6FRuPVsIYZLMS6slDK6GxtaJbCc3u20pXdcuMvi1AnZUwGan6tgBWt0hqKLQIcRjSiC27BVcakElsAeJVt2glVI8ei5+eXLQSxlkrsNgCnGslZN8WkQEKLUIcCK2E4uSmldA4mWol1EOmWgm1xJXBSsgR8A3IYiXcS7FFEkChRYiDodhSkZvVrdh4tBLGYIeVMN19W+mwElq13qoR8FrW0koYjUgj4IH0WAkJOZzUtxMIIVKj+P1w+QT/4xAWOzk2HWetPy25XYE6KN7UFwS6YtfWQ8kx91e6K1APxWtOTI8/iKAv9QVcMsJiK+TVH8ftDyHk03+P0RNQEPSqf6aSGXv17AuLg5DGHzetudx12nJoPS6t6z0BIJh68FwktpbjUL024ELIm1q0uupdULJUrAu4oKiJV+eGkp36ZoJS54Yrxbqw2PJ4k9/gqK/zICs7+Rp/XRZ82clv3Pjrs+DLSr7mYCAbud7EqjcstnKzEq/ZV+dFk+zEijwstppkJb4Bt7/eh8ZJPheVfaFchELGfgcn4kDIHPeCE2FFi5AMgFZCcXLTSmgcWgnV44S+La3raSWklTAZ6RgBT0gYCi1CMghpxJZdgotWwvjxaCWMId2TBY3kzNS+LRGshGpxgpUwFZk2Ap4QgEKLkIyD1S1xcssktgDxqlsyTyW0YwS89vHpHAFvdK3ofVuA+qmEqeAIeEJikU5oPf300+jQoQNycnJQUlKCpUuXJl3/1ltvobi4GDk5OTjuuOPwwQcfRH2uKAomTJiANm3aIDc3F2VlZVi3bl3k888++wwulyvu6+uvvwYA/PTTT3E//+qrr8z/BhBiEhRbYuSmldA4sootI3sz2Upo9Qh4LVZC1XEtEFtqrYRq4Aj4JJ+rGgGvsjGQZBxSCa033ngDY8aMwcSJE7FixQr07NkT5eXl2LFjR9z1ixYtwpAhQzBy5Eh88803GDRoEAYNGoTvvvsusuaRRx7BE088genTp2PJkiVo3LgxysvLUVtbCwDo168ftm3bFvW65pprUFRUhL59+0bl++STT6LW9enTx7pvBiEmII3YopXQWGxaCVPvl7Rvi1ZCdVhlJbSzbwtQV90SuW/LSVZCQuIhldB67LHHcO2112LEiBHo2rUrpk+fjkaNGuHll1+Ou37atGk466yzcMcdd6BLly64//77cfzxx+Opp54C0FDNmjp1KsaPH4/zzz8fPXr0wCuvvIKtW7di3rx5AACv14uCgoLIq3nz5vjHP/6BESNGwOWK/gXXvHnzqLXZ2dZMFyPETGglFCe3TGILEK+6ZbeV0I4R8OG9WqGV0NzYTrESpnsEPOAsKyEhhyON0AoEAli+fDnKysoi77ndbpSVlWHx4sVx9yxevDhqPQCUl5dH1m/cuBFVVVVRa/Lz81FSUpIw5nvvvYdffvkFI0aMiPnsvPPOQ6tWrdC/f3+89957Sc/H7/ejpqYm6kWInVBsiZHbaiuh6TEFE1sArYRaoJXQ3ONQvVZgsQXQSpj0cxVWQpKcDh06xG25GTVqVNz1dXV1uO+++9CpUyfk5OSgZ8+eqKioiFmntb0oHUgjtHbt2oVgMIjWrVtHvd+6dWtUVVXF3VNVVZV0ffh/tcR86aWXUF5ejqOOOiryXpMmTTBlyhS89dZb+Ne//oX+/ftj0KBBScXW5MmTkZ+fH3m1a9cu4VpC0oU0YotWQv1x2belbj+thClzWZ1HFCshR8AnRzaxBdBKaDdff/11VKvN/PnzAQCXXHJJ3PXjx4/Hc889hyeffBLff/89/vznP+OCCy7AN998E1mjtb0oXUgjtERg8+bN+OijjzBy5Mio91u0aIExY8agpKQEJ5xwAh566CFcccUVePTRRxPGGjduHPbs2RN5bdq0yerDJ0QVtBKKk1smK6ET+7aAzLIS6smTDiuhlevtrm7RShiNmX1btBKKS8uWLaNabd5//3106tQJp556atz1r776Ku6++24MGDAAHTt2xPXXX48BAwZgypQpkTVa24vShTRCq0WLFvB4PNi+fXvU+9u3b0dBQUHcPQUFBUnXh/9XbcwZM2agefPmOO+881Ieb0lJCdavX5/wc5/Ph7y8vKgXISJBsSVGbpnEFiBedcvuvi1AHiuhHoufnlx6+rBoJWyAVsJD1ghkJdwfpOACENMS41dxHREIBPDaa6/h6quvjpl9EMbv9yMnJyfqvdzcXCxcuDASQ2t7UbqQRmh5vV706dMHCxYsiLwXCoWwYMEClJaWxt1TWloatR4A5s+fH1lfVFSEgoKCqDU1NTVYsmRJTExFUTBjxgwMGzZM1ZCLlStXok2bNqrPjxARkUZsOdxKyBHwxslUK6EeMtVKqCUurYSJkU1sAeqshLKzJ5SL6mAjS157QrkAgHbt2kW1xUyePDnlcc2bNw/V1dW46qqrEq4pLy/HY489hnXr1iEUCmH+/PmYO3cutm3bBkBfe1G6SP0TKhBjxozB8OHD0bdvX5x44omYOnUq9u/fHxlMMWzYMLRt2zbyH3b06NE49dRTMWXKFAwcOBBz5szBsmXL8PzzzwMAXC4XbrnlFjzwwAPo3LkzioqKcM8996CwsBCDBg2Kyv3pp59i48aNuOaaa2KOa9asWfB6vejduzcAYO7cuXj55Zfx4osvWvjdICQ9hMWWyyf4HbtaP5Bj0zGmKbcrUAfFa800U1dtPZQc8/4khMWW4jUeMyy2gr7UF2fJcAeCCHkNxvCHEPLpu0cZFiNBr7oLajP26t3nrgNCGn/UPAHF8jxWrg+LraDKa2otsdWudQdcCHnViVZXvQtKVuq1roALioqYrjo3lOzkNxPCYsuVYl0w4IHHm/zmRn2dB1nZydeExZYvO/HNm7DY8mUlXnMwkI1cb3LFe7A+G7lZideExVaTbA2qPMPYtGlTlEPLp+K64aWXXsLZZ5+NwsLChGumTZuGa6+9FsXFxXC5XOjUqRNGjBhhuy1QDVIJrUsvvRQ7d+7EhAkTUFVVhV69eqGioiKiYCsrK+F2//YHsF+/fpg9ezbGjx+Pu+++G507d8a8efPQvXv3yJo777wT+/fvx3XXXYfq6mr0798fFRUVMSXKl156Cf369UNxcXHcY7v//vvx888/IysrC8XFxXjjjTdw8cUXW/BdIMQeFL+fYkuA3DKJLaBBcJkhtoAGwWWG2AJgSHAZEVuAPkFidK9eEQRoEzZ6hJ0e8aTluLSu9wTsF1sAVAkuO8QW0CC4zBJbAFQJrmRiC2gQXKnEFoCkgiuV2AIaBBfFVny0tsL8/PPP+OSTTzB37tyk61q2bIl58+ahtrYWv/zyCwoLCzF27Fh07NgRgL72onThUhRFv5+BmEZNTQ3y8/NxepPLkeWSv0RNnI3wgguwT3ClMbdVgguA6YLLLLEFGK9shTFa3QJgSHDpFVtG9urdp7W6pTeX1jxWrlcrtrTG1nIMaqtbasRWZK2KmGrEFpC6shUmleACUostIHllK7ImidgKk6q6BSCl4DpUbNXtD+CfZ76EPXv2CNdzH76+fHbFCchtYk195eC+elx//Neaz3/SpEl47rnnsGnTJmRlqT+2uro6dOnSBYMHD8Zf//pXAA2zEU488UQ8+eSTABrai44++mjceOONGDt2rLYTMhFperQIIeIgTe+Ww3PLNCiDUwljSfdkQSM5M7Vvy4pBGXb2bQHqBmWwb8ucEfAkMaFQCDNmzMDw4cNjRNawYcMwbty4yNdLlizB3LlzsWHDBvznP//BWWedhVAohDvvvDOyZsyYMXjhhRcwa9YsrF69Gtdff31Ue5FdSGUdJISIA62EYuSmlTBzrYRGe74y2Uqo7RxoJUyG2X1bQPLqlpl9W4A5VkIfaCXUyieffILKykpcffXVMZ8d3gpUW1uL8ePHY8OGDWjSpAkGDBiAV199FU2bNo2sSdVeZBe0DgoCrYNEZoQXXACthEZj00qYer8BsQXQSmhGHlGshJrsgTZaCdWILYBWQiC5lbB+vx+fDpxO66CA5283tA4SQgxDK6EYuWklNEamjoCnlVAdWqyEHAGfHCdaCQmJB4UWIcQUKLbEyC2T2ALEe+aW3Q84Ntq3le4HHOvJo+cBxyKtt/sBx+6AS+gHHCt1btUPOE5FfZ0npeDy12WlFFz++qyUgutgIFvVA44J0QKFFiHENBS/X3zBxQccG4vNBxyr229AbAHyPOBYSzXGSC6teaxeb7fYArRVt1StM1FsAeqqW2rEFiBWdetgfTYFF1ENhRYhxHSEF1sAq1tGY9NKmHq/pFZCPWSqlVBLXLuthKrW2WAlDAY8tBISx8Kpg4QQS+BUQjFycyqh8amERodkGJlKaHSyoJ69evdpneanN5eeqYRWrQ+LLbunEqqdSAioG5Qh8lRCNQ83BsyZSphqSIaaqYSisDeYg/qgRcMwgubbyp0CK1qEEMuglVCM3LQSGsPuvi1AnupWOq2EWtc72Uooet8WYJ6VUE3fFmBOdUtt3xarWyQRFFqEEMsRXmwBtBIajS24ldAMaCVUj4h9W+E9Vq230kqoOq6NVkI1ONlKSEg8KLQEw+UV3GpFiE6kqW45PLdMYgswr7olSt8WYO9UwnTmzNS+LSuqW3aOgAfUVbc4Ap6QWCi0BET4vhZCDCCF2KKVUH9sWgnVxbDJSmjHCHjt49PTMwLeqmmAAK2EqXDyCHhCDoVCS1AotoiTEV5sAaxuGY3tcLEF0EqoBSdYCWXr2wKcMwKe1S0iKxRaAkOxRZwMrYRi5JZNbNFKGA2thMbziGIlFGEEvBrBZccIeIBWQiInFFqCQ7FFnI4UYotWQv2xBe7bAmglpJUwPevtrm5lmpUwFWZaCQlJBoWWBLh8Pgou4miEF1sAq1tG4mZA3xZAK6EWRLQSOn0EPOAcK2Eq0j0CvraOgovEh0JLIii2iJOhlVCM3LQSGkMEK2G699JKqH5tpo+AN8tKKGLfFiHxoNCSDIot4nSkEFu0EuqPTSuhuhg29m2l20qoJ4/MVsJMHgEPONtKSMjh8CdGQlw+n/gXo4QYQPH7xb+pUOsHcmw6xjTldgXqoHjNt8SExZaSY96fIFegHorXnHgefxBBX+qLs1S4A0GEvPrjuP0hhHz674d6AgqCXnUXv2bt1bMvLA5CGn/UtOZy12nLofW4tK73BICgV31sLcehZm1YbIW8qUWrq94FJUvFuoALipp4dW4o2alvJih1brhSrAsGPPB4k9/YCIutrOzk6/x1WfBlJ79x46/Pgi/L/BtGVlMTzEUgaI3FsTZonRNCdljRkhThL0IJMQithGLkppXQGOzbUo+IfVvhPVatd2rflloroRpoJSQyQ6ElMRySQTIBKcQWrYT6Y2eIldBwDMmshOzbUr/WiSPgAXVWQqePgCeEQssBUGwRpyO82AJY3TISNwOmEtrdtwXIU90SeQS8VVUlwP7qVqaNgE8luNi3RcyAQsshUGwRp0MroRi5aSU0Bq2E6nGClZAj4O0bAc/qFhEBCi0HQbFFMgEpxFYGWAkti00roboYNloJ05mTVsLUcWWwEtoxAh5Ir5WQkHhQaDkM9m2RTIDVLftzW923RSuhihg2WQntGAEvqpXQyvV2V7fUii3AGVbCVKixEhJyOBRaDoVii2QCFFv255apumW2ldAMaCVUj4hWQqvXiyC2nGIlTIWavi2A1S2iDQotB0OxRTIBKcQWrYT6YwtsJRSlbwswbiVM915aCdWv1Sq2tFgJVcflCPgoKLaIWii0HA7FFskEaCW0PzethMaw20poxwj48F6t6BVbMlsJtfRtaYnNEfDxodgiZkGhlQFQbJFMgWLL/twyVbdEE1uAOVZCI8hiJdTTt6UnVzpGwNNKKG7flhkj4Elmw5+ODCEstoS/ECXEIIrfL/bNhbDgybHhGGv9acnrCtRB8WZbE7u2HkqOeX+6wmJL8RqPGRZbQV/qi7hkuANBhLz6Y4TFVsin716qJ6Ag6FU/CMGMvXr3ueuAkMYfNa25wiJESx6tx6VlvScABL3mx9W0NuBCyJtatLrqXVCyVKwLuKCoiVfnhpKd+maCUueGK8W6sNjyeJPf3Kiv8yArO/kav4oKmN3sC+agLmjN72V/UPzztwtWtDIMoS9ACTEJWglT5HWAldD0mIJVtzLRSsi+LfVrOQJePCshIfGg0MpAKLZIpkCxZX9u9m0Zg1ZCdYg8At6qBwsDtBKmIt1WQkIOh0IrQ6HYIpmCFGLLzupWGpCtb8tpUwk5At7cXHpEnZP7tgBrphKqWpfmEfAAq1tEGxRaGQzFFskUaCVMkZdWwtiYglW3RBgBn27RRCuh+rW0EppjJTRzBDwhAIVWxuPy+Si4SMZAsWV/bloJ9WN33xaQftGkN6fIVkIr19td3VIrtgBnWAkJSQWFFgHA6hbJHKQQW7QS6o9NK2Hq/bQSmprL6pHuslkJRe/bAsyzErJvi6SCQotEoNgimQKthCny0koYG1PA6pbhGLQSJs1ldR6rrYRa4mqxEqqOa4HYUmslVIOZVsIgxRZJAIUWiYJii2QSFFv256aVUD+0EqpHr9iS2UqopW9LS2w7+7YAddUtO0bAExIPCi0SA/u2SCYhhdiilVB/bMGthGZAK6E69PRt6cnFEfCHrRPcSmhm3xYhh0OhRRJCsUUyBVoJU+SllTA2psP6tgDjVsJ073VS31Z4j1Xx7RZbgHNGwFNwES1k2X0ARGxcPp/4F6CEmITi94t9g6HWD+TYdHxpyu0K1EHxZpsf939iS8kx78+eK1APxWtOPI8/iKDP2AVcWGyFvPrjuP0hhHz67sGGxUjQq37ynNG9eve564CQxh8zT0CxPI+V68NiK+hVFxdQF1vT2oALIW9q0RoWW0pW8rVhsaWkiBkWW0p28psJSp0brhRrgAbB5fGaU5FOF3vrc+CvN/93KwAE6ik+E8GKFkmJ0BeehJiM8DcWaCU0FtvhfVuAOVZCI8hS3RJ5BDythA3QSkhkh0KLqIJii2QStBKmyJsmK6FlsQXv2xLBSpgpfVsArYRmH4fqtQKLLcC8EfAks6HQEo0cFTV9m+CQDJJpUGzZm9vqvi2nV7fsnkrIEfDG88g6At6KqYSq1mkYAW/WVMJgwMPx7iQhFFoiYlcPhkootkgmIYXYopVQf2yHiy1AXiuhHSPgRbUSWrXeqhHwWtbaNQIeMNdKSEg8+JMjKhRbhAgDrYQp8tJKGB2PVsIYaCWMzWGlNVA2K6HofVuA+mduEXIo/KkRGYotQoSCYsve3Jk6Ah4wz0poOAathElzWZ1HViuh6rgUWxlBhw4d4HK5Yl6jRo2Ku37VqlW46KKLIvumTp0as2bSpEkx8YqLiy0+k9TwJ0Z0cnxCCy72bZFMQ/jqFq2E+uOyb0tdjAyyEurJQyth/HV2WQnt6Nsiyfn666+xbdu2yGv+/PkAgEsuuSTu+gMHDqBjx4546KGHUFBQkDBut27douIuXLjQkuPXAp+jJQs5PnvvVqeAz9simQafuZUkL2B5bquetwU0CC6zn7cFwJRnbpnxvC2gQXAZfd4WAEPP3NLzvC0je/U+Bwuw/plbep6fpeW4tMb3BNQ9b0trbLVrw2JL7TO3Uj1vC2gQXKmetwU0CC41z9sCoOqZWySWli1bRn390EMPoVOnTjj11FPjrj/hhBNwwgknAADGjh2bMG5WVlZSIWYHlOUyIXBlC6CVkGQewt9coJVQf2yBrYSi9G0Bxq2E6d7rpL6t8B6r4tvdtwXQSpgJBAIBvPbaa7j66qvhcum7+RJm3bp1KCwsRMeOHTF06FBUVlaadJT64U+IbFBsESIUtBKmyJ0GaCXUj91WQqN2QD172belfq0WK6EII+BpJbSXmpqaqJdfxd/GefPmobq6GldddZWh3CUlJZg5cyYqKirw7LPPYuPGjTjllFOwd+9eQ3GNQuugjITFlqBWwrDYEvrikxCToZXQ3ry0EhrDDCuhXhsh4GwrYVhs0Uqof6074FJlIwTstRKKzP56L+rqrXlWa+B/Arddu3ZR70+cOBGTJk1Kuvell17C2WefjcLCQkPHcPbZZ0f+f48ePVBSUoL27dvjzTffxMiRIw3FNoL4PxmH8fTTT6NDhw7IyclBSUkJli5dmnT9W2+9heLiYuTk5OC4447DBx98EPW5oiiYMGEC2rRpg9zcXJSVlWHdunVRa+JNR3nooYei1vzf//0fTjnlFOTk5KBdu3Z45JFHzDnhZLC6RYhQCH9zIQNGwNNKqB+OgFcPrYTmHoeqdRKMgM90Nm3ahD179kRe48aNS7r+559/xieffIJrrrnG9GNp2rQpjjnmGKxfv9702FqQ6ifnjTfewJgxYzBx4kSsWLECPXv2RHl5OXbs2BF3/aJFizBkyBCMHDkS33zzDQYNGoRBgwbhu+++i6x55JFH8MQTT2D69OlYsmQJGjdujPLyctTW1kbFuu+++6Immdx0002Rz2pqanDmmWeiffv2WL58OR599FFMmjQJzz//vDXfiEOh2CJEKKSwEjo8N62E+pHdSpjOnJlqJdQSV5YR8GqthCQ5eXl5US9fimvAGTNmoFWrVhg4cKDpx7Jv3z78+OOPaNOmjemxtSDVT81jjz2Ga6+9FiNGjEDXrl0xffp0NGrUCC+//HLc9dOmTcNZZ52FO+64A126dMH999+P448/Hk899RSAhmrW1KlTMX78eJx//vno0aMHXnnlFWzduhXz5s2LinXEEUegoKAg8mrcuHHks9dffx2BQAAvv/wyunXrhssuuww333wzHnvsMcu+F1FQbBEiHMKLLfZt6Y/tcLEFmFPdMoJMI+C1ChuOgE+8zq6+LUBddUtt3xZJTSgUwowZMzB8+HBkZUXbqIcNGxZVDQsEAli5ciVWrlyJQCCALVu2YOXKlVHVqttvvx2ff/45fvrpJyxatAgXXHABPB4PhgwZkrZzioc0Py2BQADLly9HWVlZ5D23242ysjIsXrw47p7FixdHrQeA8vLyyPqNGzeiqqoqak1+fj5KSkpiYj700ENo3rw5evfujUcffRT19b/9YVy8eDF+//vfw+v9zftaXl6OtWvX4tdff417bH6/P6Zp0BAUW4QIh9BiC6CV0EhsC8QWrYTR0EoYm8NKayCthLQSppNPPvkElZWVuPrqq2M+q6ysxLZt2yJfb926Fb1790bv3r2xbds2/O1vf0Pv3r2jLIebN2/GkCFDcOyxx2Lw4MFo3rw5vvrqq5hR8ulGmmEYu3btQjAYROvWraPeb926NdasWRN3T1VVVdz1VVVVkc/D7yVaAwA333wzjj/+eDRr1gyLFi3CuHHjsG3btkjFqqqqCkVFRTExwp8deeSRMcc2efJk3HvvvSnPWxMckkGIcIR/3oW92WDXkIw05rZqUEZYbJk9KMOMIRmAOYMyjA7JAIwNytAzSOLQvXr36cmpdcBEOJfVeaxcb/eQDED9oAw7hmSQxJx55plQlPjf588++yzq6w4dOiRcG2bOnDlmHZqpSCO07GTMmDGR/9+jRw94vV786U9/wuTJk1P6TxMxbty4qLg1NTUx01p0w4cbEyIcQk8lTNNDhhPmllhsAdZMJRRNbAGQciphuoWaXrEFWD+V0EqxBagTXFqmI2paq0FsAUgpuMKVrVSCi5UtkgppfkJatGgBj8eD7du3R72/ffv2hE+BLigoSLo+/L9aYgINs/rr6+vx008/Jc1zaI7D8fl8MU2DpkIrISHCIfwNhgywEloWm1bC1PszxEqop29LTy49fVhWPVgYoJWQkHhI85Ph9XrRp08fLFiwIPJeKBTCggULUFpaGndPaWlp1HoAmD9/fmR9UVERCgoKotbU1NRgyZIlCWMCwMqVK+F2u9GqVatIni+++AJ1db/9Npg/fz6OPfbYuLbBtEGxRYhwcCqhvbll6tsCxBuUYVRsAcanEqZ7r5P6tsJ7rIpvt9gCrJlKSIhepBFaQIOF74UXXsCsWbOwevVqXH/99di/fz9GjBgBIHZKyejRo1FRUYEpU6ZgzZo1mDRpEpYtW4Ybb7wRAOByuXDLLbfggQcewHvvvYdvv/0Ww4YNQ2FhIQYNGgSgYdDF1KlT8d///hcbNmzA66+/jltvvRVXXHFFRERdfvnl8Hq9GDlyJFatWoU33ngD06ZNi7IG2kaOT2jB5fL5KLhsIHTwYMyLpBfhxRanEuqLyxHw6mLYOAJez16OgFe/1soR8FZMJVS1TuUIeEIOR6oerUsvvRQ7d+7EhAkTUFVVhV69eqGioiIyeKKyshJu92/asV+/fpg9ezbGjx+Pu+++G507d8a8efPQvXv3yJo777wT+/fvx3XXXYfq6mr0798fFRUVyMnJAdBg8ZszZw4mTZoEv9+PoqIi3HrrrVEiKj8/Hx9//DFGjRqFPn36oEWLFpgwYQKuu+66NH1nVMC+LZKCsNhy5+bafCSZg9B9W4B9gzLS1DMmW98WAFN6t8zo2wKMD8qwq2/LyF69fVuAth6pTOrb0hpb7Vqz+7YA9YMyCAnjUlKN8SBpoaamBvn5+Sgr/BOy3BZeXAgstgDB7/I7CLUVLIqu9CG04LKzKp6m3FYJLjPFViSmSYMyAJgiuIxOJQRgSHDpFVtG9urdp3VQht5cWvNYuV6t2NIaV9NaleJIjdgCYodkhA7WYtOt92DPnj3m99wbJHx9ee7HI5HdWMN/DA3U7Q/gn2e+JOT5241U1kFiAgLbCAHBLzYdhFoBRVth+hD6JgOthPrj0kqoLoaNVsJ05qSVMHVcLVZC1XHZt0VsgkIrE2HfFtEIBVd6EFpsAZxKaCS2w8UWYM5UQiOkWzTpzalngIWeYxRNbFkxKMOqvi01got9W0QNFFqZjMBiC2B1y2r02AIpuKyHUwntzS3TVEKOgI+FUwmN5eAI+N9gdYuYAYVWpkOxldHo7cGi4LIe4cUWrYT64maIldBwDFoJk+bSmoMj4A9bS7FF0gSFFqHYynCMDLyg2LIWocUWQLFlJHYGiC1aCdWRqX1bagWXCCPg1QouQg6HQks07BI9EvRtETFhdctaaCVMkpdWwuh4tBLGIIuVUOS+LadbCdVCsUX0QKElIhkwSlkPHJJhHWaMcafgshbhxRarW/rimiy2ADGrW4ZjZIDYAmglNPs4VK2zoG+LkDAUWqJiZ4VJYLEFsLplFWY9M4uCyzqEFlsAxZbeuBnStyXzCHg9e0Xu29KThyPgG6DYIlqg0BIdiq24UGxZg5kPKKbYsgZaCZPk5Qj46HgmWwnNQNa+LSN7nWYltGq9E0fAE0KhJQPs24oLxZY1mC22KLisQXix5eDqlkx9W4B51S32bdFKmI71tBISJ5Fl9wEQleT47LtwsTN3CsJiS+iLTglx5+aaKpDCscwUcaTh517oGw61fntu1qQprytQB8WbbX7c/4ktJce8P9GuQD0UrznxPP4ggj6PoRhhsRXy6o/j9ocQ8um7XxwWI0Gv9gtlT0DRvU9PTncdENL4Y6bnGLXmsXK9JwAEvebH1bQ24ELIm1q0yiK29tdlI6tO5TdVI/V1+m9eOB1WtGSCfVsJEfpiU1KsEEWscJkPrYRJ8tJKGB1PsL4tQF4roSwj4DPFSmj7CPigHGKLpB8KLRmh2IoLxZb5WFWBotgyH+HFFq2E+mIL3rdFK6HYfVt6cnEE/GHrNFgJCTkcCi1ZYd9WXCi2zMdKsUXBZS5Ciy3A0WIL4FRCI4gwAj7d/VdO6tsK77Eqvt1iC9D2zC1CwlBoyQyftxUXPm9LLii2zIVWwiR5aSWMjieg2Mo0KyFHwKtfa+UIeCsecEwIQKElP+zbSgjFlnlYPcSC1S3zodiyLzethMaglVAdHAFvbmyKLWIFFFpOgWIrLhRb5pGOiYEUXOYivNiilVBfXFoJ1cXIALEFiGkl5Ah4Qhqg0HIS7NuKC8WWeaRrPDvFlnnQSpgkL62E0fEEFFt2WgmN9m3RSiivlVB1XIotkgIKLafBvq24sG/LPNIptii4zINiy77csoktM62EZiBr35aRvbQSqsMqKyH7tohZUGg5EfZtJYRiyxzS+eBhii3zEF5sOdhKKFPfFmBedYt9W861Empd7/QR8ITEg0LLyVBsxYViyxzSLbYouMyBVkJ787JvSz+yWwnTmVPEvq3wHqvi2y22CIlHlt0HQCwmx2fPhUtYbNlpCUqCy+cT+2JTEty5uWkVQOFc6RR5TkXx+8W96VDrt+eGTfj3lcW5XYE6KN5sa2LX1kPJMe9Pe1hsKV7jMT3+III+j+E47kAQIa/+OG5/CCGf/vvMnoCCoFd7BSMsZPTu1brPXQeENP6YpSOPlevDYivoVRcXUBdby1pROVifjax6a06gvt6YPdfJsKKVCdBKGBf2bZmDHaKH1S1zEPpmA62E+mPTSph6f4ZYCUXu23KylZCQMBRamQTFVlwotozjzs1Nu+CindAchBZbgKPFFkAroRE4Al49tBKaexyEqIVCK9Og2IoLxZY5sLolJ+zbSpKXUwmj4wkotmTu2+IIeOePgCeZDYWWYCjZaTAA83lbcaHYMge7xBYFl3GEF1sOrm7JZCU0ewS8CNUtjoBPnocj4OOvo+AiqaDQEhCrmqSjYN9WXCi2zMGuYRUUW8YRWmwBjhZbAK2ERmDflnpEtBJavZ5WQmIHFFqCkhaxBVBsxYFDMszBTrFFwWUMWgmT5KWVMDqegGJLZithOnPSSmheXBfFFkkAhZbAZITYElxwEWPYOYadYss4wostB1e3MtlKaAayWgnTLdT0iq1MsRLSHkiMQqElOIo3O31WQrug2HI0dostCi5jCC22AEeLLcBaK6HpMR3Yt5UJVkK9YoIj4AlJDYWWJLBvyz4otoxj9wOGKbaMQSuhvXnZt6WfTLUS6kHEvq3wHqviU2wRq6HQkoiMsBIKCvu2jCOC2KLgMgbFVoK87NuKjieY2AIyz0rIvi31a60aAU8IAGTZfQBEG4o329I/uBFyfPZcuITFll0XTSlw+XxiX2wKjjs313axEzp40HbRJzOK3y/uTYfw7w07btrU+i3PG/7db8VNN1dtPZQc8y4JwmJL8RqPGRZbQZ/HUBx3IIiQV3+MsNgK+fTdo/YEFAS9rrTu1bMvLCRCGn7MwmJLSy53nbYcVq4Pi62g15pjEYHaumx4AtYcdLDO2I0IJ8OKloSwb8tehL3IlAQRRA6rW8agldDevLQS6sdoZQswbiVM914nWQllHQFPMhcKLYlh35Z9UGwZQwSxBbB3yygUWwny0koYHU9AsSVz3xathGJZCQlJBoWW5LBvyz7Yt2UMkcQWBZd+hBdbDq5ucQS8MWTt2zKyN11TCTNuBLz5QzyJQ6DQcgCOtxLyeVuORRSxBbC6ZQRaCe3Nm4lWQo6Ad66VUOt6UUbAExIPCi0H4WixZXfuFFBs6cedmyuM4GJ1yxgUWwny0koYHY9WwijsGgEvqpVQ5hHwhBwOhZbDYN+WfVBsGUMUsQWwumUE4cWWg6tbtBIaQ1YrYbqFGvu2iBls2bIFV1xxBZo3b47c3Fwcd9xxWLZsmaq9X375JbKystCrV6+Yz55++ml06NABOTk5KCkpwdKlS00+cm1QaDkQ9m3ZB/u2jEGx5QxoJbQ3ryxiC6CV8HBksRKK3LdllZVQS98WSc6vv/6Kk08+GdnZ2fjwww/x/fffY8qUKTjyyCNT7q2ursawYcNw+umnx3z2xhtvYMyYMZg4cSJWrFiBnj17ory8HDt27LDiNFRBoeVQ2LdlLxRb+hFNbFFw6YdiK0Feia2EIvdtARwB79S+LVoJncXDDz+Mdu3aYcaMGTjxxBNRVFSEM888E506dUq5989//jMuv/xylJaWxnz22GOP4dprr8WIESPQtWtXTJ8+HY0aNcLLL79sxWmogkLL4dBKaB8UW/oRSWwBrG4ZQXix5eDqFvu29CN73xZHwNNKKDLvvfce+vbti0suuQStWrVC79698cILL6TcN2PGDGzYsAETJ06M+SwQCGD58uUoKyuLvOd2u1FWVobFixebevxaoNDKAGgltA+KLf2IKLYouPRBK6F9eTO5b0uE6hathMnzZMoI+EyhpqYm6uVP8Ht/w4YNePbZZ9G5c2d89NFHuP7663HzzTdj1qxZCWOvW7cOY8eOxWuvvYasrKyYz3ft2oVgMIjWrVtHvd+6dWtUVVUZOzEDUGgJhpIT+8NjSlyKLdtg35Z+RBNbAKtbRqDYsi8vrYT6oZVQPRwBLy7++ixLXwDQrl075OfnR16TJ0+OeyyhUAjHH388/vrXv6J379647rrrcO2112L69Olx1weDQVx++eW49957ccwxx1j2PbICa67qiSGUnCxLmo7DYstKOwmABtFjx0VLWGzZdcGUApfPJ/aFpqC4c3OFEzfh4xFRCIqO4veLe+Oh1m/PTZvw7yyLc7sCdZbddHPV1pt6o9AVqIfiNSeexx9E0OcxFCMstkJe/XHc/hBCPn33t8NiJOh16dqrd5+enO46IKTxx0zrMYbFkJY8Wo5La3xZxJbVbNq0CXl5eZGvfQl+17dp0wZdu3aNeq9Lly5455134q7fu3cvli1bhm+++QY33ngjgAaxpigKsrKy8PHHH6N///7weDzYvn171N7t27ejoKDAyGkZghUtQbGqsgWwb8tOhL3AFByRnrV1KKIJQFkQ+oZDBvRtZaqV0Aw4Al4dmdi3RYC8vLyoVyKhdfLJJ2Pt2rVR7/3www9o3759wrjffvstVq5cGXn9+c9/xrHHHouVK1eipKQEXq8Xffr0wYIFCyL7QqEQFixYEHdwRrpgRUtgwmLLquqW5ZUtwN7qFitbjoPVLecQ/jcg7M0HO6tbachrVXUr/PdKxOpWWGyZUd0yWtkCYKi6padCZWSvnn16qk56qmhaK2haj0tPhY4k59Zbb0W/fv3w17/+FYMHD8bSpUvx/PPP4/nnn4+sGTduHLZs2YJXXnkFbrcb3bt3j4rRqlUr5OTkRL0/ZswYDB8+HH379sWJJ56IqVOnYv/+/RgxYkTazu1wKLQkwEorIcWWPYQvLim4tCOi2AIaBBfFlnZoJUyQF6CV8NB4tBJGYZeVUM++TLQSkuSccMIJePfddzFu3Djcd999KCoqwtSpUzF06NDImm3btqGyslJT3EsvvRQ7d+7EhAkTUFVVhV69eqGioiJmQEY6cSmKor/LkphGTU0N8vPz8ceedyHLE/+PqxViKxI7HYLLTtEjqOACKLb0IqLYAljZ0ouwYiuMw63QVgkuK2zwZgkuo2IrjBGxBeivbIXRW90yslfPPj0iJR15zFgf9Ndi7eN3Y8+ePVE9SiIQvr7sOudOeBpZ8/skeMCP7y97RMjztxv2aEkE+7YM5hYU4S8wBUVUQcMx8PrgCHh788rStwWYN5WQI+A5Aj4d60lmQ6ElGUpOFkfAy5ZXBRRb+hBVbAHiVtxEh2IrQV6JH3DMEfAqY2SA2ALSNwJe60h3K9eTzIVCS1KsFFtpq27ZgZ1VtRTweVv6EF1sUXBpR3ix5eDqlpU28kwQW3ZOJUz3ZEEjOTmVkGQK0gmtp59+Gh06dEBOTg5KSkqwdOnSpOvfeustFBcXIycnB8cddxw++OCDqM8VRcGECRPQpk0b5ObmoqysDOvWrYt8/tNPP2HkyJEoKipCbm4uOnXqhIkTJyIQCEStcblcMa+vvvrK3JM/DEdYCe1CULEFsLqlB1HHv4eh2NIOrYT25eUIeGNwBLw69IotWgmJTEgltN544w2MGTMGEydOxIoVK9CzZ0+Ul5djx44dcdcvWrQIQ4YMwciRI/HNN99g0KBBGDRoEL777rvImkceeQRPPPEEpk+fjiVLlqBx48YoLy9HbW0tAGDNmjUIhUJ47rnnsGrVKjz++OOYPn067r777ph8n3zyCbZt2xZ59enTx5pvxCE4QmzRShgDxZY+KLacB8WWfXkz0UrIvi3x+7b05NIjnrRaCQmJh1RTB0tKSnDCCSfgqaeeAtDwILJ27drhpptuwtixY2PWX3rppdi/fz/ef//9yHsnnXQSevXqhenTp0NRFBQWFuK2227D7bffDgDYs2cPWrdujZkzZ+Kyyy6LexyPPvoonn32WWzYsAFAQ0WrqKgI33zzDXr16qXr3NRMHUyFVVMJ0zKREHD8RYtehL7QFBTRRY3IglBUhL754PDqvJU33cy+WWjWREKAUwnTvU/mqYRBfy1WPyX21MFOr46Dp1GOJTmCB2rx45WThTx/u5GmohUIBLB8+XKUlZVF3nO73SgrK8PixYvj7lm8eHHUegAoLy+PrN+4cSOqqqqi1uTn56OkpCRhTKBBjDVr1izm/fPOOw+tWrVC//798d577yU9H7/fj5qamqiXUdi3ZSAvq1uOQnQhI7oQFBGhrYQZ0LdFK6F+Ms1KmOl9W4QcijRCa9euXQgGgzEPHWvdujWqqqri7qmqqkq6Pvy/WmKuX78eTz75JP70pz9F3mvSpAmmTJmCt956C//617/Qv39/DBo0KKnYmjx5MvLz8yOvdu3aJVyrBVoJDeYWFIot7cggtii4tCOs2AIcLbYAjoA3Aq2E6nDKCHhCwlh3Ve5AtmzZgrPOOguXXHIJrr322sj7LVq0wJgxYyJfn3DCCdi6dSseffRRnHfeeXFjjRs3LmpPTU2N6WLLij9eijc7PVbCHJ89Fy125VWBy+cT+yJTQNy5ucKLmdDBg8KLQtFQ/H5xbz7U+u25aRP+vWVxblegzpKbbuG/V2beLHQF6k2zEnr8QcNWQncgaNhG6PaHdFsJPQFFt61P7169+9x12i1+WnOFxZPaPFrXEwJIVNFq0aIFPB4Ptm/fHvX+9u3bUVBQEHdPQUFB0vXh/1UTc+vWrfjDH/6Afv364fnnn095vCUlJVi/fn3Cz30+H/Ly8qJeZsPnbUmWVwUcAa8d0ScSArQS6oFWwiS5LYYj4PUj+wh4WglZ3SLakEZoeb1e9OnTBwsWLIi8FwqFsGDBApSWlsbdU1paGrUeAObPnx9ZX1RUhIKCgqg1NTU1WLJkSVTMLVu24LTTTkOfPn0wY8YMuN2pv20rV65EmzZtNJ0jACjZ5jTfRuKxb0t/XsEFF9GGDGKLgks7wootwPFiSxYrodl9W6JYCY1AK2FsHivXk8xFKuvgmDFjMHz4cPTt2xcnnngipk6div3792PEiBEAgGHDhqFt27aYPHkyAGD06NE49dRTMWXKFAwcOBBz5szBsmXLIhUpl8uFW265BQ888AA6d+6MoqIi3HPPPSgsLMSgQYMA/Cay2rdvj7/97W/YuXNn5HjCVa9Zs2bB6/Wid+/eAIC5c+fi5ZdfxosvvqjrPBVvlql34ZScLMsmEqbFShgWPLQSRkEroXZoJXQmtBImyAvQSnhoTIdZCcNii1ZCc3JpzUErIVGDVELr0ksvxc6dOzFhwgRUVVWhV69eqKioiAyzqKysjKo29evXD7Nnz8b48eNx9913o3Pnzpg3bx66d+8eWXPnnXdi//79uO6661BdXY3+/fujoqICOTkNIzDnz5+P9evXY/369TjqqKOijufQyfj3338/fv75Z2RlZaG4uBhvvPEGLr74Yt3naoXYAti3JVVeFVBsaUcWsQWIX4UTCeHFFmCf4JJUbAENf7OcLrYAYyPgjfZtAfrGpBsRW3pyiti3Fd5jznxK4kSkeo6Wkwk/5+APfe9GVtZvzzkwU2xFYlpU3QLS9MwtB9txjEDBpQ3RxVYYii3tCCu4AMf3nloluKywwZsluDL9eVtG9qbjOVjpyBP012LVc3yOlojnbzfS9GhlKoo3y9QHMAIOGQFvB+zbchSyCBhZBKFICH3TweE3iqzs2xJ1UIZIfVscAZ84j9V9W4TEg0JLEii2DoPP24oLxZY2ZJhICHBQhh4othLk5VTC6HgCTiU0HCMDxBaQnqmEekQdIYciVY9WpsO+rTiwbysG9m1pR4a+LYCDMrQS/ncg5A2IDOjbAqy58WZF3xZgzg1N9m3p2yty35bePKIRrPNAqTN3snWYkEVxnQArWpIhk5WQI+Dtg8/b0o4sAobVLe0IfeOBVkJ9cS24QUgrYTSyVLdoJSQiQ6ElKbKILcDhfVt2504BxZY2ZBFbAHu3tEKxlSCvxFZCkfu2AFoJnWolJEQLFFoSY4XYsrK6ZTns24oLxZY2KLaci+L3iyu40iR6Eua2GPZt6ccdCNr6gGM91Z9D96YzJ/u2iGhQaEmO2WILsNZKmBYotmKg2NKGLEMyAFoJ9SCs2AIcL7ZksRK6AvWmWgnNwE6xBaRfNOnNmQ6xpTcPyTwotBwA+7biwL6tGNi3pR1ZxBbA6pZWKLbsy5uJVkL2bbFvi2QmFFoOQhaxBdBKaCcUW9qg2HIuwostOwSX5H1bAK2EqmJkgNgC0mglNH82C3EIFFoOg31bcaDYioFiSxuyiS0KLvUI3bcFOLq6RSuhMewWW+m2Eorct0VIIii0HIhsfVuOtxIKCsWWNmQSWwCrW1qh2LIvryxiC6CV8HBkqW6ly0pIyOFQaAmG0QcdhpGpbwtw+Ah49m05BpmGZACsbmmFYitBXomthCL3bQEcAe9EKyEhh0KhJSBmiS2AfVsxsG8rLhRb2pBJbAGsbmlBaCshR8Drj50BYktmK2E6c1JskXRi3VUzMUTQ5zHNx614s0z9oxAWW1bYMhRvtqV/bCPk+Oy5YLErrwpcPp+4F5gC4s7NlUrAhA4elE4g2oni94t7A6LWb8+NmzTkDf/+t+LGm6u23tSbheG/q2bc0PT4g6bcZHUHggh59cdx+0MI+fTfg/cEFAS9Ll37AOjeq3Wfuw4IafwR03tuohCs80AJmHcj/1BCddbEdQKsaAlM0OfJSCsh+7bsg1ZCbcgmXGgl1IbQNx5oJdQXV2ArIfu22LdFnAeFlgTQSmghdlkJBe7bAmgl1IJsYguglVALtBImyW0xtBLqJ1OthHqglZBYCYWWJIgutjgCXrK8KqDYUo9sQzIAii2tCCu2AMeLLVmmEnIEfCwcAU8yHQotiTDbSmg2FFuS5VUBxZY2ZBRbFFzqodiyL68sYguglfBwaCUkmQyFloSwb8tCOAI+BvZtaUM2sQWwuqUF4cWWHYKLfVuxMQW0EhqOkQFiC2B1i5gLhZakiG4ltApH922FcwsKxZZ6KLacjdB9W4Cjq1uyWQnNgn1b4o+AJyQeFFoSI7rYopVQsrwqoNhSj6x9WxRc6qHYsi+vTGLLiVZCI6RbNOnNSbFFzIBCS3I4At5iKLZioNjShmxiC2B1SwsUWwny0koYHVPA6pah/ezbIkQVFFoOQfTqllU4XmwJKrjYt6UNii1nI7SVkCPg9cfOALGViVZCPVBsZQavvvoqTj75ZBQWFuLnn38GAEydOhX/+Mc/dMek0HIQoostqa2E7NuKC8WWemQVWxRc6hFWbAGOF1uZaiU0g0yzErJvi8Tj2WefxZgxYzBgwABUV1cjGGz4d9G0aVNMnTpVd1wKLYfBEfAWQ7EVA8WWemTs2wJY3dICxZZ9eWURWwBHwB8OrYTWo9S5LX3JzpNPPokXXngBf/nLX+Dx/HYd3bdvX3z77be648r/nXEYIa85Iol9WxZCsRUDrYTaoNhyNrQS2peXfVv64Qh49cgqtkhiNm7ciN69e8e87/P5sH//ft1xKbQEJOT1mCK4RLcSWoWjrYQC920BrG5pQVaxRcGlHmHFFuDo6pZsVkKzYN8WR8AT/RQVFWHlypUx71dUVKBLly6641p3tUsME/J6DP/CC/o8pvm4FW+WqX8UwmLLCluG4s22tEk6Qo7PngsWu/KqwOXziX2BKRDu3FwphUvo4EEphaIdKH6/uDcgav323LhJU15XoM6SG2+u2npTbxaG/66acUMz/Pfe6I1WdyBo6Iav2x9CyKf/Xr4noCDodenaB0D3Xq373HVAKE2dC8RaxowZg1GjRqG2thaKomDp0qX4+9//jsmTJ+PFF1/UHZdCS3DMEluAOXe7zBZbQIPgskpsAdZOpQJAsRUHii31UGw5H4qtBHkBy3NbKbYAc90ZrkC9ae4Rjz8ohNgCoFtw6RVbRvbqFVsKq1vSc8011yA3Nxfjx4/HgQMHcPnll6OwsBDTpk3DZZddpjsuhZYEmCG2APOqW+E/BGZXt6wQW0Caqlt2ii1ASMEVvrCk4EpNWLDIJrjCx0vBlZrwvwMhBVeaRE/C3JKKLcCa6pZoYgsw1j9upLqV7gqVkX1EfoYOHYqhQ4fiwIED2LdvH1q1amU4Jnu0JIF9WwZjO7lvK5xbUIS8sBQUWQWLbALRToS+8cC+LX2xOQI+9f4MGQFP1DFp0iS4XK6oV3FxcdI91dXVGDVqFNq0aQOfz4djjjkGH3zwgaGYiWjUqJEpIgtgRUs62LdlIDb7tmyDVkL10ErofGgltC9vJloJRerbApxvJSTq6NatGz755JPI11lZiX/WA4EAzjjjDLRq1Qpvv/022rZti59//hlNmzbVHfNwioqK4HIl/m+9YcMG1bEOhUJLQkTs2wLksBKyb8s+KLbUI7PYAuStzKUTWgnty0sroX6Mii3AuJWQYssZZGVloaCgQNXal19+Gbt378aiRYuQnd3wb7dDhw6GYh7OLbfcEvV1XV0dvvnmG1RUVOCOO+7QFROg0JKW8C86p1e32LelMy8gpOBi35Z6ZO3bAljd0gKrW/bkDf/+l2UqoWhiC8i8vi29OUl81q1bh8LCQuTk5KC0tBSTJ0/G0UcfHXfte++9h9LSUowaNQr/+Mc/0LJlS1x++eW46667oh4urCXm4YwePTru+08//TSWLVum/QT/B3u0JCcT+rasfMCx5bBvKy7CXlgKiKyCRUaBaBdC33hwcN8WYO0Djk2NZ3LflggPOJatb8tIzkyhpqYm6uVP8LutpKQEM2fOREVFBZ599lls3LgRp5xyCvbu3Rt3/YYNG/D2228jGAzigw8+wD333IMpU6bggQce0B1TLWeffTbeeecd3ftZ0XIAIloJZRoBz74te6CVUD20EjofVrYS5AWktRKK3LcFiGElZN9W+nDVueHKsqa+4qpriNuuXbuo9ydOnIhJkybFrD/77LMj/79Hjx4oKSlB+/bt8eabb2LkyJEx60OhEFq1aoXnn38eHo8Hffr0wZYtW/Doo49i4sSJumKq5e2330azZs1076fQcggcAW8gbib0bQFCCi5aCdUjq9gCaCVUC/u2kuSWVGwBtBKqiiGhlVBGsWU1mzZtQl5eXuRrn8rfZU2bNsUxxxyD9evXx/28TZs2yM7OjrIJdunSBVVVVQgEAvB6vZpjHk7v3r2jhmEoioKqqirs3LkTzzzzjKoY8aDQchDs2zIYO119WwCrW4fB6pY62LeVGbC6ZU9e2fq2AHPs+maILcCc6pZesQWkv/+KfVux5OXlRQkttezbtw8//vgjrrzyyrifn3zyyZg9ezZCoRDc7oafkR9++AFt2rSJK7LUxDycQYMGRX3tdrvRsmVLnHbaabrHxAMUWsIR8roBY7ZljoA3EptWQtug2FKPrNUtWgnVQ7FlX95MtBJyBLzB6paujJnL7bffjnPPPRft27fH1q1bMXHiRHg8HgwZMgQAMGzYMLRt2xaTJ08GAFx//fV46qmnMHr0aNx0001Yt24d/vrXv+Lmm29WHTMVYQui2VBoCUj4F4yRRlER+7YAWgmjoNiKgWJLPbKKLYDVLbXQSmhfXloJ9ZOJI+DddRySoYXNmzdjyJAh+OWXX9CyZUv0798fX331FVq2bAkAqKysjFSugIber48++gi33norevTogbZt22L06NG46667VMeMR01Njepj1lOpAyi0hCbkc9sutgDxq1vSWwnZtxUF+7bUQythZsDqlj15ZbMSiia2gMzq2yLqmTNnTtLPP/vss5j3SktL8dVXX+mOGY+mTZsmfUgx0NCr5XK5EAzquw6m0BIcM8QW4Py+LUBiKyH7tuLC6pZ6ZK1uUWyph2LLvrxWWglF7tsCxLASytS3ReTi3//+t+U5KLQkwKlWQo6APwxaCWOg2FKPzGILYN+WGoS3EnIEvPa4AvdtAWJYCWXs2yJycOqpp1qeg0JLIpxmJWTfVhxoJYyBYks9sootgNUtLQhb3eIIeP2xaSVMHYNWQpIGDhw4gMrKSgQCgaj3e/TooSsehZZk0EqoIp4T+rYAVrcOgX1b6mHfVmYgrNgCHG0llK1vC+AI+EOhlZAkYufOnRgxYgQ+/PDDuJ/r7dGy5hHRxFKM/JKJxDA4EQgw7t0+FLPuvEXi5WSZ+gcrKrZFdzRjsONCxc68KhD2wlJAZBUsoYMHpRSJdiD0jQe7btikKa9VN9xctfWm3yg060amxx805Qar0Ru9bn/I0A3nsGhK914iNrfccguqq6uxZMkS5ObmoqKiArNmzULnzp3x3nvv6Y7LipakOLVvC6CVMAr2bcVAK6F6aCV0PsL3bQEcAa8ndgZYCTNtBLzduAIuuDzWHLcrIN/343A+/fRT/OMf/0Dfvn3hdrvRvn17nHHGGcjLy8PkyZMxcOBAXXFZ0ZIco9UtMypbgPjVLatIS3XLzsqWoNUtl88n5oWlgMgsVmQViXYg9M0HB1e3XIE6S6tbpsYz8SamWZUtM6pbevEEFN0VKla2nMf+/fvRqlUrAMCRRx6JnTt3AgCOO+44rFixQndcCi0HYIbYopXQQOx0iS1aCWOg2FKHOzdXWsFFsaUeii378soktpxoJTSCEbFFweUcjj32WKxduxYA0LNnTzz33HPYsmULpk+fjjZt2uiOS+ugQ3CqlZAj4A+DVsIYaCVUj6xWQo6AV4/wVkKOgNcelyPgU++3eQR8vfzOuYxn9OjR2LZtGwBg4sSJOOuss/D666/D6/Vi5syZuuNSaAlG0OtCloEbJBwBryIm+7bkyqsCii31yCq2APZtaUHYqYQcAa8/dgb0bQHyjoAncnPFFVdE/n+fPn3w888/Y82aNTj66KPRokUL3XFpHRSQoNdlqNGSVkIV8ZzQt2XHhQr7thwBrYSZgdA3HxxsJZStb8tMK6EZyGolJHKzcOHCqK8bNWqE448/3pDIAiQUWk8//TQ6dOiAnJwclJSUYOnSpUnXv/XWWyguLkZOTg6OO+44fPDBB1GfK4qCCRMmoE2bNsjNzUVZWRnWrVsXtWb37t0YOnQo8vLy0LRpU4wcORL79u2LWvN///d/OOWUU5CTk4N27drhkUceMXyudootgCPgDcXmCHjboNhSj8xii4JLHRRb9uWVRWwBHAF/OBRbmccf//hHFBUV4e6778b3339vWlxNV+PPPPMMysrKMHjwYCxYsCDqs127dqFjx46mHVg83njjDYwZMwYTJ07EihUr0LNnT5SXl2PHjh1x1y9atAhDhgzByJEj8c0332DQoEEYNGgQvvvuu8iaRx55BE888QSmT5+OJUuWoHHjxigvL0dtbW1kzdChQ7Fq1SrMnz8f77//Pr744gtcd911kc9rampw5plnon379li+fDkeffRRTJo0Cc8//7zhczYqtkSYShj0eUwTXIo3S5rqluLNdv5UQkGh2FKPrGILYHVLLYrfL67gqvXbI7jSlDcTn7cFmDeV0HAMii2ikq1bt+K2227D559/ju7du6NXr1549NFHsXnzZkNxXYqiqPpJeuKJJzBu3DiMGDECe/bswZtvvolJkyZh3LhxAIDt27ejsLBQ95OT1VBSUoITTjgBTz31FAAgFAqhXbt2uOmmmzB27NiY9Zdeein279+P999/P/LeSSedhF69emH69OlQFAWFhYW47bbbcPvttwMA9uzZg9atW2PmzJm47LLLsHr1anTt2hVff/01+vbtCwCoqKjAgAEDsHnzZhQWFuLZZ5/FX/7yF1RVVcHr9QIAxo4di3nz5mHNmjWqzq2mpgb5+fkoOfd+ZGXnxHxu9B+80VK6Gb/wAPOsBYC5fxQAa+4SRmKnY1CGnf1TgvZuAYLf0RcImUWLzGIx3Qh9E8LhN42suvFm9s1CM29mmnWT1ehNX6M3nVPd9K6vq8WSf96DPXv2IC8vz1AuswlfXx798ANw58ZeX5pB6GAtKu8aL+T562Hjxo2YPXs2/v73v2PNmjX4/e9/j08//VRXLNU/ec899xxeeOEFPPXUU3j11Vfx73//G48//jgmTJigK7FWAoEAli9fjrKyssh7brcbZWVlWLx4cdw9ixcvjloPAOXl5ZH1GzduRFVVVdSa/Px8lJSURNYsXrwYTZs2jYgsACgrK4Pb7caSJUsia37/+99HRFY4z9q1a/Hrr78aPPMG2LcVC62Eh8ER8HER+sJSINi3lRkIfeOBVkJ9cdm3lXo/+7aIBoqKijB27Fg89NBDOO644/D555/rjqX66nvjxo3o169f5Ot+/frh008/xfPPPx+palnJrl27EAwG0bp166j3W7dujaqqqrh7qqqqkq4P/2+qNeEHmIXJyspCs2bNotbEi3FojsPx+/2oqamJeqmBVsJozBZbgLVWwrRAsRUDxZZ6ZBZbFFzqoNhKkJdWwuiY7NuKgmIrM/jyyy9xww03oE2bNrj88svRvXt3/Otf/9IdT/UVZYsWLbBp0yZ06NAh8l737t3x6aef4o9//CO2bt2q+yAykcmTJ+Pee+/VtTfodRn6B88R8CpicgS8XHlVwBHw6uEIeOcj/PO2AI6A1xObI+BTxzA4At7IDW87cQVdcFn0wC9XUM7vyaGMGzcOc+bMwdatW3HGGWdg2rRpOP/889GoUSNDcVX/pPXv3x9z586Neb9r165YsGABPvzwQ0MHkooWLVrA4/Fg+/btUe9v374dBQUFcfcUFBQkXR/+31RrDh+2UV9fj927d0etiRfj0ByHM27cOOzZsyfy2rRpU/wTTwCthLHIMiQDcLiVkCPgHQGthJmB0DcfHGwl5Ah4Y9hpJfQEFFa3HMgXX3yBO+64A1u2bMH777+PIUOGGBZZgAahNXbsWPTo0QOVlZU4fH5Gt27d8Mknn2D48OGGDygRXq8Xffr0iZp2GAqFsGDBApSWlsbdU1paGjMdcf78+ZH1RUVFKCgoiFpTU1ODJUuWRNaUlpaiuroay5cvj6z59NNPEQqFUFJSElnzxRdfoK6uLirPscceiyOPPDLusfl8PuTl5UW99MAR8NGwbysOtBLGQLGlHpnFFgWXOii27Msri9gCaCU8HIotZxG2DBp9btbhqL7S7tGjB0aMGIGioiLs3Lkz5vO2bdti1qxZph7c4YwZMwYvvPACZs2ahdWrV+P666/H/v37MWLECADAsGHDovrFRo8ejYqKCkyZMgVr1qzBpEmTsGzZMtx4440AAJfLhVtuuQUPPPAA3nvvPXz77bcYNmwYCgsLMWjQIABAly5dcNZZZ+Haa6/F0qVL8eWXX+LGG2/EZZddhsLCQgDA5ZdfDq/Xi5EjR2LVqlV44403MG3aNIwZM8bS70cY9m1FwxHwcaDYioFiSz2yii2A1S21cAS8fXkzsW8L4Ah4khlovnpUFAUuV+yF/b59+5CTY83YyDCXXnopdu7ciQkTJqCqqgq9evVCRUVFZPBEZWUl3O7fREO/fv0we/ZsjB8/HnfffTc6d+6MefPmoXv37pE1d955J/bv34/rrrsO1dXV6N+/PyoqKqLO5fXXX8eNN96I008/HW63GxdddBGeeOKJyOf5+fn4+OOPMWrUKPTp0wctWrTAhAkTop61pZag14UsHf9u2bcVi+LNkqJvC2gQXI7u2wKE7N0Kiy1hLzAFgn1bmYHi94t7EyIN/VN25Q3//rfixhv7tlTEMNi3pdRRcJH4qH6OVrg6M23aNFx77bVRvsVgMIglS5bA4/Hgyy+/tOZIHU74OQd9L3oAWdk5hkSTkb1GR6AC5txhEvl5W4B1z9xKy/O2AMfbcfRAsaUeWQUXxZZ6hBVbgOMr9LI8bwswz64v+/O26utqseijCUI+Ryp8fdn+rw/CbVFBJFRbi5/v/ouQ5283qv+FfPPNNwAaKlrffvtt1DOjvF4vevbsGXnoLzGOkQqVkb3hXzJ2V7fCv3TNmkpottiyciphWsQWpxLGwKmE6pG1uhU+Zgqu1LCylSAvIO1UwvDfLBGrW+G/9WZUt4xWtgBzetgJATQIrX//+98AgBEjRmDatGlUrGnALrEFOM9KyBHwcaDYioFiSz2yii2AVkK1cAR8ktySii2AVkJVMQxYCYmcbNq0CS6XC0cddRQAYOnSpZg9eza6du2qqxUojOafohkzZlBkpREjY9w5Aj4WWYZkABwBbxccAa8ejoDPDIS++eBgGzRHwBvDzhHwRD4uv/zySFGpqqoKZ5xxBpYuXYq//OUvuO+++3THpVyXBCOCiSPgo+EI+Dg4vOdBDxRb6qHYcj4UW/bllUVsAc4cAU8yg++++w4nnngiAODNN99E9+7dsWjRIrz++uuYOXOm7rjW3Y4npsO+LXP7tgBaCaOglTAGWgnVI6uVkH1b6qGV0L68mdi3BZhnJWTfFuAOuOB267/xnpSARXHTSF1dHXz/+932ySef4LzzzgMAFBcXY9u2bbrjyv1Tk4EYtRIaQYTnbQHiV7eswvHP2xK0ukUroXpoJcwMhL754ODqlpU32zLheVusbpFkdOvWDdOnT8d//vMfzJ8/H2eddRYAYOvWrWjevLnuuBRaksK+LbHFltRWQjtFj6BiCxD0Lr6gUGw5H4ote/Kyb8sYFFskEQ8//DCee+45nHbaaRgyZAh69uwJAHjvvfcilkI90DooMbQScgS8pdBKGAOthOqR2Uooq1BMNxwBnyAvQCvhoTE5Ap5IwGmnnYZdu3ahpqYGRx55ZOT96667LurZwVrhT4nk2DUkA3CelVDxZkljJVS82c63EgoKrYTqkdVKGDp4UEqRaAeK3y/uzYdav+OrW5bFzgAroeEYrG45ioMHD8Lv90dE1s8//4ypU6di7dq1aNWqle64FFqCEcrWLn44Al58K6FVONpKKHDfFkAroRZkFFsArYRaEFZsAY4XW7QS6oN9W+RQzj//fLzyyisAgOrqapSUlGDKlCkYNGgQnn32Wd1xKbQExI5hFxwBHw37tuLA6lYMFFvqodhyPhRb9uWVRWwBzhwB7w5QcMnOihUrcMoppwAA3n77bbRu3Ro///wzXnnlFTzxxBO641JoCYqMYksEK2HQ56GV0EootmKg2FIPxZbzodhKkFdiK6Grtp5WQuJ4Dhw4gCOOOAIA8PHHH+PCCy+E2+3GSSedhJ9//ll3XAotgbHDDsi+rVhkEVsAR8DbBfu21MO+LefDvq0kuS2GfVv6McNKSOTld7/7HebNm4dNmzbho48+wplnngkA2LFjB/Ly8nTHpdASHDtEE/u2YqGV8DA4Aj4uFFvqkVFsAaxuaUFYsQU4XmzJYiUUrW8LYHUrU5kwYQJuv/12dOjQASeeeCJKS0sBNFS3evfurTsuhZYk0EqoD7OthGYjtdgCKLbiQLGlHoot50OxZV/eTLQSitK3ReTj4osvRmVlJZYtW4aPPvoo8v7pp5+Oxx9/XHdcPkdLIvQ++8qu520BDYLL7udtAQ2Cy6znbQHmWh6sfN4WYK2VBIC9z9sChHzmVlhsCX2RKQhhsSWbeOHzttQT/ncg5E2IND33yq68Vj1vC2gQXCI+bwtoEFx2P29LNFx1gNui01HS8GjPdFBQUICCggJs3rwZAHDUUUcZelgxwIqWdOi19XEEvPhWQqugldA+hLywFBQZRQv7trQh9I0HB1e3ZLMSmgX7togWQqEQ7rvvPuTn56N9+/Zo3749mjZtivvvvx+hkP6CAStakiJbdctoZQswp7plVmULaBBbZle2AGvG6SrebOsrW4C91S0BK1tAg9gS+gJTINy5uVIKF1a31KP4/eLegKj123PjJk15rapuWVHZAsy5oRn+e8/qFknFX/7yF7z00kt46KGHcPLJJwMAFi5ciEmTJqG2thYPPvigrrgUWhIjo9gCjD3gzyyxBZhzt4tWwjhQbMVAsaUeWgmdD8VWgryAtFbC8N8sWgmJrMyaNQsvvvgizjvvvMh7PXr0QNu2bXHDDTfoFlq0DkoOR8Drh1ZCC+EI+Bg4Al4bMooW2cShnXAEfJLcFsMR8PqhldC57N69G8XFxTHvFxcXY/fu3brjUmgJRkjHNTBHwOtHdLEl9VRC9m3FhWJLPbKKLQou9QgrtgDHiy2Z+rY4Ap5YTc+ePfHUU0/FvP/UU0+hZ8+euuPSOiggoWzAreP3H62E+jDbSmjmHTjAWish+7bsgVZC9dBK6HxoJbQvryx9W4B5VkL2bZF4PPLIIxg4cCA++eSTyDO0Fi9ejE2bNuGDDz7QHZcVLUEJZeuvbunBrudtAc6zEireLGmshIo3m1ZCm6CVUBsyihbZxKGdCH3jwc7KlsRWQpGftwWYZyUkxnnooYfgcrlwyy23JFxTV1eH++67D506dUJOTg569uyJioqKmHVPP/00OnTogJycHJSUlGDp0qWqjuHUU0/FDz/8gAsuuADV1dWorq7GhRdeiLVr1+KUU07Re2qsaImOnupWWPhorTTp3Wd0L2DO87YA47/0RJ9KaEVlC0hTdcvO516xuuUIZKxusbKlHj5vK0luSYdkAJnxvC13PQWXXr7++ms899xz6NGjR9J148ePx2uvvYYXXngBxcXF+Oijj3DBBRdg0aJF6N27NwDgjTfewJgxYzB9+nSUlJRg6tSpKC8vx9q1a9GqVauUx1JYWBgz9GLz5s247rrr8Pzzz+s6P1a0JEBPZQuQr7pltLIFmFPdYt+WxbBvKwYhLywFRjbhwr4tbQh944F9W/piZ0DfFtHOvn37MHToULzwwgs48sgjk6599dVXcffdd2PAgAHo2LEjrr/+egwYMABTpkyJrHnsscdw7bXXYsSIEejatSumT5+ORo0a4eWXX9Z9jL/88gteeukl3fsptCQhU6yEIZ9bCCth0OehldBKKLZioJVQG7KJLUCuSpzdUGzZlzcTrYQef5CCywRqamqiXv4U/45HjRqFgQMHoqysLGVsv9+PnJycqPdyc3OxcOFCAEAgEMDy5cujYrndbpSVlWHx4sU6zsYcKLQkI91iS+YR8JlQ3bIKR08lFLhvC2B1Swvu3FzpBBfFlno4At6+vBwB7zzc9Q2tKJa8/vefoF27dsjPz4+8Jk+enPB45syZgxUrViRdcyjl5eV47LHHsG7dOoRCIcyfPx9z587Ftm3bAAC7du1CMBhE69ato/a1bt0aVVVV+r5pJsAeLQlJZ99WeK+MfVuAeVMJRe7bAsz/wwVwKqGdsG9LG+7cXKkEDPu2tMGphPbkDf/+l2EqYfjvqllTCc28yZpJbNq0CXl5eZGvfQn+3W7atAmjR4/G/PnzY6pUiZg2bRquvfZaFBcXw+VyoVOnThgxYoQhW2A6oNCSFI6A1xCDI+D1x6XYsg2KLW1QbDkbii378nIEPFFLXl5elNBKxPLly7Fjxw4cf/zxkfeCwSC++OILPPXUU/D7/fB4or/3LVu2xLx581BbW4tffvkFhYWFGDt2LDp27AgAaNGiBTweD7Zv3x61b/v27SgoKEh4LBdeeGHSY62urk55Psmg0JKYsI1QT3VLJrEFmDOV0IwxrGZVt8J/CGSYShj+A5uWqYR2iS1ASMEVvrCk4FKHbFMJw8dJwaUOiq0EeQFppxKG/2Y5eSohieX000/Ht99+G/XeiBEjUFxcjLvuuitGZB1KTk4O2rZti7q6OrzzzjsYPHgwAMDr9aJPnz5YsGABBg0aBAAIhUJYsGABbrzxxoTx8vPzkx5rfn4+hg0bpvLMYqHQEoyg1wWt/6Q5Al7lfo6ANxabI+Btg9UtbbC65Vw4Aj5JbknFFuD8EfAkmiOOOALdu3ePeq9x48Zo3rx55P1hw4ahbdu2kR6uJUuWYMuWLejVqxe2bNmCSZMmIRQK4c4774zEGDNmDIYPH46+ffvixBNPxNSpU7F//36MGDEi4bHMmDHDgjP8DQotAdFT/ckkKyH7tlLEY9+WfHlVQLGlDYotZ8Pqlj152bdF0kVlZSXc7t8Go9XW1mL8+PHYsGEDmjRpggEDBuDVV19F06ZNI2suvfRS7Ny5ExMmTEBVVRV69eqFioqKmAEZ6cSlKIp+PxcxjZqaGuTn5+O4kX+Fx9vQGKhXjOgRXHpzGbEDGtkLGOvbAsx7oruZU4rM7t2yqroFpMFKCNgregQVXACthFqRSXBRbGlDWLEFOP4xFlZVt6yYqGvm1N94gqu+vhZffHk/9uzZo6pHKZ2Ery9/d9df4fGpGzyhlaC/FusfvlvI87cbjncXGL3j1TkCXuV+joA3FtvJI+DDuQVF6ItLAZFJvMgkCkVA6JsOdj5vS+IR8CI/bwtw9gh4Yj4UWhKQTrGVbtFkJCdgXGwB5j3g2CysEFtWPuA4LVBsxUCxpQ3ZxBYFl3r4vK0kuS2Gz9siJDkUWpKQLrGlN5eRfUb3hnxuU6pbRgn6PKYJLrPFFmBddUvxZqevumUHgostCi71yPaAY4otbQgrtgDHiy0rq1umxgvUmya4KLaIGii0JEJP9SeUnX4roV5EsBKagZlii1bCw7BTbAkuuIh6KLacC8WWfXkz0Uro8QcpuEhSOHVQQtI1lZAj4PXDqYQWwhHwceFUQm3I9MwtTiTUhvATCYH037iR/HlbgPgj4EXHEwA8xu5nJyZgUVwHwIqWpNBKmBhaCVXGZN+WXHlVIOzFpcDIImBkEIQiIXTfFuDo6lamWgkJiQeFlsToFVu0EqrcTyuh/riZ0LclqOBi35Z2ZBJbFFzaoNiyL68sYgsw/9EqhISh0BKMkMbrXo6ATw5HwKuI54S+LVa3YqDY0oZMgzIotrRBsZUgr8RTCUXu2yLkUCi0BCRdIogj4DXEyACxRSuhZHlVQLGlHYotZyK0lZAj4PXHptgigkOhJSh6LH7s20qMU/u2ZKlu0UpoH7QSaodiy7kIK7YAx4stWayE7NsiZkKhJTh6xJYMI+BlthKagejVLaugldA+KLa0IYuVkGJLOxRb9uWVRWwBrG4Rc6DQkgBaCc3LCbBvS1U8Wgnly6sCii3tUGw5E4qtBHklthKyb4uICIWWJNBKaO5ep1oJzYZWQsnyqoBWQu3IUN3iRELtsG8rSW6LYd8WyRQotCTDqVZCvdBKGI1MfVtAGq2EdiBw3xbA6pYeRBdbAKtbehBWbAGOF1uyWAnZt0X0QqElIU60Ehq1INJKGA3F1mGwbysuFFvaodhyJhRb9uWllZA4GQotSRFZbOnNZWSf0b0cAa8iHvu25MurAloJtSOLlZBog2IrQV5aCaPjSSq23HXWvkh8KLQEQ4uwYd+WuXud2rclS3UrI/q2BBdcRBsUW86DfVtJclsMrYTEiVBoCYhWYePUvi2ZR8BnQnXLKmgltA+KLe2IXt3ikAx9CCu2AEeLLYAj4ImzoNASFKvFFiB+31Z4r959tBJGQythHCi2YqDY0ofIYgtgdUsPFFsJ8kpsJWTfFkk30git3bt3Y+jQocjLy0PTpk0xcuRI7Nu3L+me2tpajBo1Cs2bN0eTJk1w0UUXYfv27VFrKisrMXDgQDRq1AitWrXCHXfcgfr63/7RzJ07F2eccQZatmyJvLw8lJaW4qOPPoqKMWnSJLhcrqhXcXGx4XPWI7ZoJTRvr1OthGZDK6GBvIIKLvZt6YNiy3kIL7YcXN2Sqm+rLmhqPOIcpBFaQ4cOxapVqzB//ny8//77+OKLL3Ddddcl3XPrrbfin//8J9566y18/vnn2Lp1Ky688MLI58FgEAMHDkQgEMCiRYswa9YszJw5ExMmTIis+eKLL3DGGWfggw8+wPLly/GHP/wB5557Lr755puoXN26dcO2bdsir4ULF5py3nrEk1OthHoRwUpoBpnYtwXQSmgnFFvakcFKSLQhdN8W4HixJZOVkJDDcSmKoth9EKlYvXo1unbtiq+//hp9+/YFAFRUVGDAgAHYvHkzCgsLY/bs2bMHLVu2xOzZs3HxxRcDANasWYMuXbpg8eLFOOmkk/Dhhx/inHPOwdatW9G6dWsAwPTp03HXXXdh586d8Hq9cY+nW7duuPTSSyOCbNKkSZg3bx5Wrlyp+xxramqQn5+PLjf+FR5fTtw1Wqe66JkC4wlo/3HQO21GTy4j+4zudftDuvdGYgSM3/Xy+M27c2aF5cGqP15W3t2MwsEXLXoR+iJTYEQWNSKLQZER+uaDw28WWXXTzYwbhfVBPz7978PYs2cP8vLyTDgq81BzfWmUoL8Wq5+6W8jztxspKlqLFy9G06ZNIyILAMrKyuB2u7FkyZK4e5YvX466ujqUlZVF3isuLsbRRx+NxYsXR+Ied9xxEZEFAOXl5aipqcGqVavixg2FQti7dy+aNWsW9f66detQWFiIjh07YujQoaisrNR9volwUt+W3lxG9hndK1LfVqZaCdOCwy9W9EAroT5Erm6JLAJFRuibDuzb0hfXgr4tQsJIIbSqqqrQqlWrqPeysrLQrFkzVFVVJdzj9XrRtGnTqPdbt24d2VNVVRUlssKfhz+Lx9/+9jfs27cPgwcPjrxXUlKCmTNnoqKiAs8++yw2btyIU045BXv37k14Tn6/HzU1NVEvNWi17KWzbysTrISi9G0BmWklZN+WvVBs6YNiy1kIL7YcXJWXqW+LEMBmoTV27NiYIRKHv9asWWPnIUYxe/Zs3HvvvXjzzTejhN/ZZ5+NSy65BD169EB5eTk++OADVFdX480330wYa/LkycjPz4+82rVrp+lYROzb0pMnnEsPHAEv/lRCq2Dfln1QbOlD1OoWx7/rg31b9uVl3xaRCeuuhFRw22234aqrrkq6pmPHjigoKMCOHTui3q+vr8fu3btRUFAQd19BQQECgQCqq6ujqlrbt2+P7CkoKMDSpUuj9oWnEh4ed86cObjmmmvw1ltvRdkR49G0aVMcc8wxWL9+fcI148aNw5gxYyJf19TU6BJbWvqjtK4HGgSJ1r4mvXkAfT1Ueo7RaE6gQWwZ7dsKeT2G+7aCPo9pfVuKN8vUvq2w2LLij5fizU5P31aOz56LFrvyqiAstoS+0BQUd26ukMImdPCgkEJQdBS/X9ybD7V+e27apCmvK1BnyU238N8rK28WkszB1p+ili1bomXLlinXlZaWorq6GsuXL0efPn0AAJ9++ilCoRBKSkri7unTpw+ys7OxYMECXHTRRQCAtWvXorKyEqWlpZG4Dz74IHbs2BGpUM2fPx95eXno2rVrJNbf//53XH311ZgzZw4GDhyY8nj37duHH3/8EVdeeWXCNT6fD744v5xD2YBLg1DRI7YAbXvSJbb05jKyz+jecGXLiOAyS2wB5gzKCFe2zBZcVoktIA2DMuwUW4DQgotiSzsUW86CYitBXsDy3FaJLaBBcDlJbLnrALdFPjYlTbOqZESKHq0uXbrgrLPOwrXXXoulS5fiyy+/xI033ojLLrssMnFwy5YtKC4ujlSo8vPzMXLkSIwZMwb//ve/sXz5cowYMQKlpaU46aSTAABnnnkmunbtiiuvvBL//e9/8dFHH2H8+PEYNWpURATNnj0bw4YNw5QpU1BSUoKqqipUVVVhz549keO7/fbb8fnnn+Onn37CokWLcMEFF8Dj8WDIkCG6z9nqPiynjoCX2UpoBrQSWgithHER9gJTcES2EhLtCH3DIQP6tmglJKIihdACgNdffx3FxcU4/fTTMWDAAPTv3x/PP/985PO6ujqsXbsWBw4ciLz3+OOP45xzzsFFF12E3//+9ygoKMDcuXMjn3s8Hrz//vvweDwoLS3FFVdcgWHDhuG+++6LrHn++edRX1+PUaNGoU2bNpHX6NGjI2s2b96MIUOG4Nhjj8XgwYPRvHlzfPXVV6qqdcmwWjyJPJXQDtFkJCfAvi1V8XKyOJVQtrwq4FRC/VBsOQf2bdmbl2KLiIgUz9HKBMLPOTj21tjnHKTj+Vla9/B5W8kx2rtlxvO2APOeuSXT87aAND1zy047n6BWQkDwO/uCI5rAEVEEyoLQNx4cfrPIyptuiW4UyvAcrW5/svY5Wque43O04iFNRSuTScdId46AN28v4DwroUwj4AFaCe1E6AtMwRFN2Igm/GRC6BsOfN6W/tisbhGNUGhJhGhWwkwYAU8rYTS0EsaBYisGWgn1I1rvFsWWfoQXWw62ErJvi4gChZZkiCa2AGf3bRnda1RsAeZUt0QWW4C1DzhOC3zAcVwotvQjmtii4NIH+7bszUuxReyGQktC9FgJrYwPpE9s6c1lZJ/RvSGfWwgrYdDnyUgroeLNTp+V0C4othwJq1vOgWIrQV6JrYSu2noKLpISCi2JEbFviyPgE0MroYp47NsylltQKLaMQbHlDCi27MvNvi1iFxRaghH0NrzUQithZo2AB5xvJWTfloR5VcC+LWOIVN2i2NKP8GLLwVZC9m0RO6DQEhTRxBathObtpZVQZUxaCfXnFVxwEf1QbMkP+7bszZuWx38Q8j8otARGq9iilTB9+4zuBZw3Ah6glTAGWgnjQrFlDIotZ0CxlSCv5FZCUXHXNzzP1JIXC3oJodASHFoJteXRk4sj4MUXW7QSSpZXBbQSGkMUKyHFljEotuzLnYlii6QfCi1JoNiyNpeRfUb3itS3ZaaV0GxoJTSQV3DBRfRDsSU/wostB1sJrezbIgSg0JIKkayE6ezbygQroSh9W4B51S2Z+rYAWgnthGLLGCJUtyi2jMG+LXvzUmwRq6DQkgwtYgsQr7ql12rHEfAq99NKaCw2rYS2QSuhcSi25IdiK0FeWgmJpFBoSQj7trTl4Qh4fYgstgBrrYRpgVbCuFBsGcPu6lbo4EEKLoMIL7YcXN2ilZCYDYWWYIQ0XDtabSXUAkfAm7tXFCshR8BbjJ2Ch2LL0bC6JTdCiy3A0WILYHWLmAeFloBoERNWWgk5Av63fTJbCc1A5OoW+7YM5hYUWgmNI0J1i+iHfVv25qXYSh8PPfQQXC4XbrnlloRrVq1ahYsuuggdOnSAy+XC1KlTY9ZMmjQJLpcr6lVcXGzdgauAQktQtIotWgnV58k0KyH7tgzGppXQVii2jEOxJTcUWwnysm/LEXz99dd47rnn0KNHj6TrDhw4gI4dO+Khhx5CQUFBwnXdunXDtm3bIq+FCxeafciaoNASGK2VG9HEFq2E5u2llVBlTFoJ5cydAoot49hZ3aLYMo7wYsvB1S32bVnHvn37MHToULzwwgs48sgjk6494YQT8Oijj+Kyyy6DL8nfhKysLBQUFEReLVq0MPuwNUGhJQFWii0RrYRayZQR8ACthKri0UpoLLeg0EpoDnYJLoot4wgttgBHiy2A1S011NTURL38KX5mR40ahYEDB6KsrMy0Y1i3bh0KCwvRsWNHDB06FJWVlabF1gOFliSI0reVjvWZMAKeVsJoaCWMA8VWXCi2zIFiS07Yt2VvXpnFliegWPoCgHbt2iE/Pz/ymjx5csLjmTNnDlasWJF0jVZKSkowc+ZMVFRU4Nlnn8XGjRtxyimnYO/evabl0Ip1t36J6YSFhFvFv/Ow2PIE1MdWEzdd64EGQRL+x2t1HgCac4X36tlndG/I54bbH9K1NxLD64E7EDQUIyy2PH5jcYAGseUK1BuOExUzJwuuWnNjAr+JLcv/6Ob47LlwCYstuy6aUuDy+cS+2JSEsNhKpwAKHTxo+0REJ6D4/eLedKj123PDJvz7yuLcrkBd+m64ScamTZuQl5cX+TqRxW/Tpk0YPXo05s+fj5ycHNPyn3322ZH/36NHD5SUlKB9+/Z48803MXLkSNPyaIEVLQkRyUqoBfZtmbtXlL4twLzqlkx9WwCthHZCK6F5pFv4sLJlDkLfbGDfVkaSl5cX9UoktJYvX44dO3bg+OOPR1ZWFrKysvD555/jiSeeQFZWFoJB4zdvAaBp06Y45phjsH79elPi6YFCS1JEsRJyBPxv+2QeAU8roYHYtBLaCsWWOaS7d4tiyxyEFluAo8UWILeV0E5OP/10fPvtt1i5cmXk1bdvXwwdOhQrV66Ex2PO9cS+ffvw448/ok2bNqbE0wOtg4KhZKu3v2mxydFKqC0PkF4roZGcgFhWQjNshACthHGhlTAutBKahzs3N20iiDZCcwj/7At708FOK2Ea8roCdYB59xkzgiOOOALdu3ePeq9x48Zo3rx55P1hw4ahbdu2kR6uQCCA77//PvL/t2zZgpUrV6JJkyb43e9+BwC4/fbbce6556J9+/bYunUrJk6cCI/HgyFDhqTx7KJhRUtQ1FZjOAJeXR490Eqoj0wdAQ/QSmgntBKaRzqrW6xsmYfQNxuc/rytOla2zKayshLbtm2LfL1161b07t0bvXv3xrZt2/C3v/0NvXv3xjXXXBNZs3nzZgwZMgTHHnssBg8ejObNm+Orr75Cy5Yt7TgFAKxoCY2WaozW6paWyhag7Ti0rA/v0bJeT/VHz3GFc8k0JAMwXt0yo7IFiF3dsqqyBTSIrbTYSeysbgla2QJY3TKTdFW3WNkyD+GHZACOrm4R/Xz22WdJv+7QoQMUJfm10Zw5c0w+KuOwoiU4Vg2nCHrFq25pJZ0j4PXk4gh49m1Zjp2VLYEvWoS90JSQdFW3WNkyD+FvNDi8b4uQQ6HQkgAtFjvZrYRaoZUwMbQSqoxpodhKm5XQLgQXWxRc5pEOwUWxZR583laSvBRcJI1QaEmEldUtLXGtnEqYzr6tdE8l1IsIUwnNQPTqllWwb8teKLbMhWJLLii2BMxNMgoKLckQQWxpjZ2O9XqtdjKNgKeVMBpaCeNAK2FcKLbMxerqFsWWuQgvtmglJA6GQktCrLISsm9LWx7ZqltGxRYgppXQbGgllDR3CmglNB8rBRfFlrkILbYAiq004K6z9kXiQ6ElGCGv9kl6Zq+12kqoBY6AN3evKH1bgHnVLZn6tgBaCe2GYst8KLbkgGIrSd4MElwkvVBoCUjIq6gWXCKILT3HIaKV0I6+LTuEGkAroap4tBIayyuw4KLYMh+rqlsUW+bCIRmC5iaOhUJLYEQQW7QSqs+TbtFkd98WYJ6V0CxoJYwDrYRxoZXQGtL5sGOiH+HFFq2ExCFQaAmOFrGVKSPgaSU0b68oVsJMHQEP0EpoNxRb1mCm2GJVyxqEFlsAxRZxBBRaEpAJfVvpsBJqhSPgNewXrG8L4Aj4uNBKGBeKLWsws7pFsWUNFFtJ8lJwEROg0JIEp/dtpWN9ukfA68nFEfDiiy1aCSXNnQJaCa3DLMFFsWUN7NsSNDdxBBRakmG3lZB9W9bnMrLP6F5aCVXGlL26RSthQii2rINiS2yEF1u0EhIJodCSkEywEmohnX1btBKq3E8robHYmWAlFBiKLeswo7pFsWUdQostgGKLSAeFlmAoHpUVK4dbCUUdAa8nTziXHmglFF9scQS8gbwCCy5aCa2F0wnFhWIrSV4KLqIRCi0BUbI0VKwsshKqhVZCbXlkq26JNALeTCuh2Tiib4vVrbhQbFmLXsHFqpa1sG9L0NxEOii0BEXJUlQLLiushFaPgHeKlVAPMootp1kJ2beVAIqtuFBsWY8ewUWxZT3Ciy1aCVXjrlPgCVjzctepvw7NNCi0BMdOsaV1bSZaCe3o27JDqAG0EqqKRyuhsbwCCy5aCdMDLYXiIbTYAii2iNBQaEmAFrElQt8WrYTq86RbNNndtwWYZyU0C1oJ48AR8Amh2EoPagUXq1rpgWIrSV4KLpIECi1JsMJKaNUIeEA8sUUroXl7RbEScgS8xbBvKyEUW+kjLLhY5bIf9m0JmpsIDYWWZDjVSqinbysdVkKtcAS8hv2C9W0BtBLGhVbCuNBKmH7iiS4KsPQjvNii6CECQaElIbJZCbUgmpUw3SPg9eTiCHixxRZAK6G0uVVAsWUPrHLZi9BiC6DYIsJAoSUYikphJJOVkH1b1ucyss/oXloJVcakldBYboGh2CKZCMUWIamh0BIQxatoElxqyAQroRbYt2XuXoBWQlXxZBdbAK2ECaCVkGQiFFuEJIdCS2CsEFtOthJyBPxv+2glFFts0UooaW4VUGyRTEOKIRkUXMQmKLQEx2yxBVhnJVQLrYTa8shW3RJpBDythBZCK2FCKLZIJiK02AIotogtUGhJgForoRV9WwBHwCeCVsLEiNK3BYhf3bIKWgnthVZCkolQbBESjXV/5YnpKF4FrkDqi18lS4GrPvW6kFeBW0U8oEEguOtULdW0NugFPAH1cQFtx6FlfXiPlvVhMeIJaBeuWvKEc2nJc+g+QNsxGs0ZJuRzw+0P6d//P7HlDgR1xwAaxJbHbyxGGMWbBVeg3pRYwG9iy1VrXsxIbG82XAGNP2h6yPHZdwFjZ24VuHw+8S8+CTERxe8X+yZDrV/omzRW4Qko8Cj6/54nQ6mzJq4TkKaitXv3bgwdOhR5eXlo2rQpRo4ciX379iXdU1tbi1GjRqF58+Zo0qQJLrroImzfvj1qTWVlJQYOHIhGjRqhVatWuOOOO1Bf/9sFz2effQaXyxXzqqqqiorz9NNPo0OHDsjJyUFJSQmWLl1q3skfglP7tkSrbmnFyVZCu/u2ADGthGbjiL4tWgnjIvRFJyEWwL4tQhqQRmgNHToUq1atwvz58/H+++/jiy++wHXXXZd0z6233op//vOfeOutt/D5559j69atuPDCCyOfB4NBDBw4EIFAAIsWLcKsWbMwc+ZMTJgwISbW2rVrsW3btsirVatWkc/eeOMNjBkzBhMnTsSKFSvQs2dPlJeXY8eOHZrPU8lOffffiSPgAYotq3MZ2Wd0rxOthOzbSgCthHGhlZBkIkKLLYBii1iOS1EsqiOayOrVq9G1a1d8/fXX6Nu3LwCgoqICAwYMwObNm1FYWBizZ8+ePWjZsiVmz56Niy++GACwZs0adOnSBYsXL8ZJJ52EDz/8EOeccw62bt2K1q1bAwCmT5+Ou+66Czt37oTX68Vnn32GP/zhD/j111/RtGnTuMdXUlKCE044AU899RQAIBQKoV27drjpppswduxYVedYU1OD/Px8HPXUvXDn5sBVp+6iVI2VEIAqKyEA1VZCQJv1TctatVZCPbHTsV6v1U5rHiO5jNgBjewFYMhKGIlh0EoIwDQrIQBTrYSRmBZYCQGkx0oI2HsBI/jFk/AXn4SYjPA3GQzepKkP+fHJ1uewZ88e5OXlmXRQ5hC+viw5935kZedYkqO+rhZL/nmPkOdvN1JUtBYvXoymTZtGRBYAlJWVwe12Y8mSJXH3LF++HHV1dSgrK4u8V1xcjKOPPhqLFy+OxD3uuOMiIgsAysvLUVNTg1WrVkXF69WrF9q0aYMzzjgDX375ZeT9QCCA5cuXR+Vxu90oKyuL5NGDmsoW4FwroRZEq27ptdql00oo8wh4wDwroVnQShgHWgkTIvxFJyEmI/zNBcFvzhB5kUJoVVVVRVn1ACArKwvNmjWL6ZU6dI/X642pQrVu3Tqyp6qqKkpkhT8PfwYAbdq0wfTp0/HOO+/gnXfeQbt27XDaaadhxYoVAIBdu3YhGAzGjZPo2ADA7/ejpqYm6nU4VogtWayE7NuyPpeRfUb3imIl5Aj4NEArYVxoJSSZhhR9W4SYjK1Ca+zYsXEHTRz6WrNmjZ2HiGOPPRZ/+tOf0KdPH/Tr1w8vv/wy+vXrh8cff9xQ3MmTJyM/Pz/yateuXdx1SnZIdd+WFdUttYhQ3dLaE8YR8Mb2Gd0LmPOAYzMQubpl9QOO0wIfcJwQii2SaQgvtii4iInYOt79tttuw1VXXZV0TceOHVFQUBAzWKK+vh67d+9GQUFB3H0FBQUIBAKorq6Oqmpt3749sqegoCBmOmB4KmGiuABw4oknYuHChQCAFi1awOPxxEwzPDRPPMaNG4cxY8ZEvq6pqUkotoAGwaWmb8uKEfCAut4tEUbA6zkOgCPgjY6A17sX4Ah41TFzsiwbAQ+koXcrLHjsuIjhCHhChIIj4EmmYGtFq2XLliguLk768nq9KC0tRXV1NZYvXx7Z++mnnyIUCqGkpCRu7D59+iA7OxsLFiyIvLd27VpUVlaitLQUAFBaWopvv/02SsTNnz8feXl56Nq1a8LjXrlyJdq0aQMA8Hq96NOnT1SeUCiEBQsWRPLEw+fzIS8vL+qVCrv6tgBtVkLVMTkC3rI8slW3aCVUGZNWQmN5Bb5wopWQZBrC31wQ+OYMkQcpHljcpUsXnHXWWbj22msxffp01NXV4cYbb8Rll10WmTi4ZcsWnH766XjllVdw4oknIj8/HyNHjsSYMWPQrFkz5OXl4aabbkJpaSlOOukkAMCZZ56Jrl274sorr8QjjzyCqqoqjB8/HqNGjYLvf3/wpk6diqKiInTr1g21tbV48cUX8emnn+Ljjz+OHN+YMWMwfPhw9O3bFyeeeCKmTp2K/fv3Y8SIEaZ/L8JiK1V1Kyy2UlW3wmLLzAcca6nGaK3caH3AsZWVKj1VJz0VJ63HZSSXkX1G9wLmVLfMmEgocnWLDziWOLcKWN0imQQrW8TpSCG0AOD111/HjTfeiNNPPx1utxsXXXQRnnjiicjndXV1WLt2LQ4cOBB57/HHH4+s9fv9KC8vxzPPPBP53OPx4P3338f111+P0tJSNG7cGMOHD8d9990XWRMIBHDbbbdhy5YtaNSoEXr06IFPPvkEf/jDHyJrLr30UuzcuRMTJkxAVVUVevXqhYqKipgBGWpwqa1a2WglVDsCXgQroVYxRCvhb/sA/VZCu8UWQCuh7rjptBJSbMWFYotkEuGfdWEFV/h3BQUX0YEUz9HKBMLPOWj33ES4c3OgqH2Olk3P2wLUP3PLqudtAdp6t0R73hagT8joyaM3l5F9RveK8rwtQOxnbln1vC2Az9wSAQoukkkIK7bCJBBbMjxHq1/5fZY+R2vRRxOEPH+7kWK8eybiyg6pqm5l8gh4gH1bVucyss/oXlH6tgDxpxJaheP7tuzOrQLhLzwJMRHhbywIfmOGiAeFluCoFVscAa8+rtbjsHI9oF9spUvYGdlndC9gzgh4pz/g2OoR8Gl7wLFdUGwRIgwUW8RJUGhJgJa+LVXrLBBbIkwl1IJo1S29kwLTOZXQ6DRDo9Uto4g4ldBspK9u2TkZkFMJCREGKR5uTMFFVEChJQl2WgnVYpWVUC0cAW99LiP7jO51opWQI+ATwOpWQii2SCYhtNgCKLZISii0JMMOK6EVfVuAOH1bVlXZ9MQHaCVMhdPEFiCflTAtUGwlhGKLZBIUW0RmKLQEw5OderoZrYSpsdJKqEfUiG4l1IPMVsJM6NsCrKtupbVvy04rocDQSkgyCfHFloYRyCSjoNASEI9XndhykpVQdUxaCS3LI1t1SxQrodl9W7QSxoF9Wwmh2CKZgvBii6jm2WefRY8ePZCXl4e8vDyUlpbiww8/VLV3zpw5cLlcGDRoUNT7iqJgwoQJaNOmDXJzc1FWVoZ169ZZcPTaoNASFDViC3COlTCTRsCny0qoB9nEFkAroap4tBLKm1sFFFskUxB+SAZRxVFHHYWHHnoIy5cvx7Jly/DHP/4R559/PlatWpV0308//YTbb78dp5xySsxnjzzyCJ544glMnz4dS5YsQePGjVFeXo7a2lqrTkMVFFoC4/EGVVe31GCnlVAtIlgJ0zHSPR1WQjv6tuwQagCthKpj0kpoLLfA0EpIMgmKLbk599xzMWDAAHTu3BnHHHMMHnzwQTRp0gRfffVVwj3BYBBDhw7Fvffei44dO0Z9pigKpk6divHjx+P8889Hjx498Morr2Dr1q2YN2+exWeTHAotCXCK2KKV0Nh6wNlWQrv7tgBaCQ3Hdnp1i1ZCQoSBYks8ampqol5+Ff+NgsEg5syZg/3796O0tDThuvvuuw+tWrXCyJEjYz7buHEjqqqqUFZWFnkvPz8fJSUlWLx4sb6TMQnr/uISU/F4gwgGkl+8hcWWUpf8glPJDsGVYg3QILZcgdQXvmGx5apPvTbkVeBWETMsDtx1KZdqWgs0iC2Pyr7VULb6uOlYDzQIEk9AfZVQbx69uYzsM7o3LLbcfnU3FOLG8HrgDqiz7iYj6PPA4zceB2gQXK5AvSmxgN/ElqvWvJiR2N5suAI6fti0kuOzb9qXnblVEBZbvBAlTkfx+3lzQSXuQAjukP6/jUlj1zfEbdeuXdT7EydOxKRJk+Lu+fbbb1FaWora2lo0adIE7777Lrp27Rp37cKFC/HSSy9h5cqVcT+vqqoCALRu3Trq/datW0c+swsKLYlQI7aABsGlRmwBSCm4wpUttYLLTLEFaBMIWtZqFVuAtuOwcj2gX2xpzaM3V3gfgLQLNaBBcBkVWwAMCy6RxRbQILisElsArBdc4eqSHaJHcLEFNAguii3idCi2xGHTpk3Iy8uLfO1L8t/l2GOPxcqVK7Fnzx68/fbbGD58OD7//PMYsbV3715ceeWVeOGFF9CiRQvLjt0qKLQkI2wjVFPdSiW2AGuqW2rFFgDV1S27xZbW2OlYr1fI6K2i6ckV3ptuoQYYF1uAOdWtsI3QDMEVthGaXd2yQmwBGVDdslPoqYRii2QC4Z9xCi57CU8RVIPX68Xvfvc7AECfPn3w9ddfY9q0aXjuueei1v3444/46aefcO6550beC/2vMpeVlYW1a9eioKAAALB9+3a0adMmsm779u3o1auXkVMyDHu0BMOTHUSWimdpZeIIeC1TCdXCvi3rcxnZZ3SvKCPgAbEHZXAqocS5VcBBGSRT4E0FeQmFQnF7uoqLi/Htt99i5cqVkdd5552HP/zhD1i5ciXatWuHoqIiFBQUYMGCBZF9NTU1WLJkSdK+r3TAipagZGUHUV+X/MJMZCuhFX1bgPpqjNV9W1pi66lsaYkPyGMltKNvC6CVUHVMWgmN5Ra4sgWwukUyA1oJxWfcuHE4++yzcfTRR2Pv3r2YPXs2PvvsM3z00UcAgGHDhqFt27aYPHkycnJy0L1796j9TZs2BYCo92+55RY88MAD6Ny5M4qKinDPPfegsLAw5nlb6YZCS2DUii3AGVZCmfq29BwH4CwroR19W3r3As61EsoitgBaCUWAYotkAhRbYrNjxw4MGzYM27ZtQ35+Pnr06IGPPvoIZ5xxBgCgsrISbrc2N8qdd96J/fv347rrrkN1dTX69++PiooK5OTkWHEKqnEpiqL/NjExjZqaGuTn56PTq+PgaRT7Q5FKcAGpxRaQeiJhGDViC1A3JANQV9kKo1ZwaREHWoWEFsGlNbbV6wF9YkRPHr25jOwzuhcwNpUQMF7ZCmNWdQswt28LsGYiYSR2OsQWYK/gEVhshaHgIplAOgRXfSiAT3bPwJ49e1T3KKWL8PVl/z9MQlaWNaKjvr4WC/89Scjztxv2aEmCHX1banq3FK+iqndLyVJMf8Cx1r4tKx9wrAU96/U84FgrmdK3BZjzgGMzyOS+LT7g2H54x59kAryhQOyEQksi1IotpzzgWC1WPuBYS1ytx2G1QNPzAGA9xxXOpQejD0a28wHHIa/HtAccm4XZYgvgA44N5xVccFFskUyAYovYBYWWZKgRW4D66pYa7BRbWqpbauFUQuvyyFbdEmUqYdDnMU1wKd4sS6pbVuF4sWV3bhVwKiHJBCi2iB1QaAmGLzsIX3by3ogsh4yAp5VQ/3paCc3bC9BKqCoerYTGcwsOxRZxOhRbJN1w6qCg+LLr4a9L/p9H9hHwgHOnEuoZAa9lfXiPE0fAA+l9MHIYjoBXGZNTCY3lBYQelMGphMTpZOrDjd2BINwh8wYwRcWutyauE2BFS2BSVbaAzOvbEsFKqAXRrIR67X2yWAnt7tsCaCU0HJtWQtuhlZBkAryhQNIBhZbgqBVbTrASqsUqK6Fa2LdlfS4j+4zuFaVvC6CV0HJoJUwKxRZxOhRbxGootCTAl11vanVLDU4ZAQ+I07dlVZVNT3xAv9hK91RCvYjQt8WphAZjO726xamEhNgOxRaxEgotiaCVMBrZRsDrOQ5aCeUeAQ/QSmg4ttPFlt25VUArIXE6FFvEKii0JMMOK6EaMr1vi1ZCa3MZ2Wd0L62EKuNZbCVMC7QSJoViizgZxe+n4CKmQ6ElGL6seviykoupdFsJtfRtqbUSqoEj4I2t5wh48/YCtBKqjil73xZAK2ESWN0iTodii5gJhZagpBJbgNxWQrV9W4BzrYR6+rZEtBLa0bdFKyGthJZDK2FSKLaIk6HYImZBoSUw6RRbAK2EZq2llVBbHtmqW7QSqoznFCuhXVBsEWIrFFvEDCi0BEet2EoluJwyAp5WQv3raSU0by9AK6HqmLJbCe3u2xJccNFKSJwM+7aIUSi0JEBN3xZgrpVQDXaMgAdoJdS7PrxHC7QSJkckK6FZyCS2AFa3RIFiizgZii2iF+v++hHT8WXVw1+f/D+ZL7se/rrka7Kyg6ivS35hFhZbwUDyda7sEJS61BebSnYILjXrvApcgdQXvkqWAld96nVhseVWETOUDbjrUi7TvDboBTwBdWu1xk7HeqBBkHgC6oWrkTwANOcK79Wzz+jesNhy+9VVcOPG8HrgDqi7wZGIsNjy+I3FAX4TW65A6ps3qmP+T2y5as2LGYntzYYroPGHTQ85PqDWpgsuO3OrxOXz8YKUOBbF75f6hoLHH4QnaPzvQzyUemviOgFWtCTDzMqWE6yEarHbSsi+LetzGdlndC9gjpXQDDK1ukUroRjQSkicDG8kEK1QaAlGTnYdcr3J78yKOAIesMdKaEXfFiCvlVAL6ezbkslKaAT2bamMSSuhvLlVQrFFnArFFtEChZagpBJbgPNHwAPWTCVUiwhiS89xiNi3pSePkVzhvXr3OaVviyPgLcZusSW44KLYIk6FQzKIWii0BCbdYstMK6EaOALemtjpWA/QSpgMjoBXGc/iEfCOtxKG8wsMrYTEyVBskVRQaAlOrldOK6GWvi21VkI1cAS8sfVOtRLqhVbCWGglTADFVlIotohTodgiyaDQkgQRrYRqMLO6xRHwzhkBryePkVwcAU8rYVqwW2wJLrhY3SJORQlQbJH4UGhJhIhii1ZCc9bSSmh9LiP7jO6llVBlPFoJzckvOBRbhJBMgUJLMHKzkosptVbCVGTSCHhaCfWvT5eVUA+yiS2AVkLVMVndkje3Sii2CCGZAIWWgKQSW0Dq6paIfVuAPSPgAVoJ9a4P79GCHqudbCPgaSWMhlbCBNgttgQXXLQSEkKcDoWWoJghtgBaCaPWSWYl1EImWwntem4WrYSx0EoYB7sFj+BiC2B1ixDiXCi0BCY3q06VlTAVtBIesk6l2ALstxKyb8v6XEb2Gd0L0EqoOiarW/LmVgnFFiHW4qoLwhWot+ZVp87VlIlQaEmAWX1btBL+b50FfVuAGNUtq62Eevu2aCVMDK2EKmNSbBnPLbjgopWQEOI0KLQkgVZCWgm1kMnVLVoJjSFydYtWQpPyCw7FFiHEKVBoSYTTrYRqkMVKqDomR8BbkkdvLiP7jO4FaCVUHZPVLXlzq4RiixDiBCi0BKNxtorKlUOthFr6tkS3Eoo0At4q4acnPqBfbMlkJTQCrYQqY1JsGc8tuOCilZAQIjsUWgLSJDuAJtmBpGtktRKqQfTqlmx9W3qOQ8QR8HryGMkV3qt3H62EsdBKGAe7BY/gYgtgdYsQIi8UWgLjVLHlBCuhKH1btBJam8vIPqN7AXOshGYgstgCWN2SOrdKWN0ihMgIhZbgqBFbZlkJU5FJI+CdbCXUAq2ExvYZ3Qs4t2+LVsI42C22JBFchBAiCxRaEpBKbAHmVLdE7NsC7BkBDzjXSpiOke6iWwn1wBHw5vZtAbQSxsVuwUOxRQghpiGN0Nq9ezeGDh2KvLw8NG3aFCNHjsS+ffuS7qmtrcWoUaPQvHlzNGnSBBdddBG2b98etaayshIDBw5Eo0aN0KpVK9xxxx2or/9NSFx11VVwuVwxr27dukXWTJo0Kebz4uJiU8/fyX1btBKas5Yj4LXlka26xb4tDTFZ3ZI3t0poJSSEyIA0Qmvo0KFYtWoV5s+fj/fffx9ffPEFrrvuuqR7br31Vvzzn//EW2+9hc8//xxbt27FhRdeGPk8GAxi4MCBCAQCWLRoEWbNmoWZM2diwoQJkTXTpk3Dtm3bIq9NmzahWbNmuOSSS6JydevWLWrdwoULdZ1nY48/6edmWQlTQSvhIeskshKK2LeVLiuhHmQTW4BzrYRmQ7FlQm5JBBchhIiKdX+JTGT16tWoqKjA119/jb59+wIAnnzySQwYMAB/+9vfUFhYGLNnz57/b+/cw6Oo7jf+7ibZJBiSJZgbCghaEkARGzWsotAaAWurWKtIKQJGRQ0FK22FWn8E2wKCPjzWKkrlolVE8IIXEMpNrBhAI0GBEC6GIuCigkmIJrub5Pz+iDvNkuzcdnZndvN+niePMvM958yenezOm+97vqcGixYtwrJly/DTn/4UALBkyRL07dsX27Ztw6BBg/Dvf/8be/fuxYYNG5CVlYWBAwfiL3/5Cx588EGUlJTA4XAgLS0NaWlpUr+rVq3Ct99+iwkTJgSMFx8fj+zsbENeb0q8B3WNwb88UhK8qPPJP00nx/tQ3xj8YcAvtuq9wWP8YsvTGPw28Ystj0/+VopPaEKjT/7BLM7RhCav8sObLaEZwif/sOkXWzaluB+Ekc2r/PAr4gVsjcpxzQ4Bu4r+gBaBYFfWvZpjmxxAnLLjVOoX0HYdWuL9bbTE+8VInFe7LVPLOP6xtIzTuh2g7RqNaAu0iC27R90fFIL24YiD3avOvhsMv9iK84TWD/A/sWXzKv8BR3WfP4gtW4NxfUp9/yC2bF6NN5xW/GKnQf6PcGEd36yxVWJLTITwWPsaCTEbW0MjbHHG/YEsoO8m4z9jY4WoyGiVlpbC6XRKIgsACgsLYbfbsX379nbblJWVwefzobCwUDqWl5eHHj16oLS0VOr3oosuQlZWlhQzfPhw1NbWYs+ePe32u2jRIhQWFqJnz54Bxw8cOIBu3bqhd+/eGDNmDI4cOaL79QItYkv2PK2EijEArYRaoJUwurJbtBJq6JPZregdWyW0EhJCrEhUCC23243MzMyAY/Hx8UhPT4fb7Q7axuFwwOl0BhzPysqS2rjd7gCR5T/vP3cmx48fx7vvvos777wz4HhBQQGWLl2KtWvXYsGCBaiqqsJVV12F06dPB31NHo8HtbW1AT9noiS2AFoJ1WCW2ALCZyVUixWthFqhlVAeWglV9kmxFfrYUSK4CCHEKpgqtKZNm9ZuoYnWP/v27TPzEgN4/vnn4XQ6MXLkyIDj1113HW655RYMGDAAw4cPx5o1a1BdXY0VK1YE7Wv27NmSLTEtLQ3du3dvNy4l3qMqu6WEUSXgrVaVUMu6LSOrEoZj3RZgnRLw4cqy6ekfiJ4S8KxKaFxVwnCVgGdVQgPGtzjMbhFCrIKpQmvq1KmoqKiQ/enduzeys7Px1VdfBbRtbGzEqVOngq6Lys7OhtfrRXV1dcDxEydOSG2ys7PbVCH0//vMfoUQWLx4McaOHQuHQ/6p1el0ok+fPjh48GDQmOnTp6Ompkb6+eKLL2T7pJVQHqtnt6KtBLye64i1EvDRlt2ilVBDn8xuRe/YGqDYIoSYjalCKyMjA3l5ebI/DocDLpcL1dXVKCsrk9pu2rQJzc3NKCgoaLfv/Px8JCQkYOPGjdKxyspKHDlyBC6XCwDgcrnw2WefBYi49evXIzU1Ff369Qvob8uWLTh48CCKiooUX1ddXR0OHTqEnJycoDGJiYlITU0N+FHCKCuhElYTW0BsWAmtsm6LVsLwjhVKu1DbArQSqu6TYiv0saNAcFFsEULMJCrWaPXt2xcjRozAXXfdhR07dmDr1q2YNGkSbrvtNqni4LFjx5CXl4cdO3YAANLS0lBUVIQHHngAmzdvRllZGSZMmACXy4VBgwYBAIYNG4Z+/fph7Nix2LVrF9atW4c///nPKC4uRuIZH86LFi1CQUEBLrzwwjbX9/vf/x5btmzB4cOH8eGHH+Kmm25CXFwcRo8erfm1nhUvL5SMsBKqXbelxkqoBEvAt8XsEvCA9cQWrYTGtQVoJVTdZ5jFFq2E1oBWQkKsxezZs3HZZZehc+fOyMzMxMiRI1FZWanYrrq6GsXFxcjJyUFiYiL69OmDNWvWSOcjsa+tVqKivDsAvPTSS5g0aRKuueYa2O123Hzzzfj73/8unff5fKisrMT3338vHZs/f74U6/F4MHz4cDz99NPS+bi4OLzzzju499574XK5cNZZZ2HcuHF45JFHAsauqanBa6+9hieeeKLdazt69ChGjx6NkydPIiMjA4MHD8a2bduQkZGh67We9YOQ+k6uxHsESsADLYKLJeBZAj5WSsDrGSeUsfxt9ZZxD6WtX2yFUgbeiBLwQIvgMqIEPNAiuKKlBDzQIrjCXgIeMLcMexSUgAdYBp4Qq7BlyxYUFxfjsssuQ2NjI/70pz9h2LBh2Lt3L84666x223i9Xlx77bXIzMzEq6++inPOOQf//e9/2xS969+/PzZs2CD9Oz7eXKljE0Lo+xYnhlJbW9uShdtyKxwp/xM2cmILgKzYkmIUBJeS2ALk99vyIye2pBgFsQVAUWz5USO4lMSWHyWxJcWpFEdqxJYftYJLizjQKiTUCi49fYc7HtAngPSMo3esUNqF2hYITWxJfRgguIwSW4Cx+21JfYZJbAER2G/Lj9mCx+zxVUCxRYymUXixsW4ZampqVC0FiST+58trcqciPi48md3GJg82Vj6u+/V//fXXyMzMxJYtW3D11Ve3G/PMM89g3rx52LdvHxIS2n8mLSkpwapVq1BeXq75GsJFVFgHOzJnKdkEI2glVIJWwlZxtBKGFB+rVkK9mL1uC6CVMOS+I7lui1ZCWWglJMRa1NTUAADS09ODxrz11ltwuVwoLi5GVlYWLrzwQsyaNQtNTYHPgkbvaxsqFFpRwFnxHlWCS/Z8By4BD6grlGF0CXggdqsS6ikBz6qE5q/bYlVCFf3FQgl4gGJLBRRbhBjLmfvDelRkj5ubm3H//ffjyiuvbLcOgp/PP/8cr776KpqamrBmzRo8/PDDePzxx/HXv/5VitGzr224iZo1WqRFcIW6bguQtxIasW4LaBFcSlbCxIRGw9ZtAcpWQjXrtoAWwaXGSigcwvB1W4A6K6EV1m1p7TsS8YC+dU16xtE7VijtQm0LtAgurttS0WdSPNdthTo2YHkroV9s0U5IYh2bzwdbU3jyK7bmls+zM/eEnTFjBkpKSmTbFhcXY/fu3fjggw9k45qbm5GZmYmFCxciLi4O+fn5OHbsGObNm4cZM2YAaNnX1s+AAQNQUFCAnj17YsWKFaqqhocDCi2L0Tm+AR4EFzGhii1AuVCGP7MlJ7giLbYA5bVbagplWF1sAeoLZWgpOKEl1p/Z0lIoI9xiC9BeKINiKzhGiC0g9HVb/syWEYLLn9kyulBGTIgtgIUyFGChDEJC54svvghYo3VmBe8zmTRpEt555x28//77OPfcc2Vjc3JykJCQgLi4/z3n9e3bF263G16vt909btXsaxtuaB20IKnxDbLnI7FuC4hdK6GWdVtGWgnDsW4LoJUwGHqsdiwBr7EPWglD67sjWQmjwE5IKyEhoXHm/rDBhJYQApMmTcIbb7yBTZs2oVevXop9X3nllTh48CCam//3XLZ//37k5OS0K7IAdfvahhsKLYuSGt8gK7iMWrcVixscxzmaYmaDY7VYQWxp7TsS8UDkNjgOVTTpheu22sINjoNgttgxe3wVsFAGIeGnuLgYL774IpYtW4bOnTvD7XbD7Xajvr5eirn99tsxffp06d/33nsvTp06hSlTpmD//v1YvXo1Zs2aheLiYinGyH1tjYJCy+IYkd1SIhbFFqA+u6UGM8WWlqqEatEqtqxWlVArkRJbescKpV2obYHQs1vNjjjDqhIaBasSBsHs7FIUiC2A2S1CwsmCBQtQU1ODoUOHIicnR/p55ZVXpJgjR47gyy+/lP7dvXt3rFu3Dh999BEGDBiAyZMnY8qUKZg2bZoU49/XNjc3F7feeiu6du0a0r62RsA1WlFAanwDahuTgp5Xs24LkN9zy6h1W4D8nltq120B8ntuGb1uC1Decysc67YAdXtumb1uCwj/BsdWXbeldRy9Y/nbAfo3RtbbFgh93RZgTKEMI9dtAdG1wbFfbLFQhjXgui1CwoOaLXzfe++9NsdcLhe2bdsWtM3y5ctDuaywwIxWlKAms2WFEvCAcnZLzbotwFgroRpYAl6ZcFoJrbpuS884oYzlb6sXWgnbQithEMzOLpk9vgpoJSSEhAKFlsVIiQsuqJTWbQGhWwm5botWQiVoJQz/WKG0C7UtQCuh6j5jRWzRSqgIxRYhRA8UWhaks4zYAqxRlTA53qeqKqESRootM6oSqkGL2DI6u6UlS6Q1o2Q1saUnu6UVViXU2IdBYsvK2S1WJTRo7CgQXMxuEUK0QqFlUYwQW1awEkZrCXiAVkI1dMQS8HrGCWUsf1u90ErYFloJg2C22DF7fJVQbBFC1EKhZWHUiC1aCdtCK2GQWFoJg0IroTy0EqrsM1bEltnZrSiAYosQogZWHbQ4frF1uil41UEjqhLKVSQEjKtKKFeREFBflVCuIiEQO1UJ1VQkBKKzKqHWKoOsSsiqhACrEgKsSmgV/GKLlQlJVNDgCV96pZm/A8FgRitKiIZ1WwCthEZbCcOxbguglTAYtBLKQyuhhj5jJbtlJmaPrxJmtwghwaDQiiJCtRIatW6LVkJlOrqVUAu0EkaX2AJi10poNDEjtmglVISFMggh7UGhZTFS4+qRFvd90POd4xoikt1SIhqrEqohFsQWEL6qhGqx4rqtSFUl1ENHFFuA9aoShmvdFqsSGjB2FAkuQgjxQ6FlUeTEFtDxrIRKqLESmlUCPpashOEuAR8LVsJQSsDrET9ml4CnlVBln8xuGTN+FECxRQjxQ6FlYSIhtqxQAh5Qzm6pWbcFGGslVIPVs1vRtm5La9+RiAeY3VKCVkKVfcaC2AIotlRAKyEhBKDQsjxpcd+HZCVkCfj24bqtILEsAR8Uii15aCVU2SethMaMHUWCixDScaHQihJiwUpoxXVbZlgJ1aBFbBmd3dK6bstKVkIt6F23FUkroR5oJWyB2a0IYLbgodgihFgcCq0ooqNYCVkC/oc4leu2AFoJW8fGUnYrGkvAA7QSqu4zFsQWYL7YigLBRSshIR0TCi2LoWQFNEJs0UrYFloJg8TSShgUWgnloZVQZZ+0EsbG+Cqh2CKkY0GhZVGUxJYVSsDTShgcWgnVYTWxFakS8B3JShgqtBIa0DethJaC2S1COg4UWhZGSSyZvW4LoJVQCVoJlemIJeD1jBPKWP62euG6rbZQbMlgttiKIsFFSMRo8AINnjD9KD/rdVQotCxOJMSWnOAyat0WrYTK0EoYnr4jEQ/QSqiEldZt0UoYAcwWO2aPrxKKLUJiGwqtKEDNui0rWAmViEYroRpiQWwBtBK2F08roXFtAVoJNfUZC9kts7NLUSS2KLgIiU0otKIIq1sJjVi3BVjLSmjWui0jrYThWLcF0EoYDFoJ5aGVUEOfsSC2APPFVhQJLkJIbEGhZTHS7PVwKmSnZNtHSQl4WgmV6ehWQi3QShhdYguglVB1n7QSxsb4KmF2i5DYgkLLoiiJrXBaCSNRAh5QZyVUwmpiC6CVUClWLVZct0UroXFtAVoJNfUZC9kts7NLUSK2AGa3CIkVKLQsjJzYAqyR3ZIjkiXg1VgJlWAJ+LaEw0oY7nVbtBJGV3aLVkINfcaC2ALMF1tRIrgotgiJfii0LI4z7vsOYSVUwojsFkvAnxEbo+u2tPYdiXiAVkIlaCVU2SethLExvkpoJSQkuqHQihJi3UrIdVvWthJaZd1WR7US6oFWwtBgdisCmJ1dihKxBTC7RUi0QqEVRdBKaM0S8LQSthNnoRLwsWAlDGXdVrRlt2gl1NBnLIgtwHyxFSWCi9ktQqIPCi2LkWKvR2d7fdDz0S62gMhYCSNZAh6glTBoLK2EQYmW7JZeYslKaBS0Espgttgxe3wNUGwREj1QaFkUJbEVqpVQdmwVYktOcLEEfHBoJTQu1opWQq1QbMljFSuhkeu2AGa3gmJ2dsns8TVAsUW0IrweCE+YfrzKf2TvqFBoWRg5sQWElt0Kdd0WYIyVUAlaCWklVMJqYsvqVkI9mL1ui1ZClX3GgtgCzBc7Zo+vEloJCbE+FFoWp3OMWwmNWLcF0EpIK6G2fq22bguIXHYrGtdtAbQSqu6TVsLYGF8DFFuEWBcKrSghVCuhHNFSAp5WQmVoJQxP35GIB2glVIJWQg19xkJ2y2wrn9nja4DZLUKsCYWWxUizBxctoVgJY6EEPKDOSqiE1cQWoN5KqAazxBZAK2F78ZEqAU8roYY+aCUMvW9mtywJxRYh1oJCy4I4ZQQVrYTGrdtSYyVUQo2V0Kx1W0ZaCcOxbguglTAYesUIrYQa2tNKaEz/FFuWg2KLEOtAoWVR5MQWQCuhEeu2AOXslpp1W4CxVkI1WD27ZRUroRZoJex4YgugldCQvmkltBy0EhJiDSi0LIzTXq+Y3ZJtH+NWQq7bsrbYAsJnJVSLFddt0UpoXFuAVkJNfdJKGBvja4BiixBzodCKAsIltgBrZLfkiKSVUAmWgG8VZ7KVMNzrtmgl7HjZLVoJDeqfYstyMLtFiHlQaEUJsb5uywpWQpaA/yGOJeA19x2JeIBWQiVoJdTQZ6yILVoJVUOxRUjkodCyGGn24A/64V63pWQllB1bhdiilbAtHclKaJV1W7QShncsfzszrYShQiuhAX3TSmhJKLYIiSzh+5QlunHafagO8lTkF1vVzcntnu9sr8fpIOeAFsFV3dQp6PnOcQ043ZTU7jm/2KoJ0t4vtoK1B1oEV21j8PNnxXvwXWPwL4KUeA/qZM4DLYKrzhf8adovtuobgz8EJDt8qPfKPyQkxjfC0yj/K5SY0AiPTz7GL7YaffIPZXGOJjR55WP8Ykv45B82RUIzbAoxQIvYsnmVH3r9YsvWqBzb7BCwq+jT/ysg87cHXbFAi9iKU06C6upba7y/jZZ4vxCJ86rPFOoZJ5Sx/G31tAu1rV9s2T3q/qjQbh8/iC27V11WORhNiXGI84TWhx+/2LJ5lf+Io7rPH8SWrcG4PgP6dyTA5tV40+nBL3YalLcJicnxNeAXW8Jj/WslxtFc34BmmzGfRW36FhH4HY9SmNGyKE67D06d2a1YsBLKYcS6LYBWQloJ1cdq7TsS8QCthEpYJbtFK2GEMluA+dkls8fXALNbhIQfCi2Lo1dsASwBTyshrYRKdGQroR5oJQyNji62aCW0HiyUQUh4odCKApTEFkvAy8OqhLFRlVBrCXgrVSXUSiSqEoaybivasltGlYBnVUID+mehDEtCsUVIeKDQihLkxFbLeVoJZWNoJVSMoZVQfaye66CVMLR2obYFrJPdopWQVkIrQrFFiPFQaFmMzvbgb0ko67Za+qaVUAlaCWkltJqVUCvRIrZoJaSVkFZC60ErISHGEjVC69SpUxgzZgxSU1PhdDpRVFSEuro62TYNDQ0oLi5G165dkZKSgptvvhknTpwIiJk8eTLy8/ORmJiIgQMHttvPp59+iquuugpJSUno3r075s6d2yZm5cqVyMvLQ1JSEi666CKsWbNG92vtbLcrCq7g52gllD0fo+u2APVWQjWYJbaA6LQSaiFS67ZoJQyOUVZCI6CVkFZCK0KxRcLJ+++/j1/84hfo1q0bbDYbVq1apdjmqaeeQt++fZGcnIzc3Fy88MILbWKMfBY3iqgRWmPGjMGePXuwfv16vPPOO3j//fdx9913y7b53e9+h7fffhsrV67Eli1bcPz4cfzyl79sE3fHHXdg1KhR7fZRW1uLYcOGoWfPnigrK8O8efNQUlKChQsXSjEffvghRo8ejaKiIuzcuRMjR47EyJEjsXv37pBes16x1XI+PGILsEZ2Sw4jrIRq122psRIqYeV1W0ZaCcOxbguwhpVQz7otZrdCaxdqWyD07JaR67Y6enYrYpgtdsweXwPMbpFw8d133+Hiiy/GU089pSp+wYIFmD59OkpKSrBnzx7MnDkTxcXFePvtt6WYcD2Lh4pNCKFvo5IIUlFRgX79+uGjjz7CpZdeCgBYu3Ytfvazn+Ho0aPo1q1bmzY1NTXIyMjAsmXL8Ktf/QoAsG/fPvTt2xelpaUYNGhQQHxJSQlWrVqF8vLygOMLFizAQw89BLfbDYej5clr2rRpWLVqFfbt2wcAGDVqFL777ju88847UrtBgwZh4MCBeOaZZ1S9xtraWqSlpeHQvmx07hz45X+6Wf5hN9ieWy3ngu+p1dJ38PNy+20B8vtlAcH321LbXm6/LT9ye24BUNxzS26/LT9y+21JMQp7bgFQ3HMLgOKeW4DyflsAFPfb8qO035YfNXtuAVC15xagbr8tP2r23AK07Q+lJVbtflt6+o5EPKBvDyw94+gdK5R2RrQPZb8tqY8Q99vyY9SeW4Cx+21JfYZpvy2p/0jsuQWYv9+V2eNrhHtuydMovNhYtww1NTVITU01+3IC8D9f/iTul4i3heePGo3Ch81Nr+t6/TabDW+88QZGjhwZNOaKK67AlVdeiXnz5knHpk6diu3bt+ODDz4AYMyzeDiIioxWaWkpnE6nJLIAoLCwEHa7Hdu3b2+3TVlZGXw+HwoLC6VjeXl56NGjB0pLSzWNffXVV0siCwCGDx+OyspKfPvtt1JM63H8MVrGkUMuswWYWwJeyUooO7aKzBathG3pSOu2APOthFZctxWpEvCRyqL529FKSCshrYTWhNktYiYejwdJSYF/fE9OTsaOHTvg87U8f4X7WVwv4fu0NBC3243MzMyAY/Hx8UhPT4fb7Q7axuFwwOl0BhzPysoK2iZYP7169WrTh/9cly5d4Ha7pWNqx/F4PPC0+gtRTU0NAOB0XfAHWrnMVhw8qAnyVBSP71DTHDw7ZEcd6mQyWw6cRo3M+fqm4OLAgVrUNgVvmwAf6hQyW4nw4bRMdisBPnzXGPxJ2AEvvmuS/4JIhBff+YJ/wSfAo5jZSoAHDTJ9AEA8PIqZrXh44FHIWtkANKnIbKmNMy2z1aQurhnqM1taNqgXGv443wT12a0maMsIaY2X2mi+fu1ZH93X5tOXYWq06c9OhdIWAGAH7N4Qslt2YzJbjXHGZrZgB2w+A/sDgIQwZrfiAJsvQpktB8zNLjkANGhMm5tJgg3Cy+zWmTT+8MVjZZNYI3xAmC6vES2vv7a2NuB4YmIiEg0Q6MOHD8dzzz2HkSNH4sc//jHKysrw3HPPwefz4ZtvvkFOTo6uZ/FIYKrQmjZtGh599FHZmIqKighdTWSZPXs2Zs6c2eb4wEu/MuFqCCGEEEJIKJw8eRJpaWlmX0YADocD2dnZ+I/7beXgEEhJSUH37t0Djs2YMQMlJSUh9/3www/D7XZj0KBBEEIgKysL48aNw9y5c2FXcH2ZjalCa+rUqRg/frxsTO/evZGdnY2vvgoUII2NjTh16hSys7PbbZednQ2v14vq6uqArNaJEyeCtgnWz5mVCv3/9vcTLEZunOnTp+OBBx6Q/l1dXY2ePXviyJEjlvsltTK1tbXo3r07vvjiC8v5oq0M500fnDd9cN70w7nTB+dNH5w3fdTU1KBHjx5IT083+1LakJSUhKqqKni94c2cCiFgswU6T4zIZgEtNsHFixfj2WefxYkTJ5CTk4OFCxeic+fOyMjIAKDvWTwSmCq0MjIypAmSw+Vyobq6GmVlZcjPzwcAbNq0Cc3NzSgoKGi3TX5+PhISErBx40bcfPPNAIDKykocOXIELpdL9TW6XC489NBD8Pl8SEhosYWtX78eubm56NKlixSzceNG3H///VK79evXy44TLJ2alpbGDzcdpKamct50wHnTB+dNH5w3/XDu9MF50wfnTR9Wza4kJSW1WeMUjSQkJODcc88FACxfvhw///nPpTnX8yweCax5R5xB3759MWLECNx1113YsWMHtm7dikmTJuG2226TKg4eO3YMeXl52LFjB4AWwVJUVIQHHngAmzdvRllZGSZMmACXyxVQcfDgwYMoLy+H2+1GfX09ysvLUV5eLin/X//613A4HCgqKsKePXvwyiuv4IknngjIRk2ZMgVr167F448/jn379qGkpAQff/wxJk2aFMFZIoQQQgghxNrU1dVJz9sAUFVVhfLychw5cgRAi+vr9ttvl+L379+PF198EQcOHMCOHTtw2223Yffu3Zg1a5YUY9lncRElnDx5UowePVqkpKSI1NRUMWHCBHH69GnpfFVVlQAgNm/eLB2rr68X9913n+jSpYvo1KmTuOmmm8SXX34Z0O+QIUMEWpYHBvxUVVVJMbt27RKDBw8WiYmJ4pxzzhFz5sxpc30rVqwQffr0EQ6HQ/Tv31+sXr1a0+urqakRAERNTY2mdh0dzps+OG/64Lzpg/OmH86dPjhv+uC86YPzpo3Nmze3++w9btw4IYQQ48aNE0OGDJHi9+7dKwYOHCiSk5NFamqquPHGG8W+ffva9Bvqs3g4iIp9tDoCHo8Hs2fPxvTp0w3ztHYEOG/64Lzpg/OmD86bfjh3+uC86YPzpg/OGwkGhRYhhBBCCCGEGExUrNEihBBCCCGEkGiCQosQQgghhBBCDIZCixBCCCGEEEIMhkLLIE6dOoUxY8YgNTUVTqcTRUVFqKurk23T0NCA4uJidO3aFSkpKbj55pvbbLY2efJk5OfnIzExEQMHDmy3n08//RRXXXUVkpKS0L17d8ydO7dNzMqVK5GXl4ekpCRcdNFFWLNmje7XaiThmrcjR47g+uuvR6dOnZCZmYk//OEPaGxslM6PHz8eNputzU///v2lmJKSkjbn8/LyjJ0AnZg1b++991678+Z2uwP6eeqpp3DeeechKSkJBQUF0rYLZmPWvL3++uu49tprkZGRgdTUVLhcLqxbty6gDyvdb1rfP6XPFyEE/u///g85OTlITk5GYWEhDhw4EBCj5r1R81lnJpGet8OHD6OoqAi9evVCcnIyzj//fMyYMSNgY9LDhw+3+zu7bds2Y198CJhxv5133nlt5mTOnDkBMVa/34DIz12w7wCbzYaPPvoIQMe8515//XUMGzYMXbt2hc1mk8qWt8aI7xIShZhX8DC2GDFihLj44ovFtm3bxH/+8x9xwQUXiNGjR8u2ueeee0T37t3Fxo0bxccffywGDRokrrjiioCY3/72t+If//iHGDt2rLj44ovb9FFTUyOysrLEmDFjxO7du8XLL78skpOTxbPPPivFbN26VcTFxYm5c+eKvXv3ij//+c8iISFBfPbZZ4a89lAIx7w1NjaKCy+8UBQWFoqdO3eKNWvWiLPPPltMnz5diqmurhZffvml9PPFF1+I9PR0MWPGDClmxowZon///gFxX3/9teFzoAez5s1fkrWysjJgXpqamqSY5cuXC4fDIRYvXiz27Nkj7rrrLuF0OsWJEyeMnwiNmDVvU6ZMEY8++qjYsWOH2L9/v5g+fbpISEgQn3zyiRRjlftN6/un5vNlzpw5Ii0tTaxatUrs2rVL3HDDDaJXr16ivr5eilF6b9R81pmJGfP27rvvivHjx4t169aJQ4cOiTfffFNkZmaKqVOnSn34tz7ZsGFDwL3l9XrDOyEqMet+69mzp3jkkUcC5qSurk46b/X7TQhz5s7j8QTM2ZdffinuvPNO0atXL9Hc3CyE6Jj33AsvvCBmzpwp/vnPfwoAYufOnW36MeK7hEQfFFoGsHfvXgFAfPTRR9Kxd999V9hsNnHs2LF221RXV4uEhASxcuVK6VhFRYUAIEpLS9vEz5gxo12h9fTTT4suXboIj8cjHXvwwQdFbm6u9O9bb71VXH/99QHtCgoKxMSJE1W/xnAQrnlbs2aNsNvtwu12SzELFiwQqampAfPUmjfeeEPYbDZx+PBh6ViwOTcbM+fNL7S+/fbboNd3+eWXi+LiYunfTU1Nolu3bmL27Nm6Xq9RWOl+E0KIfv36iZkzZ0r/tsr9pvX9U/p8aW5uFtnZ2WLevHnS+erqapGYmChefvllIYS690bNZ52ZmDFv7TF37lzRq1cv6d/+h972HvysgFnz1rNnTzF//vyg12X1+00Ia9xzXq9XZGRkiEceeUQ61tHuudYEe+3h/C4h1obWQQMoLS2F0+nEpZdeKh0rLCyE3W7H9u3b221TVlYGn8+HwsJC6VheXh569OiB0tJSTWNfffXVcDgc0rHhw4ejsrIS3377rRTTehx/jJZxwkG45q20tBQXXXQRsrKypJjhw4ejtrYWe/bsabffRYsWobCwED179gw4fuDAAXTr1g29e/fGmDFjpF3LzcQK8zZw4EDk5OTg2muvxdatW6XjXq8XZWVlAePY7XYUFhbyfmtFc3MzTp8+jfT09IDjZt9vet4/pc+XqqoquN3ugJi0tDQUFBQEzKHSe6Pms84szJq39qipqWlzXwHADTfcgMzMTAwePBhvvfWWptcXLsyetzlz5qBr16645JJLMG/evACLlpXvN8D8ufPz1ltv4eTJk5gwYUKbcx3lnlNDuL5LiPWh0DIAt9uNzMzMgGPx8fFIT09vs3aldRuHwwGn0xlwPCsrK2ibYP20/qX09+E/JxejZZxwEK55UzMnrTl+/Djeffdd3HnnnQHHCwoKsHTpUqxduxYLFixAVVUVrrrqKpw+fVrT6zQaM+ctJycHzzzzDF577TW89tpr6N69O4YOHYpPPvkEAPDNN9+gqamJ95vM/QYAjz32GOrq6nDrrbdKx6xwv+l5/5Q+X/z/VYpRem/0zHOkMGvezuTgwYN48sknMXHiROlYSkoKHn/8caxcuRKrV6/G4MGDMXLkSEs8+Jo5b5MnT8by5cuxefNmTJw4EbNmzcIf//hHxXFaj2EmVrnnFi1ahOHDh+Pcc8+VjnW0e04N4fouIdYn3uwLsDLTpk3Do48+KhtTUVERoauJHqJt3p5//nk4nU6MHDky4Ph1110n/f+AAQNQUFCAnj17YsWKFSgqKjL8OqJh3nJzc5Gbmyv9+4orrsChQ4cwf/58/Otf/zLlmqJh3lqzbNkyzJw5E2+++WaAuIj0/UZii2PHjmHEiBG45ZZbcNddd0nHzz77bDzwwAPSvy+77DIcP34c8+bNww033GDGpVqC1nMyYMAAOBwOTJw4EbNnz0ZiYqKJVxY9HD16FOvWrcOKFSsCjvOeI+R/UGjJMHXqVIwfP142pnfv3sjOzsZXX30VcLyxsRGnTp1CdnZ2u+2ys7Ph9XpRXV0d8BeOEydOBG0TrJ8zq9b4/+3vJ1iMlnG0YPa8ZWdnt6kgdOac+BFCYPHixRg7dmyARaQ9nE4n+vTpg4MHD8rG6SWa5q01l19+OT744AMALV+wcXFxvN+CzNvy5ctx5513YuXKlW2sKGcS7vutPfS8f0qfL/7/njhxAjk5OQEx/kqqat4bNZ91ZmHWvPk5fvw4fvKTn+CKK67AwoULFa+3oKAA69evV4wLN2bPW2sKCgrQ2NiIw4cPIzc319L3G2CNuVuyZAm6du2qSjzF8j2nhnB+BxNrQ+ugDBkZGcjLy5P9cTgccLlcqK6uRllZmdR206ZNaG5uRkFBQbt95+fnIyEhARs3bpSOVVZW4siRI3C5XKqv0eVy4f3334fP55OOrV+/Hrm5uejSpYsU03ocf4yWcbRg9ry5XC589tlnAQ9u69evR2pqKvr16xfQ35YtW3Dw4EFVGYO6ujocOnQo4AvISKJp3lpTXl4uzYnD4UB+fn7AOM3Nzdi4cWOHv99efvllTJgwAS+//DKuv/56xdcV7vutPfS8f0qfL7169UJ2dnZATG1tLbZv3x4wh0rvjZrPOrMwa96AlkzW0KFDkZ+fjyVLlsBuV/5ab/07ayZmztuZlJeXw263S1lmK99vgPlzJ4TAkiVLcPvttyMhIUHxemP5nlNDOL+DicUxuxpHrDBixAhxySWXiO3bt4sPPvhA/OhHPwooTXz06FGRm5srtm/fLh275557RI8ePcSmTZvExx9/LFwul3C5XAH9HjhwQOzcuVNMnDhR9OnTR+zcuVPs3LlTqkBTXV0tsrKyxNixY8Xu3bvF8uXLRadOndqUd4+PjxePPfaYqKioEDNmzLBUeXej581fInXYsGGivLxcrF27VmRkZLRbIvU3v/mNKCgoaPfapk6dKt577z1RVVUltm7dKgoLC8XZZ58tvvrqKwNnQB9mzdv8+fPFqlWrxIEDB8Rnn30mpkyZIux2u9iwYYMUs3z5cpGYmCiWLl0q9u7dK+6++27hdDoDKimZhVnz9tJLL4n4+Hjx1FNPBZQ7rq6ulmKscr8pvX9jx44V06ZNk+LVfL7MmTNHOJ1O8eabb4pPP/1U3Hjjje2Wd5d7b9R81pmJGfN29OhRccEFF4hrrrlGHD16NODe8rN06VKxbNkyUVFRISoqKsTf/vY3YbfbxeLFiyM0M/KYMW8ffvihmD9/vigvLxeHDh0SL774osjIyBC333671IfV7zchzPtdFUKIDRs2CACioqKizXV1xHvu5MmTYufOnWL16tUCgFi+fLnYuXNnwO+ikc8uJHqg0DKIkydPitGjR4uUlBSRmpoqJkyYIE6fPi2d95f83Lx5s3Ssvr5e3HfffaJLly6iU6dO4qabbgr4pRRCiCFDhggAbX6qqqqkmF27donBgweLxMREcc4554g5c+a0ub4VK1aIPn36CIfDIfr37y9Wr15t+BzoIVzzdvjwYXHdddeJ5ORkcfbZZ4upU6cKn88XEFNdXS2Sk5PFwoUL2722UaNGiZycHOFwOMQ555wjRo0aJQ4ePGjciw8Bs+bt0UcfFeeff75ISkoS6enpYujQoWLTpk1tru/JJ58UPXr0EA6HQ1x++eVi27Ztxk+CDsyat2C/x+PGjZNirHS/yb1/Q4YMCbhuIZQ/X5qbm8XDDz8ssrKyRGJiorjmmmtEZWVlQIzSeyOEus86M4n0vC1ZsqTd+6r131CXLl0q+vbtKzp16iRSU1PF5ZdfHlBi2gpEet7KyspEQUGBSEtLE0lJSaJv375i1qxZoqGhIaAfq99vQpjzuyqEEKNHj26z76efjnjPBftdbL03p1HPLiS6sAkhRISSZ4QQQgghhBDSIeAaLUIIIYQQQggxGAotQgghhBBCCDEYCi1CCCGEEEIIMRgKLUIIIYQQQggxGAotQgghhBBCCDEYCi1CCCGEEEIIMRgKLUIIIYQQQggxGAotQgghhBBCCDEYCi1CCCGEEEIIMRgKLUIIIYYydOhQ3H///QHHJk+ejPz8fCQmJmLgwIGmXBchhBASSSi0CCGERIQ77rgDo0aNMvsyCCGEkIhgE0IIsy+CEEJIbDB+/Hg8//zzAceqqqpw3nnnAQBKSkqwatUqlJeXR/7iCCGEkAgSb/YFEEIIiR2eeOIJ7N+/HxdeeCEeeeQRAEBGRobJV0UIIYREHgotQgghhpGWlgaHw4FOnTohOzvb7MshhBBCTINrtAghhBBCCCHEYCi0CCGEEEIIIcRgKLQIIYQYisPhQFNTk9mXQQghhJgK12gRQggxlPPOOw/bt2/H4cOHkZKSgvT0dHz++eeoq6uD2+1GfX29VHWwX79+cDgc5l4wIYQQEgZY3p0QQoih7N+/H+PGjcOuXbtQX1+PqqoqjB8/Hlu2bGkT27r0OyGEEBJLUGgRQgghhBBCiMFwjRYhhBBCCCGEGAyFFiGEEEIIIYQYDIUWIYQQQgghhBgMhRYhhBBCCCGEGAyFFiGEEEIIIYQYDIUWIYQQQgghhBgMhRYhhBBCCCGEGAyFFiGEEEIIIYQYDIUWIYQQQgghhBgMhRYhhBBCCCGEGAyFFiGEEEIIIYQYDIUWIYQQQgghhBjM/wPZNoTQCKrFRQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lv.loss_scan_2d_3d(\n", + " params=paramsf,\n", + " direction1=d1,\n", + " direction2=d2,\n", + " loss_function=objective,\n", + " n_steps=300,\n", + " end_points_x=(-0.01, 0.01),\n", + " end_points_y=(-0.01, 0.01),\n", + " plot3D=True,\n", + " n_jobs=-1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "32160040", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[PCA] Starting PCA-based loss landscape scan...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Scan in PCA directions: 100%|██████████| 300/300 [00:17<00:00, 17.28it/s]\n", + "Trajectory loss: 100%|██████████| 2379/2379 [00:00<00:00, 4826.98it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[PCA] Plotting 2D PCA loss landscape\n", + "[PCA] Plotting 3D PCA loss surface\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[PCA] Computing interpretable PCA analysis...\n", + "[PCA] Visualizing parameter influence on real circuits\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[PCA] Generating global PCA analysis figures\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAPeCAYAAAB3GThSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVhU1RsH8O+wDTDAALKIiqCiIrhjKm4oLrjnjkuipuaalmtWmopIlqJlpma/1BLLVNRSc9/3LcwEFRXRXFBEdhhg5v7+IG5cZhBQYFC/n+eZR+fcc8597+HOcOflzLkyQRAEEBEREREREREREVG5YKDvAIiIiIiIiIiIiIjoP0zaEhEREREREREREZUjTNoSERERERERERERlSNM2hIRERERERERERGVI0zaEhEREREREREREZUjTNoSERERERERERERlSNM2hIRERERERERERGVI0zaEhEREREREREREZUjTNoSERERERERERERlSNM2hIRERERERERERGVI0zaEhGVoHXr1kEmk4kPU1NT1KpVCxMnTkRsbKxW/djYWEybNg3u7u4wNzeHQqGAl5cXFixYgISEBJ37aNq0KWQyGVauXFnKR0NERERERERE+iATBEHQdxBERK+LdevWYcSIEZg/fz6qVauGjIwMnDhxAj/99BNcXFzw999/w9zcHABw/vx5dO3aFSkpKXjnnXfg5eUFALhw4QJ++eUXtGjRAvv27ZP0HxUVhVq1asHV1RWVK1fGiRMnyvwYiYiIiIiIiKh0Gek7ACKi11GXLl3QpEkTAMCoUaNQoUIFhISEYMeOHRg0aBASEhLQu3dvGBoa4s8//4S7u7ukfVBQENasWaPV74YNG+Dg4IAlS5agX79+uHPnDlxdXcvikF4bqampUCgU+g6DiIiIiIiIqEBcHoGIqAz4+voCAKKjowEAq1evxv379xESEqKVsAUAR0dHfPrpp1rlGzduRL9+/dC9e3colUps3LixyDEsX74cnp6eMDc3h42NDZo0aSJpP3z4cJ0J4Llz50Imk0nKZDIZJk6ciM2bN8PDwwNmZmbw9vbGlStXxONzc3ODqakp2rZtizt37kjat23bFnXr1sVff/0FHx8fmJubw83NDVu2bAEAHD16FM2aNYOZmRlq166NAwcOSNrHxMRg/PjxqF27NszMzFChQgX0799faz+5y1UcPXoU48ePh4ODA6pUqYLDhw9DJpNh27ZtWse7ceNGyGQynD59uqhDS0RERERERFSimLQlIioDt27dAgBUqFABAPDbb7/BzMwM/fr1K3IfZ8+exc2bNzFo0CCYmJigT58+CA0NLVLbNWvWYNKkSfDw8MCyZcswb948NGzYEGfPni3+wfzr+PHjmDp1KoYNG4a5c+ciMjIS3bt3x4oVK/D1119j/PjxmD59Ok6fPo13331Xq/2zZ8/QvXt3NGvWDF988QXkcjkGDhyITZs2YeDAgejatSs+//xzpKamol+/fkhOThbbnj9/HqdOncLAgQPx9ddfY+zYsTh48CDatm2LtLQ0rX2NHz8eERERmDNnDj766CO0bdsWzs7OOscvNDQUNWrUgLe39wuPDREREREREdHL4PIIRESlIDExEXFxccjIyMDJkycxf/58mJmZoXv37gCAyMhI1KpVCyYmJkXuc8OGDXB2dkbLli0BAAMHDsQPP/yA8PBwNGzY8Lltd+3aBU9PT2zevPmFjym/69ev49q1a+LsXBsbG4wZMwYLFizAjRs3YGlpCQBQq9UIDg7WWsrhwYMH2LhxIwYNGgQA6NixI9zd3TF48GCcOnUKzZo1AwDUqVMHfn5+2Lp1K4YPHw4A6Natm1bCu0ePHvD29sbWrVsxdOhQyTZbW1scPHgQhoaGYtk777yDkJAQJCYmQqlUAgCePHmCffv24ZNPPimxcSIiIiIiIiIqLs60JSIqBR06dIC9vT2cnZ0xcOBAWFhYYNu2bahcuTIAICkpSUxqFkV2djY2bdoEf39/cakCX19fODg4FGm2rbW1Nf755x+cP3/+xQ5Ih/bt20uSsLlJ1r59+0qOLbf89u3bkvYWFhYYOHCg+Lx27dqwtrZGnTp1xDYFtTczMxP/n5WVhadPn8LNzQ3W1ta4dOmSVqyjR4+WJGwBICAgACqVSlySAQA2bdqE7OxsvPPOO4UPABEREREREVEpYdKWiKgUrFixAvv378fhw4cRERGB27dvw8/PT9xuZWUl+bp/Yfbt24cnT56gadOmuHnzJm7evIno6Gi0a9cOP//8MzQazXPbz5w5ExYWFmjatClq1qyJCRMm4OTJky98fABQtWpVyfPc2arOzs46y589eyYpr1KlitZauUqlskjt09PTMWfOHDg7O0Mul8POzg729vZISEhAYmKiVqzVqlXTKnN3d8dbb70lSXqHhoaiefPmcHNz033QRERERERERGWAyyMQEZWCpk2bokmTJgVud3d3R3h4ODIzM4u0REJuYnHAgAE6tx89ehTt2rUrsH2dOnVw/fp17Ny5E3v27MHWrVvx7bffYs6cOZg3bx4AaCVQc6nVap3l+WeuFlYuCEKJtX///fexdu1afPDBB/D29oZSqYRMJsPAgQN1JrDzzszNKyAgAJMnT8Y///wDlUqFM2fO4JtvvtFZl4iIiIiIiKisMGlLRKQHPXr0wOnTp7F161ZxTdeCpKamYseOHfD399d547JJkyYhNDT0uUlbAFAoFPD394e/vz8yMzPRp08fBAUFYdasWTA1NYWNjQ0SEhK02sXExBTr2MrCli1bMGzYMCxZskQsy8jI0Bn/8wwcOBBTpkzBzz//jPT0dBgbG8Pf37+EoyUiIiIiIiIqHi6PQESkB2PHjoWTkxOmTp2KGzduaG1//PgxFixYAADYtm0bUlNTMWHCBPTr10/r0b17d2zduhUqlarA/T19+lTy3MTEBB4eHhAEAVlZWQCAGjVqIDExEX/99ZdY7+HDh9i2bVtJHHKJMjQ01Jq5u3z58gJnBRfEzs4OXbp0wYYNGxAaGorOnTvDzs6uJEMlIiIiIiIiKjbOtCUi0gMbGxts27YNXbt2RcOGDfHOO+/Ay8sLAHDp0iX8/PPP8Pb2BpCzNEKFChXQokULnX317NkTa9aswa5du9CnTx+ddTp16oSKFSuiZcuWcHR0RGRkJL755ht069ZNvGnYwIEDMXPmTPTu3RuTJk1CWloaVq5ciVq1aum8uZc+de/eHT/99BOUSiU8PDxw+vRpHDhwABUqVCh2XwEBAeIM5sDAwJIOlYiIiIiIiKjYmLQlItKTZs2a4e+//8aXX36JXbt24aeffoKBgQHq1KmDjz76CBMnTsTjx49x4MABDBo0qMC1Xtu3bw9zc3Ns2LChwKTtmDFjEBoaipCQEKSkpKBKlSqYNGkSPv30U7FOhQoVsG3bNkyZMgUzZsxAtWrVEBwcjKioqHKXtP3qq69gaGiI0NBQZGRkoGXLljhw4IDkZm9F1aNHD9jY2ECj0aBnz56lEC0RERERERFR8ciE/N8vJSIieoNkZ2ejUqVK6NGjB/73v//pOxwiIiIiIiIirmlLRERvtu3bt+PJkycICAjQdyhEREREREREADjTloiI3lBnz57FX3/9hcDAQNjZ2ZW7JSCIiIiIiIjozcWZtkRE9EZauXIlxo0bBwcHB/z444/6DoeIiIiIiIhIxJm2REREREREREREROUIZ9oSERERERERERERlSNM2hIRERERERERERGVI0zaEr2hXF1dMXz4cH2HUe6tW7cOMpkMd+7c0XcoRERERERUCubOnQuZTPZCbV1dXdG9e/cSi+XOnTuQyWRYt25difX5otq2bYu2bdu+cPuffvoJ7u7uMDY2hrW1dYn0SfQmYdKWqJw6deoU5s6di4SEBH2H8kIWLlyI7du36zuM11JaWhpWrFiBTp06wcnJCZaWlmjUqBFWrlwJtVotqfvgwQO88847qF27NiwtLWFtbY2mTZti/fr1yL+kuaurK2Qymc5HzZo1JXVjY2MxYsQIODg4wMzMDI0bN8bmzZtL/dipcGlpaZg7dy6OHDmi71CKRaPRYN26dejZsyecnZ2hUChQt25dLFiwABkZGTrb/O9//0OdOnVgamqKmjVrYvny5WUcNRHRq62g3/v5H2XxO2XlypXo378/qlatCplMVuDkgoMHD+Ldd99FrVq1YG5ujurVq2PUqFF4+PBhqcf4Oti9ezfmzp2r7zDoDXDt2jUMHz4cNWrUwJo1a/Ddd9/pOySiV46RvgMgIt1OnTqFefPmYfjw4eJfJUvS9evXYWBQen+3WbhwIfr164devXqV2j7KwtChQzFw4EDI5XJ9hyK6ffs23n//fbRv3x5TpkyBlZUV9u7di/Hjx+PMmTNYv369WDcuLg7//PMP+vXrh6pVqyIrKwv79+/H8OHDcf36dSxcuFCsu2zZMqSkpEj2FRMTg08//RSdOnUSy5KSktCqVSvExsZi8uTJqFixIn799VcMGDAAoaGhGDx4cOkPAhUoLS0N8+bNA4BXahZDWloaRowYgebNm2Ps2LFwcHDA6dOn8dlnn+HgwYM4dOiQZAbM6tWrMXbsWPTt2xdTpkzB8ePHMWnSJKSlpWHmzJl6PBIiolfHTz/9JHn+448/Yv/+/VrlderUKfVYFi1ahOTkZDRt2vS5CdiZM2ciPj4e/fv3R82aNXH79m1888032LlzJ8LDw1GxYsVSj/VVtnv3bqxYsYKJWyqSffv2vXDbI0eOQKPR4KuvvoKbm1sJRkX05mDSlug1oNFokJmZCVNT0yK3KU9JyKJKTU2FQqEo030aGhrC0NCwTPdZmIoVK+LKlSvw9PQUy8aMGYN3330Xa9euxezZs8ULo/r162vNjpk4cSJ69OiBr7/+GoGBgeLx6UqwL1iwAAAwZMgQsWz16tW4efMmDh48CF9fXwDAuHHj0Lx5c0ydOhX9+vWDiYlJSR5yuaSP81GfSvt4TUxMcPLkSbRo0UIsGz16NFxdXcXEbYcOHQAA6enp+OSTT9CtWzds2bJFrKvRaBAYGIj33nsPNjY2pRYrEdHr4p133pE8P3PmDPbv369VXhaOHj0qzrK1sLAosF5ISAhatWolmXzQuXNn+Pj44JtvvhGvXfQpOzsbGo3mjbgeAgBBEJCRkQEzMzN9h0Il7GXO4cePHwNAqUxAInpTcHkEonJo7ty5mD59OgCgWrVq4lfTctdVlclkmDhxIkJDQ+Hp6Qm5XI49e/YAABYvXowWLVqgQoUKMDMzg5eXl5jUyEvXmrYJCQn44IMP4OzsDLlcDjc3NyxatAgajUZSL/cvpvXq1YOpqSns7e3RuXNnXLhwQYwvNTUV69evF2PPu68///wTXbp0gZWVFSwsLNC+fXucOXNGso/ctWSPHj2K8ePHw8HBAVWqVMHhw4chk8mwbds2rWPauHEjZDIZTp8+XeSxXr58OTw9PWFubg4bGxs0adIEGzdu1Iojd+xz17vS9ch7jBqNBsuWLYOnpydMTU3h6OiIMWPG4NmzZ0WOrSB2dnaShG2u3r17AwAiIyML7cPV1RVpaWnIzMx8br2NGzeiWrVqkkTa8ePHYW9vLyZsAcDAwAADBgzAo0ePcPTo0aIeiih37a7Fixfju+++Q40aNSCXy/HWW2/h/PnzxerryJEjkMlk2LRpEz7++GNUrFgRCoUCPXv2xL179yR1jx8/Ln4VUy6Xw9nZGR9++CHS09Ml9YYPHw4LCwvcunULXbt2haWlpZjILm4fd+/eRffu3WFhYYHKlStjxYoVAIArV67A19cXCoUCLi4ukvMwV2Gv0Tt37sDe3h4AMG/ePPHczDub5tq1a+jXrx9sbW1hamqKJk2a4LfffpPsp6DXHwAkJyfjgw8+gKurK+RyORwcHNCxY0dcunSpWD+n/ExMTCTnWS5d5/Xhw4fx9OlTjB8/XlJ3woQJSE1Nxa5du14qFiIi+k9qaiqmTp0q/u6pXbs2Fi9erLXMUt7r09q1a8PU1BReXl44duxYkfbj4uJSpDVF27Rpo/VtsTZt2sDW1rZI10Bt27ZF3bp1cfHiRbRo0QJmZmaoVq0aVq1aJamXmZmJOXPmwMvLC0qlEgqFAq1bt8bhw4cl9fJewyxbtky8homIiHihPlasWIHq1avD3NwcnTp1wr179yAIAgIDA1GlShWYmZnh7bffRnx8vNax/fHHH2jdujUUCgUsLS3RrVs3XL16Vdw+fPhw8boj7zVsrqJev+au4bp37140adIEZmZmWL16NQBg//79aNWqFaytrWFhYYHatWvj448/LvTnUlqePn2KoUOHwsrKCtbW1hg2bBguX75cpDVjs7OzERgYKP5MXV1d8fHHH0OlUumsv2/fPjRs2BCmpqbw8PBAWFiYZHt8fDymTZuGevXqwcLCAlZWVujSpQsuX778QseWlZWFefPmoWbNmjA1NUWFChXQqlUr7N+/X1Jv+/btqFu3LkxNTVG3bl1s27YNw4cPh6ura6H7yL/+bO519q+//oqgoCBUqVIFpqamaN++PW7evCnWy/2jOwDY29trXY/mVdA9RHL3lX8CytmzZ9G5c2colUqYm5vDx8cHJ0+elNTJ/cx28+ZN8ZurSqUSI0aMQFpamlYMGzZsQNOmTcXPhG3atNGaZVzY64uoNHCmLVE51KdPH9y4cQM///wzli5dCjs7OwAQkzEAcOjQIfz666+YOHEi7OzsxF+6X331FXr27IkhQ4YgMzMTv/zyC/r374+dO3eiW7duBe4zLS0NPj4+uH//PsaMGYOqVavi1KlTmDVrFh4+fIhly5aJdUeOHIl169ahS5cuGDVqFLKzs3H8+HGcOXMGTZo0wU8//YRRo0ahadOmeO+99wAANWrUAABcvXoVrVu3hpWVFWbMmAFjY2OsXr0abdu2xdGjR9GsWTNJXOPHj4e9vT3mzJmD1NRUtG3bFs7OzggNDRWTOblCQ0NRo0YNeHt7F2mc16xZg0mTJqFfv36YPHkyMjIy8Ndff+Hs2bMFfsW/T58+Wl/vuXjxIpYtWwYHBwexbMyYMVi3bh1GjBiBSZMmITo6Gt988w3+/PNPnDx5EsbGxgCAlJSUAtfrzMvY2BhKpfK5dR49egQA4vmSV3p6OlJTU5GSkoKjR49i7dq18Pb2fu6MiD///BORkZH45JNPJOUqlUpnO3NzcwA549GxY8dCj0mXjRs3Ijk5GWPGjIFMJsMXX3yBPn364Pbt2+KYFVVQUBBkMhlmzpyJx48fY9myZejQoQPCw8PF+Ddv3oy0tDSMGzcOFSpUwLlz57B8+XL8888/Wmv0Zmdnw8/PD61atcLixYvF4y1OH2q1Gl26dEGbNm3wxRdfIDQ0FBMnToRCocAnn3yCIUOGoE+fPli1ahUCAgLg7e2NatWqASjaa9Te3h4rV67EuHHj0Lt3b/Tp0wdAzoxrIOf117JlS1SuXBkfffQRFAoFfv31V/Tq1Qtbt27Vek3lf/0BwNixY7FlyxZMnDgRHh4eePr0KU6cOIHIyEg0btxYjFXXBXF+hoaGhc6I1XVe//nnnwCAJk2aSOp6eXnBwMAAf/75p15miRERvW4EQUDPnj1x+PBhjBw5Eg0bNsTevXsxffp03L9/H0uXLpXUP3r0KDZt2oRJkyZBLpfj22+/RefOnXHu3DnUrVu31OJMSUlBSkqKzmsgXZ49e4auXbtiwIABGDRoEH799VeMGzcOJiYmePfddwHkLAf1/fffY9CgQRg9ejSSk5Pxv//9D35+fjh37hwaNmwo6XPt2rXIyMjAe++9B7lcDltb22L3ERoaiszMTLz//vuIj4/HF198gQEDBsDX1xdHjhzBzJkzcfPmTSxfvhzTpk3DDz/8ILb96aefMGzYMPj5+WHRokVIS0vDypUr0apVK/z5559wdXXFmDFj8ODBA51LYABFv34FcpZaGzRoEMaMGYPRo0ejdu3auHr1Krp374769etj/vz5kMvluHnzplZCraxoNBr06NED586dw7hx4+Du7o4dO3Zg2LBhRWo/atQorF+/Hv369cPUqVNx9uxZBAcHIzIyUmsCSVRUFPz9/TF27FgMGzYMa9euRf/+/bFnzx7xuvj27dvYvn07+vfvj2rVqiE2NharV6+Gj48PIiIiUKlSpWId39y5cxEcHCx+7kpKSsKFCxdw6dIlcZ/79u1D37594eHhgeDgYDx9+hQjRowQ/xj/oj7//HMYGBhg2rRpSExMxBdffIEhQ4bg7NmzAHKWXfvxxx+xbds2rFy5EhYWFuL16Ms4dOgQunTpAi8vL3z22WcwMDDA2rVr4evri+PHj6Np06aS+gMGDEC1atUQHByMS5cu4fvvv4eDgwMWLVok1pk3bx7mzp2LFi1aYP78+TAxMcHZs2dx6NAhcYm4ory+iEqFQETl0pdffikAEKKjo7W2ARAMDAyEq1evam1LS0uTPM/MzBTq1q0r+Pr6SspdXFyEYcOGic8DAwMFhUIh3LhxQ1Lvo48+EgwNDYW7d+8KgiAIhw4dEgAIkyZN0tq3RqMR/69QKCT95+rVq5dgYmIi3Lp1Syx78OCBYGlpKbRp00YsW7t2rQBAaNWqlZCdnS3pY9asWYJcLhcSEhLEssePHwtGRkbCZ599prXPgrz99tuCp6fnc+vkxqHr5yAIgvDkyROhatWqQr169YSUlBRBEATh+PHjAgAhNDRUUnfPnj1a5cOGDRMAFPrw8fF5bpwqlUrw8PAQqlWrJmRlZWltDw4OlvTXvn178WdakKlTpwoAhIiICEn5+++/LxgYGAh37tyRlA8cOFAAIEycOPG5/eoSHR0tABAqVKggxMfHi+U7duwQAAi///57kfs6fPiwAECoXLmykJSUJJb/+uuvAgDhq6++Esvyv14EIWesZDKZEBMTI5bl/pw++ugjrfrF7WPhwoVi2bNnzwQzMzNBJpMJv/zyi1h+7do1AYDkfC7qa/TJkydabXO1b99eqFevnpCRkSGWaTQaoUWLFkLNmjXFsue9/pRKpTBhwgStvvP67LPPinReu7i4PLcfQRCEDh06CFZWVsKzZ8/EsgkTJgiGhoY669vb2wsDBw4stF8iItI2YcIEIe9HxO3btwsAhAULFkjq9evXT5DJZMLNmzfFstz39gsXLohlMTExgqmpqdC7d+9ixVHQdWRBAgMDBQDCwYMHC63r4+MjABCWLFkilqlUKqFhw4aCg4ODkJmZKQiCIGRnZwsqlUrS9tmzZ4Kjo6Pw7rvvimW51zBWVlbC48ePJfWL24e9vb3k+nbWrFkCAKFBgwaS67tBgwYJJiYm4u/z5ORkwdraWhg9erRkX48ePRKUSqWkPP/POFdxrl9dXFwEAMKePXskdZcuXSoAEJ48eaLVvz5s3bpVACAsW7ZMLFOr1YKvr68AQFi7dq1Ynnvtkis8PFwAIIwaNUrS57Rp0wQAwqFDh8Sy3PHYunWrWJaYmCg4OTkJjRo1EssyMjIEtVot6S86OlqQy+XC/PnzJWX549OlQYMGQrdu3Z5bp2HDhoKTk5PkvNq3b1+Rr8N8fHwkn0Nyr7Pr1KkjObe/+uorAYBw5coVsSx3TPOfD/n7LOjzVu6+Dh8+LAhCzjVrzZo1BT8/P8nnzrS0NKFatWpCx44dtfad93UmCILQu3dvoUKFCuLzqKgowcDAQOjdu7fWzyZ3H8V5fRGVNC6PQPSK8vHxgYeHh1Z53hmQz549Q2JiIlq3bl3oV5c3b96M1q1bw8bGBnFxceKjQ4cOUKvV4lfbtm7dCplMJn7dJa/CvtKmVquxb98+9OrVC9WrVxfLnZycMHjwYJw4cQJJSUmSNqNHj9ZaUzYgIAAqlUqy7MOmTZuQnZ1drNl11tbW+Oeff4r99fu8xzNo0CAkJydj27Zt4nqfmzdvhlKpRMeOHSVj6eXlBQsLC8lX4mbMmIH9+/cX+liyZMlzY5k4cSIiIiLwzTffwMhI+0sUgwYNwv79+7Fx40ZxFnH+r+/npdFo8Msvv6BRo0ZaNx8ZNWoUDA0NMWDAAJw6dQq3bt1CcHCwOOPgef0Wxt/fXzLzsnXr1gByZiYUV0BAACwtLcXn/fr1g5OTE3bv3i2W5X29pKamIi4uDi1atIAgCOJszrzGjRunVVbcPkaNGiX+39raGrVr14ZCocCAAQPE8tq1a8Pa2lpy3EV9jRYkPj4ehw4dwoABA5CcnCy2f/r0Kfz8/BAVFYX79+9L2uh6/VlbW+Ps2bN48OBBgfsKCAgo0nkdGhr63JgXLlyIAwcO4PPPP5esh5aenl7gGmumpqYvdQ4SEdF/du/eDUNDQ0yaNElSPnXqVAiCgD/++ENS7u3tDS8vL/F51apV8fbbb2Pv3r1Qq9WlEuOxY8cwb948cUZqURgZGWHMmDHicxMTE4wZMwaPHz/GxYsXAeR8GyT3d41Go0F8fDyys7PRpEkTndfVffv2lXwr7kX66N+/v+SbVbnfQHvnnXck13fNmjVDZmam+Ht7//79SEhIwKBBgyTXCIaGhmjWrJnWcgy6FOf6FchZws3Pz09Slvu7eseOHVrLq+nDnj17YGxsjNGjR4tlBgYGmDBhQqFtc68Xp0yZIimfOnUqAGgtxVSpUiXJN5asrKwQEBCAP//8U/zWkFwuF5f2UKvVePr0qbiExIssM2VtbY2rV68iKipK5/aHDx8iPDwcw4YNk5xXHTt21Pk5sjhGjBghuRZ7mWv2ogoPD0dUVBQGDx6Mp0+fiudoamoq2rdvj2PHjmmdd2PHjpU8b926NZ4+fSp+5ty+fTs0Gg3mzJmjtexK7mfbknh9Eb0oLo9A9IrK/cp0fjt37sSCBQsQHh4uWW+psIRqVFQU/vrrL62LzVy5C8nfunULlSpVgq2tbbFjfvLkCdLS0lC7dm2tbXXq1IFGo8G9e/ck67XqOk53d3e89dZbCA0NxciRIwHkfJ2sefPmxboz6cyZM3HgwAE0bdoUbm5u6NSpEwYPHoyWLVsWqf2nn36KQ4cOYdeuXeLyD0DOWCYmJkqWS8grdywBwMPD46Uvmr788kusWbMGgYGB6Nq1q846Li4ucHFxAZCTwH3vvffQoUMHXL9+XedSB0ePHsX9+/fx4Ycfam2rX78+Nm7ciLFjx4pjVbFiRSxbtgzjxo177s1DClO1alXJ89wE7ousBVyzZk3Jc5lMBjc3N8l6WXfv3sWcOXPw22+/ae0jMTFR8tzIyEjnV8mK00fuGtB5KZVKVKlSRes1qlQqJf0V9TVakJs3b0IQBMyePRuzZ88usI/KlSuLz3W9/r744gsMGzYMzs7O8PLyQteuXREQECD5Q0z16tUlz1/Epk2b8Omnn2LkyJFayXIzM7MC12PmjVCIiEpOTEwMKlWqJPkjKADxD7oxMTGS8vy/ewGgVq1aSEtLw5MnT1CxYsUSje/atWvo3bs36tati++//77I7SpVqqR1c81atWoByFlftnnz5gCA9evXY8mSJbh27RqysrLEurp+PxZ0bV6cPvJfB+Um2pydnXWW514n5CbtCkpaW1lZ6SzPqzjXr4Du+P39/fH9999j1KhR+Oijj9C+fXv06dMH/fr100qI5RUfH1/ofRYKYmtrW+AfcmNiYuDk5CQuaZWrKJ8XYmJiYGBgoFW3YsWKsLa21jr33dzctK7l8p5TFStWFO8L8u233yI6Olryh4wKFSoUGlN+8+fPx9tvv41atWqhbt266Ny5M4YOHSouQ5Abo67X5YsminOV5DV7UeWe589b3iIxMVEyAeR5cVpZWeHWrVswMDB47uexknh9Eb0oJm2JXlG6khLHjx9Hz5490aZNG3z77bdwcnKCsbEx1q5dq/OmRnlpNBp07NgRM2bM0Lk996KjrBWUfAkICMDkyZPxzz//QKVS4cyZM/jmm2+K1XedOnVw/fp17Ny5E3v27MHWrVvx7bffYs6cOZg3b95z227fvh2LFi1CYGAgOnfuLNmm0Wjg4OBQ4CzCvEm3xMTEIs0KNDEx0ZkoX7duHWbOnImxY8fi008/LbSfXP369cOaNWtw7NgxrVkSQE4S3MDAAIMGDSqwfc+ePXH58mWo1Wo0btxYvEnAy5wr+Wd15hLy3eykJKjVanTs2BHx8fGYOXMm3N3doVAocP/+fQwfPlzrL/V5Z0e8aB8FHV9RjvtlX6O5sUybNk3nzxzQ/hCj6/U3YMAAtG7dGtu2bcO+ffvw5ZdfYtGiRQgLC0OXLl0A/Le2YGEMDQ11JqH379+PgIAAdOvWTevGMEDO7Hy1Wo3Hjx9LPlxmZmbi6dOnxV4TjoiIXj337t1Dp06doFQqsXv3bq3E8svasGEDhg8fjl69emH69OlwcHCAoaEhgoODcevWLa36un5nFrePF71OyP0d/9NPP+lMjOv6FlZ+xbl+BXQfr5mZGY4dO4bDhw9j165d2LNnDzZt2gRfX1/s27evwOPo06fPC93IFsi5OWneG2WVtKLcHK+oFi5ciNmzZ+Pdd99FYGAgbG1tYWBggA8++OCFZia3adMGt27dwo4dO7Bv3z58//33WLp0KVatWiX5ZldpKMlr9oLGOP/s/Nwx+vLLL7XWg86Vf/JIScRZEq8vohfFs4uonHqRC4StW7fC1NQUe/fuhVwuF8vXrl1baNsaNWogJSUFHTp0KLTe3r17ER8f/9zZtrrit7e3h7m5Oa5fv6617dq1azAwMNCaSVCQgQMHYsqUKfj555+Rnp4OY2Nj+Pv7F6ltXgqFAv7+/vD390dmZib69OmDoKAgzJo1C6ampjrb3LhxA8OGDUOvXr103g23Ro0aOHDgAFq2bFnojL/Jkydj/fr1hcbp4+OjdefUHTt2YNSoUejTp494J+Ciyk0U558JCuTcaGzr1q1o27btc5NfJiYmeOutt8TnBw4cAIBCz6Gykv+rYoIg4ObNm+LsgytXruDGjRtYv349AgICxHr577j7PCXRR1EV9TVa0HtH7sxXY2Pjl/4ZOTk5Yfz48Rg/fjweP36Mxo0bIygoSEzaLl68uNA/fAA5M8Dz3yn47Nmz6N27N5o0aYJff/1V54Vw7oX6hQsXJLPLL1y4AI1GU+CFPBERFY+LiwsOHDiA5ORkSVL02rVr4va8dH1N+8aNGzA3Ny/wmyIv4unTp+jUqRNUKhUOHjwIJyenYrV/8OABUlNTJbNtb9y4AQDiDYW2bNmC6tWrIywsTPK7VdcSYQUpiT6KIvcbXw4ODi98nVCc69fnMTAwQPv27dG+fXuEhIRg4cKF+OSTT3D48OECY1uyZMkLz9Bs0KBBgdtcXFxw+PBhpKWlSWbb3rx5s9B+XVxcoNFoEBUVJVkqLDY2FgkJCVrnfu43mvKOr65zql27dvjf//4naZuQkFDkm+jlZ2trixEjRmDEiBFISUlBmzZtMHfuXIwaNUqMUdfrUtfnMX3Jnf2akJAgKc8/mzn3PLeysiqxzxs1atSARqNBREREgdePxXl9EZU0rmlLVE7lXkTm/+X1PIaGhpDJZJK/St65cwfbt28vtO2AAQNw+vRp7N27V2tbQkICsrOzAeSs1yUIgs6ETN6/WCoUCq3YDQ0N0alTJ+zYsUOSqImNjcXGjRvRqlWrIn+9xM7ODl26dMGGDRsQGhqKzp07F/ti5+nTp5LnJiYm8PDwgCAIkq+v5ZWSkoLevXujcuXKWL9+vc4L3wEDBkCtViMwMFBrW3Z2tmRcXnRN22PHjmHgwIFo06aNOCtWlydPnugs/9///geZTIbGjRtrbdu9ezcSEhIwZMgQnW11iYqKwqpVq9C9e3e9zcrO78cff0RycrL4fMuWLXj48KGYWMz9y3ve81YQBHz11VdF3kdJ9FFURX2N5n4oyf/6c3BwQNu2bbF69Wo8fPhQq4+CzpW81Gq1VqLfwcEBlSpVkizH8qJr2kZGRqJbt25wdXXFzp07C/zQ6OvrC1tbW6xcuVJSvnLlSpibm6Nbt26FHgsRERWua9euUKvVWt9mWrp0KWQymfg7Ndfp06clX7m+d+8eduzYgU6dOhU44624UlNT0bVrV9y/fx+7d+/W+dXvwmRnZ2P16tXi88zMTKxevRr29vbimry6fsefPXsWp0+fLvJ+SqKPovDz84OVlRUWLlyo8xo27+/4gj5jFOf6tSDx8fFaZbmJsLzXCfl5eXmhQ4cOL/TI+1X4/Pz8/JCVlYU1a9aIZRqNpkiTHXL/KLxs2TJJeUhICABoXWs8ePBAvL8DACQlJeHHH39Ew4YNxdmZhoaGWjM8N2/erHVPgaLK/1nGwsICbm5u4lg7OTmhYcOGWL9+veT6bf/+/YiIiHihfZaG3KRo3vszqNVqfPfdd5J6Xl5eqFGjBhYvXqzzG11FuZbNr1evXjAwMMD8+fO1Zjvn/qyK8/oiKmmcaUtUTuVeMH7yyScYOHAgjI2N0aNHD631t/Lq1q0bQkJC0LlzZwwePBiPHz/GihUr4Obmhr/++uu5+5s+fTp+++03dO/eHcOHD4eXlxdSU1Nx5coVbNmyBXfu3IGdnR3atWuHoUOH4uuvv0ZUVBQ6d+4MjUaD48ePo127dpg4caIY/4EDBxASEoJKlSqhWrVqaNasGRYsWID9+/ejVatWGD9+PIyMjLB69WqoVCp88cUXxRqjgIAA9OvXDwB0XmAWplOnTqhYsSJatmwJR0dHREZG4ptvvkG3bt0K/IrdvHnzEBERgU8//RQ7duyQbKtRowa8vb3h4+ODMWPGIDg4GOHh4ejUqROMjY0RFRWFzZs346uvvhLjfpE1bWNiYtCzZ0/IZDL069cPmzdvlmyvX7++OJs0KCgIJ0+eROfOnVG1alXEx8dj69atOH/+PN5//32da3qFhoZCLpejb9++Bcbg4eGB/v37o2rVqoiOjsbKlStha2ur9VX2I0eOoF27dvjss88wd+7cYh3ny7K1tUWrVq0wYsQIxMbGYtmyZXBzcxNvRuHu7o4aNWpg2rRpuH//PqysrLB169ZizfQoiT6KqqivUTMzM3h4eGDTpk2oVasWbG1tUbduXdStWxcrVqxAq1atUK9ePYwePRrVq1dHbGwsTp8+jX/++QeXL19+bgzJycmoUqUK+vXrhwYNGsDCwgIHDhzA+fPnJX9YeJE1bZOTk+Hn54dnz55h+vTpWjf4yH19ATlfvwwMDMSECRPQv39/+Pn54fjx49iwYQOCgoJeaM1tIiLS1qNHD7Rr1w6ffPIJ7ty5gwYNGmDfvn3YsWMHPvjgA8ma/gBQt25d+Pn5YdKkSZDL5fj2228BoEjfvvj999/F30NZWVn466+/sGDBAgBAz549xWubIUOG4Ny5c3j33XcRGRmJyMhIsQ8LCwv06tWr0H1VqlQJixYtwp07d1CrVi1s2rQJ4eHh+O6772BsbAwA6N69O8LCwtC7d29069YN0dHRWLVqFTw8PIq0BFBJ9VEUVlZWWLlyJYYOHYrGjRtj4MCBsLe3x927d7Fr1y60bNlSTLznfsaYNGkS/Pz8YGhoiIEDBxbr+rUg8+fPx7Fjx9CtWze4uLjg8ePH+Pbbb1GlShW0atWqxI63qHr16oWmTZti6tSpuHnzJtzd3fHbb7+JyeXnfbOxQYMGGDZsGL777jskJCTAx8cH586dw/r169GrVy+0a9dOUr9WrVoYOXIkzp8/D0dHR/zwww+IjY2VfOOxe/fumD9/PkaMGIEWLVrgypUrCA0NfeH7AHh4eKBt27bw8vKCra0tLly4gC1btoifxwAgODgY3bp1Q6tWrfDuu+8iPj4ey5cvh6enZ4megy/D09MTzZs3x6xZs8Rvc/7yyy/ihIRcBgYG+P7779GlSxd4enpixIgRqFy5Mu7fv4/Dhw/DysoKv//+e7H27ebmhk8++QSBgYFo3bo1+vTpA7lcjvPnz6NSpUoIDg4u1uuLqMQJRFRuBQYGCpUrVxYMDAwEAEJ0dLQgCIIAQJgwYYLONv/73/+EmjVrCnK5XHB3dxfWrl0rfPbZZ0L+l7uLi4swbNgwSVlycrIwa9Yswc3NTTAxMRHs7OyEFi1aCIsXLxYyMzPFetnZ2cKXX34puLu7CyYmJoK9vb3QpUsX4eLFi2Kda9euCW3atBHMzMwEAJJ9Xbp0SfDz8xMsLCwEc3NzoV27dsKpU6cksaxdu1YAIJw/f77A8VGpVIKNjY2gVCqF9PT05w2lTqtXrxbatGkjVKhQQZDL5UKNGjWE6dOnC4mJiVpx5I79sGHDBAA6H/nH87vvvhO8vLwEMzMzwdLSUqhXr54wY8YM4cGDB8WONa/Dhw8XGAMA4bPPPhPr7tu3T+jevbtQqVIlwdjYWLC0tBRatmwprF27VtBoNFp9JyYmCqampkKfPn2eG8PAgQMFZ2dnwcTERKhUqZIwduxYITY2Vqve77//LgAQVq1a9dz+oqOjBQDCl19+qbUt/zEVJnd8fv75Z2HWrFmCg4ODYGZmJnTr1k2IiYmR1I2IiBA6dOggWFhYCHZ2dsLo0aOFy5cvCwCEtWvXivWGDRsmKBQKnft72T58fHwET09PrXIXFxehW7dukrKivkZPnToleHl5CSYmJlrjd+vWLSEgIECoWLGiYGxsLFSuXFno3r27sGXLFrFOQa8/lUolTJ8+XWjQoIFgaWkpKBQKoUGDBsK3336rc2yKI/ccKOrrSxByXmO1a9cWTExMhBo1aghLly7VeV4TEVHRTJgwQeuaMTk5Wfjwww/Fa4maNWsKX375pdb7be716YYNG8Rr0UaNGgmHDx8u0r6fd42V9/epi4tLgfVcXFwK3U/u790LFy4I3t7egqmpqeDi4iJ88803knoajUZYuHCh4OLiIh7Lzp07hWHDhkn287xrmJftI/eaZvPmzZLygn5PHz58WPDz8xOUSqVgamoq1KhRQxg+fLhw4cIFsU52drbw/vvvC/b29oJMJtP6eRfl+lXXNYogCMLBgweFt99+W6hUqZJ4jTho0CDhxo0bWnXLypMnT4TBgwcLlpaWglKpFIYPHy6cPHlSACD88ssvYj1dn5eysrKEefPmCdWqVROMjY0FZ2dnYdasWUJGRoakXu547N27V6hfv774OSz/zy0jI0OYOnWq4OTkJJiZmQktW7YUTp8+Lfj4+Ag+Pj5ivdzzIe95r8uCBQuEpk2bCtbW1oKZmZng7u4uBAUFSa4JBUEQtm7dKtSpU0eQy+WCh4eHEBYWpnUOFiR/bAWdk7pizh3TJ0+ePLdPQci5Pu3QoYMgl8sFR0dH4eOPPxb2798vANB6D/nzzz+FPn36iJ/hXFxchAEDBggHDx4sdN/5P9vl+uGHH4RGjRoJcrlcsLGxEXx8fIT9+/dL6hTl9UVU0mSCUAp3dyGics/Z2Rl+fn7FutNueZOdnY1KlSqhR48eWmtDUfkwY8YM/Pzzz7h586ZkneXSlDu7d/PmzYXOCCEiIqKSIZPJMGHChHI/46xt27aIi4vD33//re9QSE+2b9+O3r1748SJE2jZsqW+w9GL4cOH48iRI1r3FiCi8oVr2hK9gbKysvD06dMXXvC+vNi+fTuePHkiuQEUlS+HDx/G7NmzyyxhS0RERESUK/fmu7nUajWWL18OKysrnfd2ICIqT7imLdEbZu/evfjll1+Qnp6O9u3b6zucF3L27Fn89ddfCAwMRKNGjeDj4yPZnpmZqfNGCHkplcqXujMuFc358+dLrK+i/lyJiIiIiADg/fffR3p6Ory9vaFSqRAWFoZTp05h4cKF/CxAROUek7ZEb5jPP/8cN2/eRFBQEDp27KjvcF7IypUrsWHDBjRs2BDr1q3T2n7q1CmtmwPkt3btWgwfPrx0AqRSUdSfq6ura9kERERERETlmq+vL5YsWYKdO3ciIyMDbm5uWL58ueRmXURE5RXXtCWi186zZ89w8eLF59bx9PSEk5NTGUVEJYE/VyIiIiIiInpTMGlLREREREREREREVI7wRmRERERERERERERE5QjXtC1FGo0GDx48gKWlJWQymb7DISIiIqICCIKA5ORkVKpUCQYGr9a8Bl5zEhEREb06inrdyaRtKXrw4AGcnZ31HQYRERERFdG9e/dQpUoVfYdRLLzmJCIiInr1FHbdyaRtKbK0tASQ80OwsrLSczREREREVJCkpCQ4OzuL12+vEl5zEhEREb06inrdyaRtKcr9epqVlRUvoImIiIheAa/i8gK85iQiIiJ69RR23flqLdhFRERERERERERE9Jpj0paIiIiIiIiIiIioHGHSloiIiIiIiIiIiKgcYdKWiIiIiIiIiIiIqBxh0paIiIiIiIiIiIioHGHSloiIiIiIiIiIiKgcYdKWiIiIiIiIiIiIqBxh0paIiIiIiIiIiIioHGHSloiIiIiIiIiIiKgcYdK2DMTHx4v/f/bsGVJSUgAAarUacXFxyMrKAgCkp6fj6dOnYt2EhAQkJycDADQaDeLi4pCZmSnWjYuLE+smJiaKdQVBQFxcHFQqFQAgIyMDcXFxEAQBAJCUlISkpCRJ3YyMDACASqWS1E1OTkZiYqK4n7i4OKSnpwMAMjMzERcXB41GI9ZNSEgQ6z59+lSsm5WVhbi4OKjVagBASkoKnj17JhmjtLQ0Sd3s7GwAQGpqqqTus2fPkJqaCgDIzs6WjGFaWppkDHWNd94xLGy8c8dQ13jnH8PcuvnHMCkpSWsM84933jHMWzfvGOaOd94xzD/e+ccwt27+MYyPj9caw7zjnf+cza2b/5zNP94JCQlFHu+852z+8c49Z0tqvHPHUNd4F3TO6hrvvGOoa7xf9JzlewTfI/gewfcIvkeUj/cIIiIiIqLygknbMrB//37x/wcPHsTly5cB5HzgCAsLw5MnTwAAN27cwM6dO8W6R48exaVLlwDkfGAKCwvDo0ePAAC3b9/Gjh07xLonTpzAuXPnAOR8WAkLC8P9+/cBADExMQgLCxM/QJ0+fRqnT58GkPNhKywsDDExMQCA+/fvIywsTPzwcu7cOZw4cULcz44dO3D79m0AwKNHjxAWFiZ+ULt06RKOHj0q1t25cydu3LgBAHjy5AnCwsLED5qXL1/GwYMHxbp//PEHIiMjAeR8yAwLCxM/5F29ehV79+4V6+7btw9XrlwBkPMBLywsTPxAe+3aNfzxxx9i3cOHDyM8PBxAzgffvOMdFRWF3377TTLeFy9eBJDzoTPveN+5cwfbtm0T6548eRJnz54FkPOBLywsDPfu3QMA3L17F2FhYeKH0DNnzuDUqVNi27CwMNy5cwcA8ODBA8l4nz9/HseOHZOM961btwAAsbGxkvH+888/cfjwYbHurl27cP36dQA5H3TDwsLED+B//fUXDhw4INbdu3cvIiIiJOOd+0E5IiJCMt4HDhzAX3/9JRnv3KTA9evXsWvXLsl4//nnnwD+O2djY2MBALdu3ZKcs8eOHcP58+cB/HfOPnjwQBzvsLAwse6pU6dw5swZADmJh7CwMNy9excAcO/ePYSFhYkfzs+ePYuTJ0+Kbbdt2yaOd+45m5uIuHjxouSc/e233xAVFQXgv3M2NwkQHh4uGe8//vgD165dA5CTLMg73leuXMG+ffsk43316lUAOYmRvOMdGRkpOWf5HsH3CL5H5OB7RM548z2ibN8jiIiIiIjKC5mQewVOJS4pKQlKpRLR0dFwdXUFkDO7w9jYGBYWFlCr1Xj27BmUSiWMjY2Rnp6OtLQ0VKhQAUDOhw5DQ0NYWlpCo9EgPj4eVlZWMDExQXp6OlJTU2FnZwcg50OegYEBLC0tIQgCnj59CktLS8jlcmRkZCAlJQUVKlSATCYTZ8dYWVmJdS0sLGBqagqVSoXk5GSxbnJyMjQaDZRKJYCcGTIKhQJmZmbIzMxEUlISbG1tYWBggOTkZKjValhbWwPISQqYm5vDzMwMWVlZSExMhI2NDQwNDZGSkoKsrCzY2NgAyPlAa2pqCnNzc7GutbU1jIyMkJqaiszMTLHus2fPYGJiAoVCgezsbCQkJIhjmJaWhvT0dHEMdY133jEsbLxzx1DXeMtkMskY5tbNP4ZJSUkQBEEyhvnHO+8Y5h3vvGOYO955xzA7O1sy3mZmZpIxzK2bfwzj4+Mhl8slY5h3vFUqFWxtbbXGO/85m3+8ExISYGRkVKTxznvO5h/v3HO2pMY795zVNd4FnbO6xjvvOatrvF/0nM3IyJCMN98j+B7B94j/zlkLc3OknL+AuH/uQenkBJvmzaHKyuJ7BN8jSvw9Ij09HUqlEomJibCyssKrJPea81WMnYiIiOhNU9RrNyZtSxEvoImIiF5c0r59iF0YjOx/Z4cCgFHFinD8eBasOnXSY2T0OnqVr9te5diJiIiI3jRFvXbj8ghERERU7iTt24f7kz+QJGwBIDs2Fvcnf4CkPMsLEBERERERvW6YtCUiIqJyRVCrEbswGND1ZaB/y2IXBkP496ZURERERERErxsjfQdAREREBOTc1Cr70SMkbN+uNcM2X0VkP3qEtAsXoWjWtOwCJCrnun99HEamCn2HQURERPTKOTStrb5D0MKkLREREZU5QRCQde8eMiIikHE1IuffiAionz0rch/ZT56UYoRERERERET6w6QtERERlSpBrUZmTIwkOZsREQFNcvJL9Wtkb19CERIREREREZUvTNoSERFRiRGysqC6fVuaoL12DUJaWqFtDW1sYOrpCbm7OxK2bIEmIUF3RZkMRo6OMG/iVbLBExERERERlRNM2hIREdEL0ahUUN2IksyeVV2/DiEzs9C2Ro6OMPXwyHl45vxr5OgImUwGADCrXw/3J3+QUznvDcn+3e748SzIDA1L+pCIiIiIiIjKBSZtiYiIqFCatDRkXL8umUGrunkTyM4utK1x5cr/JWc9PWFapw6M7Oye28aqUyfgq2WIXRgsuSmZkaMjHD+elbOdiIiIiIjoNcWkLREREUmok5ORERkpmUGbeTsa0GgKbWvi6iqZPWtapw4Mra1fKA6rTp1g2b490i5cRPaTJzCyt4d5Ey/OsCUiIiIiotcek7ZERERvsOxnzyTJ2YyICGTF3C28oYEB5DVqSBK0cnd3GFpYlGh8MkNDKJo1LdE+iYiIiIiIyjsmbYmIiN4Q2U+eICMiAulXr4oJ2uwHDwtvaGwM05o1/5s96+EBea1aMDAzK/2giV4zgiBg6dKlWL58OWJjY9GpUyesX78eSqVS36ERERERUTnCpC0REdFrRhAEZD98+N/s2X/Xoc1+8qTQtjK5HHL32v/dJMzDA/KaNWFgYlIGkRO9/qZPn44dO3Zg/fr1UCgU6NWrF+bOnYulS5fqOzQiIiIiKkeYtCUiInqFCRoNsu7d00rQqhMSCm1rYG4OuUcdaYK2enXIjHh5QFQazp49i5CQEFy4cAGNGzcGAIwePRqhoaFM2hIRERGRBD+VERERvSIEtRqZd+7kJGf//neJg8hIaFJSCm1roFTCNF+C1sTFBTIDgzKInIgAYPHixWjfvr2YsAUAR0dHxMXF6TEqIiIiIiqPmLQlIiIqh4SsLKhu3RJnzmZERCDj2jUI6emFtjW0tYWpp+d/CVpPDxhXrgyZTFYGkRORLiqVCrt27cLixYsl5RkZGcVez1alUkGlUonPk5KSSiRGIiIiIio/mLQlIiLSM41KBdWNG5IErer6dQhZWYW2NapYUTJ71tTTA0YODkzQEpUzly5dQnp6OqZOnYoZM2aI5VlZWWjXrh0AoHfv3jhy5Ajat2+PLVu2FNhXcHAw5s2bV+oxExEREZH+MGlLRERUhjSpqci4fl2aoL15E1CrC21r7OwsTdB61IFRhQplEDURvawbN25AoVAgPDxcUt6tWze0bNkSADB58mS8++67WL9+/XP7mjVrFqZMmSI+T0pKgrOzc4nHTERERET6w6RtGXj69CkyMzPF53K5HJaWllCr1Xj27JlWfTs7OwBAQkICsrOzJdssLS0hl8uRnp6O1NRUyTZjY2MolUoIgoCnT59q9WtrawsDAwMkJSVJ4gEAhUIBMzMzqFQqJCcnS7YZGhrCxsYGAHSuuWZtbQ0jIyMkJydLvqoHAGZmZlAoFMjKykJiYqJkm4GBAWxtbQEA8fHx0Gg0ku1KpRLGxsZITU1Fer6vA+eOYXZ2NhJ03GwndwyfPXsGdb5EyPPG0MTEBFZWVtBoNIiPj9fqt0KFCpDJZEhMTERWvhlwzxtDIyMjWFtbA9A9hjY2NjA0NNQ5hubm5jA3N0dmZqbW1x/z/myePn0KQRAk2583hqamprCwsNA5hjKZDBX+TQQ9bwzT0tKQlpYm2ZY7hgWd388bQwsLC5iamiIjIwMp+dboLOz8zh1DXed37hgWdn7rGsPc8zslJQUZGRmSbc87vwsbQysrK5iYmOgcQ75H5Hgd3iPUKSlQ3bqNzFu3YBAVBSEiAql37yLd1FTSzlAuh+Lf8yDJ0hKQyWBcuTLkbm6Q16gBh/r1ofD0QJqBgTiGGQAyBAHmaWl8jwDfI/Lie0SO4r5H5I+7pCUlJcHOzg5ubm5iWUxMDKKiotC3b18AQNu2bXHkyJFC+5LL5ZDL5aUVKhERERGVA0zaloHffvsNZmZm4nM3Nzf4+voiJSUFYWFhWvXfe+89AMDRo0cRGxsr2dauXTvUrFkTt2/fxsmTJyXbqlSpgq5duyIrK0tnv0OHDoWZmRlOnz6NmJgYybbmzZujfv36uH//Pg4cOCDZZmdnhz59+gAAduzYofXBsn///rCxscGlS5dw/fp1ybaGDRuiadOmePLkCXbu3CnZplAoMGTIEADAH3/8ofXhsXv37qhUqRKuXr2qNSuldu3a8PHxQXJystaxGhoaYuTIkQCAw4cPa31A7NChA6pXr46oqCicOXNGss3FxQV+fn5QqVQ6x3D48OEwMTHByZMn8c8//0i2tWzZEp6enrh79y4OHz4s2ebo6Ii3334bAHT26+/vD6VSifPnz+PmzZuSbV5eXvDy8kJsbCz++OMPyTYrKysMHDgQALBr1y6thMHbb78NR0dH/PXXX7hy5Ypkm4eHB1q1aoWEhAStmIyNjTFixAgAwIEDB7SSAn5+fnBxccH169dx/vx5ybZq1aqhY8eOyMjI0HmsI0eOhKGhIY4dO4aHDx9KtrVp0wbu7u64c+cOjh07Jtnm5OSEHj16QKPR6Ox3yJAhUCgUOHv2LKKjoyXb3nrrLTRq1AiPHj3C3r17JdtsbGzQv39/ADmv1fxJoj59+sDOzg7h4eGIiIiQbKtXrx68vb0RHx+PHTt2SLaZmpoiICAAALB3716tZFqXLl3g7OyMyMhIXLx4UbKN7xE5XrX3CEGtxgAPT6ivX8eh6GjEZmdBUP2X2HKPjITzvXuIc3LC3/Xq/ddQBthqBPgqFDD18MDR+KcwMDUF8twgzN/TA4ZKJc4fOsT3CL5H8D3iXyX9HpE/sVvS7OzskJiYCEEQxOVLgoKC0LVrV3h4eJTqvomIiIjo1SMT8k8ZoRKTlJQEpVKJ27dvw9LSUiznDJkcr8Msurw40zYHZ9Hl4Cy6/7yO7xGqh4/w6NJFqG7ehOrWbahu3YT68RNYJidDBiDV3BxqQ0NJW9OMDMgByNzdoXF3h4lbDcjd3GDi6goThYLvEf/ie0QOvkfkKOuZttWrV0diYiKsrKy04nxZsbGxcHV1xZw5czBw4ECEhoZixYoVOHfunGRpgyNHjuCbb7557pq2+eVec7YO3AkjU0WJx05ERET0ujs0rW2Z7Sv32q2w604mbUtRUX8IRERUPgmCgOwHD5Ae8d/6sxkREVA/0U485SczNYVp7dow9fSAqacnTD08IK9RAzITkzKInIiKqyyu2zZt2oTp06cjLi4Ovr6++Oqrr1CjRg1JHSZtiYiIiMpeeUzacnkEIiIiAIJGg6y7dyXJ2YyrEVDnm92ni4FCAdM6dXIStP/eJMykWjXIjPhrloj+4+/vD39/f32HQURERESvAH6aJCKiN46QnY3M6GhJcjYjMhKafF8X18VAqYRZnuSsqYcHjKtWhSzPGrRERC+iQ4cOuHz5MlJTU1GlShVs3rwZ3t7e+g6LiIiIiPSASVsiInqtCZmZUN269V9yNiICGdeuQci3/qguhnZ2ktmzZh4eMKpUSbyJEBFRScp/EzciIiIienMxaUtERK8NTUYGVDduSBK0qhs3IOS7oZUuRk5O/yZn6/z7ryeMHR3KIGoiIiIiIiIiKSZtiYjolaRJTUXGtWv/zZ6NiIDq1i1ArS60rXHVqpLlDUw96sDo37vQExEREREREekbk7ZERFTuqZOSkBERiYyrV8UEbeadO4AgPL+hTAaT6tWlCdo67jAspTvDExEREREREZUEJm2JiKhcyY6Pl8yezYiIQNa9e4U3NDSE3M3tv+SspwdMa9eGgUJR+kETEZUDOye1hhX/KEVERET0WmDSloiI9EIQBGQ/fqyVoM1+9KjQtjJjY8hr15YkaOW1asFALi+DyImIiIiIiIhKF5O2RERU6gRBQNb9B8iIuCpJ0qqfPi20rczMDKbu7tIEbY0akBkbl0HkRERERERERGWPSVsiIipRgkaDzJgYyezZjIhIaBITC21rYGEB0zp1/lvewMMDJtWqQWZoWAaRExEREREREZUPTNoSEdELE7Kzobp9W5KgVUVEQpOWVmhbQ2trSXLW1MMDxs7OkBkYlEHkREREREREROUXk7ZERFQkmsxMqKKipAnaa9chqFSFtjWyt9dK0Bo5OUEmk5VB5ERERERERESvFiZtiYhIiyYjA6rr1/9L0F6NQEZUFJCVVWhbo0pOYmLWzNMT8jp1YOzgUAZRExG92bp/fRxGpgp9h0FERETl1KFpbfUdAhUDk7ZERG84dUoqVNci/0vORkRAdfs2oFYX2tbYpep/NwjLnUFrY1MGURMRERERERG9vpi0JSJ6g6gTEpARKU3QZsbEAILw/IYGBjCpXk2aoK1TB4aWlmUTOBEREREREdEbhElbIqLXVPbTp5LkbMbVq8i6f7/whkZGkLu5SdegrV0bBubmpR80ERERERERETFpS0T0qhMEAdmxsdIEbUQEsmNjC20rMzGBvHZtyQxaea2aMJDLyyByIiIiIiIiItKFSVsioleIIAjI+ucfSXI2IyIC6vj4QtvKzMxgWqfOfwlaTw/Iq1eHzNi4DCInIiIiIiIioqJi0paIqJwSNBpk3omRJGczIiKgSUoqtK2BpaV0/VlPD5i4uEBmaFgGkRMRERERERHRy2DSloioHBCys6G6dVuSnFVFRkKTllZoW0MbG0ly1tTDA8bOzpDJZGUQORERFYcgCFi6dCmWL1+O2NhYdOrUCevXr4dSqdR3aERERERUjjBpS0RUxjSZmVDdiEJGxNV/E7SRUF2/DkGlKrStkYODVoLWqGJFJmiJiF4R06dPx44dO7B+/XooFAr06tULc+fOxdKlS/UdGhERERGVI0zaEhGVIk16OlTXryP9ap4EbVQUkJ1daFvjypUlyVnTOnVgZG9fBlETEVFpOHv2LEJCQnDhwgU0btwYADB69GiEhoYyaUtEREREEkzaEhGVEHVKClSRkdIlDm7dBjSaQtuauLj8l5z18IC8Th0Y2diUQdRERFRWFi9ejPbt24sJWwBwdHREXFycHqMiIiIiovKISVsioheQ/eyZNEF7NQKZMTGFNzQwgLxGdclNwuR16sDQwqL0gyYiIr1RqVTYtWsXFi9eLCnPyMjgerZEREREpIVJWyKiQmTHxf2bmL0qJmizHjwovKGxMeQ13cTkrJmHB+S1a8PAzKz0gyYionLl0qVLSE9Px9SpUzFjxgyxPCsrC+3atcO9e/cwdOhQPH78GEZGRpg9ezb69++vsy+VSgVVnnXQk5KSSj1+IiIiIipbTNoSEf1LEARkP3okJmZzZ9FmP35caFuZiQnk7u4w9ajzb5LWE/JaNWFgYlIGkRMRUXl348YNKBQKhIeHS8q7deuGli1bwsjICMuWLUPDhg3x6NEjeHl5oWvXrlAoFFp9BQcHY968eWUUORERERHpA5O2RPRGEgQBWffuaSVo1c+eFdpWZm4O0zp1pEscVK8GmbFxGURORESvoqSkJNjZ2cHNzU0si4mJQVRUFPr27QsnJyc4OTkBACpWrAg7OzvEx8frTNrOmjULU6ZMkfTt7Oxc+gdBRERERGWGSVsieu0JajUyY2JykrO5SxxERkKTnFxoWwMrK0ly1tTDAyYuVSEzNCyDyImI6HVhZ2eHxMRECIIAmUwGAAgKCkLXrl3h4eEhqXvx4kWo1eoCE7FyuRxyubzUYyYiIiIi/WHSloheK0JWFlS3b0tmz2ZcuwYhLa3Qtoa2tjmJWU/Pf//1gHHlyuKHayIiohfl6+uLjIwMfP755xg4cCBCQ0Px+++/49y5c5J68fHxCAgIwJo1a/QUKRERERGVB0zaEtErS6NSQXUj6r/kbEQEVNevQ8jMLLStkaPjf7NnPXP+NXJ0ZIKWiIhKhaOjI9atW4fp06cjMDAQvr6+OHHihGQ2rUqlQq9evfDRRx+hRYsWeoyWiIiIiPSNSVsieiVo0tKQce26NEF78yaQnV1oW+MqVaQJ2jp1YGRnVwZRExER/cff3x/+/v46twmCgOHDh8PX1xdDhw4t48iIiIiIqLxh0paIyh11cjIyIiP/S9BejUBmdDSg0RTa1sTV9b8lDjw9YOruDkNr69IPmoiI6CWcPHkSmzZtQv369bF9+3YAwE8//YR69erpNzAiIiIi0gsmbYlIr7KfPZPMns2IiEBWzN3CGxoYQF6jhmR5A7m7OwwtLEo/aCIiohLWqlUraIrwx0kiIiIiejMY6DuAFStWwNXVFaampmjWrJnWzRjyW7ZsGWrXrg0zMzM4Ozvjww8/REZGRrH6zMjIwIQJE1ChQgVYWFigb9++iI2NldS5e/cuunXrBnNzczg4OGD69OnILsLXsImoYFmPHyP5yBE8+fZb3Js4EVG+vojyboF7I0fhyZIQJP+xR3fC1tgYph4esO7fDxU/mwPXTb+g9sULqP77b6i06HPYBgTAvEkTJmyJiIiIiIiI6LWg15m2mzZtwpQpU7Bq1So0a9YMy5Ytg5+fH65fvw4HBwet+hs3bsRHH32EH374AS1atMCNGzcwfPhwyGQyhISEFLnPDz/8ELt27cLmzZuhVCoxceJE9OnTBydPngQAqNVqdOvWDRUrVsSpU6fw8OFDBAQEwNjYGAsXLiy7ASJ6RQmCgOyHDyXLG6RHXIX6SVyhbWVyOUzd3cXZs6YeHpC7uUFmYlIGkRMRERERERER6Z9MEARBXztv1qwZ3nrrLXzzzTcAAI1GA2dnZ7z//vv46KOPtOpPnDgRkZGROHjwoFg2depUnD17FidOnChSn4mJibC3t8fGjRvRr18/AMC1a9dQp04dnD59Gs2bN8cff/yB7t2748GDB3B0dAQArFq1CjNnzsSTJ09gUsTkUVJSEpRKJRITE2FlZfXiA0VUjgkaDbLu3ZMkaDMiIqBOSCi0rYG5OeQedf67SZiHB+TVq0NmxJVbiIiobL3K1225sbcO3AkjU4W+wyEiIqJy6tC0tvoOgVD06069ZUYyMzNx8eJFzJo1SywzMDBAhw4dcPr0aZ1tWrRogQ0bNuDcuXNo2rQpbt++jd27d4t32C1KnxcvXkRWVhY6dOgg1nF3d0fVqlXFpO3p06dRr149MWELAH5+fhg3bhyuXr2KRo0alehYEL0qBLUamdHRkuRsRmQkNCkphbY1UCphmi9Ba+LiApmB3ldpISIiIiIiIiIqV/SWtI2Li4NarZYkRgHA0dER165d09lm8ODBiIuLQ6tWrXK+fp2djbFjx+Ljjz8ucp+PHj2CiYkJrPPdTd7R0RGPHj0S6+jqI3dbQVQqFVQqlfg8KSmpwLpE5Z2QlQXVrVv/JWcjIpBx7RqE9PRC2xpWqCBZ3sDUwxPGlStBJpOVQeRERERvpp2TWr9ys4SJiIiISLdX6jvIR44cwcKFC/Htt9+iWbNmuHnzJiZPnozAwEDMnj1b3+EhODgY8+bN03cYRMWmUamgunFDkqBVXb8OISur0LZGFStKZs+aenrAyMGBCVoiIiIiIiIiohekt6StnZ0dDA0NERsbKymPjY1FxYoVdbaZPXs2hg4dilGjRgEA6tWrh9TUVLz33nv45JNPitRnxYoVkZmZiYSEBMls2/x1zp07p9VH7raCzJo1C1OmTBGfJyUlwdnZ+XnDQPRSBLUaaRcuIvvJExjZ28O8iRdkhobPbaNJTUXG9evSBO3Nm4BaXej+jJ2dpQlajzowqlChpA6HiIiIiIiIiIigx6StiYkJvLy8cPDgQfTq1QtAzk3DDh48iIkTJ+psk5aWBoN8618a/pugEgShSH16eXnB2NgYBw8eRN++fQEA169fx927d+Ht7Q0A8Pb2RlBQEB4/fgwHBwcAwP79+2FlZQUPD48Cj0kul0Mul7/YgBAVU9K+fYhdGIzsPEt2GFWsCMePZ8GqUycAgDopCRmR15Bx9aqYoM2MjgYKu/+gTAaTatWkCdo67jBUKkvzkIiIiIiIiIiICHpeHmHKlCkYNmwYmjRpgqZNm2LZsmVITU3FiBEjAAABAQGoXLkygoODAQA9evRASEgIGjVqJC6PMHv2bPTo0UNM3hbWp1KpxMiRIzFlyhTY2trCysoK77//Pry9vdG8eXMAQKdOneDh4YGhQ4fiiy++wKNHj/Dpp59iwoQJTMpSuZC0bx/uT/5AK/ma/egR7k+ajKcNG0IdH4+su3cL78zQEPIaNSTLG8hru8PQgnefJiIiIiIiIiLSB70mbf39/fHkyRPMmTMHjx49QsOGDbFnzx7xpl93796VzKz99NNPIZPJ8Omnn+L+/fuwt7dHjx49EBQUVOQ+AWDp0qUwMDBA3759oVKp4Ofnh2+//VbcbmhoiJ07d2LcuHHw9vaGQqHAsGHDMH/+/DIYFaLnE9RqxC4Mfu5s2YzwcJ3lMmNjyGvVEpOzph4ekNeqBQNT01KKloiIiIiIiIiIiksmCIV9T5peVFJSEpRKJRITE3knXyoxqWfP4e6wYYVXNDaGmaenNEFbowZkJialHyQREdEr5lW+bsuNvXXgThiZ8psyREREr7JD09rqOwQqZUW97tTrTFsqeT2Wn9B3CFTKGt44i8FFqPezTwD+rJ2z5AceAHjwFDjwtDRDozL0+/ut9B0CEREREREREZUSg8KrEFF5kqSwLlK9RAub0g2EiIiIiIiIiIhKBZO2RK+YaKeaSFDYoKB1TQQAzyxsEO1UsyzDIiIiIiIiIiKiEsKkLdErRjAwwG+tB+b8P/+2f//9vdVACAZ8eRMRERERERERvYqY1SF6Bf1dozF+6jwOiQrpEggJFjb4qfM4/F2jsZ4iIyIiIiIiIiKil8UbkRG9ov6u0RhXqzVEtYdRsEpNQJLCGtFONTnDloiIiIiIiIjoFcfsDtErTDAwwO3KtRFeqxluV67NhC0REVE5JwgCQkJCUK1aNZibm6NXr15ITEzUd1hEREREVM4ww0NEREREVEamT5+OlStXYv369Th+/DguXryIuXPn6jssIiIiIipnmLQlIiIiIioDZ8+eRUhICDZt2oQ2bdrAy8sLo0ePxu7du/UdGhERERGVM0zaEhERERGVgcWLF6N9+/Zo3Pi/G4Y6OjoiLi5Oj1ERERERUXnEpC0RERERUSlTqVTYtWsXevfuLSnPyMiAUqksdl9JSUmSBxERERG9Xpi0JSIiIiIqZZcuXUJ6ejqmTp0KCwsL8TFjxgzUqlULALBz507Url0bNWvWxPfff19gX8HBwVAqleLD2dm5rA6DiIiIiMqIkb4DICIiIiJ63d24cQMKhQLh4eGS8m7duqFly5bIzs7GlClTcPjwYSiVSnh5eaF3796oUKGCVl+zZs3ClClTxOdJSUlM3BIRERG9Zpi0JSIiIiIqZUlJSbCzs4Obm5tYFhMTg6ioKPTt2xfnzp2Dp6cnKleuDADo0qUL9u3bh0GDBmn1JZfLIZfLyyx2IiIiIip7XB6BiIiIiKiU2dnZITExEYIgiGVBQUHo2rUrPDw88ODBAzFhCwCVK1fG/fv39REqEREREZUDnGlLRERERFTKfH19kZGRgc8//xwDBw5EaGgofv/9d5w7d07foRERERFROcSZtkREREREpczR0RHr1q3DypUr4enpiTNnzuDEiRPiWrSVKlWSzKy9f/8+KlWqpK9wiYiIiEjPONOWiIiIiKgM+Pv7w9/fX+e2pk2b4u+//8b9+/ehVCrxxx9/YPbs2WUcIRERERGVF0zaEhERERHpmZGREZYsWYJ27dpBo9FgxowZqFChgr7DIiIiIiI9YdKWiIiIiKgc6NmzJ3r27KnvMIiIiIioHOCatkRERERERERERETlCJO2REREREREREREROUIk7ZERERERERERERE5QiTtkRERERERERERETlCG9ERkRERET0Gtg5qTWsrKz0HQYRERERlQDOtCUiIiIiIiIiIiIqR5i0JSIiIiIiIiIiIipHmLQlIiIiIiIiIiIiKkeYtCUiIiIiIiIiIiIqR5i0JSIiIiIiIiIiIipHjPQdABERERERvbzuXx+HkalC32EQERGVikPT2uo7BKIyxZm2REREREREREREROUIk7ZERERERERERERE5QiTtkRERERERERERETlCJO2REREREREREREROUIk7ZERERERERERERE5QiTtkRERERERERERETlCJO2REREREQlSBAEhISEoFq1ajA3N0evXr2QmJio77CIiIiI6BXCpC0RERERUQmaPn06Vq5cifXr1+P48eO4ePEi5s6dq++wiIiIiOgVwqQtEREREVEJOXv2LEJCQrBp0ya0adMGXl5eGD16NHbv3q3v0IiIiIjoFcKkLRERERFRCVm8eDHat2+Pxo0bi2WOjo6Ii4vTY1RERERE9Kph0paIiIiIqASoVCrs2rULvXv3lpRnZGRAqVSW6H6SkpIkDyIiIiJ6vTBpS0RERERUAi5duoT09HRMnToVFhYW4mPGjBmoVasWAKB3796wsbFBv379JG2jo6PRrl07eHh4oF69ekhNTS1wP8HBwVAqleLD2dm5VI+LiIiIiMoek7ZERERERCXgxo0bUCgUuHLlCsLDw8WHq6srWrZsCQCYPHkyfvzxR622w4cPx/z58xEREYGjR49CLpcXuJ9Zs2YhMTFRfNy7d6/UjomIiIiI9MNI3wEQEREREb0OkpKSYGdnBzc3N7EsJiYGUVFR6Nu3LwCgbdu2OHLkiKTd1atXYWxsjNatWwMAbG1tn7sfuVz+3KQuEREREb36ONOWiIiIiKgE2NnZITExEYIgiGVBQUHo2rUrPDw8CmwXFRUFCwsL9OjRA40bN8bChQvLIlwiIiIiKsc405aIiIiIqAT4+voiIyMDn3/+OQYOHIjQ0FD8/vvvOHfu3HPbZWdn4/jx4wgPD4eDgwM6d+6Mt956Cx07diyjyImIiIiovOFMWyIiIiKiEuDo6Ih169Zh5cqV8PT0xJkzZ3DixIlCbxRWuXJlNGnSBM7OzpDL5ejatSvCw8PLJmgiIiIiKpeYtCUiIiIiKiH+/v64e/cu0tLSsHPnTtSoUaPQNm+99RYeP36MZ8+eQaPR4NixY6hTp04ZREtERERE5RWXRyAiIiIiKiMdOnTA5cuXkZqaiipVqmDz5s3w9vbGwoUL0aZNGwiCgE6dOqF79+76DpWIiIiI9IhJWyIiIiKiMnLgwAGd5V26dEGXLl3KOBoiIiIiKq+4PAIRERERERERERFROcKkLREREREREREREVE5wqQtERERERERERERUTnCpC0RERERERERERFROcIbkRERERERvQZ2TmoNKysrfYdBRERERCWAM22JiIiIiIiIiIiIyhEmbYmIiIiIiIiIiIjKESZtiYiIiIiIiIiIiMoRJm2JiIiIiIiIiIiIyhEmbYmIiIiIiIiIiIjKESN9B0BERERERC+v+9fHYWSq0HcYRERUzhya1lbfIRDRC+BMWyIiIiIiIiIiIqJyhElbIiIiIiIiIiIionKESVsiIiIiIiIiIiKicoRJWyIiIiIiIiIiIqJyhElbIiIiIiIiIiIionKESVsiIiIiIiIiIiKicoRJWyIiIiKiMiIIAkJCQlCtWjWYm5ujV69eSExM1HdYRERERFTOMGlLRERERFRGpk+fjpUrV2L9+vU4fvw4Ll68iLlz5+o7LCIiIiIqZ5i0JSIiIiIqA2fPnkVISAg2bdqENm3awMvLC6NHj8bu3bv1HRoRERERlTN6T9quWLECrq6uMDU1RbNmzXDu3Lnn1k9ISMCECRPg5OQEuVyOWrVqaV3oFtZnRkYGJkyYgAoVKsDCwgJ9+/ZFbGyspM7du3fRrVs3mJubw8HBAdOnT0d2dnbJHDQRERERvXEWL16M9u3bo3HjxmKZo6Mj4uLi9BgVEREREZVHek3abtq0CVOmTMFnn32GS5cuoUGDBvDz88Pjx4911s/MzETHjh1x584dbNmyBdevX8eaNWtQuXLlYvX54Ycf4vfff8fmzZtx9OhRPHjwAH369BG3q9VqdOvWDZmZmTh16hTWr1+PdevWYc6cOaU3GERERET02lKpVNi1axd69+4tKc/IyIBSqSx2X0lJSZIHEREREb1eXihpe/ToUfTo0QNubm5wc3NDz549cfz48WL3ExISgtGjR2PEiBHw8PDAqlWrYG5ujh9++EFn/R9++AHx8fHYvn07WrZsCVdXV/j4+KBBgwZF7jMxMRH/+9//EBISAl9fX3h5eWHt2rU4deoUzpw5AwDYt28fIiIisGHDBjRs2BBdunRBYGAgVqxYgczMzBcYMSIiIiJ6k126dAnp6emYOnUqLCwsxMeMGTNQq1YtAEB0dDTatWsHDw8P1KtXD6mpqTr7Cg4OhlKpFB/Ozs5leShEREREVAaKnbTdsGEDOnToAHNzc0yaNAmTJk2CmZkZ2rdvj40bNxa5n8zMTFy8eBEdOnT4LxgDA3To0AGnT5/W2ea3336Dt7c3JkyYAEdHR9StWxcLFy6EWq0ucp8XL15EVlaWpI67uzuqVq0q1jl9+jTq1asHR0dHsY6fnx+SkpJw9erVAo+Jsx6IiIiISJcbN25AoVDgypUrCA8PFx+urq5o2bIlAGD48OGYP38+IiIicPToUcjlcp19zZo1C4mJieLj3r17ZXkoRERERFQGjIrbICgoCF988QU+/PBDsWzSpEkICQlBYGAgBg8eXKR+4uLioFarJYlRIGddr2vXrulsc/v2bRw6dAhDhgzB7t27cfPmTYwfPx5ZWVn47LPPitTno0ePYGJiAmtra606jx49Euvo6iN3W0GCg4Mxb968wg+eiIiIiN4oSUlJsLOzg5ubm1gWExODqKgo9O3bF1evXoWxsTFat24NALC1tS2wL7lcXmBCl4iIiIheD8WeaXv79m306NFDq7xnz56Ijo4ukaAKotFo4ODggO+++w5eXl7w9/fHJ598glWrVpXqfouKsx6IiIiISBc7OzskJiZCEASxLCgoCF27doWHhweioqJgYWGBHj16oHHjxli4cKEeoyUiIiIifSv2TFtnZ2ccPHhQMksAAA4cOFCs9bTs7OxgaGiI2NhYSXlsbCwqVqyos42TkxOMjY1haGgoltWpUwePHj1CZmZmkfqsWLEiMjMzkZCQIJltm7/OuXPntPrI3VYQznogIiIiIl18fX2RkZGBzz//HAMHDkRoaCh+//138ZozOzsbx48fR3h4OBwcHNC5c2e89dZb6Nixo54jJyIiIiJ9KPZM26lTp2LSpEkYN24cfvrpJ/z0008YO3YsPvjgA0ybNq3I/ZiYmMDLywsHDx4UyzQaDQ4ePAhvb2+dbVq2bImbN29Co9GIZTdu3ICTkxNMTEyK1KeXlxeMjY0lda5fv467d++Kdby9vXHlyhU8fvxYrLN//35YWVnBw8OjyMdIRERERATkLLW1bt06rFy5Ep6enjhz5gxOnDghTnqoXLkymjRpAmdnZ8jlcnTt2hXh4eH6DZqIiIiI9KbYM23HjRuHihUrYsmSJfj1118B5Mx23bRpE95+++1i9TVlyhQMGzYMTZo0QdOmTbFs2TKkpqZixIgRAICAgABUrlwZwcHB4r6/+eYbTJ48Ge+//z6ioqKwcOFCTJo0qch9KpVKjBw5ElOmTIGtrS2srKzw/vvvw9vbG82bNwcAdOrUCR4eHhg6dCi++OILPHr0CJ9++ikmTJjAmbRERERE9EL8/f3h7++vc9tbb72Fx48f49mzZ1AqlTh27BjGjBlTxhESERERUXlR7KQtAPTu3Ru9e/d+6Z37+/vjyZMnmDNnDh49eoSGDRtiz5494k2/7t69CwOD/yYDOzs7Y+/evfjwww9Rv359VK5cGZMnT8bMmTOL3CcALF26FAYGBujbty9UKhX8/Pzw7bffitsNDQ2xc+dOjBs3Dt7e3lAoFBg2bBjmz5//0sdMRERERJSfkZERFi5ciDZt2kAQBHTq1Andu3fXd1hEREREpCcyIe/dEKhEJSUlQalUIjExEVZWVmWyzx7LT5TJfohIv35/v5W+QyAieq3o47qtpOTG3jpwJ4xMFfoOh4iIyplD09rqOwQiyqOo151Fmmlra2uLGzduwM7ODjY2NpDJZAXWjY+PL360RERERERERERERASgiEnbpUuXwtLSUvz/85K2RERERERERERERPTiipS0HTZsmPj/4cOHl1YsRERERERERERERG+8Yt+IzNDQEA8fPoSDg4Ok/OnTp3BwcIBarS6x4IiIiIiIqGh2Tmr9yq3HS0RERES6GRS3QUH3LVOpVDAxMXnpgIiIiIiIiIiIiIjeZEWeafv1118DAGQyGb7//ntYWFiI29RqNY4dOwZ3d/eSj5CIiIiIiIiIiIjoDVLkpO3SpUsB5My0XbVqFQwNDcVtJiYmcHV1xapVq0o+QiIiIiIiIiIiIqI3SJGTttHR0QCAdu3aISwsDDY2NqUWFBEREREREREREdGbqtg3Ijt8+HBpxEFEREREREREREREeIGkLQD8888/+O2333D37l1kZmZKtoWEhJRIYERERERERERERERvomInbQ8ePIiePXuievXquHbtGurWrYs7d+5AEAQ0bty4NGIkIiIiIqJCdP/6OIxMFfoOg4iIytihaW31HQIRlQKD4jaYNWsWpk2bhitXrsDU1BRbt27FvXv34OPjg/79+5dGjERERERERERERERvjGInbSMjIxEQEAAAMDIyQnp6OiwsLDB//nwsWrSoxAMkIiIiIiIiIiIiepMUe3kEhUIhrmPr5OSEW7duwdPTEwAQFxdXstERERGRXmk0Gq3164leVSYmJjAwKPacBSIiIiKiMlfspG3z5s1x4sQJ1KlTB127dsXUqVNx5coVhIWFoXnz5qURIxEREelBZmYmoqOjodFo9B0KUYkwMDBAtWrVYGJiou9QiIiIiIieq9hJ25CQEKSkpAAA5s2bh5SUFGzatAk1a9ZESEhIiQdIREREZU8QBDx8+BCGhoZwdnbm7ER65Wk0Gjx48AAPHz5E1apVIZPJ9B0SEREREVGBipW0VavV+Oeff1C/fn0AOUslrFq1qlQCIyIiIv3Jzs5GWloaKlWqBHNzc32HQ1Qi7O3t8eDBA2RnZ8PY2Fjf4RARERERFahY02YMDQ3RqVMnPHv2rLTiISIionJArVYDAL9GTq+V3PM59/wuTYIgICQkBNWqVYO5uTl69eqFxMTEUt8vEREREb0eiv1dx7p16+L27dulEQsRERGVM/wKOb1OyvJ8nj59OlauXIn169fj+PHjuHjxIubOnVtm+yciIiKiV1uxk7YLFizAtGnTsHPnTjx8+BBJSUmSBxERERHRm+zs2bMICQnBpk2b0KZNG3h5eWH06NHYvXu3vkMjIiIioldEsZO2Xbt2xeXLl9GzZ09UqVIFNjY2sLGxgbW1NWxsbEojRiIiIqLXhkwmw/bt28tNP1TyFi9ejPbt26Nx48ZimaOjI+Li4vQYFRERERG9Sop1IzIAOHz4cGnEQURERK8hQa1G2oWLyH7yBEb29jBv4gWZoWGp7/fRo0cICgrCrl27cP/+fTg4OKBhw4b44IMP0L59+1Lff0maO3cutm/fjvDwcEn5w4cP+QfzckilUmHXrl1YvHixpDwjIwNKpbLE9qFSqcTn/LYbERER0eun2ElbHx+f0oiDiIiIXjNJ+/YhdmEwsh89EsuMKlaE48ezYNWpU6nt986dO2jZsiWsra3x5Zdfol69esjKysLevXsxYcIEXLt2rdT2XZYqVqyo7xBIh0uXLiE9PR1Tp07FjBkzxPKsrCy0a9cOANC7d28cOXIE7du3x5YtWwAA9+7dw9ChQ/H48WMYGRlh9uzZ6N+/v859BAcHY968eaV/MERERESkN8VeHoGIiIioMEn79uH+5A8kCVsAyI6Nxf3JHyBp375S2/f48eMhk8lw7tw59O3bF7Vq1YKnpyemTJmCM2fO4M6dO5DJZJKZqwkJCZDJZDhy5AgA4MiRI5DJZNi7dy8aNWoEMzMz+Pr64vHjx/jjjz9Qp04dWFlZYfDgwUhLSxP7cXV1xbJlyyTxNGzY8Lk3oJo5cyZq1aoFc3NzVK9eHbNnz0ZWVhYAYN26dZg3bx4uX74MmUwGmUyGdevWAZAuj9CiRQvMnDlT0u+TJ09gbGyMY8eOAciZnTlt2jRUrlwZCoUCzZo1E4+XSs6NGzegUChw5coVhIeHiw9XV1e0bNkSADB58mT8+OOPknZGRkZYtmwZIiIisG/fPnzwwQdITU3VuY9Zs2YhMTFRfNy7d6/Uj4uIiIiIylaxZ9oSERERPY+gViN2YTAgCDo2CoBMhtiFwbBs377El0qIj4/Hnj17EBQUBIVCobXd2toaCQkJRe5v7ty5+Oabb2Bubo4BAwZgwIABkMvl2LhxI1JSUtC7d28sX75cK2FaHJaWlli3bh0qVaqEK1euYPTo0bC0tMSMGTPg7++Pv//+G3v27MGBAwcAQOdX7IcMGYIvvvgCn3/+OWQyGQBg06ZNqFSpElq3bg0AmDhxIiIiIvDLL7+gUqVK2LZtGzp37owrV66gZs2aLxw/SSUlJcHOzg5ubm5iWUxMDKKiotC3b18AQNu2bbUS5k5OTnBycgKQM4vazs4O8fHxOs9juVwOuVxeegdBRERERHrHpC0REREVSXTffsguwo2UNJmZ0Dx7VnAFQUD2o0e40ao1DExMCu3PyM4O1bZuKVKMN2/ehCAIcHd3L1L9wixYsECcHTly5EjMmjULt27dQvXq1QEA/fr1w+HDh18qafvpp5+K/3d1dcW0adPwyy+/YMaMGTAzM4OFhQWMjIyeuxzCgAED8MEHH+DEiRNiknbjxo0YNGgQZDIZ7t69i7Vr1+Lu3buoVKkSAGDatGnYs2cP1q5di4ULF75w/CRlZ2eHxMRECIIgJtCDgoLQtWtXeHh4FKmPixcvQq1Ww9nZuTRDJSIiIqJyjElbIiIiKpLsuDhkx8aWWH+aZ8+gKbHecgi6Zve+hPr164v/d3R0FJcwyFt27ty5l9rHpk2b8PXXX+PWrVtISUlBdnY2rKysitWHvb09OnXqhNDQULRu3RrR0dE4ffo0Vq9eDQC4cuUK1Go1atWqJWmnUqlQoUKFl4qfpHx9fZGRkYHPP/8cAwcORGhoKH7//fcinyfx8fEICAjAmjVrSjlSIiIiIirPXihpm52djSNHjuDWrVsYPHgwLC0t8eDBA1hZWcHCwqKkYyQiIqJywMjOrkj1Cp1p+y8DG5siz7Qtqpo1a0Imkz33ZmMGBjlL+udN8OauIZufsbGx+H+ZTCZ5nlum0fyXejYwMNBKHBfUNwCcPn0aQ4YMwbx58+Dn5welUolffvkFS5YsKbBNQYYMGYJJkyZh+fLl2LhxI+rVq4d69eoBAFJSUmBoaIiLFy/CMN+SFLx2K1mOjo5Yt24dpk+fjsDAQPj6+uLEiRNFmjWrUqnQq1cvfPTRR2jRokUZREtERERE5VWxk7YxMTHo3Lkz7t69C5VKhY4dO8LS0hKLFi2CSqXCqlWrSiNOIiIi0rOiLlEgqNW42b5DzqxcXTNfZTIYOTrC7eCBEl/T1tbWFn5+flixYgUmTZqktR5oQkIC7O3tAQAPHz5Eo0aNAEByU7KXYW9vj4cPH4rPk5KSEB0dXWD9U6dOwcXFBZ988olYFhMTI6ljYmICtVpd6L7ffvttvPfee9izZw82btyIgIAAcVujRo2gVqvx+PFjcfkEKj3+/v7w9/cvVhtBEDB8+HD4+vpi6NChpRQZEREREb0qDIrbYPLkyWjSpAmePXsGMzMzsbx37944ePBgiQZHRERErx6ZoSEcP5717xNZvo05zx0/nlXiCdtcK1asgFqtRtOmTbF161ZERUUhMjISX3/9Nby9vWFmZobmzZvj888/R2RkJI4ePSpZV/Zl+Pr64qeffsLx48dx5coVDBs2TGtma141a9bE3bt38csvv+DWrVv4+uuvsW3bNkkdV1dXREdHIzw8HHFxcVCpVDr7UigU6NWrF2bPno3IyEgMGjRI3FarVi0MGTIEAQEBCAsLQ3R0NM6dO4fg4GDs2rWrRI6diq5Dhw7o378/du/ejSpVquD06dM4efIkNm3ahO3bt6Nhw4Zo2LAhrly5ou9QiYiIiEhPij3T9vjx4zh16hRM8n2d0dXVFffv3y+xwIiIiOjVZdWpE/DVMsQuDEb2o0diuZGjIxw/npWzvZRUr14dly5dQlBQEKZOnYqHDx/C3t4eXl5eWLlyJQDghx9+wMiRI+Hl5YXatWvjiy++QKcSiGnWrFmIjo5G9+7doVQqERgY+NyZtj179sSHH36IiRMnQqVSoVu3bpg9ezbmzp0r1unbty/CwsLQrl07JCQkYO3atRg+fLjO/oYMGYKuXbuiTZs2qFq1qmTb2rVrsWDBAkydOhX379+HnZ0dmjdvju7du7/0cVPxHDhwQGd53qU2iIiIiOjNJhOKeccOGxsbnDx5Eh4eHrC0tMTly5dRvXp1nDhxAn379kVsCd6g5FWXlJQEpVKJxMTEYt9Q5EX1WH6iTPZDRPr1+/ut9B0CveYyMjIQHR2NatWqwdTU9IX7EdRqpF24iOwnT2Bkbw/zJl6lNsOWqDDPO6/1cd1WUnJjbx24E0amisIbEBHRa+XQtLb6DoGIiqGo153FXh6hU6dOWLZsmfhcJpMhJSUFn332Gbp27fpCwRIREdHrSWZoCEWzplB27wZFs6ZM2BIRERERERVBsZdHWLJkCfz8/ODh4YGMjAwMHjwYUVFRsLOzw88//1waMRIRERERERERERG9MYqdtK1SpQouX76MTZs24fLly0hJScHIkSMxZMgQyY3JiIiIiIio7Oyc1PqVW9qBiIiIiHQrdtIWAIyMjDBkyBAMGTKkpOMhIiIiIiIiIiIieqMVe03b4OBg/PDDD1rlP/zwAxYtWlQiQRERERERERERERG9qYqdtF29ejXc3d21yj09PbFq1aoSCYqIiIiIiIiIiIjoTVXspO2jR4/g5OSkVW5vb4+HDx+WSFBEREREREREREREb6piJ22dnZ1x8uRJrfKTJ0+iUqVKJRIUERERERERERER0Zuq2DciGz16ND744ANkZWXB19cXAHDw4EHMmDEDU6dOLfEAiYiIiIiocN2/Pg4jU4W+wyAiojJ2aFpbfYdARKWg2DNtp0+fjpEjR2L8+PGoXr06qlevjvfffx+TJk3CrFmzSiNGIiIionLF1dUVy5YtK3L9devWwdrautTiyXXkyBHIZDIkJCSU+r7yK6tjJCIiIiJ6ExR7pq1MJsOiRYswe/ZsREZGwszMDDVr1oRcLi+N+IiIiKgc6bH8RJnu7/f3WxWr/vDhw7F+/Xqtcj8/P+zZs6ekwio2f39/dO3aVW/7LwtvwjESEREREZWVYidtc1lYWOCtt94qyViIiIiIXlrnzp2xdu1aSZm+/7hsZmYGMzMzvcZQmrKysl77YyQiIiIiKkvFXh4hNTUVs2fPRosWLeDm5iYukZD7ICIiItInuVyOihUrSh42NjYAcpYPMDExwfHjx8X6X3zxBRwcHBAbGwsAaNu2LSZOnIiJEydCqVTCzs4Os2fPhiAIBe4zJCQE9erVg0KhgLOzM8aPH4+UlBRxe/6lA+bOnYuGDRvip59+gqurK5RKJQYOHIjk5GSxjkajQXBwMKpVqwYzMzM0aNAAW7Zskex39+7dqFWrFszMzNCuXTvcuXPnuWMzePBg+Pv7S8qysrJgZ2eHH3/8EQCwZ88etGrVCtbW1qhQoQK6d++OW7duifXv3LkDmUyGTZs2wcfHB6ampggNDdU6xlu3buHtt9+Go6Oj+Mf+AwcOSPbt6uqKhQsX4t1334WlpSWqVq2K7777TlLnn3/+waBBg2BrawuFQoEmTZrg7Nmz4vYdO3agcePGMDU1RfXq1TFv3jxkZ2c/dxyIiIiIiMq7Ys+0HTVqFI4ePYqhQ4fCyckJMpmsNOIiIiIiKnFt27bFBx98gKFDh+Ly5cu4ffs2Zs+ejc2bN8PR0VGst379eowcORLnzp3DhQsX8N5776Fq1aoYPXq0zn4NDAzw9ddfo1q1arh9+zbGjx+PGTNm4Ntvvy0wllu3bmH79u3YuXMnnj17hgEDBuDzzz9HUFAQACA4OBgbNmzAqlWrULNmTRw7dgzvvPMO7O3t4ePjg3v37qFPnz6YMGEC3nvvPVy4cKHQm8IOGTIE/fv3R0pKCiwsLAAAe/fuRVpaGnr37g0g5w/0U6ZMQf369ZGSkoI5c+agd+/eCA8Ph4HBf3/v/+ijj7BkyRI0atQIpqam2Lt3r2RfKSkp6Nq1K4KCgiCXy/Hjjz+iR48euH79OqpWrSrWW7JkCQIDA/Hxxx9jy5YtGDduHHx8fFC7dm2kpKTAx8cHlStXxm+//YaKFSvi0qVL0Gg0AIDjx48jICAAX3/9NVq3bo1bt27hvffeAwB89tlnzx0LIiIiIqLyrNhJ2z/++AO7du1Cy5YtSyMeIiIiopeyc+dOMSGZ6+OPP8bHH38MAFiwYAH279+P9957D3///TeGDRuGnj17Suo7Oztj6dKlkMlkqF27Nq5cuYKlS5cWmLT94IMPxP+7urpiwYIFGDt27HOTthqNBuvWrYOlpSUAYOjQoTh48CCCgoKgUqmwcOFCHDhwAN7e3gCA6tWr48SJE1i9ejV8fHywcuVK1KhRA0uWLAEAMc5FixYVuE8/Pz8oFAps27YNQ4cOBQBs3LgRPXv2FOPo27evpM0PP/wAe3t7REREoG7dupJj7tOnT4H7atCgARo0aCA+DwwMxLZt2/Dbb79h4sSJYnnXrl0xfvx4AMDMmTOxdOlSHD58GLVr18bGjRvx5MkTnD9/Hra2tgAANzc3se28efPw0UcfYdiwYeIYBQYGYsaMGUzaEhEREdErrdhJWxsbG/GimYiIiKi8adeuHVauXCkpy3vtYmJigtDQUNSvXx8uLi5YunSpVh/NmzeXfJvI29sbS5YsgVqthqGhoVb9AwcOIDg4GNeuXUNSUhKys7ORkZGBtLQ0mJub64zT1dVVTJQCgJOTEx4/fgwAuHnzJtLS0tCxY0dJm8zMTDRq1AgAEBkZiWbNmkm25yZ4C2JkZIQBAwYgNDQUQ4cORWpqKnbs2IFffvlFrBMVFYU5c+bg7NmziIuLE2e13r17V5K0bdKkyXP3lZKSgrlz52LXrl14+PAhsrOzkZ6ejrt370rq1a9fX/y/TCZDxYoVxXEIDw9Ho0aNCrz2vHz5Mk6ePCnOTgYAtVpd6NgTEREREZV3xU7aBgYGYs6cOVi/fj0vhImIiKjcUSgUktmYupw6dQoAEB8fj/j4eCgUihfe3507d9C9e3eMGzcOQUFBsLW1xYkTJzBy5EhkZmYWeL1kbGwseS6TycQEae56uLt27ULlypUl9V72pmpDhgyBj48PHj9+jP3798PMzAydO3cWt/fo0QMuLi5Ys2YNKlWqBI1Gg7p16yIzM1PST2FjNm3aNOzfvx+LFy+Gm5sbzMzM0K9fP61+njcOhd3YLCUlBfPmzdM549fU1PS5bUuTIAhYunQpli9fjtjYWHTq1Anr16+HUqnUW0xERERE9GopdtJ2yZIluHXrFhwdHeHq6qp1oX3p0qUSC46IiIiopN26dQsffvgh1qxZg02bNmHYsGE4cOCAZL3WvDe6AoAzZ86gZs2aOmfZXrx4ERqNBkuWLBH7+PXXX18qRg8PD8jlcty9exc+Pj4669SpUwe//fabVpyFadGiBZydnbFp0yb88ccf6N+/v3g99/TpU1y/fh1r1qxB69atAQAnTpx4oWM4efIkhg8fLq6Vm5KSUuiN0vKrX78+vv/+e8THx+ucbdu4cWNcv3690CR9WZs+fTp27NiB9evXQ6FQoFevXpg7d67OWd1ERERERLoUO2nbq1evUgiDiIiIqGSoVCo8evRIUmZkZAQ7Ozuo1Wq888478PPzw4gRI9C5c2fUq1cPS5YswfTp08X6d+/exZQpUzBmzBhcunQJy5cvF9eOzc/NzQ1ZWVlYvnw5evTogZMnT2LVqlUvdQyWlpaYNm0aPvzwQ2g0GrRq1QqJiYk4efIkrKysMGzYMIwdO1aMe9SoUbh48SLWrVtXpP4HDx6MVatW4caNGzh8+LBYbmNjgwoVKuC7776Dk5MT7t69i48++uiFjqFmzZoICwtDjx49IJPJMHv2bHEGbVENGjQICxcuRK9evRAcHAwnJyf8+eefqFSpEry9vTFnzhx0794dVatWRb9+/WBgYIDLly/j77//xoIFC14o7pd19uxZhISE4MKFC2jcuDEAYPTo0QgNDWXSloiIiIiKrNhJW97UgYiIiMqzPXv2wMnJSVJWu3ZtXLt2DUFBQYiJicHOnTsB5Kwj+91332HQoEHo1KmTeOOsgIAApKeno2nTpjA0NMTkyZPx3nvv6dxfgwYNEBISgkWLFmHWrFlo06YNgoODERAQ8FLHERgYCHt7ewQHB+P27duwtrZG48aNxRuqVa1aFVu3bsWHH36I5cuXo2nTpli4cCHefffdQvseMmQIgoKC4OLiIrm5rIGBAX755RdMmjQJdevWRe3atfH111+jbdu2xY4/JCQE7777Llq0aAE7OzvMnDkTSUlJxerDxMQE+/btw9SpU9G1a1dkZ2fDw8MDK1asAJBzY7WdO3di/vz5WLRoEYyNjeHu7o5Ro0YVO96SsnjxYrRv315M2AKAo6Mj4uLi9BYTEREREb16ZIIgCPoO4nWVlJQEpVKJxMREWFlZlck+eyx/sa8wEtGr5ff3W+k7BHrNZWRkIDo6GtWqVdPr2qD60LZtWzRs2BDLli3TdyhUwp53XpfEdZtKpYKNjQ0WL16M8ePHi+VfffUVvvrqK9y+fful4s+7H5VKJT5PSkqCs7MzWgfuhJHpi6/PTEREr6ZD09rqOwQiKoaiXncaFLilAGq1GosXL0bTpk1RsWJF2NraSh5ERERERG+iS5cuIT09HVOnToWFhYX4mDFjBmrVqgUA6N27N2xsbNCvXz9J2507d6J27dqoWbMmvv/+++fuJzg4GEqlUnw4OzuX2jERERERkX4UO2k7b948hISEwN/fH4mJiZgyZQr69OkDAwMDzJ07txRCJCIiIiIq/27cuAGFQoErV64gPDxcfLi6uorLUEyePBk//vijpF12djamTJmCQ4cO4c8//8SXX36Jp0+fFrifWbNmITExUXzcu3evVI+LiIiIiMpesde0DQ0NxZo1a9CtWzfMnTsXgwYNQo0aNVC/fn2cOXMGkyZNKo04iYiIiMrEkSNH9B0CvaKSkpJgZ2cHNzc3sSwmJgZRUVHo27cvgJzlN/KfY+fOnYOnpycqV64MAOjSpQv27duHQYMG6dyPXC6HXC4vnYMgIiIionKh2DNtHz16hHr16gEALCwskJiYCADo3r07du3aVbLRERERERG9Iuzs7JCYmIi8t4wICgpC165d4eHhUWC7Bw8eiAlbAKhcuTLu379fqrESERERUflW7KRtlSpV8PDhQwBAjRo1sG/fPgDA+fPn+Rd/IiIiInpj+fr6IiMjA59//jmio6OxYMEC/P7771i5cqW+QyMiIiKiV0yxk7a9e/+fvXuPi6ra/z/+5joIyKCiKEpCkhpkmXjJVLxAkpgGaqJ18pIHrcwuopanMrt4KyMrC7NOYR37hXaxULNMLbUUC8PMLKljal4zc1AUVNi/P/oyxwlUUGA28Ho+Hvtxzqy99tqfPQ67Dx/WrJ2gVatWSZLGjRunRx99VFdccYWGDRumO+64o8IDBAAAznP2jEGguqvsz3NgYKDS0tKUmpqqiIgIbdy4UevXr7/gg8KCgoIcZtbu3btXQUFBlRorAAAAzK3ca9rOnDnT/v8TExN12WWXacOGDbriiivUr1+/Cg0OAAA4h4eHh1xcXPT777+rYcOGcnFxcXZIwCUxDEO///67XFxc5OHhUWnnSUxMVGJiYrmO6dixo77//nvt3btXVqtVH3/8sR599NFKihAAAADVQbmLtn/XuXNnde7cuSJiAQAAJuHm5qZmzZrpt99+06+//urscIAK4eLiombNmsnNzc1pMcTExGjLli3Ky8tTs2bNtHjxYnXu3FnPPvusevbsqaKiIk2aNEkNGjRwWowAAABwvjIVbT/66CP16dNHHh4e+uijj87bt3///hUSGAAAcC5fX19dccUVOn36tLNDASqEh4eHUwu2kvTZZ5+V2t6/f3/yaAAAANiVqWgbHx+vAwcOqFGjRoqPjz9nPxcXFxUWFlZUbAAAwMnc3NycXuQCAAAAgNqmTEXboqKiUv8/AAAAAAAAAKBiuZan8+nTpxUdHa2cnJzKigcAAAAAAAAAarVyPYjMw8ND3333XWXFAgAAAOAiLb23m/z8/JwdBgAAACpAuWbaStI//vEP/fvf/66MWAAAAAAAAACg1ivXTFtJOnPmjF5//XV99tlnioyMlI+Pj8P+lJSUCgsOAAAAAAAAAGqbchdtv//+e7Vr106StGPHDod9Li4uFRMVAAAAAAAAANRS5S7arlmzpjLiAAAAAAAAAADoIta0rQwvvfSSQkJC5OXlpU6dOmnTpk1lOu6dd96Ri4uL4uPjHdoNw9CUKVPUpEkT1alTRzExMcrJyXHoc+TIEd12223y8/OTv7+/Ro0apePHjzv0+e6779StWzd5eXkpODhYTz/99CVdJwAAAAAAAABcSLln2krSN998o0WLFmn37t06deqUw77333+/XGOlp6dr/Pjxmjdvnjp16qQ5c+YoNjZWP/30kxo1anTO43799VdNmDBB3bp1K7Hv6aef1gsvvKAFCxYoNDRUjz76qGJjY/XDDz/Iy8tLknTbbbdp//79WrlypU6fPq2RI0dq9OjRevvttyVJubm56t27t2JiYjRv3jxt3bpVd9xxh/z9/TV69OhyXSMAAABQ2W56YZ3cvXwu3BEAYFqrJ/RwdggATKLcM23feecdXX/99dq+fbs++OADnT59Wtu2bdPq1atltVrLHUBKSoqSkpI0cuRIhYeHa968efL29tbrr79+zmMKCwt122236fHHH9fll1/usM8wDM2ZM0ePPPKIbr75Zl199dV68803tW/fPi1ZskSStH37dq1YsUKvvfaaOnXqpK5du+rFF1/UO++8o3379kmSFi5cqFOnTun1119XRESEhgwZonvvvZcHrQEAAAAAAACoVOUu2k6fPl3PPfecMjIy5Onpqeeff14//vijBg8erMsuu6xcY506dUpZWVmKiYn5X0CuroqJidGGDRvOedwTTzyhRo0aadSoUSX27dy5UwcOHHAY02q1qlOnTvYxN2zYIH9/f7Vv397eJyYmRq6ursrMzLT3iYqKkqenp71P8QzgP//8s9S4CgoKlJub67ABAAAAAAAAQHmUu2j7yy+/qG/fvpIkT09P5eXlycXFRQ888IDmz59frrEOHz6swsJCBQYGOrQHBgbqwIEDpR6zfv16/fvf/9arr75a6v7i48435oEDB0osveDu7q769es79CltjLPP8XczZsyQ1Wq1b8HBwaX2AwAAAAAAAIBzKXfRtl69ejp27JgkqWnTpvr+++8lSUePHtWJEycqNrq/OXbsmG6//Xa9+uqrCggIqNRzXYzJkyfLZrPZtz179jg7JAAAAAAAAADVTLkfRBYVFaWVK1eqTZs2uuWWW3Tfffdp9erVWrlypaKjo8s1VkBAgNzc3HTw4EGH9oMHD6px48Yl+v/yyy/69ddf1a9fP3tbUVHRXxfi7q6ffvrJftzBgwfVpEkThzHbtm0rSWrcuLEOHTrkMPaZM2d05MgR+/GNGzcuNa7ifaWxWCyyWCwXvG4AAAAAAAAAOJcyz7QtnlE7d+5cDRkyRJL08MMPa/z48Tp48KAGDhyof//73+U6uaenpyIjI7Vq1Sp7W1FRkVatWqXOnTuX6N+6dWtt3bpV2dnZ9q1///7q2bOnsrOzFRwcrNDQUDVu3NhhzNzcXGVmZtrH7Ny5s44ePaqsrCx7n9WrV6uoqEidOnWy91m7dq1Onz5t77Ny5Uq1atVK9erVK9d1AgAAAAAAAEBZlbloe/XVV6tTp0567733VLdu3b8OdnXVQw89pI8++kjPPvvsRRUzx48fr1dffVULFizQ9u3bdddddykvL08jR46UJA0bNkyTJ0+WJHl5eemqq65y2Pz9/VW3bl1dddVV8vT0lIuLi+6//3499dRT+uijj7R161YNGzZMQUFBio+PlyRdeeWVuvHGG5WUlKRNmzbpyy+/1D333KMhQ4YoKChIknTrrbfK09NTo0aN0rZt25Senq7nn39e48ePL/c1AgAAAJJkGIZSUlIUGhoqb29vxcfHy2azOTssAAAAmEyZi7ZffPGFIiIilJycrCZNmmj48OFat27dJQeQmJio2bNna8qUKWrbtq2ys7O1YsUK+0O/du/erf3795drzEmTJmncuHEaPXq0OnTooOPHj2vFihXy8vKy91m4cKFat26t6OhoxcXFqWvXrg4PUrNarfr000+1c+dORUZGKjk5WVOmTNHo0aMv+ZoBAABQO02cOFGpqalasGCB1q1bp6ysLE2dOtXZYQEAAMBkXAzDMMpzQF5enhYtWqS0tDStW7dOYWFhGjVqlIYPH37OtV5rq9zcXFmtVtlsNvn5+VXJOfu9uL5KzgPAuTLGdXV2CABQo1RF3la8XNc333yjdu3aSZKeeOIJLVy4UD/99NNFj1sce7cnl8rdy6eiwgUAOMHqCT2cHQKASlbWvLPMM22L+fj4aOTIkfriiy+0Y8cO3XLLLXrppZd02WWXqX///pcUNAAAAFBTzZ49W9HR0faCrSQFBgbq8OHDTowKAAAAZlTuou3ZwsLC9K9//UuPPPKI6tatq2XLllVUXAAAAECNUVBQoGXLlikhIcGhPT8/X1ar1UlRAQAAwKzcL/bAtWvX6vXXX9d7770nV1dXDR48WKNGjarI2AAAAIAaYfPmzTp58qSSk5M1adIke/vp06fVs2dPHT16VDExMTpz5ozOnDmj++67T0lJSaWOVVBQoIKCAvvr3NzcSo8fAAAAVatcRdt9+/YpLS1NaWlp+vnnn3X99dfrhRde0ODBg+Xjw/pZAAAAQGl27NghHx8fZWdnO7T37dtXXbp0Ud26dbV27Vp5e3srLy9PV111lQYMGKAGDRqUGGvGjBl6/PHHqyhyAAAAOEOZi7Z9+vTRZ599poCAAA0bNkx33HGHWrVqVZmxAQAAADVCbm6uAgICFBYWZm/btWuXcnJyNHDgQLm5ucnb21vSXzNpDcPQuZ4XPHnyZI0fP95h7ODg4Mq9AAAAAFSpMhdtPTw89O677+qmm26Sm5tbZcYEAAAA1CgBAQGy2WwyDEMuLi6SpGnTpikuLk7h4eGSpKNHj6p79+7KycnRM888o4CAgFLHslgsslgsVRY7AAAAql6Zi7YfffRRZcYBAAAA1Fi9evVSfn6+Zs6cqSFDhmjhwoXKyMjQpk2b7H38/f21ZcsWHTx4UAMGDNCgQYMUGBjoxKgBAADgLK7ODgAAAACo6QIDA5WWlqbU1FRFRERo48aNWr9+fanLGgQGBuqaa67RunXrnBApAAAAzICiLQAAAFAFEhMTtXv3bp04cUJLly5VixYt7PsOHjyoY8eOSZJsNpvWrl3L8yMAAABqsTIvjwAAAACgcuzatUujR4+2P4Bs3LhxatOmjbPDAgAAgJNQtAUAAACcrGPHjsrOznZ2GAAAADAJlkcAAAAAAAAAABOhaAsAAAAAAAAAJkLRFgAAAAAAAABMhKItAAAAAAAAAJgIDyIDAAAAaoCl93aTn5+fs8MAAABABWCmLQAAAAAAAACYCEVbAAAAAAAAADARirYAAAAAAAAAYCIUbQEAAAAAAADARCjaAgAAAAAAAICJuDs7AAAAAACX7qYX1sndy8fZYQAAzrJ6Qg9nhwCgmmKmLQAAAAAAAACYCEVbAAAAAAAAADARirYAAAAAAAAAYCIUbQEAAAAAAADARCjaAgAAAAAAAICJULQFAAAAAAAAABOhaAsAAABUEcMwlJKSotDQUHl7eys+Pl42m83ZYQEAAMBkKNoCAAAAVWTixIlKTU3VggULtG7dOmVlZWnq1KnODgsAAAAmQ9EWAAAAqAKZmZlKSUlRenq6oqKiFBkZqaSkJC1fvtzZoQEAAMBkKNoCAAAAVWD27NmKjo5Wu3bt7G2BgYE6fPiwE6MCAACAGVG0BQAAACpZQUGBli1bpoSEBIf2/Px8Wa3Wco+Vm5vrsAEAAKBmcXd2AAAAAEBNt3nzZp08eVLJycmaNGmSvf306dPq2bOnJCkkJER+fn5ydXVVvXr1tGbNmlLHmjFjhh5//PEqiRsAAADOQdEWAAAAqGQ7duyQj4+PsrOzHdr79u2rLl262F9/9dVX8vX1Pe9YkydP1vjx4+2vc3NzFRwcXKHxAgAAwLko2gIAAACVLDc3VwEBAQoLC7O37dq1Szk5ORo4cGC5xrJYLLJYLBUdIgAAAEyENW0BAACAShYQECCbzSbDMOxt06ZNU1xcnMLDwyVJLi4u6t69uzp06KCFCxc6K1QAAACYADNtAQAAgErWq1cv5efna+bMmRoyZIgWLlyojIwMbdq0yd5n/fr1atq0qfbv36+YmBi1adNGV199tROjBgAAgLMw0xYAAACoZIGBgUpLS1NqaqoiIiK0ceNGrV+/3mEt2qZNm0qSmjRpori4OG3evNlZ4QIAAMDJmGkLAAAAVIHExEQlJiaWui8vL09FRUWqW7eujh8/rtWrV2vw4MFVHCEAAADMgqItAAAA4GQHDx5UQkKCJKmwsFBJSUnq0KGDk6MCAACAs1C0BQAAAJzs8ssv15YtW5wdBgAAAEyCNW0BAAAAAAAAwEQo2gIAAAAAAACAiVC0BQAAAAAAAAAToWgLAAAAAAAAACbCg8gAAACAGmDpvd3k5+fn7DAAAABQAZhpCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAi7s4OAAAAAMClu+mFdXL38nF2GAAq0OoJPZwdAgDASZhpCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAVyDAMpaSkKDQ0VN7e3oqPj5fNZnN2WAAAAKhGKNoCAAAAFWjixIlKTU3VggULtG7dOmVlZWnq1KnODgsAAADVCEVbAAAAoIJkZmYqJSVF6enpioqKUmRkpJKSkrR8+XJnhwYAAIBqhKItAAAAUEFmz56t6OhotWvXzt4WGBiow4cPOzEqAAAAVDcUbQEAAIAKUFBQoGXLlikhIcGhPT8/X1artULPk5ub67ABAACgZqFoCwAAAFSAzZs36+TJk0pOTpavr699mzRpklq2bClJSkhIUL169TRo0KASx584cULNmzfXhAkTznueGTNmyGq12rfg4OBKuR4AAAA4D0VbAAAAoALs2LFDPj4+2rp1q7Kzs+1bSEiIunTpIkm677779Oabb5Z6/LRp03Tddddd8DyTJ0+WzWazb3v27KnQ6wAAAIDzUbQFAAAAKkBubq4CAgIUFhZm3zw8PJSTk6OBAwdKknr06KG6deuWODYnJ0c//vij+vTpc8HzWCwW+fn5OWwAAACoWSjaAgAAABUgICBANptNhmHY26ZNm6a4uDiFh4ef99gJEyZoxowZlR0iAAAAqgmKtgAAAEAF6NWrl/Lz8zVz5kzt3LlTTz31lDIyMpSamnre4z788EO1bNnSvu4tAAAA4O7sAAAAAICaIDAwUGlpaZo4caKefPJJ9erVS+vXr7/gg8I2btyod955R4sXL9bx48d1+vRp+fn5acqUKVUUOQAAAMzGFDNtX3rpJYWEhMjLy0udOnXSpk2bztn31VdfVbdu3VSvXj3Vq1dPMTExJfobhqEpU6aoSZMmqlOnjmJiYpSTk+PQ58iRI7rtttvk5+cnf39/jRo1SsePH3fo891336lbt27y8vJScHCwnn766Yq7aAAAANQ4iYmJ2r17t06cOKGlS5eqRYsWFzxmxowZ2rNnj3799VfNnj1bSUlJFGwBAABqOacXbdPT0zV+/Hg99thj2rx5s6655hrFxsbq0KFDpfb//PPPNXToUK1Zs0YbNmxQcHCwevfurb1799r7PP3003rhhRc0b948ZWZmysfHR7GxscrPz7f3ue2227Rt2zatXLlSS5cu1dq1azV69Gj7/tzcXPXu3VvNmzdXVlaWnnnmGU2dOlXz58+vvDcDAAAANVpMTIxuueUWLV++XM2aNdOGDRucHRIAAABMyMU4+0kJTtCpUyd16NBBc+fOlSQVFRUpODhY48aN00MPPXTB4wsLC1WvXj3NnTtXw4YNk2EYCgoKUnJysiZMmCBJstls9q+rDRkyRNu3b1d4eLi+/vprtW/fXpK0YsUKxcXF6bffflNQUJBSU1P18MMP68CBA/L09JQkPfTQQ1qyZIl+/PHHMl1bbm6urFarbDZblT3Vt9+L66vkPACcK2NcV2eHAAA1ijPytopSHHu3J5fK3cvH2eEAqECrJ/RwdggAgApW1rzTqTNtT506paysLMXExNjbXF1dFRMTU+ZZBydOnNDp06dVv359SdLOnTt14MABhzGtVqs6depkH3PDhg3y9/e3F2ylv2Y9uLq6KjMz094nKirKXrCVpNjYWP3000/6888/L/6iAQAAAAAAAOA8nFq0PXz4sAoLCxUYGOjQHhgYqAMHDpRpjAcffFBBQUH2Im3xcecb88CBA2rUqJHDfnd3d9WvX9+hT2ljnH2OvysoKFBubq7DBgAAAAAAAADl4fQ1bS/FzJkz9c477+iDDz6Ql5eXs8PRjBkzZLVa7duFnhQMAAAAAAAAAH/n1KJtQECA3NzcdPDgQYf2gwcPqnHjxuc9dvbs2Zo5c6Y+/fRTXX311fb24uPON2bjxo1LPOjszJkzOnLkiEOf0sY4+xx/N3nyZNlsNvu2Z8+e814DAAAAAAAAAPyduzNP7unpqcjISK1atUrx8fGS/noQ2apVq3TPPfec87inn35a06ZN0yeffOKwLq0khYaGqnHjxlq1apXatm0r6a8FfjMzM3XXXXdJkjp37qyjR48qKytLkZGRkqTVq1erqKhInTp1svd5+OGHdfr0aXl4eEiSVq5cqVatWqlevXqlxmWxWGSxWC76/QAAAAAu1tJ7u1W7h6gBAACgdE5fHmH8+PF69dVXtWDBAm3fvl133XWX8vLyNHLkSEnSsGHDNHnyZHv/WbNm6dFHH9Xrr7+ukJAQHThwQAcOHNDx48clSS4uLrr//vv11FNP6aOPPtLWrVs1bNgwBQUF2QvDV155pW688UYlJSVp06ZN+vLLL3XPPfdoyJAhCgoKkiTdeuut8vT01KhRo7Rt2zalp6fr+eef1/jx46v2DQIAAAAAAABQqzh1pq0kJSYm6vfff9eUKVN04MABtW3bVitWrLA/9Gv37t1ydf1fbTk1NVWnTp3SoEGDHMZ57LHHNHXqVEnSpEmTlJeXp9GjR+vo0aPq2rWrVqxY4bDu7cKFC3XPPfcoOjparq6uGjhwoF544QX7fqvVqk8//VRjx45VZGSkAgICNGXKFI0ePboS3w0AAAAAAAAAtZ2LYRiGs4OoqXJzc2W1WmWz2arsq2r9XlxfJecB4FwZ47o6OwQAqFGckbdVlOocOwAAQG1T1tzN6csjAAAAAAAAAAD+h6ItAAAAAAAAAJiI09e0BQAAAHDpbnphndy9fJwdRpmtntDD2SEAAACYFjNtAQAAAAAAAMBEKNoCAAAAAAAAgIlQtAUAAAAAAAAAE6FoCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAKCKGIahlJQUhYaGytvbW/Hx8bLZbM4OCwAAACZD0RYAAACoIhMnTlRqaqoWLFigdevWKSsrS1OnTnV2WAAAADAZirYAAABAFcjMzFRKSorS09MVFRWlyMhIJSUlafny5c4ODQAAACZD0RYAAACoArNnz1Z0dLTatWtnbwsMDNThw4edGBUAAADMiKItAAAAUMkKCgq0bNkyJSQkOLTn5+fLarWWe6zc3FyHDQAAADWLu7MDAACgPPq9uN7ZIQCoIhnjujo7hAqzefNmnTx5UsnJyZo0aZK9/fTp0+rZs6ck6bnnntNrr70mwzAUExOj559/Xi4uLiXGmjFjhh5//PEqix0AAABVj5m2AAAAQCXbsWOHfHx8tHXrVmVnZ9u3kJAQdenSRb///rvmzp2rrKwsbd26VVlZWdq4cWOpY02ePFk2m82+7dmzp4qvBgAAAJWNmbYAAABAJcvNzVVAQIDCwsLsbbt27VJOTo4GDhwoSTpz5ozy8/Ml/TUDt1GjRqWOZbFYZLFYKj9oAAAAOA1FWwAAAKCSBQQEyGazyTAM+5IH06ZNU1xcnMLDwyVJEyZM0GWXXSZ3d3fdeeedatGihTNDBgAAgBOxPAIAAABQyXr16qX8/HzNnDlTO3fu1FNPPaWMjAylpqZKkv78808tXbpUv/76q/bu3auvvvpKa9eudXLUAAAAcBaKtgAAAEAlCwwMVFpamlJTUxUREaGNGzdq/fr1Cg4OliR99tlnCgsLU/369VWnTh317dv3nGvaAgAAoOajaAsAAABUgcTERO3evVsnTpzQ0qVLHZY/CA4O1ldffaX8/HwVFhbq888/V6tWrZwYLQAAAJyJNW0BAAAAJ7vuuusUFxena6+9Vq6uroqOjlb//v2dHRYAAACchKItAAAAYALTpk3TtGnTnB0GAAAATIDlEQAAAAAAAADARCjaAgAAAAAAAICJULQFAAAAAAAAABNhTVsAAACgBlh6bzf5+fk5OwwAAABUAGbaAgAAAAAAAICJULQFAAAAAAAAABOhaAsAAAAAAAAAJkLRFgAAAAAAAABMhKItAAAAAAAAAJgIRVsAAAAAAAAAMBF3ZwcAAAAA4NLd9MI6uXv5VNn5Vk/oUWXnAgAAqG2YaQsAAAAAAAAAJkLRFgAAAAAAAABMhKItAAAAAAAAAJgIRVsAAAAAAAAAMBGKtgAAAAAAAABgIhRtAQAAAAAAAMBEKNoCAAAAVcQwDKWkpCg0NFTe3t6Kj4+XzWZzdlgAAAAwGYq2AAAAQBWZOHGiUlNTtWDBAq1bt05ZWVmaOnWqs8MCAACAyVC0BQAAAKpAZmamUlJSlJ6erqioKEVGRiopKUnLly93dmgAAAAwGYq2AAAAQBWYPXu2oqOj1a5dO3tbYGCgDh8+7MSoAAAAYEYUbQEAAIBKVlBQoGXLlikhIcGhPT8/X1artdxj5ebmOmwAAACoWSjaAgAAAJVs8+bNOnnypJKTk+Xr62vfJk2apJYtW+qnn35S27Zt7VudOnW0ZMmSUseaMWOGrFarfQsODq7aiwEAAEClc3d2AAAAAEBNt2PHDvn4+Cg7O9uhvW/fvurSpYtatWpl33f8+HGFhITohhtuKHWsyZMna/z48fbXubm5FG4BAABqGIq2AAAAQCXLzc1VQECAwsLC7G27du1STk6OBg4c6ND3o48+UnR0tHx8fEody2KxyGKxVGq8AAAAcC6WRwAAAAAqWUBAgGw2mwzDsLdNmzZNcXFxCg8Pd+i7aNEiJSYmVnWIAAAAMBFm2gIAAACVrFevXsrPz9fMmTM1ZMgQLVy4UBkZGdq0aZNDv9zcXH311Vd65513nBQpAAAAzICZtgAAAEAlCwwMVFpamlJTUxUREaGNGzdq/fr1Jdai/fDDD9W7d295eXk5KVIAAACYATNtAQAAgCqQmJh4wWUPFi1apNGjR1dRRAAAADArZtoCAAAAJmCz2bRp0ybFxsY6OxQAAAA4GTNtAQAAABOwWq06ePCgs8MAAACACTDTFgAAAAAAAABMhKItAAAAAAAAAJgIRVsAAAAAAAAAMBHWtAUAAABqgKX3dpOfn5+zwwAAAEAFYKYtAAAAAAAAAJgIRVsAAAAAAAAAMBGKtgAAAAAAAABgIhRtAQAAAAAAAMBEKNoCAAAAAAAAgIlQtAUAAAAAAAAAE6FoCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAAAACAiZiiaPvSSy8pJCREXl5e6tSpkzZt2nTe/osXL1br1q3l5eWlNm3aaPny5Q77DcPQlClT1KRJE9WpU0cxMTHKyclx6HPkyBHddttt8vPzk7+/v0aNGqXjx4879Pnuu+/UrVs3eXl5KTg4WE8//XTFXDAAAAAAAAAAnIPTi7bp6ekaP368HnvsMW3evFnXXHONYmNjdejQoVL7f/XVVxo6dKhGjRqlb7/9VvHx8YqPj9f3339v7/P000/rhRde0Lx585SZmSkfHx/FxsYqPz/f3ue2227Ttm3btHLlSi1dulRr167V6NGj7ftzc3PVu3dvNW/eXFlZWXrmmWc0depUzZ8/v/LeDAAAAAAAAAC1nothGIYzA+jUqZM6dOiguXPnSpKKiooUHByscePG6aGHHirRPzExUXl5eVq6dKm97brrrlPbtm01b948GYahoKAgJScna8KECZIkm82mwMBApaWlaciQIdq+fbvCw8P19ddfq3379pKkFStWKC4uTr/99puCgoKUmpqqhx9+WAcOHJCnp6ck6aGHHtKSJUv0448/lunacnNzZbVaZbPZ5Ofnd0nvU1n1e3F9lZwHgHNljOvq7BCchvscUHtU5b3OGXlbRanOsQMAANQ2Zc3d3KswphJOnTqlrKwsTZ482d7m6uqqmJgYbdiwodRjNmzYoPHjxzu0xcbGasmSJZKknTt36sCBA4qJibHvt1qt6tSpkzZs2KAhQ4Zow4YN8vf3txdsJSkmJkaurq7KzMxUQkKCNmzYoKioKHvBtvg8s2bN0p9//ql69eqViK2goEAFBQX21zabTdJf/xhV5fTJvCo7FwDnqcr7itlwnwNqj6q81xWfy8nzGS5Kccy1+b8NAAAA1UVZ806nFm0PHz6swsJCBQYGOrQHBgaeczbrgQMHSu1/4MAB+/7itvP1adSokcN+d3d31a9f36FPaGhoiTGK95VWtJ0xY4Yef/zxEu3BwcGlXgsAXCzrg86OAAAqnzPudceOHZPVaq36E1+CY8eOSSLnBAAAqE4ulHc6tWhb00yePNlhFnBRUZGOHDmiBg0ayMXFxYmRoSbLzc1VcHCw9uzZw1ciAdRI3OdQFQzD0LFjxxQUFOTsUMotKChIe/bsUd26dcudc3bo0EFff/11hcdUkeNWxFjcR2qOyvrMVkfV/b0wY/zOiqkqzlsd7vcVMR73+5rFjPeJilDWvNOpRduAgAC5ubnp4MGDDu0HDx5U48aNSz2mcePG5+1f/L8HDx5UkyZNHPq0bdvW3ufvDzo7c+aMjhw54jBOaec5+xx/Z7FYZLFYHNr8/f1L7QtUND8/P/6jBKBG4z6HylbdZtgWc3V1VbNmzS7qWDc3t0r5uarIcStyLO4j1V9lfWaro+r+XpgxfmfFVBXnrQ73+4ocj/t9zWDG+0RFKUve6VoFcZyTp6enIiMjtWrVKntbUVGRVq1apc6dO5d6TOfOnR36S9LKlSvt/UNDQ9W4cWOHPrm5ucrMzLT36dy5s44ePaqsrCx7n9WrV6uoqEidOnWy91m7dq1Onz7tcJ5WrVqVujQCAAAAUN2MHTvW9ONWVoyonvg8/E91fy/MGL+zYqqK81aH+31ljIfqrbZ/HlwMJz9tIT09XcOHD9crr7yijh07as6cOVq0aJF+/PFHBQYGatiwYWratKlmzJghSfrqq6/UvXt3zZw5U3379tU777yj6dOna/PmzbrqqqskSbNmzdLMmTO1YMEChYaG6tFHH9V3332nH374QV5eXpKkPn366ODBg5o3b55Onz6tkSNHqn379nr77bcl/fUQsVatWql379568MEH9f333+uOO+7Qc889p9GjRzvnzQJKwROjAdR03OcAXCruIwBQO3C/R03i9DVtExMT9fvvv2vKlCk6cOCA2rZtqxUrVtgf+rV79265uv5vQvD111+vt99+W4888oj+9a9/6YorrtCSJUvsBVtJmjRpkvLy8jR69GgdPXpUXbt21YoVK+wFW0lauHCh7rnnHkVHR8vV1VUDBw7UCy+8YN9vtVr16aefauzYsYqMjFRAQICmTJlCwRamY7FY9Nhjj5VYmgMAagrucwAuFfcRAKgduN+jJnH6TFsAAAAAAAAAwP84dU1bAAAAAAAAAIAjirYAAAAAAAAAYCIUbQEAAAAAAADARCjaAgAAAAAAAICJULQFTGjEiBFycXGRi4uLPD09FRYWpieeeEJnzpyRJBmGofnz56tTp07y9fWVv7+/2rdvrzlz5ujEiRP2cRYvXqzWrVvLy8tLbdq00fLly511SQDgoCLuc9u2bdPAgQMVEhIiFxcXzZkzx4lXBKAivfTSSwoJCZGXl5c6deqkTZs2nbf/hXKe999/X71791aDBg3k4uKi7OzsEmPk5+dr7NixatCggXx9fTVw4EAdPHjQoc/u3bvVt29feXt7q1GjRpo4caL9vgUAKL/y3O/LmvtdaEzu96guKNoCJnXjjTdq//79ysnJUXJysqZOnapnnnlGknT77bfr/vvv180336w1a9YoOztbjz76qD788EN9+umnkqSvvvpKQ4cO1ahRo/Ttt98qPj5e8fHx+v777515WQBgd6n3uRMnTujyyy/XzJkz1bhxY2deCoAKlJ6ervHjx+uxxx7T5s2bdc011yg2NlaHDh0qtX9Zcp68vDx17dpVs2bNOud5H3jgAWVkZGjx4sX64osvtG/fPg0YMMC+v7CwUH379tWpU6f01VdfacGCBUpLS9OUKVMq7uIBoBYp7/2+LLlfWcbkfo9qwwBgOsOHDzduvvlmh7YbbrjBuO6664z09HRDkrFkyZISxxUVFRlHjx41DMMwBg8ebPTt29dhf6dOnYwxY8ZUWtwAUFYVcZ87W/PmzY3nnnuukqIFUJU6duxojB071v66sLDQCAoKMmbMmFFq//LkPDt37jQkGd9++61D+9GjRw0PDw9j8eLF9rbt27cbkowNGzYYhmEYy5cvN1xdXY0DBw7Y+6Smphp+fn5GQUFBua8TAGq78t7vz3au3O9CY3K/R3XCTFugmqhTp45OnTqlhQsXqlWrVrr55ptL9HFxcZHVapUkbdiwQTExMQ77Y2NjtWHDhiqJFwDKq7z3OQA1z6lTp5SVleWQw7i6uiomJuacOUxF5DxZWVk6ffq0wzitW7fWZZddZh9nw4YNatOmjQIDAx3Ok5ubq23btpX5XACAi7vfV8SY3O9RnVC0BUzOMAx99tln+uSTT9SrVy/l5OSoVatWFzzuwIEDDv+RkaTAwEAdOHCgskIFgItysfc5ADXP4cOHVVhYWK4cpiJyngMHDsjT01P+/v7nHOdc5yneBwAou4u531fEmNzvUZ1QtAVMaunSpfL19ZWXl5f69OmjxMRETZ06VYZhODs0AKgQ3OcAAAAAoHTuzg4AQOl69uyp1NRUeXp6KigoSO7uf/24tmzZUj/++OMFj2/cuHGJJ2AePHiQh/UAMI1Lvc8BqHkCAgLk5uZWrhymInKexo0b69SpUzp69KjD7Kuzx2ncuHGJJ5AXn5f8CgDK52Lu9xUxJvd7VCfMtAVMysfHR2FhYbrsssvshQxJuvXWW7Vjxw59+OGHJY4xDEM2m02S1LlzZ61atcph/8qVK9W5c+fKDRwAyuhS73MAah5PT09FRkY65DBFRUVatWrVOXOYish5IiMj5eHh4TDOTz/9pN27d9vH6dy5s7Zu3erwBPKVK1fKz89P4eHhZT4XAODi7vcVMSb3e1QnzLQFqpnBgwfrgw8+0NChQ/XII4+od+/eatiwobZu3arnnntO48aNU3x8vO677z51795dzz77rPr27at33nlH33zzjebPn+/sSwCA8yrrfe7UqVP64YcfJP314Im9e/cqOztbvr6+CgsLc/JVALhY48eP1/Dhw9W+fXt17NhRc+bMUV5enkaOHClJGjZsmJo2baoZM2ZIUplyniNHjmj37t3at2+fpL9+QZf+mjHVuHFjWa1WjRo1SuPHj1f9+vXl5+encePGqXPnzrruuuskSb1791Z4eLhuv/12Pf300zpw4IAeeeQRjR07VhaLpSrfIgCoEcp7vy9L7nehMbnfo1oxAJjO8OHDjZtvvvmc+wsLC43U1FSjQ4cOhre3t+Hn52dERkYazz//vHHixAl7v0WLFhktW7Y0PD09jYiICGPZsmVVED0AXFhF3Od27txpSCqxde/evWouAkClefHFF43LLrvM8PT0NDp27Ghs3LjRvq979+7G8OHDHfpfKOd54403Sr1fPPbYY/Y+J0+eNO6++26jXr16hre3t5GQkGDs37/fYZxff/3V6NOnj1GnTh0jICDASE5ONk6fPl3h1w8AtUV57vdlzf3ON6ZhcL9H9eFiGDztAwAAAAAAAADMgjVtAQAAAAAAAMBEKNoCAAAAAAAAgIlQtAUAAAAAAAAAE6FoCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAMAlS0tLk7+/f7mOMQxDo0ePVv369eXi4qLs7Gz16NFD999/f6XECADVBUVbAAAAAABwyRITE7Vjx45yHbNixQqlpaVp6dKl2r9/v6666qpKig4Aqhd3ZwcAAAAAAACqvzp16qhOnTrlOuaXX35RkyZNdP3111dSVABQPTHTFgAAAACAWujdd99VmzZtVKdOHTVo0EAxMTHKy8uTJBUWFmr8+PHy9/dXgwYNNGnSJA0fPlzx8fHnHO/vyyNMnTpVbdu21VtvvaWQkBBZrVYNGTJEx44dkySNGDFC48aN0+7du+Xi4qKQkJBSx3VxcdGSJUsc2vz9/ZWWlmZ/vWfPHg0ePFj+/v6qX7++br75Zv3666/2/SNGjFB8fLxmz56tJk2aqEGDBho7dqxOnz5t71NQUKAHH3xQwcHBslgsCgsL07///W/7/u+//159+vSRr6+vAgMDdfvtt+vw4cPnf5MB4CJRtAUAAAAAoJbZv3+/hg4dqjvuuEPbt2/X559/rgEDBsgwDEnSs88+q7S0NL3++utav369jhw5og8++KDc5/nll1+0ZMkSLV26VEuXLtUXX3yhmTNnSpKef/55PfHEE2rWrJn279+vr7/++qKu5fTp04qNjVXdunW1bt06ffnll/L19dWNN96oU6dO2futWbNGv/zyi9asWaMFCxYoLS3NofA7bNgw/b//9//0wgsvaPv27XrllVfk6+srSTp69Kh69eqla6+9Vt98841WrFihgwcPavDgwRcVMwBcCMsjAAAAAABQy+zfv19nzpzRgAED1Lx5c0lSmzZt7PvnzJmjyZMna8CAAZKkefPm6ZNPPin3eYqKipSWlqa6detKkm6//XatWrVK06ZNk9VqVd26deXm5qbGjRtf9LWkp6erqKhIr732mlxcXCRJb7zxhvz9/fX555+rd+/ekqR69epp7ty5cnNzU+vWrdW3b1+tWrVKSUlJ2rFjhxYtWqSVK1cqJiZGknT55ZfbzzF37lxde+21mj59ur3t9ddfV3BwsHbs2KGWLVtedPwAUBqKtgAAAAAA1DLXXHONoqOj1aZNG8XGxqp3794aNGiQ6tWrJ5vNpv3796tTp072/u7u7mrfvr19Jm5ZhYSE2Au2ktSkSRMdOnSowq5DkrZs2aKff/7Z4TySlJ+fr19++cX+OiIiQm5ubg6xbN26VZKUnZ0tNzc3de/e/ZznWLNmjX3m7dl++eUXirYAKhxFWwAAAAAAahk3NzetXLlSX331lT799FO9+OKLevjhh5WZman69etX2Hk8PDwcXru4uKioqKhcY7i4uJQoFp+9Fu3x48cVGRmphQsXlji2YcOGZYrlQg9QO378uPr166dZs2aV2NekSZMLXwQAlBNr2gIAAAAAUAu5uLioS5cuevzxx/Xtt9/K09NTH3zwgaxWq5o0aaLMzEx73zNnzigrK8spcTZs2FD79++3v87JydGJEyfsr9u1a6ecnBw1atRIYWFhDpvVai3TOdq0aaOioiJ98cUXpe5v166dtm3bppCQkBLn8PHxubQLBIBSULQFAAAAAKCWyczM1PTp0/XNN99o9+7dev/99/X777/ryiuvlCTdd999mjlzppYsWaIff/xRd999t44ePeqUWHv16qW5c+fq22+/1TfffKM777zTYdbsbbfdpoCAAN18881at26ddu7cqc8//1z33nuvfvvttzKdIyQkRMOHD9cdd9yhJUuW2MdYtGiRJGns2LE6cuSIhg4dqq+//lq//PKLPvnkE40cOVKFhYWVct0AajeKtgAAAAAA1DJ+fn5au3at4uLi1LJlSz3yyCN69tln1adPH0lScnKybr/9dg0fPlydO3dW3bp1lZCQ4JRYn332WQUHB6tbt2669dZbNWHCBHl7e9v3e3t7a+3atbrssss0YMAAXXnllRo1apTy8/Pl5+dX5vOkpqZq0KBBuvvuu9W6dWslJSUpLy9PkhQUFKQvv/xShYWF6t27t9q0aaP7779f/v7+cnWltAKg4rkY5V1FHAAAAAAA1DojRozQ0aNHtWTJEmeHAgA1Hn8OAgAAAAAAAAAToWgLAAAAAAAAACbC8ggAAAAAAAAAYCLMtAUAAAAAAAAAE6FoCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAAAACAiVC0BQAAAAAAAAAToWgLAAAAAAAAACZC0RYAAAAAAAAATISiLQAAAAAAAACYCEVbAAAAAAAAADARirYAAAAAAAAAYCIUbQEAVW7q1KlycXG5qGNDQkJ00003VVgsv/76q1xcXJSWllZhY16qzz//XC4uLnr33Xcv6vi0tDS5uLjo119/vajjc3Jy1Lt3b1mtVrm4uGjJkiWXPCYAAABKKs77Pv/88yo5n4uLi6ZOnXpRx1ZFrJfye8K5VPV7DFQUirZAFXJxcSnTVhX/MUlNTdUtt9yiyy67TC4uLhoxYkSp/VatWqU77rhDLVu2lLe3ty6//HL985//1P79+ys9xppg+fLlF50UoeZ7++23NWfOHGeHUcLw4cO1detWTZs2TW+99Zbat2/v7JAAAJWA3LT2ITd19MMPP2jq1Kn8UbqGePnll001EQO4VO7ODgCoTd566y2H12+++aZWrlxZov3KK6+s9FhmzZqlY8eOqWPHjudNch988EEdOXJEt9xyi6644gr997//1dy5c7V06VJlZ2ercePGlR5rdbZ8+XK99NJLJMco1dtvv63vv/9e999/f4WOe/vtt2vIkCGyWCzlPvbkyZPasGGDHn74Yd1zzz0VGhcAwFzITWsfclNHP/zwgx5//HH16NFDISEhzg4Hkh555BE99NBDF3Xsyy+/rICAgBJ/9ImKitLJkyfl6elZARECVYeiLVCF/vGPfzi83rhxo1auXFmivSp88cUX9pkMvr6+5+yXkpKirl27ytX1fxPzb7zxRnXv3l1z587VU089VRXhnteZM2dUVFRUa/4jbBiG8vPzVadOHWeHApNyc3OTm5vbRR37+++/S5L8/f0rMCIAgBmRm1YOclM4U15ennx8fJwdxkVzd3eXu3vFlqpcXV3l5eVVoWMCVYHlEQCTycvLU3JysoKDg2WxWNSqVSvNnj1bhmE49HNxcdE999yjhQsXqlWrVvLy8lJkZKTWrl1bpvM0b968TGsFRUVFOSTFxW3169fX9u3bL3h8jx49dNVVVykrK0vXX3+96tSpo9DQUM2bN8+h36lTpzRlyhRFRkbKarXKx8dH3bp105o1axz6Fa8/Onv2bM2ZM0ctWrSQxWLRDz/8cFFjvPTSS7r88svl7e2t3r17a8+ePTIMQ08++aSaNWumOnXq6Oabb9aRI0dKXNvHH3+sbt26ycfHR3Xr1lXfvn21bds2+/4RI0bopZdekuT49cNiRUVFmjNnjiIiIuTl5aXAwECNGTNGf/75p8N5itdw/eSTT9S+fXvVqVNHr7zyiiRp5cqV6tq1q/z9/eXr66tWrVrpX//61wX/XSrLH3/8odtvv11+fn7y9/fX8OHDtWXLljKtGXvmzBk9+eST9n/TkJAQ/etf/1JBQUGp/T/99FO1bdtWXl5eCg8P1/vvv++w/8iRI5owYYLatGkjX19f+fn5qU+fPtqyZctFXVvxmq5r167VmDFj1KBBA/n5+WnYsGEl/s0+/PBD9e3bV0FBQbJYLGrRooWefPJJFRYW2vv06NFDy5Yt065du+yfjb/P8CgqKtK0adPUrFkzeXl5KTo6Wj///HOZYz37q37Fn6P169erY8eO8vLy0uWXX64333zT3mfq1Klq3ry5JGnixImlxnS2c62JFhISUmKGw9GjR3X//ffb721hYWGaNWuWioqK7H3O/tmcP3++/bPQoUMHff311yXO8+OPP2rw4MFq2LCh6tSpo1atWunhhx926LN3717dcccdCgwMlMViUUREhF5//fXzvHsAgLORm5KbVufc9J133lFkZKTq1q0rPz8/tWnTRs8//7ykv/KlW265RZLUs2fPEsuBlCWfk/73mfrhhx/Us2dPeXt7q2nTpnr66adLxPPbb78pPj5ePj4+atSokR544IFSc91169bZlwuxWCwKDg7WAw88oJMnTzr0GzFihHx9ffXLL78oLi5OdevW1W233SZJKigo0AMPPKCGDRuqbt266t+/v3777bcyv3dljVWSMjMzdeONN8pqtcrb21vdu3fXl19+ad//7rvvysXFRV988UWJY1955RW5uLjo+++/l1T6mrZvvPGGevXqpUaNGslisSg8PFypqakOfUJCQrRt2zZ98cUX9n/LHj16SDr3mraLFy9WZGSk6tSpo4CAAP3jH//Q3r17HfoUv8d79+5VfHy8fH191bBhQ02YMKHEZwGoaMy0BUzEMAz1799fa9as0ahRo9S2bVt98sknmjhxovbu3avnnnvOof8XX3yh9PR03XvvvbJYLHr55Zd14403atOmTbrqqqsqLc7jx4/r+PHjCggIKFP/P//8U3FxcRo8eLCGDh2qRYsW6a677pKnp6fuuOMOSVJubq5ee+01DR06VElJSTp27Jj+/e9/KzY2Vps2bVLbtm0dxnzjjTeUn5+v0aNHy2KxqH79+uUeY+HChTp16pTGjRunI0eO6Omnn9bgwYPVq1cvff7553rwwQf1888/68UXX9SECRMcCj1vvfWWhg8frtjYWM2aNUsnTpxQamqqunbtqm+//VYhISEaM2aM9u3bV+rXDCVpzJgxSktL08iRI3Xvvfdq586dmjt3rr799lt9+eWX8vDwsPf96aefNHToUI0ZM0ZJSUlq1aqVtm3bpptuuklXX321nnjiCVksFv38888OCVJVKioqUr9+/bRp0ybdddddat26tT788EMNHz68TMf/85//1IIFCzRo0CAlJycrMzNTM2bM0Pbt2/XBBx849M3JyVFiYqLuvPNODR8+XG+88YZuueUWrVixQjfccIMk6b///a+WLFmiW265RaGhoTp48KBeeeUVde/eXT/88IOCgoIu6jrvuece+fv7a+rUqfrpp5+UmpqqXbt22ZNB6a9fAnx9fTV+/Hj5+vpq9erVmjJlinJzc/XMM89Ikh5++GHZbDb99ttv9p/tv88smjlzplxdXTVhwgTZbDY9/fTTuu2225SZmXlRsf/8888aNGiQRo0apeHDh+v111/XiBEjFBkZqYiICA0YMED+/v564IEHNHToUMXFxZ13tlNZnThxQt27d9fevXs1ZswYXXbZZfrqq680efJk7d+/v8S6vm+//baOHTumMWPGyMXFRU8//bQGDBig//73v/afi++++07dunWTh4eHRo8erZCQEP3yyy/KyMjQtGnTJEkHDx7UddddZy8kNGzYUB9//LFGjRql3NzcCl+WAgBqGnJTctPqnJuuXLlSQ4cOVXR0tGbNmiVJ2r59u7788kvdd999ioqK0r333qsXXnhB//rXv+zLgBT/b1nyuWJ//vmnbrzxRg0YMECDBw/Wu+++qwcffFBt2rRRnz59JP21BFV0dLR2796te++9V0FBQXrrrbe0evXqErEvXrxYJ06c0F133aUGDRpo06ZNevHFF/Xbb79p8eLFDn3PnDmj2NhYde3aVbNnz5a3t7ekv3Lr//znP7r11lt1/fXXa/Xq1erbt2+Z3rvyxLp69Wr16dNHkZGReuyxx+Tq6movsq5bt04dO3ZU37595evrq0WLFql79+4Ox6enpysiIuK894jU1FRFRESof//+cnd3V0ZGhu6++24VFRVp7NixkqQ5c+Zo3Lhx8vX1tf8RPzAw8JxjFn/WO3TooBkzZujgwYN6/vnn9eWXX+rbb791+NZZYWGhYmNj1alTJ82ePVufffaZnn32WbVo0UJ33XVXmd5T4KIYAJxm7Nixxtk/hkuWLDEkGU899ZRDv0GDBhkuLi7Gzz//bG+TZEgyvvnmG3vbrl27DC8vLyMhIaFccfj4+BjDhw8vc/8nn3zSkGSsWrXqgn27d+9uSDKeffZZe1tBQYHRtm1bo1GjRsapU6cMwzCMM2fOGAUFBQ7H/vnnn0ZgYKBxxx132Nt27txpSDL8/PyMQ4cOOfQv7xgNGzY0jh49am+fPHmyIcm45pprjNOnT9vbhw4danh6ehr5+fmGYRjGsWPHDH9/fyMpKcnhXAcOHDCsVqtD+9//jYutW7fOkGQsXLjQoX3FihUl2ps3b25IMlasWOHQ97nnnjMkGb///nuJ8Z3hvffeMyQZc+bMsbcVFhYavXr1MiQZb7zxhr39sccec3hfsrOzDUnGP//5T4cxJ0yYYEgyVq9ebW8rfj/ee+89e5vNZjOaNGliXHvttfa2/Px8o7Cw0GG8nTt3GhaLxXjiiScc2v4eX2neeOMNQ5IRGRlp/9wahmE8/fTThiTjww8/tLedOHGixPFjxowxvL297Z8jwzCMvn37Gs2bNy/Rd82aNYYk48orr3T4TD///POGJGPr1q1linXnzp32tuL3be3atfa2Q4cOGRaLxUhOTra3Fb8fzzzzzAXHlGQ89thjJc7fvHlzh3vKk08+afj4+Bg7duxw6PfQQw8Zbm5uxu7dux3O3aBBA+PIkSP2fh9++KEhycjIyLC3RUVFGXXr1jV27drlMGZRUZH9/48aNcpo0qSJcfjwYYc+Q4YMMaxWa6n/TgBQm5GbkpvWpNz0vvvuM/z8/IwzZ86cs8/ixYsNScaaNWtK7CtrPlf8mXrzzTftbQUFBUbjxo2NgQMH2tvmzJljSDIWLVpkb8vLyzPCwsJKxFDauWfMmGG4uLg45D7Dhw83JBkPPfSQQ9/i3Pruu+92aL/11lvPmb+drayxFhUVGVdccYURGxvrkIOdOHHCCA0NNW644QZ729ChQ41GjRo5/Hvs37/fcHV1dcjN//57wrnej9jYWOPyyy93aIuIiDC6d+9eom9xbl0c96lTp4xGjRoZV111lXHy5El7v6VLlxqSjClTptjbit/js2M0DMO49tprjcjIyBLnAioSyyMAJrJ8+XK5ubnp3nvvdWhPTk6WYRj6+OOPHdo7d+6syMhI++vLLrtMN998sz755JNK+6rG2rVr9fjjj9v/6l8W7u7uGjNmjP21p6enxowZo0OHDikrK0vSX2twFq/7VVRUpCNHjujMmTNq3769Nm/eXGLMgQMHqmHDhg5t5R3jlltukdVqtb/u1KmTpL/Wdzt7HaVOnTrp1KlT9q/KrFy5UkePHtXQoUN1+PBh++bm5qZOnTqV+MpbaRYvXiyr1aobbrjBYYzIyEj5+vqWGCM0NFSxsbEObcV//f3www8dvmLuLCtWrJCHh4eSkpLsba6urva/fp/P8uXLJUnjx493aE9OTpYkLVu2zKE9KChICQkJ9tfFyxR8++23OnDggCTJYrHYvz5ZWFioP/74w/41vdI+D2U1evRoh5kmd911l9zd3e3XIMlhTbdjx47p8OHD6tatm06cOKEff/yxzOcaOXKkw3p43bp1k/TXLOKLER4ebh9Dkho2bKhWrVpd9HhltXjxYnXr1k316tVz+LzHxMSosLCwxFdnExMTVa9ePfvrv1/377//rrVr1+qOO+7QZZdd5nBs8WxnwzD03nvvqV+/fjIMw+G8sbGxstlsl/Q5AIDagNyU3LQ656b+/v7Ky8vTypUrL+r48uRzvr6+DmtBe3p6qmPHjg451vLly9WkSRMNGjTI3ubt7a3Ro0ef99x5eXk6fPiwrr/+ehmGoW+//bZE/7/P9izOS//+s1vWbxmVNdbs7Gzl5OTo1ltv1R9//GH/3OTl5Sk6Olpr1661fxYSExN16NAhhyUK3n33XRUVFSkxMfG88Zz9fthsNh0+fFjdu3fXf//7X9lstjJd09m++eYbHTp0SHfffbfDWrd9+/ZV69atS/zuIUl33nmnw+tu3bpVeg4NsDwCYCK7du1SUFCQ6tat69Be/BWdXbt2ObRfccUVJcZo2bKlTpw4od9//73Cn577448/KiEhQVdddZVee+21Mh8XFBRUYjH8li1bSvprDa/rrrtOkrRgwQI9++yz+vHHH3X69Gl739DQ0BJjltZW3jH+XuwpTpKDg4NLbS9ezysnJ0eSzvmLgZ+fX6ntZ8vJyZHNZlOjRo1K3X/o0CGH16XFn5iYqNdee03//Oc/9dBDDyk6OloDBgzQoEGDSqz1drYjR47o1KlTF4yxNPXr1z/nQzV27dqlJk2a2L+SVSwsLOyC4+7atUuurq4l+jZu3Fj+/v4lPvthYWEl1ro6+zPVuHFjFRUV6fnnn9fLL7+snTt3Ovyy2KBBgwvGdC5//7nz9fVVkyZNHNaP3bZtmx555BGtXr1aubm5Dv3Lk1j+/TNaXMj8+9pyFzte8ZgXO15Z5eTk6Lvvvivxy2yxv3/eL3TdxQny+b5G9/vvv+vo0aOaP3++5s+fX6bzAgAckZuSmxarjrnp3XffrUWLFqlPnz5q2rSpevfurcGDB+vGG28s09jlyeeaNWtWIjetV6+evvvuO/vrXbt2lZrDtmrVqsS5d+/erSlTpuijjz4qkaf9/dzu7u5q1qyZQ1txbt2iRYsLnqs0ZY21+LN3vuXQbDab6tWrZ1/zNj09XdHR0ZL+Whqhbdu29p+/c/nyyy/12GOPacOGDTpx4kSJ8c/+Y0dZFN+7Sns/WrdurfXr1zu0eXl5lchjqyKHBijaAiiTPXv2qHfv3rJarVq+fHmJ5P1S/ec//9GIESMUHx+viRMnqlGjRnJzc9OMGTP0yy+/lOhf2tNpyzuGm5tbqbGcq934vwduFP+1+K233ir1l4+yPO20qKhIjRo10sKFC0vd//ekoLTrrVOnjtauXas1a9Zo2bJlWrFihdLT09WrVy99+umn57yOAQMGlPoQgLJYs2aNfUH/ylCWB5CU1fTp0/Xoo4/qjjvu0JNPPqn69evL1dVV999/f6XO/jh69Ki6d+8uPz8/PfHEE2rRooW8vLy0efNmPfjgg+U694U+i+VV0eOdy99nUxUVFemGG27QpEmTSu3/90S9IuIsfp//8Y9/nPMXiauvvrrM4wEAzIXclNxUOn9u2qhRI2VnZ+uTTz7Rxx9/rI8//lhvvPGGhg0bpgULFpx33PLmcxWZYxUWFuqGG27QkSNH9OCDD6p169by8fHR3r17NWLEiBLnPvvbZVWtOJZnnnmmxBrNxYqfj2CxWBQfH68PPvhAL7/8sg4ePKgvv/xS06dPP+85fvnlF0VHR6t169ZKSUlRcHCwPD09tXz5cj333HNVMqv7XP++QGWjaAuYSPPmzfXZZ5/p2LFjDoln8ddvip/qXqz4L5tn27Fjh7y9vc85o+1i/PHHH+rdu7cKCgq0atUqNWnSpFzH79u3T3l5eQ4zGnbs2CFJ9ifTv/vuu7r88sv1/vvvOxTuHnvssTKfpyLGKIviv1g3atRIMTEx5+17riJkixYt9Nlnn6lLly6lJr1l5erqqujoaEVHRyslJUXTp0/Xww8/rDVr1pwztmefffai/yp8zTXXnHNf8+bNtWbNGp04ccJhtu3PP/98wXGbN2+uoqIi5eTk2GfvSH89SOro0aMlPvs///yzDMNweH9L+0z17NlT//73vx2OPXr0aJkfVFKanJwc9ezZ0/76+PHj2r9/v+Li4iT99XTaP/74Q++//76ioqLs/Xbu3FlirIosUjtDvXr1dPToUYe2U6dOaf/+/Q5tLVq00PHjxy/481JWl19+uSTZnzJcmuInJRcWFlbYeQGgtiE3JTctLzPlptJfyxT069dP/fr1U1FRke6++2698sorevTRR0udSVqsPPlcWTVv3lzff/99iRz2p59+cui3detW7dixQwsWLNCwYcPs7eVZ5qE4t/7ll18cZpP+/VyXGmvxZ8/Pz69M+VZiYqIWLFigVatWafv27TIM44JLI2RkZKigoEAfffSRw2z00pb9KGtuXXzv+umnn0rMUP/pp59K3NsAZ2FNW8BE4uLiVFhYqLlz5zq0P/fcc3JxcbE/ebTYhg0bHNbD2rNnjz788EP17t27wv4amJeXp7i4OO3du1fLly8v9WtvF3LmzBm98sor9tenTp3SK6+8ooYNG9rXPSuO9+y/RmdmZmrDhg1lPk9FjFEWsbGx8vPz0/Tp0x2+5lbs999/t///4l8G/l7YGjx4sAoLC/Xkk0+WOP7MmTMl+pfmyJEjJdqK/8JdUFBwzuMiIyMVExNzUdvZ64z+XWxsrE6fPq1XX33V3lZUVKSXXnrpgtdSXPCcM2eOQ3tKSooklXjS7b59+/TBBx/YX+fm5urNN99U27Zt7TNM3NzcSsxuWLx4sX39t4s1f/58h3/31NRUnTlzxv7zWdrn8NSpU3r55ZdLjOXj43NR63CZRYsWLUqsRzt//vwSM20HDx6sDRs26JNPPikxxtGjR3XmzJlynbdhw4aKiorS66+/rt27dzvsK37f3dzcNHDgQL333nulFnfP/jkFAJSO3JTcVKq+uekff/zh8NrV1dX+LZvieM71fpQnnyuruLg47du3T++++6697cSJEyWWcSrt3IZh6Pnnny/zuYp/Nl944QWH9r/n2pcaa2RkpFq0aKHZs2fr+PHjJcb5e74VExOj+vXrKz09Xenp6erYseM5lxYpVtr7YbPZ9MYbb5To6+PjU6bPavv27dWoUSPNmzfP4bP58ccfa/v27SV+9wCchZm2gIn069dPPXv21MMPP6xff/1V11xzjT799FN9+OGHuv/++0usSXTVVVcpNjZW9957rywWiz2JePzxxy94royMDG3ZskWSdPr0aX333Xd66qmnJEn9+/e3JzS33XabNm3apDvuuEPbt2/X9u3b7WP4+voqPj7+gucKCgrSrFmz9Ouvv6ply5ZKT09Xdna25s+fb3+g00033aT3339fCQkJ6tu3r3bu3Kl58+YpPDy81ASgNBUxRln4+fkpNTVVt99+u9q1a6chQ4aoYcOG2r17t5YtW6YuXbrYf7kpTvzvvfdexcbGys3NTUOGDFH37t01ZswYzZgxQ9nZ2erdu7c8PDyUk5OjxYsX6/nnn3dY+L80TzzxhNauXau+ffuqefPmOnTokF5++WU1a9ZMXbt2rbDrLav4+Hh17NhRycnJ+vnnn9W6dWt99NFH9gT+fH/5vuaaazR8+HDNnz/f/nW0TZs2acGCBYqPj3eY2Sr99XX6UaNG6euvv1ZgYKBef/11HTx40CF5u+mmm/TEE09o5MiRuv7667V161YtXLjQPkvzYp06dUrR0dEaPHiwfvrpJ7388svq2rWr+vfvL0m6/vrrVa9ePQ0fPlz33nuvXFxc9NZbb5X69bjIyEilp6dr/Pjx6tChg3x9fdWvX79Liq8q/fOf/9Sdd96pgQMH6oYbbtCWLVv0ySeflJjJPHHiRH300Ue66aabNGLECEVGRiovL09bt27Vu+++q19//bXcs59feOEFde3aVe3atdPo0aMVGhqqX3/9VcuWLVN2drYkaebMmVqzZo06deqkpKQkhYeH68iRI9q8ebM+++yzUn+5BAD8D7kpuWl1zk3/+c9/6siRI+rVq5eaNWumXbt26cUXX1Tbtm3t3+xq27at3NzcNGvWLNlsNlksFvXq1atc+VxZJSUlae7cuRo2bJiysrLUpEkTvfXWWyWeB9G6dWu1aNFCEyZM0N69e+Xn56f33nuvXLOR27Ztq6FDh+rll1+WzWbT9ddfr1WrVpXpG3DlidXV1VWvvfaa+vTpo4iICI0cOVJNmzbV3r17tWbNGvn5+SkjI8Pe38PDQwMGDNA777yjvLw8zZ49+4Kx9O7d2z5jesyYMTp+/LheffVVNWrUqMS3uyIjI5WamqqnnnpKYWFhatSoUalrPXt4eGjWrFkaOXKkunfvrqFDh+rgwYN6/vnnFRISogceeKBM7xNQ6QwATjN27Fjj7z+Gx44dMx544AEjKCjI8PDwMK644grjmWeeMYqKihz6STLGjh1r/Oc//zGuuOIKw2KxGNdee62xZs2aMp17+PDhhqRStzfeeMPer3nz5ufs17x58wuep3v37kZERITxzTffGJ07dza8vLyM5s2bG3PnznXoV1RUZEyfPt1o3ry5/VqWLl1qDB8+3OE8O3fuNCQZzzzzTIlzXeoYa9asMSQZixcvdmh/4403DEnG119/XaJ/bGysYbVaDS8vL6NFixbGiBEjjG+++cbe58yZM8a4ceOMhg0bGi4uLiX+vefPn29ERkYaderUMerWrWu0adPGmDRpkrFv3z57n+bNmxt9+/Ytcb2rVq0ybr75ZiMoKMjw9PQ0goKCjKFDhxo7duwo0beq/P7778att95q1K1b17BarcaIESOML7/80pBkvPPOO/Z+jz32WIn34vTp08bjjz9uhIaGGh4eHkZwcLAxefJkIz8/36Ff8fvxySefGFdffbVhsViM1q1bl/h3y8/PN5KTk40mTZoYderUMbp06WJs2LDB6N69u9G9e3d7v+LPw9mf+9IUfw6++OILY/To0Ua9evUMX19f47bbbjP++OMPh75ffvmlcd111xl16tQxgoKCjEmTJhmffPKJIcnhZ/T48ePGrbfeavj7+zv8TJ3rs1jeWHfu3Fniffu7c70ff//5KG3MwsJC48EHHzQCAgIMb29vIzY21vj555+N5s2bG8OHD3c4/tixY8bkyZONsLAww9PT0wgICDCuv/56Y/bs2capU6fOe27D+Oue99hjjzm0ff/990ZCQoLh7+9veHl5Ga1atTIeffRRhz4HDx40xo4dawQHBxseHh5G48aNjejoaGP+/PnneQcBoHYiN/0fctPqn5u+++67Ru/evY1GjRoZnp6exmWXXWaMGTPG2L9/v0O/V1991bj88ssNNzc3h1ytrPlc8Wfq7/7+72wYhrFr1y6jf//+hre3txEQEGDcd999xooVK0qM+cMPPxgxMTGGr6+vERAQYCQlJRlbtmwp8fMwfPhww8fHp9TrP3nypHHvvfcaDRo0MHx8fIx+/foZe/bsKTWnKk1ZYzUMw/j222+NAQMGGA0aNDAsFovRvHlzY/DgwcaqVatKjLty5UpDkuHi4mLs2bOnxP7Sfk/46KOPjKuvvtrw8vIyQkJCjFmzZhmvv/56idz0wIEDRt++fY26desakuw5bvHP0t/jTk9PN6699lrDYrEY9evXN2677Tbjt99+c+hzrve4tDiBiuZiGBX89BEAVcLFxUVjx44t8XU1s+nRo4cOHz583rUnUbMtWbJECQkJWr9+vbp06eLscC5aWlqaRo4cqa+//lrt27d3djgAAJgKuSkAABWLNW0BABXm5MmTDq8LCwv14osvys/PT+3atXNSVAAAAAAAVC+saQsAqDDjxo3TyZMn1blzZxUUFOj999/XV199penTp1/Sk4gBAAAAAKhNKNoCACpMr1699Oyzz2rp0qXKz89XWFiYXnzxRd1zzz3ODg0AAAAAgGqDNW0BAAAAAAAAwERY0xYAAAAAAAAATISiLQAAAAAAAACYCGvaVqKioiLt27dPdevWlYuLi7PDAQAAwDkYhqFjx44pKChIrq7Va14DOScAAED1Uda8k6JtJdq3b5+Cg4OdHQYAAADKaM+ePWrWrJmzwygXck4AAIDq50J5J0XbSlS3bl1Jf/0j+Pn5OTkaAAAAnEtubq6Cg4Pt+Vt1Qs4JAABQfZQ176RoW4mKv57m5+dHAg0AAFANVMflBcg5AQAAqp8L5Z3Va8EuAAAAAAAAAKjhKNoCAAAAAAAAgIlQtAUAAAAAAAAAE6FoCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAAAACAiVC0BQAAAAAAAAAToWgLAAAAAAAAACZC0RYAAAAAAAAATISiLQAAAAAAAACYCEVbAAAAAAAAADARd2cHUCvMi5LquDk7CgAAgOplXJazI6hWBmcMloe3h7PDAAAAqHYyEjKcHUIJzLQFAAAAAAAAABOhaAsAAAAAAAAAJkLRFgAAAAAAAABMhKItAAAAAAAAAJgIRVsAAAAAAAAAMBGKtgAAAAAAAABgIhRtJRmGoZSUFIWGhsrb21vx8fGy2WzODgsAAAA1DHknAAAAyoKiraSJEycqNTVVCxYs0Lp165SVlaWpU6c6OywAAADUMOSdAAAAKItaX7TNzMxUSkqK0tPTFRUVpcjISCUlJWn58uXODg0AAAA1CHknAAAAyqrWF21nz56t6OhotWvXzt4WGBiow4cPOzEqAAAA1DTknQAAACirWl20LSgo0LJly5SQkODQnp+fL6vV6qSoAAAAUNOQdwIAAKA8anXRdvPmzTp58qSSk5Pl6+tr3yZNmqSWLVtKkhISElSvXj0NGjToguMVFBQoNzfXYQMAAAAqMu8k5wQAAKj5anXRdseOHfLx8dHWrVuVnZ1t30JCQtSlSxdJ0n333ac333yzTOPNmDFDVqvVvgUHB1dm+AAAAKgmKjLvJOcEAACo+Wp10TY3N1cBAQEKCwuzbx4eHsrJydHAgQMlST169FDdunXLNN7kyZNls9ns2549eyozfAAAAFQTFZl3knMCAADUfO7ODsCZAgICZLPZZBiGXFxcJEnTpk1TXFycwsPDyz2exWKRxWKp6DABAABQzVVk3knOCQAAUPPV6qJtr169lJ+fr5kzZ2rIkCFauHChMjIytGnTJmeHBgAAgBqEvBMAAADlUauXRwgMDFRaWppSU1MVERGhjRs3av369awLBgAAgApF3gkAAIDyqNUzbSUpMTFRiYmJzg4DAAAANRx5JwAAAMqq1hdtLyQmJkZbtmxRXl6emjVrpsWLF6tz587ODgsAAAA1DHknAAAAilG0vYDPPvvM2SEAAACgFiDvBAAAQLFavaYtAAAAAAAAAJgNRVsAAAAAAAAAMBGKtgAAAAAAAABgIhRtAQAAAAAAAMBEeBBZVbhzreTn5+woAAAAUIMt6rdIfuScAAAANQIzbQEAAAAAAADARCjaAgAAAAAAAICJULQFAAAAAAAAABOhaAsAAAAAAAAAJkLRFgAAAAAAAABMxN3ZAdQK86KkOm7OjgIAADjDuCxnR4BaYnDGYHl4ezg7DAAA4CQZCRnODgEViJm2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAAAACAiVC0BQAAAAAAAAAToWgLAAAAAAAAACZC0RYAAAAAAAAATISirSTDMJSSkqLQ0FB5e3srPj5eNpvN2WEBAACghiHvBAAAQFlQtJU0ceJEpaamasGCBVq3bp2ysrI0depUZ4cFAACAGoa8EwAAAGVR64u2mZmZSklJUXp6uqKiohQZGamkpCQtX77c2aEBAACgBiHvBAAAQFnV+qLt7NmzFR0drXbt2tnbAgMDdfjwYSdGBQAAgJqGvBMAAABlVauLtgUFBVq2bJkSEhIc2vPz82W1Wi9qvNzcXIcNAAAAqMi8k5wTAACg5qvVRdvNmzfr5MmTSk5Olq+vr32bNGmSWrZsqT179qhHjx4KDw/X1VdfrcWLF593vBkzZshqtdq34ODgKroSAAAAmFlF5p3knAAAADWfu7MDcKYdO3bIx8dH2dnZDu19+/ZVly5d5O7urjlz5qht27Y6cOCAIiMjFRcXJx8fn1LHmzx5ssaPH29/nZubSxINAACACs07yTkBAABqvlpdtM3NzVVAQIDCwsLsbbt27VJOTo4GDhyoJk2aqEmTJpKkxo0bKyAgQEeOHDln0dZischisVRJ7AAAAKg+KjLvJOcEAACo+Wr18ggBAQGy2WwyDMPeNm3aNMXFxSk8PNyhb1ZWlgoLC5nFAAAAgHIj7wQAAEB51OqZtr169VJ+fr5mzpypIUOGaOHChcrIyNCmTZsc+h05ckTDhg3Tq6++6qRIAQAAUJ2RdwIAAKA8avVM28DAQKWlpSk1NVURERHauHGj1q9f7zCroaCgQPHx8XrooYd0/fXXOzFaAAAAVFfknQAAACiPWj3TVpISExOVmJhY6j7DMDRixAj16tVLt99+exVHBgAAgJqEvBMAAABlVatn2l7Il19+qfT0dC1ZskRt27ZV27ZttXXrVmeHBQAAgBqGvBMAAABnq/Uzbc+na9euKioqcnYYAAAAqOHIOwEAAHA2ZtoCAAAAAAAAgIlQtAUAAAAAAAAAE6FoCwAAAAAAAAAmQtEWAAAAAAAAAEyEB5FVhTvXSn5+zo4CAAAANdiifovkR84JAABQIzDTFgAAAAAAAABMhKItAAAAAAAAAJgIRVsAAAAAAAAAMBGKtgAAAAAAAABgIhRtAQAAAAAAAMBE3J0dQK0wL0qq4+bsKAAAqD3GZTk7AqDKDc4YLA9vD2eHAQAAziMjIcPZIaCaYKYtAAAAAAAAAJgIRVsAAAAAAAAAMBGKtgAAAAAAAABgIhRtAQAAAAAAAMBEKNoCAAAAAAAAgIlQtAUAAAAAAAAAE6FoK8kwDKWkpCg0NFTe3t6Kj4+XzWZzdlgAAACoYcg7AQAAUBYUbSVNnDhRqampWrBggdatW6esrCxNnTrV2WEBAACghiHvBAAAQFnU+qJtZmamUlJSlJ6erqioKEVGRiopKUnLly93dmgAAACoQcg7AQAAUFa1vmg7e/ZsRUdHq127dva2wMBAHT582IlRAQAAoKYh7wQAAEBZ1eqibUFBgZYtW6aEhASH9vz8fFmt1osaLzc312EDAAAAKjLvJOcEAACo+Wp10Xbz5s06efKkkpOT5evra98mTZqkli1bSpKWLl2qVq1a6YorrtBrr7123vFmzJghq9Vq34KDg6viMgAAAGByFZl3knMCAADUfO7ODsCZduzYIR8fH2VnZzu09+3bV126dNGZM2c0fvx4rVmzRlarVZGRkUpISFCDBg1KHW/y5MkaP368/XVubi5JNAAAACo07yTnBAAAqPlqddE2NzdXAQEBCgsLs7ft2rVLOTk5GjhwoDZt2qSIiAg1bdpUktSnTx99+umnGjp0aKnjWSwWWSyWKokdAAAA1UdF5p3knAAAADVfrV4eISAgQDabTYZh2NumTZumuLg4hYeHa9++ffbEWZKaNm2qvXv3OiNUAAAAVGPknQAAACiPWj3TtlevXsrPz9fMmTM1ZMgQLVy4UBkZGdq0aZOzQwMAAEANQt4JAACA8qjVM20DAwOVlpam1NRURUREaOPGjVq/fr19TbCgoCCHGQ579+5VUFCQs8IFAABANUXeCQAAgPJwMc7+jhYcnDlzRldeeaU+//xz+wMhvvrqq3M+iOzvcnNzZbVaZZt1jfzquFVytAAAwG5clrMjQDVjz9tsNvn5+VX5+S8l7yyOPfY/sfLw9qiCaAEAwMXKSMhwdghwsrLmnbV6eYQLcXd317PPPquePXuqqKhIkyZNKnPBFgAAACgr8k4AAACcjaLtBfTv31/9+/d3dhgAAACo4cg7AQAAUKxWr2kLAAAAAAAAAGZD0RYAAAAAAAAATISiLQAAAAAAAACYCEVbAAAAAAAAADARHkRWFe5cK/n5OTsKAAAA1GCL+i2SHzknAABAjcBMWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAAAACAiVC0BQAAAAAAAAATcXd2ALXCvCipjpuzowAAXIxxWc6OAADKZHDGYHl4ezg7DAAAzisjIcPZIQDVAjNtAQAAAAAAAMBEKNoCAAAAAAAAgIlQtAUAAAAAAAAAE6FoCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmEitKtoahqGUlBSFhobK29tb8fHxstlszg4LAAAANQg5JwAAAC5VrSraTpw4UampqVqwYIHWrVunrKwsTZ061dlhAQAAoAYh5wQAAMClqjVF28zMTKWkpCg9PV1RUVGKjIxUUlKSli9f7uzQAAAAUEOQcwIAAKAi1Jqi7ezZsxUdHa127drZ2wIDA3X48GEnRgUAAICahJwTAAAAFaFWFG0LCgq0bNkyJSQkOLTn5+fLarVW6Hlyc3MdNgAAANQO5JwAAACoKLWiaLt582adPHlSycnJ8vX1tW+TJk1Sy5YtJUkJCQmqV6+eBg0a5HDszp071bNnT4WHh6tNmzbKy8s753lmzJghq9Vq34KDgyv1ugAAAGAe5JwAAACoKLWiaLtjxw75+Pho69atys7Otm8hISHq0qWLJOm+++7Tm2++WeLYESNG6IknntAPP/ygL774QhaL5ZznmTx5smw2m33bs2dPpV0TAAAAzIWcEwAAABXF3dkBVIXc3FwFBAQoLCzM3rZr1y7l5ORo4MCBkqQePXro888/dzhu27Zt8vDwULdu3SRJ9evXP+95LBbLeRNsAAAA1FzknAAAAKgotWKmbUBAgGw2mwzDsLdNmzZNcXFxCg8PP+dxOTk58vX1Vb9+/dSuXTtNnz69KsIFAABANUTOCQAAgIpSK2ba9urVS/n5+Zo5c6aGDBmihQsXKiMjQ5s2bTrvcWfOnNG6deuUnZ2tRo0a6cYbb1SHDh10ww03VFHkAAAAqC7IOQEAAFBRasVM28DAQKWlpSk1NVURERHauHGj1q9ff8GHNjRt2lTt27dXcHCwLBaL4uLilJ2dXTVBAwAAoFoh5wQAAEBFqRVFW0lKTEzU7t27deLECS1dulQtWrS44DEdOnTQoUOH9Oeff6qoqEhr167VlVdeWQXRAgAAoDoi5wQAAEBFqBXLI5RFTEyMtmzZory8PDVr1kyLFy9W586dNX36dEVFRckwDPXu3Vs33XSTs0MFAABANUXOCQAAgLKgaPt/Pvvss1Lb+/Tpoz59+lRxNAAAAKiJyDkBAABQFrVmeQQAAAAAAAAAqA4o2gIAAAAAAACAiVC0BQAAAAAAAAATYU3bqnDnWsnPz9lRAAAAoAZb1G+R/Mg5AQAAagRm2gIAAAAAAACAiVC0BQAAAAAAAAAToWgLAAAAAAAAACZC0RYAAAAAAAAATISiLQAAAAAAAACYCEVbAAAAAAAAADARd2cHUCvMi5LquDk7CgBAsXFZzo4AACrc4IzB8vD2cHYYAIAqlJGQ4ewQAFQSZtoCAAAAAAAAgIlQtAUAAAAAAAAAE6FoCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2kgzDUEpKikJDQ+Xt7a34+HjZbDZnhwUAAIAahrwTAAAAZUHRVtLEiROVmpqqBQsWaN26dcrKytLUqVOdHRYAAABqGPJOAAAAlEWtL9pmZmYqJSVF6enpioqKUmRkpJKSkrR8+XJnhwYAAIAahLwTAAAAZVXri7azZ89WdHS02rVrZ28LDAzU4cOHnRgVAAAAahryTgAAAJRVrS7aFhQUaNmyZUpISHBoz8/Pl9VqvajxcnNzHTYAAACgIvNOck4AAICar1YXbTdv3qyTJ08qOTlZvr6+9m3SpElq2bKlJGnnzp3q2bOnwsPD1aZNG+Xl5Z1zvBkzZshqtdq34ODgqroUAAAAmFhF5p3knAAAADWfu7MDcKYdO3bIx8dH2dnZDu19+/ZVly5dJEkjRozQU089pW7duunIkSOyWCznHG/y5MkaP368/XVubi5JNAAAACo07yTnBAAAqPlqddE2NzdXAQEBCgsLs7ft2rVLOTk5GjhwoLZt2yYPDw9169ZNklS/fv3zjmexWM5b1AUAAEDtVJF5JzknAABAzVerl0cICAiQzWaTYRj2tmnTpikuLk7h4eHKycmRr6+v+vXrp3bt2mn69OlOjBYAAADVFXknAAAAyqNWz7Tt1auX8vPzNXPmTA0ZMkQLFy5URkaGNm3aJEk6c+aM1q1bp+zsbDVq1Eg33nijOnTooBtuuMHJkQMAAKA6Ie8EAABAedTqmbaBgYFKS0tTamqqIiIitHHjRq1fv96+JljTpk3Vvn17BQcHy2KxKC4ursQ6ZAAAAMCFkHcCAACgPGp10VaSEhMTtXv3bp04cUJLly5VixYt7Ps6dOigQ4cO6c8//1RRUZHWrl2rK6+80onRAgAAoLoi7wQAAEBZ1erlES7E3d1d06dPV1RUlAzDUO/evXXTTTc5OywAAADUMOSdAAAAOBtF2wvo06eP+vTp4+wwAAAAUMORdwIAAKBYrV8eAQAAAAAAAADMhKItAAAAAAAAAJgIRVsAAAAAAAAAMBHWtK0Kd66V/PycHQUAAABqsEX9FsmPnBMAAKBGYKYtAAAAAAAAAJgIRVsAAAAAAAAAMBGKtgAAAAAAAABgIhRtAQAAAAAAAMBEKNoCAAAAAAAAgIm4OzuAWmFelFTHzdlRAEDtMi7L2REAQJUanDFYHt4ezg4DAFCBMhIynB0CACdhpi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAAAACAiVC0BQAAAAAAAAAToWgLAAAAAAAAACZSq4q2hmEoJSVFoaGh8vb2Vnx8vGw2m7PDAgAAQA1D3gkAAIBLUauKthMnTlRqaqoWLFigdevWKSsrS1OnTnV2WAAAAKhhyDsBAABwKWpN0TYzM1MpKSlKT09XVFSUIiMjlZSUpOXLlzs7NAAAANQg5J0AAAC4VLWmaDt79mxFR0erXbt29rbAwEAdPnzYiVEBAACgpiHvBAAAwKWqFUXbgoICLVu2TAkJCQ7t+fn5slqtFXqe3Nxchw0AAAC1R1XkneScAAAANV+tKNpu3rxZJ0+eVHJysnx9fe3bpEmT1LJlS0lSQkKC6tWrp0GDBtmP27Nnj3r06KHw8HBdffXVWrx48XnPM2PGDFmtVvsWHBxcqdcFAAAAc6mKvJOcEwAAoOarFUXbHTt2yMfHR1u3blV2drZ9CwkJUZcuXSRJ9913n958802H49zd3TVnzhz98MMP+vTTT3X//fcrLy/vnOeZPHmybDabfduzZ0+lXhcAAADMpSryTnJOAACAms/d2QFUhdzcXAUEBCgsLMzetmvXLuXk5GjgwIGSpB49eujzzz93OK5JkyZq0qSJJKlx48YKCAjQkSNH5OPjU+p5LBaLLBZL5VwEAAAATK8q8k5yTgAAgJqvVsy0DQgIkM1mk2EY9rZp06YpLi5O4eHhZRojKytLhYWFfP0MAAAA50TeCQAAgIpQK2ba9urVS/n5+Zo5c6aGDBmihQsXKiMjQ5s2bSrT8UeOHNGwYcP06quvVnKkAAAAqM7IOwEAAFARasVM28DAQKWlpSk1NVURERHauHGj1q9fX6bZCwUFBYqPj9dDDz2k66+/vgqiBQAAQHVF3gkAAICKUCtm2kpSYmKiEhMTy3WMYRgaMWKEevXqpdtvv72SIgMAAEBNQt4JAACAS1VrirYXEhMToy1btigvL0/NmjXT4sWLVVhYqPT0dF199dVasmSJJOmtt95SmzZtnBssAAAAqi3yTgAAAFwIRdv/89lnn5XaXlRUVMWRAAAAoCYj7wQAAMCF1Io1bQEAAAAAAACguqBoCwAAAAAAAAAmQtEWAAAAAAAAAEyENW2rwp1rJT8/Z0cBAACAGmxRv0XyI+cEAACoEZhpCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAi7s4OoFaYFyXVcXN2FACA8xmX5ewIAOCSDM4YLA9vD2eHAQCoABkJGc4OAYCTMdMWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAAAACAiVC0BQAAAAAAAAATqVVFW8MwlJKSotDQUHl7eys+Pl42m83ZYQEAAKAGIecEAADApapVRduJEycqNTVVCxYs0Lp165SVlaWpU6c6OywAAADUIOScAAAAuFS1pmibmZmplJQUpaenKyoqSpGRkUpKStLy5cudHRoAAABqCHJOAAAAVIRaU7SdPXu2oqOj1a5dO3tbYGCgDh8+7MSoAAAAUJOQcwIAAKAi1IqibUFBgZYtW6aEhASH9vz8fFmt1go9T25ursMGAACA2oGcEwAAABWlVhRtN2/erJMnTyo5OVm+vr72bdKkSWrZsqUkKSEhQfXq1dOgQYMcjl26dKlatWqlK664Qq+99tp5zzNjxgxZrVb7FhwcXGnXBAAAAHMh5wQAAEBFqRVF2x07dsjHx0dbt25Vdna2fQsJCVGXLl0kSffdd5/efPNNh+POnDmj8ePHa/Xq1fr222/1zDPP6I8//jjneSZPniybzWbf9uzZU6nXBQAAAPMg5wQAAEBFqRVF29zcXAUEBCgsLMy+eXh4KCcnRwMHDpQk9ejRQ3Xr1nU4btOmTYqIiFDTpk3l6+urPn366NNPPz3neSwWi/z8/Bw2AAAA1A7knAAAAKgotaJoGxAQIJvNJsMw7G3Tpk1TXFycwsPDz3ncvn371LRpU/vrpk2bau/evZUaKwAAAKonck4AAABUFHdnB1AVevXqpfz8fM2cOVNDhgzRwoULlZGRoU2bNjk7NAAAANQQ5JwAAACoKLVipm1gYKDS0tKUmpqqiIgIbdy4UevXr7/gQxuCgoIcZjns3btXQUFBlR0uAAAAqiFyTgAAAFSUWjHTVpISExOVmJhYrmM6duyo77//Xnv37pXVatXHH3+sRx99tJIiBAAAQHVHzgkAAICKUGuKthcSExOjLVu2KC8vT82aNdPixYvVuXNnPfvss+rZs6eKioo0adIkNWjQwNmhAgAAoJoi5wQAAEBZULT9P5999lmp7f3791f//v2rOBoAAADUROScAAAAKItasaYtAAAAAAAAAFQXFG0BAAAAAAAAwEQo2gIAAAAAAACAibCmbVW4c63k5+fsKAAAAFCDLeq3SH7knAAAADUCM20BAAAAAAAAwEQo2gIAAAAAAACAiVC0BQAAAAAAAAAToWgLAAAAAAAAACZC0RYAAAAAAAAATMTd2QHUCvOipDpuzo4CAFAVxmU5OwIAtdTgjMHy8PZwdhgAAEkZCRnODgFANcdMWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAAAACAiVC0BQAAAAAAAAAToWgLAAAAAAAAACZC0VaSYRhKSUlRaGiovL29FR8fL5vN5uywAAAAUMOQdwIAAKAsKNpKmjhxolJTU7VgwQKtW7dOWVlZmjp1qrPDAgAAQA1D3gkAAICyqPVF28zMTKWkpCg9PV1RUVGKjIxUUlKSli9f7uzQAAAAUIOQdwIAAKCsan3Rdvbs2YqOjla7du3sbYGBgTp8+LATowIAAEBNQ94JAACAsqrVRduCggItW7ZMCQkJDu35+fmyWq0XNV5ubq7DBgAAAFRk3knOCQAAUPPV6qLt5s2bdfLkSSUnJ8vX19e+TZo0SS1bttTRo0fVvn17tW3bVldddZVeffXV8443Y8YMWa1W+xYcHFxFVwIAAAAzq8i8k5wTAACg5nN3dgDOtGPHDvn4+Cg7O9uhvW/fvurSpYvq1q2rtWvXytvbW3l5ebrqqqs0YMAANWjQoNTxJk+erPHjx9tf5+bmkkQDAACgQvNOck4AAICar1YXbXNzcxUQEKCwsDB7265du5STk6OBAwfKzc1N3t7ekv76GpphGDIM45zjWSwWWSyWSo8bAAAA1UtF5p3knAAAADVfrV4eISAgQDabzSEhnjZtmuLi4hQeHi5JOnr0qK655ho1a9ZMEydOVEBAgLPCBQAAQDVF3gkAAIDyqNVF2169eik/P18zZ87Uzp079dRTTykjI0Opqan2Pv7+/tqyZYt27typt99+WwcPHnRixAAAAKiOyDsBAABQHrW6aBsYGKi0tDSlpqYqIiJCGzdu1Pr160tdEywwMFDXXHON1q1b54RIAQAAUJ2RdwIAAKA8anXRVpISExO1e/dunThxQkuXLlWLFi3s+w4ePKhjx45Jkmw2m9auXatWrVo5K1QAAABUY+SdAAAAKKta/SCyC9m1a5dGjx5tfxDEuHHj1KZNG2eHBQAAgBqGvBMAAABno2h7Hh07dlR2drazwwAAAEANR94JAACAs9X65REAAAAAAAAAwEwo2gIAAAAAAACAiVC0BQAAAAAAAAAToWgLAAAAAAAAACbCg8iqwp1rJT8/Z0cBAACAGmxRv0XyI+cEAACoEZhpCwAAAAAAAAAmQtEWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAi7s4OoFaYFyXVcXN2FABwacZlOTsCAMB5DM4YLA9vD2eHAQA1SkZChrNDAFBLMdMWAAAAAAAAAEyEoi0AAAAAAAAAmAhFWwAAAAAAAAAwEYq2AAAAAAAAAGAiFG0BAAAAAAAAwEQo2gIAAAAAAACAiVC0lWQYhlJSUhQaGipvb2/Fx8fLZrM5OywA+P/t3XtYFnX+//HXLQiCCGkopuJpUVdMVFBXl28ewCJxdUVLO+xqtUtb6Wp5oNzKNDNoV3HtsHSwQsvNQydF7UrzbIYHELNU5EpNM/LQGgiKIszvj37eV3egAt4yc9/383Fd8wdzf2bmPTM41/t68XFuAICboe8EAABAVRDaSpo8ebLS0tI0f/58bd68WVlZWZo2bZrZZQEAAMDN0HcCAACgKjw+tN22bZtSU1O1ePFi9enTR1FRUUpMTNSqVavMLg0AAABuhL4TAAAAVeXxoe2sWbMUGxuryMhI+7qQkBCdOnXKxKoAAADgbug7AQAAUFUeHdqeP39eK1euVEJCgsP6kpISBQUF1Wh/hYWFDgsAAADgzL6TnhMAAMD9eZtdgJmys7N17tw5TZw4UUlJSfb1paWl6t+/vySpdevWCgwMVJ06ddSwYUOtX7/+svtLTk7W9OnTr3vdAAAAcC3O7DvpOQEAANyfR4e2Bw4cUP369ZWTk+OwftCgQYqOjrb/vHXrVgUEBFx1f1OmTNGECRPsPxcWFio0NNRp9QIAAMA1ObPvpOcEAABwfx4d2hYWFio4OFhhYWH2dd9++63y8vI0fPjwau/P19dXvr6+ziwRAAAAbsCZfSc9JwAAgPvz6HfaBgcHq6CgQIZh2NfNnDlT8fHxCg8PlyTZbDb17dtXPXr00MKFC80qFQAAAC6MvhMAAADV4dEzbWNiYlRSUqKUlBTdddddWrhwoTIyMrR9+3b7mC1btqh58+bKz8/XgAED1LlzZ0VERJhYNQAAAFwNfScAAACqw6Nn2oaEhCg9PV1paWnq1KmTMjMztWXLFod3gjVv3lySdNNNNyk+Pl7Z2dlmlQsAAAAXRd8JAACA6vDombaSNHLkSI0cObLSz4qLi1VeXq4GDRqoqKhI69at04gRI2q5QgAAALgD+k4AAABUlceHtldy/PhxJSQkSJLKysqUmJioHj16mFwVAAAA3A19JwAAAH6J0PYK2rZtq927d5tdBgAAANwcfScAAAB+yaPfaQsAAAAAAAAAVkNoCwAAAAAAAAAWQmgLAAAAAAAAABZCaAsAAAAAAAAAFsIXkdWGhzZJgYFmVwEAAAA3tmTwEgXScwIAALgFZtoCAAAAAAAAgIUQ2gIAAAAAAACAhRDaAgAAAAAAAICFENoCAAAAAAAAgIUQ2gIAAAAAAACAhXibXYBHeLWP5OdVO8f6e1btHAcAAACWMiJjhOr61zW7DABOkpGQYXYJAAATMdMWAAAAAAAAACyE0BYAAAAAAAAALITQFgAAAAAAAAAshNAWAAAAAAAAACyE0BYAAAAAAAAALITQFgAAAAAAAAAsxKNCW8MwlJqaqjZt2sjf319Dhw5VQUGB2WUBAADAjdBzAgAA4Fp5VGg7efJkpaWlaf78+dq8ebOysrI0bdo0s8sCAACAG6HnBAAAwLXymNB227ZtSk1N1eLFi9WnTx9FRUUpMTFRq1atMrs0AAAAuAl6TgAAADiDx4S2s2bNUmxsrCIjI+3rQkJCdOrUKROrAgAAgDuh5wQAAIAzeERoe/78ea1cuVIJCQkO60tKShQUFOTU4xQWFjosAAAA8Az0nAAAAHAWjwhts7Ozde7cOU2cOFEBAQH2JSkpSe3bt5ckJSQkqGHDhrrjjjsqbH/27Fm1atVKkyZNuuJxkpOTFRQUZF9CQ0Ovy/kAAADAeug5AQAA4CweEdoeOHBA9evX1549e5STk2NfWrdurejoaEnS+PHjtWDBgkq3nzlzpnr16nXV40yZMkUFBQX25ejRo049DwAAAFgXPScAAACcxSNC28LCQgUHByssLMy+1K1bV3l5eRo+fLgkqV+/fmrQoEGFbfPy8rR//34NHDjwqsfx9fVVYGCgwwIAAADPQM8JAAAAZ/GI0DY4OFgFBQUyDMO+bubMmYqPj1d4ePgVt500aZKSk5Ovd4kAAABwcfScAAAAcBaPCG1jYmJUUlKilJQUHTp0SM8995wyMjKUlpZ2xe2WLVum9u3b299BBgAAAFwOPScAAACcxdvsAmpDSEiI0tPTNXnyZM2YMUMxMTHasmXLVb+0ITMzU4sWLdLSpUtVVFSk0tJSBQYGaurUqbVUOQAAAFwFPScAAACcxSNCW0kaOXKkRo4cWa1tkpOT7f9NLT09XV999RXNMwAAAC6LnhMAAADO4DGh7dUMGDBAu3fvVnFxsVq0aKGlS5eqd+/eZpcFAAAAN0LPCQAAgKogtP3/Pvvssyt+ft9999VOIQAAAHBb9JwAAACoCo/4IjIAAAAAAAAAcBWEtgAAAAAAAABgIYS2AAAAAAAAAGAhvNO2Njy0SQoMNLsKAAAAuLElg5cokJ4TAADALTDTFgAAAAAAAAAshNAWAAAAAAAAACyE0BYAAAAAAAAALITQFgAAAAAAAAAshNAWAAAAAAAAACyE0BYAAAAAAAAALMTb7AI8wqt9JD8vs6u4/v6eZXYFAAAAHmtExgjV9a9rdhmWkZGQYXYJAAAANcZMWwAAAAAAAACwEEJbAAAAAAAAALAQQlsAAAAAAAAAsBBCWwAAAAAAAACwEEJbAAAAAAAAALAQQlsAAAAAAAAAsBBCW0mGYSg1NVVt2rSRv7+/hg4dqoKCArPLAgAAgJuh7wQAAEBVENpKmjx5stLS0jR//nxt3rxZWVlZmjZtmtllAQAAwM3QdwIAAKAqPD603bZtm1JTU7V48WL16dNHUVFRSkxM1KpVq8wuDQAAAG6EvhMAAABV5fGh7axZsxQbG6vIyEj7upCQEJ06dcrEqgAAAOBu6DsBAABQVR4d2p4/f14rV65UQkKCw/qSkhIFBQXVaH+FhYUOCwAAAODMvpOeEwAAwP15dGibnZ2tc+fOaeLEiQoICLAvSUlJat++vSRpzpw56tSpk8LDwzVu3DgZhnHZ/SUnJysoKMi+hIaG1tapAAAAwMKc2XfScwIAALg/jw5tDxw4oPr162vPnj3KycmxL61bt1Z0dLROnjypl19+WVlZWdqzZ4+ysrKUmZl52f1NmTJFBQUF9uXo0aO1eDYAAACwKmf2nfScAAAA7s/b7ALMVFhYqODgYIWFhdnXffvtt8rLy9Pw4cMlSRcvXlRJSYkkqbS0VE2aNLns/nx9feXr63t9iwYAAIDLcWbfSc8JAADg/jw6tA0ODlZBQYEMw5DNZpMkzZw5U/Hx8QoPD5ckTZo0SS1btpS3t7ceeugh/eY3vzGzZAAAALgg+k4AAABUh0e/HiEmJkYlJSVKSUnRoUOH9NxzzykjI0NpaWmSpNOnT2vFihU6fPiwjh07pq1bt2rTpk0mVw0AAABXQ98JAACA6vDo0DYkJETp6elKS0tTp06dlJmZqS1btti/zOGzzz5TWFiYGjVqJD8/Pw0aNOiK77QFAAAAKkPfCQAAgOrw6NBWkkaOHKkjR47o7NmzWrFihcN/QwsNDdXWrVtVUlKisrIybdiwQR06dDCxWgAAALgq+k4AAABUlUe/0/ZqevXqpfj4eHXr1k116tRRbGyshgwZYnZZAAAAcDP0nQAAAPglm2EYhtlFuKvCwkIFBQWp4IUuCvTzMrucw6vOegAAGgZJREFU6+/vWWZXAAAAUCP2vq2gQIGBgWaXUy2Xao97N051/euaXY5lZCRkmF0CAABABVXtOz3+9QgAAAAAAAAAYCWEtgAAAAAAAABgIYS2AAAAAAAAAGAhfBFZbXhok+Ri70YDAACAa1kyeInLvY8XAAAAlWOmLQAAAAAAAABYCKEtAAAAAAAAAFgIoS0AAAAAAAAAWAihLQAAAAAAAABYCKEtAAAAAAAAAFiIt9kFeIRX+0h+XrVzrL9n1c5xAAAAYCkjMkaorn/dWjteRkJGrR0LAADA0zDTFgAAAAAAAAAshNAWAAAAAAAAACyE0BYAAAAAAAAALITQFgAAAAAAAAAshNAWAAAAAAAAACyE0BYAAAAAAAAALITQFgAAAAAAAAAshNBWkmEYSk1NVZs2beTv76+hQ4eqoKDA7LIAAADgZug7AQAAUBWEtpImT56stLQ0zZ8/X5s3b1ZWVpamTZtmdlkAAABwM/SdAAAAqAqPD223bdum1NRULV68WH369FFUVJQSExO1atUqs0sDAACAG6HvBAAAQFV5fGg7a9YsxcbGKjIy0r4uJCREp06dMrEqAAAAuBv6TgAAAFSVR4e258+f18qVK5WQkOCwvqSkREFBQTXaX2FhocMCAAAAOLPvpOcEAABwfx4d2mZnZ+vcuXOaOHGiAgIC7EtSUpLat2+v3Nxcde3a1b74+fnp448/vuz+kpOTFRQUZF9CQ0Nr72QAAABgWc7sO+k5AQAA3J+32QWY6cCBA6pfv75ycnIc1g8aNEjR0dHq0KGD/bOioiK1bt1at95662X3N2XKFE2YMMH+c2FhIU00AAAAnNp30nMCAAC4P48ObQsLCxUcHKywsDD7um+//VZ5eXkaPny4w9jly5crNjZW9evXv+z+fH195evre93qBQAAgGtyZt9JzwkAAOD+PPr1CMHBwSooKJBhGPZ1M2fOVHx8vMLDwx3GLlmyRCNHjqztEgEAAOAG6DsBAABQHR490zYmJkYlJSVKSUnRXXfdpYULFyojI0Pbt293GFdYWKitW7dq0aJFJlUKAAAAV0bfCQAAgOrw6Jm2ISEhSk9PV1pamjp16qTMzExt2bKlwjvBli1bpttuu0316tUzqVIAAAC4MvpOAAAAVIdHz7SVpJEjR171v58tWbJEDz74YC1VBAAAAHdE3wkAAICq8uiZtlVRUFCg7du3Ky4uzuxSAAAA4MboOwEAAHCJx8+0vZqgoCAdP37c7DIAAADg5ug7AQAAcAkzbQEAAAAAAADAQghtAQAAAAAAAMBCCG0BAAAAAAAAwEJ4p21teGiTFBhodhUAAABwY0sGL1EgPScAAIBbYKYtAAAAAAAAAFgIoS0AAAAAAAAAWAihLQAAAAAAAABYCKEtAAAAAAAAAFgIoS0AAAAAAAAAWAihLQAAAAAAAABYCKEtAAAAAAAAAFgIoS0AAAAAAAAAWAihLQAAAAAAAABYCKEtAAAAAAAAAFgIoS0AAAAAAAAAWAihLQAAAAAAAABYCKEtAAAAAAAAAFgIoS0AAAAAAAAAWAihLQAAAAAAAABYCKEtAAAAAAAAAFiIt9kFuDPDMCRJhYWFJlcCAACAK7nUr13q31wJPScAAIDrqGrfSWh7HZ05c0aSFBoaanIlAAAAqIozZ84oKCjI7DKqhZ4TAADA9Vyt77QZrjidwEWUl5fr+++/V0xMjHbu3Gl2OS6vR48e2rFjh9llmMLdzt3Vzseq9VqlLjPqKCwsVGhoqI4eParAwMBaPTZgVVZ5JrgqwzB05swZNWvWTHXquNYbxC71nA0aNJDNZjO7HABOwDMd14LfH2vivtScu127qvadzLS9jurUqaMWLVrI29ubUMEJvLy8PPY6utu5u9r5WLVeq9RlZh2BgYGWuAaAFVjlmeDKXG2G7SWXek4A7oNnOq4Fvz/WxH2pOXe8dlXpO11rGoGLGjNmjNkluAVPvo7udu6udj5WrdcqdVmlDsDT8W8RANwHz3RcC35/rIn7UnOeeu14PQIAwOUUFhYqKChIBQUFbvcXVwAAAAAAmGkLAHA5vr6+euaZZ+Tr62t2KQAAAAAAOB0zbQEAAAAAAADAQphpCwAAAAAAAAAWQmgLAAAAAAAAABZCaOsGEhIS1LBhQ91xxx1ml+KyuIbuhfsJANdmxYoV6tChg9q1a6d58+aZXQ4AwMnol1FT/O5YE/fFPRHauoHx48drwYIFZpfh0riG7oX7CQA1d/HiRU2YMEHr1q3Trl279K9//Us//vij2WUBAJyIfhk1xe+ONXFf3BOhrRvo16+fGjRoYHYZLo1r6F64n9axadMmDR48WM2aNZPNZtPHH3981W02bNigyMhI+fr6KiwsTOnp6RXGvPLKK2rdurXq1aun3/3ud9q+fbvD5yUlJRozZoxuvPFGBQQEaPjw4Tp+/LjDmCNHjmjQoEHy9/dXkyZNNHnyZF28ePFaThdwC9u3b1enTp3UvHlzBQQEaODAgVq9erXZZQEAnIh+GTXF7441cV/ck8eGtmlpaYqIiFBgYKACAwPVu3dvffLJJ049RlXDiquFD64gJSVFNptNjz76qFP360nX0AqOHTumP/3pT7rxxhvl5+enzp07a+fOnU7bP/fT8xQXF6tLly565ZVXqjT+0KFDGjRokPr376+cnBw9+uij+utf/6pPP/3UPmbx4sWaMGGCnnnmGWVnZ6tLly6Ki4vTiRMn7GMee+wxZWRkaOnSpdq4caO+//57DRs2zP55WVmZBg0apAsXLmjr1q2aP3++0tPTNXXqVOedPPArycnJ6tGjhxo0aKAmTZpo6NChys3NdeoxnPGc/f7779W8eXP7z82bN9exY8ecWicAuCJXeY7DesgfrI9MA1bksaFtixYtlJKSoqysLO3cuVMxMTH64x//qK+//rrS8Z9//rlKS0srrN+7d2+F2VuXVCWsqEr40LVrV918880Vlu+//76aZ3197NixQ6+99poiIiKuOI5raG2nT59WdHS06tatq08++UR79+7V7Nmz1bBhw0rHcz9RFQMHDtRzzz2nhISEKo1/9dVX1aZNG82ePVsdO3bU2LFjdccdd2jOnDn2MampqUpMTNT999+v8PBwvfrqq/L399dbb70lSSooKNCbb76p1NRUxcTEKCoqSm+//ba2bt2qzMxMSdLq1au1d+9evfvuu+ratasGDhyoGTNm6JVXXtGFCxecfyEASRs3btSYMWOUmZmpNWvWqLS0VLfddpuKi4srHW/mcxYAUJErPcfpl62F/MHayDRgWQbsGjZsaMybN6/C+rKyMqNLly7GHXfcYVy8eNG+fv/+/UZISIjxwgsvXHXfkoyPPvqowvqePXsaY8aMcThWs2bNjOTk5GrVvn79emP48OHV2sYZzpw5Y7Rr185Ys2aN0bdvX2P8+PGVjuMaWt/jjz9u/N///V+VxnI/UROXu+e/dMstt1R4jrz11ltGYGCgYRiGcf78ecPLy6vCfkaNGmUMGTLEMAzDWLt2rSHJOH36tMOYli1bGqmpqYZhGMbTTz9tdOnSxeHzgwcPGpKM7Ozsap0XUFMnTpwwJBkbN26s8JmZz9nPP//cGDp0qP3z8ePHGwsXLqzOqQGAR7Dqc7yq6JfNRf5gDWQasDKPnWn7S2VlZVq0aJGKi4vVu3fvCp/XqVNHq1at0q5duzRq1CiVl5frm2++UUxMjIYOHaqkpKQaHffChQvKysrSgAEDHI41YMAAffHFFzU+n9o0ZswYDRo0yOEcKsM1tL7ly5ere/fuuvPOO9WkSRN169ZNb7zxRqVjuZ+4Xn744QeFhIQ4rAsJCVFhYaHOnTunU6dOqaysrNIxP/zwg30fPj4+uuGGG644prJ9XPoMqA0FBQWSpEaNGlX4zMznbM+ePfXVV1/p2LFjKioq0ieffKK4uLgaHQ8A3JlVn+OwNvIHayHTgJV5m12Amfbs2aPevXurpKREAQEB+uijjxQeHl7p2GbNmmndunW65ZZbdM899+iLL77QgAEDlJaWVuPjXyl82L9/f5X3M2DAAO3evVvFxcVq0aKFli5dWunD39kWLVqk7Oxs7dixo0rjuYbWdvDgQaWlpWnChAn6xz/+oR07dmjcuHHy8fHR6NGjK4znfgJAzZWXl+vRRx9VdHS0br755krHmPWc9fb21uzZs9W/f3+Vl5crKSlJN954Y42PCQDuyMrP8aqgX6595A/WQ6YBq/Po0LZDhw7KyclRQUGB3n//fY0ePVobN2687IOzZcuWeuedd9S3b1+1bdtWb775pmw2Wy1XXdFnn31W68c8evSoxo8frzVr1qhevXpV3o5raF3l5eXq3r27nn/+eUlSt27d9NVXX+nVV1+tNLSVuJ9wvqZNm1Z4H9Tx48cVGBgoPz8/eXl5ycvLq9IxTZs2te/jwoUL+umnnxxm2/56zK9f7n9pn5fGANfTmDFj9NVXX2nLli1XHGfWc3bIkCEaMmTIdT8OALgqqz/Hr4Z+ufaRP1gLmQZcgUe/HsHHx0dhYWGKiopScnKyunTporlz5152/PHjx/Xggw9q8ODBOnv2rB577LFrOn5wcPBVwwerysrK0okTJxQZGSlvb295e3tr48aNevHFF+Xt7a2ysrJKt+MaWtdNN91UoWHo2LGjjhw5ctltuJ9wtt69e2vt2rUO69asWWP/K7GPj4+ioqIcxpSXl2vt2rX2MVFRUapbt67DmNzcXB05csQ+pnfv3tqzZ4/Dy/3XrFmjwMDAyzbOgLOMHTtWK1as0Pr169WiRYsrjuU5CwDWw3McNUH+YC1kGnAFHh3a/lp5ebnOnz9f6WenTp1SbGysOnbsqA8//FBr167V4sWLNWnSpBofryrhg1XFxsZqz549ysnJsS/du3fXvffeq5ycHHl5eVXYhmtobdHR0crNzXVYd+DAAbVq1arS8dxPVEVRUZH9GSFJhw4dUk5Ojv2PAVOmTNGoUaPs4x966CEdPHhQSUlJ2r9/v/7zn/9oyZIlDs3QhAkT9MYbb2j+/Pnat2+fHn74YRUXF+v++++XJAUFBekvf/mLJkyYoPXr1ysrK0v333+/evfurV69ekmSbrvtNoWHh+vPf/6zdu/erU8//VRPPfWUxowZI19f31q6OvA0hmFo7Nix+uijj7Ru3Tq1adPmiuN5zgKAtfAchzORP5iLTAMuwexvQjPLE088YWzcuNE4dOiQ8eWXXxpPPPGEYbPZjNWrV1cYW1ZWZnTv3t2Ij483zp8/b1+fk5NjNGrUyP5t5L925swZY9euXcauXbsMSUZqaqqxa9cu49tvv7WPWbRokeHr62ukp6cbe/fuNR588EHjhhtuMH744Qfnn/R1drVvWuQaWtv27dsNb29vY+bMmUZeXp6xcOFCw9/f33j33XcrjOV+oqrWr19vSKqwjB492jAMwxg9erTRt2/fCtt07drV8PHxMdq2bWu8/fbbFfb70ksvGS1btjR8fHyMnj17GpmZmQ6fnzt3znjkkUeMhg0bGv7+/kZCQoKRn5/vMObw4cPGwIEDDT8/PyM4ONiYOHGiUVpa6szTBxw8/PDDRlBQkLFhwwYjPz/fvpw9e7bCWJ6zAGA9PMdRU+QProFMA1bjsaHtAw88YLRq1crw8fExGjdubMTGxlb6wLxk9erVxrlz5yqsz87ONo4ePVrpNlcLKy65WvjgKq70gDMMrqEryMjIMG6++WbD19fX+O1vf2u8/vrrlx3L/QSA6qns+Sep0j9MGAbPWQCwGp7jqCnyB9dApgGrsRmGYThp0i4AAAAAAAAA4BrxTlsAAAAAAAAAsBBCWwAAAAAAAACwEEJbAAAAAAAAALAQQlsAAAAAAAAAsBBCWwAAAAAAAACwEEJbAAAAAAAAALAQQlsAAAAAAAAAsBBCWwAAAAAAAACwEEJbAAAAAAAAALAQQlsAcCP9+vXTo48+Wq1t7rvvPg0dOrRa2/zwww+69dZbVb9+fd1www2SJJvNpo8//rha+wEAAABq6vDhw7LZbMrJyTG7FABwOm+zCwAAVN+GDRvUv39/nT592h6a1tTcuXNlGEa1tpkzZ47y8/OVk5OjoKCgazo+AAAA8Ev33XeffvrpJyYEAPBohLYA4OFqErp+8803ioqKUrt27a5DRQAAAAAAeDZejwAAtaxfv34aO3asxo4dq6CgIAUHB+vpp592mO36zjvvqHv37mrQoIGaNm2qe+65RydOnJD0838D69+/vySpYcOGstlsuu++++zblpeXKykpSY0aNVLTpk01bdq0K9bz69cj9OvXT+PGjbvsPlq3bq0PPvhACxYsqHDsSzZs2CCbzaaffvrJvi4nJ0c2m02HDx+2r9uyZYtuueUW+fn5KTQ0VOPGjVNxcbHDsZ5//nk98MADatCggVq2bKnXX3/d4Vjfffed7r77bjVq1Ej169dX9+7dtW3bNvvny5YtU2RkpOrVq6e2bdtq+vTpunjx4hWvCQAAAK6/999/X507d5afn59uvPFGDRgwQJMnT9b8+fO1bNky2Ww22Ww2bdiwQZK0fft2devWTfXq1VP37t21a9cuc08AAK4jQlsAMMH8+fPl7e2t7du3a+7cuUpNTdW8efPsn5eWlmrGjBnavXu3Pv74Yx0+fNgejoaGhuqDDz6QJOXm5io/P19z58512Hf9+vW1bds2/fOf/9Szzz6rNWvWVLu+y+1jx44duv322zVixIgKx66Ob775RrfffruGDx+uL7/8UosXL9aWLVs0duxYh3GzZ8+2N+WPPPKIHn74YeXm5kqSioqK1LdvXx07dkzLly/X7t27lZSUpPLycknS5s2bNWrUKI0fP1579+7Va6+9pvT0dM2cObNGNQMAAMA58vPzdffdd+uBBx7Qvn37tGHDBg0bNkzPPPOMRowYodtvv135+fnKz8/X73//exUVFekPf/iDwsPDlZWVpWnTpmnSpElmnwYAXDe8HgEATBAaGqo5c+bIZrOpQ4cO2rNnj+bMmaPExERJ0gMPPGAf27ZtW7344ovq0aOHioqKFBAQoEaNGkmSmjRpUuGdthEREXrmmWckSe3atdPLL7+stWvX6tZbb61yfVfaR+PGjeXr6ys/Pz81bdq0xtcgOTlZ9957r/2L09q1a6cXX3xRffv2VVpamurVqydJio+P1yOPPCJJevzxxzVnzhytX79eHTp00H//+1+dPHlSO3bssF+TsLAw+zGmT5+uJ554QqNHj5b087WcMWOGkpKS7OcHAACA2pefn6+LFy9q2LBhatWqlSSpc+fOkiQ/Pz+dP3/eoddMT09XeXm53nzzTdWrV0+dOnXSd999p4cfftiU+gHgemOmLQCYoFevXrLZbPafe/furby8PJWVlUmSsrKyNHjwYLVs2VINGjRQ3759JUlHjhy56r4jIiIcfr7pppvsr1aoKmfs42p2796t9PR0BQQE2Je4uDiVl5fr0KFDldZis9nUtGlTey05OTnq1q2bPbCt7BjPPvuswzESExOVn5+vs2fPOvV8AAAAUHVdunRRbGysOnfurDvvvFNvvPGGTp8+fdnx+/btU0REhP0P+9LPPTQAuCtm2gKAxRQXFysuLk5xcXFauHChGjdurCNHjiguLk4XLly46vZ169Z1+Nlms9lfF1BV17qPOnV+/pvgL9/TW1pa6jCmqKhIf/vb3zRu3LgK27ds2bJKtfj5+V2xjqKiIk2fPl3Dhg2r8NkvG34AAADULi8vL61Zs0Zbt27V6tWr9dJLL+nJJ590+G4CAPBkhLYAYIJfN6OZmZlq166dvLy8tH//fv34449KSUlRaGioJGnnzp0O4318fCTJPjPXaho3bizp5//21rBhQ0k/z4r9pcjISO3du9fhdQbVFRERoXnz5ul///tfpbNtIyMjlZube03HAAAAwPVhs9kUHR2t6OhoTZ06Va1atdJHH30kHx+fCn1ux44d9c4776ikpMT+x/fMzEwzygaAWsHrEQDABEeOHNGECROUm5ur9957Ty+99JLGjx8v6edZpj4+PnrppZd08OBBLV++XDNmzHDYvlWrVrLZbFqxYoVOnjypoqIiM07jssLCwhQaGqpp06YpLy9PK1eu1OzZsx3GPP7449q6davGjh2rnJwc5eXladmyZRW+iOxK7r77bjVt2lRDhw7V559/roMHD+qDDz7QF198IUmaOnWqFixYoOnTp+vrr7/Wvn37tGjRIj311FNOPV8AAABUz7Zt2/T8889r586dOnLkiD788EOdPHlSHTt2VOvWrfXll18qNzdXp06dUmlpqe655x7ZbDYlJiZq7969WrVqlWbNmmX2aQDAdUNoCwAmGDVqlM6dO6eePXtqzJgxGj9+vB588EFJP89STU9P19KlSxUeHq6UlJQKDWnz5s3tX7IVEhJSraCzNtStW1fvvfee9u/fr4iICL3wwgt67rnnHMZERERo48aNOnDggG655RZ169ZNU6dOVbNmzap8HB8fH61evVpNmjRRfHy8OnfurJSUFHl5eUmS4uLitGLFCq1evVo9evRQr169NGfOHPuXXQAAAMAcgYGB2rRpk+Lj49W+fXs99dRTmj17tgYOHKjExER16NBB3bt3V+PGjfX5558rICBAGRkZ2rNnj7p166Ynn3xSL7zwgtmnAQDXjc345QsHAQDXXb9+/dS1a1f9+9//NrsUAAAAAABgQcy0BQAAAAAAAAALIbQFAAAAAAAAAAvh9QgAAAAAAAAAYCHMtAUAAAAAAAAACyG0BQAAAAAAAAALIbQFAAAAAAAAAAshtAUAAAAAAAAACyG0BQAAAAAAAAALIbQFAAAAAAAAAAshtAUAAAAAAAAACyG0BQAAAAAAAAALIbQFAAAAAAAAAAv5fy/c39aHhZmHAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[PCA] Analysis complete\n" + ] + } + ], + "source": [ + "res = lv.perform_pca_and_analysis(\n", + " theta_history,\n", + " objective,\n", + " n_steps=300,\n", + " offset=0.5,\n", + " n_top=12,\n", + " circuit=ansatz,\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/landscape_tools/_version.py b/landscape_tools/_version.py index 44cb623..11fc61a 100644 --- a/landscape_tools/_version.py +++ b/landscape_tools/_version.py @@ -2,4 +2,7 @@ from setuptools_scm import get_version -__version__ = get_version(relative_to=Path(__file__).parent.parent) +try: + __version__ = get_version(relative_to=Path(__file__).parent.parent) +except: + __version__ = None diff --git a/landscape_tools/barren_plateaus.py b/landscape_tools/barren_plateaus.py index c156f6a..26d5eba 100644 --- a/landscape_tools/barren_plateaus.py +++ b/landscape_tools/barren_plateaus.py @@ -1,13 +1,24 @@ """Module meant to study barren plateaus""" +import os from collections import defaultdict from itertools import repeat -from typing import Any, Callable, Literal, Sequence, TypeVar +from typing import ( + Any, + Callable, + Literal, + Optional, + Protocol, + Sequence, + TypedDict, + TypeVar, +) import matplotlib.pyplot as plt import numpy as np from matplotlib.lines import Line2D from numpy.typing import ArrayLike +from qiskit import QuantumCircuit from qiskit.quantum_info import Pauli from tqdm.auto import tqdm @@ -15,6 +26,8 @@ from dataclasses import dataclass +PaddingType = Literal["identity", "I", "linear_half", "log"] + @dataclass class SamplingConfig: @@ -59,7 +72,7 @@ class ExperimentConfig: initial_Pauli_string: Pauli | str | None = None """Initial Pauli string used when observables are generated by padding.""" - padding_types: Sequence[str] | None = None + padding_types: Sequence[PaddingType] | None = None """Padding strategies used to grow the initial Pauli string with the number of qubits.""" @@ -68,12 +81,12 @@ def extend_with_last( lst: Sequence[T], target_len: int, ) -> list[T]: - """ - Extend a sequence to a target length by repeating its last element. + """Extend a sequence to a target length by repeating its last element. Args: lst: Input sequence to extend. Must not be empty. - target_len: Desired length of the output list. + target_len: Desired minimum length of the output list. If target_len is + smaller than len(lst), the original list is returned unchanged. Returns: A list extended to ``target_len`` by repeating the last element. @@ -86,78 +99,52 @@ def extend_with_last( def pad_pauli_strings_growth( - pauli: Pauli, + pauli: Pauli | str, target_n: int, - growth: Literal["identity", "I", "linear_half", "log"] = "linear_half", + growth: PaddingType = "linear_half", log_base: float = 2, ) -> Pauli: """Pad a Pauli string on the left to reach a target number of qubits. Args: pauli: Input Pauli string. (for instance ``Pauli("IIYY")``) - target_n: - Desired total number of qubits. - growth: - Padding strategy. Available options are: - - "identity" or "I": - Pad with identity operators only. - - "linear_half": - Pad with X, Y or Z operators such that the total number - of X/Y/Z operators is approximately ``target_n / 2``. - - "log": - Pad with X, Y or Z operators such that the total number - of X/Y/Z operators is approximately ``log(target_n)``. - log_base: - Base of the logarithm used when ``growth="log"``. + target_n: Desired total number of qubits. + growth: Padding strategy. Available options are: + + - "identity" or "I": Pad with identity operators only. + - "linear_half": Pad with X, Y or Z operators such that the total + number of X/Y/Z operators is approximately ``target_n / 2``. + - "log": Pad with X, Y or Z operators such that the total number + of X/Y/Z operators is approximately ``log(target_n)``. + log_base: Base of the logarithm used when ``growth="log"``. Returns: - Pauli: - Padded Pauli string of size ``target_n``. + Padded Pauli string of size ``target_n``. """ - def round_value(x): + def round_value(x: float): return int(np.ceil(x)) - def target_number_of_active_paulis(n): - + def target_number_of_active_paulis(n: int): if growth == "linear_half": return round_value(n / 2) - elif growth == "log": - - if n <= 1: - return 1 - - return round_value(np.log(n) / np.log(log_base)) - + return 1 if n <= 1 else round_value(np.log(n) / np.log(log_base)) else: - raise ValueError( - "growth must be " "'identity', 'I', " "'linear_half', or 'log'" - ) + raise ValueError("growth must be 'identity', 'I', 'linear_half', or 'log'") - label = pauli.to_label() + label = pauli.to_label() if isinstance(pauli, Pauli) else pauli n_current = len(label) - if n_current > target_n: - raise ValueError( - f"Pauli {label} has length " f"{n_current} > target_n={target_n}" - ) - + raise ValueError(f"Pauli {label} has length {n_current} > target_n={target_n}") n_padding = target_n - n_current - # -------------------- Case 1: padding with I -------------------- - if growth in ["identity", "I"]: - padding = "I" * n_padding - padded_label = padding + label - return Pauli(padded_label) - # -------------------- Case 2: padding with increasing X/Y/Z -------------------- - if "Z" in label: pad_char = "Z" elif "Y" in label: @@ -168,23 +155,11 @@ def target_number_of_active_paulis(n): pad_char = "Y" current_count = label.count(pad_char) - target_count = target_number_of_active_paulis(target_n) - - n_active_to_add = max( - 0, - target_count - current_count, - ) - - n_active_to_add = min( - n_active_to_add, - n_padding, - ) - + n_active_to_add = max(0, target_count - current_count) + n_active_to_add = min(n_active_to_add, n_padding) n_identity_to_add = n_padding - n_active_to_add - padding = "I" * n_identity_to_add + pad_char * n_active_to_add - padded_label = padding + label return Pauli(padded_label) @@ -198,13 +173,12 @@ def bootstrap_var_diagnostic_1d( rel_err_warn: float = 0.05, rel_err_fail: float = 0.10, ) -> dict[str, Any]: - """ - Perform a bootstrap diagnostic for a single standard deviation estimate. + """Perform a bootstrap diagnostic for a single variance estimate. Args: var: Reference estimate of the variance of the loss. - L_samples: Array of loss values evaluated for different - parameter samples. Can have shape ``(N_samples,)`` or ``(N_samples, 1)``. + L_samples: Array of loss values evaluated for different parameter + samples. Can have shape ``(N_samples,)`` or ``(N_samples, 1)``. B: Number of bootstrap resamples. Default is 500. rng: Random number generator for reproducibility. If ``None``, a default generator is used. @@ -213,7 +187,6 @@ def bootstrap_var_diagnostic_1d( Returns: Dictionary containing diagnostic quantities, including: - - bootstrap estimates of the standard deviation - relative error metrics - diagnostic flags based on thresholds @@ -223,8 +196,6 @@ def bootstrap_var_diagnostic_1d( rng = np.random.default_rng() assert rng is not None - # -------------------- Make sure L_samples is one-dimensional -------------------- - L_samples = np.asarray(L_samples, dtype=float) if L_samples.ndim == 2: @@ -242,13 +213,7 @@ def bootstrap_var_diagnostic_1d( ) N_samples = len(L_samples) - - # -------------------- Reference estimator -------------------- - score = float(var) - - # -------------------- Bootstrap -------------------- - boot_scores = np.empty(B) for b in range(B): @@ -257,13 +222,9 @@ def bootstrap_var_diagnostic_1d( boot_scores[b] = np.var(Lb, ddof=1) - # -------------------- Error estimates -------------------- - score_se = np.std(boot_scores, ddof=1) score_rel_err = score_se / max(abs(score), 1e-30) - # -------------------- Diagnostic message -------------------- - if score_rel_err > rel_err_fail: advice = "/!\\ Increase N_samples." elif score_rel_err > rel_err_warn: @@ -323,12 +284,12 @@ def adaptive_sampling_var( If ``None``, no explicit cap is applied apart from ``N_max``. abs_err_target: Optional absolute bootstrap error target. If provided, the algorithm stops when either: - - ``relative_error <= rel_err_target``, or - ``absolute_error <= abs_err_target``. - This is particularly useful when the standard deviation is very small and relative error becomes overly strict. + n_jobs: Number of parallel jobs used when drawing new samples. + Passed to joblib.Parallel. A value of -1 usually uses all available cores. Returns: A the three following elements: an array containing all collected @@ -341,7 +302,7 @@ def adaptive_sampling_var( L_samples = [] diagnostic = None - var = None + var: Optional[np.ndarray] = None while True: @@ -394,26 +355,20 @@ def adaptive_sampling_var( ) L_samples.extend(results) - - # for _ in tqdm( - # range(n_to_add), - # desc=f"Sampling batch N={n_current}->{n_current + n_to_add}", - # leave=False, - # ): - # L_val = sample_function() - # L_samples.append(L_val) - L_samples_array = np.asarray(L_samples) # -------------------- Compute current var -------------------- var = np.var(L_samples_array, axis=0, ddof=1) + assert var is not None # -------------------- Pick observable for diagnostic -------------------- + var_obs: float + if L_samples_array.ndim == 1: L_samples_obs = L_samples_array - var_obs = var + var_obs = float(var) else: L_samples_obs = L_samples_array[:, observable_index] var_obs = var[observable_index] @@ -478,14 +433,24 @@ def adaptive_sampling_var( ) break + assert var is not None return np.asarray(L_samples), var, diagnostic +class Result(TypedDict): + nq: int + var: float | np.ndarray + obs: Optional[Pauli] + + +class LayerResult(Result): + lay: int + + def plot_layerwise_qubits( - results: dict, + results: dict[int, list[Result]], N_layers: Sequence[int], - get_obs_label: Callable, - make_param_text: Callable, + make_param_text: str, ) -> None: """Plot the variance of loss values as a function of the number of qubits for different circuit depths. @@ -497,21 +462,21 @@ def plot_layerwise_qubits( - "var": variance value - "obs": observable identifier N_layers: Sequence of circuit depths to display. - get_obs_label: Callable used to generate observable labels. - make_param_text: Callable returning the parameter summary text displayed + make_param_text: Parameter summary text displayed on the figure. """ - param_text = make_param_text() + param_text = make_param_text - layer_colors = plt.cm.tab10(np.linspace(0, 1, max(len(N_layers), 1))) + layer_colors = plt.cm.tab10( # pyright: ignore[reportAttributeAccessIssue] + np.linspace(0, 1, max(len(N_layers), 1)) + ) layer_to_color = { lay: layer_colors[i % len(layer_colors)] for i, lay in enumerate(N_layers) } plt.figure(figsize=(12, 7)) - obs_label = None for lay in N_layers: if lay not in results: @@ -521,9 +486,6 @@ def plot_layerwise_qubits( xs = [d["nq"] for d in pts] ys = [d["var"] for d in pts] - if obs_label is None: - obs_label = get_obs_label(pts[0]["obs"], 0) - plt.semilogy( xs, ys, @@ -534,9 +496,6 @@ def plot_layerwise_qubits( label=None, ) - if obs_label is None: - obs_label = f"P_{0}" - plt.xlabel(r"Number of qubits $n_q$") plt.ylabel(r"$\mathrm{Var}_{\theta}(L)$") plt.title("Loss landscape concentration with increasing system size") @@ -560,12 +519,12 @@ def plot_layerwise_qubits( handlelength=4, ) plt.text( - 0.98, - 0.98, + 0.02, + 0.02, param_text, transform=plt.gca().transAxes, - ha="right", - va="top", + ha="left", + va="bottom", fontsize=11, bbox=dict( boxstyle="round", @@ -580,12 +539,11 @@ def plot_layerwise_qubits( def plot_layerwise_qubits_padding( - results: dict, + results: dict[tuple[int, Optional[PaddingType]], list[Result]], N_layers: Sequence[int], - padding_types: Sequence[str], + padding_types: Optional[Sequence[PaddingType]], padding_latex: dict[str, str], - get_obs_label: Callable, - make_param_text: Callable, + make_param_text: str, ) -> None: """Plot the variance of loss values as a function of the number of qubits for different circuit depths and padding strategies. @@ -600,58 +558,47 @@ def plot_layerwise_qubits_padding( padding_types: Sequence of padding strategies to include in the plot. padding_latex: Mapping from padding strategy identifiers to LaTeX labels used in the legend. - get_obs_label: Callable used to generate observable labels. - make_param_text: Callable returning the parameter summary text displayed + make_param_text: Parameter summary text displayed on the figure. """ - param_text = make_param_text() + param_text = make_param_text markers = ["o", "s", "^", "D", "v", "P", "X"] linestyles = ["-", "--", "-.", ":"] - layer_colors = plt.cm.tab10(np.linspace(0, 1, max(len(N_layers), 1))) + layer_colors = plt.cm.tab10( # pyright: ignore[reportAttributeAccessIssue] + np.linspace(0, 1, max(len(N_layers), 1)) + ) layer_to_color = { lay: layer_colors[i % len(layer_colors)] for i, lay in enumerate(N_layers) } padding_to_marker = { - pad: markers[i % len(markers)] for i, pad in enumerate(padding_types) + pad: markers[i % len(markers)] for i, pad in enumerate(padding_types or [None]) } padding_to_linestyle = { - pad: linestyles[i % len(linestyles)] for i, pad in enumerate(padding_types) + pad: linestyles[i % len(linestyles)] + for i, pad in enumerate(padding_types or [None]) } plt.figure(figsize=(12, 7)) - obs_label = None - for lay in N_layers: - for pad in padding_types: + for pad in padding_types or [None]: key = (lay, pad) - if key not in results: continue - pts = sorted( - results[key], - key=lambda d: d["nq"], - ) + pts = sorted(results[key], key=lambda d: d["nq"]) xs = [d["nq"] for d in pts] - ys = [d["var"] for d in pts] - if obs_label is None: - obs_label = get_obs_label( - pts[0]["obs"], - 0, - ) - plt.semilogy( xs, ys, @@ -663,9 +610,6 @@ def plot_layerwise_qubits_padding( label=None, ) - if obs_label is None: - obs_label = "P_0" - plt.xlabel(r"Number of qubits $n_q$") plt.ylabel(r"$\mathrm{Var}_{\theta}(L)$") @@ -675,31 +619,26 @@ def plot_layerwise_qubits_padding( plt.grid(True, alpha=0.4) handles_L = [ - Line2D( - [0], - [0], - color=layer_to_color[lay], - lw=2, - label=rf"$L={lay}$", - ) + Line2D([0], [0], color=layer_to_color[lay], lw=2, label=rf"$L={lay}$") for lay in N_layers ] - handles_padding = [ - Line2D( - [0], - [0], - color="black", - linestyle=padding_to_linestyle[pad], - marker=padding_to_marker[pad], - lw=2, - label=padding_latex.get( - pad, - str(pad), - ), - ) - for pad in padding_types - ] + handles_padding = ( + [] + if padding_types is None + else [ + Line2D( + [0], + [0], + color="black", + linestyle=padding_to_linestyle[pad], + marker=padding_to_marker[pad], + lw=2, + label=padding_latex.get(pad, str(pad)), + ) + for pad in padding_types + ] + ) plt.legend( handles=handles_L + handles_padding, @@ -709,21 +648,17 @@ def plot_layerwise_qubits_padding( handlelength=4, ) plt.text( - 0.98, - 0.98, + 0.02, + 0.02, param_text, transform=plt.gca().transAxes, - ha="right", - va="top", + ha="left", + va="bottom", fontsize=11, - bbox=dict( - boxstyle="round", - facecolor="white", - edgecolor="gray", - alpha=0.55, - ), + bbox=dict(boxstyle="round", facecolor="white", edgecolor="gray", alpha=0.55), ) plt.tight_layout() + os.makedirs("figures", exist_ok=True) plt.savefig("figures/layerwise_qubits_padding.pdf") plt.show() @@ -734,7 +669,7 @@ def plot_joint_scaling_padding( B_ext: Sequence[int], N_qubits: Sequence[int], N_layers: Sequence[int], - padding_type: str, + padding_type: str | None, padding_latex: dict[str, str], Ansatz: str, rel_err_target: float, @@ -744,7 +679,7 @@ def plot_joint_scaling_padding( function of system size and circuit depth for a given padding strategy. Args: - tracked: Sequence of tracked standard deviation values. + tracked: Sequence of tracked variance values. A_ext: Extended sequence associated with the primary scan axis. B_ext: Extended sequence associated with the secondary grouping axis. N_qubits: Sequence of qubit counts considered in the scan. @@ -752,7 +687,6 @@ def plot_joint_scaling_padding( padding_type: Identifier of the padding strategy used. padding_latex: Mapping from padding strategy identifiers to LaTeX labels. Ansatz: Name of the variational ansatz displayed in the figure. - use_state_vector: Whether state-vector simulation is used. rel_err_target: Target relative error displayed in the figure annotations. """ @@ -768,7 +702,6 @@ def plot_joint_scaling_padding( sec_label = "n" tracked = np.array(tracked) - n_P = 1 padding_label = padding_latex.get( padding_type, @@ -808,12 +741,7 @@ def plot_joint_scaling_padding( xs, ys = zip(*pts) plt.plot( - xs, - ys, - "-o", - linewidth=2, - markersize=5, - label=rf"${sec_label} = {s_val}$", + xs, ys, "-o", linewidth=2, markersize=5, label=rf"${sec_label} = {s_val}$" ) plt.xlabel(x_label) @@ -822,19 +750,14 @@ def plot_joint_scaling_padding( plt.grid(True, alpha=0.4) plt.legend() plt.text( - 0.98, - 0.98, + 0.02, + 0.02, param_text, transform=plt.gca().transAxes, - ha="right", - va="top", + ha="left", + va="bottom", fontsize=11, - bbox=dict( - boxstyle="round", - facecolor="white", - edgecolor="gray", - alpha=0.85, - ), + bbox=dict(boxstyle="round", facecolor="white", edgecolor="gray", alpha=0.85), ) plt.yscale("log") plt.tight_layout() @@ -842,16 +765,51 @@ def plot_joint_scaling_padding( plt.show() +class AnalysisResult(TypedDict): + tracked: np.ndarray + metadata: list[Result] + N_qubits_extended: list[int] + N_layers_extended: list[int] + padding_type: PaddingType | None + + +class CostFunctionContext(TypedDict): + n_qubits: int + depth: int + Ansatz: str + circuits: QuantumCircuit + observables: Optional[Pauli] + + +class CostFunctionBuilder(Protocol): + def __call__( + self, context: CostFunctionContext, *args: Any, **kwargs: Any + ) -> Callable[[list[float]], float]: ... + + +class VarianceNormalisation(Protocol): + def __call__( + self, + n_qubits: int, + depth: int, + Ansatz: str, + observable: Pauli | None, + context: CostFunctionContext, + raw_var: np.ndarray, + L_samples: np.ndarray, + ) -> float: ... + + def barren_plateaus_analysis( experiment: ExperimentConfig, - cost_function_builder: Callable, - generate_params: Callable, - generate_circuits: Callable, + cost_function_builder: CostFunctionBuilder, + generate_params: Callable[[int, int], list[float]], + generate_circuits: Callable[[int, int, str], QuantumCircuit], sampling: SamplingConfig | None = None, execution: ExecutionConfig | None = None, - variance_normalization: Callable | None = None, - **cost_kwargs, -) -> dict: + variance_normalization: VarianceNormalisation | None = None, + **cost_kwargs: Any, +) -> AnalysisResult | dict[int, list[Result]]: """Run a barren plateau scaling analysis for a given experiment configuration. The function builds the requested circuits and cost functions, samples loss @@ -877,9 +835,8 @@ def barren_plateaus_analysis( builder. Returns: - Dictionary containing the variance estimates, diagnostics, and metadata - produced by the selected analysis. The exact structure depends on the - selected analysis_type. + Results produced by the selected analysis type. The returned objects contain + variance estimates and metadata such as qubit count, layer count and observable. """ # -------------------- Validation -------------------- @@ -903,35 +860,51 @@ def barren_plateaus_analysis( ) if experiment.analysis_type == "layerwise_qubits": - if experiment.observables_list is None: - raise ValueError( - "analysis_type='layerwise_qubits' requires observables_list." - ) - if len(experiment.N_qubits) != len(experiment.observables_list): + + if experiment.observables_list is not None and len(experiment.N_qubits) != len( + experiment.observables_list + ): raise ValueError( "For analysis_type='layerwise_qubits', " "N_qubits and observables_list must have the same length." ) if experiment.analysis_type == "layerwise_qubits_padding": - if experiment.initial_Pauli_string is None: - raise ValueError( - "analysis_type='layerwise_qubits_padding' requires initial_Pauli_string." - ) - if experiment.padding_types is None: + + if experiment.padding_types is None and experiment.initial_Pauli_string is None: + pass + + elif ( + experiment.padding_types is None or experiment.initial_Pauli_string is None + ): raise ValueError( - "analysis_type='layerwise_qubits_padding' requires padding_types." + "analysis_type='layerwise_qubits_padding' requires " + "padding_types and initial_Pauli_string to either " + "both be None or both be defined." ) if experiment.analysis_type == "joint_scaling_padding": - if experiment.initial_Pauli_string is None: + + if experiment.padding_types is None and experiment.initial_Pauli_string is None: + pass + + elif ( + experiment.padding_types is None or experiment.initial_Pauli_string is None + ): raise ValueError( - "analysis_type='joint_scaling_padding' requires initial_Pauli_strings." + "analysis_type='joint_scaling_padding' requires " + "padding_types and initial_Pauli_string to either " + "both be None or both be defined." ) # -------------------- Helpers -------------------- - def run_single_point(nq, lay, obs_list_builder, extra_print=None): + def run_single_point( + nq: int, + lay: int, + obs_list_builder: Optional[Callable[[int], Pauli]] | None, + extra_print: Optional[str] = None, + ) -> LayerResult: print("--------------------") print(f"Number of qubits: {nq}") print(f"Number of layers: {lay}") @@ -944,11 +917,12 @@ def run_single_point(nq, lay, obs_list_builder, extra_print=None): circuit = generate_circuits(n_qubits, depth, experiment.ansatz_name) - observable = obs_list_builder(nq) + observable = obs_list_builder(nq) if obs_list_builder is not None else None - print(f"Pauli string: {observable}") + if observable is not None: + print(f"Pauli string: {observable}") - context = { + context: CostFunctionContext = { "n_qubits": n_qubits, "depth": depth, "Ansatz": experiment.ansatz_name, @@ -1017,38 +991,24 @@ def sample_once(): "obs": observable, } - def get_obs_label(obs, j): - try: - return obs["F_0"][j].to_label() - except Exception: - return f"P_{j}" + use_state_vector = cost_kwargs.get("use_state_vector", None) + shots = cost_kwargs.get("shots", None) - def make_param_text(extra_lines=None): - use_state_vector = cost_kwargs.get("use_state_vector", None) - shots = cost_kwargs.get("shots", None) - - lines = [ - f"{experiment.ansatz_name}", - ] - - if use_state_vector is not None: - lines.append(f"state_vector = {use_state_vector}") + lines = [ + f"{experiment.ansatz_name}", + ] - if use_state_vector is False and shots is not None: - lines.append(f"shots = {shots:.0e}") + if use_state_vector is not None: + lines.append(f"state_vector = {use_state_vector}") - lines.append( - f"$\\epsilon_{{rel}} = {sampling.rel_err_target:.0%}$".replace("%", "\\%") - ) + if use_state_vector is False and shots is not None: + lines.append(f"shots = {shots:.0e}") - if extra_lines is not None: - if isinstance(extra_lines, str): - lines.insert(1, extra_lines) - else: - for line in reversed(extra_lines): - lines.insert(1, line) + lines.append( + f"$\\epsilon_{{rel}} = {sampling.rel_err_target:.0%}$".replace("%", "\\%") + ) - return "\n".join(lines) + param_text = "\n".join(lines) padding_latex = { "identity": r"$I^{n_q}$", @@ -1064,35 +1024,44 @@ def make_param_text(extra_lines=None): results = defaultdict(list) for lay in experiment.N_layers: - for nq, Pauli_string in zip( - experiment.N_qubits, experiment.observables_list - ): - def obs_builder(target_n): + if experiment.observables_list is None: + iterable = [(nq, None) for nq in experiment.N_qubits] + else: + iterable = zip( + experiment.N_qubits, + experiment.observables_list, + ) - if isinstance(Pauli_string, Pauli): - label = Pauli_string.to_label() - pauli = Pauli_string + for nq, Pauli_string in iterable: - elif isinstance(Pauli_string, str): - label = Pauli_string - pauli = Pauli(Pauli_string) + if Pauli_string is None: + obs_builder_1 = None - else: - raise TypeError("Pauli_string must be a Pauli or a string") + else: - if len(label) != target_n: - raise ValueError( - f"Pauli string size mismatch: got '{label}' " - f"(len={len(label)}), expected {target_n}" - ) + def obs_builder_1(target_n: int): - return pauli + if isinstance(Pauli_string, Pauli): + label = Pauli_string.to_label() + pauli = Pauli_string + + else: + label = Pauli_string + pauli = Pauli(Pauli_string) + + if len(label) != target_n: + raise ValueError( + f"Pauli string size mismatch: got '{label}' " + f"(len={len(label)}), expected {target_n}" + ) + + return pauli point = run_single_point( nq=nq, lay=lay, - obs_list_builder=obs_builder, + obs_list_builder=obs_builder_1, ) results[lay].append(point) @@ -1100,8 +1069,7 @@ def obs_builder(target_n): plot_layerwise_qubits( results=results, N_layers=experiment.N_layers, - get_obs_label=get_obs_label, - make_param_text=make_param_text, + make_param_text=param_text, ) return results @@ -1112,23 +1080,50 @@ def obs_builder(target_n): results = defaultdict(list) + if experiment.padding_types is None and experiment.initial_Pauli_string is None: + padding_iter = [None] + + elif ( + experiment.padding_types is None or experiment.initial_Pauli_string is None + ): + raise ValueError( + "padding_types and initial_Pauli_string must either " + "both be None or both be defined." + ) + + else: + padding_iter = experiment.padding_types + for lay in experiment.N_layers: - assert experiment.padding_types is not None - for pad in experiment.padding_types: + + for pad in padding_iter: + for nq in experiment.N_qubits: - def obs_builder(target_n, pad=pad): - return pad_pauli_strings_growth( - experiment.initial_Pauli_string, - target_n=target_n, - growth=pad, - ) + if pad is None: + layerwise_obs_builder = None + extra_print = None + + else: + + def layerwise_obs_builder( + target_n: int, + pad: PaddingType = pad, + ): + assert experiment.initial_Pauli_string is not None + return pad_pauli_strings_growth( + experiment.initial_Pauli_string, + target_n=target_n, + growth=pad, + ) + + extra_print = f"Padding type: {pad}" point = run_single_point( nq=nq, lay=lay, - obs_list_builder=obs_builder, - extra_print=f"Padding type: {pad}", + obs_list_builder=layerwise_obs_builder, + extra_print=extra_print, ) results[(lay, pad)].append(point) @@ -1138,8 +1133,7 @@ def obs_builder(target_n, pad=pad): N_layers=experiment.N_layers, padding_types=experiment.padding_types, padding_latex=padding_latex, - get_obs_label=get_obs_label, - make_param_text=make_param_text, + make_param_text=param_text, ) return results @@ -1155,31 +1149,51 @@ def obs_builder(target_n, pad=pad): A_ext = extend_with_last(experiment.N_qubits, L) B_ext = extend_with_last(experiment.N_layers, L) - for nq, lay in zip(A_ext, B_ext): + if experiment.padding_types is None and experiment.initial_Pauli_string is None: + obs_builder = None + padding_type = None + extra_print = None - def obs_builder(target_n): + elif ( + experiment.padding_types is None or experiment.initial_Pauli_string is None + ): + raise ValueError( + "padding_types and initial_Pauli_string must either " + "both be None or both be defined." + ) + + else: + + padding_type = experiment.padding_types[0] + + def obs_builder(target_n: int): + assert experiment.initial_Pauli_string is not None return pad_pauli_strings_growth( experiment.initial_Pauli_string, target_n=target_n, - growth=experiment.padding_types[0], + growth=padding_type, ) + extra_print = f"Padding type: {padding_type}" + + for nq, lay in zip(A_ext, B_ext): + point = run_single_point( nq=nq, lay=lay, obs_list_builder=obs_builder, - extra_print=f"Padding type: {experiment.padding_types[0]}", + extra_print=extra_print, ) tracked.append(point["var"]) metadata.append(point) - results = { + joint_scaling_results: AnalysisResult = { "tracked": np.array(tracked), "metadata": metadata, "N_qubits_extended": A_ext, "N_layers_extended": B_ext, - "padding_type": experiment.padding_types[0], + "padding_type": padding_type, } plot_joint_scaling_padding( @@ -1188,12 +1202,12 @@ def obs_builder(target_n): B_ext=B_ext, N_qubits=experiment.N_qubits, N_layers=experiment.N_layers, - padding_type=experiment.padding_types[0], + padding_type=padding_type, padding_latex=padding_latex, Ansatz=experiment.ansatz_name, rel_err_target=sampling.rel_err_target, ) - return results + return joint_scaling_results return {} diff --git a/landscape_tools/landscape_visualization.py b/landscape_tools/landscape_visualization.py index 52fe92e..f526ec7 100644 --- a/landscape_tools/landscape_visualization.py +++ b/landscape_tools/landscape_visualization.py @@ -1,22 +1,14 @@ -import pickle import re -from typing import Any, Callable, Dict +from typing import Any, Callable, Dict, TypeAlias import matplotlib.colors as colors -import matplotlib.patheffects as pe import matplotlib.pyplot as plt import numpy as np -import numpy.typing as npt -from matplotlib.cm import get_cmap +from joblib import Parallel, delayed from matplotlib.colors import LogNorm, Normalize -from matplotlib.patches import Rectangle -from matplotlib.ticker import FuncFormatter from numpy.typing import NDArray -from scipy.interpolate import RegularGridInterpolator from sklearn.decomposition import PCA from tqdm.auto import tqdm -from typing import TypeAlias -from joblib import Parallel, delayed ArrayLike: TypeAlias = NDArray[np.float64] ParameterVector: TypeAlias = NDArray[np.float64] @@ -32,14 +24,18 @@ def loss_scan_1d( n_jobs: int = -1, ) -> None: """ - Evaluate the loss function along a one-dimensional direction in parameter space. + Evaluate and plot the loss function along a one-dimensional direction in parameter space. Parameters: - params: Parameter vectors organized by component. - direction: Direction in parameter space used for the scan. + params: Reference parameter vector. + direction: Direction in parameter space used for the scan. It is normalized by its maximum absolute value. loss_function: Callable returning the loss for a given parameter vector. n_steps: Number of scan points. Default is 200. end_points: Bounds of the scan parameter. Default is (-π, π). + n_jobs: Number of parallel jobs used to evaluate the loss. Default is -1. + + Side effects: + Saves the figure to ``figures/landscape1d.pdf`` and displays it. """ # -------------------- Initialization -------------------- @@ -109,17 +105,22 @@ def loss_scan_2d_3d( n_jobs: int = -1, ) -> None: """ - Evaluate the loss function on a two-dimensional parameter plane. + Evaluate and plot the loss function on a two-dimensional parameter plane. Parameters: - params: Parameter vectors organized by component. - direction1: First scan direction in parameter space. - direction2: Second scan direction in parameter space. + params: Reference parameter vector. + direction1: First scan direction in parameter space. It is normalized by its maximum absolute value. + direction2: Second scan direction in parameter space. It is normalized by its maximum absolute value. loss_function: Callable returning the loss for a given parameter vector. n_steps: Number of points per scan direction. Default is 100. end_points_x: Bounds of the scan parameter along the first direction. Default is (-π, π). end_points_y: Bounds of the scan parameter along the second direction. Default is (-π, π). plot3D: Whether to generate a 3D visualization of the loss surface. Default is True. + n_jobs: Number of parallel jobs used to evaluate the loss. Default is -1. + + Side effects: + Saves the 2D figure to ``figures/landscape2d.pdf`` and, if requested, + the 3D figure to ``figures/landscape3d.pdf``. Displays the generated figures. """ # -------------------- Initialization -------------------- @@ -248,25 +249,27 @@ def pca_loss_scan( Evaluate the loss function in the PCA subspace of an optimization trajectory. Parameters: - params_history: Array containing successive optimization records. + params_history: Array containing the successive parameter vectors of the optimization trajectory. loss_function: Callable returning the loss for a given parameter vector. n_steps: Number of grid points per PCA axis. Default is 200. - offset: Margin added to the PCA scan bounds. Default is 0.5. + offset: Margin added to the PCA scan bounds. If a scalar is provided, it is converted to + (-abs(offset), abs(offset)). Default is 0.5. compute_traj_loss: Whether to evaluate the loss along the original trajectory. Default is True. + n_jobs: Number of parallel jobs used to evaluate the loss. Default is -1. + backend: Joblib backend used for parallel loss evaluations. Default is "loky". Returns: Mapping containing the PCA scan results and related metadata, including: - X, Y: PCA grid coordinates - Z: Loss values on the PCA grid - traj_xy: Trajectory projected onto the PCA plane - - traj_z: Loss values along the trajectory (if computed) - - param_history: Parameter trajectory - - param0: Reference parameter vector + - traj_z: Loss values along the trajectory if compute_traj_loss is True, otherwise None + - param_history: Parameter trajectory used to fit the PCA + - param0: Reference parameter vector used as the center of the scan - pca: Fitted PCA object - - explained_variance_ratio: Variance explained by each component + - explained_variance_ratio: Variance explained by each PCA component - components: PCA component vectors - - x_range, y_range: Scan bounds - - records: Raw optimization records + - x_range, y_range: Scan bounds along the PCA axes """ # -------------------- Load optimization records -------------------- @@ -402,6 +405,12 @@ def plot_pca_loss_scan_2d( show_colorbar: Whether to display a colorbar. Default is True. trajectory_kwargs: Optional keyword arguments for trajectory plotting. + Notes: + - The figure is saved to + ``figures/pcaLandscape2d.pdf``. + - If ``LogNorm()`` is used for normalization, + the values in ``Z`` must be strictly positive. + Returns: fig: Figure containing the plot. ax: Axis on which the plot is drawn. @@ -466,12 +475,10 @@ def plot_pca_loss_scan_2d( def plot_pca_loss_scan_3d( scan_result: dict, - ax: plt.Axes | None = None, cmap: str = "viridis", elev: float = 30, azim: float = -60, alpha_surface: float = 0.85, - show_trajectory: bool = True, trajectory_kwargs: dict | None = None, ): """ @@ -479,33 +486,35 @@ def plot_pca_loss_scan_3d( Parameters: scan_result: Mapping returned by ``pca_loss_scan``. - ax: 3D axis on which to draw the plot. cmap: Colormap used for the surface. elev: Elevation angle of the view. Default is 30. azim: Azimuth angle of the view. Default is -60. alpha_surface: Surface transparency. Default is 0.85. - show_trajectory: Whether to display the optimization trajectory. Default is True. - trajectory_kwargs: Optional keyword arguments for trajectory plotting. + trajectory_kwargs: Optional keyword arguments for + trajectory plotting. + + Notes: + - The figure is saved to + ``figures/pcaLandscape3d.pdf``. + - If ``LogNorm()`` is used for normalization, + the values in ``Z`` must be strictly positive. Returns: fig: Figure containing the plot. - ax: Axis on which the plot is drawn. + axes: Tuple ``(ax1, ax2)`` containing the main + PCA landscape axis and the log-scale surface axis. """ - if ax is None: - fig = plt.figure(figsize=(16, 6)) - ax1 = fig.add_subplot(121, projection="3d") - ax2 = fig.add_subplot(122, projection="3d") - else: - fig = ax.figure - ax1 = ax - ax2 = None + from scipy.interpolate import RegularGridInterpolator + + fig = plt.figure(figsize=(16, 6)) + ax1 = fig.add_subplot(121, projection="3d") + ax2 = fig.add_subplot(122, projection="3d") X = scan_result["X"] Y = scan_result["Y"] Z = scan_result["Z"] traj_xy = scan_result["traj_xy"] - traj_z = scan_result["traj_z"] evr = scan_result["explained_variance_ratio"] # --- Project trajectory onto the PCA loss surface --- @@ -532,46 +541,43 @@ def plot_pca_loss_scan_3d( fig.colorbar(surf, ax=ax1, shrink=0.7, pad=0.1, label="Loss value") - if show_trajectory and traj_z is not None: - if trajectory_kwargs is None: - trajectory_kwargs = {} + if trajectory_kwargs is None: + trajectory_kwargs = {} - default_traj_kwargs = dict(color="k", lw=2.5, marker="o", ms=4, alpha=1.0) - default_traj_kwargs.update(trajectory_kwargs) + default_traj_kwargs = dict(color="k", lw=2.5, marker="o", ms=4, alpha=1.0) + default_traj_kwargs.update(trajectory_kwargs) - ax1.plot( - traj_xy[:, 0], - traj_xy[:, 1], - traj_surface_z, - **default_traj_kwargs, - label="Trajectory", - ) - ax1.scatter( - traj_xy[0, 0], - traj_xy[0, 1], - traj_surface_z[0], - c="cyan", - s=55, - edgecolors="k", - label="Start", - ) - ax1.scatter( - traj_xy[-1, 0], - traj_xy[-1, 1], - traj_surface_z[-1], - c="red", - s=65, - edgecolors="k", - label="End", - ) + ax1.plot( + traj_xy[:, 0], + traj_xy[:, 1], + traj_surface_z, + **default_traj_kwargs, + label="Trajectory", + ) + ax1.scatter( + traj_xy[0, 0], + traj_xy[0, 1], + traj_surface_z[0], + c="cyan", + s=55, + edgecolors="k", + label="Start", + ) + ax1.scatter( + traj_xy[-1, 0], + traj_xy[-1, 1], + traj_surface_z[-1], + c="red", + s=65, + edgecolors="k", + label="End", + ) ax1.set_xlabel(f"PC1 ({100 * evr[0]:.2f}% variance)") ax1.set_ylabel(f"PC2 ({100 * evr[1]:.2f}% variance)") ax1.set_title(f"PCA Loss Landscape") ax1.view_init(elev=elev, azim=azim) - - if show_trajectory and traj_z is not None: - ax1.legend() + ax1.legend() Z_eps = np.maximum(Z, 1e-14) Z_log = np.log(Z_eps) @@ -651,11 +657,21 @@ def analyze_pca( Analyze a PCA applied to an optimization parameter trajectory. Parameters: - scan_result: Mapping containing PCA results and the parameter trajectory. - n_components: Number of PCA components to analyze. Default is None. - top_k: Number of parameters retained in importance rankings. Default is 10. - weight_mode: Weighting scheme for aggregating component influence. Default is "variance". - eps: Small constant for numerical stability. + scan_result: Mapping containing PCA results and + the parameter trajectory. + n_components: Number of PCA components to analyze. + Default is None. + top_k: Number of parameters retained in importance + rankings. Default is 10. + weight_mode: Weighting scheme used to aggregate + component influence across PCA components. + Supported values are: + - ``"variance"``: weights components according + to their explained variance ratio. + - ``"uniform"``: assigns equal weight to all + analyzed components. + Default is ``"variance"``. + eps: Small constant used for numerical stability. Returns: Mapping containing PCA interpretability results, including: @@ -663,7 +679,8 @@ def analyze_pca( - scores: PCA scores along the trajectory - component_reports: Per-component analyses - global_ranking: Global parameter importance - - field_ranking: Aggregated importance per parameter block + - field_ranking: Always None in the flat-parameter + analysis mode - correlations: Parameter–score correlations - influence_maps: Parameter influence arrays - raw: Raw numerical quantities @@ -900,6 +917,8 @@ def plot_pca_analysis( - components: Component-level analysis figure """ + from matplotlib.ticker import FuncFormatter + def shorten(label, max_len: int | None = None): if max_len is None: max_len = max_label_length @@ -1093,25 +1112,46 @@ def plot_pca_circuit_schematic_real_circuit( Plot a circuit schematic annotated with PCA-based parameter scores. Parameters: - qc: Quantum circuit to visualize. - analysis: Mapping returned by analyze_pca. - field_key: Deprecated / ignored. Kept only for backward compatibility. + qc: Qiskit quantum circuit to visualize, or any + compatible object exposing ``qc.data``, + ``qc.parameters``, ``qc.num_qubits``, + and ``qc.find_bit``. + analysis: Mapping returned by ``analyze_pca``. score_key: Influence metric used for coloring. cmap: Colormap used to map scores to colors. box_width: Width of parameter boxes. box_height: Height of parameter boxes. show_values: Whether to display numerical scores. title: Optional figure title. - show_gamma: Whether to display the global scaling parameter. + show_gamma: Whether to display the global scaling + parameter. The gamma parameter is shown only if + the PCA score vector contains one additional score + compared to the number of Qiskit circuit parameters. gamma_label: Optional label for the scaling parameter. - label_mode: Labeling scheme for parameter boxes. + label_mode: Labeling scheme used for parameter boxes. + Supported values are: + - ``"index"`` + - ``"theta"`` + - ``"full"`` + - ``"gate+index"`` + - ``"gate"`` + - ``"label"`` + - ``"gate+label"`` show_entanglers: Whether to render entangling gates. - entangler_linewidth: Line width for entangling connections. + entangler_linewidth: Line width for entangling + connections. Returns: matplotlib.figure.Figure + + Saved Files: + - ``figures/circuitpcainfluence.pdf`` """ + import matplotlib.patheffects as pe + from matplotlib.cm import get_cmap + from matplotlib.patches import Rectangle + # ------------------------------------------------------------------ # 1) Get flat PCA scores # ------------------------------------------------------------------ @@ -1778,18 +1818,22 @@ def perform_pca_and_analysis( n_jobs: int = -1, ): """ - Run a PCA-based loss landscape analysis pipeline. + Run the full PCA-based loss landscape and interpretability analysis pipeline. Parameters: - params_history: Ndarray containing optimization records. + params_history: Parameter trajectory used to fit the PCA. loss_function: Callable returning the loss for a given parameter vector. n_steps: Number of grid points per PCA axis. offset: Margin added to the PCA scan bounds. n_top: Number of top entries shown in analysis plots. - isa_circuits: Mapping of parameter blocks to quantum circuits. + circuit: Quantum circuit used for the PCA influence schematic. + n_jobs: Number of parallel jobs used during loss evaluations. Default is -1. Returns: Mapping returned by ``analyze_pca``. + + Side effects: + Generates and displays several plots, and saves some figures under ``figures/``. """ print("\n[PCA] Starting PCA-based loss landscape scan...") diff --git a/pyproject.toml b/pyproject.toml index ea806ef..a589c38 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,11 +6,17 @@ build-backend = "setuptools.build_meta" name = "landscape-tools" description = "Internal tools for landscape characterization" requires-python = ">=3.9" -dynamic = ["dependencies", "readme", "version"] +dynamic = ["dependencies", "version"] +readme = "README.md" + +[project.urls] +Homepage = "https://github.com/ColibrITD-SAS/landscape_tools" +Documentation = "https://landscape-tools.colibri-quantum.com" +Issues = "https://github.com/ColibrITD-SAS/landscape_tools/issues" [tool.setuptools.dynamic] dependencies = { file = ["requirements.txt"] } -readme = { file = ["README.md"] } [tool.setuptools.packages.find] include = ["landscape_tools*"] +exclude = ["**"]