diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/.gitignore b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/.gitignore new file mode 100644 index 000000000..a2846a962 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/.gitignore @@ -0,0 +1 @@ +fasttext_best_model.bin diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile new file mode 100644 index 000000000..f5c02c562 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile @@ -0,0 +1,30 @@ +# Use Python 3.12 slim (already has Python and pip). +FROM python:3.12-slim + +# Avoid interactive prompts during apt operations. +ENV DEBIAN_FRONTEND=noninteractive + +# Install CA certificates (needed for HTTPS). +RUN apt-get update && apt-get install -y \ + ca-certificates \ + && rm -rf /var/lib/apt/lists/* + +# Install project specific packages. +RUN mkdir -p /install +COPY requirements.txt /install/requirements.txt +RUN pip install --upgrade pip && \ + pip install --no-cache-dir jupyterlab jupyterlab_vim jupytext -r /install/requirements.txt + +# Config. +COPY etc_sudoers /install/ +COPY etc_sudoers /etc/sudoers +COPY bashrc /root/.bashrc + +# Report package versions. +COPY version.sh /install/ +RUN /install/version.sh 2>&1 | tee version.log + +# Jupyter. +EXPOSE 8888 + +CMD ["/bin/bash"] diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile.python_slim b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile.python_slim new file mode 100644 index 000000000..cc8f18f2f --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile.python_slim @@ -0,0 +1,28 @@ +# Use Python 3.12 slim (already has Python and pip). +FROM python:3.12-slim + +# Avoid interactive prompts during apt operations. +ENV DEBIAN_FRONTEND=noninteractive + +# Install CA certificates (needed for HTTPS). +RUN apt-get update && apt-get install -y \ + ca-certificates \ + && rm -rf /var/lib/apt/lists/* + +# Install project specific packages. +RUN mkdir -p /install +COPY requirements.txt /install/requirements.txt +RUN pip install --upgrade pip && \ + pip install --no-cache-dir jupyterlab jupyterlab_vim jupytext -r /install/requirements.txt + +# Config. +COPY etc_sudoers /install/ +COPY etc_sudoers /etc/sudoers +COPY bashrc /root/.bashrc + +# Report package versions. +COPY version.sh /install/ +RUN /install/version.sh 2>&1 | tee version.log + +# Jupyter. +EXPOSE 8888 diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile.ubuntu b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile.ubuntu new file mode 100644 index 000000000..705105d91 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile.ubuntu @@ -0,0 +1,40 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND noninteractive + +# Install system utilities and Python in a single layer. +RUN apt-get update && \ + apt-get upgrade -y && \ + apt-get install -y --no-install-recommends \ + sudo \ + curl \ + git \ + build-essential \ + python3 \ + python3-pip \ + python3-dev \ + python3-venv \ + && rm -rf /var/lib/apt/lists/* + +# Create virtual environment. +RUN python3 -m venv /opt/venv + +# Make the venv the default Python. +ENV PATH="/opt/venv/bin:$PATH" + +# Install project specific packages. +RUN mkdir /install +COPY requirements.txt /install/requirements.txt +RUN pip install --upgrade pip && \ + pip install --no-cache-dir jupyterlab jupyterlab_vim jupytext -r /install/requirements.txt + +# Config. +COPY etc_sudoers /install/ +COPY etc_sudoers /etc/sudoers +COPY bashrc /root/.bashrc + +# Report package versions. +COPY version.sh /install/ +RUN /install/version.sh 2>&1 | tee version.log + +# Jupyter. +EXPOSE 8888 diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile.uv b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile.uv new file mode 100644 index 000000000..d3b2a0abc --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/Dockerfile.uv @@ -0,0 +1,49 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND noninteractive + +# Install system utilities and Python in a single layer. +RUN apt-get update && \ + apt-get upgrade -y && \ + apt-get install -y --no-install-recommends \ + sudo \ + curl \ + git \ + build-essential \ + python3 \ + python3-pip \ + python3-dev \ + python3-venv \ + libgomp1 \ + g++ \ + && rm -rf /var/lib/apt/lists/* + +# Install uv for package management. +RUN curl -LsSf https://astral.sh/uv/install.sh | sh +ENV PATH="/root/.local/bin:$PATH" + +# Install project specific packages using uv. +COPY pyproject.toml uv.lock /app/ +WORKDIR /app +RUN uv sync +ENV PATH="/app/.venv/bin:$PATH" + +# Install Jupyter. +RUN pip install --upgrade pip && \ + pip install --no-cache-dir jupyterlab jupyterlab_vim jupytext + +# Copy project files. +COPY . /app + +RUN mkdir /install + +# Config. +COPY etc_sudoers /install/ +COPY etc_sudoers /etc/sudoers +COPY bashrc /root/.bashrc + +# Report package versions. +COPY version.sh /install/ +RUN /install/version.sh 2>&1 | tee version.log + +# Jupyter. +EXPOSE 8888 diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/README.md b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/README.md new file mode 100644 index 000000000..37d3d0c48 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/README.md @@ -0,0 +1,138 @@ +# FastText Text Classification + +## What is FastText? + +- FastText is an open-source library developed by Facebook AI Research for + efficient text classification and representation. +- It allows users to create word embeddings and perform supervised learning + tasks such as text classification with high accuracy and speed. +- FastText can handle large datasets and provides pre-trained models for various + languages, making it accessible for multilingual applications. +- The tool supports subword information, which allows it to generate embeddings + for out-of-vocabulary words, improving its robustness in natural language + processing tasks. +- FastText is designed to be easy to use, with a command-line interface and + Python bindings, making it suitable for both beginners and advanced users. + + +## Project Overview + +This project demonstrates text classification using FastText, an open-source +library developed by Facebook AI Research. We train a model to classify news +articles from the 20 Newsgroups dataset into 20 categories, covering topics +such as politics, religion, sports, science, and technology. + + +## Dataset + +We use the 20 Newsgroups dataset, which contains approximately 18,000 newsgroup +posts across 20 categories. The dataset is loaded directly via scikit-learn and +requires no manual download. + +- Training samples: 11,314 +- Test samples: 7,532 +- Categories: 20 + +Headers, footers, and quoted text are removed to make the classification task +more realistic and challenging. + +## Project Structure + + UmdTask458_DATA605_Spring2026_FastText_text_classification/ + Dockerfile - Docker environment setup + requirements.txt - Python dependencies + fasttext_utils.py - Utility functions for training and evaluation + fasttext.example.ipynb - Full project walkthrough notebook + fasttext.API.ipynb - FastText API usage examples + confusion_matrix_baseline.png + confusion_matrix_best.png + hyperparameter_tuning.png + model_comparison.png + error_analysis.png + README.md + +## Setup and Installation + +### Prerequisites +- Docker Desktop installed and running +- Git + +Note: docker_build.sh has Windows path issues. Use docker build directly instead. +FastText is incompatible with NumPy 2.0, so numpy<2.0 is pinned in requirements.txt. + +### Build the Docker Container + + docker build -t gpsaggese/umd_data605_fasttext . + +### Run the Container + + docker run -it --rm -p 8888:8888 -v "$(pwd):/home/user" gpsaggese/umd_data605_fasttext bash + +### Start Jupyter + + pip install "numpy<2.0" -q && jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root --notebook-dir=/home/user + +Then open the token URL shown in the terminal in your browser. + +## Notebooks + +### fasttext.example.ipynb +The main project notebook covering: +1. Dataset loading and exploration +2. Text preprocessing for FastText format +3. Baseline model training and evaluation +4. Hyperparameter tuning across 5 configurations +5. Best model evaluation with confusion matrix and error analysis +6. Comparison with Logistic Regression + TF-IDF + +### fasttext.API.ipynb +Demonstrates the FastText API including: +- Training a model from scratch +- Making single and top-k predictions +- Evaluating model performance +- Saving and loading models +- Accessing word vectors and nearest neighbors + +## FastText API Reference + +The core FastText API used in this project: + +- `fasttext.train_supervised()` — trains a supervised classification model +- `model.predict()` — predicts the category of a text input +- `model.test()` — evaluates model performance on a labeled dataset +- `model.save_model()` / `fasttext.load_model()` — saves and loads a trained model +- `model.get_word_vector()` — returns the vector representation of a word +- `model.get_nearest_neighbors()` — returns words most similar to a given word + +## Results + +| Model | F1 Score | Training Time | +|---|---|---| +| FastText Baseline (e=25, lr=0.5, ng=2) | 0.60 | ~5s | +| FastText Best (e=75, lr=0.5, ng=2) | 0.62 | ~8s | +| Logistic Regression + TF-IDF | 0.66 | ~19s | + +FastText trains 2.5x faster than Logistic Regression while achieving +competitive accuracy. On larger datasets, FastText's speed advantage +becomes significantly more pronounced. + +## Key Findings + +1. Hyperparameter tuning improved F1 from 0.60 (baseline) to 0.62 (best + configuration). Poor configuration choices such as low epoch count and + learning rate can drop performance as low as 0.31. +2. The most common misclassifications occur between semantically similar + categories such as talk.politics.misc and talk.politics.guns. +3. Logistic Regression + TF-IDF slightly outperforms FastText on this + small dataset, but FastText scales significantly better to large datasets. +4. FastText is best suited for large-scale text classification where + training speed and memory efficiency are critical. + +## Dependencies + +- fasttext-wheel +- scikit-learn +- numpy<2.0 +- pandas +- matplotlib +- seaborn \ No newline at end of file diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/bashrc b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/bashrc new file mode 100644 index 000000000..4b7ff4c49 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/bashrc @@ -0,0 +1 @@ +set -o vi diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/confusion_matrix_baseline.png b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/confusion_matrix_baseline.png new file mode 100644 index 000000000..b1c57a2fc Binary files /dev/null and b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/confusion_matrix_baseline.png differ diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/confusion_matrix_best.png b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/confusion_matrix_best.png new file mode 100644 index 000000000..7031ba575 Binary files /dev/null and b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/confusion_matrix_best.png differ diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/copy_docker_files.py b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/copy_docker_files.py new file mode 100644 index 000000000..0e97c194c --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/copy_docker_files.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python + +""" +Copy Docker-related files from the source directory to a destination directory. + +This script copies all Docker configuration and utility files from +class_project/project_template/ to a specified destination directory. + +Usage examples: + # Copy all files to a target directory. + > ./copy_docker_files.py --dst_dir /path/to/destination + + # Copy with verbose logging. + > ./copy_docker_files.py --dst_dir /path/to/destination -v DEBUG + +Import as: + +import class_project.project_template.copy_docker_files as cpdccodo +""" + +import argparse +import logging +import os +from typing import List + +import helpers.hdbg as hdbg +import helpers.hio as hio +import helpers.hparser as hparser +import helpers.hsystem as hsystem + +_LOG = logging.getLogger(__name__) + +# ############################################################################# +# Constants +# ############################################################################# + +# List of files to copy from the source directory. +_FILES_TO_COPY = [ + "bashrc", + "docker_bash.sh", + "docker_build.sh", + "docker_clean.sh", + "docker_cmd.sh", + "docker_exec.sh", + "docker_jupyter.sh", + "docker_name.sh", + "docker_push.sh", + "etc_sudoers", + "install_jupyter_extensions.sh", + "run_jupyter.sh" + "version.sh", +] + + +# ############################################################################# +# Helper functions +# ############################################################################# + + +def _get_source_dir() -> str: + """ + Get the absolute path to the source directory containing Docker files. + + :return: absolute path to class_project/project_template/ + """ + # Get the directory where this script is located. + script_dir = os.path.dirname(os.path.abspath(__file__)) + _LOG.debug("Script directory='%s'", script_dir) + return script_dir + + +def _copy_files( + *, + src_dir: str, + dst_dir: str, + files: List[str], +) -> None: + """ + Copy specified files from source directory to destination directory. + + :param src_dir: source directory path + :param dst_dir: destination directory path + :param files: list of filenames to copy + """ + # Verify source directory exists. + hdbg.dassert_dir_exists(src_dir, "Source directory does not exist:", src_dir) + # Create destination directory if it doesn't exist. + hio.create_dir(dst_dir, incremental=True) + _LOG.info("Copying %d files from '%s' to '%s'", len(files), src_dir, dst_dir) + # Copy each file. + copied_count = 0 + for filename in files: + src_path = os.path.join(src_dir, filename) + dst_path = os.path.join(dst_dir, filename) + # Verify source file exists. + hdbg.dassert_path_exists( + src_path, "Source file does not exist:", src_path + ) + # Copy the file using cp -a to preserve all permissions and attributes. + _LOG.debug("Copying '%s' -> '%s'", src_path, dst_path) + cmd = f"cp -a {src_path} {dst_path}" + hsystem.system(cmd) + copied_count += 1 + # + _LOG.info("Successfully copied %d files", copied_count) + + +# ############################################################################# + + +def _parse() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser( + description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + parser.add_argument( + "--dst_dir", + action="store", + required=True, + help="Destination directory where files will be copied", + ) + hparser.add_verbosity_arg(parser) + return parser + + +def _main(parser: argparse.ArgumentParser) -> None: + args = parser.parse_args() + hdbg.init_logger(verbosity=args.log_level, use_exec_path=True) + # Get source directory. + src_dir = _get_source_dir() + # Copy files to destination. + _copy_files( + src_dir=src_dir, + dst_dir=args.dst_dir, + files=_FILES_TO_COPY, + ) + + +if __name__ == "__main__": + _main(_parse()) diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_bash.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_bash.sh new file mode 100644 index 000000000..0025e81f4 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_bash.sh @@ -0,0 +1,34 @@ +#!/bin/bash +# """ +# This script launches a Docker container with an interactive bash shell for +# development. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions from the project template. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# List the available Docker images matching the expected image name. +run "docker image ls $FULL_IMAGE_NAME" + +# Configure and run the Docker container with interactive bash shell. +# - Container is removed automatically on exit (--rm) +# - Interactive mode with TTY allocation (-ti) +# - Port forwarding for Jupyter or other services +# - Git root mounted to /git_root inside container +CONTAINER_NAME=${IMAGE_NAME}_bash +PORT= +DOCKER_CMD=$(get_docker_bash_command) +DOCKER_CMD_OPTS=$(get_docker_bash_options $CONTAINER_NAME $PORT) +run "$DOCKER_CMD $DOCKER_CMD_OPTS $FULL_IMAGE_NAME" diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_build.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_build.sh new file mode 100644 index 000000000..5b0957a99 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_build.sh @@ -0,0 +1,40 @@ +#!/bin/bash +# """ +# Build a Docker container image for the project. +# +# This script sets up the build environment with error handling and command +# tracing, loads Docker configuration from docker_name.sh, and builds the +# Docker image using the build_container_image utility function. It supports +# both single-architecture and multi-architecture builds via the +# DOCKER_BUILD_MULTI_ARCH environment variable. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +# Shift processed option flags so remaining args are passed to the build. +parse_default_args "$@" +shift $((OPTIND-1)) + +# Load Docker configuration variables (REPO_NAME, IMAGE_NAME, FULL_IMAGE_NAME). +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Configure Docker build settings. +# Enable BuildKit for improved build performance and features. +export DOCKER_BUILDKIT=1 +#export DOCKER_BUILDKIT=0 + +# Configure single-architecture build (set to 1 for multi-arch build). +#export DOCKER_BUILD_MULTI_ARCH=1 +export DOCKER_BUILD_MULTI_ARCH=0 + +# Build the container image. +# Pass extra arguments (e.g., --no-cache) via command line after -v. +build_container_image "$@" diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_build.version.log b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_build.version.log new file mode 100644 index 000000000..8315eefe2 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_build.version.log @@ -0,0 +1 @@ +the input device is not a TTY diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_clean.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_clean.sh new file mode 100644 index 000000000..7e40839ae --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_clean.sh @@ -0,0 +1,26 @@ +#!/bin/bash +# """ +# Remove Docker container image for the project. +# +# This script cleans up Docker images by removing the container image +# matching the project configuration. Useful for freeing disk space or +# ensuring a fresh build. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Remove the container image. +remove_container_image diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_cmd.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_cmd.sh new file mode 100644 index 000000000..906d7a77b --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_cmd.sh @@ -0,0 +1,41 @@ +#!/bin/bash +# """ +# Execute a command in a Docker container. +# +# This script runs a specified command inside a new Docker container instance. +# The container is removed automatically after the command completes. The +# git root is mounted to /git_root inside the container. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +# Shift processed option flags so remaining args form the command. +parse_default_args "$@" +shift $((OPTIND-1)) + +# Capture the command to execute from remaining arguments. +CMD="$@" +echo "Executing: '$CMD'" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# List available Docker images matching the expected image name. +run "docker image ls $FULL_IMAGE_NAME" +#(docker manifest inspect $FULL_IMAGE_NAME | grep arch) || true + +# Configure and run the Docker container with the specified command. +CONTAINER_NAME=$IMAGE_NAME +DOCKER_CMD=$(get_docker_cmd_command) +PORT="" +DOCKER_RUN_OPTS="" +DOCKER_CMD_OPTS=$(get_docker_bash_options $CONTAINER_NAME $PORT $DOCKER_RUN_OPTS) +run "$DOCKER_CMD $DOCKER_CMD_OPTS $FULL_IMAGE_NAME bash -c '$CMD'" diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_exec.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_exec.sh new file mode 100644 index 000000000..24f8e401a --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_exec.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# """ +# Execute a bash shell in a running Docker container. +# +# This script connects to an already running Docker container and opens an +# interactive bash session for debugging or inspection purposes. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Execute bash shell in the running container. +exec_container diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_jupyter.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_jupyter.sh new file mode 100644 index 000000000..1a60dfd3a --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_jupyter.sh @@ -0,0 +1,39 @@ +#!/bin/bash +# """ +# Execute Jupyter Lab in a Docker container. +# +# This script launches a Docker container running Jupyter Lab with +# configurable port, directory mounting, and vim bindings. It passes +# command-line options to the run_jupyter.sh script inside the container. +# +# Usage: +# > docker_jupyter.sh [options] +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse command-line options and set Jupyter configuration variables. +parse_docker_jupyter_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# List available Docker images and inspect architecture. +list_and_inspect_docker_image + +# Run the Docker container with Jupyter Lab. +CMD=$(get_run_jupyter_cmd "${BASH_SOURCE[0]}" "$OLD_CMD_OPTS") +CONTAINER_NAME=$IMAGE_NAME +# Kill existing container if -f flag is set. +kill_existing_container_if_forced + +DOCKER_CMD=$(get_docker_jupyter_command) +DOCKER_CMD_OPTS=$(get_docker_jupyter_options $CONTAINER_NAME $JUPYTER_HOST_PORT $JUPYTER_USE_VIM) +run "$DOCKER_CMD $DOCKER_CMD_OPTS $FULL_IMAGE_NAME $CMD" diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_name.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_name.sh new file mode 100644 index 000000000..a74ddf9b7 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_name.sh @@ -0,0 +1,11 @@ +#!/bin/bash +# """ +# Docker image naming configuration. +# +# This file defines the repository name, image name, and full image name +# variables used by all docker_*.sh scripts in the project template. +# """ +REPO_NAME=gpsaggese +# The file should be all lower case. +IMAGE_NAME=umd_data605_fasttext +FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_push.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_push.sh new file mode 100644 index 000000000..27d752dd9 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/docker_push.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# """ +# Push Docker container image to Docker Hub or registry. +# +# This script authenticates with the Docker registry using credentials from +# ~/.docker/passwd.$REPO_NAME.txt and pushes the locally built container +# image to the remote repository. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker image naming configuration. +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source $SCRIPT_DIR/docker_name.sh + +# Push the container image to the registry. +push_container_image diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/error_analysis.png b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/error_analysis.png new file mode 100644 index 000000000..4b6482765 Binary files /dev/null and b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/error_analysis.png differ diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/etc_sudoers b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/etc_sudoers new file mode 100644 index 000000000..ee0816a15 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/etc_sudoers @@ -0,0 +1,31 @@ +# +# This file MUST be edited with the 'visudo' command as root. +# +# Please consider adding local content in /etc/sudoers.d/ instead of +# directly modifying this file. +# +# See the man page for details on how to write a sudoers file. +# +Defaults env_reset +Defaults mail_badpass +Defaults secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin" + +# Host alias specification + +# User alias specification + +# Cmnd alias specification + +# User privilege specification +root ALL=(ALL:ALL) ALL + +# Members of the admin group may gain root privileges +%admin ALL=(ALL) ALL + +# Allow members of group sudo to execute any command +%sudo ALL=(ALL:ALL) ALL + +# See sudoers(5) for more information on "#include" directives: +postgres ALL=(ALL) NOPASSWD:ALL + +#includedir /etc/sudoers.d diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/fasttext.API.ipynb b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/fasttext.API.ipynb new file mode 100644 index 000000000..5cf1341cd --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/fasttext.API.ipynb @@ -0,0 +1,423 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "64d3b0a0-edbe-4a79-a781-b35e84a4b18f", + "metadata": {}, + "source": [ + "# FastText API Usage Guide\n", + "\n", + "This notebook demonstrates how to use the FastText API for text classification.\n", + "It covers loading a trained model, making predictions on new text, and using\n", + "the utility functions provided in fasttext_utils.py." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f0112ed8-e7fe-4f9f-ae97-21e99ed01da1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Libraries imported successfully!\n" + ] + } + ], + "source": [ + "# Import libraries and utility functions\n", + "import fasttext\n", + "from sklearn.datasets import fetch_20newsgroups\n", + "from fasttext_utils import (\n", + " clean_text,\n", + " prepare_fasttext_data,\n", + " train_fasttext_model,\n", + " evaluate_model,\n", + " get_predictions\n", + ")\n", + "\n", + "print(\"Libraries imported successfully!\")" + ] + }, + { + "cell_type": "markdown", + "id": "93bc3d2b-d3d4-42b3-8c15-ca1aae8835b9", + "metadata": {}, + "source": [ + "## Part 1: Training a Model from Scratch\n", + "\n", + "The FastText API allows you to train a supervised classification model\n", + "with a single function call. Here we demonstrate the minimal setup required." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0f25bc8c-573a-46f6-851f-02b31e1f8094", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved 11314 samples to /tmp/train.txt\n", + "Saved 7532 samples to /tmp/test.txt\n", + "Model trained in 8.88 seconds\n" + ] + } + ], + "source": [ + "# Load dataset and prepare training data\n", + "train_data = fetch_20newsgroups(subset='train', remove=('headers', 'footers', 'quotes'))\n", + "test_data = fetch_20newsgroups(subset='test', remove=('headers', 'footers', 'quotes'))\n", + "\n", + "prepare_fasttext_data(train_data, '/tmp/train.txt')\n", + "prepare_fasttext_data(test_data, '/tmp/test.txt')\n", + "\n", + "# Train a model using the FastText API\n", + "model, train_time = train_fasttext_model(\n", + " '/tmp/train.txt',\n", + " epoch=25,\n", + " lr=0.5,\n", + " word_ngrams=2\n", + ")\n", + "print(f\"Model trained in {train_time:.2f} seconds\")" + ] + }, + { + "cell_type": "markdown", + "id": "655ca0b7-e9e6-48dc-95b5-96e8ba42d128", + "metadata": {}, + "source": [ + "## Part 2: Making Predictions on New Text\n", + "\n", + "Once trained, the FastText API allows you to classify any new text\n", + "with a single call to model.predict()." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "01a62829-7790-425d-a381-053d1732d06c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions on new text samples:\n", + "------------------------------------------------------------\n", + "Text: The new graphics card delivers exceptional perform...\n", + "Predicted: comp.graphics (confidence: 0.9988)\n", + "\n", + "Text: The senator proposed a new bill to regulate firear...\n", + "Predicted: talk.politics.misc (confidence: 0.7130)\n", + "\n", + "Text: Scientists discovered a new exoplanet in the habit...\n", + "Predicted: rec.autos (confidence: 0.8161)\n", + "\n", + "Text: The team won the championship after an outstanding...\n", + "Predicted: rec.sport.hockey (confidence: 0.9982)\n", + "\n", + "Text: The stock market reached a new all-time high today...\n", + "Predicted: rec.autos (confidence: 0.5739)\n", + "\n" + ] + } + ], + "source": [ + "# Predict the category of new text samples\n", + "sample_texts = [\n", + " \"The new graphics card delivers exceptional performance for gaming.\",\n", + " \"The senator proposed a new bill to regulate firearm purchases.\",\n", + " \"Scientists discovered a new exoplanet in the habitable zone.\",\n", + " \"The team won the championship after an outstanding season.\",\n", + " \"The stock market reached a new all-time high today.\"\n", + "]\n", + "\n", + "print(\"Predictions on new text samples:\")\n", + "print(\"-\" * 60)\n", + "for text in sample_texts:\n", + " clean = clean_text(text)\n", + " labels, probs = model.predict(clean)\n", + " category = labels[0].replace('__label__', '').replace('_', '.')\n", + " confidence = probs[0]\n", + " print(f\"Text: {text[:50]}...\")\n", + " print(f\"Predicted: {category} (confidence: {confidence:.4f})\")\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "5acd5c6e-3142-4014-88bb-6290420b0a25", + "metadata": {}, + "source": [ + "## Part 3: Predicting Multiple Labels\n", + "\n", + "FastText can return the top-k most likely categories for a given text,\n", + "which is useful when the correct category is ambiguous." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ae30a82c-65f0-49e7-a13e-6596bce1ccf9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top-3 predictions for ambiguous texts:\n", + "------------------------------------------------------------\n", + "Text: I am looking to buy a used computer with a good graphic...\n", + " comp.graphics: 0.7067\n", + " misc.forsale: 0.1715\n", + " sci.electronics: 0.0652\n", + "\n", + "Text: The church discussed the role of religion in modern pol...\n", + " soc.religion.christian: 0.9997\n", + " talk.religion.misc: 0.0002\n", + " alt.atheism: 0.0001\n", + "\n", + "Text: The new motorcycle engine has impressive technical spec...\n", + " rec.autos: 0.8226\n", + " rec.motorcycles: 0.1420\n", + " comp.sys.mac.hardware: 0.0284\n", + "\n" + ] + } + ], + "source": [ + "# Get top-3 predictions for ambiguous texts\n", + "ambiguous_texts = [\n", + " \"I am looking to buy a used computer with a good graphics card.\",\n", + " \"The church discussed the role of religion in modern politics.\",\n", + " \"The new motorcycle engine has impressive technical specifications.\"\n", + "]\n", + "\n", + "print(\"Top-3 predictions for ambiguous texts:\")\n", + "print(\"-\" * 60)\n", + "for text in ambiguous_texts:\n", + " clean = clean_text(text)\n", + " labels, probs = model.predict(clean, k=3)\n", + " print(f\"Text: {text[:55]}...\")\n", + " for label, prob in zip(labels, probs):\n", + " category = label.replace('__label__', '').replace('_', '.')\n", + " print(f\" {category}: {prob:.4f}\")\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "9750fc88-27c3-4b6f-a8b0-f1baf60de9cf", + "metadata": {}, + "source": [ + "## Part 4: Evaluating Model Performance\n", + "\n", + "The FastText API provides a built-in test function to evaluate\n", + "model performance on a labeled dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "feb73d73-c9c3-4bc2-805f-36dc362f1e87", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model Evaluation Results:\n", + "----------------------------------------\n", + "Test samples: 7532\n", + "Precision: 0.6022\n", + "Recall: 0.6022\n", + "F1-Score: 0.6022\n" + ] + } + ], + "source": [ + "# Evaluate model performance using the FastText API\n", + "results = evaluate_model(model, '/tmp/test.txt')\n", + "\n", + "print(\"Model Evaluation Results:\")\n", + "print(\"-\" * 40)\n", + "print(f\"Test samples: {results['samples']}\")\n", + "print(f\"Precision: {results['precision']}\")\n", + "print(f\"Recall: {results['recall']}\")\n", + "print(f\"F1-Score: {results['f1']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c972756c-54e6-41e7-ae3c-9d9a58e8a0fb", + "metadata": {}, + "source": [ + "## Part 5: Saving and Loading a Model\n", + "\n", + "FastText models can be saved to disk and reloaded for future use\n", + "without retraining, which is useful for production deployment." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "87b22675-120b-4f4d-bbfa-18a69d8a0e3d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model saved to /tmp/fasttext_api_model.bin\n", + "Model loaded successfully!\n", + "\n", + "Test prediction with loaded model:\n", + "Text: The astronauts completed a successful spacewalk outside the station.\n", + "Predicted: sci.space (confidence: 0.4991)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning : `load_model` does not return WordVectorModel or SupervisedModel any more, but a `FastText` object which is very similar.\n" + ] + } + ], + "source": [ + "# Save the model to disk\n", + "model.save_model('/tmp/fasttext_api_model.bin')\n", + "print(\"Model saved to /tmp/fasttext_api_model.bin\")\n", + "\n", + "# Load the model back\n", + "loaded_model = fasttext.load_model('/tmp/fasttext_api_model.bin')\n", + "print(\"Model loaded successfully!\")\n", + "\n", + "# Verify the loaded model works correctly\n", + "test_text = \"The astronauts completed a successful spacewalk outside the station.\"\n", + "clean = clean_text(test_text)\n", + "labels, probs = loaded_model.predict(clean)\n", + "category = labels[0].replace('__label__', '').replace('_', '.')\n", + "print(f\"\\nTest prediction with loaded model:\")\n", + "print(f\"Text: {test_text}\")\n", + "print(f\"Predicted: {category} (confidence: {probs[0]:.4f})\")" + ] + }, + { + "cell_type": "markdown", + "id": "c7f5f5fb-8844-4eb4-8608-717a33576379", + "metadata": {}, + "source": [ + "## Part 6: Word Vectors\n", + "\n", + "FastText also provides access to word vectors, which capture semantic\n", + "relationships between words. These can be used for tasks beyond classification\n", + "such as similarity search and clustering." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e6e111e6-76bd-481b-a6db-68fbd283c3de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Word vector dimensions: 100\n", + "\n", + "Sample word vectors (first 5 dimensions):\n", + "--------------------------------------------------\n", + "politics : [ 0.2386 -0.4697 -0.5411 0.3822 -0.2242]\n", + "religion : [-1.381 -0.6163 1.7671 0.565 -0.9371]\n", + "computer : [ 0.1015 0.5626 0.7517 -0.7056 0.1837]\n", + "sports : [ 0.1007 -0.1269 -0.4817 0.0266 -0.5756]\n", + "science : [ 0.159 -0.0033 0.4031 -0.2401 0.9567]\n", + "\n", + "Words most similar to 'computer':\n", + "--------------------------------------------------\n", + " lifespan similarity: 0.9351\n", + " video similarity: 0.9311\n", + " card similarity: 0.9298\n", + " screen similarity: 0.9208\n", + " available similarity: 0.9171\n" + ] + } + ], + "source": [ + "# Access word vectors from the trained model\n", + "words = ['politics', 'religion', 'computer', 'sports', 'science']\n", + "\n", + "print(\"Word vector dimensions:\", model.get_dimension())\n", + "print()\n", + "print(\"Sample word vectors (first 5 dimensions):\")\n", + "print(\"-\" * 50)\n", + "for word in words:\n", + " vector = model.get_word_vector(word)\n", + " print(f\"{word:12s}: {vector[:5].round(4)}\")\n", + "\n", + "print()\n", + "# Find nearest neighbors for a word\n", + "print(\"Words most similar to 'computer':\")\n", + "print(\"-\" * 50)\n", + "neighbors = model.get_nearest_neighbors('computer', k=5)\n", + "for score, word in neighbors:\n", + " print(f\" {word:20s} similarity: {score:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "44f7bbbb-ea82-41c0-8fa7-6bfb8bd1f9f1", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "This notebook demonstrated the key FastText API capabilities:\n", + "\n", + "1. Training a supervised classification model with train_supervised()\n", + "2. Making single and top-k predictions with model.predict()\n", + "3. Evaluating model performance with model.test()\n", + "4. Saving and loading models with save_model() and load_model()\n", + "5. Accessing word vectors with get_word_vector() and get_nearest_neighbors()\n", + "\n", + "For a complete walkthrough of the text classification pipeline including\n", + "hyperparameter tuning and model comparison, see fasttext.example.ipynb." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66c183a8-16b4-43d7-bb5b-e05700fe0a56", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/fasttext.example.ipynb b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/fasttext.example.ipynb new file mode 100644 index 000000000..4a70322a1 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/fasttext.example.ipynb @@ -0,0 +1,865 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "955ed470-77f1-4517-b03c-6334235dbfde", + "metadata": {}, + "source": [ + "# FastText Text Classification Tutorial\n", + "## Using the 20 Newsgroups Dataset\n", + "\n", + "This notebook demonstrates how to use FastText for text classification.\n", + "We will train a model to classify news articles into 20 categories." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8a3dfdb3-e37e-491b-a386-21e4157bb446", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All libraries imported successfully!\n" + ] + } + ], + "source": [ + "# Import libraries\n", + "import fasttext\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.datasets import fetch_20newsgroups\n", + "from sklearn.metrics import classification_report, confusion_matrix\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "import re\n", + "import time\n", + "\n", + "# Import project utility functions\n", + "from fasttext_utils import (\n", + " clean_text,\n", + " prepare_fasttext_data,\n", + " train_fasttext_model,\n", + " evaluate_model,\n", + " get_predictions,\n", + " plot_confusion_matrix,\n", + " plot_tuning_results,\n", + " plot_model_comparison\n", + ")\n", + "\n", + "print(\"All libraries imported successfully!\")" + ] + }, + { + "cell_type": "markdown", + "id": "631a6776-e2b7-43b3-9c21-ca27bb80bace", + "metadata": {}, + "source": [ + "## Step 1: Load the Dataset\n", + "\n", + "We use the 20 Newsgroups dataset, which contains ~18,000 newsgroup posts\n", + "across 20 different categories. It is built into scikit-learn and requires\n", + "no manual download." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e360fce1-2b51-45f8-a253-7d93b4a49109", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training samples: 11314\n", + "Test samples: 7532\n", + "Number of categories: 20\n", + "\n", + "Categories:\n", + "['alt.atheism', 'comp.graphics', 'comp.os.ms-windows.misc', 'comp.sys.ibm.pc.hardware', 'comp.sys.mac.hardware', 'comp.windows.x', 'misc.forsale', 'rec.autos', 'rec.motorcycles', 'rec.sport.baseball', 'rec.sport.hockey', 'sci.crypt', 'sci.electronics', 'sci.med', 'sci.space', 'soc.religion.christian', 'talk.politics.guns', 'talk.politics.mideast', 'talk.politics.misc', 'talk.religion.misc']\n" + ] + } + ], + "source": [ + "# Load the 20 Newsgroups dataset\n", + "train_data = fetch_20newsgroups(subset='train', remove=('headers', 'footers', 'quotes'))\n", + "test_data = fetch_20newsgroups(subset='test', remove=('headers', 'footers', 'quotes'))\n", + "\n", + "print(f\"Training samples: {len(train_data.data)}\")\n", + "print(f\"Test samples: {len(test_data.data)}\")\n", + "print(f\"Number of categories: {len(train_data.target_names)}\")\n", + "print(f\"\\nCategories:\\n{train_data.target_names}\")" + ] + }, + { + "cell_type": "markdown", + "id": "510c3083-b440-43b8-aaaa-139d10fbd05c", + "metadata": {}, + "source": [ + "## Step 2: Preprocess the Data\n", + "\n", + "FastText requires data in a specific format:\n", + "`__label__ `\n", + "\n", + "We clean the text by removing special characters and converting to lowercase." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e8c98db4-ec2a-4fd4-9292-135a04a3889c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved 11314 samples to /tmp/train.txt\n", + "Saved 7532 samples to /tmp/test.txt\n" + ] + } + ], + "source": [ + "# Prepare data in FastText format\n", + "# FastText expects: __label__ on each line\n", + "prepare_fasttext_data(train_data, '/tmp/train.txt')\n", + "prepare_fasttext_data(test_data, '/tmp/test.txt')" + ] + }, + { + "cell_type": "markdown", + "id": "73687cc1-4496-4b4f-9e62-7c65695bad3e", + "metadata": {}, + "source": [ + "## Step 3: Train the FastText Model\n", + "\n", + "We train a supervised FastText model on the preprocessed training data.\n", + "Key parameters:\n", + "- `epoch`: number of training passes\n", + "- `lr`: learning rate\n", + "- `wordNgrams`: use bigrams for better accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "99ad2b97-ead7-4c24-b386-5931c9826006", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Read 2M words\n", + "Number of words: 72943\n", + "Number of labels: 20\n", + "Progress: 96.3% words/sec/thread: 733504 lr: 0.018521 avg.loss: 1.357095 ETA: 0h 0m 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training complete in 4.16 seconds!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Progress: 100.0% words/sec/thread: 732330 lr: 0.000000 avg.loss: 1.310074 ETA: 0h 0m 0s\n" + ] + } + ], + "source": [ + "# Train the baseline FastText model\n", + "# epoch=25, lr=0.5, wordNgrams=2\n", + "model, train_time = train_fasttext_model(\n", + " '/tmp/train.txt',\n", + " epoch=25,\n", + " lr=0.5,\n", + " word_ngrams=2,\n", + " verbose=2\n", + ")\n", + "print(f\"Training complete in {train_time:.2f} seconds!\")" + ] + }, + { + "cell_type": "markdown", + "id": "2c3ab24c-b595-462f-b86f-903e7ff3783a", + "metadata": {}, + "source": [ + "## Step 4: Evaluate the Model\n", + "\n", + "We evaluate the model on the test set using accuracy, precision, recall, and F1-score." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5ee6b86f-5ddb-492c-b044-8ea6b7207df1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Baseline Model Results:\n", + "Precision: 0.5996\n", + "Recall: 0.5996\n", + "F1-Score: 0.5996\n" + ] + } + ], + "source": [ + "# Evaluate the baseline model on the test set\n", + "results = evaluate_model(model, '/tmp/test.txt')\n", + "print(f\"Baseline Model Results:\")\n", + "print(f\"Precision: {results['precision']}\")\n", + "print(f\"Recall: {results['recall']}\")\n", + "print(f\"F1-Score: {results['f1']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6eb0354f-4258-462b-a930-dfcdc1f8232a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " alt.atheism 0.41 0.40 0.41 319\n", + " comp.graphics 0.56 0.63 0.59 389\n", + " comp.os.ms-windows.misc 0.63 0.56 0.59 394\n", + "comp.sys.ibm.pc.hardware 0.58 0.54 0.56 392\n", + " comp.sys.mac.hardware 0.39 0.59 0.47 385\n", + " comp.windows.x 0.85 0.65 0.73 395\n", + " misc.forsale 0.77 0.76 0.76 390\n", + " rec.autos 0.58 0.59 0.59 396\n", + " rec.motorcycles 0.73 0.59 0.66 398\n", + " rec.sport.baseball 0.74 0.66 0.70 397\n", + " rec.sport.hockey 0.83 0.79 0.81 399\n", + " sci.crypt 0.71 0.61 0.66 396\n", + " sci.electronics 0.47 0.54 0.50 393\n", + " sci.med 0.60 0.68 0.64 396\n", + " sci.space 0.69 0.63 0.66 394\n", + " soc.religion.christian 0.57 0.72 0.64 398\n", + " talk.politics.guns 0.48 0.57 0.52 364\n", + " talk.politics.mideast 0.67 0.67 0.67 376\n", + " talk.politics.misc 0.40 0.37 0.39 310\n", + " talk.religion.misc 0.37 0.23 0.28 251\n", + "\n", + " accuracy 0.60 7532\n", + " macro avg 0.60 0.59 0.59 7532\n", + " weighted avg 0.61 0.60 0.60 7532\n", + "\n" + ] + } + ], + "source": [ + "# Generate detailed classification report for the baseline model\n", + "true_labels = [test_data.target_names[i] for i in test_data.target]\n", + "predicted_labels = get_predictions(model, test_data.data, clean_text)\n", + "\n", + "print(classification_report(true_labels, predicted_labels, zero_division=0))" + ] + }, + { + "cell_type": "markdown", + "id": "5d71d3d3-2aa0-4a8e-a156-d563469a7271", + "metadata": {}, + "source": [ + "## Step 5: Confusion Matrix Visualization\n", + "\n", + "We visualize the confusion matrix to understand which categories\n", + "the model confuses most often." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a9754aa6-9fd0-419d-9abd-3ccf886b8ad6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABcoAAAVuCAYAAABFhw+1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdUFFcbBvBn6b0jIl2qIvaGCGLFGrDExBjFFrtib1ERo4LGhr3X2I29VzB2UbAgYuwNBaz0Ot8ffGxcwUJz2eX5nbPnsDN3Zt87d3Z2eOfOHZEgCAKIiIiIiIiIiIiIiMooBWkHQEREREREREREREQkTUyUExEREREREREREVGZxkQ5EREREREREREREZVpTJQTERERERERERERUZnGRDkRERERERERERERlWlMlBMRERERERERERFRmcZEORERERERERERERGVaUyUExEREREREREREVGZxkQ5EREREREREREREZVpTJQTERERlZAPHz7Az88PNjY2UFZWhkgkQkRERIl+prW1NaytrUv0M+TZlClTIBKJEBISIu1QiPLl6ekJkUgkMS0kJAQikQhTpkyRTlClXHF8rx89egSRSIQePXoUW1xERERUujBRTkRERHLj6tWr6N27N+zt7aGpqQl1dXXY2tqiW7duOH78+HePZ8yYMViwYAGqVKmCcePGwd/fH+XLl//ucUiTtbU1RCIRRCIRbt26lW+ZrKwsmJmZics9evSo0J+3bt06iEQirFu3rtDrKG0+3ob5vfbs2VNin/25BGOPHj2+GNOnr5Joj8ImLnOX+/SlqamJqlWrIiAgAImJicUeb1mSm7gXiUSoXbv2Z8sdPnxYXM7T0/P7BUhERESUDyVpB0BERERUVNnZ2Rg1ahTmzZsHJSUlNGnSBD/88AOUlZXx4MEDHDx4EH/99RemTp2KSZMmfbe4Dhw4AAcHB+zfv/+7febJkye/22d9KwWFnL4Za9aswdy5c/PMP3z4MF68eAElJSVkZmZ+7/AkDB48GD///DMsLS2lGsenFBUVMXHixHznOTk5fedoAB8fnzx3LoSEhCA0NBTe3t6oXr26xLxP35cGtra2+PXXXwEAgiAgLi4Ohw8fxpQpU3DkyBGcPXsWioqKUo7y29StWxdRUVEwMjKSdigSlJSUcPXqVdy4cQNVq1bNM3/16tWl4ntPREREBDBRTkRERHJg4sSJmDdvHqpXr46dO3fC1tZWYn5KSgoWLVqE169ff9e4Xrx4AQ8Pj+/6mZ/WvTRQVlaGh4cH/vrrL8ycORPKysoS89esWQNdXV1Uq1YNZ86ckVKUOYyMjEpdshHISTiWpmE1fHx84OPjIzFtypQpCA0NhY+Pj0wMT2FnZ5dnm6alpcHV1RUXL15EaGgomjRpIp3gCkhDQ0MqF0y+xsvLC4cPH8aaNWswf/58iXnx8fHYv38/WrdujX379kknQCIiIqKPcOgVIiIikmn37t3DrFmzYGhoiCNHjuSbKFZXV8fo0aMREBAgMT0+Ph7Dhg2DjY0NVFVVUa5cOXTu3DnfIUJyh5p4+PAhFixYACcnJ6iqqsLKygoBAQHIzs7OU1YQBISGhuYZWuBL4+V+buiQ06dPo1WrVqhQoQJUVVVhYmICd3d3rFixQqLc58YoT0pKgr+/P5ycnKCmpgYDAwO0adMG586dy1P24/g2b96M6tWrQ11dHaampvDz80NKSkqeZb6mV69eiIuLy9O7Pi4uDgcOHECXLl2grq6eZ7n09HQsXLgQXl5esLCwELdThw4dEB4eLlG2R48e6NmzJwCgZ8+eEsNq5Mod3zk1NRUTJ06Era0tlJWVxQnT/Nqmf//+EIlECAoKyhNf7ryZM2cWeJsUpxcvXsDf3x/169dHuXLloKqqCmtrawwcOBCxsbF5yr9//x6TJ09G5cqVoaWlBR0dHdjZ2cHX1xePHz8GkLOtcr8zjRs3Fm/LwoyBf+bMGbRr1w5GRkZQVVWFvb09Jk6ciOTkZHGZe/fuQVtbG+bm5nkuan06b926dbCxsQEArF+/XqKtizIOtaqqKho3bgwg5/jwsdOnT6NXr15wdHSElpYWtLS0ULt27TzfwVzXrl1Dp06dYGlpCVVVVRgbG6NOnTqYPn16nrKxsbEYPnw47OzsoKqqCiMjI3Ts2PGzwxV96nNjlOceDxITE+Hn5yc+flStWhU7d+7Md13p6emYO3cuatasCU1NTWhra8Pd3b1QyWxzc3M0b94cmzZtQnp6usS8v/76C+np6ejVq9dnly/IMRoAnj59ii5dusDAwABaWlpo1KjRVy++fcu+SURERGUDe5QTERGRTFu3bh2ysrLQr18/mJiYfLGsqqqq+O+4uDi4urri/v378PT0xM8//4yHDx9i586dOHjwII4ePYqGDRvmWcfo0aMRGhqKtm3bwsvLC3v27MGUKVOQnp4uToDlDksREBAAKysrce/awj5k8+DBg2jXrh309PTg7e0NU1NTxMXF4fr169i4cSP69u37xeVTU1PRpEkTXL58GTVr1sSwYcPw6tUrbNu2DUePHsWWLVvw448/5llu0aJFOHLkCLy9vdGkSRMcOXIECxYsQHx8PDZt2lSgOrRv3x76+vpYu3YtOnToIJ6+ceNGZGRkoFevXvkOi/PmzRsMGzYM7u7uaN26NfT19fHgwQPs27cPhw8fxpkzZ1CnTh0AOdv93bt32Lt3b77Df3ysY8eOuH79Olq2bAk9PT1x0jU/8+bNw5kzZzB58mQ0bdpU/Hm7d+/G8uXL0aRJE4wePbpA26O4nTlzBnPmzEHTpk1Rr149KCsrIzw8HEuXLsXRo0dx7do16OrqAsgZZsTLywuXLl2Cm5sbWrZsCQUFBTx+/Bj79u1Dt27dJPbb0NBQ+Pr6ivdfPT29AsW2dOlSDBo0CHp6emjXrh3KlSuHsLAwTJ8+HadPn8bp06ehoqICOzs7LFy4ED179kSfPn2we/duAEBGRga6dOmC5ORk7Nu3D4aGhqhevTr8/PwQHByMatWqSfRuL8rDbNPT08VJ50/3n5kzZ+LevXuoX78+2rdvj3fv3uHIkSPo168foqOjMWfOHHHZiIgINGjQAIqKivD29oaVlRXevXuH27dvY8WKFfj999/FZXOPQc+ePUOLFi3g4+OD2NhY/P333zh69ChOnjyJevXqFbpOGRkZaNGiBd6+fYuOHTsiOTkZW7duRefOnXHkyBG0aNFCXDYtLQ0tW7ZESEgIqlevjt69eyMjIwMHDx6Et7c3Fi5ciMGDBxfo83v16oWjR49i//796Nixo3j6mjVr4Ozs/Nm6FfQYHRMTA1dXVzx//hxeXl6oWbMmoqKi0Lx5c/HFj099675JREREZYRAREREJMM8PT0FAMKJEycKtFzPnj0FAML48eMlph88eFAAINjZ2QlZWVni6b6+vgIAwcbGRnjx4oV4elxcnKCnpydoa2sLaWlpEusCIDRq1CjPZ/v7+wsAhNOnT+eZt3btWgGAsHbtWvG0Dh06CACEiIiIPOXj4+Ml3ltZWQlWVlYS0wICAgQAQteuXYXs7Gzx9GvXrgkqKiqCnp6e8OHDhzzx6erqCnfu3BFPT05OFhwcHAQFBQXh+fPneWLJj5WVlaCqqioIgiAMHjxYUFJSEmJiYsTznZ2dBRcXF0EQBMHLy0sAIDx8+FA8PzU1VXj27Fme9d66dUvQ0tISmjVrJjE9v+33sUaNGgkAhOrVqwuvX7/OM/9zbRMRESGoqqoKtra2QkJCgvD06VPBwMBAMDQ0/OZtUVhWVlaCoqKi4O/vn+e1ZcsWQRAE4dWrV0JCQkKeZdevXy8AEKZNmyaeduPGDQGA4OPjk6d8amqqxHq+tK9+Krfsx9s+MjJSUFJSEqpVq5ZnXw0MDBQACLNnz5aY/vPPPwsAhCVLlgiCIAijR4/O97v68OFDAYDg6+v71djyW87W1la8HSdPniwMHDhQsLW1FdTU1IQ///wzz3IPHjzIMy0jI0No3ry5oKioKDx+/Fg8fcSIEQIAYc+ePXmW+XQ7NGjQQFBUVBSOHDkiMT06OlrQ1tYWfz9y5e7DHzt9+rQAQPD395eYbmVlJQAQvL29JY5PJ06cEAAIXl5eEuUnTJggABAmTZokcaz48OGDULt2bUFFReWb9vfcePr16yekpaUJhoaGQuvWrcXzL1++LAAQ5syZI8TExOR7rCzsMfrjfV0QBGH58uUCgDz7cUH3zcLub0RERCQ7OPQKERERybSXL18CyLnF/1ulp6djy5YtMDQ0zPOAxNatW6N58+a4d+9evsOSTJo0CaampuL3RkZG8Pb2RkJCAqKjowtZi2+T39AkhoaGX11u/fr1UFZWRlBQkMQwJDVq1ICvry/evXuHPXv25FnOz88Pjo6OEp/fpUsXZGdn4+rVqwWOv1evXsjMzMT69esBAJcuXUJkZOQXh15QVVWFmZlZnunOzs5o3Lgxzpw5g4yMjALHEhAQAAMDg28uX61aNcycORP379/HgAED0K1bN7x58wZr1qxBhQoVCvz5BZWVlYWAgIA8r61btwIAypUrBy0trTzLdevWDTo6Ojhx4kSeefntT6qqqvmup7CWL1+OzMxMLFy4MM++OmbMGBgbG2PLli0S05ctWwZra2uMHDkSCxcuxOzZs1G3bl1MnTq12OICcnpy527HqVOnYsmSJbh//z6aNWuGZs2a5Smf310HSkpK6N+/P7KysnD69Ok887/2nQ0PD8f58+fh6+sLLy8viXIODg747bffcPPmzW8eguVz5s2bJ9EzumnTprCyssKVK1fE07Kzs7F06VLY2toiICBA4lihra2NyZMnIz09Hbt27SrQZ6uoqKBr1644evQoXrx4ASCnN7mysjK6deuW7zIFPUanp6dj27ZtKFeuHEaOHClRvk+fPrC3t8/zGYXZN4mIiEi+cegVIiIiKnPu3LmD1NRUNG7cGBoaGnnmN27cGMePH0dERATc3d0l5tWqVStP+dwk/bt370ok3p9//hm7du1C/fr18csvv6Bp06Zwd3f/podOfvjwAQ8ePEClSpXyvZjQuHFjrFy5EhEREXmSVsVd1xo1aqB69epYu3Ytxo4dizVr1kBFRQW//vrrF5eLiIjArFmzcPbsWbx8+TJPYjw+Pl7i4sW3qFu3boHjHzp0KI4ePYq//voLADBgwAD88MMP37Tsu3fv8jzMEMA3P6BTVVUVqampXyyza9cuLF++HNeuXcPbt2+RlZUlnpeboASASpUqoWrVqtiyZQuePXsGHx8feHp6onr16lBQKN5+NBcvXgQA8RAin1JWVsadO3ckpunq6mLTpk3w8PDA0KFDoa2tjc2bN0NJqXj/dfHy8sKRI0fE71+/fo1z587Bz88Pbm5uOHXqlMSwIAkJCZg9ezb27NmD+/fvIykpSWJ9H2/jzp07Y/78+Wjfvj1++uknNG/eHB4eHnku+uRun1evXuW7L+Rumzt37qBKlSqFqufnhhYyNzfHhQsXxO+jo6Px9u1bVKhQIc/zHICcoVA+jqkgevXqhQULFmD9+vUYPnw4tm7dirZt28LY2Fh8sfNjBT1GR0dHi4eYUlNTkyiroKAANzc3/PvvvxLTC7NvEhERkXxjopyIiIhkWvny5XHnzh08f/5covfzl3z48AEAPjumeW7SNbfcx3R0dPJMy03gfZyYLE4//vgj9uzZg7lz52LZsmVYvHgxRCIRGjdujDlz5nxxLO7SVtdevXph6NChOHHiBLZu3Sp+iN7nnD9/Hk2aNAEAtGjRAvb29tDS0oJIJMKePXtw/fp1pKWlFTiOr41nnx+RSAQfHx8cPnwYADBkyJBvXvbdu3f5Jh+/NVH+NXPmzMGoUaNgbGyMFi1awNzcXNybef78+RLbSElJCadOncKUKVPw999/i3vgGhsbY/Dgwfj999+hqKhYLHG9efMGAPJ9gOWX1KxZE1ZWVnjw4AFatWqV70N6i5uhoSF++OEHaGhooHnz5pg4cSKOHz8OIKfHsqenJ65du4YaNWqgW7duMDQ0hJKSEh49eoT169dLbON69eohJCQEM2bMwObNm7F27VoAQJ06dTBz5kzxmNm52+fgwYM4ePDgZ2P7NClfELlj039KSUlJ4iHEubFERkYiMjKyWGOpVq0aatasibVr18LS0hLv3r374p0kBT1uvX//HkDOnRX5yW89hd03iYiISH4xUU5EREQyzc3NDSEhITh58qQ4ofo1uQngV69e5Ts/t4djfoni4pDbazczMzPPvNyEz6e8vb3FQ7ycO3cOu3btwurVq9GyZUvcuXPnsw9YlHZdP9W1a1eMHj0aPXr0wIcPH9C7d+8vlp8+fTrS0tLwzz//5Hm46sWLF3H9+vVCxfHxsBLf6uHDhxg9ejQMDAzw9u1b9OnTB2fOnPmmpLK1tTUEQShMqF+VmZmJP/74A6ampoiIiJBIFgqCgFmzZuVZxtDQEAsXLsSCBQtw584dnDp1CgsXLoS/vz+UlZUxfvz4Yoktd7/68OEDtLW1v3m50aNH48GDBzA0NMT27dvh6+uL1q1bF0tMX5Pbi/zjYUn27t2La9euoXfv3li1apVE+a1bt4qHE/qYu7s7Dh8+jJSUFFy6dAn79+/HkiVL0KZNG9y6dQsVK1YUb5/CPCSzuOXG0rFjR+zcubPY19+7d28MGjQIY8eORYUKFdCqVauvxvKtx63ciwGxsbH5ls9vPYXdN4mIiEh+cYxyIiIikmk9evSAoqIiVqxYIR4a4HNye3w6OTlBTU0NV65cQXJycp5yISEhAPDFntpFoa+vDwB4/vx5nnnh4eFfXFZbWxstW7bEihUr0KNHD7x69QqXLl36bHkdHR1UrFgR9+7dy/fzSrqunzIwMICPjw+eP38OMzOzPOMyf+r+/fswMDDIkyRPTk7GtWvX8pTPTVoXd+/+zMxMdO3aFQkJCdi2bRtGjBiB8+fP59tL/HuLj4/H+/fv4erqmqdHbVhYGFJSUj67rEgkQqVKlTBo0CBx7+l9+/aJ5xd1e+YmnXOHufgWBw8exKJFi9CoUSOEhYVBX18fPXv2zJPsLKm2fvv2LQBI9La+f/8+gJwLVp/6559/vrg+dXV1eHp6Ys6cOZgwYQJSUlLE2zp3+3w8BIq0VKpUCTo6OggLCyvUuP9f88svv0BNTQ3Pnz9H9+7dv3iBqaDHaAcHB6ipqSEsLCzPEEXZ2dk4f/58nnUUZt8kIiIi+cZEOREREck0Ozs7jBkzBvHx8WjVqhUePnyYp0xqairmzp0rHuZCRUUFXbp0QXx8PAIDAyXKHjlyBEePHoWdnR3c3NxKJOY6deoAADZs2CCRjLtw4QI2bdqUp/yZM2fyTQbm9p78dEzeT/n6+iIjIwPjx4+X6NV848YNrFu3Drq6uvDx8SlMVQolKCgIu3fvxp49e746JraVlRXevn0rMRREVlYWRo0ale+FkdwHdD59+rRYYw4ICMCFCxcwcuRINGvWDDNmzEDNmjUxY8aMryZKS1q5cuWgrq6Oa9euSSQV3759m+/wMI8ePcKjR4/yTM9NRH+8PxV1ew4cOBBKSkoYMmQInjx5kmf+u3fvJC4OvXz5Ej179oS+vj7++usvWFtbY8WKFYiNjYWvr6/E/quvrw+RSFTsbT137lwAgIeHh3ialZUVAODs2bMSZUNDQ7Fy5co867hw4UK+Y8p/uo3r1q2LevXqYcuWLdi2bVue8tnZ2QgNDS1kTQpGSUkJAwYMwOPHjzFq1Kh8k+W3bt36bK/tr9HT08PRo0exe/duDB8+/ItlC3qMVlVVRefOnREbG4s5c+ZIlF+1ahXu3r2b5zMKum8SERGR/OPQK0RERCTzpk2bhtTUVMybNw+Ojo5o0qQJqlSpAmVlZTx8+BAnTpzA69evMW3aNPEyM2fORGhoKKZNm4bz58+jXr16ePToEXbs2AENDQ2sXbu22B9smKt+/frihwW6urrCw8MDjx8/xt69e9GuXTvs3r1bovzQoUPx4sULNGzYENbW1hCJRDh79iwuX76M+vXr5+lt/akxY8bg4MGD2LhxI6KiotC0aVPExsZi27ZtyMzMxMqVK7/r0APW1tawtrb+prJDhgzBsWPH0LBhQ3Tu3BlqamoICQnB8+fP4enpKe5ZmsvV1RXq6uqYP38+3r59C2NjYwDAxIkTCx3vmTNnxInx3PGMVVRUsHnzZtSqVQu//vorrl+//tnhb0qagoICBg4ciDlz5qBatWpo164dPnz4gMOHD8PKygoVKlSQKB8REYEOHTqgbt26qFy5MsqXL4/nz5+LL1x8nMRs3LgxRCIRJkyYgMjISOjq6kJPT++bhwmpUqUKlixZggEDBsDR0RGtW7eGra0tEhIS8ODBA4SGhqJHjx5YtmwZBEFA9+7dERcXh507d4ofHNupUyf07t0bq1evxty5c8VjqmtpaaFOnTo4c+YMunXrBnt7eygoKKBbt27ixPaX3Lt3T2KM+Ddv3uDcuXO4du0a9PX1MXPmTPG8du3awdraGrNmzcKtW7dQpUoVREdH48CBA2jfvn2eoUpmzpyJ06dPw8PDAzY2NlBTU8O1a9dw8uRJVKxYEe3btxeX3bJlCxo3boyff/4Z8+fPR82aNaGuro4nT57gwoULiIuL++qDXItLQEAArl27hgULFuDgwYPw8PBAuXLl8Pz5c9y8eRPXr1/HhQsXPjsW+Nd8fPHhawp6jA4KCsLJkycxceJEnD17FjVq1EBUVBQOHTqEFi1a4NixYxLrL8i+SURERGWEQERERCQnrly5IvTq1Uuws7MT1NXVBVVVVcHa2lr45ZdfhOPHj+cpHxcXJwwdOlSwsrISlJWVBSMjI6FTp07CzZs385T19fUVAAgPHz7MM8/f318AIJw+fVpiOgChUaNG+cYaHx8vdO/eXTAwMBDU1dWF+vXrC0ePHhXWrl0rABDWrl0rLrt161ahc+fOgq2traChoSHo6uoK1apVE2bOnCkkJCRIrNfKykqwsrLK83mJiYnCpEmTBAcHB0FFRUXQ09MTWrVqJfzzzz/fXB9BEPKN70usrKwEVVXVbyrr5eWV7zbeuXOnULNmTUFDQ0MwMjISOnfuLNy/f/+zbXLw4EGhTp06grq6ugBA+PiUt1GjRsKXToE/rfubN28ECwsLQVNTU4iOjs5TfuXKlQIAoVOnTt9Ux8L4lm2Ynp4uTJ8+XbC3txdUVVUFS0tLYeTIkUJCQkKefeLp06fCuHHjhPr16wvlypUTVFRUBEtLS6FDhw7ChQsX8qx73bp1gouLi6CqqioAyHf/EoT/tl1++8bly5eFn3/+WahQoYL4u1azZk1h3LhxQlRUlCAIgvDnn38KAIQ+ffrkWT4xMVG87167dk08PTo6WmjdurWgp6cniESiz+63H3v48KF4v/j4paqqKtja2goDBgwQHj9+nGe5Bw8eCB07dhSMjY0FDQ0NoU6dOsLWrVuF06dPCwAEf39/cdkjR44I3bt3FxwdHQVtbW1BS0tLqFy5sjBhwgQhLi4uz7rfvHkjTJw4UahSpYqgrq4uaGlpCfb29sIvv/wi7Nq1S6JsfvtwfjEIwuePB59bjyAIQmZmprB8+XLBzc1N0NHREe9PLVu2FJYuXSokJiZ+Zsvmjadfv35fLRsTE/PZY2VBjtGCIAiPHz8WfvrpJ0FPT0/Q0NAQ3N3dhdDQ0C8e075l3xSE//YbX1/fr9aJiIiIZJNIEEroqUJERERERERERERERDKAY5QTERERERERERERUZnGRDkRERERERERERERlWlMlBMRERERERERERFRmcZEORERERERERERERGVaUyUExEREREREREREVGZxkQ5EREREREREREREZVpTJQTERERERERERERUZmmJO0AiCivxeceSTuEEtGjjpW0QygRCiKRtEMoEXJaLaRnZks7hBKhosRr37IkI0s+90N5pSinB0QFBfmsV3a2IO0QqABSM+TzeKisKJ/fr+dvU6UdQokor6cq7RBKhCCnh0MlOf39SkzLlHYIJcJUV0XaIZQq6jUGSzuE7yIlfJG0QygU/ldNRERERERERERERGUaE+VEREREREREREREVKYxUU5EREREREREREREZRoT5URERERERERERERUpvFhnkREREREREREREQlTcQ+y6UZW4eIiIiIiIiIiIiIyjQmyomIiIiIiIiIiIioTGOinIiIiIiIiIiIiIjKNI5RTkRERERERERERFTSRCJpR0BfwB7lRERERERERERERFSmMVFORERERERERERERGUaE+VEREREREREREREVKYxUU5EREREREREREREZRof5klERERERERERERU0kTss1yasXWIiIiIiIiIiIiIqExjopyIiIiIiIiIiIiIyjQmyomIiIiIiIiIiIioTGOinIiIiIiIiIiIiIjKND7Mk4iIiIiIiIiIiKikiUTSjoC+gD3KiYiIiIiIiIiIiKhMY6KciIiIiIiIiIiIiMo0JsqJiIiIiIiIiIiIqExjopxKzKNHjyASiRAREfFdPi8kJAQikQjv3r0r0npEIhH27NlTLDEREREREREREREBAEQKZeMlo/gwT/puQkJC0LhxY7x9+xZ6enpFWpenpyeqV6+O+fPnF0tsH4uJiYG+vn6xr/d7eh59E1eP7EDco3+R9P4N2gz2h23NBgCArMxMXNy9Do9uXMH7uBioqmvConINNOjUG1r6hgCAZ3euY9esMfmu+6dJC2Bi4/jd6lIQy5YsxIqliyWmWVvbYNf+w1KKqHisXrkcJ08cw6OHD6CqpoZq1Wtg2PBRsLapKO3QiuRq2BWsW7MaUbdvIS4uDvMWLEaTps2kHVaBXbt6BRvXrcGdqEjEx8Xhz3kL4dnkv3qcOnEMu3Zsw52oSLx//x5/bdsFR6dKUoy4cOSlvT4lr/XKysrCiqWLcPjAfrx+HQ8j43Jo5+2D3n0HQCTDDxCS13p9bM2qFVgYPBe//Nodo8dOkHY4xWLr5k1Yv3Y14uPj4ODohHETJsGlalVph1Us5LG9ANmuV/jVMGzasAbRUZGIj49D0JwFaNT4v+O6a83K+S43yG8kfvXt/b3CLBZJSUlYtjgYp0+dwNs3b+DoVAkjx0yAcxUXaYf2TbasXYat65dLTDOzsMaSjbuR8OE9tqxdivCwi4h/9RI6evqo19ATXXsNhKaWtpQi/nbhV8Pw1/r/zg9nzV2ARh+dH65cugjHjx7Gq5cvoaysDKfKldF/sB+quFSTYtRfF341DH9tWIPo2znfr5lzJb9fUydPwKH9eySWqd+gIeYvXvGdIy06Wf9+bVq3CmdOn8CTxw+hqqoGZ5dq6DdkOCytbMRlXsfHY9nCOQi7dAEpycmwsLLGrz1/Q6MmzaUYOZF0MVFO9Iny5ctLO4Qiy0hLhbFFRTg39MLBxVMl5mWmpyH28T3UafcLjC0qIjU5EWc2L8WBBf742X8RAMDUrjJ6z9sisdzF3evx9HYEylk7fLd6FIatnT2Wrlwjfq+oKPuHuathl/FTl65wruKCrMwsLAyeiwF9e2PX3oNQ19CQdniFlpKSDEdHR/h06IgRfoOlHU6hpaSkwMHRET/4dMCYEUPzzE9NSUG1GjXRzKslpgdMlkKExUNe2utT8lqv9WtWYef2rQiYFoiKtva4HXkLUydPgJaWNn7u2k3a4RWavNYrV+Stm/h75zbYO5TOC9KFceTwIcyeFYiJ/gFwcamGTRvXY0C/3th74AgMDQ2lHV6RyGN7AbJfr9TUZNg7OKKtdweMH5X3d/nAsVCJ9xfO/YMZUyehcdMW3yvEYjNtykTcv/cvpk6fCWPjcjh0cD8G9uuFHbsOoJyJibTD+yaW1raYOmeZ+L2ioiIA4E18HN68jkPPAcNhYVURca9isHTudLyJj8O4qbOlFe43S0nJ2Q/b+XTA2HzODy2trDFq3O8wM7dAWmoqtmzagKEDfsPf+45A38BAChF/G3G9vDtg3Mi89QJyEuOTAqaL3yurqHyv8IqVrH+/Iq6FwefHn+FUqQqysrKwamkwRg/ph3Xb9kBdPed/yMCACUhMSMCMOQuhq6eHE0cOIWDCKCxfvxX2jrLXsYeoOMhuX3gqFY4cOYKGDRtCT08PhoaGaNu2Le7fv5+n3KNHj9C4cWMAgL6+PkQiEXr06JHvOl+/fo0uXbrAzMwMGhoacHFxwZYt/yVte/TogdDQUAQHB0MkEkEkEuHRo0fi+VevXkXt2rWhoaGBBg0aIDo6WmL9e/fuRc2aNaGmpoaKFSsiICAAmZmZ4vkfD72Snp6OwYMHw9TUFGpqarCyskJgYKBE2eXLl6Nt27bQ0NBApUqVcOHCBdy7dw+enp7Q1NREgwYN8t0mJcm6ah24dugB21pueeapamii/aggONRtBH1TC5jaVoLnr4MQ+/hfJLyOBQAoKilDU9dA/FLT1MGD8Auo3LBFqe+xp6ioCCMjY/FL1u8OAIAly1fD26cD7Ozs4ejkhKnTgxAT8wK3b0dKO7QiaejeCIP9hqNpM9nuseDW0AMDBg9D46b516N1O2/81n8Q6tZr8J0jK17y0l6fktd63bgejkaNm6ChhycqmJmhWQsv1HN1Q+Stm9IOrUjktV4AkJychAnjRmGS/x/Q0dGRdjjFZuP6tejQqTN82neErZ0dJvoHQE1NDXt2/S3t0IpEXttLHurl6uaBfoP8JO7u+pihkbHE65/QU6hZuy7MzC2+c6RFk5qailMnj2Po8FGoWasOLCyt0G/AYFhYWGLnji1fX0EpoaioCH1DI/FLRy/n3N2qoh3GTZ2Dug0awdTMAlVr1sWvfQbjyoUzyProf7fSqkFDD/Qf/Pn90Kt1W9St3wBm5haoaGcPv5FjkZSYiHv/RudbvrRo0NAD/b/w/QIAFRUVie+Yjo7ud4yweMjD9+vPBcvQqq0PbGztYOfgiHGTp+HVyxjcjbotLnPrRgQ6dP4FlZxdUMHMAt1794OWljaiPypDVNYwUU5FkpSUhBEjRiAsLAwnT56EgoIC2rdvj+zsbIlyFhYW+PvvnH+IoqOjERMTg+Dg4HzXmZqailq1auHgwYO4desW+vbti27duuHy5csAgODgYLi6uuK3335DTEwMYmJiYGHx34nt77//jjlz5iAsLAxKSkro1auXeN4///yD7t27w8/PD7dv38by5cuxbt06TJ8+PU8cALBgwQLs27cP27dvR3R0NDZt2gRra2uJMn/88Qe6d++OiIgIODk54ZdffkG/fv0wfvx4hIWFQRAEDB5cunsppiUnASIRVDQ0853/MOICUhMTUKlh6e9p8+TJY7Ro4o52LZvh97GjEBPzQtohFbvExAQAgK6u7J10EtH3UbVaDVy5dBGPHz0EANyNvoPr4dfQoKG7lCMrGnmtFwAETp8Kd3dP1HeV7YtqH8tIT0fU7UiJOikoKKB+/Qa4cT1cipEVnTy2FyC/9fqcN6/jce7sGbTz6SjtUAosKysLWVlZUFFVlZiuqqqGiPBrUoqq4F48f4IeHZujb5e2mDNtAuJexXy2bFJiAjQ0NKGoJPt3jH4sIyMde/7eDi0tbdg7OEk7nCK7FnYFrZo0RGef1pg5PQDvi/gMMWmQl+/XxxITEwEA2h/9D1mlanWcOn4EH96/R3Z2Nk4eO4z09HRUr1VHWmESSZ18/cLQd9exo+RJ5Zo1a2BsbIzbt29DS0tLPF1RUREG/7+FrFy5cl8co9zMzAyjRo0Svx8yZAiOHj2K7du3o27dutDV1YWKigo0NDTyHSZl+vTpaNSoEQBg3LhxaNOmDVJTU6GmpoaAgACMGzcOvr6+AICKFSvijz/+wJgxY+Dv759nXU+ePIG9vT0aNmwIkUgEKyurPGV69uyJzp07AwDGjh0LV1dXTJo0CV5eXgAAPz8/9OzZ87P1lbbMjHSc27kajvU8oaqef6I88p+jsKxSC9oGxt85uoJxcamGgD8CYWVtg/j4WKxYuhi9fX/Fjt37oKmp9fUVyIDs7Gz8GTQD1WvUhJ196R4Gh4ikp0fv35CUlIhO3m2goKiI7KwsDBwyDK3atJN2aEUir/U6cvgg7ty+jb+27pR2KMXq7bu3yMrKyjPEiqGhIR4+fCClqIpOXttLXuv1JYf274WGhgY8ZXA8Xk1NTVStVh2rViyFjY0tDAwNcfTwQdy8EQFzC0tph/dNHCpXgd+4qTCzsMKb1/HYun45xg/thQVrd0Ljkw48H969xfaNK9Ginexd1Pics2dCMHHsSKSmpsLIyBgLl62CnozfDevaoCE8mzRDBTNzPH/2BEsXzsfwwf2wcv1m8bA6skAevl8fy87OxqK5M1GlWg1UtLUXT/efMRtTJ4zGD80bQlFRCWpqavhj1nyZrKNMKeV36Zd1TJRTkfz777+YPHkyLl26hPj4eHFP8idPnqBy5fwflPM1WVlZmDFjBrZv347nz58jPT0daWlp0PjGsZirfvRwKFNTUwBAbGwsLC0tcf36dZw7d06iB3lWVhZSU1ORnJyc5zN69OiB5s2bw9HRES1btkTbtm3RooVkr+qPP8/k/2OVubi4SExLTU3Fhw8f8r2FNS0tDWlpaRLTMtLToKyimqdsccvKzMThpdMBAfDsNiTfMglv4vDk1lW0GlD6H+Tk5u4h/tvB0REuLtXQxqsJjh89Ap8OnaQYWfEJnBaAe/f+xboNm6UdChGVYsePHsaRgwcwLehP2NraIzo6CnNnBcLYuBzaevtIO7xCk8d6vXwZgz+DZmDpijVQVS35334qGnltL3mt19fs37cLXq3aymydp06fian+v6NV80ZQVFSEo1NleLVsg6go2Rier1a9huK/rW0d4FDJBb/93BrnTh9D8zbtxfOSkxIxdfxQWFhVRJce/aQRaomoVacuNm7bhXfv3mHvrh2YMGYE1vy1FQYGsvv8huYtW4v/trN3gJ29Izq288K1sMuoU89VipEVnKx/vz42f9Z0PHxwDwtXrJeYvmbZIiQmJmDOopXQ1dPH2dBTmDJhFBauWIeKduyURWUTE+VUJO3atYOVlRVWrlyJChUqIDs7G1WqVEF6enqh1/nnn38iODgY8+fPh4uLCzQ1NTFs2LBvXqeysrL479zxtHMT+ImJiQgICECHDh3yLKemppZnWs2aNfHw4UMcPnwYJ06cQOfOndGsWTPs3PlfT5v8Pu9LMXwqMDAQAQEBEtNa9fRDm97DvljPospNkifEv0L7MbM+25s86uwxqGlpw6a6bJ3YAIC2jg4srazx9MljaYdSLAKnT8WZ0BCsWf8XTOTgobNEVHIWzJ0N39594NWqDQDAzsEBMTEvsHb1CplNKAPyWa+oyEi8efMav/z037lJVlYWrl0Nw7Ytm3Dp6g2Z6oX3MX09fSgqKuL169cS01+/fg0jIyMpRVU08tpe8lqvL4m4FoYnjx5iWtAcaYdSaOYWllixZiNSkpORlJQII+NyGD96OMzMzaUdWqFoaWujgrklYp4/FU9LTk7ClDGDoK6ugfF/zIWSkvIX1iBb1NU1YGFpBQtLK7hUrYaO7Vpi3+6/0aN3X2mHVmzMzC2gp6ePZ0+fyFyiXF6+X/P/nI4LZ0OxYPk6lDP573/I58+eYveOLVi7ZTdsbO0AAHYOjrgRcRW7d2zFyPGTpRUykVQxUU6F9vr1a0RHR2PlypVwd88ZG/Ts2bOfLa/y/6ddZ2VlfXG9586dg7e3N3799VcAOQnmu3fvSvRQV1FR+ep68lOzZk1ER0fDzs7um5fR0dHBTz/9hJ9++gmdOnVCy5Yt8ebNG/FQMkU1fvx4jBgxQmLamqufH5uvOOQmyd/FPkeH0bOgrpX/w5oEQcDts8fg1KCZTI4FmJychGdPn6JNux+kHUqRCIKAoBl/4NTJ41i1dqPMPWyKiL6/1NQUKIgkH0WjqKAIQcj/oq2skMd61a1fHzt27ZOY5j9pAmxsKqJHrz4ynZxUVlFBpcrOuHTxApo0zXnwW3Z2Ni5duoCfu/wq5egKR17bS17r9SX79+6CUyVnuRgTWl1DA+oaGvjw4T0uXDiHocNGfX2hUiglORkvXzyDZ4uci6HJSYmYMnoglJVVMHHG/DzjRcsbQRCQUYQOZ6VR7KuXeP/+HQyNSvcQnl8iq98vQRAQPHsGzoacwvyla2BqJpngT0tNAZDz7JCPyfp5FVFRyV7mi0oNfX19GBoaYsWKFTA1NcWTJ08wbty4z5a3srKCSCTCgQMH0Lp1a6irq0NLSwuLFi3C7t27cfLkSQCAvb09du7cifPnz0NfXx9z587Fq1evJBLl1tbWuHTpEh49egQtLa1vTlpPnjwZbdu2haWlJTp16gQFBQVcv34dt27dwrRp0/KUnzt3LkxNTVGjRg0oKChgx44dKF++/BfHWC8oVVXVPLd7Kqu8KdI601NT8D72v4dYfoh/ibgn96GmqQ0NXQMcWvIH4h7fQzu/qRCEbCS9z/k8NU1tKH7US+NZVAQ+xL+Es0fLIsXzvcybPRMejRrDtEIFxMXFYtniRVBQVEDLVm2lHVqRzJgWgMOHDmD+giXQ1NREfHwcAEBLSzvfOyFkRXJSEp48eSJ+//zZM9yJioKuri5MK1SQYmQFk5ychKcf1ePF82eIvpNTj/KmFfD+/Tu8jIlBfFwsAIgfQmhoZAQjGfqnQV7a61PyWi/3Ro2xZuVylDc1RUVbe0TfuY1NG9fhB5+8d1TJEnmsl6amVp5nTqirq0NXT08unkXRzbcnJk0YC2fnKqjiUhV/bVyPlJQU+LSXzTaT1/aSp3rldJT4+Hf5Oe5GR0FHJ+d3GQCSEhNx6vhRDBkxWlphFosL585CgAArKxs8ffoYC+bNhrW1DX7wbv/1hUuBtUvmok4DDxibVMCb17HYsnYZFBQU4NG0JZKTEuE/aiDS0lIx/PfpSE5KQnJSEgBA5/93q5RmyclJePbkk/3wThR0dHWhq6eHtSuXw92zCYyMjPDu3Tvs3LYZcbGv0LS5lxSj/rovfb90dHWxevkSNG7aAgZGRnj+9AkWBc+BuYUl6jdo+IW1lk6y/v2aP2s6Thw9hOmzg6GuoYnX8fEAAC0tLaiqqcHS2gZmFpaYExiAAX6joKOrh7OhpxB2+QIC5y6ScvRy7pNOH1S6MFFOhaagoICtW7di6NChqFKlChwdHbFgwQJ4enrmW97MzEz8MM2ePXuie/fuWLduHeLj43H//n1xuYkTJ+LBgwfw8vKChoYG+vbtCx8fH7x//15cZtSoUfD19UXlypWRkpKChw8fflPMXl5eOHDgAKZOnYqZM2dCWVkZTk5O6NOnT77ltbW1MWvWLPz7779QVFREnTp1cOjQoTxXXUub2Ed3sWvWGPH7f7YuBwBUcmuOet6/4mHERQDAlikDJZbrMGYWzJ2qid9H/nMEpnaVYWAqGw/zePXqFcaPHYn3795BX98A1WvWwvpN26BfTL3/pWXHti0AgD49u0lMD5gWCG8ZTg5FRt5Cn57dxe9nzwoEAPzg3R5/zAiSVlgFFhUZif59fMXv582eCQBo84MPpvwRiDMhpzF18n9j/P8+diQA4Lf+g9B3wODvG2wRyEt7fUpe6zV6/EQsWxSMoOlT8fbNGxgZl0OHTp3xW/+BX1+4FJPXesmzlq1a4+2bN1iyaAHi4+Pg6FQJS5avgqGMDr1Cpd+d25EY1LeH+P2CuTm/y63b+WBSwAwAwPGjhyBAQAuvNtIIsdgkJiZg0YJ5iH31Ejq6umjStAUGDRkGJWXZGJ4kPu4VZv8xHgkf3kNXVx+VXKpj1pIN0NUzwM3wMNyNugkA6N9V8u7QFVsOwsS0dF/MjoqMxMDfeojfz5/z//PDdj4YO9Efjx89xKGRfnj37i109fRQybkKlq/ZiIp29p9ZY+kQdTsSgz6qV/Cc/75fYyZMxr1/7+LQ/r1ISPgAI+NyqOfqhr4Dh4jvLpclsv792vv3NgDAsP69JKaPnfwHWrX1gZKSMmbOW4IVi+djwsjBSElOgZm5Bcb7T0d9N4/8VklUJogEQRCkHQQRSVp87pG0QygRPepYSTuEEqEgp0+tltNqIT1TPm8lVFEq3RfwSFJGlnzuh/JKUU4PiAoK8lmv7Gz+eyNLUjPk83iorCif36/nb1OlHUKJKK8nn8O6yGu2R0lOf78S0zKlHUKJMNWVvQslJUm9/lhph/BdpFycKe0QCoX/VRMRERERERERERFRmcZEORERERERERERERGVaRyjnIiIiIiIiIiIiKikyemQfvKCPcqJiIiIiIiIiIiIqExjopyIiIiIiIiIiIiIyjQmyomIiIiIiIiIiIioTGOinIiIiIiIiIiIiIjKND7Mk4iIiIiIiIiIiKikidhnuTRj6xARERERERERERFRmcZEORERERERERERERGVaUyUExEREREREREREVGZxjHKiYiIiIiIiIiIiEqaSCTtCOgL2KOciIiIiIiIiIiIiMo0JsqJiIiIiIiIiIiIqExjopyIiIiIiIiIiIiIyjQmyomIiIiIiIiIiIioTOPDPImIiIiIiIiIiIhKmoh9lksztg4RERERERERERERlWlMlBMRERERERERERFRmcZEORERERERERERERGVaRyjnIiIiIiIiIiIiKikiUTSjoC+gD3KiYiIiIiIiIiIiKhMY6KciIiIiIiIiIiIiMo0JsqJiIiIiIiIiIiIqEzjGOVEpVDPOlbSDqFEOI7YJ+0QSsSVGa2lHUKJ0FRVlHYIJSIzS5B2CCVCELKlHUKJUFKU0zH85HM3hLKSfPbByMqW0waTU/LaWqkZWdIOoUSoKsnn+UZGlnz+LlsZaUg7BCoAeR0KWZDTA72uhrK0QyCSiqVLl2Lp0qV49OgRAMDZ2RmTJ09Gq1atAACpqakYOXIktm7dirS0NHh5eWHJkiUwMTERr+PJkycYMGAATp8+DS0tLfj6+iIwMBBKSgVLfTNRTkRERERERERERFTSRPLZsaQozM3NERQUBHt7ewiCgPXr18Pb2xvh4eFwdnbG8OHDcfDgQezYsQO6uroYPHgwOnTogHPnzgEAsrKy0KZNG5QvXx7nz59HTEwMunfvDmVlZcyYMaNAsYgEQV6vxRHJruR0+fxaske5bJHXHuUZmfL5/VJUkM8uQ/LaozxbTnsos0e5bJHX44a8thd7lMsWee1RrqYsn+0lr9ijXLYIcnpPlIaynO6IhaTuMUXaIXwXKWemFGl5AwMD/Pnnn+jUqROMjY2xefNmdOrUCQBw584dVKpUCRcuXED9+vVx+PBhtG3bFi9evBD3Ml+2bBnGjh2LuLg4qKiofPPnyud/M0RERERERERERET03aWlpeHDhw8Sr7S0tK8ul5WVha1btyIpKQmurq64evUqMjIy0KxZM3EZJycnWFpa4sKFCwCACxcuwMXFRWIoFi8vL3z48AGRkZEFipuJciIiIiIiIiIiIiIqFoGBgdDV1ZV4BQYGfrb8zZs3oaWlBVVVVfTv3x+7d+9G5cqV8fLlS6ioqEBPT0+ivImJCV6+fAkAePnypUSSPHd+7ryC4BjlRERERERERERERCWtjIxRPn78WIwYMUJimqqq6mfLOzo6IiIiAu/fv8fOnTvh6+uL0NDQkg4zDybKiYiIiIiIiIiIiKhYqKqqfjEx/ikVFRXY2dkBAGrVqoUrV64gODgYP/30E9LT0/Hu3TuJXuWvXr1C+fLlAQDly5fH5cuXJdb36tUr8byCKBuXMYiIiIiIiIiIiIio1MvOzkZaWhpq1aoFZWVlnDx5UjwvOjoaT548gaurKwDA1dUVN2/eRGxsrLjM8ePHoaOjg8qVKxfoc9mjnIiIiIiIiIiIiIi+u/Hjx6NVq1awtLREQkICNm/ejJCQEBw9ehS6urro3bs3RowYAQMDA+jo6GDIkCFwdXVF/fr1AQAtWrRA5cqV0a1bN8yaNQsvX77ExIkTMWjQoAL1ageYKCciIiIiIiIiIiIiKYiNjUX37t0RExMDXV1dVK1aFUePHkXz5s0BAPPmzYOCggI6duyItLQ0eHl5YcmSJeLlFRUVceDAAQwYMACurq7Q1NSEr68vpk6dWuBYRIIgCMVWMyIqFsnp8vm1dByxT9ohlIgrM1pLO4QSoamqKO0QSkRGpnx+vxQVRNIOoUQoKcpnvbKz5XM/VFaSz1H9suS0veT1uCGv7ZWakSXtEEqEqpKcnm9kZUs7hBKhpiyf7SWvRPJ5mIe8ZrEEyGfFNJTldEcsJPXGf0g7hO8i5fQkaYdQKPL53wwRERERERERERER0TdiopyIiIiIiIiIiIiIyjQmyomIiIiIiIiIiIioTGOinIiIiIiIiIiIiIjKNCVpB0BEREREREREREQk90Tss1yasXWIiIiIiIiIiIiIqExjopyIiIiIiIiIiIiIyjQmyomIiIiIiIiIiIioTOMY5UREREREREREREQlTSSSdgT0BexRTkRERERERERERERlGhPlRERERERERERERFSmMVFOBMDT0xPDhg37YhmRSIQ9e/Z8l3iIiIiIiIiIiIjo++EY5UTfKCYmBvr6+tIOo0SsWbUCC4Pn4pdfu2P02AnSDidfg1rYo1U1U9iaaCM1IwtXH7zBjL238SA2Md/yGwbUR2NnE/RZcQlHb7zMM19PUxnHxjWGqb46nEcfxIeUzJKuwjf7a+1KnDl9Ak8eP4SqqhqqVK2OfoOHw9LaRlzGr18PRFwLk1juhw4/YuR4/+8dbqFlZWVhxdJFOHxgP16/joeRcTm08/ZB774DIJKhcdvCr4Zh04Y1iI6KRHx8HILmLECjxs3E811rVs53uUF+I/Grb+/vFWaBXbt6BX+tX4M7UZGIj4vDrLkL4dkkp16ZGRlYujgY58+ewfNnz6ClrYU69VwxeOhIGJcrJ+XICy721SsEz5uN82fPIDU1FRYWlpgybQYqO7tIO7QiSUpKwrLFwTh96gTevnkDR6dKGDlmApyryG69roZdwbo1qxF1+xbi4uIwb8FiNGna7OsLygB53A/ZXqVb+NUwbN6wBtFRtxEfH4fAOQvQqHFT8fzk5CQsXTAPZ0JO4f37d6hQwQw/dvkV7Tv9JMWoC65tyyaIefEiz/Qff/oF436fLIWICif8ahj+2rAG0bdzzjdmzpU835g6eQIO7d8jsUz9Bg0xf/GK7xxp0axeuRwnTxzDo4cPoKqmhmrVa2DY8FGwtqko7dCKRF7rJa/HeXltr+1bt2Dnti148eI5AKCinR369h+Ehu4eUo6MqPRgopxkVkZGBpSVlb/b55UvX/67fdb3FHnrJv7euQ32Do7SDuWL6tsZYv2Zh7j++B0UFUUY264SNg12RZNpp5CSniVRtk/jihC+sr7Zv9RA1IsPMNVXL7mgC+n6tTC0/7ELnCpXQVZWJlYuCcaoIX2xfvteqKtriMu19emEXv0Gi9+rqalJI9xCW79mFXZu34qAaYGoaGuP25G3MHXyBGhpaePnrt2kHd43S01Nhr2DI9p6d8D4UUPzzD9wLFTi/YVz/2DG1Elo3LTF9wqxUFJTUmDv4Ih2Ph0wdoRkvVJTUxEddRu9fhsAB0cnfPjwHnNnBWLksIHYsHmnlCIunA/v36Nn9y6oXaceFi5dCX19Azx58gjaOrrSDq3Ipk2ZiPv3/sXU6TNhbFwOhw7ux8B+vbBj1wGUMzGRdniFkpKSDEdHR/h06IgRfoO/voCMkNf9kO1VuqWmpsBO/Pvll2f+gjmzcPXKJfhPC4JpBTNcunAOc4KmwcjYGO6Nmkgh4sLZuHknsrL/O1e8f+9fDOzbC81aeEkxqoJLSck532jn3QHjRuY93wByEuOTAqaL3yurqHyv8IrN1bDL+KlLVzhXcUFWZhYWBs/FgL69sWvvQahraHx9BaWUvNZLXo/z8tpeJuVNMGT4SFhaWQGCgP1792D4kEHYunMXbO3spR1e2SHi4B6lGVtHzmVnZ2PWrFmws7ODqqoqLC0tMX16zsnTzZs30aRJE6irq8PQ0BB9+/ZFYuJ/vXN79OgBHx8fzJgxAyYmJtDT08PUqVORmZmJ0aNHw8DAAObm5li7dq14mUePHkEkEmHr1q1o0KAB1NTUUKVKFYSGhuaJ7WMxMTFo06YN1NXVYWNjg82bN8Pa2hrz588XlxGJRFi6dCl++OEHaGpqYvr06cjKykLv3r1hY2MDdXV1ODo6Ijg4WGLdufUICAiAsbExdHR00L9/f6Snp+fZVmPGjIGBgQHKly+PKVOmSMz/dOiVZ8+eoUuXLjAwMICmpiZq166NS5cuAQCuX7+Oxo0bQ1tbGzo6OqhVqxbCwiR7/5YGyclJmDBuFCb5/wEdHR1ph/NF3ZZcxI5LT3H3ZQKinn/AiL/CYW6ggaoWehLlKpvpoG8TO4z6K/zz62poDR0NZSw/ea+Eoy6cPxcuR6t2PrCxtYOdgxPG+0/Hq5cxuBt1W6KcmpoaDI2MxC9NLS0pRVw4N66Ho1HjJmjo4YkKZmZo1sIL9VzdEHnrprRDKxBXNw/0G+Qn7m39KUMjY4nXP6GnULN2XZiZW3znSAumQUMPDBg8DI2bNM8zT0tbG4uWr0Fzr1awsraBS9XqGD1uIu7cjsTLmLy99kqzdWtWwaS8KQKmBaKKS1WYmZvDtUFDWFhYSju0IklNTcWpk8cxdPgo1KxVBxaWVug3YDAsLCyxc8cWaYdXaA3dG2Gw33A0bZZ3v5Rl8rofsr1KN1c3d/Qb5IdGn/n9unkjAq3beaNm7bowrWAGn46dYWfviNsy9jutb2AAIyNj8euf0BCYW1iiVu260g6tQBo09ED/L5xvAICKiorEOYeOjF28AYAly1fD26cD7Ozs4ejkhKnTgxAT8wK3b0dKO7Qikdd6yetxXl7bq5FnE7h7NIKVlTWsrG0w2G84NDQ0cOP6dWmHRlRqMFEu58aPH4+goCBMmjQJt2/fxubNm2FiYoKkpCR4eXlBX18fV65cwY4dO3DixAkMHix5FfjUqVN48eIFzpw5g7lz58Lf3x9t27aFvr4+Ll26hP79+6Nfv3549uyZxHKjR4/GyJEjER4eDldXV7Rr1w6vX7/+bJzdu3fHixcvEBISgr///hsrVqxAbGxsnnJTpkxB+/btcfPmTfTq1QvZ2dkwNzfHjh07cPv2bUyePBkTJkzA9u3bJZY7efIkoqKiEBISgi1btmDXrl0ICAiQKLN+/Xpoamri0qVLmDVrFqZOnYrjx4/nG29iYiIaNWqE58+fY9++fbh+/TrGjBmD7OxsAEDXrl1hbm6OK1eu4OrVqxg3btx37f3+rQKnT4W7uyfquzaQdigFpqOWsz3fJf93wUNNWRELe9TGxO03EJeQlu9y9uW14dfKEcM2XEO28LV+56VD7gWsT3uqHT9yED80a4geP/lgxaJ5SE1NkUZ4hVa1Wg1cuXQRjx89BADcjb6D6+HX0KChu5QjKzlvXsfj3NkzaOfTUdqhFLvExASIRCJoaZfui26fCg05hcqVq2DMCD80bdQAXX5sj107t399wVIuKysLWVlZUFFVlZiuqqqGiPBrUoqKPkde90N5VVbay6VqdfwTehpxsa8gCAKuXrmEp08eoW59N2mHVmgZGek4dHAfvH06yNQwb9/qWtgVtGrSEJ19WmPm9AC8f/dO2iEVWWJiAgBAV1f2kv5fIq/1klfy2F5ZWVk4cuggUlKSUbV6dWmHQ1RqcOgVOZaQkIDg4GAsWrQIvr6+AABbW1s0bNgQK1euRGpqKjZs2ABNTU0AwKJFi9CuXTvMnDkTJv+/JdvAwAALFiyAgoICHB0dMWvWLCQnJ2PChJxxrHMT8WfPnsXPP/8s/uzBgwejY8ecRNDSpUtx5MgRrF69GmPGjMkT5507d3DixAlcuXIFtWvXBgCsWrUK9vZ5b/355Zdf0LNnT4lpHye8bWxscOHCBWzfvh2dO3cWT1dRUcGaNWugoaEBZ2dnTJ06FaNHj8Yff/wBBYWc60VVq1aFv3/O+M729vZYtGgRTp48iebN814d37x5M+Li4nDlyhUYGBgAAOzs7MTznzx5gtGjR8PJyUm8vtLmyOGDuHP7Nv7aKlvDJACASAT4d6qCy/dfIzomQTzdv2MVXH34Bsdu5h2THABUlBSwqEctTN8TiRdvU2BpVPpvm8vOzsaiuUFwqVYDFT+6Ha6pVxuUN60AQ2NjPPj3LpYvmocnjx9h2p/BX1hb6dKj929ISkpEJ+82UFBURHZWFgYOGYZWbdpJO7QSc2j/XmhoaMAzn17asiwtLQ2LguegRcs20JKxOxueP3uKndu3oGv3Huj1Wz9E3rqJP4OmQ1lZGe2820s7vELT1NRE1WrVsWrFUtjY2MLA0BBHDx/EzRsRMJexXq9lgbzuh/KqrLTXiLG/Y+Y0f3i3bAJFJSUoiEQYNykANWrVlnZohXb61EkkJiTIVTvlcm3QEJ5NmqGCmTmeP3uCpQvnY/jgfli5fjMUFRWlHV6hZGdn48+gGaheoybs7B2kHU6xkdd6ySt5a69/70bDt2sXpKenQV1DA3OCF8HW1u7rCxKVEUyUy7GoqCikpaWhadOm+c6rVq2aOEkOAG5ubsjOzkZ0dLQ4Ue7s7CxOJAOAiYkJqlSpIn6vqKgIQ0PDPL2/XV1dxX8rKSmhdu3aiIqKyjfO6OhoKCkpoWbNmuJpdnZ2+T44MzeR/rHFixdjzZo1ePLkCVJSUpCeno7qn1wRrVatGjQ+GkvM1dUViYmJePr0KaysrADkJMo/Zmpqmm+vdgCIiIhAjRo1xEnyT40YMQJ9+vTBxo0b0axZM/z444+wtbXNt2xaWhrS0iR7P2eJVKD6SS/A4vTyZQz+DJqBpSvWlOjnlJTpnavC0VQHHeb9I57W3KU83ByM0DIo5LPLjfuhEu69SsDuK88+W6a0mTdrGh7ev4eFKzdITP+hw4/iv23tHGBoZIzhA3vj+bMnMDOXjSTY8aOHceTgAUwL+hO2tvaIjo7C3FmBMDYuh7bePtIOr0Ts37cLXq3ayuT37nMyMzIwYcxwCIKAsb/LzsNkc2VnC6js7IwhfiMAAE6VKuP+vX+xc/tWmU+kTJ0+E1P9f0er5o2gqKgIR6fK8GrZBlFRsn3bsDyS5/1QHpWV9tq5dRMib97ArHmLUN60AiKuhf1/jPJyqFPP9esrKIX27t6JBm7uMC4nm89p+JLmLVuL/7azd4CdvSM6tvPCtbDLMttegdMCcO/ev1i3YbO0QylW8loveSVv7WVtY4Otf+9GYkICThw7ism/j8OqdRuZLP+e5PCOJnnCoVfkmLp60R9S+OlwISKRKN9puUOOlLSPE/sAsHXrVowaNQq9e/fGsWPHEBERgZ49e+YZf/xbFKReX9u2U6ZMQWRkJNq0aYNTp06hcuXK2L17d75lAwMDoaurK/GaPSuwwPEXRFRkJN68eY1ffuqA2tWdUbu6M66GXcGWTRtRu7ozsrKyvr4SKfnjRxc0rVIePy04h5fvUsXTGzgYwcpIE5F/tsbD4HZ4GJzTK3l5n7rY7uf2/zLGaFPDTDx/65Cc6deDWmFE69L3MNP5s6bjwj+hmL90DcqZfPlhspWquAAAnj99+j1CKxYL5s6Gb+8+8GrVBnYODmjTzhtduvli7eoV0g6tRERcC8OTRw/xQ/tO0g6l2GRmZGD8mOGIiXmBhctWy1xvcgAwMjZGxU/+MbCpaIuXL2OkFFHxMbewxIo1G/HPhas4ePQUNmzejszMDJiZm0s7NPqEPO+H8qgstFdaaiqWLZqPISPGoGGjxrBzcESnn7uiaYtW2Lxh7ddXUArFvHiOyxcvwKfjj18vLAfMzC2gp6ePZ0+fSDuUQgmcPhVnQkOwas16mJT/8nmwLJHXeskreWwvZWUVWFpaobJzFQwdPhIOjk7Y8teGry9IVEawR7kcs7e3h7q6Ok6ePIk+ffpIzKtUqRLWrVuHpKQkcfL53Llz4iFWiurixYvw8PAAAGRmZuLq1at5xj/P5ejoiMzMTISHh6NWrVoAgHv37uHt27df/Zxz586hQYMGGDhwoHja/fv385S7fv06UlJSxAnuixcvQktLCxYWhXuYXtWqVbFq1Sq8efPms73KHRwc4ODggOHDh6NLly5Yu3Yt2rfP28to/PjxGDFihMS0LFHJPqG+bv362LFrn8Q0/0kTYGNTET169Sm1t2f+8aMLWlYzxY/B5/D0dbLEvCXH/sXW848lpp34vQkC/r6FE7dyhmLpt+oy1JT/q1s1K33M+bUGOs4/i8dxSSVfgW8kCAKC/5yBf0JOInjZWpiafT2pde/uHQCAoZFRSYdXbFJTU6DwyRO/FRUUIQjf58Lb97Z/7y44VXKGvYOTtEMpFrlJ8qdPHmPpyvXQ08t7F5AsqF69Bh79f5z8XI8fPYKpaQUpRVT81DU0oK6hgQ8f3uPChXMYOmyUtEOiT5SF/VCelIX2yszMRGZmpsSdpQCgoKAgM894+dS+Pbugb2CIhu6NpB3KdxH76iXev38HQyNjaYdSIIIgIGjGHzh18jhWrd1Y6h9+/q3ktV7yqiy1l5CdXaiOhkTyiolyOaampoaxY8dizJgxUFFRgZubG+Li4hAZGYmuXbvC398fvr6+mDJlCuLi4jBkyBB069ZNPOxKUSxevBj29vaoVKkS5s2bh7dv36JXr17i+U5OTggMDET79u3h5OSEZs2aoW/fvli6dCmUlZUxcuRIqKurf/UhO/b29tiwYQOOHj0KGxsbbNy4EVeuXIGNjY1EufT0dPTu3RsTJ07Eo0eP4O/vj8GDB+c5+f9WXbp0wYwZM+Dj44PAwECYmpoiPDwcFSpUQPXq1TF69Gh06tQJNjY2ePbsGa5cuSIes/1TqqqqeYZhSE4v2X9ANDW18oyvpq6uDl09vVI77tr0zlXhXdscfVZcQlJqJoy1c7ZZQmoGUjOyEZeQlu8DPF+8TRYn1R/HSybX9bVyLkjce5mADymZJVyDbzdv5jScPHoI02cvgLqGJl7HxwMAtLS0oKqmhufPnuDEkUOo7+YOHV09PPj3LhbNm4lqNWrD1r709Yz/HPdGjbFm5XKUNzVFRVt7RN+5jU0b1+EHnw7SDq1AkpOTJHprvXj+HHejo6Cjo4vy/0+aJCUm4tTxoxgyYrS0wiyw5OQkPHvycb2e4e6dKOjo6sLIyBjjRg/DnajbmLtgKbKysxAfHwcg5yFHysole7GvOHXt3gM9u3XB6pXL0NyrFSJv3sCuv7dj4uSp0g6tyC6cOwsBAqysbPD06WMsmDcb1tY2+EGGh4ZITkrCk4/2y+fPnuFOVBR0dXVhWkF2k5Tyuh+yvUq3T3+/Yp4/k/j9qlGrDhbNnw1VVVWUN62A8KtXcPjgPgwdkfeZQ6VddnY29u3djbY/+EBJSTb/Bf7S+YaOri5WL1+Cxk1bwMDICM+fPsGi4Dkwt7BE/QYNpRh1wc2YFoDDhw5g/oIl0NTUFJ9faGlpQ01NTcrRFZ681ktej/Py2l4L5s2Bm7sHTE1NkZSUhMMHDyDsymUsWb5K2qERlRqyeZZA32zSpElQUlLC5MmT8eLFC5iamqJ///7Q0NDA0aNH4efnhzp16kBDQwMdO3bE3Llzi+Vzg4KCEBQUhIiICNjZ2WHfvn0w+qina3R0NN6/fy9+v2HDBvTu3RseHh4oX748AgMDERkZ+dUfoX79+iE8PBw//fQTRCIRunTpgoEDB+Lw4cMS5Zo2bQp7e3t4eHggLS0NXbp0wZQpUwpdPxUVFRw7dgwjR45E69atkZmZicqVK2Px4sVQVFTE69ev0b17d7x69QpGRkbo0KGDxENHqeC6e+Rc/NgxTPJkf8TGa9hxSXaGG/kWe//eBgDw6y/54Npxk6ehVTsfKCsp4+rli9i5dSNSU1JgbFIeHk2ao3uvftIIt9BGj5+IZYuCETR9Kt6+eQMj43Lo0Kkzfus/8OsLlyJ3bkdiUN8e4vcL5s4EALRu54NJATMAAMePHoIAAS282kgjxEKJiozEgN98xe/nz8mpV5t2Pvit/2CcCTkFAPj1J8mk69KV61GrTt3vF2gROVdxwez5C7Fo/lysXLYEFczMMWrMeLRuK/sPlU1MTMCiBfMQ++oldHR10aRpCwwaMgxKnww1JksiI2+hT8/u4ve5Q5X94N0ef8wIklZYRSav+yHbq3S7czsSg/v+d66xYO4sAEDrdt6YGDADUwP/xNKF8zHl97H48OE9yptWQL9BQ9G+00/SCrnQLl08j5cxL+AtYxfjPxZ1OxKDfushfh8857/zjTETJuPev3dxaP9eJCR8gJFxOdRzdUPfgUOgoiI7F68BYMe2LQCAPj27SUwPmBYo0+0nr/WS1+O8vLbXmzdvMGnCWMTHxUFLWxv2Do5YsnwV6jdwk3ZoRKWGSBBk9N45KpUePXoEGxsbhIeH53mgZkE8e/YMFhYWOHHiRL4PIy2IHj164N27d9izZ0+R1vM9lXSPcmlxHLHv64Vk0JUZrb9eSAZpqpbOIXiKKiNTPr9figry+VAYJUX5rFd2tnzuh8pK8vn4myw5bS95PW7Ia3ulZpTeZ8gUhaqSnJ5vZMnnUHIfD2NIpZ+8PjNQXrNYAuSzYhrKcrojFpJ6iz+lHcJ3kXJMdu6m/hh7lFOpcOrUKSQmJsLFxQUxMTEYM2YMrK2txeOcExEREREREREREZUUJsqpVMjIyMCECRPw4MEDaGtro0GDBti0aROUZfj2cCIiIiIiIiIiIpINTJRTsbK2tkZhRvPx8vKCl5dXCUQErFu3rkTWS0RERERERERERPKBiXIiIiIiIiIiIiKikiavDw+QE/L5xCUiIiIiIiIiIiIiom/ERDkRERERERERERERlWlMlBMRERERERERERFRmcZEORERERERERERERGVaXyYJxEREREREREREVFJE7HPcmnG1iEiIiIiIiIiIiKiMo2JciIiIiIiIiIiIiIq05goJyIiIiIiIiIiIqIyjYlyIiIiIiIiIiIiIirT+DBPIiIiIiIiIiIiopImEkk7AvoC9ignIiIiIiIiIiIiojKNiXIiIiIiIiIiIiIiKtOYKCciIiIiIiIiIiKiMo1jlBMRERERERERERGVNBH7LJdmbB0iIiIiIiIiIiIiKtOYKCciIiIiIiIiIiKiMo2JciIiIiIiIiIiIiIq05goJyIiIiIiIiIiIqIyjQ/zJCIiIiIiIiIiIippIpG0I6AvYI9yIiIiIiIiIiIiIirT2KOcqBTKFqQdQck4N7WltEMoEa3n/yPtEErEnsFu0g6hRCjI6RV8HXX5/EmX1/aS164Kgpz+fsnrfpgtpw0mr/VSU1aUdgglQk6bCypKcnqgl1OCvO6IkM/fL7ltL/lsLiKZwl9vIiIiIiIiIiIiIirT5LP7GREREREREREREVFpImKf5dKMrUNEREREREREREREZRoT5URERERERERERERUpjFRTkRERERERERERERlGhPlRERERERERERERFSm8WGeRERERERERERERCWND/Ms1dg6RERERERERERERFSmMVFORERERERERERERGUaE+VEREREREREREREVKZxjHIiIiIiIiIiIiKikiYSSTsC+gL2KCciIiIiIiIiIiKiMo2JciIiIiIiIiIiIiIq05goJyIiIiIiIiIiIqIyjYlyIiIiIiIiIiIiIirT+DBPIiIiIiIiIiIiopImYp/l0oytQ0RERERERERERERlGhPlRERERERERERERFSmMVFORERERERERERERGUaE+VEREREREREREREVKbxYZ5EREREREREREREJU0kknYE9AXsUU5EREREREREREREZRoT5fRVIpEIe/bsKdI61q1bBz09vWKJR1p69OgBHx8faYdBRERERERERERExYxDr9BXxcTEQF9fX9phSF1wcDAEQZB2GMWibcsmiHnxIs/0H3/6BeN+nyyFiApn/65t2L9rO17F5NTFqqItfu3VD3Vd3QEAIwf2wo3wMIll2vj8iGFjJ333WD+np5sVmjgZw9pIA2mZ2bj+9D0WnLyPx6+TxWU61KyAllVM4GSqDS1VJXjMPIPEtEyJ9TiV18LQZnZwrqCNrGzgVFQs5hy7h5SMrO9dpc+Sh/bKz76/t2Hfrm0S9erWqz/qNXDHh/fvsX7lYoRdvoDYVzHQ09OHm0cT9Og3GFpa2lKO/MuuXb2CjevW4E5UJOLj4vDnvIXwbNJMPF8QBCxfshB7du1AYkICqlavgXG/+8PSylp6QRfC6pXLcfLEMTx6+ACqamqoVr0Ghg0fBWubitIOrchiX71C8LzZOH/2DFJTU2FhYYkp02agsrOLtEMrNHltL3mt1/atW7Bz2xa8ePEcAFDRzg59+w9CQ3cPKUdWNFlZWVixdBEOH9iP16/jYWRcDu28fdC77wCIZPh26mVLFmLF0sUS06ytbbBr/2EpRVQ85OW8Nz88zsumNatWYGHwXPzya3eMHjtB2uEUCdtLtsjr7zJRcWKinL6qfPny0g6hVNDV1ZV2CMVm4+adyMr+L4F6/96/GNi3F5q18JJiVAVnZGyC3gOHwczCEhAEHDu0D/5j/LB0/XZYV7QDALT27gjf3waJl1FVU5NWuPmqZaWH7WHPEPkiAYoKIgxuUhFLulZHx6UXkZqRDQBQU1bA+ftvcP7+GwxtaptnHUZaKljarQaORb7CzMN3oamqiFFe9gjwroQxO2997yp9ljy0V36Mypngt0HDYGZuBQECjh3ch8ljhmL5hh0QBAGv4+PQb8hIWNvY4tXLF5g38w/Ex8dhSuBcaYf+RSkpKXBwdMQPPh0wZsTQPPM3rF2FbVv+wpQ/AlHBzBzLFi/AkAG/YfvuA1BVVZVCxIVzNewyfurSFc5VXJCVmYWFwXMxoG9v7Np7EOoaGtIOr9A+vH+Pnt27oHadeli4dCX09Q3w5MkjaOvI9m+ZvLaXvNbLpLwJhgwfCUsrK0AQsH/vHgwfMghbd+6CrZ29tMMrtPVrVmHn9q0ImBaIirb2uB15C1MnT4CWljZ+7tpN2uEVia2dPZauXCN+r6go+/8uyst576d4nJdNkbdu4u+d22Dv4CjtUIoF20u2yOvvsswRcXCP0qzUtk52djZmzZoFOzs7qKqqwtLSEtOnTwcA3Lx5E02aNIG6ujoMDQ3Rt29fJCYmipfNHSJjxowZMDExgZ6eHqZOnYrMzEyMHj0aBgYGMDc3x9q1a8XLPHr0CCKRCFu3bkWDBg2gpqaGKlWqIDQ09Itxvn37Ft27d4e+vj40NDTQqlUr/Pvvv+L5jx8/Rrt27aCvrw9NTU04Ozvj0KFDn12ftbU1pk2bhu7du0NLSwtWVlbYt28f4uLi4O3tDS0tLVStWhVhYWGF+gxBEGBsbIydO3eKp1WvXh2mpqbi92fPnoWqqiqSk3N6tH489Erudtq1axcaN24MDQ0NVKtWDRcuXJD4nHXr1sHS0hIaGhpo3749Xr9+nSeWpUuXwtbWFioqKnB0dMTGjRvF80aNGoW2bduK38+fPx8ikQhHjhwRT7Ozs8OqVasAACEhIahbty40NTWhp6cHNzc3PH78ON9tkFuH7du3w93dHerq6qhTpw7u3r2LK1euoHbt2tDS0kKrVq0QFxcnXu7ToVd27twJFxcX8X7YrFkzJCUlieevWbMGzs7OUFVVhampKQYPHpxvPNKgb2AAIyNj8euf0BCYW1iiVu260g6tQFzdPVGvgTvMLaxgbmmNXv2HQl1dA1G3bojLqKqqwcDQSPzS1NSSYsR5Dd58Hfuvv8SDuCT8+yoR/nujYKqnhsqmOuIymy89w7pzj3Hz2ft81+HhYITMLAFBh+7i8etk3H6RgBkHo9GscjlY6Kt/r6p8lTy0V34auHuiXgMPmFtawcLSGr0HDIW6hgZu37oBG1t7TAmahwbunqhgboEateuhd/8huHg2BFmZmV9fuRS5NfTAgMHD0Lhp8zzzBEHAlk0b0Ou3/mjUuCnsHRwRMC0I8XGxCD11QgrRFt6S5avh7dMBdnb2cHRywtTpQYiJeYHbtyOlHVqRrFuzCiblTREwLRBVXKrCzNwcrg0awsLCUtqhFYm8tpe81quRZxO4ezSClZU1rKxtMNhvODQ0NHDj+nVph1YkN66Ho1HjJmjo4YkKZmZo1sIL9VzdEHnrprRDKzJFRUWJc0R5uKtUXs57P8XjvOxJTk7ChHGjMMn/D+jo6Hx9ARnA9pIt8vq7TFScSm2ifPz48QgKCsKkSZNw+/ZtbN68GSYmJkhKSoKXlxf09fVx5coV7NixAydOnMiThDx16hRevHiBM2fOYO7cufD390fbtm2hr6+PS5cuoX///ujXrx+ePXsmsdzo0aMxcuRIhIeHw9XVFe3atcs3yZurR48eCAsLw759+3DhwgUIgoDWrVsjIyMDADBo0CCkpaXhzJkzuHnzJmbOnAktrS8nfubNmwc3NzeEh4ejTZs26NatG7p3745ff/0V165dg62tLbp37y4eBqQgnyESieDh4YGQkBAAOYn+qKgopKSk4M6dOwCA0NBQ1KlTBxpfuAL8+++/Y9SoUYiIiICDgwO6dOmCzP8nfS5duoTevXtj8ODBiIiIQOPGjTFt2jSJ5Xfv3g0/Pz+MHDkSt27dQr9+/dCzZ0+cPn0aANCoUSOcPXsWWVlZ4piMjIzEcT9//hz379+Hp6cnMjMz4ePjg0aNGuHGjRu4cOEC+vbt+9VbX/39/TFx4kRcu3YNSkpK+OWXXzBmzBgEBwfjn3/+wb179zB5cv63Y8bExKBLly7o1asXoqKiEBISgg4dOojbZOnSpRg0aBD69u2LmzdvYt++fbCzs/tiPNKSkZGOQwf3wdung0zfLpyVlYXTxw8jNTUFlV2qiaefOnYIHVt64Leu7bF6STBSU1OkGOXXaavm9Nx6n5LxzcsoKyogIysbHw8MlPb/3ujVLUtnryJ5aa9PZWVl4dTxw0hNkazXxxITE6GhqQVFJdntpff8+TO8jo9H3Xqu4mla2tpwdqmKGzdk+0Q7MTEBgOzfRRQacgqVK1fBmBF+aNqoAbr82B67dm6XdljFTl7a61PyWK+srCwcOXQQKSnJqFq9urTDKZKq1WrgyqWLePzoIQDgbvQdXA+/hgYN3aUcWdE9efIYLZq4o13LZvh97CjExOQdskSWyct5L8DjvCwKnD4V7u6eqO/aQNqhlBi2l+yQp99louJUKv9LT0hIQHBwMBYtWgRfX18AgK2tLRo2bIiVK1ciNTUVGzZsgKamJgBg0aJFaNeuHWbOnAkTExMAgIGBARYsWAAFBQU4Ojpi1qxZSE5OxoQJOWNK5Sbiz549i59//ln82YMHD0bHjh0B5CQ7jxw5gtWrV2PMmDF54vz333+xb98+nDt3Dg0a5Bw8N23aBAsLC+zZswc//vgjnjx5go4dO8LFJWecuIoVvz5WV+vWrdGvXz8AwOTJk7F06VLUqVMHP/74IwBg7NixcHV1xatXr1C+fPkCf4anpyeWL18OADhz5gxq1KiB8uXLIyQkBE5OTggJCUGjRo2+uI5Ro0ahTZs2AICAgAA4Ozvj3r17cHJyQnBwMFq2bCneZg4ODjh//rxEb/DZs2ejR48eGDhwIABgxIgRuHjxImbPno3GjRvD3d0dCQkJCA8PR61atXDmzBmMHj1a3LM9JCQEZmZmsLOzw5s3b/D+/Xu0bdsWtrY5w1JUqlTpq9t51KhR8PLKueXSz88PXbp0wcmTJ+Hm5gYA6N27N9atW5fvsjExMcjMzESHDh1gZWUFAOLtDwDTpk3DyJEj4efnJ55Wp06dr8YkDadPnURiQgLaebeXdiiF8vDeXQzt2w3p6elQV9eAf9B8WNnk7AdNWrRGufKmMDIyxoP7/2LV4nl4+uQRpgTNk3LU+RMBGOVlj/An73A/Lumr5XNdefQWI1rYoburJTZfegp1FUUM+f8QLUZapWsIDHlqr489uHcXQ377VVyvgJnzYW2Td5ic9+/e4q+1y9HGu5MUoiw+r+PjAQCGhoYS0w0NjfA6Pi6/RWRCdnY2/gyageo1asLO3kHa4RTJ82dPsXP7FnTt3gO9fuuHyFs38WfQdCgrK8vs8f5T8tReH5O3ev17Nxq+XbsgPT0N6hoamBO8CLa2pbPzwLfq0fs3JCUlopN3GygoKiI7KwsDhwxDqzbtpB1akbi4VEPAH4GwsrZBfHwsVixdjN6+v2LH7n0ycYfXt5D1896P8TgvW44cPog7t2/jr607v15YRrG9ZIM8/i4TFadSmSiPiopCWloamjZtmu+8atWqiZPkAODm5obs7GxER0eLE+XOzs5QUPivw7yJiQmqVKkifq+oqAhDQ0PExsZKrN/V9b/ecUpKSqhduzaioqI+G6eSkhLq1asnnmZoaAhHR0fxMkOHDsWAAQNw7NgxNGvWDB07dkTVqlW/WP+P5+fW5+MkbO602NhYlC9f/ouf4ezsLB6CxN3dHYcPH0ajRo3g5+eHuLg4hIaGwtPTU5wo7927N86fP5/vhYHPxZg7bEtsbCycnJwQFRWF9u0lT85cXV0lEuVRUVHo27evRBk3NzcEBwcDAPT09FCtWjWEhIRARUUFKioq6Nu3L/z9/ZGYmIjQ0FBxMt/AwAA9evSAl5cXmjdvjmbNmqFz584Sw8kUdjt/un/kqlatGpo2bQoXFxd4eXmhRYsW6NSpE/T19REbG4sXL17ku//mJy0tDWlpaRLTMqDy3cb43bt7Jxq4ucO4nMl3+bziZm5lg2XrdyApKRH/nDqOP/+YiDlL1sDKxhZtfP5LRtrYOcDA0AhjhvyGF8+eooK5hRSjzt+41g6wLaeJXmuvFWi5B3FJ8N8bhREt7DC4aUVkZwNbLz9FfGIaskvZA2jlqb0+ZmFlgxUbdiIpKQFnTh3HzKkTMXfpWolkeVJSIiaMGAQr64rw/W2AFKOlzwmcFoB79/7Fug2bpR1KkWVnC6js7IwhfiMAAE6VKuP+vX+xc/tWuUmgyFN7fUze6mVtY4Otf+9GYkICThw7ism/j8OqdRtl+p/y40cP48jBA5gW9Cdsbe0RHR2FubMCYWxcDm29faQdXqG5ffQwNwdHR7i4VEMbryY4fvQIfDrI9gXeXLJ+3vsxHudlx8uXMfgzaAaWrlgjU89xKSi2l2yQx99louJUKodeUVcv+pi6ysrKEu9FIlG+07Kzs4v8WV/Sp08fPHjwAN26dcPNmzdRu3ZtLFy48IvLfBxn7i2B+U3Ljf1Ln3Ho0CFEREQgIiJCPJ63i4sLDAwMEBoaKk6Ue3p6IjQ0FFeuXEFGRoa4h3xBYizubenp6YmQkBBxUtzAwACVKlXC2bNnJRLlALB27VpcuHABDRo0wLZt2+Dg4ICLFy8WuA6fTvtcnRQVFXH8+HEcPnwYlStXxsKFC+Ho6IiHDx8WeP8NDAyErq6uxGvOrMACraOwYl48x+WLF+DT8cfv8nklQVlZGWYWlnBwqozeA/1Q0c4Bu7dtyresk3POhZDnz558zxC/ydiWDnC3N0LfDeGITUj7+gKfOHLrFVrMPYeW886h8Z//YFnoQ+hrqOD529I1dIm8tNen/quXM/oMHAZbOwfs2vaXeH5yUhLGDesPDQ0NTJ0ZDCUl5S+srfQzNDICgDxDk71+HQ9DI2NphFRkgdOn4kxoCFatWQ8TOXiItZGxMSp+8g+PTUVbvHwZI6WIipe8tVcueayXsrIKLC2tUNm5CoYOHwkHRyds+WuDtMMqkgVzZ8O3dx94tWoDOwcHtGnnjS7dfLF29Qpph1astHV0YGlljadP8n/uj6yRh/Pej/E4LzuiIiPx5s1r/PJTB9Su7oza1Z1xNewKtmzaiNrVncXDjcoytpfskMffZZkjEpWNl4wqlYlye3t7qKur4+TJk3nmVapUCdevX5d4aOK5c+fEQ6wU1cfJ1czMTFy9evWzw3hUqlQJmZmZuHTpknja69evER0djcqVK4unWVhYoH///ti1axdGjhyJlStXFjnOT33uM6ysrGBnZwc7OzuYmZkByEkAu7u7Y+/evYiMjETDhg1RtWpVpKWlYfny5ahdu7ZEj/2CqlSpksQ2AZAnaV2pUiWcO3dOYtq5c+cktlvuOOUnT56Ep6cngJzk+ZYtW3D37l3xtFw1atTA+PHjcf78eVSpUgWbN5fslWyRSAQ3NzcEBAQgPDwcKioq2L17N7S1tWFtbZ3v/puf8ePH4/379xKvkWPGl2jsufbt2QV9A0M0dP/yUDuyRBCykZ6Rnu+8+3ejAaDUJfLGtnRAYydj9NsYjhfvUou0rjdJGUjJyIKXswnSM7Nx8cHbYoqyZMhie32LbEFARnpOvZKSEjHGry+UlZTxx+yFUJGDnilmZuYwNDLClUv/HdsTExMRefMGqlbNf2z20koQBAROn4pTJ49jxZr1MCvldy98q+rVa+DR/8dPzvX40SOYmlaQUkTFQ17bS17rlR8hOxvp6fkf92VFamoKFESS/0YpKihCEEq2A873lpychGdPn8LIWPZ+h/Mjb+e9PM7Ljrr162PHrn3YumO3+FXZuQpat2mHrTt2Q1FRUdohFhrbS/bJw+8yUXEqlUOvqKmpYezYsRgzZgxUVFTg5uaGuLg4REZGomvXrvD394evry+mTJmCuLg4DBkyBN26dRMPn1EUixcvhr29PSpVqoR58+bh7du36NWrl3i+k5MTAgMD0b59e9jb28Pb2xu//fYbli9fDm1tbYwbNw5mZmbw9vYGAAwbNgytWrWCg4MD3r59i9OnT0sk3j9eX2F97TPy4+npiZEjR6J27driB396eHhg06ZNGD16dKFjAXKGm3Fzc8Ps2bPh7e2No0ePSgy7AuQ8NLVz586oUaMGmjVrhv3792PXrl04ceKEuIyHhwcSEhJw4MABBAUFiePu1KkTTE1N4eCQM+7Zw4cPsWLFCvzwww+oUKECoqOj8e+//6J79+4AgMuXL6N79+44efKk+GJBUV26dAknT55EixYtUK5cOVy6dAlxcXHi7T5lyhT0798f5cqVQ6tWrZCQkIBz585hyJAhedalqqqa55auxLSSHy4jOzsb+/buRtsffKAkow8VXL0kGHVc3VCuvClSkpJw6thhXL8WhsD5y/Di2VOcOnYIdRu4Q0dXFw/u3cWy4D/hUr0WKtqVnjHzxrVyQCsXEwzfdhPJaVkw1FQBACSmZSItM+cfbkNNFRhqqcDCIOduBXsTTSSlZeHl+1R8SM15iO5Pdcxw/el7JKdnoX5FA/g1t8PCk/eRmJYpnYrlQx7aKz+rlsxHXdeGKGdiiuTkJJw6dgjXr11B0PxlSEpKxNih/ZCamoIJU4KQnJSE5P9f6NXV0y/VJ9rJyUl4+uS/3vwvnj9D9J0o6OrqorxpBXTp2h1rVi6DhZUVzMzMsWzxAhgZl0OjJs2kGHXBzZgWgMOHDmD+giXQ1NRE/P/HWNfS0oaampqUoyu8rt17oGe3Lli9chmae7VC5M0b2PX3dkycPFXaoRWJvLaXvNZrwbw5cHP3gKmpKZKSknD44AGEXbmMJctXSTu0InFv1BhrVi5HeVNTVLS1R/Sd29i0cR1+8Okg7dCKZN7smfBo1BimFSogLi4WyxYvgoKiAlq2aivt0IpMHs57P8XjvOzQ1NTKM2a3uro6dPX0ZH4sb7aXbJHX32Wi4lRqzxImTZoEJSUlTJ48GS9evICpqSn698+5bf3o0aPw8/NDnTp1oKGhgY4dO2Lu3LnF8rlBQUEICgpCREQE7OzssG/fPhj9/xZzAIiOjsb79+/F79euXQs/Pz+0bdsW6enp8PDwwKFDh8RDeGRlZWHQoEF49uwZdHR00LJlS8ybN++z6yuMr31Gfho1aoSsrCyJXtmenp7Yu3dvnp7aBVW/fn2sXLkS/v7+mDx5Mpo1a4aJEyfijz/+EJfx8fFBcHAwZs+eDT8/P9jY2GDt2rUSn62vrw8XFxe8evUKTk5OAHKS59nZ2RLDrmhoaODOnTtYv349Xr9+DVNTUwwaNEj8QNTk5GRER0cjIyOjSPX6mI6ODs6cOYP58+fjw4cPsLKywpw5c9CqVSsAgK+vL1JTUzFv3jyMGjUKRkZG6NSpdI3teOniebyMeQFvGf6n7t3bN5g1dSLevI6DppYWbGwdEDh/GWrVdUXsq5e4duUidm37C6mpKTAuVx7uns3wS8++X1/xd9S5jjkAYJVvTYnp/ntvY//1lwCATrXN0K+RjXje6h618pRxrqCDfo0qQkNFEY/ikzDjQDQO3nz5ParwzeShvfLz9u0bBAX8/v96aaOirT2C5i9D7XoNEHH1CqIibwAAunVqLbHcpl1HUL5C8Vy8KwlRkZHo38dX/H7e7JkAgDY/+GDKH4Ho3rMPUlJSMGOqPxITPqBajZpYsGSFzI3luGPbFgBAn57dJKYHTAuU6eOjcxUXzJ6/EIvmz8XKZUtQwcwco8aMR+u2sv2wQXltL3mt15s3bzBpwljEx8VBS1sb9g6OWLJ8Feo3cJN2aEUyevxELFsUjKDpU/H2zRsYGZdDh06d8Vv/gdIOrUhevXqF8WNH4v27d9DXN0D1mrWwftM26BsYSDu0IpOH895P8ThPpQHbS7bI6+8yUXESCUIpe9KblDx69Ag2NjYIDw9H9erVpR0OlXHfo0e5NLxJks9bunwWnft6IRm0Z7B8njApyPB4aV+io15qr30XibJiqRwlrshK24N2i4u8fr/klQD53A+zsuWzXvL6/ZLTw6EsD8/6RfK7H8rnjihie8kW+WwuaCjLacUKSaPjGmmH8F0k/93r64VKIfn875OIiIiIiIiIiIiI6BsxUU5EREREREREREREZZp83qddCNbW1vJ7+w4RERERERERERERfRZ7lBMRERERERERERFRmcYe5UREREREREREREQlTF4fsisv2KOciIiIiIiIiIiIiMo0JsqJiIiIiIiIiIiIqExjopyIiIiIiIiIiIiIyjSOUU5ERERERERERERU0jhEeanGHuVEREREREREREREVKYxUU5EREREREREREREZRoT5URERERERERERERUpjFRTkRERERERERERERlGh/mSURERERERERERFTCRCI+zbM0Y49yIiIiIiIiIiIiIirTmCgnIiIiIiIiIiIiojKNiXIiIiIiIiIiIiIiKtOYKCciIiIiIiIiIiKiMo0P8yQiIiIiIiIiIiIqYXyYZ+nGHuVEREREREREREREVKYxUU5EREREREREREREZRoT5URERERERERERERUpnGMciIiIiIiIiIiIqISxjHKSzf2KCciIiIiIiIiIiKiMo09yolKISVF+bzCqKGiKO0QSsT+oQ2lHUKJ6LjsgrRDKBFrfWtLO4QSoa+pLO0QSkRKepa0QygRKkry2VdBJJ/VklsiyOf5hiCf1cLrxHRph1AijLVVpR1CiWCHQdkirz08BUHaEZQMeW0vOa0WkUzhvzNEREREREREREREVKYxUU5EREREREREREREZRqHXiEiIiIiIiIiIiIqYfI6dJC8YI9yIiIiIiIiIiIiIirTmCgnIiIiIiIiIiIiojKNiXIiIiIiIiIiIiIiKtM4RjkRERERERERERFRSeMQ5aUae5QTERERERERERERUZnGRDkRERERERERERERlWlMlBMRERERERERERFRmcZEORERERERERERERGVaXyYJxEREREREREREVEJE4n4NM/SjD3KiYiIiIiIiIiIiKhMY6KciIiIiIiIiIiIiMo0JsqJiIiIiIiIiIiIqEzjGOVEREREREREREREJYxjlJdu7FFORERERERERERERGUaE+VEREREREREREREVKYxUU5EREREREREREREZRoT5URERERERERERERUpvFhnkREREREREREREQljA/zLN3Yo7yUE4lE2LNnDwDg0aNHEIlEiIiIkGpMhTVlyhRUr179u31ejx494OPj890+j4iIiIiIiIiIiGQTe5SXcjExMdDX15d2GCSntm7ehPVrVyM+Pg4Ojk4YN2ESXKpWlXZY3yziWhg2b1iDO1G38To+DoGzF8CjcVPx/Dev47FkwVxcvngeiQkJqF6zFoaP+R0WllZSjPrr9v69Dft3bcPLFy8AANYVbdGtd3/Ua+AOAEhPS8PS4D9x+vgRpGeko049N/iN+R0GhkbSDFtC9/oW8HQ0gpWBBtIys3Hz+QcsDnmAJ29SxGW8q5nCy7kcHE20oKmqhGbzziIxLUtiPT1cLdHA1gAOJlrIyBLQfP65712Vr9qydhm2rV8hMc3MwhqLN+4CACyZMw3Xr17G2/g4qKmrw6lKNXTvOxTmVjbSCLfQli1ZiBVLF0tMs7a2wa79h6UUUeGEXw3Dpg1rEB0Vifj4OATNWYBGjZuJ57vWrJzvcoP8RuJX397fK8wia9uyCWL+fwz52I8//YJxv0+WQkTFS9Z/vz51NewK1q1ZjajbtxAXF4d5CxajSdNmX19QRshbewFA7KtXCJ43G+fPnkFqaiosLCwxZdoMVHZ2kXZo32T/rm3Yv2s7XsXkHCesKtri1179UNc151xj5MBeuBEeJrFMG58fMWzspO8ea1GtXrkcJ08cw6OHD6CqpoZq1Wtg2PBRsLapKO3QioTHDdkir+0lr98vea1XLnn7fhEVJ/YoL+XKly8PVVVVaYdRqmVkZEg7BABAenq6tEMokCOHD2H2rED0GzgIW3fshqOjEwb0643Xr19LO7RvlpKSAjsHR4wcOzHPPEEQMG7kULx4/gwz5y7E2s07Ud60AvwG9EZKSrIUov12xuVM0GfgMCxbvw1L129Fjdr1MGn0UDx8cA8AsHj+LFw4G4rJgXMwf+lavI6Phf+44VKOWlINSz38fe0F+mwMx9BtN6CkIELwT1Whpvzfz46asgIuPHiDdReefHY9SooinIqOw67wvAm/0sTS2hZr/z4mfgUuXC2eZ+tQCUPH+mPh+r/h/+diCIKAKaMHISsr6wtrLJ1s7exx7PQ/4tfqDZulHVKBpaYmw97BESPH5Z/sOXAsVOL1u/80iEQiNG7a4jtHWjQbN+/E0VP/iF9LVqwBADRr4SXlyIpOHn6/PpWSkgxHR0eMn+gv7VCKnTy214f379GzexcoKSlh4dKV2LnnIIaPHgttHV1ph/bNjIxN0HvgMCxetxWL125B9Vp14T/GD4/+f64BAK29O2LbgVPi12+DS9e5xre6GnYZP3Xpig2bt2PZirXIzMjEgL69kZJcus8Hv4bHDdkir+0lr98vea0XIJ/fL6LiVKoS5dnZ2Zg1axbs7OygqqoKS0tLTJ8+HQBw8+ZNNGnSBOrq6jA0NETfvn2RmJgoXjZ3mI0ZM2bAxMQEenp6mDp1KjIzMzF69GgYGBjA3Nwca9euFS+TO5TJ1q1b0aBBA6ipqaFKlSoIDQ39YpxLliyBvb091NTUYGJigk6dOgEANmzYAENDQ6SlpUmU9/HxQbdu3QAA169fR+PGjaGtrQ0dHR3UqlULYWFheT4j18dDr+S6c+fOZ+MNCQmBSCTC0aNHUaNGDairq6NJkyaIjY3F4cOHUalSJejo6OCXX35B8hcO8uvWrYOenh727NkjrquXlxeePn0qUW7//v2oU6cO1NTUYGRkhPbt239x2wHAxo0bYW1tDV1dXfz8889ISEgQzzty5AgaNmwIPT09GBoaom3btrh//754fm6bbdu2DY0aNYKamho2bdqErKwsjBgxQrzcmDFjIAiCeLkDBw5AT09PnJiKiIiASCTCuHHjxGX69OmDX3/9FQDw+vVrdOnSBWZmZtDQ0ICLiwu2bNkiUQ9PT08MHjwYw4YNg5GREby8cpIPt27dQqtWraClpQUTExN069YN8fHxX90u39vG9WvRoVNn+LTvCFs7O0z0D4Camhr27Ppb2qF9M1c3d/Qd6IdGTfL2xnj65DEib17HqPGTUcnZBVbWNhg1fjLS0tJw/MghKUT77Rq4e6K+mwfMLa1gYWmN3gOGQl1DA1G3biAxMQGH9+3CAL/RqFm7HhwqOWPMpD8QeSMCt29el3boYsO338TBm6/wMD4Z92KT8MfBaJjqqsGpvLa4zLaw59h48SkiX3z47HpWnX2MrVee435c0vcIu9AUFBWhb2gkfuno/XcnkFe7jnCuVgsmphVg61AJXXsPRHzsS8S+LN3J//woKirCyMhY/JLFO55c3TzQb5AfPPM5bgCAoZGxxOuf0FOoWbsuzMwtvnOkRaNvYCDRVv+EhsDcwhK1ateVdmhFJg+/X59q6N4Ig/2Go2mz5tIOpdjJY3utW7MKJuVNETAtEFVcqsLM3ByuDRrCwsJS2qF9M1d3T9Rr4A5zCyuYW1qjV/+hUFfPOdfIpaqqBgNDI/FLU1NLihEX3pLlq+Ht0wF2dvZwdHLC1OlBiIl5gdu3I6UdWpHwuCFb5LW95PX7Ja/1AuTz+0VUnEpVonz8+PEICgrCpEmTcPv2bWzevBkmJiZISkqCl5cX9PX1ceXKFezYsQMnTpzA4MGDJZY/deoUXrx4gTNnzmDu3Lnw9/dH27Ztoa+vj0uXLqF///7o168fnj17JrHc6NGjMXLkSISHh8PV1RXt2rX77NW0sLAwDB06FFOnTkV0dDSOHDkCDw8PAMCPP/6IrKws7Nu3T1w+NjYWBw8eRK9evQAAXbt2hbm5Oa5cuYKrV69i3LhxUFZWLtB2+pZ4p0yZgkWLFuH8+fN4+vQpOnfujPnz52Pz5s04ePAgjh07hoULF37xc5KTkzF9+nRs2LAB586dw7t37/Dzzz+L5x88eBDt27dH69atER4ejpMnT6Ju3S//A37//n3s2bMHBw4cwIEDBxAaGoqgoCDx/KSkJIwYMQJhYWE4efIkFBQU0L59e2RnZ0usZ9y4cfDz80NUVBS8vLwwZ84crFu3DmvWrMHZs2fx5s0b7N69W1ze3d0dCQkJCA8PBwCEhobCyMgIISEh4jKhoaHw9PQEAKSmpqJWrVo4ePAgbt26hb59+6Jbt264fPmyRBzr16+HiooKzp07h2XLluHdu3do0qQJatSogbCwMBw5cgSvXr1C586dv7hdvreM9HRE3Y5EfdcG4mkKCgqoX78BblwPl2JkxSfj/z38VVRUxNMUFBSgoqKCGxHXpBVWgWVlZeHUscNITUlB5SrVcPfObWRmZqJW3friMpbWFVGuvCkib5WeRPmntFQVAQAfUkrHHSDFLeb5E/Ts2AL9urTD3Gm/I+5VTL7lUlNScPLwPpiYmsGoXPnvHGXRPXnyGC2auKNdy2b4fewoxMTIXrK/IN68jse5s2fQzqejtEMpkoyMdBw6uA/ePh1k/uFBZeH3S57Ia3uFhpxC5cpVMGaEH5o2aoAuP7bHrp3bpR1WoWVlZeH08cNITU1BZZdq4umnjh1Cx5Ye+K1re6xeEozU1JQvrEV2JCbmdNLR1ZWdOwDKEnk9bpQV8vr9kpd68ftVOohEojLxklWlZozyhIQEBAcHY9GiRfD19QUA2NraomHDhli5ciVSU1OxYcMGaGpqAgAWLVqEdu3aYebMmTAxMQEAGBgYYMGCBVBQUICjoyNmzZqF5ORkTJgwAcB/ifizZ89KJHwHDx6Mjh1z/gleunQpjhw5gtWrV2PMmDF54nzy5Ak0NTXRtm1baGtrw8rKCjVq1AAAqKur45dffsHatWvx448/AgD++usvWFpaihOwT548wejRo+Hk5AQAsLe3L/C2+pZ4p02bBjc3NwBA7969MX78eNy/fx8VK+aMqdWpUyecPn0aY8eO/eznZGRkYNGiRahXrx6AnKRwpUqVcPnyZdStWxfTp0/Hzz//jICAAPEy1apV+9zqAOTcNbBu3Tpoa+f0Ku3WrRtOnjwpvnMgt1651qxZA2NjY9y+fRtVqlQRTx82bBg6dOggfj9//nyMHz9ePG3ZsmU4evSoeL6uri6qV6+OkJAQ1K5dGyEhIRg+fDgCAgKQmJiI9+/f4969e2jUqBEAwMzMDKNGjRIvP2TIEBw9ehTbt2+XuBhgb2+PWbNmid9PmzYNNWrUwIwZMyTqYGFhgbt378LBweGL2+d7efvuLbKysmBoaCgx3dDQEA8fPpBSVMXLytoGJuVNsXzRfIz+3R/q6urYtmkDYl+9xOv4OGmH91UP7t3F4D6/Ij09HerqGgiYOR/WFW1x/987UFZWhpa2jkR5fQNDvH1d+u5cAAARgGHN7HD96Xs8iJf92xU/5VDZBUPHBcDMwgpvX8dj6/oVmDC0Nxas3QF1jZzfrEN7tmPDspwkg5mFNabMXlLgi6TS5uJSDQF/BMLK2gbx8bFYsXQxevv+ih2798lsL8OvObR/LzQ0NODZRLZ7f50+dRKJCQlo5/31u75Ku7Lw+yVP5LW9nj97ip3bt6Br9x7o9Vs/RN66iT+DpkNZWVmmvmcP793F0L7dxOca/kHzYWVjCwBo0qI1ypU3hZGRMR7c/xerFs/D0yePMCVonpSjLprs7Gz8GTQD1WvUhJ196TgvJ0nyetwoC+T1+yVP9eL3i+jrSk2P8qioKKSlpaFp06b5zqtWrZo4SQ4Abm5uyM7ORnR0tHias7MzFBT+q5KJiQlcXP57oI6ioiIMDQ0RGxsrsX5XV1fx30pKSqhduzaioqLyjbN58+awsrJCxYoV0a1bN2zatEliCJPffvsNx44dw/PnzwHkDGHSo0cP8dWUESNGoE+fPmjWrBmCgoIkhhX5Vt8Sb9WPHsRgYmICDQ0NcZI8d9qn2+FTSkpKqFOnjvi9k5MT/sfefUdFcbVhAH+W3ougiIqAUqVp7A2IvcaefNHYNTbsBVGxK9gVsWLvxpYYewWjUWMvgNjFggqIKL3sfn8QVzdgpQw7+/zO2XPY2dnZ9zI7d2bfvfteExMT+WtdvXo1z/31KTY2NvIkOQBYWloqxHHnzh38/PPPqFChAoyMjGBjYwMg5wuGD1WrVk3+d2JiImJiYuQJ/Xexf7gOAHh5eSE0NBQymQx//fUX2rdvD2dnZ5w+fRphYWEoU6aM/IuL7OxsTJs2DW5ubihRogQMDAxw+PDhXHFUrVpV4f61a9dw8uRJGBgYyG/vvhT52L5OT0/HmzdvFG7/Ld9DX09DUxMz5y5CdPRDNP++DhrWrYbLF/9Brbr1FfqJ4srK2hYhG3di6erN+KH9j5g1dQIe3v/6/qI4GN3EHhVL6mPC3gihQykUVWvWRV3vxrCp6IAqNerAP3AxkpOScPrkUfk6Xo2aY/6qrZixKARlrMpjzhRfZCjZcV63vicaN20GB0dH1KlbH4uXrkTS2zc4eviQ0KEVmj/37kbT5q2Ufq6QP/bsRJ269VGylIXQoRCJglQqg5NzJQweOgJOzpXQodNPaNehE3b+tk3o0L5KOWtbLF+/A4tXbUbrdj9izrQJePQg51qjZduOqF6rLmztHNCwaUuMmTgDZ8KO49mTx5/ZavEWMH0K7t69g1lzlDvhT1QcifX4Emu7iChvxSZbpKurm+9t/Hd0nkQiyXPZf8t4fA1DQ0NcvnwZW7duhaWlJSZOnAgPDw+8fv0aAFClShV4eHhgw4YNuHTpEsLDw9GjRw/58ydPnozw8HC0bNkSJ06cQKVKlRRKhBSUD9tdGP8H4Nv22efiaN26NV69eoWQkBCcP38e58+fB5B7oswPvzT5Ut7e3jh9+jSuXbsGTU1NODk5wdvbG6GhoQgLC5OPJgeAOXPmYNGiRfD19cXJkydx9epVNG3a9LNxJCUloXXr1rh69arC7c6dO/ISPf8VEBAAY2NjhducWQFf3b6vYWpiCnV19Vwle+Lj42Fubl6or12UnJxdsH7rbhwOPYc/DodifvBKvHn9GmXKlhM6tM/S1NREWavycHB2Qd9Bw1DR3gG7t2+CqZk5MjMzkfRWsa53wqt4mJoVv303srEd6tqVwMAt1xD7VrkmvP1WBoaGKFOuPJ4/fZ9M0DfIWebiURVjpszB0+iHOHf6pIBR5p+hkRHKW9vgcfQjoUMpFFcvX0T0wwf4oV1HoUPJl5hnT/HPubNo26GT0KEUCFU5f4mFWPeXecmSqFDRTmGZbYWKeP4877JbxZX8WsOpEnoPHIoKdg7Ys31znus6ueQMPnr65OMTcBd3ATOm4lRYKFatWQ+L0spX/kxViLXfEDuxHl9iaxePL6LPKzaJcnt7e+jq6uL48eO5HnN2dsa1a9eQnPx+MrczZ87IS6zk17lz5+R/Z2Vl4dKlS3B2dv7o+hoaGmjUqBFmz56N69ev4+HDhzhx4oT88T59+mDdunVYu3YtGjVqBCsrxQnAHBwcMHz4cBw5cgTt27dXmGC0MOL9VllZWQoTjUZFReH169fy13J3d89zf32r+Ph4REVFYcKECWjYsCGcnZ2RkJDw2ecZGxvD0tJSnlR/F/ulS5cU1ntXp3zBggXypPi7RHloaKi8PA6Q8/5q06YNfvnlF3h4eKBChQq4ffv2Z2P57rvvEB4eDhsbG9jZ2SncPpbc9/PzQ2JiosJttK/fZ18rPzS1tOBcyQXnz52VL5NKpTh//izcPaoU6msLwcDQEKamJfA4+hFuRYajnlcDoUP6alKpDJmZGXBwqgQNDQ1cvvD+/R796AFePo+Bi+unSx8VtZGN7eDlYA6frdcRk5gmdDhFJjUlBc+fPfn4FxcyGWSy93X0lVVKSjKePH4M85IlhQ6lUPz5x244ObvA3sFJ6FDyZe/vu2Fawgz16nt9fmUloGrnL2Un1v1VuXIVPHz4QGHZo4cPYWlZRqCICoZMJkVGZt7npnu3c37Fa2aufH2+TCZDwIypOHH8KFauWa90kzOrGrH2G2Il1uNLrO3i8VVMSFTkpqSKTY1yHR0d+Pr6YsyYMdDS0kLdunURGxuL8PBwdOnSBZMmTUL37t0xefJkxMbGYvDgwejatau8Pnl+LFmyBPb29nB2dsaCBQuQkJAgn3wTyCk5EhAQgHbt2mHfvn24f/8+PD09YWpqigMHDkAqlSok7Dt37oxRo0YhJCQEGzZskC9PTU3F6NGj0bFjR9ja2uLJkye4cOGCvC7306dP0bBhQ2zYsOGTk2J+Lt5vERwcjD179igkvjU1NTF48GAEBQVBQ0MDPj4+qFWrljy2SZMmoWHDhqhYsSL+97//ISsrCwcOHJDXPffz88PTp08V/gefYmpqCjMzM6xcuRKWlpaIjo7G2LFjv+i5Q4cORWBgIOzt7eHk5IT58+fLR/l/uH13d3ds3rwZwcHBAABPT0/8+OOPyMzMVBhRbm9vj507d+Lvv/+Gqakp5s+fjxcvXqBSpUqfjGPQoEEICQnBzz//jDFjxqBEiRK4e/cutm3bhlWrVkFdXT3Xc7S1tXP9rD8t64uanS9du/eE/zhfuLi4wtXNHZs2rkdqairatmv/+ScXEzmJuvcjm549e4LbUZEwMjJGacsyOHH0MExMTWFR2hL3797BwrkBqO/dADVr1xUw6s8LWbIQNerUg4WFJVJSknH88AFcu3wBsxYth4GBIZr/0B5LF82BoZEx9PX1ETQvAJXcPBQm4BLa6CZ2aFLJAmN23URyRhZK6Of8miQ5PRvpWTm/IimhrwkzfS2UM8n5dUrFkgZIycjCizfpePPvQWBhpA0jHQ1YGOlATQLYl8r5wulJQipSM/P3q5iCsnbpAlSv44mSFpZIiI/F1rXLoaamhvoNm+H5syc4ffIIKlerBWMTU8THvsSuLWuhra2NqrXqCR36V1kwdxY8vb6HZZkyiI19ieVLgqGmroZmzVsJHdpXydVvPH2q0G8AQHJSEk4cPYzBI0YLFWaBkEql2PvHHrT6oS00NIrNJV++ieH89V8pyckK5d2ePnmCW5GROYMByih38lWM+6tLtx7o2fVnrA5ZjsZNmyP8xnXs3vUbJkycKnRoX2z10kWoXrsuSpW2RGpyMk4cOYhrly8iYOFyPHvyGCeOHECNOvVhZGyM+3dvY/miOXCrXBUV7JSvPu/M6VNw8MA+LAxaCn19fcT9O1eNgYEhdHR0BI7u27HfUC5i3V9iPb7E2i5AnMcXUUEqVp+a/P39oaGhgYkTJ+LZs2ewtLRE//79oaenh8OHD2Po0KGoXr069PT00KFDB8yfP79AXjcwMBCBgYG4evUq7OzssHfvXoWfnURFRSExMREAYGJigt27d2Py5MlIS0uDvb09tm7dChcXF/n6xsbG6NChA/bv34+2bdvKl7/7iUu3bt3w4sULmJubo3379vLJMDMzMxEVFaVQ8/xb4v0WcXFxuWpo6+npwdfXF507d8bTp09Rv359rF69Wv64t7c3duzYgWnTpiEwMBBGRkYK5UViYmJy1fT+FDU1NWzbtg1DhgyBq6srHB0dERQUpDDS+2NGjhyJmJgYdO/eHWpqaujVqxfatWsn32/veHl54erVq/JtlihRApUqVcKLFy8UvuyYMGEC7t+/j6ZNm0JPTw+//vor2rZtm2t7/1WmTBmcOXMGvr6+aNKkCdLT02FtbY1mzZoVu7rYzZq3QMKrV1gaHIS4uFg4Ojlj6YpVMFOin1zdigjH4H495fcXz8+ZWLV5qzaYMGUm4uNisXjBbLyKj4OZeUk0a/kDevbtL1S4X+x1wisEThmPV3Gx0DcwRAU7e8xatBzVaubMTj5o2BioSSSY7DccmRmZqFarDoaNmSBw1Io6fFcWALCsS2WF5dP238L+Gy8AAO2rlEGfejbyx1b8UjnXOr/Wt0FLt/c/c9zYK2fugYFbruJy9KePx6ISH/sC86b54e2bRBgbm8LZrTJmLV0PYxNTZGdlIeL6Ffy5cwuS376BsakZXDy+Q2DwWpiYlhA69K/y4sUL+PmOROLr1zA1LYHK31XF+s3bYVpCudpxKyIcg37tIb8fNH8WAKBF67bwn5IzEfPRwwcggwxNmrYUIsQCc/7c33ge8wxt2orrg48Yzl//FR5+E316dpPfnzs7pwTbD23aYdrMQKHCKhBi3F8urm6Yu3AxghfOR8jypShTthxGjfFDi1athQ7ti71OeIXZUyfgVXws9A0MYFvRAQELl6Nqjdp4+eI5Ll84h93bNyEtLRUlS5VGfe9G6NzzV6HD/iY7tm8FAPTp2VVh+ZTpAUrdP7LfUC5i3V9iPb7E2i5AnMcXUUGSyGQymdBBCOXhw4ewtbXFlStXULly5QLddsOGDeHi4oKgoKAC3W5RWbduHYYNG5ZrVDYVjaIYUS6EJJE27N0IabHpsPzs51dSQmu7V/v8SkqovJme0CEUivRi8suBgqalUby+PC0oGupK/DtLEo1sqTg/3sQnKXfJro8paajcEyZ/jITdIRUDqpvtUU5i7Td0itUQXeGZdd8qdAhFIn79z0KH8E34di1gCQkJ8prXS5cuFTocIiIiIiIiIiIiIvoMJsoLWJUqVZCQkIBZs2YVyESjREREREREREREpPwkYv3pgEiodKLcxsYGBV155uHDhwW6PaH06NEDPXr0EDoMIiIiIiIiIiIiokInzgKZRERERERERERERERfiIlyIiIiIiIiIiIiIlJpKl16hYiIiIiIiIiIiKgosEZ58cYR5URERERERERERESk0pgoJyIiIiIiIiIiIiKVxkQ5EREREREREREREak0JsqJiIiIiIiIiIiISKVxMk8iIiIiIiIiIiKiQsbJPIs3jignIiIiIiIiIiIiIpXGRDkRERERERERERERqTQmyomIiIiIiIiIiIhIpTFRTkREREREREREREQqjZN5EhERERERERERERU2zuVZrHFEORERERERERERERGpNCbKiYiIiIiIiIiIiEilMVFORERERERERERERCqNNcqJiIiIiIiIiIiICplEwiLlxRlHlBMRERERERERERGRSmOinIiIiIiIiIiIiIhUGhPlRERERERERERERKTSmCgnIiIiIiIiIiIiIpXGyTyJiIiIiIiIiIiIChkn8yzemCgnoiKjpSHOH7FoqouzXZt71xA6hELxw8K/hA6hUPwzqbHQIRQKDXVxXkimZ2ULHUKh0FDnpaUykcpkQodAX0FDTZz9YZZUKnQIhUJDTZzXh2Ilgzj7QzWRJuSkUnHuLyZQiYTHszcRERERERERERERqTQmyomIiIiIiIiIiIhIpfH3sURERERERERERESFjCV2ijeOKCciIiIiIiIiIiIilcZEORERERERERERERGpNCbKiYiIiIiIiIiIiEilMVFORERERERERERERCqNiXIiIiIiIiIiIiKiQiaRSFTi9jUCAgJQvXp1GBoaolSpUmjbti2ioqIU1vH29s71Gv3791dYJzo6Gi1btoSenh5KlSqF0aNHIysr66ti0fiqtYmIiIiIiIiIiIiICkBYWBgGDRqE6tWrIysrC+PGjUOTJk0QEREBfX19+Xp9+/bF1KlT5ff19PTkf2dnZ6Nly5YoXbo0/v77b8TExKBbt27Q1NTEzJkzvzgWJsqJiIiIiIiIiIiIqMgdOnRI4f66detQqlQpXLp0CZ6envLlenp6KF26dJ7bOHLkCCIiInDs2DFYWFigcuXKmDZtGnx9fTF58mRoaWl9USwsvUJEREREREREREREgktMTAQAlChRQmH55s2bYW5uDldXV/j5+SElJUX+2NmzZ+Hm5gYLCwv5sqZNm+LNmzcIDw//4tfmiHIiIiIiIiIiIiKiwvZ15buVVnp6OtLT0xWWaWtrQ1tb+5PPk0qlGDZsGOrWrQtXV1f58s6dO8Pa2hplypTB9evX4evri6ioKOzevRsA8Pz5c4UkOQD5/efPn39x3EyUExEREREREREREVGBCAgIwJQpUxSWTZo0CZMnT/7k8wYNGoSbN2/i9OnTCst//fVX+d9ubm6wtLREw4YNce/ePVSsWLHA4mbpFSIiIiIiIiIiIiIqEH5+fkhMTFS4+fn5ffI5Pj4+2LdvH06ePIly5cp9ct2aNWsCAO7evQsAKF26NF68eKGwzrv7H6trnhcmyomIiIiIiIiIiIioQGhra8PIyEjh9rGyKzKZDD4+PtizZw9OnDgBW1vbz27/6tWrAABLS0sAQO3atXHjxg28fPlSvs7Ro0dhZGSESpUqfXHcLL1CREREREREREREREVu0KBB2LJlC/744w8YGhrKa4obGxtDV1cX9+7dw5YtW9CiRQuYmZnh+vXrGD58ODw9PeHu7g4AaNKkCSpVqoSuXbti9uzZeP78OSZMmIBBgwZ9ti76h5goJyIiIiIiIiIiIipkEomKzOb5FZYtWwYA8Pb2Vli+du1a9OjRA1paWjh27BgWLlyI5ORkWFlZoUOHDpgwYYJ8XXV1dezbtw8DBgxA7dq1oa+vj+7du2Pq1KlfFQsT5URERERERERERERU5GQy2Scft7KyQlhY2Ge3Y21tjQMHDuQrFtYoJyIiIiIiIiIiIiKVxkQ5EREREREREREREak0JsqJiIiIiIiIiIiISKUxUU5FysbGBgsXLiyy15NIJPj999+L7PWIiIiIiIiIiIjyIpFIVOKmrDiZJ5EKunTxAtatWY3IiJuIjY3FgqAlaNCwkdBhfbXLly5g47o1uBUZjrjYWMxZsBjeDd6348SxI9i9YztuRYYjMTERm7bvhqOTs4ARf5nLly5g0/r37Zo9/327sjIzsWzJIvx9+hSePnkCA0MDVK9ZGz5DRqJkqVICR/7lftu4ButWBKFNp87oN3QMAGDx7Gm4cvE8XsXFQkdPD5VcPdBzwFBYWdsKHO17fTxt0dilFGxL6iMtU4qr0a8x//BtPIxLAQAY62pgUEM71LEzg6WJDhKSM3A84iUWH7uHpPQsAEDbKmUwo6NrntuvPzMUr5Iziqw9X2P50sVYuWyJwjIbG1vs/vOgQBF9G7H2G1cuXcSWDWsQFRmBuLhYBMwLgtf3DeWPp6QkY1nQApwKPYHExNcoU6YsOv38C9p1/EnAqL/dti2bsX7tasTFxcLB0Qljx/nDzd1d6LC+mVjOy//127at2Ll9K549ewoAqGBnh1/7D0K9+p4CR5Y/YugPN69bhb9CjyH60QNoa+vAxc0Dv/oMR/kPzrlPnzzG8qC5uHHtCjIzMlC9dl0MGemHEmbmAkb+9bKzs7FyWTAO7vsT8fFxMC9ZCq3btEXvXwco9Qf51SErcPzYETx8cB/aOjrwqFwFw4aPgo1tBaFDyxextkus/eE7Yjsvf2jNqpVYvGg+Ov/SDaN9xwkdToEQ8/4iyi+OKCell5FRfJJKmZmZQofwRVJTU+Do6Ai/CZOEDiVfUlNT4eDoiDF+/nk+npaaCo8q38Fn2Mgijix/0lJTYe/giNF5tCstLQ1RkRHo1XcANm7bhVnzghD98CFGDhsoQKTf5nbkTRzcuxO2FR0Ults5OmP4uClYsXk3ps9bCplMhgnDByA7O1ugSHOrbmuKrece4+fl59F37UVoqEsQ0qMqdDXVAQAlDXVQylAbcw/dRtugvzF+VzjqOZhjWnsX+TYO3ngOr4BQhdvp23H45/6rYpskf6einT2OnPxLflu9YYvQIX010fYbaamwc3DEyLET8nw8aN5snPv7NCZND8TWXX/ix85dMX/WDPwVdqKII82/QwcPYO7sAPQbOAjbduyBo6MTBvTrjfj4eKFD+2ZiOS//l0VpCwwePhKbf9uFzdt3okaNWhg+eBDu3b0jdGj5puz94bUrF9G24/+wZPVmzAlaiaysLIwZ0g+pqTlf/KampmDMkF8hkUgwf8kqLA7ZgKzMTIwfNRhSqVTg6L/O+jWrsPO3bRgzbgJ2/L4fg4eNxIa1q7F9yyahQ8uXSxf/wU8/d8GGLb9h+cq1yMrMwoBfeyM1JUXo0PJFrO0Sc38oxvPyO+E3b2DXzu2wd3AUOpQCI+b9RVQQRJkol0qlmD17Nuzs7KCtrY3y5ctjxowZAIAbN26gQYMG0NXVhZmZGX799VckJSXJn9ujRw+0bdsWM2fOhIWFBUxMTDB16lRkZWVh9OjRKFGiBMqVK4e1a9fKn/Pw4UNIJBJs27YNderUgY6ODlxdXREWFvbJOJcuXQp7e3vo6OjAwsICHTt2BABs2LABZmZmSE9PV1i/bdu26Nq1KwDg2rVr+P7772FoaAgjIyNUrVoVFy9e/OhrSSQSrFixAq1atYKenh6cnZ1x9uxZ3L17F97e3tDX10edOnVw7949+XPu3buHNm3awMLCAgYGBqhevTqOHTumsN309HT4+vrCysoK2trasLOzw+rVqz/Z7pSUFPTq1QuGhoYoX748Vq5cqfC4r68vHBwcoKenhwoVKsDf318hAT158mRUrlwZq1atgq2tLXR0dAAAd+7cgaenJ3R0dFCpUiUcPXpUYbsdO3aEj4+P/P6wYcMgkUhw69YtADkJd319fXkbDx06hHr16sHExARmZmZo1aqVwv/n3X7fvn07vLy8oKOjg82bNwMAVq1aBWdnZ+jo6MDJyQlLly795P+kqNWr7wWfocPRsFFjoUPJl7r1PDHAZxi+b5h3O1q0boO+/QehRs06RRxZ/tR5164GudtlYGiI4BVr0Lhpc1jb2MLNvTJGj52AWxHheB7zTIBov05qSgpmTxmHIWMmwsDQUOGx5m06wq1yVVhYloWdozO69R2E2JfP8fJ58WlXv/WX8fuVZ7j3MhlRz5MwfudNlDHVRaWyRgCAuy+TMGzrNYTeisXjV6k4f/8VFh29C2+nklBXyxm1lp4lRVxShvyWLZWhZoUS2H3pqZBN+yLq6uowNy8pv5mamgod0lcTa79Ru2599Bs0FF4N8h6FfOP6VbRo3QbfVasByzJl0bbDj7Czd0TEzRtFHGn+bVy/Fu07/oi27Tqgop0dJkyaAh0dHfy+e5fQoX0zsZyX/8vLuwHqe3rB2toG1ja28Bk6HHp6erh+7ZrQoeWbsveHsxctR7NWbWFbwQ52Do4YO3E6XjyPwe1bEQCAm9eu4nnMM/j6T0cFOwdUsHPA2EkzEBUZjisXzwsc/de5fu0KvL5vgHqe3ihTtiwaNWmKmrXrIlwJ+78PLV2xGm3atoednT0cnZwwdUYgYmKeISIiXOjQ8kWs7RJzfyjG8zKQ82u8cWNHwX/SNBgZGQkdToER6/4iKiiiTJT7+fkhMDAQ/v7+iIiIwJYtW2BhYYHk5GQ0bdoUpqamuHDhAnbs2IFjx44pJE8B4MSJE3j27BlOnTqF+fPnY9KkSWjVqhVMTU1x/vx59O/fH/369cOTJ08Unjd69GiMHDkSV65cQe3atdG6deuPfit38eJFDBkyBFOnTkVUVBQOHToET8+cn1116tQJ2dnZ2Lt3r3z9ly9fYv/+/ejVqxcAoEuXLihXrhwuXLiAS5cuYezYsdDU1Pzk/2XatGno1q0brl69CicnJ3Tu3Bn9+vWDn58fLl68CJlMpvC/SEpKQosWLXD8+HFcuXIFzZo1Q+vWrREdHS1fp1u3bti6dSuCgoIQGRmJFStWwMDA4JNxzJs3D9WqVcOVK1cwcOBADBgwAFFRUfLHDQ0NsW7dOkRERGDRokUICQnBggULFLZx9+5d7Nq1C7t378bVq1chlUrRvn17aGlp4fz581i+fDl8fX0VnuPl5YXQ0FD5/bCwMJibm8uXXbhwAZmZmahTJyc5kpycjBEjRuDixYs4fvw41NTU0K5du1yjaMaOHYuhQ4ciMjISTZs2xebNmzFx4kTMmDEDkZGRmDlzJvz9/bF+/fpP/l+IvlVS0ltIJBIYGBb/C7il82eiRp36qFK91ifXS0tNxdEDf6C0ZVmYlypdRNF9PUOdnApmiSkf/zWJoY4GktKzkC2V5fn4D1XKIDUzG0duviiUGAtSdPQjNGlQH62bNcJ431GIUYIvZyiHm3tl/BV2ErEvX0Amk+HShfN4HP0QNWrVFTq0r5KZkYHIiHDUqv3+iww1NTXUqlUH169dETAy+pzs7GwcOrAfqakpcK9cWehw8k1s/WHyvwOHjIyMAQCZmRmARAJNLS35Olpa2pCoqeGGkh1r7h5VcOH8OTx6+AAAcDvqFq5duYw69eoLHFnBSkp6CwAwNjYWOJKCJcZ2iak/FPN5OWDGVNSv763QNmUn5v2lTISuHc4a5Z8muhrlb9++xaJFixAcHIzu3bsDACpWrIh69eohJCQEaWlp2LBhA/T19QEAwcHBaN26NWbNmgULCwsAQIkSJRAUFAQ1NTU4Ojpi9uzZSElJwbhxOfWo3iXiT58+jf/973/y1/bx8UGHDh0AAMuWLcOhQ4ewevVqjBkzJlec0dHR0NfXR6tWrWBoaAhra2tUqVIFAKCrq4vOnTtj7dq16NSpEwBg06ZNKF++PLy9veXPHz16NJycnAAA9vb2n/3f9OzZEz/++COAnFHbtWvXhr+/P5o2bQoAGDp0KHr27Clf38PDAx4eHvL706ZNw549e7B37174+Pjg9u3b+O2333D06FE0apQzgq1Chc/XjmvRogUGDhwoj2PBggU4efIkHB1zfs40YcL7n43b2Nhg1KhR2LZtm8L/MSMjAxs2bEDJkiUBAEeOHMGtW7dw+PBhlClTBgAwc+ZMNG/eXP4cb29vDB06FLGxsdDQ0EBERAT8/f0RGhqK/v37IzQ0FNWrV4eenh4AyPflO2vWrEHJkiUREREBV9f39YWHDRuG9u3by+9PmjQJ8+bNky+ztbVFREQEVqxYIX9PEhWU9PR0BC+ahybNWn72SyqhhR07hLu3b2FRyOaPrrNv93asWbYQaampKFfeBjMWLv/sl4BCkUgA35ZOuPwwAXdfJuW5jomeJvp7V8COC0/yfBwAOlQriwPXnyM9q3j/lN3NzQNTpgXA2sYWcXEvsXLZEvTu/gt27NkLff3i/d4jYITveMyaPgltmjWAuoYG1CQSjPWfgipVqwkd2ldJeJ2A7OxsmJmZKSw3MzPDgwf3BYqKPuXO7Sh07/IzMjLSoaunh3mLglGxop3QYeWL2PpDqVSK4AWz4OpeBbYVcz5TVHJ1h66OLlYGL0CfgUMgk8kQsmQhpNnZiI+LFTjir9Ojd18kJyehY5uWUFNXhzQ7GwMHD0Pzlq2FDq3ASKVSzAmcicpVvoOdvcPnn6AkxNYuMfaHYj0vHzq4H7ciIrBp206hQylQYt1fRAVJdInyyMhIpKeno2HDhnk+5uHhIU+SA0DdunUhlUoRFRUlT5S7uLhATe39YHsLCwuFxKi6ujrMzMzw8uVLhe3Xrl1b/reGhgaqVauGyMjIPONs3LgxrK2tUaFCBTRr1gzNmjVDu3bt5Enavn37onr16nj69CnKli2LdevWoUePHvJvZUaMGIE+ffpg48aNaNSoETp16oSKFSt+8n/j/sHkDO/a6ubmprAsLS0Nb968gZGREZKSkjB58mTs378fMTExyMrKQmpqqnxE+dWrV6Gurg4vL69Pvu6n4pBIJChdurTC/3L79u0ICgrCvXv3kJSUhKysrFw/dbK2tpYnyYGcfWtlZSVPkgOK+wMAXF1dUaJECYSFhUFLSwtVqlRBq1atsGRJzmRMYWFh8i8igJxSLhMnTsT58+cRFxcnH0keHR2t8H6oVu19kiE5ORn37t1D79690bdvX/nyrKysj46CSE9Pz1VmR6auDW1t7TzXJ3onKzMT48YMh0wmg+/44l3XNvbFc6xYNBszFiyH1ife2983aYEq1WvhVXwcdm/dgAD/MZi7bN0nnyOUCa2dYW9hgK4r/8nzcX1tdSzr9h3uxSZj6fF7ea7jYWWMiqUMMHZH8f/5d90PJptycHSEm5sHWjZtgKOHD6Ft+44CRkZfYue2zQi/cR2zFwSjtGUZXL18EfMCp8O8ZClUr1n78xsg+kY2trbYtmsPkt6+xbEjhzFx/FisWrdRqZNDYusPF82ZgQf372Lxive/fjQxLYFJM+dh4exp2P3bZkjU1NCwcXPYOzorfE5SBkcPH8Sh/fswPXAOKla0R1RUJObPDkDJkqXQqk1bocMrEAHTp+Du3TtYp2S18j9HbO0SY38oRs+fx2BO4EwsW7mGn8mJVJDoEuW6urr53sZ/Ry9KJJI8l+VnIhtDQ0NcvnwZoaGhOHLkCCZOnIjJkyfjwoULMDExQZUqVeDh4YENGzagSZMmCA8Px/79++XPnzx5Mjp37oz9+/fj4MGDmDRpErZt24Z27dp9UbveJdzzWvauXaNGjcLRo0cxd+5c2NnZQVdXFx07dpRPnvmt/+tP/S/Pnj2LLl26YMqUKWjatCmMjY2xbds2zJs3T+E5H37Z8aUkEgk8PT0RGhoKbW1teHt7w93dHenp6bh58yb+/vtvjBo1Sr5+69atYW1tjZCQEJQpUwZSqRSurq65Jg/9MJZ39e5DQkJQs2ZNhfXU1dXzjCsgIABTpkxRWDbefxImTJz81W0k1ZGVmQm/McMRE/MMS1euLfajye9EReB1wisM7v2zfJk0Oxs3r13Gn7u3448T/0BdXR36BobQNzBEWStrOLm448fm9fH3qRPwbtz8E1sveuNbO8HLsSS6r7qAF2/Scz2up6WOFd2rIjk9C0M2X0XWR8qudKhWFpHP3iDi2dvCDrnAGRoZoby1DR5HPxI6FPqM9LQ0LA9eiIB5QahbP+fLbTsHR9y5HYUtG9YqVaLc1MQU6urquUrbxcfHw9zcXKCo6FM0NbVQvrw1AKCSiyvCw29i66YNmDBpqsCRFRxl7g8XzZmBs6fDsGjFOpS0UCx1Vr1WHWzefRCJrxOgrq4OA0MjtG/uDcsy5QSK9tsEzZ+L7r37oGnzlgAAOwcHxMQ8w9rVK0WRKA+YMRWnwkKxZv0mWJQuvuXqvpYY2yXG/lCM5+XI8HC8ehWPzj+9/9V4dnY2Ll+6iO1bN+P8pesf/Wxf3IlxfxEVNOUaDvAF7O3toauri+PHj+d6zNnZGdeuXUNycrJ82ZkzZ+QlVvLr3Llz8r+zsrJw6dIlODs7f3R9DQ0NNGrUCLNnz8b169fx8OFDnDhxQv54nz59sG7dOqxduxaNGjWClZWVwvMdHBwwfPhwHDlyBO3bt1eYYLQgnDlzBj169EC7du3g5uaG0qVL4+HDh/LH3dzcIJVKPztp6df4+++/YW1tjfHjx6NatWqwt7fHo0ef/9Dh7OyMx48fIyYmRr7sw/3xzrs65aGhofD29oaamho8PT0xZ84cpKeno27dnFqt8fHxiIqKwoQJE9CwYUM4OzsjISHhs3FYWFigTJkyuH//Puzs7BRutra2eT7Hz88PiYmJCrfRvn6ffS1SXe+S5I+jH2HJ8jUwMSn+E4hVrlYTSzfsRPDa7fKbvVMleDdpgeC12/O+2JTJANm/dVKLkfGtndCwUin0WnMRTxNScz2ur62OkJ5VkZkthc+mK8j4SEkVPS11NHMrrRSTeOYlJSUZTx4/hvkHv+6h4ikrKwtZWVm5RoGqqalBKsv7S5ziSlNLC86VXHD+3Fn5MqlUivPnz8Ldo4qAkdGXkkmluQYdKDtl7A9lMhkWzZmB02EnMH/J6k8mv41NTGFgaITLF8/jdcIr1PH0LrpAC0BaWirUJIr9n7qaOmSy4l3y7HNkMhkCZkzFieNHsXLNepQtZ/X5JykBsbYrL2LoD8V4Xq5RqxZ27N6LbTv2yG+VXFzRomVrbNuxR2mT5IA49xdRQRPdiHIdHR34+vpizJgx0NLSQt26dREbG4vw8HB06dIFkyZNQvfu3TF58mTExsZi8ODB6Nq1q7wUSX4sWbIE9vb2cHZ2xoIFC5CQkCCffBMAnJycEBAQgHbt2mHfvn24f/8+PD09YWpqigMHDkAqlSok7Dt37oxRo0YhJCQEGzZskC9PTU3F6NGj0bFjR9ja2uLJkye4cOGCvKb206dP0bBhQ2zYsAE1atT45vbY29tj9+7daN26NSQSCfz9/RVG0dvY2KB79+7o1asXgoKC4OHhgUePHuHly5fyWugftvlLXzM6Ohrbtm1D9erVsX//fuzZs+ezz2vUqBEcHBzQvXt3zJkzB2/evMH48eNzreft7Y3hw4dDS0sL9erVky8bNWoUqlevLh8dbmpqCjMzM6xcuRKWlpaIjo7G2LFjv6gNU6ZMwZAhQ2BsbIxmzZohPT0dFy9eREJCAkaMGJFrfW3t3GVW0rK+6KW+WUpyssKkrE+fPMGtyEgYGxvD8oPyNcVdSkoyHn/QjmdPnyDqVk47SluWQWLiazyPiUFcbE5pn3eTOJmZm8PcvPh+mE1JScaT/7Tr9q1IGBkbw9y8JMaOHoZbkRGYH7QM2dJsxP1bK9TY2Biamlof26yg9PT0YVNB8WelOjq6MDIyhk0FO8Q8fYJTJw7ju+q1YWxiirjYF9ixaS20tLVRvXbxmWzL/wdntHAvjcGbriIlPQvmBjn/77dpWUjPkuYkyXtUhY6WOsbuuAEDbQ0Y/Ht4v0rOwIcDy5u5lYa6mgR/Xo3J45WKnwVzZ8HT63tYlimD2NiXWL4kGGrqamjWvJXQoX0VUfcbj9+3K+bpE9yOioSRUU67qlStjuCFc6GtrY3SlmVw5dIFHNy/F0NG5J5Hpbjr2r0n/Mf5wsXFFa5u7ti0cT1SU1PRtl37zz+5mBLLefm/ghbMQ936nrC0tERycjIO7t+Hixf+wdIVq4QOLV/E0B8unDMDxw8fwPQ5i6Cnr49X8XEAAH19A2jr6AAADv65B9Y2FWBsWgIRN64ieP4sdPy5K8pb5z34o7iq7/U91oSsQGlLS1SoaI+oWxHYvHEdfmirvH0GAMycPgUHD+zDwqCl0NfXl18PGhgYQufffaiMxNousfaHgPjOy/r6Brlq4uvq6sLYxEQUtfLFtr+UkvLOc6kSRJcoBwB/f39oaGhg4sSJePbsGSwtLdG/f3/o6enh8OHDGDp0qHzSxg4dOmD+/PkF8rqBgYEIDAzE1atXYWdnh7179yr8fCUqKgqJiYkAABMTE+zevRuTJ09GWloa7O3tsXXrVri4uMjXNzY2RocOHbB//360bdtWvvzdT2W6deuGFy9ewNzcHO3bt5eX78jMzERUVBRSUlLy1Z758+ejV69eqFOnDszNzeHr64s3b94orLNs2TKMGzcOAwcORHx8PMqXLy+f9PS/bf4SP/zwA4YPHw4fHx+kp6ejZcuW8Pf3x+TJkz/5PDU1NezZswe9e/dGjRo1YGNjg6CgIDRr1kxhPTc3N5iYmMDBwUFeqsLb2xvZ2dkK9cnV1NSwbds2DBkyBK6urnB0dERQUJDCOh/Tp08f6OnpYc6cORg9ejT09fXh5uaGYcOGffH/obCFh99En57d5Pfnzg4AAPzQph2mzQwUKqyvFhkejv593k+QumDuLABAyx/aYvK0AJwKPYmpE9+/H8f7jgQA9O0/CL8O8CnaYL9CZHg4BvR9366F8/5tV+u26NvfB6dCc3558stPil9ALQtZj6rVv/3LMSFpaWsh/Npl/PHbZiS9fQOTEmZw9fgO85avh4lpCaHDk/tfzZxRTev7VldYPn7nTfx+5RkqlTGCR3kTAMChkYoJ/sZzTuHZ6zT5/fZVy+JY+Eu8LexvxgrIixcv4Oc7EomvX8PUtAQqf1cV6zdvh2mJ4rN/voRY+41bEeHw+fX9hNxB82cDAFq0boMJU2ZiasAcLFu8EJPH++LNm0SUtiyDfoOGoF3Hn4QK+Zs1a94CCa9eYWlwEOLiYuHo5IylK1bBTIl/MiyW8/J/vXr1Cv7jfBEXGwsDQ0PYOzhi6YpVqFWnrtCh5YsY+sO9u7YDAIYP6KWw3Nd/Gpq1agsAeBz9ECFLF+Htm0SUtiyLLj37otPP3f67qWJvtN8ELA9ehMAZU5Hw6hXMS5ZC+44/om//gUKHli87tm8FAPTp2VVh+ZTpAWijxF8CiLVdYu0PAXGel8WM+4vo0yQymZL95rYYevjwIWxtbXHlyhVUrly5QLfdsGFDuLi4ICgoqEC3S8WbkuTNvtrHSlAoO7H2onFJuWtvi8EPC/8SOoRC8c+kxkKHUCiyP1LfXdllZouzP9TXFuUYDNFSttI7X0qkzUJiSqbQIRQKQ11x9hsaSjbpqaqTQZwdh5pEnENXpSK9PlRTE+f+0hFnN//NrHz+EDqEIvE4uI3QIXwTvl2LqYSEBHkt7aVLlwodDhEREREREREREZFoMVFeTFWpUgUJCQmYNWtWgUw0SkRERERERERERMKRiPSXHmLBRHkBsLGxQUFXsHn48GGBbo+IiIiIiIiIiIiI8sbCaURERERERERERESk0pgoJyIiIiIiIiIiIiKVxkQ5EREREREREREREak01ignIiIiIiIiIiIiKmSczLN444hyIiIiIiIiIiIiIlJpTJQTERERERERERERkUpjopyIiIiIiIiIiIiIVBprlBMREREREREREREVMtYoL944opyIiIiIiIiIiIiIVBoT5URERERERERERESk0pgoJyIiIiIiIiIiIiKVxkQ5EREREREREREREak0TuZJREREREREREREVMg4mWfxxhHlRERERERERERERKTSmCgnIiIiIiIiIiIiIpXGRDkRERERERERERERqTQmyomIiIiIiIiIiIhIpXEyTyIiIiIiIiIiIqLCxrk8izWOKCciIiIiIiIiIiIilcZEORERERERERERERGpNCbKiYiIiIiIiIiIiEilsUY5ERWZ54lpQodQKPS1xdmVljLSFjqEQvH3hEZCh1AoKgzcKXQIheLR8k5Ch1AotDQ4VoGEpyYRZ5HMTKlU6BAKhYGOOK83NNTE2R/KIBM6hEIhEWlxXbH2hzJxvg1FW+M5W8odpgokIu1vxEKcVyVERERERERERERERF+IiXIiIiIiIiIiIiIiUmlMlBMRERERERERERGRSmOinIiIiIiIiIiIiIhUmjhnhCEiIiIiIiIiIiIqRjiZZ/HGEeVEREREREREREREpNKYKCciIiIiIiIiIiIilcZEORERERERERERERGpNNYoJyIiIiIiIiIiIipkLFFevHFEORERERERERERERGpNCbKiYiIiIiIiIiIiEilMVFORERERERERERERCqNiXIiIiIiIiIiIiIiUmmczJOIiIiIiIiIiIiokEk4m2exxhHlRERERERERERERKTSmCgnIiIiIiIiIiIiIpXGRDkRERERERERERERqTTWKCciIiIiIiIiIiIqZCxRXrxxRDkRERERERERERERqTQmyomIiIiIiIiIiIhIpTFRTkREREREREREREQqjYlyEtTkyZNRuXLlfG/HxsYGCxcuzPd2iIiIiIiIiIiISPVwMk8S1KhRozB48GChw1A5ly5ewLo1qxEZcROxsbFYELQEDRo2EjqsfNmxaQ02rFyMHzp2Rt8howEACfFxWLNsIa5ePIfUlGSUtbLBj117o6538W7rH7u248/d2/H82TMAgE2Fiujauz9q1qkPAMhIT8eyRXNw8ughZGRmoHrNuhg6ZjxKmJkLGfZXy87OxsplwTi470/Ex8fBvGQptG7TFr1/HQCJEs1wcvnSBWxavwa3IsMRFxuL2fMXw7tBznssKzMTy5Yswt+nT+HpkycwMDRA9Zq14TNkJEqWKiVw5O8Nae6EFt+Vhb2lIdIysnHhXjym7byOey+S5OvsHu2Fuo6KMa8PvYcxmy7L779Y1SnXtvutOIffLzwuvODzSYz9IcB2KRu2S7mI6fy1cd3789ecBe/PXwAgk8mwYuli/L57B5LevoV75SoYO34SylvbCBf0N1gdsgLHjx3Bwwf3oa2jA4/KVTBs+CjY2FYQOrR8+W3bVuzcvhXPnj0FAFSws8Ov/QehXn1PgSPLH7Hur3e2bdmM9WtXIy4uFg6OThg7zh9u7u5Ch/XNxLq/xHp8AcDLFy+waMFc/H36FNLS0mBlVR6Tp89EJRc3oUNTGcp0raCKOKKcBGVgYAAzMzOhw1A5qakpcHR0hN+ESUKHUiBuR4bj0N5dsKlor7B8/gx/PI1+CP+ZCxG8bgfqeDbA7Mm+uHf7lkCRfpmSpSzQZ+AwLF+/HcvWb0OVajXhP3oIHty/CwBYsnA2zp4Ow8SAeVi4bC3i415i0tjhAkf99davWYWdv23DmHETsOP3/Rg8bCQ2rF2N7Vs2CR3aV0lLTYW9gyNG+/nnfiwtDVGREejVdwA2btuFWfOCEP3wIUYOGyhApB9X27Ek1p68ixYzT6DT/FPQUFfD9hGe0NNSV1hvY9h9uI7YK79N3Xk917aGrPlHYZ2DV54WVTO+idj6w3fYLuXCdikXsZy/UlNT4eDoiDF5nL8AYMPaVdi+dRP8JkzG2k3boaurh8ED+iI9Pb2II82fSxf/wU8/d8GGLb9h+cq1yMrMwoBfeyM1JUXo0PLForQFBg8fic2/7cLm7TtRo0YtDB88CPfu3hE6tHwR6/4CgEMHD2Du7AD0GzgI23bsgaOjEwb06434+HihQ/tmYt1fYj2+3iQmome3n6GhoYHFy0Kw8/f9GD7aF4ZGxkKHRlRsMFGuRKRSKWbPng07Oztoa2ujfPnymDFjBgDgxo0baNCgAXR1dWFmZoZff/0VSUnvRwL26NEDbdu2xcyZM2FhYQETExNMnToVWVlZGD16NEqUKIFy5cph7dq18uc8fPgQEokE27ZtQ506daCjowNXV1eEhYV9NMbg4GC4urrK7//++++QSCRYvny5fFmjRo0wYcIEALlLr7yLc+7cubC0tISZmRkGDRqEzMxM+TovX75E69atoaurC1tbW2zevDlXHNHR0WjTpg0MDAxgZGSEH3/8ES9evAAAJCYmQl1dHRcvXpT/X0uUKIFatWrJn79p0yZYWVkBADIyMuDj4wNLS0vo6OjA2toaAQEBebY/LS0NLi4u+PXXX+XL7t27B0NDQ6xZs+aj/7eiVq++F3yGDkfDRo2FDiXfUlNSMG/aOAwe4w8DQyOFx26FX0OrDv+DQyVXlC5TDj917wt9A0PcvR0hULRfpk59b9Sq64ly5a1hVd4GvQcMga6eHiJvXkdS0lsc3LsbA4aOxnfVasLB2QVj/Kch/PpVRNy4JnToX+X6tSvw+r4B6nl6o0zZsmjUpClq1q6L8Js3hA7tq9Sp54kBPsPwfYPcx5OBoSGCV6xB46bNYW1jCzf3yhg9dgJuRYTjecwzAaLN288L/8L2vx8h6tkbRDxJxNA1/8DKTB/u1qYK66VmZCH2Tbr8lpSWlWtbb1IyFdZJz5IWVTO+iZj6ww+xXcqF7VIuYjl/1X13/mqYe//IZDJs3bwBvfr2h9f3DWHv4Igp0wMRF/sSYSeOCRDtt1u6YjXatG0POzt7ODo5YeqMQMTEPENERLjQoeWLl3cD1Pf0grW1DaxtbOEzdDj09PRw/ZpyXQ/+l1j3FwBsXL8W7Tv+iLbtOqCinR0mTJoCHR0d/L57l9ChfTOx7i+xHl/r1qyCRWlLTJkeAFc3d5QtVw6169SDlVV5oUMjKjaYKFcifn5+CAwMhL+/PyIiIrBlyxZYWFggOTkZTZs2hampKS5cuIAdO3bg2LFj8PHxUXj+iRMn8OzZM5w6dQrz58/HpEmT0KpVK5iamuL8+fPo378/+vXrhydPnig8b/To0Rg5ciSuXLmC2rVro3Xr1h/91tvLywsRERGIjY0FAISFhcHc3ByhoaEAgMzMTJw9exbe3t4fbefJkydx7949nDx5EuvXr8e6deuwbt06+eM9evTA48ePcfLkSezcuRNLly7Fy5cv5Y9LpVK0adMGr169QlhYGI4ePYr79+/jp59+AgAYGxujcuXK8phu3LgBiUSCK1euyL9cCAsLg5eXFwAgKCgIe/fuxW+//YaoqChs3rwZNjY2ecauo6ODzZs3Y/369fjjjz+QnZ2NX375BY0bN0avXr0+2mb6dssXBKBa7fqoXK1WrsecXDzw14kjePsmEVKpFKeOH0JGRjrcKlcTINJvk52djRNHDiItNRWVXD1w+1YEsrKyULXG+/aWt6mAUqUtEX5TuS7c3D2q4ML5c3j08AEA4HbULVy7chl16tUXOLLClZT0FhKJJNcXO8WJoZ4mAOB1cobC8va1rBGx4AeETWmC8e1dofufEecAENDlO0Qs+AGHxjfEz3VtiiJcIqIipQrnr6dPnyA+Lg41ataWLzMwNISLmzuuX1eu643/Skp6CyDnM4FYZGdn49CB/UhNTYF7Acz/VJyIZX9lZmQgMiIctWrXkS9TU1NDrVp1cP3aFQEjK1hi2V8fEtPxFRZ6ApUquWLMiKFo6FUHP3dqh907fxM6LKJihTXKlcTbt2+xaNEiBAcHo3v37gCAihUrol69eggJCUFaWho2bNgAfX19ADkju1u3bo1Zs2bBwsICAFCiRAkEBQVBTU0Njo6OmD17NlJSUjBu3DgA7xPxp0+fxv/+9z/5a/v4+KBDhw4AgGXLluHQoUNYvXo1xowZkytOV1dXlChRAmFhYejYsSNCQ0MxcuRILFq0CADwzz//IDMzE3Xq1Mn13HdMTU0RHBwMdXV1ODk5oWXLljh+/Dj69u2L27dv4+DBg/jnn39QvXp1AMDq1avh7Owsf/7x48dx48YNPHjwQD4qfMOGDXBxccGFCxdQvXp1eHt7IzQ0FKNGjUJoaCgaN26MW7du4fTp02jWrBlCQ0Pl7YuOjoa9vT3q1asHiUQCa2vrT+6rypUrY/r06ejTpw/+97//4dGjR9i3b98nn0Pf5tTxQ7h3+xbmr8z7p86+U2Zj9mRfdG7lDXV1DWjr6GDc9PkoU674f2N+/+5t+PT5BRkZGdDV1cOUWQthU6Ei7t25BU1NzVxJVtMSZkiIjxMo2m/To3dfJCcnoWObllBTV4c0OxsDBw9D85athQ6t0KSnpyN40Tw0adYSBgYGQoeTJ4kEmP5TZZy/E4dbz97Il+85H43H8Sl48ToVlcqZYEIHN1QsbYheS8/K1wn8/SZO33qJ1PRseLtYIPCX76Cvo4FVx+8K0RQiokKhCuev+Lica4r/lkg0MzNHfFysECEVCKlUijmBM1G5ynews3cQOpx8u3M7Ct27/IyMjHTo6ulh3qJgVKxoJ3RYBUZM+yvhdQKys7PzOKbM8ODBfYGiKlhi2l+AOI+vp08eY+dvW9GlWw/06tsP4TdvYE7gDGhqaqJ1m3ZCh0dULDBRriQiIyORnp6Ohg0b5vmYh4eHPEkOAHXr1oVUKkVUVJQ8Ue7i4gI1tfc/IrCwsFAok6Kurg4zMzOF0dkAULv2+5EkGhoaqFatGiIjI/OMUyKRwNPTE6GhoWjUqBEiIiIwcOBAzJ49G7du3UJYWBiqV68OPT29j7bVxcUF6urvRylaWlrixo0b8rZqaGigatWq8sednJxgYmKi8P+wsrKSJ8kBoFKlSjAxMUFkZCSqV68OLy8vrF69GtnZ2QgLC0OTJk1QunRphIaGwt3dHXfv3pWPeu/RowcaN24MR0dHNGvWDK1atUKTJk0+Gj8AjBw5Er///juCg4Nx8ODBT9ZhT09Pz1XrUaauDW1t7U++hqqLffEcIUFzMHX+Mmh95H+1efUSJCe9xfQFy2FkbIJzf4Vi9uQxCFy8Jlc98+LGytoWIRt3IjnpLcJOHMWsqROwYNnazz9RiRw9fBCH9u/D9MA5qFjRHlFRkZg/OwAlS5ZCqzZthQ6vwGVlZmLcmOGQyWTwHV986/UGdvkOjmWN8cOskwrLN556IP878ukbvEhMxa5R3rAuqY9HsckAgAX73p8bbj5+DT1tDQxs6shEORGJiqqdv8QkYPoU3L17B+s2bBE6lAJhY2uLbbv2IOntWxw7chgTx4/FqnUblT6Z947Y9pfYiW1/ifH4kkplqOTigsFDRwAAnJwr4d7dO9j52zYmyosQ5/Is3lh6RUno6urmexuampoK9yUSSZ7LpNL81ZN9N1r7r7/+QpUqVWBkZCRPnn9Y0uRr4sxvTP/l6emJt2/f4vLlyzh16hS8vb3lcYeFhaFMmTKwt89JpH733Xd48OABpk2bhtTUVPz444/o2LHjJ7f/8uVL3L59G+rq6rhz59MTfgQEBMDY2FjhNmdW3jXQ6b27tyPxOuEVhvXpjDbfV0Ob76vh5tVL+HPXVrT5vhpinj7Gvt3bMWTsZHhUrQlbO0f83LMf7BwrYf+e7UKH/1mampooa1UeDs4u6DtoGCraO2D39k0wNTNHZmYmkt6+UVg/4VU8TM3MBYr22wTNn4vuvfugafOWsHNwQMvWbfBz1+5Yu3ql0KEVuKzMTPiNGY6YmGdYvHx1sR1NPrNzFTR2t0SHuaGISUj95LqX778CANiW+nhbLt+PR9kSetDS4OUGEYmHKpy/zMxzrin+W24xPj4OZuYlhQgp3wJmTMWpsFCsWrMeFqVLCx1OgdDU1EL58tao5OKKIcNHwsHRCVs3bRA6rAIhtv1lamIKdXX1PI6peJibK9c1fF7Etr8AcR5f5iVLosJ/Ev22FSri+fMYgSIiKn74yVVJ2NvbQ1dXF8ePH8/1mLOzM65du4bk5GT5sjNnzshLrOTXuXPn5H9nZWXh0qVLCqVO/utdnfIdO3bIR2V7e3vj2LFjOHPmzCfrk3+Ok5OTPIZ3oqKi8Pr1a/l9Z2dnPH78GI8fP5Yvi4iIwOvXr1GpUiUAgImJCdzd3REcHAxNTU04OTnB09MTV65cwb59+3Il842MjPDTTz8hJCQE27dvx65du/Dq1auPxtmrVy+4ublh/fr18PX1/egIfCCn5E1iYqLCbbSv39f+a1SOR9UaCF63A0Grt8lvdk6V4NW4BYJWb0N6WhoAQO0/X9eqqalDJpMJEXK+SKUyZGZmwMGpEjQ0NHD5wnn5Y9GPHuDl8xi4uHoIGOHXS0tLhZpE8TSkrqYOmax4T/74td4lyR9HP8KS5WtgYmL6+ScJYGbnKmhRpSw6zA1DdFzKZ9d3KW8CAHiZmPbRdVzLmyAhOQMZxXxCTyKir6EK56+yZcvBzNwcF86//xyQlJSE8BvX4e6uXNcbMpkMATOm4sTxo1i5Zj3KlrP6/JOUlEwqRUZGxudXLMbEur80tbTgXMkF58+9L1knlUpx/vxZuHtUETCy/BHr/sqLGI6vypWr4OHDBwrLHj18CEvLMgJFRFT8sPSKktDR0YGvry/GjBkDLS0t1K1bF7GxsQgPD0eXLl0wadIkdO/eHZMnT0ZsbCwGDx6Mrl27ysuu5MeSJUtgb28PZ2dnLFiwAAkJCQoTUzo5OSEgIADt2uX8VMfd3R2mpqbYsmWLvDa3t7c3Ro0aBYlEgrp1635zLO/Kn/Tr1w/Lli2DhoYGhg0bpjDivlGjRnBzc0OXLl2wcOFCZGVlYeDAgfDy8kK1au8ncfT29sbixYvlo8NLlCgBZ2dnbN++HUuWLJGvN3/+fFhaWqJKlSpQU1PDjh07ULp0aXm5l27duqFs2bIICAiQ/7/Onj2L69evw8rKCvv370eXLl1w7tw5aGlp5WqTtnbuMitpWd/8L/oiKcnJiI6Olt9/+uQJbkVGwtjYGJZllOMkqaenD+sKit+G6+jowsjIGNYV7JCVlQnLslZYMnc6eg0cAUNjY5z76ySuXjyHiYGLBIr6y4QsWYgaderBwsISKSnJOH74AK5dvoBZi5bDwMAQzX9oj6WL5sDQyBj6+voImheASm4eqOSmXB9c63t9jzUhK1Da0hIVKtoj6lYENm9chx/athc6tK+SkpKMJx8cT8+ePsHtW5EwMjaGuXlJjB09DLciIzA/aBmypdmI+7e2q7GxMTQ1c/cJQgjsUgXta5ZH9+AzSErLREmjnD7pbWom0jKlsC6pj/Y1y+P4jRgkJGWgUjljTP2pMv6OikXEk0QAQBMPS5Q00sGle/FIy8qGVyULDG3hjKWHo4Rs2meJoT/MC9ulXNgu5SKm89fj/5y/om7l7J/SlmXwc5duWBOyHFbW1ihbthyWLwmCeclS8GrQSMCov97M6VNw8MA+LAxaCn19ffl52MDAEDo6OgJH9+2CFsxD3fqesLS0RHJyMg7u34eLF/7B0hWrhA4tX8S6vwCga/ee8B/nCxcXV7i6uWPTxvVITU1F23bK1Xd8SKz7S6zHV5duPdCz689YHbIcjZs2R/iN69i96zdMmDhV6NCIig0mypWIv78/NDQ0MHHiRDx79gyWlpbo378/9PT0cPjwYQwdOlRe/7tDhw6YP39+gbxuYGAgAgMDcfXqVdjZ2WHv3r0KPw+LiopCYmKi/L5EIkH9+vWxf/9+1KtXD0BO8tzIyAiOjo4KtdS/xdq1a9GnTx94eXnBwsIC06dPh7+/v8Lr//HHHxg8eDA8PT2hpqaGZs2aYfHixQrb8fLywsKFCxVGuHt7e+PatWsKywwNDTF79mzcuXMH6urqqF69Og4cOCCv9x4dHS3/+9atWxg9ejRWr14tr5G+dOlSuLu7w9/fH7NmzcpX2wtKePhN9OnZTX5/7uycJP8Pbdph2sxAocIqUBoampg8ezHWrQjCNL+hSE1NgWVZKwwbNxXVatcXOrxPep3wCoFTxuNVXCz0DQxRwc4esxYtR7WaOZPgDho2BmoSCSb7DUdmRiaq1aqDYWMmCBz11xvtNwHLgxchcMZUJLx6BfOSpdC+44/o23+g0KF9lcjwcAzo211+f+G8nOO8Zeu26NvfB6dCTwAAfvlJse7fspD1qFq9RtEF+gk9v8/50un3Md8rLB+y5h9s//sRMrOk8HS2wK+N7KGnrYFnr1Kw7/IThZrkmVlS9Py+Iqb+5AEJJHjwMgkTt1/Dpr+K9wRVYu0P2S7lwnYpFzGdv/r3eX/+WjD33/PXD20xeVoAuvXsg9TUVMycOglJb9/Ao8p3CFq6Uunm0dmxfSsAoE/PrgrLp0wPQBsl+3LjQ69evYL/OF/ExcbCwNAQ9g6OWLpiFWrV+fZBScWBWPcXADRr3gIJr15haXAQ4uJi4ejkjKUrVslLHSkjse4vsR5fLq5umLtwMYIXzkfI8qUoU7YcRo3xQ4tW4pmMWhmoqbFIeXEmkSljDQIqEg8fPoStrS2uXLmCypUrCx2OSinsEeVCiY7/fDkHZaSvLc7vHI10xdmuAp7yoNhwGLxL6BAKxaPlnYQOgYiUTGa2ODt6sX5q01QXZzVQGcS5wyQQZ4JHrJPribXfEOvxJdb9pa8l0gPsG1Uad0ToEIpExMwmQofwTcR5VUJERERERERERERE9IWYKCciIiIiIiIiIiIilSbO39VTgbCxsQEr8xAREREREREREZHYMVFOREREREREREREVMjEOieCWLD0ChERERERERERERGpNCbKiYiIiIiIiIiIiEilMVFORERERERERERERCqNNcqJiIiIiIiIiIiICpmERcqLNY4oJyIiIiIiIiIiIiKVxkQ5EREREREREREREak0JsqJiIiIiIiIiIiISKUxUU5EREREREREREREKo2TeRIREREREREREREVMs7lWbxxRDkRERERERERERERqTQmyomIiIiIiIiIiIhIpTFRTkREREREREREREQqjTXKiYiIiIiIiIiIiAqZhEXKizWOKCciIiIiIiIiIiIilcZEORERERERERERERGpNCbKiYiIiIiIiIiIiEilMVFORERERERERERERCqNk3kSERERERERERERFTJO5lm8cUQ5EREREREREREREak0JsqJiIiIiIiIiIiISKUxUU5EREREREREREREKo01yomoyJQroSt0CIVCAnHWGEtKzxI6hMIhEzqAwvFoeSehQygUpk1mCB1CoXhxwE/oEAqFhpo4+0ORdvNQE2mNTA01cY4FSs/KFjqEQiHStyFkUqEjKBwyiTgvpMR6PS/W4wsycTZMpKcvIqXCRDkRERERERERERFRIRPtF1giwe+riIiIiIiIiIiIiEilMVFORERERERERERERCqNiXIiIiIiIiIiIiIiUmmsUU5ERERERERERERUyCQsUl6scUQ5EREREREREREREak0JsqJiIiIiIiIiIiISKUxUU5EREREREREREREKo2JciIiIiIiIiIiIiJSaZzMk4iIiIiIiIiIiKiQcS7P4o0jyomIiIiIiIiIiIhIpTFRTkREREREREREREQqjYlyIiIiIiIiIiIiIlJprFFOREREREREREREVMgkLFJerHFEORERERERERERERGpNCbKiYiIiIiIiIiIiEilMVFORERERERERERERCqNiXIiIiIiIiIiIiIiUmmczJOIiIiIiIiIiIiokHEuz+KNI8qJiIiIiIiIiIiISKUxUU5EREREREREREREKo2JcioUoaGhkEgkeP36daFs/8yZM3Bzc4Ompibatm1bKK/xJQq7nURERERERERERFT4WKOcCkWdOnUQExMDY2PjQtn+iBEjULlyZRw8eBAGBgaF8hpiduniBaxbsxqRETcRGxuLBUFL0KBhI6HDyrfftm3Fzu1b8ezZUwBABTs7/Np/EOrV9xQ4svxZHbICx48dwcMH96GtowOPylUwbPgo2NhWEDq0L7ZxTQjCTh7Fo4cPoK2tAzf3yhgwZATK29jK10lPT0fwgtk4fuQgMjMyUKN2XYwc648SZuYCRv5pG9fm0a7B79v1JvE1Vq9Ygn/O/Y0XL2JgYmIKT++G6DNgMAwMDAWO/tts27IZ69euRlxcLBwcnTB2nD/c3N2FDitPo36ug7b1HeFQ3gyp6Vk4H/4E40NO4M7jV/J1bMuYILB/I9R2LQdtTQ0cvXAPIxYfwcuEZABAfY/yOLKga57brzdgDS5FxRRJWz7n8qUL2LhuDW5FhiMuNhZzFiyGd4P3/bpMJsOKpYvx++4dSHr7Fu6Vq2Ds+Ekob20jXND5tGbVSixeNB+df+mG0b7jhA4nX8R6/hLr9YYYzssAcOXSRWxa/77fmD0/CF4f9Bshy4Jx9PBBvHj+HJqamnCqVAn9fYbC1c1DwKi/nljfhx9if1j8ifV9KNZ2iaWf/xhlup4nKmocUU6FQktLC6VLl4akkGYpuHfvHho0aIBy5crBxMTkm7aRkZFRsEEpkdTUFDg6OsJvwiShQylQFqUtMHj4SGz+bRc2b9+JGjVqYfjgQbh3947QoeXLpYv/4Kefu2DDlt+wfOVaZGVmYcCvvZGakiJ0aF/syuULaN/pZ6xYtxULloYgKysLwwf1RWrq+zYsnjcLZ06FYlrgfCwOWY+42FiMHz1UwKg/T96utVuxYMm/7fJ536642FjExb7EoGGjsHH77xg/eQbOnT2NwKn+Akf+bQ4dPIC5swPQb+AgbNuxB46OThjQrzfi4+OFDi1P9T3KY/kfl+Dlsw6tRm+BhoY69s3uDD0dTQCAno4m9s3uDJlMhuYjN6PBkPXQ0lDHrhk/yifZORf+BDYdFirc1uy/ggfPEopNkhwAUlNT4eDoiDF+eb+3Nqxdhe1bN8FvwmSs3bQdurp6GDygL9LT04s40oIRfvMGdu3cDnsHR6FDKRBiPX+J9XpDDOdlIGf/2Ds4YvRH+o3y1jYYNXY8tuz8HSvXboRlmbIYMqAvEl69ynP94kqs78N32B8qB7G+D8XaLrH083lRtut5MZJIJCpxU1ZMlNMX8fb2xuDBgzFs2DCYmprCwsICISEhSE5ORs+ePWFoaAg7OzscPHgQQO6SJI8ePULr1q1hamoKfX19uLi44MCBA/Lth4eHo1WrVjAyMoKhoSHq16+Pe/fu5Yrj4cOHkEgkiI+PR69evSCRSLBu3ToAQFhYGGrUqAFtbW1YWlpi7NixyMrKUmiDj48Phg0bBnNzczRt2hQymQyTJ09G+fLloa2tjTJlymDIkCHy52zcuBHVqlWDoaEhSpcujc6dO+Ply5ef/F+dPn0a9evXh66uLqysrDBkyBAkJyd/67++UNSr7wWfocPRsFFjoUMpUF7eDVDf0wvW1jawtrGFz9Dh0NPTw/Vr14QOLV+WrliNNm3bw87OHo5OTpg6IxAxMc8QEREudGhfbH7wSrT4oR0qVLSDvYMTxk2ZgRfPYxAVGQEASHr7Fvv+2IXBI8agao1acHJ2wbhJ03Hj2lXcvFF899/8xSvRovUH7Zqs2K4KdvaYMWcR6nl+j7LlyqNq9Vr4deBQnPkrVKF/UhYb169F+44/om27DqhoZ4cJk6ZAR0cHv+/eJXRoeWozdhs2Hb6OyIdxuHH/JX6d9SfKWxijikNpAEBt13KwtjBG31l/IvxBLMIfxKLPrD/xnYMlvKvYAAAys6R4kZAsv8W/SUWrOg7YcOi6gC3LrW49TwzwGYbvG+bu12UyGbZu3oBeffvD6/uGsHdwxJTpgYiLfYmwE8cEiDZ/UlKSMW7sKPhPmgYjIyOhwykQYj1/ifV6QwznZQCoU88T/X2GKvz65ENNW7RCjVp1ULacFSrY2WPoSF8kJyXh7p2oIo40f8T6PgTYHyoTsb4PxdousfTzeVG263miosZEOX2x9evXw9zcHP/88w8GDx6MAQMGoFOnTqhTpw4uX76MJk2aoGvXrkjJ41vWQYMGIT09HadOncKNGzcwa9YsecmUp0+fwtPTE9ra2jhx4gQuXbqEXr165ZlEsrKyQkxMDIyMjLBw4ULExMTgp59+wtOnT9GiRQtUr14d165dw7Jly7B69WpMnz49Vxu0tLRw5swZLF++HLt27cKCBQuwYsUK3LlzB7///jvc3Nzk62dmZmLatGm4du0afv/9dzx8+BA9evT46P/o3r17aNasGTp06IDr169j+/btOH36NHx8fL7xv07fKjs7G4cO7EdqagrcK1cWOpwClZT0FgAKrbRRUUj+tw1GRjltiIoMR1ZWFqrVrC1fx9q2AixKWyL8+lUhQvwm/23Xx9bR1zeAhoZyVT/LzMhAZEQ4atWuI1+mpqaGWrXq4Pq1KwJG9uWM9LUBAAlv0gAA2poakAFIz8yWr5OWkQWpTIY6blZ5bqNVHXuYGeli4yHl+cD+9OkTxMfFocYHx5eBoSFc3Nxx/brytOOdgBlTUb++t8J7UUzEfP4SKzGclz8nMzMDv+/6DQYGhrB3cBI6HPoX+0OioiGWfl4M1/NEhU25PqWToDw8PDBhwgQAgJ+fHwIDA2Fubo6+ffsCACZOnIhly5bh+vXco+yio6PRoUMHeRK6QoX3tb2WLFkCY2NjbNu2DZqaOT+Hd3BwyDMGdXV1eUkXY2NjlC6dMypw6dKlsLKyQnBwMCQSCZycnPDs2TP4+vpi4sSJUFPL+U7I3t4es2fPlm9v//79KF26NBo1agRNTU2UL18eNWrUkD/eq1cv+d8VKlRAUFAQqlevjqSkpDxrowcEBKBLly4YNmyY/PWCgoLg5eWFZcuWQUdH5zP/ZcqvO7ej0L3Lz8jISIeunh7mLQpGxYp2QodVYKRSKeYEzkTlKt/Bzj7v46S4k0qlCJo7C24eVVDBzh4AEB8fB01NTRgaKo6GKmFmhvj4OCHC/GpSqRRB8xTb9V+vXydg3arlaN2uUxFHl38JrxOQnZ0NMzMzheVmZmZ48OC+QFF9OYkEmDOoMf6+8RgRD2MBAP9EPEVyagZm/NoAE1edhEQiwfS+30NDXQ2lS+Q9/0X3FpVx9OJ9PI17W5Th50t8XM4xlHvfmSM+LlaIkL7ZoYP7cSsiApu27RQ6lAIn9vOXWInhvPwpp0+FYoLvSKSlpcHcvCQWL18FE1NTocMisD8kKipi6ueV/XqeqChwRDl9MfcPJndQV1eHmZmZwuhrCwsLAMizNMmQIUMwffp01K1bF5MmTVJIpl+9ehX169eXJ8m/RWRkJGrXrq1QB6lu3bpISkrCkydP5MuqVq2q8LxOnTohNTUVFSpUQN++fbFnzx6FkeyXLl1C69atUb58eRgaGsLLywtATuI/L9euXcO6detgYGAgvzVt2hRSqRQPHjzI8znp6el48+aNwk1Za8YWBza2tti2aw82bNmOTj/+DxPHj8W9e3eFDqvABEyfgrt372DWnAVCh/LN5gdOx/17dzAlYK7QoRSo+bP+bdfMvNuVnJSE0UMHwKZCRfTuN7CIo6OFQ5vBxbYkuk3bI18Wl5iCLlN3o0Vte8TtH4MXf46CsYEOLt+OgVQmy7WNsuaGaFytAtYfuFqEkdM7z5/HYE7gTMwInAttbW2hwylwYj9/iZUYzsufUrV6DWzcvhsh67egVt16GDdmBF69Yh1bobE/JCo6Yu/nqehJJKpxU1ZMlNMX+28iWyKRKCx7l6SWSqW5ntunTx/cv38fXbt2xY0bN1CtWjUsXrwYAKCrq1uIUSvS19dXuG9lZYWoqCgsXboUurq6GDhwIDw9PZGZmYnk5GQ0bdoURkZG2Lx5My5cuIA9e3ISLB+bCDQpKQn9+vXD1atX5bdr167hzp07qFixYp7PCQgIgLGxscJtzqyAgm24CtHU1EL58tao5OKKIcNHwsHRCVs3bRA6rAIRMGMqToWFYtWa9bD499cUymb+rOn4+3QYglasRSmL920wMzNHZmYm3r59o7D+q/h4mJmZF3WYX03eruWK7XonJTkZI4f0g56+PmbOCYKGxrd/MSgUUxNTqKur55roJz4+HubmxXsfLRjSFC1q2aPpiE25RoIfv/gALr8sRfn2C1Cu7Xz0DtiLMuaGeBjzOtd2ujbzQPybVOz7W7kmFDP7d//k3ndxMDMvKURI3yQyPByvXsWj80/tUa2yC6pVdsGlixewdfNGVKvsguzs7M9vpBgT8/lLrMRwXv4cXV09WJW3hpu7ByZMng51dXXs3cM6tkJjf0hUNMTWzyvz9TxRUWHpFSoyVlZW6N+/P/r37w8/Pz+EhIRg8ODBcHd3x/r165GZmfnNo8qdnZ2xa9cuyGQyecL+zJkzMDQ0RLly5T75XF1dXbRu3RqtW7fGoEGD4OTkhBs3bkAmkyE+Ph6BgYGwssqpVXvx4sVPbuu7775DREQE7Oy+/KeBfn5+GDFihMIymbr4RoYIRSaVfvSLDWUhk8kQOHMaThw/ilVrN6JsubxrJxdnMpkMC2bPwKmTx7F45TqUKat4XDo6u0BDQwOX/jkH74ZNAADRDx/gxfMYuLhXFiDiLyNvV+hxLF6Ru11AzkjyEYN/haamFmbND1bakV+aWlpwruSC8+fOokHDnInfpFIpzp8/i//9/IvA0X3cgiFN8UM9RzQZvhGPnid+dL34N6kAAK8q1ihloo99f9/OtU63Zu7YcvQGsrJzfyFcnJUtWw5m5ua4cP4cHJ2cAeR8sRt+4zo6dvqfwNF9uRq1amHH7r0Kyyb5j4OtbQX06NUH6urqAkVWOMRw/hIrMZyXv5VMJkMm35eCY39IVLjE2s8r6/U8UVFiopyKxLBhw9C8eXM4ODggISEBJ0+ehLNzzod1Hx8fLF68GP/73//g5+cHY2NjnDt3DjVq1ICjoyP27NkDPz8/3Lp166PbHzhwIBYuXIjBgwfDx8cHUVFRmDRpEkaMGCGvT56XdevWITs7GzVr1oSenh42bdoEXV1dWFtbQyqVQktLC4sXL0b//v1x8+ZNTJs27ZPt9PX1Ra1ateDj44M+ffpAX18fEREROHr0KIKDg/N8jra2dq7EWVrueUwLVEpyskL5mKdPnuBWZCSMjY1hWaZM4b54IQpaMA9163vC0tISycnJOLh/Hy5e+AdLV6wSOrR8mTl9Cg4e2IeFQUuhr6+PuH9rChsYGCpN3ft5gdNw7NABBMxfDD09PXldZAMDQ2jr6MDA0BCt2nTA4vmzYWRkDD0DAyycPROu7pXh6uYhcPQfN2/Wv+2al3e7kpOSMNynL9LT0jBxWiCSk5KQnJQEADAxLaF0H2S7du8J/3G+cHFxhaubOzZtXI/U1FS0bdde6NDytHBoM/zU0AWdJuxAUkoGLExzflWUmJyOtIycjrZrM3dEPYpDbGIKalYqh7mDGmPxzvO48/iVwra8q9jAtowp1u6/WtTN+CIpKcl4/EG//uzpE0TdyunXS1uWwc9dumFNyHJYWVujbNlyWL4kCOYlS8GrQSMBo/46+voGuWqD6urqwtjEROlrhor1/CXW6w0xnJeBnH7jiUK/8RS3b0XCyNgYxiYmWBuyAvW9G8Dc3ByvX7/Gzu1bEPvyBRo2bipg1F9PjO9D9ofKR4zvQ0C87RJLP58XZbueJypqTJRTkcjOzsagQYPw5MkTGBkZoVmzZliwIKfGl5mZGU6cOIHRo0fDy8sL6urqqFy5MurWrQsASExMRFRU1Ce3X7ZsWRw4cACjR4+Gh4cHSpQogd69e8snH/0YExMTBAYGYsSIEcjOzoabmxv+/PNP+eQW69atw7hx4xAUFITvvvsOc+fOxQ8//PDR7bm7uyMsLAzjx49H/fr1IZPJULFiRfz0009f8+8qdOHhN9GnZzf5/bmzc0q9/NCmHabNDBQqrHx79eoV/Mf5Ii42FgaGhrB3cMTSFatQq05doUPLlx3btwIA+vTsqrB8yvQAtGmrHBc0v+/cDgAY/GsPheXjJk1Hix/a5Tw20hcSNQnGjxmGzIxM1KhdFyPHfvoYFpq8Xf16KCwfN2k6WrRuh6hbEYi4mTMnw09tmyuss2PvEViWKVskcRaUZs1bIOHVKywNDkJcXCwcnZyxdMUqeWmP4qZfm5x5KY4uVDx2+s76E5sO5+wXByszTO3zPUoY6uLR89eYvfkMgnb+k2tbPVp44OzNx7j9uHjW5o0MD0f/Pt3l9xfMnQUAaPlDW0yeFoBuPfsgNTUVM6dOQtLbN/Co8h2Clq5U2l84iI1Yz19ivd4Qw3kZyOk3BvbtIb+/cN6//UbrtvCdMAmPHj7AgZFD8fp1AoxNTODs4ooVazZ+dMLq4kqs70OxYn+oXMTaLrH083lRtut5oqImkcnymK2KiARV2CPKhZLX5HhiIIESz1TxCUnpIn0jivNtCENdcX73bdpkhtAhFIoXB/yEDqFQaKiJsz8UaTcPNWWeaekTRHq5gfQs5a47/TE6msr166ovJZWK9I0ozm5DtP2hWIm1nxfr21BHnB9TvlnNgDChQygS5/28hA7hm3AyTyIiIiIiIiIiIiJSaUyUExEREREREREREZFKY6KciIiIiIiIiIiIiFQaKwURERERERERERERFTKx1qIXC44oJyIiIiIiIiIiIiKVxkQ5EREREREREREREak0JsqJiIiIiIiIiIiISKUxUU5EREREREREREREKo2TeRIREREREREREREVMgln8yzWOKKciIiIiIiIiIiIiFQaE+VEREREREREREREpNKYKCciIiIiIiIiIiIilcYa5URERERERERERESFjCXKizeOKCciIiIiIiIiIiIilcZEORERERERERERERGpNCbKiYiIiIiIiIiIiEilMVFORERERERERERERCqNk3kSERERERERERERFTIJZ/Ms1jiinIiIiIiIiIiIiIhUGhPlRERERERERERERKTSmCgnIiIiIiIiIiIiIpXGRDkRERERERERERERqTRO5klERERERERERERUyDiXZ/HGEeVEREREREREREREpNI4opyoGJJKZUKHUCjU1MT51alMnLsL+lrqQodQKBJTM4UOgb7CiwN+QodQKKr6HxE6hELxl39DoUMoFIY64rxklkKkJzCRSkrLEjqEQqEm0qF16iK97lWDONuVmSUVOoRCoaEuzrGRWdni3F9i7Tcg0n6DxEmcvSYRERERERERERER0RcS5/AYIiIiIiIiIiIiomJEItJfUokFR5QTERERERERERERkUpjopyIiIiIiIiIiIiIVBoT5URERERERERERESk0pgoJyIiIiIiIiIiIiKVxsk8iYiIiIiIiIiIiAoZJ/Ms3jiinIiIiIiIiIiIiIhUGhPlRERERERERERERKTSmCgnIiIiIiIiIiIiIpXGGuVEREREREREREREhYwlyos3jignIiIiIiIiIiIiIpXGRDkRERERERERERERqTQmyomIiIiIiIiIiIhIpTFRTkREREREREREREQqjZN5EhERERERERERERUyCWfzLNY4opyIiIiIiIiIiIiIVBoT5URERERERERERERU5AICAlC9enUYGhqiVKlSaNu2LaKiohTWSUtLw6BBg2BmZgYDAwN06NABL168UFgnOjoaLVu2hJ6eHkqVKoXRo0cjKyvrq2JhopyIiIiIiIiIiIiIilxYWBgGDRqEc+fO4ejRo8jMzESTJk2QnJwsX2f48OH4888/sWPHDoSFheHZs2do3769/PHs7Gy0bNkSGRkZ+Pvvv7F+/XqsW7cOEydO/KpYJDKZTFZgLSOiApGSIc7DUk1NnLW4xNqLivX0kJiaKXQIhcJUX0voEApFRpZU6BAKRVX/I0KHUCj+8m8odAiFwlBHnNP6sESmcnmVlCF0CIXCSFdT6BAKhbpIr3vVRNpxZGWL83pDQ12cYyPFur/E2m/oaYmzXd/q+0V/Cx1CkTg5tM43Pzc2NhalSpVCWFgYPD09kZiYiJIlS2LLli3o2LEjAODWrVtwdnbG2bNnUatWLRw8eBCtWrXCs2fPYGFhAQBYvnw5fH19ERsbCy2tL/u8LM5ek4iIiIiIiIiIiIiUSmJiIgCgRIkSAIBLly4hMzMTjRo1kq/j5OSE8uXL4+zZswCAs2fPws3NTZ4kB4CmTZvizZs3CA8P/+LXFufwGCIiIiIiIiIiIiIqcunp6UhPT1dYpq2tDW1t7U8+TyqVYtiwYahbty5cXV0BAM+fP4eWlhZMTEwU1rWwsMDz58/l63yYJH/3+LvHvhRHlBMRERERERERERFRgQgICICxsbHCLSAg4LPPGzRoEG7evIlt27YVQZS5cUQ50UesW7cOw4YNw+vXr4UOpdCtWbUSixfNR+dfumG07zihw/lmly5ewLo1qxEZcROxsbFYELQEDRo2+vwTi7nVIStw/NgRPHxwH9o6OvCoXAXDho+CjW0FoUMrUMr4Pty8bhVOnTyG6EcPoK2tAxc3D/QbPBzlrW3l68THxWH54nm4eP4sUlNSYGVtg1969oVXg8YCRv71xHJ8Xb50ARvXrcGtyHDExcZizoLF8G7wvh0njh3B7h3bcSsyHImJidi0fTccnZwFjDi3ft9XQBM3C1QoqY/0rGxcfvgacw7cxoPY95PdTOvggjr2ZihlpI2U9GxcfpSAOftv4/4H67xjoqeJP4fXRWkTHXznfwxv075uZvjCsmltiMLx5epeGf18hqO8zfvja2i/Hrh6+aLC835o3wkj/SYVdbj5snzpYqxctkRhmY2NLXb/eVCgiArGb9u2Yuf2rXj27CkAoIKdHX7tPwj16nsKHFn+iKFde3dtx97dv+FFzDMAgHWFiujaqx9q1qkPAJgfOBWXL5xDfFwsdHX14OLmgb6DFI+/4koM/fyXEGu/Iebr3uTkZCxfsggnTxxDwqtXcHRyxsgx4+Di6iZ0aN+M+0t5KeNnL1Iufn5+GDFihMKyz40m9/Hxwb59+3Dq1CmUK1dOvrx06dLIyMjA69evFUaVv3jxAqVLl5av888//yhs78WLF/LHvhRHlJPgMjLEOTGRsgi/eQO7dm6HvYOj0KHkW2pqChwdHeE3QbkSJJ9z6eI/+OnnLtiw5TcsX7kWWZlZGPBrb6SmpAgdWoFR1vfh1csX0bbT/7B09WbMXbwS2dlZGD24H1JT3++bgCnj8PjRQ8yctxhrtu5Cfe+GmDJuFO5ERQoY+dcTy/GVmpoKB0dHjPHzz/PxtNRUeFT5Dj7DRhZxZF+uRkVTbP47Gp2Cz6HHyovQVJdgbd9q0NVUl69z80kixm6/gWZzTqPnqouQIGedvOaImtnJFbdi3hZhC77MtcsX0a7Tz1i2ZgvmBa9EVlYmRg3+VeH4AoBWbTti98FQ+a3/4OK77z6lop09jpz8S35bvWGL0CHlm0VpCwwePhKbf9uFzdt3okaNWhg+eBDu3b0jdGj5IoZ2mZeyQN9Bw7Bs3TYsXbcVVarWwMQxQ/Hw/l0AgINTJYyZMBVrt/6OwIXLIJPJ4Du0H7KzswWO/PPE0M9/KTH2G2K+7p0+eQLOn/0bU2fMwradf6Bm7boY2K8XXv6byFFG3F/KSVk/e4mFRCJRiZu2tjaMjIwUbh9LlMtkMvj4+GDPnj04ceIEbG0Vv5ivWrUqNDU1cfz4cfmyqKgoREdHo3bt2gCA2rVr48aNG3j58qV8naNHj8LIyAiVKlX64v3DRDkVOW9vb/j4+GDYsGEwNzdH06ZNcfPmTTRv3hwGBgawsLBA165dERcXJ3+OVCrF7NmzYWdnB21tbZQvXx4zZsz46GscOnQI9erVg4mJCczMzNCqVSvcu3dP/nhoaCgkEonCaPGrV69CIpHg4cOHCA0NRc+ePZGYmCg/yCdPngwASEhIQLdu3WBqago9PT00b94cd+68/2D06NEjtG7dGqamptDX14eLiwsOHDhQcP/AApSSkoxxY0fBf9I0GBkZCR1OvtWr7wWfocPRsJFyjdT9nKUrVqNN2/aws7OHo5MTps4IREzMM0REfPmEFMWZMr8P5wQtR/NWbWFb0Q52Do4YO3E6XjyPwe3ICPk6N69fRfsfO8PZxQ1lylqhW+9+MDAwRNQH6ygDsRxfdet5YoDPMHzfMO92tGjdBn37D0KNmt8+S3th673qEnZffIq7L5JwK+YtfLffQFlTXbiWe3/8bD//BBceJOBpQioinr7BgsO3UcZUF+VK6Cpsq3NtKxjpamJ12IOibsZnzVm8As1bvzu+nOA3aUau4wsAdHR0YGZuLr/pGxgIFHH+qKurw9y8pPxmamoqdEj55uXdAPU9vWBtbQNrG1v4DB0OPT09XL92TejQ8kUM7apT3xs169RHufLWsCpvg94DhkBXTw8RN68DyPkCyr1KNZQuUxYOTpXQs99gvHzxXD4CvTgTQz//pcTYb4j1ujctLQ0njh/FkOGj8F3V6rAqb41+A3xgZVUeO3dsFTq8b8b9pXyU+bMXidegQYOwadMmbNmyBYaGhnj+/DmeP3+O1NRUAICxsTF69+6NESNG4OTJk7h06RJ69uyJ2rVro1atWgCAJk2aoFKlSujatSuuXbuGw4cPY8KECRg0aNBnR7J/iIlyEsT69euhpaWFM2fOIDAwEA0aNECVKlVw8eJFHDp0CC9evMCPP/4oX9/Pzw+BgYHw9/dHREQEtmzZkqtI/4eSk5MxYsQIXLx4EcePH4eamhratWsHqVT6RfHVqVMHCxcuhJGREWJiYhATE4NRo0YBAHr06IGLFy9i7969OHv2LGQyGVq0aIHMzEwAOQd4eno6Tp06hRs3bmDWrFkwKKYf2gNmTEX9+t6oVVv5PyiokqSknJGfxsbGAkdSMMT0PkxKSgIAGH6wb1zdK+PE0UN4k5gIqVSK40cOIiMjA5WrVhcqTBIZAx1NAMDrlMw8H9fVVEeHauXwOD4FMa/T5MvtSuljUKOKGL3tOqSyIgk1X+THl5Fi33f00H780KgeevzUFiuDFyAtLVWI8PItOvoRmjSoj9bNGmG87yjEKEFC8mtkZ2fj0IH9SE1NgXvlykKHU2DE0K7s7GycOHoQaampqOTmkevx1NQUHN7/OyzLlEVJiy//6TIVPrH3G4B4rnuzs7ORnZ0Nrf8ka7S1dXD1ymWBoip43F/Fn5g+e5F4LFu2DImJifD29oalpaX8tn37dvk6CxYsQKtWrdChQwd4enqidOnS2L17t/xxdXV17Nu3D+rq6qhduzZ++eUXdOvWDVOnTv2qWFijnARhb2+P2bNnAwCmT5+OKlWqYObMmfLH16xZAysrK9y+fRuWlpZYtGgRgoOD0b17dwBAxYoVUa9evY9uv0OHDgr316xZg5IlSyIiIkI+a+6naGlpwdjYGBKJRKGW0Z07d7B3716cOXMGderknFg2b94MKysr/P777+jUqROio6PRoUMHuLnl1C6rUKF41mc7dHA/bkVEYNO2nUKHQl9BKpViTuBMVK7yHezsHYQOJ9/E9D6USqUInj8Lrh5VUKGivXz5pJlzMXXcaPzQuB7U1TWgo6ODabMXopxVeQGjJbGQSIAJPzjh4oME3HmRpPBY59pWGNPSEfraGrj3Mgk9Qi4gMzsnI66lLsH8Lh6YtT8KMa/TYFVCT4jwv1jO8RUIN48qqGD3/vhq2LQlSluWgVnJkrh/5zZWBC9A9KOHmD5nkYDRfj03Nw9MmRYAaxtbxMW9xMplS9C7+y/YsWcv9PWL55ftX+rO7Sh07/IzMjLSoaunh3mLglGxop3QYeWbGNp1/+5tDO7bFRkZGdDV1cOUWQthY1tR/vgfO7dh5ZIFSEtNhZW1DWYHrYSmpqaAEdOHxNxvvCOm6159fX24e1TGqpXLYGtbESXMzHD44H7cuH5VNNeE3F/Fn5g+e5G4yGSfH7Wjo6ODJUuWYMmSJR9dx9raOt8VHZgoJ0FUrVpV/ve1a9dw8uTJPEdd37t3D69fv0Z6ejoaNmz4xdu/c+cOJk6ciPPnzyMuLk4+kjw6OvqLEuUfExkZCQ0NDdSsWVO+zMzMDI6OjoiMzKk3PGTIEAwYMABHjhxBo0aN0KFDB7i7u390m+np6UhPT1dYli3R+qqfhnyt589jMCdwJpatXFOor0MFL2D6FNy9ewfrRFCDUmzvw4WzZ+DB/btYvHK9wvI1y4ORlPQW84JDYGxiitNhJzB53CgsXrkOFeyU+0MECW9yu0qwL22In5eey/XY3isxOHMnHqUMtdHbyxaLfqmMn5acR0aWFCNbOOLey2TsvRwjQNRfb8Hs6Xhw7y4Wh2xQWP5D+07yvyvaOcDMvCSGD+yNp0+iUbac8nyQrfvBJJAOjo5wc/NAy6YNcPTwIbRt31HAyPLPxtYW23btQdLbtzh25DAmjh+LVes2Kl1S+b/E0C4ra1us3LADyclJOHXiKGZNnYD5y9bIk+UNm7VE1Rq18So+Fr9tXo+p40chaOWGXCMsSRhi7jfeEdN1LwBMnTELUyeNR/PGXlBXV4ejUyU0bdYSkZHKXabkHe6v4k1sn72ICgsT5SQIfX19+d9JSUlo3bo1Zs2alWs9S0tL3L9//6u337p1a1hbWyMkJARlypSBVCqFq6urfOJQNbWcqkMffmv1rnRKfvXp0wdNmzbF/v37ceTIEQQEBGDevHkYPHhwnusHBARgypQpCsvGTZiI8f6TCySevESGh+PVq3h0/qm9fFl2djYuX7qI7Vs34/yl61BXV//EFkgIATOm4lRYKNas3wSLr5i1ubgS0/tw4ZwZOHs6DEEr1qHUBz9Lf/rkMfbs2Iq1W/fA9t/kiZ2DI65fvYQ9O7ZhpN9EoUImEZjY1hnfO5dE56X/4Hlieq7Hk9KykJSWhUdxKbga/RoXpzZEE1cL7Lsag9p2JeBQ2hDN3HLKmEkkObN8/jO5AZaduI+gI3eLtC2fsnD2DJz9KwyLV65XOL7y4uya82uup48fK1Wi/L8MjYxQ3toGj6MfCR1KvmlqaqF8eWsAQCUXV4SH38TWTRswYdLX/Qy2uBFDuzQ1NVH235GRDk6VEBVxE7u3b8aIsTnnJgMDQxgYGKJceWs4u3qgbeO6OB12HA2atBAybPoIMfUbgPiuewGgnFV5rFyzEakpKUhOToJ5yVLwGz0cZcuVEzq0fOP+Kv7E9NlL2f172U3FFBPlJLjvvvsOu3btgo2NDTQ0cr8l7e3toauri+PHj6NPnz6f3V58fDyioqIQEhKC+vXrAwBOnz6tsE7JkiUBADExMfJJb65evaqwjpaWFrKzsxWWOTs7IysrC+fPn5eXXnn3eh/OomtlZYX+/fujf//+8PPzQ0hIyEcT5X5+fhgxYoTCsmyJ1mfbmR81atXCjt17FZZN8h8HW9sK6NGrD0+QxYxMJkPgzGk4cfwoVq3diLLlrIQOqUCI4X0ok8mwaO5MnA49gYXL1sCyrOKFc/q/tZLffTn3jrqaOmSyL5szgSgvE9s6o7GrBX5Z/g+eJHy+JrcEgAQSaGnkvBd9NlyBtsb7Y8zdyhiBP7nh52X/IDoupbDC/ioymQyL5szEX6HHsWj52lzHV17u3r4FADAzNy/s8ApVSkoynjx+jJatfxA6lAInk0rlAxfERAztksqkyPxIG2QyGWQyICOjYAaWUMETS78h1uveD+nq6UFXTw9v3iTi7NkzGDJslNAhfTPuL+Uhhs9eREWBiXIS3KBBgxASEoKff/4ZY8aMQYkSJXD37l1s27YNq1atgo6ODnx9fTFmzBhoaWmhbt26iI2NRXh4OHr37g0AaNiwIdq1awcfHx+YmprCzMwMK1euhKWlJaKjozF27FiF17Szs4OVlRUmT56MGTNm4Pbt25g3b57COjY2NkhKSsLx48fh4eEBPT092Nvbo02bNujbty9WrFgBQ0NDjB07FmXLlkWbNm0AAMOGDUPz5s3h4OCAhIQEnDx5Es7Ozh9tv7a2dq6fPqVkFO6savr6Brnqxunq6sLYxESp68mlJCcjOjpafv/pkye4FRkJY2NjWJYpI2Bk+TNz+hQcPLAPC4OWQl9fH3FxsQByRnrp6OgIHN23E8P7cOHsGTh2+ABmzF0EXT19xMfFAQAMDAygraOD8ja2KGtVHvMCpmDA0FEwMjbB6bATuPjPWQTMDxY4+q8jluMrJSUZjz9ox7OnTxB1K6cdpS3LIDHxNZ7HxCAu9iUA4NHDBwByEq/m5iUFifm/JrerhNZVLDFg3WUkp2fB3DDny9W3qVlIz5LCqoQuWnhY4vTtOLxKzkBpYx30+74C0jKzERqZ039Exysm1031c7Zx70US3qZlFW2DPmLBrOk4fvgAZswNyvP4evokGscOHUCtuvVhZGyC+3duI3jBLHhUqYaK9o4CR/91FsydBU+v72FZpgxiY19i+ZJgqKmroVnzVkKHli9BC+ahbn1PWFpaIjk5GQf378PFC/9g6YpVQoeWL2Jo16qli1Cjdl2UsrBESkoyThw5iGuXLyJw4XI8e/oEoccOoVrNOjA2MUXcyxfYumE1tLS1UbPOx+cIKi7E0M9/CbH2G2K97gWAs2dOQwYZrK1t8fjxIwQtmAsbG1v80Kad0KF9M+4v5SGGz15ERYGJchJcmTJlcObMGfj6+qJJkyZIT0+HtbU1mjVrJh+F6e/vDw0NDUycOBHPnj2DpaUl+vfvL9/GvXv3EPfvB2g1NTVs27YNQ4YMgaurKxwdHREUFARvb2/5+pqamti6dSsGDBgAd3d3VK9eHdOnT0enTu9rndapUwf9+/fHTz/9hPj4eEyaNAmTJ0/G2rVrMXToULRq1QoZGRnw9PTEgQMH5JMbZWdnY9CgQXjy5AmMjIzQrFkzLFiwoAj+kxQefhN9enaT3587OwAA8EObdpg2M1CosPJtx/atAIA+PbsqLJ8yPQBt2rbP6ylURP7YlTML97D+vRSW+06chuat2kJDQxOzFizFyiULMW6kD1JTUlG2nBX8Js1ArbqeeW2y2BLL8RUZHo7+fbrL7y+Ym1P2q+UPbTF5WgBOhZ7E1Inj5I+P9x0JAOjbfxB+HeBTtMF+RJc6OaUSNg+oqbDcd/sN7L74FOlZUlSzNUWP+tYw0tVEfFI6LtxPwE9LzuNVsvKMeH13fA3t31Nh+diJ09G8dVtoamji0j/nsHPbRqSlpqKkRWl4NmiMbr36CRFuvrx48QJ+viOR+Po1TE1LoPJ3VbF+83aYlighdGj58urVK/iP80VcbCwMDA1h7+CIpStWoVadukKHli9iaFdCwisETpmAV/Gx0DcwQIWKDghcuBzVatZGXOxL3Lh6Gbu2bULS2zcwLWEG98pVsThkA0xLmAkd+meJoZ//EmLtN8R83ZuU9BbBQQvw8sVzGBkbo0HDJhg0eBg0lHiSXO4vIhIbiexLphYloiJV2CPKhaKmJs5iXGLtRcV6ekhMFefPxt+NCBabjCxxlqip6n9E6BAKxV/+Xz7xtjIx1BHn2BLWyFQur5KU54uur2GkK86kk7pIr3vVRNpxZGWL83pDQ13t8yspIbHuL7H2G3pa4mzXt2ocfE7oEIrEUZ9aQofwTcTZaxIRERERERERERERfSEmyomIiIiIiIiIiIhIpTFRTkREREREREREREQqjYlyIiIiIiIiIiIiIlJp4pyZiIiIiIiIiIiIiKgYEemcyKLBEeVEREREREREREREpNKYKCciIiIiIiIiIiIilcZEORERERERERERERGpNNYoJyIiIiIiIiIiIipkEhYpL9Y4opyIiIiIiIiIiIiIVBoT5URERERERERERESk0pgoJyIiIiIiIiIiIiKVxkQ5EREREREREREREak0TuZJREREREREREREVMjUOJdnscYR5URERERERERERESk0pgoJyIiIiIiIiIiIiKVxkQ5EREREREREREREak01ignIiIiIiIiIiIiKmQSCYuUF2ccUU5EREREREREREREKo2JciIiIiIiIiIiIiJSaUyUExEREREREREREZFKY6KciIiIiIiIiIiIiFQaJ/MkIiIiIiIiIiIiKmScy7N444hyIiIiIiIiIiIiIlJpHFFOVByJ9BtGqVQmdAiFQ6T7S6R7Czqa6kKHQF9BpIcXjo39XugQCkXdKceEDjFZzrsAAQAASURBVKFQXJvZTOgQCoVYRzTJRHoCM9TRFDqEQiHStyGkYn0jilSWWD+nQCp0AIVCTU2sPQcRCY0jyomIiIiIiIiIiIhIpTFRTkREREREREREREQqjaVXiIiIiIiIiIiIiAqZRLRFx8SBI8qJiIiIiIiIiIiISKUxUU5EREREREREREREKo2JciIiIiIiIiIiIiJSaaxRTkRERERERERERFTI1FiivFjjiHIiIiIiIiIiIiIiUmlMlBMRERERERERERGRSmOinIiIiIiIiIiIiIhUGhPlRERERERERERERKTSOJknERERERERERERUSGTSDibZ3HGEeVEREREREREREREpNKYKCciIiIiIiIiIiIilcZEORERERERERERERGpNNYoJyIiIiIiIiIiIipkLFFevHFEORERERERERERERGpNCbKiYiIiIiIiIiIiEilMVFORERERERERERERCqNiXIiIiIiIiIiIiIiUmmczJOIiIiIiIiIiIiokKlxNs9ijSPKiT7D29sbw4YNEzoMIiIiIiIiIiIiKiQcUU6C8Pb2RuXKlbFw4UKhQ1FJv23bip3bt+LZs6cAgAp2dvi1/yDUq+8pcGQFa82qlVi8aD46/9INo33HCR3ONxPz/nr54gUWLZiLv0+fQlpaGqysymPy9Jmo5OImdGhf7Mqli9i0YQ2iIsIRFxeLWfOD4PV9I/njUyeOw4E/f1d4Tq069bBwycoijjR/Ll28gHVrViMy4iZiY2OxIGgJGjRs9PknKoHk5GQsX7IIJ08cQ8KrV3B0csbIMePg4qo878M/d2/Hvj2/4UXMMwCAtW1FdOnVDzVq18fzmKfo1qF5ns+bMH0uPBs0KcpQP6p/gwpo6maBCqUMkJ6ZjcuPXmPWvig8iE2WrzO9owvq2JvDwlgbyenZuPwwAbP3R+H+y2SFbXWoXha9PG1gW1IfSWlZOHD9OSbvjijqJn2xVs0aIObZs1zLO/3UGWPHTxQgooIh1vPX8qWLsXLZEoVlNja22P3nQYEi+jaXL13ApvVrcCsyHHGxsZg9fzG8G+T061mZmVi2ZBH+Pn0KT588gYGhAarXrA2fISNRslQpgSP/emLo5/8rOzsbK5cF4+C+PxEfHwfzkqXQuk1b9P51ACRKPlpRFa4PAeDB/XtYsmg+rly+gOysbNhWqIiAuQtR2rKMQFF/GzEeX2Lp5z9FLJ+ViQoaE+UikpGRAS0tLaHDKFKq2OaCYFHaAoOHj0R5a2tAJsP/2bvrsKiyBgzg79CthChKSqmIrasiFgrmqljL59qxBnZ3oSB2N3autbomq6KrawcqYrEqKqiEQdfM9we7owiupJe58/6eZ56HuffOnfdw58acOfecI78dwsihQ7B73wHY2tkLHa9QhNy7i/379sDewVHoKAUm1u318cMH9O7hhVq1f8Dy1ethaGiE8PBn0DcoIXS0PElKSoS9gyPatvPEhNHDclymbv0GmDpzjvy5ugIet5KSEuHo6Ij2nh0xari30HEKlc+MKQh78hiz5sxDqVKmOHb0CAb/0ge/HvgdpqVLCx0vV0xMS6PvoBEoZ2EJmUyGwGOHMWP8cKzavBcWVjbYfeRMluWP/bYPv+7cjNp1GwiUOLsfbI2w/a9w3An/AFUVCca0csCWAbXhMf9PJKVmAADuvfyI325GIOJdMkrqqGOYhx22DKiNRnOCIJVlrqdPQ2v0bWwDvyMPEBz+AdoaqjA30hawZN+2bec+ZEgz5M/DnjzG4AF90MzdQ8BUBSfW8xcA2NrZY/X6APlzVVXF+1qVnJSUef5q74nxo7Kev5KTk/Ew9D769B8EB8cK+PjxAxb5+2L0iMHYunOfQInzTwzH+S9tCdiAfXt3Y6aPL8rb2uN+yD3MmjYJenr6+Klbd6Hj5ZuyXB++fBGOX/r8jLbtO6L/oCHQ1dXD32FPoKGpKUDaghHj/gWI4zj/NWL6rkxU2Nj1igJr3LgxvL29MWLECJiYmMDDwwP37t1Dy5Ytoaenh9KlS6N79+6Ijo6Wv0YqlcLf3x92dnbQ1NSEpaUl5syZ85/vMXToUIwYMQKGhoYoXbo01q9fj4SEBPTu3Rv6+vqws7PD8eNZf1k9d+4c6tSpA01NTZiZmWHChAlIT08HAPTq1Qvnzp3D0qVLIZFIIJFI8OzZs2++7mtlBoCQkBC0adMGBgYG0NfXh6urK8LCwnD+/Hmoq6vj9evXWfKNGDECrq6u8ucXL15E48aNoaOjA0NDQ3h4eODdu3c5/k9SUlIwZswYlCtXDrq6uvjhhx8QFBQkn//8+XO0bdsWhoaG0NXVhZOTE44dO/YfW/L7a9S4KVwbNoKVlTWsrG3gPXwkdHR0cCc4WOhohSIxMQGTJozB1OmzYWBgIHScAhPr9tocsAGly5hhpo8vKjtXQTlzc9Sr3wAWFpZCR8uT+g0aYuCQ4fJWeDnR0NCAsUkp+cNAwb7sAUAD10bwHj4Sbs2aCx2lUCUnJ+PM6UAMGzkGNWrWhoWlFX4Z5A0LC0vs+3WX0PFyrV6DxqhT3xXlLKxgbmmN3gOHQVtbB6Ehd6CqqgojY5Msj4vnzqBhUw9o6+gIHV2u9/rr2H/tFR6/iceDyDiM230X5Yy0Udn803F89+UXuPb3O7x6l4SQVx+x6PhjlDXUhrlRZjkMtNUwqqUDxu66gyO3IhEek4iHkXE4HfJWqGLliqGREUxMSskff54LgrmFJWrWqiN0tAIR6/kLAFRVVbNsM0NDQ6Ej5Vn9Bg0xyHsEmjTNflzX09fHirUBaO7RElbWNnCuUg1jJ0zBg/sheB2Z/e6H4kwsx/kv3Qm+hUZNmqJBw8YoW64cmrl74Id6Lgi5d1foaAWiLNeHa1YsRf0GDTF0xBg4VqgEcwtLNGzcFEZGxt85acGIdf8CxHGcz4nYvisrIolEOR6KihXlCm7Lli3Q0NDAxYsX4efnh6ZNm6J69eq4fv06Tpw4gTdv3qBLly7y5SdOnAg/Pz9MnToV9+/fx86dO1H6G7/ybtmyBSYmJrh69SqGDh2KQYMGoXPnzqhfvz5u3rwJd3d3dO/eHYmJiQCAV69eoVWrVqhduzaCg4OxevVqbNy4ET4+PgCApUuXol69eujfvz8iIyMRGRkJCwuLb74upzKvWbMGr169QsOGDaGpqYkzZ87gxo0b6NOnD9LT09GwYUOUL18e27Ztk78+LS0NO3bsQJ8+fQAAt2/fhpubGypVqoRLly7hwoULaNu2LTIyMpATb29vXLp0Cbt378adO3fQuXNntGjRAo8fPwYADBkyBCkpKTh//jzu3r2LefPmQU9PL49b9vvJyMjAiWNHkZSUiCrVqgkdp1D4zpkFV9fGqFuvvtBRCp2Ytte5oDOoVKkyxo0aDrdG9eHVuQMO7NsrdKwicfP6NbRs2gBd2rfCvDkz8eH9e6Ej0T8yMjKQkZGRrQWXpqYWbt+6KVCqgsnIyMDZwONITk5CpcpVs81/9OA+wh4/QIu2HQRIl3v6Wpkttz4kpuU4X1tDFZ1ql0N4TCIi3ycBABo4mEBFApQ20MTJca64MLUJlnWvBrOSWt8td0GlpaXi2NHDaNfeU+G7T/icmM5fABAe/hzuTV3RtkUzTB4/BpEKVnmcH/HxcZBIJNDTV6yKFTEe5wGgStXquHblMp4/ewoAePTwAYJv3UT9Bq7feGXxpgzXh1KpFH9dOAdLS2sMH9wfLZs2QJ/uXXHu7B9CR8szse5fgHiP82L+rkxUGMRz74iSsre3h7+/PwDAx8cH1atXx9y5c+XzAwICYGFhgUePHsHMzAxLly7FihUr0LNnTwCAra0tGjT479uuq1atiilTpgD4VNFuYmKC/v37AwCmTZuG1atX486dO6hbty5WrVoFCwsLrFixAhKJBBUqVEBERATGjx+PadOmoUSJEtDQ0ICOjg7KlCkjf59vvU5FRSVbmQFg0qRJKFGiBHbv3g11dXUAgIODg3x+3759sWnTJowdOxYAcOTIESQnJ8t/QPD390etWrWwatUq+WucnJxy/F+Eh4dj06ZNCA8PR9mymX3HjRkzBidOnMCmTZswd+5chIeHo2PHjnB2zuyTrXz58v/5/xXK40cP0bObF1JTU6Cto4OFS1fA1tZO6FgFduL4UTy4fx/bdyvebcH/RYzb69XLF9i3dxe69eiFPv1/Qci9u5jvNwfq6upo2654V+DlRb36DdC4aTOULWeOVy/DsXr5Eoz0/gXrt+yEqqqq0PGUnq6uLqpUrYYN61bDxsYWRsbGOHn8KO7euQ1zBWu99jTsEYYP6I7U1FRoa+tguu8SWNnYZlvuxJEDsLQuDyfnat8/ZC5JJMCU9hVx/WksHr2OzzKvW31LjG/jCF1NNYS9jUfPtdeQlpHZ74qFsQ4kEgkGNbPF7EOhiEtKx6iW9tjyS220XnBBvlxxdvbMacTHxYnmOCjG85ezc1XMnO0LK2sbREe/xbrVK9G358/49eBh6OoW38YRBZGSkoIVSxfCvUXrYt0AJCdiOs5/rlff/khIiEendq2hoqoKaUYGBg8dgZat2wodrUCU4frwXWwMEhMTsXXTBvwyZBiGDB+FyxcvYMLo4Vi5bjNq1KotdMRcE+v+JdbjvFi/KxMVJlaUK7iaNWvK/w4ODsbZs2dzvHgNCwvD+/fvkZKSAjc3tzy9R5UqVeR/q6qqwtjYWF4JDEDeIv3t28zbmkNDQ1GvXr0sraBcXFwQHx+Ply9fwtIy5xNmbl/3eZmBzBbhrq6u8kryL/Xq1QtTpkzB5cuXUbduXWzevBldunSBrq6u/PWdO3fO1f/i7t27yMjIyFIRD2R+eTA2zrxNbtiwYRg0aBBOnTqFZs2aoWPHjln+h19KSUlBSkpKlmkZKhrQLOL+6axtbLB7/0HEx8Xhj1MnMW3yBGzYvE2hv7y+fh2J+X5zsXpdQJH//743MW4vqVSGSk5OGDp8FACgQsVKCHvyGPv27hbNFyEAaN6ilfxvO3sH2Nk7omNbD9y8fhW1f6gnYDL616w58zBr+mS0bN4IqqqqcKxQCR4tWiM0NEToaHlibmmD1Vt+RUJ8PP48G4j5PlOwYGVAlsrylJRknA08jm69BgiY9NtmejrBoYweuq64km3ebzcjcPFRNEoZaKJfYxss714NnVdcRmq6FCoSQENNBbMOhuLCo8yu50ZsD8blGU1R184Yfz6Mzra+4ua3g/tQ38UVpUwVt1/Xz4nx/OXy2WCkDo6OcHauitYeTRF48gTae3YSMFnRSE9Lw6RxIyGTyTB+8nSh4+SLWI7znws8eRwnjv4OH7/5sLW1x8OHoVjk74tSpUzRpl17oePlmzJcH0r/GVSjYeOm8Po5swGbg2NF3Am+jYP79ihURTkgzv1LjMd5MX9XJipMrChXcP9W9gJAfHw82rZti3nz5mVbzszMDH///Xe+3uPLCmiJRJJl2r8V21KpNF/rz6vPywwA2tr/PUCXqakp2rZti02bNsHGxgbHjx/P0qf4t17/ufj4eKiqquLGjRvZWoL++wNFv3794OHhgaNHj+LUqVPw9fXFwoULMXTo0BzX6evri5kzZ2aZNmnKNEyeNiPXufJDXV0DlpZWAIBKTpUREnIPu7ZvxZTps4r0fYtSaEgIYmNj8L+unvJpGRkZuHnjOvbs2oErN+4obAteMW4vk1KlUP6LihKb8rY4/ccpgRJ9H+XMLVCypCFevghnRXkxYW5hiXUB25CUmIiEhHiYlDLFxLEjUc7cXOhoeaKuro5y5pk/KjtUqIRHofdwcO8OjBg/Tb7Mn2cCkZKchGYti2+Lw+kdKqFppVL4aeUVvP6QnG1+fHI64pPT8Sw6Ebefv8fN2c3g4VwaR25F4u3HzB+en7z51Ao9NiEV7xJSUVYBul+JjHiFq5cvYf7i5UJHKTRiPH99Sd/AAJZW1ngR/lzoKIUuPS0NE8eNRGRkBFat26Rwrcn/JZbj/OeWLVqAnn37waNlawCAnYMDIiMjsGnjOoWuKFeG68OShiWhqqYG6/JZ7/qyLl8ewQrYXYkY968vieE4L+bvykSFiRXlIlKjRg3s378f1tbWUFPLvmnt7e2hra2N06dPo1+/fkWWo2LFiti/fz9kMpm8Ev3ixYvQ19eH+T8nSw0NjWx9gOfmdTmpUqUKtmzZgrS0tK+2Ku/Xrx+8vLxgbm4OW1tbuLi4ZHn96dOns1VW56R69erIyMjA27dvswwG+iULCwsMHDgQAwcOxMSJE7F+/fqvVpRPnDgRo0aNyjItQ0Xjm1kKm0wqRWpq6nd/38JUp25d/HrgcJZp06dOgo1NefTq009UJ34xbK9q1arj2T/9av7r+bNnMDMrK1Ci7+Ptm9f48OE9jE1KCR2FvqCtowNtHR18/PgBly5dxLARY4SOVCBSqRRpaVmPEyd+P4i6DRqjpKGRQKn+2/QOleDuXBrdVl3By9ikby4vQeag4Bpqmd2z3XiaORB3eVNdeSV7CW11GOpq4NW77JXuxc3hQwdgaGSMBq6NhI5SZMRw/vpSYmICXr54gdZtfxQ6SqH6t5L8RfhzrF6/BSVLKv5AdmI6zicnJ0FFknXIMVUVVchk36fxUlFRhutDdXUNVKpUGeHPs5bzxXPFLqeY9q8vieE4r0zflYs7MY1BI0YczFNEhgwZgtjYWHh5eeHatWsICwvDyZMn0bt3b2RkZEBLSwvjx4/HuHHjsHXrVoSFheHy5cvYuHGjfB1ubm5YsWJFgXIMHjwYL168wNChQ/HgwQP89ttvmD59OkaNGiXvZ9za2hpXrlzBs2fPEB0dDalUmqvX5cTb2xsfP37ETz/9hOvXr+Px48fYtm0bHj58KF/Gw8MDBgYG8PHxQe/evbO8fuLEibh27RoGDx6MO3fu4MGDB1i9ejWio7Pfnu3g4IBu3bqhR48eOHDgAJ4+fYqrV6/C19cXR48eBQCMGDECJ0+exNOnT3Hz5k2cPXsWFStW/Gp+TU1NGBgYZHkU9a1QyxYvxI3r1xDx6iUeP3qIZYsX4vq1q2il4H0a6urq/dO1xaeHtrY2SpQsCTt7h2+voJgS6/bq1qMX7t0Jxsb1axAe/hzHjx7Bgf170eWnbkJHy5PExAQ8ehiKRw9DAQARr17h0cNQvI6MQGJiApYvno97d4IREfEK165cwtiR3jC3sETd+v89PkRxk5iQgAehoXgQmlnOVy9f4kFoKCIjFH9go0sXL+Cvi3/i1cuXuHzpIgb26wVraxv8qEC3eG9cvRR3bl3H68hXeBr2SP68qXtr+TKvXobj7u0baPmj53+sSTgzPSuhfc2yGLk9GPEp6TDR14CJvgY0/6kEtzDSxsCm5VHZ3ABmJbVQw7oklveshuS0DASFRgEAnkUnIvDeG0xtVxE1rEvCoYwe5ntVQdjbeFx+EiNk8b5JKpXi8G8H0ebH9jk2eFBEYj1/LV4wDzeuXUXEq5cIvn0To4cPhYqqClq0bCN0tDxJTEzAowehePTg3/PXSzx6kHn+Sk9Lw4SxIxB6PwSz5s5HhjQD0dFRiI6OyvYDnCIQw3H+S66NmiBg/VpcOB+EiFevcPZ0IHZs24zGTZsJHa1AlOH6EAC69eyDP04ex6EDv+JF+HP8unsHLpwPgmeXn4SMnS9i3L/Ecpz/nFi/KxMVNnFchRMAoGzZsrh48SLGjx8Pd3d3pKSkwMrKCi1atJBXNE+dOhVqamqYNm0aIiIiYGZmhoEDB8rXERYWlmMFcV6UK1cOx44dw9ixY1G1alUYGRmhb9++8gFBgcwBMHv27IlKlSohKSkJT58+hbW19TdflxNjY2OcOXMGY8eORaNGmf2iVatWLUurcRUVFfTq1Qtz585Fjx49srzewcEBp06dwqRJk1CnTh1oa2vjhx9+gJeXV47vt2nTJvj4+GD06NF49eoVTExMULduXbRpk3nSzMjIwJAhQ/Dy5UsYGBigRYsWWLx4cX7/nUUiNjYWUyeNR3RUFPT09WHv4IhVazegbn2Xb7+Yvjuxbi+nys5YsGQ5VixZhPVrVqFsOXOMGTcRrdooVgVK6P0QDOnfS/586cLM7q9atW2PcZOm4cnjRzh25DfExX2ESSlT/FDPBQMGD4WGxve/c6QgQkLuoV/vT8fPBf6+AIAf23XA7Ll+QsUqFPHxcVixbDHevnkNgxIl0NTNHUOGjoDaV+5SKo7ev4vF/NlTEBsTBR1dPZS3c8DcxWtQs86n7n1O/n4QJqalUbNOfQGTft3PLpndc+wa8kOW6eN238H+a6+Qki5F7fKG6N3QGgba6oiJT8HVv9+h8/LLiIn/VHE3ZucdTG5XARv61oJUJsPVsFj0WX8d6dLiPZDnlct/4XVkBNq1L54/ZOSHWM9fb968wcTxo/Hh/XsYGhqhWo2a2LJjDwyNiuedGl8TGhKCQf17yp8v+ef81bpte/Qf6I3zQWcAAD93zVrZtXr9FtSsXef7BS0EYjjOf2nsxClYs2Ip/ObMwrvYWJiUMoVnpy7oP3Cw0NEKRBmuD6fNmovGTZth/OTp2BKwHov958LSyhq+85egWvWaX1lj8SXG/Ussx3kiyjuJTCYr3t8aiApJ3759ERUVhcOHD397YYElpol0txRpsSDSO6fEenZITVfsW5K/RltDnLdLpol0e8UmpAkdoUg0nXtG6AhFInhuC6EjFIn/uGFPoYn1/JWeIc6CqYj0Okqs14cqIu0yQKzXh2oi3cFURFoucZYK0NEQa8nyp9MmxRuLID/29a4hdIR8YYtyEr0PHz7g7t272Llzp0JUkhMREREREREREdH3xYpyEr127drh6tWrGDhwIJo3by50HCIiIiIiIiIiUkIivTFHNFhRTqIXFBQkdAQiIiIiIiIiIiIqxkTaMyERERERERERERERUe6wopyIiIiIiIiIiIiIlBq7XiEiIiIiIiIiIiIqYirspLxYY4tyIiIiIiIiIiIiIlJqrCgnIiIiIiIiIiIiIqXGinIiIiIiIiIiIiIiUmqsKCciIiIiIiIiIiIipcbBPImIiIiIiIiIiIiKGIfyLN7YopyIiIiIiIiIiIiIlBoryomIiIiIiIiIiIhIqbGinIiIiIiIiIiIiIiUGvsoJyIiIiIiIiIiIipiEgl7KS/O2KKciIiIiIiIiIiIiJQaK8qJiIiIiIiIiIiISKmxopyIiIiIiIiIiIiIlBoryomIiIiIiIiIiIhIqXEwTyIiIiIiIiIiIqIipsKxPIs1tignIiIiIiIiIiIiIqXGinIiIiIiIiIiIiIiUmqsKCciIiIiIiIiIiIipcY+yomIiIiIiIiIiIiKmETCTsqLM1aUExVDUqnQCYqGikjvYVER64lOpMXKkMqEjkB5oCrS0W4MddWFjlAkgue2EDpCkbDqv1voCEXi9hJPoSMUCWN9DaEjFAl1NXEeD2UiPS1LRXq9kSHSDaapJtIvKuI8bCA9Q5yfQ3VVkX4OiRQI90IiIiIiIiIiIiIiUmqsKCciIiIiIiIiIiIipcaKciIiIiIiIiIiIiJSauyjnIiIiIiIiIiIiKiIiXWIM7Fgi3IiIiIiIiIiIiIiUmqsKCciIiIiIiIiIiIipcaKciIiIiIiIiIiIiJSaqwoJyIiIiIiIiIiIiKlxsE8iYiIiIiIiIiIiIqYhKN5FmtsUU5ERERERERERERESo0V5URERERERERERESk1FhRTkRERERERERERERKjX2UExERERERERERERUxFXZRXqyxRTkRERERERERERERKTVWlBMRERERERERERGRUmNFOREREREREREREREpNVaUExEREREREREREZFS42CeREREREREREREREVMIuFonsVZrirKbWxs8rwhJRIJwsLC8hWKiIiIiIiIiIiIiOh7yVVFeaNGjfiLBxERERERERERERGJUq4qyjdv3lzEMYiIiIiIiIiIiIiIhME+yomIiIiIiIiIiIiKGPvrKN5U8vvCjx8/ws/PDx4eHqhevTquXr0KAIiNjcWiRYvw5MmTQgtJ4terVy+0b99e0AwzZsxAtWrVCrweiUSCQ4cOAQCePXsGiUSC27dvF3i9REREREREREREVDTyVVH+8uVLVK9eHdOmTcPLly9x584dxMfHAwCMjIywdu1aLF++vFCDkmIqrMpnKlxtWjRFzSoVsj385swSOlqB7N29C106/IgGP9REgx9qoke3rrjw53mhYxXYjevXMHTwQDRr3ABVnRxx5vQfQkcqVLt37kDL5k1Ru7ozuv3UGXfv3BE6Up7cvnkd40YMxo8ejeFS0wnnz57OMj82Jho+0yfhR4/GaFq/JkZ5D8CL8OcCpc0/sX8O/xWwYR2qO1fA/HlzhY6SJzdvXMPIoYPQsllD1K5aEUFnsm4fmUyGNSuXoYWbKxrUqYbBA3oj/PkzYcIWgCKev0a0qYQ/Zrjj+dpOeLCiA7YNd4VdGf1sy9WyM8ahCU0Rvr4znq3thCOT3KClrgoAsDDRxdK+dXBzYVu83NAZ1+e3wfgOlaGumu82L4Xu8IE96P9zR/zoVg8/utXD0P4/4+qlP7MtJ5PJMHHkIDSrVwUXz50RIGnBifV6Q6zlWrNqOWo4V8jy8GzbUuhYhSIhIQEL/eeiTYumcKlTDX16eCHk3l2hY+WJspy/Pqeo1xo5EctxQ1k+hxvXr8X/unZE/TrV0aRhPYwYNhjPnv4tdCyiYiVfV9djx45FXFwcbt++jXPnzkEmk2WZ3759e/zxhzi/QH8PqampQkcoMJlMhvT0dKFj0Fds27kPJ8/8KX+sWhcAAGjm7iFwsoIpXaY0ho4cjR1792PHnn2oU6cuRg4dgrAnj4WOViBJSYlwdHTExCnThY5S6E4cP4YF/r74ZfAQ7P71IBwdK2DQL30RExMjdLRcS0pKgp2DI0aPn5Jtnkwmw4TRwxDx6iXmLVqOTTv3oYxZWQwf1BdJSYkCpM0/MX8O/xVy7y7279sDewdHoaPkWVJSEhwcHTFu4tQc52/dtAF7dm3HxCkzsGn7Hmhr62DooP5ISUn5zkkLRhHPX/UrmGLjH4/hPusUOs47CzVVCfaNawIdDVX5MrXsjPHrmMY4ey8SzWecRLPpJ7Hhj0eQ/nONbW9mABWJBKM2XYPLxGOYsvMWejW1x5TOVYQqVjalSpVGv8EjsGrzbqzatAvVa9bBtHHD8ezvrHeZ7t+9HRKJYt90LNbrDbGWCwBs7exx6uyf8sfGrTuFjlQofGZMwZVLf2HWnHnYve83/FDPBYN/6YO3b94IHS3XlOX89S9FvtbIiViOG8ryObxx/Sq6enXD1p17sWbdJqSnpWPQgL5ISlSs7yVERSlfFeWnTp3CsGHDUKlSpRwvdMuXL48XL14UOJyyaNy4Mby9vTFixAiYmJjAw8MD9+7dQ8uWLaGnp4fSpUuje/fuiI6Olr9GKpXC398fdnZ20NTUhKWlJebMmfPV99i3bx+cnZ2hra0NY2NjNGvWDAkJCQA+dXsyc+ZMlCpVCgYGBhg4cGCWCvuUlBQMGzYMpqam0NLSQoMGDXDt2jX5/KCgIEgkEhw/fhw1a9aEpqYmtm/fjpkzZyI4OBgSiQQSieSbA8P+V4YTJ06gQYMGKFmyJIyNjdGmTRuEhYXJ56empsLb2xtmZmbQ0tKClZUVfH195fPfv3+Pfv36ydfftGlTBAcHZ8uwdu1aWFhYQEdHB126dMGHDx/k865du4bmzZvDxMQEJUqUQKNGjXDz5s3/LFNxZGhkBBOTUvLHn+eCYG5hiZq16ggdrUAaNW4K14aNYGVlDStrG3gPHwkdHR3cyWE7K5IGro3gPXwk3Jo1FzpKodu2ZRM8O3VB+w4dYWtnhynTZ0JLSwuHDuwXOlqu1XNxxYDBw9GoabNs816EP0fI3WCMmTgNFZ2cYWVtgzETpyElJQWBJ44JkDb/xPw5BIDExARMmjAGU6fPhoGBgdBx8sylQUMM8h6BJm7Zt49MJsOuHVvRp/9ANGriBnsHR8z08UN01FucO6NYDRsU8fzVZUEQdl14ioevPiLkxXt4r78CCxNdVLUxki8z5381sC7wEZb+HoqHrz7iyes4/Hb1BVLTpQCAM3cjMXTDFQTde43nUQk4cesVVh4PRZtaFkIVK5t6ro3xQ31XmFtYwdzSGn0GDoO2tg5C7326S+jJowfYt2sLxkwuvncA5IZYrzfEWi4AUFVVzXLsMDQ0FDpSgSUnJ+PM6UAMGzkGNWrWhoWlFX4Z5A0LC0vs+3WX0PFyTVnOX4DiX2vkRCzHDWX5HK5auxHt2nvCzs4ejhUqYNYcP0RGRuD+/RChoxEVG/mqKE9KSkKpUqW+Oj8uLi7fgZTVli1boKGhgYsXL8LPzw9NmzZF9erVcf36dZw4cQJv3rxBly5d5MtPnDgRfn5+mDp1Ku7fv4+dO3eidOnSOa47MjISXl5e6NOnD0JDQxEUFARPT88sdwKcPn1aPm/Xrl04cOAAZs6cKZ8/btw47N+/H1u2bMHNmzdhZ2cHDw8PxMbGZnmvCRMmwM/PD6GhoWjevDlGjx4NJycnREZGIjIyEl27dv3q/+BbGRISEjBq1Chcv34dp0+fhoqKCjp06ACpNPNL5LJly3D48GHs3bsXDx8+xI4dO2BtbS1/fefOnfH27VscP34cN27cQI0aNeDm5palDE+ePMHevXtx5MgRnDhxArdu3cLgwYPl8+Pi4tCzZ09cuHABly9fhr29PVq1aqXQn/m0tFQcO3oY7dp7KnwLr89lZGTgxLGjSEpKRBV2/1MspaWmIvR+COrWqy+fpqKigrp16+NO8C0BkxWetH9+7NPQ0JBPU1FRgYaGBu7cVrwf2cTMd84suLo2zvJ5FItXr14iJjoadX6oJ5+mp68PJ+cquHNHsb7Ifk5Rz18G2uoAgHfxmccHE31N1LIzQfTHZByf2gyhyzvg8CQ3/OBg8s31vE8oni3ZMjIycDbwOJKTk1DJuSoAIDk5CXOnT8DQMZNhZPzfZVMkYr3eEFu5wsOfw72pK9q2aIbJ48cgMjJC6EgFlpGRgYyMDGhoamaZrqmphdu3xHGNIbbzl5ivNQDxHTf+JbbP4efi4zPrMUqUKCFwEuWiIpEoxUNRqeXnRZUqVcL58+fxyy+/5Dj/0KFDqF69eoGCKRt7e3v4+/sDAHx8fFC9enXMnfupz7KAgABYWFjg0aNHMDMzw9KlS7FixQr07NkTAGBra4sGDRrkuO7IyEikp6fD09MTVlZWAABnZ+csy2hoaCAgIAA6OjpwcnLCrFmzMHbsWMyePRtJSUlYvXo1Nm/ejJYtM/vzW79+PQIDA7Fx40aMHTtWvp5Zs2ahefNPv8Lq6elBTU0NZcqU+eb/4L8yqKiooGPHjlmWDwgIQKlSpXD//n1UrlwZ4eHhsLe3R4MGDSCRSORlBYALFy7g6tWrePv2LTT/uZhcsGABDh06hH379mHAgAEAMltmbN26FeXKlQMALF++HK1bt8bChQtRpkwZNG3aNEuGdevWoWTJkjh37hzatGnzzTIWR2fPnEZ8XBzatusgdJRC8fjRQ/Ts5oXU1BRo6+hg4dIVsLW1EzoW5eDd+3fIyMiAsbFxlunGxsZ4KpK+8qysbVC6jBnWrliCsZOnQ1tbG3t2bMXbN68REx0ldDz6x4njR/Hg/n1s371P6ChFIuafO9Ky72smCv05VMTzl0QCzPm5Bi4/isKDV5l3rFmb6gEAxnVwxvRdt3A3/D26uljj4PimaDDpGP5+E59tPTameujf3AHTdt/+nvG/6e8njzBsQHekpqZCW1sHM/yWwMrGFgCwesl8ODlXhUvDJgKnLBxivd4QY7mcnati5mxfWFnbIDr6LdatXom+PX/GrwcPQ1dXT+h4+aarq4sqVathw7rVsLGxhZGxMU4eP4q7d27D3MJS6HiFQkznLzFfa4jxuPE5MX0OPyeVSjHfby6qVa8BO3sHoeMQFRv5alE+YsQI7N69G/PmzZN3SyGVSvHkyRN0794dly5dwsiRIws1qNjVrFlT/ndwcDDOnj0LPT09+aNChQoAgLCwMISGhiIlJQVubm65WnfVqlXh5uYGZ2dndO7cGevXr8e7d++yLaOjoyN/Xq9ePcTHx+PFixcICwtDWloaXFxc5PPV1dVRp04dhIaGZllPrVq18lz23GQAgMePH8PLywvly5eHgYGBvLV4eHg4gMwuZG7fvg1HR0cMGzYMp06dkq8rODgY8fHxMDY2zvJ/ffr0aZbuWywtLeWV5P9mkEqlePjwIQDgzZs36N+/P+zt7VGiRAkYGBggPj5eniE/UlJS8PHjxyyP79nX2W8H96G+iytKmeZ8R4Kisbaxwe79B7F15x507vITpk2egLCwJ99+IVERUFNXx9wFSxEe/gwtm9SHm0st3Lx+FXVdXKGiUnwG4VNmr19HYr7fXMzxWyD/IZUUgyKev+b3qIWK5Uqg/8qL8mn/tobfcuYJdv75FHefv8OUnbfwJDIO3RraZluHmaE29o5tjN+uvsC2oLBs84VkYWWDtVt+xYoNO9C2Qxf4z56C50/D8NefZ3H7xlUMHjFe6IiFRqzXG2Isl4trQzT3aAEHR0fUd3HF8lXrEB/3EYEnTwgdrcBmzZkHyGRo2bwR6teuit07t8OjRWteYxQzYr/WEONxQxn4+szEkyePMW/+YqGjEBUr+WpR/vPPP+P58+eYMmUKJk+eDABo0aIFZDIZVFRUMHfuXLRv374wc4qerq6u/O/4+Hi0bdsW8+bNy7acmZkZ/v47by0tVVVVERgYiL/++gunTp3C8uXLMXnyZFy5cgU2NjYFzv65z8tR2Nq2bQsrKyusX78eZcuWhVQqReXKleX9mNeoUQNPnz7F8ePH8ccff6BLly5o1qwZ9u3bh/j4eJiZmSEoKCjbekuWLJnrDD179kRMTAyWLl0KKysraGpqol69egUagNXX1zdLFzMAMHHyNEyaOiPf68ytyIhXuHr5EuYvXl7k7/W9qKtrwNIy826CSk6VERJyD7u2b8WU6YrdH6oYGZY0hKqqaraBO2NiYmBiIp7b8itUdMKWXQcQHxeHtPQ0GBoaoX+Pn1ChkpPQ0QhAaEgIYmNj8L+unvJpGRkZuHnjOvbs2oErN+5AVVX1P9ZQ/Bn/sz/FxMTApJSpfHpMTDQcHCsKFatAFPH8Na97TbhXK4s2c04j4l2SfPqb95l/P4z4mGX5R5EfUM5YJ8u0MiW1cWhiU1x7HI2Rm64Wfeg8UldXR7l/WrI6VKiEh6H3cGDPDmhqaiLi1Qu0c3fJsvzMSaNQuWoNLFoVIETcAhHr9YZYy/U5fQMDWFpZ40X4c6GjFJi5hSXWBWxDUmIiEhLiYVLKFBPHjkQ5c3OhoxUKsZy/xH6tIfbjhlg+h5/znTML588FIWDLdpTOxd3/RMokXxXlADB58mR0794d+/fvx5MnTyCVSmFrawtPT0+UL1++MDMqnRo1amD//v2wtraGmlr2TWRvbw9tbW2cPn0a/fr1y9U6JRIJXFxc4OLigmnTpsHKygoHDx7EqFGjAGS2uE5KSoK2tjYA4PLly9DT04OFhQVMTEzk/af/251JWloarl27hhEjRvzn+2poaCAjIyNXGf8rQ0xMDB4+fIj169fD1dUVQGZ3Kl8yMDBA165d0bVrV3Tq1AktWrRAbGwsatSogdevX0NNTS1Lv+VfCg8PR0REBMqWLSvPoKKiAkfHzFHJL168iFWrVqFVq1YAgBcvXmQZZDU/Jk6cKN8O/0qDxleWLlyHDx2AoZExGrg2+i7vJwSZVFqgHzKo6KhraKBiJSdcuXwJTd0yB8KUSqW4cuUSfvL6WeB0hU9PXx9A5gCfD0JD0G/QUIETEQDUqVsXvx44nGXa9KmTYGNTHr369FPoL67/KlfOHMYmJrh25TIcK2R+oYuPj0fI3Tvo1PkngdPlj6Kdv+Z1r4nWNc3xo+9phEcnZJkXHp2AyNhE2JnpZ5luW8YAp4M/9aNsZphZSR789B2811/BZ0PNFFsymRRpaano2X8wWv7omWVe/587YtDwsajbQDG24beI9XpDjOVKTEzAyxcv0Lrtj0JHKTTaOjrQ1tHBx48fcOnSRQwbMUboSIVCLOcvZbjW+JzYjhti+RwCmQOT+s2djTOnA7Fh0zaUMy8+g4ITFRf5rigHMrupYBcrhW/IkCFYv349vLy8MG7cOBgZGeHJkyfYvXs3NmzYAC0tLYwfPx7jxo2DhoYGXFxcEBUVhZCQEPTt2xcA4Obmhg4dOsDb2xtXrlzB6dOn4e7uDlNTU1y5cgVRUVGoWPHTr5+pqano27cvpkyZgmfPnmH69Onw9vaGiooKdHV1MWjQIIwdOxZGRkawtLSEv78/EhMT5e/3NdbW1nj69Clu374Nc3Nz6OvrQ1NTEz169EC5cuXg6+ubqwyGhoYwNjbGunXrYGZmhvDwcEyYMCHLey1atAhmZmaoXr06VFRU8Ouvv6JMmTIoWbIkmjVrhnr16qF9+/bw9/eHg4MDIiIicPToUXTo0EHeZYyWlhZ69uyJBQsW4OPHjxg2bBi6dOki72Pd3t4e27ZtQ61atfDx40eMHTtWXrGfX5qamtluwYtPKfpvv1KpFId/O4g2P7bP8QcZRbRs8UK4uDaEmZkZEhIScPzo77h+7SpWrd0gdLQCSUxIyNK9z6uXL/EgNBQlSpSA2T8/6iiq7j17Y+qk8XByqozKzlWwfdsWJCUloX0Hz2+/uJjI/ML9aftERLzEo4ehMDAogTJmZXEm8CRKGhqidBkz/P3kMZYs8IVr46b4oZ7Lf6y1+BHr51BXVy9bv4za2tooUbKkQvXXmJiYgBefbZ+IVy/x8EHm9iljVhZe3XogYP0aWFhZoVw5c6xZuQwmpUzRqGkzAVPnj6Kdv+b3rIWOda3w85LziE9Oh2kJLQDAx8Q0JKdlNiZYfvwBJnSojHvh73Hv+Tv85GoDezN99F6eeRehmaE2fpvohpcxCZi++xZMDD5dN7z9kPz9C5WDDauWok49F5iWMUNiQgLOnDqO4JvX4bdkDYyMTXIcwNO0tBnMyipey1exXm+ItVyLF8xDw0ZNYFa2LKKi3mLNyhVQUVVBi5aKOb7Q5y5dvAAZZLCyssGLF8+xbPECWFvb4EcFGrtBGc5fYrnWyIlYjhvK8DkEgLk+M3H82O9YsmwVdHV1Ef1PH+t6evrQ0tISOJ3yUOBxLpVCgb5d3Lt3D8eOHcOzZ88AADY2NmjRokW2gSIpb8qWLYuLFy9i/PjxcHd3R0pKCqysrNCiRQt5f3NTp06Fmpoapk2bhoiICJiZmWHgwIHydYSFhclbOhsYGOD8+fNYsmQJPn78CCsrKyxcuFA+MCeQWbFub2+Phg0bIiUlBV5eXpgxY4Z8vp+fH6RSKbp37464uDjUqlULJ0+ehKGh4X+WpWPHjjhw4ACaNGmC9+/fY9OmTejVqxfCw8Oz9Z33XxlUVFSwe/duDBs2DJUrV4ajoyOWLVuGxo0by1+vr68Pf39/PH78GKqqqqhduzaOHTsmf59jx45h8uTJ6N27N6KiolCmTBk0bNgQpUt/6tvUzs4Onp6eaNWqFWJjY9GmTRusWrVKPn/jxo0YMGAAatSoAQsLC8ydOxdjxihmi40rl//C68gItGuvOBWS3xIbG4upk8YjOioKevr6sHdwxKq1G1C3vmJVSH4pJOQe+vXuIX++wD/zB6Yf23XA7Ll+QsUqFC1atsK72FisWrEM0dFRcKxQEavWbpDf4qgIHtwPwdBfesufL1+UOTBzyzbtMGXmXMRER2H5Yn/ExkTD2KQUWrT+Eb37D/za6ootMX8OxSA0JAQD+/WUP1+8ILP7ttY/tseM2b7o0bsfkpKSMHfWdMTHfUTV6jWwbNU6hewrVdHOX33c7AEARyZn/TLtve4ydl14CgBYe/IhtNRVMOd/1VFSTxMh4e/Q0f8snr3NHMizsVMZ2JbRh20Zfdxb2j7Leox77Cr6QuTC+3exmDdrCmJjoqCrpwcbWwf4LVmDmnXqCR2t0In1ekOs5Xrz5g0mjh+ND+/fw9DQCNVq1MSWHXtgaGQkdLQCi4+Pw4pli/H2zWsYlCiBpm7uGDJ0BNTU1YWOlmvKdP4SI7EcN5Tlc/jrnsxrhn69u2eZPtPHV2Guq4iKmkQmy/uNmykpKfjll1+wbds2eb/kQGYLH4lEgm7dumHDhg3Q0Pg+3UdQwfTq1Qvv37/HoUOHhI5C//geLcqFINZxhVT4k7BCiU9OFzpCkdDTKv4ta/NDKhXn8TBdpOUS6/HQqv9uoSMUidtLxPml2Fif30EUiSJ0I5QfYj1/ibNUgJqKOM9fEGmx0jPE+UlUVxXnF2Ztxfnt7rvov/ee0BG+i/VdKgsdIV/ytReOHz8eW7duxaBBgxAaGork5GSkpKQgNDQUAwcOxPbt2zFu3LjCzkpEREREREREREREVOjy1fxs+/bt6N69O1asWJFluqOjI1auXImPHz9i+/btWLJkSWFkJCIiIiIiIiIiIlJoEpHegSkW+aooT0tLQ926db86v379+jhy5Ei+Q9H3tXnzZqEjEBEREREREREREQkmX12veHh44OTJk1+df+LECbi7u+c7FBERERERERERERHR95KrFuWxsbFZns+ePRtdunSBp6cnhgwZAjs7OwDA48ePsXLlSjx//hx79uwp/LRERERERERERERERIUsVxXlJiYm2frQkclkuHv3Ln777bds0wHAyckJ6enphRSTiIiIiIiIiIiIiKho5KqifNq0aexsnoiIiIiIiIiIiCifWL1avOWqonzGjBlFHIOIiIiIiIiIiIiISBj5GsyTiIiIiIiIiIiIiEgsctWi/GsuXryImzdv4sOHD5BKpVnmSSQSTJ06tUDhiIiIiIiIiIiIiIiKWr4qymNjY9G6dWtcvXoVMpkMEolEPojnv3+zopyIiIiIiIiIiIgokwo7KS/W8tX1ytixY3Hnzh3s3LkTf//9N2QyGU6ePIlHjx5h4MCBqFatGiIiIgo7KxERERERERERERFRoctXRfmxY8fwyy+/oGvXrtDX189ckYoK7OzssHLlSlhbW2PEiBGFmZOIiIiIiIiIiIiIqEjkq6L8/fv3cHJyAgDo6ekBAOLj4+Xz3d3dcfLkyUKIR0RERERERERERERUtPJVUV62bFm8fv0aAKCpqQlTU1MEBwfL57969QoS9rlDRERERERERERERAogX4N5NmzYEIGBgZg8eTIAoGvXrvD394eqqiqkUimWLFkCDw+PQg1KREREREREREREpKjYrrh4y1dF+ahRoxAYGIiUlBRoampixowZCAkJwdSpUwFkVqQvW7asUIMSERERERERERERERWFfFWUOzs7w9nZWf7c0NAQf/zxB96/fw9VVVX5AJ9ERERERERERERERMVdvvoo/5qSJUtCX18fO3fuhLu7e2GumoiIiIiIiIiIiIioSOSrRfm3PH36FKdPny6KVRMREREREREREREpHAk7KS/WCrVFORERERERERERERGRomFFOREREREREREREREpNVaUExEREREREREREZFSY0U5ERERERERERERESm1XA/mWaVKlVyv9O3bt/kKQ0SZVEQ6toMKB62gYkBTjb8RKxIVkR4QVYUOUERURbq9bizuIHSEIuHgNlroCEUi9uoKoSMUCbFeRkkhEzpCkVAX6fWGVCrO7SXW6w2pTJzbS6zXG6QcxHl2EI9cV5QbGRnlemRWY2NjVKxYMd+hiIiIiIiIiIiIiIi+l1xXlAcFBRVhDCIiIiIiIiIiIiIiYbDFPxEREREREREREREpNVaUExEREREREREREZFSy3XXK0RERERERERERESUP7kd/5GEwRblRERERERERERERKTUWFFOREREREREREREREqNFeVEREREREREREREpNQK1Ef5q1evcP78ebx9+xYdO3aEubk5MjIy8OHDB5QoUQKqqqqFlZOIiIiIiIiIiIhIYamwi/JiLV8tymUyGUaNGgUbGxt069YNo0aNwqNHjwAA8fHxsLa2xvLlyws1KBERERERERERERFRUchXRfn8+fOxdOlSjBkzBoGBgZDJZPJ5JUqUgKenJ/bv319oIYmIiIiIiIiIiIiIikq+KsrXr1+PHj16YO7cuahWrVq2+VWqVJG3MCciIiIiIiIiIiIiKs7yVVH+4sUL1K9f/6vzdXV18fHjx3yHIiIiIiIiIiIiIiL6XvI1mKepqSlevHjx1fk3btyApaVlvkMRERERERERERERiQkH8yze8tWi3NPTE2vWrMHff/8tnyaRZG7pU6dOYfPmzejcuXPhJCQiIiIiIiIiIiIiKkL5qiifOXMmzMzMUK1aNfTo0QMSiQTz5s1DgwYN0LJlS1SpUgWTJk0q7KxERERERERERERERIUuXxXlJUqUwOXLlzFu3Di8evUKWlpaOHfuHN6/f4/p06fjzz//hI6OTmFnJSIiIiIiIiIiIiIqdPnqoxwAtLW1MWXKFEyZMqUw8xARERERERERERGJzr9dV1PxlK8W5UREREREREREREREYpGvFuV9+vT55jISiQQbN27Mz+qJiIiIiIiIiIiIiL6bfFWUnzlzJtutAhkZGYiMjERGRgZKlSoFXV3dQglIRERERERERERERFSU8lVR/uzZsxynp6WlYe3atViyZAkCAwMLkosom169euH9+/c4dOhQkb1H48aNUa1aNSxZsqTI3oOIiIiIiIiIiIiKl0Lto1xdXR3e3t5wd3eHt7d3Ya6aRGzGjBmoVq2a0DGUWsCGdajuXAHz580VOkqh2L1zB1o2b4ra1Z3R7afOuHvnjtCRCuTG9WsYOnggmjVugKpOjjhz+g+hIxUKsZYLABISErDQfy7atGgKlzrV0KeHF0Lu3RU6VqHg/qUY1qxajhrOFbI8PNu2FDpWgYlhex05sBcDu3dCh2b10aFZfYzo3x3XLl2Qz4+NiYb/zEn4qU1T/Nj0Bwzp1RV/ni1+5ezfuQGu7pmIN3/Ox5s/5yNoy2i4u1SSz+/j6YKT64fjzZ/zkXRrBUroaWd5vWtNeyTdWpHjo2Yly+9dnDzZuH4t/te1I+rXqY4mDethxLDBePb0b6FjFZgY9q+c7N29C106/IgGP9REgx9qoke3rrjw53mhYxWYWLfX58T0HUWs20us+5dYr6PEev5SNCoS5XgoqiIZzLNq1ao4f17xD47FWWpqqtARCkwmkyE9PV3oGEov5N5d7N+3B/YOjkJHKRQnjh/DAn9f/DJ4CHb/ehCOjhUw6Je+iImJETpaviUlJcLR0RETp0wXOkqhEmu5AMBnxhRcufQXZs2Zh937fsMP9Vww+Jc+ePvmjdDRCoT7l2KxtbPHqbN/yh8bt+4UOlKBiWF7lTI1RZ9Bw7Fi0y4sD9iJqjXrYMb44Xj29xMAwPxZk/Ei/Blm+C/F2m374dLIDXOnjsWTh6ECJ8/q1Zv3mLr8N9Tv5g+XbvMRdPURfl08ABXLlwEA6GipI/Cv+5gfcCrH118O/hvWzSZmeQQcuIinL6Nx43749yxKnt24fhVdvbph6869WLNuE9LT0jFoQF8kJSYKHa1AxLB/5aR0mdIYOnI0duzdjx179qFOnboYOXQIwp48FjpagYh1e/1LbN9RxLq9xLp/AeK8jhLr+YuoMBVJRXlgYCB0dHSKYtVKq3HjxvD29saIESNgYmICDw8P3Lt3Dy1btoSenh5Kly6N7t27Izo6Wv4aqVQKf39/2NnZQVNTE5aWlpgzZ85X32Pfvn1wdnaGtrY2jI2N0axZMyQkJADI7Pakffv2mDlzJkqVKgUDAwMMHDgwS4V9SkoKhg0bBlNTU2hpaaFBgwa4du2afH5QUBAkEgmOHz+OmjVrQlNTE9u3b8fMmTMRHBwMiUQCiUSCzZs3/+f/YsGCBTAzM4OxsTGGDBmCtLQ0+bx3796hR48eMDQ0hI6ODlq2bInHj7OepC9evIjGjRtDR0cHhoaG8PDwwLt373J8r6NHj6JEiRLYsWMHAODFixfo0qULSpYsCSMjI7Rr107eFdH58+ehrq6O169fZ1nHiBEj4Orq+p9lEkpiYgImTRiDqdNnw8DAQOg4hWLblk3w7NQF7Tt0hK2dHaZMnwktLS0cOrBf6Gj51sC1EbyHj4Rbs+ZCRylUYi1XcnIyzpwOxLCRY1CjZm1YWFrhl0HesLCwxL5fdwkdr0C4fykWVVVVmJiUkj8MDQ2FjlRgYthedRs0Rp36rihnYQVzS2v0HjgUWto6eBCSeXfG/XvBaNfJCxUqOcOsnDn+13sAdPX08biYVZQfO38PJy/cR1h4FJ6Ev8WMlUcQn5iCOlVsAAArdgZhwaZAXLnzLMfXp6Vn4E1MnPwR8yEBbRpXwdbDl79jKfJn1dqNaNfeE3Z29nCsUAGz5vghMjIC9++HCB2tQMSwf+WkUeOmcG3YCFZW1rCytoH38JHQ0dHBneBgoaMViFi3FyDO7yhi3V5i3b8AcV5HifX8RVSY8lVRPmvWrBwfo0aNQq1atXDgwAH07du3sLMqvS1btkBDQwMXL16En58fmjZtiurVq+P69es4ceIE3rx5gy5dusiXnzhxIvz8/DB16lTcv38fO3fuROnSpXNcd2RkJLy8vNCnTx+EhoYiKCgInp6ekMlk8mVOnz4tn7dr1y4cOHAAM2fOlM8fN24c9u/fjy1btuDmzZuws7ODh4cHYmNjs7zXhAkT4Ofnh9DQUDRv3hyjR4+Gk5MTIiMjERkZia5du371f3D27FmEhYXh7Nmz2LJlCzZv3pylYr1Xr164fv06Dh8+jEuXLkEmk6FVq1byyvTbt2/Dzc0NlSpVwqVLl3DhwgW0bdsWGRkZ2d5r586d8PLywo4dO9CtWzekpaXBw8MD+vr6+PPPP3Hx4kXo6emhRYsWSE1NRcOGDVG+fHls27ZNvo60tDTs2LEDffr0+WqZhOQ7ZxZcXRujbr36QkcpFGmpqQi9H5KlPCoqKqhbtz7uBN8SMBkpk4yMDGRkZEBDUzPLdE1NLdy+dVOgVAXH/UvxhIc/h3tTV7Rt0QyTx49BZGSE0JHoCxkZGQgKPI6U5CRUrFwVAFCpclWcO30SHz9+gFQqRVDgcaSmpqBKjVoCp/06FRUJOnvUhK62Bq7ceZqvdbRpVAXGJXSx7bfiX1H+pfj4OABAiRIlBE5C35KRkYETx44iKSkRVdj1Y7Eltu8oykJs+5cyXEfx/EWUXb4G85wxY0aO0w0NDWFra4s1a9agf//+BclFObC3t4e/vz8AwMfHB9WrV8fcuZ/6awsICICFhQUePXoEMzMzLF26FCtWrEDPnj0BALa2tmjQoEGO646MjER6ejo8PT1hZWUFAHB2ds6yjIaGBgICAqCjowMnJyfMmjULY8eOxezZs5GUlITVq1dj8+bNaNkys++u9evXIzAwEBs3bsTYsWPl65k1axaaN//0S7qenh7U1NRQpkyZb/4PDA0NsWLFCqiqqqJChQpo3bo1Tp8+jf79++Px48c4fPgwLl68iPr1My+qduzYAQsLCxw6dAidO3eGv78/atWqhVWrVsnX6eTklO19Vq5cicmTJ+PIkSNo1KgRAGDPnj2QSqXYsGEDJJLMDpc2bdqEkiVLIigoCO7u7ujbty82bdokL++RI0eQnJyc5QeM4uLE8aN4cP8+tu/eJ3SUQvPu/TtkZGTA2Ng4y3RjY2M8Zd9r9J3o6uqiStVq2LBuNWxsbGFkbIyTx4/i7p3bMLco3v3u/hfuX4rF2bkqZs72hZW1DaKj32Ld6pXo2/Nn/HrwMHR19YSOp/Sehj3GiAHdkZqaCm1tHUzzXQwrG1sAwGSf+Zg7dRw6t2gIVVU1aGppYbrvYpQzL37HDye7sgjaMhpaGmqIT0pB19Hr8eDv199+YQ56tq+HwEuhePX2feGGLGJSqRTz/eaiWvUasLN3EDoOfcXjRw/Rs5sXUlNToK2jg4VLV8DW1k7oWJQDMX5HETsx7l/KcB3F85dwJArcf3dROX/+PObPn48bN24gMjISBw8eRPv27eXze/XqhS1btmR5jYeHB06cOCF/Hhsbi6FDh+LIkSNQUVFBx44dsXTpUujp5W2fzVdFuVQqzc/LqIBq1qwp/zs4OBhnz57NcYOHhYXh/fv3SElJgZubW67WXbVqVbi5ucHZ2RkeHh5wd3dHp06dstxeVLVq1Sxd6tSrVw/x8fF48eIFPnz4gLS0NLi4uMjnq6uro06dOggNzXqrcK1a+W8R5eTkBFVVVflzMzMz3L2bOUBeaGgo1NTU8MMPP8jnGxsbw9HRUZ7h9u3b6Ny583++x759+/D27VtcvHgRtWvXlk8PDg7GkydPoK+vn2X55ORkhIWFAcjceadMmYLLly+jbt262Lx5M7p06QJdXd2vvl9KSgpSUlKyTMuQaEDzi9aohen160jM95uL1esCivR9iJTVrDnzMGv6ZLRs3giqqqpwrFAJHi1aIzSUtzXS9+Hi2lD+t4OjI5ydq6K1R1MEnjyB9p6dBExGAGBuaY1VW/YiMT4ef54NxAKfqZi/ciOsbGyxZf1KxMfHwW/ZOhiUKIlL589iztRxWLh6E2xs7YWOnsWjZ2/ww0++KKGnjQ7NqmP9rO5w77c0z5Xl5UxLonm9ivh5fEARJS06vj4z8eTJY2wWQd+1YmZtY4Pd+w8iPi4Of5w6iWmTJ2DD5m0KX5knNvyOopjEuH8pw3UUz19UnCQkJKBq1aro06cPPD09c1ymRYsW2LRpk/z5l+eJbt26ITIyEoGBgUhLS0Pv3r0xYMAA7NyZt894nivKk5KSMHnyZDRp0gRt27bN68upAD6vbI2Pj0fbtm0xb968bMuZmZnh77/z1rpPVVUVgYGB+Ouvv3Dq1CksX74ckydPxpUrV2BjY1Pg7J/7r0rjb1FXV8/yXCKR5OmHG21t7W8uU716ddy8eRMBAQGoVauWvPV4fHw8atasKe+v/HOlSpUCAJiamqJt27bYtGkTbGxscPz4cQQFBf3n+/n6+mbpwgYAJk2ZhslTZ+SuUPkQGhKC2NgY/K/rpwNQRkYGbt64jj27duDKjTtZfpBQFIYlDaGqqpptYMGYmBiYmJgIlIqUkbmFJdYFbENSYiISEuJhUsoUE8eORDlzc6Gj5Rv3L8Wmb2AASytrvAh/LnQUQub1zL8txO0rVMLD0BAc2rsDnbv1xuF9u7F2+35Yl8+sYLC1d8Td4Js4vH83ho+bKmTsbNLSM/D3i8zxcW6FvkBNJ0sM8WqMoXN252k93dvVRcyHBPx+7k5RxCwyvnNm4fy5IARs2Y7SubgzkoSjrq4BS8vMu2YrOVVGSMg97Nq+FVOmzxI4GX1OrN9RxE4Z9i+xXUfx/EXFTcuWLeW9U3yNpqbmV3uiCA0NxYkTJ3Dt2jV549zly5ejVatWWLBgAcqWLZvrLHnuo1xbWxtr167Fmzdv8vpSKkQ1atRASEgIrK2tYWdnl+Whq6sLe3t7aGtr4/Tp07lep0QigYuLC2bOnIlbt25BQ0MDBw8elM8PDg5GUlKS/Pnly5ehp6cHCwsL2NrayvtP/1daWhquXbuGSpUq/ef7amho5NhHeF5VrFgR6enpuHLlinxaTEwMHj58KM9QpUqVb/5PbG1tcfbsWfz2228YOnSofHqNGjXw+PFjmJqaZvuff96nV79+/bBnzx6sW7cOtra2WVrZ52TixIn48OFDlseYcRPz8y/ItTp16+LXA4ex+9eD8kclp8po1botdv96UGEvQNU1NFCxkhOuXL4knyaVSnHlyiVUqVpdwGSkrLR1dGBSyhQfP37ApUsX0ahx7u7yKY64fym2xMQEvHzxAib//LBLxYtMKkVaWhpSUpIBZPb//zlVFRXIpLKcXlqsqEgk0NTI+w2rPX6si52/X0V6umLctSqTyeA7ZxbOnA7EuoAtKGduIXQkyiOZVIrU1FShY9AXxPodRdmIcf8Sy3UUz1/0PaWkpODjx49ZHl/2ppAXQUFBMDU1haOjIwYNGpSlAdelS5dQsmTJLD1YNGvWDCoqKlnqCHMjX12v1KxZE/fu3cvPS6mQDBkyBOvXr4eXlxfGjRsHIyMjPHnyBLt378aGDRugpaWF8ePHY9y4cdDQ0ICLiwuioqIQEhIiH2jVzc0NHTp0gLe3N65cuYLTp0/D3d0dpqamuHLlCqKiolCxYkX5e6ampqJv376YMmUKnj17hunTp8Pb2xsqKirQ1dXFoEGDMHbsWBgZGcHS0hL+/v5ITEz85sCu1tbWePr0KW7fvg1zc3Po6+tDU1MTPXr0QLly5eDr65ur/4m9vT3atWuH/v37Y+3atdDX18eECRNQrlw5tGvXDkBmpbSzszMGDx6MgQMHQkNDA2fPnkXnzp2ztIh0cHDA2bNn0bhxY6ipqWHJkiXo1q0b5s+fj3bt2mHWrFkwNzfH8+fPceDAAYwbNw7m/7QU9fDwgIGBAXx8fDBr1rd/RdfU1Mx2y0hiatF+GdbV1cvWD5m2tjZKlCyp8P2Tde/ZG1MnjYeTU2VUdq6C7du2ICkpCe075Hz7jiJITEhAeHi4/Pmrly/xIDQUJUqUgFkefhktbsRaLgC4dPECZJDBysoGL148x7LFC2BtbYMf23UQOlqBcP9SHIsXzEPDRk1gVrYsoqLeYs3KFVBRVUGLlm2EjlYgYtheAauXonbdBihVpgySEhNx9tQx3Ll1HXMWr4aFlTXKmlti6bzZ6D90FAwMSuKv82dw89plzJq/XOjoWcwa+iNOXgzBi8h30NfVQteWtdCwlj3aDs4cB6a0sT5KGxvA1jLz+qqyfVnEJSTjxet3ePcxUb6exnUcYGNugk0H/xKkHPkx12cmjh/7HUuWrYKuri6io6MAAHp6+tDS0hI4Xf6JYf/KybLFC+Hi2hBmZmZISEjA8aO/4/q1q1i1doPQ0QpEjNtLzN9RxLi9APHuX2K9jhLr+YuKp5x6T5g+ffpXx738Ly1atICnpydsbGwQFhaGSZMmoWXLlrh06RJUVVXx+vVrmJqaZnmNmpoajIyM8Pp13roEzFdF+ZIlS9CqVStUrlwZvXr1gppavlZDBVC2bFlcvHgR48ePh7u7O1JSUmBlZYUWLVrIWyFNnToVampqmDZtGiIiImBmZoaBAwfK1xEWFobo6MzbZQ0MDHD+/HksWbIEHz9+hJWVFRYuXJjl1gc3NzfY29ujYcOGSElJgZeXV5YPuJ+fH6RSKbp37464uDjUqlULJ0+ezNLPeU46duyIAwcOoEmTJnj//j02bdqEXr16ITw8PFuLqm/ZtGkThg8fjjZt2iA1NRUNGzbEsWPH5F22ODg44NSpU5g0aRLq1KkDbW1t/PDDD/Dy8sq2LkdHR5w5cwaNGzeGqqoqFi5ciPPnz2P8+PHw9PREXFwcypUrBzc3NxgYGMhfp6Kigl69emHu3Lno0aNHnvJTwbVo2QrvYmOxasUyREdHwbFCRaxauwHGCtw1REjIPfTr/emztMA/88ejH9t1wOy5fkLFKjCxlgvIHEF+xbLFePvmNQxKlEBTN3cMGToCal90H6VouH8pjjdv3mDi+NH48P49DA2NUK1GTWzZsQeGRkZCRysQMWyv9+9iMX/2FMTGREFHVw82dg6Ys3g1atapBwDwWbgCG1cvxfSxw5CUlIiy5pYYM2U26tR3FTh5VqWM9LBxdg+UMTHAh/hk3Hv8Cm0Hr8KZKw8AAP06uWLKwFby5f8IGAkA6D9tG7Yf+dSyp1f7+rh0OwyPninO3aq/7tkFAOjXu3uW6TN9fNGuveL+cCiG/SsnsbGxmDppPKKjoqCnrw97B0esWrsBdev/912fxZ1Yt5dYiXV7iXX/Eut1lFjPX4pGRUlG85w4cSJGjRqVZVp+x5/46aef5H87OzujSpUqsLW1RVBQUK7HZswtiUwmy1XT1fPnz6NixYooVaoUnJ2dERMTgzdv3kBTUxPlypXL1vezRCJBcHBwoYYl4fTq1Qvv37/HoUOHhI6iEPr27YuoqCgcPnw4X68v6hblQlFRUY4TAhVvaQpya39eqavluTc1ElCGAnSjkR+qIj3Ov/6QLHSEIlGx2RihIxSJ2KsrhI5QJMT6vVqau6+jCkesFSFSkZ6/xPo9Raz7l0iLJdrjhrZitxUqdBOOPRI6wnfh1yp/dwJJJBIcPHgQ7du3/8/lSpUqBR8fH/zyyy8ICAjA6NGj8e7dO/n89PR0aGlp4ddff0WHDrm/szvXTcGbNGmC7du3w8vLC8bGxjAxMYGjo2Ou34hIGXz48AF3797Fzp07811JTkRERERERERERNm9fPkSMTExMDMzAwDUq1cP79+/x40bN1CzZk0AwJkzZyCVSvHDDz/kad25riiXyWT4t/F5UFBQnt6ESFm0a9cOV69excCBA9G8eXOh4xARERERERERERVb8fHxePLkifz5v+MYGhkZwcjICDNnzkTHjh1RpkwZhIWFYdy4cbCzs4OHhwcAoGLFimjRogX69++PNWvWIC0tDd7e3vjpp59QNo/jQLBzccqVzZs3Cx1BIfBHJCIiIiIiIiIioty5fv06mjRpIn/+b9/mPXv2xOrVq3Hnzh1s2bIF79+/R9myZeHu7o7Zs2dn6fN8x44d8Pb2hpubG1RUVNCxY0csW7Ysz1nyVFEuEWl/SURERERERERERERFiSNLZde4cWP81xCaJ0+e/OY6jIyMsHPnzgJnydP2+fnnn6Gqqpqrh5oaG6sTERERERERERERUfGXp9rsZs2awcEhf6OWEhEREREREREREREVR3mqKO/Zsyf+97//FVUWIiIiIiIiIiIiIqLvjv2jEBERERERERERERUxDv9YvLEPeSIiIiIiIiIiIiJSaqwoJyIiIiIiIiIiIiKlluuuV6RSaVHmICIiIiIiIiIiIiISBFuUExEREREREREREZFS42CeREREREREREREREVMhaN5FmtsUU5ERERERERERERESo0V5URERERERERERESk1FhRTkRERERERERERERKjX2UExERERERERERERUxdlFevLFFOREREREREREREREpNVaUExEREREREREREZFSY0U5ERERERERERERESk1VpQTERERERERERERkVLjYJ5ERERERERERERERUyFg3kWa2xRTkRERERERERERERKjRXlRERERERERERERKTUWFFOREREREREREREREqNfZQTFUMyoQMUkQypOEumImEnY4okOV0qdIQiocrO7hSKWLeXTJyHeZgaaAodoUjEXl0hdIQiUWH0EaEjFImrPi2EjlAktDVUhY5QJER6mBetuMQ0oSMUCR1Nce5fKWnivJ4X6/YCeED8HOsPije2KCciIiIiIiIiIiIipcaKciIiIiIiIiIiIiJSaqwoJyIiIiIiIiIiIiKlxopyIiIiIiIiIiIiIlJqHMyTiIiIiIiIiIiIqIhxLM/ijS3KiYiIiIiIiIiIiEipsaKciIiIiIiIiIiIiJQaK8qJiIiIiIiIiIiISKmxopyIiIiIiIiIiIiIlBoH8yQiIiIiIiIiIiIqYioczLNYY4tyIiIiIiIiIiIiIlJqrCgnIiIiIiIiIiIiIqXGinIiIiIiIiIiIiIiUmrso5yIiIiIiIiIiIioiEnATsqLM7YoJyIiIiIiIiIiIiKlxopyIiIiIiIiIiIiIlJqrCgnIiIiIiIiIiIiIqXGinIiIiIiIiIiIiIiUmoczJOIiIiIiIiIiIioiKlwLM9ijS3KiYiIiIiIiIiIiEipsaKciIiIiIiIiIiIiJQaK8pJ4UkkEhw6dEjoGERERERERERERKSg2Ec5KbzIyEgYGhoKHSOboKAgNGnSBO/evUPJkiWFjpPN2zdvsHTxAvx14TySk5NhYWGJGT5zUcnJWehoBSLGcm1cvxan/ziFZ0//hqaWFqpWq44RI8fA2qa80NEKRAzl2hawHufOBuL5s6fQ1NSCc5VqGDRsFCytbeTLpKSkYMVif5w+dRxpqamoU88FoydMhZGxiYDJCy5gwzosX7oI//u5B8aOnyR0nEIjlnLduH4NmwM2IvT+PURFRWHxspVo6tZM6FgFJobjRk727t6FfXt2ISLiFQCgvJ0dBgwcggauDQVOVjCKuL0GN7dDiypmsC2th+S0DNx4+g5+h+/j77cJOS6/ZeAPaFzJFP3XX8Opu68BABXLGmBQczvULm8EI10NvIxNxPaLz7Hp3NPvWZT/tH3Tepw/+weeP888f1WuUg0DvUdmOX/9SyaTYdzwQbhy6QLmzF8K18ZuAiTOvZs3rmHb5gA8CA1BdFQU5i9ejsZNPx3/ZDIZ1q5ajkMHfkV8XByqVKuOCZOnw9LKWrjQ+dCmRVNERkRkm9656/8wYfI0ARIVDjGUS8z715cyMjKwbvUKHP/9CGJiomFSyhRt27VH3wGDIJEoTkfMt29ex86tAXgQeh8x0VHwXbAMDZt82haxMdFYtWwRrl7+C/FxcahWoyZGjpsMC0srAVPnnVivNxQN+ygv3tiinBRemTJloKmpWWjrS0tLK7R1FVcfP3xA7x5eUFNTw/LV67Hv0FGMHDse+gYlhI5WIGIt143rV9HVqxu27tyLNes2IT0tHYMG9EVSYqLQ0QpEDOW6dfMaPDt7Ye3mXVi8aj3S09Mxckh/JCV9KsPyhfNw8XwQZvstwvL1WxAdFYXJY4cLmLrgQu7dxf59e2Dv4Ch0lEIlpnIlJSXC0dERE6dMFzpKoRLDcSMnpcuUxtCRo7Fj737s2LMPderUxcihQxD25LHQ0QpEEbfXD3bG2PrnU7Rf9Cd+XnkZ6qoSbBtcF9oaqtmW7du4PGQyWbbpzpYlEBOXghHbbqGZbxBWnHqM8W0roqer9XcoQe7cvnkdHTp7YU3ATixasQ7p6WkYPXRAlvPXv37dtQ1QoAqvpKQkODg6YtzEqTnO37ppA/bs2o6JU2Zg0/Y90NbWwdBB/ZGSkvKdkxbMtp37cPLMn/LHqnUBAIBm7h4CJysYMZRLzPvXl7YEbMC+vbsxbtIU/HroKIaOGI2tmzZiz87tQkfLk6SkJNg5OGL0+CnZ5slkMkwYPQwRr15i3qLl2LRzH8qYlcXwQX1z3KbFmVivN4gKEyvKqdjYt28fnJ2doa2tDWNjYzRr1gwJCZmtdwICAuDk5ARNTU2YmZnB29tb/rpvdb0ilUrh7+8POzs7aGpqwtLSEnPmzAEAPHv2DBKJBHv27EGjRo2gpaWFdevWwcDAAPv27cuynkOHDkFXVxdxcXHy1+3evRv169eHlpYWKleujHPnzsnX26RJEwCAoaEhJBIJevXqVYj/rYLZHLABpcuYYaaPLyo7V0E5c3PUq98AFhaWQkcrELGWa9XajWjX3hN2dvZwrFABs+b4ITIyAvfvhwgdrUDEUK5FK9ah1Y8dUN7WDvYOFTBp5hy8eR2Jh6H3AQDxcXH4/bf9GDpqHGrWqYsKFZ0waboP7gbfxr27wQKnz5/ExARMmjAGU6fPhoGBgdBxCo3YytXAtRG8h4+EW7PmQkcpVGI4buSkUeOmcG3YCFZW1rCytoH38JHQ0dHBnWDFPE78SxG3V8/VV7Dv6ks8fh2P0IiPGL3jNsyNdOBskfVH90rlDNC/aXmM3Zl9G+29/AIzD4TgypMYvIhJxMHrr/DrlXC0qGr2vYrxTQuWr0XLtu1hY2sHO4cKmDQ96/nrX48fPsCeHVswYepsgZLmnUuDhhjkPQJN3LIf/2QyGXbt2Io+/QeiURM32Ds4YqaPH6Kj3uLcmT8ESJt/hkZGMDEpJX/8eS4I5haWqFmrjtDRCkQM5RLz/vWlO8G30KhJUzRo2Bhly5VDM3cP/FDPBSH37godLU/qubhiwODhaNQ0+913L8KfI+RuMMZMnIaKTs6wsrbBmInTkJKSgsATxwRIm39ivd4gKkysKKdiITIyEl5eXujTpw9CQ0MRFBQET09PyGQyrF69GkOGDMGAAQNw9+5dHD58GHZ2drle98SJE+Hn54epU6fi/v372LlzJ0qXLp1lmQkTJmD48OEIDQ2Fp6cnfvrpJ2zatCnLMps2bUKnTp2gr68vnzZ27FiMHj0at27dQr169dC2bVvExMTAwsIC+/fvBwA8fPgQkZGRWLp0aQH+Q4XrXNAZVKpUGeNGDYdbo/rw6twBB/btFTpWgYm1XF+Kj48DAJQoodgt5b8khnIl/FMGg3/uYngYGoL09HTU+qGefBkrm/IoXcYMIXduCxGxwHznzIKra2PUrVdf6CiFSqzlEjsxHDe+lJGRgRPHjiIpKRFVqlUTOk6hUsTtpa+V2VPl+8RPdxxqqatiWc8amPrrXUTF5a4Vsr6WOt4nphZJxsIQHx8P4NP5CwCSk5Mwa+o4jBg3GcYmit1d2L9evXqJmOho1PnsvKynrw8n5yq4c0dxK4rS0lJx7OhhtGvvqVDdXXyLWMol5v2rStXquHblMp4/y+xa6tHDBwi+dRP1G7gKnKzwpKVmHrs1NDTk01RUVKChoYE7t28KFavAxHy9QVQQ7KOcioXIyEikp6fD09MTVlaZ/Xw5O2f2Ke3j44PRo0dj+PBPXRXUrl07V+uNi4vD0qVLsWLFCvTs2RMAYGtriwYNGmRZbsSIEfD09JQ/79evH+rXr4/IyEiYmZnh7du3OHbsGP74I2tLE29vb3Ts2BEAsHr1apw4cQIbN27EuHHjYGRkBAAwNTUtdn2Uv3r5Avv27kK3Hr3Qp/8vCLl3F/P95kBdXR1t23UQOl6+ibVcn5NKpZjvNxfVqteAnb2D0HEKjRjKJZVKsWzBPDhXrY7ydvYAgJiYaKirq0NfP2sLZSNjY8TERAsRs0BOHD+KB/fvY/vufd9eWIGItVxiJ4bjxuceP3qInt28kJqaAm0dHSxcugK2trlvGFDcKeL2kkiA6Z6VcS0sFo8i4+TTp3k64cbTWATefZOr9dS0MUSbGmXRe+3VoopaIFKpFMsX+WU5fwHA8kX+qFylGlwbNRUwXeGKic489xobG2eZbmxsgpjoKCEiFYqzZ04jPi5ONNe7/xJDucS+f/Xq2x8JCfHo1K41VFRVIc3IwOChI9CydVuhoxUaK2sblC5jhrUrlmDs5OnQ1tbGnh1b8fbNa4U8boj9eoOooFhRTsVC1apV4ebmBmdnZ3h4eMDd3R2dOnVCWloaIiIi4OaWv0FNQkNDkZKS8s3X16pVK8vzOnXqwMnJCVu2bMGECROwfft2WFlZoWHDrINc1Kv3qTWKmpoaatWqhdDQ0DxlTElJydYnYrpEo1D7Xf+SVCpDJScnDB0+CgBQoWIlhD15jH17dyv4hag4y/U5X5+ZePLkMTZv3Sl0lEIlhnIt8vPB32GPsWrjNqGjFInXryMx328uVq8LKNLj0/cm1nIpAzEcNz5nbWOD3fsPIj4uDn+cOolpkydgw+Ztovnyqojba3ZnZziY6aPT0ovyac0ql0Z9e2O08j+fq3U4mOljff/aWHr8Ef58UDwrVBb7++Bp2BOsWL9VPu3CubO4ef0KNm7nD4iK4LeD+1DfxRWlTEt/e2EFIoZyiX3/Cjx5HCeO/g4fv/mwtbXHw4ehWOTvi1KlTNGmXXuh4xUKNXV1zF2wFL6zpqJlk/pQVVVFrTp1UdfFFchhnIriTuzXG4pAke+QUQbseoWKBVVVVQQGBuL48eOoVKkSli9fDkdHR7x5k7uWOl+jra2dq+V0dXWzTevXrx82b94MILPbld69exfJAc3X1xclSpTI8ljg71vo7/M5k1KlUP6LE6FNeVu8fh1ZpO9b1MRarn/5zpmF8+eCsCFgC0qXKSN0nEIjhnItmueDvy6cw7K1m2Ba+lMZjI1NkJaWhri4j1mWj42JgbGxYt1mGxoSgtjYGPyvqydqVXNCrWpOuHH9Gnbt2IZa1ZyQkZEhdMR8EWu5xE4Mx40vqatrwNLSCpWcKmPYyNFwcKyAXdu3fvuFCkARt9esTpXh5lQaXsv/wuv3yfLp9R1MYGWii7vzWiBscWuELW4NAFjTtxZ2D62XZR32ZfSwc0g97LoYjuWniudAaYv95+CvP89hyeqALOevm9evIOLlC7RuWg9N6lZFk7pVAQBTx4/EsF96CZS24P7t4iImJibL9JiYaBiblBIiUoFFRrzC1cuX0L5jZ6GjFCoxlEsZ9q9lixagZ99+8GjZGnYODmjdth28uvfEpo3rhI5WqCpUdMKWXQdwMugyfjsZhEUr1uHj+/coW85c6Gh5JubrDaLCwBblVGxIJBK4uLjAxcUF06ZNg5WVFQIDA2FtbY3Tp0/LB8fMC3t7e2hra+P06dPo169fnl77888/Y9y4cVi2bBnu378v77rlc5cvX5a3Mk9PT8eNGzfkA43+24fZtypZJk6ciFGjRmWZli7R+MrShaNatep49k8/cv96/uwZzMzKFun7FjWxlksmk8Fv7mycOR2IDZu2oZy5hdCRCoUYyiWTybDYfw7Onz2N5es2Z7tYdqzoBDU1Ndy4ehmN3dwBAOHPnuLN60g4VakmQOL8q1O3Ln49cDjLtOlTJ8HGpjx69ekHVVVVgZIVjFjLJVZiOG7klkwqRWpq8e3TOjcUdXvN6lQZHlXKoOvyS3gRm5Rl3urAJ9h9KTzLtMCJjTHrQAhO33stn2ZfRg+7vOtj/9UXmH/0wXfJnRcymQxL5s/Fn0GnsXTNpmznr249+6FNu45ZpvXy6gDvkeNQ37Xxd0xauMqVM4exiQmuXbkMxwoVAWT2Hx1y9w46df5J4HT5c/jQARgaGaOBayOhoxQqRS6XMu1fyclJUJFkbX+pqqIKmUwqUKKipffPeGUvwp/jQWgI+g0aKnCighPD9QZRYWJFORULV65cwenTp+Hu7g5TU1NcuXIFUVFRqFixImbMmIGBAwfC1NQULVu2RFxcHC5evIihQ3M+Kbm5uaFDhw7w9vaGlpYWxo8fj3HjxkFDQwMuLi6IiopCSEgI+vbt+5+ZDA0N4enpibFjx8Ld3R3m5tl/LV65ciXs7e1RsWJFLF68GO/evUOfPn0AAFZWVpBIJPj999/RqlUraGtrQ09PL9s6NDU1s93un5BatLdwdevRC727e2Hj+jVo7tESIXfv4MD+vZgybVaRvm9RE2u55vrMxPFjv2PJslXQ1dVF9D994enp6UNLS0vgdPknhnIt9JuNP04cg++i5dDR0ZH3U6inpw9NLS3o6eujTbuOWL7IHwYGJaCjp4cl/nNRuUo1VHauKnD6vNHV1cvWr7C2tjZKlCypMP0N50Ss5UpMSEB4+KfKvFcvX+JBaChKlCgBs7KK++OhGI4bOVm2eCFcXBvCzMwMCQkJOH70d1y/dhWr1m4QOlqBKOL28unsjB9rlkP/DdeQkJyOUvqZ12gfk9OQkiZFVFxKjgN4RrxLkleqO5jpY5d3PZx/EIUNZ/+WryNDJkNsfPGojFg8zwd/nDyGuQuWQUdHV953t56eHjS1tGBsYpLjAIOly5gV+xaUiYkJePHZ8S/i1Us8fJB5/CtjVhZe3XogYP0aWFhZoVw5c6xZuQwmpUzRqGkzAVPnj1QqxeHfDqLNj+2hpiaer/aKXi4x719fcm3UBAHr16KMmRnK29rj4YP72LFtM35s7/ntFxcjiYkJePnis+NGxEs8ehgKA4PM48aZwJMoaWiI0mXM8PeTx1iywBeujZvih3ouAqbOO7FebxAVJsU765AoGRgY4Pz581iyZAk+fvwIKysrLFy4EC1btgQAJCcnY/HixRgzZgxMTEzQqVOnr64rLCwM0dGfBsmbOnUq1NTUMG3aNERERMDMzAwDBw7MVa6+ffti586d8srvL/n5+cHPzw+3b9+GnZ0dDh8+DJN/LnrKlSuHmTNnYsKECejduzd69Ogh78pFaE6VnbFgyXKsWLII69esQtly5hgzbiJatVHsQVfEWq5f9+wCAPTr3T3L9Jk+vminYBehnxNDuQ7t2wMAGDqgV5bpk6b7oNWPmf3iDx09HhIVCSaPG4G01DTUqeeC0ROmfO+opGRCQu6hX+8e8uf/dun1Y7sOmD3XT6hYBSaG40ZOYmNjMXXSeERHRUFPXx/2Do5YtXYD6tZXrC/gX1LE7dXd1RoAsHdY/SzTR2+/hX1XX+ZqHa2qmcFEXxOetc3hWftTpdeLmEQ0mHm60LIWxKH9meevYQN7Z5k+cZoPWrZtL0CiwhMaEoKB/T7dCbp4wTwAQOsf22PGbF/06N0PSUlJmDtrOuLjPqJq9RpYtmqdQo5TceXyX3gdGVFs96f8UvRyiXn/+tLYiVOwZsVS+M2ZhXexsTApZQrPTl3Qf+BgoaPlyYP7IRj6y6fttXyRPwCgZZt2mDJzLmKio7B8sT9i/+mmqUXrH9G7f+7qFIoTsV5vKBoVdlFerElkMgUcfYDoO9m2bRtGjhyJiIgIeVcqAPDs2TPY2Njg1q1bqFatWqG/b1G3KKfCpcLBOBRKfEq60BGKhK4GuwhRJCoivUIW61WlDOIsmATi/BxWGH1E6AhF4qpPC6EjFAltkZ6/eH2oWBJEen2ooynO/SslTZxdu4h1e+mo83j4uYXn/hY6wncxulF5oSPkC1uUE+UgMTERkZGR8PPzwy+//JKlkpyIiIiIiIiIiIjEReXbixApH39/f1SoUAFlypTBxIkThY5DRERERERERERERYgtyolyMGPGDMyYMeOr862trcFei4iIiIiIiIiIiMSBFeVERERERERERERERYxDWBRv7HqFiIiIiIiIiIiIiJQaK8qJiIiIiIiIiIiISKmxopyIiIiIiIiIiIiIlBoryomIiIiIiIiIiIhIqXEwTyIiIiIiIiIiIqIipsLRPIs1tignIiIiIiIiIiIiIqXGinIiIiIiIiIiIiIiUmqsKCciIiIiIiIiIiIipcY+yomIiIiIiIiIiIiKmAq7KC/W2KKciIiIiIiIiIiIiJQaK8qJiIiIiIiIiIiISKmxopyIiIiIiIiIiIiIlBoryomIiIiIiIiIiIhIqXEwTyIiIiIiIiIiIqIiJuFgnsUaW5QTERERERERERERkVJjRTkRERERERERERERKTVWlBMRERERERERERGRUmMf5URERERERERERERFTAXspLw4Y4tyIiIiIiIiIiIiIlJqrCgnIiIiIiIiIiIiIqXGrleIiiFVFXHeipOUmiF0hCIh1u2VniETOkKRSEwR5+dQT1Ocp/TUdKnQEYpEepo4P4eaaqpCRygSaqriPM6L1S3fVkJHKBKtll8QOkKROOLtInSEIqGpJs42aeqq4iyXvpY4r6NURPo9RUUiznJJ2CUHkeDEeZYjIiIiIiIiIiIiIsolcf5sSkRERERERERERFSMiPSGCNFgi3IiIiIiIiIiIiIiUmqsKCciIiIiIiIiIiIipcaKciIiIiIiIiIiIiJSauyjnIiIiIiIiIiIiKiIqbCP8mKNLcqJiIiIiIiIiIiISKmxopyIiIiIiIiIiIiIlBoryomIiIiIiIiIiIhIqbGinIiIiIiIiIiIiIiUGgfzJCIiIiIiIiIiIipiKhKO5lmcsUU5ERERERERERERESk1VpQTERERERERERERkVJjRTkRERERERERERERKTVWlBMRERERERERERGRUuNgnkRERERERERERERFjGN5Fm9sUU5ERERERERERERESo0V5URERERERERERESk1FhRTkRERERERERERERKjX2UExERERERERERERUxFXZSXqyxRTkRERERERERERERKTVWlFOuSCQSHDp0KN+vDwoKgkQiwfv37wst0/dW0P8BERERERERERERFU/seoVyJTIyEoaGhkLHkAsKCkKTJk3w7t07lCxZ8ru8Z3H7HxTEjevXsDlgI0Lv30NUVBQWL1uJpm7NhI6VZ7duXMf2rQF4eD8E0dFRmLdoGRo1ybkc83xm4OD+vRgxZgJ+6tbjOyfNm5s3rmHb5gA8CA1BdFQU5i9ejsZNP5VLJpNh7arlOHTgV8THxaFKteqYMHk6LK2shQudC7duXMeOrQF4GJq5vfwWZt1e9WpUyvF1Q4aPxs89+36vmHl25MAe/H5wL95ERgAArGxs0a3PL6hTzxWvI1+hR8eWOb5uis8CNGzq/j2jFsjG9Wtx+o9TePb0b2hqaaFqteoYMXIMrG3KCx0tT27euIbtWz7tX/6LPu1f6WlpWL1yKf66cB6vXr6Enr4eav9QD97DRqOUqanAyf/brRvXsXNrAB6G3kd0dBR8Fy5DoyZu8vmJiQlYvWwxzgedwYcP71G2bDl09voZHTp1FTB13rVp0RSRERHZpnfu+j9MmDxNgESFQyzn5S+JpVxiOH/1qGuBxo4msDLSQUq6FHdffcTKoL8RHpskX6ZdVTN4OJnCsbQedDXV0GzxBcSnZGRZT696lqhvawSH0npIy5Ch+ZKL37so/2lbwHqcOxuI58+eQlNTC85VqmHQsFGwtLaRL5OSkoIVi/1x+tRxpKWmok49F4yeMBVGxiYCJv82sV4ffkks1xv/JWDDOixfugj/+7kHxo6fJHScAhHLcT4nb9+8wdLFC/DXhfNITk6GhYUlZvjMRSUnZ6Gj5Zsy7F9EBcUW5ZQrZcqUgaamptAx8iw1NbXQ1qWo/4OcJCUlwtHREROnTBc6SoEkJSXC3sERYyZO/c/lgs78gXt3g1GqVPGu6PpXUlISHBwdMe4r5dq6aQP27NqOiVNmYNP2PdDW1sHQQf2RkpLynZPmTXJy5vYaPSHncv1+6lyWx+TpPpBIJGjiVrwrk01MS6PvoBFYuWk3VgTsQrWadTBj/HA8+/sJSpmWwe4jZ7I8evQbDG0dHdSu20Do6Hly4/pVdPXqhq0792LNuk1IT0vHoAF9kZSYKHS0PElOSoK9gyPG5rB/JScn42HoffTpPwjbdu/HvIXLEP7sGUaPGCxA0rxJTk6CnYMjRk+YkuP8ZQv9cfmvC5ju44dd+4+gy/+6Y9G8Ofjz3JnvnLRgtu3ch5Nn/pQ/Vq0LAAA0c/cQOFnBiOW8/CWxlEsM56/qliWx/2YE+m27hWF77kBNRYKlXatAS/3T10EtdRVc+jsWmy+Ff3U9aqoSnHkYhQO3sv9gVRzcunkNnp29sHbzLixetR7p6ekYOaQ/kpI+nauWL5yHi+eDMNtvEZav34LoqChMHjtcwNS5I9brwy+J5Xrja0Lu3cX+fXtg7+AodJRCIZbj/Jc+fviA3j28oKamhuWr12PfoaMYOXY89A1KCB2tQMS+fxEVBrYoVzL79u3DzJkz8eTJE+jo6KB69er47bffoKuri4CAACxcuBBPnjyBkZEROnbsiBUrVgDI7Hbk4MGDaN++fY7rlUqlmDdvHtatW4fXr1/DwcEBU6dORadOnb6a5cKFC5g4cSKuX78OExMTdOjQAb6+vtDV1QWQ2dpj2rRp2LlzJ96+fQsLCwtMnDgRbm5uaNKkCQDIW3j37NkTmzdvRuPGjVG5cmWoqalh+/btcHZ2xtmzZ3Hu3DmMHTsWwcHBMDIyQs+ePeHj4wM1tcxdoHHjxqhSpQq0tLSwYcMGaGhoYODAgZgxY4Y875f/g5cvX2Ls2LE4efIkUlJSULFiRaxcuRI//PADgoODMWLECFy/fh0SiQT29vZYu3YtatWqVZDNV2gauDZCA9dGQscosPoNGqJ+g4b/uczbt2+wcN4cLF21DqOGDvpOyQrGpUFDuHylXDKZDLt2bEWf/gPlrUVn+vjBo2kDnDvzB9xbtv6eUfOknktD1HP5+vYyNimV5fmf586gRq06KGduUdTRCqReg8ZZnvceOAy/H9yL0JA7sC5vl62F2sVzZ9CwqQe0dXS+Y8qCW7V2Y5bns+b4oWnDerh/PwQ1a9UWKFXe/ddxQ09fHyvWBmSZNnbCFPT6uQteR0agjFnZ7xExX+q5uKKei+tX59+9cxut2rZDjVp1AADtO3bBb/t/xf17d+HaqOn3illghkZGWZ5v3rge5haWqPlPuRSVWM7LXxJLucRw/hq5926W57OPPsSJ4fVRoYw+br/4AADYc/0VAKCG5dcrgjZceA4AaO1cuoiSFsyiFeuyPJ80cw7aNnPFw9D7qFajFuLj4vD7b/sxfY4/atapm7nMdB9069QW9+4Go7JzVSFi54pYrw+/JJbrjZwkJiZg0oQxmDp9NjasWy10nEIhluP8lzYHbEDpMmaY6eMrn1bO3FzARIVDzPuXIuFYnsUbW5QrkcjISHh5eaFPnz4IDQ1FUFAQPD09IZPJsHr1agwZMgQDBgzA3bt3cfjwYdjZ2eV63b6+vti6dSvWrFmDkJAQjBw5Ej///DPOnTuX4/JhYWFo0aIFOnbsiDt37mDPnj24cOECvL295cv06NEDu3btwrJlyxAaGoq1a9dCT08PFhYW2L9/PwDg4cOHiIyMxNKlS+Wv27JlCzQ0NHDx4kWsWbMGr169QqtWrVC7dm0EBwdj9erV2LhxI3x8fLJk2rJlC3R1dXHlyhX4+/tj1qxZCAwMzDF/fHw8GjVqhFevXuHw4cMIDg7GuHHjIJVKAQDdunWDubk5rl27hhs3bmDChAlQV1fP9f+TCodUKsXMKRPwc88+KG9rL3ScQvHq1UvEREejzg/15NP09PXh5FwFd+4EC5iscMXGROPihfNo276j0FHyJCMjA2cDjyM5OQmVKmf/sv3owX2EPX6AFm07CJCucMXHxwEASpRQ7JY13xIfHweJRAI9fQOhoxSIc5Vq+PPcWUS9fQOZTIYb167gRfgz1KnrInS0fEtLS8Wxo4fRrr0nJPzGQcWEopy/9DRVAQAfk9IETlK0Ev45Vxn80wr0YWgI0tPTUeuz6ygrm/IoXcYMIXduCxGxUIj5+lBM1xu+c2bB1bUx6tarL3QU+oZzQWdQqVJljBs1HG6N6sOrcwcc2LdX6FiFTkz7F1FhYYtyJRIZGYn09HR4enrCysoKAODsnNm/lo+PD0aPHo3hwz/ddli7du5+UUxJScHcuXPxxx9/oF69zIuz8uXL48KFC1i7di0aNcr+C7Ovry+6deuGESNGAADs7e2xbNkyNGrUCKtXr0Z4eDj27t2LwMBANGvWTL7Ofxn906LM1NQ0Wx/l9vb28Pf3lz+fPHkyLCwssGLFCkgkElSoUAEREREYP348pk2bBhWVzN+LqlSpgunTp8vXsWLFCpw+fRrNmzfPln/nzp2IiorCtWvX5Fk+/2EhPDwcY8eORYUKFeTro+9v26YNUFVVRRevn4WOUmhioqMBAMbGxlmmGxubICY6SohIReLYkd+go6ODxk2z73/F0dOwRxg+oDtSU1Ohra2D6b5LYGVjm225E0cOwNK6PJycq33/kIVIKpVivt9cVKteA3b2DkLHKTIpKSlYsXQh3Fu0hp6entBxCmTU+MmY5zMd7Vo0haqaGlQkEkyYOhPVaxaPO53y4+yZ04iPi0Pbdor/wxOJhyKcvyQARjSzQ/CLD/g7Wry320ulUixbMA/OVaujvF3mtXhMTDTU1dWh/8WPn0bGxoiJiRYiZqEQ6/WhmK43Thw/igf372P77n1CR6FcePXyBfbt3YVuPXqhT/9fEHLvLub7zYG6urporjvEtH8RFSZWlCuRqlWrws3NDc7OzvDw8IC7uzs6deqEtLQ0REREwM3N7dsrycGTJ0+QmJiYrUI5NTUV1atXz/E1wcHBuHPnDnbs2CGfJpPJIJVK8fTpU9y9exeqqqo5VrJ/S82aNbM8Dw0NRb169bK0NnNxcUF8fDxevnwJS0tLAJkV5Z8zMzPD27dvc3yP27dvo3r16vJK8i+NGjUK/fr1w7Zt29CsWTN07twZtrbZK82AzIqYL/sOlKlqiqY/dKE8uB+CPbu2YcvO/WxpqICOHD4Aj5ZtFGY/MLe0weotvyIhPh5/ng3EfJ8pWLAyIEtleUpKMs4GHke3XgMETFo4fH1m4smTx9i8dafQUYpMeloaJo0bCZlMhvGTFb/fzX27dyDk7h34L16BMmZlcfvmdSz084FJKVPU/qwFoiL57eA+1HdxRSnT4tkFBCknRTh/jXW3h20pXQzYfkvoKEVqkZ8P/g57jFUbtwkdhfJJLNcbr19HYr7fXKxeF1Csjw30iVQqQyUnJwwdPgoAUKFiJYQ9eYx9e3eLpqJcLPsXUWFj1ytKRFVVFYGBgTh+/DgqVaqE5cuXw9HREW/evCnQeuPj4wEAR48exe3bt+WP+/fvY9++nH8xj4+Pxy+//JJl+eDgYDx+/Bi2trbQ1tbOd55/+zjPqy+7RpFIJPKuVL70rXwzZsxASEgIWrdujTNnzqBSpUo4ePBgjsv6+vqiRIkSWR7z5/nmuCzl3u1bN/AuNhbtW7nBpZYzXGo543VkBJYt8kf7Voo7EruxSWZ/1zExMVmmx8REZ+sjVVHdvnkd4c+e4scOXx/joLhRV1dHOXNLOFSohL6DhqO8nQMO7t2RZZk/zwQiJTkJzVq2FShl4fCdMwvnzwVhQ8AWlC5TRug4RSI9LQ0Tx41EZGQElq/ZqPCtyVOSk7FmxRIMHTUODRo1gZ2DIzr91A1u7i2xc+smoePlS2TEK1y9fAntO3YWOgqRnCKcv0Y3t4OLnREG7wxGVFzhDXpf3Cya54O/LpzDsrWbYFr607nK2NgEaWlpiIv7mGX52JgYGH8xpogiEeP1oZiuN0JDQhAbG4P/dfVErWpOqFXNCTeuX8OuHdtQq5oTMjIyhI5IXzApVQrlbbN2RWtT3havX0cKlKhwiWn/UkQqSvJQVGxRrmQkEglcXFzg4uKCadOmwcrKCoGBgbC2tsbp06flg2TmRaVKlaCpqYnw8PBctwCvUaMG7t+//9V+0J2dnSGVSnHu3Dl51yuf09DQAIBcXVRUrFgR+/fvh0wmk7csvnjxIvT19WGezwE5qlSpgg0bNiA2NvarrcodHBzg4OCAkSNHwsvLC5s2bUKHDtl/fZ44cSJGjRqVZZpMlS0NCqpl6x+ztZIcMbg/WrT+EW0UuBVAuXLmMDYxwbUrl+FYoSKAzB+eQu7eQafOPwmcrnAc+e0AKlR0gr1DBaGj5JtUKkVaWtYKiBO/H0TdBo1R0jDnY0ZxJ5PJ4Dd3Ns6cDsSGTduK1SB1henfSvIX4c+xev0WlCxpKHSkAktPT0d6erq8q7F/qaioQCqTCZSqYA4fOgBDI2NRDiBGiqu4n79GN7dDIwcTDNkZjMgPyULHKRIymQyL/efg/NnTWL5uM8qWy3qt71jRCWpqarhx9TIau7kDAMKfPcWb15FwqlJNgMSFQ0zXh2K83qhTty5+PXA4y7TpUyfBxqY8evXpB1VVVYGS0ddUq1Ydz549zTLt+bNnMCvGA7vnhhj3L6LCxopyJXLlyhWcPn0a7u7uMDU1xZUrVxAVFYWKFStixowZGDhwIExNTdGyZUvExcXh4sWLGDp0aI7rcnNzQ4cOHeDt7Q19fX2MGTMGI0eOhFQqRYMGDfDhwwdcvHgRBgYG6NmzZ7bXjx8/HnXr1oW3tzf69esHXV1d3L9/H4GBgVixYgWsra3Rs2dP9OnTB8uWLUPVqlXx/PlzvH37Fl26dIGVlRUkEgl+//13tGrVCtra2l9t8Td48GAsWbIEQ4cOhbe3Nx4+fIjp06dj1KhR2SoNcsvLywtz585F+/bt4evrCzMzM9y6dQtly5ZFtWrVMHbsWHTq1Ak2NjZ4+fIlrl27ho4dcx7USVMzezcryen5ipVriQkJCA8Plz9/9fIlHoSGokSJEjArqzgn/8TEBLx88akcEa9e4dHDUBgYlEAZs7Io8UX/9apqajA2MYGVtc13Tpo3iYkJeBH+eble4uGDzO1TxqwsvLr1QMD6NbCwskK5cuZYs3IZTEqZolHT4t1S/lvbCwAS4uNxJvAkho4aK1TMPNu4eilq13WBaRkzJCUm4Myp47hz6zrmLl4jX+bVy3DcvX0DPgtXCpi0YOb6zMTxY79jybJV0NXVRfQ/fZ7q6elDS0tL4HS5l5iYgJdf7F+PHoTCoEQJmJiUwoSxI/Ag9D4WLVuNDGmGvJwlSpSAurqGULG/6cv9K/LVyyz7V/WatbFiyQJoamqijFlZ3LpxDcePHsawUeMETJ0/UqkUh387iDY/toeamjguZcVyXv6SWMolhvPXWHc7uFcqjXH77yEhNR1Gupl3UiakZCAlPfMOSiNddRjrasC8ZOadk7al9JCYmo43H1Pw8Z+L09IGmjDQUkNpAy2oSAB708w7OV++S0JSWs53Yn5PC/1m448Tx+C7aDl0dHTk/XPr6elDU0sLevr6aNOuI5Yv8oeBQQno6Olhif9cVK5SDZWdsw/CXZyI9frwS2K53vicrq5etj6gtbW1UaJkSYXvG1osx/kvdevRC727e2Hj+jVo7tESIXfv4MD+vZgybZbQ0QpEjPsXUWETx7cLyhUDAwOcP38eS5YswcePH2FlZYWFCxeiZcuWAIDk5GQsXrwYY8aMgYmJCTp1+vpto2FhYYiO/jTgzezZs1GqVCn4+vri77//RsmSJVGjRg1MmjQpx9dXqVIF586dw+TJk+Hq6gqZTAZbW1t07dpVvszq1asxadIkDB48GDExMbC0tJSvr1y5cpg5cyYmTJiA3r17o0ePHti8eXOO71WuXDkcO3YMY8eORdWqVWFkZIS+fftiypQpef0XymloaODUqVMYPXo0WrVqhfT0dFSqVAkrV66EqqoqYmJi0KNHD7x58wYmJibw9PTEzJkz8/1+hS0k5B769e4hf77AP7Orlx/bdcDsuX5Cxcqz0PshGNK/l/z50oXzAACt2rbHtFlzBUpVcKEhIRjY79MPTIsXZJar9Y/tMWO2L3r07oekpCTMnTUd8XEfUbV6DSxbta7Y93n44H4IhgzoJX++bNGn7TV1Zub2Cjx5DDLI4O7RWoiI+fL+XSzmz56C2Jgo6OjqobydA+YuXoOadT7d0XDy94MwMS2NmnXqC5i0YH7dswsA0K939yzTZ/r4ol17TyEi5UtoSAgG9f+0fy3557jRum179B/ojfNBZwAAP3fNeufJ6vVbULN2ne8XNI8e3A+B94De8ufLFmUOat2qbTtMmTkXs3znY/XyJZgxeTw+fvyAMmZl8cuQYejQqevXVllsXbn8F15HRijU5+5bxHJe/pJYyiWG81fHGuUAAKu7VcsyffbRBzh6N7MbRs/qZdGvgbV83tqfq2VbZoCrNVo7f7pNf1ufzAGBB++8jZvhH4oofe4d2rcHADD0s+0FAJOm+6DVj5nH9aGjx0OiIsHkcSOQlpqGOvVcMHpC/r8XfC9ivT78kliuN5SFWI7zX3Kq7IwFS5ZjxZJFWL9mFcqWM8eYcRPRqo1id6HI/Yvo2yQymYLec0skYkXdolwoSani7H9PVUWcg4WmZ4jz9BAn0h3M1ECxvgjnVmq68C0Ui0L6V8bAUHSaauK8fVxNVZzHebFKTBHn9Uar5ReEjlAkjni7CB2hSGiqKXIPrV+nrirOcom1WkRFpN9TMqQi3V4ScW4vbfVvL6NMNl8L//ZCItCrtqXQEfKFLcqJiIiIiIiIiIiIiphEpD+IiIU4fw4mIiIiIiIiIiIiIsolVpQTERERERERERERkVJjRTkRERERERERERERKTVWlBMRERERERERERGRUuNgnkRERERERERERERFjEN5Fm9sUU5ERERERERERERESo0V5URERERERERERESk1FhRTkRERERERERERERKjX2UExERERERERERERUxFQl7KS/O2KKciIiIiIiIiIiIiJQaK8qJiIiIiIiIiIiISKmxopyIiIiIiIiIiIiIlBoryomIiIiIiIiIiIhIqXEwTyIiIiIiIiIiIqIixqE8ize2KCciIiIiIiIiIiIipcaKciIiIiIiIiIiIiJSaqwoJyIiIiIiIiIiIiKlxj7KiYiIiIiIiIiIiIqYhJ2UF2tsUU5ERERERERERERESo0V5URERERERET/Z+++42NI/ziAfzabnkiQRIqQRBoiiE6QEC0I0eX8Dqf33nsI0aJEdKf3fk493Z1z0VsSUQ5RghBCev39kbMsQfrszn7eXvt62dnZ2c9kdp+Z/e4zzxAREZFKY6GciIiIiIiIiIiIiFQaC+VEREREREREREREpNJ4MU8iIiIiIiIiIiKiAibh1TwVGnuUExEREREREREREZFKY49yIgWUkpYudIQCIdYfTjXVxfmbo4ZU6ASUE2L9fGmoi3PF1NLF2W5kZGQIHaFAZGSI830o1nZDW1Ocn69Dg12FjlAgyvTaJnSEAvF8w/+EjlAgklLThI5QIMR6PJ+aJs79crpIjzfUpCLdMRMpEXHuDYiIiIiIiIiIiIiIsok9yomIiIiIiIiIiIgKGHssKzZuHyIiIiIiIiIiIiJSaSyUExEREREREREREZFKY6GciIiIiIiIiIiIiFQaC+VEREREREREREREpNJ4MU8iIiIiIiIiIiKiAiaRSISOQN/BHuVEREREREREREREpNJYKCciIiIiIiIiIiIilcZCORERERERERERERGpNBbKiYiIiIiIiIiIiEil8WKeRERERERERERERAWMl/JUbOxRTkREREREREREREQqjYVyIiIiIiIiIiIiIlJpLJQTERERERERERERkUrjGOVEREREREREREREBUwi4Sjliow9yomIiIiIiIiIiIhIpbFQTkREREREREREREQqjYVyIiIiIiIiIiIiIlJpLJQTERERERERERERkUrjxTyJiIiIiIiIiIiIChh7LCs2bh8SJYlEgv379wsdAwDg7u6OYcOGCR2DiIiIiIiIiIiIvoE9ykmUIiMjUaxYMaFjKKy0tDSsWh6EIwd/x5s3r2FsUgJerb3Rs09/SCQSoeNl27Url7F5w1rcCQvB66gozF0QCLeGjWSPr14ehOPHjuDlixfQ0NBA2fLl0W/QUFRwriRg6py7cvkS1q/9FWGhtxEVFYWFgUvR0KPRj5+o4H5dvRInT/yBRw//hZa2NipVdsGw4aNgbVNG6Gg5cu3KZWzZuBbhYSF4/ToKswMC4dbg0/apXaV8ls8bOHQk/tetZ2HFzDOxvg93bt+G3Tu24fnzZwCAMnZ26NNvIOrWqy9wsrwRSzuflbi4OKxYuhinT53A2+hoOJYth5FjJsCpgrPQ0XJNLO3hl9huKLZrVy5j68a1CA8LxevXUfAPCIRbAw/Z4/HxcVgeuBDnzpxCTMw7WFiURAef/6FN+04CppY3onUFeFUvBXsLQyQmpyH4bhSmbruK+5Hv5earbm+MKZ1cUNXWGGnp6bj1+C3a+p9EYkoaAMDWrAhmdKmKWo4m0JCqISTiHWbuuo4/Q18KsVrZ9urlSyxeOB9//3UOiYmJKFWqNKb5zUJ5J+VpD1XleF4s7caXWjZriMjnz7+a3qHTTxg3cYoAiXLn6pVL2LT+0/tw3sIlcP/sfXjqxB/Yu2sH7oSFICYmBpt37IVj2XICJs4dsR5vEOUn9ignUTIzM4OWlpbQMRTWhrVrsHvndoyZMAm79h/C4GEjsXHdr9ixdbPQ0XIkISEe9g6OGD1+cpaPl7ayxqhxE7F1936sWrcJ5hYlMaR/b7yNji7kpHmTkBAPR0dHjJ80Vego+erK5Yvo5NMFG7fuxIpV65Cakor+fXoiIT5e6Gg5kpiY+T4cOS7r9+HBP87K3SZO9YNEIkEDjyaFnDRvxPo+NDUzxeDhI7Fl5x5s2bEbNWrUwvDBA/Hg/j2ho+WJWNr5rPhNm4TgC39j+sw52L77N9Ss7YoBfXvg1UvFLmh9j1jawy+x3VBsiYkJsHNwxMhxk7J8PDBgLv75+y9M9ZuNbXt+R8effsaCOTPx59lThZz021zLlcDqP8LRaMoReM86AQ11CfaN94Cu1qf+YNXtjbFnnAdO3XyOhpMPo8GkI1j9RzjSMzJk8+wc0xDqUgm8/I7DbeJh3I54ix2jG6KEobYQq5Ut72Ni8EtXH6irq2PJ8tXYvf8Qho8eiyIGhkJHyxFVOZ4XS7vxpU1bd+PYqT9lt2Wr1gIAGjVpKnCynElISICDoyPGfON9mJiQgEouVTBo2MhCTpa/xHq8QZSf2KOcFNru3bvh6+uL+/fvQ1dXFy4uLvjtt9+gp6eHtWvXIiAgAPfv30fx4sXRrl07BAUFAcgcemXfvn3w9vbOcrnu7u5wdnaGVCrFhg0boKmpCT8/P/z0008YNGgQdu/eDVNTUyxZsgSenp6y592+fRujR4/Gn3/+CT09PTRp0gQLFy6EsbExgMxebv3798fevXtRpEgRjBo1qsD/Rrlx88Y1uDVoiLr13QEAFiVL4tiRQwi5fUvYYDlUp2591Kn77V4YTZu3lLs/dORYHNi3B/fvhaN6zdoFHS/f1K3nhrr13ISOke+WrfxV7v70mbPRsH5thIaGoGq16gKlyrnarvVR2/Xb70MjYxO5+3+ePYUq1WqgpGWpgo6Wr8T6PnRzbyh3f9DQ4di1Yztu3rgBWzt7gVLlnVja+S8lJibi1MnjCFgUhCpVM9uJvv0H4c+zp7F71zYMGDRM2IC5JJb28EtsNxRbbdd6qO1a75uP37p5Hc29WqNKtRoAAO92HfHbnl0IvX0L9dwafvN5handbPmiff/lf+PfVR1R2aY4/r7zCgDg/3M1rDx6BwsPhMjm+7zHefEiWrAzN8CglRcQEvEOADBt21X0buKI8qWK4lXMi4JfkVxYv3YNTM3M4evnL5tW0tJSwES5oyrH82JpN75UrHhxufvrf10Ny1KlUfW/dkNZuNatD9fvvA+be7UGADx/9qywIhUIsR5vKBtlP7tT7NijnBRWZGQkfHx80KNHD4SFheHMmTNo27YtMjIysHz5cgwcOBB9+vTBrVu3cODAAdjZ2eVo+Rs2bICxsTEuXryIwYMHo3///ujQoQPq1KmDq1evokmTJvj5558R/9+vq+/evUPDhg3h4uKCy5cv4+jRo3j58iU6duwoW+bo0aNx9uxZ/Pbbb/jjjz9w5swZXL16NV//LvmhYiUXXAr+B48fPQQA3A2/gxvXrqJO3W9/WVJ2KSnJ2L9nJ/T1i8DeoazQcSgLsbEfAACGhsrVEyonot+8xvm/zsHLu53QUSgLaWlpOHr4EBIS4lGxcmWh4+SJWNv5tLQ0pKWlQfOLs8a0tLRx/Zri7W9zSxXaQ7EQU7vxJeeKlfHn2dOIevUSGRkZuHIpGE8iHqFGLVeho32Toa4mAOBtbDIAwNhAG9XtTRD1PhF/+DbFvRXtcWhKE9Ry/PQjdvSHJNx9FgOf+mWgq6UOqZoEv3g44FVMAq4/VNxey2fPnEL58hUwZsRQeLjVgU+HNti7e6fQsQqUWI7nxdpupKQk4/ChA2jt3ZaFQCXB4w2ir7FHOSmsyMhIpKamom3btrCysgIAODtnjrfn5+eHkSNHYujQobL5q1fP2S+glSpVwqRJmaeajh8/HrNnz4axsTF69+4NAJgyZQqWL1+OmzdvolatWggKCoKLiwtmzZolW8batWtRqlQp3L17FxYWFvj111+xefNmeHhkju+4YcMGWCpgz47uPXsjLi4W7Vu3gJpUivS0NAwYPAyeLbyEjpbv/jp3BpPGjkRiYiKMjU2wZMUaFOX49QonPT0d82bPQmWXKrCzdxA6ToE5/Ptv0NXVhXvDxkJHoc/cuxuObl18kJycBB1dXQQsDoKtbc5+fFU0Ym3n9fT0ULFSZaxZtRw2NrYobmSEY0cO4dbN67AsVVroePlCVdpDZSfGduNLI8ZOxBy/qWjdrCGk6upQk0gwbrIvXKpWEzpaliQSwL9rNVy48wphT98BAKxL6AMAxrerhElbruDW42h0rmeLAxMbo9aY3/Hvi8wiUetZJ7B1pDuere2M9IwMRL1PRLvZJ/EuLlmo1fmhZ0+fYPfObejStTt69O6LkNu3MG/2TGhoaMCrdRuh4+UrsRzPi73dOH3qJGI/fBDd+0+seLxBlDUWyklhVapUCR4eHnB2dkbTpk3RpEkTtG/fHikpKXj+/LmsGJ1bFStWlP1fKpXCyMhIVogHAFNTUwDAq1eZp23euHEDp0+fhr6+/lfLevDgARISEpCcnIyaNWvKphcvXhyOjo7fzZGUlISkpCS5acnQKNAx1o8fO4Kjhw7Cb/Y82NraIzw8DAvm+sPEpARatvYusNcVQtXqNbBpx168e/cOv+3dhQljRmDt5u0oXtxI6Gj0GX8/X9y/fw/rN24VOkqB+v3AXjT1bMlrKCgYaxsbbN+zD7EfPuDEH8cwZeI4rFm/Sam/vIq5nZ8+cw6mT50Iz8ZukEqlcCxbHk2btUBYWMiPn6wEVKU9VHZibDe+tHv7FoTcuom5C4NgZm6B61cvI2C2H4xNSijkkBcBv9RAuVJF0WzaMdk0tf96ta47eRdbzj4AANx8dBluFczws7sdfLdfAwDM/6UGomIS0cz3GBKT09C1oR22j2qABpOO4OW7hMJfmWxIT89AeScnDB46AgBQtlx5PLh/D7t3bhddoVIsx/Nibzd+27cbdVzrwaSEqdBRKBt4vEGUNQ69QgpLKpXi+PHjOHLkCMqXL48lS5bA0dERL/PpYl0aGhpy9yUSidy0j6eLpaenAwBiY2Ph5eWF69evy93u3buH+vVzf7Vyf39/GBoayt0C5s7O9fKyI3DBfHTr2QtNPVvAzsEBLbxaw+fnblj366oCfV0h6OjoolRpKzhXrIRJ0/wglUpxYN8eoWPRZ/xnTse5s2ewZu0GmJqZCR2nwFy/ehkRjx6iVZv2QkehL2hoaKJ0aSuUd6qAIcNHwsGxLLZt3ih0rDwRcztvWao0Vq3dhD8vXMGhY6ewcetOpKamKOXYvF9SlfZQDMTYbnwuKTERK4IWYfCIMajr1gB2Do5o37kLPJp4YuvGdULH+8q87tXRtIolvGYcx/PoTxel+1jkvvMsRm7+u89iYGmkBwBwczJDsyol0WPJnwi+G4Ubj6Ixcu1FJCan4af6ZQpvJXLI2MQEZb4osNqUscWLF5ECJSo4YjmeF3O7Efn8GS7+cwHe7ToIHYWygccbRN/GQjkpNIlEAldXV/j6+uLatWvQ1NTE8ePHYW1tjZMnTxZqlipVqiAkJATW1taws7OTu+np6cHW1hYaGhoIDg6WPeft27e4e/fud5c7fvx4xMTEyN1GjhlXoOuSmJgANYn8x1+qJkVGRnqBvq4iyMjIQEqy4p5Gq0oyMjLgP3M6Tp08jlVrNyjdxS1z6vff9qJsOSelHlNTVWSkpyNZydsJVWjndXR1YWxSAu/fx+DChfNwc8/bmWZCUrX2UIzE0G58LjU1FampqVBTk29H1NTUkJ6RIVCqrM3rXh0tq5eGl99xPI6KlXvscVQsnkfHw97cQG66nbkBnrzOnFdHK/Mk6/R0+fVKz8iQ9UhXRJUru+DRf9eh+Ojxo0cwN7cQKFHhEcvxvJjajQP796JYcSNRXsBZTHi8oRgkKnJTVhx6hRRWcHAwTp48iSZNmqBEiRIIDg5GVFQUypUrh2nTpqFfv34oUaIEPD098eHDB5w/fx6DBw/OclkeHh5o06YNBg0alOs8AwcOxOrVq+Hj44MxY8agePHiuH//PrZv3441a9ZAX18fPXv2xOjRo2FkZIQSJUpg4sSJX33B+JKWltZXwzB8SCrYQkY9twZYu3olzMzNUcbWHuF3QrFl03q08m5boK+b3+Lj4/A0IkJ2//mzZ7h7JwwGhoYwLFoU61avRD33hjA2Nsa7d++we8dWRL16CY/GTQVMnXPxcXGI+Gw9nz19ijthYTA0NIS5hfJ+GZrl54sjhw9iUeAy6Onp4fXrKACAvn4RaGtrC5wu++Lj4/D0yRfvw/AwGBgYwuy/L6txsbE4dfwYBo8YLVTMPBPr+zBwYQBc69WHubk54uLicOTQQVy+dBHLVq4ROlqeiKWdz8qF838hAxmwsrLBkyePEbhwPqytbdBKiYcaEEt7+CW2G4rty/1X5LOncvsvl6rVEbRoPrS0tGBmboFrVy7hyKEDGDJijICp5QX0qIH2dWzwU8BpxCakoIRh5uflfXwKElPSAACBB0Mwvn0l3H78Frcev4VP/TKwtzBA14VnAQAX70XhXVwyVvSvgzl7byEhORXdG9rDqoQ+jl17Jti6/UiXrt3xy88++HX1CjRu6omQWzexd89OTJoyXehoOaIqx/NiaTeykp6ejgO/7UPLVt5QV1fOElN8fByeyL0PnyL8Tub+yszcAjEx7/AiMhKvozKHZf14sXQjY2MYG5tkuUxFJNbjDaL8JMnIULAuAUT/CQsLw/Dhw3H16lW8f/8eVlZWGDx4sKzYvXLlSixcuBD//vsvjI2N0b59ewQGBgLI7Im+b98+eHt7AwCsra3RvXt3TJs2DQDg7u6OypUrY9GiRbLXs7a2xrBhwzBs2DDZtC+Xc+/ePYwdOxanT59GUlISrKys0KxZMyxYsAASiQSxsbHo378/9u7diyJFimDkyJE4dOjQV6/1IwVdKI+Li8OKoMU4feoE3kZHw9ikBJp6NkfvfgOgoaFZYK+blp6/zc2VSxcxoHf3r6a38PLG2ElTMWX8aITcuol3797CsGhRlHOqgB69+qF8BeevF5YH2hrSfF3ely5dDEavX7p+Nb1V6zaYMavghukp6L1D5QpZj9/v6+eP1gVYzEtITsvX5V29fBED+3T/anpzL29M9s28+O/+PTuxKGA2Dh47C/0iRfL19T/S1RLn+7Cgey5OmzwRF4Mv4HVUFPSLFIG9gyN+6dELteq4Fujr5nd7+CWh2nkUwlHl8WNHEBS4EK9evoCBoSEaejTBwMHDCuyzBQDq0oI9CVOo9rCgO8uy3chfBbH/GtTnl6+mN/dqjUm+s/DmdRSWL1mEi//8jffvY2BmboHWbdujc5dusiEK80OZXtty/dyYbT9nOb3/8vPYeu5f2f3hrZzQq4kjiulp4XZENKZsvYp/wqNkj7uUKY7JHV3gUsYI6lIJ7jyNwZy9N3HixvNcZ3u+4X+5fm52nTt7GkGLFiAi4jEsSlrif127o237jgX6milp+fs9RVGO5zXVC7adF6rdSC+EE8ku/P0XBvXrhb0HjsDK2qbgXxD5385fuXQR/Xp1+2p6i1bemDbDH7//tg/Tp0z46vHe/QaiT//cd8b7koZIjzd0NH48jyrZf/OF0BEKhXdF5RzWh4VyIgVU0IVyoRR0YUgoBV0oF4pY9w75XWhQFAVdKBeKop3in1/E2h4WRqFcCAVdKBeKAo8qkSdibTfEuv/KS6FckRVGoVwI+V0oVxQFXSgXSmEUyoUg1na+oAvlQmGhXB4L5YpNOc+LISIiIiIiIiIiIlIiYu2oIBbi/LmKiIiIiIiIiIiIiCibWCgnIiIiIiIiIiIiokJ37tw5eHl5wcLCAhKJBPv375d7PCMjA1OmTIG5uTl0dHTQqFEj3Lt3T26e6OhodOnSBQYGBihatCh69uyJ2NjYHGdhoZyIiIiIiIiIiIiICl1cXBwqVaqEpUuXZvn43LlzERgYiBUrViA4OBh6enpo2rQpEhMTZfN06dIFISEhOH78OA4ePIhz586hT58+Oc7CMcqJiIiIiIiIiIiIqNB5enrC09Mzy8cyMjKwaNEiTJo0Ca1btwYAbNy4Eaampti/fz86d+6MsLAwHD16FJcuXUK1atUAAEuWLEHz5s0xf/58WFhYZDsLe5QTERERERERERERFTA1SFTilpSUhPfv38vdkpKScvz3evjwIV68eIFGjRrJphkaGqJmzZq4cOECAODChQsoWrSorEgOAI0aNYKamhqCg4NzuH2IiIiIiIiIiIiIiPKBv78/DA0N5W7+/v45Xs6LFy8AAKampnLTTU1NZY+9ePECJUqUkHtcXV0dxYsXl82TXRx6hYiIiIiIiIiIiIjyxfjx4zFixAi5aVpaWgKlyT4WyomIiIiIiIiIiIgoX2hpaeVLYdzMzAwA8PLlS5ibm8umv3z5EpUrV5bN8+rVK7nnpaamIjo6Wvb87OLQK0RERERERERERESkUGxsbGBmZoaTJ0/Kpr1//x7BwcGoXbs2AKB27dp49+4drly5Ipvn1KlTSE9PR82aNXP0euxRTkRERERERERERFTAJBKhEyie2NhY3L9/X3b/4cOHuH79OooXL47SpUtj2LBh8PPzg729PWxsbDB58mRYWFjA29sbAFCuXDk0a9YMvXv3xooVK5CSkoJBgwahc+fOsLCwyFEWFsqJiIiIiIiIiIiIqNBdvnwZDRo0kN3/OLZ5t27dsH79eowZMwZxcXHo06cP3r17h7p16+Lo0aPQ1taWPWfLli0YNGgQPDw8oKamhnbt2iEwMDDHWSQZGRkZeV8lIspPH5LShY5QINLSxdncaGtIhY5QIMS6d0hIThM6QoHQ1RLn+zBdpG9EsbaHEOlqqUvFOVqhWHs0ibXdEOv+q0yvbUJHKBDPN/xP6AgFIiVNnN9TNNXF2c6ni3Nzibad1xDp8YaOhtAJFMvB2y+FjlAoWlYwFTpCrojzU0hERERERERERERElE0ceoWIiIiIiIiIiIiogEkg0lP6RII9yomIiIiIiIiIiIhIpbFQTkREREREREREREQqjYVyIiIiIiIiIiIiIlJpLJQTERERERERERERkUrjxTyJiIiIiIiIiIiICpiE1/JUaOxRTkREREREREREREQqjYVyIiIiIiIiIiIiIlJpLJQTERERERERERERkUrjGOVEREREREREREREBUwNHKRckbFQTqSA1NXEebJHalqa0BEKRHpGhtARCoSaSK8ykibS7SVWfB8qF6lUnNtLpG9D0RLpxwvp6UInKBh3V3YWOkKBcBi6X+gIBSJsYWuhIxSI1DSRNhykVHi8QSQ8cVbjiIiIiIiIiIiIiIiyiYVyIiIiIiIiIiIiIlJpLJQTERERERERERERkUrjGOVEREREREREREREBYxj0Ss29ignIiIiIiIiIiIiIpXGQjkRERERERERERERqTQWyomIiIiIiIiIiIhIpXGMciIiIiIiIiIiIqICxjHKFRt7lBMRERERERERERGRSmOhnIiIiIiIiIiIiIhUGgvlRERERERERERERKTSWCgnIiIiIiIiIiIiIpXGi3kSERERERERERERFTAJeDVPRcYe5URERERERERERESk0lgoJyIiIiIiIiIiIiKVxkI5EREREREREREREak0FsqJiIiIiIiIiIiISKXxYp5EREREREREREREBUyN1/JUaOxRTkREREREREREREQqjYVyIiIiIiIiIiIiIlJpLJQTERERERERERERkUpjoZyUjkQiwf79+4WOQURERERERERElG0SFfmnrFgoJ6UTGRkJT09PoWMotV9Xr8RPndqhTg0XNKhfG8OGDMCjh/8KHSvHrl25jJFDB6BlYzfUcimPs6dPfHPeOX7TUMulPLZv2ViICfPHzu3b0LFNK9StWRV1a1ZF1y6d8Nef54SOlWdXLl/C4AH90Mi9Lio5OeLUyW9vP0W1ae1q9Pq5IxrXq46Wjeph/IjBiHj0UG6epKQkBMyegeYN66Bx3WqYOHooot+8Fihx3m3fugWejRuiuoszunTugFs3bwodKU/E8D78lri4OATMnYWWzRrCtUZl9Ojqg5Dbt4SOlSdsD5WT2NqNFcuWoIpzWblbWy/lOjbdtG41enXtiMb1q6Nl43oYP1J+//U+5h0Wzp0Jn7Yt0NC1Ctq28MCiebMQG/tBwNQ/tnndavTp2glN3WqgVZP6mDBqyFf75Y8yMjIwekg/1K9eAX+eOVnISb9vUFMHHBrrjvCFLXFjbnP82rcmbE31vzn/pkG18Wx5GzStZC43vZJVUewY6orQgBYICWiBLYProHxJg4KOnyNXr1zC8MH94dmoPqpXKoczp+Tbv4yMDKxYGohmHvVQt0ZlDOjzCyIePxImbA5wvbheikjsxxtE+YGFclI6ZmZm0NLSEjqGUrty+SI6+XTBxq07sWLVOqSmpKJ/n55IiI8XOlqOJCTEw97BEaPGT/7ufGdOncDtWzdgYlKikJLlL1MzUwwePhJbdu7Blh27UaNGLQwfPBAP7t8TOlqeJCTEw9HREeMnTRU6Sq5du3oJbTv4YOX6bVi4bDVSU1MxfGBvJCR8+iwtCZiD8+fOYMbsBViyegNeR0Vh4uihAqbOvaNHDmP+XH/0HTAQ23ftg6NjWfTv2xNv3rwROlquieF9+C1+0yYh+MLfmD5zDrbv/g01a7tiQN8eePXypdDRco3tofIRY7sBALZ29vjj9J+y268btwodKUdk+69127Bw6X/7r0Gf9l+vo6LwOuoVBg4bhU079mPitJn458JfmD39+8dcQrt+9TLadPDBirVbsSBoFVJTUzBycB+5/fJHu7ZtAiSK2eOtlr0xNpz9F15zz8Jn8V/QkKph62BX6GhKv5q3d0NbZGR8vQxdLSm2DHLFs+gEeM09izbzzyEuMRVbBrtCXU1x1jshIQEOjo4Y843j+Y3r1mDHts0YP2ka1m3eAR0dXQzu3xtJSUmFnDRnuF5cL0Uk5uMNovzCQjkJZvfu3XB2doaOjg6MjIzQqFEjxMXFAQDWrl0LJycnaGlpwdzcHIMGDZI970dDr3xvud27d4e3tzd8fX1hYmICAwMD9OvXD8nJybLnHz16FHXr1kXRokVhZGSEli1b4sGDB3Kv8fTpU/j4+KB48eLQ09NDtWrVEBwcLHv8t99+Q5UqVaCtrY0yZcrA19cXqamp+fFnyxfLVv6K1t5tYWdnD8eyZTF95mxERj5HaGiI0NFypE7d+ug3cCjcGzb65jyvXr1EwJyZ8J01F1J19UJMl3/c3BuiXn03WFlZw8raBoOGDoeuri5u3rghdLQ8qVvPDYOGDodHo8ZCR8m1BUGr0LxVG5SxtYO9Q1lM8J2Jly8iER4WCgCI/fABB3/bg8EjxqBqjVooW84JE6b64daN67h9S/m236YN69C2fUd4t2kHWzs7TJrqC21tbezfu0foaLkmhvdhVhITE3Hq5HEMGT4KVapWR6nSVujbfxBKlSqN3bu2CR0v19geKh8xthsAIJVKYWxsIrsVK1ZM6Eg5smDJKjT3+mz/NU1+/1XGzh4z5y1G3foNUNKyNKpWr4U+A4bi/J9nFOqY9kvzl6yEp5c3bGztYOdQFhOmyq/XR/fC72DHlg0YN3mGQEm/739Bf2PnPxG4G/kBoc/eY9jGK7A00kXF0kXl5nOyNETfRvYYuenqV8uwMy2CYvqamH8wDA9exuJu5AcsOHQHJQy1YWmkW0hr8mOudeuj/6BhaODxdfuXkZGBbVs2okfvfnBr4AF7B0f4+s3G66hXOHtKsXvCcr24XopIzMcbRPmFhXISRGRkJHx8fNCjRw+EhYXhzJkzaNu2LTIyMrB8+XIMHDgQffr0wa1bt3DgwAHY2dnlebkfnTx5UvbYtm3bsHfvXvj6+soej4uLw4gRI3D58mWcPHkSampqaNOmDdLT0wEAsbGxcHNzw7Nnz3DgwAHcuHEDY8aMkT3+559/omvXrhg6dChCQ0OxcuVKrF+/HjNnzszHv2D++ngaraGhocBJ8ld6ejp8J43D/7r1QBlbe6Hj5Iu0tDQcPXwICQnxqFi5stBx6Atx/32WDAwyP0vhYSFITU1FtZq1ZfNY2ZSBqZk5Qm5eFyJirqUkJyMsNAS1ateRTVNTU0OtWnVw88Y1AZNRVtLS0pCWlgbNL87A0tLSxvVrXxdUlBHbQ8Un5nYjIuIxmjSsB69mjTBx7ChERj4XOlKefLn/+tY8enr6UFeijgexsbEA5NcrMTEB0yePwbAxE2FkbCxUtBwx0NEAALyL/9S5R1tDiqAe1TBh+w1Evf+6V+uDl7GIjk1C5zpW0JBKoK2hBh9XK9yNfI8nb5TjLNJnz57izevXqPHZcZR+kSJwcq6ImzeV9wdSrpdyEet6EVHWlOcoh0QlMjISqampaNu2LaysrAAAzs7OAAA/Pz+MHDkSQ4d+GpqgevXqeV7uR5qamli7di10dXXh5OSE6dOnY/To0ZgxYwbU1NTQrl07ufnXrl0LExMThIaGokKFCti6dSuioqJw6dIlFC9eHADkCvm+vr4YN24cunXrBgAoU6YMZsyYgTFjxmDqVMU7xSk9PR3zZs9CZZcqsLN3EDpOvtq0bg2kUik6+vxP6Ch5du9uOLp18UFychJ0dHURsDgItrbZ+wGJCkd6ejoC58+BcyUXlLHL/GHmzZvX0NDQQJEi8uOBFjcywhslG6f87bu3SEtLg5GRkdx0IyMjPFTCaxyInZ6eHipWqow1q5bDxsYWxY2McOzIIdy6eR2WpUoLHS9P2B4qD7G2G87OleA7wx9W1jZ4/foVVi1fip7d/odd+w5AT+/b40grqvT0dAQGyO+/vvTu3VusX7MCXm06FHK63EtPT8eSBbO/Wq8lC+aiQsXKqOfWUMB02SeRAL4dKuLi/TcIf/5pjHjfDs64/G80/rgZmeXz4pJS0X7hn/i1by0Ma14WAPDwVSx+WnIeaelZjNWigN68zjxW+roNMcab11FCRMoXXC/lItb1IuEo6Khf9B8WykkQlSpVgoeHB5ydndG0aVM0adIE7du3R0pKCp4/fw4PD498Xe7np8NWqlQJurqfTjesXbs2YmNj8eTJE1hZWeHevXuYMmUKgoOD8fr1a1lP8YiICFSoUAHXr1+Hi4uLrEj+pRs3buD8+fNyPcjT0tKQmJiI+Ph4udcGMi/09+XYZulqWoU2Dru/ny/u37+H9Uo2tuaP3AkNwY5tm7Bh6x5IRLAnsraxwfY9+xD74QNO/HEMUyaOw5r1m1gcUiALZvvh3wf3sOzXTUJHIQIATJ85B9OnToRnYzdIpVI4li2Pps1aICxMuYbZ+hLbQxKaa736sv87ODrC2bkSWjRtiOPHjsK7bXsBk+XOgjn/7b/WZL3/iouNxeih/WFdxhY9+w4o5HS5t3CuHx4+uI+g1Z8u5P7X2dO4ejkYv27eLWCynJnVuRIcLYqgzfxPFy5uXNEMro4maDLr1Defp62hhvn/q4LL/0Zj4NpLkKpJ0K+RPTYOrIMWs08jMSW9MOITEREpFQ69QoKQSqU4fvw4jhw5gvLly2PJkiVwdHTEyzxeYOxby334MOur3WfFy8sL0dHRWL16NYKDg2Vjj38cx1xHR+e7z4+NjYWvry+uX78uu926dQv37t2Dtrb2V/P7+/vD0NBQ7jZvjn8O1jr3/GdOx7mzZ7Bm7QaYmpkVymsWluvXruBtdDS8m3vAtZozXKs540XkcwQumAvv5t8e01xRaWhoonRpK5R3qoAhw0fCwbEstm3e+OMnUqFYMMcPf/91FoEr16GE6afPkpGRMVJSUvDhw3u5+aPfvIGRkXKc7v1RsaLFIJVKv7oA35s3b2CsJKeuqxrLUqWxau0m/HnhCg4dO4WNW3ciNTUFJS0thY6WJ2wPlYeqtBtFDAxQ2soaTyIeCx0lx2T7rxXy+6+P4uPiMHJIX+jq6WHWvECoq2sIkDLnFs6dib//PItFy9fKrdfVy8F4/vQJWjSsjQa1KqFBrUoAgMljh2NI3+4Cpf02v04V0aiCGTos/AuR7xJl0+s6msDKWA9hAS3xOKg1Hge1BgCs7lMTu4bXBQB4Vy+FUka6GL7xCm48foerD99i4NpLKG2kiyaVzAVZn5z6ODTO123IaxgZmwgRKV9wvZSLWNeLiLLGQjkJRiKRwNXVFb6+vrh27Ro0NTVx/PhxWFtb4+TJk/m63H379skev3HjBhISEmT3//nnH+jr66NUqVJ48+YNwsPDMWnSJHh4eKBcuXJ4+/at3PIrVqyI69evIzo6OsvXr1KlCsLDw2FnZ/fVTU3t64/c+PHjERMTI3cbPXZ8rtc/OzIyMuA/czpOnTyOVWs3oKRlqQJ9PSF4tmiFzTv3Y+P2vbKbiUkJdOnaA4uXrRY6Xp5lpKfLXYSWhJGRkYEFc/xw7vRJLF6xFhYl5QuQjuWcoK6ujisX/5FNi3j0EC9fRMKpYuVCTps3GpqaKFfeCcH/XJBNS09PR3DwBVSs5CJgMvoRHV1dGJuUwPv3Mbhw4Tzc3HN31paiYnuouFSl3YiPj8PTJ09gbKI8BRPZ/uvMSSxe/vX+C8jsST58UG+oq2tgzoKgQjvbMS8yMjKwcO5M/HnmJBZlsV5duvXCuq178evm3bIbAAwaPgbjpvgJEfmb/DpVRLPKFui46K+vxhQPOnYXjWaeRJNZp2Q3AJi2+yZGbMy8DoWOphTpGcBnl2qS3VdTkrMtS5a0hJGxMS4FfzqOio2NRcitm6hYsZKAyfKG66VcxLpeRJQ1Dr1CgggODsbJkyfRpEkTlChRAsHBwYiKikK5cuUwbdo09OvXDyVKlICnpyc+fPiA8+fPY/DgwVkuy8PDA23atMGgQYO+u9yPkpOT0bNnT0yaNAmPHj3C1KlTMWjQIKipqaFYsWIwMjLCqlWrYG5ujoiICIwbN07u9Xx8fDBr1ix4e3vD398f5ubmuHbtGiwsLFC7dm1MmTIFLVu2ROnSpdG+fXuoqanhxo0buH37Nvz8vj4A19L6epiVhJR8+CN/xyw/Xxw5fBCLApdBT08Pr/8bW01fv0iWvd4VVeYX0wjZ/efPnuFueBgMDAxhZm4Bw6JF5eaXqqvDyNgYVtY2hZw0bwIXBsC1Xn2Ym5sjLi4ORw4dxOVLF7Fs5Rqho+VJfFwcIiI+bb9nT5/iTlgYDA0NYW5hIWCy7AuYPQMnjh6G/4Il0NXVlY1TqK9fBFra2tAvUgQtW7fDkgVzYWBgCF19fSyaOwsVKlZGBWflO7D+udsvmDxhLJycKqCCc0Vs3rQBCQkJ8G7TVuhouSaG9+G3XDj/FzKQASsrGzx58hiBC+fD2toGrVq3ETparrE9VD5ibDcWzp+D+m4NYG5hgaioV1ixNAhqUjU082wpdLRsC5jz3/4rIOv918cieVJiIqbMmI242FjE/XdhzKLFikMqlQoZ/5sWzvHDiWOHMWt+IHR19WRjC+vr60NLWxtGxsZZXsDT1Mw8yx8LhDKrcyV4V7dEjxX/IDYpFSYGmd8VPiSkIDElHVHvk7K8gOez6ARZUf1c2CtMalsBszpXwtoz/0JNAgxq6oDU9HT8Ha444yrHx8fhScTnx/NPEX4ns/0zM7eAT5euWLt6BUpZWaFkSUusWBoIY5MScGuo2GeIcr24XopIzMcbykQC5fixUlWxUE6CMDAwwLlz57Bo0SK8f/8eVlZWCAgIgKenJwAgMTERCxcuxKhRo2BsbIz27b893uODBw/w+r+D4B8tF8gsrNvb26N+/fpISkqCj48Ppk2bBgBQU1PD9u3bMWTIEFSoUAGOjo4IDAyEu7u77Pmampr4448/MHLkSDRv3hypqakoX748li5dCgBo2rQpDh48iOnTp2POnDnQ0NBA2bJl0atXr3z+K+berh3bAAC9fvlZbrqvnz9aeyvPF9ew0BAM7N1ddn9xwBwAQHMvb0yZPkugVPkvOjoakyeMxeuoKOgXKQJ7B0csW7kGteq4Ch0tT0JCbqPXL11l9+fPzRxyqFXrNpgxa7ZQsXJk/+4dAIDBfbrLTZ8w1Q/NW2UWIwePHAuJmgQTxwxDSnIKatR2xchxkwo7ar5o5tkcb6OjsSwoEK9fR8GxbDksW7kmy6KDshDD+/BbYmM/IChwIV69fAEDQ0M09GiCgYOHQV1DOYZOyArbQ+Ujxnbj5cuXGD92JGLevUOxYsVRuUpVbNiyA8W+cf0aRSTbf30x3MiEqX5o7tUG4XdCEXr7JgCgk7en3Dy7DvwBc4uShZIzp/bvyVyvIf1+kZs+foofPL28BUiUO93cygAA9oyoLzd9+IYr2PlPRFZP+cqDl7HovuwCRrQohwOj6yM9Awh58g7/C/obr7IosgslLCQE/Xp1k91fOD/zeL5FK29Mm+GPrr/0QkJCAmZNn4rYD+9RyaUKApetUvgzHLheXC9FJObjDaL8IsnIyFCOS14T5YPu3bvj3bt32L9/v9BRvquge5QLJTElTegIBUJLQ5yjWCnLabk59SExVegIBaKINn/7ViYpqeK8iJpUKs52Q6ztoVilpYvz6018kjiPo9JF+nW0ytiDQkcoEGELWwsdgUi0NNXF+b2SX1PknQnPehhfsXF3VJ4OBJ8T56eQiIiIiIiIiIiIiCibWCgnIiIiIiIiIiIiIpXGEyBIpaxfv17oCEREREREREREpILUOKKfQmOPciIiIiIiIiIiIiJSaSyUExEREREREREREZFKY6GciIiIiIiIiIiIiFQaxygnIiIiIiIiIiIiKmAScJByRcYe5URERERERERERESk0lgoJyIiIiIiIiIiIiKVxkI5EREREREREREREak0FsqJiIiIiIiIiIiISKXxYp5EREREREREREREBUzCa3kqNPYoJyIiIiIiIiIiIiKVxkI5EREREREREREREak0FsqJiIiIiIiIiIiISKWxUE5EREREREREREREKo0X8yQiIiIiIiIiIiIqYLyWp2Jjj3IiIiIiIiIiIiIiUmkslBMRERERERERERGRSmOhnIiIiIiIiIiIiIhUGscoJyIiIiIiIiIiIipgahKOUq7I2KOciIiIiIiIiIiIiFQaC+VEREREREREREREpNJYKCciIiIiIiIiIiIilcZCORERERERERERERGpNF7Mk0gBxSSkCB2hQBTRFmeTw4txKBd1NW4vZZKRIXSCgqGhzr4KJDyxfr6kIm3n9bSlQkcoEAnJaUJHKBD3Ar2FjlAgjLyXCB2hQLz9bYjQEQpEcmq60BEKhFiP52MTU4WOUCC09cVZB8gtcb57xYPf0oiIiIiIiIiIiIhIpbFQTkREREREREREREQqjYVyIiIiIiIiIiIiIlJpHCiIiIiIiIiIiIiIqKBxkHKFxh7lRERERERERERERKTSWCgnIiIiIiIiIiIiIpXGQjkRERERERERERERqTQWyomIiIiIiIiIiIhIpfFinkREREREREREREQFTMKreSo09ignIiIiIiIiIiIiIpXGQjkRERERERERERERqTQWyomIiIiIiIiIiIhIpbFQTkREREREREREREQqjRfzJCIiIiIiIiIiIipgEl7LU6GxRzkRERERERERERERqTQWyomIiIiIiIiIiIhIpbFQTkREREREREREREQqjWOUExERERERERERERUwDlGu2NijnIiIiIiIiIiIiIhUGgvlRERERERERERERKTSWCgnIiIiIiIiIiIiIpXGQrmIPXr0CBKJBNevXwcAnDlzBhKJBO/evcv2MqZNm4bKlSsXSL7sWr9+PYoWLZqr51pbW2PRokWCvDYREREREREREREpBxbKVUidOnUQGRkJQ0PDbD9n1KhROHnyZAGmKliXLl1Cnz59sjVvVkX1Tp064e7duwWQrPBsXrcafbp2QjO3GmjdpD4mjhqCiEcPv5rv9s3rGNa/B5rWqw5P95oY3KcbkhITBUicN69evsTEcaPRoG5N1K5WCR3beCE05JbQsfLF9q1b4Nm4Iaq7OKNL5w64dfOm0JHyhbKv17UrlzFy6AC0bOyGWi7lcfb0iW/OO8dvGmq5lMf2LRsLMWH+uHL5EgYP6IdG7nVRyckRp05+ez2Vya+rV+KnTu1Qp4YLGtSvjWFDBuDRw3+FjpVnYt1eYl2vj5S9PfySWD9fH4lte+3cvg0d27RC3ZpVUbdmVXTt0gl//XlO6Fg5du3KZYweOgCtmrijThUnnD0t/10mPj4OAbP90LpZQ7jXroKf2nlh3+4dAqXNPWXcXqM6VMNfCzvh1a5+eLylF3ZOagH7kkXl5jEtpotfRzbBw8098XpPf/y9uDO869h+taxm1a1xbkFHRO8dgOc7+mDnpBaFtBa5I5b919UrlzB8cH94NqqP6pXK4cwp+fU4deIPDOrbE43q10L1SuUQfidMoKT5Z+2aVXBxLot5c2YJHSXHrl+9jDHDBqBVU3e4VnXCuS/aw+g3r+E3dQJaNXVHwzpVMWJQHzyJeCxQWhUiUZGbkmKhXEmlpKTk+DmampowMzODRJL9d6y+vj6MjIxy/FpCS05OBgCYmJhAV1c318vR0dFBiRIl8iuWIG5cvYw2HXywfO1WBAStQmpqCkYN7oOEhHjZPLdvXseYIf1QvWYdrFi/DSvXb0ebDj6QqClXE/E+Jga/dPWBuro6lixfjd37D2H46LEoYpD9H4cU1dEjhzF/rj/6DhiI7bv2wdGxLPr37Yk3b94IHS1PxLBeCQnxsHdwxKjxk78735lTJ3D71g2YmChnm5KQEA9HR0eMnzRV6Cj56srli+jk0wUbt+7EilXrkJqSiv59eiIhPv7HT1ZgYt1eYl0vQBzt4ZfE+vkCxLm9TM1MMXj4SGzZuQdbduxGjRq1MHzwQDy4f0/oaDmSmJgAOwdHjBw3KcvHAwPm4p+//8JUv9nYtud3dPzpZyyYMxN/nj1VyEnzRhm3Vz3nklhx6CbcRu5Ey0n7oa6uhoN+3tDVUpfNs2ZEEziULIoO0w+i2sAt+O3vB9g8zhOVypjI5vGuY4tfRzbBxuOhqDFoKxqO2o0dZxS7c5NY9l8JCQlwcHTEmG8c9yYmJKCSSxUMGjaykJMVjJDbt7Bn9w7YOzgKHSVXEhL+aw/Hft0eZmRkYNzIIXj+7CnmLFiCdVt3w8zcAkP795SrFRCpGuWqgimY3bt3w9nZGTo6OjAyMkKjRo0QFxeH9PR0TJ8+HZaWltDS0kLlypVx9OhRuec+ffoUPj4+KF68OPT09FCtWjUEBwdn+Tofh1DZsWMH3NzcoK2tjS1btgAA1qxZg3LlykFbWxtly5bFsmXLvpk3q6FXVq9ejVKlSkFXVxdt2rTBggUL5IYa+XLolR+t28ese/fuRYMGDaCrq4tKlSrhwoUL3/1bvnv3Dn379oWpqSm0tbVRoUIFHDx4UG6eY8eOoVy5ctDX10ezZs0QGRkpe6x79+7w9vbGzJkzYWFhAUfHzB3Z573EMzIyMG3aNJQuXRpaWlqwsLDAkCFDAADu7u54/Pgxhg8fDolEIvsx4cuhVx48eIDWrVvD1NQU+vr6qF69Ok6ckP8V3draGrNmzUKPHj1QpEgRlC5dGqtWrfru+hekeUtWwtPLGza2drBzKIvxU2fi5YtI3A0Llc2zdOFctOvUBV2694KNrR1KW9ugYeNm0NTUFCx3bqxfuwamZubw9fNHBeeKKGlpidp16qJUqdJCR8uzTRvWoW37jvBu0w62dnaYNNUX2tra2L93j9DR8kQM61Wnbn30GzgU7g0bfXOeV69eImDOTPjOmgupuvo351Nkdeu5YdDQ4fBo1FjoKPlq2cpf0dq7Lezs7OFYtiymz5yNyMjnCA0NETpanoh1e4l1vQBxtIdfEuvnCxDn9nJzb4h69d1gZWUNK2sbDBo6HLq6urh544bQ0XKktms99B04FG7f2C/funkdzb1ao0q1GjC3KAnvdh1hZ++I0NvKdQaiMm6v1lN+w+YTYQiLiMath6/RZ8EJlC5hABe7T50IapUzw7Lfb+Ly3Zd49OI95uy4hHdxSbJ5pGoSzO/rhglr/8KaI7dx//k73HkSjT1/Ke4PBIB49l+udeuj/6BhaOCR9Xo092qN3v0GokbNOoWcLP/Fx8dhwrhRmDx1BgwMDISOkyu1Xeuhz4Cs28MnEY8RcusGRo2fgnJOzrCytsGo8VOQlJSE40cPC5CWSDGwUJ5LkZGR8PHxQY8ePRAWFoYzZ86gbdu2yMjIwOLFixEQEID58+fj5s2baNq0KVq1aoV79zJ33rGxsXBzc8OzZ89w4MAB3LhxA2PGjEF6evp3X3PcuHEYOnQowsLC0LRpU2zZsgVTpkzBzJkzERYWhlmzZmHy5MnYsGFDttbh/Pnz6NevH4YOHYrr16+jcePGmDlz5nef86N1+2jixIkYNWoUrl+/DgcHB/j4+CA1NTXLZaanp8PT0xPnz5/H5s2bERoaitmzZ0MqlcrmiY+Px/z587Fp0yacO3cOERERGDVqlNxyTp48ifDwcBw/fvyrIjsA7NmzBwsXLsTKlStx79497N+/H87OzgCAvXv3wtLSEtOnT0dkZKRcEf5zsbGxaN68OU6ePIlr166hWbNm8PLyQkREhNx8AQEBqFatGq5du4YBAwagf//+CA8P/+7ftrDExsYCgKyX9dvoNwi9fRNFixfHgB5d4N20Pob06Y6b168KGTNXzp45hfLlK2DMiKHwcKsDnw5tsHf3TqFj5VlKcjLCQkNQq/anA041NTXUqlUHN29cEzBZ3oh1vb6Unp4O30nj8L9uPVDG1l7oOPQDsbEfACBHw5QR5ZWqtIdi+XypwvZKS0vD0cOHkJAQj4oCX68ovzlXrIw/z55G1KuXyMjIwJVLwXgS8Qg1arkKHS3XlHV7Gehldsp5G/tpuMd/wl6gfX17FNPXgkQCdKhvD21NdZy79RQA4GJXAiWN9ZGenoELgT74d1NP7PdthfJWxQVZBxIv/5nTUa+eu1xbLyYp/52F/3nnODU1NWhqaiplLYAovyhntzYFEBkZidTUVLRt2xZWVlYAICu6zp8/H2PHjkXnzp0BAHPmzMHp06exaNEiLF26FFu3bkVUVBQuXbqE4sUzd+h2dnY/fM1hw4ahbdu2svtTp05FQECAbJqNjQ1CQ0OxcuVKdOvW7YfLW7JkCTw9PWUFZwcHB/z9999ZFpk/+tG6fTRq1Ci0aJE5Tpyvry+cnJxw//59lC1b9qtlnjhxAhcvXkRYWBgcHBwAAGXKlJGbJyUlBStWrICtbeb4dIMGDcL06dPl5tHT08OaNWu+2Qs6IiICZmZmaNSoETQ0NFC6dGnUqFEDAFC8eHFIpVIUKVIEZmZm31z/SpUqoVKlSrL7M2bMwL59+3DgwAEMGjRINr158+YYMGAAAGDs2LFYuHAhTp8+LevpLpT09HQELZgN50ouKGOXWbB7/izzoHP96mXoP2QU7BzL4o9DBzBiQE+s374flqWthIycI8+ePsHundvQpWt39OjdFyG3b2He7JnQ0NCAV+s2QsfLtbfv3iItLe2rYZCMjIzwUInHehXren1p07o1kEql6OjzP6Gj0A+kp6dj3uxZqOxSBXb2DkLHIRWiCu2hmD5fYt5e9+6Go1sXHyQnJ0FHVxcBi4Nga/vj7ynKZMTYiZjjNxWtmzWEVF0dahIJxk32hUvVakJHyzFl3l4SCTCvT338HfIcoY+jZdP/N/swNo31xPMdfZGSmob4pFR08juEfyNjAAA2Zpk9eyd1qYmxq//E41fvMbRNFRzzb4eKfTbibWySIOtD4nL0yCHcCQ3F5u27hY5SYKysbWBqZo6VQYsweuJU6OjoYMeWjXj18gXevI4SOp6oSZR5AG8VwB7luVSpUiV4eHjA2dkZHTp0wOrVq/H27Vu8f/8ez58/h6urfI8EV1dXhIVlXsji+vXrcHFxkRXJs6tatU8Hb3FxcXjw4AF69uwJfX192c3Pzw8PHjzI1vLCw8NlheKPvrz/ueys20cVK1aU/d/c3BwA8OrVqyyXe/36dVhaWsqK5FnR1dWVFck/LvPL5Tk7O393qJAOHTogISEBZcqUQe/evbFv375v9nL/ltjYWIwaNQrlypVD0aJFoa+vj7CwsK96lH++/hKJBGZmZt9c/6SkJLx//17ulpRUMAd4C+f64eGD+5gyc55sWsZ/ZzJ4temA5q3awMGxHAaNGItSVtY4fGBvgeQoKOnpGShbrjwGDx2BsuXKo12HTmjTrgN279wudDRSUXdCQ7Bj2yZM9p2Vo+tDkDD8/Xxx//49zJm3UOgoRKLDz5dysLaxwfY9+7Bx6w506NgZUyaOw4MH94WOla92b9+CkFs3MXdhENZt3onBw0cjYLYfLgV/f6hIRaTM22tRf3c4WRmh6xz5IUqn/lwbRfW14DlhL1yH7UDgvmvYPM4TTlaZP0yp/Xc8NWfHJez/+wGu3Y9Cn4UnkAGgbV2euUd59+JFJObNnoWZs+dDS0tL6DgFRl1DA7PmL0ZExCN4NqgDD9dquHr5Imq51oOakl2rjCg/sUd5LkmlUhw/fhx///03/vjjDyxZsgQTJ07E8ePHf/hcHR2dXL2mnp6e7P8fh89YvXo1atas+VU2oWloaMj+/7E49K2hZbLz9/h8eR+XmZGRITft879PVkqVKoXw8HCcOHECx48fx4ABAzBv3jycPXv2q+V/y6hRo3D8+HHMnz8fdnZ20NHRQfv27WUXD/1e3m+tv7+/P3x9feWmjRw3CaPGT8lWpuxaNHcmLvx5FktWbUAJ00+95o2MMy+MY20jfzV5K+syePniRb5mKGjGJiYo80UvGpsytjh54g+BEuWPYkWLQSqVfnWBsDdv3sDY2FigVHkn1vX63PVrV/A2OhrezT1k09LS0hC4YC62b9mI/YdPfOfZVJj8Z07HubNnsHbDZph+58wiooIg9vZQbJ8vMW8vDQ1NlP7vbMLyThUQEnIb2zZvxKSp03/wTOWQlJiIFUGL4B8QCNd6bgAAOwdH3Lsbjq0b16F6zdoCJ8wZZd1eC/u5oXkNGzQauwfP3sTKptuYGaK/VyVU6b8ZYRGZvcxvPXwN1woW6NuyIoYsPY3It5kXGbwT8akXenJqGh69iEGpEkUKd0VIlMJCQhAd/QY/dfp0Nn9aWhquXrmMHdu2IPjKTYWoueSHsuWcsGHbXsR++ICU1BQUK1Ycvbt2RtnyTkJHIxIMfybKA4lEAldXV/j6+uLatWvQ1NTEyZMnYWFhgfPnz8vNe/78eZQvXx5AZm/j69evIzo6OqvFZoupqSksLCzw77//ws7OTu5mY2OTrWU4Ojri0qVLctO+vP85AwODH65bblSsWBFPnz7F3bsFf6VyHR0deHl5ITAwEGfOnMGFCxdw61bmhXs0NTWRlpb23eefP38e3bt3R5s2beDs7AwzMzM8evQoT5nGjx+PmJgYudvgEWPztMzPZWRkYNHcmfjzzEksWr4W5iUt5R43sygJY5MSePL4kdz0JxGPYfrf2QDKonJlFzx69FBu2uNHj2BubiFQovyhoamJcuWdEPzPp55O6enpCA6+gIqVXARMljdiXa/PebZohc0792Pj9r2ym4lJCXTp2gOLl60WOh4hs430nzkdp04ex6q1G1DSspTQkUgFibU9FOvnS6zbKysZ6elfdQhRZqmpqUhNTf2qt6SamhrSv+iEo4yUYXst7OeGVrVt0WzCXjx++V7uMV2tzH58X26LtLQMqKlldr66du8VEpNTYW9ZTPa4ulQNpUsYIOKV/PKIcqNGrVrYtfcAtu/aJ7uVd6qA5i28sH3XPtEUyT+nX6QIihUrjicRj3EnLAR13RoKHYlIMOxRnkvBwcE4efIkmjRpghIlSiA4OBhRUVEoV64cRo8ejalTp8LW1haVK1fGunXrcP36dWzZsgUA4OPjg1mzZsHb2xv+/v4wNzfHtWvXYGFhgdq1a+PixYvo2rUrTp48iZIlS34zg6+vL4YMGQJDQ0M0a9YMSUlJuHz5Mt6+fYsRI0b8cB0GDx6M+vXrY8GCBfDy8sKpU6dw5MiR7w4P8KN1y45nz57Bw8MDGzduRI0aNeDm5ob69eujXbt2WLBgAezs7HDnzh1IJBI0a9Ys28v9kfXr1yMtLQ01a9aErq4uNm/eDB0dHdkY89bW1jh37hw6d+4MLS2tLHsE2dvbY+/evfDy8oJEIsHkyZN/eBHWH9HS0vrqlK749yl5WubnFs7xw8ljhzFzfiB0dPXw5vVrAIC+vj60tLUhkUjQ+X+/YN2qpbB1cISdQ1kcO/gbIh4/xPQ5C/ItR2Ho0rU7fvnZB7+uXoHGTT0Rcusm9u7ZiUlTFLtXTXb83O0XTJ4wFk5OFVDBuSI2b9qAhIQEeLdp++MnKzAxrFd8fByePvk0/NLzZ89wNzwMBgaGMDO3gGHRonLzS9XVYWRsDCvr7P2oqSji4+Lkhpl69vQp7oSFwdDQEOYWyvtj1Cw/Xxw5fBCLApdBT08Pr/8bk1Ffvwi0tbUFTpd7Yt1eYl0vQBzt4ZfE+vkCxLm9AhcGwLVefZibmyMuLg5HDh3E5UsXsWzlGqGj5ciX++XIZ0/l9ssuVasjaFHmkApm5ha4duUSjhw6gCEjxgiYOueUcXstGuCOTm6O6DDjIGITUmBaTBcAEBOXhMTkNIQ/fYv7z94haFBDjP/1L7x5n4hWtcvAw6U02voeAAB8SEjGmsO3MLlLLTyNikXEq/cY3q4qAGDvX4o77IxY9l/x8XF4EvH5ce9ThN/JXA8zcwvExLzDi8hIvI7KHHb08X+dmIyMjWH835nMik5PT/+ra2no6OjAsGhRpbvGxlffU57Lt4enjh9D0WLFYGpmjn/v38Oi+f6o594QNWsr78WNifKKhfJcMjAwwLlz57Bo0SK8f/8eVlZWCAgIgKenJ5o2bYqYmBiMHDkSr169Qvny5XHgwAHY22eOmaapqYk//vgDI0eORPPmzZGamory5cvLLoYZHx+P8PBwpKR8v1jaq1cv6OrqYt68eRg9ejT09PTg7OyMYcOGZWsdXF1dsWLFCvj6+mLSpElo2rQphg8fjqCgoG8+Z8iQId9dt+xISUlBeHg44uPjZdP27NmDUaNGwcfHB3FxcbCzs8Ps2bOzvczsKFq0KGbPno0RI0YgLS0Nzs7O+P3332UXYpo+fTr69u0LW1tbJCUlfTW0CwAsWLAAPXr0QJ06dWBsbIyxY8fi/XvF7rnw254dAICh/X6Rmz5uih88vbwBAB1++hnJyUkIWjAHH96/h629AwKCVqOkZenCjpsnThWcMX/REgQtWoDVK5bBoqQlRo0Zj+YtvYSOlmfNPJvjbXQ0lgUF4vXrKDiWLYdlK9fASMlP8RbDeoWFhmBg7+6y+4sD5gAAmnt5Y8r0WQKlyn8hIbfR65eusvvz5/oDAFq1boMZs/K3vS5Mu3ZsAwD0+uVnuem+fv5o7a28BS+xbi+xrhcgjvbwS2L9fAHi3F7R0dGYPGEsXkdFQb9IEdg7OGLZyjWoVUe5CiZ3QkMwqM+n497ABXMBAM29WmOS7yxM95+H5UsWYdrEsXj/PgZm5hboO3AI2rTvJFTkXFHG7dW3ReZ1nI7PaSc3vffC49h8IgypaenwnvYb/Lq7YvcUL+jraODB83foteA4jl1+LJt//NrzSE3PwK8jm0BHSx2Xwl/Ac8JevFPgC3mKZf8VFhKCfr26ye4vnJ953NuilTemzfDHuTOnMX3KBNnjE8eOBAD07jcQffoPKtywhDuhIRjc91N7uOS/9tCzZWZ7+OZ1FJYsnIvoN69hZGyCZi1a4Zfe/YSKqzJ46SrFJsnIqhpIKqt37964c+cO/vzzT6GjqLQX+dijXJEU0Rbnb3NSNe7plElC8veHWFJWOpriOw0UAMR6lMIDZFIE/HwpFzEMDZIV7peVi5H3EqEjFIi3vw0ROkKBSE7N29nPikpdpN+/4kXaHhrri7MOkFtXHil2Z8v8UtXaQOgIucJ3q4qbP38+GjduDD09PRw5cgQbNmzAsmXLhI5FREREREREREREVGhYKFdxFy9exNy5c/HhwweUKVMGgYGB6NWrl9CxiIiIiIiIiIiIiAoNC+UqbufOnUJHICIiIiIiIiIiEj1xDhwkHmpCByAiIiIiIiIiIiIiEhIL5URERERERERERESk0lgoJyIiIiIiIiIiIiKVxkI5EREREREREREREak0XsyTiIiIiIiIiIiIqKDxap4KjT3KiYiIiIiIiIiIiEilsVBORERERERERERERCqNhXIiIiIiIiIiIiIiUmkslBMRERERERERERGRSuPFPImIiIiIiIiIiIgKmIRX81Ro7FFORERERERERERERCqNhXIiIiIiIiIiIiIiUmkslBMRERERERERERGRSuMY5UREREREREREREQFTMIhyhUae5QTERERERERERERkUpjoZyIiIiIiIiIiIiIVBoL5URERERERERERESk0lgoJyIiIiIiIiIiIiKVxot5EhERERERERERERUwXstTsbFHORERERERERERERGpNBbKiYiIiIiIiIiIiEilcegVIgWkpS7O37CkajzJiISnJuH7UJlkIEPoCAUiLU3oBAVDrM18ujjfhhBrc5iWJs4NJtbjKC11qdARCkSaSBuO57sGCh2hQDRa9KfQEQrE7wPqCB2hQLyNSxE6QoEwLqIpdAQilcdCOREREREREREREVFBE+fv3qIhzm6rRERERERERERERETZxEI5EREREREREREREak0FsqJiIiIiIiIiIiISKWxUE5EREREREREREREKo0X8yQiIiIiIiIiIiIqYBJezVOhsUc5EREREREREREREak0FsqJiIiIiIiIiIiISKWxUE5EREREREREREREKo1jlBMREREREREREREVMAmHKFdo7FFORERERERERERERCqNhXIiIiIiIiIiIiIiUmkslBMRERERERERERGRSmOhnIiIiIiIiIiIiIhUGi/mSURERERERERERFTAeC1PxcYe5URERERERERERESk0lgoJyIiIiIiIiIiIiKVxkI5EREREREREREREak0FsqJiIiIiIiIiIiISKXxYp5EREREREREREREBY1X81Ro7FFORERERERERERERCqNhXIiIiIiIiIiIiIiUmkslItQ9+7d4e3tLbvv7u6OYcOGFXoOa2trLFq0SHZfIpFg//79333Ol9mJiIiIiIiIiIiIChrHKFdw7u7uqFy5slzBWVlFRkaiWLFiAIBHjx7BxsYG165dQ+XKlWXzLF68GBkZGQIlFK9rVy5j88a1CA8NwevXUZizIBBuDRplOe8cv2nYt2cnho0ah85duhZy0ry5cvkS1q/9FWGhtxEVFYWFgUvR0CPr9VQmXC/FdvXKJWzesBZ3wkLwOioKcxcsgXvDzPVITUnB8qWL8fdf5/Ds6VPoF9FH9Zq1MWjISJiUKCFw8tzZvnULNqz7Fa9fR8HBsSzGTZgM54oVhY6Vazu3b8PuHdvw/PkzAEAZOzv06TcQdevVFzhZ3rRs1hCRz59/Nb1Dp58wbuIUARLlv7VrVmHJ4gX46X9dMXrsBKHj5ImYt9erly+xeOF8/P3XOSQmJqJUqdKY5jcL5Z2chY6WbVevXMKm9Z/a+XkLP7XzAHDqxB/Yu2sH7oSFICYmBpt37IVj2XICJs6dFcuWYNXypXLTrK1tsPf3IwIlyh9i/XylpaVh1fIgHDn4O968eQ1jkxLwau2Nnn36QyJRngFwf/Q9ZfqUCTj8+36559SqUxeLlq4q5KTf9r8alnBzMIZVcR0kpabj1rP3WH7uEZ68TZDNoymVYJB7GXiUNYGGVA0XH71FwIn7eBufIrcsT6cS6FTNEqWK6SA+ORWnw19jwckHhb1K3ySG7fWl3/fuwMF9O/EyMrOdsLKxRZcefVGjdj3ZPKG3bmDdykDcCb0FqZoUZewd4b9oBbS0tIWKnStibeeVjYSDlCs0Fsqp0JiZmf1wHkNDw0JIonoSEuJh7+AIr9ZtMW7kkG/Od+bUCdy+dQMmJspZwEtIiIejoyO827bDiKGDhI6Tb7heii0xISHz8+XdFmNHyH++EhMTER4Wih69+8PBsSzev4/Bgrn+GDlsADZu3S1Q4tw7euQw5s/1x6SpvnB2roQtmzagf9+e+O3gURgZGQkdL1dMzUwxePhIlLayAjIy8Ptv+zF88EBs370Xtnb2QsfLtU1bdyMtPU12/8H9exjQpwcaNWkqYKr8E3L7Fvbs3gF7B0eho+QLsW6v9zEx+KWrD6pVr4kly1ejWLHiiIh4hCIGynW8l5CQAAdHR7TybosxI74+jkpMSEAllypo1LQZZvoqb+EVAGzt7LF89VrZfalU+b8uivXztWHtGuzeuR2+fv4oY2uP0JDbmD5lAvT1i6Bzl5+Fjpdt2fmeUqtOXUz2nSm7r6GpWVjxssWllCH2XnuOOy9iIVWToE89ayzsUAH/W3cFiSnpAIDBDWxRp0wxTD4QhrjkNAz3sMXM1uUwYNtN2XI6VS2JztVKYtnZhwiJ/AAdDTWYGSpWIVYM2+tLxiVM0bP/MJQsVRoZGRk4fvgApo0dimXrd8K6jB1Cb93AhBH90fnnnhg4YjykUin+vX8XEolyDtAgxnaeKD8p5ydbRXTv3h1nz57F4sWLIZFIIJFI8ODBA/Ts2RM2NjbQ0dGBo6MjFi9enKPlHjp0CIaGhtiyZUuWj585cwYSiQSHDh1CxYoVoa2tjVq1auH27dty8+3ZswdOTk7Q0tKCtbU1AgICvvu6nw+9YmNjAwBwcXGBRCKBu7u7bJ0/H3olPT0dc+fOhZ2dHbS0tFC6dGnMnJm5001OTsagQYNgbm4ObW1tWFlZwd/f/5uvn5qaiiFDhqBo0aIwMjLC2LFj0a1bN7nX+3K4GACoXLkypk2bJrcea9asQZs2baCrqwt7e3scOHBA9vjbt2/RpUsXmJiYQEdHB/b29li3bt13/zYFrU7d+ug3cKhc76cvvXr1EgFzZsJ31lxI1ZVzZ1m3nhsGDR0Oj0aNhY6Sr7heiq1O3froP2gYGjT8ej30ixRB0Mq1aNzUE1bWNnCuWBmjx03CndAQvIj8unebotu0YR3atu8I7zbtYGtnh0lTfaGtrY39e/cIHS3X3Nwbol59N1hZWcPK2gaDhg6Hrq4ubt64IXS0PClWvDiMjU1ktz/PnoFlqdKoWq2G0NHyLD4+DhPGjcLkqTNgYGAgdJx8IdbttX7tGpiamcPXzx8VnCuipKUlatepi1KlSgsdLUdcP7bzHlnvr5p7tUbvfgNRo2adQk6W/6RSqdx78ePZoMpMrJ+vmzeuwa1BQ9St7w6LkiXRqElT1KztipDbt4SOliPZ+Z6iqakJI2MT2c1AwX5sG7knBEdCXuHhm3jcj4rDrCN3YWagDUdTfQCAnqYULZ1NseTMQ1x9EoPwl7GYdfQuKpY0hJN5EQBAES119K5rBb8jd3H8ThSexyTiwet4nH8QLeSqfUUM2+tLteu6o0adeihZygqWpa3xS78h0NHRRVhI5o8YKwLnwrvDT+jctSesy9ihlJUN3DyaQlPBfwD4FjG280T5iYVyBbZ48WLUrl0bvXv3RmRkJCIjI2FpaQlLS0vs2rULoaGhmDJlCiZMmICdO3dma5lbt26Fj48PtmzZgi5dunx33tGjRyMgIACXLl2CiYkJvLy8kJKSeWrYlStX0LFjR3Tu3Bm3bt3CtGnTMHnyZKxfvz5bOS5evAgAOHHiBCIjI7F3794s5xs/fjxmz56NyZMnIzQ0FFu3boWpqSkAIDAwEAcOHMDOnTsRHh6OLVu2wNra+puvOWfOHGzZsgXr1q3D+fPn8f79+x+Omf4tvr6+6NixI27evInmzZujS5cuiI7OPIj5mPXIkSMICwvD8uXLYWxsnKvXKSzp6enwnTQO/+vWA2VslbcHJZEyiI39AIlEAv0iylXgS0lORlhoCGrV/lQIUlNTQ61adXDzxjUBk+WftLQ0HD18CAkJ8aj42bBgyi4lJRmHDx1Aa++2SnU6/rf4z5yOevXc5d6LYiKm7XX2zCmUL18BY0YMhYdbHfh0aIO9u7N3zErCiIh4jCYN68GrWSNMHDsKkUr4o+73iOnzVbGSCy4F/4PHjx4CAO6G38GNa1dRp269HzxT+Vy9fAmeDeuio3dzzJnpi5h374SO9F16WlIAwPvEVACAo6k+NKRquPz4rWyeiOgEvHifCCeLzEJ5deuikEgkMNHXxOZfqmJv3xqY7lUWJYooXzFW2bbX59LS0nD6+BEkJiagfIVKeBv9BndCbqFoseIY1udndGzhjpEDfsHtG1eFjpprYm/nifJKObuNqghDQ0NoampCV1dXbtgSX19f2f9tbGxw4cIF7Ny5Ex07dvzu8pYuXYqJEyfi999/h5ub2w9ff+rUqWjcOLPnzIYNG2BpaYl9+/ahY8eOWLBgATw8PDB58mQAgIODA0JDQzFv3jx07979h8s2MTEBABgZGX1zSJYPHz5g8eLFCAoKQrdu3QAAtra2qFu3LgAgIiIC9vb2qFu3LiQSCaysrL77mkuWLMH48ePRpk0bAEBQUBAOHz78w6xZ6d69O3x8fAAAs2bNQmBgIC5evIhmzZohIiICLi4uqFatGgB8t3ivKDatWwOpVIqOPv8TOgqRqCUlJSFocQCaNGsBfX19oePkyNt3b5GWlvbVECtGRkZ4+PBfgVLlj3t3w9Gtiw+Sk5Ogo6uLgMVBsLW1EzpWvjl96iRiP3yAV+s2QkfJs6NHDuFOaCg2b1e+oYuyS0zb69nTJ9i9cxu6dO2OHr37IuT2LcybPRMaGhqiWD+xcXauBN8Z/rCytsHr16+wavlS9Oz2P+zadwB6esq1z/oWMX2+uvfsjbi4WLRv3QJqUinS09IwYPAweLbwEjpavqpdpy7cGzaCRUlLPHsageVLFmH4oL5YvWErpFKp0PG+IgEwpEEZ3Hwag4ev4wEARnqaSE5NR2xSmty80XEpMNLLLIRbGGpDTQL8XLMUFp9+gLikNPSua4WF7Z3RbcNVpKYrx3W8lG17ffTwwV0M7fMzkpOToaOji6n+i2BlY4uw25lnGG76dTn6DBoJW3tHHD/6O8YO6Y1Vm/eiZKnv1yAUjSq080R5xUK5Elq6dCnWrl2LiIgIJCQkIDk5We6CmFnZvXs3Xr16hfPnz6N69erZep3atWvL/l+8eHE4OjoiLCwMABAWFobWrVvLze/q6opFixYhLS0tX3aCYWFhSEpKgoeHR5aPd+/eHY0bN4ajoyOaNWuGli1bokmTJlnOGxMTg5cvX6JGjU+nWEqlUlStWhXp6ek5zlbxswvX6enpwcDAAK9evQIA9O/fH+3atcPVq1fRpEkTeHt7o06db/d6S0pKQlJSkvy0NHVoaWnlOFdu3AkNwY5tm7Bh6x6l71lDpMhSU1IwYcxwZGRkYOzEqULHoc9Y29hg+559iP3wASf+OIYpE8dhzfpNoimW/7ZvN+q41oNJCVOho+TJixeRmDd7FpavWlto+0ghiGV7AUB6egbKOzlh8NARAICy5crjwf172L1zuygKlWLj+tlFjB0cHeHsXAktmjbE8WNH4d22vYDJ8o+YPl/Hjx3B0UMH4Td7Hmxt7REeHoYFc/1hYlICLVt7Cx0v3zRu1lz2fzt7B9jZO6KdV1NcvXwR1WvW/s4zhTGikR3KGOthwLacDeEmkUigIVXDolMPcOnxOwDAtIPh+K1/TVQpbYiLj97lf9gCoGzb6yPL0jZYvmEX4mJj8efp45jnNwnzl65FekbmDxQtvNujaUtvAICdYzlcvxyMowf3o2f/oQKmzjlVaOeVAcsuio1DryiZ7du3Y9SoUejZsyf++OMPXL9+Hb/88guSk5O/+zwXFxeYmJhg7dq1yMhQjl+jdXR0vvt4lSpV8PDhQ8yYMQMJCQno2LEj2rfPW+Oupqb21d/n43Azn9PQ0JC7L5FIZAV3T09PPH78GMOHD8fz58/h4eGBUaNGffM1/f39YWhoKHdbOH92ntYjJ65fu4K30dHwbu4B12rOcK3mjBeRzxG4YC68m3977Dkiyr7UlBSMHzMckZHPsWTFr0rXmxwAihUtBqlUijdv3shNf/PmjcIPL/UjGhqaKF3aCuWdKmDI8JFwcCyLbZs3Ch0rX0Q+f4aL/1yAd7sOQkfJs7CQEERHv8FPndqiWmUnVKvshCuXL2Hblk2oVtkJaWlpP16IghPT9gIAYxMTlPniByebMrZ48SJSoESUE0UMDFDayhpPIh4LHSVfiO3zFbhgPrr17IWmni1g5+CAFl6t4fNzN6z7dZXQ0QpUSctSKFq0GJ4+iRA6yleGe9iiTpniGLLzJqJiP30/fxOXDE11NehryXcmK66ngTdxybJ5AODRm3jZ4+8SUhCTkALTIop1Qc+cUOTt9TkNDQ2UtCwNh7Ll0bP/UJSxc8C+nVtQ3CjzGLe0ta3c/KWty+DVS+Xfl4mtnSfKDyyUKzhNTU25L37nz59HnTp1MGDAALi4uMDOzg4PHjz44XJsbW1x+vRp/Pbbbxg8eHC2Xvuff/6R/f/t27e4e/cuypUrBwAoV64czp8/Lzf/+fPn4eDgkK3e5B8vfPG9L7X29vbQ0dHByZMnvzmPgYEBOnXqhNWrV2PHjh3Ys2ePbKzwzxkaGsLU1BSXLl2STUtLS8PVq/Jji5mYmCAy8tMO7/3793j48OEP1+dLJiYm6NatGzZv3oxFixZh1apvH7COHz8eMTExcrfho8bl+DVzy7NFK2zeuR8bt++V3UxMSqBL1x5YvGx1oeUgEquPRfInEY+xdMVaFC2qnBfM0dDURLnyTgj+54JsWnp6OoKDL6BiJRcBk+W/jPT0H/4ArSwO7N+LYsWNULfej4dcU3Q1atXCrr0HsH3XPtmtvFMFNG/hhe279in0Kd3ZJabtBQCVK7vg0SP546jHjx7B3NxCoESUE/HxcXj65AmM/xsyUdmJ7fOVmJgANYn813mpmhQZGTk/W1aZvHr5AjEx72BkrFjvy+EetqhvZ4ShO28iMkb+bOHwl7FISUtH1dJFZdNKFdOBmYE2Qp5/AADcevYeAFC6uK5sniLa6jDU0cCL94kFvwIFRFG314+kp6cjJSUZZuYlYWRcAk8jHsk9/jTiMUzNzIUJl4/E1s4T5QcOvaLgrK2tERwcjEePHkFfXx/29vbYuHEjjh07BhsbG2zatAmXLl2CjY3ND5fl4OCA06dPw93dHerq6li0aBEAYN++fRg/fjzu3LkjN//06dNhZGQEU1NTTJw4EcbGxvD29gYAjBw5EtWrV8eMGTPQqVMnXLhwAUFBQVi2bFm21qtEiRLQ0dHB0aNHYWlpCW1tbRgayl8NW1tbG2PHjsWYMWOgqakJV1dXREVFISQkBD179sSCBQtgbm4OFxcXqKmpYdeuXTAzM0PRokUBAF27dkXJkiXh7+8PABg8eDD8/f1hZ2eHsmXLYsmSJXj79q3ccCMNGzbE+vXr4eXlhaJFi2LKlCk5/uI9ZcoUVK1aFU5OTkhKSsLBgwdlPzBkRUtL66tTyNPi87dXXOYO8NOv+M+fPcPd8DAYGBjCzNwChv/9zT6SqqvDyNgYVtY/fl8pkvi4OEREfFrPZ0+f4k5YGAwNDWFuobxfyrleii0+Pg5PIz7/fD3F3TthMDA0hLGxCcaNHoY7YaFYELgcaelpeP06CkDmD3gaGsp1gaafu/2CyRPGwsmpAio4V8TmTRuQkJAA7zZthY6Wa4ELA+Barz7Mzc0RFxeHI4cO4vKli1i2co3Q0fIsPT0dB37bh5atvKGurvyHfHp6+rCzd5CbpqOjA8OiRb+arozEtr0AoEvX7vjlZx/8unoFGjf1RMitm9i7ZycmTZkudLQciY+Pw5Mv2vnwO5n7KzNzC8TEvMOLyEi8jsochu/jxRWNjI1hrETFoYXz56C+WwOYW1ggKuoVViwNgppUDc08WwodLc/E+Pmq59YAa1evhJm5OcrY2iP8Tii2bFqPVt7KtU/+3vcUA0ND/LpyGRp4NEFxY2M8exKBoMUBsCxVGrXq1BUwtbyRjWzRqGwJjN8fivjkNBTXzTz7ODY5Dcmp6YhLTsPBWy8xuEEZvE9MRXxyGoY1tMWtZ+8REplZKH/yNgHn7r3G0IZlMPePe4hLTkO/etaIiI7H1ScxQq6eHDFsry/9unwxqtdyRQkzcyTEx+HUH0dw89plzFq4AhKJBB26dMPGNctRxs4Btg5lcfzwATx5/BCTZwYIHT3HxNzOE+UXcRwliNioUaPQrVs3lC9fHgkJCbhz5w6uXbuGTp06QSKRwMfHBwMGDMCRI0eytTxHR0ecOnUK7u7ukEqlCAgIQExMDMLDw7+ad/bs2Rg6dCju3buHypUr4/fff5f1BK9SpQp27tyJKVOmYMaMGTA3N8f06dOzdSFPAFBXV0dgYCCmT5+OKVOmoF69ejhz5sxX802ePBnq6uqYMmUKnj9/DnNzc/Tr1w8AUKRIEcydOxf37t2DVCpF9erVcfjwYaipZfasiIiIkP0fAMaOHYsXL16ga9eukEql6NOnD5o2bSpXCB8/fjwePnyIli1bwtDQEDNmzMhxj3JNTU2MHz8ejx49go6ODurVq4ft27fnaBn5LSw0BAN7d5fdXxwwBwDQ3MsbU6bPEihV/gsJuY1ev3SV3Z8/N/NHklat22DGrMIbzia/cb0UW1hICPr37ia7v+i/z1cLL2/07jcI586cAgD8r5P8eLzLV29A1eo1oEyaeTbH2+hoLAsKxOvXUXAsWw7LVq6BkRIPvRIdHY3JE8bidVQU9IsUgb2DI5atXINadVyFjpZnwf/8jReRz9FayYomqkqM28upgjPmL1qCoEULsHrFMliUtMSoMePRvKVyXWwwLCQE/Xp9aucXzv+vnW/ljWkz/HHuzGlMnzJB9vjEsSMBAL37DUSf/oMKN2wevHz5EuPHjkTMu3coVqw4Klepig1bdqBY8eJCR8szMX6+Ro+fhBVBizF75nS8jY6GsUkJtG3fEb37DRA6Wo5873vKmAlTcP/eXRz+/Td8+PAexiYlULO2K/oMGCz7XqoI2lTO7OAR1Lmi3PSZR8JxJCTzB7Qlpx8gI6MMZrYqBw11NVx8+BYBJ+7Lze935C6GNCiDeW2dkJ4BXH8Sg5F7biNNgS7kKYbt9aV3b6Mxb8YkRL+Jgq6ePsrYOWDWwhWoWiNzTPW2nX5GclIyVgTOw4f3MbC1c8TsxSthYVlK4OQ5J+Z2XplwiHLFJslQlgGrqdCcOXMGDRo0wNu3b2W9s8UoPT0d5cqVQ8eOHTFjxgyh48h5m889yhWFjqbynxZPyi8pRZynJGtpiHM0tXSRHqbk4jrSSkFNpEf+ClSjyFdivZiUIhWV8pNUpB8wkTbzyIA4Vyw1TZzr5bXsb6EjFIjfB9QROkKBeJ+QKnSEAmFcRHF/UMgLPU1x7r9yK+x5nNARCkU5Cz2hI+QKe5STynj8+DH++OMPuLm5ISkpCUFBQXj48CF++uknoaMRERERERERERGRgMTZ/YwoC2pqali/fj2qV68OV1dX3Lp1CydOnPju+OFEREREREREREQkfuxRTl9xd3eHGEfkKVWqFM6fPy90DCIiIiIiIiIiIlIwLJQTERERERERERERFTQO2a7QOPQKEREREREREREREak0FsqJiIiIiIiIiIiISKWxUE5EREREREREREREKo1jlBMREREREREREREVMAkHKVdo7FFORERERERERERERCqNhXIiIiIiIiIiIiIiUmkslBMRERERERERERFRoZs2bRokEoncrWzZsrLHExMTMXDgQBgZGUFfXx/t2rXDy5cvCyQLC+VEREREREREREREJAgnJydERkbKbn/99ZfsseHDh+P333/Hrl27cPbsWTx//hxt27YtkBy8mCcRERERERERERFRAZPwWp5ZUldXh5mZ2VfTY2Ji8Ouvv2Lr1q1o2LAhAGDdunUoV64c/vnnH9SqVStfc7BHOREREREREREREREJ4t69e7CwsECZMmXQpUsXREREAACuXLmClJQUNGrUSDZv2bJlUbp0aVy4cCHfc7BHORERERERERERERHli6SkJCQlJclN09LSgpaW1lfz1qxZE+vXr4ejoyMiIyPh6+uLevXq4fbt23jx4gU0NTVRtGhRueeYmprixYsX+Z6bPcqJiIiIiIiIiIiIKF/4+/vD0NBQ7ubv75/lvJ6enujQoQMqVqyIpk2b4vDhw3j37h127txZyKlZKCciIiIiIiIiIiKifDJ+/HjExMTI3caPH5+t5xYtWhQODg64f/8+zMzMkJycjHfv3snN8/LlyyzHNM8rFsqJiIiIiIiIiIiICphERW5aWlowMDCQu2U17EpWYmNj8eDBA5ibm6Nq1arQ0NDAyZMnZY+Hh4cjIiICtWvXztbycoJjlBMRERERERERERFRoRs1ahS8vLxgZWWF58+fY+rUqZBKpfDx8YGhoSF69uyJESNGoHjx4jAwMMDgwYNRu3Zt1KpVK9+zsFBORERERERERERERIXu6dOn8PHxwZs3b2BiYoK6devin3/+gYmJCQBg4cKFUFNTQ7t27ZCUlISmTZti2bJlBZJFkpGRkVEgSyaiXHsbnyZ0hAKhoykVOgIRklLShY5QILQ0xDmaWrpID1PSxfk2hJpE6AQFI12cb0NIRLq90kS6waQi/YCJtJlHBsS5Yqlp4lwvr2V/Cx2hQPw+oI7QEQrE+4RUoSMUCOMimkJHKBB6muLcf+XW3RfxQkcoFA5mukJHyBX2KCciIiIiIiIiIiIqaPzdQKGJs/sZEREREREREREREVE2sVBORERERERERERERCqNQ68QKSCxjv0n1rGG1cQ6yKtIqfEnYqUi1s9XhkSc7aFYsd1QLhpScW4wsY55LVZqIj23PlWk78Pf+tcWOkKBKDd0n9ARCsTthd5CRyAikRLnUSQRERERERERERERUTaxRzkRERERERERERFRAZOI9IwjsWCPciIiIiIiIiIiIiJSaSyUExEREREREREREZFKY6GciIiIiIiIiIiIiFQaxygnIiIiIiIiIiIiKmASDlGu0NijnIiIiIiIiIiIiIhUGgvlRERERERERERERKTSWCgnIiIiIiIiIiIiIpXGQjkRERERERERERERqTRezJOIiIiIiIiIiIiogPFanoqNPcqJiIiIiIiIiIiISKWxUE5EREREREREREREKo2FciIiIiIiIiIiIiJSaRyjnIiIiIiIiIiIiKigcZByhcYe5URERERERERERESk0lgoJyIiIiIiIiIiIiKVxkI5EREREREREREREak0FsqJiIiIiIiIiIiISKXxYp5EREREREREREREBUzCq3kqNPYoJyIiIiIiIiIiIiKVxkK5gLp37w5vb2/ZfXd3dwwbNqzQc1hbW2PRokWy+xKJBPv37//uc77MLrRHjx5BIpHg+vXr35znzJkzkEgkePfuXaHlIiIiIiIiIiIiIsXHQnk+EarIXRAiIyPh6ekJ4NsF6MWLF2P9+vWFH+4bSpUqhcjISFSoUEHoKDLZKd4Xlk3rVqNX145oXL86Wjauh/EjByPi0UPZ4+9j3mHh3JnwadsCDV2roG0LDyyaNwuxsR8ETJ1zO7dvQ8c2rVC3ZlXUrVkVXbt0wl9/nhM6Vp5duXwJgwf0QyP3uqjk5IhTJ08IHSlfiHW90tLSsDxoMVo1awTX6pXRunkTrFm5DBkZGUJHyxfbt26BZ+OGqO7ijC6dO+DWzZtCR8oTsb4PVyxbgirOZeVubb08hY6Vr9auWQUX57KYN2eW0FHyTKz7L7Gu16+rV+KnTu1Qp4YLGtSvjWFDBuDRw3+FjpVnYt1eAPDq5UtMHDcaDerWRO1qldCxjRdCQ24JHSvfKHN7eO3KZYwcOgAtG7uhlkt5nD397f3wHL9pqOVSHtu3bCzEhLlz7cpljB46AK2auKNOFSecPX1S7vH4+DgEzPZD62YN4V67Cn5q54V9u3cIlDZrgz0dcXRiQ9xf0hq3A1pi3YDasDXVl5tn7yg3vFjdXu42538usseL6Wli69C6uD6vBR4va4Mrc5pjlk9l6Gsr1ijA169exphhA9CqqTtcqzrh3BfbK/rNa/hNnYBWTd3RsE5VjBjUB08iHguUNm/E3h4S5ZVitU6kEMzMzH44j6GhYSEkyT6pVJqt3Krq2tVLaNvBB2XLOyMtLRWrli7G8EG9sXnXAejo6OJ1VBReR73CwGGjYFPGFi8in2Oe/3S8jnoFv7mLhI6fbaZmphg8fCRKW1kBGRn4/bf9GD54ILbv3gtbO3uh4+VaQkI8HB0d4d22HUYMHSR0nHwj1vXasHYNdu/cDl8/f5SxtUdoyG1MnzIB+vpF0LnLz0LHy5OjRw5j/lx/TJrqC2fnStiyaQP69+2J3w4ehZGRkdDxckWs70MAsLWzx/LVa2X3pVLxHPaF3L6FPbt3wN7BUego+UKs+y+xrteVyxfRyacLnCo4Iy01DUsWL0D/Pj2x97dD0NHVFTperol1e72PicEvXX1QrXpNLFm+GsWKFUdExCMUMVCs7zO5peztYUJCPOwdHOHVui3GjRzyzfnOnDqB27duwMSkRCGmy73ExATYOTiiZeu2GD9q6FePBwbMxZVLwZjqNxvmFiURfOE8Amb7wdjEBPXcGgqQ+Gu1HUyw7vQDXH/0FlI1CSa0qYAdw+uh/pQ/EJ+cJptv07l/Mfe3ENn9hM8eS8/IwLHrzzFnfwjefEiCdQl9+P9UGXP1qmDAmouFuj7fk5CQub1atGqLCaPlt1dGRgbGjRwCdXV1zFmwBLp6+tixZQOG9u+JLbszv08rC7G3h0T5gT3K80H37t1x9uxZLF68GBKJBBKJBA8ePEDPnj1hY2MDHR0dODo6YvHixTla7qFDh2BoaIgtW7Zk+fjHoUQOHTqEihUrQltbG7Vq1cLt27fl5tuzZw+cnJygpaUFa2trBAQEfPd1Px96xcbGBgDg4uICiUQCd3d32Tp/PvRKeno65s6dCzs7O2hpaaF06dKYOXMmACA5ORmDBg2Cubk5tLW1YWVlBX9//2++/sdlz5o1C6ampihatCimT5+O1NRUjB49GsWLF4elpSXWrVsne05WvbcPHz4MBwcH6OjooEGDBnj06NFXr/XXX3+hXr160NHRQalSpTBkyBDExcXJHt+0aROqVauGIkWKwMzMDD/99BNevXole/zt27fo0qULTExMoKOjA3t7e1mub/3thLBgySo092qDMrZ2sHcoiwnTZuLli0iEh4UCAMrY2WPmvMWoW78BSlqWRtXqtdBnwFCc//MMUlNTBcudU27uDVGvvhusrKxhZW2DQUOHQ1dXFzdv3BA6Wp7UreeGQUOHw6NRY6Gj5CuxrtfNG9fg1qAh6tZ3h0XJkmjUpClq1nZFyG3l76mxacM6tG3fEd5t2sHWzg6TpvpCW1sb+/fuETparon1fQhk/ohsbGwiuxUrVkzoSPkiPj4OE8aNwuSpM2BgYCB0nHwh1v2XWNdr2cpf0dq7Lezs7OFYtiymz5yNyMjnCA0N+fGTFZhYt9f6tWtgamYOXz9/VHCuiJKWlqhdpy5KlSotdLQ8E0N7WKduffQbOBTuDRt9c55Xr14iYM5M+M6aC6m6cvzoW9u1HvoOHAq3b6zXrZvX0dyrNapUqwFzi5LwbtcRdvaOCFWg48WfFv+FHX8/Rvjz9wh9GoOh6y7B0kgPFa3kjycSktMQ9T5JdotN/PT9MSY+BRvO/osbj9/iaXQ8/rrzCuvP/Iua9saFvTrfVdu1HvoMyHp7PYl4jJBbNzBq/BSUc3KGlbUNRo2fgqSkJBw/eliAtLkn5vZQmUgkqnFTViyU54PFixejdu3a6N27NyIjIxEZGQlLS0tYWlpi165dCA0NxZQpUzBhwgTs3LkzW8vcunUrfHx8sGXLFnTp0uW7844ePRoBAQG4dOkSTExM4OXlhZSUFADAlStX0LFjR3Tu3Bm3bt3CtGnTMHny5GwPm3LxYuavvCdOnEBkZCT27t2b5Xzjx4/H7NmzMXnyZISGhmLr1q0wNTUFAAQGBuLAgQPYuXMnwsPDsWXLFlhbW3/3dU+dOoXnz5/j3LlzWLBgAaZOnYqWLVuiWLFiCA4ORr9+/dC3b188ffo0y+c/efIEbdu2hZeXF65fv45evXph3LhxcvM8ePAAzZo1Q7t27XDz5k3s2LEDf/31FwYN+tSjMCUlBTNmzMCNGzewf/9+PHr0CN27d5c9/nF9jxw5grCwMCxfvhzGxsY5+tsJIe6/IVUMvvPLcVzsB+jp6UNdSQ5Gv5SWloajhw8hISEeFStXFjoOqZCKlVxwKfgfPP5veKO74Xdw49pV1KlbT+BkeZOSnIyw0BDUql1HNk1NTQ21atXBzRvXBExG3xIR8RhNGtaDV7NGmDh2FCIjnwsdKV/4z5yOevXc5d6LYiLW/ZdY1wuAbKg6RTvjMi/EtL3OnjmF8uUrYMyIofBwqwOfDm2wd3f2vpMpOrG3h0BmhyzfSePwv249UMZWec9s+JJzxcr48+xpRL16iYyMDFy5FIwnEY9Qo5ar0NG+qYiOBgDgXVyy3PR2NUsjZIEXzkxrjAltKkBHU/rNZZgaaqNFlZK4cDeqQLPmp5TkzPXV1NSUTVNTU4OmpiZuXr8qVKxcEXN7SJRflLMCpmAMDQ2hqakJXV1dueE/fH19Zf+3sbHBhQsXsHPnTnTs2PG7y1u6dCkmTpyI33//HW5ubj98/alTp6Jx48yecBs2bIClpSX27duHjh07YsGCBfDw8MDkyZMBAA4ODggNDcW8efPkCr7fYmJiAgAwMjL65tAmHz58wOLFixEUFIRu3boBAGxtbVG3bl0AQEREBOzt7VG3bl1IJBJYWVn98HWLFy+OwMBAqKmpwdHREXPnzkV8fDwmTJgA4FNh/q+//kLnzp2/ev7y5ctha2sr6z3v6OiIW7duYc6cObJ5/P390aVLF9nY8vb29ggMDISbmxuWL18ObW1t9OjRQzZ/mTJlEBgYiOrVqyM2Nhb6+vqIiIiAi4sLqlWrBgByPwBk528nhPT0dAQGzIFzJReU+cZptO/evcX6NSvg1aZDIafLu3t3w9Gtiw+Sk5Ogo6uLgMVBsLW1EzoWqZDuPXsjLi4W7Vu3gJpUivS0NAwYPAyeLbyEjpYnb9+9RVpa2ldDrBgZGeGhCMbmFRtn50rwneEPK2sbvH79CquWL0XPbv/Drn0HoKen/+MFKKijRw7hTmgoNm/fLXSUfCfW/ZdY1+uj9PR0zJs9C5VdqsDO3kHoOHkmxu317OkT7N65DV26dkeP3n0RcvsW5s2eCQ0NDXi1biN0vFwTc3v4uU3r1kAqlaKjz/+EjpKvRoydiDl+U9G6WUNI1dWhJpFg3GRfuFStJnS0LEkkwIzOlRF87zXuPH8vm743OAJPo+Px4l0CylsaYlI7Z9iaFUHP5Rfknr+8dw00rWQBXS11HLv+HCM3XCnsVcg1K2sbmJqZY2XQIoyeOBU6OjrYsWUjXr18gTevlafgD4i3PSTKTyyUF6ClS5di7dq1iIiIQEJCApKTk1H5Bz0ydu/ejVevXuH8+fOoXr16tl6ndu3asv8XL14cjo6OCAsLAwCEhYWhdevWcvO7urpi0aJFSEtLg1T67V97syssLAxJSUnw8PDI8vHu3bujcePGcHRPzVdBAAEAAElEQVR0RLNmzdCyZUs0adLku8t0cnKCmtqnEx5MTU3lLtQplUphZGQkNwzKl5lq1qwpN+3zvxMA3LhxAzdv3pQb2iYjIwPp6el4+PAhypUrhytXrmDatGm4ceMG3r59i/T0dACZxf/y5cujf//+aNeuHa5evYomTZrA29sbderkrEdHUlISkpKS5KclS6GlpZWj5WTXgjl++PfBPSxbsynLx+NiYzF6aH9Yl7FFz74DCiRDQbK2scH2PfsQ++EDTvxxDFMmjsOa9ZuU/kseKY/jx47g6KGD8Js9D7a29ggPD8OCuf4wMSmBlq29hY5HKsK1Xn3Z/x0cHeHsXAktmjbE8WNH4d22vYDJcu/Fi0jMmz0Ly1etLbB9pJDEuv8S63p95O/ni/v372H9xq1CR8kXYtxe6ekZKO/khMFDRwAAypYrjwf372H3zu1KWxgSe3v40Z3QEOzYtgkbtu6BRJnP48/C7u1bEHLrJuYuDIKZuQWuX7383xjlJVC9Zu0fL6CQzf7JBWUtDNBq7hm56Zv/fCj7/51n7/EyJhF7RrrBykQPj6M+DWk6ZccNBPwehjKm+pjYtgJ8O1bCuK3KcUaiuoYGZs1fDP/pk+HZoA6kUimq1aiFWq71gIwMoePliBjbQ6L8xqFXCsj27dsxatQo9OzZE3/88QeuX7+OX375BcnJyd99nouLC0xMTLB27VpkKEmjq6Oj893Hq1SpgocPH2LGjBlISEhAx44d0b7997+ka2hoyN2XSCRZTvtYuM6N2NhY9O3bF9evX5fdbty4gXv37sHW1hZxcXFo2rQpDAwMsGXLFly6dAn79u0DANl29PT0xOPHjzF8+HA8f/4cHh4eGDVqVI5y+Pv7w9DQUO62OGDOj5+YCwvm+OHvv84icMU6lDD9upd7fFwcRg7pC109PcyaFwh1dY0slqLYNDQ0Ubq0Fco7VcCQ4SPh4FgW2zZvFDoWqZDABfPRrWcvNPVsATsHB7Twag2fn7th3a+rhI6WJ8WKFoNUKsWbN2/kpr9580Y25BQpriIGBihtZY0nEY+FjpJrYSEhiI5+g586tUW1yk6oVtkJVy5fwrYtm1CtshPS0tJ+vBAFJtb9l1jXC8gc9uLc2TNYs3YDTBXo7MG8EOP2MjYxQZkvCv02ZWzx4kWkQInyTuzt4UfXr13B2+hoeDf3gGs1Z7hWc8aLyOcIXDAX3s2/Paa5oktKTMSKoEUYPGIM6ro1gJ2DI9p37gKPJp7YunHdjxdQyGb5VEajiuZoF3AWkW8TvjvvtX+jAQA2JeTPXot6n4T7Lz7gjxuRGL3pKro3sEUJQ+0Cy5zfypZzwoZte3HszD/47dgZLAhahffv3sGipKXQ0XJEjO2hMpKoyE1ZsUd5PtHU1JQ7IDl//jzq1KmDAQM+9ch98ODBD5fzcbgQd3d3SKVSBAUF/fA5//zzD0qXzrz4wtu3b3H37l2UK1cOAFCuXDmcP39ebv7z58/DwcEhW73JP47D9b2DLXt7e+jo6ODkyZPo1atXlvMYGBigU6dO6NSpE9q3b49mzZohOjoaxYsX/2GG3ChXrhwOHDggN+2ff/6Ru1+lShWEhobCzi7rHjK3bt3CmzdvMHv2bJQqVQoAcPny5a/mMzExQbdu3dCtWzfUq1cPo0ePxvz587P1twMyh5EZMWKE3LT3yXnv6f+5jIwMLJw7E+fOnMSSleuz3KHHxcZixOA+0NDQxJwFQaLpnZKRnv7DH6iI8lNiYgLUJPK/Q0vVpMjIyP0Pe4pAQ1MT5co7IfifC2jokfnlND09HcHBF9BZZKdDi1F8fByePnmCFl6thI6SazVq1cKuvfL79qmTJ8DGpgy69+iVL2fJKRKx7r/EsF4ZGRmYPWsGTp08jjXrNqGkZSmhIxUYMWyvypVd8OjRQ7lpjx89grm5hUCJ8k5V2kPPFq2+6l09bEBvNGvRCi2VuPdramoqUlNT5c6gBjLHvU5XsM5ys3wqw9OlJNrOP4uI1/E/nN+pVFEAwMt3id+cR+2/swO01JWv36Z+kSIAMi/weScsBL36DxY4Uc6IsT0kym8slOcTa2trBAcH49GjR9DX14e9vT02btyIY8eOwcbGBps2bcKlS5dgY2Pzw2U5ODjg9OnTcHd3h7q6OhYtWgQA2LdvH8aPH487d+7IzT99+nQYGRnB1NQUEydOhLGxMby9vQEAI0eORPXq1TFjxgx06tQJFy5cQFBQEJYtW5at9SpRogR0dHRw9OhRWFpaQltb+6sLFWlra2Ps2LEYM2YMNDU14erqiqioKISEhKBnz55YsGABzM3N4eLiAjU1NezatQtmZmYoWrQoAKBr164oWbIk/P39s5UpO/r164eAgACMHj0avXr1wpUrV766gOnYsWNRq1YtDBo0CL169YKenh5CQ0Nx/PhxBAUFoXTp0tDU1MSSJUvQr18/3L59GzNmzJBbxpQpU1C1alU4OTkhKSkJBw8elP1IkZ2/HQBoaWl9VZRO+pD61Xx5ETBnBk4cPQz/gCXQ1dWVjaWmr18EWtraiIuNxfBBvZGUmIgpM2YjLjYWcbGxAICixYorzcF24MIAuNarD3Nzc8TFxeHIoYO4fOkilq1cI3S0PImPi0NERITs/rOnT3EnLAyGhoYwt1Degxqxrlc9twZYu3olzMzNUcbWHuF3QrFl03q08m4rdLQ8+7nbL5g8YSycnCqggnNFbN60AQkJCfBuo7zrJtb34cL5c1DfrQHMLSwQFfUKK5YGQU2qhmaeLYWOlmt6evpfjQGto6MDw6JFlX5saLHuv8S6XrP8fHHk8EEsClwGPT09vP7suEpbW3l6SH5JrNurS9fu+OVnH/y6egUaN/VEyK2b2LtnJyZNmS50tFwTU3uY+UPup/3w82fPcDc8DAYGhjAzt4Dhf98ZP5Kqq8PI2BhW1j/+Xi2kL9cr8tlTufVyqVodQYvmQ0tLC2bmFrh25RKOHDqAISPGCJha3uyfXNCmZil0X/o3YhNTYGKQ+Z31Q0IKElPSYWWih7Y1SuPkrUi8jUtGOUtDTO9YCRfCoxD2LAYA4FHBDCYG/2fvrsOqSN8+gN9HVERFxEJERSwsBAMLUUzEQNfudu1aFRO7u7DbtWtX1+4O7MZuFLGl4/v+wXvmd47gqmucOYfv57q8LpkT3A8z88zMPc/cj7lcfPBGQiKixTFLGhlav7Ccvh0sj199OfH+q8TbDp/pr68De3dLWmtrsclsK/fu3Jbpk8eJu0dFKVlavZOvJsQU+0OiH42J8h+kb9++0qpVKylQoICEhYXJzZs35cKFC9KoUSPRaDTSpEkT6dKli+zcufOrvs/R0VEOHDigjCyfMmWKvHv3TgICAuK9d/z48dKzZ0+5ffu2uLi4yLZt25TRzEWLFpX169fL0KFDZdSoUWJraysjR478qok8RUSSJk0qM2fOlJEjR8rQoUPF3d1dDh06FO99vr6+kjRpUhk6dKg8e/ZMbG1tpVOnTiIiYmlpKRMnTpTbt2+LmZmZuLq6yo4dO5Q76I8ePYp3N/17Zc+eXTZt2iS9e/eWWbNmSYkSJWTs2LF6k3MWLlxYDh8+LIMHDxZ3d3cBILly5ZJGjRqJSNxI8WXLlsmgQYNk5syZUrRoUZk8ebJ4e/9vNF7y5Mll4MCB8uDBA7GwsBB3d3dZu3btN/3tfoW/Nq4TEZHuHVvrLR80bLRUr/WbBNy8LtevXhYRkUZ1vPTes2HrHrHNYvdL4vxer1+/Ft9B/SX45UtJbWkpefI6ypz5i6RUGeM6gfnUtWtXpX2blsrPkyfG3VTyrv2bjBo73lBhfTdTbVe/gUNk3uwZMn7MSHnz+rVkyJhJ6tZvKB06GV/N/09V86oub16/ljmzZ0pw8EtxzJdf5sxfJOmNuPSKqW6HL168kIH9+8i7t2/F2jqduBQtJstXrRPrn/QkF30fUz1+mWq7NqxbIyIi7du00Fs+YvQ4qW3EN0VNdX0VLOQkk6fPktnTp8rCeXMki11W6eszUKrXNO5Jtk3FjevXpGuH1srP2hKU1WvVkaEjxxooqu938/o16fZ7G+XnmVMniohI9Vq1ZciIsTJy3CSZO2u6DB/cX96/fyeZbbNIx6495Lf6jQwVcjytK+QSEZEt/Tz0lvdc6i/rTjyUqOhYKZc/k3SonFtSmieVZ69DZfv5pzJt+w3lveFRMdLMPaeMaGQpyZOaybM3obLj/FOZtTN+XsOQbl6/Jt07/m99zfr/9eVVM259vQp+KbOmTZTXr4IlfYaMUq2Gt7Tp0MlQ4f5n7A+JvkwDYymETfEcOnRIKlSoIG/evFFGZ5NpePmDR5SrRaoUxjEy/VslMbHJhUxdVIxxl0D5nGRmxvf4amIWE2uap18m2xuabMNMk8ZEVxjENPsNU70aNc2tUCQi2jTPo9RW8uRHKdjrL0OH8FNcnVbH0CH8FBbJTfN6OVVyU+0R/5sHwZ8vTWRKcmQwzqfsOKKciIiIiIiIiIiI6GfjfQNV4/AzIiIiIiIiIiIiIkrUOKLciHl4eAgr5xARERERERERERF9H44oJyIiIiIiIiIiIqJEjSPKiYiIiIiIiIiIiH4yU5103FRwRDkRERERERERERERJWpMlBMRERERERERERFRosZEORERERERERERERElakyUExEREREREREREVGixsk8iYiIiIiIiIiIiH4yDefyVDWOKCciIiIiIiIiIiKiRI2JciIiIiIiIiIiIiJK1JgoJyIiIiIiIiIiIqJEjTXKiYiIiIiIiIiIiH4ylihXN44oJyIiIiIiIiIiIqJEjYlyIiIiIiIiIiIiIkrUmCgnIiIiIiIiIiIiokSNiXIiIiIiIiIiIiIiStQ4mScRERERERERERHRT6bhbJ6qxhHlRERERERERERERJSoMVFORERERERERERERIkaE+VERERERERERERElKgxUU5EREREREREREREiRon8yQiIiIiIiIiIiL66Tibp5oxUU6kRibabybh9M6kBjB0AESm2x/GwkR3MBNtFrdD42KWxDTXV0R0rKFD+CmSmOiz28nMTLNhp++/MnQIP8W16XUMHcJPsf1GoKFD+Cl+c7IzdAg/iWkev8g0meZRjoiIiIiIiIiIiIjoKzFRTkRERERERERERESJGkuvEBEREREREREREf1kJlr5zmRwRDkRERERERERERERJWpMlBMRERERERERERFRosZEORERERERERERERElakyUExEREREREREREVGixsk8iYiIiIiIiIiIiH4yzuWpbhxRTkRERERERERERESJGhPlRERERERERERERJSoMVFORERERERERERERIkaa5QTERERERERERER/WQaFilXNY4oJyIiIiIiIiIiIqJEjYlyIiIiIiIiIiIiIkrUmCgnIiIiIiIiIiIiokSNiXIiIiIiIiIiIiIiStQ4mScRERERERERERHRT6YRzuapZhxRTkRERERERERERESJGhPlRERERERERERERJSoMVFORERERERERERERIkaE+VERERERERERERElKhxMk8iIiIiIiIiIiKin41zeaoaR5SbsNatW0udOnWUnz08PKRXr16/PI4cOXLI9OnTlZ81Go389ddf//qZT2M3tAcPHohGo5GLFy8aOhQiIiIiIiIiIiL6wTii3Eh4eHiIi4uLXsLZWAUGBoq1tbWIxCWgHRwc5MKFC+Li4qK8Z8aMGQLAQBHGly1bNgkMDJQMGTIYOpRvtnLJQjl8cK88fHBfzM1TiFNhF+nc4w/JnsNBec/fm9fL3l075NbN6xIaEiI7D50US8s0Boz6+6xdvUqWL10swcEvJa9jPhkwyFecChc2dFjfje0yHiEhITLPb4YcPLBP3rx+LY758ksfn0FSsJCToUP7bqa4vkRMr12LF86X/fv2yIP798Q8RQpxdikivXr3lRwOOQ0d2neZN2eWLJjrp7csRw4H2bxtp4Ei+jFMtV2muh2KiAS9eCEzpk2WE8eOSHh4uGTLll2Gjx4rBQoabz9/7qy/LFuyWG5cvyovX76UaTP9pGKlyoYO65udP+cvfy5fIjdvXJPgly9l4tRZ4lExrh3RUVEy12+GnDh2RJ4+eSKpLVOLa8nS0q1HH8mYKZOBI/82MTExsmDubNn5zzZ59SpYMmTMJLVq15F2v3cWjcZ4hyvWrFZRAp89i7e8QaOmMmDwUANE9N+Eh4bIttUL5dKpI/Lh3RvJ6pBXGnToJTny5BcREQDyz+pFcnzvNgkL+SA58xWWJp37SqYs2Qwc+b+7cO6srF6xRAJuXJfg4JcybspMKV+hkvJ6aGiIzJ05TY4cOiDv3r2VLFnspEGT5vJb/UYGjFrfoxuX5eT29fL8/m35+PaV1O89QhyLuymv3/Q/Kuf3/SPPH9ySsI8fpN2YeZI5R+543/Pk9nU5tH6JPLt7UzSaJGJjn0uaDBgvyZKb/8rmfBNT7TeIfiSOKKdfLnPmzGJu/u8HDysrK0mbNu2vCegrmJmZSebMmSVpUuO7t3ThvL/UbdBE5i9bI9PmLJTo6Gjp3bWDhIWFKu+JCA+XkqXdpEWbDgaM9MfYtXOHTJ44Tjp26SprN2wRR8d80rljO3n16pWhQ/subJdxGT18iJw+eUJGjpkgazf+LSVLu0mXjm0l6MULQ4f2XUx1fZliu86dPSONmjSTFavXy7wFSyU6Klo6/95OwkJDv/xhlcuVO4/sOXhU+bd4xWpDh/RDmGK7THU7fP/unbRp2USSJk0qs+YulI1/bZfe/fqLZRorQ4f2XcLCQsXR0VEGDhlm6FC+S3hYmOTJ6yj9BvrGfy08XAJuXJe2HTrLyrWbZMKUmfLowQPp06uLASL9PsuXLJKN69eKz6AhsuGv7dK9Vx9ZsXSxrFv9p6FD+y4rV2+U3QeOKv/mLFgiIiKVq3oaOLJv8+fs8XLzor+06j1UBs9cKfmLlJCZQ3vK21cvRURk7+ZVcmj7RmnSuZ/0m7RQzFOkkFnD/5CoyAgDR/7vwsPDJHdeR+kzYEiCr8+cMlFOnTgmw0aPlzWbtknDpi1k6oQxcvTwgV8c6edFRoSLTfac4tm6e4KvR4WHSzbHQlKh8eevjZ/cvi5rJwyQnE7FpM3I2dJ2lJ8Ur1pb9clmU+03iH4kJsqNQOvWreXw4cMyY8YM0Wg0otFo5O7du9KuXTtxcHAQCwsLcXR0lBkzZnzT927fvl2srKxk1apVCb5+6NAh0Wg0sn37dilcuLCkSJFCSpUqJVevXtV736ZNm6RgwYJibm4uOXLkkClTpvzr79UtveLgEDequUiRIqLRaMTDw0Nps27pldjYWJk4caLkzp1bzM3NJXv27DJmzBgREYmMjJRu3bqJra2tpEiRQuzt7WXcuHGf/f3a7x47dqzY2NhI2rRpZeTIkRIdHS39+vWTdOnSSdasWWXp0qXKZz4tvfLmzRtp1qyZZMyYUSwsLCRPnjx673/y5Ik0adJE0qVLJ6lSpZLixYvL6dOn//Xv8rNMnb1Aqnv/Jjlz5ZY8efPJoBFj5MXzQAm4cV15T8OmLaVFmw5S0MnZIDH+SCuXL5W69RtKnd/qSa7cuWXIsBGSIkUK+WvzJkOH9l3YLuMRHh4uB/bvlR69+0rRYq6SLbu9dOzcTbJlyy4bN6wxdHjfxRTXl4hptmvO/MVSu05dyZ07jzjmyycjx4yXwMBncv36NUOH9t3MzMwkQ4aMyj/tU2rGzhTbZarb4bIli8Qms62MGD1OCjkVFrusWaV0mbKSLVt2Q4f2Xcq6l5duPXtLpcpVDB3KdylTtpx07tZLKlSM347UlpYye/4SqeLpJfY5HMSpsIv0GzBEbl6/Js8D449iVrPLly5I+QoVpWw5D8liZyeVq3pKydJucu3qFUOH9l2s06XT6wuPHj4kWbNll2LFSxg6tK8WGREhF08eljqtu0qegi6SyTar1GzSTjLaZpUjO7cIADmwbb1Ua9BKnEu6S9YcuaVVL1959zpYLp06aujw/1VpN3fp2LWnlK+Y8NMmVy5flOq1akvR4iXENoud1KnXUHLncZTrKtouc7uUEI+GbSWfa9kEX3dyryLudVuIQ6Gin/2OvSvnSHHP36SMdxPJmDWHpM+STQqU8pCkyZL/rLB/CFPtN4yNJpH8M1ZMlBuBGTNmSOnSpaVDhw4SGBgogYGBkjVrVsmaNats2LBBrl+/LkOHDpVBgwbJ+vXrv+o7V69eLU2aNJFVq1ZJs2bN/vW9/fr1kylTpoi/v79kzJhRatWqJVFRUSIicu7cOWnYsKE0btxYrly5IsOHDxdfX19ZtmzZV8Vx5swZERHZt2+fBAYGyubNmxN838CBA2X8+PHi6+sr169fl9WrV4uNjY2IiMycOVO2bt0q69evl4CAAFm1apXkyJHjX3/vgQMH5NmzZ3LkyBGZOnWqDBs2TGrWrCnW1tZy+vRp6dSpk3Ts2FGePHmS4Oe1cezcuVNu3Lghc+fOVcqyfPz4UcqXLy9Pnz6VrVu3yqVLl8THx0diY2O/6m/ys4V8/CAiImmMfNRTQqIiI+XG9WtSqnQZZVmSJEmkVKkycvnSBQNG9n3YLuMSExMjMTExkvyTJ2fMzVPIxQvnDRTV9zPV9WWq7frUx//v+62sjL/vf/TooVSt6C61qlWWwf37SqCRJbc+x1TbpctUtsPDhw5IgQKFxOePnlKpfBlp0uA32bzx687BSX0+fvwgGo1GUhtZ2cHCzkXE//QpefjgvoiI3Aq4KZcunJcyZd0NHNmPExUVKTu2b5XadeqqfqSurtiYaImNjZFknyRNkyc3l7s3LsurF8/k/ZtXks+5uPKaRarUkiNvAbkXcPXTrzMqToVd5Ojhg/Iy6IUAkHP+p+XxowdSopTblz9sJELevZFnd29KqjRpZdnwHjK9c31ZOeoPeRyg/mRzYug3iL6X8dWRSISsrKwkefLkkjJlSsmcObOyfMSIEcr/HRwc5OTJk7J+/Xpp2LDhv36fn5+fDB48WLZt2ybly5f/4u8fNmyYVKkSNyJj+fLlkjVrVtmyZYs0bNhQpk6dKpUqVRJf37hHG/PmzSvXr1+XSZMmSevWrb/43RkzZhQRkfTp0+u1TdeHDx9kxowZMnv2bGnVqpWIiOTKlUvKlo27A/zo0SPJkyePlC1bVjQajdjb23/x96ZLl05mzpwpSZIkEUdHR5k4caKEhobKoEGDROR/ifljx45J48aN433+0aNHUqRIESlePO7kRjcxv3r1ann58qX4+/tLunTpREQkd+74Nc0MITY2VmZOniBOzkUkZ+48hg7nh3vz9o3ExMRI+vTp9ZanT59e7t+/Z6Covh/bZVxSpUolhZ1dZNGCueLgkEvSpU8vu3dulyuXL0pWIx5taKrry1TbpSs2NlYmjR8rLkWKSu48eQ0dzndxcnKWEaPGiX0OBwkODpIFc/2kXavmsmHLVkmVKrWhw/vPTLVdukxpO3z65LFsXL9GmrVsLW07dJRrV6/IpPFjJFmyZFKr9m+GDo++QUREhMyeMUWqVqshqVMb177Wul0HCQn5KPVr15AkZmYSGxMjXbr3Eq8atQwd2g9z8MB++fjhg9HtVylSphIHx0Kyc/0yyZzVXtKkTSf+R/fJvYCrkjGznbx781pERNKkTaf3uTRp08n7N8Zb9k1E5I/+g2XC6GFSu1pFMUuaVJJoNDLAd4QUKVb8yx82Em+DAkVE5OjmFVKpaUexsc8lV47ulVVjfeT3CQslXeasBo7w8xJDv0H0vZgoN2J+fn6yZMkSefTokYSFhUlkZKTehJgJ2bhxowQFBcnx48fF1dX1q35P6dKllf+nS5dOHB0d5caNGyIicuPGDaldu7be+93c3GT69OkSExMjZmZm39aoBNy4cUMiIiKkUqVKCb7eunVrqVKlijg6Okq1atWkZs2aUrVq1X/9zoIFC0qSJP97oMLGxkYKFSqk/GxmZibp06eXoKCgBD/fuXNnqVevnpw/f16qVq0qderUkTJl4kYjXrx4UYoUKaIkyb8kIiJCIiL0a9FFRJl9sY77fzF1/Gi5d/e2zFm88od/NxH9z8gxE2TksMHiVaW8mJmZiWO+AuJZrYbcuGHc5QbIOI0bPULu3Lkty0yg5rWbeznl/3kdHcXJyVlqeFaUvbt3SZ269Q0Y2fcx1XbpMqXtMDYWUqBgQene8w8REcmXv4DcvXNbNq5fa3QJvcQsOipKBvn0FgDSf7Dx1WXfu3un7Nr+j4weP0ly5cojAQE3ZOrEcZIxYyapWbuOocP7If7eslHKuLlLxkw2hg7lm7Xu7SsrZ42TQW3rSJIkZpItV14p7l5ZHt0NMHRoP9XGtavk2pXLMnHabMlsm0Uunj8rU8aPlgwZM4lrydJf/gIjAEBERIpUrCnO5auJiEjmHHnkwbULcunQLqnQuL0hw/tXiaHfIPpeLL1ipNauXSt9+/aVdu3ayZ49e+TixYvSpk0biYyM/NfPFSlSRDJmzChLlixROni1s7Cw+NfXixYtKvfv35dRo0ZJWFiYNGzYUOrX//eLymTJkun9rNFoElz2uXIpXl5e8vDhQ+ndu7c8e/ZMKlWqJH379v2qeD81btw4sbKy0vs3Y8qEb/qOrzF1wmg5ceywzJy/VDLZJDx639hZp7UWMzOzeBPwvXr1SimNY4zYLuOTNVt2WbBkpRw9eU627z4gK1avl+joKLHLqt4RJl9iquvLVNulNW7MSDly+JAsWrJcbD7z5JYxs0yTRrLb55DHjx4aOpQfytTaZWrbYYaMGSVnLv2nBR1y5pLnzwMNFBF9q+ioKBno01sCA5/JrHmLjW40uYjIzKmTpVW79uLpVUNy580rNWrVliYtWsnSxQsMHdoPEfjsqZw5dVLq1Gtg6FD+k4y2WeWPsX4ybd0+GbN4s/SfvEhioqMlg00WsbKOG1D1/u1rvc+8f/ta0linT+jrjEJEeLjMmz1duv/hI2XLV5DceR2lfuNmUqmql6xesfTLX2AkUv//kwAZ7PSfZE+fJbu8e5XwQDu1MPV+g+hHYKLcSCRPnlxiYmKUn48fPy5lypSRLl26SJEiRSR37txy9+7dL35Prly55ODBg/L3339L9+4Jz/L8qVOnTin/f/Pmjdy6dUvy588vIiL58+eX48eP673/+PHjkjdv3q8aTZ48eVzdNt22fSpPnjxiYWEh+/fv/+x70qRJI40aNZKFCxfKunXrZNOmTfL69evPvv9HyJgxo7Rq1Ur+/PNPmT59uixYEHdwKVy4sFy8ePGrf//AgQPl3bt3ev969un/w+IEIFMnjJYjB/fLjHlLJIud8SbqviRZ8uSSv0BBOX3qpLIsNjZWTp8+KYWdixgwsu/Ddhkvi5QpJUPGTPL+/Ts5efK4lPdI+MkYY2Cq68tU2wVAxo0ZKQf275UFS5aLXdZshg7ppwgNDZEnjx9Lhv8v5WYqTKVdprodurgUkQf/X99V6+GDB2Jrm8VAEdG30CbJHz96KH7zlkjatMY5cW54eJgk0ehfzpslMRNAHfMifa+tf20W63Tppaz7l0uFqpl5CguxSpdBQj++lxsXz4hzSXdJb5NF0linl4DL55T3hYWGyINb1yWnY6F/+TZ1i46OlujoaL0nt0Xi5n6JNZJBel/DKmNmSW2dXl4FPtZb/vr5E7HKoO6nH0y93zAWGk3i+GesWHrFSOTIkUNOnz4tDx48kNSpU0uePHlkxYoVsnv3bnFwcJCVK1eKv7+/ODg4fPG78ubNKwcPHhQPDw9JmjSpTJ8+XUREtmzZIgMHDpSbN2/qvX/kyJGSPn16sbGxkcGDB0uGDBmkTp06IiLSp08fcXV1lVGjRkmjRo3k5MmTMnv2bJkzZ85XtStTpkxiYWEhu3btkqxZs0qKFCniTfCUIkUK6d+/v/j4+Ejy5MnFzc1NXr58KdeuXZN27drJ1KlTxdbWVooUKSJJkiSRDRs2SObMmSVt2rQiItKyZUuxs7OTcePGfVVMX2Po0KFSrFgxKViwoERERMg///yj3Dxo0qSJjB07VurUqSPjxo0TW1tbuXDhgmTJkkWvjI2Wubl5vDIrER+jf1isU8aPkn27dsi4qbMkZcqU8ir4pYiIpE5tKeYpUoiIyKvgl/L6VbA8ffxIRETu3bktKVOmFJvMtpLGKu0Pi+VXaNGqjfgO6i8FCxaSQk6F5c+VyyUsLEzq/FbX0KF9F7bLuJw8fkwgEHt7B3n8+KHMnDZZcuRwEG8jfyTfVNeXKbZr7OgRsnPHPzJ95hxJlSqVBOv0/Sn+v+83RtMmT5By5SuIbZYs8vJlkMzzmy1JzJJINa+ahg7tu5hqu0x1O2zWsrW0adFEFi+cJ1U8veTalcuyedN6GTJ0pKFD+y6hISHy6NEj5eenT57IzRs3xMrKSmyzGM9NgNDQEHmi045nT5/IrZs3JI2VlWTIkFEG9OslN29cl6kz50pMbIyyXVpZWcWbfFHN3MtXkCUL50tmW1vJmSuPBNy8LqtWLhPvOsZ77NKKjY2VrX9vkZredSRpUuNMWVw/f1ogEBu77PIy8IlsWeYnNnbZpXSlGqLRaKRirYayc/1yyWSbVdLbZJFtqxeKVboM4lxK3ZMqxt3I/d/+Ffj0idwKuCFp0lhJZtssUqSYq8yePlnMzc0ls20WuXDOX3Zu3yo9/vAxYNT6IsPD5PXzp8rPb18GyvMHd8QitaVYZbCRsI/v5V1wkHx8G/e04ev/T4inTptOUqdNJxqNRkrXaChHNi0Xm+y5xMY+l1w+ukdePXss9Xqqu4yTKfcbRD+KcR51EqG+fftKq1atpECBAhIWFiY3b96UCxcuSKNGjUSj0UiTJk2kS5cusnPnzq/6PkdHRzlw4IB4eHiImZmZTJkyRd69eycBAfFrpo0fP1569uwpt2/fFhcXF9m2bZsyErxo0aKyfv16GTp0qIwaNUpsbW1l5MiRXzWRp4hI0qRJZebMmTJy5EgZOnSouLu7y6FDh+K9z9fXV5ImTSpDhw6VZ8+eia2trXTq1ElERCwtLWXixIly+/ZtMTMzE1dXV9mxY4dyJ/vRo0fx7mp/r+TJk8vAgQPlwYMHYmFhIe7u7rJ27VrltT179kifPn2kevXqEh0dLQUKFBA/P78fGsPX+mvjOhER6f57a73lg4aNlurecUm7vzatl6UL/ndzo2v7lvHeYyyqeVWXN69fy5zZMyU4+KU45ssvc+YvkvRGXkKB7TIuHz9+kNkzp0nQi+eSxspKKlaqKl2795Kkn5R4Mjamur5MsV0b1q0REZH2bVroLR8xepzUNuKLoRcvXsjA/n3k3du3Ym2dTlyKFpPlq9aJ9VfOC6JWptouU90OCxZyksnTZ8ns6VNl4bw5ksUuq/T1GSjVaxr3ZGjXrl2V9m1aKj9Pnhg3yMS79m8yaux4Q4X1zW5cuyadO7RSfp7+/yUNa9SqIx06dZMjhw6IiEjzRvrnuHMXLpdiriV+XaDfqd/AITJv9gwZP2akvHn9WjJkzCR16zeUDp26GDq073b61Al5HvjMqPuJsNCP8vfKefI2+KWktEwjRUqXF+/mHcXs/xP/Veo2k4jwMFk9Z6KEhnyUXPkLS7dhUyRZ8h8/T9WPdPP6Nen2exvl55lTJ4qISPVatWXIiLEyctwkmTtrugwf3F/ev38nmW2zSMeuPeS3+o0MFXI8gfcC5M8xfZWf9/05T0RECrtXlVqdfOTWuZPyz4JJyutbZo8RERH3ui2kXL24vqWEVz2JjoqUvX/OlfCQD5Ipe05pOnCCWNuo+6aiKfcbRD+KBsZSqJp+uUOHDkmFChXkzZs3yuhs+jVe/sAR5WpimYL35sjwoqJN89HCZElZTc2YmOrZlyk9Wp0YJDHm52L/haluh2ZJTHN9RUSZ5nH5B4/TUQ2NmOZ2ePr+qy+/yQi5ZEtr6BB+iu03THNOiN+c7Awdwk9haW6iHeJ/FPQhytAh/BKZLI1zkBizVkREREREREREREQ/manecDQVvK1DRERERERERERERIkaR5TTZ3l4eAgr8xAREREREREREZGp44hyIiIiIiIiIiIiIkrUmCgnIiIiIiIiIiIiokSNpVeIiIiIiIiIiIiIfjbO5alqHFFORERERERERERERIkaE+VERERERERERERElKgxUU5EREREREREREREiRprlBMRERERERERERH9ZCxRrm4cUU5EREREREREREREiRoT5URERERERERERESUqDFRTkRERERERERERESJGhPlRERERERERERERJSocTJPIiIiIiIiIiIiop9Mw9k8VY0jyomIiIiIiIiIiIgoUWOinIiIiIiIiIiIiIgSNSbKiYiIiIiIiIiIiChRY6KciIiIiIiIiIiIiBI1TuZJRERERERERERE9JNphLN5qhlHlBMRERERERERERFRosZEORERERERERERERElakyUExEREREREREREVGixhrlRERERERERERERD+ZhiXKVU0DAIYOgoj03XoRaugQfgrbtCkMHcJPkcyMD+cYk+gY0zzsJTXjGZcxiY01ze1QY6Jn/ibaLJNlqvtXkiSmuSFGRccaOoSfwsxE19ftFx8NHcJPYWdtYegQfgpTvU4x1ePyo1emmQcoZJfa0CGoypvQGEOH8EtYpzQzdAj/iWn2mkREREREREREREREX4mJciIiIiIiIiIiIiJK1JgoJyIiIiIiIiIiIqJEjYlyIiIiIiIiIiIiIkrUmCgnIiIiIiIiIiIiokSNiXIiIiIiIiIiIiIiStSYKCciIiIiIiIiIiKiRC2poQMgIiIiIiIiIiIiMnUajaEjoH/DEeVERERERERERERElKgxUU5EREREREREREREiRoT5URERERERERERESUqDFRTkRERERERERERESJGifzJCIiIiIiIiIiIvrJNMLZPNWMI8qJiIiIiIiIiIiIKFFjopyIiIiIiIiIiIiIEjUmyomIiIiIiIiIiIgoUWONciIiIiIiIiIiIqKfTMMS5arGEeVERERERERERERElKgxUU5EREREREREREREiRoT5URERERERERERESUqDFRTkRERERERERERESJGhPlJqZ169ZSp04d5WcPDw/p1avXT/+9hw4dEo1GI2/fvhURkWXLlknatGm/6Ts+jV1N1BwbERERERERERGpnyaR/DNWTJSr2K9Kcv8MjRo1klu3bn3TZ2bMmCHLli37OQF9JzXH9q02/LlEapUrIgtnTlKWvXkVLFNGD5EWdSpL/aqlpWe7JnL80D4DRvnfxMTEyNzZM8S7WmVxc3WR2tWryqL5cwSAoUP7LufO+kv3Lp2kskdZcS7oKAf2G9+6+TdrV68SryoVxbWIkzRr3ECuXL5s6JC+S81qFaVY4Xzx/o0fM9LQof0Qpra+TH3/0lqyaIEUcconkyaMNXQo32XxwvnStFE9KVOiiFQoV1p69egiD+7fM3RYPwz3L+NjKvuWiGmvr5CQEJkycazUrFZR3Eq4SNuWTeTa1SuGDuuHMebt8HVwkMwc5yttf6skzaq7SZ/2jeRuwHUREYmOjpY/F86UPu0bSYuaZaVjo2oye/xQeR380sBRf9nF82fFp1cX8fb0ELdiBeXIwf16r79+FSyjhw0Sb08PqVimmPzR7Xd5/OihgaL9eufP+csfPTpL9SrlpIRLfjl04H/9RHRUlMyaPlma1PeWcqWKSvUq5WTYkP7yMijIgBF/nfPn/KV3987iVbmcuDrrt0tE5MC+PdKtYzupXK6UuDrnl4CbNwwU6ddbt2y+1KtYTO9f91Z1RUQk6PmzeK9p/504tNfAkRMZFhPl9K8ASHR09Dd/zsLCQjJlyvRNn7GysvrmUei/ippj+xa3blyTXVs3SY5cefSWTx3jK08fPRDfsdNl9rINUqZcRZk4vL/cvXXTQJH+N8uXLJKN69eKz6AhsuGv7dK9Vx9ZsXSxrFv9p6FD+y5hYaHi6OgoA4cMM3QoP9yunTtk8sRx0rFLV1m7YYs4OuaTzh3byatXrwwd2n+2cvVG2X3gqPJvzoIlIiJSuaqngSP7fqa4vkx5/9K6dvWKbNq4TvLkdTR0KN/t3Nkz0qhJM1mxer3MW7BUoqOipfPv7SQsNNTQoX037l/Gx5T2LRHTXl+jhw+R0ydPyMgxE2Ttxr+lZGk36dKxrQS9eGHo0L6bMW+HHz+8F9+e7SRp0qQyaNwMmbZ4vbTs1FtSWaYREZHI8HC5f/um1GveXibM/VP6DJskz548lIlD/zBw5F8WFhYmufM6Sp/+Q+K9BkAG9Okhz54+kQlTZ8nS1Rsls20W6dm5nYSFqft4Fh4WJnnyOkq/gb7xXwsPl4Ab16Vth86ycu0mmTBlpjx68ED69OpigEi/TVhYmOR1dBSfBNolEtdu5yJFpVuvPr84su+TLUcuWbRxt/JvzMzFIiKSPqON3vJFG3dLo9YdJYVFSilS0s3AURMZFhPlKtW6dWs5fPiwzJgxQzQajWg0Grl79660a9dOHBwcxMLCQhwdHWXGjBnf9L3bt28XKysrWbVqVYKva0uo7Ny5U4oVKybm5uZy7NgxiY2NlXHjxim/29nZWTZu3PjZ35NQ6ZXRo0dLpkyZxNLSUtq3by8DBgwQFxcXvTbrljeJiIiQHj16SKZMmSRFihRStmxZ8ff3jxfr/v37pXjx4pIyZUopU6aMBAQEfDauBw8eiEajkfXr14u7u7tYWFiIq6ur3Lp1S/z9/aV48eKSOnVq8fLykpcv/zdS4dPYNm7cKE5OTmJhYSHp06eXypUrS0hIiPL6kiVLpGDBgmJubi62trbSrVu3z8b0q4SFhsqUUYOku4+vpP7/k0+tm9cuSc16jSVvgUKSOUtWadSqg6RKbSl3bl03ULT/zeVLF6R8hYpStpyHZLGzk8pVPaVkaTejHzFU1r28dOvZWypVrmLoUH64lcuXSt36DaXOb/UkV+7cMmTYCEmRIoX8tXmToUP7z6zTpZMMGTIq/44ePiRZs2WXYsVLGDq072aK68uU9y8RkdDQEBk0oK/4DhsladKk+fIHVG7O/MVSu05dyZ07jzjmyycjx4yXwMBncv36NUOH9t24fxkXU9u3REx3fYWHh8uB/XulR+++UrSYq2TLbi8dO3eTbNmyy8YNawwd3ncx9u3w77XLJX1GG+nSb5jkzldIMtnaiXPxUpI5S1YREUmZOrX4TpwjZTyqSJZsOSRvASdp281H7t26IcEvnhs4+n9X2s1dfu/SU8pXrBzvtcePHsq1K5ek78Chkr+gk9jncJC+A4dKRESE7N21wwDRfr0yZctJ5269pELF+P1EaktLmT1/iVTx9BL7HA7iVNhF+g0YIjevX5Pngc8MEO3Xc9O2q1LC/V/1WrWlQ6euUqJkmV8c2fcxMzMT63QZlH9prKwTXG6dLoOcOXZIynhUEQuLlAaOmsiwmChXqRkzZkjp0qWlQ4cOEhgYKIGBgZI1a1bJmjWrbNiwQa5fvy5Dhw6VQYMGyfr167/qO1evXi1NmjSRVatWSbNmzf71vQMGDJDx48fLjRs3pHDhwjJu3DhZsWKFzJs3T65duya9e/eW5s2by+HDh7/qd69atUrGjBkjEyZMkHPnzkn27Nll7ty5//oZHx8f2bRpkyxfvlzOnz8vuXPnFk9PT3n9+rXe+wYPHixTpkyRs2fPStKkSaVt27ZfjGfYsGEyZMgQOX/+vCRNmlSaNm0qPj4+MmPGDDl69KjcuXNHhg4dmuBnAwMDpUmTJtK2bVu5ceOGHDp0SOrWrauU95g7d6507dpVfv/9d7ly5Yps3bpVcufO/VV/p59p3rRxUry0u7gULxXvtXwFneXogT3y4f07iY2NlSP7d0lkZIQ4uRQ3QKT/XWHnIuJ/+pQ8fHBfRERuBdyUSxfOS5my7gaOjBISFRkpN65fk1Kl/3fCmSRJEilVqoxcvnTBgJH9OFFRkbJj+1apXaeuaDTGXKktcawvUzRuzEhxd/fQW2+m5OPHDyIS9+SXMeP+ZXxMfd8yJTExMRITEyPJzc31lpubp5CLF84bKKofw9i3w7Mnj0jOvPll6sj+0r5+FfHp2FT2bd/yr58JDfkoGo1GUqZO/Yui/PGiIiNFRCR58uTKsiRJkkjy5Mnl8kXj3iY/9fHjB9FoNPEGatGvEfj0kbRv4Cmdm3nL9DGD5eWLwATfd/fWDbl/J0AqedX+xRESqU9SQwdACbOyspLkyZNLypQpJXPmzMryESNGKP93cHCQkydPyvr166Vhw4b/+n1+fn4yePBg2bZtm5QvX/6Lv3/kyJFSpUrc3dSIiAgZO3as7Nu3T0qXLi0iIjlz5pRjx47J/Pnzv+r7Zs2aJe3atZM2bdqIiMjQoUNlz5498vHjxwTfHxISInPnzpVly5aJl5eXiIgsXLhQ9u7dK4sXL5Z+/fop7x0zZowSw4ABA6RGjRoSHh4uKVKk+Gw8ffv2FU/PuDIIPXv2lCZNmsj+/fvFzS3uMaN27dp9tiZ5YGCgREdHS926dcXe3l5ERJycnJTXR48eLX369JGePXsqy1xdXf/17/OzHdm/S+7euilTFyRcgqT/iIkycXh/aVrTQ8zMkop5ihQyaPRUyZI1+y+O9Pu0btdBQkI+Sv3aNSSJmZnExsRIl+69xKtGLUOHRgl48/aNxMTESPr06fWWp0+fXu6bSM3hgwf2y8cPH6RW7d8MHcp3Swzry9Ts2rldbl6/Ln+u/fwTYMYsNjZWJo0fKy5FikruPHkNHc534f5lXEx93zI1qVKlksLOLrJowVxxcMgl6dKnl907t8uVyxclazbjOtfVZQrbYVDgU9m7bZPUqN9MfmvSRu4GXJelfpMlabJk4lG1Zrz3R0ZGyKpFs8StgqekTGW8iXL7HA5ik9lW5s+eLv0GDxMLCwtZt2qFBL14Lq+MoP7614qIiJDZM6ZI1Wo1JLUR39gwVnnyF5JuPsMlS7Yc8ub1S9mwfKEM6dlepi9ZLxYpU+m9d/+OvySrvYPkK+RsoGgTGeMeP2XymCg3Mn5+frJkyRJ59OiRhIWFSWRkpF75koRs3LhRgoKC5Pjx41+dsC1e/H8jie/cuSOhoaFK4lwrMjJSihQp8lXfFxAQIF266NcmK1GihBw4cCDB99+9e1eioqKUxLWISLJkyaREiRJy44b+xBmFCxdW/m9raysiIkFBQZI9++dPfHU/Y2NjIyL6yW4bGxsJ+sykI87OzlKpUiVxcnIST09PqVq1qtSvX1+sra0lKChInj17JpUqVfrs7/5URESERERE6C2LjIg/6uW/evniuSycOUlGTp372e9ctdhPQj5+kNHT5kkaq7Ry6ughmTjcR8bPWhKvnrma7d29U3Zt/0dGj58kuXLlkYCAGzJ14jjJmDGT1Kxdx9DhUSL095aNUsbNXTJmsjF0KJTIPH8eKJPGj5W5C5aI+Q86nqjNuNEj5M6d27JsxWpDh0KJSGLYt0zRyDETZOSwweJVpbyYmZmJY74C4lmthty4YZxlm0xlO4xFrOTKW0CatusqIiIOefLJowd3Ze+2TfES5dHR0TJt1AARQNr3HGCIcH+YpMmSydjJM2TcSF/xqlBGzMzMpHiJUlLKzV3k/59SNnbRUVEyyKe3AJD+g01v3gNjUFSn1niOXHkkb34n6dSkhhw/tFcqV6+jvBYRES5H9++SBi3aGyBKIvVhotyIrF27Vvr27StTpkyR0qVLi6WlpUyaNElOnz79r58rUqSInD9/XpYsWSLFixf/qsf/U6X63x1G7ajv7du3i52dnd771HBilixZMuX/2rbFxsZ+82c+Xfa57zAzM5O9e/fKiRMnZM+ePTJr1iwZPHiwnD59WjJkyPDN8Y8bN07vSQERkW59Bkn3foO/+bsScufWDXn75rX0at9UWRYbEyPXLp2Xf7ask3l/bpF/Nq+T2cs3ir1DLhERccjtKNcun5ftW9ZJ177xJ6BRq5lTJ0urdu3F06uGiIjkzptXAgOfydLFC5goVyHrtNZiZmYWb6K6V69e/ad9SW0Cnz2VM6dOyqRpswwdyg9h6uvL1Ny4dk1ev34lTRvVVZbFxMTI+XNnZd2aVXL63GUxMzMzYITfZ9yYkXLk8CFZsvxPsdF58s5Ycf8yHqa+b5mqrNmyy4IlKyUsNFRCQj5KhoyZZGC/3mKXNauhQ/tPTGU7tE6XQbLaO+gty5rdQU4f1R9MpU2SB794LkMnzTXq0eRa+fIXlOVrNsvHDx8kKjpKrK3TSYeWjSVfgYKGDu27RUdFyUCf3hIY+EzmLFjK0eQqkSq1pdhmtZfnTx/rLT95eL9ERoRL+QSe4iBKjJgoV7HkyZNLTEyM8vPx48elTJkyeiOz7969+8XvyZUrl0yZMkU8PDzEzMxMZs+e/U1xFChQQMzNzeXRo0dfVWYlIY6OjuLv7y8tW7ZUlulOzJlQzMmTJ5fjx48r5U2ioqLE399fevXq9Z9i+JE0Go24ubmJm5ubDB06VOzt7WXLli3yxx9/SI4cOWT//v1SoUKFr/qugQMHyh9/6M/c/uhtzGfe/e2ci5WQ2cs26C2bPn6YZM3uIPWbtpaI8HAREUnyyQ2UJEnMlLrrxiI8PEySaPSnXjBLYibAv984IcNIljy55C9QUE6fOikVK8VNdBQbGyunT5+Uxk2aGzi677f1r81inS69lHX/b/2m2pj6+jI1JUqVkg2bt+otG+Y7SBwcckrrtu2NIoGSEAAyfuwoObB/ryxaulLssmYzdEg/BPcv42Gq+1ZiYZEypVikTCnv37+TkyePS49efQ0d0n9iKtuhY0Fnefb4od6yZ08eSkYbW+VnbZL8+dNHMmzyfLG0SvuLo/y5UltaikjcBJ83b1yT9p27Gzii76NNkj9+9FDmLlwuadNaGzok+n9hYaHy4tkTsa5SXW/5gZ1/S/Ey5cWK64pIRJgoV7UcOXLI6dOn5cGDB5I6dWrJkyePrFixQnbv3i0ODg6ycuVK8ff3FwcHhy9+V968eeXgwYPi4eEhSZMmlenTp4uIyJYtW2TgwIFy8+bNz37W0tJS+vbtK71795bY2FgpW7asvHv3To4fPy5p0qSRVq1affH3d+/eXTp06CDFixeXMmXKyLp16+Ty5cuSM2fOBN+fKlUq6dy5s/Tr10/SpUsn2bNnl4kTJ0poaKi0a9fui79P68yZM9KyZUvZv39/vNHw/9Xp06dl//79UrVqVcmUKZOcPn1aXr58Kfnz5xcRkeHDh0unTp0kU6ZM4uXlJR8+fJDjx49L9+4Jn/SYm5vHG5mfPCz0h8QqIpIyZSqxz6k/mWiKFBaSJo2V2OfMLdHRUWJrl038Jo+Wtl3+EEsrKzl19KBcPHtKho6f8cPi+BXcy1eQJQvnS2ZbW8mZK48E3Lwuq1YuE+86db/8YRULDQmRR48eKT8/ffJEbt64IVZWVmKbJYsBI/t+LVq1Ed9B/aVgwUJSyKmw/LlyuYSFhUmd34x7ncXGxsrWv7dITe86kjSp6RxqTXF9mer+lSpV6nh1uy0sLMQqbVqjruc9dvQI2bnjH5k+c46kSpVKgv+/lmvq1Jb/OjeJMeD+ZRxMdd8SMc31pXXy+DGBQOztHeTx44cyc9pkyZHDQbyNdA4RU9kOa9RrKr4928rm1UukTPkqcufmNdm/Y4v83jvuydro6GiZOsJH7t8JkP6jp0lsbIy8fR0sIiKpLa0kqc4TwWoTGhoiTx7/b3969uyJ3Aq4IWnSWElm2yxyYO9uSWttLTaZbeXendsyffI4cfeoKCVLu/3LtxpeaGiIPNHpJ549fSK3bt6QNFZWkiFDRhnQr5fcvHFdps6cKzGxMcpx2srKSpIlS/65rzW40NAQefxJuwJuxvV/mW2zyLt3b+V5YKAEv4wrz/rwwX0REUmfIYNkyJDRIDF/yfK506R4mXKS0cZWXge/lHXL50uSJEmkbMVqynsCnz6W65fPy+BxMw0YaeKjYZFyVTOdq3cT1LdvX2nVqpUUKFBAwsLC5ObNm3LhwgVp1KiRaDQaadKkiXTp0kV27tz5Vd/n6OgoBw4cUEaWT5kyRd69eycBAQFf/OyoUaMkY8aMMm7cOLl3756kTZtWihYtKoMGDfqq392sWTO5d++e9O3bV8LDw6Vhw4bSunVrOXPmzGc/M378eImNjZUWLVrIhw8fpHjx4rJ7926xtv76O52hoaESEBAgUVFRX/2ZL0mTJo0cOXJEpk+fLu/fvxd7e3uZMmWKMuloq1atJDw8XKZNmyZ9+/aVDBkySP369X/Y7//RkiZNJsMnzpJl82fKqIE9JSwsVGztskmvQSOleGl3Q4f3TfoNHCLzZs+Q8WNGypvXryVDxkxSt35D6dCpy5c/rGLXrl2V9m3+9zTG5InjRETEu/ZvMmrseEOF9UNU86oub16/ljmzZ0pw8EtxzJdf5sxfJOmNvNTA6VMn5HngM6lt5DdpPmWK68uU9y9TtGHdGhERad+mhd7yEaPHGf3+xv2LDM2U19fHjx9k9sxpEvTiuaSxspKKlapK1+69VJ1oTQxy5ysofUdMltWLZsumlYskk20WadW5j7hXiruueh0cJGdPHhEREZ+OTfU+O2zyPCnoUjzed6rFzevXpHvHNsrPs6ZOFBERr5q1ZciIsfIq+KXMmjZRXr8KlvQZMkq1Gt7SpkMnQ4X71W5cuyadO/xvoNz0KRNERKRGrTrSoVM3OXIormxO80b6N6HmLlwuxVxL/LpAv9GNa9ekU/v/tWva5P9vl3cdGT5qnBw5dFBGDv1f7mNw/z4iItKhU1f5vXO3XxvsV3oVHCTTRg+SD+/fSRora8nv5CLjZi/TGzl+YOffkj5jJnEuXsqAkRKpiwbGVluBTEaVKlUkc+bMsnLlSkOHojq3Xvy4EeVqYpvWuEf7fU4ysyRffhOpRnSMaR72kppxZIIxiY01ze3wa+ZBMUYm2iyTZar7V5IkprkhRkWbZok8MxNdX7dffDR0CD+FnbWFoUP4KUz1OsVUj8uPXplmHqCQHevU6/oYYZrnKZ9KbW6cOypHlNMvERoaKvPmzRNPT08xMzOTNWvWyL59+2Tv3r2GDo2IiIiIiIiIiIgSOSbK6ZfQaDSyY8cOGTNmjISHh4ujo6Ns2rRJKleubOjQiIiIiIiIiIiIKJFjopx+CQsLC9m3b5+hwyAiIiIiIiIiIjIIUy0dZCpMs2AVEREREREREREREdFXYqKciIiIiIiIiIiIiBI1JsqJiIiIiIiIiIiIKFFjjXIiIiIiIiIiIiKin4wlytWNI8qJiIiIiIiIiIiIKFFjopyIiIiIiIiIiIiIEjUmyomIiIiIiIiIiIgoUWOinIiIiIiIiIiIiIgSNU7mSURERERERERERPSzcTZPVeOIciIiIiIiIiIiIiJK1JgoJyIiIiIiIiIiIqJEjYlyIiIiIiIiIiIiIkrUWKOciIiIiIiIiIiI6CfTsEi5qnFEORERERERERERERElakyUExEREREREREREVGixkQ5ERERERERERERESVqTJQTERERERERERERUaLGRDkRERERERERERHRT6bRJI5//4Wfn5/kyJFDUqRIISVLlpQzZ8782D/+V2CinIiIiIiIiIiIiIgMYt26dfLHH3/IsGHD5Pz58+Ls7Cyenp4SFBT0S+NgopyIiIiIiIiIiIiIDGLq1KnSoUMHadOmjRQoUEDmzZsnKVOmlCVLlvzSOJgoJyIiIiIiIiIiIqJfLjIyUs6dOyeVK1dWliVJkkQqV64sJ0+e/KWxJP2lv42IiIiIiIiIiIiITFZERIREREToLTM3Nxdzc/N47w0ODpaYmBixsbHRW25jYyM3b978qXHGAyJKtMLDwzFs2DCEh4cbOpQfiu0yLmyXcWG7jAvbZVzYLuPCdhkXtsu4sF3Ghe0yLqbaLlKXYcOGQUT0/g0bNizB9z59+hQighMnTugt79evH0qUKPELov0fDQD82tQ8EanF+/fvxcrKSt69eydp0qQxdDg/DNtlXNgu48J2GRe2y7iwXcaF7TIubJdxYbuMC9tlXEy1XaQu3zKiPDIyUlKmTCkbN26UOnXqKMtbtWolb9++lb///vtnh6tgjXIiIiIiIiIiIiIi+iHMzc0lTZo0ev8SSpKLiCRPnlyKFSsm+/fvV5bFxsbK/v37pXTp0r8qZBFhjXIiIiIiIiIiIiIiMpA//vhDWrVqJcWLF5cSJUrI9OnTJSQkRNq0afNL42CinIiIiIiIiIiIiIgMolGjRvLy5UsZOnSoPH/+XFxcXGTXrl3xJvj82ZgoJ0rEzM3NZdiwYZ99/MVYsV3Ghe0yLmyXcWG7jAvbZVzYLuPCdhkXtsu4sF3GxVTbRcavW7du0q1bN4PGwMk8iYiIiIiIiIiIiChR42SeRERERERERERERJSoMVFORERERERERERERIkaE+VERERERERERERElKgxUU5ERERERERGKSIiwtAhEBERkYlgopyIiIiI6Cd5/fq1oUOgbxQbG2voEOgrLV26VEaMGCFv3741dChEJufTvtBU+kYAhg6BiFSMiXKiRMBUTgZMpR26TOWE81MJtcsU1p8ptCEhprodknExxf2ra9euUqpUKXn27JmhQ/kptH2Hqa27JEniLpFu3rxp4EjoS06ePCk7duyQOXPmmFSy3NT2KVOmew715s0bA0byYwUHByt94ZIlSyQwMFD52ZjFxsaKRqMRkbg2RkdHGziiH0N3O9S2if0I0X9j/D0dEenRHhCfPXsmr169ktDQUNFoNEafCNM9qXn8+LGEh4cbOKLvFxsbq5xw/vPPP3L58mUDR/Rj6Lbr5s2bcuvWLXn8+LGy/oyV7jYYEhIi0dHREhUVJSIiMTExhgztu2nX159//im3bt0ycDQ/l7H3hZ8ylYsg3f3r7t278uHDBwNH9GP88ccfotFopFGjRiaZLNf2Hffu3TNwJD/G+vXrxc/PT0Ti1l3fvn3l48ePBo7qx9D2FU+ePDGpZN6CBQukSpUqsnXrVpk1a5a8e/fO0CF9N93+8Pnz5/L27VtlnRnzMcyYY/8c3XPeqVOnysSJE+XatWsGjur7HTlyRBwdHeXBgwfSu3dvGTRokERGRho6rO+mu75Gjx4tffv2lbNnzxr9ebxuu+bMmSMjR45UcgBE9O2YKCcyMRqNRrZs2SKlS5eWChUqSNWqVeXx48eSJEkSoz1B1T34Dx8+XDp37iwXL1406hEAAJQ29e/fX/r27Stbt241+uSQbruGDh0q9evXl9q1a0vRokVl+vTp8urVKwNH+N/oboOTJ0+WFi1aSNmyZaVPnz5y8+ZNMTMzM3CE3weABAYGSsuWLeXRo0eGDueH0CaFLl68KGvXrpVly5bJw4cPTWI0lLZt/v7+snfvXqPvN3T3r6FDh0qPHj3kzJkzyo0oY7R792758OGD5MqVS/bs2SPPnz+XBg0amGSyfNu2bdKgQQN5/vy5oUP5LtHR0XL79m3p3r27VKtWTRYuXChjxoyR1KlTGzq07wZANBqNbN26VWrWrCl79+6V9+/fGzqs76btI/744w9xcHCQjRs3ypw5c4y6T9Q9jxo9erQ0atRI3NzcpF69erJ3716jPYbptmvnzp2ycOFCuXLlioSFhRk4su+jbZOPj4+MGzdOnJ2dJW3atHrvMcYb2qVKlZLSpUuLq6urLF68WPbt2yf29vZG2RZd2vU1cOBAmTVrllStWlUcHByM/jxedzscM2aMZMiQQV68eGHgqIiMGIjIpNy+fRvZs2fH9OnTMXfuXFStWhXp06fHlStXAAAxMTEGjvC/69+/PzJnzox169bhxYsXhg7nh5g8eTLSp0+P06dPIyQkxNDh/DBjx45FxowZceDAAURGRqJly5ZIlSoVrl27ZujQvsuAAQOQIUMGLFmyBPPmzUPhwoWRP39+vH//3tChfbNP+4KwsDAUKlQImzZtMlBEP97GjRuRNWtWlCxZEhUqVEDSpEmxdetWQ4f1XWJjYwEAmzZtQrp06TBu3Djcu3fPwFH9GAMGDECmTJmwefNmBAcHGzqc/2z16tXQaDSYO3cuPnz4AAB48OABcufOjTJlyuDp06cGjvDH+uuvv2BjY4NLly4BMO7zDAAoWrQoNBoNBg8eDMD426P1999/I1WqVJg0aRIePHgQ73Vt32Js1qxZg/Lly8PT0xOZM2eGtbU1Ro8ejbdv3xo6tO8yZMgQpE+fHn/99ReOHDmC8uXLI0WKFHj27JmhQ/suPj4+sLKyQs6cOZE6dWoMGzYM9+/fN3RY32XVqlXImjWr0gcCQGhoKG7duqX8bCz7l26cvr6+0Gg0sLGxwY0bNwwY1Y918uRJODg44PDhw4YO5YfatGkTbG1tcfz4cUOHQmT0mCgnMgG6JzUPHz7EwIEDlZ+fPHkCb29vo0+WHz58GFmzZsWJEycAAJGRkXj27BkOHz6M27dvGzi6/+bjx4+oXbs2pk6dCuB/68UY1492G4yNjUVYWBhq1KiBZcuWAQA2b94Ma2trzJkzBwAQHR2t9xljcfXqVTg7O+Po0aMAgO3bt8PS0hILFiwAoP83MCZPnjxR/v/bb7+ha9euys/Guq4A4OzZs0ifPr2yfm7dugWNRoORI0caOLLvt2/fPlhaWmLhwoUICwtTlhvz+jp69Cjs7e1x6tQpAHE3bh4+fIgdO3bg5s2bAIyrXUOGDEGyZMkwZ84ck0qW6x6fdNeHt7c3KleujMjISEOE9cNERUWha9eu6NKlCzQaDWbPnq28ZozHZq2goCAULVoU48aNAwBERETg/fv32Lp1K06fPm3g6P67ixcvIm3atFiyZAlevHiB6OhotGnTBoULF8aYMWOM8iY2ADx//hzu7u7YvXs3AGDbtm1ImzZtvPMoY6DbT5w8eRLly5fH8ePHERUVhcmTJ8PR0RF9+/Y16hu+U6ZMQcWKFQHEnWtMmzYNefPmRa5cudCzZ0/DBvcNdPu4iIgIvHz5EhcvXoS3tzeyZMmCs2fPAoh/LDamYzMA7Nq1C7ly5cLz58/jnbtHRUXpnVcZk9GjR6NatWp6yz5dN8Z8HCP6lYzz2S0iUuD/H6fdu3ev9O/fX3r06CGXL1+WkJAQERGxs7OTOXPmiJubm1SpUkUuXbpkFI9t4pNH+yIiIiRjxoySPXt2OXfunPj6+oq7u7s0a9ZMOnToYBT1vT9tU5IkSeTmzZtKPU3tekmSJImEh4fL/fv3f3mM/4VuLc2nT59KihQp5Ny5c1K4cGE5cuSItGzZUsaOHSudO3eW8PBwGTJkiNy+fVv1dfM+LVUUFRUlr169kjJlysjff/8tjRo1kokTJ0qHDh0kNDRUVqxYIe/evVN9u3RNmTJFypUrJ8WKFZP69etLYGCgvH79Wm7cuCGhoaHKo6hqb9OZM2eU/2v3s4cPH0qFChWkQ4cOcv/+falYsaJ06tRJfH19RUSUSd8+3S+NwebNm6V27drSvn17iY2NlbNnz0qvXr1k4MCBcv78edWvr4QkSZJErK2txcLCQi5evChDhgyRihUrSrdu3aROnTpy8eJFo2iXts7pqFGjxMfHR7p37y4rV66Ujx8/ir29vezbt0+CgoKMtgyL9jgVHR2ttz5atWolHz9+VGrzGkupt0/jTJo0qcyePVv8/Pxk5MiR0r17d5kzZ46I/K/t586d++Vx/ghJkiSRPHnyyNOnT2Xs2LHi7e0tjRs3lq5du8qiRYsMHd5/8uTJE7G0tJTKlStLpkyZxMzMTBYvXiwuLi4yadIkmTNnjlHWY//w4YNcvXpVChUqJDt37pQmTZrIuHHjpHPnzhIWFibTp0+Xx48fGzrMr6LtJxYuXChLliyR3LlzS5kyZSRp0qTSp08f6dy5s2zdulXmzp1rFOe9CZ0zpEiRQoKCgqRJkyZSp04dOXPmjDRp0kR69eolq1evlqtXrxog0m/zaYnB/v37S1BQkDg7O8vq1avF2dlZvL299Y7FY8aMkRcvXqj62JzQsSgkJEQePnwo4eHhotFoJCYmRmnDkSNH5Ny5c6o/N0yoXWFhYfL27VsJDQ1Vlmk0GomOjpbNmzfLx48fjSIHQKQG3FOIjJxGo5E9e/ZIrVq15PTp0/L06VM5dOiQHD9+XHmPnZ2dzJ07V/Llyyd169ZV/WQsn07qFh4eLjly5JDr169L8+bNpUKFChIcHCyjRo2SJUuWyIMHD1RfG1W3TdqJwWJiYsTe3l5u374tHz580Dspu3XrlowYMUIePnxokHi/FnRqTvr4+Ej79u1FRMTb21v69u0r1apVk5kzZ0qnTp1EJC45eeLECTl69KjBYv5a2naNHTtW1qxZIxqNRvLnzy9+fn7SsmVLmTx5stKuK1euyJ49e4ziIk9X2bJlZcmSJVKzZk3Jnj27vHv3TtauXSudOnUSBwcHqVChgjRs2FD27t1r6FA/68yZM1KqVCmZPHmyiIjeTZunT5/KnTt3xMPDQ6pXry6zZ88WkbjJcwcNGiQfP35U9QXep3T7iDdv3siOHTukc+fO4uvrKwcOHJDLly9Lt27d5PXr1waM8ssSusBLnTq1vHv3Trp16yZly5aV9+/fy+jRo2XVqlWSJEkSo9m3zMzMlPaNHj1aBgwYkGCy/OXLl9K4cWOjSXbpWrRokdjZ2Ymfn59cuXJFREQ8PT3l48eP8ZLKaqZ7/Jo/f774+PhIt27d5NSpU/Lx40cZMmSIjBo1Snr06CHTpk2Tly9fSp06dWTatGkGjvzLtH3FgwcP5MWLF5IxY0ZJkSKF+Pr6SoECBeTKlStSv359uXTpklhYWMjdu3cNHPG30bbPzMxMNBqNMjgkIiJCNBqN+Pn5SfLkyWXevHmyaNEiVd+40Y1Ne36YLVs28fDwkClTpkijRo1kypQpyvnGgwcP5OjRo3Lz5k2DxPtfXb58WRYtWiQXLlyQoKAgZXnPnj2la9eusn37dhk/frwEBgYaMMp/p3su//LlS6UGdMuWLaVp06YSHR0tf/zxh4wePVqGDx8urq6u4uDgIJaWloYM+6vonstPmDBBSpUqJVZWViIikipVKtmyZYsULlxYqlSpIrNnz5aKFSvK2rVrJUOGDIYM+1/pJv+3bt0q+/btExGR8uXLS+nSpaVnz57y+PFjZVBIeHi4jBkzRg4dOqTqc0Pddp08eVLpD/PlyydXrlyR/fv36/UroaGhsnjxYvn7778NEi+RUTLEMHYi+nGCg4Ph4+OD+fPnAwBevXqFJk2aIF26dDh48KDee589e4bHjx8bIMqvp/tImK+vLypUqIDt27cDAM6dO4eJEydi69atePfuHQAgPDwcRYsWxd9//22QeL+GbpvGjBmDRo0aKY/d79ixA0mSJMHgwYOVuutv3rxBzZo1UaNGDVU/Iqf7ON+xY8dQpkwZnDx5EgCwdOlS5M6dG15eXggPDwcAvH37Fl5eXihfvryqHxvW/ZuvXr0aadKkweXLlxETEwMPDw9oNBqMGTNGeU9oaCi8vLxQu3ZtVa+vTyX0qOw///yD9OnT49ChQ1iyZAnGjRuHpk2bqnp9hYWFYfLkyUiePDmmTJmiLPf390f58uVhbW2N1q1bA/jfuu3duzcaNGig9CNqltB62rZtG4oUKYL06dOjadOmSv+3ePFilCtXTtWPDevuI6dPn8b27dtx+fJlAEBAQADmz5+P7du34+PHjwDi+vgiRYqovnb+v+37AwcOhJmZWbwyLJaWlujYseOvCvE/0300PTY2Fvfv30eXLl1QoUIFZMiQAQMHDsTly5exb98+FClSBGfOnDFwxF+mu18NHDgQlpaWaNCgAfLkyYN8+fKhT58+ePXqFYC4sgoajQYFChRAwYIFVV9eRtu2LVu2IH/+/Jg7d67Shy9YsAArV65ESEiIss02bNgQPj4+ep9Vo4RiCw0NRa5cuVCrVi295ffv30eNGjXQqVOnBOuxq4VuvzFp0iT4+vri+vXrAICuXbtCo9Gge/fuyns+fPiA6tWro2rVqqo+3/jcdjRy5EhkypQJ48ePR1BQkN5rY8aMQePGjVW9DWoNHjwYxYoVQ+bMmTFkyBClHr5u+bMPHz6gVq1aql9XutasWROv1vrHjx+VbRIAmjZtilKlSqFmzZpKX6jG9uluRz4+PsiRIweWLl2Kly9fAgAWLVqEcuXKoUyZMti6dStWrFgBT09PODs7IyoqylBhf5Hu33rIkCHImTMn1q5dqyxr3rw5rKyssGzZMpw/fx7Xrl2Dp6cnXF1dVX0uT6Q2TJQTGanY2FhcunQJqVOnRr58+bBx40bltaioKDRu3BjW1tZGO1GJr68vMmXKhL///ltv4k7tiU94eDhev36NatWqoWTJkqo8+H96st+vXz9kyZIF8+bN05u4aNWqVTA3N4ebmxtKlSqFUqVKwcnJSdUnoLrWrl2Lpk2bokWLFnrLfX194eLigvz586NmzZooUaIEXFxclHapcZ3p+uuvvzBjxgy9GrXv37+Hk5MTChcujNGjR2Pq1KmoWLGiXvJE7esrIbGxsYiJicHVq1eRK1euBG+oqXl9hYeHY+rUqdBoNEqyPCoqCh07doSNjQ1mzpyJ9+/f4/HjxxgwYADSp0+Pq1evGjjqL9P2ISdPnsS8efMwePBgJan8+vVrZXJc7fv69euHihUrqrYur26fOGDAAOTMmRP58+dHvnz5UKdOHaVtQNw6DQoKgpeXF0qUKKHq7U93n9+5cydWrVqFzZs3603QrE2W607wGRgYqOp2Afpte/funZI8BuLqXq9atQqlS5dGsWLF4OjoiKxZs2LJkiXxPqtWT58+haenp3KTFwBGjBgBNzc3DBs2DBEREQCAS5cuYevWrcr6UnMiBYjbDlOmTImZM2d+doDE+/fvMXDgQKRLl06ZB0CttH3H4cOHMWjQIHTs2BGLFi0CEDcfhY2NDWrWrAl/f38EBARgyJAh8PT0NIqboUBcIi9TpkxYvHix3vwFtWvXRvbs2dG0aVP06NED5cqVU/35oW5MHz580OszgLjjlL29PSZPnqwkLbXUOteLbpsWLFgAOzs7zJs3D2PGjIGFhQVatWqFgIAAAHE3bxYuXAhPT0+9c141rqtPzZw5E+XLlwcQd+N6ypQpyJ07NxwcHNCuXTvlfbq1vdXeF44fPx42NjY4duxYvHVw8OBB/Pbbb7C0tESxYsVQp04dVV+j6MY/ePBgZMqUCQcOHEBgYKDe+3r06IHs2bMjderUcHZ2hpubm6rbRaRGTJQTGbk2bdooI1w/ndStefPm0Gg0OHbsmAEj/LJPT1xu376NAgUKxBslrj0pi46OxqhRo1CqVCmULFlSlQf/T0fKbN26Fba2tnoj7T58+IC7d+8CAK5du4apU6eid+/emDlzpnLiqfYT0NjYWDRv3hxp0qSBs7NzvHWwZ88eDBs2DH369IGfn5/RtCsoKAgWFhbQaDQYMGAAgP9tf2/evEHTpk3h5uaGSpUqoXPnzqpu17dcnEVHR8Pe3h4rV65UlqntgvVzwsLClGT5xIkTAcRNRtWwYUMULlwYKVOmROnSpZE7d26cP3/ewNF+vQ0bNsDS0hJubm7InTs3rK2tMWTIEL1RkmfPnoWPjw/SpEmjNxJMTXS3o9mzZyNz5sw4cuQIAKBPnz6wtLTEvn37AMRthyNHjoSHhwdKlSqlyj5e69Pkf+bMmVGyZElYWFigWbNmesffQYMGwdzcHJMmTUJoaKiyXI3tAvTbNnbsWJQrVw45c+ZE9erVcejQIeVpocDAQJw8eRINGjSAtbU17O3tjWKy0unTpyNnzpwoWbKk3v4UHR2Nvn37Il++fAnedFLb+tI994uNjUV4eDhq166N3r17671PN+7NmzejYsWKyJkzp9H0h5s2bYK1tTUaNmyIPn36QKPRoFOnTnjz5g0uXLiAfPnyIVu2bLCzs4Otra0y8aDa7dixA1mzZtU7P9Q9lxg/fjyaNm2KBg0aYOjQoUZzvjFmzBhUqVIFmTJlwqBBg5SJ0IG4ZHmOHDkwZcoUPH/+XO871HzOcerUKYwcORLr169Xlh04cADp0qVDq1atcPv2bURGRmLs2LHo3bu3qteV7t9Zu97mz5+PQoUKoX79+nB0dETTpk0xatQozJ8/HxkyZMC5c+c++x1q0L9/f70++927d6hQoQJmzpwJIO5Jrl27dqF58+bo06ePEv+DBw/w/v171Sb/V6xYoffz3bt34ezsjB07dgCIGzhx/fp1jB8/XllHAQEBOHLkCE6dOqWsX7W1i0jNmCgnMiLaA/ilS5dw6NAhZXn79u2RMmVKbNiwQblwBeIOiO3atVP1SCFvb2+cOnVKb9mlS5dgY2OjPOqneyIWGRmJ0NBQXLlyBWPGjFHlSWinTp0waNAgAP+Lfe7cuShXrhwA4MKFCxg7dixy586NdOnSoVevXsqoNV1quxgHEj4p1iYVsmbNimHDhimjJT9Hje3SpW3j1atXkT9/fri6uioj8nQvAkNDQ/XWm5q2QS3deA8cOKCMeNKlu04jIiKQJ08e5aLC2Hz8+FFJlk+YMAFA3Hq5dOkSVq5ciRMnThhFAk/r5s2byJYtG5YsWaL07RMmTICzszOGDx+Ojx8/4ubNm6hduzZKliypyiS57oW1dt9v3rw5RowYASDuyY00adJg3rx5AOKSflFRUbh8+TKmTp1qNCN4J02aBDs7O5w+fRoA4OfnB41Gg99++00vWd61a1e4u7urLsHwb3x9fWFjY4OlS5ciICAAmTNnhpubW4IlLfbs2QN3d3ds2LABgPoSKbouX74MR0dHJE2aFMePHwfwvz7zzZs3SJ48OTZv3mzIEL+oZ8+emDJlit7fOTw8HE5OTko//ukxNygoCKGhoZgxYwbu3LnzS+P9r+7du4fcuXPDz88PQFxfnzp1avTp00d5T3h4OI4fP44jR47gyZMnhgr1my1duhTFixfH+/fv9Up3/Bu1nUd9ekNeO9p1/vz5WLt2LXLnzo1atWrhn3/+Ud7Tv39/mJubY/Xq1b863G8WExODK1euQKPRQKPRKOUutQ4cOID06dOjVatWePjwod76U9u6AuKvL+3xNSQkBOPHj0ezZs2wZMkS5enXs2fPonjx4qruLwICAuDh4aF3rhAeHo7q1aujXbt2WLFiBby9vVG+fHl4enoiZ86caNiwIQD9v4faRv5PnToVzZo104vr0qVLsLS0xPHjx3H69Gl06tQJTk5OyJgxI+zt7eOVXgXU1y4itWOinMhIaE+6Nm3ahBw5cmDkyJHKaGQAaNGiBSwtLeMly9Xu999/V5KN2jbevn1b7+RZWxYCiHtMbt26dXrfobaT0LVr1yojILUjG/bt2weNRoPGjRsjW7ZsaN68ORYuXIg5c+bA3NzcKMpAfPo4bUhIiN7oi06dOsHV1RUTJkxQ6gurbd0k5N9OHq9cuQJbW1t4eXkhODgYQMIXsGpMBn060tXFxQULFizAhw8flNe0bQ8JCVHW2Zo1a1SflNS9mXHo0CFs27ZNeS0sLEypKawdWW4sPt2OTp48CXt7e1y5ciXe6N706dMrx4AbN27Ee/RWDXx9fVGyZEll1BMQt83Vq1cPO3fuxKFDh5A6dWolSR4ZGYl58+bFS06qvR8JCgpC+/btsWzZMgDAxo0bkTZtWgwYMAA2Njbw9PRURs8D6i0v8CltPfIiRYooc4UcOXIEqVKlwoIFC5T3APrrqFq1amjevPmvD/grjR49WimpdePGDeTIkQPlypXDo0ePlPfcu3cPOXPmxP79+w0V5lfx8/NTRoTrroMSJUqgUaNGys/a127fvq2UojImV65cQalSpQDErRs7Ozv8/vvvyusXLlwwUGTfb/To0bCxsVF+1h5/Y2JisH//fr360Gr0ac3+nTt3wtHRESdOnAAQNwo7adKkyJMnDypXrozdu3cr7/Xz81Nt/55QsnvLli3QaDRo3rx5vJHwBw8ehEajwciRIxP8DrXQPeedO3cuWrdujXr16uHPP/9Ulutug+/fv0etWrVQuXJlo0m2rlu3Tin5M2nSJFSsWBEWFhYYMmSIclO0b9++aNu2rSHD/CrBwcHK9qd70/23335DmjRpkCpVKvTo0QNbt24FADg6OmL06NEGiZXIlDBRTmREtDUn58yZo/fYtlbz5s2RLl06/Pnnn6pPln96Yjx9+nTs2LEDERERiI6ORps2bVCiRAns3LlT7zOVKlVCp06dfnW4X+XTE+Jly5bB29tbGXW3fv16NGzYEMuXL1dGO718+RKurq6qf0RY9+R43LhxqFGjBnLlyoUxY8Yojwtra0KXKFECkyZN+uLIcjXQbdeyZcvg6+uLjh074s6dO8r6vHz5MjJnzowaNWrEq7VpDIYNG4YMGTLg0KFDCfYbHz58QKdOndClSxe9mspqTZZr18vmzZuRI0cOpS5yxYoVlQvX8PBwTJkyBcmTJzfKC4Z79+4hLCwMR44cQbp06XDjxg0A0Fs/WbNmxdSpUw0V4lc5fvw4KlSogJo1ayqJVgDo3LkzrKyskCpVKr0yP8HBwahQoQImT55siHD/s/DwcOzbtw+vXr3C+fPn4eDggOnTpwMAFi5cCHNzc1SuXFlJaGonxVSjTxMhd+7cQb58+QDETSKbOnVqzJ07F0Bc3/Hnn38q/Yr2s506dUL9+vUTfFLK0KKjo9GtWzd4enri9evXAIDr168jW7ZsKFGiBObMmYN//vkHNWrUQOHChVWbxPvUjh07MHbsWOWG7oIFC5A/f369iaeBuJIXxYoVU95nLM6fPw97e3vs3r0bOXPmxO+//66smzNnzqBKlSqqfnoS+PxN+atXryJnzpzo3bu3Xr/w9u1bVKlSRan5r0atWrVSbopp+7Xz588r/d+OHTtgbW2N5cuX49y5c0iVKhW8vLz0SpcA6r4ZumzZMsydO1e5rlq7di00Gg369u0br8b6uXPnVHvu9Kn+/fvDzs4OHTt2hI+PjzLHi7bf/vjxI+bPn290tdafP3+OJEmSwMvLSylLFRgYqDc3FABUqlQJ3bp1M0CEX0+3P9i1axfy5s2LUaNGKcv++uuveE9lly9fXjlGE9F/x0Q5kUqtWrVKKREQGxuLkJAQ1K1bFwMHDgQQN1L56tWrGDNmjN6FUO3atZEtWzajGy1UvHhxZMqUSRm9deLECdSrVw+5cuXCoEGDMHLkSFSoUAGFChUympPQyZMno1SpUmjVqpVSukO31m5ISAi8vLzg7u6u+hNPrUGDBiFDhgyYP38+Jk+ejGLFisHLy0uZNDYqKgpdunSBvb293ugUtevfvz+yZMmC+vXrKzU1N23apIyyvnz5Muzs7FCyZEmjmRwMiEtyubi4KCN6nz9/jlOnTmHgwIFYu3YtgLhtsUmTJmjevLlqk3ef2rt3L6ysrLBw4UJERETg8OHD0Gg08PDwwMOHDwHElZEZPXo00qVLp/obHHfv3lWSDVu2bIGzs7NyUefm5oZixYrpvf/t27dwcXFR1qEaabclf39/lC9fHtWrV1dGPL179w6enp6wtbXF+/fv8f79ezx//hzVqlVDqVKlVJs00X266VPaZPGkSZNQuXJlvH37FgAwZ84ceHt7o2nTpqrv53XjW7t2LR4+fIgPHz4gf/78+P3335EmTRq9kgNXrlyBu7u73qTh586dg4ODAy5evPhLY/8WmzdvRpYsWfRuUF+/fh158+ZV6l53795dOddQ6/aoS7fkVGRkJIKDg9GnTx8UKFAAtWrVgq+vL5o0aYI0adKoet0ACY/Cff/+PerXr49UqVKhfv36eq8NHDgQ7u7uehO/q43uvnX27FmcPHlSb/LHoUOHwtXVFa1bt8atW7ewb98+1KhRA0WKFFHtOW9MTAxOnToVbw6Jt2/f4uXLl/jw4QMqVaqEMWPGKOu0ePHisLGxUa5l1C4yMhIVKlRAsWLFsGzZMiVZvnr16s8mywH1DjTQWrVqFXLkyKGUCtu9e7dSVmbIkCGIiopCZGQkxo8fj759+6qyzKVWQv3FuXPnYGtri5o1ayrHYiDu3OP06dPw9PSEk5OTKtvzOU+ePEHnzp1RunRpjBs3Tu+1kJAQBAQEoGbNmnB2djaqdhGpFRPlRCoTExODe/fuIV26dErCR6tRo0aoU6cOAgIC0LFjR1SsWBEFCxZE+vTp0aBBA+V9z549+9Vhf5PPJQuqVq0KW1tbJVl+7do1jB07Fnnz5kWVKlXQpk0b1Z6sfa5Nfn5+cHNzQ/PmzZXHukNCQrBgwQK4u7ujWLFiRjNK46+//kLevHmVEeSHDx9G0qRJUbhwYVSpUkV5nDEqKgqTJk0yiuQCEDd5UdasWZXRntqka4YMGbBq1SplFO+5c+dQq1Yt1a8nXW/fvkXBggUxbtw4nDhxAi1atICzszNKliwJjUajlE+IiYlR2qX2ZPm7d+/QvXt3ZaT4o0ePkCNHDjRv3hyOjo4oXbq08hRHRESE6pPksbGx+Pvvv5EhQwa4ublBo9Fg1apVyuv+/v7Inz8/ihQpAn9/f5w8eRK+vr7ImDEj7t27Z8DIP+/TfeT06dNKslw7svzYsWNwdnZGunTpUKBAAbi6usLV1VW1E3fqTpgIAMuXL8fo0aMxZswY3L59W1nu4+OD0qVL4969e4iIiIC3t7dSkgVQZz+vW0c+JiYGFy9eRLp06ZSb9SNGjEC6dOnQsmVL5X1hYWGoWbMmvLy84rUpocSRIej2ZZ/2a97e3vD09NTbzm7evIk8efKgRo0ayoTcatsO/8306dOVyd2BuP5//fr1qFKlCjw8PNCsWTPVl3nTrqfDhw9j6tSpmDZtmnK+t3HjRjg5OaFevXo4dOgQjhw5gj59+sDKykqV8zNo6W57gwcPhr29PfLkyQNzc3NMnToV4eHheP/+PebMmYPChQsjRYoUyJ8/PypXrqza/vDT/WnevHnImzevXj8ZHByMAgUKKOcZ7969Q5s2bbBlyxZV9oPA52/S1K1bFyVLlsTSpUuVZPmaNWuQNGlSdOjQQS8Zq3YRERGYM2cO5syZAwD4559/kCZNGixatAjz58/Xm+NFdz2pbRsE9ON7+/atXoznzp1DhgwZULt2beXpoW3btsHb2xve3t6q3beA+OcJ2p+fPHmCbt26oWTJkhg7dqzy+vr16+Hu7o7y5curul1ExoSJciKV0Z6kaUeyXrp0SUmwzp49G25ubkiSJAnq16+PdevWITw8HNOmTUOFChWUz6iZ7sE/ICAAT5480Yu7YsWKyJw5s15d0E8TFGpOku/ZsweHDx+Gv7+/smzWrFkoW7YsmjdvrowsX7duHfr376/axD8Q/4Lh2LFjGDZsGIC4k01ra2ssXrwY27Ztg5WVFapUqaJXexJQ54napxNyjh8/HosWLQIQN5o3TZo0WLlyJdq0aYMMGTJg7dq18crIqPUiT2vq1KlK+YoePXrA2dkZSZMmRa9evZRyRnXr1tWbCA1Qf7u0NmzYgGvXruHVq1coWrQoOnToACBupKhGo0GRIkX06g0bg/79+0Oj0cDV1VVveXR0NC5cuAAPDw9kypQJOXPmRL58+fSSm2qiuw399ddfyuRf2pHlXl5e2LNnj/LeBQsWYMGCBdi8ebNqJ+7s378/3N3dlWNVr169YG1tjVKlSimJrRUrVgCIqytvaWmJQoUKIVeuXHpPQanxJlRCdeT9/f31nky7efMmmjdvjpw5c6Jdu3bo27cvPDw8UKhQIb0bvWrqP3RjmTlzJubMmYPLly8ry7Zs2YIiRYrg2rVrAP53rLp+/TqyZs0KLy8vVdb9B/63Hd2/fx9XrlzBmzdvlNcmT56sJMt1S/DFxsaqbr/6nO3btyNZsmQoV64cLCwsUKJECWXdLV++HNWrV0eyZMlQuHBhlCpVSvUj5LVGjRoFW1tbHDhwAADQpUsXmJubY/DgwXpl0U6fPo379+8r27Aa19un+/qBAwdQsGBBuLm5KdvdvXv3ULJkSbRo0QKzZ89GtWrVULp06QTnNVCbT29Cv3//HnXq1EHJkiWxfPlypTzJ4sWLUaZMGVX27VoJzYnx8OFD3Lt3D0+ePEHhwoUxZcoUAHFPT6ZOnRoajcaoyneMGDEClStXVkp2ahPj58+fR8aMGVG7dm3l+H3+/HlV71u668nPzw/du3fHqFGjlBvyjx8/VpLl48ePBxB3U2rLli2qPYciMkZMlBOpVHR0NN68eQMzMzPUrVsXb968QUxMDO7fv6/3mDMQNyFm3bp1VVkPVGvmzJk4efKk8nP//v2RL18+WFlZoVu3bsqFAxCXLLezs8P+/fvjtUnNJ6M+Pj6wtraGnZ0dChQooNRoBOKS5e7u7mjVqlW8BJ6aLxaAuItWbT3T4OBgvH//HuXLl9cbzVCsWDHkzJlTSbyqeT1paetZ+/v748mTJ7h165beejt16pTyKKo2sadWun/vsLAwDB48GBUqVMCTJ0/w7t07XL9+PV4yoUyZMvEe31QjbdsuXbqkjPrX2rJlC0qWLKlMarl9+3ZUr14dZcqU0ZvsWK1019ucOXPQs2dP5MqVC7Vr11aW6yYkLl26hGvXrqm2xIBue/r3749s2bJh6tSpygWqbrL8n3/+SfA71NYfRkdHY+7cuShdujR+++03XLlyBXXq1MH58+cRGRmJqKgo+Pj4IHny5MokpMePH8eUKVMwdepU1Zfv0K0jr50U9+rVq3BxcdFbn1evXsW8efPg6uqK+vXrq/pxfN24Dx48iEqVKqFcuXLImDEjRo0apTwV5eTkhJ49e8b73I0bN2BhYYG6deuqKvmva8OGDciZMyfSpk2LypUrY/Hixcpr2mT5hAkTjK4WOQD07NkTc+bMQXR0NIKDg1GoUCHkz59fOYZFRUXh6tWrePHihd5NAjW7desWatSogb/++gtA3LHL2toazZo1U8pdJPQ0qBq3v0OHDuHgwYMAgHbt2qF///4AgP3798PFxQUlS5ZUBrhs2rQJpUuXhouLC6pUqaLcWFPzOeLSpUtRuHBhvTmSgLhkeYUKFZA7d24sX7483iAeNbZJd/sJCgrCmzdv9OY6OXPmDAoWLKhMGHv79m10794dO3fuVF2//jnz58+HjY0NJkyYAC8vL2TKlAmTJk1SzvHPnz+PzJkzo1SpUno3pNS4b+kaPnw4MmbMCE9PTxQpUgSOjo5KH/j48WN0794dpUuXhq+vr97n1HquQWRsmCgnUiHdk60DBw4gVapUaNasWbyT6Nu3b6NPnz5ImzYtrly58qvD/GrHjh1D9uzZ0apVK1y5cgX//PMPsmXLhm3btmHq1KkoU6YMatWqpTfZW+XKlWFmZqbqSS5119OtW7dQsmRJXLx4EceOHcPw4cNhZWWl3O0H4p4IyJs3L0aOHGmIcP+T8+fPw8XFBWvWrFGWPXnyBPb29sqywMBANG3aFKtWrVL9iafWkiVL4OzsrLdsx44dKFasGG7dugUgLoE0ePBgjB8/XtUXDAn9zY8dO4bixYsro4S022pISAguX76MatWqGUUdQ23cmzZtQq5cuTBgwAA8f/5cWT5x4kRkzpxZGcE2aNAg9O7dW/Xt0rVnzx4laRwdHY2NGzciR44ceslyIC5J/umFuVpNnjwZ6dOnx5kzZ5Sa/tp1dubMGXh4eKBWrVrYuHGjIcP8alFRUVixYgXc3NxQqlQpuLq64uXLl3r7XpcuXWBra5vgTQy1Xrh+WkdeO9r/0KFDKFGixFf152prm27MAwYMQL58+fD06VM8fPgQS5cuRbFixVCoUCG0bNkS/fv3R+7cuRM8fwoICFCOBWoTEBCA/PnzY9asWdizZw9+++03uLm5YdKkScp7pk2bBo1Gg2nTpqkygadLG9+jR49w//59DBw4EMeOHVNej4yMRKFChVCgQAGcPXtWddvc1wgKCsKKFSsQFhaGY8eOwc7ODjNnzgQQl2xOmTIlevXqpeoSHrGxsXj//j3y5cuHypUro1GjRrCyssKFCxcAxPUF+/btg4uLC0qUKKEcr549e4bXr18r61ltx+dP94/Hjx+jSJEiqFixInbt2qX32oULF2BpaYl8+fIpNxbVun/pxjV27FiULVsWRYoUQcmSJZVSRf7+/koZvosXL6JGjRqoUaOG8jm1rSsg/jnv7NmzlSe6gLjzwOzZs2PixIlKsvz06dOoUaOGqq9RPo2tW7duSg35M2fO4LfffoOtra0yYOTJkydo0aIF2rdvr9ptkMiYMVFOpCLaA5325FJ71//gwYNIliwZWrRooZTuOHjwINq0aQMnJyejeOx03bp1cHV1RZcuXfDHH39g3rx5ymv79+9HlSpVUKNGDb3Hv7t3767aC6JPy3ecO3dOr4b68+fPMXr0aKRJk0ap9QfE1dhUa5uAhJOu9evXR9myZZWf7969Cw8PD7Ro0QIrV66El5cXKlasqGy/ajwR/TSmFy9ewNraWiklA8SNIkqZMiWOHj2Ku3fvombNmvj999+V19V4waBr4sSJaN++vTJia968eUiePLkyUigqKgpLlixBnTp1ULFiRaOpY7h9+3akSJEC8+bNi5dEePbsGbJkyYLcuXOjQoUKsLS0VHWt2k/Fxsaic+fO0Gg0ykV3aGgoNm7cCAcHB9SqVQvv3r3DkCFDULx4caMYHRoZGYm6desqT5wk9Jj92bNnUbBgQfTt29cgMX4LbfyRkZFYunQpSpcujbRp0yojWbU3ac6dOwc7OzucOnXKUKF+k8/VkW/QoAE6deoEGxsbDB48GD4+Phg6dChGjx6Njh07KuW11H5hHhgYiDZt2sRLdD179gwnTpxAxYoVkStXLmg0GixcuBCAOo9dn7p8+TKGDh2KHj16KOsgODgY7du3R5kyZfSS5bNnz1ZKy6jdhg0bkC1bNuTIkQMajQZTpkzR28YiIyNRpEgR2NnZxXuySG0+tx1py0F0794dzZo1U/qOfv36oWzZsqov4aH15s0bZMmSBWZmZkrZOi1tsrxo0aLxRvAC6tvHdP/eGzduVAbnPH36FK6urihXrpxeH6K99vLx8VH9uZPWkCFDkCFDBqxbtw7+/v4oVKgQcuTIoQy+GjVqFDQaDXLnzq03b5Iat0XdmDZs2AA/Pz80btwYGzZs0Hufdi6ASZMmxRtkprZtENCPyd/fH2fOnEG5cuX0SuxdunQJderUQZYsWZSbU0FBQUYzvxCRsWGinEgltAe4Xbt2oVmzZqhatSpatWqlXOQcOXIEyZMnR8uWLfHy5UtER0fj0KFDymRbaqV74F69ejVcXV1hZWWlTDalpU2We3t7K4+va6n5ZHT48OFwc3ND+fLlUa5cOb3XXrx4gTFjxsDa2hpDhgzRe03NbQLiRrlqT8Tev3+PrFmzokePHsrrCxcuRLly5ZArVy5UqlTJaCYkffnypbJNzpkzB+7u7nqljKpXr44kSZLA3t4eLi4uSrvULDY2Fu/evUO6dOmg0Wjg6emJ1atX49mzZ+jevTsqVaqkJFifPXuGPXv2qLo+o67w8HDUqlULI0aMABC3Ld68eRNjx47FggULEBERgVu3bqFTp07o37+/0SSFdIWFhaFnz54wNzfH1q1bAcQly7du3Yrs2bMjW7ZssLW1VcpFqM2n+3xwcDBsbW31+njdm8DaY9a1a9dU3Q8m1JdFRERg9erVsLe3R6VKlZTR8kBcuQ47OzscPXr0V4b5n3yujrw2WZ4jRw5kzpwZ7dq1Q9WqVVGzZk3Uq1cP1atXV/U601q6dCnMzc31ynXExsbGSyT4+/ujc+fOyJYtm2rLGekKDQ2Fp6cnUqdOjcqVK+u9FhQUhHbt2qFcuXJG9dQaEDdC3sXFBePHj8fOnTtRsmRJODs7Y+vWrXrbW2RkpOrLaunuWzt27MD69ev1ykxFRkbC09MTrVu3Vt5bu3ZtvRtsakx4aWONjo7Gw4cP4eLigrx588LLy0tvTiHte/bv3w8bGxtl/hA10l1XJ0+eRPHixVG7dm3cuHEDQFyyvESJEqhQoQJmzZqFa9euoWbNmhg0aJDyObX3h4GBgShdurQyCGnr1q1ImzatMpGn1sWLF+Hv76/qc0Pd/cLHxwepUqVCwYIFodFoUKdOHWUSdy1fX18kT54cf/75568O9T/z8fFB6tSpUaBAAaRKlUpv8BgQd6O0Xr160Gg0ek88qf3ai8gYMVFOpCJbtmyBhYUFhg4dihkzZqBy5cpIkSIFnjx5AgA4evQoUqVKBW9vb7x8+dLA0X5ZQo9Zbt68Gfny5UO5cuX0JrwE4srMFClSRNWjDHVPRmbNmoXMmTNj0KBBaNWqFTQaTbwL1KCgIAwYMABVqlRJ8EJdjXbs2AGNRgMnJydlpN3KlSvh4eGhJPKAuLY9ffpU1SfWumbOnInUqVNj1qxZuHHjBt6+fQsPDw/069dP733btm3Dnj17VD0pTkInxTt27EC1atVQq1YttG/fHjVq1ECvXr3QsGFDrFy5Mt62p9YTa22c58+fR3R0NLy9vdG4cWO8fPkSnTt3Rvny5ZE/f36Ym5vr9RVqbU9CtJPDatsaHh6Orl276iXLY2Ji8Pz5c/z9999GMTHpihUrlCeemjdvjtq1a8e7cD116hTatWunl5RUY6JBd1vau3cvNmzYgE2bNilPea1Zs0Z5hP3w4cPYtWsXqlevjqJFi6qyPbq+VEf+/PnzKF++PGrVqoVDhw4l+B1qa+On+/6bN2/g5eUFjUaTYC183fdfvXoVTk5On22rGuiuszt37qBu3bpwcHDA8uXL9d738uVLNGzYEJ6ennj16tWvDvM/uXjxIgYMGIBOnTrplQjz8PBAiRIl8Pfff6tue/sc3fXUq1cvZMiQAXZ2dsiePTsKFSqkJPinT58OjUYDb29vFC5cGAULFlT1hL+6+8v+/fuVviIwMBDOzs6oUqVKvGQ5AFy5ckW160737zx+/Hi0adMGefLkQfLkyVG3bl1l8thnz56hXr16cHBwgJ2dHUqVKqXaEdd169aNlwC/fv060qVLh48fP2LXrl1InTq1Mknnhw8fMGnSJL0bvoD6+vdPnT9/Hg0bNsSpU6cQFRWFCRMmwNnZGX379o13rjR//nxVt0d3Gzp27Bjy5cuHQ4cOYcuWLahXrx7SpEkT71r53LlzGDhwoKrbRWQKmCgnUok3b97A3d0dU6dOBRBXIy9btmxo3749gP+dqO7btw+ZMmVS/Uhy3RPrkJAQvZOBtWvXomjRomjVqpXeY2VA3AmAMSS8Tp48iYkTJyoTM3348AGzZ8+GmZlZvNHyb968SXDWeTWIjY1VTra0sT158gTVqlWDp6cnrKys8Mcff2DmzJmoUaMGBg8erJQG0m2LGteZbnzR0dHK46Vt27ZFhQoVsH37duzduxdmZmafHQWq9hPR+fPnw9/fH+/fv8e7d+/Qq1cvzJw5E/7+/pgyZQrMzc2h0Wjg4uIS7xFoNdu5cyfSpEmDHTt2YP78+ShUqJAysfGqVasAAGPGjEG5cuX0JqYyBhcuXECaNGmU8gG6o607dOiAlClTqn7y2E/dunUL+fPnx8qVKwHElf1xcHDAsGHDcP/+fQBxZQe8vb1RpUoVVfYXCfHx8UHWrFnh4eGBLFmyoFKlSjhw4ABiYmLw559/IleuXLCwsECDBg3Qv39/oylnBHxdHfmaNWti/fr1hgzzi3S3pe3btyu1rd+8eQMPDw84ODh88UkTBwcH5aawmmjXhzYxqe3r7ty5gxo1aqBixYpYvXq13meCg4MTnBRSjSIjI1G/fn2kSpUKJUuW1Hvt/fv38PDwgJubG9avX6/6fUr3fOP06dNwdXXF2bNn8fTpU1y4cAHly5eHvb09goKCAAB+fn5o3bo1evXqpeoJf3XbNXDgQBQoUACzZs3C+/fvAcSV4itcuDC8vLywa9cuREdHw83NTW/QiBrbpTVp0iRYWlpi9+7duH79OsaNGwdXV1fUrVsXV69eBRC3LV67dg3Hjx9X7cCQ8PBw9OrVC2ZmZnr1uqOjo1GrVi106dIFqVOn1uvnAgICUKVKFaM631i7di3c3NxQrVo1vTlbxo8fDxcXF/Tp0yfBgQVq3gYBYOrUqfD19cXgwYOVZYGBgWjYsGGCyXIttbeLyJgxUU6kEk+fPkX27Nlx7949BAYGws7OTq8+8po1a5RReGpPeH06UqNChQqoXr06unbtqixfs2YNihUrhlatWiVYb1LNiZSrV69Co9FAo9Fg6dKlyvLw8HD4+fkhadKkGDduXLzPqS1J/mm954CAAABxcU6aNAldu3bFhQsX0KNHD3To0AE2NjZIkSJFvEcB1U5bS/jdu3dwdnZGvXr1sG3bNqRNmxbDhg1DwYIFUbp0aeXJDWMRHR2NIkWKoFChQujZsyceP36MgwcPIl++fLh58yaAuBEq1apVg7u7u6r3KeB/+8fjx4/x+++/Y9asWQDibkLdu3cPe/fu1Xt/+/bt0axZM6Moj6Pr2bNn8PT0RKZMmZSyENp1c+HCBSRPnhwajSZebWW1q127Njw8PJSfx48fDycnJ+TLlw/ly5dHkSJF4OTkZDRlmhYuXAhbW1vlAnXWrFlImjQpdu7cCSBu/1u9ejUKFCig92SD2hIoCTGVOvK6x9R+/frB0dERU6ZMUUpNvXnzBm5ubsiTJ48yV8On/vrrL1haWip9plpo27Z9+3Z4e3ujXLlyqFu3rlKC6c6dO6hevToqVKiAtWvXGjLU7/Lq1Su0bdsW2bNnx8yZM/X2n/fv36NIkSKoXLmy8hSO2q1duxY1a9ZEgwYN9Pan4OBguLq6okqVKsoy3T5Q7f2Gr68v0qdPj6NHjypJcu02evfuXZQoUQJOTk5wdHREoUKFEBERYchwvyg2Nhbh4eGoVq1avKcKFy9ejFy5cqFevXpKGRZdak1OhoSEwNfXFxqNRrlpHRERgU6dOsHCwkLvmjIkJATVq1eHp6en6o/FuqZPnw4nJydkzpw53jn7hAkTULx48XhPrRmDxo0bKyVkdM9pAwMD0ahRI1hbW+PEiRMGjJAo8WGinEglQkNDUatWLcydOxfZs2dHx44dlRPnx48fo3nz5soj+WpLuOrSjW3y5MmwtLTE0KFD0blzZzg4OMDJyUkZ7fTnn3+iZMmSqFWrlpKkNRabNm1C6tSp8fvvv+uNaggPD8fcuXOh0WjiPRatJgMHDkSdOnWUGeH37t0LjUYDHx8fPHr0CNHR0XB1dYWPjw+AuBGGrVu3hkajQb169QCoczvs2bMnjh07psS2bNkyNGjQQHks+OzZsyhbtizOnDmDO3fuoF27dnBxcYFGo1F9HcPPXcz4+fmhVq1asLGxwYEDB9C4cWO4u7srF7NBQUGqnmhV15kzZ1CnTh0ULVpUuSj4NOZbt26hX79+sLa2xpUrVwwR5nd7+vQp6tSpA2tra73JmO/fv4/WrVujX79+n03sGdqn60ObNLh27RocHByUEf9A3MRn8+bNQ48ePTBr1izlmKb2pBAQVzqhV69eAOImo7ayslIea//48SM+fPiAqKgo7NixI95TOWr39u1bk6gjrzV16lRkzJgRJ06cUCZI1Hrz5g3Kli2LfPnyKeUUdJ04cUK1Na+3bduG5MmTY9CgQejVqxe8vb2RLFkyZeK6gIAAeHt7o2jRoti4caOBo/28zz31o922Xr9+jSZNmsDNzQ1z587V62M+fvwYr4STmug+Lfjhwwe0bt0aWbJkQdGiRZX3aPu7JUuWIH/+/Kof8b9mzRplgAEQd1OmePHiysjj58+fw9/fH/369VOeqnz8+DEWL16M2bNnG1U/X79+fbRo0SJe392xY0dYWFigYcOGqr8+0f07nz9/Hi1atIBGo1FuoL19+xZVq1aFi4sLGjZsiAEDBsDd3d2oblzrWrlyJQoXLoz69evj3r17eq8NGTIErVu3NppjsVZ0dDR69eqFFClSxCsX9vz5c1SpUkXvJhsR/XxMlBP9YjExMXpJK92RXM2aNdNLRGr5+PigcOHCRjXi9ejRo+jUqZNeTev79++jWLFiehcQS5YsQdu2bY3qJE1r7dq1SJo0KQYOHKg3AiAsLAybN29W9UXC6NGj4ebmhnbt2imPAm/YsAG5c+dGtWrVsHDhQjx48ABly5bVW4erV69WbeIkJiYGNjY2cHJyUkbdLV++HM2aNUOaNGkwYcIEXLhwAcOGDcPQoUMBxI1mO3z4MLp27arq9aW7fxw8eBC7du3C33//rSx7/vw5hg0bhvTp06NGjRqwsbGJV5vRGPYxf39/uLq6IlmyZJg5c6ayXBv7wYMH8fvvv+tN0qdm2v799u3buHTpkt6EnM+fP1eS5bt378adO3cwfPhwVK5cWfVPDQFxk4KFhIQofV9QUBC8vb3RpUuXf/2cGvuPTy+qo6OjUa9ePfj5+eHcuXN6dV2jo6Mxffr0eDdC1dguQL9tukk9Y68jD8S1IyQkBN7e3pg4caKyDNDv7969e4fcuXOjUaNGBonzW2nbVaVKFQwYMEBZHh4ejn79+iFZsmTKk3gBAQFo2LChapPJPXv2xPDhwz97/NEuf/XqFRo3bowyZcpgwYIFRnG80o1RO2/Q8+fP0adPH6RPn16vjAIQ93SAg4NDvOSemsyePRvVqlXTa9vz58+RPXt2TJ8+HWfPnkXLli3h5OSEYsWKQaPRKDdudKm1z/jUkCFDkD179nhPtk6bNg1Vq1ZF5cqV4evraxTb44ABA1CsWDHUrVsXmTJlgkajweLFiwHE3YwaP348atWqpSTLjemGBqC/vy1cuBDlypVD48aNlfJuWsYyMCQhbdu2haWlZbwnCl+9emWU7SEyZkyUE/0i2pFM2gPdjh070KRJEzRt2hRr1qwBEHcRVKpUKRQoUACjR4/GokWL8Pvvv8PKysookkJa27dvh5OTE2xtbXHy5EkA/2v31atXYWdnh0WLFsX7nDGeBKxevTrBZLmW2k5AdZMms2bNQuXKldGmTRtlZPmNGzcwePBg5MuXDy4uLqhXrx66desWb7IftbVLu+1ER0fD2dkZ+fPnVy58QkNDsXTpUtjY2KBly5aoU6cOSpQogVOnTsX7HrW161N9+/ZFlixZlNrIVapUwenTp5X1um/fPmVi2bZt2xo42v/m4sWLSm1a3ZsBQNzFwv79+43ipqF2nWzZsgU5c+ZEvnz5kCJFCnTr1k2J/9WrV2jTpg00Gg3y5MmD9OnT48KFCwaM+vN0++ebN2/CwsICRYsWxe+//45bt24BiJuQOUWKFEb1iLBuu65cuaI8ITR//nykSJECZmZmenWgP3z4gMqVKys329RMt22vXr3SG8n6559/wt7eHkOHDjXqOvIRERFwcXHBiBEj4r0WFhamnDt9/PhR9ck7bZ+hPd7mypULs2fPVl6LiYlBaGgoqlWrhrZt2yqj59V83Fq9erVyLP5cnNr18urVKzRr1gwFChTQK2unRrr7x6hRo+Dl5aX0g0FBQejRoweKFi2KXr16ISgoCNeuXUPVqlVRvnx51e9b2vVx6tQpPH/+HDExMfDx8YG9vT3Mzc3Rq1cvZdRr9erV0bt3b0OG+5/onguXLVsWefPmxdGjRxEUFITw8HDUqVMHS5cuRf/+/WFnZxevVKHarF+/HqlSpcLJkycRFhaGW7duoXfv3nolIhMaZa3GPvHTOD83H9KCBQtQrlw5NGvWDLdv3/7X7zAmbdq0QZo0abB79+54r6m97yAyJUyUE/0CR44c0buzv2vXLlhYWKBRo0bw8vKCRqPB8OHDAcRd2LVu3RqlS5eGk5MT6tevn+Djwmp269YttG3bFilSpIhX++/NmzcoUKAAJk+ebKDovs63nIysWbMG5ubm6Nq1qypPOnXptuvo0aNo1aoVbGxs0KFDBwQGBgKIqwsaEBCAmjVrIkmSJNBoNDh8+LChQv4quu0KDg5G1qxZUaFCBZw+fVqv/nPv3r1RqVIlaDQaODg4KKPAjMHChQuRMWNGnD17Fo8fP8atW7dQsGBBuLu76/URL1++xIEDB1S/LWovZK5fv469e/fi0KFDyuPeZ8+ehYeHB7y8vLBt2zYDRvl9du3aBSsrK8ybNw8hISHYuHEjNBoNWrdujYcPHyrv27dvH/bv36+3TE1096/r168jNDQUHz9+xOTJk1GzZk2kTp0aPXr0wMqVK9G2bVsMGDBASeypmW58vr6+qFy5MtavX4+YmBg8efIEbdq0QZYsWXD8+HGEh4fj3r17qFatGooXL67q5CSgnygYPnw4ihUrBltbW5QpU0Ypl+Dn54eCBQsabR15IG6AQYUKFVCrVq14rwUEBKBjx456pRPU3i9u2LABVapUQVhYGBo0aAAvLy+lPrd2nbZq1Qre3t6GDPObbd++HQMGDFDqx2tp14d2WwsKCkLbtm3jjRJVKx8fH2TJkgVLly7VizkwMBC9evWCubk5bGxs0KBBAzRq1Eh5WkiN+5ZuXfGTJ08iRYoUmDRpktLfX7lyBefOnVPeEx0djTJlymDKlCmGCPer/FvSVbvtRUREoGLFirC3t0fOnDlRoEAB5MqVCwCwZ88eODo6qupcsX///kppPa1p06bBzc1Nb1lwcDDat28PjUaDTZs2/coQ/zPd/UJ74+lTun34ggULkD9/fgwbNuxnh/ZdEtrf/60PaNeuHTQaDU6fPv0zwyKif8FEOdEv8OHDBwwZMgTJkiXDypUr8eeffyoT1YWFhWHBggVImjQpfH19AcSdyIWGhuL9+/eqnxDncwf6Bw8eoEOHDnByctJLikdFRaFQoULKY9JqpNumNWvW4Ny5c/GSIp+2e9GiRXB3dzeaUQw9e/ZE0aJF0bx5c7i6uiJjxoxo06aNkizX8vPzQ5s2bVSfFNL6448/0LJlSxQtWhTJkyeHs7MzTp06pcT/+vVrpU55qVKlVHmxCgC7d+9WksbabapXr15o2LAhgP9dKAQHB8Pe3h4tWrRI8HvUuN50S05t2LABdnZ2sLe3h729PbJmzapcGPj7+8PDwwO1atUymos8XW/evEHr1q0xcuRIAMC9e/eQK1cueHt7I2XKlGjcuHG8UVBqpNunDR48GC4uLspIf+1ry5cvR8eOHZEhQwblJtSnyT01GzBgADJkyIBdu3YppagA4Ny5c2jYsCGSJk2KnDlzwtnZGW5ubkoiWe1JVwAYOXIk0qdPj8WLF2Pr1q2oUaMGnJyc4OfnByDuRv7cuXNVXUf+0yeatLTb1unTp5EyZUp069YNISEhiIiIwNu3b+Hl5QUvLy/V9vNa2nbcuXMHrq6umD9/PmJiYrB48WKULFkSw4cP16vz3bZtW7Rq1QqRkZFGsX8BcRMkajQaDBkyBK9evYr3+p49e/D48WMA6kwiJ2TPnj2ws7NTnpwE4upBX7x4UalZ3rt3bxQrVgz9+/dX3qM7r40a+fn5ITo6Gv3794eDgwOmTp2q1y+GhITg4sWLqF69OpydnVXVV+j61qTrhg0b4Ofnh7lz5yrLf//9d5QtW1Y1k8kGBATAw8Mj3t98xYoVsLS0VG62a/uFf/75BxqNBhqNBtu3b//l8X4L3fU1fPhweHt7Y8eOHQm+R3cuir/++kvVx2LddgUGBuqVNdN9GlZXbGwsxowZo9p9iygxYKKc6Bf5+PEjhg4dCo1Gg5w5c2LZsmV6ry9cuBBmZmZKUsUY6B78jx8/ji1btuDMmTPKI4q3b99G+/btkTVrVjRo0ACDBw/Gb7/9hty5c6v24K970TlgwADY2tpi7ty58UZvAHEXRAnVElb7hevu3buRIUMGvZEKo0ePhqurK9q1a/fZkTNqXWdac+fORdq0aeHv74/bt2/j6tWrKFCgAAoVKoRTp07FOxHVbr9quyifO3cuUqdOjXnz5ikJotjYWDRs2BCenp7K+7QX2+vXr0eWLFnw5MkT1bVF15o1a/QuEE6fPg1LS0ulHv758+fRoEEDWFlZ4ezZswDiJvcsUqQIGjRooJoL1a8VFhaGNWvW4N69ewgODoaLiwvatWsHIO7GWpIkSVC/fn3V1hb+1PDhw5EpUybs3LlTbz1qRURE4Pbt2/jjjz+QI0cODBo0yABRfrsTJ04gT548Sn/44cMH3LlzB6tWrVLauXfvXqxZswb79+9X+hG194exsbF4+fIlihUrhiVLlui91rlzZ+TNm1dvdKguNSUdSpcurTdfwad0SxylSpUKRYsWhaurK0qVKoXChQsbzej4c+fOoV+/fmjUqJHeTaYBAwbA1dUVHh4eGDlyJFq2bInUqVOrfiJj7Xp58OCBMuBjxYoV0Gg0GDRokF6yXLvuJk6ciOjoaNWfQ2mtWLFCmXPn3LlzGD58OHLnzo1UqVKhdevWCA8PR2BgILp164aSJUuqdoCI7t/bz88PyZIlU0oW9evXD/b29pg6dapybrhq1Sp4e3ujQoUKqr1p+C1J14TO4y9fvozOnTsjXbp0uHTp0s8N9j9at26d8oTGrVu34Obmhk6dOunVwD937hzatWuH5cuXq/6YpdW/f39kyJAB27dvjzd4B4i79hoyZEi80nxq2wY/NWTIEOTJkwf58uVDy5Yt473+8uVLZQJWXcay3ohMDRPlRD+B9uRLt2b169evERkZifHjx+slxHVPULUjbtR6Mq1LN+7+/fsjT548yJIlC9zc3NC0aVOl5vWdO3fQoUMHWFlZoVy5cno3CNR8UjNu3DhkypQJZ8+eTXBUf1RUFJo0aYLChQurfuK9TxME//zzz/+xd+dxPWX/H8DfH032JGkhWxtpUZFItkRFKWXNNqFslRBFxdgrZV9TZG0QyU6DkGWI7JJ9yVqWivY+r98f/T53PrcyY+Y7o/vJef6le28e53a3c97nnPeBuro6N3pLcoy/vz9q166N8ePH83LZClXZ8/L29ka/fv1427Kzs9GqVSt06NABFy9eLPc7Qg2ejBs3Drq6uli3bh0+fPgAoPS61apVq1zQa+fOnTA2NuZGoAvR9OnT0aJFCzx//pzbFh0dja5du/Ker/z8fPTv3x/a2tpcJ8H169dlJphclmQU6MaNG2FpaYmXL18CADZv3oxOnTqhcePGvOdQiMRiMZ4/fw5TU1Nerm7JvrL/zs3NRUBAAOzs7AT9jpe4evUqmjVrhuTkZNy5cwdTpkyBtrY2GjdujAYNGlSYD18WzgsorXe0atWKy1ErPQrP0NAQ7u7ulVSyb3fgwAGu3H81Evf58+dYtGgRAgMDsXLlSkGOjq8o9QMAeHh4QEFBAa1ateKVVywWY8eOHfj555/RoUMHDBo0SPDp+CTnGB8fjw4dOiAsLIw71y1btlQYLJ85c+ZXR/0K1Y0bNyASiWBnZwd1dXW4ublh8+bN2Lt3L+Tk5Li1Gt68eYMpU6agVatWWLp0aSWX+uvOnDkDHx8f7Nu3j7ddOlj+5csXvHv3Dr/99ptMdBp+a9BVknMdAJcmrUuXLoINkr958wbVqlWDvb09N5Bn5cqVsLCwwKBBg5CYmIhr166hT58+GDBgAPd7Qr5WQOk6J1paWlwnbn5+Pl69eoX4+HiurXXhwgU0a9YMU6dOrcyi/iXp9sXmzZuhrq6OjRs3Ijw8HI0bN0aPHj24aycWixEbGwuRSIStW7dWVpEZhpHCAuUM8x95+vQpZs+eDbFYjN27d6NJkybIzMxEVlYW5s6dy1tgRdrWrVtx9+7d71/gfygkJASNGjXC2bNnAZSmvqhZsyZsbW25oNCjR4/g7u6OXr16cSlnAGEFKaUbr3l5eejbty+WL18OoLTxfezYMTg7O2PhwoXcaNeEhAQ4OTkJ6jz+THBwMGJjY3Hs2DHo6uri/PnzAP64Du/fv0fTpk3RrFkzLFiwoDKL+rdInqOxY8eiY8eO3HZJUCU6OhoikQja2tq4c+dOZRTxm0kHssaMGQNDQ0OsW7cOWVlZ+PLlCzdad926dfj8+TNevnwJe3t72NvbC3YU3qNHj6ClpYXdu3cDAF68eIGioiKsWLECioqKXLklje6zZ8+iefPm3AJwVUFQUBDatm3LBf/9/f0RFRXFu95CUvad9vz5c9SvX5+7JtL7CwsLuc4cyfarV69CRUUF9+7d+04l/jYVPSO3b9+GjY0N9PX1oaCggLFjx2L79u149eoVWrRogfXr11dCSf++ir5DYrEY5ubmcHJy4rZJOqZGjRolUwv+zps3D5MmTfpqjmvJwISy11iInRrSMzKOHj2K/fv3o6CgAD4+PlBTUyuXakUiLy9P8IEuiYMHD6JGjRpYs2ZNuTqtJFgeFBRUYfBSSP4q7U9iYiI8PDx4M6ays7Nhbm6OpKQk7rhXr15hxowZgs29fvz4cRgaGkJdXR3nzp0DwK+PTJ8+HZqampg3bx4+f/7MbRdy/fd/DbpWNJO0slT07bp69SoaNWoEBwcH7nyioqLQt29fiEQitGzZEm3btv3qu1EIypYpISEBLVq0QHp6OlJTUzFjxgxoampCVVUVLVu25M7lwoULgny3V+Tw4cNc2lWJGzduQFNTE1ZWVtwMos+fP2PHjh0y845nmKqOBcoZ5j8SHh6Oli1bwtnZGTVq1OCNpP78+TN++eWXrwbLhUy6Uvzy5Ut07dqVyx987Ngx1K1bF2PGjEGbNm3Qp08fbmT5/fv34e7uDktLS4SGhlZK2b/F+/fvUVRUBD09Pbi5uSE2NhZOTk7o2rUrrK2toa+vjylTpgDgN8CFWGGTvlaS/IV37txBYWEhTE1NYWlpyVs8MC0tDS4uLtiwYYOgGz/SZVu8eDFEIhGePXuGS5cuoX79+li0aBHv+L1798LT0xMjRowQ5HWSkG4wbN26FSEhIahRowbU1dURERGBwsJCpKenIzAwEDVq1ICGhgZ0dXXRrl07QacXePToEYyMjLBp0yZERkbCzMyMawQZGRnhl19+4TW87969ixYtWlSpRYySkpLw008/oWfPnrC1tUW9evUEPyoUKE0/FRQUhI8fP6Jp06YIDg7m9kkacwkJCdiyZQvv2QoODoaGhkaFKVoqS9kFfyXfJqA04LBjxw789ttvXMAhOzsbZmZmMpEfX7phfffuXbx69YoLKCclJUFBQQETJkwA8MffoUOHDuUW2xaSsu+ytWvXfjXH9YcPHxATE8N1zgtZVlYWGjdujKlTp2L//v0QiUTYs2cPgNJAnoeHB8zNzbF06VKus1fWAidZWVmwsbHhFqmXkJ5lKUnDMm/ePMF+l/8q7U9ZhYWFyM7ORu/evWFhYVEuvZtQzxMA0tPT4enpiXr16mHixIncdukZX2PHjoWLi4sgA67AvxN0FeK5Sb8LP336xLuPrl69ioYNG8Le3p43u/X69eu4ffs297tCfIdIn9ft27dRWFiIO3fuoFOnTjA2NoaysjLGjBmDjRs3IjU1FcrKytixYwfv/xDyMwWU1n+rVasGkUiEdevW8fbdvHkTWlpasLa2LtcpI8TrxTA/GhYoZ5j/0KhRoyASidCnT59yH0FJsLx69erlPp5CJV2BPHXqFAoLC3HkyBG8ePECv//+Oxo3bsyNvpswYQJEIhFMTU25YMnTp08xZMgQ9OrVixuBKCTr16/nRpUcPnwYGhoaUFVVRVBQEM6cOQMA8PX1hYuLS2UW8287dOgQVqxYwbvP3rx5A01NTbRv3x6rV6/GwYMH0atXLzg7O3PXWYhBV2kXL17E7Nmzcfz4cQClga0FCxZAS0sLs2fPRlZWFp4+fYrevXtj4cKF3O8JvWI9e/ZsKCkpYfv27YiOjoaDgwNUVVURERHBNVrT0tKwa9cuHD16VCamP//yyy9QUVFBtWrVsGLFCgClKTqmTJmCrl27IigoCHl5efj48SMCAwOhq6vLC2QKleRZuXfvXoWjp8ViMXdMQkICBg4cCA8PD8HmF5Z+xx8+fBgtW7bE+fPnkZubi3HjxqFLly68hmpRURFsbW0xbNgw3v8xbdo0Qc0IkH6XLVy4EO3bt4e2tjZ69uyJR48e8fbn5+fj2bNnsLe3R/v27QX9vli0aBF+//137md/f39oa2tDTU0Nbm5u3MjQbdu2QUFBAe3bt4eLiwssLS3RunVrwb4zpK/H5cuXuZGtX8txvX79elSrVk0mBh4UFRXh0KFDqFmzJmrWrIlff/0VwB8Byby8PIwZMwbm5uZYvny54Bd+rMi7d+/QrFkzbNiwocL9kvtux44dgp7l9XfS/hQUFCAyMhKWlpZo3769YDuvS0pKyr3TJD+/fv0akyZNgrGxMW/AgXSwXPKNEFpA+UcIus6dOxc9e/aEubk5jh49yrWjUlJSoKKigr59+1bYthLaPQjwyzRr1iz07NmTy8994sQJrFixAgcPHuTWvJKst/Hbb79VSnn/qcLCQhw7dgyampro27dvuf23bt1CrVq14OXlVQmlYxjmz7BAOcP8BwoKCiAWi+Hj44OhQ4fCzMwM06ZN43KdSiqYnz9/hq+vLxo0aMBVBoRKulIcGBgIQ0NDPHjwgLdt+PDhXIV66dKlsLOzw8yZM3mVz2fPngkm/3XZiv769eshEolw+fJlAKVTZaVzKpeUlMDW1lamKjSvXr2CnJwcRCIRZs+eDeCP8/748SMcHR3Rpk0baGtr8xZmElojqKyEhAQ0atQIampqSE5O5ranp6dj2bJlaNCgAVRVVdG0aVOYmJjwRrIJlVgsxrt372BgYFAu3cOIESOgpKSEiIiIcqMpAeE28CSNoZMnT0IkEkFJSQkxMTFcYy47OxvTpk1DmzZtULNmTbRv3x6qqqpfXWRQSCTPyN69e6Gvr49ffvmFN4JauiEoCbIUFBQIstFa1pEjR+Dh4YFZs2Zx21JTU+Hs7AwTExO4uroiICAAlpaWMDQ05AJfQj+3oKAgNGrUCJGRkbh58yaaNm2K7t27IykpiVtEcO3atbCzs0PHjh0Fu1AdUDoK0tjYGI6Ojrh9+zZOnz6Npk2b4tixYwgPD4eDgwM6derEdfKmpaVh3LhxmDBhAmbMmCHI/N1A+bqGmZkZ1q5dy91bX8txvXz5ckFep4rcuXMHIpEIIpEI/v7+3HbJ/ZaXl4exY8dCV1cXa9euraxifjPJNbt27RqeP3+OrKwstGvXDmFhYeWOvXr1KkJCQmTimyzxtbQ/0u+7oqIiHDlyBHPmzBHss/Xu3Tvez2vWrMHEiRPh5+eH1NRUAKWp0SSLj4aEhHDHSl8vodUPf4Sga0REBNTU1BAaGorevXtDVVUVYWFh3ICClJQUqKurw9LSUlApY8oqe+/MmjULysrKSEhIqHBGUGFhIV69egUHBwd07NhR0O/4svUf6XM9evQo6tevD1dX13L7Hz16JOjzYpgfFQuUM8x/SPLRnDt3LkxNTTFt2jReReDly5coLi4uV3kVssePH8PR0RGnTp3ibR83bhxMTU25qX8uLi5YtmwZt7+oqEhQlWvpskjywwGAm5sbLCwseAu4ZWdn4/jx43BwcOAFhYR0Pn8mJSUF2tra6Ny5M9dJIbk3xWIx3r9/j6dPnwp6imZZN2/exMSJE1GzZk0sWbKEt08sFiMjIwP79u2TmRHXEp8+fYK+vj6ioqIA8EexmZmZoXXr1ggPD+fds7IgKSkJhw4dwuTJk6GqqoqoqCguWJ6fn4/nz58jOjoaBw4ckKmFO48fP45atWph3bp1X32PL1q0CEuXLuWllxGy9PR0ruOibA7rJ0+eYPXq1ejSpQv69u2LiRMnCjYoVNbp06fRpk0bnD59GkBp503dunXRuHFjtGzZkht9ffHiRWzcuFEm3huxsbHo2bMnBgwYgKlTp3LragCluZNdXFxgYWHx1YCQkBvnv/zyC5SVlXH69Olyeaylc1yX7XgX6jlJ6gsvX75EZmYm0tLSEB8fjxo1amDy5MnccZKAZEFBAaZNm4bHjx9XSnm/leS89u3bh8aNGyMoKAgAMH78eDRs2BAXLlzg1ZUCAgLQs2dPQc4qlPgnaX/KppkS2n04d+5c1K5dm/u++vv7Q0VFBfb29mjXrh1v0MGLFy/g7e2NTp06ISAgoDKL/ad+pKDr6tWreYs8BgQEoFmzZli8eDEXLL906RLs7e0F32Etce/ePZiYmPAWUgX+uK4FBQVYu3YtbGxsYG5uLuiOa+m/+apVqzB27Fj06NED27Ztw8OHDwGUBssVFRUxdOjQCv8PIZ4Xw/zIWKCcYf4lkg/7zZs3ERcXh6NHj/IaOHPnzkXbtm3h6+uLBw8eYPbs2dDU1KxwwSahWrZsGbS0tNCxY0eusi2pHOzatQvm5ubQ19eHmZkZ9PT0ZCKgHBwcjF69emHXrl0Qi8W4fv06rKyssG7dOt7CdA4ODnBwcJCZilpZycnJaNiwIVxcXLhRNRVdFyFWsL9Wpnv37mH8+PFo2rQpF1gGUOFINVm6Xj169EDXrl25nyXnM3DgQKirq2PYsGGCfqb+yvjx46GqqoqNGzfi48ePlV2cf0QsFiM/Px8jRoyAr68vtw0of1179uyJdu3aCfZcK5pKf/nyZXTv3h0tW7ZEfHz8X/4fQg4mS1y6dIkbnZuQkICGDRsiOjoaBQUFaNKkCbp06YLExETe7wjxvQHw77Fdu3bB1tYWDRs2LLc+Q2JiIvr374/OnTvj4MGD37uY/9iLFy/QoUMHbgFgCen7TBIsl4XFVqWDyd26dcP69euRm5uLwsJC7NixAzVq1ODeIwCwbt06HDhwoLKK+7cdOnQItWrVQmRkJF68eMFtHzBgAFRUVPDLL78gJCQEHh4eUFBQwI0bNyqxtH/un6T9kYX1hi5cuABbW1toa2vj9u3bmDp1KrcwfVpaGgYNGoRatWpxMyrT09MxYsQIeHh4yER9oyoFXaX/3rGxsVizZg2GDBmC2NhY3nGBgYFo3rw5wsLCynUYCq0uP3bsWOzbt4+37caNG2jQoAGSkpLKHS+ZnXzy5EmsXLlSsB3XZZ8NPz8/KCsrw8vLC3379oWmpiaGDBnCpaI7evQoGjZsCDs7u8ooLsMwfwMLlDPMv0B6Cr6amhratWuHRo0awcXFhRdkWLRoEUxNTaGlpYXGjRvzcosKUdmK1vPnz9G8eXOIRCIcO3aMt6+wsBC7d+/GzJkzedO6hVYJla7UZGdnY9SoUahZsyb69OkDBwcHZGVlwcvLCxYWFsjKygJQWjF78OCBoEdcl124c+7cufD29ualjrl8+TKUlZXRv39/waf6kZA+r3PnzuHo0aNcKgGgNBell5cX9PT0sHHjRm670Bt20ud1/fp1PHz4kGvo3LhxA6qqqhg4cCDvWFdXV5w7d443G0CWSL8LJkyYAFVVVURHR3PPmSzq1KkTt7hvWdIL5UoHj4Sk7CJhhYWFXAP1999/R9euXeHg4ICjR49yx5V9/wnxPqwoSCAWi5Geno78/HzY2toiMDAQQGkKtK5du0IkEnHPnCyQ/rvv27cP7du3h6GhIRf8kjhz5gysrKwwbty4713Eb1b2et27dw/16tUrF/QCgC9fvnBBrsOHDwvye1yRgwcPokaNGli6dClv1kxxcTFiYmJQq1YtODo6wsPDAzVq1BB07m5peXl5GDhwIDfy+MuXL7h//z7Cw8ORkJCAAQMGoG/fvjA0NISzs7OgFzGu6ml/rly5AhsbG6irq8PExIQ3mOfp06cYNGgQ6tSpw40sf/funSDrG1U16Arw/85+fn6oU6cODAwMIBKJ0K9fv3Iz7mbNmoXq1atj+/bt37uo3+zp06cIDAwsN4jl4sWLUFNT49YZkn6Gjh49yqvTl90vRBcvXoSmpiYuXrzIbdu1axd69uwJNzc3vH//HsXFxYiPj4ednZ3gOjMYhuFjgXKG+ZecPHkSDRs25Eas7du3DwoKCrCwsOBy5QGlwb7Dhw/jyZMnlVTSvy85OZlLRfLmzRtoaGjAwsLiLxtyQq/UAKX5C5s3b45t27bBw8MDHTt2xJo1ayASiTBp0qRyxwu9YuPv74/GjRujX79+6NKlCzQ0NHDgwAEuJU5ycjJUVVXRvXt3waeCkG4wzJw5E61ateLuPek8fzdv3oS3tzf09fWxatWqyijqP+bn54cWLVpASUkJAwcOxOHDhwGULiKmrq4OfX19ODs7o127dtDV1eWeKaHeh3+1EKz0di8vL8jJyWHbtm2CaoT/GenR1zk5OejVqxc3jVZybSQB2ZkzZ1a4wKdQSF+LkJAQWFlZoWPHjnB0dOS+T18LlguZdPDjzp07ePbsGa/TIjMzE4aGhtwI0IKCAnh4eODp06cy8c2SVjZY3qNHDzg6OpZbSPXatWuCfWdIlysuLg5Pnz7Fixcv0KpVK0RGRpab8XD06FHMnz+fd52FGPCSEIvF+PDhA6ysrHiLSgP8FGgnT55Et27d0K9fP1y/fr0yivqP5ObmwszMDN7e3nj//j28vLzQtWtXqKuro3nz5ggPD0dubi6ys7O5eojQVaW0P2Wf+6tXr8LFxQXy8vJcHV7ybD179gxDhgyBSCTC3bt3v/p/VKYfJeiakpKCQYMG4ffff0dRURFCQ0NhbGyMadOm8QbAAKX5y4V+PhKbNm3C6tWruZ/79OkDTU1NXgdAbm4u7O3tBb0eVEWdNefPn4eamlq5GTNbt26FsrIybt++DYD/3RbSs8UwDB8LlDPMvyA/Px+TJk3iRhY+ffoUWlpacHR0hLW1NUxMTL5p+rpQSH+4jx07BhUVFSxdupTLwZieng51dXV0795dsJXpP7N9+3Z4enpyPy9YsABGRkYoLCxEVFQUl1tTJBLh5MmTlVjSv2fdunVo0qQJrl27BqB02r1IJIK6ujr27NnDNVLPnz+P3r17y8z1Cg4OhpqaGs6fP4/CwkIEBARAJBKhd+/e3DG3bt3C8OHD4erqKtiga0lJCa9sJ06cgKamJk6dOoWoqCgMGDAA7du3x/79+wGULsTq4+ODiRMnYvLkyYKdpSEhObcTJ05gyZIl5XKESsotXX5fX1+kpaV9v0L+Q5Jzy8zMRE5ODjcj4+jRoxCJROUWrZs5cybMzMzK5a0VoqCgICgrK2PlypWYNWsWunXrhgYNGuDChQsASjt3raysYGFhwRspJTSLFi3izdKaPn06mjdvDnV1dejq6nKdaGKxGMbGxrCwsMCKFStgZWUFExMT7n0oxOdLLBZ/tVxlp+lbW1vD0dGR+w5IE9o7v2xnqIaGBlauXAkAGDlyJFRVVXHu3DnuuNzcXPTt2xdubm6Cfc9X5PPnz9DV1S0XrJOQpGUqKCiQqXR8Elu2bEGtWrVQr149ODs7Y8uWLQCASZMmwcrKStAdGWVVpbQ/0s/7b7/9xgXqrl69iu7du6NJkybcqHLphQVnzZolE9esqgRdy9q5cycsLS1hZ2fHW6cmJCQEJiYm8PX1LRcsB4T57ZIuU25uLpycnNC+fXtERkYCAF6/fg1LS0uoqKhg7ty5mDdvHnr06AEDAwPB3oNf66w5c+YMVFVVuVmv0vubNGmCNWvWfNdyMgzzv2GBcob5l9y+fRspKSnIyspC27ZtuUXQDh8+jNq1a6N169bYs2dPJZfyr0k3PtetW4fFixejZs2aUFVVxYoVK3jB8kaNGsHa2lrQU2mlicVifPnyBXPmzEHr1q2hp6eHU6dO4fHjx/Dx8UFoaCiA0gVL161bBysrK0FWPCuSk5ODRYsWcQ3xffv2oV69eti6dStcXV2hpqaGvXv3lhtFLrTASVkPHjyAjY0NN9L66NGjqFu3LiZOnIhmzZrBwcGBO/bRo0eCnCZckX379mHChAncPQeUpsYZPnw4zMzMyuWilBBqw0Fiz549qFevHqZMmfLVALhkYSNZIbmXDh48CEtLS7Rt2xY6OjrYvn07Pn36hNWrV0MkEsHFxQUjR47EsGHDUK9evXKjeoXoxYsXMDQ05N1v2dnZGDJkCJSVlZGZmQkAOHv2LDw9PQX7vrhw4QKMjY3h6OiI27dv48SJE2jUqBGOHTuGuLg4LFy4EHJycpg5cyaA0u9X27Zt0bFjR/Tu3Ztr0Ar1/KTz258+fRoZGRm8/WWD5TY2NrC0tMT9+/e/VxH/J/PmzUPDhg1x+fJl7lzFYjEGDRoEVVVVjB07Fj4+PujatSsMDAy46yXk97z0SPjnz5+jadOmXFBPkgoCKE0zs3btWkEvbvkt7ty5g4SEBAB/PEeenp4YOXIkl+dbiKpq2p+yKTx0dXWxadMmLtXZlStX0KtXL2hqapYLlksI7fyqYtC1IsuXL4eRkRHU1dW52bwSoaGhMDMzw5gxYwTfES9d1wsLC8Pt27eRlpYGNzc3WFhYYNOmTdx+T09PWFlZoWvXrnB3dxd0Dnlp0dHRvM4ae3t7aGpq8maxvXnzBvr6+oiLi6uMIjIM8w+xQDnD/Eskle2DBw+iXbt2XG//mTNn0LlzZ0yYMIH34RS6OXPmoH79+oiNjUVsbCxcXV2hoqJSLlguEokEPVKjosBHcXExsrOz4ezsDFNTU7i5uWHcuHHw9PQsVymVHC80FQUILl26hJcvXyItLQ2tW7fGihUrAJSOIBeJRBCJRDh16tT3Lur/bMuWLXj9+jXOnz8PDQ0NREREAAAmTpwIkUgEMzMz3vFCC3YNGzYM4eHhAEqv2/3799GlSxfUr18f/v7+vGOTk5MxfPhwdOjQgRuVJytu3LgBdXX1r46aBP4YiVdRHlEhO3z4MGrVqoUlS5bg5s2b8PT0hEgk4kZYnz17FsOHD0ffvn0xfvx4mckvfPfuXdStW5cbPS55dl6/fg0jIyMsXry43PMktOdLIjY2Fj179sSAAQMwfvx4zJs3j7d/27ZtEIlE2LFjB4DSZ/HTp0/cu1SogZTTp0+jbdu2yMzMxJQpU6Cjo1MuUF72mkRHR2PSpEmCvVbS3r9/j549e3I5dtPT05GYmIixY8ciNjYWo0aNwogRI2BnZ8ebWSPU6yU9+h34o5wzZsxA9erVy83K8PX1hb29vcysG/ItUlNTERAQAEVFRdy6dauyi/NVVT3tDwCEh4dDVVUVSUlJ5WYrJCcnw9bWFjo6OoLvVPsRgq7Stm3bhjZt2mDAgAG8XPJA6Swwoc+quXHjBkQiEXbu3AkfHx/Ur1+fS0V39+5djBgxAhYWFoiKiuJ+JycnhzcKW4jPluSdUVJSgnfv3qFfv34wNzfnOms+fPiAzp07Q01NDUuWLMH69ethZ2cHExMTmbr/GIZhgXKG+Z9UVEmJi4tDkyZNuIBkYGAgvLy8eCPChO79+/cwMjIql+95woQJqFevHlasWIE3b94AKF3sR4iVGaB8I2jx4sWIiorCuXPnuO0bNmzA6NGjUbt2bYhEIowaNaoyivq3SI9GKzv1DyjNb21mZoZHjx4BKO2sCQwMxLx58wR7rYC/rhQHBQVh5MiR3FTU8PBwODs7w93dXbAV0KysLGzatKncdTp69Cisra2ho6NTLr3PlStXYG9vjzFjxnzPov7PDh48CDMzM2RkZHDXsmygTtKwlU7ZJFTS7/cRI0Zwo5GfPXsGXV1duLu7846TjJoU6jMmeR8ApYHUnJwcAED79u0xceJEXrkLCgrQoUMHboE+IZO+x3bt2gU7OzsoKytz10tyTElJCUaMGIHBgwcjLy+Pd32FHHA4fPgwevfujWbNmkFJSemrHe5ZWVm8hY4lhB4s//DhAxo3bozAwECcOXMGgwcPhrm5Odq1awcNDQ1u3RdZCE5K7qPjx49j4MCBsLW1Rb9+/ZCeno7Xr19j6NCh+OmnnxASEoKwsDBMnDgR9erVk6mc5H/lypUrcHV1RevWrQV9XlU97Y9YLEZeXh569eqFxYsX8/ZJ15euX78OU1NTDBgw4HsX8ZtV1aBrRaTf15GRkejatSuGDBlSbl2rv1oPprJIp71ZsmQJatasCQUFBS5vt6S8qampGDlyJCwtLbkgszShP2OS+t6NGzfKddaUlJTAw8MD7du3R9u2bTFgwACZ7KxhmB8dC5QzzF+QroRI/l12AR9p165dg5WVFVq3bo0OHTrwKgiy4tOnT9DX18e6desAgJcjr2vXrtDU1MTq1at5U4WF/PGfNm0aVFRU0K1bN2hqakJPTw9z587l9r969QoxMTGoVq0aOnfuLNgKWtmAanh4OGxtbTFq1ChulCRQmjKnbt26+P333/H06VM4ODjwcrILrcHw7t073s+xsbEIDQ3F8ePHeffY4MGDudHjhYWFcHFxwbJly7j9Qr4HgdLrIh38PnbsGHr37g0bGxskJibyjr13757gGkB/ZcWKFahXrx73c9nGuGQmSkWdO0K1b98+rF69GmZmZkhISEBOTg4aN26MsWPHcu+JNWvW8BqHQnx/nDt3Dh06dEBsbCwmT54MkUiER48eQSwWY968eejUqROWLl3KHV9QUIBOnTrxUgMJWdlFLdu1a4fmzZvj0qVLvOMmTZqEnj17fu/i/SPSz8+0adMgEolgbGyMFy9eAODXTYqLizF9+nS0atVKptbVkIiKioKSkhLq1asHPz8//PbbbwBKZ+OMHDmSd6wQny9p8fHxqF27NoKCgrBlyxaYm5ujUaNGSE9Px/v37xESEgJjY2O0bdsWDg4OMpO67lvl5ubi7NmzFeZQFqKqmPZHIisrC5qamtwsL+l3Sl5eHhdsvn//viDrG1U56Fq2TF9b4HHDhg3o2rUrhg0bhgcPHvzp/1HZHBwceHXcrVu3QiQSQU5OjpsxBPxR7rt378LNzQ3a2to4ePDgdy/v3yF9TWJjY9GlSxduFtDNmzcr7KzJzMxEdna24GetMQxTMRYoZ5hvcO/ePS7dw65du9CtW7dyKTqkP6KJiYlYunQpZsyYwVVEZY2DgwMvpYVkFPOoUaNgaGiIpk2b4sSJEwCEV1mTrozs378fampq3CjyJ0+eYOHChWjatGm5Bfju3bvHNSSEdk6RkZGoX78+N2IhNDQUDRo0gI+PD3r16oWWLVti4cKF3PHdunXDTz/9hObNm8PY2FiwwUl3d3deWqKZM2dCQUEB7dq1g5ycHCZOnMgtSnfo0CFoa2vD2NgYZmZm0NfX56610K4XUL6T7ZdffoGuri636C9Qek59+vSBjY2NTI0Glfy9nzx5wgVEbt++jZYtW2LBggXcaJvi4mKUlJTAzc2Nl8dRFly5cgUNGjRAXFwcRo8ejcGDB6NJkyaYOHEi9zx9+fIFjo6OCA8PF+Q9KPH69Ws4OzujSZMmUFRU5HXeZmVlYfz48TA1NUX37t0RGBgIS0tLmcvrKv33379/P7p16wYbGxskJycDKB1h2LVrVwwfPryyiviPhIWFYevWrYiIiICjoyM6duyI1NRUAPxv3aVLl+Dp6Sn4DsOvefbsGS/9Q0lJCaytrREYGFiJpfpr0vddVlYWunbtyo3gffHiBVq0aMHNPpHIyMhAcXGxTC7cWZVUtbQ/FbG0tOQtfC6pU9y8eRMBAQG8gT9Cqm/8KEHXr6W8kX6Pb9iwAa1bt8Yvv/zyXxftf/L27Vuu7ieZsfbmzRuEhoZCTk6O68SQPv8nT55g/vz5gv5uSZf3+PHjGDduHKpVq4bBgwdznWs3b96Uuc4ahmH+HAuUM8w3WL58OUQiETw8PCASibB58+bKLtJ/RlIhuHv3Llq0aAE7Ozve9sGDB+Pq1avo06cPzM3NK62cFZkzZw73b0kgKzw8vFw5X79+jenTp6N79+7IyMgo1zgQYoXt1q1b8Pb2hp6eHtasWYO5c+dyIwdfvHiBefPmoUmTJryR8rGxsThy5Ah3PkJs3C1evBhNmjSBv78/Tpw4AVtbWy6H6969e6Gnp4dRo0bhzp07KC4uxqFDh+Dp6YkZM2Zw5yPE6yUtPj4e9+/fx6dPn7B48WIYGBjAx8eH23/48GE4ODigbdu2MrEApKTCv2/fPhgYGGDTpk34+PEjPn/+jLFjx6Jz586YNWsW8vPz8fjxYwQFBUFVVVWmOg0fPHiA2bNnw8/PDwCwceNG6OjowNzcnMs9DJR27Ojo6PDSmgiN5PkIDw9H7dq10bZtW+zcuZPXcMvOzsaOHTswcOBAODo6Yvz48YJ9vsRi8VfLVHZRSwsLC9StWxddu3aFq6srTE1NBT8iVPp7FBMTg59++onr2Dhy5Ajs7OzQsWNH3mK5cXFx5UaYy6qcnBwkJSXBwcEBRkZGgvxuAUBwcDB27twJ4I976c2bN9DU1MSLFy/w9u1baGhoYOzYsdzvbN++nTdDj6lcVSntT1mS90F8fDy0tLS4+1AsFiM3Nxd2dnbo3bu3YN+DP0LQdc6cOXB0dMSRI0cqPEZ6Edz4+HjBntehQ4fw+vVr7uelS5fCwMCA69AFSs9VTk4O0dHR3DZvb2/cvn2b+1mo5ycxZcoUtGnTBpMmTYKVlRU0NDTQt29fbubrrVu34ObmBl1dXcF31jAM89dYoJxhviI6Opo37W/QoEEQiUTcNGCxWFyugrlo0SLeyA1ZVlxcjOPHj0NbWxtaWlpwcHCAiYkJdHR0AAAhISHo0KGDYCrZV69ehZKSEnr16sXbvn37drRs2bLcqI2EhAReAEIW3Lt3D97e3tDX10fz5s15i2S9evUK8+fPR9OmTcstYgcIrwIqfd+sW7cOzZo1w5gxYzBo0CDe6Pc9e/ZwwfKK8loLudEqFovx6NEjaGtrc7MX3rx5g5CQkHLB8j179mDatGmCGtH1Zw4cOIA6depgyZIlvAbSp0+f4O/vj1atWqFGjRowMjJC8+bNZaIDQCIrKwtmZmZQUVHB5MmTAZQ+P76+vjA2NkaPHj0wZcoUDBgwAEpKStyMB6EpuxDduXPncOHCBQwYMABdunThNVilCT0oJL3ex+nTp8stbCn9bjl48CAsLS2hqamJHTt2cM+XEM+rrL1792Ljxo3YsGEDb/uRI0fQp08fmJqa4siRI7C1tYW5ublgvsX/C7FYjMTERDg4OMDW1laweV0LCgq4gRPx8fG8fba2tggODkazZs0wfvx47hxev36Nfv36Ye/evZVRZOYrqlLan4p8+vQJa9euRYsWLWBgYAA7Ozu0b98ebdq0EWSn4Y8SdPX390fDhg1x+PBh3vlKfPr0CUFBQdi/fz9vu9DOa9OmTahZsyZWrFjBBYyfP38OZWVlWFtb8+rtc+fOhUgkwrhx49CpUye0atVK0N9i6eciMTGRW7dAYt26dWjfvj2cnJy4NCwpKSmC76xhGObbsEA5w1QgOzsbampqMDU15fKBjh8/Ho6OjhCJRFixYgV3rPRCbkuWLIGxsXG5tCxCU1Gl+GsV5YyMDPj7+8Pb2xt+fn5cxXrEiBFwcXFBQUGBICrZeXl5OHz4MPT09GBlZcVtP3fuHJo1a4Y5c+ZwOZKB0hHzbdq0kbn8oHfv3oW3tzeqV69eLpXFq1evsHDhQvz0008yMetBOii8du1a1K1bF5qamuVGHu/duxeGhoZwdnYW/KjkigLdS5YsQa1atbgGw9u3bxESEgJDQ0NeGpY/+z8q09mzZ3k/v3//Hh07dsSiRYsAlD577969w/bt23HhwgXumB07duDMmTOCfx9WJCUlBbq6ujAxMcHVq1cBlAZXN2/eDDc3N9jZ2WHKlCm8xruQSN9DL1++RE5ODteQe/bsGZydndGlSxds3bqVO27RokXcyD1AWMETidOnT6Nt27bIzMzElClToKOjUy5QXvb5iY6O5nVCCe35qsjz589Rp04diEQi7jmTbnifPHmSS6VjbW0tyIDXP5Wfn4+UlBTBd2pkZWXB19cXcnJy2LdvH4DSALqnpycUFBTQp08f3vEzZsyAkZERV6dkhKMqpP35s215eXm4c+cOJk+eDF9fX4SEhAgyjUxVDrpKO3XqFLS0tLi6RX5+Pl69eoX4+HhuxtqFCxfQrFkzTJ06tTKL+k2mTp0KLS0trFixggv6p6enQ11dHd26deNdt/Xr18Pe3h6jRo0SbEeojY0NN7NVIi4uDg0bNuTVZ/Py8hAaGoratWtj0KBBXCe+5HyEdl4Mw/w9LFDOMF/x/PlzGBoaon379nj58iW3PSQkpFywHAB3jPRoNyGSDhK8e/euwlzrko97RQGFjIwM+Pj4QFlZmTd6ozJJV44PHDgALS0tODs7c9uWL18OBQUFTJ06FQcOHMCtW7dgY2MDCwsLmQialHX//n2MHz8e2tra3CJNEi9evMDmzZtlpoIm/fePjo6GqqoqfH198eTJE95x27dvx9ChQ2Xmeu3atQvHjx/nfnZxcYG9vT0X1MvIyMDixYuhoqKC5cuXV1Yx/9LJkyehoKCAjIwMrgGelZWF7t27Y+XKlXj27BlmzpyJ7t27o0GDBtDS0uLy88q6GzduoE2bNnB3d5epmSfSgZK5c+fC3Nwcurq6MDc3x9GjRwGUNmJdXFxgaWkJHx8f2NvbQ1lZWfDvjcOHD6N3795o1qwZlJSUuLUNysrKypKpnP9lFRcXIzExEfr6+ujcuTM3BV/6W1dQUIBHjx4JPqD8vxD69crKysKUKVMgJyfHjRR/8+YNunfvDnNzc/j7+yMqKgpjxoyBoqIirl+/XsklZv6MrKT9AfjPRmZmZrlF0YG/DtQJ8X1f1YKuQPnOi4SEBLRo0QLp6elITU3FjBkzoKmpCVVVVbRs2ZI7lwsXLgjyfCSkyzZlyhS0aNECK1aswJs3bwDwr9udO3e4Y7Ozs7l/C+0Ze/78OWbPns2tyyVx+fJltG7dutwMooyMDGhpaUFPTw+DBw9m604wTBXCAuUM8ydevHiBVq1aoX379twoIEkPcrVq1bB8+XIUFxdj3rx5sLKy4o3GE7rAwEAYGhpCUVER/fr1440sBEo//hs3buQW6gNKKxBLly6FiYmJYNINSFdAw8LC4OrqCi0tLYhEItja2nL71q1bB0tLS9StWxeGhoawtLTkKqNCb4xX5N69e/Dy8kKrVq24BT7LEnIFW1rZkeUaGhrw9/fnpT762vFClJKSApFIBF1dXYwePRr5+fk4fPgw7OzsEBMTw5VfMgpbyNcpLy+Pm4khuR6FhYVwcnJCu3btUKNGDfTv3x8bNmzA06dPMXDgQHh6elZmkf9VKSkpaNu2Ldzd3QXTMfit5syZgwYNGiAmJgarV6/G6NGjedPVX7x4AW9vb9jZ2cHJyUnQ70PpZ2TatGkQiUQwNjbmvstl83NPnz4drVq14tZxELKyf2/pwMHp06ehpqYGBwcHbltF7wshXrMfRVZWFnx8fCAnJ4fY2FgApQGiSZMmwdzcHG3btsXAgQN5qdIY4ZGVtD9lzZo1CyYmJmjRogUCAgLKBeoyMjJw+PBh3toaQlQVg64A/918+/ZtFBYW4s6dO+jUqROMjY2hrKyMMWPGYOPGjUhNTYWysjJ27NjB+z+EfA9K/819fHwqvG6NGjWCtbV1uY5Coc6Akvy9w8LCcOjQIQClqXA6d+6M7t2748qVK9yxz549w4ABAxAcHAxjY2MudRPDMLKPBcoZ5i9IguVmZma8YPnSpUshEolgZmaGunXr8j6cQiRdWVuzZg3U1NSwceNG7N69GzY2NrC0tERoaCh3zIEDByASibBmzRre//PixYtyU92FICQkBPXq1cORI0dw/vx5hISEQFNTEz169OCOkYzeuHHjhqBH4ZUNenytMimds3zVqlXfo2j/kz+rFJcNljdp0gQzZ87Ew4cPv0fR/idlr9fLly8xfPhwDB48GDY2NjA2NkZsbCwsLS2/uoaBkBtCAPD48WOIRCLuHZGXl4c9e/Zg9+7dKCws5K6tq6srvL29K1zDQValpKTA3NwcQ4YMEWyqlbI+fPgACwsL3oyTkpISzJkzB9WqVcOlS5cAlE75zsvL466VEN+H0sLCwrB161ZERETA0dERHTt25K6JdNkvXboET09PwT9X0u+OFStWwM3NDZ06dcKGDRu4kZOnT5+GqqoqHB0duWOryrMlayR/94yMDDx+/Bg5OTncNfT29oacnBx2794NoPR+LCoqQm5ubrnRiYwwyULaH+l3xrp166ChoYFVq1Zh4cKFqFu3LlxdXbkgJVCag72iXPpCVNWCrtLXatasWejZsye3APCJEyewYsUKHDx4kEuLlpGRgXbt2gk+2PpnHbNeXl4VXjeRSAQvL6/vVcS/bfjw4bCzs+N+zsjIwIABA1C3bl0cO3YMQGndXkdHB507d8b8+fOxf/9+9OjRA/3790deXh4aNmxY4RpRDMPIJhYoZxgpkorWvXv3kJyczOXmffHiBQwMDHjBcgC4ePEiNmzYgMePH1dKef+Js2fPIiQkhJfDOjMzE97e3ujQoQMvH3FcXBxXcRViJVQiLy8Pzs7OmDNnDm/bnj17oK6ujr59+1b4e0IchSddpri4ODx69OhPj7lz5w6GDx8OV1dXQV8j6TKnpqbyRgFVdMzatWshJyeHdevWfZfy/RukGzd79+5Fy5Yt8ebNG6xevRpjx45F7969IRKJMGPGjEos5T9TVFSEOXPmoHr16liyZEm5/R8+fMCMGTOgpKRU4aKrsu7y5cvo1q0bXr16VdlF+SYvX76EoqIiYmJiAPyx+PSXL19gbW0NX19flJSU8J45Ib4/pMsXExPDW4D5yJEjsLOzQ8eOHZGWlsYdFxcXV26EudD5+flBWVkZU6dOxZAhQ6ClpQUXFxcu5/+ZM2egoaGBTp06VXJJf1yS52Pfvn0wNzdHkyZN0KNHD3h5eeHLly8oKCjg0rBIcpYzskuI9UNp58+fx/Lly7mOGaC0g7BevXoYPHgwb02etWvXCjLoD1TNoGvZb+msWbOgrKyMhIQEXipPicLCQrx69QoODg7o2LGjoL9Z0tdr69at8PX1xezZs7F9+3Zue0XXLSMjQ9DnFRcXhwYNGmDEiBHctnv37sHd3R1KSko4fPgwgNK1oEaMGAETExPo6uqiZ8+e3GyNLl26YMuWLZVSfoZh/n0sUM4w/0+6EdSiRQu0bt0atWrVgpubG169eoXnz59XGCyXJWlpaRCJRLyRoZLzzsnJgY6ODvz8/Mr9nlAr2NK6d+8OFxcX3rbi4mK4ublBJBLB3Ny8kkr27aQr1/7+/mjWrBlmzZqFvLy8csdIp/l5/PgxV3kVerArKCgIdnZ22LlzJ+++klSgJdOdgdJgs5Ar1tKuXLmCZs2awdzcnFsgdsaMGejSpQvy8vJw+/ZtrFq1CiKRCL179xbkdZImKd/du3eRlJTEpWAKDw+HSCTi5VXfvXs37O3toaOjg5SUlEop7/cg/RwKydcCDc7OznB0dOQCJpJr6uTkhNGjR3+38v0b9u7di40bN2LDhg287UeOHEGfPn1gamqKI0eOwNbWFubm5oJ/vqQlJydDS0sL586d47YdOHAAdnZ2GDp0KN69e4eSkhIkJCSgb9++gg/gVWUJCQmoXbs2li9fjhcvXiAgIAAikQi7du0C8McCnyKRiJuyzzD/ttTUVK4uHxkZCeCP9/vly5ehqKgIV1fXckFZodXlq2rQVdq9e/dgYmJS7n0guV4FBQVYu3YtbGxsYG5uLjMpf6ZPnw4VFRX0798fFhYWUFVVxZgxY7j9kyZNgra2NhYuXIj3799z24V6XmKxGEeOHEH9+vXh6urKbb937x5Gjx7NC5bn5+cjKyuLN3AiMDAQ6urqMjVwjmGYP8cC5Qwj5fjx46hfvz4iIiJQUFCAI0eOQCQSYfDgwXjx4gWeP38OExMT6OjolFsEU4gqChYcOXIESkpKcHJywocPH3jHjB49GkOGDBF0kOFrQYJly5ahU6dO3BQ5iaVLl8LJyQnu7u6CraCVFR4eDmVlZVy5cgVZWVnl9n/58gXjxo0rF+wSegBFMqrm6NGjFabvyczMxKxZs5CcnMzbLgvX7fPnz0hNTUWvXr2gp6eHadOm4cSJE/D19UVERAT3TN28eZM7HyE/Z0Bpp2HdunWhra2NGjVqIDIyEm/fvuXSTkkWNM7Pz0dERARrIFQC6Wf+xYsXvLz+UVFR6NChA2bMmMFN7c7Pz0e3bt0QEBDw3cv6Tz1//hx16tSBSCTCokWLAPDfCSdPnoSzszOaNGkCa2trLtAg9OdLIjk5GWpqauXee3v37oWSklK57YDw3/VVjVgsRmFhIdzd3bkZQRkZGWjSpAlvZGtJSQny8vIwc+bMKjmzhhGOgwcPol69enBzc+NGtEreecnJyRCJRJg1a1ZlFvGbVZWg69ixY8vNJrlx4wYaNGiApKSkcsdLUjKdPHkSK1eu5M5HaB0aZSUmJqJRo0bcOWVlZWHnzp1QVFTkrVEzatQo9O/fX2a+xSUlJThy5AgUFRUxdOhQbrskWN6gQQMcP36c9zu3bt1C3759oaGhUaUHijDMj4gFyhnm/2VlZWHs2LGYO3cugNJRutra2hgwYAAUFRXh6OiIp0+f4unTp7CwsBB8UEi6IV12cZ/4+HjUqFEDEyZMwMuXLyEWi5GXlwdTU1NBT2eUPqczZ87g2LFj3HV49OgRLCws0LdvX+zbtw9isRhZWVlwcnJCcHAw93tCq1iXlZ+fj/79+yMsLAzAH+csfe5ZWVkYPXo0hg8fLjMV0Hv37qFNmzbciAwJ6fI/fPgQIpEIU6dO/d7F+1ctW7YMLi4uUFVVhZmZGQYOHFhuIS0hN4RKSkrw/v17WFpaIiIiAg8ePMCCBQsgEokQEhKC169fY+nSpahRowYWLFhQ2cVlUDp7oWXLllBRUcG4cePw4cMHAMDChQvRrl076Onp4eeff4a5uTn09fUFff+VVVxcjMTEROjr66Nz587Iz88HwH+GCgoK8OjRI0HnFgb+eN9Jv/d+//13qKqq4ujRowD4s2q0tbWxbNmy71pG5uv69++PTZs2IT09HRoaGhg7diy3Lz4+nvu+ycp3mRG+P+sUi42Nhby8PKZOncoFXSX3XmpqqmDfg9KqStD16dOnCAwM5L2/gdIUnWpqalyAVboNcvToUd46ImX3C9X27duhq6vLfYuBPwZM6Onp8QLGsjLbVdrhw4dRr149XrA8LS0N7u7uEIlEuHz5Mu/4LVu28NK/MQxTNbBAOcP8v4KCAuzevRsPHz7E+/fvYWpqyo1oiImJ4VImpKeny0TlUyIkJAQuLi5wcXHB1atXuYBdXFwcatSoASMjIwwcOBBOTk5o06aNTCw65e/vj3r16qF58+aoVasWl289NTUV1tbWMDAwQNOmTWFkZMQLCgmxolZWdnY2mjdvzhsJJCl3bm4uXr9+DQD4+PEjt10WRhfevn0bampqOH/+fLl9+fn5+PjxIwDg/v37MvV8SZNu4Dx69Ajh4eGoUaMGRCIRVq5cWYkl+zaS+ykvLw+5ubkICAjgAq4AsHz5cl6wfOHChWjQoAHev38vE89WVbV3715oampix44diIqKQoMGDdCrVy9u1tPJkycxY8YMjBgxAgEBAdzzJcQGedl3mfS74PTp01BTU4ODgwO3raJzEOr7ULpcZb+zgwcPhrq6Ou7du8dty8jIgIGBAbf4G1O5iouLMXz4cDg6OkJLSwseHh7cey8rKwsjRoxAWFiYIJ8rRjaVXbfF09MTAwYMQExMDJdWZdeuXZCXl4evr2+Fs2mEXp+qKkFXaZs2bcLq1au5n/v06QNNTU3ejK/c3FzY29sLenBSWZK/+7lz56CmpoYzZ87w9l+/fh0KCgo4efIkb7sQv8nSZTp9+jS2b9+OU6dO4dmzZwBKg+VlR5bfvn0bixYtEvwzxTDMv4MFyhlGiiQH7bZt22BhYcHlIv/111/RvXt3NG/enPuIyoLly5ejQYMGmDFjBgwMDKCtrY3NmzdzCykePHgQioqKMDIyQmJiYoV5ooVAukJz+fJlGBoa4vz587h//z5++eUXVKtWjUsD8fbtW5w7dw4LFy5ERESETAWFgNLR/4MHD8aQIUPKLRz4+++/Y+DAgby8k0KsgFYkOTkZCgoKSEhIAMAPFJ05cwaRkZH4/Pkzt02IFdGKGmdlt5X9+cKFC/D39xfk+VQkPj4etra20NfXh56eHrdwosTy5ctRvXp1/PLLL3jz5g1vGjTzfZR95k+fPs29/4DSmRnKysro2bMnr2Eu9OCJ9HmtWLECbm5u6NSpEzZs2MClsTh9+jRUVVXh6OjIHSv0oAnAL2NYWBjs7OwwYMAAzJw5E0Bp6qbevXtDUVERCxYswLJly2BrawtjY2NBfruqqrKz78pKS0tDo0aNoKury3uGAgIC0KJFCzx48OC/LiLzA5o+fToaNGgAT09PWFpawtjYGI6OjtyMytjYWNSqVQtjxowR5Lu9IlUp6Cr9js7NzYWTkxPat2/P5Y9//fo1LC0toaKigrlz52LevHno0aMHDAwMBH29vva3lsysHj16NK+O+OrVKxgZGeHEiRPfq4j/Mz8/P2hqaqJt27awsLBAu3btuNkNklSlw4cPL/d7Qr5uDMP8O1ignGEqMG/ePBgaGnKjKWfMmIFVq1YJLoBcVtlKzZw5cxAXF8f9PHToUOjp6WHTpk3cYpAHDhyAvLw8fHx8IBaLBdUol4yelggPD0dQUBCmT5/O275w4UJUq1YNq1atqrBiJ6RzkiibW1g6KL57924uGPnkyRMAwPv37+Hk5AQbGxtBNhQk/qxsrq6uaNiwIR4+fMhty8vLg62tLSZNmvQ9ivePSZ/Xu3fvyq1RUFJS8pe5x4VesU5OTka9evUwfvx4uLm5ce8F6WArAAQHB0NJSQmZmZmVVNIfl/S9tXbtWvj4+MDU1BRBQUG84x49eoSGDRuid+/euHPnzvcu5v/Ez88PysrKmDp1KoYMGQItLS24uLjgwoULAEo71jQ0NNCpU6dKLum3kb5mISEhUFBQgK+vL9zc3KCqqoquXbtydY3JkyejU6dOMDc3x+DBg2VmYbeqwMfHB3PmzPnqN0yyPS4uDrVq1YKVlRX69euHQYMGQUlJieWnZf4TFy5cgKamJm823o4dO2BjYwNXV1fu3bF9+3Z069ZNsB2HVTXoKl2fDQsLw+3bt5GWlgY3NzdYWFhg06ZN3H5PT09YWVmha9eucHd3F/T7vWxdw9fXF6NHj8alS5cAlC5srKenh/79+2PdunVITExEr1690K5dO0GeT0UiIyOhrq7OPVvz589HjRo1EB8fzx0jWatszpw5lVVMhmEqCQuUM0wFUlJSUKNGDVhaWsLa2hr16tUrN7JSaKQrNUeOHMGuXbvw888/IzExkXfcsGHDoKenh+joaG6hyPj4eNSpUwdjxowRTOqVHj16YNq0abxtI0eOhEgkgr29fblOi0WLFqF69epYvHixYM7hWwQGBkJbWxvNmzdHmzZtcOTIEQDA5s2boa6uDnNzc3Ts2BHt27dHmzZtuPMWYrBcuky7d+9GWFgYli5dyo2ye/jwIWxsbFC7dm0sWLAAs2bNQs+ePWFoaCj4ILJEYGAgDA0NoaioiH79+mHr1q28/RkZGdi4caNMLPYr7eHDh5g9ezYvn//atWvRpEkTzJgxo1ywXDolC/N9SL/jJe+7QYMGoVatWjAwMMCpU6d4xz9+/Fjmcv4nJydDS0sL586d47YdOHAAdnZ2GDp0KN69e4eSkhIkJCSgb9++gnwPfs358+cxduxYLhc5ANy9exe6urqwtrbmtmVlZSE3N5e73rLybpR1MTExXLD7r/7mqampGD9+PH7++WfMnTuX5adl/hVDhw4t9x4/fvw4VFRUeLMVxGIx1q9fj5YtW/ICtRJCey9W1aDrjRs3IBKJsHPnTvj4+KB+/fpc+qy7d+9ixIgRsLCwQFRUFPc7OTk5vPaLEN/v0vePn58f6tevD2dnZ5iamkJVVRWzZs1CYWEhTp06BVdXVygqKsLU1JS3mLYQr1vZ1D0TJ07k2pn79u2DgoICIiIiAJTO8pIM1rp48aIgrxPDMP8tFihnmK+4cOEChg8fDk9PT9y+fbuyi/OnpCuhU6dOhaKiIpo0aQKRSAQPDw98+vSJd/zPP/+M+vXr49ChQ9y22NhYqKmp4c2bN9+t3H8mNTWVy1koXX4/Pz9Ur14de/fuLfc7M2bMQOfOnQU7ogbgV0BjYmKgpKSEHTt2ID4+HgMHDoSKigpXUTtz5gwiIiLg4+ODNWvWcBU1oVfY/Pz8oKqqCicnJ7Ro0QK9evXCnj17AJRObZ85cyYsLCxgZWUFd3d3QZ+X9PVas2YN1NTUsHHjRuzevRs2NjawtLREaGgod8yBAwcgEomwZs2ayijuP5KVlQUzMzM0bNgQAQEBvH2rV6+GhoYGAgMDeQsYC/kZq+quXLkCNzc3bnrw48ePoa+vD3t7e5w9e5Z37MuXLwXZYP2a5ORkqKmpITk5mbd97969UFJSKrcdEF5QqCIHDhxAmzZt0KRJE1y7dg3AH+W+dOkSVFVV8euvv/K2A+w5qwyHDx/GjBkzys2YKTtjSJaeK0b40tLSuACktKSkJGhra3MBdMn9V1BQgHr16pVbDFJoqmLQVXrgwJIlS1CzZk0oKChwA6ok55yamoqRI0fC0tKSS8MiTejv9/fv32PQoEFchwZQOurawMCAq/fm5eXh7du3SE9PF3TnrvTf+sqVKygsLMTEiROxYcMGHD9+HHXr1sW6desAlN5v0dHRiIqK4p2LEM+LYZj/DguUM8yfKCkpEXxFRlpKSgr69OmDCxcu4N27d/D29oapqSkWLlzIjR6XmDdvXrmPviQdS2WTrhQHBwfDxsaGS0ECAOPHj0ft2rWxf//+cr8ruV5Cv267du3CqlWruKC4hJeXF5SUlHD9+vUKf09oDYayVq1ahWbNmnEBra1bt0IkEqFTp07YsWMHd1zZzhuhV0DPnj2LkJAQbuFYAMjMzIS3tzc6dOjAC1DGxcUJ/nzKSklJga6uLiwtLXHr1i3evnXr1qFmzZqYO3euzJ1XVRMTE8PNLpFeL+Pu3bswMDCAvb09F0CXJsTrVtG7+vfff4eqqio36lo6aKStrY1ly5Z91zL+U2WD91evXsWQIUNQvXp1LFy4kLfv3bt30NHR4RrpTOXauHEjRCIRgoKCKlyDISEhgbdOiNDrGozsWbduHW8RXzMzM7Rv357XWf3q1Su0adMGhw8frowi/m1VJejq4OCAMWPGcD9L6rhycnLYvn07t11S/rt378LNzQ3a2to4ePDgdy/vP7V+/XooKSnB1NQU9+/f5+0LCAiAqqpqhTMLhdhxLV2myZMnQ0dHB2/fvsWsWbNQu3Zt1KlTh5ci5/3797C2tsb8+fMro7gMwwgEC5QzTBXx66+/wtraGoMGDeIFU318fNCuXbsKg+WA8CqhFS2GKC8vj8GDB/OC5ePGjUOdOnUqrHgKveEqWRBMJBLxGggSnTp1gqurKwDhn4u0L1++wN/fH6tWrQJQOgq0fv36mD9/Pjp16gR9fX1eQ0JC6OeYlpYGkUjEu16SMufk5EBHRwd+fn7lfk9oz9ZfuXHjBkxMTDB27Nhys2iioqLKNZaY7+/GjRuwtraGgoICNmzYwNuXmpqKNm3aoEOHDl/taBMK6YZr2VRZgwcPhrq6OjeFHShNaWRgYMALHgmV9LkdOHCAW3/i/v37GDZsGIyNjXkdpAUFBWjdujVvQVbm+5G8y58+fcrdi5LgV0BAAC9Yvm/fPtSpUweLFy8WZECIkU3SsxVevnyJ/v37Q1dXl5uJ9/79e+jo6MDY2BiLFy9GTEwMbG1tYWJiIvjBE0DVCrq+ffuWm+0qGVz05s0bhIaGQk5Ojhs5Ll32J0+eYP78+TJxrSSSk5NhaWmJmjVrcrOgJO/HnJwcKCkpcfenrPjw4QNGjhzJWyBWssbE3bt38fLlSzx79gy2trYwNzeXuTo8wzD/LhYoZ5gqoKSkBDNnzoSWlhZatWpVrjI2efJkmJubw9/fH58/f66kUv49wcHB3FTTK1euoHbt2hgwYAAvWD5hwgSIRCJePltZkJeXhz179sDQ0BAdO3bktktGT44ePRpDhw6trOJ9s7IBbrFYjFu3buHt27dITU1Fy5YtuRGgv/32G+rWrSsTI6AqCtwfOXIESkpKcHJywocPH3jHjB49GkOGDBF8wP9bpKSkoG3btnB3d5e5RSCrOknD+8GDB7CxsUGPHj3KpaC6desWhg8fLsgAg4T0cxIWFgY7OzsMGDAAM2fOBFCaG7R3795QVFTEggULsGzZMtja2sLY2FjwgQbpc5s5cyaaNGmCVatWcR2hd+7cwfDhw6GhoQF3d3csWLAA/fr1g66uLmuUVwLJ9YqPj0eHDh0QFhbG3WNbtmypMFg+c+ZM1mnI/KcuXboEd3d3tG7dGrt37wZQ+l4cMGAAzMzM0KZNGzg7Ows2NUlZVSHoeujQIS5nNQAsXboUBgYGSE1N5bbNmTMHcnJyiI6O5rZ5e3vzBh4I/VpJiMViXL9+HW3atIGJiQnvHfj06VM0a9YMx48fr8QS/j2Szhpzc3M8evSI2/7gwQN0794dysrK0NDQQPv27dGxY0eZebYYhvnvsEA5w8igioIghYWFCA8Ph7a2NsaNG1cutYWbmxtGjx4tE8G8oqIiDBkyBJ06deIWRbx69WqFwfLFixfLZIAhPz8f8fHx0NDQQM+ePVFSUoKCggKIxWJ07NgRHh4elV3EP1X2HpT8LBlps2XLFrRv3x4ZGRkASkeXOzs7Y+bMmYIO4kmX7cuXL7x98fHxqFGjBiZMmICXL19CLBYjLy8Ppqam8PLy+t5F/c+kpKTA3NwcQ4YM4TUCmconPZ27V69e6NWrV4XrNQDCHI0n/f0JCQmBgoICfH194ebmBlVVVXTt2pUbWTh58mR06tQJ5ubmGDx4sEw1XOfMmQMVFRX8/vvv5WZyPXjwAEOHDkWdOnVgZWXFyzEsC+dW1Rw8eBA1atTAmjVrcPfuXd4+SbA8KCiIFyRjmH+D9Ds6MjISNjY23M+XL1/GqFGj0Lp1a+zatYvb/vHjR7x7906wqUkqIutB102bNqFmzZpYsWIF9316/vw5lJWVYW1tzXtvzJ07FyKRCOPGjUOnTp3QqlUrmbhGX3P9+nXo6+vDwMAAkZGRiIuLQ58+fWSi41qapLOmTp063CAQ6frIgQMHsHv3bpw4cYI7L1m+bgzD/O9YoJxhZIx0xfr27dtIS0vjKmlFRUUIDg5Ghw4d4Onpiezs7Ap/V2jB8ooCOidOnIC1tTWioqK4AElKSgrq1KmDwYMH4+HDh7zjZbFCU1BQwAXLtbW1YWNjg+HDh6Nly5Yycz5Lly7F6NGjMWHCBN4ojfXr18PQ0BAnTpxAVlYWHB0dsWDBAm6/EIN40kJCQuDi4gIXFxdcvXoVubm5AErzj9eoUQNGRkYYOHAgnJyc0KZNm3LpI2Td5cuX0a1bNy5tBPP9/NWzIR0st7W1hZ2dHbZt2/Y9ivavOX/+PMaOHcvlIgdKz0dXVxfW1tbctqysLOTm5spUUCgjIwPdu3fn0sS8evUK58+fh4eHB3bs2IHs7Gw8fvwYw4cPh62tLS83qtC+zVVdVlYWbGxsMGfOHN526dz4kjQs8+bNk6nAECNs0u/53377Db6+vhCJRLz815Jgub6+foUjroVejypLloOuU6dOhZaWFlasWMF1mqWnp0NdXR3dunXjBcvXr18Pe3t7jBo1StAdvN96/1y/fh1mZmYQiUTw9PTEnDlzuFlSQjyvikg6a4yMjGBqasoNhCm7eK6ErJwXwzD/HRYoZxgZUnZat66uLho3bgxVVVUEBgaiqKgIRUVFWLhwISwsLODt7V1uZLmQK9aLFy/G0qVLuZ+nTJkCPT09LkgJlFbYRCIRAgMDK6OI3+xbAx4FBQXYt28f2rZtCw0NDdy4cYPbJ/Sg0MKFC6GqqorBgwfDzMwMioqKuHjxIgDg3r17aNu2LTQ1NdG0aVO0adOGq5AKPRi0fPlyNGjQADNmzICBgQG0tbWxefNmruPp4MGDUFRUhJGRERITE7kK9dcq3LJKOm8+831Iv59PnjxZLlc8UPr8SJ6hO3fuoG3btpg8efJ3K+P/6sCBA2jTpg2aNGnCTcOXnPelS5egqqqKX3/9lbcdEP57Q+Ldu3dQUVFBaGgokpKSMHToUJiZmcHExATKysrcop03btzA8OHD0aVLF6xdu7aSS/1jevfuHZo1a1Yu37+E5Bu8Y8cOloqK+U9MmzYNRkZG8Pb2hqWlJerWrYuBAwdy+y9fvowxY8ZAWVkZZ86cqcSS/rmqGnSVLtOUKVPQokULrFixAm/evAHAD5ZLvyOkByoJsS4vfb02bNjwl+uaSGYatm/fngsyS2aQypLr16+jdevWaN++Pde2FOJ9xzBM5WOBcoaRQWFhYVBWVsapU6eQmJiITZs2oXr16txIlMLCQixcuBDa2tpYsmRJJZf2r4nFYjx8+JBbMHH69OnYt28fSkpKYGlpyS1sKXH//n1BVjwl/iy4I/m5bIqPuLg4tGzZEvb29tx2oVXeyjaEZsyYwTXc0tPTuXQCSUlJAEqv0549e7B161ZBT2Use15z5sxBXFwc9/PQoUOhp6eHTZs2cYs3HThwAPLy8vDx8YFYLBbctWJkj/S7ws/PD0ZGRli2bBkvdYfkmLy8PK6x+vjxY0F3gJYt29WrVzFkyBBUr14dCxcu5O179+4ddHR0uGCyrFq2bBkUFBSgoKCAadOmcWkFXFxceCNG7969CycnJ9ja2pbr1Gb+fZLn59q1a3j+/DmysrLQrl07hIWFlTv26tWrCAkJqXIdoEzlkn7Pnzx5Eg0aNMDZs2cBlOYhj4qKgoaGBgYPHswdd/78eSxatEiw9YyqHnSVrrf6+PhUGCxv1KgRrK2ty5270Dp4ExMTuX8XFxfj2bNnUFFRwdOnT3nHSa6p5NwLCwtx7do1tG7dGhYWFoJc7+rvdNbo6+ujY8eO5VIsMgzDSLBAOcPIAOmKVklJCfr161duRPWpU6cgEomwatUqAKUjlbds2SITFWuJ5cuXQ1VVFW5ubhgxYgQcHR0RFRUFS0tLLnAp/bcQYtBV2rJly+Di4gJ/f3+cOHGC2y65Jh8/fuQqp1++fEF8fDz09PTQuXPnSinvn5G+XklJSfjtt9/Qo0cPLigOAG/fvsWwYcNQt27dChdYFeK9KH0/HTlyBLt27cLPP//Ma0wAwLBhw6Cnp4fo6GgucBkfH486depgzJgxVS71ClN5QkND0bBhQ5w7d67Cxmh2djbGjBmD0NBQXiNPiMFy6TIdOHCAS+Vz//59DBs2DMbGxoiIiOCOKSgoQOvWrbFixYrvXtZ/2/3793k5/sViMaytrTFnzhzerIB79+7h5cuXlVXMH4bk771v3z40btwYQUFBAIDx48ejYcOGuHDhAu97EBAQgJ49e3I5iRnmf9G7d29eejoA2L59OzQ0NHijj7OysrBkyRKIRCK4u7tz2yX1XSHVo37UoKuXl1eFwXKRSCTo9WqCg4Ohr6+PrVu3cttSU1OhrKxc4TcoOzsbTk5O3ExRoHQmlJqaGnr06PFdyvyt/m5nzfXr19GgQQNexzXDMIw0FihnGIGT/vhLFkbU19fH9OnTAZQ2/iQjniZPnowePXqUy00upIp1WfHx8bh8+TKA0lGSXl5emDt3LlJSUjBs2DAoKSlBUVER/fr1K3deQhYaGgoVFRW4ubmhffv2aNeuHTZv3sztz8vLg5+fHxo0aIDHjx8DKA0S7dq1C23btsXz588rq+h/ys/PD7Vq1YKhoSFEIhEiIyN5+9+9e4eRI0dCJBLh1q1blVTKbyMdFJk6dSoUFRXRpEkTiEQieHh4lBvh+fPPP6N+/fo4dOgQty02NhZqampcY4lh/imxWIyPHz/CxsaGS8VR0QwUAOjSpQsGDx4suNFq0sqmCmvSpAlWrVrFTbO/c+cOhg8fDg0NDbi7u2PBggXo168fdHV1Bd8J+q155AEgJycHFy5cgIODA4yMjLhzE2LHRlV36NAh1KpVC5GRkXjx4gW3fcCAAVBRUcEvv/yCkJAQeHh4QEFBgZcKjWH+qYyMDHh5eZXrUL927RqaN2+O+Ph43va0tDQ0atQI9erVw4gRI7jtQnrf/yhB161bt8LX1xezZ8/G9u3bue0VBcszMjIE3d56/Pgx+vXrh+7duyM6OhoA8Pr1a7Rq1YpLQ1JUVMSdw+PHj2FmZoYePXrw7r3bt2+XWyeqsvzTzpqioiLcv39f0NeLYZjKxQLlDCNg0pW1JUuWYMKECUhPT8fChQuhqamJ5ORkAH9UnoOCgtCzZ89KKevfJRaLkZmZCTU1NVhbW8Pf3x8AsHnzZgwZMgSZmZkAgI0bN8LCwgJdunQRVCOhrLJBDz8/P5w8eRIAcOvWLUycOBGtWrXiKqdAaZDVy8uLV1ErKCjg0nsIgfTf/Pz582jXrh3OnDmD33//HWPHjkXt2rV5gWOgtOI9d+5cwQe7JFJSUtCnTx9cuHAB7969g7e3N0xNTbFw4UJe2gsAmDdvXrnzEtL1YmRbdnY2dHR0sHz58nL78vLykJaWxv0s1MWZy5ozZw5UVFTw+++/l3ueHjx4wKVssrKywsaNG7l9Qm3AfmseeYmEhATY2dnBxsZG0Au7VXV5eXkYOHAgAgICAJTO4rp//z7Cw8ORkJCAAQMGoG/fvjA0NISzszNu3rxZySVmqoKy7+clS5Zw91Z6ejp69uyJAQMG4Pz589wxz549w5AhQ7B27Vro6+vjyJEj37XM36IqBl3Lmj59OlRUVNC/f39YWFhAVVWVNwJ50qRJ0NbWxsKFC/H+/Xtuu9De70uWLOFmNz179gxOTk7o0qULtm3bhqtXr6JDhw5fTX3z6tUrwdY1/mlnzYULF3jbhXa9GIYRBhYoZxgZ4OfnBxUVFcTExODZs2e4evUq+vbtCzs7Oy5Y/vnzZ9jY2MDNza2SS/ttJBWu9PR0LF26FMbGxjA3N8eZM2dgaGiIUaNGccc+ffqUq6gJcRSedJlOnDiBCxcuoFevXrz0I3fv3sXEiRO5XNdlCb2itmTJEkyePLncooHjxo1DnTp1ygXLJYQeLP/1119hbW2NQYMG8a6Bj48P2rVrV2GwHBD+eTHCV9G7LDMzEyYmJvDw8Ch3zI0bNzB58mTeSCkhvg+lZWRkoHv37ti5cyeA0kb3+fPn4eHhgR07diA7OxuPHz/G8OHDYWtry3s3Cq1RDvy9PPL5+fkoKipCYWEhfv/993Ij2pjvKzc3F2ZmZvD29sb79+/h5eWFrl27Ql1dHc2bN0d4eDhyc3ORnZ3NW0CcYf6pgQMHwt3dnesgy8nJQefOnaGoqMgt/JiUlARjY2P07t0bwcHB+O2332BtbQ0XFxekp6dDVVUVy5Ytq8Sz4KuqQdeyEhMT0ahRIy69YFZWFnbu3AlFRUV4enpyx40aNQr9+/cX7Pn89ttvaN26NVxdXfHgwQMAf1w3W1tbuLu7o3r16hg9ejRGjhyJCRMmwMvLCy4uLtizZw/3/wixrvG/dNYAwr8HGYapXCxQzjACd+LECWhqapbL+bx//344OjqiTp06MDMzg5GREQwNDbkKudArAGKxmBcwePv2Lfr27QtLS0v069cPCgoK2LVrF+93hFhRk/47T5s2DXXq1IGGhgZq1KiBpUuX8o5NTU2Ft7c3lJSUcPDgwe9d1P+Jh4cHRCIRunbtWi4lybhx41CvXj1epVoWlJSUYObMmdDS0kKrVq3KdVZMnjwZ5ubm8Pf3F2QOTUZ2Sb/LHj58iMePH3PTt/ft2wc5OTksXryYe7/k5OSgd+/e6Nevn+Df7dLevXsHFRUVhIaGIikpCUOHDoWZmRlMTEygrKzMLdp548YNDB8+HF26dOHSzgjZt+SRHz16NMLCwnhBIyF+w34kW7ZsQa1atVCvXj04Oztjy5YtAEpHhlpZWbFODOZftWXLFtSoUQN+fn7cvZWeng5HR0coKytz6el+//13eHh4oEmTJtDT00OXLl2494alpSV3n1a2qhx0LWv79u3Q1dXlvb/z8/MREREBPT09pKSkcNuFHvyPiopCt27dMGTIEO66PX36FE5OTtDU1ISOjg68vb0xatQoeHh4YOzYsRg6dKhg34f/VmcNwzDMn2GBcoYRuE2bNsHAwAAfP34EwK9gPnr0CEePHsW8efOwbt06Xu41ISspKeEqlEePHkVMTAy3b8OGDRg+fDhEIhGmTp1aWUX82x4/fgxjY2NcuXIFp0+fxpQpU1CzZk1s2LCBd9zNmzexZMkSwY8gr8isWbO4vORlV4ofPHgwrK2tK6lk36aiynFhYSHCw8Ohra2NcePGlesEcHNzw+jRowXbAGJkj/S99Msvv8DIyAh6enpo1KgRIiMjkZmZibVr10IkEsHa2hq9evWCpaUljIyMZKYjVNqyZcugoKAABQUFTJs2DcePHwcAuLi48Kax3717lwu4lH0OhaKq5ZH/Ed25cwcJCQkA/rhmnp6eGDly5FeDKwzzT8XGxkJeXh6+vr5cve/ly5ewt7fnBcvz8vLw6dMnXsoIf39/aGholMu3XJmqWtC1LMn7+ty5c1BTU8OZM2d4+69fvw4FBQUutaKEEIOv0mWKjIxEly5deNftxYsX6NevH6ytrcsNTJIQWlvlR+qsYRimcrFAOcMIlKSytmbNGujp6XGBcrFYzFVcdu/eXS63n9AqNdKVEckibhJxcXFQUFBATEwML5iQkZGB2NhYmalYL1y4ECNGjOBNx3z58iUCAgKgoKBQLlguIbRr9TVlU5LUqFED0dHR5aanC7niKV2227dvIy0tDXfv3gVQ2rEUHByMDh06wNPTs9yisUIfLcTIpnnz5kFFRQXHjx/H58+f4ezsDCUlJS4P+aVLlzB9+nRMnDgRwcHBMtMRWpH79+9zI8CA0mfJ2toac+bMgVgs5p6te/fuVZhbVEiqYh75H1VqaioCAgKgqKgo+MWnGdm1e/du/PTTTxUGyxs2bMilYZG4ePEi+vfvj8aNG/NGLlemqhh0Bb5eb3369CksLCwwevRo3qK+r169gpGREU6cOPG9ivg/kf6bb9iwodx1e/bsGZe+ZPXq1ZVVzL+lqnfWMAwjDCxQzjACd/fuXcjJyeGXX37hbc/JyYGjo6OgKzbSFdA1a9Zg3bp1SE9PB1CaUqZmzZpYv349d0xFwQShV2yKioowb948VKtWDZ07d+bte/nyJQIDA1G/fn1B5Zj8mj8L5pQNltesWRNbtmwpl3ZAiMFy6fOaOXMmdHV10bhxY6iqqiIwMBBFRUUoKirCwoULYWFhAW9v73IjWoV4Xoxskb6HSkpK4ODggO3btwMoTbeipKSENWvWAMBXF32UpUCDhPTzl5OTgwsXLsDBwQFGRkbc+12oz9ePkEf+R3XlyhW4urqidevWuH79emUXh6kivva879y5s8JguaOjI0QiEZ48ecI7fsWKFbxONyGoakFX6W/T2rVr4evri9GjR+PSpUsAShdi1tPTQ//+/bFu3TokJiaiV69eaNeunSC/xRJ/9s1Zv359hdetS5cu8PT0FHSnblXtrGEYRphYoJxhZEBERATk5eUxadIkJCQk4PTp07CxsUGbNm0EH0gG/lg5fvPmzVwe3tTUVMTGxlZyyf6+iiqgnz59wvLlyyESicqNMnz16hW8vLzQs2dPmamAfvr0qcKySlcwJ0+eDJFIhCNHjnyX8v0bwsLCoKysjFOnTiExMRGbNm1C9erVufQPhYWFWLhwIbS1tbFkyZJKLi1TVc2ePRshISHQ0NBAWloaEhMTUbduXS5fd25uLgIDA/HixYtKLulfk35vnDx5Erdv3y53jPS7JCEhAXZ2drCxsflqZ4BQ/Ch55H9Uubm5OHv2LJ4/f17ZRWGqCOl3RlJSEmJjY3Hy5EnuvRETE1MuWP78+XNMnz6d+1loHWs/QtDVz88P9evXh7OzM0xNTaGqqopZs2ahsLAQp06dgqurKxQVFWFqagpra2tBf7ukz2v37t2YPXs2Vq5cyUshI7lu0ulL3rx5IxMzoKpaZw3DMMLFAuUMIwPEYjHi4+PRrFkzaGhowMDAQCYCDUBphaxRo0a8EVt5eXm8tB1CrpRJKxs4uXnzJm//okWLIBKJsGrVKt72jIwM7hyFeK7S57Vo0SL4+Pjg3r17vGMk95h0x8yyZcsE3VEj/bcuKSlBv379EBgYyDvm1KlTvGtWUFCALVu2CPqZYmSL9PO1c+dONG3aFLdv38bw4cNha2uL2rVrY+PGjdwxL1++5BamEjLp58vPzw9GRkZYtmwZsrKyyh2Tn5+PoqIiFBYW4vfff+f+JkJ9f/xoeeQZhvn3+Pn5oWXLltDT04O1tTVat27NpUmMjY1F9erVecFxCaG9D6t60BUA3r9/j0GDBnGjyAFg/vz5MDAwQGhoKIDSNsvbt2+Rnp7OnY/QrhXA/1tPnz4djRs3hr29PaysrNC+fXts3bqV279+/Xp0794dNjY2vE55oXXUAFW3s4ZhGGFjgXKGkSEZGRl4+PAh7t+/L/hAg4Svry9GjhwJoDS4HB0dDVNTU/Ts2ZMbQSl0c+bMwatXr7if/f390bRpUygoKMDIyAghISF4//49gNJAc7Vq1bgUCtKEXmGbPn061NXVER0dzY2AkpaRkYHIyEhkZGTwtgvxHpSuWEvKq6+vj+nTpwMovRaSgNbkyZPRo0ePcrnJWbCc+TedPn0a48eP52adrF69Gi1atEDfvn25Y7Kzs9G7d290795dZu6/0NBQNGzYEOfOnSuXigkoPafRo0cjLCyMt1iiEBvkZf1IeeQZhvnfrVu3Dqqqqrh48SKAPwZQxMfHc8fs3r27wkEVQlJVg67S1q9fDyUlJZiamuL+/fu8fQEBAVBVVcWHDx/K/Z4Qz0u6TKtXr0bz5s25e3DNmjWoXr06tLS0EBERwR23ZMkSTJw4UZDnI/EjdNYwDCNMLFDOMDJMaJUb6cqIWCxGSUkJvL29YW5uDj8/P1hYWMDZ2RkTJkzAhAkTYGpqitevXwu6EpOeno6ffvoJvXr1wvv37xETE4PGjRtj7969uHr1KiZMmIAOHTrAx8eHS1myePFiiEQi3grrQhcbGws1NTXeyP+srCw8fvwYX758AQAcO3YMIpFI8NMZpZ+LJUuWYMKECUhPT8fChQuhqamJ5ORkAH/cr0FBQejZs2ellJX5Mbx+/Rra2tpQUFBAcHAwgNKOmClTpsDY2BgmJiYYOHAgOnToAGNjY5mYLSQWi/Hx40fY2Nhg7dq13Dag/LepS5cuGDx4sKDf9UDVzSPPMMx/o+y7buzYsViwYAEAYP/+/ahbty4iIyMBAJ8/f8bHjx8BlKaqEmqHWlUNupaVnJwMS0tL1KxZE9euXQNQOqsQKE2lpaSkJBP1eOnvalZWFjw9PREWFgag9B5UVFTE7Nmz4erqCg0NDV4nx9e+2ULwI3TWMAwjXCxQzjDMv0K6MlJQUMClVnny5AlcXV3RoUMHLFu2jEtXEhsbiy5duvCm6QuNZPTjvXv30KJFC9jb22P58uXlFuYMCQmBkZERl3M9JycH27dvF2wjCChfeYyIiICtrS0A4M6dOwgODoampiaMjIzg5ubGXacjR44I+ryk+fn5QUVFBTExMXj27BmuXr2Kvn37ws7OjguWf/78GTY2NnBzc6vk0jJV3Y0bN6Cjo4NOnTrhypUrAEqDqvv378fUqVPh7e2NpUuXytSo5OzsbOjo6JRbmwEona4uvRidLI3uqkp55BmG+W9Iv8uuXLmCvLw8uLm5YdWqVTh48CDvnVFcXIyoqChERERwnWyA8N7zVTXoWhGxWIzr16+jTZs2MDEx4WaGAsDTp0/RrFkzHD9+vBJL+NdOnTrFdeaOHTsW/v7+ePXqFR49eoT79+9DR0eHa7PExcWhRo0aqFu3Lm+NKCF+k3+UzhqGYYSLBcoZhvlXzZ8/H7a2tujatSsOHjwIoHTkXU5ODndMQUEB7O3t4ezsLMgKGgB069YN+/fv535OTU1FixYtIBKJ4O3tXe54a2tr9OnTp9x2oTWCyoqLi8O7d+8QExODatWqwc3NDc2aNcPQoUOxfPlyhIWFQUdHB3fu3OH9ntDP68SJE9DU1MS5c+d42/fv3w9HR0fUqVMHZmZmMDIygqGhIcsrzHwXN27cgImJCdzd3XHjxo2vHifEUckVNT4zMzNhYmICDw+PcsfcuHEDkydPxtOnT//0/xCCqppHnmGY/4Z0XcHX1xdmZmZ48uQJ/P39oaOjA0VFRV56wYyMDNja2nJ5r4WoqgZd/8r169ehr68PAwMDREZGIi4uDn369IGxsbEgv8VA6d85OzsbvXr1Qrdu3dC3b1/Uq1ePV6/Ytm0bzM3N8enTJwDA8ePH4eLigsjISMGeF/BjddYwDCNcLFDOMMy/ZuXKlWjUqBFmzpyJ/v37l0vTkZWVhc2bN6NPnz68Rc+EWKEJDQ3lRpRLypmWlgYDAwMYGRnh0aNHvOPnzZsHGxsbbtqmLLh27RpatGjB5fpbunQp3N3dsXnzZjx//hxA6YyANm3acNNSZcWmTZtgYGDATXOWvscePXqEo0ePYt68eVi3bp1MjeBlZF9KSgratm0LDw8P3L59u7KL803KLmT8+PFjbh2Dffv2QU5ODosXL+YaqTk5Oejduzf69esnU4GTqppHnmGY/8arV6/Qu3dvJCYmAiitL3bs2BGNGzfGrVu3kJGRgRcvXsDOzg7m5uaCrGdU5aDrt7Yvrl+/DjMzM4hEInh6emLOnDnIy8sDIMyOa4n379+jVatWEIlECAkJ4e3buXMn1NXVcfDgQXz58gUODg6YOnUq900W4nn9qJ01DMMIjwgAiGEY5h8Qi8VUrVo17ue1a9dS48aNqV+/fkREtHjxYpo5cyatXLmSPD096ePHj+Tn50fFxcUUGRlJP/30ExUXF9NPP/1USWdQXtlzCg4OJiUlJRo5ciTVrl2b0tLSyMbGhjQ1NWnlypWkqalJcnJy1LNnT2revDn9+uuvlVj6v8/Kyork5eUpISGBiIgKCwupevXqJBaLKT8/nwYOHEh5eXl04sQJ3t9FqACQSCSitWvX0qpVq+jixYtUv359AkBisZjk5OQoNjaW2rZtS9ra2tzvlZSUkJycXCWWnPmRXLt2jcaNG0fNmzenxYsXk6amZmUX6askzxQR0Zw5cyguLo6KioooKyuL5s2bR87OzrR7927y9PSkHj16ULVq1Sg3N5eys7Pp6tWrJC8vz/s/hOrNmzfUuXNnevfuHQUEBNCMGTOopKSEpk+fTqdOnSKRSES6urr0/Plzys/Pp+TkZJKXl2fvDob5QS1btowiIyNJVVWVYmJiqHHjxkRElJ6eTjY2NlRUVEQ5OTmkpaVFJSUldO7cOUG/Mz58+ECdOnWi+/fvU3BwMPn7+3P7du3aRZMnT6bIyEjq0aMHDR48mFq2bEnh4eEkEokEeU7S9fnIyEgyAxdePQAAMGpJREFUNzcnY2Pjrx5/7do1Gj9+PAGg06dPU+3atamgoIBq1KjxvYr8t3369ImGDRtGnz9/pho1atDPP/9Mw4YNIyKiW7du0YIFC+i3336j+vXrU506dSglJUWQ32QA9PnzZ+rfvz8VFhZSvXr16MyZM5SUlERt2rQhIqLt27fTqlWrKCEhgRQVFSkhIYEiIiKod+/eNGrUKMHdfwzDyLhKC9EzDCPTpHvs9+/fj82bN6NHjx68Xn0AWLx4MeTk5LBq1SoAwJcvXwQ9mqGsMWPGoFq1atiyZQu3qGVqaiqaN28OFRUVWFpaYuDAgWjbtq2g03eUzQ8sGfl+5swZGBkZ4bfffuOOy8vLw/z582FtbQ1TU1NBj/z/mrt370JOTg6//PILb3tOTg4cHR0FvyApU/VdunQJo0aNkpnnat68eVBRUcHx48fx+fNnODs7Q0lJictDfunSJUyfPh0TJ05EcHCwTM7UqIp55BmG+W8kJydDS0sLderU4RZCl079cODAAWzevBknTpzg6rtCfmd8/PgRffr0QdeuXdGrVy9uZC8A3Lx5E4MGDYKSkhI0NTUFnbJOMrofKH1/P3v2DCoqKrw0YMAfdVrJNSksLMS1a9fQunVrWFhY4PPnz9+tzP+r169fo0+fPrCysuJdt3v37iE+Ph7btm2TiXuwqo2QZxhGdrFAOcMwf5t0pXjGjBmQl5dHu3btIBKJMH78eGRmZvKODw8Ph0gkwu7duyv8P4RIunxTpkxBjRo1EB0dzQXL7927h7Zt20JOTg5XrlyRiQooAG5hIkkD4eXLl2jbti1mzJjBOy46OhqTJk2S6YBQREQE5OXlMWnSJCQkJOD06dOwsbFBmzZtZPJ8mKpHyPk0pctUUlICBwcHrgG+b98+KCkpYc2aNQD+SE9VtqEqiw1XWc4jzzDM93Xz5k00btwYdnZ23GKQX3s3yMo7Q5aDrsHBwdDX1+flrU5NTYWysjJevnxZ7vjs7Gw4OTlxC0UCpd8ANTU19OjR47uU+d/y+PFj2Nvbo1evXti4cSOKi4vRo0cPzJ8/nztG6PdgVemsYRhG9rFAOcMw/1hycjJsbGxw4cIFZGZmYs2aNRCJRJg/fz4+fPjAO3bHjh2Cq1D/FekKpY+PT7lg+e3bt+Hk5MQFlIQY7JKuPCYnJ6NWrVowNjbG/Pnz8fDhQwDA3r17oaqqikuXLlX4fwi9Yv01YrEY8fHxaNasGTQ0NGBgYAAbG5uvBvUYpjIIvYE3e/ZshISEQENDA2lpaUhMTETdunW5hepyc3MRGBiIFy9eVHJJ/z2ymEeeYZjKce3aNaiqqsLR0ZFX9xX6u/3PyGrQ9fHjx+jXrx+6d++O6OhoAKWB/1atWiE3NxdAaXBfUvbHjx/DzMwMPXr04F2v27dvc3VkWfL48WO4uLigdevWXDBZltZOkpDlzhqGYaoGlqOcYZh/ZO3atXT69GkiIvr111+53HDr1q0jT09PmjdvHnl5eVH9+vV5vye0nORE9Ke5+qTzLk6ePJkiIiIoIiKC+vfvT3Xq1KnwOKGQzs/4+vVratSoEX369IkWLlxId+7cobNnz9KMGTNIXV2dEhMTycLCgry8vKioqIjk5eUrufT/nszMTMrKyiKxWEza2tpUrVo1Qd6HDCME0u+NXbt20fTp0+no0aMUEhJCGRkZlJSURKtWraLRo0cTEdGrV69oyJAhNHbsWBo+fHhlFv1fJUt55BmG+W+UXbfma65fv052dnZkYWFBUVFRpKys/B1K99968uQJTZs2jVJTUyk/P5/q1KlDV69eperVq1d20cpZunQp9enTh/T09Oj58+c0adIk+vDhA40dO5b09fVp4sSJdObMmQrzjb9+/ZrU1NSoWrVqgsvd/U+8fv2arl69Sm/fvqWff/5ZkOtBfYsnT56Qt7c3FRYW0pAhQ+jnn38mGxsbsrKyoqCgICISZtuLYZiqgQXKGYb5R1auXEkzZsygRo0a0aFDh6h169bcvvXr15OXlxdNnTqVZs+eTXXr1q3Ekv456UZQVlYW1atXr1wlWboiNmXKFFqxYgUdOnSI+vTp893L+62kz2vBggV0/PhxCg8Ppw4dOhARUX5+PkVHR9Px48cpLS2N0tLSqHXr1nTt2jVBNoL+Td/a8GWYH9mZM2do586dpKenRz4+PrRmzRoKDw8nIyMjOnDgABER5eTk0ODBg7kFf6tag/Xy5cu0fv16ioqKYu8MhvnBSNcVbt26Rerq6qSiovLV469fv05t27YlPz8/CgkJ+V7F/E/JQtD1xIkTNGnSJDIxMaF58+aRjo4OFyzPz8+npk2b0tatW2n48OFUXFxMderUITk5OXr16hUNHTqU+vfvT0RVt24oy8FkWeqsYRimamGBcoZh/rEdO3bQ1KlTadiwYeTt7c0bcRceHk779u2jc+fOCXZ0hnSlODg4mN6+fUsTJkygVq1accdIKpjSDYPly5eTl5eXoBoKX+Pv709bt26l1atXk6mpKWlpafH2v337ljIyMigsLIxOnz5Nvr6+NGnSpEoqLcMwQvDmzRvq3LkzvXv3jgICAmjGjBlUUlJC06dPp1OnTpFIJCJdXV16/vw55efnU3JyMsnLy8t0g/xrJCMMq2oQhWGY8qRHFgcGBtLx48dp1qxZ1KtXL6pduzYR/VGHlH43PHz4kDQ1Navce1BCqO/4jRs30rZt26hRo0Y0f/580tHRoWfPnpGPjw/dvHmT5OTkqHfv3vT582f66aefSCQS0efPn2nLli0yUZf/kclCZw3DMFUPC5QzDPO3STcKNmzYQPPmzaOhQ4fSxIkTqUWLFtxxkoaG0Kcy+vn50bZt2yg4OJh69+5NampqvP2ZmZkUHx9P/fr1o4YNG3LbhV5RO3PmDI0aNYpiYmKoY8eOVFxcTNnZ2XTz5k1q27Yt1atXjzs2Pz+fJkyYQB8/fqT4+PjKKzTDMIJw8+ZN6t+/P6mqqtLKlSupXbt2VFJSQocPH6YzZ85QUVERaWpqkre3d5VvuAr9G8YwzH9j/vz5tHr1atq6dSu1b9+eGjRowNuflZVFkyZNounTp5OhoSG3XagB5apGuj0SFRVFW7duJQ0NDS5Ynp6eTt7e3pSTk0Njx46lQYMGlfs/2LWSLex6MQzzPbBAOcMwX/VnwYGywfL58+fTsGHDyN3dnXR0dL7p/xCCPXv2kJeXFx0/fpyMjY2JiCg7O5vev39PampqVLt2bTp+/Dj17t2bVq1aRZ6enpVc4m+3Z88emj59Oj158oRu3bpFu3fvpp07d9KTJ0/Izs6Ofv31V1JQUOACXElJSTR06FBKSkridXgwDPNjunnzJv38889kZmZG3t7e1KZNmwqPYw1XhmGqEgD05s0bsre3J19fXxo2bBhvn6ReK5l9Y2JiQnv27Kms4v7QpL8/kZGRtG3bNl6w/Pnz5+Tj40OfPn2iAQMGyFQ9nmEYhqkcbA4pwzAVEovFXEPgxYsXlJ+fz9svmW5KRDR27FiaPXs2hYeH0/Hjx3nHCS1ILimzxIcPH8jExISMjY3p7t27FBISQiYmJuTk5ESenp6UnZ1Ntra2dPjwYRo3blwllfqfadeuHRUXF5OJiQn16tWLXr9+TbNnz6Zbt27RkSNH6Pz580RE3CjQw4cPU82aNUlRUbEyi80wjEC0adOGNm3aRCkpKbR69Wq6c+dOhcexIDnDMFWJSCSivLw8evHiBWlraxPRH/VHkUhERUVF9ObNG1JXV6czZ87Qrl27KrO4Pxzpurz098fDw4OGDRtGL1++pFmzZtHDhw+pWbNmtGLFCiopKaHU1FRiYwQZhmGYv8JGlDMMU470aPG5c+fSnTt3yNvbmzp16sRVSCUjOIqKikheXp6IiPbv308ODg4yETTZt28fde7cmU6cOEHDhw+nkSNH0qlTp6hz585kbm5ORUVFFBERQfv37yd9fX3u92QpvUBxcTFdu3aN9u7dSx06dKBu3bpRgwYNuOB/aGgode3alRsd5e7uTuPHjyczM7PKLjrDMAJy7do1GjduHDVv3pwWL17MW4+CYRhG1lU0+zE7O5t0dHRo0qRJFBQURER/1H3PnTtHqampNGLECKpZsyZvH/Pfkm6jxMbG0u3bt6lhw4ZkbGxMXbt2JSKiiIgI2rFjBzVp0oRb4PPt27ekoqJC1apVE/xsV4ZhGKZysUA5wzBfNWPGDIqOjqY1a9ZQt27dSEVFhbf//fv3tHTpUnJyciJzc3Nuu9AbC9evXydnZ2fasmULde3alZYtW0Z3796lzp07U48ePahp06b09OlTcnJyoi1btpCJiUllF/lfUVhYSNnZ2TRq1CjKyMig8+fPk5ycHGswMAzzly5fvkzr16+nqKgotqglwzBVhnTgtbi4mIj+mGk3c+ZMOnLkCE2aNInGjBlDRKV13D59+pCKigpt27aN1Z++I+n6qp+fH+3YsYNMTU0pNzeXPn/+TN7e3jRixAgiKg2W79y5k6pXr04bN26kJk2aEBGxhZkZhmGYv8QC5QzDVOjEiRM0atQoio+P51J4ZGRk0IMHD0hHR4caN25Mjx8/Jh0dHfLx8aFly5ZVdpH/FisrK5KXl6eEhAQiKg0iV69encRiMeXn59PAgQMpLy+PTpw4IdgKdUUB7q8FvQsLC2nXrl0UGRlJBQUFdO7cOZKXlxd8pwbDMMIheb+wQAPDMFWB9LtsyZIldOXKFbp//z65urqSvb09NWzYkGbOnEknT54kCwsLUlVVpatXr9KnT58oJSWF5OXl2WCD70T6Wq1Zs4bCwsJo586d1LFjR1q7di1NmTKFmjRpQv7+/jR27FgiIlq6dCk9evSIVq1axb5ZDMMwzDdjgXKGYSr022+/UUBAAO3Zs4eys7Pp119/pV9//ZXk5ORIUVGRdu/eTdra2vT48WNq1qyZYNORSCrWkoaMJCB+9uxZ8vLyoqVLl1LPnj1JLBZTYWEhhYeH0+nTp+nDhw906dIlkpeXF2RQSLpMGRkZVFhYSBoaGrz9ALggeFFRESUmJtKtW7fIx8eHfvrpJ5lKI8MwjDCwoBDDMFXNzJkzacOGDTRp0iR69OgR3bt3j6pXr04rV66kVq1aUVxcHEVFRVHDhg1JQ0ODli5dyupR35H0dyc7O5sCAgKoRYsWNG3aNDpw4ACNHDmSfHx86MGDB3T27FkKDg7mRpazDl6GYRjm72KBcoZhKqw8JiYm0ogRI0hfX5+uXLlCzs7O1LVrV1JXVydvb29atWoV2dracscLvbGQkJBANjY23Lm+evWK+vbtSzY2NhQcHMwdt3nzZrp27RotWbJEJhpBQUFBtH//fnrx4gVZWVmRi4sL1zggIsrMzKT9+/eTo6MjL3UOG0nOMAzDMMyP7tatWzRw4EBat24dWVlZEVFpHTgiIoIyMzNp8+bNXNoOaUKvH1YViYmJ9OrVKxo2bBiNGzeOlJSUyMfHh/Ly8rg0OJ6enjR58mTat28fubq6kry8PEVHR9OAAQOIiHXwMgzDMH8P+7ozzA9OOkienp5OBQUFpK2tTVZWVrR9+3a6fPkyTZgwgaysrKh+/fqUlZVFtWvXLlfhFFpjQbpSfOXKFerXrx+1bNmSBgwYQK6urqStrU2BgYE0YcIEcnZ25nKsu7m5kZubGxGVBpOFdl7S12vt2rUUFRVFixYtIgUFBYqKiqKIiAh6/fo1+fn5ERHRxYsXycPDgwoKCmjixInc/8OC5AzDMAzD/GjKDg4pLi6mt2/f8up7VlZWVFBQQOPHj6dHjx5RkyZNygVbhVY/rGoA0OfPnyk4OJhLH3jmzBlKSkqiRo0aERHR9u3bqUGDBjRq1CgiIqpTpw7Z29tT7969ydnZmfu/WJCcYRiG+TvY/COG+YEB4BoLs2bNIltbW7K0tCQtLS2KiIggY2Nj8vPzI2dnZ6pduzZ9+PCBhg4dSrVr1yZra+tKLv3XicVirlL8+vVrMjMzo1evXlGvXr3owoULZGxsTAsWLKAPHz5Qz5496fLly0RUmp5EmhCDyZLrlZSURDk5ORQaGkqjR4+mgQMHUkxMDLVt25bi4uIoKSmJiIj69u1Le/fu5fI1MgzDMAzD/Iikg+RxcXH07NkzUlRUJDU1NXr27BkRldaNiYjs7OyoRo0aXH2KBVu/L5FIRAoKCrRz50568+YNHTp0iAICAqhNmzbcMfLy8vT8+XNKSkqi3NxcWrVqFbVo0YLGjBlDcnJyVFJSUolnwDAMw8gq1hXOMD8wSaU/NDSU1q9fT2vXriUNDQ3avn07rVixgl69ekVeXl6krKxMoaGhdObMGcrJyaFz585xFVChBZOlG0ELFiyg48ePU3h4OHXo0IHCwsIoPz+foqOj6fjx45SWlkZpaWl0/fp1Gjt2LFWvXr2SS/9t7t+/T926dSMiopCQECIqbdgpKyvTokWLyNTUlA4dOkRdunQhIuJG1bBpwgzDMAzD/IikB4cEBATQ1q1bacaMGeTl5UUdO3YkX19f0tLSIgsLCyIi+vjxI9WuXZuaNm1amcX+4VWrVo20tbVJTU2NTp48SU2aNKFhw4YREZG+vj517dqVRo4cSfXr16c6depQXFwciUQi3jo9DMMwDPN3sBzlDPMDA0Bfvnwhe3t7cnR0JF9fX27fggULuFQetra2lJCQQFeuXCE/Pz+ZyN3t7+9PW7dupdWrV5OpqSlpaWnx9r99+5YyMjIoLCyMTp8+Tb6+vjRp0qRKKu2fqyi34tGjR2nYsGHUtWtXio6Opvr163PHjBkzhnJzcykmJoaNgGIYhmEYhvl/8+fPp5UrV9KRI0dIV1eX6tevT0REgwcPpjNnztDQoUOpYcOGdPr0aXrz5g2lpKQIur77o3jz5g2NGTOG8vLyaMyYMVywPC0tje7du0c5OTnk6upKcnJygm+jMAzDMMLGUq8wzA9MJBJRtWrVKCcnhwuoFhQUEFHpIpF6enq0fPlyIiKysbGhgIAA+umnnwSZu1vamTNnKDY2lvbt20f9+/enZs2a0YcPH+j06dOUnZ1NRERqampkaGhIERER1KNHDzp16lQll7pi0mlkcnNzue29e/em6OhoOnbsGAUGBtLr168JAOXn59O1a9eoYcOGLEjOMAzDMAzz/z58+EBnz56l5cuXU/v27enLly+UmJhI48aNo/79+5O1tTU9efKEDh8+TI0aNaKrV69y9V6mcqmrq9Pq1aupdu3atGXLFtq0aROVlJTQxIkT6datWzR8+HButquQ2ygMwzCM8LER5QzDkIuLCz19+pRSUlKIqDRXt7y8PE2bNo2ePXtGsbGxlVzCv2fPnj00ffp0evLkCd26dYt2795NO3fupCdPnpCdnR39+uuvpKCgwI04SUpKoqFDh1JSUhK1aNGisotfodDQUC6XemBgILVu3Zpq1apF+/btI1dXV2rZsiXp6elRYWEhPXnyhJKTk2UmlQzDMAzDMMx/7ePHj2RoaEijRo0iGxsbWrt2LT158oRKSkrozZs3FBQUxC2AXrt2bSJiaeuE5smTJzRt2jRKTU2l/Px8qlOnDl29epXVeRmGYZh/DRtRzjA/MLFYTESlea4/fvxIvXv35rYBoMuXL1PDhg0rs4j/SLt27ai4uJhMTEyoV69e9Pr1a5o9ezbdunWLjhw5QufPnyci4ho+hw8fppo1a5KiomJlFvurVqxYQYsXL6aWLVtSWloaDRo0iHbv3k05OTnk7OxMe/bsoefPn9O9e/do8uTJlJKSQtWrVy+3OCnDMAzDMMyPSklJiebNm0dr166lvn37UvPmzWnhwoV05coV6tatG128eJHk5OS4IDkAFiQXGE1NTVq9ejUtXryYAgMD6dq1a1S9enUqLi6u7KIxDMMwVQT78jPMD0yyqJG2tjZt2LCBJkyYQNra2qSpqUmfP3+mL1++0KpVqyq5lH9f06ZNKS4ujvbu3UsdOnSgbt26UYMGDSg7O5s6dOjAawCJRCLKzMykX3/9lZSUlCq55KWkFyQlIvr06RNFRUWRs7MzBQcH07BhwygkJITEYjENHDiQHBwcaNu2bdS/f3+Kj4+nbt26UUlJCcnLy1fiWTAMwzAMwwjLmDFjqFevXlRQUEC6urpEVFrvevv2LXXs2JF3LEthJ0yNGjUiBwcH7meWboVhGIb5N7HUKwxTxVW0EGRF24hKp6SuXLmSioqKqHbt2jKzcOdfKSwspOzsbBo1ahRlZGTQ+fPnSU5O7qt/h8okXaajR49STk4OHTlyhNzc3Kh79+7cccOHD6erV6+Sv78/ubi4UL169Wj//v00bNgwGjJkCK1du5ZNQ2UYhmEYhvmKz58/0/Xr1yk0NJSePXvGFu5kGIZhGIYFyhmmKpMemZyRkUGFhYWkoaHB2w+A5OTkyo1iligpKSE5ObnvVuZv8XeC/4WFhbRr1y6KjIykgoICOnfuHMnLywv+vHx9fWnjxo2koKBAL1++JHd3dwoLC+Olh3Fzc6P9+/fT9u3byd7enohK87N7eXnRjRs3SE1NrVLOg2EYhmEYRsgA0JkzZ2jJkiVUVFREBw8eFGz9kGEYhmGY74flKGeYKkwS+A4KCqIePXqQgYEBOTs707Zt27j9cnJylJmZSZs3b6YXL16U+z+E1lgQi8VcMDkjI4NevnxJRH9MjxWLxVRSUsIdLxKJSE1NjZycnOj8+fMkLy9PxcXFgjsvoj/O4dq1a3Tv3j06evQopaSkkJeXF125coXWrFlD2dnZ3PGbN2+mqVOnkq2tLbdtwIAB9PDhQxYkZxiGYRiG+QqRSEQWFhY0b948OnLkiKDrhwzDMAzDfD9sRDnDVEHSo8PXrl1L8+bNo0WLFpGCggJFRUXRly9fyNHRkfz8/IiI6ODBg+Tk5ESrV6+miRMnVmbRv1lQUBDt37+fXrx4QVZWVuTi4kIjRozg9mdmZtL+/fvJ0dGRVFRUuO1CHym0c+dOioqKImVlZYqJieHKOnnyZDp37hy5uLiQl5cX1atXj/d7sp4eh2EYhmEYprJ8bWYlwzAMwzA/FlYbYJgqSFLRT0pKopycHAoNDaXRo0fTwIEDKSYmhtq2bUtxcXGUlJRERER9+/alvXv30tixYyuz2H9KLBZz/167di1FRUXRlClTKDIyknJzcykiIoIWL17MHXPx4kXy8PCg2NhY3v8j5CC5WCymmzdv0pMnT+jGjRu8fcuXL6cuXbrQ/v37adGiRfTlyxfefhYkZxiGYRiG+WdYkJxhGIZhGCI2opxhqqz79++Tnp4eERGFhISQn58flwP78+fPZGpqSi4uLhQaGsr7PaGPTE5KSqILFy6Quro6/fzzz0RE9P79e5o7dy5dvnyZwsLCqEuXLkREtG/fPurbt69gz6ei0UtFRUW0cuVKWrduHfXs2ZNCQ0N5eclHjRpF1apVo6ioKMEtRMowDMMwDMMwDMMwDCOrWNc5w1QRZfu8WrZsSYcPH6b69evThQsX6OPHj9y+unXrUteuXen58+flfk+oQWWi0uB/t27daObMmfT27VsiKj1vZWVlWrRoEb1//54OHTrEHe/s7Ew//fQTFRcXV1aRv0o6SH7nzh26f/8+paamkry8PPn4+JC7uztdv36dAgMDKScnh/u96OhoioyMJJFIVO7aMQzDMAzDMAzDMAzDMP8MC5QzTBUgvcBlbm4ut713794UHR1Nx44do8DAQHr9+jUBoPz8fLp27Ro1bNhQ0KOSq2rwHwAXJA8ICCBnZ2eysrKi7t27U1BQEBERTZs2jRwdHSklJYUCAwMpKyuL+/1q1arxrjnDMAzDMAzDMAzDMAzzvxFW9IhhmH9EEnQNDQ2ly5cvExFRYGAgtW7dmpycnOjXX38lV1dXOnfuHOnp6VFhYSGVlJTQkiVLKrPYf0p6xHVubi7Vrl2biP4I/g8ePJgCAwMpKCiIGjVqRAUFBXTt2jWytLQUfABZUr7w8HDasGEDxcbGkkgkoidPntD48ePpzZs3FBUVRdOnTyciok2bNlGLFi1o6tSp3P/BcmkyDMMwDMMwDMMwDMP8e1iOcoapIlasWEHz5s2jsWPH0sGDByk/P59mzZpFLi4upKCgQIcOHaLhw4dTs2bNaOXKldSlSxeSk5OjoqIikpeXr+zif1VFwf9atWrRvn37yNXVlVq2bMkF/588eULJyclUvXr1Si51xSQ54olKOwL69+9PBgYGtGDBAu6YxMREsra2ppUrV5KXlxcVFhbSzp07adiwYYJeiJRhGIZhGIZhGIZhGEaWsSGJDCOjxGIx7+dPnz5RVFQUBQcH0+3bt6lDhw4UEhJCe/bsoc+fP5ODgwNt27aN7t27R/Hx8VStWjUqKSkRdJB8xYoVtHjxYmrZsiWlpaXRoEGDaPfu3ZSTk0POzs60Z88eev78Od27d48mT55MKSkpVL16dSoqKqrsopcjnSolMzOTqlWrRvfv36fCwkIiKg2iFxUVkZWVFfn4+NC+ffsoJyeHqlevTiNHjiQ5OTkqKSmpzFNgGIZhGIZhGIZhGIapslignGFkkHSO66NHj9Lu3bvpyZMnpKSkxB2zY8cOateuHS1evJj27NlD2dnZ1LdvX4qNjaWoqCjy8PAQXOC1qgb/pdPILF26lGbPnk0vX76kYcOG0Z49e+jKlSskEom4XOp169alatWqkYKCAu//YSPKGYZhGIZhGIZhGIZh/hssUM4wMkY6fYevry+5urqSr68vbd26lWJiYniLPm7fvp06dOhAU6ZMoaSkJCIicnJyos2bN9OhQ4d4i2FWtqoa/Cf6I5+4v78/hYSEUJcuXaikpITs7OzI0NCQZs2axQXLv3z5QpcvX6YmTZpUcqkZhmEYhmEYhmEYhmF+HCxHOcPIqGvXrlFQUBAFBQWRjo4OzZ8/n86dO0cDBgwgLy8vqlevHnfs/PnzaebMmdyIZSKiz58/U926dSuj6OWUDf5v3LiRFBQU6OXLl+Tu7k5hYWGkqKjIHe/m5kb79++n7du3k729PRER7dmzh7y8vOjGjRukpqZWKefxZ06ePEkeHh60bds2srS05LYfOHCANm7cSCdPnqTWrVtTQUEBAaCUlBSSl5fn/W0YhmEYhmEYhmEYhmGY/wYLlDOMDNq5cydFRUWRsrIyxcTEcCk5Jk+eTOfOnSMXF5dywXIiouLiYl6wXGiqUvC/rOjoaFqyZAmdO3eO6tevz0vH8vjxY7p//z4lJyeTiooKubu7008//ST468UwDMMwDMMwDMMwDFNVsAgMw8gYsVhMN2/epCdPnlB6ejpv3/Lly2nKlCm0f/9+ys7OplmzZlGdOnW4/UIOukoH/83NzUlOTo5WrlxJkydPpri4OCIiXrB81qxZRMQP/gsxSC4ZEZ6Xl8dLCyMSiaikpITk5OTo6tWr1LZtW7Kzs+P2l5SUCPp6MQzDMAzDMAzDMAzDVCUsRznDCFzZBS6rVatGc+fOpYkTJ1JxcTF5enry8pIvW7aM9PX1KSMjg2rXrv29i/uPSAf/b9y4wdu3fPly6tKlC+3fv58WLVpEX7584e0XejBZkjbFysqKHjx4QMuXL+e2y8nJ0efPn2n79u107Ngx3u+xhTsZhmEYhmEYhmEYhmG+H5Z6hWEETDo9x507d0heXp5KSkqodevWVFxcTOHh4RQfH09mZmYUHBxMCgoK5X5XiDmupc9LoqioiFauXEnr1q2jnj17UmhoKC8v+ahRo6hatWoUFRUluPP5Vhs2bCAvLy+aMGECOTg4UPXq1WnRokX05s0bunr1quCD/gzDMAzDMAzDMAzDMFUVC5QzjEBJB7gDAgJoz5499OXLFyouLiYPDw+aM2cOEREtXryYDh06RGZmZjR//nxecLmigHRlq6rB/28BgA4cOECTJk2ikpISql+/PmloaNChQ4e4vwMbSc4wDMMwDMMwDMMwDPP9sUA5wwhceHg4hYSEUGxsLIlEInry5AmNHz+eRowYQVFRUVRUVERhYWG0adMmmjhxIk2dOrWyi/xVVTX4/3dlZmZSVlYWicVi0tbWpmrVqrGFOxmGYRiGYRiGYRiGYSoRi8owjMBIB5PFYjGdP3+exo8fT1ZWVkRE1L17d2rRogVZW1uTiYkJeXl50bRp06hJkyY0bNiwyiz6X5KcV3h4OG3YsKFc8P/NmzcUFRVF06dPJyKiTZs2UYsWLXjBf1kPkhMRNWzYkBo2bMj9LBaLWZCcYRiGYRiGYRiGYRimErER5QwjINKjpTMzM6lhw4ZkYGBA9vb2tHjxYgJAxcXFJC8vT1OmTKGbN29SfHw8Lz2JENN3lA3+9+/fnwwMDGjBggXcMYmJiWRtbU0rV64kLy8vKiwspJ07d9KwYcMEdz4MwzAMwzAMwzD/1979x1RZ/n8cf53D4YBIJSMgERQkKSY1J/ZL/IFpYgfyj2oOp6U26shUcNWyOaUSprVScYkCrkWhm0ELbYw0SGzqH5aILZkM5rAfulIaoiFCnHN//3Ccr0fwV/kBPOf52Ni4r/u6r/t9/cdeXHvfAADPcvcfzQQ8xNUh+YYNG5Sdna3Tp09r3rx5+vLLL3XkyBGZTCbXyePAwECZzWa3kFzSoAuVnU6nKyRvaWmR2WxWY2Ojurq6JF0J0f/55x9NmzZNWVlZKi8v18WLF2W1WvXyyy/Lx8dHDodjILcAAAAAAAAAD0dQDgwSPSH5ihUr9P7772vy5MlyOByaNWuW4uPjtXr1aldY3t7erh9++EEREREDXPWNeWr4DwAAAAAAAM9CUA4MIt99953KyspUXl6uuXPnauTIkRo/frzS09NltVqVlJSkxx57TE899ZTOnDmjoqIiSVdOZQ9Gnhj+AwAAAAAAwPPw9ThgEPn1118VEBCgsWPHSvr/E9mzZ89WfHy8Ghsb9eOPPyokJETp6emyWCzq7u4e1B+CvDr8T0xMlCSNHDlS6enp+uSTT5SUlKS4uDh1dnbKMAxVVFRIcu9rDgAAAAAAAPwvDd50DfAiPaFwR0eHWz9uk8nk+jhnbW2txo8fr1mzZrnuOxyOQR2SS54Z/gMAAAAAAMCz0HoFGAR6Tk5PmzZNTU1NysvLc437+Pjo77//1vbt27Vnzx635wZz7+6edjDXC/8lqba2VmPGjNHq1au1ePFiWSyWuyL8BwAAAAAAgGchKAcGkbi4OG3ZskVr165VVlaWqqqq9P333+uFF17QqVOnZLfbB7rEW+aJ4T8AAAAAAAA8k8kYrF8BBLyUYRj6+uuvlZmZKYfDoWHDhmnEiBGqqKiQr6+vqxXL3aSoqEhLly5VRkaGUlNTZbVatXbtWv3xxx+qra3lBDkAAAAAAAAGFEE5MEi1tLSora1NTqdTMTExMpvNd23vbk8M/wEAAAAAAOA5CMqBu0TPRzDvZp4U/gMAAAAAAMBzEJQDGDCeEP4DAAAAAADg7kdQDgAAAAAAAADwahzlBAAAAAAAAAB4NYJyAAAAAAAAAIBXIygHAAAAAAAAAHg1gnIAAAAAAAAAgFcjKAcAAAAAAAAAeDWCcgAAAAAAAACAVyMoBwAAAAAAAAB4NYJyAAAAYABFRUVp4cKFruv9+/fLZDJp//79A1bTta6tsT8kJSUpPj7+jq45EPsAAADA3YGgHAAAAF6ruLhYJpPJ9ePv76/Y2FgtXbpUf/7550CXd1sqKyv17rvvDmgNJpNJS5cuHdAaAAAAgH/DMtAFAAAAAANtzZo1io6O1uXLl3Xw4EFt3bpVlZWVOn78uAICAvq1lilTpqijo0NWq/W2nqusrFR+fv6Ah+UAAADA3YigHAAAAF7v2Wef1YQJEyRJ6enpCg4O1oYNG7R7927NnTu3z2fa29s1dOjQO16L2WyWv7//HV8XAAAAwPXRegUAAAC4xtNPPy1Jam5uliQtXLhQgYGBOnnypGw2m+655x7NmzdPkuR0OpWXl6exY8fK399fYWFhstvtam1tdVvTMAzl5uYqIiJCAQEBmjZtmurr63u9+3o9yg8fPiybzaagoCANHTpUjz76qDZt2uSqLz8/X5LcWsn0uNM1/he7d+9WSkqKwsPD5efnp5iYGOXk5MjhcPQ5v7a2VhMnTtSQIUMUHR2tgoKCXnM6Ozv1zjvv6MEHH5Sfn58iIyP11ltvqbOz847WDgAAAM/FiXIAAADgGidPnpQkBQcHu8a6u7uVnJysSZMm6aOPPnK1ZLHb7SouLtaiRYuUmZmp5uZmbd68WXV1dTp06JB8fX0lSdnZ2crNzZXNZpPNZtPRo0c1c+ZMdXV13bSeqqoqpaamavjw4crKytIDDzygEydOqKKiQllZWbLb7Tpz5oyqqqpUUlLS6/n+qPFWFRcXKzAwUK+//roCAwO1b98+ZWdn68KFC/rwww/d5ra2tspms2nOnDmaO3euSktLlZGRIavVqldeeUXSlX8CzJ49WwcPHtRrr72muLg4/fzzz9q4caMaGxu1a9euO1Y7AAAAPJgBAAAAeKlPP/3UkGRUV1cb586dM3777Tdj586dRnBwsDFkyBDj999/NwzDMBYsWGBIMt5++2235w8cOGBIMnbs2OE2vmfPHrfxs2fPGlar1UhJSTGcTqdr3sqVKw1JxoIFC1xjNTU1hiSjpqbGMAzD6O7uNqKjo41Ro0YZra2tbu+5eq0lS5YYff15/7+o8XokGUuWLLnhnEuXLvUas9vtRkBAgHH58mXX2NSpUw1Jxvr1611jnZ2dxrhx44zQ0FCjq6vLMAzDKCkpMcxms3HgwAG3NQsKCgxJxqFDh1xjo0aNuqV9AAAAwPvQegUAAABeb8aMGQoJCVFkZKTS0tIUGBio8vJyjRgxwm1eRkaG23VZWZnuu+8+PfPMM2ppaXH9JCQkKDAwUDU1NZKk6upqdXV1admyZW4tUZYvX37T2urq6tTc3Kzly5dr2LBhbveuXut6+qPG2zFkyBDX7xcvXlRLS4smT56sS5cuqaGhwW2uxWKR3W53XVutVtntdp09e1a1tbWu/cXFxenhhx92219P+5ye/QEAAAA3QusVAAAAeL38/HzFxsbKYrEoLCxMDz30kMxm9zMlFotFERERbmNNTU1qa2tTaGhon+uePXtWkvTLL79IksaMGeN2PyQkREFBQTesracNTHx8/K1vqJ9rvB319fVatWqV9u3bpwsXLrjda2trc7sODw/v9cHU2NhYSdKpU6f05JNPqqmpSSdOnFBISEif7+vZHwAAAHAjBOUAAADweo8//rgmTJhwwzl+fn69wnOn06nQ0FDt2LGjz2euF972p8FU4/nz5zV16lTde++9WrNmjWJiYuTv76+jR49qxYoVcjqdt72m0+nUI488og0bNvR5PzIy8r+WDQAAAC9AUA4AAAD8SzExMaqurlZiYqJbS5FrjRo1StKV092jR492jZ87d06tra03fYckHT9+XDNmzLjuvOu1YemPGm/V/v379ddff+mrr77SlClTXOPNzc19zj9z5oza29vdTpU3NjZKkqKioiRd2d9PP/2k6dOn31IrGgAAAKAv9CgHAAAA/qU5c+bI4XAoJyen173u7m6dP39e0pUe6L6+vvr4449lGIZrTl5e3k3fMX78eEVHRysvL8+1Xo+r1+oJk6+d0x813iofH59edXd1dWnLli19zu/u7lZhYaHb3MLCQoWEhCghIUHSlf2dPn1a27Zt6/V8R0eH2tvb71j9AAAA8FycKAcAAAD+palTp8put2vdunU6duyYZs6cKV9fXzU1NamsrEybNm3Siy++qJCQEL355ptat26dUlNTZbPZVFdXp2+++Ub333//Dd9hNpu1detWPffccxo3bpwWLVqk4cOHq6GhQfX19dq7d68kuYLjzMxMJScny8fHR2lpaf1S49WOHDmi3NzcXuNJSUmaOHGigoKCtGDBAmVmZspkMqmkpMQtOL9aeHi4PvjgA506dUqxsbH64osvdOzYMRUVFcnX11eS9NJLL6m0tFSLFy9WTU2NEhMT5XA41NDQoNLSUu3du/embXUAAAAAgnIAAADgPygoKFBCQoIKCwu1cuVKWSwWRUVFaf78+UpMTHTNy83Nlb+/vwoKClRTU6MnnnhC3377rVJSUm76juTkZNXU1Oi9997T+vXr5XQ6FRMTo1dffdU15/nnn9eyZcu0c+dObd++XYZhKC0trd9q7HH48GEdPny413hOTo4mTZqkiooKvfHGG1q1apWCgoI0f/58TZ8+XcnJyb2eCQoK0meffaZly5Zp27ZtCgsL0+bNm932bTabtWvXLm3cuFGff/65ysvLFRAQoNGjRysrK8v18U8AAADgRkzG9Y5vAAAAAAAAAADgBehRDgAAAAAAAADwagTlAAAAAAAAAACvRlAOAAAAAAAAAPBqBOUAAAAAAAAAAK9GUA4AAAAAAAAA8GoE5QAAAAAAAAAAr0ZQDgAAAAAAAADwagTlAAAAAAAAAACvRlAOAAAAAAAAAPBqBOUAAAAAAAAAAK9GUA4AAAAAAAAA8GoE5QAAAAAAAAAAr0ZQDgAAAAAAAADwav8HTb89DGyfc9MAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Confusion matrix saved to /home/user/confusion_matrix_baseline.png\n" + ] + } + ], + "source": [ + "# Plot confusion matrix\n", + "plot_confusion_matrix(\n", + " true_labels,\n", + " predicted_labels,\n", + " test_data.target_names,\n", + " title='Confusion Matrix - FastText Baseline Model',\n", + " save_path='/home/user/confusion_matrix_baseline.png',\n", + " cmap='Blues'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "bbadd108-9bd4-40eb-a3cc-498f611c91cc", + "metadata": {}, + "source": [ + "## Step 6: Hyperparameter Tuning\n", + "\n", + "We experiment with different hyperparameters to improve model performance.\n", + "We test different combinations of epochs, learning rate, and word n-grams." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7181baf4-1296-466b-8f9a-30e20e010e22", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=10, lr=0.1, ngrams=1 → F1: 0.3225\n", + "epoch=25, lr=0.5, ngrams=2 → F1: 0.6013\n", + "epoch=50, lr=0.5, ngrams=2 → F1: 0.6155\n", + "epoch=50, lr=1.0, ngrams=3 → F1: 0.5781\n", + "epoch=75, lr=0.5, ngrams=2 → F1: 0.6212\n", + "\n", + "Best configuration: {'epoch': 75, 'lr': 0.5, 'wordNgrams': 2, 'minCount': 2, 'f1': 0.6212}\n" + ] + } + ], + "source": [ + "# Hyperparameter tuning experiments\n", + "configs = [\n", + " {\"epoch\": 10, \"lr\": 0.1, \"wordNgrams\": 1, \"minCount\": 1},\n", + " {\"epoch\": 25, \"lr\": 0.5, \"wordNgrams\": 2, \"minCount\": 1},\n", + " {\"epoch\": 50, \"lr\": 0.5, \"wordNgrams\": 2, \"minCount\": 1},\n", + " {\"epoch\": 50, \"lr\": 1.0, \"wordNgrams\": 3, \"minCount\": 1},\n", + " {\"epoch\": 75, \"lr\": 0.5, \"wordNgrams\": 2, \"minCount\": 2},\n", + "]\n", + "\n", + "results_list = []\n", + "for config in configs:\n", + " m, t = train_fasttext_model(\n", + " '/tmp/train.txt',\n", + " epoch=config[\"epoch\"],\n", + " lr=config[\"lr\"],\n", + " word_ngrams=config[\"wordNgrams\"],\n", + " min_count=config[\"minCount\"],\n", + " verbose=0\n", + " )\n", + " r = evaluate_model(m, '/tmp/test.txt')\n", + " results_list.append({\n", + " \"epoch\": config[\"epoch\"],\n", + " \"lr\": config[\"lr\"],\n", + " \"wordNgrams\": config[\"wordNgrams\"],\n", + " \"minCount\": config[\"minCount\"],\n", + " \"f1\": r[\"f1\"]\n", + " })\n", + " print(f\"epoch={config['epoch']}, lr={config['lr']}, ngrams={config['wordNgrams']} → F1: {r['f1']:.4f}\")\n", + "\n", + "print(\"\\nBest configuration:\", max(results_list, key=lambda x: x['f1']))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "86db2148-81f9-4558-9d1a-377a15b883a4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjOtJREFUeJzs3XlcVGX///H3sLshKoqKKC7lvuKGlktS2uLSqm0qmZVLekf1zS3RLLFb87bFMk3NFpM7szQzU0ktc99ySUxywQ0EF1BMQOb6/eGPuZ0ARcQD4uv5eMyj5jrXOfM541wzw3vOuY7NGGMEAAAAAAAAWMiloAsAAAAAAADArYdQCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAPiHVatWyWazacyYMQVdSpEQGBiowMDAgi4DAFDIEEoBAAq9gwcPymazXfF25syZG/b4HTp0kM1my9IeGBh41bouvx08eDDfa/v0009ls9n06aef5mm9CRMm5NhnzJgxstlsmjdv3nVWiZtFQQcHffv2vaYxda2v+5vdP99zXF1dVa5cOXXq1Elff/11QZd3zTLfY1atWlXQpQAACohbQRcAAEBu1axZU0899VS2y7y8vCyuRvrXv/6VJQz79NNPdejQIQ0dOlQ+Pj5Oy/55H4CzHj16ZAnFVq1apdWrV6t79+5q0qSJ07J/3s9PLVu21J49e+Tr63vDHiMvXF1dNWrUKElSenq6YmJi9O233+rnn3/W+PHjNXz48AKuEACA3COUAgDcNGrVqlWoTqX517/+laVt1apVOnTokP71r39xqgpwjXr06KEePXo4tY0ZM0arV69Wjx491LdvX8tqKV68uOrUqWPZ4+WWm5tblvfB3377Te3atdO4ceM0dOhQFS9evGCKAwDgGnH6HgCgyNiyZYsGDx6sBg0aqHTp0ipWrJgaNmyoCRMmKD09PUv/ffv2KTQ0VNWrV5enp6fKli2rxo0b61//+peMMZIkm82m1atXO/4/83atfxwbYzRr1iy1bdtW3t7eKl68uJo3b65Zs2Y59Zs3b55sNpvuu+8+Rw05Levbt69CQ0MlSaGhoU713QhJSUkqUaKE6tevn+1yu92uwMBAlSlTRn///bck59NzZs6cqYYNG8rLy0v+/v566aWXdPbs2Wy3tWPHDvXq1UuVKlWSh4eHqlWrphdffFEnT5506pd5amffvn21Z88ePfjggypXrpzT6ZI2m00dOnTQkSNH9Pjjj8vX11fFixdX27ZttWLFiiyP/eeff+r//u//1KxZM5UrV05eXl66/fbbNWzYMJ07dy5L/8zTOy9cuKBRo0apZs2acnd3dwQHed1eamqqRowYoapVq6pYsWIKCgpy1JuUlKRBgwapcuXK8vLyUnBwsDZu3Jjtc3nixAm99NJLqlWrljw9PeXr66uHH35Yu3btyvI8Hjp0SIcOHXJ6Lf0zAPnll1/UtWtX+fr6ytPTU7fddptGjRql8+fPO/W7fE6mtWvX6p577pGPj0++vT4z/12zk91piJmnBh44cEDvvfee6tSpI09PT1WrVk1jx46V3W7Psf7stn3u3DkNHTpUlStXlqenpxo1aqT58+dnW8/BgwfVs2dPlS1bViVLllT79u31yy+/5Nvpa23btlWdOnX0999/648//siyfOHCherUqZPKlCkjLy8vNWjQQJMmTVJGRoZTP7vdrk8++UQtW7ZU2bJlVaxYMVWpUkVdu3Z1qvFKpw3ndi6uDh06aOzYsZKkjh07Ol5vl/+75eY9GgBwc+NIKQBAkTFjxgx9//33ateune677z6dP39eq1at0vDhw7Vp0yZ98803jr7Hjh1Ty5YtlZKSovvvv189e/ZUSkqK9u3bpw8//FCTJk2Sm5ubwsPDHafkhYeHO9a/ltOGjDF68skn9dVXX+m2227TE088IQ8PDy1fvlz9+vXTH3/8oUmTJkmSevXqpaVLl2rOnDl69913HUdjHTx4UC+88IL8/PwcfxD26NFDZ86c0cKFC7M9tSm/lS5dWr169dKsWbO0du1atWnTxmn58uXLdejQIQ0aNEjFihVzWjZ58mRFRUWpZ8+euv/++7VixQpNmTJF69ev1y+//CJ3d3dH30WLFumxxx6Ti4uLunfvroCAAP3xxx/64IMP9NNPP2nDhg0qU6aM0/ZjYmLUunVrNWzYUH379tXJkyfl4eHhWH769Gm1bdtW5cuX17PPPquEhARFRkaqS5cumj9/vtPROQsWLNDMmTPVsWNHdejQQXa7XevXr9fbb7+t1atXZ6k308MPP6zff/9dXbp0kY+Pj6pXr35d2+vZs6d27typbt266e+//9aXX36pBx54QL/99puee+45paWl6dFHH3XalwMHDqh06dKObfz111+OQO6ee+5Rjx49dOLECX3zzTf66aefFBUVpVatWsnHx0fh4eGaMmWKJOejAC8Pfj766CMNGjRIPj4+6tq1qypUqKDNmzfrrbfe0sqVK7Vy5Uqn512S1q5dq/Hjx6tjx4567rnnFBsbm2VfrfTqq69q9erVeuCBB9S5c2d99913GjNmjNLS0vTWW2/lahvp6em65557dPr0aT388MM6f/685s2bp8cee0xLly7VPffc4+h79OhRtWnTRsePH1eXLl3UtGlT7d27V3fffbfuuuuufN8/Nzfnr/fDhw/XhAkT5O/vr4ceekilS5fWr7/+qldffVUbNmxwmotq+PDh+ve//62aNWvqiSeeUKlSpXT06FGtWbNGK1asyDEEzIvMYH/16tXq06ePI4zKPM05t+/RAICbnAEAoJA7cOCAkWRq1qxpwsPDs9zWrVtnjDHm0KFD5uLFi07r2u1288wzzxhJZs2aNY729957z0gyU6ZMyfJ4J0+edLrfvn17k9uPzMy+Bw4ccLRNnz7dSDKhoaEmLS3N0Z6ammq6du1qJJnNmzc72s+ePWtq1aplPD09zbZt28zFixdNmzZtjM1mM0uXLnV6vNmzZxtJZvbs2bmq75/rderUKdvnNDw83LEvX331lWO9DRs2GEmmb9++Wbb5yCOPGElm+/btjrbw8HAjyXh4eJjff//d0W63280TTzxhJJlJkyY52hMTE423t7fx9/c3Bw8edNr+V199ZSSZwYMHO9oyXxuSzOjRo7Pd18zlTzzxhLHb7Y7233//3Xh4eJjy5cub8+fPO9qPHDliUlNTs2xn7NixRpL54osvnNozn6cmTZpkee1cz/buuOMOc+7cOUd7ZGSkkWR8fHzMo48+atLT0x3L3n77bSPJvPPOO07batOmjXF1dc3yutm7d68pVaqUadiwoVN7tWrVTLVq1bLUaowxu3fvNm5ubqZx48YmMTHRaVlERESWf8uVK1c6nvtZs2Zlu83cyHwN/fM1Lsm0b98+23Wy248+ffoYSaZ69erm2LFjjvaEhATj4+NjSpUq5fTvlFl/eHh4lm1LMt27d3fqv2LFCiPJdO7c2an/U089ZSSZt956y6l95syZjudn5cqVV34SLntsT0/PLO1r1qwxLi4uply5cubvv/92tC9btsxR0+WvJbvdbl544QUjycyfP9/RXrZsWVO5cmWTkpKS5TEuf21f6X3nSs/bP/9NMv9ts9v/a3mPBgDcvAilAACF3uXBQ3a3//znP1dcf8uWLUaSGTNmjKMt8w+ejz/++KqPf72hVKNGjUyJEiWcgo9MO3bsMJLMyy+/7NS+adMm4+7uburUqWNeeeUVI8m89NJLWda/3lAqN7fLQyljjGnatKkpUaKESUpKcrSdOHHCeHh4mBYtWjj1zfyj89lnn81Sw8GDB42rq6tp0KCBo23y5MlGkvnss8+yrbtZs2bG19fXcT/ztVGxYsVsgx9jLoUXrq6uWUIuY4zp169flj/Mc3Ly5MlsA7nMf/OFCxdedRvXsr3Vq1c7tWdkZBh3d3cjyRw6dMhpWWxsrJFkevfu7WjbunWrkWSeeeaZbB8/LCzMSDI7d+50tF0plBoyZIiRZH755ZcsyzIyMkz58uVNUFCQoy0znGjWrFn2T0Au5XcolV1Alrlsx44dWerPKZTav39/to9btmxZx/0LFy4YT09PU6FCBXPhwgWnvna73dSuXfuaQylXV1dHcDxixAjz2GOPGXd3d+Pm5mYiIyOd+nfr1i3b14sxxpw5c8bYbDbz8MMPO9rKli1rAgMDs9T6T1aGUrl5jwYA3Lw45hUAcNPo3Lmzli5dmuPytLQ0ffDBB5o3b56io6N17tw5p3lHjh075vj/rl27avjw4Ro0aJCioqLUpUsXtW/fXjVq1MjXms+fP6+dO3eqcuXKevvtt7Msz5zrKjo62qm9efPmGjdunIYNG6bo6Gg1adJEEyZMyNfaJCkiIkLDhg3LdtmYMWMcc75c7vnnn9cLL7yguXPn6oUXXpAkffbZZ0pLS1P//v2z3dadd96Zpa1atWoKCAjQ7t27lZaWJg8PD61fv16StGHDBv31119Z1rlw4YISExOVmJjodFW0xo0bZzlt7HJVq1ZVtWrVsq1r5syZ2rZtmx5++GFJl063nD17tj799FPt2rVLSUlJTvMNXf46ulzLli2zbc/r9v55OqaLi4sqVKig8+fPq2rVqk7LKlWqlGVbmc9lfHx8tvP7ZL7moqOj1aBBg2xruFzm9jJP+/snd3f3LK9jSWrRosVVt22loKCgLG1VqlSRpCxX08zJ5adn/nM769atc9zfu3evUlNT1bx5c3l6ejr1tdlsatOmjfbu3XsN1UsZGRlZxqWbm5u+/vrrLJPEr1+/XiVKlMgyd12mYsWKOf2b9erVSx9++KEaNGigXr16qWPHjgoODs5yOq4VrHqPBgAULEIpAECR8cgjj+j777/X7bffrp49e6pChQpyd3fXmTNn9O677yo1NdXRNzAwUOvXr9eYMWO0ZMkS/fe//5Uk1alTR2+88YYeffTRfKnp9OnTMsbo6NGj2QY8mVJSUrK0de/eXSNGjJDdbtdzzz13xdDFSk888YReeeUVffLJJ45QaubMmSpZsqQef/zxbNfx8/PLsf3gwYM6e/asypUrp1OnTkmSpk6desUaUlJSnEKpnLafm8eXLk0cnmnIkCH64IMPFBAQoG7duqlSpUqOQGHs2LFOr6PcPEZet+ft7Z2lzc3NLcd2SU4T+mc+lz/88IN++OGHbB9Dyv61l53M7eV23qVMV/u3sdqVnr9/Tvydk8vn7frndi4PHJOTkyVJFSpUyLZ/Xp4bT09PXbhwQZJ07tw5/fzzz3rmmWf09NNPa82aNWrcuLGj76lTp3Tx4sVcv/e8++67ql69umbPnq0333xTb775pry8vPTYY4/pnXfecRpzN5pV79EAgIJFKAUAKBI2bdqk77//Xp07d9YPP/wgV1dXx7L169fr3XffzbJOgwYNNH/+fKWnp2vLli368ccf9d5776lnz56qXLmy2rZte911Zf4BHBQUpM2bN+d6vfT0dD311FOSLh2VMWrUKHXt2tVxREdBKlWqlJ588kl9/PHH2r59u1JSUrRnzx49++yzKlmyZLbrxMfH59hus9lUqlQpSf97vnbu3Jmro3cyXe2Kbld6fOl/IcOJEyc0depUNWrUSOvWrVPx4sUdfePi4q74x312NVzP9q5X5nP5/vvva/Dgwfm2veTkZMe/V27cqKtB2mw2Xbx4MdtlSUlJOQZHVsp8zk6cOJHt8pxel7lVsmRJdevWTZGRkQoJCVFoaKi2bNnieM69vb1ls9mUmJiYq+25ubnplVde0SuvvKJjx45p9erVmj17tj777DPFxcXpp59+knTpqD1J2T7/lwe818uK92gAQMFyKegCAADID5mnet1///1OgZQk/frrr1dc193dXa1bt9bYsWP13nvvyRijxYsXO5Znbi+3R1FcrlSpUqpbt6727NmT61ODJGnEiBHasmWLRowYoc8//1ynTp3S008/neWy9ddT2/V4/vnnJV264uEnn3wiSTmeuidl/29w6NAhHT58WPXr13ccBdaqVStJcjoFKj/Exsbq0KFDOdbVtGlTSdL+/ftljFFISIhTgJTTPlxNfm/vWuTluXR1dc3xtZS5vczT+ApamTJldPTo0SztBw8evKaxdiPVrl1bnp6e2rJlS5Yj4owx+fY679Spk3r06KFt27bpq6++crS3atVKJ0+e1L59+655m5UrV9bjjz+upUuXqlatWlqxYoX+/vtvSXJc/TK753/btm25fozcvn9d7T0aAHDzIpQCABQJmfMFrVmzxql99+7dioiIyNJ/y5YtjlNrLpd55IKXl5ejrWzZspKkw4cP56m2IUOG6Pz58+rfv3+2p0odOHBABw8edNxfvny53nnnHbVu3Vrh4eF64IEHNGjQIK1atSrLvFLXW1teNW3aVC1atNCXX36pr7/+Wo0aNcpxTiXp0pxTO3bscNw3xmjEiBHKyMhwXBpekkJDQ1WqVCmNHDlSu3fvzrKd8+fP5ykUycjI0IgRI5zmGNuxY4c+//xzlS9fXvfdd5+k/72O1q5d6xQAHjlyRMOHD7/mx83v7V2Lli1bqlWrVvrqq68UGRmZZbndbtfq1aud2sqWLavExETH6WGXGzhwoNzc3PTiiy8qNjY2y/IzZ85cUyBxvVq0aKGDBw867UNaWprCwsIsq+FqPD099cgjjyg+Pl5TpkxxWvbZZ59lOwdXXo0ZM0Y2m01jx451hDxDhgyRJD3zzDM6efJklnXi4uK0Z88eSVJqaqrWrl2bpU9KSorOnTsnd3d3xxFSQUFBstlsmjdvntNrZd++fdkelZqTK71/Xct7NADg5sXpewCAIqFly5Zq2bKl/vvf/+r48eNq3bq1YmNjtWjRIt1///2aP3++U//PP/9cH3/8sdq1a6eaNWvK29tbf/zxh5YsWaKyZcsqNDTU0feuu+7S/Pnz9fDDD+vee++Vl5eXGjdurK5du+aqtueff17r16/XnDlz9NtvvykkJESVK1dWfHy8oqOjtWHDBs2dO1eBgYFKTExUnz59VKpUKc2dO9cx182kSZO0evVqhYeHq1OnTo6jVjInIZ4yZYpOnz6t8uXLS5JGjRqVH0/rFb3wwgvq16+fpCsfJSVdmqQ+ODhYvXr1Uvny5RUVFaXNmzerdevWevHFFx39ypcvr6+++kqPPvqoGjdurC5duqhOnTpKTU11BBBt2rS54oT32WnUqJHWrFmjFi1aKCQkRAkJCYqMjNTFixc1ffp0x0TOlSpV0sMPP6xvvvlGzZs3V6dOnRQfH6/FixerU6dO2U6+fiX5vb1r9dVXX6ljx47q1auXpkyZombNmqlYsWKKjY3VunXrlJCQ4BQq3HXXXdq8ebPuvfde3XnnnfLw8FC7du3Url07NWjQQB9++KEGDBig2rVr67777lPNmjV19uxZ7d+/X6tXr1bfvn01bdq0G7pPmcLCwrRs2TLdd999evzxx1W8eHEtX75cPj4+jonfC4OIiAitWLFCw4YN0+rVq9W0aVPt3btXixcvVpcuXbR06VJH2HM9GjdurAcffFALFizQF198oT59+qhLly56/fXXNW7cONWqVUtdunRRtWrVdPLkScXExOjXX3/Vm2++qbp16+rvv/9W27ZtdfvttysoKEhVq1bVuXPntHjxYsXFxemVV15xzIWWeRTV3LlzFRQUpC5duujEiRP69ttv1aVLF33zzTe5qrljx46y2WwaMWKEdu/erdKlS8vHx0eDBw++pvdoAMBNrICu+gcAQK4dOHDASDKdO3e+Yr8TJ06YZ555xlSuXNl4eXmZhg0bmqlTp5r9+/cbSaZPnz6OvuvXrzfPP/+8adCggfHx8THFihUzt912mxk8eHCWy6enp6eb//u//zNVq1Y1bm5uWbZ1ufbt2xtJ5sCBA1mWRUZGmpCQEFOmTBnj7u5u/P39TYcOHcw777xjEhISjDHGPPDAA0aS+eKLL7Ksv3PnTuPl5WVq1KhhkpOTHe0//PCDadGihSlWrJiRZHLz8Z55SfeIiIgc+2Rerv2rr77KdnlKSorx9PQ0xYoVM6dPn77iNlauXGlmzJhh6tevbzw9PU2lSpXM0KFDnfbjctHR0aZfv36mWrVqxsPDw5QpU8Y0bNjQDBkyxGzcuNHRL/O1kdO/hzHGSDLt27c3hw8fNj179jRly5Y1Xl5eJjg42CxbtixL/7Nnz5qXX37ZBAYGGk9PT3PbbbeZcePGmbS0NMe2Lpf5b56T/NxetWrVTLVq1a64n/906tQpM2rUKNOgQQNTrFgxU7JkSXPbbbeZJ554wixYsCBLrf379zeVKlUyrq6uRpIJDw936rNx40bTq1cvU7lyZePu7m58fX1Ns2bNzLBhw8yePXsc/VauXJnt+tcq8zU0e/bsLMu+/vpr07BhQ+Ph4WEqVqxoXnzxRXP27Nlsn6c+ffrkODYvf51erf4r/Rvk9G+3f/9+8+ijj5rSpUub4sWLmzvvvNOsXr3aDB482Egy27Ztu/KTcNlje3p65rj8999/NzabzdSoUcOkp6c72pcvX266du1qypcvb9zd3U3FihVNcHCwGTdunImNjTXGGJOWlmbefvttc88995gqVaoYDw8P4+fnZ9q1a2fmzp1r7Ha702OdP3/eDBkyxPj5+RlPT0/TqFEj8+WXX17z8/bpp5+ahg0bGk9PTyPJ0eda3qMBADcvmzGXHccOAACQS5s3b1aLFi309NNP67PPPsu2z5gxYzR27FitXLlSHTp0sLbA/89ms6l9+/ZatWpVgTw+kJM77rhD69atU1JSUo4XCQAAoChjTikAAJAnEydOlCQNGDCggCsBCrfjx49nafviiy8cp/MSSAEAblXMKQUAAHItNjZWc+fO1e7du/Xf//7XMVcUgJw1aNBATZs2Vb169eTq6qrt27dr1apVKlWqlCZNmlTQ5QEAUGAIpQAAQK7t379fw4cPV8mSJdW1a1dNnz69oEsCCr0XXnhB33//vTZv3qyUlBSVL19eTzzxhF5//XXVqVOnoMsDAKDAFLo5paZOnaqJEycqLi5OjRs31vvvv3/FS0xPmTJFH330kWJjY+Xr66tHHnlEERERXCYWAAAAAACgECtUc0pFRkYqLCxM4eHh2rp1qxo3bqzOnTvrxIkT2fafO3euhg0bpvDwcO3Zs0czZ85UZGSkRowYYXHlAAAAAAAAuBaF6kipVq1aqUWLFvrggw8kSXa7XQEBAXrxxRc1bNiwLP0HDx6sPXv2KCoqytH28ssva8OGDVqzZo1ldQMAAAAAAODaFJo5pdLS0rRlyxYNHz7c0ebi4qKQkBCtW7cu23XatGmjL774Qhs3blTLli21f/9+LVmyRE8//XSOj5OamqrU1FTHfbvdrlOnTqlcuXKy2Wz5t0MAAAAAAAC3IGOMzp49q8qVK8vFJeeT9ApNKJWYmKiMjAz5+fk5tfv5+Sk6OjrbdZ544gklJibqjjvukDFGFy9e1AsvvHDF0/ciIiI0duzYfK0dAAAAAAAAzg4fPqwqVarkuLzQhFJ5sWrVKo0fP14ffvihWrVqpZiYGA0dOlTjxo3T66+/nu06w4cPV1hYmON+UlKSqlatqsOHD8vb29uq0gEAAAAAAIqk5ORkBQQEqFSpUlfsV2hCKV9fX7m6uio+Pt6pPT4+XhUrVsx2nddff11PP/20nn32WUlSw4YNlZKSoueee04jR47M9hAxT09PeXp6Zmn39vYmlAIAAAAAAMgnV5smqdBcfc/Dw0NBQUFOk5bb7XZFRUUpODg423XOnz+fJXhydXWVdOn8RQAAAAAAABROheZIKUkKCwtTnz591Lx5c7Vs2VJTpkxRSkqKQkNDJUm9e/eWv7+/IiIiJEldu3bV5MmT1bRpU8fpe6+//rq6du3qCKcAAAAAAABQ+BSqUKpnz55KSEjQ6NGjFRcXpyZNmmjp0qWOyc9jY2OdjowaNWqUbDabRo0apaNHj6p8+fLq2rWr3nrrrYLaBQAAAAAAAOSCzdzi57klJyerdOnSSkpKYk4pAAAAAACA65TbrKXQzCkFAAAAAACAWwehFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxXKEOpqVOnKjAwUF5eXmrVqpU2btyYY98OHTrIZrNlud1///0WVgwAAAAAAIBrUehCqcjISIWFhSk8PFxbt25V48aN1blzZ504cSLb/gsWLNDx48cdt127dsnV1VWPPvqoxZUDAAAAAAAgtwpdKDV58mT1799foaGhqlevnqZNm6bixYtr1qxZ2fYvW7asKlas6LgtX75cxYsXJ5QCAAAAAAAoxApVKJWWlqYtW7YoJCTE0ebi4qKQkBCtW7cuV9uYOXOmevXqpRIlSmS7PDU1VcnJyU43AAAAAAAAWKtQhVKJiYnKyMiQn5+fU7ufn5/i4uKuuv7GjRu1a9cuPfvsszn2iYiIUOnSpR23gICA664bAAAAAAAA16ZQhVLXa+bMmWrYsKFatmyZY5/hw4crKSnJcTt8+LCFFQIAAAAAAECS3Aq6gMv5+vrK1dVV8fHxTu3x8fGqWLHiFddNSUnRvHnz9MYbb1yxn6enpzw9Pa+7VgAAAAAAAORdoTpSysPDQ0FBQYqKinK02e12RUVFKTg4+Irrfv3110pNTdVTTz11o8sEAAAAAADAdSpUR0pJUlhYmPr06aPmzZurZcuWmjJlilJSUhQaGipJ6t27t/z9/RUREeG03syZM9WjRw+VK1euIMoGAAAAAADANSh0oVTPnj2VkJCg0aNHKy4uTk2aNNHSpUsdk5/HxsbKxcX5AK+9e/dqzZo1WrZsWUGUDAAAAAAAgGtkM8aYgi6iICUnJ6t06dJKSkqSt7d3QZcDAAAAAABwU8tt1lKo5pQCAAAAAADArYFQCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAALgFTJ06VYGBgfLy8lKrVq20cePGK/Y/c+aMBg0apEqVKsnT01O33367lixZ4lgeERGhFi1aqFSpUqpQoYJ69OihvXv3Om1j+vTp6tChg7y9vWWz2XTmzBmn5QcPHlS/fv1UvXp1FStWTDVr1lR4eLjS0tLybb9ReBFKAQAAAABQxEVGRiosLEzh4eHaunWrGjdurM6dO+vEiRPZ9k9LS9Pdd9+tgwcPav78+dq7d69mzJghf39/R5/Vq1dr0KBBWr9+vZYvX6709HTdc889SklJcfQ5f/68unTpohEjRmT7ONHR0bLb7fr444+1e/du/ec//9G0adNy7I+ixWaMMQVdREFKTk5W6dKllZSUJG9v74IuBwAAAACAfNeqVSu1aNFCH3zwgSTJbrcrICBAL774ooYNG5al/7Rp0zRx4kRFR0fL3d09V4+RkJCgChUqaPXq1WrXrp3TslWrVqljx446ffq0fHx8rridiRMn6qOPPtL+/ftzt3ModHKbtXCkFAAAwA2Q36dI/PLLL+ratasqV64sm82m7777Lss2+vbtK5vN5nTr0qWLU5/AwMAsfSZMmJAv+wwAKJzS0tK0ZcsWhYSEONpcXFwUEhKidevWZbvOokWLFBwcrEGDBsnPz08NGjTQ+PHjlZGRkePjJCUlSZLKli17XfUmJSVd9zZwc3Ar6AIAAACKmsxTJKZNm6ZWrVppypQp6ty5s/bu3asKFSpk6Z95ikSFChU0f/58+fv769ChQ06/JKekpKhx48Z65pln9NBDD+X42F26dNHs2bMd9z09PbP0eeONN9S/f3/H/VKlSuVxTwEAN4PExERlZGTIz8/Pqd3Pz0/R0dHZrrN//379/PPPevLJJ7VkyRLFxMRo4MCBSk9PV3h4eJb+drtd//rXv9S2bVs1aNAgz7XGxMTo/fff16RJk/K8Ddw8CKUAAADy2eTJk9W/f3+FhoZKunQKxA8//KBZs2Zle4rErFmzdOrUKa1du9ZxikRgYKBTn3vvvVf33nvvVR/b09NTFStWvGKfUqVKXbUPAODWZrfbVaFCBU2fPl2urq4KCgrS0aNHNXHixGxDqUGDBmnXrl1as2ZNnh/z6NGj6tKlix599FGnH09QdHH6HgAAQD6y6hSJnKxatUoVKlRQ7dq1NWDAAJ08eTJLnwkTJqhcuXJq2rSpJk6cqIsXL17z4wAAbh6+vr5ydXVVfHy8U3t8fHyOP1JUqlRJt99+u1xdXR1tdevWVVxcXJYr4w0ePFiLFy/WypUrVaVKlTzVeOzYMXXs2FFt2rTR9OnT87QN3HwIpQAAAPLRlU6RiIuLy3ad/fv3a/78+crIyNCSJUv0+uuv65133tGbb755TY/dpUsXffbZZ4qKitLbb7+t1atX695773UKt4YMGaJ58+Zp5cqVev755zV+/Hj93//937XvKADgpuHh4aGgoCBFRUU52ux2u6KiohQcHJztOm3btlVMTIzsdruj7c8//1SlSpXk4eEhSTLGaPDgwfr222/1888/q3r16nmq7+jRo+rQoYOCgoI0e/ZsubgQVdwqOH0PAACggF3rKRI56dWrl+P/GzZsqEaNGqlmzZpatWqVOnXqJEkKCwtz9GnUqJE8PDz0/PPPKyIiItv5pwAARUNYWJj69Omj5s2bq2XLlpoyZYpSUlIcp5r37t1b/v7+ioiIkCQNGDBAH3zwgYYOHaoXX3xR+/bt0/jx4zVkyBDHNgcNGqS5c+dq4cKFKlWqlOPHl9KlS6tYsWKSpLi4OMXFxSkmJkaStHPnTpUqVUpVq1ZV2bJlHYFUtWrVNGnSJCUkJDi2z6nmRR+hFAAAQD7K6ykS7u7uOZ4ikfmL9LWqUaOGfH19FRMT4wil/qlVq1a6ePGiDh48qNq1a+fpcQAAhV/Pnj2VkJCg0aNHKy4uTk2aNNHSpUsdR/bGxsY6HaEUEBCgn376SS+99JIaNWokf39/DR06VK+99pqjz0cffSRJ6tChg9NjzZ49W3379pV0aV7FsWPHOpa1a9fOqc/y5csVExOjmJiYLKf+GWPybf9ROBFKAQAA5KPLT5Ho0aOHpP+dIjF48OBs12nbtq3mzp0ru93u+IPgn6dI5MWRI0d08uRJVapUKcc+27dvl4uLS7ZXBQQAFC2DBw/O8bNo1apVWdqCg4O1fv36HLeXm9BozJgxGjNmTI7L+/bt6wiwcOvhRE0AgJOpU6cqMDBQXl5eatWqlTZu3HjF/mfOnNGgQYNUqVIleXp66vbbb9eSJUuuaZvTp09Xhw4d5O3tLZvNpjNnzmR5nG7duqlq1ary8vJSpUqV9PTTT+vYsWPXvb/AjRAWFqYZM2Zozpw52rNnjwYMGJDlFInhw4c7+g8YMECnTp3S0KFD9eeff+qHH37Q+PHjNWjQIEefc+fOafv27dq+fbsk6cCBA9q+fbtiY2Mdy1999VWtX79eBw8eVFRUlLp3765atWqpc+fOkqR169ZpypQp+v3337V//359+eWXeumll/TUU0+pTJkyFj07AAAAlxBKAQAcIiMjFRYWpvDwcG3dulWNGzdW586ddeLEiWz7p6Wl6e6779bBgwc1f/587d27VzNmzJC/v/81bfP8+fPq0qWLRowYkWNtHTt21H//+1/t3btX33zzjf766y898sgj+bfzQD7q2bOnJk2apNGjR6tJkybavn17llMkjh8/7uifeYrEpk2b1KhRIw0ZMkRDhw7VsGHDHH02b96spk2bqmnTppIuBV9NmzbV6NGjJUmurq7asWOHunXrpttvv139+vVTUFCQfv31V8dcUZ6enpo3b57at2+v+vXr66233tJLL73EVY4AAECBsJlb/CTN5ORklS5dWklJSfL29i7ocgCgQLVq1UotWrTQBx98IOnSKUcBAQF68cUXnf44zjRt2jRNnDhR0dHRcnd3v+5trlq1Sh07dtTp06fl4+NzxVoXLVqkHj16KDU1NcfHBgAAAGC93GYtHCkFAJB06ainLVu2KCQkxNHm4uKikJAQrVu3Ltt1Fi1apODgYA0aNEh+fn5q0KCBxo8f77j8fF62mRunTp3Sl19+qTZt2hBIAQAAADcpJjoHAEiSEhMTlZGR4Ti9KJOfn5+io6OzXWf//v36+eef9eSTT2rJkiWKiYnRwIEDlZ6ervDw8Dxt80pee+01ffDBBzp//rxat26txYsXX/M2AADArWtmnYUFXQJwRf2iuxd0CZbiSCkAQJ7Z7XZVqFBB06dPV1BQkHr27KmRI0dq2rRpN+TxXn31VW3btk3Lli2Tq6urevfuzaWCAQAAgJsUR0oBACRJvr6+cnV1VXx8vFN7fHy8KlasmO06lSpVkru7u1xdXR1tdevWVVxcnNLS0vK0zavV6Ovrq9tvv11169ZVQECA1q9fr+Dg4GveFgAAAICCxZFSAABJkoeHh4KCghQVFeVos9vtioqKyjH0adu2rWJiYmS32x1tf/75pypVqiQPD488bTO3Mh8zNTX1urYDAAAAoGBwpBQAwCEsLEx9+vRR8+bN1bJlS02ZMkUpKSkKDQ2VJPXu3Vv+/v6KiIiQJA0YMEAffPCBhg4dqhdffFH79u3T+PHjNWTIkFxvU5Li4uIUFxenmJgYSdLOnTtVqlQpVa1aVWXLltWGDRu0adMm3XHHHSpTpoz++usvvf7666pZsyZHSRVyXb97sKBLAK7o+x7fFnQJAADcsgilAAAOPXv2VEJCgkaPHq24uDg1adJES5cudUxUHhsbKxeX/x1kGxAQoJ9++kkvvfSSGjVqJH9/fw0dOlSvvfZarrcpSdOmTdPYsWMd99u1aydJmj17tvr27avixYtrwYIFCg8PV0pKiipVqqQuXbpo1KhR8vT0vNFPCwAAAIAbwGZu8Rlik5OTVbp0aSUlJcnb27ugywEAoEjhSCkUdhwpBdxauPoeCruicvW93GYtzCkFAAAAAAAAyxW6UGrq1KkKDAyUl5eXWrVqpY0bN16x/5kzZzRo0CBVqlRJnp6euv3227VkyRKLqgUAAAAAAEBeFKpQKjIyUmFhYQoPD9fWrVvVuHFjde7cWSdOnMi2f1pamu6++24dPHhQ8+fP1969ezVjxgz5+/tbXDkAAACAG+FafrT+9NNPZbPZnG5eXl5Off65PPM2ceJER58///xT3bt3l6+vr7y9vXXHHXdo5cqVTtsZMmSIgoKC5OnpqSZNmuTrPgPAraJQhVKTJ09W//79FRoaqnr16mnatGkqXry4Zs2alW3/WbNm6dSpU/ruu+/Utm1bBQYGqn379mrcuLHFlQMAAADIb9f6o7UkeXt76/jx447boUOHnJZfvuz48eOaNWuWbDabHn74YUefBx54QBcvXtTPP/+sLVu2qHHjxnrggQcUFxfntK1nnnlGPXv2zN+dBoBbSKEJpdLS0rRlyxaFhIQ42lxcXBQSEqJ169Zlu86iRYsUHBysQYMGyc/PTw0aNND48eOVkZGR4+OkpqYqOTnZ6QYAAACg8LnWH62lS0dCVaxY0XG7/GqvkpyWVaxYUQsXLlTHjh1Vo0YNSVJiYqL27dunYcOGqVGjRrrttts0YcIEnT9/Xrt27XJs57333tOgQYMc6wEArp1bQReQKTExURkZGVk+NPz8/BQdHZ3tOvv379fPP/+sJ598UkuWLFFMTIwGDhyo9PR0hYeHZ7tORESE02XHASA7NT46V9AlAFe0f0DJgi4BAG6ozB+thw8f7mi72o/WknTu3DlVq1ZNdrtdzZo10/jx41W/fv1s+8bHx+uHH37QnDlzHG3lypVT7dq19dlnn6lZs2by9PTUxx9/rAoVKigoKCj/dhAAUHiOlMoLu92uChUqaPr06QoKClLPnj01cuRITZs2Lcd1hg8frqSkJMft8OHDFlYMAAAAIDeu9KP1P0+jy1S7dm3NmjVLCxcu1BdffCG73a42bdroyJEj2fafM2eOSpUqpYceesjRZrPZtGLFCm3btk2lSpWSl5eXJk+erKVLl6pMmTL5t4MAgMJzpJSvr69cXV0VHx/v1B4fH6+KFStmu06lSpXk7u4uV1dXR1vdunUVFxentLQ0eXh4ZFnH09NTnp6e+Vs8AAAAgAIXHBys4OBgx/02bdqobt26+vjjjzVu3Lgs/WfNmqUnn3zSaTJ0Y4wGDRqkChUq6Ndff1WxYsX0ySefqGvXrtq0aZMqVapkyb4AwK2g0Bwp5eHhoaCgIEVFRTna7Ha7oqKinD5YLte2bVvFxMTIbrc72v78809VqlQp20AKAAAAwM0hLz9a/5O7u7uaNm2qmJiYLMt+/fVX7d27V88++6xT+88//6zFixdr3rx5atu2rZo1a6YPP/xQxYoVczrNDwBw/QpNKCVJYWFhmjFjhubMmaM9e/ZowIABSklJUWhoqCSpd+/eTueUDxgwQKdOndLQoUP1559/6ocfftD48eM1aNCggtoFAAAAAPkgLz9a/1NGRoZ27tyZ7dFNM2fOVFBQUJYrd58/f17SpfmrLufi4uL0YzgA4PoVmtP3JKlnz55KSEjQ6NGjFRcXpyZNmmjp0qWO88hjY2OdPhwCAgL0008/6aWXXlKjRo3k7++voUOH6rXXXiuoXQAAAACQT8LCwtSnTx81b95cLVu21JQpU7L8aO3v76+IiAhJ0htvvKHWrVurVq1aOnPmjCZOnKhDhw5lORoqOTlZX3/9td55550sjxkcHKwyZcqoT58+Gj16tIoVK6YZM2bowIEDuv/++x39YmJidO7cOcXFxenvv//W9u3bJUn16tXjrA0AyKVCFUpJ0uDBgzV48OBsl61atSpLW3BwsNavX3+DqwIAAABgtWv90fr06dPq37+/4uLiVKZMGQUFBWnt2rWqV6+e03bnzZsnY4wef/zxLI/p6+urpUuXauTIkbrrrruUnp6u+vXra+HChU5HVT377LNavXq1437Tpk0lSQcOHFBgYGB+Pg0AUGTZjDGmoIsoSMnJySpdurSSkpLk7e1d0OUAKCRqfHSuoEsArmj/gJIFXUKudP3uwYIuAbii73t8W9AlALDQzDoLC7oE4Ir6RXcv6BLyRW6zlkI1pxQAAAAAAABuDYRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcm4FXQAAAACAq/jYVtAVAFf2/C19UXcAecSRUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxXKUGrq1KkKDAyUl5eXWrVqpY0bN+bY99NPP5XNZnO6eXl5WVgtAAAAAAAArlWhC6UiIyMVFham8PBwbd26VY0bN1bnzp114sSJHNfx9vbW8ePHHbdDhw5ZWDEAAAAAAACuVaELpSZPnqz+/fsrNDRU9erV07Rp01S8eHHNmjUrx3VsNpsqVqzouPn5+VlYMQAAAAAAAK5VoQql0tLStGXLFoWEhDjaXFxcFBISonXr1uW43rlz51StWjUFBASoe/fu2r17txXlAgAAAAAAII8KVSiVmJiojIyMLEc6+fn5KS4uLtt1ateurVmzZmnhwoX64osvZLfb1aZNGx05ciTb/qmpqUpOTna6AQAAAAAAwFqFKpTKi+DgYPXu3VtNmjRR+/bttWDBApUvX14ff/xxtv0jIiJUunRpxy0gIMDiigEAAAAAAFCoQilfX1+5uroqPj7eqT0+Pl4VK1bM1Tbc3d3VtGlTxcTEZLt8+PDhSkpKctwOHz583XUDAAAAAADg2hSqUMrDw0NBQUGKiopytNntdkVFRSk4ODhX28jIyNDOnTtVqVKlbJd7enrK29vb6QYAAAAAAABruRV0Af8UFhamPn36qHnz5mrZsqWmTJmilJQUhYaGSpJ69+4tf39/RURESJLeeOMNtW7dWrVq1dKZM2c0ceJEHTp0SM8++2xB7gYAAAAAAACuoNCFUj179lRCQoJGjx6tuLg4NWnSREuXLnVMfh4bGysXl/8d4HX69Gn1799fcXFxKlOmjIKCgrR27VrVq1evoHYBAAAAAAAAV1HoQilJGjx4sAYPHpztslWrVjnd/89//qP//Oc/FlQFAAAAAACA/FKo5pQCAAAAAADArYFQCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWI5QCgAAAAAAAJYjlAIAAAAAAIDlCKUAAAAAAABgOUIpAAAAAAAAWC7PoVRsbKxeeOEF1a5dW2XLltUvv/wiSUpMTNSQIUO0bdu2fCsSAAAAAAAARYtbXlb6448/dOedd8put6tVq1aKiYnRxYsXJUm+vr5as2aNUlJSNHPmzHwtFgAAAAAAAEVDnkKp//u//5OPj4/Wr18vm82mChUqOC2///77FRkZmS8FAgAAAAAAoOjJ0+l7v/zyiwYMGKDy5cvLZrNlWV61alUdPXr0uosDAAAAAABA0ZSnUMput6t48eI5Lk9ISJCnp2eeiwIAAAAAAEDRlqdQqlmzZvrhhx+yXXbx4kXNmzdPrVu3vq7CAAAAAAAAUHTlKZQaPny4li5dqgEDBmjXrl2SpPj4eK1YsUL33HOP9uzZo2HDhuVroQAAAAAAACg68jTR+b333qtPP/1UQ4cO1fTp0yVJTz31lIwx8vb21meffaZ27drla6EAAAAAAAAoOvIUSknS008/rYceekjLly/Xvn37ZLfbVbNmTXXu3FmlSpXKzxoBAAAAAABQxFxzKHX+/HkFBARo2LBhevXVV9WjR48bUBYAAAAAAACKsmueU6p48eJyc3NTiRIlbkQ9AAAAAAAAuAXkaaLzhx9+WPPnz5cxJr/rAQAAAAAAwC0gT3NK9erVSwMHDlTHjh3Vv39/BQYGqlixYln6NWvW7LoLBAAAAAAAQNGTp1CqQ4cOjv//9ddfsyw3xshmsykjIyPPhQEAAAAAAKDoylMoNXv27PyuAwAAAAAAALeQPIVSffr0ye86AAAAAAAAcAvJUyh1uXPnzunw4cOSpICAAJUsWfK6iwIAAAAAAEDRlqer70nSpk2b1LFjR5UpU0YNGjRQgwYNVKZMGd11113avHlzftYIAAAAAACAIiZPR0pt2LBBHTp0kIeHh5599lnVrVtXkrRnzx599dVXateunVatWqWWLVvma7EAAAAAAAAoGvIUSo0cOVL+/v5as2aNKlas6LRszJgxatu2rUaOHKnly5fnS5EAAAAAAAAoWvJ0+t6GDRv0/PPPZwmkJMnPz0/PPfec1q9ff93FAQAAAAAAoGjKUyjl4uKiixcv5rg8IyNDLi55nq4KAAAAAAAARVyekqM2bdpo6tSpOnToUJZlsbGx+vDDD9W2bdvrLg4AAAAAAABFU57mlBo/frzatWunOnXq6MEHH9Ttt98uSdq7d68WLlwoNzc3RURE5GuhAAAAAAAAKDryFEo1bdpUGzZs0MiRI7Vo0SKdP39eklS8eHF16dJFb775purVq5evhQIAAAAAAKDoyFMoJUn16tXTt99+K7vdroSEBElS+fLlmUsKAAAAAAAAV5XnUCqTi4uL/Pz88qMWAAAAAAAA3CLydFjTqFGj1KRJkxyXN23aVGPHjs1rTQAAAAAAACji8hRKzZ8/X/fee2+Oy++77z5FRkbmuSgAAAAAAAAUbXkKpWJjY1WzZs0cl1evXl2HDh3Kc1FTp05VYGCgvLy81KpVK23cuDFX682bN082m009evTI82MDAAAAAADgxstTKFWyZMkrhk4HDhyQl5dXngqKjIxUWFiYwsPDtXXrVjVu3FidO3fWiRMnrrjewYMH9corr+jOO+/M0+MCAAAAAADAOnkKpTp06KCPP/5YR48ezbLs8OHDmj59ujp27JingiZPnqz+/fsrNDRU9erV07Rp01S8eHHNmjUrx3UyMjL05JNPauzYsapRo0aeHhcAAAAAAADWydPV98aNG6eWLVuqfv366tevn+rXry9J2rVrl2bNmiVjjMaNG3fN201LS9OWLVs0fPhwR5uLi4tCQkK0bt26HNd74403VKFCBfXr10+//vrrte8QAAAAAAAALJWnUKp27dr69ddf9eKLL+o///mP07J27drpvffeU926da95u4mJicrIyJCfn59Tu5+fn6Kjo7NdZ82aNZo5c6a2b9+eq8dITU1Vamqq435ycvI11wkAAAAAAIDrk6dQSpIaNWqk1atXKzExUfv375ck1ahRQ76+vvlW3NWcPXtWTz/9tGbMmJHrx42IiNDYsWNvcGUAAAAAAAC4kjyHUpl8fX3zLYjy9fWVq6ur4uPjndrj4+NVsWLFLP3/+usvHTx4UF27dnW02e12SZKbm5v27t2b5SqBw4cPV1hYmON+cnKyAgIC8qV+AAAAAAAA5E6uJzqPi4vTL7/8onPnzjm1p6ena/To0apZs6aKFy+uZs2aadGiRXkqxsPDQ0FBQYqKinK02e12RUVFKTg4OEv/OnXqaOfOndq+fbvj1q1bN3Xs2FHbt2/PNmzy9PSUt7e30w0AAAAAAADWyvWRUhMmTNBXX32lw4cPO7W//PLL+uCDD+Tj46P69evrjz/+0MMPP6yoqCi1a9fumgsKCwtTnz591Lx5c7Vs2VJTpkxRSkqKQkNDJUm9e/eWv7+/IiIi5OXlpQYNGjit7+PjI0lZ2gEAAAAAAFB45DqUWr16tbp27SoPDw9HW0JCgj788EPVq1dPa9askY+Pjw4dOqTg4GC98847eQqlevbsqYSEBI0ePVpxcXFq0qSJli5d6pj8PDY2Vi4uuT7ACwAAAAAAAIVQrkOpw4cPq3fv3k5tixcvlt1u1yuvvOI4QqlatWoKDQ3VzJkz81zU4MGDNXjw4GyXrVq16orrfvrpp3l+XAAAAAAAAFgj14ccXbhwQSVLlnRq+/XXX2Wz2dSpUyen9po1a+r06dP5UyEAAAAAAACKnFyHUtWrV9f27dud2lauXKlq1aplmVD83LlzKlu2bL4UCAAAAAAAgKIn16HUQw89pDlz5igyMlKHDx/WW2+9pUOHDumxxx7L0nf9+vWqUaNGvhYKAAAAAACAoiPXc0r93//9n77//ns9/vjjstlsMsaodu3aGjlypFO/kydPatGiRXr11VfzvVgAAAAAAAAUDbkOpUqUKKGNGzfq22+/1f79+1WtWjX16NFDXl5eTv2OHj2qsWPH6pFHHsn3YgEAAAAAAFA05DqUkiQ3Nzc9+uijV+zTqFEjNWrU6LqKAgAAAAAAQNGW6zmlAAAAAAAAgPxCKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADL3ZBQavHixXrmmWduxKYBAAAAAABQBNyQUOr333/XnDlzbsSmAQAAAAAAUARw+h4AAAAAAAAs55bbjjVq1Mj1RpOSkvJUDAAAAAAAAG4NuQ6lYmNj5e/vr0aNGl21b0xMjM6cOXM9dQEAAAAAAKAIy3UoVbduXfn4+Oj777+/at+33npLo0ePvq7CAAAAAAAAUHTlek6pli1bauvWrcrIyLiR9QAAAAAAAOAWkOsjpXr16iW73a6EhARVrFjxin27deumKlWqXHdxAAAAAAAAKJpyHUrdfffduvvuu3PVt2HDhmrYsGGeiwIAAAAAAEDRluvT9wAAAAAAAID8kutQasSIEdqxY8eNrAW4LlOnTlVgYKC8vLzUqlUrbdy4Mce+CxYsUPPmzeXj46MSJUqoSZMm+vzzzx3L09PT9dprr6lhw4YqUaKEKleurN69e+vYsWOOPgcPHlS/fv1UvXp1FStWTDVr1lR4eLjS0tKc+thstiy39evX35gnAQAAAACAm0SuQ6kJEyZo165djvsnT56Uq6urfv755xtSGHAtIiMjFRYWpvDwcG3dulWNGzdW586ddeLEiWz7ly1bViNHjtS6deu0Y8cOhYaGKjQ0VD/99JMk6fz589q6datef/11bd26VQsWLNDevXvVrVs3xzaio6Nlt9v18ccfa/fu3frPf/6jadOmacSIEVkeb8WKFTp+/LjjFhQUdGOeCAAAAAAAbhK5nlMqO8aY/KoDuC6TJ09W//79FRoaKkmaNm2afvjhB82aNUvDhg3L0r9Dhw5O94cOHao5c+ZozZo16ty5s0qXLq3ly5c79fnggw/UsmVLxcbGqmrVqurSpYu6dOniWF6jRg3t3btXH330kSZNmuS0brly5a56gQAAAAAAAG4lzCmFm15aWpq2bNmikJAQR5uLi4tCQkK0bt26q65vjFFUVJT27t2rdu3a5dgvKSlJNptNPj4+V+xTtmzZLO3dunVThQoVdMcdd2jRokVXrQkAAAAAgKLuuo6UAgqDxMREZWRkyM/Pz6ndz89P0dHROa6XlJQkf39/paamytXVVR9++GGOV5i8cOGCXnvtNT3++OPy9vbOtk9MTIzef/99p6OkSpYsqXfeeUdt27aVi4uLvvnmG/Xo0UPfffed06mAAAAAAADcaq4plDp48KC2bt0q6dIf9JK0b9++HI8cadas2fVVB9xApUqV0vbt23Xu3DlFRUUpLCxMNWrUyHJqX3p6uh577DEZY/TRRx9lu62jR4+qS5cuevTRR9W/f39Hu6+vr8LCwhz3W7RooWPHjmnixImEUgAAAACAW9o1hVKvv/66Xn/9dae2gQMHZulnjJHNZlNGRsb1VQfkgq+vr1xdXRUfH+/UHh8ff8V5nFxcXFSrVi1JUpMmTbRnzx5FREQ4hVKZgdShQ4f0888/Z3uU1LFjx9SxY0e1adNG06dPv2q9rVq1yjJfFQAAAAAAt5pch1KzZ8++kXUAeebh4aGgoCBFRUWpR48ekiS73a6oqCgNHjw419ux2+1KTU113M8MpPbt26eVK1eqXLlyWdY5evSoOnbsqKCgIM2ePVsuLlefpm379u2qVKlSrusCAAAAAKAoynUo1adPnxtZB3BdwsLC1KdPHzVv3lwtW7bUlClTlJKS4rgaX+/eveXv76+IiAhJUkREhJo3b66aNWsqNTVVS5Ys0eeff+44PS89PV2PPPKItm7dqsWLFysjI0NxcXGSpLJly8rDw0NHjx5Vhw4dVK1aNU2aNEkJCQmOejKP0JozZ448PDzUtGlTSdKCBQs0a9YsffLJJ5Y9NwAAAAAAFEZMdI4ioWfPnkpISNDo0aMVFxenJk2aaOnSpY7Jz2NjY52OYkpJSdHAgQN15MgRFStWTHXq1NEXX3yhnj17Srp0BFTmVfKaNGni9FgrV65Uhw4dtHz5csXExCgmJkZVqlRx6mOMcfz/uHHjdOjQIbm5ualOnTqKjIzUI488ciOeBgAAAAAAbho2c/lfz7eg5ORklS5dWklJSTleVQ3ArafGR+cKugTgivYPKFnQJeRK1+8eLOgSgCv6vse3BV1C7nxsK+gKgCt7/ub4s3JmnYUFXQJwRf2iuxd0Cfkit1nL1SfAAQAAAAAAAPIZoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALCcW0EXgPyVEtKqoEsArqjEig0FXQIAAAAAoBDgSCkAAAAAAABYjlAKAAAAAAAAliOUAgAAAAAAgOUIpQAAAAAAAGA5QikAAAAAAABYjlAKAAAAAAAAliOUAgAAAAAAgOUKZSg1depUBQYGysvLS61atdLGjRtz7LtgwQI1b95cPj4+KlGihJo0aaLPP//cwmoBAAAAAABwrQpdKBUZGamwsDCFh4dr69ataty4sTp37qwTJ05k279s2bIaOXKk1q1bpx07dig0NFShoaH66aefLK4cAAAAAAAAuVXoQqnJkyerf//+Cg0NVb169TRt2jQVL15cs2bNyrZ/hw4d9OCDD6pu3bqqWbOmhg4dqkaNGmnNmjUWVw4AAAAAAIDcKlShVFpamrZs2aKQkBBHm4uLi0JCQrRu3bqrrm+MUVRUlPbu3at27drdyFIBAAAAAABwHdwKuoDLJSYmKiMjQ35+fk7tfn5+io6OznG9pKQk+fv7KzU1Va6urvrwww919913Z9s3NTVVqampjvvJycn5UzwAAAAAAAByrVCFUnlVqlQpbd++XefOnVNUVJTCwsJUo0YNdejQIUvfiIgIjR071voiAQAAAAAA4FCoQilfX1+5uroqPj7eqT0+Pl4VK1bMcT0XFxfVqlVLktSkSRPt2bNHERER2YZSw4cPV1hYmON+cnKyAgIC8mcHAAAAAAAAkCuFak4pDw8PBQUFKSoqytFmt9sVFRWl4ODgXG/Hbrc7naJ3OU9PT3l7ezvdAAAAAAAAYK1CdaSUJIWFhalPnz5q3ry5WrZsqSlTpiglJUWhoaGSpN69e8vf318RERGSLp2O17x5c9WsWVOpqalasmSJPv/8c3300UcFuRsAAAAAAAC4gkIXSvXs2VMJCQkaPXq04uLi1KRJEy1dutQx+XlsbKxcXP53gFdKSooGDhyoI0eOqFixYqpTp46++OIL9ezZs6B2AQAAAAAAAFdR6EIpSRo8eLAGDx6c7bJVq1Y53X/zzTf15ptvWlAVAAAAAAAA8kuhmlMKAAAAAAAAtwZCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiOUAoAAAAAAACWI5QCAAAAAACA5QilAAAAAAAAYDlCKQAAAAAAAFiuUIZSU6dOVWBgoLy8vNSqVStt3Lgxx74zZszQnXfeqTJlyqhMmTIKCQm5Yn8AAAAAAAAUvEIXSkVGRiosLEzh4eHaunWrGjdurM6dO+vEiRPZ9l+1apUef/xxrVy5UuvWrVNAQIDuueceHT161OLKAQAAAAAAkFuFLpSaPHmy+vfvr9DQUNWrV0/Tpk1T8eLFNWvWrGz7f/nllxo4cKCaNGmiOnXq6JNPPpHdbldUVJTFlQMAAAAAACC3ClUolZaWpi1btigkJMTR5uLiopCQEK1bty5X2zh//rzS09NVtmzZG1UmAAAAAAAArpNbQRdwucTERGVkZMjPz8+p3c/PT9HR0bnaxmuvvabKlSs7BVuXS01NVWpqquN+cnJy3gsGAAAAAABAnhSqI6Wu14QJEzRv3jx9++238vLyyrZPRESESpcu7bgFBARYXCUAAAAAAAAKVSjl6+srV1dXxcfHO7XHx8erYsWKV1x30qRJmjBhgpYtW6ZGjRrl2G/48OFKSkpy3A4fPpwvtQMAAAAAACD3ClUo5eHhoaCgIKdJyjMnLQ8ODs5xvX//+98aN26cli5dqubNm1/xMTw9PeXt7e10AwAAAAAAgLUK1ZxSkhQWFqY+ffqoefPmatmypaZMmaKUlBSFhoZKknr37i1/f39FRERIkt5++22NHj1ac+fOVWBgoOLi4iRJJUuWVMmSJQtsPwAAAAAAAJCzQhdK9ezZUwkJCRo9erTi4uLUpEkTLV261DH5eWxsrFxc/neA10cffaS0tDQ98sgjTtsJDw/XmDFjrCwdAAAAAAAAuVToQilJGjx4sAYPHpztslWrVjndP3jw4I0vCAAAAAAAAPmqUM0pBQAAAAAAgFsDoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsRygFAAAAAAAAyxFKAQAAAAAAwHKEUgAAAAAAALAcoRQAAAAAAAAsV+hCqalTpyowMFBeXl5q1aqVNm7cmGPf3bt36+GHH1ZgYKBsNpumTJliXaEAAAAAAADIs0IVSkVGRiosLEzh4eHaunWrGjdurM6dO+vEiRPZ9j9//rxq1KihCRMmqGLFihZXCwAAAAAAgLwqVKHU5MmT1b9/f4WGhqpevXqaNm2aihcvrlmzZmXbv0WLFpo4caJ69eolT09Pi6sFAAAAAABAXhWaUCotLU1btmxRSEiIo83FxUUhISFat25dAVYGAAAAAACA/OZW0AVkSkxMVEZGhvz8/Jza/fz8FB0dnW+Pk5qaqtTUVMf95OTkfNs2AAAAAAAAcqfQHClllYiICJUuXdpxCwgIKOiSAAAAAAAAbjmFJpTy9fWVq6ur4uPjndrj4+PzdRLz4cOHKykpyXE7fPhwvm0bAAAAAAAAuVNoQikPDw8FBQUpKirK0Wa32xUVFaXg4OB8exxPT095e3s73QAAAAAAAGCtQjOnlCSFhYWpT58+at68uVq2bKkpU6YoJSVFoaGhkqTevXvL399fERERki5Njv7HH384/v/o0aPavn27SpYsqVq1ahXYfgAAAAAAAODKClUo1bNnTyUkJGj06NGKi4tTkyZNtHTpUsfk57GxsXJx+d/BXceOHVPTpk0d9ydNmqRJkyapffv2WrVqldXlAwAAAAAAIJcKVSglSYMHD9bgwYOzXfbPoCkwMFDGGAuqAgAAAAAAQH4qNHNKAQAAAAAA4NZBKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLEUoBAAAAAADAcoRSAAAAAAAAsByhFAAAAAAAACxHKAUAAAAAAADLFcpQaurUqQoMDJSXl5datWqljRs3XrH/119/rTp16sjLy0sNGzbUkiVLLKoUAAAAAAAAeVHoQqnIyEiFhYUpPDxcW7duVePGjdW5c2edOHEi2/5r167V448/rn79+mnbtm3q0aOHevTooV27dllcOQAAAAAAAHKr0IVSkydPVv/+/RUaGqp69epp2rRpKl68uGbNmpVt/3fffVddunTRq6++qrp162rcuHFq1qyZPvjgA4srBwAAAAAAQG4VqlAqLS1NW7ZsUUhIiKPNxcVFISEhWrduXbbrrFu3zqm/JHXu3DnH/gAAAAAAACh4bgVdwOUSExOVkZEhPz8/p3Y/Pz9FR0dnu05cXFy2/ePi4rLtn5qaqtTUVMf9pKQkSVJycvL1lF5opFzMKOgSgCvKuEnGmv3vcwVdAnBFycn2gi4hV9LPpxd0CcAV3TTfAf8u6AKAq7hJxtLfGecLugTgim6az6WryNwPY8wV+xWqUMoKERERGjt2bJb2gICAAqgGuAWVLl3QFQBFQumXC7oCoGgoLT6XgHzxEmMJyA8vFrGhdPbsWZW+wt+AhSqU8vX1laurq+Lj453a4+PjVbFixWzXqVix4jX1Hz58uMLCwhz37Xa7Tp06pXLlyslms13nHqAoSU5OVkBAgA4fPixvb++CLge4qTGegPzBWALyB2MJyB+MJeTEGKOzZ8+qcuXKV+xXqEIpDw8PBQUFKSoqSj169JB0KTSKiorS4MGDs10nODhYUVFR+te//uVoW758uYKDg7Pt7+npKU9PT6c2Hx+f/CgfRZS3tzdvsEA+YTwB+YOxBOQPxhKQPxhLyM6VjpDKVKhCKUkKCwtTnz591Lx5c7Vs2VJTpkxRSkqKQkNDJUm9e/eWv7+/IiIiJElDhw5V+/bt9c477+j+++/XvHnztHnzZk2fPr0gdwMAAAAAAABXUOhCqZ49eyohIUGjR49WXFycmjRpoqVLlzomM4+NjZWLy/8uGtimTRvNnTtXo0aN0ogRI3Tbbbfpu+++U4MGDQpqFwAAAAAAAHAVhS6UkqTBgwfneLreqlWrsrQ9+uijevTRR29wVbjVeHp6Kjw8PMvpngCuHeMJyB+MJSB/MJaA/MFYwvWymatdnw8AAAAAAADIZy5X7wIAAAAAAADkL0IpAAAAAAAAWI5QCgAAAAAAAJYjlMItx263y263F3QZwE2PsQTkH8YTkD8YS0D+YCzBKoRSuOW4uLjIxcVFJ06cUGJiYkGXA9y0MsdSXFyc/vzzz4IuB7ipMZ6A/JE5lg4fPqyoqCidOXOmoEsCbkp8LsEqhFK4pRhj9OOPP6pDhw6qWLGivvnmG34BAPIgPT1dc+bMUaNGjdSiRQv16tVLzz33nI4ePVrQpQE3HcYTkD8yx1Ljxo3VpEkTvfzyy2rVqpVWrFhR0KUBNxU+l2AlQincUv744w/Nnj1bQUFBatasmZYuXaqzZ88WdFnATcVut2vixIn64IMP1Lt3b61Zs0b9+vXTL7/8ojFjxkiSMjIyCrZI4CbBeALyz6effqrPPvtMTz75pPbs2aNvvvlG9evX16hRo5SWllbQ5QE3BT6XYDW3gi4AsJKPj4969eqlLl26KCoqSj179tT+/fvVtGnTgi4NuGnY7Xa5uLgoNDRUAwcOlCQNGjRIdrtd7777riTJ1dW1IEsEbhqMJ+D6ZY6j1q1bq379+mrVqpVcXFxUoUIF3XvvvXrjjTfk7u5e0GUCNwU+l2A1QikUaRcvXnScDy1J/v7+euihhyRJXbt2lZubm6KiotSoUSPeXIEruHwsubm56eWXX87yBf+PP/5Q3bp1lZKSohIlShRQpUDhx3gC8sfFixfl6urq+J7XsGFDp+WrVq3SzJkzNWHCBKWlpcnT07MgygQKPT6XUJA4fQ9FTkZGhuOQUjc3N7m4uCgpKUkXL16UdGleqcxDuB955BF9/fXXOnXqlGMZgEuyG0sXLlyQJLm7u8sYI2OMLl68KGOMtm3bpuDgYJUoUYKxBPwD4wnIH/8cSzabTSkpKU5zhCYkJOihhx7S3XffLWOMJkyYoB49emj//v0FVTZQ6PC5hMKCUApFgt1ud4ROrq6ucnV11YULF/TRRx+pfv366tmzpw4cOCBJstlscnO7dJDgiy++qM2bN2v37t2OZcCtLKexNG3aNNWqVUsjRoxwfGGx2WwyxsjNzU0rV65UXFyc+vfvL2MMYwkQ4wnIL1caS7Vr19YLL7zgdEVlb29vvfnmm0pISNDq1au1YMECHThwQFOmTGFuKdzS+FxCYcTpe7gp/fPN8PJT9BYuXKhp06bpt99+U2BgoHr27KnQ0FAFBAQ49TfGqGnTpvL399eSJUvUtm1bubu7KyMjg1P5cEvI7ktFTmOpevXqeuqpp9S/f395eXk5+meuHxERofvvv1/ly5e3bgeAQoTxBOSPzCMwcvM9r3r16nriiSfUr18/VahQwdHfw8ND9erVk3Tpj/DbbrtNDRo00PHjx/ljGrcMPpdwsyCUwk3BbrfLGOMIi2w2mxITE+Xr6yu73a7ExEQNHDhQv/32m9zc3NStWzeNGzdOzZs3d2xj586dql69ukqWLOnYpqurq/r166d58+bpjjvu0IYNG1SpUiUNHjy4QPYTuNEyD9N2dXV1fNFITk6Wt7e3jDE6dOiQhg8frpUrV8rd3T3bsXT06FFVrlxZNptNNptNUVFR+uOPP/Thhx9KkmJjY7V8+XL16dPHcVQiUBQxnoD8kd1YOn36tMqUKSO73a7jx4/rpZde0q+//prj97yYmBhVrVpVHh4eWQKtmJgYRUdH65577mHCcxRpfC7hZsTpe7gpuLi4yNXVVYmJifrtt9/0ySefqGbNmo5l58+fl6urq2bMmKHDhw9r6tSpat68ubZu3arnnntOJUuW1GuvvaYTJ044tmmz2XT48GFduHBBe/fuVY8ePfTTTz85flkDiqLMQ7VPnz6tLVu2aNy4cY7J/+12u9asWaOMjAx98sknWcbS888/L3d3d40fP16pqamSLv0KFxkZqaZNm2rnzp1q0aKFAgMDNWXKFCUlJRXkrgI3HOMJyB+ZY+nkyZPasGGD/vOf/zj9kfzXX3/JZrNl+z3v+eefV7FixRQeHu4YJ3///bdWrFihAwcOaPr06XrmmWdUvXp1DR8+vKB2EbAEn0u4KRmgEMnIyDAZGRlZ2hMSEkyPHj1MsWLFzAMPPGBatWplbDab2bBhQ5a+R48eNa+//rqpWbOmKVu2rHnsscfM4sWLzfnz55367du3z1SqVMn4+fmZ999/35w+ffpG7RZguYyMDGO327O0R0dHm44dOxofHx/z6KOPmho1apiqVauaQ4cOGWOMSU9Pd/TNbix9//33TmMpMTHR2Gw2Y7PZTGBgoAkPDzeJiYk3fgcBCzGegPyR01iKjY01Xbp0MSVLljTdu3c39evXNzabzezbt88YY8zFixcdfXPzPS81NdU89NBDpmrVqub22283EydONMnJyTd+BwGL8LmEooTj7VDgzGXnO2ee4/xPkZGR2rdvn1auXKmGDRtq7ty5OnjwoD766CO1bNlSdrtd+/fv13333aeEhAQ1adJEI0eOVNeuXeXr65vtNv39/bV582ZVrlzZ0Xb5Ia/AzcoYk+NYeu+995SRkaGNGzfKxcVF7777rj777DN9++23Gjp0qGw2m9auXavnnntOR44cUdOmTa86lmbPnq02bdrotttuc7QxllBUMJ6A/HGlsfTJJ5/o5MmTWrt2rfz8/PTJJ59owoQJjv8aY/T777+rV69eOn78+BXHkjFGHh4eGjVqlMqUKaPAwECnZcwphZsdn0soamzGcD1HFB67d+/WF198oTp16ujuu+92BEaPPPKIzp8/ryVLlki69Gb873//W2+99ZZOnTolNzc3nTp1SnPmzFHXrl1Vq1atXD+mMcYxuTlfVFBU7Nq1Sz/88IPatm2roKAgFStWTMePH1fXrl3VuXNnvfXWW5KkU6dO6fnnn9fJkyf1888/S5KWLVum33//XQ899JDjNNncYCyhqGI8Aflj165d+uabbxQUFKQ77rhDPj4+Sk1N1X333aeqVatq9uzZki6dfvd///d/+v7773Xw4EFJl+YGXbZsmXr06MFYwi2PzyUUJcwphRvCGKPc5J3GGCUnJ+vXX3/V3Llz9dBDD2nVqlV666239NBDDyk9PV0pKSlycXFRuXLlnNbt3Lmz0tPT9d1330mSypQpo5deeumaAinp0txSbm5uvLmiUMr8ApAbZ86c0a5du/Tpp5+qXbt2mjt3rnr37q2XXnpJknThwgWdPn1aderUcaxTtmxZtW3bVgcPHtTmzZslSSEhIXr11Vev+YsKYwmFHeMJyB/GGNntdsf/X0lSUpI2b96szz//XF26dNH333+vF198UX369HEsT01NVbVq1RzrFCtWTCEhITp58qRWrVolSapXr55efvnlaxpLEt/zULjxuQQQSiGfZX4xybxaw9XYbDZ99913at++vebMmaPZs2dr3bp1+vbbb7VlyxbNmjVLJUqUkL+/v86cOaM//vjDsZ63t7dKly6tyMhIp8cGioLML/s2m81xaPSRI0eu2H/kyJFq1KiRVq9erc2bN2vTpk16+eWXNX36dP3111+qXr26ihcvrm3btuns2bOOdWvUqKG4uDj9+OOPkvI2lviCgsKM8QTkL5vN5jh96Gqv1w8//FAtW7bUd999px9//FGbN2/W+++/r8WLF2vZsmWqUKGCypUrpwMHDujo0aOO9SpWrOiYZBkoavhcAv6HUAr5KvMN6/fff9dLL72kb7/9VpKu+AtA79695ePjo7///luNGzeWJNWvX1/du3fX/PnzdeHCBd1///2Ki4vT/PnzHevt3r1bxhgtXLhQZ8+ezfHcauBmlPl63rBhg5566im5uLgoIiJC6enpOfZ/7LHHVKJECfn4+Kh69ery8PBQv379VL9+fU2ZMkWS9PTTT2vJkiXatGmTY93o6Gh5enrqxx9/lN1uZ34AFDmMJyB/ZP4xu337dvXu3Vvdu3fXjBkzFBcXJ+l/f2hf7oknnpC3t7fc3NxUu3ZtSdIDDzygtm3bavr06ZIuTdOwbds2LV++3LHenj175O7uroULFzpOGQKKCj6XgP/hr3jkq7i4OA0cOFDdunXTRx99pFmzZknKeRK8zLDq7rvvVnp6us6fP+9Y9txzz2nLli3avHmzOnTooCeffFJjxozRwIEDNWzYMEVERGjixIny8/NznMKX3Zch4Gb022+/qUyZMrr77ruVlpam5cuXa+rUqXJ3d89xnQYNGqhmzZpKT0+XzWaT3W6Xl5eXnnzySX3zzTeSpGeffVZ169bV008/rffff1/h4eH65ZdfNGTIENntdq1du1YSRx6iaGE8AfnDZrNpw4YN6tGjh9LS0lSvXj2NHj1aTz/9tKTsL1hTrVo1BQUF6eLFi3Jzc3N8V3v++ee1bNkyHT16VA899JA6deqkAQMGaMyYMRo1apQ+//xzjR07VqVLl3Yc4cH3PBQVfC4Bl7mRl/bDrefcuXPmscceM1988YUZP368qVevnuNyvtldtjTzEr8rV6407u7uZv369U7Lq1WrZsaMGWP+/vtvY4wxM2fONI888ohp3bq1WbBggfnrr79M/fr1zb///e8bvGeAtdatW2dsNpvZtGmToy01NfWK69jtdjNu3DhTsWJFp/bo6Gjj5eVlli1bZowx5vjx4+a1114zQUFBpnHjxua3334zP/74owkICDAbNmzI/50BChjjCcg/Dz74oOnevbtJS0szxhizYcMG4+vrayIiInJcZ86cOaZ06dLm2LFjjrYLFy6YUqVKmU8++cQYc+kS92+//bbp1KmTCQoKMj/99JPZuHGjqVmzpvnvf/97Y3cKsBifS8D/EErhqjIyMnLVLzN0OnTokDHGmLVr15qWLVuaCRMmGGP+F0DlxNfX14wZM8akp6c72p5//nlTvXp1s3fv3mzXmTt3rqlcubLZunVrrmoEClJux1KmevXqmZdeesnMmTPH3HvvvaZ///7mo48+MklJScaY7IPebdu2GXd3d/Pzzz87PW6bNm3MPffc49T38rE2ZswYU716dXPixIlrqhEoKIwnIH/kdixl9qtZs6aZMmWKMeZ/4+bNN980AQEB5sCBA9mue/r0aVOqVCkze/Zsp/V69OhhGjVqZJKTkx19Lx+LU6dONf7+/uavv/66pn0CCgKfS0DeuBX0kVoo/DIPxd6xY4fOnj2rVq1ayc0t60sncz6pqlWrSpJuu+02NWzYUEuXLtVrr72W7Sl85v9fccLNzU1PPfWUFi1apOeee06VKlWSJA0dOlQVK1aUv7+/Y50FCxboxIkTjvOlX3jhBTVq1Cjf9xvIb5ljKXM+tHr16l1xLrTevXtr+PDhuuOOOxQcHKwzZ84oLCxMa9eu1fTp0+Xl5eXoa7fb5eLiottuu03t27fXzJkz1bFjR0f7kCFDtGfPHsfVUy5evKgFCxbo3LlzWrRokTZt2qSJEyeqfPnyN/x5APID4wnIH5nj5tixY/Lz88txygUXFxedPHlSdevW1Y4dOyTJMT/NgAEDNHr0aG3atEmBgYGOdTLHiI+Pj7p27aqvvvpKvXv3djzmK6+8oh9//FGenp6OdebNm6dz587phx9+0IYNGzRixAjVqFHjBu09kH/4XALyqODyMNwsfv75Z1OnTh3j4+Nj6tWrZx544AHHoZ9XO/ppxowZpnbt2mbdunXGmCv/grB7925js9nM8uXLs12e+WvBggULTOfOnc3zzz9vduzYkZddAgrEDz/8YGrWrGl8fHxMw4YNTe/evR1HFmY3No4cOWLeeOMNc+TIEUfbN998Y2rUqGFmzpxpjMl+DL733nvGZrNd9TDwSZMmmXr16pnnn3/e7Ny583p2DbAc4wm4fufOnTPTpk0zt912m6lXr55Zu3atMSb7IzSMuXTkxaBBg8xdd93lOLop82iM4OBg89xzz+W4/uLFi43NZjN//vlnttvOXOeTTz4xLVq04Hsebjp8LgF5YzOGWc6Qs5SUFPXt21fFixfXe++9p40bN+rf//63jh8/rl27duW4nvn/Kf3WrVsVFhamFi1aaOLEiY40P9Nvv/2ms2fPqlOnTnJ3d9ePP/6oe++9N8u2MmUm/9kdqQUUZomJiXrqqadUp04djRw5UitWrNDbb7+tKlWqaPHixTmul5aWJg8PD8eYSkxMVP/+/eXh4eF0mew1a9aoWrVqCggI0LFjx7Rx40b16NHDaVt2u102m81xVOPff/+tYsWK3ZD9BW4kxhOQP+bOnav33ntPNWvW1B9//KFnn31WgwYNyrZv5riZMWOGPv74Y40cOVIPPvig0tPT5e7urhEjRujHH3/Utm3bHH1/++03eXl5KSgoSBkZGfrxxx/1wAMPOG03cyxJl77nZY5T4GbC5xJwHQosDsNN4a+//jI2m83pl6odO3aYMmXKmKlTp151/fPnz5uwsDDTsmVLk5GRYRISEkx8fLxjeYMGDUyXLl2MMVc/6gq4ma1fv97YbDan+TYWLVpkypQpYxYsWGCMufKRhJm/ICclJZkaNWqYUaNGOfonJCSYUqVKmddff92pL1BUMZ6A/LFz507z5ZdfmuTkZHPvvfea3r17m1OnTmXbN3Ms7N2713Tv3t3cf//9jmUXL1403bt3N4899pi5cOGCo71KlSqmX79+jj5AUcXnEpB3OZ/kiluOMUYXL150ajty5IiqVKmilJQUSZcS+IYNG+qJJ57Qxx9/rLS0NMe6GRkZWbZZrFgxNWrUSEeOHFG7du1UoUIFTZ482bG8V69eKl68uCTlOIcBcLPJbiz9+eefatCggS5cuOBoa9eunTp06KB3333Xad1/XvI685cvY4wiIyNVokQJdevWzXHUoaenp7p3766yZctK+t/8bkBRwHgC8kd2Y6lBgwZ64oknVKpUKXXo0EH79u3Ttm3bJCnbsSNJt99+u5555hktW7ZMY8aMUUxMjDZs2KA9e/bosccek6enp6PvQw89pJIlS0riex6KDj6XgPxFKAVlZGQ43gwzT4s7efKkpEtvnFWqVNGWLVsk/e9N8Omnn9bOnTsVGxvraP/nl43ExES98cYbCgsL06lTpxQQEKBFixZpwoQJjm37+fmpT58+luwncKNlN5ZOnz4tSSpRooRcXFy0b98+R//SpUurZ8+e+u2333Tu3Dm5uLjIZrM5neK6Z88eTZs2TUOGDFGDBg00evRovfDCCwoKCnL0KVasmFxdXdW5c2eL9hS48RhPQP7IbiydPXtW0qU/hjN/VOzatatSU1O1bt06ScoyQfPl3/O6deumSZMmaenSperUqZPuuusu3XvvverUqZNjXbvdrtKlS+vRRx+94fsIWIHPJeDGIJS6hZjL5ma6/EuIq6urXFxcFBcXpzfeeEPVq1fXgAEDJEnNmzdXsWLF9Pvvvys1NdWR4tesWVNVqlTRihUrJEmpqamaO3euwsLCHI+Rnp6u3bt3a8KECUpJSdFXX33lmEcg8w392WefVbdu3ax6CoB8cflYysjIyHYsjRkzRnXr1tUbb7whSQoJCdHZs2e1Y8cOp1/Xbr/9dlWqVEk//vijpEvn/3/++eeKiIiQJJUtW1ZJSUk6fPiwXnnlFR09elQDBw50fKExxsjNzU2ffvqp6tata8n+A/mJ8QTkj2sZS+Hh4ZIuhUeZYVPdunVVq1Ytbdu2TYcPH3badkZGhubOnauXXnrJ0TZkyBAtW7ZMn3/+uc6fP68pU6bIx8fHsdzFxUVvvPGG2rZte6N2Gbgh+FwCrEUoVQRdfkioMcbxxnr5oZ6ZX0IuXryomTNnqnXr1rrtttv0008/6bXXXtOMGTMkXUr927Rpo+joaK1Zs8axnYyMDFWpUkXJycmSLr1J//XXX5oyZYrjjbhSpUqKjIxU//795eLi4vSmfvkvBJe/8QOFyeWvzZzGkqura7Zjafny5Ro6dKjjy4q3t7fuuOMO/frrr9q9e7dj/WLFiqlMmTJOj7ty5Uq98847unjxovz8/PTqq6/q22+/VWhoqGMsZVcLYwmFGeMJyB/5MZbGjh3rtM3M72ddunRRbGys4wj5zG0bY/TXX3/p3XffdfqD29vbW+3atXOMpX+elvTPeoHChM8loHAglCpCNmzYoK5du2rhwoWSLn3BuPwKDCtXrtTbb7/t6Jt5bvKkSZPUuXNnbd++Xb/99pteeOEFlSpVStu3b5ckPfjggypevLjeeecdx2Pt379fu3bt0p133ilJcnNz0zPPPKM///xTbm5uWX5hkP73pv5PnBeNwmbZsmV69NFHtXbtWknZj6VZs2ZJklatWqVu3bqpXLly2Y6lEiVKKDo6WpLUt29fnTp1StOnT3c8VkxMjGJiYtSoUSNJl768hIWFaePGjY6xlPnfy8dSduOGsYTCiPEE5I/8HksxMTGS5HRl5Pvuu08eHh5as2aNli1bpkGDBunEiRNyc3NT3759s/2elynzKJJ/YiyhsOFzCShc3Aq6AFw/8/8vIerp6anTp0/rt99+04MPPihXV1cdO3ZM0dHR2rRpk2bPnq0uXbpIktavX6+AgAD99NNPCg4Odmzrp59+0kcffaQVK1aoa9eu+uqrr9SsWTONGDFC9913n+666y41aNBAS5cu1SOPPKImTZo41vX393eqJxMTW+JmkfnadXd3165du7Rt2za1bdtWrq6uio2N1YkTJ/TNN9/oyy+/VL9+/SRd+mJTvnx5/fTTT2rdurVjW8uWLdMHH3ygNWvWqG/fvpo8ebI6duyooUOH6plnnlFCQoICAwP1zTffaNCgQapVq5Zj3QYNGjj+//LLZDOWcDNhPAH540aNpdDQUL3zzjuOICk1NVVnzpxRfHy8Jk+erPfff1/t2rVTamqqJCkgIMCpHuBmw+cSUEjlxyX8cOPZ7fZcXf7zxRdfNJ06dTJHjhwxxhgzcOBAU7lyZdO2bVuzcePGbNfZsWOHGTBggPHz8zOVK1c2AwYMMGvXrnVchjTzcTdt2mTeeustc//995sZM2Zc8bKmQGFlt9tz9dp94IEHzNNPP20SEhIc98uXL2+6du1q9u7dm+06VxtLmZYtW2ZeeeUV06lTJ/PJJ59waV/ctHL72cR4Aq6sMIyld955x9hsNtO2bVvz1VdfmYsXL17/jgEW43secPMhlCrkcvslJfPNcO7cuaZVq1Zm9uzZxhhj1q5da6pUqWJCQkIc28sUGRlp6tSpY0qXLm169OhhvvvuO3Pu3Llrrg+4GWRkZFzTWJo4caIJDg42P/74ozHm0hcMNzc307t3b2OM82t/+vTpplatWqZMmTK5Hkv/rIWxhJvJtX42MZ6A7BWGsZS57YSEBHPs2DGnZRcvXiScwk2B73nAzYs5pQq5zPObt23bpjFjxujHH3/UyZMnJTlPdpd56Ocdd9whX19f/fLLL5Kk4OBgNWzYUG5ubjp16pRsNptjgkp3d3e9+uqr2rt3r7799lt1795dJUqUuGpN5rJznjl8GzeLzMvwbtmyRU899ZQaNWqkHTt2ZOmX+Zru2rWr0tLStGnTJknS3XffrVq1asnLy0spKSlOY8nV1VVhYWHas2dPrsdS5pUsGUu4GV3+2fTvf/9b69evV0pKiiTni20wnoArKwxjKfP0vXLlyqlSpUpZrjbGKUW4GfA9D7h5EUoVcufPn9eLL76oDh06aOXKlRo6dKjuu+8+xcbGOr25Zf5/QECAGjVqpH379mnnzp2SpDvvvFPJycmOicsz+z744IN65pln5Ofnd001cc4zCjOTzeSrFy5c0NSpU1W5cmV17NhRycnJeu+99xyTTl4uc3zUrl1btWrV0vbt27V//35JUqdOnbRnzx4dOnTIqe8zzzyjAQMGMJZQ5Bhjsr2a1qlTp/TUU0+pffv2+vbbb/X444/rscce099//+000THjCbjkZhhLmesRRKEw++dYMsbwPQ+4yRFKFbDsvqBcbvPmzZo/f76WLl2q1atXa+nSpTp9+rRGjhypM2fOSPrfH+GZ27rzzjuVkZGhFStWSJLuv/9+XbhwQevXr5fExOMomjJf/9n9EhUTE6P3339ft99+u5KTk7Vo0SJ16NAhx23ldGnsp556Svv373f88sZYQlH0z192XVxcHJ8z6enpkqQ1a9Zo9erV2rBhg3799Vf997//1W+//aa33npL58+fd9oe4wm3KsYSkD+yG0sXL17UX3/9JZvNpujoaL7nATcxQqkClvkr2Lp16/T7779nWb5hwwZVqVJF9erVkyTVqFFDw4YNU3R0tBYuXCjpf3+MZ26rdevW8vf317p162S329WoUSPddttt2rFjh44cOSIp+6NJgJtZ5ut/xYoV+uyzzxy/ckmXrnJyzz33qFy5cjpy5Ii++eYbvf7664qKilJiYqIk54A4c1v33nuv3NzctGnTJhlj1Lp1a1WpUkVr1651hMJAUXP5L7vff/+92rZtq6ZNm0q6dNq3JC1evFiNGzfW/2vvzoOiOvI4gH+HGRiOUY5wmRJF0FKOuLigJkECaAJKImKiFdEUh0KxSrHKStwiaOJmNVkJeFQoiSZRUONRZiWIaFbZoJZKJVrJunEhrFySIgiSIKDLITO9f6Tmhcmgog5DBr+f/+jped1vit+bnt/r7jdu3DgoFApMnToVqampKC0txZkzZwDofzcxnuhxw1giMoy+sVRYWIjZs2fD1tYW77zzDgDAz8+P4zwiE8ak1BDq7u7Grl278NRTTyEwMBD79u1DV1cXgF8y+A0NDbCyspLWNAM/r3l2d3dHQUEBAN0svhAC9vb2CAgIQGNjI86fPw8AmD59Oi5evIgrV64A4LpmGl7a29uRlZUFNzc3JCQkIDc3F35+fti3bx96enoAAAEBAfj666/h4+ODjRs34ptvvsGiRYsQGRmJ1tZWvWUSQgi4uLjAz88P5eXlUuw899xzKCws1El6EQ0nP/30E1atWgWVSoX4+HhMmTIFe/bsAQDpu6i9vR1yuRyWlpZS2cKFC2FhYYGTJ08C+GXQz3iixxVjicgwKioqEBMTA5VKhcTERPj4+MDCwkK6aQ8A06ZN4ziPyEQxKTWEbty4gTNnzmDRokVYuHAhLl++LF0Atdn8sLAwXLp0CW1tbdL73Nzc4Ofnh8bGRtTV1QGA3iZ6QUFB6OjowJEjRwAAsbGxOHz4MGbPnm2s0yMymqNHj6KkpARvv/02qqurceLECSxZsgTvvPMOrl69CgAICQlBVFQUPvjgA5w7dw779u1DWVkZvvvuO2zdulVaJvHrWIqIiEBFRQVOnz4NAEhLS8PBgwfxu9/9zvgnSmQEly5dwvbt27Fq1Sq0tLQgJydH2pdDO6gPDQ3FhQsX0NvbC4VCAQDw9vaGp6cnampq0NTUBIDxRI83xhKRYeTk5KC7uxuFhYVobm5GdnY2vLy80NjYKNUJDg7mOI/IRDEpNQS0S+dsbW2xfPlypKenIzU1FRUVFdIaZu207qCgIJibm+PUqVM67/Xw8EBXVxcaGhoA/DJbqrKyEgDg7++PxYsXY/78+QAAe3t7/P73vzfSGRIZh3Zg4eDggOjoaCxZsgQymQx2dnZIT09HbW0trKysAABjxozBypUrsXDhQlhbW8PW1hbjx4/H0qVLUVxcLCV+tbGkTfjOmjUL8+bNw7PPPgsAcHJywjPPPGPkMyUafNqbIZMnT8aLL76I+vp6AMCWLVuwceNGfPnll9IP6cDAQLS3t0t7F2pneHh5eeH777+Xnh7GeKLHEWOJyDC047z3338fhw4dwqxZswAATU1NuHXrFhwcHKS6bm5uHOcRmSpBRqFWq8WdO3fuWWfKlCnij3/8o2hra5PeI4QQ8fHxwt/fX3z//fdS3TNnzgilUilu3Lghlf3lL38REyZMELW1tYY/AaLfiIHEkhBCHD9+XIwePVrU1NT0+3pvb68QQoiPPvpI2NraSvEmhBAJCQli5syZorm52TCdJvqN6i+e1Gq1yMnJETKZTIwePVqEhISI0NBQIZPJxJo1a6TvnfDwcBEeHi56enqk9x45ckSoVCopvoRgPNHjgbFEZBgDHee5urqK3Nxc6T2/xnEekengTKlBJIRAb28vhBAwMzOTpmVfvnxZuvMlhJCewBIZGYkLFy6gqqoKwC932tLT03H9+nVkZmaiubkZarUahw8fRlBQEJRKpTR7ytHRER4eHnB0dNR7Ih+RKRtILGnvpmn/5/ft24dp06Zh3Lhx/W7sL5fL0djYiF27dmH+/PnQaDTSHWpHR0dYWlrCyclJOp72+ESm7l7x1NHRATMzM0ybNg1paWn4+OOPcerUKZw4cQL5+fkoKipCfn4+AGDt2rU4e/Ys3n//fXR0dKC3txcHDx5EREQE1Gq1FDOMJxquGEtEhjGQcV5fzc3NGD16tLS8tT8c5xGZDialBoFarYZGo4FMJoNCoYBMJsOVK1eQnJyMJ554AsnJydKUUW0dAFiyZAl++OEHfP311wAAhUIBIQQmTJiArKwsHD16FFFRUfD29sahQ4eQmpqKESNGSO16eXnhp59+gkqlktZJ993Uj8jUPEgsyeVyaTBTWVmJs2fPYu3atQB0N/Y/duwYDh48iE2bNmHOnDkwNzdHeno6FAqFNKV7ypQpejHExwKTqRtIPGn3NfT29sbq1avxwgsvQKFQQKlU4tVXX4WXlxcuXryI27dvY8aMGcjIyEB2djaioqLw1FNPoaysDCkpKbCwsJBiiPFEww1jicgwHmSc15cQAi0tLXB1dQWg+3uH4zwi0yMT/U0hoAHRaDQQQtz1ItbS0oIdO3Zg7969uH79Op577jnExMTg5Zdf1ksWCSEgk8kwc+ZMuLm5YfPmzXjiiSfQ0dEhJZ7q6upQUlIChUKBJUuWSPtOEZk6Q8WSNo7WrVuHixcvorCwEEqlUue1Tz75BOvWrYOrqytiY2OxbNkyKTGs1dnZKe1FRWRqDPndpKVWqyGXyxEeHg5bW1scPHgQZmZmEEKgvLwcxcXFcHBwQGxsrN53E+OJTBVjicgwBiOWHBwckJOTg8WLF0Oj0Uj1Dhw4gIyMDI7ziEyJURYJPgYqKytFd3e3EEKI2tpaMWHCBGFnZyemT58ucnJydPZ+amlpEfv37xeNjY1SmXbd886dO4WXl5dYu3atmDt3rli+fPld2+y7z0BfGo3GEKdENCQeNZYaGhqEr6+vKCoqEkIIcfLkSZGQkCD27t0rhBCiq6tLtLa26rTZ314EQjCWyPQ9ajz1VVZWJjw9PcWWLVvu2Sa/m2g4YiwRGcajxJL2f7+qqkr4+fmJzZs365QLwXEekSliUuohaC9gdXV14rXXXhN2dnZi6tSpIiQkRHz77bdCiJ83Ha+oqNB5X35+vggKChIWFhYiKipKVFdXS6/duXNHlJaWikWLFgmZTCbs7e1FTEyMKC8v12v/bhdWIlMzGLGUlZUlbGxsRHJysnBxcRHW1tYiOjpa1NfX6xxDrVbfdcBPZIoMHU8dHR1i79694tixYyIlJUVMmDBBLF68WNy+fbvf9vndRMMFY4nIMAZjnCeEEPX19UImk4kjR47ctW2O84hMB5NSjyAxMVHMmzdPlJaWivr6erF48WIREREhLly4INUpLS0Vr7zyirC1tRUTJ04U69at07vwCiFEe3u78PDwEIGBgeLUqVPGPA2iIWfIWHr66aeFmZmZiIiIEAUFBUY8C6LfBkPG06pVq4S3t7eYM2eOKC4uNuZpEA05xhKRYRgyloT4OdGbmJgo6urqjHUKRDSIFPdf4Ef9+eqrr3Dp0iV8+umn8PDwwI8//ghzc3N8/vnnCAkJgaenJ0aPHg0XFxfMnj0bx44dw9NPP623pllrxIgR+O9//6uz1rq3txdmZmbcrJyGNUPFknafjh07dsDLy0tnLw7GEj0uDBVP2v050tPTkZWVpfPd1HfvDqLhirFEZBiG/s0EACqVCjt37jTiWRDRYGJS6iGVl5fj9u3bKCkpwfbt21FbW4vp06fjwIEDmDNnDkaMGIHCwkLMmDFD5wl59yKXy9Hb2wuZTAa5XH7PizHRcGGoWNIO9CdPngzgl0f7MpbocWKoeNL+UHZ2dgagG0/8EU2PA8YSkWEMxm8mLe0NSSIybXz63kP67rvv4OPjA29vbyxduhQLFiyAm5sbgJ8vkLdu3YKtra30xC8i6h9jichwGE9EhsFYIjIMxhIR3Q9v0TykUaNGYdKkSXjhhReQmpoqXVwbGhqwdetWlJWVAQAvrkT3wVgiMhzGE5FhMJaIDIOxRET3wzUtD8nW1hZpaWlYs2YNmpqakJSUhJqaGuzZswdCCISGhg51F4lMAmOJyHAYT0SGwVgiMgzGEhHdD5fvPaJPPvkE+/fvxw8//IDW1lbExMQgJSUFTk5OQ901IpPCWCIyHMYTkWEwlogMg7FERHfDpJQBdHV1obW1FaNGjZLKuC6a6MExlogMh/FEZBiMJSLDYCwRUX+YlDKw3t5eyOVyXlyJHhFjichwGE9EhsFYIjIMxhIRaTEpRURERERERERERsen7xERERERERERkdExKUVEREREREREREbHpBQRERERERERERkdk1JERERERERERGR0TEoREREREREREZHRMSlFRERERERERERGx6QUEREREREREREZHZNSRERERAZ29epVhIWFwdbWFjKZDJ999hny8vIgk8lQV1c31N17aKdPn4ZMJsPp06eHuitEREQ0DDApRURERMNWdXU1kpKS4OHhAUtLS4wcORKBgYHYtm0bOjs7B63d2NhYfPvtt9i4cSP27t2LgICAQWtrMGzfvh15eXlD3Q0iIiIa5mRCCDHUnSAiIiIytOLiYixcuBBKpRIxMTHw9fVFT08Pzp07h7///e+Ii4vDzp07Dd5uZ2cnrK2tkZGRgQ0bNkjlarUad+7cgVKphEwmM3i7huTr6wtHR0e9GVEajQY9PT2wsLCAmRnvbRIREdGjUQx1B4iIiIgMrba2FosWLcLYsWPxxRdfYNSoUdJrycnJqKqqQnFx8aC0fePGDQCAnZ2dTrlcLodcLh+UNu9FCIGuri5YWVk98rHMzMxgaWlpgF4RERERcfkeERERDUOZmZm4desWPv74Y52ElNb48eOxcuVKAEBvby/++te/wtPTE0qlEu7u7njjjTfQ3d2t8x53d3e89NJLOHfuHKZNmwZLS0t4eHhgz549Up3169dj7NixAIDXX38dMpkM7u7uANDvnlIajQbr16/Hk08+CWtra4SGhqK8vBzu7u6Ii4vTOW5/s6v6O6a2n//4xz8QEBAAKysr7NixAwCwe/duzJw5E87OzlAqlfD29kZubq7eef7nP//BmTNnIJPJIJPJEBISAuDue0odPnwY/v7+sLKygqOjI1577TU0NDTo1ImLi4NKpUJDQwOioqKgUqng5OSEtLQ0qNVqvXMjIiKi4Y8zpYiIiGjYKSoqgoeHB5599tn71k1ISEB+fj4WLFiA1atX48svv8S7776LiooKFBQU6NStqqrCggULsGzZMsTGxmLXrl2Ii4uDv78/fHx88PLLL8POzg6pqamIjo5GREQEVCrVXdtOT09HZmYm5s6di/DwcFy+fBnh4eHo6up6pPOvrKxEdHQ0kpKSkJiYiIkTJwIAcnNz4ePjg8jISCgUChQVFWHFihXQaDRITk4GAGzduhUpKSlQqVTIyMgAALi4uNy1rby8PMTHx2Pq1Kl499130dTUhG3btuH8+fP45ptvdGaMqdVqhIeHY/r06cjKykJJSQmys7Ph6emJ5cuXP9I5ExERkQkSRERERMNIW1ubACDmzZt337r/+te/BACRkJCgU56WliYAiC+++EIqGzt2rAAgzp49K5U1NzcLpVIpVq9eLZXV1tYKAOK9997TOebu3bsFAFFbWyuEEOL69etCoVCIqKgonXrr168XAERsbKxU9tZbb4n+hm2/Pmbffn7++ed69f/3v//plYWHhwsPDw+dMh8fHxEcHKxXt7S0VAAQpaWlQgghenp6hLOzs/D19RWdnZ1SvWPHjgkA4s0335TKYmNjBQDx9ttv6xxzypQpwt/fX68tIiIiGv64fI+IiIiGlfb2dgDAiBEj7lv3+PHjAIA//elPOuWrV68GAL19p7y9vREUFCT97eTkhIkTJ6KmpuaB+/nPf/4Tvb29WLFihU55SkrKAx/r18aNG4fw8HC98r77SrW1taGlpQXBwcGoqalBW1vbA7dz6dIlNDc3Y8WKFTp7Tb344ouYNGlSv/t2/eEPf9D5Oygo6KE+PyIiIjJ9TEoRERHRsDJy5EgAQEdHx33rXrt2DWZmZhg/frxOuaurK+zs7HDt2jWd8jFjxugdw97eHq2trQ/cT+2xf922g4MD7O3tH/h4fY0bN67f8vPnz+P555+HjY0N7Ozs4OTkhDfeeAMAHioppT0H7fLAviZNmqT3+VlaWsLJyUmn7GE/PyIiIjJ93FOKiIiIhpWRI0fiySefxJUrVwb8nv42Ee/P3Z6eJ4QYcFsP4279u9sG4f09aa+6uhqzZs3CpEmTsHnzZri5ucHCwgLHjx/Hli1boNFoDNrn/gzF0weJiIjot4szpYiIiGjYeemll1BdXY2ysrJ71hs7diw0Gg2uXr2qU97U1ISbN29KT9IbDNpjV1VV6ZT/+OOPejOHtDOnbt68qVP+65lI91JUVITu7m4cPXoUSUlJiIiIwPPPP99vAmugSTrtOVRWVuq9VllZOaifHxEREZk+JqWIiIho2FmzZg1sbGyQkJCApqYmvderq6uxbds2REREAPj5iXN9bd68GcDPeyMNllmzZkGhUCA3N1enPCcnR6+up6cnAODs2bNS2e3bt5Gfnz/g9rSzlPrO6mpra8Pu3bv16trY2OglwPoTEBAAZ2dnfPDBB+ju7pbKT5w4gYqKikH9/IiIiMj0cfkeERERDTuenp7Yv38/Xn31VXh5eSEmJga+vr7o6enBhQsXcPjwYcTFxWHlypWIjY3Fzp07cfPmTQQHB+Orr75Cfn4+oqKiEBoaOmh9dHFxwcqVK5GdnY3IyEjMnj0bly9fxokTJ+Do6KgzWyksLAxjxozBsmXL8Prrr0Mul2PXrl1wcnJCfX39gNoLCwuDhYUF5s6di6SkJNy6dQsffvghnJ2d0djYqFPX398fubm52LBhA8aPHw9nZ2fMnDlT75jm5ubYtGkT4uPjERwcjOjoaDQ1NWHbtm1wd3dHamrqo31IRERENKwxKUVERETDUmRkJP7973/jvffeQ2FhIXJzc6FUKjF58mRkZ2cjMTERAPDRRx/Bw8MDeXl5KCgogKurK9LT0/HWW28Neh83bdoEa2trfPjhhygpKcEzzzyDkydPYsaMGTpPszM3N0dBQQFWrFiBdevWwdXVFatWrYK9vT3i4+MH1NbEiRPx6aefYu3atUhLS4OrqyuWL18OJycnLF26VKfum2++iWvXriEzMxMdHR0IDg7uNykFAHFxcbC2tsbf/vY3/PnPf4aNjQ3mz5+PTZs2wc7O7qE/GyIiIhr+ZGKwd+YkIiIiogG7efMm7O3tsWHDBmRkZAx1d4iIiIgGDfeUIiIiIhoinZ2demXa/a1CQkKM2xkiIiIiI+PyPSIiIqIhcujQIeTl5SEiIgIqlQrnzp3DgQMHEBYWhsDAwKHuHhEREdGgYlKKiIiIaIhMnjwZCoUCmZmZaG9vlzY/37Bhw1B3jYiIiGjQcU8pIiIiIiIiIiIyOu4pRURERERERERERsekFBERERERERERGR2TUkREREREREREZHRMShERERERERERkdExKUVEREREREREREbHpBQRERERERERERkdk1JERERERERERGR0TEoREREREREREZHRMSlFRERERERERERG938L/kwprTF+2gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tuning plot saved to /home/user/hyperparameter_tuning.png\n" + ] + } + ], + "source": [ + "# Plot hyperparameter tuning results\n", + "plot_tuning_results(results_list, save_path='/home/user/hyperparameter_tuning.png')" + ] + }, + { + "cell_type": "markdown", + "id": "a4dd5073-dfa8-4672-81cd-97b89e67367e", + "metadata": {}, + "source": [ + "## Step 7: Best Model Evaluation\n", + "\n", + "We retrain using the best configuration found during tuning (epoch=75, lr=0.5, wordNgrams=2)\n", + "and generate a detailed classification report and confusion matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d5db49f3-3d30-4016-b0a3-c5bed2ddbaec", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Read 2M words\n", + "Number of words: 38526\n", + "Number of labels: 20\n", + "Progress: 100.0% words/sec/thread: 873661 lr: -0.000134 avg.loss: 0.878564 ETA: 0h 0m 0s" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best Model Results:\n", + "Precision: 0.6216\n", + "Recall: 0.6216\n", + "F1-Score: 0.6216\n", + "Training time: 7.75 seconds\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Progress: 100.0% words/sec/thread: 873564 lr: 0.000000 avg.loss: 0.878564 ETA: 0h 0m 0s\n" + ] + } + ], + "source": [ + "# Train the best model\n", + "best_model, best_train_time = train_fasttext_model(\n", + " '/tmp/train.txt',\n", + " epoch=75,\n", + " lr=0.5,\n", + " word_ngrams=2,\n", + " min_count=2,\n", + " verbose=2\n", + ")\n", + "\n", + "best_results = evaluate_model(best_model, '/tmp/test.txt')\n", + "print(f\"Best Model Results:\")\n", + "print(f\"Precision: {best_results['precision']}\")\n", + "print(f\"Recall: {best_results['recall']}\")\n", + "print(f\"F1-Score: {best_results['f1']}\")\n", + "print(f\"Training time: {best_train_time:.2f} seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "25483f3d-3b12-4bc2-9a0c-22409296a749", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " alt.atheism 0.44 0.44 0.44 319\n", + " comp.graphics 0.60 0.65 0.62 389\n", + " comp.os.ms-windows.misc 0.61 0.58 0.59 394\n", + "comp.sys.ibm.pc.hardware 0.59 0.59 0.59 392\n", + " comp.sys.mac.hardware 0.66 0.58 0.62 385\n", + " comp.windows.x 0.86 0.63 0.73 395\n", + " misc.forsale 0.77 0.76 0.77 390\n", + " rec.autos 0.44 0.71 0.54 396\n", + " rec.motorcycles 0.77 0.59 0.67 398\n", + " rec.sport.baseball 0.77 0.67 0.72 397\n", + " rec.sport.hockey 0.84 0.82 0.83 399\n", + " sci.crypt 0.71 0.65 0.68 396\n", + " sci.electronics 0.50 0.54 0.52 393\n", + " sci.med 0.62 0.69 0.65 396\n", + " sci.space 0.72 0.66 0.69 394\n", + " soc.religion.christian 0.60 0.70 0.65 398\n", + " talk.politics.guns 0.52 0.60 0.56 364\n", + " talk.politics.mideast 0.71 0.67 0.69 376\n", + " talk.politics.misc 0.43 0.39 0.41 310\n", + " talk.religion.misc 0.34 0.30 0.32 251\n", + "\n", + " accuracy 0.62 7532\n", + " macro avg 0.63 0.61 0.61 7532\n", + " weighted avg 0.64 0.62 0.62 7532\n", + "\n" + ] + } + ], + "source": [ + "# Get detailed classification report for the best model\n", + "predicted_labels_best = get_predictions(best_model, test_data.data, clean_text)\n", + "print(classification_report(true_labels, predicted_labels_best, zero_division=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "22f0f7d3-5265-40fb-a378-a65be4a08318", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Confusion matrix saved to /home/user/confusion_matrix_best.png\n" + ] + } + ], + "source": [ + "# Plot confusion matrix for best model\n", + "plot_confusion_matrix(\n", + " true_labels,\n", + " predicted_labels_best,\n", + " test_data.target_names,\n", + " title='Confusion Matrix - FastText Best Model (epoch=75, lr=0.5, ngrams=2)',\n", + " save_path='/home/user/confusion_matrix_best.png',\n", + " cmap='Greens'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "843f847d-c22a-4ab9-a7cb-2faf868a34d7", + "metadata": {}, + "source": [ + "## Step 8: Error Analysis\n", + "\n", + "We analyze which categories the model struggles with most and why." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e58637b5-3226-449d-811c-ef1ae4629c97", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 10 Most Common Misclassifications:\n", + "--------------------------------------------------\n", + " 88 times: talk.politics.misc → talk.politics.guns\n", + " 55 times: rec.motorcycles → rec.autos\n", + " 51 times: talk.religion.misc → soc.religion.christian\n", + " 45 times: comp.windows.x → comp.graphics\n", + " 44 times: talk.religion.misc → alt.atheism\n", + " 42 times: alt.atheism → talk.religion.misc\n", + " 41 times: alt.atheism → soc.religion.christian\n", + " 40 times: comp.os.ms-windows.misc → comp.sys.ibm.pc.hardware\n", + " 40 times: comp.sys.mac.hardware → comp.sys.ibm.pc.hardware\n", + " 36 times: comp.sys.ibm.pc.hardware → comp.os.ms-windows.misc\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAA2YlJREFUeJzs3XdYFFf7N/DvItJ7BwtoRAGlSDFWWEuCjdgSaxCwx96VJypgiWjUiDEaY0ONvRsbKgIqKqKIiiIqihU7gpiIlHn/8N35sbBUzWKS7+e69nqyM2fO3HPmDE/2zjlnJIIgCCAiIiIiIiIiIlIilaoOgIiIiIiIiIiI/nuYlCIiIiIiIiIiIqVjUoqIiIiIiIiIiJSOSSkiIiIiIiIiIlI6JqWIiIiIiIiIiEjpmJQiIiIiIiIiIiKlY1KKiIiIiIiIiIiUjkkpIiIiIiIiIiJSOialiIiIiIiIiIhI6ZiUIiIiIqJ/vejoaEgkEgQHB//t57KxsYGNjc3ffp6KKO36jxw5ghYtWsDQ0BASiQRdu3YFAEilUkgkEuUGWgqJRAKpVFrVYdA/VHh4OCQSCcLDwz+oHvZDoo+LSSkiIiKiT4BEIqnQpyqcOHECEydOROvWraGvrw+JRAJ/f/9SjykoKMDPP/8MR0dHaGpqwtTUFH369MHt27crdG7Zdaurq+PFixcKy2RkZEBTU7NK2+ifJi0tDV26dMHt27cREBCAoKAg9O7du0pi+dSSYFUpODi42DNfrVo1mJiY4Msvv8TevXuVFktaWlq5nvWSjpNIJLCwsEBeXp7CcsnJyWK5Ty2ZS0R/P9WqDoCIiIiIgKCgoGLbFi9ejMzMTIX7qsKaNWuwbt06aGlpoXbt2sjKyirzmKFDh2LVqlVo2LAhRo8ejUePHmHbtm04cuQIzp49C1tb23KfX1VVFe/evcPGjRsxevToYvs3btyIt2/fQlVVtdgP4CZNmiA5ORkmJiblPt+/SUnXf+zYMbx9+xYLFy5E37595fatX78ef/75pzLDLFVycjK0tLSqOgyl6tGjBxo1agQAePfuHVJTU7Fv3z4cPXoUS5cuxYgRI6o4wrKpqqriyZMnOHjwIL766qti+1evXg0VFY6VIPqvYlKKiIiI6BOgaFpVeHg4MjMzlTLlrDxGjhyJSZMmwc7ODvHx8WjWrFmp5aOiorBq1Sp4enri6NGjUFNTAwD07dsXHTt2xMiRIxEREVHu83/22WcQBAFr165VmJRas2YNGjRoAABISUmR26elpQU7O7tyn+vfpqTrf/ToEQDAysqq2L7atWv/7XFVxH/x/n399dfFRq7Fx8ejSZMmmDdv3j8iKdW8eXNcunQJa9asKZaUysvLw++//4527dohJiamiiIkoqrElDQRERHRP8zz588xduxY1KlTB+rq6jAzM0PPnj2RlJRUrKy/vz8kEglu376N+fPnw9bWFhoaGqhTpw5mzpyJ3Nzccp/X3d0dDRs2RLVq1cpVfuXKlQCAWbNmiQkpAOjQoQOkUimOHDmCe/fulfv8ABAQEIDExEQkJCTIbb906RIuXryIgIAAhceVtKbSzZs3ERAQILalkZERnJ2dMXbsWAiCIFf29evXCAkJgZOTE7S0tKCvr4/GjRtj+vTpZbbjo0ePEBQUhKZNm8LMzAzq6uqwsbHB8OHD8fTp02LlMzMzMWPGDDg4OEBHRwd6enqoV68e/Pz8cPfuXbGcbJSTs7Mz9PX1oa2tDRsbG/Ts2ROXLl0q8fplU6tko/Bat24tTqGKjo4GUPp0ur179+LLL7+EsbExNDQ0YGNjA19fX7k+eOPGDUyePBmurq5iufr162Pq1KnIzs6Wq08ikYhJicJT1gpPGStpLZ/KPA937tzBkiVLYGdnB3V1dVhbWyMkJAQFBQVy5QsKCrBq1So0adIERkZG0NTURM2aNeHj4yO2k7J5eHjAyMgIz58/V7j/xIkT8PHxgYmJCdTV1WFra4tp06YpHPW2c+dOeHl5wczMDBoaGrCyskK7du2wc+dOAO8T43Xq1AEArFu3Tu7elPf6NTU10bt3bxw4cKBYX9+/fz+ePHmCAQMGlHj8mzdvEBQUBDs7O2hoaMDIyAidOnVCbGyswvIvX77EsGHDYG5uDi0tLXh4eGD37t2lxnj58mX07t0blpaWUFNTg7W1NUaNGlXiVGEi+ng4UoqIiIjoH+TZs2do1qwZUlNTIZVK0bt3b9y5cwc7duzAgQMHEBERgZYtWxY7buzYsYiNjUXPnj2ho6ODP/74A0FBQbh8+TJ27Njxt8QaHR0NbW1ttGjRotg+b29vREdHIyYmBr6+vuWu08/PD9OmTcPatWvh6uoqbl+9ejWqVauG/v37Y+3ateWq69GjR2jSpAnevHmDTp06oVevXnjz5g1u3ryJZcuWYcGCBVBVff+vy0+fPoWXlxeuX78OFxcXfPfddygoKMD169cxb948TJgwAQYGBiWe68SJE1i4cCHatm2Lzz//HNWrV8fFixexfPlyREREICEhAfr6+gAAQRDg7e2NuLg4tGjRAu3bt4eKigru3r2Lffv2wdfXF9bW1mJ7bNu2DU5OTggICIC6ujru37+PqKgoxMfHw9nZWWE8BgYGCAoKEu+Bn5+fuJ5PWev6TJgwAYsWLYKRkRG6du0KMzMz3L9/H8eOHYObm5s43WzXrl1YvXo1WrduDalUioKCApw9exbz5s1DTEwMTpw4gerVqwN4P301PDwcd+/elZuu6uLiUmoslX0eJk2ahJiYGHTu3Bne3t7Ys2cPgoOD8e7dO8yZM0csFxgYiPnz5+Ozzz5D3759oauri4cPH+LUqVM4duxYlSx4feHCBbx8+VLhc7V8+XKMGDECBgYG8PHxgZmZGc6fP485c+YgKioKUVFRYoJ4+fLlGD58OCwtLdGtWzcYGxvj8ePHOHfuHHbv3o0ePXrAxcUFY8aMQVhYGJydncVF8IGy+0lhAwYMwIoVK7BhwwZMmDBB3L5mzRqxHyny9u1btGnTBufOnYOrqyvGjh2LJ0+eYOvWrYiIiMDmzZvxzTffiOX//PNPSKVSXLlyBc2aNYOXlxfu37+PXr164csvv1R4jn379qFnz55QUVFBly5dUKtWLVy7dg1Lly5FREQE4uLiYGhoWO5rJaIKEoiIiIjok2RtbS0U/de1gIAAAYAQGBgot/3AgQMCAKFevXpCfn6+uN3Pz08AIJiamgr3798Xt+fk5Aienp4CAGHHjh0Vju3MmTMCAMHPz0/h/uzsbAGA0KhRI4X7d+zYIQAQpk+fXq7zARAaNGggCIIgdO7cWTAyMhLevn0rCIIgvH37VjAyMhJ8fHwEQRCEBg0aFGu3qKgoAYAQFBQkbluyZIkAQFi8eHGx87148ULue48ePQQAwv/+979iZR8/fizk5uaK362trQVra2u5Mk+ePBFev35d7Nh169YJAITZs2eL2y5fviwAELp27Vqs/Nu3b8V6Xr16JUgkEsHNzU3Iy8uTK5eXlydkZGSUev2CIAhBQUECACEqKqrYuby8vIq14x9//CEAEBwdHYXnz5/L7cvNzRUeP34sfn/w4IGQk5NTrN6QkBABgPD777+Xeb7CAAheXl5y2yr7PNSpU0d49OiRuP3Zs2eCgYGBoKurKxezkZGRYGVlJbx586ZYPEX7yMckuy89evQQgoKChKCgICEwMFDo3bu3oKWlJdStW1dITEyUO+bq1auCqqqq4OzsXOzezJ07VwAgLFiwQNzm6uoqqKmpCU+ePCl2/sLH37lzp9RnvSSy47y9vQVBEIRGjRoJDRs2FPenp6cLqqqqwqhRowRBEAR1dfViz42sr/Tr108oKCgQtyckJAhqamqCgYGBkJWVJW6XtdvgwYPl6jl8+LAAQAAgrF27Vu469fT0hBo1aghpaWlyx2zevFkAIIwcOVJuu6J+SESVx+l7RERERP8Q7969w+bNm2FsbIxp06bJ7evYsSO++OIL3Lp1S+G0ljFjxqBmzZridzU1NXFEyIe+Il2RzMxMABBH/xSlp6cnV64iBgwYgJcvX2LPnj0AgD179uDly5elTgEqjaamZrFtRkZG4j8/fvwYu3btwmeffaZwfS9zc3NxRFVJzMzMoKOjU2y7r68v9PT0cOzYsXLFpa6uLtYjkUggCAI0NDSKLRRdrVq1UkduVdayZcsAAGFhYTA2Npbbp6qqCnNzc/F7jRo15KZtyowcORIAFF5zRXzI8zB9+nRYWlqK301MTNClSxe8fv262HpkampqCqesFu4jf5edO3ciJCQEISEhmDt3LrZs2QKJRII+ffqgXr16cmVXrFiBvLw8/Pzzz8XuzeTJk2FqaorNmzfLba9evbo4Wq2wosd/DAMGDMDVq1cRFxcH4P10wLy8vFKf23Xr1qF69eoIDQ2Vm0rauHFj+Pn54dWrV+LfAeD94vxqamqYOXOmXD3e3t5o27ZtsfrXr1+PrKwszJ07Vxx9KNO7d2+4urpiy5YtlblcIionTt8jIiIi+oe4fv063r59i9atWyt8C1nr1q1x9OhRJCYmolWrVnL7in4HgGbNmkFVVRUXL17822L+O3Tu3BlmZmZYs2YNevXqhTVr1sDMzAydO3euUD0+Pj4IDAzEiBEjEBkZifbt28PLywt169aVK3f+/HkIgoDWrVsr/AFfXrt27cKKFSuQkJCAjIwM5Ofni/tkC44DgL29PZycnLB582Y8ePAAXbt2hVQqhYuLi1zySU9PDx07dsTBgwfh6uqKb775BlKpFB4eHh8UZ2nOnTsHdXV1eHl5lVlW+P+L0oeHhyMpKQmZmZlyazYVvubK+JDnwc3NrVh5WdL21atX4rbevXtj2bJlaNSoEXr37o3WrVujWbNmChOGioSHhyMtLU1uW9euXcucliizefNmcaHzvLw8PHz4EOHh4QgJCcHRo0cRGxsrJkTPnj0LAIiIiEBkZGSxuqpXr47r16/LXdvkyZPRqFEj9O3bF61bt0bLli3FhPHH9u2332LKlClYs2YNPv/8c6xduxaNGzcusS2ysrJw+/Zt2NvbyyXUZVq3bo2VK1ciMTERvr6+yMrKwp07d+Dg4AALC4ti5Vu1alWsXWRtFhcXh9TU1GLHvH37Fs+fP8fz58//s2/uJPq7MSlFRERE9A+RlZUFAHKjUQqTjfyQlStM0THVqlWDsbFxpUYrlUU2QqqkumUxljSSqjTVq1fHt99+i8WLF+P06dM4duwYxo0bV+ZopaJsbGxw9uxZBAcH4+DBg9i2bRuA9295mzlzprhWjewaatSoUeFYZRYuXIiJEyfC1NQUX375JWrWrCkmNhYvXoycnByxrKqqKo4fP47g4GDs3LlTXIPH1NQUI0eOxPfffy+O3Nm+fTt++OEHbNq0Cd9//z2A98mqgIAA/PDDDwqTNR8iMzMTNWrUKDYyS5HRo0dj6dKlqFWrFr766itYWlpCXV0dABASEiJ3zZXxIc+DosSLrP8UThaGhYWhTp06WLt2LWbPno3Zs2dDQ0MDPXv2xMKFC8tMVISHhxd7q5yNjU25k1JF47O2tkZQUBBu3ryJjRs3YuvWrejXrx+A9wt8A5BbE6s0EydOhLGxMZYvX46FCxeKa6h16tQJP/30k7jA+cdiamoKHx8fbNmyBd988w1SUlLw888/l1i+ovdX9r9mZmYKyyuqR9Zmv/zyS6mxv3nzhkkpor8Jp+8RERER/UPIfkg/efJE4f7Hjx/LlStM0TH5+fl48eJFpRJDZdHW1oalpSXu3Lkj9yNf5ubNmwAAW1vbStU/cOBAFBQUoGfPnigoKMDAgQMrVU+jRo2wY8cOvHz5EmfOnMGMGTPw+PFj9OrVS5z2JZsG9/Dhw0qdIy8vD7NmzYKlpSWSkpKwceNGzJs3D8HBwQgKCsK7d++KHWNsbIyff/4ZDx8+FBddNjIyQlBQEObPny+W09LSwuzZs3H79m3cvn0bq1evRoMGDRAWFoZx48ZVKt7SGBgY4PHjx8XeUlfU06dP8csvv8DJyQnXr19HeHg45s6di+DgYAwbNuyjxPIhz0N5qaqqYuLEibh69SoePnyITZs2oVWrVli/fr2YDCpNdHQ0BEGQ+xR+o2Blff755wCA+Ph4cZvsOrOysoqds/BHRiKRYMCAAYiPj8ezZ8+we/dudO/eHXv37kXnzp0VPrcfauDAgcjKyoK/vz80NDRKbcOK3l/Z/yp6m2VJ9ciOuXLlSqltVnRqHxF9PExKEREREf1DyF6JHh8fr/D17rJXtCsahXHy5Mli286cOYO8vDw0btz4Y4cKAPDy8sKbN28UrukTEREBAPD09KxU3Q4ODvj888/x8OFDNG3aFPb29h8Ua/Xq1dG0aVOEhIRgyZIlEAQB+/fvBwC4u7tDRUUFUVFRyM3NrXDdz58/R2ZmJpo1a1ZsFMf58+fx119/lXisRCKBvb09RowYgaNHjwJ4/7YwRerUqYMBAwYgJiYGOjo6JZb7EE2aNEFOTk6x0T9F3b59G4IgoF27dsVGaynqiwDE0V/lTYZ8yPNQGVZWVujTpw8OHz6MevXq4dixY6Xeu79TRkYGAMglB2WJKtmUtIowNjZG165dsXXrVrRp0wbXrl3DrVu3AFT8vpTG29sbNWrUwMOHD9G1a9dS32qnp6eHunXr4tatWwoTwkXvr56eHurUqYNbt26JCavCFPU7WZudOXOmEldDRB8Dk1JERERE/xBqamro06cPnj9/jrlz58rtO3z4MCIiIlCvXj2Fr4oPCwvDgwcPxO/v3r0Tp3t9jJEbigwZMgTA+0WlC48GOnToEKKjo/Hll19+0AiENWvWYPfu3Vi9enWljr9w4YLCqV2yERUaGhoA3k/76dGjB1JTUxESElKs/NOnT5GXl1fieczMzKCpqYmEhAS55ElGRgZGjRpVrHxaWlqxdYgUxfXs2TMkJSUVK5eRkYGcnByx3Mc0YsQIAO8XzpdNfZLJy8sTY5Td19OnT8slTh48eIDAwECFdcsWDr9//365YvmQ56E8cnJycPr06WLb37x5g+zsbFSvXr1c0xg/toyMDKxduxaAfFJ3+PDhUFVVxahRo3Dv3r1ix7169Upu/TjZKK7CcnNzxfsq6z+GhoaQSCTlvi+lqVatGvbs2YPdu3cXu2eK+Pn5ITc3F4GBgXKxXr58GeHh4dDX10fXrl3F7b6+vnj37h1mzJghV8+RI0cUrrMVEBAAXV1dfP/997h69Wqx/X/++WelknxEVH5cU4qIiIjoH2TevHmIiYnB7Nmzcfr0aXz++edIS0vD9u3boaWlhbVr1yr8ody0aVM4OzujV69e0NbWxh9//IGUlBR0794dPXr0KNe5T506hVWrVgF4nxCRbZMltUxMTLBgwQKxfOvWrTFo0CCsWrUKrq6u6NSpE9LT07F161YYGRmVup5MeTg4OMDBwaHSx2/YsAErVqyAp6cnPvvsM+jp6eHatWs4ePAgjIyMEBAQIJZdtmwZkpKSMGfOHBw8eBBt2rSBIAi4ceMGjhw5gidPnpT4tjsVFRUMHz4cCxcuhLOzM3x8fJCVlYVDhw7B2toaVlZWcuUTExPRvXt3NGnSRFy0+eHDh9izZw9UVFTEaXkPHz5E48aN4ezsDCcnJ9SoUQMvXrzA3r17kZubi4kTJ1a6bUrSsWNHTJw4EQsWLICtrS26desGMzMzPHz4EJGRkZg4cSLGjh0LS0tL9OjRAzt37oS7uzvatm2LJ0+eYP/+/Wjbtq3CRaXbtGmDHTt2oEePHujQoQM0NDTE9ipJZZ+H8vjrr7/QokUL1K9fH25ubqhduzays7Oxf/9+PH78GBMnThTXyPq77NixQ1ycPD8/Hw8ePMC+ffvw8uVLtG/fHt27dxfLNmrUCMuWLcN3332HBg0aoGPHjvjss8/w+vVr3L59GzExMfD398evv/4K4P2C63p6emjatCmsra2Rm5uLo0eP4tq1a/j666/FxKKOjg48PDxw4sQJ+Pr6wtbWFioqKvD19a1UUtnd3R3u7u7lKjt58mQcOHAAGzZsQHJyMtq2bYunT59i69atyMvLw8qVK6GrqytXfteuXVi5ciWuXr0KT09P3L9/H9u2bUOnTp1w4MABufplbyT85ptv4OzsjPbt28POzg45OTlIS0tDTEwMmjdvjsOHD1f4OomonAQiIiIi+iRZW1sLiv517dmzZ8Lo0aMFa2troXr16oKJiYnw9ddfC1euXClW1s/PTwAgpKamCqGhoUK9evUENTU1wdraWggODhZycnLKHc/atWsFACV+rK2tix2Tn58vhIWFCQ0bNhTU1dUFY2NjoVevXsKtW7cq1BYAhAYNGpSrbIMGDYq1W1RUlABACAoKEredPXtWGDp0qNCoUSPBwMBA0NTUFGxtbYWRI0cKd+/eLVZvZmamMH36dMHOzk5QV1cX9PX1BRcXF2HGjBnCu3fvxHLW1tbF2uLdu3fCnDlzBFtbW0FdXV2oXbu2MGHCBOH169fFyt+/f1+YOnWq0LRpU8HMzExQU1MTateuLXTv3l04c+aMWC4jI0MIDg4WPD09BUtLS0FNTU2wsrIS2rdvLxw6dKjM6xcEQQgKChIACFFRUcWu18vLS2H/EwRB2Llzp9C6dWtBX19fUFdXF2xsbARfX18hKSlJLPP69WthwoQJgo2NjaCuri7Y2toKs2bNEt69eycAELy8vOTqzM3NFSZPnizUrl1bUFVVFQAIfn5+4n5FxwhC5Z6HO3fuFNtXtC3evXsnzJs3T/jyyy+FmjVrCmpqaoK5ubng6ekpbNq0SSgoKFDYNh+DLJaiH11dXaFp06bCkiVLhNzcXIXHnjt3Tujdu7dgZWUltoerq6swdepUITk5WSy3bNky4auvvhKsra0FDQ0NwdjYWGjSpImwfPlyuf4sCIKQkpIidOzYUTAwMBAkEkmJfaawO3fuCAAEb2/vcl2zurq6wr8h2dnZwvTp04X69esLampqgoGBgdChQwfh5MmTCut58eKFMGTIEMHU1FTQ0NAQ3NzchF27dol/v9auXVvsmOvXrwsDBw4UrK2tBTU1NcHQ0FBwdHQURo8eLZw7d06ubEn9kIgqRyIIRcZsEhEREdG/hr+/P9atW4c7d+7AxsamqsMhIiIiEnFNKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqXjmlJERERERERERKR0HClFRERERERERERKx6QUEREREREREREpnWpVB0BERP9+BQUFePToEXR1dSGRSKo6HCIiIiIi+hsJgoDXr1/DysoKKiolj4diUoqIiP52jx49Qq1atao6DCIiIiIiUqL79++jZs2aJe5nUoqIiP52urq6AN7/n5Kenl4VR0NERERERH+nrKws1KpVS/wdUBImpYiI6G8nm7Knp6fHpBQRERER0X9EWUt3cKFzIiIiIiIiIiJSOialiIiIiIiIiIhI6ZiUIiIiIiIiIiIipWNSioiIiIiIiIiIlI5JKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqVjUoqIiIiIiIiIiJSOSSkiIiIiIiIiIlI6JqWIiIiIiIiIiEjpmJQiIiIiIiIiIiKlY1KKiIiIiIiIiIiUjkkpIiIiIiIiIiJSOialiIiIiIiIiIhI6ZiUIiIiIiIiIiIipWNSioiIiIiIiIiIlI5JKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqVjUoqIiIiIiIiIiJROtaoDICKi/470dq2RrVqtqsMgIiqR1elzVR0CERHRfwZHShERERERERERkdIxKUVERERERERERErHpBQRERERERERESkdk1JERERERERERKR0TEoREREREREREZHSMSlFRERERERERERKx6QUEREREREREREpHZNSRERERERERESkdExKERERERERERGR0jEpRURERERERERESsekFBERERERERERKR2TUkREREREREREpHRMSn0EEokEe/bsAQCkpaVBIpEgMTGxSmOqrODgYLi4uCjtfP7+/ujatavSzkcEfLx+V/jZ/yeKjo6GRCLBq1evqjoUIiIiIiL6D1Kt6gD+DdLT02FoaFjVYRBROYWFhUEQhKoOo8o1b94c6enp0NfXr+pQiIiIiIjoP4hJqY/AwsKiqkP45OXm5qJ69epVHQbevXsHNTW1qg6DqhiTMO+pqanx7xcREREREVWZCk3fKygowPz581GvXj2oq6ujdu3amDNnjrj/ypUraNOmDTQ1NWFsbIwhQ4YgOztb3C+bMvPDDz/A3NwcBgYGmDlzJvLy8jBp0iQYGRmhZs2aWLt2rXiMbDrcli1b0Lx5c2hoaKBRo0aIiYkpNdZly5bB1tYWGhoaMDc3x9dffw0AWL9+PYyNjZGTkyNXvmvXrvD19QUAXLp0Ca1bt4auri709PTg5uaG8+fPl3guRVN4rl+/XmK8sikzERERaNy4MTQ1NdGmTRs8ffoUhw4dgr29PfT09NC3b1/8+eefJZ43PDwcBgYG2LNnj3it3t7euH//vly5P/74Ax4eHtDQ0ICJiQm6detWatsBwIYNG2BjYwN9fX307t0br1+/FvcdPnwYLVu2hIGBAYyNjdG5c2ekpqaK+2X3bOvWrfDy8oKGhgY2btyI/Px8jB8/Xjxu8uTJcqNV9u/fDwMDA+Tn5wMAEhMTIZFIMHXqVLHMoEGD8O233wIAXrx4gT59+qBGjRrQ0tKCo6MjNm/eLHcdUqkUI0eOxNixY2FiYgJvb28AQFJSEjp06AAdHR2Ym5vD19cXz58/L7NdFElKSipXudjYWEilUmhpacHQ0BDe3t7IyMgAAOTk5GD06NEwMzODhoYGWrZsifj4ePHYyvYZ2fWPHDkS+vr6MDExwfTp08scJbR8+XJ89tlnUFNTQ4MGDbBhwwZxnyAICA4ORu3ataGurg4rKyuMHj26xLpkU0LXrFmD2rVrQ0dHB8OHD0d+fj7mz58PCwsLmJmZyf0tqeg5Jk6ciM6dO4vfFy9eDIlEgsOHD4vb6tWrh1WrVgEoPn1PKpVi9OjRmDx5MoyMjGBhYYHg4GC5c9y8eROenp7Q0NCAg4MDjh49WiyO0v4GJiUlQUVFBc+ePQMAvHz5EioqKujdu7d4/OzZs9GyZUsAQEZGBvr16wdTU1NoamrC1tZW7m9jUVKpFKNGjcLYsWNhaGgIc3NzrFy5Em/evEFAQAB0dXVRr149HDp0SDym6PS9u3fvwsfHB4aGhtDW1kbDhg1x8OBBsfzVq1fRuXNn6OnpQVdXF61atZJ79omIiIiIiCqiQkmpwMBAhIaGYvr06bh27Ro2bdoEc3NzAMCbN2/g7e0NQ0NDxMfHY/v27Th27BhGjhwpV8fx48fx6NEjnDhxAosWLUJQUBA6d+4MQ0NDxMXFYdiwYRg6dCgePHggd9ykSZMwYcIEXLx4Ec2aNYOPjw9evHihMM7z589j9OjRmDlzJlJSUnD48GF4enoCAL755hvk5+dj3759YvmnT5/iwIEDGDBgAACgX79+qFmzJuLj43HhwgVMnTq1wqN8yhNvcHAwli5ditOnT+P+/fvo2bMnFi9ejE2bNuHAgQM4cuQIfv7551LP8+eff2LOnDlYv349YmNj8erVK7kfuQcOHEC3bt3QsWNHXLx4EZGRkWjSpEmpdaampmLPnj3Yv38/9u/fj5iYGISGhor737x5g/Hjx+P8+fOIjIyEiooKunXrhoKCArl6pk6dijFjxiA5ORne3t5YuHAhwsPDsWbNGpw6dQovX77E7t27xfKtWrXC69evcfHiRQBATEwMTExMEB0dLZaJiYmBVCoFALx9+xZubm44cOAAkpKSMGTIEPj6+uLcuXNycaxbtw5qamqIjY3Fr7/+ilevXqFNmzZo3Lgxzp8/j8OHD+PJkyfo2bNnqe2iyF9//QVvb2+5xJkiiYmJaNu2LRwcHHDmzBmcOnUKPj4+YgJu8uTJ2LlzJ9atW4eEhATUq1cP3t7eePnypVw9lekz69atg6qqKs6dO4ewsDAsWrRITM4osnv3bowZMwYTJkxAUlIShg4dioCAAERFRQEAdu7ciZ9++gkrVqzAzZs3sWfPHjg6OpZ6/ampqTh06BAOHz6MzZs3Y/Xq1ejUqRMePHiAmJgYzJs3D9OmTUNcXFylzuHl5YVTp06J7Vm07zx8+BCpqali31Fk3bp10NbWRlxcHObPn4+ZM2eKiaeCggJ0794dampqiIuLw6+//oopU6bIHV/W38CGDRvC2NhYTFCfPHlS7rssblmMsr+zhw4dQnJyMpYvXw4TE5NS23ndunUwMTHBuXPnMGrUKHz33Xf45ptv0Lx5cyQkJODLL7+Er69vicnuESNGICcnBydOnMCVK1cwb9486OjoiG3o6ekJdXV1HD9+HBcuXMCAAQOQl5dXakxEREREREQlkQjlXFjl9evXMDU1xdKlSzFo0KBi+1euXIkpU6bg/v370NbWBgAcPHgQPj4+ePToEczNzeHv74/o6Gjcvn0bKirv82F2dnYwMzPDiRMnAAD5+fnQ19fHqlWr0Lt3b6SlpaFOnToIDQ0VfwTm5eWhTp06GDVqFCZPnlwsll27diEgIAAPHjyArq5usf3Dhw9HWlqaOAJg0aJF+OWXX3Dr1i1IJBLo6enh559/hp+fX3maBhKJBLt370bXrl3LFW90dDRat26NY8eOoW3btgCA0NBQBAYGIjU1FXXr1gUADBs2DGlpaXKjPQoLDw9HQEAAzp49i88//xzA+xFa9vb2iIuLQ5MmTdC8eXPUrVsXv//+e7muJTg4GD/++CMeP34stt3kyZNx4sQJnD17VuExz58/h6mpKa5cuYJGjRqJbbB48WKMGTNGLGdlZYVx48Zh0qRJcu3i5uYmjjRzc3NDnz59MHHiRHTr1g0eHh4ICQnBixcvkJmZiZo1a+LGjRuwtbVVGEvnzp1hZ2eHBQsWAHg/eiQrKwsJCQlimdmzZ+PkyZOIiIgQtz148AC1atVCSkoK6tevX662krl8+TLatGmDoUOHyo32Kaxv3764d+8eTp06VWzfmzdvYGhoiPDwcPTt2xfA++mONjY2GDt2LCZNmlTpPiOVSvH06VNcvXoVEokEwPtk4b59+3Dt2jWFsbZo0QINGzbEb7/9Jm7r2bMn3rx5gwMHDmDRokVYsWIFkpKSypWsVdSn2rdvj5SUFKSmpsr9LfD398fUqVMrfI5Xr17B2NgYcXFxcHNzg4mJCSZNmoQ9e/bg7Nmz2LhxI6ZMmSImu/39/fHq1Sux30mlUuTn5+PkyZNinU2aNEGbNm0QGhqKI0eOoFOnTrh79y6srKwAvB8x2KFDB/HZL8/fwB49esDS0hJLly7FuHHjUL16daxatQqnT5/GZ599Jo58/OKLL/DVV1/BxMQEa9asKfP6FV2D7G9p9+7dsX79egDA48ePYWlpiTNnzqBp06Ziv8rIyICBgQGcnJzQo0cPBAUFFav/f//7H7Zs2YKUlJRy3ZOcnBy5EalZWVmoVasWrnu4Qle1WrmuiYioKlidPld2ISIiIipVVlYW9PX1kZmZCT09vRLLlXukVHJyMnJycsQfxIr2Ozs7iz/GgPc/bgsKCpCSkiJua9iwofgjFADMzc3lRkBUq1YNxsbGePr0qVz9zZo1E/9ZVVUV7u7uSE5OVhjLF198AWtra9StWxe+vr7YuHGj3MiAwYMH48iRI3j48CGA98kdf39/8Uf7+PHjMWjQILRr1w6hoaGVmp5SnnidnJzEfzY3N4eWlpaYXJBtK9oORamqqsLDw0P8bmdnBwMDA/FcshE6FWFjYyOXzLO0tJSL4+bNm+jTpw/q1q0LPT092NjYAADu3bsnV4+7u7v4z5mZmUhPTxeTZ7LYC5cB3o94iY6OhiAIOHnyJLp37w57e3ucOnUKMTExsLKyEhNS+fn5mDVrFhwdHWFkZAQdHR1EREQUi8PNzU3u+6VLlxAVFQUdHR3xY2dnBwAl3msbGxtIJBKFH2dnZ7x48QI//PCDXFKjsNLuQ2pqKnJzc9GiRQtxW/Xq1dGkSZOP0meaNm0q9m3gfd+8efOmOKqoqOTkZLlYgPfPsiyWb775Bn/99Rfq1q2LwYMHY/fu3WWOlinap8zNzeHg4FDsb4Es9tLO8cMPP8jdu3v37sHAwADOzs6Ijo7GlStXoKamhiFDhuDixYvIzs5GTEwMvLy8So2xcNsC8v0+OTkZtWrVEhNSsnYs2m5l/Q2U9W/g/aioNm3awNPTE9HR0YiPj5frB9999x22bNkCFxcXTJ48GadPny41/qLXIPtbWvjvq2xka0l/V0aPHo3Zs2ejRYsWCAoKwuXLl8V9iYmJaNWqVblHjc6dOxf6+vrip1atWuU6joiIiIiI/jvKnZTS1NT8KCcs+oNGIpEo3FZ0KlhF6OrqIiEhAZs3b4alpSVmzJgBZ2dncd2Uxo0bw9nZGevXr8eFCxdw9epV+Pv7i8cHBwfj6tWr6NSpE44fPw4HBwe5aWYfS+Hr/jvaAajcfSsrDh8fH7x8+RIrV65EXFycOOXq3bt3cscV/nFeXlKpFKdOncKlS5dQvXp12NnZQSqVIjo6ulhi4ccff0RYWBimTJmCqKgoJCYmwtvbu8w4srOz4ePjg8TERLmPbM0gRSIjI5GcnKzwc/z4cRgbG6Nnz55o3ry5wuP/jufn7+ozZZGNKFu2bBk0NTUxfPhweHp6Ijc3t8RjKvrcl3aOYcOGyd03WaKoaD8xMjKSS2iWlZRSRltKpVJcu3YNN2/exLVr19CyZUu5uN3d3aGlpQUA6NChA+7evYtx48bh0aNHaNu2LSZOnFjhayjaZwCUeF2DBg3C7du34evriytXrsDd3V2cDlrRPhwYGIjMzEzxU3StOyIiIiIionInpWxtbaGpqYnIyEiF++3t7XHp0iW8efNG3BYbGwsVFRU0aNDggwMtPHUsLy8PFy5cgL29fYnlVVVV0a5dO8yfPx+XL19GWloajh8/Lu4fNGgQwsPDsXbtWrRr167Yf8WvX78+xo0bhyNHjqB79+6lLjD8MeKtrLy8PLlF2FNSUvDq1SvxXE5OTiXes8p48eIFUlJSMG3aNLRt2xb29vbiYt2l0dfXh6WlpZjAksV+4cIFuXKydaV++uknMYkg+9EeHR0ttyZQbGwsunTpgm+//RbOzs6oW7cubty4UWYsrq6uuHr1KmxsbFCvXj25T0mJtM8++wx2dnbFPtbW1hg+fDikUik2btyIatUUT0sq7T7IFhSPjY0Vt+Xm5iI+Ph4ODg5lXk9ZCrc58L5v2tralhirvb29XCzA+7YuHIumpiZ8fHywZMkSREdH48yZM7hy5coHx1pYSecwMjKSu2eqqu9fIipbVyoyMlLsJ1KpFJs3b8aNGzdKXU+qLPb29rh//z7S09PFbUWns5bnb6CjoyMMDQ0xe/ZsuLi4QEdHB1KpFDExMcX6NwCYmprCz88Pv//+OxYvXiw3pfLvUqtWLQwbNgy7du3ChAkTsHLlSgDv+/DJkydLTT4Wpq6uDj09PbkPERERERFRYeVOSmloaGDKlCmYPHky1q9fj9TUVJw9exarV68G8H5xcA0NDfj5+SEpKQlRUVEYNWoUfH19xSkjH+KXX37B7t27cf36dYwYMQIZGRniwuTA+2lrstFM+/fvx5IlS5CYmIi7d+9i/fr1KCgokEuO9e3bFw8ePMDKlSvl6vnrr78wcuRIREdH4+7du4iNjUV8fLyY5Hn48CHs7OyKLaZd0XgrY+nSpcWmgFWvXh2jRo1CXFwcLly4AH9/fzRt2lRczDwoKAibN29GUFAQkpOTxcWLZQIDA9G/f/9yx2BoaAhjY2P89ttvuHXrFo4fP47x48eX69gxY8YgNDQUe/bswfXr1zF8+HBx9Frh+p2cnLBx40bxB7qnpycSEhJw48YNudEutra2OHr0KE6fPo3k5GQMHToUT548KTOOESNG4OXLl+jTpw/i4+ORmpqKiIgIBAQElDilrSSampoIDQ3Fli1bxOSIIoGBgYiPj8fw4cNx+fJlXL9+HcuXL8fz58+hra2N7777DpMmTcLhw4dx7do1DB48GH/++ScGDhxYoXgUuXfvHsaPH4+UlBRs3rwZP//8s9xaX0X7wKRJkxAeHo7ly5fj5s2bWLRoEXbt2iWO0gkPD8fq1auRlJSE27dv4/fff4empiasra0V1lcZZZ1DEU9PT7x+/Rr79++XS0pt3LgRlpaWFV4rrLB27dqhfv368PPzw6VLl3Dy5El8//33cmXK8zdQIpHA09NTrn87OTkhJycHkZGRcv17xowZ2Lt3L27duoWrV69i//79conttm3bYunSpZW+JkXGjh2LiIgI3LlzBwkJCYiKihLPOXLkSGRlZaF37944f/48bt68iQ0bNshNzyYiIiIiIqqICr19b/r06ZgwYQJmzJgBe3t79OrVS1ybREtLCxEREXj58iU8PDzw9ddff9QfTaGhoQgNDYWzszNOnTqFffv2yb2JKiUlBZmZmQAAAwMD7Nq1C23atIG9vT1+/fVXbN68GQ0bNhTL6+vro0ePHtDR0ZF7NXy1atXw4sUL9O/fH/Xr10fPnj3RoUMHhISEAHg/giUlJaXEt1eVN97KeP78ebE1j7S0tDBlyhT07dsXLVq0gI6ODrZu3Srul0ql2L59O/bt2wcXFxe0adNGLqGWnp5ebA2m0qioqGDLli24cOECGjVqhHHjxuHHH38s17ETJkyAr68v/Pz80KxZM+jq6qJbt27Fynl5eSE/P1/80W5kZAQHBwdYWFjIJRanTZsGV1dXeHt7QyqVwsLCQu5elsTKygqxsbHIz8/Hl19+CUdHR4wdOxYGBgZyaxyVV5cuXUpNSAHvR94dOXIEly5dQpMmTdCsWTPs3btXPC40NBQ9evSAr68vXF1dcevWLURERMDQ0LDC8RTVv39//PXXX2jSpAlGjBiBMWPGYMiQIeL+on2ga9euCAsLw4IFC9CwYUOsWLECa9euFe+HgYEBVq5ciRYtWsDJyQnHjh3DH3/8AWNjY4X1VUZZ51DE0NAQjo6OMDU1FdcI8/T0REFBQZlT98qioqKC3bt3i+04aNCgYoval/dvYNH+raKiAk9PT0gkErm1vNTU1BAYGAgnJyd4enqiWrVq2LJli7g/NTUVz58//6DrKio/Px8jRoyAvb092rdvj/r162PZsmUAAGNjYxw/fhzZ2dnw8vKCm5sbVq5cWeE3kxIREREREcmU++17VUX2JreLFy/CxcXlo9bdtm1bNGzYEEuWLPmo9SpLeHg4xo4dW2y0EZGMVCqFi4sLFi9eXNWh0H+c7O0bfPseEX3q+PY9IiKiD1fet++VPrzjXyojI0Nco0g2CoCIiIiIiIiIiJTnP5mUaty4MTIyMjBv3ryPsgg7ERERERERERFVzCc/fY+IiP75OH2PiP4pOH2PiIjow5V3+l7FV3UmIiIiIiIiIiL6QExKERERERERERGR0jEpRURERERERERESsekFBERERERERERKR2TUkREREREREREpHRMShERERERERERkdIxKUVERERERERERErHpBQRERERERERESkdk1JERERERERERKR0qlUdABER/XdYHouCnp5eVYdBRERERESfAI6UIiIiIiIiIiIipWNSioiIiIiIiIiIlI5JKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqVjUoqIiIiIiIiIiJSOSSkiIiIiIiIiIlI6JqWIiIiIiIiIiEjpVKs6ACIi+u9Ib9ca2arVqjoMIqJPmtXpc1UdAhERkVJwpBQRERERERERESkdk1JERERERERERKR0TEoREREREREREZHSMSlFRERERERERERKx6QUEREREREREREpHZNSRERERERERESkdExKERERERERERGR0jEpRURERERERERESsekFBERERERERERKR2TUkREREREREREpHRMShERERERERERkdIxKUVERERERERERErHpBQBAGxsbLB48WKlnU8ikWDPnj1KOx99Wgrf/7S0NEgkEiQmJlZpTJUVHBwMFxcXpZ3P398fXbt2Vdr5iIiIiIiI/i6qVR0AEf33pKenw9DQsKrDICIiIiIioirEkVL0t3n37l1VhyDKzc2t6hCoEAsLC6irq1d1GJ+0T6XPfkrPMRERERER/bsoLSlVUFCA+fPno169elBXV0ft2rUxZ84ccf+VK1fQpk0baGpqwtjYGEOGDEF2dra4XzZl5YcffoC5uTkMDAwwc+ZM5OXlYdKkSTAyMkLNmjWxdu1a8RjZtKAtW7agefPm0NDQQKNGjRATE1NqrMuWLYOtrS00NDRgbm6Or7/+GgCwfv16GBsbIycnR658165d4evrCwC4dOkSWrduDV1dXejp6cHNzQ3nz58v8VwSiQQrVqxA586doaWlBXt7e5w5cwa3bt2CVCqFtrY2mjdvjtTUVPGY1NRUdOnSBebm5tDR0YGHhweOHTsmV29OTg6mTJmCWrVqQV1dHfXq1cPq1atLve4///wTAwYMgK6uLmrXro3ffvtNbv+UKVNQv359aGlpoW7dupg+fbrcD2fZNKZVq1ahTp060NDQAADcvHkTnp6e0NDQgIODA44ePSpX79dff42RI0eK38eOHQuJRILr168DeP+jWFtbW7zGw4cPo2XLljAwMICxsTE6d+4s1z6y+75161Z4eXlBQ0MDGzduBACsWrUK9vb20NDQgJ2dHZYtW1Zqm5QkPz8fycnJZZZjv1dM0fTN69evlxhvdHQ0JBIJIiIi0LhxY2hqaqJNmzZ4+vQpDh06BHt7e+jp6aFv3774888/SzxveHg4DAwMsGfPHvFavb29cf/+fblyf/zxBzw8PKChoQETExN069at1LYDgA0bNsDGxgb6+vro3bs3Xr9+Le6rbJ/Nz8/H+PHjxeMmT54MQRDE4/bv3w8DAwPk5+cDABITEyGRSDB16lSxzKBBg/Dtt98CAF68eIE+ffqgRo0a0NLSgqOjIzZv3ix3HVKpFCNHjsTYsWNhYmICb29vAEBSUhI6dOgAHR0dmJubw9fXF8+fPy+zXYiIiIiIiEqitKRUYGAgQkNDMX36dFy7dg2bNm2Cubk5AODNmzfw9vaGoaEh4uPjsX37dhw7dkwuUQEAx48fx6NHj3DixAksWrQIQUFB6Ny5MwwNDREXF4dhw4Zh6NChePDggdxxkyZNwoQJE3Dx4kU0a9YMPj4+ePHihcI4z58/j9GjR2PmzJlISUnB4cOH4enpCQD45ptvkJ+fj3379onlnz59igMHDmDAgAEAgH79+qFmzZqIj4/HhQsXMHXqVFSvXr3Utpk1axb69++PxMRE2NnZoW/fvhg6dCgCAwNx/vx5CIIg1xbZ2dno2LEjIiMjcfHiRbRv3x4+Pj64d++eWKZ///7YvHkzlixZguTkZKxYsQI6OjqlxrFw4UK4u7vj4sWLGD58OL777jukpKSI+3V1dREeHo5r164hLCwMK1euxE8//SRXx61bt7Bz507s2rULiYmJKCgoQPfu3aGmpoa4uDj8+uuvmDJlitwxXl5eiI6OFr/HxMTAxMRE3BYfH4/c3Fw0b94cwPv+Mn78eJw/fx6RkZFQUVFBt27dUFBQIFfv1KlTMWbMGCQnJ8Pb2xsbN27EjBkzMGfOHCQnJ+OHH37A9OnTsW7dulLbRZEDBw6gadOmOHfuXKnl2O/LrzzxBgcHY+nSpTh9+jTu37+Pnj17YvHixdi0aRMOHDiAI0eO4Oeffy71PH/++SfmzJmD9evXIzY2Fq9evULv3r3F/QcOHEC3bt3QsWNHXLx4EZGRkWjSpEmpdaampmLPnj3Yv38/9u/fj5iYGISGhor7K9tnFy5ciPDwcKxZswanTp3Cy5cvsXv3brF8q1at8Pr1a1y8eBFA8WdHtk0qlQIA3r59Czc3Nxw4cABJSUkYMmQIfH19i/XjdevWQU1NDbGxsfj111/x6tUrtGnTBo0bN8b58+dx+PBhPHnyBD179iy1XYiIiIiIiEojEQr/Z/e/yevXr2FqaoqlS5di0KBBxfavXLkSU6ZMwf3796GtrQ0AOHjwIHx8fPDo0SOYm5vD398f0dHRuH37NlRU3ufS7OzsYGZmhhMnTgB4P3pFX18fq1atQu/evZGWloY6deogNDRUTITk5eWhTp06GDVqFCZPnlwsll27diEgIAAPHjyArq5usf3Dhw9HWloaDh48CABYtGgRfvnlF9y6dQsSiQR6enr4+eef4efnV662kUgkmDZtGmbNmgUAOHv2LJo1a4bVq1eLP/i3bNmCgIAA/PXXXyXW06hRIwwbNgwjR47EjRs30KBBAxw9ehTt2rUrVxw2NjZo1aoVNmzYAAAQBAEWFhYICQnBsGHDFB6zYMECbNmyRRwRExwcjB9++AEPHz6EqakpAODIkSPo1KkT7t69CysrKwDvR4106NABu3fvRteuXXHlyhU4OzvjyZMnUFVVhYWFBaZPn46kpCRs2bIFc+bMwcGDBxEbG6swjufPn8PU1BRXrlxBo0aNxPu+ePFijBkzRixXr149zJo1C3369BG3zZ49GwcPHsTp06fL1U6FzZkzBz/++COOHTsGd3f3YvvZ70smkUjE+1+eeKOjo9G6dWscO3YMbdu2BQCEhoYiMDAQqampqFu3LgBg2LBhSEtLw+HDhxWeNzw8HAEBATh79iw+//xzAO9HaNnb2yMuLg5NmjRB8+bNUbduXfz+++/lupbg4GD8+OOPePz4sdh2kydPxokTJ3D27FmFx5S3z1pZWWHcuHGYNGmSXLu4ubmJI83c3NzQp08fTJw4Ed26dYOHhwdCQkLw4sULZGZmombNmrhx4wZsbW0VxtK5c2fY2dlhwYIFAN6PlMrKykJCQoJYZvbs2Th58iQiIiLEbQ8ePECtWrWQkpKC+vXrF6s3JydHbnRdVlYWatWqhesertBVrVaepiUi+s+yOl36f/QiIiL61GVlZUFfXx+ZmZnQ09MrsZxSRkolJycjJydH/DGpaL+zs7P4wxwAWrRogYKCArmROg0bNhR/mAOAubk5HB0dxe/VqlWDsbExnj59Kld/s2bNxH9WVVWFu7t7iVOvvvjiC1hbW6Nu3brw9fXFxo0b5aYDDR48GEeOHMHDhw8BvP+R6+/vD4lEAgAYP348Bg0ahHbt2iE0NFRuik5JnJyc5K4JgNx1mZub4+3bt8jKygLwfqTUxIkTYW9vDwMDA+jo6CA5OVkcKZWYmIhq1arBy8urzHOXFIdEIoGFhYVcW27duhUtWrSAhYUFdHR0MG3aNLnRWQBgbW0tJqSA9/e2Vq1aYkIKkL8fwPuEmpGREWJiYnDy5Ek0btwYnTt3FqdvFR7pAbyfDtinTx/UrVsXenp6sLGxAYBisRROFL158wapqakYOHAgdHR0xM/s2bNLvEeyKWMlfaZNm4bMzEz06tVL4fHs9xVTnniLPiuyqaSFtxVth6JUVVXh4eEhfrezs4OBgYF4rsTExBLvWUlsbGzkknmWlpZycVSmz2ZmZiI9PV1MnsliL5oAlY00FAQBJ0+eRPfu3WFvb49Tp04hJiYGVlZWYkIqPz8fs2bNgqOjI4yMjKCjo4OIiIhicbi5ucl9v3TpEqKiouSeHTs7OwAo8V7PnTsX+vr64qdWrVqltiEREREREf33KCUppamp+VHqKTodSCKRKNxWdEpMRejq6iIhIQGbN2+GpaUlZsyYAWdnZ7x69QoA0LhxYzg7O2P9+vW4cOECrl69Cn9/f/H44OBgXL16FZ06dcLx48fh4OAgN92mrOuS/chXtE12XRMnTsTu3bvxww8/4OTJk0hMTISjo6O4IHFl27u0tjxz5gz69euHjh07Yv/+/bh48SK+//77YosgF06wlJdEIoGnpyeio6PFBJSTkxNycnKQlJSE06dPyyXYfHx88PLlS6xcuRJxcXGIi4sDUHxB5sKxyNZpWrlyJRITE8VPUlJSiaNZmjRpguTk5BI/ISEhUFVVxY8//qjwePb70vt9ZRR9Lj52OwCVu29lxVGZPlteUqkUp06dwqVLl1C9enXY2dlBKpWKz1PhZ+fHH39EWFgYpkyZgqioKCQmJsLb27vMOLKzs+Hj4yP37CQmJorrxSkSGBiIzMxM8VN03S4iIiIiIiKlJKVsbW2hqamJyMhIhfvt7e1x6dIlvHnzRtwWGxsLFRUVNGjQ4IPPXzjpkJeXhwsXLsDe3r7E8qqqqmjXrh3mz5+Py5cvIy0tDcePHxf3Dxo0COHh4Vi7di3atWtXbARA/fr1MW7cOBw5cgTdu3eXW4T6Y4iNjYW/vz+6desGR0dHWFhYIC0tTdzv6OiIgoKCMhe2rojTp0/D2toa33//Pdzd3WFra4u7d++WeZy9vT3u37+P9PR0cZuiJJBstEd0dDSkUilUVFTg6emJH3/8ETk5OWjRogWA9ws1p6SkYNq0aWjbti3s7e2RkZFRZhzm5uawsrLC7du3Ua9ePblPnTp1FB6jpaUFOzs7hZ/79+9j7ty52Lx5M7p3767wePb7ivX7isZbWXl5eXKLsKekpODVq1fiuZycnEq8Z5VR2T6rr68PS0tLMYEli/3ChQty5WTrSv30009iAkqWlJI9TzKxsbHo0qULvv32Wzg7O6Nu3bq4ceNGmbG4urri6tWrsLGxKfb8lJRIU1dXh56entyHiIiIiIioMKUkpTQ0NDBlyhRMnjwZ69evR2pqKs6ePSu+Da5fv37Q0NCAn58fkpKSEBUVhVGjRsHX11eczvYhfvnlF+zevRvXr1/HiBEjkJGRIa7XBLyfviMb1bF//34sWbIEiYmJuHv3LtavX4+CggK5JEHfvn3x4MEDrFy5Uq6ev/76CyNHjkR0dDTu3r2L2NhYxMfHiz92Hz58CDs7uzIXxy6Lra2tuJD4pUuX0LdvX7lRGTY2NvDz88OAAQOwZ88e3LlzB9HR0di2bZvCay7vOe/du4ctW7YgNTUVS5YsKdfx7dq1Q/369eHn54dLly7h5MmT+P7774uVk0qluHbtGq5evYqWLVuK2zZu3Ah3d3fxh6+hoSGMjY3x22+/4datWzh+/DjGjx9frmsICQnB3LlzsWTJEty4cQNXrlzB2rVrsWjRonK3g0zTpk2xZ88e8Q11irDfV6zflxVvZSxdurTYVLzq1atj1KhRiIuLw4ULF+Dv74+mTZuKi5kHBQVh8+bNCAoKQnJyMq5cuYJ58+aJxwcGBqJ///7ljuFD+uyYMWMQGhqKPXv24Pr16xg+fLg4eq1w/U5OTti4caOYgPL09ERCQgJu3LghN1LK1tYWR48exenTp5GcnIyhQ4fiyZMnZcYxYsQIvHz5En369EF8fDxSU1MRERGBgIAA8c1/REREREREFaW0t+9Nnz4dEyZMwIwZM2Bvb49evXqJa65oaWkhIiICL1++hIeHB77++mu0bdsWS5cu/SjnDg0NRWhoKJydnXHq1Cns27cPJiYm4v6UlBRkZmYCAAwMDLBr1y60adMG9vb2+PXXX7F582Y0bNhQLK+vr48ePXpAR0cHXbt2FbdXq1YNL168QP/+/VG/fn307NkTHTp0QEhICAAgNzcXKSkppb6yvjwWLVoEQ0NDNG/eHD4+PvD29oarq6tcmeXLl+Prr7/G8OHDYWdnh8GDB8uNyCl8zeXx1VdfYdy4cRg5ciRcXFxw+vRpTJ8+vczjVFRUsHv3bvz1119o0qQJBg0ahDlz5hQr5+joCAMDA7i4uIhvCZRKpcjPz5cb6aGiooItW7bgwoULaNSoEcaNG1fi9LmiBg0ahFWrVmHt2rVwdHSEl5cXwsPDSxwpVRpdXV14e3uXWY79vvz9vqx4K+P58+fF1jzS0tLClClT0LdvX7Ro0QI6OjrYunWruF8qlWL79u3Yt28fXFxc0KZNG7mEWnp6erE1mErzIX12woQJ8PX1hZ+fH5o1awZdXV1069atWDkvLy+5Z8XIyAgODg6wsLCQSyxOmzYNrq6u8Pb2hlQqhYWFhdy9LImVlRViY2ORn5+PL7/8Eo6Ojhg7diwMDAzk1jsjIiIiIiKqCKW8fa+qyN5odfHiRbi4uHzUutu2bYuGDRtiyZIlH7Veog/Ffl+y8PBwjB07tthoI/r7yd6+wbfvERGVjW/fIyKif7ryvn1PVYkx/StkZGSIa7UsW7asqsMhUgr2eyIiIiIiIvrYmJSqoMaNGyMjIwPz5s37KItRE/0TsN8TERERERHRx/avnr5HRESfBk7fIyIqP07fIyKif7ryTt/jCrVERERERERERKR0TEoREREREREREZHSMSlFRERERERERERKx6QUEREREREREREpHZNSRERERERERESkdExKERERERERERGR0jEpRURERERERERESsekFBERERERERERKR2TUkREREREREREpHSqVR0AERH9d1gei4Kenl5Vh0FERERERJ8AjpQiIiIiIiIiIiKlY1KKiIiIiIiIiIiUjkkpIiIiIiIiIiJSOialiIiIiIiIiIhI6ZiUIiIiIiIiIiIipWNSioiIiIiIiIiIlI5JKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqVTreoAiIjovyO9XWtkq1ar6jCIiD5pVqfPVXUIRERESsGRUkREREREREREpHRMShERERERERERkdIxKUVERERERERERErHpBQRERERERERESkdk1JERERERERERKR0TEoREREREREREZHSMSlFRERERERERERKx6QUEREREREREREpHZNSRERERERERESkdExKERERERERERGR0jEpRURERERERERESsekFBERERERERERKR2TUv9gEokEe/bs+aA6wsPDYWBg8FHiqSr+/v7o2rVrVYdBFWBjY4PFixeL3z9GX64qyn6GgoOD4eLiorTzERERERER/V1UqzoAqrz09HQYGhpWdRhVLiwsDIIgVHUYVAHx8fHQ1tau6jCIiIiIiIioCjEp9Q9mYWFR1SF8EvT19as6BKogU1PTqg7hk5ebm4vq1atXdRh49+4d1NTUqjoMIiIiIiL6F6rQ9L2CggLMnz8f9erVg7q6OmrXro05c+aI+69cuYI2bdpAU1MTxsbGGDJkCLKzs8X9smlWP/zwA8zNzWFgYICZM2ciLy8PkyZNgpGREWrWrIm1a9eKx6SlpUEikWDLli1o3rw5NDQ00KhRI8TExJQaa0ZGBvr37w9DQ0NoaWmhQ4cOuHnzprj/7t278PHxgaGhIbS1tdGwYUMcPHiwxPpsbGwwe/Zs9O/fHzo6OrC2tsa+ffvw7NkzdOnSBTo6OnBycsL58+crdQ5BEGBqaoodO3aI21xcXGBpaSl+P3XqFNTV1fHnn38CkJ/yJGunXbt2oXXr1tDS0oKzszPOnDkjd57w8HDUrl0bWlpa6NatG168eFEsluXLl+Ozzz6DmpoaGjRogA0bNoj7Jk6ciM6dO4vfFy9eDIlEgsOHD4vb6tWrh1WrVgEAoqOj0aRJE2hra8PAwAAtWrTA3bt3FbaB7Bq2bduGVq1aQVNTEx4eHrhx4wbi4+Ph7u4OHR0ddOjQAc+ePROPKzp9b8eOHXB0dBT7Ybt27fDmzRtx/5o1a9CwYUOoq6vD0tISI0eOVBhPWZKSkspVrrTz3bt3T+w/enp66NmzJ548eSLul03VWrNmDWrXrg0dHR0MHz4c+fn5mD9/PiwsLGBmZib3HALv+8by5cvRoUMHaGpqom7dunJ9S5GS2u3EiROoXr06Hj9+LFd+7NixaNWqFYDKPU+Fp+8B70f+lRRvZftGUdHR0ZBIJDhw4ACcnJygoaGBpk2bFruXsbGxkEql0NLSgqGhIby9vZGRkVFq+0VERMDe3h46Ojpo37490tPTxX3x8fH44osvYGJiAn19fXh5eSEhIUHueNk9++qrr6CtrS3e09DQUJibm0NXVxcDBw7E27dvxWOSkpKgoqIiXvPLly+hoqKC3r17i2Vmz56Nli1bAgDy8/MxcOBA1KlTB5qammjQoAHCwsLk4pA9T3PmzIGVlRUaNGgAALh//z569uwJAwMDGBkZoUuXLkhLSyu1TYiIiIiIiEpToaRUYGAgQkNDMX36dFy7dg2bNm2Cubk5AODNmzfw9vaGoaEh4uPjsX37dhw7dqzYD/7jx4/j0aNHOHHiBBYtWoSgoCB07twZhoaGiIuLw7BhwzB06FA8ePBA7rhJkyZhwoQJuHjxIpo1awYfHx+FCRUZf39/nD9/Hvv27cOZM2cgCAI6duyI3NxcAMCIESOQk5ODEydO4MqVK5g3bx50dHRKvf6ffvoJLVq0wMWLF9GpUyf4+vqif//++Pbbb5GQkIDPPvsM/fv3F6eSVeQcEokEnp6eiI6OBvA+qZacnIy//voL169fBwDExMTAw8MDWlpaJcb4/fffY+LEiUhMTET9+vXRp08f5OXlAQDi4uIwcOBAjBw5EomJiWjdujVmz54td/zu3bsxZswYTJgwAUlJSRg6dCgCAgIQFRUFAPDy8sKpU6eQn58vxmRiYiLG/fDhQ6SmpkIqlSIvLw9du3aFl5cXLl++jDNnzmDIkCGQSCSltnNQUBCmTZuGhIQEqKqqom/fvpg8eTLCwsJw8uRJ3Lp1CzNmzFB4bHp6Ovr06YMBAwYgOTkZ0dHR6N69u3hPli9fjhEjRmDIkCG4cuUK9u3bh3r16pUajyIXL16Eh4cH9u3bV2q50s5XUFCALl264OXLl4iJicHRo0dx+/Zt9OrVS66O1NRUHDp0CIcPH8bmzZuxevVqdOrUCQ8ePEBMTAzmzZuHadOmIS4uTu646dOno0ePHrh06RL69euH3r17Izk5ucLt5unpibp168olJ3Nzc7Fx40YMGDAAQOWep6LKE++H9I3CJk2ahIULFyI+Ph6mpqbw8fER/zYkJiaibdu2cHBwwJkzZ3Dq1Cn4+PiIfV6RP//8EwsWLMCGDRtw4sQJ3Lt3DxMnThT3v379Gn5+fjh16hTOnj0LW1tbdOzYEa9fv5arJzg4GN26dcOVK1cwYMAAbNu2DcHBwfjhhx9w/vx5WFpaYtmyZWL5hg0bwtjYWEzSnzx5Uu478P4ZlUqlAN73uZo1a2L79u24du0aZsyYgf/973/Ytm2bXByRkZFISUnB0aNHsX//fuTm5sLb2xu6uro4efIkYmNjxeTbu3fvFLZJTk4OsrKy5D5ERERERESFSYRyLsbz+vVrmJqaYunSpRg0aFCx/StXrsSUKVNw//59ca2YgwcPwsfHB48ePYK5uTn8/f0RHR2N27dvQ0XlfT7Mzs4OZmZmOHHiBID3/yVfX18fq1atQu/evZGWloY6deogNDQUU6ZMAQDk5eWhTp06GDVqFCZPnlwslps3b6J+/fqIjY1F8+bNAQAvXrxArVq1sG7dOnzzzTdwcnJCjx49EBQUVK6GsrGxQatWrcQf5o8fP4alpSWmT5+OmTNnAgDOnj2LZs2aIT09HRYWFhU+x88//4wVK1YgKSkJe/fuxdy5c2FhYYH27dtj2LBh+OKLL9CkSRNxBIVEIsHu3bvRtWtXsZ1WrVqFgQMHAgCuXbuGhg0bIjk5GXZ2dujbty8yMzNx4MAB8Zy9e/fG4cOH8erVKwBAixYt0LBhQ/z2229imZ49e+LNmzc4cOAAXr16BWNjY8TFxcHNzQ0mJiaYNGkS9uzZg7Nnz2Ljxo2YMmUKHjx4gJcvX8LY2BjR0dHw8vIq8/oVXcOWLVvQp08fREZGok2bNgDejxwJDw8Xk3X+/v549eoV9uzZg4SEBLi5uSEtLQ3W1tbFzlGjRg0EBAQUS8ZVxoYNGzBkyBDs2LEDnTp1UlimtPMdPXoUHTp0wJ07d1CrVi0A/3fPzp07Bw8PDwQHB+PHH3/E48ePoaurCwBo3749UlJSkJqaKvcc+fv7Y+rUqQDe941hw4Zh+fLl4vmaNm0KV1dXuaSGTFntNn/+fISHh+PatWsAgF27dsHPzw+PHz+GtrZ2pZ6nsWPHYuzYseWKt7J9o6jo6Gi0bt0aW7ZsEZN/L1++RM2aNREeHo6ePXuib9++uHfvHk6dOlWuawkPD0dAQABu3bqFzz77DACwbNkyzJw5s9joMpmCggIYGBhg06ZN4shDiUSCsWPH4qeffhLLNW/eHI0bN8Yvv/wi1y5v375FYmIiAKBHjx6wtLTE0qVLMW7cOFSvXh2rVq3C6dOn8dlnn8HAwAB79uzBF198oTCWkSNH4vHjx+LINH9/fxw+fBj37t0Tp+39/vvvmD17NpKTk8Wk8rt378S6v/zyy2L1BgcHIyQkpNj26x6u0FWtVmqbEhH911mdPlfVIRAREX2QrKws6OvrIzMzE3p6eiWWK/dIqeTkZOTk5KBt27Yl7nd2dpZbvLhFixYoKChASkqKuK1hw4biD2kAMDc3h6Ojo/i9WrVqMDY2xtOnT+Xqb9asmfjPqqqqcHd3L3HUR3JyMlRVVfH555+L24yNjdGgQQPxmNGjR2P27Nlo0aIFgoKCcPny5TLbwMnJSS5uAHKxy7bJYi/tHA0bNoSOjo445Qh4Pwrp2rVrePbsmTi6QSqVIjo6Grm5uTh9+rQ44qE8Mcqm/sniSU5OlmsTQL5dZWVatGght61FixZiuxkYGMDZ2RnR0dG4cuUK1NTUMGTIEFy8eBHZ2dmIiYkRE1BGRkbw9/eHt7c3fHx8EBYWJjelqTzXUFI7F+0fMs7Ozmjbti0cHR3xzTffYOXKleK0q6dPn+LRo0cl9uGiZFPGSvr0798fb9++RY8ePcRRNoWVdb7k5GTUqlVLTEgBgIODAwwMDOT6to2NjZiQkl2/g4NDseeotGdG9r2kZ6a0dgPeJypu3bqFs2fPAoCYwJE975V5nooqT7wf0jdKOpeRkZHc3wbZSKmK0NLSEhNSwPtnr3AcT548weDBg2Frawt9fX3o6ekhOzsb9+7dk6vH3d1d7nt5nlkvLy9xpGJMTAzatGkjjrqMj49Hbm6u3DP9yy+/wM3NDaamptDR0cFvv/1WLA5HR0e5daQuXbqEW7duQVdXV/y7ZWRkhLdv3yI1NVVhmwQGBiIzM1P83L9/v6TmIyIiIiKi/6hyJ6U0NTU/ygmLLtwrkUgUbisoKPgo5yvJoEGDcPv2bfj6+uLKlStwd3fHzz//XOoxheOUjRZQtE0We2nnOHjwIBITE5GYmCiuv+To6AgjIyPExMTIJaViYmLEH5eykV8VifFjt6UsUSZLQBkZGcHe3h6nTp2SS0oBwNq1a3HmzBk0b94cW7duRf369cXERkWuoei2kq6pWrVqOHr0KA4dOgQHBwf8/PPPaNCgAe7cuVPhPlyjRg0kJyeX+FmxYgWqVauG+fPnK1yQ+p/0zJTWbgBgZmYGHx8frF27Fk+ePMGhQ4fEqXtA5Z6nyviQvlFelblviu5H4UGofn5+SExMRFhYGE6fPo3ExEQYGxsXm/pWmTcSSqVSXLt2DTdv3sS1a9fQsmVLuWfU3d1dnPK7ZcsWTJw4EQMHDsSRI0eQmJiIgICAMuPIzs6Gm5ub+DdL9rlx4wb69u2rMC51dXXo6enJfYiIiIiIiAord1LK1tYWmpqaiIyMVLjf3t4ely5dkltQOjY2FioqKuJCuR+icCIjLy8PFy5cgL29fYmx5OXlya2x8+LFC6SkpMDBwUHcVqtWLQwbNgy7du3ChAkTsHLlyg+Os6iSzmFtbY169eqhXr16qFGjBoD3P2RbtWqFvXv34urVq2jZsiWcnJyQk5ODFStWwN3dvVI/WmXs7e2LrTtUNEFkb2+P2NhYuW2xsbFy7SZbVyoyMlIcuSWVSrF582bcuHGj2Giuxo0bIzAwEKdPn0ajRo2wadOmSl9DeUgkErRo0QIhISG4ePEi1NTUsHv3bujq6sLGxqbEPlxU9erVYWdnp/CTl5eHCRMmYMGCBRg9erTC48s6n729Pe7fvy83guTatWt49eqVXHtXVtF7e/bs2RKfGaDkdpMZNGgQtm7dit9++w2fffZZsRF1H/o8VTTeD1H4XBkZGbhx44Z4Licnp3L3kfKKjY3F6NGj0bFjR3HR++fPn5d5XHmeWUdHRxgaGmL27NlwcXGBjo6OmMyOjo6Wex5lU5qHDx+Oxo0bo169eiWOdCrM1dUVN2/ehJmZmfh3S/bh2y+JiIiIiKiyyp2U0tDQwJQpUzB58mSsX78eqampOHv2LFavXg0A6NevHzQ0NODn54ekpCRERUVh1KhR8PX1FafZfIhffvkFu3fvxvXr1zFixAhkZGTIjdSws7MTf0Db2tqiS5cuGDx4ME6dOoVLly7h22+/RY0aNdClSxcA798cFhERgTt37iAhIQFRUVFyP4AL11dZZZ1DEVlyR/bjUkVFBZ6enti4cWO51mUqzejRo3H48GEsWLAAN2/exNKlS+Xemge8XwA6PDwcy5cvx82bN7Fo0SLs2rVLbtFmT09PvH79Gvv375dLSm3cuBGWlpaoX78+AODOnTsIDAzEmTNncPfuXRw5cgQ3b94U2+DcuXOws7PDw4cPP+i6CouLixMXhb537x527dqFZ8+eiecMDg7GwoULsWTJEty8eRMJCQmVGtFjZ2eH33//XVwTqSSlna9du3ZwdHREv379kJCQgHPnzqF///7w8vIqNo2rMrZv3441a9bgxo0bCAoKwrlz5+RePNC2bVssXboUQNntBgDe3t7Q09PD7NmzERAQIHeuj/E8lRVvZezevRt2dnbFts+cORORkZFISkqCv78/TExMxDc4BgYGIj4+HsOHD8fly5dx/fp1LF++XEwiLV26tMLT+2xtbbFhwwYkJycjLi4O/fr1K9eIrDFjxmDNmjVYu3at2C5Xr16VKyN7ScLGjRvF51GWzI6MjJT7u2Fra4vz588jIiICN27cwPTp0xEfH19mHP369YOJiQm6dOmCkydP4s6dO4iOjsbo0aOLvZSCiIiIiIiovCr09r3p06djwoQJmDFjBuzt7dGrVy9x3RQtLS1ERETg5cuX8PDwwNdffy33o/dDhYaGIjQ0FM7Ozjh16hT27dsHExMTcX9KSgoyMzPF72vXroWbmxs6d+6MZs2aQRAEHDx4UJxmk5+fjxEjRsDe3h7t27dH/fr15RaALlpfZZR1DkW8vLyQn58vN7pBKpUW21YZTZs2xcqVKxEWFgZnZ2ccOXIE06ZNkyvTtWtXhIWFYcGCBWjYsCFWrFiBtWvXyp3b0NAQjo6OMDU1FX/we3p6oqCgQO4HsJaWFq5fv44ePXqgfv36GDJkCEaMGIGhQ4cCeP/GspSUFIXrMVWWnp4eTpw4gY4dO6J+/fqYNm0aFi5cKK7b5efnh8WLF2PZsmVo2LAhOnfujJs3b1b4PKqqqmKCszSlnU8ikWDv3r0wNDSEp6cn2rVrh7p162Lr1q0VjkeRkJAQbNmyBU5OTli/fj02b94sNwIrNTVVTLSU1W4AoKKiAn9/f+Tn56N///5y5/oYz1NZ8VZGZmam3Jp2MqGhoRgzZgzc3Nzw+PFj/PHHH+IaSvXr18eRI0dw6dIlNGnSBM2aNcPevXuhqqoKAHj+/Hm5RhcVtnr1amRkZMDV1RW+vr4YPXo0zMzMyjyuV69emD59OiZPngw3NzfcvXsX3333XbFyRf9uyJLZstFvMkOHDkX37t3Rq1cvfP7553jx4gWGDx9eZhxaWlo4ceIEateuje7du8Pe3h4DBw7E27dvOS2PiIiIiIgqrdxv36sqsrduXbx4ES4uLlUdDtE/QuE3M35MAwcOxLNnz7Bv376PWq+yyN6+l5GRAQMDg6oO5z9F9vYNvn2PiKhsfPseERH905X37XuqSoyJiP6hMjMzceXKFWzatOkfm5AiIiIiIiKiTwuTUkRUpi5duuDcuXMYNmwYvvjii6oOh4iIiIiIiP4FPvmklI2NDT7xGYZEn5yP/cxER0d/1PqqilQq5d8TIiIiIiKiT0SFFjonIiIiIiIiIiL6GJiUIiIiIiIiIiIipWNSioiIiIiIiIiIlI5JKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqVjUoqIiIiIiIiIiJSOSSkiIiIiIiIiIlI6JqWIiIiIiIiIiEjpVKs6ACIi+u+wPBYFPT29qg6DiIiIiIg+ARwpRURERERERERESsekFBERERERERERKR2TUkREREREREREpHRMShERERERERERkdIxKUVERERERERERErHpBQRERERERERESkdk1JERERERERERKR0TEoREREREREREZHSqVZ1AERE9N+R3q41slWrVXUYRET/eFanz1V1CERERB+MI6WIiIiIiIiIiEjpmJQiIiIiIiIiIiKlY1KKiIiIiIiIiIiUjkkpIiIiIiIiIiJSOialiIiIiIiIiIhI6ZiUIiIiIiIiIiIipWNSioiIiIiIiIiIlI5JKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqVjUoqIiIiIiIiIiJSOSSkiIiIiIiIiIlI6JqXok5eWlgaJRILExESlnC86OhoSiQSvXr36oHokEgn27NnzUWKi/xMcHAwXFxfxu7+/P7p27VqhOmxsbLB48eKPGldFSaVSjB07tsLHfYz+WdlzExERERERfUyqVR0AUUVFR0ejdevWyMjIgIGBwQfVJZVK4eLi8rckKNLT02FoaPjR6yV5YWFhEAShQsfEx8dDW1v7b4ro79W8eXOkp6dDX1+/zLIlPSu7du1C9erV/8YoiYiIiIiIysakFNHfxMLCoqpD+Ed59+4d1NTUKnxceZIzRZmamlb4mE9Bbm4u1NTUPrhvGRkZfaSIiIiIiIiIKo/T96jKHT58GC1btoSBgQGMjY3RuXNnpKamKiyblpaG1q1bAwAMDQ0hkUjg7++vsOyLFy/Qp08f1KhRA1paWnB0dMTmzZvF/f7+/oiJiUFYWBgkEgkkEgnS0tLE/RcuXIC7uzu0tLTQvHlzpKSkyNW/d+9euLq6QkNDA3Xr1kVISAjy8vLE/YWn77179w4jR46EpaUlNDQ0YG1tjblz58qVXbFiBTp37gwtLS3Y29vjzJkzuHXrFqRSKbS1tdG8efMS26Usd+7cwZ9//llqmbJivHfvHrp06QIdHR3o6emhZ8+eePLkiVwdf/zxBzw8PKChoQETExN069atxPPJpuGtWrUKderUgYaGBgDg1atXGDRoEExNTaGnp4c2bdrg0qVLJdZTdPre69ev0a9fP2hra8PS0hI//fRTselqRafvlXVtslg3bNgAGxsb6Ovro3fv3nj9+nWpbRobGwupVAotLS0YGhrC29sbGRkZ4v6CggJMnjwZRkZGsLCwQHBwsNzxEokEy5cvx1dffQVtbW3MmTOn2PS9u3fvwsfHB4aGhtDW1kbDhg1x8ODBUp+Vou2xYcMGuLu7Q1dXFxYWFujbty+ePn0q7pedMzIystRngoiIiIiIqCKYlKIq9+bNG4wfPx7nz59HZGQkVFRU0K1bNxQUFBQrW6tWLezcuRMAkJKSgvT0dISFhSms9+3bt3Bzc8OBAweQlJSEIUOGwNfXF+fOnQPwftpXs2bNMHjwYKSnpyM9PR21atUSj//++++xcOFCnD9/HqqqqhgwYIC47+TJk+jfvz/GjBmDa9euYcWKFQgPD8ecOXMUxrJkyRLs27cP27ZtQ0pKCjZu3AgbGxu5MrNmzUL//v2RmJgIOzs79O3bF0OHDkVgYCDOnz8PQRAwcuTICrWtzIQJE9C5c2f89ddfJZYpLcaCggJ06dIFL1++RExMDI4ePYrbt2+jV69e4vEHDhxAt27d0LFjR1y8eBGRkZFo0qRJqXHdunULO3fuxK5du8Q1w7755hs8ffoUhw4dwoULF+Dq6oq2bdvi5cuX5brW8ePHIzY2Fvv27cPRo0dx8uRJJCQklFi+PNcGAKmpqdizZw/279+P/fv3IyYmBqGhoSXWm5iYiLZt28LBwQFnzpzBqVOn4OPjg/z8fLHMunXroK2tjbi4OMyfPx8zZ87E0aNH5eoJDg5Gt27dcOXKFbk+KDNixAjk5OTgxIkTuHLlCubNmwcdHZ0KPSu5ubmYNWsWLl26hD179iAtLU1hsre0Z4KIiIiIiKiiOH2PqlyPHj3kvq9Zswampqa4du0aGjVqJLevWrVq4tQjMzOzUteUqlGjBiZOnCh+HzVqFCIiIrBt2zY0adIE+vr6UFNTg5aWlsLpUHPmzIGXlxcAYOrUqejUqRPevn0LDQ0NhISEYOrUqfDz8wMA1K1bF7NmzcLkyZMRFBRUrK579+7B1tYWLVu2hEQigbW1dbEyAQEB6NmzJwBgypQpaNasGaZPnw5vb28AwJgxYxAQEFDi9ZZm7dq1aNeuHXx8fPDHH39AU1OzQjFGRkbiypUruHPnjpi4W79+PRo2bIj4+Hh4eHhgzpw56N27N0JCQsTjnJ2dS43r3bt3WL9+vTid7tSpUzh37hyePn0KdXV1AMCCBQuwZ88e7NixA0OGDCm1vtevX2PdunXYtGkT2rZtK167lZVViceU59qA98mr8PBw6OrqAgB8fX0RGRlZYiJy/vz5cHd3x7Jly8RtDRs2lCvj5OQk9hdbW1ssXboUkZGR+OKLL8Qyffv2lbvvt2/flqvj3r176NGjBxwdHQG874sy5X1WCieX6tatiyVLlsDDwwPZ2dnQ0dER95X2TBSVk5ODnJwc8XtWVlaJ5yciIiIiov8mjpSiKnfz5k306dMHdevWhZ6enjg65969ex9Ub35+PmbNmgVHR0cYGRlBR0cHERER5a7XyclJ/GdLS0sAEKc0Xbp0CTNnzoSOjo74kY24UjRNzt/fH4mJiWjQoAFGjx6NI0eOlHo+c3NzABATDbJtb9++LfHHvb+/vzgNsejHwMBAHIm2YMGCEo8vKcbk5GTUqlVLbiSZg4MDDAwMkJycDOD/RgZVhLW1tdz6TpcuXUJ2djaMjY3l2vbOnTvlmrp4+/Zt5Obmyo3Q0tfXR4MGDUo8pjzXBryf8idLSAHv+0ThKW5Flac9Ct/zkup0d3cvtY7Ro0dj9uzZaNGiBYKCgnD58uVSyyty4cIF+Pj4oHbt2tDV1RUTT0WfldKeiaLmzp0LfX198VO4fYmIiIiIiACOlKJPgI+PD6ytrbFy5UpYWVmhoKAAjRo1wrt37z6o3h9//BFhYWFYvHgxHB0doa2tjbFjx5a73sJvJ5NIJAAgTinMzs5GSEgIunfvXuw4RaNGXF1dcefOHRw6dAjHjh1Dz5490a5dO+zYsaPU85UWQ1Fz587F1KlTFe7Ly8vDgAEDkJ2dXeJoo/LEWBpFo6/KUvQNeNnZ2bC0tER0dHSxsh/6psUPVfRtdRKJpMR7AZSvPcpTZ1lvCRw0aBC8vb1x4MABHDlyBHPnzsXChQsxatSoMs8PvJ8+6+3tDW9vb2zcuBGmpqa4d+8evL29iz0rFemPgYGBGD9+vPg9KyuLiSkiIiIiIpLDpBRVqRcvXiAlJQUrV65Eq1atALyfwlUa2RvaCq/No0hsbCy6dOmCb7/9FsD7H883btyAg4ODXF1l1aOIq6srUlJSUK9evXIfo6enh169eqFXr174+uuv0b59e7x8+fKjvQnN0tJSHL1SlJ+fH7KyshAdHS2OwqpIjPb29rh//z7u378vJhauXbuGV69eie3p5OSEyMjISk8xBN636+PHj6Gqqlpsza3yqFu3LqpXr474+HjUrl0bAJCZmYkbN27A09NT4THlubbKkLVH4emMf5datWph2LBhGDZsGAIDA7Fy5UqMGjWqXM/K9evX8eLFC4SGhorXf/78+Q+OSV1dXZyCSUREREREpAin71GVMjQ0hLGxMX777TfcunULx48flxtdoYi1tTUkEgn279+PZ8+eITs7GwCwdOlSuelStra2OHr0KE6fPo3k5GQMHTq02NvibGxsEBcXh7S0NDx//rzUkS+FzZgxA+vXr0dISAiuXr2K5ORkbNmyBdOmTVNYftGiRdi8eTOuX7+OGzduYPv27bCwsFDa6J+hQ4ciKipK4dpZ5YmxXbt2cHR0RL9+/ZCQkIBz586hf//+8PLyEqeXBQUFYfPmzQgKCkJycrK46LZMYGAg+vfvX2qc7dq1Q7NmzdC1a1ccOXIEaWlpOH36NL7//vtyJUp0dXXh5+eHSZMmISoqClevXsXAgQOhoqIijuxRdM6yrq08iva/wMBAxMfHY/jw4bh8+TKuX7+O5cuX4/nz5+WuszzGjh2LiIgI3LlzBwkJCYiKioK9vT2Akp+VwmrXrg01NTX8/PPPuH37Nvbt24dZs2Z91BiJiIiIiIgUYVKKqpSKigq2bNmCCxcuoFGjRhg3bhx+/PHHUo+pUaOGuNC4ubm5+Ea658+fy607NG3aNLi6usLb2xtSqRQWFhbo2rWrXF0TJ05EtWrV4ODgIE5bKg9vb2/s378fR44cgYeHB5o2bYqffvpJ4QLmwPtkiWzhaw8PD6SlpeHgwYNQUVHOI9i8efMSR1GVJ0aJRIK9e/fC0NAQnp6eaNeuHerWrYutW7eKx0ulUmzfvh379u2Di4sL2rRpI77pEADS09PLbF+JRIKDBw/C09MTAQEBqF+/Pnr37o27d++WOsKrsEWLFqFZs2bo3Lkz2rVrhxYtWsDe3l7htErZOcu6tvIo2v/q16+PI0eO4NKlS2jSpAmaNWuGvXv3QlX14w5Qzc/Px4gRI2Bvb4/27dujfv364uLqJT0rhZmamiI8PBzbt2+Hg4MDQkNDS1x3jIiIiIiI6GOSCIIgVHUQRER/lzdv3qBGjRpYuHAhBg4cWNXh/GdlZWVBX18f1z1coatararDISL6x7M6fa7sQkRERFVE9u//mZmZ0NPTK7Ec15Qion+Vixcv4vr162jSpAkyMzMxc+ZMAECXLl2qODIiIiIiIiIqjEkpIvrXWbBgAVJSUqCmpgY3NzecPHkSJiYmVR0WERERERERFcKkFBH9qzRu3BgXLlyo6jCIiIiIiIioDFzonIiIiIiIiIiIlI5JKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqVjUoqIiIiIiIiIiJSOSSkiIiIiIiIiIlI6JqWIiIiIiIiIiEjpmJQiIiIiIiIiIiKlY1KKiIiIiIiIiIiUTrWqAyAiov8Oy2NR0NPTq+owiIiIiIjoE8CRUkREREREREREpHRMShERERERERERkdIxKUVERERERERERErHpBQRERERERERESkdk1JERERERERERKR0TEoREREREREREZHSMSlFRERERERERERKx6QUEREREREREREpnWpVB0BERP8d6e1aI1u1WlWHQUT0r2d1+lxVh0BERFQmjpQiIiIiIiIiIiKlY1KKiIiIiIiIiIiUjkkpIiIiIiIiIiJSOialiIiIiIiIiIhI6ZiUIiIiIiIiIiIipWNSioiIiIiIiIiIlI5JKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqVjUoqIiIiIiIiIiJSOSSkiIiIiIiIiIlI6JqWIiIiIiIiIiEjpmJQiApCWlgaJRILExESlnC86OhoSiQSvXr36oHokEgn27NnzUWL61BW+VmXeL39/f3Tt2lX8LpVKMXbs2ArV8Snfp085NiIiIiIi+ndTreoAiD5F0dHRaN26NTIyMmBgYPBBdUmlUri4uGDx4sUfJbbC0tPTYWho+NHr/bukpaWhTp06uHjxIlxcXKo6nErZtWsXqlevXqFjPuX79CnHRkRERERE/25MShH9g1lYWFR1CP9Y7969g5qaWoWPMzIyqvAxn/J9+pRjIyIiIiKifzdO36P/hMOHD6Nly5YwMDCAsbExOnfujNTUVIVl09LS0Lp1awCAoaEhJBIJ/P39FZZ98eIF+vTpgxo1akBLSwuOjo7YvHmzuN/f3x8xMTEICwuDRCKBRCJBWlqauP/ChQtwd3eHlpYWmjdvjpSUFLn69+7dC1dXV2hoaKBu3boICQlBXl6euL/w1Kt3795h5MiRsLS0hIaGBqytrTF37ly5sitWrEDnzp2hpaUFe3t7nDlzBrdu3YJUKoW2tjaaN29eYruU5c6dO/jzzz9LLVOnTh0AQOPGjSGRSCCVSgEA8fHx+OKLL2BiYgJ9fX14eXkhISGh3OfOz8/HgAEDYGdnh3v37iksI5uGN2fOHFhZWaFBgwYAgPv376Nnz54wMDCAkZERunTpInePiio6fS89PR2dOnWCpqYm6tSpg02bNsHGxkZuZFzRKXJXrlxBmzZtoKmpCWNjYwwZMgTZ2dnFYl2wYAEsLS1hbGyMESNGIDc3t8S4goOD4eLigjVr1qB27drQ0dHB8OHDkZ+fj/nz58PCwgJmZmaYM2eO3HEV6UOvXr3C0KFDYW5uDg0NDTRq1Aj79+8vMSYiIiIiIqLSMClF/wlv3rzB+PHjcf78eURGRkJFRQXdunVDQUFBsbK1atXCzp07AQApKSlIT09HWFiYwnrfvn0LNzc3HDhwAElJSRgyZAh8fX1x7tw5AEBYWBiaNWuGwYMHIz09Henp6ahVq5Z4/Pfff4+FCxfi/PnzUFVVxYABA8R9J0+eRP/+/TFmzBhcu3YNK1asQHh4eLGkgsySJUuwb98+bNu2DSkpKdi4cSNsbGzkysyaNQv9+/dHYmIi7Ozs0LdvXwwdOhSBgYE4f/48BEHAyJEjK9S2MhMmTEDnzp3x119/lVhG1i7Hjh1Deno6du3aBQB4/fo1/Pz8cOrUKZw9exa2trbo2LEjXr9+XeZ5c3Jy8M033yAxMREnT55E7dq1SywbGRmJlJQUHD16FPv370dubi68vb2hq6uLkydPIjY2Fjo6Omjfvj3evXtXruvu378/Hj16hOjoaOzcuRO//fYbnj59WmL5N2/ewNvbG4aGhoiPj8f27dtx7NixYu0eFRWF1NRUREVFYd26dQgPD0d4eHipsaSmpuLQoUM4fPgwNm/ejNWrV6NTp0548OABYmJiMG/ePEybNg1xcXEKjy+tDxUUFKBDhw6IjY3F77//jmvXriE0NBTVqlUrVzsREREREREVxel79J/Qo0cPue9r1qyBqakprl27hkaNGsntq1atmjhFy8zMrNQ1pWrUqIGJEyeK30eNGoWIiAhs27YNTZo0gb6+PtTU1KClpaVwmtScOXPg5eUFAJg6dSo6deqEt2/fQkNDAyEhIZg6dSr8/PwAAHXr1sWsWbMwefJkBAUFFavr3r17sLW1RcuWLSGRSGBtbV2sTEBAAHr27AkAmDJlCpo1a4bp06fD29sbADBmzBgEBASUeL2lWbt2Ldq1awcfHx/88ccf0NTULFbG1NQUAGBsbCzXHm3atJEr99tvv8HAwAAxMTHo3LlziefMzs5Gp06dkJOTg6ioKOjr65cao7a2NlatWiVO2/v9999RUFCAVatWQSKRiNdhYGCA6OhofPnll6XWd/36dRw7dgzx8fFwd3cHAKxatQq2trYlHrNp0ya8ffsW69evh7a2NgBg6dKl8PHxwbx582Bubg7g/Si9pUuXolq1arCzs0OnTp0QGRmJwYMHl1h3QUEB1qxZA11dXTg4OKB169ZISUnBwYMHoaKiggYNGmDevHmIiorC559/Xuz40vrQsWPHcO7cOSQnJ6N+/foA3vfJkuTk5CAnJ0f8npWVVWJZIiIiIiL6b+JIKfpPuHnzJvr06YO6detCT09PHP1R0lSv8srPz8esWbPg6OgIIyMj6OjoICIiotz1Ojk5if9saWkJAOIom0uXLmHmzJnQ0dERP7IRV4qmyfn7+yMxMRENGjTA6NGjceTIkVLPJ0t+ODo6ym17+/ZtiQkEf39/cRpi0Y+BgYE4Em3BggXlun6ZJ0+eYPDgwbC1tYW+vj709PSQnZ1dZjv26dMHb968wZEjR8pMSMmutfA6UpcuXcKtW7egq6srtrGRkRHevn1brmmMKSkpUFVVhaurq7itXr16pS4cnpycDGdnZzEhBQAtWrRAQUGB3PTNhg0byo1CsrS0LHUEFgDY2NhAV1dX/G5ubg4HBweoqKjIbSupntL6UGJiImrWrCkmpMoyd+5c6Ovri5/CIwSJiIiIiIgAjpSi/wgfHx9YW1tj5cqVsLKyQkFBARo1alTuKVol+fHHHxEWFobFixfD0dER2traGDt2bLnrLfwWN9lIHdmUwuzsbISEhKB79+7FjtPQ0Ci2zdXVFXfu3MGhQ4dw7Ngx9OzZE+3atcOOHTtKPV9pMRQ1d+5cTJ06VeG+vLw8DBgwANnZ2RgyZIjiCy6Bn58fXrx4gbCwMFhbW0NdXR3NmjUrsx07duyI33//HWfOnCk22kqRwokg4H0bu7m5YePGjcXKykZ1VZWib/iTSCQl3pfSjqlIPaX1IUUj30oTGBiI8ePHi9+zsrKYmCIiIiIiIjlMStG/3osXL5CSkoKVK1eiVatWAIBTp06VeoxsNE1+fn6p5WJjY9GlSxd8++23AN4nc27cuAEHBwe5usqqRxFXV1ekpKSgXr165T5GT08PvXr1Qq9evfD111+jffv2ePnyZaXeGKeIpaWlOKKrKD8/P2RlZSE6OlochVVUSe0aGxuLZcuWoWPHjgDeLz7+/PnzMuP57rvv0KhRI3z11Vc4cOCAOBWyvFxdXbF161aYmZlBT0+vQscCQIMGDZCXl4eLFy/Czc0NAHDr1i1kZGSUeIy9vT3Cw8Px5s0bMUkWGxsrTq+raiX1IScnJzx48AA3btwo12gpdXV1qKurKyFiIiIiIiL6p+L0PfrXMzQ0hLGxMX777TfcunULx48flxvBoYi1tTUkEgn279+PZ8+eiW9GW7p0Kdq2bSuWs7W1xdGjR3H69GkkJydj6NChePLkiVxdNjY2iIuLQ1paGp4/f17maBeZGTNmYP369QgJCcHVq1eRnJyMLVu2YNq0aQrLL1q0CJs3b8b169dx48YNbN++HRYWFqWuifUxDR06FFFRUQrXzpIxMzODpqYmDh8+jCdPniAzMxPA+3bcsGEDkpOTERcXh379+pV7ZM6oUaMwe/ZsdO7cWS7Z2L9/fwQGBpZ6bL9+/WBiYoIuXbrg5MmTuHPnDqKjozF69Gg8ePCgzHPb2dmhXbt2GDJkCM6dO4eLFy9iyJAh0NTUFEedKTqnhoYG/Pz8kJSUhKioKIwaNQq+vr4lJvMUCQwMRP/+/ctdvjxK60NeXl7w9PREjx49cPToUXFE1eHDhz9qDERERERE9N/BpBT966moqGDLli24cOECGjVqhHHjxuHHH38s9ZgaNWqIC42bm5uLb0Z7/vy53FpD06ZNg6urK7y9vSGVSmFhYYGuXbvK1TVx4kRUq1YNDg4OMDU1Lfd6U97e3ti/fz+OHDkCDw8PNG3aFD/99JPCBcwBQFdXF/Pnz4e7uzs8PDyQlpYmLnCtDM2bNy9xFJWMqqoqlixZghUrVsDKygpdunQBAKxevRoZGRlwdXWFr68vRo8eDTMzs3Kfe+zYsQgJCUHHjh1x+vRpAO/XC0tPTy/1OC0tLZw4cQK1a9dG9+7dYW9vj4EDB+Lt27flHjm1fv16mJubw9PTE926dcPgwYOhq6urcIql7JwRERF4+fIlPDw88PXXX6Nt27ZYunRpua8XANLT0z94TbSiyupDO3fuhIeHB/r06QMHBwdMnjy5UqMAiYiIiIiIAEAiCIJQ1UEQEf1bPHjwALVq1cKxY8fkRtX912VlZUFfXx/XPVyhq1qt7AOIiOiDWJ0+V9UhEBHRf5js3/8zMzNL/Q/+XFOKiOgDHD9+HNnZ2XB0dER6ejomT54MGxsbeHp6VnVoREREREREnzQmpYiIPkBubi7+97//4fbt29DV1UXz5s2xcePGYm+9IyIiIiIiInlMShERfQBvb294e3tXdRhERERERET/OFzonIiIiIiIiIiIlI5JKSIiIiIiIiIiUjompYiIiIiIiIiISOmYlCIiIiIiIiIiIqVjUoqIiIiIiIiIiJSOSSkiIiIiIiIiIlI6JqWIiIiIiIiIiEjpmJQiIiIiIiIiIiKlY1KKiIiIiIiIiIiUTrWqAyAiov8Oy2NR0NPTq+owiIiIiIjoE8CRUkREREREREREpHRMShERERERERERkdIxKUVERERERERERErHpBQRERERERERESkdk1JERERERERERKR0TEoREREREREREZHSMSlFRERERERERERKx6QUEREREREREREpHZNSRERERERERESkdKpVHQAREf13pLdrjWzValUdBhERlYPV6XNVHQIREf3LcaQUEREREREREREpHZNSRERERERERESkdExKERERERERERGR0jEpRURERERERERESsekFBERERERERERKR2TUkREREREREREpHRMShERERERERERkdIxKUVERERERERERErHpBQRERERERERESkdk1JERERERERERKR0TEoREREREREREZHSMSlFRERERERERERKx6QUUSn8/f3RtWtX8btUKsXYsWP/9vNGR0dDIpHg1atXAIDw8HAYGBhUqI6isX9KPuXYykMikWDPnj1KOVdaWhokEgkSExM/qB4bGxssXrz4o8RERERERET0MahWdQBEyiCVSuHi4vKP/VHeq1cvdOzYsULHhIWFQRCEvymiD/Mpx1ZRaWlpqFOnDi5evAgXF5cPqsvf3x+vXr36WxJe8fHx0NbW/uj1EhERERERVRaTUkRKJAgC8vPzoapasUdPU1MTmpqaFTpGX1+/QuWV6VOO7d/K1NS0qkMgIiIiIiKSw+l79K/n7++PmJgYhIWFQSKRQCKRIC0tDfn5+Rg4cCDq1KkDTU1NNGjQAGFhYRWq+8CBA9DX18fGjRsV7pdNwzt06BDc3Nygrq6OU6dOoaCgAHPnzhXP7ezsjB07dpR4HkXT92bPng0zMzPo6upi0KBBmDp1qtxInaJT5HJycjB69GiYmZlBQ0MDLVu2RHx8fLFYIyMj4e7uDi0tLTRv3hwpKSklxiWbWrZt2za0atUKmpqa8PDwwI0bNxAfHw93d3fo6OigQ4cOePbsWYmx7dixA46OjtDU1ISxsTHatWuHN2/eiPvXrFmDhg0bQl1dHZaWlhg5cmSJMZUmKSmpzDLx8fH44osvYGJiAn19fXh5eSEhIaHE8nXq1AEANG7cGBKJBFKpVGG5svpbcHAw1q1bh71794r9NDo6Wtx/+/ZttG7dGlpaWnB2dsaZM2fk6j916pR4D2rVqoXRo0fLtWHh6XuCICA4OBi1a9eGuro6rKysMHr0aLmys2fPRv/+/aGjowNra2vs27cPz549Q5cuXaCjowMnJyecP3++zPYkIiIiIiIqCZNS9K8XFhaGZs2aYfDgwUhPT0d6ejpq1aqFgoIC1KxZE9u3b8e1a9cwY8YM/O9//8O2bdvKVe+mTZvQp08fbNy4Ef369Su17NSpUxEaGork5GQ4OTlh7ty5WL9+PX799VdcvXoV48aNw7fffouYmJhynXvjxo2YM2cO5s2bhwsXLqB27dpYvnx5qcdMnjwZO3fuxLp165CQkIB69erB29sbL1++lCv3/fffY+HChTh//jxUVVUxYMCAMuMJCgrCtGnTkJCQAFVVVfTt2xeTJ0/G/2vvvuOqLP8/jr+PIEOWCxFz4GAqKCqWUo7EL2r61bQkMxF3X7eJg8qtSaYlZs4stJxljnLiosSBC0ciKmlYkaMUHIUK/v7wwfl5lKXlwfL1fDzO48G57+u+7899nwvTd9d1naioKH333Xc6deqURo0aleOxqamp6tixo7p166bExERt375d7dq1M07vmzVrlvr27atevXrpyJEjWrNmjapVq1ag53S3gwcPKiAgQGvWrMmz3ZUrV9SlSxft2LFDu3fvlru7u1q2bKkrV67k2D4+Pl6StHnzZqWmpuqrr77KsV1+/S08PFwdOnRQ8+bNjf20QYMGxuPfeusthYeHKyEhQR4eHurYsaNu3bolSUpOTlbz5s3Vvn17HT58WMuWLdOOHTtyDe9WrFihDz74QHPmzNHJkye1atUq+fr6mrT54IMPFBgYqIMHD+qFF15Q586dFRoaqtdee00HDhxQ1apVFRoamus0zIyMDKWnp5u8AAAAAOBuTN/Dv56Tk5OsrKxUrFgxlS1b1rjdwsJCY8eONb6vXLmydu3apeXLl6tDhw55nvOjjz7SW2+9pa+//lqNGjXKt4Zx48apWbNmku78Y/2dd97R5s2bVb9+fUlSlSpVtGPHDs2ZM6dA5/vwww/VvXt3de3aVZI0atQobdq0SVevXs2x/bVr1zRr1ixFR0erRYsWkqR58+YpJiZG8+fP19ChQ41tJ06caKxhxIgReuGFF/Tnn3/KxsYm13rCw8MVHBwsSRo4cKA6duyoLVu2KDAwUJLUvXt3RUdH53hsamqqbt26pXbt2qlSpUqSZBKQTJgwQUOGDNHAgQON2wICAvJ8Pjnx9/fX3LlzFRISoi+//FIvvPBCju2ef/55k/dz585V8eLFFRsbq1atWt3XPntaXKlSpUz6172KFi2aZ3+zt7eXra2tMjIycjxPeHi4seaxY8eqevXqOnXqlLy8vDRp0iR16tTJuAi/u7u7pk+frkaNGmnWrFn3fXYpKSkqW7asgoKCVLRoUVWsWFH16tUzadOyZUv17t1b0p3+NWvWLAUEBOjll1+WJA0fPlz169fXuXPncqx30qRJJvcLAAAAAPdipBSeaB999JHq1KkjZ2dn2dvba+7cuUpJScnzmC+//FKDBw9WTExMgQIkSapbt67x51OnTun69etq1qyZ7O3tja+FCxcqOTm5QOdLSkq6L0S49/3dkpOTdfPmTWNIJN0JSerVq6fExESTtn5+fsafXV1dJUnnz5/Ps567j3FxcZFkGiy5uLjkeo6aNWuqadOm8vX11csvv6x58+bp0qVLxuv+8ssvatq0aZ7Xz5Y9nTC3V2hoqP7880+1b99eN2/ezPEc586dU8+ePeXu7i4nJyc5Ojrq6tWr+faLgniY/pYtr8/l0KFDio6ONulPwcHBysrK0unTp+8718svv6w//vhDVapUUc+ePbVy5UrjqKucrpfbZ3p3DfeKiIhQWlqa8XX27NkC3ScAAACAJwcjpfDEWrp0qcLDwzV16lTVr19fDg4Oeu+997Rnz548j/P399eBAwf0ySefqG7dujIYDPle6+5vPcsezbR27Vo99dRTJu2sra0f4k7+XkWLFjX+nH1vWVlZD3zMvdtyO4eFhYViYmK0c+dObdq0SR9++KHeeust7dmzR6VLl36g2p966qn7Qra7ffvtt+rTp48mT55sUt/dunTpot9++01RUVGqVKmSrK2tVb9+fd24ceOBarnXw/a3bHl9LlevXlXv3r1N1oXKVrFixfu2VahQQUlJSdq8ebNiYmLUp08fvffee4qNjTVepyCf6d013Mva2vqx6M8AAAAAHl+EUngiWFlZKTMz02RbXFycGjRooD59+hi3FWSkUtWqVTV16lQ1btxYFhYWmjFjxgPV4uPjI2tra6WkpBR4pNW9PD09tXfvXoWGhhq33b1oeU41W1lZKS4uzjhF7ubNm9q7d69xyldhMhgMCgwMVGBgoEaNGqVKlSpp5cqVeuONN+Tm5qYtW7aoSZMm+Z6naNGi8vLyynHf0aNHNWTIEE2ZMiXH8CZbXFycZs6cqZYtW0qSzp49q4sXL+ba3srKSpLu6185nTe//pZTPy2I2rVr69ixYw+01patra1at26t1q1bq2/fvvLy8tKRI0dUu3btB74+AAAAADwMpu/hieDm5qY9e/bozJkzunjxorKysuTu7q59+/Zp48aNOnHihEaOHJlnsHM3Dw8Pbdu2TStWrDAJdVauXJlrKJLNwcFB4eHhGjx4sBYsWKDk5GQdOHBAH374oRYsWFCg6/fv31/z58/XggULdPLkSU2YMEGHDx/OddSWnZ2d/ve//2no0KHasGGDjh07pp49e+r69evq3r17ga4p3VnU28vLSz///HOBj8nPnj179M4772jfvn1KSUnRV199pQsXLsjb21vSnW+lmzp1qqZPn66TJ08an9WD8vLy0ueff55vCOfu7q7PPvtMiYmJ2rNnjzp16iRbW9tc25cpU0a2trbasGGDzp07p7S0NEn394WC9Dc3NzcdPnxYSUlJunjxYq5TDO81fPhw7dy5U/369VNCQoJOnjyp1atX57rQeXR0tObPn6+jR4/qhx9+0Oeffy5bW1tjYAkAAAAA5kAohSdCeHi4LCws5OPjI2dnZ6WkpKh3795q166dQkJC9PTTT+u3334zGcWSH09PT23dulVLlizRkCFDJElpaWlKSkrK99jx48dr5MiRmjRpkry9vdW8eXOtXbtWlStXLtC1O3XqpIiICIWHh6t27do6ffq0wsLC8lyMPDIyUu3bt1fnzp1Vu3ZtnTp1Shs3blSJEiUKdsOSrl+/rqSkpAKHJQXh6Oiob7/9Vi1btpSHh4fefvttTZ061bgge5cuXTRt2jTNnDlT1atXV6tWrXTy5MkHvo6lpaXatGmTb7v58+fr0qVLql27tjp37qwBAwaoTJkyeZ53+vTpmjNnjsqVK2e8xr19oSD9rWfPnvL09FTdunXl7OysuLi4At2bn5+fYmNjdeLECT333HPy9/fXqFGjVK5cuRzbFy9eXPPmzVNgYKD8/Py0efNmff311ypVqlSBrgcAAAAAfwfD7dy+zxvAP0qzZs1UtmxZffbZZ4VdCnCf9PR0OTk56XhAbTlYWhR2OQCAAii3M76wSwAA/ENl//0/LS1Njo6OubZjTSngH+j69euaPXu2goODZWFhoSVLlhgXrQYAAAAA4J+AUAr4BzIYDFq3bp0mTpyoP//8U56enlqxYoWCgoIKuzQAAAAAAAqEUAr4B7K1tdXmzZsLuwwAAAAAAB4aC50DAAAAAADA7AilAAAAAAAAYHaEUgAAAAAAADA7QikAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZHKAUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwsC7sAAMCTw3XzNjk6OhZ2GQAAAAAeA4yUAgAAAAAAgNkRSgEAAAAAAMDsCKUAAAAAAABgdoRSAAAAAAAAMDtCKQAAAAAAAJgdoRQAAAAAAADMjlAKAAAAAAAAZkcoBQAAAAAAALOzLOwCAABPjtSgJrpqaVHYZQAA/gbldsYXdgkAgH84RkoBAAAAAADA7AilAAAAAAAAYHaEUgAAAAAAADA7QikAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZHKAUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwIpQAAAAAAAGB2hFIAAAAAAAAwO0IpAAAAAAAAmB2hFGAmY8aMUa1atf7yedzc3DRt2rS/fB78+xkMBq1atSrX/du3b5fBYNDly5fNVhMAAAAAZCOUAswkPDxcW7ZsKewyAKMGDRooNTVVTk5OhV0KAAAAgCeQZWEXADwp7O3tZW9vX9hl4DF2+/ZtZWZmytLSPH80W1lZqWzZsma5FgAAAADci5FSeOxkZWVp8uTJqlatmqytrVWxYkVNnDjRuP/IkSN6/vnnZWtrq1KlSqlXr166evWqcX9YWJjatm2rd955Ry4uLipevLjGjRunW7duaejQoSpZsqTKly+vTz/91HjMmTNnZDAYtHTpUjVo0EA2NjaqUaOGYmNjc61zxowZqlGjhvH9qlWrZDAYNHv2bOO2oKAgvf3225Lun76XXeeUKVPk6uqqUqVKqW/fvrp586axzfnz59W6dWvZ2tqqcuXKWrRo0X11pKSkqE2bNrK3t5ejo6M6dOigc+fOSZLS0tJkYWGhffv2GZ9tyZIl9cwzzxiP//zzz1WhQgVJ0o0bN9SvXz+5urrKxsZGlSpV0qRJk3K8/z///FPVq1dXr169jNuSk5Pl4OCgTz75JNfnlpvz58/r/Pnz+ba7fPmyevfuLRcXF+Pn9M033xj3r1ixQtWrV5e1tbXc3Nw0depUk+Pd3Nw0YcIEhYaGyt7eXpUqVdKaNWt04cIF43P08/MzPjNJio6OVvHixbVq1Sq5u7vLxsZGwcHBOnv2bJ617ty5U7Vq1ZKNjY3q1q1r7CMJCQmS/n/63Pr161WnTh1ZW1trx44dSk5OVps2beTi4iJ7e3sFBARo8+bN993H+PHj1bFjR9nZ2empp57SRx99dF8NFy9e1IsvvqhixYrJ3d1da9asMe7LafpeXFycGjdurGLFiqlEiRIKDg7WpUuXJElffvmlfH19jb97QUFBunbtWt4fGAAAAADkglAKj52IiAhFRkZq5MiROnbsmBYvXiwXFxdJ0rVr1xQcHKwSJUpo7969+uKLL7R582b169fP5Bxbt27VL7/8om+//Vbvv/++Ro8erVatWqlEiRLas2ePXn/9dfXu3Vs//fSTyXFDhw7VkCFDdPDgQdWvX1+tW7fWb7/9lmOdjRo10rFjx3ThwgVJUmxsrEqXLq3t27dLkm7evKldu3apcePGud7rtm3blJycrG3btmnBggWKjo5WdHS0cX9YWJjOnj2rbdu26csvv9TMmTNNgpusrCy1adNGv//+u2JjYxUTE6MffvhBISEhkiQnJyfVqlXLWNORI0dkMBh08OBBY5AXGxurRo0aSZKmT5+uNWvWaPny5UpKStKiRYvk5uaWY+02NjZatGiRFixYoNWrVyszM1OvvfaamjVrpm7duuV6z7mJjIxU06ZNdfHixVzbZGVlqUWLFoqLi9Pnn3+uY8eOKTIyUhYWFpKk/fv3q0OHDnrllVd05MgRjRkzRiNHjjR5ppL0wQcfKDAwUAcPHtQLL7ygzp07KzQ0VK+99poOHDigqlWrKjQ0VLdv3zYec/36dU2cOFELFy5UXFycLl++rFdeeSXXWtPT09W6dWv5+vrqwIEDGj9+vIYPH55j2xEjRigyMlKJiYny8/PT1atX1bJlS23ZskUHDx5U8+bN1bp1a6WkpJgc995776lmzZo6ePCgRowYoYEDByomJsakzdixY9WhQwcdPnxYLVu2VKdOnfT777/nWEdCQoKaNm0qHx8f7dq1Szt27FDr1q2VmZmp1NRUdezYUd26dVNiYqK2b9+udu3amTwjAAAAAHgQhtv8iwKPkStXrsjZ2VkzZsxQjx497ts/b948DR8+XGfPnpWdnZ0kad26dWrdurV++eUXubi4KCwsTNu3b9cPP/ygIkXu5K5eXl4qU6aMvv32W0lSZmamnJyc9PHHH+uVV17RmTNnVLlyZUVGRhqDg1u3bqly5crq37+/hg0bdl8tt2/flrOzs2bPnq2XXnpJ/v7+CgkJUVRUlFJTUxUXF6cmTZro8uXLKlasmMaMGaNVq1YZR8lk15mcnGwMVTp06KAiRYpo6dKlOnHihDw9PRUfH6+AgABJ0vHjx+Xt7a0PPvhAgwYNUkxMjFq0aKHTp08bRzsdO3ZM1atXNx43ZMgQJSUl6ZtvvlFUVJR27dql48ePKzIyUs2bN5e7u7uGDRumnj17asCAAfr++++1efNmGQyGAn1m7733niZPnqxXXnlFK1as0JEjR1SqVKmCfuRGN27cULt27XT27Flt3bo1x3Ns2rRJLVq0UGJiojw8PO7b36lTJ124cEGbNm0ybhs2bJjWrl2r77//XtKdEUbPPfecPvvsM0nSr7/+KldXV40cOVLjxo2TJO3evVv169dXamqqypYtq+joaHXt2lW7d+/W008/Len/P4s9e/aoXr1699Uye/Zsvf322/rpp59kY2MjSfr444/Vs2dPHTx40BgWNmnSRKtWrVKbNm3yfD41atTQ66+/bgxg3dzc5O3trfXr1xvbvPLKK0pPT9e6desk3Vno/O2339b48eMl3Ql17e3ttX79ejVv3tx4/UuXLql48eJ69dVXlZKSoh07dtx3/QMHDqhOnTo6c+aMKlWqlGetkpSRkaGMjAzj+/T0dFWoUEHHA2rLwdIi3+MBAI+/cjvjC7sEAMBjKj09XU5OTkpLS5Ojo2Ou7RgphcdKYmKiMjIy1LRp01z316xZ0xhISVJgYKCysrKUlJRk3Fa9enVjICVJLi4u8vX1Nb63sLBQqVKl7psuVr9+fePPlpaWqlu3rhITE3OsxWAwqGHDhtq+fbsuX76sY8eOqU+fPsrIyNDx48cVGxurgIAAFStWLNf7rV69ujGQkiRXV1djTYmJibK0tFSdOnWM+728vFS8eHGT51GhQgVjICVJPj4+Kl68uLHuRo0aaceOHcrMzFRsbKwaN26sxo0ba/v27frll1906tQp42iusLAwJSQkyNPTUwMGDDAJd3IzZMgQeXh4aMaMGfrkk0/yDKTGjBkjg8GQ48va2lpr167V4cOHcwwBpTsjecqXL59jIJX9PAIDA022BQYG6uTJk8rMzDRu8/PzM/6cPQrv7v6Rve3u/mFpaWkMB6X//yxy6x9JSUny8/MzBlKScgyvJKlu3bom769evarw8HB5e3urePHisre3V2Ji4n0jpe7ur9nv763n7nu1s7OTo6NjrtMks0dK5aRmzZpq2rSpfH199fLLL2vevHnGaX05mTRpkpycnIyvu/soAAAAAEiEUnjM2Nra/i3nKVq0qMl7g8GQ47asrKy/dJ3scOe7776Tv7+/HB0djUHV3dPiHqTOv1rTvRo2bKgrV67owIED+vbbb01CqdjYWJUrV07u7u6SpNq1a+v06dMaP368/vjjD3Xo0EEvvfRSnuc/f/68Tpw4IQsLC508eTLPtv369VNiYmKurxdeeEGurq65TnN7FP0je0RYTtv+7s8iN3eHrNKdb2pcuXKl3nnnHX333XdKSEiQr6+vbty48cDnfpA+ltfztbCwUExMjNavXy8fHx99+OGH8vT01OnTp3NsHxERobS0NOMrv/W3AAAAADx5CKXwWHF3d5etra22bNmS435vb28dOnTIZHHluLg4FSlSRJ6enn/5+rt37zb+fOvWLe3fv1/e3t65ts9eV+qLL74wjjZq3LixNm/ebFww+mF5eXkZa8iWlJRksii1t7e3zp49a/IP/mPHjuny5cvy8fGRJBUvXlx+fn6aMWOGihYtKi8vLzVs2FAHDx7UN998c19w5ujoqJCQEM2bN0/Lli3TihUrcl2DSJK6desmX19fLViwQMOHD8915JAklS5dWl5eXjm+lixZon379mnr1q25joTy8/PTTz/9pBMnTuS439vbW3FxcSbb4uLi5OHhYTIi7WHcunXLZPHz7M8it/7h6empI0eOmExh27t3b4GuFRcXp7CwML344ovy9fVV2bJldebMmfva3d1fs9/n1V/z4+fnl+vvnnQn0AoMDNTYsWN18OBBWVlZaeXKlTm2tba2lqOjo8kLAAAAAO5GKIXHio2NjYYPH65hw4Zp4cKFSk5O1u7duzV//nxJd9YMsrGxUZcuXXT06FFt27ZN/fv3V+fOnY1Trv6Kjz76SCtXrtTx48fVt29fXbp0yWTRbi8vL5N/hPv5+alEiRJavHixSSi1atUqZWRk3DeV7EF4enqqefPm6t27t/bs2aP9+/erR48eJqNZgoKC5Ovrq06dOunAgQOKj49XaGioGjVqZDIlrHHjxlq0aJExgCpZsqS8vb21bNkyk1Dq/fff15IlS3T8+HGdOHFCX3zxhcqWLWucMhgaGqqIiAiT57Vr1y4tWLBAnTp1Utu2bdWpU6eHGtETEhKirVu3ysvLK9c2jRo1UsOGDdW+fXvFxMTo9OnTWr9+vTZs2CDpzlTCLVu2aPz48Tpx4oQWLFigGTNmKDw8/IHruVfRokXVv39/42cRFhamZ555xjglLz4+Xl5eXvr5558lSa+++qqysrLUq1cvJSYmauPGjZoyZYok5btel7u7u7766islJCTo0KFDxnPdKy4uTpMnT9aJEyf00Ucf6YsvvtDAgQMf+h4jIiK0d+9e9enTR4cPH9bx48c1a9YsXbx4UXv27NE777yjffv2KSUlRV999ZUuXLjwl0IwAAAAAE82Qik8dkaOHKkhQ4Zo1KhR8vb2VkhIiHENnGLFimnjxo36/fffFRAQoJdeeklNmzbVjBkz/pZrR0ZGKjIyUjVr1tSOHTu0Zs0alS5d2rg/KSlJaWlpxvcGg0HPPfecDAaDnn32WUl3gipHR0fVrVv3vmlZD+rTTz9VuXLl1KhRI7Vr1069evVSmTJlTK6/evVqlShRQg0bNlRQUJCqVKmiZcuWmZynUaNGyszMNBm51bhx4/u2OTg4aPLkyapbt64CAgJ05swZrVu3zrg+V0pKilJTUyXdWeh76NChmjlzpnG9oJkzZ+rixYsaOXLkA9+rj4+PcXRXXlasWKGAgAB17NhRPj4+GjZsmHG9qNq1a2v58uVaunSpatSooVGjRmncuHEKCwt74HruVaxYMQ0fPlyvvvqqAgMDZW9vb/Kcr1+/rqSkJN28eVPSnRFnX3/9tRISElSrVi299dZbGjVqlCSZrDOVk/fff18lSpRQgwYN1Lp1awUHB6t27dr3tRsyZIj27dsnf39/TZgwQe+//76Cg4Mf+h49PDy0adMmHTp0SPXq1VP9+vW1evVqWVpaytHRUd9++61atmwpDw8Pvf3225o6dapatGjx0NcDAAAA8GTj2/cAyfjte9nfigbcLTo6WoMGDTKZOvkwFi1apK5duyotLe0vr4/l5uamQYMGadCgQX/pPOaS/e0bfPseAPx78O17AIDcFPTb9yzNWBMAPFEWLlyoKlWq6KmnntKhQ4c0fPhwdejQ4W9bsB0AAAAA/skIpQDgEfn11181atQo/frrr3J1ddXLL7+siRMnFnZZAAAAAPBYYPoeAOCRY/oeAPz7MH0PAJCbgk7fY6FzAAAAAAAAmB2hFAAAAAAAAMyOUAoAAAAAAABmRygFAAAAAAAAsyOUAgAAAAAAgNkRSgEAAAAAAMDsCKUAAAAAAABgdoRSAAAAAAAAMDtCKQAAAAAAAJidZWEXAAB4crhu3iZHR8fCLgMAAADAY4CRUgAAAAAAADA7QikAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZHKAUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwIpQAAAAAAAGB2loVdAADgyZEa1ERXLS0KuwwAAIzK7Ywv7BIA4InFSCkAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZHKAUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwIpQAAAAAAAGB2hFIAAAAAAAAwO0IpAAAAAAAAmB2hFAAAAAAAAMyOUAoAAAAAAABmRygFAAAAAAAAsyOUQo7CwsLUtm1b4/vGjRtr0KBBj/y627dvl8Fg0OXLlyVJ0dHRKl68+AOd497aHyePc23/FAaDQatWrZIknTlzRgaDQQkJCQU+/mH61N/t3n7+IP7q7+JfuTYAAAAA/J0sC7sAPFqNGzdWrVq1NG3atMIu5aGEhISoZcuWD3RMVFSUbt++/Ygq+mse59r+iSpUqKDU1FSVLl26wMc8TJ96nHz11VcqWrRogdrm9PvfoEEDpaamysnJ6RFVCAAAAAAFQygFs7h9+7YyMzNlaflgXc7W1la2trYPdMzj/I/tx7m2wnbz5s0Chy3ZLCwsVLZs2Qc65mH61OPgxo0bsrKyUsmSJf/SeaysrB74mQEAAADAo8D0vX+xsLAwxcbGKioqSgaDQQaDQWfOnFFmZqa6d++uypUry9bWVp6enoqKinqgc69du1ZOTk5atGhRjvuzpwitX79ederUkbW1tXbs2KGsrCxNmjTJeO2aNWvqyy+/zPU6OU21mjBhgsqUKSMHBwf16NFDI0aMUK1atUzu++4pchkZGRowYIDKlCkjGxsbPfvss9q7d+99tW7ZskV169ZVsWLF1KBBAyUlJeVaV/a0seXLl+u5556Tra2tAgICdOLECe3du1d169aVvb29WrRooQsXLuRa25dffilfX1/Z2tqqVKlSCgoK0rVr14z7P/nkE1WvXl3W1tZydXVVv379cq0pL0ePHs23zfbt21WvXj3Z2dmpePHiCgwM1I8//mjcP2vWLFWtWlVWVlby9PTUZ599ZnL85cuX1bt3b7m4uMjGxkY1atTQN998k+v1DAaDZs2apf/+97+ys7PTxIkTJUmrV69W7dq1ZWNjoypVqmjs2LG6detWjufIafremjVr5O7uLhsbGzVp0kQLFizId0pofvdmMBj08ccf68UXX1SxYsXk7u6uNWvW5Pk8MzIyNHz4cFWoUEHW1taqVq2a5s+fb9Jm//79ufa5MWPGqFatWvr4449VuXJl2djYSLp/+t7MmTON9+vi4qKXXnpJUu6///dO3/vtt9/UsWNHPfXUUypWrJh8fX21ZMkSkzobN26sAQMGaNiwYSpZsqTKli2rMWPG5Hn/AAAAAJAfQql/saioKNWvX189e/ZUamqqUlNTVaFCBWVlZal8+fL64osvdOzYMY0aNUpvvvmmli9fXqDzLl68WB07dtSiRYvUqVOnPNuOGDFCkZGRSkxMlJ+fnyZNmqSFCxdq9uzZ+v777zV48GC99tprio2NLdC1Fy1apIkTJ+rdd9/V/v37VbFiRc2aNSvPY4YNG6YVK1ZowYIFOnDggKpVq6bg4GD9/vvvJu3eeustTZ06Vfv27ZOlpaW6deuWbz2jR4/W22+/rQMHDsjS0lKvvvqqhg0bpqioKH333Xc6deqURo0aleOxqamp6tixo7p166bExERt375d7dq1M07vmzVrlvr27atevXrpyJEjWrNmjapVq1ag53S3gwcPKiAgIM8Q5datW2rbtq0aNWqkw4cPa9euXerVq5cMBoMkaeXKlRo4cKCGDBmio0ePqnfv3uratau2bdsmScrKylKLFi0UFxenzz//XMeOHVNkZKQsLCzyrG3MmDF68cUXdeTIEXXr1k3fffedQkNDNXDgQB07dkxz5sxRdHS0MbDKz+nTp/XSSy+pbdu2OnTokHr37q233norz2Pyu7dsY8eOVYcOHXT48GG1bNlSnTp1uq8P3S00NFRLlizR9OnTlZiYqDlz5sje3t6kTX597tSpU1qxYoW++uqrHNfN2rdvnwYMGKBx48YpKSlJGzZsUMOGDSXl/vt/rz///FN16tTR2rVrdfToUfXq1UudO3dWfHy8SbsFCxbIzs5Oe/bs0eTJkzVu3DjFxMTk+WwBAAAAIC9M3/sXc3JykpWVlYoVK2YyXcfCwkJjx441vq9cubJ27dql5cuXq0OHDnme86OPPtJbb72lr7/+Wo0aNcq3hnHjxqlZs2aS7owceeedd7R582bVr19fklSlShXt2LFDc+bMKdD5PvzwQ3Xv3l1du3aVJI0aNUqbNm3S1atXc2x/7do1zZo1S9HR0WrRooUkad68eYqJidH8+fM1dOhQY9uJEycaaxgxYoReeOEF/fnnn8YRKjkJDw9XcHCwJGngwIHq2LGjtmzZosDAQElS9+7dFR0dneOxqampunXrltq1a6dKlSpJknx9fY37J0yYoCFDhmjgwIHGbQEBAXk+n5z4+/tr7ty5CgkJ0ZdffqkXXnjhvjbp6elKS0tTq1atVLVqVUmSt7e3cf+UKVMUFhamPn36SJLeeOMN7d69W1OmTFGTJk20efNmxcfHKzExUR4eHpLufLb5efXVV42fpSR169ZNI0aMUJcuXYznGD9+vIYNG6bRo0fne745c+bI09NT7733niTJ09NTR48ezTPUyu/esoWFhaljx46SpHfeeUfTp09XfHy8mjdvft85T5w4oeXLlysmJkZBQUHGe7lXfn3uxo0bWrhwoZydnXOsPSUlRXZ2dmrVqpUcHBxUqVIl+fv7S8r99/9eTz31lMLDw43v+/fvr40bN2r58uWqV6+ecbufn5/xM3B3d9eMGTO0ZcsW4+/3vTIyMpSRkWF8n56enmsNAAAAAJ5MjJR6Qn300UeqU6eOnJ2dZW9vr7lz5yolJSXPY7788ksNHjxYMTExBQqQJKlu3brGn0+dOqXr16+rWbNmsre3N74WLlyo5OTkAp0vKSnJ5B/Kku57f7fk5GTdvHnTGBJJUtGiRVWvXj0lJiaatPXz8zP+7OrqKkk6f/58nvXcfYyLi4sk02DJxcUl13PUrFlTTZs2la+vr15++WXNmzdPly5dMl73l19+UdOmTfO8frbsaWy5vUJDQ/Xnn3+qffv2unnz5n3HlyxZUmFhYQoODlbr1q0VFRWl1NRU4/7ExESTZyhJgYGBxmeYkJCg8uXLGwOpgrq7f0jSoUOHNG7cOJP+kT3S5/r16/meLykp6b7gLq/+IeV/b9nu/qzt7Ozk6OiY62ebkJAgCwuLfH9P8utzlSpVyjWQkqRmzZqpUqVKqlKlijp37qxFixYV6DndLTMzU+PHj5evr69Kliwpe3t7bdy48b4/D+6uNbvevH4/Jk2aJCcnJ+Mrp1FaAAAAAJ5shFJPoKVLlyo8PFzdu3fXpk2blJCQoK5du+rGjRt5Hufv7y9nZ2d98sknBf4GOTs7O+PP2aOZ1q5dq4SEBOPr2LFjea4rZS53L7KdPW0tKyvrgY+5d1tu57CwsFBMTIzWr18vHx8fffjhh/L09NTp06cfeCHup556SomJibm+5syZIwsLC02ePDnXxcQ//fRT7dq1Sw0aNNCyZcvk4eGh3bt3F+j6D7tw+N39Q7rTR8aOHWvSP44cOaKTJ0/mOWLNHO59bnl9tgV9Hvn1uXufz70cHBx04MABLVmyRK6urho1apRq1qxpXC+qIN577z1FRUVp+PDh2rZtmxISEhQcHHzfnwcPcv+SFBERobS0NOPr7NmzBa4JAAAAwJOBUOpfzsrKSpmZmSbb4uLi1KBBA/Xp00f+/v6qVq1agUYqVa1aVdu2bdPq1avVv3//B67Fx8dH1tbWSklJUbVq1UxeBR1F4enpabJIuaT73t9bs5WVleLi4ozbbt68qb1798rHx+eB7+HvZjAYFBgYqLFjx+rgwYOysrLSypUr5eDgIDc3N23ZsqVA5ylatKi8vLxyfN26dUtDhgzRlClTNGDAgDzP4+/vr4iICO3cuVM1atTQ4sWLJd2Zynf3M5Tu9KPsZ+jn56effvpJJ06ceIin8P9q166tpKSk+/pHtWrVVKRI/n9ceXp6at++fSbb8uofUv739jB8fX2VlZVV4LXS/gpLS0sFBQVp8uTJOnz4sM6cOaOtW7dKyvn3/15xcXFq06aNXnvtNdWsWVNVqlT5y5+jJFlbW8vR0dHkBQAAAAB3Y02pfzk3Nzft2bNHZ86ckb29vUqWLCl3d3ctXLhQGzduVOXKlfXZZ59p7969qly5cr7n8/Dw0LZt29S4cWNZWlpq2rRpku4sFh0REaHjx4/neqyDg4PCw8M1ePBgZWVl6dlnn1VaWpri4uLk6OhoXEcoL/3791fPnj1Vt25d44iew4cP57p+kZ2dnf73v/9p6NChKlmypCpWrKjJkyfr+vXr6t69e77XyxYfH6/Q0FBt2bJFTz31VIGPy8uePXu0ZcsW/ec//1GZMmW0Z88eXbhwwbiW05gxY/T666+rTJkyatGiha5cuaK4uLgHDgS9vLz0+eefq02bNrm2OX36tObOnav//ve/KleunJKSknTy5EmFhoZKkoYOHaoOHTrI399fQUFB+vrrr/XVV19p8+bNkqRGjRqpYcOGat++vd5//31Vq1ZNx48fl8FgUPPmzfXzzz+radOmWrhwYZ7T6UaNGqVWrVqpYsWKeumll1SkSBEdOnRIR48e1YQJE/K91969e+v999/X8OHD1b17dyUkJBjX9MoeiXSv/O6toLy8vDRp0iS9+OKLcnNzU5cuXdStWzdNnz5dNWvW1I8//qjz58/nu27bg/jmm2/0ww8/qGHDhipRooTWrVunrKwseXp6Ssr59/9e7u7u+vLLL7Vz506VKFFC77//vs6dO/dYhLYAAAAA/t0YKfUvFx4eLgsLC/n4+MjZ2VkpKSnq3bu32rVrp5CQED399NP67bffjIs8F4Snp6e2bt2qJUuWaMiQIZKktLQ0k6+zz8348eM1cuRITZo0Sd7e3mrevLnWrl1boEBMkjp16qSIiAiFh4erdu3aOn36tMLCwvKc2hUZGan27durc+fOql27tk6dOqWNGzeqRIkSBbthSdevX1dSUlKO6zE9LEdHR3377bdq2bKlPDw89Pbbb2vq1KnGBdm7dOmiadOmaebMmapevbpatWqlkydPPvB1LC0t8wykJKlYsWI6fvy42rdvLw8PD/Xq1Ut9+/ZV7969JUlt27ZVVFSUpkyZourVq2vOnDn69NNP1bhxY+M5VqxYoYCAAHXs2FE+Pj4aNmyYcZTOzZs3lZSUlO96R8HBwfrmm2+0adMmBQQE6JlnntEHH3xgXAg+P5UrV9aXX36pr776Sn5+fpo1a5bx2/esra1zPKYg91YQSUlJSktLM76fNWuWXnrpJfXp00deXl7q2bOnrl279kDnzE/x4sX11Vdf6fnnn5e3t7dmz56tJUuWqHr16pJy/v2/19tvv63atWsrODhYjRs3VtmyZdW2bdu/tU4AAAAAyInhdkEXBwIeU82aNVPZsmX12WefFXYpeAxNnDhRs2fPZk2jQpaeni4nJycdD6gtB0uLwi4HAACjcjvjC7sEAPjXyf77f1paWp5LeTB9D/8o169f1+zZsxUcHCwLCwstWbJEmzdvVkxMTGGXhsfEzJkzFRAQoFKlSikuLk7vvfee+vXrV9hlAQAAAADuQSiFfxSDwaB169Zp4sSJ+vPPP+Xp6akVK1YoKCiosEvDY+LkyZOaMGGCfv/9d1WsWFFDhgxRREREYZcFAAAAALgH0/cAAI8c0/cAAI8rpu8BwN+voNP3WOgcAAAAAAAAZkcoBQAAAAAAALMjlAIAAAAAAIDZEUoBAAAAAADA7AilAAAAAAAAYHaEUgAAAAAAADA7QikAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZnWdgFAACeHK6bt8nR0bGwywAAAADwGGCkFAAAAAAAAMyOUAoAAAAAAABmRygFAAAAAAAAsyOUAgAAAAAAgNkRSgEAAAAAAMDsCKUAAAAAAABgdoRSAAAAAAAAMDtCKQAAAAAAAJgdoRQAAAAAAADMzrKwCwAAPDlSg5roqqVFYZcBAMBjpdzO+MIuAQAKBSOlAAAAAAAAYHaEUgAAAAAAADA7QikAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZHKAUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwIpQAAAAAAAGB2hFIAAAAAAAAwO0IpAAAAAAAAmB2hFAAAAAAAAMyOUArAP0Ljxo01aNCgwi4DAAAAAPA3IZQCnmAEPU+mMWPGqFatWoVdBgAAAIAnHKEU8De6ceNGYZdQKJ7U+84LzwQAAAAA8kYoBfwFjRs3Vr9+/TRo0CCVLl1awcHBkqSjR4+qRYsWsre3l4uLizp37qyLFy8aj8vKytLkyZNVrVo1WVtbq2LFipo4cWKe1+nfv78GDRqkEiVKyMXFRfPmzdO1a9fUtWtXOTg4qFq1alq/fr3JcbGxsapXr56sra3l6uqqESNG6NatW5KksLAwxcbGKioqSgaDQQaDQWfOnMn3uLzu+/vvv1erVq3k6OgoBwcHPffcc0pOTta3336rokWL6tdffzWpb9CgQXruueeM7+Pi4tS4cWMVK1ZMJUqUUHBwsC5dupTjM8nIyFB4eLieeuop2dnZ6emnn9b27duN+3/88Ue1bt1aJUqUkJ2dnapXr65169bl+oxzc/36dZ0+fTrfdm5ubho/frxCQ0Pl6OioXr16SZJ27Nih5557Tra2tqpQoYIGDBiga9eumdzH8OHDVaFCBVlbW6tatWqaP39+rtf57LPPVLduXTk4OKhs2bJ69dVXdf78eeP+6OhoFS9e3OSYVatWyWAwGPePHTtWhw4dMn7u0dHRkqSUlBS1adNG9vb2cnR0VIcOHXTu3DnjeQ4dOqQmTZrIwcFBjo6OqlOnjvbt25fvswEAAACAnBBKAX/RggULZGVlpbi4OM2ePVuXL1/W888/L39/f+3bt08bNmzQuXPn1KFDB+MxERERioyM1MiRI3Xs2DEtXrxYLi4u+V6ndOnSio+PV//+/fW///1PL7/8sho0aKADBw7oP//5jzp37qzr169Lkn7++We1bNlSAQEBOnTokGbNmqX58+drwoQJkqSoqCjVr19fPXv2VGpqqlJTU1WhQoV8j8vtvn/++Wc1bNhQ1tbW2rp1q/bv369u3brp1q1batiwoapUqaLPPvvMePzNmze1aNEidevWTZKUkJCgpk2bysfHR7t27dKOHTvUunVrZWZm5vg8+vXrp127dmnp0qU6fPiwXn75ZTVv3lwnT56UJPXt21cZGRn69ttvdeTIEb377ruyt7d/wE9X+vjjj43hWn6mTJmimjVr6uDBgxo5cqSSk5PVvHlztW/fXocPH9ayZcu0Y8cO9evXz3hMaGiolixZounTpysxMVFz5szJs86bN29q/PjxOnTokFatWqUzZ84oLCyswPcTEhKiIUOGqHr16sbPPSQkRFlZWWrTpo1+//13xcbGKiYmRj/88INCQkKMx3bq1Enly5fX3r17tX//fo0YMUJFixbN8ToZGRlKT083eQEAAADA3Qy3b9++XdhFAP9UjRs3Vnp6ug4cOGDcNmHCBH333XfauHGjcdtPP/2kChUqKCkpSa6urnJ2dtaMGTPUo0ePAl8nMzNT3333nSQpMzNTTk5OateunRYuXChJ+vXXX+Xq6qpdu3bpmWee0VtvvaUVK1YoMTHROEpm5syZGj58uNLS0lSkSBE1btxYtWrV0rRp04zXKuhx9973m2++qaVLlyopKSnHoGLy5MmKjo7WsWPHJElfffWVunTpol9//VV2dnZ69dVXlZKSoh07duT6DLJrTUlJUZUqVZSSkqJy5coZ2wQFBalevXp655135Ofnp/bt22v06NEFesa5uX37tnr37q0NGzZo+/btqlKlSo7t3Nzc5O/vr5UrVxq39ejRQxYWFpozZ45x244dO9SoUSNdu3ZNKSkp8vT0VExMjIKCgh6qvn379ikgIEBXrlyRvb29oqOjNWjQIF2+fNnYZtWqVXrxxReV/cf9mDFjtGrVKiUkJBjbxMTEqEWLFjp9+rQqVKggSTp27JiqV6+u+Ph4BQQEyNHRUR9++KG6dOmSb11jxozR2LFj79t+PKC2HCwtHupeAQD4tyq3M76wSwCAv1V6erqcnJyUlpYmR0fHXNsxUgr4i+rUqWPy/tChQ9q2bZvs7e2NLy8vL0lScnKyEhMTlZGRoaZNmz7Qdfz8/Iw/W1hYqFSpUvL19TVuyx5plT2VKzExUfXr1zcGS5IUGBioq1ev6qeffsr1OgU97t77TkhI0HPPPZfryJmwsDCdOnVKu3fvlnRnGlmHDh1kZ2dnPL6gz+TIkSPKzMyUh4eHyXOOjY01jmgaMGCAJkyYoMDAQI0ePVqHDx/O9XzR0dHGqWz3vooUKaJ58+bp7Nmz6tmzZ5511a1b1+T9oUOHFB0dbVJjcHCwsrKydPr0aSUkJMjCwkKNGjUq0H1L0v79+9W6dWtVrFhRDg4OxmNTUlIKfI6cJCYmqkKFCsZASpJ8fHxUvHhxJSYmSpLeeOMN9ejRQ0FBQYqMjMxz9FhERITS0tKMr7Nnz/6l+gAAAAD8+1gWdgHAP112qJLt6tWrat26td5999372rq6uuqHH354qOvcG/YYDAaTbdkhUlZW1kOd/0Hde9+2trZ5ti9Tpoxat26tTz/9VJUrV9b69etN1oDK7/i7Xb16VRYWFtq/f78sLExH3WRPfevRo4eCg4O1du1abdq0SZMmTdLUqVPVv3//+8734osv6plnnsn1eh988IEWL16s8ePH51lXTn2hd+/eGjBgwH1tK1asqFOnTuV5vntdu3ZNwcHBCg4O1qJFi+Ts7KyUlBQFBwcbF1YvUqSI7h0Ae/PmzQe6Tm7GjBmjV199VWvXrtX69es1evRoLV26VC+++OJ9ba2trWVtbf23XBcAAADAvxOhFPA3q127tlasWCE3NzdZWt7/K+bu7i5bW1tt2bKlwNP3Hoa3t7dWrFih27dvGwOruLg4OTg4qHz58pIkKyur+9ZsKshxOfHz89OCBQt08+bNXEdL9ejRQx07dlT58uVVtWpVBQYGmhy/ZcuWHKd83cvf31+ZmZk6f/68yULp96pQoYJef/11vf7664qIiNC8efNyDKWcnJzk5OSU4zk+/fRTLV68WOvXr1eDBg3yre1utWvX1rFjx1StWrUc9/v6+iorK0uxsbEFmr53/Phx/fbbb4qMjDSOaLp3oXFnZ2dduXJF165dMxmFdrfcPvezZ8/q7NmzJtP3Ll++LB8fH2M7Dw8PeXh4aPDgwerYsaM+/fTTHEMpAAAAAMgP0/eAv1nfvn31+++/q2PHjtq7d6+Sk5O1ceNGde3aVZmZmbKxsdHw4cM1bNgwLVy4UMnJydq9e7fJN641bdpUM2bM+Et19OnTR2fPnlX//v11/PhxrV69WqNHj9Ybb7yhIkXu/Oq7ublpz549OnPmjC5evKisrKwCHZeTfv36KT09Xa+88or27dunkydP6rPPPlNSUpKxTXBwsBwdHTVhwgR17drV5PiIiAjt3btXffr00eHDh3X8+HHNmjXL5FsLs3l4eKhTp04KDQ3VV199pdOnTys+Pl6TJk3S2rVrJd35Zr+NGzfq9OnTOnDggLZt2yZvb+8Hfo7NmzfXxo0b9eyzzz7wscOHD9fOnTvVr18/JSQk6OTJk1q9erVxoXM3Nzd16dJF3bp106pVq3T69Glt375dy5cvN57Dy8vLuE5VxYoVZWVlpQ8//FA//PCD1qxZc9/oraefflrFihXTm2++qeTkZC1evNj47XrZ3NzcjNMHL168qIyMDAUFBcnX11edOnXSgQMHFB8fr9DQUDVq1Eh169bVH3/8oX79+mn79u368ccfFRcXp7179z7UMwUAAAAAiVAK+NuVK1dOcXFxyszM1H/+8x/5+vpq0KBBKl68uDHUGTlypIYMGaJRo0bJ29tbISEhxrWgpDtrT+UUxjyIp556SuvWrVN8fLxq1qyp119/Xd27d9fbb79tbBMeHi4LCwv5+PgYp4IV5LiclCpVSlu3btXVq1fVqFEj1alTR/PmzTMZNVWkSBGFhYUpMzNToaGhJsd7eHho06ZNOnTokOrVq6f69etr9erVOY42k+6MYAoNDdWQIUPk6emptm3bau/evapYsaKkO4vB9+3bV97e3mrevLk8PDw0c+bMB36Orq6uDzxCKpufn59iY2N14sQJPffcc/L399eoUaNMFmefNWuWXnrpJfXp00deXl7q2bOnrl27ZtyflJSktLQ0SXdGQUVHR+uLL76Qj4+PIiMjNWXKFJNrlixZUp9//rnWrVsnX19fLVmyRGPGjDFp0759ezVv3lxNmjSRs7OzlixZIoPBoNWrV6tEiRJq2LChgoKCVKVKFS1btkzSnXXMfvvtN4WGhsrDw0MdOnRQixYtCjSyDQAAAABywrfvATCr7t2768KFC1qzZk1hlwIzyv72Db59DwCA+/HtewD+bQr67XusKQXALNLS0nTkyBEtXryYQAoAAAAAQCgFwDzatGmj+Ph4vf7662rWrFlhlwMAAAAAKGSEUgDMYvv27YVdAgAAAADgMcJC5wAAAAAAADA7QikAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZHKAUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwIpQAAAAAAAGB2hFIAAAAAAAAwO8vCLgAA8ORw3bxNjo6OhV0GAAAAgMcAI6UAAAAAAABgdoRSAAAAAAAAMDtCKQAAAAAAAJgdoRQAAAAAAADMjlAKAAAAAAAAZkcoBQAAAAAAALMjlAIAAAAAAIDZEUoBAAAAAADA7CwLuwAAwJMjNaiJrlpaFHYZAAAAwL9KuZ3xhV3CQ2GkFAAAAAAAAMyOUAoAAAAAAABmRygFAAAAAAAAsyOUAgAAAAAAgNkRSgEAAAAAAMDsCKUAAAAAAABgdoRSAAAAAAAAMDtCKQAAAAAAAJgdoRQAAAAAAADMjlAKAAAAAAAAZkcoBQAAAAAAALMjlAIAAAAAAIDZEUrhsREWFqa2bdsa3zdu3FiDBg0yex1ubm6aNm2a8b3BYNCqVavyPObe2gvbmTNnZDAYlJCQUNil/K3u/iwK6x63b98ug8Ggy5cvS5Kio6NVvHjxfI8rSD8CAAAAgCcJoRT+doUVJj0qqampatGihaTcg5CoqChFR0ebv7hcVKhQQampqapRo0Zhl3Kff1tgFhISohMnThjfjxkzRrVq1bqv3d39CAAAAAAgWRZ2AcDjrmzZsvm2cXJyMkMlBWdhYVGguvHX2draytbWNt92fB4AAAAAYIqRUvhbhYWFKTY2VlFRUTIYDDIYDDpz5owyMzPVvXt3Va5cWba2tvL09FRUVNQDnXvt2rVycnLSokWLctyfPa1q7dq18vPzk42NjZ555hkdPXrUpN2KFStUvXp1WVtby83NTVOnTs3zundPu6pcubIkyd/fXwaDQY0bNzbe993T97KysjR58mRVq1ZN1tbWqlixoiZOnChJunHjhvr16ydXV1fZ2NioUqVKmjRpUq7Xzz73O++8IxcXFxUvXlzjxo3TrVu3NHToUJUsWVLly5fXp59+ajzm3tFIly5dUqdOneTs7CxbW1u5u7ubtP/pp5/UsWNHlSxZUnZ2dqpbt6727NmT53PJyenTp3X9+vU82+T2DPfu3atmzZqpdOnScnJyUqNGjXTgwIECXzszM1PdunWTl5eXUlJScmyT/SzHjh0rZ2dnOTo66vXXX9eNGzeMbTIyMjRgwACVKVNGNjY2evbZZ7V3795cr3v39L3o6GiNHTtWhw4dMvb/7BF0907fy+uZHzp0SE2aNJGDg4McHR1Vp04d7du3L9cajh8/rmeffVY2Njby8fHR5s2bTa5375RDSUpISDD+ft59Hxs3bpS3t7fs7e3VvHlzpaamGo/Zvn276tWrJzs7OxUvXlyBgYH68ccfc60LAAAAAPLCSCn8raKionTixAnVqFFD48aNkyQ5OzsrKytL5cuX1xdffKFSpUpp586d6tWrl1xdXdWhQ4d8z7t48WK9/vrrWrx4sVq1apVn26FDhyoqKkply5bVm2++qdatW+vEiRMqWrSo9u/frw4dOmjMmDEKCQnRzp071adPH5UqVUphYWH51hEfH6969epp8+bNql69uqysrHJsFxERoXnz5umDDz7Qs88+q9TUVB0/flySNH36dK1Zs0bLly9XxYoVdfbsWZ09ezbP627dulXly5fXt99+q7i4OHXv3l07d+5Uw4YNtWfPHi1btky9e/dWs2bNVL58+fuOHzlypI4dO6b169erdOnSOnXqlP744w9J0tWrV9WoUSM99dRTWrNmjcqWLasDBw4oKysr3+dxryFDhujy5ctau3ZtrqOHcnuGV65cUZcuXfThhx/q9u3bmjp1qlq2bKmTJ0/KwcEhz+tmZGSoY8eOOnPmjL777js5Ozvn2nbLli2ysbHR9u3bdebMGXXt2lWlSpUyhobDhg3TihUrtGDBAlWqVEmTJ09WcHCwTp06pZIlS+ZZR0hIiI4ePaoNGzZo8+bNknIeRZffM+/UqZP8/f01a9YsWVhYKCEhQUWLFs3xmpmZmWrbtq0qVqyoPXv26MqVKxoyZEiedebm+vXrmjJlij777DMVKVJEr732msLDw7Vo0SLdunVLbdu2Vc+ePbVkyRLduHFD8fHxMhgMOZ4rIyNDGRkZxvfp6ekPVRMAAACAfy9CKfytnJycZGVlpWLFiplMV7KwsNDYsWON7ytXrqxdu3Zp+fLl+YZSH330kd566y19/fXXatSoUb41jB49Ws2aNZMkLViwQOXLl9fKlSvVoUMHvf/++2ratKlGjhwpSfLw8NCxY8f03nvvFSiUyg47SpUqlet0rCtXrigqKkozZsxQly5dJElVq1bVs88+K0lKSUmRu7u7nn32WRkMBlWqVCnf65YsWVLTp09XkSJF5OnpqcmTJ+v69et68803Jd0JwSIjI7Vjxw698sor9x2fkpIif39/1a1bV9KdxdyzLV68WBcuXNDevXuNoUu1atXyrSknn376qYKCgtS6dWt9/fXXOQZTuT3D559/3qTd3LlzVbx4ccXGxuYZRF69elUvvPCCMjIytG3btnynUlpZWemTTz5RsWLFVL16dY0bN05Dhw7V+PHj9ccff2jWrFmKjo42rv80b948xcTEaP78+Ro6dGie57a1tZW9vb0sLS3znK6X3zNPSUnR0KFD5eXlJUlyd3fP9VwxMTFKTk7W9u3bjdecOHGi8XfgQdy8eVOzZ89W1apVJUn9+vUzhsvp6elKS0tTq1atjPu9vb1zPdekSZNMfucBAAAA4F5M34PZfPTRR6pTp46cnZ1lb2+vuXPn5jrNKtuXX36pwYMHKyYmpkCBlCTVr1/f+HPJkiXl6empxMRESVJiYqICAwNN2gcGBurkyZPKzMx8wDvKWWJiojIyMtS0adMc94eFhSkhIUGenp4aMGCANm3alO85q1evriJF/v/X1cXFRb6+vsb3FhYWKlWqlM6fP5/j8f/73/+0dOlS1apVS8OGDdPOnTuN+xISEuTv75/vKKC768+emnbvq3jx4tq3b5+2bNmiKVOmFOh82c6dO6eePXvK3d1dTk5OcnR01NWrV/PtIx07dtS1a9e0adOmAq3tVbNmTRUrVsz4vn79+rp69arOnj2r5ORk3bx506SPFC1aVPXq1TP2ob9Dfs/8jTfeUI8ePRQUFKTIyEglJyfneq6kpCRVqFDBJASrV6/eQ9VVrFgxY+AkSa6ursY+VbJkSYWFhSk4OFitW7dWVFSUydS+e0VERCgtLc34ym80IAAAAIAnD6EUzGLp0qUKDw9X9+7dtWnTJiUkJKhr164ma/nkxN/fX87Ozvrkk090+/ZtM1X71+S36HXt2rV1+vRp48icDh066KWXXsrzmHunbhkMhhy35TblrkWLFvrxxx81ePBg/fLLL2ratKnCw8MLVO+9Jk2apMTExBxfR44cUUBAgLy9vdWrV68HOm+XLl2UkJCgqKgo7dy5UwkJCSpVqlS+faRly5Y6fPiwdu3a9UDXK0z5PfMxY8bo+++/1wsvvKCtW7fKx8dHK1eufOjrZQead/8O3bx58752OfWpu4/59NNPtWvXLjVo0EDLli2Th4eHdu/eneM1ra2t5ejoaPICAAAAgLsRSuFvZ2Vldd+oo7i4ODVo0EB9+vSRv7+/qlWrlufoj2xVq1bVtm3btHr1avXv379A17/7H8mXLl3SiRMnjNOMvL29FRcXd19tHh4esrCwyPfc2esf5TWqyt3dXba2ttqyZUuubRwdHRUSEqJ58+Zp2bJlWrFihX7//fd8r/9XODs7q0uXLvr88881bdo0zZ07V5Lk5+enhISEAl/f1dVVXl5eOb7ee+89paena+vWrXJxccnx+NyeYVxcnAYMGKCWLVsaF6K/ePFivvX873//U2RkpP773/8qNjY23/aHDh0yrqcl3ekv9vb2qlChgqpWrSorKyuTPnLz5k3t3btXPj4++Z47+/7yG3VXkGfu4eGhwYMHa9OmTWrXrp3JwvR38/T01NmzZ3Xu3DnjtnsXZs+eMnn3yKbsRfAflL+/vyIiIrRz507VqFFDixcvfqjzAAAAAAChFP52bm5u2rNnj86cOaOLFy8qKytL7u7u2rdvnzZu3KgTJ05o5MiReX6j2d08PDy0bds2rVixQoMGDTJuX7lypXHNnbuNGzdOW7Zs0dGjRxUWFqbSpUsbvxlvyJAh2rJli8aPH68TJ05owYIFmjFjhnHUUH7KlCkjW1tbbdiwQefOnVNaWtp9bWxsbDR8+HANGzZMCxcuVHJysnbv3q358+dLkt5//30tWbJEx48f14kTJ/TFF1+obNmyxm9wCw0NVURERIHqKahRo0Zp9erVOnXqlL7//nt98803xqCuY8eOKlu2rNq2bau4uDj98MMPWrFixUONPOrdu7e2bduW53pKuT1Dd3d3ffbZZ0pMTNSePXvUqVOnAo/i6t+/vyZMmKBWrVppx44dxu05PcsbN26oe/fuOnbsmNatW6fRo0erX79+KlKkiOzs7PS///1PQ4cO1YYNG3Ts2DH17NlT169fV/fu3QtUi5ubm06fPq2EhARdvHjRZLHvbHk98z/++EP9+vXT9u3b9eOPPyouLk579+41fl4///yzvLy8FB8fL0lq1qyZqlatqi5duujw4cOKi4vT22+/LUnGRcirVaumChUqaMyYMTp58qTWrl2b77dO3uv06dOKiIjQrl279OOPP2rTpk06efJknutKAQAAAEBeCKXwtwsPD5eFhYV8fHzk7OyslJQU9e7dW+3atVNISIiefvpp/fbbb+rTp0+Bz+np6amtW7dqyZIlxm8WS0tLU1JS0n1tIyMjNXDgQNWpU0e//vqrvv76a+PonNq1a2v58uVaunSpatSooVGjRmncuHEFWuRckiwtLTV9+nTNmTNH5cqVU5s2bXJsN3LkSA0ZMkSjRo2St7e3QkJCjGvzODg4aPLkyapbt64CAgJ05swZrVu3zjjFKiUlJc+1eh6GlZWVIiIi5Ofnp4YNG8rCwkJLly417tu0aZPKlCmjli1bytfXV5GRkQUaOXavBg0ayNXVNc82uT3D+fPn69KlS6pdu7Y6d+6sAQMGqEyZMgW+9qBBgzR27Fi1bNnSuGZWTs+yadOmcnd3V8OGDRUSEqL//ve/GjNmjHF/ZGSk2rdvr86dO6t27do6deqUNm7cqBIlShSojvbt26t58+Zq0qSJnJ2dtWTJkvva5PXMLSws9Ntvvyk0NFQeHh7q0KGDWrRoYVw0/ObNm0pKStL169cl3VlPbNWqVbp69aoCAgLUo0cPvfXWW5LuBKTSnWl52UGon5+f3n33XU2YMKHAz1a6s97U8ePH1b59e3l4eKhXr17q27evevfu/UDnAQAAAIBshtv/lIV6gHxs375dTZo00aVLl4yjjoC7hYWF6fLly1q1alVhl/JIxcXF6dlnn9WpU6dMFi4vTOnp6XJyctLxgNpysHzwwBMAAABA7srtjC/sEkxk//0/LS0tz/VlLc1YEwDgEVi5cqXs7e3l7u6uU6dOaeDAgQoMDHxsAikAAAAAyAmhFAD8w125ckXDhw9XSkqKSpcuraCgoAdeMwoAAAAAzI3pewCAR47pewAAAMCj80+dvsdC5wAAAAAAADA7QikAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZHKAUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwIpQAAAAAAAGB2hFIAAAAAAAAwO8vCLgAA8ORw3bxNjo6OhV0GAAAAgMcAI6UAAAAAAABgdoRSAAAAAAAAMDtCKQAAAAAAAJgdoRQAAAAAAADMjlAKAAAAAAAAZkcoBQAAAAAAALMjlAIAAAAAAIDZEUoBAAAAAADA7AilAAAAAAAAYHaEUgAAAAAAADA7QikAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZHKAUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwIpQAAAAAAAGB2hFIAAAAAAAAwO0IpAAAAAAAAmB2hFAAAAAAAAMyOUAoAAAAAAABmZ1nYBQAA/v1u374tSUpPTy/kSgAAAAA8atl/78/+d0BuCKUAAI/cb7/9JkmqUKFCIVcCAAAAwFyuXLkiJyenXPcTSgEAHrmSJUtKklJSUvL8jxJgTunp6apQoYLOnj0rR0fHwi4HkES/xOOLvonHEf3y8XX79m1duXJF5cqVy7MdoRQA4JErUuTOEoZOTk78hQGPHUdHR/olHjv0Szyu6Jt4HNEvH08F+Z/RLHQOAAAAAAAAsyOUAgAAAAAAgNkRSgEAHjlra2uNHj1a1tbWhV0KYES/xOOIfonHFX0TjyP65T+f4XZ+388HAAAAAAAA/M0YKQUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwIpQAAj9RHH30kNzc32djY6Omnn1Z8fHxhl4QnyKRJkxQQECAHBweVKVNGbdu2VVJSkkmbP//8U3379lWpUqVkb2+v9u3b69y5c4VUMZ5EkZGRMhgMGjRokHEb/RKF5eeff9Zrr72mUqVKydbWVr6+vtq3b59x/+3btzVq1Ci5urrK1tZWQUFBOnnyZCFWjH+7zMxMjRw5UpUrV5atra2qVq2q8ePH6+7lsemX/1yEUgCAR2bZsmV64403NHr0aB04cEA1a9ZUcHCwzp8/X9il4QkRGxurvn37avfu3YqJidHNmzf1n//8R9euXTO2GTx4sL7++mt98cUXio2N1S+//KJ27doVYtV4kuzdu1dz5syRn5+fyXb6JQrDpUuXFBgYqKJFi2r9+vU6duyYpk6dqhIlShjbTJ48WdOnT9fs2bO1Z88e2dnZKTg4WH/++WchVo5/s3fffVezZs3SjBkzlJiYqHfffVeTJ0/Whx9+aGxDv/zn4tv3AACPzNNPP62AgADNmDFDkpSVlaUKFSqof//+GjFiRCFXhyfRhQsXVKZMGcXGxqphw4ZKS0uTs7OzFi9erJdeekmSdPz4cXl7e2vXrl165plnCrli/JtdvXpVtWvX1syZMzVhwgTVqlVL06ZNo1+i0IwYMUJxcXH67rvvctx/+/ZtlStXTkOGDFF4eLgkKS0tTS4uLoqOjtYrr7xiznLxhGjVqpVcXFw0f/5847b27dvL1tZWn3/+Of3yH46RUgCAR+LGjRvav3+/goKCjNuKFCmioKAg7dq1qxArw5MsLS1NklSyZElJ0v79+3Xz5k2Tfurl5aWKFSvST/HI9e3bVy+88IJJ/5Polyg8a9asUd26dfXyyy+rTJky8vf317x584z7T58+rV9//dWkbzo5Oenpp5+mb+KRadCggbZs2aITJ05Ikg4dOqQdO3aoRYsWkuiX/3SWhV0AAODf6eLFi8rMzJSLi4vJdhcXFx0/fryQqsKTLCsrS4MGDVJgYKBq1KghSfr1119lZWWl4sWLm7R1cXHRr7/+WghV4kmxdOlSHThwQHv37r1vH/0SheWHH37QrFmz9MYbb+jNN9/U3r17NWDAAFlZWalLly7G/pfTf9vpm3hURowYofT0dHl5ecnCwkKZmZmaOHGiOnXqJEn0y384QikAAPBE6Nu3r44ePaodO3YUdil4wp09e1YDBw5UTEyMbGxsCrscwCgrK0t169bVO++8I0ny9/fX0aNHNXv2bHXp0qWQq8OTavny5Vq0aJEWL16s6tWrKyEhQYMGDVK5cuXol/8CTN8DADwSpUuXloWFxX3fFnXu3DmVLVu2kKrCk6pfv3765ptvtG3bNpUvX964vWzZsrpx44YuX75s0p5+ikdp//79On/+vGrXri1LS0tZWloqNjZW06dPl6WlpVxcXOiXKBSurq7y8fEx2ebt7a2UlBRJMvY//tsOcxo6dKhGjBihV155Rb6+vurcubMGDx6sSZMmSaJf/tMRSgEAHgkrKyvVqVNHW7ZsMW7LysrSli1bVL9+/UKsDE+S27dvq1+/flq5cqW2bt2qypUrm+yvU6eOihYtatJPk5KSlJKSQj/FI9O0aVMdOXJECQkJxlfdunXVqVMn48/0SxSGwMBAJSUlmWw7ceKEKlWqJEmqXLmyypYta9I309PTtWfPHvomHpnr16+rSBHT6MLCwkJZWVmS6Jf/dEzfAwA8Mm+88Ya6dOmiunXrql69epo2bZquXbumrl27FnZpeEL07dtXixcv1urVq+Xg4GBcW8LJyUm2trZycnJS9+7d9cYbb6hkyZJydHRU//79Vb9+fb7hDI+Mg4ODcV2zbHZ2dipVqpRxO/0ShWHw4MFq0KCB3nnnHXXo0EHx8fGaO3eu5s6dK0kyGAwaNGiQJkyYIHd3d1WuXFkjR45UuXLl1LZt28ItHv9arVu31sSJE1WxYkVVr15dBw8e1Pvvv69u3bpJol/+0xFKAQAemZCQEF24cEGjRo3Sr7/+qlq1amnDhg33LUQJPCqzZs2SJDVu3Nhk+6effqqwsDBJ0gcffKAiRYqoffv2ysjIUHBwsGbOnGnmSgFT9EsUhoCAAK1cuVIREREaN26cKleurGnTphkXlJakYcOG6dq1a+rVq5cuX76sZ599Vhs2bGB9NDwyH374oUaOHKk+ffro/PnzKleunHr37q1Ro0YZ29Av/7kMt2/fvl3YRQAAAAAAAODJwppSAAAAAAAAMDtCKQAAAAAAAJgdoRQAAAAAAADMjlAKAAAAAAAAZkcoBQAAAAAAALMjlAIAAAAAAIDZEUoBAAAAAADA7AilAAAAAAAAYHaEUgAAAAAAADA7QikAAAAAkqTk5GT17t1bVapUkY2NjRwdHRUYGKioqCj98ccfhV2eZs6cqejo6MIuAwDwNzHcvn37dmEXAQAAAKBwrV27Vi+//LKsra0VGhqqGjVq6MaNG9qxY4dWrFihsLAwzZ07t1BrrFGjhkqXLq3t27cXah0AgL+HZWEXAAAAAKBwnT59Wq+88ooqVaqkrVu3ytXV1bivb9++OnXqlNauXVuIFQIA/o2YvgcAAAA84SZPnqyrV69q/vz5JoFUtmrVqmngwIGSpFu3bmn8+PGqWrWqrK2t5ebmpjfffFMZGRkmxxgMBo0ZM+a+c7m5uSksLMz4Pjo6WgaDQXFxcXrjjTfk7OwsOzs7vfjii7pw4YLJcd9//71iY2NlMBhkMBjUuHHjv+X+AQCFg5FSAAAAwBPu66+/VpUqVdSgQYN82/bo0UMLFizQSy+9pCFDhmjPnj2aNGmSEhMTtXLlyoeuoX///ipRooRGjx6tM2fOaNq0aerXr5+WLVsmSZo2bZr69+8ve3t7vfXWW5IkFxeXh74eAKDwEUoBAAAAT7D09HT9/PPPatOmTb5tDx06pAULFqhHjx6aN2+eJKlPnz4qU6aMpkyZom3btqlJkyYPVUepUqW0adMmGQwGSVJWVpamT5+utLQ0OTk5qW3btnr77bdVunRpvfbaaw91DQDA44XpewAAAMATLD09XZLk4OCQb9t169ZJkt544w2T7UOGDJGkv7TuVK9evYyBlCQ999xzyszM1I8//vjQ5wQAPN4IpQAAAIAnmKOjoyTpypUr+bb98ccfVaRIEVWrVs1ke9myZVW8ePG/FCBVrFjR5H2JEiUkSZcuXXrocwIAHm+EUgAAAMATzNHRUeXKldPRo0cLfMzdI5oeVGZmZo7bLSwsctx++/bth74WAODxRigFAAAAPOFatWql5ORk7dq1K892lSpVUlZWlk6ePGmy/dy5c7p8+bIqVapk3FaiRAldvnzZpN2NGzeUmpr60HX+lTAMAPD4IZQCAAAAnnDDhg2TnZ2devTooXPnzt23Pzk5WVFRUWrZsqWkO9+Ed7f3339fkvTCCy8Yt1WtWlXffvutSbu5c+fmOlKqIOzs7O4LugAA/1x8+x4AAADwhKtataoWL16skJAQeXt7KzQ0VDVq1NCNGze0c+dOffHFFwoLC9PAgQPVpUsXzZ07V5cvX1ajRo0UHx+vBQsWqG3btibfvNejRw+9/vrrat++vZo1a6ZDhw5p48aNKl269EPXWadOHc2aNUsTJkxQtWrVVKZMGT3//PN/xyMAABQCQikAAAAA+u9//6vDhw/rvffe0+rVqzVr1ixZW1vLz89PU6dOVc+ePSVJH3/8sapUqaLo6GitXLlSZcuWVUREhEaPHm1yvp49e+r06dOaP3++NmzYoOeee04xMTFq2rTpQ9c4atQo/fjjj5o8ebKuXLmiRo0aEUoBwD+Y4TYrBwIAAAAAAMDMWFMKAAAAAAAAZkcoBQAAAAAAALMjlAIAAAAAAIDZEUoBAAAAAADA7AilAAAAAAAAYHaEUgAAAAAAADA7QikAAAAAAACYHaEUAAAAAAAAzI5QCgAAAAAAAGZHKAUAAAAAAACzI5QCAAAAAACA2RFKAQAAAAAAwOwIpQAAAAAAAGB2/wfFJz0CUoUEWQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error analysis saved!\n" + ] + } + ], + "source": [ + "# Error analysis - find most confused category pairs\n", + "errors = {}\n", + "for true, pred in zip(true_labels, predicted_labels_best):\n", + " if true != pred:\n", + " pair = f\"{true} → {pred}\"\n", + " errors[pair] = errors.get(pair, 0) + 1\n", + "\n", + "top_errors = sorted(errors.items(), key=lambda x: x[1], reverse=True)[:10]\n", + "\n", + "print(\"Top 10 Most Common Misclassifications:\")\n", + "print(\"-\" * 50)\n", + "for pair, count in top_errors:\n", + " print(f\"{count:3d} times: {pair}\")\n", + "\n", + "# Plot error analysis\n", + "plt.figure(figsize=(12, 6))\n", + "pairs = [p[0] for p in top_errors]\n", + "counts = [p[1] for p in top_errors]\n", + "plt.barh(pairs, counts, color='#E53935')\n", + "plt.title('Top 10 Misclassifications - Best Model', fontsize=14)\n", + "plt.xlabel('Count', fontsize=12)\n", + "plt.tight_layout()\n", + "plt.savefig('/home/user/error_analysis.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "print(\"Error analysis saved!\")" + ] + }, + { + "cell_type": "markdown", + "id": "53430b8f-263b-4e5c-acc3-25dd21a6d9f4", + "metadata": {}, + "source": [ + "## Step 9: Save the Best Model\n", + "\n", + "We save the trained model to disk for future use." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "120718e7-b1ee-4417-89c9-e166ac7ac997", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model saved to /home/user/fasttext_best_model.bin\n", + "Loaded model F1: 0.6216\n", + "Model saved and verified successfully!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning : `load_model` does not return WordVectorModel or SupervisedModel any more, but a `FastText` object which is very similar.\n" + ] + } + ], + "source": [ + "# Save the best model to disk for future use\n", + "model_path = '/home/user/fasttext_best_model.bin'\n", + "best_model.save_model(model_path)\n", + "print(f\"Model saved to {model_path}\")\n", + "\n", + "# Verify the model loads correctly\n", + "loaded_model = fasttext.load_model(model_path)\n", + "loaded_results = evaluate_model(loaded_model, '/tmp/test.txt')\n", + "print(f\"Loaded model F1: {loaded_results['f1']}\")\n", + "print(\"Model saved and verified successfully!\")" + ] + }, + { + "cell_type": "markdown", + "id": "d25d49c5-51bb-4bea-9afd-f35cefda0cdc", + "metadata": {}, + "source": [ + "## Step 10: Comparison with Logistic Regression + TF-IDF\n", + "\n", + "We compare FastText against a traditional Logistic Regression classifier\n", + "using TF-IDF features. This demonstrates the trade-offs between modern\n", + "neural approaches and classical machine learning methods for text classification." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0a0a4aaa-c408-4a71-afcb-162ffcb01ed2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Logistic Regression + TF-IDF Results:\n", + "F1-Score: 0.6551\n", + "Training time: 23.50 seconds\n", + "\n", + "Detailed Report:\n", + " precision recall f1-score support\n", + "\n", + " alt.atheism 0.46 0.42 0.44 319\n", + " comp.graphics 0.56 0.68 0.62 389\n", + " comp.os.ms-windows.misc 0.63 0.59 0.61 394\n", + "comp.sys.ibm.pc.hardware 0.67 0.61 0.64 392\n", + " comp.sys.mac.hardware 0.73 0.65 0.69 385\n", + " comp.windows.x 0.79 0.66 0.72 395\n", + " misc.forsale 0.74 0.81 0.77 390\n", + " rec.autos 0.68 0.66 0.67 396\n", + " rec.motorcycles 0.66 0.75 0.70 398\n", + " rec.sport.baseball 0.49 0.81 0.61 397\n", + " rec.sport.hockey 0.87 0.85 0.86 399\n", + " sci.crypt 0.83 0.64 0.73 396\n", + " sci.electronics 0.56 0.59 0.57 393\n", + " sci.med 0.73 0.71 0.72 396\n", + " sci.space 0.69 0.74 0.71 394\n", + " soc.religion.christian 0.63 0.78 0.70 398\n", + " talk.politics.guns 0.59 0.69 0.64 364\n", + " talk.politics.mideast 0.82 0.72 0.76 376\n", + " talk.politics.misc 0.60 0.38 0.47 310\n", + " talk.religion.misc 0.61 0.15 0.24 251\n", + "\n", + " accuracy 0.66 7532\n", + " macro avg 0.67 0.65 0.64 7532\n", + " weighted avg 0.67 0.66 0.66 7532\n", + "\n" + ] + } + ], + "source": [ + "from sklearn.pipeline import Pipeline\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "import time\n", + "\n", + "# Train Logistic Regression with TF-IDF\n", + "start = time.time()\n", + "tfidf_pipeline = Pipeline([\n", + " ('tfidf', TfidfVectorizer(max_features=50000, ngram_range=(1, 2))),\n", + " ('clf', LogisticRegression(max_iter=1000, C=1.0))\n", + "])\n", + "tfidf_pipeline.fit(train_data.data, train_data.target)\n", + "lr_time = time.time() - start\n", + "\n", + "# Evaluate\n", + "lr_preds = tfidf_pipeline.predict(test_data.data)\n", + "lr_preds_named = [test_data.target_names[i] for i in lr_preds]\n", + "lr_f1 = float(classification_report(\n", + " true_labels, lr_preds_named, output_dict=True, zero_division=0\n", + ")['weighted avg']['f1-score'])\n", + "\n", + "print(f\"Logistic Regression + TF-IDF Results:\")\n", + "print(f\"F1-Score: {lr_f1:.4f}\")\n", + "print(f\"Training time: {lr_time:.2f} seconds\")\n", + "print(f\"\\nDetailed Report:\")\n", + "print(classification_report(true_labels, lr_preds_named, zero_division=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "fdc4c6d3-2ee5-4571-b676-b13fef8c977a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAJOCAYAAADMCCWlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAmp5JREFUeJzs3XdYlfX/x/HXARmiAioIargH4h6JIzeKI5PK1ExTMv06M3EUmnvQcOUuf5qWs0zLkThwZTlSs6l+cxsJLoQEBYX790cX59sJUETgHOP5uK5zXd2fcd/v+0By8+I+n9tkGIYhAAAAAAAAAIBNsLN2AQAAAAAAAACA/yG0BQAAAAAAAAAbQmgLAAAAAAAAADaE0BYAAAAAAAAAbAihLQAAAAAAAADYEEJbAAAAAAAAALAhhLYAAAAAAAAAYEMIbQEAAAAAAADAhhDaAgAAAAAAAIANIbQFAPzr7dmzRyaTSRMmTLB2KQAA/OuZTCY1b978kfbxuP/snjBhgkwmk/bs2WPtUpADsuN73Jpef/11eXh46M8//7R2KTbjUf/NadKkifz9/bO3KOR5hLYAssX58+dlMpnu+7p586Z5/L59+zRixAi1aNFCbm5uMplM6t27d5aOff36db355puqWrWqXFxc5OLiotKlS6tVq1aaOHGioqOjs+ckbdDRo0fVp08fVaxYUQUKFFD+/PlVvnx59ezZUzt27LB2eQAAwEoedF32zxcy1rx584d6Lx/XoDYyMlKhoaGqU6eO3N3d5ejoqOLFi6tDhw5atmyZkpKSrF0issFvv/2mBQsWaMSIESpUqJC1y/nXmDBhgg4fPqw1a9ZYuxT8i+SzdgEA/l3Kly+vHj16pNvn7Oxs/u+lS5dq+fLlcnFxUalSpRQXF5el4/3+++9q1KiRLl26pFq1aik4OFju7u66fPmyvv32W02YMEGNGzeWl5dXlvZvq1JSUjRixAjNmjVL+fLlU8uWLfXMM8/IwcFBZ8+e1ZYtW7RixQpNmjRJY8eOtXa5Vle/fn2dOHFCHh4e1i4FAIBcMX78+DRts2fPVmxsbLp92enEiRNycXF5pH3Y0s/u3r17p7mr8osvvtAPP/ygXr16qUyZMhZ9ZcqU0eDBg9WtWzeVKlUq9wp9BKtXr1afPn10+/Zt1a1bVz169JCbm5uioqK0a9cuBQcH65NPPlFERIS1S7UJ2fE9bi2TJ0+Wg4ODBg0aZO1S/lVatWqlOnXqaPz48eratSt/DEO2ILQFkK0qVKiQqY+UDB48WCNHjpSvr6++++47NWzYMEvHGz9+vC5dupRhOPnTTz/J3d09S/u2ZW+99ZZmzZqlWrVqad26dSpfvrxF/+3btzVv3jxdv37dShXaFhcXF/n6+lq7DAAAck1612PLli1TbGxsji85kB0/c23pZ3d6nwY7f/68fvjhh3QD3VS2EDhnRnh4uHr06CF3d3d9+eWXat26tUW/YRj64osv9H//939WqtD22Mr35sO6fv26Pv30U3Xu3Jm7bHNAjx49FBISol27dqlVq1bWLgf/AiyPAMAq6tWrp6pVq8re3v6R9nPgwAFJ0pAhQ9Ltr169unx8fNK0nz17Vv369VPZsmXl5OSkYsWKqXnz5lq2bFmasR999JH8/f1VsGBBFSxYUP7+/umO+/s6SN9++63atGkjd3d3i7+yGoahpUuXqnHjxnJ1dZWLi4vq1aunpUuXZvqcT58+rXfffVdFixZVeHh4msBWkvLnz6+RI0dq4sSJFu3Xrl3T66+/bnHeXbp00c8//5xmH71795bJZNLZs2c1ffp0VapUSfnz55efn5/5Yz9JSUkaM2aMypQpI2dnZ9WoUUNbt25Ns6/UjxXeuXNHb775pkqVKiVnZ2dVqVJFc+fOlWEYFuNjY2P1zjvvqFmzZipRooQcHR1VokQJvfzyyzpz5kya/f993bhly5apTp06cnFxMf8SldEaVb/99puCg4PN70eRIkVUs2ZNvf7662lqunDhgvr06aOSJUvK0dFRTzzxhPr06aOLFy9meL53797VhAkTVKZMGTk5OalSpUpasGBBmvEAAFhL6hJXvXv31okTJ/Tss8+qaNGiMplMOn/+vCRpw4YNevHFF1WhQgW5uLjIzc1NTZo00eeff57uPtNb7zP1uuLcuXOaM2eOfH195eTkpNKlS2vixIlKSUmxGJ/Rz+4yZcqoTJkyunXrloYOHaoSJUrIyclJNWrU0Lp16zI8x65du6pIkSIqWLCgmjVrpn379uXourPp7fuf7/XTTz8td3d3FS5cWC+++KKuXbsm6a/r21atWsnV1VWFCxfWq6++qvj4+HSPs2/fPnXs2FEeHh5ycnJSxYoV9dZbbykhISFTdSYnJ2vQoEFKSUnRp59+miawlf76ej777LNav369Rfu9e/c0c+ZM1axZU/nz55ebm5tatGihTZs2pdnHsmXLZDKZtGzZMm3atEn+/v5ycXFRyZIlNXbsWPPXf/ny5eb9lSpVSu+9995939slS5aoevXqcnZ2VsmSJTVs2LB012ldunSpOnXqZL5mLVKkiAIDA7V79+40YzNzTZ/e93hsbKzGjRsnPz8/FSxYUK6urqpQoYJ69eqlCxcuWIyNj4/X+PHj5evra66nQ4cO+uabb+57vqtWrVKtWrWUP39+FS9eXEOHDtXt27fTzMnI6tWrlZiYqBdeeCFN3507dzRjxgzVrFlTbm5uKlCggMqUKaMuXbrohx9+SDP+yy+/VKtWrVS4cGE5OzurWrVqmj59upKTk9M99pdffqk2bdqoaNGicnZ2VpkyZdSzZ880v4dk5feVzP67Iv11c8ubb74pHx8fc92LFy/O8D07duyYOnfurFKlSsnJyUmenp568sknNXXq1DRjU9/X9H5XBLKCO20BPNaKFi0qSfrvf/+r+vXrZ2rO/v371aFDB/35558KDAxUt27dFBMTo++//17vv/++xd0Ur732mubOnauSJUuqT58+kqTPP/9cwcHB5vH/9O2332ratGlq0aKF+vXrZw71DMPQSy+9pNWrV6tixYrq3r27HB0dtWPHDvXp00e//vqrpk+f/sD6ly1bpuTkZP3nP/954LIPTk5O5v++evWqGjZsqDNnzqh58+bq1q2bzp07p3Xr1mnLli3atm2bnnrqqTT7CAkJ0aFDh9SxY0fZ29trzZo16t69uwoXLqy5c+fq119/VYcOHXTnzh2tWrVKnTp10okTJ9INk7t06aLvv/9ezz//vPm9fO2113T+/HnNmDHDPO7EiRMaN26cWrRooWeffVYFChTQyZMntWrVKm3ZskXHjh1T6dKl0+z/vffe0+7du9WpUye1adPmvn8U+OOPP1S/fn3Fx8erQ4cO6tq1q+Lj483rfE2fPl358v31Y/K///2vnnrqKV29elUdO3ZU1apV9fPPP2vp0qXatGmT9u/fr0qVKqU5xosvvqjDhw+rXbt2sre316effqpBgwbJwcFBffv2vc9XDgCA3HX69Gk1aNBA1atXV+/evXX9+nU5OjpKkkJDQ+Xo6KinnnpKxYsX19WrV7Vx40Z17txZc+bMyfCP5+kZOXKk9u7dq6efflqBgYH64osvNGHCBCUlJaUbgqTn7t27atOmjWJiYvT8888rISFBa9asUZcuXRQeHq42bdqYx0ZGRqpRo0a6fPmy2rZtq9q1a+vUqVNq3bq1WrZs+XBvUjY5d+6cGjVqpHr16unVV1/VkSNHtGbNGl26dElvv/222rRpo9atW6tfv37mYDIlJSXNH/kXLlyoQYMGyd3dXR07dlSxYsV05MgRTZ06Vbt379bu3bvNX8OM7N69W2fPnlWjRo0eeGfg368rDcNQ586d9eWXX6pSpUoaNGiQ4uPjtXbtWj3zzDOaOXOmhg0blmYfGzZs0Pbt2xUUFKTGjRtry5YtmjJligzDkJubm6ZMmaJOnTqpefPm+vzzzzVq1Ch5eXnp5ZdfTrOvmTNnKiIiQl27dlWHDh20c+dOzZ49WwcPHtS+ffvk4OBgHjto0CDVrFlTAQEB8vT0VGRkpL744gsFBARo/fr16tSpU5r9Z3RNnx7DMBQYGKhDhw6pcePGatu2rezs7HThwgVt3LhRPXv2NF+73rlzRy1bttThw4dVp04dvf7664qOjtbatWu1bds2rV69Ot1Qdd68eQoPD1enTp3UsmVLhYeHa86cObp27ZpWrlx5369dqtTlLRo0aJCmr1evXvr0009Vo0YNBQcHy8nJSZcuXdLu3bv13XffqWbNmuaxoaGhevvtt1WyZEk999xzcnNz09dff62RI0fq0KFD+uyzzyz2PXz4cM2cOVNFihRRUFCQihUrpkuXLmnnzp2qW7euqlWrJinrv69k9t+VlJQUPfPMM9q5c6eqV6+u7t276/r16xo2bJhatGiRZr/Hjx9Xo0aNZG9vr06dOql06dK6efOmfv31V3344YcaM2aMxfgnnnhCPj4+LCOC7GMAQDY4d+6cIckoX768MX78+DSvAwcOZDj3wIEDhiSjV69eD33cOXPmGJKMYsWKGePGjTN2795txMbGZjj+zp07RsmSJQ07Oztj69atafovXbpk/u+9e/cakowqVaoYN2/eNLffuHHDqFSpkiHJ2Ldvn7l99+7dhiRDkrF06dI0+/7www8NSUZwcLCRlJRkbk9MTDQ6duxoSDKOHDnywHNu3ry5IcnYuXPnA8f+XXBwsCHJCA0NtWjfsmWLIcmoUKGCkZycbG7v1auXIcmoVKmSceXKFXP7oUOHDEmGu7u78dRTTxm3bt0y961du9aQZAwZMsTiGM2aNTMkGZUrV7Z4L2/evGlUrlzZMJlMxnfffWfRfv369TTnsGvXLsPOzs549dVXLdrHjx9vSDIKFChg/Pjjj2nmpX5txo8fb25L/d6ZPXt2mvH/PHaLFi0MScYHH3xg0T5//nxDktGyZct0z9ff39/i+/HkyZNGvnz5jMqVK6c5JgAAOa106dLGP38FTL2Gk2SMGzcu3XlnzpxJ0/bnn38a1atXN9zc3Iz4+HiLPklGs2bNLNpSryvKli1r/PHHH+b2q1evGu7u7kahQoWMxMREc3t6P7v/fg6dOnWyGL9z505DkhEYGGgxvkePHoYkY+rUqRbtS5YsMZ/37t270z3v+0k9n4zmpl6b/L3/7+/1368/UlJSjPbt25uvr7744gtzX1JSklGjRg0jX758RlRUlLn9l19+MfLly2fUrFnTuHbtmsWxw8LCDEnG9OnTH3geEyZMMCQZb731VibP/C/Lly83f53//nW4cOGC4eHhYeTLl8/i++ajjz4yJBkODg7G4cOHze1xcXFGsWLFDBcXF8Pb29tizsWLFw1HR0ejevXqFsdOfW8dHR2NH374wdyekpJidO/ePd1zP3v2bJpz+OOPP4wSJUoYFStWtGh/0DW9YaT9Hv/xxx8NSUZQUFCasXfu3DH+/PNP8/bEiRMNScZLL71kpKSkmNuPHTtmODo6Gu7u7kZcXFya83VzczNOnjxpbk9ISDAqVapk2NnZGZGRkenW+U+enp5GyZIl07TfvHnTMJlMRt26dY179+5Z9N27d8+IiYkxb2/fvt38/9rffw9ISUkx+vfvb0gy1q1bZ27ftGmTIcmoXr16mu/Vu3fvWnxfZ/X3lcz+u5L6fdi2bVuL8/zxxx8NR0fHNP/mhISEGJIs/p9M9c9zSfXss88aktL9ngMeFqEtgGzx94vQ9F6zZs3KcO6jhLYpKSnGyJEjzT9kJRkmk8nw8/Mz3njjDYsf3obxv1Dx5ZdffuC+X3nlFUOSsXbt2jR9K1euNCQZr7zyirkt9QKvTp066e6vRo0aRoECBYyEhIQ0fakXesOHD39gXb6+voYki4u2B0lMTDScnZ2NokWLpvnFyjAMo3Xr1mlC6NSLoOXLl6cZX65cOUOSsXfvXov2e/fuGQ4ODkbTpk0t2lNDzBUrVqTZ1yeffGJIMgYPHpypc6levbpRpkwZi7bUi9lhw4alO+d+oe0/g9h/unDhgiHJ8PPzs7iwNgzDSE5ONn89Ll68aG5PPd9du3al2V9q398vxgEAyA33C229vb0two3MmDFjhiHJ2LNnj0X7/ULb9EKw1L6//+H1QaFteoFI6dKljSJFipi379y5Yzg5ORnFihUz7ty5YzE2JSXFqFy5slVC2/Lly6e5pvj4448NSUaLFi3S7GvSpElpritee+21NNduqZKTkw1PT0+jbt26DzyP1JBt0aJFDxz7dy1btjQkGYcOHUrTN3XqVEOSMWnSJHNbalgWHBycZnzqNffEiRPTPY69vb1x9+5dc1vqe/vPP+IbhmGcP3/esLe3N6pVq5ap8xgyZIghyTh//ry57UHX9IaRcWj74osvPvCY5cqVMxwcHCxuFknVt29fQ5Lx8ccfm9tSzze9P6qk9m3cuPGBx01MTMzwvGJjYw1JRuPGjdN8b/7TM888Y0gyLly4kKYvNfx9/vnnzW3t2rXL8Lr4n/Vl9feVzP67knojxtGjR9OM79OnT4ah7bZt2+5b+9+l/j+V3v+bwMNieQQA2SowMFDh4eG5djyTyaR3331Xo0aN0ldffaWDBw/qyJEjOnr0qH799Vd98MEHCg8Pl7+/vyTp8OHDkmTxsbmMfP/995KU7sMlUj8+c/z48TR9Tz75ZJq2hIQE/fTTTypRooTeeeedNP13796VJJ08efKBdWXFyZMndefOHbVo0SLdJ922aNFCO3bs0PHjx9WkSROLvlq1aqUZX7x4cZ09ezZNn729vYoVK6Y//vgj3Tr+ue+/t6W+36n27Nmj2bNn69ChQ7p27Zru3btn7svoo36ZXSJDkjp27KjQ0FANGjRIERERatu2rZo1a6Zy5cpZjEv9Gjdr1izNU2Dt7OzUtGlTnTx5UsePH0+zfnLdunXTHPeJJ56QJN28eZMHQAAAbEbNmjUz/Pl65coVvf3229q6dasuXLiQZg3NjH7up+dBPxszw93dXWXLlk13P6nPO5CkU6dOKTExUfXq1bP4aL/01zVko0aNdOrUqUzXnl1q1KiR5pqiePHikjK+7pIs3+eDBw9KkrZt25buR7EdHBxy7LpS+uu6zcXFJd1rr/tdJ9/v/DLqS05OVnR0tEqWLGnRl951ZenSpeXj46NffvlFSUlJ5u/ps2fPKiwsTLt27VJkZKQSExMt5v3xxx9plt5K75o+I1WqVFGNGjW0evVq/f777woKClLz5s1Vq1Yt2dn971FCcXFxOnv2rKpUqWL+vv+7Fi1aaPHixTp+/Lh69uxp0feo/++kPqA4vYc0u7q6qn379vrqq69Up04dvfDCC2revLmefPJJi2UmpL++9woUKJDhMzny589v8b13+PBhOTk5qVmzZvet71F+X8nse/PDDz+oQIECqlOnTprxTZo00ZIlSyzaunTpotmzZ+vZZ59V165d1bp1azVt2jTN9+LfFSlSRJLMa1QDj4LQFsC/goeHh15++WXzeldRUVEaPHiwPv/8c/Xr18+8eH5sbKwk3fcHbaq4uDjZ2dnJ09MzTZ+Xl5dMJpPi4uLS7funmJgYGYahyMjINA8H+7uMHjLxd97e3jp58qQiIyNVuXLlB46XZK4zozVwUy+W0zsfV1fXNG2pa71m1JcaQv9TesdPbUv92kjSZ599pq5du6pgwYIKDAxUmTJl5OLiYn6AxT8f5nC//WekTJkyOnjwoCZMmKCvvvpKn376qaS/ngY8adIk81piOfXeZfSQBgAArCGjn3M3btzQk08+qYsXL6px48YKCAiQu7u77O3tdfz4cX355ZdpArD7yY6fjW5ubum258uXz+LBQ6k/m4sVK5bu+Ie5bshOWbm2kmRxfXXjxg1JyvQ6wBnx9vaW9Nfavw8jLi4u3Yf9Stl/XSkp3WvLjL5+Xl5eOn/+vP78808VLVpUp0+fVv369RUXF6cWLVqoY8eOcnV1lZ2dnfbs2aO9e/em+z38MN8f+fLl065duzRhwgR9/vnnGj58uCTJ09NTgwcP1pgxY2Rvb2/V68r8+fNL+mtN3fR89tlnmjZtmlatWmVeq9XV1VXBwcGaNm2aOUi9ceOG7t27l+nfaWJjY1WyZEmL8Do9ufHexMbGZvh9m95x/f39tWfPHvP78tFHH0n6K9B/55130l0HN/WPWukFz8DDIrQF8K/k7e2tTz75RJs3b9aPP/6o69evq2jRoua/LGfmwtTV1VUpKSm6evVqmov9K1euyDCMdC8Q/nnnROq+pL/+CnzkyJEsnNH/NG7cWHv27FFERESmH6CRevzo6Oh0+6OioizG5ZTo6GiVKlUqTZtk+QvYhAkT5OzsrKNHj6pixYoW49esWZPh/tN77++nWrVqWrdune7evaujR49q69atmjNnjrp27aoSJUqocePGNvPeAQCQkzL6GbpkyRJdvHhRkydP1ltvvWXR9/bbb+vLL7/MjfKyJPVn85UrV9Ltz+hn++Mg9dzi4uIe6ZM7jRs3lvTXA6omTZr0UMfP6H3NzevKjNpNJpP5fZk1a5ZiYmL0ySefqEePHhZj+/fvr71796a7n4e9rixatKjmzp2rOXPm6OTJk9q1a5fmzp2r8ePHy8HBQaGhoVa9rnR3d5eDg4M58P8nFxcXTZkyRVOmTNG5c+e0e/duLVq0SO+//75u376tDz74wFybyWTK9J2k7u7uioqKUkpKyn2D29x4b9zc3HT16tV0+zI6bpMmTbR161bdvn1bhw4d0qZNm7RgwQJ16NBBP//8c5pP6aW+v+nd+AM8rPv/qQMAHmNOTk5pPs6T+hGu7du3P3B+7dq1Jf31Mf1/Sm1L72Nc6SlUqJCqVKmiEydOZPqjfxnp3bu37O3t9eGHH2Z40ZEq9a4BX19fOTs767vvvlNCQkKacQ97Pln19ddfZ9iW+n5L0pkzZ1SlSpU0ge3ly5d19uzZbK/LwcFBDRo00MSJEzVnzhwZhqHNmzdL+t97sm/fPhmGYTHPMAzt27fPYhwAAP8mZ86ckSR16tQpTV96P9dtSeXKleXk5KSjR4+muZPSMAyLpRQeN6lLf6Uuk5BVLVq0ULly5fTtt99q9+7d9x379/ewdu3aSkhIMC899nfWvK68cOGCLl26pKpVq5qXRsjoe9gwDH3zzTfZXpfJZFKVKlU0aNAg7dixQ5K0ceNGSX8FjuXKldPp06fTvYkkp9+7atWq6dy5c0pKSrrvuLJly+qVV17R3r17VbBgQXP90l/fe9evX9dvv/2WqWPWr19fiYmJGYbjqXLj95WaNWsqPj5ex44dS9P3oH/P8ufPr+bNm2vGjBkaPXq0bt++bf76/t2pU6fk4OAgX1/fLNcJpCK0BfBYmzFjRobrdc2bN0+3bt2Sr6+vihYtKkl65pln9MQTT2jFihXatm1bmjl/v3jq1auXJGnixIkWH8OJjY01fxwodUxmvPbaa0pISFDfvn3TXQbh3LlzOn/+/AP3U6FCBY0aNUrXrl1Tu3btdO7cuTRj7ty5o5kzZ2rChAmS/loD9sUXX9S1a9cUFhZmMTY8PFzbtm1ThQoVzHdb5JTJkydbLIMQGxurKVOmyGQyWbyXpUuX1unTpy3+4n3nzh0NGDAgw6UXHtbRo0fT/XhV6jGdnZ0lSaVKlVKLFi30yy+/pFm768MPP9SJEyfUsmXLDD9qBQDA4yx1nc/9+/dbtK9atUpfffWVNUrKNCcnJ3Xu3FnR0dGaPXu2Rd/HH3+co2u+5rSBAwcqX758GjJkiC5evJim/+bNm2meF5Aee3t7zZ8/X3Z2durSpYt27dqV7rhNmzapc+fO5u3U67bQ0FCLa7NLly5p5syZypcvn1566aWHPa2H8vHHH+vHH380bxuGodGjRys5OVm9e/c2t2f0Pfz222/r559/zpZazp8/n+51/D+vK6W/3ru7d+8qNDTU4oaAH3/8UcuWLZObm5uCgoKypa5/atasmRITE81Lx6W6evVquu9FTEyMEhMTLep/7bXXJEmvvPKKeZ3cv4uKitKJEyfM24MGDZIkDR06NM1dvvfu3TO/R7nx+0rqOsFjxoyxWDbhp59+0ieffJJm/IEDB9JdTiK9r6skJSUl6fvvv1e9evVYHgHZguURAFjF/v379X//93+SZL5bdP/+/eYLLA8PD02fPv2B+/nkk080YsQIVa9eXf7+/ipWrJhu3rypgwcP6tixY8qfP78WLlxoHu/k5KRPP/1Ubdu2Vbt27dS2bVvVrFlTcXFxOn78uBISEswXuE2bNtWQIUM0d+5cVatWTc8//7wMw9Dnn3+u33//Xa+99pqaNm2a6XP+z3/+o4MHD2r58uX65ptvFBAQoBIlSig6OlonT57UoUOHtGrVKpUpU+aB+5oyZYru3LmjWbNmqXLlymrZsqWqVasmBwcHnTt3Tjt37tT169c1ZcoU85x33nlHe/fu1ZQpU/Ttt9/K399f58+f12effSYXFxd99NFHD1xr6lFVqlTJ/F5KMr+XISEhqlevnnnckCFDNGTIENWuXVudO3fWvXv3tGPHDhmGoZo1a6a50MyKTz75RB988IGaNm2q8uXLy9XVVb/++qu++uorFSlSRMHBweaxCxcu1FNPPaW+fftq06ZN8vPz0y+//KKNGzfK09PT4nsMAIB/k549e+qdd97RkCFDtHv3bpUuXVo//PCDIiIi9Nxzz2n9+vXWLvG+wsLCtHPnTr355pvau3evateurVOnTmnz5s1q27atwsPDc/z6JydUq1ZNCxYs0IABA1S5cmW1b99e5cuX159//qmzZ89q79696t27txYtWvTAfbVt21affPKJXn31VbVq1Ur16tVTw4YNVahQIUVHR2vPnj06c+aMAgICzHN69uyp9evX68svv1SNGjX09NNPKz4+XmvXrtWNGzc0Y8aMNB8bz26BgYFq2LChunXrJk9PT0VEROjIkSNq0KCBhgwZYh7Xv39/ffTRR3r++efVpUsXFS1a1Py7QocOHbRly5ZHruX48eN67rnnVL9+ffn5+cnb21uRkZH64osvZGdnp2HDhpnHjho1Slu2bNEnn3yiEydOqFWrVrpy5YrWrl2re/fuafHixTn2sNpnn31Ws2fP1o4dOywetBYZGanatWurZs2aqlGjhkqWLKnr16/ryy+/1N27dzVixAjz2LZt22rs2LGaPHmyKlSooLZt26p06dK6fv26Tp8+ra+//lpTpkxRlSpVJEnt27fXiBEjNH36dFWsWFHPPvusihUrpsjISEVERGjEiBF6/fXXJeX87yu9evXSqlWrFB4ertq1a6tdu3a6ceOGVq9erTZt2pg/aZfqnXfe0e7du9W0aVOVLVtWzs7OOnbsmCIiIlSuXDk9++yzFuO//vprJSYm5ljojryH0BaAVZw+fVrLly+3aDtz5oz540ulS5fOVGj70UcfadOmTdq1a5e2bdum6Oho2dvbq3Tp0howYICGDRuW5iP2DRs21LFjxxQWFqZt27Zp586dKly4sPz8/NS/f3+LsXPmzFHt2rW1cOFCffjhh5KkqlWratKkSRahXmakPkSrffv2Wrx4sTZv3qxbt26pWLFiqlixoqZPn25xMXw/dnZ2mjlzprp3766FCxdq37592rdvn1JSUlS8eHEFBgYqODjYYn+enp46dOiQJk+erC+//FJff/21+S/548ePV7Vq1R7qfLLi008/1fjx47V69WpFR0erbNmymjNnjgYPHmwxbtCgQXJwcNDcuXO1ePFiubu7q0OHDgoLCzM/IOxRvfjii7pz546++eYbHT58WImJiXriiSc0YMAAjRw50mLt3cqVK+vIkSOaOHGiwsPDtWXLFnl6eio4OFjjx49P87RhAAD+LZ544gnt3btXo0aN0s6dO3Xv3j3VqVNH27dv16VLl2w+tPXx8dGBAwf0xhtvaPv27dq7d6/q1q2r7du367PPPpP0+K5L37dvX9WqVUszZ87Uvn37tGnTJrm5ualUqVIaNmzYQ30irHv37mrWrJnmzp2r7du3a/ny5UpISFDRokVVu3ZtvfXWWxZ3zppMJq1bt07vv/++li9frrlz58rR0VF16tRRSEiInnnmmZw4ZQupx5k9e7ZOnz6tIkWKaOjQoZo8ebJ5aQTpr6Uctm/frrfeekvr16+Xvb29GjVqpG+++UYbN27MltC2Xr16euONN7Rnzx5t2bJFN2/elLe3twICAjRy5Eg1aNDAPNbZ2Vm7du3SO++8o7Vr12rWrFlycXFRs2bNNHr0aD311FOPXE9GmjZtKj8/P61cuVKjR482t5cpU0YTJkzQrl27zDd/eHh4qE6dOho6dKjatm1rsZ9JkyapadOmmjNnjiIiInTz5k0VLVpUZcuW1YQJE9LcZf3ee++pYcOGmjdvntatW6c7d+6oePHiatmypVq3bm0el9O/r9jZ2enLL7/UxIkTtXLlSr3//vsqX768Zs2apYoVK6YJbQcMGCA3NzcdOnRIe/fulWEYKlWqlEaPHq1hw4al+bdjxYoVcnR0fOjfE4GMmIx/LtAHAEA2a968uflCBwAAwBY89dRTOnDggGJjY1WwYEFrl4NMmjBhgiZOnKjdu3erefPm1i7nsbNkyRK9+uqr2r9/f44vjZaXxMTEqHTp0urcuXOaJdWArHr8PgcCAAAAAEAmXb58OU3bihUrzMtVEdgiL+ndu7eqVq1qfkYHssfMmTOVnJysyZMnW7sU/IuwPAIAAAAA4F+rWrVqql27tvz8/GRvb6/jx49rz549KlSoUKaW4wL+Tezt7bV06VJt3bpVf/75Z46tn5vXFClSRB9//LFKlixp7VLwL0JoCwAAAAD41+rfv782bdqkI0eOKD4+Xp6enurevbvGjh0rX19fa5cH5Lr69eurfv361i7jX+XvD5sDsovNrWk7f/58vffee4qKilLNmjU1d+7c+/5jMnv2bC1cuFAXL16Uh4eHOnfurLCwMDk7O+di1QAAAAAAAACQPWxqTdu1a9cqJCRE48eP17Fjx1SzZk0FBgbqypUr6Y5ftWqV3nzzTY0fP14nTpzQkiVLtHbtWounIAIAAAAAAADA48Sm7rT19/fXk08+qXnz5kmSUlJS5OPjoyFDhujNN99MM37w4ME6ceKEIiIizG3Dhw/XoUOHtH///lyrGwAAAAAAAACyi82saZuUlKSjR48qNDTU3GZnZ6eAgAAdOHAg3TmNGjXSihUrdPjwYdWvX19nz57VV199pZ49e2Z4nMTERCUmJpq3U1JSdOPGDRUtWlQmkyn7TggAAAA5xjAM/fnnnypRooTs7Gzqw2O5KiUlRX/88YcKFSrEtSwAAMBjILPXsTYT2l67dk3Jycny8vKyaPfy8tLJkyfTndO9e3ddu3ZNTz31lAzD0L1799S/f//7Lo8QFhamiRMnZmvtAAAAsI5Lly7piSeesHYZVvPHH3/Ix8fH2mUAAADgIT3oOtZmQtus2LNnj6ZNm6YFCxbI399fp0+f1tChQzV58mSNHTs23TmhoaEKCQkxb8fGxqpUqVK6dOmSXF1dc6t0AAAAPIK4uDj5+PioUKFC1i7FqlLPn2tZAACAx0Nmr2NtJrT18PCQvb29oqOjLdqjo6Pl7e2d7pyxY8eqZ8+eevXVVyVJ1atXV3x8vPr166cxY8ake4uxk5OTnJyc0rS7urpyoQsAAPCYyetLAqSeP9eyAADYps8++0wrVqzQ0aNHFRMTo4oVK+q1115TcHCw+ef4iBEjtHXrVl28eFEmk0mVK1fW8OHD1a1bt/vu+/z58ypbtmyadn9/fx08eNCi7dtvv9Xw4cN1/PhxFStWTAMHDtSoUaPy/LWUNT3ovbeZ0NbR0VF169ZVRESEgoKCJP21RldERIQGDx6c7pyEhIQ0way9vb2kv9aHAAAAAAAAAKxl5syZKlOmjGbMmCFPT0/t2LFDffv21aVLlzR+/HhJ0q1bt9S3b1/5+vrKZDJp3bp1evHFF5WSkqLu3bs/8BjTpk1TixYtzNv/vIPz9OnTCgwMVOvWrTVlyhT9+OOPevPNN2Vvb68RI0Zk7wkj29hMaCtJISEh6tWrl+rVq6f69etr9uzZio+PV3BwsCTp5ZdfVsmSJRUWFiZJ6tixo2bOnKnatWubl0cYO3asOnbsaA5vAQAAAAAAAGvYtGmTPDw8zNstW7bU9evXNXPmTI0dO1Z2dnZatGiRxZzAwED9+uuvWrZsWaZC24oVK6pBgwYZ9r/33nsqWrSo1qxZI0dHR7Vq1UpXr17V1KlTNWTIkHQ/kQ7rs6lH7Xbt2lXTp0/XuHHjVKtWLR0/flzh4eHmh5NdvHhRly9fNo9/6623NHz4cL311lvy8/NTnz59FBgYqA8++MBapwAAAAAAAABIkkVgm6p27dqKi4tTfHx8hvOKFi2qpKSkbKlh69atCgoKkqOjo7mtW7duunnzpg4cOGBue/vtt1WhQgU5OzvL09NTAQEBOnfuXLbUgIdnU3faStLgwYMzXA5hz549Ftv58uXT+PHjzbeTAwAAAAAAALZs//79KlmypMUyBoZhKDk5Wbdu3dKmTZu0fft2rVixIlP7GzBggLp27aqiRYuqU6dOeuedd1SkSBFJUnx8vC5duiRfX1+LOalLMZw8eVLNmzfXxx9/rLFjx2rSpElq2LChYmNj9fXXXysuLi77ThwPxeZCWwAAAAAAAODfaP/+/VqzZo1mzJhh0R4REaHWrVtL+usmxXnz5qlz58733ZeTk5MGDBigwMBAubu769ChQ5o6daqOHDmiw4cPy8HBQTdv3pQkubu7W8x1dHSUi4uLbty4IUk6fPiwatSoodDQUPOYTp06PeLZ4lEQ2gIAAAAAAAA57Pfff1fXrl3VokULvfbaaxZ9/v7++u677xQbG6vw8HANGTJE+fLlU58+fTLcX/HixbVgwQLzdrNmzVS1alU9/fTT2rBhg7p06ZLp2urUqaMFCxYoJCREzz33nPz9/eXg4PDwJ4lsY1Nr2gIAAAAAAAD/Njdv3lS7du1UtGhRff7557Kzs4zkChUqpHr16qlVq1Z67733NGjQIIWEhCg5OfmhjtO+fXsVKFBAR48elfS/O2xjY2MtxiUlJSkhIcG8jELv3r01a9Ysbdu2TU2aNJGnp6eGDh2q27dvZ/GM8agIbQEAAAAAAIAccvv2bT399NOKjY3V1q1b5ebm9sA5devWVVxcnK5evfpIxy5QoIB8fHx08uRJi/ZTp07JMAzzWrd2dnYaOnSofvnlF/3+++8aO3asFixYoOnTpz/S8ZF1hLYAAAAAAABADrh37566dOmiEydOKDw8XCVLlszUvP3798vV1VUeHh4PdbzNmzcrPj5eTz75pLmtXbt2+vLLL3X37l1z29q1a+Xu7q5GjRql2UfJkiU1fPhw1ahRQydOnHio4yP7sKYtAAAAAAAAkAMGDhyozZs3a8aMGYqLi9PBgwfNfbVr19apU6f0xhtv6IUXXlCZMmV069Ytbd68Wf/3f/+nsLAw5cv3v+guX7586tWrl5YsWSJJGj58uOzs7NSgQQO5u7vr8OHDCgsLU7169RQUFGSeN3LkSK1cuVIvvviiBg4cqJ9++knvvfeepk6dKkdHR0nSf/7zHxUuXFgNGjRQ4cKF9c033+iHH37QwIEDc+eNQhqEtgAAAAAAAEAO2L59u6S/AtZ/OnfunLy8vOTu7q5JkyYpKipKbm5u8vX11YYNG9SpUyeL8cnJyRZr3Pr5+WnBggX68MMPlZCQoJIlS6pPnz6aOHGiRdhboUIFbd++XSEhIWrfvr08PT01ceJEi5oaNWqkxYsXa/HixUpISFC5cuU0a9as+z4IDTnLZBiGYe0irCkuLk5ubm6KjY2Vq6urtcsBAABAJnAN9xfeBwAAgMdLZq/fWNMWAAAAAAAAAGwIoS0AAAAAAAAA2BBCWwAAAAAAAACwIYS2AAAAAAAAAGBDCG0BAAAAAAAAwIYQ2gIAAAAAAACADSG0BQAAAAAAAAAbQmgLAAAAAAAAADaE0BYAAAAAAAAAbEg+axcAAAAAAACAvKfcwlvWLgGQJJ0dUNDaJaTBnbYAAAAAAAAAYEMIbQEAAAAAAADAhhDaAgAAAAAAAIANIbQFAAAAAAAAABtCaAsAAAAAAAAANoTQFgAAAAAAAABsCKEtAAAAAAAAANgQQlsAAAAAAAAAsCGEtgAAAAAAAABgQwhtAQAAAAAAAMCGENoCAAAAAAAAgA0htAUAAAAAAAAAG0JoCwAAAAAAAAA2hNAWAAAAAAAAAGwIoS0AAAAAAAAA2BBCWwAAAAAAAACwIYS2AAAAAAAAAGBDCG0BAAAAAAAAwIYQ2gIAAAAAAACADSG0BQAAAAAAAAAbQmgLAAAAAAAAADaE0BYAAAAAAAAAbAihLQAAAAAAAADYEEJbAAAAAAAAALAhhLYAAAAAAAAAYEMIbQEAAAAAAADAhhDaAgAAAAAAAIANIbQFAAAAAAAAABtCaAsAAAAAAAAANoTQFgAAAAAAAABsCKEtAAAAAAAAANgQQlsAAAAAAAAAsCGEtgAAAAAAAABgQwhtAQAAAAAAAMCG2GRoO3/+fJUpU0bOzs7y9/fX4cOHMxzbvHlzmUymNK8OHTrkYsUAAAAAAAAAkD1sLrRdu3atQkJCNH78eB07dkw1a9ZUYGCgrly5ku749evX6/Lly+bXzz//LHt7e73wwgu5XDkAAAAAAAAAPDqbC21nzpypvn37Kjg4WH5+flq0aJFcXFy0dOnSdMcXKVJE3t7e5teOHTvk4uJCaAsAAAAAAADgsWRToW1SUpKOHj2qgIAAc5udnZ0CAgJ04MCBTO1jyZIl6tatmwoUKJBTZQIAAAAAAABAjsln7QL+7tq1a0pOTpaXl5dFu5eXl06ePPnA+YcPH9bPP/+sJUuWZDgmMTFRiYmJ5u24uLisFwwAAAAAAAAA2cym7rR9VEuWLFH16tVVv379DMeEhYXJzc3N/PLx8cnFCgEAAAAAAADg/mwqtPXw8JC9vb2io6Mt2qOjo+Xt7X3fufHx8VqzZo369Olz33GhoaGKjY01vy5duvTIdQMAAAAAAABAdrGp0NbR0VF169ZVRESEuS0lJUURERFq2LDhfed+9tlnSkxMVI8ePe47zsnJSa6urhYvAAAAAAAAALAVNrWmrSSFhISoV69eqlevnurXr6/Zs2crPj5ewcHBkqSXX35ZJUuWVFhYmMW8JUuWKCgoSEWLFrVG2QAAAAAAAACQLWwutO3atauuXr2qcePGKSoqSrVq1VJ4eLj54WQXL16UnZ3lDcKnTp3S/v37tX37dmuUDAAAAAAAAADZxuZCW0kaPHiwBg8enG7fnj170rRVrlxZhmHkcFUAAAAAAAAAkPNsak1bAAAAAAAAAMjrCG0BAAAAAAAAwIYQ2gIAAAAAAACADSG0BQAAAAAAAAAbQmgLAABs3smTJ9W6dWsVKFBA3t7eGjVqlJKSkjI1NzIyUr169ZKnp6fy58+vKlWqaOXKleb+8+fPy2QypXk1aNDAYj8TJkxId9yiRYssxi1YsEBPP/20PD09ZTKZtG7dukd/AwAAAADkKfmsXQAAAMD9xMTEqGXLlqpYsaLWr1+vyMhIhYSEKCEhQfPmzbvv3MuXL6thw4aqXLmyPvzwQ7m6uuqXX35RYmJimrHTpk1TixYtzNuFChVKMyZ//vzatWuXRVu5cuUstj/++GNJUvv27c3/DQAAAAAPg9AWAADYtEWLFikuLk4bNmxQkSJFJEn37t3TwIEDNXr0aJUoUSLDuaNGjZKPj4/Cw8Nlb28vSWrVqlW6YytWrJjm7tp/srOze+CYb7/9VnZ2djp//jyhLQAAAIAsYXkEAABg07Zu3aqAgABzYCtJXbp0UUpKirZv357hvLi4OH366acaOHCgObDNDXZ2XF4BAAAAeDT8VgEAAGzayZMn5evra9Hm7u6u4sWL6+TJkxnOO3bsmJKSkuTg4KBmzZrJwcFB3t7eeuONN3T37t004wcMGCB7e3sVK1ZMffv21Y0bN9KMuX37tjw9PZUvXz75+flp8eLFj36CAAAAAPAPLI8AAABsWkxMjNzd3dO0Fy5cON1gNVVUVJQk6dVXX1Xfvn01YcIEHT58WOPGjZOdnZ3CwsIkSU5OThowYIACAwPl7u6uQ4cOaerUqTpy5IgOHz4sBwcHSVKFChX0zjvvqHbt2rpz545WrVqlfv36KTY2ViNGjMj+EwcAAACQZxHaAgCAf6WUlBRJUkBAgGbMmCFJatGihf78809Nnz5d48aNU/78+VW8eHEtWLDAPK9Zs2aqWrWqnn76aW3YsEFdunSRJPXo0cNi/x06dFBSUpKmTJmioUOHmsNdAAAAAHhULI8AAABsWuHChRUbG5umPSYmxmKd2/TmSVLLli0t2lu1aqXExESdPn06w7nt27dXgQIFdPTo0fvW1qVLF8XGxt53XwAAAADwsAhtAQCATfP19U2zdm1sbKwuX76cZq3bv/Pz87vvfu/cuZMt9QEAAABAdiO0BQAANq1du3bauXOnbt68aW777LPPZGdnpzZt2mQ4r3Tp0qpevbp27txp0b5jxw7lz5//vqHu5s2bFR8fryeffPK+ta1Zs0bu7u6qUKFC5k4GAAAAADKBNW0BAIBN69+/v+bOnaugoCCNHj1akZGRGjlypPr3768SJUqYx7Vq1UoXLlywWKpg6tSp6tSpk15//XV16NBB3333naZPn65Ro0apQIECkqThw4fLzs5ODRo0kLu7uw4fPqywsDDVq1dPQUFB5n3VrVtXvXr1kq+vr27fvq2VK1dq/fr1mj17tsV6tkeOHNH58+d19epVSdLBgwclSZ6enmrWrFlOvlUAAAAA/iUIbQEAgE0rXLiwIiIiNGTIEAUFBalQoUJ69dVXNXXqVItxycnJunfvnkVbx44dtXr1ak2ePFkLFy5U8eLFNXHiRL355pvmMX5+flqwYIE+/PBDJSQkqGTJkurTp48mTpyofPn+d6lUoUIFzZo1S1FRUTKZTKpevbpWrFihl156yeKY8+bN0/Lly83bqQ9Ba9asmfbs2ZNdbwsAAACAfzGTYRiGtYuwpri4OLm5uSk2Nlaurq7WLgcAAACZwDXcX3gfAACPs3ILb1m7BECSdHZAwVw7Vmav31jTFgAAAAAAAABsCKEtAAAAAAAAANgQQlsAAAAAAAAAsCGEtgAAAAAAAABgQwhtAQAAAAAAAMCG5LN2AQAA4NHw1F3Ygtx84u7jICwsTOvXr9fJkyeVP39+NWrUSO+8844qV65sHnPnzh0NHz5ca9asUWJiogIDA7VgwQJ5eXlZsXIAAADYAu60BQAAALLZ3r17NWjQIB08eFA7duzQ3bt31aZNG8XHx5vHDBs2TJs2bdJnn32mvXv36o8//tBzzz1nxaoBAABgK7jTFgAAAMhm4eHhFtvLli1TsWLFdPToUTVt2lSxsbFasmSJVq1apZYtW0qSPvroI1WpUkUHDx5UgwYNrFE2AAAAbAR32gKAFZ08eVKtW7dWgQIF5O3trVGjRikpKSlTcyMjI9WrVy95enoqf/78qlKlilauXGnu/+677/TKK6+oQoUKcnFxUcWKFRUaGmpxl5ckHTlyRMHBwapSpYrs7Oz09NNPZ/mYAID0xcbGSpKKFCkiSTp69Kju3r2rgIAA8xhfX1+VKlVKBw4cyHA/iYmJiouLs3gBAADg34c7bQHASmJiYtSyZUtVrFhR69evV2RkpEJCQpSQkKB58+bdd+7ly5fVsGFDVa5cWR9++KFcXV31yy+/KDEx0Txm7dq1+u233zRq1ChVqlRJv/zyi8aNG6dDhw5p165d5nHffPONvv76a/n7++v27duPdEwAQFopKSl6/fXX1bhxY1WrVk2SFBUVJUdHR7m7u1uM9fLyUlRUVIb7CgsL08SJE3OyXAAAANgAQlsAsJJFixYpLi5OGzZsMN95de/ePQ0cOFCjR49WiRIlMpw7atQo+fj4KDw8XPb29pKkVq1aWYx544035Onpad5u3ry5ChcurJdeeklHjx5V3bp1JUlDhgzR0KFDzWMe5ZgAgLQGDRqkn3/+Wfv373/kfYWGhiokJMS8HRcXJx8fn0feLwAAAGwLyyMAgJVs3bpVAQEB5sBWkrp06aKUlBRt3749w3lxcXH69NNPNXDgQHN4mp6/B7apateuLUn6448/zG12dg/+UZDZYwIALA0ePFibN2/W7t279cQTT5jbvb29lZSUpJs3b1qMj46Olre3d4b7c3Jykqurq8ULAAAA/z6EtgBgJSdPnpSvr69Fm7u7u4oXL66TJ09mOO/YsWNKSkqSg4ODmjVrJgcHB3l7e+uNN97Q3bt373vM1Lu8/nncB3mUYwJAXmQYhgYPHqwNGzZo165dKlu2rEV/3bp15eDgoIiICHPbqVOndPHiRTVs2DC3ywUAAICNIbQFACuJiYlJs5ahJBUuXFg3btzIcF7qWoevvvqq6tWrp+3bt2vYsGGaPXu2xo0bl+G8a9euacKECerUqZMqVqz4ULVm9ZgAkFcNGjRIK1as0KpVq1SoUCFFRUUpKirKvHa4m5ub+vTpo5CQEO3evVtHjx5VcHCwGjZsqAYNGli5egAAAFgba9oCwGMmJSVFkhQQEKAZM2ZIklq0aKE///xT06dP17hx45Q/f36LOXfv3lW3bt0kSQsXLsyVYwJAXpb6b+0/1wr/6KOP1Lt3b0nSrFmzZGdnp+eff16JiYkKDAzUggULcrlSAAAA2CLutAUAKylcuLBiY2PTtMfExFisc5vePElq2bKlRXurVq2UmJio06dPW7QbhqFXXnlFhw8f1ldffaXixYtnqdaHOSYA5HWGYaT7Sg1sJcnZ2Vnz58/XjRs3FB8fr/Xr1993PVsAAADkHdxpCwBW4uvrm2bt2tjYWF2+fPm+a876+fndd7937tyx2B4xYoQ+/fRTffXVV6pZs2aWan3YYwIAAAAAgKzjTlsAsJJ27dpp586dFk8O/+yzz2RnZ6c2bdpkOK906dKqXr26du7cadG+Y8cO5c+f3yJgffvttzVr1iwtW7ZMrVq1ynKtD3NMAAAAAADwaLjTFgCspH///po7d66CgoI0evRoRUZGauTIkerfv79KlChhHteqVStduHDBYgmCqVOnqlOnTnr99dfVoUMHfffdd5o+fbpGjRqlAgUKSJJWrVql0NBQ9ejRQ2XLltXBgwfN88uXLy9PT09J0tWrV7V3717zf9+6dUvr1q2TJLVv314uLi6ZPiYAAAAAAHh0hLYAYCWFCxdWRESEhgwZoqCgIBUqVEivvvqqpk6dajEuOTlZ9+7ds2jr2LGjVq9ercmTJ2vhwoUqXry4Jk6cqDfffNM8Zvv27ZKkFStWaMWKFRbz//4gnF9++UUvvPCCRX/q9rlz51SmTJlMHxMAAAAAADw6k2EYhrWLsKa4uDi5ubkpNjZWrq6u1i4HAICHVm7hLWuXAOjsgIK5ejyu4f7C+wAAeJxxHQtbkZvXspm9fmNNWwAAAAAAAACwIYS2AAAAAAAAAGBDCG0BAAAAAAAAwIYQ2gIAAAAAAACADSG0BQAAAAAAAAAbks/aBQBARjp+8ay1SwAkSZuCNli7BAAAAABAHsKdtgAAAAAAAABgQwhtAQAAAAAAAMCGENoCAAAAAAAAgA0htAUAAAAAAAAAG0JoCwAAAAAAAAA2hNAWAAAAAAAAAGwIoS0AAAAAAAAA2BBCWwAAAAAAAACwIYS2AAAAAAAAAGBDbC60nT9/vsqUKSNnZ2f5+/vr8OHD9x1/8+ZNDRo0SMWLF5eTk5MqVaqkr776KpeqBQAAAAAAAIDslc/aBfzd2rVrFRISokWLFsnf31+zZ89WYGCgTp06pWLFiqUZn5SUpNatW6tYsWJat26dSpYsqQsXLsjd3T33iwcAAAAAAACAbGBToe3MmTPVt29fBQcHS5IWLVqkLVu2aOnSpXrzzTfTjF+6dKlu3Lihb7/9Vg4ODpKkMmXK5GbJAAAAAAAAAJCtbGZ5hKSkJB09elQBAQHmNjs7OwUEBOjAgQPpztm4caMaNmyoQYMGycvLS9WqVdO0adOUnJyc4XESExMVFxdn8QIAAAAAAAAAW2Ezoe21a9eUnJwsLy8vi3YvLy9FRUWlO+fs2bNat26dkpOT9dVXX2ns2LGaMWOGpkyZkuFxwsLC5ObmZn75+Phk63kAAAAAAAAAwKOwmdA2K1JSUlSsWDF9+OGHqlu3rrp27aoxY8Zo0aJFGc4JDQ1VbGys+XXp0qVcrBgAAAAAAAAA7s9m1rT18PCQvb29oqOjLdqjo6Pl7e2d7pzixYvLwcFB9vb25rYqVaooKipKSUlJcnR0TDPHyclJTk5O2Vs8AAAAAAAAAGQTm7nT1tHRUXXr1lVERIS5LSUlRREREWrYsGG6cxo3bqzTp08rJSXF3Pbf//5XxYsXTzewBQAAAAAAAABbZzOhrSSFhIRo8eLFWr58uU6cOKEBAwYoPj5ewcHBkqSXX35ZoaGh5vEDBgzQjRs3NHToUP33v//Vli1bNG3aNA0aNMhapwAAAAAAAAAAj8RmlkeQpK5du+rq1asaN26coqKiVKtWLYWHh5sfTnbx4kXZ2f0vZ/bx8dG2bds0bNgw1ahRQyVLltTQoUP1xhtvWOsUAAAAAAAAAOCR2FRoK0mDBw/W4MGD0+3bs2dPmraGDRvq4MGDOVwVAAAAAAAAAOQOm1oeAQAAAAAAAADyOkJbAAAAAAAAALAhhLYAAAAAAAAAYEMIbQEAAAAAAADAhhDaAgAAAAAAAIANIbQFAAAAAAAAABtCaAsAAAAAAAAANoTQFgAAAAAAAABsCKEtAAAAAAAAANgQQlsAAAAAAAAAsCGEtgAAAAAAAABgQwhtAQAAAAAAAMCGENoCAAAAAAAAgA0htAUAAAAAAAAAG0JoCwAAAAAAAAA2hNAWAAAAAAAAAGwIoS0AAAAAAAAA2BBCWwAAAAAAAACwIYS2AAAAAAAAAGBDCG0BAAAAAAAAwIYQ2gIAAAAAAACADSG0BQAAAAAAAAAbQmgLAAAAAAAAADaE0BYAAAAAAAAAbAihLQAAAAAAAADYEEJbAAAAAAAAALAhhLYAAAAAAAAAYEMIbQEAAAAAAADAhhDaAgAAAAAAAIANIbQFAAAAAAAAABtCaAsAAAAAAAAANoTQFgAAAAAAAABsCKEtAAAAAAAAANgQQlsAAAAAAAAAsCGEtgAAAAAAAABgQwhtAQAAAAAAAMCGENoCAAAAAAAAgA0htAUAAAAAAAAAG0JoCwAAAAAAAAA2hNAWAAAAAAAAAGwIoS0AAAAAAAAA2BBCWwAAAAAAAACwIYS2AAAAAAAAAGBDCG0BAAAAAAAAwIYQ2gIAAAAAAACADSG0BQAAAAAAAAAbQmgLAAAAAAAAADaE0BYAAAAAAAAAbAihLQAAAAAAAADYEEJbAAAAAAAAALAhhLYAAAAAAAAAYEMIbQEAAAAAAADAhthkaDt//nyVKVNGzs7O8vf31+HDhzMcu2zZMplMJouXs7NzLlYLAAAAAAAAANnH5kLbtWvXKiQkROPHj9exY8dUs2ZNBQYG6sqVKxnOcXV11eXLl82vCxcu5GLFAAAAAAAAAJB9bC60nTlzpvr27avg4GD5+flp0aJFcnFx0dKlSzOcYzKZ5O3tbX55eXnlYsUAAAAAAAAAkH1sKrRNSkrS0aNHFRAQYG6zs7NTQECADhw4kOG8W7duqXTp0vLx8VGnTp30yy+/ZDg2MTFRcXFxFi8AAAAAAAAAsBU2Fdpeu3ZNycnJae6U9fLyUlRUVLpzKleurKVLl+rLL7/UihUrlJKSokaNGun3339Pd3xYWJjc3NzMLx8fn2w/DwAAAAAAAADIKpsKbbOiYcOGevnll1WrVi01a9ZM69evl6enpz744IN0x4eGhio2Ntb8unTpUi5XDAAAAAAAAAAZy2ftAv7Ow8ND9vb2io6OtmiPjo6Wt7d3pvbh4OCg2rVr6/Tp0+n2Ozk5ycnJ6ZFrBQAAwL/DzZs39e233+rXX3/VtWvXZDKZ5OHhoSpVqqhhw4YqXLiwtUsEAABAHmNToa2jo6Pq1q2riIgIBQUFSZJSUlIUERGhwYMHZ2ofycnJ+umnn9S+ffscrBQAAACPs6SkJK1atUrLli3T/v37lZKSku44Ozs7NW7cWMHBwXrxxRf54z8AAAByhc0tjxASEqLFixdr+fLlOnHihAYMGKD4+HgFBwdLkl5++WWFhoaax0+aNEnbt2/X2bNndezYMfXo0UMXLlzQq6++aq1TAAAAgA1btGiRypUrp/79+8vV1VWzZs3S/v379ccff+j27dtKSEhQZGSk9u/fr5kzZ8rNzU39+/dX+fLlM1yCKz379u1Tx44dVaJECZlMJn3xxRcW/b1795bJZLJ4tW3bNpvPFgAAAI8jm7rTVpK6du2qq1evaty4cYqKilKtWrUUHh5ufjjZxYsXZWf3v6w5JiZGffv2VVRUlAoXLqy6devq22+/lZ+fn7VOAQAAADZs2rRpGjFihIKDg+Xm5pbumOLFi6t48eJq1KiRXnvtNcXFxWnp0qUKCwvTf/7zn0wdJz4+XjVr1tQrr7yi5557Lt0xbdu21UcffWTe5k5eAAAASDYY2krS4MGDM1wOYc+ePRbbs2bN0qxZs3KhKgAAAPwbnD17VvnyPdxlsKurq15//fVML9klSe3atVO7du3uO8bJySnTz24AAABA3mFzyyMAAAAAOelhA9vsmpuePXv2qFixYqpcubIGDBig69evZ+v+AQAA8HiyyTttAQAAgNzy559/6ubNm/Lx8TG3/fHHH1q0aJESExP1/PPPq379+tl+3LZt2+q5555T2bJldebMGY0ePVrt2rXTgQMHZG9vn+6cxMREJSYmmrfj4uKyvS4AAABYH6EtAAAA8rR+/frp3LlzOnjwoKS/gtAGDRro999/l52dnd5//32Fh4erefPm2Xrcbt26mf+7evXqqlGjhsqXL689e/aoVatW6c4JCwvTxIkTs7UOAAAA2B6WRwAAAECetn//fj399NPm7RUrVuiPP/7Qt99+q5iYGNWoUUNTpkzJ8TrKlSsnDw8PnT59OsMxoaGhio2NNb8uXbqU43UBAAAg9xHaAgAAIE+7du2aSpYsad7euHGjnnrqKTVo0ECFChXSyy+/rB9++CHH6/j99991/fp1FS9ePMMxTk5OcnV1tXgBAADg34fQFgAAAHmau7u7oqKiJEm3b9/W119/rTZt2pj78+XLp4SEhIfe761bt3T8+HEdP35cknTu3DkdP35cFy9e1K1btzRy5EgdPHhQ58+fV0REhDp16qQKFSooMDAwW84LAAAAjy/WtAUAAECe1qhRIy1YsEC+vr4KDw/XnTt31KlTJ3P/f//7X4s7cTPryJEjatGihXk7JCREktSrVy8tXLhQP/74o5YvX66bN2+qRIkSatOmjSZPniwnJ6dHPykAAAA81ghtAQAAkKe98847atOmjZ5//nlJ0vDhw1W1alVJUnJysj777DO1bdv2offbvHlzGYaRYf+2bduyVjAAAAD+9QhtAQAAkKdVqFBBp06d0q+//io3NzeVKVPG3JeQkKB58+apZs2a1isQAAAAeQ6hLQAAAPI8BweHdIPZQoUKWSyVAAAAAOQGQlsAAADkKfv27cvSvKZNm2ZzJQAAAED6CG0BAACQpzRv3lwmk8m8bRiGxXZGkpOTc7IsAAAAwIzQFgAAAHnK7t27LbYTExM1atQoJSQkqF+/fqpcubIk6eTJk1q8eLEKFCigd9991xqlAgAAII8itAUAAECe0qxZM4vtkJAQOTo66uDBg3J2dja3d+zYUYMGDVKzZs0UHh6u1q1b53apAAAAyKPsrF0AAAAAYE0rV65Uz549LQLbVC4uLurZs6dWrFhhhcoAAACQVxHaAgAAIE+Lj4/X5cuXM+y/fPmyEhIScrEiAAAA5HWEtgAAAMjTAgIC9P7772v9+vVp+j7//HO9//77CggIsEJlAAAAyKtY0xYAAAB52vz589WyZUu98MILKl68uCpUqCBJOnPmjP744w+VL19ec+fOtXKVAAAAyEu40xYAAAB5WsmSJfXDDz9o5syZqlatmqKjoxUdHa2qVatq1qxZ+uGHH/TEE09Yu0wAAADkIdxpCwAAgDzP2dlZQ4cO1dChQ61dCgAAAMCdtgAAAAAAAABgS7jTFgAAAHnetm3btGTJEp09e1YxMTEyDMOi32Qy6cyZM1aqDgAAAHkNoS0AAADytPfee09vvvmmvLy8VL9+fVWvXt3aJQEAACCPy3Joe/HiRU2bNk27d+/W1atX9cUXX6hp06a6du2aJk2apODgYNWuXTs7awUAAACy3fvvv6+WLVvqq6++koODg7XLAQAAALIW2v76669q0qSJUlJS5O/vr9OnT+vevXuSJA8PD+3fv1/x8fFasmRJthYLAAAAZLeYmBh17tyZwBYAAAA2I0uh7ahRo+Tu7q6DBw/KZDKpWLFiFv0dOnTQ2rVrs6VAAAAAICfVr19fp06dsnYZAAAAgJldVibt27dPAwYMkKenp0wmU5r+UqVKKTIy8pGLAwAAAHLaggULtH79eq1atcrapQAAAACSsninbUpKilxcXDLsv3r1qpycnLJcFAAAAJBbunbtqnv37qlnz54aMGCAnnjiCdnb21uMMZlM+uGHH6xUIQAAAPKaLIW2derU0ZYtWzRw4MA0fffu3dOaNWvUoEGDRy4OAAAAyGlFihRR0aJFVbFiRWuXAgAAAEjKYmgbGhqqp59+WgMGDFC3bt0kSdHR0dq5c6emTZumEydOaN68edlaKAAAAJAT9uzZY+0SAAAAAAtZCm3btWunZcuWaejQofrwww8lST169JBhGHJ1ddXHH3+spk2bZmuhAAAAAAAAAJAXZCm0laSePXvqueee044dO/Tbb78pJSVF5cuXV2BgoAoVKpSdNQIAAAA5Kjk5WStWrNCWLVt04cIFSVLp0qX19NNP66WXXkqzxi0AAACQkx46tE1ISJCPj4/efPNNjRw5UkFBQTlQFgAAAJA7YmNjFRgYqO+++06FChVSuXLlJEk7duzQ559/roULF2rbtm1ydXW1cqUAAADIK+wedoKLi4vy5cunAgUK5EQ9AAAAQK4aM2aMjh49qrlz5+rq1as6duyYjh07pitXrmjevHk6cuSIxowZY+0yAQAAkIc8dGgrSc8//7zWrVsnwzCyux4AAAAgV23YsEEDBw7UwIED5eDgYG53cHDQgAEDNGDAAH3++edWrBAAAAB5TZbWtO3WrZsGDhyoFi1aqG/fvipTpozy58+fZlydOnUeuUAAAAAgJ12/fl2VK1fOsN/X11c3btzIxYoAAACQ12UptG3evLn5v7/++us0/YZhyGQyKTk5OcuFAQAAALmhQoUK2rhxowYOHJhu/8aNG1W+fPlcrgoAAAB5WZZC248++ii76wAAAACsYuDAgRo8eLDat2+v119/XZUqVZIknTp1SnPmzNGOHTs0b948K1cJAACAvCRLoW2vXr2yuw4AAADAKgYOHKgrV67o7bff1rZt2yz6HBwcNG7cOA0YMMBK1QEAACAvylJo+3e3bt3SpUuXJEk+Pj4qWLDgIxcFAAAA5KYJEyZo8ODB2rlzpy5cuCBJKl26tAICAuTh4WHl6gAAAJDXZDm0/e677zRq1Cjt379fKSkpkiQ7Ozs1adJE7777rurVq5dtRQIAAAA5zcPDQ926dbN2GQAAAEDWQttDhw6pefPmcnR01KuvvqoqVapIkk6cOKHVq1eradOm2rNnj+rXr5+txQIAAADZbefOndq1a5emTZuWbv+YMWPUqlUrtWzZMpcrAwAAQF6VpdB2zJgxKlmypPbv3y9vb2+LvgkTJqhx48YaM2aMduzYkS1FAgAAADll8uTJKlWqVIb9kZGRmjJlCqEtAAAAco1dViYdOnRI//nPf9IEtpLk5eWlfv366eDBg49cHAAAAJDTfvrpJ/n7+2fY/+STT+rHH3/MxYoAAACQ12UptLWzs9O9e/cy7E9OTpadXZZ2DQAAAOSqxMREJSUl3bc/ISEhFysCAABAXpelZLVRo0aaP3+++cm6f3fx4kUtWLBAjRs3fuTiAAAAgJxWrVo1bdiwId0+wzC0fv16+fn55XJVAAAAyMuytKbttGnT1LRpU/n6+urZZ59VpUqVJEmnTp3Sl19+qXz58iksLCxbCwUAAABywpAhQ/Tyyy/rhRde0Lhx48wP2f311181adIkHThwQEuXLrVylQAAAMhLshTa1q5dW4cOHdKYMWO0ceNG88fFXFxc1LZtW02ZMoW7EQAAAPBY6NGjh86cOaPJkydr/fr15mW+UlJSZDKZ9NZbb6lXr15WrhIAAAB5SZZCW0ny8/PThg0blJKSoqtXr0qSPD09WcsWAAAAj53x48erR48e2rBhg86ePStJKl++vIKCglS+fHkrVwcAAIC8JsuhbSo7Ozt5eXllRy0AAACA1ZQvX14jRoywdhkAAABA1h5E9tZbb6lWrVoZ9teuXVsTJ07Mak0AAABArjt48KDCwsI0bNgw/fbbb5KkhIQEHTt2TLdu3bJydQAAAMhLshTarlu3Tu3atcuwv3379lq7dm2WiwIAAAByS1JSkp577jk1btxYY8aM0Zw5c3Tp0iVJf32qrE2bNnr//fetXCUAAADykiyFthcvXrzv2l5ly5bVhQsXslzU/PnzVaZMGTk7O8vf31+HDx/O1Lw1a9bIZDIpKCgoy8cGAABA3jJ27Fht3rxZCxcu1KlTp2QYhrnP2dlZL7zwgr788ksrVggAAIC8JkuhbcGCBe8byp47d07Ozs5ZKmjt2rUKCQnR+PHjdezYMdWsWVOBgYG6cuXKfeedP39eI0aMUJMmTbJ0XAAAAORNq1ev1oABA9SvXz8VKVIkTX+VKlXMDycDAAAAckOWQtvmzZvrgw8+UGRkZJq+S5cu6cMPP1SLFi2yVNDMmTPVt29fBQcHy8/PT4sWLZKLi4uWLl2a4Zzk5GS99NJLmjhxosqVK5el4wIAACBvunLliqpXr55hv729vRISEnKxIgAAAOR1+bIyafLkyapfv76qVq2qPn36qGrVqpKkn3/+WUuXLpVhGJo8efJD7zcpKUlHjx5VaGiouc3Ozk4BAQE6cOBAhvMmTZqkYsWKqU+fPvr6668f/oQAAACQZ/n4+OjkyZMZ9n/zzTeqUKFCLlYEAACAvC5LoW3lypX19ddfa8iQIZo1a5ZFX9OmTTVnzhxVqVLlofd77do1JScny8vLy6Ldy8srwwvp/fv3a8mSJTp+/HimjpGYmKjExETzdlxc3EPXCQAAgH+P7t27a+bMmXr++edVqVIlSZLJZJIkLV68WJ9++qnefvtta5YIAACAPCZLoa0k1ahRQ3v37tW1a9fMa3yVK1dOHh4e2Vbcg/z555/q2bOnFi9enOnjhoWFaeLEiTlcGQAAAB4XY8aM0cGDB9W0aVNVqVJFJpNJw4YN040bN/T777+rffv2GjZsmLXLBAAAQB6S5dA2lYeHR7YFtR4eHrK3t1d0dLRFe3R0tLy9vdOMP3PmjM6fP6+OHTua21JSUiRJ+fLl06lTp1S+fHmLOaGhoQoJCTFvx8XFycfHJ1vqBwAAwOPH0dFR4eHhWrlypdatW6fk5GQlJiaqRo0amjJlinr27Gm+8xYAAADIDZkObaOiovTf//5XderUUcGCBc3td+/e1eTJk7Vy5UpdvnxZvr6+mjBhgp555pmHLsbR0VF169ZVRESEgoKCJP0VwkZERGjw4MFpxvv6+uqnn36yaHvrrbf0559/6v333083jHVycpKTk9ND1wYAAIB/L5PJpB49eqhHjx7WLgUAAADIfGj79ttva/Xq1bp06ZJF+/DhwzVv3jy5u7uratWq+vXXX/X8888rIiJCTZs2feiCQkJC1KtXL9WrV0/169fX7NmzFR8fr+DgYEnSyy+/rJIlSyosLEzOzs6qVq2axXx3d3dJStMOAAAAZJZhGNq9e7cSExP11FNPqVChQtYuCQAAAHlIpkPbvXv3qmPHjnJ0dDS3Xb16VQsWLJCfn5/2798vd3d3XbhwQQ0bNtSMGTOyFNp27dpVV69e1bhx4xQVFaVatWopPDzc/HCyixcvys7O7qH3CwAAAKRnzJgx+vbbb7V7925JfwW2bdq00a5du2QYhkqVKqWIiIg0y24BAAAAOSXT6eelS5dUtWpVi7bNmzcrJSVFI0aMMN/hWrp0aQUHB+vQoUNZLmrw4MG6cOGCEhMTdejQIfn7+5v79uzZo2XLlmU4d9myZfriiy+yfGwAAADkLZ9//rnq169v3l63bp0iIiI0ZcoUbd68WcnJyZowYYL1CgQAAECek+k7be/cuWOxlq0kff311zKZTGrVqpVFe/ny5RUTE5M9FQIAAAA5KDIyUhUqVDBvr1+/Xn5+fgoNDZUkDRgwQAsXLrRWeQAAAMiDMn2nbdmyZXX8+HGLtt27d6t06dJpHvh169YtFSlSJFsKBAAAAHJSvnz5lJiYKOmvpREiIiLUtm1bc7+Xl5euXbtmrfIAAACQB2U6tH3uuee0fPlyrV27VpcuXdLUqVN14cIFdenSJc3YgwcPqly5ctlaKAAAAJATqlWrphUrVigmJkYfffSRrl+/rg4dOpj7L1y4IA8PDytWCAAAgLwm08sjjBo1Sps2bdKLL74ok8kkwzBUuXJljRkzxmLc9evXtXHjRo0cOTLbiwUAAACy27hx49SxY0dzMNu4cWO1aNHC3L9lyxY9+eST1ioPAAAAeVCmQ9sCBQro8OHD2rBhg86ePavSpUsrKChIzs7OFuMiIyM1ceJEde7cOduLBQAAALJb69atdezYMe3YsUPu7u7q2rWruS8mJkZNmzZVp06drFghAAAA8ppMh7bSX+t9vfDCC/cdU6NGDdWoUeORigIAAAByk5+fn/z8/NK0Fy5cWLNmzbJCRQAAAMjLMr2mLQAAAPBvkJCQYJW5AAAAQGYR2gIAACBP8fHx0aRJk3T58uVMz4mMjNS4ceNUqlSpHKwMAAAA+MtDLY8AAAAAPO4WLlyoCRMmaNKkSWrcuLECAgJUp04dlS1bVoULF5ZhGIqJidG5c+d05MgR7dy5UwcPHlTFihW1YMECa5cPAACAPIDQFgAAAHlKly5d1LlzZ23cuFHLli3T1KlTlZSUJJPJZDHOMAw5OjqqTZs2WrdunZ555hnZ2fFBNQAAAOQ8QlsAAADkOXZ2dgoKClJQUJASExN19OhRnTx5UtevX5ckFS1aVL6+vqpbt66cnJysXC0AAADyGkJbAAAA5GlOTk5q1KiRGjVqZO1SAAAAAEk59CCyzZs365VXXsmJXQMAAAAAAADAv1qOhLY//PCDli9fnhO7BgAAAAAAAIB/NZ6kAAAAAAAAAAA2JNNr2pYrVy7TO42Njc1SMQAAAAAAAACQ12U6tL148aJKliypGjVqPHDs6dOndfPmzUepCwAAAAAAAADypEyHtlWqVJG7u7s2bdr0wLFTp07VuHHjHqkwAAAAAAAAAMiLMr2mbf369XXs2DElJyfnZD0AAABArrt48aL69++vypUrq0iRItq3b58k6dq1a3rttdf0/fffW7lCAAAA5CWZvtO2W7duSklJ0dWrV+Xt7X3fsc8884yeeOKJRy4OAAAAyGm//vqrmjRpopSUFPn7++v06dO6d++eJMnDw0P79+9XfHy8lixZYuVKAQAAkFdkOrRt3bq1Wrdunamx1atXV/Xq1bNcFAAAAJBbRo0aJXd3dx08eFAmk0nFihWz6O/QoYPWrl1rpeoAAACQF2V6eQQAAADg32jfvn0aMGCAPD09ZTKZ0vSXKlVKkZGRVqgMAAAAeVWmQ9vRo0frxx9/zMlaAAAAgFyXkpIiFxeXDPuvXr0qJyenXKwIAAAAeV2mQ9u3335bP//8s3n7+vXrsre3165du3KkMAAAACA31KlTR1u2bEm37969e1qzZo0aNGiQy1UBAAAgL3uk5REMw8iuOgAAAACrCA0NVXh4uAYMGGC+SSE6Olo7d+5UmzZtdOLECb355ptWrhIAAAB5SaYfRAYAAAD8G7Vr107Lli3T0KFD9eGHH0qSevToIcMw5Orqqo8//lhNmza1cpUAAADISwhtAQAAkOf17NlTzz33nLZv367Tp08rJSVF5cuXV2BgoAoVKmTt8gAAAJDHPNTyCOfPn9exY8d07Ngx80PJfvvtN3PbP1/Iu06ePKnWrVurQIEC8vb21qhRo5SUlPTAeT169FDFihVVoEABFS5cWE2bNtX27dstxiQlJWnUqFFq2rSpChQoIJPJpGvXrqW7vyVLlqhGjRoqUKCAfHx81LdvX125csViTGxsrPr16ycPDw+5uLioefPmOn78eJbPHQAAPJ4KFCigZ599ViNHjtQbb7yhzp07E9gCAADAKh7qTtuxY8dq7NixFm0DBw5MM84wDJlMJiUnJz9adXgsxcTEqGXLlqpYsaLWr1+vyMhIhYSEKCEhQfPmzbvv3KSkJIWEhKhixYq6c+eOlixZovbt22v37t1q0qSJJCkhIUGLFy/Wk08+qSZNmmjbtm3p7uvjjz/Wq6++qpEjR6pt27a6cOGCRo8erV9//VXffPONedyLL76oI0eO6N1335WXl5dmzZqlli1b6ocffpCPj0/2vTEAAMCm3b17V5GRkYqJiUn32Q116tSxQlUAAADIizId2n700Uc5WQf+RRYtWqS4uDht2LBBRYoUkfTXk5cHDhyo0aNHq0SJEhnO/fTTTy2227Vrp7Jly+qTTz4xh7bu7u66ceOGTCaTli1blmFou2rVKjVr1kzvvvuuRfsrr7yiS5cuycfHRwcPHtTWrVu1ceNGdezYUZLUokULlS1bVtOnT9f777+f5fcBAAA8Hm7evKkRI0Zo5cqV6X4yiBsSAAAAkNsyHdr26tUrJ+vAv8jWrVsVEBBgDmwlqUuXLurfv7+2b9+u3r17Z3pf9vb2cnd3T/MLlMlkeuDcu3fvys3NzaItdTv17pnvv/9eJpNJrVu3No9xcXFRkyZNtGnTJkJbAADygN69e2vTpk3q1q2b/P3901w/AAAAALmNB5Eh2508eVKvvPKKRZu7u7uKFy+ukydPPnC+YRhKTk5WbGysPvroI/3222/64IMPHrqOPn36KDg4WOvWrVNgYKAuXryoqVOnqmPHjipVqpQk6c6dO7Kzs1O+fJb/Kzg5Oen8+fO6ffu28ufP/9DHBgAAj4/t27frtdde06xZs6xdCgAAACCJ0BY5ICYmRu7u7mnaCxcurBs3bjxw/pIlS9S3b19JUsGCBbV27Vo1bNjwoevo3r274uPj1b17d929e1eSFBAQoDVr1pjHVKxYUcnJyTp27Jjq168vSUpJSdF3330nwzB08+ZNQlsAAP7lihYtqgoVKli7DAAAAMDMztoFAP8UFBSk7777Tlu3blWXLl3UpUsXbd269aH3s379eg0fPlxjx47Vnj179PHHH+u3335Tly5dzMsjtGnTRuXLl1f//v31888/68qVKxoxYoTOnj0rKXPLMAAAgMdbv379tGbNGqWkpFi7FAAAAEASd9oiBxQuXFixsbFp2mNiYizWuc2Ih4eHPDw8JElt27bVjRs3NHLkSLVr1y7TNRiGof79+6tv374aO3asub1cuXJ66qmntGPHDrVp00aOjo5au3atXnzxRVWvXl2SVL16db3++uuaM2eOihYtmuljAgCAx9PYsWOVmJioevXqqWfPnnriiSdkb2+fZtxzzz1nheoAAACQFxHaItv5+vqmWbs2NjZWly9flq+v70Pvr27dug99p+3Vq1d19epV1apVy6K9du3akqQzZ85Y7P/UqVM6ffq0DMNQxYoVNXjwYNWtW1cODg4PXS8AAHi8REZGateuXTp+/LiOHz+e7hiTyaTk5OTcLQwAAAB5FqEtsl27du00bdo03bx507y27WeffSY7Ozu1adPmofe3f/9+lStX7qHmeHp6ysXFRceOHVPPnj3N7UePHpUklSlTxmK8yWRSxYoVJf0V+K5du1bvvvvuQ9cKAAAeP6+88oqOHTum0NBQ+fv7y83NzdolAQAAII8jtEW269+/v+bOnaugoCCNHj1akZGRGjlypPr3768SJUqYx7Vq1UoXLlzQ6dOnJUlbtmzRxx9/rKefflo+Pj66ceOGVq1apW3btmn16tUWx9i6davi4+N15MgRSdKmTZtUqFAh+fn5yc/PTyaTSf369dP8+fPl6uqqZs2a6cKFC5owYYKqVq2qli1bmvc1depUVahQQV5eXjp16pSmTZumunXrqnfv3jn/ZgEAAKvbv3+/3njjDU2cODFb97tv3z699957Onr0qC5fvqwNGzYoKCjI3G8YhsaPH6/Fixfr5s2baty4sRYuXGj+QzIAAADyLkJbZLvChQsrIiJCQ4YMUVBQkAoVKqRXX31VU6dOtRiXnJyse/fumbfLly+vxMREvfnmm7p27Zo8PDxUo0YN7dmzR82aNbOYO2DAAF24cMG8/corr0iSxo8frwkTJkiS3n77bXl6euqTTz7Re++9Jw8PD7Vo0UJTp06Vk5OTeW5MTIxGjBihK1euqHjx4urZs6feeust2dnxnD4AAPICb2/vTK27/7Di4+NVs2ZNvfLKK+muh/vuu+9qzpw5Wr58ucqWLauxY8cqMDBQv/76q5ydnbO9HgAAADw+TIZhGNYuwpri4uLk5uam2NhYubq6WrscAH/T8YtnrV0CIEnaFLTB2iXcV7mFt6xdAqCzAwrm6vGy8xpuwYIFWrhwoQ4cOKCCBXPmPEwmk8WdtoZhqESJEho+fLhGjBgh6a9nAHh5eWnZsmXq1q1bpvbLtSwA4HHGdSxsRW5ey2b2+o07bQEAAJCn3blzRw4ODqpQoYK6dOkiHx8f2dvbW4wxmUwaNmxYth3z3LlzioqKUkBAgLnNzc1N/v7+OnDgQKZDWwAAAPw7EdoCAAAgT0u901WS5s2bl+6Y7A5to6KiJEleXl4W7V5eXua+9CQmJioxMdG8HRcXl201AQAAwHYQ2gIAACBPO3funLVLyLSwsLBsf2AaAAAAbA+hLQAAAPK00qVL5/oxvb29JUnR0dEqXry4uT06Olq1atXKcF5oaKhCQkLM23FxcfLx8cmxOgEAAGAddtYuAAAAAMhrypYtK29vb0VERJjb4uLidOjQITVs2DDDeU5OTnJ1dbV4AQAA4N+HO22tJD7A39olACqw85C1SwAAINeVLVtWdnZ2OnnypBwcHFS2bFmZTKb7zjGZTDpz5sxDHefWrVs6ffq0efvcuXM6fvy4ihQpolKlSun111/XlClTVLFiRZUtW1Zjx45ViRIlFBQUlJXTAgAAwL8IoS0AAADylGbNmslkMsnOzs5iO7sdOXJELVq0MG+nLmvQq1cvLVu2TKNGjVJ8fLz69eunmzdv6qmnnlJ4eLicnZ2zvRYAAAA8XghtAQAAkKcsW7ZM+/bt040bN+Tp6ally5blyHGaN28uwzAy7DeZTJo0aZImTZqUI8cHAADA44s1bQEAAJDntGjRQjt27LB2GQAAAEC6CG0BAACQ59zvDlgAAADA2ghtAQAAAAAAAMCGENoCAAAgT8qJh48BAAAA2YHQFgAAAHlSjx49ZG9vn6lXvnw8vxcAAAC5xyavPufPn6/33ntPUVFRqlmzpubOnav69eunO3b9+vWaNm2aTp8+rbt376pixYoaPny4evbsmctVAwAA4HESEBCgSpUqWbsMAAAAIA2bC23Xrl2rkJAQLVq0SP7+/po9e7YCAwN16tQpFStWLM34IkWKaMyYMfL19ZWjo6M2b96s4OBgFStWTIGBgVY4AwAAADwOevXqpe7du1u7DAAAACANm1seYebMmerbt6+Cg4Pl5+enRYsWycXFRUuXLk13fPPmzfXss8+qSpUqKl++vIYOHaoaNWpo//79uVw5AAAAAAAAADw6mwptk5KSdPToUQUEBJjb7OzsFBAQoAMHDjxwvmEYioiI0KlTp9S0adN0xyQmJiouLs7iBQAAAAAAAAC2wqZC22vXrik5OVleXl4W7V5eXoqKispwXmxsrAoWLChHR0d16NBBc+fOVevWrdMdGxYWJjc3N/PLx8cnW88BAAAAAAAAAB6Fza1pmxWFChXS8ePHdevWLUVERCgkJETlypVT8+bN04wNDQ1VSEiIeTsuLo7gFgAAII9JSUmxdgkAAABAhmwqtPXw8JC9vb2io6Mt2qOjo+Xt7Z3hPDs7O1WoUEGSVKtWLZ04cUJhYWHphrZOTk5ycnLK1roBAAAAAAAAILvY1PIIjo6Oqlu3riIiIsxtKSkpioiIUMOGDTO9n5SUFCUmJuZEiQAAAAAAAACQo2zqTltJCgkJUa9evVSvXj3Vr19fs2fPVnx8vIKDgyVJL7/8skqWLKmwsDBJf61RW69ePZUvX16JiYn66quv9Mknn2jhwoXWPA0AAAAAAAAAyBKbC227du2qq1evaty4cYqKilKtWrUUHh5ufjjZxYsXZWf3vxuE4+PjNXDgQP3+++/Knz+/fH19tWLFCnXt2tVapwAAAAAAAAAAWWZzoa0kDR48WIMHD063b8+ePRbbU6ZM0ZQpU3KhKgAAAAAAAADIeTa1pi0AAAAAAAAA5HWEtgAAAAAAAABgQwhtAQAAAADAI2vevLlMJlO6rzVr1qQ7Z8+ePRnO8fX1feC4bt265dbpAUCussk1bQEAAAAAwONlwYIFiouLs2ibPXu2Pv/8cwUEBKQ7p06dOjpw4IBFW1xcnNq1a6d27dqlGf/RRx9ZhLkeHh7ZUDkA2B5CWwAAAAAA8Mj8/PzStB0+fFht2rTJMFx1dXVVgwYNLNqWLVumlJQUde/ePc34atWqqV69etlTMADYMJZHAAAAAAAA2e7bb7/VuXPn9NJLLz3UvFWrVqlixYp68sknH/qYGzduVL169VSwYEG5u7urXr16+uqrrx56PwBgbYS2AAAAAAAg261atUoFChRQp06dMj0nOjpau3btSvcuW0lq37697O3t9cQTT2jkyJG6ffu2ue/MmTPq3Lmzqlatqg0bNmjt2rXq0qWLYmJiHvlcACC3sTwCAAAAAADIVvfu3dOnn36qZ555RgUKFMj0vLVr1yo5OTlNaOvm5qZRo0apadOmyp8/v3bt2qXp06frxIkT2rx5syTp+++/1927dzVv3jwVKlRIkhQYGJh9JwUAuYjQFgAAAAAAZKsdO3bo6tWrGd4xm5GVK1eqbt26qlSpkkV77dq1Vbt2bfN2y5YtVbx4cQ0ePFiHDx9W/fr1VaNGDdnb26t79+7q16+fmjZtKjc3t2w5HwDIbSyPAAAAAAAAstWqVatUtGjRh7rT9cyZMzp8+HCm18Dt0qWLJOno0aOSpEqVKmnz5s2KjY3Vs88+K09PTz3zzDO6ePHiw58AAFgZoS0AAAAAAMg2t2/f1hdffKEXXnhBDg4OmZ63atUq2dnZqVu3blk+dtu2bbVv3z7duHFDK1as0NGjRxUcHJzl/QGAtRDaAgAAAACAbLNx40bdunXroZdGWL16tZo3b67ixYtnavyaNWskSU8++WSaPldXV3Xp0kXdunXTiRMnHqoOALAFrGkLAAAAAACyzapVq1SqVCk99dRTafpatWqlCxcu6PTp0xbt33//vU6cOKHhw4enu88ePXqoQoUKqlOnjpydnbVr1y7NmjVLQUFBqlevniTpgw8+0IEDB9S2bVsVL15c586d04oVK9SmTZvsP0kAyGGEtgAAAAAAIFvExMQoPDxcr7/+ukwmU5r+5ORk3bt3L037qlWr5OTkpOeffz7d/VatWlUrV67UjBkzlJiYqLJly2r06NEKDQ01j6lRo4Y2bdqkkJAQXb9+Xd7e3nrxxRc1efLk7DtBAMglJsMwDGsXYU1xcXFyc3NTbGysXF1dc+248QH+uXYsICMFdh6ydgn31fGLZ61dAiBJ2hS0wdol3Fe5hbesXQKgswMK5urxrHUNZ2t4HwAAjzOuY2ErcvNaNrPXb6xpCwAAAAAAAAA2hNAWAAAAAAAAAGwIoS0AAAAAAAAA2BBCWwAAAAAAAACwIYS2AAAAAAAAAGBDCG0BAAAAAAAAwIYQ2gIAAAAAAACADSG0BQAAAAAAAAAbQmgLAAAAAAAAADYkn7ULAAAAAADg36bjF89auwRAm4I2WLsEAFnEnbYAAAAAAAAAYEMIbQEAAAAAAADAhhDaAgAAAAAAAIANIbQFAAAAAAAAABtCaAsAAAAAAAAANoTQFgAAAAAAAABsCKEtAAAAAAAAANgQQlsAAAAAAAAAsCGEtgAAAAAAAABgQwhtAQAAAAAAAMCGENoCAAAAAAAAgA0htAUAAAAAAAAAG0JoCwAAAAAAAAA2hNAWAAAAAAAAAGwIoS0AAAAAAAAA2BBCWwAAAAAAAACwIYS2AAAAAAAAAGBDCG0BAAAAAAAAwIYQ2gIAAAAAAACADSG0BQAAAAAAAAAbQmgLAAAAAAAAADaE0BYAAAAAAAAAbAihLQAAAAAAAADYEEJbAAAAAAAAALAhhLYAAAAAAAAAYEMIbQEAAAAAAADAhhDaAgAAAAAAAIANscnQdv78+SpTpoycnZ3l7++vw4cPZzh28eLFatKkiQoXLqzChQsrICDgvuMBAAAAAAAAwJbZXGi7du1ahYSEaPz48Tp27Jhq1qypwMBAXblyJd3xe/bs0Ysvvqjdu3frwIED8vHxUZs2bRQZGZnLlQMAAAAAAADAo7O50HbmzJnq27evgoOD5efnp0WLFsnFxUVLly5Nd/zKlSs1cOBA1apVS76+vvq///s/paSkKCIiIpcrBwAAAAAAAIBHZ1OhbVJSko4ePaqAgABzm52dnQICAnTgwIFM7SMhIUF3795VkSJF0u1PTExUXFycxQsAAAAAAAAAbIVNhbbXrl1TcnKyvLy8LNq9vLwUFRWVqX288cYbKlGihEXw+3dhYWFyc3Mzv3x8fB65bgAAAAAAAADILjYV2j6qt99+W2vWrNGGDRvk7Oyc7pjQ0FDFxsaaX5cuXcrlKgEAAAAAAAAgY/msXcDfeXh4yN7eXtHR0Rbt0dHR8vb2vu/c6dOn6+2339bOnTtVo0aNDMc5OTnJyckpW+oFAAAAAAAAgOxmU3faOjo6qm7duhYPEUt9qFjDhg0znPfuu+9q8uTJCg8PV7169XKjVAAAAAAAAADIETZ1p60khYSEqFevXqpXr57q16+v2bNnKz4+XsHBwZKkl19+WSVLllRYWJgk6Z133tG4ceO0atUqlSlTxrz2bcGCBVWwYEGrnQcAAAAAAAAAZIXNhbZdu3bV1atXNW7cOEVFRalWrVoKDw83P5zs4sWLsrP73w3CCxcuVFJSkjp37myxn/Hjx2vChAm5WToAAAAAAAAAPDKbC20lafDgwRo8eHC6fXv27LHYPn/+fM4XBAAAAAAAAAC5xKbWtAUAAAAAAACAvI7QFgAAAAAAAABsCKEtAAAAAAAAANgQQlsAAAAAAAAAsCGEtgAAAAAAAABgQwhtAQAAAAAAAMCGENoCAAAAAAAAgA0htAUAAAAAAAAAG0JoCwAAAAAAAAA2hNAWAAAAAAAAAGwIoS0AAAAAAAAA2BBCWwAAAAAAAACwIYS2AAAAAPAQbt26pSeeeEImk0lHjhy579gFCxbo6aeflqenp0wmk9atW5fh2C1btqhRo0YqUKCAChcurBYtWuj333/P7vIBAMBjgNAWAAAAsIIJEybIZDJZvHx9fa1dFjJh8uTJunfvXqbGfvzxx7p27Zrat29/33ErVqzQc889p+bNm2vz5s1avny56tWrpzt37mRHyQAA4DGTz9oFAAAAAHlV1apVtXPnTvN2vnxcntu6kydPav78+ZoxY4b69+//wPHffvut7OzsdP78eX388cfpjrlx44YGDRqk2bNna8CAAeb2Z555JtvqBgAAjxfutAUAAACsJF++fPL29ja/PDw8rF0SHmDIkCHq37+/KleunKnxdnYP/pXr008/VXJysvr06XPfcd98842aNm0qNzc3FSpUSNWrV9fy5cszVQcAAHi8ENoCAAAAVvLbb7+pRIkSKleunF566SVdvHjxvuMTExMVFxdn8ULuWbdunX766SeNGzcuW/d78OBB+fr6avny5SpdurTy5cunWrVqaevWreYxcXFx6tChg1xdXbV69Wp98cUX6tevn27evJmttQAAANvA568AAAAAK/D399eyZctUuXJlXb58WRMnTlSTJk30888/q1ChQunOCQsL08SJE3O5UkhSQkKCQkJCNG3aNLm6umbrvqOionTq1CmNHTtW7777rooXL6758+frmWee0fHjx1W1alX997//VWxsrMLCwlS9enVJUqtWrbK1DgAAYDu40xYAAACwgnbt2umFF15QjRo1FBgYqK+++v/27j+qqjrf//jrgPL7l4oKJclVArXRUAx/juikQanjr0odb/64VpNesiIdtUyg5o5zb6lkY7W0O9Kdask4ZrNyzFV4Qx2k/BVmqUwagt1A0wLEDEE+3z/8usejqPw+G30+1tprcfb+7P357L3O++w377PP3ptUUlKiP//5z1ddZ+HChSotLbWmY8eONeOIb26//e1v1bFjR82YMaPRt11dXa3y8nKtWrVKU6dO1YgRI7Ru3Tp16tRJ//mf/ylJ6tq1qwICAjRr1iz9+c9/1nfffdfo4wAAAPZB0RYAAACwgaCgIEVGRurw4cNXbePp6amAgACnCU2voKBAS5cuVWpqqkpLS1VSUqLy8nJJUnl5ufV3fbVp00aS9Itf/MKa17p1aw0ZMkRffvml1eajjz6Sv7+/HnroIYWEhGjo0KHav39/g/oGAAD2RNEWAAAAsIHy8nIdOXJEoaGhrh4KLpOfn69z585p5MiRatOmjdq0aaPRo0dLkoYNG6bhw4c3aPt33HHHVZf99NNP1t+xsbH64IMPVFJSovfff18nTpzQ2LFjG9Q3AACwJ4q2AAAAgAvMnTtXW7du1dGjR7Vjxw6NGzdO7u7umjx5squHhstER0fr448/dpqWL18uSXr99df16quvNmj7o0aNkiRlZmZa886dO6etW7cqJibmivbe3t667777NGvWLOXn5zsVdgEAwI2BB5EBAAAALvDNN99o8uTJOnXqlNq3b6/Bgwfrk08+Ufv27V09NFwmKChIQ4cOrXFZTEyM+vTpI+nCg8EKCgqcbnGxe/duHT161LoH7SeffCJJat++veLi4iRJffr00YQJE/Too4/q+++/tx5Edvz4cc2bN0+S9Le//U3//d//rXHjxum2225TcXGxXnnlFQ0aNEheXl5NtesAAMBFKNoCAAAALrB27VpXDwGN7Pz586qqqnKa94c//EFvvvmm9Xrp0qWSpLi4OGVlZVnz33zzTS1cuFALFixQWVmZYmJilJmZqZ49e0qSIiIi5ObmpmeffVYnTpxQu3btdM8992jJkiVNv2MAAKDZUbQFAAAAgDoaOnSojDFO8y4twl6Unp6u9PT0627P19dXK1as0IoVK2pcHhUVpb/85S/1GSoAAGiBuKctAAAAAAAAANgIRVsAAAAAAAAAsBGKtgAAAAAAAABgIxRtAQAAAAAAAMBGKNoCAAAAAAAAgI1QtAUAAAAAAAAAG6FoCwAAAAAAAAA2QtEWAAAAAAAAAGyEoi0AAAAAAAAA2AhFWwAAAAAAAACwkVauHgAAAACAluPM8H6uHgIg38xPXT0EAACaFFfaAgAAAAAAAICNULQFAAAAAAAAABuhaAsAAAAAAAAANkLRFgAAAAAAAABshKItAAAAAAAAANgIRVsAAAAAAAAAsBGKtgAAAAAAAABgIxRtAQAAAAAAAMBGKNoCAAAAAAAAgI1QtAUAAAAAAAAAG6FoCwAAAAAAAAA2QtEWAAAAAAAAAGyEoi0AAAAAAAAA2AhFWwAAAAAAAACwEYq2AAAAAAAAAGAjFG0BAAAAAAAAwEZsV7RduXKlwsPD5eXlpX79+mnnzp1Xbfvll19qwoQJCg8Pl8PhUFpaWvMNFAAAAAAAAACagK2KthkZGUpKSlJycrL27t2rO++8U/Hx8Tpx4kSN7X/88Ud16dJFv//97xUSEtLMowUAAAAAAACAxmerou2yZcv0yCOPaMaMGerRo4def/11+fj46I9//GON7e+66y69+OKLmjRpkjw9PZt5tAAAAAAAAADQ+GxTtD137pz27Nmj4cOHW/Pc3Nw0fPhw5eTkuHBkAAAAAAAAANB8Wrl6ABedPHlS58+fV8eOHZ3md+zYUYcOHWq0fioqKlRRUWG9Lisra7RtAwAAAAAAAEBD2eZK2+ayZMkSBQYGWlNYWJirhwQAAAAAAAAAFtsUbYODg+Xu7q7jx487zT9+/HijPmRs4cKFKi0ttaZjx4412rYBAAAAAAAAoKFsU7T18PBQTEyMtmzZYs2rrq7Wli1bNGDAgEbrx9PTUwEBAU4TAAAAAAAAANiFbe5pK0lJSUmaNm2a+vbtq9jYWKWlpenMmTOaMWOGJGnq1Km69dZbtWTJEkkXHl524MAB6+//+7//U25urvz8/BQREeGy/QAAAAAAAACA+rJV0XbixIn67rvvtHjxYhUXFys6OlqbN2+2Hk5WWFgoN7d/Xhz87bffqnfv3tbrl156SS+99JLi4uKUlZXV3MMHAAAAAAAAgAazVdFWkhITE5WYmFjjsssLseHh4TLGNMOoAAAAAAAAAKB52OaetgAAAAAAAAAAirYAAAAAAAAAYCsUbQEAAAAAAADARijaAgAAAAAAAICNULQFAAAAAAAAABuhaAsAAAAAAAAANkLRFgAAAAAAAABshKItAAAAAAAAANgIRVsAAAAAAAAAsBGKtgAAAAAAAABgIxRtAQAAAAAAAMBGKNoCAAAAAAAAgI1QtAUAAAAAAAAAG6FoCwAAAAAAAAA2QtEWAAAAAAAAAGyEoi0AAAAAAAAA2AhFWwAAAAAAAACwEYq2AAAAAAAAAGAjFG0BAAAAAAAAwEYo2gIAAAAAAACAjVC0BQAAAAAAAAAboWgLAAAAAAAAADZC0RYAAAAAAAAAbISiLQAAAAAAAADYCEVbAAAAAAAAALARirYAAAAAAAAAYCMUbQEAAAAAAADARijaAgAAAAAAAICNULQFAAAAAAAAABuhaAsAAAAAAAAANkLRFgAAAAAAAABshKItAAAAAAAAANgIRVsAAAAAAAAAsBGKtgAAAAAAAABgIxRtAQAAAAAAAMBGKNoCAAAAAAAAgI1QtAUAAAAAAAAAG6FoCwAAAAAAAAA2QtEWAAAAAAAAAGyEoi0AAAAAAAAA2AhFWwAAAAAAAACwEYq2AAAAAAAAAGAjFG0BAAAAAAAAwEYo2gIAAAAAAACAjVC0BQAAAAAAAAAboWgLAAAAAAAAADZC0RYAAAAAAAAAbISiLQAAAAAAAADYCEVbAAAAAAAAALARirYAAAAAAAAAYCMUbQEAAAAAAADARijaAgAAAAAAAICNULQFAAAAAAAAABuxZdF25cqVCg8Pl5eXl/r166edO3des/26devUrVs3eXl5qWfPntq0aVMzjRQAAABomLrmvgAAALjx2a5om5GRoaSkJCUnJ2vv3r268847FR8frxMnTtTYfseOHZo8ebJmzpypzz77TGPHjtXYsWP1xRdfNPPIAQAAgLqpa+4LAACAm4PtirbLli3TI488ohkzZqhHjx56/fXX5ePjoz/+8Y81tn/55ZeVkJCgefPmqXv37nrhhRfUp08f/eEPf2jmkQMAAAB1U9fcFwAAADeHVq4ewKXOnTunPXv2aOHChdY8Nzc3DR8+XDk5OTWuk5OTo6SkJKd58fHxeu+992psX1FRoYqKCut1aWmpJKmsrKyBo6+bM1Xnm7U/oCbnm/l9X1eVP1a6egiApOY/R9RV9dlyVw8BUFlZdTP3dyEujTHN2m9jqk/ua4dcljwWdmD3PFYil4U9kMcCtdOcuWxt81hbFW1Pnjyp8+fPq2PHjk7zO3bsqEOHDtW4TnFxcY3ti4uLa2y/ZMkSpaamXjE/LCysnqMGWrDAQFePAGgRAkWsANcT+LRr+j19+rQCW+j5rD65L7ks8P+10LgHmht5LFA7rshlr5fH2qpo2xwWLlzodGVudXW1vv/+e7Vr104Oh8OFI0NdlJWVKSwsTMeOHVNAQICrhwPYEnEC1A6x0jIZY3T69Gndcsstrh5KsyKXbfn4zAFqh1gBaodYaXlqm8faqmgbHBwsd3d3HT9+3Gn+8ePHFRISUuM6ISEhdWrv6ekpT09Pp3lBQUH1HzRcKiAggA8l4DqIE6B2iJWWp6VeYXtRfXJfctkbB585QO0QK0DtECstS23yWFs9iMzDw0MxMTHasmWLNa+6ulpbtmzRgAEDalxnwIABTu0l6aOPPrpqewAAAMAO6pP7AgAA4OZgqyttJSkpKUnTpk1T3759FRsbq7S0NJ05c0YzZsyQJE2dOlW33nqrlixZIkl64oknFBcXp6VLl2rkyJFau3atdu/erVWrVrlyNwAAAIDrul7uCwAAgJuT7Yq2EydO1HfffafFixeruLhY0dHR2rx5s/WAhsLCQrm5/fMC4YEDB+qdd97RokWL9Mwzz+j222/Xe++9p5/97Geu2gU0A09PTyUnJ1/x80AA/0ScALVDrMCVrpf74sbDZw5QO8QKUDvEyo3LYYwxrh4EAAAAAAAAAOACW93TFgAAAAAAAABudhRtAQAAAAAAAMBGKNoCAAAAAAAAgI1QtAUAAE0uPDxcaWlp9V4/PT1dQUFBjTaeG0lDjy0AAACujjy26ZDHXhtFWzSq6dOny+FwXDEdPny43tvMysqSw+FQSUmJNa+mPi6dUlJS6t3f0aNH5XA4lJubW+9tANdDrMBOpk+frrFjxzZpH7t27dKjjz5aq7Y1JW8TJ07UP/7xj3r3n56ebr3v3dzcFBoaqokTJ6qwsLDe27SLuhxbAFfHuRmoHWIFdkIe27KRx15bK1cPADeehIQErVmzxmle+/btG7WPoqIi6++MjAwtXrxYeXl51jw/P79G7Q9oCsQKbiYNfW97e3vL29u7QdsICAhQXl6ejDHKz8/X7Nmz9cADD+jTTz9t0Havp7KyUq1bt26y7Tf25wZwM+PcDNQOsYKbCXkseayrcKUtGp2np6dCQkKcppdfflk9e/aUr6+vwsLCNHv2bJWXl1vrFBQUaPTo0WrTpo18fX11xx13aNOmTTp69KiGDRsmSWrTpo0cDoemT5/utO3AwEA5HA6neWvXrlX37t3l5eWlbt266dVXX7X6+rd/+zf16tVLFRUVkqRz586pd+/emjp1qiTpX/7lXyRJvXv3lsPh0NChQ5vpyOFmQ6ygpdi6datiY2Pl6emp0NBQLViwQFVVVdby06dPa8qUKfL19VVoaKiWL1+uoUOH6sknn7TaXHrVgTFGKSkpuu222+Tp6albbrlFc+bMkSQNHTpUBQUFeuqpp6wrCqSaf1b2/vvv66677pKXl5eCg4M1bty4a+7Hxfd/aGioBg4cqJkzZ2rnzp0qKyuz2vz1r39Vnz595OXlpS5duig1NdVpXw8dOqTBgwfLy8tLPXr0UGZmphwOh9577z1J/7xyJyMjQ3FxcfLy8tLbb78tSXrjjTeuGm/nzp1TYmKiQkND5eXlpc6dO2vJkiXXPV6XH1tJKiws1JgxY+Tn56eAgAA9+OCDOn78uLU8JSVF0dHR+tOf/qTw8HAFBgZq0qRJOn369DWPH3Az4NwM1A6xgpaCPJY8tkUzQCOaNm2aGTNmzBXzly9fbv73f//X5Ofnmy1btpioqCgza9Ysa/nIkSPNiBEjzOeff26OHDli3n//fbN161ZTVVVl1q9fbySZvLw8U1RUZEpKSpy2vWbNGhMYGGi9fuutt0xoaKhZv369+frrr8369etN27ZtTXp6ujHGmNOnT5suXbqYJ5980hhjzNy5c014eLgpLS01xhizc+dOI8lkZmaaoqIic+rUqUY+SgCxAnu52vvRGGO++eYb4+PjY2bPnm0OHjxoNmzYYIKDg01ycrLV5uGHHzadO3c2mZmZZv/+/WbcuHHG39/fPPHEE1abzp07m+XLlxtjjFm3bp0JCAgwmzZtMgUFBebTTz81q1atMsYYc+rUKdOpUyfz/PPPm6KiIlNUVGSMufL9u3HjRuPu7m4WL15sDhw4YHJzc83vfve7q+7j5esfP37cDBs2zLi7u5vy8nJjjDHbtm0zAQEBJj093Rw5csR8+OGHJjw83KSkpBhjjKmqqjJRUVFmxIgRJjc312zfvt3ExsYaSWbDhg3GGGPy8/ONJBMeHm7F1rfffnvdeHvxxRdNWFiY2bZtmzl69KjZvn27eeedd657vC4/tufPnzfR0dFm8ODBZvfu3eaTTz4xMTExJi4uzmqfnJxs/Pz8zPjx483+/fvNtm3bTEhIiHnmmWeuevyAmwHnZqB2iBXYCXkseeyNnMdStEWjmjZtmnF3dze+vr7WdP/991/Rbt26daZdu3bW6549e1ofJpf7+OOPjSTzww8/1Lj88g+wrl27Wh8QF73wwgtmwIAB1usdO3aY1q1bm+eee860atXKbN++3Vp28YPqs88+q8UeA/VDrMBOrpXsPvPMMyYqKspUV1db81auXGn8/PzM+fPnTVlZmWndurVZt26dtbykpMT4+PhcNdldunSpiYyMNOfOnauxz0vbXnT5+3fAgAFmypQptd7HNWvWGEnG19fX+Pj4GElGkpkzZ47V5u67774iYf7Tn/5kQkNDjTHGfPDBB6ZVq1ZWAm6MMR999FGNyW5aWprTdq4Xb48//rj5xS9+4XScL6rL8frwww+Nu7u7KSwstJZ/+eWXRpLZuXOnMeZCsuvj42PKysqsNvPmzTP9+vWrcfvAzYJzM1A7xArshDz2AvLYGzOP5Z62aHTDhg3Ta6+9Zr329fVVZmamlixZokOHDqmsrExVVVX66aef9OOPP8rHx0dz5szRrFmz9OGHH2r48OGaMGGCevXqVee+z5w5oyNHjmjmzJl65JFHrPlVVVUKDAy0Xg8YMEBz587VCy+8oPnz52vw4MEN22mgHogVtAQHDx7UgAEDrJ93SdKgQYNUXl6ub775Rj/88IMqKysVGxtrLQ8MDFRUVNRVt/nAAw8oLS1NXbp0UUJCgu677z6NHj1arVrVPi3Jzc11eu/Whr+/v/bu3avKykp98MEHevvtt/Uf//Ef1vJ9+/YpOzvbad758+etGMzLy1NYWJhCQkKs5Zfu96X69u1r/V2beJs+fbpGjBihqKgoJSQkaNSoUbrnnnsk1e14HTx4UGFhYQoLC7Pm9ejRQ0FBQTp48KDuuusuSRd+iubv72+1CQ0N1YkTJ2p3IIEbGOdmoHaIFbQE5LHksS0d97RFo/P19VVERIQ1VVRUaNSoUerVq5fWr1+vPXv2aOXKlZIu3PtEkh5++GF9/fXXeuihh7R//3717dtXr7zySp37vnjPpNWrVys3N9eavvjiC33yySdWu+rqamVnZ8vd3b1BTzkFGoJYwc0qLCxMeXl5evXVV+Xt7a3Zs2dryJAhqqysrPU26vMwBzc3N0VERKh79+5KSkpS//79NWvWLGt5eXm5UlNTnWJi//79+uqrr+Tl5VWnvnx9fZ22K1073vr06aP8/Hy98MILOnv2rB588EHdf//9khrneF3u8gdKOBwOVVdX13t7wI2CczNQO8QKblbkseSxzYmiLZrcnj17VF1draVLl6p///6KjIzUt99+e0W7sLAwPfbYY3r33Xf19NNPa/Xq1ZIkDw8PSRe+Jbqejh076pZbbtHXX3/tlERERERYN5uXpBdffFGHDh3S1q1btXnzZqcnn9alP6AxESuwo+7duysnJ0fGGGtedna2/P391alTJ3Xp0kWtW7fWrl27rOWlpaX6xz/+cc3tent7a/To0VqxYoWysrKUk5Oj/fv3S7rw3rre+6pXr17asmVLA/ZMWrBggTIyMrR3715JFxLOvLy8K2IiIiJCbm5uioqK0rFjx5wehnDpfl9NbeMtICBAEydO1OrVq5WRkaH169fr+++/l3Tt43Wp7t2769ixYzp27Jg178CBAyopKVGPHj3qfayAmxXnZqB2iBXYEXkseWxLx+0R0OQiIiJUWVmpV155RaNHj1Z2drZef/11pzZPPvmk7r33XkVGRuqHH37Qxx9/rO7du0uSOnfuLIfDoY0bN+q+++6Tt7e3/Pz8rtpfamqq5syZo8DAQCUkJKiiokK7d+/WDz/8oKSkJH322WdavHix/vKXv2jQoEFatmyZnnjiCcXFxalLly7q0KGDvL29tXnzZnXq1EleXl5OP7MBmgqxAlcqLS1Vbm6u07x27dpp9uzZSktL0+OPP67ExETl5eUpOTlZSUlJcnNzk7+/v6ZNm6Z58+apbdu26tChg5KTk+Xm5ub0U7RLpaen6/z58+rXr598fHz01ltvydvbW507d5Z04SdP27Zt06RJk+Tp6ang4OArtpGcnKy7775bXbt21aRJk1RVVaVNmzZp/vz5td7nsLAwjRs3TosXL9bGjRu1ePFijRo1Srfddpvuv/9+ubm5ad++ffriiy/029/+ViNGjFDXrl01bdo0/dd//ZdOnz6tRYsWSdJV9/Wi68XbsmXLFBoaqt69e8vNzU3r1q1TSEiIgoKCrnu8LjV8+HD17NlTU6ZMUVpamqqqqjR79mzFxcU5/dQNQO1wbgZqh1iBK5HHksfesFx9U13cWK52E/Bly5aZ0NBQ4+3tbeLj483//M//ON1oPjEx0XTt2tV4enqa9u3bm4ceesicPHnSWv/55583ISEhxuFwmGnTpjlt+/KbehtjzNtvv22io6ONh4eHadOmjRkyZIh59913zdmzZ02PHj3Mo48+6tT+l7/8pRk4cKCpqqoyxhizevVqExYWZtzc3JyeVAg0FmIFdjJt2jTrgQaXTjNnzjTGGJOVlWXuuusu4+HhYUJCQsz8+fNNZWWltX5ZWZn51a9+ZXx8fExISIhZtmyZiY2NNQsWLLDaXPqQgQ0bNph+/fqZgIAA4+vra/r3728yMzOttjk5OaZXr17G09PTXExVanr/rl+/3nr/BgcHm/Hjx191H2ta/2Jfksynn35qjDFm8+bNZuDAgcbb29sEBASY2NhYpyfcHjx40AwaNMh4eHiYbt26mffff99IMps3bzbGXPvBJleLN2OMWbVqlYmOjja+vr4mICDA3H333Wbv3r21Ol6XP/CioKDA/PKXvzS+vr7G39/fPPDAA6a4uNhanpycbO68806nsS1fvtx07tz5qscPuBlwbgZqh1iBnZDHksfeyHmsw5hLrhMHAABooDNnzujWW2/V0qVLNXPmTFcPp0llZ2dr8ODBOnz4sLp27erq4QAAAKAByGNhJ9weAQAANMhnn32mQ4cOKTY2VqWlpXr++eclSWPGjHHxyBrfhg0b5Ofnp9tvv12HDx/WE088oUGDBpHoAgAAtEDkseSxdkbRFgAANNhLL72kvLw8eXh4KCYmRtu3b6/xHl4t3enTpzV//nwVFhYqODhYw4cP19KlS109LAAAANQTeSzsitsjAAAAAAAAAICNuLl6AAAAAAAAAACAf6JoixtKeHi40tLSrNcOh0Pvvfeey8YDAAAA1AZ5LAAAuBRFWzSa6dOny+FwWFO7du2UkJCgzz//3GVjKioq0r333uuy/oHG0tTxlZKSoujo6EbZFuBKl8ZJTVNKSoqOHj1a47J//dd/vep2s7Ky5HA4VFJS4vTa4XDIzc1NgYGB6t27t37zm9+oqKjIad2UlJQa+8vMzGzKQwGgDshjgaZFLgtcH3ksLkfRFo0qISFBRUVFKioq0pYtW9SqVSuNGjXKZeMJCQmRp6eny/oHGpPd4gtoLkOHDlV6enqt2l6MkaKiIqWlpSkgIMBp3ty5c622mZmZTstWrlxZ57Hl5eXp22+/1a5duzR//nxlZmbqZz/7mfbv3+/U7o477nDqq6ioSEOGDKlzfwCajt3Os+SxuNHYLcaA5kAei4agaItG5enpqZCQEIWEhCg6OloLFizQsWPH9N1330mS5s+fr8jISPn4+KhLly567rnnVFlZaa2/b98+DRs2TP7+/goICFBMTIx2795tLf/73/+un//85/L29lZYWJjmzJmjM2fOXHU8l/6s7OI3Uu+++66GDRsmHx8f3XnnncrJyXFap659AM3levF17NgxPfjggwoKClLbtm01ZswYHT161Fo/KytLsbGx8vX1VVBQkAYNGqSCggKlp6crNTVV+/bts745rW1iAdjNxRgJCQlRYGCgHA6H0zw/Pz+rbbt27a5oX1cdOnRQSEiIIiMjNWnSJGVnZ6t9+/aaNWuWU7tWrVo59RUSEiIPD48G7y+AxkMeCzQtclng2shjcTmKtmgy5eXleuuttxQREaF27dpJkvz9/ZWenq4DBw7o5Zdf1urVq7V8+XJrnSlTpqhTp07atWuX9uzZowULFqh169aSpCNHjighIUETJkzQ559/royMDP39739XYmJincb17LPPau7cucrNzVVkZKQmT56sqqqqRu0DaGqXx1dlZaXi4+Pl7++v7du3Kzs7W35+fkpISNC5c+dUVVWlsWPHKi4uTp9//rlycnL06KOPyuFwaOLEiXr66aedvkGdOHGiq3cRaJG8vb312GOPKTs7WydOnHD1cADUE3ks0LTIZQH7IY+1n1auHgBuLBs3brS+/Tlz5oxCQ0O1ceNGubld+H5g0aJFVtvw8HDNnTtXa9eu1W9+8xtJUmFhoebNm6du3bpJkm6//Xar/ZIlSzRlyhQ9+eST1rIVK1YoLi5Or732mry8vGo1xrlz52rkyJGSpNTUVN1xxx06fPiwunXr1mh9AE3hWvH1zjvvqLq6Wm+88YYcDockac2aNQoKClJWVpb69u2r0tJSjRo1Sl27dpUkde/e3dq2n5+f9Q0qcLMYOHCgdX6SpO3bt6t3794N3u7Fc9jRo0fVoUMHSdL+/fudro7o0aOHdu7c2eC+ADQe8ligaZHLAo2HPPbmwJW2aFTDhg1Tbm6ucnNztXPnTsXHx+vee+9VQUGBJCkjI0ODBg2yLu1ftGiRCgsLrfWTkpL08MMPa/jw4fr973+vI0eOWMv27dun9PR0+fn5WVN8fLyqq6uVn59f6zH26tXL+js0NFSSrG+RGqsPoClcK7727dunw4cPy9/f33rvtm3bVj/99JOOHDmitm3bavr06YqPj9fo0aP18ssvX3GTecAufve73zl9Dm/fvl2PPfaY07xLzx31lZGRYcVUbm6uevToIenCfbsu9lOfhwAZYyTJ+qdTkqKiopz6Wr9+fYPHD6BxkccCTYtcFjcD8lg0Jq60RaPy9fVVRESE9fqNN95QYGCgVq9erZEjR2rKlClKTU1VfHy8AgMDtXbtWi1dutRqn5KSol/96lf629/+pg8++EDJyclau3atxo0bp/Lycv3617/WnDlzruj3tttuq/UYL/5MTfrnB1F1dbUkNVofQFO4VnyVl5crJiZGb7/99hXrtW/fXtKFqxXmzJmjzZs3KyMjQ4sWLdJHH32k/v37N9s+ALXx2GOP6cEHH7ReT5kyRRMmTND48eOtebfcckuD+wkLC3OKqYs2bdpk3afS29u7zts9ePCgpAtX4l3k4eFRY18A7IM8Fmha5LK4GZDHojFRtEWTcjgccnNz09mzZ7Vjxw517txZzz77rLX84pULl4qMjFRkZKSeeuopTZ48WWvWrNG4cePUp08fHThwoEk/LJqjD6CxXBpfffr0UUZGhjp06KCAgICrrtO7d2/17t1bCxcu1IABA/TOO++of//+8vDw0Pnz55tx9MDVtW3bVm3btrVee3t7q0OHDs322dy5c+d6r3v27FmtWrVKQ4YMsf7JBNAykccCTYtcFjci8lg0Jm6PgEZVUVGh4uJiFRcX6+DBg3r88cdVXl6u0aNH6/bbb1dhYaHWrl2rI0eOaMWKFdqwYYO17tmzZ5WYmKisrCwVFBQoOztbu3btsu5VNH/+fO3YsUOJiYnKzc3VV199pb/+9a+N+nCF5ugDqK9rxdeUKVMUHBysMWPGaPv27crPz1dWVpbmzJmjb775Rvn5+Vq4cKFycnJUUFCgDz/8UF999ZUVX+Hh4crPz1dubq5OnjypiooKF+8t0DKcOHFCxcXF+uqrr7R27VoNGjRIJ0+e1GuvvebqoQGoI/JYoGmRywL2Qh5rf1xpi0a1efNm6/5a/v7+6tatm9atW6ehQ4dKkp566iklJiaqoqJCI0eO1HPPPaeUlBRJkru7u06dOqWpU6fq+PHjCg4O1vjx45Wamirpwj28tm7dqmeffVY///nPZYxR165dG/XJoM3RB1Bf14uvbdu2af78+Ro/frxOnz6tW2+9VXfffbcCAgJ09uxZHTp0SG+++aZOnTql0NBQ/fu//7t+/etfS5ImTJigd999V8OGDVNJSYnWrFmj6dOnu2hPgZYjKipKDodDfn5+6tKli+655x4lJSXxIBSgBSKPBZoWuSxgL+Sx9ucwF+8yDAAAAAAAAABwOW6PAAAAAAAAAAA2QtEWAAAAAAAAAGyEoi0AAAAAAAAA2AhFWwAAAAAAAACwEYq2AAAAAAAAAGAjFG0BAAAAAAAAwEYo2gIAAAAAAACAjVC0BQAAAAAAAAAboWgLAAAAAAAAADZC0RYAAAAAAAAAbISiLQAAAAAAAADYCEVbAAAAAAAAALCR/wctTcpVq/E6owAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparison plot saved to /home/user/model_comparison.png\n" + ] + } + ], + "source": [ + "# Compare FastText vs Logistic Regression across F1 score and training time\n", + "model_names = ['FastText\\nBaseline', 'FastText\\nBest', 'Logistic Regression\\n+ TF-IDF']\n", + "f1_scores = [0.3189, best_results['f1'], lr_f1]\n", + "train_times = [train_time, best_train_time, lr_time]\n", + "\n", + "plot_model_comparison(\n", + " model_names,\n", + " f1_scores,\n", + " train_times,\n", + " save_path='/home/user/model_comparison.png'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f7474f31-02e6-4f44-9cd5-0e1f3c921079", + "metadata": {}, + "source": [ + "## Summary and Conclusions\n", + "\n", + "Key Findings\n", + "\n", + "1. FastText achieved 62% F1 on the 20 Newsgroups dataset, a challenging \n", + " 20-class classification problem where random chance would yield only 5%.\n", + "\n", + "2. Hyperparameter tuning doubled performance from 31% (baseline) to 62% \n", + " (best), demonstrating the importance of proper configuration.\n", + "\n", + "3. Most common confusions occur between semantically similar categories \n", + " such as talk.politics.misc → talk.politics.guns and \n", + " rec.motorcycles → rec.autos, which is expected behavior.\n", + "\n", + "4. Logistic Regression + TF-IDF slightly outperforms FastText (65% vs 62%) \n", + " on this small dataset. However, FastText trains 2.5x faster and scales \n", + " significantly better to large datasets with millions of samples.\n", + "\n", + "5. FastText is best suited for large-scale text classification where \n", + " training speed and memory efficiency are critical requirements." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/fasttext_utils.py b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/fasttext_utils.py new file mode 100644 index 000000000..194d27f61 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/fasttext_utils.py @@ -0,0 +1,213 @@ +""" +fasttext_utils.py + +Utility functions for FastText text classification project. +Provides reusable functions for data preprocessing, model training, +evaluation, and visualization. +""" +import re +import time +import fasttext +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns +from sklearn.metrics import classification_report, confusion_matrix + + +def clean_text(text): + """ + Clean and normalize text for FastText training. + + Removes special characters, converts to lowercase, and strips + extra whitespace to produce consistent input for the model. + + Args: + text (str): Raw input text. + + Returns: + str: Cleaned and normalized text. + """ + text = re.sub(r'[^a-zA-Z\s]', ' ', text) + text = text.lower() + text = re.sub(r'\s+', ' ', text).strip() + return text + + +def prepare_fasttext_data(data, filename): + """ + Convert sklearn dataset to FastText supervised format and save to file. + + FastText expects one sample per line in the format: + __label__ + + Args: + data: sklearn Bunch object with .data and .target attributes. + filename (str): Output file path. + """ + with open(filename, 'w', encoding='utf-8') as f: + for text, label in zip(data.data, data.target): + clean = clean_text(text) + category = data.target_names[label].replace(' ', '_') + f.write(f"__label__{category} {clean}\n") + print(f"Saved {len(data.data)} samples to {filename}") + + +def train_fasttext_model(train_path, epoch=25, lr=0.5, word_ngrams=2, min_count=1, verbose=0): + """ + Train a supervised FastText classification model. + + Args: + train_path (str): Path to FastText-formatted training file. + epoch (int): Number of training epochs. + lr (float): Learning rate. + word_ngrams (int): Maximum word n-gram size. + min_count (int): Minimum word frequency threshold. + verbose (int): Verbosity level. + + Returns: + tuple: (model, training_time_seconds) + """ + start = time.time() + model = fasttext.train_supervised( + input=train_path, + epoch=epoch, + lr=lr, + wordNgrams=word_ngrams, + minCount=min_count, + verbose=verbose + ) + elapsed = time.time() - start + return model, elapsed + + +def evaluate_model(model, test_path): + """ + Evaluate a FastText model and return precision, recall, and F1. + + Args: + model: Trained FastText model. + test_path (str): Path to FastText-formatted test file. + + Returns: + dict: Dictionary with precision, recall, and f1 scores. + """ + results = model.test(test_path) + f1 = 2 * results[1] * results[2] / (results[1] + results[2]) + return { + "samples": results[0], + "precision": round(results[1], 4), + "recall": round(results[2], 4), + "f1": round(f1, 4) + } + + +def get_predictions(model, texts, clean_fn): + """ + Generate predicted labels for a list of texts. + + Args: + model: Trained FastText model. + texts (list): List of raw text strings. + clean_fn (callable): Text cleaning function. + + Returns: + list: Predicted category labels. + """ + predicted = [] + for text in texts: + clean = clean_fn(text) + labels, _ = model.predict(clean) + label = labels[0].replace('__label__', '').replace('_', '.') + predicted.append(label) + return predicted + + +def plot_confusion_matrix(true_labels, predicted_labels, category_names, title, save_path, cmap='Blues'): + """ + Plot and save a confusion matrix heatmap. + + Args: + true_labels (list): Ground truth labels. + predicted_labels (list): Model predicted labels. + category_names (list): List of category names. + title (str): Plot title. + save_path (str): File path to save the figure. + cmap (str): Colormap for the heatmap. + """ + cm = confusion_matrix(true_labels, predicted_labels, labels=category_names) + plt.figure(figsize=(16, 14)) + sns.heatmap(cm, annot=True, fmt='d', cmap=cmap, + xticklabels=category_names, + yticklabels=category_names) + plt.title(title, fontsize=14) + plt.ylabel('True Label', fontsize=12) + plt.xlabel('Predicted Label', fontsize=12) + plt.xticks(rotation=45, ha='right') + plt.yticks(rotation=0) + plt.tight_layout() + plt.savefig(save_path, dpi=150, bbox_inches='tight') + plt.show() + print(f"Confusion matrix saved to {save_path}") + + +def plot_tuning_results(results_list, save_path): + """ + Plot hyperparameter tuning results as a bar chart. + + Args: + results_list (list): List of dicts with tuning results. + save_path (str): File path to save the figure. + """ + labels = [f"e={r['epoch']},lr={r['lr']},ng={r['wordNgrams']}" for r in results_list] + f1_scores = [r['f1'] for r in results_list] + colors = ['#F44336', '#2196F3', '#4CAF50', '#FF9800', '#9C27B0'] + + plt.figure(figsize=(12, 6)) + bars = plt.bar(labels, f1_scores, color=colors[:len(labels)]) + plt.title('FastText Hyperparameter Tuning Results', fontsize=14) + plt.xlabel('Configuration', fontsize=12) + plt.ylabel('F1 Score', fontsize=12) + plt.ylim(0, 0.8) + for bar, score in zip(bars, f1_scores): + plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01, + f'{score:.4f}', ha='center', fontsize=10) + plt.xticks(rotation=20, ha='right') + plt.tight_layout() + plt.savefig(save_path, dpi=150, bbox_inches='tight') + plt.show() + print(f"Tuning plot saved to {save_path}") + + +def plot_model_comparison(model_names, f1_scores, train_times, save_path): + """ + Plot F1 score and training time comparison across models. + + Args: + model_names (list): List of model name strings. + f1_scores (list): F1 scores for each model. + train_times (list): Training times in seconds for each model. + save_path (str): File path to save the figure. + """ + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6)) + colors = ['#F44336', '#4CAF50', '#2196F3'] + + bars1 = ax1.bar(model_names, f1_scores, color=colors[:len(model_names)]) + ax1.set_title('F1 Score Comparison', fontsize=14) + ax1.set_ylabel('F1 Score', fontsize=12) + ax1.set_ylim(0, 0.8) + for bar, score in zip(bars1, f1_scores): + ax1.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01, + f'{score:.4f}', ha='center', fontsize=11) + + bars2 = ax2.bar(model_names[:len(train_times)], train_times, color=colors[:len(train_times)]) + ax2.set_title('Training Time Comparison (seconds)', fontsize=14) + ax2.set_ylabel('Time (seconds)', fontsize=12) + for bar, t in zip(bars2, train_times): + ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.5, + f'{t:.2f}s', ha='center', fontsize=11) + + plt.tight_layout() + plt.savefig(save_path, dpi=150, bbox_inches='tight') + plt.show() + print(f"Comparison plot saved to {save_path}") \ No newline at end of file diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/hyperparameter_tuning.png b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/hyperparameter_tuning.png new file mode 100644 index 000000000..52ecc689c Binary files /dev/null and b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/hyperparameter_tuning.png differ diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/model_comparison.png b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/model_comparison.png new file mode 100644 index 000000000..9e88dac75 Binary files /dev/null and b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/model_comparison.png differ diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/requirements.txt b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/requirements.txt new file mode 100644 index 000000000..e61087618 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/requirements.txt @@ -0,0 +1,6 @@ +fasttext-wheel +matplotlib +numpy<2.0 +pandas +scikit-learn +seaborn \ No newline at end of file diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/run_jupyter.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/run_jupyter.sh new file mode 100644 index 000000000..d725c3fe7 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/run_jupyter.sh @@ -0,0 +1,35 @@ +#!/bin/bash +# """ +# Launch Jupyter Lab server. +# +# This script starts Jupyter Lab on port 8888 with the following configuration: +# - No browser auto-launch (useful for Docker containers) +# - Accessible from any IP address (0.0.0.0) +# - Root user allowed (required for Docker environments) +# - No authentication token or password (for development convenience) +# - Vim keybindings can be enabled via JUPYTER_USE_VIM environment variable +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Print each command to stdout before executing it. +#set -x + +# Import the utility functions from /git_root. +GIT_ROOT=/git_root +source $GIT_ROOT/class_project/project_template/utils.sh + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Setup Jupyter Lab environment. +setup_jupyter_environment + +# Initialize Jupyter Lab command with base configuration. +JUPYTER_ARGS=$(get_jupyter_args) + +# Start Jupyter Lab with development-friendly settings. +run "jupyter lab $JUPYTER_ARGS" diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.API.ipynb b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.API.ipynb new file mode 100644 index 000000000..3afca937c --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.API.ipynb @@ -0,0 +1,215 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "183c2248-ea3d-43ba-b87e-d821bba1bbc6", + "metadata": {}, + "source": [ + "# Template API Notebook\n", + "\n", + "This is a template notebook. The first heading should be the title of what notebook is about. For example, if it is a neo4j tutorial the heading should be `Neo4j API`.\n", + "\n", + "- Add description of what the notebook does.\n", + "- Point to references, e.g. (neo4j.API.md)\n", + "- Add citations.\n", + "- Keep the notebook flow clear.\n", + "- Comments should be imperative and have a period at the end.\n", + "- Your code should be well commented.\n", + "\n", + "The name of this notebook should in the following format:\n", + "- if the notebook is exploring `pycaret API`, then it is `pycaret.API.ipynb`\n", + "\n", + "Follow the reference to write notebooks in a clear manner: https://github.com/causify-ai/helpers/blob/master/docs/coding/all.jupyter_notebook.how_to_guide.md" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "265e0d58-a7cd-4edf-a0b4-96b60220e801", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "d3b2f997-5c9b-4238-b6d5-e5f2cea43809", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d1480ee9-d6a6-437d-b927-da6cbb05bdf5", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "# Import libraries in this section.\n", + "# Avoid imports like import *, from ... import ..., from ... import *, etc.\n", + "\n", + "import helpers.hdbg as hdbg\n", + "import helpers.hnotebook as hnotebo" + ] + }, + { + "cell_type": "markdown", + "id": "f9208cc9-837d-4fec-a312-9c4aa5b7648d", + "metadata": {}, + "source": [ + "## Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9a2d7a9c-c6c5-48c9-8445-11c97045d00b", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0mWARNING: Running in Jupyter\n", + "INFO > cmd='/venv/lib/python3.12/site-packages/ipykernel_launcher.py -f /home/.local/share/jupyter/runtime/kernel-085a2ce7-6161-4c8a-92d5-492051832f3c.json'\n" + ] + } + ], + "source": [ + "hdbg.init_logger(verbosity=logging.INFO)\n", + "\n", + "_LOG = logging.getLogger(__name__)\n", + "\n", + "hnotebo.config_notebook()" + ] + }, + { + "cell_type": "markdown", + "id": "79c37ba3-bd5d-4a44-87df-645eee54977a", + "metadata": { + "lines_to_next_cell": 2 + }, + "source": [ + "## Make the notebook flow clear\n", + "Each notebook needs to follow a clear and logical flow, e.g:\n", + "- Load data\n", + "- Compute stats\n", + "- Clean data\n", + "- Compute stats\n", + "- Do analysis\n", + "- Show results\n", + "\n", + "\n", + "\n", + "\n", + "#############################################################################\n", + "Template\n", + "#############################################################################" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a8a109cd-fc8e-4b9e-9dc0-4fc8d4126ad8", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "class Template:\n", + " \"\"\"\n", + " Brief imperative description of what the class does in one line, if needed.\n", + " \"\"\"\n", + "\n", + " def __init__(self):\n", + " pass\n", + "\n", + " def method1(self, arg1: int) -> None:\n", + " \"\"\"\n", + " Brief imperative description of what the method does in one line.\n", + "\n", + " You can elaborate more in the method docstring in this section, for e.g. explaining\n", + " the formula/algorithm. Every method/function should have a docstring, typehints and include the\n", + " parameters and return as follows:\n", + "\n", + " :param arg1: description of arg1\n", + " :return: description of return\n", + " \"\"\"\n", + " # Code bloks go here.\n", + " # Make sure to include comments to explain what the code is doing.\n", + " # No empty lines between code blocks.\n", + " pass\n", + "\n", + "\n", + "def template_function(arg1: int) -> None:\n", + " \"\"\"\n", + " Brief imperative description of what the function does in one line.\n", + "\n", + " You can elaborate more in the function docstring in this section, for e.g. explaining\n", + " the formula/algorithm. Every function should have a docstring, typehints and include the\n", + " parameters and return as follows:\n", + "\n", + " :param arg1: description of arg1\n", + " :return: description of return\n", + " \"\"\"\n", + " # Code bloks go here.\n", + " # Make sure to include comments to explain what the code is doing.\n", + " # No empty lines between code blocks.\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "id": "00926523-ae59-497d-bba8-b22e58333849", + "metadata": {}, + "source": [ + "## The flow should be highlighted using headings in markdown\n", + "```\n", + "# Level 1\n", + "## Level 2\n", + "### Level 3\n", + "```" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py:percent" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.API.py b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.API.py new file mode 100644 index 000000000..4192ef8fe --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.API.py @@ -0,0 +1,129 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.19.0 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# %% [markdown] +# # Template API Notebook +# +# This is a template notebook. The first heading should be the title of what notebook is about. For example, if it is a neo4j tutorial the heading should be `Neo4j API`. +# +# - Add description of what the notebook does. +# - Point to references, e.g. (neo4j.API.md) +# - Add citations. +# - Keep the notebook flow clear. +# - Comments should be imperative and have a period at the end. +# - Your code should be well commented. +# +# The name of this notebook should in the following format: +# - if the notebook is exploring `pycaret API`, then it is `pycaret.API.ipynb` +# +# Follow the reference to write notebooks in a clear manner: https://github.com/causify-ai/helpers/blob/master/docs/coding/all.jupyter_notebook.how_to_guide.md + +# %% +# %load_ext autoreload +# %autoreload 2 +# %matplotlib inline + +# %% [markdown] +# ## Imports + +# %% +import logging +# Import libraries in this section. +# Avoid imports like import *, from ... import ..., from ... import *, etc. + +import helpers.hdbg as hdbg +import helpers.hnotebook as hnotebo + +# %% [markdown] +# ## Configuration + +# %% +hdbg.init_logger(verbosity=logging.INFO) + +_LOG = logging.getLogger(__name__) + +hnotebo.config_notebook() + + +# %% [markdown] +# ## Make the notebook flow clear +# Each notebook needs to follow a clear and logical flow, e.g: +# - Load data +# - Compute stats +# - Clean data +# - Compute stats +# - Do analysis +# - Show results +# +# +# +# + + +# ############################################################################# +# Template +# ############################################################################# + + +# %% +class Template: + """ + Brief imperative description of what the class does in one line, if needed. + """ + + def __init__(self): + pass + + def method1(self, arg1: int) -> None: + """ + Brief imperative description of what the method does in one line. + + You can elaborate more in the method docstring in this section, for e.g. explaining + the formula/algorithm. Every method/function should have a docstring, typehints and include the + parameters and return as follows: + + :param arg1: description of arg1 + :return: description of return + """ + # Code bloks go here. + # Make sure to include comments to explain what the code is doing. + # No empty lines between code blocks. + pass + + +def template_function(arg1: int) -> None: + """ + Brief imperative description of what the function does in one line. + + You can elaborate more in the function docstring in this section, for e.g. explaining + the formula/algorithm. Every function should have a docstring, typehints and include the + parameters and return as follows: + + :param arg1: description of arg1 + :return: description of return + """ + # Code bloks go here. + # Make sure to include comments to explain what the code is doing. + # No empty lines between code blocks. + pass + + +# %% [markdown] +# ## The flow should be highlighted using headings in markdown +# ``` +# # Level 1 +# ## Level 2 +# ### Level 3 +# ``` diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.example.ipynb b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.example.ipynb new file mode 100644 index 000000000..a2e9aedd7 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.example.ipynb @@ -0,0 +1,198 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "50f78f7e-2dee-45d6-9d37-7a55eeaae283", + "metadata": {}, + "source": [ + "# Template Example Notebook\n", + "\n", + "This is a template notebook. The first heading should be the title of what notebook is about. For example, if it is a project on neo4j tutorial the heading should be `Project Title`.\n", + "\n", + "- Add description of what the notebook does.\n", + "- Point to references, e.g. (neo4j.example.md)\n", + "- Add citations.\n", + "- Keep the notebook flow clear.\n", + "- Comments should be imperative and have a period at the end.\n", + "- Your code should be well commented.\n", + "\n", + "The name of this notebook should in the following format:\n", + "- if the notebook is exploring `pycaret API`, then it is `pycaret.example.ipynb`\n", + "\n", + "Follow the reference to write notebooks in a clear manner: https://github.com/causify-ai/helpers/blob/master/docs/coding/all.jupyter_notebook.how_to_guide.md" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6226667e-cab5-479c-be6a-6b7d6f580a97", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8020901a-4bc7-4b73-95e8-aaa462b4fc19", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "# Import libraries in this section.\n", + "# Avoid imports like import *, from ... import ..., from ... import *, etc.\n", + "\n", + "import helpers.hdbg as hdbg\n", + "import helpers.hnotebook as hnotebo" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4ecb72b2-b21d-4fb0-ac92-e7174da390e6", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0mWARNING: Running in Jupyter\n", + "INFO > cmd='/venv/lib/python3.12/site-packages/ipykernel_launcher.py -f /home/.local/share/jupyter/runtime/kernel-783e0930-1631-4d64-8bb4-f3a98bb74fcd.json'\n" + ] + } + ], + "source": [ + "hdbg.init_logger(verbosity=logging.INFO)\n", + "\n", + "_LOG = logging.getLogger(__name__)\n", + "\n", + "hnotebo.config_notebook()" + ] + }, + { + "cell_type": "markdown", + "id": "1ede6422-bff2-4f0a-8d28-29a01d4786b2", + "metadata": { + "lines_to_next_cell": 2 + }, + "source": [ + "## Make the notebook flow clear\n", + "Each notebook needs to follow a clear and logical flow, e.g:\n", + "- Load data\n", + "- Compute stats\n", + "- Clean data\n", + "- Compute stats\n", + "- Do analysis\n", + "- Show results\n", + "\n", + "\n", + "\n", + "\n", + "#############################################################################\n", + "Template\n", + "#############################################################################" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8bbd660d-d22f-44fa-bf53-dd622dee0f53", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "class Template:\n", + " \"\"\"\n", + " Brief imperative description of what the class does in one line, if needed.\n", + " \"\"\"\n", + "\n", + " def __init__(self):\n", + " pass\n", + "\n", + " def method1(self, arg1: int) -> None:\n", + " \"\"\"\n", + " Brief imperative description of what the method does in one line.\n", + "\n", + " You can elaborate more in the method docstring in this section, for e.g. explaining\n", + " the formula/algorithm. Every method/function should have a docstring, typehints and include the\n", + " parameters and return as follows:\n", + "\n", + " :param arg1: description of arg1\n", + " :return: description of return\n", + " \"\"\"\n", + " # Code bloks go here.\n", + " # Make sure to include comments to explain what the code is doing.\n", + " # No empty lines between code blocks.\n", + " pass\n", + "\n", + "\n", + "def template_function(arg1: int) -> None:\n", + " \"\"\"\n", + " Brief imperative description of what the function does in one line.\n", + "\n", + " You can elaborate more in the function docstring in this section, for e.g. explaining\n", + " the formula/algorithm. Every function should have a docstring, typehints and include the\n", + " parameters and return as follows:\n", + "\n", + " :param arg1: description of arg1\n", + " :return: description of return\n", + " \"\"\"\n", + " # Code bloks go here.\n", + " # Make sure to include comments to explain what the code is doing.\n", + " # No empty lines between code blocks.\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "id": "103f6e36-54cf-442c-b137-8091d48805a7", + "metadata": {}, + "source": [ + "## The flow should be highlighted using headings in markdown\n", + "```\n", + "# Level 1\n", + "## Level 2\n", + "### Level 3\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d05d52af-67ba-4a4f-a561-af453e43854f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py:percent" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.example.py b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.example.py new file mode 100644 index 000000000..8566ff277 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template.example.py @@ -0,0 +1,125 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.19.0 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# %% [markdown] +# # Template Example Notebook +# +# This is a template notebook. The first heading should be the title of what notebook is about. For example, if it is a project on neo4j tutorial the heading should be `Project Title`. +# +# - Add description of what the notebook does. +# - Point to references, e.g. (neo4j.example.md) +# - Add citations. +# - Keep the notebook flow clear. +# - Comments should be imperative and have a period at the end. +# - Your code should be well commented. +# +# The name of this notebook should in the following format: +# - if the notebook is exploring `pycaret API`, then it is `pycaret.example.ipynb` +# +# Follow the reference to write notebooks in a clear manner: https://github.com/causify-ai/helpers/blob/master/docs/coding/all.jupyter_notebook.how_to_guide.md + +# %% +# %load_ext autoreload +# %autoreload 2 +# %matplotlib inline + +# %% +import logging +# Import libraries in this section. +# Avoid imports like import *, from ... import ..., from ... import *, etc. + +import helpers.hdbg as hdbg +import helpers.hnotebook as hnotebo + +# %% +hdbg.init_logger(verbosity=logging.INFO) + +_LOG = logging.getLogger(__name__) + +hnotebo.config_notebook() + + +# %% [markdown] +# ## Make the notebook flow clear +# Each notebook needs to follow a clear and logical flow, e.g: +# - Load data +# - Compute stats +# - Clean data +# - Compute stats +# - Do analysis +# - Show results +# +# +# +# + + +# ############################################################################# +# Template +# ############################################################################# + + +# %% +class Template: + """ + Brief imperative description of what the class does in one line, if needed. + """ + + def __init__(self): + pass + + def method1(self, arg1: int) -> None: + """ + Brief imperative description of what the method does in one line. + + You can elaborate more in the method docstring in this section, for e.g. explaining + the formula/algorithm. Every method/function should have a docstring, typehints and include the + parameters and return as follows: + + :param arg1: description of arg1 + :return: description of return + """ + # Code bloks go here. + # Make sure to include comments to explain what the code is doing. + # No empty lines between code blocks. + pass + + +def template_function(arg1: int) -> None: + """ + Brief imperative description of what the function does in one line. + + You can elaborate more in the function docstring in this section, for e.g. explaining + the formula/algorithm. Every function should have a docstring, typehints and include the + parameters and return as follows: + + :param arg1: description of arg1 + :return: description of return + """ + # Code bloks go here. + # Make sure to include comments to explain what the code is doing. + # No empty lines between code blocks. + pass + + +# %% [markdown] +# ## The flow should be highlighted using headings in markdown +# ``` +# # Level 1 +# ## Level 2 +# ### Level 3 +# ``` + +# %% diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template_utils.py b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template_utils.py new file mode 100644 index 000000000..f8916102e --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/template_utils.py @@ -0,0 +1,72 @@ +""" +template_utils.py + +This file contains utility functions that support the tutorial notebooks. + +- Notebooks should call these functions instead of writing raw logic inline. +- This helps keep the notebooks clean, modular, and easier to debug. +- Students should implement functions here for data preprocessing, + model setup, evaluation, or any reusable logic. + +Import as: + +import class_project.project_template.template_utils as cpptteut +""" + +import pandas as pd +import logging +from sklearn.model_selection import train_test_split +from pycaret.classification import compare_models + +# ----------------------------------------------------------------------------- +# Logging +# ----------------------------------------------------------------------------- + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +# ----------------------------------------------------------------------------- +# Example 1: Split the dataset into train and test sets +# ----------------------------------------------------------------------------- + + +def split_data(df: pd.DataFrame, target_column: str, test_size: float = 0.2): + """ + Split the dataset into training and testing sets. + + :param df: full dataset + :param target_column: name of the target column + :param test_size: proportion of test data (default = 0.2) + + :return: X_train, X_test, y_train, y_test + """ + logger.info("Splitting data into train and test sets") + X = df.drop(columns=[target_column]) + y = df[target_column] + return train_test_split(X, y, test_size=test_size, random_state=42) + + +# ----------------------------------------------------------------------------- +# Example 2: PyCaret classification pipeline +# ----------------------------------------------------------------------------- + + +def run_pycaret_classification( + df: pd.DataFrame, target_column: str +) -> pd.DataFrame: + """ + Run a basic PyCaret classification experiment. + + :param df: dataset containing features and target + :param target_column: name of the target column + + :return: comparison of top-performing models + """ + logger.info("Initializing PyCaret classification setup") + ... + + logger.info("Comparing models") + results = compare_models() + ... + + return results diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/test/test_docker_all.py b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/test/test_docker_all.py new file mode 100644 index 000000000..c7fce0cfd --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/test/test_docker_all.py @@ -0,0 +1,40 @@ +""" +Run each notebook in the FastText project inside Docker. + +Import as: +import class_project.data605.Spring2026.projects.UmdTask458_DATA605_Spring2026_FastText_text_classification.test.test_docker_all as tftdal +""" +import logging +import pytest +import helpers.hdocker_tests as hdoctest + +_LOG = logging.getLogger(__name__) + + +# ############################################################################# +# Test_docker +# ############################################################################# + + +class Test_docker(hdoctest.DockerTestCase): + """ + Run all Docker tests for the FastText text classification project. + """ + + _test_file = __file__ + + @pytest.mark.slow + def test1(self) -> None: + """ + Test that fasttext.example.ipynb runs without error inside Docker. + """ + notebook_name = "fasttext.example.ipynb" + self._helper(notebook_name) + + @pytest.mark.slow + def test2(self) -> None: + """ + Test that fasttext.API.ipynb runs without error inside Docker. + """ + notebook_name = "fasttext.API.ipynb" + self._helper(notebook_name) \ No newline at end of file diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/utils.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/utils.sh new file mode 100644 index 000000000..cc0ed8c4a --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/utils.sh @@ -0,0 +1,607 @@ +#!/bin/bash +# """ +# Utility functions for Docker container management. +# """ + + +# ############################################################################# +# General utilities +# ############################################################################# + + +run() { + # """ + # Execute a command with echo output. + # + # :param cmd: Command string to execute + # :return: Exit status of the executed command + # """ + cmd="$*" + echo "> $cmd" + eval "$cmd" +} + + +enable_verbose_mode() { + # """ + # Enable shell command tracing (set -x) when VERBOSE is set to 1. + # + # Reads the VERBOSE variable set by parse_docker_jupyter_args. + # Call this after parsing args to activate tracing for the rest of the script. + # """ + if [[ $VERBOSE == 1 ]]; then + set -x + fi +} + + +# ############################################################################# +# Argument parsing +# ############################################################################# + + +_print_default_help() { + # """ + # Print usage information and available default options for docker scripts. + # """ + echo "Usage: $(basename $0) [options]" + echo "" + echo "Options:" + echo " -f Force kill existing container with same name before starting" + echo " -h Print this help message and exit" + echo " -v Enable verbose output (set -x)" +} + + +parse_default_args() { + # """ + # Parse default command-line arguments for docker scripts. + # + # Sets VERBOSE and FORCE variables in the caller's scope. Enables set -x + # when -v is passed. Prints help and exits when -h is passed. + # Updates OPTIND so the caller can shift away processed arguments. + # + # :param @: command-line arguments forwarded from the calling script + # """ + VERBOSE=0 + FORCE=0 + while getopts "fhv" flag; do + case "${flag}" in + f) FORCE=1;; + h) _print_default_help; exit 0;; + v) VERBOSE=1;; + *) _print_default_help; exit 1;; + esac + done + enable_verbose_mode +} + + +_print_docker_jupyter_help() { + # """ + # Print usage information and available options for docker_jupyter.sh. + # """ + echo "Usage: $(basename $0) [options]" + echo "" + echo "Launch Jupyter Lab inside a Docker container." + echo "" + echo "Options:" + echo " -f Force kill existing container with same name before starting" + echo " -h Print this help message and exit" + echo " -p PORT Host port to forward to Jupyter Lab (default: 8888)" + echo " -u Enable vim keybindings in Jupyter Lab" + echo " -v Enable verbose output (set -x)" +} + + +parse_docker_jupyter_args() { + # """ + # Parse command-line arguments for docker_jupyter.sh. + # + # Sets JUPYTER_HOST_PORT, JUPYTER_USE_VIM, TARGET_DIR, VERBOSE, FORCE, and + # OLD_CMD_OPTS in the caller's scope. Enables set -x when -v is passed. + # Prints help and exits when -h is passed. + # + # :param @: command-line arguments forwarded from the calling script + # """ + # Set defaults. + JUPYTER_HOST_PORT=8888 + JUPYTER_USE_VIM=0 + VERBOSE=0 + FORCE=0 + # Save original args to pass through to run_jupyter.sh. + OLD_CMD_OPTS="$*" + # Parse options. + while getopts "fhp:uv" flag; do + case "${flag}" in + f) FORCE=1;; + h) _print_docker_jupyter_help; exit 0;; + p) JUPYTER_HOST_PORT=${OPTARG};; # Port for Jupyter Lab. + u) JUPYTER_USE_VIM=1;; # Enable vim bindings. + v) VERBOSE=1;; # Enable verbose output. + *) _print_docker_jupyter_help; exit 1;; + esac + done + # Enable command tracing if verbose mode is requested. + enable_verbose_mode +} + + +# ############################################################################# +# Docker image management +# ############################################################################# + + +get_docker_vars_script() { + # """ + # Load Docker variables from docker_name.sh script. + # + # :param script_path: Path to the script to determine the Docker configuration directory + # :return: Sources REPO_NAME, IMAGE_NAME, and FULL_IMAGE_NAME variables + # """ + local script_path=$1 + # Find the name of the container. + SCRIPT_DIR=$(dirname $script_path) + DOCKER_NAME="$SCRIPT_DIR/docker_name.sh" + if [[ ! -e $SCRIPT_DIR ]]; then + echo "Can't find $DOCKER_NAME" + exit -1 + fi; + source $DOCKER_NAME +} + + +print_docker_vars() { + # """ + # Print current Docker variables to stdout. + # """ + echo "REPO_NAME=$REPO_NAME" + echo "IMAGE_NAME=$IMAGE_NAME" + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" +} + + +build_container_image() { + # """ + # Build a Docker container image. + # + # Supports both single-architecture and multi-architecture builds. + # Creates temporary build directory, copies files, and builds the image. + # + # :param @: Additional options to pass to docker build/buildx build + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + # Prepare build area. + #tar -czh . | docker build $OPTS -t $IMAGE_NAME - + DIR="../tmp.build" + if [[ -d $DIR ]]; then + rm -rf $DIR + fi; + cp -Lr . $DIR || true + # Build container. + echo "DOCKER_BUILDKIT=$DOCKER_BUILDKIT" + echo "DOCKER_BUILD_MULTI_ARCH=$DOCKER_BUILD_MULTI_ARCH" + if [[ $DOCKER_BUILD_MULTI_ARCH != 1 ]]; then + # Build for a single architecture. + echo "Building for current architecture..." + OPTS="--progress plain $@" + (cd $DIR; docker build $OPTS -t $FULL_IMAGE_NAME . 2>&1 | tee ../docker_build.log; exit ${PIPESTATUS[0]}) + else + # Build for multiple architectures. + echo "Building for multiple architectures..." + OPTS="$@" + export DOCKER_CLI_EXPERIMENTAL=enabled + # Create a new builder. + #docker buildx rm --all-inactive --force + #docker buildx create --name mybuilder + #docker buildx use mybuilder + # Use the default builder. + docker buildx use multiarch + docker buildx inspect --bootstrap + # Note that one needs to push to the repo since otherwise it is not + # possible to keep multiple. + (cd $DIR; docker buildx build --push --platform linux/arm64,linux/amd64 $OPTS --tag $FULL_IMAGE_NAME . 2>&1 | tee ../docker_build.log; exit ${PIPESTATUS[0]}) + # Report the status. + docker buildx imagetools inspect $FULL_IMAGE_NAME + fi; + # Report build version. + if [ -f docker_build.version.log ]; then + rm docker_build.version.log + fi + (cd $DIR; docker run --rm -it -v $(pwd):/data $FULL_IMAGE_NAME bash -c "/data/version.sh") 2>&1 | tee docker_build.version.log + # + docker image ls $REPO_NAME/$IMAGE_NAME + rm -rf $DIR + echo "*****************************" + echo "SUCCESS" + echo "*****************************" +} + + +remove_container_image() { + # """ + # Remove Docker container image(s) matching the current configuration. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker image ls | grep $FULL_IMAGE_NAME + docker image ls | grep $FULL_IMAGE_NAME | awk '{print $1}' | xargs -n 1 -t docker image rm -f + docker image ls + echo "${FUNCNAME[0]} ... done" +} + + +push_container_image() { + # """ + # Push Docker container image to registry. + # + # Authenticates using credentials from ~/.docker/passwd.$REPO_NAME.txt. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker login --username $REPO_NAME --password-stdin <~/.docker/passwd.$REPO_NAME.txt + docker images $FULL_IMAGE_NAME + docker push $FULL_IMAGE_NAME + echo "${FUNCNAME[0]} ... done" +} + + +pull_container_image() { + # """ + # Pull Docker container image from registry. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker pull $FULL_IMAGE_NAME + echo "${FUNCNAME[0]} ... done" +} + + +# ############################################################################# +# Docker container management +# ############################################################################# + + +kill_container() { + # """ + # Kill and remove Docker container(s) matching the current configuration. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker container ls + # + CONTAINER_ID=$(docker container ls -a | grep $FULL_IMAGE_NAME | awk '{print $1}') + echo "CONTAINER_ID=$CONTAINER_ID" + if [[ ! -z $CONTAINER_ID ]]; then + docker container rm -f $CONTAINER_ID + docker container ls + fi; + echo "${FUNCNAME[0]} ... done" +} + + +kill_container_by_name() { + # """ + # Kill and remove a Docker container by its name. + # + # :param container_name: Name of the container to kill + # """ + local container_name=$1 + echo "# ${FUNCNAME[0]}: $container_name" + # Check if container exists (running or stopped). + local container_id=$(docker container ls -a --filter "name=^${container_name}$" --format "{{.ID}}") + if [[ -n $container_id ]]; then + echo "Killing container: $container_name (ID: $container_id)" + docker container rm -f $container_id + else + echo "Container '$container_name' not found" + fi + echo "${FUNCNAME[0]} ... done" +} + + +exec_container() { + # """ + # Execute bash shell in running Docker container. + # + # Opens an interactive bash session in the first container matching the + # current configuration. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker container ls + # + CONTAINER_ID=$(docker container ls -a | grep $FULL_IMAGE_NAME | awk '{print $1}') + echo "CONTAINER_ID=$CONTAINER_ID" + docker exec -it $CONTAINER_ID bash + echo "${FUNCNAME[0]} ... done" +} + + +# ############################################################################# +# Docker common options +# ############################################################################# + + +get_docker_common_options() { + # """ + # Return docker run options common to all container types. + # + # Includes volume mount for the git root, plus environment variables for + # PYTHONPATH and host OS name. + # + # :return: docker run options string with volume mounts and env vars + # """ + echo "-v $GIT_ROOT:/git_root \ + -e PYTHONPATH=/git_root:/git_root/helpers_root:/git_root/msml610/tutorials \ + -e CSFY_GIT_ROOT_PATH=/git_root \ + -e CSFY_HOST_OS_NAME=$(uname -s) \ + -e CSFY_HOST_NAME=$(uname -n)" +} + + +# ############################################################################# +# Docker bash +# ############################################################################# + + +get_docker_bash_command() { + # """ + # Return the base docker run command for an interactive bash shell. + # + # :return: docker run command string with --rm and -ti flags + # """ + if [ -t 0 ]; then + echo "docker run --rm -ti" + else + echo "docker run --rm -i" + fi +} + + +get_docker_bash_options() { + # """ + # Return docker run options for a Docker container. + # + # :param container_name: Name for the Docker container + # :param port: Port number to forward (optional, skipped if empty) + # :param extra_opts: Additional docker run options (optional) + # :return: docker run options string with name, volume mounts, and env vars + # """ + local container_name=$1 + local port=$2 + local extra_opts=$3 + local port_opt="" + if [[ -n $port ]]; then + port_opt="-p $port:$port" + fi + echo "--name $container_name \ + $port_opt \ + $extra_opts \ + $(get_docker_common_options)" +} + + +# ############################################################################# +# Docker cmd +# ############################################################################# + + +get_docker_cmd_command() { + # """ + # Return the base docker run command for executing a non-interactive command. + # + # :return: docker run command string with --rm and -i flags + # """ + echo "docker run --rm -i" +} + + +# ############################################################################# +# Docker Jupyter +# ############################################################################# + + +get_docker_jupyter_command() { + # """ + # Return the base docker run command for running Jupyter Lab interactively. + # + # :return: docker run command string with --rm and -ti flags (if TTY available) + # """ + local docker_cmd="docker run --rm" + # Add interactive and TTY flags only if stdin is a TTY. + if [[ -t 0 ]]; then + docker_cmd="$docker_cmd -ti" + fi + echo "$docker_cmd" +} + + +get_docker_jupyter_options() { + # """ + # Return docker run options for a Jupyter Lab container. + # + # :param container_name: Name for the Docker container + # :param host_port: Host port to forward to container port 8888 + # :param jupyter_use_vim: 0 or 1 to enable vim bindings + # :return: docker run options string + # """ + local container_name=$1 + local host_port=$2 + local jupyter_use_vim=$3 + # Run as the current user when user is saggese. + if [[ "$(whoami)" == "saggese" ]]; then + echo "Overwriting jupyter_use_vim since user='saggese'" >&2 + jupyter_use_vim=1 + fi + echo "--name $container_name \ + -p $host_port:8888 \ + $(get_docker_common_options) \ + -e JUPYTER_USE_VIM=$jupyter_use_vim" +} + + +configure_jupyter_vim_keybindings() { + # """ + # Configure JupyterLab vim keybindings based on JUPYTER_USE_VIM env var. + # + # Reads JUPYTER_USE_VIM; if 1, verifies jupyterlab_vim is installed and + # writes enabled settings; otherwise writes disabled settings. + # """ + mkdir -p ~/.jupyter/lab/user-settings/@axlair/jupyterlab_vim + if [[ $JUPYTER_USE_VIM == 1 ]]; then + # Check that jupyterlab_vim is installed before trying to enable it. + if ! pip show jupyterlab_vim > /dev/null 2>&1; then + echo "ERROR: jupyterlab_vim is not installed but vim bindings were requested." + echo "Install it with: pip install jupyterlab_vim" + exit 1 + fi + echo "Enabling vim." + cat < ~/.jupyter/lab/user-settings/\@axlair/jupyterlab_vim/plugin.jupyterlab-settings +{ + "enabled": true, + "enabledInEditors": true, + "extraKeybindings": [], + "autosaveInterval": 6 +} +EOF + else + echo "Disabling vim." + cat < ~/.jupyter/lab/user-settings/\@axlair/jupyterlab_vim/plugin.jupyterlab-settings +{ + "enabled": false, + "enabledInEditors": false, + "extraKeybindings": [], + "autosaveInterval": 6 +} +EOF + fi; +} + + +configure_jupyter_notifications() { + # """ + # Disable JupyterLab news fetching and update checks. + # """ + mkdir -p ~/.jupyter/lab/user-settings/@jupyterlab/apputils-extension + cat < ~/.jupyter/lab/user-settings/\@jupyterlab/apputils-extension/notification.jupyterlab-settings +{ + // Notifications + // @jupyterlab/apputils-extension:notification + // Notifications settings. + + // Fetch official Jupyter news + // Whether to fetch news from the Jupyter news feed. If Always (`true`), it will make a request to a website. + "fetchNews": "false", + "checkForUpdates": false +} +EOF +} + + +configure_jupyter_autosave() { + # """ + # Configure JupyterLab global autosave interval to 6 seconds. + # """ + mkdir -p ~/.jupyter/lab/user-settings/@jupyterlab/docmanager-extension + cat < ~/.jupyter/lab/user-settings/\@jupyterlab/docmanager-extension/plugin.jupyterlab-settings +{ + "autosaveInterval": 6 +} +EOF +} + + +check_jupytext_installed() { + # """ + # Verify that jupytext is installed before starting Jupyter Lab. + # + # Jupytext is required for pair notebook/Python file functionality. + # Exits with error if jupytext is not installed. + # """ + if ! pip show jupytext > /dev/null 2>&1; then + echo "ERROR: jupytext is not installed but is required to run Jupyter Lab." + echo "Install it with: pip install jupytext" + exit 1 + fi +} + + +setup_jupyter_environment() { + # """ + # Configure Jupyter Lab environment before launching. + # + # Performs all necessary setup steps: + # - Configure vim keybindings + # - Disable notifications + # - Configure autosave interval + # - Verify jupytext is installed + # """ + configure_jupyter_vim_keybindings + configure_jupyter_notifications + configure_jupyter_autosave + check_jupytext_installed +} + + +get_jupyter_args() { + # """ + # Print the standard Jupyter Lab command-line arguments. + # + # :return: space-separated Jupyter Lab args for port 8888 with no browser, + # allow root, and no authentication + # """ + echo "--port=8888 --no-browser --ip=0.0.0.0 --allow-root --ServerApp.token='' --ServerApp.password=''" +} + + +get_run_jupyter_cmd() { + # """ + # Return the command to run run_jupyter.sh inside a container. + # + # Computes the script's path relative to GIT_ROOT and builds the + # corresponding /git_root/... path used inside the container. + # + # :param script_path: path of the calling script (pass ${BASH_SOURCE[0]}) + # :param cmd_opts: options to forward to run_jupyter.sh + # :return: full command string to run run_jupyter.sh + # """ + local script_path=$1 + local cmd_opts=$2 + local script_dir + script_dir=$(cd "$(dirname "$script_path")" && pwd) + local rel_dir="${script_dir#${GIT_ROOT}/}" + echo "/git_root/${rel_dir}/run_jupyter.sh $cmd_opts" +} + + +list_and_inspect_docker_image() { + # """ + # List available Docker images and inspect their architecture. + # + # Lists all images matching FULL_IMAGE_NAME and attempts to inspect + # their architecture using docker manifest inspect. + # """ + run "docker image ls $FULL_IMAGE_NAME" + (docker manifest inspect $FULL_IMAGE_NAME | grep arch) || true +} + + +kill_existing_container_if_forced() { + # """ + # Kill existing container if FORCE flag is set. + # + # If FORCE is set to 1, kills and removes the container with name + # CONTAINER_NAME. This is typically set by the -f flag. + # """ + if [[ $FORCE == 1 ]]; then + kill_container_by_name $CONTAINER_NAME + fi +} diff --git a/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/version.sh b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/version.sh new file mode 100644 index 000000000..c46ed254c --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask458_DATA605_Spring2026_FastText_text_classification/version.sh @@ -0,0 +1,28 @@ +#!/bin/bash +# """ +# Display versions of installed tools and packages. +# +# This script prints version information for Python, pip, Jupyter, and all +# installed Python packages. Used for debugging and documentation purposes +# to verify the Docker container environment setup. +# """ + +# Display Python 3 version. +echo "# Python3" +python3 --version + +# Display pip version. +echo "# pip3" +pip3 --version + +# Display Jupyter version. +echo "# jupyter" +jupyter --version + +# List all installed Python packages and their versions. +echo "# Python packages" +pip3 list + +# Template for adding additional tool versions. +# echo "# mongo" +# mongod --version