From d8acfe98b273c45a3efc9392632754ba8f5dc1be Mon Sep 17 00:00:00 2001 From: souparno majumder Date: Mon, 15 Sep 2025 22:34:59 +0530 Subject: [PATCH 1/2] code fixes --- Neural_Network.ipynb | 529 ++++++++------- playground.ipynb | 1490 +++++++++++++++++++++--------------------- 2 files changed, 1042 insertions(+), 977 deletions(-) diff --git a/Neural_Network.ipynb b/Neural_Network.ipynb index 22fbf0f..5a94eb2 100644 --- a/Neural_Network.ipynb +++ b/Neural_Network.ipynb @@ -1,247 +1,302 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "ucrKgBCAIPbB" + }, + "outputs": [], + "source": [ + "# =========================\n", + "# Minimal NumPy MLP (XOR)\n", + "# =========================\n", + "import numpy as np\n", + "from abc import ABC, abstractmethod\n", + "from typing import List\n", + "\n", + "np.random.seed(42)\n", + "\n", + "# --- Activation functions ---\n", + "class ActivationFunction(ABC):\n", + " @abstractmethod\n", + " def output(self, z: np.ndarray) -> np.ndarray: ...\n", + " @abstractmethod\n", + " def derivative(self, z: np.ndarray) -> np.ndarray: ...\n", + "\n", + "class Sigmoid(ActivationFunction):\n", + " def output(self, z: np.ndarray) -> np.ndarray:\n", + " return 1.0 / (1.0 + np.exp(-z))\n", + " def derivative(self, z: np.ndarray) -> np.ndarray:\n", + " a = self.output(z)\n", + " return a * (1.0 - a)\n", + "\n", + "class ReLU(ActivationFunction):\n", + " def output(self, z: np.ndarray) -> np.ndarray:\n", + " return np.maximum(0.0, z)\n", + " def derivative(self, z: np.ndarray) -> np.ndarray:\n", + " return (z > 0.0).astype(z.dtype)\n", + "\n", + "class WeightedReLU(ActivationFunction):\n", + " def __init__(self, alpha: float = 0.01):\n", + " self.alpha = alpha\n", + " def output(self, z: np.ndarray) -> np.ndarray:\n", + " return np.where(z > 0.0, z, self.alpha * z)\n", + " def derivative(self, z: np.ndarray) -> np.ndarray:\n", + " return np.where(z > 0.0, 1.0, self.alpha)\n", + "\n", + "class Tanh(ActivationFunction):\n", + " def output(self, z: np.ndarray) -> np.ndarray:\n", + " return np.tanh(z)\n", + " def derivative(self, z: np.ndarray) -> np.ndarray:\n", + " a = np.tanh(z)\n", + " return 1.0 - a * a\n", + "\n", + "# --- Cost functions ---\n", + "class CostFunction(ABC):\n", + " @abstractmethod\n", + " def value(self, y_true: np.ndarray, y_pred: np.ndarray) -> float: ...\n", + " @abstractmethod\n", + " def derivative(self, y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray: ...\n", + "\n", + "class MeanSquared(CostFunction):\n", + " def value(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:\n", + " return float(np.mean((y_pred - y_true) ** 2))\n", + " def derivative(self, y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:\n", + " m = y_true.shape[0]\n", + " return (y_pred - y_true) / m # dL/dy_pred\n", + "\n", + "# --- Perceptron (one neuron) ---\n", + "class Perceptron:\n", + " def __init__(self, input_size: int, activation: ActivationFunction):\n", + " # Xavier-ish scaling helps for tanh/sigmoid\n", + " limit = np.sqrt(6.0 / (input_size + 1))\n", + " self.weights = np.random.uniform(-limit, limit, size=(input_size, 1))\n", + " self.bias = np.zeros((1, 1))\n", + " self.activation = activation\n", + " self.z = None\n", + " self.a = None\n", + "\n", + " def feedforward(self, X: np.ndarray) -> np.ndarray:\n", + " self.z = X @ self.weights + self.bias # (B,1)\n", + " self.a = self.activation.output(self.z) # (B,1)\n", + " return self.a\n", + "\n", + " def backward(self, X: np.ndarray, error: np.ndarray, learning_rate: float) -> np.ndarray:\n", + " # error is dL/da for this neuron\n", + " dz = error * self.activation.derivative(self.z) # (B,1)\n", + " dW = X.T @ dz # (in,1)\n", + " db = np.sum(dz, axis=0, keepdims=True) # (1,1)\n", + " # gradient descent\n", + " self.weights -= learning_rate * dW\n", + " self.bias -= learning_rate * db\n", + " # upstream gradient to previous layer: dL/dX\n", + " return dz @ self.weights.T # (B,in)\n", + "\n", + "# --- Dense layer ---\n", + "class Layer:\n", + " def __init__(self, input_size: int, num_neurons: int, activation: ActivationFunction):\n", + " self.perceptrons = [Perceptron(input_size, activation) for _ in range(num_neurons)]\n", + " self.input_size = input_size\n", + " self.num_neurons = num_neurons\n", + "\n", + " def feedforward(self, X: np.ndarray) -> np.ndarray:\n", + " return np.concatenate([p.feedforward(X) for p in self.perceptrons], axis=1) # (B,N)\n", + "\n", + " def backward(self, X: np.ndarray, errors: np.ndarray, learning_rate: float) -> np.ndarray:\n", + " # errors: (B,N) for this layer's activations\n", + " grads_to_prev = []\n", + " for i, p in enumerate(self.perceptrons):\n", + " e_i = errors[:, i:i+1] # (B,1)\n", + " grads_to_prev.append(p.backward(X, e_i, learning_rate)) # (B,in)\n", + " # sum contributions across neurons\n", + " return np.sum(grads_to_prev, axis=0) # (B,in)\n", + "\n", + "# --- Network ---\n", + "class NeuralNetwork:\n", + " def __init__(self, layers: List[Layer], cost: CostFunction):\n", + " self.layers = layers\n", + " self.cost = cost\n", + "\n", + " def _forward_all(self, X: np.ndarray) -> List[np.ndarray]:\n", + " activations = [X]\n", + " for layer in self.layers:\n", + " activations.append(layer.feedforward(activations[-1]))\n", + " return activations\n", + "\n", + " def train(self, input_data: np.ndarray, target_data: np.ndarray, epochs: int, learning_rate: float) -> None:\n", + " for _ in range(epochs):\n", + " acts = self._forward_all(input_data)\n", + " y_pred = acts[-1]\n", + " error = self.cost.derivative(target_data, y_pred) # dL/dy_pred\n", + " for layer, A_prev in zip(reversed(self.layers), reversed(acts[:-1])):\n", + " error = layer.backward(A_prev, error, learning_rate)\n", + "\n", + " def predict(self, input_data: np.ndarray) -> np.ndarray:\n", + " a = input_data\n", + " for layer in self.layers:\n", + " a = layer.feedforward(a)\n", + " return a\n", + "\n", + "# --- Training monitor ---\n", + "class TrainingMonitor:\n", + " def __init__(self):\n", + " self.loss_history: List[float] = []\n", + "\n", + " def monitor_training(self, neural_network: NeuralNetwork,\n", + " input_data: np.ndarray,\n", + " target_data: np.ndarray,\n", + " epochs: int,\n", + " learning_rate: float) -> None:\n", + " self.loss_history.clear()\n", + " for epoch in range(epochs):\n", + " neural_network.train(input_data, target_data, 1, learning_rate)\n", + " y_hat = neural_network.predict(input_data)\n", + " loss = neural_network.cost.value(target_data, y_hat)\n", + " self.loss_history.append(loss)\n", + " print(\"Training complete.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { "colab": { - "provenance": [] + "base_uri": "https://localhost:8080/", + "height": 944 }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" + "id": "JqqXaG2EDM85", + "outputId": "7968d593-2fb4-484e-f1f3-4ab39d90a9d5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training complete.\n" + ] }, - "language_info": { - "name": "python" - } - }, - "cells": [ { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "id": "ucrKgBCAIPbB" - }, - "outputs": [], - "source": [ - "from abc import ABC, abstractmethod\n", - "import numpy as np\n", - "from typing import List\n", - "\n", - "# Activation function interface\n", - "class ActivationFunction(ABC):\n", - " @abstractmethod\n", - " def output(self, x: np.ndarray) -> np.ndarray:\n", - " pass\n", - "\n", - " @abstractmethod\n", - " def derivative(self, x: np.ndarray) -> np.ndarray:\n", - " pass\n", - "\n", - "# Sigmoid activation implementation\n", - "class Sigmoid(ActivationFunction):\n", - " def output(self, x: np.ndarray) -> np.ndarray:\n", - " return 1 / (1 + np.exp(-x))\n", - "\n", - " def derivative(self, x: np.ndarray) -> np.ndarray:\n", - " return self.output(x) * (1 - self.output(x))\n", - "\n", - "# ReLU activation implementation\n", - "class ReLU(ActivationFunction):\n", - " def output(self, x: np.ndarray) -> np.ndarray:\n", - " return np.maximum(0, x)\n", - "\n", - " def derivative(self, x: np.ndarray) -> np.ndarray:\n", - " return np.where(x > 0, 1, 0)\n", - "\n", - "# Weighted ReLU activation implementation\n", - "class WeightedReLU(ActivationFunction):\n", - " def __init__(self, alpha: float = 0.01):\n", - " self.alpha = alpha\n", - "\n", - " def output(self, x: np.ndarray) -> np.ndarray:\n", - " return np.maximum(self.alpha * x, x)\n", - "\n", - " def derivative(self, x: np.ndarray) -> np.ndarray:\n", - " return np.where(x > 0, 1, self.alpha)\n", - "\n", - "# Tanh activation implementation\n", - "class Tanh(ActivationFunction):\n", - " def output(self, x: np.ndarray) -> np.ndarray:\n", - " return np.tanh(x)\n", - "\n", - " def derivative(self, x: np.ndarray) -> np.ndarray:\n", - " return 1 - np.tanh(x)**2\n", - "\n", - "# Cost function interface\n", - "class CostFunction(ABC):\n", - " @abstractmethod\n", - " def derivative(self, target: np.ndarray, output: np.ndarray) -> np.ndarray:\n", - " pass\n", - "\n", - "# Mean squared cost implementation\n", - "class MeanSquared(CostFunction):\n", - " def derivative(self, output: np.ndarray, target: np.ndarray) -> np.ndarray:\n", - " return target - output\n", - "\n", - "# Perceptron class\n", - "class Perceptron:\n", - " def __init__(self, input_size: int, activation: ActivationFunction):\n", - " self.weights = np.random.randn(input_size, 1)\n", - " self.bias = np.zeros((1, 1))\n", - " self.activation = activation\n", - "\n", - " def feedforward(self, X: np.ndarray) -> np.ndarray:\n", - " self.output = self.activation.output(np.dot(X, self.weights) + self.bias)\n", - " return self.output\n", - "\n", - " def backward(self, X: np.ndarray, error: np.ndarray, learning_rate: float) -> np.ndarray:\n", - " delta = error * self.activation.derivative(self.output)\n", - " self.weights += X.T.dot(delta) * learning_rate\n", - " self.bias += np.sum(delta, axis=0, keepdims=True) * learning_rate\n", - " return np.dot(delta, self.weights.T)\n", - "\n", - "# Layer class\n", - "class Layer:\n", - " def __init__(self, input_size: int, num_neurons: int, activation: ActivationFunction):\n", - " self.perceptrons = [Perceptron(input_size, activation) for _ in range(num_neurons)]\n", - "\n", - " def feedforward(self, X: np.ndarray) -> np.ndarray:\n", - " return np.concatenate([perceptron.feedforward(X) for perceptron in self.perceptrons], axis=1)\n", - "\n", - " def backward(self, X: np.ndarray, errors: np.ndarray, learning_rate: float) -> np.ndarray:\n", - " delta_accumulated = [perceptron.backward(X, errors[:, i:i+1], learning_rate) for i, perceptron in enumerate(self.perceptrons)]\n", - "\n", - " return np.concatenate(delta_accumulated, axis=1)\n", - "\n", - "# NeuralNetwork class\n", - "class NeuralNetwork:\n", - " def __init__(self, layers: list, cost: CostFunction):\n", - " self.layers = layers\n", - " self.cost = cost\n", - "\n", - " def train(self, input_data: np.ndarray, target_data: np.ndarray, epochs: int, learning_rate: float) -> None:\n", - " for epoch in range(epochs):\n", - " layer_inputs = [input_data]\n", - "\n", - " # Forward pass\n", - " for layer in self.layers:\n", - " layer_inputs.append(layer.feedforward(layer_inputs[-1]))\n", - "\n", - " # Backward pass\n", - " output_error = self.cost.derivative(layer_inputs.pop(), target_data)\n", - " for layer, layer_input in zip(reversed(self.layers), reversed(layer_inputs)):\n", - " output_error = layer.backward(layer_input, output_error, learning_rate)\n", - "\n", - "\n", - " def predict(self, input_data: np.ndarray) -> np.ndarray:\n", - " layer_input = input_data\n", - " for layer in self.layers:\n", - " layer_input = layer.feedforward(layer_input)\n", - " return layer_input\n", - "\n", - "# Training monitor class\n", - "class TrainingMonitor:\n", - " def __init__(self):\n", - " self.loss_history: List[float] = []\n", - "\n", - " def log_epoch(self, epoch: int, loss: float) -> None:\n", - " print(f\"Epoch {epoch + 1}/{len(self.loss_history)} - Loss: {loss}\")\n", - "\n", - " def monitor_training(self, neural_network, input_data: np.ndarray, target_data: np.ndarray, epochs: int, learning_rate: float) -> None:\n", - " for epoch in range(epochs):\n", - " neural_network.train(input_data, target_data, 1, learning_rate) # Train for one epoch\n", - " predicted_output = neural_network.predict(input_data)\n", - " loss = np.mean(neural_network.cost.derivative(target_data, predicted_output))\n", - " self.loss_history.append(loss)\n", - " # self.log_epoch(epoch, loss)\n", - "\n", - " print(\"Training complete.\")" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "# Training data for XOR\n", - "input_data_xor = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])\n", - "target_data_xor = np.array([[0], [1], [1], [0]])\n", - "\n", - "# Creating and training the neural network for XOR\n", - "nn_xor = NeuralNetwork([\n", - " Layer(2, 5, Tanh()),\n", - " Layer(5, 5, Tanh()),\n", - " Layer(5, 1, Tanh()),\n", - "], MeanSquared())\n", - "\n", - "# Create a training monitor with loss history for XOR\n", - "monitor_xor = TrainingMonitor()\n", - "\n", - "# Train the neural network for XOR with monitoring\n", - "monitor_xor.monitor_training(nn_xor, input_data_xor, target_data_xor, epochs=10000, learning_rate=0.1)\n", - "\n", - "# Plot the overall training loss for XOR\n", - "plt.plot(range(1, len(monitor_xor.loss_history) + 1), monitor_xor.loss_history, marker='o')\n", - "plt.xlabel('Epoch')\n", - "plt.ylabel('Training Loss')\n", - "plt.title('Training Loss Over Epochs (XOR)')\n", - "plt.show()\n", - "\n", - "# Create a meshgrid of points for XOR\n", - "h_xor = 0.01\n", - "x_min_xor, x_max_xor = input_data_xor[:, 0].min() - 1, input_data_xor[:, 0].max() + 1\n", - "y_min_xor, y_max_xor = input_data_xor[:, 1].min() - 1, input_data_xor[:, 1].max() + 1\n", - "xx_xor, yy_xor = np.meshgrid(np.arange(x_min_xor, x_max_xor, h_xor), np.arange(y_min_xor, y_max_xor, h_xor))\n", - "grid_xor = np.c_[xx_xor.ravel(), yy_xor.ravel()]\n", - "\n", - "# Predict the function value for the whole grid for XOR\n", - "Z_xor = np.round(nn_xor.predict(grid_xor)).reshape(xx_xor.shape)\n", - "\n", - "# Plot the contour and training examples for XOR\n", - "plt.contourf(xx_xor, yy_xor, Z_xor, alpha=0.8)\n", - "plt.scatter(input_data_xor[:, 0], input_data_xor[:, 1], c=target_data_xor.ravel(), edgecolors='k')\n", - "plt.xlabel('Input 1')\n", - "plt.ylabel('Input 2')\n", - "plt.title('XOR Classification with Decision Boundary')\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 944 - }, - "id": "JqqXaG2EDM85", - "outputId": "7968d593-2fb4-484e-f1f3-4ab39d90a9d5" - }, - "execution_count": 18, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Training complete.\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predictions on XOR inputs:\n", + "[[0.013]\n", + " [0.975]\n", + " [0.979]\n", + " [0.025]]\n" + ] } - ] -} \ No newline at end of file + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# =========================\n", + "# XOR demo (0/1 targets)\n", + "# =========================\n", + "\n", + "# Training data for XOR\n", + "input_data_xor = np.array([[0, 0],\n", + " [0, 1],\n", + " [1, 0],\n", + " [1, 1]], dtype=float)\n", + "target_data_xor = np.array([[0],\n", + " [1],\n", + " [1],\n", + " [0]], dtype=float)\n", + "\n", + "# Build network (Sigmoid at output for 0/1 targets)\n", + "nn_xor = NeuralNetwork([\n", + " Layer(2, 5, Tanh()),\n", + " Layer(5, 5, Tanh()),\n", + " Layer(5, 1, Sigmoid()), # <-- Sigmoid works best for binary 0/1\n", + "], MeanSquared())\n", + "\n", + "# Train with monitoring\n", + "monitor_xor = TrainingMonitor()\n", + "monitor_xor.monitor_training(nn_xor, input_data_xor, target_data_xor, epochs=10000, learning_rate=0.1)\n", + "\n", + "# Plot loss\n", + "plt.figure()\n", + "plt.plot(range(1, len(monitor_xor.loss_history) + 1), monitor_xor.loss_history, marker='.')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Training Loss')\n", + "plt.title('Training Loss Over Epochs (XOR)')\n", + "plt.show()\n", + "\n", + "# Decision boundary plot\n", + "h_xor = 0.01\n", + "x_min_xor, x_max_xor = input_data_xor[:, 0].min() - 1, input_data_xor[:, 0].max() + 1\n", + "y_min_xor, y_max_xor = input_data_xor[:, 1].min() - 1, input_data_xor[:, 1].max() + 1\n", + "xx_xor, yy_xor = np.meshgrid(np.arange(x_min_xor, x_max_xor, h_xor),\n", + " np.arange(y_min_xor, y_max_xor, h_xor))\n", + "grid_xor = np.c_[xx_xor.ravel(), yy_xor.ravel()]\n", + "\n", + "Z_xor = (nn_xor.predict(grid_xor) >= 0.5).astype(int).reshape(xx_xor.shape)\n", + "\n", + "plt.figure()\n", + "plt.contourf(xx_xor, yy_xor, Z_xor, alpha=0.8)\n", + "plt.scatter(input_data_xor[:, 0], input_data_xor[:, 1], c=target_data_xor.ravel(), edgecolors='k')\n", + "plt.xlabel('Input 1')\n", + "plt.ylabel('Input 2')\n", + "plt.title('XOR Classification with Decision Boundary')\n", + "plt.show()\n", + "\n", + "# Quick sanity check on the 4 points\n", + "print(\"Predictions on XOR inputs:\")\n", + "print(np.round(nn_xor.predict(input_data_xor), 3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python [conda env:base] *", + "language": "python", + "name": "conda-base-py" + }, + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/playground.ipynb b/playground.ipynb index 0819be7..8485444 100644 --- a/playground.ipynb +++ b/playground.ipynb @@ -1,758 +1,768 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "KRROW5UXDdo0" + }, + "outputs": [], + "source": [ + "import math\n", + "import random\n", + "import numpy as np\n", + "\n", + "class Node:\n", + " def __init__(self, node_id, activation, init_zero=False):\n", + " self.id = node_id\n", + " self.input_links = []\n", + " self.bias = 0.1\n", + " self.outputs = []\n", + " self.total_input = 0\n", + " self.output = 0\n", + " self.output_der = 0\n", + " self.input_der = 0\n", + " self.acc_input_der = 0\n", + " self.num_accumulated_ders = 0\n", + " self.activation = activation\n", + "\n", + " if init_zero:\n", + " self.bias = 0\n", + "\n", + " def update_output(self):\n", + " self.total_input = self.bias + sum(link.weight * link.source.output for link in self.input_links)\n", + " self.output = self.activation.output(self.total_input)\n", + " return self.output\n", + "\n", + "class ErrorFunction:\n", + " def __init__(self, error_func, der_func):\n", + " self.error = error_func\n", + " self.der = der_func\n", + "\n", + "class ActivationFunction:\n", + " def __init__(self, output_func, der_func):\n", + " self.output = output_func\n", + " self.der = der_func\n", + "\n", + "class RegularizationFunction:\n", + " def __init__(self, output_func, der_func):\n", + " self.output = output_func\n", + " self.der = der_func\n", + "\n", + "class Link:\n", + " def __init__(self, source, dest, regularization, init_zero=False):\n", + " self.id = source.id + \"-\" + dest.id\n", + " self.source = source\n", + " self.dest = dest\n", + " self.weight = random.random() - 0.5\n", + " self.is_dead = False\n", + " self.error_der = 0\n", + " self.acc_error_der = 0\n", + " self.num_accumulated_ders = 0\n", + " self.regularization = regularization\n", + "\n", + " if init_zero:\n", + " self.weight = 0\n", + "\n", + "\n", + "class Activations:\n", + " TANH = ActivationFunction(np.tanh, lambda x: 1 - np.tanh(x) ** 2)\n", + " RELU = ActivationFunction(lambda x: max(0, x), lambda x: 0 if x <= 0 else 1)\n", + " SIGMOID = ActivationFunction(lambda x: 1 / (1 + np.exp(-x)), lambda x: x * (1 - x))\n", + " LINEAR = ActivationFunction(lambda x: x, lambda x: 1)\n", + "\n", + "class RegularizationFunctions:\n", + " L1 = RegularizationFunction(lambda w: abs(w), lambda w: -1 if w < 0 else (1 if w > 0 else 0))\n", + " L2 = RegularizationFunction(lambda w: 0.5 * w * w, lambda w: w)\n", + "\n", + "class Errors:\n", + " SQUARE = ErrorFunction(lambda output, target: 0.5 * (output - target) ** 2, lambda output, target: output - target)\n", + "\n", + "def build_network(network_shape, activation, output_activation, regularization, input_ids, init_zero=False):\n", + " num_layers = len(network_shape)\n", + " id_counter = 1\n", + " network = []\n", + "\n", + " for layer_idx in range(num_layers):\n", + " is_output_layer = layer_idx == num_layers - 1\n", + " is_input_layer = layer_idx == 0\n", + " current_layer = []\n", + " network.append(current_layer)\n", + " num_nodes = network_shape[layer_idx]\n", + "\n", + " for i in range(num_nodes):\n", + " node_id = input_ids[i] if is_input_layer else str(id_counter)\n", + " id_counter += 1\n", + " node = Node(node_id, output_activation if is_output_layer else activation, init_zero)\n", + " current_layer.append(node)\n", + "\n", + " if layer_idx >= 1:\n", + " for j in range(len(network[layer_idx - 1])):\n", + " prev_node = network[layer_idx - 1][j]\n", + " link = Link(prev_node, node, regularization, init_zero)\n", + " prev_node.outputs.append(link)\n", + " node.input_links.append(link)\n", + "\n", + " return network\n", + "\n", + "def forward_prop(network, inputs):\n", + " input_layer = network[0]\n", + "\n", + " if len(inputs) != len(input_layer):\n", + " raise ValueError(\"The number of inputs must match the number of nodes in the input layer\")\n", + "\n", + " for i in range(len(input_layer)):\n", + " node = input_layer[i]\n", + " node.output = inputs[i]\n", + "\n", + " for layer_idx in range(1, len(network)):\n", + " current_layer = network[layer_idx]\n", + "\n", + " for i in range(len(current_layer)):\n", + " node = current_layer[i]\n", + " node.update_output()\n", + "\n", + " return network[-1][0].output\n", + "\n", + "def back_prop(network, target, error_func):\n", + " output_node = network[-1][0]\n", + " output_node.output_der = error_func.der(output_node.output, target)\n", + "\n", + " for layer_idx in range(len(network) - 1, 0, -1):\n", + " current_layer = network[layer_idx]\n", + "\n", + " for i in range(len(current_layer)):\n", + " node = current_layer[i]\n", + " node.input_der = node.output_der * node.activation.der(node.total_input)\n", + " node.acc_input_der += node.input_der\n", + " node.num_accumulated_ders += 1\n", + "\n", + " for i in range(len(current_layer)):\n", + " node = current_layer[i]\n", + "\n", + " for j in range(len(node.input_links)):\n", + " link = node.input_links[j]\n", + "\n", + " if link.is_dead:\n", + " continue\n", + "\n", + " link.error_der = node.input_der * link.source.output\n", + " link.acc_error_der += link.error_der\n", + " link.num_accumulated_ders += 1\n", + "\n", + " if layer_idx == 1:\n", + " continue\n", + "\n", + " prev_layer = network[layer_idx - 1]\n", + "\n", + " for i in range(len(prev_layer)):\n", + " node = prev_layer[i]\n", + " node.output_der = sum(output.weight * output.dest.input_der for output in node.outputs)\n", + "\n", + "def update_weights(network, learning_rate, regularization_rate):\n", + " for layer_idx in range(1, len(network)):\n", + " current_layer = network[layer_idx]\n", + "\n", + " for i in range(len(current_layer)):\n", + " node = current_layer[i]\n", + "\n", + " if node.num_accumulated_ders > 0:\n", + " node.bias -= learning_rate * node.acc_input_der / node.num_accumulated_ders\n", + " node.acc_input_der = 0\n", + " node.num_accumulated_ders = 0\n", + "\n", + " for j in range(len(node.input_links)):\n", + " link = node.input_links[j]\n", + "\n", + " if link.is_dead:\n", + " continue\n", + "\n", + " regul_der = link.regularization.der(link.weight) if link.regularization else 0\n", + "\n", + " if link.num_accumulated_ders > 0:\n", + " link.weight -= (learning_rate / link.num_accumulated_ders) * link.acc_error_der\n", + " new_link_weight = link.weight - (learning_rate * regularization_rate) * regul_der\n", + "\n", + " if link.regularization == RegularizationFunctions.L1 and link.weight * new_link_weight < 0:\n", + " link.weight = 0\n", + " link.is_dead = True\n", + " else:\n", + " link.weight = new_link_weight\n", + "\n", + " link.acc_error_der = 0\n", + " link.num_accumulated_ders = 0\n", + "\n", + "def for_each_node(network, ignore_inputs, accessor):\n", + " start_idx = 1 if ignore_inputs else 0\n", + "\n", + " for layer_idx in range(start_idx, len(network)):\n", + " current_layer = network[layer_idx]\n", + "\n", + " for i in range(len(current_layer)):\n", + " node = current_layer[i]\n", + " accessor(node)\n", + "\n", + "def get_output_node(network):\n", + " return network[-1][0]" + ] }, - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "KRROW5UXDdo0" - }, - "outputs": [], - "source": [ - "import math\n", - "import random\n", - "import numpy as np\n", - "\n", - "class Node:\n", - " def __init__(self, node_id, activation, init_zero=False):\n", - " self.id = node_id\n", - " self.input_links = []\n", - " self.bias = 0.1\n", - " self.outputs = []\n", - " self.total_input = 0\n", - " self.output = 0\n", - " self.output_der = 0\n", - " self.input_der = 0\n", - " self.acc_input_der = 0\n", - " self.num_accumulated_ders = 0\n", - " self.activation = activation\n", - "\n", - " if init_zero:\n", - " self.bias = 0\n", - "\n", - " def update_output(self):\n", - " self.total_input = self.bias + sum(link.weight * link.source.output for link in self.input_links)\n", - " self.output = self.activation.output(self.total_input)\n", - " return self.output\n", - "\n", - "class ErrorFunction:\n", - " def __init__(self, error_func, der_func):\n", - " self.error = error_func\n", - " self.der = der_func\n", - "\n", - "class ActivationFunction:\n", - " def __init__(self, output_func, der_func):\n", - " self.output = output_func\n", - " self.der = der_func\n", - "\n", - "class RegularizationFunction:\n", - " def __init__(self, output_func, der_func):\n", - " self.output = output_func\n", - " self.der = der_func\n", - "\n", - "class Link:\n", - " def __init__(self, source, dest, regularization, init_zero=False):\n", - " self.id = source.id + \"-\" + dest.id\n", - " self.source = source\n", - " self.dest = dest\n", - " self.weight = random.random() - 0.5\n", - " self.is_dead = False\n", - " self.error_der = 0\n", - " self.acc_error_der = 0\n", - " self.num_accumulated_ders = 0\n", - " self.regularization = regularization\n", - "\n", - " if init_zero:\n", - " self.weight = 0\n", - "\n", - "\n", - "class Activations:\n", - " TANH = ActivationFunction(np.tanh, lambda x: 1 - np.tanh(x) ** 2)\n", - " RELU = ActivationFunction(lambda x: max(0, x), lambda x: 0 if x <= 0 else 1)\n", - " SIGMOID = ActivationFunction(lambda x: 1 / (1 + np.exp(-x)), lambda x: x * (1 - x))\n", - " LINEAR = ActivationFunction(lambda x: x, lambda x: 1)\n", - "\n", - "class RegularizationFunctions:\n", - " L1 = RegularizationFunction(lambda w: abs(w), lambda w: -1 if w < 0 else (1 if w > 0 else 0))\n", - " L2 = RegularizationFunction(lambda w: 0.5 * w * w, lambda w: w)\n", - "\n", - "class Errors:\n", - " SQUARE = ErrorFunction(lambda output, target: 0.5 * (output - target) ** 2, lambda output, target: output - target)\n", - "\n", - "def build_network(network_shape, activation, output_activation, regularization, input_ids, init_zero=False):\n", - " num_layers = len(network_shape)\n", - " id_counter = 1\n", - " network = []\n", - "\n", - " for layer_idx in range(num_layers):\n", - " is_output_layer = layer_idx == num_layers - 1\n", - " is_input_layer = layer_idx == 0\n", - " current_layer = []\n", - " network.append(current_layer)\n", - " num_nodes = network_shape[layer_idx]\n", - "\n", - " for i in range(num_nodes):\n", - " node_id = input_ids[i] if is_input_layer else str(id_counter)\n", - " id_counter += 1\n", - " node = Node(node_id, output_activation if is_output_layer else activation, init_zero)\n", - " current_layer.append(node)\n", - "\n", - " if layer_idx >= 1:\n", - " for j in range(len(network[layer_idx - 1])):\n", - " prev_node = network[layer_idx - 1][j]\n", - " link = Link(prev_node, node, regularization, init_zero)\n", - " prev_node.outputs.append(link)\n", - " node.input_links.append(link)\n", - "\n", - " return network\n", - "\n", - "def forward_prop(network, inputs):\n", - " input_layer = network[0]\n", - "\n", - " if len(inputs) != len(input_layer):\n", - " raise ValueError(\"The number of inputs must match the number of nodes in the input layer\")\n", - "\n", - " for i in range(len(input_layer)):\n", - " node = input_layer[i]\n", - " node.output = inputs[i]\n", - "\n", - " for layer_idx in range(1, len(network)):\n", - " current_layer = network[layer_idx]\n", - "\n", - " for i in range(len(current_layer)):\n", - " node = current_layer[i]\n", - " node.update_output()\n", - "\n", - " return network[-1][0].output\n", - "\n", - "def back_prop(network, target, error_func):\n", - " output_node = network[-1][0]\n", - " output_node.output_der = error_func.der(output_node.output, target)\n", - "\n", - " for layer_idx in range(len(network) - 1, 0, -1):\n", - " current_layer = network[layer_idx]\n", - "\n", - " for i in range(len(current_layer)):\n", - " node = current_layer[i]\n", - " node.input_der = node.output_der * node.activation.der(node.total_input)\n", - " node.acc_input_der += node.input_der\n", - " node.num_accumulated_ders += 1\n", - "\n", - " for i in range(len(current_layer)):\n", - " node = current_layer[i]\n", - "\n", - " for j in range(len(node.input_links)):\n", - " link = node.input_links[j]\n", - "\n", - " if link.is_dead:\n", - " continue\n", - "\n", - " link.error_der = node.input_der * link.source.output\n", - " link.acc_error_der += link.error_der\n", - " link.num_accumulated_ders += 1\n", - "\n", - " if layer_idx == 1:\n", - " continue\n", - "\n", - " prev_layer = network[layer_idx - 1]\n", - "\n", - " for i in range(len(prev_layer)):\n", - " node = prev_layer[i]\n", - " node.output_der = sum(output.weight * output.dest.input_der for output in node.outputs)\n", - "\n", - "def update_weights(network, learning_rate, regularization_rate):\n", - " for layer_idx in range(1, len(network)):\n", - " current_layer = network[layer_idx]\n", - "\n", - " for i in range(len(current_layer)):\n", - " node = current_layer[i]\n", - "\n", - " if node.num_accumulated_ders > 0:\n", - " node.bias -= learning_rate * node.acc_input_der / node.num_accumulated_ders\n", - " node.acc_input_der = 0\n", - " node.num_accumulated_ders = 0\n", - "\n", - " for j in range(len(node.input_links)):\n", - " link = node.input_links[j]\n", - "\n", - " if link.is_dead:\n", - " continue\n", - "\n", - " regul_der = link.regularization.der(link.weight) if link.regularization else 0\n", - "\n", - " if link.num_accumulated_ders > 0:\n", - " link.weight -= (learning_rate / link.num_accumulated_ders) * link.acc_error_der\n", - " new_link_weight = link.weight - (learning_rate * regularization_rate) * regul_der\n", - "\n", - " if link.regularization == RegularizationFunctions.L1 and link.weight * new_link_weight < 0:\n", - " link.weight = 0\n", - " link.is_dead = True\n", - " else:\n", - " link.weight = new_link_weight\n", - "\n", - " link.acc_error_der = 0\n", - " link.num_accumulated_ders = 0\n", - "\n", - "def for_each_node(network, ignore_inputs, accessor):\n", - " start_idx = 1 if ignore_inputs else 0\n", - "\n", - " for layer_idx in range(start_idx, len(network)):\n", - " current_layer = network[layer_idx]\n", - "\n", - " for i in range(len(current_layer)):\n", - " node = current_layer[i]\n", - " accessor(node)\n", - "\n", - "def get_output_node(network):\n", - " return network[-1][0]" - ] - }, - { - "cell_type": "code", - "source": [ - "\n", - "# Example usage:\n", - "network_shape = [1, 2, 3, 1]\n", - "activation = Activations.RELU\n", - "output_activation = Activations.SIGMOID\n", - "regularization = RegularizationFunctions.L2\n", - "input_ids = ['input1']\n", - "learning_rate = 0.01\n", - "regularization_rate = 0.001\n", - "\n", - "network = build_network(network_shape, activation, output_activation, regularization, input_ids)\n", - "inputs = [0.5]\n", - "target = 1\n", - "error_func = Errors.SQUARE\n", - "\n", - "for epoch in range(100):\n", - " output = forward_prop(network, inputs)\n", - " back_prop(network, target, error_func)\n", - " update_weights(network, learning_rate, regularization_rate)\n", - "\n", - "output_node = get_output_node(network)\n", - "print(\"Final Output:\", output_node.output)" - ], - "metadata": { - "id": "Wjt3Erfrbfmx" - }, - "execution_count": null, - "outputs": [] + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Wjt3Erfrbfmx" + }, + "outputs": [], + "source": [ + "\n", + "# Example usage:\n", + "network_shape = [1, 2, 3, 1]\n", + "activation = Activations.RELU\n", + "output_activation = Activations.SIGMOID\n", + "regularization = RegularizationFunctions.L2\n", + "input_ids = ['input1']\n", + "learning_rate = 0.01\n", + "regularization_rate = 0.001\n", + "\n", + "network = build_network(network_shape, activation, output_activation, regularization, input_ids)\n", + "inputs = [0.5]\n", + "target = 1\n", + "error_func = Errors.SQUARE\n", + "\n", + "for epoch in range(100):\n", + " output = forward_prop(network, inputs)\n", + " back_prop(network, target, error_func)\n", + " update_weights(network, learning_rate, regularization_rate)\n", + "\n", + "output_node = get_output_node(network)\n", + "print(\"Final Output:\", output_node.output)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 }, + "id": "yzSaWtewERQQ", + "outputId": "67c7f83f-099d-442b-d834-82b1d793c99f" + }, + "outputs": [ { - "cell_type": "code", - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Define XOR dataset\n", - "xor_inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])\n", - "xor_targets = np.array([0, 1, 1, 0])\n", - "\n", - "# Build neural network\n", - "network_shape = [2, 5, 1]\n", - "activation = Activations.TANH\n", - "output_activation = Activations.TANH\n", - "regularization = RegularizationFunctions.L2\n", - "input_ids = ['input1', 'input2']\n", - "learning_rate = 0.1\n", - "regularization_rate = 0.001\n", - "error_func = Errors.SQUARE\n", - "\n", - "network = build_network(network_shape, activation, output_activation, regularization, input_ids)\n", - "\n", - "# Train neural network\n", - "num_epochs = 10000\n", - "\n", - "for epoch in range(num_epochs):\n", - " for i in range(len(xor_inputs)):\n", - " inputs = xor_inputs[i]\n", - " target = xor_targets[i]\n", - " forward_prop(network, inputs)\n", - " back_prop(network, target, error_func)\n", - " update_weights(network, learning_rate, regularization_rate)\n", - "\n", - "# Plot decision boundary\n", - "def plot_decision_boundary():\n", - " h = 0.01\n", - " x_min, x_max = xor_inputs[:, 0].min() - 1, xor_inputs[:, 0].max() + 1\n", - " y_min, y_max = xor_inputs[:, 1].min() - 1, xor_inputs[:, 1].max() + 1\n", - " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", - "\n", - " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", - " Z = Z.reshape(xx.shape)\n", - "\n", - " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", - " plt.scatter(xor_inputs[:, 0], xor_inputs[:, 1], c=xor_targets, cmap=plt.cm.RdBu, edgecolors='k')\n", - " plt.xlabel('Input 1')\n", - " plt.ylabel('Input 2')\n", - " plt.title('XOR Decision Boundary')\n", - " plt.show()\n", - "\n", - "plot_decision_boundary()\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 472 - }, - "id": "yzSaWtewERQQ", - "outputId": "67c7f83f-099d-442b-d834-82b1d793c99f" - }, - "execution_count": 2, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUe0lEQVR4nO3deXhU9d3//+dkmwCSQCCQUPZFQBCCIAguwC3ebFW5pRZEBVxrW+4WUSnprbKopYgLbnepXxe0SOmNorYuKAb5uRRRUFwQUZDFIgmyJGENJDm/P2jGDElmzkxm+Zwzr8d1cV3N5ExyMkXz9P35nDMey7IsRERERBJQUrxPQERERCReFEIiIiKSsBRCIiIikrAUQiIiIpKwFEIiIiKSsBRCIiIikrAUQiIiIpKwFEIiIiKSsBRCIiIikrAUQiJitPbt2zN58uSQnjNr1iw8Hk90TsjlJk+eTPv27eN9GiIxoxASiaOrrrqK9PR0vv766xqf++Mf/4jH4+GVV17xPXb48GHuuusuevXqRcOGDcnMzOT888/n2WefpbZ3y/F4PH5/MjIyGDx4MK+++qqt89u+fbvf81NTU2nevDmDBg3i97//PTt37gz/h3epU1/zRo0accYZZ3D33Xdz5MiReJ+eiJzCo/caE4mfPXv20K1bN/Ly8li1apXv8W3bttGjRw9GjRrF888/D0BRUREXXnghmzZtYvz48QwePJhjx47xwgsv8M477zBu3Diee+45kpOTfV/H4/Fw0UUXMXHiRCzLYseOHfzpT39i9+7dvP766wwfPjzg+W3fvp0OHTpwxRVXMGrUKCorKzlw4AAfffQRy5cvx+Px8OSTTzJ+/PjovEBAWVkZSUlJpKam2n5OeXk55eXlpKenR+286lL9NQc4dOgQ7777LkuWLOFnP/sZy5Yti/k5hWLy5MmsXr2a7du3x/tURGLDEpG4evzxxy3AWrRoke+xESNGWBkZGda//vUv32PDhw+3kpKSrJdffrnG17j11lstwPrjH//o9zhg/frXv/Z77Msvv7QAa+TIkUHPbdu2bRZgzZ8/v8bntm/fbp1++ulWWlqatWHDhqBfK1HU9ppblmX97Gc/s5KSkqyjR4/G4azsmzRpktWuXbuIfK2Kigrjf14RLY2JxNn111/Pueeey6233sq+fftYunQpK1as4O677+YnP/kJAB988AFvvPEGkydP5pJLLqnxNebOnUuXLl2YN28eR48eDfj9unfvTvPmzdm6dWu9zrtdu3YsWrSI48ePc++99/p9rri4mKlTp9KmTRu8Xi+dO3dm3rx5VFZW+h1XWVnJQw89xJlnnkl6ejrZ2dmMGDGCdevW+Y45dY/QiRMnmD17Nl26dCE9PZ1mzZpx3nnnsXLlSt8xte0RKi8v56677qJTp054vV7at2/P73//e8rKyvyOa9++PT/96U9577336N+/P+np6XTs2JFnn322Xq9XTk4OHo+HlJQUv8eXLVtG3759adCgAc2bN+eqq65i165dfscMGTKEIUOG1Piap+7nqVrKvO+++3j88cd9P+vZZ5/NRx99VOP5L730Ej179iQ9PZ2ePXvy4osv1nru9913H4MGDaJZs2Y0aNCAvn37+iaV1Xk8HqZMmcJzzz1Hjx498Hq9vP7667Rv355LL720xvHHjh0jMzOTX/ziF7V+X5FYUAiJxJnH4+HPf/4zJSUl/PKXv+Tmm2+mX79+/PrXv/Yd849//APAt9xyqpSUFCZMmMCBAwd4//33A36/kpISDhw4QNOmTet97gMHDqRTp05+EXLkyBEGDx7M4sWLmThxIg8//DDnnnsu+fn5TJs2ze/51113nS+Y5s2bx4wZM0hPT+eDDz6o83vOmjWL2bNnM3ToUB599FH+53/+h7Zt2/Lxxx8HPNfrr7+eO++8k7POOosHH3yQwYMHM3fu3FqX9bZs2cLPfvYzLrroIu6//36aNm3K5MmT2bhxo63X5dixY+zdu5e9e/eyY8cOlixZwjPPPMOECRP8QmjRokX8/Oc/Jzk5mblz53LDDTewfPlyzjvvPIqLi219r9osWbKE+fPn84tf/IK7776b7du3c9lll3HixAnfMW+++SZjx47F4/Ewd+5cxowZwzXXXOMXoVUeeugh+vTpw5w5c/jDH/5ASkoKl19+ea17zVatWsXNN9/MuHHjeOihh+jQoQNXXXUVr7/+Ovv37/c79h//+AelpaVcddVVYf+sIvUW75GUiJyUn59vAVZycrK1fv16v8+NGTPGAqwDBw7U+fzly5dbgPXwww/7HgOs6667zvrhhx+sPXv2WOvWrbNGjBhR53LXqQItjVW59NJLLcAqKSmxLMuy7rrrLqtRo0bW119/7XfcjBkzrOTkZGvnzp2WZVnWqlWrLMD6zW9+U+NrVlZW+v53u3btrEmTJvk+7t27tzV69OiA5z1z5kyr+r/eNmzYYAHW9ddf73dc1ZLiqlWr/L4fYL3zzju+x/bs2WN5vV7rlltuCfh9Levka17bnzFjxljHjh3zHXf8+HGrRYsWVs+ePf2Wj1555RULsO68807fY4MHD7YGDx5c43uduoxV9f9Xs2bNrP379/sef/nlly3A+sc//uF7LC8vz8rNzbWKi4t9j7355psWUGNp7MiRI34fHz9+3OrZs6f1H//xHzV+9qSkJGvjxo1+j2/evNkCrD/96U9+j19yySVW+/bt/f7/Fok1TYREDNG8eXMAWrVqRc+ePf0+d/DgQQAaN25c5/OrPldaWur3+JNPPkl2djYtWrSgX79+FBQUMH369BrTmXCddtppfue4bNkyzj//fJo2beqbiuzdu5dhw4ZRUVHBO++8A8ALL7yAx+Nh5syZNb5moEvfmzRpwsaNG/nmm29sn+Nrr70GUONnvuWWWwBqTDbOOOMMzj//fN/H2dnZdO3alW+//dbW97v00ktZuXIlK1eu5OWXXyY/P58VK1YwYcIE39V969atY8+ePfzqV7/y29Q9evRounXrZvvKvtqMGzfOb+JX9bNUnf/u3bvZsGEDkyZNIjMz03fcRRddxBlnnFHj6zVo0MD3vw8cOEBJSQnnn39+rVO4wYMH1/gap59+OgMGDOC5557zPbZ//35ef/11rrzySt3qQOJKISRigO+++46ZM2fSs2dPvvvuuxp7bqoipyo2alNXLFX9Un711Vd9e2eOHDlCUlJk/vE/dOiQ3/f95ptvWLFiBdnZ2X5/hg0bBpy8Ug5g69attGrViqysrJC+35w5cyguLub000/nzDPP5LbbbuOzzz4L+JwdO3aQlJRE586d/R7PycmhSZMm7Nixw+/xtm3b1vgaTZs25cCBA7bOsXXr1gwbNoxhw4ZxySWX8Ic//IG7776b5cuX+26HUPU9u3btWuP53bp1q3FOoTj1/KuiqOr8q752ly5dajy3tvN55ZVXOOecc0hPTycrK4vs7Gz+9Kc/UVJSUuPYDh061HpOEydO5P333/d972XLlnHixAmuvvrqEH4ykchTCIkYYMqUKQC8/vrrXH755dxzzz1+04fu3bsDBPyFX/W5U/9rvOqX8qhRo5g5cyYPPPAAjz76KMuXL4/IuX/xxRe0aNGCjIwM4OQG6Isuusg3ETn1z9ixY+v1/S644AK2bt3KU089Rc+ePXniiSc466yzeOKJJ4I+1+7kofotCKqz6nG3kQsvvBDANxELRV3nXVFRUevjkTz/d999l0suuYT09HT+93//l9dee42VK1f6Tbeqqz49qm78+PGkpqb6pkKLFy+mX79+tYaXSCwphETi7MUXX+Tvf/87d911F61bt2bBggWkpaX5bZb+6U9/ClDnlUsVFRUsWbKEpk2bcu655wb8fr/4xS/o1KkTt99+e71+sQOsWbOGrVu38p//+Z++xzp16sShQ4d8E5FT/1RNKzp16sT3339fYwOtHVlZWVxzzTX89a9/5bvvvqNXr17MmjWrzuPbtWtHZWVljeW0oqIiiouLadeuXcjnEKry8nLgxwla1ffcvHlzjWM3b97sd05NmzatdfN0uFOjqq9d2/LiqefzwgsvkJ6ezhtvvMG1117LyJEjfdO9UGRlZTF69Giee+45duzYwfvvv69pkBhBISQSRwcPHuQ3v/kNffr04b//+7+Bk3uE7rrrLlasWOG7+d6gQYMYNmwYTz/9tN+dpqv8z//8D19//TXTp0+v87/Iq6SkpHDLLbewadMmXn755bDPfceOHUyePJm0tDRuu+023+M///nPWbNmDW+88UaN5xQXF/uCYOzYsViWxezZs2scFyjQ9u3b5/fxaaedRufOnWtcBl/dqFGjAFiwYIHf4w888ABwcl9OtFVd+de7d28A+vXrR4sWLVi4cKHfub/++uts2rTJ75w6derEV199xQ8//OB77NNPPw16hWBdcnNzycvL45lnnvFb3lq5ciVffvml37HJycl4PB6/6dP27dt56aWXQv6+V199NV9++SW33XYbycnJUb0Rp4hdKcEPEZFouf322/n+++9Zvny533LGr3/9a5555hmmTp3KiBEjaNy4Mc8++ywXXnghl156KRMmTOD888+nrKyM5cuXs3r1asaNG+cXJIFMnjyZO++8k3nz5jFmzJigx3/88ccsXryYyspKiouL+eijj3ybnf/yl7/Qq1cv37G33XYbf//73/npT3/K5MmT6du3L4cPH+bzzz/n+eefZ/v27TRv3pyhQ4dy9dVX8/DDD/PNN98wYsQIKisreffddxk6dKhvufBUZ5xxBkOGDKFv375kZWWxbt06nn/++TqPh5PxMWnSJB5//HGKi4sZPHgwH374Ic888wxjxoxh6NChtl43u77++msWL14MnLydwAcffMAzzzxD586dfVOQ1NRU5s2bxzXXXMPgwYO54oorKCoq4qGHHqJ9+/bcfPPNvq937bXX8sADDzB8+HCuu+469uzZw8KFC+nRo0eNzfF2zZ07l9GjR3Peeedx7bXXsn//fh555BF69Ojhm1rByUh84IEHGDFiBBMmTGDPnj089thjdO7cOejerFONHj2aZs2asWzZMkaOHEmLFi3COneRiIrjFWsiCW3dunVWcnKyNWXKlFo//+GHH1pJSUl+l5cfPHjQmjVrltWjRw+rQYMGVuPGja1zzz3XWrRoUa2XIFPHXY4ty7JmzZplAdbbb79d5zlWXY5d9SclJcXKysqyBgwYYOXn51s7duyo9XkHDx608vPzrc6dO1tpaWlW8+bNrUGDBln33Xefdfz4cd9x5eXl1vz5861u3bpZaWlpVnZ2tjVy5Ei/2wecevn83XffbfXv399q0qSJ1aBBA6tbt27WPffc4/d1T7183rIs68SJE9bs2bOtDh06WKmpqVabNm2s/Px8v0vaq75fbZfn13UJ+6k45bL55ORkq3Xr1taNN95oFRUV1Tj+b3/7m9WnTx/L6/VaWVlZ1pVXXul3R/Eqixcvtjp27GilpaVZeXl51htvvFHn5fO13e4AsGbOnOn32AsvvGB1797d8nq91hlnnGEtX7681jtLP/nkk1aXLl0sr9drdevWzXr66adrfY0D/X2r8qtf/coCrCVLlgQ8TiRW9F5jIiISMzfffDNPPvkkhYWFNGzYMN6nI6I9QiIiEhvHjh1j8eLFjB07VhEkxtAeIRERiao9e/bw1ltv8fzzz7Nv3z5++9vfxvuURHwUQiIiElVffvklV155JS1atODhhx8mLy8v3qck4qM9QiIiIpKwtEdIREREEpZCSERERBKW9ggFUVlZyffff0/jxo31DskiIiIOYVkWBw8epFWrVgHfZFohFMT3339PmzZt4n0aIiIiEobvvvuO1q1b1/l5hVAQjRs3BuC8Gx8iJS3weziJiEhgO/cfAeD8Ib3jeh7FR//9nnf929b7a50orwRgUNvMsJ5vVRwHoCWHghxZy3NLT75pccWOTWF9b4Bju78DYN/XPwQ5MnTF33wLwHf70yP+tYM5Wn6Cm9au8P0er4tCKIiq5bCUtAakeHUDMBGRcO3Yd5jktAYMufCsuJ7HgaMnSG3gZfzA9vX+WifKK0kFzm/fJKznW+XHgXRyOAgE/oVd47ml+6DxaVRs+wIahfcf6sd27SStQTp7vyqisTctrK9RlwObt3Jaaio79qXTMI61EWxbi0JIRESiase+wwBGBBAQkQCCHydB9Ysg/h1BIT63dB/AyQgK07FdOwHY+1VR2F+jLgc2bwVgx77YT4JCpRASEZGocWMEVQUQhBdB9QkgqH8ERTOAwFkRBAohERGJEjdHkKZAtXNaBIFCSEREokARVJObI8iJAVRFISQiIhHjxgACRVAgTo4gUAiJiEiEuDGC4hlAoP1AsaAQEhGRelME1eTmKRC4I4JAISQiIvXgxgACRVAwbokgUAiJiEiYFEE1VQUQKIKcQiEkIiIhc2MEuWU/EGhTdCgUQiIiEhJFUE1aCnMuhZCIiNjixgACRVAwbo4gUAiJiIgNiqCa4r0UBoqgSFAIiYhIQG6MIBOmQKAIMoFCSEREalUVQKAIqs7tS2GQOBEECiEREamFG6dAoAgKJpECqIpCSERE/LgxgqoCCLQfqC6JGEGgEBIRkWrcHEHaD1S3RI0gUAiJiAjuDCAwI4JMDiBwbwS1yTpm67ikKJ+HiIgYThFUO0WQc7VrZi+CQBMhEZGE5sYIcvpbZYAiKFxVAdS0aydSyo4HOfokhZCISALSpfG1034g56oeQaFQCImIJBg3ToHAjAgyOYDAnREUbgBV0R4hEZEEogiqnSLImeobQaCJkIhIwnBjBGk/kD1ui6BIBFAVhZCIiMuZFkDg/AiKRACBIihU1a8Gi0QEgUJIRMTVTIsgLYWdFIsAAndGUKQCqIpCSETEpdwYQZF6qwxIjAhyUwBB5CMIFEIiIq6jS+Nrp/1AzhOtKVB1CiERERdx4xQInL8UBoqgUER7ClSdQkhExCUUQbWLdwRVBRAoguyIxRSoOoWQiIgLuDGCtBRmnxsiKJZToOoUQiIiDmZKAIEi6FSKIPtiPQWqTiEkIuJQpkSQlsJqUgTZE88AqqIQEhFxIEVQ7eIdQdoPZJ8JEQQKIRERR9Gl8bXTUphzmBJAVRRCIiIOoSlQ7RRBzhDLzdDNu7Uk7eix4AeiEBIRcQRFUO3ivRQGiiA7YjkFat6tJQDpuW1sHa8QEhExnBsjqL5vlQGKICeI9RQIIP0nbQE4fviorecphEREDGVKAIH2A50qVgEEzo+gmE6B/h1BoVAIiYgYyJQIctNSGDgrgpweQBC7KRCEF0GgEBIRMY4iqHZaCjOfU6ZA1SmEREQMYUoAgZlLYaAIMlU8AgjqH0GgEBIRMYIpEVQVQGBWBCXCUhgogoKJ1BSoOoWQiEicmRZBbloKA0VQtDh5ClSdQkhEJE7cepdoMCOCnLIUBs6KoFi/S3w0pkDVKYREROLAlCkQmLkfKJ5LYaAIqkus3x4j2hEECiERkZgzJYLcNAUC7QeKJrdNgapTCImIxJAiqHZaCjOXU6dAye262zpOISQiEgOmBBDorTJqowiqyalToOQOPU/+j4OHbB2vEBIRiTJTIkiXxtdOEVSTY6dA/44gT0YzPJ40W89RCImIRJFpEeSGpTBw3n4gcEYExSuAILIRFAqFkIhIFOjS+Lol2lIYKIJqE40pUDiS6vXdY+ydd97h4osvplWrVng8Hl566aWAx69evRqPx1PjT2FhYWxOWEQSUvUpkJsi6ER5JSfKKzm/fZOwIsgqP64IMlC7Zsdo1+wYTbt2itleIFMiCBw2ETp8+DC9e/fm2muv5bLLLrP9vM2bN5ORkeH7uEWLFtE4PRERLYXVwYSlMNB+oOpivRkazJkCVeeoEBo5ciQjR44M+XktWrSgSZMmkT8hEZFqFEG1MyGCNAXyl4h7geriqBAKV15eHmVlZfTs2ZNZs2Zx7rnnxvuURMRFTAkg0KXxtVEE/cgNUyCIXASBy0MoNzeXhQsX0q9fP8rKynjiiScYMmQIa9eu5ayzav8XVllZGWVlZb6PS0tLY3W6IuJApkSQLo2vnSLoR7GeAoGZS2GncnUIde3ala5du/o+HjRoEFu3buXBBx/kL3/5S63PmTt3LrNnz47VKYqIg5kWQVoK86cIOklToMBcHUK16d+/P++9916dn8/Pz2fatGm+j0tLS2nTpk0sTk1EHMKUAAJFUG1iHUBgfgQl4hSoiNNsHZdwIbRhwwZyc3Pr/LzX68Xr9cbwjETESdwaQfUNIEjM/UBgZgQ5OYCg/hFUSGPA3tYWR4XQoUOH2LJli+/jbdu2sWHDBrKysmjbti35+fns2rWLZ599FoAFCxbQoUMHevTowbFjx3jiiSdYtWoVb775Zrx+BBFxMFMiSFOg2sUrgkwMIHBmBEUmgE7yJLvwLTbWrVvH0KFDfR9XLWFNmjSJRYsWsXv3bnbu3On7/PHjx7nlllvYtWsXDRs2pFevXrz11lt+X0NEJBjdJbpuiRpBmgKdZN4UCDwpVQF0rO6Dq/FYlmWF9R0TRGlpKZmZmQyZ8jgp3obxPh0RiTFTpkDgzkvjQfuB6ivRp0BQWwTBwdJSurdrRUlJid9NlU/lqImQiEgsmRJBujS+doqg+E6BIP4RVFsAhUohJCJSC9MiSEth/hI9gtwyBYL4RhAohERE/JgSQKAIqosiSFOgKvWNIFAIiYj4uDWCdGl8/ZgSQfEIIDB9Q3T9KYRERDAngjQFql0iR1C8lsHAnA3RkZ4CVacQEpGEZkoAgSKoLvGMIE2B3DkFqk4hJCIJSxFUt0SOIE2BzJgCQfQjCBRCIpKgTIkgUy+NB+0HihdNgSITQP/cWWLrOIWQiCQU3SW6bok8BYL4R1C8Agjcd1n8u9uLbR+rEBKRhGHKFAgUQXVJxAgyYRkM4r8UFokN0VUBlJqSRGpKkq3nKIREJCG4NYJMuTQeFEHh0BTopEhOgewGUBWFkIi4mpbC6pboUyCIXwRpCnRSJKdAEHoEgUJIRFzMrVMgUARFQrwjyMlTIDBjQ3S4U6DqFEIi4kqKoLopguITQSYEEMR/CgT1j6D6ToGqUwiJiOuYEkGmBhDE99J4iH8ExSOAQFMgU6ZA1SmERMQ1TAkgMDeCNAVKnCkQaEO0HQohEXEFRVDdFEGxjyBNgX4U6cviI00hJCKOZ0oEmXaXaFAEQfwiSFMgc6dA1SmERMSxTAkg0BQokESJILcEEJg1BYLoRRAohETEoRRBdTMlguIZQBC7CIr3MhiYGUEmT4GqUwiJiOO4NYKqAggUQfUV6wiKdwCBLosPl0JIRBxDd4muW6QujQdFkB2aAvlz2hSoOoWQiDiCW6dA4L6lMEiMCIp3AIE2RNdl6ZrtnDh6OPiBKIRExAEUQXUzLYLiFUAQ/QiKdwCBmVMgMOuy+KVrtgPQpIG9xFEIiYixTFwKA10afyq3R5AJy2Cgy+KDqQoggKYNUjl+tMzW8xRCImIkTYHqZkoAQeJEkBsCCMyaAkHkI6hpg9SQn6sQEhHjKILqZkoEmRBAEL33DTMhgMDMCDJpCgT1iyBQCImIYdwaQbo0PvKiEUFuWwYDMy6Lh+gthYUbQFUUQiJiBLcGEOjS+EiL1lKYpkA1mRhAELkIAoWQiBhAEVQ3U6ZA4N4IMi2AQBui63LqhuhIUAiJSFwpgupmSgSZEEAQ+QgyZRkMzJwCgXs2RAeiEBKRuFAABaYI8hetCDIlgEBToLpEYwpUnUJIRGJOEVQ3UwII3BlBpgQQmDUFAjPfJyxaU6DqFEIiElOKoLopgmqKVASZtAwGZkWQiVMgiE0EgUJIRGLExAAC3SX6VKYEEEQ+ghRANZkYQbEKoCoKIRGJOhMjyLQpEOjS+OoiEUEmBRCYFUEmBhDEPoJAISQiUaYIqpspUyBwVwQlwjIYuCuCor0hOhCFkIhEhYkBBLpL9KmqAgicH0GmBRCYOQWCxNsQHYhCSEQizsQIMmUKBOZFkAkBBJGJINMCCHRZfCDxjiBQCIlIhCmC6mZKAIF5EVQl1AgyLYDArCkQmBlBJgRQFYWQiEREVQCBIqg2iqDAQn0DVROXwcCsCDIxgMCsCAKFkIhEgKZAgZkSQSYGEIQWQQoge0yMoHhuiA5EISQi9aIIqlukAgjcHUF2mBpAYFYEaUN06BRCIhIWLYUFZsoUCMyPoEDToEQLIHDXUpipU6DqFEIiEjJNgQJTBAUXLIJMDiAwawoEifs+YZGgEBKRkCiCAjMlgkwNoOpqiyCnBBCYEUEmToHAOREECiERsUlLYYGZEkBgfgTVti/I9AAC902BwN2XxdulEBKRoEycAoHuEl0b0yMITobOgc1b/eKn6nETaQpkj2kR9O7qT20dpxASkYBMjCBTpkBgTgSZ9lYZwZgaPafSFCg40zZEry74GIC2WQ351sbxCiERqZWWwgLTpfHuZ1IE6bJ4e6oiqF2zRpSXHbH1HIWQiMMc2vsvDv2wk6RUL1ltzyAlrUHEv4dJUyBwbwS5ZSnMsiy+KNzD9v0lNPamMbB9a7wpzv31osvi7TEpgqoCCE5GUCgc9Tf1nXfeYf78+axfv57du3fz4osvMmbMmIDPWb16NdOmTWPjxo20adOG22+/ncmTJ8fkfEUi6fD+7/nyzScp2bXZ91hSipe2Z/0nnc69HE9SZP4FZ1IEmRZAoAg61affF3L7a6v46ocfJ1yZXi+/Ou9srjk7D4/HE7dzC4dJUyAwM4JMCiDwnwKFw1EhdPjwYXr37s21117LZZddFvT4bdu2MXr0aG666Saee+45CgoKuP7668nNzWX48OExOGORyDhWupd1S++i3Eomuf1QPI1bQXkZlfu+ZvtHr3D86EHO+M/r6/U9tBQWWFUAQfwjyIQAAviy6Aeueu5FMiuSGUkLcvFyiAq+KCtlbsF7HDl+ginn9Y/rOdqlDdH2uC2CwGEhNHLkSEaOHGn7+IULF9KhQwfuv/9+ALp37857773Hgw8+qBASR9n24T8oL68guetP8aT8+94ryWkkt+oLaY34/vPVtD1rBKc1bx3W1zdpCgTmRlC8AwjMiSCAB1avoWFFEqOtFqRy8pdtU5I4n2akkcT/vv8RV5x1Js0aRn75NpI0BQrO1A3R9QmgKo4KoVCtWbOGYcOG+T02fPhwpk6dWudzysrKKCsr831cWloardMTscWqrGT3l+/hyer2YwRVk5TVBatoA7s3vkuXwVeE/PVNiiDTAggUQXXZd/gI73y7g/PJ8kVQdb3J4PPKg7z65ddM7Nc7DmcYnKlTINCG6EAiGUHg8hAqLCykZcuWfo+1bNmS0tJSjh49SoMGNf8rZe7cucyePTtWpygSVMWJY1SeKCM5vWmtn/ckJYM3g7LDxSF/bUVQYKZEkImXxu87chQLaErtv7DTSea0pBR+OHS41s/HmzZE22NSBNVnQ3Qgrg6hcOTn5zNt2jTfx6WlpbRp0yaOZySJLjk1naRUL9axA0CHGp+3KiugrBRvoya2v6ZJAQTmRZApAQRmTYGqa9awAR7gAMfJwVvj88eo4JBVTovTIvcLK1K0FBacSQEEkZ8CVefqEMrJyaGoyP9fHkVFRWRkZNQ6DQLwer14vTX/oRaJF09SErlnnMf3X67Byj6jxvJY5f5vsE4cJbfH+ba+nkkRFK0AAkVQtDVr1JALOrbj82276Ww1qrE89imlJHk8jD7j9DidYU2RDCDQhuhYiWYEgctDaODAgbz22mt+j61cuZKBAwfG6YxEwtOh/8Xs+fojyre8TlLLPDwZP/n3VWObqdzzBa3OHGJro3QiRJAblsLA7AiqcsuQgfx85/O8UrGHvlYmOXg5TDlfcJAvOcTU884hy5CN0poCBefmDdGBOCqEDh06xJYtW3wfb9u2jQ0bNpCVlUXbtm3Jz89n165dPPvsswDcdNNNPProo0yfPp1rr72WVatW8X//93+8+uqr8foRRMKSntGcfuPv4Ms3n6Bkx2rf40mp6bQfcAmdBo0N+HyTAgjMiyDdJTo83Vtms/jK/+KO19/m9T17fI838Xr5/XnnMfnsvPid3L+5eUO0pkCR4agQWrduHUOHDvV9XLWXZ9KkSSxatIjdu3ezc+ePmwo7dOjAq6++ys0338xDDz1E69ateeKJJ3TpvDhSo6xczh5/B4f27eLQD9+RnJJKUxt3ljYpgiIdQGBOBCXKFOhUvVvl8PK149lY+APbDxTT2JvGOe3MuLO0pkD2mBRB0doQHYjHsiwrJt/JoUpLS8nMzGTIlMdJ8TaM9+mIhMTNEaSlMKmLm6dAoA3RdpWXHWH1ozdSUlJCRkZGncfFP9lFJOJMCiAwL4LqG0Dg7kvjnUyXxdvj9ggKhUJIxGVMiqCqAAL3RJCmQObSUlhwibohOhCFkIiLmBhBpgQQKILcSpfF26MpUO0UQiIuYFIAgXkRZNIbpoIiKJI0BQrO1CkQxD+CQCEk4ngmRZCWwgJTAEWONkTboylQcAohEQczMYJMCSBQBLmVNkTbowiyRyEk4kAmBRAogoJRBEWOlsKCUwCFRiEk4jCKoMBMvEs0KILqSxui7VEEhU4hJOIQVQEEZkSQaQEEmgK5laZAwWlDdPgUQiIOoClQcIog9zF1CgTaEB2IE6ZA1SmERAynCArMpLtEgyIoUrQh2h5FUP0phEQMlShLYRD//UAKIHOYdlk8mBlBCqDIUQiJGEhToOAUQe5j6lKYSQEEiqBIUwiJGEYRFJiWwtxJG6KD04bo6FAIiRhCS2HBaQrkPqZOgUAbogNx+hSoOoWQiAE0BQpOEeQ+2hBtjyIouhRCInGmCApMb5jqPtoQbY8CKDYUQiJx4valMIj/fqBoBBAogupDUyB7FEGxoxASiQNNgYIzMYIUQPWjDdHBmboh2o0BVEUhJBJjiqDAtBTmPtoQbY+mQPGhEBKJES2FBWfSG6aCIigSNAWyRxEUPwohkRjQFCg4LYW5izZE26MAij+FkEiUKYKCUwS5izZE26MIMoNCSCRK3B5AoKUwqUlLYcGZuiEaEi+CQCEkEhVujyBNgeRU2hBtj6ZA5lEIiUSYIig4RZC7aApkjyLITAohkQhxewBB/JfCQBFkEm2ItkcBZDaFkEgEuD2CNAWSU2lDtD2KIPMphETqSREUnCLIXbQUFpw2RDuHQkgkTG4PINBSmPjThmh7NAVyFoWQSBjcHkFunQKBIihcmgLZowhyHoWQSIgUQcGZGEEKoPBoQ7Q9CiDnUgiJ2OT2AAIthYk/U5fCTAogUAQ5nUJIxAa3R5Bbp0CgCAqXlsKC04ZodwgphD799FP+8Y9/kJWVxc9//nOaN2/u+1xpaSlTp07lqaeeivhJisSLae8YD4qgYDQFqh9Tp0CgDdGBaAoUPo9lWZadA998800uvvhiunTpwsGDBzl8+DDLli1j6NChABQVFdGqVSsqKiqiesKxVlpaSmZmJkOmPE6Kt2G8T0diyO1TINBSmPjTvYHsUQQ5Q3nZEVY/eiMlJSVkZGTUeZztidCsWbO49dZbueeee7Asi/nz53PJJZewbNkyRowYEZGTFjGF2yOoKoAg/m+YGokAAkVQfWhDtD0KIHeyHUIbN27kL3/5CwAej4fp06fTunVrfvazn7F06VLOPvvsqJ2kSKxoKcwekyJIAVQ/pi6FmRRAoAhyM9sh5PV6KS4u9ntswoQJJCUlMW7cOO6///5In5tITLl9CgRaChN/2hBtj0kRpA3RkWc7hPLy8nj77bfp27ev3+Pjx4/HsiwmTZoU8ZMTiRW3R5CWwqQ6U6dAoA3RgWgKFB22Q+iXv/wl77zzTq2fu+KKK7Asi//3//5fxE5MJBZMCyDQUlgwCqD60YZoexRBicP2VWOJSleNuZdpEaSlsOAUQeHThmh7TL03kAIodBG/akzETdweQVoKk+pMXQozKYBAU6BEpRCShGJaAIGWwoJRANWPNkTbY1IEaUN0bCmEJGGYFkEmL4WBIsjpTJsCgZkRZFIAgaZA8aAQEtdLpHsDQfyXwkARFG/aEG2PIkggjBCaM2cOt956Kw0b+m8cPnr0KPPnz+fOO++M2MmJ1JdpUyDQUlgwCqDwaUO0PdoQLdWFfNVYcnIyu3fvpkWLFn6P79u3jxYtWui9xsQYpkWQlsKCUwSFz7SlMN0byB5FUPRE7aoxy7LweDw1Hv/000/JysoK9cuJRJyWwuzRUph7aEO0PYogqY3tEGratCkejwePx8Ppp5/uF0MVFRUcOnSIm266KSonKWKXaVMg0FJYMAqg8Jk2BQIzI0gBJIHYDqEFCxZgWRbXXnsts2fPJjMz0/e5tLQ02rdvz8CBA6NykiJ2mBZBWgoLThEUPtMiyMQAAkWQBGc7hKreS6xDhw4MGjSI1NT4/KV67LHHmD9/PoWFhfTu3ZtHHnmE/v3713rsokWLuOaaa/we83q9HDt2LBanKjFiWgCBlsLsUASFT0thwZm6IRoUQaYJeY9Qhw4d2L17d52fb9s2Mv91Upu//e1vTJs2jYULFzJgwAAWLFjA8OHD2bx5c43N21UyMjLYvHmz7+Pa9jeJcyVSBGkpTEydAoE2RAeiKZDZQg6h9u3bB4yJaF419sADD3DDDTf4pjwLFy7k1Vdf5amnnmLGjBm1Psfj8ZCTkxO1c5L4MS2CtBQWnCIofLo3kD2KIAlVyCH0ySef+H184sQJPvnkEx544AHuueeeiJ3YqY4fP8769evJz8/3PZaUlMSwYcNYs2ZNnc87dOgQ7dq1o7KykrPOOos//OEP9OjRo87jy8rKKCsr831cWloamR9AIsa0AAJNgexQBIVH9wayRwEk4Qo5hHr37l3jsX79+tGqVSvmz5/PZZddFpETO9XevXupqKigZcuWfo+3bNmSr776qtbndO3alaeeeopevXpRUlLCfffdx6BBg9i4cSOtW7eu9Tlz585l9uzZET9/iQxFkD0mRZACKHymLoWZFECgCJL6idhbbHTt2pWPPvooUl8uIgYOHOh3JdugQYPo3r07f/7zn7nrrrtqfU5+fj7Tpk3zfVxaWkqbNm2ifq4SWCLcGwgitxQWbgCBIsgU2hBtj0kRpA3RzhRyCJ26VGRZFrt372bWrFl06dIlYid2qubNm5OcnExRkf+/UIuKimzvAUpNTaVPnz5s2bKlzmO8Xi9er7de5yqRpSmQPSZNgUARFC7TpkBgZgSZFECgKZCThRxCTZo0qbFZ2rIs2rRpw9KlSyN2YqdKS0ujb9++FBQUMGbMGAAqKyspKChgypQptr5GRUUFn3/+OaNGjYraeUpkKYLsMSmCFEDh04ZoexRBEkkhh9Dbb7/t93FSUhLZ2dl07tyZlJTovpn9tGnTmDRpEv369aN///4sWLCAw4cP+64imzhxIj/5yU+YO3cucPINYs855xw6d+5McXEx8+fPZ8eOHVx//fVRPU+pPy2F2aOlMPfQUlhwujeQREPI5TJ48OBonIct48aN44cffuDOO++ksLCQvLw8VqxY4dtAvXPnTpKSfvwH7sCBA9xwww0UFhbStGlT+vbtyz//+U/OOOOMeP0IYoOmQPaYNAUCRVC4TFsK072B7NEUyD1Cfvd5gM2bN/PII4+wadMmALp3786UKVPo1q1bxE8w3vTu87FlWgRVBRAoguqiAAqflsLsUQRJOKL27vMvvPAC48ePp1+/fr4rsj744APOPPNMli5dytixY8M/a0lYpgUQaCnMDkVQeHRvIHsUQBILIYfQ9OnTyc/PZ86cOX6Pz5w5k+nTpyuEJGSJEEFumwKBIihcpi6FmRRAoAiS2Ak5hHbv3s3EiRNrPH7VVVcxf/78iJyUJAaTN0SDIqguCqDwaUN0cNoQLbEWcggNGTKEd999l86dO/s9/t5773H++edH7MTE3RJhCgRaCpOTTJsCQf0jSBuixS1CDqFLLrmE3/3ud6xfv55zzjkHOLlHaNmyZcyePZu///3vfseKnCoRIsitUyBQBIXKtAgycQoEiiCJn5CvGqt+eXrAL+zxRPWd6GNFV41FjpbC7DMxghRAodNSWHAKIImWqF01VllZWa8Tk8SUCFMg0FKYnGTqFAi0FBaIIigxRfdW0CIkRgS5dQoEiqBQ6d5A9iiCxBRhhVBBQQEFBQXs2bOnxoToqaeeisiJifMlQgCBeyNIARQ6LYUFpwAS04QcQrNnz2bOnDn069eP3NzcGm/AKgKKILu0FOYOpi6FmRRAoAgSM4UcQgsXLmTRokVcffXV0TgfcTgTN0SDlsKCUQCFT1Og4HRvIDFZyCF0/PhxBg0aFI1zEYfTFMg+RZDzufFtMrQhWhJRyH/Tr7/+epYsWRKNcxEHS4QIOlFeGZGlMKv8ODkcDCuCrNJ9iiADVJ8CmRBBhTSmkMZ4UtLqHUGpKUmKIEkoIU+Ejh07xuOPP85bb71Fr169SE31/wv+wAMPROzkxHwmBhBoKSwYBVD4tBQWnAJInCTkEPrss8/Iy8sD4Isv/P+FrI3TicXECDJxKawqgEAR5GSmLYXp3kD2KIIkmJBD6O23347GeYjDJEIEVQUQxO+qsKoAAkVQPOneQPYogsSJdENFCYnJAQRaCquLAih8WgoLTgEkTmY7hC677DJbxy1fvjzskxGzmRxBWgqrmyIoPLo3kD2KIHE62yGUmZkZzfMQg+neQPaZOAUCRVCotBQWnO4NJG5hO4SefvrpaJ6HGMrkKRAoguqiKVD43LYUpg3RIoFpj5DUyeQIMnEpTG+T4WxaCrNHESRuoxCSGkwMINBSWDAKoPC5bQoEWgoTsUshJH5MjCATp0CgCHILt0WQlsJEQqMQEiBxNkSDlsLkJC2F2aMIErdTCImRUyDQUlgwCqDwuW0KBLo3kEi4FEIJzsQIMnEKBIogtzApgiL5NhmaAomERyGUoEwMINDbZASjewOFT0thwZm2IRoUQRJ9CqEElGgRpCmQmDQFArMjSAEkiUYhlEC0Ido+vU2Ge5gUQSYGECiCJLEphBJEok2BQEthiU5vkxGcaUthujeQxINCKAGYGEF6m4zgNAUKn0lTINC9gezQFEjiRSHkYiYGEGgpzA5FUPhMiiATp0CgCBKpTiHkUokSQSYthSmA4ktLYcGZGkCgCJL4UQi5kIkRZOIUCBRBbmHSFAi0FGaHpkBiCoWQi5gYQGBmBJn0NhnaEF0/JkWQiVMgUASJBKIQcolEiSBNgaSKlsKCUwCJBKcQcjjdGyg0iiB3MHEKBHqbjEAUQWIqhZCDJcoUCOK/FKZ7A5nDxAgycQoEiiAROxRCDmViBOneQMFpChQ+kwIIzI4gBZCIfQohhzExgMDMKRAogtzCpAjSUpg9iiBxCoWQgyRKBJl0byCI3FKYAig8JkaQiVMgMCOCdG8gcRqFkAOYviEatBRWF0VQ+EwKIDA7gkwIINAUSJxJIWS4RJkCgbveJkMbouvHpAjSUpg9iiBxKoWQwRIlgkxaCtMUKP5MjCBNgeqmpTBxOoWQgRIlgEBLYfIjkwII9DYZdmgKJG6gEDKMIsg+bYh2D5MiyMQpECiCRKJFIWQIUzdEg94mIxhFUP0oggIzNYBAESTuoBAygKZAoTElgrQhun5MCiDQUpgdmgKJGymE4kwRZJ+WwtzDpAgycQoEiiCRWFEIxYnpAQRaCquLIqh+FEGBKYBEYkshFAemR5CJUyCIfwSZEEDf7jvA0k++YFPRXhqkpjDs9I5c3ON0GqSa8UszEJMCCCK3FKYpEJQWbWPXZ29z+EAhqd6GtOx6Di269CMpWb9ixHyR+yc4Rh577DHat29Peno6AwYM4MMPPwx4/LJly+jWrRvp6emceeaZvPbaazE605p27DucMBF0orwyokth4USQVboPq3QfFdu+cEUEPfXhJ4x4fDF/W/c5e3bu5+uthdz++ipG/Hkx2/cXx+287DApggppTCGN8aSkGRNBS9dsd2QEWZbF16uf48PFd/D9Vx9ScvAIe3fv5ItXH2Xt4jsoO1wSq9MVCZujcv1vf/sb06ZNY+HChQwYMIAFCxYwfPhwNm/eTIsWLWoc/89//pMrrriCuXPn8tOf/pQlS5YwZswYPv74Y3r27BnTc0+UAAIthUXDqm+2MbfgPXqTwdlWE5LxAFDCCd48tJdrl77MG7+4itTk5LidY11MiyDQUlggoSyF7fq0gJ3rXyepVX+Ssrvj8Zx8TawjezmyrYDP/v4Q/cbfgcfjieo5i9SHx7IsK94nYdeAAQM4++yzefTRRwGorKykTZs2/Pd//zczZsyocfy4ceM4fPgwr7zyiu+xc845h7y8PBYuXGjre5aWlpKZmcmQKY+T4m0Y1nkrguyr71KYWzdET/jLC/xr134utlrgwf+Xyl6O8wK7eeS/RjKiW+c4nWFNJgUQaCnMjlAiyLIqef+JWyhLakxK+8E1Pl9ZspOKbQWcPWE2mbmdIn6uIsGUlx1h9aM3UlJSQkZGRp3HOWYidPz4cdavX09+fr7vsaSkJIYNG8aaNWtqfc6aNWuYNm2a32PDhw/npZdeqvP7lJWVUVZW5vu4tLQ07HM2NYBA9wYKxqQIOnainI/+9T0XkFUjggCak0bzpDTe/XaHMSFkUgSZPAUCZ0YQwNHiPRwr/YHkjnm1ft6T0RpPSjr7tn+mEBKjOSaE9u7dS0VFBS1btvR7vGXLlnz11Ve1PqewsLDW4wsLC+v8PnPnzmX27Nn1Pl9TI8jEKRCYE0Em3huowjr5+qbUEkFVUiwPJyor6/x8LCmCAnPyFKg6q7Li5P9Iqv3XiMeTBEnJWJXl9To/kWhzTAjFSn5+vt8UqbS0lDZt2th+fiLdIRp0b6BYaJiaSvummew4cJQunFbj84coZ49VRq/clrU8O3aqAgjqH0FaCouN+lwan56ZTYq3EZUlO+G0nBqfrzzyA9bxw2TkaBokZnNMCDVv3pzk5GSKivx/SRUVFZGTU/MfQoCcnJyQjgfwer14vd6wztH0KRBoKawupkYQgMfjYdLZecx58//jWw7TkR9/aZVj8R77aZCayqU9u8XtHDUFCswNS2GnSk5J4ye9hrJj/Qo8mW1JqhZDVnkZlbvW4s1oTvMOeZE4XZGocUwIpaWl0bdvXwoKChgzZgxwcrN0QUEBU6ZMqfU5AwcOpKCggKlTp/oeW7lyJQMHDoz4+ZkeQSZNgcCcCDI5gKq7ok9PPtq5i9e+2kIbz2FaW+kcpYKtniOUJVn86b9G09gb/i/++lAEBeamKdCpOg68jJLdWyjeuoLKjLZ4GrWEE4exDmwlKTmJ3mNm4Ely3F1aJME4JoQApk2bxqRJk+jXrx/9+/dnwYIFHD58mGuuuQaAiRMn8pOf/IS5c+cC8Nvf/pbBgwdz//33M3r0aJYuXcq6det4/PHHI3ZOpgYQRG9DNMR/KcztU6BTJScl8eCYEQz9YjOL13/Ghh/24U1JZkTX07nm7Dy6ZIe/hFQfkYqgSAUQaCkskEjfJTo5NY2zxv6OXV+s5l+fruLong0kpzUgp9cQ2p41nAaZ2RH5PiLR5KgQGjduHD/88AN33nknhYWF5OXlsWLFCt+G6J07d5JU7b8+Bg0axJIlS7j99tv5/e9/T5cuXXjppZcidg8hUyNIU6DATNwQbUeSx8OYM7sx5sz4LYFV0RQoMFMDCCL/VhlJKam0ybuINnkXRfTrisSKo+4jFA+13UfI1AACMyNI9wZyF0VQYKZGkN4rTBKN6+4jZIpEiiAthcmptBQWmCJIxHkUQjbt3H+E5LSTwzPTIsjEKRCYE0EKoPrTFCgwUwMIFEEiwSiEQmBaAIGZEWRKAIEiKBLcFEFVAQTujyAFkIg9CiGbzh/SO96n4Ef3BgrMqRuiTaOlsMAUQSLOpxByIBOnQGBeBCmAwuemKRBoKUxE6qYQchhtiA5MEVR/boogLYWJSDAKIYfQFCgwBVBkaCksMEWQiPsohBzAxAjSvYHcxaQ3TNVSWHBaChOJHIWQ4bQUVjdtiI4MLYUFZmoEKYBEIkMhZCgTp0BgXgQpgOpHS2GBKYJE3E8hZCATI8iUAAJFUKSYFkFaCqublsJEokchZBDdGygwkwPowOatNR5r2rVTHM4kOC2FBWZqBCmARKJDIWQIE6dAUL8ISoQN0dUDaMe+dN//btfsWDxOJyjTpkCgpbBAFEEi0acQMoCJEWTaFAjMiqC6AggUQcFoKSw4LYWJxI5CKI5MDCAwL4JMDKBT46dKVQSZtCympbDATI0gBZBIbCiE4sTECNK9geoWLICqc2MEVQUQhBdBJi6FVQUQKIJEEplCKA50b6C6mRpAEDyC2jU75uoI0lJY9GgpTCR+FEIxZOIUCBRBtQklgMCsfUFuuku0lsJEJNoUQjFiYgSZFkAQ/wgKNYDArH1BWgqrm5bCRKQ2CqEo072BAjNxCmQ3gMDdEaSlsOjRUpiIORRCUWTyFAjiuyHaxClQKAEEiqDaaCksOE2BRMyiEIoSkyNIU6CTwlkGq2JKBJlyabyWwuxRBImYRyEUYSYGECiCqqtPAIH7IijeUyDQUpiIxI9CKIJMjKBILYW5IYAg/GWwKoogf1oKC05TIBGzKYQiIJobokFLYZFQ3wACMyLIlKUwiFwEaSlMROJJIVRPJk6BwIw3SzVhQ3R9l8GquCmC4h1AoKUwETGHQqgeTIwgTYF+FIkpECiCqtNSWHCaAok4i0IoDCYGECiCqkQqgEARVJ2WwoJTBIk4j0IoRCZGkDZEnxSpZbAq8Y4gtwQQaClMRMylEAqB3iy1bqZEUCQCCBRBVbQUFpymQCLOphCyqfhoOVf/R9eIfT23LIXFe0N0pKdAoAiqoqWw4BRBIs6nELJpbP/6X65cRUthkRHpKRDEN4LcEkDg/qUwUASJuIVCKIa0FBYZ0QggOBlBmgJpKSwYBZCIuyiEYiTeS2GRvjeQW5bBQEthVbQUFpwiSMR9FEIxoHsD1V80p0Dg7AiqCiCo3xumaiksMEWQiDsphKIo3lMgcP6G6GgFEGg/EGgpzA4FkIi7KYSiRBui608RFJgpEaSlMBFxMoVQhGlDdP1FM4BAEaSlMHsUQSKJQSEUQfFeCnP6huhobYauLl4RZEIAgZbC7FAAiSQWhVCEaEN0/UR7CgSKINOWwkARJCLxpxCqJ7cshcVrQ3QspkCQ2BGkpTB7FEEiiUkhVA+mLIVpChSYkyPIlCkQuDeCFEAiiU0hFCYthYUvVgEE8blbtAlTINBSmB2KIBFRCIXIlCkQOG9DdKyWwcDZUyCIzFIYmBNBpgUQKIJE5CSFUAh0b6DwxXoKBM6MoHhPgcD9EaQAEpHqFEI2nSivJBVnL4W5fQoE8YkgE6ZAoKUwOxRBInIqhZBNg9pm0jgjI6znJvpSWCwCCBI3grQUZo8iSERqoxCKIpOmQBC7CIr1FAicG0F6w9ToqwogUASJSE0KoSgxKYLcPAUC50eQlsKiR1MgEQlGIRQFiXhvoHgEEMQ+gkxYCgPzIsi0AAJFkIjYoxCKIE2BNAWyQ3eJjj5FkIjYFbmZeJTt37+fK6+8koyMDJo0acJ1113HoUOHAj5nyJAheDwevz833XRTVM6vvlMgJ0bQgc1bObB5Kzv2pSuCbEju0JPkDj3xZDSLSwS9u72Yd7cXk5qS5NoIWl3wMasLPqZds0aKIBGxxTEToSuvvJLdu3ezcuVKTpw4wTXXXMONN97IkiVLAj7vhhtuYM6cOb6PGzZsGNHzMuHeQLHeEB2PzdBVtBSmpbC6aAokIuFwRAht2rSJFStW8NFHH9GvXz8AHnnkEUaNGsV9991Hq1at6nxuw4YNycnJicp5JeJSWLz2AkFiRpCWwuxRBIlIuBwRQmvWrKFJkya+CAIYNmwYSUlJrF27lv/6r/+q87nPPfccixcvJicnh4svvpg77rgj4FSorKyMsrIy38elpaW1HpdoG6LjOQUCZ0aQ26ZAYF4EKYBEpL4cEUKFhYW0aNHC77GUlBSysrIoLCys83kTJkygXbt2tGrVis8++4zf/e53bN68meXLl9f5nLlz5zJ79uw6P68pUOwpgkKnKZCIiD1xDaEZM2Ywb968gMds2rQp7K9/4403+v73mWeeSW5uLhdeeCFbt26lU6faf6nm5+czbdo038elpaW0adMGSLw7RMd7CgSxjSAthdVOESQibhbXELrllluYPHlywGM6duxITk4Oe/bs8Xu8vLyc/fv3h7T/Z8CAAQBs2bKlzhDyer14vd4aj1sVx4H0hNsQnQgBBO64S7SWwkREQhfXEMrOziY7OzvocQMHDqS4uJj169fTt29fAFatWkVlZaUvbuzYsGEDALm5uSGfa0sOkYEn5Oc5bSks0aZAoKWw2lQFECiCRMTdHLFHqHv37owYMYIbbriBhQsXcuLECaZMmcL48eN9V4zt2rWLCy+8kGeffZb+/fuzdetWlixZwqhRo2jWrBmfffYZN998MxdccAG9evWK+jk7eUN0vAII4rMUBvGLIL1hqj2KIBGJFkeEEJy8+mvKlClceOGFJCUlMXbsWB5++GHf50+cOMHmzZs5cuQIAGlpabz11lssWLCAw4cP06ZNG8aOHcvtt98e9XPVFCg82g8UmqoAAvdGkN4wVUSizWNZlhXvkzBZaWkpmZmZ7Pv2CzIaNw56vFMjKJ4BBM6LIC2FRZ+mQCJSH+VlR1j96I2UlJSQkZFR53GOmQiZzmkbok0JIEisCNJSmD2KIBGJFYVQBGgKFB6nBRBoKSwWFEEiEksKoXpw2r2BTAkgcF4EaSks+hRAIhIPCqEwaQoUPkVQaLQUJiISPQqhMDgpgkwKIIhdBJl0abzuEh2YIkhE4kkhFAJtiK6fWEeQ7hLtz7QIUgCJiAkUQjZZpfuh8WmaAoXJiRGkpbDoUQSJiCkUQiFQBIUukfYDaSnMHkWQiJhEIWRTxY5N0KhByM9L1AACZ02BwIxL4xNhKQwUQSJiDoVQFCmCnBFBWgqLPk2BRMRUCqEoiNWGaBMDCBIngrQUZo8iSERMphCKsESeAoEiyK5EWAoDRZCImE8hFEGxiCAFkJbCTqUAEhEJn0IoAjQFSowI0hum2qMIEhEnUQjVUyJPgSDxIsiUAAJFkIhIJCiEwpToG6IhNhGku0TXpDdMFRGJHIVQGBJ9CgTOiyDtB4oeRZCIOJlCKESKoMSIoEgFECiCRERMphCy6dju70hrkB6TAAIzI0j7gexJpKUwUASJiLMphEKgKZC7p0BgbgSZEkCgKZCIuItCyKZ9X/9AY2/4dxCui+lTIEiMCNJdou1RBImI2yiE4sj0KRAoguzQpfEiIs6lEIoDJ0yBIPoRVBVAEH4EaSks+hRAIuJmCqEY0xToJKdPgUARJCLiBgqhGNEU6EdOjyAthYmIuIdCKAacMAUCZ0SQW+8SbWIAgSJIRNxPIRRFTpkCQez2A8V7CgSKoEA0BRKRRKMQihKnTIEgcSLIlAACRZCIiCkUQlHglAhywlIYuCuCTAwgUASJSOJSCEWQUwIIdGm8HYkQQQogEUl0CqEIUQT9yC1TIFAEiYi4nUKonpwUQKAICiYR3jAVFEEiIlUUQvXgpAhywn4gLYVFnwJIRMSfQigMTrosHjQFCkZLYSIiiUshFCInTYFAERSMLo0XEUlsCiGbir/5lvLUk7/YFEEn6S7R/kwMIFAEiYgEohAKgVMCCJwTQXrD1OhRAImIBKcQsum7/ek0dMCrZXoAgZbCYkERJCJijwN+tYtdiqDAEmEKBIogEZFQKIRcwvQI0humRp8CSEQkdAohF4hmBGkKVJMiSETEPRRCDlYVQKAIqk0iTIFAESQiUh8KIYdy81IYKILsUgSJiNSPQsiB3BxBpgUQmBlBCiARkchQCDmM9gPVTW+YKiIioVIIOYjJEaS7RMeGIkhEJLIUQg6gpbC66Q1TRUSkPhRChjN5CgRmRJD2A4mISLgUQgZTBNVNS2EiIhIJCiFDmRxBukt0bCiCRESiL3JrClF2zz33MGjQIBo2bEiTJk1sPceyLO68805yc3Np0KABw4YN45tvvonuidZTu2bHaNfsGE27dop4BDXv1tKICPKkpIUVQe9uL+bd7cWkpiS5OoJWF3zM6oKPadeskSJIRCTKHBNCx48f5/LLL+eXv/yl7efce++9PPzwwyxcuJC1a9fSqFEjhg8fzrFjx4I/OQ5iNQWKdwSFIxpToKVrttO0QapxEQSaAomIxIpjlsZmz54NwKJFi2wdb1kWCxYs4Pbbb+fSSy8F4Nlnn6Vly5a89NJLjB8/PlqnGhYthdVNS2EiIhItjgmhUG3bto3CwkKGDRvmeywzM5MBAwawZs0ao0LI7RFkSgCBmRFUFUCgCBIRiTXXhlBhYSEALVu29Hu8ZcuWvs/VpqysjLKyMt/HJSUlABwtPxGFs4Q2WcdIad8RgINlxyP6tZudns3xJtkAHD98NOTnJ7frDgcP4cnIgoMHQ3puEacBpXiS04DQlyL/ufPk656akkSkXvkXPtwJQJMGKRw/Whbk6NipOH6UtlkNASgvOxLnsxERcYfy4yd/71mWFfC4uIbQjBkzmDdvXsBjNm3aRLdu3WJ0RjB37lzfMlx1N61dEbNzkMTzbbxPQETEpQ4ePEhmZmadn49rCN1yyy1Mnjw54DEdO3YM62vn5OQAUFRURG5uru/xoqIi8vLy6nxefn4+06ZN831cXFxMu3bt2LlzZ8AXUoIrLS2lTZs2fPfdd2RkZMT7dBxNr2Xk6LWMHL2WkaPXsv4sy+LgwYO0atUq4HFxDaHs7Gyys7Oj8rU7dOhATk4OBQUFvvApLS1l7dq1Aa8883q9eL3eGo9nZmbqL2OEZGRk6LWMEL2WkaPXMnL0WkaOXsv6sTPAcMzl8zt37mTDhg3s3LmTiooKNmzYwIYNGzh06JDvmG7duvHiiy8C4PF4mDp1KnfffTd///vf+fzzz5k4cSKtWrVizJgxcfopRERExCSO2Sx955138swzz/g+7tOnDwBvv/02Q4YMAWDz5s2+zc0A06dP5/Dhw9x4440UFxdz3nnnsWLFCtLT02N67iIiImImx4TQokWLgt5D6NSd4R6Phzlz5jBnzpywv6/X62XmzJm1LpdJaPRaRo5ey8jRaxk5ei0jR69l7HisYNeViYiIiLiUY/YIiYiIiESaQkhEREQSlkJIREREEpZCSERERBKWQqgW99xzD4MGDaJhw4Y0adLE1nMsy+LOO+8kNzeXBg0aMGzYML755pvonqgD7N+/nyuvvJKMjAyaNGnCdddd53fvp9oMGTIEj8fj9+emm26K0Rmb47HHHqN9+/akp6czYMAAPvzww4DHL1u2jG7dupGens6ZZ57Ja6+9FqMzNV8or+WiRYtq/P3TLTfgnXfe4eKLL6ZVq1Z4PB5eeumloM9ZvXo1Z511Fl6vl86dOwe98jdRhPparl69usbfSY/HE/B9M8U+hVAtjh8/zuWXXx7wDtSnuvfee3n44YdZuHAha9eupVGjRgwfPpxjx0J/w1E3ufLKK9m4cSMrV67klVde4Z133uHGG28M+rwbbriB3bt3+/7ce++9MThbc/ztb39j2rRpzJw5k48//pjevXszfPhw9uzZU+vx//znP7niiiu47rrr+OSTTxgzZgxjxozhiy++iPGZmyfU1xJO3s23+t+/HTt2xPCMzXT48GF69+7NY489Zuv4bdu2MXr0aIYOHcqGDRuYOnUq119/PW+88UaUz9R8ob6WVTZv3uz397JFixZROsMEY0mdnn76aSszMzPocZWVlVZOTo41f/5832PFxcWW1+u1/vrXv0bxDM325ZdfWoD10Ucf+R57/fXXLY/HY+3atavO5w0ePNj67W9/G4MzNFf//v2tX//6176PKyoqrFatWllz586t9fif//zn1ujRo/0eGzBggPWLX/wiqufpBKG+lnb/uU9kgPXiiy8GPGb69OlWjx49/B4bN26cNXz48CiemfPYeS3ffvttC7AOHDgQk3NKNJoIRcC2bdsoLCxk2LBhvscyMzMZMGAAa9asieOZxdeaNWto0qQJ/fr18z02bNgwkpKSWLt2bcDnPvfcczRv3pyePXuSn5/PkSNHon26xjh+/Djr16/3+/uUlJTEsGHD6vz7tGbNGr/jAYYPH57Qf/8gvNcS4NChQ7Rr1442bdpw6aWXsnHjxlicrqvo72Tk5eXlkZuby0UXXcT7778f79NxDcfcWdpkVeu0LVu29Hu8ZcuWCb2GW1hYWGN0m5KSQlZWVsDXZcKECbRr145WrVrx2Wef8bvf/Y7NmzezfPnyaJ+yEfbu3UtFRUWtf5+++uqrWp9TWFiov3+1COe17Nq1K0899RS9evWipKSE++67j0GDBrFx40Zat24di9N2hbr+TpaWlnL06FEaNGgQpzNzntzcXBYuXEi/fv0oKyvjiSeeYMiQIaxdu5azzjor3qfneAkTQjNmzGDevHkBj9m0aRPdunWL0Rk5l93XMlzV9xCdeeaZ5ObmcuGFF7J161Y6deoU9tcVsWPgwIEMHDjQ9/GgQYPo3r07f/7zn7nrrrvieGaSqLp27UrXrl19Hw8aNIitW7fy4IMP8pe//CWOZ+YOCRNCt9xyC5MnTw54TMeOHcP62jk5OQAUFRWRm5vre7yoqIi8vLywvqbJ7L6WOTk5NTaklpeXs3//ft9rZseAAQMA2LJlS0KEUPPmzUlOTqaoqMjv8aKiojpft5ycnJCOTxThvJanSk1NpU+fPmzZsiUap+hadf2dzMjI0DQoAvr37897770X79NwhYQJoezsbLKzs6PytTt06EBOTg4FBQW+8CktLWXt2rUhXXnmFHZfy4EDB1JcXMz69evp27cvAKtWraKystIXN3Zs2LABwC8y3SwtLY2+fftSUFDAmDFjAKisrKSgoIApU6bU+pyBAwdSUFDA1KlTfY+tXLnSb7KRiMJ5LU9VUVHB559/zqhRo6J4pu4zcODAGrdw0N/JyNmwYUPC/Dsx6uK9W9tEO3bssD755BNr9uzZ1mmnnWZ98skn1ieffGIdPHjQd0zXrl2t5cuX+z7+4x//aDVp0sR6+eWXrc8++8y69NJLrQ4dOlhHjx6Nx49gjBEjRlh9+vSx1q5da7333ntWly5drCuuuML3+X/9619W165drbVr11qWZVlbtmyx5syZY61bt87atm2b9fLLL1sdO3a0Lrjggnj9CHGxdOlSy+v1WosWLbK+/PJL68Ybb7SaNGliFRYWWpZlWVdffbU1Y8YM3/Hvv/++lZKSYt13333Wpk2brJkzZ1qpqanW559/Hq8fwRihvpazZ8+23njjDWvr1q3W+vXrrfHjx1vp6enWxo0b4/UjGOHgwYO+fxcC1gMPPGB98skn1o4dOyzLsqwZM2ZYV199te/4b7/91mrYsKF12223WZs2bbIee+wxKzk52VqxYkW8fgRjhPpaPvjgg9ZLL71kffPNN9bnn39u/fa3v7WSkpKst956K14/gqsohGoxadIkC6jx5+233/YdA1hPP/207+PKykrrjjvusFq2bGl5vV7rwgsvtDZv3hz7kzfMvn37rCuuuMI67bTTrIyMDOuaa67xC8pt27b5vbY7d+60LrjgAisrK8vyer1W586drdtuu80qKSmJ008QP4888ojVtm1bKy0tzerfv7/1wQcf+D43ePBga9KkSX7H/9///Z91+umnW2lpaVaPHj2sV199NcZnbK5QXsupU6f6jm3ZsqU1atQo6+OPP47DWZul6hLuU/9UvXaTJk2yBg8eXOM5eXl5VlpamtWxY0e/f2cmslBfy3nz5lmdOnWy0tPTraysLGvIkCHWqlWr4nPyLuSxLMuK8RBKRERExAi6j5CIiIgkLIWQiIiIJCyFkIiIiCQshZCIiIgkLIWQiIiIJCyFkIiIiCQshZCIiIgkLIWQiIiIJCyFkIgYbfLkyb73CYulRYsW0aRJk6DH7d69mwkTJnD66aeTlJTk935vImI+hZCISD2UlZWRnZ3N7bffTu/eveN9OiISIoWQiDjKkCFD+M1vfsP06dPJysoiJyeHWbNm+R3j8Xj405/+xMiRI2nQoAEdO3bk+eef931+9erVeDweiouLfY9t2LABj8fD9u3bWb16Nddccw0lJSV4PB48Hk+N71Glffv2PPTQQ0ycOJHMzMwo/MQiEk0KIRFxnGeeeYZGjRqxdu1a7r33XubMmcPKlSv9jrnjjjsYO3Ysn376KVdeeSXjx49n06ZNtr7+oEGDWLBgARkZGezevZvdu3dz6623RuNHEZE4UwiJiOP06tWLmTNn0qVLFyZOnEi/fv0oKCjwO+byyy/n+uuv5/TTT+euu+6iX79+PPLII7a+flpaGpmZmXg8HnJycsjJyeG0006Lxo8iInGmEBIRx+nVq5ffx7m5uezZs8fvsYEDB9b42O5ESEQSh0JIRBwnNTXV72OPx0NlZaXt5yclnfxXn2VZvsdOnDgRmZMTEUdRCImIK33wwQc1Pu7evTsA2dnZwMlL36ts2LDB7/i0tDQqKiqie5IiEncp8T4BEZFoWLZsGf369eO8887jueee48MPP+TJJ58EoHPnzrRp04ZZs2Zxzz338PXXX3P//ff7Pb99+/YcOnSIgoICevfuTcOGDWnYsGGt36sqog4dOsQPP/zAhg0bSEtL44wzzojqzygi9aeJkIi40uzZs1m6dCm9evXi2Wef5a9//asvTFJTU/nrX//KV199Ra9evZg3bx5333233/MHDRrETTfdxLhx48jOzubee++t83v16dOHPn36sH79epYsWUKfPn0YNWpUVH8+EYkMj1V9kVxExAU8Hg8vvvhiXO5ILSLOoomQiIiIJCyFkIiIiCQsbZYWEdfRir+I2KWJkIiIiCQshZCIiIgkLIWQiIiIJCyFkIiIiCQshZCIiIgkLIWQiIiIJCyFkIiIiCQshZCIiIgkLIWQiIiIJKz/HyvSZUF4etGUAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Define XOR dataset\n", + "xor_inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])\n", + "xor_targets = np.array([0, 1, 1, 0])\n", + "\n", + "# Build neural network\n", + "network_shape = [2, 5, 1]\n", + "activation = Activations.TANH\n", + "output_activation = Activations.TANH\n", + "regularization = RegularizationFunctions.L2\n", + "input_ids = ['input1', 'input2']\n", + "learning_rate = 0.1\n", + "regularization_rate = 0.001\n", + "error_func = Errors.SQUARE\n", + "\n", + "network = build_network(network_shape, activation, output_activation, regularization, input_ids)\n", + "\n", + "# Train neural network\n", + "num_epochs = 10000\n", + "\n", + "for epoch in range(num_epochs):\n", + " for i in range(len(xor_inputs)):\n", + " inputs = xor_inputs[i]\n", + " target = xor_targets[i]\n", + " forward_prop(network, inputs)\n", + " back_prop(network, target, error_func)\n", + " update_weights(network, learning_rate, regularization_rate)\n", + "\n", + "# Plot decision boundary\n", + "def plot_decision_boundary():\n", + " h = 0.01\n", + " x_min, x_max = xor_inputs[:, 0].min() - 1, xor_inputs[:, 0].max() + 1\n", + " y_min, y_max = xor_inputs[:, 1].min() - 1, xor_inputs[:, 1].max() + 1\n", + " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", + "\n", + " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", + " Z = Z.reshape(xx.shape)\n", + "\n", + " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", + " plt.scatter(xor_inputs[:, 0], xor_inputs[:, 1], c=xor_targets, cmap=plt.cm.RdBu, edgecolors='k')\n", + " plt.xlabel('Input 1')\n", + " plt.ylabel('Input 2')\n", + " plt.title('XOR Decision Boundary')\n", + " plt.show()\n", + "\n", + "plot_decision_boundary()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 }, + "id": "C-uNluqrcql4", + "outputId": "91c8ad5a-bf47-437c-80c0-902ecfbfc259" + }, + "outputs": [ { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Define a function to shuffle an array\n", - "def shuffle(array):\n", - " counter = len(array)\n", - " while counter > 0:\n", - " index = np.random.randint(0, counter)\n", - " counter -= 1\n", - " array[counter], array[index] = array[index], array[counter]\n", - "\n", - "# Define a function to classify XOR-like data\n", - "def classify_xor_data(num_samples, noise):\n", - " def get_xor_label(point):\n", - " return 1 if point['x'] * point['y'] >= 0 else -1\n", - "\n", - " points = []\n", - " for i in range(num_samples):\n", - " x = np.random.uniform(-5, 5)\n", - " padding = 0.3\n", - " x += padding if x > 0 else -padding\n", - " y = np.random.uniform(-5, 5)\n", - " y += padding if y > 0 else -padding\n", - " noise_x = np.random.uniform(-5, 5) * noise\n", - " noise_y = np.random.uniform(-5, 5) * noise\n", - " label = get_xor_label({'x': x + noise_x, 'y': y + noise_y})\n", - " points.append({'x': x, 'y': y, 'label': label})\n", - "\n", - " return points\n", - "\n", - "# Define a function to train the network on the new dataset\n", - "def train_on_xor_data(network, xor_data, num_epochs, learning_rate, regularization_rate, error_func):\n", - " inputs = np.array([[point['x'], point['y']] for point in xor_data])\n", - " targets = np.array([point['label'] for point in xor_data])\n", - "\n", - " for epoch in range(num_epochs):\n", - " for i in range(len(inputs)):\n", - " input_data = inputs[i]\n", - " target = targets[i]\n", - " forward_prop(network, input_data)\n", - " back_prop(network, target, error_func)\n", - " update_weights(network, learning_rate, regularization_rate)\n", - "\n", - "# Define a function to plot the decision boundary\n", - "def plot_decision_boundary_after_training(network, xor_data):\n", - " h = 0.1\n", - " x_min, x_max = min([point['x'] for point in xor_data]) - 1, max([point['x'] for point in xor_data]) + 1\n", - " y_min, y_max = min([point['y'] for point in xor_data]) - 1, max([point['y'] for point in xor_data]) + 1\n", - " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", - "\n", - " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", - " Z = Z.reshape(xx.shape)\n", - "\n", - " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", - " plt.scatter([point['x'] for point in xor_data], [point['y'] for point in xor_data], c=[point['label'] for point in xor_data], cmap=plt.cm.RdBu, edgecolors='k')\n", - " plt.title('Decision Boundary After Training')\n", - " plt.xlabel('X-axis')\n", - " plt.ylabel('Y-axis')\n", - " plt.show()\n", - "\n", - "# Example usage\n", - "xor_data = classify_xor_data(500, 0.05)\n", - "\n", - "# Create and initialize the neural network\n", - "network_shape_xor = [2, 5, 1]\n", - "input_ids_xor = ['input1', 'input2']\n", - "activation = Activations.TANH\n", - "output_activation = Activations.TANH\n", - "regularization = RegularizationFunctions.L2\n", - "network_xor = build_network(network_shape_xor, activation, output_activation, regularization, input_ids_xor)\n", - "\n", - "# Train the network on the XOR-like dataset\n", - "num_epochs_xor = 10000\n", - "learning_rate_xor = 0.1\n", - "regularization_rate_xor = 0.001\n", - "error_func_xor = Errors.SQUARE\n", - "\n", - "train_on_xor_data(network_xor, xor_data, num_epochs_xor, learning_rate_xor, regularization_rate_xor, error_func_xor)\n", - "\n", - "# Plot the decision boundary after training\n", - "plot_decision_boundary_after_training(network_xor, xor_data)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 472 - }, - "id": "C-uNluqrcql4", - "outputId": "91c8ad5a-bf47-437c-80c0-902ecfbfc259" - }, - "execution_count": 9, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define a function to shuffle an array\n", + "def shuffle(array):\n", + " counter = len(array)\n", + " while counter > 0:\n", + " index = np.random.randint(0, counter)\n", + " counter -= 1\n", + " array[counter], array[index] = array[index], array[counter]\n", + "\n", + "# Define a function to classify XOR-like data\n", + "def classify_xor_data(num_samples, noise):\n", + " def get_xor_label(point):\n", + " return 1 if point['x'] * point['y'] >= 0 else -1\n", + "\n", + " points = []\n", + " for i in range(num_samples):\n", + " x = np.random.uniform(-5, 5)\n", + " padding = 0.3\n", + " x += padding if x > 0 else -padding\n", + " y = np.random.uniform(-5, 5)\n", + " y += padding if y > 0 else -padding\n", + " noise_x = np.random.uniform(-5, 5) * noise\n", + " noise_y = np.random.uniform(-5, 5) * noise\n", + " label = get_xor_label({'x': x + noise_x, 'y': y + noise_y})\n", + " points.append({'x': x, 'y': y, 'label': label})\n", + "\n", + " return points\n", + "\n", + "# Define a function to train the network on the new dataset\n", + "def train_on_xor_data(network, xor_data, num_epochs, learning_rate, regularization_rate, error_func):\n", + " inputs = np.array([[point['x'], point['y']] for point in xor_data])\n", + " targets = np.array([point['label'] for point in xor_data])\n", + "\n", + " for epoch in range(num_epochs):\n", + " for i in range(len(inputs)):\n", + " input_data = inputs[i]\n", + " target = targets[i]\n", + " forward_prop(network, input_data)\n", + " back_prop(network, target, error_func)\n", + " update_weights(network, learning_rate, regularization_rate)\n", + "\n", + "# Define a function to plot the decision boundary\n", + "def plot_decision_boundary_after_training(network, xor_data):\n", + " h = 0.1\n", + " x_min, x_max = min([point['x'] for point in xor_data]) - 1, max([point['x'] for point in xor_data]) + 1\n", + " y_min, y_max = min([point['y'] for point in xor_data]) - 1, max([point['y'] for point in xor_data]) + 1\n", + " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", + "\n", + " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", + " Z = Z.reshape(xx.shape)\n", + "\n", + " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", + " plt.scatter([point['x'] for point in xor_data], [point['y'] for point in xor_data], c=[point['label'] for point in xor_data], cmap=plt.cm.RdBu, edgecolors='k')\n", + " plt.title('Decision Boundary After Training')\n", + " plt.xlabel('X-axis')\n", + " plt.ylabel('Y-axis')\n", + " plt.show()\n", + "\n", + "# Example usage\n", + "xor_data = classify_xor_data(500, 0.05)\n", + "\n", + "# Create and initialize the neural network\n", + "network_shape_xor = [2, 5, 1]\n", + "input_ids_xor = ['input1', 'input2']\n", + "activation = Activations.TANH\n", + "output_activation = Activations.TANH\n", + "regularization = RegularizationFunctions.L2\n", + "network_xor = build_network(network_shape_xor, activation, output_activation, regularization, input_ids_xor)\n", + "\n", + "# Train the network on the XOR-like dataset\n", + "num_epochs_xor = 10000\n", + "learning_rate_xor = 0.1\n", + "regularization_rate_xor = 0.001\n", + "error_func_xor = Errors.SQUARE\n", + "\n", + "train_on_xor_data(network_xor, xor_data, num_epochs_xor, learning_rate_xor, regularization_rate_xor, error_func_xor)\n", + "\n", + "# Plot the decision boundary after training\n", + "plot_decision_boundary_after_training(network_xor, xor_data)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 }, + "id": "IwM91qJNSkdR", + "outputId": "49e9635f-e609-4500-fad2-e1ee421dfadf" + }, + "outputs": [ { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Define a function to classify circular-like data\n", - "def classify_circular_data(num_samples, noise):\n", - " points = []\n", - " radius = 5\n", - "\n", - " def get_circle_label(p, center):\n", - " return 1 if np.sqrt(p['x']**2 + p['y']**2) < (radius * 0.5) else -1\n", - "\n", - " # Generate positive points inside the circle.\n", - " for i in range(num_samples // 2):\n", - " r = np.random.uniform(0, radius * 0.5)\n", - " angle = np.random.uniform(0, 2 * np.pi)\n", - " x = r * np.sin(angle)\n", - " y = r * np.cos(angle)\n", - " noise_x = np.random.uniform(-radius, radius) * noise\n", - " noise_y = np.random.uniform(-radius, radius) * noise\n", - " label = get_circle_label({'x': x + noise_x, 'y': y + noise_y}, {'x': 0, 'y': 0})\n", - " points.append({'x': x, 'y': y, 'label': label})\n", - "\n", - " # Generate negative points outside the circle.\n", - " for i in range(num_samples // 2):\n", - " r = np.random.uniform(radius * 0.7, radius)\n", - " angle = np.random.uniform(0, 2 * np.pi)\n", - " x = r * np.sin(angle)\n", - " y = r * np.cos(angle)\n", - " noise_x = np.random.uniform(-radius, radius) * noise\n", - " noise_y = np.random.uniform(-radius, radius) * noise\n", - " label = get_circle_label({'x': x + noise_x, 'y': y + noise_y}, {'x': 0, 'y': 0})\n", - " points.append({'x': x, 'y': y, 'label': label})\n", - "\n", - " return points\n", - "\n", - "# Define a function to train the network on the new dataset\n", - "def train_on_circular_data(network, circular_data, num_epochs, learning_rate, regularization_rate, error_func):\n", - " inputs = np.array([[point['x'], point['y']] for point in circular_data])\n", - " targets = np.array([point['label'] for point in circular_data])\n", - "\n", - " for epoch in range(num_epochs):\n", - " for i in range(len(inputs)):\n", - " input_data = inputs[i]\n", - " target = targets[i]\n", - " forward_prop(network, input_data)\n", - " back_prop(network, target, error_func)\n", - " update_weights(network, learning_rate, regularization_rate)\n", - "\n", - "# Define a function to plot the decision boundary\n", - "def plot_decision_boundary_after_training(network, circular_data):\n", - " h = 0.1\n", - " x_min, x_max = min([point['x'] for point in circular_data]) - 1, max([point['x'] for point in circular_data]) + 1\n", - " y_min, y_max = min([point['y'] for point in circular_data]) - 1, max([point['y'] for point in circular_data]) + 1\n", - " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", - "\n", - " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", - " Z = Z.reshape(xx.shape)\n", - "\n", - " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", - " plt.scatter([point['x'] for point in circular_data], [point['y'] for point in circular_data], c=[point['label'] for point in circular_data], cmap=plt.cm.RdBu, edgecolors='k')\n", - " plt.title('Decision Boundary After Training')\n", - " plt.xlabel('X-axis')\n", - " plt.ylabel('Y-axis')\n", - " plt.show()\n", - "\n", - "# Example usage\n", - "circular_data = classify_circular_data(500, 0.05)\n", - "\n", - "# Create and initialize the neural network\n", - "network_shape_circular = [2, 5, 1]\n", - "input_ids_circular = ['input1', 'input2']\n", - "activation = Activations.TANH\n", - "output_activation = Activations.TANH\n", - "regularization = RegularizationFunctions.L2\n", - "network_circular = build_network(network_shape_circular, activation, output_activation, regularization, input_ids_circular)\n", - "\n", - "# Train the network on the circular-like dataset\n", - "num_epochs_circular = 10000\n", - "learning_rate_circular = 0.1\n", - "regularization_rate_circular = 0.001\n", - "error_func_circular = Errors.SQUARE\n", - "\n", - "train_on_circular_data(network_circular, circular_data, num_epochs_circular, learning_rate_circular, regularization_rate_circular, error_func_circular)\n", - "\n", - "# Plot the decision boundary after training\n", - "plot_decision_boundary_after_training(network_circular, circular_data)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 472 - }, - "id": "IwM91qJNSkdR", - "outputId": "49e9635f-e609-4500-fad2-e1ee421dfadf" - }, - "execution_count": 10, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define a function to classify circular-like data\n", + "def classify_circular_data(num_samples, noise):\n", + " points = []\n", + " radius = 5\n", + "\n", + " def get_circle_label(p, center):\n", + " return 1 if np.sqrt(p['x']**2 + p['y']**2) < (radius * 0.5) else -1\n", + "\n", + " # Generate positive points inside the circle.\n", + " for i in range(num_samples // 2):\n", + " r = np.random.uniform(0, radius * 0.5)\n", + " angle = np.random.uniform(0, 2 * np.pi)\n", + " x = r * np.sin(angle)\n", + " y = r * np.cos(angle)\n", + " noise_x = np.random.uniform(-radius, radius) * noise\n", + " noise_y = np.random.uniform(-radius, radius) * noise\n", + " label = get_circle_label({'x': x + noise_x, 'y': y + noise_y}, {'x': 0, 'y': 0})\n", + " points.append({'x': x, 'y': y, 'label': label})\n", + "\n", + " # Generate negative points outside the circle.\n", + " for i in range(num_samples // 2):\n", + " r = np.random.uniform(radius * 0.7, radius)\n", + " angle = np.random.uniform(0, 2 * np.pi)\n", + " x = r * np.sin(angle)\n", + " y = r * np.cos(angle)\n", + " noise_x = np.random.uniform(-radius, radius) * noise\n", + " noise_y = np.random.uniform(-radius, radius) * noise\n", + " label = get_circle_label({'x': x + noise_x, 'y': y + noise_y}, {'x': 0, 'y': 0})\n", + " points.append({'x': x, 'y': y, 'label': label})\n", + "\n", + " return points\n", + "\n", + "# Define a function to train the network on the new dataset\n", + "def train_on_circular_data(network, circular_data, num_epochs, learning_rate, regularization_rate, error_func):\n", + " inputs = np.array([[point['x'], point['y']] for point in circular_data])\n", + " targets = np.array([point['label'] for point in circular_data])\n", + "\n", + " for epoch in range(num_epochs):\n", + " for i in range(len(inputs)):\n", + " input_data = inputs[i]\n", + " target = targets[i]\n", + " forward_prop(network, input_data)\n", + " back_prop(network, target, error_func)\n", + " update_weights(network, learning_rate, regularization_rate)\n", + "\n", + "# Define a function to plot the decision boundary\n", + "def plot_decision_boundary_after_training(network, circular_data):\n", + " h = 0.1\n", + " x_min, x_max = min([point['x'] for point in circular_data]) - 1, max([point['x'] for point in circular_data]) + 1\n", + " y_min, y_max = min([point['y'] for point in circular_data]) - 1, max([point['y'] for point in circular_data]) + 1\n", + " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", + "\n", + " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", + " Z = Z.reshape(xx.shape)\n", + "\n", + " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", + " plt.scatter([point['x'] for point in circular_data], [point['y'] for point in circular_data], c=[point['label'] for point in circular_data], cmap=plt.cm.RdBu, edgecolors='k')\n", + " plt.title('Decision Boundary After Training')\n", + " plt.xlabel('X-axis')\n", + " plt.ylabel('Y-axis')\n", + " plt.show()\n", + "\n", + "# Example usage\n", + "circular_data = classify_circular_data(500, 0.05)\n", + "\n", + "# Create and initialize the neural network\n", + "network_shape_circular = [2, 5, 1]\n", + "input_ids_circular = ['input1', 'input2']\n", + "activation = Activations.TANH\n", + "output_activation = Activations.TANH\n", + "regularization = RegularizationFunctions.L2\n", + "network_circular = build_network(network_shape_circular, activation, output_activation, regularization, input_ids_circular)\n", + "\n", + "# Train the network on the circular-like dataset\n", + "num_epochs_circular = 10000\n", + "learning_rate_circular = 0.1\n", + "regularization_rate_circular = 0.001\n", + "error_func_circular = Errors.SQUARE\n", + "\n", + "train_on_circular_data(network_circular, circular_data, num_epochs_circular, learning_rate_circular, regularization_rate_circular, error_func_circular)\n", + "\n", + "# Plot the decision boundary after training\n", + "plot_decision_boundary_after_training(network_circular, circular_data)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 }, + "id": "3svLnC5UgncH", + "outputId": "e944e9d4-9990-4690-91c8-6ac202de009e" + }, + "outputs": [ { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Define a function to classify Gaussian-like data\n", - "def classify_gauss_data(num_samples, noise):\n", - " points = []\n", - "\n", - " label_scale = np.linspace(0, 2, 6)\n", - " gaussians = [\n", - " [-4, 2.5, 1],\n", - " [0, 2.5, -1],\n", - " [4, 2.5, 1],\n", - " [-4, -2.5, -1],\n", - " [0, -2.5, 1],\n", - " [4, -2.5, -1]\n", - " ]\n", - "\n", - " def get_label(x, y):\n", - " # Choose the one that is maximum in abs value.\n", - " label = 0\n", - " for cx, cy, sign in gaussians:\n", - " new_label = sign * label_scale[np.argmin([np.linalg.norm([x - cx, y - cy]) for cx, cy, _ in gaussians])]\n", - " if np.abs(new_label) > np.abs(label):\n", - " label = new_label\n", - " return 1 if label > 0 else -1\n", - "\n", - " radius = 6\n", - " for _ in range(num_samples):\n", - " x = np.random.uniform(-radius, radius)\n", - " y = np.random.uniform(-radius, radius)\n", - " noise_x = np.random.uniform(-radius, radius) * noise\n", - " noise_y = np.random.uniform(-radius, radius) * noise\n", - " label = get_label(x + noise_x, y + noise_y)\n", - " points.append({'x': x, 'y': y, 'label': label})\n", - "\n", - " return points\n", - "\n", - "# Define a function to train the network on the new dataset\n", - "def train_on_gauss_data(network, gauss_data, num_epochs, learning_rate, regularization_rate, error_func):\n", - " inputs = np.array([[point['x'], point['y']] for point in gauss_data])\n", - " targets = np.array([point['label'] for point in gauss_data])\n", - "\n", - " for epoch in range(num_epochs):\n", - " for i in range(len(inputs)):\n", - " input_data = inputs[i]\n", - " target = targets[i]\n", - " forward_prop(network, input_data)\n", - " back_prop(network, target, error_func)\n", - " update_weights(network, learning_rate, regularization_rate)\n", - "\n", - "# Define a function to plot the decision boundary\n", - "def plot_decision_boundary_after_training(network, gauss_data):\n", - " h = 0.1\n", - " x_min, x_max = min([point['x'] for point in gauss_data]) - 1, max([point['x'] for point in gauss_data]) + 1\n", - " y_min, y_max = min([point['y'] for point in gauss_data]) - 1, max([point['y'] for point in gauss_data]) + 1\n", - " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", - "\n", - " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", - " Z = Z.reshape(xx.shape)\n", - "\n", - " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", - " plt.scatter([point['x'] for point in gauss_data], [point['y'] for point in gauss_data], c=[point['label'] for point in gauss_data], cmap=plt.cm.RdBu, edgecolors='k')\n", - " plt.title('Decision Boundary After Training')\n", - " plt.xlabel('X-axis')\n", - " plt.ylabel('Y-axis')\n", - " plt.show()\n", - "\n", - "# Example usage\n", - "gauss_data = classify_gauss_data(500, 0.05)\n", - "\n", - "# Create and initialize the neural network\n", - "network_shape_gauss = [2, 5, 1]\n", - "input_ids_gauss = ['input1', 'input2']\n", - "activation = Activations.TANH\n", - "output_activation = Activations.TANH\n", - "regularization = RegularizationFunctions.L2\n", - "network_gauss = build_network(network_shape_gauss, activation, output_activation, regularization, input_ids_gauss)\n", - "\n", - "# Train the network on the Gaussian-like dataset\n", - "num_epochs_gauss = 10000\n", - "learning_rate_gauss = 0.1\n", - "regularization_rate_gauss = 0.001\n", - "error_func_gauss = Errors.SQUARE\n", - "\n", - "train_on_gauss_data(network_gauss, gauss_data, num_epochs_gauss, learning_rate_gauss, regularization_rate_gauss, error_func_gauss)\n", - "\n", - "# Plot the decision boundary after training\n", - "plot_decision_boundary_after_training(network_gauss, gauss_data)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 472 - }, - "id": "3svLnC5UgncH", - "outputId": "e944e9d4-9990-4690-91c8-6ac202de009e" - }, - "execution_count": 14, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAHHCAYAAABHp6kXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gc5bm373dm+2pXvfdmW+4V44YrvddACi0J6SQh5DuBdCAQck4S0klychISuqmmGGNwA9u4N9myrd5712q1bd7vj7VlC0m2bKvac3P5utDM7Myzs7M7v3nf5/k9Qkop0dHR0dHR0dEZ4ygjHYCOjo6Ojo6OzmCgixodHR0dHR2d8wJd1Ojo6Ojo6OicF+iiRkdHR0dHR+e8QBc1Ojo6Ojo6OucFuqjR0dHR0dHROS/QRY2Ojo6Ojo7OeYEuanR0dHR0dHTOC3RRo6Ojo6Ojo3NeoIsaHZ0zpKSkBCEE//rXv87odUuWLGHJkiVDEtP5TlpaGnffffdIh3HW7Nixg/nz52O32xFCsHfv3pEOaUg42+/GcYQQ/OxnPxvUmHQuLHRRozPm+Ne//oUQovufxWIhISGByy+/nN///ve0t7ePdIijig0bNvQ4X0IIIiIiuPjii3nuuedGOrwxT15eXvd12NLS0mu9z+fj1ltvpampid/+9rf85z//ITU1lT//+c9nffM/U372s5/1ugb6+qeLbp2xjmGkA9DROVseeeQR0tPT8fl81NTUsGHDBr7zne/wm9/8hlWrVjF16tQhOW5qaiputxuj0XhGr3v//feHJJ6Bcv/99zNnzhwAGhsbeemll/j85z9PS0sL3/jGN0Y0trHMs88+S1xcHM3Nzbzyyit86Utf6rG+sLCQ0tJS/v73v/dY9+c//5moqKhhGYG66aabyMrK6v67o6ODr33ta9x4443cdNNN3ctjY2PP6Thn+904jtvtxmDQb0s6Z49+9eiMWa688kpmz57d/fdDDz3EunXruOaaa7juuuvIy8vDarUO+nGPP5WfKSaTadBjORMWLVrELbfc0v331772NTIyMnj++ecvKFHT1dWFyWRCUc59oFpKyfPPP89nP/tZiouLee6553qJmrq6OgDCwsLO+Xinw+/3o2lar2tt6tSpPUR+Q0MDX/va15g6dSqf//zn+93fmZ6rs/1uHOdcXqujA/r0k855xrJly/jxj39MaWkpzz77bI91hw8f5pZbbiEiIgKLxcLs2bNZtWpVr320tLTw3e9+l7S0NMxmM0lJSdx55500NDQAfecN1NTUcM8995CUlITZbCY+Pp7rr7+ekpKS7m36yqmpq6vji1/8IrGxsVgsFqZNm8YzzzzTY5vjx/uf//kf/va3v5GZmYnZbGbOnDns2LHjrM+VyWQiPDy815Ox3+/n0Ucf7T5OWloaDz/8MB6Pp8d2/eU/fDr/5fh04ebNm3nggQeIjo7Gbrdz4403Ul9f3+O1Ukoee+wxkpKSsNlsLF26lIMHD/Y6RlNTEw8++CBTpkwhJCQEp9PJlVdeyb59+3psd3zq7cUXX+RHP/oRiYmJ2Gw29u7dixCC3/72t732vWXLFoQQvPDCC6c7hWzevJmSkhJuv/12br/9djZt2kRFRUX3+rvvvpvFixcDcOutt3ZP8aSlpXHw4EE2btzY59RPS0sL3/nOd0hOTsZsNpOVlcWTTz6Jpmnd25x8XTz11FPdn9ehQ4dOG3df9Heu2traBny++/pu3H333YSEhFBZWckNN9xASEgI0dHRPPjggwQCgR6v//Q1dXzarKCggLvvvpuwsDBCQ0O555576Ozs7PFat9vN/fffT1RUFA6Hg+uuu47Kyko9T+cCQx+p0Tnv+MIXvsDDDz/M+++/z5e//GUADh48yIIFC0hMTOQHP/gBdrudl19+mRtuuIFXX32VG2+8EQgOyy9atIi8vDzuvfdeZs6cSUNDA6tWraKiooKoqKg+j3nzzTdz8OBBvvWtb5GWlkZdXR1r166lrKyMtLS0Pl/jdrtZsmQJBQUFfPOb3yQ9PZ2VK1dy991309LSwre//e0e2z///PO0t7fzla98BSEEv/rVr7jpppsoKioa0HB/e3t7tzBramri+eefJzc3l3/84x89tvvSl77EM888wy233ML3vvc9tm3bxhNPPEFeXh6vv/76aY/TH9/61rcIDw/npz/9KSUlJTz11FN885vf5KWXXure5ic/+QmPPfYYV111FVdddRW7d+/msssuw+v19thXUVERb7zxBrfeeivp6enU1tby17/+lcWLF3Po0CESEhJ6bP/oo49iMpl48MEH8Xg8TJgwgQULFvDcc8/x3e9+t8e2zz33HA6Hg+uvv/607+m5554jMzOTOXPmMHnyZGw2Gy+88ALf//73AfjKV75CYmIijz/+ePf0X2xsLC6Xi29961uEhITwwx/+EDgx9dPZ2cnixYuprKzkK1/5CikpKWzZsoWHHnqI6upqnnrqqR4x/POf/6Srq4v77rsPs9lMRETEwD6Qfvj0uTKZTBw6dOiMzvenCQQCXH755cydO5f/+Z//4YMPPuDXv/41mZmZfO1rXzttTLfddhvp6ek88cQT7N69m//93/8lJiaGJ598snubu+++m5dffpkvfOELXHzxxWzcuJGrr776nM6FzhhE6uiMMf75z39KQO7YsaPfbUJDQ+WMGTO6/16+fLmcMmWK7Orq6l6maZqcP3++zM7O7l72k5/8RALytdde67VPTdOklFIWFxdLQP7zn/+UUkrZ3NwsAfnf//3fp4x78eLFcvHixd1/P/XUUxKQzz77bPcyr9cr582bJ0NCQmRbW1uP40VGRsqmpqbubd98800JyLfeeuuUx12/fr0Eev1TFEX+4he/6LHt3r17JSC/9KUv9Vj+4IMPSkCuW7euexkgf/rTn/Y6Xmpqqrzrrru6/z7+ea1YsaL7HEop5Xe/+12pqqpsaWmRUkpZV1cnTSaTvPrqq3ts9/DDD0ugxz67urpkIBDocdzi4mJpNpvlI4880uu9Z2RkyM7Ozh7b//Wvf5WAzMvL617m9XplVFRUj2P1h9frlZGRkfKHP/xh97LPfvazctq0aT22Ox7DypUreyyfNGlSj+vhOI8++qi02+3y6NGjPZb/4Ac/kKqqyrKysu73C0in0ynr6upOG+/J1NfX9/r8TnWuBnq+P/3dkFLKu+66SwI9tpNSyhkzZshZs2b1WPbpmH76059KQN577709trvxxhtlZGRk99+7du2SgPzOd77TY7u777673+tU5/xEn37SOS8JCQnproJqampi3bp13Hbbbd2jFQ0NDTQ2NnL55ZeTn59PZWUlAK+++irTpk3rHrk5GSFEn8eyWq2YTCY2bNhAc3PzgGN89913iYuL44477uheZjQauf/+++no6GDjxo09tv/MZz5DeHh499+LFi0CgqMWA+EnP/kJa9euZe3atbz00kvccccd/PCHP+R3v/tdj5gAHnjggR6v/d73vgfAO++8M+D392nuu+++Hudw0aJFBAIBSktLAfjggw/wer1861vf6rHdd77znV77MpvN3XkegUCAxsZGQkJCGD9+PLt37+61/V133dUrv+q2227DYrH0qABbs2YNDQ0Np8wzOc7q1atpbGzs8fndcccd7Nu3r88ps4GycuVKFi1aRHh4ePe12tDQwIoVKwgEAmzatKnH9jfffDPR0dFnfbxP09e5OtPz3Rdf/epXe/y9aNGiAV+7fb22sbGRtrY2AN577z0Avv71r/fY7lvf+taA9q9z/qCLGp3zko6ODhwOBwAFBQVIKfnxj39MdHR0j38//elPgRPJnIWFhUyePPmMjmU2m3nyySdZvXo1sbGxXHLJJfzqV7+ipqbmlK8rLS0lOzu7VxJmTk5O9/qTSUlJ6fH3cYEzUCE1ZcoUVqxYwYoVK7jtttt49tlnueaaa/jBD37QndtSWlqKoig9KmUA4uLiCAsL6xXTmXC6+I/vOzs7u8d20dHRPcQcgKZp/Pa3vyU7Oxuz2UxUVBTR0dHs37+f1tbWXsdOT0/vtSwsLIxrr72W559/vnvZc889R2JiIsuWLTvt+3n22WdJT0/HbDZTUFBAQUEBmZmZ2Gy2cyqVz8/P57333ut1ra5YsQI4ca2e6r2dC33t70zP96exWCy9hFd4ePiAr92BXDuKovSK/dPXsc75j55To3PeUVFRQWtra/cP2vHkygcffJDLL7+8z9ec64/fd77zHa699lreeOMN1qxZw49//GOeeOIJ1q1bx4wZM85p38dRVbXP5VLKs97n8uXLefvtt9m+fXuP/IP+RqUGwqeTP48zmPE//vjj/PjHP+bee+/l0UcfJSIiAkVR+M53vtMjmfY4/VXB3XnnnaxcuZItW7YwZcoUVq1axde//vXTVvu0tbXx1ltv0dXV1UuEQTD/6Re/+MVZnUdN07j00kv5f//v//W5fty4cT3+HuwKv772d6bn+9P099kPlKG49nXOT3RRo3Pe8Z///AegW8BkZGQAwamd40+7/ZGZmUlubu5ZHTczM5Pvfe97fO973yM/P5/p06fz61//ulcV1nFSU1PZv38/mqb1uIkePny4e/1Q4/f7geDI1vFjappGfn5+94gRQG1tLS0tLT1iCg8P72U25/V6qa6uPqtYju87Pz+/+zMDqK+v7/VE/8orr7B06dJeSc4tLS39JnP3xRVXXEF0dDTPPfccc+fOpbOzky984Qunfd1rr71GV1cXf/nLX3od78iRI/zoRz9i8+bNLFy4sN999Cd4MjMz6ejoOO21OpwM1vkeKo5ft8XFxT1EZkFBwQhGpTMS6NNPOucV69at49FHHyU9PZ3Pfe5zAMTExLBkyRL++te/9nnDPbms+Oabb2bfvn19Vvn091TY2dlJV1dXj2WZmZk4HI5eZdAnc9VVV1FTU9Oj+sfv9/OHP/yBkJCQ7lLgoeTtt98GYNq0ad0xAb0qbH7zm98A9BjNyczM7JXf8be//a3fkZrTsWLFCoxGI3/4wx96nOtPxwLBJ/dPfx4rV67szo0aKAaDgTvuuIOXX36Zf/3rX0yZMmVApo3PPvssGRkZfPWrX+WWW27p8e/BBx8kJCTktFNQdru9Twfi2267ja1bt7JmzZpe61paWrqF6HAyWOd7qDj+APPnP/+5x/I//OEPIxGOzgiij9TojFlWr17N4cOH8fv91NbWsm7dOtauXUtqaiqrVq3qYeT1pz/9iYULFzJlyhS+/OUvk5GRQW1tLVu3bqWioqLbb+P73/8+r7zyCrfeeiv33nsvs2bNoqmpiVWrVvH000933/xP5ujRoyxfvpzbbruNiRMnYjAYeP3116mtreX222/vN/777ruPv/71r9x9993s2rWLtLQ0XnnlFTZv3sxTTz3VnRM0WHz00Ufd4uv4e9q4cSO33347EyZMAILi5q677uJvf/sbLS0tLF68mO3bt/PMM89www03sHTp0u79felLX+KrX/0qN998M5deein79u1jzZo1Z/3kfty75IknnuCaa67hqquuYs+ePaxevbrXPq+55hoeeeQR7rnnHubPn8+BAwd47rnneozwDJQ777yT3//+96xfv75HiXB/VFVVsX79eu6///4+15vNZi6//HJWrlzJ73//+373M2vWLP7yl7/w2GOPkZWVRUxMDMuWLeP73/8+q1at4pprruHuu+9m1qxZuFwuDhw4wCuvvEJJScmwj44M5vkeCmbNmsXNN9/MU089RWNjY3dJ99GjR4Fzm07VGVvookZnzPKTn/wECJrIRUREMGXKFJ566inuueeeXoJg4sSJ7Ny5k5///Of861//orGxkZiYGGbMmNG9HwhWTX300Uf89Kc/5fXXX+eZZ54hJiaG5cuXk5SU1GccycnJ3HHHHXz44Yf85z//wWAwMGHCBF5++WVuvvnmfuO3Wq1s2LCBH/zgBzzzzDO0tbUxfvx4/vnPfw6Jdf7JN1iTyURGRga/+MUvuj1VjvO///u/ZGRk8K9//YvXX3+duLg4Hnrooe6k6uN8+ctfpri4mH/84x+89957LFq0iLVr17J8+fKzjvGxxx7DYrHw9NNPs379eubOncv777/fy2/k4YcfxuVy8fzzz/PSSy8xc+ZM3nnnHX7wgx+c8TFnzZrFpEmTyMvL6x7dOxUvvvgimqZx7bXX9rvNtddey6uvvsrq1atxOp19bvOTn/yE0tJSfvWrX9He3s7ixYtZtmwZNpuNjRs38vjjj7Ny5Ur+/e9/43Q6GTduHD//+c8JDQ094/d4rgzm+R4q/v3vfxMXF8cLL7zA66+/zooVK3jppZcYP3687lR8ASGknmmlo6NzgTNjxgwiIiL48MMPRzoUnUFk7969zJgxg2effXZAglVn7KPn1Ojo6FzQ7Ny5k71793LnnXeOdCg654Db7e617KmnnkJRFC655JIRiEhnJNCnn3R0dC5IcnNz2bVrF7/+9a+Jj4/nM5/5zEiHpHMO/OpXv2LXrl0sXboUg8HA6tWrWb16Nffddx/JyckjHZ7OMKGP1Ojo6FyQvPLKK9xzzz34fD5eeOEFPe9ijDN//nyampp49NFH+d73vsfRo0f52c9+xp/+9KeRDk1nGNFzanR0dHR0dHTOC/SRGh0dHR0dHZ3zAl3U6Ojo6Ojo6JwXXFCJwpqmUVVVhcPh0M2YdHR0dHR0xghSStrb20lISDhlb7YLStRUVVXpWfA6Ojo6OjpjlPLy8n6NUOECEzXHXWafnnsFVoNxhKPRuRBIjugiLLunlXzkuGgs8UFxrabmIJwR1BKCUE0AbClrxWhQeHV7GWHW4Ff0ow37SImwDW/wOjo6OqMEv9fNx3/79mnbx1xQoub4lJPVYMSmixqdYSDEGMBhNvVY5rRasNitAKiOEITDQScOhCG4nS1Ew2hQMFrtmKzB61Q1WanskKRG2of3Dejo6OiMIk6XOqInCuvojBKk39vvuiXLZw5jJDo6OjpjE13U6OiMAuJoH+kQdHR0dMY8uqjR0dHR0dHROS/QRY2OzhBS2mih+Uhhr+VdlWUDen2z2zfYIeno6Oict+iiRkdnmGk4XNv9/4HiXGRbY5/b3T4vbZgi0tHR0Tk/0EWNjo6Ojo6OznmBLmp0dHR0dHR0zgt0UaOjo6Ojo6NzXqCLGh2dUYjPr/VatmT5TEobXSMQjY6Ojs7YQBc1OjqjjEVpYSMdgo6Ojs6YRBc1OjqjiFO5Cuvo6OjonBpd1OjojBJ0V2EdHR2dc0MXNTo6Ojo6OjrnBbqo0dEZARoO1w7IVfj2eWm6q7COjo7OANFFjY7OMNBXq4ST6c9VWEdHR0dn4OiiRkdniClttJxyfaA4d5gi0dHR0Tm/0UWNjo6Ojo6OznnBmBI1lZWVfP7znycyMhKr1cqUKVPYuXPnSIc1qglISa3bRV2XC03KkQ5HZxDQDfguLKTU8HvdaFpgpEPR0Rn1GEY6gIHS3NzMggULWLp0KatXryY6Opr8/HzCw8NHOrRRSUBK3q0o4J2KAhq9bgCizVauTsrmysRMFCFGOEKds2HJ8pls+HD3SIehMwx43e2Ubn+bygMb8HtcCNVI3Pi5pF10HfbIhJEO77yms7mGin0f0FSWh0QSkZxD0rQV2CPiRzo0ndMwZkTNk08+SXJyMv/85z+7l6Wnp49gRKMXTUr+eHgnm+vKycbORcQAUOhx8Uzhfoo7WvjG+FkIXdjQ5HFT2N6MIgTjnJE4jKaRDgkIugp/VNKC0TCmBlN1BgmPq4UdLzyKp6MZEZGNaotCetqpKdhLXf5OZt76EKHxmYN2PF+Xi9ojn9DV3ojJ6iR2/FzMIRfmA2PtkW3kvvtnUIzgTAagc/9GyvesZfKVXyUuZ/4IR6hzKsaMqFm1ahWXX345t956Kxs3biQxMZGvf/3rfPnLX+73NR6PB4/H0/13W1vbcIQ64uxurOHjunKWE0UW9u7lKVhJxML62jIWxCQxIyJuBKMcWdp9Xv43fy+f1FeiEZyWMwqFpXGp3Jk5FbOqjlhs0u9FGEaHuBpp/N4uAj4PRmsIijJyn8lwc3TDc3g621HHXYcwO7qXy+iJBIreJ/edPzP/i/+NEOcuest2ryF/04tILYAw2ZE+N0c3Pk/q7KvIWnTboBxjrOBqqg4KmtBU1OQFCCV4i5San0D5FnJXP01ITCohkYkjHKlOf4wZUVNUVMRf/vIXHnjgAR5++GF27NjB/fffj8lk4q677urzNU888QQ///nPhznSkWdtdRGxmHsImuNkY+cA7aytKr5gRU1XwM/P922i1uViHmGkY0MD8qWLddUl1LpdPDR1AeowjGR1VZZhSUzp/juOdmpwnOIVFwbNFYcp2baKxpIDgMRgCSFxyhLS516HwWwb6fCGFG9nG3VHtyPiZvUQNABCNaLEz8Zd8C5NZYeITJ18Tseqyt3I0fX/QYnKQY2dijDakH4PWkMepTveRjEYyZx/8zkdY7QhpaStupDao9sJ+NzYIhKIn7gQk9VBxb4PQDH2EDQAQjGgJi8g0FFNxZ73mbDinhF8BzqnYsyIGk3TmD17No8//jgAM2bMIDc3l6effrpfUfPQQw/xwAMPdP/d1tZGcnLysMQ7klS62onD3Oc6gSAeM5Wu0WvJ7wn48WoadoNxSHJ/1teUUu5q4ybiieTEiMhMQonGxLstdexprGF21NDOnzccriVqQuyQHuN0SClpLs+j5vAWfO4OLI4I7FFJGEw2rKHROOMyhn2asi5/B/vf+gPCGo6SdDHCaEPrqKFs9/s0FO9j9md+hNHSW7CPFaSUtFbl42qsRDVZiEyb2uP9uJqqkFoA1dn3aICwxyBUIx31ZeckaqSmUbjlNURYOmrSxSf2bzCjxk0HzU/pjndInXXleSMk/Z5O9q36Hc1lBxEmO8JgRXNvouCjl5mw/G4aSw9CaEoPQXMcoaiI0JTgNjqjljEjauLj45k4cWKPZTk5Obz66qv9vsZsNmM2931zP5+xGoy4PP5+17sIYDOMvvNyoLmO18uOcKClHoAIo4XLEjO4Njkb0yBOPayrLiYNWw9Bc5xkrMRgZl1NyZCLmk8j2xoRzshhO57f28W+N5+iuSwXYQlFSgHeNpBa9zb2yCRyVtxDWNL4YYvp4Oq/ooSmoKQuPjH1EZqCjMims+Bdij95g3FLPjcs8Qw2rdWFHHzvb3Q2VXYvUwwmUmZeTuaCWxGKgnps6lH6PfQpJzV/UPSc4xRla3UBnvZG1Oy5fa5XoifirztAQ9He8yaPZP9bf6ClqgA1fRnCmYIQAsXfRaBqF3nv/x2zIwphOpVgFsDZVZF6O9upObyFrrZ6jBYHsRMuxhY2sg815yNjRtQsWLCAI0eO9Fh29OhRUlNTRyii0cv8mCReLj6ECz/2T33EHfgpxc3nYgYvyXAw2FhTyp+O7CIaM4uIwIJCua+LlSV57Guq5UfTFg6asGn0dDEBa7/rIzDS2OUelGOdTPORQsLH933eA8W5qOn9P3U3u32EW42DGs+h9/+XlsojqOkrkJ42ZNV2RHgWaswkMIUgO+vprNnHrpVPMOszPyQsIXtQj98XtYe3EvB5MCTM6ZXLIazhiMhxVB7YQNbC25BIWqsK0AI+QqKSsTgihjy+c6GjoZxdKx9HGp2omZcjQuLA34XWcJiS7W/j97iZsOJuQmJSMYWE42s8ihLS+6anNRUAkqiM6ecUj/9YVaQw9nMTN1hBiO7txjptNUU0lR5ATVuKEnriviEMFtTk+QS8bciAG9lWHswv+tTvjZQasq2c8HGzz/jYZbvfI3/ji0gpUcwOpK+Tws0rSZiyhAnL70ZRh/9WHPB5qD26HXdLLQazjdhxF2FxRg17HIPNmBE13/3ud5k/fz6PP/44t912G9u3b+dvf/sbf/vb30Y6tFHH8vg03q0oYLWvnkVEEHNsRKIWDxtpwqyqTAgdvhGB09Hq7eLpo3sYh53FRCKOPZ9mYGccdt5pq+OdigJuTBmc0YJwk4Vmf9/9lAJImvCSeMqntTOntNFCamTXWb329nlpvLi1ZFDj6Wypo+7INtSkeYiQOAKlG1CiJqAmzeveRjgSEfY4AgXvkr/pRebc/uNBjaEvOhorUayhCFNIn+uFI4FAXS4FH79MVe4m/J5jnj1CITpzJhOW3zVqq3aKtryGVMxBQaMeE6hGG2r8TFDNVOz7kJTZV2ILiyX9ous4su4ZAmYnSswkhGII3lRbStGqdxI3Yf4534COjxJIV12f51t21oOUWM+T0YS6gp0IoxURmtJrnRACJWIc3rJNIASByk+C341jwlpKDa1yG9LrInnGpWd03OpDH3N0/bPBvKW46QiDBan50RqPUpW7CcVgYsKyOwflPQ6Umrwt5H3wTwJeN8IUgvR3kb/pBRKnLGX8sjtHRGQNFmMm8jlz5vD666/z0EMP8cgjj5Cens5TTz3F5z43NoehhxKn0cxPpy3iydytvNFVQwgGfGh40IJuiwF4eM8GLoqM5/6ci0a00gdgQ00ZSMnFhHcLmuPEYyELG2sqi1gYnURFZzsGRWGcM5Imj5sSVysmRWFiaBRWw8BGMpbEpfJcUS6t+Agl+Jo2fOyhjXw6CABNLXX85cgubk6dQMwYzt/oj8bifSAEIiIT2VIMmh8lZmqv7YSiokRPorV0I+7WOqyhMUMal2o0I/0epNT6rrrxBYVh2a73UKJyMKRlg2pCa6ugoWw/O154hIs+9wgm2+hKtvZ73dQV7EJJmH1C0JyEEjUeWbuXmrwtZMy7kaTpK/C4minZtgrZcBAs4eDtQHo7iMqcSc6lXzznmGzhcYQlTaC1bj/CmYRQT0xnSS2AVrMHizOaiJSJp9jL2CHg8yAMlv6ruYzBdiZZi26n4KMXCbRXHRNAAtlaivS5yLn0XhwxA58dkPJY3lJoKkri3O78NKEYUKMnguanct+HpM+9HrM99Fzf4oBoKN5H7rt/QYSlY8iciTA7kAEfWtNRKg9sACDn0nuHJZahYMyIGoBrrrmGa665ZqTDGBMk2Z08ddFlvFF6mBdL8wAIQSUZKx40SuhkR2M1v8rdyo+nLRzRWMs624jGhIW+xVUUJo54m/nG9jXds9kGBP6T5rYtisqViZl8Jn0i6mlKUJfFp7G2qoi3umq5iDDCMfIOdSjADEKJwEST9LKttpIdDdU8OmMxiaPsJnmuaAEfCBWEivS5QTX3m0sgLMGRD09Hy5CLmpjs2ZRsexPZWoYIS+uxTkpJoD6YpKkkzUWNyulep0ZNQDoS8RxdRdmud8la9JkhjfNM8Xe5QGoIc983LqEYEGYH3s6g7YQQgqyFt5EweTFVuRvpam3AaA0hLmc+zrjMQUvenrD8Lna88AiBo28hoicirJHgaUVryIOuFibe/P/Om5LukMgkNPf7KN6OHiNT0t+F1piP1pSPUFRsYbFc9LlHqdj7AU1lhwBJePZMkmdchjM27YyO2VFfTldrXXB0ro/PTIkcj79mN/WFu0iauuwc3+HAKNz8KiIkFjX1khMiSzWiRk8CCZUH1pM+97oxOxU1pkSNzpmhCsGmunIALiKM6Ti7R0I6CfAedRxoqaO4o4X0kLARi9OsqHQJDSllr5EaNwF20YoVhdmEkXJMlB2mg1zaGY+dGYRyWOvgjfKjtPo8fG38rFMez24w8vMZi/nL4V2sb65FAE4M3EBct7BKx8Yk6WCVv5a/HNnFYzOWDM2bB5rbXQQ0jRgpeyWG+vzakBjwOWLSQPMhXbUIgxUCXqTX1aewkV3NAJjsYYMex6dxxqYTkTqF5ootwZGkY8mc0t9FoHoXuBsRRhtKZO+pSGF2IMIzgzk3o0zUGK0hwSkkdxM4k3qtlwEvmqcNS0g4rqYqGor3If0+HLHpZC64ZciERUhUMhd99ucUfPwy9YXbu5PEw1Mmkbngm8OSRzVcxE6Yx9ENz6FV7URJvQQhFLSmAgLlWwAJ1kgghP2rniIkOoUZN32fiZd/CSk1QJyVkDyRt9R39ZgwmBGKkYD37KamzxR3az3ttUWoaUv7EVnj0Gp2U3t0O6mzrxqWmAYbXdScxzR7u6h2d5CAmRn0fEK0obKcKF6kildK8/j+pHn97GXomRMVz9rqYqrxkEDPjtZ7aSWA5FYScBy7XEOABUQQioHNNDMVJ3MJx4mBdTWlXJWYRWrIqYdyw00WHp66gF2N1fwydysXEdZrpMiCymxCWdvWQJmrlZRBHB6WUvLWoaM889wr7C+rBiA9KYFvfe0+bvriNzAYTrgKDwXhyTlYw+PpqtqBkroUFBWt7kCP0l44Ng1Rf5DQhHHYwoZ2lOY4U6/9VrDstngdwhSCMFjQ3M0IReCISaPD7ev3Ji+skfga8tAC/lGVF6AaLcROuJjagj3IyHEIQ8/rXKs7CAE/TeWHKfj4ZVAMCEVF+j1YQmOZeu03ccYOjYO6PTKBadd/B29nO15XC0ZryKjNSzoXDCYLE6+4jwNv/xGZ/zbYYpENh4LJ8YlzgrkuUiJddbjKNrLjhUcwOyJorToKCMISx5M66wqis0790HQytrBYEAKtowbVEtZrvexsQAa82MKHp9LS7+kM/k9/o7KqEWEw4/eM3eTw82NcUadP2r0eJPRpwgcQipEojFR1dgxvYJ9iWngsGfYw1okGquhCHptWcuHnIB1MIKRb0JxMDg6sKBwhGP84QrALlfU1pac8XrvPw1vl+fzx8E7eqSgAIKmfaqjjy8sH2dfnqU3b+N6q92kpb2EZkawgCrWyle/96Ofc/7WvoGlav69dsnzmOTe1FEIw5epvoAQ60QreQdii0Rry8Jd9jHQ3B+fY26sIFK2BrmayL7n9nI53JhjMNmbe8gPm3PEzkqcsIj5zCtmLb2fRV/6AMz4TvO3IfpqzSk8bqsnaq3JlNJAx7yZURSFQsBqtqRDp60R2NuIv34xWuxezM5LmisOoKQsxTP4s6qQ7ULOvxuPX2PXy43S21A5pfCabg5Do5PNS0BwndtxFzLrtYSJiEpENeWAJR01Z2C0yhRDBijN7HF1t9bS1tqIkzEVJmENrSxP73vwtRVteG/DxzCHhRGXMQNbnBqd5T0JqAQLVuzCFhBOZ3jufbSiwOCKDYrmjrs/10tOO9LqwDtMDzFAweh5ldAadMPOxL2rfbhfd66wj/ESrCMEPps7nlwe28FZHLWHCiBmFOhkUZVF9+MkAqAgiMB1L7Q3+HSaNNJ9iKHdzXTl/OrwLTUqiMdFO0M/HTQBTHxrffWzf5kG8SeZW1/HnLTu4iDBmyBOjP5nSTjouVr3+GpdfeRXX3zq0QsIZm8bczz9G2c53qD60mQAgmwvxN+V3b2OLSCDnqh8QljhuSGP5NEIIQhOyCE3I6rE8PmcBlfs+RLaW9s658Xchm/NJmLRwVPY1s4XFMOeOH3P4g3/RXLape7nR6iRm2nIq932ImnEZykmme8Ieg8i4jMDh1ynd+S4554GTrauxkvqiPWgBP+aQCJAaUgvgjMsYstGokwlPmoAzLoP1v/siStT4XteK1lGDbC5ESZiNGjPlxIroiQRq91G09TUi0qYMeGpu/NLPs/35n+PPfwsROQFhiwJvO1rDYfC0Mumm7w9aC5CA30tjyQF87g6sodGEJ0/oMapptIYQkz2HuuIDyPD0HtNiUkoC1btQTVZix100KPGMBLqoOY9xGs04DCYK/S4m0Ltksx0/9Xi5JmbCCETXk3CThSdmLuVAcx07GqvxagGusDl5seQQLVrf5dcaklZ8pGLr/rtF+JlusvS5fV5LA7/L20EWduYRjhUVDwGepZI8OriY3k+oeXRgUVQmhUcP2nt9fs8BnIqRaZqz17oM7CQqLv79f/8YclEDwRvthBX3MH753cHcAU2jqfwQvq4OrKExhMZnjSqBEJqQTVTmLBqKP0J6O1AiskE1Itsr0ap3oaoqqXOuHukw+8UekcCs2x6ms7kGV1M1qslMWMI48tb+H8ISjnD07r4tVBMiIouavC1jWtT4PZ3kvvsXGor2gDAAEmSgxzaOuEwmX/nVIe+GLQN+QCLU3iakWkMemENRonv7RikxU5FNBVTs/WDAosYaGsNFn/s5hZtfofbwJ2iaHxBEpk0hY/79hMZnnXYfp0NKSfmetRRtefWEzQFgcUYzYcXdRKVP616WdcntNFccxpf/NiJqEsIeAz4XWkMesqOWnKu/jmocfeasA0UXNaOAgJSAPG3VztlwS9oE/lmwn0O0k0NI96iNF431NGBWVJbGpw36cc8GRQimRcQyLeKEL0Z1VwcfV5cxVTp75bwU0UkHAbKPTa8dxYVL+lkc29uHAuCN8iNEYmIJkSjHzoMZlak42UMrIahMwNFdWXWYdvbTxk1JEwZlNKu00QJHCjla10icZuqO4dMkaGaOHj58zsc7E4QQCKGCovb4ARxtCCGYcs03OPLhv6k6uAmtagfHXV5DYtKYfNXXsI6Bqg1beBy28BO91/xdLjDa+hWQwuQg4HX3X+o+ypFSsveN39JaXYiSvAjZXIDsrA9O7URkgWJAtlXQUb2LnS89xsVfeGxIp8FUkxWzIxJveyVKeEbPWN1NKM7kPj8LIQTCkUhbbfEZHc/qjGLylV9lwvK78bpaMFjsmKyDV1FZtms1+RufR4kcjyF9EpgdyM56PDV72fv6r5l5yw+6S/OtzijmfPZnFGx6ibr87WhaUFg6YjPIvOzBUf39Hwi6qBlBdjfW8Fb5UQ62NiCBjJAwrk7KYlFM31+os+HKhEyK21vYUFvGQdpJPVY9VIALhOBHUxae8Q3bqwX4pL6SvU21+KVGpiOcpXGpOIdA3d+QPJ4tdRW87a9jDqEkY8V7rPppBy2kYcWGwk5a2EMrl8Qkk+4I67Ufn6axp6mWeYT3EhOzCKWLAJtpZiethAkjbfhxywCzIuIoam/ms5veQALjnRFcnZTFnKjeT9QDxWYy0kz/OTNuAlj7+MEbClfhsYhqMDHx8i+RufAWGksOoAV8OGJSccYOf5+qwcIaFg1leX062QJorjrMjsgxKWgAmssO0lKRh5pxGQjQOqpRM1agOE/04hOhKQhbFP4jb1C2e82Q5nEJIUievoKCj19Bi8hGCTmpua9QkIG+R4chWKmmDNAT69MYTBYMpsFtJOz3uinc/GrQ3O/kHl72WETGpQQK3iN/04vM/fwj3eusziimXPMNfO676GpvxGAO9no7H9BFzQjxZvlRni3KJQ4z84lABUo63Pzh8E6OtDbypezpg/IDLYTg6+NnMT86iXcrCynuaMGkqFwZk83lCRlEW86sUV2Fq41f7N9Mg9dNDGYMCLbXV/Fy8SHunziHuVF9N+E7W6ItNh6Zvpg/5O3gPVf9ifdFsANLCW5KcGMSClclZvG5floN+KWGhD69cBQEi4ikHg8Wm4W0kDDafB7afV52NdUQhYmZOFEQFLe286vWT7gxeRyfzTi7ZoKXj8/kkdIK2vDhpOePoxeNIrWLz93whR7Lh8JVeKxjtoeRMGnRSIcxKCRMXkLZrvfQGg71zOMgOHIgW4pJvPj6EYru3Kk58gnCEhZ0hC77CCxhCEfv0nZhtCHCMqk6+NGQJ6enzLyChpIDtBS+jxaWhuJMRPo94O9CthQhEy/qZZQo/R5oKyN6zujxS6sv2IXm92D41HUDIISCEj2J9pJ1uJqqsEf0fBgzWkMwWvt27x6r6KJmBCjtaOXZolxm4GQOYd1TQjk4yKOd96uLmR4Re06jAScjhGBGZBwzIs/tCaEr4OfR/R8jvBq3kUD4sRuymwAfyyZ+e2g7T8xcOuieN8l2J0/OWkZBezOlrlaMisq08BjafV5KOoKOwpPDo7GfosGfRVGJNlup8Li7p6t6vDcCNONnjs3JtoZKfFpQBE3DydyTPqOpONlHK6+XH2VKeAxTws+8SuD6yRN4estO1rgaWCIjiD7WUb0VHx8pzShmI3d/8ctnvN/RgMfVSk3eZtyt9UGzuAnzhzw/4nwgJCqJ1NlXUbrzXaS7GSVyHEIxorWVIxsOYY+IJ2Xm5SMd5lkTnF6zBx/U/F0Is7P/hzaLE1/j0E+/KgYjM2/6PmW711C+7wM8pYWAICw5h7aqfAIl61BTFnUn00qvi0DZJhTVQNK04THKGwheV2sw76pf88yw4Hadbb1ETX/4ulx4OpowWsZeeb8uakaA96uLsAsDs2RYr8qkHBwcwcWayqJBEzWDxea6cpq8XdxOQnd7AQArKsuI4mWqeKeigG9OOPOGb6dDCEG2M4Js54mmhWEmC8n23sm2/b3+8oRMXig+yHi6evjhSCSf0IyG5JOGSrKxI4FKuriI3p/RVJzk08nqysKzEjUhZhP//uyNfOmlVbzWWkOEakJFoT7QRaQjlLef+wcpY7BRa8mOtyn8eCUSgWJxIr0uire+TvykS8i59N5R5RtzLmh+X7DpptmGUAZvOijrkjuwOKMo2f42noLVQNA3JH7iArIvuQOD+cxGVUcT1rBYKD6A1PxgsiPbq4Jmm58SNtLvQWsqRDUGe2HFjr8Y4xC2KVEMRtIuuobUOVcT8HlQVAOKaqCp/BD73vgt/kMrEfZYQCJdtRhMNqbf+OCoutGbQ8KRAS/S044w9562lu7G7u1OR2dzDQUfr6Quf0e3EWNYUg6ZC24mPGnkC0oGwvnxKzPGKG5vIVGaUftJFE3GwtGOluENagDsbKwmEUsPQXMcFUGWtLOjoWoEIhsYVyVlsqephndb68jE1t0y4ggdNOAlzmKHLj9LiOQ1akjB2mcyr0CQjIXCtuazjiU9Mpw1X/0C6wuK2d3SCFYbcydmcdtd92CLSaTmpG37cxUubXSRGjk6+lJV5W6kYNOLKNGTUWOnIgzmYNO+pgKqD32MajQzYfldIx3mOdFeV0rxJ29SV7ATpIbBbCdxymJSL7p2UJI+hRAkz7iMpGkr6GgoRwv4sUfED0jMeFyteDqaMFkdo9LePmHyYkp3vI1WfxAlIptA41FkUwEiMlhBJKVEqzuAVrMXpIZmtHD4w2c4sv5ZMhfcTOrsq4c0X0oIgeGkqsmI5Iksuu93VB38mJaKPBCC8KTLiZ+4YNSJy+isWagmK4HafajJC3qcJ6n50epzj5lnnroxaWdzDduf/xkBKYI9ymzR4GmjtSGP3SufYNoND4yJJGJd1IwARkWl8xSJoh40jKPQPMynaX16uRzHjILvFKZxI41RUfnh1AW8U1HAmsoijnobAJgWHsOdcen8Om8by4hCIFAJ5rf0hx+Jqpzbj6xBUbh0XCZ3TJiPJTFYsaVaepaj9+cqvGT5TDZ8uPucjj9YSE2jcOvriLB01MQ53cuFYkCNmgABH5X715F+8fWYh6HVwlDQVHaIPa/9NxhtKPGzEKYQNFcdZXs+oK5wD3Nu/zEm28BGDU+HUJQBN03saKykYNOLNBTvhWOGhKEJ48haeCvhyTmnfvEwYo+IJ/3i6yn+5E0ITUOExBMo34zsakaJyEZrKUar3YcSPRklZjLCaEX63Gh1ByjY9CKqwXzG3bHPFYPZRsrMy0iZedmwHE9qGvWFu6jYv57O5lqMFjvxOfNJmHzJKYWUajQzbvFnyVv7DwKaDyV6EsLsRLrq0er2g6eNcUu+ddrjH1n/HwJSQc2++oTjtT0GEZ5BoPhDDq35Owvv+92geeoMFbqoGQFmR8bzbGsuLvzYP/UR+NEopJNLokbf9ENaSBhrmhvwo2HoQ9yU4yb9NO0JRhqjonJDyniuTx5HZ8CPUVEwKSrV7qArse3Y+wrDSD4uugj0Si72o5GPi0xLRK/9DybS70WcIk9otNBeX4qnrQE1a06f65XIcfird9FQuIfEqUvxuTtoLM1F83sJiU454yaBw40W8JP77p/BFo2avhyhHPvOhqUho8bTlf8u+ZteZNIV9w1rXB0N5ex44RE0xYSaOA9hi0R62mhrOMSulU8w/YYHCIlKomLfhzSW5iKlJDxxHEnTVww4t2IwyZh/C2ZHJCXb3qKrI5j0r9UfQqs/CAiUyPE9RbHRipp4ETLgpWjrayROXXreTGF+Gi3gZ/9bf6ChcFfQcNEWjcfj4ujG5ynbvYZZn/nhKa0KEqcuRTEYKfh4JZ78d7qXh0SnMuHar57WC6ervZHG4v2oyfN7tfAQQkGNm4n36Coai/cRnTnz3N7sEHN+XiGjnCVxqbxRdoQ1/nqWE9U9ndNJgI004hOSKxMzRzjK3lwan86q8qNso4X5hPfINSnARQVd3J94dhVBw40QAvtJZZkRJisWRaVK85B4rGwc4H2Cn9Fx8dlFgA004kWjZQj7o8TRTg1jozP48WZ8wtB3qwlUE6gGfJ5Ojqx/lop9H/YomXXEZjDpyq8QEjm4lXODRUPRnqC3yPjFJwTNMYQ5FBE9kZrDWxm/9PPDOjVxZN1/0BQLavZVCDUofoUtChGWRqD4Q3JXP43f2xUsA3cmg1Bw5X5E+d4PmHj5l0iYdMmwxQrB71zS1GUkTlmCq6kaze/FHBJOVe5GCj9eiRI9sc/XqdET8R3Jp7k8j8i03hU+oxlXUxWV+9fRVluKajQRnTmTuJwFPaa6AIo/eYOGoj2o6ctRQk/4bElPO56iNexf9Tsu+twjp5yCi5+4kLgJ82mpOtrtKBwSnTKgaTt3Sx0gj+UP9UbYIhGqkc7mmj7XjyZ0UTMCOIwmfjRtIY/v38yLviriMKMgqKYLk1D4r8nzSLCNvhtarNXOl7Kn8/f8vdTiIRs7BgSluCnDzaKYZBbEJJ9+R6MQs6qyOC6VjVWlZGPHjUYCFurx8jyVxGNBAaroQiAYh51yn2ekwx4V2MLjjjXtq0a19B6pk50NEPDRWLyP5orDKLHTUCPHgWpGtlfSUbObnS8+ytzPPzoqvTI6GiqCpcbWvkfmhCMRrXo3nS11wzbq1NlSR3P5IdSUS7oFTXc8QkGNm4H/6FvB0aXMy7tLk6UWIFCxlUNr/o4jOnXA01yDiRBKDwHbnQNk7Cc/zBQsOT7ZKXcsULprNfkbnkcYzBASB4FWGov/RdHWN5h16w+wHzsHmt9H+d4PUCLH9xA0EOw8ryReTHvRWlqrC07rYiwU5awSeo+LcelzIfr6Dvu7kAE/BlM/Dy6jiLHp5HQekB4Sxh/nXs5Xs2cQ4rDRpgaQBHM13qsqJK+lYaRD7JPLEjL4ydSFJIWHs5VmNtGEsBv5yriZfHPCbJQxan4G8Jm0HCIsVt6khk4C+JDcQSIXE44RgYJgNmF8lkQUBCGDODXUVVk2oO2a3f2bgo0UwaZ9M5F1uUhfZ491UvOjVe/CaAsN3oST5qHGTQ+KBEVFCU1BzbyCQECjZMfbQxKflBpdbQ24W+uRZ5HzpRpMweoSzd/3Bv7gSJVqHL6pQndrsCGhsPddfSdsUSAUlNDUHl4rQlGDUwxGO2W71wxLrKfDFhocHZCd/TRZdAUbeVpPk+g6mmgo3kf+hudQYiahTrwNQ9pSDJmXY8i5GZ8Gu1/9FVogeD25mqrwd3UgwvvueyUciQjVREt53pDFGxKdjDUsNtgqoY9msVrDYYSinFGH8pFCH6kZQYyKyqHWBgram0nBygwc+KRGfmMTP23cxNfGz2RpXNpIh9mL4/4smpTIIWrvMBI4jGYem7mYlaWH+aCqmDbppwUfU3AyhRNJoC78FNLJdXFn3uTxeKuE8PEnphcbDtcSNeHED7Zsa0Q4I3u9digN+LSAn476MqTUsEcm9RoePx3jl36eHS/8HN/RtxCR4xG2aKS3DdlwBHwdhGfOoL44FxHRe25fGCyIiGyqD33MhGV3DVqZtJSSin0fULpzNV3HRIDJHk7KjEtJmXP1gBMeo7Nmkb/pBWRzESKy92euNR7FGh6HLXz4/HiOlzlLb0ffZby+TpAawtj7yVoIBRGaRlNp7pDHORCc8ZnYIhJx1+wNuuCeNMUnNT9azT5ColJwxKSNXJBnSMmOdxD2GJT42T2mf4TZgZqyGM+RN6jL30HchHkjGOUJhFDInH8zue/+Ga1iK8qxBw8Z8KE1Hkar3UvKzCsGLRl+KNFFzQjycV05m+rKWU4UWScZwk3FyUc08fSRPUwOizlj19/hIjgqM3ZHZvrCYTRzb9Y07kibyI/2bGRNZz3zCCMDOwpQThdbacZuNHF5QsZp93emBIpzUftxRR4KpKZRsuMtynatweduA0AxWkicfAmZC28bsLixhkZz0Wd/TtHW16jO24IW8IEQRKVPJ2P+TZTtXA1mZ782/8ISRsDnIeD3DMoQt5SSwx/+i8p9HyLCM1DTp4IQ+FpKKNi8ktaaYqZe+60BCShbeBwx4y6ivnA7qKagnb9QkAEvWu1+ZGspGVd+dVhbNDhiUrGExuBpOIQIievdabo+D1AQzn6mg4Xo84l8JBBCMPGyL7Jr5RME8t9BiZ6IsIQj3c1oDQcRPhc5139jzLTA0AJ+WsoPoSTN67t/lDUcYYuisWQ/cRPmYY9IwGAJQWsugT5yWmR7JTLgJWyIfWLicubj93RydOPz+JvyUUx2NJ8bZICk6ZeSfckdQ3r8wUIXNSPI6spCkrH0EDQQ9EGZRziFdPJhdTG3p08aoQhP0On3saaqiA+rimnwunEYTCyOS+WqxEwizOd+E2r0dJLbXI+GJMsRMWBTvaHCajDys+mL+EPeTtY117KRJhTAhyTdHsp3J84l7AxHM0YbUkoOrfkb1Yc2o0SNR01ahBAqWmsZFfvX01pTzKzbHkId4DSbxRnJxMu/zPhld+J1t2M027rn6s0h4eBp7be3kXQ3oZqsg9YduKXyCJX7PkRJmhcsKz+G4kxCcyZTX7COuvztxI6/+BR7OcGkK+5j/1t/pLF4PcIUgjDakV1NSC1A1qLPED9x4aDEPVCEUMhacAu57/6ZQPkW1LhpCFNI0Lyu4VCwlPdYg9JPI6VEtpURntp3Yu5IEJY4jtm3/4iCj16muezj7uURqVPIWnQbzti+p2aGC7+nk5q8LbRUFyCEIDJ1CjHZc/rsASWPmdYJcYqRQEVFHmskqRiMJE9fQfG2VQhHfK9EYa1yG47YdEIH2BX8XEiavoK4nPnUHN5KV1sDRquD2PFzsTh6jxyPVnRRM4KUdLRwEWF9rjOiEI+ZolFgwtfu8/CTPZuocXeQiY0swmj1+XmvvIANNaU8Mv2Ss05sdvt9/O3oXrbUl/dwhZkcGsU3JswmagRHqRxGMw9PXUCFq40DLfUEpEa2I4JxzohR89R4LgZ8LZVHgsZ4KYuCnZKPodoi0ZyJtBW8S3XuJpKmrzij/apGM9ZPiZP4SYso3fkOWuMR1E9VuUhfJ7Ipn8Qplwxaw8aKfR8iLGEokeN7rVPCUtFC4ijf++GARY1qtDD9xu/RVlNE7ZGt+LpcWMNiSZh0CRbH0Jb290dcznz8vi6Obgg+WQuTDenrQghInLqMyv3rCZRvRU1Z0H1epZRo1TuRXa0kD5P/ykAJjctk1q0P0dXehLezFbM9bFQ49zaV5rJv1e8IeLtQ7NFIqVF98CPMIRHMuPn7hET1HA1TDSbskUl0tpWjRPYWItLXiXTV44w7cf7TL76B9vpyGgo/RLPHImxRSJ8L2VqGxRHJ1GvvP+ffnM7mGkp3rab28CcEfF1Yw+JImracpGPl4McxmG0kTVt+TscaSXRRM4IYhIJP9p+46EPDMAryVf5ZsJ9Gdyc3Ed/d7wlgBqG87avld3k7+OXMpWf8pQtIjV/mbqWgtYl5RJCNHRVBCZ1sb23hp3s38ctZy3AMYwJmXyTZnSSN8MhRX5yrAV/l/vXBJoPhve0DFHsMmjOZigPrz1jU9EVIVBKJ05ZTuW8deDtQTqp+0mr3YTRbSLvo2nM+znFcjVVBv49+rklhj8PVXHJG+xRCEBqfSWj86LFbSJq6jLgJ86g7uh13WwMmq5PY8RdhsoUSnjSB3NVPE3BVI0LTglNOrWVITxvjlnz+tJU0I4XFETFiQvHTdDbXsPeN3yCt0RiyFnT3V5JdLXhLN7J75ZPMv/dXvUr5k2dexuG1/4fWXIQSfmKaWmoBAuVbUAymHqN7impg2vXfpr4gaL7nbqnFYLYTv+SzJEw6tfneQGipPMruV3+FREGEZyGMNrpcNRzd8Cx1+TuYcdP3hzXRfSjRRc0IMisynoMNtUyXob3s+FvxUYWH6yNHthlgq9fDlvoKLiKsh6ABsKEylzDe66inoL25R1+mgbCrsYZDrQ1cQyyJJ/ViysJOLGZe9lSxtqqIm1LHRs+RoeK4q3BfrRLOhc6WOrBG9n/jt0Xjbhy8iosJy+/CbA+jdOe7+OsPdi+PSJ1CzqX3DupTucFsRbb1XwIsfZ0YjGN7+vA4BpOVhMmLey2Py5mPPSqJ8j3v01iaC1ISnj6Z5BmXEZpwajM2nSDle95HChU1fVmPBGZhCUNNX44371WqD31M8oyeo16JU5bQUn6YmsMb0ZryEY4E8HuRLUXg72Lq9d/p1dNKCIWY7DnEZPdtYnm2BI39fo80h6GmrzhRDRedg+iooaVoLcXb3iRr4a2DetyRQhc1I8g1SVlsra9kPY0sJBzzMefaFnx8QAMRJgsLYpJGNMYyVysBKUml77yZZKwoQOFZiJqNtWXEYO4haI7jwEAGNjbUlF7QomYoXYVN1hBoP0WvLm/HoDYTFEIhY96NpM6+ipbKIwT8PkKikk7bk+ZsiB03l5b1/0Z62hDmnqNs0t8FrcXEzbl60I872nBEpzDxsi+NdBhjltr8HYiwjF6mi0Awt8qRSF3+zl6iRgiFSVd9laiM6ZTv/YCO+lyEwUjMuNmkzLqCkKjh+12vL9h5zDzyhh7l/QBKSBwyIpuKfR+SMe/G88Kxeey/gzFMljOC+3Pm8MfDOymRncRhxo+kBg8RJgs/mroQ8whfZMenv/z0XSkRQKIR7GN0prR6uwg9xSUYjpEKX8cZ7/d8YahdheNy5tNQ9Ce0zgYUW08LdulzI1uKiZ9z1aAfVzWaiUybOuj7PZn4SQsp2fkO3uIPUJLmB0uFhUB2NhCo2IpqNI/pvIG+kFLSUnmE1qp8hFCISJ08IuZ65xOa3xd0xO4P1UTA37d3lBAKcTnzicuZP0TRDYy2mmKE2Ymw9j0SKkJT8Dfk0dXWEDTSHOPoomaEWRCTxMSwKNZXl1DQ3oxBUbg5Io550UmY1ZFvHJbpDMeuGjkS6GA+vUdi8nEhgGnhZ/60HWm2cYQOJLJHy4XjNOIlYgw4WA4WXZVl3Y0th4OY7DmERKfgKv4AEuYiwlIBgeyoRqvajsFsHZR8mpHAYLIy69aH2ffGb3AVrEaYQoI5JZ52zM4opl//0KhIQh0sXE1V7F/1e1yNFQjVFCzX3vQCYUk5TLnmm5jto7sn22jFEZ1CS3MVML3XOik1cNXgTBlYsvlIIVQDaH6klH1PNR9rWXI+jNKALmpGBeEmy6idYjEpKlcnZbGyNI8ITIzHjkAgkVTQFewDFZ10Vl46y+JS2VJfQQlu0un5+ia8FOHmCwljo5fUufJpA77hQFENzLzlBxx45880l26AckO3/4o9Kpmp13xrzHbVBrCFxXDxXY/TVHqQprKDICWhieOIypg+6jsNnwkeVys7X/oFfqkEWyKExAMS2VpGa+U2dr/yS+Z+7pE+y491Tk3S9BU0v/V7tKZClIgTCeJSSrSafUivi8RRPuIXlT6Nkm1vItsrEc7e015acwG2iATMY6hs+1TookbntNyUOoG6LhcbasvYI1qJlCba8NOIl0mhUXxl3Iyz2u+U8BhmR8bxYWMt03Ay7lj1UzGd7KGNJJuD5fEj608xEhw34DuVq3C4dXBuUCabk1m3/oCO+nIaSw8gNY3QhCzCEsePmrL1c0EIhci0KWOuEeKZULH3A/yeTtQJNyGMxx8OBCIsDWFy4Dq6itqj24bdS+d8ICZ7DvGTLqH64Ca01pKgh4ymobUUITtqyFx4G47o4RtdPRtCE7JxxmfRXrEF0pai2IL91aQWQKvLRbaWkXbFfefF9x10UaMzAFQh+Pr4WVyWkMGHNSU0dHWSZDRzSWwKU8NjzrrfkyIED0ycy3NFB/mgupjdWmtwOYJ50Yl8MXsa1vNkSPRk+mqVMNKERCcTEn36ZqTutga8rhZM9jCszqjTbq8z9FTnbYbQ9JMEzQmELRIREk/N4a26qDkLhBBMvPxLhCWOo2z3GlzHjAFDE8aRuvwOYkZxLyQpJVILHCsX/w67X3kS19G30ezRYLBCZwPS10n6xTcQP3HRSIc7aJx/dwydIUEIQbYz4owrnE6HUVG5O2sqt6blkN/WREBqZDjCCR/jbr2jBSk1mkpzaSo7BFISljiOqIwZA+6v5HN3UJ23hZbKw7RWF+Jpb+xeF5Y0gexLbic0Xi8PHkn8nk5E+CmqaUx2vO4LN+H+XBFCIXHKEhKnLCHg8yCEMqqn8lyNlZTseJvaI9vQ/F5MIeEkTV3GrNseprk8j7oj2/B73dgyJpA4ddmwVmINB7qo0RkV2A1GpkeMnS68Y4HjxmGdTVXdibKlO9/B4oxm+g0PnHZkpnL/eg6v+3fQzt3kAL8bABESjwjPoLXxCDtf+gWzbvkBYUm9nXt1hgdraAwdrvo+10kpobMBW0zOMEd1fjJYbTyGipaKI+x+9UmkYkJETUI12fG56ij65E3q8ncw67YfEjvuopEOc0gZebtaHZ1hQErJvqZafntoGw/tWs8TB7awua4Cv9a/o/NYobSxt8mc39PJrpVP4O50oWZdhZpzC4acW1DHXYvHr7Fr5eN4XK397rO+YBd5a/8BYekYJt6GMecmDJPvQE25BNlZj2yvRM26CiwR5H3wz1HTHPFCJGnqUmRbBVpHba91srkQ2dVC4tSlIxCZznCiaQH2v/NHpCUCdfwNqHHTUSKyMSQvwJB9Na6mGgo3vzLSYQ45uqjROe/xaxq/PriNxw5s5kh9PWqHl+qmZp7K286P9mygw+cd6RBPy6K0MHz+3gJsyfKZfW5fdfAjPB3NqOmXooTEdicBKrYo1PRL8Xm7qNz3Yb/HK/rkDYQjATVpPsIYLKsXQkGJyERNvBjZUgLedpS46bgaK2irKTz3N6lzVsRPXEhY4jgCRe8TqNqF1tmA1lFLoHwrgbKPiZu4kPAkfaTmfCXg81JfsIv8Dc/h7WhGTbiol8mesEYgoiZSlbsJv7drhCIdHvTppzFKQErKXK14AwHibSE4R/mw6EjyUskhdjRWcylRpGPr9sSpxcN7HfX86chO/mvyyBpkDTa1R7YhnEkIc2/zPmG0IkLTqDnyCRnzb+q1vqutkfbaYtS0vvt5ifAMqNyG1lKKcqw5pbulTs+tGSEUg5EZN/8/CjevpHL/BgJ1+wEw2pykL7yFtDnXnjeVLaMRv6eTygMbqDr4Ed7ONiwhESROWUz8pEuGtJ+SlJKyXasp+uQNAp7O4ELVjLD1XZotnIkEavfibq0b9RVb54IuasYYUkrW1ZTwaulh6j3BHAdVCOZFJXJn1tQhT7D1aQE+rC5hbVUxtV0ubKqBBbHJXJWYdVZeNUONJ+BnTWURU3CQQU/L/1jMXEwYGxprqO7sIN4WMkJR9k8c7dT4HWfcKsHvdSMM/bc4EEYrfldjn+sCvmNPcoa+jQ+FooLBDJoPvB3dx8tb+380luQi0QhPHE/yjEt1oTNMqEYz45Z8nswFt9DRWIkQKiFRSeeNodpoxdPRzM6XHsPd2oAITUU40+lwN3H4w2eozN3IrFsfOudmlP1Rsv0tCj9+GSVqAob0iWgtxcESban13e0+EByRVtTRm+Q8GOhX/BjjtbIjvFhyiExszCUWKwoVsos99dUcbWvi8ZlLCTUNzaiNJ+Dnsf2bOdLWSBo2ZuKkXfPzQUUx66tL+em0RaQ7wobk2GdLYXsLbs1PNn3f4DOxsZFGclvqRoWoGSxXYXtEAp3lR/t1EZWuWuwRfTdLNTsiUQwmZEc1hPRO3paeNvB2ICxhBOoPohotHP7wmeAIkDMVhEJt0QFq8jYzbunnSZl5xTm/H52BoRothMb1tAoI+LxU5W6k8sAG3G31GC0hxE9cQPL0SzHZRl/3+bFE7uqn6erswDDhhh49xmRnAx1F73Nk3b+ZdOVXB/24PncHRVtfR4mZjJoQbICphKai1exBtpQER1M/hdaUjzUs7rxohXAq9JyaMUR9VycvlRxiBk5WEE0iFiIwMRUn1xNHm6eL18uODNnxXy7Jo7CtieuI5TKimYqTBURwO/HYAwq/PvgJgVGWMKodi0ftow0DBD1xBIyKuBsOn0j0DBTnItv6HkkZCEnTliHdzcim/F7rtJYSZEdtv72PDCYLcTnzkQ15QQFzElJqBKp2gmpCc9Uhm/IJ+L2IsHTUnFtQk+aiJs5BnXATSsxkjq5/lpaq3jHoDA9+r5tdL/+CI+v/jcsLMiIHjxpG8fa3+eTfP6SzuWakQxw22mpLOLTm72z553+x9ZmHyN/0Iu62hrPen6uxkuaygyjxs3s1TRW2KETMFGoOb8Xb2dbPHs6e2vztSM2PEn3CcV1YwxHOJAIVW9HaKruT96XmJ1CzF9lSQtpF5/9UpC5qxhAba0sxojCd3n1cHBgYTwjra0oIyMGv6PEEAnxQXcxEHMR9qqu2GZX5hFPr6WRfU+8KjJEkNSQUo1AoprPP9aW40YDxfbj3DiWljRaajwxdcm148kQSpiwlUL4Zf+lGtNZytLYK/GUfEyjdQMy4i4jJnt3v67MW3obFHkog/x0C1bvQ2irRGo/iP/IWsrUUAl5EazFhSTkI1YSaPL/HkLcQIvhjbwmlfPf7Q/Y+dU5N/sYXaK8vR82+BkP6MtTYqRhSFmCYcBO+gMaBd/50QVSule1+j+3P/ojqo7voUhx0ahbK9qxl6/99n4bifWe1z5aqAiDYELIvlNA0pBagrbb4rOPuD6+rFWGwdifxH0dNuQRhiSBQ9D7+vFfxF64hcGglWs0e0ufdSMLkSwY9ltGGLmrGEHVdnYQLI6Z+PrYYzHQG/Lj66Rp7LtR2ddAZ8JNG33kWMZiwCZWC9qZBP/a54DCaWBSbzD7aqMfTY10HfrbRwjhHxKibNjsVt89Lo9l96s9YCEHOpfcwftmdmLUOAsUfEChai8nbSNbCzzDl6m/2Pe9+DJPNyZzP/pTEyYsQTUeDlTXlm7HZbSRMXkLOZV/mkq/+kYDfC45EhNJ7JlsIgXCm0Fxx+Jzfs86Z4/d0UnXwI0T0pF5d2IXRhpIwh/ba4vO+cq254jBH1z+LEj0ZNedm1KR5GFIWoubcirTHsX/V7/C4Ws54v90jHv2KQu3YdoN/mzWHhCN9bqSv58OaMJhRs65AiZkM3nYiomJInXkp8+/9HzLn33zej9KAnlMzpggxmOjAj4ZE6WM6pR0fqhBYhiA5UD32xfTT9xdYEpzCUYfgC3yu3JU5ldKOVl7vqCENG1GYaMVHEZ2EmSx8e+KckQ5xSBBCIXnGZSRNX0FXexNIicUROWA3YZPNyYTld5G9+A58nW2oJitGS8/cpOBVeKonfUk/M3+nxe/tomLvWir2r6errQGD2UZ8znxSZl+lt2gYAO31ZciADzU0tc/1wpEIikprdcF5ndBdtmsNwhqOkjC7x01dqEbUlEX4D71M5YENZFx8wxntNzw5BxDIliJEZG/zSa2pCMVgIjR+8NuhxI67iCPr/o1Wux816VNdwmUA2V5FeMpkZtz04KAfe7Qz+u5AOv2yICYJlwxQSG+zNR8aebiYG5WIaQg6EMdZQ4gyWTnax7EBynDjQRtVrsBSSnKb63ml9DCZjnAuiU1BsxnIU110WAS3pOXwq9nLiLH0XyV0PiCEgtUZhTU0ekCCRkqJpgW6/1YNJizOqF6CBiAidRK0VSADvUeOpNSQraVEpkw645h9XS52vvgoBZtfwaM4UBIvQnOkUXFgE9v+/UPa68vOeJ8XGt0jBDLQ9wZSgpQIcf50LO+L5vJDiNC0vu0JDGaEI4HmskNnvF9raDTR2bPRqnehuep6rNPaKtDqc0mcsmRIqp8MZhtZi25Da8jDX7oJ2dmA9HehtZYTKHgP4esg+5LPDPpxxwL6SM0YItMRzkWR8WxqrMGDxnhCMCCox8s2WnArAW5KGRq7elUIrksZx/8V7CMGExNxdI8W1ePhY5qY6Iwi0xF+xvvWpDzrppj90eRx82TuVoo6WnAIA0YUmqSXEIORBybNZUp4zKAeb7jw+TWMhqF5FmmrLaZkx9vUF+xCBvxYw2JJmrac5OmX9tvrJmnqMkp3riZQtik4n3+sXFRqAbTKT5DeDpJnXn7GseRvehFXcw2G7GsQ1hP9xmTsVAJFa9j/1h+Yf8+vLojh9LPFEZuGwWxHay5EtfUe2ZItJSC1oDA9jzl9xpAYwDZ9M/GyL7H71Sdpz38HLSQOzE5wNyE7G4hMm0rWJbef5Z5PT8rMK1AMJgo3v4bv6Fvdy0Ni0shZ8U2cselDduzRjC5qxhj351zE3/P3sKm2jK20YETgQSPKZOVHExeSGtI7iXiwuCIhg+rODlZXFbJftBMjTXQQoBYPqXYn35008J4idV0uVpXn81FtGZ0BPxFGC8sT0rg6KQv7GXqyfBq/pvHY/o9pdru5hhgSpAWBoBUfm/1NPHFgC0/OWkayfWyVsy5KC+OjkpYh2Xd94W72r/odmEIQMdNQDFa6OqrJ3/QiDUV7mX7Tg6h9fC4WZxRTr72f/W/9nsChl8GZDEKB9gqkv4uJl33pjH9c/Z5Oqg99jIie3EPQQPDJWkm4CHfBaprLDxFxFqNAFwqqwUTyjMso3vYGwhaNCEvvFoGaqx6tajuR6dOwRySMcKRDS3jSBBqripGx03qJYBnwItsriZh43Vnt22ixM+f2n1CXv5PqQx/h6WjBEp9K4pQ7iUqfPuCp3rMlaeoyEiZdQkvlEfyeTqyhMThi+p5uvFAYs6Lml7/8JQ899BDf/va3eeqpp0Y6nGHDrKp8c8JsPpM2kV2N1Xi0ACk2J1MjYlGH+KlVCMG92dNYHJfCB9XFVHd2EGkw8tmYZOZEJWAc4Be4pKOFn+/9CC2gMQ47oRio83l5o/QIW+oqeGTG4nNySN7RWE15Zzs3EUc0J/YTipHLiOZlqnmrPJ+vT5h11scYTSxZPpMNH+4mNfLsptH8Xje57/wZHImoqUuC5nqAEpmNFjmO5qL3Kd35br85B9GZM5h/739TsfcDGktzQfoJm7SQ5OmXYo888xumq7EqmAvi7LvhprDHIlQTbTXFuqg5DenzbqCzuZraIxsRdfvBEgHeDqSrFkdsOpOv/NpIhzjkpMy6nIbCx9FqdqPEzewWNlLzEyj7GEWIc+qNpagG4iZcTNyEi0+/8RCgqAb9e3ASY1LU7Nixg7/+9a9MnTp1pEM5Z+q6XOxsCIqTJJuDmZFxA0q2jbbYuCJx8BPQBkKmI/ysppkgmK/xu0M7sAQE1xCPmeANdAIwBSdvuWt5pmA/38o5++TdbfWVxGDuIWiOY0AhW9r5pL5yzIias3UVHig1eVsI+D0YEi/uFjTHUULi0MIyqdj7Ielzr+u3ksPqjCL7ktvJHoR4hBqMQWr+vnOMZQApNd0tdwAoisrkq79B4tSlQfO91gZM4QnET7yV6KzZF8Q5jEieSPYld5C/6YWgMZ0zCbRA0JpABphy7f2YQ87u92wk8XW5qDq4idoj2wl4uwiJSiRp2nLCkiZc0NOyY+6K7ujo4HOf+xx///vfeeyxx0Y6nLPGEwjw16O7+biuHAWBSSi4ZYAIk4X7c+YwKSx6pEMcEg61NlDhbucaYrsFzXHCMTINB1vqK7gra+pZj9a4A34sp8iBt6HSpfn7ddsdTpqPFBI+fmTE6XHa60pRrBEIU98jPYozCW/JUXzudky2oZvePE5IVDImWxi+pgKUvhyNW0pA8xOZPvYfaoYDIQQRKZMu6Kf51DlXE5Y0nvI9a2mpKkBRFKKmLSFp2oozctj1e7uoPbyVtroSFEUlKmMGEamThqRs+1S4GqvYtfJxvJ1tCGcywmCns/QwtUc+IWnaCsYvv2vEf9tGijEnar7xjW9w9dVXs2LFijEtav6Qt4NdjdUsIIJx2DFKhQa8fOJt5hf7N/OLGUvGlHeKO+DnaGsjfqmRFhJKZD8Z/yUdrRgQJPQxigKQgo1PZAsVrnYmhp2dqEmyOchrqsePxNDHs34VXSRaHSP+pS9ttJAaOfIdcxXVgAz4+hd5J/WM6WproL2+HEU1EJaYjWoc/F5jimogdc5V5G98noA1HCVqAkIoSCmRHdVoVduJyphx3ueC6AwuofFZ51S63lC8jwNv/5GAtwvFFoEM+Cjf8z72qBRm3PQ9LI7hMfCUmsbe13+NTxMYcm5GmILtXaSUaI1HqNj3AYrRROKUJRfkd2RMiZoXX3yR3bt3s2PHjgFt7/F48HhOGK61tQ2+XfXZUNTezLbGKpYRSTYn+g1FYeIKYnhVVvNq2WEenDQyc7RnQkBqvFSSx3sVhbg1PxC0JZkdGc+Xx83o1WDToChoSPxIjH0IDu8xw6qB5uf0xfL4NFZV5LObFuYQ1t2VG4KCpphO7kmcdtb7H0oaDtcSBVgSUwgU56KmT0b04XZ8+7w0XtxaQrj13JvTRWXOpHzP+8iOGoSjZz8oKSVacwGO2AxyVz9NQ+EejteTqCYrKTMvJ2PeTYOeEJky6wrcrfVU7F2LrD8YzAXxdSDdTYQmjBuSfjpni6ejmfa6EoSiEhqfNWQNDHVGjvb6Mva98VsIicOQNQ9hCgmKbFctnWUfsfuVJ7n4zseHZTqvoWgP7tZa1HHXdgsaANyNwVFMoGznu5TtfBdHTBpZiz5DZNqUIY9rtDBmRE15eTnf/va3Wbt2LRbLwJ4On3jiCX7+858PcWRnzua6CuxCJVP2Hu43IJhICJ80VOMJ+DGP4jlvKSV/PryLj+vKmYqTcYRgQlCKm92Ndfx4zwaemLkMh/FELsj08FgkkI+LiTh67fMIHYQZzaSHhJ11XAk2B59Nn8TzxQdpwHssLoVSOjmCi0mhUayIvzDLHfsiImUijpg0Oso/gtQlKPZgubsM+NCqdyE7augKOOlorkVNnodwJIHmQ2vMp/iTN+lqb2LSFfcNakxCKExYfhcJkxdTlbsRd0stRmsScRPmE5k2dcirSgaCt7Odwx/+i7r8HXCsNYliMJM0bTlZi267IPJVLhSOrPs3UjVjSFvWnXcmhECExCHSltJ59C3qC3cTO27gFaBnS1N5HooltIdLtNbZQKBgNZgcQWsFWyTS00ZH/UH2vPbfTLvu20RnjY0cwnNlzHzrdu3aRV1dHTNnzuxeFggE2LRpE3/84x/xeDyoas8cjYceeogHHnig+++2tjaSk/uuqBhOXH4fdgx9ugJDsI+ThsQ9ykVNfnszm+rKWUIkGdjoJIBAMBEHSVh4pauG1ZUF3JY2kRZvF7saa/AE/OSERvJJaxN2VFKwIhAEkByinTw6+ELyZAzneNO6MWU8sRY7b5Qd4UNXsGldmNHMzQkTuCFl3DmNBJ1vCKEw/cbvsfvVX+HKfwfNGgkGM3Q2IDU/EamTaa44ijruOoT5hBBVE+cgLE6qD24iecalQ+KL4YxNwxmbNuDt/V43dfk78HS0YLaHEpM9Z0hGTvyeTna+9Cju9maUhDkooSmgBdCaCynbvQZ3az1Tr7t/xKc4dc6dmrwttFQcQYmb3iuRHo41r7RFUXd0+7CImuBIac/rSqvcDmYnhuyru1uWCEtYsMFl8TryPvgXkRnTUYbAmHW0MXrvmJ9i+fLlHDhwoMeye+65hwkTJvBf//VfvQQNgNlsxmw++9LgoSLWameT9OJBw9xHQmstHqyqgZAhqnYZLNbXlBCCSi0eNtOE79i0RBxmZhJKFjY+qCqmzeflg+riYBuFYwLGrKi8p9UTLoyESJUm4cMlA1yRkMG1SYNRQwPzY5KYH5NEq7cLn6YRbraMyjYOowFzSDhzv/AYjUV7qcvfQcDnwR41l8TJS9j23I8R4Zk9BM1xREQ2onY/VbmbRtzsq3zP++R/9BKaz4MwWJB+D4c/fIbM+TeTMvuqMxIYxytLWiqPIoDwlInE5yzoFkgV+9bR2VKLYdx1CEtY9+vU+JkIawT1BetpLs8jImXiIL/LC4fOllqqcjfS2VyDwWwjdvzFRKRMGlahqPl9HF73b0CC4RQzBAZLsA/aMBCWOJ7y3WtQ3E0IawSyqxXpqkVNW9qrB5sQCmrcDLxHV9FUmktU+uicdh9MxoyocTgcTJ48uccyu91OZGRkr+WjncWxKbxYfIg9tHIxPUsJ2/FzGBfL4tLOebRiqKlzu/CgUUQnU3CSgIVO/Byig3epYzx2mn0e1lYVM4dQco5NA9XiYZvWQqOQZEdEIYEpFhvL4tKGxDww1DT4yayjjXP1qoFg+W901qwew9RS04J9nyL7npMXQgFzKJ6OkW1kWrl/PUfW/RslcgKG2CnBnAdfJ1rdAfI3vYBQDaQM0Nm4seQA+1b9Ds3vRYTEgZTUFeykcPMrTL/xQcISsqnM3RC03j9J0BxHhKYirOFU5W4cUVGj+X0IRR0VU3VnStEnb1C0+dWgjYE1Enwuqg5sIDRxPNNveKDPlh1DQUPxXvxdHWB2IturIWpCr22k5gdXHSETZgxLTNGZMzGHROAt34yacSnS2w4ER4z6xBoBQsHdWtf3+vOMMSNqzicizFY+mz6JZ4tzacdPDiFYUanAzX7acZrNQ9buYDBp9LoRwI3EEcqJhNUs7KynsbtP1ELCyTkpfyYOC1cRw6uyBlVReGDi3OEOfcxy3FV4qFolfBqhKEGrfU9rn+ullOBtx2Qb/uu1rbaYjvpyhKJS8PFKRHgmavK87vXCaENNnAuan6Itr5E4dWmfrsgn09lSx743f4u0xWBIXogwBrvSS28HgbJN7Hntv5l/z3/jaW9GxPRjDigEmMPpam8cvDc7QLSAn4q9H1C+dy3ulloQClEZM0ibczVhieOGPZ6zoergJoo2v4ISOw0ldipCMQSTcturaCvbSO67f2bGTd8flli62ptAMaBE5aBVbkdrr0JxnKgoklKi1exBBnwkTDl7A78zQVENTLvhAXa/8ksCea8g7cGSdOnt6Jk4fByfC6SG0dJ7pPV8ZEyLmg0bNox0CGfN9SnjCDWZebX0MO90BRW0QQjmRSfxhcwpo350wRMIUO/uZDLOHoIGQCCYSxj5uDCjMI7eXzQjChMJYVt91ahPiB4tSL93yAz4TkX8pIVU7N+IjJ7cfZPvjqmlBOlpI37iwmGLp6OhgoPv/ZX22uKTlgqEJQoptV6eIUr0JPyNR2kqPUh05qmfpiv2vo9ECTorqyeua2EKQU1bhv/QSqoObMBodeA9pdBrxWQb3s7XWsDP3td/TVPZQURYGmrKQqTfS2NVAQ0vPcbkq74+Yq63A0VKSfEnqxChqajxJ/InhRAIZyIkXkxj8Uba68twRKcMeTwmqwM0P8KZhGirIFC0Fi08E8WZHEyWb8pHdtSQMvsqbGHD10/OGZvGvLueoGLfOmqOfIJbUdHqcoNu25+antPqD6IYLURlTB+2+EYS/U4ygiyJS+WS2BQqOtvwBALEWe04zqE9wHDS4u3CKzXi+/GbsWPAiMCBAbWfhOjQYwnRnX7fqBM1tW4Xa6qK2N1YjV/TyHSGc0VCJjlh/QzxDjFxtFPTR7XYcJA6+ypqDm/FX/he0GY+NBkCXrTGfLTaPURnzSI0YXDyoE5HZ0sdO198lIBiRk1fgXAkQMCD1ngUrWYvAQSG1Et6vujY06uvq+O0+68r2I0IS+shaI4jDBaEM5m6gp0gNWRTYbCf0KeejmVHFbKzkYRJd5/1+zwbynevoansIGrGpT1HE6JzCJR9xKH3/kpE6qTgjXqU4m6pxd1Sg5q+os/1IiwNUbGVhqI9wyJqojJnohgtyPpDqOnL0eoPojUcJtCUH9xANWN2RJJ9yR2Dcryu9kYq96+jsfQQIAlPHE/itOV9CiZzSDiZC24mc8HN1B75JOihU/YRatx0hNl5bPr1IFr9IbIWfQbDKH9QHixG153kAkQRghT70Lu0nopWbxctXg9Ok7mXr0x/WI4lZncS6HN9AIkEWvDhRcPUR0J0HV7MikqIse/Rh4CUHG5toN3nJcpsJdMRPixJgvub63gydwuKBunYMGLgUEMdW+orWRCdxKzIeBJsIWSEhF0Q1S0WRySzP/NjDq5+mraSdd3LhaKSOHkx45Z+ftjOQ8m2VQQkqJlXIAzHBLViC/6QG20EyjcjY3o2wpSuegBsoad/kpYBP5iNSHczWkMeWnslSImwR6NE5SBUI13ttfjcHaCa8BesRo2fhQhNBc2P1lyIVrWT0IRxRKYNX1KmlJLyvR8gwtJ7CBo4liyacBH+llKqD35E6uyrhi2uM0UL+IL/08+IpBAKqEY0v29Y4jGYLGTOv4n8jc8DoMRMRomZguyoJlB/CNoqyFlx96Bc/w1Fe9m/6nfBcgtHEghB+94PKNv9HpOu/NopR9lix19MwOfl6Ibn8Oe9ilDNyIAXxWAkc+GtpM655pzjGyvoouYCprSjleeLc9nTVHusbgmmhcdwR/qk0/Z2CjVZyHFGcqitgyzsvcrTC3HhRyKAfbQxh7Ae6134OUwHl8SmYOyjzPCj2nKeKzpAo/eE426S1cEXs6czOXzoWki0+zz8d+5WYjUzlxKF8ZgYu1iGsZc2NtdXsLm+AoA0u5P7xs0k2xlxql2eFV2VZVgST/8k2uz2DYoB3+mwR8Rz0ed+TlttSbCtgsFAZOrkYWmbcBxNC1BzeAsiatIJQXMSIiILqnejNRWiJgY/E6kF0Gr3Yg2LI3QAOSXOuHTqy46g1R8EgwUlLA2EitZaFvQBUU1IJEpEFkrsVAJlHxEo3XhyFABEZUwb1gTdgM9DV1s9amrficnCaEWxR9FeXzZsMZ0N1tDo4MhIWyXY+2iR4W5Cel3D2ok6ZdaVABRtfR1/Q16wC73UMNnCGH/tt4jKOPcEYXdbA/tW/Q5C4lFTFiHUoKiTmp9A+WZy3/0zIVFJhEQl9buPhMmXEDv+YuoLd9HV1ojJ5iQme/YFZwapi5oLlML2Zn66dxM2TWEREURgohkfuc0t/LhlIz+dtojxoae2/b41LYdH93/Mehq4iHAcGAggKcTFxzQzNzKBNEcoL5Xk0Y6ficcSoivpYi9tWExGbk7tXU2woaaUPx3ZRTo2FhFHKAYa8LLb3cpjBz7mx1MXDllvrHXVpXg1jaVEdgsaCOYJzSCUEjoxIJhGKLtcLfx830c8OmPxOZkFfpqGw7VETTjxgy7bGk/pKjycnKlvzGAS8Hah+b2olr6FlBAKmEKQnXXBm19XC1r9IehqIufm/xrQ03TsuIuoL9iFCEsP3lyOdyyPn4VWsxetdi8SUBwJCFMIhqwrke5mZGcDCIEIiUcr3UBnc+1gvvXTEvQfEciAp/+NAl7UPqbVRhOq0ULCpEVUHtiIDEvrOeKm+QlUbsdkDxsUITFQhBCkzr6KpGnLqC/ci8/djsUZRWTalEEzWKzc9yEggsZ5J+dyKQbU5IUEOmoo37uWnBX3nHI/qtFE3IR5p9zmfEcXNRcofzu6B6emci2x3TfvWMxkYeNtWcfTR3bzmzkrTnkjmBIew7dz5vD0kd0UapWECSNuGaALjbmRCXwzZzZmRcVhNPNa6WHe9AZ/6I+3UbgnaxqR5p6Jp14twDOF+8nCzjIiu1scJGElHgtvy1r+XXiAJ2ctG/RzcqS1kZWleSRgxkrfJlWZ2NlGM9diJR4zr2s1vFh8kIemLDirY5Y2WuAUTS2Pt0rQAYPJimq0IN1NENbbE0dqAfC0IgNe/EfeBCA0YRzZl3xtwJU/HY2VoBhQkxf0MFoTQqDETUe2liK7mpF+94l11nCENTiyqXna0bpaaCo7yN43fkN0xgzicuYNSY+s4wT8XjoaynHGZ9DeVICM7N2lWXPVobmbicqc2c9eRg9ZC2+lpfIIHfnvIMIzUOyxSK8L2ZyPCHiYcvP/GxG3ZtVoGbJE64aSA+BM7juXS1ERoWk0lhzo45U6n0YXNRcgJR0tFHW0cDnRPUYjAAwozCaUd9x1HG1rOu1ozYKYZGZGxLGlvoLKzg6sqoG50Qk98oQuT8hgRXwaRe0tdAX8JNgcvcTMcfY01tDh9zGT6B49mwBUBNNwsqajnnJXG8l251megd6UdLTwyP6PENqptzvZy9OIwmQcfNxUS6u3a9RXrI11hKIQP2kRlQc/RkblIIw9h9W1xsMQ8DLj1odQDSbM9lCsA8ijOZmWyqPBSpe+bi5CIMLSoK4d2ZSPjBzfo9JKazxKoHwLKCpeYaextpqGwt0UbnmNmbf81ymnDs4GLeCn+JM3Kd/zPn6Pq3t5oHwzasKc7ik6rbMerXQj9sikMWG+ZjDbmH37jynb9R4V+9bhbTyKUI3Ejp9L2pxrBv08jgak1ECcorJRUZDaaX6cdABd1FyQVLuDP4Bx/VQuxRG8Odd0uU4ragCsBiPLT9NLSRXKgHJPmrxdqAjC6XuYPJLgF7/J4x5UUbOy5DA2TWU8dnbQQicBbJ8arZHHptYSOCFeIjAhgVaf57wXNV3tjVQd2Eh7QzmqwUh0ZtCobzifmtMuupa6ozvwFaxGiZ2GcCQeq346glZ/iKTplxKZMunsDyAUkLL/9VJDMZgIuJuDlSYJcxBGG1p7NYHyzYjI8cFlx0SR9LTjK1nH7lefZMG9v0btJyn+TJFSI/edP1NXsBMlagJqWAZCCALVe5BN+fibixD2GAh4kO4mbBGJzLj5+4Oa5yOlpLn8EE2luUhNIzQhK1gtNAhW/AaTlYx5N5Ix78agiaCq9irVP58ITxxP58HNSC3QqxWDlBLZWka4PmI7IHRRcwFiO3YTchHA0sc0iwt/j+2GkzCTmQCSVny9/G8AmvEd227wBITb72NnYzXzCCMbO3to40MauIzo7jYWGpJdtFKPl6s48fTfhBcBhA7h9MJAGQxX4f6o3L+evA/+GfzBtQVvljV5W7CGxzPzlv/C6hyeUneLI4LZd/yEvLX/R3PZR93LVbONjAW3kD73unPaf2TKJFq2vo70e3olIwdvLiVEp08lOms2h9b8Df+hEhRrBJq7BSxhqEnzekz9CLMDNW0J3rzXqD36CQmTPlVufpY0lhygLn87atrSYDLzMQyZlxJoKUUrWYcjxIo9MovorNlEDXLfn662Bva+8Rs66ssQJjsIFbnzHcwhEUy74buD2jJDMYzuPKDBIGn6Cir2fYBWuQ0l6eJuASelDDaV9bSRPOOyEY5ybKCLmguQiWHROA0mcv3tLKb3SMwB2rGpBqaGD5+Z1HFmRsRhUw3sDbT1ik1Dso82Um1OUgZxlKbD70ND4sSIGZXLieY96niOCtKwYTzWedxFgIsII5ng1JkPjVzaGe+MxDlIT+ADxefXTusq3NXWSEdjBYpqJDQh67Ruuv3RWJpL3tp/oEROQEmYfWIUorORrtL17Hn1V8y765fDVu1jC4th1q0/oLO5ho7GSlSDibDE8YMyCpIwZQnF21cRKNt4zIDveBVKAK1qO7KrjZRZVxAan0Vk2hRq8jbTXl9OVe5GlIjsPnPQhDkUYY+hsWjfoImayv3rEbbIYCn5p1DDUpGORIRiYNIVXxmU451MwOdh18on6HJ3BkvrQ+IQQiA7G/FWbmX3yl9y8Z2/wDJMQvd8ICQykZxLv0je2n8gO6oQoWkgBLK1DNnVQvaSzxGacOZmjlJKWqvyaSw5gJQBnHGZgy5wRxu6qLkAMSoKt6Tl8H8F+zChMB0nVlS6CLCfNg7SzudTJ4+IIZ5ZNfC5jMn8PX8vGpJpxxyL6/Gwm1Zq8PBw5qxB9UVxGk0YhUKD9JKClQQsfIYEDtFBGW78SDoJEI6BNKx40ajBww5aaMFHc1sj39mxli9kTGF2VPygxdUfx1sl9EdXeyOHP3yGhqI93VMpBrOd1NlXkTb32jMexi/Z/lbQpyXp4p6jELZIlJTFdOa/TUPRnh49o4YDW3gctvC4Qd2n2R7K9Ou/y943f0vg0MvgTAahQnsF0t9FzqX3EhofvLkYLXaSZ1yGlBpVBzaAcorvi2JE0/yDFmdnSx3CGtXv90DYouhsLR20451MzeGtuFtqMUy4sUfvK2GLRE2/lMDhVynfs5bsxYNjSHehkDhlCY7oFMqOmShKKQlPmUDKzMvPqsWFp6OZfat+R1t1QdAJXFGRnlWYHZFMu+7bOOMyhuBdjDy6qLlAuSIhA0/Az8sleeTKduxCpVMGEAJuS8nhukHqlH02XJaQgSIELxQd5Ki/unt5jNnGf2XPY1pEb/+Kc8GsGlgQk8SO2sruPlx2DMwhjDmEsZ1m9uCjBT8vcyIeJwYuIxoDgv3uNn51cCvfnTiXedGJgxrfceJop8bvOGWrBL+7jR2v/hKvpws1cV7QWj7gJVCfR+HmlTSVHWTcks8N2Ocj4PfSXHYQ5VPTKsdR7NFo1nAaivYOu6gZKiJSJ7Pg3v+hYt86Gkr2IzUfYZMWkjx9BfbI3p+tEAqO2DRcbeV9Nzz0e5CuWpxxZ1ch1xcmawidLX23aYBgHyCjpY8+QINA7dHtCEdC3808DWZEWDo1Rz7RRc1Z4IzLYPJVXzvn/Wh+H7te+SXu9hbUjEsRjsSTRtM+YdfKJ7j4zsexhg6d59dIoYuaCxQhBDekjGd5fBpb6ipo9HYRbrIwPzqJUNPIt2pYEZ/O4thUDjTX0ebzEGW2MTEsCmWInGtvS5vI7sYa3vTXMh0niVjoJMAh2jmKCycGJmBnH+2YECwjmlhM3RVaiVhYSz3/l7+XOZHx59xhveFwLVEwIAO+k2nOfR+vuwN13HXBTtVSQ6s/hGwuDK4vP8S2//wQZ1wmk664r8+b9MlILegY3Vc10HGEYjrhBHuecLIF/UBInnEph977G6K5ECX8RHm+lBqByk8AiTkkgkNr/k7A5yEkKpmEyZdgDjm1yWV/xOUsoPn9vyPdzd3l5N3H9HYgW0tImD+w2M8Uv8cNhr6rFwEw2gm0lw/JsXUGRl3+DjobKzGMuw5hOzGNL2yRqBmXEsh7lbLdaxi/9PMjGOXQoIuaCxyH0czliX17pIw0BiGYFBaNSVGG3IY/2mLjFzOX8I/8fWxqPuGwLIDx2FlMJM342E4ri4nuVTkmEMwijFd81exrrmVWZO9pqIAMOiwPlTCTUtKWvwURntXdjyhQthnZXIgSNw0lYhwYzMi2StprdrPjxceY+4VHT5nkqxotWEJj8LRV9LhZdx/T50brrMcRc+mQvKexQvzEhTSXHaL60Ca0pgKEIwk0H7K5EOlpx+yM4tB7TwfN5FQztfk7Kdr6GhOW303i1DPv7hw3YR6lO9/BXbwWJeEiRGgKIJDtlWiV2zDbw0icOvheThB0l24v2NNn81AA2VGDLWLop2F1+qf2yLZgc0tb75xJoZoQ4ZnUHN6qixodneGg0eNmVflRNtSU0hnwY1MNLIlL5brkcf362wwGcdYQfjh1AfVdnVR1tvP3o3uweCRLCN70O471uYqi7+mfiGOuPw1dnd3LpJR8VFfOuxUFFHa0oCCYEhbNtcnZA55GO27A15erMJxolRDwedC8LtRjLqyysxHZXICavAAl8sScvAhLRYTEEjjyJqXb32LCKVxKhRAkT19B/qYX0cKzUJwnRnaCoxDbUFQD8ZMWDei9nK8IoTDxivuISJtC+Z61tNfuQVENRKdPp72uBLerDTX7ahR7MPle+j1o1bvIW/uPbnfaM0E1mph128McePtPtJSsB8UQnF4I+HDEpjP12m9htA7N9FPStGVUH9yE1nAYNbpnWwatrQLZXknSgvv6fG3A58XVVIkQCvbIxBEx0RuraAE/dUe3U3lgA+62BkxWB/GTFpIwaVEvc0efpxOMp2iPYLQROKkFzfmEfkXpDIiAlHi1ABZFHdJRk2p3Bz/ZsxGPz8947IRjpDngY31lCVvqKnhsxhJirYNfsnwy0RYbYSYztZ7OHhVY1mPl3a34cPTx1WnHjwY4j03fSSn5e/5e1lYXk4yFRUQQQFLQ0spjLZu5O3MqVydlndZV+FSc3CpBNZoRBjPS0waA1lwIBmuwJ9KnEAYLIiKbqkMfM375XadMHk6ecRlNZQdpLF6LFpqK4khE+ruOjUK0Mfmab2K0nNln4vd0Un3oY2qPbMPv7SIkKomkqcsISxrfYztNC9BQtDeY7KioRKZOITRx3KhsJCqEQnzOAuJzTuTONJbsZ8+rW1GzruwWNBDMPVGS5iG7minZ/tYZixoAsz2M2Z/5Ie11pTSVHwIpCUsYhzM+c0jPT2h8Fskzr6B893tIV21wBE+oyNZStKZ8ItOnE5fTM38o4PdStPlVKvavI+ANujEbbU5SZl5B2pxrBlw5115fRn3BLjS/l5CoZGKy51wQJd8Bn5e9r/8PzeWHECHxCGsMHncbbev+Tfmetcy67WHM9rDu7e0R8bTWbe9/NM1Vi32Qk+xHC7qo0TklFa42Xi87wpb6SvxSw2kwsTw+jeuSx/XbXftcePrwbvBp3EJ8D/O7KTh5w1fDo/s/YnJYDBbVwMXRiYx3RgzJD/jxXJkAJ4zYojARhoH9tJGIpZfj8T7asKkGZkYEfyx2NFaztrqYxUQygRNPzZNx8AktPFO4n2nhMSQNUnm6EAJn5lzainYioyci/e5gOXE/gkVYwgj4PAR8Hgym/kfAFNXAtOu/S+X+9ZTvXUtn+WaEohKdNYvU2VcTGn9mYqyzuYZdLz+Ox9USNM8zWnEV51KTt5mk6ZcyftmdCCFoqy1m35tP4WlvRJhDQAtQ/MkbOGIzmHb9d7A4BqeR6PGy17r87fi9XdjD44mftAiT7dw/l/rCPQhLKKKP5oxCCJSILJrLtxDwdZ11KwVHTOqwNngEGLfkc9gjEyjd8S7u4g8BMNrCSJt/E2lzrulRMqwF/Ox9/dc0VxwJGgWGpoHUCDQXUfjxSlyNlUy68qun/B77PZ0ceOfPNBbvDfoHqSakpx2j1cHkq75+VqJwLFHw0Ys0Vx5FzbwCxXFiak92teAuep/cd//CrFsf6l6eOHUplfvXodXnocb0NKPUOmqQreUkrbh7uMIfVnRRo9MvR1obeXT/x5g0wQycODBQ5/fwTnkB2xqqeHTGYpzGwUsqrnC1caitgeVE9XLzLaUTF35cXX4O1FTjFgHeqSxgcmgUD06+GPtZerD0h0FRmBwaTX5rGxMJQRz7by7hrKGetdQzizAiMdGGj320cYgO7k6b2l0K/15lIXGYewgaCAqmiwijABfvVxdzb9bgWdeHT74cV+luAoVrwORAelr6dCmFYMdj1WhBHcBnqKgGkmdcSvKMS4N27UKclZiUmsae13+N169hmHATwuwILpcSrfEwFXvX4ohOITJtCrtX/pKAasMw7lqELSpoftdeRUfFFna/8kvmfuGxs/beOY7f08m+Vb+juewgwhSCMFrR3B9R8PHLjF9+F0nnmJei+b3BHIb+zpV6rJWB349qDJZqt9cWIxSF8KScIZtCOleEECRNXUbilKV42hvRNA2LM7JP/5OavC00lx3sdUMmJBZhj6EmbxMJkxYRkdq3Y66Ukn1vPkVLVQFq6mJEWBpCKMiuFvxVO9j7+q+Z89mfDqrh32jC7+mk8sAGlOjJPc8fwQcTJX42zaUb6Wio6G4h4YxNJ2XWVZTtehfZWY8SkQnCgGwtQ2s6SnhyDgmTF4/Auxl6dFGj0ycBKfld3nbCNQNXEdPdIyobO+Ow85a7lu/t+IBQo5l4m4MV8WlMDY85p1GTUlewRDWFnqMGpXSyiSZyCOEiwrCgIqWkFDcbWxv5zcFt/Hja4Od0XJeSzeMHtvAJLcwhDAOCNGwsIJxPaKYYNwqgEXRfvjttKledlHRd3NFCDn1Py6gIErBQ1N581vH1ZcBndEQx+zM/Inf103TUlQDBnkRqdE6P7aSvE9mUT+KUS87Yt+ZsTfba60op3v4W7uZq1OyruwUNBG+SalQOsqOGkp3v4mqqIhDwo2Zf2u3sK4RAOBMR6cvpPPImdUe3Ez9x4VnFcpz9b/+Rlsp81PRlCGdKcPTE34VWvZvDa/8Psz2M6HNoAhkSnYp28CMUX2evXlUQzEExhYQT8HvIfe0vNBbv614nVCOJkxczbsnnRu0UixDitCZ7FfvXI5yJvW7IACI8A1F/gIoD6/sVNS2VR2guP4Savhwl9EQ1oLCEoaYtI3B0FSXb3mLqdfef25sZpbTVlqD5vRjC+xZtIjQVhKCl8kiPvljZi+/AFh5LyY536Sr6AACDJYSUOVeTfvH1520+0/n5rnTOmX1NtdR73NxIXI+ml+34+YAG/EgcPoHdp5HfWc8nDZVcEpPM1yfMRj1LYWM89pTnQcN00jH30EY8ZhYR0T3lI44JDA1Y21JPYXszmY6zK4/tjxkRcdyTOZV/Fe4nHxfxmPGgUUUXYUYzN6UGPUmcRjOzIuN6mRUahYKX/pvQ+dCwnqWz56kM+EKikpj7+Udpqykif+MLtFRuA29HMFnYYEa2VaDV7sNotpA655qzOv6Z4Pd2kfvOn2ko2h00qDPaEba+/TGUsAzcJeuoOexGhGX0alUAIKwRiJA4ag5/ck6ipq22mKaS/ahpS1BOcuYVBksw38XTRvEnb56TqImfuICCj15Eq9yOktpTQGodNcjmIhIuuoadL/0Cj9uFmrwwWMmk+dGaC6g4sIGu9kam3fDAqMwjGgjullpEaN9TlEIIsEbjbq7r9/W1R7YhzA6EM7n36xUVEZFNXcFOtID//LxRD+Rj76NdmRCCpGnLSZy6FHdrPVILYHVGj1qBPFich1eAzmBQ6mrFgkLMSaXLEsla6pFIbiOBsGO9mSSSfFxsqCsnJSSU65PP3P0SCJZvC4XDsoM5hAHgJkAtHpYR1SuHBSANKzahsq2hatBFDcBVSVlMj4hlbXUxJe2thKkKV0fmsDA2GetpfkBnRcWztaaCOTIM9VOxu/BTjps7IwfX5PDk/k+h8ZnMuu1hij55nbJd7+Gvz+3eLjxlEjmX/n/2zjs8jvO61+/MbN8Fdhe9dwJg752UKFKiqF5tyY57zXVLLMdO7NiOHbf4urcrJ3Yct9jqvZKSWMVeAQIE0Xtvu8D2nfnuHwuABLEgARIgQQvv8/B5iGn7zZaZM+c75/f76JTVpVyMslcepaehFDnrBoSnAzHQNv4Nemh5OOiH2IsUH+sthIcKTi+XruqjkYLpKFYDkiQhxxfibthNwNM/qghzMuhNVubf9veUvvRLROULkXZ7nQltoBXRX4czoxhJkvAP9KIruve87JURJXkxktFBd+1b9DWVE3clRp3XEJ3JSjg4OP4GoUF0Q3o9mhqmo/IQraf34B/oxWh1ILQwkt4yvnqy3gpCQwsH/yaDmtikHGSdAa2vDiV16Zj1wtUACBwZY4UfIVLAbnFMrWDpTOZv7xswy5RgkBXCCMJo6IayJu0ERgwdHeeZTUpIFGKjjQCvNFVzZ0YBymU46lp1eral5/NScxUx6CjESnjoEcRM9OPJSJhQCKrqZZzlxEizxPDB/EWT3u/29AJ2tTfyBl3cQDzmoTohFyHepBubzsCmlMmJ601EVfh8JFkmf90D5Ky8g77msyNdIxO1FxBC0N9cQXvFAUL+Qcz2JNIW3Ih1gjokA12NdNUcQ7IkojXtAxHJXAlfb0Sz5QK0/gaMMfEYzDEMejqAsQWgQmjg7cKafmUKxmooGAlqxvuu6kwj210JyYWrMD38deqPvEhXzTEQGqbYRDI3PkTm0q3s/58vRrJS503HDSPZs5DMTlrL9l63QU3q3HXUHnwekbpszBSc8PUhBlpJXXcH4aCPE0//AFdrJVJMKpLRid/VjxhoBUlBVoMjXlyjjuFpR2+ORZlCk9uZhM5oIX3hJppOvYVkS0aOSRtZJ3x9aK1HcGYtwHYJIc13CrNBzSxRWRafMjLtMpfIxbYFPyZkMoh+8cjHQkWokzbv4GV39Lw3bz79QT+7O5s4JrmIFQoy0IyfDMZ26AwQpk8EybSOvSFcazKtsfzT/NX8pPwwf9ZaSCXiQN5OAIfeyFcXrZ/yAufxUPQmEnInV5AcDvo49fxPI0W0JjvorVBbQsORl8hZdRf5G959ySmRhmOvAhIi7EdOWQp6C1rzQcKN+9Dl3zpqeknrr0f015B1w3vQGcyc2fHfaAOtoy7iAFp3BSIwQPriyYvWnY81PgPN348cGIgaUIiBVhSDGaPNcUWvA2BPK2DxPZ9HaBqaFh5V4BzwuJDG8eGRJAmMdgIDvVc8hmtFxuItNJ96k1DN68jpq5FsqYBAuJvQWg5hiUsjuWgtFW/+HndHPUrB7ci2c5kF1dWEVvcGWvtJ5LSVo75zwteH1ldD1orbJl0bdj1RsPFhBnta6Kt5Hc2WgmSORwTcCHczlrjUKbFW+FthNqiZJSqpZhtrE9I52N2GCYWcoYDiYrcweWjtGVcPr7XWEtJUcmwObkjOnPDNW5FkPjt3JXdmzGFXRwN9QT9G3yBnBgeYg5X484TvNAQH6cOk6FiXNHa+fSawPD6VR9dsY1d7I5XuXhRJ4j5nEuuTMuj0e/mvyhMc72lDQ2P+/iN85Ma1bMw7Nx3ib2kcsUoQ7p5xBfimg/LXfjNURHszUmxGRNxNC6N1lVN/+EWMMXFkLhlfSVjTVDorjyBZk1DytyINGT7KJgfhmtcJlz+B7MwDnQXhaUMMdpBUuIqsZdsQQqP97CH66t5AxBVG6kyEitZXi+irJXPZrdhTrkwJO6V4NZW7/ozaegQlZ9Oom6Lw9SF6zpK+ePMVd1idjyTLKPLo4xmtdgK+/qjbCyEg4MKYev0+hRsssSx/91coeeHneGpejwSyQiDUIPa0Qhbd9VnUkI/2M28jpSwbFdAAKPZMhD0brasMEXCdU8YeaEF0V2B1JA8Zi4rrtu7oUih6A0sf+BKdlUdoKd2J392NwRZL6qoPkTpv/WXLAfwtIgkhopQY/W3idrux2+38Yf1dWP7Gi6WmAp8a5idlhzjR10GspEMnJHoJcTfJpEbJ1uyjl7MMEkbgkPQYkOkWAfSywmeKV7DmMo0eveEQXz+5mzbPIIVYSRvyZapgkF5CPDJ/FasTZvZFv8vv5dWWGg52NeNXVRx6Iy2+AUwoFGBFh0ST5KNLBPn4mmV8cdM6JEkioTh5JKgZVhVuJzL9tLe+H71O5rED9TjN577PwzU1V4K3r539v/unMWrEw4QbdiN72ln34e+P61/UWX2Mkud/MsZ/BkAEPYQbdoOnCyRwpBeRueRmkgpXjgQXWjhE3aHnaTr5BmF/pCbDZE8iZ+UdpC/aPCU3sM7qY5S88DMkkwMpvhBJZ0EMtiP6qrA4U1jx0FcnLSw4WWoPPEvtwecvqKmJoPU3oNa/xbIH/2Xc7qDrheGpzP7WSiRJJi5r/ohTdFf1MU49/xN0896NZBj7fotwgPDpv2CMiScw0AOArDNgionH6+oCLYzB6iRj8Waylm+7qO7SLNcn4YCXXb/8BC6Xi9jY8WcCZjM1s4yLWdHx5YXrOOvuZV9nEwOhAKf7utgX7uV2krCe9/VpxEc5A+iQuItkUoURCQkPYQ5offyk/DDfXnojc2InX5hq0en59yU38lzjWd5oq+d0eAAJWBqXzD9kFVNsvzrZiw6fhx1tddQM9KGTZJbFp3BDchbWSwTIVe5evlWyD6Fq5GPFjIGWsB8NSMbIahzISKwQdkoZ4DcHj7MsPZWbC6NPSVzIsKrw+YHNldJdexJkBckZfQxyXCFqXy0H//ivrPq7b0Z1+x3sakTSm6P7zxisKOmrUCtfJGnOahbd9dmxr6HTk7/+QXLX3IvP1YUkK5jtCVM6zZBUsJwVD3+NuoPP01N3CBDoTDYylm8jZ9Vd6IwXkZqfIjKX3ELr6T0Eal5FTlmKFDvc/VSD1nGKhLylOK/TeprzkSQJZ+ZcnJlzx6y75JP1UACbv+FdONOL6Gs5y5nt/43PO4ictAjJYCXs6aD24PN0Vh1lxUP/elU+u1lmHrNBzTsQnxpmZ1s9b7XX0xfw4zCYuCk1my0pOZgvuEFLkkSxPX4kcGjxDvCNk3t4LNRKHhZs6GgnQCsRH5FtJJF2XhbHio7NJPC01M5zjZV8ccGayxqzRafnvXkLeCh3PoOhIEZFwXQVOx3eaqvnPytPoB/Slwmj8T99HTxVf4avLtpAbowj6n6+cIjvlLxNjKpwO6kYhwqelwN1eNlBF6cZYBGxSEgsIpZ6yccfjpyccFAzHkII3G01tJzehc/VjcESQ+rcdcTnLL6k1oymhiLTRVL0lvPhWphQOEzZa//Jioe+OmYbWadHaOFxxf8IBwDIWr7tomORFd2EC5MvB0faHJbe/08j6sp6k+2ytXguB73ZxoqHv0b59t/SW79vZLkk60hfGNGp+VudVhnGnloAkozWXz9GARdA9NcBEs70Iow2J9V7HgNzAkrezSPTmsQVICfMxVP9KjVvP0XR5g9c3ZOYQga6Gmk89hrddacQmoY9NY/MpVsnXRf3TmQ2qHmH4Q4F+ObJvTR73eRgoRAzfeEQf6o5zRutdXxzyQ3YL9JFkG6J4YcrbuaNtjr2dTTRHQ6QYrHhwEa7yzUqoBlGRqJIWDnU04YqxGXr2AAokoTdMHUqxhOhwtXDryuPU4yNtThHdHsGCbMj3M23S/bxy9W3jgkIO3wevnpiFx41xB2kjQQ0w+RiYQ5WTjPAQmJGWtZzhJljLe1XNGahaZRv/y1tZXsiUxqmeOhqo6PiAI70Ipbc94VRT7JCCLqqj9F0Yjvu9loEkZS/8HYhnedZNIzmbo50pCQvob95P4M9LWO6LxLzl1G95zFEfy1S3NjWda3nLCZ7UuSGNgNQ9MYJqStPB6aYOJY98CW8fe24O+qRFQVHRjEG88wrgJ8OjFY7KcVr6ag6imZLQj5Px0j4etHajpNYsByzPZGOysMEPf3oim48F9AMIZnjkBKKaT29h4KN774ua006zh6i9OVfRdrYHbkg6+jtaKTnmR+Qs+ouCjY+dK2HOKOZDWreYfxX5Qm6vB4eIJW484pu+wjxkq+DX589zj8vXHfRY9gNRh7ILuaB7HO6CD8pP4yL8bUoTMhoCDShoYzz9D9Team5CqdkYKOIG6WVY0PHzSTw13ALezub2Jp2LrMS0jS+XbIPbyiEAx1Ook8N5WKhEg9e1JHpPBWBPMHAL5qqMEDdoedpK9uLkrkeKW5OpMhXCMRgG676nZS//tsRBVYhBGd3/onmE9sjHkXxcxGeLgi1oDYfQirYhqScG7/w96N1nkZy5iHH5aM178fdXjMmqLHGpZFYsJLuusOgGEYUe4UaQussRbgayLv1E3/zWYjJYHGmTLjd/m+N4i0fxNPbxkDlS4jYDDA5EH4Xwt2MLSGTuVs/CgxNaxpsUSUBAKTYDNSOEnyuLmwJM7OBYDz8A72cfuX/ITlyULI2jky1iuTFIwX69rRCEvPH6tXMEmE2qHkH0e33cri7lQ3EjQpoAJzoWYmdPb3tdPg8k3bCzrLGcqSrhQDamIwERFqyk42WEdXgy6XJ46Z+0IVBkVnoSLoqBd8neztYLGKiiv/FoCMNEyd6O0YFNYe7W2j3eyjASieBcY89bJg53DkmENRKXtbnXPpiPJ6qsBYOUX/sNeSE4lFFvpIkIcWkQdpKOqv243N1YrYn0VV9lOYT25Ez1iLHpBOueR2CA2CKA38v4TNPIycUIRliEJ4utL5qMNhQ0laAFo6MX45+KZl/2ycoeeHn9Na9FckY6a3g60VoIfLXv4u0BTdc8jxnuXq422vprD6KGgpgi88guXjNSNGtf6AXNRTAFBOPMg1mtjqjhRUPf5WOigO0lO7GP9iO0eogbfWHSZ27fiSLJit6UIPjOlATDp7b7jqjpWQnSDJKxtpR5yZJEkrSfISrnsbjr88GNRdhNqh5B1E90Icgkh2IRi5WdtNL1UDvpIOazSnZPNlwhkOib5SdAUArfmrw8r70y+/eaPUO8OjZ41S4e0aWGWWFben5vCd33mWJ/U0UVYgxisDnoyChidF2CEd62kjCSAEWqvHQQYBkxk5tVOEhDj0mZFQEh+ijWwT58OrLv2jNzzVRE/Cgy44+rSM586B5Pz31pWQs3kLj8deRbCnI8YWEK54DQFd8H5LJgebtRq18Ca2jJCKcpzMjJ85HTpyPpDOidpYiyQpx2dELWXUGM0sf+BKu1iraKw4QDngxO9aStuBGzJfwDJrl6hEOeCl58Rf0NpRGirt1JjTfdip3/S8ZS7bQ23iGgY5aIKJ5lDp/I/nrH5zyzjBFZyBtwY0XNVtMyFtCzdtPIvrroxaya71VmJ2pmK9DFd3+1iqwpUYVGQSQYrNwtZ2Oum6WCLNBzTuI4SkNbZxeA+2CrMFkcBrNfHzOEn5deYJeQhRhxYhMIz6q8TLPHs+29MsrfO32e/naid3IYcEtJJCBmQAaFdogLzRV4gr6+XTxiss69kQoiHHS6PawiLFthAE02vCzJiZn1PKgqmJEIhMzDnTspJvbSMI+NA2lITjNAA34SMDALnpolvz4hMq/bb2R1Vnjt6hfSlVYVSPZE8bJniApkaLMoe3c7bVISYsR7mYIuFDm3IlkckQOYUlAJM5H6ypDztqI5MhDluWIq7arEa39JGnzNmKw2McdryRJONILcaRfnn3GLNOLEIJTL/ws4oKdc1NExViSkYODqHVv0XDkZSRbKkr2JtCZEINttJzeQ29jOSvf8/Vpb3m/kJikbOJyFtPXfBAUI1JM2jkNpY4ShKuB3G2fHJnWdHfUMdBRj6zTE5e9EKN1/O/qtUaW5RHV7agI9W9aZHAqmA1qriHtvkF6Aj5i9UYyLDHTXltQFBuPTpKoEh6WMPaHXYUHGYm5jst7gt6SmkuC0cJzjWfZ4+oGIM5g4t1pc7krc85lTz0911RJOKzyIKkjVgMGZFbiwIbCro5G7syYQ7Ztei5Wt6Xn8xP3Yc4wMKKuDJHAZB+9CAm2pOaM2ifX5uBUTwdhBNtI4mU6eJxWMjBhQaEZPx5U5trj0TSBKgR3Jifwoc0bmJNwZX5McRn5IOvQ3E0oQ8HJ+YiBFtDUEY0QSZIjXUoDLWC0I1tHt2fLacsRoUG0xr3QfgLNHA9BN8LXR3zO4uu6y2QWcLfV0NdYhpK7eZSxJ7IO4e9Dji9Gzlhz7voUk4pw5uGrepn6Qy8w58b3XPUxL7zjU5x87se4arefU7v29SDCQfLWP0ja/I14els5/ep/MtBeM7KfJCukzt9I0eYPTKmo4lQRl72AnobHEFFc3YUQiP46Eq5zvaLpZjaouQZUu3v5Q03pqKmUbEssf5e/gKVx01ckaDcYuTE5mz3tDSRgGGU70IqfY7jYkJSB8wo8VBbHJbM4Lhm/GiakaVh1+gkXvUZDE4Ld7Q3MxToS0JxPITaOSS52dTTwQdvk/ZkmwtrEdMr6c9neVkcVHrIwE0JQI3kZEGE+V7ySOONosa/NqTk81VDBQSLTcQ+SRjUeavHSQQAPKvdkzuF9eee8jbLj/TivMKABMMU4iMldwWDDSURMBpL5nDieCPnQ2o5iS8we6TqKz1lEV1MlWJIgSuApSTJK9iY000m09pPYkzIxx2aSOn8jzsx5M7rQVwjBQEcdnt5WFL2RuOwFM1aYLeh10VK6m96G0wih4UgvJGPRZkzTPE3XUXk4UngbO9qHTOutBiTk1KVjPmPJ5ECKm0NL6S7yN74b+Qpr5SaL3mRlxUNfpa+xjI6zhyLTms4VpC3YhMWRhH+gh6OPfZuwkFFytyDFZoAaQuutorVsH0GPa0Y6n6ctuJHag8+hNuyOZM2G/MeEFkZrOYLwuy4pgfBOZzaoucpUuXv5xqk9xGo6tpBAIgZchCnxuvle6X7+af4aViWkXfpAl8mHCxbR6ffwcn8nyRhxoqePEB0EmBsbz8cKp6YAzaToME3BdS6gqfg1dUxh8zAKEnahpy/ov/IXGwdJkvjYnCUsdCbxaksNp84T37sjo4C8KO7g8UYznyhcyn9WHqebIIVYMSBjQqaNMCvjU3lP7ug6lIYeE5ytwVl0Tv6/u6KDBLikVcKFAnyJq96N5mrBU/Uikj0HyZIAATeivxadwcjCOz49ckHPWnEbndVHQDFGinijeCFJkoQIuDHFJrL83V+ZcTeDaLg76ih//bcMdjWMLJP1JrJX3Ebe2vtmVBq/t7GcU8/9GFUNR4q5JRnX0ddoOPIyC27/PyQXTUzfSQiBu72WnoZS0DTsaXOIy55/0XNVQ74hY8/Rn6kIuJBMzpEb64VItmTCXWWE/YMXnX6cLiRJIi57QVSl5YajrxIOBVGK7kXSDwWxOiNK0gIkg43u2p24WipxZBRd5VFfHL3JytL7/okTz/6QcPkTSDHpkWnkgVaEGmDuLR+Znca9BLNBzVXm99Ul2DUdd5M84n5tR08GJnbQxW8rT7I8PmXaCl+Nio5/XbSBYz1t7Gyvp9fvJ9No4/0p2axISJ3WgtvLwSgrmCSFcjFAOQMIIBED84jBgR4VQb8UIm6an74lSWJNYvqkrB62pOaQbLLyQlMl+/s6EECa2caH0hezNS13Qu+1JgRP7D/J/+z5PeX1zZgtFu67+w7e88nPkl80b9z9FKOVle/5Os0n34x4xbQ1oDfbSF16C1nLbh1lbeBIm8O8rR+n/PXfABJq036UvC2jNEA0VyOiv47MG997XQQ0gz0tHHv8O2h6W0SgzZYKIR9aTwV1B54lHPBSdNP7r/UwAQgM9nHyuR8jTHHosjeNCBsKNYTavJ/Sl/8f1rh0bIkX74gLDPZR8uLPcbVWRY4hyYjQM5idKSy++x/GbW+2xKWh+fYgh/2jAhhJ1qOFveN6KomQD5CumbbPxWgr24vkLDgX0JyHZM9GMsbSVr5vxgU1AI70QtZ/5Ee0nt49JL4Xxp63ifRFW6ZVhPJvhdmg5irS7HFTOdDLLSSOBDTDyEgsx8HToTZO9XayLH76pqEUSWJVQtq0ZoSmikp3LyqCDgJkYUaPTBUeTjPARuIQgFeo3JicdcljXQsWOBNZ4EwkrGmoQmBUJp6+UjWNR55/nVcqqsmUzczVTPh8Yf70x8f4w1+f5PdPPA2Z4yuM6gxmclbdSc6qOy/5WmkLbsCZWUz13ifoqDxMuPwp5LiCkcJQ4W4msWA5mUu3Tnj815LaA8+gyQaU/PM0dowxKGkrQWei6fh2spZti2rvcLVpKd2FpoZHBTQAkqJHydqI6umk6cT2EZ2WaKjhIMee/A98g/1DBqTpgITwduJvPsSxJ77Lmg98N6pPV+q8DVTvfQK19WhE12gogJEcudBVhnA1IjmyR+0jhIboqSQ+d/GME7gTmkY44EExRc8eRZzPYwl63ZHthwpzZ1LmzmCJmfBvd5bRzAY1V5GugBeApHGmUuKHtGqHt5sIIU3jdH8ng6EgiSYrRbFx18WT9EQYCAX5Xul+EoWem0kcqakJIzhAL3voBSLt5NNVJNzmG+Tl5moOdDbjU8OkmW3ckp7H5pQc9JOQ0tfJ8qR/bP97vJRXK6q5hUTytHNFgytUOztED59433v56WtH0MfYJnnk6JjtSSy88zPk9bTSePw1OqqOoIWC2OLTyVz7CVLnbbiq9gGXSzjoo7PyCHLqilGigcPI8cWIjhLaz+wnd80912CEo+muO4UUmzkqoBlGkmQkezbddacueoyOs4fw9ragK7pnlCidZE1Gyt9K+MzTNJ18g4IN7xqzr8EcQ/GWD3Fm+29Qg+4hF2wz2kALSDJq4x4Q65EcOZGi8sAAausRhL+P3NWfvvI3YIqRZBm9xY7q64m6XggN/P1oajxHHvsWrpZKAOxpc8hecRtJc1ZezeHOMsXMBjVXkZihansXYWxR3vpBVLTztrsUO1rreKyuDPeQ2BRAmsnGxwoj9R/XO7vaGwioYbaQPqpIWIfEBuJoxk+M2cQnCpdNy+ufdfXw7ZJ9KBrMwYoFhTZvgP+uOsmhrhb+ZeE6DNNUICmE4I9HTpGPlbwLdIX0yGzQHDzmbmX/q89x67vfN2b/TVuWXbZbtzU+jbm3fIS5t3zkssd/LQn5PSC0kbb0C5EUPZLRRsDTf1XHNR5C08b12AJAVsboIF1Ix9mDSLbUqCq7ks6E5Mil/cz+qEENQPrCGzHaHNQdfB5X414AFKOF1MWb8fZ10NuwG6nlEJLOiOZ3oRgtLLj7H2ZsfUf6wk00HH0VkbhgTH2Y6K1CBAfpqT8V0WdKXw0SuPvrKXnhZ+SsvpuCDe8ec8yg14W3rwNFb8SWmDmjMjuznGM2qLmK5MU4STFZKfW7ScM4RqG2BDdmWTehqadXW2r4XfUpCrGylXhi0dFFkGN+F98pfZuvL9rIvMtszZ4pnOrrIH2oBfpCJCQKsVIe9FyRl9R4hDSNH5YdJE7Ts43EEb+nhUQ6xV7p7+TZxrM8lDN+XcuV4PYHaOh3sYWxn6GHMCEE8YqJwYbyca0S3qlEDCkVhL8XYsfWQAk1hAgMYIoyFXMtcKQVMHh6b1TjTyEEwt2EI33OmOXnurpMBL0Dkbbm8TDYCA82X3QcCbmLSchdTNDrRg0HMVrsyEOK3QNdjXRVHUUNB7HGp5FcuHpG1tIMk7V8G+1n9hOoeRUpaRFybCaoQbTeKrSuMgDk1OUoyed1TCbMRe0spf7QC8TnLMKZEbGB8Q/0ULnzf+msPjqiIWOKTSRv7X2zitgzkNmg5ioiSxJ/l7eAH5Uf4i26WY4DB3oGCVOCm9MM8P6cBZd0n/apYf5aW8ZcbNzAuU6YNEwkY+RF0cGfakv53rKbpvuUphVNiCiGC+eIKPlOz2sf6W6lPxTgFlJHApph0jBRjI3tLbU8kFWMbhqmZOShY6rnCSV2EOAI/bQMOaKjwt633mTp3e8nr2julI/hekVnMJFcuJqO2lJEXOGYaR2tqwyhqaTMW3+NRjiajCU303RyB1rL4VF6MEKIiJicr4/MZbeMbB+tq0uSFYSsQ9O0ke/O+QhP54QVdg2WsSKTMYlZxCTOzLq1aBjMMax8z9epePP3dNUcRGs+AESyT9b4DLyeAeSkhWP2kxMXIHqraT75Bs6MYgKDfRz5yzcJBgPIaSuRbamIsI9Az1nKX/8vgj43OStn615mErNBzVVmTWI6ny1ewf9Un+LxcCt6ZEJoGGWF92Uv4K6MsW7GF3K0uxWfFmZpFAE9BYlFxLJjoItW7wBpluvX5bfIHs8L/T0E0TBECW/q8VFkv3Jdl2hUD/Rhl/TEiehTgTmYKQsP0BPwTdpSYiLEGA0sSk2mut1NkbBFskN04MTATcRjR08PQUpbO/j6++/i2396Hri6yq4zmbx199Nddwq15lXk5MWjup+07gpyVt2FKWZsa/y1wBqXxtybP8KZHb9DeNqQ7DmRziV3I8LbQ966B4jLjGQER3d13YJkS4mcV3cFous0Wu0O5IJbRx1fG2xHuJvIWPOxa3B21w6jzcniez6Pf6CHwa4mZEWHPW0OB//0VSRbWtTaw4g/Wjqu9joAag8+RzDgQ5lzF5Ih8vuScCLHpKG2HqF67xOkztuA0eq4mqc2y0WYDWquATckZ7E2MZ2jPe10+73YDUZWxqdinqA5Y38wgAGZmHE+vrghKf6+oP+6DmpuTs3hucaz7BU9bCJhxH9JIChhgA4CfCQ9ur/RlaKTZcJoCERUI8vQUAZlOqa+hvn4mmV89tlXOUIf1XhJwsgdJI+8D8kYKdCsvBDo4jff+jILP/3zaRvL9YbFmcKKh7/GmR2/w1W/a2S5zmglb+PDZK+849oNLgrpi27ClphJ47HX6WkoRQhBXHohmcs+Tvx5Oiy1bz8dvasrfSXojGhtxwjV7URJKAJJQbga0HrO4sycR+q8Ddfo7K4tppj4UQGsrNMjwqFxtxdqEEWnRwuHIq3h8fNGAprzkZMWoXVX0Fa2b7ZLaQZx3QQ13/ve93jmmWeoqKjAbDazbt06vv/971NUNPN0BiaCXlZYOwnNk/NxGEwE0XATIpaxgVAvkcLh6dZumW7ijRY+N3clPy0/QrvUSr6woEOiAR/dBLkvs3DaWt+XOpN5tvEszfjJZOz7WImHDHMM8cbpe4+3FRfw+RvW8JM9BwHYRPwYY00DMks1G2+cOkp2Wz3OvEtn+t4p2BIyWPmerzPY04KnpwWdwYQjo3hGyuMD2FMLWHjn+EF6OOijs/ro+F1dCXPROk6h+NpRa+qBSBCXuXwbeevuR77EtPY7haT8ZdQfeQURDoyZmhRqEFwNJK64jaBvAC0cRLFGr02UdEZkkx2fu+tqDHuWCXLdfMt3797Npz/9aVauXEk4HOYrX/kKW7dupby8HKv1nZV2X5mQilnRcUJ1c8MFjtgqglMMUBgTR6plalp9ryVrEzNIWx7DKy3VnOjpQBUac2Lj+Pv0fBbHTZ8Lb7E9ngKbkz2eXm4ViSQMteGrCEpwU4+XT2Utn/b2+U+tX0lY0/jFvsOkRHH5BkaWL4sPUe0LjagKzxLBFp+OLT7yACGEQA0HkWXdddGefj4h32Ckq8vsiLpeUvTIxlhSi5aTueRmhKZhdibPqCBODQVoO/M2beVvE/INYI5NJG3hjSQVrLgqn0dPfQl9zWcRaohw3RsRbaChLIwIelAb9yLLMhmLN6MzmkGSEIGBqMcSmooIedGbrv/r7N8S101Q89prr436+/e//z1JSUkcO3aMG254Z1WgmxQd78tbwG+qThJGYxGxxKKniwDHcdErBflM/uprPcwpI9tm5/8ULZ/y41a5eynr70IQCWKKY+PPCY9JEl9csIZvndrH0742kjFiRRnxbbo/q4hN0yD4J4Tg+Z37ebaji/KObow6HUUJkS6dQdSoU46DqABYbLEQHLP6qiKERkfFQZpOvsFgdxOyoidpzgqylm3DGn/txB7VUIDG46/TfOpNAgM9SLJCYsEKclbdSWxy7jUb12TQm2MiBcG+PoiJ1tUVRAsOYIqJwxp/eVng6STg6efYE9/D29uKFJuBZHDg62qn58WfE5+ziMX3fH6k22o6qDv4PDVvP4lkSUCKL0T01RAufxIsiREbEG8nisHMkvv/aWS6KiFvGT0tZxHxhaMUtgFEXw0i5COleO20jflShPweQr4B9OaYq+6WPlO5boKaC3G5XADExU1PoehMZ2taHjpJ5q91ZTwTah9ZnmGO4auFq5hrv77buaeTnoCXH5cdpnKgFwMyEhBAI8dq5wvzV5Nijjx5xRnN/N8VWzjc3cqBrmZ84RBF1lRuTs0hyzr1Yn9CCP71YAVvtNWhsyaixRSCGqCrsQ6QOEgftzBWAfc0A8QlJFG0eDklRy7etjudCKFR9sqvaa/YjxSThhQ/H1UN0FpxiNayvSy59xHic8Z2nEw3asjPsSf/A3dHHZIjDyVrHiLko6uxgq7qYyy+9/Mk5I6vzDxT0BlMJM1ZRWf9aUTcnChdXeWgqaTMXXeNRnhxTr/yKL6BviGBwHPt9Jq7mZ76t6je9ySFm947oWNpapi+pnKCXjdGWxzOzOKL6sb0t1ZR8/aTyClLkJOXRIKYtJVovdWRIutAP1krbidvzb3ojOd0ofLW3kvPX/8dtfYN5LQVyJaESPDYU4XWdoyU4nXYEjImNGafq4vGY6/SXnGQcNCH2ZFMxqLNpC/aNOlsmqenlZq3nzrXZi5JJOQtJX/9g9dVl9p0cF0GNZqm8Y//+I+sX7+eBQvGt2EPBAIEAoGRv91u99UY3lVjc2oONyRnUe7qZiAUJMlkoSDG+TejKDwd+NUw3zy5l0F/gFtJJAszEtCMn/3ePr5xci8/WLGFGH3kIqOXZdYnZbA+aWIXrithd0cjb7TVRaTq4wtH1HlE6nLk+reoHWjjEH0sJhYTCl5UTuCiGg9//5lvoOiu7c+5pWQn7RX7UbI3ITvPZT9EyhLU+p2UvPhzNn7iZ6NuGleDuoPP4+6oR8m/Ddl6LigUifNQ63dS+vKvuOGTv5jRuivD5K27n+764a6uJUNdXd5zXV2r754xXV3nM9jdRF9jGUr2jaMCGgA5NgORMJ+WkrfIW3c/OsPFbRday/ZQtedxQl7XyDJjbALFmz9IYn50Q97mk28gGWNHAhoYsqFInIucUIRa8SxBr3vMdzM2OZel93+Rsld/TaDyRTTFiNAiRcZpC26gePMHJ3T+7o46jj3xXTQBkiMPyWDF7+mkctef6Kg8xLIHvjTh799gVxNHHvt3NEmPnLYCyRSHCLjoaTlD71++wfJ3/yv21PxLH+hvlOsyqPn0pz/N6dOn2bdv30W3+973vsc3v/nNqzSqa4NOlln0N6AefLXY29FIu9/Du0jDeV6RdSZm7hB6Hgu28lZbPfdkXX2l1JdaapBjM5DjR7+2pOiRMzeglT9JiTTAaQax6vQMhIPo9Qbe/7lvcPMDfxf1mA09nstSFZ4IashPx9lDeHpakXUG2s68jeTIGRXQAEiyDiVjHeEzT9J25m0yl9wyzhEnhxCCvqZyWkp24u3rQGeykjp3LclFa1GGglJNDdNcshM5bs6ogCYyLgUlfTXhM0/RcfYgaQtunJJxTSfWuFRWPvw1yrf/Dnf9zpHlOqOVvBseJnvFzOrqGqavqQKGLB+iITtzCXeWMNBZPyJ6F42W0t2c2f4bJGceusxNYIxF+HoJdpzi1PM/Zsm9XyAhb8mY/Vxt1ZEpr6ht3HKkjbutJuprxmXNY8PHf0pP/SkGe1rQ6U0k5C+dcPAoNI1TL/ws0oafe8u5DFvifCRPB66a7dTuf4Y5N75nQscr3/E7NMWMUnAbkjKU4YlJRTjzUWtep/z137Dmg997xz7cXndBzWc+8xleeukl9uzZQ0bGxZ+ev/zlL/PII4+M/O12u8nMvLjT7SxTixCCs+5eWrwDmBQdS+KSsF7DwsW9HU1kYsaJHoGgBT9N+BEIEjGSg4m9HY1XPagJaSoNg/0omfOjrpcMVnQxSdyxOJNNmzfTNegjJi2Xux98NyV9RFUVHrZKmA46q45Q9tp/oQZ9SKZYRMgPahAla+O445csibjbamAKghqhaZS9/l+0l++LPPmbE6Cvl77Xf0P9kZdZ/q4vY7Q5CXr6CfsHUdKiXyskYwyy2clAV+MVj+lqYUvIZNV7/43B7mY8va0zvqsrwpCI5Lg32kvfgLVwiKo9f0Vy5qNkbTyXcbEmIeVuQa3dQeXuvxCfu3jMDV1SdAg1PP7otPBFu8MkWSYhbykJedEzQReju+4kAXc3SuFdY6YMZWsyIr6Y5tKd5K17YCQYH4/BnhbcbVUoOTedC2iGx6jokVOW4qndjrutBnva9MhdzHSum6BGCMFnP/tZnn32WXbt2kVu7qWL+4xGI0bjzE8p/61S5e7l/1Uco9l3rnvAIMnckVHAQ7nzp1XjZTwGw0Fi0TFImNfpopsgNhR0SJQygB4Jc1C9qmPShKDBE0mli4t5/GgaVpORT3/wYaTYeNqJQdIZ2GiHvfX9V2ewQF9zBSUv/gLJnoUufwWSMQZNDaGW/hnERd47MdYG4HJpOPIS7eVvR25uzvxzKry+Pnx1Oyh58ResfM/XzxWeqtErqIUQCDWIHKVFeqoZ7GlhoLMeWdETlzX/igs7bQkZE67nuNY40otAaEOO3zlj1mv9dcg640XrQXrqSwj7B9Hl3DI2aJFk5KSFeGteZ6Czfkzxd2LuEhpPvoFQV41phxdqKNLGvXy0aOFU4W6vRTJYkS3jtIbbs1C7TuNzdV7y8/T2tkb2sUWXshhe7ulrnQ1qZjqf/vSn+ctf/sLzzz9PTEwM7e2R4li73Y7ZfH3rsfwt0uhx8c1Te7FrOu4giTRM+FApEwM811SJTw3z0TlLrvq4Usw26rzdvIyPMIK7SCZ1yIerjxB76KErHKTNN0iqefpbNd9sq+eZhgo6h5zZtd5q5PiiMRdt4XcR9nRx07J7z50LA7SHI4HN1aT2wHNI5rhIfcRQcaas6NGsyai91UhxhWPH7+tFeHumpFBYU8M0HH8dOb4QOW70hVsyO5HT1+CqexNXew32lHxikvMY7K1CcuSOHZe7GRH0kJg/PaaoAN7+Dspe+y9cLWfPjVPRk7FoM3NufM87Qj8mJikbR0YxrtYjSGYnkvFcob020IbWVUbm4s0XrbcKDNfQGKMX6Q8bmAYG++ECtYdhKwq1YVckENZF6nZE2I/auAdJgozFWy77/C6GJCughRFCi17MrIXPbXcJlGHtsZAXdFFqj0KR64juOtcouxKuG6GGRx99FJfLxaZNm0hNTR359/jjj1/roc0ShSfqz2DSZO4kiQzMyEhY0bEKJ2tw8nprLR0+z1Uf15bUHLoJ0U+YbUPB1rDOjxM9t5OEAZmXm6unfSzPNFTw68rjxATgTpJZhxO8XWjtJ0dlbETIC027SY5z8OCma9uqHw546Ws8jRxfOOYCLSctAE8nWttxhHYuYyMCA6iNezDGJpBYsOKKx+DpbSXkdSE586Kul2IzkBQDfQ0R48Lc1XchBlrRWo9EnsoZ8lUaaENrfht7ehH2tOkRLQwM9nH0r9/C3dOOkrMJ3cL3oZv3bqTEBTSd3EHZq79GiGkyMLsCNDVMwONCDfmn7JgLbv8UJouVcMVzhOt3orYeJVzzOmrNazjSCynY+PBF9zdahwqM/f1R1wtfX2S7KEalZnsii+/5PJKvi3D5E4Rrtkf+lT2B5Othyb2PYIqdno7R+NxFiHAA4W6Kul7rrcYUm4jFeWndLWd6ETqTDa37TPRjdZ9B0ZuIy776XYYzhevmEWEm/vBniY4vHOJIdxtrcIwxgwSYi41juNjX2cQD2eMXBU4HS+NScOpNGEKCeMZmOPTIFGJlX0cTH5vGTFJPwMvj9WdYSiyriFyE0zERQnCk4yRaTwVSbCaSGkC4m3GYjTz5+Y9gMkTGLNw9SLFXv8slHBy6yenHPlHL9ixE2gq01qNovZWRzhw1gBhow2BzsOz+L01JVkJoQwHfuC28UsQ7aeiakTRnJYU3vZ/KXf+L6K0ESwKE/Ah/HzHJeSy++x+mraiy4ejLhIJ+lKJ7kIbfM0WPkrIEyRBDx9k9ZC2/bcZ0qwR9A9Qfep6W0t2oQd9Iq3Dumnuwp1x8jCG/h9ayPfQ3VwASzsxiUudtHJlmM8XEsfp936K1bC9tZfsI+tow2xOJX7wBn6uTI3/9JpKiIzF3MemLbhoTnMTnLERviSXccWooS3juMxNCQ+sswZqQSUxS9GLk+JyFbPjYT2kt2x0pXAbilt5A6oIbMJinz07GnpKPPb0Id/NB0FlGCtaF0NC6ziD6a8nZ8qGLtqQPI+v05K25l8pdfwadGTlxPpLOGGkz7z6D1lVG3roHLtlBNhmEEIR8boSImJ3O9ALk6yaomeX6YTAcQkPgiGLhAJHAIUbS0R+cuqfAiSJLEukWG16Xd9xtLCh41RABNYxxmqYGdrU3okNiyQWmpMuwk4WZneFu+vtqWJqewtYV67h/4VwKslIBUOtOo+SOL2UwnRgssSgGM2KwA2LHFt3LzgK01mM4UrIBCUUXQ+KabaQUr5uyC601Lg3FaEG4GsA6tvNPDLYjwn7s6eeyL1nLbiVpzgpaS3fj6W1F0RtJKlxFfM7CCd1MLgchBK2n9yI5C84FNOchOXOROk7QVr5vRgQ1Qa+bI3/9d/yDfUhxc1CsyYjgID2tlfT89d9Zct8XiM9ZFHXf3sYyTj33E9RwMFLXIQRdNcepeftpltz3hZGOJp3RQtayW8laFqlfaTz+GpU7/xxR9bWlQyjMwKEXaTj6Ckvu/6dRnVCyoqNw099R9sqjqEJFTlqIZLQjfD1onSUITyeF27500ZuuwRJDzso7r7qz9uK7P8exJ7+Hp+olVEsCkt4Gvi5E0EPW8ttIn8TUV+ayWwkHfdQeeBatqwzZYEMLRtSms1feSe6ae6ZkzEIIWkt3UX/0FXx9bQCYHclkLdtGxpIt0/a7uVJmg5pZppwYvQGdJNMjglF9kwJouEVoWn2TLkaGNZbdrl5UxBgvJYAWIsHW253NbE7NmZYxdPg9OCU9BjH2wpCAgRU42C66+NUDtxNvmfj79PDaHB47UD9tVgmyoiNtwY00n3orIgBnOheUCSFQ244jKToW3/159BOoSfL0tEaCDIMJZ3rRhBRlFb2BjEWbaTj2GlJMBnJM6rkxhLxorYewxmfgzJg7aj9TTDx56+6fxNleGUJTCQc8KEO1HhciSTIYYgl4+q/amC5G9d4n8A/2o8y5E8kYO7JcxBeh1r/F6Vd+zcZP/nxMts3n7ubksz9CmBPRZW1E0ke+ryLkRW3Yw8lnfsjaD/9fTDGjhVJ7G8up3Pln5MQFyGnLR26SIhxAbdjJyWd/xIaP/WTU9yh17nokSaZqz2MEql4eWW52plJ8/xdHmX/OFHoaTlN/+EU83RFhTDk0gNGgEFe0ivTFW4hNzom6n9A0umqO0Xp6Dz53D0arndT5G0guXE3e2vtIX3QT7Wf2Exjsw2C1k1K8dso0ioQQVLz5e1pOvYnkyEHJuQkAf389Z9/6A+6OOubd+vEZmbWZDWpmmXJMio51iemc6GyjGBsmRhfAleJGBTZOg83ARLghOYvXWms5hZtlF2RKmvHRiI8YdJxxdU9bUBOjMzA45AMuRwmsBgijSBI2w8zzcbKn5tF0/HXClS8iJ85DikmLCMB1VyA8HRRt+dAlA5rBnhbObP9vXK2VI8t0Jhu5q+8ma/ltl7xY5q27H3dHHX01r6HFpiNZkhDBQUR/HQaTjUV3f+6qX3CD3gGaS96k/cx+Qn4PFkcyst6I5uuNWrwohAYBF0brvKs6zmiEA96IzlDiwlEBDQzp+aStJFTxLF3VR0kuWjNqffPJNxBIQ23G576vkt6CkrsZtfwJWkreIn/9g6P2azz2KpI5LiIgd95nJemMKFk3Ei5/gtayPWSvuH3UfinFa0kuXE1/y1mCXjemmHhiU/Nn5A22pWQnZ3b8N5I1ETljLZJiQHM34+uvw2fvHrfbSQ0FOfncj+lrPB1pWTc58fZ20/vKozQee51lD/4zRqtjzHtzPkJoqEE/ss4w6WnfvqZyWk69iZyxFiXhvGyZIwetN4O2sj0kzVk5rtjhtWQ2qJllWnhXzlyO97bzQriDpdhJx4QXlTIGqGCQB7OLr1mmJssauWgfoZ8OAhRiRY9MHV4qGSRzqFNrOi+SG5IzeaG5imo8FDI6AAihcUYa5NaiAozXWCX4QsJBP2d2/A/EpCEZbGhdZdBxKrLS6ABJJuSLbgA4jLevnaN//XdUyYCSvSkyXRH2oXVXULX7L4QD3jE3wAtRdAaW3v9F2s/sp7lkJ77+GnRGC6mr7yZjyRYMlqm3sbgY3r52jj7+bYK+QSR7DlJMEu6BTkQoAD0VaAlzkU2jgwXRW4MIDpK2YPq963yuTppPvklPw2mEEDgzishYcvOI0afP3Y1QQ6OyXucjmRxIBiuD3S0kF41e11VzHGKzozqHS4oBYrPoqjkx5jPtbSxHSlwQXRBPb0aypdLbWBb1xi3JMs7MuWOWzyT8A72ceeN/kOOLIgHN0HnKzjy0uAJ6a3fQfOoNspZtG7Nv5e7/pa+5AiV/K/J5Pl+ap4vBujco3/5bFt/9D1FfNxz00XDkFZpL3oqoLksyifnLyV19F7Ep0YvrL6T51JuRTsL4ojHrJGc+UvcZmk+9ORvUzPLOIcVs49tLN/GbyhO85eoeWR6rM/Ch7EXcnn7tagiMio58m4O+QQ+DhHmDyPgsKCzHTjYWnqKN+Y6xPktTRa7NweqENPZ2txFEowgbemQ6CXCIfnySyv9Zf+WdQlNNR8UB1KAfXcE6JIMNkb4Kgh5Q9Eh6C2rTfppPvknu6nvGdV2u2f80qpBR5tx2ToxMb0bJXAc6M3WHXiBj8ZaoXSznE5kKu+GqBAUXQwjBqRd+RkgFXfH9I67PANpAK2rtDtSqFyF9NVJsBqghtN5KtM7TpMxdP+2Gml3Vxyh56RcgKRCbBZKEt+xtmk+9wbytHyNtwY3nJPrD0evchBaOiCtGEYfT1DDSRTKKkmJAU33RjnoRMT4iheDXcYNI6+ndICtjMlEAckwamj2bppNjg5qQ30Pr6T3ISQtHBTRApMg4dRldVQfwubsxX9CxFQ54OfrEdxnsbkZ2FqAkLkGEfHQ3V9Jd+00W3/vIhHzOBrtbkKwp4ygwS0i2VAZ7rp3P3MWYDWpmmTbSLTF8Y8kNtHkHRxSFi+zx6Me52V1N7sos5KdnDrMaO3OwIYgENX40XqcLp97E2sTpdTr+3NyV/FflCfZ0NHKAfvRIBNBIMJj5+ZpVFCdNvMV0Y46DvfX9Y1SFp5qBznpkSxySIZJdkmQdnFdXI8VmEOw5S9DrihqUhIM+OisPI6UsG6OuCiAnzUfrOk1b+dvkrLq6xZyXS39zBZ7uJpT8W0cFNBC5eYmEuYieCtTGveeW64xkr7id/A3vmtax+dzdkYAmJiOizzLkNC00Fa3lIOXbf4stMYuYpBys8Rl4eyojXXcX6vn01SHUEIkFy8e8hj0lj86GCoQQY/cTAjHQTGz+2BupI72Ivu4GSBrbfizCAcRgG45Fa8asu14Y7G5CsiSOUf4dRo5Jx9e0D00drWbsaqtGqCGU8SQLHHnQtJ++pjOY549W8K498CyenlZ0BbcjWc7V14iEYtT6nZx++f+x8ZO/uKRysaI3IgLRAtGh44V86PRT12E1lcwGNTMYvxpmR2sdb7bV0eX3YtMb2JicxR3p+Tiv0dTN5ZBqsZFqmX4hu8mwLjGdhsFCnm2qpAIv6Rjxo9GAD4tOz9cWrscwReq3AJ5wkG6/D6tOT4Ip0gljkBU+U7yCh3LmcaynjYCmkmmJZXFcMnkJgUsc8dog6/QINRj1BgaMKPfK4wgChnwDCE1FNsdFXS8pBmRjDIHB3sseoxACd3ttRMlVlonLXojFMX3+aP2tVUg6Y6SFPQqSIwetq4xF93w+cu6KHmdm8VURSGs59SYgo2RuGAloIFInI2esRQy20XRiO/O3fZK8tfdS+tIv0VoPR4wfdUaE0BD99agtBzHa4jjy2LdACOIy55K57FacGcVkLLmZjrMH0TpLUZLPdUcJIdA6TiECA2QuuXnM2LKW3Urvsz9E7SiJdDINq0JrYdSmfciyTNqCTdP9Fk0bis4A6vi/Y6H6kWRlbEZzODs1XnfR8O/ugiyWGg7SUroLKb5wVEATOZSCkr6K8Jmn6ag8RNr86HYmwyQXrWJg75OIkHdM554I+xGuepJX333RY1wrZoOaGYonHOSbJ/fS4HGTh5nl2HEHw7zWVM2u9ga+ueQG0i3Tp63wt44kSbw3bwHL41PZ3lpLw6ALg6Ln4YRcNqfmEDtFjs1dfi9/qT3Nge4W1KGLUGFMHA/lzhsxIk00Wdh2BdNxIhwcV1V42P9pqkwtE/KW0njsNcRgW6RA+PxxCIHWW0Vs6pxxLQD0JltEQ8bfDxfsDxHJehH0YLBeXk2Mt6+d0pd/xUBH3dBNQYCAxDkrmH/rx6fFIVySpKEbjCCqh9HQ526OTRhXQ2W66Gkog9jM6PUukowUm03vkEhhctEaAp5+qnb/lXBPJbLZiQh5EcGISGYgpCI7It/TrqZqOquOULjpfWQt30bumnupO/gcYqAZyZ4DQiBc9QhPJ/nr34U9daxkf0LeEnLX3EfdwWcR/bVIMRkR5V1XPWhhFt39OYyX+T2YCSQWLKetfB+at3uMRYIQGqK3msT8ZWNao2NTcpFkBa2/HiVpbDeX6K8HGCMYGRjoRQ36UGKiZ5glYyyyyY6nO7oI4PmkL9hEw9FXCdfuiATEQ0GS8PWiNr2NzmAiffHmSx7nWjAb1MxQ/lhTSqtngPtIIeE8kbhl2Hk51MFPyw/zf5dvnpEV/9cTRfZ4iuzTI2LX5ffyleM7CYdUVuIgGSODhCkbGODbJfv4/LzVVzzFlcIA7Vy94NaZOS9iO9C0D7I3IQ/pxAg1hNZ+HDHYTu6W8d2GdUYLSQXL6WqqiLSEX3Cz1XoqEFqIlLnrJz22gKefo499m5AGSu7NSLHpEb+hvlq6645y4pkfsuKhr45b63O5OLPmIfY+jnA3I9nHdvSJvlr0llis8dM7nRmdcQKtYaQRq0kAspZtI7loDW1l+/D1d6CGQ7Sf2YecOB85beW5bErKErS2o1Tu+jOO9ELy1z9IbEoeDcdew9VyFABHRjHZWz8Q1TV7mPz1DxCXNY+mE9vpb6tBVnQkLthIxpJbsMZFz3xdLyTkL8MSl46vfidk3xiZipIkRMiH2nIIEXCTvXKsq7rBEmnPbq88grClIJ0XEAm/C639OHE5i8a8PyPZ0XGyQ0JoiHBg3Czq+ejNNpa/68ucfPZH+CtfiBSKA5q/H6MtjiUPfBmj1THh9+JqMhvUzEAGQ0H2djSxlNhRAQ1E6j7W4OQVTyeV7t5puyHPcuX8ubaUcFjlPlKwjLS1G8nDwpt0859nj7MsLgWjMnaaq6HHBGdrcBZde1G285EkiSX3fp4TT/+AwaqX0cxxEQ8abzdCC1N40/uj1l2cT966++n+yzdRa15HTlmKFJM60hKudZaStXzbmALIidB0YjuhgBel+L5zKXNJRoovBEMMrprX6K47OeU+T/aUfGJT5zDQchDJGDviQSSEQPTXofWeJXfdg9fE48mZMZfBU28htPCo6aeR8bkaibtAyNFodYzUM5W//hskg21s27UkIacuR7gaaDq5g/nbPkli/jIS85eNKDlP9IHLmTl3xncyXQ6yrLDswS9x4ukf4Kl6OfK9UAwIbzeyomPBnZ+JmsECKNr8gYgBauVLEdsPcxwi4EK4GjE7kpm/7RNj9jHanNiScvD0VEY68C6sb3I1IsL+S/4+AQIeFx1nDyGEQNYZUCQVa3w66YveQ3Lh6hntVzZzR/YOpsnjJiQ0cqII1wFkYEKHRPVA36SCmpCmccbVjSccIsVsJdfmmKIRXztUoXG8p51TfZ1oQlBkj2dtYvqU1sNcDgOhAAe7WlmN47yAJoKMxCocPKa2cri7ZVJ6Pf6WRkzp10bfZxijzcnq93+b7toTdFYfRQ36scavIn3hphH/nIh3lRT1xmZLyGT5u79M+Wu/wVO7fWS5rDOSu+Y+8tbdd1njai3bh+TMi6reK8ekolkSaCt/e1rMKxfd9VmOP/UfeCueRYpNR9JbEd5uhK+X5OK15Ky6a8pfcyJkLNlC04nXUZv2o2SuHzFNFEJDaz2KCLjJXLZ13P37W6uGCofHZrckSUaKyaC/pfKC5bPZ42FMMfGs+cB36akvoav2BFo4SEzS1lH2EdHQGS2seOhrtJ95m+bSXQQGGjBY7KRtei9pC26MWo8lSRJ5a+6h5IWfReqiUpYiKYahYu0WtOYDOLPmX7LbztPbxrHHv0Mo4EFy5IItm7C3i/7ms2iqSmL+8tmgZpbJIQ9dFMJEb2dUAQ3QTfDiIYRge2stT9SfwR0OjizPtdr5eOFS5sRGL9qc6bR6B/he6X7ah9R5ZSR2tNXxx+oSvrRg7TXNYnX5vWgIUolem2NHj1XS0T4JU8/uig4SiiOmd8NWCdH8nx5em8Mf3yzFFPZgjrl4W/TlIskyiQXLRz31aeEQDcdepfnEG/hcHUiygi0hk/z17yIhb3T3iz0lnzUf/B7utpoRReH4nIVXVDwb9g9CbPQnXwAMMQQvoaFzuQz7GrVXHDgnvpdRQPqim4jLjq7FcjWwOJKZf9vfc/qVR1EH25Ds2ZGaJncTIuCm8KYPjJstgEjgcr456RiENiF36XcykiyTkLfkotNw0VD0BtIX3UT6opsmvE/E5+wDVO76M1pvFbI5DhHyIQJu7OlFLLrrcxfdXwhByYu/iEzhFt8/6gFB83QyULud6r2PU7zlg5M6l6vJbFAzA8mLcRCjM1AZ9pAY5aZYgwcNwaK46K6umhAc6GrmtZZa6gf7EUBAU8nBzFZSsaHQToDjHhffPLWXby25kdwYx/Se1BTjC4f491P70IJh7ieFRBF5n1yE2BPu5Tslb/PDlVtIusjT0PmoQnCqt4O6wX70sszSuBQyrbGX3nEcLENy/4OoRFO7CaIREOrIdlNFQ+UZHvvVDziyc/vIDceatYSETQ9hjR9bmDtVqOEgJ57+Af0tZ5Hs2SiZ6xEhHwM9Zzn57A+Iy17Aknu/MMoGQZIk7GkF2NMuEohMAmNMPH5fd9R1Qgjw92JOv7RGx+Wi6I2kL9xE+sJN0/Yal0NK8VpsCZk0ndxBT30pCIEjfxGZS2+5pEllfM4ivKfeQmirx05faWGEq4GExZumcfSzTJasZVtJLlxJ6+k9ePra0OlNJBWtwpkx95LBtaulEk93I0r+VlCMaL3VaH21EA6AwQoxGbSU7qZg47uvSvfe5TAb1MxA9LLCHRkFPF5fTjwGirAiDRX7teLnIH2sjE8lNYoUvSYE/+/sMXZ3NJKOiSXEEECjEg+N+CjCRjwGsrGQhonntA7+UlfGvy6afGHmtWRPRyO9QR8Pk0bsecaZdvTcSiJ/1Vp5raWWD+SP1cC4kCp3Lz8tP0xnwItZUggLwZ9qT7M8LoXPzl2J9TICj2STlVyrnTLPADmYRz6/YSoYREWwOmHqAo2aspP8+8fejSoZkNNWIZkcCH8vnrYKDv/l31jx8NeISZyeqauGwy/R31qJkn8rsi1lZLmctAC17k16G8oo3/4bFtz+qWl5fYCMRTdRtedxRFIv0gUt46KvBuF3zbiA42phS8hg7s0fnvR+GUtupunkDtSG3RGdmyHNFaGGIro7WpiMxWPbtWe5thhtzssytnS1VUeK901xhKteAl9vRPHbEofwdoMvIrUw0NmIM2Os2vBM4NqroM0SlXuzirgxOYvd9PA4beygi2do40U6yI5x8Oni6MVeu9ob2N3RyGYSuJNkFmNnFU7eQzrZQwWqfiLpZD0yC4nhVF8HfRcRWpqJHOxqJRPzqIBmGAMy+Vg42HVpxcs27yDfOrUPKRAp6H2/SOeDZHAT8Zzu7eT7pfvRLkPVVJIkHsqdRyt+dtLDAGEgYoFQiptD9LMlNWdEs+ZKEULw62/8E6piRSq4EyVxLnJMKkrifJTCu9AUM2d2/O6yj6+GArSe3sOZHb+j4o3f01l1FG1oWkLTVJpOvYHsnDMqoIEhfYyMtYCg/cx+vP0dV3KaFyV90WZs8emoNa+jdpQi/C6Etwe15TBq0z5S5q4f0wY7y8WxOJJYfPfnkAbbUMufIFy3k3D9TtTyx2GwlUV3fw6LM+XSB5rl+kCWI9IMjXsh5EVXeBe6gtvQZa5HV3j3kLGlFFFLnqHMZmpmEP1BP2+21XO8p42QplEQG8dnipZT5uqmy+cl2WDgw0mZLItPRRknjfhqSw3ZmJnD6GkXBYmNxPFnmqnEwyIiUyvx6BFAfzBwXQn6+dUwpovE5GZkAupFagGGeKG5ElnA7SRhGDqeAhRiw4LCy+5OSvs6WTzOVN/FWB6fymeKV/DbypNUay3YJB1+oRJGsCUlh48WLJn0Mcfj5PFjNFdXoORtHdMmLSkG5OTFuOt3MtjdhC0hc1LH7muu4NTzPyPsH0C2xCM0leZTb2B2JLP0/i8i6wyEvG6U5FVR95eMMWByQMBN59lD5EyTaJfOYGL5Q/9K5a4/037mAOG2SGuxzmgle8295K25b7aI9TJIyFvKuo/+iJbSnfQ1nQHAWXwn6Ys2TZkr9Cwzg/jsBVRp/4sYaEHJvmFUO7kkSUiOHETifDqrjlC85YPn7DVmELNBzQzhrKuH75a+TVBVycKMAYn93iZ2tNXxofxFfKro0m14qtCo97i4geiFv2YUUjDSwTkdg15CANgNM+/LeTGybLEc8bSgiegu160EyLhETYwQgn0dTcwTtpGA5nzSMREnGXi7q/miQY03HKLK3YsqBLk2+6jg8IbkLFYmpHGwq5l2nwerTs+axPQJ1/pMlJqqKgAkW/RxDqvdenrbJhXUePs7OPHMDxDGOHRzt444OGvebvyNezn25PdY/tBXIxtrwajHEEKAGgJZRyjgnfBrXw56k5X52z7JnBvfy2BXE7KsEJOce0lZ+Fkujikmjvx1D1zrYcwyzdgSMjE7U/H1tUdEFKMgO/MId51moLMBR3rh1R3gBJgNamYAnnCQ75Xux64qbCUF01ALsCoER+jn9zUlZFljWei8lNR7pHJDHadrCiIdVfJ5/y9lgIWOROKuoywNwC2pubzV3kAJbpYwWnW0Fg+t+HkobdE4e0fQAL+mEkP07g0JCauQ8YRDUdeHNI2/1pWxvbWWwNBUjIzE6sQ0PjZnyYgqsVnRcVNKzuROcJLYYobqq0I+MEYR4wtFgonJFvc1HX8dgYySu2VUBki2JCDlbiFw5hl660vO6WM48sbqYwy2QSjS5WVxTD7jdTGE0OipO0VzyS58/Z3ozTZS564jZe464rLmTelrzTLLO4G0eRuo2f/0+GajQ+39EdmGmcdsTc0MYHd7Iz41xBYSRgIaiEwZrcZBAgZeaq665HEUSWKRI4kqvIgogU0/IToJko6ZZny8TAduKcx7c+dP6flcDQpi47gvs5BD9PMqnVThoRYPb9LFG3SzPjGDNZdQ61UkiQSDmQ6iZxhUBD1SiOQoWRUhBD8rP8wrzdXM06w8RBp/RzprcXCyq51vnNyDb5xgaDrYeONNWKw2tO4zUddr3WfQmWw4M4onddz2igNIjtzoMvvGWKSYNDqrjpC35h7EYDta29GIo/Pw63o6URv2gs6EpDOQXDx1BoWaGqbkxV9w8tkf0dPWgE+y4nIPcGbHf3PoT18lMNg3Za81yyzvFOJzFkaUuN3RaxI1Vz2yzjBtTQdXymymZgZQ2t9FKiasUT4OCYkMTJzs7eA7JW+jSBJL4pK5ITkrajvwXZlz+Hb/2xygj1U40Q1NzQwQZjtdSMBuegDIMMfwtaLVFFynOjXvyZ1PpjWWF5qqeMsTaeVNNlr4UMYibk3PH9H7uRg3p+XyVP0ZFhBD/AXqzaW48QqVzSmj/XqaPG5eaq7iUE8rC7GRjJE2/JhRKCaGdEw87W1nR1sdd2dOf3o2hQHaTTF86h/+kR9+99ugMyInzI0Ib4UDaF3laD1nyb/xvaNaqi+Ft7+TkH8Q2XGR7I7OhBoKkDRn5Yj/j9Z9FsmahAj5wN8Lsh60EHO3fWJK20DrDj5HV/UxlJzNyI5zn5Hw9+Or3U7JS79k5cNfm7LXeycSDvpoOfVWRABusA+DOYa0+REbA8Os99zfJLEpecSm5DPQegTJHIdkONdlq3k6EV1lpC+4cVp81KaC2aBmBiCEGDdlVo2HU7iRkejrcxNG8Lvedp6sP8O/LlpP3gXiaovjkvlIwWL+p/oU1XhJxUgAjVb82PVGPpy1GIteT4rJSmFs3IQLJ1WhcbSnjVO9EeXeObFxbEjKwHgNlSUlSWJjchYbkjIZDIfQhCBWb5hUMejt6fkc7GrhRU8HC4ghGzMBNM7ioRoP92QWjtTm+MIhflFxlCM9beiRMCBxmkFKGRw5ngmZlTjIxcKbrfVXJagZ5nNf+BJnW3t46Y//idpZimS0IQIDEVflxXeQtfy2SR2v6cTrgIQYaIXksVN5Qmgw2IYtM5J9yV//IPE5iziz47/x9LSMbGeNT6Ng/QNTquSrhoM0ndiBnFA8KqABkEwO5LTVuOrfwt1RN0pBdbC7icZjr9FVcwJNDROTlE3m0ltImrNytoj4AoK+AY49/h08vW1IjmykxHQCfje1h1+k5fRuVjz8tcuys5hJuNtraT29G5+7G4MllpS564nLmhdVQfmdxMI7P8PRx79NoOJZJHs2kjE2opDtbsKeVsicGx++1kMcl9mgZgZQZI/nVG8HftRR009dBHiLbvKxsJH4kWLWQcLsCHfznZK3+fnqW8foqNyWns8SZzI72uqoG+jHocjcEV/MhuQszJcRhJyv3BsnGVCAN9vr+XNNKf+0YA3zHdHk5a4ekiQRM1QIGtJU9rY38VZ7Pb1+H3aDiRtTstiUko0pyrmbdXq+sWQj/1tbxp6ORo5pLgASjWY+lrWEramRG6IQgh+VH+JMXzc3EY8eme10kT3koJ6AgX7CnMLFXnrJxUJv0H/13gRAlmXe+w//yp1/91F++ejvEN5+rM5ECtZt4/CxxknftDsqjyDZUiMS6/31yI6cUeu1zlJEyEvG4i0jyxzphaz90PcJ+T343d0oBjMWx6VqwSaPp7uZcMCD4siLul6yZ4Kip6+xfCSo6ao+RsmLPwedGcmRB4oeV38L/S/+nLSFNzH3lo/MBjbncfatP+J1daMrvAvJfO7hSQQXE6x5jdOvPHrdZsKEpnFmx+9oPb0rkokwxUF7I21le3FmzWfxPZ9HZzBd62FeM8z2RNa8/zu0lLxFa/nbhFxdmOyJZKz+KKnzNkwq43u1mQ1qZgCbU7J5quEMu7UetpA4MmVUghsbOm4iYVSHjw0dW0ngL+EW9nQ0clv6WFXQVIttQsJzl8KnhvnWqX2oFyj3ugmxV+3le6X7+cGKLVGFAC8HVQiO97RR0teJhqAoNp41E/Ry8oZDfLtkH9UDfWRgJh09/UE/v6s+xfbWWv5t8Q1Ru7ysOgOfKFzK+/IW0OYbRC/LpFtiR7XNV7p7OdXXyVYSycHME7SRgYlbSRwR1nOiZxMJSEhU4SFOd20uivEpaRRtex9O8/kXnsZJH0cLBcCZjaQYUOt3oTlykR1ZoGlofTWIgRb0VidBr4va/c8gyQpxOQuwp+SjN1kv6m1zpVzaNDHyqQzXlgW9A5S+/CuIzUTJuuGctH/yIrSeKlpLd+LMKCJ13oZpG/P1xLChoZy2clRAA0QMLlNX4LpMiYCZQN3hF2g9vRslcx1S3JyIHcSQR1J/wy7O7PhvFt7x6Ws9zGuK3mwjZ/Xd0ybBMF3MBjUzALvBxCPzVvOjskP8VbSQhwU9ErV4WYI9asuyFR3pmDje0x41qJkq9nU00hP08RBp2M8TuotFz1YSeUxr5dWWGj5ScOXy89G8nLa31vGH6hI+UrAYWZYxyDLzHIlRM07/U32KhgEX95BC8nn2Er0EednbyaNnj/EvC9eN+/oWnZ78cbyS9nc1EyPpyBFmugnST4j1OMcoBQMsIZYKBpljvz5rlQACg31oQkP01kRcuBUDwtWA2l8b2cAcD7IeLRTgxNP/F0lvBqFR8/aT2NMKWXT35zBaHdM2PltCBorBjNZfj2IZOwUiBloQaghneqQwurVsN5qmostYO8arSI6fg9ZfR+Px7bNBzRADnfUgNGR79GJQKTYSyLhaq69aUCOEmJJMmhoO0njstcjUZfw5VVxJkpBiMxCpK+g4e5A5Gx8aMWid5fphNqiZISyPT+UHK7bwWksNx3raCWsaUkhCH+WmOYwOmbA2vW11h7pbScc0KqAZRo9MARYOdrZccVAznpdTMz7eCHfz04ojI9uaZIXbMgp4KGfeSDbFFQywr7OJFdhHBTQAcRhYiYPdve20+wZJuYyskiccwioUJCR8RN5zR5T3BCB26Gd1Yb3T9UI46OfIY9+KZGqEL9LllFAUUeh1NUZaxi0J4OtFU2JR5tyEZEkEBMLdjLvlIMef/A9Wv+9b05amVvRGMhbdRMPx15Fi0pBjztlNiOAgavMBQKKn8TT2tALcbTVI1mSkcbJnkj2LgeaDCKG94+spgHPvwXhmlkPtvJIyvWaWaihI88kdNJ16E7+rE0VvIrloNdkr7rhsL7OB9jrC/kF0WdHVpWVnPlrzQXrqSydlJjnLzGA2qJlBpFti+OicJXx06Lf2jZN7aHQNjNFhgYjcfit+bovNuOgxXcEAb7TVcaCrGX84TJo1hq2peSyPT5nQU09AHV3ncyEmFILaldeORPNy8hBmJz0YkVmPk8yhIt4KbZDnGs/iCvr5P0OihNUDvYSFII/oUx75WNhNDxWunssKalLNNvbTTBAN69D70UMQW5Sf0LCgYbr5+uwOaSvbi9/VCbIepeB2ZOu5minhdxGufhV6KkHRoeRvPS9QkJDsWUh6K57KF+isOkLK3PEzY1eKLTEbCQm15nU0WyqSNRERHET0N0TqZhKKqH37aVKKh7Iz4iIK05o6pMsxW1MDYE8rQNab0PqqUVLHCn9qfdUgycRlTZ8chBryc+zJ/8DdXofkyEHJKECEPLRVHqO94iDLHvgSjsvwH9KGJQeiyBQAIOtAktDUqyfJMMvUMftIMoO5LT2fNgKUMzBquYZgP32EENySljvO3tDocfGFo2/wVP0Z9B6VlICOlt5+vl92gF9WHEWdgKdRli2WNikwrqBfC/4rcrMeJpqX00ncaAjuJpk52DChYEfPapxsII632htoGIwU9g5PA0XT54ksZ2i7y2NTSjYqguO4cKIjAQMncI95X8TQNhKQMo01JdNJy+ndgIScvGhUQAMgmewo6SsBgRSTETXzIVnikWwptFccmLYxtpXvo+zVRxECsCSBEGi9NQhfP3LKUnRFd6OkrUTSGWgt3UVc9kLEYEekG+wChBCI/lricxbOFgoPoTOYyVy8Ga3zNFp//UgNE4A20IpoO05y0epptUmo3f8s7s4GlILb0GXfgJxQhJK6DKXoXoTJSclLv0BTw5c+0AXYEjKRZAXN1RR1vRhoAaERmxy9CH2Wmc1spmYGsyohjW1pebzWWksNXrIxE0ZQjYd+QvyfouXjyu2rQvD90gPoQoL3kI7lvGxLNR7e6mwiN8bBnRkXN/jbmprH9tY6TuJiOY5R62rx0oKfz6VdeUHyhV5OAkElg8wjJqp+TxE2jksudnU08EHbIubEOtFLMjXCy9Ioma0aPEhAujWGpxsqONbTRljTyItxcmtaHrkxjjH7nE+80cx78+bx59oy+gmRi5ljuHiRDpaNdD+FOIWbRnzokXijvZ4PFVxc1XgmEhGtE2O6nYaJyKfvGZmCiIreSsjvmYbRRaYkzr71J3DkQn8dSvwc5PhxWufNCXj62sldcy81bz9JqGEXSs5mJEPkdyO0MFrbMYS3m+zlH5uW8V6v5G94N15XF11VOyPFwiYnBNwIbzeOjGLm3vKRaXttNRykuXQncnzR2MBa0aOkryZ49nm6ao6TXBjdc2w8DJZYkgtX01FzAhGbgWQ6d70QYT9a21FsidnEpk5freIs08dsUDODkSSJjxQsZp4jkVebqzk60DckvpfCnRkFFNnHf0o63tNGZ8DL/aSMCmgACrDShI9Xmqu5Pb3goiJ12TY7D+XM5fH6M7QToAArOiTq8VKDl7UJ6axPuvgU2ETItMZydLAFjYiXUxhBEEEc0T17FCTsQkebd5Czrh7sBmPE1by9kWSMpHEug9BFgCO4KI6N51un9hFUVbIxY0TmkLeZN9vreV/eAu4ZR1Omyt3Lc42VHO1pAyLZqQZ8I8d+lc6RbWPRcQsJNOKjvL/rit+XidDO1E1ztZXvI+R1R/4YN5MXWS6CY7Mekd0EeLuwpF158Xg0umqOR9q5c5egupsQoeh+UkIICHvRGUwoeiNL7/8ix5/6PqEzTyHFpEVEAQfbEOEARZs/QFz2gmkZ7/WKrOhYdNfn6Gsqp/X0HnzuboyJeaTO+wAJuUuQ5OlL9Ptd3agBL0ps9CJkyRyHZIxhoKNu0kENQOFN78fdWY+38oWItYclPhKw9dWg0+tZeMenZrN21ymzQc0MR5Ik1iams/YSkv8XcsbVQ6ykHym4vZA8LLwW6OLNtjpuSbt4mvXB7LmkW2J4obGKXYMRNeIUk5UPZyxma1rehJR7L8XWtFx2djRQipvF2NERKZLuIwhR6mQ0BL2EaO1t51hvOwAFNifp1hhe9HSQhok49PQTohk/2ZZYGj3uMf5amhAcpZ8/154m22pnyQXGlYe7W/lR2SHs6FiNAzMyTfioxosJmQdIwYdgkDAmFJIxICHRgC9qZ9REyY6fXJ2SpBvfsHHXm8cndIyehtOUvfqf4MgGVxNafy1KytIx24m+ush/fL1og+3ItpRR67Wes4iAm/RFmyd+ApMgMNATcR43OdDsOWg9VchJC5Dk0ZczMdiO8PWRXBQRB4xJymb9R39Ia9k+umuPo4VDxOZvIn3RZqxxl1d0+reOJEnEZc2f1tqZqK873N2ojmeSqoEaOrfdJDFYYlj13m/QeGI7LSW7CLRUoTfFkLr4JrKWb7uiaTV3R12kMF3REZ+9EFPs9eNkrqlhumtP4O3rQGc0k1iwAqN1bOZ7JjPpb8Rrr72GzWZjw4ZI6+OvfvUrfvOb3zBv3jx+9atf4XRenx0fMxkhBJXuXnZ3NNIf9OM0mtiUnE1BjPOSTxMCEfXmOvwM/l9VJ4nVG1l9iaBpbWIGaxMz8IZDqEJg0+mn9EmmIDaOezMLea6pkrahjFAKRsoZZCGxmC/INlUyiH+oC2kVdmLRUzo4QDdB7sssonagj+6AF4fBxj0p8xkMB/ljTSn3kT6q8FlGYiUOWgjwUnPVqKDGGw7xizNHyMHMZhJQht7HOdiYR4AXaaccDyuH/LmGCaHRgI9tcZMLRC/EWTS59Pfe+n70uuhPz9nxl67vqTv4HJI1ESV7E1rLIbSOUiRLEnLsufMQ3m7U1iPE5y5BDQXor92BiC9GcmSBpkb0a3qrSV+0GUfaxac2L4YaCuBqrUJTw9gSszDFnGuP11tiEGoQEfKiJC0g7KpHrX0DJWMNksmBEBrC1YTWvJ/YlPyIl80QOqOFrGVbyVq29bLHNsv0Y7YnYnam4u+tjtpWLtxNiLCfxLyxQfdE0Rkt5K25l7w1917BSM/h6W3j9CuPMtBRGyk6FwIkieSiNcy95aMzXsyvu/YEZa//lpDXhaQzItQQZ9/6IxlLbmbOje9FnoBW2Exg0kHNF7/4Rb7//e8DUFpayhe+8AUeeeQRdu7cySOPPML//M//TPkg38mENI2fnznCwe4WYiUdDqGnQgqxvbWO9YkZfKZ4BbooaeD5jgRebK6ik+CYFmeAGrzEosOJjt9Xl7AiIW2U2Nx4RPObmireO+zl1FjJm96Il5MMPEc7q3GMdD+dYZCTuCjEiheVenzch4McLLxKJ293NvGL1beOyiD9sOzgRf218rFwuL9rlBbGvs4mAprKOpwjAc0wKRgpxkYpbpYQi36oHiiExi56UKVI9mkqSSg+F3ApuVM7VRLyDdLfXIGSuQFJkpDTViACbtTa7WiWRCRLPMLfjxhsx5aYxfzbPomiM1J74BmaS95C7ToNgNEWR/am95F5mUGD0DRqDzxL44nXUQND00qSRGL+coq3fBCjzUlSwQoqdL9H6zyNkr4KJe8W1PpdhCueBYMt8nSvBnFkzGXR3Z+bbdGe4Xh6WuhpOI3QVOwp+djTC5EkidzVd1H+2n+htp8clYnTBjvQmg/gyJhLbMrMKOYNDPZx9PFvE9YklNybkWLTR4L8zqpjBD0ulr3rX2bsd7GvuYKTz/0EKSYdXdEmJHNcxDeu5yxNJ7YjVJXimz90rYc5ISYd1NTV1TFv3jwAnn76ae68806++93vcvz4cW6//fYpH+A7nT/VlHKku5UtJJAvLEhIaCJSLLy7q5k4ozmqcvCSuBRSTVZ2+3u4naSR1uNIAW7E12g9ThIx8lywnTP93SxwXnu7gxuSs9iYlMlgOIgmBD8sO0S9u48ddI9sp0NiAbGswkE5Axwi4sasILECO88HOii/4Hy0i/hrQSR4urCEpH7QRbxkwCqi/0wyMVPOIH+hhRwsaAga8KFK8Mi8VeMWcV+K7Hj/uFkaU/q5p1ZpnLT2YwfqL1ATvjRqKBD5jz5iOCnJOpS8mxGuRrTeKrTBDggO4syaz9L7/mlEf2bODQ+Tt+5+fH0dSLKMxZl6RbUW5dt/S1vZXuTEeeji5oCiR3M3091wioN//Arzt32S+NzFkcLffU+AEMhJ81HmPojoLkfrqQQ1SOFNH5jNxsxwQr5BTr/6KD11p0BWABm0ENaELBbd9RlS523E5+qi7sCziO4zEW2kkA/h6yEmOZdFd33uWp/CCI3HXycc9KMU3RcRogRQZJSEYjSDjb7aHfQ2lI3KGs4kat5+Cskcj5K7eSTwknRGlORFIMk0l7xJzqo7rwsxwkkHNQaDAa838gT1xhtv8IEPfACAuLg43G731I7uHc5AKMgbbXUsI5aC8+pKZCQKseEizPbWWh7MLh6TQVEkiX9euI5/Pb6Lv6gt5GLBgkIrfnoJUYSV+cQQHpqI6gv6oo6h0ePilZYaTva0ow4ZWW5Lz2eRc+r9fIaJeDlFsksxegNx6FlHHL0EUZBIHyryBQiijcqiJA1lpTr8HhZwLqiZa0/geE87PtQxU1kAdfgousDg0yArBNHGncILDE1/bUjNotrdhwTc6sxna1oeyebLD2gmw6WKhHe9eXxCU08Gqx3FaEEMtMGQ9pEkyUiOHGRHDiLoIXzmSZLnrBwjqKfoDNgSr1xV1t1eS1vZHpTM9aO6mZSEYkRMOqGKZzn57A+xxmcwb9snkSSJ2oPPE+4uB0kGoWGwOim+7fMkFYzVVrkctHCIzuqjDHY1IuuNJBUsvy5tAc5HCA01FETRG65Z5kBTwxx/+v8y2NMasa1w5IAkIwZb8bYe4ejj32bN+79D/roHSCleS2vpLjx97egMZpKLVk97ofJkaS3bGyk41o91oZdi0pHMTtrK983IoCYw2BfJ0mbdEPX7IMcXobWfoOPsIbJX3nENRjg5Jh3UbNiwgUceeYT169dz+PBhHn/8cQAqKyvJyLjyLphZznG6v4uQ0CgiulhcEVaOay7K+7tZkZA6Zn26JYbPFC/n+2UH6SNEHyEc6FmDkwxMSCOFuOCIMt97sKuFn545jFko5GFBh0RtTw/f6mnjgawiHs6d/uLBFfGpHOlpQ4fEnAveB3Uo65SFZWTZABHdigtDkE0pWTxeX84urYdbSEA3FBQJBKUM0Iqf92aM7tZZmZDKyy3VtOAng9EXK4HgLIPMjY3nk4VT5z4N0WtpLjb1JOkMF62nmQiyoiN9wSaaTr6BiCsYbWAoNNS2o8g6w7SK6bWe3oNksCHFFYxZJxljhuwM6vH6/Bx/8rus+rt/J2PJLXTXniDkG8RsTyQuZ+GUzf331Jdw+pVHCfkGkIwxoAapffsp4vOWsPD2T6EzWi59kBlEYLCP+iMv0Xp6D2rQh6wzkDpvAzmr7sJsv7pZ2q6a4wx01KLMuR3Zeu67LcWkI+XFEa54hqaTOyjY8G6scWnMufG9kzq+u6OOxuOv01NXEpnWSi0gc9lWEnKnpyMv7B9EckbX65IkCQyxBL0z86F/RHrBGP0+Iyl6ZL2ZkH/wKo7q8pn0VfCXv/wlOp2Op556ikcffZT09EgR4auvvsq2bdumfIDvZIYtEAzjfEzDy0MX0QtZGp9KotGMHR3vIpWtJJKJGQkJgeAkbuINJuZd4LTdE/DxszNHyBVmHiaNtThZiYMHSGE1Dp5uPMuJnvYpOtPxWZ+UQbzBzHa66OOcwqcflZ10M0iYRedlK0pwR/RoLKMzGDF6I/80fw1tUoC/0Mo+ejlMH0/TzgH6uDtjDqsSRnfAzLMnUBDjZBc9tOIfEfYLoLGPXtoIcF/W5BVNx+Ni004wduopWpbmcqaehslbey8WRxJq9SuoLYfRXE1oPZWoVa8g+uuYt/Vj03oj9w/2gskxbvZAMsdB2I+ctxUNhfpDz6MzmEgpXkvm0ltIyFsyZQGNu6OOk8/+mLDejq74PnRzH0SZ/zBK9g30NpRz6oWfjxKkm+n43N0c+t+v01yyG+HIR8m+EeLn0nrmIIf+/DUGe1qu6njaz+xHsiaOCmiGkfQRF/W28rcv+9iH//ff6Kg5hRqbg+YspLezhZPP/IDqvY9f6dCjYrTFIXy9UdcJIcDfi3mGTt0YbU4kWUF4uqOuFyEvWnAQ01UOfC+XSWdqsrKyeOmll8Ys/8lPfjIlA5rlHLm2SCtdA75R00/DDGulDG8XDUWS+ED+In5UfojtdLEUO3Ho6SPECdzU4eXz+avGFAm/2VaHLGAj8aOmdyQklmCnDh+vtNSwND7lwpecUoyKjq8t3sC3T+3jiWArSRjQIdFOAAGsJ45EjHgIU4KbciJPE4mmsTffJXHJ/GjlzRF/re42QppGfmw8nxpnOk2SJP55wVq+V7qfFwc7cEp6zEKhiwAq8Ik5S6bk/C815ZRQnDwS0IyXpYnGRKeehtEZLax4+GvUH3qeltLdhLvKAHBmzSd39ceJy5o34WNdDgZLLARrxjUuFH4XKEZknRERX0T72YPM3fox5Mts670YdQefB4MtItQ3FChJkozkzAdZR1/dW7haq3CkjyP6N8Oo2PE7QqEwSuHdI8KDACJxHmrNa5S9+p+sft+/X7XxBH0DYLjI1KnRRshdP+nj+tzdlL32n0iOXJSsDecC5JQlqJ2nqT/8Io70IhLyllzWuMcjfdEmavY/i0hagGRyjFon+qoRgQHSFtw4pa85VehNVpLmrKSz7jQiLn+USrgQArX9BLKiJ2VIGmGmM6GrgdvtJjY2duT/F2N4u1munAxrLPPsCRx1uUjFOKpzZ5Awx3Cx2Jl0SS+jNYnpPDJvNX+sLuHZ4LnsSpzBxD/mr2JdFPG8ClcPaRjHzRLlYuaUK6JZUzPQx+6ORlzBAHFGEzelZJM1hdoG6ZYYfr56Kwe7WjjU3crh7lZi0eElzD56OUL/SG2NBYU8u5M449i5bYh4OH24YDEfnqABp8Ng4nvLbuJUXweHulrxa2FusMSyOSUb5zivMRmGA5rxMjTRAprzszTDAY1eJ/PYgfqR/SaqTXMhepOVOTe+l/wN7ybodaPojeivkt1D6rwNtJbuQrgaIjUW5yFCPrTeauShqSnJGIumhgkHfRim2GNLC4foqjmOnLpijKM3gBSbhWSMoePswesiqPG5OumpL4l0thlGf5aSzoScsoyBujdxd9QRmzy1HXvjYbEn4u4uGd9529t9WZmNlpK3QFJQMtaOyfgpSQsQ/fU0Hn99yoOazCW30Fb+Nr6a15ASF0ba0LUQWm81Wnc5KfM2zGiF4oKN76a3sYxw1ctIifORbSmIoAet+wzC3UTRLR+5bqZbJxTUOJ1O2traSEpKwuFwRH+KGvpyqupFTONmmTSfKlrO107s5slQG4VYcaKnlxBVeIgxGCdcz7E2MZ1VCWmU93fRF/TjHJpyGq+NW5YkLub/rSKQEPy0/DBvdzVjk3TYhY6TUoiXmqu5JTWXj85ZMqE28YmglxU2JmexMTmLpxrO8Hj9GYqxYUeHOqQ+3IGfXinMe/Omtt1ZliSWxqWwNG7qslKXCmZgdEAzzPkBTURwzzsqoDl/6mkyWZoLkRXdKG2Yq0HkCXop3fV7EcFB5KHuJ+FuRm09CpKMnBip4xK+HmS9aVoutGooAEIbEwAMI0kSkt5CeJzi+pnGYFfE40iKja6bJA0Vhg92NV61oCZ94U20le9D9FYjxY/WM9K83WiuRtI3/d2kj9vfWg22NKRxzColexautvLLGvPF0BktrHjoa5zd+Uc6Kw8Tbj0MgGK0kLv6XvLW3jejFYrN9iRWvvcbVO76X7prD6INTa1a4tLIv/OzJBetvsYjnDgTCmreeust4uLiRv4/kz+cvzWSzVa+v/wmXmquZld7A6XhAex6I7elFHBnRgH2SQg6KZLEwgl2LS1yJvGXvq6o3UICQQ1e7AYTB7tauIl4CoQVGQlVCCoY5I22OpwGE+/KmTup850ID2QVo5cVnmmowHueoV2a2cZXC9cwJ/bq3ownwoVTTM6ifEKqynOlFTx24jQNff3YTSbuWlDEZ959E/Ex1otmaM6fdrowoLncLM21RpIkFt75Wc6+9Uday/agtR45t86SiJK7BclgRYS8iN4q0udvnBZBMJ3Rgs5ki7SxR/G/EmoQzdeLxTm9U69ThTysNq0GQR8lCAxH2vnl8VyrpwF7eiGp8zfSVrYP4etGchYMmUw2IrrKiEnKIX3hTZM+riTJl3RjvzD7poVDtJTupOnUW/j62lEMJlKKVpO1/LYxn7GmhgkHfOiM5jHTngZLDAvv+DTBm97HQGcjsqIjNiUfRT++2ve1RgiBq6WS/tYqJFkmf90DzL35w/hcXeiMZqzxGdfd/X5CQc2NN56bC9y0adN0jWWWcXAazbw/fyHvz18Y0Vu5Cl+ym1KyebqhgjfUbm4hYUSFV0VwgD76CKEEwizDTuF5XUkKEvOJwU2Il5qruDtzDsYprnmQJIl7MgvZlpZHSV8nnnCIZLOV4tj4GfUDjBbIDBMIq3zyyRd5u76JTMlMljAw6A3yq72H+evJ0+z4+deYw6UDmuGOpwsDmivJ0lxLFL2Bebd+jPwND1L++m/pqTuJZM+O6GXIClpPJVpnCXqDidzVd0/LGCRZJmPRTTQcex2RUDSqRkIIgdZ+EjSVtPk3TMvrTzWO9EIUowWt5yxK+tgnbq2nEknRE3cV240lSWLe1o9jcaTQePw1Qt0VQCQAS1+wkYIbHr6sYCAhZyF9e59AhHxj2qsjStN1xGefO081FOTEMz+gv6UCyZ6NlLocLeSlpfwAreVvs+zBf8aRNgefu5u6g8/RfmY/WjiIpOhJKV5L7pp7sDhGFzsbLPYZ2bp9Id6+dkpe/AWDXQ1IiiFiPaGFcWTMZeGdn7nu7BGGkcQkS/i/8Y1v8PWvfx35Ao0Al8vF3//93/PXv/51Sgc4lbjdbux2O39Yf9e0KuNeKSFN40h3K8d72wlpGrk2OzelZE8qKzMVnOnv5nun9xNSVbIwo0OiER8BNHKsduo8Lt5PxhjDTIA+gjxBG19duJ7FcWM7HKab3oCPvR1N9AR9OA0mNiRlRi0enirGK/Ydb3rpBzvf5neHTnCrSBzVLu4hzCtKN2l5GRx79YnIVMdFAprzu52u94DmQoQQNB57lfrDLxLyDZtnSsTnLqJ4y4emtQ055Pdw9LFv4XV1IcUXI8WkQ9iP1luJcDdTuOl9ZC2/fro9aw88S+3+p5HTVyPHF0W6XYSG6K1Bbd5PxpKbKd78gXH3D/k9tJbuorV8H0GvG3NsAukLN5Eybz3KRXzHJoIWDjHQ1YjQVGwJGVc0pRj0DfD2f38BTR+LknPTSNGr0MKozYcQfVWsfM83sA/Vt1Tve5L6Iy+j5N0yysNMqCHUujfQCz/LHvwXjj3xHcJhFSm+CMnkjKhr955FkWDFw1+97rSLgt4BDv7xK4RUgZy+CsmWBoiI2GbLISyxcax6379f8Wc7lYQDXnb98hO4XK6L1u5OOqjJzMwkMzOTP//5z+TlRSSqd+3axQc+8AFSUlI4fPjwlY18Grkegpp23yDfKXmbdr+HRAzokekkgCRJfLp4OeuTru6Ppz/o5622evZ3NdPqHSAkBBYUQmiEEHyMrDEWAgBeVP5EM1+av4aVCVfPLFAIwRMNZ3im4SwKECvpGRBhQmjcnl7AB/IXXnam62JdSpPxafKHwqz/5e/I8RtZy1ivtGZ8vEwnbz73OIXrbxlZvq85InoZrYZmpgc0QghcbdV0VR9DCwexJWaTUrwaRX/pQF1Tw7jaqlFDAazx6VetNTbk91Cz70lay/aiDU3RWBMyyVtzz4hJ5vWCEBoVb/6BllNvRlqmjQ5E0I0IekguXsv8bZ8ct4vMP9DD0ce/g9/dE8lmGGMRvh6Eu4nY1AKWPfjP6AxXXjQ/VfS3VHLimR+ghoNItvSIWvFgK0INMe/Wj41k2DQ1zJ5ffwbNloWSMTaDJXy9hM8+jyUuHZ/Xg1Jw2+jOoHAAteY1bLGOq9o5NhXUHniW2oPPoyu+f0zt2PB5z9v2SdLmb7xGIxzLRIOaSc8LlJSU8MlPfpIlS5bwox/9iMrKSn72s5/xxS9+kW9+85tXNOiJ8Ktf/Yof/OAHtLe3s3jxYn7xi1+watXkrednIiFN5dun9hEIhHiQVOKHTBL9qOwXffz8zBESTVYKr2LNiMNgYm1SBs81VhIvDKwnjgQMdBLgWdppwkcOY5+sGvEhwZR2QXnCIYKaSqzeOG4B8sst1TzVUMEy7CwiFqOQCaFRxgCvtFRj1ul4KGf81uSpClyiMSygV9rQhtsfIDdKQAOQjgmzouf1w6UUrr8lanYGrp+AJugboOSFn9HfXIFksCIpBrQT26nc9WcW3P4pEvMvbkooKzqcGcVXabTn0JusFN/8Iebc+DB+dw+yzoAxJp7+5grKXvsvgl4XJlscqQtuwJ5aMKOmPi9EkmTm3vxhMpdupe30HvyDvRgsdlLnrb9kcfDpVx4l4POiK74vIkI4hObpYqB2O5W7/sK8rR+d7lOYMI70QtZ/9Me0lu2mp64ETVNxzLmF9EWbsTjO1RT63d2E/YMo6dEfFCVzHOiteHtbULJvHBXQQMRGQE5ZwkDdWwx0NhCTlD2t5zWVtJ3Zj+TIiVoML5njkGJSaT+zf0YFNRNl0kGN0+nkiSee4Ctf+Qqf/OQn0el0vPrqq2zZsmU6xjeKxx9/nEceeYRf//rXrF69mp/+9KfceuutnD17lqSk6ZPtv1oc6m6lI+DlXaQSd57rswmFTcTTTZAXmir5p/lX9ynxpeYqZCG4jaSRFu8kjCRh4BD9JGMcVUzsIcxxXCx2Jl+2XcD5nOrt4OnGs5xxRcShYvRGtqbmcG9WEabzni5DmsozDWeZi42VOEaW65FZgh0/Gi83V/HpRVlY9dG/+lcauMBo9d/zGS78NQ3ZLAmiJ0kFoCGQdfqh7EwkQ/P0kcZz47xOAhohNE4++2MGupqGjP4ihYdyYAC19TAlL/yUFe/5OvaUyb3vAU8/rtZqkCQcaXMiGjfThKI3YY1PRw0FOfXcjyN1PiYHGGOhtY6W0p2kFK9j3m2fnPFOxrb4dObc+J4Jbz/Y1RSR0M+5aVRAAyBbExFJC2gr38ecGx6+aq3/E8FgiSFn5Z3krLxz3G2k4WuHFo66XggBWkTwU4oZp3NsaPlgd9N1FdSE/R4k+0UK3fW2iJbQdchlVXD+4he/4Gc/+xnvec97OHbsGJ/73Of4y1/+wuLF0yNBPcyPf/xjPv7xj/PhD38YgF//+te8/PLL/O53v+Nf/uVfpvW1rwZHe9pIwjgqoBkm4vdk5VhP2/jaDtPE/o5m5gjrGM2aTSTwAu08TivzsOFETzchKhnEYjDwicKLP4FPhLfa6nm08jiKJRElcz3oTHgGWni2uYpT/V3896YVmHWRr/Hhzm4GwkHmE93ocT4xnFLdnNYpbJuirEs0LmzDhtGiefMzikh0/ojqPg+pjJ1+acRHQA1jnRNp178eszPD9DaW426rQsm/FTnm3DSkZIxByd6EWvkC9YdeZPE9/zih44UDXire/APtFQdgSElbkhVS5q6naPP7p3Ua5Oxbf6Sn4XTE9C82C0mSEEIg+mpoP/s2pth4CjY+dFnHFkLgaq2ip/4UmqoSm5JHYv6yaREWnAz9rZUgSUj2sd9pANmeQ7jtOAMddcRlT62UwnRjionH7EzF31sd0ZW5ADHQEukYAwj7QWcce5BwJLOr6KOsm8GY7Il4vF1R1wkhEJ5OfCKAp7cNa9xYC56ZzKR/Mdu2bePo0aP84Q9/4MEHH8Tn8/HII4+wZs0avvnNb/KlL31pOsZJMBjk2LFjfPnLXx5ZJssyN998MwcOHIi6TyAQIBAIjPw90w03Q5qGMUp9yjAGZMJCoEGU0tzpw6uGR1y+z8eJnvtJ5UXaKWEAFYFF0XFzah53ZxbivILC5ux4P73+AL+pPokcNwcpc/25QM6ehRZXQG31qzzd5+KzGyLTj/LQ6miFy+cv9wRDUdefz8WClmGiBS8wVvV3mGFX7V5i+NDff4of/cd3SRUm8rGMGGb2EeRtxUXR/GXMXbJ8lKDetQhohKYx0NWAGvRjcaZgtEWfMhuPzqojSCY7km3shVGSFXDk0lV9jIGuRmwJmRcN1tVwkGNP/geDPS3IqSuQnbkgBFp/He0VB/H2tbP83V+ZlkAg4OmnrXwvcsoyZPu5J3JJkpDiChD+fppO7CBn9T3oJvm9Dwz2cer5n+Jur0HSW0DWIY68hMHqYNHd/4Ajbc6lDzJdSFIkdSi0iGnoGIayjdfIGPNKkCSJ3FV3Uv76b1A7SpAT54+0e2vebrTm/cSk5OHtbRvqHBtb5qD1nEXWGYnLmn4fvKkkY9FNnNn+W6TB9lEF0gCivw4CLlS9lWNPfIe1H/wP9JcQeJ1JTPrXr6oqJSUlpKVFnrrMZjOPPvood955Jx/72MemLajp7u5GVVWSk0ffbJKTk6moqIi6z/e+972rUuczVeTa7JzobieIFlXJtwk/WZbYKRO0myipZivtPj/zo3gNWVDQJNiamsvf5S3AICvj3pgm40DtLMrnqYPH0ZCQ01aMOaZsSUR15vOX46f59PqVyJJEblzkhtuKn/wothKtRF5/2bJ8EgouP2iB8QOXYYYDGIjupP2ZL3yJ6qoqnn3qCU7IRhI1Hf2odODHFpdBwd/92xgfp6udnWkp3UXtgWcJDESUo5EkEvKWUbT5/RMu1lWDftCZx3x+IuRDbTuG6KsBBIf++BXMzhSyV9yBzmAi5BvAFBNPfO7ikSCl/cyBiAli4Z3IlnOdT0rSAjRLIq7qV+isPDwtppu9jWUITUWJYrYJIMcVEO4sxdVaSXzOogkfV1PDHH/q+3gH+lDybokYOkoSwtdHqOUgJ576Pqvf/+1rpokTlzkPEIj++qhGo1pfDbLeRGxK3tUf3BSQOv8GvP2d1B96HtF9BiwJEPYhPF1YEzJZcu8jtJTspHb/06C3IicUIck6hKZG5AU6SslZded1o7Y7TOq8DbSVv01/7Q5EwjxkR3akG66vFq27AsmRh5y6nODZZ2gp3UXOqvGn8WYakw5qduzYEXX5HXfcQWlp6RUPaCr58pe/zCOPPDLyt9vtJjNz5rbebU7J4amGCg6IPm4gbuTpHaAeLw14+Xj6kqs+rlvS8vhjTSkLCJDM6DRrKW48QuUD89LJjw0D0eenYfL1KlXdPcjmuDEFesNIMWl091Qy4A9gN5tYs2Eua3ZmcaK2nQzNhPG8jE0IjWOyi3mZ6Wy4Yd0lp+8mE7RA9MBlZNuhtsjzPZo6WxqpbGwFoFcL0EuQ4afeUMBHz6ldLLj1YWC0mN7VCmjqD79I9d7HIx46BauQdGa0wTZ6mkr/P3vnHRhHWt/9zzOzfaVV773acu/9in2+ylWO4zg44AIBkryUBBJeeAkEQggkIYEkJPRASIDjei/u9rn3qmL13stK2tW2mef9Y+SVZa1syZYt+U6fv+zZ2Z3Z1e7M7/mV75cjv/smqz7yLWzRkct8F+OMT0dWHEJqAYRqfA4y5CNU9QZoAZTUpSjR6ciQD193BeVbf2k8USggdcwOF3M3fZyUOatpObsbxZU5KqC5gBKVgh6dRvPZ3aOCGqnrdFYfp+XsbnwDPVgcLtLmbyCleHXEjI6UcthNWWJxxIS/J/KCyKMyztTk8HZdG//7H4mOyqN4upswFT+AcIwEisIeh5q3Ga38BRqOv83cOz4+qdedKhxxqSTkL6G7/jDS240+0AyBAVCtCEcicqCZ7GV3Tzo7NVMQQlC44TFS566h+fROPD2tmKyppBR/iKTC5Siqibw1DxEYGqDpxBZkx2lj+svfjwz5yFi0iYL1j03325g0impi6fv/ir2/+AuCnWfRO04bD5hsKKlLUFIWIYSC7sqmrfzAuzuouRyJiddv1DIxMRFVVWlvbx+1vb29ndTUyKsYq9WK1Xrz1DrjrXY+U7yMH1cco4sARRh9LI0MUYuXFQlpbErLvWHncyGz8snYNI73NvB6TzslRJODnQAa5/FQyxBPFRdQ4Iqekibbi3GazQjNP77BYdCYsMqYn47NYtxU/uMrf8IdX/g7Xhxqp0SPIgEzfQQpVTz4zfDiD7+HKf/KqeJLgxa4fOACI8ELwI+feZ03f/tzzh09CFJSsnwN933kj1m24TZ6Otr4m6cepq9/yGg2DXpRkuYhXNmghwj0VnHwdz+g9NgxUtYaUvE3snfG7+mjau+zKMkLUNNXhrerthhkTDbB869Ss/9F5t39x1d8rfQFt1K9/3n01uMoGasRQqC3n4aQz7iRW40GXwEorky0liPoHecwzXsMQn5C7Sc589qPUEzmYRfv8ev7whqHb2DEKVkLBjj18g/oqT+DcCYhbPF4urvoeePHNBx7m2Uf+L/h5lYpJc1ndlJ/9E2GelsBsMUkkzpnDQn5i8MOxbK/cYwvFYDe3whCEJ00uWbR9vOHEM7kUQFN+P2oZkRcPm0VB6ctqAGYs+ljHPz1V9G7yhCxeYjEuRAYRO+uRAiF1Dlrp+3cpoqoxCzmjKPTI4TC3E0fI3vpXbSWvoNvoBerM4a0ebfgTLhxchVTjWq2YLI6CDnSUOKGp/dscaMUl4XFScjXMY1nOXmuqvz0gx/8gGeeeYaGhgYCgcCox3t6ItuvXysWi4Xly5ezfft2Hn74YQB0XWf79u189rOfvS7HnA42puaQbHPwSuN5Dva0I4FMezSfzFjM5vQ81CmoXU+0DHRxkPK/RXn8+97D/PbYaU4HR3qTEp1OsnMyiC6anGfMRHpWPqCt4H+Pn0EdbEVEj754SKmj9FVxx+rFxOYVhDMrC4G9L5fw7X/9Cc+/sY2QpqEqCg/euZGvf+EzLFw5Vo/iSsHKBcQlQlRj3bGNKaXXfvMTfvuDv0N1JiJj5gBw+vgpTu59ggXv/1N8fV243QMoCXPR206iFt2H4hyZ3lOi09AcSfRX7GHO8k3EpEUueVwvWkv3Gj5LyWPLKMLsQCTMoa18P3M2feyKqq/WqDjmbPooFdv/G+nrQ8QXonefNwTgrGMnlpSUxehd5eg9lagpi41mYm0rlXuexuqMJeDpG/dY0t+HNSY2/P+qd56mp7EMNf8ulIt8j3RPJ4O12yh9+xcsfugLSCkp3/5rQ8MlNhc1dyP6YBu+nirqDr9C3eFXQCiY7NForceMIOQiuwHp70e2nyIxfxm2CMHw5dACQ2C6THOz2WmU8KaRhiNvIKXEVHz/qOBLSVmMVvM2Z978Mev+6B9n9Ej7VOCIS532rIy7rZqOisOEAkM44tNIK9mAxXH565eUOm1l+2k8uY3BzgYU1UxS4TKyl9+LMz4NX2sjSmbkwFR6OnAk3Rx2IBeYdFDzrW99i1/84hd86Utf4q//+q/52te+Rl1dHS+99BLf+MY3rsc5hvniF7/Ixz/+cVasWMGqVav44Q9/iMfjCU9DvVuYH5vE/NgkNCnRpcSsRA5k6gfd7Gyrp9s/RIzFyq0p2WzOHdu/cClXk1Gxm80UJcYzFNJQ7XHIuCKEaqFnoJFvb32H/fVN/Psj92JSlGtqsr2Yu9KzWPn2EU6UlHf9jAAA/X9JREFU7UHP3DDSbxD0orcchqFevvLFf0TNWzAqszJncQL/+18/48eDg5R2+YlPiCc62riBto1zrCsHLHAhaLnABYuCi/nP37/Jjh/8HUryIkTasrDQn0xeCG0nOPvCj1EtNkRcEXpfHSImZ1RAcwEloRjZeZbmM7tueFDjc3eh2GIQkaY9AOFIRAsFCA4NoJqvfBPPWnIntqh4ag+9Qn/DO8ZrRHjPAEK1GIqtfmOcVAiBkjQfb80Wclc/RP+hV5BDPYaGyEXo3i7kQAvp6x8ADOG85jO7UJIXjgpowBhFJm05nVX7GXJ3MNTXQfOp7aiZ61AS56B1nEV2lRl/m8S54dJbqOM0hAJo5S8i4grAFgtDPeh9Ndij4im5c/LXIUdcGr0tNUipj3GVBpCDbWNk+G8kocAQLef2IJLmjckmCZMVJX0VQ1Vv0ttw7qabfrqZCAWGOP3qj+ipO2VoPZns6L7dVL3zB+Zu+jgZiyL7ZEmpc+6Nn9BWvh8RnY5IXoyuBWirOklb2X5yVz1AV/Vx9N4alLjRfVF6Xx3S00HmHR++EW9xyph0UPPb3/6Wn//857zvfe/jm9/8Jk888QQFBQUsWrSIgwcP8vnPf/56nCcAjz/+OJ2dnXzjG9+gra2NJUuW8NZbb41pHn63oApBfqJ/zHZdSv7x5DleqG1ANduQtjiU/nbebqlhlyefHzx0D1bT1M5HhVId/L9/3GEYz2WtH1HlTShCdzewvXIHb7Q18olNxoTAtTTZXszLv/hX3v9nX+bgka2Y7dGgWtE8PVhtNn7ws19QuOlh2sd7clQ0ubFjMwlXG7Bc4OKJpEtpfOdFFGs0StrSUcGlEAIldSm4a9F8/aj2eOgqQ8RHnmwRQgF7It6+8VO/uhZCCAUxTtB7tZjtUciABxnB/A+MzARCYJqE7URS4XKSCpfj6+9i7y++iAwMRtxPSh0Z9IwK9C5kdGJSC4hKzMJTswUldSkidmT6SbYdJzolj9Rhpd/+thr0UABTXOQMoojNg8Z99DaW01VzEmGPQyQUI4ND6K3HUJLmj5p2Ue1xKDE5hM6/gjMuGb+nhWB3ORZnHBmr7id76d1XNSGSuWgTTSe3onecNfytLkIfbEP2N5C5cXz7guuNp7vF+Bxd4wjUOVMQJiv9bTWzQc115Ozr/0lvY5mhFxSTjRAKSsiH3nqMsq2/xOKMIalg2ZjnNZ/ZRVv5ftTc21FiR34LMmUxWv1u6o68TnLRKjoq96APtBgThQhkXy16TyXJxatIKhz7ujOZSQc1bW1tLFxomHVFRUXhdrsBuP/++/n6178+tWcXgc9+9rPvmnLTRMpAkbIqP9p7mBdrG1Ey1yAS5qAIBSklal8t26v28u2tu/m7ezdN6BwmklUB+OHOE+gohk/IpZNIMdkQk83P953lc9/45oReb8I9K65cnnl9C4cPHuStN17D5/MxZ24Jj37oI7hiRqsVTyRYucB4QcvlApaLuXgq6WI6qs5CdGbEVbcQAqIzwV+B9PWBajGaLscj6MFsHf056bpG86ntNJzYavR+CEFC7mJyV91/zaq7nVXHqD/+Nn1N5SB1owSUOPo1pR5CdleQVLDsqjRhbK5EkgqW09V03jCLVEZfgmRfPQS9iItWjXLImL5yxKey7INfpWzLL+msOgCN+40dhCC5aCUld34SZdj+RA5r2BBhivDCc4z9JIPdTQhnKkIItN5qQKCkjNXcEhYnSuJcvF2l3PZ/fjIlvjhRSVnkrn6QukOvIL1dKPEFoJgND56eSmIzS8hYePs1H+dqudBMLfVQZLEJqRvB7zTr6bybGeiop6vmBGrObSgX9XMJkw0lcx3SP0DtwZcjBjWNx7cYGcfY0cG9UFTUzLWESp8hJr0QV2o+DcffJlBdCYDFGUvW+sfIWfm+iNeymcykv4mZmZm0traSnZ1NQUEBW7ZsYdmyZRw5cuSmasq9Xkx2bHmy+IIhfnn4JCKpBDWxJLxdCIGIy0cLenju9HG+/ckHSHJdeeU4kTIQwOm2neBMDk+wjCE6k/KqfejOWFR17Or+avtWAPbW9UHWYu74zMiN5lSvhN6+UftdbXblYsYLVq7EhQmlIV8QKcZ/DamHMFntaD2ViJhsYyQ2dcmYCS/d04n0dJBa8qGRbbrGqZd/QHfNSURMNmrWBqQWoKetmu5nvsO8uz991bLm1fuepfbgywhnCkraCvTeGvSmg6AFURKKQbUgvV3orccg6CFvzSNXdRyAvDUP0fX7b6HVbkdNX4mwxxvBUm8NWvMhhCsLZbjUIfUQescZXGmFOOONvqrFD/05Q/1duJvPAxCbMWdML4srJQ+hqOjuOtTksY7J0l1vPDe9iCazDekfMh4IDIDVdZnSW5JRevMOoE6yf2Y8CtY/hiM2hbojr+Ot3QGA2R5N9sr3kbfmoXCgNh04EzOxOGMJ9lSN0TMBkO460EMk5F1f4dX3KlLqNJ7YijBZIzaoCyFQEorpr9+Nf7B3lI6UHgri6W5CzdoQ8bWF2Y5wJtPfXsvC9/0fslfcy1BfByCxx6bMeHXs8Zh0UPPII4+wfft2Vq9ezec+9zmefPJJfvnLX9LQ0MBf/MVfXI9znHYmE6jA1EjtRyJxbgp7SqsZ9PsxxRdH3EeJLybUcpR3mnr58J3jexzB5MpAVmcUyjhy4gBS86OaTHQoMaNG0S8QKViZaGblcsEKXP+A5QIXj1ZfyoXppEDhUhqOb0FqqxHq6ONJLQjuepLnraPj/FFCAy0gdUJVb6Fmrh3uM7nglHuQqOTc8OprqL+LM6/9B/2txkpK9jehKybUlCWQNA+tcR9lW35BQs6CSQvk9TaWUXvwZZS0FagpRgCgJJWgNR1Cbz2G3noUFBPoIayuRBY8+mVcKbmTOsbFuFJyWfr+v+TsGz8mUPEywuxAagFDrt5kRyTMQQYGjSCq4wz43czZODo7a3clXlYrx+JwkVqyjrbyQ+hRaeEgCUD63eitx4jLXoAzIZ2U4lUM7HsWGfSCaoWgd/zSW2DAKL1Zp0a5OODtp+nUdlrL9hEc8hCVlEPKnFVkLZ0ZY9KKopKz4j4qd/8OzZ5g6LQMr9z1wTb05sMk5C0mKiGyjcAsV09r6V6q9z2Pr78TzM7xMybDjeZa8JJWBUUBBPIy122hh8LBi6KoN516cCQmHdR873vfC//78ccfJzs7mwMHDlBUVMQDDzwwpSd3o7jaMtBUMtHmWtnca/xnvIzJ8I004EqatNbKBSJlVTbcfT9PP/8ypghNmlLqKO4aNt99L/uah8Y52uSClYkGKhe41gzLRJjIWHXmks00ntiCVr8LNfuWcAZGhvxoDe+A1Mledi96MDAi9e/rQ6t6Y1jrRIIeIi57Pgvf939QVBPe3jaO/P5vCQYNXRdhj0f63Ojd5YTOv4ap8B7U9JWE+mppPrub/DUPT+ozaDixBWGPQ0ke+b4IoWDKWouesgit4mWiEzMoWP8oCTkLp6SHJz57Phs+9UO6ak4w2N2MarKgmKw0nngbb+02LhSPXGmFzNn42atqlp6z8aMMdjUzcP41dFcmwp6A9LuR7nrsMUksuPczAKQvvI36Y28QqtmKkrwYND+ytxqRMHrhIHUN2V1BYt6SKRFb8/S0cuyZ7xDweRAxuYjYNLzeTqr3Pkt33VmWvv+vrjhddiPIXn4PQ30dNJ3ahuw8C/YECHqQ3i5caYUsuO/PpvsU33U0ndxG+fZfG67oyQuRHWeQ/oEx/lsAcrAFxWzDGjX6uqwoKnHZ8+jrrkYmzh0rgDnUi+7tetdl2a65ELp27VrWrr25dAqy4n1EmbXw/69nZmUyXKkUpOYtYKE1ESH+BTnQhEiYM2Yf2d8MwJJVqyclEBd+vpScPHWKttYWkpKSWb5qNYqicN9Dj5L8t39Hd8MuyL49HNjIkB+9+RByqI+1jxm6JVORWbnWrApMPGCZSg0YuyuRxQ/9Bade+SGh0mfD9gBysBVFUVj44Beo3vsHOqtPoqQsQokrRAoV2XEGvacSk9XO4ge/MKo/pmzbrwjpwnBJvlCmigElcQ6hqrcINe7FVPwgwpnMYGdDpNO6LP1tteHJsktRLE5kbC56yEviFF/8FNVEctFKkotGtHAyF29ioKM+rCh8LTogJquDFY//Na1le2k+vQvfQC0Wh4v0254gY8Ft4cDEYo9m+WP/j5Mv/jO++p2gmNGaDiC1IEqCMeUnvV1orcfAP0D+2qsvvV1ASsnpV/+doAamue8fNSIuBtvoq9lK9b5nKb79I9d8rGtFCIW5m58ifeFtNJ/ZxVBfO2ZbGqlzP0pi/tIpb1SfSfg9bppObaOt/CAhvxdHXCqZizaSMnftNZdntFCA9opDuFvOA4L47HkkFa5ADwU4v/t3KAlzjFFrqRHqrkBrOYKae/uojI309SG7K8hYcGvEADh35f2ceP4f0FuOoKQtC/ewSX8/WsNurK7EUb+/dwPXFNS4XC5OnjxJfv7NJZEdW5RPtPXqV0ATDVYm0q8ymRKQcCWQ7UrgfXfdwVu7DyKjMxCWkb4ZGfIhOk6wYNFiMpesHzO+fKUS0Kn9u/j1P36Dtvqa8LakjGw++sWvs3LTvfzNz57mbz/zBO0VL6NGJSGFGentQFUUln3iG5wJJHHmyJVvqjdrwDJREnIXsuGPf0DLmV30NJYBkrhFa0lfcBuerkY6q46h5m4MN/0JgMzVKElzCVW8Ql/z+XBQ4+1to7fhHGr2rWP6boRqQU1bhlazFentMhR61cl/topqgkuUcKUWRA60gB5EDwwgbDcmYyCEuKbS1qWoZguZizaRuejyjfNRiZms++T36ao+Tk/9OXqbyvC0HkFvPYpQzciQH4szjgXv/8spsQToa67A09WAWnD3qIAGQIlKRSaW0HxmFwXrH0U1T38ZCow+JVfK5PSobmYGu5s59sx3CPqGELG5iOgU+vs7OPfmT2grO8Dih/48Yr9TKDBER+VRAp4+LM5YkotWjGmqd7dWcfLFfyE41I/iSDDEH0/vwBqdQPqCW9G1IKaUxcZCQ5hQszag1e0kdP5VQ+PJ7EAOtiF7KrHHJFKw7tGI7yEhdyFzNn2Mih3/Y1iSOFNACyAHW7FGxbPs/V+edtPUqWbC76alpSXs93QBKeWUn9B0M1UaKzDxgGUyZSCAb/zTDzl+3720V76KHpOPcMQjff0o7mqiHFb+7ae/YG9TpKmf8SeBTu7bxT987mOIqFTjQjtc4ujqOMO/fOnTrPnM35G5fCPrv/obWk7uoeX0XvRQkNisB8ldfz82V/w1BSuTKQPBzHentjhc5K5+kNzVD47aXrn7dwhbLCJmrPKssMYgYnNpPrOLvOHnebqNzJuIjlzrviBKKPubkN4ukgo+FHG/y5FUsITGU7uQGStBqOjtp9A7zoI+Yvzp12Jwt1UTk3p9y7DTiaKoozJHvoFuOquOowV9OBMyDB+qKWqedLdUGpo8EYw+AURsLlrHGQa7m2/6z1xKnZ6GUrprTyP1EK7UfJKLV03J9Nj1QkqdUy//kJA0YSp5FGEeCUr0gWa6a7dTe+ilMWJ89cfepOqdZ4z+OdUCWoDybb+m8JYPkr3sbsD4Xh1/7h/QzS5MczcjbMYUpxzqIdCwl/qjbxi9ZZaRa5wSmwOF96J3nEZvMgycVYudzCWbyVvzUFgZOxJZS+8iIXcRzad30N/RgGoyk7T2PlJL1s6YgHkqmXBQM3/+fP7jP/6DD3/45hLiiURCcRIue+Q/5kRKQJPhakpA4eeOm1mJ5Rv//Sqv/89P2fHi03gaSrE6nNz28Ae4/2N/SrstbVIlICklb//NV8CZipJ3Zzi9KaJsCGcyWt0OTj/zQ+avuwPFbifhlrtZeMvdE34fcOWgZaYHKVdCSp3OquM0ndqOp6cV1WIldc4aMhZtwuocGT33DfYaUuTjCCQKWzyBjpFsl2oensIJ+cAcoY8jZPSD6d0V2GNTSSpcMelzz1xyF02ndqDV7QRLNLKrDCVpPkpiCQyvCENtJzj2h++w8sPfJDppYkH9zY4tOoGspXdel9cWwzIMht9XhO+C1ML73cz4+rs5+dI/M9jZgLBEIVQzjSe2cH7Xb1n0wOeJyxqZ4NR1jZ76s/gHejA7XCTkLpxw4OPpbqHx5FZ6GktBQnxWCZlL77zqBuae+nMM9baiFt43KqABUKIzkPHFNJ7cTt7qh8PZmup9z1N78EWUxLmoyYsQFicy4EHvOM35nf9DwOOm8JYP0nRyG7qmoRbfMWrKTtjjUfM3Eyp9FmQAGfKPelyJSkGJuhOtqwK9aT+rP/YdHDGRRSwvxRGXStFtN/+9eyJMOKj5zne+w2c+8xlefPFFfvrTnxIfH8+TTz6JyzVW6nymY0vLwuYc/UWdbBnoUqYmWLmU8TMricnJfPxLX+djX/xrQsEAJrMFIYQRrDRPrK/iQmalo+osg+3DqfBLLqJCCNSUxXjPv0rLuaNkLhyxGZjqJtubFanrnH3zx7SXHzAk9J1pBIJeag6+TOOJLSx/7P8RlWSIl1kdMdDVNr6fla8Pq2PkNxWTUYzJFoXeXYEaQcpc7zIc6m2OaJZ94OpSyY7YZBY/9BecfPkHyP4mlNSlqKlLwo8LV4YR3Fa+RvW+51ny8LtzyvFaGO/vOR7xOQtgz++R7oaIo7qytwazPZqoxJlrwHsl9FCQY899D59nALXgHkSUoQWk+NyEmg9w4oV/YuUT32Sov5PuutO0Vxwi5BsRZTRZnRTe8kEyF99x2eO0le3n7Js/McaeXdkgoLl0P02ndzD/nk+TNi/ySPPlcLdUhkeeIyFicwl1leHtaycqMRPfYC+1h15GxBeO+p0KixM1cy1SC1F3+FWikrNpP3/EKGdFkA0QZgfClWVMQHaVjfodwrA4Zc95YjPnTjigea8x4Svgn/3Zn3HvvffyyU9+knnz5vHzn/+cH//4x9fz3K4bak4JavRYDZdrCVYiBSowNWPLk5kEupoSkKfXUK29dKopzPD24/uOUNUx8vozKVAJDA3QVrbPcNk1W0kuXoUrteCG+NE0HH+L9vKDhjjWxaJxwSFCNVs5+dK/sO6T30dRVNLmb6C94oDR6H2JSqsMDCLdtaRfVLJSTRZyV91P1Z6nwexESSwxejz0EHr3efT20yQWLGfRA5+7ptp4Qu5CclfeT+2hV1CSxkoBCNWMSJxLV80hgkODmO1R6FqIgfY6dC2IMyEdiyMmwiu/exnoqKf+6Bt0VB1FDwVwJmSStWQz6QtvH1OmCvm9dFQewe9xYx3us4jNLMHdfAhhdY003kuJ7KtB764gd92jN3W/Q0flEYZ6WzHNeWjUtUXYYlBz7yB07g8c/t3fGKUaQMRkY8reZFxv/P1oHWco3/YrgHEDG093ixHQxOahZq0Pj+FLXUNrOsC5t35GdHLO5INDIeBy7RXD4o4Xri/V+54DqaMmRTbLVZPnE+qt4twbP8FkjwLr+AGJMNkwOVwE206A1IzfvNmB7u1Cbz0Ovl4K1//p5N7Pe4hJ/WLy8vLYsWMHP/rRj3j/+99PSUkJJtPolzh+fHK9EdOBcMXTHj3xqYqJZVYmp1x7gRulsQLjZ1aGOgzFVulzI6IilOV8fQCkpSSTOIMCmQu0nN1N2bZfI3UdxR6HDA1Rf/QN4nMWsuiBz03J+O14SF2n4fjbiLj8Md4pwmxHzVqH7/yrdNWcJLlwOQm5C4nPWUhP3S5k6lKU+EIQKrK/Ab31BFZnDJlLNo96nZwV7yM4NEj9kdeRHWcQVpcRAIV8ZCzaxNw7npqSCRQt4EOxRI0rsCissSAlfm8/Lef2UHfkdYJeQ1FcKCrJRaso3vjkqHLbVBPwuvH1d2OyReGInb6Vamf1CU6/8kNDPyRhHorJhnegmfJtv6ar5gSLHvzzcEBSf+xNqvc+ix4KIkxWZMhP+fb/JnfV/QSHBvBUvGz0RpmdMNSFHOolde468lY9ePmTmOG0nz9s2ChEWCzpPVWgB5FxheBpQ1hjUHM3jSxCbDGYsjcQAqr2Pkva/FsilqKaTm1DmKyjAhoYVszNWoc20Ezjia2U3PmJSZ17fPZ8avY/jxxoRrgyx55/bw2WqDjscYYgYW9DqfGAZZxF8PB2qWuYLXZCg60Rd5NSIgdbSchfgD0mmfqjbxBqPw1CBalhjU5g3iNfIjZz7OTrLAaTXgbU19fzwgsvEBcXx0MPPTQmqLkZaCcK14RLQDCZzMqN0leByTfXQuTsioxfQNe+ZPwdZ4zyyUXZDSklWvsZzI4Y4rMjr0Kmk67aU5S+/XNEfBGm9BUIk81I0bob6W3cy+nX/oNlj/7VdTu+f7AH/0A3at7SiI8LRyLC6qKvqYLkwuUIobD4oT+nYsdvaC3dS6jlSHjfuOz5zL/701jsoy+MQgiKbv0QmYvvoLV0L/6BHixOF6kl68Mqu1OBNSoWPTCIckkt/wLS1wtCoenEFuNmklCMmnELQrWg9zfRUXOK/vYaVn74m2Pew7Xi7W3j/O7f01VzPLyCjk7Jp3DDYyTkjlUMvp6E/F7OvP4fEJ2BmnP7yM00cS56fxNdtdtpPLGFnBX30XhyK5W7fouSWIIpeeGoPoua/c9TvPGjmKwO2sr2E/QN4kiaQ/rC24nPnn/Tu15rQR+Yxi6SpB5CbztuTPHEF6H1VqFkbYj4ftXkhYTKK+muPU1y0dh+se6GUoQrO6JQohAKIiabngsBxySISS8iOiWfweaDCMtmhC3WOHcpkb1VyJ5Kcm59IpyRu2DLIb2d4eb9Ue/Z22n8wx6HxeHC21uB3lNlLGouQu8sRfr7yVy8mdiMYrKX30tXzQlC/iHssclTphP1bmZSEcnPf/5zvvSlL7F582bOnTtHUlLS9Tqv68qB5iEc7r4x22+GrMqlTEUJSAiF4tue4PQr/4ZWtwMlZbGxuvL1obWfQfbVUHzvn8zIVHjNgZeMia2s9eGLohAKIjYH0Omp20V/e+11HEW9cCGOnKq+0Ax68fVaNVuZd/enKNjwQXobS5G6hisl/4qaLPaYpCnRSBmP1JJ1VO55Gr3zLGra8lGPSS2A7CojPns+Tae2oaSvRL1IrE+1xSBjsvCdf5WGY29SuOGDU3Zenp4WjvzuW2ioKBlrUBxJyMAAg11lnHjhH1l4/+dIKV515ReaIlrL9qGH/Jgy1465mSquTPTYPBpPbCVz8Waq9z2PiC9CzVwT3ufiPovaQy9zy6f/LaK9hZSSjsojNJ7YQn9bDUJRSchbRM7y+4hJm/kTUc6EDHpb9oxRZ5buRkN+IHmh4YEG4QmgMQybmQaG+sc5ypUmcMUE9onwLCFY/OAXOPbs3zNU/iLClWFk0jydSF8vafNvJXvFveH9o5Pz8HvcaG0njOzUxe9X19BaTwyLaxr+Z2mxKbSe24Pe34gSkzNszFqD7G8iZ8X7iM0whB/NNudV9QS9l5nwXeqee+7h8OHD/OhHP+JjH5s+19ipwGxSRgUw17tn5VJmosZKctFKFj7wOSp2/g+B86+Gt5sdMRTf+ycz8ocV8Lrpb600NFwirPJETA7CbKej8uh1C2qs0XHYXEn4e2sNY89LkN5OpH+AuKyxfSpWZwypc2eOcKXVGUv+moepOfAChHzD009O5GArevspFBnEGhWHMNuNxy5BWF2IuAKaTu2kYP1jU5ZpqNz9ezRU1KL7wxkk4UhAxGSj1e+mbOt/kZS/9IZ5JPW31aI4Esfoy1xAcWXhq99FZ80JQr5BTDnj91kEK6robSwbk22SUlKx/b+NjFhUKiJ5MVIP0VlfTsf5w8y/5zPh36SUkq6aEzSd2s5gVzOq2UrKnFVkLr4DqzN2St/7ZMhYuJHG42+jd5wZ1fAqQ0MgFEMdVwsY24a6I3+eQz0A2KIi9/vFZ82j+dy+iLYWUurI/gbi515dwGtzJbDmY39PW9l+2soPEPR7sWXkYY9ZjdUZS1f1CRLyl6AoKllL7qCr+ih4u9Aq30BJno+wxSF9vWgdZ2GoG5E4D9lVSlLBUpKLVxGTXkjDsbfw1u8GICopm5x7/4TUkvVXdb6zGEw4qNE0jdOnT5OZOba+eLPx/OEGzPbRAcONkNm/wExqsL2YlOJVJBUup7ehFP9gLxanUXKaiRkauMjrZBytBSEUhMk61hNlChFCIWfFvVTs+A16dxoivih8M5eBQfTGfdjj0kjIXXTdzmEqyVv7CKrVTu3Blwl1nw9vd6UVUrL5j6g99LIxkj6OXotwJBLqKqP5zC4yF2285vPxD/bSVXMSNWvtmJKYEApq6jJC5S/QWX2clDmrx3mVqUUxmS/rp3NB30cPDNuvWMYOJVy8PXjRxM8FOiqP0HRqG2rmOpTEkf4JmbIIrXE/5976GXGZc7FGx1P61s9oLd2LcCYZk3ehIWoPvUbjia0sf+yrRCeP1US6EUQlZpK/7lGjN8XbiRJnOJDr7gbD3dvXZzQF2+PR288gotJHZzikRGs/hcURS/w4JcasJZtpOrUdrekAata68PSmlLqhCh30krXkrqt+D6rZSsaijaTNv4WKnf9D8+mdAAjFhNQCWJxxzL/n08TnLCB94e20nNmFDA6iDQcqYZwpyIFmbDHJJBWuQAiFzEWbyFi4kZDfaG+4nNbMLBNnwnerrVu3Xs/zuKHE2k1YJhjETCRomalBytWgKOpV9ShIKQ0PqBvo7GpxxqJa7MiBVogeq0chA4PoQ+7rbraXuWQzA52NtJzZiegqRThTkMEhZH8jFmcMSx7+4k1TBxdCkLP8XrIWb6a3qZxQYAhnXFp4JN1ij4bAYHiEWUod2VeH3n3eMHvUNUBQvvWX2F2J19zvMuTuBCTCMc5orS0GYbIx5O64puNMhsS8xTSf2o7u6URxji7BSynRe6qMkdvhcuK4fRYeo8/CHmE0t/HEFkRU6qiABoYDuYzVaO56mk7vxOqMobV0L2r2rSjxIyUpmb4SrWYrJ1/8Z9b/8b9M28Ikf+0jww7krzE4fKM3O2LQTFa09lOo2bca76f6bbTqt1FSFhoeXT43eudZZH8zc+7/7LjXFWdCBvPv+TTn3voZ2kAzIiYbEMj+BmTQy7y7PhX+7l4L5dt+Rcu5d1DSlhm9QKoF6e0m2HqMky9+nxUf+jold36C6OQcava/SHBYPwphArMdPO1YXYkse3S07IIQYjaYmWJm5hL8BjCrsTI19LfXUX/kdTqqjiK1ILaYFLKW3EHWkjuvezlANVlIX3AbTad2IOMKEPYRd2opdbSWo0Yq/jqXeIRQKLnzE6TOWU3TqR0MdjdjcthJWfoE6fNvndEXLS3op6v2lOG15EokPmcBiqKimMwRA5LUuetoOrUd6a4HVxZa3Q5kfxPCmYoSm48MDBiPoVC177lrDmoufHYyMDjq73sBGfIjtcB1nXC7lMS8JTji0xlq2I3I3TQyjq0F0dtOID3t5N71UWLSCo392k5G7LPQ20/iTMiMaLvQ31aDSI6c3ROqGaJScbdWMeTuQsTmjQpowBgLVrPW4694mc6qYzcsixWJ1JJ1pMxdS3CoH10LYXXG0Va+n3Nv/gRND6EkLUDJuQ295Shazbbw8+yxKRQ9+IWIDcIXkzZvA9HJuTSd3Ep3QylISfzc1WQtuXNKAhpvbxstZ3ejZK5BvajsKhwJqHl3oFW+Rs3+F1j66JfJWnInmYs3426roa1sH97edkxmC0mFy2e8ivK7hfdkUPPOrlPkpyVO92nc9HTVnuLUSz8AswORvBDFZMc/2ErlnqfprD7B0kf/6rr/iPPXPkJP/Vm8VW8YpZ+oVAgOofecRw71MO/+z2KyXH8pcCEE8TkLDFG1m4SG41uo3v8cmn9kus/ijGXuHR8f1+QuJqOYhLwldNfvAUcKeNpQ8+9CcY1kw2RgkFDVWwy01RAYGsRiH6f8MgEc8ek4E7PwdpUiXJlj+nT0rjKEEFe88U0lQlFY+uiXOf7s9xiqeBnhTALVBp52pB6keOPHSMxfAkDJnZ/g+LPfQ6t6AyVpPsIWi/T1oXeeA7+bkvu/ErkfTFGvUOLSQILP3Y6aG9nXStjjwRJNZ82JaQ1qwPh9XKxjlDZvA4pqonLPH/BVvRHebo9NJX3BrcRnz5uUzlRUYiZzN//RlJ83QFv5AYRqQYkvGvOYUFSUxLl01x0I6zcJIYhNKyD2JmjmfjfyngxqsuNv3Kru3YoW9HHmtR9BVBpq7sbwKlRJKEZPmENfzRbqj7x+Xad1wFjJr/jQ16k79ArNZ3YR6jwHQHzOQvLW/Mkot+tZRmg4voXzO3+DkjAHU/4CQ0djqIdg+0lOv/JvLHnkiyTmjx1TF0Kw6IHPceA3/w9fXytK0rxRAQ2AsEShZq1Fq95CX1P5NQUcQggK13+AUy//AK1hD2rqMoQ12nCH7y5HbztJ9vJ7b7jwn92VyNqnvkdH5RE6q46hBf1EzV1CxqKNo8pJcZlzWf7416jc8zTui/osYjPnUnTLZ4lJL4z08iTmLaajvgyZsniMyrcMeJCDLcQvXkdv4zkuP90j6Wsqv5a3et1ImbOG5OJVuFuqCAy7skcn58y4Ufagz4OwOMMO12OwRAOSoN+D+RoC+GvF29dO86kd9LVWGW0EeYtIX3DblMsrzHTek0HNLNdOW9kBtIAPU+GasWOtUanIuIJhb5SHrns/idnmpOi2JyjY8BjBoQFUs/WGliNuNrSgj+p9z6IkzEHNWjfygCMBNXcTWs0Wzu9+moS8JZG1Q8xWUopWUn/ktYgS/wAiKh0UM4PdTdecRUkqXM78e/+E8u3/TajsOcOhOOQHJNnL76Ho1smbeE4Fimoide7aK06wxaYXsfJDX2fI3RFWFLbHXF4OI3v5vbSfP4zWuA81Y41RcsLIgml1uzDboshcvJmmk9sJ9NaEHd8vRnq7IDCILzCIb6AbW3Rk49zpRAglPL48U7HHJKL7+lFCPkQk3R1vF0I1T6uidsvZ3ZRu+aUhnBmVBrpG7zvPUnvoFZa+/6+ITR+bZXq3MhvUzHJVDHTUozjiEONMdghXFsHu8wS8bqxRY3shpoKgz8NARz1CUXCl5KKabdftWO8mOqtPogWGMCWP7XcRQqAkLcBbs4XBzoZxJ2cS85dSf+S1y0jJSxCgTJEhY9q8DSQXrTSk992dmG1OkotXYXXGIqWOb6AHkMbI+Qw1gbTHJEdsCo5ETFoB8+/5NKVv/xzN3QBRqaCHkIOtmG1RLH30y5htTmIyiuioOITWVW40sIYn7zyEGvYa2ipBD97e9hkZ1NwMpM5dT+Xup9HbTqJkrB4tThr0IrvKSJ279oaUuSPhbqmidMsvUOKLjPMbzijJ4BBa/U5OvvB91n/yn6c1i3QjmQ1qZrkqFJMJqQXHN/Ib1p9Q1KlvFg75vZzf/TtaS/eFfWNUi53MxXdQsP4Dk570kNJI0Tef3Y3P3YnF4SJ13gYShzUo3m0Eh/pHdEIiIC4InnnHEzwzbrqqxY7sq4WolDGPy/5m0ILEZY/V57laVLN1lF6SlDqNJ7ZSf+wtfO52AGyuJLKX3U3WsrtmbHAzUdLmbSAucy7NZ3bibq1BUVUSVt5J2rz14UxkfPZCOioOoTcdQO8sRYlOH568awCTDSVtGXrD3mm74b4bsDiiKbrtCc7v/B9k0DPixTTQiuw8i9lioWDdo9N2fvXH30RYXSiZ60Zdi4XZjppzO6HSZ2k5t4ecFfdN2zneSGaDmlmuisT8pTQcews52DpmXPXCWKsrrXDKVwdaMMCxZ7/HYFcTInkRakwOSA29t4b6o2/g7W1j0YOfn/ANTdc1zr3xY9orDhpS6LZ46K2lo/IIMenFLH3/X055KcsQSztJw/G36W+tAkUhMXcR2cvvISYtco/FVGKNig/rhFyQfx91fhcEz6LHMTjFKL3krLiPmgMvGuJwMSO9ENLnRm8+iCu1AFfq9WmWlFJStvVXxhh9XD5q3iZA4O+r4/yu39LfXsv8e/9kxvVnTBabK5GC9Y+N+3hy4VLKtymI2AKQIfTBNoRiQklbjhJfhNa0H6srkeiU3Bt30u9CspfdjdkeRc2+FxiqftvYKBSSCpZRvPFJbBHMkG8U3XVnEHHFkRvOzQ5EdDrd9Wdng5pZZrkccVnzDG+Uxr2QczuK00irh8daB1vJveMvpvy4Led2M9Bei1p8P4pjZIJNtccjHIl0Vu2kp/7shMXuava/QPv5w6g5tyFi88IXBn2wjf7a7ZS+/QsWPfj5KX0PVe/8wehHcSYjEueD1OioL6P9/CHm3fUp0hfcOqXHu5TE/CWY7S5CbScM76KL0+m6ht5xBldqAc4r6Pvkrn6Qwc5GOip3Gh5XjiTDaLO/CXtMMose+Px1Cyp66s/ScmYnatZ6lISRngwlJhvdlUlb2W5S5qwmqWDZdTn+TMHiiCFr6Z00ntiKkr4CNXuDIQwX8qG3n0L21VFw96du+qzVTCCtZD2pc9cy2NWEFvBhj02eVsXmMLpuGF6Oh1CRunbjzmeamQ1qZrkqhBAsefgvOPH8PzFY+Tq6PcEwr/N2Do+1Pkly4fIrv9AkaT6zCxGTNSqgCZ9TTA7CHk/zmV0TCmq0oJ/GE1tQEueNcdhWolIhfSUdlfsZcndMuBfiSnTVnKT+yGso6atQk0fk82XKYrSmA5Ru+QWxmXNwxI4t6UwVimpizsYnOfvGf6Lp241RY6sLOdSN3nEafL0UP/inV34dRWXhA5+lu/YUTad34u1txxzlJG3lx0mdt+G6ljyaTu9A2OMREcZslbh89M5Smk5tf9cHNQBFt30YPRSk+fROZNtJhMWJ7u9HDD+WvuC26T7Fdw1CKEQnjbVDmU5caYX0dTdCythrntSCMNhKbMm9EZ757mQ2qJllFFJKkHJCE0vWqDhWf/Tv6Kw5QWflEUJBP1EJK0hfuBG76/roAPn6uxGxkaclhBBgT2DI3TWh1+pvqzEaZuMjl0hEXD407qen/hwZiyYW1GihAN6eVoRQcMSnjenvaTixBeFIGhXQGOc+ohTbfGoHRbc9MaHjXS2pJetQTGYqdz/NUPVb4e3RKXnMeeBPJzyRIoRCYv7SiOPf1xNPd4shaDdOJkhEpTDY3XxDz2m6UBSVkjs/Qc7K99FefpDA0AB2VyKpJeuwOFzTfXqzXGeyl91N70v/jNZxbvRCadgqAqmRsTCyltG7kdmgZhYA3K1V1B95nc7q40hdwxGfQdbSzWQs2nTZZlmhKCQXLr8uWZlImO3R+PzjN7AS6McSkzah1wqnZMd7f0IBISaUutVCAWr2v0DT6R1hMTuzI4acZXeTs/L+cJDY31qNiBsnKFNMEJVOX2vVhM7/WkkuWklS4XL622oJDvVji06cEgXWG4FqsSGHhsZ9XAaHMI3jCfZuxRGbQt6ah6b7NCaEp7uZhuNv0VF5DF0LEpWUTdaSO0mZs2q2VDZJEvOXkLPyfuqPvIbsq0W4MkFqyL5aZMDDgvv+dFp7fm40s0HNNKFrITqrjtHbWAZIYjPmkFy8alo8WtorDnLm9f80XJZTlqKYrAwNNFOx/Td0151h0YNfuK5TQAMd9fQ2liGlTmzmHGIu01yaPm8D1QdeRAaWjhkn1z0dyMF20m77wISOG5WUg1BUdHcDaoTxZtnfBFLHdQVlUF0LcfLFf6G3yRirVWNzQepovTVU7X2Wwe7mcNOqUFSQlwmS9BCKYp/Q+V+Kp6eFtvIDhHwebK5E0uZtuOJKXQiFmOH3N9BRT/PpnQhFIT57wYy+EKYWr6LynWeQAUMY7WJkcAjpridl7cPTc3LvYXRdCxviWqPiiMueN+ba0V13mpMv/QBUCyI2D1QrA/0tnH39R3TVbmD+PZ+eDWwmgRCCols/RFxWCY3Ht+BuPY9QVBILl5C19G5c77Em8dmgZhoY7GzkxIvfxz/QjTLsZ9N0ajuW3b9jySNfwpWSd8POJeAd4NybP0XE5qJm3xK+mCgJxej9jXTVbKfp5Dayl9095cf2e/o489p/0NdUBhfUOvUQ1ugEEIKQz4PFGUvGgtvIXLwJk9VBxuJNNJ3eQaD6bZS0FYiYLGOSp68WveUo0Sl540r8X4rFEU3q3LW0nT+KjM4Ie/iAoT+htx4lOrXgin+PtvL99DacRS24G+XiSbCoVIQzhbayPaTPv8WwUcieR3vNGZTUpWOVYoNDyIEWEpd8cGIf4DC6FqJs6y9pPfcOwmRFmJ3ofjdV7/yBolufIHv5PZd9vrevg3Nv/gR3y4grN0KQMmcNJXd+ApPl6oKs60n6wtupP/YmwZotKFkbwsaS0tuF1rgPs9U+JS7hs4zPkLsTLeDD5krAZHXQVn6A87t+S8DTF97H4oyl+PaPhAUKQ34vp1/5N3CmoubePqLSm7II0VtDW+lu4jLmkDH7t5s0iXmLScxbPN2nMe3MBjU3mIB3gGPPfpeQMGOa81D4Rqr4+gg27OX4s99j7VPfu2Eicq3n9qBLHVPG6jE3WcWVhR6TS+OJrVMe1GhBP8ee+XuGBt2GzUKM0Xwn+5vxNx0ALYBImo8vMEDVXkNnYcXjX8PiiGHFh77O2df/E3fdDqNEJCUgScxfxvx7Pj2pbFfxxo8y0NHA4PlXEbG5CHsC+PuRfTWYbVEsfN//ueJrNJ/eiYjOGB3QDCPi8hGdZ2g6s5PYzLkMdjdB0IPWsBc1c+2IUmxwCK12h6HFMsnpp4odv6G1dD9K5lqU+CLDj2Z4+uX8rv/FbI8ape9yMQGvmyO//yZBv9+Y/orLQzhTkX01dFQew+9xs/wDX5lxLuNmm5Ps5fdQtecPaJWvoZmdIAQEBgFBdM58zLaZIQ8vpU5P/Vmaz+xmqL8Lq8NF2rz1JBWumDb37Mkw2N1M04ktdNefRUpDYdc/2Iu3pwUwyqautALczRWImFxMxbeCPQ6Gegm2n+bs6/8BCFLnrqG1dC9aKIApa90Y2wElLh+9r5aG42/PBjWzXDUz/xf1LqPl7C6Cfi+mkkcR5hH9E2GLRc3fTKj0OZpP7yR/3ftvyPkMdNQjHEkR5b8BFFcmQw3voAUDqOapM6dsK9uPt6cF05yHR7kvi5gshC2WUPmLCNWEmnMrMmUxQ9VvUbb1v1j80F9gdyWy8olv0N9eh7ulcrhcMh9HXOqkz8Nsc7LiiW/QfGYnzad34us4jdkeTfrK+8launlC0ufevg6EK3I2RwgBjiS8ve10VB7B09WESF2CbD9NyN1gaPxIDTnQAlKSvuyuSXm1+AZ6aD6zCyVtOWriiM+VMNlQ0lchAx6q979Iasm6MUFryO/l6NPfJujtB8WEHGw1xPTMUai5tyFyb6evegvddafDBo0zBb+nj+q9z0JsPkpcDgwa4nvCmTIcROyi5ezuab856lqIM6/9O51Vx4wFjD2ewYEWump+RHRqPsse/b8z2sW9rfwAZ9/4McJkQ8TkIH1ufA3nEM4U1NyNYHagD7ThbjmBiMk2si8XmrcdCai5t6PV7aRy9+9IKV6Fu7Ua4Uwade27GCUmG0/D3im/3szy3mE2qLnBtJ8/gnBlRfxRC5MNEZtD2/nDNyyoEaoprP4bCakFADHlK/XWsv2G67J9bEZKWKMRMTnovTWoyQsRthiUlCV0Vh/A19+FbXiyypWSOyX1YpPFRs7ye8lZfnVjj2ark1DAM/4OAQ/muFijPBSViil1KTK+CL37PNLTCUKgpC1HH2yjt3Fy5oNd1ccBRmm1XEAIgZI4F1/12wx2No6yPJBScvKlH+B1d6Fm32pkqRQV3duF3nwYrfpt1KL7EY4EWkv3zrigpuXMbiQCU+ZqhMkKMaPtHGRfDQ0ntk57UFO97zk6q08OZyNHBAp1TweDtdspfftnLH5o6vWcpgJvb5sR0MTmoWatB6kROvcHRFzBcKl6OHjRNTSpoyQvGjONJoRASV6Iv/I1epvKEIqCiNB4L0N+ZGAA3T9gPG+GZQZnuXmY/ebcYLSgf9ysCBiBjRb03bDzSSpYihzqMczvLkFKieytJiF34ZSnyYNDg+P6RgEIaxSE/CP/j80BKXG31UzpeUwFqSVrjUmDoHfMY3KoFznQTOrcdfg9boTVyPwISxRq2jJMhXdjKrgLNXkBij0B/0X9CBMhFPQhFJNhZBcBYTL6YbSgf9T23sZS+prKUHM3osQXjLisOxJR8+8E1YreeQ4s0fgvY5cwXfR31BnihSZrxMcVVyaergakrl+X44cCPppP7+T8rt9Rvf95BjsbI+7TdHKb4WQemzvqhq84k1HSltNZdRxvX/t1OcdrpenUNoRqQc1ah1BUI4una6hpy0cHLyFjCi2SOvXF2wMeNwk5C9G9XUhfH2CUXUMN7xA69we0868i20+hmKy0lR+4ju9slnczs0HNDSYqMRPpaTP0YC5BSokcbCU68caN1SYWLMMel4ZWvzssjw9GhkZr2o/0dpOz8v4pP649NiliIBU+vrcLYbmoDKOHAMY4gs8EMhdvwmKLQqvZYvjBSImUOrq7Aa12K464NFLnrsUWHY/09Y77OtLXgy1qfGuCSDjj05FaYNzPUh9sBaFgv0TMr738IMIWg4geqxosVDNKQrERqA31YJ+BU1CKagp/JyIhtYDxXbkOisbtFYd45yefpWzrf9F0bj91R97k4G++ysmX/oVQYGRB0t9Wgxb0ocRdRgcJSW9D6ZSf41TQ01gOrswRg0R/P1iixkybMZx1vvj6cTHSZ2y3RsWRXLQSa3QCWv0udE8Xoao3kP1NKKlLMBU/gJp/F9KZSulbP6Xu8GvX783N8q5lNqi5wWQuvgM51IveXTHmMdlThfR231AFUEVRWfbol7HZHYQqXiZ0/lVC1VsInXsG2VNFyV1/TPwUmhJeIGPhRqS3C91dP+YxfaAVOdCCkjCiFqv3ViNU84RF4W4kFkcMyx//fzgcTrTqt9DOPY129vdotduJTkhn+Qf/H6rZQvqCW5GeDvSBljGvIYd6kP2NZCyc3N8+IW8xFmccWuuxMXo6MuhFdp4juXA5Vufo3qCg3wNm5/jidRanETT4+2ekIm1S/lKkpyO84r8YKXVkbw2J+Uum3Kahp6GUM6//CN2ZhmneB1DnPoI6/3HU7FvprjvD2df/c9R5ADBeKeWCDpK8Ptmka0Ug4OK1l2KBkA95STApnClgiUZvPz1msSalRG87hVBMxKQXoZjMLHv0y5gV0CpfheAQpqL3oaYsQjgSUVwZmPI2oSQvpGrvM8Pu67PMMnFme2puMCabUXLRmw4YK5S4fECg99Ui3fWAoL+9juSiFTfsnOwxSax96nt0Vh2ls+o4mhYkOmkNGQtvv25TWIn5i0kqXE5n9S5kYokxJYRAd9ehd5xDRKUh4vKNrEd/E3r7aTIW3japJtobiTM+nTUf/y69jWW4WypBCOKz54c1YACSCpYTlz2f3trtyJTFI397dz2y/RRRidmkzb9lUsdVFJUF936GEy98H63yVUTCXIQlGuntRHZXYLZYKb79I2OeZ49JhprTSD00ZgoFQHo6AEFy8SpiM+ZM9uO47iQXrcTmSsJft9PoVxkucUgtgNZ8GOnrJWf5lSfXJkvtwZcQ9kTUnFvDjddCKIj4AhCCrprd9LfX4UrJJTo5B6GY0PsaUFMi6CC5G0DKG2JiejXEZ89j8OS28HdEic1FbzuO7KlGJI58J4QQKOkr0et2oNVsRUlZhLDFIn19RqAzYCg799SfJTF/Cc6EDNY89V32/vTzEFccdoW/GCVlEXp3Oa3n3rlpBAVnmRnMBjU3mIpt/wVgNIb21qDV7zYesMagZK5FDvXQdGob+eseua6Cd5eiqCZS5qwhZc6aG3I8IRQW3v85ag68QNPJ7YQ6zw0/YIjTSS2A1rAXOdQLvh6sUXH4B3up3P170hfejjN+YqrBNxIhBPHZ88bNbAlFYcnDX+T8rt/Scu4dQq3HLjxAypzVzL3jKVRz5B6RyxGfs4AVT3ydmv0v0l17EJAI1UxayTry1z0a0W07Y+Ht1B95Db3jLGrqklGPyaFe9J5qYjOKWHDfn85Ip2vFZGbZB/4vx5/7B3zlLyKcSaBYkJ52BJL593yG2MzJB2OhgI+WM7toPrML/2AvFkcM6fM3kLH4DpCS3sZS1KwNEcXhRGwuouUwHZWHcaXkYrFHk1qyjrbyg8joNMRFfmUyMIjeepSY9OJRDdwziYzFd9Bw/C1DfiB7g1GujCtAaz6IRKLEFxrmmf5+ZK/R6yZ9fWhVb468iHm4VGVxjp6i0yV6KIA6rC90KUK1oNjiGHJ3XMd3OMu7kdmg5gaiBf24W6vBGoOasggleSFoww2cqhUhBLq7kVB3BQFPH7bomdfLMJUoqonCDR8kb/XDDHY2IJFEJWTS21ROa+k7+Pq78PqChIBASNLd0U53fSn1R18nb83D5K97dEbecC+HarZScucnKNjwGO6WKkOxODX/mjNiMakFLH3/XxL0eQj5vVgcrssGSI64VPLWPEztwZeQvj6j1KdajaxYZynO+DSWPPKXM1pHxRGXyro/+kfaKw/TVX0CXQsRnXz1GcbA0ADHnvl7PN3NxqRS/FyGfH1U7X+BpjO7WPi+PzN2HGccWQgFYbKjXdRXM2fjkwx2NTJQ+RrClY1wJCB9/Uh3HVZnDAsuvCZGqaa/rZrBzkYUs4WEnEVYHNOXmXTEJrPw/s9y5rUfoZU+C64so2SGgt50AL3lCEK1IoMeUC3hCS/p7YSg1/icTA60smcRjLYbUS1WEApynKlBKXVk0IPJGvmzfi/hH+yl+fROeobV5+OySshYuDHiYmWW2aDmhhL0DQIS9CBSSuOGfOkk1PB4tTLONMu7EdVsISZ9JAWfVLCUpIKlHH/+H9G6WlAL7jbKUUIg9RB6x1lqD76EzZVIxsLbx7yelDpS12f0DdlijyapYOpNIM0254R1T4wsTgK1h17BV70FAMVkIWP+BgpvefymuKEoJjNpJetJK1l/za9Vsf2/8fZ1Yip+cJTUgPQP4K9+i6p3nkE125CDbeAa22Atg150Xx+OuJEsosnqYMXjf03L2T00n9mFr/e8oYO07hEyF92B2W6Uowc66jn31k8Z7GwIP1coJjIWbaT49o9M23c5uWgla5/6B5pObaO7/hxSSuIX3U5i4TIGOxsY7GygrWw/Ss5GFJchPimcI+av+oUMTmBwlN2IarKQXLiczsYKZOKcMSVQ2VeHDHjCSsTvVbpqTnD6lX9DB0SU8fn2HXqN+sOvsfCBz1+Xa8jNzsy96r8LMducxkon6EUOtCAuuTBKKdF7zmONip/WFdrV4Olpoa3swLAxYgKp8zZc00pioLOBnrrTqDm3jVLqFYoJNXUJ0tdL3eFXSV9wWzhb099eR/2R1+ioPILUNayuRLIW30HW0rtnhbwiIIQgY9FG0hfehqenFT0UwBGbclMEM1ONf7CX9vOHUdJXjtFOEtZolLRl9NbvIbVkPe2VR5HxhQjbSPO1lBKt9RiKaiK1ZN2o56tmK1lL7yRr6Z0Rj+3ta+foM99BV+yo+XcagoxaAL27gqZT2wn5PKMyOjcaR1wqxbc/OWZ7Yu4ipNTpa6nG334SGZUyajpRagG09lOgWjCZraQUjy5t5615mM6ab6LVbkdNW2FksfQQsrcareUIiflLcaXmX/f3N1MZcndw6pV/g6g0TNm3hGUbLpTmT7/6b6x96ns4LplsfK8zO/10A1HNNsOXSDGhNbyDPjiiTyG1IHrLEeRgG7mrH5zGs5wcuq5R+vYvOPCrL1N39A1aKk9SdeBF9v78z6k58GLE0fWJ0FVzEqFaELG5ER9X4osY6mvH29tm7F97iiO/+xs66koRKUtQszYQUGOo2vscx5/73hidlllGEEIhKiEDV0reezKgASMgRuoow3YdlyKGxf1caQXYouPRql5Haz2OPtCC3luNVv0WsqeauZufmrRCcN2hV9ClMLzDXJnDZSwbaspi1Mx1tJXvZ6Bj7JTgTEAIhXl3fxKGutHOv4reXYnuaUfrLCNU8TL43Agkix/6wpiFRXRyDkvf/1eYdS+h868QOvc0obO/R2vcT0rhchbe/9lpelczg8YT20CoqDm3jdKhEqoFNedWECpNJ7dO4xnOTGYzNTeYgnXvp6vmJLoeRKt6A80WhzDZkd4O0EPEpBeTtWTzdJ/mhKnc/Ttazu1ByVwz7DtkQtEC6B1nqdn/PGZ7FFlLIq9QL4euBUE1j+/WO/wj17UgWtDPmdf/A6LSjbr+BSG5hCL0xLm4q9+m7vArFKx/bNLnEfJ7aTm3l67ak+haiJiUXDIWbboqS4ZZZhZS6iMTTBfGrscbrx7uBzFbHax84hvU7H+BlnPvGJkIwJVWRP5dH520oaCua7SV7UckLYgoJCjiCxDtJ2gt3TtjG4rjs+ax4kNfp2rvM/Q27A1vF6qZ5LlrKVj3/nF/L/HZ89jw6X+lq+Yknq4mFLOFpIJls9kHoKvuFLiyI04nCsWEiMmmq/YMxbff+HObycwGNTcYZ0IGKz7015x982d4uxvB14ukF4RC5pI7mbPxo9N9ihMm4B0wFFNTFqMmloS3C9WCmrYMGfBQe/AVMhZtmvQkV3RyLjLgQXq7EY6xDdOyvxHFbMMRm0x7xUE0vxdT/n1jxPkUZzIyvoimUzvIW/PIqN4ELRSgrewAraV7CXjd2KITSF9wG8nFK1EUlb6WKk48/w9oAZ9RElDNuFu3U3/sTeZu/iMyF22a5Cc2y3QT9HloOPYWzWd2EfD0olodpJWsJ3PRJhSTBb23GjV1bJ+C3lsDQiEuqwSLPZq5d3ycolufwD/Yg2qxYXXGXtX56EE/uhZEtUb2GBNCQViiCMxAVeeLiUkrYPljX8Xv6SM4NIDFGTth+QVFUUkuXA6Fy6/zWd5cSF1HqJe5bgoVqY21nHivc1MENXV1dXz7299mx44dtLW1kZ6ezpNPPsnXvvY1LJabr1fClZLH2o//Pf1tNXi6m1EtNhJyFtx0qf+u2hNIXRtlpHgxSuIcApWv099aPWnRvMT8JVii4gi2HEbN2xx2swaQ3m5kVzmZi25HNdsY6KhHscchrJEvosKVSbCrjIDHjW1YHTfgHeD4c99lsLMB4cpAWGIY6u6k5/UfEXd6Hon5S6jc8zRYYzDNuz9s6SD1EHrLEcq3/gpnfDpxmZHf+yzTi5QSd/N5BjobUEwWEvMWIRSVI09/m6H+LpTYfNT4eUh/P83n9tJWfoCkohW0VxxC2BMMf7YLPk0Drci246TMWT1qIlE1W645Y6eabUbz8VA3xI01RZV6COlz3zSTLlZn7FUHeNeKt7eN/vY6FFUlLmvejDYKnQix6UW0VR5HylVjMtZS6siBJmILl0zPyc1gboqgpry8HF3X+elPf0phYSFnz57lU5/6FB6Ph+9///vTfXpXhRCCmLSCUeJsNxta0G80PquRR4fH8x2aCIqisuj+z3H8+X9Aq3gREVeEsDjRPR3IvlqiEjMpWP8BY1/VbFgFXJgoG3OixvEV00hgVPr2z/BcmHS5KBOkD7TQW7ud3kZDut6Ud8cojyqhmFAy1iA9HdQffWM2qJmBDHTUc/aNH+PpbjK+n1IHoWBzJeL3DmAqfiDswQUgkxegVb9Nb2M59tgUhmq3gz0eYYuHQD/S00FMxhxK7vzElJ+rUBTSF9xK05k9yKR5Y4xu9a5yZMhH2vxbp/zYg52NtJ8/SMg/hCMuldSS9TdlIODr7+Lc27+gt+FseJtQzcbk2G0fntFTkJcja+mdtJ7bg95y1GhgH762SSnRW48h/QNXVdp/t3NT/LXvuece7rnnnvD/8/Pzqaio4Mc//vFNG9S8G3DGZ4DUDcGzqLErVjnYCggcVymUF5tRzOqPfJv6o6/TVn4ALRTAGp1A5rpHyFp6NyaLMQ6fWLCU+qOvIweaEa7M0ecgJXpPFdEp+VgchnKpt7eNrpoThojaJaUtJTodmbwQve0EOFMiZn+EEIi4fLrrTo4fSM0yLXh724xJItURlgJAD6J1lOJrP4GSsWpUQAOGiaySvoJA9RYuzE4oIQ82rDhTs0ib/2ESC5ZeNzHM3FUP0H7+CMGqNwyn6+gM0Pzo3efRu8rIWnb3lIpNakE/Z9/4CZ1VRxBmO8JkQ/e5qdzzNHM2fXzSVh3TScDr5sjT3yYQCBhu865M0IPoPVU0ndyOf7CXRQ98/qb8jbpS8ije+CTnd/6vMS0bkwNieNzd10fx7U++p6fDxuOmCGoi4Xa7iY+/fErW7/fj949kCfr7Z3Zd+mYjLmsu9tgUfK3HEAV3j2pok8Eh9I4zJOQtwu5KvMyrXB5nQjrz7v4UJXf9MVLqEW8ssRlzcKUVMdC4D3JuQzhTDE0bLYjedgI50ELexj8P79/bZPhuiQjpfgAlLh+97UTEBr0wQp2UA7RvoJuWM7sZ7G5CNVtJLlpJYt6SkQbVWaaEusOvGZNE+XeNNN6qFpSoZLR2w707EiIqHYRirIidSeitxxlytzPvnk8Tm14U8TlThTUqjpVPfIPybb+mu24/FwyXTLYo8jd8kJxVU2soe+6tn9JZcwI1+xbDnkQoKEEvWutxyrb8HIvDddPonzQce4uAdwB1zkMXZVStKClGw3Zn5RFqD7xI1rK7b8osVPaye3Al59Fw/K1h8T2Iyywhe/nds1nicbgpg5qqqir+/d///YpZmu9+97t861vfukFn9d7C29dOy5ld2KLiGWo5j1bxMiJxLsIag/R2IbsrMJlNzNn08Sk5nhACISKvlIUQLHn4zznx/D8xUPWmoTNisoO3C6kHKd745CVeWlcaMx9O8w62IUP+iFMp0t2AKzV/QivAppPbKN/xG6OJ2ZEEIR+t594hKimbpe//q+vmr/VeQ+o6beX7EYnzxv7NLnx3tGDkJ+shkBIhVBRHEiJvM1rV61Tve47lj331+p44hv/a0kf/iqH+LjxdjSgmC7HpxaNKplOBp7uZjvOHUbM2oMSPCF4KswM1az1aYJCaAy/eNEFN89k9iLiCUSVi6e0m1LAXht3Baw68QO3hV8laeieFtzx+Q+1npoLYzDlXZfnxXmVag5qvfOUr/MM//MNl9ykrK2Pu3JGItLm5mXvuuYfHHnuMT33qU5d97le/+lW++MUvhv/f399PVlbWtZ30LNQefJnqfc8hTBawJ4DJYfi/NB8GGPEdWvsItmvI0kwGiyOGVR/5W7rrTtN+/jBa0IczfjUZC28bcw4XmpZlX71hRHgJel8tFwIbrWm/oRNxUaOe3n0eOdhK9q1XFkTrqjlJ+fZfoySWoKQtDzc86552PPW7OfnSv7DqI387belxLRSgr6mckN+LIy5txo4NTwQtFDD8hCIYJApHIphs6D2VqI6x30m9t8rYb1gQUygqSkIJvQ178Xv6bljzq92VeE2ZzSvRUXnU0H+KG1u2EEKgJMxhoH4Xvv7ucFP9TEVKSdDbjxI/4rUmfX2Eqt4Ca7SRrYtOg5APvauChmNvEvIPMe+uT07jWc9yvZnWoOZLX/oSTz311GX3yc8f+fG1tLSwceNG1q1bx89+9rMrvr7VasVqnbxB4Czj01q6l+p9z6KkLDbceBWT4aQ92IpWt4uYlByWfeAr06LgKxSFxPwlI6Z54+CMTyc+dxG9zUcRjoSwwzOA7ulAbz8FJhtKxir0hncIlT6PEp8PigXdXQ/eTjIWbSRlAhLutYdeQUSloGSsHhW4KM4UyNrAQPXb9DacIz5nwdW+7atCSknD8beoPfgyId9geHt0Sj4ld/4RrpTIpbmrZcjdQcPxt2mvOIQW8OGITyNz8R2kzdswZY2cqtmCyepE93ZD3OhgVSgqSmKJ0StljUVJnIMQyrALfCN6y1GjFHPRih+bERwFhwanbaJnqtGCPjBZx0gfhBluVNaCvsiPTxN+j5u+5ophV/MCbK5EhBCYHTFovr7wflr7KTBZMBXeMyJYZ3agpi0Fk42WMzvJWXEvzvj0yAea5aZnWoOapKQkkpIiu7ReSnNzMxs3bmT58uX86le/QpntRbjhSCmNm3RMNmrasvB2IYSh45K1DnfdTjw9zVN+U5xq5t/zGY498x28FS8Z47vWGORQD3KgGUdCJt6eFmRXGUrqcqS3A72rPFyimKiZZsjvxd1yftjVeey+IioNYY2ms+bEDQ9qag++RM3+51ES5mDKKQGzA+lpZ7D9JEf/8B1WffhviEqcmqymu7WK48/9A7ouEXEFEGNncLCdsi2/oP38YZY8/MUpCWyEUEhfcBuNp7Ybk0QXByiAHC5B6c0HkZ1nwBaH9PVBYBARnYGaOTpIld5uEMq7JqABcMSnIf0DSP9AxCZ4OdiKYrJgvWh0Pejz0HruneEMqJ+oxEwyF98xaZmGqyEU8FGx/de0lR8YMcQUgqSC5ZTc+UkyFt5K/dG3kMkLwGRD9tWhpC4bpcB7ASWhCNl+krayfVclxDnLzcFN0VPT3NzM7bffTk5ODt///vfp7OwMP5aaOqvseqPw9Xfi7WlBzbsj4uMiJhthstFVc/KagxpPTwve3nZMFhsx6UVTPpZpdRrlqtbSd2g5+w4Bbys2VwIZ6z9N6py1uNuqOb/rdwy0Hgk/Jzolj6JbnyA+e95lXnkE/UL/xjjmpEIIhGpFD43T53Gd8Hvc1B58CSVlEWraiOCZiMlGRKWhVb5K9b7nWPzQX1zzsXQtxKmXf4hudqHmbx652SQvRB9opqdmO3WHXyV/7SPXfCyA3FXvo73yMIGqNxDJi1AumiSS3RVkL7+HtHm30HJ2N96+drrrmhGubJTcjaOatmXIj+wqJblwRdh08t1ASvFqKnb8D1rr0TFlVekfQHaVkV6yPjxZ6Olu5tiz3yXg7Ue4MhEmG57as7SV7SN7+b0U3fbh61Y61bUQJ1/4J9xttYjU5ahx+SAEsq+ervoTHHvmOyx55Eu0lu4jUPUWImkeSH2UJ9fFCMWEsEYT8MwOjLybuSmCmq1bt1JVVUVVVRWZmWNHdme5MeihkPGPcW/SCigqHZVHGHJ3EpteRGrJWlSzLeL+kRjsaqR826+NVPMwFkcs+WsfJmPxHREvoFLX6W0uJ+gdwBadgCutYEIXWpPFRtaSOyNqPcRlzmX1k3+Lp7sFv6cXizOWqISxzsyXw2yLxuKMJTTQBLFje1VkwIPu7b7hfSzt5QeQCNSksdkhoZoRiSV0Vh8iMDQwYVXY8eisOkbA04dpzsNjVs9KdAYyvpDGk9vIXf3glDRwWhwxrHribyjf/t90Vh9CH7Y9MNtd5N/6IXJWvA8hBHM2fQyAhuNvc37n/6A37IbEEoTZifS0o3ecQUWnYMPNt6LXggHaKw7QWrafgHcAR2wS6QtuJzF/MarZyvx7Ps3pV/8drfJ1lIS5YHEgB9uR3RXYnDEUbDD0n3Rd48SL/0xQF5hKHh0RoJQSvauUhmNvEpWYRfqCiWvoSF2nu+40ndXH0UMBopKySZt/S8TvWWfVMfqaK1AL70W5SDJCJM5BOJPxnH+ZrpoTrPzQ1ynd8kt66g8ZxxjqgQgeXlILIn1urDeJkOEsV8dNEdQ89dRTV+y9eTegayE6q44ZKsNmK0mFy6+rx5DUdTprDF+ZgOeCTcCtxOcsiBgU2FyJqBY7sr8JIunSDPUiAx4GezU8fd20ntvD+T2/Z8nDX5zQ+KGnp4UjT38bXbEaq8ioVGTQS7CzjPLtvybk944x+2wr20/lnqfxD/aEt9nj0pi76WMk5C68ik9lNM6EdJwJV1d/F4pC5uI7qDn4EiKuYNSFWUodrfkQitk6xtX5euP39KFYnBGnugCELQ6GmzCvNahxt1YjbK4xztfhY8XkEOyuwD/Qgz1mYqXoK2GNimPxQ3+Of7CXwe5mVNWMK60gYrYve9ndmKx2qve/gL/qzfD2uOz5zN30sSnVh7kRBLxujj3zXTzdTYjodIQlGm9LPZ1V/0xS4XIW3v85kotWsvyxr1Jz8KWwV5NitpGx4Bby1z4S1nPqqj6Bz91hiBVeLEApBGrSfORgG/VH3yBt/i0TWkT4B3s58cI/GSretliEaqW17ABVe59l/t2fGvM7aDm3B+FMGfW7CZ+DPQ7hyqb57G6ylt7Fsg/8X7y9bZRu/S/cbRXIxLkI0+jFlN5VhtSCpM3bMOnPdZabh5siqHkv0FV7inNv/pTgUD/C7EBqASr3/J6UuWuZd9enprzxNhQY4uSL/0xfU7kxGWJ10d9bTnvFARILlrPogc+NuQmoZgsZC2+j8eR2ZGyu8bxhpB4iVL/LUHAN+ZCqBRBo/iGOPftd1j31PRxxl79BVO99Dh0TasG94RuuMDtQcm5BM9uo3v886Qs3YnEYN9qWc+9Q+tZPETG5qEXrEFYXcqgbX/tpTrzwTyx79Ms3vFflUnJWvo+ehlL6qt9Gj81DiU5DhnzInioIDLDwgc9jsthv6DlZnDHoAQ/KeOPqvj4QArNj7BTRZBGKAro2vkihHhrZb4qxRsVNaFw+ff6tpJVsoL+9ZlhdNwV7TPKUn8/lCPm9tFUcxNvTisnqIKV4Fc5JZgYBzrz+Y7z9PZjmPISwj2QkdHc9ndW7qNn/PIW3PE5cVgnLs0oIDg0SCvqwOFyoptHXmN7GUhRb7Kjf+cUosXl46ncTHBoM/ybHQ+o6J174JzzubtTC+xDOZGPaKuRDaz7M2Td/gi06YdTosn+wd1QT/6UIWxz+gdrw/x1xqcy/59Mc/t9vEKp6AyV58ajpJ727nJyV909Z8DzLzGQ2qJkBuFurOfXSv0BUGqacOxC2WMPzpbea9vOH0bUQix/8wpQes2zrr3C31qAW3I0SbWQipJRIdz1dNXuoeucPFN/+kTHPy1/3KL1NFYYeTGweijMFGfSgd5aC5ke4slDTliPscciQH727Ar31OKdf/RFrPvadcc8n6PPQUTUsBx7hRqskLyTUVUZb+X6yl92NroWo3P07RFy+oSQ6fMMU0emIqFS0qreo2PVb1nzs76dVTVQ1WVj26JdpPLmVxpPb8DVUIxSVpMLl5K68f1oUQVPnrqVy9+/RO0uNqZCLkFoQ2VVGYv7Sa87SACTkLqL+yGvIwVajmfwS9N5qHPHpWKOmtyQgFIWYtMIr73gdaC3dS9m2X6GHAijWGGRoiJr9z5NcvJr593wGXQvScnY3nTUn0UNBXCm5ZC7ZPKocGhwapPbwK/Q2nDWynPbRn6cSk4NMmkfjyW3krXkY1Wz8xsz2qHF7hqSUcLnfTrgf58oilN11pxjsbEAtvA8lasSBW5hsqNkb0Hy91B15jSUXBTXWqDg8HW3jvqb09Y4JWu2uRFY+8Q3Ktv2K3oY94e0mW1S4/DjLu5vZoGYGUHPgRbC6UHM3hUcthWJCJMwBYaKzcg8DHfVT1nvhG+imveIgSvqqcEADw42rsbnIoR6aTu0gf+0jY0w2TRY7Kx7/Gg3H36bp1A78jZXDFzcBjiTUvE3h5kNhsqKmLAIhGGw5im+ge5Qh4MUEvG6jyc8e+eYmTDYUSxT+gW7AyGwFhwYw5WweE7QIoaCkLMJTs5XBzoZp115RTGZyVtxHzor70LUQQlHGGNTdSKzOWPJWP0jtwZdA86MkloDFiRxsQ287iQh5w75a10pcVglRSTl4mvYjcu8Il6Gk1NE7zyHd9eTc9ambUsb+Ar6BbhqPb6G1/ACa34s9NoXMRRtJX3DbFcXzLmRoRVw+prTlCIsTqWvI3ho6qg4SevkH9LfXEfJ7DAsAxczAuX00ndxG8e0fIXv5PQx01HP8ue8RHBoEoRhy+hFQYvMJdZxloKN+QpNLselFNJ3ciuLri5gx0fvqsMekYLZfOaPXUXXMKBk5x2bAhFAQ8UV01RoLuAsZ4vT5t9Jd++/og21jSlByqBfZ30DGxo+NeT1HXCrLH/sq3r72cCn/eggZzjIzmQ1qpplQYIju2lMomWsiakeIuDxE6xHaKw5O2c25p6EUpI4SQXgOQIkrINR+CndrdcS+FNVsI2/1Q+StfghdC3Hwf/4ab3cTatK8iDdrJWEueutxzrz2I5Y88pcR5crNtmhAgN8duV9HC6AHPFgcxmSDr78bEOOmp4XNuHkOuTunPai5mJlirpe/7lFUs5XaQ68Q6ioLb3cmZjHv4c8SnTS20fJqMNSev8ix577HUMVLhkeYyQHeDmRgkJyV90+q0XSmMdDZwLFn/h4tFETE5oPLicfTQfn2/6at4iBL3//ly5aOaw68iIhKMSwLLmQbFRWRUITUQ/TUH0I4EjDNuy9sdil1Db31OOd3/S/22BTKtv6SkLCipBait58eP7tyYfsEhyuSi1ZiccYSbNyHmrd5VAZV761B9tWRvemjEwpI9VAAVOu4+wrVClIi9RAM/0aSilYQmzEHd+12ZMpilLh8EAp6Xx2y/STO+AzSF9wy7jEdsSk4YlPGfXyWdycz4wr7HibkHwIkwhzZl0QIBWF2EPJ7p+yYYc+icWwHGA6uwroQl0FRTTjjUvB2N4ElchpbqGYw2XC31nD06W+z8olvjMkAWRzRJOQtoqetzJA9v8R3Se8qB6mHBe9CAQ8gkT53xBFOOSzINeTuuOJ7eC8ihCB31QNkLb2LnoZzhAKGU7MrZWLWD5PB5kpgzce+Q8f5w7RXHCIUGMKZvYqMRRvHHf3XtRB9zRWEAj6ccWlX3ax9PZFS5/Qr/4qmWFHnPjCqMVUfbKevZgs1+5+j6LYPR3y+b6CH/taq4dHqSJ+5ACRqzu2j3LuFoqKkr0B62qh65w/GdFnJo6AFDK+z/iZEhOkfva8exWQlKmli+kOKyczih/+C48/9A6HSZxHOZGRgEIJe0IPEpBWRNsGANCoxi7aKw8iQb0wDL4A+0IzVlYhyUeCkKCpL3v9XVOz4DW1l+wi1DMsrCEFS4QpK7vzEpCYrZ3lvMBvUTDMWezSq2Yb0dkDM2IuNDPnQfW7sU7jiiEkzMjTS3RDR1FF3N4BQiE7JndDrZS25k86qY0hvJ0RIL8uAB4JDKKlL8Haepe7I6xRGGJUtWP8Ben7/t2g1W1BSlhqr+qAXvasMveMM2cvvwzY8jumITQUEWvupUatcGC5tdJwBBCbrzWdidyNRzVaSCpZdecdrRRp/F3tsCqrJTGLBMqKTc8fuJiWNx9+m9tDLBIcGwttjMuZQsvmPiEqMbEg5HfTUn2Worx216L4xN2olKgWZMJem0zvJX/eBiNkaLTCs2mt2jHkMQHpawZE8vlN8bD6eliPgSEIMW0MIZzJa82GELW7U8/TBdvSuc2Qt2jhmQXE5YlILWPPRv+PEC9/H29MMtljjmuEfwN1ayZHffYvlj30lnEGNRHBokPjchbDvObSWo6hZ60f9XvXBNmRfLVm3fHBMcGey2Jh/z6cpvOXxixSFC2echcOQu8MYofe4sUbFklayYcad43uF2aBmmlFMZtIX3ErTmT3I+OJRFyIppdHjgCRt3vopO2ZUYiaxmSW4W48hnEmjzeCGepHtp0gpXjVhJdX4nAU44jPwdpxFiSsYdYGXUqK1nQBFRUmajx7y0Xx6JwXrHx1TqnKl5LH8A1/h3Ns/Z6j6rfB2xWQhb80j5K8bEWgzJkMksrcaDYmavBCsLqS3G739FHKwDZA44mbTz9NNV+0pzr7+n4T8HhRbLFILUHf4VWIz57LogS+MmpypOfACtQdeRCQUY8raaCgdD7bR337KyPJ9+JszZsza3VqNMNsRjsiTUiI2G63zLN6+tojlPGt0PEI1G9/VCCVXtODlp8IUFZAXNeyCmnMboao3CZW/iIjNQViikd5O5EALsRlzKLzl8cm+TVrO7sHb24aaezsiJjcceEhvN97abZx5/ccsf+wrY57XXXeG2kMv09dUbpyuyYreU0loqBslvhhhsqL3NyP7aonLnEv20rvHPQerM4aU4lWTPvfrjZQ653f9lsbjWwyNJ2s00t9P9b7nyF15PwUbxgZqs1xfZoOaGUDemofprDmJv+p1w2E4Oh2CQ+jdFcj+Roo3fuyyK6GrYcG9n+HIH/4Of/mLiNg8hC0G6e1Buutwxqcz547JuWsveeRLHPqfrxGqeAUlZdHIVFRXGbK/yVidqWaEM5lgVxltZQdILloRnsK4QGzmHNZ94p/oa64YHm+1k5C7aMzqMjopm+iUfAZ6O5ADrYR6a0YetESDLQa7zUZsxqy77XTS317LqZd+YEz25d9jjN0P+y25m/Zz8qV/ZuUT30AIBf9gL7UHX0ZJWTzahiMuDxGdjlb5KjX7X2Dh/f9nGt/RCBfG1Q3X90jj6trwfpHLvCaLjbSS9bRWHELGFVyyoNGRwSHw9SKDQwjz2LF/6a7H6krEP9CJDHoRZgfCEoWp+EH0nvPoPTVIdwOKaqLk7k+RWrJ+0j1dWihA44mthiFr7OisrnAkoKSvpLd+N4NdjaNsNVpL9xoN0M4k1KwNYLYjB1uh+zyqNoTWfBAAa3QCWRs+QPaye27KRt6aAy/SePxtlPQVKAlzjSBVC6J3llJ3+FVMVie5q+6f7tN8TzFroDQDsDhcrHzib0gtXoHsOI12/lW02m3YTToL3vdZspfdNeXHtLkSWf3kt8lf+zBWzY3oOodd8VF064dY+eG/mfQ4ryM2mdVPfhub3YHedIBQxUtoNVuRgUHU3I0oCcPO2EEPAOfe/DF7fvJZ6g6/NkYVWghBXOZcwzRyzppx0+Ulm59C0QNgsqIkzkNJXYKSvAhUMyIwSMldn5hdJU0zdYdfBYsTNXfjSIlECJSYbJTsW+lvraKn/hxgCCkiFJTkCErHJisiYS4dlYcJBYZu6HsYj4SchUgtgOxvjPi43lONNSoe52X0mQo2PIbVHoVW9Tpa20n0gVb0nmq0qjfB14NQVbSm/UYD7cWv3V2BHGghf3g8W2vcF95HmKyoyQtRk0pAD1Gy+SljEusqmtQHOxuMyasIrt5giCeiqPQ0nAtvC/o8lG39L0NuofA+lIQiFFcmavpKTIX3oWsaWcvv4fbP/owNn/ohuaseuCkDmlBgiPqjb6IkL0BNXmj0DmL0EKqpi1ES51J3+FW0UGCaz/S9xWymZoZgdcYw/57PUHz7kwy5OzFZbNhjU67rTdlsiyI+a54xdSB1YtOLic+Zf9Xjxo64VObf+xmO/eHvUNJWoLgyjRr8hXS1HkLvqjDE8tKXo3eWUvXO0+ihAPnr3j/p47lS81n5xN9Q9c4f6K47Hd4emzWPog2fJyZ9enRHZjGQuk5n1TFEytLIk31RaQhbLB3nD5OQuxDfYA+KNTqiGSGAsMej6xoB78ANFyyMhCs1n5iMOfQ3HUSYnWGROil1w2uqt4qc25+8bAnJ6oxh5Ye/Sc3+52gt3WeUajF6iPLv/QRy2DtLK3seEZsHqgU50Iz0dJC5eDPpC27D5krk1Ev/glb2HCImD0wX9ukkY9EmkgqX426tAiGISswaI7J3OS4MFYx7TRACEKMWJm1l+9C1EKb0FWPlFuxxiPgiWs++Q9EtH7qpFx099WfRgz5MCZHV0pWEuYS6yulrKichd9ENPruJEfJ7aTm3l47zhwgFfDfUrPR6MRvUzDDMNmfEkeepxjfQzamX/5WB9hqjB0YIZPBF7HFpLH7ozyftc3SB2Iw5xGXPp6/5NNLsMFbnQkUO9aI1H4agN7xqVzPXgGqm9tDLZC7ZHJZnnwzRyTksffTL+Ad78Xv6sNhdsw16MwRdCyF1DWWcRlghBJjs4cyLxRGDDAwitWB41XsxhtKxgmUGGUwueuDzHH/ue3jOv4pwpoDFCd5OpH+AjMV3kLVs/D6RC1idMZTc+UmKb/8I/sE+VIsdq3Ok3LzmY9+h4cQWOquOo2tBopNzyd78ERILliGEICFnAWs+9vc0ntxKR+UxdG+Q6KRsMjZ9iL7mSvb85HPoQaMp2WR1krX0TvLWPDyhzE1UUpbRC9NXhxpBQ0r2N4MeIja9KLzN092CYo8bNbEV3l/qIBRCfg+nXv4BMWmFRmB2E/ox+Qfdxj8ilAYv3h660BA+w/D0tHLs2b8n4HEbGkgXmZVmLb2b4o1P3pRB52xQ8x5EC/o49sx38XkHUfPvREQbAYz0dOBrPsixZ77Dmo99d9SF9VJ66s/ScPxt+loqEUIhPmc+2cvuISatgMUPfoGzb/yYrpo9iOaDyGHrBEx2w6nZMRJ0KEnzCXWco73iIFlLr77MNlFJ/OnC7+kj4O3H6owZtz9K1zW6qk8w0FmParKQVLB8Ro4yTxTFZMYSFU9wsDWiJpLUgjDUhTPeGNNPLVlH9b5n0bvKUVMWjtlXdpeTVLBsUtM71xtFNZG5aBM99Wfw9nWgmAVR6UvJWLRx1I3+UkJ+LwOdDQC4UnJRzTZUsy2i15szIYOSzX9EyeY/Gvf1HHGpzNn4UeZs/ChgBJTHn/9H+prPoyTNwxSTi0RH762l9tArDHY3s+iBz10xK2uy2A1rlNM7EdEZo9SAZWAQveUw0Sn5uFJH/r6qxWZYgUh9tAt4YJBQ9RZDi8oWT09XJ931pdQceJGSOz9BxsLbw/v6PX34B/uwOFwzKuDRdY2WM7toPLkdT5fx95ODrQhXhMnVwVaAq7K7uN5IXefki/9MMCQxzX1/uJ/LMCsto/HE20QlZY36m9wszAY170Hayg4w1NeGae4jo8TrRFQKIv8ugmXP03xqOxmL78A30IXZFjVKxKrm4EvU7HsOYY9HxBaB1OmoK6W94iAld/4xGQtvY8kjX2Kwq4mm0ztoOrEFJXUZSvKCMWUIYbIhLHb8HveNevs3FHdbNVXvPEtvw9nhLYKEvMUU3fL4KL2Q3sYyzrz+nwQ8vcYKVw9S9c4fSCxYxoJ7/2RG3cgnihCCrMV3UH3gRfTEOSiOEc8dY7LvBFLXSF94G2BI3Gcvu5uGY2+B5jOUjs0O5GAreusJhOajYN2j0/V2xtBwfItRPtVChhJwcAikTnzm3LBswqVoQR+Ve/5Ay9ndhiAdhphl5uI7KNjw2JSJM7aV76evsXSUw7UAY/zbmUxn5U66a0+TmL/kiq9VeMvj9HfU4656A92ViXAkIv0DRqOyM4aF93921Io+uWilYY3hbkDE5gJGhiZUsxWkhqn4wfDCRmoB9JajlG35JXZXImZ79HA5+QxGAzbEZc2j8JYPTpuNxQV0LcTpV/6VrpqTiJgsRPpqowey5RjCmTKqbCpDfrTWE6gW+1Vnva8nXbWnGOprQy26f1SDumFWOi9sVpq+YDwNpZnLbFDzLkEL+uioPMqQuxOzPYrkolXjZlraKg4iXBkR1XiF2Y6IzaXu6BvUHHwxrD4anZJH4YbHEKqJmn3PoaQuRUlZPNIvk7oEvekgZVt/QWxGMc74NKISM8lf8xBNJ7YizLaIfRUyOIQMeLHN4CzL1dLXVMGx574HlmhjAsQWC0M99LSWcvj332LF41/DlZLHYGcjJ174J6QtIWxEKHUN2VdLd90hTr3yryz7wFduuosLQPbyu+msPs5A9dvI+CJEdCZofvSeSuRAC8UbnxxlnVF024dRzXbqj75BqONseLszIZN5D391wsJx15uWc3s4v/M3KIlzMaUsDpvQ6p1l1B99HcVkomD9aC0mI3vyT7hba1CS52OKzQNpZE/qj7/FYHczSx7+4pSYezaf3oVwZUR2uI7JQTgSaD6za0JBjWq2svwDX6G1bB/Np3cy5K7BbI8ibd37yVi0ccxQgSs1n/ichfQ27hs+XrbRTO3rM26iF2VqhWpByVyLHOqmau+zDHY3IVUHatY6sMeDr4++zlKOPv13LHvsK8RlRu5fuRE0nthCV+0p1PzNRr8gIKNShkfoX0JJmoewxSF9PeidZRDyYXHNTPPM3sZzCKsLxRn5/JS4fLx1Owl43ROW9pgpzAY17wJazr1DxY7foAWGjItryM/5nf9L9vJ7Kbzlg2NSzEGfB0zj9+0IixM9FETJWIPiSEIGBhnsKuXEC/9kKM7a40YFNDDst5SxCumup+nUtnAa3OKIMZSCW0sRsfljeiX0jjMIRSVlzppR2wNDA/Q2lKLrIVzJuVOawpVS0ttURvOpnXh6WjBZ7aTMWU3avA1T1oAqpeTcll+APR41/64RhWRnEiIuH636Tcq3/ZpVH/kWtYdfQao2ozQ3vJ9QVER8IagWemu309dcMa0X9KtFNdtY9thXqT34Es2ndxLqLAWMIDlv4xdILlo5an8hFArWP0rOyvvorjuDFhjCEZ9OTFrhjAnqpK5Tvf8FRGwuSsaaEXsD1YKauhhkiPqjb5K9/L5R/XFtZftxN1eETR2llMiBFqNXSDHTXXuaUy//gOKNT16zvP+QuwMRFdkeRAiBsCfi7Zu42rZiMpOx8PYJlSOEECx64HOcfvXf6anbaVyTdA3GuYkKIRDxhfQ3HQR7AqbCe0euE45ERGweWs3blG75Jev+6B+n5XsgpaTxxFbDxNc1IgApHAmYiu9HazmKHlY8VgwPPW83UckzIwi/FCnl5UuPk7TUmEnMBjU3OR2VRyh966eIuAJMBUsN8aeQH72rjPojryOEGCO45YxLxVNfMfzFHnuBkINtxs040biJCkcCIiYLrX43/e21iKR5EZ8nFBNEZ9LXXDlqe+Etj3Pk999Cq37TCIacKRDwoHWVIXsqKbzlQ2GnYD0U5Pyu39J8ZteoMdbYzBLm3/Mp7DGRhc4mipQ65dt+TfPpHYbqqjMZ2e+hb8dvqD/yBsse+yqO2Gs7BoC7pZKh3lbUgnvGWD4I1YySvJj+uh0MdNTTcf4wImXJmP0AhCsLYXXRXn7wpgxqwNBjKbr1QxSs/wD+wV4Uk/mKqz+TxX5FsbXBriYajr1FZ/WFBtocspZsJrl4NVpgiJ7GMuRwY22kXpWrpb+9Bn9/F2rhqoi/AyWxhFD7abpqTpA2b0N4e/OZC9kTI6DRW46gd54DW7wheaAF6aovpee/v8rih/4iou/aRDHZoggGBsd9XAYGsMRdv+yoyepg2Qf+L+62ajorjxpZ5MD4titCMUo3SvL8MQsfoagoKUsZqn4Ld/N5YjNvvPZUyO/F19+JmjN/zGPCFospfzPB8lfAGo0pewOyvwGtt4bMRZtu+LlOhNj0IkNfZ6gnoomw3mdoIFku01c5U5kNam5ipJRU7X0W4cocbYhnsqKmLgEpwyvGi1VbMxZtpL3iILKnCpEwuplR729GDrahZo/2dBFCQU1dRqivDoYu0/8itTE35+ikbFY8/teUbf0VA7U7wtvNDhf5d3ycrCV3ht/Pmdf/k86a44YAW3wRKGZDqK3tBEd+/21Wf/Tb15QObTyxjebTOwwxwPiikfKZvx9/zVZOvfQvrPn4d695NejtbQOI6EoMRv8SwGB3szEhNJ5vlhAwxd5f04WimrDHTE06vqvmJKde/iGYbOFRZ3dfM32v/Qhnwot4+zqMRuRh4rIXMP/uP8bmSrzmYxt+bUZGMyIm+/CEz2g9nSF3JyLKUBaW7jr0znMoGatREkvC3zclfQVa3U5OvfKv3PLpf73qScj0knVU7X8BGRgcpRgOIId6kAMtpK1731W99mSISS0gJrUAsz2ayj1/GFdIUB9oAgQiKnJj/IXfi9fdPi1BTbh0rgfH30mGEFJDazmM7K7EZIuicu+z9NSfJWPxHVOyWJoqkgpXYHHGEWzaj5p352iz0r5aZG8N2bd/+KrlPaaT2aDmJsbT3YS3p8WYYIq0YkwqIdR+is6qo2Qs2hjeHpc1j7T5t9J6bg+6pz3sfiv76tC7yo2mtwieUMIWY+hkeNvHTDaA0Rwn+xtJLHlwzHNdKXmsfvJvGehsYKivHZPFTmzm3FGNke7m83RWHUHNuR3louOLuHxEVCrB8hdpOPYWRbd+6Ko+Lyl1Go69iYjLD4sBho9hdaFkrcdT9SY9DedIyBktAOfr76an0XA3j0krvGI5LNzYG/SANcKo+vAq2uJwYba70DztEEHgzJgQ6sEeu2bMY+9Vgj4Pp1/7d4hON8weL9xwUhah91TjadiDcGVhylwzHBQ30dd+giNPf5vVT/7tNatzX/Bhk572MQEDgPR2gdTHZIcsjmiC/n4A9M4yRFQqatK8UfsIxYSatYFQ6TO0nnuH7OX3XNU5ZizaROOp7QSq30bJWDUy4ehuQG85jCMhg6jkXCp2/Ibu+rNIKYnLnEPWkjuvi6t92vxbqN77LFrzIdScW0ddOwyrhDpAIoKeyCPSw7+X6fJyM1lsxKQX099bPWoxdAHd0wl+N9LvBhQjqLUl4QkIPCe30XD8LRbc96djyuzThaKaWPLIFzn+7PfQyp6D2FyEyWjKl552UuasuaxtxUxmNqi5iQn6DHXeSBdWGJ4sUs1jVvlCCObd/cdEJWZSf/RNAtVGuchkdaIjEUmRBfhkyA96CKREa3gHNXNdOFUsQ360+l0oqjoqgLqU6KTsiD44YEirC6srPDEx6pzNDkRcIS3n9lx1UOPr7zZSyPmLIz4unCkIi5Pei4KakN9L2bZf0V5xcFR9OS5rPvPv/fSoJteLSchdgGqxo3eWGno8l6B1lWF2xISVk+uPvoFMLEHYYg2JfHcDcrDNuFhqAVIvKmO812k99w56KIgpc92Y5nMlvgC9twYZ9IR/FyK+ABGVSqDiJRqOvUXB+sfobSrHP9iDxRlLXFYJyjhWBpFwxCYTlzWPvvbTiOjMUatcqWvobcexRicQnz26VJE2bwOVe/6A7utHejpQMlZHfH1htiOcKfQ1V1x1UGO2R7Hi8a9x+tUfMVCzDRQzSB2khjMhk7R5Gzjy22+AakG4skERtFYcoeXsbko2f+Kyv+GrwWKPZv59f8qZ136EVvEKIq7A8H4aaEa664nPWUh/ex1aZymmnLHO33pnKarFPmaxcSPJXfUAp176Z/SWIyhpy8IZaTnUg96wB2t0Av6BXrAnoCTPQxm+nkg9hNa4j7Nv/JioxKwZM+LtSsljzce/S9OpbbRXHCbk6yAqIYPMTY+TXLTipszSwGxQc1NjpPIF0tMRcZJJDvUitQD2CGlPIRRyVtxH1rK7GeptQ0qJPSaZw7/7G7zd5ciY7LGrka4yhBDMueMpKnb8N1p/E0RngNSQAy1G9P/wF8fVixnsasTb24bJ6iA2Y86Y8VW/pw+sMeOWfoQtlmBX6bi9QFdiRPU08o9VCGFkrIb303WNEy98n/72OqNMEFdgPO5uoK/1GEf/8B1WP/ntiCUC1Wwje9nd1B58CVSLMRlhsiGDQ+gdZ5A9VRRs/iMU1UTuyvfRWXUMb9WbEJOLdDdAyGt4WA1z/NnvsuSRL40bEL7bkVIn4B1AKAru1iqEMzliGQNAic0Ztg3QwkGPsDgRcQU0ntxOa9l+/APd4f0tUXEU3/ZhUueunfD5zNn0MY48/bdola8Zfm2OBPD3o3eVga+XeY/85ZgppoyFt9N4chu+6reHt+iXe8cjzZpXiT0mmVUf+RZ9TRVU73sWd2sVUhoZ3qp3ngazE7XofhSLkVWUcjV68yHKtv4X0Sm5uFLGZmuvhZTiVdie+Ab1R143+qB0DXtcGtkbP0rGok20nN1N+bZfoalWlJSFw0MPPvSOc+hdZRTe+qExXnE3kqSCpRTf/iTnd/0W2VsFjmTQ/EhPB7aYZFSTBT89MNSJXr8bHYGIyUbNWoeatQFtsI3GE1uZu/mpaXsPl2KLjqdwwwcp3PDB6T6VKWM2qLmJsUUnkJC7kJ62s8aY5sUrRqmjtR3HbHeRmL903NdQFHXUyqFww2OceukHaA17UFOXGgaEIT96Vzl620lyVtxL5uJNJOQtovnUdnqbzyOEQsKCR0hfeHvEMfKBjnrKtv2K/taq8Dazw0X+2kfIXLw5HKBYo+KguXr8BmZfL2bH+EHPFT8vVwIWZyxBdx2Ka+xqSR9Wgr0gEd5VfRx3y/lRWh8wXA5zJOGreInmU9vJXT263Hah2bnp9E7j/+2n0NtPg9kGIT9CUSm89UNkLr4DMEpVKx7/ayp2/S9tZfvAGoOp4M5wA58c6iHQuJfjz36XtU99b8rNTWcyuhai4fhbNJ7YGg5ETFYnqOPr9oQbzC/9nkgdLeBFtyeiFq1F2OOQvj6C7ac5+/p/AIwKbKTU6ak/R3fdaaTUiUktILl4FYpqIioxk1VPfJPKd/5AV/UhLtZUKVj/ZxFl5k1WBys++DXOvPGfuJsr0HuqURLHNt3LwCBysJ347Hsn+3FF+jSoP/o6fa1VKEkLUeONwFx3N6C3nUSr3YoovM8wmxUKSsZq5EAzjcffZv69fzIFxx9NTFohix78gjH5JfVRGbLMxXegBf1U73uOUHc5wmw3enCEQv66R8lZcf17gK5E9vJ7SCxYSvPpnQx2NaGaLSQVPEp7xUG6ak+hpCxGiS8ERQ1/xqHKNzAV34+IyaGr7sx0v4V3PbNBzU1O8e1PGpNFla8hkuYPj2APoHeWIr0dlDzw+UkJeiUVLGP+fX9C+fb/JlT2vHFhCfkRQgyPiBulH7srccxUVSQGu5o4+vS30U0O1NxNRsNfwEOoq4yK7f+NFvCHXWzT599K8+kdyN4axCUKtDIwiOytJmPF1V/oFUUla+mdVO97Ht2VhRIzkvWQIR960wFsriQS85YA0HpuL8KZHFnrwxqNiMmh5dzeUUGNlJIzb/wnndXHDYPN+CKkDKG1HAN3I0JRmH/3p0mZO7okZbZH4YxPA6FgKrh7lMS8sMej5t1JsOw5mk/vIm/NQ1f9GdxM6LpmiJ3VnjLMEXONcelQ+xnDisDnNvq8LkJKid5bjYhOH61mKyV6Xy0iOtP4Hl5oqnckInI3otXt5Pzu3xlBi6Iy5O7k5Iv/jKe7yfhbC5XG429j3vVbFj/058SmF9HfXjPcEG4ENKrFgSslj+jk8bNpNlcCKz/0dRpPbKFix2/Q204gEoqRXeXovdUQ8oMQKCYzSYXLr/kzbDm7h66aE6h5d4z6vqtJ81CiUglVvILeUxnu7RFCQbiy6Wksv+ZjXw4hBEKMLfnlrLiP9AW30X7+EP6BXqzOGJKLV48adJhuHLEpo0rg3fVnjc84dyPKRaVzNXEuSlQaoYqX0bvKQShXNSLd315H67k9+Ad7sThjSZu3YVxxx1lmg5qbHmdCOiuf+Bsq9/yertqD6MM/GldqAQX3PHVVY6FpJetJLlxBR9VRhvo6MNuiSC5eeVVTR1V7n0FXrajDq0EATDZM2RvQVCvV+54jfeFtWOzRuNIKSJmzhvbze5F+N0p8EahmpLsRvf0kFkc02RPw0rkcOSvvp7+tls6q7ehRqQhnquEc7q7DZLGx+OGvhssGRjlsfD8qYYsl0NM2apu7tYrOyiP/n73zDo/juu72e2e2offeAQJgJ9gpkhKLKtWL5SJZtlxkO3GRe4m/2I7jWLFlOy7J97kljmPHlqxeKYkixSKxE2ADCIDovWN30bbN3O+PAUGCWIANJEBw3ufhI2F3Z/bO7O7Mueee8/uhZq1Dick1TDybi2G4EFJqcPz1/6Du4GvM3/QZwuNPa160V+5HRGYF9cwR1hBEVCbtlfuvmaCmtfRd42aRexPKGTL0IiqLQOnTBOq2Ycm9eaR2RuoaemsxDHah5I623JCuetB8KEkLx5osCoGatBBf5Sv0Np4gOjWfQ8/8K17PkPG9DUs0nMU9TgJNuyl59kekLdxgFJ1HZaLmbATFhnQ3UV/yFr3NFSx98FsTLpVkLL4Fze+latfT0HEMhGrM8G0RyMEOdFcDh1/4KUsf/NZFqUlrfg+lb/yOjsp9hqlsEBl/QxE8C7375JiC5anE6gibtq3QwWg9vtMw6owaW2AtHFGI6Gz0npMIIDrv/I0tdV3jxFv/SWvpTqPTzh4N3hM0Hd5CUuEq5m36zKQpUM8kzDMyAwiLS6Xovq/gHXDi6evG6oi45PZB1WonZc6aS9qHb7CPrpoSQ6AsiEGhkrSAQFcZ7eV7yVhsdHDN2/QZHBGxNB5+m0D7keFXCuKyFzLnlo9flOnlqPdUVBbe9QXaK/fTdGQrg711qLYQkpffSXrRjaMCN0dkHH1NEyyHDfVgP8uXprV013Cxcw5SSrT6nUh3E0rqstNBWl8LA60HOfj0D1j5yA8IGW4z1nxehHV8M05hCSHg67qk47+aaDryNkpk+qiABoY7hPJuRTv5GoGyZxERqaDaoL8VGfAAAjnYiTzVreduNMxUIWjtGWCoPQO+ASdt5XvxuNrH2og4olFzbiJQ9gwNhzajJBWhppyxtBuRgojOxl21mcbDW8hefueEx5e1/E6ajm3H6/EaekYjNULzkINd9Fe/ycmdTzHn5o+f9zkDIyt19JVf0dNQBrYIIxs1Xp1aSByyr/WMbXWku4HYWUUX9J7XMp7+HrDHTHCOY5HOWqTUyVh883nvt2b3c7SW7RqWn5iFEIrx+fTW0l75HrbQKAo3PjJZhzFjMIOaGYQ9LHpaSVr7Bp0gZVBxJzC6sxRbGN7+npHHFNVC/rqHyFl1L71NFSOuxJOp8SAUheTZq0iePXF7Zer8dXRU7ke6GxFRo5cU5FAv0lVP2vqHRj3uG3SBPRIhBPpAB9JVP7ZFfdg/R6t4kfoDrzH7xo8CEB6fhqe5NmgQJaVE9rcSnjq5xZvTmYHuZkgM3qmmhMajRaYTInyERMehB3xE5K4ndf46Wo5tp+noNgJtJSOvj0jKoa+9FunpRQRZTpQeJ2D8huoPbTaWr4LZiKg2o4Db60ZJGpsFVcIS0KOzaTqy7ZxBjbO5Ao+zHTXv1jFFzyI0HpEwj9ayd8m/4YMXlK1xt1bTXXsENXsDek81eMbXlZIeJ1gcxv9LHb15H9Lbf0nmspeb/s5G3O01CNVCbOa8C7rm9Xc303T4bVyt1SiqhficRePWAp4vtrAo6KmaoBbQCVJSsOERopLPb9ko4PPQUPwWSsL8UfITQiiI2Dykr4+mo9vIve6+EeFSEwMzqDG5bFhDhrMqHicEEaGTAS+6fzCoaqXFHkpC3vgFzleCuOwFxOUU0V2/HZmwACU2F4SK7qpHth8lPC6d1PnrR21jD4+FhgpjRtVTDbbw4C3qFgciJp/Wsncp3PgRhBCkL7qJzqofIXtOIs7S0ZE9VcihHtIXfeIyHvH0QrHa0QOecZ8Xmo+wpFSK7v3yqMcLNz5C7ur76W0sQw/4iUgyFIXf+8+v4W0/arTun3HzkVKitx/BHh5LTMZcqve8MHKjD4quGUtSQRSgAZTwZDyN1UG1nM7E3VYDihURnhJ8P1GZBNpK6O9qClp4PB5tFXsQtnBEVBYKoNW9g97fNqY2THr7kM5aREgsWtMepLsR6R9kzs0fn/TOp8lgyNXB8dd/jaul8vSDQiFl7lpm3/jRc3ZGNR7eQsXW/zECyIhU8Ppw7XmBugOvsvi+r160qF/q3OvpqNiH7GtGnGGhAKdqAWtIXbDugpbOnU3l6H4PlrPEUU+hxBUQaCuhp6GUpMLg0gDXKmZQc42h6xq+ASeKar3kpZxzYQ+LMoztOsqMjqGzbgJ6ZxkCSCo8/1baK4kQCovufpyTu54yfIvaDw8/oZBUuJLZGz+KxTb65pc673qaDm9B9lQjAx5jKWrcFvVINN8QUgsgLFZis+aTumADLcfeMS6Q0caNRTrr0J21pC5YT1z2+a/JX+0kFaygpWwPMnmshYT0OJH9bSSuDV5fZHWEjfGVKtzwMEde+je02rdREheOdD/pHceQrgYK7voCQlEIj0vF3Xlg/KBE9yInEpb1D6BY7efU+TDazXVDPyZI0eypLi6hnr+GDkDAM2C0sAsBUZmIsCS0mreRqUtHyRLorQdRrQ5sNgtoLmJnryC96OZRsgG6Zoxhqms3fIMuDjz1z/j9Gmr2BqNGSA+g91TRemI3vgEnRfd/bdzfWm9TORVb/4gSPxclddlIq78MeNDq3qHkxZ+y9hM/u6isR1zOQmIy59Fbtx2ZvBglNg8UC9JVj95ajD0i5ryaKs5EP6WGrY4TqA07guvaBF/EaxQzqLlG0Pw+6va/QtORrfiHDFXTiKRcclbeNebiP5nMuv79HPjr99Gq30JJLjJS/74B9K4y9M4yclbdc0mp38uNYrFSuOER8lY/YOh86BoRSTnjprwjk3NJnrvWaM12xIJ/cNyboxzswRoSgRi+YQghhmfJ2dQf2sxQndESHhKTTNZNHyNt4YZpY+p4JchcchutpbvQareipl9nyAtIiRzsRG/YRUhUEkkF5z9LTchbwqJ7vkTFO3/GU/X6yOP2yHgK7z5trpm2cCPNR99B7yxFTRy9xKS7m8A/BP6h4NkPPYDsqSL5PMYVl70A3tGQzrox3X4Asqcaa0gkEQkXpvAbEp2ErNiP1PwI1YqaezNa4270pn3oTXtHXheTMZd5mz4dVECyvXI/9QdfH5FhiEjKJWvZJpIKV03Jd7Ch+E38QwOohfeetqdQVNTEeQh7BN21W+ltKCU6fTYB3xAWW8ioQKzh0GbDiDdttF+XsDhQs9YTKPsbDSVvoVqsOJsrQQhiM+eSMvf6c1pVCKFQdO+XKN/6P7SWvYvesn/kuZjMecy79VNjnMzPRfhwYCndTYax7VlIdxPABX83rgWElBfRY3aV4na7iYqKYv3nfntRHQVXK1rAR8mzP8LZWo0SO8tIkWo+9J4qZF8L+eseImvZ7Zft/Z3NlZS++TuGek8XJKpWB9kr7yJ7xd0z7kat6xo17z1LffGbyIAPJX0VavycUa+Rvn60ipfIWnpr0FmclJL+zgb8viHC49KxnccMUkpJwDOARGJ1hM+I89rTWMbRl39JwNOPEhJrBA1eN6GxaSy+/6sX5SUlpY6rpWpEUTg6rWBM0Fm162nq9r+CiMoczm4MLzv2VhOXvRDfoIv+njaU9NVGjZRQkB4nWvNexFA3Kz78z4Sfh3JsyQs/oaehHCV7w0iAJKVE9pxEa9xN3toHyTlLB+lceNxdvPv7L6EkLkBNOd0WLn396M5a9NYSUuetZe6tjwXdvurdv1G372VERApKVA4I0J11yL4WspbdTv66h4JudznZ+ZvPE3AkoaaPzepKKQlUvEBISAje/l50vxehWkguXEXOqnsJjUnmnV9+Ehk/FzUpeI2Wv+Jl8PSCEIiwZEAaHng2B4vv/cp5L015B5z0NpSh6xpRyXmExQX3sjofip/9Eb1tdah5m0b5jEn/EFr1G0TGJrL8Q9+56P1fbQS8g2z/90/hcrmIjJygK9UMamY+9Qdf5+TOp1DzbkMZNoaD4VqC1oPonaWs+cRPL9kBeyKklLhaTg4rCocQl70A1TpB3cIMIODzcOzVX9FdewQlfo5R8Kfa0N1NyI6j2B2hrHj4n8YsA/Y2lVP93nM4m04AxjJFYv4KZl3/YNDPSEpJa9ku6g9uZqCrETCyO5lLbiV90Y1Xrdz5KTS/j/bKvbhbaxCqSlz2QuKyF1zW4xo5pwdeZ6DbmBUrVjtxmfOYc8tjgOToK7/E2VQOFjugQGAIS0gEi+76AjEZcybc/yn8ngFKnn8Sd2sVIjQebOEw1I309pE6fx1zbvnERR1n7b6XqH73GUR0NkpswbAlQQuyqwxHWBQrHvpe0KUWZ3MlB5/6PkrKMtSzCqG1jlL0lv0sefAfiM28si3gW//to4iU5agJY8+r9PYRKH8RFBUlfrbRbeR1IbsrUYTOsvd/mwN//SdIXDgm82Zs7yJw4gVEZJphDHyqcNo/iFa/A8XnYvXHn7ziTRhD7i4O/vX7+DwDiJhZI8ulsqcKi83O8g/+46S6z093zKAmCNdqUPPu77+CVwnDkrVuzHNS86OV/Y2sZZuYtfbBkcf7u5vpa69FKBZiM+de9vqb6YiuBfAP9aFYbBftliylTu2+l2k4uJmA1/DqQggS8pYw+8ZHx1hKdNUc5vCLP0OExKLEzxnWLelEdp3Aoiosf+i7hEYnjdqmcvv/jmimKNE5IATSWY/urCVl3vXMvfVTMyJrM1kM9rbRdGQbfZ31KKqVhLzFJM9ZM6Y+SvN7Ob7513SePICw2BHWEHSPC8ViY85NHyM6rYCjL/+Kvo7akW2EaiFt4UYK1j103nUouq7RVV1CW/lufEP9hEYlkLpgPVEpsy7pc2s5vpOavS/hcbUPj81K8uzryL/hg+P+no+99h901JWhFt4XtANPq3yJ+PRZLLr78Yse18Ww67dfxGeNxZI5VmYiUP0W0uM0VHvP0HiSAS9a9ZuEhYdhDYnE2d2BJX+sKnGg8T2ksw7LvA+Mrd0KeAmU/Y3cVfeQe919k39g58A74KTh4Os0H99JwNOPag8ldd71ZC27A0dE8K7Smcr5BjVmTc0MR9c1PK521IzgmjNCtUJoAgM9LYDRYVD6xm+NGeip1ygqqfPXUbDhw6gW2xUZ91QS8A5Su+9lozh4OBCJyZhLzqp7L3iGKoRC7qp7yVp2O67WKvSAn/D49KB1DLoWoPTN3yEiUlFzzsiwhCchY2cROPkqldv/d1S3j7OpwtBMSVs5WkAtOgfRk0Fr6U4SZy2bFHXamYCh5Psnw1IkLBk0L921/03NnhdZ+uA3R1mGlG7+DZ01h43Ze0yuYSPgG0BrPUTp5t9gcYShSQU1a93wkq4fveckTYe34ut3suCuz59XUKIoKon5y0jMXzapx5o6/wZS5q1loKcVPeAjJCpx3OBc8/toLdtFR9UhpC4JVLyMEpuHEldgtLEzrAIcnkpfR/2kjvN8SFuwjpq9LyGTFiDOEMSU3j5kXzNq5toxopXCYkdJWUJ/zRby1z1Eb8Nf0DqOoSTMH/lcpK4he+tQYsc2Mpzah4jMpLO6ZEqCGntYNPnrHiJ/3UPoWgChqOYE5RyYQc0MRwgFoVqR/qHxXxTwYLHa8Q44OfDXf8Yf0FCz1xsdBpofvaeK5uOGTPeie788o39UAe8gB5/6AQO9bYjYfNTwFAgM4eyupPjZJ5i/6e9InrN63O37OhtoPrIVd0c9qsVGwqwlI8WGsRkTB0RdNYfxD7pQC9YNFxhrYA03LmQWByJhPl01e/H2945keJqObkM4ooyszlkosXno3eU0HtlqBjVAd90xKrb9D0rCXJSUpaddlr19+Ou2Uvzcj1nz8Z+gWKz0dzfTcXI/auZaQ+l3GGELQ828Hs3XT2CwE8uc952ud1BtqMlFCHskHSd34GqtIjo1eEvulUII5Zy1PQHvIIeeeYK+9jpEZDpKSBzS60JvPYTeXYFl1qaRgEFqPhTLWCHNy03G4ltoLXsPT9VmRNIiQ5BRD6C1FgMgIoIfo4gwalos9lCyV95N3b6XDRuW4e2lsxZkwHAxHw/Vgq6PLy1wpZjqDrSrBfMszXCEECQVrKC95hgycf5IK+Mp9IEO5FA3iQUraDj0Bn7PAOrs+07PehQLatIChD2Crpp3cDZXEJM+ewqO5MpQu/clBnrbUGdtGiUaKGJnoTXsouyt3xOfWxR0+bJu/ytU7XraOHfhKaD10bv9L9Tue4Wl7/sm4QljperPZKCnFYSK1rDT0PYBUO0ocQWGj1R4MrqUDLk6R4Kavs5GRFjy+G3j4cn0dzVd3Mk4B7qu0VGxj6aj7zDobMfqCCN59nWkLdxwwd0eV4K6A68hQhNQUs/qgLFHoGatx1v+Ah0nD5A8ZzUdlfuNWXp07pj9CCFQ4mej1bcHddIW0TmIthJaS3dOeVBzPlS88yf6u1uM5ZvQ+JHHpddNoGozWsMuLHm3IgNecNWTeJ7+a1JK2iv20liyBXebIZYXn72QrGW3E5U6tqNnIqyOMJZ98B8pf/sPdFbvRW/aA3BaqTzggSD2IgS8AKgWG7PWvp+YjLk0lmzB1VqFoqjEz72Owd42nJ1NSLk0yJKbDn3NRBeuuKDxTiUD3c00lmyhq+4oUteJTs0nY/HNF6R1dDVjBjXXAFnLbqe9Yh9a3TbUtFUIe4TRYdHXgt74LuEJWcTnFFH21n8iYvKCew9FZSEcUbSW7pqxQY2uBWg+th0Rmz9GBVkIBTV1OYGyWlpPvEdG0Wi5887qYqp2PY2StBAlefHI0pH0DRA4lQX45E8nXL5zNpeD1BD2SJSUpYbWhbsJvesEcqADkTAfAIvttPqsxeZADow/i5QBz2VZMtQDfo689HO6644gwlMQYen4ff1U736exsNbWPb+b0+rIkap6/Q2lI5p6T2FcEQjQuPpqjtK8pzVaD6PkR1TxtGIsQx/BpofzprkCyHAHom33znhmHQtYLQf20NHuVVfSXyDfbSd2I1IXjIqoAEQ9kjU1OVo9TvQ+1rQ24+gqCrpi87tyySlpPztP9B8dBsiIgWRvAT0AJ2NlXRUHWDebZ8mZe7aCxqrPSyKRfd8EU9fN30d9YZbemI2e/7wdfTuiqCdUXp3BUK1jug7xWXNJy5r/qjX9DSUUvzME+gdx0cVRxuNFMVI3wDpRTdd0Finio6TBzj26r+Daje8qBSVjvoy2iv2MOv6D46YB89kzKDmGiAiMYui+77MsVf/g8CJZ1FCYpCaH+nrJyI5j6J7vwRC4B90o8QGXyIRQoAt0jB5nKH4Bl0EvAOoEcEVXoU1FCUkloHuljHP1R98HRGehJK8ZHQWwBaGmrkOX/nzdFTuH/dC3t/dbHRJJS9BTT6j7TQiFRGdhXZyMzJwiJCYFMLOMMFMzF+Ga+fTSN/AqLZPMIoccdaRdAnO5uNRs/cFuuuPo+bejHKGiqr0DeCveZMjL/+CVR/54bRZqpRSB+S4KsCAEUQOi82Fxqage9wovv4Rw8xR++tvM1yXg0wApJTgdWMPDz4zHuhupnbvS7RX7kPqGqrVQer8G8hYcis99cdpPbEbv2eAsJgk0hZsIC5nYdAOKP9QPy1lu+jvMAqe43OLiM9dPGLIej6422uMMQQxYwRGTBq16jexOMIouv9rQevBzqa9Yh/NR7ehZqwZJfMvkxagNe6m9I3fEpM+B0fkufd1No6IuFFjyF5+h2EMag1HSZiDUCzDtTJV6O1HyFh8y4SierGZ88heeQ91+15CuhsQUdmAjnTWIQe7yF/3EBGJ018PxuPu5thr/wGRmUYd2CmBwZRl6G0lVO16isiU3HMug1/tmEHNNUJc9kKu//Qvaa/YOzLLic9bQnRa4ciNxxYWTWCoN+j2xoXahSPiwtLGVxOqZVi90x888yGljvQPjZFj17UAzqZylPTrxskCRCFCE+ipPz5uUNN89B2ENQQlcf6Y55SwJPSoLKSrnlk3f3jUe6TOX0fdgdcI1L5tXMiGM0zS40RrfA/FYiF90Y3ndfznixbw0XR4K0p84aiABowgTklbxUD1mzibys+7tfl86O9qor1iHwHvACHRiSTPWXPey1yKaiEsPoNBd+Oom+wppH8IOdBBZLKRhUgqXEXlO39GazmImnXDqKBCet3oXUa7PZoXzjJrlb01SK+b1Pk3jHkfV2sVh575V6RiRSQVodgjkYPdNB7dQeORbYYFQ2Q6whbOUEs9nVU/IbFgBfPv+OyobE575X5KN/8aXQughMaD7qf52DuExqax5IGv4YiMH/PewTh9XHrwF0jj8eS5a5l946NjOsTGo7HkLUR4yphzLYSCmrYSzVVP87Ft5K15cJw9nD9Zy+/EN9hHw6HXkZ3HEPZopM+N9A+RMu968m/44Dn3MWvtg0Ql59JQ/CbO5uIR8b3MpZ8ck9mZrjQd3QYohgHmGd8VIQRK8mKku5HG4rfMoMZk5qBa7aTOH9vWfYq0BTdQd+B1o/bGPvpmcepCnTJv7IV6pmANCSc6fTaunsphV9yz1tddDUj/4FgF5mFVBBFE6n4EoSD1cW4cwGBvK4QkjLvcISKSke56kgpHm3BaHWEsffBblLzwE7wVLyFCYhAI9KEerKFRFD3wjUlv/RzsaTUyWkE8rQBjOcpix9lcOSlBjRbwUfbGb2mv2GssCVlD0T0uTu58isL1Hz7vpYHMxbdwYst/ovfWoMScrpWRuobWtAdFtZA6/P222BzMvfWTHHvtP9CqBlDiCsEaiuxvQ3ZX4AiLNFr+q94wlLIjM0YELfWOoyQVriLyLPNCKSXHX/810haBmnvrSD2IjMpC72s2dG4KbkM4okZeL131dJzcTt2+l0e6b1yt1Rx79d8RUVlY0laOmGGKgU6GGnZQ/NyPWfWRH55XYWlUSh6KxYbeW4OaPNZrTTprAUHe6gfOO6ABcLfXIpKCe7cJ1Qphybhaa857fxMhhKBg/UOkL9pIa9kuPH092EKjSJm7hvD4ievYziRh1tKruqDe2VRuZHbVsUXPQghEVCa9Z3S1zlTMoMZkhIwlt9Fathtv9WaUpOELtW60qeodx0kqXEVUyszN1EhdJz53Mc6df0Vr2IWaugxhDTUyNK5G9KbdxGTOIzJ5dPGoYrESnpDJgKseJYgBnfQNIAc7iEq9bdz3tthCINA8/uD8g6i24NpK4fHprPn4T+isLqa3oQyJJCatkMT85ZenU+VUsDeuxJU0npuklacTb/0n7ScPomasHfYQU1ECHvS2Esq3/jfWkIjzMvVLXbCO3qZy2k7sQO85aXTMaF5kbw0Ehlhw9+OjlimSCldhdYRTs/dFnA27AFAsdtLmrSV39QPoAR+lb/6e3uHnjOdtZC4xVKLPDop7G08w5BwuQj/jxiMHu2CoGzXnppGABoZvRNHZyP5CGkveInvFXSiqhfoDrxr1LmdlkJSwBETWegYrX6GzupikgnMXt1rsoaQtWE/jkW1GEfUZmTd9oBO99RAJs5ZdsHKzolqQ+gS+RLp/0rt5QmOSJyXzc9UixAS/SUAStLB9pmEGNSYj2EIiRjoMump2Y/wKjAt51tJN5K19cMprJE4pE7dX7MXvMZYh0uavO+90+3h0Vh2i/J0/4XV3Ge/TW02gtwYREmPc+HwDxGTOY+FdXwh6DjKX3ErZm79D7zmJEns6sJF6AK1pN6rVQcrc4FpBAEmFK2mv2Is+0IkSNvoGIjU/srealNnj37gV1UJSwYrzupFdKmGxqVhDItF6ayF8bDGw7GtGaj5iM+Zd8nsNOjtoO7EbJX3VqIBRWBwoaauQvn5q9rxAYkHwAuAzEUJh3qZPE5+ziMbDb9PXcRTFYiUhfwmZS28bZeR4itis+cRmzcc36Cbg82APi0a1ni68XvrgNxnsbRtZ0o3JmDOusGd/VyMoKiJstHii7G813Lojx2lLjs7F31XOQHcz4QmZdFYXI5IWB62zEaHxiND48w5qAGbd8EEGe9vortmCHppgKNd63cj+NiKScpl76yfPaz9nEp+ziI76E8iksfVA0teP7G8jftX4Qb7JhRObOQ/n3peQAa+hw3QGRtavltismb30BGZQY3IWjohYiu77CkOuTvo66lBUK9HphaM6bqaKgM/D0Vd+SU/dUYQtHGELQ1YeoHbvi+Stfh85q4I7Np+LzuoSjrz8c0REOmr+HYbM+kAHWssB5FAPcTmLyL3uPiKT88a9cabMuwFn80lajm9H7z5p6GNoPqSzBvQAC+/98oQq1vF5S4xsT902GPETEsihHrTmfQipkbl08gt+LwZFtZCx5BZqdj+HCE8yWphPiZl5XOhNe4lMziMyZaxJ44XSWXXQkL8PYuonhECJm81A7dsMOdvPq9tKCIXkOasn1BoKhi00clwV3tCY5PN6b9ViA10HzTdsrTBqYIyb2jp1bqU0soa6hnL29qPeyIYe8J1zPGeOq+i+r9JVU0Lz8Z143F3Y4xNJueF+EgtWXFRGJXPpJtor96M1vIeavnJEwE/6+tHq3sEaGnHBn4HJxKQtWE/d/leMLHPWutPLm1JHb96P9LjJXDLzA0kzqDEJSkhUwkWZBV5Oyt74Lb2NJ1CzNyKiMo2bvuZH7zhG9XvPYA+PnrBmKBhSSiq3/y8i/JSKr3EDERGpiIK70ep34m6vJSIxe8JMgBCCObd8gvjcU1mAkygWK4nz1pKx+BbCYoN3VJ1CUVQWP/ANjr78C1y1bxt1EooF6e3DFhbNwge+fs59XAqevm40nxd7ROx51U5kr7iLga4m2it2IDqPI0ITjGU2dxMh0YnjZrQuFM3nQai28buWhutJAr6pF0c7F/G5RSAEes9J1DMKwkVYohEA97cEFZGTzjos9jDC4lJRFJWQmBS8fS0QrOBZ8yEHOgmPH9vePBFCUc6rpmSgu4WmI2/T21SBEApx2fNJX3TjmExpVEoe8zZ9mrI3fovmrjfUm/UAsr8Na2gkSx74xrSYKM0k7OExLLrnSxx56d/Qyv4GkRmgqOBuQvqHmH3To1eFbtKlctUFNV6vl5UrV3LkyBFKSkooKiqa6iGZXAEGe9sMhdeMNSjRp9srhWpFTVmC9Lqo3fcyKfNuuKCbqbut2qhzyLttzHZCCNSkBfgrXqKn/rhxU5oAIQSJ+cvHFhKfJ/awKJZ98B9xt1bTVXsYXQsQmZxLQt6SC5ote/p6aDm+g8HeVoRQEYqKd9CFoijEZs4jZe7akaxRZ3UJNXteoK/dKNpULDZS5q4hb82DE/p9KYrK/Ds+S8q862k++g6Dve1YIkJJWfEoKXPXTJpZaVhcKtI/iPQ4EY7oMc/L/laEYpl2AXgw7OExpC1YT/PxHYawX0yesTTjiAVLKFrjHsSs20a1kOvuZvSucjKX3z6iN5RRdDOV2/+EcDejnLFkJaVEbzkIUrvg4P58aD62gxNbfm8YPkakg9TpP/Qm9YfeYNHdj4/5faTMWUNM+myaj27H3VZtiO+tui2oz5bJ5BCXvYDVH3uSpqNb6a49hq77iZl7HelFN11Q0fTVzFUX1Hz9618nNTWVI0eOTPVQTK4gndXFoFgQMWMVXgGU2AKGat5ioKflnLLwZ+IdcAEEvWECMPz4ldLnEUIQlTrrghVXT9FQ/BaV2/8MQkWExiF9/eDrB9UOjmg6q0uofu85iu77CgM9rZx463eI8BTUrPVgDUH2t9FStoeehjKWf+i7YwIb36CbtvI9ePu6sYZEkjx7FYvu+eKlH/g4JOQtxRoSQaDlIGrOxtGt1b5+ZGcZSYUrL9pw9EpTuOERAt5B2iveRbQWI2zhSI8TNB+qLYRA+fOG0KUtHAY60ftbicteRO5194/sI33RRrpqDtNTswUtNA4lPBlpDYPeGuRgJ3Nu/sSkd7y522s5seX3KLH5KGmrTmugaH60hp0cffkXrP7ET8Zo2Dgi4shb88CkjsVkYhyRccxa+35mrX3/yGO6rtF8bAdNR95moLsF1WonqWAFmUtvm1YimZPBVRXUbN68mbfeeovnnnuOzZs3T/VwTK4gWsCHUK3jLkOcKoy7kFoCAHt4NADS0zvSGjuKYd2es920L5SAbwhncyW6FiAiMYuQSyxsDkbHyQNUvvM/KPFzUVIWI1SbUYfR34JWt8PQCJnzPrSGnZQ8/yR6wI+ILUDNWH06SxWejIzJxXPyNWr2vMDsGz86sv+6A69S/e4zSAmKPRzdN0DVu0+TsfhWCtY9dEGib+eLYrEy77ZPceSln6NVvooSXwjWcORAB7K7HJsj9Lx0SKYLisXKgjs/R/aKu2g78R6+oT4ckfGkzrsBiy2E5mPbaT3xHv6BJkKjk0i/4T4SC1eO0qjpqNxPX2c9IGGwC32wCxCExqVRePs3L4uuSkPxmwhb+LAW0+nPWahW1Mwb0Mr+RvPRydGdMZlcdC3A0Zd/TlfNYURkBiJxIVpgiOay3bSU7mLxA1+bUSrxV01Q097ezmOPPcaLL75IaOj4BZdn4vV68Xq9I3+73e7LNTyTy0x4fIYhkDbYjQgN4nDd14xQrYRGJwXZenwik3IJjU1lqOMYIjx5dCZASrT2o9hCo4m9yBuFrgWofu9ZGku2oAdOfRcF8blFzLn545ccLJ1J7b5XEBGpo6wAhBBGnUbmGrTabcjAIGr2BgJlfwNdx5KyZOyymz0SEVdAa+ku8td9CNVio+noNqp2PoWSMA81aaHRfaT50bvKaSx+E9VqGzUznEzicxez9P3fpmb38/Q07D41SkDi7fdSuf1/Kdz4UWyh089vajwiErOCqtRmr7hzQin7tvI9HH/9/yKis7FkrDcyiR4nWvtRBrtr8Q9enmtcT30pIio7eMeVaoWINLrrS82g5jLjbq+l6cg2+rsaUa12EvOXGcvJE9QnNRzaTFft0bHq30lFaLVbOfryL1j7qV9cFjuVqWDyp1aXASkljz76KJ/5zGdYtmzZeW/3xBNPEBUVNfIvI+PaWFOcicTnFmELjzE6kvTAqOekx4XsLCN59nUTdhgFQwhB4YYPI/vb0Gq2oPe3IQNe9IEOtLptSFcdBesfuihvHiklpZt/Tf3B1yGuEMucB7DM+yBqxmq6myo58Nfv4xvqu+D9BsPb30tfew1KbH5wVePIDLCEIF0NhoDdcBFh0OwUIMKS0fwefINudF2jZvcLiJg81LQVRk0Fw7P0pAUoSQtGzFAvF1Gp+cMaMgIRV4hacBeWuQ+ipK2go+YIB5/+ZwLewcv2/tMBqeuc3PFXRFQWatZ6REgsQiiIkFij2yU6m8qdf0XXtcvx7hNrnAhlYo0UkwvGO+Ck+r3n2P2Hr7PzN1/g3d9/mf1//kdayvfT5wGn00XFtv9h9x++zkDPWOsWML4zDSVbEDF5Y9W/VStq+nX4h/roqNx/JQ7pijClQc03v/lNYyY5wb/y8nJ+9atf0dfXx7e+9a0L2v+3vvUtXC7XyL/GxsbLdCTXJlrAh7u9Fnd7LdoFLvtcKIqisuD2v0d4utEqXkLrOIbWVUGg5m0ClS9jD4sk/4YPXdS+47IXUnTfV3CoOlrVZgLH/4J28jVs+gAL7vzcRbeeulqraK/Yi5qxFjVlqZEBsYagxBWg5m3CO+Cksfiti9r32WiBYaGzcVp9hVBAtcGpG55iheEW4bORmh+91ygcrtn9HI3Fb+Ib6EWJD56iVuLnoAd8dNdevjo3Z3OFcS4zr8eSsRolNA5hC0dNmIuadxuDzg6aDr992d5/OtDbVI63vwclcUHwovbEBfj6e3E2npj0945OLzQUtYMELlIPQF/TjFrCmGr6OurZ89/fpO7AqwwRRiAsHY/f+K2KsETUzDVYcm/GMvsB/BqUPP+ToMGsb9CFr78HJWqsBhMYFi5KSAyu1urLejxXkildfvrKV77Co48+OuFrcnNz2bZtG3v27MFuH33BXrZsGQ8//DB//OMfg25rt9vHbGNy6ehagJo9L9B0+G0CXmN2brGHkV50E7nX3TfpSqGniMmYw4qH/omavS/QUXmAU+KAAN6+biq3/5nZN370grM1YIiFxX18Ia6Wk3j7DZn16LTCS6oTaT2+0whkghQ3C3sEIjqP5uPbJ6WQ0hEeg8Uehu5uhmBtwV43eF2IkAVGINPXDFJD9tYiYk/ryeh9zWh12w0tFXs0bSdLkKW7mFAeeNixuu7AqwAXrW0yES3HdxoeWsHOpSMaEZVN07HtZK+8+5z78g310XnyIL4hN46IOBLzl01at9blxDd4jqJ2e9Tw685vCUpKObxPgS00csKuwczFt9JRsQ+99RBKytLTukRSR2vcDXqAtGGPMc3vxdlyEqn5CY/PvCjTymsZXdc4/OLP0BQH6py7RjKjaspS9N5awzU9NB512M5GzbgeT+XLdFUXj+m8HLFdOSu7fQopJVLXxnejvwqZ0qAmISGBhIRzt2L+8pe/5Ac/+MHI3y0tLdx66608/fTTrFx5bnl0k8lD6jpHX/4FXbVHUeJno0bnAKA7a6nb/yr9nQ0suudLl6VoFAz3ZN+AC1QLSuIilJgcQKA762g/eZCBnlaWffD/XNT6sBCC6LTgzsoXg6e/B+zR498sQmLw9VQgpbxkTRfFYiVtwXoaSt5CxuQiQk8XIktdQ2veb3RARWWjtxYj/YNEJGbT1/geSN0IFrxutJqtiPBk1PTrEPYI46I30IFWvx2t9h3E3PeNuQDKgQ4A+vvcHH/9/xK690WWvO+bk9qB4+nrBkfMuOdJhMbibaufcB9SSmr3vEDtvpeRUkNYHEj/EOVbQyhY/zBpC9aPen1/ZyPu9loU1UJs1jxsoVHBd3yFcIQPm5UOdSOCKTl7egCwn+O8S6nTdGQrDYfeZMjZBkBITDJZSzeRtnBj0HMcnVZA/rqHOLnjL4aTdWQGSB3pqkf6h5h/+98REhlP9XvP0VD8BppvyNhQCOJzlzDnpkcntX5sJtNVXYy3rxtLwd0jAc0plJgcdHcjetcJlIR5xopGaBwiJIae+uNjghprSIQh6tlbPcrv7BRyoAPpdROfs/CyHtOV5KooFM7MHJ06Cw83dBzy8vJIT08PtonJZaKj6iBdNSWoOTehRJ1RoxSWgAhPoavmbTqrD12QVstATwtd1SVoAR/h8enE5y4ed6bfcfIAzuYK1FmbUM64sKuJ89DDk+irfIW2E7vH3KCmAntYNLTWjR+0eJxYQyaeIV8IOdfdS09jGX1VmxExuSjhKUj/IHpXOfj6EbGz0KvfQA52kb/uIXQtQF9nA1rju9C8H9BBtRut08NdZkIIQzU492YCFS+h91ShxheOvKfUA2ith8AeiaXwXhjqYahuG0de/BkrPvzPk3ZsttBI6Gyd4Fy6sZ7Dsbtu38vU7HkeJWkhasI8I6jx9qG1H+HEW79HtdhInrOaQWc7pZt/g6ulcmRboaikzLuBwo2PTFlBZVRaPo6oJLztRxFhiWcVtevo7UdxRCZMGJhLKTnx1n/ScnwHIjoHNXsDAF5nLeVv/4G+jnpm3/SxoOc4a9ntRKcW0FjyFr3Nw+J7s1eQsfgWwuMzKH3jt7SW7kJJmIslrgAUK9LdRHfjEQ789fusePj7V1Ux91ThbK5AcUQFbYgAUKKz0XqrwT8INkPKQIxjmCuEIHv5nRx//f+itR1GOcO2Qg71ojfuIiwu/aIbIaYjV0VQYzJ9aD76DiIsaXRAM4wSlYEelkTTkW1jghpdCwzLu9tGLpgBn4fSN35D58kDoFoRihXpH8QWFs38O/6e2IyxPiUtx3ciwpNHBTQj7x8ajx6ZQfOxHdMiqEmZu5aW4zuQrnrEWY7W0j+I7K0mbemtk/Z+FlsIS9//bRoObabpyFZ83ZUgFCyOMAJCgKuO2Iy5ZC77JHFZ82kofhOEQM2/G+luRG8/ihJXELRtXoTEQkg8est+0APGBdfrQussA28fat4txucaGoeSsYa+6jfpbToR9DO8GFLmrqW9fA+yr2WMR5L0DyKdNaQuG99GIuAdpHbfyygJ81FTTqvmGun7NWial6p3nyE6YzYHn/pn/AEdNXvDKFPXltJd+AacLLr3y1PigSaEwuyNj3D4xZ+i1WwxamscMUhPL3rHMWR/K4X3fDloh9IpuuuO0nJ8B2rG2tHmq9HZiO5Kmo9uI7Fgxbht4eNpKLnba2kt3WmIY56hdCziCxERqXgrX6ah+A1mrTW7o86NGLbEGCeAP6uuSXrd6IPdRI2jFpw8ZzUDva3U7nkB2V0BYUkQGEL2txESnUTR/V+d8DtztXFVBjXZ2dlBC9ZMLj+Dzo5RSxtnI0LjGXR2jPzd21RO3f5X6a47AlLiiEoko+gm0otu5ugrv6S3sXyU+7Ic6sHfcoCS555kxUPfG9P26unrQTjGT2MLRwze/gncrq8g0emzic9dTFfdLqSvDyVmFqhWI4BoLcbqCCNjyeQENR53Fy2luxhydWB1hLHwni8SHpeOYrGO27kVl7XAKBz2OFGTi9DbDoNl/NoSYQ3FqgTwtR6E4QJjEZmOknk9yhnfCRGegrCF0V17dNKCmrjsBcRkzMVZ/w4yeYnhBaVYDPf01oPGuVx8y7jbd9UcRg94sSSMHY8QAiVhHp6qzVTtfBq/dwi18F6Edbg2S1FRExcgbBF01byDs7liyopi43OLKLrvq1S882eGqt8ceTwkJoXCe79MfO7iCbdvOvy2sVwRzEsrNh/RdYKmw1svWOum5fhOw48t2H7tEYiYPJqPbSd7xZ1ofh/WkPCL6ii8nLjb62g5voMhVye2kHCS56whNmvepN/wvQMumo+9Q2dVMbrmJzIpm/Sim4hKNmrbYjPn0nBoM3KwCxE2tjxDd9YY9VPWUEP8sHE3FkcESYWrxn3PvNUPkJS/gqaj2+jvbsZiiyFx7T0kFawcZdA6E7gqgxqTqcPqCMPr6R/3eenrH269hdYT71G6+dcIRyxK6gqEasfb18zJnU/RVrGXvrYa1OyNo20PQmJRc25Eq3yZuv2vsODOz43avz0siiGnc/z39zqxhUVf0jFOFkIIFtz1eSrf+TMtx3cQaDk48lxUWiHzbvu0sUR1idTue4nq955FKFawRyO9ThoOvYE9PIbMpZtIW7A+aPF0WFwqcblF9DTsB1s4hMSgO2uRg51G3YZQEVEZKHGFRufUYAcpRTeSPHcN+/7nH1Cy1qEGK9wVAqFY0bXgxYkXgxAKi+79MuVb/ou2ir3ozftGnotMyWf+7X+HPWz8mhe/dwCEgrAFVx4+ZU3QWVOCiM47HdCc+ZqoLIQjitbSXVPa6ROfs4i47IW422rwDjixh0UTmZx7Xtmj/u5mRFhK8LZ/IRBhyfR3N13wmLx9PeCIHjcAECGx+LtOsP1XjwFgcYSTvnAD2SvvnnIPKCl1yrf+keYjW43vgSMG/PW0lr1LdMZciu790gWNUUqJ5vegKBYUi3XUc66WKoqf/zGa34eIzESooQxWHaa1dBe5a95H7qp7icteREh0Mp7GdxG5N498N6WU6N0VSGcdIjLDMKl01iAELLr/q+cMTsITMkaJac5UzKBmipBSNwpehcAWGjUl6eyLIWXuaiq3/wXpdSPsoyX0pdeNdDeSsuRhfINuyt78HSI6DzVzzcjFTonNQ4+dRV/NFlBtiCCthkKxIGLz6Th5AF0LjKqvSZl3Pb1v/AZ9sBMldPQsRg71It2NpC2bPj9c1WJjzs0fJ2/NA/TUl6LrASKTcibNh6X52A6q333GWCuPyECrf8foXAqNx6srnNzxV2p2P8/Cux8nLnvBmO3nb/o7Sp77Me6q1402b92P9PUjQuMNR+j2Y+idZYjIDGTAS9rCDTiiErCGRqH1t0Ow4kOPE93jJCo5uKXFxWKxOZh/x98z64YP0FNfitQ1IpNzg4rYnU1IVKJR2DrYFTTTKAc6AdC8gygJwYMjIQTYIkesNaYSIQRR53BB97i7aDqyle6640ipE51WYNReBIbG3UYGhi7Kl8kWGgnek6OWTKRvAL2nEjnUg/QYXVZK+kqENQy9r4X6Q2/QXXeMpR/49pQGNvUHXqP5yFaU9FUocYXGOZIS2deCq347ZW/+joV3feGc+9G1AA3Fb9B4+G28bkPlOTZrPtkr7iI2cy4Bn4eSF36CbonAkr9xpAj4VD1UzXvPEpGQSULeEoru+zKHnnkC34nnEJHpCEsocqAN6TEmbZq3B4s+SNKi9aQX3UJodOJlPktXD2ZQc4WRuk5D8Rs0lLw1/MWH0NhUspbdTur8ddM+uEmddwMNh97EW/MWSurKkfoG6W5Gb9k3LPl+PU1HtyElWNKWj5m9KRGp6NHZSFfDuO8jbOHouoYe8I0KapILV9FYsoX+mreRyYuHK/oF0lmL3lZMWGwaKfPWXpZjvxRsoVEXrXczHlLq1O59ERGdjZIwn0D5C2ANxTLrNsRwe6/0D6I1vsfhF3/Gqo/8cIzTt9URxrIPfYfqXX+j/uBrRlrb60K6hoX07NGGnk1vDblrHhjxiclYdCM1+15CRGehRKSeHpPmR2vaizUk8qKNPc+FIyKO1Pk3XNA2cVkLsIfH4msrGXZjP6PIVvOjdxwlKq2QIWcHgWFrjLORUgevE0fE9Hc67qo9wtGXfo5EGG7NwsJA6btIvweEQKYuHyO8KP2DSHcDSWved8Hvlzx3Dc3H3hmpH9O7K41Wb0VFhCWBYgEkekcplrxbUKIykbH59Fdvpm7/K5dNjfpc6FqA+oObUeIKUePnjDwuhDCubanL6ajczaCzY8LAQdcClDz/E3oby4wC7Kx5SM1Lb2cVPc88wdxbH0PX/AQ8A1jmbhrV1SSEgpK0CNnXQv3BzSTkLSEsNpXVj/6IltKdtFfsJ+AdIDxrNmmLNhKTPmfa3yemEjOouYJIqXPstf+go3I/IiYXNWchSMlQbw0n3vo9/V2NFG54ZKqHOSEWeyjLPvBtjrzyK/pq30aoRspTaj4ikvNYdNfnsdhD6e9oQITGj2lJPIUSkY7WW4MMeIKq2sqBDiyOcNSzZo2KxcqS932DE2/9Jx1Ve9Gb9gw/Y1gPzL31satCc2QyGOhqxuPuRM1bgt5TBZoXS8Fdo5ZYhDUUNXsD2olnaSx5K2j6WVFUuhtKh1VhdcMLKjQR6e9H7zyB7DNqlM40t8xecRe9zZX0Vr+FHpWBCE+B4eJnITUWPvC1Man3qUQoCnNu/rih/1G12WiHtUciB7vRO0sR2hCFGx6hs+oAdQdeRw5rgJyJ7K1BevsuOKC60nj6eoyAJizZUBpWjc9B6hp68z707goCVZuxZBuqxABysBut8T2sjjBS56+/4PeMTiskPm8JXbW70PtakN0Vhq9Y2vLT14ihXgJ12wjUbMEy+z6jtidmFk1HtpG7+oEpqbHpa6/DP+RGTQ/+mYqYXGjaQ3fdEUKLbh53P42Ht9DbWGZYEZwZ5MfNRmt8jxNb/pO4nEVGJ+EZLuwj7yMEIjobZ/N+pNQRQsFiDyVzyW1kLrnt0g/0PJBS0ttQSuPhrbg7alFVGwmzlpBRdBOOy+BVd7kwg5orSEflAToq96Fmb0A5oxtGic5G6yyjsfhNkgpWTqpWyuXAERnPioe+h7utmt7GcgBiMmYTmZw3MoNQLFbQvOPuQw4/p3eUoqSNtr6QHheyp4q0JbcEXaO3OsJYePcX8Li76G2uACmJTiswlhiuIbRhLylhcaC7GxERaUFrRoRiQUTn0lF1KGhQo+sa/R11YAs3gqJhVWIREoOISEdr2IV01tJTf5z0hRsB4/NdfP9XaTm+g8bDbzPYVoxqtZM89zoyl26als6/8blFLHnfN6ja9Tfcde+MPB6btYD8Gz5IRGIWjsg4Wk/swVu9GSVxESIqAzQ/ek8VeudxkmevJjJ54mWfqab56DtIQM26YSSgAaMtXUlfhexvQWhDBCpeQnFEIzGWDO2R8Sy+71sX1XYthGDBnZ+jYtufaDm2HRzRo41SMb5PluwNBCpeGs7o5CAiUgl0ncA/6J4SHRt9WJTuzPM0CqGCUJDaxNYTjSVvGxnTMwIaGFZ6Tl1OwFnLoLMdGfChO2sRtggIiRudcRHKmXqiVxQpJSd3/JWGQ68b9hsRqfg1Hw0lW2g8/DaL7//qVaMYbQY1V5CmI4awmXJWey8YUvOy6wRNR7ZO+6AGTq3pzyIqZWy3A0DCrKW0HN+BPtCJclYFv5Q6sreK0JgUBjuPEfC5jTZQix3pbkF2leGIjCN7xV0TjsERGU/KVTSDmEyGXJ3U7TcUfPVhdWDUCZSUVRv6KSuFszilQKskLhgJaE4hhEBNXkygtxqPu3vUc4pqIX3RjaQPK8leDcRmzmPFw//EoLMd/2Af9ogYHBGn9UBsIREs/+A/cuLtP9BVvQeaDANNxeoge/kd5K5535Sl/n2Dbvq7GlEUCxHJOePq5XTXH4eI9JEMyZkIoSCislH7G5m36TM4m05NSuYQn7fkkrIlqsXGnJs+Rsvx7YY0QLBi5JBYCIlDdzWiROdAwGNsa50a5fewuDSEYkF3N6IGUWqW/a2gB4hIyh53H1rAh8fVjpp5fdDnhcUO1lCGettBDxiK3QAhsajp16GEDU/GXHVEpeZPSrfVkKuDpiPbcLfVoKgW4nKKSJ23dly19faKfTQceh0lbSVK/OnlLZm6Aq1uK4df/BnXf+oXU17UfT6YQc0VpL+7GRGRE/Q5IQSEJdPfPT3akS+V+JwiwuLSGazfDlnrRwIbGfAYppRDPcy569sMuTqp3fcSQzVbAGPGlDJnDbOu/wBWR/BOlWudIVcH+//yPQIBzbhBdBxHhKci+1pGUtdnI/uaxy2o9fUbNSTKOK36wh4Bqh3bOcTtriZCo5NgHEd3e3gMRfd+GY+7i76OeoRqITqt8KIKaCcD31Afle/8mfaKvchhfx+LPYzMpbeRs/KeIOrd52E+iSSpYAVJBSsmdaxS6iAlQhm/E0eoVqNoW0r0nkpiMuddlLXJZGALiSB59iraKg8iIzNGWVDIgAe95SBhcelEpxWOuw9FsRjZnEDwzLTWWQpeN8TkYUmYB7Zw5GAHetsRtKo3YNYm4+++VjLXXXg909k0H9vBiS3/aZznsGTQA3TX/4navS+y+IGvExkkQGs4tBkRkYp6luSBUK2oGdcTOPEMrWXvkjHBEtx0wQxqriCqzYE2QecBgSEsoTPjRi4UhcUPfI2S555k4OSr6CGxoNqM7hMB8277NDHps4lJn03K3LUM9rSiBXyERidO2QUOjI6RQWc7qs1BZFLOtBSlqtz+VwIBiZpvZLICVa8j3Q2gB9DbSlCSl4yaJevdJ5EDHWTc9HDQ/Vkcwy2jw11PZyMDXtB8RGfMGfPcTMYRGT/ltQQB7yCHnv4XBl1diOQlqFEZoAXQe6qo2f08Q64O5t76qVGfd0z6bPpKtiD1wCghRakH0J116N0VhMUm4x86Lb8wWSiqhdDYVIb6mkaL+50aQ8CDHOhESZxvLGsOdpFz+ycndQwXSv76h3G31zFQ+YqxJBYaD94+ZG8VqsXCgju+OmF2TigK8blFdLdUIRPmnFWE7kNvOWRYyqRfd3qbSKMOLVD5Klr1m6D7yVp2O4mXGGQ6mys58dbvUeLyUdJWjnz+0jdAoG4bJc/9mDWf/NmoAF3XNdxt1ShnjG/U8dnCEGGJOJsqzKDGZDTJBSuoP/QmMmXpmDS/9PYh+5pIWvaRKRrd5OOIiGPVR35IV+1hOqsOoQf8hCesJ3X+DaOKToUQhMWlTrCny89ATyuV7/yJ7rpjnFrYdkQmkLv6PlLnTZ/CUN+gi87qQ4buz3CBtSX/DvT2o+hd5cZ/+1pQYmchhIruqke6m0hdsIGEvCVB9xkanUhEch79nWWIqMwxgZzeXQ5CkDJ3zWU/PpPRNB5+m4HeNqPW6Ywsgjrs99Nauov0RTeOWgZOX7SRhkOb0RrfM4QtFRW9+yRay36j3V+x0tdRz87ffJ6clXeTs+reSV1Sy1x8C+Vb/4juahjlDi2ljta0F4ZbmBXVwtzbPk1s5rxJe++LwRYSwfIPfYfGki00HX0Hb3MVFnsYKQvXkbV003kFttnL76Tr6R+gNexCTVtpWHBIidZ+DKSGkjjWW0koFtTEBWgNO5l/+9+RPOfSf1/1B19HhESjpJ9Vz2QLQ83egL/sWdpOvHfhS8byHNm/aYQZ1FxB0otuounINrTaLajpaxAhMYYewmAneuN72MNiZtyNQygKCXlLxr2hTgcGne0c+Ov30aRAzViDCE9C+gfxdp2g7I3fEvAOXrEOhHMx5OoEqaOEn146ERYHatoKlNRl6M5a9Pp30Qf3nnqW8PgMclffP+GNa9aa91Hy/I/R6t5BTVmKcEQb6feucvS2w2Qu3TQpQoEmF0bzse2I6Oygztwidhai4xgtx3aMCmpCohKZt+nvDL+f/jZwxCD7mhExeajJiw2jUv8QemcpNbufQwiFnFX3TNqYUxduoLv+OJ1V29CjMlAi0pGaF9lbhfS4icmcS0LeElLmrp02S8wWeyg5q+4hZ9U9F2UwG51WwPzb/56yN35DwFmPEhqP1HxITy+o9vFFH0OM4uiQcZZCL5TuuqOIhAXB65ls4YjwZLpqj4wKahRFJSq1ALezFuLHFgNLbx9yoIPYjIlrHKcLZlBzBXFExLHkwW9y+IWf4at40eg8kDrS6yYkJoXF933lsi29SClxt1bjHejFFhpFVOqsabm0MhVUv/ssmi5RC+4caUEX9kiU8GS0pr2c3Pk0KXPWTnqq/mKw2Izvh/QNjLTjnkIIBSUyA12ASFpiKAH3NTLQWsyhv/2QlQ//07jfr7jsBSy86wuUvfVfBMpfQFjsSM2HEApZy25n1vUfuOzHZjIWb183IiW4iKEQCjhiGHJ3jnkuefYqwuPTaSh+k9bSXYjIDNTM60dudsIagpq6DKRO7b6XyVh886RdexRFZeFdX6D5+HYaS7Yw0LQHoaok5C4ha/nt4zYXTBcuNmuVPHsVsVnzaC3dRX9ng2FRolppPLwF6R8MqlItPUY922SpoEtdRwQp9pZSIvtbkV437tZBTu74K6nz141kyLOWbeLoy79Aaz9qNAycKhQOeNAadmJxRJA8J/jy1HTDDGquMJFJOax97N/orDqIs+UkQghiM+cRl70oSMHf5NBVc9jwinG2jTzmiEqkcP3DJMxaOsGWM5+Ad5COk/sRyUuCauooSYsIdFfQVr6HjMVTv54cGptiFGB3nTCURs+6AOvdRou7GpePsDogNh8RmshQxYs0H9tO1rLbx913Yv5y4nOK6KwpYcjZgcURSuKsZaOWCk2uLBZHOJrXbdyUBtqRvbVIzTvsp5QPvj5soWlBtw2PTyd94QZajr1juJIHuVkrCfMIdJbSVXN4UsUhhaKQvnAj6Qs3GsXDiGtCMM4WEjHqN+b3DNB09B30juOoaaPrZaSuoXeWEZ0+m5BJqt2KTM7F7W6EhNNLelLzo9VuQ/a3gC0cvxpGw5Ft1B98jazldzLr+g+QmL+cnFX3Ubv3BWTPSUREqpFpcjWgWm0sfuDrV43+lxnUTAGKaiGpcNWEBmSTRVdNCYdf/BkiPAU17zZjycvjxNtxjCMv/ZyFdz9OYv6yc+9ohuLtdxru4eN1/lhDUOwReILMhqcCIQR5ax4wZlWN7xnLCbYwQxW3u3KkKPHMWaFwRCGismg5vnPCoAYM/ZnJ7ogxuXhS566lvmQLcqgbOdAOtgiELcxo428/CkDS7PGDEb/HUIY+W0jwFMIWBkLBP4Gf26VyLWeErY4w8tY8QNXOp5C6H/VU99NAB3r7YfA4mXX9Zyft/TIW38Lx1/4dvbtyxC3dKMjuRM29CRFhTIROBVT1B17FERFHxuKbyVvzAPE5i2g88jbu9lpUq42E6+4lbcGGCX3VphtmUDODkVKnfNufEeGpxhd6+OIiwpMRYUlotVup2P5nEvKWXLYs0XRnZEnJ2wfhYwXjpOZH9w9iDZk+2YrE/OXMvfUxyrf9iUBvFcIWjvQNGgWJcbNR0sYGJcIRjddVNQWjvfJofh/eAScWmx1b6NVzMQ5G5tLbaCh5CznUbdg7RGYM35QC6O3H0NsP4xsIbusAEBI1LKUw0BFUyVYOdoHUrznhyitJ1rI7UFQrNbufJ9BdOfJ4SEwKc9/3DaJTJ892I6lwJb1NJ2g+shW9twpCE5CuetSMtSiRp/3mhKKiJi1AenqpO/Aq6YtuRCgKUamziEqd3suD58IMamYwrpYqQxRq1qYxsyUhBErSQrwnX6O3qZzYzLnj7GVmYwuNJDZrAb0dZYiY3DHr0Xp3BegBkmdf/qzahZA6fx2JBStoL9/LkKuDjupiBgeGUDOCr3tLTy+OKVBsvZL4Bvuo2f0cLaW70Ic1Q6LSCoedj8eaeV4NBLxDSM2Pmrl2VCeRUCyoKYuRXie1+14d9o0bOzEJjUkmKq0Qd8cxIyA6QzlXSh2t7TC2sBhir9LzczUghCBzya2kLdxAb0Mpfs8AIVGJw0J7k7skJ4Rg9o2PEps5j8aSLbhayg13+pjg+mhKbD7e6jfo72o8L2PYq4Frc3p+jeDt7wEYU1B6ilOPn3rdtUre6gfA60KrfRt92K1ZBjxobYfRWw+Svmh6ep9YbCGkLdzArOs/YBgCenrQ3WPFG+VQD9LVcFGePlcLvsE+Dvz1ezSXvgtxc1DzbkXNvAG3s5eS535M24ndUz3Ei6KrpgRUKyI6eLGwEluAx9XOQE/ruPuYvfEjiMAg2snXDM2ioV50Zx1a1RvIvmbm3PzxKfFdutZQLTbicxeTMnftsGP65akxEkKQVLCCZR/4NnlrHjACWRH88z2lOq1rwdXGr0bMTM0M5lTqXXqciLAg6WWP03jdNd6qG5U6i8X3f43SN3+H9+SraIoFhoXLMpdsIv+GD071EM9JQu5iYrMW0FO3DZm0ECUmD4SC7qxDth8hLC6NtAXTR29nsqnZ/Ryefhdq/h0I+xkaSDG5aA27KNvyn8TnLb4qZN7PRAv4DO8uRTUKbn3D7um2cOOmOKx3pQd84+4jIjGL5R/8R07ufIqe+ndPP56US/6mjxGbNf+yHoPJlUEP+Gmr2Etr6S68A07s4TFEJmUjA17kYGfQe4De14RQrYTGpEzBiC8PZlAzg4lOK8QeEYev4xgie+OomcEpYShbWAwx15hSbDBis+az9pP/Rnf9MQZ727DYQojPW3zVWAMIRWHRPV+icvufaSndRaC1+NQTJOYvZ85NH7tquhcuFM3vo6V0FyJuzqiABoa9q1KWEjhRQ1v5nhFDzquFiIRMpH8IrWkPuqsB/IPGE7YIlIS5yIAXxWIzbB8m2k9iFkve9w087m48/T3YQiKmpemoycXh9wxQ/OyP6GuvQUSkIuzRDPX20NtQirDY0FsOIHJvHuUHJj1OZGcZKXNWTxu9oMnADGpmMEJRKFj/MMde+aUhqpa0EBwx4HGidRxFuuoouP3vzdTzMEJRiM9ZBDmLpnooF4VqtTHn5o+Tt/ZBXC0nkbpOVErelLgfX0m8A73oAS9qePAbu7CFodijGJxgiWa6EpuzEKFa0bsqELGzDBNIdPTeWvTmfSBUkicwKjwbR2Qcjsi4c7/wEgh4B2kp3UnbiT34vYOExaaQvnADcTlF10Rb91Rw4u0/0N/djJp/5ygDYX2gHa36LcRQN1rFi4iYfKOxYLATvbea0Jgk8m/40Mjr/Z4BWo7voLO6GC3gJzIxi/RFN15V9TZmUDPDSSpYAXd+jop3/hdf5Ssjj9tCoym4/e8nVZtiuuLp66H56Dv0Np0ABLGZc0lbsH7G3uxtIRHTWsH5YpG6TldNCS2lO/H09WIPjyZ13vVEJucZL/APIXXNcFbWfGCPRITEARIZ8KBOkSHlpdBVVWwUCmdvRIk+fWNRIjPQw5PRGt+bVp/1kKuDg0//C97+XqMw2RqNp7WBruqfklS4isylm2g5voOBnhYs9lCSClaQWLBiXMdxk3Pj6eumo3I/StqKUQENgBKWhExejN56iOS8IjpOHkAL+LCFRZO28i6ylm4aCYj7OuopfvZH+D39iIh0sNjoL99H89Ft5K19Pzkr756Kw7tgzKDmGiCpcBUJ+cvpbSjD22/cDGIy5qKoM//j76g6xLFX/934IzwNkDj3vkTd/ldYdM8Xicse68liMv3Q/F4Ov/hv9DYcNwwHHTH0tzXRVf0LotNnE5GUR19bMbTsh4Dn9IYhsSiRmciA56rU32k6ug0RnjwqoDmFiM1HdJbSXr6HxGkgoiml5MhLP8fn82OZff+INo6UEumspb1iJ+0Ve43W8tBEcDrpqv41tXtfYsmD38QRcXkzSDMVZ3OlYZ0SPU6HU0wuessBEvOXM2/TZwxdrrOu/ZrfR8nzTxIQNixzHxzRuZJSR287TPW7fyM8Pn1aBdDjMfPvaiaAIV1+tba1XiwDPa0ce+WXEJlheDoNryfLgBetYRdHXvo5qz/242nZ2WQymsrt/0tvUzlq7i0okacVdPW+Flx127BHxIKvHxFXgBo/d1jgrB2trQS9/QjR6XMIj8+Y4B2mJwPdLYjwzKDPCSEQYcn0d4/teJsKnE3l9Hc2oObdOkrsTwiBiMlF729FOutQZt+Hcso9eqiHodqtHHnp56x4+PuXfXlKSjkyphnD8DHBuY7J8LQSQSaz7ZV78Q04scy5f7Rwp1BQkhcj+9uoP/i6GdSYTC+krhPwDaFa7ddElqbp8BZQbYbnjXL6eIXFjpq1Dq3sbzQd2XpN+BpJKXG1nKS77ghS14lMziU+b8lVUU/lG+yj5fhOlKRFowIaACUiFZm0GE/LfkRcAZaM04awIjIdEZ6MVvkKQrk6b2IWWwj+U8XBQZCBQSzhl8cv7kLpbTyBsIYgwoN30ijROWjdlWg1W9GlBtZQlNh8RPp19NVswdlcQUz6WEPFyaC7/jgNBzfT03AcKSVRKbPIXHIriQUrrvoAJzqtAIRAOusQ8YVjnteddSCUCT23eupLEWEJCPtYscpTQamzaQ+6rk37a8bMv7NdA0gpcTZXMNDVhGK1E59ThC309EzJP9RP3YFXaT62nYCnH6GoJOQvI2fF3VdVAdiF0lV7BBGVNSqgOYVQrRCZSVft0Rkf1Hj7ezny8i9wt1YhrCGgWJD7X8EWHsOiux+f9gaDzpZKpB5AjRlPqyUPvWU/ImRsxk0oFpSE+fQ2vDu89HphdVRSSvxDbqQ0hBqv9A0wefYqava9gkxdNsabTHr7kO5Gkpd+5IqOaTwk8hyvGD53gUEIiUMOdaPVvIWIzARLCN11Ry9LUNNQ/AaV7/wZERpveLwJhT53I8de/RUZi2+lYMOHp01g4+3vpbV0F0N93dhCwkmevWbEdHI8HJHxJOQto6uu2AhMztAlk4NdyPbDJBeumvC7L6UOE9hZjAg7ynN9xlOPGdRc5bjaqind/BsGe1pACJASoVhIX3Qj+es+RMA7xIGnvo/H3Y2InYWanIj0DdBZX05nVTGL7//ajFUTlrocV3QKDKlwXfeM+/xMQNcCFD/7Iwb7elFzb0ZEpBky+0M9+Jv2UPzsj1j5yL8QGj2NZfKlbvx3vM/ylP3HeNnHkGgAvAOu8w5qpJQ0H91G/aE3GOptHd5NMllLbyNt0cYr5meUtuhGGg9vIVDzFkr6apTQ+BFzS71pN/bwWFLmrjn3jq4AMWmF1O55AdnfhogYm62RzjpQ7VgK70EIxTgOVz1a/Q5QVKSuT/qY+ruaqHznzygJ81FSl50OXhLmQtcJGkveJC57AfG5Ree9Tykl7tZqBnpaUG0O4rLmX7LDuZSSun0vU737OVBUFHsU0tdP7d6XSJl3PXNu/sSE2fU5t3yc4r89QX/Fy0aG0hGN9PQi3U1EJOVQeONHJ3z/6NR82iv2ju8m7qonPDH7qsjwT/8RmoxLf3czh/72BNIWYZhVhieD5kXvrjAuhL5BhFDx9PWi5t+JcJxOLcr42Wi1Wzn++v9l7WM/vyq+rBdKdOos2muPI1OXj5mJSakj+5qImX31FY9eCB0nDzDQ3YSl4C6jwHYYERKLmnszWvnzNBa/QeHG6THbD0Zkci4Ige6qR40fO5OXznrjf2zj+HMNOQHO25RPSkn523+g+eg2RHQ2avYGALzOOsq3/jfu9jrm3PKJKzK7t4dFsfTBf+Dwiz/DU/kKuj0CpI70DRAam0bRfV++5BvqZBGTOc9wkG/ei8i9xTDLHEZ31aN3V6AkF532oBMCEZ2NHOpBbz9KWFxwt/FLoenIVoQ1FCVlyZjPS42fg+ypprFky3kHNa62asre+B0D3U0jjykWO1nLbid39X0XHew2H3uH6veeQUlaiJK4AKHajE6+nipay95DtdiZfdOj425vC4lg+UPfpfXEe7Qc34m3vxV7eAxpqz5J8pzV5+wuS5m7lqp3n0FrfBc1e+Oo7LbeXYnubiJz9acv6tiuNDPvTnYNUbvnRaRiRc299bSni8WBmrQIoTpoLd2FUC2IhIWjAhoY9o5JXY6v4iW6akpIzF8+BUdweclYfAtt5bvR24pRkk9f1KSU6C0Hkb5B0otunuJRXl7aK/YhwhJHBTSnEKoNEZ1LW/neaR3UOCLijPR6/WFkWBIi5HS2RXpc6G3FIBSkqw7OammVegC9q4zYrAXnnaXpaSil+eg21IzVKHFn1ChEZyO602g5vp3EguWGptEVIDwhgzWf+CldtUdwNlcghCAmYy6xWfOmlQO2EIJF93yRg0//C77y5xCRWQhbKHKgwzDUjMxASRrbbajE5KG3H8F6GYQu3W01EJ4yxtNtZMyRabjba85rX/2djRz62w+RtkjUvFuM2iH/IHpXObV7XyDgG6RwwyMXPEap69TueRERk4eacrqLTSgqIr4QqXlpPvYOOdfdN2FgrlrtpC/ceFECkxZ7KAvvfpwjL/4M7cSziKgcsNiQfc3IgU6SZl9HeEImAe/gtAmix8MMaq5SNL+PjpP7EcmLR5nUnULEzoLWg0jNhxIZfE1WhMQirKH0dzXNyKAmKnUWs274IFU7n0K6mxBRWSAl0lWH9Dgp3PhRIhKCd5bMFALeQQiSTh7BGobmn/5LcHNu/jiH/vYvDFS+bNRJOWIMRVRXHSHRSSTm30T9/pdB86GMdD91oLcfRvj6mHX9+8/7vZqObDV+G7EFY54TsbMQ3SdoOrL1igU1YAhDJuQtJiFv8RV7z4shNCaZ6z76BM3HttNWvge/px3VYWdwAJSs9cGDsOGA43LkvRTVAvrQ+C/Q/OMvW55F9e7nkKpj9CTSFo6augwsdhpL3iJz6SZCztFNqesaHpfhMeeISqCvvQ5vfw/qrOCmuUpcIYHWQ3TVlJC2YP15jfViiMuaz6qP/JDGkrfoqDqEPuDHHh5DQE2gvXwP7eV7EIqFpNmryL/+A9NW58sMaq5SAj5DaEyxB0+5C0VF2MKQQz4Ydiw+G6kHkLofxTI2KLra0bUAAe8QmUtuIyo5j4biN+htqgAgNmMuyXNW09/VSOnmXxsiYIWrLotr7lQTFpuCs30vUupBbyhyoP2cEvvTAVtoBMsf+h4tx7fTfGwHXmelISB2wwdJW7Ae1RaCPSySmj0vEuiuHNkuLD6DOXf/A5FJwTU8gtHf1YQISw76XTDaqFPo72oKsqUJgDUknOwVd5K94k7AOJ97//hNcDdCELdo3VUPQiEiKXvSxxKftxjnrmeQ/iGjSP4MpB5AOmtJnBvc2f5MAt5BOquLUVKXB51EKnGzke1HaDvxHjkr7wm6D6nr1B98jYbit/AN9AJgC4sZWfo6e3wjqDZQLFdk8hEak0zhxo9QuPEjNB/bzom3fo+ISEXN3gjWUGR/G+0ni+ltPMGKh743LQMbM6i5SrE6wlAsNuRgD0SN7WCSmh/p7cfiiEDrrkSJTB/7mt5a0Pwk5E29cNdkMejsoHbvi7SV70FqfhSLjeTZ11Gw/sOERBlLE3UHXuXoK780Aj9HLNI/QGPJW8RmLWDh3Y9juQqVZ8cjbeFGmo5sRe8sRU0crVOk97chXQ2k3zh9l57OxGJzkLnkNjKX3Bb0+cwlt5G2cCO9jScIeAYIiU4iMjn3ggNVi9WOxzf+7F4GhmbUd+RyEx6fTnT6HFyth4wOpDM0bORQL7L9KEmFK7FfBmPd1PnrqNv3ClrdNtSsdYbwHyADHrTG90DzkbH41nPux+/pB6kjHMHHKFQrwhaOb8AV9HkpdY6//n9pr9yHiMlHTTYy4/7eWlqObwdAczdjSRg7SZWDHaAHCIud/Jqjs9G1AJ1VB2mv3E/HyYOI2HxD4+vUbygsARmTg+/kq9Tsfp45t3ziso/pQjGDmqsURbWQMnctLSf2IuMLx1Ss652lIAPkrLyLkzv+gtZyCCXJ8JE51XWgt+wjIX85YbEzw6G1v7uZg0/9M5ouEQnzURwxSE8vrZUH6agqZvkH/xF3Ry1VO59CSZyPklR0xvlooLfxXUo3/5pF93xxqg9l0ohIzCJr+Z3UH3gVOdiFEjPLaOl2NaD3VBKdMYe0BRumepiThmqxXfKyUFLBCvp2Px+0E0T6h5CuehKvu/eS3uNaY/6mz3Dw6R/gqXgREZ2DsEchh7qRrnrC4tKYvXHi7pyLxRYSwZL3fYOS55/EX/as0UwhFORAG4qisvCex8/ZMg1gDYkwnNKHeiBi7Oul5kP39hkikEHoqjlMe8Ve1Oz1o5R/lYg09Ig0tPrtyPYjyOisUd85qQfQW4txRCUSmzXvIs7A+TPk6qT42R8x5GwDaxhIiRqkwFrYwhFxs2k98R4FGx6edka5ZlAzzQh4B2kte5fu+uMgJdGp+aQuWIctdGyBWM6qe+isLsZf9TpK4kJERCoy4EHvqkD2VJK98h6ylt2O1DWq3v0bsrscERKD9A0gff3EZi9i3m1XR0X7+VD25u/QhBW1YBPCYh9+NMvo9KraTOmbvyPgHUBEZaKmnq4hMrowskD301m1i4HulvO60F0K7vZaGku24G6vRVGtJMxaQtqCDefdoXMhzLr+A4RGJ1F34DWGat8GwOIIJ3P5HeSsumdGdr5dCqkLNlB/6A0CNW8bs9RQQ75fDvWgNb6HxRYyowLBK4EjMo6VH/5nmo5spaV0J77uJhzhsaSt+xBpCzZc1sxXZHIuaz75M9pO7Kan/jhS6kSlXk/qvHWj9LwmwmILITF/BR21x5Gx+WdcXwz0jlKQOilzgrfXNx3ZhghNCGploMTkoHceB6/LEIqMK0SExhk6RN0ViMAg8x/4xmUtCtd1jeLnfoxnaBBLwd1oPVXIvuag7d0AIiwRra0E74CL0GgzqDEZB1dLFSUvPEnAO2TMKBB01R2jZu+LLLjz82OKBB0RcSz/0Hco3/pHumt3w7D4lTU0ipwNHx5Jq2avuIvk2atpKd3JkKsDiz2U5MLriEzJmzE1JH2dDbhbq4x2xLMuOMLiQEkuwl23HQA156ag+xDROYjmfXRWH7qsQU3tvpeofvcZhD0CEZ6K9Prp2/Mi9QdeY/EDXyc6NX9S308IQdrCDaQuWI/H3YmuaYREJZjBzDjYQiNY+uC3KHnhJ3grX0YZXnLQPU7s4bEUPfDNyxJ8TjcC3kEC3iGsoRGXZDgZ8A7SfHwHrWXv4h/qxxEZT+5195FUuOqKfQctthDSF91I+qIbL3ofeWseoLvuKFrVZiPrHZ4CgSH0rhPo3ZXkrLpv3BqTgZ5WRNj4WlAiLAmbRRCXPZ/WsvfQAj4QComzlpKz6t7LLpLaVV3MUG8rav4d6H0tyJ4qQCJ1LXjnmG8AMM7rdMO8ql1hfINuGkvepOX4u/iG3NjDoklbsJ6kwpUUP/9jdEsEljl3jGg8yIAXrfFdjr78C1Z95F/GaDmERCWy+P6v4XF3MdDTgmKxEZUya8zFwhEZR+51912x47xcBHweuuuOGjUTMUnEpM9GCIWB4cJNESQ1bDx+xnmzBJ9ZCEUF1Yrm9036uE/RVVNC9bvPoCQVoSQvGpl9yYAHrW4bh1/4KWsf+7fLcrEQQhASNY1F9qYRI23UNSX0Np5ASklMxhwS8pbM+GDQ1VZN7Z4X6ao5DEgUi53UeWuHW4qjL2hfnr5uDj79L3jcXYioTERIGj53F6Wbf03z8Z0svu+rqNarw6E7NCaZZR/8R068/Qdc9TtGHreGRDBr/YfJWDJ+bY7VHorXN4HdhX8Aa0g4c27+BAUbHsE/1I/FHnrFarc6q0vAEYPefgTZ1wIRaeBuRG89hBJfOMo+QUodvbucmMx52ELH0YaaQmb2r3OaMeTq5OBT/4xvqN/ICkTNwjvUQ/WeF2gofhPN58WSf88oOfQRn6ITz9FYsmVcASZHZPxVa8zobq+j6fDbuFqrUVQL8blFpC/aOGrWI6Wkbv8r1O17eVQXgCMqibm3fAIxPJPUnXUoofGjtEyAEedmoVqQfc1j9ExguGjRN0B4wsUZH7rb60bS29Gp+USnzx6TCas/uBkRljgsQnb6OWFxoGbeQKDsWdrK3iO9KHg2yeTKoagWEvOXz0i5g/HorjvG4Rd+AvZIlPRVCFs4cqCT5tL36Kw5fMEdL8de/Q+8Q4NYZt+HOKNTU+9rxVn7NlXvPn1R2i7BkFKnu+4YXdXF6FqA8IQsUuauweoIO/fG50l4fDrLP/iPDHS3MNDTgsXmIDqt8JwdpEmzV9K36xmkb2CUKCGA9PUjXY0k32DYtagWG+o4tTmXC6kFQGpIdzNKUhG6qxYwajP1zlIITURNX4FQbWgth5BDPeRe95krOsbzxQxqriClb/wGnz+AWnjvqC+2TFyAv+p1UO1j/F3AEMoT0Tl0VhdPqCp5NVJ/8HVO7viLUXwWkYb0++k/8Cr1hzaz+P6vjnjB1Ox5nto9L6AkzMVyhguzt+0wJc/9COvwDFJvfBcdECFxKGkrUMKTjce7KlBtISQVLKe1fD8yOme0wrIeQGs5gDU06oKdaL0DTo69+u84m8qNdk+hIANewuLSWXj3FwiLNbJHUkp6m8qNttBg7cK2cER4Ej2NZWZQY3LF0bUApZt/A2HJqDk3nl52iExHxuXjO/kalTv+woI7Pnte+3O31+JqqTSWhM+SnlAiUpAJ82g+up28Ne+75Mykp6+bkud/ykBXA8IRhVBt6KW7qNr1FPNv/7tJD0zD4lIvaIk6bf56Gg69iX/Y7uLUUpRhd7EHW1gkqfPXTeoYL4TwxEwo3wshsejtJYiIVJTUFQh7pOHR1XYErfI1QGKxhzH3ri9cNvPRS8UMaq4Q/V2NOJvKUbPXj4nUhSMKJbkIvWlv0EgeAMWKrmtXaLRXhu7645zc8ReUxIUoKYvPWIrxotW/M7wU83OkrlG372WUpIWjFTfDkxG5NxOofBXfYD9q7i0IR5RR0Nl+DK36TWTOjeB1oXceJ+e6+8hYfAvOliqGTr6KiJmFCDe8sGRPJfgHWXDfVy5oeUEL+Ch+5l8ZdPcYF++oDEAg+9sYbNnHoad/yKqP/stwobcc/jdRHZO4KkzjTGYeXTUl+AadWArXjamjELZwRMI8Oir349v4EWwTqP9KXafx8BZq9rwAQhn+TYxFic4m0H6Evo76S7pB6rpG8bM/ZqjfhTrrdkNBWwgU/yB6836OvvIrln/ou0Sl5F30e1wsUkrcbTV01x0lMX8pnVXFeKteP11e4BsgNDaVRfd8aVIzShdK6rx1VO18CrxuRFQWavaGkYmXsEcgItMJnHwNJTDA9Z/51SXVWF1uzKDmCuFuM6S4RWRwBVslMhOdveiDXahnpyelRPY1EpUc3KX4aqXh0GZEaPwYXxZhsaNmriNQ9jdaju9AsRht12rC2JZGoaioifPRGnYiHNEIW9hI1idQ9QZ67VaQOumLbiL3OsObZfmHvkvd/lcM1/KuMqMgL38Z2SvuJvICBcDaK/YZ3kqF94xyxxURKYjcW/CVP0/T4a3krr4fIRSiUvJxu+ogYc6YfUn/IHKgnei0iy9mNLm8SKkT8A6hqNarphbkfBnoaUFYHKO+x2eiRKQSaDnAkLNj3KBGSp1jr/0HHZX7ISQWGL+O5BTiHFrC3v5eXK3VCEUhKjV/zHt3VRcz2NOMWnAnSujpZWVhDUXJugFZ8RL1B15j4d1fOOdYJhPvgJOjL/8SV0ulkYEXCtI/iC00mrjcRdjDoonJmENs5twpt7uwhUYgFAtS96MmLx7bxq1YUJMWodW9g8fdNZJ9no6YQc0VYmTmowdGZMFHoQcAkL3VyKjMUV8qvasMOdhNetHHr8RQrxi9jScMX6pgSzHWEER4Cr2NZUQk5hh/WxxIKUFqINTT251aRgp4YDggFIqKmrwIrWYLC+/+Ion5y0b2bXWEkX/DB5l1/fsJeIdQrfaLLv5sO7EbEZ4S9EYgrKGIqGxaT+wmd/X9AGQuvY1jr/wSraMUJWHuaT8qzW+YyVlspMy7fmQfg852o05H14hMzrsoMbmrFSklzqZyepvKQQhiM+ael+qz1HUGe1uRUic0OnlSFLM1v4+GQ5tpPPz2iBpsbNYCslfeRWzGzHC5V612pO5Hav6gqrnSbwgSqhMUr7aX76Wjcp8x07dHEah4EemsRwRTEu6tQbWFEJEUvLPHP9RP+db/pr1y/4hTu1CtpM67noL1Hx4JKjurDiFC40YFNKcQQkHEzKKz+hBSyiv229G1wOkMbs6NiMh0QCAHu/A376Xz5EFWfeSHOCLjrsh4zoeIxEzc7XVj6xGHESHGWD3ubjOoMYHYzHkgFPSeKtTEsRkHvbfKKGJ11aOdfAURnTNs0teA7G8ja9ntlywq1tNYRsPBzfQ0lCJ1najUWWQuuZWEWcum5EZ5PhcZKcEREYv0DRCo34l0NYDuB9WOEpePkjAfhnqMF58lM37qR8g47yGEcskpX79nAIZVSoO+hy0cv7Nt5O/E/OVkLbuD+oOvIXurjK4szY901SHQWXTvl7E6wvB7Bih747d0Vh8CoWAsS2lEJOWw4I7PEhqTjJQST183mt+LIyJuRqncDva2ceTlXzDQ1ThSZ1bz3rNEJOWw8O7Hg/rrSKnTcOgN6g+9ga/f+E5YHOGkL9pI7qr7Ljq40fw+ip/7Ea7WKkR0HmrCImTAS2/nSXqeeYJ5t32alLlrL/5gpwkJs5ZRuf1/0XtOoiaMDtSklOjd5YTEpEx4Q2s8shURkYISnQ2ACE9Fa95nZFHPuFnq7kb0zjKylt4WVLxN83s49LcfMuDsQEldbuxP6ui9NTQf38mgs50lD3wDoShG+7NqH7OPUwiLA13XjPbkK9S51lG538jgFtw1ykxWhCUgcm9BK3+expI3yV/30BUZz/mQWLACd1sN0tc/orx8JtLXB3BZjEcnEzOouULYw2NImbuW1hO7EfZIRGQ6QghjaclZi95xnKylm4jLWUj9wc30NBwBqROVWkDmxg+QMGvZud8E0PxeuuuPE/AOEBqdPDKzbSzZQsW2PxpGfQkLEULB5Wzg6Mu/IHPpJvLXPXTFA5votAKc3fXIuMKRQOVURksGPMiBNmKK1hIalwYIZF+zkd2wRyKHetC7K9F760AI43yerf7qNSTLJ1r/v1RCo5Porz8xboAmBzsJiT7dRi2EIH/dh4jLXkDj4bdPi+8t2kh60U2ERiei6xolzz9JX2cjasZaY5YrFGRfM/0tBzn49A/IW/MgjSVv0t/ZAIBisZEydy15ax+8rMd7JfAP9XPwb/+CPyBR82419EAA2ddCf/MeDv3th6z6yL+MKi6VUnLirf+i5fh2Q9o9b7kxiXA1UHfgNdxttRRdYL3UKRqKN+NqrULNvRUl/LRPlowrQGt4j7K3/pO47EXnLeQ2XQmJjB++Ru1BKFZETK6hohvworcfRroayLv97ye8Tgx0NSFiTzubq1k3EKh+g0DFi4iINOO3O9iJHOwiLqeIvDXvC7qf5mM76e9uxFJw96gsqJq0EBEaR2/1W3TWlJA4aynh8Rl0VJUgNR9CHbskqPc1ExKdfEVb8dsq9iLCk0YFNKcQFjsiOofW8j3TKqhJX3QTNbufR+84jpo+2lxTSonecZzQ2NTLrplzqZhBzRVk9o0fxdvfS0/t28asxR4Fnl6kx0ViwQry1j6IolqMrM4FIqWk4dBmava+iOY9vY4dGptKzsq7qdj2Pyjxc1HSVpy+KCXOQ+sso+HQZmIz540Yq10pEmctobfhTwSO/dl4QLGgxOQhEuejN+9HUVRS5t1AyXM/QjiiUWdtGiWspyTMJVD5Kvg9qDkbR+371I/QEZlAVOqsy3YMaQvX016xB9lbbTijn4He34Z0N5G+6pNjtovNmk9s1vyg++yqLjGEBGdtGuneAhCRGYiQOHxlz3Lird8hItMMozmLA9nfSkvZbnoaT7DiQ9/FGjJ+9mi603zsHXyDbiyzHxhVNC8i0xD2W/CUP09r6btkLL555DlncwUtx7ejZqxBiTvDXTs8GRGZTk/1m7Sd2E3q/BsuaCxSShoPv42Izh0V0ICR6VPTlhNw1tJatousZbdf3AFPI2bf9DH0gJ/2incRbYcQ1lB0jwuBpGD9h0mes3rC7RWrHT1wWnJBWEOwFNyF7K1B761G763GarMz5+4vkpC3BKEEryVpOb4DEZkZdFlXiUhDD0ug5fgOEmctJXX+Omr2vIDecshoQz9z6b6vFemqJ2PdQ0gpcTVX0lK6E29/L7awKFLmriUmY+6kT+gCngGwTJAFtoWhuSZwD58CLDYHuavvNwqGESiJ84yWfo8Tra0E2dfMrHu+NO2Xv6+qoOa1117j+9//PkePHsXhcLBu3TpefPHFqR7WeaNa7Sx+4Gv01JfSWrYL74ALR1oGqfPXEZ1WeElflrp9L1P93jMo8bOx5M4FazhyoIOh9hJK3/gtqDaU1LHLTEr8HGRvNY0lW65oUONsquDkzqeNrFX8HIQ9AjnYhd5ZDj0nQSgsuvdLeFyd9Hc2oObePFYp2BY+3DW2h0D7USwpS4azOL1o7UeQ7kby7/rCZS3Ci8mYS/LctbSVvYsc6ETE5IKiIJ316F0niE6fc8FLE20n3kOEJYwKaE4jQOoo8XNQ0lae/jzDk5DROXhOvkrtvpcoWP/wpR/cFNF6YjciKitoF6CR5cygrXzPqKCm+eg7xhJH7Fg1ZiUiFT0yjaaj2y44qAl4B/H196JmBV/6FRYHSmgc/V2NF7Tf6YpqsbHgzs+Rs+pe2sr3DBuDJpIyd01Qq5azScpfRtOxncjkJSN1OUKxIOIKEOEpBE48R96ah0fVuAXD29+LiJqgW8keg6fPWGJ0RMQy+6ZHKd/yX0hPj+FvptrQ+5qQvTXEZMwldcF6jr3673RU7jPayx3R0NZAa+ku4nKKWHjXFya18Ds0NgVX1yGk1INef+RAB6HRSUG2nFqylt0BYLjdd5WBYgE9gDUkksI7PkvirOlvfnzVBDXPPfccjz32GD/84Q/ZuHEjgUCA48ePT/WwLhghFOKyFxCXveDcLz5PfEN91Ox5ASVxAWrq6YuFiEhBhCUY2YyAJ6jctRACEZmBq61q0sZzLqTUOb7510hHrBGsKMNfw8gMlLhCApWvEpOSQ3zOIpqObAXEaEXgM1Ai09EBZaCFwIlao35GSuNHePvfk1Sw4rIeixCCebd+irDYVBqK38DfXQ6Aagshc/Et5K153wWnvX1DfWALvpSh91aBECjBOhQcUYi4ApqP72DW9R+4apVvA95BRMj4dRvCGobf4x712EBPK4QmjDsxEKGJDPZe+HdcUa2AQGqeoM9LKZGad1q3uF4M4fHpzFr74AVvl7HkVpqP70Sr3YqasXpEn0YOdqE17MIeEUvyOP5IZ2ILi2LQ4xz/BV4n9qjT35H0hRsJiUygbv8r9DbuBsAeEUfG2veTufQ2qt99ho6TB1CzbkBE555e+nc10F2/k4p3/sTcSXScTluwgZZj2w19rLM6HfX+dqSrkfRpqDkmhCB7+Z2kL7qRruoSfENuHBHxxOcWXTXXk6tilIFAgMcff5wnn3yST3zi9Bdv7tyZ0XVwqXRU7kdKHTVx7HKGUCzDLc+7xtfA0fxX9AvbU1+Kx92Jmn/H6YBmGGENRUlaSG/jXrz9vcPFnRI0H1iCFAMGvAAsvOuLaP4hfIMuHOGxxOUsumLHJBSFnJV3k7Xsdga6m5FSJyw2FdU6fvHiRIRExuPqOha0Tkd63WCPHpO1GhlLWBJax3H8noGr1p8oNCYZZ09n0OeklMjBDkJTskc9bnWEwWD3uPuU/gEs9gsXeFOtNuKyF9DTcRIZVzhm1i3725Ae13nXvM10QqOTWHz/Vzny0s8JnHgOJTQOqWtIj5OQ6CSK7vvqeRW0p867npM7n0J6XKNEMmF4WXegg9T5Hxz1+KnJoub3omsBLPZQhBAEvIM0Hn4bJXEBSszp7M8pI1vpK6K1dCez1r7vvLJR50NUSh7pRTfTdHgLcrATJTYPhNEIondXEJ0+m9R5F5Y1vJJYbCHnXGqcrkxtc/x5UlxcTHNzM4qisHjxYlJSUti0adM5MzVerxe32z3q30zEO+AcaXkOyrAhnwwy85G6hnTVkpBXdNnGdzYD3c2gWBBBWjDBUBtFSgZ6W4nLXjjcNXYy6Gv1npNYHOHEZswmqWAFGUU3kzBr6ZTMKhTVQkRiFpFJORcd0ACkLliP9LiQvTVjn9R18A8gh1tcz0b6BwCBxXbx7z/VpC/cgOxvQ3ePXdKRrjpD3mDh+lGPJ89ehexrQQ71jt0m4AFnHSlzrruo8WSvuMsQdGx419gXwzVbfa3oDTuJSMohNuvC6+BmKjHps7n+U79k7q2fImXWQtIKl7Hw7i9y3cd+TFhsynntI23BekKik9Cq30DvPonU/IYoZ2cZeu1WolILxlX+Vq12rI6wkQmBs+UkesCLEhu8tk6JzUfqGj31pRd3wONQuPEjFGz4CLaAE636LbSq11HcdWQtvY3F939tUqQGTMZyVWRqamqMi/v3vvc9fvazn5Gdnc1Pf/pT1q9fT2VlJbGxwcWinnjiCf7pn/7pSg51SrCHxxjCbf7B4Fbxwy3PWuuhEYE6GFbubdoNAc+Io/eVQLXaQdfGzb6c0sOwWB3Yw6JJnb+OltJdhu5LdDZCKEhdQ++uQO86Qc7a98+oC0R0WiHJs1fTVrELOdRtzC4VFd3VgHTXD7eA1xtt/2cgpY7sriQ+tyhom+zVQmL+CuJzF9NVu83IjkTnABLZW4veU0FS4SricopGbZNUeB21+1/FU/u2USwakQ6AHOxAb9qHxeYgfdHFWU/EZMxh/qa/o/TN3xFw1iFC40DzIj0uIpJyKLrvq1MunjbdUK02UuffcME1TKew2ENZ9oH/Q9mbv6W79l1ofNd4QigkF65i9s0fO++Ji64ZGmAo47x++HF9WCtsshBCkLnkFjKKbmLQ2YbUdUKiE2fcUuV0Y0qDmm9+85v86Ec/mvA1J06cQNeNWem3v/1tHnjgAQD+8Ic/kJ6ezjPPPMOnP/3poNt+61vf4stf/vLI3263m4yMizMrnM4kFaykYtuf0NuPoaavHPWc1APoXWVEpsxisLeNwIlnEGHJoKjI/jYUIZh/1xcIj0+/YuONzy0CIdB7KlETx9YW6d0V2CPiiEjMBqBw4yP4h/rorNqBaCs26k08TqR/kPRFN5G94s4rNvYrgRCCuZs+TUh0Eo0lbxHoNGaQQrWSMvs6vP299Da+B7pmGKMqKtLjQms5AF4XOSvvmeIjuDSEorDw7sep3fsSjYe3EOg6AYA1NJKc1e8ja8WdY5blVKuNpQ9+i6Mv/wJ3zdujFFxDopNZdM9XL8iI8WyS56wmNnsBraW76O9qQrXYSJi1lNiseWZAc5mwh0Wx+P6vMehsx9VyEiEUotNn47hAs8fIxCxAIN1NiDM744aRLiMjGJl8eWwUhKJMa7G6mcaUBjVf+cpXePTRRyd8TW5uLq2trcDoGhq73U5ubi4NDQ3jbmu327Hbr940/PlidYQxa+2DnNzxF6TmMwrTbEb3k95+BOEfYPaNXyE0OpHWsnfprj+O1HWiF15H6vz1V7z2wh4eQ9rCDTQf3Y5QbYYHk6IiNR96xzFkbw05N398pN1TtdhYePfjuNuqaS17D/+gG3tEEanzb7iiwdiVRFFU8tY8QPaKu+hrr0WXGhHxmVhDwgn4PJRu/g2dVbsQzfvAYkd6+7A4wpl/zxcvawv7lUJRLeSteYCclXcz2NsGAkJjUiacnTsiYln+0PdwtVad4ZZeMGmBhy0kYka0bV9thEYnXVKnkCMynvi8xXQ3HjbUv+2ni/ClbwC9rZjo9NmExwVvRjC5upjSoCYhIYGEhOB1FWeydOlS7HY7FRUVrF1rtMf6/X7q6urIypreQkBXiqxlt6Na7VTvfh5/5ekuj4jEbGbf/PkRT6OMxbeQsfiWKRrlaQo3PILm99JW9i6itRhhC0f3ukDXyFvzIGkLNox6vRCCqJRZRKVc/TfsC0G12ohOLxz1mMXmYNE9j9Pf3Uxn1UE0v5fwuHQS8pfNuNS2YrESnnD+2VUhBNGp+USnjm3tNrl2mXPzxzn4139mqPIllOgccMSC14nsrcEaEsa824Jn+02uPoSUV4cl8Be/+EWeffZZ/uu//ousrCyefPJJXnnlFcrLy4mJOb+0stvtJioqivWf+y0We5DakxmArgVwNlcQ8A4SEpU47dUf+7ubaTuxG/9Qn6FoOu/6S1omMDExMQmGf6ifxpK3aD6+wxDfC40idf71ZC65ddK6nkwuHwHvINv//VO4XC4iIyPHfd1VUSgM8OSTT2KxWHjkkUcYGhpi5cqVbNu27bwDmmuFi1UknirC49IuSg/DxMTE5EKwhoSTu/r+EXNZk5nJVRPUWK1WfvKTn/CTn/xkqodiYmJiYmJiMg0xy/ZNTExMTExMZgRmUGNiYmJiYmIyIzCDGhMTExMTE5MZgRnUmJiYmJiYmMwIzKDGxMTExMTEZEZgBjUmJiYmJiYmMwIzqDExMTExMTGZEZhBjYmJiYmJicmMwAxqTExMTExMTGYEZlBjYmJiYmJiMiMwgxoTExMTExOTGYEZ1JiYmJiYmJjMCMygxsTExMTExGRGYAY1JiYmJiYmJjMCM6gxMTExMTExmRGYQY2JiYmJiYnJjMAMakxMTExMTExmBGZQY2JiYmJiYjIjMIMaExMTExMTkxmBZaoHcCWRUgIQ8A1N8UhMTExMTExMzpdT9+1T9/HxEPJcr5hBNDU1kZGRMdXDMDExMTExMbkIGhsbSU9PH/f5ayqo0XWdlpYWIiIiEEJM6VjcbjcZGRk0NjYSGRk5pWOZjpjnZ3zMczMx5vkZH/PcjI95biZmqs+PlJK+vj5SU1NRlPErZ66p5SdFUSaM8KaCyMhI8wc0Aeb5GR/z3EyMeX7Gxzw342Oem4mZyvMTFRV1zteYhcImJiYmJiYmMwIzqDExMTExMTGZEZhBzRRht9v57ne/i91un+qhTEvM8zM+5rmZGPP8jI95bsbHPDcTc7Wcn2uqUNjExMTExMRk5mJmakxMTExMTExmBGZQY2JiYmJiYjIjMIMaExMTExMTkxmBGdSYmJiYmJiYzAjMoGYa8dprr7Fy5UpCQkKIiYnh3nvvneohTSu8Xi9FRUUIITh8+PBUD2fKqaur4xOf+AQ5OTmEhISQl5fHd7/7XXw+31QPbcr4j//4D7Kzs3E4HKxcuZL9+/dP9ZCmBU888QTLly8nIiKCxMRE7r33XioqKqZ6WNOSf/3Xf0UIwRe/+MWpHsq0oLm5mQ9/+MPExcUREhLCggULOHjw4FQPa1zMoGaa8Nxzz/HII4/wsY99jCNHjvDee+/x0EMPTfWwphVf//rXSU1NnephTBvKy8vRdZ3f/OY3lJaW8m//9m/8+te/5h/+4R+memhTwtNPP82Xv/xlvvvd71JcXMyiRYu49dZb6ejomOqhTTk7duzgs5/9LHv37mXLli34/X5uueUWBgYGpnpo04oDBw7wm9/8hoULF071UKYFvb29rFmzBqvVyubNmykrK+OnP/0pMTExUz208ZEmU47f75dpaWny97///VQPZdry+uuvy9mzZ8vS0lIJyJKSkqke0rTkxz/+sczJyZnqYUwJK1askJ/97GdH/tY0TaampsonnnhiCkc1Peno6JCA3LFjx1QPZdrQ19cn8/Pz5ZYtW+S6devk448/PtVDmnK+8Y1vyLVr1071MC4IM1MzDSguLqa5uRlFUVi8eDEpKSls2rSJ48ePT/XQpgXt7e089thj/OlPfyI0NHSqhzOtcblcxMbGTvUwrjg+n49Dhw5x0003jTymKAo33XQTe/bsmcKRTU9cLhfANfldGY/Pfvaz3HHHHaO+Q9c6L7/8MsuWLePBBx8kMTGRxYsX87vf/W6qhzUhZlAzDaipqQHge9/7Hv/n//wfXn31VWJiYli/fj09PT1TPLqpRUrJo48+ymc+8xmWLVs21cOZ1lRVVfGrX/2KT3/601M9lCtOV1cXmqaRlJQ06vGkpCTa2tqmaFTTE13X+eIXv8iaNWuYP3/+VA9nWvDUU09RXFzME088MdVDmVbU1NTw//7f/yM/P58333yTv/u7v+MLX/gCf/zjH6d6aONiBjWXkW9+85sIISb8d6ouAuDb3/42DzzwAEuXLuUPf/gDQgieeeaZKT6Ky8P5nptf/epX9PX18a1vfWuqh3zFON9zcybNzc3cdtttPPjggzz22GNTNHKTq4HPfvazHD9+nKeeemqqhzItaGxs5PHHH+d///d/cTgcUz2caYWu6yxZsoQf/vCHLF68mE996lM89thj/PrXv57qoY2LZaoHMJP5yle+wqOPPjrha3Jzc2ltbQVg7ty5I4/b7XZyc3NpaGi4nEOcMs733Gzbto09e/aM8RtZtmwZDz/88LSeMVws53tuTtHS0sKGDRtYvXo1v/3tby/z6KYn8fHxqKpKe3v7qMfb29tJTk6eolFNPz73uc/x6quvsnPnTtLT06d6ONOCQ4cO0dHRwZIlS0Ye0zSNnTt38u///u94vV5UVZ3CEU4dKSkpo+5LAHPmzOG5556bohGdGzOouYwkJCSQkJBwztctXboUu91ORUUFa9euBcDv91NXV0dWVtblHuaUcL7n5pe//CU/+MEPRv5uaWnh1ltv5emnn2blypWXc4hTxvmeGzAyNBs2bBjJ7inKtZl8tdlsLF26lK1bt45IIei6ztatW/nc5z43tYObBkgp+fznP88LL7zA9u3bycnJmeohTRtuvPFGjh07Nuqxj33sY8yePZtvfOMb12xAA7BmzZoxrf+VlZXT+r5kBjXTgMjISD7zmc/w3e9+l4yMDLKysnjyyScBePDBB6d4dFNLZmbmqL/Dw8MByMvLu+Znms3Nzaxfv56srCx+8pOf0NnZOfLctZid+PKXv8xHP/pRli1bxooVK/j5z3/OwMAAH/vYx6Z6aFPOZz/7Wf7yl7/w0ksvERERMVJnFBUVRUhIyBSPbmqJiIgYU1sUFhZGXFzcNV9z9KUvfYnVq1fzwx/+kPe///3s37+f3/72t9M6I2wGNdOEJ598EovFwiOPPMLQ0BArV65k27Zt01sPwGRK2bJlC1VVVVRVVY0J8KSUUzSqqeMDH/gAnZ2dfOc736GtrY2ioiLeeOONMcXD1yL/7//9PwDWr18/6vE//OEP51zqNLl2Wb58OS+88ALf+ta3+P73v09OTg4///nPefjhh6d6aOMi5LV49TMxMTExMTGZcVybC/AmJiYmJiYmMw4zqDExMTExMTGZEZhBjYmJiYmJicmMwAxqTExMTExMTGYEZlBjYmJiYmJiMiMwgxoTExMTExOTGYEZ1JiYmJiYmJjMCMygxsTE5Jpi+/btCCFwOp1TPRQTE5NJxgxqTExMpgRN01i9ejX333//qMddLhcZGRl8+9vfvizvu3r1alpbW4mKiros+zcxMZk6TEVhExOTKaOyspKioiJ+97vfjUivf+QjH+HIkSMcOHAAm802xSM0MTG5mjAzNSYmJlNGQUEB//qv/8rnP/95Wltbeemll3jqqaf4n//5n3EDmm984xsUFBQQGhpKbm4u//iP/4jf7wcMz6ubbrqJW2+9dcT/qqenh/T0dL7zne8AY5ef6uvrueuuu4iJiSEsLIx58+bx+uuvX/6DNzExmXRMQ0sTE5Mp5fOf/zwvvPACjzzyCMeOHeM73/kOixYtGvf1ERER/Pd//zepqakcO3aMxx57jIiICL7+9a8jhOCPf/wjCxYs4Je//CWPP/44n/nMZ0hLSxsJas7ms5/9LD6fj//f3v2DpPrFcRz/VHcqiSCIligoBwebJApbJKKoKaIpqKAGGypBEsTAiAYHQdAliNwCJajFkCD6NxREaTREEGWJW4NNQn/A33D5CdHlcoe8ch/eLzjLcw7nOd9n+jzPOfCcnJyorq5ONzc3pb/BA/i3sP0EoOJub29lsVhktVqVSqX048efv28Fg0HFYjFdXFyUrm1tbWliYkIul0uRSETpdFpms1nSzy81DodD+XxeDQ0N6uzs1OjoqPx+/7fXBeDvYvsJQMVFo1HV1tYqk8kol8tJkpxOp0wmU6n9Lx6Py263q7m5WSaTSUtLS8pms5/mGxsb08jIiAKBgILBYCnQ/Mr8/LxWV1dlt9vl9/t1fX1dniIBlB2hBkBFnZ6eKhQKKZFIqKurS9PT0yoWi1pZWdHV1VWpSdLZ2ZnGx8c1NDSkRCKhdDotn8+nt7e3T3MWCgVdXl6qpqZGd3d3v73/zMyMHh4eSttfNptNkUikXOUCKCNCDYCKKRQKmpqa0uzsrBwOhzY2NnR+fq61tTU1NTWpo6Oj1KSfAai1tVU+n082m01ms1lPT09f5nW73aqurlYymVQ4HNbBwcFv19HS0iKn06nt7W253W6tr6+XpV4A5UWoAVAxXq9XxWJRgUBAktTW1qZgMCiPx6PHx8cv481ms7LZrGKxmO7v7xUOh7Wzs/NpzO7urqLRqDY3N9Xf36/FxUVNTk4qn8//cg0ul0t7e3vKZDJKpVI6PDyUxWL59loBlB8HhQFUxPHxsfr6+nR0dKTe3t5PfQMDA/r4+ND+/r6qqqo+9Xk8HkWjUb2+vmp4eFjd3d1aXl7Wy8uLnp+fZbVatbCwIK/XK0l6f39XT0+P2tvbFY/HvxwUnpubUzKZVC6XU319vQYHBxUKhdTY2PjXngWA70GoAQAAhsD2EwAAMARCDQAAMARCDQAAMARCDQAAMARCDQAAMARCDQAAMARCDQAAMARCDQAAMARCDQAAMARCDQAAMARCDQAAMARCDQAAMIT/AChq3NKctfqTAAAAAElFTkSuQmCC\n" - }, - "metadata": {} - } + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define a function to classify Gaussian-like data\n", + "def classify_gauss_data(num_samples, noise):\n", + " points = []\n", + "\n", + " label_scale = np.linspace(0, 2, 6)\n", + " gaussians = [\n", + " [-4, 2.5, 1],\n", + " [0, 2.5, -1],\n", + " [4, 2.5, 1],\n", + " [-4, -2.5, -1],\n", + " [0, -2.5, 1],\n", + " [4, -2.5, -1]\n", + " ]\n", + "\n", + " def get_label(x, y):\n", + " # Choose the one that is maximum in abs value.\n", + " label = 0\n", + " for cx, cy, sign in gaussians:\n", + " new_label = sign * label_scale[np.argmin([np.linalg.norm([x - cx, y - cy]) for cx, cy, _ in gaussians])]\n", + " if np.abs(new_label) > np.abs(label):\n", + " label = new_label\n", + " return 1 if label > 0 else -1\n", + "\n", + " radius = 6\n", + " for _ in range(num_samples):\n", + " x = np.random.uniform(-radius, radius)\n", + " y = np.random.uniform(-radius, radius)\n", + " noise_x = np.random.uniform(-radius, radius) * noise\n", + " noise_y = np.random.uniform(-radius, radius) * noise\n", + " label = get_label(x + noise_x, y + noise_y)\n", + " points.append({'x': x, 'y': y, 'label': label})\n", + "\n", + " return points\n", + "\n", + "# Define a function to train the network on the new dataset\n", + "def train_on_gauss_data(network, gauss_data, num_epochs, learning_rate, regularization_rate, error_func):\n", + " inputs = np.array([[point['x'], point['y']] for point in gauss_data])\n", + " targets = np.array([point['label'] for point in gauss_data])\n", + "\n", + " for epoch in range(num_epochs):\n", + " for i in range(len(inputs)):\n", + " input_data = inputs[i]\n", + " target = targets[i]\n", + " forward_prop(network, input_data)\n", + " back_prop(network, target, error_func)\n", + " update_weights(network, learning_rate, regularization_rate)\n", + "\n", + "# Define a function to plot the decision boundary\n", + "def plot_decision_boundary_after_training(network, gauss_data):\n", + " h = 0.1\n", + " x_min, x_max = min([point['x'] for point in gauss_data]) - 1, max([point['x'] for point in gauss_data]) + 1\n", + " y_min, y_max = min([point['y'] for point in gauss_data]) - 1, max([point['y'] for point in gauss_data]) + 1\n", + " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", + "\n", + " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", + " Z = Z.reshape(xx.shape)\n", + "\n", + " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", + " plt.scatter([point['x'] for point in gauss_data], [point['y'] for point in gauss_data], c=[point['label'] for point in gauss_data], cmap=plt.cm.RdBu, edgecolors='k')\n", + " plt.title('Decision Boundary After Training')\n", + " plt.xlabel('X-axis')\n", + " plt.ylabel('Y-axis')\n", + " plt.show()\n", + "\n", + "# Example usage\n", + "gauss_data = classify_gauss_data(500, 0.05)\n", + "\n", + "# Create and initialize the neural network\n", + "network_shape_gauss = [2, 5, 1]\n", + "input_ids_gauss = ['input1', 'input2']\n", + "activation = Activations.TANH\n", + "output_activation = Activations.TANH\n", + "regularization = RegularizationFunctions.L2\n", + "network_gauss = build_network(network_shape_gauss, activation, output_activation, regularization, input_ids_gauss)\n", + "\n", + "# Train the network on the Gaussian-like dataset\n", + "num_epochs_gauss = 10000\n", + "learning_rate_gauss = 0.1\n", + "regularization_rate_gauss = 0.001\n", + "error_func_gauss = Errors.SQUARE\n", + "\n", + "train_on_gauss_data(network_gauss, gauss_data, num_epochs_gauss, learning_rate_gauss, regularization_rate_gauss, error_func_gauss)\n", + "\n", + "# Plot the decision boundary after training\n", + "plot_decision_boundary_after_training(network_gauss, gauss_data)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 }, + "id": "a_W_qqssldA3", + "outputId": "5fadf3c9-644e-4a7e-ad7c-60ae5c5587eb" + }, + "outputs": [ { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "def classify_spiral_data(num_samples, noise):\n", - " points = []\n", - " n = num_samples // 2\n", - "\n", - " def gen_spiral(delta_t, label):\n", - " for i in range(n):\n", - " r = i / n * 5\n", - " t = 1.75 * i / n * 2 * np.pi + delta_t\n", - " x = r * np.sin(t) + np.random.uniform(-1, 1) * noise\n", - " y = r * np.cos(t) + np.random.uniform(-1, 1) * noise\n", - " points.append({'x': x, 'y': y, 'label': label})\n", - "\n", - " gen_spiral(0, 1) # Positive examples.\n", - " gen_spiral(np.pi, -1) # Negative examples.\n", - "\n", - " return points\n", - "\n", - "def train_on_spiral_data(network, spiral_data, num_epochs, learning_rate, regularization_rate, error_func):\n", - " inputs = np.array([[point['x'], point['y']] for point in spiral_data])\n", - " targets = np.array([point['label'] for point in spiral_data])\n", - "\n", - " for epoch in range(num_epochs):\n", - " for i in range(len(inputs)):\n", - " input_data = inputs[i]\n", - " target = targets[i]\n", - " forward_prop(network, input_data)\n", - " back_prop(network, target, error_func)\n", - " update_weights(network, learning_rate, regularization_rate)\n", - "\n", - "def plot_decision_boundary_after_training(network, spiral_data):\n", - " h = 0.1\n", - " x_min, x_max = min([point['x'] for point in spiral_data]) - 1, max([point['x'] for point in spiral_data]) + 1\n", - " y_min, y_max = min([point['y'] for point in spiral_data]) - 1, max([point['y'] for point in spiral_data]) + 1\n", - " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", - "\n", - " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", - " Z = Z.reshape(xx.shape)\n", - "\n", - " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", - " plt.scatter([point['x'] for point in spiral_data], [point['y'] for point in spiral_data], c=[point['label'] for point in spiral_data], cmap=plt.cm.RdBu, edgecolors='k')\n", - " plt.title('Decision Boundary After Training')\n", - " plt.xlabel('X-axis')\n", - " plt.ylabel('Y-axis')\n", - " plt.show()\n", - "\n", - "# Example usage\n", - "spiral_data = classify_spiral_data(500, 0.05)\n", - "\n", - "# Create and initialize the neural network\n", - "network_shape_spiral = [2, 5, 5, 5, 1]\n", - "input_ids_spiral = ['input1', 'input2']\n", - "activation = Activations.TANH\n", - "output_activation = Activations.TANH\n", - "regularization = RegularizationFunctions.L2\n", - "network_spiral = build_network(network_shape_spiral, activation, output_activation, regularization, input_ids_spiral)\n", - "\n", - "# Train the network on the spiral dataset\n", - "num_epochs_spiral = 10000\n", - "learning_rate_spiral = 0.1\n", - "regularization_rate_spiral = 0.001\n", - "error_func_spiral = Errors.SQUARE\n", - "\n", - "train_on_spiral_data(network_spiral, spiral_data, num_epochs_spiral, learning_rate_spiral, regularization_rate_spiral, error_func_spiral)\n", - "\n", - "# Plot the decision boundary after training\n", - "plot_decision_boundary_after_training(network_spiral, spiral_data)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 472 - }, - "id": "a_W_qqssldA3", - "outputId": "5fadf3c9-644e-4a7e-ad7c-60ae5c5587eb" - }, - "execution_count": 13, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" } - ] -} \ No newline at end of file + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def classify_spiral_data(num_samples, noise):\n", + " points = []\n", + " n = num_samples // 2\n", + "\n", + " def gen_spiral(delta_t, label):\n", + " for i in range(n):\n", + " r = i / n * 5\n", + " t = 1.75 * i / n * 2 * np.pi + delta_t\n", + " x = r * np.sin(t) + np.random.uniform(-1, 1) * noise\n", + " y = r * np.cos(t) + np.random.uniform(-1, 1) * noise\n", + " points.append({'x': x, 'y': y, 'label': label})\n", + "\n", + " gen_spiral(0, 1) # Positive examples.\n", + " gen_spiral(np.pi, -1) # Negative examples.\n", + "\n", + " return points\n", + "\n", + "def train_on_spiral_data(network, spiral_data, num_epochs, learning_rate, regularization_rate, error_func):\n", + " inputs = np.array([[point['x'], point['y']] for point in spiral_data])\n", + " targets = np.array([point['label'] for point in spiral_data])\n", + "\n", + " for epoch in range(num_epochs):\n", + " for i in range(len(inputs)):\n", + " input_data = inputs[i]\n", + " target = targets[i]\n", + " forward_prop(network, input_data)\n", + " back_prop(network, target, error_func)\n", + " update_weights(network, learning_rate, regularization_rate)\n", + "\n", + "def plot_decision_boundary_after_training(network, spiral_data):\n", + " h = 0.1\n", + " x_min, x_max = min([point['x'] for point in spiral_data]) - 1, max([point['x'] for point in spiral_data]) + 1\n", + " y_min, y_max = min([point['y'] for point in spiral_data]) - 1, max([point['y'] for point in spiral_data]) + 1\n", + " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", + "\n", + " Z = np.array([forward_prop(network, np.array([x, y])) for x, y in zip(xx.ravel(), yy.ravel())])\n", + " Z = Z.reshape(xx.shape)\n", + "\n", + " plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=0.8)\n", + " plt.scatter([point['x'] for point in spiral_data], [point['y'] for point in spiral_data], c=[point['label'] for point in spiral_data], cmap=plt.cm.RdBu, edgecolors='k')\n", + " plt.title('Decision Boundary After Training')\n", + " plt.xlabel('X-axis')\n", + " plt.ylabel('Y-axis')\n", + " plt.show()\n", + "\n", + "# Example usage\n", + "spiral_data = classify_spiral_data(500, 0.05)\n", + "\n", + "# Create and initialize the neural network\n", + "network_shape_spiral = [2, 5, 5, 5, 1]\n", + "input_ids_spiral = ['input1', 'input2']\n", + "activation = Activations.TANH\n", + "output_activation = Activations.TANH\n", + "regularization = RegularizationFunctions.L2\n", + "network_spiral = build_network(network_shape_spiral, activation, output_activation, regularization, input_ids_spiral)\n", + "\n", + "# Train the network on the spiral dataset\n", + "num_epochs_spiral = 10000\n", + "learning_rate_spiral = 0.1\n", + "regularization_rate_spiral = 0.001\n", + "error_func_spiral = Errors.SQUARE\n", + "\n", + "train_on_spiral_data(network_spiral, spiral_data, num_epochs_spiral, learning_rate_spiral, regularization_rate_spiral, error_func_spiral)\n", + "\n", + "# Plot the decision boundary after training\n", + "plot_decision_boundary_after_training(network_spiral, spiral_data)\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python [conda env:base] *", + "language": "python", + "name": "conda-base-py" + }, + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 1e9ad935276109a58840a1fceb4f076506d4cee4 Mon Sep 17 00:00:00 2001 From: souparno majumder Date: Tue, 16 Sep 2025 00:24:48 +0530 Subject: [PATCH 2/2] adding comment for better understanding --- Neural_Network.ipynb | 42 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 40 insertions(+), 2 deletions(-) diff --git a/Neural_Network.ipynb b/Neural_Network.ipynb index 5a94eb2..4e0d2d0 100644 --- a/Neural_Network.ipynb +++ b/Neural_Network.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "metadata": { "id": "ucrKgBCAIPbB" }, @@ -119,11 +119,49 @@ " self.cost = cost\n", "\n", " def _forward_all(self, X: np.ndarray) -> List[np.ndarray]:\n", + " \"\"\"\n", + " Perform a forward pass through all layers.\n", + " \n", + " Args:\n", + " X (np.ndarray): Input batch to the network.\n", + " Example:\n", + " X = [[0.5, -1.2],\n", + " [1.0, 0.3],\n", + " [-0.7, 2.4]] # shape (3, 2)\n", + " \n", + " Returns:\n", + " activations (List[np.ndarray]): A list of arrays containing the input to each\n", + " layer and the final output.\n", + " \n", + " Example (for a 2→5→1 network, batch_size = 3):\n", + " activations[0] = [[ 0.5, -1.2],\n", + " [ 1.0, 0.3],\n", + " [-0.7, 2.4]] # shape (3, 2) raw input\n", + " \n", + " activations[1] = [[-0.34, 0.12, 0.88, -0.45, 0.05],\n", + " [ 0.51, -0.77, 0.21, 0.36, -0.10],\n", + " [-0.13, 0.92, 0.44, -0.81, 0.72]] # shape (3, 5) hidden layer\n", + " \n", + " activations[2] = [[0.46],\n", + " [0.91],\n", + " [0.08]] # shape (3, 1) final output (y_hat)\n", + " \n", + " In other words:\n", + " * activations[0] is the raw network input\n", + " * activations[1:] are outputs of each layer (also inputs to the next layer)\n", + " * activations[-1] is the final prediction\n", + " \n", + " Note:\n", + " The first dimension (3 in this example) is the batch size,\n", + " i.e. the number of input samples processed together\n", + " in one forward pass.\n", + " \"\"\"\n", " activations = [X]\n", " for layer in self.layers:\n", " activations.append(layer.feedforward(activations[-1]))\n", " return activations\n", "\n", + "\n", " def train(self, input_data: np.ndarray, target_data: np.ndarray, epochs: int, learning_rate: float) -> None:\n", " for _ in range(epochs):\n", " acts = self._forward_all(input_data)\n", @@ -159,7 +197,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/",