{ "cells": [ { "cell_type": "markdown", "source": [ "# Hybrid Quantum-Classical Model Exploration\n", "\n", "## Overview\n", "\n", "This notebook is inspired from https://opg.optica.org/viewmedia.cfm?r=1&rwjcode=opticaq&uri=opticaq-3-3-238&html=true and demonstrates a comparison between hybrid quantum-classical models and traditional linear models for image classification using the MNIST dataset. The implementation leverages the Merlin framework for quantum neural networks and PyTorch for classical neural networks.\n", "\n", "## Key Components\n", "\n", "### 1. Model Architectures\n", "\n", "#### QuantumReservoir Model\n", "The main hybrid architecture combines:\n", "- A quantum layer processing PCA-reduced image features\n", "- A linear classifier operating on the concatenation of the original flattened image and quantum output\n", "\n", "#### Linear Model\n", "A simple linear classifier operating directly on flattened image features, serving as a baseline for comparison.\n", "\n", "#### PCA Model\n", "A linear classifier operating on PCA-reduced features to evaluate the information content of the dimensionality reduction.\n", "\n", "### 2. Data Preparation\n", "\n", "- The MNIST dataset (Perceval Quest subset) is loaded using the custom `mnist_digits` module\n", "- Images are flattened and normalized\n", "- Principal Component Analysis (PCA) reduces feature dimensionality to a specified number of components\n", "\n" ], "metadata": { "collapsed": false }, "id": "8ac0256ea372550c" }, { "cell_type": "code", "source": [ "import torch\n", "import torch.nn as nn\n", "import numpy as np\n", "from sklearn.decomposition import PCA\n", "import matplotlib.pyplot as plt\n", "\n", "import merlin\n", "from merlin import Ansatz\n", "from merlin import PhotonicBackend as Experiment\n", "from merlin import CircuitType\n", "from merlin import AnsatzFactory\n", "from merlin import QuantumLayer\n", "from merlin import OutputMappingStrategy\n", "from merlin import StatePattern\n", "\n", "import perceval as pcvl # just to display the circuit" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:16.018152500Z", "start_time": "2025-06-09T12:54:11.868478700Z" } }, "id": "initial_id", "outputs": [], "execution_count": 1 }, { "cell_type": "code", "source": [ "# Simple Baseline Linear Model\n", "class LinearModelBaseline(nn.Module):\n", " def __init__(self, image_size, num_classes=10):\n", " super(LinearModelBaseline, self).__init__()\n", " self.image_size = image_size\n", "\n", " # Classical part\n", " self.classifier = nn.Linear(image_size, num_classes)\n", "\n", " def forward(self, x):\n", " # Data is already flattened\n", " output = self.classifier(x)\n", " return output" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:16.024698900Z", "start_time": "2025-06-09T12:54:16.024698900Z" } }, "id": "39b690b2911545ca", "outputs": [], "execution_count": 2 }, { "cell_type": "code", "source": [ "# LinearModel with PCA\n", "class LinearModelPCA(nn.Module):\n", " def __init__(self, image_size, pca_components, num_classes=10):\n", " super(LinearModelPCA, self).__init__()\n", " self.image_size = image_size\n", " self.pca_components = pca_components\n", "\n", " # Classical part\n", " self.classifier = nn.Linear(image_size + pca_components, num_classes)\n", "\n", " def forward(self, x, x_pca):\n", " # Data is already flattened, just concatenate\n", " combined_features = torch.cat((x, x_pca), dim=1)\n", " output = self.classifier(combined_features)\n", " return output" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:16.037167Z", "start_time": "2025-06-09T12:54:16.031423900Z" } }, "id": "cc71b21871b477fb", "outputs": [], "execution_count": 3 }, { "cell_type": "code", "source": [ "# definition of QuantumReservoir class - quantum layer applying on pca, and linear classifier on input and pca\n", "class QuantumReservoir(nn.Module):\n", " def __init__(self, image_size, pca_components, n_modes, n_photons, num_classes=10):\n", " super(QuantumReservoir, self).__init__()\n", " self.image_size = image_size\n", " self.pca_components = pca_components\n", " self.n_modes = n_modes\n", " self.n_photons = n_photons\n", "\n", " # Quantum part (non-trainable reservoir)\n", " self.quantum_layer = self._create_quantum_reservoir(\n", " pca_components, n_modes, n_photons\n", " )\n", "\n", " # Classical part\n", " self.classifier = nn.Linear(\n", " image_size + self.quantum_layer.output_size,\n", " num_classes\n", " )\n", "\n", " print(f\"\\nQuantum Reservoir Created:\")\n", " print(f\" Input size (PCA components): {pca_components}\")\n", " print(f\" Quantum output size: {self.quantum_layer.output_size}\")\n", " print(f\" Total features to classifier: {image_size + self.quantum_layer.output_size}\")\n", "\n", " def _create_quantum_reservoir(self, input_size, n_modes, n_photons):\n", " \"\"\"Create quantum layer with Series circuit in reservoir mode.\"\"\"\n", "\n", " # Create experiment with Series circuit\n", " experiment = Experiment(\n", " circuit_type=CircuitType.SERIES,\n", " n_modes=n_modes,\n", " n_photons=n_photons,\n", " reservoir_mode=True, # Non-trainable quantum layer\n", " use_bandwidth_tuning=False, # No bandwidth tuning\n", " state_pattern=StatePattern.PERIODIC\n", " )\n", "\n", " # Create ansatz with automatic output size\n", " ansatz = AnsatzFactory.create(\n", " PhotonicBackend=experiment,\n", " input_size=input_size,\n", " # output_size not specified - will be calculated automatically\n", " output_mapping_strategy=OutputMappingStrategy.NONE\n", " )\n", "\n", " # Create quantum layer\n", " quantum_layer = QuantumLayer(\n", " input_size=input_size,\n", " ansatz=ansatz,\n", " shots=10000, # Number of measurement shots\n", " no_bunching=False\n", " )\n", "\n", " return quantum_layer\n", "\n", " def forward(self, x, x_pca):\n", " # Process the PCA-reduced input through quantum layer\n", " quantum_output = self.quantum_layer(x_pca)\n", "\n", " # Concatenate original image features with quantum output\n", " combined_features = torch.cat((x, quantum_output), dim=1)\n", "\n", " # Final classification\n", " output = self.classifier(combined_features)\n", " return output\n" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:16.134740600Z", "start_time": "2025-06-09T12:54:16.127746Z" } }, "id": "ba47d39e327808c2", "outputs": [], "execution_count": 4 }, { "cell_type": "code", "id": "6928fd1cde89fbc6", "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:23.085602300Z", "start_time": "2025-06-09T12:54:16.134740600Z" } }, "source": [ "from merlin.datasets import mnist_digits\n", "\n", "train_features, train_labels, train_metadata = mnist_digits.get_data_train_percevalquest()\n", "test_features, test_labels, test_metadata = mnist_digits.get_data_test_percevalquest()\n", "\n", "# Flatten the images from (N, 28, 28) to (N, 784)\n", "train_features = train_features.reshape(train_features.shape[0], -1)\n", "test_features = test_features.reshape(test_features.shape[0], -1)\n", "\n", "# Convert data to PyTorch tensors\n", "X_train = torch.FloatTensor(train_features)\n", "y_train = torch.LongTensor(train_labels)\n", "X_test = torch.FloatTensor(test_features)\n", "y_test = torch.LongTensor(test_labels)\n", "\n", "print(f\"Dataset loaded: {len(X_train)} training samples, {len(X_test)} test samples\")\n" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset loaded: 6000 training samples, 600 test samples\n" ] } ], "execution_count": 5 }, { "cell_type": "code", "id": "e728d045e4a9fc01", "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:23.090625700Z", "start_time": "2025-06-09T12:54:23.090111700Z" } }, "source": [ "n_components=8\n", "M=9\n", "N=4" ], "outputs": [], "execution_count": 6 }, { "cell_type": "code", "id": "db12a382b7c88334", "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:23.328179400Z", "start_time": "2025-06-09T12:54:23.093991100Z" } }, "source": [ "# train PCA\n", "from sklearn.decomposition import PCA\n", "pca = PCA(n_components=n_components)\n", "\n", "# Note: Data is already flattened\n", "X_train_flat = X_train\n", "X_test_flat = X_test\n", "\n", "pca.fit(X_train_flat)\n", "X_train_pca = torch.FloatTensor(pca.transform(X_train_flat))\n", "X_test_pca = torch.FloatTensor(pca.transform(X_test_flat))\n", "print(X_train_pca)" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor([[ 1.8300, 0.5721, 0.0553, ..., -0.9327, 1.7091, -1.0749],\n", " [ 0.8860, -4.1798, 1.3963, ..., 0.1214, -0.9330, 0.1368],\n", " [-0.2782, 1.7010, 0.4974, ..., -0.4593, -1.0291, 1.7501],\n", " ...,\n", " [ 0.2924, -4.0464, -1.2219, ..., -0.9095, 0.9783, 0.8630],\n", " [ 0.1567, 1.2983, -4.0294, ..., -3.1340, -2.1575, 0.3926],\n", " [ 4.4576, 1.2257, 0.7489, ..., -0.9504, -1.7016, -1.8599]])\n" ] } ], "execution_count": 7 }, { "cell_type": "code", "id": "c236b83743b27024", "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:23.334301800Z", "start_time": "2025-06-09T12:54:23.329928200Z" } }, "source": [ "# define corresponding linear model for comparison\n", "linear_model = LinearModelBaseline(X_train_flat.shape[1])" ], "outputs": [], "execution_count": 8 }, { "cell_type": "code", "source": [ "# define model using pca featues\n", "pca_model = LinearModelPCA(X_train_flat.shape[1], n_components)" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:23.378182200Z", "start_time": "2025-06-09T12:54:23.336302Z" } }, "id": "5716b4ce63a88f1a", "outputs": [], "execution_count": 9 }, { "cell_type": "code", "source": [ "# define hybrid model\n", "hybrid_model = QuantumReservoir(X_train_flat.shape[1], n_components, n_modes=M, n_photons=N)\n", "pcvl.pdisplay(hybrid_model.quantum_layer.ansatz.circuit)" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:54:23.487616700Z", "start_time": "2025-06-09T12:54:23.350225500Z" } }, "id": "6adabc63f0d2bfe1", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Quantum Reservoir Created:\n", " Input size (PCA components): 8\n", " Quantum output size: 495\n", " Total features to classifier: 1279\n" ] }, { "data": { "text/plain": "", "image/svg+xml": "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCPLX\n\n\nΦ=pl0x\n\n\nΦ=pl1x\n\n\nΦ=pl2x\n\n\nΦ=pl3x\n\n\nΦ=pl4x\n\n\nΦ=pl5x\n\n\nΦ=pl6x\n\n\nΦ=pl7x\n\n\n\n\n\n\n\n\n\n\n\nCPLX\n\n\n\n\n\n\n\n\n\n0\n1\n2\n3\n4\n5\n6\n7\n8\n0\n1\n2\n3\n4\n5\n6\n7\n8\n" }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "execution_count": 10 }, { "cell_type": "code", "id": "c0241462cf6e3ae5", "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:56:07.564072900Z", "start_time": "2025-06-09T12:54:23.498849800Z" } }, "source": [ "# Loss function and optimizer\n", "criterion = nn.CrossEntropyLoss()\n", "optimizer_linear = torch.optim.Adam(linear_model.parameters(), lr=0.001)\n", "optimizer_pca = torch.optim.Adam(pca_model.parameters(), lr=0.001)\n", "optimizer_hybrid = torch.optim.Adam(hybrid_model.parameters(), lr=0.001)\n", "\n", "# Create DataLoader for batching\n", "batch_size = 128\n", "train_dataset = torch.utils.data.TensorDataset(X_train, X_train_pca, y_train)\n", "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n", "\n", "# Training loop\n", "num_epochs = 25\n", "\n", "history = {\n", " 'hybrid': {'loss': [], 'accuracy': []},\n", " 'pca': {'loss': [], 'accuracy': []},\n", " 'linear': {'loss': [], 'accuracy': []},\n", " 'epochs': []\n", "}\n", "\n", "for epoch in range(num_epochs):\n", " running_loss_hybrid = 0.0\n", " running_loss_linear = 0.0\n", " running_loss_pca = 0.0\n", " \n", " hybrid_model.train()\n", " linear_model.train()\n", " pca_model.train()\n", " \n", " for i, (images, pca_features, labels) in enumerate(train_loader):\n", " # Hybrid model - Forward and Backward pass\n", " outputs = hybrid_model(images, pca_features)\n", " loss = criterion(outputs, labels)\n", " optimizer_hybrid.zero_grad()\n", " loss.backward()\n", " optimizer_hybrid.step()\n", " running_loss_hybrid += loss.item()\n", "\n", " # Comparative linear model - Forward and Backward pass\n", " outputs = linear_model(images)\n", " loss = criterion(outputs, labels)\n", " optimizer_linear.zero_grad()\n", " loss.backward()\n", " optimizer_linear.step()\n", " running_loss_linear += loss.item()\n", "\n", " # Comparative pca model - Forward and Backward pass\n", " outputs = pca_model(images, pca_features)\n", " loss = criterion(outputs, labels)\n", " optimizer_pca.zero_grad()\n", " loss.backward()\n", " optimizer_pca.step()\n", " running_loss_pca += loss.item()\n", "\n", " avg_loss_hybrid = running_loss_hybrid/len(train_loader)\n", " avg_loss_linear = running_loss_linear/len(train_loader)\n", " avg_loss_pca = running_loss_pca/len(train_loader)\n", "\n", " history['hybrid']['loss'].append(avg_loss_hybrid)\n", " history['linear']['loss'].append(avg_loss_linear)\n", " history['pca']['loss'].append(avg_loss_pca)\n", "\n", " history['epochs'].append(epoch + 1)\n", "\n", " hybrid_model.eval()\n", " linear_model.eval()\n", " pca_model.eval()\n", " with torch.no_grad():\n", " outputs = hybrid_model(X_test, X_test_pca)\n", " _, predicted = torch.max(outputs, 1)\n", " hybrid_accuracy = (predicted == y_test).sum().item() / y_test.size(0)\n", " \n", " outputs = linear_model(X_test)\n", " _, predicted = torch.max(outputs, 1)\n", " linear_accuracy = (predicted == y_test).sum().item() / y_test.size(0)\n", "\n", " outputs = pca_model(X_test, X_test_pca)\n", " _, predicted = torch.max(outputs, 1)\n", " pca_accuracy = (predicted == y_test).sum().item() / y_test.size(0)\n", " \n", " history['hybrid']['accuracy'].append(hybrid_accuracy)\n", " history['linear']['accuracy'].append(linear_accuracy)\n", " history['pca']['accuracy'].append(pca_accuracy)\n", "\n", " print(f'Epoch [{epoch+1}/{num_epochs}], LOSS -- Hybrid: {avg_loss_hybrid:.4f}, Linear: {avg_loss_linear:.4f}, PCA: {avg_loss_pca:.4f}'+\n", " f', ACCURACY -- Hybrid: {hybrid_accuracy:.4f}, Linear: {linear_accuracy:.4f}, PCA: {pca_accuracy:.4f}')" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch [1/25], LOSS -- Hybrid: 1.6186, Linear: 1.6428, PCA: 1.5413, ACCURACY -- Hybrid: 0.8067, Linear: 0.7933, PCA: 0.8100\n", "Epoch [2/25], LOSS -- Hybrid: 0.9110, Linear: 0.9272, PCA: 0.8344, ACCURACY -- Hybrid: 0.8350, Linear: 0.8250, PCA: 0.8383\n", "Epoch [3/25], LOSS -- Hybrid: 0.6787, Linear: 0.6900, PCA: 0.6258, ACCURACY -- Hybrid: 0.8500, Linear: 0.8567, PCA: 0.8583\n", "Epoch [4/25], LOSS -- Hybrid: 0.5694, Linear: 0.5785, PCA: 0.5287, ACCURACY -- Hybrid: 0.8650, Linear: 0.8633, PCA: 0.8717\n", "Epoch [5/25], LOSS -- Hybrid: 0.5032, Linear: 0.5112, PCA: 0.4697, ACCURACY -- Hybrid: 0.8783, Linear: 0.8750, PCA: 0.8750\n", "Epoch [6/25], LOSS -- Hybrid: 0.4586, Linear: 0.4658, PCA: 0.4298, ACCURACY -- Hybrid: 0.8850, Linear: 0.8867, PCA: 0.8883\n", "Epoch [7/25], LOSS -- Hybrid: 0.4252, Linear: 0.4318, PCA: 0.3999, ACCURACY -- Hybrid: 0.8917, Linear: 0.8833, PCA: 0.8933\n", "Epoch [8/25], LOSS -- Hybrid: 0.3996, Linear: 0.4059, PCA: 0.3768, ACCURACY -- Hybrid: 0.8933, Linear: 0.8900, PCA: 0.8983\n", "Epoch [9/25], LOSS -- Hybrid: 0.3787, Linear: 0.3846, PCA: 0.3581, ACCURACY -- Hybrid: 0.8983, Linear: 0.8900, PCA: 0.9067\n", "Epoch [10/25], LOSS -- Hybrid: 0.3619, Linear: 0.3677, PCA: 0.3430, ACCURACY -- Hybrid: 0.9083, Linear: 0.9033, PCA: 0.9100\n", "Epoch [11/25], LOSS -- Hybrid: 0.3474, Linear: 0.3529, PCA: 0.3300, ACCURACY -- Hybrid: 0.9050, Linear: 0.9017, PCA: 0.9083\n", "Epoch [12/25], LOSS -- Hybrid: 0.3345, Linear: 0.3399, PCA: 0.3184, ACCURACY -- Hybrid: 0.9067, Linear: 0.8983, PCA: 0.9033\n", "Epoch [13/25], LOSS -- Hybrid: 0.3240, Linear: 0.3293, PCA: 0.3088, ACCURACY -- Hybrid: 0.9133, Linear: 0.9050, PCA: 0.9067\n", "Epoch [14/25], LOSS -- Hybrid: 0.3146, Linear: 0.3199, PCA: 0.3002, ACCURACY -- Hybrid: 0.9083, Linear: 0.9083, PCA: 0.9083\n", "Epoch [15/25], LOSS -- Hybrid: 0.3052, Linear: 0.3104, PCA: 0.2919, ACCURACY -- Hybrid: 0.9150, Linear: 0.9083, PCA: 0.9117\n", "Epoch [16/25], LOSS -- Hybrid: 0.2975, Linear: 0.3026, PCA: 0.2848, ACCURACY -- Hybrid: 0.9133, Linear: 0.9100, PCA: 0.9150\n", "Epoch [17/25], LOSS -- Hybrid: 0.2901, Linear: 0.2953, PCA: 0.2781, ACCURACY -- Hybrid: 0.9133, Linear: 0.9133, PCA: 0.9100\n", "Epoch [18/25], LOSS -- Hybrid: 0.2841, Linear: 0.2892, PCA: 0.2727, ACCURACY -- Hybrid: 0.9183, Linear: 0.9183, PCA: 0.9117\n", "Epoch [19/25], LOSS -- Hybrid: 0.2779, Linear: 0.2830, PCA: 0.2671, ACCURACY -- Hybrid: 0.9150, Linear: 0.9167, PCA: 0.9150\n", "Epoch [20/25], LOSS -- Hybrid: 0.2725, Linear: 0.2775, PCA: 0.2621, ACCURACY -- Hybrid: 0.9183, Linear: 0.9217, PCA: 0.9117\n", "Epoch [21/25], LOSS -- Hybrid: 0.2666, Linear: 0.2717, PCA: 0.2566, ACCURACY -- Hybrid: 0.9217, Linear: 0.9167, PCA: 0.9217\n", "Epoch [22/25], LOSS -- Hybrid: 0.2619, Linear: 0.2671, PCA: 0.2525, ACCURACY -- Hybrid: 0.9200, Linear: 0.9150, PCA: 0.9167\n", "Epoch [23/25], LOSS -- Hybrid: 0.2577, Linear: 0.2629, PCA: 0.2486, ACCURACY -- Hybrid: 0.9217, Linear: 0.9217, PCA: 0.9183\n", "Epoch [24/25], LOSS -- Hybrid: 0.2527, Linear: 0.2579, PCA: 0.2440, ACCURACY -- Hybrid: 0.9217, Linear: 0.9167, PCA: 0.9167\n", "Epoch [25/25], LOSS -- Hybrid: 0.2491, Linear: 0.2543, PCA: 0.2409, ACCURACY -- Hybrid: 0.9233, Linear: 0.9233, PCA: 0.9183\n" ] } ], "execution_count": 11 }, { "cell_type": "code", "id": "eef9c34d373396c2", "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2025-06-09T12:56:08.216094700Z", "start_time": "2025-06-09T12:56:07.569072700Z" } }, "source": [ "import matplotlib.pyplot as plt\n", "def plot_training_comparison(history):\n", " # Create a figure with two subplots side by side\n", " fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 6))\n", " \n", " # Define colors and styles for consistency\n", " model_styles = {\n", " 'hybrid': {'color': 'blue', 'linestyle': '-', 'marker': 'o'},\n", " 'pca': {'color': 'green', 'linestyle': '-', 'marker': 's'},\n", " 'linear': {'color': 'red', 'linestyle': '-', 'marker': '^'}\n", " }\n", "\n", " # Plot loss curves\n", " for model_name, style in model_styles.items():\n", " if model_name in history:\n", " ax1.plot(\n", " history['epochs'],\n", " history[model_name]['loss'],\n", " color=style['color'],\n", " linestyle=style['linestyle'],\n", " marker=style['marker'],\n", " markevery=max(1, len(history['epochs'])//10), # Show markers at 10 points\n", " label=f'{model_name.capitalize()} Model'\n", " )\n", " \n", " ax1.set_title('Training Loss Comparison', fontsize=14)\n", " ax1.set_xlabel('Epochs', fontsize=12)\n", " ax1.set_ylabel('Loss', fontsize=12)\n", " ax1.legend(fontsize=12)\n", " ax1.grid(True, alpha=0.3)\n", "\n", " # Plot accuracy curves\n", " for model_name, style in model_styles.items():\n", " if model_name in history:\n", " ax2.plot(\n", " history['epochs'],\n", " history[model_name]['accuracy'],\n", " color=style['color'],\n", " linestyle=style['linestyle'],\n", " marker=style['marker'],\n", " markevery=max(1, len(history['epochs'])//10), # Show markers at 10 points\n", " label=f'{model_name.capitalize()} Model'\n", " )\n", " \n", " ax2.set_title('Training Accuracy Comparison', fontsize=14)\n", " ax2.set_xlabel('Epochs', fontsize=12)\n", " ax2.set_ylabel('Accuracy', fontsize=12)\n", " ax2.legend(fontsize=12)\n", " ax2.grid(True, alpha=0.3)\n", " \n", " plt.tight_layout()\n", " plt.show()\n", "\n", "# Call the function to generate the plot\n", "plot_training_comparison(history)\n" ], "outputs": [ { "data": { "text/plain": "
", "image/png": "iVBORw0KGgoAAAANSUhEUgAABv4AAAJOCAYAAAB/dnBOAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd4FFUXBuAvCb33XhN6L1IUkF5/kKo06dIUQQGpgoIC0qsoKB0UEVEBEQERREV6lxp6772m/M93hwmbkEASkuwm+V6fecLOTnZnd2fi3jn3nOPm7+/vDxERERERERERERERERGJ1tydvQMiIiIiIiIiIiIiIiIi8uIU+BMRERERERERERERERGJART4ExEREREREREREREREYkBFPgTERERERERERERERERiQEU+BMRERERERERERERERGJART4ExEREREREREREREREYkBFPgTERERERERERERERERiQEU+BMRERERERERERERERGJART4ExEREREREREREREREYkBFPgTEXExkydPRt68eUO19OvXL0Ke8/Tp0+bxevfuHa7fr1KlCl599VU4w5IlS8y+832Lrnx9fbF8+XJ07NgRFStWRKFChVCuXDl069YNmzdvRmw8/v/55x9n74qIiIiISIg0bgu/Nm3amNfx/vvvO3tXYoT79+/ju+++Q6tWrVC+fHkznuS4ksfJgQMHEJvwXOOxdeLECWfvioiIU8Vx7tOLiEhQ1atXR7Zs2QKtGzFiBK5du4ZRo0YFWh90u/BKlSqVeeysWbOG6/cHDBgAf3//CNmX2ObixYvo2bMntmzZgpdeegnNmjVD6tSpcfLkSRPUXL16Nfr374+2bdsiNh3/uXPndvauiIiIiIiESOO28AcvN23ahESJEpmxzpUrV8z4R8Ln6NGj6NGjBw4fPoxKlSqZoGqyZMnM7R9//BG//vorxowZg9q1ayM2aNq0KV5++WWkSZPG2bsiIuJUbv7O/j++iIiEambmmTNncPDgQWfvisthcIyBMWbHvfvuu4hOfHx88Oabb2L37t3mIkH9+vUD3X/z5k20bNkShw4dwvTp082sTRERERERcU0atz3fpEmT8Pnnn+O9997DhAkT0KtXL3Tq1MnZuxUt3b59Gw0bNsSlS5cwdepUvPLKK4HuP3v2rJlYyuDqDz/8gHz58jltX0VEJGqp1KeIiIiTcPC1Y8cOtG7d+qmgH3Gm5pAhQ8y/58yZ44Q9FBERERERiRh+fn746aefkDZtWpOZljBhQlOikusl7Dg5lJViGDwNGvSjTJky4YMPPjATThcsWOCUfRQREedQ4E9EJIb0lli7di3q1Klj6vk3b97c3Mek7kWLFqFFixamjGTBggVNzX+WlnSseR9crwj2B6hVq5aZrcoZmCVLlkTx4sVNycldu3Y9s1eEvU8sLzJ48GDTr65w4cJ47bXXzEAvKG9vb3Tv3h1ly5Y1z8Fed1xXoECBCOuHYTt//jw+/PBDs798r/iTt7ne0b1790wWHt+DIkWKoEyZMujcuTO2bdsWaLtTp06Z2aqVK1cO6KXADETOrnwe+73gex2SEiVKYNmyZfj6668Dref7w8+RAzw+b9WqVfHZZ5/hxo0bT3023O+///7bzPYsWrSo+Z1hw4bh4cOHpsyOvZ6vgWVgHj16FPD7fP/5OfB18jjg58PPic/NdUH99ttvaN++vXm/eLzxZ5cuXbB3795A2/H4GDRoED755BMUK1YMpUuXxqpVq4Lt8ffff/+Zx6hQoULAa/30009x/fr1p3pbTJkyxXxm3I6Pyd/buXNnoO3CenyKiIiIiLwojduAjRs3moxIPg9LfbI0JV/Thg0bgt2emWocL3C/OSarVq2aKXV669atQNvt27fP7BdLPHK/OKnym2++CShr+qzeiFzH+7gNcXzE2/PmzTPjGnvMeO7cuYDX0LVrVzOm4udUqlQpE8QMrkf5s/aLC18Pf5/jsqA4juE4iVl9weHvL126FAkSJMAbb7wR4nvOEp8rVqww76MjjpH4HBwz8TXyGOJY6sGDB4G243sxdOhQ05Oe+8/jg2NeZhhyH1auXIkGDRqYz4flb2fMmBHo93l8cj3fC1az4biTxzaPt6tXrz71msJyHjB7lH0iuU/8PHi8B9fjj58ZPyN+DtyW7wmzTTl+dMSxNMfUHG/yPeH2fG4e4474HHwcHst8fo55+fpZZnT9+vUhfhYiIlFJPf5ERGIIDlgaN25svkzHjRvXrGNwhwMWftHmF1Z+kWbgil/8mWnGQIu9bXD4RZylKDnQ4UxBfsGePXu2GUSuW7cOyZMnf+Y+MeCULl0685ODGWat9e3b16yzZyTySzQDT5yFyEEBa/Fz8MAv+xE985PPxfeHgycOjthHjgPkxYsX4/fffzeDsJw5c5pt+X4xWMbtPT09cfnyZTNLkgMGbs8yKSzFyWw97icH7exNwUEzH4cDRr7PHIgFh5/Fnj17kDFjRmTOnPmZ+50nT55At7du3YoOHTrAw8PDPC9/nwM3fja8kLBw4ULT/8MxcMZSqHyfOShjIHHu3Lk4fvw4tm/fbgYoLBHz888/46uvvjKZho7ldrivfJ0ZMmQwAxsOcPhecADF98Lefz4/g6Uc+PD5eGwx4MeLBps3b8aaNWsC7RcHj3z9ffr0MUFEDnqDlkXier7nnBXcrl07JE2a1Azo5s+fb0qkcoawm5ubCdRyO97HATSPJX5mfC/4GQbX1yI0x6eIiIiISESKzeM2VjwhBj7pf//7n+lBx+/sQdsasHxlo0aNzGtr0qQJ8ufPjwMHDpjXxfeE4xm+Jwy4ceySJEkSs3/p06c3YyJWTuG4he9HeIwbN86MTzhZkUE/jls4yZH99Bjo5HMmTpzYjP++//57EwTluMfuVR6a/eIYjMGrP/74AzVr1gwU8GQwtG7duub3Q+oVz/1igCx+/Pghvo44ceLAy8sr0DoeV8wS5NiMxw3HsX/99ZcJBPN5+fk7jmO53xy7cVuOo/l5TZw40YzH+FnY67/99lsTmOV7ZX/GxAmbHKsxKM2x3/79+02A799//zWtO+zXGNbzYNasWSbIx4m8HNvycwmK42R+NryPAVu+Vxznf/HFF+Z3GAAkjh05tub40w5k8jzia+Lr50Rcvtc2HvM89vn8DO7yNXJ/+Bx8r3gNQUTEqdjjT0REXFvlypX98+TJE+x9kyZNMvd98MEHgdZfvXrVv0CBAv6dO3d+6ne6d+9ufmf37t3m9qlTp8ztXr16BWzz5ptvmnVffPFFoN+dPHmyWf/dd98F2r8KFSo8tU/t27f39/PzC1i/adMms75nz54B6zp16uSfN29e/127dgWs8/Hx8X/rrbfMtn379n3me/PDDz+Y7ficz9O6dWuz7T///BNo/fr16816vma6cuWKuf3RRx8F2m779u3+NWrU8F+0aJG5/euvv5rtfvnll0DbzZw5079evXr+e/bsCXFf7Od4/fXX/cPC19fXv3r16v6FChXyP3LkSKD7vvnmG/OY/fr1e+rYWbZsWaDnzpcvn1m/evXqgPU3btzwz58/v3/z5s0D1vH953YdOnQwn4uNv8f1vXv3Nrd5X5kyZfzr168faDsaOXKk2Zbvl423uZw8eTLQtvax8/fff5vbX3/9tbnteHzQ8OHD/Rs2bOh//vx5c3vKlClmuwkTJgTajveXLl3av2TJkv43b94M8/EpIiIiIhJaGreF7Pr16/6FCxc2380fPnxo1j148MB8T+cY5Ny5c4G279+/v3lcjtWCe132OKZatWrmMe1xAfG1cOxXsGBBM/YJ7n2zcR3v4zb077//mttVqlR5alzToEED/3LlyvnfuXMn0Pr58+eb3+HYxRaa/Tp79qwZl3Xp0iXQ482aNcs8HvclJPwcuM17773nHxa3bt3yf+mll8zY7fLly4HuGz16tHlMvsdBx20cC9v27dtn1nHf9+7dG7D+4MGDgcaIjsfnhx9+GOi5Zs+ebdaPHz8+3OdBsWLFzOtxZI9fjx8/bm4PGTLE3A76WvmYTZs2Nceg4/H2/fffB9pu//795vPi52kfD/ZzBH1NS5YsMevHjRsXwrsvIhJ1VOpTRCSGCJqhlDJlSpMZxkwnR8xSYy8FCqlsiCOWeXHEkhf2DMznqVevnsnGCvq7nE1HLNHCmYUs9cIZdTZmsnGmXETiTFFm4bGUCUt2OOLMWK5nVhpnV3LGITPLOKOTszft18ryLFz3+uuvm9ucyUic/ceMwbt375rbzExj2RX79QaHr5F8fX3D9DqYvceyJZz9GXTmJmeSMvuO++j4uJwVWaNGjYDbnNnJhbMdWcbExkw/rr9w4cJTz8sMPnufiVl1fH6+bj4X7/vzzz/N7FDH7fie2LMygx5vWbJkQdasWZ/5eu33ePz48WbWrF0Gh+VUOTuUM2eJs405K5WzlB3xfs5A5bEWtITQ845PEREREZGIFlvHbcyCYhlJZrbZ44N48eKZ7C6OJ1jJw8ZMr9WrV5vKJ46lSYlZjD/++KPZF46N2OOOYyN7XEB8LSzZyIomHOOEB8eHjuMa4tiQ4zyWKbVxfOLu7h7ocwrtfnGsw+OB45Rr164FbMfXx7ES9+FZmXzhGU8y243Hlp3p5+idd94xYypm2AXtFcixsM0eh2bLls2U47TlyJHD/AxuPMmsOEfMluOYm1l84T0PWG4zpIxIG6vWEFtFMHvQfr+YscjMRR6DzN7jfnBsymxcR6z0w8+RnyfLlUbUOSciEtlU6lNEJIYI+qWdGNhhWQoGZ1jGgiVF+CXcHtTZPQ+ehSVcHPGLMYWmnMvzfpdfnlkqxi6v6ShXrlyISCzTwddrl14JiusZ+ON27DvAARmDSywbQhx0sr8AB8V2CRFux4Eum6q//fbbZgDLdRycsjyI4yAvKJbb4aAqrIMCvmchvT/8XPk6WM6HA0f7/eeg0n7vbRzE8phxHOATB63BHRdBy40Sy5ew5A+DpSwDxOfgYIrleo4dO2aON5afsR8v6OMGPT6CwwsDHHwxyMfAH98zlohhKSC+x3bZIr4vHKgFV1rV/sztvh0RcWyLiIiIiIRHbB232WU+2cPc8Xs5v9vzuz5bCDDwxIAWyyYy4BN0wiYx0GOPx+ye48GVVbQnEIZXcGMV7ht7ubO/HcdB/Jz4Wuz3yf4Zlv1iGVMGVX/55RcTjGM5Uy7vvvvuU2M1R/ZYMyLHkwywcUxlbxPSe2EHRNmOwZEdAA16vDKoF3Rbjp35XEeOHAn3eRCa8STL0trlQrkw2MgSruwbyYAeXzPHzgxu81gM7j13HE86Br41nhQRV6bAn4hIDBF0NiJnHrIPHINZnAnHmXiss89BEhtOT5s2LVSPa395D4/n/e6jR4/Mz+D6VYTUGy+8njdYtmf+2V/WmdHGWaScfcmBGLMFZ86caer2DxgwwPS8o/fee8/052CwjbMn+X5zpuKXX35ptmVD9pBwwMHH58DwWZlvDCoywDVw4MDnvs6gr8NxNmhQzxpIBt0uuMfg4N/x8dkngjN5OYjk6+ZgijMkGQRkL4vwHFs8rocPH27eA/a+YPBvy5Yt5r3mMcxZmpxp+qzP1x54BQ1+vsixLSIiIiISHrFx3MZAlp0txd6BIfWsY9CHlUrsccbzxiv2di8ipIy54N6TsWPHmkmfzMZjvzcGJtnjjfvB8Up49osVWFKkSGGyABn4Y7YfXzf7/z0vgMzAInuq379/P8TPgfvCsSt7JHJSa2jGxUHHTS86ngz6eI77Zj92eM6D0BzzDOzxdxlg5HiSfQXZq57HGvvbs9dgWK8VhOX5RUScRYE/EZEYillX/NLML89soO2IgwlXkD17djNYYGAoqKNHj0boc9mBNTZfDw4HAtwXzpxkCZGDBw+aAR0HnnaZTDYh56Dp888/Nz85u5KPx0Efy39y4aCBgzYOaBkoZLP2kHCGIQN/8+fPN9mFweFAjjMeObuWs1vt1+E4M9LG5+b7xu3CW9ImOHxczvoMOiuUnxtnb9plWRj0q127tinL6TgIZEP18OIsTz43B9WcrcmFA0QO0tiInc3W+V4z+McAanCDXvszZ4kaERERERFXEhvGbczmo0aNGgVqNWBjYIcBGE7q49iL7QdYTjO452MLh48//thUBuF4jYLbjsEdZhmyDYOdZWm3DXAU2jL/zPTjGIQZi2xv4BgEYvlPR6HdLwa3+DisKjNv3jwz9mHJybJly5oWDs/zv//9D5MnTzbvnT0xNSiOJZnxxgAYP0OOm0IaT967d8/sAz/viMRx8507d5A4ceKAdfwsmEFnZ5FG1nnAz4AVajhm53i2Y8eOpuQsJ5fyeOMYlmVHOYbme8Kxb9CApv1evWgWqYhIVNLUBBGRGMruERC0RCP7w7EHXETNkHwRDBgxoMOMOseAHL9sM2gWkTh4tPv4cbDliM/PwBXv53YM+vHLP0u4BC3xwdIg9qxEDmA5YFuzZk3ANhwk2Fl+QWfzBsWeABzsMfAXdLBoD5B69uxp/m3/5IxHBv+WLVtmyss44oCPAzXHfn4RhX0MHbFMCsuvcLDJ18xyPPZ75DhQ4sDcHuiH53j74osvTB+PXbt2Bazj+2+XWLHfYw78GfQLOhOU7+E333xjBpks1SoiIiIi4kpi+riNAR6OXfi9vUePHqayStDl/fffN2UeWd2Dr5vbsnoIx2VBx24cW/B94ZiDYykGY1gmM2gAj/vF9Swxyf1ntiIzDx0z/DieCe0kxRs3bpjXy0CVY9CPwTIG7ch+7NDul2O5T+KkUQYYGSANjfbt25sedpwQGfR9Io4XP/roIzN+4ntPrGrDIBfHoAyIBR172X0YIxIrsMyYMSPQutmzZ5t+8JwMG5nnwdChQ814ku+rjcea3ZuQxxoz99hrkoFIuySt7dChQ2bsyzG4XWJWRCQ6UMafiEgMVaFCBVOKhL3qGAxiDzYO0vhF1v7CzDr2zsZMt2bNmpmFpU04AOKsxO3bt4epfAjLdoTU34BlUtiMnIMeBvQ4y69p06Zmxh/fEwbMWF6F9xNncbLJOmcAsrcEA4IcxHEWIt9LuzwNM/yYccYSnBwwMujFAQsb03Ngyey0Z+EAg9mD3J8PPvjANItn7zp7tiF7XXAwxHKidjCPAxM2Ju/UqZN5/ubNm5sZpXx+ZhpyZmjv3r0R0TjYYXCPxxVnTfJ1c7ao3aSd7xnfQ86CZQCO99kDJ/s4C8/xxkEan5uvl8cIXyv7PDCYxyDsG2+8YbbjzFAeAwzW8jPlhQkOZPkZ8nlHjRplZg2LiIiIiLiSmD5u4zYcRzDAxyBVcDj5kpMiOR7i93eOtzimYbsFjpX4nBxrsVwo3xe+ZwxOcWzElgLsDcj+39yOj8XnZJCS4yi+n8TKJJxs+dZbb5l/22MKBnSCTqgMDseOzIT76aefzLiCJT5ZnpTZaPY4lGNHYqAttPtFbI/AQBQfm2PB0E7k5H6w9CjfIwYBOZZktiDHov/9958ZHxLHj/bESY6hOO7le8z3nONiZkSylQL3j/vB9yiiMfDHCi0cl+/evdu8b0WLFjXHUmSeB507dzaTf3kdgGNHHrcM+PKzZ3CW5UTtthXcjuVQOSmY+8bxLLez20+E9tqEiIgrUOBPRCSG8vLyMoMAzhq0Z2Hyiy2/WNeqVcsMQFhmkhlbzsQZffwyPW7cODNTkrMoy5QpY8pFdu3aNdg+EsHhINDuGxEUM/A4wOBgjcE0Bts4a5ABOn7x5wxLPpfdIJ1f6Fkyhe8bg33s32cPyMaMGWNKsdjNvBcsWGCCTcz6YzCMgy82Bef+Ozb+Dgk/E+4HB3mcCcuZjwweMojGDDUGvhhUc8TBHIOVfF4OhFialGUsOdjr0qVLhJb5dJz9yay/kSNHmn6DHCCy4Tz/TRzI8v3i58h948xevp8ckDMrksccjzcG8MKCnxnfYz4/3yMG8/jeMLDHgbRdqobvO2et8pi3PzMOavlZcOD6rF6LIiIiIiLOEtPHbXYGFQMvz8JxD7P5GBBiBiDfA/4ux2UrV640YyZOAmQvPU76syt/MNhlj8k4luKETb6nDCLZ2WTEYBfHLnws9gxn5h6DXxxfcJLg8/D1cTzE8SAnJjJIyeAUS0hyXMK+7wye2aUiQ7tfNo5JOZ7l5xyWfvcMQDLAx/3hGJcVUBgg41iVz8P3ikFTRwz48f3lcTd37lwzduO4igFJjimZERfReMwwAMn3n2Nwjlt53NjZk5F1HnDsPGvWLDNBlccvg9B8bzim5+dmj2e5Tzz++Hmx/x9LgHLcyYA195X7JyISnbj5P6+DqYiISCTi7Eh+8Q46e44zR5nN1q1bNxNgEufo16+fGXyz10RE93oQEREREZHoQeO2yMVJpOxdyABeaCaQRhesgsNMOgY17ZYZIiIS+dTjT0REnIpNyDmDz7HXAtk975SpJSIiIiIi4lwat0UeZtwxG41lNmNS0E9ERJxHUy1ERMSpGjdujNGjR6NNmzam1wL73rGXA8s1Vq5c2ZS7FBEREREREefRuC3iMVuS5UAPHTpkFrY3EBERiQgK/ImIiFOx/xrr6bO0ycSJE81sRzZY/+CDD0yfBzXQFhERERERcS6N2yJe4sSJTV9Avnf9+/dHlSpVnL1LIiISQ6jHn4iIiIiIiIiIiIiIiEgMoB5/IiIiIiIiIiIiIiIiIjGAAn8iIiIiIiIiIiIiIiIiMUCs6vHn5+cHHx8f04BYtcdFRERERCQ6Y9cGjnHixIljxjgSmMZ/IiIiIiISG8d/sSrwx0Hfnj17nL0bIiIiIiIiEaZw4cKIFy+es3fD5Wj8JyIiIiIisXH8F6sCf3YUlG+Mh4dHoEjpzZs3kSxZMs0ElUin402iko43iUo63iQq6XiTqOSqx5uvr68JbCnbL3ga/4kr0PEmUUnHm0QlHW8SlXS8SVTzd8FjLizjv1gV+LM/IA76gg78+GZxnat8iBJz6XiTqKTjTaKSjjeJSjreJCq5+vHmivvkCjT+E1eg402iko43iUo63iQq6XiTqObvwsdcaPZHU0NFREREREREREREREREYgAF/kRERERERERERERERERiAAX+RERERERERERERERERGIABf5EREREREREREREREREYgAF/kRERERERERERERERERigDjO3gERERERkejC19cXjx49cvZuSBTz9/fHw4cPcf/+fbi5uUX688WNGxceHh6R/jwS+DPm+e3j4+PsXZEY/PfDPrej4u+IiIiIiMReCvyJiIiIiITiwu358+dx/fp1Z++KOImfnx+uXLkSZc+XIkUKZMiQQQGCKDi3eV5funTJBP5EIvvvBwN/6dKlQ/LkyXV+i4iIiEikUOBPREREROQ57KAfL9YmSpRIF2tjaTZYVGTq8Lnu3r2LixcvmtsZM2aM1OeL7exzO1myZGaJEyeOzm+JlL8f7u7u5ufNmzdx7tw53Lt3T+e3iIiIiEQKBf5ERERERJ6BF2rtoF/q1KmdvTsSwwN/lDBhQvOTwT8edyr7GTn4md64cQNp06ZFmjRpnL07Ekv+fiRNmhTx48fH5cuXdX6LiIiISKRwj5yHFRERERGJGeyefsz0E4kq9vGmnpKRh+8tgzKJEyd29q5ILMNjjseezm8RERERiQwK/ImIiIiIhILK/0lU0vEWdfReS1TTMSciIiIikUmBPxEREREREREREREREZEYQIE/EREREZFYql+/fqhSpUqI9/M+bhNakydPRt68eSNlX2jJkiXm8U+fPh3iNq1atTLbNGvWLMRt3n//fbNNWF5bSDZt2mQeiz8j83dEwkrnt85vEREREYmd4jh7B0REREREYiNfX2DDBuDcOSBjRqBCBcDDA7HW22+/jdatW0fIY7m7u2Pnzp04f/48MmTIEOi+u3fv4o8//oiQ5xEJic7vwHR+i4iIiIhEHWX8iYiIiIhEsSVLgBw5gMqVgRYtrJ+8zfWxVbZs2VCgQIEIeSw+Tvz48bFy5cqn7mNQIGHChEifPn2EPJdIUDq/n6bzW0REREQk6ijwJyIiIiIShXjxv0kTIGg1uzNnrPWuGhwYOXIkihQpglu3bgVaP3XqVJQsWRL37t0LWLdmzRrUrFkThQsXxuuvv46NGzc+VQZv4cKFqFy5MkqUKIG///77qVKAfn5+5rErVaqEokWLmoyhGzduhGpfEyVKhIoVKwYbGFixYoXZtzhxAhc/efDgAT7//HPUqlXL7HeNGjUwffp0sx+OuN/8fb4Xb775Js6ePfvUc3Bdz549Ubp0abPvbdq0wX///ReqfZfoTee3zm8RERERif7VO9atAxYvjmt+8nZ0o8Cfs61ZwymL1k8RERERiVb8/YE7d0K/3LwJdO9u/V5wj0U9eljbheVxg3u8sPDx8Ql2cdSkSRNz8Tzoxfaff/4ZderUMVk2toEDB5qyfuwJljhxYnTs2BF79uwJ9HtTpkxB3759MXjwYBQvXvypfRo9erS5UM/n5bYpUqTA2LFjQ/2auE92OUDb7du38eeff6Ju3bqBtvX390eXLl3w9ddfm0DGl19+aQIEEyZMwEcffRSw3fz5881tBh0YtOBF/0GDBgV6rKtXr5r+Y/v27TP3cZ8ZXGjZsiW8vb1Dvf8Svc7tyDq/X/TcJp3fOr9FREREJGzVO4ZV+R2vdCxlfkbH6h3q8edMHMUNGADs32/9rFoVcHNz9l6JiIiISCi/ypUvD/zzT8Q+JjOFkicP2++VK2f1EwvPV8kzZ86gYMGCz93Oy8vLXMBnIIAXz2n79u04fvw4Pvvss0DbDhkyxFxYp5dffhlVq1bFV199hUmTJgVs06JFi4Btgrp58ybmzZuHdu3aoVu3bmZdhQoVcPHiRWzgCw0FZhIxWMFARtu2bc261atXI3Xq1CaDyRGDBf/88w/GjRuH//3vf2ZduXLlkCBBAkycOBGtWrVCzpw58cUXX5iAwwB+dwc///Im2MAsIducOXNw/fp1fPvtt8icObNZ9+qrr5rf42M5vgcSe87t8J7fL3Juk87v55/fDGLmypXLBPt0fouIiIjEXkseV+/gxLEfMAAFsB/DMQBlT1dFkyZuWLwYaNQI0YIy/pxp1Spgyxbr3/zJ2yIiIiISbcSEOVtp06bF4sWLg114n6PGjRtj69atJphAP/74owmIOWb0xI0b15TRs7EXFy+Mb7G/9z6WP3/+EPeJmTyPHj0ypQId1a5dO9Svixf1WVrQMYPpl19+MY/hFuSD27x5sykNGDRQ8dprr5mf3Pdjx47hypUrz90nlj3ka2OPMTuzyt3d3bwHDD5I9BATzm3S+f3885v3Hz16VOe3iIiISCzm62tV5+BkvRpYhdKwvt/yZ3VYcZv33os+ZT+V8ecsPIJYNoSDEv7bw8O6zUFUTBllioiIiMRg/MrG5JS7d0P/O3/+yRJ1z99uxQpmkYT+cRMlCv9XyHjx4pmeVyHd54hZLcOHDzdZQR06dMCvv/6KTp06BdomZcqU5kK4I2bhMMsn8D4nCnGf7F5ffCxHQQMVz8OL9swoYjlABih40f49jtaCeT4+lwe/kwfzfNz30O4Ts4FOnDgRYpaVY680iTnndmSd3y9ybpPO7+ef3+xrqPNbREREJHZbutTu0+2PyegGdoLmt14feOATDMIq/xo4dcrNjBMqVYLLU+DPFbL9iKFiO+uvZk1n7pmIiIiIhBIvyCdOHPrtOccrSxaW3wu+dxcfj/dzuyDXqF0C+3kxa4YBgTx58uDu3buoX79+oG14EZ2lURyzbi5fvoxUqVKF+nnsi+/MwPH09Ax00T0smIXDfWZWEAMRWbJkQaFChZ7aLnny5Lh27Rp8fX0DBQdYetDeH8d9chR0n5ImTYrSpUujT58+oQq2SMw4t0nnd+jo/BYRERERZ/HzA44cYRWKwMu5c0BcPMS3aIY8OBKwfRz4mqw/ZgGuQk2zXXSgUp/OzPYLOtqzs/4iooO7iIiIiLgcft2bONH6d9AsHvv2hAmuGRSwNWnSBIcOHTK9rl555RVT8i5oxsu///4bcPvOnTtYt24dypQpE+rnYGlBlvJzLONHf/zxR5j2lRfhq1Wrht9++80EM+z+XkHxQj5L9gV9vqWc9gmYnmHZs2dHxowZn7tPfCyWBWWJRGZa2QuzqFheMWjWkcQcOr+j7/mdI0cOnd8iIiISyMkbJ7H93HZsOb0d05dtx/BZ1k/e5nreH5MxT2ndOuDbb62f0aXEpaN796xcq6++At55x+qfnSwZkDcv0LQpMGIE8OuvVtAvG07gT1RAY/z41OPYWX/MBsyYEdGCMv5cIdvPpqw/ERERkRiPzcDZFJz9A6xSIhZmAjEo4OrNwnmRnBe92Rdr/PjxT93PHmADBgxAz549kSRJEkyfPh3379/H22+/HernYBYPt58wYQISJkyIsmXLYv369WEODNjlCzt37mzKE3744YchZg4xcMH7L1y4gHz58pnX99VXX6Fhw4bIlSuXyRbq1asXevfubbZjZhR7lX3LkbCDtm3bmiAAf7Zv395kEq1YsQKLFi1C//79w7z/Er3o/I6e5zfx3OY5rvNbREREGNTLOyUv7vvcD3IHgO3WPxPESYCD3Q4iW/JsiGmWLLG+z+Y9vQaT0B3dMQkHs1Qzk9xc9fvspUtPZ/EdOGBl+AWVIAFQpAhQrJi1VL69DHmHt4Hb9WvBPrad9dcyzSpUqBA94jYK/Dkr2499EYI76rhevf5EREREYjQOllhBj/0BOLuQswYrVHDtTCBHlSpVwtWrV022TVAs+ceL5+PGjcOlS5dQtGhRzJ8/P1BJv9DgxXyW72PmERdmCfXt2xcff/xxmB6HWUvJkiUz2TxeXl7BbsOyhdOmTcOkSZMwe/Zs89pYNpDBjXbt2gVsV7duXZPRM3XqVHPxn+UQhw4darazMUNq4cKFGDt2rNnXBw8emGyiYcOGmWwqifl0fkff85sBRJ3fIiIicvnu5aeDfkHwfm4X0wJ/DPrxaw3Lu/+AASiA/RiOASh7uiqaNHEzk9ycGfxjSOXo0aeDfCy3H5w0aVhxwlrsQF/u3EAcRsYePQIGDADGjDHb+sRPDPcHd+GOpysy+sIdk5IPgod7DX7DhKtz8+cnGEtwli5n7RUrVixQCQ6+BWzmzdr/jr0KIsWDB0D27MCFCyFvkyEDcPw4ED9+5O6LOEWUHm8S6+l4k6ik401i6vHGbBa7tBvL08V2fO9ZUq98+fIm8yc24Gu2+4NF1d+30Bx3IY1vJHTjv/jx4+P48eM6t2P5+e2Mvx/6/4pEFn0fl6ik401i8vHGcp6lZ5R87nabO2xDqSwlEFOwIGGOHFblihr4Db+hVsB9NbESq91qmkoWx45FzaS2+/eBffuswN6OHdbPXbuA27eD354BPTu4V+zxwkl4wR4yJ09a9T7tMvbdugGLFrERtMvGbcIy/lPGX1SLHx+/Dt2CDztfMnHjEtiOr9ERp5AFDfCz2eTToelQW0E/EREREXEht2/fNtkye/bswalTp9CqVStn75KIRBCd3yIiIuKyrl0Dhg5FsoULgRYtrGp5KVJE6lMyyBTa7UplQYzA9DBm+1nl6v3xGfqC9QrdH2e7fYIPscq/Bk6dckOiRFET+GMOVXBFExk6KVw4cICPpTuTJg3lAy9fDrRpA1y9CiRPDsyeDTRoAPTpY2qGMgC6fbs/Tp++jyxZEqBECTfr9aZLF22StRT4i2I8aDp9khWnkdXcvgCrWXoGnMcuFIGfWxx0/gQ41j76lIIRERERkZiPWSkscefn54fhw4cja1br+6xIUCx/OGTIEKxatcocN+yFxiU4f/31F0aNGmWCTSwbOXjw4ICykZzZzT5sPO6uX7+OwoULY9CgQQE92STi6PwWERERl8MyjF98AQwZArerV63iiuPGAXPmmHXo1IkNiCP8ac+ftwJgyPH8bXv3BpZNDxyAypnT6ublynx8rP53QctlXrli3d8HI1EcuwK294AfSmMr3sUkTEYPPHwYdfuaOrX1vjqW6syb93GpzvAcUwMHAqNHW7dfesnK8uOHRvwOnDUrGJZ56SV/5I7GWc0K/EUx9nlwbPJ+DhlxH/GRAA+QBadxwj8HTp2ytqtUyZl7KiIiIiLyRJw4cUyQRuR5GMjbu3ev6d129uxZ07stU6ZMqFXrSakgOnz4sOn11qlTJ9SrVw+LFy9GmzZtsHLlSiROnNgEombOnIkRI0aYPmpff/01OnbsiBUrViBhwoROe30xkc5vERERcanUM2ZkMap26JC1qlAh3GvdGglnz4bbf/9ZZRmnTLF6s9WpE0Itx7Blli1bZiV+rVwJ+KZjU+Ln/96t2z5mV7nYmHVWtGjgYGDBgpxoBae4dQvYvTtwgG/PHus1BxXHzRcD/D/BxxgS7GNNwnsoi3+RZNJnKFIve6TvO9+z9Olf+OO1MOjSrBnwzz/W7R49gJEjo00GX1gp8BfF2NzdkT/ccQw5kR8H4AVvnHg8lSDodiIiIiIiIq7u7t27+P77702mXsGCBc3CAN+CBQueCvx9++23KF68OHpw0A3ggw8+wLp167Bs2TI0a9YMP/74o8kUrFy5srn/448/RunSpbF9+3aUK1fOKa9PRERERCIRo1K9egFr11q3WVrxk0+Adu3w8M4dJHzvPeDrr4HBg62Utbp1gerVgbFjrdqPYYwvbt9uBfu++caq+mgrUPQu/gvFY2Ts3gwN403Fw/9qBQTUGGjjfCrHOVXMTsuf/+n+c6lShWmXn/t6GFOwg3t2T7wjR4LfPmiA8qUs51FoREt4rH/83oegBRbCv89PcDvfE+jXLwz1NZ1oxQqgdWsrpZGlPWfOBBo1QkzmMkmnDx8+RN26dbFp06YQtzl48CCaN2+OIkWKmBmh/9qNF6MRNpMM6iisUjaeOPrM7URERERERFzZgQMH4OPjYwJ6tpIlS2LXrl2mjKQjlvfk2M7GEjp58uQxDeupT58+eO211wLdz/Kft3g1RURERERiDkas3noLKFHCCvoxC4tBpcOHrZKedl1H/uza1YpmffABEC8esHq1Fbnq3Bm4cOG5T8VNGCfk11BWemTiIIN+mTMD/fsDe/57hBRN+oZut+8fw9SbtXG6Um3M/mWfCfox+DdvnhW/rFrVCu6xtGbQ9SxhmS0bUL8+8NFHwI8/AseOWQG80LQTY+IjA5ZsS1ejhpUZx9fwv/9Z1SwXL34S9Atu/fXrVtXByZOBDp5/oGjb4ibo5+/mDj+rsOpTuP5RgqRwu38fGD4cyJ3bCsRyh1yRj491HPHFM+hXsqQV7Y3hQT+XyfhjD4hevXqZmaAh4eCOsz2rVKmCzz77DD///DO6deuG3377Dal5lkQTFSoAWbIAZ848OYkdA39MW+X93E5ERERERCQ6uXTpElKmTIl4vAjzWJo0acyYj336UjlMa+b6C0Euzpw/f9700aCXeCXGATMJGVRkIFFEREREYoB796wo3GefAXfuWOuaNrVu53hGkz1+Xxw1CujSBejb14pmTZ/OkhLAgAEAMwMdamuyJx3LcTK7j8lfdpyK8cWGDYG2bYFq1dibzx9vLe2Cf04/Lgf5DPE94qN10daYvXM2Vh5ZiVXeq9CpRCcMqTwEbxZKhzfftLZjDICxAMdSm8zGO3rUqj7JZenSwC8taKlQxtmClurkWxcUewsGzSzkY6VNG8KL4BsxbJjVM5GT9AoUgNuFC3Czm/0FfXzWL0yRGJg804qSMoLYsSMwaZLVf5Fvoqs4fRpo3vxJ6iXLw7I0bAwt7elygb8jR46YoB9nbj4Ly7wkSpTIlHfx8PBA9+7dsX79etM7omLFioguPDyAiROBJk2s2rR82d7wCpTxN2GCtZ2IiIiIiEh0cu/evUBBP7Jvs8qLo9q1a+Ptt982lV8qVKhgSnzu2bMHZcqUeepxmTE4cuRIdOjQAWlDvHIRPI41Hceb9m17XdD7RSKL4zFn/9SxJxEp6N83kcik401eCINMj4N0box88Zjid0AGj15+2drmGd/fAuTMCSxaZAV3evaE29atJiDl/+WX8B8+AjvzNsXsOW4mM+7KlSdZbGXK+JtgH2OMKVI8ebiP132MmTtnwt3NHdP/Nx3FMhYzsTEG6i5f5sQ1gIUteO0+TaI0yJY8G/q80gd91/TFkgNL8OW2L/HN3m8woPwAdC/THQniJAjIuLOz7mw3bgTuvbdrF7B3L9e74c8/YZZnSZzY3wT1HIOEhQoBwbXCDvY05QS8Vq3gtmaNtU379lYAj0G/S5dCfN2m/Cozl+rVA6ZOBYYOhRsjkdWrw5+lVxmQzZcPTrVypSnt6Xb5MvyTJbOyEhmQMS/UP9r+jQvLvjg98Ld582YzsHv//fdRjEfnM7arWrWqCfrZfvjhB0RHzCTlJAS2smDg2c74yxf3KBYvjBWZpiIiIiIiEgPFjx//qQCffTuBw6xrevXVV/HOO+/g3Xffha+vrxkX1q9fH7dv3w603Y4dO9CxY0ezvd0PMCxu3rwJd05/dhgwsxch94vlR/ncXEQiS9AytzzeuI6VjZgNKxJR7L9vdnlkkcik403Cy+Pff5Hwww8RZ9s2c9svSxbc++gjPGrc2MqUYUQsrMcb+/v99hvifv894n38CeKeOAG3li3wAJOwGeNxBWWRIYMfmjZ9iObNHyJv3if/b7afbu7euRj651Dz7zGVx6CxV+OAbfK8GvxruXHjBtJ4pMGMmjPQvlB7fPjnh9h5cSf6/d4PX2z5Ah+X/xj1c9UP8RxhuVEubD9Hjx4Bhw65Y88ej4Bl714Pk6RWuLBvoCVnTj+T4eeIX7uDfBUPVpy//kKit96C+4UL8E+UCHfHjsWjZs2sHWCgjAuA3HmA3I9/J9A3dPtNa9cObvXrI8GoUYg3Ywbcli+H/8qVeNi+Pe737Qv/iGxiGBo+PkgwYgQSMIDMm0WL4u6sWfBjgDiY4yq6/Y0L+p3SpQN/LVq0CNV2dv+HQYMGYe3atcicOTP69u0brjIvz5vxGRWYQsx2FcxAnvqOFfgrksQbRRpyP6JsN8QJXHG2gMRcOt4kKul4k5h6vCkzQxxF1TEQmuPOFY/H9OnT49q1a6YkZ5zHvVhY/pNBv2SPLyA46tq1q8niYwCELRwY2ONYz8Ye8F26dEG5cuUwduzYQAG80OLzOk4gtd83BimvXr1q7nO8XyQyOB5j/DeP5aRJkz4VEBd5EfbfN5ZMdpWLlBJz6XiTMGMDu3794Pb99+amf5IkJjvP7b33kCi4NLUwHG8MdrGE55xfO2HtpTfRHePRD5/hZfyLf/EyzlZsjrRfD0ccr+z8FvjU7684vAI91/Y0/2a23nvl3wvzy6uTvA5q5a+F+bvnY8DaAThx8wTarWiHV7K8gnE1x6F05tKhehxm173ySnD3xHnxcA4DR+zN9/HHcPPzg3+BAiZjMhF/Pnbyxklcvns55P17nOkYqDbpF1+Y8qr+ffvCbelSxJ8+HfGYiTloEPDOO1YvxsjGeqotWsCNjQsB+HftCo+xY5E0DN+1HF87jzlOSEyCJAHH3FOvPYqFZbKi0wN/ocXo6vTp09G6dWt89dVX+OWXX8wA8ddff0XGjBkjZMYnRfX/qGrUcMMHyGk997VruHHiBPwd84slxnHF2QISc+l4k6ik401i6vGmrCAJ6+zKiBCajKCo3qfQyJ8/vwn47dy5M6BH37Zt21C4cOGngnbLly83JTwHDhxogn737983gT72dKdDhw6ZwCDLgI4bNy4gkBhW/BsR9O+E47rg7heJKI4Besdjzv6pY08imn1c6diSqKDjTUKFmVYMNrG/FSN0/E7YoQPchg4FMmR4oeON5THZt2/+fKskpSUxVpf+ELkbtEezfYMQ/5tZyLT+W6DQElMO1PSmS5o04DG2nNmCNxa/AV9/X7Qp2gafVvk03Me0h5sH2hRrgyYFmmDMP2Mw6p9Rpl9g2Rll0bJwSwyvOtx5gaOLF2EaD65ebd1u2xZuU6awZmigwFe+z/Phvs/9EB+G5UsPdjv49Otgec+ffwZ+/x3o1Qtu/HB69bKCgiz/2aCBldEZGVatsl7bpUvWZ/v113B7440wPcQLvfYoEpbjMtoE/jgjjoNI9vajAgUK4O+//8bPP/9sZoBGxIxPZ8xQ4aRXj6TAuVsZkBHnkYw1dLNz5oHEVJoRJVFJx5tEJR1vElOPNwYjrly5oqwgidLPPzQZQa4YiE6YMCEaNGhgerMPHz4cFy9exMyZMzFixIiA7D/7NeXIkQP9+/dHqVKlkCdPHowePdpM6mRJTxo8eLC5zW2YRWhTlpSIiIhINODjY/VWGzzYCshQ1apWHz/WtwwnPhR79jHgx954NsYQW7UC2rQBChbkmkwAZgC937UCfn/8AfA76YwZwKefAu3bw/vGcfzvm//h7qO7qOFVA1/V+ypCxpeJ4yXGR5U+wlsl3sKHf3yIOTvnYMGeBfhh/w/o/XJv9C3fF0niJUGUYcPA5s2Bs2etJoDszccmh0Ew2+1ZgS/i/dwuxOAXP2OWcZ0zBxg4EDhyxOptVrGi9dmXKBGxx9jHH1uBZV4jYCs5ZhrmtguUhl6EvHYXEvY6KU7CBu6enlZJTBsHiufOnQvzYznODnD24u7uBk9Pt4A+f27Hjjl9n7Ro0aJFixYtWrQEXlztO2RELaymkS9fvkALM7MqV66MoUOHmkoZkb0PU6ZMMc/Lsv537twJdpuFCxeabdjzOyKek4/F5w3L51+wYEFMnjzZ5Y47V8RAHd+vNm3aYMiQIaaHX40aNcx95cuXxwrWYQJQqFAhEyBkhl+jx43Op02bZgKeDBCyt9+RI0dQqVIl83v2Yv++PFurVq2QN2/eQAvfc76f/FzYkyay8Zzh8/LvStDejbZvv/3WbFOlSpUIeU4+Fp83sn9HRETEGW6cuIaLGw5aAQ9XtnIlULQo67pbkbq8eVnuwco2C0fQj63nVqyIA7YBZFX4996zgn6sINmkCfDLL2wVZiWWWUE/BwwGMQuN2WgMCDHzrVMn+BQtjKGDX8Wlu5dQPENxLH59MeJ6xEVEypwsM2bVn4WtnbaiYvaKJnD06YZPkXtybszYPgO+fpE8kc8u7Vm5shX0y58f2LIl2KBfhOKEyfbtWcID+PBDNvsG1q8HWBGEz82ynC+Kr6daNWDYMCvox2Nt48ZwBf1iomiT8VesWDFs4UHp4OjRo6hbty6iOy8v4OguT5TDP4C3t7N3R0REREQiUZh7JkQyVtL46KOPAm4/evQI+/btM6UV9+/fby7KR0WAiT3h2Mv7NTbCDkKBnuiFWX8jR440S1AHDx4MdLtx48ZmCW7iZ9BtowOd38HT+S0iIvJi7ly8gy1Nx6DUulFIjrt44J4AN7MVRvKKxRCvTHEruFW4MMC+ec60bx/Qu7cV+KNUqYAhQ4DOnYG4YQ+q7dnzpJTnxYtPXpsdP2rWDEidOhQPxO87/B5Sq5YpPek/ZAji7NuPOfuA1gUSosicCUga/0n5z4hWImMJ/NHmD/x88Gd8sPoDHLl6BG8tewuTN082/f+q5IyYCVCBMODKFMjffrNut25tZfo5lPa0PfR9iP8u/YelB5eG6qF3nNuBXKlyIVn8p3t4B8Kym598YgKtpsTqggVWJiD7PPbpYx0rwezPczGA3LKl9Rp5zH/1lXUwhKOS0JlbZ7Dz/E7T5zEmcenAn2MZmGbNmmH+/PlmFh4HCz/99BNOnTqF+vXrI0YE/h5n/OHoUWfvjoiIiIhEYlAg75S8LtU3IEmSJGaSnSOWXmT23aRJk0wPtqD3R4YSJUqY/t1BAwMXLlzA1q1bTdl/ZiCKuCqd3yHT+S0iIhI+fj5++Oft+fCaMQCV/KwsqQeIh/h+95H2+BaAyxxrW39WhGC2E//f7rhkzBj5O8osOk42mj7dyjJjkO/dd61sr5Qpw/RQ7IRll/Lcvt1e64a0af3QqpUb2rZ1MzHOcIkXDz7vvoPWiX5FqZm/odtmoOp/94CyVayMMb6GNGkQGTjZqkG+BqiTuw4+3/w5hv45FLsu7ELVuVVRL089jK4+GnnT5I2YJ9uwwQqE2aU9P//cipS6ueH6/esm0OW4MOj3yO9RqB+eQUsuXim9UCxDsUBL5qSZn55YljWrFb1lGzeWXf37b6tEJwN2zEhkf74g/cCDxVYHDCSzVCuz/JhVytKeefI891d9/Hxw4PKBp177lXtXEBO5dOCPZVzYC4JlXzJnzoyvv/4aw4YNw/Tp0+Hl5WV+pk+fHtEdK5huVOBPREREJMaLTn0DWBKQzp49GxAY4OS7OXPmmMobKVOmRL169UwZx3issQNgzZo1pp8bM4mYWZQlSxZTbrAlZ2M+R506dUzJR5YDZLDCtnLlSuTMmdOU59y8efNTmUIcIxw7dgyJEiUypUB79eplej/a+Dtjx47FgQMHkCFDhkDZT7YHDx5g4sSJ+OWXX0w/Rz5f165dzT6JhJbO75Dp/BYREQm7XZP/RLy+76P8PSv6dSpODpzuPgrZejTCL5OPYt83O5Hu7E4Ug7Vk9j9rlVbkwmCIjdfPgwYDGSCMiP7V9+8DkyZZ5RbtSTws4c7KD7lyhfphWLmUSYIM9i1dapX2JMYP69VjzMofZcveRJo07PEe/t1lhle3Fd3w7dnf8GPdBHh1xEyUnPCdVQZ0yhRg3jxg0CCgWzcgfnxEhnge8fD+y++jddHWGLJ+CKZumYplh5bh1yO/4u2X3sbgioOROlFo0hiDwaAr650y4Orri0d5vLBhdHdsSHYSOxc1MoGu49ePB/urKROkNIG8ree2Pvdp0idOjwt3LsD7mrdZ2LvQscKFCQKmfxIMZEAzjnscoHRpKyi5eLGV8Xf8uNWUceJEYPx44HGv72Cx5VuLFsC6ddZtZhFOmGAFNoO49eAWdl/Y/STAd2En9lzYgwe+D57a1sPNA/nT5ke2ZNmw4kjMyfpzqcBf0FIuQW+XLFkSS5YsQUzDjL/58LJuKPAnIiIiEm1w4MhG8KF179G9UG935+GdUD9uoriJIrxcHy+2U1bOzgSrsiwwff9ef/119OzZ01TfGDVqlOkTxvXr1q3DO++8Y/oGMlhw//59fPPNN+Y+BhmKcjbmM9SsWdNM8gtaDpAX///3v/+Z53M0depUk7HUokULvP/+++Z+XtzfuXMnFi1aZKqGsKRh+/btUbZsWbPt6dOnzb4H/Qy539u3b0f37t3NBMPVq1ebx3z48CEaNGgQge+qxNRzO7LO78g4t0nnt85vERFxXSd+P4Jzrfui7FnrOvgNJMPOOgNRZkF3ZE2RwKzrNDo3/EflxqZNr5tgWcuFQLwbFwOCgDXS7sRLcXYi+YWDcLtwwSr3aJd8JAZL2GvPDgQWL26VCk2UKOQdW7PGythioK9qVSt407cvv1hY95coAYwbB1SsGKbKoNx/xtu4mzY+FBPUmje3EvCY3BUR7YlH/DUC07ZNgxvc8E2jb1Ayf0OgUnNg7VqgVy+rcSDLT37xhRVAa9jQKhPq+NrZVy4CMLg3qfYkvF3qbfRZ3ccE/yZtnoR5u+eZ4B/XM0gYGo98H+HQwX+QvFN3ZPl7t1n3XfG46FDLG3d29Hhq+xwpcgQKzhXPWBxZk2XFjvM7UHJ6yec+34qWK8xEtl3ndwUE1vhz/6X9ZpLbmqNrzGKL7xEfhdMXfhIMLFMMRXZuRtJps6ygMVM7edyEFDRmj0ZONuNBwklk06aZICC/6527ddaUHnXcjyNXjwS730niJXkqKFkwXUFTlWP7ue0K/EnEZ/zZpT79T5yAG6c4xNFHIyIiIuLKOMgoP6s8/jn1T4Q/Nh83LMplLYcN7TaEK0DA18H+WzZe6GcWzRdffIHixYubi/p+fn74/PPPUa1aNXzKsiqP3bt3z2TRMPvnyJEjaNiwIQYOHBhwP3+/TJky2LRp03MDA2nSpDElCB3LAZ45c8aUImQAgvvjuI+8/cYbb2Dw4MEB6/PkyWOyj3744Qfzc9q0aUidOrXZNu7jniLMZOJFf9s///yDDRs2YPz48QEZQBUqVDCvbcyYMaanuEdEzIaWaCMyz+2wnt8vcm6Tzu/nn99xNPYWEREXcePEdexo/Ale2TYZ2fEIvnDH3wU7o8Cij1GxQLqntufXg7JlrYXJUj//nA6zZtXAmNU1MPqStU2aRHfRrdJeNMu3E3nu7oTbzh3A7t3A3bvApk3WYmOpRZZMDJodyIxBRt4GDAD277cCYClSABs3Wr+XKRMwYkSoyzVevQp8+60V8NvqkFyWNq31EAz4MSYZ0ebumouBa63vMgy4NWTQz1alirUzc+dar9Pbm82orQy0sWOfvHb+ZNAzAidm5UuTD0ubLzWBsl6replMtfd/ex+fb/nclP+sn7d+oO+CN+7fMCVCHctVJtu6B/MW+SDLTeBeHKBbHWBm8UeI6xEXxdIVDBTsKpqhKFIkSPHC+83MvqqeVc3iWN1i38V9AfvFQCL39fbD29h6dqtZbAy+sk/gq2MrousvF1Bi6Va4LVkC/2XL4MYyscy8tHsEDh1qjsH7+fNg9WcdsSHhTuycN9s8x6W7jw/2IDInzRyoBGnxDMWRM2VOuLuFoqRoDKBvuC4gWzbgknsG3PNLgIS+94GTJ61ooIiIiIi4NA5WorstW7agYMGCgda5u7vjlVdeMdk8HGSy9B9L5FWvXj3Qdh06dDALvfXWW+Yne4cxm+jkyZPYs2ePWcfMmtDghXkGHuxygAw6cN+yZ88eaDtm/fAxedHe0UsvvWRaBDCwwcDAtm3bULly5YCgANWoUSNQIG/jxo3mNVasWDFQgKRKlSpYunQpDh8+bMoQSuwSE85t0vn9/POb/QVFRESc6dHdR/inzTQU+uFjVPK3+o1tTVMLKb4eg1frB/7/eEiYwMeWblxOn7Yy6BhYO3QoET5eUdosOXJYVRXbzPNFTt8jVnab43L+PHDggLUsXPjkwdkjMHPmJ1E6BsCI2YEs18gMucSJn7l//N/wqlXWPrGqpv31gfNvrFKeQO3aVmnPyLDKexU6LLW+1/R5pQ+6le729Eb8DtGuHfD661a235gxwJ9/skHyk222bLFeSM2aEb6P1TyrYXun7Zi9c7YJUDJrreF3DVEpRyVUzlE5INh39NqTioFufkDvf4DhvwNx/IGTGRLi28ENUeHl6ng3QzEUSFsg1FmDdjCP2W/P61nN7UK6r2Smkmax+fn7mX0O2lvvzK0zOHz1MPjfjGJAgUzAmFVA7SOPTObona+/wM1s6ZBx7wnzODNe8kC3modwf8cHgZ6TgTwGTxnYs4N8RdMXRdrEaUP9uiPitbsaBf5cAP+gZc3ujmPHcqIA9lvlPhX4ExEREXFpvJjMTJywlAPkACc02T5/tfvLDFhC60XKAfLC+xA2SH/8muLHj4+MGTMG6sN1/fp185PZNSG5evWq6a/FPmB8HF7M54V6O+soNBh4YDDCLgfI7CD2GQuKGUF2FlFQXHfr1q2A7ZgB5IjZPY7r+Nq4fyVYTygYFy9eVOAvlgnPuR1Z5/eLlvrU+f3881uBPxERcRZ/P39sHboCqUb0RsWHB8y6I/EL4MagsXhpYK1wP26WLED//kC/flZSHoNt331ntVPj14IhQzxQqVJetG2bF00+bPokZsfAX9BgIPsFsrcaF0f83sD7+WTPwBihXcrT8SGYSMhgH1u2MdMvMrEMZONFjeHj54OWhVtiRLURz/4Ffk9ihlnHjtYbuWBB4Pvr17eilSyPamdFMjgaAVmAHu4e6FCiA94o+AZG/j0SYzeOxbrj68ziiGU2KyQugEEzvZH338NmnX+LFsj25Zfoyyy5cOLjHux20JTrDAkDX2HpV83AHDP7uDQp0CRg/cU7F58qFVo3/QFUP+SHsauAgpfuIfHeE7gdF+hcD/imiC8Sx02MVzIUDVSqs1C6QkgY9+k+fy/62vkd0p6wZn8fD+trdyYF/lyoz9/RY55PAn8iIiIi4vI4AEgc79mzWx2FdkDC7cLyuC8iceLEKMx+Hs+QLFmygIv/jq5du4b//vvPlPzr3bu3yRyaPXu2uR0vXjxTTo/9uEIrVapUpl/XypUrUaRIERw4cCBQCUBb8uTJzc/Lly/DM8iEuUuXLgX0LUuRIoXZxhEHcHZggZImTYpEiRJhLsv6BCNoNpLEDmE9t0nn97Pp/BYREXni0A97cKtTT5S6avVBu+SWFvubD8UrM95CnAQRc8mesYpXXrGWCROAn36ygnBsV7dunbV062YluDEIV6FCBrjVqgVwsd25A3z1FeBQStu4csVq0BdM4O/aNSvQOGsWsHnzk/Wc08M2bXwuxsqiwvHrx1Hnmzqm1GSVnFUws/7M0Jd65HeOVq2eDvw9eGD1N+RiY/TS7pVoBwNZNjWcLQOSxk+KT6t8ik4lO2H036Nx48GNgIw2lupMtfMg0LQpwD7J8eMDkyfDjRUaIiD4yMBWVAS30iVOh+pe1c3i2At778W92PjuNuya9y0y7TyKHR3qoH7pqvg4Q3F4pfKK1FKd2Rxeu/29kt9NI6PndmSLHQVNo0ngzxte1g0F/kRERETEhfDiO7No/vjjj0Drf/75Z3Tq1Mn0AGPZPZbZY88vBgXoT5bGYXkXP79QPxfLAf71119YvHgxSpYsiQwZMjy1DfuJ8TmWL18eaP3WrVtx9uzZgOyel19+2ewDAxQ29vvi/tpKly6Nu3fvmoEdAyT2cujQIdP3zLE8oEhMpPNbRETCytfXChotXhzX/ORtCZ2Lu8/jz/yd4NWkGEpeXYMHiId1pfsg3vHDeHVBlwgL+gXFqpzMrmOVSmb+sa1vrlzA7dtWgK5iRes226mdsCorGicfXcad2V/B3yNwGIG37/TtiZPXrY15DKxcaZUaZfJb165W0I9xL7b3/fFH9ve1ApBRFfS7eu8qai+ojfO3z6NwusJY8saSMJW9NH0N2WcuaPCOfQwZ8GzeHChQwLp96RKwerVVIpRvNNcz865MGaBzZ4CTnZh+yUBqGDAINbnOZMxtOBfvv/w+KueohFSfz7R6DzLolzu31aeR2YnRMDgV3AS5UplL4a0yXdBiynpU+usU3m83zWRA5k6dO9b054sIyvhzEZzIeBSPZzMq8CciIiISI0XXvgHsmfXuu++aMn0sB8j+WOzzNWnSJNNri7MgmcGzbNkyU1qQF/O3b9+O6dOnm9mRjhfmQ1MOkCUFmVk0cODAYLdhpg8DErxwz/5e7PN1+vRpTJw4Ebly5ULDhg3Ndu+8844pTcg+ZexRxoymCRMmBOoJxt5fpUqVwttvv20WLy8v7N6927y2ChUqmCyl0JYylNhN53f0PL9FRCRsliwBevRgHzkGGawMdsZAJk4EGjVy9t65rntX72FT8wkouWo4XsVts+6frG8g6/zPUOnVnFG6L9myAfzf8IABwD//WIE/JvHzkvTgwdZSpQpQ982T+H1dbizf9WRSjc3N1w+Jd/2Hpt1zI1vmI/h5bjacPfvkfhYcYLs8xsDSp0eUY+bYa9++hgOXDyBLsixY0XIFkiewqgqEGqOk7OkXFCc9sZEiGyay1x+/C+3dG7hE6q5dVpCP0U/HtEcG55gJaGcF2kswk6GewuoMTJdctsy6zSjr9OlWgFEkCAX+XCjjb4Md+PP2dvbuiIiIiEgkiIyeCVGFAQCWzJsxYwa+++47c/G/Y8eOZqHPPvsMn3zyiVkoR44cprfY0qVLTaZOaLHsYPny5U3mTk0OpEPAQAX7fc2fP9/sD4MFtWrVwnvvvWf2094H3s99e//9901Qo2/fvua2zd3d3QQwGFSYNm0arly5gvTp06Ndu3YmsCASWjq/n0/nt4hI9A/6NWliJUI5YiYX17PyoYJ/T/fx29hjIbJ90Q+VfE+adfsSl4Lv6PF4pWs5p+4bY1DlylkLA7fMymMp0N9/B9auBdb+dwmb3B+BCZ3BFazk+sG/P0IZv0vA+WzgfBq7lCcrXjorAc3Xzxdv/vgm/j71N5LHT46VLVea4F+Y2Nl+zOYLrroB1/P+GjWAhAmBUqWsJWAnfK1r/EF7JrLR4cGD1sJ6qDZGR+0goF0ulCmYdrbhv/9apT1PnrRKe/ID69QpRmT5SeRw849F01d9fX2xc+dOFCtWzMxqtEV1vdaTN04+NRg8cAAY9oY39l1+A37Jk8H9+pO+BBKzRPf6wBK96HiTqKTjTWLq8Xb//n2T/ZIzZ04kSJAgUp9LXPd441iCY4io+vsWmuMupPGNhG78Fz9+fBw/flzntkT53w/9f0Uii76PS2RiHCNHDivRKTg85Jj5d+xYuNuahZr3VW+sPbYWZbOUReH0z+5l60x7pm+EW6/3Uej2JnP7jEdWHO/8GV6e2AzucVy3ZCFLfbI97swf/8XGQy8jwzOqU55LArSssRHdWpbF//5nxaSc+feN2/VY2QOTN082ZT1XvbkKFXNUDPsTso8fewFfuBDyNszSY93UsLxoPh6zAXfseBIMZBAwuBANJzsVKQLkzAl8/z3AEuUMBvLfUVUvNRbzd8H/p4Zl/KeMvyjGoF/eKXmDLf+SsBOA4YD7jZs4dWIPsmZ33f9xiYiIiIiIiIiISOywYUPIQT9i3IItx5iUVK+eFZfInx943Br2hd16cAvf//c9Zu+cjQ0nN5h1bnBDh+Id8EmVT5AhSShKJUaR038dx8kW/fDKKSuj6zYSY2u1/ij97fvInMbKXHdljHcxmS1d0XgotQ5I+4zA38XEwODK8dCoHlzCmH/GmKAfzW0wN3xBP2Iwj2U+2bsvJOnShT3Sycw+ZglysbEkaNBSobt3A3fvWpl+XOiNN4CvvmIJhfC9JolVFPiLYsz0C6nnw714wNkkQKbbwO0DuwEF/kRERERERERERFw2C44BMVbvy5gRqFAh8rPdnIWvMTR++MFaiG1XCxYMXMGwaFEgeShbrfn5+2H98fWYtXMWftj/A+4+umvWu7u5o0j6Ith5fie+3vE1Fu5biP7l++P9su8jYdyEcNZnfvP0TWx/fQTK/jseWfAAfnDD33naI893n6BSsYyILm7cv4FF+xZh+L4pOJ0cZnmWrw59ikKneuPlLC87NTPqmz3foM+aPubfY2uMRdNCTV/sAbNmtZbIljgxUKaMtTgeaIcPW0FABgXZNJGBPxfJPBPXp8Cfizma0gr8xT/xjCk0IiIiIiIiIiIi4tR+dz16BM6CY6lLtt6KiX3uQhtvaNwYuHzZilfcuPEkgckRKxfawUB7YXzFfo6j145izs45mLNrDk7cOBHwe3lT50XbYm3RqkgrZE6WGX+f/Bvv//Y+tpzdgoFrB2Latmn4rOpnaFaoWaQEoOzPPO/pNZiE7uiOSTiYpRrGj/ZB+uUzkP+bQajkb2WIbU9ZBYm/HIcKbxRFdMAgK8unMqNyyf4luOdzL9S/u/X2jyg380fkTpXbfD6ti7YOe0+9F8R9b/tTW/Pv98q8h54v94zS549wjCbny2ctIuGgwJ8LBv7KnwLiH1fgT0RERERERERExNUwANSkydNtuc6csdYvXhyzgn/LlwNduz57G7vH33ffWTELvjfsFWcH/uyWZidPWn0Aufz445PfT5n+NjJUWYxbXrNxOs76gPXJ4yc3gTwGlMpkLhMooFcuWzn8+9a/WLh3Ifqt6WdaLLVY0gITN03E+Jrj8XLWlyPhM/fHDxiAAtiP4RiAD0/7Im/z3iiMvWa7Y3Hz4FLfMSg1pC7c3F0/O+vI1SMBQdZTN08FrM+fJj+q5qyOKVsmPfcx/perLv44sRaHrx42AdgP136I6l7V0bZoWzTI1yDSszB3X9iNht81xCO/R3i9wOsYW3NspD6fSHSgwJ8LBv4o/skzzt4VERERERERERERQeAKfMz6Chr0I65jXOq994D69aN/2c9Hj4ABA4AxY6zbXl7A0aPWvx1fvx2LmzDhyWvmuhw5rKVBgyfbXr0K7Nr1OBi40w9/n96AY8ln4Vr+xbgW73EzOX83wLs6PPa2Rc44DfDocEJsOQY8KmaVCnVsccayny0KtzABpvEbx2PEXyOw6cwmvDLzFTQt2BSfVfsMOVLkiLDPvAZWoTS2mPX8uQq1rNeFlNjd8GOUm9cFORNHUGPDSMJ+iSzlOXvXbPx18q+A9SkSpEDzQs1NkLVUplLYcX5HqAJ/Q6sMQe5U32Dxf4vNY/554k+s8l5llmcFbiPCqRunUGdBHdx8cBOvZn8VcxvONceESGynwJ+LBv7inVDgT0RERERERERExJWwv5tjec+gGBw6dcrarlIlRFt8DU2bAhs3WrcZ+Bo1ysr+C67EKYN+oclyTJUKyFHsGP50m4u/3OfgmOexgPvSx8kNzxvt4LujFfZvyoJbtwBWCd25NfBjMABZpEjgACCQCMBA1PFoj50pB+Fwkpn4bt93+H7PTyhw830Uvt4f8fwD/UKonT9vv15/jEUv07vPHVbk0w/ARPTAJxiMJd1TIW5iuGwpz3XH15lSnkH7JdbwqmGy8+rnq48EcRIE/E6aRGnM7fs+90N8XN7P7ZLGT4p2xduZxfuqN+bumhtQqpUlWLkELdX6oq7fv47aC2rjzK0zKJC2AH5q+lOg/ReJzRT4czHeqayfyvgTERERERERERFxLefORex2rmjFCqBVKys7L3lyYObMJ0E9/mQ2459/+sPb+y68vBLh1VfdnpvdeOfhHRNwYuDpj+N/BKxPGi9pQEbYy1leDsgI8/MDjh9/UirULhfKAJy3t7UELyOAr4H07wI1e8LPcy32pvgMe+POANZ+AuzoAPiF7ZJ4GlxCDyzAu5gELzwJVBJzy1aiNq4hlUt+5s/ql9iuWDu8WeTNEINw2ZJnw8FuB3H57mWT9cj3n/0b06QBihe3sjsZ9ON2jrxSeWFI5SH4qNJHWH98PWbtnGWyAQ9eOYj+v/c35UBDCjaG1gOfB2iwsAH2XdqHTEkz4deWvyJlwscZNSKiwJ/LZvydOW/l08eN6+xdEhEREREREREREYaVMkbsdq6ElyIHDQJGjrRulywJLFoEeHpat9lDj0EgSpbXH7kz30aSJEmw66IVrAsaBGI/vA0nN5hg3/f/fY/bD2+b9W5wQ1XPqibw0zB/QySKy2y9wNzdrefl4phJyMATS4Xu2wc8ePCsV1MU/v5rsN93OZY/6o3LiQ8B9bogw2tTUDfeOOTxqP7M98Ld9xE8D6xAoa2z4bl/OTz8fKzXZPb/CR944BMMwirUQMaMrtHTj+8zA20MuLHspi08ZTf5edqfaaksYdsPZhNWzlnZLFPqTLFKge6cbY6JlUdWmoXlRZsVbGYyBVleNDT7xOzF1j+1xvoT603geEWLFU8FH0ViOwX+otjzUqTPJwHuxQES+vha3W6Zuy4iIiIiIiIiIiJOxaynP54kqz3TuHFApkxAnjyIFphJ16wZ8Pff1u133wVGjwbix38S9Ms7Je9zyz4yQ4wBP5Z6ZL83ZpzZcqXKZYJ9rYq2CneghtlmVatay/MxiFQPD31r4sutX+LjdR/j/P29+PpBDdTJXQdjqo9B/rT5A//K7t3ArFnAggXApUsBq7098sDL91CgoB/Fga/p9dcyzSpUqFATzsJgGIN8DKwxwHbn0Z2AIGt1r+omu69+3vpIGDehU/YvWfxkaF+8vVmOXD0SkIV46uYpfLntS7PkT5PfBCWZhcgsvpB8sOoD06Mwrntc/Nj0RxTNUDRKX4tIdKDAXxRzTJGmrWe3ovPyzsiaLCt+avYTGjcGjvo1Q0EctrrlKvAnIiIiIiIiIiLiVBcuAC1bAr///mQdk5PY0y/obWarLVsG/Por0K2blUXH3nauivvJ0p5Xrlh982bMAJo0CbwNr2U+K+hHvL/JoibYcnZLwLok8ZKgacGmJqBTLmu5UGV0RbR4HvHQvUx3E1D6ZP0nmLJlClYcXoHfjvyGLi91wZBC7yL1T78Bs2db9Sxt6dNbb0ybNkjZoD18vd3hYbr6BeYLd0xKPgge7jWC5ANGvmPXjgX00zt2/UkZ0jyp8wQEWbMkC2OqXiRjAPiTKp+YcqB/HPvDZCYu2b8E+y/vR981fU050Fq5apn9r5e3XqBSoBP+nYBx/44z/55Vf5bJHBWRp7EMsTgh+FciYwmz8I8Ynb99HkXTF0XBVCVw1C+vtSEDfyIiIiIikaRVq1ZmeZZ+/fqhSpUqcHV8HXnz5kUzTlUPwfvvv2+24Wt6UZs2bTKPxZ+R+Tsi4aXzO/x0fotIUMzyK1bMCvolSgTMnQv88AOQOUhrtCxZrPV79gB16gA+PsCECUCuXMDEiVYpTVfC/evf39pXBv1KlAC2b3866BcWdtCvSs4qmNdwHs73Oo+vX/sa5bOVd0rQz1GqhKkwvtZ47Ht7Hxp51UPtA76o3PtzJPXMB/ToYQX92HaJb8Dy5VYaJNMec+dGqtsngw36EdenunMKePgwSl4H+yUyY67ynMrwnOSJj9d/bIJ+zKrrWKIj/m7/Nw68cwD9K/R3uaBf0FKgDNzNbzQf53qdw1f1vjLBYWYvMjD7xuI3kGlsJrzzyzsmeebHQz+i16pe5nc/q/oZWhZp6eyXIOKylPHnZJmTZjazTh76PsTpm6fh6Zkd3nic5afAn4iIiIg42dtvv43WrVsjOnB3d8fOnTtx/vx5ZMiQIdB9d+/exR+hrc0lEkvo/BYReX5pz+HDgY8/Bvz8gIIFge+/B/I/rg5Zvz6wYQNw7pzV069CBcDDw7rvl1+AVauAnj2tfnTvvQdMnWrFkerVs7IDnenMGaB5c2v/6Z13gDFjgARPkqvCpUvJLuhXvh+yp8gOl7R3L/LMno0f5m8GLjxZvTUjsPyV1CjZcwzqvtwmcJCS9U63bDGlP3lMMD7IXoMsO1q8+OPPPF26J3VRIxDLpp69dRY7z+/EjvM7zLLKe1WgfonVPKuZjMoG+RoE2y8xOkieIDneKvGWWQ5dOWQCm3N3zzXXy6dunWoW2zul3kGfcn2cur8irk6BPyfzcPdAzhQ5cfDKQXhf84aXFwN/jzvmKvAnIiIiErOtWQN07w5MmgRUqwZXlC1b+PqvOEOBAgVw5MgRrFy5Em3btg10H4MCCRMmRDLWrxKJCjq/I5TObxGJahcvAm++Caxebd1u1w6YMsXK+LMx4FOpUsiPUaMGsHMnMHOmVe7z0CErWMhk67FjrSxCZ/jtN+u1MXiVNCnw9dfAG288+3fu+dwL1WN3LNnR9YJ+TGf89lurlOe2bU/Wp0sHv5YtsLRsKrx96gucu30OWN0OFQ7OxLia4/BSppeebJs1q1kY43upVOTspo+fDw5ePmiCfGa5YP20W0Y5ioh+ia6KZUqHVR2GoZWHYu2xtaZXJEuBspRsg7wNMLHWRKdnj4q4OpX6dAGeKa1An/dVBv6Ao3bgz9vbuTsmIiIiIpGHDWAGDAD277d+OjaIcSFBSwHy35MmTcLIkSPxyiuvoEiRIujQoQOOHz8e6Pe2bt2KN998E0WLFkXp0qXRt29fXL16NdA2W7ZsMb9bqlQpFCpUyDz25MmT4ccp9WB1pdOmdN6sWbNQq1Yt81g/sH5WCBIlSoSKFSuawEBQK1asQM2aNREnTuC5jw8ePMDnn39uHr9w4cKoUaMGpk+fHrAPtkWLFpnf5+vl6zp79uxTz8F1PXv2NK+X+9qmTRv8999/z32PJQbS+R2tzu+FCxfq/BaRQNavt4JyDPox0Md4EYN3jkG/0OKfpk6dgMOH+XfXSgpbu9Yqq9mhg5UtGJWlPQcOBGrVsoJ+fI0s7RlS0I/ZZhtPbUSnZZ1Qc15NRCt8sUy7fP11IFMm4N13raAfS3k2agQsXWpKebqPG48GbwzCoXcPYfCrg5EwTkJsOLkBpb4qhdY/tjYZZ3TyxklsP7c9xIX3hwUz9v459Q+mbplq3t/SX5VG0hFJUeiLQnjzxzcxZuMYrDm6xgT9PNw8UChdIdOjcEz1Mfin/T841O0QBr46MMYF/YImzFT3qo4FjRbgbM+z+LnRz/iuyXdmvYg8mzL+XIBXSqu059FrR1HO80ngz9/bG24cIGoGg4iIiIhr4ne1u3fDnw3EkkHEn7z4EN6sIF6FisLvjHPnzkXJkiUxYsQI3LhxA8OGDTMX/r/77ruAC/7t2rVD2bJlMWHCBLPNxIkTTUnBxYsXI0GCBDhw4IDJ2uEF+fHjx5sLS8uWLcOUKVPg6emJ//3vfwHPx2DBwIEDkSRJEnPB/Vnq1KmD9957L1A5wNu3b+PPP/80AQb+tPE5u3TpYsoHduvWDfny5TP9ubjPp06dwieffGK2mz9/Pj799FNzof/VV1/Fxo0bMYjT9h0w6MH+Y8w64n38OWfOHLRs2dK8Zi/O8JPYcW5H5Pkdxed2bD2/+W+d3yJCnBcwYgQweLD17wIFrNKe/PmimJTMx+7c2QoA8s8qg4n8ydssCRqewGJocU4DS3vafyq7dgXGjQu+tCeDXfN2zTOZViy7GK1wUgYjtfPmAefPP1nPmpzMGG/RwqrRGUSSeEkwpPIQU2py4NqBmLd7nlkW/7cYnUp0wpfbvsQD3wchPm2COAlwsNvBpwJx/P/R+dvnA0p12tl8R64egT/8g92PoumLoliGYgFLwbQFkTBuQsRmKRKkwKtZX0Vcj7jO3hWRaEGBPxfglcoaJLDUZ85ywDHkNLfdbt4Erl0DUqVy8h6KiIiISLCBgfLlgX/+iZjHa9Ag/L9brpzVoCWKAgQspzd16lR4PG5ic/LkSXPx/tq1a0iZMiXGjh2LnDlzYtq0aQHb8II+L/Yzo4cXyxkYYEbR6NGjTe8u62WUw9q1a83FecfAQO3atdG4ceNQ7VulSpXMRXnHcoCrV69G6tSpTTDDEYME//zzD8aNGxfwfNwHBi7sQEauXLnwxRdfmH3o37+/KStUvnx5E2xglpCNQYDr16/j22+/RebMmc06BhEYqOBjMYtKYum5/SLndxSf27Hx/OZr5Xk6gJmZ4Eev81sktrp0ySp/yb581KYN8PnnQOLEEfs8OXIw0xjo0QN4/31g0yarDOi0acBnn1nBucd/OiMMMxdbtrReY5IkwFdfAc2aBd7m3qN7+Pngz5i9czZWH10NP38rO5o9414v8DpeyfoKOi/vDJfE66d8U2fNejLxhtKmtT5UfpjPmVxiy5o8K+Y2nIvuZbrj/d/ex18n/8LEzROf+3ssQ3nh9gXceXjnqVKdF+9cDPZ3MiXNZAJ7xTMUDwjysTKcu5uK9InIi1Hgz4VKfTLjL2FCIFWmhDhzNhMy46zV50+BPxERERHXFEsrM7Bknn3Bn+zMm3v37pmL6rt27TIl/jjD2YdllkxblKwmK+bvv/82gYEGDRqYhaX4jh07hhMnTmD//v3w9fXFo0ePAj1f/vz5Q71vfH6WFHQMDPzyyy8muBC0F8jmzZtNaUBmJTl67bXXzMV83s+gxZUrV0zAwREfzzEwwCwh7mf69OkDXjN/l8GBpcz2kugllp7bsfX8rly5cqBtdH6LxD7MgmPAjVlxvDY3daqVHBaZXn6Zf1+seBUz/k6etGJUEycC48dbcz9elK8vMGQI8Omn1rwWxr6YwZg7t3U//5ZvOrPJBPsW7l2IGw9uBPxuxewV0bZYWzTO3xhJ4yc1pSyZ1cYAV0h4f5pET2fTRQr+PWZEk9l9P/0EPHz4pLZq3brWB1i7NhAvXrgenv39/mz7p+kt12NlD5y5dea5v1NhVoVgswIZyMuXJp8V3EtvBfiKZiiKdInThWvfRESeR4E/Fyr1yYw/c5t9/s56Pgn8veTQSFZEREREXAMvMjMTJ6zlAHnVpWJFYNcu62qMjRfaeTWGTWXCGnSI4nKAzLhxZGf0sG/WzZs3zc+vvvrKLEHFZ2Mbzoq+f9+U1/v555/NhfQsWbKgePHi5kI9L0IF7e0VFrxoz9J+LAfI5+NFe5YHDIolCpnB5BjkoLScHQ7g1q1bZhtKkSJFsNvYmA3E4EbBggWD3ScGTSSGn9uRcX47odRnbDy/uV1w29h0fourY2bWuuPrTPDm31P/Ik+aPIHKBCqDKGQs5zlyJPDhh9a/8+WzAmOFCkXN8/NPPAOOTAyfMAEYPtxKWGPiOVvTcd9yWoXBwoy9A1nVct066zZLjDKgyD/zZ2+dDSjleeDygYDfyZ48O9oUbYPWRVsHVCizsYQlS1my5xzx7zkzpFmq2Z58waBfpPSc4/87jh0Ddu58sjBV8qJDJl2RIkC7dlZqY5C/4+HF19W4QGNkTpoZL898+bnbM+jHDMmgpTrZn4/rRUSiigJ/LiBnSuv/4NfvX8fVe1fh6ZkKRzd4ogL+ArytYKCIiIiIuCBe5Ahr/afffgO2b396PYMEXP/330DNmoiuEidObC6SMBvHsZxf0KAC+4b99ttvpt8WSwLaF/9f5vT3F8QsHO4Hs4L4uAw6FArmCl7y5MlN+UJmITkGBy4+vojEYIAdEGBWUNBAgKOkSZOidOnS6NOnT7D7FC+cs80lGp3bpPPb/NT5LRI1vK96Y86uOWZhNpbt8LXD+OXwLwG3k8ZLarKL7Ewj0zMsXUGTnRWbsexl69bAypXW7VatrEw/lsKMavzz2b+/Fbdif8EZM6wA5M8/A5zbwGrEyZOHrdUs41/8k8fXM3060PD1+1h6cClm7ZyFVd6rAkp5JoyTEE0KNDHZfZVyVHpmkJhBPTuwx8AfJ1Dw723QrOsX8uCB1afPMcjHhS2RgmKvPr5QZvcVK4bIEi9O6P7OL3ljCV7L+xo83ANPOhERiWoK/LkAzvjImCQjzt0+Z8p9enmlwlFY5T9Nxp+IiIiIxAycrcwmLsyg4bTyoLie99eoEW1LDXLWd4ECBXD06FFTMtDGDKDu3bujYsWKpq/Wtm3bUKZMGVSrVi1gm7179+Lq1asmo+hF8CI8H5eBB5YGDC5AQbyQ//XXX5sAguM2duk+9gzLkSMHMmbMaB6rUaNGAdv88ccfTz3WsmXLTO8zvge2Tz/91JQ2HMI6WxKz6fyOtuc3t2FpUpvOb3Fltx7cwuL/FptMrT9P/BmwPnn85GhWqBkqZaqEyz6Xsev8LtNfbM+FPbj18JbpU8bF5uHmgfxp8wfqL8YspdSJUodpfxhwtDPAghNpGWAv6K+/rB53Z86wjDAwZQrQvr3z/zyzujKDdN26AT17Ar//DowaZbWuGzoUeOstq5JlSDjPhNt98on1v6XCRfwx6Ist+OPabLw99luTdGArn6082hVrZ4J+yeIng9N68zFLfseOJwE+Bv0el1UOhJMsONGDAT57KVMm3KU8I0P2FNkV9BMRl6DAn4tg+jwDf5yt5eX1En5V4E9EREQk5mHvETZwCenCN9efOmVt97hkXmRjubzZ7I0SRJ48eUymTnj07NkTnTp1Qq9evUw/LWbczJw50/QGe/vtt802RYoUwa+//opvv/3W9AY7cOAAvvjiCzNjPCLK5tWpUwedO3c2ZQo/ZP2uEDKHGJzg/RcuXEC+fPlM3y+WMGzYsKEJYBBfR+/evTFo0CDTL2znzp1mvx0xA4plDfmzffv2JpNoxYoVWLRoEfpzCr/EfDq/o+X5zXObr4Xb6fwWV8XMLAb5WMqTQb87j+6Y9W5wQw2vGiZTq37e+iaDL2gGlo+fjynluPP8zoBlx/kdpuLU3ot7zTJ/9/yA58qaLGugEoVccqbIGWxGF4N+eafkfW7PN5aHdJXgH/8Ujx4NDBxoBcny5rUy6xzmMrgEVq1k+7oVK/g9BDh4EOjaFZg8GRg7FgjSvtQ4f95Kflu7ljM1zqF0x/m45Tkbb6z+L9Dny1KebYq1Qa5U1t/BcFuzBknffdfaqerVn70to5AnTjydxcd1wWFGtmOAr3hxqw5r3Lgvts8iIrGEAn8ugvXWOfOKff6qeALeeFxHW4E/ERERkZiDF/vZuIW1pUKSLl2UBQXo5MmTGDFixFPrmzRpEu7AQPny5TFjxgxMmTLFZAHFjRvX9MaaNWsWij0uw9SvXz+TKcNSgA8fPjTl+rp27YojR45g7dq1JpjwIrjvyZIlM9k8DDwEhxcxp02bhkmTJpngCLORuB8MbLRjra3H6tata35yW178Z9Bk6NChZjtb+vTpsXDhQowdOxYff/wxHjx4YLKJWPKQ76XEAjq/o+35zQDi1KlTdX6Lyzl27Rjm7pprSnkeu34sYH2e1HlMptabRd5ElmRZAtYH7aFJcdzjmP5iXLi9vd2ZW2eeCgayCtWpm6fMsuzQsoDHYDaYCQI6lAotkLaAyfR7VtCPeD+3c4XA3+XLQJs2VjCNGCT78kvnlPYMDcZambDMRPFp04CPPrKS4WrXtgJ/Y8YAdutRBvuav/kAF1Mug0erWfDzWonN8AOuWMHXxvkbmwBxlZxVIqbfI4+1AQPgcfAg/FmHlBnednCYE1z27386yBekjHIANjF0DPJxyZrV+emXIiLRmJt/cN8KYigOLjh7j4MRxxr/kVaTOgyGrh+Kj9Z9hA7FO2DEy1+jcLrzOI+M8Hd3h9v9+5rREoO4wvEmsYeON4lKOt4kph5vLGF37NgxU+KNZeUkdh5vdp+wqPr7FprjLqTxjYRu/Bc/fnwcP35c57ZE+d8P/X9FnuXOwzsBpTzXHV8XKPjWrGAzE7wpm6VssP8/etHvRzfu38DuC7ufBAQv7DQZgQ99HwYbUMyRIgeOXD3y3Mfd1mkbSmQsAWdii1WW9jx92irtySS1Dh2iV2yJVTE//dTa90ePrArSHTv5wz/Vv5i1fS5QaCGQ4Elw7eWsZU12H4N+yROEoUFgaKxaBdSr9+R2585Wbz4G+Pbts3YwKF7bZKTSMcBXtCiQIgVcXXTMbo1pdL1Bopq/Cx5zYRn/KePPRXiltGYpMuOPfWnvJE6Pu3cSIpHfPSvt/XEZEhERERERERERiVkXFzec3GBKeX7/3/e4/fB2QCnPap7VTHZfg3wNkDBuwmc+DstXTpyY3GSDtW1rZYWFZR45g0MVslcwi+2R7yNTKpQZgY4ZgtfuXwtV0M8VSnsyM45JaUw2zpPHKu3JUprRTbLkvujY/zCy1t6J7xf8hbK716DtYm8UvuyDadxgZdDf+Pfx0jXyd44piY6SJ3+6VGf+/C7Vjy8sGMxjUC869rMUkdhJgT8XKvVJLKvAALJXLjcc3eWJQthnlftU4E9EREREREREJMY4cf2EKeXJ7D5eD7LlTpXbZPa1KtIKWZNnDdVjjR8PjBhhZSQsWWIt6dMDb75pBQELFQrfPsb1iIvC6QubpXXR1gGBSpYD/eG/H9Bz1ZOyuK7myhWrtOcvv1i3mze34lNJk8Ll3X10F3su7AkUcN1/Zheq/ncfbXcC6w8DcVythhtrp7L8MQN92bNHr3TKUGBQT4E9EYkuFPhzEV6prIy/UzdO4YHPA3h5xQ8c+BMREREREREREZcsAxjaTCCW8lyyf4kJ9q09tjZgm6TxkqJpwaYm4PdK1lfCVFZs0SLAbkv53nv34eYWHwsWuOHCBWDsWGspWRJge0sGv1KlepFXa/XQ5OupmKNiqLb38fNBVNu4EWjaFDh1ymqtOmkS0LFjxMWiwvKZP8+F2xcClVflz0NXDsHP3w/wB4qdB9rtAFrsAdLcc/i9wjlxt8UbSNO0E5KmSh0RL+v52DGqShVg924rhdLGknOHDgH168e4gJ+ISHSkwJ+LSJsoLRLHTYw7j+7g+PXj8PTMC288blKuwJ+IiIiIiIiISLTt/TW/4Xz8euRXLNq3CLce3goo5VklZxUT7GuUvxESxU0U5udfvx5o1cr6d7du/hg8+D5SpIiPkSOBX38FZs8Gli0Dtm2zFgYIX3vNygKsWROIEwVXBpsuboqpdaaidu7aURKXGjcO6NcP8PGxCmixtCeT0Jzd742BPJZHZWBvx7kdAUG+87fPP/X7aW8DXQ4mQdtdbvA8eevJ68uUCW6tW5tUxvT58iHK/fYbsGPH0+sZBNyyxer9xwNLREScSoE/F8HZUsz6YxNllnfw8sqLfbDKfyrwJyIiIiIiIiLiepj19awAEPH+Jt83CbjtldIroJRn9hTZw/3c+/YBDRoADx8CjRpZ5T5vW+0BTW8/Bvi4XLoEfPONFQTcuRNYvNhaMmSwgoYMAhYogEjDCe51vqmDml41MabGGBRKF866o89x9ar1WhjoJGb8TZ8OJEvmnM983fF15qedzcdrfpzwHxQDwHlS50HJ1IXR6FgClF97BOnWb4Wbz+MPkymL/KDbtoVb9epWdp0zMKo6aBDg7m41TwyK63l/jRrK+hMRcTIF/lwIv/jxS4D3NW/k8QSW2YE/b29n75qIiIhIrMd+NiJRRcdb1NF7LVFNx1zslDBOQjQv1NwE/MpnKx+mUp7BOXMGqFULuH4dKFcOmD8/5HhQ2rRAjx7WwsDfnDnW9ufPA6NHW0upUlYp0GbNgJQpQ7cPLGfJzLZnBcHie8RHm6JtMGvnLPzm/RtWf7kaHUt0xNDKQ5EucTpEBJ5Sf/9ttZg7eRKIFw+YMAHo0sW58ac2P7V5ah3fryLpi6B4huIolqGYWYqe80fCBd8BQxYAlx3Kh5YubX0ojGCG9kOJTIww8w0OLuhHXM/aqtyOwUoREXEaBf5ciGdKK9DnfdUbtXMDRx8H/vyPHoUbv8VotoyIiIhIlIvzuAaWD+tFiUQR+3izjz+JeB6Pr5A/evQICRMmdPbuSCzCY87xGJTYYXWr1SiXrVyEPNaNG0Dt2sDp0wCrPS5dCvDPWGhiyix5yYWlQFessLIAf/nFqtLI5b33ApLLwOSyZ/1viGUsWc4yNL3u+pTrg75r+uKH/T9g2rZp+GbPNxhYYSB6lO1hgmGhxdNn/34rgMmFVSf5kwFQ8vKySnsWLw6nS5EgBUpnLo1i6a0AH5fcqXMjjnschzTMrtYLsDEN83Epz0hNwwwPBvN4kHDfH09iuH37NpIkSfIkkJ0unYJ+IiIuQKNIF8v4o6PXjyJbNuCUew7AD3C7edOqV5A6ihr1ioiIiEgAXpjlcvPmTSRNmtTZuyOxBI83+9iTyBE3blzEjx8fN27cMOf2i2bfiIQGL5TzmOOxx2NQYo+EcSNmgoFd1nPPHitGxD5+qVKF/XGYFccAH5eLF60Y1KxZwO7dwKJF1pIpk1UKlDGo/PmDfxwG9Rz72IWE7W0Wv7EYf574Ez1/64lt57ah3+/98OW2LzGy2ki8XuD1p/4OM8C5a9eTIB8XljflexAUA5TMVvz884gv7elo/6X9mPjvxFBtu6bVGpTMVDJw1HL5CuuNXr7cakJofxj161vRVpbJdOVJP1mzWgv5+8OXH1Ly5EpWEBFxMS78f5LYh1+C7Iw/fv9Plz0hTh/LjCw4Y/X5U+BPREREJMrxIlS6dOlw7tw5c6E2ceLEChDEwgv1vr6+JggX2Z89n+vOnTsm8JcxY0Yda5EsTZo0OHPmDE6fPo3kyZObQIzec4mMvx/u7u4mk5dBP2bIZM6c2dm7JtEQKymy8uPatUCSJFbGXo4cL/64TNJipp9dCpRZgAsWAGfPWpmBXMqUseJSDK6lSPH0Y/j6Ahs2AOfOARkzAhUqBF969NXsr2Jzx81YsHsB+v/e3/T/a7q4KUalm4jmKcfj7uHSAUE+XgoLDgN7duYiF2b3MTAZWYlm1+5dw3f7vsPsnbOx6cymUP9ewP9PGKVlsI/1VR9nyxkvvfTkTdU1PxERiUAK/Llgqc+j146awYGXlxuOHvN8EvhjwXURERERiXIMCNy7dw+XL1/GJccLNhJr+Pn5mQv3UYEXClOkSGGOO4lcyR6nhfDcZgBQJLL/fnACCYN+9rEn0d/ei3uj7Ln697cy85gQ9sMPEV/OknEqPiYX9v1jUhqDgAwwbtpkLQwQNmxoxauqVbOCe0uWWEFDlh61ZckCTJxoZSc6YtLbwYPucNvTCo3PNsKyq2NxLNNIbLv4D7ZdLAPsbgH8PgK4YWURMrnMDu7ZgT4GOyN7joavny/WHF1jehP+dOAnPPB9YNZ7uHmYkq3MXLRV9QYm/Qp0rw38bs3pR+o7QNoZC4EfOwLbtz954PTpn6RRFioUuS9CRERiLQX+XEj25Nnh7uaOez73cP72eXh6ZjR9/l7FBsDb29m7JyIiIhJrMRDD7Ctm/tm9mST24KS8W7duRVk5SGadqcRn1GEAhgvPbWZmiUTW3w/27FR5z5jlj2N/oMvyLlHyXFOmAKNGWf/++murImRkYvVJBu24XLhgZQAyaW3vXmDhQmth4iozAX/88en+gpxL0aQJ8OmnViVIuxcff/+BFUMDkBjAYCDpW3CrOhD+RecARb5BnCJL0DRrL3xauy9yZIzaMusHLx80mX1zd8/F2VtnA9YXSlcI7Yq1Q8vCLXHm1hmUnP64hKc/MPx3oMBlYMQaYMgjoO0u4LWDQDy/0dY2PO9fe82Kltasad0WERGJRAr8uZC4HnFNXXSWOfC+5g0vLyvwZ4RU30BEREREoox6rsXeC/cPHjxAggQJVAYyBmNARkEZiWj6+xFzLTu4DK9//7rJBOMkbj9/vxC3TRAnAdIkShPu52JGXffu1r8ZSGOyWFRiklrPnsD771sBPAYAmXnI4B73LTh2IHDgwKfvY8vkokUdS3VmQoECs/DftXdN/7/1J9Zjwalh+P2bGfi08qdoW6wtPNwj7/vXjfs3Akp5bjy9MWB9qoSpTKCPz188Q/GAc5ifOT/T+z73UcMbKP04PljqHLB84ZPHfVi0EOJ16AS0aKFSniIiEqUU+HMxXim9TOCP5T49PcvjJwX+RERERERERERcxjd7vkHrH1vD198X9fPWx6jqo3D74e0Qt2fQjxO9w+Pvv4GWLa1AWufOwIABcBrGvUqUsJYxY4DPPgM+/vj5v1e2rFUW1A705cwJBFc9u0TGEvijzR/4+eDP+GD1Bzhy9QjeWvYWJm2ehHE1xqGqZ9UILeW59thaU8rzxwM/miCeXcqzdu7aaFu0LermqYv4cZ5uHMjP8mC3g7h8+yIKlqkHf5yHHdb38/DApfZN4demNTKWqxlh+ysiIhIWCvy5YODv92O/w/uqNxp4Ad54XBxcgT8REREREREREaeatnUauv7SFf7wR6sirTCz/kzEcY+cy2sHDgD16gH371s/We7TVRJH48cH8uQJ3bbMVmzePHTbMquuQb4GqJO7DqZumYoh64dg94XdqDavGurlqYfR1Ucjb5q84d7vQ1cOYc7OOaaU5+mbT5oSFkxb0CrlWaQlMiTJ8NzHyYbkyNb8TeDM+UDr3X19kb5xa0BBPxERcSIF/lyMZ0orw4+lPj1LIKDUp/+pU3B7+NAqsi4iIiIiIiIiIlFq1N+j0HdNX/Pvt196G5PrTDZlPiPDuXNArVrAtWtWHz321IvjYlfxMmaM2O0cxfOIh/fKvmeCq0PXD8XUrVOx7NAy/HrkV3R9qSs+qvgRUicKXfnMmw9uYtG+RaaU59+n/g5YnzJBSrQo3MKU8iyZsWToy/Fu3w68/nrwk/RZEn7QIKsJo6tEaUVEJNaJnG8nEm5eqawMP5b6ZPNj31TpcAeJ4ObnB5w44ezdExERERERERGJdb0aB/w+ICDoN6D8AEypMyXSgn63bgH/+591GShXLmDZMiBRIricChWALFlCjm9xfdas1nbhxeDexNoTsbfrXpPx5+Png8mbJyPX5FwYv3E8Hvo+DPb32HNxzdE1eHPJm8gwJgM6Lutogn78zJhNuKjJIpztddZ8ji9leil0QT/WW506FXj55ZArc/n6Alu2AKtWhf9Fi4iIvCAF/lyw1Ked8Wdu53ILyPpTuU8RERERERERkajDAFK3Fd0w4q8R5vbIaiMxrOqw0GeHhdGjR0CTJsCOHUC6dMDKlUDatHBJTG6bONH6d9C3w749YYK13Ytiec+lzZdidavVKJK+CK7fv46eq3qi4NSC+OnATyY4S+wLOGjtIOSYkAPV51XHgj0LcM/nHvKnyW8+u1Pvn8IvLX7B6wVfR4I4CUK/AzdvAs2aAe+8A7AiF2frh3QMsIEhs/4e75OIiEhUc7EiAWKX+rx45yJuPbgFT8+kOLrZE4WxV4E/EREREREREZEowuyydj+3w/zd8+EGN0z931R0ealLpD0f40RvvWUlizHDb/lywMuaHx46ly4h3uLFQOHCQNGiQLJkiGyNGgF8yh49gNNPWuaZTEAG/Xh/RKrmWQ3bO203ZTsHrh1oAn0Nv2uIV7O/aoK0f538K2DbFAlSoHmh5qaUZ6lMpcIfrN250yrteeSIVW912DBg3Djgxo3gt2fVrlOnrAAhmyGKiIhEMQX+XEzyBMmROmFqXLl3BceuH4OXVxF44/G3PAX+REREREREREQi3X2f+2i2uBl+PvgzPNw8MLfhXNMPLjIxSWzuXCtD7vvvgVKlwvDLPj7Aa68h0aZNT9YxalisGFC8uPWTS6ZMEd57jsG9+vWBDRus3oTs6cfynhGR6RccD3cPdCjRAW8UfAMj/x6JsRvH4s8Tf5r7WMqzhlcNtC3aFvXz1Q9bVl9wkdjp062o5oMHVt3S776zSn02b24CrSFiuqaCfiIi4iQK/Llo1h8Df95XvU3gb5td6tPbKv8pIiIiIiIiIiKR4/bD22iwsAF+P/Y74nvEx/evf496eetF6nNOm2Ylktn/rlMnjA8wbhzcNm2Cf+LEQMqUcGP6Ha8jcfnhhyfbpUnzJAhoL3nzWplsL4BBvkqVEKWSxk+KT6t8ik4lO+HLrV+aDL+WhVsic7LMEdNosVMnYOFC6zabLs6ZA6RObd1mEJCLiIiIC1LgzwV5pfLClrNbcPTaUbzkCXyvHn8iIiIiIiIiIpHu2r1rqPNNHfx7+l8kiZcES5stReWclSP1OZctA95+2/r3Rx8BHTqE8QH27wcGDzb/vDdyJBLywa5cAXbtspoFslQllwMHgMuXgTVrrMWWIIFVHtQxGFikCJAkSdj2g4/ZvTswaRJQrRqiSrbk2TC86vCIe0C+byztefiwFdEcMQLo1cvq3SciIhINKPDngrxSWqU9va95o2lR4OjjwJ//0aNwY5mBSGogLSIiIiIiIiISW124fQE15tfA7gu7kTJBSvza8leUyVImUp+TlTmbNrXawjHgx8BfmPj6Au3amVKU/rVq4WGLFkhoZ/ZVrWottnv3gH37ngQCuTDIdfs2sGWLtdh47SlXrqdLhWbIEPx1KV6vGjDACkLyJ583ul2/4mv46isreMnSnmxUyNKer7zi7D0TERGJnoG/hw8folGjRhg0aBDKlHn2l6rTp0+jXr16+PLLL5+7bXQt9WkH/lh6/Vy8HPB76AZ3lhngjC1+eRMRERERERERkQhx4voJVJ9XHYevHkaGJBmwutVqFEpXKFKfkwlldeta8bjatYEvvghHrGz8eCt6mCyZVSP0WQ+QMCHw0kvWYmPEkeVAHYOBXM6etXaQCxsOOvauC1oqNE8eK9vPDhzy56pVQM2aiDYY/OzcGfjmG+s2a62y4aJd2lNERCQacYnA34MHD9CrVy8c5peJUPj4449x9+5dxPSMP5b6ZBWBTJ4JcOZAZmTFaavcpwJ/IiIiIiIiIiIR4uDlgybod+rmKWRPnh1rWq9BrlS5IvU5L160gn2svFmyJLBoERA3bhgfhKU7P/zQ+ve4cVbPuRs3wvYYvPCUO7e1sLyl4w4GLRV68KC1nkE9Lo6lQlkSk0FHZs3x34MGATVqRI+sv927gTfesF4f9334cKB3b5X2FBGRaMvpgb8jR46YoJ8/vxiEwtKlS3Hnzh3E9B5/dPz6cfj4+cDTMw6OHvC0An+chVW6tLN3UUREREREREQk2tt5fidqzKuBS3cvIV+afCbTL0uyLJH6nLysxUw/XuLx9AR++SXs7fQcS3yazLr27SN2J5nZV726tdg4CX/v3qdLhQadnM99Y9bf118DHTvCZfFa5IwZwLvvAvfvA5kzAwsXAuXLO3vPREREXojTp65s3rzZlOv8jjWzn+PatWsYPXo0hg4dipgsU9JMiO8R3wT9Tt04BS+vJ33+TMafiIiIiIiIi2JFlwEDBuCll15C+fLlMXPmzBC3/euvv/Daa6+hePHiaNu2LY4GGe8sX74c1apVQ9GiRfHOO+/g6tWrUfAKRCS2+OfUP6g0u5IJ+hXPUBx/tv0z0oN+Pj5WchnjYqwi+euvQPr04XigCROAf/8Fkia1+tJFRWZdokTWZPROnYCpU4F//rEyDAsVCj47jtuxRc+XX/KiHlyutGfr1lZgkkG/WrWsQKaCfiIiEgM4PeOvRYsWod72s88+Q8OGDZGb5QdeALMLHTMM7duhzTqMbG5wQ86UOXHg8gF4X/WGp2eOgMCfP6eDuch+Svi42vEmMZuON4lKOt4kKul4k6jkqsebq+2PbdSoUdi7dy/mzJmDs2fPom/fvsiUKRNq8aKqA7Z66Ny5Mzp16mR6uC9evBht2rTBypUrkThxYuzevRsDBw7EkCFDkC9fPgwbNgz9+/fHNPawEhF5Qau9V6PBdw1w99FdlM9WHsubL0fyBMkj9Tn5Z7trV2DFCqvd3vLlVnu8MGNJyqAlPp3l99+tLMCQbN5sLe+9BzRoYGUpVqtmldR0Fu4vy5qyVCr349NPgT59VNpTRERiDKcH/kLrn3/+wbZt28yMzxd18+ZNuDv8z5wDZrtnoJuL1B7PmiSrCfztPbsX6dOXxZbHgT+fw4dxJ6z12sWluOLxJjGXjjeJSjreJCrpeJOo5KrHm5+fH1wN36fvv/8eX331FQoWLGgWBvgWLFjwVODv22+/NZl+PXr0MLc/+OADrFu3DsuWLUOzZs0wf/581K5dGw14ofhxQLFy5co4deoUsjrzIreIRHs/7v8RzX5ohoe+D1HTqyaWNF2CRHETRfrzfvKJVf2Sl6RYUbJs2XA8CMtosqwns9TYQ69DBzgNI5ns5ccXFNz/k/j/zCxZgGTJgH37AFb74pIpk5Vt17YtkDdv1O7v7NnAO+8A9+5Z+8EPokKFqNsHERGRKBAtAn/379/H4MGD8dFHHyEBGwa/oGTJksHDYWaRPVM2efLkLjOQz5suL1YfX41z98+hepHEmAir71+ckyfNfkr05YrHm8RcOt4kKul4k6ik402ikqseb768+OtiDhw4AB8fHxPQs5UsWRJffvmlCVQ6TsBkAK9IkSIBt/ne5smTBzt37jSBv127dqGjQ2+ojBkzmsxBrlfgT0TCa87OOWi/tD38/P3QpEATLGi0APE84kX687Lq8UcfWf/+/HPgtdfC+UATJ1olNqOyxGdIHj4ETp4MPuhH/P/no0fA1q3Af/9ZQbcFC4CzZ1nWy1peftkKADZtyv/RRm5jxbffBubOtW6zL+K8eUDatJH3nCIiIk4SLQJ/LPHCQWH37t0DrecgkLM/w9rzjwPKoAN2e52rDORzpcxlfh69fhSe5d2e9Pg7dQpu/GIVP75zd1BeiKsdbxKz6XiTqKTjTaKSjjeJ7cebK+2L7dKlS0iZMiXixXtyET1NmjSm79/169eRKlWqQOsvXLgQ6PfPnz8fMNHx4sWLSJcuXaD7U6dObbaJSa0eJGbT8eZapmyegu4rrWtLbYu1xfS60xHHPU6kfz7s48d2d2zu0r+/Pzp3DmcXl0OHgIEDwb/+/mPGWCU+nfn3jX/rWcbz0qWQt+HfcV7D4oQQLqNGWTVO58wxb4zbxo3Axo3wZ/Z3w4ZWELBKlYgtBcpswzfegNv+/fDnBBReR+zXz8pU1LkZbvr7JlFJx5tENX8XPObCsi/RIvDHWaCrVq0KtK5GjRr49NNPUa5cOcREnimtQB97/LHue9yMaXH7XGIk8b8DnDgRziLwIiIiIiIikefevXuBgn5k337ICYwOWMbz7bffRt26dVGhQgVT4nPPnj0oU6ZMQOWX4B4r6OPEhFYPEnPpeHOdz2HslrEYtnGYud2lWBcMe3UY7ty6E+nPvWOHB954Iwl8fd3QrNlDfPDBXYSrg4uvL5K0aYM49+/jUaVKuMMedUEeyCnHG8t4cnmWoC+YPf6qVYPbhQuI9/33iLdgATzYb+/bb83ilykTHjZrhofNm8MvlzUxPrziffMNEvbuDbd79+CXIQPufP01fHkt8datF3pc0d83iVo63iSq+bvgMReWVg8uHfjjbNGkSZOa8p7Zs2d/6v706dObGZ8xkVcqq7Sn9zVvc5B55XLD0XOeKII9wNGjCvyJiIiIiIjLiR8//lOBOft20LYNr776Kt555x28++67pmwpA37169fH7du3n/lYCTkzMoa1epCYS8eba3wGfdb0wdiNY83twa8OxkcVP4qUz4MVmDdsAM6dY3liIHNmoFkzVpl0Q/Xq/pg9Oy7ixQtnOcsJE+C2aRP8kyZFnFmzkDxFiuh/vDHDe+BAYMAA+G/bZpUC/fZbuJ89iwTjxpnFn0G6Nm1Mxt5zA4xBS3u++y7c+Jh8b6pXh9u8eUgSJJNcwi/aHW8Srel4k6jm74LHXFhaPbh04K98+fIYMWIEGjVqhNgmZ4qc5ufNBzdx9d5VeHqmxtENDoE/ERERERERF8PJmdeuXTN9/uLEiRMwoZNBPwbgguratSs6dOiAW7dumUmdPXr0QGZeKX/8WJcvXw60PW+nDWM/pujQ6kFiNh1vzuPr54uuv3TFV9u/MrfH1RiH919+P1Kea8kSgNUqT59+so5/Bn18gGLFgB9+cAt/15bDh60AGY8nlvjMkSNmHW/c11KlrGXcOGDpUisIuHIl3P7+G+DCN5fXB+1SoA6Z3E9hP0FmRPIntxsyBG4DBjz7dyRcouXxJtGWjjeJ7cecWxj2w6X+j3fw4MGAsi727ZCCfkG3jWkSxk2ITEkzBWT9eXkB3rCyABX4ExERERERV5Q/f34T8Nu5c2fAum3btqFw4cKBym3S8uXLMWzYMFO+k0E/lvbctGlTwDivaNGi5ndt586dMwvXi4g8zyPfR2i5pKUJ+rm7uePrel9HatCvSZPAQT9i0I+6dQOSJg3ng3N2f7t2rKVslcjs2BExGqOjDNr98ov1hrInYP781utfsACoXt0KfA4aBBw58vTvz5tnBRAZ9MuQAfj9d+DDDxX0ExGRWEX/13NhXimtQN/Ra0fh6QkchdX3D97ezt0xERERERGRYLAMZ4MGDfDxxx9j9+7dWLNmDWbOnInWrVsHZP8xwEc5cuTAwoULTT/348ePo1evXsiYMaMpAUrNmzfHzz//jO+//x4HDhxAnz59UKlSJWTNmtWpr1FEXN+9R/fQ8LuG+G7fd4jrHhcLGy9EhxIdIuW5GJdjMtrjimBP4eT8IUOs7cJlyhQr4y1JEuCrr6wHjC1YL/WDD4B9+4BNm5gmDrDE6alTwKefArlzAxUqADNnAhcuAB06APz/DXsyVa0KcBJKpUrOfhUiIiJRToE/F+aZ0gr0eV+1Mv4CAn/K+BMRERERERfVv39/FCxYEG3atMGQIUNMD78aNWoEtHNYsWKF+XehQoVMgPCzzz4LqPQybdq0gMzA4sWLY+jQofj8889NEJD9NdgKQkTkWfZe3Itq86rhl8O/IEGcBPi52c94veDrkfZ87OkXNNPPEQOCjFNxuzBjRlv//ta/R49+ZonPGI3BztKlgalTrQaK330H1KplZfH99ZcV8GN2HwOAdqT1t99YM9rZey4iIuIULt3jL7ZzzPjr+PKTwJ//0aNw4zfH2DTLS0REREREok3W38iRI80SXMsGR40bNzZLSBgQjI0930Uk7C7euYjBfww2pT39/P2QNF5SLG+xHK9mt7KIIwvjUBG5XQA/P6B9e6vEJXvade4cnt2LeRIkAN54w1rOnAHmzwdmzeL/YKxA3zffWO+XiIhILKbAnwvzSuUV0OOP/esvJ84BvztucL99m13tYVaKiIiIiIiIiMRS933uY+K/EzFswzDcenjLrGucvzFGVhsZcF0lsnBONlvJhbZqZZhLfDJNMHFiYMYMTf4OTubMQN++QJ8+wN69AEtBsxSoiIhILKfAX3Qo9XnN23y/y5orPk7vyoJsOGWV+1TgT0RERERERERiIX9/f3z/3/fou6Yvjl8/btaVzFgS42qOi/QsP9q4EejZE/j332dvx+s5WbJYrejCVOKzXz/r37G5xGdo8U0uXNjZeyEiIuIy1OMvGpT6PHPzjJnB5unp0OfP29u5OyciIiIiIiIi4gSbTm9CuZnl0HRxUxP0y5w0M+Y2mIvNHTdHetDv+HGgWTPglVesoB8T8nibsaegSXn27QkTAA+PMJT4ZM86lvisXFklPkVERCTMFPhzYWkSpTE16f3hb77Ienk5BP6Y8SciIiIiIiIiEkucvHESLZe0RNkZZbHx9EYkipsIQyoNwcFuB9GqaCu4u0XeZa6bN4H+/YF8+YDvvrOCeozPHT4MfPstsHixVXnSETP9uD5MrUqnTgX+/PNJiU93XboTERGRsFGpTxfm5uZmyn3uurAL3le94emZT4E/EREREREREYlVbj24hc/++gzj/h1nKiK5wQ1tirXBsCrDkClppkh9bh8fYOZMYNAg4OJFax0T8caNA4oVe7Idg3v161tt+c6ds3r6sbxnqDP97OpO7FlHo0YBOXNG7IsRERGRWEGBPxfHRtQM/B29dhR5vYANCvyJiIiIiIiISCzg6+eLWTtn4cO1H+LCnQtmXcXsFU0fvxIZS0T6869ebfXx27vXup0nDzBmDFC37tNlPYlBvkqVwvlkdonPu3etB+nS5YX2XURERGIvBf5cnGcKK9Dnfc0bdXID3rD6/vkfPYpgvmOKiIiIiIiIiER7vx/9HT1X9cTuC7vN7VypcmF09dGon7e+qZAUmfbvB3r3BlassG6nTAl8/LEVi4sXL5Ke9IsvgPXrVeJTREREXpgCf9Eg44+Y8ZctG3DC3RPwA3D6NPDgARA/vrN3UUREREREREQkQhy4fAAfrP4Ayw8tN7dTJEiBjyp+hLdLvY14HpEVdbNcvmwF+L78EvD1BeLEAbp1s8p8pkoViU/Mqk52ic+RIwHPx9WeRERERMJBgT8X55XSKyDjL25cIFG2NLh1PAmS+t8Gjh8H8uZ19i6KiIiIiIiIiLyQK3evYMj6Ifhi6xfw8fNBHPc4ePultzG44mCkTpQ6Up+b86onTwY+/RS4ccNax359bLPH8p6Ryi7xeecOULEi0LVrJD+hiIiIxHQK/Lk4z5SeARl/fv5+8PRyx9HjniiK3daMMAX+RERERERERCSaeuj7EJ9v/hxD/xyK6/evm3X18tQzZT3zponcax7+/sCSJUCfPtYlFipWDBg3DqhcGVGD6YXr1gGJEqnEp4iIiEQIBf5cXLbk2eDh5oH7Pvdx/vZ5eHllwtHfHQJ/IiIiIiIiIiLRjL+/P3468BP6rOmDI1ePmHVF0hfBuBrjUNWzaqQ//9atQM+ewIYN1u2MGYFhw4DWrQEPD0SNY8esqCN99hngZVV9EhEREXkRCvy5uLgecZE9RXaT8ed91dsE/rzx+IugAn8iIiIiIiIiEs1sP7cdPX/rifUn1pvb6ROnx7Aqw9C2WFt4uEdu1O30aWDAAGDePOt2woTABx9YS5IkiDqOJT5ffRV4550ofHIRERGJyRT4iyblPk3g75o3PD0rYC0eN3n29nb2romIiIiIiIiIGCdvnMTlu5dDvN/H1wdTt07F3F1z4Q9/JIiTAL1e7oW+5foiafykkbpvt28Do0dby7171rpWrawsv6xZEfWmTwf++MOKPM6cqRKfIiIiEmEU+IsGvFJ6YQ3WmOBfQy/gazvwp4w/EREREREREXGRoF/eKXlNq5LQaFm4JYZXHW5anER2Yt2cOcDAgcC5c9a68uWB8eOBl16Ccxw/bqUYkkp8ioiISART4C+aZPyRyfgrARx9HPjzP3oUbuxE7ebm5D0UERERERERkdiMmX6hCfoVTV8U0+tNR+nMpSN9n9ats/r47dhh3fb0BEaNAho1cuKlFF7HYYlPpiBWqAB06+akHREREZGYSnUEoknGHzHjL3ly4Haq7PCDG9xYB/7SJWfvnoiIiIiIiIhIqMx4bUakBv18fYGdO4GGDYHKla2gH6+ljBkD/Pcf0Lixk+dPs8Tn2rUq8SkiIiKRRhl/0YBXKivw533V6umXxSs+Tl3Niuw4aZX7TJfOyXsoIiIiIiIiIvJ8bhEYdbt7F9izxwr0McDHn7t3P+nh5+EBdOkCfPQRkDYtnO/ECaB3b+vfI0YAuXI5e49EREQkBlLgLxqV+rx09xJuPbgFL6+kOLrF0wr8eXsDZcs6exdFREREREREJBbj9YrIdOGCFdhzXA4dsnr4BZUoEVC9OjB8OFCgAFwDS3y+9ZZV4pNNBt9919l7JCIiIjGUAn/RQLL4yZAmURpTL5/lPr28ipo+f5Wxzsr4ExERERERERFxgke+jzB923QMXDswQh6PgbwjR54O8p07F/z26dMDxYsDxYo9WZhIx2w/l/LVV8CaNUCCBCrxKSIiIpFKgb9o1OePgT/va97w9CwKb1hZgAr8iYiIiIiIiEhU8/f3x4rDK9B7dW8cuHwgXI/Bkpx79z5dqvPOnae3ZYXQPHkCB/i4ZMgA18cSn716Wf9mGmLu3M7eIxEREYnBFPiLRuU+N53ZZPr8lfYCVivwJyIiIiIiIiJOsOfCHvRa1Qurj642t1ml6K3ib+Gzvz977u/OmQuM3W0F+Q4cCL5UJ5PiihQJHODj7cSJEf2wxGfHjlaJz3LlgO7dnb1HIiIiEsMp8BeNMv6IpT6bFQW8Yd32P3oUEdcWW0REREREREQkeBduX8DgPwbj6x1fw8/fD/E84uG9Mu9hQIUBuHr3Bj5bPwGIcz/kB3iUAJPGpwFuPFmVJs2TUp32TybExYkpV6xmzABWr35S4tPlapCKiIhITBNTvkbFiow/YqnPzJmBM/E8gYcAzpwB7t+3vkCKiIiIiIiIiESw+z73MX7jeAz/azhuP7xt1r1e4HV8Vu2zgOsVO/5NDkw+CCS6HPID3U2DisWyoUaNJ5l8GTNaZTxjpJMngZ49rX8PG2bVKhURERGJZAr8RRNeqZ5k/LH/c7KcqXHzYFIk878FHD8O5Mvn7F0UERERERERkRjWx++7fd+h35p+OHHjhFlXKlMpjK85HuWylQu07blzAG5ks5Zn6NwZaN4cMZ9d4vPWLeCVV4AePZy9RyIiIhJLuDt7ByRspT75RdvHzweeXm44qj5/IiIiIiIiIhIJ/j39L16Z+Qqa/9DcXIvIkiwL5jecj3/f+vepoB9jXBs3hu5xmeEXK7Cs56pVKvEpIiIiUU4Zf9FExqQZEd8jPh74PsDJGyfh5eVpAn/FsEuBPxERERERERGJECeun0C/3/th4d6F5nbiuInRr3w/9Hy5JxLFTfTU9jduAB06AD/88OzHZTnPLFmAChUQs61ZA3TtCpw9a93+9FMgb15n75WIiIjEIsr4iybc3dwD6uaz3KenJ+ANKwsQ3t7O3TkRERERERERidZuPriJAb8PQN4peU3Qzw1u6FC8Aw6/exgfvvphsEG/bduAEiWsoF/cuEC7dlaAL2jPPvv2hAkxPPGNqY/9+wNHjgB37wJlygDvvefsvRIREZFYRhl/0azP3/7L++F91RteXtWwQqU+RUREREREROQF+Pr5YsaOGRj0xyBcvHPRrKucozLG1RyHYhmKhRjfmjoV6NkTePgQyJED+O47oHRpoG5dq53d6dNPtmemH4N+jRpFwQvizv38M7BnD6Lc4cPA1q1Pbr/1VgyPdIqIiIgrUuAvGvFMYQX6vK95o7wnAnr8+R89iiCT6UREREREREREnmm192r0WtULey5aQbLcqXJjTI0xqJenHtyCpu05lPbs2BH4/nvrdv36wKxZQMqU1m0G97huwwbg3Dmrpx/Le0ZJ/OvmTaBTJysK6Wx8/6ZPt+qghvBeioiIiEQGBf6iWcZfQKnP8k8CfybjjzPa9EVSRERERERERJ5j/6X96L26N1YcXmFup0yQEh9V/AhdS3VFPI94If7e9u3AG29YHUfixAFGj7ay+4JejmCQr1IlRK2dO62dY9Ydd655cyBhwqh7/lOngF9/fXKb12m2bAFWrQJq1oy6/RAREZFYT4G/aMTu8ceMP353fZQxO3zPucODdeMvXgTSp3f2LoqIiIiIiIiIi7p89zI+Xvcxvtz6JXz9fRHHPQ66leqGQRUHIVXCVCH+HmNYX35ptatjac9s2YBFi6wWdk7HnWNmHSOQDx4AWbNaGX8vvxy1+8A3gxFPX98n63l70CCgRg1N1hYREZEo4x51TyUvyivlk4w/f39/ZPWKh1PIat3J6XYiIiIiIiIiIkE88HmAsf+MRa5JufD5ls9N0K9+3vrY9/Y+jK81/plBP1bPZPLc229bQb/XXgN27HCRoN+tW0DLlkCXLlbQ73//s3YuKoN+xKw+Zvc5Bv2It+2sPxEREZEoosBfNJIzZU7z8+aDm7hy7wq8vIKU+xQREREREREReYyThpfsX4KCUwua0p43HtxAsQzF8Hvr3/FTs5+QJ3We51bPfOklK4GO1TPHjgV++glIFXKcMOrs3m3t3LffWpl1o0YBS5cCqVNH7X4w249Zfe4hXGLjet7P7URERESigEp9RiMJ4iRA5qSZcebWGXhf9YanZxoT+KuCPxT4ExEREREREZEAp26cwps/vok/T/xpbmdIkgHDqwxH66Kt4eHu4fLVM5+5czNmAO++C9y/D2TJYu3cK684Z3+YBnnyJODnF/z9XM/+f9wufvyo3jsRERGJhRT4i2a8UnmZwB/LfXp5lcE+ZfyJiIiIiIiIiANfP180/6E5/j71NxLGSYjer/RGn3J9kCReklBVz+zc2Uqko7p1gTlzXCTL7/Ztq6znggXW7Tp1rJ1Lk8Z5+8RgHst5XroU8jbp0inoJyIiIlFGgb9o2OePs/W8r3mjmhewFFbfPwX+RERERERERIQmb55sgn4M9G3rtO25JT0dq2e+/jpw6JBVPfOzz4CePUOuYhml9uyxdu7gQWvnhg0DPvjANXaOKZFcRERERFyAC3w7krDwTGll+DHw5+n5pMefv7e3k/dMRERERERERJzt8JXDGPD7APPv0dVHhyrox+qZX30FlCljBf1YPfPPP4HevV0grmaX9ixd2gr6Zc4MrFsH9O3rAjsnIiIi4nr0DSkaZvwRS32mTQtcTGwF/tzOngXu3XPy3omIiIiIiIiIs/j5+6H90va453MPVXJWQeeSnUNVPbNVK6BTJ6tlHqtn7tzpvJZ5gdy5A7RpA7z1lrVztWoBO3YA5cs7e89EREREXJYCf9E14++qN9zcgBSeqXADyaw7jx937s6JiIiIiIiIiNNM2TwFf538C4njJsaM12bAjRcOnlM986WXrJZ5rJ45ciSwbBmQOjWcb+9eoFQpYN48K7Nv+HDgl19gZkGLiIiISIgU+ItmvFJZGX9nbp3BvUf34JXLLaDcp/r8iYiIiIiIiMROR64eQb81/QJKfOY4dQto1MiK5rFK0HOqZ65fD/Tp4yLVM2fPtnZu/34gUybgjz+A/v1dZOdEREREXJu+MUUzqROmRrL4Vobf8evHTZ8/b1jBQAX+RERERERERGJnic8OSzuYEp+Vc1RGZ683gNdeA378EejXD8iaFahdG1i0CLcv33+qeiZLe5Yr5yKlPdu2Bdq1s9qZ1KhhlfZ89VVn75mIiIhItKHAXzTDMh0B5T6vecPLC08y/ry9nbtzIiIiIiIiIhLlPt/8Of488adV4rPe13Bv195qB5Ijh9UPz88PWLkSaNoUPukzocy8d1DGfQtGDPc31TPTpHH2KwDw339Wlt+cOVZm36efAr/+CqRL5+w9ExEREYlWFPiLhrxSWhl+R68dDRz4U8afiIiIiIiISKzifdUb/X63SnyOqj4KOWcuAZYuBeLHB374AdiwATh0CLvqDsRptyxI4XcN72Aq/vUrjX7zC8F97Gjg3Dnnvoi5c61+fgz+ZcwIrF0LDByo0p4iIiIi4aBvUNE48Mcv9yz1aQf+/BX4ExEREREREYl1JT7vPrqLSjkqocv9QlZpT5o4EShRwqqeOSw3ii3/FNn9j6P/S6txv3FLIEECK9DGxn4sBVq3LrB4MfDgQdS9gLt3gfbtYWqP8t/VqlmlPStWjLp9EBEREYlhFPiLhhxLfWbPDhx3s0t9HrU6dIuIiIiIiIhIjDd1y1SsP7HelPic9coouDdrDvj6Ai1bAp06PVU985NhHhi2qRoSLJ4PnD8PTJ8OvPKK9Tus+fn661bGXbduwLZtkXuNYf9+a+dmzbJ2buhQqxxp+vSR95wiIiIisYACf9GQV6onpT7jxgX8s2WHL9zhdv8ecOGCs3dPRERERERERCIZrwn0XdPX/HtU5RHI8c5A4OxZIH9+4MsvMXeeW6DqmX/8AQwY4FA9M3lyoGNH4O+/gYMHrTszZwauXQM+/xx46SWgSBFg7NiIv9Ywb571+Pv2ARkyAGvWAIMGAR4eEfs8IiIiIrGQAn/ROOOPX/JZ1iN7rrg4iWzWnd7ezt05EREREREREYmyEp8Vs1dEl9+uAKtXA4kS4d68xWjfPUlA9czq1YGdO4FXX33GA+bJAwwbBpw4Afz2G9C8uVUKdO9eoHdvKyD42mvAkiXAw4fh33Hu0FtvAa1bW/+uWtXaucqVw/+YIiIiIhKIAn/RULbk2RDHPQ4e+D7A2Vtn4eX1pM8f1OdPREREREREJEb7cuuXWHd8HRLFTYRvkrWHO8tkAjgzeBpKtSkQUD3z00+t6pnp0oXygZlxV6MG8M03wLlzJnMQZctapUCXLQMaNwYyZQJ69LB68YWlFOiBA0CZMsCMGYCbG/Dxx1aQUaU9RURERCKUAn/REIN+2ZNnD8j68/RU4E9EREREREQkNjh27Rj6rO5j/j25cD9k6tLbBOAOV+qIPEPfDKie+fvvwMCBDqU9wypFCqBzZ2DjRqsfX79+VtDvyhVg0iSgRAmgWDFg/Hjg4sWnf5/lOwsUsH4ykMjSnswgZKCP2YkffaTSniIiIiKRQIG/aF7u0/uqtzL+RERERERERGJRic87j+6gcpYKaDdqFXDpEk6mKobC6yYFqp5ZqVIEPnG+fMCIEcDJk8CvvwJNmwLx4wO7dwM9e1qlQBs0AH76CXj0yMoEZM9ABgxZNrRlS+DOHaukJ3eOOykiIiIiMTvw9/DhQ9StWxebNm0KcZt169ahfv36KF68OOrVq4ffOX0tlvJK6RUo488b1m0F/kRERERERERipmlbp+GP438gYZyE+GFXfrj99RduuSdDlavf46FbAgwZEsnVM5mhV6sWsHChVQr0iy+A0qUBHx/g55+Bhg2tIGCjRsCWLdbvXL5s/Rw82Mr0YzqiiIiIiMTswN+DBw/Qs2dPHD58OMRtDhw4gG7duqFx48b46aef0KxZM/To0cOsj428UlmBPu9rgTP+/I54O3nPRERERERERCSiHb9+HB+s/sD8+7v4byLl5Onm3239ZuJ2+lymoiZja1FWPTNlSqBLF4ATuFlftE8fK6h36ZKV+ecoTx6rp59Ke4qIiIjE/MDfkSNH8MYbb+Aky0U8w/Lly1G2bFm0bt0a2bNnR8uWLVGmTBn8yhITsbnU5zVvJE8OXH982/38OZjaHiIiIiIiIiISI/j7+weU+GycoBSqfLjYrJ+AHrhepbGpnlmlihN3kL38Ro4ETp0Chg59+v5Dh4BVq5yxZyIiIiKxjtMDf5s3bzYBvO++++6Z2zVs2BC9e/d+av2tW7cQ20t9UiqvlLiO5Nadx487c9dEREREREREJAJN2zYNa4+tRTL/BPjok/tI/OAa/kUZ3PpwlImnuUz1TGb0LVv2dGYfbw8aZPX+ExEREZFIFQdO1qJFi1Bt58V6lg5YFnTjxo2m5Gdszvi7fPcybj64Ca9cyXB0qydKYIfV54+z7UREREREREQkxpT4HPFVKRS+swFX3VLBZ/4iDGoRDy6FUUi7t58jX19rPe+vWdMZeyYiIiISazg98Pd/9u4Duopya+P4k0qAQEjovYTemxQBRZCuELyKggIWiiKggA1UQLEhYAEUAUVBBZXeO6JIk14lQOg9SOgJaeeud4YEQk0wOWn/31rznel5D77fXZns2XvfizNnzqhHjx6qWrWqGjZseE8lMsxy4/b1+1I6b09v5cyUU8GXg7X3370qWrSKguRvBf4cQUG8RZeCpcb5htSL+QZnYr7BmZhvcKaUOt9S2ngAJM3/nz8/o5Muhl9Um99LqduxFfaBCT+qbrtCSlHM/yaZrD5XVyk6+ubjZr853rix5OKSHCMEAABIF1Jd4O/06dN67rnnrF9+hw8fLlfzi2MCnT9/Ps515l6Xr/bFc0lFv3wWyVrECvxtP7pd+fKV1j7ZWYDh//yj0HPnknt4uI3UOt+QOjHf4EzMNzgT8w3OlFLnW/St/rAOIE35YMFY/X5wqUqcyKBv/zhi7Yt+s6/8nmmuFCc8XDp06NZBP8PsNz0AzXkZMjh7dAAAAOlGqgr8nTx5Uh06dLDWJ0yYID8/v3u6T9asWeV2Xb35mDdlfXx8UtSD/N2UyFFC606s0/Erx1WjXEb9cjXw53n0qDx9rvb7Q4qTWucbUifmG5yJ+QZnYr7BmVLqfIsypfMApFkjfzqo/v/0UUZJ037yUxYdlx58UK4fvK8UyQTzTDnP4ODbn5MrF0E/AACAJJZqAn/mDdtOnTpZmXom6JczZ857vpd5WL/xgT1mX0p6kL8bfz+77+H+s/vVrpJLbMaf6fGXmr5HepQa5xtSL+YbnIn5BmdiviG9z7eUNJbrXblyRe+9954WLVokLy8vPf/889ZyK4sXL9Znn32mEydOqHTp0nrnnXdUrly52Pt8+umnmjdvnrXdqFEjvfXWW8qUKZNTvw/gbGFh0qu9HBp9qbPkf1GjJ+dS+YvHpdy5pUmTJPcU/KecggXtBQAAAMkm4XUynSg4OFhh5jdeSaNHj9ahQ4c0ePDg2GNmuXDhgtIrf1878BcUEqT8+aUjHnbgzxG0jx5/AAAAAJKFCdZt375d48eP14ABAzRy5EgtWLDgpvP27NmjPn36qGvXrpo5c6bKlCljrYeGhlrHzXV///23xowZYz0Prl+/3goSAmnZ3r1S7drS6L+/lfwX6/lN7mq/45TdH88E/fLmTe4hAgAAIIVL0YG/unXrxr7duXDhQisI+MQTT1j7Y5YPP/xQ6VUxXzvQF3QmyHoGcCtaSJFyk+uVMOnEieQeHgAAAIB0xlRqmTx5st5++20rc89k6ZnKLT///PNN565cuVLFixdXQECAChUqpN69e1svd+41kQ9Jf/zxh5588klVqFBBFStWVNu2bbVmzZpk+FaAc0yeLFWtKm3ef0guTfuo/EnpmwVXM3vfe0966KHkHiIAAABSgRRVHyIwMPC227d6QzS9iyn1eejcIUVERahwcQ8d2l1IxbRfCgriTUAAAAAATrVr1y5FRkaqSpUqsfuqVaumb775RtHR0VbrhhjZsmWzgnwbNmywzp82bZq8vb2tIGDMcfMC6KOPPmptm9KhJisQSGtMoaPXXpO++spsOZStR2dFOi5ozvSM8rgSKjVpIvXrl9zDBAAAQCqRogJ/SJg83nnk5e6lsMgwK/hXrJi/1efPCvzt22dSJpN7iAAAAADSEZOx5+vrK09Pz9h9OXLksPr1nT17Vn5+frH7mzdvrmXLlqldu3Zyc3OzgoKmpKePj491/I033lCPHj1Us2ZNa7tkyZIaNWpUMnwrIOmYd3bbtJE2brS3m7/znea5LdJv01xV+ESoVKCA9NNPdqlPAAAAIB4I/KViri6uVrnPncE7rT5//v524E9aagf+AAAAAMCJTH++64N+Rsx2eHh4nP0hISFWoLB///6qVKmSJk2apL59+2r69OnKnj271eM9b968+uSTT6wswvfff99a/+CDDxI0JofDYS03bl+/D0gqd5pvU6ZInTpJ58+7KHt2h4Z9e0g9/umtl/6SntgWLYe7u/TLL1L27OZGyTJ+pC787xucifkGZ2K+wdkcKXDOJWQsBP5SOX9ffyvwty9kn/z9pZVW4E8E/gAAAAA4XYYMGW4K8MVse3l5xdk/dOhQK4vv6aeftrYHDRqkZs2aaerUqVYWoOkT+MMPP1hBQeOjjz7SM888o549eypXrlzxHtP58+fjlBg1D8ymF6Hh4nK1fxqQRG41365ckd59N6PGjs1gbdeqFamxYy/q1fUvqOT+C/pikTnPobCBA3WlXDnp3Llk/Q5IPfjfNzgT8w3OxHyDszlS4JwzrRPii8BfKmcy/oygM0GqV0yaILvvn2PfPqWM6QgAAAAgvcidO7eVyWcy9NxNttLV8p8m6Jc1a9Y45+7YsUPt27eP3TbBudKlS+vYsWPat2+f9aBttmOULVvWetg9ceJEggJ/5ueaUqI3vilrSoqmlId4pE1RUdKffzq0b5+HihXLpAcecNHBg9KTT0obNthz7803HRo0yE0Ttk3Vhl1LtWmy5BnpkCMgQF59+8qLOYoE4H/f4EzMNzgT8w3O5kiBcy7K/HIZTwT+0kDGn7Hv7D4VraurpT4lx94gAn8AAAAAnKpMmTJWwG/z5s2qXr26tW/Dhg2qUKFCnKw7wwTvgkyDs+vs37/fOjcmsLd3716VMxlPVlETu6pJAdPzLAHMg/qND+sx+1LKQzzSnmnTpFdekY4cMXPM29pnKnaGhkrm5XGzPmGC6XXpoiPnj6j3wl6aMEMqcta84VtMLt9/T18/3BP+9w3OxHyDMzHfkN7nnEsCxsFvkamcv59/bMZfpkzS5dx24M/15An7aQIAAAAAnCRjxowKCAjQwIEDtXXrVi1ZskTjxo1Thw4dYrP/wsLCrPU2bdrot99+04wZM3Tw4EGr9KfJ9mvdurXy5MmjevXq6d1339X27du1bds2a71Fixby8/NL5m8J3D3o9/jjJugXd/+//9qP6aVKSZs2maCf/TZ559md1fn3C2oVKDlMT8zJk6Vs2ZJr+AAAAEjlyPhLK6U+Q4KsB4YcJXwVcjKbfHXWvC4rXX07FgAAAACcoW/fvlbgr2PHjvL29laPHj3UuHFj61jdunX18ccf67HHHlPz5s116dIljR492irfabIFx48fr+wmFUrSsGHD9Mknn6hLly7W260NGzbUm2++mczfDrgzU4HJZPpdrQ51S5cuSfny2es/bP5BF5Yu0CdL7W2XL7+UqlZ1zmABAACQJhH4S+WKZCsiF7noYvhFnb58WsWK5dS+v4qpmjaaWjgE/gAAAAA4Petv8ODB1nKjwMDAONtPPPGEtdyK6adhgoRAarJixc2Zfjcyx815xase0YdTX9EfUyT3aEnt2klduzprqAAAAEijKPWZynm5eyl/1vyxWX/+/lKQ7PKfVuAPAAAAAAA4xfHj8Tvv2DGHXprVRaMmXVD+C5KjdGlp9GjTvCWphwgAAIA0jsBfGuDve63Pnwn87ZNd/lNBQck7MAAAAAAA0pG8eeN33lbX8ar63Xw12idFZ8oolylTJG/vpB4eAAAA0gECf2ko8LcvZJ+KFbsu8EfGHwAAAAAATlOvnpTfLspzSyahL2+po/pnSXcNWG7vc/1mNG06AAAAkGgI/KUBxXyLxSn1GRP4iw4i8AcAAAAAgLO4uUm1a98+6OeQQ5We7Kixky5Zf5CJfuF5qX17Zw8TAAAAaRiBvzTA3+9axl/OnNKJjFcz/vbvl6JNh3AAAAAAAJDUNm6Upk+317Nnj3usQAHplW9+UL8flirXZSmsXCm5jhiZLOMEAABA2kXgLy31+AsJst4g9CxeSJFyk+uVsPh3FgcAAAAAAPcsPFx67jkpKkp6/HHp5Elp2TKHxo69ZH2u3HpMRSe+pHqHpCuZMshr+mwpY8bkHjYAAADSGPfkHgASr9TnsQvHFBoRqiLFM+rgtsLy1z67z9+dGgwAAAAAAID/7KOPpK1bJd8ih9R14GltOSVlLeVQifwXlTlzZn01oKM++eOKda779+OlEiWSe8gAAABIgwj8pQF+Gf3kk8FH566c0/6z+1WsWFmrz19s4M90FwcAAAAAAEli82bpww8l+RzSxedKqdGUMGt/wyBp+Hzpw3rSiPn2uSNruaplk9oqlLxDBgAAQBpFqc80wMXFJTbrL+hMkPz9ZQX+LCbwBwAAAAAAkqzE57PPSpGRUoNHTivCYQf95JA+WiqVPS2NniP5hUlr80u9H47W6cunk3vYAAAASKMI/KUR/n7X+vwVK0bgDwAAAAAAZ/j4Y2nLFil7dumtt67tbxwk1Thmr3tHSBc8pDZPSBHUXgIAAEASIvCXRvj72oG/fSH7rIy/INnbjqCgZB4ZAAAAAABpkwn4ffCBvf7VV3bwz+KQBi2TolyunXs8i3TIJ1mGCQAAgHSEwF8aEVvqMyRIhQpJB1zs7ei9ZPwBAAAAAJDYIiKulfh87DGpTRspIioiTrafm+Pa+SXP2PsBAACApETgLw1m/Hl6SuEF7MCfW/BJ6dKlZB4dAAAAAABpr8Tn5s2Sr59DL72/Sa8s6KkmPzWxsv0+XGp9xBHpYmcB3nQAAAAASERUlk9jPf72h+xXtCNauUpm05nDvvJTiLR/v1S+fHIPEQAAAACANFPi8/1hp6RaPytLyx/UaMrW2GMmq6/68ZuvcXfYWYBk/QEAACApkfGXRhTIWkDuru66EnVFR88fVbFi0j7ZWX/aR7lPAAAAAAD+q/CocE3ZPkMPjgpQ1Cv5paa9dSh8qzK4ZdCT5Z7UiKbDNWrO7a+PUkzWH2l/AAAASBpk/KURJuhXJFsR7T2z1yr36e9fUEHyV3VtkIJ4nRAAAAAAgHu15cQW/bD5B/207Sedvnxaymvvr5KrhjpXf1ZPlX9Kvhl9dXz5HOU+e/v7uEkqdF4Kd8/qtLEDAAAgfSHwl4YU8y1mBf6CQoJUrNiD2kvGHwAAAAAA9yT4UrAmbpuoH7b8oM0nNl87cDGPtKW9Brd9Vm88V/ba/gsXlLdrH3u1WgUd+eANOVxcFHr5sjJmyiSXq6dlLVhchXKVcPK3AQAAQHpB4C8N8fe1+/wFnQnS//ylRQT+AAAAAACIt4ioCM3fO9/K7puze44ioiOs/Z5unnqkREtt+eE5BS1qrFaPuuv1Z6+70JTu7NxZ2r1byp9fWRYsU5kcOeRwOHTu3Dn5+PjIxSUm9AcAAAAkHQJ/aTDwt+/sPvlXv9bjL3rvPpo5AgAAAABwG9tObtP3m7/XT1t/UvDl4Nj91fNV17OV7FKe33yeXdMWSL6+0qhRUpw4ntnx66+Su7v0229SjhzJ8j0AAAAAAn9prNRnTMafj490xqeYdE7Sgf1SdLTkSvgPAAAAAADD9OqbtG2SVcpz4/GNsftzZc6l9hXbq2OljqqQu4K1b/t26b337OMjRkh5r/b4s6xfL/XqZa8PHizdf79TvwcAAABwPQJ/aYi/39WMvxC7tKdXiYKKWO8uj/Ar0rFjUoECyTxCAAAAAACST2R0pBbsXWCV8pwVOCu2lKeHq4ceLfWonqv8nJr4N5GHm0fsNRER0rPP2p8tW0rt2l13w5AQ6YknpPBwKSDgWgAQAAAASCYE/tJgxt+/of/qXNg5Ffb30cH1hVVcQXafPwJ/AAAAAIB0aPup7Vawz5TyPHnpZOz+KnmqWMG+thXaKkemW5fnHDJE2rBBypZN+uab60p8mr5+JiJ44IBUtKj0/fc31P8EAAAAnI/AXxri7eltlSQ5demUgkKC5O9f1erzFxv4e+CB5B4iAAAAAABOE+2IVrup7fTrjl9j9+XMlFPPVHzGKuVZKU+lO15vSnwOHGivDx9+Q4nPYcOkWbMkT09p8mQ7MggAAAAkMwJ/aYy/r78V+DPlPosVswN/FhP4AwAAAAAgHRm9frQV9HNzcbNKeT5b6Vk1L9E8TinP24mMlJ57zi7x+eij0jPPXHfwr7+kt96y17/8UqpWLem+BAAAAJAArgk5Gamn3GfQGZPxJwJ/AAAAAIB06cDZA3p98evW+mdNPtP0J6erVelW8Qr6GUOHSuvX36LE56lT0pNPSlFRUtu2UteuSfgtAAAAgIQh8JcGM/4Mu9SnFCR727E3KJlHBgAAAACA80p8vjDrBV2KuKR6heqpe43uCbp+xw5pwIBrCX358l09YIJ9Tz8tHTsmlS4tjRlDXz8AAACkKAT+0hh/PzvQZ0p9mgeTw+52xl/0XjL+AAAAAADpw5gNY7Rs/zJldM+oca3GydUl/n/+iCnxGR4utWghtW9/3cEPPpCWLJEyZrT7+nl7J8n4AQAAgHtF4C+tlvoMCZKbmxRdxN52+/eUdPFiMo8OAAAAAADnlfj8uOHHKu5XPEHXDxsmrVtnl/iMk9BnAn7vvWevjxollS+f2EMHAAAA/jMCf2m01Oehc4cUERWhXCV89K/87IP79yfv4AAAAAAASEIOh0OdZnXSxfCLqluornrU7JGg63fulPr3t9e/+OK6Ep9Hj0rt2pkfIL3wgtSxY+IPHgAAAEgEBP7SmDzeeaxSJqafwcFzB60+f/tkZ/1pH+U+AQAAAABpu8Tn0v1L7RKfLe+9xGfz5lKHDtcdeOopKThYqlRJGjEiycYPAAAA/FcE/tIYFxeXa+U+zwRZgb8g2VmACgpK3sEBAAAAAJBEDp49qNcWv2atf9TwI5XIXiJB13/2mfT335KPzw0lPt9+W/rrLylLFruvn+nvBwAAAKRQBP7SIH8/O9C3L2SfihUj4w8AAAAAkA5KfM62S3zWKVhHPWokrMTnP//ELfGZP//VA7NmSZ9+aq+PGyeVSFgwEQAAAHA2An9pULFsVzP+QuyMPwJ/AAAAAIC07NuN32rJviXycvfSuFbj5ObqFu9ro6LsEp9XrkjNml3Xvu/AgWsbPXtKjz+eNIMHAAAAEhGBvzQoJuPPBP6KFr0W+IvaQ+APAAAAAJC2HDp3SH0W9bHWP2zwoUpmL5mg6z//XFq7Vsqa9boSnyYK+MQT0tmzUo0a0pAhSTR6AAAAIHER+EuD/H2vlfrMlEm6mNMO/Lkc3C9FRyfz6AAAAAAASMQSn7M66UL4Bd1f8H69UvOVBF2/a5f0zjvXAoAFClw98Npr0vr1kq+v9Ntvkqdn4g8eAAAASAIE/tKgYr5XS32eCbIegjKWLKgIucs1Ilw6ejS5hwcAAAAAQKL4btN3WrxvsV3is+W9l/hs2tRet/z6qzRypL3+449S4cJJM3gAAAAgCRD4S4OKZCsiF7noUsQlnbp0SkX83XRAReyD9PkDAAAAcJ0rJuoBpNISn70X9rbWP3joA5XKUSpB13/xhbRmzQ0lPnfvljp1sk946y2pRYukGDoAAACQZAj8pUEZ3DOooE/B2HKf/v7X+vwR+AMAAABwvTp16mjAgAHaunVrcg8FiDdT3abL7C5Wic9aBWrp1VqvJuj6wMBrJT4/+0wqaB6hL1+WHn9cunhReuABadCgpBk8AAAAkIQI/KX1cp8hQSpWjMAfAAAAgFt7/vnntWbNGj355JNq3ry5vv32WwUHByf3sIA7GrdpnBYGLVQGtwz6vtX391TiMyxMatzY/P/A1QM9ekjbtkm5ckmTJknu7kk2fgAAACCpEPhLo/x9/a1PMv4AAAAA3Em3bt20cOFC/fzzz6pWrZpGjx6thx56SF26dLH2R0REJPcQgTgOnzus3ouulvhs8IFK5yidoOu//FJavVrKkkUaO/Zqic8ffpDGjbM3Jk6U8uVLotEDAAAASYvAXzrJ+AuSHQiM3huUzCMDAAAAkBJVrVpVgwYN0sqVK/Xll18qNDRUr776qurWravBgwfr6NGjyT1EwC7xOaeLzl85b5X47FWrV4KuNy383n77WonPQoVkZ/l162bvfO89qWHDJBg5AAAA4BwE/tJ4xl/QmSCrSslxLzsQGL2XjD8AAAAAt3b8+HGNGzdOw4cP17p161SkSBE99thj+vPPP60yoPPmzUvuISKd+37z91qwd4FV4nNcy3EJLvFpynqaEp+NGkkvvCDpwgW7r19oqNSkybWoIAAAAJBKUbA+jfL3u1bq01QqcfUvKu2Q3M8E2w82pqYJAAAAgHTv4sWLVknPGTNmaMOGDfLy8lLTpk01YMAAKwvQePPNN9W1a1d99NFHVgAQSA5Hzh9Rr4V2ht/7D72vMjnLJOj6ESOklSvtx+Fvv5Vc5JA6d7bTAPPnl378UXLl/WgAAACkbgT+0nipz+MXj+tyxGXlKuGj0zuyK4f+lfbvlypWTO4hAgAAAEgB6tSpoytXrqhy5cp6//33rcBepkyZbjqvQoUK2rlzZ7KMEbBKfM62S3zWzF9TfWr3SdD1e/ZI/frZ60OHXi3x+fUo6ddfJXd36bffpJw5k2bwAAAAgBMR+Euj/DL6KZtXNp0NO2tl/fn7l9c+FbMDf/v2EfgDAAAAYHn66af1+OOPq5hpDn4Hzz33nF566SWnjQu43vgt4zV/73yrxOf3rb5PcInP556zq3k+/LCd5Kf166VeV/sDfvKJdP/9STd4AAAAwImoYZEO+vyZwJ95hg+Sva2goOQdGAAAAIAU44033lBISIi++uqr2H0ms++VV17R9u3bY/dlzpxZbm7xD7YAieXo+aN6dcGr1vp79d9LcInPkSPtEp/e3ldLfJ4NkZ54QgoPl1q1knr3TqKRAwAAAOk48BceHq5HHnlEa9euve055uHziSeeUKVKlfS///0vzkMobl/uM+hMkPz9ZWX8WUzGHwAAAABI+uOPP9SxY0f99ddfsftcXFx04MABtWvXTutNZhSQnCU+53TRuSvnVCN/DfW5P2ElPo8ciVvis3Ahh/Tss9KBA1LRotIPP5gJnzSDBwAAANJr4M/0k+jdu7f2mKL7t3H58mV16dJF1atX17Rp01SlShWrubzZj7tn/F0f+HMQ+AMAAABw1YgRI9SiRQtNnDgxdl+ZMmU0c+ZMNWvWTJ999lmyjg/p24QtEzRvzzx5unlaJT7dXRPWseS118zfE0wvS6lLl6vRv1mzJE9PafJkKVu2JBs7AAAAkC4Df3v37lWbNm106NChO543b948ZciQwSpD4+/vr7ffftsqNbNgwQKnjTXVZvyFBFmNyw+42NtRuwn8AQAAALAFBQUpICDAyvK7kdm/a9euZBkXYEp8vrLgldgSn2Vzlk3Q9cuXS7/+Krm62uU+XVb+JfXtax/84gupWrWkGDYAAACQvgN/f//9t2rWrKlfzW/jd7BlyxZVq1Yt9mHUfFatWlWbN2920khTH38//9jAn3mZ8Up+O/DneviA3d0cAAAAQLqXJUsW7d+//5bHDh8+rEyZMjl9TIAp8dl1TlerxGf1fNX12v2vJej6yEipRw97vWtXqXK+U9KTT9rPwm3bSi++mDQDBwAAAJJZwmpkJAHTMyI+goODVbx48Tj7smfPfsfyoHd6gDDLjdvX70sLimWzA30Hzh5QZFSkMpbIr/AjHvKMCJfDNDowaYBwurQ635AyMd/gTMw3OBPzDc6UUudbYo2nUaNG+vLLL5U3b1499NBDsftXrFhh7W/cuHGi/BwgIX7c+qPm7plrlfj8odUPCS7x+fXX0vbt5u8G0gfvRUntnpaOHZNKlZJGj6avHwAAANKsZA/8xVdoaKg8Tdradcx2eHh4gu91/vx5uZpaH9c9MMf0CrxVeZvUKosjizxcPRQeFa5/jv6j/IVK6oCKqKT26NK2bYr08UnuIaZLaXW+IWVivsGZmG9wJuYbnCmlzrfo6OhEuU+vXr20bds2vfTSS/Lw8FC2bNl09uxZRUZGqlKlSurTp0+i/Bwgvo5dOBZb4nPggwNVLle5BF1/6pTUv7+9/uEHDvl9/q60ZImUMaM0ZYpJc02KYQMAAAApQqoJ/Jn+fjcG+cy2l5dXgu+VNWtWubm53fSmrI+PT4p6kE8MRbIV0Z4zexQcGaxSpcprn4pZgb/MJ0+aL5zcw0uX0vJ8Q8rDfIMzMd/gTMw3OFNKnW9RiVS+39vbW7/88ov++OMPbdiwQefOnbPKf1avXl3169eP89Ik4KwSn2fDzqpa3mp6vc7rCb5Hv37SuXPSA5XOqcuSTtLUKfaBUaOk8uUTf9AAAABACpJqAn+5c+fW6dOn4+wz27ly5UrwvczD+o0P7DH7UtKDfGL1+TOBv/1n96t48QZW4M9wMT080th3TU3S6nxDysR8gzMx3+BMzDek9/mWmGMxwT1T5vP6Up/XB2JS0vdG2vbztp81Z/ccq3rNDwEJL/H599/Sd99JVbRRC063kcuWIMndXRo6VOrYMcnGDQAAAKQUqSbwZ0rMjB07Nvah03xu3LhRL9KQO159/oJCgvS4v7T2auBPQUHJOzAAAAAAKca8efP0999/W1VVYjIcY0qcbt68WX/++WdyDxHpwPELx9Vzfk9rfcCDA1Q+V8Ky80z12+4vO/SSRulL117yOBouFS4s/fqrVLNmEo0aAAAASFlSdOAvODjYKjFjynk2bdpUw4YN04cffqinnnrKKkVj+v41a9YsuYeZ4jP+jH0h+1SsmhQkeztq7z5dK3YKAAAAIL0aOXKktZhnL9PXz/T5c3d315kzZ6xMwCeeeCK5h4h0VOIzJCzEKvH5Zt03E3yPn0edV5/1nfWkfpNMC8yWLaXvv5f8/JJkzAAAAEBKlGjNGrZv365Fixbp/PnziXVL1a1b13rzNKbvxOjRo62eE4899pi2bNmiMWPGKFOmTIn289KiYr7XMv6yZZP+zWpvO4L2JfPIAAAAAKQE06dPV0BAgJXx9+yzz1rlPletWqUpU6YoW7ZsKlGiRHIPEenAxG0TNXv3bKvE5/etvk9wic8Lf25SnVeqWUG/KHPtsGHSjBkE/QAAAJDu3FPG36lTp9SnTx/Vrl1b3bp1008//WRl4pk39MyD4Y8//nhPD4eBgYF33K5YsaL1UIr48/e1M/yCztilPV39i0qbJPeQ05IJ0mbNmswjBAAAAJCcTp48qUcffdRqqVCmTBnNnTvX2l++fHmrtcLkyZP1zDPPJPcwkYaduHhCPeb3sNb7P9hfFXJXiP/FpjTt6NHy6v6qikVd0TH3Qsr1+69S3VpJN2AAAAAgrWX8DRkyRPv371eFChUUHR2tb775Rvfff79mzJih4sWLWyU5kbIy/ky5lJDQEOUpmVXBymEf3L8/eQcHAAAAINmZKiom6GcULlxYR44cUVhYmLVtAoFmG0gq5gXiF+e8aD2zVslTRW/WSUCJzwsXpHbtpJdekkfUFc3WI9r96ya5E/QDAABAOnZPgb+//vpLb775purVq6eNGzfq9OnT6tChg0qXLq1OnTpp/fr1iT9S3JPMnpmVO3Pu2D5//v7SPtnBQAXZWYAAAAAA0i/zQqd5idMoWrSo3NzctHr1ams7KChInp6eCbrflStX1K9fP1WvXt1q3zBu3Ljbnrt48WKrb3uVKlXUtm1b7dixI87xn3/+WfXr11fVqlXVs2dPnT179p6+I1KuSdsnaWbgTKvE5w8BP8jDzSN+F27ZIlWrJv3yi6Lkptc0RONbz1T9xyjtCQAAgPTtngJ/ly9fVp48eaz1P//803oQrFXLfqPOrJs39pBy+PtdLfcZEqRixaQg2dvaR58/AAAAIL0z5TxNb3XzaZ7nWrZsab3o2aNHDw0ePNgK3iXEp59+avWAHz9+vAYMGKCRI0dqwYIFN523Z88eq4VE165dNXPmTCu70KyHhoZax82YzL369u2rX375RcePH9f777+faN8bKavE57sPvKuKuSve/SLz94YxY6SaNc0k0mW/AqqnP/WV12sa9vk9/YkDAAAASFPu6bfiIkWKWFl9ERERWrhwoWrUqKEMGTJYx2bNmmUdR8rr83dTxh+BPwAAACDdu++++zRlyhQr887o37+/mjRpon379qlp06Z65513EvSSqOkJ+Pbbb6tcuXJq1KiRVRXGZO7daOXKlVariICAABUqVEi9e/dWcHCw9u7dax0fO3asOnfubI2lZMmSeuONN7R7925FRUUl4rdHcjEvDL809yWdCT2jynkq6626b8WvtKfpN9m1q0ktVWST5qqZYbNW63717WtK1Tpj5AAAAEAaDPyZhy/z1mbt2rV1+PBhPffcc9b+xx9/3Ar8vfDCC4k9TiRCn7+gM3bGX0zgzxFE4A8AAABI777++mt5eHioVatW1rZ5qXPQoEGaO3euPv74Y/n4+MT7Xrt27VJkZKRVujNGtWrVtGXLFqs//PWyZctmBfk2bNhgHZs2bZq8vb2tIODFixe1c+dOK3B4fYByzpw5VilSpH6/bP9FM3bNkLuru35oFY8Sn1u3StWrSxMnSmYODB6sgVVna/vx7DLvHr/+urNGDgAAAKRs7vdy0SOPPKK8efNaD2gm269y5cqxD2Km78IDDzyQ2ONEYmT8nd2n/Pmlw+7FpEgpcvc+xbN7AgAAAIA0avTo0VZ2nr8pD/IfmYw9X1/fOH0Bc+TIYfX9M/35/Pyu9V9r3ry5li1bpnbt2lnBPFdXV2ssJtD4zz//WOecOXNGTz31lI4cOaI6depYmYRZs2ZNcGbZ9e0oYrZpUZF8Tl48qe7zu1vrb9d72yrxedv/Hmb/d99JPXvKJSxMDvNQ+8sv2pu7joaUt0/5/HOHvLzsU1Ma5hucifkGZ2K+wZmYb3A2RwqccwkZyz0F/mLe2jRLDPNWp+nHYN7aRMrN+DMvRkYULCbtl9yOHJBMmRzemAUAAADSLVNuc//+/XrwwQf/871Mf77rg35GzHZ4eHic/SEhIVag0JQWrVSpkiZNmmT185s+fbouXbpknWN6+r322mvWc+aHH35olfv85ptvEjSm8+fPW0HF6x+YTUlSw8XF5Z6/K+6N+ffvPLezVeKzQs4KernCyzp37tytT754UZn69JHnb79ZmxENG+ry6NFyZM+u7k9GKjzcQw0bRujBBy/pdrdIbsw3OBPzDc7EfIMzMd/gbI4UOOdurKCS6IE/E+QzD1uFCxfWo48+qrVr11qZfuaBymQADh8+PEHlYJC0/P3sN3cPnz+s8KhweZfKryv7PZUhMlw6coRGCAAAAEA69tBDD+mzzz7TihUrVKpUKWXKlCnOcfOg+/LLL8frXqZM6I0BvphtL5OSdZ2hQ4davfuefvppa9uUFzV9BqdOnWo9VxpdunRRw4YNrXUT+DP9AE+ePKncuXPH+/uZDMHry4PGvClrnllTykN8WnXo3CGdvnw6zr5FQYs0J2iO3Fzc9EmjT5TDL8etL96+XWrTRi67dslh/vsNGiT3N95QVldXzZkjLVrkIg8Ph0aOdFe2bCn37w/MNzgT8w3OxHyDMzHf4GyOFDjnEtLr/J4Cfyaw991336lfv37W9gcffGC9gWkeBr///nsNGzbMejMTKUPuzLmVySOTLkdc1sGzB1W0eAkdUBGV0m5p3z4CfwAAAEA6Zvq3GytXrrSWGyUk8GcCciaTz7ws6u5uP26arD4T9LuxROeOHTvUvn372G2TlVe6dGkdO3ZMOXPmtPYVM03KrypatKj1eeLEiQQF/sz4b3xYj9mXUh7i02rQr/RXpRUWGXbL41GOKP3vt/8psHugCvkUunbA/JHlhx8kM+dCQ6V8+eTyyy9SvXrW4bAwqVcv+9RXX3VR6dJK8ZhvcCbmG5yJ+QZnYr4hvc85lwSM41q9kwQwTd579+5tvZkZFBSkPXv26KWXXlKHDh3Uq1cvq08DUg4zIWLLfYYEyTw779PVB2gT+AMAAACQbu3ateuOS0y/vfgoU6aMFfDbvHlz7D7TG75ChQpxym0auXLlsp4nr2dKjhYoUED58uWzjpufH8Oca55tzDGkfCbT73ZBvxjmeJyMQFPi9dlnpeeft4N+TZpIZi5dDfoZn31m5oKUN6/07rtJ+Q0AAACA1OmeAn+nTp2yejAYy5cvtx7gHnjgAWs7T548unDhQuKOEv+Zv69/bJ8/f38CfwAAAAASX8aMGa1ynAMHDtTWrVu1ZMkSjRs3znpJNCb7L8ykbMlUcWyj3377TTNmzNDBgwet0p8m269169ZWgO/ZZ5+1qs2YLEQTADT3fPjhh2OzAZHG7Ngh3XefNGGCSf80tV2lefOk6/57Hz5s7zaGDJGyZEm+4QIAAAAp1T2V+jRvXh45ckTVq1e3svvMW51+fn7WsU2bNlnBP6TMwN++kH16sJj0R0zg74Y3bAEAAACkL3379r3rOR9//HGC7meCdB07dpS3t7d69Oihxo0bW8fq1q1r3euxxx5T8+bNdenSJY0ePdoq32meK8ePH6/s2bNb5z7//PO6cuWK3njjDV2+fFkNGjSw7os0yJT27NbNzvIzqXyTJkkPPnjTaa+9Jl2+bOaR1K5dsowUAAAASJuBv0ceecR6WJs9e7ZVtqV///6xzdYnTZqkF198MbHHif8oTqnPelKQ7EBg5O599zYJAAAAAKQJa9euvWmfCbSdPXvW6uVuynQmNOtv8ODB1nKjwMDAONtPPPGEtdyKyfrr1q2btSBtyhQuFX51oPTbbHtHo0bSTz+Zt41vOvf336XffrOTAUeMMPPD+eMFAAAAUoN7ivm8+uqrypQpk9atW6c+ffqo3dVX7bZt22a9lcmDWcrj73ct4y9TJulCjmLSaclBqU8AAAAgXbtdj3bTU6979+5W6U4gsZU5JU2eLGUPnm1H8957T+rXz16/QWSk1LOnvW7eM65c2fnjBQAAANJ04M+8edm1a1drud4vv/ySWONCEmX8mcCfw+GQq39RK/Dnce5f6dw5yccnuYcIAAAAIAXx9/e3ynSOGDFCLVq0SO7hIJVrGCQNny/1bCblvSh9M0fKHCFF5Mouj1+nSPXr3/bar7+Wtm+XTBXYQYOcOmwAAAAg1bnnKo9nzpyxmrT//fffOn/+vHx9fa2ef6YBe0xPBqQcRbIVkauLqy5FXNLJSyeVr1QenVqbU7kULO3fzyuTAAAAAG5ievQdPXo0uYeB1M4hfbRUKntamjRFyhlq715SVMo1Y5IqVrx90O/UKelqdxF99JHk5+ekMQMAAACp1M01NOLBNF5v3bq11Xg9Q4YMKlu2rNzd3fX9999bZWBOnjyZ+CPFf+Lp5qmCWQvGZv0VK3atz5927kzewQEAAABINseOHbtpOXz4sNavX6/hw4dbmX9AQuXIlMN6DjUaB0k1jtn7TdAvWlL/+lKr5zIoW+FSd7xP3752kZqqVaUXXnDGyAEAAIB0mPE3ZMgQK9A3b948FSxoB5MM83Boevx9/vnn+uSTTxJznEikcp8Hzx1U0Jkg+fvfrz/1gGprjd08/WqfRgAAAADpS4MGDax2DjcyLQK8vLw0cuTIZBkXUrdCPoX0cLGHNW/3PH29IqscOi8zyxySwv0LK+DnqeqUOad13u38/bc0bpy9bqahm5vzxg8AAACkq8DfX3/9pX79+sUJ+hlm++WXX9ann36aWONDIvL39dfvB35XUEiQmvhLA9VZb+pTacEC6cABqUiR5B4iAAAAACf76KOPbgr8mW1T5rNmzZrKkiVLso0NqdeBswe0YO8CK9vP/+D52P1mpnkFHVTVbaelJtVue310tNS9u73eoYNUu7YzRg0AAACk08BfVFSU1dPvVvz8/HTx4sX/Oi4kAX8//2ulPu83pT6La7EeViPHEunbb6UPPkjuIQIAAABwsscee0zR0dHavXu3Spcube0LDg7Wzp07lTFjxuQeHlKp4WuHW/Pqy5VZJJeLJoX02kGTuvfuu1LjxibKfMvrv/9eWrdOMnHnwYOdN24AAAAgXfb4K1WqlGbPnn3LYzNnzlTJkiX/67iQRKU+DZPxlyuXlDmzNFpd7YPffSdFRCTvAAEAAAA4nenR3qpVK3WPSa+y2oDvVNeuXfXMM8/o7NmzyTo+pD7nr5zXtxu/tbL9Su+/EDfoZ0RF2VG9RYtueX1IiN3bzxg4UMqTxwmDBgAAANJz4K9bt25W4K9Lly6aMWOGVq5caX127tzZ6vtnHhCRMkt9xmT8mZcqixWTZqqVrmTLLZ04Ic2aldxDBAAAAOBkplVDeHi4hg4dGrvvwQcf1LRp06yg37Bhw5J1fEh9vtv4nS5cuaChf3rJcZuMPrm62ll/NwYFJQ0YYLJOpTJlpB49kn68AAAAgNJ74K9OnTr65JNPrLdA33rrLb3wwgvW5z///KOPP/5YjRo1SvyRItEy/k5cPKFL4ZdUpYoUKQ8tLfK8fcLo0ck7QAAAAABOt2rVKr322muqXLlynP1ly5bVK6+8ot9//z3ZxobUJzI6UsP/Hi7PKMn/oodcbhHYi23id/iwFB4eZ/e2bdLXX9vrw4dLHh5OGDQAAACQ3gN/RkBAgFasWKG5c+dq4sSJ1qfZzp07t941b+0hxfHN6CtfL9/YrL9Onez9r+3qbL+FuXixFBSUvIMEAAAA4FQm28/N9Fy7BdPj79KlS04fE1KvGbtm6MDZA8qSJbtc122Q9cap8eab0oYNcRdT7jNDhthrTYzQZPiZSqD/+5/08MPJ9z0AAACAdBf4M1xcXOTv76+qVatan2bbNISfMmVK4o0Qicrf71q5z7p1pXLlpH/CiupQqcb2CWPHJu8AAQAAADhVpUqV9P333yvihp7fkZGRmjBhgipWrJhsY0Pq8/maz63Pl6q/JK8cue0UPqNzZ6lq1bhLgQJxrv31V+mPP0zAWaLCLAAAAHBv3O/xOqTicp/rj61XUEiQ1efvpZek7t2loRdf1AgtlMaNk95/X/L0TO6hAgAAAHCCnj17qn379mrYsKEeeOABZc+eXWfOnLF6uf/777/68ccfk3uISCXWHlmrVYdXycPVQ93u6yYtXWYiyFLx4pK//RLq7Vy8KL32mr3et69UuLBzxgwAAACkNf8p4w+pj7+v/bAVdMYu6dm+vZQ5szTqyCO6kiOf3UF9+vRkHiUAAAAAZzG9/X799Vfrc/ny5fruu++0ZMkSlStXTr/88gsZf0hwtl+7Cu2UN0teacEC+0DTpne99qOPpKNHpaJFpddfT+qRAgAAAGkXGX/pNPC37+w+6zNrVumZZ6TRo901O9cLevz0ILMhPflkMo8UAAAAgLOULVtWn3/+eWyvv9DQUKvUZ5YsWZJ7aEglDp07pCk77bYfvWr1shv2LVxoH2zS5I7X7tkjDR1qr3/+ueTlleTDBQAAANIsMv7SYanP6zP+DFPu03gjsJMcrq7S779Lu3cn1xABAAAAOJHp7TdgwAC1adMmdt+mTZtUu3ZtDR48WNHR0ck6PqQOI9aOUJQjSg2KNlClPJXsZ8oDB+w2EvXr3/HaV18189BODGzZ0mlDBgAAANJ3xl+HDh3idd6JEyf+y3iQxPz97Iy/A2cPKCo6Sm6ubqpUSbr/fmnVqkLaW7KZSuyeK40Zc+2VSwAAAABp1ogRIzRr1iz16NEjTgbga6+9Zh3z9fVVly5dknWMSNkuXLmgMRvHXMv2M2LKfNarJ3l73/baOXOkefMkDw/pyy9l9aIHAAAA4ISMP4fDEa8ld+7cql69etKOGvcsf5b8VqP1iOgIHTl/5Kasv4/OvGivfP+9FBaWTKMEAAAA4CyzZ8/Wm2++qeeffz52X7Zs2fTss8+qV69emjLFLt8I3M73m7/X+SvnVTJ7STUv0dzeGY8yn+aR02T7Gb16SSVLOmO0AAAAQNoW74y/H3/8MWlHAqcwGX5FfYtq97+7FRQSpMLZClv7H3/cftCacLqZvspRUJlOH5amTpWefjq5hwwAAAAgCYWEhKhgwYK3PFasWDGquuCOTCWZL9Z8Ya2/WvNVubq4miaR0vLl9gmmfudtDBsmBQVJefNK77zjrBEDAAAAaRs9/tIhf1+73Oe+kH2x+0zzdPOCb7TcNMWnk71z9OjkGiIAAAAAJzHBvYUx2Vk3WLZsmQoXtl8WBG5lVuAs7T+7X34Z/dSh0tUWIStW2MG/fPmk8uVved3hw9JHH9nrpstElixOHDQAAACQhsU74w9pRzHfYtZn0JmgOPu7dpWGDJH6Br2g9m7vy8U8rO3caRp8JNNIAQAAACQ108/9rbfe0tmzZ/Xwww8re/bsOnPmjH7//XfNnz9fH3/8cXIPESnYZ2s+sz67VuuqzJ6Zby7zeZumfa+9Jl2+bLcAbNvWacMFAAAA0jwCf+k448+U+rxesWJ2FZb58/NrR9FHVH7vTGnMGOkLu2wLAAAAgLQnICBAly5d0tdff61FixbF7vf19VX//v3VqlWrZB0fUq51R9fpr0N/WX3ku9fofu3AggV3LPO5bJn022+Sq6s0YsRtY4MAAAAA7gGlPtMhf7+bS33GeOkl+/O9Ey/aK+PH2yVaAAAAAKRZTz/9tP766y/NmzdPEydO1Jw5czRjxgz9+++/atCgQXIPDynU52s+tz6fLP+k8mXJd62Gp6kcY6J6Dz980zUREVLPnteePytVcuqQAQAAgDSPjL/0XOrzhow/o3lzqVAhaeqhxrqQo4iynD5gv4rZsWMyjBQAAACAs7i4uFj9/lasWKHvvvtOf/zxhyIjI1WgQIHkHhpSoMPnDmvyzsnWeq9ava4diCnzWaOG5OdnrUZF2W3/jh+XVq6UduyQsmeX3n8/WYYOAAAApGkE/tJx4O9s2FmFhIbIN6Nv7DE3N7vX39tvu+rnjJ31ot6WRo8m8AcAAACkYaan35QpU/Tbb7/p6NGj8vb2VuvWra0yn9WrV0/u4SEFGvn3SEVGR+rBwg+qat6qty3zOW2a9Mor0pEjca9//PHYuCAAAACARESpz3Qok0cm5fHOc9usvxdekDw8pIGHn5fD3V1avVrati0ZRgoAAAAgKa1Zs0a9evXSgw8+qC+++EJ58+a19n/11VcaNGgQQT/c0sXwixqzcczN2X6RkdKSJfZ606ZW0M8E+G4M+hmmnbw5DgAAACBxEfhLp/x97T5/QWduDvzlzi3973/SSeXRxoKt7J0m6w8AAABAmvDDDz+oWbNmevbZZ7Vz505169ZNy5YtswJ+DofDKvsJ3M4Pm3+wKsgU9yuuR0o+cu3A2rXSuXNWKl9UlepWpp/Dcfv7vPqqXQYUAAAAQOIh8JdO+fvZgb99Iftuedw0WTcGHHvRXvnxR+nSJaeNDwAAAEDS+eSTT+Tp6akJEyZo4cKFeumll5QnTx4CfrirqOgofbn2S2v9lZqvyM3V7eYyn40aacUqt1tm+sUwAcHDh+3efwAAAAASD4G/dKpYtmK3LfVp1KsnlSsnzbvSQGdz+Evnz0u//OLkUQIAAABICi1atNDBgwfVtWtXK9tv8eLFijRlGoG7mLN7jvae2atsXtn0bOVn4x68rr/f8ePxu198zwMAAAAQPwT+0nnG3+0Cf+ZFX5P155CrvnXtYu+k3CcAAACQJgwbNkx//fWX3njjDQUHB6tHjx6qV6+ePv30Uyvrj8w/3M7naz63PrtU7SJvT+9rB4KDpQ0b7PUmTXS1XeRdxfc8AAAAAPFD4C+d9/i7XalPo317KXNm6dNTzyra3UNat07atMmJowQAAACQVLy9vdW2bVtNnjxZs2fPVqtWraw+f6bHX79+/fTll19q7969yT1MpCAbj2/UHwf/kLuru3rU7BH34OLFdv3OihWtaJ6pIlOgwO3vZWLLBQva1WYAAAAAJB4Cf+lUMV+71Ofhc4d1JfLKLc/JmlV6+mkpWLm0Ju9j9k6y/gAAAIA0p0SJEnrrrbf0xx9/aMSIESpWrJjGjh2rRx99VC1btkzu4SGFZfs9UfYJFcha4LZlPg03N6lXr1vfJyah9Isv7PMAAAAAJB4Cf+lUrsy5lNkjsxxy6MDZA7c9z5T7NN49+qK98vPP0oULTholAAAAAGdyd3dXo0aN9M0332j58uXq3bs3vf9gOXr+qH7Zbvd97127d9yD0dHSokVxAn8m+W/mTHtXxoxxTzeZgFOmSI9dfb8UAAAAQOIh8JdOmZ4dMVl/pjH77VSuLNWuLS2LflCnc5SSLl6UJk504kgBAAAAJIccOXKoc+fOmjdvXnIPBSnAV+u+UmR0pOoWqqvq+arHPbhli3TypN0rok4da9evv0p//mkH/XbskH7/3X6UNJ/79xP0AwAAAJIKgb90rFq+atbnxO13DuR162b+r4u+juxyrdyneX0TAAAAAJDmXQq/pNEb7LYPvWvdkO13fZnPBg0kT0/rfdE+fexdfftKRYtK9etLbdvan5T3BAAAAJIOgb90rGeNntbnr9t/1cGzB2973uOPS9mzS1+e7agojwzSpk3S+vVOHCkAAAAAILlM2DJBZ0LPWFVjWpa6Rc/HG/r7ffihdOyYVKyY9PrrTh4sAAAAkM4R+EvHquStooeLPawoR1Rsk/Zb8fKSnn9eOqPs+iPH49ey/gAAAAAAaVq0I1pfrP3CWn+l5ityc70hXe/8eWnVKnu9SRPt3i0NG2Zvfv65/TwJAAAAwHkI/KVzr99vv3757cZvFRIactvzunY1fQGl/sdftHdMmiSdO+esYQIAAAAAksG8PfO0+9/dypohq56r/NzNJyxbJkVGSsWLy1HMX6++KkVE2Ml/jz6aHCMGAAAA0jcCf+lco2KNVCl3JV2KuKRR60fd9jx/f+vlTa1UHZ3IXla6fFn66SenjhUAAAAA4Fwx1WG6VO2iLBmy3LHM55w50vz5koeH9OWX9sujAAAAAJyLwF865+LiEpv1N3ztcIVFht323Jdesq7Ql6Fdr5X7dDicNFIAAAAAgDNtPrFZy/Yvk5uLm3rU7HHzCeZ5cOFCazX8oSZWtp/Ru7dUsqSTBwsAAAAgZQT+rly5on79+ql69eqqW7euxo0bd9tzFy9erGbNmqlKlSpq27atduzY4dSxplVtyrVRwawFdfLSSf245cfbnteihVSokPTN5faK9PCStm2T1qxx6lgBAAAAAM7xxRq7t9/jZR9XIZ9CN59gGvodOCB5eurzTfW1b5+UL5/0zjvOHysAAACAFBL4+/TTT7V9+3aNHz9eAwYM0MiRI7UgplTIdfbs2aM+ffqoa9eumjlzpsqUKWOth4aGJsu40xIPNw/1qtXLWh+6eqjVvP1W3NykLl2ks/LVwmxPXsv6AwAAAACkKccvHNfEbROt9ZjnxZtcfXYPu6+e3hvmba0PHSp526sAAAAA0lvg7/Lly5o8ebLefvttlStXTo0aNVKnTp30888/33TuypUrVbx4cQUEBKhQoULq3bu3goODtXfv3mQZe1rTqWonZfPKZjVtnxU467bnvfCC3a9hUPCL9o5ff5VCQpw3UAAAAABAkvt63deKiI7Q/QXvV80CNW990tUyn5MvNJF5J/eBB6SnnnLuOAEAAACkoMDfrl27FBkZaZXujFGtWjVt2bJF0dFxs86yZctmBfk2bNhgHZs2bZq8vb2tICD+O9Ok/aXqVhM/DVk15Lbn5ckjPfaYtFY1ddivohQWJv14+/KgAAAAAIDUJTQiVKPWj7pztp+J9C1fbq1+urWpXF2l4cNNH3lnjhQAAADAjdyVjEzGnq+vrzw9PWP35ciRw+r7d/bsWfn5+cXub968uZYtW6Z27drJzc1Nrq6uGj16tHx8fBL8cx0Oh7XcuH39vvSo+33dNWz1MK06vEorD6203uy8lRdfNIl+LvrsYhd9ru5yfPON1L07T3jxxHyDMzHf4EzMNzgT8w3OlFLnW0obD9KOH7f+qH9D/1WRbEUUUDrg1ietWGEF/06659P2yPLq3k2qVMnZIwUAAACQogJ/pj/f9UE/I2Y7PDw8zv6QkBArUNi/f39VqlRJkyZNUt++fTV9+nRlz549QT/3/PnzVuDw+gdmU3bUcEnHwatMyqSnSj+lCTsm6OM/P9ZPj/x0y/PMw1zp0lk0btczGuzxhjz/+UcXFixQ1P23DhQiLuYbnIn5BmdivsGZmG9wppQ6326skgIkBtPz/fM1n1vrPWv0lLur+x3LfM6NbKIcOVz0/vvOHCUAAACAFBn4y5Ahw00BvphtLy+vOPuHDh2qkiVL6umnn7a2Bw0apGbNmmnq1Knq0qVLgn5u1qxZrazBG9+UNdmDKelBPjm89eBbVuBvXtA8nYg4oVI5St3yvG7dpJ49fTQr81N6/Ow4eU+cKDVr5vTxpkbMNzgT8w3OxHyDMzHf4Ewpdb5FRUUl9xCQBi3cu1C7Tu9SFs8seqHqC7c9L3LOAusPCgvUVB99JPn6OnWYAAAAAFJi4C937txWJp/p8+fubg/FZPWZoJ8Jzl1vx44dat++fey2ydgrXbq0jh07luCfax7Wb3xgj9mXkh7kk0OZnGXUslRLzQqcpc/WfKYxj4655XkdOkhvvSV9cvYlPa5xcpkyRfrySymB2ZfpFfMNzsR8gzMx3+BMzDek9/mWksaCtMM8BxqdqnZS1gxxn8tjHT4s9907FSVX/Vv5YT3/vHPHCAAAAOD2rtW7TAZlypSxAn6bN2+O3bdhwwZVqFAhTilOI1euXAoKCoqzb//+/SpQoIDTxptevH7/69bnhC0TdOLiiVueY1orPvOMtEHVtc+3qnTlijR+vJNHCgAAAABILNtObtOSfUvk6uKqnjV73va8oFF2mc+/VUMffeOn6wrqAAAAAEjPgb+MGTMqICBAAwcO1NatW7VkyRKNGzdOHUw62dXsv7CwMGu9TZs2+u233zRjxgwdPHjQKv1psv1at26dnF8hTapTsI5qF6itK1FXNGLtiNue99JL9ueQ813tldGjTR0kJ40SAAAAAJCYYnr7PVbmMRXJVuSW55gKswdGLbDWT1Zuqpo1nTpEAAAAACk58Gf07dtX5cqVU8eOHfXee++pR48eaty4sXWsbt26mjdvnrXevHlzvfvuuxo9erQVLNy4caPGjx+v7JSWTJKSQTFZf6PWj9LF8Iu3PK9yZal2bemnqLa64ukt7d4tLV/u5NECAAAAAP6rkxdP6udtP1vrvWv1vu1534+NVLWzS6z1eh81ddr4AAAAAKSCHn8xWX+DBw+2lhsFBgbG2X7iiSesBUnP9Pkr4VdCe87s0Xcbv9MrtV65bdZfh9VZNNnzaT0TPtrO+nvoIaePFwAAAABw775e97XCo8JVM39N1S5Y+5bnhIRI099aq046p9BMfsreuLrTxwkAAAAghWf8IWVyc3XTa/e/FtvcPSIq4pbnmTisSbocdvFquc9p06RTp5w5VAAAAADAfxAaEWpVezF61759tl///lKtc3aZzwwtGonmfgAAAEDKQ+APt9WhUgflypxLh84d0uSdk295jpeX9Pzz0mZV0S6fGlJEhPTDD04fKwAAAADg3pgSn8GXg1XIp5DV3+9WtmyRvv5aaio78OfanDKfAAAAQEpE4A+35eXupR41eljrQ1YNkcPhuOV5Xa8m+w05d3XFlPuMjnbaOAEAAAAA98Y8532+5nNrvWeNnnJ3vbkjiHkU7NFD8osOVjVtsHc2aeLsoQIAAACIBwJ/uKNu93VTJo9M2nxis5bssxu438jf337m+0VPKswzq7Rvn7R0qdPHCgAAAABImEVBi7QzeKe8Pb3VqWqnW57zyy/SihVSC4/FcpVDqlhRypvX6WMFAAAAcHcE/nBHfhn91KlKp9isv9vp1k26rMz6yaX9taw/AAAAAECKFpPt90KVF+Tj5XPT8YsXpdfs9u/qXc4u86mmlPkEAAAAUioCf7irXrV7yc3FTYv3LbYy/26lRQupYEHpyytXy33OnCmdOOHcgQIAAAAA4m3HqR1aGLRQLnJRz5o9b3nOBx9Ix45J/kWjVeH4InsngT8AAAAgxSLwh7sqkq2I2pRrc8esPzc3qUsXabsqaGuW+6XISGncOCePFAAAAEByu3Llivr166fq1aurbt26GneH54LFixerWbNmqlKlitq2basdO3bc8rxvv/1WDRo0SMJRp09frPnC+mxdprWK+Ra76fju3dJnn9nr3/XcIpeTJ6XMmaU6dZw9VAAAAADxROAP8fL6/a9bn79u/1UHzx685TmdOknu7tLQC1ez/saMkaKinDlMAAAAAMns008/1fbt2zV+/HgNGDBAI0eO1IIFV0tEXmfPnj3q06ePunbtqpkzZ6pMmTLWemhoaJzzDh8+bN0DievUpVP6ceuP1nqvWr1uOu5wSK+8IkVESM2bSw9cvvrf0ARgPT2dPVwAAAAA8UTgD/FSJW8VNSzaUFGOqNi3Qm+UJ4/02GPSZD2hSxl8pYMHpUVXS8EAAAAASPMuX76syZMn6+2331a5cuXUqFEjderUST///PNN565cuVLFixdXQECAChUqpN69eys4OFh79+6Nc54JHpqgIBLXN+u/0ZWoK7ov332qU/DmDL7ZsyUTrzUxvi++kFwWLbQPUOYTAAAASNEI/CHe3qjzhvU5duNYhYSG3PKcbt2kMGXUD1Ed7B2jRztziAAAAACS0a5duxQZGWmV7oxRrVo1bdmyRdHR0XHOzZYtmxXk27Bhg3Vs2rRp8vb2toKAMWbMmGFlAD7++ONO/R5pXVhkmL5a91Vstp+Li0vc42HSq6/a6717SyVynzeRWntHkyZOHy8AAACA+CPwh3hrVKyRKuWupEsRlzRq/ahbnvPAA1LZstLIyKvlPufMkY4ede5AAQAAACQLk7Hn6+srz+tKQebIkcPq+3f27Nk45zZv3lz169dXu3btVL58eatE6PDhw+Xj42MdP3PmjIYOHar333//psAU/ptJ2yZZpT4LZC2gx8veHFQdMkTav1/Kn196+21Jy5bZfdyLF5f8/ZNlzAAAAADixz2e5wHWw/Zr97+m9tPba/ja4epdu7e83L1uOEd68UWpZ88yWpfpAd13+U/pu++k/v2TbdwAAAAAnMNk510f9DNitsPDw+PsDwkJsQKF/fv3V6VKlTRp0iT17dtX06dPV/bs2fXRRx+pdevWKlGihLZt23bPY3I4HNZy4/b1+9IT870/X/O5td79vu5yd3WP829hOjZ8/LFZc9GQIQ5lziw5FiyQCb06TLZfOv13u1fpfb7BuZhvcCbmG5yJ+QZnc6TAOZeQsRD4Q4I8We5J9VvaT4fPH9aPW35U52qdbzqnQwfprbekzy931UT9KY0dK/XrJ7kz3QAAAIC0LEOGDDcF+GK2vbzivjRosvlKliypp59+2toeNGiQmjVrpqlTp1o9/TZv3qwPPvjgP4/p/PnzcnV1jfPAbHoRGukxk3D5oeXadmqbMntk1pPFn9S5c+fiHH/11UwKDfVUnTqRatr0os6ddSjL/Plyk3Spbl1F3nA+7iy9zzc4F/MNzsR8gzMx3+BsjhQ4525snXAnRGKQIB5uHlYPiN6LemvY6mF6oeoLcnWJWzHWVOYxz+7jx/5PFzx7KsuRI9L8+dKjjybbuAEAAAAkvdy5c1uZfKbPn/vVF/9MVp8J+mXNmjXOuTt27FD79u1jt01wrnTp0jp27Jj279+vEydOqHbt2tYxc7+IiAird+DYsWNVvXr1eI/J/Fw3NxO2ivumrCkpmlIe4p1pzLYx1uezlZ9V4dyF4xxbulSaOdNFbm4OffWVm7Jl85ECA+Vy6JAcnp7K3KKF5O2dTCNPndL7fINzMd/gTMw3OBPzDc7mSIFzLioqKt7nEvhDgnWq2knv/fGeAv8N1OzA2WpVutVN57z0kkn0y6Cxkc+qt4ZJo0cT+AMAAADSOJOpZwJ+JlsvJji3YcMGVahQIU7WnZErVy4FBQXF2WcCfuZcU+LzRdND4KpFixbpxx9/tBYTXEwI86B+48N6zL6U8hDvLP8E/6P5e+fLRS56tdarcb5/RIRp2WCvd+vmokqVrh5YuND6cKlXT8qSJTmGneql1/mG5MF8gzMx3+BMzDek9znnkoBxxH3yAuIhS4Ys6nZfN2v901Wf3vKcKlWkWrWkb6K72DtMxt+hQ84cJgAAAAAny5gxowICAjRw4EBt3bpVS5Ys0bhx49TB9AO4mv0XFhZmrbdp00a//fabZsyYoYMHD1qlP022nwn6mR5/hQsXjl3MtgkomvUbS4Yi/r5Y84X12bJUSxX3Kx7n2MiR0j//SDlySO+9d92Bq4E/mf5+AAAAAFI8An+4Jz1q9JCnm6dWHV5lLbdisv72qKRWZmhgCtBK337r9HECAAAAcK6+ffuqXLly6tixo9577z316NFDjRs3to7VrVtX8+bNs9abN2+ud999V6NHj7aChRs3btT48eOtIB8S3+nLpzVh6wRrvXft3nGOnTghDRxor3/yieTre/VAaKi0fLm93rSpU8cLAAAA4N4Q+MM9yZslr9pXtPtxDFk15JbntGkj+flJX17pau8wgT9TPwYAAABAms76Gzx4sDZt2qQVK1bo2WefjT0WGBioxx57LHb7iSee0Pz5861zJ06caAUMb8Vcs2zZMqeMP636ZfsvCosMU5U8VVSvUL04x956Szp/XrrvPum55647sGKFHfzLl08qX97pYwYAAACQcAT+cM/61O5jfc7cNVOBpwNvOm4q8Dz/vDRDAQrxzCUdPy7NmZMMIwUAAACA9G3GrhnW59MVno7TH2T1amn8eHt9xAgpTivG68t8ppDeJgAAAADujMAf7lmZnGWs3hAOOTRs9bBbntO1qxQhT40Jv/ra6OjRzh0kAAAAAKRzIaEhWn7ALtkZUDogdn9UlNSjh71uXtqsWfOGCxcssD8p8wkAAACkGgT+8J+8fv/r1ueELRN08uLJm44XL26/HDpGne0dixZJ+/c7e5gAAAAAkG7N3TNXUY4oVchVQf5+/rH7v/tO2rBB8vGRPv74hosOH5Z27rRTAB9+2OljBgAAAHBvCPzhP6lTsI5qFailK1FXNOLvEbc856WXpH3y1+8ejSWHQxo71unjBAAAAID0Xubz+my/M2ekfv3s9ffek3LluuGimDKfNWrYzdsBAAAApAoE/vCfmN4Qb9z/hrX+9bqvdTH84k3ntGghFSggjYjoau8YN04KD3f2UAEAAAAg3QmNCNWCvQtuCvz17y/9+69Uvrz08su3uJAynwAAAECqROAP/5np81fCr4RCwkL03cbvbjru7m73+putR3XaI4908qQ0c2ayjBUAAAAA0pMl+5boUsQlFcxaUFXyVLH2bdkijRplHx8xwn5miyMyUlqyxF4n8AcAAACkKgT+8J+5ubqpT+0+1vpnaz5TRFTETed06mQigB76JuIFe8fo0c4eJgAAAACk6zKfpmKL6b7Qo4cUHS21aSPVr3+Li9aulc6ds0t8Vq/u9DEDAAAAuHcE/pAoOlTqoFyZc+nQuUOavHPyTcfz5JEee0waq86Klou0dKk0frxUtuy1N0kBAAAAAIkmKjpKs3bPilPmc9IkacUKKVMmaejQ21wYU+azUSPJzc1ZwwUAAACQCAj8IVFk9MioHjV6WOtDVg2Rw7xGeoOXXpIOqbAWuTWzd7z1lvTPP3ZH+VucDwAAAAC4d6sOr9Lpy6fl6+WreoXq6cIF6bXX7GNvvy0VLHibC+nvBwAAAKRaBP6QaF6q/pIyeWTS5hObtXT/0puOP/igVKaM9HVUV3vHiRP257p10qJFTh4tAAAAAKSPMp+PlHxEHm4e+uAD6fhxyd9f6mN3a7hZcLC0YYO93qSJ8wYLAAAAIFEQ+EOiyZ4puzpVMc38pE9XfnrTcRcXO+tvnpopXB6x+x2ubnK88y5ZfwAAAACQSEwVlhmBduCvdenW2rtX+vxz+9iXX0oZMtzmwsWL7WezihWlvHmdN2AAAAAAiYLAHxJVr9q95ObipsX7FluZfzfq0EFq6r5MnoqI3ecSHSWX9ev0V3+y/gAAAAAgMWw/tV37QvbJy91Ljf0b68cfpYgIu21fixZ3uJAynwAAAECqRuAPiapItiJ6otwT1vrQVTd3il+6xKH+ke8qUnEbxJttzw/e1bSpZP0BAAAAQGKV+TRBv8yemTXD3lT79ne4KDr6WhsGAn8AAABAqkTgD4nu9ftftz5/2f6LDp49GLs/Kkqa9uIi1dA6uSsqzjVm2+w3x815AAAAAIB7F1PmM6BUgPbtk7Zuldzc7pLtt2WLdPKklDmzVKeO08YKAAAAIPEQ+EOiq5q3qhoWbagoR5S+WPNF7P4VfzrU8/S7irrNtDO5fj1Pv2OdBwAAAAC4N+YFzI3HN8rVxVWPlHwkNtvvwQclP794lPls0EDy9HTKWAEAAAAkLgJ/SNKsv7EbxyokNMRaP3k4XIV0SG6KvuU1LpLKaqd1HgAAAADg3swMnGl91i1UVzkz54wN/AUE3OXChQvtT8p8AgAAAKkWgT8kCdNHomLuiroUcUmj1o+y9uUulEH3aZ2qasNNSz99YJ3jrcuqvPmHZB49AAAAAKT+/n6mzOepU9LKlfb+Vq3ucNH589dObNLECaMEAAAAkBQI/CFJuLi4xGb9DV87XGGRYapXT1KBgtrsUlWbFHf5WG/rXb1vnV9y+MvX3jQFAAAAAMTbv5f/1Z8H/7TWW5VupTlzpOhoqVo1qVChO1y4bJkUGSkVLy75+zttvAAAAAASF4E/JJknyz2pglkL6uSlk/pp609WI/kvv7SPuZi6njf4QO8osGYHuURFSU88IW3f7vQxAwAAAEBqNnfPXKvfuqnAUsy3GGU+AQAAgHSGwB+SjIebh3rV6mWtD101VNGOaD32mDRlipQ//w3nepj/66I258Yqos6D0oULUosW0okTyTJ2AAAAAEjtZT4vXpQWLYpH4M/hkBYssNcp8wkAAACkagT+kKQ6Ve0knww+Cvw3ULMDZ1v7TPDvwAHp99+liRPtzz177GDg1l2eeswxTdElSkqHDkmPPipdvpzcXwMAAAAAUrzLEZe1YK8dwGtdprUV9Ltyxa7cWa7cHS7cvdt+SPP0lOrXd9p4AQAAACQ+An9IUlkyZNFL1V+y1oesGhK735T9NM+Tbdvan4ULS/PmSVmySHNW+al3qXlyZM8urV8vPfOMZMp/AgAAAABua8m+JQqNDFVhn8KqlLtSnDKft2q3cFOZT9OY3dvbKWMFAAAAkDQI/CHJ9azZU55unlp5eKVWHV512/MqVpSmTpXc3aUv5/hrdPOZ9hun06dLb77p1DEDAAAAQKot81k6QJGRLpozJ579/SjzCQAAAKQZBP6Q5PJmyav2FdvflPV3K40aSWPH2usv/VhHS9v/YG8MGyZ9802SjxUAAAAAUqPI6EjNCpwVG/j7808pJETKmVOqXfsOF4aFScuX2+tNmzpnsAAAAACSDIE/OEWf2n2sz5m7ZirwdOAdz332WWnAAHu9yQ9tFdh+kL3Rvfu1N1EBAAAAALFWHlqpf0P/lV9GP9UtVDe2zGfLlnarhdtasUIKDZXy5ZPKl3fWcAEAAAAkEQJ/cIoyOcvo0ZKPyiGHhq0edtfzTeCvY0e7tV+1qW/r30eubrRpI23b5pQxAwAAAEBqK/NpnrvcXNzj9PeLd5nPOzYCBAAAAJAaEPiD07xR5w3rc8KWCTp58eQdzzXPm2PGSA8/LF267KIq68YorFZ96cIFqUUL6fhxJ40aAAAAAFI2h8OhGYHX+vtt3CgdOSJlzmw/U8Ur8EeZTwAAACBNIPAHp6lTsI6q5KmiK1FX1G9ZP208vvGm5dC5Q7Hne3pKU6ZIFSpIh096qv6ZaYoqUUo6fFh69FHp0qVk/T4AAAAAkBJsPblVB84eUEb3jGrs3zg2269ZM8nL6w4XmmernTslV9d4RAgBAAAApAbuyT0ApB+Hzx/W9lPbrfVxm8ZZy4283L0U2D1QhXwKWds+PtK8eVKtWtLa3b7qUHOufspRSy4bNkhPPy1NnXqXhhUAAAAAkD7KfJqgXyaPTPEv87lwof1Zo4bk55fEowQAAADgDGT8wWlOXz6tiOiIO54TFhlmnXe9AgWkuXOlLFmkiWv99X7VmXJkyCDNnCm9YZcPBQAAAID0KqbMZ+vSrbV3r7R9u+TuLjVvfpcLKfMJAAAApDkE/pAqVKpkl/00D68DF92v35r9YB/47DNp1KjkHh4AAAAAJAtT4nPzic1ydXHVIyUfsd6PNOrXl3x973BhZKS0ZIm9TuAPAAAASDMI/CHVaNxYGjPGXn9qxlNaF/ChvdG9uzR/frKODQAAAACSw8xddqTvgcIPKHum7PEv87l2rXTunF3is3r1pB8oAAAAAKcg8IdU5bnnpAED7PXas/rqyMPPStHRUps20pYtyT08AAAAAHCq6bumW58BpQJ06pS0cqW9v2XLeJb5bNSIvukAAABAGkLgD6mOCfx17ChFRbuowqrRulD9IeniRemRR6Rjx5J7eAAAAADgFKY/+opDK6z1VqVbadYsyeGwE/gKFrzLxfT3AwAAANIkAn9IdVxc7JKfDRtKZy976r5DUxXhX1o6ckR69FHp0qXkHiIAAAAAJLk5u+co2hGtynkqq0i2IvEv8xkcLG3YYK83aZLk4wQAAACQjgJ/V65cUb9+/VS9enXVrVtX48aNu+25gYGBatu2rSpWrKhHH31Ua9ascepYkXJ4ekpTp0rly0uBp3z1iMtcRefIKW3cKLVrJ0VFJfcQAQAAACBJzdg1I7bM54UL0pIl8Qz8LV5spwZWrCjlzZv0AwUAAACQfgJ/n376qbZv367x48drwIABGjlypBbElBy5zoULF/T888+rePHimj17tho1aqTu3bvr33//TZZxI+FyZMohL3evu54XeDowXvfz8ZHmzZPy5ZMW7S2mnoVmypEhg6z6Nq+/nggjBgAAAICU6XLEZS0KWmStB5QO0MKF5sVaqUQJqWzZu1xMmU8AAAAgzXJPzh9++fJlTZ48WWPHjlW5cuWsZc+ePfr555/V9IYHkOnTpytTpkwaOHCg3Nzc1LNnT/3xxx9W0PDBBx9Mtu+A+CvkU0iB3QOtPhQ3ioiK0OuLX7f6U7ww6wXly5JPDxa5+39X07fCBP/q1ZO+2lhbpepNUI8VT0qffy75+0svv5xE3wYAAAAAko8J+oVGhlolPivmrqgh15X5NO0Rbis6WlpkBwwJ/AEAAABpT7Jm/O3atUuRkZGqUqVK7L5q1appy5YtijYPI9f5+++/1bBhQyvoF2Pq1KkE/VJh8K9q3qo3LTUL1NTi9ovVrHgz6+G1xcQWWnHQblJ/N5UqSVOmSGZq9FzRRosf+sg+0LOnHRUEAAAAgDRa5rN16daKjHTRnDnxLPO5ZYt08qSUObNUp07SDxQAAABA+gn8BQcHy9fXV56mYdtVOXLksPr+nT17Ns65hw8flp+fn959913VqVNHbdq00YaYZuRIEzK4Z9C0J6epsX9jXYq4pOYTm2vV4VXxurZxY2nMmKvrv7+lwDrP22+yPvmk/WALAAAAAGlEZHSkZu+eHVvm848/pHPnpNy5pZo141nms0EDu3k6AAAAgDQlWUt9hoaGxgn6GTHb4eHhN5UFHTNmjDp06GCVBp07d65eeOEFzZ8/X3kT2Izc4XBYy43b1+9D8sjglnaTawsAAGbqSURBVEHT20xXy19aaun+pWr6U1MtfGahahWodddrn3tOOnBAGjTIRZVWj9KRSgeUY8syOVq0kNaskfLnV0rAfIMzMd/gTMw3OBPzDc6UUudbShsPnOevQ3/pTOgZq4/6/QXv16tD7P0tW9qVUO7INAM0KPMJAAAApEnJGvjLkCHDTQG+mG0vL684+02JzzJlyli9/YyyZctq5cqVmjlzpl588cUE/dzz58/L1dU1zgOzCSwaLndshgBnmdBsgp6c9aT+OvKXmvzURDNaz1DVPFXvel2vXtKePZn0yy+eqrx3igIL11bmg4GKbNFCF+fOlby9ldyYb3Am5hucifkGZ2K+wZlS6ny7sT0C0o/p/0y3Ph8t+ajcXNw147r+fnd0/ry0cqW93qRJEo8SAAAAQLoL/OXOnVshISFWnz93d/fY8p8m6Jc1a9Y45+bMmVPFihWLs69IkSI6fvx4gn+uuff1vQJj3pT18fFJUQ/y6ZmPfDT/mflWuc8Vh1bofzP/p8XPLFa1fNXueu0PP5h55NDSpb5qkGmeVmWvJfetW+XTrZs0bVo8XoFNWsw3OBPzDc7EfIMzMd/gTCl1vkVFRSX3EJBM83FG4IzYMp/r10tHj9rvOJrqnXe0bJkUGSkVLy75+ztlvAAAAADSUeDPZPCZgN/mzZtVvXp1a5/p21ehQoU4GXlG5cqVtW7dujj79u3bp0ceeSTBP9c8rN/4wB6zLyU9yKd33hm8NbfdXDX7uZlWHl6pxj811rKOy1Q5T+U7XpchgzR1qlS3rvT39mJqX3SWfr70kFxmz5Zee0364gslN+YbnIn5BmdivsGZmG9I7/MtJY0FzrP5xGYdOndImTwyqVGxRvpgoL2/WTNTOecuF1PmEwAAAEjz4kbXnCxjxowKCAjQwIEDtXXrVi1ZskTjxo2z+vjFZP+FhYVZ60899ZQCAwM1YsQIHTx4UF9++aUOHz6sVq1aJedXQBLLkiGL5j09z+rxFxIWoocnPKytJ7fe9TofH2nePClfPmnS/lp6v/gE+8CXX0ojRyb9wAEAAAAgCczYZWf7NfFvooweGeNf5tNkri5YYK9T5hMAAABIs5I18Gf07dtX5cqVU8eOHfXee++pR48eaty4sXWsbt26mmeiN5Ly58+vb7/9Vr///ruV5Wc+x4wZY5ULRdqWNUNWLXh6gWrkr6F/Q/9VwwkNtf3U9rteV7CgFNPWb+D2J/RrlU/sA6+8Yh8AAAAAgFTm+jKfu3dLO3dKpnNG8+Z3udCcfOCA5Okp1a/vlLECAAAASGelPmOy/gYPHmwtNzIZfterVq2appkebUh3fLx8tPCZhVbG34bjG9RgfAMtf3a5yuYse8frKleWpkyRWrSQntr0hopX3qNqm7+TnnxS+vNPqWpVp30HAAAAAPgv9oXssyqguLm4qUWJFhr3lb3f9PbLli2eZT5NTwTzdiQAAACANCnZM/6A+MrmlU2L2i9SlTxVFHw52Ar+7Tq9667XmSo2o0ebNRfV2jxKR8s0lC5dkurVk8aMsUveAAAAAEAKN3PXTOvzgcIPKHum7PEv82nElPmkvx8AAACQphH4Q6ril9FPi9svVsXcFXXy0kkr+Lfn3z13ve6FF6R335Ui5aGKgVP0b+WG0uXLUteu9lNycLBTxg8AAAAA/7XMZ+vSrXXihLR6tb2/Zcu7XBgWJi1fbq8T+AMAAADSNAJ/SHXMm61L2i9R+VzldfzicT00/iEFnQm663XvvSe1by+dic6monsW6UivYXZ/i1mzpAoVpKv9JAEAAAAgpQm+FKy/Dv1lrbcq3UqzZ9vFS2rUkPLnv8vFK1ZIoaFSvnxS+fJOGS8AAACA5EHgD6lSzsw5tbTDUqvH39ELR63gn+l3cScuLtK339r9Ly5cclXJb3rrl95/y1GunHTypN0I8OWX7UxAAAAAAEhBZu+erWhHtKrmrapCPoXurcyn6YNgHowAAAAApFkE/pBq5cqcS8s6LFPpHKV1+PxhK/h34OyBO15jEvymTZMaNbJfeG37SSU9mme9LnZ61T7h66+latWkjRud8yUAAAAAIB5m7LIjfQGlAnT+vLRkib2f/n4AAAAArkfgD6labu/cVvCvZPaSOnTukNXzz3zeiY+P/dw7fLjk5SXNXeqlQlM/1+99F0l580q7dkk1a0qffCJFRTntuwAAAADArVwMv6hFQYus9YDSAdbzTHi4VLKkVLr0XS4+fFjauVNydZUeftgp4wUAAACQfAj8IdXLmyWvFfzz9/XX/rP7reDfkfNH7niNeebt0UPatEmqXl0KCZEafNxInWttU/gjj0mRkVLfvnZd0IMHnfZdAAAAAOBGJuh3JeqKivkWs3qdX1/m866VOxcutD9NM0A/vyQfKwAAAIDkReAPaUL+rPn1e8ffVTRbUQWFBFnBv2MXjt31OvN27KpV0oABkpub9O307Cq6YYq29/le8vaW/vxTqlhR+vlnp3wPAAAAALhTmc+ICBfNnWvvp8wnAAAAgBsR+EOaUdCnoBX8K+xTWHvO7LGCfycunrjrdR4e0sCBdgDQlMo5dtxFFYY9q4EBmxVVs7asBhrPPCO1ayedPeuU7wIAAAAARkRUhObsnhNb5nP5cvsRJU8eu0PBHZlKJjHNAAn8AQAAAOkCgT+kKYWzFbaCf4V8Cinw30Ar+Hfy4sl4XWsq35jSn92729vv/eSvCmf+1JEu79vpgJMm2dl/5kkbAAAAAJxgxaEVCgkLUc5MOXV/wftjy3y2amW3MLijtWulc+fsEp+mxwEAAACANI/AH9Kcor5FrZ5/BbIW0D+n/1HDCQ0VfCk4XtdmyiSNGGG3wciXT/pnj7uKfPeuxnRcKUfx4tLhw3bfvzfekK5cSfLvAgAAACB9iynz2bJUS7nITTNn3kOZz0aN7JcZAQAAAKR5BP6QJvn7+VvBv3xZ8mlH8A4r+Hf68ul4X9+4sbRtm/TUU1JUlNR1XE09mGWTzj7RWXI4pCFDpFq1pJ07k/R7AAAAAKnNlStX1K9fP1WvXl1169bVuHHjbnvu4sWL1axZM1WpUkVt27bVjh07Yo+Fh4dr8ODBeuCBB3Tffffp5Zdf1okTdy/ln5Y4HI5r/f1KB2j9eunYMSlLFumhh+JxA/NGo0GZTwAAACDdIPCHNKtE9hJW8C+Pdx5tO7VNjX5spDOhZ+J9vamGY6p7msXXV1qxyVt5Z4/RnBemy5E9u7R5s1Stmp0iaIKBAAAAAPTpp59q+/btGj9+vAYMGKCRI0dqQUzm2XX27NmjPn36qGvXrpo5c6bKlCljrYeGhlrHhw8friVLlmjo0KGaNGmSIiMj1b17dysYll5sOrFJh88fVmaPzGpYtGFsmc/mzaUMGe5ycXCwrEhhzJuNAAAAANIFAn9I00rlKGUF/3JlzqXNJzZbwb+Q0JAE3cNk/ZnsP/OsHBYmPfpdgJ4qu01h9ZvaO3r2tJ+8jx9Psu8BAAAApAaXL1/W5MmT9fbbb6tcuXJq1KiROnXqpJ9//vmmc1euXKnixYsrICBAhQoVUu/evRUcHKy9e/dax6dPn65evXqpRo0a1nmDBg3Stm3bdPDgQaUX0/+Zbn02Ld5UGT0yavr0BJT5XLzYfkHR9Ck3fQwAAAAApAsE/pDmlclZxgr+5cyUUxuPb1STn5robNjZBN0jf367PcZXX0kZM0q/rcirvJvmaX3HEXJ4edkHzQN1zCu4AAAAQDq0a9cuKzPPlO6MUa1aNW3ZskXR0dFxzs2WLZsV5NuwYYN1bNq0afL29raCgGZ7yJAhuv/++2/6GRcuXFB6MSPwWpnPXbvMv6/k4SE1axaPiynzCQAAAKRLBP6QLpTLVU5LOyxV9ozZte7YOjX9qanOXzmfoHu4uEjdukmbNkk1akhnz7novvHd1efBDYqsUFk6fVpq3Vrq3Fm6eDHJvgsAAACQUpmMPV9fX3l6esbuy5Ejh9X37+zZuC/fNW/eXPXr11e7du1Uvnx5q0SoKe/p4+MjV1dXK+hngoMxJkyYYN27VKlSSg/2ntmr7ae2y83FTS1KtNDMmfb+Bg0kH5+7XGyCrAT+AAAAgHTJPbkHADhLhdwVrOBfgwkNtPboWtUYW0OjWozSQ0UfStB9zN8ZVq6UPvpIev996fOFZTU1z1r9/vi7KjZ1iPTtt9Ly5dJPP0k1aybZ9wEAAABSGtOf7/qgnxGzHR4eHmd/SEiIFSjs37+/KlWqZPXx69u3r1XiM7vpqX0d0+tv3Lhxeu+99266/92YnoDX9wWM2U7pvQJn7LKz/eoXqa9sXtk0Y4YZr4tatTJjv8vFmzfL5eRJOTJnlkzWZAr/rmlZaplvSBuYb3Am5hucifkGZ3OkwDmXkLEQ+EO6UilPJS1uv1jNf26uwH8DrSBgh0odNKTREKsPYHy5u0v9+9ut/dq3NyV3POU/ZbA+a9lMr2zsIFfTl6ROHfukfv3sCwAAAIA0LkOGDDcF+GK2vUyJ/OsMHTpUJUuW1NNPP21tmx5+zZo109SpU9WlS5c4Qb9XX31VzzzzjJ544okEj+n8+fNWBuH1D8ymF6HhYsp6pFBTd0y1PhsXbqzAwPNas8ZO86tf/7zOnbvzQ3+GGTOUUVJkvXq6FBpqIrJOGTNullrmG9IG5hucifkGZ2K+wdkcKXDO3dg64U6IRiDdqZq3qnZ136V+S/vpm/XfaMKWCZodOFuDHx6sF6q+IFeX+FfArV5d2rhReustafhwqfes+vqp2FYtbNxNORZNkgYMsPv//fij5O+fpN8LAAAASG65c+e2MvlMnz/3qy+/maw+E/TLmjVrnHN37Nih9uYtuqtMcK506dI6duxY7L65c+fqjTfe0FNPPaV+5oW6e2B+rpub201vypqSoinlIf5Gpy6d0tpja631pyo9pXm/2P92tWo5VLp03H/HW/rzT+vD/ZFHrO+J5JMa5hvSDuYbnIn5BmdivsHZHClwzkVFRcX7XAJ/SJdMqZyvW3ytjpU66sW5L2rzic3qMqeLvt/8vb555BtVzF0x3vfKmFH68kvp0Uel556TNu7LpjwHJ2pSwCN6fNlLclm9Wqpc2Y4MPvuseWVZWXr0kEaMkBo1StLvCQAAADhTmTJlrIDf5s2bVd28JSdpw4YNqlChQpysOyNXrlwKCgqKs2///v3Wucbq1autoJ/JCLzXoJ9hHtRvfFiP2ZdSHuJvNGf3HDnkULW81VQoW6HY/n4BAWbMd7n4/Hm7N4H5nqa/Xwr9julJSp9vSFuYb3Am5hucifmG9D7nXBIwjvinNgFpUM0CNbWu8zp93uRzeXt6a/WR1ao6uqpeX/S6LoZfTNC9Hn5Y2rpVatfORN+lNjPa6ZGCW3Wp+gPSxYvS88/L8dj/dLHbG3ILDNSFHv0UFZlyagQDAAAA/1XGjBkVEBCggQMHauvWrbG9+Tp06BCb/RcWFmatt2nTRr/99ptmzJihgwcPWqU/TbZf69atrYxBE+y777771LlzZ+u6mOXGUqJp0YxAu79f69KtrTje0qX2/oCAeFy8bJkUGSkVL07VEQAAACAdIvCHdM/d1V2v1npV/7z8j/5X5n+KckRp6OqhKvtVWc3cdfXV2njy9ZV+/ln69Vd7fd6Owsq5dZn+euQTRbt5yGXGdGXZu9k6N2vgenXMu0jTpiXRFwMAAACSQd++fVWuXDl17NhR7733nnr06KHGjRtbx+rWrat58+ZZ682bN9e7776r0aNHW8HCjRs3avz48cqePbu2b99uBQFN1p+55vpl06ZNSsvMC4iLgxZb6wGlAzR/vhQRIZUuLZUqFY8bLFxof5psPwAAAADpDqU+gasKZC2gKW2maO7uueo+v7sOnD2ggF8D1LJUSw1vOlyFsxWO973atDF/1LCS/LRwoZvqzXlTVfSwVqquMsp+w9nk+g08/bJK/S9Qk6e66bHHkvDLAQAAAE7M+hs8eLC13CgwMDDO9hNPPGEtN6pcufJN56YXC/Yu0JWoKyruV1xlc5bVoOkJyPYzvUhMj3GjSZMkHScAAACAlImMP+AGLUq20I5uO9S3bl8rG3BW4CyV/bqshqwcooioiHjfJ18+WW/njhxpt9XIqdOxQT/DVOQtriDtVxH91fkHRYXF/94AAAAA0qYZu+wynwGlAhQe7qKrCZLxC/zt3i0dOCB5ekr16yftQAEAAACkSAT+gFvI5JFJHzX8SJu7bla9QvV0OeKy3ljyhqqNqaZVh1fF+z4m4FeunHnx1qFBeleRcotz3GT9FdIRfXbmOUUU9pdGjJAuX06CbwQAAAAgpTMvGs7ZPSe2zOfvv0sXLkh580r33ZeAMp/16kne3kk7WAAAAAApEoE/4A7K5SqnP579Q+NajlP2jNm17dQ21RlXR11md9GZ0DPxusfx41JjLVINrZO7ouIcM1l/xhllk9epw1LPnlKRItKHH0pnzybBNwIAAACQUv1x8A+du3JOuTLnUq0CtTTDTv5Tq1aSa3ye3inzCQAAAKR7BP6Au3BxcdFzVZ7Tru679Hzl5619YzeOVamRpTRhywQrm+9O8uaxs/2ibvP/bmb/PvlrVrOv5ShaVAoOlt55RypUSHrrLenkyST5XgAAAABSZpnPliVbykVumjkzAWU+w8Kk5cvt9aZNk3CUAAAAAFIyAn9APOXIlEPftfpOfz77p8rmLKvTl0+r44yOajChgf4J/ue219WrGa6irofkpuhbHjf78+uonpj/vEppt5Y+95Oiy5W3a/oMHiwVLiy9/LLdqwMAAABAmmReKIzt71c6QH//LZ04IWXNKj30UDxusGKFFBpqNxsvXz7JxwsAAAAgZSLwByRQvcL1tKnrJn3S8BNldM+o5QeWq9I3lfTOsncUGhF60/lumTJo/ah1qqYN1lL1uiVm36BH1ylL9gzas99dD3//tPKd2qLJz8xU5H21pCtXpK+/looXlzp0kHbsSJbvDQAAACDpbDi+QUcvHJW3p7caFmsYW+azRQvJ0zOBZT5Ns3EAAAAA6RKBP+AeeLp56s26b2rnyzvVokQLRURH6MMVH6r8qPJasPfqA/d1mnUpqLenVtWpAlW1SdeW4IJVrf1fzyqggwel4cPtBL+Twa5q81NL+f2zSqPa/K6wBxpJUVHSjz/ab++2bi3rFWAAAAAAaUJMtl+z4s3k5e4VG/iLV5nP6wN/lPkEAAAA0jUCf8B/UCRbEc1uO1vT2kxT/iz5tS9kn5r93ExPTnlSxy4ci3PuY4/Z1TqXLXNo7NhL1uf+/fZ+I3NmqUcPac+ea/G9Cxdd1O23+vJZs0iDWq7Thcb/s9/eNX8FqFlTathQWrrU1AVKnn8AAAAAAIni+jKfu3ZJgYF2pl+84niHD0s7d0qurtLDDyf5WAEAAACkXAT+gP/IxcVFrcu01j8v/6PetXrLzcVNv+34TaVHltaItSMUFR2lQ+cOaePxjdpyaqOyltqoEg+stz7Nttlvjsfw8JCeeUbaulWaM0eqV08KD5f6z6oun8VT1PPhnQp+5FnJ3d1EEe0HexMENMHA6Fv3EQQAAACQcu35d492BO+Qu6u7mpdorunT7f3mPT/T4++uFi60P2vUkPz8knSsAAAAAFI29+QeAJBWZMmQRcOaDFP7Su3VdU5X/X30b/Vc0FNjN45V4L+BCo8Kv+21ppRPYPdAFfIpFLvPJPaZfh5mWbVKGjxYmjVLGrG4tEboez1Ve6A+yTVMhRaOlcu6dXb5z7JlpTfflNq2tSOIAAAAAFJNtt9DRR5SNq9slPkEAAAAcM/I+AMSWeU8lbXq+VUa1WKUfDL4aNupbXcM+hlhkWE6ffn0bY/ff780c6a0fbvUsaOd7PfL6sIqMnO4Hi5+UDsD+snh42OX9zEnlCghffWVFBqaBN8QAAAAQGKaEXitzOfRo3Y7b/MiYMuW8bg4MlJassReJ/AHAAAApHsE/oAk4Obqpherv2hl8TUr3izR7luunPTDD1JQkPTqq1KmTNKy7blUbsaHqux7UGsCPpYjVy7p4EGpe3epSBHpk0+kc+cSbQwAAAAAEs+Jiye0+vBqa71lqZZWlQ+jVi0pT5543GDtWvv3fVPis3r1pB0sAAAAgBSPwB+QhHJ759YHDT5I9PsWKiR9/rl06JD03ntS9uzS1gM+qj3jLRVxHNDCll8pumBh6dQpqW9f+4J+/extAAAAACnG7MDZcsih+/LdpwJZC9x7mc9GjSQ3tyQbJwAAAIDUgcAfkIqZgF///naC3/DhdnzvUHBGNZ3VTTlC9uiX5hMUUaKMdP689PHHUuHCUrdudu0ghyO5hw8AAACke9eX+Tx7Vlq2LIGBv4UL7U/KfAIAAAAg8AekHH2X9tVfh/6S4x4CcpkzSz16SHv3Sj/+KJUvL4Vc9FDbee2V5cB2jWw4XaEV7pPCwqRRo6SaNaVSpex0QXMRAAAAAKe7cOWCluxbEhv4mz/fbtlXpoxUsmQ8bhAcLK1fb683bpy0gwUAAACQKhD4A1KIRUGLVO/7eqo8urLGbBijS+GXEnwPDw/pmWekrVulOXOkunWlKxGu6rE0QJm3rdWAukt1ulFbOTJmlPbskQYOlEqUsAOBJmXw5Mkk+W4AAAAAbrZg7wKFR4WrZPaSKpOjTGyZz9at43mDxYvtSh4VK0r58iXlUAEAAACkEgT+gBSiValWyuieUVtPblXXOV2V77N8emX+Kwo8HZjge7m4SC1aSCtWSCtXSi1bSg656P2/Gijn4omqku+UprX+URfrNZVcXe3Sn6+8IuXPLzVrJv30k3TxYpJ8TwAAAAA3lPksFaDwcBfNm2fvp8wnAAAAgHtF4A9IYjky5ZCXu9cdzzHHhzcbrqO9j+qzxp+puF9xnb9yXsP/Hq7SX5VWox8bacauGYqMjkzwz7//fmnmTGn7dqljR8kk+20J8tb/pj+jLCvmq1G5Y1ra6kuFV64hRUVJCxZI7dtLuXNLTz8t668PERH/4V8AAAAAwI1Mpt/c3XNjy3wuXWq/e2fexatWLR43iI6+Fvhr0iRpBwsAAAAg1XBP7gEAaV0hn0IK7B6o05dPW9umh9/Fixfl7e0tF5OadzU4aM4zetXupVdqvaLFQYv11bqvNGf3HKvvh1kKZi2ortW6qlPVTsrtnTtB4yhXTvrhB2nECDsQOGmS/XeCJdtya8m2nnJx6am29+1Rr1w/q8rOn+W2f680caK95MwptWlj1xE1ZUGvjhsAAADAvVl+YLnOXTmn3Jlzq2aBmnpxkL2/VSu7KMddbdlil+o3Db/r1Enq4QIAAABIJcj4A5zABPWq5q0au1TKVSnOdkzQL4ari6uaFG+iWW1nad8r+/RWnbes4ODh84f1zu/vqODnBfX0tKe16vAqK5CYEFmy2PG7uXOlEyekUaOkevXs1iAT15XQfXMHyuvQbvWus1aBTXoqOmcuKThY+uorqXZtuydg//5SYMJLkAIAAACwmYoeMSX/HdGu1st591Tms0EDKUOGJBolAAAAgNSGwB+QwhXJVkQfP/yxDvc6rAkBE1Qzf01FREdo4raJqjOujqqOqaqxG8bqUvilBN87Rw7pxRelP/+UDh6UPv1UqlxZioxy0ecra6j0wi+V7eJRffLgfB2p/4wc5m3ioCBp0CCpdGnpvvukL76wI4gAAAAA4iXaEa2ZgTNjy3yuXSudOiX5+EgPPhjPm5gS/QZlPgEAAABch8AfkEqYPoDtK7XXmk5rtL7zej1f+Xlr3+YTm9VlThfl/yy/ei3opd3/7r6n+xcqJL3+urRpk7Rzp/Tuu1Lx4tKFUHf1/aOpCi7/UQU9TmrsQxP1b83mcri5SevXS7162Y1IGjeWJkyQLlxI9O8OAAAApCXrj63XsQvH5O3prQZFG2iGnfynFi0kT8943OD8eWnlSnu9adMkHSsAAACA1IXAH5AKVctXTd+1+k5Hex/V0EZDVcy3mNUf5Iu1X6jUyFJq/GNjzdw1U1HRUfd0/zJlpPffl3bvlv7+247t5c0rHT2bWV1+b6sca+eqYo7jmtZgpC5WqC1FR0uLF0sdO0q5c0tPPSXNni2Fh1+76ZIlUtmy9icAAACQjsWU+Wxeork83TJo+vQElvn8/XcpMtJ+U8/fP+kGCgAAACDVIfAHpGJ+Gf3U5/4+2tNjj+a1m6cWJVrIRS5avG+xAn4NULHhxfTxio8VfCn4nu7v4mJX8/zsM+nwYWnpUqlTJylbNmn7yZz637KXlWXbKjUsvFfL6r+vK0VLSaGh0q+/Si1bSvnySd26KeqPv3S+e1/pn390vns/RUUmrC8hAAAAkBYDfwGlAsyvyNq7127TF+/kvZgyn2T7AQAAALgBgT8gDXB1cVWzEs00p90cBfUM0hv3v6HsGbPr0LlD6resnwp8XkDtp7fXmiNr5HDcW9DNVPZs0EAaO9Zu6TdzpvTkk1LGjNKyg/5quPxdee3/R0+XWq/19XopKmce6d9/pVGj5Fa/nrIGrrfukzVwnZ7PM0/TpiXyPwIAAACQApnfyTce3xi7TPtnmv45/Y/cXdyVL0s+/TD9kHXeww9LWbLE44bm93n6+wEAAAC4DffbHQCQOhX1LarBjQZrYP2B+m3Hb/pq3Vdad2ydftr6k7VUzF1Rj5d5XAGlA1Q+V3m5mLS+BDJvI5uEPrNcvGgHASdOlBYtctHEwGrW4qoheq7QMtU99JPa6ye5KTr2+u/+bak5/3tEmzs1VuXXG0klStjphQAAAEAaC/qZUvxhkWE3HYt0RKr++PpyifKSfAIVEFAofjc19fgPHLCbAdavn/iDBgAAAJCqkfEHpFEZPTKqY+WO+rvz3/q70996tvKzyuCWQVtPblX/5f1V8ZuKKj6iuPos7KMVB1fccz9Ab2/p6aeluXOl48etBD898IAULTd9d6iRJqldnKCf4a5oBWiWKn/bXSpVSipaVOrcWfrtNztLEAAAAEgDTl8+fcug3/UcbmFSptN69NF43nThQvuzXj37l3EAAAAAuA6BPyAduC//ffq+1fc62vuovmv5nR4p+YgVBNwXsk+frflMD/zwgPIOy6tOszppzu45Co0IvaefkyOH9OKL0h9/2G3+JIcG6V1Fyi3OeVFy1WHl1zLVV7SHp3TwoPTtt3bt0Jw57caC/fpJy5dLV64kzj8CAAAAkEJVqiTlzh3PkynzCQAAAOAOKPUJpCPZM2XX81Wet5aL4Re1cO9CzQicYQX7gi8H67tN31lLZo/Malq8qVUOtEWJFvLN6JvgnxUVJTXWItXQupuOmQzAgjqqTvpOraPr6qVKK/SY9yKVP7FYmYK2S+vX28vHH0uZMkkPPig1biw1aiSVLUtZUAAAAKQp8a7YGRZmvxxnNG2alEMCAAAAkEoR+APSKW9Pb/2v7P+sJSIqQn8e/FMzds2wAoFHzh/R1H+mWou7q7seLPygFQRsVaqVCvoUjNf98+axs/1Mdt+NpT4Ns98crxm1VoO3NNVg2X+4KJvtmF4ssURNXBerWNBiuZ8+Kc2fby9Gvnx2ANAsDz+cgFejAQAAgFQe+FuxQgoNtX8nLl8+iUcFAAAAIDVK9lKfV65cUb9+/VS9enXVrVtX48aNu+s1R44cUZUqVbR27VqnjBFI6zzcPNSwWEONaD5Ch149pPWd1+udeu+ofK7yioyO1NL9S9Vjfg8V+qKQqo+prg/+/EA7Tu2Qw+G47T3r1QxXUddDtwz6GWZ/EdfD2rkpXCNGSK1aSVmzSjvP5lPPdR1Uau2P8jh9XM3zb9HkmkN1omJjOby8pGPHpPHjpWeekfLkkSpXll5/XVq82P4jCAAAAJDKFCp0D2U+qYIBAAAAICVm/H366afavn27xo8fr2PHjunNN99Uvnz51PQOZUsGDhyoy5cvO3WcQHrh4uKiavmqWcugBoO098xezdw108oEXHlopTYc32At7/7+ror7FVdAqQArG7BWgVpyc73Wy88tUwYtHD5Dnw0Muu3P6j2wuJ6pnEFlKkvdu0uRkdK6ddKSJfayerWL5h+taC1SH3kpTB2Lr9RTfotU9cxiZd27SdqyxV6GDpUyZJDq1btWFrRiRck12d9vAAAAABJHTOCPMp8AAAAAUmLgzwTvJk+erLFjx6pcuXLWsmfPHv3888+3DfzNmjVLly5dcvpYgfTKBPf63N/HWk5ePGn1A5y+a7qW7FtiBQWHrh5qLbky51LLki2tIKDJHjx16ZQ6n31IYd3Dbnvvzme99MC5QBXysV9xdneXate2l3fflS5elP780w4CmoS+7du9NHpvQ41WQ0mDVcDzlF4ssVSPei1W6SOL5XnyyLWooZEzp10ONCYQmD+/s/7ZAAAAgMR1+LC0c6f9Ypv5HRcAAAAAUlrgb9euXYqMjLTKdsaoVq2avvnmG0VHR8v1hkydkJAQDRkyxCoH+sgjjyTDiIH0Lbd3br1Q9QVruXDlghYGLbT6AppgoAn0fbvpW2vJ7JHZygAMi7x90M8wx09fPh0b+LuRt7fUvLm9GCdOSEuX2kFAE9s7cjSX3tnRVu+orSSHavnsUpeii9UgarEKBv0u1+BgadIkezGKFr0WWTSLyQj08Ej0fycAAADAyJEph7zcve74e7E5bs67q4UL7c8aNSQ/v0QcJQAAAIC0JFkDf8HBwfL19ZWnp2fsvhw5clh9/86ePSu/Gx5mPvnkE7Vu3VolSpRIhtECuF6WDFn0eNnHrSUiKkJ/HPzDCgKa5eiFo1ZfwMRmWvo9/bS9mPaCgYHXgoC//+6iNefKaM3mMpJ6ykPheizvGnXIs0i1LiyW7771ctm/XzLLxIn2DTNmlKpXjxsMzJ070ccNAACA9Mm84BbYPdB62e16gwZJM2ZIbdpIQ97LcdsX4eKgzCcAAACAlB74Cw0NjRP0M2K2w8PD4+xftWqVNmzYoDlz5vznn+twOKzlxu3r9wFJJS3ON3dXdzUs2tBahjcdbvUA/Gb9Nxq3edxdrzXZvff6b1GqlL3E9Af8+287CGiyAlev9tCvxx+wFukD+eisnij8t1r4rVa18DXKd2iN3C6clVassJerHDFZgbVq2UulSqk6KzAtzjekXMw3OBPzDc6UUudbShsPbs0E9a4P7EVFSaumSjoldXnUHI/HTcwvuzHl7An8AQAAAEipgb8MGTLcFOCL2fby8ordFxYWpv79+2vAgAFx9t+r8+fPxykjah6YTb9Bw8XF5T/fH7iT9DDfSmQuoQ5lOsQr8Nfs52aqX6i+7s9/v2rnq61SfqXu+d+lXDl7eeUV6cIF88KAu/74w12//+6hXbuy6duDja3FcFG0qmbapTYFV+pBz9UqHbJGWY/uuikr0JExo6IqV1bkffcpqkYN69ORK5dSi/Qw35ByMN/gTMw3OFNKnW/mBSqkHibgZ943W75cOnVK8vGRHjDvqMXH2rXSuXN2iU9TsQIAAAAAUmLgL3fu3FbfPtPnz93dPbb8pwnuZc2aNfa8rVu36vDhw+rZs2ec6zt37qyAgAC9//77Cfq55t5ubm43vSnr4+OToh7kkTall/nmfdk7XuedDj2tKYFTrMUw/U3qFaoXu1TKU8nKKEwo84cUUzrJLMbJkw7r7yVr1th/N/n7bxdtuFRWGwLLmv81sc7JqnNqnW+tHs2xWtUj1yj/4TVyv3BW7qtXW0sMR5Ei17ICzefdsgLN29kmGvnll9LDD8uZ0st8Q8rAfIMzMd/gTCl1vkWZSBJShWnT7F8Hjxy5ti8iQpo9W3rsMcW/zGejRtJ1z7IAAAAAkKICf2XKlLECfps3b1b1q28tmnKeFSpUiJORV7FiRS1atCjOtY0bN9YHH3ygOnXqJPjnmof1Gx/YY/alpAd5pF3pYb7F97uNajFKJy+e1J+H/tTqw6ut/ifTd023FiOLZxbVKVRHDxR6QPUK19N9+e5TBvcM99QfsFUre4mplrRzpykJagcDzbJrl4/GH2tsLdZ3ULQqZQjUk4VW66GMJitwtbIe2SmXAwcks0yadOtegSYgaH6g+YNcpEOXerytrIH/6HyPt5V5+8Nyc3fuf/f0MN+QcjDf4EzMN6T3+ZaSxoI7B/0ef9zuUX09k0Rq9k+ZEo/g38KF9idlPgEAAACk5MBfxowZrYy9gQMH6qOPPtKpU6c0btw4ffzxx7HZf1myZLEyAAsXLnzLjMHs2bMnw8gBJJYa+Wuoat6q1np4VLg2HNugFYdW6M+Df+qvQ3/p3JVzWrB3gbUYGdwyqFaBWnqg8ANWRmDtgrXl7Rm/7MLrmSTjihXtpWtXe19IiN0nMCYQuGaNqzafLaPNe8pIej42K/CRnH+rZa7VqhG1WgWP2lmBN/YKVJEiOlygtpZtyqaOl9bZ1wau0zN5F+mx0U3i92Y3AAAAUjWTlGky/e7UjvHVV+2X026byBccLK1fb683tl9QAwAAAIAUGfgz+vbtawX+OnbsKG9vb/Xo0cPK5jPq1q1rBQEf4y/kQKpjSnZ6uXspLDLstueY4+a8GJ5unlYgzyxv1HlDUdFR2nZqm1YcXGFlBJpg4KlLp/THwT+sxXBzcVO1fNViMwLrFqorv4x+9zRmX1+pSRN7MUzbnD174mYFbtvmo4nBjawlJiuwvHug2hRcrQaZVqvsudXyOWpnBRY8cEAdr7u/+XvPl6fbadj/+ihPv0q6v2sFqWBB87r+PY0XAAAAKZt5L+z68p43MgHBw4ft8+rXv81JixfbJ5o31vLlS6qhAgAAAEgjkj3wZ7L+Bg8ebC03CgwMvO11dzoGIPkV8imkwO6BVunO/7d3J/BxlfX+x7/JZN8mW5eUbnRfKN2wZSkoUHa9QKuCyKKAeJW2/pGLSAFFqnABEahcpXCtFAHxsshdFFoqoqylFLpBG9p0b9I2STPZ18n8X89zMpOZ7GnTSTr5vH09rzNz5szkJBynefKd3+9RO0zoZ45rjyvapWmDp9mxcPZCu77O58WfByoCzdhdulsf7v/Qjl++/0v7vCkDpwQqAs02JzXniL4H03F4/HhnfOtbzr6KCucD1/4g8P33o7Xp0ERt2jlRdwdVBZ4a9aG+6fuDrtUfAq9n4r0sHdZ9ulO6T84wixFOmeL8Ice/PekksxjpEZ0zAAAA+o6Cgh44jjafAAAAAI6n4A9A5DKhXkfB3pGsYzM+e7wdN8640e7b7dltg0B/VeDWoq22StCM/1j7H/aYMZljbAjobyt68qCTbbXhkUhJcT6N7f9Etvnw9e7doVWB69a5tco7V0t0pxrkUoy8gec3KkolylCBBmuS63NFl5ZK77zjjGCmvXFwGGi248Y5PUoBAABwXMjJOcrjTAsKf/Dnb0sBAAAAAB3gL8gAjmsj0kfYcfXJV9v7phWoCQH9VYHrD6zX9sPb7fj9+t8H2oNOHjjZhoAzBs+w26mDpx7RWoGmS+fIkc74xjecfStWSM9/a5VmyVnbL1i0fLbq7yo9r7e8X9JJrq06b/AmnZ66SZO9GzXk8CYlFu930kQz/vd/m58cHy9NnNgcBPpDwcGDaRcKAADQB515pjR0qLR/f9vr/Jlf4czj5rg2bdggHTwoJSdLZ5xxrE8XAAAAQAQg+AMQUQYmD9T8SfPtMDw1Hr239z29s+cdfVzwsdYVrLPtRzce3GjH03raHhclp5rQhIAzc2barWkxmp6Q3u1zGDHcpyW6W15Fy6XGVo+b/ebxc5LW6OOqqfp4/9SQxzN0WLMSN+m8QRv1hYRNGluzSQMPbJKrplJav94ZwbKyWlcHTp7s/IEIAAAAvcblkh57TPrqV52QLzj8839u69FHnePa5K/2O+cc50NgAAAAANAJgj8AEc0EdxePvdgOw6wTuL98vw0B/UGg2eaX59s2oWY8v+n5wPNHZ4x2KgODhlmbsCNnzq5TsWunXN7WoZ9hwsCRrl3yHKpTweF4bdqkwNi8WdqyJVMrq7+olbu+GHhOlHmOdumL6Rv1paxNmurapBPLNirt0DZFFRdLf/+7MwJPiJJGj7ZBYILZTp0qTZjgLFho+pUCAAAgLObNk156SfrBD6R9+5r3m0o/E/qZx9v1+uvOljafAAAAALqI4A9Av2LWCRyaNtSOfxn/L4H9ByoO6JOCT5xA8IATCu7y7FJeSZ4dL372YuDYYWnDQioDzchJbV6YZX/9QX3pB+VKr2j/PEpSyvSPhoMaPmy4hg2TLnZySau+Xtq2rTkMdEa0du4cpZ2eUXrac1ng2ARV66Soz3TuwE06I3WjJjVu0gmHNynBc1Davl1R27er1WqGJ5zgBID+INC/NScSHX20P2IAAAC0YMK9Sy+V3n5bKihw1vQz7T3brfQzysqkd991bl94YbhOFQAAAMBxjuAPACQNThmsi8ZeZIdfcVWxPjnQFAY2jW2Ht2lv2V47/jv3v0Oe718z0J3g1s60Wimto69Ya1uODncPb/VIbKw0aZIzrriieX95ufTZZy0DwUR9VDRTHx2cKR1sPnaADumUuE2aO3CDpsZ9qjGN2zWoZKsSSg85i8yY8eaboV84MVEaN651IGj2HUmV4OrV0qJF0tKl0ty53X8+AABABDEh35e+1I0nmG4ODQ3SmDFOJwcAAAAA6AKCPwBoR1ZSluaOmmuHX1ltmdYfWB/SJtS0BzUVg3/d9lc7jpXUVGn2bGf4mXViDh4MbRVqtp9+OlCvVZ+r1/adG/Ia6SrRBOXq9OxczUrdqgnRuRpWuVXpRdsVXV0tbdjgjJZML6q2qgTN/jaqBL0NPlUuWKy03C0qW7BYyZvPlSumaSEbAAAAdI42nwAAAACOAMEfAHRDWnyazhpxlh1+lXWV2nhwY6Aq8J297+jz4s87fa2H3n3Ivs7EARM1IXuCBiUPsq1Iu8McPniwM847r3m/1yvt2CFt3OjTJ5/UaM+eBOXmRik3N0MflJ6qD4pOlYqaj3epQSdqp06Oz9UZWbmamrBVoxtyNdizVQllhc6CNGb87W+hJ5CU1KpK8G/7xuu5+/do+eG1zs8sd62uzlmlecsu6HgNGwAAADR/ussf/NHmEwAAAEA3EPwBwFFKjkvWacNOs8Mw4d/MJ2d2+rwXPn3BDr/0hHQbAJoxMXtiYHtixomKiY7pdiupsWOdzlDnnlsrtzvBhoTmb0iFhVJubssRox07xmp77Vi9kv/lkNfK0GGNV65OTc/VrLStmmiqBKtzlVG8XdFVVdL69c5ocm7T8JlgUlKjonR/0Y26Zf4jcv9yjM69abRTvggAAIC2mQWfd+2S4uK62R8UAAAAQH9H8AcAveTqKVerpKZEW4q2aGfJTnlqPPpg3wd2BItzxWls5tiQQNCM8dnjlRLXvbX3TPg3cKAzzjwz9LH6eqdK0B8Gfv65/3amPjh0mj7wnCZ5WlcJTonZqtMyczUtcauS9+Vqknej0lVmQz8jWj4N0z69pK9J/yZnDBggjRrlrFfTcpjyxW5WPgIAAEQUf7XfnDlHttYyAAAAgH6L4A8Aesktp92iGTkz7O2ahhrbHtSsF2iGCQPNNrcoV9UN1fq08FM7WhqWNsxpFZo1IdAy1ISDA5MHdrttaGys063TjJZKSoKDwOYqwW3bnCrBPx/6StORPq3RbM3Qx4qRN/B8U/VXpSRVKVEDTY9RU3Zoxpo1rb9YYmLboaDZN3Kk88l3AACASEabTwAAAABHiOAPAPqAhJgEnTzoZDuCNfoatad0j7YUbmkVChZWFWpv2V47VuWtCnlecNvQ4UnDNXnIZI3JHKPRGaPlTnB3+/wyMqTZs50RzKwluHevEwQ+/7x04JlVmiVnbb9gpuovRZWar5f1vk7TKO3Q+Jg8nZKep8mJeRrl26HBVXlye3Yrqrpa+vRTZ7R6oWhp2LDQMDA4HHR3/3sDAADoU2pqpLfecm4T/AEAAADoJoI/AOhh2UnZNsgzVXztMY+b4zoTHRWtkekj7bho7EUhjxVXFbcKAztrG2pkJmbaAHB05mhnmzFaozJG2ftDUofYr9mdtQRNEZ4Z8XE+JT33I3m9UXLZFf5CeRWlJa4f6fKB6/Vp4TRtaJim/yoKPSZG9Rqh3RqtPE1PzdPJKTs0LiZPQ2vzlOXJU2xdlbR7tzPefLP1CWVlhQaCJiQ0Y+hQZ5gEkzaiAACgL3v7bcl8EGrIEOmkk3r7bAAAAAAcZwj+AKCHDXcPV+6CXBVVtUi1gpjQzxx3NLKSsnTG8DPsCBbcNvSzws+05eAW7a3Yq7ySPB2qPKTD1YftWJu/ts1A8sT0EwOhoA0Em0JCsz8+Jr7d8xkxYbsSEzbKVdn24yYMHJawUe+s267hA8faSkGzpqAZeXn+bax27BijvJIxWlUuyYwAnwbpoA0FJ8Tu0Ax3nibF52lkY54GlecpqeKQVFzsjA8/bPskkpKcADA4DPTf9m97IhxcvVpatEhaulSaO/foXgsAAPTPNp8XXMAHlgAAAAB0G8EfABwDJtQ72mCvJ9qG+nw+lZaWyu122zX/ymvLtaNkhx0mCMw7nOdsS/K027PbhoamatCMlqIUpaFpQ0PCQP/W7CtRuc66SRrQTvBnHEqW/kflOjGoUvCcc9peU7B1KBilHTsG64M9g/Ve/Rla3iJXTTGvq502GJyRlqeTkndqePReDa7fp8zKvUqsLJKqqpzFCs1ojz8cbCsU9N/uIBz0NvhUuWCx0nK3qGzBYiVvPleuGP5oBwAAumjlSmdLm08AAAAAR4DgDwD6kdT4VE0dPNWOlhoaG+x6goEwsGnrDwkr6ioCawr+Y/c/Wj0/JS5FFW5pXw8ss2dytZkzndFSfb3T6TM0FDTbVOXlnaxNFSfr1TJJZgSJV42Gap8dI6L3aXLaXo1J2OeEgw1OOJh0JOFgUDD43t5h+t//2KP7S51qyrTctbo6Z5XmLbtA8+Yd/c8FAABEONMSwaxzbNY1pmsAAAAAgCNA8AcAsGKiY2zlnhnn6byQx0zlYGFVYasw0H//QMUBGwx2xZ1v3qnpg6drhHuEXbtwRPoIWx2ZFJvUpefHxkpjxjijJZ9PKipywsCdO6V9+4JHgvbuHaN/FoyRr1GSp/XzTTh4gvZrmPZqeNQ+TUrdq7GJJihsCgerOg4HT28agfOR9Nui+Vo1/3zlXThEo88cIuXkOMOs22O2Zl1C88c9AAAAf7XfrFlSZmZvnw0AAACA4xDBHwCgU6ZN6MDkgXacNuy0Vo9X1lXqL9v+oiteuqLT13p9++t2tDQgaUAgCDShoB3pTeGge4TcCZ2XEprumwMGOGP27LaPMRWDBw60DAWbw8F9+0brnf2j5fU2VQ2WtR8ODtM+TTThYMI+JRbv1fjGzzRWec3nY6osVan5+rNkvuXW37YUEyMNHtwcBAaHgsH3zTflcnX6MwAAoLfV1tbqZz/7mVatWqWEhARdf/31drTljTfe0K9+9SsdOHBAEyZM0F133aXJkycHHn/66af1u9/9ThUVFbrooot09913KzExURG/vh9tPgEAAAAcIYI/AMBRS45L1pjMNkrw2rBo1iJ5fV7t8uzS7tLddm3B8rpyW1Foxtp8p01mS+54d0gQ2DIYzE7KtgFlVyoGTWdOM9pjQr+DBzsOB9/bN9qGiCpvGvJpjWarQbsUI2/zaynaNhh9Vt/U5IwCjYwv0ICGAmVU5zvVgw0NzS/eEVMVOGhQ62CwZUhojjHfJAAAveTBBx/U5s2btWLFCuXn5+v222/XkCFDdGGLMGvbtm269dZbde+992rGjBk25Pvud79rw0AT7q1cuVKPP/64HnroIWVlZemOO+6wt3/yk58oIpnfCVavdm4T/AEAAAA4QgR/AICwum7adZqRMyOkjainxmNDQBsGenY7gWDQ/eLqYpXWlmrjwY12tMW0CjUtQ/0tRM3tE1JPUE5qjoakDlFOSo4yEzO7FA6awjqTp5lhOm21pbHRaStq8rrnn5c2/fZZzapqHVq61KgR2qN/Jk3UXSX3hTwWqzoN0kHlqEBDlK9hMQUak1ygE+PydUJ0gQZ6C5RRU6DkyoOKMl+woMAZH3/cedljRwGhuW2qDOPi1KNWr1bqwoXSr38tnRfaLhYA0D9UVVXpxRdf1FNPPWUr98wwAd9zzz3XKvh79913NWbMGF122WX2/g9/+EN73Pbt2zVlyhQ988wzuu6663T22Wfbx00V4Q033KDbbrstMqv+1qyRSkudFp+nnNLbZwMAAADgOEXwBwDoVSaIy0jMsGPa4GltHmPWD9xTuseGgIFKwaZqQbPNL89XVX2VthZttaM9ca44GwDaINAEgilDQoJB//6sxKxOA0JTgDdwoDO2Hdytrz9/nbxVJuhrzdT/LXFfp4m3nqUTs0bY7C4/32R4cSooGKa8gmFae9h80l9Saevnu9SggTpkA0IzhkXn24BwZEKBhkbna1BjgTJrCpRSeUDRjV7p0CFnbNjQ8Q/frC/YWYtRs01I6Ph1zPfY4FPlwsVKy81V2cLFSt48V66YzkNWAEBk2bp1qxoaGjR9+vTAvpkzZ+qJJ55QY2OjooPWtU1PT7ch37p16+zxr7zyilJSUjR8+HB5vV5t2rRJCxYsCBw/bdo01dfX268R/PoR1+bTfHiG9t4AAAAAjhDBHwCgR5hWmwkxCappqGn3GPO4Oa67UuJSNGnAJDvaUttQq71lewNBoAkHTVBYUFFgQ8GC8gJbNVjnrQuEhh0xAeHglME2CAwJBYNDw9QhgYBw9LgCDS3ztRn6GWb/sHKfrr6uQKeMHtH291DrrD3YHAoGjxgVFAzR/oIh+uSQ5GsMbjHaLFpeZasoEBCeICcgPDGxQENdBRrcmK+s2gKlVhbI5a2XioudsWlTx/8B0tM7rB5cuTFHf/rJp1p++CN7eFruR7o6Z5XmLbtA8+Z1/NIAgMhSWFiojIwMxQVVlWdnZ9t1/zwejzJNNVuTiy++WG+++aauuuoquVwuGwouW7ZMbrdbJSUl9jkDzSdsmsTExNiw0KwH2B2mu4AZLe8H7+sTVq606wP7LrjAnGRvnw16SJ+93hCRuN4QTlxvCCeuN4Sbrw9ec905F4I/AECPMK01cxfkqqiqqN1jTOhnjutp8THxdo3BjtYZNOHggYoDThAYFAjmVzRtm/ab8zcBoQkOzehIbHSsDQHT4tLkuUkaUNn+sYeSpf9Jar+1Zny8NGKEMzpb/sesPxgaDPoDQ5cKCgbZsfnANLtWocw5tTovn7JUHAgITZvR0YkFGpVYoGEx+RrsK1BWXYHcVQWKqa+RPB5nfPZZm+d0QdMwv37YP1hK+nXRlXp5/nzlzhuo8WdkO+1HW45IbNMGAP1cdXV1SOhn+O/X1dWF7DfhngkKzZp9U6dO1R//+Ee7jt+f//znwLFtvVbL1+lMWVlZSKWhmTCblqRGV1qAh0NUUZHSPnI+QFN26qnymZafiAh98XpD5OJ6QzhxvSGcuN4Qbr4+eM2ZDipdRfAHAOgxJtQ7FsFeT4WDI9JH2NERE/oFAsKmQDAkLGzamoCwvrG+ORx0S/vcHZ/D/P+ab9cfHJQ8yBkpoVtTZTgweaA91/bExEgnnOCMjvjXIGy7gjBKBQXZys/P1ucFU2T/flrdNEL4lC5PSEB4YnyBRiUVaIQJCFWg2KICDfXtVYJqbehnmG2GPLpRv5NekTPakpTUdiCY3U5QmJbmrGEIAOiz4uPjWwVz/vsJLVpH//KXv9S4ceP0zW9+095fsmSJLrroIr388sv66le/GvLc4Nfq7vp+aWlptqKw5SdlTWVhX5nE6y9/UZT5RPHJJyttwoTePhv0oD55vSFicb0hnLjeEE5cbwg3Xx+85sxyCF1F8AcAQIs2n10JMP0BoQkH397ztm5747ZOX9u0IDWjM+kJ6aHBYNNtEwy2DAxN+9TO1iCcOrX9r2V+jykpCa4abBkQZtjxQf4k2Q861TYNv7TdWlN1sWY0bFWMmj955FWUCqKz9bLrEo1NqtUJ8YXK9BbKXVuo5OpCp9WoecHdu53RFbGxbYeCwfvMbbN2oX/bolLkmFi9Wlq0SFq6VJo799h/PQDowwYNGmQr+cw6f6Y1p2Gq+kzoZwK4YJ9++qmuueaawH1TlTdhwgTl5+fblp4mRCwqKtLo0aPt4+Y1TbvQAeb9vhvMRL3lZN2/r69M4rVqld1EXXghH3KJQH3uekNE43pDOHG9IZy43tDfr7mobpwHwR8AAEcZEMa6Yrv0nN9e8lu54906WHlQBysO2q0JD/33D1UeslWEnhqPHbnFuZ2+Zlp8WqBaMDgoNJWDLYc5tvUfPiWz3JIZkyd3HBCWl4dWDv7Xyj2qqh2rWS/UtzreJZ+GNhbqr19/Tqte2y4dCg5SfUpTmV2PcIAKA2NoXKGGJRQqJ7ZIg6ILldVYqPT6QqXUFCqurlKqr2/+4l2VmuqEgMGBYGe3uxEWeht8qlywWGm5W1S2YLGSN58rV0zf+IUQAHrDxIkTbeC3fv16nXLKKXbfunXrNGXKlJB2m4ZZvy8vLy9k386dOwPHmq157uzZs+1j5jXNa5twMKKYMv2VK53bZn0/AAAAADgKBH8AAITJrBNmaUbOjA7bCJTUlARCQbMNDgbtNui2qTosqy2zY9vhbZ1+/XhXfJuBYPDwh4YDkgfYcDM4IDSFGmaMH+/sK08u1LTv1cs0GmhuoNbM7F/yz3qNWFSoaYOHq7DQVH2YFqRRKix027G7cLTWFTlrF8p0c2tn2aYEVdtwMDgsHBxdqOGJhbaa0NzOUpHSvcVKrS1SYvVhRfsanbTSjJ071a2wsAsh4epPsvTqLzbr8cNr7dPSctfq6pxVmrfsAs2b1/UvBwCRxLThvOyyy3TPPffovvvu06FDh7R8+XLdf//9geq/1NRUWwH49a9/XT/+8Y910kknafr06XrxxRdttd/ll19uj73qqqvs+n+mHagJCc1rmud0t9Vnn7dhg7OAb3KydMYZvX02AAAAAI5zBH8AAPQRphovMzHTjokDJnZ4rAkJS2tL2wwHTeVg8DD7KuoqVOut1d6yvXZ0hWk5GhIMJjWFgylOOBiVVajhpW2HfobZP6xMuum6ep0yuqPvRSot9YeCzrY5JPTfTlRh4XAVFQ3X54VSZaWpkJBU2TRa/izVaNcnNEGhGVkqttvBMcUallhkqwoHuIqV7TNhYZFSa4uVWF0cGhbu6rgtq2nqGdzY03R/f7Locn00f6YKTslQzqQMKT29eWS0c98EjS2qYADgeHbHHXfYkO66665TSkqKFi5cqPPPP98+NmfOHBsCzps3TxdffLEqKyu1bNkyHThwwFYLrlixQlnmQxaSLrnkEu3fv9+Gf2ZtP/Mat93WeWvt446/2u+cc8wiib19NgAAAACOcwR/AAAcpeykbLvWXk1DTbvHmMfNcT0ZEppgzozx2U0leB2oqq9SYWVhm6Fgy31meH3eQMvRz4s/b/d1h94kDWgjePM7lCx9fft/6dPyXPv9ZyVlKSsxy27NuUdHRdtqQn8WNnZs177/6uq2Q8LiYmdbVBStoqJMFRdnalfROH1U5HQKlaksLG/7Nf1hoT8k9G+HxBbphIRi5cSZFqRFylSxooqKNNiXr3SVBj1fSlK1ztI70kdyRleYH4Db3X4w2Nn9pKTeWw+K9Q0BtMFU5D3wwAN2tJSbG9rG+mtf+5od7bnpppvsiGivv+5safMJAAAAoAcQ/AEAcJTMOn+5C3JVVFXU7jEm9DLH9Zak2CSNSB9hR2cafY028LPBYNPagyGjytnu9uzWXu3VPnfHr/fIB4+0ud+EfhkJGSFhoNnagDDofsttfEy8TJe3YcOc0RX+NQqbg8GWQaG57YSFZuwqGqt1xU1hoX8ES9utNdUXa0Z9uWJs6aHDqyjtdJ2gB2Jv1oAGl4Yklig71qMsl0cZ8sjtK1Gq16Pkeo8SazyKMWGxOTmPxxlHIiamOQj0h4FtbdvaZwJH8/wjwPqGANADysqkd991bl94YW+fDQAAAIAIQPAHAEAPMKFebwZ7PckEcv6WoxOyJ7R73McFH2vmkzM7fb0LRl9gw8Ti6mIVVxXbrWk9GthXXdyt80uOTbYhYKuAMDErcN7+kZGY4WwTMpSWFmvXKDzxxO6FhS1Dwj+/uUeVNWM164X6Ntqb+jTGu097vvYT/edr26XSjq+JeNXYKsPgkaESux0U59GgeI8GxJYoK9qj9CiP3I0epTaUKKneo4Qaj1yNDc4Cif6TPBKm1Wg3A8O/vpeuF3/8kX7P+oYAcHT+/nfnfXzMGGl0B32xAQAAAKCLCP4AAMAxdd+592lGzoyQfbUNtTpcfTgkDPRvTeVkW/vN8SYsrKyvVGVppfaU7unWeaTGpbYOBRMy2w0L/ePEExM1alRzJVu1u1DTvlcvb9M6hi2Z/Uv+Wa8zf1moC6cNDxTztTVKShLk8Qy2Y69H2uSRqqqaXqiuabTLpyRVBYLC4G1mVIkGJ3g0KLap4jDKPFaitEaPUupLlFjrUXxdhfMy/jUN93T953lx0zDrGkY1bZcVzdOa+bOUPytdQya6nWrC4GFS15b7zOjNVqUA0Nto8wkAAACghxH8AQCAsDPtOnNSc+zoKhP6ldaUtg4JgwLCkpoSGxCa4b9t2pYa5XXlduwu3d29c3XFh4SCcfXSv5S2HfoZZv+wMunMOSWaMb7RVlB2R12dVFoaHA62FxxGyeNJVklJsjyeodpW4hxrnm+TuOqm0Y4Y1beqMjRbM2y1YVyJBsR5lB3t7EvzOdWG0eWHld5YKpcabehnmG2yqnSO3pI+lDO6yuVqOxRsLyj0709Ls2td2tDQVC1Gd+/nfKS8Xmnzo6s18pFF2nXLUp30/+babwEAus2UlvuDP9p8AgAAAOghBH8AAOCImFabCTEJqjHr1LXDPG6O6wl2TcDEDDvGZI7p8vO8jV4b/rUMBFuOtvY3NDao1lurgooCO/y+cJM0oLL9r3koWdr/p/MUpSilxqfKHe9WWnya3Anu5tvxbnvff7vV41lujRzi1snxaTYo7erfkGtqmsNCs23vtscTq5KSAXYc9EhbS5zCvw6rDd17pB+P05qnGzWjQIrxBf2co6RdbumXs13KeuffNCgqWlkxpcp0lSo9qlRpKlVKY5mSG0qVVFeq+NpSRfsanSTNf3LdYMLGwPKSJvQzgaBpRWpCQbMNvt2VfbGxnX7NV16RfrDIp5f3L5ZbW1T7b4s18pFz9djSKFqcAui+bdukXbukuDjpS1/q7bMBAAAAECEI/gAAwBExaxrmLsi1VXeGz+dTRUWFUlJSnEqspnCwt9c+dEW7nHUAk7K69Tz7/dRVtAoF1x9Yr1+8/Qvtc3fhNeRTWW2ZHUfDVB0Gh4StAsOmfSEBYqpbGQPcGtm0LyWu+b9Le8wyU6basL2w8C8fFylxT61m5bd+rssnjfZIOwZ49UTa16WCGZ3+dJJVqTSVya3SkGH2ZUSXamBcqbLjSpVlwsNo57hUX6lSvKVKqi9VQm2pYrx1UmNjcynkkTItR9sKCJtub96XrtXPufV97dYsOWsbmu25+1foX+dfoujnU3TZlQm0LQXQdf5qvzlzpJSU3j4bAAAAABGC4A8AABwxE+r5gz0TlJWWlsrtdncaMB0PzPdgqvXMGKERgf2jMkbZ4K8z713/nj22tLbUBn+mTWmnt2tL7X3/bRM8Gqbq8FDlITuOpmKyrerCtqoQ7f3UNLkHuDU+OGhcVa8Z31fH6xu+KZ21xKeLZzghYlmZsw2+7WyjVFqaorKyFJWWDtGBMim36TGT48kMU0zafkGpFa8a26bUhIL+1qX+2yYwHBjv0cBYj608zIj2yO0rVapZ67DBo0RbedhU5mgWVzSjoLmyM9hJkn7Txv6n9W3nxlWS7xqXoswf7/3DtCAN3h7JbVMJ1EfQ5hToYbT5BAAAAHAMEPwBAAAcA6Y956CUQXYcKdOm1F8x2DIUbHW7rjlEbBksen1eu0aiaXnqX/PwSMQ1SLu7sL5hUfZyfdDwoVIzU5WWk6ahcamaFJ9mQ1QTIKbGpSopNqnNgNi0K62s7Cw0NMV9PhUV1am6Ol4ez2A7Cj3SNo/zuA0PTRJZ1fH3FC2vrTBsGRqabUaUR4MTPMqIKlVs/T6N0+eaU7+h3deKMsmY/4R7ign+2goEk5Obt/7Rnfvx8d2qTqTNKdDDTF/mt95ybhP8AQAAAOhBBH8AAAB9lGlT6l/X8EiZSsyq+qpWFYYtg0O77eAYs5ZjXUwX1zdc/xtpfecViCYADA4D7dZUWfpv+7eZqUodnKoB8Wka1XR8SmyKXYdw2IBhrUJEEx5WVDR3/zTDCQvb2ueSx5PRNKT9Ta1OTdtTmTUMq5vWNvx/Zm3DWjW0WNuwIUr6JEc65xtxSnnyHaWWu5WiCjtSVR7YuqMrlBlXoczYcqXHVCjNVaG0qHKlqkLJvgolNZYr0VuhhPpyxdVVKKah1vkCdXXS4cPO6ElmXcQuBoVb9iRrzYvJur1Fm9P5+x/T3fPPV+KyVF10RZpzfKSWAK5erdSFC6Vf/1o677zePhtEgrfflqqrpSFDpJNMTTEAAAAA9AyCPwAAgG4w6xYmxCTYIKw95nFzXF9gArHkuGQ7hqQOOeLXqfPW6e3db2vuH+Z2ur7hJWMvUZwrTuV15TY4LK8tD7lt1j40FYj+sPFoxUTHtNvCNLAmYkaa3IPdyk5wa3Tw401b8/MxYaQ/ODR/j/eHgytWFemTj9pe29CEgF/Il04/WKdtU1xKKB+nknJpb4UTPpqiHquLrUsDr6v6QIAYHCL6b5v1EdNjKpURWyF3bKXcrkqluiqVFlVhHzMj0VfphIneSsXVOyMQKJqSSFM+aUYnJkp6oI39j+oW58Z3m4Z/rcS0NKc60b9t73Zn+2L6xlTF2+BT5cLFSsvNVdnCxUrePFeumOO/nTH6SJvPCy5gbVAAAAAAPapvzKYBAACOE2ZNw9wFuSqqKmr3GBP6+dc+jBQmyOtq5eG9Z9+rGTkz2q1ArKyvbBUG2m1decjtdvcFPdcEiA2NDSquLrbjSEUpqu3gMMGt2sG1du3CztY2LPl7seaMrFRibGIgRKyvd1qXlpc7QaB/G3y77cdiVVGRofLyDHs/P+gY28bUaGgapiqxi1xqCASDZpggseX9FBMqxlUqPbZSybH5ihr1O40t8eq8na1fryxOSmiQ4vzn5F8r8cABHbXExNZhoKkqNOGieayjbVeOSUjoNHAxLU5f+e4qPVv0kb2flvuRrs5ZpXnLLqDFKY7OypXOljafAAAAAHoYwR8AAEA3mVAv0oK9cFYgpsSl2JGjnCN+HRMgejwexSTFtG5Z2sa2rTUQ/VsTHJoqxPYqEM3aho93YW3DM/9wvm2Hapj2o2YkxzrVlm1uM5KVPCjZHpcam6zB7R0X5xxjbifFJquxPs6GiSYINFv/6Oh+8+0YVVa6VVHhtvc9ldK+psdMlWNAXdPI+Vj6ypNa85TT1rRlm9Ot2dLs70hxy95X2oHRthrRrJlotsG3s2PLlBVXbludZrjK5I4uV1pUmVJ95bbNaVJDmW1zGl9bphiv+cIm0Kx2xqFDOmY6CAcLSpPUsC5Bj+rvalSUouVTg1xaVHS3Tp1/vl56mfUNcYT27pU+/dRpuTt3bm+fDQAAAIAIQ/AHAACA47LNqT9ENOsCnqATjjhArG6obnvNw6bt1sKt+sJNT3W6tqE/9DPMuopmFKn9ytCjaW3qhIBJLULBprAxPVlJ2c2PZcYmaViL44Of49+X6EqWGpLkrUlUdVW0DQOfe1Nav07ttjk1+8/Pk/ZNjlPG6AEqKxug0nJpX7nTRdRUPFpm67/diVjVtRkgmpGkKqVGVyk1tlrumCqluqqUElOtlOgqJUdVKymqSkmqVqKvSgm+asU3Vim+sVpxDVWKq69STEO1XN6gE/GHi20wsfTXW37P8tr1Dc/L/A8tuPNfdOmlwyN2WUOEodpv1iwpM7O3zwYAAABAhCH4AwAAQL9tc2rCQ38QlpPadgXixwUf66lPnup0bcO131mrCdkTVFlXaduZmuDPf7u9bcgx7Rxnj6mvtJWJhtn21PqI7UmMSbQ/k9ioGP13F9qc/ul3z2vyoPVKjUsNVHSaQDZOKWqsTZFqUtVQnaTy8ijbrtSEgsHb0H1xKi/PUllZlr1f0PRYXV3QeolmqcKm5Qq7y7Q7TVS1DRHb2yYl7lHi2T/UT971alip5DRuba50XJKwULPn/ZteeuNzXXHh8XO9ow9YvVr64Q+d27T5BAAAAHAMEPwBAACgy2hz2j6zrp8/9DoW6rx1rQJDf2Whf1/w/pB9nT1eV2krH/3MbTNMm9PhXWhz+vi7D4dUPLa3jqL/5+MPBlOyUpSSkxIIDHPiUjU2+HH/7bhUxUWlKLohSWpIlK8+Qd66BDXWJshbm6C66ljV1ETZ5QVNAV9b2+bbMaquTlVVVWrgsUNBx9oCwPSPdX6mVyNKO6h03FOrvAITgvP/B3SRzyfdcYeTcBvnn9/bZwQAAAAgAhH8AQAAAMeBOFec4hLjlJGYcUxev9HXqOr66pCw0FQ7fqHymk7bnH5x3Hn2/CrqKlReV+5sa52tGb6m/5nHzDgWoatpMxsy0hOUmJ3Yan96TIJyYlrvNyMxNlFxrgS9/XG+bv5p55WO678WtOgh0JlVq6SPPmq+X1LSm2cDAAAAIEIR/AEAAADH0dqGx4oJz8x6f2b4me/ZtDjtrM3p/8z9d83ImdHuOoomSAwOBYODwU73BQWJthKxvtqeV623NiS09AeWPcFUOj7QhUrH6MldXLgQMNV+d99t+gs7t832nnukiy5ybgMAAABADyH4AwAAAPrZ2obhXkfRHygO0qAee10T9pn2pyYENMMfCLYcJixsc3/L473N+w9VHtIXblrbaaXj/yTF9dj3g35Q7bd2bfN9E/6Z+2b/BRf05pkBAAAAiDAEfwAAAEAn+uvahn252jG4vWdPMy1OZ+bP7LTSEehWtZ/LJXlNo9gm5r7Zb9b6o+oPAAAAQA8h+AMAAADQJqodgWNQ7ednQkCq/gAAAAD0MII/AAAAAO3qr9WOQI9W+0VHS42NrR83+6n6AwAAANCDonvyxQAAAAAgUlqcdqS3WpziOFNXJ+3Z03boZ5j9e/c6xwEAAABAD6DiDwAAAAA6aHHq8/lUUVGhlJQURTVVZdHiFF0SH++08ywsbP+YgQOd4wAAAACgBxD8AQAAAEAHLU5N8FdaWiq32x0I/oAuGzbMGQAAAAAQBrT6BAAAAAAAAAAAACJArwd/tbW1Wrx4sU455RTNmTNHy5cvb/fYt956S5deeqmmT5+ur3zlK/rb3/4W1nMFAAAAAAAAAAAA+qpeD/4efPBBbd68WStWrNBPf/pTPf7443r99ddbHbd161YtWLBA8+fP16uvvqorr7xSP/jBD+x+AAAAAAAAAAAAoL/r1TX+qqqq9OKLL+qpp57S5MmT7di2bZuee+45XXjhhSHH/t///Z9OPfVUXXvttfb+iBEj9Oabb+q1117ThAkTeuk7AAAAAAAAAAAAAPqGXg3+TLVeQ0ODbd3pN3PmTD3xxBNqbGxUdHRzQeLll1+u+vr6Vq9RXl4etvMFAAAAAAAAAAAA+qpeDf4KCwuVkZGhuLi4wL7s7Gy77p/H41FmZmZg/+jRo0OeayoD33//fdvys7t8Pp8dLe8H7wOOFa43hBPXG8KJ6w3hxPWGcOqr11tfOx8AAAAAQD8P/qqrq0NCP8N/v66urt3nHT58WAsXLtSMGTN07rnndvvrlpWVhVQTmgmzaTtqREVFdfv1gO7gekM4cb0hnLjeEE5cbwinvnq9mS4pAAAAAAD0meAvPj6+VcDnv5+QkNDmc4qKivTtb3/bTr6XLl0aEuB1VVpamlwuV6tPyrrd7j41kUdk4npDOHG9IZy43hBOXG8Ip756vXm93t4+BQAAAABAH9Orwd+gQYNUUlJi1/mLiYkJtP80oZ8J51o6ePCgrr32Wnv7mWeeCWkF2h1mst5ywu7f15cm8ohcXG8IJ643hBPXG8KJ6w39/XrrS+cCAAAAAOgbul8u14MmTpxoA7/169cH9q1bt05TpkxpVclnWuvceOONdv+zzz5rQ0MAAAAAAAAAAAAAfSD4S0xM1GWXXaZ77rlHGzdu1OrVq7V8+fJAVZ+p/qupqbG3ly1bpj179uiBBx4IPGZGeXl5b34LAAAAAAAAAAAAQJ/Qq60+jTvuuMMGf9ddd51SUlK0cOFCnX/++faxOXPm6P7779e8efO0cuVKGwJ+7WtfC3n+5Zdfrn//93/vpbMHAAAAAAAAAAAA+oZeD/5M1Z+p4vNX8gXLzc0N3H799dfDfGYAAAAAAAAAAADA8aNXW30CAAAAAAAAAAAA6BkEfwAAAAAAAAAAAEAE6PVWn+Hk8/ns1uv1ttrf2Nho90dFRfXS2aG/4HpDOHG9IZy43hBOXG8Ip756vfnnNf55DkIx/0NfwPWGcOJ6QzhxvSGcuN4Qbr4+eM11Z/7Xr4I/8x/K2LRpU2+fCgAAAAD06DwHoZj/AQAAAOiP878oXz/6eKj5gTQ0NCg6OrrPpLQAAAAAcDSfQo2JibFzHIRi/gcAAACgP87/+lXwBwAAAAAAAAAAAEQqPhYKAAAAAAAAAAAARACCPwAAAAAAAAAAACACEPwBAAAAAAAAAAAAEYDgDwAAAAAAAAAAAIgABH8AAAAAAAAAAABABCD4AwAAAAAAAAAAACJAvw/+amtrtXjxYp1yyimaM2eOli9f3tunhAj2xhtvaPz48SFj0aJFvX1aiDB1dXX68pe/rDVr1gT27d27V9/61rc0bdo0XXzxxXrnnXd69RwR2dfbz3/+81bvdc8++2yvnieObwcPHrT/Xs6aNUtnnnmm7r//fvs7nMH7G8J5vfH+dvxj/odwYv6HcGD+h3Bi/odwYP6HcDoYofO/GPVzDz74oDZv3qwVK1YoPz9ft99+u4YMGaILL7ywt08NEWj79u06++yztWTJksC++Pj4Xj0nRBbzD9Ott96qbdu2Bfb5fD7dfPPNGjdunF5++WWtXr1aCxYs0F//+lf7fgf05PVm5OXl2f2XX355YF9KSkovnCEigXkPM7+Ep6Wl6bnnnlNpaan9o310dLR+9KMf8f6GsF1vZp7A+9vxj/kfwon5H4415n8IJ+Z/CAfmfwgnXwTP//p18FdVVaUXX3xRTz31lCZPnmyH+cfL/Edm4odjwbxZmH+cBgwY0Nunggj9w4L5x8j8oxXsgw8+sJ+IeuGFF5SUlKTRo0fr/ffft78kLVy4sNfOF5F5vfnf62644Qbe69AjduzYofXr1+vdd99Vdna23Wd+MX/ggQd01lln8f6GsF1v/okf72/HL+Z/CDfmfziWmP8hnJj/IVyY/yGcdkTw/K9ft/rcunWrGhoaNH369MC+mTNnasOGDWpsbOzVc0NkMm8WI0eO7O3TQIT68MMPNXv2bP3pT38K2W/e0yZNmmR/KQp+rzP/sAE9fb1VVFTYNgm816GnmF+w//M//zPwS3jwtcb7G8J5vfH+dvxj/odwY/6HY4n5H8KJ+R/ChfkfwmlABM//+nXFX2FhoTIyMhQXFxfYZ/4jm9J1j8ejzMzMXj0/RBbzqaidO3fa3tPLli2T1+u1nyw2nyIIvgaBI3XVVVe1+143cODAkH1ZWVk6cOBAmM4M/el6M3/gioqK0hNPPKF//vOfSk9P17e//e2QtghAd5iWG6bPvp/547zpqX/qqafy/oawXm+8vx3/mP8hnJj/4Vhj/odwYv6HcGH+h3BKi+D5X78O/qqrq1v9wu2/bxarBXqSWUPEf809+uij2rdvn10gtKamRnfddVdvnx764Xsd73M4Vm0SzC9Go0aN0tVXX621a9fq7rvvtj3QzzvvvN4+PUSAhx56SJ999pleeuklPf3007y/IWzX26effsr723GO+R/CifkfegvzP4QT8z8ca8z/EE4PRdD8r18Hf2ZR7ZZvDP77CQkJvXRWiFQnnHCC1qxZI7fbbd80Jk6caD9FcNttt+mOO+6Qy+Xq7VNEBL/XmU+xt3yv430Ox8Jll12ms88+234SypgwYYJ27dqlP/7xj8fFL0bo+7+Er1ixQo888ohdM4n3N4Tzehs7dizvb8c55n8IJ+Z/6C38foRwYv6HY4n5H8LpoQib//XrNf4GDRqkkpISu86DnykZNm8WpswT6GnmjcJM+vzMIrSmtVBpaWmvnhci/72uqKgoZJ+537I9AtATzHuc/5ciP/PpKNMXHTgaS5Ys0e9//3v7y/gFF1xg9/H+hnBeb7y/Hf+Y/yHcmP+hN/D7EcKJ349wrDD/QzgticD5X78O/swn7mJiYkIWAF23bp2mTJmi6Oh+/aPBMfD222/bhZBN2w2/LVu22DcQ1hPBsTR16lRbnm7aCgW/15n9QE977LHH9K1vfStk39atW+0vR8CRevzxx/XCCy/oV7/6lS655JLAft7fEM7rjfe34x/zP4QT8z/0Fn4/Qjjx+xGOBeZ/CKfHI3T+169nN4mJibYk/Z577tHGjRu1evVqLV++XNdee21vnxoi0PTp021JulnPwfRA/8c//qEHH3xQN954Y2+fGiLcrFmzlJOTY1sKbdu2TU8++aR9z/vqV7/a26eGCGTaIJi+57/73e+0Z88ePf/883r11Vd1/fXX9/ap4ThlFtT+zW9+o+985zuaOXOmrc7xD97fEM7rjfe34x/zP4QT8z/0Fn4/Qjjx+xF6GvM/hFNeBM//onw+n0/9mPn0nZn4rVq1yi7MeMMNN7RKcoGeYv5Ruu++++ynjJOTk3XllVfq5ptvDmn/AvSE8ePH65lnnrGfMjZ2796tO++8Uxs2bNCIESO0ePFinX766b19mojQ6838IXXp0qW297lZ3+aWW27R+eef39unieOUmcw9/PDDbT6Wm5vL+xvCer3x/nb8Y/6HcGL+h3Bh/odwYv6HY4n5H8LpyQie//X74A8AAAAAAAAAAACIBP261ScAAAAAAAAAAAAQKQj+AAAAAAAAAAAAgAhA8AcAAAAAAAAAAABEAII/AAAAAAAAAAAAIAIQ/AEAAAAAAAAAAAARgOAPAAAAAAAAAAAAiAAEfwAAAAAAAAAAAEAEIPgDAAAAAAAAAAAAIkBMb58AAADh8uMf/1h//vOf2308Oztb7777bljPafz48VqwYIEWLlwY1q8LAAAAAJGOOSAAoD8i+AMA9CsDBgzQ448/3uZjsbGxYT8fAAAAAMCxwxwQANDfEPwBAPqVuLg4TZs2rbdPAwAAAAAQBswBAQD9DWv8AQDQwjXXXGNbwjzxxBM6/fTTNXPmTH3/+9/X/v37Q47btGmTbrjhBs2ePVszZszQv/7rv2rbtm0hxxw6dEi33367TjvtNE2fPl1XX321Pvnkk5BjKioqdOedd2rWrFn2mEWLFqmoqCjw+J49e+xrm68zdepUXXHFFfrHP/5xjH8KAAAAANA/MAcEAEQSgj8AQL/T0NDQ5vD5fIFj/va3v+mVV17RXXfdpZ/97GfasmWLnQxWV1fbxz/44AN94xvfsLfvu+8+/fznP1dBQYGuvPJK5eXl2f2VlZX2mDVr1ui2226z7WXi4+N1/fXXa9euXYGv9cwzz6i+vl6PPfaYbr31Vr355pu699577WONjY367ne/a7/ugw8+qN/85jdKT0/X9773Pe3evTvMPzkAAAAAOP4wBwQA9Ce0+gQA9CvmE5uTJ09u87Ef/ehH9tObhplkmUnfsGHD7P1Ro0bp8ssv16uvvmoncg8//LBGjBihJ598Ui6Xyx4zZ84cnXfeeVq6dKmdwJlF5M3XM9uJEyfaY8ynQi+77DKtXbtWI0eOtPumTJliJ3SG+VTohg0bAp/mLC4u1o4dO+ynTb/4xS/afSeffLKdQNbV1R3znxcAAAAAHM+YAwIA+huCPwBAv1vY/be//W2bj+Xk5ARum8mZf8JnTJo0yd43k7VLL73UtnhZsGBBYMJnpKWl6eyzzw5M2NatW6ehQ4cGJnxGYmKiVq5cGfJ1TRuZYOY5ZWVl9nZ2drbGjBmju+++W++8846dWJ511lm64447jvpnAQAAAACRjjkgAKC/IfgDAPS7hd3Npys7M2jQoFb7srKyVFpaqvLyctsSxkzIWjL7zOOGx+Oxz+lMUlJSyP3o6OhAy5moqCgtX77cTlTfeOMN+2nT2NhYzZ0717afcbvdnb4+AAAAAPRXzAEBAP0Na/wBANCGkpKSVvvMYuuZmZlKTU21k7Hgxdf9CgsL7foLhjnu8OHDrY75+OOPA2tAdIWZgN5zzz32055m0mda0axatUqPPvpot78vAAAAAEBrzAEBAJGC4A8AgDaYFi3BE7/Nmzdr3759dv0F8+nMk046Sa+99pq8Xm/gGPMpz7feeivQtuWUU07R3r17tW3btsAxtbW1WrhwoV566aUunccnn3yi008/XRs3brQTTdMy5pZbbtG4ceOUn5/fo98zAAAAAPRXzAEBAJGCVp8AgH7FLIa+fv36dh8fP358YGH3G2+8Ud/73vdUWVmpRx55xE60vvzlL9vHb731Vvupy5tuuklXXXWV6uvr7SLv5vVvvvlme8y8efP0hz/8wb7GokWLlJGRoWeeecYea57TFWZdiYSEBLvovJksmjYy7733nrZs2aJrr722R34mAAAAABCpmAMCAPobgj8AQL9i2rBcccUV7T5u2qj4P6l56qmn6s4777T3zznnHDvxMutDGOZTn7///e+1dOlS/fCHP7T7zXMeeOABjR071h6TkpKiZ599Vg8++KCWLFmixsZGTZs2zU78gheN70h8fLxd3+Hhhx/WL37xC7vg+8iRI3XvvffaSSUAAAAAoH3MAQEA/U2Uz79yLAAAsK655hq7NZ/UBAAAAABENuaAAIBIwhp/AAAAAAAAAAAAQAQg+AMAAAAAAAAAAAAiAK0+AQAAAAAAAAAAgAhAxR8AAAAAAAAAAAAQAQj+AAAAAAAAAAAAgAhA8AcAAAAAAAAAAABEAII/AAAAAAAAAAAAIAIQ/AEAAAAAAAAAAAARgOAPAAAAAAAAAAAAiAAEfwAAAAAAAAAAAEAEIPgDAAAAAAAAAAAAIgDBHwAAAAAAAAAAAKDj3/8HryfJvuCRkbkAAAAASUVORK5CYII=" }, "metadata": {}, "output_type": "display_data" } ], "execution_count": 12 }, { "cell_type": "code", "execution_count": null, "outputs": [], "source": [], "metadata": { "collapsed": false } } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.9" } }, "nbformat": 4, "nbformat_minor": 5 }