{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "RVNImn10HJcI", "outputId": "b01c1eb5-05dd-419b-faa8-c08ae8df50aa" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Requirement already satisfied: tensorflow in /usr/local/lib/python3.11/dist-packages (2.18.0)\n", "Requirement already satisfied: keras in /usr/local/lib/python3.11/dist-packages (3.8.0)\n", "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.4.0)\n", "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.6.3)\n", "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (25.2.10)\n", "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.6.0)\n", "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.2.0)\n", "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (18.1.1)\n", "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.4.0)\n", "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow) (24.2)\n", "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (5.29.4)\n", "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.32.3)\n", "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow) (75.2.0)\n", "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.0)\n", "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.0.1)\n", "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.13.2)\n", "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.2)\n", "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.71.0)\n", "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.18.0)\n", "Requirement already satisfied: numpy<2.1.0,>=1.26.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.0.2)\n", "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.13.0)\n", "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.4.1)\n", "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.37.1)\n", "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras) (13.9.4)\n", "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras) (0.0.9)\n", "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras) (0.15.0)\n", "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow) (0.45.1)\n", "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.1)\n", "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n", "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.4.0)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2025.4.26)\n", "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.8)\n", "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (0.7.2)\n", "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.1.3)\n", "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras) (3.0.0)\n", "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras) (2.19.1)\n", "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras) (0.1.2)\n", "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow) (3.0.2)\n" ] } ], "source": [ "!pip install tensorflow keras\n", "import numpy as np\n", "import tensorflow as tf\n", "from tensorflow import keras\n", "\n", "# Data processing and visualization imports\n", "import string\n", "import pandas as pd\n", "import plotly.express as px\n", "import tensorflow.data as tfd\n", "import matplotlib.pyplot as plt\n", "from sklearn.preprocessing import LabelEncoder\n", "from sklearn.model_selection import train_test_split\n", "\n", "# Model building imports\n", "from sklearn.utils import class_weight\n", "from tensorflow.keras import callbacks\n", "from tensorflow.keras import Model, layers" ] }, { "cell_type": "code", "source": [ "num_heads = 4\n", "embed_dim = 256\n", "ff_dim = 128\n", "vocab_size = 10000\n", "max_seq_len = 40\n", "\n", "# Set constants\n", "learning_rate = 1e-3\n", "epochs = 100\n", "batch_size = 32\n", "\n", "# Define training callbacks\n", "callbacks = [\n", " keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True),\n", " keras.callbacks.ModelCheckpoint(\"SpamDetector.h5\", save_best_only=True)\n", "]" ], "metadata": { "id": "KXZX-MiaIB9a" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "random_seed = 123\n", "np.random.seed(random_seed)\n", "tf.random.set_seed(random_seed)" ], "metadata": { "id": "AXke-pwyIZ_I" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "import pandas as pd\n", "\n", "# Load the dataset using pandas, specifying the encoding as 'latin-1'\n", "data_frame = pd.read_csv('spam.csv', encoding='latin-1')\n", "data_frame.rename(columns = {'v1':'Category','v2':'Messages'},inplace=True)\n", "\n", "# Print the first five rows of the dataset\n", "print(data_frame.head())" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "IWIFoa10Ien6", "outputId": "068ee878-6a88-4688-8830-81f6cddb26d0" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ " Category Messages Unnamed: 2 \\\n", "0 ham Go until jurong point, crazy.. Available only ... NaN \n", "1 ham Ok lar... Joking wif u oni... NaN \n", "2 spam Free entry in 2 a wkly comp to win FA Cup fina... NaN \n", "3 ham U dun say so early hor... U c already then say... NaN \n", "4 ham Nah I don't think he goes to usf, he lives aro... NaN \n", "\n", " Unnamed: 3 Unnamed: 4 \n", "0 NaN NaN \n", "1 NaN NaN \n", "2 NaN NaN \n", "3 NaN NaN \n", "4 NaN NaN \n" ] } ] }, { "cell_type": "code", "source": [ "\n", "class_dis = data_frame.Category.value_counts()\n", "class_names = class_dis.index\n", "\n", "# Create the Pie Chart\n", "fig = px.pie(names=class_names,\n", " values=class_dis,\n", " color=class_names,\n", " hole=0.4,\n", " labels={'value': 'Count', 'names': 'Class'},\n", " title='Class Distribution of Spam Text Messages')\n", "\n", "# Customize the layout\n", "fig.update_layout(\n", " margin=dict(l=10, r=10, t=60, b=10),\n", " legend=dict(orientation=\"h\", yanchor=\"bottom\", y=1.02, xanchor=\"right\", x=1),\n", ")\n", "\n", "# Show the plot\n", "fig.show()\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 542 }, "id": "AytubNcyIiFE", "outputId": "fd32bc9d-0061-4778-ff22-52004bb71f5a" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/html": [ "\n", "\n", "\n", "
\n", "
\n", "\n", "" ] }, "metadata": {} } ] }, { "cell_type": "code", "source": [ "N_SAMPLES = len(data_frame)\n", "\n", "print(f\"Total Number of Samples : {N_SAMPLES}\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "yW73nhrwKo2U", "outputId": "fd711c6f-4bfb-4f8f-e839-5aecd01fd3ab" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Total Number of Samples : 5572\n" ] } ] }, { "cell_type": "code", "source": [ "max_len = max([len(text) for text in data_frame.Messages])\n", "print(f\"Maximum Length Of Input Sequence(Chars) : {max_len}\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "J_qfT-V9MCJK", "outputId": "c1456930-6ece-4118-b018-6dc484507559" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Maximum Length Of Input Sequence(Chars) : 910\n" ] } ] }, { "cell_type": "code", "source": [ "X = data_frame['Messages'].tolist()\n", "y = data_frame['Category'].tolist()\n", "\n", "\n", "# Initialize label encoder\n", "label_encoder = LabelEncoder()\n", "y = label_encoder.fit_transform(y)\n", "\n", "# Print the first 5 elements of X and y\n", "print(f'X[:5]: \\n{X[:5]}\\n')\n", "print(f'y[:5]: {y[:5]}\\n')\n", "print(f\"Label Mapping : {label_encoder.inverse_transform(y[:5])}\")\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "RdZ3CLu3MFz2", "outputId": "e2092b5e-f1e2-4a66-d45c-6398e2e8d47a" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "X[:5]: \n", "['Go until jurong point, crazy.. Available only in bugis n great world la e buffet... Cine there got amore wat...', 'Ok lar... Joking wif u oni...', \"Free entry in 2 a wkly comp to win FA Cup final tkts 21st May 2005. Text FA to 87121 to receive entry question(std txt rate)T&C's apply 08452810075over18's\", 'U dun say so early hor... U c already then say...', \"Nah I don't think he goes to usf, he lives around here though\"]\n", "\n", "y[:5]: [0 0 1 0 0]\n", "\n", "Label Mapping : ['ham' 'ham' 'spam' 'ham' 'ham']\n" ] } ] }, { "cell_type": "code", "source": [ "class_weights = class_weight.compute_class_weight(class_weight='balanced', classes=data_frame.Category.unique(), y=label_encoder.inverse_transform(y))\n", "class_weights = {number: weight for number, weight in enumerate(class_weights)}\n", "# Show\n", "print(f\"Associated class weights: {class_weights}\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7YbFnWsFNIHI", "outputId": "402b004f-3dee-4a7c-cfc2-1126ffd23006" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Associated class weights: {0: np.float64(0.5774093264248704), 1: np.float64(3.7295850066934406)}\n" ] } ] }, { "cell_type": "code", "source": [ "def preprocess_text(text: str) -> str:\n", " \"\"\"\n", " Preprocesses the text by removing punctuation, lowercasing, and stripping whitespace.\n", " \"\"\"\n", " # Replace punctuation with spaces\n", " text = tf.strings.regex_replace(text, f\"[{string.punctuation}]\", \" \")\n", "\n", " # Lowercase the text\n", " text = tf.strings.lower(text)\n", "\n", " # Strip leading/trailing whitespace\n", " text = tf.strings.strip(text)\n", "\n", " return text\n", "\n", "\n", "# Create a TextVectorization layer\n", "text_vectorizer = layers.TextVectorization(\n", " max_tokens=vocab_size, # Maximum vocabulary size\n", " output_sequence_length=max_seq_len, # Maximum sequence length\n", " standardize=preprocess_text, # Custom text preprocessing function\n", " pad_to_max_tokens=True, # Pad sequences to maximum length\n", " output_mode='int' # Output integer-encoded sequences\n", ")\n", "\n", "# Adapt the TextVectorization layer to the data\n", "text_vectorizer.adapt(X)" ], "metadata": { "id": "F_XmRN2FNNZ5" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "for _ in range(5):\n", " # Send a text to randomly.\n", " text_temp = X[np.random.randint(N_SAMPLES)]\n", "\n", " # Apply text to vectorization.\n", " text_vec_temp = text_vectorizer(text_temp)\n", "\n", " # Show the results\n", " print(f\"Original Text: {text_temp}\")\n", " print(f\"Vectorized Text: {text_vec_temp}\\n\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "4Epp7fX6NSa3", "outputId": "0afc39db-6ca2-4b70-ac5e-a7c98e69c4fe" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Original Text: I sent your maga that money yesterday oh.\n", "Vectorized Text: [ 2 197 15 2578 19 229 513 136 0 0 0 0 0 0\n", " 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", " 0 0 0 0 0 0 0 0 0 0 0 0]\n", "\n", "Original Text: No need lar. Jus testing e phone card. Dunno network not gd i thk. Me waiting 4 my sis 2 finish bathing so i can bathe. Dun disturb u liao u cleaning ur room.\n", "Vectorized Text: [ 42 81 342 365 3108 152 116 702 421 441 29 659 2 267\n", " 11 257 45 12 682 22 316 2211 26 2 25 1075 252 1152\n", " 7 349 7 2181 40 371 0 0 0 0 0 0]\n", "\n", "Original Text: Is it ok if I stay the night here? Xavier has a sleeping bag and I'm getting tired\n", "Vectorized Text: [ 10 13 50 37 2 528 6 127 117 2298 126 5 600 1450\n", " 8 2 30 278 832 0 0 0 0 0 0 0 0 0\n", " 0 0 0 0 0 0 0 0 0 0 0 0]\n", "\n", "Original Text: Aight I've been set free, think you could text me blake's address? It occurs to me I'm not quite as sure what I'm doing as I thought I was\n", "Vectorized Text: [ 386 2 154 114 601 53 112 4 230 75 11 2833 20 567\n", " 13 6030 3 11 2 30 29 362 76 192 51 2 30 163\n", " 76 2 280 2 64 0 0 0 0 0 0 0]\n", "\n", "Original Text: I accidentally brought em home in the box\n", "Vectorized Text: [ 2 2237 2192 1063 82 9 6 367 0 0 0 0 0 0\n", " 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", " 0 0 0 0 0 0 0 0 0 0 0 0]\n", "\n" ] } ] }, { "cell_type": "code", "source": [ "VOCAB = text_vectorizer.get_vocabulary()\n", "\n", "# Let's have a look at the tokens present in the vocabulary\n", "print(f\"Vocabulary size: {len(VOCAB)}\")\n", "print(f\"Vocabulary: {VOCAB[150:200]}\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "efgjn27ANXkQ", "outputId": "89be8f9e-af19-4de4-8cc4-63d0e6263994" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Vocabulary size: 8862\n", "Vocabulary: [np.str_('should'), np.str_('message'), np.str_('e'), np.str_('won'), np.str_('ve'), np.str_('tomorrow'), np.str_('prize'), np.str_('say'), np.str_('right'), np.str_('already'), np.str_('after'), np.str_('ask'), np.str_('said'), np.str_('doing'), np.str_('cash'), np.str_('yeah'), np.str_('3'), np.str_('really'), np.str_('amp'), np.str_('why'), np.str_('meet'), np.str_('b'), np.str_('them'), np.str_('im'), np.str_('very'), np.str_('find'), np.str_('life'), np.str_('let'), np.str_('babe'), np.str_('last'), np.str_('thanks'), np.str_('morning'), np.str_('\\\\'), np.str_('would'), np.str_('cos'), np.str_('win'), np.str_('miss'), np.str_('uk'), np.str_('lol'), np.str_('anything'), np.str_('also'), np.str_('every'), np.str_('sure'), np.str_('pick'), np.str_('com'), np.str_('care'), np.str_('150p'), np.str_('sent'), np.str_('nokia'), np.str_('urgent')]\n" ] } ] }, { "cell_type": "code", "source": [ "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42, shuffle=True)\n", "\n", "# Apply the Text Vectorization\n", "X_train = text_vectorizer(X_train)\n", "X_test = text_vectorizer(X_test)\n", "\n", "# One Hot Vectors\n", "Xoh_train = tf.one_hot(X_train, depth=10000)\n", "Xoh_test = tf.one_hot(X_test, depth=10000)" ], "metadata": { "id": "8SPtbOxeNb8Q" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "class TokenAndPositionalEmbedding(layers.Layer):\n", "\n", " def __init__(self, embedding_dims, vocab_size, seq_len, **kwargs):\n", " super(TokenAndPositionalEmbedding, self).__init__(**kwargs)\n", "\n", " # Initialize parameters\n", " self.seq_len = seq_len\n", " self.vocab_size = vocab_size\n", " self.embedding_dims = embedding_dims\n", " self.embed_scale = tf.math.sqrt(tf.cast(embedding_dims, tf.float32))\n", "\n", " # Define layers\n", " self.token_embedding = layers.Embedding(\n", " input_dim=vocab_size,\n", " output_dim=embedding_dims,\n", " name=\"token_embedding\"\n", " )\n", "\n", " self.positional_embedding = layers.Embedding(\n", " input_dim=seq_len,\n", " output_dim=embedding_dims,\n", " name=\"positional_embedding\"\n", " )\n", "\n", " def call(self, inputs):\n", " seq_len = tf.shape(inputs)[1]\n", "\n", " # Token Embedding\n", " token_embedding = self.token_embedding(inputs)\n", " token_embedding *= self.embed_scale\n", "\n", " # Positional Embedding\n", " positions = tf.range(start=0, limit=seq_len, delta=1)\n", " positional_embedding = self.positional_embedding(positions)\n", "\n", " # Add Token and Positional Embedding\n", " embeddings = token_embedding + positional_embedding\n", "\n", " return embeddings\n", "\n", "\n", " def get_config(self):\n", " config = super(TokenAndPositionalEmbedding, self).get_config()\n", " config.update({\n", " 'embedding_dims': self.embedding_dims,\n", " 'vocab_size': self.vocab_size,\n", " 'seq_len': self.seq_len,\n", " })\n", " return config" ], "metadata": { "id": "pmkzVuqHNgpk" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "temp_embeds = TokenAndPositionalEmbedding(embed_dim, vocab_size, max_seq_len)(X_train[:1])\n", "temp_embeds" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "NhCPM7vYNrDS", "outputId": "e915f6ef-31c5-4603-f9a2-d9ac85d43b57" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 28 } ] }, { "cell_type": "code", "source": [ "class TransformerLayer(layers.Layer):\n", "\n", " def __init__(self, num_heads: int, dropout_rate: float, embedding_dims: int, ff_dim: int, **kwargs):\n", " super(TransformerLayer, self).__init__(**kwargs)\n", "\n", " # Initialize Parameters\n", " self.num_heads = num_heads\n", " self.dropout_rate = dropout_rate\n", " self.embedding_dims = embedding_dims\n", " self.ff_dim = ff_dim\n", "\n", " # Initialize Layers\n", " self.mha = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embedding_dims, dropout=dropout_rate)\n", " self.ln1 = layers.LayerNormalization(epsilon=1e-6)\n", "\n", " self.ffn = keras.Sequential([\n", " layers.Dense(ff_dim, activation='relu', kernel_initializer='he_normal'),\n", " layers.Dense(embedding_dims)\n", " ])\n", " self.ln2 = layers.LayerNormalization(epsilon=1e-6)\n", "\n", " def call(self, inputs):\n", " \"\"\"Forward pass of the Transformer Layer.\n", "\n", " Args:\n", " inputs: Tensor with shape `(batch_size, seq_len, embedding_dims)` representing the input sequence.\n", "\n", " Returns:\n", " Tensor with shape `(batch_size, seq_len, embedding_dims)` representing the output sequence after applying the Transformer Layer.\n", " \"\"\"\n", "\n", " # Multi-Head Attention\n", " attention = self.mha(inputs, inputs, inputs)\n", "\n", " # Layer Normalization and Residual Connection\n", " normalized1 = self.ln1(attention + inputs)\n", "\n", " # Feedforward Network\n", " ffn_out = self.ffn(normalized1)\n", "\n", " # Layer Normalization and Residual Connection\n", " normalized2 = self.ln2(ffn_out + normalized1)\n", "\n", " return normalized2\n", "\n", " def get_config(self):\n", " \"\"\"Get the configuration of the Transformer Layer.\n", "\n", " Returns:\n", " Dictionary with the configuration of the layer.\n", " \"\"\"\n", " config = super(TransformerLayer, self).get_config()\n", " config.update({\n", " \"num_heads\": self.num_heads,\n", " \"dropout_rate\": self.dropout_rate,\n", " \"embedding_dims\": self.embedding_dims,\n", " \"ff_dim\": self.ff_dim\n", " })\n", " return config" ], "metadata": { "id": "_Ou6n-atNvAr" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "TransformerLayer(num_heads=num_heads, embedding_dims=embed_dim, ff_dim=ff_dim, dropout_rate=0.1)(temp_embeds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7GM5yXkYN8Dz", "outputId": "331a8fae-abbb-439e-f4c4-9bc7d0de0814" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 30 } ] }, { "cell_type": "code", "source": [ "InputLayer = layers.Input(shape=(max_seq_len,), name=\"InputLayer\")\n", "\n", "# Embedding Layer\n", "embeddings = TokenAndPositionalEmbedding(embed_dim, vocab_size, max_seq_len, name=\"EmbeddingLayer\")(InputLayer)\n", "\n", "# Transformer Layer\n", "encodings = TransformerLayer(num_heads=num_heads, embedding_dims=embed_dim, ff_dim=ff_dim, dropout_rate=0.1, name=\"TransformerLayer\")(embeddings)\n", "\n", "# Classifier\n", "gap = layers.GlobalAveragePooling1D(name=\"GlobalAveragePooling\")(encodings)\n", "drop = layers.Dropout(0.5, name=\"Dropout\")(gap)\n", "OutputLayer = layers.Dense(1, activation='sigmoid', name=\"OutputLayer\")(drop)\n", "\n", "# Model\n", "model = keras.Model(InputLayer, OutputLayer, name=\"TransformerNet\")\n", "\n", "# Model Architecture Summary\n", "model.summary()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 391 }, "id": "8eYjV2h2OAJJ", "outputId": "510ecfdb-ab6e-4a45-e767-f22c24493e8b" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "\u001b[1mModel: \"TransformerNet\"\u001b[0m\n" ], "text/html": [ "
Model: \"TransformerNet\"\n",
              "
\n" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", "│ InputLayer (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m40\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ EmbeddingLayer │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m40\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m2,570,240\u001b[0m │\n", "│ (\u001b[38;5;33mTokenAndPositionalEmbedding\u001b[0m) │ │ │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ TransformerLayer │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m40\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,118,848\u001b[0m │\n", "│ (\u001b[38;5;33mTransformerLayer\u001b[0m) │ │ │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ GlobalAveragePooling │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", "│ (\u001b[38;5;33mGlobalAveragePooling1D\u001b[0m) │ │ │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ Dropout (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ OutputLayer (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m257\u001b[0m │\n", "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" ], "text/html": [ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
              "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
              "│ InputLayer (InputLayer)         │ (None, 40)             │             0 │\n",
              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
              "│ EmbeddingLayer                  │ (None, 40, 256)        │     2,570,240 │\n",
              "│ (TokenAndPositionalEmbedding)   │                        │               │\n",
              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
              "│ TransformerLayer                │ (None, 40, 256)        │     1,118,848 │\n",
              "│ (TransformerLayer)              │                        │               │\n",
              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
              "│ GlobalAveragePooling            │ (None, 256)            │             0 │\n",
              "│ (GlobalAveragePooling1D)        │                        │               │\n",
              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
              "│ Dropout (Dropout)               │ (None, 256)            │             0 │\n",
              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
              "│ OutputLayer (Dense)             │ (None, 1)              │           257 │\n",
              "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
              "
\n" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m3,689,345\u001b[0m (14.07 MB)\n" ], "text/html": [ "
 Total params: 3,689,345 (14.07 MB)\n",
              "
\n" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m3,689,345\u001b[0m (14.07 MB)\n" ], "text/html": [ "
 Trainable params: 3,689,345 (14.07 MB)\n",
              "
\n" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" ], "text/html": [ "
 Non-trainable params: 0 (0.00 B)\n",
              "
\n" ] }, "metadata": {} } ] }, { "cell_type": "code", "source": [ "model.compile(\n", " loss='binary_crossentropy',\n", " optimizer='adam',\n", " metrics=[\n", " keras.metrics.BinaryAccuracy(name='accuracy'),\n", " keras.metrics.Precision(name='precision'),\n", " keras.metrics.Recall(name='recall'),\n", " keras.metrics.AUC(name='auc'),\n", " ]\n", ")\n", "\n", "# Train Model\n", "history = model.fit(\n", " X_train, y_train,\n", " validation_split=0.1,\n", " batch_size=batch_size,\n", " epochs=10,\n", " callbacks=callbacks,\n", " class_weight=class_weights\n", ")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "oZYuIFJuOFuJ", "outputId": "4c17fa29-186a-4fba-bcb7-926b2293df03" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Epoch 1/10\n", "\u001b[1m126/126\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 512ms/step - accuracy: 0.9943 - auc: 0.9993 - loss: 0.0244 - precision: 0.9618 - recall: 0.9944 - val_accuracy: 0.9888 - val_auc: 0.9832 - val_loss: 0.0627 - val_precision: 0.9848 - val_recall: 0.9420\n", "Epoch 2/10\n", "\u001b[1m126/126\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 497ms/step - accuracy: 0.9985 - auc: 0.9997 - loss: 0.0080 - precision: 0.9882 - recall: 1.0000 - val_accuracy: 0.9865 - val_auc: 0.9779 - val_loss: 0.0860 - val_precision: 1.0000 - val_recall: 0.9130\n", "Epoch 3/10\n", "\u001b[1m126/126\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 491ms/step - accuracy: 0.9995 - auc: 1.0000 - loss: 0.0026 - precision: 0.9961 - recall: 1.0000 - val_accuracy: 0.9933 - val_auc: 0.9777 - val_loss: 0.0711 - val_precision: 1.0000 - val_recall: 0.9565\n", "Epoch 4/10\n", "\u001b[1m126/126\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 490ms/step - accuracy: 0.9997 - auc: 1.0000 - loss: 0.0015 - precision: 0.9980 - recall: 1.0000 - val_accuracy: 0.9865 - val_auc: 0.9777 - val_loss: 0.0906 - val_precision: 1.0000 - val_recall: 0.9130\n" ] } ] }, { "cell_type": "code", "source": [ "fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(15, 8))\n", "plt.subplots_adjust(hspace=0.5)\n", "\n", "axes[0, 0].plot(history.history['loss'], label='Training Loss')\n", "axes[0, 0].plot(history.history['val_loss'], label='Validation Loss')\n", "axes[0, 0].set_title('Loss', fontsize=14)\n", "axes[0, 0].set_xlabel('Epoch', fontsize=12)\n", "axes[0, 0].set_ylabel('Loss', fontsize=12)\n", "axes[0, 0].grid(True)\n", "axes[0, 0].legend(fontsize=10)\n", "\n", "axes[0, 1].plot(history.history['accuracy'], label='Training Accuracy')\n", "axes[0, 1].plot(history.history['val_accuracy'], label='Validation Accuracy')\n", "axes[0, 1].set_title('Accuracy', fontsize=14)\n", "axes[0, 1].set_xlabel('Epoch', fontsize=12)\n", "axes[0, 1].set_ylabel('Accuracy', fontsize=12)\n", "axes[0, 1].grid(True)\n", "axes[0, 1].legend(fontsize=10)\n", "\n", "axes[1, 0].plot(history.history['precision'], label='Training Precision')\n", "axes[1, 0].plot(history.history['val_precision'], label='Validation Precision')\n", "axes[1, 0].set_title('Precision', fontsize=14)\n", "axes[1, 0].set_xlabel('Epoch', fontsize=12)\n", "axes[1, 0].set_ylabel('Precision', fontsize=12)\n", "axes[1, 0].grid(True)\n", "axes[1, 0].legend(fontsize=10)\n", "\n", "axes[1, 1].plot(history.history['recall'], label='Training Recall')\n", "axes[1, 1].plot(history.history['val_recall'], label='Validation Recall')\n", "axes[1, 1].set_title('Recall', fontsize=14)\n", "axes[1, 1].set_xlabel('Epoch', fontsize=12)\n", "axes[1, 1].set_ylabel('Recall', fontsize=12)\n", "axes[1, 1].grid(True)\n", "axes[1, 1].legend(fontsize=10)\n", "\n", "fig.suptitle('Model Performance Metrics', fontsize=16, y=1.05)\n", "plt.show()\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 630 }, "id": "QAiJS9mNOLIT", "outputId": "45dc8a9d-ef86-4363-8457-e52c8616b6a9" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAABN4AAAMzCAYAAAB5jN/0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4FFXbx/HvbnqnhySEFkoAgdAFkYCgNOkK8ihSFMsjKiIICAKKiogiiL7yqBQFFRVpClKkdxWkV2mhdxLSy877x5ANIQkEkiUBfp/rmgt2zpkz95xsYHPnFIthGAYiIiIiIiIiIiKSq6x5HYCIiIiIiIiIiMjdSIk3ERERERERERERB1DiTURERERERERExAGUeBMREREREREREXEAJd5EREREREREREQcQIk3ERERERERERERB1DiTURERERERERExAGUeBMREREREREREXEAJd5EREREREREREQcQIk3ERGRfKZ06dJYLBYsFguvvvrqdeuOGTPGXtfZ2fm2xHf48GEsFgulS5fOlfamTp2KxWKhR48eN3Vd6nNffXh4eBASEkLPnj3Ztm1brsSXXcePH6dbt24EBgbi7Ox8S88keadx48b291G7du2uW/fnn39O9747duzYbYoye1LjEhERkbx3ez6hi4iIyC357rvvGDNmDK6urpmWT548+TZHlP80b96c4sWLA3DmzBn++usvpk6dynfffcf06dPp3Lmzw2MwDIOOHTvy559/UrlyZZo0aYKLiwsNGzZ0+L0l9y1YsIDTp0/j7++fafmkSZMcct/UZJlhGA5pX0RERG4/Jd5ERETyqdq1a/P3338zd+5cHn/88Qzl69atY8+ePdSpU4e//vorDyLMHwYNGkTjxo3tryMjI3n88cdZsmQJvXv35uGHH6ZgwYIOjeHIkSP8+eeflCxZkq1bt9620YeS+1K/77799lsGDBiQofzo0aMsWbIkX3/f7d69O69DEBERkSs01VRERCSf6tWrF5D1qLbUUTep9cTk5+fHl19+CUBUVBSLFi1y+D0jIiIAKFOmjJJud7innnoKV1dXpkyZkmn51KlTsdls+fr7LjQ0lNDQ0LwOQ0RERFDiTUREJN+qWrUqtWvXZvHixRw/fjxdWXR0ND/99BMlSpTgkUceuW47Fy5c4M0336RKlSp4enri4+NDrVq1+PDDD4mLi8vyut9++43w8HB8fHzw8/PjwQcfZO7cuTeM++LFiwwfPpywsDB8fHzw9PSkatWqvPvuu8TGxmbv4XOodOnSFCpUCDDXpLvapk2bePLJJylZsiRubm4UKlSI5s2bs2DBgizbslgsHD58mLlz5/LQQw9RqFAhLBaLfX268PBwAFauXJlu7a+r7x0bG8sHH3xAzZo17f1SpUoVhg4dysWLFzPc9+q19FJSUhg7diw1atTA29vbPiVxxYoVWCwWGjduTEJCAm+//TYVKlTA3d2dkiVLMnDgQOLj4wFzJGD//v0pW7Ys7u7ulC5dmhEjRpCcnJzh3mfPnuXTTz+lVatWlClTBg8PD3x9falduzajR4+2t3mtq9cW++WXX2jYsCG+vr54eXnxwAMPZNnHAMnJyUyePJlmzZpRpEgR3NzcKFGiBM2aNWPChAmZXrN06VI6duxIQEAArq6uFCtWjA4dOrB+/fos73MjhQsXpm3btuzevTtDO4ZhMHXqVDw8POjatesN25o5cyYtWrSgaNGiuLq6EhQUxFNPPcWuXbvS1RsxYkS6NdmuXbsw9X109XqIFy5coG/fvoSEhODm5pZu1Of11ni7mX5OSEhgzJgx1KpVCx8fH1xdXSlevDh16tThjTfe4MKFCzfsAxERkXueISIiIvlKqVKlDMBYvXq18X//938GYLz77rvp6kyaNMkAjCFDhhiHDh0yAMPJySlDWwcOHLC3V7RoUaNTp05G27ZtDR8fHwMwatasaVy4cCHDdWPHjjUAAzDq1q1rdO3a1ahdu7YBGP369TMAo1SpUhmu27lzpxEcHGwARkBAgNGiRQujTZs2hr+/vwEYYWFhxqVLl9JdM2XKFAMwunfvflP9lBrf8uXLM5SlpKQYbm5uBmCMHTvWfn7cuHGG1Wq1x/LYY48ZDRs2NFxdXQ3AePvttzO0ldp/ffr0MQCjdu3aRteuXY3w8HBj1apVRvfu3Y3mzZsbgOHv7290797dfpw9e9YwDMM4f/68ERYWZgCGr6+v0bZtW6NTp05GkSJFDMAoU6aMcejQoXT3Tf26lixZ0mjbtq3h6upqNG3a1OjatatRrVo1wzAMY/ny5QZg1K9f3wgPD7e3/eijjxp+fn4GYDz66KPG+fPnjYoVK9rfA4888ojh7u5uAMYLL7yQ4ZmnTZtmAEZQUJARHh5uPPHEE0bTpk0Nb29v+/3i4+Oz/JoMGzbMsFgsxgMPPGB06dLFqF69ugEYFovFmDVrVobrLl26ZDRs2NAADBcXFyM8PNzo2rWr0aRJE6No0aJGZh9ZX3/9dQMwrFarUbduXePxxx836tWrZ1gsFsPJycmYPHlyhmuuJzw83ACMadOmGQsWLDAA49lnn01XZ+nSpQZgPPnkk+me9+jRo+nqJSUlGZ07dzYAw83NzWjQoIHx+OOP2/vBw8PD+P333+31Z8+ebXTv3t3e3tXvoavfR6nfK61btzbKlCljFCxY0Gjbtq3x+OOP22O6Oq6c9HNKSorRtGlT+3u2ZcuWRteuXY1mzZrZvyf++eefm+pjERGRe5ESbyIiIvnM1Ym3S5cuGR4eHka5cuXS1XnggQcMi8ViHDhw4LqJt3r16hmA0bZtWyM6Otp+/syZM0bNmjUNwPjPf/6T7pqtW7caTk5OhtVqNX7++ed0ZdOnTzcsFkumibfY2FgjJCTEAIyhQ4caCQkJ9rKYmBija9euBmD07Nkz3XWOSLz99ttv9vJly5YZhmEYCxcuNCwWi1GkSBFj5cqV6epv27bNKFGihAEYK1asSFeW+vVwcnIy5s6dm2ksqQmw8PDwTMu7dOliAEa9evWMc+fO2c9fvnzZaNmypQEYDRo0SHdN6tcVMEqUKGHs3bs3y/umJkivbvvw4cNGwYIFDcCoWrWq0aZNGyMmJsZe/tdffxnOzs6G1Wo1jhw5kq7dXbt2GevXr89wvwsXLhiPPPKIARgffvhhhvLUWAoUKGBs2LAhXdnw4cMNwKhQoUKG6zp27GgARo0aNTIkIJOSkow5c+akO/fll18agFGuXDlj69at6cpWrlxp+Pj4GK6ursa+ffsy3CsrVyfeUlJSjBIlShg+Pj7p+uzJJ59M957KKvH25ptv2r/eBw8eTFf2888/G05OTkbBggWNixcvpivLKmGWKvV7BTCaNm1qREZGZlovq3Zupp9XrlxprxsVFZWhrb/++ivd+01EREQyp8SbiIhIPnN14s0w0n7YT00I7dmzxwCMxo0bG4ZhZJl4W716tQEYnp6exqlTpzLc5++//7aPGLo6cfDss88agNGlS5dM42vXrl2mibcvvvjCPsIqM5cvXzaKFStmODs7pxtll5uJt7Nnzxrff/+9UaxYMfuotpSUFMMw0pKQM2fOzLS9n376yQCMTp06pTuf+vXo1atXlrFcL/F25MgRw2q1GhaLJUOSyDAM49ixY/bRZ2vXrrWfvzrx9u233173vhaLxdi+fXuG8ldeecUADG9vb+P06dMZytu0aWMAxjfffJPls11r7969BmDUqVMnQ1lqvJ9++mmGsvj4ePsovIiICPv5LVu2GIDh7u5uHDt27Ib3T0lJMQIDAw3A+PvvvzOt8+GHHxqA8frrr2f7ua5OvBmGYQwZMsQAjKlTpxqGYdiT4GXLljVsNlu65736++f8+fOGh4fHdZ/nv//9rwEYEyZMSHc+u4k3FxcX48CBA1nWy6ydm+3n1O+HV1555YZ1RUREJGta401ERCSfu3aThdQ/b7S4+4oVKwBo0aIF/v7+Gcpr1apF9erVsdlsrFy5MsN1Tz31VKbtdu/ePdPz8+fPB6BLly6Zlnt7e1O7dm2Sk5NzdTfIJk2a2Ne0Klq0KP/5z384c+YMNWvWZM6cOVitVs6dO8eff/6Jh4cHbdq0ybSd1DWy1q1bl2n5Y489dkvxrVq1CpvNRo0aNahWrVqG8qCgIJo3bw7A8uXLM22jU6dO171HyZIlue+++zKcL1++PGB+rYsVK5Zl+YkTJzKUpaSksHTpUkaOHMl///tfevbsSY8ePXjvvfcA2Lt3b5bxZNbHbm5ulC1bFiDdmoULFy4EoHXr1gQFBWXZZqp//vmHEydOEBISQq1atTKtc6OvZXb07NkTi8Vi/377/vvviYuLo0ePHlmunwbm1zAuLo4HHnggy+fJaXw1atSw92V23Ww/16xZEycnJyZPnsznn3/OyZMnbylWERGRe5223RIREcnnmjRpQpkyZZg5cybjxo3j22+/xdfX94aJoNTkRpkyZbKsExISwtatW9MlQo4dO3bd67I6f/DgQQC6detGt27drhvb2bNnr1t+M5o3b07x4sUBM7kTGBjIgw8+aE/IARw6dAjDMIiLi8PNze2WYitduvQtxZfdr8PVda9WrFgxPD09r3uPkiVLZnre29v7uuU+Pj4AGTZL2L9/Px06dGDnzp1Z3jMqKuqm4/H19c1wvyNHjgBkexfO1PfZgQMHrpsAg5y9z0JCQmjUqBGrVq3iwIEDTJ48GavVSo8ePbIV39KlSx0W3628F2+2n0NCQvjkk08YMGAAffr0oU+fPpQqVYr69evz6KOP8vjjj+Pq6nrTcYiIiNxrlHgTERHJ51J3MRw+fDjdu3fn1KlTPPfcc3h4eOR1aOnYbDYg6xF2VytVqlSu3XfQoEHpdnTMTGps3t7eNxw9lpW86u/s3Ndqvf4khhuVX+uxxx5j586dPProo7zxxhtUrlwZX19fXFxcSExMvGHy8mbvdzNSv5bFixe3jxTMSpEiRXJ0r169erFy5Upee+01/v77bx555BGCg4OzFV+5cuV44IEHrls3u0mwa92u9+LLL79M586dmTdvHmvWrGHNmjXMmDGDGTNmMHz4cFavXk1AQMBtiUVEROROpcSbiIjIHaBHjx68/fbb/Prrr8CNp5kC9ulkqSNwMpNadvXUs6CgIA4cOMDhw4epUqVKhmsOHz6caVvBwcHs2bOHZ5555panZTpKarIkdeqgIxND17rVr0Ne2bNnD9u2baNYsWLMnj0bZ+f0Hxf379+fq/dLHR23Z8+ebNVP/VoWLlyYqVOn5mos13rsscd4+eWXb+r7LjW+ihUrOjy+m3Gz/ZzK39+f3r1707t3b/v1vXr1Yv369QwaNIhvvvkm12MVERG5m2iNNxERkTtAyZIladeuHYULF+b++++nXr16N7wmdRTYwoULOX36dIbyf/75hy1btmC1WmnUqJH9fHh4OADfffddpu1+++23mZ5v2bIlAD/99NMNY7vdAgMDqVatGpcvX7avdXW7NGrUCKvVypYtW9i6dWuG8pMnT9pjatKkyW2NLTMXLlwAzD67NukGMH369Fy9X4sWLQBYsGBBpmvNXatOnToUKVKEXbt2XXcqbG7w9PSkR48eFC5cmDJlytC+ffsbXtO0aVNcXV1ZsWIFZ86cuan7ubi4AJCcnHwr4V7XzfZzVkJDQxk4cCAAW7ZsyY3QRERE7mpKvImIiNwhZs2axblz51i/fn226jds2JB69eoRFxfH888/T2xsrL3s3LlzPP/88wA88cQT6abPvfzyyzg5OfHTTz8xe/bsdG3OmDGDOXPmZHq/5557jlKlSvHzzz8zcOBALl++nKHOqVOn+Oqrr7IVf2579913AXPR/NQRTFczDIONGzeyePHiXL1vyZIlefzxxzEMg+eff57z58/by2JiYnjuueeIj4+nQYMGNGjQIFfvfSsqVKiAk5MT27dvt2+0kerXX3/lk08+ydX7hYWF0a5dO+Li4mjXrh0RERHpypOTk5k3b579tYuLC8OHD8cwDDp06MCaNWsytJmSksKyZcvYsGFDjuMbP348586d4+DBgzecYgvmCLGXX36ZmJgY2rRpw/bt2zPUSUhIYN68eRlGn5UoUQLAIQnFm+3nZcuWsWDBApKSktLVMwyD3377DcjdKeMiIiJ3K001FRERuYt9//33PPTQQ8ydO5cyZcrQqFEjkpKSWL58OVFRUdSsWZPPPvss3TVhYWGMGjWKN954g44dO1KvXj1CQkLYv38/f/31F6+99lqmyRcvLy/mz5/Po48+yocffsiXX35JtWrVKFGiBLGxsezbt4/du3dTrFgx+7S126lNmzaMHz+e119/nbZt21KuXDkqVqyIn58fZ8+eZevWrZw5c4aBAwfyyCOP5Oq9P//8c/bs2cPGjRsJCQmhSZMmODs7s3LlSs6ePUuZMmWyHGF4uxUpUoQ+ffowfvx4mjZtyoMPPkhgYCB79+5l8+bNDB061J7EzC1TpkyhVatWbNiwgfLly9OgQQMCAwM5deoU27dv5+zZsxiGYa/fp08fIiIiGDNmDA8++CBVqlShXLlyeHh4cOrUKbZs2cKlS5f44osvuP/++3M11uz44IMPOHnyJN9//z1hYWFUr16dsmXL4uzszLFjx9iyZQsxMTH8/vvv6dZ569SpEx999BHNmjXjoYcesm9+MXr0aAoXLpzjuG6mn7dt28Zrr72Gr68vNWvWJDAwkLi4ODZv3syRI0fw8/PjnXfeyXFMIiIidzsl3kRERO5iZcuWZfPmzXz00UfMmTOH3377DavVSsWKFenSpQuvvPJKpgu1DxgwgIoVKzJmzBj++ecfdu7cSbVq1Zg5cya1atXKctRTlSpV2LZtGxMnTmT27Nls27aN9evXU6RIEUqUKEH//v3p0KGDox87S6+88goPPfQQEyZMYPny5SxduhSr1Urx4sWpUaMGrVu3vuXNF66ncOHCrFu3jk8//ZQff/yRxYsXY7PZKFOmDL1796Z///4ULFgw1+97qz755BOqVavG//3f/7Fp0ya2bNlC1apVmTFjBl26dMn1xFvBggVZuXIlkydP5vvvv2fLli2sW7eOYsWKERYWlukUzw8//JD27dvzf//3f6xZs4aFCxfi6upKQEAAjRs35tFHH6Vjx465Gmd2OTs789133/HUU0/x9ddfs3HjRnbs2IGXlxcBAQG0adOGtm3bppviDTBy5EisViuzZs1izpw5JCYmAjB06NBcSbzdTD+3adOGyMhIVq9ezf79+9mwYQMeHh4EBwczaNAgXnrpJfsIPREREcmaxbj614ciIiIiIiIiIiKSK7TGm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYiIiIiIiIiIuIASryJiIiIiIiIiIg4gBJvIiIiIiIiIiIiDqDEm4iIiIiIiIiIiAMo8SYi96TDhw9jsVho0aJFXociIiIick/r1asXFouFwoULk5CQkNfhiIjkKiXeREREREREJE9cvnyZn376CYvFwoULF5gzZ05ehyQikquUeBMREREREZE88eOPPxITE8Nrr72G1Wpl0qRJeR2SiEiuUuJNROQGjhw5wjPPPENQUBCurq6UKFGCZ555hoiIiAx1T548yauvvkr58uXx8PCgQIECVKpUiRdeeIHIyEh7vcjISIYNG0blypXx9vbG19eXcuXK0b17d44cOXI7H09EREQkz0yaNAlnZ2feeOMNmjRpwtKlS7P8LLRq1Srat2+Pv78/bm5uBAcH07FjR9asWZOunmEYTJkyhQcffJACBQrg6elJ+fLlef7559N9fitdujSlS5fO9F6NGzfGYrGkOzdixAgsFgsrVqxg6tSp1KxZE09PTxo3bgyYn+9Gjx5NeHg4gYGBuLq6EhgYyNNPP82BAwcyvU92Ym3YsCHOzs6cPHky0zaefvppLBYL69evz7RcRPKWc14HICKSn+3bt4+GDRty9uxZ2rRpQ5UqVdixYweTJ0/m119/Zc2aNVSoUAGA2NhYHnjgAQ4fPswjjzxChw4dSExM5NChQ0ybNo3+/fvj5+eHYRg0b96cjRs38sADD9CiRQusVitHjhxh3rx5dOvWjVKlSuXxk4uIiIg41q5du9iwYQOtWrXC39+fp59+mqVLlzJlyhRGjBiRru748eN57bXX8PDwoEOHDpQsWZLjx4+zZs0aZs6cScOGDQGw2Wx06dKFmTNnEhQURNeuXfH19eXw4cP89NNPtGzZkpIlS+Yo7jFjxrB8+XLatWvHI488gpOTEwC7d+9m2LBhNGnShA4dOuDl5cWePXv4/vvvmT9/Pps3b073GS+7sT7//POsXbuWKVOm8Oabb6aL5dKlS8ycOZMqVapQv379HD2XiDiIISJyDzp06JABGM2bN79uvSZNmhiA8b///S/d+c8//9wAjIceesh+bt68eQZg9O3bN0M7ly9fNuLj4w3DMIxt27YZgNG+ffsM9eLj443Lly/fyiOJiIiI3FH69etnAMYPP/xgGIb5ecnLy8soWbKkkZKSYq+3ZcsWw2q1GoGBgcahQ4fStWGz2Yzjx4/bX0+YMMEAjKZNmxqxsbHp6sbGxhrnz5+3vy5VqpRRqlSpTGMLDw83rv1xefjw4QZgeHl5Gdu2bctwzaVLl9K1n2rZsmWG1Wo1nn322XTnsxtrXFycUahQIaNs2bKGzWZLV++zzz4zAGPcuHGZPoeI5D1NNRURyUJERATLly+ncuXK9O7dO13ZCy+8QGhoKMuWLePo0aPpyjw8PDK05e3tjZub2w3rubm54e3tnQvRi4iIiORfSUlJTJs2DV9fX9q3bw+Yn5c6dOhAREQEf/zxh73u//73P2w2G++++26GqaEWi4XAwED76//7v//DycmJL774IsNnLQ8PDwoVKpTj2J977jmqVq2a4byfn1+m7Tdp0oQqVaqke6abidXd3Z3u3btz8OBBli1blq7epEmTcHNzo1u3bjl9LBFxECXeRESysGXLFgDCw8MzrPFhtVpp1KhRunqNGjUiICCADz74gNatW/PFF1+wa9cuDMNId22lSpWoVq0aP/zwA40aNWLs2LFs3rwZm83m8GcSERERyQ/mzp3L2bNnefzxx3F3d7eff/rppwHSbbLw559/AvDII49ct83o6Gh2795NmTJlKF++vAOiNtWtWzfLshUrVtC+fXsCAgJwcXHBYrFgsVjYvn07J06cuOVYn3vuOQC++uor+7lNmzbxzz//0KlTp1xJKIqIY2iNNxGRLERFRQHg7++faXlAQEC6en5+fmzYsIFhw4bx66+/smDBAgCCg4MZNGgQ//3vfwFwdnZm2bJljBgxgl9++YXXX38dgKJFi9KnTx+GDBliXytERERE5G6UmlhLTbSlatq0KUFBQcydO5cLFy5QqFAhIiMjsVgs9s9eWUndyCooKMgxQV+R1WfDn3/+mS5duuDt7U3z5s0pXbo0np6eWCwWpk6dmm7TiJuNNTQ0lPDwcObMmcP58+cpXLgwX3/9NUCGmRkikr9oxJuISBZ8fX0BOH36dKblp06dSlcPoGTJkkydOpWzZ8/yzz//MHr0aGw2Gy+99BI//PCDvV7hwoWZMGECx48fZ9euXXz22WcUKlSI4cOH8+GHHzrwqURERETy1tGjR1m8eDGQNrMg9XBycuL48eMkJCQwffp0AAoUKIBhGFnu6pnKz88PgOPHj2crDqvVSnJycqZlV+9Gf61rZ0KkGjFiBO7u7mzatImff/6ZMWPG8Pbbb9vP5yRWMJc6SUhI4NtvvyU2NpYffviB8uXL23dVFZH8SYk3EZEshIWFAebW9ddOFzUMg1WrVqWrdzWr1UpYWBhvvPGGPeE2b968DPUsFguVKlXipZdeYsmSJVnWExEREblbTJ06FZvNRsOGDXnmmWcyHN27dwfSRsWlTu1MTdZlxdvbm8qVK3Po0CH2799/wzgKFizImTNnMiTfYmJisnX9tQ4cOEClSpUyTB09efIkBw8ezFGsAB07dqRo0aJ8/fXX/Pzzz0RGRvLss8/edJwicnsp8SYikoWSJUvSpEkTdu7cyeTJk9OVffnll+zevZuHHnqI4OBgAHbu3Jnp6LjUc6m/6Tx8+DCHDx++YT0RERGRu41hGEyZMgWLxcI333zD119/neGYOnUq9evXZ9u2bfz999+88MILODk5MXTo0HTTNVPbu3rttJdeeomUlBT++9//EhcXl65ufHw8Fy5csL+uU6cOSUlJfPfdd+naGzx4MDExMTf9bKVKleLff/9N93kwPj6eF198kaSkpAz1byZWAFdXV3r06MGuXbt48803cXFxoUePHjcdp4jcXhbj2mEcIiL3gMOHD1OmTBkCAwN5+OGHM60TGhpKhw4daNiwIefPn6dt27ZUrlyZnTt3Mm/ePIoWLcqaNWuoUKECAOPGjWPAgAE88MADVKhQgcKFC3Pw4EH7CLbVq1dTu3Zt5syZQ8eOHalbty6VK1emePHiHD9+nDlz5hAdHc3s2bNp27btbesLERERkdtl6dKlNGvWjPDwcFasWJFlva+++ornnnuOF154gS+++ILPPvuMV155BU9PT9q3b0+pUqU4deoUq1atonXr1owbNw4wE2dPPPEEP/30E0FBQbRt2xZfX18iIiJYtGgRkyZNsu+iumPHDmrVqoXNZqNLly4ULVqU1atXc+nSJby9vdm6dWu6WQ8jRozg7bffZvny5ZlO7/zss894+eWXCQgI4LHHHiM5OZklS5ZgGEam7d1MrKkOHDhA+fLlMQyDTp06MXPmzFv9UojI7WKIiNyDDh06ZADXPcLDww3DMIzDhw8bPXv2NAICAgxnZ2cjICDA6Nmzp3H48OF0be7atct49dVXjRo1ahiFCxc23NzcjLJlyxrdu3c3du7caa939OhRY9CgQcb9999vFCtWzHB1dTVKlixpdOzY0Vi/fv3t7AYRERGR26pr164GYEyZMuW69SIjIw0PDw/Dz8/PiI2NNQzDMJYvX248+uijRqFChQxXV1ejRIkSRqdOnYy1a9emu9Zmsxlff/21cf/99xteXl6Gp6enUb58eeOFF14wIiIi0tVdtmyZUa9ePcPNzc0oXLiw0a1bN+P06dNGeHi4ce2Py8OHDzcAY/ny5ZnGbLPZjIkTJxpVqlQx3N3djeLFixvPPPOMcebMmUzbu9lYUzVs2NAAjIULF163D0Ukf9CINxEREREREZE7QHx8PCVKlMDb25uDBw9itWr1KJH8Tt+lIiIiIiIiIneAKVOmcP78eZ5//nkl3UTuEBrxJiIiIiIiIpKPffDBB5w9e5b//e9/eHl5sW/fPvz8/PI6LBHJBiXeRERERERERPIxi8WCi4sL1atXZ8KECdx///15HZKIZJNzXgcgIiIiIiIiIlnTeBmRO5cmhYuIiIiIiIiIiDiAEm8iIiIiIiIiIiIOoKmm2WCz2Thx4gQ+Pj5YLJa8DkdERETuEIZhcPnyZQIDA7X7XD6lz3kiIiJyK7L7OU+Jt2w4ceIEwcHBeR2GiIiI3KGOHj1KiRIl8joMyYQ+54mIiEhO3OhznhJv2eDj4wOYnenr65vr7SclJbF48WIeeeQRXFxccr39u536L2fUfzmj/ssZ9V/OqP9yztF9GBUVRXBwsP2zhOQ/+pyXv6n/ckb9lzPqv5xTH+aM+i9n8svnPCXesiF12oGvr6/DPpB5enri6+urb6ZboP7LGfVfzqj/ckb9lzPqv5y7XX2oKYz5lz7n5W/qv5xR/+WM+i/n1Ic5o/7LmfzyOU+LjYiIiIiIiIiIiDiAEm8iIiIiIiIiIiIOoMSbiIiIiIiIiIiIA2iNNxERERGR6zAMg+TkZFJSUm762qSkJJydnYmPj7+l6+916r+cyU7/OTk54ezsrLUoRUQcRIk3EREREZEsJCYmcvLkSWJjY2/pesMwKF68OEePHlVi4xao/3Imu/3n6elJQEAArq6utzE6EZF7gxJvIiIiIiKZsNlsHDp0CCcnJwIDA3F1db3p5I/NZiM6Ohpvb2+sVq3ycrPUfzlzo/4zDIPExETOnj3LoUOHKF++vPpZRCSXKfEmIiIi965z+3FPupjXUUg+lZiYiM1mIzg4GE9Pz1tqw2azkZiYiLu7uxIat0D9lzPZ6T8PDw9cXFw4cuSIva5IThmGQWxiCucvx3MhAY5fisPZOSmvw7rjJCcnq/9yIDk5meh80G1KvImIiMi9w5YCx/6CPfNh7wJczv9LqeLtgSfzOjLJx5Twkbud3uNyI4ZhcDkhmQvRiZyPSeRCTCIXYhLMv0ebr9POJ3I+JoH4JNuVq515e/PqPI3/zqb+y4lqhax0zuMYlHgTERGRu1tiLBxcAXvnw96FEHvOXmQ4ueKaEpN3sYmIiOQBm80gKj7Jniw7H31NMi3D+UQSU2w3bvgazlYLFsOG1cnJAU9xb7ClpKj/csDZcvPv21yPIa8DEBEREcl1Medg30LYswAOLIPkuLQydz8o3xxCW5FcKpztS1cTnHeRitwxSpcuTd++fenbt2+26q9YsYImTZpw8eJFChQo4NDYRO51KTaDS7HpR56ljUa7Jpl25c8Um3HT9/FwcaKQlyuFvV0p5GUehb1cKeTlRmHv1L+7UtjLjULerrhabPz++++0atUcFxcXBzz53S0pKYkFCxao/25Rav/lNSXeRERE5O5w/oB9CilHN4Jx1W84/UpCaCuo2ApKNQCnKx9ek/LBwh8iuexGG0AMHz6cESNG3HS7f/31F15eXtmu36BBA06ePImfn99N3+tWhYaGcujQIY4cOULx4sVv231Fcltyio0LVxJpV0/vPH9lVNq1o9EuxiZyC3k0vN2cr0mguVLI25UiXm72v1+dTPNwvbmRV0n6f1ZEiTcRERG5Q9lscHyTOYV0zwI4tzd9eUB1qNjaTLj53wc3uRulyJ3q5MmT9r//+OOPDBs2jL17074/vL297X83DIOUlBScnW/8Y0HRokVvKg5XV9fbmvxas2YNcXFxPPbYY3zzzTcMHDjwtt07M0lJSRqhInaJyTYuxiZyLjohwzTOdMm0K2WXYm8tYeXr7kxhb7cMybTC3m5pibUrI9YKerri7qIpjCKOpsSbiIiI3DmS4uHQSnNk276FEH06rczqDKUfhNDWULEl+JXIuzhF8tDVyS4/Pz8sFov9XOr0zwULFjB06FC2b9/O4sWLCQ4Opl+/fmzYsIGYmBgqVarEqFGjaNasmb2ta6eaWiwWvvrqK+bPn8+iRYsICgri448/pm3btunulTrVdOrUqfTt25cff/yRvn37cvToURo2bMiUKVMICAgAzB3o+vXrx7fffouTkxPPPPMMR48eJTY2lrlz5173uSdNmsR//vMfwsPDefXVVzMk3o4dO8aAAQNYtGgRCQkJVKpUic8//5x69eoB8Ouvv/LOO++wfft2vL29efDBB5k9e7b9WWfPnk379u3t7RUoUIBx48bRo0cPDh8+TJkyZZgxYwb/93//x8aNG5k4cSJt2rShT58+rFq1iosXLxISEsKbb75J165d7e3YbDY++ugjvvzyS44ePYq/vz/PP/88Q4YM4aGHHqJy5cp89tln9vpnz54lKCiI33//naZNm2brPSG5Lz4pxT6V83xMQvppnNEZk2mX45Nv+h4WCxTwcEmbumkfjZY6Ms3tqtForhT0csXFSRtliOQ3SryJiIhI/hZ7AfYtMke2/bsMkq7aDMHNF8o/bE4hLdcMPArkWZhybzAMg7iklGzXt9lsxCWm4JyYnOOdIz1cnG44jTS7Bg0axEcffUTZsmUpWLAgR48epVWrVrz33nu4ubnx7bff0qZNG/bu3UvJkiWzbOftt9/mww8/ZMyYMUyYMIEnn3ySI0eOUKhQoUzrx8bG8tFHHzFt2jSsVitPPfUU/fv357vvvgNg9OjRfPfdd0yZMoVKlSoxbtw45s+fT5MmTa77PJcvX+bnn39m48aNhIaGEhkZyerVq3nwwQcBiI6OJjw8nKCgIObNm0fx4sXZvHkzNps5JX3+/Pl06NCBIUOG8O2335KYmHhL6wINGjSIjz/+mBo1auDu7k58fDy1atVi4MCB+Pr6Mn/+fLp160ZISAh169YFYPDgwXz11Vd88sknNGzYkJMnT7Jnzx4Ann32Wfr06cPHH3+Mm5sbANOnTycoKIiHHnropuOTrMUmJnP+qoTZ+ehEzl6O4+8jVlbO2sGluOS0ZFp0IjGJ2f93IJXVgn3E2dXJtLS10dzSrZ9WwMMFZyXSRO54SryJiIhI/nPhkLlW254FELEejKt+wPENMke0hbaGUg3B2TXv4pR7TlxSCpWHLcqTe+96pzmerrnz8f2dd97h4Ycftr8uVKgQ1atXt78eOXIks2fPZt68efTp0yfLdnr06GEfvfX+++/z6aef8ueff9KiRYtM6yclJTFx4kRCQkIA6NOnD++88469fMKECQwePJgOHTrYX8+fP/+GzzNjxgzKly9PlSpVAHjiiSeYNGmSPfH2/fffc/bsWf766y97UrBcuXL269977z2eeOIJ3n77bfu5q/sju/r27UvHjh3Tnevfv7/97y+//DKLFi3ip59+om7duly+fJnx48fz2Wef0b17dwBCQkJo2LAhAB07dqRPnz7MnTuXzp07AzB16lR69OiRa0nYu5FhGEQnJHMhJpFz1+7WGZ1+gwHz7wnEJ2W186EVTpzItMTZakk3dbOQlzkCrXC6tdHc7CPS/DxcsFr1dRO51yjxJiIiInnPZoOT/5iJtr0L4Myu9OX+95mj2kJbQUCY1msTyaHatWunex0dHc2IESOYP38+J0+eJDk5mbi4OCIiIq7bTrVq1ex/9/LywtfXlzNnzmRZ39PT0550AwgICLDXj4yM5PTp0/aRYABOTk6EhYXd8HkmT57MU089ZX/91FNPER4ezoQJE/Dx8WHLli3UqFEjy5F4W7ZsoXfv3je8z41c268pKSm8//77/PTTTxw/fpzExEQSEhLw9PQEYPfu3SQkJGQ5ZdTd3Z1u3boxefJkOnfuzObNm9mxYwfz5s3Lcax3EsMwiIpL5lyGTQWu2a3zqs0GElOySqRlzdXZmm4dtEKeLkSeOU6tKhUo6uuRLsFWyMsVX3dnJUBF5IaUeBMREZG8kZwAh1abU0j3/g6X0xaEx+Jk7j6aul5bwdJ5FqbI1TxcnNj1TvNs17fZbFyOuoyPr0+uTDXNLdfuTtq/f3+WLFnCRx99RLly5fDw8OCxxx4jMTHxuu1cu3mAxWKxT9/Mbn3DuIWtGK+ya9cuNmzYwJ9//pluXbeUlBRmzJhB79698fDwuG4bNyrPLM7Mdmu8tl/HjBnD+PHjGTduHFWrVsXLy4u+ffva+/VG9wVzumlYWBjHjh1jypQpPPTQQ5QqVeqG1+VnNpvBpbgkLsQk2EekpY1GuyaZFpPIxZhEkm9hy04PF6d0UzcLe7nZ/55u4wEvNwp5u+Llmn46d1JSEgsWHKVVeFltlCEit0yJNxEREbl94i7C/iXm5gj/LoXEy2llrt5Qrqm5E2n5h8Ez85EpInnJYrHc1HRPm81GsqsTnq7OOU68OdLatWvp0aOHfYpndHQ0hw8fvq0x+Pn54e/vz19//UWjRo0AM3m2detWatSokeV1kyZNolGjRnz++efpzk+ZMoVJkybRu3dvqlWrxtdff82FCxcyHfVWrVo1li5dSs+ePTO9R9GiRdPtFrt//35iY2Nv+Exr166lXbt29tF4NpuNffv2UblyZQDKly+Ph4cHS5cu5dlnn820japVq1K7dm2++uorvv/++3QbLeQXySk2LsYmXRl1lpY4S7fBwFWj0S7GJnILeTS83ZyvWRMtbXpnoXTTO81kmoerduwUkbynxJvIvcwwsBzfTMnzq+B0SQisBlZ9QBGRXHYp4soU0vlwZB3YrtrZzbt42nptZRqBs1vexSlyDytfvjyzZs2iTZs2WCwW3nrrreuOXHOUl19+mVGjRlGuXDlCQ0P59NNPuXTpUpbT+ZKSkpg2bRrvvPMO9913X7qyZ599lrFjx7Jz5066du3K+++/T/v27Rk1ahQBAQH8888/BAYGUr9+fYYPH07Tpk0JCQnhiSeeIDk5mQULFthH0D300EN89tln1K9fn5SUFAYOHJitEVDly5dn5syZrFu3joIFCzJ27FhOnz5tT7y5u7szcOBA3njjDVxdXXnggQc4e/YsO3fu5Jlnnkn3LH369MHLy8ueHHWkxGQbF2MTr2w2kD5xdu1unRdiErkUm3H0X3b4ujtT+OqdOb0zSaZddd7NWZ9TReTOo8SbyL3o0lHY9iNsnYHz+f3UAPj6a3N3wOC6ULK+eQTVBJcbT4EQEUnHMODk1rTNEU5vT19etJK5VlvF1hBYA/LxKCCRe8XYsWPp1asXDRo0oEiRIgwcOJCoqKjbHsfAgQM5deoUTz/9NE5OTvTu3ZumTZvad/S81rx58zh//nymyahKlSpRqVIlJk2axNixY1m8eDGvv/46rVq1Ijk5mcqVK9tHyTVu3Jiff/6ZkSNH8sEHH+Dr62sfdQfw8ccf07NnTx588EECAwMZP348mzZtuuHzDB06lIMHD9K8eXM8PT157rnnaN++PZGRkfY6b731Fs7OzgwbNowTJ04QEBDACy+8kK6drl270rdvX7p27Yq7u3u2+vJqhmEm01JsNpJtBskphvmnzUZKikFCQjxnLycwfNJGdp+N53J88o0bvYbFAgU8XCjs7XbNNM7U0Whu6c4V9HLFRTt2isg9QIk3kXtFwmXYNQ+2/gCHV9tPGy6eXHANolDSCSwJUfDvH+YB4ORq/lBc8n4zERdcT1O/RCRzyYlwZM2VkW2/Q9SxtDKL1fw3JHVzhEJl8y5OkXtMjx496NGjh/1148aNM11TrXTp0ixbtizduZdeeind62unnmbWzqVLl7K817WxALRv3z5dHWdnZyZMmMCECRMASE5OplKlSnTp0iXT5+vUqRMpKSmZloG5/luqUqVKMXPmzCzrduzYMcOOpKkCAwNZtCj9brZXP2vp0qUz7Y9ChQoxZ86cLO8JYLVaGTJkCEOGDMmyzrlz54iPj083Cu5GUmwGp6PiuRADtujrJ1GN5GQSkm0cvxTH5XizP60WrjON86rdOq+MRivo6YqTduwUEclAiTeRu5ktBQ6thK0zYPevkHTVWiSlH4TqXUku35I1S1fTqsUjuJzfCxEbIGKd+Wf0aTi60TzWjjevK1rJTMSVamD+WaBk3jybiOS9+Ehzvba9C2D/H5CQNoIDF08IecicQlq+OXgVzrs4ReSOceTIERYvXkx4eDgJCQlMmDCBI0eO0LVr17wOLU8kJSVx/vx5hg4dyv3330/NmjWzdV1UXBLHL8WRdNXOnhaLBWerBSer+aez1Yqzk/nalmQlxcuVT7qEUcjXm8Jervh5uGBVIk1EJMeUeBO5G53ZbY5s2/ZT+l0CC5eD6l2hWue0hFnqjlxWZwgMM4/7XzDnJFw8BEfWQ8R6MxF3fj+c3W0em6aY1/mWuDIi7sqouGKVNW1M5G4Wecwc0bZnPhxeA7ar1vXxKgYVW5hTSMuGa6q6iNw0q9XK1KlT6d+/P4ZhcN999zF79mwqVaqU16HlibVr19KkSRMqVKhw3dF6qZJSbJy4FEdknPlvs6uTFT8XG0UL+uBktWa5Vl58PFxydaJMiQK3NJVVRESypsSbyN0i5hxsn2km3E5uSTvvURDu6wTV/2Ou2ZbFB64MLBZzOlihslDjSfNc9Fk4uuHKqLj1cGKLOZ1sx0zzAHDzg5L1riTiGphTVV30AU7kjmUYcHpH2uYIJ7emLy9S4coU0tYQVFuJdxHJkeDgYNauXWt/bbPZ8mStufwiq6nB1zIMgwsxiZyKjCfFMLBgoYiPK8W83bh8OQqrxZJl0k1ERBxLiTeRO1lSPOxbaE4l/XdJ2k6BVmeo0AKqPwHlH8m9XQK9i0KlNuYBkBgDx/5Om5569C9zqtn+xeYBV9aJqwmlrmzYEFzXTAaKSP6VkmTuPrp3gXlciriq0GKu95i6OUKRcnkWpoiIQHxSCscuxhGbaH4O9HR1JqiABx6uTnmyM62IiKSnxJvIncYw4Nhf5si2Hb+YayylCqxpTiW9r9PtWU/J1cucTlY23HydkgyntqWNiItYDzFXRskd3QB8AljM6aipU1NL1Qe/Eo6PVUSuL+GyubHKngVm4jz+UlqZs7u5XlvFVmZS37tonoUpIiImm83gzOUEzkYnYBgGVouF4n7uFPZy1eg2EZF8RIk3kTvFxSOw7Ucz4XbhYNp53yCo1sUc3Va0Yt7FB+DkbE5nDaoJ9f9rJgkvHDQTcKlrxV04AGd2msffk8zr/ILTEnEl60PRUE1XE7kdok6mjWo7tApSEtPKPAtDhZbmyLayTcDVM+/ilDvG559/zpgxYzh16hTVq1dnwoQJ1K1bN9O6SUlJjBo1im+++Ybjx49TsWJFRo8eTYsWLex1Ll++zFtvvcXs2bM5c+YMNWrUYPz48dSpU8deJzo6mkGDBjFnzhzOnz9PmTJleOWVV3jhhRcc/rwieSU6Ponjl+JJSDZ3IPV1dyGwgAeuzvr8JCKS3yjxJpKfxUfBrrnmVNIja9LOu3hB5bZmsq30g2B1yrsYr8digcIh5lHjKfNc9Jm0zRoi1sPJbRB5FLYfhe0/m3XcC1y1YUMDc8OH3JouK3IvMwxz85W9882RbSc2py8vFJI2hTS4bv79t0XypR9//JF+/foxceJE6tWrx7hx42jevDl79+6lWLFiGeoPHTqU6dOn89VXXxEaGsqiRYvo0KED69ato0aNGgA8++yz7Nixg2nTphEYGMj06dNp1qwZu3btIigoCIB+/fqxbNkypk+fTunSpVm8eDH//e9/CQwMpG3btre1D0QcLTnFxsnIeC7Gmr8ocXGyEljAAz8PlzyOTEREsqLEm0h+k5IMB1eYI9v2/AbJ8VcKLOaUzupdIfRRcPPOyyhvnXcxqNzOPAASos2ps6mJuGN/mVPc9i00DwAnNwiqlbZOXIk64FEgr55A5M6SkgxHN5qj2vbMN3crvlqJOmmbIxSpkP0NWESuMXbsWHr37k3Pnj0BmDhxIvPnz2fy5MkMGjQoQ/1p06YxZMgQWrVqBcCLL77IH3/8wccff8z06dOJi4vjl19+Ye7cuTRq1AiAESNG8Ouvv/LFF1/w7rvvArBu3Tq6d+9O48aNAXjuuef43//+x59//qnEm9w1DMPgUlwSJy/Fk3xl3bbC3m4U93XDSbMERETyNSXeRPKL0zvNZNu2nyH6VNr5IhXMZFu1LuAXlHfxOYqbN4Q0MQ8wF3U/tS1tamrEBog9Z27eELHuykUW8L8vbVRcqQbgG5hnjyCS7yTGwIFl5qi2fQsh7kJamZMblG1sjmyr0BJ8/PMsTLl7JCYmsmnTJgYPHmw/Z7VaadasGevXr8/0moSEBNzd0+967eHhwZo15gjv5ORkUlJSrlsHoEGDBsybN49evXoRGBjIihUr2LdvH5988kmW901ISLC/Tt0xMykpiaSkpHR1k5KSMAwDm812y4vUp+5ImdqO3Bz1HySm2DhxKZ7oBHPzBHdnJ4IKuOPhao5Kvl6/ZLf/bDYbhmGQlJSEk5NGO6dK/Tfh2n8bJPvUhzmj/ssZR/dfdttV4k0kL0WfMadXbv0BTm1PO+9RCKo+bk4lDaxxb41AcXIxR7cF1YIGfcypcef/TT899cJBOL3dPP76yryuQMm0NeJK1jcTlvoNsNxLos/A3t/NkW0HlkNKWmIBj4LmpggVW5mbJNypI2Yl3zp37hwpKSn4+6dP5Pr7+7Nnz55Mr2nevDljx46lUaNGhISEsHTpUmbNmkVKirlmlY+PD/Xr12fkyJFUqlQJf39/fvjhB9avX0+5cmm76U6YMIHnnnuOEiVK4OzsjNVq5auvvrKPkrvWqFGjePvttzOcX7x4MZ6e6dcydHZ2pnjx4kRHR5OYmJjhmptx+fLlHF2fFx599FGqVq3KqFGjAKhWrRovvvgiL774YpbXFCxYkOnTp9O6desc3fvadu7E/sspw4DLSRCZCAZgAfxcwcclhaT4GJLib9RCmhv1X2JiInFxcaxatYrk5OQcxX03WrJkSV6HcMdTH+aM+i9nHNV/sbGx2aqXLxNvN7MwL8DPP//MW2+9xeHDhylfvjyjR4+2T1sALbor+UxSvPmD8dYZ5g6ChvkDBlYXqNjCHN1W7mFwds3bOPMLiwWKlDePmk+b5y6fupKE22COgju1HS5FmMe2H806HgWvJOGubNoQEKY+lbvPuf2UO/0bTlMnwPG/MX80u6JgaXOtttBWEHy/ufmJSD4yfvx4evfuTWhoKBaLhZCQEHr27MnkyZPtdaZNm0avXr0ICgrCycmJmjVr0rVrVzZt2mSvM2HCBDZs2MC8efMoVaoUq1at4qWXXiIwMJBmzZpluO/gwYPp16+f/XVUVBTBwcE88sgj+Pr6pqsbHx/P0aNH8fb2zjDyLrsMw+Dy5cv4+Pjctp0m27ZtS1JSEr///nuGstWrV9O4cWP++ecfqlWrdt12nJ2dcXV1tffLX3/9hZeXV4YE5bU8PDwy9GVW3n77bebOncvmzenXnDx+/DgFCxbE1dXV4f0XFxdHcHAwVquVo0eP4uaW9+vKxiWlcPxSPPFJ5udEbzdnAgu44+p0c79UzO77Lz4+Hg8PDxo1anTL7/W7UVJSEkuWLOHhhx/GxUXr6N0K9WHOqP9yxtH9lzpq/kby3afwm12Yd926dXTt2pVRo0bx6KOP8v3339O+fXs2b97MfffdB2jRXckHDMNMEm39AXbOgYTItLISdcyRbVU6gmehPAvxjuJTHKq0Nw+AhMvm2nCp01OP/Q1xF9N2awRwdoeg2lemptaHEnXBPXs/FIjkG7YU872+Zz7sXYDL+X+pcnV5YA1zrbaKraFYpXtrtKzkqSJFiuDk5MTp06fTnT99+jTFixfP9JqiRYsyZ84c4uPjOX/+PIGBgQwaNIiyZcva64SEhLBy5UpiYmKIiooiICCALl262OvExcXx5ptvMnv2bPvIqGrVqrFlyxY++uijTBNvbm5umSZWXFxcMnwoT0lJwWKxYLVasd7iKOrU6X2p7dwOzz77LJ06deLEiROUKFEiXdk333xD7dq1CQsLy1ZbV8d97YjGrNxMf6Umg66tHxhoLiFxO/pv9uzZVKlSBcMwmDdvHl26dHHIfbIjOcXGiYsxXIo3E27OVgsBfh4U8HS5pcRjdvvParVisVgy/T6QzP99kJujPswZ9V/OOKr/sttmvpuHdfXCvJUrV2bixIl4enqm++3n1caPH0+LFi0YMGAAlSpVYuTIkdSsWZPPPvvMXufqRXdLly7Nc889R/Xq1fnzzz9v12PJverCIVjxAXwaBlNawOZvzKSbXzA82B/6bIJn/4A6zyrplhNuPub0uYeGQI/fYPBReHYpPPKumYDwKGRuUnFkDaz+CKZ3gtGlYGJDWPAG7JgFUSfz+ilEMpcYa67VNvcl+KgCTG4O6z6F8/9iOLly2qcaKS0+hH674bkV0GgA+FdW0k1uK1dXV2rVqsXSpUvt52w2G0uXLqV+/frXvdbd3Z2goCCSk5P55ZdfaNeuXYY6Xl5eBAQEcPHiRRYtWmSvk7ou27UJBScnp3t2PTAwp4gWLVqUqVOnpjsfHR3Nzz//zDPPPMP58+fp2rUrQUFBeHp6UrVqVX744Yfrtlu6dGnGjRtnf71//377CKnKlStnOpVn4MCBVKhQAU9PT8qWLctbb71lXxNn6tSpvP3222zduhWLxYLFYrHHbLFYmDNnjr2d7du389BDD+Hh4UHhwoV57rnniI6Otpf36NGD9u3b89FHHxEQEEDhwoV56aWXsrX+zqRJk3jqqad46qmnmDRpUobynTt38uijj+Lr64uPjw8PPvggBw4csJdPnjyZKlWq4ObmRkBAAH369AHg8OHDWCwWtmzZYq976dIlLBYLK1asAGDFihVYLBZ+//13wmrUxMPDnSXLV3L08CH6936KJjUqEOxfiLp16/LHH3+kiyshIYGBAwcSHByMm5sb5cqVY9KkSRiGQbly5fjoo4/S1d+yZQsWi4V///33hn0iIiK5J1+NeLuVhXnXr1+fbroAmGuGXP0ftSMX3c0NWjAxZ/Jd/8VHYdk9B+v2n7Ae3WA/bbh6YYS2w1atM0bJBmC58kNCHsed7/ovt/hXN486L9jXibMc3YD16AYsRzdiuXTYnKJ6ajv8+T8AjAKlMYLrYQuuhxFcHwqXu2Hy4q7tv9tE/ZeFmHNY/l2Mdd/vWA6uwJIcZy8y3P0wQpphq9CSxJKN2LBqAw9XuzJ8Xv140/LLort3g379+tG9e3dq165N3bp1GTduHDExMfZdTp9++mmCgoLs64Vt3LiR48ePExYWxvHjxxkxYgQ2m4033njD3uaiRYswDIOKFSvy77//MmDAAEJDQ+1t+vr6Eh4ezoABA/Dw8KBUqVKsXLmSb7/9lrFjxzrmQQ0DkrK3pgsANptZP9Ep52uPunhmK6nu7OzM008/zdSpUxkyZIh9pNTPP/9MSkoKXbt2JTo6mlq1ajFw4EB8fX2ZP38+3bp1IyQk5LpLvKQ9lo2OHTvi7+/Pxo0biYyMpG/fvhnq+fj4MHXqVAIDA9m+fTu9e/fGx8eHN954gy5durBjxw4WLlxoTyr5+fllaCMmJoaWLVtSv359/vrrL86cOcOzzz5Lnz590iUXly9fTkBAAMuXL+fff/+lS5cuhIWF0bt37yyf48CBA6xfv55Zs2ZhGAavvfYaR44coVSpUoA55bVRo0Y0btyYZcuW4evry9q1a+3roH3xxRf069ePDz74gJYtWxIZGcnatWtv2H/X6jfgDfq++Q4lSpamcOGC2C6fo1P7Nowd8wFubm58++23tGnThr1791KyZEnA/J5av349n376KdWrV+fQoUOcO3cOi8VCr169mDJlSrqfk6ZMmUKjRo3SrZEoIiKOl68Sb7eyMO+pU6cyrX/qVNqukI5cdDc3acHEnMnL/rMYKRSN2kHwhTUERG7GyTB/0DKwcNanCkcLNeSkXy1SnNxgZxTsXJhnsWbl3nj/FQbn1lCmNe5JFykUvY/CMfsoFL0Pv7gILJcOY7l0GOt2c524BGcfLniV57xXRS54V+CSZykMS+b/bN4b/ec46j/wij9F8cjNBERuplDMfixXrdcW61KYUwVqctKvJue9K5rvw8PAYTO5r/7LubxedPdu0KVLF86ePcuwYcM4deoUYWFhLFy40P45LSIiIt3ItPj4eIYOHcrBgwfx9vamVatWTJs2jQIFCtjrREZGMnjwYI4dO0ahQoXo1KkT7733XrqpHTNmzGDw4ME8+eSTXLhwgVKlSvHee+85bi3fpFh4P/s7aVuBArl17zdPgKtXtqr26tWLMWPGsHLlSho3bgyYiZdOnTrh5+eHn58f/fv3t9d/+eWXWbRoET/99FO2Em9//PEHe/bsYdGiRfZpoe+//z4tW7ZMV2/o0KH2v5cuXZr+/fszY8YM3njjDTw8PPD29rZvYpGVmTNnEh8fz7fffouXl/n8n332GW3atGH06NH291jBggX57LPPcHJyIjQ0lNatW7N06dLrJt4mT55My5YtKViwIGD+An/KlCmMGDECMNee9vPzY8aMGfb3XYUKFezXv/vuu7z++uu8+uqr9nN16tS5Yf+Buf5aZJy5accLrw2mQaOHKOrjSjEfd6zW0jSoW9ted+TIkcyePZt58+bRp08f9u3bx08//cSSJUvsU6qvnqbdo0cPhg0bxp9//kloaChJSUl8//33GUbBiYiI4+WrxJujOHLR3dygBRNzJk/779R2rNt/xLpzFpaYM/bTRtFQbFW7YKvyGAV9AygIXH/54ryj958pOT4Ky/G/zdFwR9djObEZt+TLBFxJhAAYzh4YQbUwguthBN+PEVSbJKu7+i8H7un3n2HDcmIzln2/myPbzu1LX+xfFVuFltgqtMTF/z6CLRaCr2ninu6/XJJfFt29W/Tp08c+ze5aqVPrUoWHh7Nr167rtte5c2c6d+583TrFixdnypQpNxXnvSA0NJQGDRowefJkGjduzL///svq1at55513AHP9uvfff5+ffvqJ48ePk5iYSEJCQrZ/ybx7926Cg4PtSTcg02nFP/74I59++ikHDhwgOjqa5OTkm/48vW/fPqpXr25PugE88MAD2Gw29u7da0+8ValSBScnJ3udgIAAtm/fnqG9VCkpKXzzzTeMHz/efu6pp56if//+DBs2DKvVypYtW3jwwQcz/ffhzJkznDhxgqZNm97U8wAkJqdw4GwM56LNxFut2rUpV8wbD1cz/ujoaEaMGMH8+fM5efIkycnJxMXFERERAZjTRp2cnAgPD8+0/cDAQFq3bs2UKVMYPXo0v/76KwkJCTz++OM3HauIiORMvkq83crCvMWLF79ufUcvupubtGBizty2/rt8Crb/bO5KenpH2nnPIlD1caj+BJaA6jhZLDhl3Uq+c8+//1wKQ2hz8wBIToSTW81dUyM2QMR6LHEXsRxZY64VB2Cx4ux/H/elFMf132ScyzQEn+wtPC3p3TPvv6R4OLTS3Bxh30KIvur/L6szlG5orktYsSWWAsE4Qbb+Hbln+s+B8nrRXbmDuHiaI8+yyWazEXX5Mr4+PjnfHMDl5mZePPPMM7z88st8/vnnTJkyhZCQEHuiZsyYMYwfP55x48ZRtWpVvLy86Nu3L4mJiTmL8Srr16/nySef5O2336Z58+b2kWMff/xxrt3jatd+v1ksluuu9bdo0SKOHz+eYTOFlJQUli5dysMPP4yHh0eW11+vDNI2jDCMtBHMCQlm/x67GEfxxGT7gttVSha1J90A+vfvz5IlS/joo48oV64cHh4ePPbYY/avz43uDeYmG926dWPEiBFMnTqVLl26OHT2joiIZC5fJd6uXpi3ffv2QNrCvFn99rR+/fosXbo03ZoSS5Yssf/GTYvuSq5IijN/UN76AxxYBsaV946TK1RsBdW7Qrmm4KQfsO4azq4QXMc8HnjVXKPn3D5z19SIDWZC7lIEllPbCGEbzFpsXlewDJRqYO6eWjJ768TJXS72AuxbBHvnw7/LICkmrczNF8o1M3ciLdcMPArkWZgikk0WS7anewLm/x8uKeY1t2lX01SdO3fm1Vdf5fvvv+fbb7/lxRdftK/3tnbtWtq1a8dTTz11JUwb+/bto3Llytlqu1KlShw9epSTJ08SEBAAwIYNG9LVWbduHaVKlWLIkCH2c0eOHElXx9XVlZSUlOveq0KFCvzwww/ExMTYR72tXbsWq9VKxYoVsxVvZiZNmsQTTzyRLj6A9957j0mTJvHwww9TrVo1vvnmG5KSkjIk9nx8fChdujRLly6lSZMmGdovWrQoACdPnqRGjRpExycxf8U6AAzAz8OFEoXMRNi1O5auXbuWHj160KFDB8AcAXf48GF7edWqVbHZbKxcuTLTgQQArVq1wsvLi8mTJ7No0SJWrVqV/c4REZFck68Sb3DzC/O++uqrhIeH8/HHH9O6dWtmzJjB33//zZdffgnk0aK7cnew2cwky9YfYNdcSLhqulBwPaj+BFTpAB4F8y5GuX2sVigWah61zX+PiDxO8uG1RKz+kTLWU1jO7ISLh8xjy3dmHc8iaUm4UvWheDUlaO8FFw7B3gXmbqQR68G46odK3yCo2NJM2pd+0Ezyiog4gLe3N126dGHw4MFERUXRo0cPe1n58uWZOXMm69ato2DBgowdO5bTp09nO/HWrFkzKlSoQPfu3RkzZgxRUVEZEljly5cnIiKCGTNmUKdOHebPn8/s2bPT1SldujSHDh1iy5YtlChRAh8fnwwzTx5//HFGjx5N9+7dGTFiBGfPnuXll1+mW7duGdZ6zq6zZ8/y66+/Mm/ePO677750ZU8//TQdOnTgwoUL9OnThwkTJvDEE08wePBg/Pz82LBhA3Xr1qVixYqMGDGCF154gWLFitGyZUsuX77M2rVrefnll/Hw8OD+++9n1KgPcC9YnMPHTvLJB+8C4O/rTqnCXhxyyjwZW758eWbNmkWbNm2wWCy89dZb6QYNlC5dmu7du9OrVy/75gpHjhzhzJkz9unZTk5OdO/enXfeeYfy5cvfcIdhERFxjHyXeLvZhXkbNGjA999/z9ChQ3nzzTcpX748c+bMSfcf6G1fdFfubOcPmNNIt82ASxFp5wuUNEe2VesChUPyLj7JP/yCMCp3YPthN4JbtcIlJRaO/pk2Ku7Y3xB7Dvb8Zh5gThMqURtKXhkVV6IOuHnn7XNIztlscPIfM9G2dwGcuWbdKv/7zERbaCsICNMoSBG5bZ555hkmTZpEq1at0q3HlrqxRfPmzfH09OS5556jffv2REZGZqtdq9XK7NmzeeaZZ6hbty6lS5fm008/pUWLFvY6bdu25bXXXqNPnz4kJCTQunVr3nrrLfvGBQCdOnVi1qxZNGnShEuXLjFlypR0CUIAT09Pfv/9d1577TXq1KmDp6cnnTp1ytEv0VM3ashsfbamTZvi4eHB9OnTeeWVV1i2bBkDBgwgPDwcJycnwsLCeOCBBwDo3r078fHxfPLJJ/Tv358iRYrw2GOPAeYU008+n8iLzz1H64caUiqkHMNHvs9/OrbB2+36P4aNHTuWXr160aBBA4oUKcLAgQMzrBn5xRdf8Oabb/Lf//6X8+fPU7JkSd588810dXr16sWoUaMy9KmIiNw+FuPqRQckU1FRUfj5+REZGemwzRUWLFhAq1attBbMLciV/ou7CDtnmwm3oxvTzrv6QJX2ZsKtZP3bPkXkdtD7L2eu23/JCXBiy5VE3JVkXPyl9HUsThBQzXx/laxvJuO8i92u8PPcHf3+S06AQ6vNKaR7f4fLJ9PKLE7mlONQc702CpZ2SAh3dP/lE47uQ0d/hpCcu97XKD4+nkOHDlGmTBnc3d1vqX2bzUZUVBS+vr45X+PtHnSn9l9CcgrHL8YRnZAMgLuLE0EFPPC6QcItt61cuZKHH36YI0eO2KcEZyY33ut3I/0/m3Pqw5xR/+VMfvmcl+9GvIncNilJ8O8f5lTSvb9DypXFhC1WCGlqTiWt2ApctQit3CJnNyhZzzzoe2WduL1wJHXDhg0QGQEn/jGPDf9nXlcoxJyWmpqMK1RWI6Tyi7iLsH+Juebjv0sh8XJamau3udZjxdZQ/mHwLJR3cYqISJ6wGQbnohM4E5WAzTCwWiwU83WjiLcb1tv4f3lCQgJnz57lnXfeoV27drc8JVdERHJOiTe5txiGuVPl1hnmzqSx59LKilWBsK7mzqQ+me+iK5IjVisUq2QedZ4xz0Ues++aypH15hTFCwfM45/pZh2vYunXifOvCk765/u2uRRxZQrpfDNpaktOK/Mubo5oC21trtfmolECIiL3qtiEZI5diiM+yVzX09vNmaACHri53P597n/44QeeeeYZwsLCmDBhwm2/v4iIpNFPbnJviDoB234yE25nd6ed9yoKVTubCbfiVfMuPrl3+ZWAqo+ZB5gjqo7+Ze6aGrEBjm+CmDOwe555ALh4mbut2teJq31zO+zJ9aUm6FM3Rzi9PX150UrmWm0VW0NgjbtyCrqIiGRfis3GqagEzkcnAOBstRDg50EBT5cMu5XeLj169KBHjx72qboiIpJ3lHiTu1dijDkdbMv3cHAF5sbtgJObOTqlelcIeUgjhyR/8SgIFR4xD4CkeHMaauoacUc3QHyk+Z4+uMKsY3GCgOrmmmKpI+O8iuTVE9yZkhPhyJorI9t+h6hjaWUWq9mnqZsjFCqbd3GKiEi+EhmXxIlLcSSlmDuOFvR0JcDPHecsdisVEZF7jzIOcnex2cwfnrfOgF1zITE6raxkfTPZVrkdeBTIsxBFboqLuzm9tFR987XNZo7aTJ2aGrEeoo7Dic3msf4zs17h8mYSLjUZV7CM1om7VnykuV7b3gWw/w9IuGonPxdPMzEf2hrKNwevwnkXp4iI5DtJyTZORMYRGZcEgKuzlRIFPPB21+LnIiKSnhJvclfwjj+JdcX7sONniDyaVlCwtJlsq9ZZo1Tk7mC1gn8V86jzrHnu0tH0O6ee2QXn95vHP9PMOt7F00bDlbzfnFptvf1rzuS5yGPmiLY98+HwGrAlpZV5FYOKLcwppGXDwcUj7+IUkXzFMIy8DkHyCcMwuBCTyKnIeFIMAwsWivq4UszHHav1zv0Fl97jIiKOo8Sb3LliL8COX3Da8gNNT2xKO+/mB1XaQ9h/ILieRvnI3a9AsHlU62y+jr0AR/9MS8Yd3wzRp2DXHPMAcPW5sk7clZ1Tg2rdnTv4Ggac3pG2OcLJrenLi1S4MoW0NQTV1nptIpKOi4s5eik2NhYPDyXj73VxSSkcvxhHbKK5yY6nqzNBBT3wyIPNE3JbbGwskPaeFxGR3KPEm9xZkhPh3yWw9QfYuxBsSVgBG1Yo1xRr2H/MHQY1UkXuZZ6FrozcamG+Tooz14k7cmXDhqMbISEKDiwzDwCrMwSEmVNaS9aH4Pvv3OmVKUnms+5dYB6XIq4qtJgJ+dTNEYqUy7MwRST/c3JyokCBApw5cwYAT0/Pm14s32azkZiYSHx8PFYl929afug/m83gfEwCF2OSMDCwWiwU8XajgKcTlpQk4lOSbtxIHrlR/xmGQWxsLGfOnKFAgQI4Od35SUQRkfxGiTfJ/wzDXLtq6wzYPhPiLqSVFa9Kyn2dWXKqAE3bdcWq39KJZOTiYa71VqqB+dqWYk5HjdiQtlbc5RNw/G/zWDfBrFekYtr01FL1oUCp/DuCNOEy/PuHObJt/2KIv5RW5uxurtdWsRVUaAHeRfMsTBG58xQvXhzAnny7WYZhEBcXh4eHR57tcHkny+v+S0hK4WJsEsk2cyqmh4sTBTxduBRr4dJtj+bmZbf/ChQoYH+vi4hI7lLiTfKvyGOw7Scz4XZub9p5b39zSl21J6D4fdiSkkhYsCDv4hS501idzDXeileFur3N5PaliLREXMR6OLvH/L47txc2f2Ne5xNwJRF3ZcMG/yp5u05c1EnYd2W9tkOrICUxrcyzMFRoaY5sK9vk7pxGKyK3hcViISAggGLFipGUdPMjm5KSkli1ahWNGjXSNL5bkFf9dyk2kYkrD7Bk12kAini78fJD5ahd/s765U12+s/FxUUj3UREHEiJN8lfEqJh96/mVNJDq4ArC706e0ClR6H6E1CmMTjprSuSaywWKFjKPKp3Mc/FXjCnpKZOTz3xD1w+CTtnmweAmy8E100bFRdUy7HTvA0Dzuw212rb+zsc35S+vFBI2hTS4Lr35uYRIuIwTk5Ot5SccHJyIjk5GXd3dyXebsHt7j/DMJj9z3FG/raLi7FJWCzQvX5pXn+kAj534I6lev+JiOQ9ZS8k79lS4PBqc2TbrnmQFJNWVqqhmWyr3A7cffMuRpF7jWchc73Eii3N14mx5pTv1KmpR/8014n79w/zALC6QGANMxFXqoG5lppnoZzFkZJsJgD3LjBHtl08lL68RJ20zRGKVMi/U2FFRCTfO3wuhiFztrP23/MAhBb3YVTHqtQoWTCPIxMRkTuZEm+Sd87uNUe2bfsJoo6nnS9UFqp3hWpdzBE4IpL3XD2hdEPzADNhfnpn2tTUI+vNnVOP/Wke6z416xUNTds5teT9UKDkjZNjiTHmpg97FsC+henXdXRyg7LhZrKtYkvw0Xo0IiKSM0kpNr5cdZBPl+4nIdmGm7OVvs0q8OyDZXBx0oYYIiKSM0q8ye0Vcx52/AJbvzenrqVy94P7OpkJtxJ1NGpFJL+zOkFANfOo97w5DfTi4avWidtgrg93do95bJpiXucblDY1tWR9KHhlV9HoM3DwD3Nk24HlkJKQdi+PglC+uTmNNKQpuHnf9scVEZG70+aIi7w5azt7Tl0GoGG5IrzX4T5KFfbK48hERORuocSbOF5yAuxbZE4l3b8IbMnmeaszlHsYwrqaP1S7uOdtnCJy6ywWKFTGPMK6mudizpnTRFNHxJ3cYo5u3fGLeQDObr40thbA+Z+j2Nd0BHMH1dDW5si2kvW1rqOIiOSqy/FJjFm0l2kbjmAYUMjLlbcerUT7sCDtPisiIrlKP8mIYxiGufD51h/MH7DjLqaVBYSZI9vu6wTed9bOUCJyE7yKmMmz0Nbm68RY89+F1OmpR//EkhCFH1FmeWANc2OE0FZQrLJGvoqIiEMs2nmK4XN3cioqHoBONUswpHUlCnm55nFkIiJyN1LiTXLXpQjY9qM5uu38v2nnfQKgWmcz4VasUt7FJyJ5x9UTyjxoHgApySQd38KWZbMJa/M8LoVL5m18IiJyVzsZGcfwuTtZvOs0AKULe/Jeh6o8UK5IHkcmIiJ3MyXeJOcSLpu7kW79wdydNJWLJ1RqY+5KWibcXBNKRCSVkzMEVOdEweOE+QbkdTQiInKXSrEZfLfxCB8u3Et0QjLOVgsvhIfQ56FyuLvo86mIiDiWEm9ya2wpcHCFObJt96+QHJdWVvpBc2Rb5bbg5pNnIYqIiIjIvW33ySgGz9rOlqOXAKhZsgCjOlajYnF9RhURkdtD+2PLzTmzG5YMg0+qwPSOsP0nM+lWuBw89Bb03Q49foMaTyrpJiIico/5/PPPKV26NO7u7tSrV48///wzy7pJSUm88847hISE4O7uTvXq1Vm4cGG6OpcvX6Zv376UKlUKDw8PGjRowF9//ZWhrd27d9O2bVv8/Pzw8vKiTp06RERE5PrzyZ0jPimF0Qv30GbCGrYcvYSPmzMj29/HzBcaKOkmIiK3lUa8yY1Fn4UdM82ppCe3pp33KGhukFD9PxBUUwuhi4iI3MN+/PFH+vXrx8SJE6lXrx7jxo2jefPm7N27l2LFimWoP3ToUKZPn85XX31FaGgoixYtokOHDqxbt44aNWoA8Oyzz7Jjxw6mTZtGYGAg06dPp1mzZuzatYugoCAADhw4QMOGDXnmmWd4++238fX1ZefOnbi7a7f0e9Wa/ecYMmc7R87HAtCiSnFGtK1CcT+9J0RE5PZT4k0ylxQP+xaaybb9S8BIMc9bnaFCC3PdtvKPgLNb3sYpIiIi+cLYsWPp3bs3PXv2BGDixInMnz+fyZMnM2jQoAz1p02bxpAhQ2jVqhUAL774In/88Qcff/wx06dPJy4ujl9++YW5c+fSqFEjAEaMGMGvv/7KF198wbvvvgtgb+PDDz+0tx0SEuLox5V86Hx0Au/N382sf44DUNzXnXfaVeGRKsXzODIREbmXKfEmaQwDjv5pJtt2zoL4yLSywJrmum33dQKvwnkXo4iIiOQ7iYmJbNq0icGDB9vPWa1WmjVrxvr16zO9JiEhIcOoNA8PD9asWQNAcnIyKSkp161js9mYP38+b7zxBs2bN+eff/6hTJkyDB48mPbt22d534SEBPvrqKgowJz6mpSUdHMPng2pbTqi7XtBdvrPMAxmbznBBwv3cTE2CYsFutUryWvNyuHt5nxP973efzmj/ss59WHOqP9yxtH9l912lXgTuHgYtv1kJtwuHEw77xsE1bqYo9uKVsyz8ERERCR/O3fuHCkpKfj7+6c77+/vz549ezK9pnnz5owdO5ZGjRoREhLC0qVLmTVrFikp5ih7Hx8f6tevz8iRI6lUqRL+/v788MMPrF+/nnLlygFw5swZoqOj+eCDD3j33XcZPXo0CxcupGPHjixfvpzw8PAM9x01ahRvv/12hvOLFy/G09Mzp12RpSVLljis7XtBVv13Ng5+PGhlf5S5dHWgp8ETZVMoZTnIqqUHM73mXqT3X86o/3JOfZgz6r+ccVT/xcbGZqueEm/3qvhI2DXX3JX0yNq08y5e5m6k1Z8wdye1aot1ERERyX3jx4+nd+/ehIaGYrFYCAkJoWfPnkyePNleZ9q0afTq1YugoCCcnJyoWbMmXbt2ZdOmTYA54g2gXbt2vPbaawCEhYWxbt06Jk6cmGnibfDgwfTr18/+OioqiuDgYB555BF8fX1z/TmTkpJYsmQJDz/8MC4uLrne/t0uq/5LTLYxae1hPv/rIAnJNtycrbzyUAg9G5TCxUn7x6XS+y9n1H85pz7MGfVfzji6/1JHzd+IEm/3kpRkOLjCHNm25zdIjr9SYIGy4eZU0tBHwc07L6MUERGRO0yRIkVwcnLi9OnT6c6fPn2a4sUzX1+raNGizJkzh/j4eM6fP09gYCCDBg2ibNmy9johISGsXLmSmJgYoqKiCAgIoEuXLvY6RYoUwdnZmcqVK6dru1KlSvbpqNdyc3PDzS3jGrUuLi4O/aHG0e3f7a7uv01HLvLmrO3sPX0ZgAfLF+Hd9vdRqrBXXoaYr+n9lzPqv5xTH+aM+i9nHNV/2W1Tibd7wakdZrJt+88QfdUH4iIVzGRbtS7gF5R38YmIiMgdzdXVlVq1arF06VL72mo2m42lS5fSp0+f617r7u5OUFAQSUlJ/PLLL3Tu3DlDHS8vL7y8vLh48SKLFi2yb6Tg6upKnTp12Lt3b7r6+/bto1SpUrnzcJJvRMUnMWbhXqZvPIJhQCEvV4Y9Wpl2YYFYLJa8Dk9ERCRTSrzdraLPmIm2LT/A6e1p5z0KQdXHzamkgTVAH1JEREQkF/Tr14/u3btTu3Zt6taty7hx44iJibHvcvr0008TFBTEqFGjANi4cSPHjx8nLCyM48ePM2LECGw2G2+88Ya9zUWLFmEYBhUrVuTff/9lwIABhIaG2tsEGDBgAF26dKFRo0Y0adKEhQsX8uuvv7JixYrb+vziWIt3nead+Xs4HWVujPFYrRIMaVWJgl6ueRyZiIjI9SnxdjdJioO9C8x12/5dCoa5ODFWF6jYwhzdVu5hcNYHFBEREcldXbp04ezZswwbNoxTp04RFhbGwoUL7RsuREREYLWmrb0VHx/P0KFDOXjwIN7e3rRq1Ypp06ZRoEABe53IyEgGDx7MsWPHKFSoEJ06deK9995LN7WjQ4cOTJw4kVGjRvHKK69QsWJFfvnlFxo2bHjbnl0c52RkPF/vsbJ9/VYAShf25P0OVWlQrkgeRyYiIpI9Srzd6QwDIjaYU0l3zoGEyLSyEnXMkW1VOoJnoTwLUURERO4Nffr0yXJq6bUj0MLDw9m1a9d12+vcuXOmU0+v1atXL3r16pXtOCX/S7EZTFt/mDGL9hKTaMXZauGF8BD6PFQOdxdt/iUiIncOJd7uVBcOwtYfYdsMuHg47bxfsLlmW/WuUKRcnoUnIiIiInIrdp+MYtCs7Ww9egmA0t4Gn/eoT5US+kWyiIjceZR4u5PEXYJdc8x1245uSDvv6g2V25uj20o9AFZtoS4iIiIid5a4xBTGL93P16sPkmwz8HFzpv8j5fE9u50K/j55HZ6IiMgtUeItv0tJggPLzKmkexZAirmgLBYrlG1sjmwLbQ2u2j5dRERERO5Mq/efZcjsHURciAWg5X3FGdG2CoU8nFiwYPsNrhYREcm/lHjLjwwDTm03N0nY/hPEnE0rK1oJwrqaO5P6BuZdjCIiIiIiOXQ+OoF35+9m9j/HAQjwc+eddvfxcGVzU46kpKS8DE9ERCTHlHjLTy6fgt2zzYTbmZ1p5z2LmIm26k9AQHWwWPIuRhERERGRHDIMg182H+fd+bu4FJuExQI9GpTm9Ucq4u2mH1FEROTuof/V8lpyIpads7j/389x3rIDDJt53skVKraE6v+Bck3BySVv4xQRERERyQWHzsUwZPZ21h04D0ClAF9GdaxKWHCBvA1MRETEAZR4ywecFg3CP+6i+SK4njmyrUoH8CiYt4GJiIiIiOSSxGQbX646wKfL/iUx2Ya7i5XXmlWgV8MyuDhpczAREbk7KfGW15xdsdV9kX/37qRshzdx8Q/N64hERERERHLVpiMXGDxrO/tORwPwYPkivNe+KiULe+ZxZCIiIo6lxFs+YGvYjz1RCyhbKCSvQxERERERyTVR8Ul8uHAP322MwDCgsJcrbz1amXZhgVi0brGIiNwD8uWY7s8//5zSpUvj7u5OvXr1+PPPP69b/+effyY0NBR3d3eqVq3KggULMtTZvXs3bdu2xc/PDy8vL+rUqUNERISjHkFERERE5J5lGAa/bz9Js49XMn2DmXR7vFYJ/ugXTvsaQUq6iYjIPSPfJd5+/PFH+vXrx/Dhw9m8eTPVq1enefPmnDlzJtP669ato2vXrjzzzDP8888/tG/fnvbt27Njxw57nQMHDtCwYUNCQ0NZsWIF27Zt46233sLd3f12PZaIiIiIyD3hxKU4en+7iRe/28yZywmUKeLF973rMebx6hT0cs3r8ERERG6rfDfVdOzYsfTu3ZuePXsCMHHiRObPn8/kyZMZNGhQhvrjx4+nRYsWDBgwAICRI0eyZMkSPvvsMyZOnAjAkCFDaNWqFR9++KH9upAQTesUEREREcktKTaDb9cf5qNFe4lJTMHFycKL4SH8t0k53F2c8jo8ERGRPJGvEm+JiYls2rSJwYMH289ZrVaaNWvG+vXrM71m/fr19OvXL9255s2bM2fOHABsNhvz58/njTfeoHnz5vzzzz+UKVOGwYMH0759+0zbTEhIICEhwf46KioKgKSkJJKSknLwhJlLbdMRbd8L1H85o/7LGfVfzqj/ckb9l3OO7sP89rXZuHEj9erVy+sw5C6060QUg2dtY+uxSABqlSrIqI5VqeDvk8eRiYiI5K18lXg7d+4cKSkp+Pv7pzvv7+/Pnj17Mr3m1KlTmdY/deoUAGfOnCE6OpoPPviAd999l9GjR7Nw4UI6duzI8uXLCQ8Pz9DmqFGjePvttzOcX7x4MZ6ejtt5acmSJQ5r+16g/ssZ9V/OqP9yRv2XM+q/nHNUH8bGxjqk3VtVv359ypUrR7du3XjyyScpW7ZsXockd7i4xBTGLd3H16sPkWIz8HFzZlCrULrWKYnVqnXcRERE8lXizRFsNhsA7dq147XXXgMgLCyMdevWMXHixEwTb4MHD043ii4qKorg4GAeeeQRfH19cz3GpKQklixZwsMPP4yLi0uut3+3U//ljPovZ9R/OaP+yxn1X845ug9TR83nF9OnT+e7775j5MiRjBgxgvvvv59u3brRuXNnChUqlNfhyR1m1b6zDJmznaMX4gBoVbU4w9tUwd9X6yiLiIikyleJtyJFiuDk5MTp06fTnT99+jTFixfP9JrixYtft36RIkVwdnamcuXK6epUqlSJNWvWZNqmm5sbbm5uGc67uLg49AcbR7d/t1P/5Yz6L2fUfzmj/ssZ9V/OOaoP89vX5T//+Q//+c9/OHfuHDNmzOD777/nv//9L3379qVFixY89dRTtG3bFldXLYAvWTsXncC7v+1izpYTAAT6ufNOu/toVtn/BleKiIjce/LVrqaurq7UqlWLpUuX2s/ZbDaWLl1K/fr1M72mfv366eqDOV0ktb6rqyt16tRh79696ers27ePUqVK5fITiIiIiOR/RYoUoU+fPqxbt479+/czZMgQ9uzZQ5cuXShevDjPPfdclr+glHuXYRj89PdRmo1dyZwtJ7BaoOcDpVncL1xJNxERkSzkqxFvAP369aN79+7Url2bunXrMm7cOGJiYuy7nD799NMEBQUxatQoAF599VXCw8P5+OOPad26NTNmzODvv//myy+/tLc5YMAAunTpQqNGjWjSpAkLFy7k119/ZcWKFXnxiCIiIiL5hoeHB56enri7u2MYBhaLhblz5zJp0iRq1qzJN998k2HmgNx7Dp6NZsjsHaw/eB6ASgG+fNCxKtWDC+RtYCIiIvlcvku8denShbNnzzJs2DBOnTpFWFgYCxcutG+gEBERgdWaNlCvQYMGfP/99wwdOpQ333yT8uXLM2fOHO677z57nQ4dOjBx4kRGjRrFK6+8QsWKFfnll19o2LDhbX8+ERERkbx2+fJlZs6cyXfffcfKlSuxWq20bNmSYcOG0aZNG6xWK7Nnz+b111+nZ8+ebNy4Ma9DljySmGzjfysPMGH5vyQm23B3sfJaswr0algGF6d8NXlGREQkX8p3iTeAPn360KdPn0zLMhul9vjjj/P4449ft81evXrRq1ev3AhPRERE5I40d+5cvvvuO3777Tfi4+OpU6cO48aN44knnqBw4cLp6j722GNcvHiRl156KY+ilbz29+ELDJ61nf1nogFoVKEo77W/j+BCnnkcmYiIyJ0jXybeRERERCT3dejQgeDgYF577TWefvppKlaseN361atX58knn7xN0Ul+ERmXxIcL9/DdxggACnu5MqxNZdpWD8RiseRxdCIiIncWJd5ERERE7hHLli2jcePG2a5ft25d6tat67iAJF8xDIPfd5xixLydnLmcAEDn2iV4s1UlCnhqp1sREZFbocSbiIiIyD3iZpJucm85cSmOYXN38MfuMwCULeLFex2qUj+k8A2uFBERkevRiqgiIiIi94ihQ4cSFhaWZXmNGjV4++23b19AkudSbAaT1xyi2diV/LH7DC5OFl55qBwLXn1QSTcREZFcoBFvIiJyT0hJSSEpKSmvw8hVSUlJODs7Ex8fT0pKSl6Hc0fKaR+6uLjg5OTkgMgcY+bMmXTo0CHL8latWvHjjz8yfPjwW2r/888/Z8yYMZw6dYrq1aszYcKELKeqJiUlMWrUKL755huOHz9OxYoVGT16NC1atLDXuXz5Mm+99RazZ8/mzJkz1KhRg/Hjx1OnTp1M23zhhRf43//+xyeffELfvn1v6RnuJTtPRDJ41na2HYsEoHapgozqWJXy/j55HJmIiMjdQ4k3ERG5qxmGwalTp7h06VJeh5LrDMOgePHiHD16VAue36Lc6MMCBQpQvHjxO+JrEBERQUhISJblZcqU4ciRI7fU9o8//ki/fv2YOHEi9erVY9y4cTRv3py9e/dSrFixDPWHDh3K9OnT+eqrrwgNDWXRokV06NCBdevWUaNGDQCeffZZduzYwbRp0wgMDGT69Ok0a9aMXbt2ERQUlK692bNns2HDBgIDA28p/ntJXGIK4/7Yx9drDpFiM/Bxd2ZQy1C61imJ1Zr/38ciIiJ3EiXeRETkrpaadCtWrBienp53RHIku2w2G9HR0Xh7e2O1avWIW5GTPjQMg9jYWM6cMdfECggIcESIucrb2/u6ibVDhw7h7u5+S22PHTuW3r1707NnTwAmTpzI/PnzmTx5MoMGDcpQf9q0aQwZMoRWrVoB8OKLL/LHH3/w8ccfM336dOLi4vjll1+YO3cujRo1AmDEiBH8+uuvfPHFF7z77rv2to4fP87LL7/MokWLaN269S3Ff69Yue8sQ+ds5+iFOABaVw1geJvKFPO9ta+7iIiIXJ8SbyIictdKSUmxJ90KF7771iqy2WwkJibi7u6uxNstymkfenh4AHDmzBmKFSuW76edNm7cmP/973+88MILGUaMHT16lC+//JImTZrcdLuJiYls2rSJwYMH289ZrVaaNWvG+vXrM70mISEhQ5LPw8ODNWvWAJCcnExKSsp164D5NezWrRsDBgygSpUqNx37veJcdAIjf9vF3C0nAAj0c2dk+/toWsk/jyMTERG5uynxJiIid63UNd08PT3zOBK5m6W+v5KSkvJ94m3kyJHUrVuXKlWq8Mwzz9gTVTt27GDy5MkYhsHIkSNvut1z586RkpKCv3/6JI6/vz979uzJ9JrmzZszduxYGjVqREhICEuXLmXWrFn2tfZ8fHyoX78+I0eOpFKlSvj7+/PDDz+wfv16ypUrZ29n9OjRODs788orr2Qr1oSEBBISEuyvo6KiAPPr54h1IFPbzKs1Jg3DYObmE4xetJfIuGSsFuhevxSvPhSCl5tzvl/7Mq/7706n/ssZ9V/OqQ9zRv2XM47uv+y2q8SbiIjc9e6m6aWS/9xJ76+KFSuyevVqXn75ZT755JN0ZY0aNeLTTz+lUqVKtyWW8ePH07t3b0JDQ7FYLISEhNCzZ08mT55srzNt2jR69epFUFAQTk5O1KxZk65du7Jp0yYANm3axPjx49m8eXO2vw6jRo3KdOfWxYsXOzRJv2TJEoe1nZUzcfDjQSv/RpmjOYM8DZ4ISaGkcYCVSw/c9nhyIi/6726i/ssZ9V/OqQ9zRv2XM47qv9jY2GzVU+JNRERE5B5SrVo1Vq5cyblz5zh48CAAZcuWpUiRIrfcZpEiRXBycuL06dPpzp8+fZrixYtnek3RokWZM2cO8fHxnD9/nsDAQAYNGkTZsmXtdUJCQli5ciUxMTFERUUREBBAly5d7HVWr17NmTNnKFmypP2alJQUXn/9dcaNG8fhw4cz3Hfw4MH069fP/joqKorg4GAeeeQRfH19b7kPspKUlMSSJUt4+OGHcXFxyfX2M5OYbOPL1Yf44q9DJCbb8HCx8mrTcnS/vyTOTnfWtPS86L+7ifovZ9R/Oac+zBn1X844uv9SR83fiBJvIiIi94jSpUvTt29f+vbtm636K1asoEmTJly8eJECBQo4NDa5/YoUKZKjZNvVXF1dqVWrFkuXLqV9+/aAufba0qVL6dOnz3WvdXd3JygoiKSkJH755Rc6d+6coY6XlxdeXl5cvHiRRYsW8eGHHwLQrVs3mjVrlq5u8+bN6datm32Th2u5ubnh5uaW4byLi4tDf6hxdPup/j58gcGztrP/TDQA4RWK8m77+wgudGdPub9d/Xe3Uv/ljPov59SHOaP+yxlH9V9221TiTUREJJ+50ZS54cOHM2LEiJtu96+//sLLyyvb9Rs0aMDJkyfx8/O76XvdDCX4br9jx47xzz//EBkZic1my1D+9NNP33Sb/fr1o3v37tSuXZu6desybtw4YmJi7Amwp59+mqCgIEaNGgXAxo0bOX78OGFhYRw/fpwRI0Zgs9l444037G0uWrQIwzCoWLEi//77LwMGDCA0NNTeZuHChTNsnOLi4kLx4sWpWLHiTT/DnSwyLonRC/fw/cYIAIp4u/LWo5VpWz3wjpoOLSIicrdR4k1ERCSfOXnypP3vP/74I8OGDWPv3r32c97e3va/G4ZBcnIyrq6uN2y3aNGiNxWHq6trltME5c4UHx9P9+7d+eWXX7DZbFgsFgzDANInfG8l8dalSxfOnj3LsGHDOHXqFGFhYSxcuNC+4UJERES6nWPj4+MZOnQoBw8exNvbm1atWjFt2rR0ydfIyEgGDx7MsWPHKFSoEJ06deK9997Tb/2vYhgGC7afYsSvOzl72dw0okvtYAa3CqWA543/XRARERHHytEiDxEREem2cwfYunUrTz/9NF26dGHOnDk5aV5EROSeVLx4cfvh5+eHxWKxv96zZw8+Pj78/vvv1KlTB39/f9asWcOBAwdo164d/v7+eHt7U6dOHf7444907ZYuXZpx48bZX1ssFr7++ms6dOiAp6cn5cuXZ968efbyFStWYLFYuHTpEgBTp06lQIECLFq0iEqVKuHt7U2LFi3SJQqTk5N55ZVXKFCgAIULF2bgwIF0797dPv3wVly8eJGnn36aggUL4unpScuWLdm/f7+9/MiRI7Rp04aCBQvi5eVFlSpVWLBggf3aJ598kqJFi+Lh4UH58uWZMmXKLcdyp3vzzTeZNWsW7733HitWrMAwDL755hsWL15My5YtqV69Olu3br3l9vv06cORI0dISEhg48aN1KtXz162YsUKpk6dan8dHh7Orl27iI+P59y5c3z77bcEBgama69z584cOHCAhIQETp48yWeffXbDEZiHDx/O9nTqO93xS3E8+83fvPT9Zs5eTqBsUS9mPHc/ox+rpqSbiIhIPpGjxNsrr7ySbqrL6dOnadKkCbNmzWLVqlV06tSJWbNm5TRGERGRXGMYBrGJybf9SB1VlFsGDRrE+++/z8aNG6lWrRrR0dG0atWKpUuX8s8//9CiRQvatGlDRETEddt5++236dy5M9u2baNVq1Y8+eSTXLhwIcv6sbGxfPTRR0ybNo1Vq1YRERFB//797eWjR4/mu+++Y8qUKaxdu5aoqKgc/yKuR48e/P3338ybN4/169djGAatWrWyb+H+0ksvkZCQwKpVq9i+fTujR4+2jwp866232LVrF7///ju7d+/miy++yLV1ze5EM2fOpGfPngwcOJAqVaoAEBQURLNmzfjtt98oUKAAn3/+eR5HKTeSYjOYtOYQD49dydI9Z3BxsvBK0/IseOVB7i9b+MYNiIiIyG2To6mmf/75J6+++qr99bfffktcXBw7duygTJkytGjRgo8++oiOHTvmOFAREZHcEJeUQuVhi277fXe90xxP19xb4eGdd97h4YcfJioqCl9fX4oUKUL16tXt5SNHjmT27NnMmzfvuovb9+jRg65duwLw/vvv8+mnn/Lnn3/SokWLTOsnJSUxceJEQkJCAHOE0zvvvGMvnzBhAoMHD6ZDhw4AfPbZZ/bRZ7di//79zJs3j7Vr19KgQQMAvvvuO4KDg5kzZw6PP/44ERERdOrUiapVqwKk2xUzIiKCGjVqULt2bcAc9XcvO3PmDHXr1gXAw8MDgJiYGHt5p06deOedd/jiiy/yJD65sR3HI3lz9na2HYsEoE7pgrzfoSrl/X3yODIRERHJTI5GvF24cIFixYrZX//222+Eh4cTEhKC1WqlY8eO7NmzJ8dBioiISHqpiaRU0dHR9O/fn0qVKlGgQAG8vb3ZvXv3DUe8VatWzf53Ly8vfH19OXPmTJb1PT097Uk3gICAAHv9yMhITp8+bU/sADg5OVGrVq2berar7d69G2dn53RTFgsXLkzFihXZvXs3YI7Af/fdd3nggQcYPnw427Zts9d98cUXmTFjBmFhYbzxxhusW7fulmO5G/j7+3P+/HnA/FoWLFgw3fqBUVFRxMfH51V4ch2xicm8v2A37T5fy7Zjkfi4OzOqY1V+fK6+km4iIiL5WI5+9V60aFGOHDkCwKVLl9iwYQMffPCBvTw5OZnk5OScRSgiIpKLPFyc2PVO8zy5b266dnfS/v37s2TJEj766CPKlSuHh4cHjz32GImJiddt59pF6i0WS6a7XF6vfm5Po71Zzz77LM2bN2f+/PksXryYUaNG8fHHH/Pyyy/TsmVLjhw5woIFC1iyZAlNmzblpZde4qOPPsrTmPNKvXr1WLNmDQMHDgSgTZs2jBkzhoCAAGw2G5988gn3339/Hkcp11qx9wxD5+zg2MU4AFpXC2D4o5Up5uuex5GJiIjIjeQo8dasWTM+/fRTfH19WbFiBTabLd3iybt27SI4ODinMYqIiOQai8WSq1M+84u1a9fSo0cP+xTP6OhoDh8+fFtj8PPzw9/fn7/++otGjRoBkJKSwubNmwkLC7ulNitVqkRycjIbN260TzU9f/48e/fupXLlyvZ6wcHBvPDCC7zwwgsMHjyYr776ipdffhkwf1HYvXt3unfvzoMPPsiAAQPu2cTbK6+8ws8//0xCQgJubm6MHDmS9evX061bNwBCQkL49NNP8zhKSXX2cgIjf9vFvK0nAAgq4MHI9lV4KNQ/jyMTERGR7MrRTx4ffPAB+/bto3///ri6uvLRRx9RpkwZABISEvjpp5/4z3/+kyuBioiISNbKly/PrFmzaNOmDRaLhbfeeuu6I9cc5eWXX2bUqFGUK1eO0NBQJkyYwMWLF7FYLDe8dvv27fj4pE2Zs1gsVK9enXbt2tG7d2/+97//4ePjw6BBgwgKCqJdu3YA9O3bl5YtW1KhQgUuXrzI8uXLqVSpEgDDhg2jVq1aVKlShYSEBH777Td72b2oYcOGNGzY0P46ODiY3bt3s337dpycnAgNDcXZ+e5LTN9pDMPgp7+P8v6CPUTGJWG1QM8HytDv4Qp4uenrIyJ3iCPrcfp7MoXjywGt8joakTyTo/+5/f39Wbt2LZGRkXh4eODqmrZtuc1mY+nSpRrxJiIichuMHTuWXr160aBBA4oUKcLAgQOJioq67XEMHDiQU6dO8fTTT+Pk5MRzzz1H8+bNcXK68VTb1FFyqZycnEhOTmbKlCm8+uqrPProoyQmJtKoUSMWLFhgn/aakpLCSy+9xLFjx/D19aVFixZ88sknALi6ujJ48GAOHz6Mh4cHDz74IDNmzMj9B78DxMbG8tRTT9GpUyeefPJJ+3mr1ZpuYw7JWwfORvPmrO1sPGTuLlwl0JcPOlajagm/PI5MRCSbbCmweiyseB+rYeMBLNhWJUOTQWDN3aU3RO4EufIrMz+/jB8EPDw89CFOREQkh3r06EGPHj3srxs3bmxfU+3qEW2lS5dm2bJl6a596aWX0r2+duppZmuzXbp0KdN7ZRYLQPv27dPVcXZ2ZsKECUyYMMEeY6VKlejcuXOWz3jtfa5VsGBBvv322yzLU++VmaFDhzJ06NAsy+8lnp6e/PHHH7Rs2TKvQ5FMJCSnMHHFQT5f/i+JKTY8XJzo93AFej5QGmenHO2HJiJy+1w+DbN6w6GVABjF7sNyZgdOqz+Eo+uh41fgG5DHQYrcXjn6X3zp0qWMGTMm3bnJkydTsmRJ/P39ee2110hJSclRgCIiInLnOHLkCF999RX79u1j+/btvPjiixw6dEhLT+QTDRs2ZP369Xkdhlzjz0MXaDV+NZ/8sY/EFBuNKxZl8WuN6N2orJJuInLnOLAMJj5gJt1cPKH9FyT3XsGmUs9juHjB4dUwsSH8+0deRypyW+Xof/IRI0awdetW++vt27fz/PPPU7RoURo3bsynn356zy5eLCIici+yWq1MnTqVOnXq8MADD7B9+3b++OOPe3pdtfzks88+Y/Xq1QwdOpRjx47ldTj3vMjYJAbP2k7n/63nwNkYini7MqFrDab0qENwIc+8Dk9EJHtSkmHpOzCtI8SchWJV4LkVEGb+0u1YoQdIfmYp+FeF2HMwvRMsGc7/s3fn8TGd7R/HPzOTPZHEGkmEEPsatZWqpQ2xFFFKl1+pqq3VVvWhtChtPap9qlS1ulK6aa1VrS32fUkotbTUGmKXkMg+vz9GhlQQJmOyfN+v13nFOXPPmetcxrhzzX3um/RUx8Ytco/YdKvp3r176dKli3V/5syZeHt7s3btWjw8POjfvz8zZsywLlkvIiIiBVtQUBDr1693dBhyE3Xq1CEtLY1x48Yxbtw4nJyccHV1zdLGYDAQFxfnoAgLB7PZzKJdJxn9yx7OXk4G4PEGQQxrWxVfD5fbPFtEJA+JOw6ze8OxTZb9er2gzThwds/arnhFeG45LH0Dtn4J6yfCkQ3Q9SvwLXvPwxa5l2wqvCUkJODt7W3dX7x4MW3atMHDw/INXYMGDfj2229ti1BEREREckWXLl1ytMKs2M/xC4mMWvAnK/adBqBCSU/Gda5FowrFHRyZiMgd2v87zB8AVy6Aqzd0mAQ1H715e2c3aP8BlG8GC16E41sst552+gSqPXLv4ha5x2wqvAUFBbF161aeffZZDhw4wO7du3n11Vetj58/f/6Gb1FFRERExDGmT5/u6BAKrbT0DL7Z9A8fLP2LK6npuJiMDGgRwvMtQ3B10ip/IpKPpKXA8jdh0yeWff9QeGwaFKuQs+dX7wT+dWD2sxCzHWY9BQ37Qeu3wUn1Ayl4bCq8PfXUU7z11lvExMTw559/UrRoUTp16mR9fPv27VSuXNnmIEVERERE8qtjl6Hr55v588QlABoGF+O/j9akYqkiDo5MROQOnf/HUjA7EW3Zv/95CBt95wWzosHQazGseAs2TIYtn1luV+06DYqH5HbUIg5lU+HtjTfeICUlhd9++42yZcsyffp0fH19Actot1WrVvHyyy/nRpwiIiIiYqMZM2bkqF2PHj3sHEnhkJyWznuL9/P1LhNmLuHt5sTwdtXoXj8Io1G3/IpIPrN7Lix8GZLjwb0oRHwKVdre/fmcXKD1OxDcDOb1g5M74bPm0GEi1Oqaa2GLOJpNhTcnJyfGjh3L2LFjb3isWLFixMbG2nJ6EREREclFzzzzzE0fu37uNxXecoeT0ci2IxcxY6B9zdK82akGpYq4OTosEZE7k3oFFg+H7dMs+0H3WxZF8CmTO+ev3BoGrIc5z8GR9TCnNxxaDW3Gg4tWeJb8z6bC2/UuX77MsWPHAMvcb15eXrl1ahERERHJBYcOHbrhWHp6OocPH+aTTz7h6NGjfPPNNw6IrGAyGQ38N6I6C5avY0j32jg7Ozs6JBGRO3NmP/zcC07/CRjgwcHQ4nUw5VopwcI7AHr8Amveg9XvQdQMOLYVHpsOparm7muJ3GNGW0+wdetWWrZsSdGiRalZsyY1a9akaNGiPPTQQ2zbti03YhQREZG70KJFCwYNGmTdDw4OZuLEibd8jsFgYP78+Ta/dm6dR3JXuXLlbtgqVKjAQw89xOzZsylZsiQff/yxo8MsUCr7FaFGUbOjwxARuXM7vofPW1iKbp4l4em58PCo3C+6ZTI5QcvXoccC8PKDM3strx81E8z6HJX8y6bC2+bNm2nWrBlRUVE899xzfPjhh3z44Yc899xzREVF0axZM7Zs2ZJbsYqIiBQKHTp0oE2bNtk+tnbtWgwGA3/88ccdn3fr1q307dvX1vCyGD16NKGhoTccP3nyJG3b2jDvSw5cP7es5I5HHnmEWbNmOToMERFxpOTLMLcfzB8AqYlQvjn0Xw8hD92b169w3eulXYFfBsLcPpB86d68vkgus3lxhcDAQNatW0fp0qWzPDZ69GgeeOAB3njjDZYtW2ZTkCIiIoVJ79696dKlC8ePH6dMmazzp0ybNo369etTu3ZtMjIy7ui8JUuWzM0wb+nf/QLJHw4ePEhycrKjwxAREUeJ3QU/PwPnDoDBaBmB1nQwGE33Ng6vkvDUHFg/EVa8A7t+hpgoeGwa+Ne5t7GI2MjmEW/9+vXLtnPt5+dH37592bRpky0vISIiUug88sgjlCxZkunTp2c5fvnyZX7++Wd69+7NuXPnePLJJ6levTpeXl7UqlWLH3744Zbn/fetpn///TfNmjXDzc2N6tWrZ/tF2WuvvUblypXx8PCgQoUKjBw5ktTUVMAy4mzMmDHs3LkTg8GAwWCwxvzvW0137drFQw89hLu7O8WLF6dv375cvnzZ+vgzzzxDREQE//vf//D396d48eK88MIL1te6G0ePHqVTp054eXnh7e1Nt27dOHXqlPXxnTt38vDDDxMUFISvry/16tWzTpNx5MgROnToQNGiRfH09KRGjRr89ttvdx1LXrFmzZpst19++YX//Oc/fPTRR3YfqSgiInmQ2Qxbv4QvHrYU3YoEwDOLoNmQe190y2Q0WuaU6/U7+ATB+YPwZRhs/ly3nkq+YtOIN6PRSFpa2k0fT09Px2i0eRo5ERGR3GM2W26buNecPeC6VSNvxcnJiR49ejB9+nTeeOMN62qTP//8M+np6TzxxBNcvnyZevXq8cILL+Dv78/vv//O008/TUhICA0bNrzta2RkZPDoo4/i5+fH5s2biYuLyzIfXKYiRYowffp0AgIC2LVrF3369KFIkSIMHTqU7t27s3v3bhYvXszy5csB8PHxueEcCQkJhIeH07hxY7Zu3crp06d57rnnGDhwYJbi4sqVK/H392flypUcOHCA7t27ExoaSp8+fXKUt39fX2bRbfXq1aSlpfHCCy/QvXt3Vq1aBcBTTz1FaGgo48ePx8fHhz/++MM6+f0LL7xASkoKa9aswdPTkz179hSIhaNatGiRZfXSTGazGZPJxGOPPcbkyZMdEJmIiDjMlYuw8CXYs8CyXykcIj4Fz+IODcuqbCPotwYWDIT9i+D3IZZVTzt9DO5FHR2dyG3ZVHhr0qQJU6ZM4cknn6RcuXJZHjt69CiffPIJDzzwgE0BioiI5KrURPhvwL1/3ddPgItnjps/++yzvP/++6xevZoWLVoAlttMu3Tpgo+PDz4+Prz66qvEx8fj7e3Niy++yJIlS/jpp59yVHhbvnw5+/btY8mSJQQEWPLx3//+94bRTiNGjLD+OTg4mP/85z/8+OOPDB06FHd3d7y8vHBycrrlraXff/89SUlJzJgxA09PSw4+/vhjOnTowPjx4/Hz8wOgaNGifPzxx5hMJqpWrUr79u2JjIy8q8JbZGQku3bt4tChQwQFBQEwY8YMatSowdatW2nQoAFHjx7l1VdfpXLlynh7e1OlShXr848ePUqXLl2oVasWABUqVLjjGPKilStX3nDMYDBQtGhRypUrh7e3twOiEhERhzm+HWY/AxePgtEZwkZD4xdy/GXhPeNRDB7/DjZ/BstGwr5f4eQf0PVrCGrg6OhEbsmmwtt///tfmjVrRtWqVencuTOVK1cGYP/+/SxYsACTycS4ceNyJVAREZHCpGrVqjRp0oSvv/6aFi1acODAAdauXctbb70FWEaVjx07lh9//JHY2FhSUlJITk7Gw8MjR+ffu3cvQUFB1qIbQOPGjW9oN2vWLD766CMOHjzI5cuXSUtLu+PizN69e6lTp4616AbwwAMPkJGRwf79+62Ftxo1amAyXbudxd/fn127dt3Ra13/mkFBQdaiG0D16tXx9fVl7969NGjQgMGDB9O3b1+++eYbwsPD6datGyEhIQC89NJLDBgwgKVLlxIWFkaXLl2oXbv2XcWSlzRv3tzRIYiISF6QkQGbpsDy0ZCRBr7loOs0KFPP0ZHdnMEA9/e3jID7uRdcOATT2sBDI6HJS5ZbU0XyIJsKb3Xr1mXz5s288cYb/PLLLyQmWm7d8fDwoE2bNowePZoSJUrkSqAiIiK5wtnDMvrMEa97h3r37s2LL77IlClTmDZtGiEhIdbCyfvvv89HH33E2LFjadiwIUWKFGHQoEGkpKTkWsgbN27kqaeeYsyYMYSHh+Pj48OPP/7IBx98kGuvcb3M2zwzGQyGO15A4k6MHj2axx9/nLlz57JixQpGjx7Njz/+SOfOnXnuuecIDw9n0aJFLF26lHHjxvHBBx/w4osv2i2ee+HQoUPs3r2bDh06ZPv4woULqVWrFsHBwfc2MBERuXcSzllWLP17iWW/eifoOBncbpwuIk8KqGu59fTXQbB7Dix/Ew6vhc6fgafqD5L32FwSrl69OvPmzSM+Pp6TJ09y8uRJ4uPjmTt3LgsXLszyTXNOTZkyheDgYNzc3GjUqBFbtmy5Zfuff/6ZqlWr4ubmRq1atW45+XH//v0xGAxZJpcWEZFCxGCw3PJ5r7e7uGWjW7duGI1Gvv/+e2bMmMGzzz5rnZ9r/fr1dOzYke7du1OnTh0qVKjAX3/9leNzV6tWjWPHjnHy5EnrsX8viLRhwwbKlSvHG2+8Qf369alUqRJHjhzJ0sbFxYX09PTbvtbOnTtJSEiwHlu/fj1GozHL7Z25KfP6jh07Zj22Z88eLl68SPXq1a3HKleuzPPPP8+SJUt49NFHmTZtmvWxoKAg+vfvz9y5c3n11Vf54osv7BLrvZS5gMLNTJkyhWHDht31+e+kD5eamspbb71FSEgIbm5u1KlTh8WLF2dpc+nSJQYNGkS5cuVwd3enSZMmbN26Ncs5XnvtNWrVqoWnpycBAQH06NGDEyccUFwXEckPjmyAqU0tRTeTK7SfAI99k3+KbpncvKHLV9DhI3BygwPLLdd1aK2jIxO5Qa6NxTQajfj5+eHn52fTggqzZs1i8ODBvPnmm0RFRVGnTh3Cw8M5ffp0tu03bNjAE088Qe/evYmOjiYiIoKIiAh27959Q9t58+axadOmLLfViIiI5FVeXl50796d4cOHc/LkSZ555hnrY5UqVWL58uVs3ryZvXv30q9fvywrdt5OWFgYlStXpmfPnuzcuZO1a9fyxhtvZGlTqVIljh49yo8//sjBgwf56KOPmDdvXpY2wcHBHDp0iB07dnD27FmSk5NveK2nnnoKNzc3evbsye7du1m5ciUvvvgiTz/9tPU207uVnp7Ojh07smx79+4lLCyMWrVq8dRTTxEVFcWWLVvo0aMHzZs3p379+ly5coWBAweyatUqjh49yvr169m6dSvVqlUDYNCgQSxZsoRDhw4RFRXFypUrrY/lZxs3bqRVq1Y3ffzhhx9m7dq7+6XlTvtwI0aM4LPPPmPy5Mns2bOH/v3707lzZ6Kjo61tnnvuOZYtW8bMmTPZtWsXrVu3JiwsjJiYGAASExOJiopi5MiRREVFMXfuXPbv30/Hjh3v6hpERAqsjHRY/T5Mbw+XTkDxStAnEhr0znvzueWUwQD1ekKflVCiClw6CTM6wqp3LdcrkkfkuZugJ0yYQJ8+fejVqxfVq1dn6tSpeHh48PXXX2fbftKkSbRp04YhQ4ZQrVo13n77be677z4+/vjjLO1iYmJ48cUX+e677264lUVERCSv6t27NxcuXCA8PDzLF0cjRoygbt26dO3alYceeojSpUsTERGR4/MajUbmzZvHlStXaNiwIc899xxjx47N0qZjx4688sorDBw4kNDQUDZs2MDIkSOztOnSpQtt2rShZcuWlCxZkh9++OGG1/Lw8GDJkiWcP3+eBg0a0LVrVx5++OEb/q++G5cvX6Zu3bpZtg4dOmAwGFiwYAFFixalWbNmhIWFUaFCBWbNmgWAyWTi3LlzPPPMMzRo0IDHH3+ctm3bMmbMGMBS0HvhhReoVq0abdq0oXLlynzyySc2x+toFy5coEiRIjd93MvLi3Pnzt3Vue+0Dzdz5kxef/112rVrR4UKFRgwYADt2rWz3sp85coV5syZw3vvvUezZs2oWLEio0ePpmLFinz66aeAZRXdZcuW0a1bN6pUqcL999/Pxx9/zPbt2zl69OhdXYeISIFz6RTM7Awr3wFzBtR5AvqugtK1HB1Z7vCrDn1XQt3/s1zfqnEwoxPEn7z9c0XuAZvmeMttKSkpbN++neHDh1uPGY1GwsLC2LhxY7bP2bhxI4MHD85yLDw8nPnz51v3MzIyePrppxkyZAg1atS4bRzJyclZvrGPj48HLLczpKam3skl5UjmOe1x7sJA+bON8mcb5c829s5famoqZrOZjIwMu84VZk+NGjWy3sp5/TX4+voyd+5cLl26RJEiRay3oF7fbsWKFVn2//nnnyz7FStWZPXq1Vle79+v9e677/Luu+9mafPSSy9ZH3d2duann37K8nhGRsYN56lRowbLly+/4foyH88szlx/jRMmTLjh2PV69OhBjx49sn0sIyODMmXK3DBCL/MxJycnvvvuO8xm8w05zMjIYNKkSUyaNOmm8f77mNlsJjU1NcviEJD3PhvKli3L+vXrGTBgQLaPr127ljJlytzxee+mD5ecnIybm1uWY+7u7qxbtw6AtLQ00tPTb9kmO3FxcRgMBnx9fW/6uurn5R/Kn22UP9sUhPwZ/lmF6ZcBGBLOYHb2IL3Ne5hrP2558B5c1z3LocEF2k3EUPYBTL//B8PhtZinNiW94xTMIQ/b97XtqCC8Bx3pXvyukRN5qvB29uxZ0tPTb7jtxM/Pj3379mX7nNjY2Gzbx8bGWvfHjx+Pk5MTL730Uo7iGDdunPUb7+stXbo0x6vF3Y1ly5bZ7dyFgfJnG+XPNsqfbeyVPycnJ0qXLs3ly5dzddGBvObSpUuODiHfsyWHKSkpXLlyhTVr1pCWlpblscyFp/KKJ554grfffpuGDRsycOBA6/Qg6enpfPzxx8yaNeuGW45z4m76cOHh4UyYMIFmzZoREhJCZGQkc+fOtRZtixQpQuPGjXn77bepVq0afn5+/PDDD2zcuJGKFStme86kpCRee+01nnjiiZuuvqt+Xv6k/NlG+bNNfsyfwZxO1ZNzqXTqVwyYiXMLYlv5F7h83BuO33xOdHu5dzn0xDNkFPUPT8E38ShOP3bn71Lt2RvQBbMhT5U/7kh+fA/mJfbKX077eXf8zouKispx27wwse327duZNGkSUVFRWUYD3Mrw4cOzjKKLj48nKCiI1q1b37QTZ4vU1FSWLVtGq1atdBvsXVD+bKP82Ub5s42985eUlMSxY8fw8vK6YdRMQZDdaC25M7mRw6SkJNzd3WnWrNkN77PM0VR5xfDhw1m3bh2DBg1i7Nix1sUt9u/fz5kzZ2jRosVdFd7uxqRJk+jTpw9Vq1bFYDAQEhJCr169styaOnPmTJ599lkCAwMxmUzcd999PPHEE2zfvv2G86WmptKtWzfMZrP1VtTsqJ+Xvyh/tlH+bJNv8xcfg2leX4ynNgOQft8zeIS9TTNn93seisNymPYU6cvfxLT9KyqdXkSI82nSO38OPne++KMj5dv3YB5h7/zltJ93x4W3+vXr57hjajab76gTW6JECUwm0w2TQ586dYrSpUtn+5zSpUvfsv3atWs5ffo0ZcuWtT6enp7Oq6++ysSJEzl8+PAN53R1dcXV1fWG487OznZ9s9v7/AWd8mcb5c82yp9t7JW/9PR0DAYDRqPRpoV/8qrM2x4zr1HuXG7k0Gg0YjAYsn0f57XPBVdXV5YuXco333zD3LlzOXjwIAANGzakS5cu9OjR467ycDd9uJIlSzJ//nySkpI4d+4cAQEBDBs2jAoVKljbhISEsHr1ahISEoiPj8ff35/u3btnaQPXim5HjhxhxYoVtyygqZ+XPyl/tlH+bJOv8rfvN1jwPFy5AK7e0PEjTDU6Y7r9M+3qnufQ2Rk6TICQFrBgIMaYrRi/bAGdPoFqj9y7OHJJvnoP5kH2yl9Oz3nHhbdp06bdcTA55eLiQr169YiMjLROEJ2RkUFkZCQDBw7M9jmNGzcmMjKSQYMGWY8tW7aMxo0bA/D0008TFhaW5Tnh4eE8/fTT9OrVyy7XISIiIpJXGY1GevXqlav9oLvpw2Vyc3MjMDCQ1NRU5syZQ7du3W5o4+npiaenJxcuXGDJkiW899571scyi25///03K1eupHjx4rl2XSIi+UZaMix7EzZfHfEbUBe6ToNi5R0bl6NV7wj+dWD2sxCzDWY9BQ37Qeu3wenGL2FE7OGOC289e/a0RxxWgwcPpmfPntSvX5+GDRsyceJEEhISrJ3DHj16EBgYyLhx4wB4+eWXad68OR988AHt27fnxx9/ZNu2bXz++ecAFC9e/IYOmLOzM6VLl7beXiEiIgWb2Wx2dAhSgOWn99f58+c5fvw4tWvXzvbxXbt2UaZMGYoWLXrH577TPtzmzZuJiYkhNDSUmJgYRo8eTUZGBkOHDrWec8mSJZjNZqpUqcKBAwcYMmQIVatWtZ4zNTWVrl27EhUVxa+//kp6erp1nt9ixYrh4uJyx9chIpLvnP8Hfu4FJ3dY9u9/AcJGg5M+AwEoWg6eXQyRb8GGj2DLZ3Bsk6UwWTzE0dFJIZDnZhfs3r07Z86cYdSoUcTGxhIaGsrixYutk/UePXo0yy0QTZo04fvvv2fEiBG8/vrrVKpUifnz51OzZk1HXYKIiOQRmcO/ExMTcXe/9/OaSOGQObFufrgF5JVXXmH//v1s2rQp28f79etHtWrV+Oqrr+743Hfah0tKSmLEiBH8888/eHl50a5dO2bOnJllNdK4uDiGDx/O8ePHKVasGF26dGHs2LHWXMfExPDLL78AEBoamiWelStX0qJFizu+DhGRfGX3HPjlZUi5BO5FIeJTqNLW0VHlPSZnyyi38s1gXj84uRM+awaPTITajzk6Oing8lzhDWDgwIE3vS1h1apVNxx77LHHeOyxnP9jyW5eNxERKXhMJhO+vr6cPn0aAA8PjwK1CEFGRgYpKSkkJSVpjre7ZEsOzWYziYmJnD59Gl9fX0wmR8+gc3srVqxgwIABN328Q4cOTJ069a7Pfyd9uObNm7Nnz55bnq9bt27Z3nqaKTg4OF+NOBQRyTWpV2DxMNg+3bJftjF0+RJ8yjg0rDyvUivovw7mPAdH1sPc5+DQamj7HrjYb2VrKdzyZOFNREQkt2RO7J5ZfCtIzGYzV65cwd3dvUAVFO+l3Mihr6/vTRcQyGvOnDlDiRIlbvp48eLFC+S/FRGRAuXMfvj5GTi9BzDAg69Ci+Fg0q/3OeIdAD1+gTXvwer3IHomHN8Gj02DUtUcHZ0UQPqXKSIiBZrBYMDf359SpUqRmprq6HByVWpqKmvWrKFZs2b54jbHvMjWHDo7O+eLkW6Z/P39iY6Ovunj27dvp2TJkvcwIhERyTGzGXZ8D7/9B1ITwbMUPPo5hLR0dGT5j8kJWr4OwU1hTh84sxc+bwnt3oO6T4O+0JRcpMKbiIgUCiaTKV8VSHLCZDKRlpaGm5ubCm93qbDlMCIigilTptC2bVs6duyY5bEFCxYwbdq0W96KKiIiDpJ8CRa9Cn/MsuyXbw6PfgFF/BwbV35Xvpnl1tN5/eBgJPzyIhxaA498CK5FHB2dFBAqvImIiIgUEqNHj2b58uV07tyZOnXqWBej2r17Nzt27KB69eqMGTPGwVGKiEgWJ/+A2b3g3AEwGC0jtZoOBmPB+kLRYbxKwlOzYcMkiHwbdv0MMdstq54GhDo6OikANBOziIiISCHh4+PDpk2bGDFiBKmpqcyePZvZs2eTmprKqFGj2LJlixYrEBHJK8xm2PIFfBlmKbp5B8Izv0GzISq65TajEZq+Ar1+B58gOP8PfNUKNn9m+XsQsYEKbyIiIiKFiKenJ2PGjGHXrl0kJiaSmJjI1q1bqVGjBk8++ST+/v6ODlFERK5chJ96WOZzS0+Gym0st0SWa+zoyAq2so2g3xqo0h7SU+D3oTDr/+DKBUdHJvmYbjUVERERKYTMZjORkZF89913zJs3j0uXLlGiRAmefPJJR4cmIlK4Hd9mubX04lEwOkOrMXD/85rw/17xKAaPfwdbPoelI2Dfr5bbfbt+BUENHR2d5EMqvImIiIgUItu3b+e7777jxx9/JDY2FoPBwOOPP87AgQO5//77MegXOxERx8jIgE1TYPloyEgD33Lw2DQIrOfoyAofgwEa9bMU2n7uBRcOwddt4OFR0OQly62pIjmkd4uIiIhIAffPP//w9ttvU7VqVRo2bMjs2bN56qmnmDVrFmazmS5dutC4cWMV3UREHCXhHPzQ3TLCKiMNqkdA/7UqujlaQF3Lrac1u4A5HZa/Cd91hctnHB2Z5CMa8SYiIiJSgDVu3JgtW7ZQokQJunbtypdffknTpk0BOHjwoIOjExERDq+HOc/BpRNgcoW270K9Xrq1NK9w84YuX0H55vD7a3AwEqY2hS5fQvkHHR2d5AMqvImIiIgUYJs3b6Z8+fJMmDCB9u3b4+Sk7p+ISJ6QkQ5rP4BV48CcASUqQ9dpULqmoyOTfzMYoF5PKNPAMv/emX0woyM0f02rzMpt6VZTERERkQLs448/xt/fn86dO1O6dGn69evHypUrMZvNjg5NRKTwuhQLMyNg5VhL0a3Ok9BnpYpueZ1fdeizAur+n+XvbdU4mNEJ4k86OjLJw1R4ExERESnAnn/+edatW8fBgwcZNGgQa9eu5eGHHyYwMJBRo0ZhMBg0t5uIyL104OqtiofWgLMnREyFzp+Cq5ejI5OccPGETlPg0S/BxQsOr4WpD8Dfyx0dmeRRKryJiIiIFALly5dnxIgR7Nmzh61bt/L444+zatUqzGYzzz//PH379uXXX38lKSnJ0aGKiBRM6amWFUu/fRQSzoBfTei7CkKfcHRkcjdqP2ZZeKF0LUg8B991gWWjLH/PItdR4U1ERESkkKlXrx4TJkzg2LFjLF26lPDwcGbNmkXHjh0pUaKEo8MTESl4Lh6D6e1h3YeW/fq94bnlULKyY+MS2xQPgd7LoWFfy/76STCtLVw44ti4JE9R4U1ERESkkDIajYSFhTF9+nROnTrFDz/8wMMPP+zosERECpZ9v1luLT22GVy94bHp8MgEcHZ3dGSSG5zdoN370G0muPnA8a3w2YOwd6GjI5M8QoW3PGBOVAxbzxhISE5zdCgiIiJSSLm5udG9e3cWLFjg6FBERAqGtGT4fRj8+AQkXYSA+yy3Jtbo7OjIxB6qd4R+ayGwPiTFwaz/g9+GQKqmcCjsVHhzsIwMMxMjD/DtARONx6/i5R+jWbn/NGnpGY4OTURERERERO7GuYPwVSvY/Kllv/FAeHYJFCvv2LjEvoqWg2cXwwMvW/a3fG55H5w76Ni4xKFUeHOwlPQMutUvQ0k3M1dSM1iw4wS9pm2l0X8jGf3Ln+w4dhGz2ezoMEVERERERCQnds2Gz5rDyZ3gXhSemAXhY8HJxdGRyb1gcoZWb8FTs8GjOMT+AZ81gz9+dnRk4iBOjg6gsHNzNvFiyxAqJO6nTJ0H+HXXKRbuPMG5hBSmbzjM9A2HKV/Ck4jQQCLqBlCuuKejQxYREREREZF/S0mExcMg6hvLftnG0OUr8Al0bFziGJVaQf/1MOc5OLIO5j4Hh1ZD2/fAxcPR0ck9pMJbHmEwQJ0yPtQvX4I32ldj3YGzzI+OYcmfsRw6m8CHy//iw+V/UbesL53rBtK+lj/FvVwdHbaIiIiIiIic3geze8HpPYABmv0Hmg8Dk37lLtS8/aHnL7D6PVg9HqJnWhZfeGw6lKrm6OjkHtGnQB7kbDLSskopWlYpRUJyGkv3xDIv+gTr/j5D9NGLRB+9yFsL99Csckki6gbSqpof7i4mR4ctIiIiIiJSuJjNsOO7q5PoJ4JnKXj0cwhp6ejIJK8wmqDlcAh+AOb0gTP74POW0HY83NfDMgpHCjQV3vI4T1cnOtctQ+e6ZTh9KYmFO08yPzqGXTFxrNh3mhX7TuPpYqJNTX861w2kcUhxTEb9wxUREREREbGr5Evw62DY9ZNlv0ILePQL8Crl0LAkjyrfDPqvg3n94GAkLHwJDq2BRz4EN29HRyd2pMJbPlKqiBu9m5and9PyHDh9mQU7YpgXHcPxC1eYE3WcOVHHKVXElY51AoioG0iNAG8Mqp6LiIiIiIjkrpN/wM/PwPmDYDBBy9eh6WAwav1CuQWvkpZFFzZ8BJFvwe7ZcCIKuk6DgFBHRyd2ok+FfKpiKS9ebV2FtUNbMrt/Y55qVBZfD2dOX0rmy3WHeGTyOlp/uIYpKw9w/EKio8MVERGRQmDKlCkEBwfj5uZGo0aN2LJly03bpqam8tZbbxESEoKbmxt16tRh8eLFWdpcunSJQYMGUa5cOdzd3WnSpAlbt27N0sZsNjNq1Cj8/f1xd3cnLCyMv//+2y7XJyKC2QxbvoAvwyxFN+9AeGaRZU43Fd0kJ4xGaDoInl0MPkFw/h/4qhVs/szy/pICR58M+ZzBYKB+cDHGdq7FltfD+KJHfdrX8sfFycjfpy/z/pL9NB2/km5TN/L95qPEJaY6OmQREREpgGbNmsXgwYN58803iYqKok6dOoSHh3P69Ols248YMYLPPvuMyZMns2fPHvr370/nzp2Jjo62tnnuuedYtmwZM2fOZNeuXbRu3ZqwsDBiYmKsbd577z0++ugjpk6dyubNm/H09CQ8PJykpCS7X7OIFDJXLsJPT8Nv/4H0ZKjc1nLrYLnGjo5M8qOghtBvDVR9BNJT4PehMOv/4MoFR0cmuUyFtwLExclIq+p+THnqPraNCOO9rrVpElIcgwG2HD7P6/N20WDscvrN3Mbvu06SlJru6JBFRESkgJgwYQJ9+vShV69eVK9enalTp+Lh4cHXX3+dbfuZM2fy+uuv065dOypUqMCAAQNo164dH3zwAQBXrlxhzpw5vPfeezRr1oyKFSsyevRoKlasyKeffgpYRrtNnDiRESNG0KlTJ2rXrs2MGTM4ceIE8+fPv1eXLiKFwfFt8NmDsHchGJ0hfBw88QN4FHN0ZJKfeRSD7t9C2/fA5AL7foWpD8Kxm48Yl/xHc7wVUN5uznSrH0S3+kGcjLvCLztOMH/HCfaejGfJn6dY8ucpirg50b6WPxF1A2kYXAyjFmUQERGRu5CSksL27dsZPny49ZjRaCQsLIyNGzdm+5zk5GTc3NyyHHN3d2fdunUApKWlkZ6efss2hw4dIjY2lrCwMOvjPj4+NGrUiI0bN/L4449n+7rJycnW/fj4eMBy62tqau7fGZB5TnucuzBQ/myj/NkmNTUVzBmY13+Eec1/MWSkYfYNJr3zF5gD6kJamqNDzPP0Hsyh+54F/3o4zXsOw4VDmL9uQ0aLN0it3w9Q/u6Wvd9/OT2vCm+FgL+PO/2ah9CveQj7YuOZH32CBTtiOBmXxI9bj/Hj1mME+LjRMTSQznUDqVK6iKNDFhERkXzk7NmzpKen4+fnl+W4n58f+/bty/Y54eHhTJgwgWbNmhESEkJkZCRz584lPd0yIr9IkSI0btyYt99+m2rVquHn58cPP/zAxo0bqVixIgCxsbHW1/n362Y+9m/jxo1jzJgxNxxfunQpHh4ed3bhd2DZsmV2O3dhoPzZRvm7Oy6p8dx/9HNc4v8AIMa3ITvKPkvajpOw46SDo8tf9B7MGaegYdRhGmUubMK08i0ubZuHS7l+yp+N7JW/xMSczaevwlshU7W0N8PaejM0vApbDp9nfnQMi3ad5ERcElNXH2Tq6oNU8/cmIjSAjqEB+Pu4OzpkERERKYAmTZpEnz59qFq1KgaDgZCQEHr16pXl1tSZM2fy7LPPEhgYiMlk4r777uOJJ55g+/btd/26w4cPZ/Dgwdb9+Ph4goKCaN26Nd7e3jZdU3ZSU1NZtmwZrVq1wtnZOdfPX9Apf7ZR/u6e4ch6jPOHYrwci9nJjYxW71Cqbk9aG3SX0J3Qe/AumB8lbed3mJYMx+/SLlruGwFdvsRUsYWjI8t37P3+yxw1fzsqvBVSRqOB+ysU5/4KxRndsQYr951mXnQMK/efZu/JePaejOfdxftoXKE4EXUDaVOzNN5u+qAUERGRG5UoUQKTycSpU6eyHD916hSlS5fO9jklS5Zk/vz5JCUlce7cOQICAhg2bBgVKlSwtgkJCWH16tUkJCQQHx+Pv78/3bt3t7bJPPepU6fw9/fP8rqhoaHZvq6rqyuurq43HHd2drbrL4X2Pn9Bp/zZRvm7AxnpsOZ/sPpdMGdwydUftx6zcA6sg8nRseVjeg/eoQa9oNz9mH/qidvZ/ZhnPYah+WvQfCgY9U68U/Z6/+X0nFpcQXBzNtG2lj+f96jP1jfC+G/nWjQMLobZDBsOnmPo7D+o/85yXvguimV7TpGSluHokEVERCQPcXFxoV69ekRGRlqPZWRkEBkZSePGt17tz83NjcDAQNLS0pgzZw6dOnW6oY2npyf+/v5cuHCBJUuWWNuUL1+e0qVLZ3nd+Ph4Nm/efNvXFRG5waVYmNEJVv0XzBlk1H6C1VXeglLVHR2ZFEalqpH27DKOFG+OAbOlGPxNR4g/4ejI5A5pxJtk4evhwpONyvJko7IcO5/ILztPMC86hgOnL7No10kW7TqJr4czj9T2JyI0kHrlimLQcGsREZFCb/DgwfTs2ZP69evTsGFDJk6cSEJCAr169QKgR48eBAYGMm7cOAA2b95MTEwMoaGhxMTEMHr0aDIyMhg6dKj1nEuWLMFsNlOlShUOHDjAkCFDqFq1qvWcBoOBQYMG8c4771CpUiXKly/PyJEjCQgIICIi4p7nQETysQPLYW4/SDwLzp7wyATSq3ch/bffHB2ZFGbOHuwo25vApk/g9Pt/4Mg6mNoUOn8GlVo5OjrJIRXe5KaCinnwQsuKPN8ihD9PxDM/OoYFO09w5lIy3246yrebjhJUzJ2I0EA6hQZSsZSXo0MWERERB+nevTtnzpxh1KhRxMbGEhoayuLFi60LHxw9ehSj8drNFklJSYwYMYJ//vkHLy8v2rVrx8yZM/H19bW2iYuLY/jw4Rw/fpxixYrRpUsXxo4dm+XWjqFDh5KQkEDfvn25ePEiTZs2ZfHixTeshioikq30VFg5FtZ9aNn3qwmPTYcSlUArSUoeYa7ZFco2hJ+fgdg/4Luu0OQleHgUmHQLb16nwpvclsFgoGagDzUDfRjerhobD55jXnQMi3ef5Nj5K0xecYDJKw5QK9CHiLqBdKjjT6ki6uyKiIgUNgMHDmTgwIHZPrZq1aos+82bN2fPnj23PF+3bt3o1q3bLdsYDAbeeust3nrrrTuKVUSEi8dg9rNwfItlv8Fz0HosOOt3GcmDiofAc8th6UjY8hls+AiOboQuX0HRco6OTm5BhTe5IyajgaaVStC0UgneiajJsr2nmB8dw5q/zrArJo5dMXGMXbSHppVK0rluAK2rl8bTVW8zERERERHJQ/YtgvnPQ9JFcPWGjpOhRoSjoxK5NSdXaPcelH8QFrwAx7fCZw9Cx4+hekdHRyc3oYqI3DV3FxMd6wTQsU4A5y4ns2jXSeZFxxB99CJr/jrDmr/O4O68m9Y1/IioG8iDFUvgZNJ6HiIiIiIi4iBpybBsFGyeatkPrAddv4aiwQ4NS+SOVOsA/nWujtjcCj89DQ37Qqu3NWIzD1LhTXJFcS9XejQOpkfjYA6fTWDBjhPM3xHDoat/XrDjBCW8XHikdgARdQOpU8ZHizKIiIiIiMi9c+4gzO4FJ3da9hsPhIffBCcXx8Ylcjd8y0Kv32HF27B+Emz53HLradfpUKKio6OT66jwJrkuuIQnL4dV4qWHK7LzeBzzo2NYuPMEZy+nMH3DYaZvOEz5Ep5EhAYSUTeAcsU9HR2yiIiIiIgUZLtmw8JBkHIJ3ItB56lQOdzRUYnYxuQMrd6C4GYwrx/E7oLPm8MjH0LtW8+RKveOCm9iNwaDgdAgX0KDfHmjfTXWHTjL/OgYlvwZy6GzCXy4/C8+XP4Xdcv60rluIO1r+VPcy9XRYYuIiIiISEGRkgiLX4OoGZb9sk2gy5fgE+jYuERyU6Uw6L8O5vaBw2stPw+thrbvgYsGujhanpxwa8qUKQQHB+Pm5kajRo3YsmXLLdv//PPPVK1aFTc3N2rVqsVvv/1mfSw1NZXXXnuNWrVq4enpSUBAAD169ODEiRP2vgy5jrPJSMsqpZj0eF22j2jFh93r0KxySYwGiD56kVEL/qTRfyPpPX0rC3ee4EpKuqNDFhERERGR/Oz0PvjioatFNwM0Gwo9F6roJgWTtz/0WAAthoPBCNHfWt7/p269grjYX54rvM2aNYvBgwfz5ptvEhUVRZ06dQgPD+f06dPZtt+wYQNPPPEEvXv3Jjo6moiICCIiIti9ezcAiYmJREVFMXLkSKKiopg7dy779++nY0et+OEonq5OdK5bhhnPNmTT6w8z8pHq1Ar0IS3DTOS+07z4QzT131nGqz/tZN3fZ0nPMDs6ZBERERERyS/MZoiaCZ+3gDN7wbMU9JgPD70BJt30JQWY0QQthkGPX8CrNJzZB1+0hO3fWP5diEPkucLbhAkT6NOnD7169aJ69epMnToVDw8Pvv7662zbT5o0iTZt2jBkyBCqVavG22+/zX333cfHH38MgI+PD8uWLaNbt25UqVKF+++/n48//pjt27dz9OjRe3lpko1SRdzo3bQ8C19syvLBzXnxoYqUKepOQko6c6KO839fbabxuEje+XUPu2PiMOvDQkREREREbib5EsztC78MhLQrUKElDFgPFVo4OjKRe6f8g5ZbTyuGQVoSLHwJ5vSGpHhHR1Yo5alyf0pKCtu3b2f48OHWY0ajkbCwMDZu3JjtczZu3MjgwYOzHAsPD2f+/Pk3fZ24uDgMBgO+vr7ZPp6cnExycrJ1Pz7e8uZMTU0lNTU1h1eTc5nntMe585NyRV15qWUFXmxRnqijF1mw8yS/7z7F6UvJfLnuEF+uO0TFkp50quNPhzr+BPq6A8qfrZQ/2yh/tlH+bKP82c7eOdTfjYjIPXRyJ/zcC84fBIMJHhoBDwwCY54bbyJif14l4cmfYeNkiHwLds+BmCh4bBoE1HV0dIVKniq8nT17lvT0dPz8/LIc9/PzY9++fdk+JzY2Ntv2sbGx2bZPSkritdde44knnsDb2zvbNuPGjWPMmDE3HF+6dCkeHh45uZS7smzZMrudOz+63wnq14a9Fw1sO2tg93kDB84k8MHyA3yw/AAhRczUL5lBaHEzHk7Kn62UP9sof7ZR/myj/NnOXjlMTEy0y3lFROQ6ZjNs/RKWvA7pKeBdBrp+BWXvd3RkIo5lNMIDL0PZxjD7WbhwCL5sBa3fgUb9wGBwdISFQp4qvNlbamoq3bp1w2w28+mnn9603fDhw7OMoouPjycoKIjWrVvftFhna1zLli2jVatWODs75/r587vM2fguJaWyZM9pftl5kk2HznPwkoGDl0zMPWKgmk86zz5ci7BqpXF1Njk03vxG7z/bKH+2Uf5so/zZzt45zBw1LyIidnLlAiwYCPt+texXbgsRn4BHMcfGJZKXBDWE/muv/VtZ/Jpl9dOOk/Vv5R7IU4W3EiVKYDKZOHXqVJbjp06donTp0tk+p3Tp0jlqn1l0O3LkCCtWrLhlAc3V1RVXV9cbjjs7O9v1Fxt7nz+/K+bszBONgnmiUTAn466wcOcJ5kWfYO/JeP44b2TQz39SxG0/7Wv5E1E3kIbBxTAaVcHPKb3/bKP82Ub5s43yZzt75VB/LyIidnRsq2UUT9xRMDpDq7fg/gEaxSOSHfei0P1b2PIFLH3DUoA7uRO6fAVlGzk6ugItT93s7uLiQr169YiMjLQey8jIIDIyksaNG2f7nMaNG2dpD5bbRa5vn1l0+/vvv1m+fDnFixe3zwXIPePv407fZiH8/vKD/PpCYx4OyKC0tyuXktL4cesxHv98E03Hr+Dd3/exP/aSo8MVEREREZHckpEB6yfBtDaWolvRYOi9FBo/r6KbyK0YDNCoLzy3HIpVgLhjMK0trPvQ8u9K7CJPjXgDGDx4MD179qR+/fo0bNiQiRMnkpCQQK9evQDo0aMHgYGBjBs3DoCXX36Z5s2b88EHH9C+fXt+/PFHtm3bxueffw5Yim5du3YlKiqKX3/9lfT0dOv8b8WKFcPFxcUxFyq5pkrpInQsl8EnbZoRHXOJ+dExLNp1khNxSUxdfZCpqw9Szd+bznUD6FgnkNI+bo4OWURERAoJ4+p3qXtkI4adF6FCM0uBQIUBkbuXcBbm9YcDV+fmrNEZOkwCNx/HxiWSn/jXgX5r4NdXYNfPsHw0HFoLnT+zLMoguSrPFd66d+/OmTNnGDVqFLGxsYSGhrJ48WLrAgpHjx7FeN2qNE2aNOH7779nxIgRvP7661SqVIn58+dTs2ZNAGJiYvjll18ACA0NzfJaK1eupEWLFvfkusT+jEYD91cozv0VijO6Yw1W7jvNvOgYVu4/zd6T8ew9Gc+43/fRuEJxIuoG0qZmabzddAuQiIiI2I9x73zKnj8Av663HPAOhHIPQPADEPygZcSBCnEiOXN4Hcx5Di6dBCc3aPMu1HtG/4ZE7oZrEXj0CyjfHH4bAgcjYeoDlmMVmjs6ugIlzxXeAAYOHMjAgQOzfWzVqlU3HHvsscd47LHHsm0fHByM2WzOzfAkH3BzNtG2lj9ta/lzMTGF33bFMj86hi2Hz7Ph4Dk2HDzHyPm7CavuR0RoIM0rl8TFKU/deS0iIiIFQHrrcfyzYgYVnU9hPBEN8TGw6yfLBuBV2lKEK/cABDeFEpVVRBD5t4x0WPM+rB4P5gzLv5PHpoNfDUdHJpK/GQxw39NQpj783AvO7IUZnaD5UGj+Ghi1cGFuyJOFN5Hc5OvhwpONyvJko7IcO5/ILztPMC86hgOnL7Poj5Ms+uMkvh7OPFLbn851A7mvbFEM6vCKiIhILjBXaMnefVco364dRnMKHNsCR9bD4fUQsw0ux8LuOZYNwLPktSJcuQegZFUw6stBKcTiT8LcPpYVGAFC/w/avQcuno6NS6QgKVUN+qywrHYaNcNS5D68Hrp8Ad4Bjo4u31PhTQqVoGIevNCyIs+3COHPE/HMj45hwc4TnLmUzLebjvLtpqMEFXMnIjSQTqGBVCzl5eiQRUREpKBw8YSQlpYNIPUKHN9muX3uyHo4vhUSzsCe+ZYNwL3Y1RFxTS0/S9VQIU4KjwPLYW4/SDwLzp7wyASo87ijoxIpmFw8oONky62nC1+GI+tgalOImAqVWzs6unxNhTcplAwGAzUDfagZ6MPwdtXYePAc86JjWLz7JMfOX2HyigNMXnGA2mV8iAgNpEOdAEoWcXV02CIiIlKQOLtD+QctG0BaMsRst4wyOLzWMjruynnYu9CyAbj5Qrkm10bEla6lW4Gk4ElPhRXvwPqJln2/WvDYNChRyaFhiRQKtbpCQF34+RmI/QO+fwyavAgPvwkmzZF+N1R4k0LPZDTQtFIJmlYqwTsRNVm+9xTzo2NY/dcZ/jgexx/H43hn0R6aVipJ57oBtK5eGk9X/dMRERGRXObkaimqlWsCzYdAWgqciLaMOji8Ho5ugqSLsP83ywbg6gNl77cU4oIfgNJ1wKR+iuRjF4/C7N5wfItlv8Fz0HosOLs5Ni6RwqR4CDy3HJaOhC2fwYbJcGQjdP0aipZzdHT5jv5XFrmOu4uJDnUC6FAngHOXk1m06yTzomOIPnqRNX+dYc1fZ3B33k3rGn5E1A3kwYolcDLpdg8RERGxAycXKNvIsj34qmUU0Mmd125NPboJkuPg7yWWDcCliKV9uaurpgaEaoSC5B97f4UFz0NSnKWo3GkyVO/k6KhECicnV8t8iuWbWf5dxmyDqQ9Cp4+hekdHR5evqPAmchPFvVzp0TiYHo2DOXw2gQU7TjB/RwyHrv55wY4TlPBy4ZHaAUTUDaROGR8tyiAiIiL2Y3K2rDxXpj40HQTpaXBql6UQd3g9HN1gKVgcWG7ZwDIvVlDDa/PEBd5n+WVKJC9JS742sgYgsN7VkTXBDg1LRIBqj4B/7WsjUX96Ghr0gdbvaCRqDqnwJpIDwSU8eTmsEi89XJGdx+OYHx3Dwp0nOHs5hekbDjN9w2HKl/AkIjSQiLoBlCuuVZZERETEzkxOlnl4Aupa5t/JSIdTf15dNfXqqLgrF+CflZYNwMkdghpcW6whsL5+cRLHOncQZveyjOYEy3v5oVGWEZ8ikjf4loVev12be3HrF3BsE3SdDiUqOjq6PE+FN5E7YDAYCA3yJTTIlzfaV2PdgbPMj45hyZ+xHDqbwIfL/+LD5X9Rt6wvnesG0r6WP8W99K2yiIiI3ANGk2VUgn9tuH8AZGTAmb2W0XCZ88QlnoVDaywbgMkVyjS4OiLuAcufXTwcex1SeOyaDQsHQcolywq+nadC5XBHRyUi2TE5Q6sxlmkM5vWD2F3wWTPoMBFqd3N0dHmaJqcSuUvOJiMtq5Ri0uN12T6iFR92r0OzyiUxGiD66EVGLfiTRv+NpPf0rSzceYIrKemODllERMSupkyZQnBwMG5ubjRq1IgtW7bctG1qaipvvfUWISEhuLm5UadOHRYvXpylTXp6OiNHjqR8+fK4u7sTEhLC22+/jdlstra5fPkyAwcOpEyZMri7u1O9enWmTp1qt2vMV4xG8KsBjfpCtxkw5AA8vxnafwA1HgUvP0hPthTlVo+HGR3h3bLwVThEvg0HV0BKgqOvQgqilET45UWY09tSdCv3APRfp6KbSH5QKczy7zX4QUhNgLl9YP4L+v/iFjTiTSQXeLo60bluGTrXLcPpS0ks3HmS+dEx7IqJI3LfaSL3ncbTxUSbmv50rhtI45DimIyaD05ERAqOWbNmMXjwYKZOnUqjRo2YOHEi4eHh7N+/n1KlSt3QfsSIEXz77bd88cUXVK1alSVLltC5c2c2bNhA3bp1ARg/fjyffvop33zzDTVq1GDbtm306tULHx8fXnrpJQAGDx7MihUr+PbbbwkODmbp0qU8//zzBAQE0LGjJn/OwmCAUlUtW4PnwGyGcweu3ZZ6eD1cOmG5fejYJlj7PzBevZ01c7GGso3AtYijr0Tys9N74edeltGYGKD5UGg2VKvxiuQn3v7QYwGs+R+sfhd2fAvHt8Jj08GvuqOjy3P06SaSy0oVcaN30/L0blqeA6cvs2BHDPOiYzh+4Qpzoo4zJ+o4pYq40ik0gE6hgdQI8NaiDCIiku9NmDCBPn360KtXLwCmTp3KokWL+Prrrxk2bNgN7WfOnMkbb7xBu3btABgwYADLly/ngw8+4NtvvwVgw4YNdOrUifbt2wMQHBzMDz/8kGUk3YYNG+jZsyctWrQAoG/fvnz22Wds2bJFhbfbMRigRCXLVr+XpRB34dC1xRqOrIe4Y5Zfpo5vtczrYzCBf51rizWUvR/cfR19JZIfmM0Q/S38NgTSrlhGXD76OVRo4ejIRORuGE3Q4jUo1wTmPAdn98MXLaHteLivp+X/GAFUeBOxq4qlvHi1dRUGt6pM1NELzIuO4dc/TnL6UjJfrD3EF2sPUamUFxF1A+kUGkCZoppTRURE8p+UlBS2b9/O8OHDrceMRiNhYWFs3Lgx2+ckJyfj5pZ1Un93d3fWrVtn3W/SpAmff/45f/31F5UrV2bnzp2sW7eOCRMmZGnzyy+/8OyzzxIQEMCqVav466+/+PDDD2/6usnJydb9+Ph4wHLra2pq6p1f/G1kntMe57aLIkFQ6wnLBnDxKIajGzAeWY/h6AYMF4/AiSjLtmEyZoMR/GqSUbYJ5rJNMJdtDO5Fcy2cfJe/PCbP5C/5Eqbf/4PxzzkAZFRoSXqHKeBVChwd2y3kmfzlY8qhbfJF/srcD8+twrRwIMaDy2Hhy2QcXEV6uwkOHyFt7/zl9LwqvIncAwaDgXrlilGvXDFGPVKD1X+dYX50DMv2nuLv05d5f8l+3l+yn4bBxYi4uiiDj4ezo8MWERHJkbNnz5Keno6fn1+W435+fuzbty/b54SHhzNhwgSaNWtGSEgIkZGRzJ07l/T0a3OiDhs2jPj4eKpWrYrJZCI9PZ2xY8fy1FNPWdtMnjyZvn37UqZMGZycnDAajXzxxRc0a9Ys29cdN24cY8aMueH40qVL8fCw3xdgy5Yts9u57c8bTG2hfFvcUs5R4vI+il/eR4nL+/BKPgWxf2CK/QO2TMWMgXi3MpwtUo1zXlU451WVFCfbf/HK3/lzPEfmzyfxMPUPT8Er+RQZGNnn34W/vdvDmm0Oi+lO6f1nO+XQNvkif0X+j4oBxal2YjbGPfNIPLCebeVfIM6jvKMjs1v+EhMTc9ROhTeRe8zFyUir6n60qu5HfFIqi3fHMj86ho3/nGPL4fNsOXye0b/8ScuqJelcN5AWVUrh5mxydNgiIiK5atKkSfTp04eqVatiMBgICQmhV69efP3119Y2P/30E9999x3ff/89NWrUYMeOHQwaNIiAgAB69uwJWApvmzZt4pdffqFcuXKsWbOGF154gYCAAMLCwm543eHDhzN48GDrfnx8PEFBQbRu3Rpvb+9cv87U1FSWLVtGq1atcHYueF+qpV46aRkJd2QDxqMbMJz7G5+kY/gkHSPkzFIAzCWrWkbElXsAc1BjyyinnJ6/gOfP3hyaP7MZ47avMEa+gyE9BbN3IBkRn1MpqBGV7m0kd03vP9sph7bJf/l7hIyYXhjm9cEr7hjN/36HjLAxZNTv45BbT+2dv8xR87ejwpuIA3m7OdOtfhDd6gdxMu4KC3eeYF70CfaejGfJn6dY8ucpirg50b6WPxF1A2kYXAyjFmUQEZE8pkSJEphMJk6dOpXl+KlTpyhdunS2zylZsiTz588nKSmJc+fOERAQwLBhw6hQoYK1zZAhQxg2bBiPP/44ALVq1eLIkSOMGzeOnj17cuXKFV5//XXmzZtnnQeudu3a7Nixg//973/ZFt5cXV1xdXW94bizs7Ndf6mx9/kdplhZyxZq+Tvi0inL3HCZizWc2YvhzD5MZ/bB9qtF1RKVry7W0NTy09v/ti9TYPN3j9zz/F25AAsGwr5fLftV2mHoNAUnj2L3LoZcpPef7ZRD2+Sr/AU3hv5rYcFADPt+xbT0dUxH1kOnj8FBnwH2yl9Oz6nCm0ge4e/jTt9mIfRtFsK+2HjmR59gwY4YTsYl8ePWY/y49RgBPm50qhtIRGggVUprRTEREckbXFxcqFevHpGRkURERACQkZFBZGQkAwcOvOVz3dzcCAwMJDU1lTlz5tCtWzfrY4mJiRiNxiztTSYTGRkZwLV52W7VRu6xIn5Q81HLBpBw9loR7sh6OLUbzv5l2bZPs7QpFnJtsYbgB8CnjOPiF9sd2wqzn4W4o2B0htbvQKN+mmhdpDBxLwrdv4WtX8KS12H/Ipi6E7p+bVkdu5BR4U0kD6pa2pthbb0ZGl6FLYfPMz86hkW7TnIiLolPVx3k01UHqebvTee6AXSsE0hpH7fbn1RERMSOBg8eTM+ePalfvz4NGzZk4sSJJCQkWFc57dGjB4GBgYwbNw6AzZs3ExMTQ2hoKDExMYwePZqMjAyGDh1qPWeHDh0YO3YsZcuWpUaNGkRHRzNhwgSeffZZALy9vWnevDlDhgzB3d2dcuXKsXr1ambMmJFlAQZxIM8SUL2TZQNIPA9HN15dOXUdxO6C8wctW9QMS5uiwdeKcIGF7xe0fCsjAzZ8BCvehow0KFre8kt24H2OjkxEHMFggIZ9IKgh/NzL8jk/rS08NAIeGAT/+tKsIFPhTSQPMxoN3F+hOPdXKM7ojjVYue8086JjWLn/NHtPxrP3ZDzjft9H4wrFiagbSJuapfF2yydDkEVEpEDp3r07Z86cYdSoUcTGxhIaGsrixYutCy4cPXo0y8i0pKQkRowYwT///IOXlxft2rVj5syZ+Pr6WttMnjyZkSNH8vzzz3P69GkCAgLo168fo0aNsrb58ccfGT58OE899RTnz5+nXLlyjB07lv79+9+za5c74FEMqra3bABXLsLRTXDkaiHu5E64cNiy7fgWZ6CVSwlMaYug/IOWYlzR8ho9ldcknIV5/eDAcst+jUehwyRwy/15E0Ukn/GvA/1Ww6+DYddPEDkGDq+Fzp/d0Zyf+ZkKbyL5hJuziba1/Glby5+LiSn8tsuyKMOWw+fZcPAcGw6eY+T83YRV9yMiNJDmlUvi4lR4vkUQERHHGzhw4E1vLV21alWW/ebNm7Nnz55bnq9IkSJMnDiRiRMn3rRN6dKlmTZt2p2GKnmFuy9UaWPZAJLi4dhm64g484loPFLOwq5Zlg2gSIBlfrjM21OLh6gQ50iH1sKc5+ByLDi5QdvxcF9P/Z2IyDWuReDRz6FCc1j0Hzi4AqY2hUe/sBwr4FR4E8mHfD1ceLJRWZ5sVJZj5xP5ZecJ5kXHcOD0ZRb9cZJFf5zE18OZR2r707luIPeVLYpBnR8RERHJ69y8oVIrywakJVxg69wpNPJLw3RsI8Rsh0snLKMmdv1keY5XaSjX5Goxrqll8Qb1e+wvIx3WvA+rx4M5A0pUgcemgV8NR0cmInmRwQB1/w8C68PPz8CZvTCjEzQbAs1fA1PBLU8V3CsTKSSCinnwQsuKPN8ihD9PxDM/OoZfdp7g9KVkvt10lG83HSWomDsRoYF0Cg2kYikvR4csIiIikjMuXpzxrkVGy3aYnJ0hJRGOb7m2WMPxrZaRVn/OtWwAniUthbhyVwtxJasWqrmE7on4kzC3j+V2MYDQ/4N274GLp2PjEpG8r1RV6LMCFg+DqG9gzXuWz/MuX4J3gKOjswsV3kQKCIPBQM1AH2oG+jC8XTU2HjzHvOgYFu8+ybHzV5i84gCTVxygdhkfIkID6VAngJJFXB0dtoiIiEjOuXhAhRaWDSD1ChzfdnXl1HWWQlzCGdizwLIBuBe7NiKu3APgV1OFOFv8vRzm9YXEc+DsCY98CHW6OzoqEclPXDyg40dQvhksHGT5DP/0Acu8b5VbOzq6XKfCm0gBZDIaaFqpBE0rleCdiJos33uK+dExrP7rDH8cj+OP43G8s2gPTSuVpGMtPzLSHR2xiIiIyF1wdrcsulD+Qct+WjLERFmKcEfWwbEtcOU87PvVsgG4+V4dEfeAZZ640rXBaHLYJeQb6amWFUvXT7Lsl64FXadDiYoODUtE8rFaXSGgLszuZVlc5/vHoMmL8NAocHJxdHS5RoU3kQLO3cVEhzoBdKgTwLnLySzadZJ50TFEH73Imr/OsOavMxgwMf7PVZTwcqVEEReKe7pS3MuFEl6uFPe8+tPr2k8PF310iIiISB7k5ArlGls2hkBaCpzcYV2sgWObIeki7P/NsgG4ekPZxtcWa/CvU6DnGrorF47AnN6WEYUADfpA63fA2c2xcYlI/lc8BHovg2WjYPNU2DAZjmyArl9D0WBHR5cr9D+KSCFS3MuVHo2D6dE4mMNnE1iw4wTzoo9z+Fwi5xJSOJeQwv5Ttz+Pu7PJWqAr4fWvQt11P4t7ulLM0wWTURMci4iIiAM4uUBQQ8v24GBIT7OMqjiyzjJP3NGNkBwPfy+xbAAuXhDU6NpiDQF1weTs2OtwpL0LYcELkBQHrj7QaTJU7+ToqESkIHFytayIHPwgLHjespDO1GYF5vNGhTeRQiq4hCcvh1ViQLNyzFrwO6H3P8jFpHTOXU7h7OVkSyHucjJnL1/7efZyMslpGVxJTefY+SscO3/ltq9jMEAxDxdrIS6zMFfCy4XimSPqirhSwjNzNJ1JK7CKiIiIfZicoEw9y/bAy5aVOWP/uLZYw5H1lgLTwUjLBuDsYSncZS7WEHif5ZfEgi41CZaNhC2fW/YD60PXrwrMCBQRyYOqPQL+tWF2b8tCOj/1gAbPQeux+XqErQpvIoWcwWDA2wWqli6Cs/Otv801m80kpqRz9rqC3PUFurOXkzl3OYVzCZb9C4kpmM1YR9PB5dvG4+ZstIykK+JKCc+rBburBbqSRVytxbviXi4U83DByaTJkUVEROQuGU2WEW0BdaHJQEsh7tSf1xZrOLLBMkfcP6ssG4CTG5RpcG2xhjIN8vUvhNk6dxB+fsZSlARo8hI8PKpwj/wTkXvDtyz0+g1WjoV1H8LWL+HoZnhser6dU1KFNxHJMYPBgKerE56uTpQrfvvl4tPSM7iQmMq5hGTrSDprwe5qge6MdURdMkmpGSSlZhBz8QoxF3M2mq6ohwvFryvQlbDOSZc5us7FWsjz1Gg6ERERuRWjyTLawr823D8AMjLgzL5rizUcXg+JZ+HwWssGYHKFMvWvLdZQpqFlxb786o+f4ddBkHLZsiJsAV1lUETyMJMzhI22fMExtx+c2gWfNcu3qyir8CYiduNkMlKyiCsli+TsdozElDTOXU7hTGZh7uqIuuwKducTUsgww/mEFM4npPD36duf39XJeN38c9cKdCW8rt0Km3kbbFFPF5w1mk5ERKRwMxrBr7pla9QXzGY4+9e1xRqOrIfLp67dproGMDpDYL2rizU8YJkvztXL0VdyeymJ8PtQiJ5p2S/3AHT5ErwDHBuXiBReFcOg/zqY28fyZce8vnBoDbR7D1xuPxAkr1DhTUTyDA8XJzyKORFU7PbfEqdnmLmQmGIt0J1NSOHspeTrRtdl3vJq2U9MSSc5Leej6QB8PZytBbrrF4y4fp46HzcjV9Ist+GKiIhIAWcwQMkqlq1Bb0sh7tzBa6PhDq+DSyfg2CbLtvYDMDqBf+i1xRqCGoGbt6OvJKvTey23lp7ZBxig+VBoNlSru4qI43n7Q48FsOZ/sPpd2PGtZYXlx6aBXw1HR5cj+iQVkXzJZDRYC2JQ5LbtM0fTnbuuQGcZRZe1QHf2cgrnE5LJMMPFxFQuJqZy8EzCbc7uxKjoyKtz0l0r0JUo4mJdNOL6eeqKaTSdiIhIwWAwWOYcKlER6j1jKcRdOHRtsYbD6yHuKMRss2zrJ4LBCP51rt6a+iCUvR/cfR0Tv9lsGeH221BIuwJefvDoF1ChuWPiERHJjtEELV6zjCSe8xyc3Q9fPGRZCfW+npbP4jxMhTcRKRTuZDRdRuZouoTrFozIvN01IevCEmcvJZOQkk5KWgYn4pI4EZeUo3h83J0tI+euFuiKX1egK3F1pdfiVwt53m5OmptOREQkPzAYoFgFy3bf05ZjF45cK8IdWQcXDsOJaMu28WPAAKVrXVusoVwT8Chm/1iT4uHXV2D3bMt+yEPQ+XPwKmn/1xYRuRvBTS23ns7rDweWwcKX4Z/V0GFS3htJfB0V3kRE/sVoNFwdueZKZb9bj6ZLTU1l/sLfaPBgS+KSMiyFuUspnE3IOk/dmUuWn+cTUkjPMBN3JZW4K6n8c9vRdOBsMlhH0F1/q+u1eequ/Szm6YKrkym3UiFyz2RkmElJzyA5NYPk9HTLz7QMUtIySE5Lv+7P2R2ztE9JtzyenJp+3bmu/kxLtz7f8rx0a9s63kbaOToBIlJwFS1n2UKftOzHHbeslnp4raUYd/6gZfXQ2D9g0yeAwXL7VOZiDeUeAM8SuRvTiR0wuxec/wcMJnh4JDR52TKnnYhIXuZZAp78yfLFReQY+HMunIiCrtMg8D5HR5ctFd5ERGzkYoJAX3eCnZ1v2zbjatHt7HUj6DILdGeuK9RlLiRxKTmN1HQzsfFJxMbnbDSdt5vTTeeky7zltbiXKyW9XPF212i6ws5sNpOWYb6hYJWSbcEq3Vq4yrbolZpBym2KZtef7/pjqemOmycxMR8vPigi+ZBPGajdzbIBxJ+8tjjD4XWWxRtO7bZsWz6ztClZ7VoRLrgpeJW6u9c2m2HL57B0BKSngE8QdPkKyjbKnWsTEbkXjEZ44CXLCOGfe1lGEn/VGlq/DY3657lbT1V4ExG5h4xGA0U9LaumVvK7ffuk1PQshbgsK7xedyvs2cuWlV7TMszEJ6URn5TGP2dvP5rOyWjIUqAr6ZV1TrrrF5Yo5umCm7NG0+WmOxnldWPBKp3E5DT2HDXyx+L9pGVwXbHsxudkGeX1r9fIa2uDGAyWVYhdnUy4OBmv/tmIi5Ppuj9bHs/cd3U24mIy4upsOWb587/Pce3PmT9NmNmxea2jL1lECjNvf6jV1bIBXD593a2p6+H0Hjiz17Jt/dLSpkTla0W4cg9YznE7Vy7AgoGw71fLfpX20Onje3Nbq4iIPZSpD/3XwC8vwt6FsHiYZdXTTlPy1GebCm8iInmYm7OJQF93An3db9s2I8NMfFKqtTD37znprPPVXS3YXUpKIy3DzKn4ZE7FJ+coniKuTllubc06J13m6DpLIc/H3RmjMW9925TpZqO8ri9I2WuU1/VtcmeUlxFijuTCeSycTYZsCl7XilzZFbEsRS/TdcWvG4tmrjecI2v764tmTkbDPRuJmZqayiGXe/JSIiI541UKanS2bAAJ564bEbfeMhLu7F+Wbfs0S5tiFa4W4ZpaRsb5lMlySsPxrTC/L8QdA5MLtH4HGvbNc6NCRETumHtR6DbT8sXEktdh/28w9UHo+hX413N0dIAKbyIiBYbRaMDXwwVfDxcqlvK6bfvktPSrt7lmnZPOOoruupF25xKSSU03cyk5jUvJaRw+l3jb8zsZDRS7elurpRiXWbC7VqDzcTVxNgkOnkkgA2OORnnddC6vfxXKrj0v/47yulnBK7OQ5WyCE8ePUTmkPB6uztkWsXJSNHO9rmiWV4ulIiKFlmdxqN7RsgEknoejG68t1hC7yzJX2/l/IGqGpY1vOQhuiqHM/VSKXY1pxzwwp0PR8vDYNAio67jrERHJbQYDNOwDQY3g52csc2dOa4ex+XAwV3R0dCq8iYgUVq5OJgJ83QnIwWg6s9lM/JW0Gwp0189Td/1tr/FXR9OdvpTM6Uu3G03nBNHrc+ei7tKtRnndeuRXzkZ53XyUmG2jvFJTU/nttyO0a1MF5xzMMSgiIgWARzGo2t6yAVy5CEc3WYpwh9fDyZ1w8QjsOILTju+onvm8ml3gkYl5euU/ERGb+NeGfqvh18Gw6ydMq97hfu/akNEWcFxfWYU3ERG5LYPBgI+HMz4ezoSUvH37lLQMzidkzkl3bdTcucspnLlu/+ylZM5fTsLNxfm2I7SyFr8sBSsX003m98rmHDfMCeakUV4iIlIAuPtClTaWDSD5EhzdDIfXknF4HYlnj+H28Gs4NXhWt5aKSMHnWgQe/RwqNMf82xAueFSgmNGx81TnycLblClTeP/994mNjaVOnTpMnjyZhg0b3rT9zz//zMiRIzl8+DCVKlVi/PjxtGvXzvq42WzmzTff5IsvvuDixYs88MADfPrpp1SqVOleXI6ISKHj4mSktI8bpX3cbtnOMmLrN9q1C9eILRERkdzgWgQqhUGlMNJTU4n87Tfa1W2nopuIFB4GA9T9P9ICGrB/4x5CHByO0cGvf4NZs2YxePBg3nzzTaKioqhTpw7h4eGcPn062/YbNmzgiSeeoHfv3kRHRxMREUFERAS7d++2tnnvvff46KOPmDp1Kps3b8bT05Pw8HCSkpLu1WWJiIiIiIiIiMi9UqwCGBxf9nJ8BP8yYcIE+vTpQ69evahevTpTp07Fw8ODr7/+Otv2kyZNok2bNgwZMoRq1arx9ttvc9999/Hxxx8DltFuEydOZMSIEXTq1InatWszY8YMTpw4wfz58+/hlYmIiIiIiIiISGGSpwpvKSkpbN++nbCwMOsxo9FIWFgYGzduzPY5GzduzNIeIDw83Nr+0KFDxMbGZmnj4+NDo0aNbnpOERERERERERERW+WpOd7Onj1Leno6fn5+WY77+fmxb9++bJ8TGxubbfvY2Fjr45nHbtbm35KTk0lOvrYKX3x8PGCZiyg1NfUOrihnMs9pj3MXBsqfbZQ/2yh/tlH+bKP82c7eOSxsfzd3Mk9vamoq48aN45tvviEmJoYqVaowfvx42rRpY22Tnp7O6NGj+fbbb4mNjSUgIIBnnnmGESNGZFkFeO/evbz22musXr2atLQ0qlevzpw5cyhbtqzdr1lERETkVvJU4S2vGDduHGPGjLnh+NKlS/Hw8LDb6y5btsxu5y4MlD/bKH+2Uf5so/zZRvmznb1ymJiYaJfz5kWZ8/ROnTqVRo0aMXHiRMLDw9m/fz+lSpW6of2IESP49ttv+eKLL6hatSpLliyhc+fObNiwgbp16wIwfvx4Pv30U7755htq1KjBtm3b6NWrFz4+Prz00ksAHDx4kKZNm9K7d2/GjBmDt7c3f/75J25ut17cRUREROReyFOFtxIlSmAymTh16lSW46dOnaJ06dLZPqd06dK3bJ/589SpU/j7+2dpExoamu05hw8fzuDBg6378fHxBAUF0bp1a7y9ve/4um4nNTWVZcuW0apVK63qdxeUP9sof7ZR/myj/NlG+bOdvXOYOWq+MLh+nl6AqVOnsmjRIr7++muGDRt2Q/uZM2fyxhtvWFeiHzBgAMuXL+eDDz7g22+/BSyLaHXq1In27dsDEBwczA8//MCWLVus58k8x3vvvWc9FhLi6PXLRERERCzyVOHNxcWFevXqERkZSUREBAAZGRlERkYycODAbJ/TuHFjIiMjGTRokPXYsmXLaNy4MQDly5endOnSREZGWgtt8fHxbN68mQEDBmR7TldXV1xdXW847uzsbNdfbOx9/oJO+bON8mcb5c82yp9tlD/b2SuHheXvJXOe3uHDh1uP3W6e3uTk5BtGpbm7u7Nu3TrrfpMmTfj888/566+/qFy5Mjt37mTdunVMmDABsPQTFy1axNChQwkPDyc6Opry5cszfPhwa19SRERExJHyVOENYPDgwfTs2ZP69evTsGFDJk6cSEJCgvXb0x49ehAYGMi4ceMAePnll2nevDkffPAB7du358cff2Tbtm18/vnnABgMBgYNGsQ777xDpUqVKF++PCNHjiQgIEAdMhEREZFccDfz9IaHhzNhwgSaNWtGSEgIkZGRzJ07l/T0dGubYcOGER8fT9WqVTGZTKSnpzN27FieeuopAE6fPs3ly5d59913eeeddxg/fjyLFy/m0UcfZeXKlTRv3vyG19VcvvmL8mcb5c82yp/tlEPbKH+2yStz+ea5wlv37t05c+YMo0aNIjY2ltDQUBYvXmztyB09ehSj8dpirE2aNOH7779nxIgRvP7661SqVIn58+dTs2ZNa5uhQ4eSkJBA3759uXjxIk2bNmXx4sU5nvvDbDYD9rtdJDU1lcTEROLj4wvNN+O5SfmzjfJnG+XPNsqfbZQ/29k7h5l9h8y+hFwzadIk+vTpQ9WqVTEYDISEhNCrVy++/vpra5uffvqJ7777ju+//54aNWqwY8cOBg0aREBAAD179iQjIwOATp068corrwAQGhrKhg0bmDp1araFt5vN5Tt//ny7zuW7YMECu527MFD+bKP82Ub5s51yaBvlzzb2yl/mXL637eeZ5baOHTtmBrRp06ZNmzZt2u5qO3bsmKO7M3aVnJxsNplM5nnz5mU53qNHD3PHjh1v+dwrV66Yjx8/bs7IyDAPHTrUXL16detjZcqUMX/88cdZ2r/99tvmKlWqWF/XycnJ/Pbbb2dpM3ToUHOTJk2yfb2kpCRzXFycdduzZ4/D3x/atGnTpk2btvy73a6fl+dGvOVFAQEBHDt2jCJFimRZuj63ZC7ecOzYMbss3lDQKX+2Uf5so/zZRvmzjfJnO3vn0Gw2c+nSJQICAnL93HnJ3czTm8nNzY3AwEBSU1OZM2cO3bp1sz6WmJiY5U4HAJPJZB3p5uLiQoMGDdi/f3+WNn/99RflypXL9vX+PZevl5eX+nl5mPJnG+XPNsqf7ZRD2yh/tskr/TwV3nLAaDRSpkwZu7+Ot7e3/jHZQPmzjfJnG+XPNsqfbZQ/29kzhz4+PnY5b15zp/P0bt68mZiYGEJDQ4mJiWH06NFkZGQwdOhQ6zk7dOjA2LFjKVu2LDVq1CA6OpoJEybw7LPPWtsMGTKE7t2706xZM1q2bMnixYtZuHAhq1atylHc6uflD8qfbZQ/2yh/tlMObaP82cbR/TwV3kRERETEZnc6T29SUhIjRozgn3/+wcvLi3bt2jFz5kx8fX2tbSZPnszIkSN5/vnnOX36NAEBAfTr149Ro0ZZ23Tu3JmpU6cybtw4XnrpJapUqcKcOXNo2rTpPbt2ERERkZsxmM2a7dfR4uPj8fHxIS4uTlXsu6D82Ub5s43yZxvlzzbKn+2UQ7E3vcdso/zZRvmzjfJnO+XQNsqfbfJK/oy3byL25urqyptvvpllvhHJOeXPNsqfbZQ/2yh/tlH+bKccir3pPWYb5c82yp9tlD/bKYe2Uf5sk1fypxFvIiIiIiIiIiIidqARbyIiIiIiIiIiInagwpuIiIiIiIiIiIgdqPAmIiIiIiIiIiJiByq8iYiIiIiIiIiI2IEKb/fIlClTCA4Oxs3NjUaNGrFly5Zbtv/555+pWrUqbm5u1KpVi99+++0eRZo33Un+pk+fjsFgyLK5ubndw2jzljVr1tChQwcCAgIwGAzMnz//ts9ZtWoV9913H66urlSsWJHp06fbPc686k7zt2rVqhvefwaDgdjY2HsTcB4ybtw4GjRoQJEiRShVqhQRERHs37//ts/T5981d5NDfQZe8+mnn1K7dm28vb3x9vamcePG/P7777d8jt5/cjfUz7ON+nl3T/0826ifZxv19Wyjfp5t8lM/T4W3e2DWrFkMHjyYN998k6ioKOrUqUN4eDinT5/Otv2GDRt44okn6N27N9HR0URERBAREcHu3bvvceR5w53mD8Db25uTJ09atyNHjtzDiPOWhIQE6tSpw5QpU3LU/tChQ7Rv356WLVuyY8cOBg0axHPPPceSJUvsHGnedKf5y7R///4s78FSpUrZKcK8a/Xq1bzwwgts2rSJZcuWkZqaSuvWrUlISLjpc/T5l9Xd5BD0GZipTJkyvPvuu2zfvp1t27bx0EMP0alTJ/78889s2+v9J3dD/TzbqJ9nG/XzbKN+nm3U17ON+nm2yVf9PLPYXcOGDc0vvPCCdT89Pd0cEBBgHjduXLbtu3XrZm7fvn2WY40aNTL369fPrnHmVXeav2nTppl9fHzuUXT5C2CeN2/eLdsMHTrUXKNGjSzHunfvbg4PD7djZPlDTvK3cuVKM2C+cOHCPYkpPzl9+rQZMK9evfqmbfT5d2s5yaE+A2+taNGi5i+//DLbx/T+k7uhfp5t1M/LPern2Ub9PNupr2cb9fNsl1f7eRrxZmcpKSls376dsLAw6zGj0UhYWBgbN27M9jkbN27M0h4gPDz8pu0LsrvJH8Dly5cpV64cQUFBt6x6y430/ssdoaGh+Pv706pVK9avX+/ocPKEuLg4AIoVK3bTNnr/3VpOcgj6DMxOeno6P/74IwkJCTRu3DjbNnr/yZ1SP8826ufde3r/5Q7187Knvp5t1M+7e3m9n6fCm52dPXuW9PR0/Pz8shz38/O76VwAsbGxd9S+ILub/FWpUoWvv/6aBQsW8O2335KRkUGTJk04fvz4vQg537vZ+y8+Pp4rV644KKr8w9/fn6lTpzJnzhzmzJlDUFAQLVq0ICoqytGhOVRGRgaDBg3igQceoGbNmjdtp8+/m8tpDvUZmNWuXbvw8vLC1dWV/v37M2/ePKpXr55tW73/5E6pn2cb9fPuPfXzbKN+3s2pr2cb9fPuTn7p5znZ/RVE7rHGjRtnqXI3adKEatWq8dlnn/H22287MDIpDKpUqUKVKlWs+02aNOHgwYN8+OGHzJw504GROdYLL7zA7t27WbdunaNDybdymkN9BmZVpUoVduzYQVxcHLNnz6Znz56sXr36pp0yEcnb9BknjqR+3s2pr2cb9fPuTn7p52nEm52VKFECk8nEqVOnshw/deoUpUuXzvY5pUuXvqP2Bdnd5O/fnJ2dqVu3LgcOHLBHiAXOzd5/3t7euLu7Oyiq/K1hw4aF+v03cOBAfv31V1auXEmZMmVu2Vaff9m7kxz+W2H/DHRxcaFixYrUq1ePcePGUadOHSZNmpRtW73/5E6pn2cb9fPuPfXzcl9h7+eB+nq2Uj/v7uWXfp4Kb3bm4uJCvXr1iIyMtB7LyMggMjLypvceN27cOEt7gGXLlt20fUF2N/n7t/T0dHbt2oW/v7+9wixQ9P7LfTt27CiU7z+z2czAgQOZN28eK1asoHz58rd9jt5/Wd1NDv9Nn4FZZWRkkJycnO1jev/JnVI/zzbq5917ev/lvsLazwP19Wylfl7uy7P9PLsv3yDmH3/80ezq6mqePn26ec+ePea+ffuafX19zbGxsWaz2Wx++umnzcOGDbO2X79+vdnJycn8v//9z7x3717zm2++aXZ2djbv2rXLUZfgUHeavzFjxpiXLFliPnjwoHn79u3mxx9/3Ozm5mb+888/HXUJDnXp0iVzdHS0OTo62gyYJ0yYYI6OjjYfOXLEbDabzcOGDTM//fTT1vb//POP2cPDwzxkyBDz3r17zVOmTDGbTCbz4sWLHXUJDnWn+fvwww/N8+fPN//999/mXbt2mV9++WWz0Wg0L1++3FGX4DADBgww+/j4mFetWmU+efKkdUtMTLS20effrd1NDvUZeM2wYcPMq1evNh86dMj8xx9/mIcNG2Y2GAzmpUuXms1mvf8kd6ifZxv182yjfp5t1M+zjfp6tlE/zzb5qZ+nwts9MnnyZHPZsmXNLi4u5oYNG5o3bdpkfax58+bmnj17Zmn/008/mStXrmx2cXEx16hRw7xo0aJ7HHHecif5GzRokLWtn5+fuV27duaoqCgHRJ03ZC57/u8tM2c9e/Y0N2/e/IbnhIaGml1cXMwVKlQwT5s27Z7HnVfcaf7Gjx9vDgkJMbu5uZmLFStmbtGihXnFihWOCd7BsssbkOX9pM+/W7ubHOoz8Jpnn33WXK5cObOLi4u5ZMmS5ocfftjaGTOb9f6T3KN+nm3Uz7t76ufZRv0826ivZxv182yTn/p5BrPZbM79cXQiIiIiIiIiIiKFm+Z4ExERERERERERsQMV3kREREREREREROxAhTcRERERERERERE7UOFNRERERERERETEDlR4ExERERERERERsQMV3kREREREREREROxAhTcRERERERERERE7UOFNRERERERERETEDlR4ExFxsOnTp2MwGNi2bZujQxERERGRXKR+noio8CYihUJmp+dm26ZNmxwdooiIiIjcBfXzRCQvc3J0ACIi99Jbb71F+fLlbzhesWJFB0QjIiIiIrlF/TwRyYtUeBORQqVt27bUr1/f0WGIiIiISC5TP09E8iLdaioictXhw4cxGAz873//48MPP6RcuXK4u7vTvHlzdu/efUP7FStW8OCDD+Lp6Ymvry+dOnVi7969N7SLiYmhd+/eBAQE4OrqSvny5RkwYAApKSlZ2iUnJzN48GBKliyJp6cnnTt35syZM3a7XhEREZHCQv08EXEUjXgTkUIlLi6Os2fPZjlmMBgoXry4dX/GjBlcunSJF154gaSkJCZNmsRDDz3Erl278PPzA2D58uW0bduWChUqMHr0aK5cucLkyZN54IEHiIqKIjg4GIATJ07QsGFDLl68SN++falatSoxMTHMnj2bxMREXFxcrK/74osvUrRoUd58800OHz7MxIkTGThwILNmzbJ/YkRERETyOfXzRCQvUuFNRAqVsLCwG465urqSlJRk3T9w4AB///03gYGBALRp04ZGjRoxfvx4JkyYAMCQIUMoVqwYGzdupFixYgBERERQt25d3nzzTb755hsAhg8fTmxsLJs3b85y68Nbb72F2WzOEkfx4sVZunQpBoMBgIyMDD766CPi4uLw8fHJxSyIiIiIFDzq54lIXqTCm4gUKlOmTKFy5cpZjplMpiz7ERER1s4YQMOGDWnUqBG//fYbEyZM4OTJk+zYsYOhQ4daO2MAtWvXplWrVvz222+ApUM1f/58OnTokO18I5kdr0x9+/bNcuzBBx/kww8/5MiRI9SuXfvuL1pERESkEFA/T0TyIhXeRKRQadiw4W0n3a1UqdINxypXrsxPP/0EwJEjRwCoUqXKDe2qVavGkiVLSEhI4PLly8THx1OzZs0cxVa2bNks+0WLFgXgwoULOXq+iIiISGGmfp6I5EVaXEFEJI/49zeymf59q4KIiIiI5C/q54kUXhrxJiLyL3///fcNx/766y/rRLrlypUDYP/+/Te027dvHyVKlMDT0xN3d3e8vb2zXSlLRERERO499fNE5F7TiDcRkX+ZP38+MTEx1v0tW7awefNm2rZtC4C/vz+hoaF88803XLx40dpu9+7dLF26lHbt2gFgNBqJiIhg4cKFbNu27YbX0TecIiIiIveW+nkicq9pxJuIFCq///47+/btu+F4kyZNMBot30VUrFiRpk2bMmDAAJKTk5k4cSLFixdn6NCh1vbvv/8+bdu2pXHjxvTu3du6zLyPjw+jR4+2tvvvf//L0qVLad68OX379qVatWqcPHmSn3/+mXXr1uHr62vvSxYREREpFNTPE5G8SIU3ESlURo0ale3xadOm0aJFCwB69OiB0Whk4sSJnD59moYNG/Lxxx/j7+9vbR8WFsbixYt58803GTVqFM7OzjRv3pzx48dTvnx5a7vAwEA2b97MyJEj+e6774iPjycwMJC2bdvi4eFh12sVERERKUzUzxORvMhg1hhYEREADh8+TPny5Xn//ff5z3/+4+hwRERERCSXqJ8nIo6iOd5ERERERERERETsQIU3ERERERERERERO1DhTURERERERERExA40x5uIiIiIiIiIiIgdaMSbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIjaaPn06BoOB6dOn39XzW7RogcFgyN2gRERERCTPCQ4OJjg4OMsxW/uSIpK3qfAmInna4cOHMRgMWTYXFxeCgoJ48skn+eOPPxwdooiIiIjcQ9n1D52dnQkMDKRbt25s27bN0SGKiFg5OToAEZGcCAkJ4f/+7/8AuHz5Mps2beKHH35g7ty5REZG8sADDzgsts6dO3P//ffj7+9/V8+fMWMGiYmJuRyViIiISMF2ff8wISGB7du38/PPPzN//nyWL19Os2bNHByhiIgKbyKST1SsWJHRo0dnOTZixAjGjh3LG2+8wapVqxwSF4CPjw8+Pj53/fyyZcvmYjQiIiIihUN2/cN3332X4cOHM3LkSFavXu2YwERErqNbTUUk33rxxRcB2Lp1KwAGg4EWLVoQExNDjx49KF26NEajMUtRbs2aNXTo0IESJUrg6upKpUqVGDFixE1HnK1Zs4aIiAj8/PxwdXUlKCiIRx99lHXr1lnb3GxejqioKLp27UrZsmVxdXWlZMmSNGjQgLFjx2Zpd7M53tLS0pgwYQJ16tTB3d0dHx8fWrZsycKFC29oe30MS5cupUmTJnh4eFC8eHF69uzJuXPncpRTERERkfysd+/eAGzfvj3L8ZSUFCZMmMB9992Hp6cnRYoU4cEHH+SXX37J9jwpKSl8+OGHNGjQgCJFiuDl5UX16tUZPHgwFy5csLZbuXIlzz77LFWqVMHLywsvLy/q16/P559/br+LFJF8RSPeRCTfu75ode7cORo3bkyxYsV4/PHHSUpKwtvbG4BPP/2UF154AV9fXzp06ECpUqXYtm0bY8eOZeXKlaxcuRIXFxfruSZNmsQrr7yCu7s7nTt3pmzZssTExLBu3Tpmz55N06ZNbxrTjh07aNKkCSaTiU6dOlGuXDkuXrzInj17+Pzzz3njjTdueU1ms5muXbuyYMECKleuzAsvvEBCQgKzZs2iY8eOTJgwgVdeeeWG5/3yyy8sWrSIDh060KRJE9asWcOMGTM4ePBglmKhiIiISEHm5HTtV93k5GTatGnDqlWrCA0NpXfv3qSmprJo0SI6derE5MmTGThwoLX9lStXaNWqFevXr6dSpUr06tULV1dX/v77bz777DN69OhB0aJFARg/fjwHDhzg/vvvp3Pnzly8eJHFixfTr18/9u/fzwcffHDPr11E8hYV3kQk3/rkk08AaNiwofXY7t276dWrF1988QUmk8l6fM+ePbz00kvUrl2byMhIihcvbn0s85aEyZMn8+qrrwKwc+dOBg8ejL+/P+vXr8+y+pTZbObkyZO3jG3mzJkkJyczf/58OnXqlOWxnIw+mzlzJgsWLKB58+YsXbrUWhAcPnw49erVY+jQoXTq1IkKFSpked7ChQtZtWqVdc679PR0wsLCWLVqFZs2beL++++/7WuLiIiI5FdffvklQJYvSN966y1WrVrFyJEjGTNmjPVL20uXLvHQQw/x6quv8uijjxIQEADAyJEjWb9+PU8//TTTpk3L0qeMi4vLsv/pp59Svnz5LDGkpaXRrl07Jk2axMsvv6xpRUQKOd1qKiL5woEDBxg9ejSjR49myJAhNGvWjLfeegs3N7cst266uLjw3nvvZekQAXz22WekpaUxefLkLEU3gKFDh1KyZEl++OGHLO0zMjJ45513bljy3WAwWDtmt+Pu7n7DsX+/fna++eYbAN57770so/DKli3LK6+8QlpaGt99990Nz3vyySezLDRhMpno2bMncO2WXBEREZGC4N/9w4ceeojXX38dPz8/3n//fQAyMjL49NNPCQkJyVJ0AyhSpAijRo0iJSWFuXPnApai2eeff46Pjw+TJk26oU/p4+ODl5eXdf/fRTewjLbr378/6enprFy50h6XLiL5iEa8iUi+cPDgQcaMGQOAs7Mzfn5+PPnkkwwbNoxatWpZ25UvX54SJUrc8PxNmzYBsGTJEiIjI2943NnZmX379ln3t2zZAkDr1q3vKt5u3boxceJEOnfuTPfu3WnVqhXNmjUjMDAwR8+Pjo7Gw8Mjy2i+TC1btgQst7P+W7169W44VqZMGQAuXryY8wsQERERyeOu7x9mKl26NGvXrqVixYoA7N+/nwsXLhAQEHBDW4AzZ84AWPuB+/bt49KlS4SFhVlvJ72VS5cu8b///Y/58+dz8OBBEhISsjx+4sSJu7o2ESk4VHgTkXwhPDycxYsX37adn59ftsfPnz8PcMPCBjcTFxeHwWDA398/50Fep1GjRqxatYr//ve/fP/990ybNg2ABg0aMH78eGvx7Gbi4+MJCgrK9rHMmOLj4294LHM+u+tlznGSnp5+R9cgIiIikpdd3z88c+YM33zzDa+99hodO3Zky5YteHl5WfuAf/75J3/++edNz5VZMIuLiwPI0ZelKSkptGjRgqioKOrWrcvTTz9N8eLFcXJy4vDhw3zzzTckJyfbepkiks+p8CYiBUp2q4PCtYJUfHw8RYoUue15fH19rXO55XSU2r89+OCD/P7771y5coXNmzezcOFCPvnkE9q3b8/u3btvmJ/t3/GePn0628diY2OtbUREREQESpYsyX/+8x/i4uJ45513GDFiBBMnTrT2l7p06cLs2bNvex5fX18AYmJibtt2wYIFREVF0bt3b+vccpl+/PFH69QhIlK4aY43ESkUGjVqBFy75fR2Mm/xXLp0qc2v7e7uTosWLfjggw94/fXXuXLlCsuWLbvlc+rWrUtiYqL1ltfrrVq1CoDQ0FCbYxMREREpSF5//XUCAgL45JNPOHz4MNWqVcPb25tt27aRmpp62+dXqVIFb29vtm7dyoULF27Z9uDBgwA3LKQFsHbt2ru7ABEpcFR4E5FC4fnnn8fJyYkXX3yRo0eP3vD4xYsXiY6Otu73798fk8nEiBEjOHLkSJa2ZrP5tvN1bNy4kaSkpBuOnzp1CgA3N7dbPj9zQYThw4dn6SQeO3aMCRMm4OTkxFNPPXXLc4iIiIgUNu7u7rz22mukpqby9ttv4+TkxIABAzhy5Aj/+c9/si2+7d6923qngZOTE/369SMuLo6XX375hqk64uLiuHz5MgDlypUDYN26dVnarF69mi+++MIelyci+ZBuNRWRQqFmzZp88sknDBgwgCpVqtCuXTtCQkK4dOkS//zzD6tXr+aZZ55h6tSpANSqVYuJEyfy0ksvUaNGDSIiIihXrhyxsbGsWbOG9u3bM3HixJu+3vjx41m5ciXNmjWjfPnyuLm5ERUVRWRkJBUqVKBz5863jPfpp59m7ty5LFiwgNq1a/PII4+QkJDArFmzOH/+PB988MEtb1UVERERKaz69u3L+PHjmTFjBq+//jpjxowhKiqKjz76iEWLFtGsWTNKlSpFTEwMu3btYufOnWzcuJFSpUoB8NZbb7Fp0yZmzpzJpk2baNu2La6urvzzzz8sXryYdevWERoaSocOHQgODua9995j9+7d1KxZk/379/Prr7/SuXPnHN3aKiIFnwpvIlJo9OnTh9DQUCZMmMCaNWtYuHAhPj4+lC1blldeecU6yizTwIEDqVmzJh988AG///47ly9fplSpUjRq1Ihu3brd8rUGDBiAj48PmzdvZvXq1ZjNZsqWLcvrr7/OK6+8ctv52QwGA7Nnz2bSpEl88803TJ48GRcXF+677z4GDx5Mx44dbc6HiIiISEHk5ubG8OHDefHFFxkzZgwzZszg999/56uvvmLGjBnMmTOH5ORk/Pz8qF69Ov3796dWrVpZnr9s2TI+/vhjvv32W7744gtMJhNly5alf//+BAcHA+Dl5cWKFSsYMmQIa9asYdWqVdSoUYPvvvsOPz8/Fd5EBACD2Ww2OzoIERERERERERGRgkZzvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ2oMKbiIiIiIiIiIiIHajwJiIiIiIiIiIiYgcqvImIiIiIiIiIiNiBCm8iIiIiIiIiIiJ24OToAPKDjIwMTpw4QZEiRTAYDI4OR0RERPIJs9nMpUuXCAgIwGjU9515kfp5IiIicjdy2s9T4S0HTpw4QVBQkKPDEBERkXzq2LFjlClTxtFhSDbUzxMRERFb3K6fp8JbDhQpUgSwJNPb2zvXz5+amsrSpUtp3bo1zs7OuX7+gk75s43yZxvlzzbKn22UP9vZO4fx8fEEBQVZ+xKS96ifl7cpf7ZR/myj/NlOObSN8mebvNLPU+EtBzJvO/D29rZbh8zDwwNvb2/9Y7oLyp9tlD/bKH+2Uf5so/zZ7l7lULcw5l3q5+Vtyp9tlD/bKH+2Uw5to/zZJq/08zTZiIiIiIiIiIiIiB2o8CYiIiIiIiIiImIHKryJiIiIiIiIiIjYgQpvIiIiIiIiIiIidpCnCm9r1qyhQ4cOBAQEYDAYmD9//m2fs2rVKu677z5cXV2pWLEi06dPv6HNlClTCA4Oxs3NjUaNGrFly5bcD15EREREbkr9PBERESmM8lThLSEhgTp16jBlypQctT906BDt27enZcuW7Nixg0GDBvHcc8+xZMkSa5tZs2YxePBg3nzzTaKioqhTpw7h4eGcPn3aXpchIiIiIv+ifp6IiIgURk6ODuB6bdu2pW3btjluP3XqVMqXL88HH3wAQLVq1Vi3bh0ffvgh4eHhAEyYMIE+ffrQq1cv63MWLVrE119/zbBhw3L/IkRERETkBurniYiISGGUpwpvd2rjxo2EhYVlORYeHs6gQYMASElJYfv27QwfPtz6uNFoJCwsjI0bN97LUEXyJrMZw+E1VD0xG+PKaDDlqUGw+YIxPYNqJw4of3dJ+bON8mc7Y3oGpePMQDtHhyL/on6eyN2JT0ol5sIVYi5c4ei5y2w6amTfsr8x6v+JO5aRnsEB5c8myqFtlD/bZKRncPmMweG9vHxdeIuNjcXPzy/LMT8/P+Lj47ly5QoXLlwgPT092zb79u276XmTk5NJTk627sfHxwOQmppKampqLl4B1vNe/1PujPJ3FzLSMexfhHHjRzid3EEVgFOODip/MgGVQfm7S8qfbZQ/25mAUiUestv/Ifq/6e6pnyeg/P2b2WzmfEIKMReTiLl4hRNxScRcTOLERUuhLSYuiUtJaf96lhFiDjkk3oLByDLlz0bKoW2UP1vULmZweD8vXxfe7GXcuHGMGTPmhuNLly7Fw8PDbq+7bNkyu527MFD+bs+YkUrQ+XVUPP0bXsmW39TTDC6cKNqAVJOng6MTEXGM856V+cNO/4ckJiba5bxy99TPy58KS/4yzBCXAueT4UKyIevPFMvP1AzDbc/j6WSmqCsUczXj45LHJvYWEbmHAjzNdvs/JKf9vHxdeCtdujSnTmX9mv/UqVN4e3vj7u6OyWTCZDJl26Z06dI3Pe/w4cMZPHiwdT8+Pp6goCBat26Nt7d37l4ElirpsmXLaNWqFc7Ozrl+/oJO+cuBpHiM0dMxbp6KISSADbkAAKKeSURBVMEy4bTZzZeM+s+REtqT6PXRyt9d0vvPNsqfbZQ/26WmprLbjjnMHE0ld079PIGCl7+UtAxOxidZRqdljlSLu/rzYhKxcUmkZZhveQ6DAUp5uRLg60aArztlfN0J8HUj8Op+gI8bnq6WX/MKWv7uNeXPdsqhbZQ/29g7fznt5+Xrwlvjxo357bffshxbtmwZjRs3BsDFxYV69eoRGRlJREQEABkZGURGRjJw4MCbntfV1RVXV9cbjjs7O9v1zW7v8xd0yl82Lp2CTZ/Atq8h+eqHgncgNB6I4b4emFy9cE5NBaKVPxspf7ZR/myj/NnOXjnU38vdUz9Prpdf8peYkkbMhSscv3iF41fnWYu5eIWYC4nEXLzC6UvJmG9dV8PJaMDf141AX3cCfT0ILOpOmaKWAltgUXdK+7jh6mS6o7jyS/7yKuXPdsqhbZQ/2zi6n5enCm+XL1/mwIED1v1Dhw6xY8cOihUrRtmyZRk+fDgxMTHMmDEDgP79+/Pxxx8zdOhQnn32WVasWMFPP/3EokWLrOcYPHgwPXv2pH79+jT8f/buO67q6n/g+Ovey94uhrhxL3DPXKm4ypnmyD3SzPUr01JTK/laZpha7l1muRrmwJUbnKWpuLeAmw2Xe+/vj4/cREDBC9wLvJ+PBw/4nPsZ78/hMu77nnPedesSGBhITEyMsfqVEHnSg8tw6Fs4tRZ0T9exKVIRGo2Gqt3Aysa88QkhhMh35P88kdsZDAaexGmVhNrTNdWUr2ON249iX77ej521WkmqFXDA201Jqhk/F7DH3dkOjfrl00mFEELkDhaVeDt27BjNmzc3bidPA+jXrx8rVqzg7t273Lhxw/h46dKl2bJlC2PHjmXOnDkUK1aMJUuWGEvMA/To0YN79+4xZcoUwsLC8PPzY9u2bakW4hUiT7hzEg4EwrnfwKBX2orXg0ZjoHwbUMsKH0IIIcxD/s8Tlk6vN3A/OoFbj58dqRbHrUf/JdZiEnUvPY+znRXFnkuqeT+TXCvoaINKJYk1IYTILywq8dasWTMMLxh7vWLFijSPOXny5AvPO3LkyBdOORAiVzMY4MpeOBiofE5Wzh8aj4WSDcwUmBBCCPEf+T9PmFuSTs/dJ/HGJNqzn289iuXOk3gSk/QvPU9hJxu8CzgYp34qU0Kffl3AHhc7mQ4mhBDiPxaVeBNCZIJep4xsOxAId08pbSoNVOumTCn1qGLO6IQQQgghclS8VpdmUi35890ncbykbgFqFXi62D1dV80hxWi15M921plbX00IIUT+Jok3IXIbbTz8vVZZw+3hFaXNyh5q9YMG74FbCfPGJ4QQQgiRDaLitcrotIdPE2rJU0Gffr4fnfDSc9ho1EoFUOPUz5TJNU9XO6w1sjSHEEKIrCOJNyFyi/gncHQpHPkeYiKUNvsCUHcY1B0KjoXMG58QQgghxCsyGAw8jEl8rmhBHDcfxnD+hobJJ3cTGZ/00vM42mieG6HmYCxaUMzNnsJOtqilcIEQQogcJIk3ISxdVBgc+Q6OLYeESKXNpRg0HAk1+4KNo3njE0IIIYR4CZ3eQERU/DNrqsU9Ux00ljuP44nTple4QAUoSbcCDtbPrKvmkKJoQbEC9rjaW0vhAiGEEBZFEm9CWKoHl+HgHGVaqS5RaStSSVm/rVo30MjCvUIIIYSwDIlJeu4+STn1M7lowe3HcYQ9iUere8kCa4C7s+3TEWrKFFBPFxvuXDxDp5avUbKIM4628vJFCCFE7iJ/uYSwNLdPKBVKz/4GPP0HtXh9aDxGqVSqlnVHhBBCCJGzYhOTUiXVnk2uRUQl8IKitQBYqVV4utopibWno9WerQzq5WaHrVXKwgVarZY/75+mnIcT1tby0kUIIUTuI3+9hLAEBgNc2QMHvoGr+/5rL98GGo2Bkg3MFpoQQggh8jaDwUBkXBK3Hscq0z+frwr6OI6HMYkvPY+tlTpF0YJiz1UD9XCxQyPrqwkhhMhnJPEmhDnpdXB2MxwIhLB/lDa1FVTtpkwp9ahszuiEEEIIkQcYDAbuRSekKFrwfHItOuHlhQuc7ayM66klJ9SerQpayNFG1lcTQgghniOJNyHMQRsPp36AQ3Ph0VWlzdoBavaDBu+BW3HzxieEEEKIXCNJpycsMmXhgmdHq91+HEdikv6l5ynsZJNihJry9X9VQV3sZH1ZIYQQIrMk8SZETop7DMeWwpEFEBOhtNkXhHrDoO5QcCho1vCEEEIIYXnitTruPH5+XbX/vg6LjEenf/ECa2oVeLrY/ZdUe3adtadtdtaaF55DCCGEEJkniTchckLkXTjyHRxbDolRSptrcWgwEmq+AzaO5o1PCCGEEGYTFa9NNf3z1jPJtfvRCS89h41GjZeb3X/TQJ8m1ZKnhnq62mGtkQJNQgghRE6TxJsQ2en+RTg4B/5ZB7qnixK7V1bWb6vaFTQyZUMIIYTIywwGA9FaOH37CeFR2v9GqyUn2B7FEhn/8vXVHGw0z6yrljqxVsTJFrUULhBCCCEsjiTehMgOt47DwW/g3B/A06kfJRpA47FQrjXIwsNCCCFEvvDm/MOcD7eCY8Ev3M/NwfqZddX+K1qQPILNzcFaChcIIYQQuZAk3oTIKgYDXN6lVCi9tv+/9grtoNEYKFHPXJEJIYQQwkwKOtlAOLg726ZYX62Y29PkWgF7irrZ42Qr/5YLIYQQeZH8hRfCVLokOLsZDgZC2GmlTW0F1bpDo1HgXsmc0QkhhBDCjGa/VZ2De3byZofWWFvLEhNCCCFEfiOJNyFelTYOTv0Ah+bCo2tKm7Uj1OoH9UeAW3GzhieEEEII8yvkaIOV1DQQQggh8i1JvAmRWXGP4OgSCF4IMfeUNvuCUO9dqDsEHAqaNz4hhBBCCCGEEEJYBEm8CZFRkXfg8Hw4vgISo5U21xLQ8H2o0QdsHMwanhBCCCGEEEIIISyLJN6EeJl7F+DQHPh7Hei1Spt7FWg8Bqp0Bo2s1yKEEEIIIYQQQojUJPEmRHpuHlUKJpzfAhiUtpKNlAql5VqBSmXG4IQQQgghhBBCCGHpJPEmxLMMBri0Ew4EwvUD/7VXaK+McCte11yRCZFnPIpJJDQ8igvhUZy784STF9SsiziGWiWrj2eW3qDn/n3pP1PoDXo8dSramTsQIYQQQgiRJ0niTQgAXRL8uwkOzoHw00qb2gqq94CGo8C9onnjEyIXik5I4kJ4FBfCorgQHs2F8ChCw6O4F5Xw3J5qePLQLDHmDWouSP+ZpJGHjGAWQgghhBDZQxJvIn9LjIVTP8Chb+HxDaXN2hFq9YcGI8C1mFnDEyI3iNfquHzvaWItLPlzFLcfx6V7TPGC9lTwcKZsEUcib1+iVg0/rKw0ORh13pCUpOPUqVP4+Un/vaqkJB23Q0+aOwwhhBBCCJFHSeJN5E+xD+HoUgj+HmIfKG0OhaDecKgzCBwKmjc+ISxQkk7PtQcxXAiPJjQsyjiC7dr9GPSGtI/xcLGlvIczFTycKe+pfC7r7oSjrfLnR6vV8uefF2nn64W1tRQqySytVovV7ZPSfybQarX8eVsSb0IIIYQQIntI4k3kL09uw+H5cHwFaGOUNrcSynRSv95g42DW8ISwBHq9gduP4wgNizKuxRYaFsWVezEk6vRpHuNqb00Fz5QJtvIeTrg52ORw9EIIIYQQQghhOSTxJvKHe6HK+m3//Ax6rdLmUVWpUFqlM2jkR0HkPwaDgXtRCYQ+TawpI9iiuRgeRWyiLs1jHGw0lH+aVCvv4WxMthVxtkUllX6FEEIIIYQQIgXJNoi87WaIUqE0dMt/bSUbKxVKy7YESRSIfOJxbKIxuXYhPNo4ku1xrDbN/W00anzcnajg4fTMCDZnvN3sUavl50YIIYQQQgghMkISbyLvMRjgYhAcDITrB/9rr9hBGeFWvI65IhMi28UkJHExIpoLz00TjUhVSVShVkGpwo7GxFoFT+VzqUIOWGnUORy9EEIIIYQQQuQtkngTeYc+Cf7ZpIxwi/hXaVNbg28PaDgaipQ3a3hCZKWEJB2XI2K4GBGVotDBzYfpVxItVsDeuAZb8lRRnyJO2FlLNUwhhBBCCCGEyA6SeBO5nzaW0vd2YPXdJ/DkptJm4wS1+kP9EeDqbdbwhDBFkk7P9YexqUawXXsQiy6dUqJFnG2fGcGmJNjKeTjjZCu/8oUQQgghhBAiJ8mrMJF7xT6EkMVYhSykeuwDpc2hMNR/F+oMBvsC5o1PiEwwGJRKokpiLdqYYLt0L5rEpLQribrYWRmnhiZ/Lu/hTEFHqSQqhBBCCCGEEJZAEm8i93lyCw7Ph+MrQRuDCoixKYJd8w/R1O4L1vbmjlCIdBkMBu5FJ3AhTClwcPHpFNGL4dFEJySleYy9tSZFFdHkz+5SSVQIIYQQQgghLJok3kTuEXEeDs6B0z8r67kBeFQjqcH77LpmTdvab6CxtjZvjEI840mslgvPrsH29POjdCqJWmtU+BR5LsHm4UyxAlJJVAghhBBCCCFyI0m8Cct3IxgOfAMXtv7XVuo1aDwGfF7HkJSE4fqfZgtPiAQd/HPrCVcePJ0qGq5UFQ2LjE9zf7UKShVyVKaGPi10UMHDmVKFHbGWSqJCCCGEEEIIkWdI4k1YJoMBLu5QEm43Dj9tVEGlDtBoLBSrZdbwRP6UmKTnyv3oZ0awRRMaFsmtRxoMIcFpHuPtZq9ME/V0NhY8KOsulUSFEEIIIYQQIj+QxJuwLDotnNmgTCmNOKu0qa3B921oNBoKlzNvfCJf0OkN3HgY+1+CLTyKC2FRXL0fQ1KalURVFHK0SVXooJyHEy52Mv1ZCCGEEEIIIfIrSbwJy5AYAydWw+F58OSm0mbjBLUHQP0R4FLUvPGJPMlgMHDnSTwXwv5LroWGR3EpIpqEdCqJOttZKSPXno5g8ylsz/V/jtC9Y2usZY1BIYQQQgghhBDPkMSbMK/YhxCyCIIXQtxDpc2xCNR7F+oMAvsC5o1P5Bn3oxP+S7AZCx2kX0nUzlpNOffkEWz/FTzwdLFLUUlUq9Xy4FxO3YUQQgghhBBCiNxEEm/CPB7fhMPz4cRK0MYqbQVKQcNR4NcLrO3NGp7IvZ7EabkYriTVnq0k+iAmMc39rdRKJdFyTwscJI9kK17QAY1UEhVCCCGEEEIIYQKLS7zNnz+fr776irCwMHx9fZk7dy5169ZNc1+tVktAQAArV67k9u3bVKhQgZkzZ9KmTRvjPlFRUUyePJlNmzYRERFBjRo1mDNnDnXq1MmpWxLPCj+rrN92Zj3on4408qyuVCit1BE0FveUFBYqLlHHpYjo50awRXH3SdqVRFUqKFnQIcUabBU8nSlVyBEbK6kkKoQQQgghhBAi61lUlmPdunWMGzeOBQsWUK9ePQIDA/H39yc0NBR3d/dU+0+aNIk1a9awePFiKlasyPbt2+ncuTOHDh2iRo0aAAwePJgzZ86wevVqihYtypo1a2jZsiVnz57F29s7p28x/7p+GA4GwoVt/7WVbgKNxoBPCyUrIkQaEpP0XHsQ80wlUeXz9YexGNKqcwB4udqlTLA9rSRqbyOVRIUQQgghhBBC5ByLSrzNnj2bIUOGMGDAAAAWLFjAli1bWLZsGRMmTEi1/+rVq/nkk09o164dAMOHD2fnzp18/fXXrFmzhri4ODZs2MCvv/5KkyZNAJg6dSq///4733//PZ9//nnO3Vx+pNfDxe1wIBBuHnnaqIJKbygj3LxrmTE4YWl0egM3H8amKHJwITyKK/fSqyQKBR1tqPBMgq28hxPlPJxxtZciB0IIYamyenaDTqdj6tSprFmzhrCwMIoWLUr//v2ZNGlSijU5hRBCCCHMwWISb4mJiRw/fpyJEyca29RqNS1btuTw4cNpHpOQkICdnV2KNnt7ew4cOABAUlISOp3uhfukd96EhATjdmRkJKD886fVajN3YxmQfM7sOLdZ6LSo/t2I5shcVPfOA2DQ2GCo1h1d/ZFQqKyyXxbdb57rvxyW0/1nMBgIi0zgYkS0sg5bRDQXw6O5dC+aeG3alUQdbTWUd3dSEmtPP5d3d6KQk22a++fkc0Gef6aR/jON9J/psrsP5XuTUnbMbpg5cybff/89K1eupEqVKhw7dowBAwbg6urKqFGjcvoWhRBCCCFSsJjE2/3799HpdHh4eKRo9/Dw4Pz582ke4+/vz+zZs2nSpAk+Pj7s2rWLjRs3otPpAHB2dqZBgwZ89tlnVKpUCQ8PD9auXcvhw4cpW7ZsurEEBAQwbdq0VO07duzAwcHBhLt8saCgoGw7d07Q6BIo+WAvPhFbcdAqFUq1ajuuFX6dK+6tiVcVgOALwIVsuX5u7z9zy47+i9bC3VgVd2Offo5TERYLcbq0RyBYqwx4OICXvQEvBwOeDuDlYKCATRIqVQLwAB7Bo0cQnPavBbOR559ppP9MI/1nuuzqw9jY2Gw5b26V1bMbAA4dOkTHjh1p3749AKVKlWLt2rWEhITk0F0JIYQQQqTPYhJvr2LOnDkMGTKEihUrolKp8PHxYcCAASxbtsy4z+rVqxk4cCDe3t5oNBpq1qxJz549OX78eLrnnThxIuPGjTNuR0ZGUrx4cVq3bo2Li0uW34dWqyUoKIhWrVphbZ0Lp8jFPkB9dDHq40tRxT0CwODojr7uMKjZn1J2rpTKxsvn+v4zs6zov6j4JC5FKKPXLoRHG0ezpVdJVKNWUbqQQ8oRbB5OFC+Q+yqJyvPPNNJ/ppH+M11292HyqHmRPbMbABo2bMiiRYu4cOEC5cuX5++//+bAgQPMnj073XPKzIbcQ/rPNNJ/ppH+M530oWmk/0xjKTMbLCbxVrhwYTQaDeHh4Snaw8PD8fT0TPOYIkWKsHnzZuLj43nw4AFFixZlwoQJlClTxriPj48Pf/31FzExMURGRuLl5UWPHj1S7PM8W1tbbG1TT2GztrbO1hc22X3+LPf4BhyaBydWQVKc0lagNDQahcq3FxprO3JyKftc138WJiP9F69VKoleCI8yrsV2ITya24/j0j2mhLGSqJOx4EHpwo7YWuWtQgfy/DON9J9ppP9Ml119KN+X/2TH7AaACRMmEBkZScWKFdFoNOh0Or744gt69+6d5jllZkPuJP1nGuk/00j/mU760DTSf6Yx98wGi0m82djYUKtWLXbt2kWnTp0A0Ov17Nq1i5EjR77wWDs7O7y9vdFqtWzYsIHu3bun2sfR0RFHR0cePXrE9u3b+fLLL7PjNvKH8H/h4Bw4vR4MT//x9fJVKpRW7gjqvJVQyY+0Oj3X7sc8V+ggmusPYkinzgGeLnaU93SmgofT00IHzpTzcMLBxmJ+zQghhMhlMjK74eeff+aHH37gxx9/pEqVKpw6dYoxY8ZQtGhR+vXrl+qcMrMhd5H+M430n2mk/0wnfWga6T/TWMrMBot6RTxu3Dj69etH7dq1qVu3LoGBgcTExBjXAenbty/e3t4EBAQAEBwczO3bt/Hz8+P27dtMnToVvV7P+PHjjefcvn07BoOBChUqcOnSJT788EMqVqxoPKfIIIMBbhxWKpRe3P5fe+mm0HgslGkGUjksV0rQ6jj9UMX1v65w6V4sF8KjuHwvGq0u7Qybm4N1ikqiFTydKe/ujKuD/CEQQgiRvuya3fDhhx8yYcIE3n77bQCqVavG9evXCQgISDPxJjMbcifpP9NI/5lG+s900oemkf4zjblnNlhU4q1Hjx7cu3ePKVOmEBYWhp+fH9u2bTNOSbhx4wZqtdq4f3x8PJMmTeLKlSs4OTnRrl07Vq9ejZubm3GfJ0+eMHHiRG7dukXBggXp2rUrX3zxhTxpM0qvhwvb4MA3cCt5kWKVMrKt0WjwrmnW8IRpnsRp6bk4hLN3NRB6KcVjjjYaynk4U8HD+elINmfKezpRxMkWlSRZhRBCZFJ2zW6IjY1N8f8hgEajQa9Pu1K2EEIIIUROsqjEG8DIkSPT/edr7969KbabNm3K2bNnX3i+7t27pzn1VLxEUiKcWa9MKb33dN0VjQ349YKGo6CQj3njEyaLSUhiwPIQzt6NwsHKQKsqRano5Wpci62oqz3qXFboQAghhGXLjtkNb7zxBl988QUlSpSgSpUqnDx5ktmzZzNw4ECz3KMQQgghxLMsLvEmzCwhGk6shMPzIfK20mbrArUHQv3h4Jz2VBCRu8RrdQxZdYwTNx7jam/FsHLxDOlWTUaCCiGEyFbZMbth7ty5TJ48mREjRhAREUHRokUZNmwYU6ZMyenbE0IIIYRIRRJvQhFzH4IXQsgiiH+stDl5KMm22gPBztWs4Ymso9XpGfnjCQ5dfoCjjYalfWtx+5+D5g5LCCFEPpHVsxucnZ0JDAwkMDAwiyIUQgghhMg6knjL7x5dh8Pz4MRqSIpT2gqWUdZvq/42WNuZNz6RpXR6A2PXnWLnuQhsrdQs7V8H32Iu3P7H3JEJIYQQQgghhBB5jyTe8quwM8r6bWc2gEGntHn5KRVKK70Bao1ZwxNZT6838PHG0/zxz12sNSoWvFOL+mUKodVqzR2aEEIIIYQQQgiRJ0niLT8xGOD6IaVC6aWg/9rLNIfGY6B0U5BqlXmSwWDgsy1nWXfsJmoVfPt2DZpXcDd3WEIIIYQQQgghRJ4mibf8QK+H0D/hYCDcOqq0qdRQuaMypbRoDbOGJ7Lf7KALLD94DYAvu/nStpqXeQMSQgghhBBCCCHyAUm85WVJiXD6Z2VK6f0LSpvGFvx6QcP3oZCPeeMTOWLBX5eZu/sSAJ91rEK3WsXMHJEQQgghhBBCCJE/SOItL0qIguMr4fB8iLqjtNm6QJ1BUG84OHuYNz6RY1Yfvsb/tp4H4KM2FXmnQSnzBiSEEEIIIYQQQuQjknjLS6LvQchCCFkE8U+UNicPqD8Cag8AO1fzxidy1Ibjt5j8678AjGxeluHNZISjEEIIIYQQQgiRkyTxlhc8ugaH5sLJNZAUr7QV9IFGo6D622BtZ9bwRM7bevouH67/G4D+DUvxf63LmzkiIYQQQgghhBAi/5HEW24WdhoOBMK/m8CgU9qK1oDGY6FiB1BrzBqeMI89oRGM+ukkegN0r12MKR0qo5JqtUIIIYQQQgghRI6TxFtuYzDAtQNKhdJLO/9r92kBjcZA6SYgSZZ868iVB7y7+jhanYEO1b0I6FIdtVqeD0IIIYQQQgghhDlI4i230OshdIsywu32MaVNpYbKnaDRaCjqZ8bghCU4dfMxg1YcJSFJz+sV3fmmhx8aSboJIYQQQgghhBBmI4k3S5eUAP/8DAfnwIOLSpvGFmr0hobvQ8Ey5o1PWITzYZH0WxZCTKKOBmUKMb93Taw1anOHJYQQQgghhBBC5GuSeLNUCVFwbDkc+Q6i7ipttq5QZxDUHw5O7uaNT1iMK/ei6bMkhCdxWmqUcGNJv9rYWcv6fkIIIYQQQgghhLlJ4s3SREdA8AI4ugTinyhtTp7Q4D2o1R/sXMwanrAstx7F0mdJMPejE6js5cKK/nVxtJUfayGEEEIIIYQQwhLIK3QL4ZAQgXrrh/DPWkiKVxoLlVXWb6veA6xszRugsDgRkfH0WRLMnSfx+BRxZNWgurg6WJs7LCGEEEIIIYQQQjwliTdzi3+C5rfRtDy7GRUGpc27llKhtGJ7UMuUQZHao5hE+iwN5tqDWIoVsGfN4HoUdpLkrBBCCCGEEEIIYUkk8WZuNs6oIs6iwoC+TAvUr42FUq+BSqpRirRFxWvptzyEC+HReLjY8uPg+ni52ps7LCGEEEIIIYQQQjxHEm/mplaja/sVB0JO0ajbCNTWMlVQpC8uUcegFcf459YTCjra8MPgepQo5GDusIQQQgghhBBCCJEGtbkDEGAo0ZAnDqXMHYawcAlJOoauPkbItYc421mxamBdyro7mzssIYQQQgghhBBCpEMSb0LkAkk6PaPWnmT/xfs42GhYMaAOVb1dzR2WEEIIIYQQQgghXkASb0JYOL3ewIfr/2H7v+HYWKlZ3Lc2tUoWNHdYQgghhBBCCCGEeAmTEm8Gg4GFCxdSt25dChcujEajSfVhZSXLyAnxqgwGA5N/PcOmk7exUqv4rldNGpUtbO6whBBCCCGEEEIIkQEmZcXGjx/P7Nmz8fPzo0+fPhQoUCCr4hIi3zMYDARsPc8PwTdQqWB2Dz9aVvYwd1hCCCGEEEIIIYTIIJMSbytXrqRr1678/PPPWRWPEOKpb3ddYtG+KwD8r0s13vQtauaIhBBCCCGEEEIIkRkmTTWNi4ujZcuWWRWLEOKpJfuv8M3OCwBM6VCZHnVKmDkiIYQQQgghhBBCZJZJibfXX3+do0ePZlUsQghgbcgNPt9yDoD/a1WegY1LmzkiIYQQQgghhBBCvAqTEm/fffcdR44cYcaMGTx48CCrYhIi3/r11G0+3nQagGFNyzCyRVkzRySEEEIIIYQQQohXZVLirUKFCly5coXJkyfj7u6Oo6MjLi4uKT5cXV2zKlYh8rQd/4Yx7ue/MRigT/0STGhTEZVKZe6whBBCCCGEEEII8YpMKq7QtWtXSQwIkQUOXLzPyB9PotMb6FLDm+lvVpWfLSGEEEIIIYQQIpczKfG2YsWKLApDiPzr2LWHDFl1jESdnjZVPPmyW3XUakm6CSGEEJZEp9Oh1WozfZxWq8XKyor4+Hh0Ol02RJa3Sf/9x9raGo1GY+4whBBCZJJJiTchhGnO3H7CgOVHidPqaFq+CHN6+mGlMWkGuBBCCCGykMFgICwsjMePH7/y8Z6enty8eVNGs78C6b+U3Nzc8PT0lL4QQohcxOTEW2RkJN988w1btmzh+vXrAJQsWZIOHTowZswYXFxcTA5SiLzoYngU7ywNJiohibqlC7KgTy1sreRdTCGEEMKSJCfd3N3dcXBwyHTCQ6/XEx0djZOTE2q1vLmWWdJ/CoPBQGxsLBEREQB4eXmZOSIhhBAZZVLi7c6dO7z22mtcvXqVihUr0qhRIwBCQ0OZOnUqq1atYv/+/fKHQYjnXH8QQ+8lwTyK1eJbzJWl/WpjbyNJNyGEEMKS6HQ6Y9KtUKFCr3QOvV5PYmIidnZ2+Tpx9Kqk//5jb28PQEREBO7u7jLtVAghcgmTEm8fffQRYWFh/PHHH7Rr1y7FY1u3buWtt95iwoQJrFy50qQghchL7j6Jo9fiYCKiEqjg4cyKAXVxtrM2d1hCCCHyuRs3brzScSVKlMjiSCxH8ppuDg4OZo5ECEXyc1Gr1UriTQghcgmTEm/btm1jzJgxqZJuAG3btmXUqFEsXrzYlEsIkafcj06g95Jgbj+Oo3RhR1YPrksBRxtzhyWEEEJQqlSpV1o3Kj8seC/raQlLIc9FIYTIfUxKvMXExODh4ZHu456ensTExJhyCSHyjCexWt5ZGsKVezF4u9mzZnA93J3tzB2WEEIIAcCyZcvkRb0QQgghRBYzKfFWuXJl1q5dy7vvvouNTcpRO1qtlrVr11K5cuVMnXP+/Pl89dVXhIWF4evry9y5c6lbt26a+2q1WgICAli5ciW3b9+mQoUKzJw5kzZt2hj30el0TJ06lTVr1hAWFkbRokXp378/kyZNkn8uRY6JTkii3/IQzt2NpLCTLWsG18Pbzd7cYQkhhBBG/fv3N3cIwsKVKlWKMWPGMGbMmAztv3fvXpo3b86jR49wc3PL1tgsQf/+/Xn8+DGbN28GoFmzZvj5+REYGGjWuIQQQpiXSSuUfvTRRwQHB1O3bl0WLVrE3r172bt3LwsXLqRu3bqEhIQwYcKEDJ9v3bp1jBs3jk8//ZQTJ07g6+uLv7+/sXrP8yZNmsTChQuZO3cuZ8+e5d1336Vz586cPHnSuM/MmTP5/vvvmTdvHufOnWPmzJl8+eWXzJ0715RbFyLD4rU6Bq88yqmbj3FzsOaHwfUoXdjR3GEJIYQQIo9SqVQv/Jg6deornffo0aMMHTo0w/s3bNiQu3fv4urq+krXy6i9e/emuL8iRYrQrl07Tp8+na3XFUIIITLCpBFvb731FjExMUyYMIF3333XOILMYDDg7u7OsmXL6NatW4bPN3v2bIYMGcKAAQMAWLBgAVu2bGHZsmVpJvBWr17NJ598Ylxjbvjw4ezcuZOvv/6aNWvWAHDo0CE6duxI+/btAeWdurVr1xISEmLKrQuRIYlJeoavOc6RKw9xsrVi1cC6VPB0NndYQgghRCrTp0/P9DEqlYrJkydnQzTCFHfv3jV+vW7dOqZMmUJoaKixzcnJyfi1wWBAp9NhZfXylwVFihTJVBw2NjZ4enpm6hhThIaG4uLiwp07d/jwww9p3749ly5dSjUzRwghhMhJJiXeQBlS3adPH44dO8b169cBKFmyJLVr187QH/BkiYmJHD9+nIkTJxrb1Go1LVu25PDhw2kek5CQgJ1dyjWy7O3tOXDggHG7YcOGLFq0iAsXLlC+fHn+/vtvDhw4wOzZs9ONJSEhgYSEBON2ZGQkoExtTa5ulZWSz5kd584PLLX/knR6xv1ymj2h97CzVrOoTw0qeThaXJyW2n+5hfSfaaT/TCP9Z7rs7sPc9L15lVFQknizTM8mu1xdXVGpVMa25Omff/75J5MmTeL06dPs2LGD4sWLM27cOI4cOUJMTAyVKlUiICCAli1bGs/1/FRTlUrF4sWL2bJlC9u3b8fb25uvv/6aN998M8W1kqearlixgjFjxrBu3TrGjBnDzZs3ady4McuXL8fLywuApKQkxo0bx6pVq9BoNAwaNIibN28SGxvLr7/++sL7dnd3x83NDU9PT8aMGcObb77J+fPnqV69OgAHDhxg4sSJHDt2jMKFC9O5c2cCAgJwdFRmIiQkJDBlyhR+/PFHIiIiKF68OBMnTmTQoEHodDqGDh3K7t27CQsLo0SJEowYMYLRo0dnzTdNCCFEnmVy4g3AysqK+vXrU79+/Vc+x/3799HpdKmKNXh4eHD+/Pk0j/H392f27Nk0adIEHx8fdu3axcaNG1NU15owYQKRkZFUrFgRjUaDTqfjiy++oHfv3unGEhAQwLRp01K179ixI1vLyQcFBWXbufMDS+o/vQHWXlYTck+NRmWgf1kt984e5s+z5o4sfZbUf7mR9J9ppP9MI/1nuuzqw9jY2Gw5b3bQ6/U5cp2sXs8X4Pbt23z00Uds3bqV2NhYypYty/Lly6ldu3aWx28wGIjTZrySq16vJy5Rh1ViEmq1Sau8YG+tybI1iidMmMCsWbMoU6YMBQoU4ObNm7Rr144vvvgCW1tbVq1axRtvvEFoaCglSpRI9zzTpk3jyy+/5KuvvmLu3Ln07t2b69evU7BgwTT3j42NZdasWaxevRq1Wk2fPn344IMP+OGHHwBlmZgffviB5cuXU6lSJQIDA9myZQvNmzfP8L09efKEn376CcA42u3y5cu0adOGzz//nGXLlnHv3j1GjhzJyJEjWb58OQB9+/bl8OHDfPvtt/j6+nL16lXu378PKN/HYsWK8csvv1CoUCEOHTrE0KFD8fLyonv37hmOTQghRP6TqcTbvn37AGjSpEmK7ZdJ3j+rzZkzhyFDhlCxYkVUKhU+Pj4MGDCAZcuWGff5+eef+eGHH/jxxx+pUqUKp06dYsyYMRQtWpR+/fqled6JEycybtw443ZkZCTFixendevWuLi4ZPl9aLVagoKCaNWqFdbW1ll+/rzO0vrPYDDw2ZbzhNy7iUat4tsevrSunH71X3OztP7LbaT/TCP9ZxrpP9Nldx8mj5oXiuT1fBcsWEC9evUIDAzE39+f0NBQ3N3dU+0/adIk1qxZw+LFi6lYsSLbt2+nc+fOHDp0iBo1agDw6NEjGjVqRPPmzdm6dStFihTh4sWLFChQIFvuIU6ro/KU7dly7pc5O90fB5ssed+c6dOn06pVK+N2wYIF8fX1NW5/9tlnbNq0id9++42RI0eme57+/fvTs2dPAGbMmMG3335LSEhIquRoMq1Wy4IFC/Dx8QFg5MiRKaY5z507l4kTJ9K5c2fj9pYtWzJ0T8WKFQMgJiYGgDfffJOKFSsCyhvrvXv3No7WK1euHN9++y1Nmzbl+++/58aNG/z8888EBQUZR/mVKVPGeG5ra+sUb8yXLl2aw4cP8/PPP0viTQghxAtl6i93s2bNUKlUxMXFYWNjY9xOj8FgQKVSpRiBlp7ChQuj0WgIDw9P0R4eHp7u2hBFihRh8+bNxMfH8+DBA4oWLcqECRNS/JH88MMPmTBhAm+//TYA1apV4/r16wQEBKSbeLO1tcXW1jZVu7W1dba+sMnu8+d1ltJ/X247z+rgmwDMeqs67X2LmTmijLGU/sutpP9MI/1nGuk/02VXH8r3JaXsWM935syZFC9e3DhqCZSkiHix50cDRkdHM3XqVLZs2cLdu3dJSkoiLi6OGzduvPA8ydM4ARwdHXFxcUm3MBqAg4ODMekG4OXlZdz/yZMnhIeHpxgBqdFo8PPzy9A97d+/HwcHB44cOcKMGTNYsGCB8bG///6bf/75xziyDpTXKnq9nqtXr3L69Gk0Gg1NmzZN9/zz589n2bJl3Lhxg7i4OBITEzMcmxBCiPwrU4m3PXv2AP8N2U7ezgo2NjbUqlWLXbt20alTJ0AZ0r1r164XvssGYGdnh7e3N1qtlg0bNqR41yk2NjbVsH6NRpNj0ylE/jJ/zyW+23sZgM86VaVzjdyRdBNCCCHS8s8//zB37lxOnDjBkydPUv3/pFKpuHz5cobOlV3r+f7222/4+/vz1ltv8ddff+Ht7c2IESMYMmRIRm8zU+ytNZyd7p/h/fV6PVGRUTi7OGfJVNOskryuWbIPPviAoKAgZs2aRdmyZbG3t6dbt24kJia+8DzPJ5dVKtUL/89Oa3+DwZDJ6NNWunRp3NzcqFChAhEREfTo0cM4Qyc6Opphw4YxatSoVMeVKFGCS5cuvfDcP/30Ex988AFff/01DRo0wNnZma+++org4OAsiV0IIUTelanE2/PvAL3oHaFXMW7cOPr160ft2rWpW7cugYGBxMTEGN8V7du3L97e3gQEBAAQHBzM7du38fPz4/bt20ydOhW9Xs/48eON53zjjTf44osvKFGiBFWqVOHkyZPMnj2bgQMHZmnsQqw8dI2vtisVwya2rcg79UuaOSIhhBDi1e3du5c2bdpQoEABateuzcmTJ2nRogXx8fEcPnyYKlWqUKtWrQyfL7vW871y5Qrff/8948aN4+OPP+bo0aOMGjUKGxubNGc3ZKaIllarNY6KejaZZGeV8QSawaAiyUaTJeuzGQyGTCepkuNO6/Oz93Tw4EH69etHx44dASVRde3aNeP9PxvDs9vPn+fZtuev9XwMz8fj7OyMh4cHISEhNG7cGFCKLfz999/UqFEj3YReWvc0fPhwAgIC2LBhA507d6ZGjRqcPXs2xcyYZ1WpUgW9Xs+ePXtSFJRIduDAARo2bMi7775rbEtOOidfM/n786L+MpVer8dgMKDVatFoXp6IlSI8ppH+M530oWmk/0xjKUW0smaRiOdcuXKFhIQEKlWqlKnjevTowb1795gyZQphYWH4+fmxbds24z9oN27cSPFOYXx8PJMmTeLKlSs4OTnRrl07Vq9ejZubm3GfuXPnMnnyZEaMGEFERARFixZl2LBhTJkyJUvuVQiAX47d5NPf/gVgVIuyDGvq85IjhBBCCMs2ZcoUypQpw5EjR0hMTMTd3Z2PP/6YFi1aEBwcTNu2bZk5c2a2xpCR9Xz1ej21a9dmxowZANSoUYMzZ86wYMGCNBNvmSmiZWVlhaenJ9HR0S8d+fUyUVFRJh3/quLj4zEYDMYEY3LBj6ioqBT/V5cqVYr169cbixjMmDEDvV5PYmKi8Vi9Xk98fHyKtQvj4uJSbBsMBuM+z1/r+ViSj4f/EqCDBw8mICCAokWLUq5cORYtWsTjx4/R6XTprpmY3j298847TJkyhRYtWjBixAhat27NsGHD6Nu3Lw4ODoSGhrJnzx6++uorChYsSM+ePRk4cCAzZ86katWq3Lx5k3v37tG5c2eKFy/OqlWr2LRpEyVLlmTdunWEhIRQsmTJFMnbpKQk43ZSUlKK/ssKiYmJxMXFsW/fPpKSkjJ8nBThMY30n+mkD00j/WcacxfRMinx9u2333Lo0CFj1SCAAQMGsGrVKkD5x+fPP/9Mc7Hc9CRXF0rL3r17U2w3bdqUs2dfXCbS2dmZwMBAAgMDMxyDEJmx5Z+7fLThHwAGNirN2FblzRyREEIIYboTJ04wbdo0XFxcePToEYBxpFm9evUYNmwYkydPpm3bthk6X3at5+vl5UXlypVTHFepUiU2bNiQ5jkzU0QrPj6emzdv4uTklGrKa0YZDAaioqJwdnbOsoqkmWFnZ4dKpTLeW3Jy0dnZOcX9zpkzh8GDB+Pv70/hwoUZP368cV3n5P3UajV2dnYpjrO3t0+xrVKpjPs8f63nY0k+HjC2TZkyhcePHzN8+HA0Gg2DBw/m9ddfx9bWNt0iZ+nd07hx4/juu+/Yvn073bt3Z8+ePUyaNIl27dphMBjw8fGhe/fuxmMWL17MJ598wocffsiDBw8oUaIEEyZMwMXFhVGjRnHu3DkGDRqESqXi7bffZsSIEWzbts14vLW1NVZWVsZtKyurFP2XFeLj47G3t6dJkyYZek5KER7TSP+ZTvrQNNJ/prGUIlomJd6WLFmSorT39u3bWblyJcOGDaNatWpMmjSJadOmMX/+fFMuI4TF2nM+gtE/nURvgLfrFGdyh0pm+adaCCGEyGpWVlY4OzsD4ObmhrW1dYpF88uUKfPSN0CflV3r+TZq1IjQ0NAU+1+4cIGSJdNe8iEzRbR0Oh0qlQq1Wv3K67MlTzNMPk9OGzhwYIolVlq0aJHmdNUyZcqwe/fuFG3Pf1+uXbuWYjut8zx+/Djdaz0fC0CXLl1S7GNjY8O8efOYN28eoIwaq1SpEj169Ei3/9K7p5IlS6aYBlSvXr0XjnpwcHDgm2++4Ztvvkn1mL29PStWrEjV/r///c/49cqVK1M89vyggaygVqtRqVSZLggjRXhMI/1nOulD00j/mcbcRbRMSrxdv349xXTSn3/+mdKlS/P9998DEBYWxurVq025hBAW6/DlB7y75jhJegNv+hbli87VJOkmhBAizyhbtiwXL14ElKRRxYoV2bRpE7179wZgy5Yt6Y5US092rOc7duxYGjZsyIwZM+jevTshISEsWrSIRYsWZUU3iBx2/fp1duzYQdOmTUlISGDu3Llcv36dnj17mjs0IYQQ4pWYlHh7/p2lHTt2GBdkBWWtiLCwMFMuIYRFOnnjEYNXHiUhSU/LSh583d0XjVqSbkIIIfKOdu3asWzZMgICArCysmLcuHEMGDCAcuXKAcrC8skJsozKjvV869Spw6ZNm5g4cSLTp0+ndOnSBAYGGhOEIndRq9WsWLGCDz74AIPBQNWqVdm0aVOm144WQgghLIVJibfy5cuzadMm3n33XbZv386dO3dSrPNx69atFP8YCZEXnL0TSb9lIcQk6mhUthDzetXAWpPzU0eEEEKI7DR58mRGjx5trJzYr18/NBoNGzZsQKPR8Mknn9C/f/9Mnzer1/MF6NChAx06dMh0LMLyFC9enIMHDxq39Xp9lhYnEEIIIXKaSYm3Dz74gF69elGgQAFiYmKoVKkS/v7+xsd3796Nn5+fqTEKYTEu34vmnaXBRMYnUatkARb3rY2d9ctLuQshhBC5jbW1NYUKFUrR1qdPH/r06WOmiIQQQgghch+TEm9vv/02hQoV4s8//8TNzY0RI0ZgZaWc8uHDhxQsWJB33nknSwIVwtxuPoylz5JgHsQkUqWoC8v618HBxqQfISGEEMJiPXz4kFu3blG9evU0Hz99+jTFihWjQIECORyZEEKIXOHJbdSnN2Cf6GjuSIQwK5OzBq1ataJVq1ap2gsWLMjGjRtNPb0QFiE8Mp7eS4K5+ySesu5OrBpYF1d7qSojhBAi7xo7diyhoaEcOXIkzceHDRtGpUqVWLp0aQ5HJoQQwuKdXg9bxqGJf0JztT0qHzuo0QukGJ3Ih2RhKiFe4mFMIn2WBHPjYSwlCjrww+B6FHKyNXdYQgghRLbavXs3b775ZrqPv/HGG+zcuTMHIxJCCGHx4h7B+kGwYRDEP8Fg64y1Pg6r30bA+gEQ+9DcEQqR4zI14q106dKo1WrOnz+PtbU1pUuXRvWSjLVKpeLy5csmBSmEuUTGa+m7LJiLEdF4utjxw+B6eLjYmTssIYQQItvdu3ePwoULp/t4oUKFiIiIyMGIhBBCWLQrf8Hm4RB5G1QaaPIhSfVHcmnVaCqGbUb17ya4EQydvgOf5uaOVogck6nEW9OmTVGpVMYy78nbQuRFsYlJDFx+lDO3IynkaMOawfUoXtDB3GEJIYQQOcLLy4uTJ0+m+/jx48cpUqRIDkYkhBDCImnjYfdncHiesl2wDHRZDMVqg1bLBc+OlGszTBn19uASrO4E9YZDy0/B2t6soQuREzKVeFuxYsULt4XIK+K1OoauOs6x649wsbNi9aB6lHV3MndYQgghRI7p1KkT8+fPp23btqmmnP76668sX76c4cOHmyk6kROaNWuGn58fgYGBAJQqVYoxY8YwZsyYdI9RqVRs2rSJTp06mXTt5PO8aLpzXvEq/SyExQg7AxuHQsS/ynat/tD6C7BN+drJULQmDNsHOybDsaUQ/D1c2aMk6LzSLuIjRF4ha7wJ8RytTs/IH09y4NJ9HGw0rBhYl8pFXcwdlhBCCJGjpk6dSoUKFejcuTM1a9akb9++9O3bl5o1a9KlSxfKly/PtGnTzB2mSMMbb7xBmzZt0nxs//79qFQq/vnnn0yf9+jRowwdOtTU8FKYOnUqfn5+qdrv3r1L27Zts/Raz1uxYgUqlco4o8fLy4sePXpw48aNbL2uEHmCXg8Hv4XFzZWkm0Nh6PkTvDEnVdLNyMYROsyGXr+AozvcOw+LW8CBQNDrcjR8IXKSSYm3tWvX0r9//3QfHzBgAD///LMplxAiR+n0Bj745W92ngvHxkrNkr61qVmigLnDEkIIIXKcq6srR44cYdKkSWi1WtavX8/69evRarVMnjyZ4OBg3NzczB2mSMOgQYMICgri1q1bqR5bvnw5tWvXpnr1zI8wKVKkCA4OObPshqenJ7a22V/MysXFhbt373L79m02bNhAaGgob731VrZfV4hc7fFNWPUmBE0GXSKUbwsjjkCFDCbLy7eGEYehYgfQa2Hnp7DyDXgsSW+RN5mUePvmm29e+AfR3t6eb775xpRLCJFjDAYDkzaf5tdTd7BSq1jQpyYNy6a/qLQQQgiR1zk6OjJt2jROnz5NbGwssbGxnD59mqlTp+Lo6Gju8EQ6OnToQJEiRVItCxMdHc0vv/zCoEGDePDgAT179sTb2xsHBweqVavG2rVrX3jeUqVKGadDAly8eJEmTZpgZ2dH5cqVCQoKSnXMRx99RPny5XFwcKBMmTJMnjwZrVYLKCPOpk2bxt9//20ceZYcs0qlYvPmzcbznD59mhYtWmBvb0+hQoUYOnQo0dHRxsf79+9Pp06dmDVrFl5eXhQqVIj33nvPeK30qFQqPD098fLyomHDhgwaNIiQkBAiIyON+/z666/UrFkTOzs7ypQpw7Rp00hKSjI+/vjxY4YNG4aHhwd2dnZUrVqVP/74A+CV+lkIi/bPL/B9I7i2H6wdlBFuPdeCUybX/HQsDD3WwJvzwMYJrh9Uzvv3T2AwZE/sQphJptZ4e15oaCgDBw5M93FfX1/5wyJyBYPBwBdbzrE25CZqFQS+7UeLih7mDksIIYSwCHfv3iUiIoKyZctKws1gAG1sxvfX65X9EzWgNnGVF2sHyEBhMysrK/r27cuKFSv45JNPjMXQfvnlF3Q6HT179iQ6OppatWrx0Ucf4eLiwpYtW3jnnXfw8fGhbt26GbgtPV26dMHDw4Pg4GCePHmS5ppkzs7OrFixgqJFi3L69GmGDBmCs7Mz48ePp0ePHpw5c4Zt27axc+dOQBlp+byYmBjatm1LgwYNOHr0KBEREQwePJiRI0emSC7u2bMHLy8v9uzZw6VLl+jRowd+fn4MGTLkpfcDEBERwaZNm9BoNGg0GkCZmtu3b1++/fZbXnvtNS5fvmycbvvpp5+i1+tp27YtUVFRrFmzBh8fH86ePWs8Pj4+3qR+FsJixD2CLf8HZzYo2961ocsiKOTz6udUqaDmO1CqMWwaBjeDlc+hW6HDN+BQMGtiF8LMTEq8GQwGHj9+nO7jjx49eum7TEJYgsCdF1ly4CoA/+tanQ7Vi5o5IiGEEML8fv31Vz766CMuXrwIQFBQEC1atOD+/fu0atWKTz/91ORF9HMdbSzMyPj/CWrALauu/fEdZY2kDBg4cCBfffUVf/31F82aNQOUaaZdu3bF1dUVV1dXPvjgA+P+77//Ptu3b+fnn3/OUEJo586dnD9/nu3bt1O0qNIfM2bMSLUu26RJk4xflypVig8++ICffvqJ8ePHY29vj5OTE1ZWVnh6eqZ7rfXr1xMfH8+qVauMid958+bxxhtvMHPmTDw8lDdLCxQowLx589BoNFSsWJH27duza9euFybenjx5gpOTEwaDgdhYJaE6atQo43WmTZvGhAkT6NevHwBlypThs88+Y/z48Xz66afs3LmTkJAQzp07R/ny5Y37JPP29japn4WwCFf2wuYREHkbVBpoOh5e+wA0JqUT/lOwNPT/Ew5+A3v/B2c3K0m4Tt+BT4usuYYQZmTS2241atRg7dq1JCYmpnosISGBH3/8kRo1aphyCSGy3eJ9V5izS3lBMfWNynSvXdzMEQkhhBDm9/vvv9OlSxcKFy7Mp59+iuGZqT+FCxfG29ub5cuXmzFC8SIVK1akYcOGLFu2DIBLly6xf/9+Bg0aBIBOp+Ozzz6jWrVqFCxYECcnJ7Zv357hwgLnzp2jePHixqQbQIMGDVLtt27dOho1aoSnpydOTk5MmjQp08ULLly4gK+vb4rRlo0aNUKv1xMaGmpsq1KlinGkGYCXlxcREREvPLezszOnTp3i2LFjfP3119SsWZMvvvjC+Pjff//N9OnTcXJyMn4MGTKEu3fvEhsby6lTpyhWrJgx6fY8U/tZCLPSxsO2j2FVRyXpVtAHBu2AZhOyLumWTGMFTT6EQUFQqBxE3YXVnWHrR6CNy9prCZHDTPppmTBhAh06dKB58+ZMmDCBKlWqAHDmzBkCAgL4999/+e2337IkUCGyww/B1/niz3MAfOhfgf6NSps5IiGEEMIyTJ8+nSZNmrBnzx4ePHjA1KlTUzzeoEEDFi5caJ7gzMnaQRl5lkF6vZ7IqChcnJ1RZ8VU00wYNGgQ77//PvPnz2f58uX4+PjQtGlTAL766ivmzJlDYGAg1apVw9HRkTFjxqT5hvqrOnz4ML1792batGn4+/vj6urKTz/9xNdff51l13iWtbV1im2VSoVer3/hMWq1mrJlywJQqVIlLl++zPDhw1m9ejWgrIs3bdo0unTpkupYOzs77O3tX3j+nOhnIbJF2GnYOBQizirbtQaA/xcZHnX7yrxrwrB9EDQFji6G4AXKiLsui8DLN3uvLUQ2MSnx1rZtW5YuXcro0aNTTDMwGAw4OzuzePFi2rdvb2qMQmSLTSdvMWnzGQCGN/PhveZlzRyREEIIYTnOnDnD7Nmz033cw8PjpaOJ8iSVKnMvPPV6sNYpx5iaeMuk7t27M3r0aH788UdWrVrF8OHDjeu9HTx4kI4dO9KnT5+nYeq5cOEClStXztC5K1WqxM2bN7l79y5eXl4AHDlyJMU+hw4domTJknzyySfGtuvXr6fYx8bGBp1O98JrlS9fnrVr1xITE2Mc9Xbw4EHUajUVKlTIULwZNWHCBHx8fBg7diw1a9akZs2ahIaGGpNzz6tevTq3bt3iwoULaY56M7Wfhchxeh0cnge7P1cqljoWUQogVGiTczHYOED7WVC+Dfw6Au6dh8WvQ/OPodFoUGtefg4hLIjJf/379+/PzZs3WbduHQEBAQQEBPDLL79w69atFxZeEMKctp0J44Nf/sFggH4NSjLeP2v/aRNCCCFyOwcHB2JiYtJ9/MqVKxQqVCgHIxKZ5eTkRI8ePZg4cSJ3796lf//+xsfKlStHUFAQhw4d4ty5cwwbNozw8PAMn7tly5aUL1+efv368ffff7N///4UCbbka9y4cYOffvqJy5cv8+2337Jp06YU+5QqVYqrV69y6tQp7t+/T0JCQqprvfXWW9jZ2dGvXz/OnDnDnj17eP/993nnnXeM67tlleLFi9O5c2emTJkCwJQpU1i1ahXTpk3j33//5dy5c/z000/GteuaNm1KkyZN6Nq1K0FBQVy9epWtW7eybds2Yx+Y0s9C5KjHN2Dlm8poM10iVGgHww/nbNLtWeVaKtev9AbotbBrGqzoAI+uv/xYISxIlrzt5uLiQrdu3Rg/fjzjx4+na9euODs7Z8Wphchy+y7cY9Tak+j0BrrVKsanb1QxvvsrhBBCCEXz5s1ZuXIlSUlJqR4LCwtj8eLFtG7d2gyRicwYNGgQjx49wt/fP8V6bJMmTaJmzZr4+/vTrFkzPD09M1UoQ61Ws2nTJuLi4qhbty6DBw9OsTYawJtvvsnYsWMZOXIkfn5+HDp0iMmTJ6fYp2vXrrRp04bmzZtTpEgR1q5dm+paDg4ObN26lYcPH1KnTh26devG66+/zrx58zLXGRk0duxYtmzZQkhICP7+/vzxxx/s2LGDOnXqUL9+fb755htKlixp3H/Dhg3UqVOHnj17UrlyZcaPH28cxWdqPwuRIwwG+HsdfN8Irh8Aa0d441t4+0dwKmLe2BwLQffV0PE7sHGCG4eUOE/9qMQtRC5g8oqIOp2OX375hT179hAREcH06dOpVq0aT548YdeuXTRq1CjL34kS4lWFXH3I0NXHSNTpaVfNk/91qYZaLUk3IYQQ4nlffPEF9evXp06dOrz11luoVCq2b9/O7t27WbhwIXq9nk8//dTcYYqXaNCgQYrCGMkKFizI5s2bX3js3r17U2xfu3YtxXb58uXZv39/irbnr/Xll1/y5ZdfpmgbM2aM8WtbW1vWr1+f6trJ50leo61atWrs3r073VhXrFiRqi0wMDDd/UGZufPsKMBk9evXT3Ef/v7++Pv7p3ueggULGotYpPWYqf0sRLaKfQhbxsG/T0ejFqsDnRdCIR/zxvUslQpq9IaSDWHTu3DzCGweDqFb4Y054FDQ3BEK8UImjXh7/PgxjRo1olevXqxdu5bffvuNe/fuAcrQ9lGjRjFnzpwsCVQIU/1z6zEDVxwlXquneYUiBPaogZUmZ9daEUIIIXKLChUqcODAAQoVKsTkyZMxGAx89dVXzJgxg2rVqnHw4MEUo36EEELkMpf3KKPH/t0EKg00/wQGbLOspNuzCpaGAX9Ci8mgtoJzv8F3DeDSTnNHJsQLmZR1mDBhAv/++y/bt2/nypUrKd4Z0mg0dOvWjT///NPkIIUwVWhYFH2XhRCdkET9MgX5vk8tbKwk6SaEEEK8SJUqVdi5cyf3798nODiYw4cPEx4ezrZt29i3b1+WL2wvhBAiB2jjYOsEWN0Jou5AobIwOAiajgeNyZPispdaA00+gME7oXB5iA6DNV3hz/HKfQlhgUzKPGzevJn333+fVq1apblGVvny5WWotDC7q/dj6LM0mMexWvyKu7GkXx3srKUSjhBCCJGWxMRE1q9fz8yZM1m0aBF37tyhQIEC1KlTh2rVqrF8+XJKlSrFu+++m+YURiGEEBbs7j+wqBkEf69s1x4Ew/aBdy2zhpVpRWvA0L+g7lBlO2QhLGwKd06ZNSwh0mJSOvvJkyeULl063ce1Wm2aC/IKkVNuP46jz5Jg7kUlUNHTmZUD6uJka+Hv4gghhBBmcufOHZo1a8bly5eNSTU7Ozt+//13bGxs6NWrF7dv36Zu3brMnTuXLl26mDliIYQQGaLXwaG5sPtzpUKoozt0nA/lc3GRHBsHaPcVlPeHze/B/VBY8jo0/xgajVFGxwlhAUzKQPj4+HDixIl0H9+xYweVK1c25RJCvLKIqHj6LAnm9uM4yhR2ZPWgerg6WJs7LCGEEMJiffLJJ1y9epXx48fz2muvcfXqVaZPn87QoUO5f/8+VapUYc2aNTRt2tTcoQohhMioxzeUogTXDyrbFdrDm9+CY2HzxpVVyraEEYfh99HKum+7psPFIOi8AAqUMnd0QpiWeBs8eDAfffQRzZo14/XXXwdApVKRkJDA9OnT2bZtG4sWLcqSQIXIjMexifRdGsLV+zF4u9mzZnA9ijjbmjssIYQQwqIFBQUxYMAAAgICjG2enp689dZbtG/fnl9//RW1Ov+tkSpTaoWlkOeiyBSDAf5ZB39+CAmRYO0Ibf8HNd5RKoXmJQ4Fofsq+Hutst7bjcPwfWNoOxP8euW9+xW5ikmJt9GjR/Pvv//Ss2dP3NzcAOjVqxcPHjwgKSmJYcOGMWjQoKyIU4gMi05Iot+yEM6HRVHE2ZYfBtejqJu9ucMSQgghLF54eDj169dP0Za8PXDgwHyXdLO2VkbKx8bGYm8v/0sI84uNjQX+e24Kka7Yh/DHWDi7WdkuVhe6LISCZcwaVrZSqZQkW8mGygi/G4fh1xFwYSt0mAOOhcwdocinTEq8qVQqFi9eTL9+/Vi/fj0XL15Er9fj4+ND9+7dadKkSVbFKUSGxCXqGLTiKH/fekIBB2t+GFyPUoUdzR2WEEIIkSvodDrs7OxStCVvu7q6miMks9JoNLi5uREREQGAg4NDmgXFXkSv15OYmEh8fHy+S1xmBek/hcFgIDY2loiICNzc3NBoZO0q8QKXd8PmERB1F9RW0HQCNB5r+RVLs0qBUtB/CxycA3tmwLnf4WYIdPwOyrU0d3QiH3rln7zY2Fj69OlD165d6d27N40bN87KuITItMQkPe/9dJLgqw9xtrVi1cB6lPdwNndYQgghRK5y7dq1FGv4PnnyBICLFy8aZzg8q2bNmjkVmll4enoCGJNvmWUwGIiLi8Pe3j7TSTsh/fc8Nzc343NSiFS0cbBzKgQvULYLlYMui8A7b/+eTpNaA6+Ng7Kvw4YhSuGFH7pCnSHQarpSmEGIHPLKiTcHBwd27txJ27ZtszIeIV6JzgDjfvmHvaH3sLNWs2xAHaoVy3/vzAshhBCmmjx5MpMnT07VPmLEiBTbBoMBlUqFTqfLqdDMQqVS4eXlhbu7O1qtNtPHa7Va9u3bR5MmTWR64CuQ/vuPtbW1jHQT6bv7N2wcCvfOK9t1BkOrzyTB5OULw/76LyF5dDFc/UtJSBatYe7oRD5h0ljTxo0bc/jwYYYMGZJV8QiRaXq9gbWX1Ry9F4GNRs3ivrWpU6qgucMSQgghcp3ly5ebOwSLpdFoXinpodFoSEpKws7OLt8njl6F9J8QL6HX/TelUq8FJw/oOB/KtTJ3ZJbD2l4pslCutTIF9/4FWNISmk2AxuOU0XFCZCOTEm/z5s3D39+fSZMm8e6771KsWLGsikuIDDEYDEzfcp6j99Ro1Crm9arBa+WKmDssIYQQIlfq16+fuUMQQgiRUY+uPy0icEjZrtgB3vhWigikp+zrMOIw/DEGzv4Kuz+Hi0HQeSEULG3u6EQeZtIKpb6+vty6dYuAgABKliyJra0tLi4uKT7y40K8ImcYDAZmbgvlh5CbqDDwZZeqtK4ia14IIYQQQggh8jCDAU79CN83UpJuNk7KKLceayTp9jIOBeGtldBpAdg4w81gWNAYTq5R+lWIbGDSiLdu3bplVRxCZNr8PZdY8NdlALqX0fOmr5eZIxJCCCGEEEKIbBT7EH4fDed+U7aL14fOC2TEVmaoVODXE0o2/G/E4K/vQehWGTEossUrJd7i4+P59ddfqVChAoUKFaJDhw54eUnSQ+ScZQeuMmvHBQAmtimP55OzZo5ICCGEEEIIIbLRpZ2w+T2IDgO1FTSbCI3Hyhplr6pASej/Bxz6FnZ/Aef/gFtHZY08keUynXiLiIigYcOGXL161VjNysHBgU2bNtGyZcvsiFGIFH4+epPpfyiJtjEtyzGwUSn+/FMSb0IIIYQQQog8SBsHQZ9CyEJlu3B5qcqZVdQaJXnp0+K/qrA/dJOqsCJLZXqNt88++4xr164xduxY/vjjD7755hvs7OwYNmxYlgU1f/58SpUqhZ2dHfXq1SMkJCTdfbVaLdOnT8fHxwc7Ozt8fX3Ztm1bin1KlSqFSqVK9fHee+9lWcwiZ/z+9x0+2vgPAENeK83o18uZOSIhhBBCCCGEyCZ3TsHCpv8l3eoMgaF/SdItq3n5wtC9UG+4sn10CSxsArdPmDUskTdkesTbjh076Nu3L7NmzTK2eXh40KtXL0JDQ6lQoYJJAa1bt45x48axYMEC6tWrR2BgIP7+/oSGhuLu7p5q/0mTJrFmzRoWL15MxYoV2b59O507d+bQoUPUqKH8Mjp69Cg6nc54zJkzZ2jVqhVvvfWWSbGKnLXzbDhj153CYIBe9UrwcbtKqFQqc4clhBBCCCGEEFlLr4ODgbBnBuiTwMkDOn4H5WSWWbaxtoe2/4PyrWHzCHhwEZa2gqYTlFFxGpOWyBf5WKZHvN24cYPGjRunaGvcuDEGg4Hw8HCTA5o9ezZDhgxhwIABVK5cmQULFuDg4MCyZcvS3H/16tV8/PHHtGvXjjJlyjB8+HDatWvH119/bdynSJEieHp6Gj/++OMPfHx8aNq0qcnxipxx8NJ9Rvx4giS9gU5+Rfm8Y1VJugkhhBBCCCHynkfXYEV72DVdSbpVegOGH5akW07xaQHDD0GVzkr/7/kclreFh1fMHZnIpTKdsk1ISMDOzi5FW/J2UlKSScEkJiZy/PhxJk6caGxTq9W0bNmSw4cPZzgee3t7Dhw4kO411qxZw7hx49JN3CQkJJCQkGDcjoyMBJRprVqtNlP3lBHJ58yOc+cFJ288Zsiq4yQm6WlVyZ2ATpXR6ZJIHsQo/Wca6T/TSP+ZRvrPNNJ/psvuPpTvjRBCiAwzGODUj7D1I0iMAhtnaDsT/HoplThFznEoCN2WQ/m28OcHcCsEFrwGbQKgxjvy/RCZ8kpjJa9du8aJE//NdX7y5AkAFy9exM3NLdX+NWvWzNB579+/j06nw8PDI0W7h4cH58+fT/MYf39/Zs+eTZMmTfDx8WHXrl1s3LgxxdTSZ23evJnHjx/Tv3//dOMICAhg2rRpqdp37NiBg0P2La4YFBSUbefOrW7FwLx/NcTpVFRw1dPG5Q47tt9Jc1/pP9NI/5lG+s800n+mkf4zXXb1YWxsbLacV+Qi4f/iEnvd3FEIISxdzAP4YzSc+13ZLl4fuiyEAqXMGla+plKBbw8o2QA2DYfrB+C39+HCdnhjDjgWNneEIpd4pcTb5MmTmTx5cqr2ESNGpNhOrnqaXhIsK8yZM4chQ4ZQsWJFVCoVPj4+DBgwIN2pqUuXLqVt27YULVo03XNOnDiRcePGGbcjIyMpXrw4rVu3xsXFJcvvQavVEhQURKtWrbC2ts7y8+dWlyKimbr0KHE6LbVLurG0b00cbFI/ZaX/TCP9ZxrpP9NI/5lG+s902d2HyaPmRf6l2T2V5lf2oF+7B14bB6Uay0gJIURKF3fCryMgOhzUVtD8Y2g0Rqm4KczPrQT0+w0Oz4Ndn8H5P+BmCHScr6wHJ8RLZDrxtnz58uyIA4DChQuj0WhSrRUXHh6Op6dnmscUKVKEzZs3Ex8fz4MHDyhatCgTJkygTJkyqfa9fv06O3fuZOPGjS+Mw9bWFltb21Tt1tbW2frCJrvPn5vcfBjLgJUneBSrpZq3K8sG1MXF7sV9I/1nGuk/00j/mUb6zzTSf6bLrj6U70s+p9OCfQEMqFBf2Q1XdoN3LWWR7grtQZ3p5ZaFEHlJYiwETYGji5XtwhWgyyIo6mfWsEQa1BpoNBrKNIeNQ+HeOfjxLag9EFp/DjaO5o5QWLBMJ9769euXHXEAYGNjQ61atdi1axedOnUCQK/Xs2vXLkaOHPnCY+3s7PD29kar1bJhwwa6d++eap/ly5fj7u5O+/btsyN8kUXCnsTTa8kRwiLjKefuxMqBL0+6CSGEECJ3mD9/Pl999RVhYWH4+voyd+5c6tatm+a+Wq2WgIAAVq5cye3bt6lQoQIzZ86kTZs2ae7/v//9j4kTJzJ69GgCAwOz8S4ySGONrtMi9hoa0sL+LJq/f4Tbx2FdHyhUDhqNguo9wCr1G75CiDzuzkklgXP/grJddxi0mqZU1hSWy6s6DN0Lu6bBke/g2DK4uk9JmHrXMnd0wkJZ3Nts48aNY/HixaxcuZJz584xfPhwYmJiGDBgAAB9+/ZNUXwhODiYjRs3cuXKFfbv30+bNm3Q6/WMHz8+xXn1ej3Lly+nX79+WFlJGWBL9SA6gd5LjnDzYRwlCznww+B6FHS0MXdYQgghhMgC69atY9y4cXz66aecOHECX19f/P39iYiISHP/SZMmsXDhQubOncvZs2d599136dy5MydPnky179GjR1m4cCHVq1fP7tvItFhbd/RtvoQxZ+C1D8DOFR5cVNYKmuMLB7+FeJmWLES+oNfBvq9gSUsl6ebkCX02QLsvJemWW1jbKUUW3tkMzkXhwSVY0gr++hJ0phWcFHmTxSXeevTowaxZs5gyZQp+fn6cOnWKbdu2GQsu3Lhxg7t37xr3j4+PZ9KkSVSuXJnOnTvj7e3NgQMHUhV52LlzJzdu3GDgwIE5eTsiE57EaXlnaQiX78Xg5WrHD4Pr4e5i9/IDhRBCCJErzJ49myFDhjBgwAAqV67MggULcHBwSHdt3tWrV/Pxxx/Trl07ypQpw/Dhw2nXrh1ff/11iv2io6Pp3bs3ixcvpkCBAjlxK6/GqQi8PhnG/qtMTXIuClF3IWgyfFMVdk2H6LSTkEKIPODhVVjeFnZ/DvokqNwRRhyGsi3NHZl4FT7NYfhBqNIFDDrY8wUsbwMPr5g7MmFhLHLo18iRI9OdWrp3794U202bNuXs2bMvPWfr1q0xGAxZEZ7IBjEJSQxYHsLZu5EUdrLhh8H1KFYg+yrICiGEECJnJSYmcvz48RQzF9RqNS1btuTw4cNpHpOQkICdXco34ezt7Tlw4ECKtvfee4/27dvTsmVLPv/88xfGkZCQQEJCgnE7uQCGVqtFq9Vm6p4yIvmcKc6ttoM670LNgajOrEdz+FtUDy7B/q8xHJqH3rcX+vrvSTVD0uk/kWHSf6bJsv4zGFD9sxbNjomoEmMw2Dih85+JoVp3pdhKHv7+5PnnoLUzdFyIqmwrNNs+QnXrKIbvG6Nr9TkGvz4mF9PJ8/2XzbK7/zJ6XotMvIn8JV6rY8iqY5y48RhXe2tWD6pHmSJO5g5LCCGEEFno/v376HQ64yyGZB4eHpw/fz7NY/z9/Zk9ezZNmjTBx8eHXbt2sXHjRnQ6nXGfn376iRMnTnD06NEMxREQEMC0adNSte/YsQMHh+x70y8oKCidR9yg+CQ8XU5SLvwPCsZeRnNiOeoTK7jtVpdLHu154lAq2+LKLdLvP5ER0n+mMaX/bJKi8L2xjKJPjgPwwLE8x0sOI+6WM9zamlUhWry8/xx0xL7sVGpcX0yR6HNY/TmWuwdXcar4IBKtXUw+e97vv+yVXf0XGxubof0k8SbMSqvTM/LHExy6/ABHGw0rB9alkpfpv5iEEEIIkfvNmTOHIUOGULFiRVQqFT4+PgwYMMA4NfXmzZuMHj2aoKCgVCPj0jNx4kTGjRtn3I6MjKR48eK0bt0aF5es/x9Eq9USFBREq1atXlLltgMYJpF04xDqw3NRX95JscfBFHscjL5Mc/QN3sdQ8jWTR0/kNhnvP5EW6T/TmNp/qks70fwxDVVMBAa1NfqmE3CpP5Lmak02RGuZ8t1z0NAHXfB3qPfOwOvJSTyTpqFrPwdDudavdLp8139ZLLv7L3nU/MtI4k2YjU5vYOy6U+w8F4GtlZql/evgV9zN3GEJIYQQIhsULlwYjUZDeHh4ivbw8HA8PT3TPKZIkSJs3ryZ+Ph4Hjx4QNGiRZkwYQJlypQB4Pjx40RERFCzZk3jMTqdjn379jFv3jwSEhLQaFK+wLW1tcXWNnUVUWtr62x9UZPh85dtpnyEnYaDc+DMRtRX9qC+sgeK1oTGY6BiB8hHL9wh+78/eZ30n2ky3X+JscrajUeXKNuFK6DquhiNly/56yf3P/nqOfjaWCjXCjYOQRVxFqufe0GtAeD/Bdg4vtIp81X/ZYPs6r+MntPiiiuI/EGvN/DxxtP88c9drDUqFrxTi/plCpk7LCGEEEJkExsbG2rVqsWuXbuMbXq9nl27dtGgQYMXHmtnZ4e3tzdJSUls2LCBjh07AvD6669z+vRpTp06ZfyoXbs2vXv35tSpU6mSbrmKZzXougRGnYA6Q8DKDu6cgJ/7wvy6cHwlJCW8/DxCiJx1+wQsbPJf0q3euzDsL/DyNW9cImd5VoUhe6DB07Xrjy+HBa/BrePmjUuYhYx4EznOYDDw2ZazrDt2E7UKvn27Bs0ruJs7LCGEEEJks3HjxtGvXz9q165N3bp1CQwMJCYmhgEDBgDQt29fvL29CQgIACA4OJjbt2/j5+fH7du3mTp1Knq9nvHjxwPg7OxM1apVU1zD0dGRQoUKpWrPtQqUgvazoNkECF4IIYvgwSX4fRTsmQENRigjKexkqQ4hzEqXBAe+gb/+p1QsdfaCTt+BTwtzRybMxdpOGeVWrjVsHg4PL8PSVtB0PLz2AWgkHZNfyHda5LjZQRdYfvAaAF9286VtNS/zBiSEEEKIHNGjRw/u3bvHlClTCAsLw8/Pj23bthkLLty4cQO1+r8JGfHx8UyaNIkrV67g5OREu3btWL16NW5ubma6AzNyLAwtPoFGo+HESjg8HyJvQ9AU2Pc11BkI9YaDs8fLzyWEyFoPr8DGYXArRNmu3Ak6fAMOBc0alrAQZZrC8IOw5QM4sx72BsDFIOiyCAr5mDs6kQMk8SZy1IK/LjN39yUAPutYhW61ipk5IiGEEELkpJEjRzJy5Mg0H9u7d2+K7aZNm3L27NlMnf/5c+Q5tk7Q4D1l+unpX5R14O6HKiNtDn8Hfr2g4fvyYk6InGAwwMnVsG0iJEaDrQu0+wqq98h3hVDES9gXgG5LoXwb2PJ/cPsYLGgM/jOgVn95vuRxssabyDGrD1/jf1vPA/BRm4q806CUeQMSQgghhMitrGygRm8YcQTe/hGK1QVdgrKO0Lza8Et/uHPK3FEKkXfF3Id1feC395WkW8lGyqgm37cliSLSV/0t5XlS6jXQxsIfY2BtT4i+Z+7IRDaSxJvIERuO32Lyr/8CMLJ5WYY3k3dhhRBCCCFMplZDxfYwaAcM2KqsJWTQw7+bYFFTWNUJruxVRuYIIbLGhR3wXQM4/weoraHlNOj3O7iVMHdkIjdwKw59f4PWn4PGBi5she/qQ+hWc0cmsokk3kS223r6Lh+u/xuA/g1L8X+ty5s5IiGEEEKIPEalgpINofcvMPzQ06luGriyB1Z1hEXN4N/NoNeZO1Ihcq/EGPhjLPz4FsREQJFKMGQ3NB4D6lxcRVnkPLVaWRZgyB5wrwKx92Ht2/D7aEiINnd0IotJ4k1kq72hEYz66SR6A7xVqxhTOlRGJUOvhRBCCCGyj0cVZdHuUSeh7jCwsoe7p+CXfjCvDhxbDtp4c0cpRO5y+zgsbALHlinb9UfA0L3gVd2sYYlczrOqkrxtMBJQwfEVsPA1uHXM3JGJLCSJN5Ftgq88YNjq42h1BtpX9+J/XaujVkvSTQghhBAiRxQoCe2+hLFnoOlHyuLeDy8rawrNqa4UZIh/Yu4ohbBoKoMO9f5ZsKQVPLgEzkXhnc3QJgCs7cwdnsgLrO3A/wvo9xu4FFOq5C5tDXsCQKc1d3QiC0jiTWSLv28+ZtDKYyQk6WlR0Z1vuvuhkaSbEEIIIUTOcywMzT+GMWfAP0B5YRcdDjunwjdVIehTiAozd5RCWJ5HV2l84XM0+/4HBh1U6awsjO/T3NyRibyodBPl+VXtLeX59tf/0Kxqj2O8/H7O7STxJrLc+bBI+i4LITohiQZlCvFd75rYWMlTTQghhBDCrGydoMEIGH0KOi2AIhUhIRIOBkJgNWVtoQeXzR2lEOZnMMDxlVgtbkbB2MsYbJ2h8yLothwcCpo7OpGX2btB1yXQdSnYuaK+c4JmoZNQn1ghRXJyMcmGiCx15V40fZaE8CROS40SbizpVxs7a1loVAghhBDCYmiswa8nDD8MPX+C4vVAl6isLTS3FvzcF26fMHeUQphH9D34qRf8PgqVNob7ThVJGrIPfHsoRUyEyAnVusHwQ+hLvYaVPhHN1g+U4gvREeaOTLwCSbyJLHPrUSx9lgRzPzqByl4urOhfF0dbK3OHJYQQQggh0qJWQ4W2MGgHDNgG5dsABjj7KyxuDivfhMt7ZJSFyD8ubIfvG0Don6C2RtfiUw6WnQCuxc0dmciPXIuh67WB0969MGhs4cI2+K4BnP/T3JGJTJLEm8gSEZHx9FkSzJ0n8fgUcWTVoLq4OlibOywhhBBCCJERJRtAr3XKKLjqb4NKA1f/gtWdYFFTOLMR9DpzRylE9kiMgd/HwI/dIeYeFKkEQ/egb/A+qOQlszAjlZor7m1IGrgTPKpC7H34qSf89j4kRJs7OpFB8ltEmOxRTCJ9lgZz7UEsxQrYs2ZwPQo72Zo7LCGEEEIIkVkelaHLQmUduHrvgrUD3P0b1g+AebXh2DLQxps7SiGyzq3jsOA1OL5c2a7/HgzdC57VzBqWECm4V4Ihu6HhKEAFJ1bBgsZwM8TckYkMkMSbMElUvJZ+y0O4EB6Nh4stPw6uj5ervbnDEkIIIYQQpnArAW1nKpVQm04A+wLw8Ar8MVYpxLB/NsQ/MXeUQrw6XRLs/R8sbQUPL4NzUej7K7SZAdZ25o5OiNSsbKH1Z9Dvd6U69aOrsMwfdn8BOq25oxMvIIk38criEnUMWnGMf249oaCjDT8MrkeJQg7mDksIIYQQQmQVx0LQfCKM/RfazFRe7MVEwK5pMLsKBE2BqDBzRylE5jy4rCQs9gaAQQdVu8KIQ1CmmbkjE+LlSr8Gww9Cte5g0MO+L2Fpa7h/ydyRiXRI4k28koQkHUNXHyPk2kOc7axYNbAuZd2dzR2WEEIIIYTIDjaOUP9dZQpq54XKGliJUXBwjjIC7rf35UWfsHwGAxxbrkzRu30MbF2hyxLotkwZ1SlEbmHvBl0XK89dO1e4c0J5Xh9dKgVxLJAk3kSmJen0jFp7kv0X7+Ngo2HFgDpU9XY1d1hCCCGEECK7aazB920Yfgh6roMSDUCXqKw3NK82rHsHbh83d5RCpBZ9D9b2hD/GgDYWSj0dNVT9LXNHJsSrq9pVKYpTuikkxcGWcfBjD4gKN3dk4hmSeBOZotcb+HD9P2z/NxwbKzWL+9amVsmC5g5LCCGEEELkJLUaKrSBgdtg4HYo3xYwwLnfYHELWPkGXNolIy+EZQjdCt/VhwtbQWMDrT+Hvr+BW3FzRyaE6Vy94Z3N4B8AGlu4uB2+bwDnt5g7MvGUJN5EhhkMBib/eoZNJ2+jUav4rldNGpUtbO6whBBCCCGEOZWoD71+ghFHwLcnqK3g6j5Y0wUWNoEzG5SF7IXIaQnR8PtoWPs2xN4H98owZA80fF9JHguRV6jV0GCEUpHXoxrEPoCfesGvIyEhytzR5Xvy20ZkiMFgIGDreX4IvoFKBbO7+9Kysoe5wxJCCCGEEJbCvRJ0XgCjTkH9EWDtAGH/wPqBMK+WsvaQNs7cUYr84tYxWPgaHF+hbDcYqSTdPKuaNSwhspVHZRiyCxqNBlRwcrWy9tvNEHNHlq9J4k1kyLe7LrFo3xUAAjpXo6Oft5kjEkIIIYQQFsmtOLQJUCqhNvsY7AvCo2vK2kOB1WDfLIh7bO4oRV6l08KeAKXK48Mr4OKtTCv1/wKs7cwdnRDZz8oWWk2H/n+Aa3Hl9+8yf9j9ufLzIXKcJN7ESy3Zf4Vvdl4AYHKHyrxdt4SZIxJCCCGEEBbPoSA0+wjGnoG2X4JrCYi5B7s/g2+qwo5JEHnX3FGKvOTBZSXB8Nf/wKCDqt2UAgplmpo7MiFyXqnGTwuIvA0GPez7Cpa2gvsXzR1ZvmNl7gCEZfsp5AafbzkHwLhW5RnUuLSZIxJC5FY6nQ6tNuW7bFqtFisrK+Lj49HpdGaKLPeS/jOdqX1obW2NRqPJhsiEyENsHKHeMKg9EM5shIOBEHEWDs2F4IVQvYcyLapwOXNHKnIrgwGOL4ftnygVS21docNsqNbN3JEJYV52rtBloVIM5/cxcOckLHgNWn8GdQaDSmXuCPMFSbyJdP166jYTN50GYFiTMrzfoqyZIxJC5EYGg4GwsDAeP36c5mOenp7cvHkTlfzhzzTpP9NlRR+6ubnh6ekp3wMhXkZjDb49oHp3uBgEB76BG4eUNYhOroFKHaDRWChWy9yRitwkOgJ+ex8ubFO2S72mrDXoWsy8cQlhSap0huL1YPMIuLIH/vwALmyHjvPBWdZuz26SeBNpCjobzrif/8ZggD71SzChbUV5QSGEeCXJSTd3d3ccHBxS/C7R6/VER0fj5OSEWqqLZZr0n+lM6UODwUBsbCwREREAeHl5ZUeIQuQ9KhWUb6183AhWRsCF/gnnflc+Sr0GjceAz+vmjlRYuvN/Kkm32PugsYHXP1UKe8jfRCFScykKfTZCyCIImgKXguC7+vDmt1DpDXNHl6dJ4k2kcuDifd774QQ6vYEuNbyZ/mZVSboJIV6JTqczJt0KFSqU6nG9Xk9iYiJ2dnaSOHoF0n+mM7UP7e3tAYiIiMDd3V2mnQqRWSXqQYm1EHEeDn0L/6yDa/uVD89qqOq/j8pgbe4ohaVJiIbtE+HEKmXbvQp0XQweVcwblxCWTq2G+u8q6x5uHAJhp2FdH/DrA23/B7bO5o4wT5L/0kUKx649ZMiqYyTq9LSp4smX3aqjVkvSTQjxapLXdHNwcDBzJEJkn+Tn9/NrGAohMsG9InT6Dkb/DfXfA2tHCDuN1eahvH52POpjy0AbZ+4ohSW4GQILGj9Nuqmg4fswdI8k3YTIDPdKMHg3NBoDqODUGvi+Edw4Yu7I8iRJvAmjM7efMGD5UeK0OpqWL8Kcnn5YaeQpIoQwnYyaFXmZPL+FyEKuxaDNDKUSavNPMDgUwjHxHprt45VKqPu+grhH5o5SmINOC7u/UKqWProKLsWg3+/Q+nOwsjV3dELkPlY20Goa9N+iVJ1+fB2Wt4Vdnyk/byLLSFZFAHAxPIp3lgYTlZBE3dIFWdCnFrZWMl1GCCGEEEKYgUNBaDqepJEn+afYOxhcSyjreO3+XEnAbf8EIu+YO0qRU+5fgqWtYd+XYNBDte4w/CCUfs3ckQmR+5VqBMMPgG9P5edr/yxY0hLuXTB3ZHmGJN4E1x/E0HtJMI9itfgWc2Vpv9rY20jSTQghslqpUqUIDAzM8P579+5FpVKlWRE2L+jfvz+dOnXK8n2FEHmItQNXi7QiaUQIdFmirOWVGA2H50Fgdfj1PXlxmJcZDHB0qTK19M4JsHOFbsuU9dzs3cwdnRB5h52rUg34rZVgXwDunoKFTSBksfJzKEwiibd87u6TOHotDiYiKoEKHs6sGFAXZztZwFYIkb+pVKoXfkydOvWVznv06FGGDh2a4f0bNmzI3bt3cXV1faXrZVRygi/5w8PDg65du3LlypVsve6cOXNYsWJFlu8rhMiD1FZQ/S1llFPv9VCyMei1cHINzK8LP/WGm0fNHaXISlHh8GMP2DIOkuKgdBMYfhiqdjV3ZELkXVU6KT9nPi2Un7s/P4AfukFUmLkjy9Uk8ZaP3Y9OoPeSYG4/jqN0YUdWD65LAUcbc4clhBBmd/fuXeNHYGAgLi4uKdo++OAD474Gg4GkpKQMnbdIkSKZKjRhY2ODp6dnjq0hFhoayp07d/jll1/4999/eeONN9DpdKn2y8w9v4irqytubm5Zvq8QIg9TqaBcKxiwBQbthIodAAOc/wOWtoTl7eFikIzQyO3Ob4HvG8DF7aCxBf8Z8M6v4Opt7siEyPtcvKD3Bmj7JVjZwaWd8F0DOPubuSPLtSTxlk89idXyztIQrtyLwdvNnjWD6+HubGfusIQQ+YDBYCA2Mcn4EZeoS7GdnR+GDL4Q8/T0NH64urqiUqmM2+fPn8fZ2ZmtW7dSq1YtbG1tOXDgAJcvX6Zjx454eHjg5OREnTp12LlzZ4rzPj/VVKVSsWTJEjp37oyDgwPlypXjt9/++6fm+ammK1aswM3Nje3bt1OpUiVcXFzo1q0bd+/eNR6TlJTEqFGjcHNzo1ChQnz00Uf069cvQ9M03d3d8fLyokmTJkyZMoWzZ89y6dIlYxzP37NerycgIIDSpUtjb2+Pr68v69evT3HOf//9lw4dOuDi4oKzszOvvfYaly9fBlJPH12/fj3VqlXD3t6eQoUK0bJlS2JiYtLcNyEhgVGjRuHu7o6dnR2NGzfm6NH/Rrskx7xr1y5q166Ng4MDDRs2JDQ09KX9IITIJYrXgbd/gPdCwK8PqK3h+gFldMaC1+CfX0Bn+psEIgclRMGvI+GnXhD7ADyqwtC90OA9UMtLVyFyjFoN9YbB0L/AszrEPYSf34HNIyA+0tzR5TpW5g7gefPnz+err74iLCwMX19f5s6dS926ddPcV6vVEhAQwMqVK7l9+zYVKlRg5syZtGnTJsV+t2/f5qOPPmLr1q3ExsZStmxZli9fTu3atXPilixOdEIS/ZaHcO5uJIWdbFkzuB7ebvbmDksIkU/EaXVUnrLdLNc+O90fB5us+dM3YcIEZs2aRZkyZShQoAA3b96kXbt2fPHFF9ja2rJq1SreeOMNQkNDKVGiRLrnmTZtGl9++SVfffUVc+fOpXfv3ly/fp2CBQumuX9sbCyzZs1i9erVAPTp04cPP/yQH3/8EYCZM2fyww8/sHz5cipVqsScOXPYvHkzzZs3z9T92dsrfxcSExPTveeAgADWrFnDggULKFeuHPv27aNPnz4UKVKEpk2bcvv2bZo0aUKzZs3YvXs3Li4uHDx4MM3Rcnfv3qVnz558+eWXdO7cmaioKPbv359usnT8+PFs2LCBlStXUrJkSb788kv8/f25dOlSir775JNP+PrrrylSpAjvvvsuAwcO5ODBg5nqCyGEhStSATrNh+Yfw5Hv4PgKCD8NGwfD7unQcBT49QabjI84FmZwMwQ2DoFH1wAVNHwfWkySiqVCmJN7RRi8C/YGwIFv4NQPcG0/dF4EJRuYO7pcw6ISb+vWrWPcuHEsWLCAevXqERgYiL+/P6Ghobi7u6faf9KkSaxZs4bFixdTsWJFtm/fTufOnTl06BA1atQA4NGjRzRq1IjmzZuzdetWihQpwsWLFylQoEBO355FiNfqGLzyKKduPsbNwZofBtejdGFHc4clhBC5zvTp02nVqpVxu2DBgvj6+hq3P/vsMzZt2sRvv/3GyJEj0z1P//796dmzJwAzZszg22+/JSQkJNWbSMm0Wi0LFizAx8cHvV7P4MGDmTVrlvHxuXPnMnHiRDp37gzAvHnz+PPPPzN1b3fv3mXWrFl4e3tToUIFDh06lOqeExISmDFjBjt37qRBA+UfrzJlynDgwAEWLlxI06ZNmT9/Pq6urvz0009YWyvrh5YvXz7dayYlJdGlSxdKliwJQLVq1dLcNyYmhu+//54VK1bQtm1bABYvXkxQUBBLly7lww8/NO77xRdf0LRpU0BJHLZv3574+Hjs7GSUtxB5jqs3+H8BTT6Ao0vgyAJ4fENZo2hvANQbDnUGKRVTheXQaeGvmbD/a6WiomtxZZH3Uo3NHZkQAsDKBlp+CuVaw6ahyu/VFe2g0RhoNlF5XLyQRSXeZs+ezZAhQxgwYAAACxYsYMuWLSxbtowJEyak2n/16tV88skntGvXDoDhw4ezc+dOvv76a9asWQMo7/wXL16c5cuXG48rXbp0DtyN5UlM0jN8zXGOXHmIk60VKwfUpYKns7nDEkLkM/bWGs5O9wdAr9cTFRmFs4sz6hyYQmJvnXUVm58fNR0dHc3UqVPZsmWLMYkUFxfHjRs3Xnie6tWrG792dHTExcWFiIiIdPd3cHDAx8fHuO3p6Wnc/8mTJ4SHh6cYKa7RaKhVqxZ6vf6l91SsWDFlKnBsLL6+vmzYsAEbm//+mXr2ni9dukRsbGyK5CMoI+SS3/w6deoUr732mjHp9iK+vr68/vrrVKtWDX9/f1q3bk23bt3SfKPs8uXLaLVaGjVqZGyztrambt26nDt3LsW+z/avl5cXABERES8chSiEyOXsC0CTD6HBSKX4wqFvlReKez5XRmzU6q9MXZT1wszv/kVllNudk8p29R7Q7iulwqIQwrKUbADvHoRtE5SRbwdmw+Vd0GWxMvJYpMtiEm+JiYkcP36ciRMnGtvUajUtW7bk8OHDaR6TkJCQ6h1re3t7Dhw4YNz+7bff8Pf356233uKvv/7C29ubESNGMGTIkOy5EQuVpNMzdt0p9oTew85azdJ+tfEt7mbusIQQ+ZBKpTJO99Tr9STZaHCwscqRxFtWcnRMOVr4gw8+ICgoiFmzZlG2bFns7e3p1q1biqmaaXk+KaVSqV6YJEtr/4yuXfcy+/fvx8XFBXd3d5ydU78x8+w9R0dHA7Blyxa8vVO+eLW1VaYFJU9XzQiNRkNQUBCHDh1ix44dzJ07l08++YTg4GCT3jB7tr+Si1RkJAkphMgDrO2h7hCoNQDOboYDgcoU1CPzIWQRVO8OjUbLC0ZzMBiUUYk7JiuVE+3coMM3ULWLuSMTQryInQt0+g7K+8Pvo+Hu37CwCbSaDnWHKgVwRCoWk3i7f/8+Op0ODw+PFO0eHh6cP38+zWP8/f2ZPXs2TZo0wcfHh127drFx48YUFdiuXLnC999/z7hx4/j44485evQoo0aNwsbGhn79+qV53oSEBBISEozbkZHK4oFarRatVmvqraaSfM7sODeAXm9g4uZ/2XL6LtYaFd/19KNmcZdsu15Oy+7+y+uk/0wj/fdiWq0Wg8GAXq9PM9mRnDBK3scSJceV1udnYz548CD9+vWjY8eOgJKYunbtWqp7e347rb5Jbnv+Ws/H8GzCTa/X4+zsjIeHByEhITRurEzR0el0nDhxAl9f33T7OLm9ZMmSxsqhz8f4fKwVK1bE1taWa9eu8dprr6V5zmrVqrFq1SoSEhLSHPVmMBhS9UeDBg1o0KABkyZNonTp0mzcuJGxY8em2Ld06dLY2Niwf/9+ihcvDijPtaNHjzJ69Og0+y69+8iK56Ber8dgMKDVatFoUo6qlN8NQlgAjRVU6wZVu8KlXXAwUFmj6NQPykeF9tB4DBRPe11pkcWiwuHX9+BSkLJdphl0+h5cipo1LCFEJlTuCMXqKj/Ll3fB1vFwYRt0/E6piipSsJjE26uYM2cOQ4YMoWLFiqhUKnx8fBgwYADLli0z7qPX66lduzYzZswAoEaNGpw5c4YFCxakm3gLCAhg2rRpqdp37NiBg0P2LcoaFBSU5ec0GGDjNTX7wtSoMfCOj46oiyH8eTHLL2V22dF/+Yn0n2mk/9JmZWWFp6cn0dHRLxz5FRUVlYNRZU58fDwGg8H4JkxsbCygxPzsKL1SpUqxfv16YxGDGTNmoNfrSUxMNB6r1+uJj483bgPExcWl2DYYDMZ9nr/W87E8K7lt8ODBBAQEULRoUcqVK8eiRYt4+PAhOp0uzeNedE8ve3zkyJGMGzeO2NhY6tevT2RkJMHBwTg7O9OzZ0/69u3L3Llzeeuttxg7diwuLi4cPXqUWrVqUa5cObRaLUlJSURGRnLs2DH++usvWrRoQeHChTl+/Dj37t2jRIkSREZGptgXYODAgYwfPx47OzuKFSvGt99+S0xMDG+99VaafQcYK6RGR0en6gtTnoOJiYnExcWxb9++VIUjkuMQQlgAlQrKtVQ+bh1Tpp2e3wKhTz9KNlLWLCrXSkZtZJdzv8Nvo5QKiRpbaDUN6g6TiqVC5EYuXtBnA4QshqDJcHk3fN8AOgRClU7mjs6iWEzirXDhwmg0GsLDw1O0h4eH4+npmeYxRYoUYfPmzcTHx/PgwQOKFi3KhAkTKFOmjHEfLy8vKleunOK4SpUqsWHDhnRjmThxIuPGjTNuR0ZGUrx4cVq3bo2Li8ur3N4LabVagoKCaNWqVYbWwcmM2UEX2Rd2FYCZXavRyS/vvZOUnf2XH0j/mUb678Xi4+O5efMmTk5OaS5mbzAYiIqKwtnZ2TgN0NLY2dmhUqmMv/+T34BxdnZO8Tdhzpw5DB48GH9/fwoXLsz48eOJi4vDxsbGuJ9arcbOzi7Fcfb29im2VSqVcZ/nr/V8LM+OeEtumzJlCo8fP2b48OFoNBqGDBmCv78/Go0m3b9h6d3Tyx6fOXMmxYoVY86cOYwePRo3Nzdq1KjBxIkTcXFxwcXFhV27djF+/Hg6dOiARqPBz8+Pli1b4uLigrW1NVZWVri4uODl5UVISAgLFy4kMjKSkiVLMmvWLLp27QqQYl+Ar7/+GisrK4YPH05UVBS1a9dm27ZtxrXb0oo5eaqsk5NTij409TkYHx+Pvb09TZo0SfU8Ty/ZKYQws2K14e0flDXGDs6Bv3+C6weVD/cqygi4Kl2U0XLCdAlRsHUCnFLW4cazmrIulHsl88YlhDCNSgX1hkKZpsp6jXf/hl/6wYVe0HamMjVVWE7izcbGhlq1arFr1y46deoEKCMDdu3a9cJqcKC8KPL29kar1bJhwwa6d+9ufKxRo0aEhoam2P/ChQvGimlpsbW1Na5P8yxra+tsfWGd1ef/bu8lvt+nJN0+61SVt+qkf895QXZ/f/I66T/TSP+lTafToVKpUKvVaY6kSp7al7yPJRo4cCADBw40brdo0SLNNdXKlCnD7t27U7Q9//fr2rVrKbbTOs/jx4/Tvdbzsej1etq3b49OpzP2n42NDfPmzWPevHnGfSpVqkT37t3T7eP07ikjj48ZM4YxY8ake6yfnx87duxI87GVK1cav65SpQrbt29P9zzP7gtKYm3u3LnMnTs3wzHXrFkzVVtWPAfVajUqlSrN3wPye0EIC1e4HHScB80/hiPfwbHlEPGv8gJy12fQcCTUeAdssm/WS5534whsHAqPrwMqZV295h+DVerXW0KIXKpIBRi0E/76nzKa+O8f4foB6LwQSjY0d3RmZ1GvcsaNG8fixYtZuXIl586dY/jw4cTExBirnPbt2zdF8YXg4GA2btzIlStX2L9/P23atEGv1zN+/HjjPmPHjuXIkSPMmDGDS5cu8eOPP7Jo0SLee++9HL+/nLTy0DW+3KYkHCe2rcg79fN20k0IIYTi+vXrLF68mAsXLnD69GmGDx/O1atX6dWrl7lDE0IIy+VSFFp/DmPPQIvJ4FgEntxQ1i0KrAp7Z0LsQ3NHmbvotErycnlbJenmWgL6b1Gml0rSTYi8x8oGXp8CA7aCW0mlmvTydrBzKiS9uNhYXmdRibcePXowa9YspkyZgp+fH6dOnWLbtm3Gggs3btzg7t27xv3j4+OZNGkSlStXpnPnznh7e3PgwAHjwtAAderUYdOmTaxdu5aqVavy2WefERgYSO/evXP69nLML8du8ulv/wIwqkVZhjX1MXNEQgghcoparWbFihXUqVOHRo0acfr0aXbu3EmlSjKdR1iG+fPnU6pUKezs7KhXrx4hISHp7qvVapk+fTo+Pj7Y2dnh6+vLtm3bUuwTEBBAnTp1cHZ2xt3dnU6dOqWa7SBEhtkXgCYfwJjT0P5rKFAKYh/A3hnwTVXYNhGe3DJ3lJbv3gVY0hL2zwKDHqq/DcMPQKlG5o5MCJHdStSHdw+AXx/AoIyAW/I6RKRdNDM/sJippslGjhyZ7tTSvXv3pthu2rQpZ8+efek5O3ToQIcOHbIiPIu35Z+7fLThHwAGNirN2FblzRyREEKInFS8eHEOHjxo7jCESNO6desYN24cCxYsoF69egQGBuLv709oaCju7u6p9p80aRJr1qxh8eLFVKxYke3bt9O5c2cOHTpEjRo1APjrr7947733qFOnDklJSXz88ce0bt2as2fPGtf1EyLTrO2hzmCo2R/O/aq8cAw7rUxHDVkE1borUybdK5o7UstiMMDRJbBjMiTFgZ0bvBEIVTqbOzIhRE6yc4FO86G8P/w+GsL+gUVNoeU0qDs03xVUyV93m8ftOR/B6J9OojfA23WKM7lDJYtdrFwIIYQQ+c/s2bMZMmQIAwYMoHLlyixYsAAHB4cUFemftXr1aj7++GPatWtHmTJlGD58OO3atePrr7827rNt2zb69+9PlSpV8PX1ZcWKFdy4cYPjx4/n1G2JvExjBVW7wrD90GcjlHoN9EnK+kXf1YMf34YbweaO0jJEhcEP3eDPD5SkW5nmMOKwJN2EyM8qv6n8HijbEpLiYdtHsKYLRN4xd2Q5ShJvecThyw94d81xkvQG3vQtyhedq0nSTQghhBAWIzExkePHj9OyZUtjm1qtpmXLlhw+fDjNYxISElJVirW3t+fAgQPpXufJkycAFCxYMAuiFuIplQrKvg79/4Ahu6HSm4AKLmyFZa1hWRu4sF0Z8ZUfnf0NvmsAl3aClR20makkKl2KmjsyIYS5OXtC7/XQbhZY2cOVPcrvi383mTuyHGNxU01F5p288YjBK4+SkKSnZSUPvu7ui0YtSTchhBBCWI779++j0+mMa/cm8/Dw4Pz5tNd98ff3Z/bs2TRp0gQfHx927drFxo0b0el0ae6v1+sZM2YMjRo1omrVqmnuk5CQQEJCgnE7MjISUNaT02q1r3JrL5R8zuw4d35gkf3nXh26LIMHF9EcmY/q9M+obhyGHw9jKFIJXYP3MVTuDBrzVzXO9v5LiEKz42PU/6wFwOBRjaSOC5QKhzqd8pGLWeTzL5eRPjRNnuq/Gv2heCM0v76LOuxv+KU/+vN/omv9P2VqajbI7v7L6Hkl8ZbLnb0TSb9lIcQk6mhUthDzetXAWiMDGYUQQgiR+82ZM4chQ4ZQsWJFVCoVPj4+DBgwIN2pqe+99x5nzpx54Yi4gIAApk2blqp9x44dODg4ZFnszwsKCsq2c+cHFtt/qtbYVapDmYjtlLq/G+t757D6bQSxWydz2b0t1ws1RacxfwXP7Oi/gtGh1Ly+EMfE+xhQcdGjPec9u2A4ehm4nOXXMyeLff7lItKHpslL/afyHE0Fw2bKh/+O+vTPxIfu5kTJoTxwyr41M7Or/2JjYzO0nyTecrHL96J5Z2kwkfFJ1CpZgMV9a2NnrTF3WEIIIYQQqRQuXBiNRkN4eHiK9vDwcDw9PdM8pkiRImzevJn4+HgePHhA0aJFmTBhAmXKlEm178iRI/njjz/Yt28fxYoVSzeOiRMnMm7cOON2ZGQkxYsXp3Xr1ri4ZP077lqtlqCgIFq1aoW1tflHQOU2uaf/ekP8E3THl6M+ugiHmAiq3V5D1Yd/oq89GH3tweCQ89Ofs6X/dImo932J+tS3qAx6DK7F0b35HaVLNKB01lzBYuSe55/lkj40Td7tvzfR3QpB8+sIHB5fo9HFAPQNRqJvMgGssu7Niuzuv+RR8y8jibdc6ubDWPosCeZBTCJVirqwrH8dHGzk2ymEEJakWbNm+Pn5ERgYCECpUqUYM2YMY8aMSfcYlUrFpk2b6NSpk0nXzqrzWKLn+zWr9hXZy8bGhlq1arFr1y7j81Kv17Nr1650K9ons7Ozw9vbG61Wy4YNG+jevbvxMYPBwPvvv8+mTZvYu3cvpUu/+KW/ra0ttrap/6m3trbO1hc12X3+vC5X9J91YWj2ITR6Xym+cPBbVI+uotn/JZoj86BmP2jwHrgVz/nQsqr/7oXCxiFw929l27cXqrYzscqmaWKWIlc8/yyc9KFp8mT/lW4Eww/AtgmoTq5Bc3gumit7oeticK+UpZfKrv7L6DllTmIuFB4ZT+8lwdx9Ek9ZdydWDayLq30e+yEUQggzeuONN2jTpk2aj+3fvx+VSsU///yT6fMePXqUoUOHmhpeCv/73/+oWbNmqva7d+/Stm3bLL3W81asWIFKpUKlUqFWqylWrBgDBgwgIiIiW6+7ceNGPvvssyzfV2S/cePGsXjxYlauXMm5c+cYPnw4MTExDBgwAIC+ffsyceJE4/7BwcFs3LiRK1eusH//ftq0aYNer2f8+PHGfd577z3WrFnDjz/+iLOzM2FhYYSFhREXF5fj9ycEANZ2UHsgvH8cui0HL1/QxkLw9/CtH2wcBuFnzR1l5hgMELwQFjZRkm72BaD7Kuj8fbatzSSEyAdsnaHjfOjxAzj8f3v3HmZjvf9//LnWjDmfkMMQ4zBmDDlF4zdUJO1xzHSivnLIlJLRVlvSTpF+JbFzyGnv3beZqIiK2iXjTBhnwxBCDsUgJYMxjFn394+1rVpmMDP3rFlreD2ua12Xda/PWvd7va/b7e29PvfnrgjHM+CfbWDdNLDZ3B1didEUqTLmt3MXefz99Rz+LZsaFfz5KLElFYPcv26EiMiNJDExkYceeoiff/453yVrycnJtGjRgsaNGxf5cytVqlRSIV7X1S7dK2khISHs2bMHm83Gtm3beOKJJzh69Cipqan5xubl5TmadGYU5W6VurOlZ+nRowe//PILr732GseOHaNp06YsXLjQccOFw4cPOx0fOTk5DB8+nB9//JGgoCA6derEzJkzCQsLc4yZNm0aYJ/d+GfJycn07dvX1V9J5OqsXnDbg9DwAftd/FZPgAMrYfts+yOqA7QeDBFx7o702rIy4ctnYf8y+/O699r/oxwS7t64ROTGEdMFbr0DvhwI+xbDwmHww0JImHZD3B1ZM97KkKycXHp/sJ69J85SNcSPT578f1QN9XN3WCIiN5wuXbpQqVIlUlJSnLafPXuWuXPnkpiYyK+//spjjz1G9erVCQgIoFGjRsyaNeuan1urVi2nSx737t3L3XffjZ+fHw0aNChw4deXXnqJqKgoAgICqFOnDq+++qrjDkopKSmMGTOGbdu2OWaeXY7ZYrEwf/58x+dkZGTQrl07/P39qVixIv379+fs2bOO1/v27UtCQgLjxo0jPDycihUrMnDgwOverclisVC1alWqVatGx44dee6551iyZAnnz58nJSWFsLAwvvrqKxo0aICvry+HDx/mwoULDBkyhOrVqxMYGEjLli1ZsWKF0+euWbOGtm3bEhAQQPny5YmPj+fUqVOAvcHy58t1p06dSr169fDz86NKlSo8/PDDjteuHHvq1Cl69+5N+fLlCQgIoFOnTuzf/8ci4JdjTk1NJSYmhqCgIDp06EBmZuY18yCFl5SUxKFDh7hw4QLr16+nZcuWjtdWrFjh9PeuTZs2fP/99+Tk5HDy5ElmzJhBtWrOBbhhGAU+1HQTj2GxQN120OcreGo5NOgGWOz/qUzuAP8bD3u+9czZHTvnw7Q4e9PN2w86joXHP1fTTURKXnAV6DkXOv8DvP3hxxUwNQ52fOHuyExT462MyL54iX7JG9lxJIuKgT589GRLalRw3Z23RERcxjDg4rk/HrnZzs9d+TCMQoXo7e1N7969SUlJwfjTe+bOnUteXh6PPfYYOTk5NG/enG+++YYdO3bQv39/evXqxYYNGwq1D5vNxoMPPoiPjw/r169n+vTpvPTSS/nGBQcHk5KSwvfff8/EiRP597//zfjx4wH77KGkpCQaNmxIZmYmmZmZ9OjRI99nnDt3jvj4eMqXL8/GjRuZO3cuS5Ysybeu1vLly9m/fz/Lly/nww8/JCUlJV/z8Xr8/f2x2WxcunQJsN/tacyYMbz//vvs3LmTypUrk5SURFpaGrNnz2b79u088sgjdOjQgb179wKQnp7OvffeS4MGDUhLS2P16tV07dqVvLy8fPvbtGkTzz33HKNGjWLPnj0sXLiQu++++6rx9e3bl02bNvHVV1+RlpaGYRh0797dqcGYnZ3NuHHjmDlzJqtWreLw4cMMGTKkSHkQESlQ9dvtl2gmbbKv+eblAz+tg1mPwrRWkD4L8q79g0epyMmCeQNgbh84fwqqNoanV0HL/vZGooiIK1gscMeT8Mx3UK0Z5PwOnz0BX/SHnNPujq7YdKlpGZCTm8fTMzez6dApQvy8mZEYS2TlIHeHJSJSPLnZ8JZ9xooVCCvNff/9KPgEFmpov379GDt2LCtXrnRcwpacnMxDDz1EaGgooaGhTs2YQYMGkZqaypw5c4iNjb3u5y9ZsoTdu3eTmprqmMHz1ltv5VuXbfjw4Y4/16pViyFDhjB79myGDh2Kv78/gYGBeHt7X/PS0k8++YScnBxmzJhBYKD9+0+ePJmuXbsyZswYx2V+5cuXZ/LkyXh5eVG/fn06d+7M0qVLeeqppwqVs7179zJ9+nRatGhBcHAwYL+b1NSpU2nSpAlgv5QwOTmZw4cPO773kCFDWLhwIcnJybz11lu88847tGjRgqlTpzo+u2HDhgXu8/DhwwQGBtKlSxeCg4OJiIigWbNmV43vq6++Ys2aNbRq1QqAjz76iIiICObPn+9oWubm5jJ9+nTq1q0L2GdojRo1qlA5EBEplFsi4f5JcM/f7WsZbfoAftkF85+BZf8fWiXB7b0L/W9WiTq0FuY9Db8fBovVfjls25fB26f0YxGRm9Mt9SBxMax8B74bB9s/tZ+bHpgOte50d3RFphlvHi43z8agWVv5bu9JAny8SOkXS8Nqoe4OS0Tkhle/fn1atWrFBx98AMC+ffv47rvvSExMBOzrlb3xxhs0atSIChUqEBQURGpqKocPHy7U5+/atYsaNWo4XTYXF5d/nZ9PP/2U1q1bU7VqVYKCghg+fHih9/HnfTVp0sTRdANo3bo1NpuNPXv2OLY1bNgQLy8vx/Pw8PDr3ijh9OnTBAUFERAQQHR0NFWqVOHjjz92vO7j4+O0Hl5GRgZ5eXlERUURFBTkeKxcudJxyeflGW+Fcd999xEREUGdOnXo1asXH3/8MdnZ2VfNg7e3t9OljRUrViQyMpLdu3c7tgUEBDiaboXNg4hIsQRXhfteh+d3QPuREFgZsn62r280viEsfwvO/Vo6sVy6CEtGQnIne9MtrCb0XQDtR6jpJiKlz6sctHsF+qVC+dpw+idI6QKLXoVLF9wdXZFoxpsHy7MZDJm7jcXfH8fH28r7vVtwe83y7g5LRMSccgH2mWfYL7fMOnOGkOBg0wvuF3rfRZCYmMigQYOYMmUKycnJ1K1blzZt2gAwduxYJk6cyIQJE2jUqBGBgYEMHjyYixcvlli4aWlp9OzZk9dff534+HhCQ0OZPXs2//jHP0psH3925S3RLRYLtuusORQcHMyWLVuwWq2Eh4fj7+/v9Lq/vz+WP12WdPbsWby8vNi8ebNTkw8gKCjI8Z7Curz/FStWsGjRIl577TVGjhzJxo0bnRbgL4qC8mAU8jJlEZFi8QuFO5+HlgNg2yxYOwl++xFWjoE1k+yz31ol2ZthrnBiN3zxFBz77x27m/aEDm/rjqUi4n41YuGZ1ZD6MmyZYT8/7l8OD/4LqjRwd3SFohlvHsowDIbPz+DL9KN4Wy1Mf/x2WkXe4u6wRETMs1jsl85cfpQLcH7uykcR16Xp3r07VquVTz75hBkzZtCvXz9HE2nNmjV069aNxx9/nCZNmlCnTh1++OGHQn92TEwMP/30k9Oi/evWrXMas3btWiIiInjllVdo0aIF9erV49ChQ05jypUrV+DaZ1fua9u2bZw7d86xbc2aNVitVqKjowsdc0GsViuRkZHUqVOnUA2zZs2akZeXx4kTJ4iMjHR6XL5ctnHjxixdurTQMXh7e9O+fXveeecdtm/fzsGDB1m2bFm+cTExMVy6dIn169c7tv3666/s27ePmJiYQu9PRMRlyvlBiyfsa8A9kgLhTeHSedjwT5jY1L7O0fGdJbc/mw3WTYd/tbE33fwrQPeZkDBVTTcR8Ry+QXD/e/DoJxBQEY5nwL/aQtoUz7wxzRXUePNAhmHw5je7mLXhJ6wWmPBoU9rVr+LusEREbjpBQUH06NGDl19+mczMTKe7JNarV4/Fixezdu1adu3axdNPP83x48cL/dnt27cnKiqKPn36sG3bNr777jteeeUVpzH16tXj8OHDzJ49m/379zNp0iTmzZvnNKZmzZocOHCA9PR0Tp48yYUL+afe9+zZEz8/P/r06cOOHTtYvnw5gwYNolevXo713UpLVFQUPXv2pHfv3nzxxRccOHCADRs2MHr0aL755hsAXn75ZTZu3Mizzz7L9u3b2b17N9OmTePkyZP5Pu/rr79m0qRJpKenc+jQIWbMmIHNZiuwoVivXj26devGU089xerVq9m2bRu9evUiPDycbt26ufy7i4gUmtULGj4A/VdA7y+hTlsw8uzrHE1rBR93t693ZGY2btZR+OhBWPgSXMqByPbwbBo0uL+kvoWISMmq3xmeXQf14iHvAqT+HWYmwOkj7o7smtR480ATluzl/dUHAHj7ocZ0aVztOu8QERFXSUxM5NSpU8THxzutxzZ8+HBuv/124uPjadu2LVWrViUhIaHQn2u1Wpk3bx7nz58nNjaWJ598kjfffNNpzP3338/zzz9PUlISTZs2Ze3atbz66qv5xsTHx3PPPfdQqVIlZs2alW9fAQEBpKam8ttvv3HHHXfw8MMPc++99zJ58uSiJaOEJCcn07t3b/72t78RHR1NQkICGzdupGZN+yVUUVFRLFq0iG3bthEbG0tcXBxffvkl3t75V8gICwvjiy++oF27dsTExDB9+nRmzZp11ZsxJCcn07x5c7p06UJcXByGYTBnzpx8l5eKiHgEi8XedOv9pb0J1yDBfsODvamQ3BH+9y+we0HRZ3zsnAdT4+DH5eDtB53GQc/P7GvOiYh4sqDK8D+fQpfx9itnDqyEaXGQ8Zm7I7sqi6FFS64rKyuL0NBQTp8+TUhIyU+5zs3NZcGCBXTq1ImUtJ94c8EuAEZ2bUDf1rVLfH83mj/nT/9xKjrlzxzl79pycnI4cOAAtWvXxs/PL9/rNpuNrKwsQkJCSmeNtxuM8mdeSeTwWse5q2sIMa806zz9O1F0yl8Bft0Pa9+D9E/sMz4AKtWH1n+F2x52uhFCvvzlnIYFQ2H7bPuA8Kbw4L+hUlTpf48yQMefecqhOcrfdZzcZ1+f8ugW+/NGj9h/SPAPA1yfv8LWEKrSPcisjX803V6Mj1bTTUREREREnFWsC10nwOAM+w0ZfEPgl90wfwBMampf8+jC2fzvO7gGpt1pb7pZrHDXEEhcrKabiJRdt0RC4iJo8xJYvCBjLkxrDQdWuTsyJ2q8eYiNv1gY8R97021A27oMvCfSzRGJiIiIiIjHCq4C7UfC8zug/esQVAWyjtjXPBrfEJa9CedOYrXlYl32OqR0htOHISwCnvgW7n3VaXaciEiZ5FUO7vk79EuF8rUh62f48H5YNBwu5V/72B3yL5YipW7R98f5ZJ8VA+gTF8HQeHN3mBMRERERkZuEXyjcORhaPmOfzbZmEvy2H1a9g/fa97jHKwSvC/+9+U+zx6HD2+Ab7NaQRURKXI074JnV9h8ftnwIa9/De98ygiv8j7sj04w3dztxJoe/fZaBDQsPNqvGiK4NsVgs7g5LRERERETKknJ+0LwvJG2E7jOgWjMsl84TdOE4hn8F6PERdJuippuI3Lh8g+D+SfDoLAi4BcuJndxxYDLY8twalhpvblY52I8xD9zG7RVtvNmtAVarmm4iIiIiIlJMVi9o0A2eWs6lnl+wq+qDXHpqFcR0dXdkIiKlo34neDYNW1RH0mv2s58X3UiXmnqATo2qwk82vL3UBxWRG5NuoC03Mh3fIuKRLBaMWnfzQ/hZIoOrujsaEZHSFVSZvEdm8tuCBe6ORDPeRETEdS7ftjs7O9vNkYi4zuXj2xW3qRcRERGRsk0z3kRExGW8vLwICwvjxIkTAAQEBDitY2mz2bh48SI5OTlYrfotqKiUP/PM5NAwDLKzszlx4gRhYWF4ebn3MgYRERER8TxqvImIiEtVrWq/vOVy8+3PDMPg/Pnz+Pv768YyxaD8mVcSOQwLC3Mc5yIiIiIif6bGm4iIuJTFYiE8PJzKlSuTm5vr9Fpubi6rVq3i7rvv1mV6xaD8mWc2h+XKldNMNxERERG5KjXeRESkVHh5eeVrUHh5eXHp0iX8/PzUOCoG5c885VBEREREXEkLwoiIiIiIiIiIiLiAGm8iIiIiIiIiIiIuoMabiIiIiIiIiIiIC2iNt0IwDAOArKwsl3x+bm4u2dnZZGVlaX2ZYlD+zFH+zFH+zFH+zFH+zHN1Di/XDpdrCfE8qvM8m/JnjvJnjvJnnnJojvJnjqfUeWq8FcKZM2cAqFGjhpsjERERkbLozJkzhIaGujsMKYDqPBERETHjenWexdBPsNdls9k4evQowcHBWCyWEv/8rKwsatSowU8//URISEiJf/6NTvkzR/kzR/kzR/kzR/kzz9U5NAyDM2fOUK1aNaxWrfDhiVTneTblzxzlzxzlzzzl0BzlzxxPqfM0460QrFYrt956q8v3ExISor9MJih/5ih/5ih/5ih/5ih/5rkyh5rp5tlU55UNyp85yp85yp95yqE5yp857q7z9NOriIiIiIiIiIiIC6jxJiIiIiIiIiIi4gJqvHkAX19fRowYga+vr7tDKZOUP3OUP3OUP3OUP3OUP/OUQ3E1HWPmKH/mKH/mKH/mKYfmKH/meEr+dHMFERERERERERERF9CMNxERERERERERERdQ401ERERERERERMQF1HgTERERERERERFxATXeREREREREREREXECNt1IyZcoUatWqhZ+fHy1btmTDhg3XHD937lzq16+Pn58fjRo1YsGCBaUUqWcqSv5SUlKwWCxODz8/v1KM1rOsWrWKrl27Uq1aNSwWC/Pnz7/ue1asWMHtt9+Or68vkZGRpKSkuDxOT1XU/K1YsSLf8WexWDh27FjpBOxBRo8ezR133EFwcDCVK1cmISGBPXv2XPd9Ov/9oTg51DnwD9OmTaNx48aEhIQQEhJCXFwc33777TXfo+NPikN1njmq84pPdZ45qvPMUa1njuo8c8pSnafGWyn49NNPeeGFFxgxYgRbtmyhSZMmxMfHc+LEiQLHr127lscee4zExES2bt1KQkICCQkJ7Nixo5Qj9wxFzR9ASEgImZmZjsehQ4dKMWLPcu7cOZo0acKUKVMKNf7AgQN07tyZe+65h/T0dAYPHsyTTz5JamqqiyP1TEXN32V79uxxOgYrV67sogg918qVKxk4cCDr1q1j8eLF5Obm8pe//IVz585d9T06/zkrTg5B58DLbr31Vt5++202b97Mpk2baNeuHd26dWPnzp0FjtfxJ8WhOs8c1XnmqM4zR3WeOar1zFGdZ06ZqvMMcbnY2Fhj4MCBjud5eXlGtWrVjNGjRxc4vnv37kbnzp2dtrVs2dJ4+umnXRqnpypq/pKTk43Q0NBSiq5sAYx58+Zdc8zQoUONhg0bOm3r0aOHER8f78LIyobC5G/58uUGYJw6dapUYipLTpw4YQDGypUrrzpG579rK0wOdQ68tvLlyxvvv/9+ga/p+JPiUJ1njuq8kqM6zxzVeeap1jNHdZ55nlrnacabi128eJHNmzfTvn17xzar1Ur79u1JS0sr8D1paWlO4wHi4+OvOv5GVpz8AZw9e5aIiAhq1Khxza635Kfjr2Q0bdqU8PBw7rvvPtasWePucDzC6dOnAahQocJVx+j4u7bC5BB0DixIXl4es2fP5ty5c8TFxRU4RsefFJXqPHNU55U+HX8lQ3VewVTrmaM6r/g8vc5T483FTp48SV5eHlWqVHHaXqVKlauuBXDs2LEijb+RFSd/0dHRfPDBB3z55Zd89NFH2Gw2WrVqxc8//1waIZd5Vzv+srKyOH/+vJuiKjvCw8OZPn06n3/+OZ9//jk1atSgbdu2bNmyxd2huZXNZmPw4MG0bt2a22677arjdP67usLmUOdAZxkZGQQFBeHr68szzzzDvHnzaNCgQYFjdfxJUanOM0d1XulTnWeO6ryrU61njuq84ikrdZ63y/cgUsri4uKcutytWrUiJiaGf/7zn7zxxhtujExuBtHR0URHRzuet2rViv379zN+/Hhmzpzpxsjca+DAgezYsYPVq1e7O5Qyq7A51DnQWXR0NOnp6Zw+fZrPPvuMPn36sHLlyqsWZSLi2XSOE3dSnXd1qvXMUZ1XPGWlztOMNxe75ZZb8PLy4vjx407bjx8/TtWqVQt8T9WqVYs0/kZWnPxdqVy5cjRr1ox9+/a5IsQbztWOv5CQEPz9/d0UVdkWGxt7Ux9/SUlJfP311yxfvpxbb731mmN1/itYUXJ4pZv9HOjj40NkZCTNmzdn9OjRNGnShIkTJxY4VsefFJXqPHNU55U+1Xkl72av80C1nlmq84qvrNR5ary5mI+PD82bN2fp0qWObTabjaVLl1712uO4uDin8QCLFy++6vgbWXHyd6W8vDwyMjIIDw93VZg3FB1/JS89Pf2mPP4MwyApKYl58+axbNkyateufd336PhzVpwcXknnQGc2m40LFy4U+JqOPykq1XnmqM4rfTr+St7NWueBaj2zVOeVPI+t81x++wYxZs+ebfj6+hopKSnG999/b/Tv398ICwszjh07ZhiGYfTq1csYNmyYY/yaNWsMb29vY9y4ccauXbuMESNGGOXKlTMyMjLc9RXcqqj5e/31143U1FRj//79xubNm41HH33U8PPzM3bu3Omur+BWZ86cMbZu3Wps3brVAIx3333X2Lp1q3Ho0CHDMAxj2LBhRq9evRzjf/zxRyMgIMB48cUXjV27dhlTpkwxvLy8jIULF7rrK7hVUfM3fvx4Y/78+cbevXuNjIwM469//athtVqNJUuWuOsruM2AAQOM0NBQY8WKFUZmZqbjkZ2d7Rij89+1FSeHOgf+YdiwYcbKlSuNAwcOGNu3bzeGDRtmWCwWY9GiRYZh6PiTkqE6zxzVeeaozjNHdZ45qvXMUZ1nTlmq89R4KyXvvfeeUbNmTcPHx8eIjY011q1b53itTZs2Rp8+fZzGz5kzx4iKijJ8fHyMhg0bGt98800pR+xZipK/wYMHO8ZWqVLF6NSpk7FlyxY3RO0ZLt/2/MrH5Zz16dPHaNOmTb73NG3a1PDx8THq1KljJCcnl3rcnqKo+RszZoxRt25dw8/Pz6hQoYLRtm1bY9myZe4J3s0KyhvgdDzp/HdtxcmhzoF/6NevnxEREWH4+PgYlSpVMu69915HMWYYOv6k5KjOM0d1XvGpzjNHdZ45qvXMUZ1nTlmq8yyGYRglP49ORERERERERETk5qY13kRERERERERERFxAjTcREREREREREREXUONNRERERERERETEBdR4ExERERERERERcQE13kRERERERERERFxAjTcREREREREREREXUONNRERERERERETEBdR4ExFxs5SUFCwWC5s2bXJ3KCIiIiJSglTniYgabyJyU7hc9FztsW7dOneHKCIiIiLFoDpPRDyZt7sDEBEpTaNGjaJ27dr5tkdGRrohGhEREREpKarzRMQTqfEmIjeVjh070qJFC3eHISIiIiIlTHWeiHgiXWoqIvJfBw8exGKxMG7cOMaPH09ERAT+/v60adOGHTt25Bu/bNky7rrrLgIDAwkLC6Nbt27s2rUr37gjR46QmJhItWrV8PX1pXbt2gwYMICLFy86jbtw4QIvvPAClSpVIjAwkAceeIBffvnFZd9XRERE5GahOk9E3EUz3kTkpnL69GlOnjzptM1isVCxYkXH8xkzZnDmzBkGDhxITk4OEydOpF27dmRkZFClShUAlixZQseOHalTpw4jR47k/PnzvPfee7Ru3ZotW7ZQq1YtAI4ePUpsbCy///47/fv3p379+hw5coTPPvuM7OxsfHx8HPsdNGgQ5cuXZ8SIERw8eJAJEyaQlJTEp59+6vrEiIiIiJRxqvNExBOp8SYiN5X27dvn2+br60tOTo7j+b59+9i7dy/Vq1cHoEOHDrRs2ZIxY8bw7rvvAvDiiy9SoUIF0tLSqFChAgAJCQk0a9aMESNG8OGHHwLw8ssvc+zYMdavX+906cOoUaMwDMMpjooVK7Jo0SIsFgsANpuNSZMmcfr0aUJDQ0swCyIiIiI3HtV5IuKJ1HgTkZvKlClTiIqKctrm5eXl9DwhIcFRjAHExsbSsmVLFixYwLvvvktmZibp6ekMHTrUUYwBNG7cmPvuu48FCxYA9oJq/vz5dO3atcD1Ri4XXpf179/fadtdd93F+PHjOXToEI0bNy7+lxYRERG5CajOExFPpMabiNxUYmNjr7vobr169fJti4qKYs6cOQAcOnQIgOjo6HzjYmJiSE1N5dy5c5w9e5asrCxuu+22QsVWs2ZNp+fly5cH4NSpU4V6v4iIiMjNTHWeiHgi3VxBRMRDXPmL7GVXXqogIiIiImWL6jyRm5dmvImIXGHv3r35tv3www+OhXQjIiIA2LNnT75xu3fv5pZbbiEwMBB/f39CQkIKvFOWiIiIiJQ+1XkiUto0401E5Arz58/nyJEjjucbNmxg/fr1dOzYEYDw8HCaNm3Khx9+yO+//+4Yt2PHDhYtWkSnTp0AsFqtJCQk8J///IdNmzbl249+4RQREREpXarzRKS0acabiNxUvv32W3bv3p1ve6tWrbBa7b9FREZGcueddzJgwAAuXLjAhAkTqFixIkOHDnWMHzt2LB07diQuLo7ExETHbeZDQ0MZOXKkY9xbb73FokWLaNOmDf379ycmJobMzEzmzp3L6tWrCQsLc/VXFhEREbkpqM4TEU+kxpuI3FRee+21ArcnJyfTtm1bAHr37o3VamXChAmcOHGC2NhYJk+eTHh4uGN8+/btWbhwISNGjOC1116jXLlytGnThjFjxlC7dm3HuOrVq7N+/XpeffVVPv74Y7KysqhevTodO3YkICDApd9VRERE5GaiOk9EPJHF0BxYEREADh48SO3atRk7dixDhgxxdzgiIiIiUkJU54mIu2iNNxERERERERERERdQ401ERERERERERMQF1HgTERERERERERFxAa3xJiIiIiIiIiIi4gKa8SYiIiIiIiIiIuICaryJiIiIiIiIiIi4gBpvIiIiIiIiIiIiLqDGm4iIiIiIiIiIiAuo8SYiIiIiIiIiIuICaryJiIiIiIiIiIi4gBpvIiIiIiIiIiIiLqDGm4iIiIiIiIiIiAuo8SYiIiIiIiIiIuIC/wdfEMqNVoN3XQAAAABJRU5ErkJggg==\n" }, "metadata": {} } ] }, { "cell_type": "code", "source": [ "loss, acc, precision, recall, auc = model.evaluate(X_test, y_test, verbose=0)\n", "\n", "# Show the model performance\n", "print('Test loss :', loss)\n", "print('Test accuracy :', acc*100)\n", "print('Test precision :', precision*100)\n", "print('Test recall :', recall*100)\n", "print('Test AUC :', auc*100)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "L08GUPU3RQK0", "outputId": "e60f034e-6f00-499e-aaae-71c2c9d704bb" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Test loss : 0.07856446504592896\n", "Test accuracy : 97.57847785949707\n", "Test precision : 87.65432238578796\n", "Test recall : 95.30201554298401\n", "Test AUC : 98.94327521324158\n" ] } ] }, { "cell_type": "code", "source": [ "def decode_tokens(tokens):\n", " \"\"\"\n", " This function takes in a list of tokenized integers and returns the corresponding text based on the provided vocabulary.\n", "\n", " Args:\n", " - tokens: A list of integers representing tokenized text.\n", " - vocab: A list of words in the vocabulary corresponding to each integer index.\n", "\n", " Returns:\n", " - text: A string of decoded text.\n", " \"\"\"\n", " text = \" \".join(VOCAB[int(token)] for token in tokens).strip()\n", " return text" ], "metadata": { "id": "2S6Iaw7BRjui" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "for _ in range(10):\n", " # Randomly select a text from the testing data.\n", " index = np.random.randint(1,len(X_test))\n", " tokens = X_test[index-1:index]\n", " label = y_test[index]\n", "\n", " # Feed the tokens to the model\n", " print(f\"\\nModel Prediction\\n{'-'*100}\")\n", " proba = 1 if model.predict(tokens, verbose=0)[0][0]>0.5 else 0\n", " pred = label_encoder.inverse_transform([proba])\n", " print(f\"Message: '{decode_tokens(tokens[0])}' | Prediction: {pred[0].title()} | True : {label_encoder.inverse_transform([label])[0].title()}\\n\")" ], "metadata": { "id": "Oc7GR9-GRvpI", "outputId": "0459a1fd-16e7-40d4-8f28-cadd4e502ba4", "colab": { "base_uri": "https://localhost:8080/" } }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'well thats nice too bad i cant eat it' | Prediction: Ham | True : Ham\n", "\n", "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'so check your errors and if you had difficulties do correction' | Prediction: Ham | True : Ham\n", "\n", "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'in which place do you want da' | Prediction: Ham | True : Ham\n", "\n", "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'carlos is down but i have to pick it up from him so i ll swing by usf in a little bit' | Prediction: Ham | True : Ham\n", "\n", "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'how much did ur hdd casing cost' | Prediction: Ham | True : Ham\n", "\n", "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'its like that hotel dusk game i think you solve puzzles in a area thing' | Prediction: Ham | True : Ham\n", "\n", "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'dare i ask any luck with sorting out the car' | Prediction: Ham | True : Ham\n", "\n", "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'i m home doc gave me pain meds says everything is fine' | Prediction: Ham | True : Ham\n", "\n", "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'you could have seen me i did t recognise you face' | Prediction: Ham | True : Ham\n", "\n", "\n", "Model Prediction\n", "----------------------------------------------------------------------------------------------------\n", "Message: 'they said Ì dun haf passport or smth like dat or Ì juz send to my email account' | Prediction: Ham | True : Ham\n", "\n" ] } ] }, { "cell_type": "code", "source": [], "metadata": { "id": "73y-E0d_Rz-G" }, "execution_count": null, "outputs": [] } ] }