From c1d1f7bf2154ee4981219390813d61707719219e Mon Sep 17 00:00:00 2001 From: Kaleb Phipps <kaleb.phipps@kit.edu> Date: Fri, 17 Jan 2025 17:02:33 +0100 Subject: [PATCH] add solutions for logit exercise --- 4_logit/solutions/logit_parallel.py | 282 +++++++ 4_logit/solutions/logit_serial.py | 238 ++++++ 4_logit/solutions/solution.ipynb | 1170 ++++++++++++++++++++++++++ 4_logit/solutions/submit_parallel.sh | 23 + 4_logit/solutions/submit_serial.sh | 23 + 5 files changed, 1736 insertions(+) create mode 100644 4_logit/solutions/logit_parallel.py create mode 100644 4_logit/solutions/logit_serial.py create mode 100644 4_logit/solutions/solution.ipynb create mode 100644 4_logit/solutions/submit_parallel.sh create mode 100644 4_logit/solutions/submit_serial.sh diff --git a/4_logit/solutions/logit_parallel.py b/4_logit/solutions/logit_parallel.py new file mode 100644 index 0000000..be0eba4 --- /dev/null +++ b/4_logit/solutions/logit_parallel.py @@ -0,0 +1,282 @@ +""" +Data-parallel logistic regression +""" +import argparse +import time +from typing import Union + +import h5py +from mpi4py import MPI +import numpy as np + +np.random.seed(842424) # Fix random seed for reproducibility. + + +def sigmoid(z: Union[float, np.ndarray]) -> Union[float, np.ndarray]: + """ + Compute sigmoid. + + Parameters + ---------- + z : float + The input for the sigmoid function. + + Returns + ---------- + float + The input's sigmoid function value. + """ + return 1.0 / (1.0 + np.exp(-z)) + + +def lr_predict(w: np.ndarray, x: np.ndarray) -> np.ndarray: + """ + Return prediction of logit model for data x using model weights w. + + Parameters + ---------- + x : np.ndarray[float] + The dataset (after bias trick), shape = [n_samples, n_features +1]. + The 0th input should be 1.0 to take the bias into account in a simple dot product. + w : np.ndarray[float] + The parameters, i.e., weights to be learned (after bias trick), shape = [n_features + 1, ]. + There is one weight for every input dimension plus a bias. + + Returns + ------- + np.ndarray[float] + The predicted activations of the logit model for the input dataset, shape = [n_samples, ], + i.e., the sigmoid of the dot product of the weights and the input data. + """ + return sigmoid(x @ w) + + +def mse(y_est: np.ndarray, y: np.ndarray) -> np.ndarray: + """ + Compute mean-square-error loss. + + Parameters + ---------- + y_est : np.ndarray[float] + The predictions, shape = [n_samples, ]. + y : np.ndarray[float] + The ground-truth labels, shape = [n_samples, ]. + + Returns + ---------- + np.ndarray[float] + MSE loss + """ + return ( + (1.0 / y.shape[0]) * (y - y_est).T @ (y - y_est) + ) # Return MSE loss for considered batch. + + +def lr_loss( + w: np.ndarray, x: np.ndarray, y: np.ndarray +) -> tuple[np.ndarray, np.ndarray]: + """ + Return the loss and the gradient with respect to the weights. + + Parameters + ---------- + w : np.ndarray[float] + The model's weights to be learned, where weights[0] is the bias. + x : np.ndarray[float] + The input data of shape [N x D+1], 0th element of each sample is assumed to be 1 (bias trick). + y : np.ndarray[float] + The ground-truth labels of shape [N,]. + + Returns + ------- + np.ndarray[float] + The scalar mean-square-error loss for the input batch of samples. + np.ndarray[float] + The gradient of the loss with respect to the weights for the batch. + """ + y_est = lr_predict(w, x) # Compute logit prediction for all samples in batch. + loss = mse(y_est, y) # Compute MSE loss over all samples in batch. + # Compute gradient vector of loss w.r.t. weights. + gradient = ( + (-2.0 / y.shape[0]) * ((y - y_est) * y_est * y_est * np.exp(-x @ w)).T @ x + ) + return loss, gradient + + +def lr_train( + w: np.ndarray, + x: np.ndarray, + y: np.ndarray, + comm: MPI.Comm = MPI.COMM_WORLD, + epochs: int = 100, + eta: float = 0.001, + b: int = 10, +) -> tuple[np.ndarray, np.ndarray, np.ndarray, float]: + """ + Train the model, i.e., update the weights following the negative gradient until the model converges. + + Parameters + ---------- + w : np.ndarray[float] + The model weights to be learned, where weights[0] is the bias. + x : np.ndarray[float] + The input data of shape [N x D+1], where each sample's 0th element is assumed to be 1 for bias trick. + y : np.ndarray[float] + The ground-truth labels of shape [N,]. + epochs : int + The number of epochs to be trained. + eta : float + The learning rate. + b : int + The batch size. + + Returns + ------- + np.ndarray[float] + The trained weights. + np.ndarray[float] + The history array with each epoch's loss. + np.ndarray[float] + The history array with each epoch's accuracy. + float + The average training time per epoch. + """ + size, rank = comm.size, comm.rank + + # Apply bias trick. + n_samples = y.shape[0] # Determine number of samples. + n_batches = n_samples // b # Determine number of full batches in data (drop last). + print(f"Rank {rank}/{size}: Data is divided into {n_batches} batches.") + loss_history = np.zeros(epochs) + acc_history = np.zeros(epochs) + training_time_per_epoch = 0.0 # Initiate training time per epoch. + + for epoch in range(epochs): # Loop over epochs. + # The number of epochs is a hyperparameter of gradient descent + # that controls the number of complete passes through the training dataset. + # The batch size is a hyperparameter of gradient descent + # that controls the number of training samples to work through before the + # model’s internal parameters are updated. + + loss_sum = 0.0 # Initiate loss for each epoch. + accuracy = 0.0 # Initiate accuracy for each epoch. + + start = time.perf_counter() + + for nb in range(n_batches): + x_ = x[nb * b : (nb + 1) * b] + y_ = y[nb * b : (nb + 1) * b] + loss, gradient = lr_loss(w, x_, y_) + loss_sum += loss + + corr = np.sum((lr_predict(w, x_) + 0.5).astype(int) == y_) + accuracy += corr + gradient_global = np.zeros_like(gradient) + comm.Allreduce(gradient, gradient_global, op=MPI.SUM) + gradient_global /= size + w -= eta * gradient_global + + end = time.perf_counter() + + # Calculate loss + accuracy after each epoch. + loss_sum /= n_batches + accuracy /= n_samples + accuracy *= 100 + + loss_sum_global = comm.allreduce(loss_sum, op=MPI.SUM) / size + accuracy_global = comm.allreduce(accuracy, op=MPI.SUM) / size + + loss_history[epoch] = loss_sum_global + acc_history[epoch] = accuracy_global + training_time_per_epoch += end - start + + # Print every tenth epoch the training status. + if rank == 0: + if epoch % 10 == 0: + print( + f"Epoch: {epoch}, Loss: {loss_sum_global}, Accuracy: {accuracy_global}" + ) + training_time_per_epoch /= epochs + training_time_per_epoch_global = ( + comm.allreduce(training_time_per_epoch, op=MPI.SUM) / size + ) + return w, loss_history, acc_history, training_time_per_epoch_global + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(prog="Logit") + parser.add_argument( + "--epochs", + type=int, + default=100, + help="The number of epochs to train.", + ) + + parser.add_argument( + "--batch_size", + type=int, + default=10, + help="The batch size.", + ) + + args = parser.parse_args() + comm = MPI.COMM_WORLD # Set up communicator. + size, rank = comm.size, comm.rank + + if rank == 0: + print( + "################################\n" + "# Parallel Logistic Regression #\n" + "################################" + ) + print( + f"We train for {args.epochs} epochs with an effective batch size of {args.batch_size}." + ) + + path = "/pfs/work7/workspace/scratch/ku4408-VL-ScalableAI/data/logit_data_n100000_d2.h5" + + with h5py.File(path, "r") as f: # Load data in sample-parallel fashion. + chunk = int(f["data"].shape[0] / size) + if rank == size - 1: + data = np.array(f["data"][rank * chunk :]) + labels = np.array(f["labels"][rank * chunk :]) + else: + data = np.array(f["data"][rank * chunk : (rank + 1) * chunk]) + labels = np.array(f["labels"][rank * chunk : (rank + 1) * chunk]) + + print( + f"Rank {rank}/{size}: Local data has {data.shape[0]} samples with {data.shape[1]} features and " + f"{labels.shape[0]} labels.\n0th elements are: {data[0]}\n{labels[0]}" + ) + + # Bias trick: Prepend data with 1's for additional bias dimension. + ones = np.ones( + ( + data.shape[0], + 1, + ) + ) + data_bt = np.hstack([ones, data]) + + # Initialize model parameters randomly. + # After bias trick, weights have shape [n_features+1, ] + if rank == 0: + weights = np.random.rand(data_bt.shape[1]) + else: + weights = np.zeros(data_bt.shape[1]) + + # Broadcast weights from root to other processors. + comm.Bcast(weights, root=0) + + b_local = args.batch_size // size # Calculate local batch size. + print(f"Rank {rank}/{size}: Local batch size is {b_local}.") + # Train model. + (weights, loss_history, acc_history, training_time_per_epoch) = lr_train( + weights, data_bt, labels, b=b_local, epochs=args.epochs + ) + + if rank == 0: + print( + f"Final loss: {loss_history[-1]}, final accuracy: {acc_history[-1]}\n" + f"Average training time per epoch: {training_time_per_epoch} s" + ) diff --git a/4_logit/solutions/logit_serial.py b/4_logit/solutions/logit_serial.py new file mode 100644 index 0000000..012eea1 --- /dev/null +++ b/4_logit/solutions/logit_serial.py @@ -0,0 +1,238 @@ +import argparse +import time +from typing import Union, Tuple + +import h5py +import numpy as np + + +np.random.seed(842424) # Fix random seed for reproducibility. + + +def sigmoid(z: Union[float, np.ndarray]) -> Union[float, np.ndarray]: + """ + Compute sigmoid. + + Parameters + ---------- + z : float + The input for the sigmoid function. + + Returns + ---------- + float + The input's sigmoid function value. + """ + return 1.0 / (1.0 + np.exp(-z)) + + +def lr_predict(w: np.ndarray, x: np.ndarray) -> np.ndarray: + """ + Return prediction of logit model for data x using model weights w. + + Parameters + ---------- + x : np.ndarray[float] + The dataset (after bias trick), shape = [n_samples, n_features +1]. + The 0th input should be 1.0 to take the bias into account in a simple dot product. + w : np.ndarray[float] + The parameters, i.e., weights to be learned (after bias trick), shape = [n_features + 1, ]. + There is one weight for every input dimension plus a bias. + + Returns + ------- + np.ndarray[float] + The predicted activations of the logit model for the input dataset, shape = [n_samples, ], + i.e., the sigmoid of the dot product of the weights and the input data. + """ + return sigmoid(x @ w) + + +def mse(y_est: np.ndarray, y: np.ndarray) -> np.ndarray: + """ + Compute mean-square-error loss. + + Parameters + ---------- + y_est : np.ndarray[float] + The predictions, shape = [n_samples, ]. + y : np.ndarray[float] + The ground-truth labels, shape = [n_samples, ]. + + Returns + ---------- + np.ndarray[float] + MSE loss + """ + return ( + (1.0 / y.shape[0]) * (y - y_est).T @ (y - y_est) + ) # Return MSE loss for considered batch. + + +def lr_loss( + w: np.ndarray, x: np.ndarray, y: np.ndarray +) -> Tuple[np.ndarray, np.ndarray]: + """ + Return the loss and the gradient with respect to the weights. + + Parameters + ---------- + w : np.ndarray[float] + The model's weights to be learned, where weights[0] is the bias. + x : np.ndarray[float] + The input data of shape [N x D+1], 0th element of each sample is assumed to be 1 (bias trick). + y : np.ndarray[float] + The ground-truth labels of shape [N,]. + + Returns + ------- + np.ndarray[float] + The scalar mean-square-error loss for the input batch of samples. + np.ndarray[float] + The gradient of the loss with respect to the weights for the batch. + """ + y_est = lr_predict(w, x) # Compute logit prediction for all samples in batch. + loss = mse(y_est, y) # Compute MSE loss over all samples in batch. + # Compute gradient vector of loss w.r.t. weights. + gradient = ( + (-2.0 / y.shape[0]) * ((y - y_est) * y_est * y_est * np.exp(-x @ w)).T @ x + ) + return loss, gradient + + +def lr_train( + w: np.ndarray, + x: np.ndarray, + y: np.ndarray, + epochs: int = 100, + eta: float = 0.001, + b: int = 10, +) -> Tuple[np.ndarray, np.ndarray, np.ndarray, float]: + """ + Train the model, i.e., update the weights following the negative gradient until the model converges. + + Parameters + ---------- + w : np.ndarray[float] + The model weights to be learned, where weights[0] is the bias. + x : np.ndarray[float] + The input data of shape [N x D+1], where each sample's 0th element is assumed to be 1 for bias trick. + y : np.ndarray[float] + The ground-truth labels of shape [N,]. + epochs : int + The number of epochs to be trained. + eta : float + The learning rate. + b : int + The batch size. + + Returns + ------- + np.ndarray[float] + The trained weights. + np.ndarray[float] + The history array with each epoch's loss. + np.ndarray[float] + The history array with each epoch's accuracy. + float + The average training time per epoch. + """ + n_samples = y.shape[0] # Determine number of samples in batch. + n_batches = n_samples // b # Determine number of full batches in data (drop last). + print(f"Data is divided into {n_batches} batches.") + loss_history = np.zeros(epochs) + acc_history = np.zeros(epochs) + training_time_per_epoch = 0.0 # Initiate training time per epoch. + + for epoch in range(epochs): # Loop over epochs. + # The number of epochs is a hyperparameter of gradient descent + # that controls the number of complete passes through the training dataset. + # The batch size is a hyperparameter of gradient descent + # that controls the number of training samples to work through before the + # model’s internal parameters are updated. + loss_sum = 0.0 # Initiate loss for each epoch. + accuracy = 0.0 # Initiate accuracy for each epoch. + + start = time.perf_counter() # Start timer. + + for nb in range(n_batches): + x_ = x[nb * b : (nb + 1) * b] + y_ = y[nb * b : (nb + 1) * b] + loss, gradient = lr_loss(w, x_, y_) + loss_sum += loss + + corr = np.sum((lr_predict(w, x_) + 0.5).astype(int) == y_) + accuracy += corr + w -= eta * gradient + + end = time.perf_counter() # Stop timer. + + # Calculate loss + accuracy after each epoch. + loss_sum /= n_batches + accuracy /= n_samples + accuracy *= 100 + + # Append loss + accuracy of current epoch to history arrays. + loss_history[epoch] = loss_sum + acc_history[epoch] = accuracy + training_time_per_epoch += end - start + + # Print every tenth epoch the training status. + if epochs < 100: + mod = 5 + elif 100 <= epochs < 1000: + mod = 10 + elif 1000 <= epochs < 10000: + mod = 100 + elif 10000 <= epochs < 100000: + mod = 1000 + else: + mod = 10000 + if epoch % mod == 0: + print(f"Epoch: {epoch}, Loss: {loss_sum}, Accuracy: {accuracy}") + training_time_per_epoch /= epochs + return w, loss_history, acc_history, training_time_per_epoch + + +if __name__ == "__main__": + path = "/pfs/work7/workspace/scratch/ku4408-VL-ScalableAI/data/logit_data_n10000_d2.h5" + parser = argparse.ArgumentParser(prog="Logit") + parser.add_argument( + "--epochs", + type=int, + default=100, + help="The number of epochs to train.", + ) + + parser.add_argument( + "--batch_size", + type=int, + default=10, + help="The batch size.", + ) + + args = parser.parse_args() + + with h5py.File(path, "r") as f: + data = np.array(f["data"]) + labels = np.array(f["labels"]) + + print( + f"We have {data.shape[0]} samples with {data.shape[1]} features and {labels.shape[0]} labels." + ) + + # Bias trick: Prepend data with 1's for additional bias dimension. + ones = np.ones( + ( + data.shape[0], + 1, + ) + ) + data_bt = np.hstack([ones, data]) + weights = np.random.rand(data_bt.shape[1]) # Initialize model parameters randomly. + weights, loss_history, acc_history, time_per_epoch = lr_train( + weights, data_bt, labels, epochs=args.epochs, b=args.batch_size + ) + print(f"Final loss is {loss_history[-1]}, final accuracy is {acc_history[-1]}.") + print(f"Training time per epoch is {time_per_epoch} s.") + diff --git a/4_logit/solutions/solution.ipynb b/4_logit/solutions/solution.ipynb new file mode 100644 index 0000000..4099d4e --- /dev/null +++ b/4_logit/solutions/solution.ipynb @@ -0,0 +1,1170 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9d10dea7", + "metadata": {}, + "source": [ + "# Skalierbare Methoden der Künstlichen Intelligenz\n", + "Dr. Charlotte Debus (<charlotte.debus@kit.edu>) \n", + "Dr. Markus Götz (<markus.goetz@kit.edu>) \n", + "Dr. Marie Weiel (<marie.weiel@kit.edu>) \n", + "Dr. Kaleb Phipps (<kaleb.phipps@kit.edu>) \n", + "\n", + "## Übung 4 am 21.01.25: Logistische Regression\n", + "In der vierten Übung beschäftigen wir uns mit der logistischen Regression und ihrer Parallelisierung. Die logistische Regression ist ein einfacher Machine-Learning-Algorithmus zur binären Klassifizierung. Er berechnet die gewichtete Summe seiner Eingaben und gibt eine Aktivierung aus, die die gewichtete Summe in das feste Intervall $\\left(0,1\\right)$ abbildet. Auf diese Weise können wir die Ausgabe als Wahrscheinlichkeit für die Zugehörigkeit zu einer Klasse interpretieren. Im Falle mehrerer Klassen trainiert man einfach mehrere Modelle. In dieser Übung werden wir die logistische Regression verwenden, um zu entscheiden, zu welcher von zwei Verteilungen ein Datenpunkt gehört.\n", + "\n", + "### Aufgabe 1\n", + "Wie in der Vorlesung vom 05.12.24 besprochen kommt in der logistischen Regression zur numerischen Minimierung der Kostenfunktion $L$ und damit zur Bestimmung der Modellparameter $W$ typischerweise das iterative Gradientenabstiegsverfahren zum Einsatz:\n", + "\n", + "$$W_{i+1}=W_i-\\eta\\nabla_W L$$\n", + "\n", + "In dieser Update-Regel bezeichnet $\\eta$ die sogenannte Lernrate.\n", + "Dieses Verfahren erfordert die Berechnung des Gradienten der Kostenfunktion bezüglich der Modellparameter. Der Gradient $\\nabla_W L$ entspricht gerade dem Vektor mit den Komponenten $\\frac{\\partial L}{\\partial W_j}$. \n", + "Berechnen Sie den Gradienten der Mean-Square-Error-Kostenfunktion\n", + "\n", + "$$L\\left(Y,\\hat{Y}\\right)=MSE\\left(Y,\\hat{Y}\\right)=\\frac{1}{N}\\left(Y-\\hat{Y}\\right)^T\\left(Y-\\hat{Y}\\right)=\\frac{1}{N}\\sum_{i=1}^N\\left(y_i-\\hat{y}_i\\right)^2$$\n", + "\n", + "für die logistische Regression mit\n", + "\n", + "$$\\hat{Y}=sig\\left(XW\\right)=\\frac{1}{1+e^{-XW}}$$\n", + "\n", + "per Hand. Betrachten Sie hierzu einen Datensatz $\\lbrace\\text{Samples, Labels}\\rbrace=\\lbrace X, Y\\rbrace$ bestehend aus $N$ Samples mit jeweils $D$ Features, d.h. für die Daten $X\\in\\mathbb{R}^{N\\times\\left(D+1\\right)}$, die Labels $Y\\in\\mathbb{R}^N$, die Modellparameter $W\\in\\mathbb{R}^{D+1}$ sowie die Modellvorhersage $\\hat{Y}\\in\\mathbb{R}^N$ gilt (nach Anwendung des Bias Tricks):\n", + "\n", + "$$X=\\begin{pmatrix}\n", + "1 & x_{11} & x_{12} & \\dots & x_{1D}\\\\\n", + "1 & x_{21} & x_{22} & \\dots & x_{2D}\\\\\n", + "\\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n", + "1 & x_{N1} & x_{N2} & \\dots & x_{ND}\n", + "\\end{pmatrix},\\quad\n", + "Y=\\left(y_1, y_2, \\dots, y_N\\right)^T,\\quad\n", + "W=\\left(w_0, w_1,\\dots,w_D\\right)^T,\\quad\n", + "\\hat{Y}=sig\\left(XW\\right)=\\left(\\hat{y}_1, \\hat{y}_2,\\dots, \\hat{y}_N\\right)^T$$\n", + "\n", + "Hierbei entspricht $w_0$ gerade dem Bias.\n", + "\n", + "#### Lösung\n", + "\n", + "$$\\begin{align} \n", + "\\frac{\\partial MSE}{\\partial w_j}&=\\frac{\\partial}{\\partial w_j}\\left(\\frac{1}{N}\\sum_{i=1}^N\\left(y_i-\\hat{y}_i\\right)^2\\right) \\text{ mit }\\hat{y}_i = sig\\left(X_i\\cdot W\\right)=\\frac{1}{1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}\\\\\n", + "&= -\\frac{2}{N}\\sum_{i=1}^N\\left(y_i-\\hat{y}_i\\right)\\frac{\\partial \\hat{y}_i}{\\partial w_j}\\\\\n", + "\\frac{\\partial \\hat{y}_i}{\\partial w_j} &= \\frac{\\partial}{\\partial w_j}\\frac{1}{1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}= \\frac{\\partial}{\\partial w_j}\\left(1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)\\right)^{-1}\\\\\n", + "&=-\\left(1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)\\right)^{-2}\\cdot \\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right) \\cdot \\left(-x_{ij}\\right)\\\\\n", + "&= \\frac{\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}{\\left(1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)\\right)^2} \\cdot x_{ij}=\\hat{y}_i^2\\cdot \\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)\\cdot x_{ij}\\\\\n", + "&= \\frac{1}{1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}\\cdot \\frac{\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}{1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}\\cdot x_{ij}\\\\\n", + "&= \\hat{y}_i\\cdot \\frac{\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)+1-1}{1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}\\cdot x_{ij}\\\\\n", + "&= \\hat{y}_i\\cdot \\left(\\frac{1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}{1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}-\\frac{1}{1+\\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)}\\right)\\cdot x_{ij}\\\\\n", + "&= \\hat{y}_i\\cdot\\left(1-\\hat{y}_i\\right)\\cdot x_{ij}\\\\\n", + "\\Rightarrow\\frac{\\partial MSE}{\\partial w_j}&=-\\frac{2}{N}\\sum_{i=1}^N\\left(y_i-\\hat{y}_i\\right)\\cdot \\hat{y}_i\\cdot\\left(1-\\hat{y}_i\\right)\\cdot x_{ij}\\\\\n", + "&= -\\frac{2}{N}\\sum_{i=1}^N\\left(y_i-\\hat{y}_i\\right)\\cdot\\hat{y}_i^2\\cdot \\mathrm{exp}\\left(-\\sum_{j=0}^D w_j x_{ij}\\right)\\cdot x_{ij}\n", + "\\end{align}$$\n", + "\n", + "### Aufgabe 2\n", + "#### Teil a\n", + "Wir betrachten zunächst eine serielle Implementierung der logistischen Regression zur binären Klassifikation eines künstlich erstellten Datensatzes. Der Datensatz besteht zu gleichen Teilen aus Samples, die aus zwei verschiedenen Gaußverteilungen gezogen und anschließend durchmischt wurden. Untenstehend finden Sie eine beispielhafte Funktion zur Generierung solcher Daten, eine veranschaulichende Plotfunktion sowie den seriellen Code zur lokalen Ausführung im Notebook.\n", + "\n", + "Wie Sie der Funktionssignatur entnehmen können, hat der Gradient-Descent-Trainingsalgorithmus `lr_train` drei Hyperparameter:\n", + "\n", + "- Die Lernrate `eta` legt die Schrittgröße des Gradientenabstiegs fest.\n", + "- Die Anzahl der Epochen `epochs` legt die Anzahl der vollständigen Durchläufe durch den Trainingsdatensatz fest.\n", + "- Die Batchgröße `b` legt die Anzahl der Samples des Trainingsdatensatzes fest, die durchlaufen werden, bevor die Parameter des Modells innerhalb einer Epoche aktualisiert werden.\n", + "\n", + "Analysieren Sie das Trainingsverhalten des Algorithmus für Daten bestehend aus 10 000 Samples mit je 2 Features für verschiedene Kombinationen von `epochs` und `b`. Was fällt Ihnen auf?\n", + "\n", + "|`b`| 1 | 10 | 10 | 100 | 100 | 2000 | 10,000 | 10,000 | \n", + "|-----|----|----|-----|-----|------|-------|-------|--------|\n", + "| `epochs` | 20 | 20 | 100 | 100 | 1000 | 10,000 | 10,000 | 100,000 |" + ] + }, + { + "cell_type": "code", + "id": "596d6bfb", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-18T11:33:27.887174Z", + "start_time": "2024-12-18T11:33:27.502037Z" + } + }, + "source": [ + "from typing import Tuple, Union\n", + "import time\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "np.random.seed(9) # Fix random seed for reproducibility.\n", + "\n", + "\n", + "def generate_data(\n", + " n_samples: int = 10000, input_dim: int = 2\n", + ") -> Tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"\n", + " Generate artificial data, i.e., coordinates distributed in 2D space by two different Gaussian distributions\n", + " and their corresponding labels.\n", + "\n", + " Parameters\n", + " ----------\n", + " n_samples : int\n", + " The overall number of samples in the dataset.\n", + " input_dim : int\n", + " The number of features, i.e., dimension, of input samples.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray[float]\n", + " The samples.\n", + " np.ndarray[float]\n", + " The corresponding labels.\n", + " \"\"\"\n", + " half_samples = n_samples // 2 # Generate two equally balanced classes.\n", + "\n", + " # Generate the blobs.\n", + " x1 = np.random.normal(1.0, 0.25, size=(half_samples, input_dim))\n", + " x2 = np.random.normal(2.0, 0.30, size=(half_samples, input_dim))\n", + "\n", + " # Create matching labels.\n", + " y1 = np.zeros(half_samples)\n", + " y2 = np.ones(half_samples)\n", + "\n", + " data = np.concatenate((x1, x2))\n", + " labels = np.concatenate((y1, y2))\n", + "\n", + " # Shuffle data to improve convergence behavior and more closely emulate real data.\n", + " shuffled_indices = np.arange(n_samples)\n", + " np.random.shuffle(shuffled_indices)\n", + "\n", + " return data[shuffled_indices], labels[shuffled_indices]\n", + "\n", + "\n", + "data, labels = generate_data()\n", + "print(\n", + " f\"We have {data.shape[0]} samples with {data.shape[1]} features and {labels.shape[0]} labels.\"\n", + ")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "We have 10000 samples with 2 features and 10000 labels.\n" + ] + } + ], + "execution_count": 1 + }, + { + "cell_type": "code", + "id": "1d71c18b", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-18T11:33:46.893688Z", + "start_time": "2024-12-18T11:33:46.772315Z" + } + }, + "source": [ + "def plot_data(data: np.ndarray, labels: np.ndarray, title: str) -> None:\n", + " \"\"\"\n", + " Plot data colored by labels.\n", + "\n", + " Parameters\n", + " ----------\n", + " data : np.ndarray[float]\n", + " The data to plot.\n", + " labels : np.ndarray[float]\n", + " The corresponding labels.\n", + " title : str\n", + " The plot title.\n", + " \"\"\"\n", + " plt.xlabel(\"Feature 1\", fontweight=\"bold\")\n", + " plt.ylabel(\"Feature 2\", fontweight=\"bold\")\n", + " plt.grid()\n", + " plt.scatter(data[:, 0], data[:, 1], c=labels, vmin=0.0, vmax=1.0)\n", + " plt.title(title, fontweight=\"bold\")\n", + " plt.show()\n", + "\n", + "\n", + "plot_data(data, labels, \"Labeled training data\")" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 4 + }, + { + "cell_type": "code", + "id": "d9549e82", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-18T11:33:51.028929Z", + "start_time": "2024-12-18T11:33:51.022077Z" + } + }, + "source": [ + "def sigmoid(z: Union[float, np.ndarray]) -> Union[float, np.ndarray]:\n", + " \"\"\"\n", + " Compute sigmoid.\n", + "\n", + " Parameters\n", + " ----------\n", + " z : Union[float, np.ndarray]\n", + " The input for the sigmoid function.\n", + "\n", + " Returns\n", + " ----------\n", + " Union[float, np.ndarray]\n", + " The input's sigmoid function value.\n", + " \"\"\"\n", + " return 1.0 / (1.0 + np.exp(-z))\n", + "\n", + "\n", + "def lr_predict(w: np.ndarray, x: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " Return prediction of logit model for data x using model weights w.\n", + "\n", + " Parameters\n", + " ----------\n", + " w : np.ndarray[float]\n", + " The parameters, i.e., weights to be learned (after bias trick), shape = [n_features + 1, ].\n", + " There is one weight for every input dimension plus a bias.\n", + " x : np.ndarray[float]\n", + " The dataset (after bias trick), shape = [n_samples, n_features +1].\n", + " The 0th input should be 1.0 to take the bias into account in a simple dot product.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray[float]\n", + " The predicted activations of the logit model for the input dataset, shape = [n_samples, ],\n", + " i.e., the sigmoid of the dot product of the weights and the input data.\n", + " \"\"\"\n", + " return sigmoid(x @ w)\n", + "\n", + "\n", + "def mse(y_est: np.ndarray, y: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " Compute mean-square-error loss.\n", + "\n", + " Parameters\n", + " ----------\n", + " y_est : np.ndarray[float]\n", + " The predictions, shape = [n_samples, ].\n", + " y : np.ndarray[float]\n", + " The ground-truth labels, shape = [n_samples, ].\n", + "\n", + " Returns\n", + " ----------\n", + " np.ndarray[float]\n", + " MSE loss\n", + " \"\"\"\n", + " return (\n", + " (1.0 / y.shape[0]) * (y - y_est).T @ (y - y_est)\n", + " ) # Return MSE loss for considered batch.\n", + "\n", + "\n", + "def lr_loss(\n", + " w: np.ndarray, x: np.ndarray, y: np.ndarray\n", + ") -> Tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"\n", + " Return the loss and the gradient with respect to the weights.\n", + "\n", + " Parameters\n", + " ----------\n", + " w : np.ndarray[float]\n", + " The model's weights to be learned, where weights[0] is the bias.\n", + " x : np.ndarray[float]\n", + " The input data of shape [N x D+1], 0th element of each sample is assumed to be 1 (bias trick).\n", + " y : np.ndarray[float]\n", + " The ground-truth labels of shape [N,].\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray[float]\n", + " The scalar mean-square-error loss for the input batch of samples.\n", + " np.ndarray[float]\n", + " The gradient of the loss with respect to the weights for the batch.\n", + " \"\"\"\n", + " y_est = lr_predict(w, x) # Compute logit prediction for all samples in batch.\n", + " loss = mse(y_est, y) # Compute MSE loss over all samples in batch.\n", + " # Compute gradient vector of loss w.r.t. weights.\n", + " gradient = (\n", + " (-2.0 / y.shape[0]) * ((y - y_est) * y_est * y_est * np.exp(-x @ w)).T @ x\n", + " )\n", + " return loss, gradient\n", + "\n", + "\n", + "def lr_train(\n", + " w: np.ndarray,\n", + " x: np.ndarray,\n", + " y: np.ndarray,\n", + " epochs: int = 100,\n", + " eta: float = 0.001,\n", + " b: int = 10,\n", + ") -> Tuple[np.ndarray, np.ndarray, np.ndarray, float]:\n", + " \"\"\"\n", + " Train the model, i.e., update the weights following the negative gradient until the model converges.\n", + "\n", + " Parameters\n", + " ----------\n", + " w : np.ndarray[float]\n", + " The model weights to be learned, where weights[0] is the bias.\n", + " x : np.ndarray[float]\n", + " The input data of shape [N x D+1], where each sample's 0th element is assumed to be 1 for bias trick.\n", + " y : np.ndarray[float]\n", + " The ground-truth labels of shape [N,].\n", + " epochs : int\n", + " The number of epochs to be trained.\n", + " eta : float\n", + " The learning rate.\n", + " b : int\n", + " The batch size.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray[float]\n", + " The trained weights.\n", + " np.ndarray[float]\n", + " The history array with each epoch's loss.\n", + " np.ndarray[float]\n", + " The history array with each epoch's accuracy.\n", + " float\n", + " The average training time per epoch.\n", + " \"\"\"\n", + " n_samples = y.shape[0] # Determine number of samples in batch.\n", + " n_batches = n_samples // b # Determine number of full batches in data (drop last).\n", + " print(f\"Data is divided into {n_batches} batches.\")\n", + " loss_history = np.zeros(epochs)\n", + " acc_history = np.zeros(epochs)\n", + " training_time_per_epoch = 0.0 # Initiate training time per epoch.\n", + "\n", + " for epoch in range(epochs): # Loop over epochs.\n", + " # The number of epochs is a hyperparameter of gradient descent\n", + " # that controls the number of complete passes through the training dataset.\n", + " # The batch size is a hyperparameter of gradient descent\n", + " # that controls the number of training samples to work through before the\n", + " # model’s internal parameters are updated.\n", + " loss_sum = 0.0 # Initiate loss for each epoch.\n", + " accuracy = 0.0 # Initiate accuracy for each epoch.\n", + "\n", + " start = time.perf_counter() # Start timer.\n", + "\n", + " for nb in range(n_batches):\n", + " x_ = x[nb * b : (nb + 1) * b]\n", + " y_ = y[nb * b : (nb + 1) * b]\n", + " loss, gradient = lr_loss(w, x_, y_)\n", + " loss_sum += loss\n", + " \n", + " # Calculate how many values are correct - due to integer rounding we need to push the value above 1.\n", + " corr = np.sum((lr_predict(w, x_) + 0.5).astype(int) == y_)\n", + " accuracy += corr \n", + " w -= eta * gradient\n", + "\n", + " end = time.perf_counter() # Stop timer.\n", + "\n", + " # Calculate loss + accuracy after each epoch.\n", + " loss_sum /= n_batches\n", + " accuracy /= n_samples\n", + " accuracy *= 100\n", + "\n", + " # Append loss + accuracy of current epoch to history arrays.\n", + " loss_history[epoch] = loss_sum\n", + " acc_history[epoch] = accuracy\n", + " training_time_per_epoch += end - start\n", + "\n", + " # Print the training status every x-th epoch.\n", + " if epochs < 100:\n", + " mod = 5\n", + " elif 100 <= epochs < 1000:\n", + " mod = 10\n", + " elif 1000 <= epochs < 10000:\n", + " mod = 100\n", + " elif 10000 <= epochs < 100000:\n", + " mod = 1000\n", + " else:\n", + " mod = 10000\n", + " if epoch % mod == 0:\n", + " print(f\"Epoch: {epoch}, Loss: {loss_sum}, Accuracy: {accuracy}\")\n", + "\n", + " training_time_per_epoch /= epochs\n", + " return w, loss_history, acc_history, training_time_per_epoch" + ], + "outputs": [], + "execution_count": 5 + }, + { + "cell_type": "code", + "id": "c2a6309d", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-18T11:33:58.918856Z", + "start_time": "2024-12-18T11:33:58.915782Z" + } + }, + "source": [ + "def plot_progress(\n", + " loss: np.ndarray, accuracy: np.ndarray, title=\"Training progress\"\n", + ") -> None:\n", + " \"\"\"\n", + " Plot training progress in terms of loss and accuracy over number of epochs.\n", + "\n", + " Parameters\n", + " ----------\n", + " loss : np.ndarray\n", + " The loss history as function of the number of epochs trained.\n", + " accuracy : np.ndarray\n", + " The accuracy history as function of the number of epochs trained.\n", + " \"\"\"\n", + " epochs = np.arange(loss.shape[0]) # Get number of epochs.\n", + " plt.subplots(1, 2, figsize=(7, 3))\n", + " plt.suptitle(title, fontweight=\"bold\")\n", + " plt.subplot(121)\n", + " plt.xlabel(\"Epoch\", fontweight=\"bold\")\n", + " plt.ylabel(\"Loss\", fontweight=\"bold\")\n", + " plt.grid()\n", + " plt.plot(\n", + " epochs, loss, color=\"k\"\n", + " ) # Plot loss as function of number of epochs trained.\n", + " plt.subplot(122)\n", + " plt.xlabel(\"Epoch\", fontweight=\"bold\")\n", + " plt.ylabel(\"Accuracy / %\", fontweight=\"bold\")\n", + " plt.grid()\n", + " plt.plot(\n", + " epochs, accuracy, color=\"k\"\n", + " ) # Plot accuracy as function of number of epochs trained.\n", + " plt.tight_layout()\n", + " plt.show()" + ], + "outputs": [], + "execution_count": 6 + }, + { + "cell_type": "code", + "id": "75702c70", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-18T11:34:34.729841Z", + "start_time": "2024-12-18T11:34:04.079882Z" + } + }, + "source": [ + "# Bias trick: Prepend data with 1's for additional bias dimension.\n", + "ones = np.ones(\n", + " (\n", + " data.shape[0],\n", + " 1,\n", + " )\n", + ")\n", + "data_bt = np.hstack([ones, data])\n", + "\n", + "weights = np.random.rand(data_bt.shape[1]) # Initialize model parameters randomly.\n", + "\n", + "# Before training.\n", + "plot_data(\n", + " data, lr_predict(weights, data_bt), \"Continuous predictions of untrained model\"\n", + ")\n", + "plot_data(\n", + " data,\n", + " np.around(lr_predict(weights, data_bt)),\n", + " \"Mapped predictions of untrained model\",\n", + ")\n", + "\n", + "batch_sizes = [1, 10, 10, 100, 100, 2000, 10000, 10000]\n", + "epochs = [20, 20, 100, 100, 1000, 10000, 10000, 100000]\n", + "\n", + "for b, e in zip(batch_sizes, epochs):\n", + " # Train model.\n", + " print(\n", + " \"##############################################################\\n\"\n", + " f\"Train for {e} epochs with a batch size of {b}.\"\n", + " )\n", + " weights = np.random.rand(data_bt.shape[1]) # Initialize model parameters randomly.\n", + " weights, loss_history, acc_history, training_time_per_epoch = lr_train(\n", + " weights, data_bt, labels, b=b, epochs=e\n", + " )\n", + " print(\n", + " f\"Final loss: {loss_history[-1]}, final accuracy: {acc_history[-1]}\\n\"\n", + " f\"Training time per epoch: {training_time_per_epoch} s\"\n", + " )\n", + " # After training.\n", + " plot_progress(loss_history, acc_history)\n", + " plot_data(\n", + " data, lr_predict(weights, data_bt), \"Continuous predictions of trained model\"\n", + " )\n", + " plot_data(\n", + " data,\n", + " np.around(lr_predict(weights, data_bt)),\n", + " \"Mapped predictions of trained model\",\n", + " )" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##############################################################\n", + "Train for 20 epochs with a batch size of 1.\n", + "Data is divided into 10000 batches.\n", + "Epoch: 0, Loss: 0.2260625901949327, Accuracy: 50.339999999999996\n", + "Epoch: 5, Loss: 0.10126615648638317, Accuracy: 98.81\n", + "Epoch: 10, Loss: 0.06373035136464925, Accuracy: 99.41\n", + "Epoch: 15, Loss: 0.04758066056691857, Accuracy: 99.49\n", + "Final loss: 0.040149561603253885, final accuracy: 99.52\n", + "Training time per epoch: 0.1109059729000137 s\n" + ] + }, + { + "data": { + "text/plain": [ + "<Figure size 700x300 with 2 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##############################################################\n", + "Train for 20 epochs with a batch size of 10.\n", + "Data is divided into 1000 batches.\n", + "Epoch: 0, Loss: 0.2960632778598177, Accuracy: 50.0\n", + "Epoch: 5, Loss: 0.20672411491726175, Accuracy: 51.27\n", + "Epoch: 10, Loss: 0.1880221161961136, Accuracy: 65.82000000000001\n", + "Epoch: 15, Loss: 0.17163400700446385, Accuracy: 81.96\n", + "Final loss: 0.15997752122320555, final accuracy: 89.14999999999999\n", + "Training time per epoch: 0.010905652100018415 s\n" + ] + }, + { + "data": { + "text/plain": [ + "<Figure size 700x300 with 2 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##############################################################\n", + "Train for 100 epochs with a batch size of 10.\n", + "Data is divided into 1000 batches.\n", + "Epoch: 0, Loss: 0.24130876217267297, Accuracy: 50.0\n", + "Epoch: 10, Loss: 0.19442600066971194, Accuracy: 60.42999999999999\n", + "Epoch: 20, Loss: 0.16221760937063368, Accuracy: 87.87\n", + "Epoch: 30, Loss: 0.1374967345270963, Accuracy: 95.85000000000001\n", + "Epoch: 40, Loss: 0.1186023957955331, Accuracy: 98.0\n", + "Epoch: 50, Loss: 0.10401428648494582, Accuracy: 98.71\n", + "Epoch: 60, Loss: 0.09256869201437411, Accuracy: 99.03\n", + "Epoch: 70, Loss: 0.08342892358584143, Accuracy: 99.16\n", + "Epoch: 80, Loss: 0.07600388931502111, Accuracy: 99.3\n", + "Epoch: 90, Loss: 0.06987505581101547, Accuracy: 99.33\n", + "Final loss: 0.06521786004561365, final accuracy: 99.4\n", + "Training time per epoch: 0.010976783400001295 s\n" + ] + }, + { + "data": { + "text/plain": [ + "<Figure size 700x300 with 2 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##############################################################\n", + "Train for 100 epochs with a batch size of 100.\n", + "Data is divided into 100 batches.\n", + "Epoch: 0, Loss: 0.25558917232973966, Accuracy: 50.0\n", + "Epoch: 10, Loss: 0.23348976967677154, Accuracy: 50.0\n", + "Epoch: 20, Loss: 0.22306995744898306, Accuracy: 50.0\n", + "Epoch: 30, Loss: 0.21728555755667622, Accuracy: 50.019999999999996\n", + "Epoch: 40, Loss: 0.21282188853320352, Accuracy: 50.129999999999995\n", + "Epoch: 50, Loss: 0.20872944994348275, Accuracy: 50.73\n", + "Epoch: 60, Loss: 0.2047850762905313, Accuracy: 51.89\n", + "Epoch: 70, Loss: 0.2009404785770494, Accuracy: 53.82\n", + "Epoch: 80, Loss: 0.19718559098232466, Accuracy: 56.589999999999996\n", + "Epoch: 90, Loss: 0.1935182583845141, Accuracy: 60.150000000000006\n", + "Final loss: 0.1902919533434642, final accuracy: 63.480000000000004\n", + "Training time per epoch: 0.0011953979200052345 s\n" + ] + }, + { + "data": { + "text/plain": [ + "<Figure size 700x300 with 2 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##############################################################\n", + "Train for 1000 epochs with a batch size of 100.\n", + "Data is divided into 100 batches.\n", + "Epoch: 0, Loss: 0.4032026551907745, Accuracy: 50.0\n", + "Epoch: 100, Loss: 0.22076304713816888, Accuracy: 50.46000000000001\n", + "Epoch: 200, Loss: 0.18293691903009945, Accuracy: 71.97\n", + "Epoch: 300, Loss: 0.15337050845719877, Accuracy: 91.43\n", + "Epoch: 400, Loss: 0.1307477372464688, Accuracy: 96.67\n", + "Epoch: 500, Loss: 0.1134119531370812, Accuracy: 98.29\n", + "Epoch: 600, Loss: 0.09995954042245417, Accuracy: 98.81\n", + "Epoch: 700, Loss: 0.08934388176713816, Accuracy: 99.05000000000001\n", + "Epoch: 800, Loss: 0.08081832019033271, Accuracy: 99.17\n", + "Epoch: 900, Loss: 0.07385536168285291, Accuracy: 99.31\n", + "Final loss: 0.06813304705797224, final accuracy: 99.31\n", + "Training time per epoch: 0.0012260110269987762 s\n" + ] + }, + { + "data": { + "text/plain": [ + "<Figure size 700x300 with 2 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##############################################################\n", + "Train for 10000 epochs with a batch size of 2000.\n", + "Data is divided into 5 batches.\n", + "Epoch: 0, Loss: 0.40558308153551126, Accuracy: 50.0\n", + "Epoch: 1000, Loss: 0.25509336530253124, Accuracy: 50.0\n", + "Epoch: 2000, Loss: 0.2193721779512181, Accuracy: 50.029999999999994\n", + "Epoch: 3000, Loss: 0.1994687391536733, Accuracy: 54.99000000000001\n", + "Epoch: 4000, Loss: 0.18173194057235237, Accuracy: 72.24000000000001\n", + "Epoch: 5000, Loss: 0.16609771089849767, Accuracy: 85.84\n", + "Epoch: 6000, Loss: 0.1524057472310507, Accuracy: 92.63\n", + "Epoch: 7000, Loss: 0.14044729471512038, Accuracy: 95.49\n", + "Epoch: 8000, Loss: 0.13000304673847268, Accuracy: 96.96000000000001\n", + "Epoch: 9000, Loss: 0.12086446482943022, Accuracy: 97.8\n", + "Final loss: 0.11285134285273721, final accuracy: 98.45\n", + "Training time per epoch: 0.0002350828903998945 s\n" + ] + }, + { + "data": { + "text/plain": [ + "<Figure size 700x300 with 2 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##############################################################\n", + "Train for 10000 epochs with a batch size of 10000.\n", + "Data is divided into 1 batches.\n", + "Epoch: 0, Loss: 0.26416478154134077, Accuracy: 50.0\n", + "Epoch: 1000, Loss: 0.2343491715896676, Accuracy: 50.0\n", + "Epoch: 2000, Loss: 0.21961461724572034, Accuracy: 50.0\n", + "Epoch: 3000, Loss: 0.21253714833083914, Accuracy: 50.05\n", + "Epoch: 4000, Loss: 0.20784350343764424, Accuracy: 50.49\n", + "Epoch: 5000, Loss: 0.2037865262400474, Accuracy: 51.49\n", + "Epoch: 6000, Loss: 0.19993582670554746, Accuracy: 53.63\n", + "Epoch: 7000, Loss: 0.1961971439074342, Accuracy: 56.8\n", + "Epoch: 8000, Loss: 0.19255066150876962, Accuracy: 60.22\n", + "Epoch: 9000, Loss: 0.18899201938217983, Accuracy: 63.89\n", + "Final loss: 0.1855232966051956, final accuracy: 67.72\n", + "Training time per epoch: 0.0001813526257013791 s\n" + ] + }, + { + "data": { + "text/plain": [ + "<Figure size 700x300 with 2 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##############################################################\n", + "Train for 100000 epochs with a batch size of 10000.\n", + "Data is divided into 1 batches.\n", + "Epoch: 0, Loss: 0.3318672389102417, Accuracy: 50.0\n", + "Epoch: 10000, Loss: 0.17823436373624313, Accuracy: 76.32\n", + "Epoch: 20000, Loss: 0.14974711279480923, Accuracy: 92.58999999999999\n", + "Epoch: 30000, Loss: 0.12798220939060906, Accuracy: 96.84\n", + "Epoch: 40000, Loss: 0.11128760173852001, Accuracy: 98.34\n", + "Epoch: 50000, Loss: 0.09830544705065106, Accuracy: 98.95\n", + "Epoch: 60000, Loss: 0.08803511353596566, Accuracy: 99.11\n", + "Epoch: 70000, Loss: 0.07976579982094134, Accuracy: 99.26\n", + "Epoch: 80000, Loss: 0.07299572638656812, Accuracy: 99.35000000000001\n", + "Epoch: 90000, Loss: 0.06736803795053745, Accuracy: 99.42999999999999\n", + "Final loss: 0.06262596614431658, final accuracy: 99.47\n", + "Training time per epoch: 0.00018902279104021774 s\n" + ] + }, + { + "data": { + "text/plain": [ + "<Figure size 700x300 with 2 Axes>" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArEAAAErCAYAAADJz9uVAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbVxJREFUeJzt3XlcVGX///HXsIOyuLIJsqjggopLhPutIKmVppl6m1tmi1oZpfdtuWdpZmZ6u5TlUm4tLlkaiZRriPuOC4o74IoIKIxwfn/4m/N1AhUQODPweT4e84g5c8113ofk8OHMda5LpyiKghBCCCGEEGbEQusAQgghhBBCFJYUsUIIIYQQwuxIESuEEEIIIcyOFLFCCCGEEMLsSBErhBBCCCHMjhSxQgghhBDC7EgRK4QQQgghzI4UsUIIIYQQwuxIESuEEEIIIcyOFLFCCJPSrl07dDodOp2Os2fPFqmPxYsXq31MmDChWPMJIYQwDVLECiHy5ePjoxaCj3ts3rxZ67hCCCHKGSutAwghxINmz57NrVu3AHB3dy9SH507d2bbtm0AeHt7F1s2IYQQpkOnKIqidQghhOnZs2cPd+/eVZ/37NmT5ORkAGbNmkVwcLD6WlBQEM7Oznn6yMjIoEKFCiUfthzIzc0lOzsbOzs7TfYv/y+FEKZGhhMIIfLVrFkzWrVqpT5sbW3V14KCgtTtNWrUwMXFBZ1OR7t27di6dSuhoaHY29szbNgwAL799lsiIiLw9vamQoUK2NnZUbt2bd566y2uXbtmtN/8xsSePXtW3dauXTt2797Nv/71LxwcHHBzc2PMmDHk5uaqfTxsTOyDfR86dIi33nqL6tWrY29vT6dOnTh37pxRltzcXCZNmkSNGjVwcHDgX//6FwcOHCjUuN1/Zlm6dCn169fHzs6OevXqsXz5cqP2EyZMUNsvXLiQyZMnU7NmTaytrdm5cycAiqLw9ddf8/TTT+Po6IidnR2BgYF88MEH6lXsB/388880aNAAOzs7GjRowI8//mi0n8WLF6ttHxxGcv78eXr06IGzszMNGjRQ21y9epXIyEhq166Nra0tlSpVokuXLmq+B3311Vc0a9aMihUrYmtri6enJ2FhYUybNs3o+/zxxx/ToEED7O3tsbOzw9vbmy5duvDtt98+8vsrhCjHFCGEKICaNWsqgAIof/31l7o9MTFR3e7h4aHY2dmpzwcMGKAoiqJERESo2/75qFu3rnLnzh21v7Zt26qvJSYm5tmHu7u7Ym9vn6efBQsWqH0sWrRI3T5+/Ph8+/bz88vTR8uWLY2O+e23387TxtnZWfHx8cmT8WEezBIQEJDv92D58uVq+/Hjxz80419//aXk5uYqvXv3fuj3MzAwULlx44ba36pVqxSdTpenXaNGjdSvFy1alO//5wf3X7NmTUVRFOXcuXNKjRo18t23tbW18ssvv6h9fffddw/N6enpqbabNGnSQ9v98/+JEEIYyJVYIUSxuXz5MjVq1GDp0qVs2LCBbt26AdCrVy8WLlzI+vXr2bx5M+vXr6d///4AxMfHs3r16gLvIykpiSZNmvDLL7/w9ttvq9u/+uqrQmW9evUq8+fPZ+nSpbi4uACwY8cOjh49CsCJEyeYPXs2ABYWFowbN45ff/2Vp556qsizJpw4cYJ33nmH9evX8/LLL6vbIyMj0ev1edqfOXOGvn37sn79er777js8PT358ccfWblyJQCVKlXi66+/Zs2aNTRs2BCA48eP88EHHwCQk5PDiBEjUP7/qLGePXuyfv163n77bQ4ePPjYvCkpKcyYMYONGzeqfQ4dOpSLFy8C0L9/f6Kiopg3bx4VK1ZEr9fzyiuvkJGRAcAvv/wCgJWVFfPnzycmJoZly5bx3nvv4evrq+7H0M7FxYWlS5eyadMmvvvuO954440ij4sWQpQDWlfRQgjzUJArsRYWFsrx48fzvPf8+fPKkCFDFF9fX8XW1jbP1bZ3331Xbfu4K7E2NjZKcnKyoiiKkpOTozg4OCiA4uLiovZRkCuxX3zxhbr9jTfeULevXbtWURRF+fTTT9VtPXr0UNveuHHD6EpwYa7EPnhV8d69e4q3t7f62tatWxVFMb4Sm99VyOeff159ffbs2er2w4cPq9srVaqk5ObmKnFxceo2Nzc3JTs7W23/9NNPP/ZK7Ndff2207+vXr6tXdd3c3JRt27apjxdeeEF9388//6woiqJeMXZwcFA2bdqk3Lp1K9/vkSGLp6enEhsbq2RkZDzyeyqEEIoiV2KFEMWodu3aBAQEGG27ffs2LVq0YMGCBSQmJpKVlZXnfampqQXeR2BgIK6ursD9K6SVKlUqdB8Abdu2Vb+uUqVKnixnzpxRt4WEhKhfV6pUicDAwELtK79+LC0tadq0qfr8wf0ZPPvss3m2nTx5Mt/+GjRogIODAwA3b97k6tWrRn02adIEa2tr9XloaOhj8z733HNGzxMSEtSrusnJybRu3Vp9rFmzRm0XHx8PwKBBg9DpdGRmZhIWFoazszNeXl68/PLL7NmzR20/ePBgAC5dukRoaCgVK1akVq1avP7660bHK4QQD5IiVghRbAzF5YPWrFmjfvwcGBjIDz/8wLZt2/jiiy/UNg/elPU4hqLVwMqqaDMFPtjPg30o+UzYotPpirSPx3lcv/l9P0tqX8W5f8Nwgo4dO7Jjxw6GDBlCcHAwDg4OXLx4kWXLltG2bVu1yH711Vf5/fff6devHw0aNMDGxobTp0/z9ddf07Zt20L/gSKEKB+kiBVCFJv8CqVLly6pXw8bNoyXXnqJVq1aGU3fZYr8/f3Vr3fv3q1+ffPmTY4fP16kPnft2qV+nZOTY3Q10s/PL0/7/L6fderUybe/I0eOkJmZCdwv0KtVq2Z0DPv37ycnJ0d9Hhsb+9i8/9x/rVq11G3+/v7cu3cPRVGMHtnZ2UyaNAm4/wdBaGgoX3/9Nfv27eP27dt8/vnnAGRmZhIVFaW2e+aZZ/juu+84fPgw6enpjBgxArh/xffvv/9+bFYhRPkjix0IIUpUzZo11a8XLlyIn58fCQkJTJ48WcNUj9e1a1f+85//oCgKq1at4qOPPqJJkyZ8+eWX3Llzp0h9bt++ncjISMLDw1m5ciXnz58H7l/xfPrppwvUx7///W/WrVsHwLhx47C1taVq1apMnDhRbdOrVy90Oh1NmjTBy8uLCxcucPnyZfr370/fvn35448/8p0O63EqV65Mp06d2LBhA6dPn+b5559n8ODBODo6cu7cOfbv38/q1auJjY3Fx8eHt99+m6SkJMLDw/Hy8sLKykpdhAJQh5a8+OKLODo60rp1a2rUqMG9e/eMCvz8hqAIIYQUsUKIEvXcc8/h7u5OUlIS+/fvp0uXLgC0bNmSHTt2aJzu4erUqcNbb73FrFmzyMnJYdy4cQA4OTlRs2bNPHPKFkRQUBBffPGF0VAKgOnTpxuNV32Ul156iTVr1vDDDz9w48YNhgwZYvR6YGAgn3zyCXB/3O3MmTN58cUXURSF5cuXq/PSBgUFcfjw4UIfw7x582jZsiUXL15kw4YNbNiw4aFt79y5w6pVq1i1alWe1+zt7enatSsAt27dYvXq1SxZsiRPO1dXV9q3b1/onEKIsk+GEwghSpSjoyPR0dG0b9+eihUr4unpyaRJk9SPnE3ZjBkzmDBhAh4eHtjZ2dG6dWv++usvo/G0hpupCqJ79+788MMP1K9fHxsbGwICAvj++++Nptt6HJ1Ox/Lly5k/fz5PPfUUFSpUwNbWljp16vDf//6XnTt3GuXr3r07P/74I/Xq1cPGxoa6deuyfPlyOnToUKRj8Pb2Zv/+/YwcOZLAwEDs7OxwdHQkMDCQ/v37s27dOry8vADo27cvAwYMICAgAGdnZywtLalevTrdunVj27Zt6hCKoUOH0qtXL/z9/alYsSJWVlZ4enrSt29ftm/fnu9qcEIIIcvOCiHEQyiKkmdc6PXr1/H29iYzMxMXFxeuX7+OhcXDrwcsXryYQYMGATB+/HijFcRKQ37HAPD0008TFxcHwL59+4yWERZCCHMgwwmEEOIhpk+fzo0bN3j22Wfx9vbm3LlzjB07Vr2BqmfPno8sYE3Btm3bmDdvHgMHDiQwMJDU1FS+/vprtYANCAigUaNGGqcUQojCkyJWCCEeIiMjg6lTpzJ16tQ8r9WtW5cpU6ZokKpwcnNzWblypbrK14McHR1ZvHixyRfiQgiRHzlzCSHEQ7Rr144uXbrg6emJjY0NFStWJDg4mEmTJrFr1y6jRRJMlZ+fHy+//DL+/v44ODhga2tLrVq1ePPNNzl48GCBZ0UQQghTI2NihRBCCCGE2ZErsUIIIYQQwuxIESuEEEIIIcyOFLFCCCGEEMLsSBErhBBCCCHMjhSxQgghhBDC7EgRK4QQQgghzI4UsUIIIYQQwuxIESuEEEIIIcyOFLFCCCGEEMLsSBErhBBCCCHMjhSxQgghhBDC7EgRK4QQQgghzI4UsUIIIYQQwuxIESuEEEIIIcyOFLFCCCGEEMLsSBErhBBCCCHMjhSxQgghhBDC7EgRK4QQQgghzI4UsUIIIYQQwuxIESuEEEIIIcyOFLFCCCGEEMLsSBErhBBCCCHMjpXWAUxRbm4uly9fxtHREZ1Op3UcIUQpURSF27dv4+HhgYWF/I1fHOR8KkT5VBrnUyli83H58mW8vLy0jiGE0MiFCxeoUaOG1jHKBDmfClG+leT5VIrYfDg6OgL3v/FOTk6Pba/X69m4cSMdO3bE2tq6pOMVG8ldusw1N5hv9sLmTktLw8vLSz0HiCcn51PTZq65wXyzl5fcpXE+lSI2H4aPvJycnAp80nVwcMDJycns/kFK7tJjrrnBfLMXNXdZ+dh769atfPbZZ+zdu5ekpCTWrFlDt27d1NcVRWH8+PEsWLCA1NRUWrZsybx586hdu7ba5saNG7z11lv8+uuvWFhY0KNHD7788ksqVqxYoAxyPjVt5pobzDd7ectdkudTGfQlhBBlVEZGBo0aNWLOnDn5vj5t2jRmzZrF/PnziYuLo0KFCkRERHD37l21Td++fTl69CjR0dH89ttvbN26lddee620DkEIIR5KrsQKIUQZ1alTJzp16pTva4qiMHPmTMaMGUPXrl0B+O6773B1dWXt2rX07t2b+Ph4oqKi2L17N82aNQNg9uzZdO7cmenTp+Ph4VFqxyKEEP8kV2KFEKIcSkxMJDk5mbCwMHWbs7MzISEhxMbGAhAbG4uLi4tawAKEhYVhYWFBXFxcqWcWQogHyZVYIYQoh5KTkwFwdXU12u7q6qq+lpycTPXq1Y1et7KyonLlymqbf8rKyiIrK0t9npaWBtwfT6fX6x+by9CmIG1NieQufeaavbzkLo3jkyL2CaWkpHDs2DHOnTundRQhhNDclClTmDhxYp7tGzduxMHBocD9REdHF2esUiO5S5+5Zi9IbkVRuHfvHoqioCiKuu2fXz/qtX9+/bj3ZWdnk5OTQ25urvpQFEX9OjU1FRcXl8dmz8zMLOB3ouikiH1C3377LR9++CEdOnTgzTff1DqOEEIUiJubG3D/D3F3d3d1e0pKCo0bN1bbXLlyxeh99+7d48aNG+r7/2n06NFERkaqzw3T7HTs2LHAsxNER0cTHh5udnduS+7S9c/sOTk5ZGZmqp8G3Llzh8zMTLUgy8nJ4d69e+Tk5KiPO3fukJGRQVZWFpmZmaSlpamfGuj1eu7du0d6err69T8fD/ZvKAQf93Vubi5paWlUqFABwGh7dnY2d+7cITs7m+zsbLKysrh3757G32lj33zzDZ07d35sO8OnMCVJitgnVK1aNQBu3bqlcRIhhCg4X19f3NzciImJUYvWtLQ04uLi1D/IQ0NDSU1NZe/evTRt2hSAP//8k9zcXEJCQvLt19bWFltb2zzbra2tC1UkFba9qSjPuQ1F4J07d7hz5w5Xr14lKSmJ1NRUbt68yZ07d9Tiz1AU6vV60tPTSU9PJyMjQ21nKC6trKzUAvTBK4MPFqVwvxA0tWLP1Oh0ugI9rK2tsbOzw9LSEgsLCywtLdWv79y5g4uLS4H+rZTGz4EUsU9IilghhKlKT08nISFBfZ6YmMiBAweoXLky3t7ejBgxgsmTJ1O7dm18fX0ZO3YsHh4e6lyydevW5ZlnnmHIkCHMnz8fvV7P8OHD6d27t8xMUA4oisK5c+c4duwYZ8+e5eLFi1y7do2MjAxu3LhBeno6qampXLlyhfT09FL5+LigLC0tsbOzo2LFimoRZmlpiZWVldFzW1tbHB0dsbe3x87ODicnJ2xsbNSi3traGnt7e+zt7bGyslLfb/ja1tYWOzs7tQC0sLB47Ne5ubns3r2bkJAQbGxsjF63tramQoUK2NjYqA8HBwcsLS0LXITm9ygOer2eDRs2FOgqbGmRIvYJGW56KI3L5kIIURh79uzhX//6l/rc8DH/gAEDWLx4MaNGjSIjI4PXXnuN1NRUWrVqRVRUFHZ2dup7li1bxvDhw+nQoYO62MGsWbNK/VhEybh+/TqnTp1i3bp1HD58WC1MExISOHToEDdv3ix0nw4ODtjZ2VGlShXc3d2pUqUKTk5OODo6qsWf4WFtba1OoO/g4ICLiwsODg7Y2NiQnp6Om5sbFhYW6hVBw9cWFhbk5OSwdetWOnTogK2tLVZWVlSsWBFbW1ssLS1L4LtVPAxDFTp06GCWV+1NiRSxT0iuxAohTFW7du2Mbub4J51Ox6RJk5g0adJD21SuXJnly5eXRDxRChRF4ezZs8THx5OYmEhiYiInT54kOTmZa9eukZiY+Ng+ateujZ+fH7Vq1aJ69eo4Ojri4uKiFp7Vq1enUqVKODs7U7ly5VJb8U6v1xMfH0+NGjWkGCynpIh9QoYi9u7du9y9e1d+kIQQQmjm3r177Nmzh7i4ONavX8/OnTu5ffv2I99TuXJlatSoQVBQEB4eHlSoUAFPT08aNmxI/fr11RuQhDA1UsQ+IWdnZ6ytrdHr9Vy9ehVHR0etIwkhhCgncnNziY+PZ8uWLWzcuJEdO3Zw7do1ozZWVlbUrl2bmjVr4ufnR2BgID4+Pjg7OxMQEMDOnTvp3LmzXIQRZkeK2Cek0+moWrUqSUlJXLt2DT8/P60jCSGEKMPS0tJYvXo1y5cvZ/v27dy5c8fodRcXF5o2bUrr1q154YUXCAgIyHfGCDC/CfeFeJAUscWgWrVqJCUl5ZlPUQghhCgOWVlZrF27lqVLl/Lbb78ZvWZjY0OjRo2IiIigc+fONG3aFBsbG42SClF6pIgtBoZxsVevXtU4iRBCiLJCURRWrVrFypUr+f33342msPLy8uKll15iwIABBAYGylAAUS5JEVsMqlatCpBnHJIQQghRGIqicObMGVasWMH333/PyZMn1deqVKlC//79GTRoEA0aNCi1WQCEMFVSxBYDuRIrhBDiSSQnJ/Ptt9+yZMkSTp06pW63s7Ojd+/e9OnTh/bt22NlJb+2hTCQn4ZiIFdihRBCFNX//vc/Ro4cyd27d4H7q021adOGHj160LdvX1xcXLQNKISJkiK2GBhW7ZIrsUIIIQpq8+bNvPvuuxw4cACAoKAgBg0axKBBg6RwFaIApIgtBoYrsVLECiGEeJyzZ88yduxYli5dqm6bPHkyo0ePxsLCQsNkQpgXKWKLgWFMrAwnEEII8TA3b95kzJgxLFiwQJ2f9cUXX+Tzzz/H29tb43RCmB8pYouBXIkVQgjxKJs3b6Znz57qxY6nnnqKDz74gOeff15mGRCiiEzic4s5c+bg4+ODnZ0dISEh7Nq166FtV69eTbNmzXBxcaFChQo0btyY77//3qiNoiiMGzcOd3d37O3tCQsLM7rbs7gZxsSmpaWRlZVVYvsRQghhfjZs2ED79u25du0azs7OrF69mp07d9K1a1cpYIV4ApoXsT/88AORkZGMHz+effv2qauOPGz1q8qVK/Phhx8SGxvLoUOH1EHwf/zxh9pm2rRpzJo1i/nz5xMXF0eFChWIiIhQ7/wsbi4uLlhaWgIypEAIIcT/mT9/Pl26dEFRFDp27Mi+fft44YUXpHgVohhoXsTOmDGDIUOGMGjQIOrVq8f8+fNxcHBg4cKF+bZv164dL7zwAnXr1sXf35933nmHhg0bsn37duD+VdiZM2cyZswYunbtSsOGDfnuu++4fPkya9euLZFj0Ol0ODk5AcjSs0IIIQD45ptvePPNNwF49tlnWbNmDX5+fhqnEqLs0LSIzc7OZu/evYSFhanbLCwsCAsLIzY29rHvVxSFmJgYTpw4QZs2bQBITEwkOTnZqE9nZ2dCQkIK1GdRGYpYuRIrhBDlW3Z2Ni+//DJDhgwBoG/fvqxbtw4HBweNkwlRtmh6Y9e1a9fIycnB1dXVaLurqyvHjx9/6Ptu3bqFp6cnWVlZWFpaMnfuXMLDw4H7q54Y+vhnn4bX/ikrK8toLGtaWhoAer1evYP0UfR6vVrEJiUlFeg9psCQ01zyGkju0meu2Qub29yOT5geRVEYPHgwy5YtA2Do0KHMnj1bhg8IUQLMcnYCR0dHDhw4QHp6OjExMURGRuLn50e7du2K1N+UKVOYOHFinu0bN24s8F/OhiJ269atODs7FymHVqKjo7WOUCSSu/SZa/aC5s7MzCzhJKKsmzRpEkuXLkWn0zF37lzeeOMNrSMJUWZpWsRWrVoVS0tLUlJSjLanpKTg5ub20PdZWFhQq1YtABo3bkx8fDxTpkyhXbt26vtSUlJwd3c36rNx48b59jd69GgiIyPV52lpaXh5edGxY0e1OH0UvV7P119/DdyfM7Zz586PfY8p0Ov1REdHEx4ejrW1tdZxCkxylz5zzV7Y3IZPYYQoinXr1qn3c0yfPl0KWCFKmKZFrI2NDU2bNiUmJoZu3boBkJubS0xMDMOHDy9wP7m5uepwAF9fX9zc3IiJiVGL1rS0NOLi4tQB9v9ka2uLra1tnu3W1tYF/oVtKHZv3LhhVr/koXDHaUokd+kz1+wFzW2Oxya0pygKU6ZMUQvY4cOHG10YEUKUDM2HE0RGRjJgwACaNWvGU089xcyZM8nIyGDQoEEA9O/fH09PT6ZMmQLc/+i/WbNm+Pv7k5WVxYYNG/j++++ZN28ecH+mgBEjRjB58mRq166Nr68vY8eOxcPDQy2US4Lc2CWEEOWPoiiMHDmSzz//HIBhw4bx5ZdfapxKiPJB8yK2V69eXL16lXHjxpGcnEzjxo2JiopSb8w6f/680VrSGRkZDB06lIsXL2Jvb09gYCBLly6lV69eaptRo0aRkZHBa6+9RmpqKq1atSIqKgo7O7sSOw7DOFhZtUsIIcqPUaNGqQXsyy+/zIwZM4x+ZwkhSo7mRSzc/+jlYcMHNm/ebPR88uTJTJ48+ZH96XQ6Jk2axKRJk4or4mMZrsRKESuEEOXD4sWLmT59OnD/U8K6devKLARClCL5c7GYSBErhBDlR3JyMiNGjADgvffe47333tM2kBDlkBSxxcQwnODGjRvk5ORonEYIIURJioyM5NatW9SpU0e9Z0MIUbqkiC0mjo6OwP1B/jdu3NA4jRBCFMzt27cZMWIENWvWxN7enhYtWrB79271dUVRGDduHO7u7tjb2xMWFsapU6c0TKy9HTt2sGLFCgAWLlwos1oIoREpYouJpaUllStXBmRIgRDCfLz66qtER0fz/fffc/jwYTp27EhYWBiXLl0CYNq0acyaNYv58+cTFxdHhQoViIiI4O7duxon10ZOTg7Dhg0DYPDgwbRs2VLjREKUX1LEFqMqVaoAUsQKIczDnTt3WLVqFdOmTaNNmzbUqlWLCRMmUKtWLebNm4eiKMycOZMxY8bQtWtXGjZsyHfffcfly5dZu3at1vE1MWPGDA4ePIiDg0Op3jwshMhLithiVK1aNUCKWCGEebh37x45OTl5ph+0t7dn+/btJCYmkpycTFhYmPqas7MzISEhxMbGlnZczcXExPCf//wHgE8++QQPDw+NEwlRvpnEFFtlRdWqVQEpYoUQ5sHR0ZHQ0FA++ugj6tati6urKytWrCA2NpZatWqRnJwMoM7bbeDq6qq+9k9ZWVnqCorwf0v56vV69Hr9YzMZ2hSkbWm6d+8eb7/9Noqi0L17d9544w2jjKaa+3HMNTeYb/bykrs0jk+K2GJkuBIrq3YJIczF999/zyuvvIKnpyeWlpY0adKEPn36sHfv3iL1N2XKFCZOnJhn+8aNG3FwcChwP9HR0UXaf0lZv349x44dw9bWlk6dOhEVFZVvO1PLXVDmmhvMN3tZz52ZmVnCSaSILVZyJVYIYW78/f3ZsmULGRkZpKWl4e7uTq9evfDz88PNzQ2AlJQU3N3d1fekpKTQuHHjfPsbPXo0kZGR6vO0tDS8vLzo2LGjOp/2o+j1eqKjowkPDzeZu/6vXr1K3759Afj4448ZMGBAnjammLsgzDU3mG/28pLb8ClMSZIithhJESuEMFcVKlSgQoUK3Lx5kz/++INp06bh6+uLm5sbMTExatGalpZGXFwcb775Zr792NraYmtrm2e7tbV1oX5hF7Z9SRo9ejQZGRk0btyYd99995HLyppS7sIw19xgvtnLeu7SODYpYouRFLFCCHPzxx9/oCgKAQEBJCQkMHLkSAIDAxk0aBA6nY4RI0YwefJkateuja+vL2PHjsXDw4Nu3bppHb1U3Lx5kx9//BGAmTNnPrKAFUKULilii5HMTiCEMDe3bt1i9OjRXLx4kcqVK9OjRw8+/vhj9SrKqFGjyMjI4LXXXiM1NZVWrVoRFRWVZ0aDsmrhwoXcvXuXBg0a0KZNG63jCCEeIEVsMZIiVghR3DIyMoD7H/eXhJdeeomXXnrpoa/rdDomTZpULudEzc3NZfbs2QAMHToUnU6ncSIhxIPkc5FiZBhOcO3aNRRF0TiNEMKcnT59mhYtWuDk5ISTkxOhoaEkJCRoHatc2bFjB+fOnaNixYr53swlhNCWFLHFyFDE6vX6UrkrTwhRdr3++uucOHGCF154gZ49e3Lp0iWGDBmidaxy5ZtvvgHg2WefLdT0YEKI0iHDCYqRvb09FSpUICMjg6tXr+Ls7Kx1JCGEmYiNjSU0NFR9vnfvXlatWkX79u0BuHLlCrVq1dIqXrlz8+ZNfvjhBwDeeOMNjdMIIfIjRWwxq1atmlrEyi8cIURBtW3bltdff52pU6dSoUIFateuzRtvvEG3bt2wtrbmzz//pE6dOlrHLDcWLFhAVlYW9evXlxu6hDBRMpygmMnNXUKIoti6dStbtmyhbt26rF+/nrlz53L37l2mT5/OlClTuHTpEnPnztU6ZrmQm5vLF198AcBbb70lN3QJYaLkSmwxk6VnhRBF8fTTT7Nv3z6mTJnCiy++SLdu3fj7779JTU1FURQCAwPNcmJ0cxQXF0dycjIODg5yQ5cQJkyuxBYzWfBACFFUVlZWjB07lv3793Pp0iUaN27M3r17CQoKkgK2FP3yyy8AdOrUqdzMhyuEOZIitpjJcAIhRFHFxMQwY8YMLl++zNatW5k8eTIjRoygY8eOnD17Vut45YKiKKxatQrgkfPnCiG0J0VsMZMiVghRFFOnTiU8PJz333+f8PBwpk2bxhtvvMHRo0epUKECDRo04PPPP9c6Zpm3Z88eEhISsLW1pVOnTlrHEUI8gkkUsXPmzMHHxwc7OztCQkLYtWvXQ9suWLCA1q1bU6lSJSpVqkRYWFie9gMHDkSn0xk9nnnmmZI+DECKWCFE0cyZM4cxY8bwxx9/8MEHH6grRXl4eLBmzRqWLFnCjBkzNE5Z9hnmhu3WrRuOjo4apxFCPIrmRewPP/xAZGQk48ePZ9++fTRq1IiIiAiuXLmSb/vNmzfTp08f/vrrL2JjY/Hy8qJjx45cunTJqN0zzzxDUlKS+lixYkVpHI7c2CWEKJK0tDT69etHeHg4/fr14/bt20av9+jRg/j4eI3SlQ96vV4dSjB48GCN0wghHkfzInbGjBkMGTKEQYMGUa9ePebPn4+DgwMLFy7Mt/2yZcsYOnQojRs3JjAwkG+++Ybc3FxiYmKM2tna2uLm5qY+KlWqVBqHI1dihRBF0q5dOxo0aICXlxdBQUG0a9cuTxsnJ6fSD1aOxMbGcv36dSpXrkzbtm21jiOEeAxNp9jKzs5m7969jB49Wt1mYWFBWFgYsbGxBeojMzMTvV5P5cqVjbZv3ryZ6tWrU6lSJdq3b8/kyZOpUqVKvn1kZWWRlZWlPjcsGavX69Hr9Y/NYGij1+vVVbquXr1aoPdq6cHc5kRylz5zzV7Y3Foe39dff01kZCQHDx6kbdu2Mv5VAytXrgQgIiICGxsbjdMIIR5H0yL22rVr5OTk4OrqarTd1dWV48ePF6iP//znP3h4eBAWFqZue+aZZ+jevTu+vr6cPn2aDz74gE6dOhEbG4ulpWWePqZMmcLEiRPzbN+4cWOh1suOjo4mIyMDgIyMDNasWYOtrW2B36+V6OhorSMUieQufeaavaC5MzMzSzjJw7m6urJs2TLN9l/e3bhxg6VLlwLI3LBCmAmzXuxg6tSprFy5ks2bNxvN5de7d2/166CgIBo2bIi/vz+bN2+mQ4cOefoZPXo0kZGR6vO0tDR1rG1BPr7T6/VER0cTHh6OlZUVAwcORK/X07RpU7y9vZ/wKEvOg7nNaQ5KyV36zDV7YXMbPoUR5c/ChQu5ffs29evXJzw8XOs4QogC0LSIrVq1KpaWlqSkpBhtT0lJwc3N7ZHvnT59OlOnTmXTpk00bNjwkW39/PyoWrUqCQkJ+Raxtra2+V4xtba2LtQvbEP7atWqcfnyZVJTU/H39y/w+7VS2OM0FZK79Jlr9oLmNsdjE09OURT+97//ATBs2DAsLDS/XUQIUQCa/qTa2NjQtGlTo5uyDDdphYaGPvR906ZN46OPPiIqKopmzZo9dj8XL17k+vXruLu7F0vux5EZCoQQwnxs2bKFc+fOUaFCBRlKIIQZ0fzPzcjISBYsWMCSJUuIj4/nzTffJCMjg0GDBgHQv39/oxu/Pv30U8aOHcvChQvx8fEhOTmZ5ORk0tPTAUhPT2fkyJHs3LmTs2fPEhMTQ9euXalVqxYRERGlckyy9KwQQpiPtWvXAvfnhi3MfRBCCG1pXsT26tWL6dOnM27cOBo3bsyBAweIiopSb/Y6f/48SUlJavt58+aRnZ3Niy++iLu7u/qYPn06AJaWlhw6dIjnn3+eOnXqMHjwYJo2bcq2bdtK7SYrw5XYh811K4QQ//TBBx+we/durWOUO4qisHr1auD+XLxCCPNhEjd2DR8+nOHDh+f72ubNm42eP279cHt7e/74449iSlY0Hh4eAEbFtxBCPMqcOXP49NNPcXNz47nnnuOFF16gffv2Mk63hB08eJALFy5ga2tbap/WCSGKh+ZXYsuiGjVqAPfH4gohREFcu3aNDRs20LVrV9avX0+nTp2oWrUqL730EitWrODWrVtaRyyTDBc9OnToIEMJhDAzUsSWAE9PT0CKWCFEwVlbWxMREcHcuXO5cOECcXFxvPXWW8THx9O3b1+qV69OWFgYc+bMyTOjiyi6HTt2AOQ7c40QwrRJEVsC5EqsEOJJNW/enMmTJ3P48GESEhKYMmUKer2eESNG8NVXX2kdr0y4ffs2mzZtApBlZoUwQyYxJrasMRSxly9fJjc3V+YcFEI8ET8/PyIjI4mMjOT69evcuHFD60hlQkxMDHfu3MHf358mTZpoHUcIUUhSXZUAd3d3dDod2dnZMlesEKJYValShdq1a2sdo0z4+++/AfjXv/6FTqfTOI0QorCkiC0B1tbW6hRhMqRACGGqcnJyGDt2LL6+vtjb2+Pv789HH32EoihqG0VRGDduHO7u7tjb2xMWFsapU6c0TF18DAvttGrVSuMkQoiikCK2hMi4WCGEqfv000+ZN28e//vf/4iPj+fTTz9l2rRpzJ49W20zbdo0Zs2axfz584mLi6NChQpERERw9+5dDZM/uatXr7Jv3z4AOnXqpHEaIURRSBFbQgxF7KVLlzROIoQQ+fv777/p2rUrXbp0wcfHhxdffJGOHTuya9cu4P5V2JkzZzJmzBi6du1Kw4YN+e6777h8+bK6ypW5MgwlqFevHtWrV9c4jRCiKOTGrhLi7e0NQGJiosZJhBDm5Mcff6Rbt27Y2NiU+L5atGjB119/zcmTJ6lTpw4HDx5k+/btzJgxA7h//kpOTiYsLEx9j7OzMyEhIcTGxtK7d+88fWZlZZGVlaU+T0tLA0Cv16PX6x+bydCmIG2fxF9//QXc/x4Ux75KK3dxM9fcYL7Zy0vu0jg+KWJLSK1atQBISEjQOIkQwpz07t2bSpUq0bNnT/r370+LFi1KbF///e9/SUtLIzAwEEtLS3Jycvj444/p27cvAMnJyQDqGH8DV1dX9bV/mjJlChMnTsyzfePGjYVaTCA6OrrAbYtizZo1ADg5ObFhw4Zi67ekc5cUc80N5pu9rOfOzMws4SRSxJYYKWKFEEVhaWnJzZs3WbBgAQsWLMDf35/+/fvTr18/atasWaz7+vHHH1m2bBnLly+nfv36HDhwgBEjRuDh4cGAAQOK1Ofo0aOJjIxUn6elpeHl5UXHjh1xcnJ67Pv1ej3R0dGEh4eX2JK7V69e5fz58wBERkYWy3CC0shdEsw1N5hv9vKS2/ApTEmSIraEGKbASUhIkLlihRAFduXKFdatW8fPP//Mpk2bSEhIYPz48UyYMIFWrVoxaNAg/v3vfxfLL7+RI0fy3//+Vx0WEBQUxLlz55gyZQoDBgzAzc0NgJSUFNzd3dX3paSk0Lhx43z7tLW1xdbWNs92a2vrQmUubPvC2Lt3L3B/PKxhhcXiUpK5S5K55gbzzV7Wc5fGsUllVUJq1qyJpaUld+7cISkpSes4QggzUalSJQYMGMCvv/7K1atXmT17Ng4ODuTm5rJt2zZeeeUV/P392bNnzxPvKzMzM88f2JaWluTm5gLg6+uLm5ubOhUV3L+6EhcXR2ho6BPvXyv79+8HkAUOhDBzxVLEXrx4kTVr1nDixIni6K5MsLa2xtfXF6DMzKkohCg9Gzdu5NVXX2XkyJHq2DIHBwcCAgK4ePEir7/++hPv47nnnuPjjz9m/fr1nD17ljVr1jBjxgxeeOEFAHQ6HSNGjGDy5MmsW7eOw4cP079/fzw8POjWrdsT718r27ZtA3jo1WQhhHko0nCCUaNG8fPPP7N8+XLs7e1p1aoVmZmZWFpa8vPPP/P8888Xd06zVLt2bRISEoiPj6ddu3ZaxxFCmIFx48axZMkSLl68qC46UK9ePd5880369++Po6MjrVu3Ji4u7on3NXv2bMaOHcvQoUO5cuUKHh4evP7664wbN05tM2rUKDIyMnjttddITU2lVatWREVFYWdn98T710Jqaip//vknAM8++6zGaYQQT6JIRezGjRu5cuUKTZs2ZeTIkWRkZODk5ERaWhqffvqpFLH/X6NGjfj99985cOCA1lGEEGZi8uTJwP1Pc7p3787QoUNp3bq1UZtmzZoVy0Iqjo6OzJw5k5kzZz60jU6nY9KkSUyaNOmJ92cKtm7dSm5uLrVr1yYgIEDrOEKIJ1Ck4QRnz56lZs2aWFtbs3fvXvz8/Lh69SoeHh7Ex8cXd0azFRwcDPzf+CshhHgcb29vPv74Yy5cuMCKFSvyFLAAX3zxhcxBXUSG+WE7dOigcRIhxJMq0pVYvV6PpaUlACdOnKB169ZYW1vj6uoqRewDDEXs4cOHuXfvHlZWMhmEEOLREhMT0el0WscoswyfjDVv3lzbIEKIJ1akK7He3t4cPXqUiIgIrl+/rhZrycnJ6pQsAvz9/XF0dOTu3bscO3ZM6zhCCDPwn//8hyZNmnDw4EF126FDh2jSpAmjRo3SMJn5S09PZ8eOHQAluoiEEKJ0FKmIffXVV1EUhejoaGxsbPj3v//NmTNnSEpKkilLHmBhYcHTTz8NwJYtWzROI4QwBytWrCAlJYVGjRqp2xo2bMiVK1dYsWKFhsnM39atW9Hr9dSsWVPGwwpRBhSpiH3vvfdYu3Yt06dPZ8+ePfj5+ZGbm8uCBQv44IMPijujWWvfvj2AejesEEI8ypUrV6hUqVKe7S4uLly9elWDRGXHb7/9BkDHjh1lyIYQZUCRB2n+cwaCKlWqMHjw4CcOVNYYbh7YvHkzer3eLFfnEEKUnsqVK3Py5Eni4uIICQkBYNeuXZw4cYKqVatqnM68GRZteO655zROIoQoDkW6Evvdd9/xyiuvcPjwYVJSUmjYsCFVq1alZs2aHDlypND9zZkzBx8fH+zs7AgJCWHXrl0PbbtgwQJat25NpUqVqFSpEmFhYXnaK4rCuHHjcHd3x97enrCwMM0WHGjSpAnVq1cnNTXVaNUbIYTIz7/+9S/u3btH27ZtiYiIICIigjZt2pCbmyt31D+BGzducPLkSQBatmypcRohRHEoUhH79ddfs3TpUry8vPjqq684cuQIiqJw4cIFxo4dW6i+fvjhByIjIxk/fjz79u2jUaNGREREcOXKlXzbb968mT59+vDXX38RGxuLl5cXHTt25NKlS2qbadOmMWvWLObPn09cXBwVKlQgIiKCu3fvFuVwn4ilpSUvvfQSAMuWLSv1/QshzMukSZNwdnYmOzubTZs2sWnTJrKzs3FxcWHixIlaxzNbhlW6AgMDqVy5ssZphBDFoUhF7MmTJ/H29sbFxYW///6bqlWrEhsbi5OTEzt37ixUXzNmzGDIkCEMGjSIevXqMX/+fBwcHFi4cGG+7ZctW8bQoUNp3LgxgYGBfPPNN+Tm5qpXORVFYebMmYwZM4auXbvSsGFDvvvuOy5fvszatWuLcrhPrG/fvgD8/PPPpKSkaJJBCGEeatWqxZ49exg4cCB169albt26DBo0iF27duHv7691PLO1b98+APVmWyGE+SvSmNi0tDS8vb0BOH78OE2bNiUkJIRatWoVajhBdnY2e/fuZfTo0eo2CwsLwsLCiI2NLVAfmZmZ6PV69S/rxMREkpOTCQsLU9s4OzsTEhJCbGwsvXv3ztNHVlYWWVlZRscH9+fD1ev1j81gaPOwtk2aNOGpp55i165dfP7553z88ccFOraS9rjcpkpylz5zzV7Y3KZyfP7+/g/9Q14UjaGIbdy4sbZBhBDFpkhFbPXq1Tl27BhTpkzhwoUL6sflN27cKNTHNNeuXSMnJwdXV1ej7a6urhw/frxAffznP//Bw8NDLVqTk5PVPv7Zp+G1f5oyZUq+H9Nt3LgRBweHAuUAiI6OfuhrHTp0YNeuXXz55Zf4+/ub1Hy6j8ptyiR36TPX7AXNnZmZWcJJCiY7O5sdO3Zw+fJlcnJyjF7r37+/RqnMl16vZ+vWrYCMhxWiLClSEdulSxe++uorxowZA9yfqeDGjRtcvHiRNm3aFGvAR5k6dSorV65k8+bN2NnZFbmf0aNHExkZqT5PS0tTx9o6OTk99v16vZ7o6GjCw8MfOvtAp06diIuL488//+Snn35i/fr1WFgUaTRHsSlIblMkuUufuWYvbG7DpzBaOnXqFGFhYVy8eDHPazqdTorYIti9ezdpaWlUqVJFXZxHCGH+ilTETp8+HXt7exISEnjuuedo1aoVu3fvplevXjz77LMF7qdq1apYWlrmGSeakpLy2CuV06dPZ+rUqWzatImGDRuq2w3vS0lJwd3d3ajPh32MZGtri62tbZ7t1tbWhfqF/bj2c+fOJTg4mJiYGKZNm1bom+BKSmGP01RI7tJnrtkLmtsUju2///0vFy5c0DpGmWJYDr1p06bqkulCCPNXpEuBFSpUYMaMGaxbt44hQ4YA99eh/v777+nVq1eB+7GxsaFp06ZGU08ZbtIKDQ196PumTZvGRx99RFRUFM2aNTN6zdfXFzc3N6M+09LSiIuLe2SfpSEgIIB58+YBMH78eFavXq1pHiGE6dm2bRtWVlbqEIjg4GBWrFhB1apVzXY4h9bOnDkDIDfGCVHGFPnz7JMnTzJo0CCCgoIICgrilVdeKdJcrJGRkSxYsIAlS5YQHx/Pm2++SUZGBoMGDQLuj/968MavTz/9lLFjx7Jw4UJ8fHxITk4mOTmZ9PR04P7HbSNGjGDy5MmsW7eOw4cP079/fzw8POjWrVtRD7fYDBgwgDfffBNFUfj3v/8ty9EKIYykpqZSt25dOnTogE6nw9raml69euHm5sYnn3yidTyzZLjhWJaaFaJsKdJwgiNHjtCyZUvS09NRFAWAY8eOsWrVKv7++2/q169f4L569erF1atXGTduHMnJyTRu3JioqCj1xqzz588bjR2dN28e2dnZvPjii0b9jB8/ngkTJgAwatQoMjIyeO2110hNTaVVq1ZERUU90bjZ4jR79mySkpJYu3YtXbt2ZdOmTXmuKAshyidHR0dyc3MBqFixIsePHycuLo7z589z+vRpjdOZp/379wPIeFghypgiFbFjx47l9u3bVKxYkdatWwP3PwK7ffs248aNY9WqVYXqb/jw4QwfPjzf1zZv3mz0/OzZs4/tT6fTMWnSJCZNmlSoHKXF0tKS5cuX88wzz7B161bCw8PZtGkTTZs21TqaEEJjXl5enDlzhpycHIKCgoiNjaVFixbA/eFSonBSU1PVMcaNGjXSOI0QojgVaTjB1q1bcXR0JD4+nvXr17N+/XqOHTuGo6OjfDxeQPb29vz222+0bNmS1NRUwsLC2Lt3r9axhBAaGzBgAB06dODUqVN8+OGHWFtboygKFhYW6qdNouAM51VfX1+cnZ01TiOEKE5FKmLT09OpUaMGnp6e6rYaNWpQo0YNbt++XWzhyjpHR0d+//13WrRoQWpqKuHh4VLIClHOvfvuu6xZs4bAwEA6depEfHw8P//8M0eOHOHll1/WOp7ZOXDgACBDCYQoi4pUxHp7e3PixAlmz57NtWvXuHbtGrNmzeL48ePqSl6iYBwdHYmKiqJFixbcvHmT9u3bs337dq1jCSE0oNfr8ff3p0mTJur9Br6+vnTv3l1uSiqi3bt3A8hwLSHKoCIVsS+99BK5ubmMGDECV1dXXF1deffddwHyXdZVPJrhimybNm1IS0ujY8eObNy4UetYQohSZm1tze3bt8nJyUGn02kdp0wwfLrVvHlzjZMIIYpbkYrYsWPH0qFDBxRFMXqEhYWpq3iJwnFycuL333+nU6dO3Llzh+eee07mkRWiHBo4cCAnTpxQp4USRZeZmanO6CA3dQlR9hRpdgI7Ozuio6PZvHmz0Uc1hw8f5quvvuLtt98u1pDlhYODA2vXruXll1/mp59+omfPnixcuJABAwZoHU0IUUqSk5OB+1cO//Wvf+Hq6qpeldXpdHz77bdaxjMrZ8+eRVEUnJ2dqV69utZxhBDFrEhFrEG7du1o164dAFlZWYSFhWFhYSFF7BOwsbFhxYoVODk58e233zJw4EDS0tJ46623tI4mhCgFS5cuRafToSgKUVFRagGrKIoUsYVkmJKxZs2a2gYRQpSIJypi82O4GUEUnaWlJQsWLMDJyYkvvviCt99+m0uXLvHJJ58YLfwghCh72rRpU2rjYX18fDh37lye7UOHDmXOnDncvXuX9957j5UrV5KVlUVERARz585VF6MxdYahBH5+fhonEUKUhGIvYkXx0Ol0fP7551SpUoUxY8bw6aefcvHiRRYuXIiNjY3W8YQQJeSfC7yUpN27d5OTk6M+P3LkCOHh4fTs2RO4P93X+vXr+emnn3B2dmb48OF0796dHTt2lFrGJ3HixAkA6tSpo3ESIURJkCLWhOl0Oj788EM8PT0ZMmQIy5YtIzk5mVWrVsmk3UKIJ1atWjWj51OnTsXf35+2bdty69Ytvv32W5YvX0779u0BWLRoEXXr1mXnzp08/fTTWkQulF27dgFyU5cQZVWhithHfSQjwwhKzsCBA3F3d+fFF18kJiaGNm3asGHDBqPFJoQQZYOlpeVDX9PpdNy7d69E9pudnc3SpUuJjIxEp9Oxd+9e9Ho9YWFhapvAwEC8vb2JjY01+SL23r17HDx4EICQkBCN0wghSkKhiljDIHlR+iIiItiyZQudO3fm0KFDhIaGsn79eoKCgrSOJoQoRlpdEFi7di2pqakMHDgQuD9Lgo2NDS4uLkbtXF1d1RkU8pOVlUVWVpb6PC0tDbi/kINer39sDkObgrR9lDNnzpCdnY2trS01atR44v4ep7hylzZzzQ3mm7285C6N4ytUEVuaNxyIvJo0aUJsbCzPPPMMJ0+epEWLFqxYsYJnn31W62hCiGKyaNEio+e3bt1izZo1bN++ncmTJ5fYfr/99ls6deqEh4fHE/UzZcoUJk6cmGf7xo0bcXBwKHA/0dHRT5Tj0KFDAFStWpWoqKgn6qswnjS3Vsw1N5hv9rKeOzMzs4STFLKILc0bDkT+fH19+fvvv3nxxRfZvHkzzz//PJ9++invv/++/IEhRBmQ37zQw4YNo2HDhhw4cKBE9nnu3Dk2bdpktMCKm5sb2dnZpKamGl2NTUlJwc3N7aF9jR49msjISPV5WloaXl5edOzYEScnp8dm0ev1REdHEx4ejrW1ddEOCLh69SpwfwhE586di9xPQRVX7tJmrrnBfLOXl9yGT2FKktzYZYaqVKnCxo0bGT58OF9//TWjRo3i2LFjzJ8/H1tbW63jCSGKmU6nw8LCgvXr15dI/4sWLaJ69ep06dJF3da0aVOsra2JiYmhR48ewP27/c+fP09oaOhD+7K1tc33PGRtbV2oX9iFbf9Phw8fBiAoKKhUC4Unza0Vc80N5pu9rOcujWOTItZMWVtbM3/+fOrXr8+7777L4sWLSUhIYPXq1XnuOBZCmA/DTAAGOTk5JCYmcunSpSf+qD8/ubm5LFq0iAEDBmBl9X+/EpydnRk8eDCRkZFUrlwZJycn3nrrLUJDQ03+pi6AxMREAAICAjROIoQoKVLEmjGdTsfbb79NQEAAvXr1Yvv27TRr1oxVq1bRrFkzreMJIYpg8+bN6opd/zR06NBi39+mTZs4f/48r7zySp7XvvjiCywsLOjRo4fRYgfm4NixYwDUqlVL4yRCiJIiRWwZEBERwc6dO3nuuedISEigVatWzJkzh8GDB2sdTQhRSP379zca367T6ahevTodOnQgPDy82PfXsWPHh86IYGdnx5w5c5gzZ06x77ckpaenq6t1NW7cWNswQogSI0VsGREYGMju3bsZMGAA69at49VXX2Xnzp3Mnj0bOzs7reMJIQpo8eLFWkcwe/Hx8QBUr16dqlWrapxGCFFSLLQOIIqPi4sLa9as4ZNPPsHCwoJvvvmGVq1a5bs2uhDCNB06dIh169Zx+fJlddulS5dYt26dOm2UeDTDcrP16tXTOIkQoiRJEVvGWFhYMHr0aKKioqhSpQp79+6lSZMm/P7771pHE0IUwJAhQ+jVq5fRHf729vb06tWL119/XcNk5sNwU9ejVpkUQpg/zYvYOXPm4OPjg52dHSEhIepa1/k5evQoPXr0wMfHB51Ox8yZM/O0mTBhAjqdzugRGBhYgkdgmsLDw9m7dy/NmjXjxo0bdO7cmffee4/s7GytowkhHiE+Pp7atWtTpUoVdVvlypWpXbs2R48e1TCZ+TB8+uTt7a1xEiFESdK0iP3hhx+IjIxk/Pjx7Nu3j0aNGhEREcGVK1fybZ+ZmYmfnx9Tp0595GTb9evXJykpSX1s3769pA7BpNWsWZNt27bx1ltvATBjxgxatmxJQkKCxsmEEA9z7949kpOTuXfvnrpNr9eTnJxMTk6OhsnMx8mTJwHw9/fXOIkQoiRpWsTOmDGDIUOGMGjQIOrVq8f8+fNxcHBg4cKF+bZv3rw5n332Gb17937kpP5WVla4ubmpj/I8sN/Ozo5Zs2axdu1aKleuzJ49ewgODmbZsmVaRxNC5CMwMJDr16/Tp08fYmNjiY2N5eWXX+batWvl8lOlojh16hQgc8QKUdZpVsRmZ2ezd+9ewsLC/i+MhQVhYWHExsY+Ud+nTp3Cw8MDPz8/+vbty/nz5580rtnr2rUrBw8epE2bNqSnp/Pyyy8zePDgUlnbWAhRcK+++iqKorB69WpatWpFq1at+Pnnn9HpdAwZMkTreCbv9u3bJCcnA1CnTh2N0wghSpJmU2xdu3aNnJwcXF1djba7urpy/PjxIvcbEhLC4sWLCQgIICkpiYkTJ9K6dWuOHDmCo6Njvu/JysoiKytLfW5Y71ev16PX6x+7T0ObgrTVkqurK3/88QeffPIJH3/8Md9//z1RUVFUqlSJDh06aB2vwMzl+/1P5pobzDd7YXObwvENHTqU+Ph45s6dq87fqtPpGDZsGG+88YbG6UzfhQsXgPuztTg7O2ucRghRksrcPLGdOnVSv27YsCEhISHUrFmTH3/88aGT/0+ZMoWJEyfm2b5x40YcHBwKvO/o6OjCB9ZA06ZN+eijj/jyyy+5cuUKnTp14rnnnuPll19+5DANU2Mu3+9/MtfcYL7ZC5rbVD6ZmD17Nu+//z67d+8G7g+lqlmzpsapzINhkQMfHx9tgwghSpxmRWzVqlWxtLQkJSXFaHtKSsojb9oqLBcXF+rUqfPIm5lGjx5NZGSk+jwtLQ0vLy86duyIk5PTY/eh1+uJjo4mPDwca2vrYsld0jp37szgwYPp168f0dHR/Prrr5w8eZLFixfTtGlTreM9kjl+v8F8c4P5Zi9sbsOnMFoyfDLk6empFq737t0jLS0NW1tbs/pDUwuGIrZ27doaJxFClDTNilgbGxuaNm1KTEwM3bp1AyA3N5eYmBiGDx9ebPsxLD/Yr1+/h7Z52C8Ga2vrQv3CLmx7rVWuXJlhw4YxfPhw3njjDU6cOEGrVq344IMP+PDDD03+l6W5fb8NzDU3mG/2guY2hWPr1q0b0dHRHD58mLp16wKQkJBAUFAQ4eHhbNiwQeOEps1wU1etWrU0TiKEKGmazk4QGRnJggULWLJkCfHx8bz55ptkZGQwaNAg4P4a4qNHj1bbZ2dnc+DAAQ4cOEB2djaXLl3iwIEDRldZ33//fbZs2cLZs2f5+++/eeGFF7C0tKRPnz6lfnzmolOnThw+fJhevXqRk5PDRx99RHBwMDt27NA6mhDlzu7du/H391cLWLg/Y4Gfn586vEA8nOGeCrkSK0TZp2kR26tXL6ZPn864ceNo3LgxBw4cICoqSr3Z6/z58yQlJantL1++THBwMMHBwSQlJTF9+nSCg4N59dVX1TYXL16kT58+BAQE8NJLL1GlShV27txJtWrVSv34zEmVKlVYuXIlP/74I9WrVyc+Pp5WrVoxbNgwk/iIVYjy4vbt2/neYKbX67l9+7YGicyLYY5YmY5MiLJP8xW7hg8fzrlz58jKyiIuLo6QkBD1tc2bN7N48WL1uY+PD4qi5Hls3rxZbbNy5UouX75MVlYWFy9eZOXKlTLhdSH07NmT+Ph4XnnlFQDmzp1LvXr1WLduncbJhCgfvLy8OHfuHDNmzFBnJ5g5cyZnz56lRo0aGqczbXfv3uXSpUuADCcQojzQvIgVpqdy5cp8++23xMTE4O/vz6VLl+jatSsvvviiOn2NEKJkdOvWDUVRGDlyJBUqVMDBwYH33nsPnU5H9+7dtY5n0hITE1EUhYoVK5brRW6EKC+kiBUP1b59ew4fPsx//vMfLC0tWbVqFYGBgXzyySdG8+oKIYrPhAkTCA4ORlEU7t69y927d1EUheDgYMaNG6d1PJMWHx8P3B9KoNPpNE4jhChpUsSKR7K3t2fq1Kns27ePVq1akZmZyYcffkiDBg34/ffftY4nRJlTsWJFdu7cyZIlSxg6dChDhw5lyZIlxMbGUrFiRa3jmTTDTb6yUpcQ5YMUsaJAGjZsyNatW1m6dClubm4kJCTQuXNnunXrRmJiotbxhChTrK2t6devH//73//43//+R79+/bhy5QqffPKJ1tFMmmFmAilihSgfpIgVBabT6ejbty8nTpzgvffew8rKil9++YXAwEBGjRpFamqq1hGFKFPu3r3L8uXL6dixIz4+PjKc4DGOHTsGYDQ9mRCi7JIiVhSak5MT06dP5+DBg3To0IHs7Gw+++wzatWqxaxZs8jOztY6ohBm7e+//+a1117D3d2dfv36ERMTQ05OjjpbgchLURROnDgBSBErRHkhRawosnr16hEdHc1vv/1G3bp1uX79Ou+88w7169dn9erV8gtXiEK4dOkSn3zyCQEBAbRu3Zpvv/2WW7duGU2zde7cOY1Tmq6bN2+qnwbJtIpClA9SxIonotPp6NKlC4cOHWL+/PlUr16dhIQEevToQevWrdm2bZvWEYUwCzVr1mTs2LGcOnUKRVEICgris88+o0KFCgC8/fbbMk/sIxiWm3Vzc8PBwUHjNEKI0iBFrCgWVlZWvP766yQkJDB27Fjs7e3ZsWMHbdq0ISIigl27dmkdUQiTlpubC0Dz5s3V5bUNY8/F4xnGwzZo0EDjJEKI0iJFrChWjo6OTJo0iVOnTvHGG29gZWXFxo0bCQkJoWvXrhw8eFDriEKYtD179tCpUydGjRrFoUOHtI5jNmRmAiHKHyliRYnw9PRk3rx5nDx5koEDB2JhYcG6deto3LgxL730knrVRAhx38KFC2nTpg0ASUlJfP755wQHB3Pr1i3g/4o0kT/DcILAwECNkwghSosUsaJE+fr6smjRIo4dO0afPn3Q6XT89NNP1K9fn+7du7Nnzx6tIwphEgYOHMhff/3F6dOnGTduHD4+PkY3R9avX5969eoV+34vXbrEyy+/TJUqVbC3tycoKMjo51JRFMaNG4e7uzv29vaEhYWpBaMpMSyJ7e3trXESIURpkSJWlIqAgACWL1/OwYMH6dGjBzqdjjVr1tC8eXMiIiLYsmWLzGYgBODj48OECRM4ffo0f/31F/3798fBwcFoCqnicvPmTVq2bIm1tTW///47x44d4/PPP6dSpUpqm2nTpjFr1izmz59PXFwcFSpUICIigrt37xZrlid16dIlALn5TYhyRIpYUaqCgoL4+eefOXLkCP3798fS0pKNGzfSrl07WrduzYYNG6SYFeL/a9u2LYsXLyY5OdlouEFx+fTTT/Hy8mLRokU89dRT+Pr60rFjR3WKKkVRmDlzJmPGjKFr1640bNiQ7777jsuXL7N27dpizfIkcnNzuXr1KgCurq4apxFClBa57VVool69eixZsoQJEybw2WefsXDhQnbs2EGXLl2oX78+I0aM4OWXX8bOzk7rqEJorkKFCgwcOJCBAwcWa7/r1q0jIiKCnj17smXLFjw9PRk6dChDhgwBIDExkeTkZMLCwtT3ODs7ExISQmxsLL17987TZ1ZWFllZWerztLQ0APR6PXq9/rGZDG0K0tYgKSmJe/fuYWFhQeXKlQv13uJSlNymwFxzg/lmLy+5S+P4pIgVmvL19WXu3LmMHTuWGTNmMH/+fI4ePcqQIUP44IMPePPNNxk6dKhcXRGiBJw5c4Z58+YRGRnJBx98wO7du3n77bexsbFhwIABJCcnA3mvbrq6uqqv/dOUKVOYOHFinu0bN24s1Pyt0dHRBW4bHx8PQJUqVQr1vpKg9f6Lylxzg/lmL+u5MzMzSziJFLHCRLi7u/PZZ5/x4Ycf8s033zB79mzOnz/PpEmTmDp1Kn379uXdd98lKChI66hClBm5ubk0a9aMTz75BIDg4GCOHDnC/PnzGTBgQJH6HD16NJGRkerztLQ0vLy86NixI05OTo99v16vJzo6mvDwcKytrQu0zxs3bgD354jt3LlzkXI/qaLkNgXmmhvMN3t5yW34FKYkSRErTIqLiwvvv/8+I0aMYPXq1XzxxRfs3LmTRYsWsWjRItq0acOQIUNkmIEQxcDd3T3PjAd169Zl1apVwP3VrwBSUlJwd3dX26SkpNC4ceN8+7S1tcXW1jbPdmtr60L9wi5M+8uXLwP3b4rTuigo7HGaCnPNDeabvaznLo1jkxu7hEmysrLipZdeIjY2lr///puePXtiYWHB1q1b6devH6+++ipjxozh7NmzWkcVwmy1bNkyz4wHJ0+epGbNmsD94T5ubm7ExMSor6elpREXF0doaGipZn0Uw/RaXl5eGicRQpQmKWKFyQsNDeXHH3/k3Llz6nyVt27dYtq0afj5+fHss8+yfv16cnJytI4qhFl599132blzJ5988gkJCQksX76cr7/+mmHDhgGg0+kYMWIEkydPZt26dRw+fJj+/fvj4eFBt27dtA3/AMP0Wp6enhonEUKUJilihdmoUaMGEydOJCEhgVGjRtG+fXsURWH9+vU8++yz+Pr6MnbsWBISErSOKoRZaN68OWvWrGHFihU0aNCAjz76iJkzZ9K3b1+1zahRo3jrrbd47bXXaN68Oenp6URFRZnUkB7DlViZI1aI8kWKWGF2rK2tadGiBVFRUZw4cYLIyEgqVarEhQsXmDx5MrVr16ZNmzYsWrSI9PR0reMKYdKeffZZDh8+zN27d4mPj1en1zLQ6XRMmjSJ5ORk7t69y6ZNm6hTp45GafNSFIXTp08D94c/CCHKD82L2Dlz5uDj44OdnR0hISHs2rXroW2PHj1Kjx498PHxQafTMXPmzCfuU5i3OnXq8Pnnn3P58mVWrlzJM888g4WFBdu2beOVV17Bzc2NgQMHsmXLFnJzc7WOK4QoZteuXVP/WPXz89M4jRCiNGlaxP7www9ERkYyfvx49u3bR6NGjYiIiODKlSv5ts/MzMTPz4+pU6eqd80+aZ+ibLCzs6NXr178/vvvnD9/nk8++YTatWuTkZHBkiVLaNeuHT4+PowaNYr9+/fLqmBClBHnz58H7s+0kN+sCEKIskvTInbGjBkMGTKEQYMGUa9ePebPn4+DgwMLFy7Mt33z5s357LPP6N2790NPVoXtU5Q9np6ejB49mhMnTrBjxw5effVVHB0duXDhAp999hlNmjShbt26TJw4kZMnT2odVwjxBM6dOwfIzARClEeazRObnZ3N3r17GT16tLrNwsKCsLAwYmNjS7VPLZZJNAXlIXfz5s1p3rw5M2bM4Pfff+eHH35g/fr1nDhxggkTJjBhwgSCg4Pp1asX3bt3x8fHxyRymxpzzW6KyySK4mW4EmuYFkwIUX5oVsReu3aNnJycfJczPH78eKn2qcUyiaakvOS2tbWlf//+vPjii8TFxbFt2zYOHDjA/v372b9/P//973/x8/MjNDSUp59+usSu7Jjr9xvMN7spLZMoipfMEStE+SUrdqHNMommoDznfvHFFwG4evUqq1ev5qeffmL79u2cOXOGM2fOsGzZMgICAujWrRsvvPACwcHB6HQ6zXNrxVyzm+IyiaJ4nTlzBpCZCYQojzQrYqtWrYqlpSUpKSlG21NSUh5601ZJ9anFMommpDzn9vDwYPjw4QwfPpyrV6+ybt06Vq9eTXR0NCdOnODTTz/l008/xdvbm27dutGlSxfatm37RDeQmOv3G8w3uyktkyiKlxSxQpRfmt3YZWNjQ9OmTY2WM8zNzSUmJqbIyxmWRJ+i/KhWrRqDBw9m/fr1XL16leXLl/Piiy/i4ODA+fPnmTVrFhEREVSpUoVu3bqxYMECdaUgIUTpUxRFLWL9/f01TiOEKG2aDieIjIxkwIABNGvWjKeeeoqZM2eSkZHBoEGDAOjfvz+enp5MmTIFuH/j1rFjx9SvL126xIEDB6hYsSK1atUqUJ9CFISzszN9+vShT58+3Llzh40bN/Lbb7+xfv16kpKS+OWXX/jll18ACA4OpkuXLnTp0oXmzZtjaWmpcXohyoebN2+qc8TKjV1ClD+aFrG9evXi6tWrjBs3juTkZBo3bkxUVJR6Y9b58+exsPi/i8WXL18mODhYfT59+nSmT59O27Zt2bx5c4H6FKKw7O3t6dq1K127dkVRFPbv38/69etZv349u3btUm8Mmzx5MpUrV6ZDhw6Eh4cTHh5eorMdCFHeGW7qql69Ovb29hqnEUKUNs1v7DKMR8yPoTA18PHxKdAk9Y/qU4gnodPpaNKkCU2aNGHs2LFcuXKF33//nfXr1/PHH39w48YNfvrpJ3766Sfg/kechoK2devWGqcXomy5ePEiADVq1NA4iRBCC5oXsUKYs+rVqzNgwAAGDBiAXq9n165dREdHs2nTJnbu3Mnp06c5ffo08+fPx8LCglq1arFz5046dOhAaGgoFSpU0PoQhDBbhiuxnp6eGicRQmhB0xW7hChLrK2tadmyJRMmTGD79u3cuHGDX375heHDhxMQEEBubi4nT55k6tSphIeH4+LiQosWLRg9ejRRUVEyvZMQhZSYmAggw3aEKKfkSqwQJcTJyYnnn3+e559/Hrg/FdDMmTO5du0a27Zt4+LFi8TGxhIbG8vUqVOxsLCgSZMmtG3blrZt29K6dWtcXFy0PQghTJhhZgI/Pz+NkwghtCBFrBClxMvLiw4dOtC5c2esrKw4e/YsW7ZsUR+JiYns2bOHPXv28Pnnn6PT6ahXrx6hoaG0aNGC0NBQ6tSpY3SzoxDlmRSxQpRvUsQKoQGdToevry++vr4MHDgQuD++b+vWrWpRe/LkSY4ePcrRo0f55ptvAKhUqRKhoaHq46mnnsLR0VHDIxFCG4qikJCQAMgcsUKUV1LECmEivLy86Nu3L3379gXgypUr6nCD2NhYdu/ezc2bN9mwYQMbNmwAwMLCgqCgIJ5++mmaNWtGs2bNqF+/vqw8Jcq8q1evkpaWhk6nkyJWiHJKilghTFT16tXV+WkB9Ho9Bw8eJDY2lr///pvY2FjOnTvHwYMHOXjwIF999RVwfxnlxo0b06xZM5o3b06zZs0IDAyURRhEmXLy5Eng/h9/dnZ2GqcRQmhBilghzIS1tbV6tfWtt94CICkpib///pvdu3er42lv3bpFXFwccXFx6nsdHBxo0qQJzZo1o2nTpjRu3JiAgAC5YivM1tGjRwGoW7euxkmEEFqRIlYIM+bu7k6PHj3o0aMHALm5uZw5c4Y9e/aohe2+fftIT09n+/btbN++XX2vjY0N9evXp3HjxjRq1Eh9VKpUSavDEaLA9u3bB0CjRo00TiKE0IoUsUKUIYYFFWrVqkXv3r0ByMnJ4eTJk+qV2r1793Lo0CFu376tLpn7IC8vrzyFrZeXlxaHI8RDGYrY5s2ba5xECKEVKWKFKOMsLS2pW7cudevWpV+/fsD9K7Znz57lwIED6pjagwcPcvbsWS5cuMCFCxf49ddf1T7s7Oxwd3fnhx9+ICgoiPr161OvXj18fX1lrK0odbm5uRw/fhyA+vXra5xGCKEVKWKFKIcsLCzw8/PDz8+P7t27q9tv3brFoUOHjIrbI0eOcPfuXRITE0lMTGTFihVqezs7O+rWrasWtfXr16d+/fr4+PhIcStKTEJCAunp6djY2FCrVi2t4wghNCJFrBBC5ezsTOvWrWndurW6zTAc4fvvv8fBwYHjx49z9OhRjh8/zt27d/MdkmBnZ0ft2rUJCAggICCAOnXqqP+VMbfiScXExADw1FNPyc2JQpRjUsQKIR7J0tKSWrVqERISQufOndWiIScnhzNnznDs2DF1UYYHi9vDhw9z+PDhPP1Vq1bNqKg1FLp+fn7Y2tqW9uGVaxMmTGDixIlG2wICAtSP6u/evct7773HypUrycrKIiIigrlz5+Lq6qpFXNWaNWsAeOaZZzTNIYTQlhSxQogisbS0pHbt2tSuXVudyxbuF7eJiYmcOHGCkydPGv338uXLXL16latXr7Jjxw6j/iwsLPDx8cHf3199+Pn5qf+VlclKRv369dm0aZP63Mrq/34tvPvuu6xfv56ffvoJZ2dnhg8fTvfu3fP8vytNFy5cIDo6GoBevXpplkMIoT0pYoUQxcpw5bZWrVp06dLF6LXbt29z6tSpPMXtiRMnSE9P58yZM5w5c0YtUh5UrVq1PMWt4eHm5oZOpyutQyxTrKyscHNzy7P91q1bfPvttyxfvpz27dsDsGjRIurWrcvOnTt5+umnSzsqAHPnzgWgRYsWMh5WiHJOilghRKlxdHSkSZMmNGnSxGi7oigkJydz8uRJzpw5w+nTp9X/nj59muvXr6tXcHfu3JmnX3t7e/z8/PDx8VEfvr6+1KhRg7S0NBRFKa1DNDunTp3Cw8MDOzs7QkNDmTJlCt7e3uzduxe9Xk9YWJjaNjAwEG9vb2JjY0ukiNXr9Zw7d46kpCROnDiBTqfj3r176uPYsWN89tlnAIwcObLY9y+EMC9SxAohNKfT6XB3d8fd3Z22bdvmef3WrVt5ilvDf8+fP8+dO3fUMbn5adGiBf7+/iV9GGYnJCSExYsXExAQQFJSEhMnTqR169YcOXKE5ORkbGxscHFxMXqPq6srycnJD+0zKyuLrKws9XlaWhpwv0DV6/WPzJOQkEC9evUem7tJkyZ06tTpsf2VJkMWU8pUEOaaG8w3e3nJXRrHJ0WsEMLkOTs7ExwcTHBwcJ7X9Ho958+f5/Tp05w9e1Z9JCYmcvbsWa5du4anp6cGqU1fp06d1K8bNmxISEgINWvW5Mcff8Te3r5IfU6ZMiXPzWIAGzduxMHB4ZHvvXLlCjY2NlhYWGBpaZnnYW1tTZMmTejRowdRUVFFylfS8hsKYw7MNTeYb/aynjszM7OEk0gRK4Qwc9bW1urY2H/S6/X88ssvMmdtAbm4uFCnTh0SEhIIDw8nOzub1NRUo6uxKSkp+Y6hNRg9ejSRkZHq87S0NLy8vOjYsSNOTk6PzdC3b1+io6MJDw83q+mz9Hq95C5l5pq9vOQ2fApTkqSIFUKUaeb0S0Jr6enpnD59mn79+tG0aVOsra2JiYmhR48eAJw4cYLz588TGhr60D5sbW3znSrN2tq6UP8vCtveVEju0meu2ct67tI4NilihRCinHr//fd57rnnqFmzJpcvX2b8+PFYWlrSp08fnJ2dGTx4MJGRkVSuXBknJyfeeustQkNDNZuZQAghHmShdQCAOXPm4OPjg52dHSEhIezateuR7X/66ScCAwOxs7MjKCiIDRs2GL0+cOBAdDqd0UMmxRZCCGMXL16kT58+BAQE8NJLL1GlShV27txJtWrVAPjiiy949tln6dGjB23atMHNzY3Vq1drnFoIIe7T/ErsDz/8QGRkJPPnzyckJISZM2cSERHBiRMnqF69ep72f//9N3369GHKlCk8++yzLF++nG7durFv3z4aNGigtnvmmWdYtGiR+lxWAhJCCGMrV6585Ot2dnbMmTOHOXPmlFIiIYQoOM2vxM6YMYMhQ4YwaNAg6tWrx/z583FwcGDhwoX5tv/yyy955plnGDlyJHXr1uWjjz6iSZMm/O9//zNqZ2tri5ubm/qQ9dqFEEIIIcoOTa/EZmdns3fvXkaPHq1us7CwICwsjNjY2HzfExsba3TnK0BERARr16412rZ582aqV69OpUqVaN++PZMnT6ZKlSr59vkk8xoa2j34X3MhuUuXueYG881uivMaCiGEKB6aFrHXrl0jJycHV1dXo+2urq4cP3483/ckJyfn2/7BybefeeYZunfvjq+vL6dPn+aDDz6gU6dOxMbG5jvVzsPmNVy7du1j5zV80C+//FLgtqZEcpcuc80N5pu9oLkN8xrKCl/Fx/C9LOh0O3q9nszMTNLS0szqzm3JXfrMNXt5yW34mS/J86nmY2JLQu/evdWvg4KCaNiwIf7+/mzevJkOHTrkaf/PeQ0vXbpEvXr1ePXVV0slrxDCtNy+fRtnZ2etY5QJt2/fBsDLy0vjJEIILZTk+VTTIrZq1apYWlqSkpJitP1Rk2m7ubkVqj2An58fVatWJSEhId8i9p/zGlasWJELFy7g6OiITqd77HEYJvO+cOFCgSbzNhWSu3SZa24w3+yFza0oCrdv38bDw6MU0pUPHh4ecj41YeaaG8w3e3nJXRrnU02LWBsbG5o2bUpMTAzdunUDIDc3l5iYGIYPH57ve0JDQ4mJiWHEiBHqtujo6EdOvn3x4kWuX7+Ou7t7gXJZWFhQo0aNAh+HgZOTk1n9gzSQ3KXLXHOD+WYvTG65Alu85HxqHsw1N5hv9vKQu6TPp5rPThAZGcmCBQtYsmQJ8fHxvPnmm2RkZDBo0CAA+vfvb3Tj1zvvvENUVBSff/45x48fZ8KECezZs0ctetPT0xk5ciQ7d+7k7NmzxMTE0LVrV2rVqkVERIQmxyiEEEIIIYqX5mNie/XqxdWrVxk3bhzJyck0btyYqKgo9eat8+fPY2Hxf7V2ixYtWL58OWPGjOGDDz6gdu3arF27Vp0j1tLSkkOHDrFkyRJSU1Px8PCgY8eOfPTRRzJXrBBCCCFEGaF5EQswfPjwhw4f2Lx5c55tPXv2pGfPnvm2t7e3548//ijOeI9la2vL+PHjza5Iltyly1xzg/lmN9fc5Zm5/j+T3KXPXLNL7uKjU2QuGSGEEEIIYWY0HxMrhBBCCCFEYUkRK4QQQgghzI4UsUIIIYQQwuxIEfuE5syZg4+PD3Z2doSEhLBr164S29eUKVNo3rw5jo6OVK9enW7dunHixAmjNnfv3mXYsGFUqVKFihUr0qNHjzyLQ5w/f54uXbrg4OBA9erVGTlyJPfu3TNqs3nzZpo0aYKtrS21atVi8eLFefIU9dinTp2KTqczmuvXlHNfunSJl19+mSpVqmBvb09QUBB79uxRX1cUhXHjxuHu7o69vT1hYWGcOnXKqI8bN27Qt29fnJyccHFxYfDgwaSnpxu1OXToEK1bt8bOzg4vLy+mTZuWJ8tPP/1EYGAgdnZ2BAUFsWHDhnwz5+TkMHbsWHx9fbG3t8ff35+PPvrIaPk/U8i9detWnnvuOTw8PNDpdKxdu9bofaaQsTBZxJOR86mcT03pZ97AXM6nUA7PqYoospUrVyo2NjbKwoULlaNHjypDhgxRXFxclJSUlBLZX0REhLJo0SLlyJEjyoEDB5TOnTsr3t7eSnp6utrmjTfeULy8vJSYmBhlz549ytNPP620aNFCff3evXtKgwYNlLCwMGX//v3Khg0blKpVqyqjR49W25w5c0ZxcHBQIiMjlWPHjimzZ89WLC0tlaioqCc+9l27dik+Pj5Kw4YNlXfeecfkc9+4cUOpWbOmMnDgQCUuLk45c+aM8scffygJCQlqm6lTpyrOzs7K2rVrlYMHDyrPP/+84uvrq9y5c0dt88wzzyiNGjVSdu7cqWzbtk2pVauW0qdPH/X1W7duKa6urkrfvn2VI0eOKCtWrFDs7e2Vr776Sm2zY8cOxdLSUpk2bZpy7NgxZcyYMYq1tbVy+PDhPLk//vhjpUqVKspvv/2mJCYmKj/99JNSsWJF5csvvzSp3Bs2bFA+/PBDZfXq1QqgrFmzxug4TCFjYbKIopPzqZxPFcW0fuYNzOV8qihKuTunShH7BJ566ill2LBh6vOcnBzFw8NDmTJlSqns/8qVKwqgbNmyRVEURUlNTVWsra2Vn376SW0THx+vAEpsbKyiKPf/gVtYWCjJyclqm3nz5ilOTk5KVlaWoiiKMmrUKKV+/fpG++rVq5cSERGhPi/Ksd++fVupXbu2Eh0drbRt21Y96Zpy7v/85z9Kq1atHnpMubm5ipubm/LZZ5+p21JTUxVbW1tlxYoViqIoyrFjxxRA2b17t9rm999/V3Q6nXLp0iVFURRl7ty5SqVKldRjMew7ICBAff7SSy8pXbp0Mdp/SEiI8vrrr+fJ1aVLF+WVV14x2ta9e3elb9++Jpv7nydcU8pYkCziycj5VM6npvQz/yBzPJ8qSvk4p8pwgiLKzs5m7969hIWFqdssLCwICwsjNja2VDLcunULgMqVKwOwd+9e9Hq9UabAwEC8vb3VTLGxsQQFBamLSQBERESQlpbG0aNH1TYP9mFoY+ijqMc+bNgwunTpkqdvU869bt06mjVrRs+ePalevTrBwcEsWLBAfT0xMZHk5GSjPp2dnQkJCTHK7uLiQrNmzdQ2YWFhWFhYEBcXp7Zp06YNNjY2RtlPnDjBzZs3C3R8D2rRogUxMTGcPHkSgIMHD7J9+3Y6depk0rkfZEoZC5JFFJ2cT+V8Cqb1M/+gsnA+NbWcxXVOlSK2iK5du0ZOTo7RSQDA1dWV5OTkEt9/bm4uI0aMoGXLlupqZcnJydjY2ODi4vLQTMnJyflmNrz2qDZpaWncuXOnSMe+cuVK9u3bx5QpU/K8Zsq5z5w5w7x586hduzZ//PEHb775Jm+//TZLliwx2vej+kxOTqZ69epGr1tZWVG5cuViOb78sv/3v/+ld+/eBAYGYm1tTXBwMCNGjKBv374mnftBppSxIFlE0cn5VM6nD+7bFH7mH1QWzqemlrO4zqkmsWKXKLxhw4Zx5MgRtm/frnWUx7pw4QLvvPMO0dHR2NnZaR2nUHJzc2nWrBmffPIJAMHBwRw5coT58+czYMAAjdM93I8//siyZctYvnw59evX58CBA4wYMQIPDw+Tzi2EFuR8WjrkfCqKm1yJLaKqVatiaWmZ547PlJQU3NzcSnTfw4cP57fffuOvv/6iRo0a6nY3Nzeys7NJTU19aCY3N7d8Mxtee1QbJycn7O3tC33se/fu5cqVKzRp0gQrKyusrKzYsmULs2bNwsrKCldXV5PMDeDu7k69evWMttWtW5fz588b7ftRfbq5uXHlyhWj1+/du8eNGzeK5fjyyz5y5Ej16kFQUBD9+vXj3XffVa/cmGruB5lSxoJkEUUn51M5nz64b1P4mX9QWTifmlrO4jqnShFbRDY2NjRt2pSYmBh1W25uLjExMYSGhpbIPhVFYfjw4axZs4Y///wTX19fo9ebNm2KtbW1UaYTJ05w/vx5NVNoaCiHDx82+kcaHR2Nk5OTenIJDQ016sPQxtBHYY+9Q4cOHD58mAMHDqiPZs2a0bdvX/VrU8wN0LJlyzzT7pw8eZKaNWsC4Ovri5ubm1GfaWlpxMXFGWVPTU1l7969aps///yT3NxcQkJC1DZbt25Fr9cbZQ8ICKBSpUoFOr4HZWZmYmFh/ONtaWlJbm6uSed+kCllLEgWUXRyPpXzKZjWz/yDysL51NRyFts5tcC3gIk8Vq5cqdja2iqLFy9Wjh07prz22muKi4uL0R2fxenNN99UnJ2dlc2bNytJSUnqIzMzU23zxhtvKN7e3sqff/6p7NmzRwkNDVVCQ0PV1w1Tq3Ts2FE5cOCAEhUVpVSrVi3fqVVGjhypxMfHK3PmzMl3apUnOfYH76Y15dy7du1SrKyslI8//lg5deqUsmzZMsXBwUFZunSp2mbq1KmKi4uL8ssvvyiHDh1Sunbtmu+UJcHBwUpcXJyyfft2pXbt2kZTlqSmpiqurq5Kv379lCNHjigrV65UHBwc8kxZYmVlpUyfPl2Jj49Xxo8f/9ApYQYMGKB4enqqU8KsXr1aqVq1qjJq1CiTyn379m1l//79yv79+xVAmTFjhrJ//37l3LlzJpOxMN8vUXRyPpXzqaKY1s+8gbmcTxVFKXfnVClin9Ds2bMVb29vxcbGRnnqqaeUnTt3lti+gHwfixYtUtvcuXNHGTp0qFKpUiXFwcFBeeGFF5SkpCSjfs6ePat06tRJsbe3V6pWraq89957il6vN2rz119/KY0bN1ZsbGwUPz8/o30YPMmx//Oka8q5f/31V6VBgwaKra2tEhgYqHz99ddGr+fm5ipjx45VXF1dFVtbW6VDhw7KiRMnjNpcv35d6dOnj1KxYkXFyclJGTRokHL79m2jNgcPHlRatWql2NraKp6ensrUqVPzZPnxxx+VOnXqKDY2Nkr9+vWV9evX55s5LS1NeeeddxRvb2/Fzs5O8fPzUz788EOjKVFMIfdff/2V77/pAQMGmEzGwny/xJOR86mcT03pZ97AXM6nilL+zqk6RXlgyQkhhBBCCCHMgIyJFUIIIYQQZkeKWCGEEEIIYXakiBVCCCGEEGZHilghhBBCCGF2pIgVQgghhBBmR4pYIYQQQghhdqSIFUIIIYQQZkeKWCGEEEIIYXakiBWimAwcOBCdTke7du20jiKEEGZNzqeiIKSIFWarXbt26HS6fB9r167VOp4QQpgNOZ8Kc2SldQAhnpSNjQ3BwcFG2ypXrqxRGiGEMF9yPhXmRK7ECrPn7u7Ozp07jR5t2rRh8eLF6pWEzZs3ExwcjJ2dHQ0bNmTLli1GfWzfvp2IiAicnZ2xtbWlbt26fPbZZ+Tk5KhtFEVh7ty5BAcHY29vj6OjI0899RQHDhzIk+mbb77B19cXR0dHnn32WZKTk0v62yCEEE9MzqfCrChCmKm2bdsqgFKzZs18X1+0aJECKIDi4OCg1K1bV7G3t1cApUKFCsqlS5cURVGUv/76S7GyslIApVKlSkrt2rXV97366qtqf8OHD1e3V6lSRalfv75iY2OjrFmzRlEURRkwYIACKPb29oqdnZ1RP//+979L+tshhBBFJudTYY7kSqwwe+fOncszhuufZsyYwbFjx9i9ezdWVlZkZGQwa9YsAMaPH8+9e/eoWbMmZ86c4eTJk7zzzjsAfPvtt5w5c4azZ88yZ84cAF544QUuX77MkSNHuHjxIs2aNTPaV1ZWFjt37uTkyZO88MILAMTExJTkt0AIIYqFnE+FOZExscLs5TeG65/69OkDQP369QkKCmL//v0cPnwYgN27dwPQuXNnXFxcAPj3v//Nl19+iaIo7N27F7j/8RfAe++9h42NDQDVqlXLs6+goCAaNWoEQL169VizZg0pKSlPeJRCCFHy5HwqzIkUscLsGcZwmQrDiRvAykp+xIQQ5kPOp8KcyHACUS788MMPAMTHx6tXDIKCggBo3rw5ABs2bCA1NRWAFStWAKDT6WjatCnNmzdXP1abOXMm2dnZAFy/fp2LFy+W2nEIIYTW5HwqTIUUscLsJSUl8fTTTxs9DCdZg/fff5/69evTrFkz7t27h4ODA2+99RYAEydOxMrKinPnzuHn50edOnWYOXMmAIMHD8bPzw8fHx+GDRsGwM8//4ynpydBQUF4enqyZ8+eUj1eIYQoKXI+FeZEilhh9rKzs4mLizN6JCUlGbX5/fffsbOz4969ezRo0IBff/0VT09P4P4k33/99Rfh4eHk5ORw9uxZAgMD+fTTT5k/f77ax6xZs5gzZw6NGzcmPT2dxMREGjZsiI+PT2kerhBClBg5nwpzolMMo6uFKGMWL17MoEGDgP+7iUAIIUThyflUmCK5EiuEEEIIIcyOFLFCCCGEEMLsyHACIYQQQghhduRKrBBCCCGEMDtSxAohhBBCCLMjRawQQgghhDA7UsQKIYQQQgizI0WsEEIIIYQwO1LECiGEEEIIsyNFrBBCCCGEMDtSxAohhBBCCLMjRawQQgghhDA7/w+2k+2B1XfxSAAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA3V9JREFUeJzsnXd4FFXXwH93tmZTSEKRXsQuIooNGzZAUBEVuwKvvfdePrH7Wl9sKDZURBQbKkVRQbGLYsEOKiAd0rPZze7O+f6YzZIlW5NN5f6eJ0+yd+7ce2ayM3Pm3FOUiAgajUaj0Wg0bQSjuQXQaDQajUajySRaudFoNBqNRtOm0MqNRqPRaDSaNoVWbjQajUaj0bQptHKj0Wg0Go2mTaGVG41Go9FoNG0KrdxoNBqNRqNpU2jlRqPRaDQaTZtCKzcajUaj0WjaFFq50WjSZNy4cSilUEoxf/785hanXowfPz5yDJMnT4609+7dO9KeaSZPnhwZe/z48RkfvyVQXV3NzTffTN++fXE4HCilGDVqVHOLFaHm/Pfu3bu5RWlRsqRDvGunqcfQJMbe3AJoWjbjx4/n1ltvjXweMmQI77//flSfb7/9lj322COqraqqCrfb3SQyaloONUpLfn4+l112WbPK0hw8+OCD3HHHHWnts6WfM42mMdDKjSYtPvzwQ5YtW0avXr0ibU899VQzSqTJJK+99ho+n6/e+9cowr169arzoB4xYgQLFiwAoGfPnvWeoyXz7rvvRv5+/PHH2WWXXWjfvn3CfRKds0xTc/71i4emraOVG01amKbJM888w2233QZAZWUlU6dObWaptgy8Xi8ej6dR59jcApdJOnXqRKdOnRpt/JbAqlWrIn+fd955jbK8V0N9vg/7779/I0mj0bQstM+NJmVyc3MBeO655zBNE4BXXnmF8vLyyLZYXHnlley777506dIFl8tFTk4Ou+++O/fffz/BYDCqb+11+D///JMjjzySnJwcOnTowIUXXkhlZWWk7z///BPpf9BBB/HNN98wePBgPB4PXbt25eabb64zvojw3HPPsd9++5GXl0dWVha77rorEyZMiBxTbR599FH69u1LVlYWe+21Fx999FFa52z+/PkRGceNG8d7773HHnvsgdvtpk+fPvzvf/+L6r+5X8oTTzzB9ttvj8Ph4NVXX430mzFjBocddhgFBQW4XC623357br31VqqqqurI8Oqrr7Lzzjvjdrvp169f1Dibk8jn5uWXX+bggw+OzNm7d29OP/10SktLIz4ENSxbtqyOT0Uin5slS5bwn//8hx49euB0Omnfvj0jRozgww8/THo+99xzT9xuNz179uThhx+O6l9VVcXVV1/Ntttui8vlIjs7mz59+nDsscfy5ptvxj0Ptfnuu+84/vjj6dy5M06nk86dOzN69Gi+/fbbSJ+aY/v7778jbYZhJPQvqs85i/V9qO/1tbnsNXNMmTKFfv364XK52G677WJ+X9avX88VV1wROa8FBQUcccQRfPnll3X6btiwgTFjxtCuXTvy8/MZM2YMGzZsSHrea1Pbz2327NlccskltG/fnsLCQi666CL8fj/Lly9n5MiR5OTk0LlzZ2666aY617SIMGnSJPbZZx9yc3Nxu93ssMMO3HDDDZSWltaZN51rB+DHH3/k5JNPpkuXLjidTrp168ZZZ53Fv//+m9bxajKAaDQJuOWWWwQQQMaNGycOh0MAmTlzpoiI7L333gLIOeecE+kHSFVVVWQMl8sVta32z3/+85+o+Wra8/PzZauttqrT//DDD4/0/fvvvyPt3bt3l+zs7Dr9zz333Kjxx4wZE1eWE088MarvfffdV6ePw+GQHXfcMfJ53rx5Cc/fvHnzIn379u0rNputzph33313pP9zzz0Xad96662j+j333HMiInLzzTfHPYYDDjhA/H5/ZLxXX31VlFJ1+vXv37/OuCIivXr1irTX5owzzog7599//x31Pdn8p1evXnWO7ZZbbomM/dVXX0lubm7MfZVS8vjjj8c8n7169RLDMOrsM3fu3JTkPvXUUxP+70REZsyYEfnOx/ouzJgxo86xbf5T+1hrk+45i/d9qM/1VTN+sjkAMQxDfvvtt0j/ZcuWSffu3ZOeExERv98vu+22W8LvX21Z4jF27Nio62jz8U4//XTp06dPnfannnoqMoZpmnLSSSfFPVc77LCDFBUVRfqne+3MmjUr7v+ic+fO8tdff8X839ceQ5M5tHKjSUjti/Daa6+VY445RgA55phj5Mcff4xs+/rrr6Mu5trKzW233SYvv/yyzJkzR+bPny9vvPFGRClSSsmKFSsifWuPMXDgQHnrrbfkkUceEY/HE2l/++23RSRauQFk6NCh8s4778jtt98epUT88MMPIiIyffr0SNv2228vL7/8srzzzjuyzz77RNqnTZsmIiJFRUWSlZUVab/44otl5syZctppp0XNmY5yA8gpp5wiM2fOlMsvvzzS5nK5ZP369SJS9yE5bNgweeutt+TVV1+Vr7/+Ouo8d+nSRZ555hmZM2eOHHHEEZH2e+65R0REgsGgdOvWLdJ+0kkn1Zl785trLOXmtddei7TZbDa56qqrZNasWfLCCy/IkCFD5J9//pFly5bJggULom7mCxYskAULFsg333xT59hqHvimacpOO+0UaR89erTMnDlTbr755oji4nQ6Zfny5THP59FHHy3vvPNO1ENr9OjREdnbt28feYC+9tpr8v7778szzzwjY8aMkYsuuijh/66iokI6dOgQGff888+XWbNmyQUXXBBp69Chg1RUVMjatWtlwYIF0rlz58i2muNftmxZzPHTPWexvg8i9bu+4ik3gJx55pny7rvvyqGHHhppu+qqqyL9a3/XxowZI3PmzJGJEydKTk6OANK+fXupqKgQEZEnnngi0rd9+/by7LPPyvTp06OUqHSVm+zsbJk0aZI8/fTTUcpt586dZdq0aTJ+/PhI2x577BEZY9q0aZH2goICmTRpkrz55ptRysp5550nIulfO5WVldKxY0cBxG63y5133invv/++XHPNNZG+tV/MtHLT+GjlRpOQzZWbmTNnClhvaCeccELkTUYkWjGprdx8+umncvTRR0vnzp3FbrfXeaup/aZXu/3PP/+MtN94442R9jPOOENEopUbj8cjJSUlkf6nnnpqZNttt90mIiJHH310pO3hhx+OPEieeuqpSPuRRx4pIiKvvPJKpG3PPfeMjBsMBqVnz571Um569uwpwWAwsm2//faLbHvhhRdEJPpB06tXLwkEAlHjXXrppZHtN9xwQ+QY3nnnnUh7v379RMSyiNS0de3aNWqs2nMnU25qn7frr78+4fEmemDFUm6+++67qIdTdXV1pP9xxx0X2fbQQw/VOZ+dOnUSn88nIiJr1qyJtA8YMCAyRo2yseuuu8qiRYsi/VPhjTfeiIw5cODAqG0DBw6MbHvzzTcj7fEsX4lI9ZzF+j6I1O/6iqfc7LrrrpH2L7/8MtI+atQoERHZuHFjxJpRWxlbsGBB5MUHkNdee01ERIYPHx5pe+yxxyJjz507t97KzQ033BBp33nnnSPtzzzzjIhYCnONJTA/Pz/Sd+TIkZG+jzzySKT9p59+ilJ6TNNM+9p58803I23Dhw+POi+9e/cWsBTNmpcYrdw0PtqhWJMWhx9+OD169GDFihWR9eezzz47bv+vv/6agw8+mEAgELdPSUlJnbbCwkK22WabyOe99tor8vdff/1Vp/8OO+xAu3btovq/9NJLUf3/+OOPyPZLLrkkpiy//vprnTn23HPPyN82m42BAweyfPnyuMcTjz322AObzRYl42effRb3mA4//HDs9uhLtPYx3HXXXdx111119vvtt9/qjDlgwICosWrPnYzacx555JEp7ZMqtcfefffdcTgckc977bUXr7/+ep1+Neyzzz64XC6AqIik2t+nM888kzvvvJMffviB3XbbDZvNxnbbbcfhhx/O1VdfTZcuXVKSbe+9947attdee0V8bmLJ1hjE+j7U9/qKx+DBgyN/xzqnS5YsQUQAWLNmDQcccEDMcZJdR7Wv53SpvW9hYWHk7xpneKUUhYWFlJeXRx17vP9nv3798Hg8eL1eiouLWb9+fdrXTu2xZ8+ezezZs+vILSL89ttv2qm7idAOxZq0MAyD//znP5HPbreb0047LW7/J554InLjPfLII5k1axYLFixgzJgxkT6xHHk3J92ok/pGqdR2WM702OmOs9VWW9Vr3GAwiN/vb9DcLYFkMhYUFET+rv3wqXn4Atx+++28/PLLHH/88Wy//fYopfj111956KGHGDp0aB2H20zJ1hjE+j5k6vqqIZVzmgrJrqOGnL/aLzGGsekRlpeXV+8x06Ehsqdyf9FkBq3caNLmjDPOiNxUjjvuOPLz8+P2XblyZeTvu+++m+HDh7P//vuzdu3ahHMUFRWxZMmSyOevvvoq8vfWW29dp//vv/9OWVlZwv7bbbddpG3evHmItSwb9bN06dI6cyxcuDDydygUivqcDt9++23UgybZMcW6idY+hueeey7mMVRWVuJyuaLG/P777wmFQjHnTkbtOWfOnJmwb43MqT5Qa4+9aNGiKGWjtoy1+6XLSSedxKuvvspvv/1GeXk5o0ePBmDx4sUJrS615/z666+jttX+3BDZIPVzFuv7UN/rq75ss802ETn69u1LMBis8/2rrq6OpIqIdx2l8/3LFPH+n4sXL8br9QKWctexY8e0r53aY48dOzbudTls2LCMHpMmPnpZSpM2vXr14rHHHmPNmjWRB0WivjXcfffdjB07ltmzZ/Pee+8lneeUU07hpptu4t9//40KmT766KPr9K2srOTEE0/koosu4ocffmDatGl1+p966qnMmDEDgNNPP50bb7yRbbfdlvXr1/Pnn38yc+ZMhg8fzi233MKQIUNwu934fD6+/vprLrvsMoYNG8a0adPqtSQFVqjv2LFjOeWUU/jwww8jpm2Xy8Xhhx+e0hinnHIKEyZMAODyyy+nqKiI/v37U1JSwtKlS3n//ffp1asXzz77LAMHDqRbt26sXLmSVatWMWbMGE477bSouVPhtNNOi5y3e++9l2AwyMEHH8zGjRuZMmUKTzzxROT/XFBQQFFREatWreKll16iV69ebLXVVmy77bYxxx4wYAA77rgjv/76K6tXr+bUU09l3LhxfPXVV5FQbafTyXHHHZeyvLXZb7/92G233dhrr73o1q0b5eXl/PLLL5HtiSxcQ4cOpX379mzcuJGFCxdy0UUXccQRRzBr1qzIg7pDhw4MGTKkXrLVkO45q01Drq/6UFhYyPDhw5k1axZLly5l5MiRnHnmmeTm5rJs2TIWLVrEG2+8wRdffEHv3r0ZOXJkZInm//7v/8jKyiInJ4frr7++UeRLxCmnnMLbb78dkcXlctGhQ4eoDOwnnngiSqm0r50hQ4bQsWNH1q9fzwsvvEBhYSFDhgwhFArxzz//8Nlnn/HDDz9Effc0jUwT+vdoWiGbOxQnoqYftRyKv/rqqzrhlEopGTRoUEyHupq2wsLCmOGmQ4YMEdM0RSTaobhXr16Sl5dXp/9ZZ50VJWOiUHCIDtu955576mw3DCMq0iMdh+Idd9wxZljxHXfcEekfL1y6NolCwQEZO3ZspO/LL78cs88222wT8/zHc4it7dC5+c/ff/8d6VfbCXhzeTIdCl77OEViO8vGChuu+dlpp52iHLxj8dZbb6UUCp7s/CWiPues9rmrz/UVz6G49hy1r6/BgwdH2hOFgm/+nfD7/bLrrrvW2b7tttvGlCUetb9/ta+5wYMHx/wexvo/mKYpJ554YlyZNw8FT/famTlzZsKw/NrHqR2KGx+9LKVpVPbaay/efPNNdtllF9xuNzvvvDPTp09n6NChCffLzc1lwYIFHHXUUWRnZ1NYWMh5553HG2+8EdM837t3bz7++GMOOuggsrKy6Ny5MzfccAMTJ06M6vf888/zwgsvMHjwYNq1a4fT6aRnz54ceuihPPzww1xwwQWRvtdeey0TJkygd+/euFwuBgwYwIwZM+I6UaZyLubMmcOee+6Jy+WiV69ePPDAA9x4441pjXPbbbfx7rvvcvjhh9O+fXscDgfdunVj//3355577ol6Ez3ppJN4+eWX2XHHHXE6nWy//fY8++yznHrqqWnNOXnyZF588cU65+3UU0+N8tN49NFHOeGEE+jYsWPKY9c4544dO5Zu3bpht9spKCjg8MMP5/333+f8889PS9baXH/99Rx99NH06tULj8eDw+Ggd+/enHfeeXz00UdRDt6xOProo/niiy8YPXo0nTp1wm6307FjR4499lg+//xzRo4cWW/ZaqjPOauhvtdXQ+jZsyeLFi3i6quvZocddsDtdpObm8sOO+zAmDFjePvtt+nRowdgWd3mzp3LqaeeSl5eHnl5eZxwwgnNUnBWKcXUqVN54okn2GuvvcjOzo4kKrzuuuv48ssvo77L6V47I0aMYOHChZx++ul0794dh8NBhw4dGDBgAFdccQXTp09vqkPVAEokTU8xjaYRqVFcevXqxT///JOw7z///EOfPn0AK8qjJVbonj9/PgcffDBgrcXrCsAajUbT+GjLjUaj0Wg0mjaFVm40Go1Go9G0KbRyo9FoNBqNpk2hfW40Go1Go9G0KbTlRqPRaDQaTZtCKzcajUaj0WjaFFtchmLTNFm1ahW5ubmtor6ORqPRaDQaEBHKy8vp2rVrVF2xWGxxys2qVasiCaY0Go1Go9G0LlasWEH37t0T9tnilJvc3FzAOjmxqsgGAgHef/99hg4disPhaGrxWgX6HCVHn6PU0OcpOfocJUefo9Ro7eeprKyMHj16RJ7jidjilJuapaiaVOCbEwgE8Hg85OXltcp/flOgz1Fy9DlKDX2ekqPPUXL0OUqNtnKeUnEp0Q7FGo1Go9Fo2hRaudFoNBqNRtOm0MqNRqPRaDSaNoVWbjQajUaj0bQptHKj0Wg0Go2mTaGVG41Go9FoNG0KrdxoNBqNRqNpU2jlRqPRaDQaTZtCKzcajUaj0WjaFFtchmKNRqOpQcQHVa8j3mkQWgmqHcpzLHhORRmFzS2eRqOpJ1q50Wg0WyRiViBFYyG4uKYFpAKpeAy806DwZZS9Z7PKqNFo6odeltJoNFskUv5fCP4MSPinBhPMIqTk0maSTNMQRAQJ/Ib4P0OCS5pbHE0zoS03Go1mi0PMMqh6EzDj9AhB8Gck8CPK0b8pRdM0AKn+Ain5L4T+3NRm74fKuwHl3KMZJdM0Ndpyo9FotjyCvwPVSToZUL2oKaTRZAgpvghCm1lrgr8gRWOQ6m+aRyhNs6CVG41GswViS6GPpNhP09yIhGp/2myrCZhI2a2IbL5N01bRyo1Go9nycOwEKidJJwHXvk0ijqaBBGqsMvGUFxOCf0Dw16aSSNPMaOVGo9FscSjlBs9YQMXpYQPngSj71k0plqa+hNak2G9l48qhaTFo5Uaj0WyRqJwLwTU8/Klm+Sl8S7Rvj8q/vznE0tQHoyDFfjp30ZaCjpbSaDRbJErZIf8hqD4BqXoNQivAKES5jwb3YSjlbG4RNaniHAR8kLiP0QUcuzWJOJrmRys3Go1mi0UpBa59Udq3plWTiiKqcq9GKb1YsaWglRuNRpNxRALg/xDxzQazFOxbo7JORDm2b27RNG0YlXsN+B4EqcTypxKrpEbeDaisI5tbPE0TopUbjUaTUSS0ASkeZ0WnYAAmVH+FeKcg2eegcq60LCYaTYZRnpNQeaPBNw/MDWDrDK6D9BLjFohWbjQaTcYQEaTkQgguDbfUZAAO5yGpnAS2XuA5vjnE09RCAr+Afx4ifpRjR3AdmpISIBICqQCV1SKVBqWyIGtEc4uhaWa0cqPRaDJH4AcIJMrqq5DKJyFrtLbeNBNillp1s6o/x4oSUwhBK5Ko3QSUa+84+xUhFU9B1SuWcoMdcQ9DZZ+PcmzXlIeg0SSlWb2rJk6cSP/+/cnLyyMvL49BgwYxe/bshPtMnz6dHXbYAbfbzS677MKsWbOaSFqNRpMM8X9C4qy+AqHlVmSSpskRMZHis6H6q3BLCAhaf5olSPGZSOCPuvuFNiAbR4N3clixwdrPNwfZeCxSvbAJpNdoUqdZlZvu3btzzz338O2337Jw4UIOOeQQjj76aH7++eeY/T///HNOPvlkzjzzTBYtWsSoUaMYNWoUixcvbmLJNRpNbALET4y3eT9Nk1P9BQS+J7JMGIUJhJDKp+pskfL/Qmh1jP0s5UhKLt+sBIJG07w0q3Jz1FFHMWLECLbddlu222477rzzTnJycvjyyy9j9p8wYQKHH344V199NTvuuCO33347u+++O48++mgTS67RaGKhHLsQsQTE7ZQLth5NIs+WgpglSHAFIlWJ+/lmktiyFgLfrKgaTGKWgG8msRUiABPMtVC9IE2pNZrGo8X43IRCIaZPn05lZSWDBg2K2eeLL77giiuuiGobNmwYb731Vtxx/X4/fr8/8rmsrAyAQCBAIFD37bGmLdY2jYU+R8nZUs+RGAcgZjcwi9jkTFwbA7JPxQgqILDFnqd0SHSOpPpHpPIJqK55IXRC1ghU9rko21Z1+pvVVRB0kOzWrwLeiLOwVP+FBG0kVopsqKo/UcZ+KRxR5tHfo9Ro7ecpHbmVNHOZ1J9++olBgwbh8/nIyclh6tSpjBgR29Pd6XTy/PPPc/LJJ0faHn/8cW699VbWrl0bc5/x48dz66231mmfOnUqHo8nMweh0Wg0Go2mUfF6vZxyyimUlpaSl5eXsG+zW2623357vv/+e0pLS3nttdcYO3YsH3/8MTvttFNGxr/++uujrD1lZWX06NGDoUOHxjw5gUCAuXPnMmTIEBwOR0ZkaGvoc5ScLf0cSfBfpOolqJoN4gVbd5TneMg6Lip8uCWcJwmtRapeBd9HIAFw7IjynIBy7tks8mxOzTk67NCB2H2Pgu89ki79YQPXIRj5/41qleC/yMajiV8920DlnIfKPmvTPmIiG44EM1FxSoVq/zbK3q3WftJkEXEt4XvUGmjt56lm5SUVml25cTqdbLPNNgAMHDiQb775hgkTJvDkk0/W6du5c+c6Fpq1a9fSuXPnuOO7XC5cLleddofDkfCfm2y7Rp+jVNhiz5GjD2TdBNyUWvdmOk9S/Q1SehaIH5Rp+UKHlkP5LMg+G5VzVYsJWbeXn4lDLQd7io67oVko202o2sUiHX2Q/PORioeIZPCNYAP7tqi8MSgj+n8h+WcjZfH+lwa4R2Bk9bYUxcrnoOoNkFIwOkDWCajssSgjP/WDrSeZ/B5J4HfEOxUCC7GUxQNRnpNRtm5J923ptNb7Ujoyt7hCG6ZpRvnI1GbQoEF8+OGHUW1z586N66Oj0Wg08RCzAik+z1JsovyDahIOPgX+Oc0hWmxCa4nv1BsLE4J1Q+5VzvmodveCrXetRg94TkMVTkUZ2XWHyjoelXMplkJkq/UDuAaj2t2JBP+xrELe50FKAAFzPVRORDYeh4Q2pCF78yLel5GNI6HqVQj+CcHfoPJpZP0wxP9xc4unSYFmtdxcf/31DB8+nJ49e1JeXs7UqVOZP38+7733HgBjxoyhW7du3H333QBceumlDB48mAceeIAjjjiCadOmsXDhQiZNmtSch6HRaFojvhnhnC3xl2ik8lmUe3hTSlUHkZolqHqEWsdSVACVNQrcR4fzDVVby4bKHXcYpRTkXAhZo6DqDSS4Aox8VNaRKEd/AMySK606YnXkNCG0Cikbjypo+ZGtUv09UjYe63tR+1hMIIAUXwQdP4jpsK1pOTSrcrNu3TrGjBnD6tWradeuHf379+e9995jyJAhACxfvhzD2GRc2nfffZk6dSo33XQTN9xwA9tuuy1vvfUW/fr1a65D0Gg0rRQr8dzmSzO1MSHwAyJBlGrGW6WU128/lYeESsAW2/dFKQX2nukNaesGORfXyWQkgV8g+FOCPUPg/wAJrW3xSoF4n8da1IilTAoQsCw6ORc3rWCatGhW5eaZZ55JuH3+/Pl12o4//niOP17XpdFoNA2lZfjSJEXVM6pTKqD4FMSxBxRMRBntMitXbQKJFJsaTGt5p4UrN/g/I7GVzET8n6G0ctOiaXE+NxqNRtMUKOdexM7FU4MBjt2a12oDKFUTEJEoz0wswscWWIQUn0+jZv1QqTp6tj4n1tg0awYVTQpo5Uaj0WyZuI8ClUf826CJyj6zKSVKgo3YshqAm/iWqJAV8RP4rtEkw7kfSR8nKhucuzWeDJnCuSeJFUkDnPs0lTSaeqKVG41Gs0WijGxUwVOgsoi+FYYfbNkXoNxDm0O0mKiCR8FoH/5Uo+gocA0FfCS2JtgR3/uNJ5ttK8tBOe4jRYFnHEplNZoMmUJljyP+spQCDJTnxKYTSFMvmj3PjUaj0TQXyrkbdHgPql5BfHNBfODYBeU5FeXcvbnFi0I590B5Pgb/JxD8w1LKXIeAciPrUwhZT1J3KuYuwb+hxvHauQfK3ju+fO3GI+aGcI0pG5aCEP7tPhqVc1Ha8zcHyrkn5F5rFQuNHAfhvxUq/yGUrWvzCahJCa3caDSaLRpl62RFALUCB1Gl7OA+BDgk0iYSBNXOSpoXlxDKvk3K80hoI1J6TZ1imOI8EJV/b3RiwIhsWVDwNFR/jfjegtAGsHVFeY6LhIu3FlT2meAYiHhfhOpvQNmtfD6e01D2vs0tniYFtHKj0Wg0TYRIEEKrQNnA6JqR7MdK2RHPSVbSwbgO0k7IOjo1GU0vUnQahP6pu7H6M2tb+9djLjEppcC1N8q1d8ryt1SUcwDKOaC5xdDUE63caDSaRkNEoPqrsDOrshwxHQNaTEmDpkKk2spw630hXDEdsPWA7LMh68QGnw+VfS7i/wSCvxOt4BiAoNrdmXoouG8GhJbG2RiC4BKoehu030mLRAJ/WHXAjPZg32mLu9Zq0MqNRqNpFCT4N1J8QfhBWRN98hDY+0HBYyhbl0acexnifRkC3wI2lOtAq4SArWOjzRlXFgkixRdC9SdEOf2G/kXK/g+Cf6HybmjQHMrIgcKXkMonwTtt0xKVcy9U9gUoV+rRPVL1OomTGyqk6g3tVNvCkOqFSNntEPx1U6OtN+Rej3If3GxyNRdaudFoNBlHzCKk6FQwi8MttaJPgr+GlzbeoTHynkjVW0jpdYSrYFptge+h4kkoeDKtB31G8L0N1bHqEYWVB+9kxH0Eyrlrg6ZRRg4q90ok51LrvKssS+lJl9BGEkdeCZitp07UloBUf4MUjaXOsmRoGVJyHuQ/jHIPaxbZmgsdCq7RaDKP95Xw8kuskNqQVdPI93bGp5XAz0jptVg3+c3rAvmQ4nObvICjeKeS+FZrQ7zTMjafUnaUrWMdxUbMMqRyMmbRGMyNJ2GW3YUE/4ohTjcSZ282wNDRQi0FEUHKbsX6jm/uc2UpqVJ2a60aZVsGWrnRaDQZR6pmkDj7r0KqGkG5qZxM/NuaAH6rLlAjETMLcPBvEp+LEISWNJZIgFX7SdYfhpTfDdVfWj5Q3heRDcORyinRnR27kthyY7bKJSmp/gaz+BLMdQdgrjsIs+xWJBjPt6gVEfzNSg0Q9zsWtrRVf96UUjU7WrnRaDSZR8qSdUgSulxP/J+QvC7QggTb00eC/2CW3oy5djdk7Q6Y6w9FKp9BxGd1SFobSoHKzahMUfKZXqToP+H/SW2lJQQIUn4b4v/C6is+y2cnEUYXSGGJQ6QKqV6EVH+HmN56y58JpGKitUzqnwvmWjBXgXcasuEoxPdBs8rWYEJrUuy3qnHlaGFo5Uaj0WQeW2+SLcVYfTJNIgtJDYmUn/SQ6kXIhqOh6jWQSkAgtAIpvxfZeJr1UHcfSeJ0/oJyj8iYTHXwvQNSTPxzY0Mqw0WMfXOAJFXIzQoSWXZEqjHL70PW7YsUnYgUnYSs2xuz9HZE/PU4gIYh/s+QiofCn2r/70NACCm5FAmtbXK5MkaMnEMN6tdG0MqNRqPJOMpzMsmWYpTnpMxP7BxI0rpARkek+ocGF5IUCSIlFwF+6ipMAsHFSMXDqOzTY5R4qMFmhYRnHdEgWRLK6f+MxD40ISt/jQgS+JXkcSblEEcZEAlZkWGVT4eVvRr8UPUisn4IZqgkucziR3xzkMrJSNW7iFmZdJ+4Y1VOJv53QoBQoy5VNjqOXcDWnYT/Y5UDrsFNJlJLQCs3Go0m87iHg/NA4t5w3UeCc/+MT6s8Y0m2LIV/LlJ0PLJhCOKfX//J/B+BuZ74SpwJVa+AUYgqfAGMDuF2OxEFwt4XVfhiI9dcSsWRNIR4X4XAD6Rk2YpUKt8M/wfhyLA4iqO5BjYek3CZSqresKw+JZcg5fcgpVcg6/dFKp9PLlcsAgtJulRZ/U39xm4BKGWgcq8lkTVN5V5Zq7r8loFWbjQaTcZRyo4qeByyzwtX3g5jFKJyLke1u69Rkosp1yBUzqXhT4ksOEBouRU95fuoXnNJ4GeSWjmkEvHNsWpWtZ+Jyn8UssdB9pmogudR7d9p9DpFyjGAxJYbZf2U/19YuUlk0VJg39EqWRED8b6SZC7AXAneKTE3SdW7Vhi/1CyNmTUbkPI76zo/Z4zWnehOuYeh2j0IqmCzDTmo3P9DeU5tHsGaEZ3nRqPRNApKOVG5lyM5F0LwL6wH49YolfncNlHz5lwIjt2tbMD+b4BEzs2ClN0GroNQKr13PaUcSEJFIEzpNeFeWYjnJFTuFU37Fu0ZDRUPAwFiKy6bOxknQlA558ffHFoeZ47NRvG+jMo5J7pNQkj5fYn3q3gQPKNRyp10jgjO/cD/IYkqfSvnvqmP10JRWUdajt7+BWCutiyFrsHpnas2hLbcaDSaRkUpJ8qxA8qxfaMrNpE5XYMwCiaCZ2TyzuaqcCbjNHENJj3n5CrwPo8Un4dI5pyawXLilap3MUsuxSw623LoDS4HQBmFqPz/YVmyaluz0rn9G4BC5V6Lch+eoFuKTqvmqro+T4HvrYdyIqQC/J+mNkcYlT2ORIoNuMFzfFpjtlSUcqDch1hV7d3DtljFBrTlRqPRtFFEQlYNpFT6BpdBcBkS/A2UC+U6GBwDEy6dKccuiGPPcN2sVJUVE6o/s0KSEykJaSChlUjROAgtw1JCTKj+FKl82kq9nz0O5T4M2r+FeJ8H3wdAAGy9IPhz8gmMPmDkgX0bsHVFJBBXSVVZo6xs0MlQnrrnNpLNOjHiew/xzwPsKNcB4Doo8VTOPSD3/5Dy27HOT83/ygCcqIInYlY517RutHKj0WhaFWIWQdVbSHCJ9ZB0DwXHnnUflqG/U8i3E6bsdoQqam6JUvkUOHaDgokJH3yq4BGk6MywkmAjNSXHQLyvJLaApIhIyJo/9G+4pca5OVx2ovwusPUE18GW87NZBkYBGLlg3z415cb8G0wbBH9CfK+DaocUPIPh7F+3r/toqHgs7GgdDxu4Y1jUUvU98s2wxkAhVS+DrSeS81TCXVT2aeDc08oWHfgWsIPrYJTnRJStc2rzaloVWrnRaDRRiFSD7z0k8BMoO8p5IDj3bhHVhcX7BlJ2M1YEkLVUIt4XwDHAqhtl1HKolFRy3tRQFf5dK7Io8CNSdBa0fy2uP44yCqH9a+Cfj/hmQXANBJNF3piQqcy4/k8gFKOEQi2k/AHL56RqOhEFLETYeThVailtUgpFx2PmT8RwHxLVSxnZSOF02DACiBURZViWsewz6m6y7xhWuP4keb6iWvKEViLF5wIXJtxDObZHtbs1ybiatoL2udFoNBGk+htk3QFI6ZVWREvlZKR4DLLxaCTVTKiNJZv/M6TsejY5xoaIKCOBn5DiC6L9OOy9G5j5NwTBxdYyUgKUsqHch2LkPwDOnVIb2lyPmBX1kkokhPjmYZbdgVTcT9LbeOjPsGIDmUtgKFBykWU92wzD3hXVaX64jANYfi1hXx+jkxUlZu9VZz+lFCpvPNbxpPNoCiX31dFscWjlRqPRACDBv60ljkhZhCAR5SH4J1I0xrLqNBNS8TjxQ3ZD1nJD4LtIi1JO8JySYJ9UsFmh3KkS/D3FjiGk6s20pZHgMqseVMm54J2aopUjFerzKAgiFU/G3KKMfIz201Ht30blXIHKuQCV/ySq47yE1c+VcyCq8CUrMV2D5dNsyehlKY1GA9Rkcg0Q+2EZgtA/4Hsfso5EJGAtXXmnWf4eRntU1jGQdQzKyE5tPvFHInqSZQsWsxwCyZZ77IhvLso5MNKici5CfLPDIcr1QUDSqIsUSGO5qep1yD49ejaptjL7qlyUir49i+lFSk+v5c+SwSrPxlZWgr1IGLeH2MtKm+Gbichd8R2MHTuAY4e0RFHO3VDtpyPBv626SUYHZOMxQPqKtYiZdoj/loZIwEpIGfzDyqTtOhRl79PcYjUYrdxoNBoL30wSL1sYlhXDfRhSfDZUf0UkOsdcjZQvBu/zUPhS3CRvAGJWIBWPQNWrSCAI3IFsPA7JPxuVFSd0W6pit9fp54v6qJQLyb0ZSs5Obf8YKHvf+NOZFYBpLX8FfwJJ5Ei7GaFNSykSXIpUPBH+HwRBZSFZx6GyzwPCfkT+2WEFpBGQSuj4KcpcD0ah5afje5vkOWuC1v+mEUL8lb0PhB+yYt/OWiJMAQmtQSqfhao3QMoQoz1knWBFjRkFyQfYghD/F0jp5WAWYakDJpTfi7iGodrdk/KLSktEKzcajcZiM8WgLiZIOVJ+P0TS1ddYecIPwdC/SMkVqPZxMtCaXqTodAj+Gt43nMwutAwpvQpCq1A559Xd0SgE1S5JJfEQyr5NnVblOgCxdQ9XRa7HEk7W6LrH4ZuNVDy16YFr62lVy0aRShI7SzCnNVbgJ6ToNJBqIsqlVIH3ZSvsOW9auOm99GVPFSlDBX+zQqsBPCcjvhnJ91M5oJrgAZh1MpTfmLSbWXoTEpyHVfwzfC7NjVD5JFL1NrR/JaJ4W47zc5Dqz0FCKOdu4B6JMnIa7zhaEBL4BSk+i00WwFqWQP9cpKQKCp5qEYEE9UHb6zSaVoSIWMnaNh6PuaYf5trdMEuuCpcCaCD23iT2TwlX8va+QnwlIQSBr5HAH7E3e5+vpdjUxlIIpOKhyFJVbZSyh/1n4t2yFOCErKNj7Gug8h8OF6/cvCSDwlKwNh/X+qxyb6gTKiwVjyEll0Lwl02NoRUQ+IqUFRsA+66YpomUXAkSq/hmCMwipPy/1sfgn6mPnTa2qPpKyrk7uI9Lso8BWcejVJIyF5kg1aUt3yyglLrn0gRzDVJ2CwAS+ANZf4ilUFfNAN+7SNl4ZP0BiP+LDArecrF82Exif2dNqP4EAj82sVSZQys3Gk0rQcRESq9HSq+AwE9A2D/DN9Na1knH8TUGVv2ZRA/nEDj6Y1XBTjhSuFhhXcQ7lcTWEwOpei32qNnnWOHCdW5b1sPVMqPHjo5Sjn6o9m9B1vFATZFKF6h8y+ri2B2ota99Z1T+46jsMdHyB35FKiaEP9U+jnpUGK9+H9btYPkyJVIW/R+Hp0hktcoA1Qsx1x2EuXZXzPXDwLY12OIvyaHyUDnnWqKJH6magVl6C2bZeMviJIG0phezAql8BnP9UEuGdQdbiqRZjEoryive/yIE/o8wA0uQ4jGWRaemPWIx8yLF51hJHdswItVWkdOE59WG+GY2lUgZRy9LaTStBd8M8L0R/lD7YRgClGUB6LgHytYhxs4pkDUafO9B9RdEPyDCSy3ZF6LsPVKpHBS7VarBXJtkXxOC/8TcooxsKJxiZd71TgUptmRz7gvZZ4JZgll6HUgA5dgZso5FGfnhB++7Vq6X0CqwdbAsLQStMULFEDIsy067x1HO3eMm7hPvNFJP1teaCEUrpKG/oTJxnSekBHzzEXtfpPic8P8jnATROxWMrlD4dMylwjpDmUXIxlPDOXvC3x9ZaflmeV+FgkmAA8vhvSGIZT00i4n9PRUgiHhfROXd1MC5WjDiJaUl2kgB09aHVm40mlaCVD5PfJ+OcN6Xqtcgls9KCijlsB4ilU8h3imb3mxt26ByzkVljQw70LqBJP45zr1iNDpI/oAyIIHPgzKyUbmXIjkXhS0ZbitnTPE4JLQSS/EQxPculD+EeE4JL6PFivypraCY1g2/5BrotCC+eMFfaXuKTf2R8nuAQC2H71p+G+Zay7+qw3soIy/W7tYYwSVIyfWWQlXnu22CuQ7KbrOyGvvepMGh70nLQ4TANwfasnKjci1/KUmUa0lQtp5NJlKm0ctSGk0rQMQMP1gT2U3EyircAJRyWlW1O3wCeQ+B6wiw97KcXgO/Ws6WnhOJf+uwgWOf2I69SoF7BHX9XmoTQrmHpyCnzbKuKBtSNNYKGQ7vv8mPwA/e50gppBnC+1QgG45C/PPjTOyhYXlz2hhSElZs4qQPMDcilS/G3jW4DHPjSciGERD8Ic4Y4XEC34DnBDC6NUxelY31Tp/E/ijJll5bN0rZwHMSSVWArGOaRJ7GQCs3Gk2roFaW10R9VMONsWZgMWw4GMouB/9Ma23e+wKy8WjM0lsh53Jw7h3uXXMLCT/wbT1R+Q/ElzD7bGrqAtXFZmW1de6XurC+WVZV70xaU8x/Lb8L7/Q6m5R7KIkfjFviLTWJJaXyEaQ62gdLQmuQohPTKgGhgn+hOrxl5eSpL55x4QSBia4lA+zp5eZpjajsc8DWg9hO9qByr2rVdbe2xCtRo2l1KKXAdQCJb8omyjm4QfNI9TewcbS1FBC9xfpV9RLKOwVV8AwqfwI497FukI5dUXm3odq/ibJ1THQk4ailGAqCrQ+q4KmUk66JCOJ9NaW+9UHKxltFOmvjHglGJ2L/HwzAYRXcTKqIbkmYSPHZiFkSaZHKp8GMFdWUAGVDGbmogiexnMJjnWO7VWcMam0P/3Yfi8q5COU5Kcm8plVos42jjHxU+1cg61jAuWmDrSeq3X2o7LOaTbZMoH1uNJpWgso+M/5yCTYrF0zWiJTHEwlCcAkQsCJjlBMpvohkb+JS+bSVEM09PKUlpMh+phcpHhd/nT/0l5VJ2MhPQXbTKqAZ+Dbl+dMnhFQ+B/atsRyX90LZukLhC1aZCnMlm5Y4QqCyUfmPg70nsvHEsIKYidIILRkD6/iTLfN4wxmZz7SyUVe9TnrWNsNSpAHl2AnaTw/nW/o4am5V8CzKMwAC3yJVb1l+Y7bOqKzjUI5+VifHTpBzOVLxEJEklNbe1ljuY8E1NFr80GqoesNKU2C0Q7mPAEd/lFJIcKnloK7yw22tx2agjEJUuzuR3OvCx5AFtt6tNrdNbbRyo9E0AJEQ+D+xHFjNErD3QGWdAGyb8bmUcy/Iux0p+z+sG3GIyA3ZKEAVPIdS7hRkFvBORiqfAnNDuNVtOQFLcXJBpAQCi8G5e8qyW6UDrq9VOiAWCql8DpX/UPIBvVNrFYNsLMRK/la7xdYX8v+H6vg++D9C/J9ZxySVQDbinw2MgtxboOLBcPRPrf9TmyNV5U0Q/+eo7DOJpDBIGQPcR0QtkSjHdqjCSUhoI5jrUKF2wDcQ+BwpeQaUG+U6BNxDYpaGUDnng30b6xqocTC2bYPKHgdZo6Me7lLxRFgRUpEf8U4Gx0BE/NGZk40ukHsVKuuoNI6v+VFGLhgpFn1tJWjlRqOpJ2KWWhk+Az8QCQ+utiHeqZiOsUC/jM+pPCeAc1+kapqlYOBCuQ8G91Gp13Qquw2qXtqs1QfVCaKE6gwSv86PVH+PeF8KJ7lzg2uwFX0SqltBOhorD0nccaUafHMR/5fgfyd1WetNDGUktBQ2HoVkX2JlUvZ9aIWYY8NKfKYsxQuIDhlvi4pNutScCydphXU7BqLybou5Sdnag629FSWIA6mYBHYfVqmQt6GiFxRORtnqOiIr9xCUe0i4GGwIpbLq9JGqN5CKB2s+RW+MZTU0VyOlV4J4UZ4TUzu+JqSmhptZdjemrRRsvVCe0ZZFso2hlRuNpp5IyZVhBQM23bjDv6umAXc0yrzK3h2Ve1W99pXATzEUm8jWFEcxwB7bMmWWPwSVE4l6sAfTiOASHxL8F2XvHt0c+N1SJM21tIg8M5UPW34jkUisWEqMDhmPwizHLL44bLVJUbHJOh2Vd0PCLMji/8JS2LmdTZFy4XMf+hcp+g90mFWnEGkNSjljtouYSMWjqcm5+b7ld4VfODz12r8xELMcKb4YOAaq3gR7FZa19DHIuQqVU//6ay2R1rM4qNG0ICS4xEpPnuQBJpLBys2AhNYhFU9glt6AWXZP2qHfVgRQA51dXcOtN+bNx/bNDis2UP8HuyAbDkUqn7GS7/nmYFY8HvZhqVnSailKQxrVwjWWkut/D6o/TX2f6o9J9piSykkJ+oSr2fvnpT5nZNe/rIr39UGqwP9+/fZtJKTkslo5foJYimAIEKTiPqSqKayhTYe23Gg09cH/CdHOiHEILgHnLhmZUiqfRcrvDX+yHDnF+yziOgSV/1BMs3odQv/QIOVAtUe1uzm2fBXPkNI5SYpY9ZQqHg7nUGmr/iqapISWI5UTwTMuphVEJADVnxMV7VMHG+Kfh3IPSW/uVCvRx5mzdtX35kYCv4WXnV1xeiik4jFwH9kmnIlBW240mvohAVJK5pYhy41UvRPOBmuGf4JElBT/fKTkutQGUvmkftlvdnyOvVAd58QsTWA5Vv5IRqODIg8Xrdhs0VT8D9kwBLPiaaRqJmLWrrEVJKXvRwIfsbjYelH/938TjLrWzWbD/xGJLbYStlStaCqJGh1tudFo6oOjHylZQOx9GjyViFg1duJaMEzwz0aCl6PsvROOpbKORPwpFth07mulabd1R3lORNl7JZIytTE1mvpgroeKe8PfMifiOS3sd+a28iwFE0XhhcBIv96aMvIQ90irplva1k4HuIelPWdjIeIjtcza9VACWyjacqPR1AfnIKuadNy3oXCl6hQjmBIS+ju8nJQ4M6743kf88xHvtHBV5hj1n1yHgK13CpMaKNcBGAUPY+Rdk0SxwQpBt22dwrgaTUOpBu9zSNktKKVQnjHJd/E+i1l6m1XGJA1U3jVg60bd6zzxo1PlXIAy2qU1V2Oi7DsQVfcrJu7wsbYNtHKj0dQDpQxU/sPhWkMx0pfb+2ZuslhKSiwqH7PKBpT9H1JyMbJuXysku7Zkyg5xwmqjMa3CeslECy7BLL0Jc+2e4cKHGk1TIFA1HTPwJ2LfMbVyCVVToHJSWrMooxDVfrpVtiFyPdjANczKZVSnFEQWKudKyD4/rXkaEwmtQXzzk/SygWd0an57rQS9LKXR1BMrU+oMxPs8VL1lZd61dUV5TkbZTwDqEaERC1sPkucFMes6QEoFUnarJavn1E1yO/dCbN0gtDLBeHZwHZpQLPF/ghSfz6aoC42mKTGg6ETrugvGc5SNRiqfhuwz4oZ/x0IZBai8a5Hcq6y5VJb12/ceknW8Fdpu64wytgLX4MxYazOEhFYhG0eDmSg5pwH2rVE5lzWVWE1Cs1pu7r77bvbcc09yc3Pp1KkTo0aN4vfff0+4z+TJky1TZK0ftzt5VlaNpjFQ9u4YeTdibPUNRudfMTp+iMo+C2Vk7g1IGblWTaN6hnBL+QNRS1RKGaicyxPNCJ7TYoZ7R8Y0y5GSS4hybNZomhQzfimPeEhZrXDo9FDKBioPKich6/ZHysZD5RPgnQzlD4K5sUUpNgBSdndYsYl3jSrIPhdV+ArKyGtK0RqdZlVuPv74Yy688EK+/PJL5s6dSyAQYOjQoVRWJk7NnZeXx+rVqyM/y5YtayKJNZrmQeVdDbaupLv2D1gPAP/H0eNljUTl3oRlEVJYRlzD+jvrZFTuNYnHrHorbCnSjsSaVob4679v5VNIxcNsitKq+e1Hym9HvK9lRMRMIKGN4J9L4pcPQTl2QhnJl6BbG826LDVnTnTUxuTJk+nUqRPffvstBx54YNz9lFJ07tx6S7FrNOmijEJo/xpSMdFKNS8VgAGO/qm9iW5e3RpQ2WMgayRUvYuEVqKMfKuGz2bZgWsjIhD4BvFOQSs2mlZJnOzamyPBJeHimxusSvDu4VD5WOJ9Kh6CrGMSZlRuMkL/kjw1gw2CbdNXrkX53JSWWvkLCgvr5tGoTUVFBb169cI0TXbffXfuuusudt5556YQUaNpNqy1/xuQ3Gss87ryQHAZsjGFIn1G7JcBZeRD9mkpBYmKWWb52AS+SUtujablkB1VgDMWIiFryanqFaIspZVPJB/eXA+B78C5Z0OEzAwpLZGZoFrWUlqmaDHKjWmaXHbZZey333706xe/4OD222/Ps88+S//+/SktLeX+++9n33335eeff6Z797pvnH6/H79/kxmyrKwMgEAgQCBQ10Gzpi3WNo2FPkfJafxzlAuASB+EXaxMyPHe0oxClLE3qoGymMVXQfXPxM9yGg8H1kPCz+bWnmDIFfVbUxd9jpKT8jly7o2R5DowKx6Fyreo+z1P7XGpqstQqvnvjSI9Edk2nJjPuu7qnicDZTu4wfeGpiKd+6mSmjKhzcz555/P7Nmz+fTTT2MqKfEIBALsuOOOnHzyydx+++11to8fP55bb721TvvUqVPxeFpOUTONRqPRaDTx8Xq9nHLKKZSWlpKXl9gBukUoNxdddBEzZszgk08+oU+f9DO6Hn/88djtdl5++eU622JZbnr06MGGDRtinpxAIMDcuXMZMmQIDocjbVm2BPQ5Sk5TnyOp/s6qOxX8Y1OjrTsq9wqw9QpX1C5lk3UnnO3YsSuqYCIEVyIl59YKGRVqqm+rnAuAEFLxNPWPjDLA6Irq8BpgIhVPQNXrBINBPvj+Zg4bcDt2WwMcPdswwZBLn6MkJD9HClyHotr9N2HtJPHPQ0qurKcUBth3wmj/Qj33bxyk6jWk7H4gQDDk4YPvr7fOU/awcMX11MPim5uysjI6dOiQknLTrMtSIsLFF1/Mm2++yfz58+ul2IRCIX766SdGjBgRc7vL5cLlqmuqdDgcCR86ybZr9DlKhSY7R469Ift1JPA7hFaBrT3YrYKdsuEIMNaDEUMxkYVQ9T+rgrGxIXYf30Ng9AB7NcmznCZiKZQcDUYeBH8BmwliXZt2mx+HXT+4E6HPUXJiniOVC54xqJwLrSSWCZCgH0npHG9eCsUGOFDtb0S1tHui42QkZwRUvQN+K7eVo9OrOLNaX0bxdO6lzarcXHjhhUydOpUZM2aQm5vLmjVrAGjXrh1ZWVaekDFjxtCtWzfuvvtuAG677Tb22WcfttlmG0pKSrjvvvtYtmwZZ511VrMdh0bTUlCO7cGxfeSzVH8NoSUJ9jChahqJEwQCZoYK6pnLM1pbU6OJjQHuo1GeU8CxA0ql6K+UYiQV9p0g+HP4gwLnvqjcq1COHeslbWOjjHaQfRqGMwDMQtl7NLdIjU6zKjcTJ04E4KCDDopqf+655xg3bhwAy5cvxzA25fIoLi7m7LPPZs2aNRQUFDBw4EA+//xzdtppp6YSW6NpPVR/T83yUnwCKfTRaFobIZRz17T2UI4dEHv/sOIS63pQYHRGZY9BHP1R4gWjE8q2eRmGaER8EAgnqHVs16bKHLRUmn1ZKhnz58+P+vzQQw/x0EMPNZJEGk0bQ9lILR9Ns7veaTQZRMCIn2E7ESr/HmTjSVZZhToKjoC5Dim91gqhzhuPytol7limWQllN4NvLla0IKA8iOcUVM6lqVuUNGmjC2dqNG0Z574kXwfypNBHo2lNCCrr6HrtqezboNq/CVnHArGcbcMKj1QipVcjvg9jjmN6p8O6vcD3LhHFBkC8UPk0sm4/TO8MRBrix6aJh1ZuNJo2jHLsCI69SFiXynMyoM3kmpZAJh9J9VcalL0HRrs7ocP7JJZJIRUP1VmFEO/LUHYjCX3ZpAzKrkaKxiINKQmhiYlWbjSaNo7KnwD2vuFPNZd8WNkxeoL3eaAqxp6tDTuklGtZ02Jx7AE5N2AlfmwYsnEcZuUUzLK7MMsfRAI/Wu0iKblEAKjqeSReshUr/UJoUwkDMb1I+X9TFzTwDVJ2R+r9NSnRYjIUazSaRsLIhtz/g+ovwg7G5WB0h8CPYK6k7TgSh9C+Q62cwNdWWZGMLJNWQPltWI85QSqfQFQBSDkQQuzboTxjIetYlIrznm+WYb0QJLlGzPJNf/s/spae0qHqNST32jZZwLK50MqNRtNGEQkiFY9ZlhmpCLc6IWs0GB3AP4eW42uTQ5RfQr3Qik3rxwbVn5FZhbvW8pQU12r+Aym7Aao/hXYPxlZwbD1TkEWBreumj+Y6LIUonWsrhFR/j3Lvn8Y+mkRo5UajaYOIiJVp1T+H6Id+dTivjZ30FRsDa9mnMSw9Fcm7aLYAQjSdwh2+LnyzEAFyL0HZN0ts5z4MyvIs/5iY2MB1EMrWcVOT0ZF6HYNsTH8fTVy0z41G0xap/hz8s4ltzTCB6vTHNDpDwfPgPBB969A0DgZW9F4T+075ZyEbDscsPh8xNynaSrlQ7e4Iy7O5TDZQOajc66KbXYdCffLYOOKHlGvSR9+hNJo2iHinkzBCqn6jgn8BBFcQO0RWo2koJth60WxLjP55SPEZUQ7Hyn04quAZsPer1dEAe3/IuRqM3KghlOFB5V6T3ryqPcbmVqNGxHKq9qXsWN0a0cqNRtMWCS0n48tH5mrwTgLzb8CX2bE1mhpCvzTj5CYEvkeKTkZCqyOtyrU/RofXof274DwYUBBcBOU3Iev2xyy5ATErN/X3nIrKuw1UQWrT5t2a4eOIjYSsEkeyfn9kbX9k3UDMsruR0Pommb8p0cqNRtMWMQppnMu77b7paTQRAouQjccjoXWRJpFqKLsJqj8m+sUhCL43whafTcu9ynMSqtMCy+qTdzfYB8aYyA65d2JkDW20Q6lBgkuRjSeHP4RTP0gFeF9ANo5CQisbXYamRDsUazRtEJV1NFL9SXOLodG0UgTMjUjlk6i8m60m30wIfB+nvwmBReB7D7KOirQq5QTXAZa3juc4JPAn4psFUomy9wL3SNRmy1qNhZRcUytqsjYhMIuQ0v9DFT7TJLI0Bdpyo9G0RdzDwL4Dmfe7qSdGd8i9C3A3tyQaTYqErPwzYmUZtvzYEj0yDcT7asIRlWNbjNxLMfJusJaumkqxCfwCwZ+Iv1QdgupPkeCKJpGnKdDKjUbTBlHKiSqcHK4t1dwosHfDyB4NOVc0tzAaTepIVTjpHxBaTeIQbxNCKxH/Z5jlD1lZkf0LEGkBuaSCv6XQSSD4e6OL0lRo5UajaaMooxCj8BnYPFQ1rUFyM6AgCQR+xyx/GHxzGjiWRtOU2EGFswYbHZJ3N9cjxf+Byqes4pjFZyIbhiHBvxpXzKSkWH28DVUp18qNRtPGUZ5TNt2gU8YJ9p0sxajdQ5aS0xCkBCofheB3DRtHo2kybOAejlLOcMh0KhaYmkKZQSKZkUP/IkWnIWZxvJ0aH9e+JHWxVdng3KNJxGkKtHKj0bRxlHKj8m5Kc69qy5RddiOUXgn5j5GJYoYaTevBgOAyzLV7IesGhX1WkhFLAQqBuRG8r2VawJRRRgFknUzC5Iiecaj6JB9soWjlRqNp5YgIEvwXCfyO1C7gVwuVdSzkXEd6mV/DN+rqz1CBhZD/RINl1WhaDwEILrasjlLUwLEE8b2TCaHqjcq7FlxDwp9sWI//cMBB1vGonIuaSbLGQYeCazStGPF9iFRMqOUwaEfcR6Jyr0LZOm3qF1oDFY9Qvzw1glQ8SsspsqnRNBUZ/M7HefFIBTFLoHoRYIJjl6hrO1WUcmLk3wPMAs/xYKwDozMq61iUY/t6y9ZS0cqNRtNKEe9rVlXjKGtMEHzvINVfQvvXIwX9pOQ6oDLWMCmiFRuNpv4YYO+b9l4iPqTsbqh6jU3+PAbiHo7KG48y2tVPmtxrMBxte5lZL0tpNK0QMcuQspqU7ZtbY0JW1EbFBGtrcDkEPm9S+TSaLYtkj1ITHDumNaJICCk+D6peYZNiEx7LN8dyUq7JNKypg1ZuNJrWiO9dElf2DkHVW4jpheDPTSWVRrMFYlg1pIyeibtVTklPGfHPg+rPieukHPwDvK+nI+gWhVZuNJpWiAT/IXn24WowN6CjnDSaxiQLCl8Ac12SfpVI1ayUR5Wq10h2jUtV4ozIWzLa50ajaY2oXCJ5NBIgG4aC8mC9xyTzm3GS2Bqk0WjqUgmVLwK+5F3L70KkEjynoFSSx29wJfHLJQAIhKt8a+qiLTcaTQtBTC/i/xLxf4aENibubOuS4qhmuFheKlFS1aDyUxxXo9FE8E1LrZ+UI+V3IiUXI5JIcQHEm3y8VLImb6Foy41G08yIBJCKh8H7Yq0bmg1xj0Dl3Ywy8uvuVP1lurPU+lsRV9mRkjTH1Wg06SHg/xCq3rBCsmP1MCvATMEqU6sCuSYardxoNM2IiCCl14BvFtEKRwh8s5Dgr1D4KsrYrHxCaHX9J3XuA6F1EFpa/zE0Gk0DUIj3RetarP4EJACOncGxB0opqP6K6AipONh6NLqkrRWt3Gg0aVBTY0apZM68KRL4Bnwz42wMQXCpFQqafWb0JqMTlrNhEtN2Hezg2AVCH5HQgqPRaBoRgeBvyIbDwp8VYIJta8j/H0gK/jukl298S0P73Gg0KSDVP2AWX4Ss3RlZuyPm+mGI9yVEkjv1JhzXmywiQhBv3fV85TmG9BUbazxwQGg5WrHRaBoJY9sUO0r4J+zsH1qGFJ2KxFqKjoW97WUWzhRaudFokiC+2UjRidY6eaTS7z9I2W1I8QWIpGA+jkcoWUQEsSMinPuDc1/Sv4RDKNdBVgVgjUbTOJhL6rljyPK7888Dx+7Ef/GxgWM3lCNVJWrLQys3Gk0CxCxCSq7GeruqrYSE37iqPwbvy/WfwOhA0nw1RkGdJqUMVMFEcB+TfP8I1g0RR/+wI2KGltY0Gs1mNMQqGoKqN1Ht7g6nfNj8OrWByrW2a+KilRuNJhFVb2I59sW/WYn3+bAvTvqorKNJbLkxwH0s4v8cs/gSzPUjMDeegFS+ABLCyL8b1XEB5D0AOVdB3kPgGRve17ZpDAD7Nqj8x1BKoTzjQLmJfQuwgX07aPcoelVfo4lHIz4+pRxsvVEd3oKsEwF3eIMbsk5EdXgTZd+68eZvA2iHYo0mARL4lcSOtwKhFVgJvLLSn8A1GBx7QOA76ibZs1lp3UMrkOLHiTgQhxQS+AEqn4LCKRBYDJUPQ2hZeD8DnPuB0dnKmmrkotzDwXUISlnZipW9OxS+gBRfGA45tROxTjl2ReU/ipT9X5Jj12i2UGzbAmbjRRyqfKT8LiCIcvZHcq9CYYLyJE/+lyYi1eB7Hwn+AjitZWvHrlbUVitGKzcaTSKUk+TWC0V9LyWlbFAwCSm9AfzvEaVIOHYG5wFQ+Vi4ocbCE+5jbkA2ngyyYTMZTSsPjlGAav86Kk7CP+XYBTrOA//HSOBH66bpOhDl6I8ZWhv2MdKKjUZTh9Cf4BwEoX+on2N/EqQEvC9Zf/ISqLsg/zGUa+/MTuP/Eim5FKSYmhccqXwcHAOh4DGUUZjR+ZoSrdxoNAlQrsHhGi/xsIFzUMQiUq85jBxUwcNIaCX4P8eynvQH+w7I+oMT7BkKKzYQuzJ4MVI+AZV/T/y5lQ3ch6Dch0TaxCyColNjjKnRaCJUf9HIE9SKxJQKpPgs6DAjY8tREvjTGjMyT635At8jRWdA+9czl/aiidE+NxpNIlyHgq038Z1vTVT2ORmZStm6oTzHozwnoRw7QWgVmA1I1kcIfO8gZmVae0nxJRD6twHzajStHRuorsn7NBkmEEQqn8/YiFL5FJbVKV7V8V/A/0nG5mtqtHKj0SRAKTuq4FmwdQu32LCWgAzAhsq7E+Xap5Fmz4TlJADm+tRnDPwKga9JXmRTo2nLhECSPR5DpOVnZ+tL7CVuBeTEaI8xny/1quKJEBHwzSbxkpoN8c3JyHzNgV6W0miSoOzdocNs8H+A+D4E8aMc20PWaJStc+NNbOtqhYqbG5L3TYSRl3rf6s8aNpdG02ZIwXppZKM85yIVT5C0Knjor7CTf21rbI3DforWValKrV9STMCfvI9UZGi+pkcrNxpNCijlAPdwK+ooQ4gIBBZCcAmoLHANRtXKaaOUDTzjkIoHqJ8VxwDnPnGdAkVMlIp+O5VQaT3m0Wi2RGzgPBCVcwF4xkD1p0ioGLzPhR2NN0diLDPLZr8TocDet0ESR0ZSNjC6grkqQS8D7H3SHluk2qpdZ3ia1SFZKzcaTTMg1T8gpVdvdhO0I57TULnXRMI9xeiAleOiPm9sgsq5OLoltAHxPgfe6SAliMoHz2iU5wyUrYN1U9JoNClgorLHAFZQAO7DIfAbUn5LI80nKM9pGRtNeU5FKu4nvmJlorJOSHk8MUuRikeharqVZRkQx26onItRrv0bLnCaaJ8bjaaJkcCfSNHp4fpOtQmC93mkzLo5SuWzUHYd9VNssCoMOwdumje0Etk4CiqftUJNwfpd+Syy4TDMkpvC+XY0Gk1yDKT8AcQ3d1ONOf9cGsfRWIFzMGQdk7khs0+3ojLrqAGWX5DKuRxl75nSUGKWIhtPBO+UiGIDQOAHpPhMpOqtjIicDlq50WiaGKl4FCvrcSynXYGq6Zj+hUj5fQ2YRYEzOieGlN4A5kbqOhGa1g3J9yqYy9BoNKkQguoFSMmFyMZjrVItUkXGs3qrfFTOlaiCxzOawE8pN6rgecg+M1zmIYxtG1S7B1E556U8llQ8Fk4iGuPegiClNyNmWSbEThm9LKXRNCFiesPJ+hJFI9mg4hEaHC1V6y1Pgv80QV4OjWYLJfgnUnwRynM8UjtfTENRhdDxE5ThzNyYtYc3PKjcq5GcSyG02kpaanROKzuxSLW1FJUw8qoaqt6G7MwtqyVDW240mqZEykkeZq2ssgkNmwiKTkKqv7E+Bn5p4HgajSY+IQgsRGzd2VQHquGo3MsxGkmxiZpHOVH2Xihbl/TLLpgbQZJFe9mQxipVEQet3Gg0TYmRDyS7WZnhSuANzDVjbkSK/oMEfocGZFDWaDSpYAP/F2DvVc/9a8q4KMCJyr0O5Tkxc+I1FiqVXD8CKrvRRamNVm40miZEKRdkHU1ip0OBrFMyMJsJhJDKJ8P+N43/BqjRbNnE86WLRfjx6zoEOnyAyr0JPGeCewTYuiLlD2Cu3Quz7HYkuKKxBG4wysgHx94kVidCGU2jkQrNqtzcfffd7LnnnuTm5tKpUydGjRrF77//nnS/6dOns8MOO+B2u9lll12YNSszWRs1mqZA5VwIKo+4Ck72BShnvwzNFgLfHFAe8JxKxp0dNZo2RUOujxDYdwI8ybsaW6Fyr0J1mIVR8ASGvSd4Rlt5r3yzws65gXABzanIxpFI4McGyNa4qJwLsXwEY50/A5wHoBw7N6lMzarcfPzxx1x44YV8+eWXzJ07l0AgwNChQ6msjL9+9/nnn3PyySdz5plnsmjRIkaNGsWoUaNYvHhxE0quaYuImEj1IsT3IRL4xUqy1wgoW1dU++lWVeHaNwOjEJV7EyrnEjA6AZlaSgoi5f8F3zto5UajSYCtvktKYVS71Pzlss9CZZ+Fsm8TaZKKRyGwCEtJqH3vCYFUIcUXbgo5b2Eo1z6odg8CLjYtr4Vf3pz7o/InNLlMzRotNWdOdN2KyZMn06lTJ7799lsOPPDAmPtMmDCBww8/nKuvvhqA22+/nblz5/Loo4/yxBNPNLrMmraJ+GYjZf+Nzthp3w7ybkE598z4fMreE1X4LBL810rLrrLAMQClHJZS5X0RMhl14X2ButFX9nrOYSNxZIRG00qJmVk4DYK/pVjsNtpqK+KHypeIv6RlgrkW/B+D+9CGydhIqKwjwDUYfO8iwaWgPCj3MKsIcDPQokLBS0ut1O+FhfFTNn/xxRdcccUVUW3Dhg3jrbfeitnf7/fj92+qoVFWZsXaBwIBAoFAnf41bbG2aSza2jkS3yyk9KbwJ9emDcEV4DsHVfAkyrlbWmOmfo62AmOr8HwAAcQ7DSl/lMb3kTHAvisEfyU1ZcUA10GWU3Tg1/B+DSMYckX91tRFn6PktJhzFHJCMJkMBirgQ4XvDSIB6/4TDBF1/6mDHaoWY9hiv/inQuPfu13gOC7a6JzBudKRW0lj2d7TxDRNRo4cSUlJCZ9++mncfk6nk+eff56TTz450vb4449z6623snbt2jr9x48fz6233lqnferUqXg8KayNajQajUajaXa8Xi+nnHIKpaWl5OUlLgjcYiw3F154IYsXL06o2NSH66+/PsrSU1ZWRo8ePRg6dGjMkxMIBJg7dy5DhgzB4dDhs7FoS+dI/POQkiuT9lPtX0PZt0553PqeI6n+Eim+IHlHowu0ewDDuYP15rf+4Oi0542B+2iMdlZpCLP8EfBOpqGJBoMhFx98fzOHDbgduy1ZleItE32OktO85yhcriD/fpTrYMzii6H6S+JbQz3Q8X0Mw4OE1iIbRpDqdaQKXmhQsEFrv3fXrLykQotQbi666CLeffddPvnkE7p3756wb+fOnetYaNauXUvnzp1j9ne5XLhcdU19Docj4T832XZN2zhHUr0WsVeT7OaijPUox/aJxzIrQarCuWys85LuOZJQJWJP5eb8D8ruRTkcSHAZYitOeY56Ydse1f42lDIsZSr0Idh9GRvebvPjSOm4t1z0OUpOs5wjowsq70aUeygAUngNsvF4ED+xFRw/lAxDtbsdQqvC958Uwscdu6M8A9JPshdrqFZ6705H5maNlhIRLrroIt58800++ugj+vRJXl590KBBfPjhh1Ftc+fOZdCgQY0lpqYtY7QnpbcmI74fmFQvxCw6A1m3O7J+X2Td3pgV9YwOSDlaw4b43gn/3QQRULaOVgbWwO9I1SwI/dn4c2o0rQFzA1L+P6RyCiLVKPvWVjSkK4FvjBRZNakCP5DyYzhrdEYUmy2FZlVuLrzwQqZMmcLUqVPJzc1lzZo1rFmzhqqqTVWQx4wZw/XXXx/5fOmllzJnzhweeOABfvvtN8aPH8/ChQu56KKLmuMQNK0d98FJMmcqsPUF+44xt4rvfaTotHDdprCSJOVQOcX6M81iccqxI9hizxWNCWYpYnoRoxMYHdKaJ22qP0WKTkM2HgVlN6NDyjWaGgIQWoqU344UjUGkylJw2t1D0sUR3xxSjliseq2hgm5RNKtyM3HiREpLSznooIPo0qVL5OeVV16J9Fm+fDmrV28Krdt3332ZOnUqkyZNYtddd+W1117jrbfeol+/TCU902xJKJWFyonncxNeS8+7LuYbk5hepPRaLKVmc/Oz9VkqJ6UvU/6dqfSC6q+RdQNg3UCa9lL20eCinhpNmyKcmybwPVL+sNXkm0vyKMQ0UjEEFiGiUzCkSrP63KQSqDV//vw6bccffzzHH398I0ik2RJR2aeBMpDyB8KFLcMYHVF541GuwbF39M1KXjCu6i1ErrDKLqQqj6MfknUSVE1L0MsEqeVnY25IeXyNRtNYmOCdikkIfB+S2ZeAzI0lIkhgMYTWg60T2Hdqc0teaSs3paWl2O12srOjTfnff/89ZWVlcZPvaTQtGeU5BbKOA/8CMIvA1hWcg1Aqfg0oCf6J5TicIPeCeCG0Fuw905Mn92qk+utwGvZU3tYaWGRTo9FkiKpwJGEmMcCxa8L7UTrIxmMR9cemBtvWkHcTyrV/RsZvCaRsy66oqODII4+ksLCQ/Px8xowZE1Um4fzzz+eQQw5pFCE1mqZAKRfKfRjKcwLKtX/yG4nykJJSkVLV3M12MXJR7V8G9yiiM2I50f4uGs2WhonK/k+dVgmtwSyfgFl0LmbxJYj3DUTiRzFKdTjVSmh59IbQ30jxWYj/k0wK3aykrNzce++9zJo1CxEhFArx0ksvMWLECHy+TSeyheQD1GiaBOUeQlKrir0fytaxfuMbBRj5d6M6fYEqnI5qPwNUPg0yTxvd0dXBNZpWRvY54BoW1STeN6z8VpUToXoe+N9Hyq5D1g9Fgn/VGULERErvrvm0+VZAkLJb28xzPGXl5pVXXkEpxT777MPFF19Mly5d+PTTT6MyBWs0WxLKsRM4DyRudW+A7LMaPo+Rh3LuakVSGQ3Mqt3ubozOi6HTb1AwDXA3WD6NRtNIqE6owikYuVdF+cRI9TdI2fVYL1c11uPwb3M9UjTOqldVm8C3SepeCYRWQOC7DB5A85GycrNixQo6dOjA/PnzmTBhAt999x19+/bl7bff5rLLLmtEETWalovK/x849w5/slHnkqp8FKl6N3MTuofVnSMNam6PhmGg7N2wIp80Gk3DyPRSsVVZWxVORDn3qrNVKp8m/n0gBOaacJh57eY1qU0dSqXwZ8sn5btkdnY23bp1w+m0TNqdOnVi9uzZtG/fnkceeYRFixY1mpAaTUtFGTmoguegYCoYnajjgxNcipRegVQ8npn5PKeCclNvBUfVstSo1pehVKNpPuIoMKodOA/P0BzhGB+VjyqYhHLsUqeHiID/ExIviRuIf/5mTfETkUb3a59avxZOynfIXr168dtvv0U5Efft25cZM2bgcrmorq5uFAE1mpaOUgoV/M16W6qDtX4tFf9DgksbPpets6VMqZq6aDYSLovVxmgPjp03jWUUgn0nmjndlUbTwrFZCkw85UbKwNEzvERdTxx7QPYFqJzzUfkTUJ0WJIhcMkkeQSkgm0VxOvdOruAYnSCGpag1kvJdbf/998fn8/Hkk09GtQ8aNIgXXngh44JpNK0J8b6UpIcN8b6akbmUczdUp49ReXdB1tGQNQrV7l5wH0OiS1pln4dS0dkfVM55xI/40lFZmi0dG+ABKSX+dSLgnQJ5N9R66UgD93Go/AkYuZehci5GuYejVHynf6VsYN+OxNenQtV6kbH2s6Nyr4jTP9wn99qMhZs3NykrN3fccQd///03p556ap1to0ePZuXKlfz1V10PbY1miyD0D4mjmEIQXJKx6ZTKQnlGY7S7B6Pd3aisUah2t4Hr0HAPO1FWneyzwTOm7jjuw1E5V2HdKGtuauHbgq1bxuTVaFoljn0g5+zk/aQSZW5EdZgNzsGk9WLgewPZMASp/iblXZRnLInvNzbIqpvoVrlHhP9ot9mGfFS7/6KyjkpZhpZOykn8cnJyyMnJibu9S5cuGRFIo2mVKHeSbMUGGPGvn1iIhEBKEbGhpBgwwdYDFcdXRikXquAxJPAjUvUOmMVg64rKGo1KkERQ5ZwD7qGI9xUI/glGNso1DLH1gqJj0pJZo2lThP4AX2ouF+Kfh8q5DKPwKUwzANUfQ8mVJC9XIiA+pPgc6DgfZbRL0DdM1nFQ/Tn4ZmK9jNRYlWyAoNrdi7LFrzenOr6HMr8Ec721FOXaP6G1qDXSrOUXNJqmxFtehd/rJ699LjZ7+qbXYCDI5zO+4ft5P4MI/fbfgf2P2wenywHuEVD1BvHXwk3UZnkq4iFSBZVPI5VTIiUWIrdGlQ/Zp0P2uXFvRsrRH+Xon86hoey9UXnXRjdWPIZE3Tg1mi0Mc731kwqVTyP+L6DweQwjD9yHIQWTkOIzse4LifxkTCubedXrkH0GAGIWha29TnDsHPVSo5QB7R4A5wGI93kI/g44wHUwKvtMlHPXhKIq5US5D03Yp7WjlRtNm+eH+T/z0h2vseijxQDkFmRzxLlDOfn6Y/DkppY9+O/Fy7lhxF1s+HejpRgpeOeJ9ym48nluf+d6thtwBlI1A0sN2VwZsIGtF7iHJJ1HpAopGguBH4j5ticlSMWjUP0TFExs1PVxES9o5UajSZ3gb0jJpdDuHpRtK5Rrb+jwFlL5HFRNT7KzWMqR+2ik/I5wKHdYITIKw0vLZ0Ty3ShlgOdYlOdYRKTN1YZqKDpMQtOqCAVD/PLF73z3wY+sW5G8WOS8aZ9x9aG38sPHv0TayosrefW+GVxx4M14y6uSjlG2sZyrDxlP0eriiAyhgHXTKd1QzrVDbqNofSGq4BlQueG9ar032LdDFU6Ou5wUReVzEPiRpGbs6vlW4c5GRNm2Jq2qxRrNFk8Iqj9D1h+AuX4YZtn9iFmMyvs/IJXiudVI0YnRig2AWYSU/xcpvzvmXk2p2EhwBWb5vZjrh2OuH4JZch0S+KnJ5k8VrdxoWgUiwjsT3+Pknudx6X43ce3Q2zm19/nceORdrP57bcx9Kkoquf/MxxEEMxRtfTBDJn8vXsHLd72RdO45z35EWVFFnTFqxqmq8PHuE++jXHujOn2KancfeCxnPlUwCdX+LZStcwrHaCLeKaRmKTEQ71Sruq9ZZP1kOm26e3i4fpZ+I9Ro0ib0N3gnQdGpyNpdsJSbRI9cAyQEoX+Ju4TlnYxkMDAhXcT/CbJhuPUSFlpqFfb1zUA2HodUPttscsWiQcrN6tWrWbFiRaZk0WjiMvXON3j4wqcpXlOyqVFg4Xs/cPE+N8S04nz40gICvkBcI4gZMnn3ybkEA4mtE/Nf/Rwx4ysOZshk/iufA2Gn3qyjMXKvtj4790j9rUoqwExujQrPCoFfkQ3DkHX7WD8bDke8r2ROyZFKyL4g/EG/B2k0DaOMxC8uCgK/JeljQ7yvZVasFJHQBqT4QiBAtPJl/S3l9yD+L5tDtJjU6441ZcoUevXqRffu3TnxxBN5++23OeSQQ5g1q3HN5Jotkw0rN/L8+FdibjNDJhXFFUy5ve4Fv+znFRj2xF/xipJKStaXxd0uIvz7+6qkMlZVZqCMgXKRnpXEa7051RD6Bym7GSkbn5KCI2LG7CfBJZhF5yDr94eK+7G0w9q+SVngOQ1yx4fl1ZYdjabhhLAUoESYEFrZFMLUpWo6lmIT795is5ybWwhpOxS//vrrjBkTnS9j4MCBfPzxx3Tq1IkRI0ZkTDiNBuCDFz9BKYXEuahCQZMPpnzCRQ+fgdO9KYLIne1KqYC22xN/Lfznz36jqiKx4qKUom//XsknSoJSLsS5P1R/RupOvFL376qXEddQcGxtjWN0jjgei1SB9yWk8iUwVwJuxD0ClXMW4EQqJ0LVW+H5a49dBRiQdzsqayRKWefMtG0F5Q9C6M96H7dGo0kVI/UyChlGqr8k8X0pBNWt2HJz1113oZSKKpbZrVs3unbtyjffpJ6ESKNJlXXLN2AYia0DAV+A0g3lUW37HbM3oWD88EvDZtB/8E7k5GfH7TP3hY8xbInnFhEOPe2AhH1SReWcn4FRDCg5H1k/GFl/MLL+QKRiEqZZhmw8HSm/L6zYAPisNfMNI5ENQ6xQVELU1QrDyk7Fg4CBBH7CLL4USi7Rio1G02SEmjHRXoZ9+hqZtJWbX375he23354HH3wwqr1jx46sWpXcfK/RpEteh1zMJMsshqHIyfdEte00aDv6D94Jwxb7a26aJqfeeFzMbZVlXj6e/gW/fbMEM5T8or537KNMuuZFQqFkNV8So5x7oNo9QGqRFfEwiar2ba5HKh6AjcdBcDF1b1IhrKioZMcpYG5EKiYgG48H//tYZmqNRpNZYr1QGeA8ABwDm1waAOXch8Qqg82qX9VCSFu5cbvdlJWVYZqbzFN+v5+///4bj8eTYE+Npn4ccsoBmMH45lDDZrDvqL3IyonOWaOUYvwbV7PzftsDYLPbsNltKKVwuBxcM/kidj8sOtmdaZpMvnkaJ3Q+iztOfJC/flhGKoSCJtMfeJsnrqj/mrNIADHLwH04qtOn4Dyo3mPFGD3sn9PQnDUGVD5DasX7NBpNvVA1S09q04/7SFTBoykFKEhwCVLxCGbZnUjlC4hZ0nCZso4HHMT3sQuhPOMaPk+GSNvnZtCgQbz33nsR35p///2Xww47jLKyMoYPH55xATWanjt0Y+i4g5j7/Md1HGANQ2F32Dj9/+rWUQHILcjhgXm38vPnv/PpG1/hq/DRc6fuDBkzmNyCuuUQnrjyed58eFb9LLACMx6dw/FXjaSgcwop1Gt2C/6FVDwRTqUeAJxW7RfZWA8hGhud0E+jaXQKX0RJEQR+tQINXAeibF2T7ibiR0qvB9+7WKUYFEIIyv8LeTeDI7alOhWUrSMUPBqOmKqdcdkGhKyim6596j1+pklbubnlllv48MMPmTt3LkopVq5cyb///ovD4eDmm29uDBk1Gi5/8lw8uVm8M/F9QsGQ5WAsQqdeHbnuxUvYOoFDr1KKfvvtQL/9dkg4x5p/1tVfsYnMBfOnfcYxl6XmWC+Bn5Ci00Cq2XSzqAZJMeW7RqNpQyhwDsJwbGN9dO6V1t5SenOt5J61LasBpOz/kJzUX7piSucaDB1mI96p4P/ImsOxOyr7tLRLvjQ2aSs3e++9N/PmzePGG2+MOBDvueee3Hbbbey9d8tZb9O0LewOOxdOOINTbzqOr2Z+R1WFj147dWfXg3bGMDKTg+WjqZ9iGEbMZH2pYtiMOo7N8RARpOQKED8Ns4jUXMY6m7BG0/woyLkCjI7g/wSkCqoXkPL1mXdvvWaV4Arw1ZSAiS2XlD8BnFGv8SOj2HuE69Bdm7Rvc5KWchMMBvn8cytZ2Ycffpixh4pGkyr5HdsxbNzBjTJ28doSDENhNsCVJBQ02apXx9Q6V38dnaemPuRcsynyyfSDr3kSfGk0GgCblXrBcwrKyAXPsQBI9TdI0RiS+6kJylZP64p/LpY/TDzlRiD0V/3GboWkpdzY7XYOPfRQevXqxZIlzZcCWqNpDDp0a5/UaqOUCmdJj30DsTttHHzyfqlNGPydxDejRBhg3xkj56xIi5gViH+Olek4Zaz1csgFyhsgj0azpVLj9GuCox8qf4Kl2NTu4dwTyRoZziGV6PrKApwJtidAF7qNIm3Ty3bbbZf5GjYaTQvg0NMOSHjbsdkN9j5yd7LzPHHDy8/+7+kxHZVjsXZFiFce6cikW7sw45kOlBWlU+HbQLW7PapFGTnQ7v7Uh1A54D4Klf8kdPoclXcH2LfDUngar9q4RtNmcJ+Ayr3ecqZt/zpG++lxHX9V1skkVmxskHVM/YtgplToNm1PlFZL2kf64IMPcvTRR3PjjTdy6aWX0qlTp8aQS6Npcjp0LeS0m0bz4m3T62wzbAbuHDfnPTAWMYXHLnmWhXN/iNyrOvXqyLjbTmTI6YPjjr9k0d+s+H0Vbo+Tr2YvYtakD1CqM4ZNCAUVk27rwpk3rubYc1KpLyVg61JXTvchmM59ofrzJPvbwHMKRu5VQDi403MCynOCNXrF40jFw9TvLVBbfzRtEYWl9Atggud0VO4NKJWijcCxK7gOCzvibn5d2UBlo7LPirVnargPg7J8kFJiX382cA+r//itjLSVm5oQ8HvuuYd77rknaptSimBQOzVqWi+n33I8OfnZTLnjNcqLNi3v7Lzv9lw68Wy6bWMpFHfPuYm1y9azaukaPHkett29T1wftD++XcqDZz/B0u//qbNNRGGa1ptaMKB4cnw3svNCDDupOImkIfB/CrGylebdBhuGkzjBng3lObmuPMF/IbQEsfWh/gqKVmw0bQyVC56zQNahjI6WxdPeI70hlIL8h5Cy26HqNaIUHHtfVLsHUfbu9RdROaHdf5GS84ksk0WwgdEBlXMxsLDec7Qm0lZu9JKUprlZtXQNM5+cyx/f/YXD5WDQkQM59LQD8eRm1elbVelj3suf8cU7Cwn4qtlmtz6MOPswuvbtHNWvvLiCdya+z+xnPqRkXSkFW7Vj35F7ULaxnJ8+/Y2fP/+d8wdeQ7/9duT8h8bSZ5debNWrI+5sF5+9+TWLPvyJLn06MWjkHjjdTv79YzUAx3c+k8riqjSOTpj83y4cOroYe7KrU+KMW/UGSc3TudejbN02DRVcgZTdAtWf1upkUH9FJZn1xk1UFmWNJlMYfcD8O7Nj5t2JkXV4g4dRyoVqdweSc6kVQSXVYN8RHP3rvxxVe3z3wVA4Bal4tJb11mktd+VcjDILGjxHayFt5ea5555rDDk0mpR498m5PHzhUyilMEMmSsE3cxbxwvhXufeD/6PPLpvy3Sz/bSXXHHYrG1cVR/LiLPpoMa/e/zYXPXwmIy+wTLQbVhVx+QE3s3bZesS0Hsir/1rH6r/WRc1thkwWffQT5wy4iutfuoRli//l1ftmEAyGsNkMQkGT7HwPx156BG88MpP/PHMs1b50LZmKorUOjurTn132ruCCO1fSe3t/zJ4rlubQc5cYG6peIbFiYUBo081fQmuQohOgThbThjgmJlOKdNkGTSORScVG5ULeHUkVGzHLwgEChuVUrBKXT1G2jpB1bObkrD22cw9U4WTELAazAmwdUCr84mduOddd2srN2LFjG0MOTSOw+q+1zH7mQ/79czWenCwOPH4QewzbtdWG8P8w/2cmnD8JIFIhvMaQWFZUwbVDb+fFvx7DleWi2h/g2qG3U7y2NNzP6lgTDfXIRU/Tfbsu7H5Yfx4483HWrdgQUWySInD3qQ9HPb9D4fIQlSVeXrx1Og6Po0HHaoYUP3yey3mHbM+NTy7jgCNLa80Fy/90c96hz3LmXX5Ouu6YTaJJCMxkmY1NCK2MfJKKiWHFpinLKejSDZoWTvb5qJxLE/rUiFmBlP8Xqt4Eqq1GlYN4xqJyLkSp5nPgVUYBGFuOpWZz0j7zL7zwQsLtY8aMqbcwmswx7b9v8cwNL2EYBmIKhk3x3uR5bDdwa+6ecxN57XOTD9LCePWBt7HZjYgiURszZFK8tpQrDx6PYRiEgkE2/Bv/IW/YDKbf/zad+3Ri4Xs/pC9MCjUmM4GI4q7zezF5wK9s1T1AMAj+KoN7L+4JKJ65YSq/L1xKt206s8ewAex60M5WFFTCcHAbGIXh8QPhZSytbGg0mzBQnpMTKzbiQ4rGQvBnoqycUgGVjyPBvyD/fxlZbtKkT9rKzbhx4+L+s5RSWrlpAcyb9hnPXP8SsMlSEQpaT9slP/zD+GPv48GPb2s2+eqDiPDt+z/EVGxq8/s3SyzFIsn9xAyZfPvBj/z61Z+ZE7KRME2Y+WJ7Tr9iLR+9mc+0h7di1T+bzN6fvvEVAK/cO4OOPTrw4Kwj6NT+NeIrLCFU1ijrTykHYi97aTRbJoZVvNbWOXG3qtchuJjYbzIC/tmI/xiQUsQ/DySAcuwMWaNRNh1l3NjUy2amnYpbLiLCS3e8FvEx2RwzaPLTgl/5/ZslbL/nNs0gYf0QEULBFKwLstnvRF1NwTBawVuVKF55pBOvPtYJMRPLu37FBs7bv5xp3+fidJVTV8ExwLEHUr0Q8U4H5WFTIj+NprWSwaV2xy5WzqckiHdakh4GlFyC4KPGOV/8H0LFo9DuHlTWyExIq4lD2t8I0zSjfkpKSpg0aRJOp5OZM2c2hoyaNFj/70aW/fJvQgXUZjf44p2WGw7or/Kz6KOf+Hr2ItaHl5YMw8DtSeyklw5KKTr36UTJ+rKkVp6WgUqq2NRQWern+f+NBvvmyquV1ZjAQqiYAL53oOpVtGKjadXY+2FF3zUUJ+Tdjip8yUqImYzQKhK/RZlsigg0ieTHIYiUXo1UL2qgvJpENNjbKS8vj7POOoupU6dyww03cPjhDQ+X09SfgD+5N7xSioAvs17z65av590n57L4099QhmL3w/oz4qxDKdgqP+UxTNPkpTte57UH38FbVhWRdZ+jBnLEuUPxVWZu+UREWPP3Oh6/tG1G/815/hfOefBtCPxIyL+YFb/7cGVV0bn9w80tmkaTWYKLgQy8+LiPwPCcmHp/ox2EUiuSG2NnpPJplPOxeu6vSUbays3y5cujPodCIf744w++//57/H69dt/cdOzRgex2HipLvXH7BAMh+g7o3eC5vOVV/PDRQn6Y/zPvPjkX2OTj89OCX3n5rje4bca17H5Y/5TGm3DBU8x66oOolyER4atZ3/Hjx7+gDJV6RFMcMjFGwwSAgk7tCAZDlG9MpwZUelSWVgIwY9IqXvnvJ2xYuZEnPvwDswBaabCcRtO4+N5G/EeA84CUnIBV1rFWPpl6pUwIgX8+IqIdjhuJtJWbPn36xN222267NUgYTcNxuhwccfZhvPbQuzGLQCpDkZOfzf7H7VPvOUIhaxlj7LYXxU1QJ6ZQ7Qtw89H/5fk/HqZDt/YJx1z6wz/MmvRBzG1m0AxbchqulDjdDqqrAs3nNyZQuqGc/E71rPybIja7jUlXv8hrD74DQMduAfrsqJPmaTTxCSHFZ4FnDOTemFzp8JwC3pfBLKJ+S7tBUop+0NSLtN/hRCTmT48ePXj88ccbQ0ZNmpz2f6PZZrc+qM2cZW12A7vDxs2vXoHTVf88LE9fa0ViJUtQJyIEq4MRq04i5jz7ETZ7/GKN1vcsPTnroMDvrW52h3gzZFK6vrRR72kujyui2AC4s3SlYI0mJbwvgC+5/6gyClGFL4N9h3CLQeSiNurWfdtsb7Bvl3pdKk3apG25mTdvXtRnpRSdOnVi2223xWbTlYRbAlk5WTww/1beengWbz/+Huv/3YjdaWfwCYM48eqjo7L4psuqpWuY9fSHnHtIamvTZsjkmznfM+62k2JuX//vRiqKK1jz97qYlqaM0oKC/JKFtDeUzZcl16104vMq3J4WdBI0mhaJQiqfA+cgMNeCURg3LFzZe6I6vIlZ/QP4F4ASUIVQnizaSlAenTalMUlbuVFKkZeXx4ABA6La/X4/fr8fj8eTKdk0DcDtcXHSdcdw0nXHEAwEsdltGVnb/XDKAgxbeuOEAnUtPN998COTb54WyTOzJS47d+7dkfX/bmx0RQesxH/vTSvkyDEbsdUrjCAHaDwfIY2m5SAQ/AlZvy81b0Ti2AuVewXKuXvd3lWzoPJxCP6R+hSu4ZB1XIbk1cQibZvYQQcdxIUXXhizPS8vLyNCaTKL3WHPmNNa0ZritHLD2OwG/fbfMaptwRtfcd2wO/j1600J9ERo+LJTKyO3Q15a0WQN5fl7u7BiqYtQuuWuAK3YaLY8at2QAguRotMQ/+fRPSqfQUovg2AayUBVO2j3gF6SamTqdXZj+SxUVlY2uy+DpvHp0K09ZhrRRmZIOCpcoBKg2lfNf8c8bH1XtvCvy9Lv/yYYDHH81SPTtobVh8oyG5eP3JZXH+tEWXHNEnItPwGNRhMHEwghpTcgYllaJbQKKb83vD2Nm5mUovTLQqOTsoH6kEMOifz9yy+/RH2urKxk8eLF5OfnZ1Q4TcvjsNMPZOo9ryftZ7MbhEImlz1xDr127B5pv3nkPfi91Y0pYqvBDJqUrC1l+n1vN9mc3nIbL9zfjelP9OGJ726hU5d/oOSCJptfo2m9CJiroPorcA2yMnyjqN9bWsMK62qSk7JyM3/+fJRSKKUoKytj/vz5dfocdthhaU3+ySefcN999/Htt9+yevVq3nzzTUaNGpVQhoMPPrhO++rVq+ncOUkdEE1G2KpXR469dET8Dgqy8zzsOXwAx156JDvuvW1k0xfvLOS7D35qAik1sajJ8dOhe3tuee1Ktuq9NYGit7ChUFu6GU2jSZXQMmAQhP6px84GOAagjOwMC6XZnJSVm7FjxwLw/PPP07FjR0aM2PSA83g87LDDDpxxxhlpTV5ZWcmuu+7KGWecwbHHHpvyfr///nuUf0+nTroIWVNy+i0nMHv2bLLzsiip2pTpeJcDduSyJ8+l5w7dYu739HVTmkpEzWbUdrnq0K2AHz/5lf+OeYQDhn/LaVcIevlfs0Wjcq0yDoEvUusLoLJJf0nXRGWfk650mnqQsnLz3HNWmvp58+YxcODAyOeGMHz4cIYPH572fp06ddril8BEhAWvf8kbE2by+9dLUDaDPYcNYPQVR7HLATsmH6AB1DgnT/7zYX77YglVFT567tg9rlJTI++K31Y1qlya+IgQ8dj+9Ys/+eVzK7JjUU4uY65a24ySaTTJUFjRel42Jctzs6luU0MwwOiE6milOJH1g8Fcl6C/G1yDLancw5GqV1OcxwaYqNzrUO5DkvbWNJy0g0L/+eefRhAjPQYMGIDf76dfv36MHz+e/fbbL27fmhD1GsrKygAIBAIEAnXrK9W0xdrWUhARnr7uJd59ci6GTaHs1mv3dx/9wDdzv+fC//2HoWMParT5a86NMhT9D9qpTnssQqEQdneDS5m1GhxZ9qjfTY1SYU+AJKtNfy5ux28/5LP1TlXNEo4fDLmifmvq0vbPUTK/FQNsXaDwFZS5EiSEEISiUyI96neObKBcqLyHUeF0DOK+HCkbH1/SnPNQIReEAojaA1F7QOAX6mYoVpbcjj1A2cGxLcp9LMreHZrx2dIanm+JSEduJfUIcZo4cSLTpk1j1apVkVT8YL3RL126NN3hIvsm87n5/fffmT9/PnvssQd+v5+nn36aF198ka+++ordd6+bfwBg/Pjx3HrrrXXap06dqnPyaDQajUbTSvB6vZxyyimUlpYmTT2TtnIzYcIErrjiCqBuSLhSKkrZSYdUlJtYDB48mJ49e/Liiy/G3B7LctOjRw82bNgQ8+QEAgHmzp3LkCFDcDhapkf7zSPvYfFnv2GGYv/rDJti5PnD+M8dJyMiLP9tJeUbK+jYvZCtejfcP6k+52jV0rWcP/CaBs/dWnBk2TnjmeN49szXCVTVK7FMk+LKMtl/RAmHjS6mY/dq3G4TT55Zx6PANGH1Mifd+lQTMsGW1FdHgX0nMDeCuabO1mDIxQff38xhA27HbotfeFd1/ASpehkqJqZ9bK2dVM9RqyHnUpSRi5Q9AFRhLSAku0bskDUSI+8mAKTyeaRiQmRrOudI5T+ECi8txUPMCvC/j4TWoowCcA1F2Qrj9w/8jPg/AapR9m3BdRhKOZMcU9PTGp5viSgrK6NDhw4pKTdp28yffvppAA444AA++eQTOnbsSNeuXVmxYgUjR46sn8QNYK+99uLTTz+Nu93lcuFy1TVVOhyOhP/cZNubk18//xN/ReJw6l+/+JPv3v+RSde8yPJfV0badzlgR4aOO4iF733P4k9/w7AZ7D1id0ZdPJxeO/VISw6Hw0HxmlI+n/ENvko/vXfuwZ6HD4jUiFrzzzpW/7WWnPxsfvnyDwK+wBaX2yZQFSRQ1fJNwIEqmDMllzlTLGdJwxCOO289x527noKO1oOnsszgnec7MOXBrbj/jSX8/LWHQcPK6do70XdRoXIPA88ZEFyMVM0B79N1etltfhz2eA8lO9htYJSAPUTyB2HbJPE5akX4nwdZW+vpk8oxBcHmwwjfk03zS4hxLuKfIxsQguxzMXJSieotAFdqJWYAcAwAz4DU+zczLfn5loh0ZE5buVm6dCmdOnVi3rx52Gw2+vbty7x58+jRowc77bRT8gEyzPfff0+XLsmKlLVugoEg//6xGhGh27ZdsDuT1/CqKKnkppH3oDZ791786W/8tOBXDJuKWH5mP/Mhs5/5kBtfvpwD0qgW/vCFT/HeM/NBWZY3M2TSvmsB/7njJD6csoBFHy2O9PXkZW1xik1rxjQV0x/vxOtPdqTHNj5sNlix1EXAb2CzCU+O78pv32Xz96/FXPW/FQlGsiHuIzGUAY7+SPmEBH3jEYT1e9T3UDQtDamPA7uJcuxce5AU9jHA2AqotsKvPaehXPH9MzVti3p5O3br1g2lFHa7neLiYlwuF4WFhUyYMIGrrroq5XEqKipYsmRJ5PPff//N999/T2FhIT179uT6669n5cqVvPDCCwD873//o0+fPuy88874fD6efvppPvroI95///36HEaLJxQKMf2+t3n9fzMpWVcKQE5BNp16tKey1JuwJtGav9eBgGx2E6hZSqy9pBUKmqDgzlP+xwt/PkKnnh1Tku+jlz+NZBqumadoTQn3nzGxTkVyb1lVSmNqWhZmSLHs96yotlBI8cs3OQDMfbWAorV2CrcKsu0uVRw6uoicdrW/l0HYeAJm1qngewdCadTf0WgAyznXCVmjNjU594DqBQn2sYFzX4zCZxpZtrqI/zPE+yJUf2c5EzsHo7LHoByNG8WqiSZt5aZDhw5s2LABgK5du/LHH38wfPhw/vjjD3Jzc9Maa+HChVFJ+Wp8ecaOHcvkyZNZvXo1y5cvj2yvrq7myiuvZOXKlXg8Hvr3788HH3wQM7Ffa0dE+O+YR5k37dOol5SK4koqSirjvrgopXB5nPgq0zRfC4gpzJz0Af+54+SEXf/52XpTlxi6lYRLM0gaJRo0zYsyYv8vU9ybbz/OxbApPpguPHNXF657bBn7Hl62qYu5FiofyISomi0Oy0qt8h9CGbV8LMwNSfYLobL/03hixcEsnwCVjxFZBhPA9xbiexPaPYjKSpAAVZNR0k7d1a9fP1asWMHy5csZMWIEIhKxnBx66KFpjXXQQQchInV+Jk+eDMDkyZOjMiFfc801LFmyhKqqKjZu3Mi8efPapGIDsPD9H5j38qexlZgEeoOIsOtBO6dV3LIGM2Ty4ye/JO234PUv0x5b03JxOBu69q4wQyCi8PsUt5/dmz9/rG3t0Yqupj44wX04qv10lHuTn4yY5eBNll/GDo7dEdOLeKdhFo3D3Dgas+QGJPBjo0gr/gVhxQaiQ8NDgImUXoWEdK6vpiJty81TTz3Fhg0bKCgo4P777ycQCPDVV1/Rv39/HnzwwcaQcYtk5qS5GDYDM5T+K/XPn/+eVnHL2gSDQX74+GdK15dR2DmfnfbdHsOI1oHLiytpj04f3lao9mXQ4VmsUg7TJ3bkhonLk/fXaKJQYHSEDvNQyh5JGCrBv5DKF8A3B6SS5E7IQaTqXUvZMFcTyaUT+BnxvYZkn43KuSoyfiaQyslELDYxMRHvK6jcyzM2pyY+aSs33bp1o1u3TZlon3rqqYwKpLFY8fuqeik2YC1d2Z12gtXpR5X89uUSrjp4fORzp14dueChcew3aq9I21a9UvPJ0WyZhEKKz2e3Q4RmSQyoaa0oQKHa3YkyNlkTxf85UnwOltKQRqqRyoetFATWKOHf4f0rnwJ7X8hKvexPUgLfJZHPhOqFmZtPk5B6VZTZsGEDt9xyC8OGDePcc89l8eLFvPDCC1H+MZqGkVeY06AHw75H75kROdYtW8/44+5jwRtfRdoOPllHHGgSE6hWpJ8eVNP2SB7ZuYksVOELUTloxKxASi4CAqSl2EC4jEK8fRRSMalOrraGkcLjVKVzPjQNIW3l5p9//mHXXXfljjvu4IMPPuCnn36ipKSEcePG8eijjzaGjFskh5y8f4M8FY445zD+c8fJONzWG5ARzrZmd1rGus2jmZLx+GXPRRI0Fm6V3wDJNG0fwe0xMer16qRpW6ShkCgHGJ2j23zvglSQnt+WLRwCnmhhQiD0Vy3LTgZwHkBiZU6hnAdkbj5NQtK+/VxzzTWsXr2abt26RbTe/fffn7y8PObOnZtxAbdUDjv9QDr37oRhS99806FbIbsetDOn3HAs01c/xTWTL2L/Y/fG4bKWqgybkV40k8CGfzfy0ye/RjVf8thZEWUpFbpt0zmiZGnaMgqf16Bkg8HjN3flkiO24cpj+jLn5QKCAfj24xzmTs+n2qe0q7FmE1KGbBiO+OZtagr8QHrWHxuoPHAOSrF/5hJCWtFZ8VwJDFBZ4DkuY/NpEpP2k+aDDz6gQ4cO/Ppr9IOuV69eLaKoZlshKyeLB+aNp0O39mnve/5D47DZrBtCdrtsbA4bn0z/goDfupDr68uzYWURoWCIb+da0QauLAd7DN01tZ0VrPprbb3n1rQ2FCf278eMZzry+yIPi7/K5qEre3JEr/7ccHJfnru7K0631Cnv0PS4oAVIoQHLOhNESi5GQjWJ/tJ8RGUdi+rwJsp1IEkVF6OjlZOm8gXE/wki9SsdVINy7orKuxNL5toKmQHKjSp4CmXEL+GgySxpOxRXVVWx7bbbkp0dHS1TUVERVcNJ03A69exIu455rF+xMaW14Y492nP+g+OisgybpskzN0zNiDxr/1nHKb3Op7ykgnOnnsh9Z0xEpfrqLXVrkWnaMsImpaG28mD9HQpC6UYbWe2aWq7aKFJL/d9SUCSvoN3cpFInKhFhBcf7Cir3EpTrAKRqegr7WcqEkXc9yuZA3B2gvBDMEuJaU8wiKLseqTmnxlbQ7m6Ua/96S688o8E5EPG+HHYwtls+RFnHo2wd6j2uJn3SVm769u3Lzz//zJQpUwCrMOUjjzzC33//Tf/+/TMu4JbOyj9XJ1UKuvbtzBVPnUe/A3aIWGxq+GPhUtYtW99gOXILc3h+/Ksggt29KZIho2HEmjZEYmtIyQYHJ+zSj4494MSHm+tx3ZKVhBioPLA5IfRvc0uSgEws85hQ/SVwCbgOtZQOM1nJhujvm1JOyH8SKR4L4meT74/BJmWnpi38PTDXIcVnQ+EUlHNgvaVX9j6ovBvqvb8mM6S9LHX22WcjIowdOxalFN9//z2XXXYZSinOOOOMxpBxiyY7z5NwuzIUXbfZil0P2rmOYgNWTppM4Mm1krLF07MymS9Cs+VQssF6v5o0vquOrkpKAEJlybs1F47MR1Eq5YCCZ0i+dFh3SUk5d0V1mAmesZaCpHKtCvVxxxJAkPKHGia0pkWQtnJzySWXcN555wFEMgoDnHPOOVxyySWZlU7DIafsn9AJV0zh4JPim1G7bL1VynMlymq8dtn6hE7IIkLXvltpJUeTJtb3Zc7L7fnxi2xM01KgtaITA/ECLVS5cY+CnEszNJgBzr03fXJsB57/EF8pUYA79hZbN4y86zA6LcDY6ltU1sgE4wCYEPgas/xRxDcHkda0bKmpTdrKjVKKxx9/nKVLl/Lqq6/y6quvsmTJEiZOnNgY8m3xjLp4OJ68rJgKjmE36L5dFw46cd+4+3fftgs777d9XAVJKUVhlwKeWHQfh50+OO0Q8dpUlnq1X42mnghTJ3Til4UeJv5fV+6+oKdWcFoDqhN4zkK5Dw67BHVq6ICAHeU5Mbo15+Kw1WXz+5gNUKj821IaXcziGGPEoPIRpOQSZN2+iPf1lMbWtCxS9rl5++23KSwsZP/9LStB79696d27d2PJpQnToVt77v9oPLeMupe1y9Zjs9sAIRQ02WZAH25982qcbmfCMS565Ewu2/9mAv5AVLSSMhRKKa546jz67tobb3nDKneXbijnuMuP5M2HZyGmaEVHkwaK7xfk8f2CTcUR89sH6LZ1NaapyPKY7DO0jPwOmQvd1cAmB+VEZQM2xwDnfuDYCbyvgfdpy6gEYHRK7Mrk2BuVPRYJ/gkVD202rw0wUPmPoGzR+W6UkQ2FU5DKp8E7FaTYkt25PyrnPJTqD8xKfrS2LkhKxxk+CClHyq4H5URlHZXCfpqWQsrKzahRoxg0aBCfffYZADabjX322SfyWdN49N21N88veYSF7/3Ar1/8gc1uY/ch/dlp0HYpLQNtM6APj3xxJ5OufpGFc3+IXLc77LkNZ959KrsetDP+Kj+fv/V1g6p5GzaDjauKySnIpmxDeb3H0WhAmPFsR2pHBxk2OGrsBs65ZRX2BtX6DDuV2naCUPJCsW0OowuobCuBna0LynMS4jwAql6FyidI7mhtQnApVC+IsWkD1vlVVr+IA69A1kmovP+zakZxGOI6AKmcAoGFgB1cg1GeU1H2njFnVUY2KvdSJOdikDIrvFqFl6MCKQY2uI+AsjtJN0pOyu8F9whUihmGJbQK/J8BIXD0Rzl2Sms+TcNJK1qq9pt4bX8bTeNjs9nYe8Tu7D1i93rt32eXXtw95yY2rNzI+n+LyO+YF+WP4y331bvYZgQFn7/9Tb1qWmk00dQNHzdD8PZzHfBXGVz+wOYRQy4ofAu8T4BvFla6fqwII/uOVoSRudJqs/cDz+lQ8V9afmh1IyBBjE7RVg4FiH1rJNVzYcarbh1WaOw7obKOQkIrrdwu7iPqKC3K0Q+Vf0/a4itlgMpPez8AZeRC3nVI2a3p7WiutUK7nYnL2ohZgZTdBL7Z1P5eiaM/qt2DcRU3TebR6WK3ACpKKln/70YC1QE6dGvPjntvS5ett0JEIiUVcguycbga9DqMGTKprqrWifo0jYaIYs7L7Vn51+ZLsUEUpRj596E6fYkqfBny7gCyIfAVmGs2dbX3smr8mBuov2JjgH0XcA0BGnLd2GnyJIKyHqmo6yMp/k9ILxtwPEwI/gSugzHybkTlnN+iHurKcyqq3b1gdE1vR7Mo4WaRkFXg0zeHOt+rwM9I0clIaEN6c2rqTdp5bjSthx8/+YUpt01n0UeLAcjKcXP4GYew1xG7MfPJD/jinYWEAiF67NCVYy4eQcce7Vm1ZE2SUeOjlAJFg5a2NJpkGDZh3psFnHZl7dwngpRcCh3no4xcxGgHZXcA1eHttfwsfDMh8BPROU/SJfwAD/5khRhLkPopSs1j5ZSKh8A9FGXvu6nR9JJ2ccpEmOuAXpkbL4OorFHgHgnBxYj/a6i4N/lOtm6Jt/s/CS+xxSIE5kbEOwWVe1ma0mrqQ1rKzaJFi9h6663jflZKsXTp0sxJp6k3C17/kttPfDDKJ6eqwsdbj87mzYdnYdiMiIXl399X8fBFTycMBa9BKVWnIGJNraptd+/DHwv/yuhxaDSbo5RQWrT5rcsEcy1SNBZyr0S8U7GWpmIpLyaE/smcQBL2L1NbgSRLNtdSsCGVL4K9B+L/CkIrrEKSmcTomLSLhDYCATA6oFTTvmsrZYCjP9j7Id4Xw9a9WAqqAfa+YN854XhSNYPEjtkmVL0OWrlpEtL6NlVXV0fVj/L7/VGfdY6TlkFVpY/7/vOY5Re1mRWl5nPtpaMa1ykzlPzNs++AXux33N5RbR26FXLU+cP4/es/tXKjaXRCIUWn7tWxNwa+QYpOpFl8aWQtYICtZ2aVp0YhBFXTwj42mT5PBtj7oey94/YQ3xxraSwYrlFoFILnNMg+G6VcGZYnMUoZ0O5WpPi8GulqbTUAA5V3S/Lnm2wgqeXLLK6/oJq0SFm5OfDAA7Xy0oL487u/eP1/7/LlO98SDATZdmBfjrl4OAcctw8fv/I5VRW+Rpn33z9W8+b/ZjLmqVGApdBuXFXEM9e/hM2RifV6jSYJAgePiveQkM1+NzWmZQVpFTSGb5xV/0rlXRu3h1Q8hVTcR5SvkVmEVDwK/q+g8BmrfEITolwHQcEzSPndEPxj0wb7zqi861HOPZIPYnQjaUj9ZiHumsYjZeVm/vz5jSiGJh0+nv4Fd53yP5SCUNC6Qf3y+e8sXvArR5w7hKxsF//f3n3HN1W9Dxz/3Juke7BLgbL3LrtsEChDAUFkOJCl+ANlqAiiAoKiXwVcICAiiCIgyJAlS0DZUwHZlA1lt9Dd3Pv7IzRQm6TpXs/79eIFuffcm5NDmj454zlGk4H4uHQcP38oOiIGs/Z4r4+OOd7yi8ScAc8nRFIKru7ZeV6Xmdy3CsvJ16P6ofh+jGJnVZEefwH9wWcJj/5z1pIdmMhF4PliWiqbKoprE3D5DeLPgHYTDH6J5yQld73HM+jRyx2UUFE8eqW9osIpsloqh7l97S4fP/8FmqZZAxt4NMy0ZtZGrp+/Kcv0RbaV1h5gFzcND6/sHkj/d2gjp3Py80QPRzfYXxmlRy0hufbQI39MQb3Sl6IoKKYKKK6NUxTYAGCqZ8mjY3P1mwGMZcFdgpvMkht+6vKU9d9tsQQydj5rVFXhyulriQIfIbKL3mO6WYYvUxnfKIpOm2fuoKg5Yf8pI3gMQPEaZsmtk21k4MRdPRJu90CLWoN2/3O0+1+ixx549GUr7gyO56XoYL6QI7+cKYqC4vspeA62JEm0MlgSABZYiKJ6ZVn98hpZCp7DnNh72mGyPU3TuXj8MkFP1WPP2oOSc0ZkK79+sdpmkkfVoFC5YXlO7Dnj8HpdV9i3xZsDW72o1+pBss9386qJLb/m4/Z1E/kKx9O6212KBjiZzdYuZ4ecNFB9wbUZxF+E+KNpfN504P0uxP4NMWtJ12Xfj9NvQ9gILL9edPSIry3BXf4ZoHqS/BJ8txw7v1NRjCjeI9C9BkPsP0A8GCujGApmddXyHOm5yWEMJkOyP/iq0cCYn16nfvvalmuMKgYHO4sLkVliIm2vctI0neIVnEuqdvOqKx8NLk3kfRWznd/Pug7z/1eUFxpUYd7H/qz5oSALPitK30ZVmDmuGFqaYn5nf5Y0ePAF+u2nITq9Nl9Myy99Bcw3wKMnGRbYJBL/6Hnij6PfeQFcW+E4sDGAW4dMqFvGUhR3FNeGKK5NJLDJIvIbL4epH1zbYYp0RVEIbF0ddy93Jv02hi92TKJak8qJJgELke3osPnH7U7vSh/5wMD7fcsQF6NgtpEHb9mswiz83A9dU9A0hfh4Fc2sgK6w/NtC/DjFD1At2zOkmBnyzwW3Ls6VTVeWzSVTR4fI2XB3IJhqPXa/zGAG8wXQosBY3s7zKoABxbN/JtVJ5GYS3OQwrfs0xbegj93eG13XuXDsMg/CIvj18zW80/Ej/tn2b+5auCFyrZRktz66x4uBLSrzyzdFuHTGldDLJqIiFaIjFX7+ooiDKxWWflOEyOgqD/cKSukveAOKS2PLVg9eb5KQC8Vyn9QGC05+FPt+Amq+hw+Mzl+XSDTEHQUlP5gCARfLH5dG4NIxFfdzlgIx61DyzwNjpYfHjFhnRyheKPlno5gqZmAdRF4hc25yGHcvd16fPoCJPafZLXPz0i0mPjuVgxv/ycSaCZH57txw5/vJ/nw/2R+AstWieG7EdR6EOf5oi4lWmf1hawZNKo8nm1PwjCq4tLUkfgMUr5fBvTNELUc3X7JMJI1cREp3nbZ8+3B1fJ2pLqr7U+huwRCzGT3uJMT8CfHHSHnOGrNlZ22DH2rBo+hRq9DD3uHRdhUZQQctHMVQBAouh9i96DFbgVgUU7WHu267ZeDzi7xEgpsc6MhfJ1ANit2MwpqmS2Aj8oT/5lY6d8ydz98q4dS1677byob52/hqQ3XKVj7q5GwWDeIPocedRjFVAEAxFAWvVy3TjM030CPnp+AVqICC4vsx6FHo4e/bKQOK9wjL34qLZV6KSzP0iDmkPhmfGaLXot08BebTqbxHSjxcDs3DdACuDVFcGyZzjRCpI8NS2Ziu64Tfvk9EWESi49fP33BqqwQhcjvVxkT5+3ed36XbHK8ztI3KgZ1P/Gf5rgPaLfQ7z9ve4VnxxKlJv6o/uDQGz1dQCm9Gce+C4tELxfcTUP8zpGa0DNMopqr/qfx50t7TomdSYANgRvHomUnPJfI66bnJhszxZlZOX8+vX6wh9PxNACrULUvPUV1p0SMI7wJeGIyq5LIReZbBqOLu5caDe5FpvpemKYzrfZdFlzfj7bESIhaAdtnBFWbQwyBqEXgNTXRGUT3RXVtCzFYcTnRT86EWmJfksOL+tGW36riDoIWBoQQq5YC1Nm6SuVsUpJl7TzDVzepaiDxCem6yGbPZzIe9pzFz5HxCL9y0Hj9zKIRJPafy06RltO7dTAIbkae5e7vTqk+zdLtffLyZHSsPoXr2Qym8+eEO0I56YDT0qN/sVO55kp3BH38cPe6UzVOKYkBxqY/i1gbFVNn+PYzlLT1AGU4BQwqz9T5OLYriPRbFZ0KOzV8jch4JbrKZLQv/4s9leywZOh/7fExYRTLv/UXk9/OlRrMqNrvkbR2zx+QqHXciZ6rbthaVG5ZPt/upqsr9O5akgJZfwLEkG6Do920eVhQnv3jE/e18BW0+j4ri9aqDEiooRUhbbpyEJ/PA+ZVgBssmkgV+Rin0O0rhP1A8+1onYQuRGeTdlgki70dxYOPf7Ft/iLs3whyWXTXjd1QHuT4MRpW1325i4m+jafSkpYtXURVrUFO0dGGncoUUq1A0RYGQENnJtiU7+bTv9HS7n2bW8C/72FwXQzkc/zJXwVDWzjknvzQo6ZBjxr2nJd0/YKmvgrXeamHQb5H2PBAuoN3BuZw9ruDeA6XgUlSXuijGMijp8TqFSCH56p6B4mLj+G7MQlbP3EBMlGXin2pUaflsY4Z+NQDv/En3GTl/7JLD7RXM8RrnjlzE08eDCctHcfn0NfatO0RcTBzl65QlsHV1Xiw/lOshN+zeQzWoBFQsxtXT19P+IoXI6RTwzu9Fo6fqPTrk0Qs9Zr2DizQUj962T5lqAW5AtIPrVcuE4jRSFAXFeyS6e1f0qKUQfwlUbzDfhdiULHF38By+H6E/mJF8QUMASsFVKKqTE7OFyEAS3GQQTdP4oMcU9qw5mCgxmRavsXXxTkKOXOSLnR/i7pk4r4OruwvRD+x/KCqKgrunq/VxiQr+lKiQeNz9qcHtmDPmJ7sJ0TSzRs0WVdmz5mBqXpoQuYaiKqDDiFmv4OL62CorlyBw625n2wTFso2AW3s79/RC93gOIudiu9dEBbcOliXk6UQxlkXxHgWAHn8Z/dYTjkrbqZcNproo7k+hx5+EiPPY772xbJsggY3ILmRcIoMc2PA3u387YDPA0Mwa549eYt2cpN+smj8ThGq0/9+i6zpNuzVy+Nydh7SnfO0ydoeduo94kkZP1rN5Toi8pFyt0ny49h2adU/8M2XZ4flDFO93QPV7dEItgOI1DCXfVw6HWxTvEeDa5uEjQ+K/TYEoPhPTVG89/gxa2Hi0Gy3QbjRFu/s6euw+y8notTieZ+PsMJXBuk2D4tEHy3dhW/dVAKP9niwhsoD03GSQ9d9vQTWodnfl1tFZ++0mug3rlOh4t2Ed+f37LcRpepLASDWoFCyWn1a9mzh8bjcPVz77Yzzfj/2Zdd9ttg6JGYwG/MsWoWzNUhQtXZgazatwbMdJ2Tlc5F7/7aRQoHHn+jw7qgv5CvtQvLz91UaKooLnS+DxApgvAxoYSqAoyefRURQXyPc1xO5Gj1oG5iugFkZx7wquLdI0D0WP/h393oiHL+xhT0rMRsswmtcIdC0cSyCVzM+1WyeIXuOggBnF4xnL6zEUg/yz0O/9H+hRPGpUBRQ3lHzfoBiKp/o1CZHepOcmg4ReuOU4aNDh5uXbSQ6XqFiMj9aOxcPHHbAEJAaj5YOwaOnCfLp5XJKhLFs8vN0ZPLUv9YIffvNSFczxZq6cuc6n/abzfNkh+Bb0xuRilInFIldq+2IL3DweDeG6uLvQZUgH3l/6BtWCKjkMbB6nKAYUY6mHk2OdTxCoKAqKaxBqvs9QC/6Mmv9LFLfWaQtszNceBjZmEg8RWf6tP5gGegyWHbkdMYLXKAebWAKeA1GMj1akKa6NUQpvtQx/ubQCl1Yo3qMsx1zTPn9IiPQkPTcZpEDRfA57bgDyFba9I3GtltVYdHk2Wxft4PjuUxhMRuoF16JhpzoYDAa0hzt8q6rjoGTBB7+wc+V+4NFS8oS/716/x18r9loKSrJjkctUql+ejQu2JVp5GB8bx8qv11GsnF+SHtOcQo9cjKVHxt4PrcGy+zZGIM5+GbcOqEZ/9AI/o9//FKJWYM12rPqheL4CHs8luVJR84HnABTPAWl7IUJkMAluMkjbF1qwa9V+u+cVVSG4X2u75908XGnfvzXt+1vK6LrO9qW7WTb1N07sPQ2KQo1mVejxRmfrkvDHxUbHsuKrdZZ8OfZIUCNyoaJlinBq/1nLPo2PbVOS8O9vRsyjalBFKjeokFVVTL3YfTgebjJD3GEU71Ho9z+0cd4AijeK13AAFNUXxXcSuvfbEH8OFFcwVpDl2yLHk/GIDNK4S32qBlW0nWjPqFK4REGeHNzWqXvpus7stxYwqedUTu47g65bemCO/nWC9zp/zMKPfk1yzdm/LxARlvbU9ELkNLcu38ZRvjiDUWXldEfLvCEmKoZfP1/DS5Vep71LT54u+BJfDZ3DtXOh6VzbFHIqEZ5iSZrn+8l/Mhgr4NIEpeAvKMaA/9zWG8WlFoqpsgQ2IleQ4CaDGIwGPlo3lqbdGiRJOV4tqBLT/pyITwFvm9fGRsdyN/QesTGWbuWDm/5h6VRLqvfHc+AkDHl9/+7PnNx/NtE9ZJKwyKvi48wON5Y1x2v8s/Vfu+ejIqJ5s/V4Zr4xnytnrmGO13hwN4LVszfySu03ObnvTAbU2jmKS2Mcf2wbrPlzFPenLdmBC/6Kkv8HlMJbUQvMQTGWypS6CpGVZFgqA3n6ePDe4jcIvXCTw38cxRyvUaVRBcpUL5mo3L+7T/HrF2vYu+YgMVGx1sBEURRKVS2Bh4+7w40yDUaV3775nUrf/Z/1WJkaJXF1d7GulBJCPOJoEv389xdzav+5JEO6WrxGTFQs47t/xo8h0zEYsqCHw70HPPgGiMH2uLKG4tnP+khRVDBVz6zaCZFtSHCTCfxKFSb4pVY2z637bjNTX56JqipJvm3qus75Y5eSvb85XkvybdLD250OA59g1YzfpRdHiMcYjCr129e2eS4mKoa1czbZ/ZnRzBq3Lt9m79pDBD2V+bmiFEMhyD8T/e5gLBOAE+ppWfqt+IxHcQnM9HoJkd1k6bDU9u3beeqppyhWrBiKorBixYpkr9m6dSt16tTB1dWV8uXLM2/evAyvZ0a5fPoa016ZlWTiY2q4uLkkOTZg8nNUDaoI4NR+U0LkFV1e62Dz+NWzoUTdd7RtgmXIOUuHplwboxTeAJ6vWnYvN1YCj14ohdZIIj0hHsrSnpuIiAhq1apF//796datW7LlQ0JC6NSpE4MHD+ann35i8+bNDBw4EH9/f4KDgzOhxulD13VOHzzH/HFL0uV+iqrQuEt9Iu9HsWnBdnau2kdMVCwVAssw9OsBnNhzmsWfrEg+944QuZhqUFEUGPPTcEpVKWGzjNGU/FCTruuYXJzPd5MRFENRFO9h4D0sS+shRHaVpcFNhw4d6NDB9jcoW2bOnEmZMmWYMmUKAFWqVOGvv/5i2rRpOSa4+Xf3KT5/ZRYhRy6my/1UVcXNy5UazSrzUsXXuHsjzJKUVYd/d55k+VdrKV29JNfO3XC427gQuZ1m1qjetDK1W1V7dEzTuHHxFrquU6RkIYpX8KdIqcLcuHDT4X0adJShHyGysxw152bXrl20adMm0bHg4GCGDx9u95qYmBhiYmKsj8PDwwGIi4sjLi5pkquEY7bOpdXZv88zptMkzLHxmNxT981PUbBu76Lr4OXrwZifhvG//tOJjIjC5Jb4vgYMXDlzzfp86TEF0uRuTPS3SErayDmZ3U6nD59j7JMf8vHG99k4bysrvl7Hzct3AMhfNB+dXw3m2VFPMevNBTavV1QoXa0kpaqXyJDPCFsy8jMpt5A2ck5Ob6eU1FvRHWZ5yzyKorB8+XK6du1qt0zFihXp168fY8aMsR5bu3YtnTp1IjIyEnd39yTXjB8/ngkTJiQ5vnDhQjw8PNKl7kIIIYTIWJGRkfTp04ewsDB8fGxn+E+Q679WjhkzhpEjR1ofh4eHExAQQLt27Ww2TlxcHBs3bqRt27aYTOk3rn4n9B79KqVtfPz9X96gbtuaiY49uBfB+O6fcfrAuTTdOyVM7kb6f9eduQOWEReV3B42eZO0kXOyazuNXvAa/mX9mD1qAcd2nExyXlEsc90+WPE2NZpVQdM0oh9E4+LugtGUvh+rGfWZlJtIGzknp7dTwsiLM3JUcFO0aFFCQxNnCA0NDcXHx8dmrw2Aq6srrq6uSY6bTCaH/7nJnU+p+zcfEBeV+q7A3mOeplHHR9ss7Fixl58nL8/SVRtxUfFpek15gbSRc1LSTu5ebkQ9cLyiKS0UVWHRR8vp/U43ju84Zbdeiqowa+QP1G9fmzWzN/HgXgQGo0qzZxrRZ0w3ytRI32R56f2ZlBtJGzknp7ZTSuqco4KboKAg1q5dm+jYxo0bCQoKyqIaOS+fn69T5Qr450Mz60SERaKoClWCKtL77a7UbVvLWmbp1N+Y9eYP1rk3QuQVBYvlp36HQDbO32o3qWVa6ZrO6YMhfPDMlGTLnfvnAuf+uWA9Zo7X2P7LLnas2MfH69+lZvOqGVJHIYRjWRrcPHjwgDNnHvU8hISEcPjwYQoUKEDJkiUZM2YMV65c4YcffgBg8ODBfP3114waNYr+/fuzZcsWlixZwpo1a7LqJTitULEC1G5dnX+2/Wt3ObbRxci3R6ba3ZYB4OrZ68x6y9IesvGlyEsUVeGdhcPx8HZn/Xdbsro6dmlmHV2L48Pen7PwwjcYjLJXkxCZLUuT+O3fv5/AwEACAy3LKkeOHElgYCDvv/8+ANeuXePixUdLpsuUKcOaNWvYuHEjtWrVYsqUKcyZMyfHLAMf+PHzGIyq3SXZL4571mFgA7Bm9qaMqFpi0iMksiFd05nUcyrbl+6iz9juWV0dh3Qd7ly7y561B7O6KkLkSVnac9OyZcsk+7c8zlb24ZYtW3Lo0KEMrFXGqVSvHP/bNI6pg2Zy6cQV63FPXw9eHPcsTw/r6PD6iyeuWHYzzoAeG0VVUFUFc7yGdz5P7t+NSP8nESKN7oaGsfh/K/Et5PhLQHagGlRCjlykcef6WV0VIfKcHDXnJjeo3qQy3x2bxom9Z7h29jqe+TwJbF3d5vYJjwu7Fc4bLccRExXjsFxqKKpCkZKFaNWzCb6FfSzzeYTIpjSzRtgt51dNZBVN03B1d/xzLYTIGBLcZAFFUajSsAJVGlZw+pq13262fKBnQK+NrumEXrhJ73e68WarcSiqgq7JhB6RfaV1L7ZMoUPDTnWyuhZC5ElZOudGOG/Lwj8zNuDQIeTIRU4fDJHARoh08nrjsVw9ez2rqyFEniPBTQ7x4F7Gz4FZNu23DH8OIfKSB3cjGNJgNJH3o7K6KkLkKRLc5BAlqxRHNWTsf9dfy/dm6P2FyIse3I1g04JtWV0NIfIUCW5yiCdfaWc3P056keEokRcpiu3cB4qiYHRNn2mJm37cni73EUI4R4KbHKLJ0w1o2q2h3Q9iIUTKmdxM1GxhySKc0DOa8Hf1ppXxK1k4XZ4nIlyGpYTITLJaKodQVZV3F41g8f9WsvzLtdy7EQaAu7c7MZEx6JruMGeQECKpt+e/RtNuDdiz+iDrv9/CzUu3KVyiIG37tqRx53pM7DmVK6evpfl5ytcunfbKCiGcJsFNDmIwGujzTjeefasz186FoigK/mX9iAiPZOuinexatY/9G/7O6moKke0VKl6A174eSFDnehzffYrbV+/QuHN96rWvTaFiBazl2r7Qgh0O5qIpqoLRZCQuxvGmn0+9mjOyqAuRW0hwkwMZTUYCKhW3PvYp4E3bvi2Ijozm6M6TRGfgjskOKeCVz5MHkt1YZDKD0YA53uywTNEyRWjZswn+ZYsQ3K8VF/+9zKCab3Dh2CUUxbJlgmpQaftiC16fPhAXNxcaPVmXSvXLc/rguSRz3lSDilc+T96a93+Mf/ozu8/feUgw1ZtUTrfXKoRIngQ3OVh0ZAyaWcMcb+bNVuMJOXoxaycF6/BjyAwiwiJ5Pegdbl+9m3V1EXmKm6crEWGRDstcD7nBoo+XA7Dwo18JuxFO7MMel4QRXc2ssXH+VsJv32fC8lEYjAYmrx/Lxy98yd61h1BUBUVR0MwaAZWK8d6SkZSqGsC8k1/waf9vOPrnv2gPfwbzFfHhhXHP8tTgdhn3woUQNklwkwPtXLWPxf9byb87TwLg7u1GdERMlq92MpoMuHm64unjQYGi+SW4EZmmUPECRD2IdnpFYej5m3bPaZrOrlX7Ob7nNFUbVcQ7vxcfrn6HiyeucGDD38THmancoDzVm1a2TvAvWsaPKX+Mx2w2c+vyHVSDSqHiBWQBgBBZRIKbbMgcb2b70t2snrWBK6ev4ZXPkzbPN6fjoDasn7uFb9/+MdHO4lH3Uz8MZTQZiI9z3J3vNEVh66IdrPl2E6cPnkufewqRHAWefr0jnw+enW63NBgNbFqwnaqNKlqPlaxcnJKVizu4CgwGA36l0meFlRAi9SS4yWbiYuMY//Sn7F13CNWgopk1bl+9y9x3f2bptNWE3bRsGKilUy+NOR1z58THxvPxC1+l2/2EcIZvIR8unrhC7dbV+fuPY+myalDTcsbmnEII2yS4yWZ+mriMfb8fBkjUxa5rOuG37qfrcymKJO4TOV/YzXBWfLUOXdOp3742x/ec5v6dB2m6p6oqFAkolE41FEJkNgluspHYmDhWTl9vN+BI7zw2khZH5ESqQUmyK3jCF4G96w7x0bqxFCiaj50r9/LD+F9S9RzmeI0nnm+W5roKIbKGBDfpyBxv5uiOEzy4G0Gxcn6UqVEqRddfPnk1UzbIFCIn+29g8ziDUWXxJyt4cC+Cs4fPp+l5Zr+1gEmrx+DiakrTfYQQmU+Cm3Sy7rvNfP/uz9wNDbMeq1C3LMO+eZlK9co5dQ9ZWCFE2pjjNf7eegzV4NwPk6IqdntKD/9xlF8+W8VzY7unZxWFEJlA9pZKB8u/XMvUQTMTBTYAZw+F8EaL9zlzOMSp+wRULo5vIe9kyymqREFCOOKodwcseXGa9whyOOdM13RWTl+P2ZxOqwmFEJlGgps0igiLYM7oH22e0zSduNh4vhv9k1P3MpqMPD2sk90eHNWoUrpaAIUDCloeG1TJoyFEChUsXoAl177Ft6A3BpPBYdm71+9ZVygKIXIOCW7SaNsvu61ZTm3RzBr7N/7N7WvOJbTr9XZXWjzbGLDMH4BHw1Vevp406BjIgI/60O/D3hiMqmyWKURKaTruXu4YXZwblTfJnBshchyZc5NGNy7eRFEUx0GGDrev3qGgf/5k72cwGnhn4XDavtiSNbM3cunEFSLvR3Hn+j3u37nPsmmrMcdroCC9NkKkkGpQKVHJH4CGneqw/Mu19suqChXqlsM7v1dmVU8IkU6k5yYN4uPi+XPZbqdyxeQr4uv0fRVFoUGHQCYsH0XDTnW4fe0uuqaj65YJkwDokqNGiJTSzBqdXrbs9RT4RA3K1ixl7SFNUlbT6TW6aybWTgiRXiS4SYPfvtnApRNXHZZRVIUazaukOCFYbEwcK2esZ+m01SAxjBBppigKDZ+sS/MejQBQVZUP14yhWHlLT45qUB/9rcDLn75I06cbZll9hRCpJ8NSabDi63XoyUQeCjBw8nMpuu/18zcY1eYDrp0LTUPthMjbvAt4WTMVexfwouvQDvQZ2w2D4dEk4kLFCzL778/YuXIff/66h+iIaEpVKUGnl9viX9Yvq6ouhEgjCW5SKT4unqtnridbrnqzKlQNquT0fc1mM2M6fEjoRfu7FgshHDMYVRp3qUePNzqj61C8QlFMLrYnBhtNRpo/E0TzZ4IyuZZCiIwiw1KppBpUu2P11jJGNcU7BO9bd5jLJ6+ixaffhpZC5FT12te2DhelhDle4/SBEEpVDaB0tQC7gY0QIneS4CaVVFWl0ZP1HAY4WrxGUOf6Kbrv3nWHMBgd597IdAq4e7lRtlYpgl9qSdHSsqGgyHjFyhdl9A+vUcA/X6qud3F3Sd8KCSFyDAlu0uDZUV3QNN0yseY/VKNKiUrFaNy5XoruGR8b71Q5RVVw93anZa/G5PfzzdisxTpEPYgm/NZ9ipX35/r5Wxn3XEI81GVIe3wL+VC6WkDK0x4ocD3kBgOrj+CroXO4cPxyxlRSCJEtSXCTBlUbVWTszyMwuZhQVOXhUJWl16V4eX8+2fBeinthKtYr51S69wYdApmx72PGLhzBkmtzGPvziFS9hv9y9bD/bffWlTt8/97PsgeWyBTu3m4A3L/zIOXJKnW4dyOMC/9e5rdvNjCo+kh+//6PDKilECI7kgnFadSiRxCBT1Rn4/xtnDkcgouriaDO9anfoXaiVRnOat2nKbPf+oHoiBibH+iKAs+9+wx9J/RMUo/YqKFMHzaXiLBIVIOKZnZ+3o6iKhSv4M/lk46XtqODJEUWGc1oMnDu7wsAFC3rx5lDIY9yPNlhbxPMhJ+jzwbMwMXdRKteTZ2qw41Lt/h76zE0s0bVoIoEVCqewlchhMgqEtykA58C3nQf8WS63MvD2533lozk/a7/Q9c06wd6Qhbk+h3r8Ny7tncpbvtiC1o8G8SuVfu5cek2Lq5G1szeSMjRSxiMqmUIDcuHvYuridhoy7YRnr4edP6/YLb9sitdXoMQaaXr4OJm6UXs0L812xbvdFi+fGBpLp+6RnREjMNyn/T9mmqNK1GkpP2J/hHhkUx7eSbbf9md6AtG4BM1GDV/KIWKFUjBKxFCZAUJbrKh+u0tQ07Lpq1m+7LdxEbFUbJKcboMaU/7/q0dDnW5uLlY96YCePLVduxff5g/l+0hKiIanwJe1GlTk/KBZQh/mAOkdLUSuLq7snrWxgx/bUI4wxxvJujhfLU6bWrSrHtD/vp1b5LeTNWgUr52aYK61Gf++4uTv2+cmRVfrePlT1+0eT4+Lp4x7Sdxct/ZJM/197ZjvNHifWbs/wRPX89UvjIhRGaQOTfZVJkapXhz7hBWhS1gfewiZv89hU4vt03xHB6DwUDDTnWp3qwKx3efYvWsjXzQYwp9K7zGT5OWkq+wD67urgCWpGXpMJ9GURV8C/uk/UYiT1KNKlUaVaRaY0t+KEVReGfhcHqN7mqdhwNgdDES3K8Vkze8y+qZG5y+/+af/rR7bseKfRzffdrmkK4Wr3Et5AZr52xJwasRQmQFCW7ygCWfrmTKgBncvHTbekzXdfasOchrjcZw87LleKeX26Z5qwc3T1de+qAnYTfD03YjkeckrPgrV6s0H6wclWiFlNFkpP+HfVhybQ7Ttn/AZ1vGs+Tat4ycPZjoBzHcvnrX6eeJfBBt99yG+X84zKujazrr50pwI0R2J8NSudzd0HvMHbvQ5jnNrBF++z4LJixh5Lev0uaF5myY/wf/7jyV8tUpAAqUrlaSk/vOohpVSUQonObl60694EBaPtuEfH4+nD96iaJlYihauggn9p5m2eer2bv2EJpZo1KD8nR7vRNe+SxDQylK8qdAiQr+dk/fvno32Yn4d0PvOf98QogsIcFNLhV2K5wdy/eyY8Vehx/W5niNTT/9yZAv++Pq7srk9e8yd8xCVs/aQHxc4iXpJhcjcY7y8Ohw49JNrp+/IYGNSJG5J77k0KajzBj+PVdOX7MeL1mlOJdOXEU1KNbJ9Ue2H+fvP47RbXgnBk/pS0H//JSoVIwrp64mv5JPh6deDbZ72q9UYUKOXLT/M6NA4RIFU/ryhBCZTIKbXEbTNOa/v5gln64kPt6MgpLsB35cdBxhN8MpUrIw7p5uDPmyP/0+7M3Zw+c5f+wS3vk9KV7Bn5lvzuefbf86vNe9G+FomgQ2wjnKw06XnSv28elL05PM+bp4/AoA5vhHb+KEwOPXz9dQq2U1GneuT89RXZkyYEYyz6VQu1V12vVtYbdM+/6t2blyn8P7dBzUxuF5IUTWkzk3ucwP45aw8KNfLb0uOk4NLymqgme+xKs/PLzdqdGsCk8NbkfLnk2oUKcsLZ9tnOycHM2spXnejsgbDEaVoKcsK6JmvTXfcjAF7x3VoLL8i7UABL/Ukmff7PzweNJZ8Z75POjzTjcmrR6D0WT/O12DjoHUa1fLZsZv1aBStkYpgvu1cr6SQogsIT03uUj47fss/nRliq5RDSoNOgbi6eOR6HhcbBxbF+1k7ZxNhJ6/ST4/X8rVKpWe1RV5nkL3EU9y6upxoh44zk9ji2bWOLH3tOVOisKg/71A8x5B1txO7t5u1G5VgwYdalOqagmnNs80GAxMWDGK2W8tYO2czcTFWHJBqUaVFj0a89rXA3DzcE1xXYUQmUuCm1xk58p9xMc5tzcVgPpwy4gX3u+R6HhURDTvdPiQo3+dQFUVNE3n5pXbnD5wLr2rLPIoF3cXxi97k/K1y3Dq6nEMRpW4VNznv5OJK9UvT6X65dNWNzcXhn41gJcm9uLfXacsk5jrlyO/X7403VcIkXkkuMlFwm/fR1WT33YhIU19Af/8jF7wOhXrlkt0fvZbC/h35ykAa1ZjGWoS6alUleLUbx9IXJwlpEnJViEJDEYDDTvVSe+qWXnl86RBh8AMu78QIuNIcJOL+Jf1c+qXRO8xT1OtcWXqtquZZP+rB/ci+P37LTIpWGSoc0cuJnpsMKZ8+p+maXQfnj7bngghcheZUJyLNHyyLt4FvOyeVw0qddrUoN/E3jToEGhzY89TB84RF+P80JYQqWGON/Nhn2kc323pIXz69U6OL3hsfq9qUDEYVUbNG5rmISghRO4kPTe5iIuriWHfvMykXlMfLgF/NJakGlRc3V0YPPUlh/dQUrD9goe3G2FRcdZ5OUI4TYc/l+5mx8p9vLKwJ33GdkNVVBb/bwVxMfHW95RvYR8GT+1L+K377Ft3iPh4M1UbVaTTy20cbn4phMjbskVwM336dD799FOuX79OrVq1+Oqrr2jQoIHNsvPmzaNfv36Jjrm6uhIdbT+lel7SokcQ7l7vMGf0j4QkdP0rUOeJGrwypS+lqwU4vL5ivXK4uD3aMdyRyAfRKIoENiJ1zPEaqsnSe3hw0xH6TuhJt+Gd2LVqP/fvPMC/rB8NOgZal253G5ZM744QQjyU5cHN4sWLGTlyJDNnzqRhw4Z8/vnnBAcHc/LkSYoUKWLzGh8fH06ePGl9rKSkuyEPaNAhkPrta3P51FXCbz+gSMlCTmdV9fTxoOOgNqycvh7dRtCiGBSMpoejmU7m0bGn85BgGnWqy6KPV/DPdsfJAUXutmr6eoI61cM7vxft+rbM6uoIIXK4LJ9zM3XqVAYNGkS/fv2oWrUqM2fOxMPDg7lz59q9RlEUihYtav3j5+eXiTVOmYsnrjD15Zl0yfciwaae9K86jBVfryM2JjULX52nKAoBlYpTrXGlFKeLH/jxc9RuVR14tNQ2IYDMX9iX+HTaWmHLwr+IjY7jg1VvE1C5uM3EaSJncvN0pX77QJp0rY+Hj3uy5Y/tOplsmawQcvQi01+fy5utx/Nel4/ZMH8rMVEpz8kjhMhcWdpzExsby4EDBxgzZoz1mKqqtGnThl27dtm97sGDB5QqVQpN06hTpw4fffQR1apVs1k2JiaGmJhHH0bh4ZbdquPi4qzLUB+XcMzWuZQ6uuMEE7p/ijnejDlex+BiIPTiTb4dvYCdv+1l3LI3cXF1SfPzpDfVqPLBqlHsWXOADfO2EnrxJvmK+NK6TzN2rdrPkR2WXhaTe9rePjExsXz0wue8t+RN+oztxqJPlnP1bGh6vIQsl9A2aW2jnEI1KhgMKiNnD6ZMjVIULJYfFzfLe3tSr2nsW3/Y5nUJ7ePibkz0Mxdy9CLH/joBQLWmlSlTvWTGvgAbFv9vJQs/+hWDUcEcr6OocGDTP/z8ya9MWj2GIgGFMqUe6fmZlFtJGzknp7dTSuqt6GkZV0ijq1evUrx4cXbu3ElQUJD1+KhRo9i2bRt79uxJcs2uXbs4ffo0NWvWJCwsjM8++4zt27dz7NgxSpQokaT8+PHjmTBhQpLjCxcuxMPDI8lxIYQQQmQ/kZGR9OnTh7CwMHx8fByWzXFfK4OCghIFQo0bN6ZKlSrMmjWLiRMnJik/ZswYRo4caX0cHh5OQEAA7dq1s9k4cXFxbNy4kbZt22IyJZ+u3Z7tv+xiyqCZDsv4FPDi+5NfONzrJrv5adIyVn6zjpe+7cbcAcuIi8p+y8Zf+qAnLq4mZo/+MX2SDyow8KPe7Fp9gFP7nVsqb3I30v+77tm2jZKTohVwCuQr7MOUrRMoVKxAktP37z5gYPURxETFov9nRDOhnQh15edJvxJ++4HNpzAYFYoEFOLzvybh5umW0peTIrquM6LZe5z/91KS+j5u3NI3qNOmZobWBdLvMyk3kzZyTk5vp4SRF2dk6W/VQoUKYTAYCA1NPBQRGhpK0aJFnbqHyWQiMDCQM2fO2Dzv6uqKq2vSvWBMJpPD/9zkzifn9P5zaPEa5jiz3TK3r9wl7MZ9ipa2PXE6O+o44AmWTvsNgLioeOKiMrF7UwE3D1eiI+zMeVAsy+GDX2qFoijMfOMHh+2fEt8M/yFV12V6G6WD1s81o0rDCkx/3f68t/+6feUuiz9awfBZryQ5V6BIfsYteYuxT04mPjbOmmjy8S0XFk1azp0r9+xOUI8DLh6/ypafdtBlSPuUvqQUCbsVzql9jrcaMZgMHNxwhIYd6mZoXR6X1s+kvEDayDk5tZ1SUucsnVDs4uJC3bp12bx5s/WYpmls3rw5Ue+MI2azmSNHjuDv759R1UwVo4vRqV4Do0vO6bUBKFKyMK9/PQiwfJvOVDr2A5uH52Oj4+hRZADjuv6P4Jdk9+aUcnEz8fr0gfiXSVnArcVrbFiwjdjoWJvna7WsxvcnvqD36KcpU6MkJSoW44nnmvPZlnEAhN25n+zKOwXYuGAbANfP32DG8O95xm8AHT36MLDGCFbN+D1dJuqb450LiFOyj5sQInNl+WqpkSNH8u233zJ//nyOHz/Oq6++SkREhDWXzYsvvphowvEHH3zAhg0bOHfuHAcPHuT555/nwoULDBw4MKtegk31OwQ6/JBUFIVS1QIo6J8/E2uVPlr1bgJA0JP1cHV3SZQ9NjvQdfh31ynWfrsJgylpFmZh33PvPoOnjweBbWo6zHZtS1x0HOG379s9X7hEQV6a2IvZf0/h+xNf8Nb3Q6hQpyzg3FtI1yHsZjinDpzl5VpvsHLGesJuhhMXHcfFfy/z9WtzGN1uYppXM+Ur4kvBYo5/Ls1xZsmOLEQ2luXBTc+ePfnss894//33qV27NocPH2b9+vXW5d0XL17k2rVr1vJ3795l0KBBVKlShY4dOxIeHs7OnTupWrVqVr0Em2o2r0qFumXt7pmj6zq9Rz+do3P0vDVvKKsjfuL3uMV8suE9XD2SDv9llYShD3OcOdsFX9lVp5fb0nvM04BleG/g5OdSdL2qKnj6pm6SvjPLGlSDStHSRRj39KfERMaiPZaSQNctf47tOMGPHyxNVR2sz6OqPP16J7s/m6qq4F3AixbPOte7LITIfFke3AAMHTqUCxcuEBMTw549e2jYsKH13NatW5k3b5718bRp06xlr1+/zpo1awgMzH479yqKwsRVoylRsRjwKF+M+jDYeXH8szzxXLMsq196UlWVOm1q0u7FFqnaADEjKYoiO5onR4H8fr407lKP6a/PpX/VYfSrMowzh88T+EQNp26hGlQad22Au1fyOW1sX598BKqZNSrWLcuty7ftbhCraTq/zdyQ5uGp7iM6Ub+j5XPl8fxLBqOK0cXEuGVv4uqefYJ5IURiOWvCRw5T0D8/Mw99ys6V+9i+dBeR4VGUrFKCjoPaULJy8ayuXrrr+npH1n23OfmCmUjXdQwmg2WIMBcHOapBdWpHeJt0uBsaxthOky29XA/b6drZ62iajld+TyLCIm1mrAbLfmQGk4Hn33vG5vnI+1FsmLeVTT9uI+zWfYqXL0qnl9vSuGt9p6uoKAp12tTAYDJY/j8dTBSPCIvk2rlQSlVJmhrCWUaTkQ+Wj2LjD9tYOX09F49fxs3TlRY9GtNteCfrlxYhRPYkwU0GM5qMNH8miObP5P4u7JKVizN++SjGd/uU+NjsM9nSHGemSMlC3Lh4K6urkiGC+7Xi9tW77P/9cNpv9lj8Yn447BMRFknJKsW5cOxyouAnQZFShRm94HXK1Sqd5HY3Lt1iZIv3uXHhFjo66HDj4i0ObPyHBp3qMHbRMABe/3oQn/WbgaKCZk78BAajgadf70C/Sb1Z/MlKp8awjOkw18pgNNC+f2va92+d5nsJITKXBDciXTXsWIeJq95mTPsPs7oqidy4eIuSVUtw+eTV1PdwZEOqqtDr7a545fekV/FXnF7pk9LnqNG0Cm/NHcKRP48T9SAaXdfxzu9FqaolqN26OqpqezhyYo8p3Lx8O9FKqIT237fuEIs/XkGBep606t2EEhX8WTp1NXvXHiQuLp6AysVp2SOIbiOexOPhcFe99rX5YcIS+5VVwK9UYfzLZt8tWYQQGU+CG5HuAp+oQaHiBbh15U6qrlcNKj6FvLkXGpZudVINKr6FvLlz1Z0H9yLS7b62KKqCl2/q5p4oqmJ3+McmVWHVjN/5v8/70fq5pmz+8c90D97M8RoHNv3DsG9eTtEKoZP7znBir+38UwC6prPm2828UK8zAFWDKvH+L5Uc3rNyg/JUaVSRk/vPJJpQ/Oim0HNUV7vBlhAib5BPAJHuDAYDfSf0tF8gmbmjmllj7MLh9Hmnm3UidlppZo17oWFM3/dxhm7QqRoUGneuz4OwqFRdr2t6inIfafEau1fvB2DIF/0fLa1O79eYil1a/tn2b7L/f5H3U9ZOiqIw/tc3CahkmbOmPnydCRPZu494kidfaZviugohchfpuRF2xUbHsunHP1k/dwu3Lt+mQLH8tO/Xmpa9Gyd7bfv+rbl/N4K57/yE2axhMKhomo6u6XT+v2BKVSvBl0PmYDCo1rkdCZNi67SpybRXZnHr8m0UxfILLa1boCmKQj4/X4qVK0rzHkH8uXRXkrkdafawrsf3nE7TbVI6Xyku1jIUZTAa6Ppae3avPsiZg+eIjowhv18+4uPiOX/0EqpBRVGVFGdtNhhV6rSplaJrMlKBovn55sAn7Fi+l62Ld/DgXiQBlYrRcVAba3AnhMjbJLgRNj24F8FbT0zgzKEQ61DJrSt3OLnvDGu/20jw2CbJ3qPHG0/Rrm8Ltiz8ixsXb+Fb2IdWvZrgV6owAGVrlubXz1dzYOM/6JpOpQbluXzqKoe2HHE4NFO0TBGeG9sdRVWYMuAbVINiDZDs0XWdti+0AODZNzvz51L7u86nlslkJD7ezJ1rdzG5Z15qc7+ShVj33WZmvjGfyPAoa5Do6uHKs292odvwToQcvcjOlfuIjYrlypnrbFuy0+n7a2adLkOCU1yvmi2qJjtE5uGdun2iTC4mWvZsQsueyb8PhRB5jwQ3wqYvh8zh3D8XAKyBRkLvyYXjlwGYMWIevvm9af1cM7tL230L+fD06x1tnqvWuBLVGj+aY/FRn8/5e+sxm4GNalAoWTWAd38eTkDl4tY5FSUqFmPZNMsk1Jgo26n/DUaV4hX8ad2nKQAV65ajauPKHP3zeLLt4CzVoGIwGYhLQa9L4YCCuLiauHLmepqe+97NMKY+tklrQkARExnDNyPnYTAZ6DKkPWWqlwTg6I4TKQpu3vjuVcrUKJXielWqX55K9ctx5lCIzeBTURU6DmqT4vsKIURyZM6NSOL2tbtsW7LT7rfuhJ2SN/7wBz9/vJwBVYczZeCMNO21czf0HtuW7rKfnM2sc/7IReLjzIkmi1ZrXIn3f3mD1RE/sfDiTKoGWYIlRVFISDBbs0U1Ptsy3pp0LSI8kmM7TqS6rrbrpzne98qGm5dupzmwAbgectPh+XnvLUq059P6uVusySST88yIJ+3u0XX/7gOWTVvNG63G8XrjscwY/j0XT1xJVOb9X96gUImCibL9JszDqd++Nr1Gd3X4/NGRMSybtpp+lYfR0b03z/oP4tu3f+TWldtO1V8IkTdJz41I4vjuU06tuNHMj3oJfv9+K+7e7vzftH6pes4zh8/bXv3yHyf3nkmSTyU2OpaVX69n5Yz1hJ6/icFooEzNktRtU5O2L7agVNWAROVDL9xM2Yqk7ExJfqPHB/ciOLDxH4KeqgfAoU1HnGrrfEV8eX5cD5vnTh88x9ttJ/LgXoS1R+/k/jMs/2otQ77oT9ehHQDLRquzDn/Ghnlb2bhgG+G37lO8QlE6DmpL024N0DT79YgIj+TNVuM5e/i8NUfO3dB7LJ36G+u+28y07R8k+b8VQgiQ4EbYkJr9rnRd57cZv/Pc2O74FvJJ8fUGo3NJ19T/lIuJimF08CSO7TxpDVjM8WZC/rnA+SMXqdWyWpJfgGtmb0xx/bItJ2O0sFuPNrTUnbzo3o0wtvz0J0+9mni+TdSDKEYHTyIiPDJx/pqHAdP01+dSskoJ6jzcusHTx4OnX+9oc3jSUXDz7agFnPvnQpLJ5JpZIyIskg96TGHO0Wk5en82IUTGkGEpkUTVoIpOD1s8Lj7OzN61h1L1nFUaVcDN0/FePQkp+B+3+JOViQKbBOZ4DXO8xqRe04iKiLYeP3XgLKum/56qOuZkRUsXtv67dqvqTu8BNn/8kiTDjZt/+ovwO/ft9u6pBpWlU39LfWWBiLAINvywzcEwpcbF41c4ko7zpoQQuYcENyKJ/H75aN27aapyzEQ/FkikhLunG12HdrC/E7NBpcWzQRQJKGQ9Zo43s2rGertDTLquExkexbbFjybPrvhqXaoCt5xKURSKlCxEzRZVrce6vtYBs5OJ/sJuhnP0r8Tzkw5u+hvFQbIizaxxcNM/aVq+f+Hfy8RFO978UjWonNx3NtXPIYTIvfLOp7xIkde+Hkil+uUASEmvf6lqqZ8D0feDnjTrbtkRPqFnISHAqta4EiNmD05U/m7ovUTDLbYYTQbOHAqxPj78x1Gn5pv8V1qHPgoWK5Cm61NDURUUVWH4zJcTTcKuWLccw2a87PR9IsIiEz3WzFqyQ1t6GrMkOzNMqet6uuwhJYTIfSS4ETZ5eLszZesExvz4OmVtbIhoS/6i+ajRrEqqn9NoMvLu4pF89sd4WvVuSo1mVWjWrSETV43m0y3j8PBOvKWByTX5XDK6Di5uj8o56nF4nKIqluXdD3/JVmtSCdWQ+gDH3cuNKg0rZGh25P8qW7MUk9e/S/32gUnOPflKW9787lWn7lO8gn+ix5UbVnQY7KmqQsV65VIdEJ7cf5a/lu9J9P9mi67p1AvOPskFhRDZh0woFnaZXEy07tOMpt0b0dN/ULJ7Mo2aNzTNPRyKolCrRTVqtaiWbFnfQj5UrFuWM4dC0OwMTZnjzTR8sq71cd12Ndkwf6vdpH+KotD6uWYUL1eUK2ev4enjQateTajWpDIrvlrHjOHfoygp343g6tnrTF7/LqPbTbS5s3Z6Uw0KX++ZjNFk/0e83Uut+PnjFVw9e91ObiGVinXLUvo/vXHt+7diwYQlxMbE2XwdmqbTbfiTKa7z/bsP+OCZKRz+4ygGo2pNOWCLalCpF1zLug2DEEI8TnpuRLJcXE30fLurwzJPPNeMeu0y/1t0n7Hd7QY2BqNKxXrlqNn88fkmHe2WR7H80uw2vCOdhwTz9vzXeO3rgVRvWgVFUXj69Y6MfZhEMDXqPFGD9355A698ng/rZ7D05ChQsV76bhugmXW7SQ0TKIrCm9+9itFkSDK/SjWouLiZGPZN0uGrfIV9GbtoBAaDIdHE5IR7dBnSnpY9k9+i43G6rvPeUx/zz/Z/AcuEcFsrqRKeo0KdMoxe8HqKnkMIkXdIz41wSs9RXQi7Gc7Sqb9Zh2cS/m7zQnPemOPcEEd6a9K1Aa9OfYmZb8637EGl6dbtGEpVDWDSb6MT9SaVrVmK/h/25rsxCxPdJ2EPq4LF8jOk3mgA/Mv60W14Jzr/X7B1zkrLnk1o8Wxjrp69TuT9KOa9t8ipFWL+5fwAaNatIQ07BrJjxT6unrmOp68HTbs14N7NcF6tMyr5F+xkr49vIW/cvZLf2qB60ypM+3MS349dyIGN/1ieQlFo0DGQAR89l6TXJkHjzvWZeehTVny5lh0r9hIXF0/FuuXo+loHgp6ql+IevKN/neDYzpN2zyuKgk9BL2q1rMYTzzWnYac6TqcPEELkPRLcCKcoisIrn73Ik4PbsnHBNgC6Du3AE32aW9P6Z5VuwzvR5OkGrJuzmYsnLuPm5Uazbo1o0DEQgyHxL8BTB87y06RlqAYl0caZum7pPbh56VHm22shoUwfNpfju0/x9g+vWQMcRVEoXt4yD2Xcsrd4td4oLh677LCO/Sb2sv7bxc2FVr0S74nkU9AbT1+PJJN3/6tKgwpomuZwlZBqUHnylXaJJhE7UqleOT7+/T3uht7j3s1wChTN51SuotLVAhg+6xWGz3rFqedxZMfyvRiMBrsJCXVd5/7dCMb8NMzhUJsQQoAENyKFipf357l3u7N27Vr6TuiJyZR5G0Q64leqMC89FkDYous6k5//ktjoOLs7gidavvzwn1sW/kXTbo1o1q1hkvIuribm/DOV/lWGc/nUVZv3bP5MI1r0cDxM4+LmQuf/C2bRJyvszn8pVbUEX+z8EEVR+OWzVcwetSDJjumqQSWgcnF6vPmUw+ezJb9fPvL75UvxdekhKiIq2aXjmlkjNjpOghshRLJkzo3IM47tOMHlk1ed2lricapBZdWM9XbPK4rC3OOf89LEXnj4JF7R9cpnL/Dekjecep4XxvWwzlt6fA6Moirk9/Nl/K9vWYd7erzZmXcWDiegcjFrOVcPV54a3I7P/5yIp6+n068vOyhWzj/ZMvmK+Do11CaEEPIVSOQZIUcvpeo6zawRcuSiwzKKovDc2O48N7Y7mqYRHx/PunXr6DjQ+V2vTS4mJq4azfalu1kzewOXT13Hp4AXbV5oTvsBrfEp4J2ofKteTWjZszGhF24SExWLX6nCuHk4zvKcXT3xfDMWjFti97xqUOn8arBstSCEcIoENyJXCTl6kcNbjqJrOtWaVKJS/fLWc2n5xZ/c1hCPU1U11b+EDUYDrXo1STInxx5FUShaukiqnis7KVSsAK9M6cs3I+ahqEqioTnVoFKmegDdR6Z8ebkQIm+S4EbkCndD7/FRny84/MdRa6I8XdOpWK8c7y0ZSdHSRajfobbDSav2qAaVls+mbGmzSLluwzpRuERBfpq0lLN/XwDAw8edDgOe4MXxzyZJ4iiEEPZIcCMcigiPZNOC7exdd5C4mHgq1S9P8ICWWV2tRGKjY3nriQnWCb2Pf+s/cziEEc3fZ9bhT8lX2JcnB7dl1fTfnd73SFUVXN0tk31FxmvWvRHNujfi1tU7xEbFUqh4AVzcXLK6WkKIHEaCG2HXmcMhvN12IuF3Hu7fpMPfW4+x/Os1DFrwbNZW7jF/LNrBhX9tL8XW4jVuX73D2m830+vtrgye0peIe5Fs+nH7wwR0ltVGmlnDw8edyPAoS/4UBcxxZrwLePPBqrcpUrKwzfuLjFEoC/biEkLkHhLcCJuiHkQxut0ky5YLj3VyaGbNuoz6xJ7T1Gha1c4dMs+mH7cnmafxOF3T2TB/K73e7orRZOTtH17j2VFd2PzjdsJuhlOkZGHavNicIgGF2PXbfg5tPoKu6VRtXInmPYJwcWIPKyGEENmHBDfCpk0//knY7XCH2XBXTF+fLYKbsJvhdgObBOG3E+8eXqZ6SQZ+/HySck2fbkjTp5PmsxFCCJFzSJ4bYdO+9YeS3UH74Ma/M6k2jhUrVzTJ3kiPU1QF/zI5f0WREEII50hwI2wyx5uTnXSb0lVHGaXDwCccJubTNZ1Or7TLxBoJIYTIShLcCJsq16+Q7N5E5QLLZFJtHKvfvjZNujawmVtGNahUb1qZJ55rmgU1yx5uXb3DloV/snHBNi6fvpbV1RFCiAwnc26ETR0GPcFPHy0DBzsVdB6cPXpDVFXl3cUj+GH8ElZOX09keBQAru4udBj4BAMmP4fJJe9NCo68H8WX//ctW37+K9GcpLrtavHW90Mo6J8/C2snhBAZR4IbYVOhYgV4e/5rTH7+C1RVwRxviXIen9vSJBtNvDWajPT/sA/Pvduds39fQNd0ytQomWcTv5njzYzt9BH/7jqVZLL14S1HGNHsPb458EmO24NKCCGcIcGNsKtVryYUK1+UXz9fze7fDhAfF0/FeuXo+np77nErW+7z4+ruStVGFVN0zZnDISz/Yi171hzAbNao0qgiT7/ekfrBtTOmkplg56r9HP3rhM1z5niN6+dvsGb2Jp59q0sm10wIITKeBDfCoUr1yjHmx2GJjsXFxbF27dosqlH6+mPRjiS9Uwc2/M2+dYfoPeZp+n/YJ4trmDob529FNah2J1rrms76uVskuBFC5EoyoVjkWTcu3uSTF79E13RrYANYA4KfJy9n77pDWVW9NLl19Y7DFWQAd0LvZU5lhBAik0lwI/Ks1bM24mi1u2pQWf7FmsyrUDryK1nIYe4fFNniQAiRe0lwI/KsYztPOuzd0Mwax3aezMQapZ/gfq0dvjYFhY6D2mRijYQQIvNIcCPyLIPRkGwZ1Zgzf0QadAykXrtaKKrt3D8lqxSnw4DWWVAzIYTIeDnzk1uIdGDvl38Cg1GlXg5dMaWqKhNWjOKpwe0wujxaN6CoCs26NWTqtg9w98qby+SFELmfrJYSeVb7/q35cdIyoiOibW68qZl1ug9/Mgtqlj5c3Fx47euB9P2gJ//uPIVm1qhYv5zMtRFC5HrScyPyLJ+C3ny09h3cPF0T9eCoBhVVVXjju1ep0rBCFtYwffgU8KbRk3Vp3KW+BDZCiDxBem5Enla9SWV+OPM16+f+wd51BzHHmakaVIknB7eleHn/rK6eEEKIVJDgRuR5+Qr70uvtrvR6u2tWV0UIIUQ6yBbDUtOnT6d06dK4ubnRsGFD9u7d67D8L7/8QuXKlXFzc6NGjRq5JluuEEIIIdIuy4ObxYsXM3LkSMaNG8fBgwepVasWwcHB3Lhxw2b5nTt30rt3bwYMGMChQ4fo2rUrXbt25ejRo5lccyGEEEJkR1ke3EydOpVBgwbRr18/qlatysyZM/Hw8GDu3Lk2y3/xxRe0b9+et956iypVqjBx4kTq1KnD119/nck1F0IIIUR2lKVzbmJjYzlw4ABjxoyxHlNVlTZt2rBr1y6b1+zatYuRI0cmOhYcHMyKFStslo+JiSEmJsb6ODw8HLBs/hgXF5ekfMIxW+eEhbRR8qSNnCPtlDxpo+RJGzknp7dTSuqdpcHNrVu3MJvN+Pn5JTru5+fHiRMnbF5z/fp1m+WvX79us/zkyZOZMGFCkuMbNmzAw8PDbt02btyYXPXzPGmj5EkbOUfaKXnSRsmTNnJOTm2nyMhIp8vm+tVSY8aMSdTTEx4eTkBAAO3atcPHxydJ+bi4ODZu3Ejbtm0xmUyZWdUcQ9ooedJGzpF2Sp60UfKkjZyT09spYeTFGVka3BQqVAiDwUBoaGii46GhoRQtWtTmNUWLFk1ReVdXV1xdXZMcN5lMDv9zkzsvpI2cIW3kHGmn5EkbJU/ayDk5tZ1SUucsnVDs4uJC3bp12bx5s/WYpmls3ryZoKAgm9cEBQUlKg+WLjZ75YUQQgiRt2T5sNTIkSPp27cv9erVo0GDBnz++edERETQr18/AF588UWKFy/O5MmTARg2bBgtWrRgypQpdOrUiUWLFrF//35mz56dlS9DCCGEENlElgc3PXv25ObNm7z//vtcv36d2rVrs379euuk4YsXL6KqjzqYGjduzMKFC3n33Xd55513qFChAitWrKB69epZ9RKEEEIIkY1keXADMHToUIYOHWrz3NatW5Mc69GjBz169EjVc+m6ZfdnexOT4uLiiIyMJDw8PEeOSWYGaaPkSRs5R9opedJGyZM2ck5Ob6eE39sJv8cdyRbBTWa6f/8+AAEBAVlcEyGEEEKk1P379/H19XVYRtGdCYFyEU3TuHr1Kt7e3iiKkuR8wlLxS5cu2VwqLqSNnCFt5Bxpp+RJGyVP2sg5Ob2ddF3n/v37FCtWLNF0FVvyXM+NqqqUKFEi2XI+Pj458j8/M0kbJU/ayDnSTsmTNkqetJFzcnI7JddjkyDL95YSQgghhEhPEtwIIYQQIleR4OY/XF1dGTdunM2sxsJC2ih50kbOkXZKnrRR8qSNnJOX2inPTSgWQgghRO4mPTdCCCGEyFUkuBFCCCFEriLBjRBCCCFyFQluhBBCCJGr5MngZvr06ZQuXRo3NzcaNmzI3r17HZb/5ZdfqFy5Mm5ubtSoUYO1a9dmUk2zTkraaN68eSiKkuiPm5tbJtY2823fvp2nnnqKYsWKoSgKK1asSPaarVu3UqdOHVxdXSlfvjzz5s3L8HpmpZS20datW5O8jxRF4fr165lT4SwwefJk6tevj7e3N0WKFKFr166cPHky2evy0mdSatooL34mffPNN9SsWdOaoC8oKIh169Y5vCY3v4/yXHCzePFiRo4cybhx4zh48CC1atUiODiYGzdu2Cy/c+dOevfuzYABAzh06BBdu3ala9euHD16NJNrnnlS2kZgyXh57do1658LFy5kYo0zX0REBLVq1WL69OlOlQ8JCaFTp060atWKw4cPM3z4cAYOHMjvv/+ewTXNOiltowQnT55M9F4qUqRIBtUw623bto0hQ4awe/duNm7cSFxcHO3atSMiIsLuNXntMyk1bQR57zOpRIkSfPzxxxw4cID9+/fTunVrunTpwrFjx2yWz/XvIz2PadCggT5kyBDrY7PZrBcrVkyfPHmyzfLPPvus3qlTp0THGjZsqL/yyisZWs+slNI2+v7773VfX99Mql32A+jLly93WGbUqFF6tWrVEh3r2bOnHhwcnIE1yz6caaM//vhDB/S7d+9mSp2yoxs3buiAvm3bNrtl8uJn0uOcaaO8/pmUIH/+/PqcOXNsnsvt76M81XMTGxvLgQMHaNOmjfWYqqq0adOGXbt22bxm165dicoDBAcH2y2f06WmjQAePHhAqVKlCAgIcPhtIa/Ka++jtKhduzb+/v60bduWHTt2ZHV1MlVYWBgABQoUsFsmr7+XnGkjyNufSWazmUWLFhEREUFQUJDNMrn9fZSngptbt25hNpvx8/NLdNzPz8/uuP7169dTVD6nS00bVapUiblz57Jy5Up+/PFHNE2jcePGXL58OTOqnCPYex+Fh4cTFRWVRbXKXvz9/Zk5cybLli1j2bJlBAQE0LJlSw4ePJjVVcsUmqYxfPhwmjRpQvXq1e2Wy2ufSY9zto3y6mfSkSNH8PLywtXVlcGDB7N8+XKqVq1qs2xufx/luV3BRfoLCgpK9O2gcePGVKlShVmzZjFx4sQsrJnISSpVqkSlSpWsjxs3bszZs2eZNm0aCxYsyMKaZY4hQ4Zw9OhR/vrrr6yuSrblbBvl1c+kSpUqcfjwYcLCwli6dCl9+/Zl27ZtdgOc3CxP9dwUKlQIg8FAaGhoouOhoaEULVrU5jVFixZNUfmcLjVt9F8mk4nAwEDOnDmTEVXMkey9j3x8fHB3d8+iWmV/DRo0yBPvo6FDh7J69Wr++OMPSpQo4bBsXvtMSpCSNvqvvPKZ5OLiQvny5albty6TJ0+mVq1afPHFFzbL5vb3UZ4KblxcXKhbty6bN2+2HtM0jc2bN9sdlwwKCkpUHmDjxo12y+d0qWmj/zKbzRw5cgR/f/+MqmaOk9feR+nl8OHDufp9pOs6Q4cOZfny5WzZsoUyZcoke01eey+lpo3+K69+JmmaRkxMjM1zuf59lNUzmjPbokWLdFdXV33evHn6v//+q7/88st6vnz59OvXr+u6rusvvPCCPnr0aGv5HTt26EajUf/ss8/048eP6+PGjdNNJpN+5MiRrHoJGS6lbTRhwgT9999/18+ePasfOHBA79Wrl+7m5qYfO3Ysq15Chrt//75+6NAh/dChQzqgT506VT906JB+4cIFXdd1ffTo0foLL7xgLX/u3Dndw8NDf+utt/Tjx4/r06dP1w0Gg75+/fqsegkZLqVtNG3aNH3FihX66dOn9SNHjujDhg3TVVXVN23alFUvIcO9+uqruq+vr75161b92rVr1j+RkZHWMnn9Myk1bZQXP5NGjx6tb9u2TQ8JCdH/+ecfffTo0bqiKPqGDRt0Xc9776M8F9zouq5/9dVXesmSJXUXFxe9QYMG+u7du63nWrRoofft2zdR+SVLlugVK1bUXVxc9GrVqulr1qzJ5BpnvpS00fDhw61l/fz89I4dO+oHDx7MglpnnoRly//9k9Auffv21Vu0aJHkmtq1a+suLi562bJl9e+//z7T652ZUtpGn3zyiV6uXDndzc1NL1CggN6yZUt9y5YtWVP5TGKrfYBE7428/pmUmjbKi59J/fv310uVKqW7uLjohQsX1p944glrYKPree99pOi6rmdeP5EQQgghRMbKU3NuhBBCCJH7SXAjhBBCiFxFghshhBBC5CoS3AghhBAiV5HgRgghhBC5igQ3QgghhMhVJLgRQgghRK4iwY0QQgghchUJboQQadKyZUsURbH5Z8WKFen+fC+99BKKotCyZct0v3dazJo1i6ZNm+Lp6Wl9/SdOnMjqagmRJxmzugJCiNzBxcWFwMDARMcKFCiQRbVJGV3XiY+Px2Qypfoe69at49ChQxQuXJgLFy6kY+2EECklPTdCiHTh7+/P7t27E/1p3rw5YNmd+IsvvqB69eq4ubmRP39+evToQUhIiPX6y5cv07FjRwICAnB3d8fd3Z3q1avz+eefk7BLTOnSpZk/fz4A27Zts/aQbN26la1bt1ofnz9/3nrfhGPz5s0DYN68edZj69evp1q1aphMJnbs2AHAnj176NixI/ny5cPNzY06deqwdOnSZF//jBkzCA8PZ/z48enQmkKItJDgRgiR4YYOHcrw4cM5duwY5cuXx2AwsHTpUho3bsyNGzcAuHXrFuvWrQOgSpUq+Pj4cOzYMUaMGMGMGTMACAwMpFChQgB4e3vTsGFDGjZsiI+PT6rq1aVLFyIjIwkICABgx44dNGvWjHXr1uHu7k7p0qU5dOgQPXr04IcffnB4r2LFimEwGFJVDyFE+pLgRgiRLi5cuJBkzg1ASEgIM2fOBGD+/PkcPXqU8+fPU6JECa5fv85XX30FQJkyZQgJCeHSpUscPHiQa9euWXt+Fi1aBMDy5cvp1KkTAHXq1LH2ENWpUydVdR4xYgQhISGEhITQrFkz3n33XeLi4mjbti2XLl3ixIkTDB8+HICxY8emum2EEJlL5twIIdKFrTk3APv377cOK/Xt25e+ffsmOr97924AjEYj//vf/1izZg1Xr14lPj7eWubq1asZUueEwAXAYDCwd+9eADZu3Jhk/s3ly5e5cuUKxYsXz5C6CCHSjwQ3Qoh0kTDnxpHatWvj6uqa6FipUqUAS6AxZ84cACpUqECBAgU4e/Yst27dwmw2J/v8CT1FgLV8WFiYw2v8/PxsHi9evDglSpRIcvzxgEsIkX1JcCOEyFB169ZFURR0Xeell15i2LBhgGWF0l9//YWvry/wqAenXbt2/P7770RHR9OoUSNu3bqV6H4eHh4AREREJDpepEgR679PnTpFuXLl+OWXXxzW7fGACKB+/fps27aNUqVKsWnTJtzd3QFLr82BAwesgZgQInuTOTdCiAxVtmxZBg0aBFh6Z8qWLUvNmjXJly8fzZs35+DBgwDUrFkTgA0bNlCpUiUCAgK4dOlSkvtVrlwZsAx31ahRg0aNGhEVFUWFChUoWbIkAH369KFVq1YMGTIkRXX94IMPMBqN7Ny5E39/fwIDAylRogQlS5Zk2rRpDq99++23KV++PG+//bb1WHBwMOXLl+fLL79MUT2EEGkjwY0QIsN98803TJs2jRo1anD16lUuXLhA6dKlGTlypDUZ39SpU+nSpQteXl7cv3+ft956i6eeeirJvfr370/37t3x9fXl6NGj7NmzB7PZjNFoZPHixQQGBhIdHc2dO3dYvnx5iurZvHlztm/fTocOHVAUhX///ReTyUT37t158803HV4bGhrK2bNnrau/AC5evMjZs2e5c+dOiuohhEgbRU+Y6SeEEEIIkQtIz40QQgghchUJboQQQgiRq0hwI4QQQohcRYIbIYQQQuQqEtwIIYQQIleR4EYIIYQQuYoEN0IIIYTIVSS4EUIIIUSuIsGNEEIIIXIVCW6EEEIIkatIcCOEEEKIXEWCGyGEEELkKv8Pd2cliGmS+2MAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 7 + }, + { + "cell_type": "markdown", + "id": "c8d616f4", + "metadata": {}, + "source": [ + "#### Teil b\n", + "Testen Sie die serielle Implementierung auf einem CPU-basierten Knoten des bwUniClusters. \n", + "\n", + "- Erstellen Sie dazu ein Python-Skript basierend auf untenstehendem Code sowie den Funktionen in der obigen Implementierung, welches Sie mithilfe eines Submit-Skripts auf dem Cluster starten. \n", + "- Nutzen Sie die Daten und Labels in der HDF5-Datei `/pfs/work7/workspace/scratch/ku4408-VL-ScalableAI/data/logit_data_n10000_d2.h5`, die Sie in den Datensätzen `data` bzw. `labels` vorfinden. Der Datensatz enthält 10 000 Samples mit je 2 Features.\n", + "- Die zu verwendende Anzahl der Epochen sowie die Batchgröße können Sie als Command-Line-Argumente des Python-Skripts übergeben. \n", + "- Laden Sie wie auf den vorherigen Übungsblättern die benötigten Module und aktivieren Sie Ihre virtuelle Python-Umgebung, bevor Sie das eigentliche Skript ausführen (siehe untenstehendes Submit-Skript). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "80c0733c", + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "\n", + "import h5py\n", + "import numpy as np\n", + "\n", + "\n", + "np.random.seed(842424) # Fix random seed for reproducibility.\n", + "\n", + "##################################\n", + "# PUT FUNCTION DEFINITIONS HERE! #\n", + "##################################\n", + "\n", + "if __name__ == \"__main__\":\n", + " path = \"/pfs/work7/workspace/scratch/ku4408-VL-ScalableAI/data/logit_data_n10000_d2.h5\"\n", + " parser = argparse.ArgumentParser(prog=\"Logit\")\n", + " parser.add_argument(\n", + " \"--epochs\",\n", + " type=int,\n", + " default=100,\n", + " help=\"The number of epochs to train.\",\n", + " )\n", + "\n", + " parser.add_argument(\n", + " \"--batch_size\",\n", + " type=int,\n", + " default=10,\n", + " help=\"The batch size.\",\n", + " )\n", + "\n", + " args = parser.parse_args()\n", + "\n", + " with h5py.File(path, \"r\") as f:\n", + " data = np.array(f[\"data\"])\n", + " labels = np.array(f[\"labels\"])\n", + "\n", + " print(\n", + " f\"We have {data.shape[0]} samples with {data.shape[1]} features and {labels.shape[0]} labels.\"\n", + " )\n", + "\n", + " # Bias trick: Prepend data with 1's for additional bias dimension.\n", + " ones = np.ones(\n", + " (\n", + " data.shape[0],\n", + " 1,\n", + " )\n", + " )\n", + " data_bt = np.hstack([ones, data])\n", + " weights = np.random.rand(data_bt.shape[1]) # Initialize model parameters randomly.\n", + " weights, loss_history, acc_history, time_per_epoch = lr_train(\n", + " weights, data_bt, labels, epochs=args.epochs, b=args.batch_size\n", + " )\n", + " print(f\"Final loss is {loss_history[-1]}, final accuracy is {acc_history[-1]}.\")\n", + " print(f\"Training time per epoch is {time_per_epoch} s.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a1abbe8", + "metadata": {}, + "outputs": [], + "source": [ + "#!/bin/bash\n", + "\n", + "#SBATCH --job-name=logit_serial # Job name\n", + "#SBATCH --partition=dev_single # Queue for the resource allocation.\n", + "#SBATCH --time=5:00 # Wall-clock time limit \n", + "#SBATCH --cpus-per-task=40 # Number of CPUs required per MPI task\n", + "#SBATCH --ntasks-per-node=1 # Maximum count of tasks per node\n", + "#SBATCH --mail-type=ALL # Notify user by email when certain event types occur.\n", + "\n", + "export OMP_NUM_THREADS=40\n", + "export VENVDIR=<path/to/your/venv> # Export path to your virtual environment.\n", + "export PYDIR=<path/to/your/python/script> # Export path to directory containing Python script.\n", + "\n", + "# Set up modules.\n", + "module purge # Unload all currently loaded modules.\n", + "module load compiler/gnu/13.3 # Load required modules.\n", + "module load mpi/openmpi/4.1\n", + "module load devel/cuda/12.4\n", + "module load lib/hdf5/1.14.4-gnu-13.3-openmpi-4.1\n", + "\n", + "source ${VENVDIR}/bin/activate # Activate your virtual environment.\n", + "\n", + "python ${PYDIR}/logit_serial.py --epochs 100 --batch_size 10" + ] + }, + { + "cell_type": "markdown", + "id": "83c5b31f", + "metadata": {}, + "source": [ + "### Aufgabe 3\n", + "Implementieren Sie ausgehend von obigem seriellen Code eine daten-parallele Version der logistischen Regression. Datenparallelismus bezeichnet eine Form der Parallelisierung, bei der das Training über die vorliegenden Samples in einem Batch der effektiven Batchgröße $b_\\text{eff}$ parallelisiert wird.\n", + "Die Daten werden partitioniert und auf die verschiedenen Prozessoren verteilt, die diese parallel bearbeiten.\n", + "Jeder Prozessor verfügt über eine eigene Kopie des Modells und arbeitet lokal mit den jeweils vorliegenden Samples, wobei bei Bedarf mit den anderen Prozessoren kommuniziert wird, um die Kopien konsistent zu halten. Für den Gradientenabstieg bedeutet dies, dass es neben der oben erwähnten globalen effektiven Batchgröße $b_\\text{eff}$ auf jedem Prozessor $p$ eine lokale Batchgröße $b_p$ (\"Mini-Mini-Batch\") gibt, für die gilt:\n", + "\n", + "$$b_\\text{eff}=\\sum_{p}b_p$$\n", + "\n", + "Jeder Prozessor berechnet für seine lokal vorliegenden Batches der Größe $b_p$ die Kostenfunktion sowie deren Gradient bezüglich der Gewichte. Nach Abarbeitung eines lokalen Batches müssen nun alle Prozessoren die jeweils lokal berechneten Gradienten austauschen und über diese mitteln, sodass jeder Prozessor anschließend die Gewichte seiner lokalen Modellkopie entsprechend der effektiven Batchgröße redundant und mit allen anderen Kopien konsistent aktualisieren kann. \n", + "\n", + "- Wie in den vorherigen Übungen auch laden wir dazu die Daten entlang der Sample-Achse verteilt auf die vorliegenden Prozessoren. Untenstehend finden Sie einen entsprechenden Dataloader. \n", + "- Implementieren Sie ausgehend von den seriellen Funktionen eine daten-parallele Version des Gradientenabstiegs für die logistische Regression und testen Sie Ihren Code auf vier CPU-basierten Knoten des bwUniClusters. \n", + "- Erstellen Sie dazu analog zu Aufgabenteil 2b ein Python-Skript sowie ein Submit-Bash-Skript (siehe auch vorherige Übungsblätter). \n", + "- Nutzen Sie die Daten und Labels in der HDF5-Datei `/pfs/work7/workspace/scratch/ku4408-VL-ScalableAI/data/logit_data_n100000_d2.h5`, die Sie in den Datensätzen `data` bzw. `labels` vorfinden. Der Datensatz enthält 100 000 Samples mit je 2 Features.\n", + "- Trainieren Sie für $epochs = 100$ Epochen und nutzen Sie zunächst eine effektive Batchgröße von $b_\\mathrm{eff}=100$. \n", + "- Sie können diesen Datensatz ebenfalls mit Ihrer seriellen Variante der logistischen Regression auf dem Cluster klassifizieren. Vergleichen Sie die Güte des trainierten Modells für die gleiche Anzahl an Epochen $epochs = 100$ und die gleiche (effektive) Batchgröße $b_\\mathrm{(eff)}=100$. Was fällt Ihnen auf? Variieren Sie gegebenenfalls die Hyperparameter Ihrer parallelen Version, sodass Sie eine vergleichbare Qualität des trainierten Modells erhalten. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5789926d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from mpi4py import MPI\n", + "import h5py\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " parser = argparse.ArgumentParser(prog=\"Logit\")\n", + " parser.add_argument(\n", + " \"--epochs\",\n", + " type=int,\n", + " default=100,\n", + " help=\"The number of epochs to train.\",\n", + " )\n", + "\n", + " parser.add_argument(\n", + " \"--batch_size\",\n", + " type=int,\n", + " default=10,\n", + " help=\"The batch size.\",\n", + " )\n", + "\n", + " args = parser.parse_args()\n", + " comm = MPI.COMM_WORLD # Set up communicator.\n", + " size, rank = comm.size, comm.rank\n", + "\n", + " if rank == 0:\n", + " print(\n", + " \"################################\\n\"\n", + " \"# Parallel Logistic Regression #\\n\"\n", + " \"################################\"\n", + " )\n", + " print(\n", + " f\"We train for {args.epochs} epochs with an effective batch size of {args.batch_size}.\"\n", + " )\n", + "\n", + " path = \"/pfs/work7/workspace/scratch/ku4408-VL-ScalableAI/data/logit_data_n10000_d2.h5\"\n", + "\n", + " with h5py.File(path, \"r\") as f: # Load data in sample-parallel fashion.\n", + " chunk = int(f[\"data\"].shape[0] / size)\n", + " if rank == size - 1:\n", + " data = np.array(f[\"data\"][rank * chunk :])\n", + " labels = np.array(f[\"labels\"][rank * chunk :])\n", + " else:\n", + " data = np.array(f[\"data\"][rank * chunk : (rank + 1) * chunk])\n", + " labels = np.array(f[\"labels\"][rank * chunk : (rank + 1) * chunk])\n", + "\n", + " print(\n", + " f\"Rank {rank}/{size}: Local data has {data.shape[0]} samples with {data.shape[1]} features and \"\n", + " f\"{labels.shape[0]} labels.\\n0th elements are: {data[0]}\\n{labels[0]}\"\n", + " )\n", + "\n", + " # Bias trick: Prepend data with 1's for additional bias dimension.\n", + " ones = np.ones(\n", + " (\n", + " data.shape[0],\n", + " 1,\n", + " )\n", + " )\n", + " data_bt = np.hstack([ones, data])\n", + "\n", + " # Initialize model parameters randomly.\n", + " # After bias trick, weights have shape [n_features+1, ]\n", + " if rank == 0:\n", + " weights = np.random.rand(data_bt.shape[1])\n", + " else:\n", + " weights = np.zeros(data_bt.shape[1])\n", + "\n", + " # Broadcast weights from root to other processors.\n", + " comm.Bcast(weights, root=0)\n", + "\n", + " b_local = args.batch_size // size # Calculate local batch size.\n", + " print(f\"Rank {rank}/{size}: Local batch size is {b_local}.\")\n", + " # Train model.\n", + " (weights, loss_history, acc_history, training_time_per_epoch) = lr_train(\n", + " weights, data_bt, labels, b=b_local, epochs=args.epochs\n", + " )\n", + "\n", + " if rank == 0:\n", + " print(\n", + " f\"Final loss: {loss_history[-1]}, final accuracy: {acc_history[-1]}\\n\"\n", + " f\"Average training time per epoch: {training_time_per_epoch} s\"\n", + " )" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/4_logit/solutions/submit_parallel.sh b/4_logit/solutions/submit_parallel.sh new file mode 100644 index 0000000..9daaf00 --- /dev/null +++ b/4_logit/solutions/submit_parallel.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +#SBATCH --job-name=logit_parallel # Job name +#SBATCH --partition=dev_multiple # Queue for the resource allocation +#SBATCH --nodes=4 # Number of nodes +#SBATCH --time=5:00 # Wall-clock time limit +#SBATCH --cpus-per-task=40 # Number of CPUs required per MPI task +#SBATCH --ntasks-per-node=1 # Maximum count of tasks per node +#SBATCH --mail-type=ALL # Notify user by email when certain event types occur. + +export OMP_NUM_THREADS=40 +export VENVDIR=<path/to/your/venv> # Export path to your virtual environment. +export PYDIR=<path/to/your/python/script> # Export path to directory containing Python script. + +# Set up modules. +module purge # Unload all currently loaded modules. +module load compiler/gnu/13.3 # Load required modules. +module load mpi/openmpi/4.1 +module load devel/cuda/12.4 +module load lib/hdf5/1.14.4-gnu-13.3-openmpi-4.1 + +source ${VENVDIR}/bin/activate # Activate your virtual environment. +mpirun python ${PYDIR}/logit_parallel.py --epochs 100 --batch_size 100 diff --git a/4_logit/solutions/submit_serial.sh b/4_logit/solutions/submit_serial.sh new file mode 100644 index 0000000..8b6758c --- /dev/null +++ b/4_logit/solutions/submit_serial.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +#SBATCH --job-name=logit_serial # Job name +#SBATCH --partition=dev_single # Queue for the resource allocation. +#SBATCH --time=5:00 # Wall-clock time limit +#SBATCH --cpus-per-task=40 # Number of CPUs required per MPI task +#SBATCH --ntasks-per-node=1 # Maximum count of tasks per node +#SBATCH --mail-type=ALL # Notify user by email when certain event types occur. + +export OMP_NUM_THREADS=40 +export VENVDIR=<path/to/your/venv> # Export path to your virtual environment. +export PYDIR=<path/to/your/python/script> # Export path to directory containing Python script. + +# Set up modules. +module purge # Unload all currently loaded modules. +module load compiler/gnu/13.3 # Load required modules. +module load mpi/openmpi/4.1 +module load devel/cuda/12.4 +module load lib/hdf5/1.14.4-gnu-13.3-openmpi-4.1 + +source ${VENVDIR}/bin/activate # Activate your virtual environment. + +python ${PYDIR}/logit_serial.py --epochs 100 --batch_size 10 -- GitLab