{"cells":[{"metadata":{},"cell_type":"markdown","source":"# 1. Introduction\n**MNIST** - the famous dataset of handwritten digits, which commonly used to learn computer vision basics. Dataset consists of black-and-white images of hand-drawn digits (between 0 and 9).  \nIn current notebook I will use PyTorch library to create Fully Connected Neural Network in order to determine digit by its handwritten image.\n\nThe task was completed as part of the [Getting Started Prediction Competition](https://www.kaggle.com/c/digit-recognizer/).  \nThe submission file should contain a header and have the following format:  \nImageId,Label  \n1,0  \n2,0  \n3,0  \netc.  ","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"# 2. Import libraries\nPytorch:  \n* **torch** - the core package of PyTorch  \n* **torch.nn** - the nn package is used for building neural networks (imported as nn)  \n* **torch.nn.functional** - contains all the functions in the torch.nn library (imported as F)\n\nOther:  \n* **train_test_split** from sklearn.model_selection - to split our train data on train and validation datasets  \n* **scikitplot** - to create a confusion matrix (imported as skplt)  \n* **pandas** - to load and transform data  (imported as pd)\n* **matplotlib.pyplot** - to create some visualizations  (imported as plt)\n\n","execution_count":null},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"import torch                        # The core package of Torch\nimport torch.nn as nn               # The nn package is used for building neural networks\nimport torch.nn.functional as F     # Contains all the functions in the torch.nn library\n\nfrom sklearn.model_selection import train_test_split\nimport scikitplot as skplt\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# 3. Prepare data","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"## 3.1 Load data\n\nAs input information I have two CSV files:  \n* **train.csv** - contains information about 42 000 (60% of the whole MNIST dataset) gray-scale images of hand-drawn digits (from 0 to 9).  \nFirst column is the digit. The rest 784 columns represent pixels of hand-drawn digit (each image has 28 x 28 pixels shape). The value of each pixel-column is an intager between 0 and 255 - represent darkness or lightness of the given pixel. \n* **test.csv** - contains information about 28 000 gray-scale images of hand-drawn digits (from 0 to 9). Doesn't contain labels. ","execution_count":null},{"metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true},"cell_type":"code","source":"# read data\ntrain_data = pd.read_csv('../input/digit-recognizer/train.csv')\ntest = pd.read_csv('../input/digit-recognizer/test.csv')\n\n# check that we loaded data correctly\nprint(\"Train data shape:\", train_data.shape)\nprint(\"Test data shape:\", test.shape)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Let's create a barchart to check the number of digits in each class:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"label_counts  = train_data[\"label\"].value_counts().sort_index()\nlabel_counts.plot.bar()\nplt.hlines(xmin = -1, xmax = 10, y = 4000, linestyles='dotted')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Split labels and features of training dataset and convert to numpy array:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_all = train_data.iloc[:,1:]     # only features (pixels)\ntrain_all_label = train_data[\"label\"] # labels\n\n# convert to numpy array\ntrain_all_numpy = train_all.to_numpy()\ntrain_all_label_numpy = train_all_label.to_numpy()\ntest_numpy = test.to_numpy()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Lets visualize some train examples with it's labels:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def plot_img(data, label):\n    fig, axs = plt.subplots(3, 3) # 9 images\n    k = 0\n    for i in range(3):\n        for j in range(3):        \n            axs[i, j].imshow(data[k].astype('uint8').reshape(28, 28))   # plot image            \n            axs[i, j].set_ylabel(\"label:\" + str(label[k].item()))       # print label\n            k +=1\nplot_img(train_all_numpy, train_all_label_numpy)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## 3.2 Train and validation \n\nI would like to check my model on unseen data (data I didn't use in the training process) before submitting it.  \nSince I don't have labels in test dataset, I will randomly split my treaining data on training and validation datasets in proportion 8:2.  \nTo do so, I am using train_test_split function from sklearn module:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# split train on train and validation\ntrain, validation, train_label, validation_label = train_test_split(train_all_numpy, train_all_label_numpy, test_size=0.2)\n\nprint(train.shape)\nprint(train_label.shape)\nprint(validation.shape)\nprint(validation_label.shape)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Check if both datasets represent all classes in fair proportion:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"unique, counts_train = np.unique(train_label, return_counts=True)\nplt.subplot(1, 2, 1)\nplt.bar(unique, counts_train/len(train_label))\nunique, counts_val = np.unique(validation_label, return_counts=True)\nplt.subplot(1, 2, 2)\nplt.bar(unique, counts_val/len(validation_label))\n#print (np.asarray((unique, counts_train/len(train_label), counts_val/len(validation_label))).T)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## 3.3 Tensors\nTensor is a multi-dimensional matrix containing elements of a single data type. To use PyTorch, we need to covert our data to tensors.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_all_tensor = torch.as_tensor(train_all_numpy).type(torch.FloatTensor)\ntrain_all_label_tensor = torch.as_tensor(train_all_label_numpy)\ntest_tensor = torch.as_tensor(test_numpy).type(torch.FloatTensor)\n\ntrain_tensor = torch.as_tensor(train).type(torch.FloatTensor)\ntrain_label = torch.as_tensor(train_label)\n\nvalidation_tensor = torch.as_tensor(validation).type(torch.FloatTensor)\nvalidation_label = torch.as_tensor(validation_label)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# 4. FNN\n## 4.1 neural network architecture","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"                   # nn.Module - Base class for all neural network modules.\nclass FNet(nn.Module):             \n    def __init__(self):\n        super(FNet, self).__init__()\n                   # 784 inputs, connects to hidden layer with 600 nodes\n        self.fc1 = nn.Linear(in_features=784, out_features=600)\n                   # 600 nodes connects to hidden layer with 500 nodes\n        self.fc2 = nn.Linear(in_features=600, out_features=500) \n                   # 500 nodes connects to hidden layer with 250 nodes\n        self.fc3 = nn.Linear(in_features=500, out_features=250) \n                   # connection between the last hidden layer \n                   # and the output layer (with 10 nodes)\n        self.fc4 = nn.Linear(in_features=250, out_features=10)  \n                                                                \n    def forward(self, x):\n        x = x.view(-1,784)          # Put all the entries of the image in the vector\n        x = F.relu(self.fc1(x))     # Input x into first layer and apply a ReLU\n                                    # to the nodes in this layer\n        x = F.relu(self.fc2(x))        \n        x = F.relu(self.fc3(x))\n        x = self.fc4(x)\n        return x     ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### 4.1.2 Layers\nA fully connected neural network consists of a series of fully connected layers.  \nThe first layer takes the 784 (28 x 28) input pixels and connects to the first 600 node hidden layer. Then we have 600 to 500 hidden layer, 500 to 250 hidden layer and in the end the connection between the last hidden layer and the output layer (with 10 nodes).\n\n* input: 784 (image shape)\n* 3 hidden layers (600, 500, 250 nodes)\n* output: 10 neurons for each possible class\n\nI use **nn.Linear** to constructs a fully connected layer. The first argument is the number of nodes in layer l and the next argument is the number of nodes in layer l+1.\n\n### 4.1.3 Forward method\n* First, I need to reshape tensor x, so I use the view function for it.  \n* Second, input data x into the first fully connected layer (self.fc1(x)) and then apply a ReLU activation to the nodes in this layer using. * * Because of the hierarchical nature of this network, we replace x at each stage, feeding it into the next layer. \n* We do this through our three fully connected layers, except for the last one.\n\nAs activation function, I am using **ReLU** (The Rectified Linear Unit). It gives an output 0 if x is negative and x otherwise. The purpose of the activation function is to introduce non-linearity into the network (non-linear means that the output can not be reproduced from a linear combination of the inputs). To do it in code, I am using F.relu - applies the rectified linear unit function element-wise.\n\n$$\nf(x)=max(0,x)\n$$","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"## 4.2 Training the NN","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"## 4.2.1 Accuracy\nBefore start the training process, let's define an accuracy function.  \n**Accuracy** - fraction of the time classifier is correct.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def get_accuracy(predictions, true_labels):\n    _, predicted = torch.max(predictions, 1)\n    corrects = (predicted == true_labels).sum()\n    accuracy = 100.0 * corrects/len(true_labels)\n    return accuracy.item()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### 4.2.2 Training function\n\nTraining process:  \n1. Do a forward pass\n2. Calculate loss function\n3. Calculate the gradients\n4. Change the weights based on gradients\n\n\nThe entire training of the network is based on minimizing the loss function. An optimizer determines, based on the loss function, how each parameter should change.  \nThe optimizer solves the credit assignment problem: how do we assign credit to the parameters when the network performs poorly?","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def training (dataloader, epochs, model, criterion, optimizer):\n\n    train_accuracies, train_losses = [], []\n    \n    # set the train mode\n    model.train()\n    \n    # loop over training dataset multiple times\n    for epoch in range(epochs):        \n\n        train_loss = 0 \n        train_accuracy = 0\n        num_batch = 0\n        \n        # iterate over all batches\n        for data, labels in dataloader:\n            \n            # zero the parameters gradient to not accumulate gradients from previous iteration\n            optimizer.zero_grad()\n            \n            # put data into the model\n            predictions = net(data)\n            \n            # calculate loss\n            loss = criterion(predictions, labels)\n            \n            # calculate accuracy\n            accurasy = get_accuracy(predictions, labels)\n            \n            # compute gradients\n            loss.backward()\n            \n            # change the weights\n            optimizer.step()\n            \n            num_batch += 1\n            train_loss += loss.item()\n            train_accuracy += accurasy\n    \n        epoch_accuracy = train_accuracy/num_batch\n        epoch_loss = train_loss/num_batch        \n        train_accuracies.append(epoch_accuracy)\n        train_losses.append(epoch_loss)\n        \n        print(\"Epoch: {}/{} \".format(epoch + 1, epochs),\n              \"Training Loss: {:.4f} \".format(epoch_loss),\n              \"Training accuracy: {:.4f}\".format(epoch_accuracy))\n    \n    return train_accuracies, train_losses\n    ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### 4.2.3 Train\n\n* **Loss function** - For the loss function I will use **Softmax Cross-Entropy Loss** (nn.CrossEntropyLoss()) - transforms numbers into probabilities. A loss function computes how \"bad\" a predictions was, compared to the ground truth value for the input. The more accurate the network is, the smaller the loss is. The loss function transforms a problem of finding good weights to perform a task, into an optimization problem: finding the weights that minimize the loss function (or the average value of the loss function across some training data).\n\n* **Optimizer** - I will use **Adam optimizer**(torch.optim.Adam) - a version of gradient descent (by going in the direction of the gradient we are actually going in direction of the local minima of the function).\nParameter lr is learning rate - controls the size of each parameter update step we take. An epoch is a measure of the number of times all training data is used once to update the parameters.\n\n* **DataLoader** - represents a Python iterable over a dataset.\n* **batch_size** -  denotes the number of samples contained in each generated batch.\n* **epochs** - number of passes through the full training set. 1 Epoch = 1 Forward pass + 1 Backward pass for ALL training samples.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"torch.manual_seed(0)                                      # set seed to make results reproducible\n\nbatch_size = 128                                          # Set the batch_size\ntrain_dataset = torch.utils.data.TensorDataset(train_tensor, train_label)\ntrainloader = torch.utils.data.DataLoader(train_dataset, batch_size = batch_size, shuffle = True)\n\n\nepochs = 40                                               # set number of epohs\n\nnet = FNet()                                              # initialize network\ncriterion = nn.CrossEntropyLoss()                         # set criterion\noptimizer = torch.optim.Adam(net.parameters(), lr = 3e-4) # set optimizer\n\n                                                          # start training process\ntrain_accuracies, train_losses = training(trainloader, epochs, net, criterion, optimizer)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"A training curve is a chart that shows:\n\n* The epochs on the x-axis\n* The loss and accuracy on the y-axis","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def train_curves(epochs, train_losses, train_accuracies):\n    iters = range(1, epochs+1)\n    fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(15, 5))\n    fig.suptitle('Training Curve')\n    ax1.plot(iters, train_losses)\n    ax1.set_xlabel(\"Iterations\")\n    ax1.set_ylabel(\"Loss\")\n    ax2.plot(iters, train_accuracies, color = 'g')\n    ax2.set_xlabel(\"Iterations\")\n    ax2.set_ylabel(\"Training Accuracy\")\n    plt.show()\n    \ntrain_curves(epochs, train_losses, train_accuracies)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# 5. Evaluation \nLet’s see the test loss after the training. We switch the module mode to the evaluation mode and check the test loss.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# set net in test (evaluation) mode\nnet.eval()    \n# get predictions\nval_predictions = net(validation_tensor)\nval_loss = criterion(val_predictions, validation_label)\nval_accurasy = get_accuracy(val_predictions, validation_label)\n \nprint(\"Loss: \", str(val_loss.item()), \"Accuracy: \", str(val_accurasy))\n\n# to get class with the maximum score as prediction\n_, val_predicted = torch.max(val_predictions.data,1)            \n\n# confusion matrix\nskplt.metrics.plot_confusion_matrix(validation_label, val_predicted, figsize=(5,5))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Some examples with predicted label:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"plot_img(validation, val_predicted)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"And examples of the wrong classified images (with predicted labels):","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# wrong predicted\n\nval_wrong = validation[validation_label != val_predicted]\nval_lab_wrong = val_predicted[validation_label != val_predicted]\n\nplot_img(val_wrong, val_lab_wrong)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# 6. Train all \nFor the submission I will use model, traind with all possible information,entire train dataset - 42000 labeled examples (60% of the whole MNIST dataset):","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"torch.manual_seed(0)                                      # set seed to make results reproducible\n\nbatch_size = 128                                          # Set the batch_size\ntrain_all_dataset = torch.utils.data.TensorDataset(train_all_tensor, train_all_label_tensor)\ntrainloader = torch.utils.data.DataLoader(train_dataset, batch_size = batch_size, shuffle = True)\n\nepochs = 40                                               # set number of epohs\n\nnet = FNet()                                              # initialize network\ncriterion = nn.CrossEntropyLoss()                         # set criterion\noptimizer = torch.optim.Adam(net.parameters(), lr = 3e-4) # set optimizer\n\n                                                          # start training process\ntrain_accuracies, train_losses = training(trainloader, epochs, net, criterion, optimizer)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_curves(epochs, train_losses, train_accuracies)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# 7. Save results","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# set net in test (evaluation) mode\nnet.eval()  \n\n# get predictions for test data\ntest_predictions = net(test_tensor)\n\n# to get class with the maximum score as prediction\n_, test_predicted = torch.max(test_predictions.data,1)\n\n# Save results in the required format\noutput = pd.DataFrame({'ImageId': test.index + 1,\n                       'Label': test_predicted})\noutput.to_csv('submission.csv', index=False)\noutput.head()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"As result I got accuracy score = 0.97871  \n![submission_1.JPG](attachment:submission_1.JPG)\n\nIn the next notebook I will use CNN and additional data preparation","attachments":{"submission_1.JPG":{"image/jpeg":"/9j/4AAQSkZJRgABAQEAeAB4AAD/4RDmRXhpZgAATU0AKgAAAAgABAE7AAIAAAAJAAAISodpAAQAAAABAAAIVJydAAEAAAASAAAQzOocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRlbWlkb3ZhAAAABZADAAIAAAAUAAAQopAEAAIAAAAUAAAQtpKRAAIAAAADNDMAAJKSAAIAAAADNDMAAOocAAcAAAgMAAAIlgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIwMjA6MDU6MTAgMTg6MzE6MzcAMjAyMDowNToxMCAxODozMTozNwAAAGQAZQBtAGkAZABvAHYAYQAAAP/hCxtodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvADw/eHBhY2tldCBiZWdpbj0n77u/JyBpZD0nVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkJz8+DQo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIj48cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPjxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSJ1dWlkOmZhZjViZGQ1LWJhM2QtMTFkYS1hZDMxLWQzM2Q3NTE4MmYxYiIgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIi8+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iPjx4bXA6Q3JlYXRlRGF0ZT4yMDIwLTA1LTEwVDE4OjMxOjM3LjQyNzwveG1wOkNyZWF0ZURhdGU+PC9yZGY6RGVzY3JpcHRpb24+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iPjxkYzpjcmVhdG9yPjxyZGY6U2VxIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpsaT5kZW1pZG92YTwvcmRmOmxpPjwvcmRmOlNlcT4NCgkJCTwvZGM6Y3JlYXRvcj48L3JkZjpEZXNjcmlwdGlvbj48L3JkZjpSREY+PC94OnhtcG1ldGE+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgIDw/eHBhY2tldCBlbmQ9J3cnPz7/2wBDAAcFBQYFBAcGBQYIBwcIChELCgkJChUPEAwRGBUaGRgVGBcbHichGx0lHRcYIi4iJSgpKywrGiAvMy8qMicqKyr/2wBDAQcICAoJChQLCxQqHBgcKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKir/wAARCADLBJoDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD6OklEZAwWY9FWmee3/PCT81/xpD/x9P8A7i/zNPoAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAG+e3/PCT81/xo89v+eEn5r/AI06igBvnt/zwk/Nf8aPPb/nhJ+a/wCNOooAb57f88JPzX/Gjz2/54Sfmv8AjTqKAGH/AI+n/wBxf5tT6Yf+Pp/9xf5tT6ACiiigAoqjd6j9i1C1hmixDckoJ933X7KRjv65o/tHfrJsIYt4jj3zy7sCPP3RjHJP8qAL1FQw3dtcsy29xFKyHDBHDFfrjpThPEY2kEqFEyGbcMLjrk0ASUVA97axLuluYUXaHy0gA2nofpUjyJFGXkdUQDJZjgD8aAH0VALy2LSKLiItEMyAOMoPf0p8U8NxEJYJUljPR0YEH8RQBJRUMF3b3O77NcRTbThvLcNj64o+2W32n7P9oi8/r5W8bvy60ATUVRi1e0m1OWwSVfOiAJ+YYYnPA5zkY5q3JLHFt82RU3HC7jjJ9KAH0VAb60Ft9oNzCIM480yDb+fSpEkSSMSI6shGQwOQR9aAH0VDBd291u+zTxTbThvLcNg/hQt3bPcNAlxE0y/ejDgsPw60ATUVBLe2sGfOuYY9rBTvkAwfT61Dfata6e9utxIAbhwi/MOM/wARyenHWgC7RSKwZQykFSMgg9aijvLaaZoYriJ5U+8iuCy/UUATUVGJ4jG0glQomQzbhhcdcmqkuqxRalHbPsET27T+eZAFABA/r1zQBfoqEXVu1v8AaFnjMOM+YHG38+lILy2JkAuISYv9YN4+T6+lAE9FU7i9/wBBFxYvbzBmUBmlAQgnB+YZ5qaa8treREuLiKJ3+6ruFLfTPWgCaiop7mC1j33M0cKZxukcKPzNRT3Lq1sbfyXSZ8MzSY+XHVfU+1AFqioZbu2gkSOe4ijd/uq7gFvoD1p0lxDCcSypGcFsMwHA6mgCSio4Z4riISW8qSxnoyMGB/EVJQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFADD/AMfT/wC4v82p9MP/AB9P/uL/ADan0AFFFFAFPVbSO90ueGbOChII6qRyCPcGudEci+AZLlGd57oCa5k/iYFhu/8AHa60gEEEZB6g02OGOGFYoo1SNRgIqgAD0xQBz94ljHqGjnSBCspmwPIxzDtO7OO3Sq0d5bxeGtZglmRJRNcDyycNkk44610dvp9naOz2tpBAzfeaOMKT+VK+n2ckzTSWkDyuu1naMFmHTBPpQwWjTOf060t7rW7X7TCkoTS4iquMgHPXFafib/kWb7/rka0Et4Y3DxwxowQIGVQCFHQfT2p0sUc8TRzIskbDDK4yD+FEtQjoznrrTbJdd0dFtYgrpLvAQfPhQRu9eeeaoXaC3j1yGFfLtVu4DKkYwFjIXfwP1rrzDE0iSNGhePOxioyueuD2oW3hVpGWJA0v+sIUZfjHPrxR/X4i7GDcpZx67pP9lLCshLb/ACAOYdvfHbOMVQAh0+3Eu2y1GzN1uDglLgOX/wDHiD9OldTbWFpZsxtLWGAt94xxhc/lSDTrIXX2kWcAnznzfKG7P160dR9DKtIrVPGN9mOFZDDE0eVAOTuyR/Wn+I4UuDpkUy7ke9QMp7jDcVrPawSXCTyQRtLH9yRkBZfoe1OkhjlKGWNXKNuXcoO0+o9DR2Duc5qMHl+JLSGNLOOBbdjAk6fu9+75sAYG7GKqXEPkaRegXED2rXkf2hLUEJEuRvH8ice9dZcWsF3H5d1BHMmc7ZEDD8jRHbQQweRDDHHFjHlqoC4+lH9fjcDGul02KRjpXlrqH2STyVt+644zjjrjGfwrKtrZZNHsGS402A70McqI3m78jIznOTyDXV21jaWe77HawwbvveVGFz+VIunWSXRuUtIFnJyZRGA359aOodDIs7G1u9Y1trq3jmPmqo8xQ2B5a9M9KzIUhfw74fkuljYC6VC0gBwvzcEnt0rsFhiR3ZI0VpDlyFALHGOfXiozZWptfsxtoTb/APPLyxt/LpR/wPwD/ghOI/sMg3eXF5ZG5P4RjqK5qw8uwl0uJ4rG7iZwlvc2xKyjIPzMvfjrzXVKiogRFCqowFAwAKgh06yt5zNb2kEUrdXSMBj+Io6h0sc5HeW8XhrWYJZkSUTXA8snDZJOOOtLGtq2r6KL3YUOn/KJPulvlxnP+c10b6fZyTNNJaQPK67WdowWYdME+lD2NpKoWS1hcBPLAaMHC/3fpwOKF/X3NA/6/A5S+EK2fiNbHaLQLHwn3BJ/FjH4ZrRutNsl8R6Wi2sQV4pd6hBh8AEbvXnnmttbK1W1NsttCLc9YhGNp/DpUjQxtKkjRoZEBCOVGVz1we1AHIXEaQW+rwwqscS6jAVRRgDJTOBVrUIUj1DUriJrC7UqPtFvdZV0AXorehHPSuiaztm37reI+Ywd8oPmYdCfUjApk+nWV1KstzaQTSL0eSMMR+Jo6W/roHUwpljvJtOurN7aOb7JlLS9BK7DjkHsR0zzUUM8U8Wk+RbLbKmpMhRG3JkK+Sp9K6S5srW8RVu7aKdV5USIGx+dKLW3CxKIIwsJzGNgwh9R6U+v9dxdDnrNNPkXWDq4gM4uHEhmxuEePkxntjpioNPgN1PoC6inmn7JKdsgzkZXbkHrxiuln0+zuZllubSCaRfuvJGGI/E1MYY2lWVo0MiAhXKjKg9QDSWg2Y2ixJb65rMECLHEskbBFGACU5wK3KjSGKOR5EjRXkxvYKAWx0ye9SUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAw/wDH0/8AuL/NqfTD/wAfT/7i/wA2p9ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA3arXT7lBwi4yPdqk8qP+4v5U1f+PqT/AHF/m1SUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQA3yo/7i/lR5Uf8AcX8qdRQA3yo/7i/lR5Uf9xfyp1FADfKj/uL+VHlR/wBxfyp1FADfKj/uL+VHlR/3F/KnUUAN8qP+4v5UeVH/AHF/KnUUAN8qP+4v5UeVH/cX8qdRQBGv/H1J/uL/ADapKjX/AI+pP9xf5tUlABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBGv/H1J/uL/NqkqNf+PqT/AHF/m1SUAFFFFAFG91e10+9tLa6LK10SqNgbQRjqfxqW5v4rS6tYJFctdOUQqBgEDPP5Vla1aQ32v6dbXK7o5IZwR+C8/Ws83Uy63pOm35LXVrcNhyP9bGUO1/r2PuKXb+uoHXUVxWqbJtNvdUsrSZmRmZL6a52spDY+RR2yMY4rSazi1TxJNFe7pIjYxMYw5UMSzcnFNag9Do6K4eW2VPB76nvla8tZSsMrStlFWXaB16Yq/cRzanr99HPZfbI7cRrFG1wYwmVzuA7knv7UAdTRWdoa3MelrHeOHdHYKRJv+XPALdyBxWjQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBn3erx214LSK3uLu4272jgUHYvYkkgCptP1GHUYWeJZI2jYpJFKu1kb0Iqjc2fnaxLNpeoC3vVjVZ42TerLyVyOCPqDWbf6jNPpF3FdpFHcWl5Ckrwk7Hy6nIzyOOooX9feD0Oqqtp99HqVjHdQK6xyZwHAB4OO30rO1F/8Aiq9IQN/BMSuf9kVi2On2r+CjqDSMLqCORo5hIQYirHAHOP8AHNHS47XO0ormUtk1bXUXUAzI+mxu8YYqCxY9cVnyWaDwncXxeZrqzldbeUytmMLJgAc+lG2/9a2Etdv66nXfamW4nWWCRIoUDeccbW9cd+Ka2pWqacl80uLdwpV9p5DEAcde4rGmiS71LWY7gb0NpE23JHOGP9Kz7jTLRfANrIIvmIhkJ3H7zFQT19KF/kB2dFc1qluRqljpcFt5tmIXk+zmcorkEdTznGc496rXAvdP0u9iB+y27zQoqrceY0CscPz2Hp9aP6/QDpbm/itLq1gkVy105RCoGAQM8/lVmuZu9Ms9N1zRVssxBp3zFvJDfIfm5PX3966ahAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBXv7xNPsJruVHdIV3MEAJx+NV9S1q00u0hubksY5nVE2AHrznr0q5PCtxbyQyDKSIVYexGK5Gxi/ttYNOn+b7BayxS+0hJjX9AT+NIZ1FzfxWt1a27q7SXTlUCgcYGSTz0q1XIWeoJdsb27d1TTbDy5Wj+8srHDY98L+tLHC1jq2lSQWT2QnlKOz3G95gVJ+YDI985p9bE9DojqSQ2k1zfRSWscUmzLjO4ZwGGM8HNXK4y9gjuPC+pvMNzRag5Qknj94B/I11tvaw21ottCm2IAgLkng+9HS4+pGL+OW3uJLRWuGt2ZGjUYJdeqjNWInMkKOyNGWUEo3VfY1yVnY29tomvywR7JEe4iVgx4UDgdas/ZY77VtNgudzRNppLIHIDcr1xR/X4Ng9Px/NHTUVxh06BvD+rSu0zPYTTLakyt+5C8jHNTymfVNVjhuLX7ZEllHKIWn8tSzdWI7+ntQGx1lFZegxXMFpNFckbUmYRL53mFF4+Ut7HNalABRRRQAUUUUAFFFFABRRRQAVT1LUo9MhieSGaYyyiJEhALFjnHUj0q5WJ4mEjR6cIXVJDfR7WZdwBw3bIzQBds9Re7mMbafeWw253zqoX6cMeavVSt7a9IkTUbmC5idduxICn5/MawNJkNzrEVjPMXtLIubRjn/AEgg4699mce/WjrYOlzrKK4yG3udTtbm8ktN9z5sgW5N5sMGCQABjgDH41fSA6trS2usHzFhso5BErnY7tnc3HXGMUA9DpKCcDJrm7qOGzTTIbe8aeJNSCfNJu8vg/Jn29+afdRx3XjJ7eX542007k3Ef8tPaj0/rS4/6/Gxq/2isunpeWMUl2khG0IMEjOCecdKuVxtvbRW3gW3lgXY800Jchjz+9ArSFpDrHiDUYtSDSJaiNYYi5AUFclsA9c9/amSdBRXHI0l1a6fbyzStGmqPAku87njAbHzfpmtLTraPTfFU9nZho7Z7RZjGWJAfcRkZpb/ANeVx/1+NjZmu4YJ4IZX2vOxWMYJ3EDJ/SiOd3u5omt5ESMDbKSNr59O/FYuvafa3WuaSbiLcZJHRvmIyAhIHB9ar6gSsviUKSAtnHt56fI1LpcZ1FFctNpkEN7pBjaZWvAUuGErZlXy84PPqO2KqXLyaWdZstOLxwLLbhQJCPLD/ewT0z69qfWwlqrnaUVzllYXFnq9s1vaJYxMGEyfat/mjHB2nuDjmujoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKyH8RQjzXhs7y4t4WKvcRRgoMdcZOTj2Fa9c7Db3FnZSXOg6hDNZZaQQXCZUcksA45HOeuaQzfhmjuIEmhYPHIoZWHcGn1zCyxa/qllFcoyWcll9oW33EB2LYwcdcD+dO1CNLGxSys7yQwS3yQy4lyYFbqgPUduvrT/AK/Gwv6/C50tFc81rFpHiGyg01THFdRy+dEHJX5QCGwe+eM1nW0P2HwSdUt/MN60Ozzi5yil8HHYY6/rR0A7KiuZtdPuLTULOW1tFswXxMxvN/nqR3B6nvmumoAKKKKAI1/4+pP9xf5tUlRr/wAfUn+4v82qSgAooooAhktIZbqK5dMzQhhG2TwD14/Cmz2FtcXUFzNEGmtyTE+SCuRg/WrFFAGY/h3S5DLvtiVlyXTzGCZPUhc4B9xVxLOCO6NykeJWjERbJ+6OQMfjTru6hsbOa7un2QQRtJI+CdqgZJwOegpbeeO6toriBt0UqB0bBGQRkHmgCu2k2T6c9g0ObZ2LMm9uSW3dc560l3pFlfSrLcRN5irtDxyMjEehKkZFXaKAIra2hs7dILaNY4kGFVegqWq1nfRX3n+Ssq+RM0L+ZEyZYdcZAyOeo4qzQAUUyaVYIXlcMVRSxCqWOB6Acmm2lyl5Zw3MIcRzIHUSIVYAjPIPIPsaAJaKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCje6NY6hMst1DmVRtEiOyNj0ypGRTo9IsItPexS2QWz53ocnd7k9SfeodS8QafpNwkF3JM07qXENvbyTuFH8RVFJA9zxTm17S00Yas99Ctiy7hOWwD7euc8Y654paWDqFtoWnWc0Utvb7ZIs7HLsxGRg8k88evSox4b0oBALX5UOQnmNtJznJGcN+Oat6fqFtqunQX1hJ5ttOm+N9pXcPoQCPxpbe/trq5uoLeTfLaOI5l2kbGKhgOevBB4p9Q6DhaQi8N2ExOYxGWyfug5xjp1qI6VZmwlsjD/o8rFnTceSTk85z1q3RQBAllbx3Es6x/vJUVHJJO4DOBjp3NQR6LYRWMtklv8A6NKctEzMR+GTx+FXqKAKMmj2M1nFbSRM0cJzGfMbch9mzn9adDpNjBaS2yW6mKbJlDksX+pPJq5RQBnwaFp1tJFJFAd8Lbo2aRmK8EdSemCeOlaFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFV7ewtrS4nnt4gklw26VgT8xqwTgZPArGtPFmjXt7HbW9y5aZikMj28iRTMOoSQqFc8HoT0o6gXotKsoY7mOO3UJdMXmUkkOT161DDoOnQSROkLF4W3Rs8rsUOMcZPTnp0rRooAq/2ZZ/ZZ7YwAw3DM8iEk7i3U1La20VnbJBAGEacKGYsfzPNS0UAUjo9iZrmTyMNdKUmw7AOD14zjPv1qVLG2juIpkjxJDF5KHceE44/QVYooAq/2bafZrm38r91dMzTLuPzFuvfj8KZcaRZXSQrLCcwrtjZHZGUem4EHFXaiu7qGxs5ru6fZBBG0kj4J2qBknA56CgN2JaWdvY24gtIxHGCTgc5PqSeSamqO3njuraK4gbdFKgdGwRkEZB5qSgSs1oFFFFAwooooAKKKKACiiigAqrf6ba6pbrDfReZGrBwA5XBHfII9atVXv7+20yyku76ZYYIxlnPPsAAOSSeAByaAKtp4f02xd3tYHRnQox85zwevU8fWpxpdmsNtGsIVbQgw7WI2HGOuefx61Dpmvafq8ssVnJIJoQGeGeB4ZFB6Ha4BwfXGK0aAM6fQdNubh5prclpDmQLIyq5/wBpQcH8RUt5pNlfeWbiH5ohhGRyjKPQFSDj2q5RQBSbRtPfTf7Pa1T7L12ZPX1z1z79aS00awsrgT20GyUR+XvLsSVznnJ557nmr1FAFBND0+OGSFLfbFJIJGQO2NwOQQM8c9hTrzR7K/mEtzETIF270kZGK+hKkZFXaKAKo02zWO2jWBVS1bfCqkgIcEZ469T1qQWcAvjeBP35j8svk/dznGOnWmXmo2untbC8l8s3UywQ/KTucgkDgcdDyeKs0B5Fa+0+11GJY7yLeEbcpDFSp9QRyKa+mWkn2nfFn7VGI5vnPzqAQB146npVuigCB7K3d7d2jy1scxHcfl4x+PHrTDptm0tzI8Cs12oWbcSQ4AwODxVqigCjaaNY2M4mt4W8wLtVnkZyo9BuJx+FXqKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKxrjxbo1rfPaz3ThopBFJKLeQwxueitKF2KeRwT3o8gNmsuXw3pU0zySWvMjbnVZGVWPqVBwfyrUzWLB4v0W5vEt4rpz5khijmNvIIZH6bVlK7GOeODzR1DoX7vSrK9jiSeAYh/wBWUYoU+hXBFImkWEentYrbJ9nfJZGydx9STyT71Ru/FulWN3JbXBvfMjOG8vTriRc+zKhB/A04+KtHGk22pC5d7e7bbbhIJGklPOQsYXeeh7UdA6luz0iysZGkt4j5jrtLvIztj0yxJA9qmhsba3sRZxRAW4Ur5bfMMHtz1qjF4l0ybTZ76KWZord9kyC2lMsbccGLbvB5HbpzUFt4x0a7v7eyjluknuWKRLNYTxByATjc6AdAT1o30DzLlroen2dws0EBDoCE3yM4TP8AdBJA/CtCs238Q6Vda5Lo9tepNfQxmSSJATtAIBy2MZBI4znnpWlR0AKKKKAI1/4+pP8AcX+bVJUa/wDH1J/uL/NqkoAKKKKAOa8VLqBurIomoyaXtk+1Lpj7Z9/Gw8ENt+9kKc5xVOPUiYfD62GqXV1E+qPBK06lJdojkPlyAgHKkDqMnAJrf1PRv7QuIbiDULzT7iFWRZbZl5U4yCrqynoOcZHrVN/CNi+j/YTPdiT7R9r+2iUCfzv+em7GM9sYxjjGKF/X3/5D/r8DL8T3M5vfENqZX+zr4eaQRZ+UMTKCceuAKrG0u9C8I6frkOr3ctxDFbmWJ5cwSodqlBH0HB4I5yBkmttPB9oPtz3F9fXM1/ZmznmmkUsU+bkYXAPzHoMe3XKReD7WP7LDJf301haMrw2EjqYlZfuk4XcQCMgFiB6cCiOn9eb/AMwlrt/Wi/yM1ra71XVPEok1a/t47KZfsyW0xTyz5CNn3GT908cnINV7Se//ALH8OeIZNTu3ub+W3S5hMn7h1lGCBH0XGRgjnjkmusg0e3gm1KVHkLak4eXJGFIQJ8vHHCjrnmq8fhy0j0XTdMWSfydNeJ4WLDcxj+7u4wffAFC0t8v+CKWq08/+AYbz6xdaPqv2GS6maLWHR1gcCb7OCNyxluAcdOnfHNOsrieTRdXtfD19qL6hHEGitNUBE1uxB5DSDLA4OCSVyOtbEnhq2a1uIorq7gea8N4JopAHjkPpxgj2YEetMi8LW4hvftl7e3lxeosct1LIEkCrkqF2BQuCSeB1POaS+Gz7fog638/1f6GNp95HAL2JL3Wra7NjJIbLVNzMWA/1iOcjjoQjY5HAp9tPeay2haXJfXEEUulC8uZYZCkszYRQu8cgZYkkc9Oa1YfC0f2hrjUNSvtRm8h7eN7lox5SPjdtCIoycDkgnipJ/DNtJZ6fHb3V1aT6dGIre7hZfMVcAEHKlWBwMgrjjtTW+v8AW/8Amhen9bf8E5vVr3UdK0/xDpcGo3EjWkVvPa3MjbpIhI5XYzdWwUJyecHrWnLBc6H4o0fy9SvbmPUZJIbmO5l3qSImcOo6IcrjC4HPSr3/AAilm2l3lnPcXU8l66vcXUjqZZCpGO20AYxgACtC80uG+v7C7laQSWErSxBSMEsjIc8dMMemOaa3DuZ/ie7uYo9PsrOdrZ9RvFtmuEA3RLtZmK543EJgHtnNN/sfU9Mtr3+yNUnuDJbMIIb5zKUn/hYOxzj1U5HTGKmk8N28+kvYXN3ezhpzcRzyT5lhfduBRscBT0HpxzTIPDEI+0vqF/fajNcQG3MtxIqskZ6hfLVQvrkDPA5qej/rp/X5laXX9dTI8PTJHqsNvd3muWt7NEwltNTJZJ2AGWjflARycIRwelRLqV+2hR6D9rl/tb+0f7PefcfM8sHeZM+phwc+prcs/DS2+oW95eanf6k9qCLZbpo9sWRgkbEXLY4y2TyfWph4esl8UNrwMv2toPJ2bv3fX72MfewAM+gquv8AX9eXzJ6f1/XmaoGBiiiikMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAMjVruy0MyX623nahebYIoo/8AWXLDO1B7DJJPQDJNRaPoS2OixpqKQz3ayy3bNtyscshZm2Z6Y3EA9cfWm6l4VXUdcXVU1jUrO4SLyUW3aIqi5ycB42wT3I64FadhYvZWRt5r66viST51yU389vlVRj8KW6Y+pkeAP+RA0f8A69h/Ws6z0htV8SeJg+oXlrEt3FtW0mMTbvIj+YsOT246dcg102kaXDouj22m2rSPDbIERpCCxHvgAfpS2emQ2V7f3UTSF76VZZAxGAQipxx0wo9actZNgtjktO1XUNcsfD+nzXssJu4p3urmEhJJRCwTAI+7uJBJHPHGM0msXV9oNn4h06DUbmZItJN7ayyyl5YG+ZSN/UjIBBOT15rdXwlZR6TaWVvcXUL2UjyW10jqJY2YknttIO4jBBGKmtfDVpFBereSz6jLfp5VzPdMC0iYICfKAFUZPAA6k0a7/wBf1/XUFbQrazd3EN14cWKZ0FxfBJQrY3r5MhwfUZAP4VR8OW99fR3+oy6ndSzxXt3FbQNKRCoEjKoZR978emBjFXLXwbbwXFjNPqepXjafL5lsLmZWCDaV24CjIwep5469a07HR7axsLi0jaR4riWWV97c5kYswBGMDJOO9J9fn+n/AAQWyXp+v/AOY0C4kt9TsY9Xu9atNTlBSaG+y9vdPtJIjYZReRkBSDgdK3/Et1Ha6RiS/uLIzSpGr2sXmTOSfuIuDyQDzjjr2qC18KxwXVpLdapqF/HZNutYLl0KxNgqDlVDMQCQCxP581f1fSYdYtY4pZZoJIZVmhngYB4nHRhkEdCRggjmm9RLQ5O01i70fUdSjjj1Q2sWlyXsceqSB3Loedp3FsHI4b04pur2mo6d4KGsRa9fNfSrC8zPMfLcO65CJ0Trxtx75ro7Pw1Da6k+o3F3d6hdvbG3drlkw6Eg42qoA6dgByc5PNcheaGdQ0uPSbLT9cgkM0W22u5CbWzCyKzEPnDAAEDBbrwB2I7q/wDWr/SwmtH/AF0X/BOgign8Sa1q4uNRvbSDT7gW0EVnOYsHy1cuxH3iS+MHjA6VoeFb+51DQw19IJbiCea2klAAEpjkZN2BwM7c/Wi98NpcahNeWWo32mzXAC3H2RkxNgYBIdWwccbhg4+grQ0+wt9L0+Kzsk2QxDCgkknuSSeSScknuaFt/X3/ANfoN7lmiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDF8ZPLH4I1l7ckSLZSlSpwR8prP8URwReA4Ps4UeS9qbXb2YSJsx/L8a6iSNJY2jkUMjgqykcEHtWDa+D7W2mtt9/f3FpZuHtbKaVTFCR93ooZtvbcxxQt/u/D+tAe33/iamrC+OjXg0kqL4wv8AZy/QPj5c5965nRLyO0v9s9zrcF2bd2ksdUy6zMoBLI/K5HPCHGD0rq720iv7Ga0n3+XMhRijlWAPoRyDWZZeG1t9QhvL3U77UpbdGSAXbR7YgwwSAiLkkcZOTS11sPscdaaprN3otvrFrb+IZtUmRZ1UBfsjg4PlhN2NuDgNjd3zXRiKfxF4h1SGe/vLO205o4YobSYxFmaMOXYjk/eAA6cHIOasR+EYYdsMOqalHp6yB109JVEQ5ztDbd4XP8O7HbpxVi/8Opdai99Z6je6bcSoI5mtGTEqjpuDqwyMnBGD703bp/X9f8ERm3KajLq2l+HrrVJirWs1xc3VuPJlnCMqquR937+SVxnHGM4rM1i81HR7LXtKttRuJPs9vb3FrcSvukiEkhUoW6sMrkE84JGa6KTwrZfYrKG0murSax3eRdQyAyru+9ksCG3dSGByeaT/AIRS0fTby1ubm6uJb5la4u5XXzX2kFRwu0AY6AAcn1o/r+v6/MHtp/X9f1sUZoLnQ/FGj+XqV7dR6jJJDcxXMu9SREzh1HRDlMYXA56VkzWl1rnw/wBQ12fVruO4urSeRYvNxBHHhgIzH908DBY85yc12l5pcN9fWF3K0gksJWliCkYJZGQ546YY9Mc1kzeDLSWK5tVv7+LTrou0lgkieVluuMruAyc7d23PbHFKSurIqLtJMy7kX39m6EWTU30n+z0Ew0p9sok2rtLbSHK4zwvfqK6Pw7cxXWiQvb38t+gLJ506bJOGI2uMAhh0OQDxzUM/hxWW0+xanf2EtrALdZIHQ70GOGV1ZSeOuAauaTpVvo9gLW1Mjgu0jyStueR2OWZj6kmrbu3/AF1M4q0Uv62LtFFFSUFFFFABRRRQAUUUUAFc54o+bVfDccn+pbU8uD0JEUhX/wAeAP1Aro6p6rpVtrFg1rd7wu4OjxtteN1OVZT2INHW4d0ZWpBV8faG0X+te2ukkx3jAQ8/8C2/nUnioakbG2/s1bp4RODeJZOFnaLafuEkc7tucEHGcVPpmgR6ffSX097d6hePGIhPdspKJnO1QiqoGeTxk96n1XSl1SOHF3c2c0D+ZFPbOAynBHQgqwwTwQRR0X9dQW5ylxrh07wtef2RfajPP9rhtxFexE3Np5jKuMSYLnklS2QSepFSaddahZaxAbW015rJ45Ptf9qMHVSFLK6tuJByMYHHzdBituLwrZfYr2C9mub6S+KtPcTuBISv3MFAoXbjI2gYPNSWGgG0vVurrVtQ1F40KRLdOgVAevCKoY+7ZNH9fgBk6Jp2oarothrn9t3kd/dpHcspbdbqrYYx+VwMYOM/e75qSC1uPEmqaq9xqd7aRWV0bW2is5jEF2opLtj7xJbocjAHFWI/B1tHsgXUNQ/s1JRKuneYvkgg7gudu/bnnbux2xjip7zw0k9/Pd2WpX2myXIAuRaOgWbAwCQythscZXB/IUO19P62/r8Q/r+v68jnrfUNS1lvD0EmoTQNJNeW93Lb/J5/lEruHYZK5z2ycYpbrUb7w8viCxtr2e4W3jtXtJbt/NeEzsYzljywBG7nPpXTQ+HrG2k01rYPEumq6wIGyDvGDuzyT3znrRceHrG7utRmuleUajBHbzxsfl2puxjHIPznnPYYxQ+oLzOa13RH0288OuuqXlyDq0PmpeTeZvba3zLn7p68Lge3FLqst1a6tfT63dazYwpKGs72zy9rFHgffRc85zkuMehFa6+EIXms5b7VdRvmsZlmtvtEifuyvb5UG7PcnJ9+Tl174UjvZLpTqupQ2d4xa4s45E8uTIwwyVLqCOoVhQv6/D/IOuvZfr/mbyMHjVlYMCMhh0PvS02NFijWONQqIAqgdgKdQJbBRRRQMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAQ52nHXFcj4figl+FRF4FKy2s7XW7uxLFyffOa6+uduPBlnPJOgvr6GwupDLcafHIohkYnLfw7gGPUBgDUtXTXcadncsaPHPf+BLKO5cx3FxpyK791Zoxk/rXJ63PrEHw5l0c6C9tNaW6R/avNjNv8hG1o8NuLEgYBUYJ56V3P8AZif2m14Z7go1uLf7KZP3AGc7tn97tn0rMtvB9rbvBG1/fTWFq4kt9PlkUwxEHK9FDEKcYDMQMCtG7yb7/wDBJSskuw7xPdz/AGCDSrFyl9qjeRG46xJjMkn/AAFc49ytZ2s272Os6BZeG4IjfWkMvlRTkrCtuAqvuYZIOdmCAe/GK6IaVB/bh1V2kefyPIRWI2xrnJ2jGck4zz/CKh1XQ4dUnguVubmyvLcMIrq1YB1VsblIYFWBwOCD0qf6/wAv682My/DLXA8Q6yusJHFqsghkdICWh8nBVCpOCeQ2cgHPbGKk0z/id+KLrVm+a0sN1nZ+jPn99J+YCD/db1q7YeH4rBbtxeXc95eLtlvZnUy4AIXGFCqBk4AXGTV3TdPg0rTLexs1Iht0CJuOScdye5PUmgDnltoLP4mWMFrCkMS6PNhI1Cgfvo+wrqqotpMD+II9XLyfaI7ZrYLkbNrMGJxjOcqO9XqF8KXr+bYPdv8ArYKKKKAI1/4+pP8AcX+bVJUa/wDH1J/uL/NqkoAKKKKACiue1jxnYaJdtBd212219m+NUKlgqsQMsDwHXt3rO/4Wdo3/AD7X/wD37T/4uuaWKoxfLKWpm6sE7NnZUVxv/CztG/59r/8A79p/8XR/ws7Rv+fa/wD+/af/ABdL65h/5kL21PudlRXG/wDCztG/59r/AP79p/8AF0f8LO0b/n2v/wDv2n/xdH1zD/zIPbU+52VFcb/ws7Rv+fa//wC/af8AxdH/AAs7Rv8An2v/APv2n/xdH1zD/wAyD21PudlRXG/8LO0b/n2v/wDv2n/xdH/CztG/59r/AP79p/8AF0fXMP8AzIPbU+52VFcb/wALO0b/AJ9r/wD79p/8XR/ws7Rv+fa//wC/af8AxdH1zD/zIPbU+52VFcb/AMLO0b/n2v8A/v2n/wAXR/ws7Rv+fa//AO/af/F0fXMP/Mg9tT7nZUVxv/CztG/59r//AL9p/wDF0f8ACztG/wCfa/8A+/af/F0fXMP/ADIPbU+52VFcb/ws7Rv+fa//AO/af/F0f8LO0b/n2v8A/v2n/wAXR9cw/wDMg9tT7nZUVxv/AAs7Rv8An2v/APv2n/xdH/CztG/59r//AL9p/wDF0fXMP/Mg9tT7nZUVxv8Aws7Rv+fa/wD+/af/ABdH/CztG/59r/8A79p/8XR9cw/8yD21PudlRXG/8LO0b/n2v/8Av2n/AMXR/wALO0b/AJ9r/wD79p/8XR9cw/8AMg9tT7nZUVxv/CztG/59r/8A79p/8XR/ws7Rv+fa/wD+/af/ABdH1zD/AMyD21PudlRXG/8ACztG/wCfa/8A+/af/F0f8LO0b/n2v/8Av2n/AMXR9cw/8yD21PudlRXG/wDCztG/59r/AP79p/8AF0f8LO0b/n2v/wDv2n/xdH1zD/zIPbU+52VFcb/ws7Rv+fa//wC/af8AxdH/AAs7Rv8An2v/APv2n/xdH1zD/wAyD21PudlRXG/8LO0b/n2v/wDv2n/xdH/CztG/59r/AP79p/8AF0fXMP8AzIPbU+52VFcb/wALO0b/AJ9r/wD79p/8XR/ws7Rv+fa//wC/af8AxdH1zD/zIPbU+52VFcb/AMLO0b/n2v8A/v2n/wAXR/ws7Rv+fa//AO/af/F0fXMP/Mg9tT7nZUVxv/CztG/59r//AL9p/wDF0f8ACztG/wCfa/8A+/af/F0fXMP/ADIPbU+52VFcb/ws7Rv+fa//AO/af/F0f8LO0b/n2v8A/v2n/wAXR9cw/wDMg9tT7nZUVxv/AAs7Rv8An2v/APv2n/xdH/CztG/59r//AL9p/wDF0fXMP/Mg9tT7nZUVxv8Aws7Rv+fa/wD+/af/ABdH/CztG/59r/8A79p/8XR9cw/8yD21PudlRXG/8LO0b/n2v/8Av2n/AMXR/wALO0b/AJ9r/wD79p/8XR9cw/8AMg9tT7nZUVxv/CztG/59r/8A79p/8XR/ws7Rv+fa/wD+/af/ABdH1zD/AMyD21PudlRXG/8ACztG/wCfa/8A+/af/F0f8LO0b/n2v/8Av2n/AMXR9cw/8yD21PudlRXG/wDCztG/59r/AP79p/8AF0f8LO0b/n2v/wDv2n/xdH1zD/zIPbU+52VFcb/ws7Rv+fa//wC/af8AxdH/AAs7Rv8An2v/APv2n/xdH1zD/wAyD21PudlRXG/8LO0b/n2v/wDv2n/xdH/CztG/59r/AP79p/8AF0fXMP8AzIPbU+52VFcb/wALO0b/AJ9r/wD79p/8XR/ws7Rv+fa//wC/af8AxdH1zD/zIPbU+52VFcb/AMLO0b/n2v8A/v2n/wAXR/ws7Rv+fa//AO/af/F0fXMP/Mg9tT7nZUVxv/CztG/59r//AL9p/wDF0f8ACztG/wCfa/8A+/af/F0fXMP/ADIPbU+52VFcb/ws7Rv+fa//AO/af/F0f8LO0b/n2v8A/v2n/wAXR9cw/wDMg9tT7nZUVxv/AAs7Rv8An2v/APv2n/xdH/CztG/59r//AL9p/wDF0fXMP/Mg9tT7nZUVxv8Aws7Rv+fa/wD+/af/ABdH/CztG/59r/8A79p/8XR9cw/8yD21PudlRXG/8LO0b/n2v/8Av2n/AMXR/wALO0b/AJ9r/wD79p/8XR9cw/8AMg9tT7nZUVxv/CztG/59r/8A79p/8XR/ws7Rv+fa/wD+/af/ABdH1zD/AMyD21PudlRXG/8ACztG/wCfa/8A+/af/F0f8LO0b/n2v/8Av2n/AMXR9cw/8yD21PudlRXG/wDCztG/59r/AP79p/8AF0f8LO0b/n2v/wDv2n/xdH1zD/zIPbU+52VFcb/ws7Rv+fa//wC/af8AxdH/AAs7Rv8An2v/APv2n/xdH1zD/wAyD21PudlRXG/8LO0b/n2v/wDv2n/xdH/CztG/59r/AP79p/8AF0fXMP8AzIPbU+52VFcb/wALO0b/AJ9r/wD79p/8XR/ws7Rv+fa//wC/af8AxdH1zD/zIPbU+52VFcb/AMLO0b/n2v8A/v2n/wAXR/ws7Rv+fa//AO/af/F0fXMP/Mg9tT7nZUVxv/CztG/59r//AL9p/wDF0f8ACztG/wCfa/8A+/af/F0fXMP/ADIPbU+52VFcb/ws7Rv+fa//AO/af/F0f8LO0b/n2v8A/v2n/wAXR9cw/wDMg9tT7nZUVxv/AAs7Rv8An2v/APv2n/xdH/CztG/59r//AL9p/wDF0fXMP/Mg9tT7nZUVxv8Aws7Rv+fa/wD+/af/ABdH/CztG/59r/8A79p/8XR9cw/8yD21PudlRXG/8LO0b/n2v/8Av2n/AMXR/wALO0b/AJ9r/wD79p/8XR9cw/8AMg9tT7nZUVxv/CztG/59r/8A79p/8XR/ws7Rv+fa/wD+/af/ABdH1zD/AMyD21PudlRXG/8ACztG/wCfa/8A+/af/F0f8LO0b/n2v/8Av2n/AMXR9cw/8yD21PudlRXG/wDCztG/59r/AP79p/8AF0f8LO0b/n2v/wDv2n/xdH1zD/zIPbU+52VFcb/ws7Rv+fa//wC/af8AxdH/AAs7Rv8An2v/APv2n/xdH1zD/wAyD21PudlRXG/8LO0b/n2v/wDv2n/xdH/CztG/59r/AP79p/8AF0fXMP8AzIPbU+52VFcb/wALO0b/AJ9r/wD79p/8XR/ws7Rv+fa//wC/af8AxdH1zD/zIPbU+52VFcb/AMLO0b/n2v8A/v2n/wAXR/ws7Rv+fa//AO/af/F0fXMP/Mg9tT7nZUVxv/CztG/59r//AL9p/wDF0f8ACztG/wCfa/8A+/af/F0fXMP/ADIPbU+52VFcb/ws7Rv+fa//AO/af/F0f8LO0b/n2v8A/v2n/wAXR9cw/wDMg9tT7nZUVxv/AAs7Rv8An2v/APv2n/xdH/CztG/59r//AL9p/wDF0fXMP/Mg9tT7nZUVxv8Aws7Rv+fa/wD+/af/ABdH/CztG/59r/8A79p/8XR9cw/8yD21PudlRXG/8LO0b/n2v/8Av2n/AMXR/wALO0b/AJ9r/wD79p/8XR9cw/8AMg9tT7nZUVxv/CztG/59r/8A79p/8XR/ws7Rv+fa/wD+/af/ABdH1zD/AMyD21PudlRXG/8ACztG/wCfa/8A+/af/F0f8LO0b/n2v/8Av2n/AMXR9cw/8yD21PudlRXG/wDCztG/59r/AP79p/8AF0f8LO0b/n2v/wDv2n/xdH1zD/zIPbU+52VFcb/ws7Rv+fa//wC/af8AxdH/AAs7Rv8An2v/APv2n/xdH1zD/wAyD21PudlRXG/8LO0b/n2v/wDv2n/xdH/CztG/59r/AP79p/8AF0fXMP8AzIPbU+52VFcb/wALO0b/AJ9r/wD79p/8XR/ws7Rv+fa//wC/af8AxdH1zD/zIPbU+52VFcb/AMLO0b/n2v8A/v2n/wAXR/ws7Rv+fa//AO/af/F0fXMP/Mg9tT7nZUVxv/CztG/59r//AL9p/wDF0f8ACztG/wCfa/8A+/af/F0fXMP/ADIPbU+52VFcb/ws7Rv+fa//AO/af/F0f8LO0b/n2v8A/v2n/wAXR9cw/wDMg9tT7nZUVxv/AAs7Rv8An2v/APv2n/xdH/CztG/59r//AL9p/wDF0fXMP/Mg9tT7nZUVydn8RdJvr6C0it70STyLGpZEwCxwM/N05rrK2p1YVVeDuXGcZfCwooorQojX/j6k/wBxf5tUlRr/AMfUn+4v82qSgAooooA8s+IX/IQb/r8k/wDRFtXGV2fxC/5CDf8AX5J/6Itq4yvksZ/vEvU8mt/EYUVkyX9/eahPbaStusdsQss1wCQWIztUDHTuamsb25IuI9UhWCS3wWlXPlOuM7gT+o7Vg4NK5nys0KKpWmsWF9N5Vrcq8mMhcEbh6jI5HuKZJr2mRSeXJeIrbzGQQeGBxzxxz3PFHJK9rByvsaFFU4NXsLm9a0guUedc5UZ5x1weh/Coj4g0sFM3iDecAkHAOSOTjjkHrRyS7ByvsaNFUTfSDX0sQE8prVpi2OchgPy5oi1rTproW8V0jSE7V64Y+gboT7A0ckuwcrL1FZcGvW0+tzacDh48BW5+ZucjpxjFTNrenJd/Zmu0Em7Yeu0N6FugPtmj2c9rBytF6iiioEFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAaPh/8A5GbS/wDr8i/9DFe614V4f/5GbS/+vyL/ANDFe617+VfBL1O/C/Cwooor2DsI1/4+pP8AcX+bVJUa/wDH1J/uL/NqkoAKKKKAPLPiF/yEG/6/JP8A0RbVxldn8Qv+Qg3/AF+Sf+iLauMr5LGf7xL1PJrfxGc/b3kGg6jfw6ixhiuZzcQzMCVbcBlc9iCOlJqV3NrWhXxs7aQ26lDG+CDcKCC2FxnGOPeuh69aKz9orqVtdPwJ5le5z1zfWurX+lppUgleGYSuUH+qj2kEH0zwMVXKr/wiuunaMm4uCeOvNdTRT9qkrJBz2t5f8Ewr1Quq+H9oAwzgY7Dy6zLLULGHwnPaTDM8xmCw7TumJZgMevpntiuwqrp1iunWKWyOXCszbiOfmYn+tNVFy2f9bjUkkvL/AIJhG2uRew22cXX9itHnP8eVH86rW7QXGn2djJqUvmK0Y+yJbqHjZSDzxkYI612FFHtvIXPoYscyQeLbuOV/Le5gjEO4ffI3Zx9KxLcxporabf6lJFKSY5LRbdS7MW6jjJz1zXa0Uo1Uunb8PkHONiXZCikkkKBk9TTqKKwMwooooGFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBo+H/wDkZtL/AOvyL/0MV7rXhXh//kZtL/6/Iv8A0MV7rXv5V8EvU78L8LCiiivYOwjX/j6k/wBxf5tUlRr/AMfUn+4v82qSgAooooA4nxT4P1PXL93tZLRIvOMqmSRgxzHEmCApxzH696wv+FY6z/z82H/fx/8A4ivU6K4amAo1JOUt2YSoQk7s8s/4VjrP/PzYf9/H/wDiKP8AhWOs/wDPzYf9/H/+Ir1Oio/s3D+f3k/VqZ5Z/wAKx1n/AJ+bD/v4/wD8RR/wrHWf+fmw/wC/j/8AxFep0Uf2bh/P7w+rUzyz/hWOs/8APzYf9/H/APiKP+FY6z/z82H/AH8f/wCIr1Oij+zcP5/eH1ameWf8Kx1n/n5sP+/j/wDxFH/CsdZ/5+bD/v4//wARXqdFH9m4fz+8Pq1M8s/4VjrP/PzYf9/H/wDiKP8AhWOs/wDPzYf9/H/+Ir1Oij+zcP5/eH1ameWf8Kx1n/n5sP8Av4//AMRR/wAKx1n/AJ+bD/v4/wD8RXqdFH9m4fz+8Pq1M8s/4VjrP/PzYf8Afx//AIij/hWOs/8APzYf9/H/APiK9Too/s3D+f3h9Wpnln/CsdZ/5+bD/v4//wARR/wrHWf+fmw/7+P/APEV6nRR/ZuH8/vD6tTPLP8AhWOs/wDPzYf9/H/+Io/4VjrP/PzYf9/H/wDiK9Too/s3D+f3h9Wpnln/AArHWf8An5sP+/j/APxFH/CsdZ/5+bD/AL+P/wDEV6nRR/ZuH8/vD6tTPLP+FY6z/wA/Nh/38f8A+Io/4VjrP/PzYf8Afx//AIivU6KP7Nw/n94fVqZ5Z/wrHWf+fmw/7+P/APEUf8Kx1n/n5sP+/j//ABFep0Uf2bh/P7w+rUzyz/hWOs/8/Nh/38f/AOIo/wCFY6z/AM/Nh/38f/4ivU6KP7Nw/n94fVqZ5Z/wrHWf+fmw/wC/j/8AxFH/AArHWf8An5sP+/j/APxFep0Uf2bh/P7w+rUzyz/hWOs/8/Nh/wB/H/8AiKP+FY6z/wA/Nh/38f8A+Ir1Oij+zcP5/eH1ameWf8Kx1n/n5sP+/j//ABFH/CsdZ/5+bD/v4/8A8RXqdFH9m4fz+8Pq1M8s/wCFY6z/AM/Nh/38f/4ij/hWOs/8/Nh/38f/AOIr1Oij+zcP5/eH1ameWf8ACsdZ/wCfmw/7+P8A/EUf8Kx1n/n5sP8Av4//AMRXqdFH9m4fz+8Pq1M8s/4VjrP/AD82H/fx/wD4ij/hWOs/8/Nh/wB/H/8AiK9Too/s3D+f3h9Wpnln/CsdZ/5+bD/v4/8A8RR/wrHWf+fmw/7+P/8AEV6nRR/ZuH8/vD6tTPLP+FY6z/z82H/fx/8A4ij/AIVjrP8Az82H/fx//iK9Too/s3D+f3h9Wpnln/CsdZ/5+bD/AL+P/wDEUf8ACsdZ/wCfmw/7+P8A/EV6nRR/ZuH8/vD6tTPLP+FY6z/z82H/AH8f/wCIo/4VjrP/AD82H/fx/wD4ivU6KP7Nw/n94fVqZ5Z/wrHWf+fmw/7+P/8AEUf8Kx1n/n5sP+/j/wDxFep0Uf2bh/P7w+rUzyz/AIVjrP8Az82H/fx//iKP+FY6z/z82H/fx/8A4ivU6KP7Nw/n94fVqZ5Z/wAKx1n/AJ+bD/v4/wD8RR/wrHWf+fmw/wC/j/8AxFep0Uf2bh/P7w+rUzyz/hWOs/8APzYf9/H/APiKP+FY6z/z82H/AH8f/wCIr1Oij+zcP5/eH1ameWf8Kx1n/n5sP+/j/wDxFH/CsdZ/5+bD/v4//wARXqdFH9m4fz+8Pq1M8s/4VjrP/PzYf9/H/wDiKP8AhWOs/wDPzYf9/H/+Ir1Oij+zcP5/eH1ameWf8Kx1n/n5sP8Av4//AMRR/wAKx1n/AJ+bD/v4/wD8RXqdFH9m4fz+8Pq1M8s/4VjrP/PzYf8Afx//AIij/hWOs/8APzYf9/H/APiK9Too/s3D+f3h9Wpnln/CsdZ/5+bD/v4//wARR/wrHWf+fmw/7+P/APEV6nRR/ZuH8/vD6tTPLP8AhWOs/wDPzYf9/H/+Io/4VjrP/PzYf9/H/wDiK9Too/s3D+f3h9Wpnln/AArHWf8An5sP+/j/APxFH/CsdZ/5+bD/AL+P/wDEV6nRR/ZuH8/vD6tTPLP+FY6z/wA/Nh/38f8A+Io/4VjrP/PzYf8Afx//AIivU6KP7Nw/n94fVqZ5Z/wrHWf+fmw/7+P/APEUf8Kx1n/n5sP+/j//ABFep0Uf2bh/P7w+rUzyz/hWOs/8/Nh/38f/AOIo/wCFY6z/AM/Nh/38f/4ivU6KP7Nw/n94fVqZ5Z/wrHWf+fmw/wC/j/8AxFH/AArHWf8An5sP+/j/APxFep0Uf2bh/P7w+rUzyz/hWOs/8/Nh/wB/H/8AiKP+FY6z/wA/Nh/38f8A+Ir1Oij+zcP5/eH1ameWf8Kx1n/n5sP+/j//ABFH/CsdZ/5+bD/v4/8A8RXqdFH9m4fz+8Pq1M8s/wCFY6z/AM/Nh/38f/4ij/hWOs/8/Nh/38f/AOIr1Oij+zcP5/eH1ameWf8ACsdZ/wCfmw/7+P8A/EUf8Kx1n/n5sP8Av4//AMRXqdFH9m4fz+8Pq1M8s/4VjrP/AD82H/fx/wD4ij/hWOs/8/Nh/wB/H/8AiK9Too/s3D+f3h9Wpnln/CsdZ/5+bD/v4/8A8RR/wrHWf+fmw/7+P/8AEV6nRR/ZuH8/vD6tTPLP+FY6z/z82H/fx/8A4ij/AIVjrP8Az82H/fx//iK9Too/s3D+f3h9Wpnln/CsdZ/5+bD/AL+P/wDEUf8ACsdZ/wCfmw/7+P8A/EV6nRR/ZuH8/vD6tTPLP+FY6z/z82H/AH8f/wCIo/4VjrP/AD82H/fx/wD4ivU6KP7Nw/n94fVqZ5Z/wrHWf+fmw/7+P/8AEUf8Kx1n/n5sP+/j/wDxFep0Uf2bh/P7w+rUzyz/AIVjrP8Az82H/fx//iKP+FY6z/z82H/fx/8A4ivU6KP7Nw/n94fVqZ5Z/wAKx1n/AJ+bD/v4/wD8RR/wrHWf+fmw/wC/j/8AxFep0Uf2bh/P7w+rUzyz/hWOs/8APzYf9/H/APiKP+FY6z/z82H/AH8f/wCIr1Oij+zcP5/eH1ameWf8Kx1n/n5sP+/j/wDxFH/CsdZ/5+bD/v4//wARXqdFH9m4fz+8Pq1M8s/4VjrP/PzYf9/H/wDiKP8AhWOs/wDPzYf9/H/+Ir1Oij+zcP5/eH1ameWf8Kx1n/n5sP8Av4//AMRR/wAKx1n/AJ+bD/v4/wD8RXqdFH9m4fz+8Pq1M8s/4VjrP/PzYf8Afx//AIij/hWOs/8APzYf9/H/APiK9Too/s3D+f3h9Wpnln/CsdZ/5+bD/v4//wARR/wrHWf+fmw/7+P/APEV6nRR/ZuH8/vD6tTPLP8AhWOs/wDPzYf9/H/+Io/4VjrP/PzYf9/H/wDiK9Too/s3D+f3h9Wpnln/AArHWf8An5sP+/j/APxFH/CsdZ/5+bD/AL+P/wDEV6nRR/ZuH8/vD6tTPLP+FY6z/wA/Nh/38f8A+Io/4VjrP/PzYf8Afx//AIivU6KP7Nw/n94fVqZ5Z/wrHWf+fmw/7+P/APEUf8Kx1n/n5sP+/j//ABFep0Uf2bh/P7w+rUzyz/hWOs/8/Nh/38f/AOIo/wCFY6z/AM/Nh/38f/4ivU6KP7Nw/n94fVqZ5Z/wrHWf+fmw/wC/j/8AxFH/AArHWf8An5sP+/j/APxFep0Uf2bh/P7w+rUzyz/hWOs/8/Nh/wB/H/8AiKP+FY6z/wA/Nh/38f8A+Ir1Oij+zcP5/eH1ameWf8Kx1n/n5sP+/j//ABFH/CsdZ/5+bD/v4/8A8RXqdFH9m4fz+8Pq1M8s/wCFY6z/AM/Nh/38f/4ij/hWOs/8/Nh/38f/AOIr1Oij+zcP5/eH1ameWf8ACsdZ/wCfmw/7+P8A/EUf8Kx1n/n5sP8Av4//AMRXqdFH9m4fz+8Pq1M8s/4VjrP/AD82H/fx/wD4ij/hWOs/8/Nh/wB/H/8AiK9Too/s3D+f3h9Wpnln/CsdZ/5+bD/v4/8A8RR/wrHWf+fmw/7+P/8AEV6nRR/ZuH8/vD6tTPLP+FY6z/z82H/fx/8A4ij/AIVjrP8Az82H/fx//iK9Too/s3D+f3h9Wpnm2l/DrVrHWLO7luLIxwTpIwV3yQrAnHy9eK9Joorqo4eFBNQ6msKcYK0Qooorc0P/2Q=="}},"execution_count":null}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}