Teacher&Student.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"Teacher&Student.ipynb","provenance":[],"collapsed_sections":[]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"},"accelerator":"GPU"},"cells":[{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"iwJzQrr6u_s9","outputId":"46f2e681-599f-4aed-db71-0d2481a2fb99"},"source":["from google.colab import drive\n","drive.mount('/content/drive')"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Mounted at /content/drive\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"RCL8vmU8vOf_","outputId":"2e24ae03-9560-4a47-fe1a-099303f8f4e5"},"source":["!ls"],"execution_count":null,"outputs":[{"output_type":"stream","text":["drive  sample_data\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"1nQN1RamvUkt"},"source":["import os\n","import cv2\n","from PIL import Image\n","import numpy as np\n","import scipy\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","plt.style.use('seaborn')\n","\n","from sklearn import metrics\n","from sklearn.model_selection import train_test_split\n","from sklearn.metrics import classification_report\n","from tqdm import tqdm\n","\n","import time\n","import timeit"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"c5LafAravWx_"},"source":["import keras\n","import tensorflow as tf\n","from keras import layers\n","from keras.models import Model\n","from keras.layers import Lambda, concatenate\n","from tensorflow.keras.utils import to_categorical\n","from keras.preprocessing.image import ImageDataGenerator\n","from keras.models import Sequential\n","from keras.layers import GlobalAveragePooling2D , Conv2D , MaxPooling2D\n","from keras.layers import  Dropout , BatchNormalization , Dense\n","from keras.optimizers import Adam\n","from tensorflow.keras.applications import ResNet50\n","from keras.callbacks import Callback , ReduceLROnPlateau , ModelCheckpoint\n","from sklearn.metrics import cohen_kappa_score, accuracy_score\n","from keras.losses import categorical_crossentropy as logloss\n","from keras.metrics import categorical_accuracy"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"ygz1SKZKvYwR","outputId":"9c8911d1-5124-43f9-bf71-300269ea931e"},"source":["benign_train = np.load('/content/drive/MyDrive/CSE465/Dataset/benign_train.npy')\n","malign_train = np.load('/content/drive/MyDrive/CSE465/Dataset/malign_train.npy')\n","benign_test = np.load('/content/drive/MyDrive/CSE465/Dataset/benign_test.npy')\n","malign_test = np.load('/content/drive/MyDrive/CSE465/Dataset/malign_test.npy')\n","print('Done Loaded :)')"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Done Loaded :)\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"VLjanYKivaqF","outputId":"971357ad-944b-416a-832c-bb28e9749c6b"},"source":["# Shape of our dataset\n","print(f'Benign Train:',benign_train.shape)\n","print(f'Malignant Train',malign_train.shape)\n","print(f'Benign Test:',benign_test.shape)\n","print(f'Malignant Test',malign_test.shape)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Benign Train: (3500, 224, 224, 3)\n","Malignant Train (3496, 224, 224, 3)\n","Benign Test: (1500, 224, 224, 3)\n","Malignant Test (1500, 224, 224, 3)\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"5DNk8wRPZgFl"},"source":["**Set to class 0 and class 1**"]},{"cell_type":"code","metadata":{"id":"IY14E6WpvjuZ"},"source":["benign_train_label = np.zeros(len(benign_train),dtype=float)\n","malign_train_label = np.ones(len(malign_train),dtype=float)\n","benign_test_label = np.zeros(len(benign_test),dtype=float)\n","malign_test_label = np.ones(len(malign_test),dtype=float) \n","\n","X_train = np.concatenate((benign_train, malign_train), axis = 0)\n","Y_train = np.concatenate((benign_train_label, malign_train_label), axis = 0)\n","X_test = np.concatenate((benign_test, malign_test), axis = 0)\n","Y_test = np.concatenate((benign_test_label, malign_test_label), axis = 0)\n","\n","s = np.arange(X_train.shape[0])\n","np.random.shuffle(s)\n","X_train = X_train[s]\n","Y_train = Y_train[s]\n","\n","s = np.arange(X_test.shape[0])\n","np.random.shuffle(s)\n","X_test = X_test[s]\n","Y_test = Y_test[s]\n","\n","Y_train = to_categorical(Y_train, num_classes= 2)\n","Y_test = to_categorical(Y_test, num_classes= 2)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"HMPa7P1XfuuN","outputId":"36fea5a1-d9ae-4d01-b7bb-3c0598cfb58a"},"source":["print(f'X train shape:',X_train.shape)\n","print(f'X test shape:',X_test.shape)\n","print(f'Y train shape:',Y_train.shape)\n","print(f'Y test shape:',Y_test.shape)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["X train shape: (6996, 224, 224, 3)\n","X test shape: (3000, 224, 224, 3)\n","Y train shape: (6996, 2)\n","Y test shape: (3000, 2)\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"18-dtZkWZfTc"},"source":["**Split**"]},{"cell_type":"code","metadata":{"id":"ZUpq1QB1vl-j"},"source":["x_train, x_val, y_train, y_val = train_test_split(X_train, Y_train, test_size=0.2, random_state=10)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"DyL-RqBfvnfm","outputId":"6169bfd0-8eb7-4dcd-ea28-6240099e75cc"},"source":["print(f'x train shape:',x_train.shape)\n","print(f'x val shape:',x_val.shape)\n","print(f'y train shape:',y_train.shape)\n","print(f'y val shape:',y_val.shape)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["x train shape: (5596, 224, 224, 3)\n","x val shape: (1400, 224, 224, 3)\n","y train shape: (5596, 2)\n","y val shape: (1400, 2)\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"o3O5-mfAvpmL","outputId":"456ecaf3-0f29-4cc1-a54b-88e9463f2a22"},"source":["# Teacher model with ResNet50\n","def build_model(backbone , lr = 1e-4):\n","  model = Sequential()\n","  model.add(backbone)\n","  model.add(layers.GlobalAveragePooling2D())\n","  model.add(layers.Dropout(0.5))\n","  model.add(layers.BatchNormalization())\n","  model.add(layers.Dense(2 , activation='softmax'))\n","  \n","  model.compile(\n","        loss='categorical_crossentropy',\n","        optimizer=Adam(learning_rate=1e-4),\n","        metrics=['accuracy']\n","    )\n","    \n","  return model\n","\n","resnet = ResNet50(\n","    weights = 'imagenet',\n","    include_top = False,\n","    input_shape = (224 , 224 , 3)\n",")\n","# call the model \n","model = build_model(resnet , lr = 1e-4)\n","model.build((None, 224, 224, 3))\n","model.summary()"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Model: \"sequential_2\"\n","_________________________________________________________________\n","Layer (type)                 Output Shape              Param #   \n","=================================================================\n","module_wrapper_2 (ModuleWrap (None, 7, 7, 2048)        23587712  \n","_________________________________________________________________\n","global_average_pooling2d_2 ( (None, 2048)              0         \n","_________________________________________________________________\n","dropout_2 (Dropout)          (None, 2048)              0         \n","_________________________________________________________________\n","batch_normalization_2 (Batch (None, 2048)              8192      \n","_________________________________________________________________\n","dense_2 (Dense)              (None, 2)                 4098      \n","=================================================================\n","Total params: 23,600,002\n","Trainable params: 23,542,786\n","Non-trainable params: 57,216\n","_________________________________________________________________\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"_NzK9jN7i6yP"},"source":["learn_control = ReduceLROnPlateau(monitor='val_acc', patience=5,verbose=1,factor=0.2, min_lr=1e-4)\n","filepath=\"ResNet50weights.best.hdf5\"\n","checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"PVroJarTwWl6","outputId":"a4e3cf85-6f56-428a-ce69-3422b82a36a1"},"source":["# Training the teacher model with Resnet50\n","# Train the teacher model as usual\n","# Configuration\n","import time\n","epochs = 10 \n","batch_size = 64\n","\n","# Calculate the starting time    \n","start_time = time.time()\n","\n","teacher_his = model.fit(x_train, y_train,\n","            batch_size=batch_size,\n","            epochs=epochs,\n","            verbose=1,\n","            validation_data=(x_val, y_val),\n","            callbacks=[learn_control, checkpoint])\n","\n","\n","end_time = time.time()\n","print(\"--- Time taken to train : %s seconds ---\" % ((end_time - start_time)))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Epoch 1/10\n","88/88 [==============================] - 61s 637ms/step - loss: 0.3081 - accuracy: 0.8843 - val_loss: 0.2629 - val_accuracy: 0.8729\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","Epoch 2/10\n","88/88 [==============================] - 57s 643ms/step - loss: 0.0644 - accuracy: 0.9741 - val_loss: 0.1101 - val_accuracy: 0.9650\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","Epoch 3/10\n","88/88 [==============================] - 58s 655ms/step - loss: 0.0294 - accuracy: 0.9903 - val_loss: 0.1530 - val_accuracy: 0.9393\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","Epoch 4/10\n","88/88 [==============================] - 58s 663ms/step - loss: 0.0159 - accuracy: 0.9940 - val_loss: 0.1766 - val_accuracy: 0.9593\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","Epoch 5/10\n","88/88 [==============================] - 58s 663ms/step - loss: 0.0140 - accuracy: 0.9955 - val_loss: 0.1599 - val_accuracy: 0.9543\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","Epoch 6/10\n","88/88 [==============================] - 58s 665ms/step - loss: 0.0454 - accuracy: 0.9843 - val_loss: 0.1656 - val_accuracy: 0.9443\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","Epoch 7/10\n","88/88 [==============================] - 58s 665ms/step - loss: 0.0139 - accuracy: 0.9945 - val_loss: 0.1658 - val_accuracy: 0.9571\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","Epoch 8/10\n","88/88 [==============================] - 58s 664ms/step - loss: 0.0154 - accuracy: 0.9947 - val_loss: 0.1792 - val_accuracy: 0.9593\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","Epoch 9/10\n","88/88 [==============================] - 59s 675ms/step - loss: 0.0105 - accuracy: 0.9966 - val_loss: 0.1863 - val_accuracy: 0.9621\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","Epoch 10/10\n","88/88 [==============================] - 58s 665ms/step - loss: 0.0064 - accuracy: 0.9976 - val_loss: 0.3269 - val_accuracy: 0.9536\n","WARNING:tensorflow:Learning rate reduction is conditioned on metric `val_acc` which is not available. Available metrics are: loss,accuracy,val_loss,val_accuracy,lr\n","WARNING:tensorflow:Can save best model only with val_acc available, skipping.\n","--- Time taken to train : 627.1994976997375 seconds ---\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"pWGepXgSjynR","outputId":"9102ca51-57f6-4d1e-a1a7-63be44acf7c7"},"source":["model.save_weights(\"ResNet50_model.h5\") #using h5 extension\n","print(\"model saved!!!\")"],"execution_count":null,"outputs":[{"output_type":"stream","text":["model saved!!!\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"CDJo_3UBzsCf"},"source":["#https://machinelearningmastery.com/display-deep-learning-model-training-history-in-keras/\n","# summarize history for accuracy\n","plt.plot(teacher_his.history['accuracy'],)\n","plt.plot(teacher_his.history['val_accuracy'])\n","plt.title('model accuracy')\n","plt.ylabel('accuracy')\n","plt.xlabel('epoch')\n","plt.legend(['train', 'val'], loc='lower right')\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"J-QHDbz1zv6E"},"source":["#https://machinelearningmastery.com/display-deep-learning-model-training-history-in-keras/\n","# summarize history for accuracy\n","plt.plot(teacher_his.history['loss'])\n","plt.plot(teacher_his.history['val_loss'])\n","plt.title('model Loss')\n","plt.ylabel('Loss')\n","plt.xlabel('epoch')\n","plt.legend(['train', 'val'], loc='lower left')\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"e9C50c_0zzjJ","outputId":"ee67d214-c61a-441e-bbd6-22fee4610072"},"source":["Y_val_pred = model.predict(x_val)\n","print(f'The Teacher model Accuracy on the Validation Set:',accuracy_score(np.argmax(y_val, axis=1), np.argmax(Y_val_pred, axis=1)))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["The Teacher model Accuracy on the Validation Set: 0.9535714285714286\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"4ybwvuF9z0Nf","outputId":"9c546ea6-ce30-4710-b4eb-afcddfe2fc00"},"source":["#Now let's check my Y_test values\n","print(f'My Y_test values are:\\n' ,Y_test)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["My Y_test values are:\n"," [[1. 0.]\n"," [0. 1.]\n"," [1. 0.]\n"," ...\n"," [1. 0.]\n"," [0. 1.]\n"," [1. 0.]]\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"xc8YoU-Hz6D3","outputId":"9c90ac9c-97b7-4810-c427-f2e8ef5026db"},"source":["#Now let's check my predcited values from X_test dataset\t\n","# And calculate the y_pred with time\n","import timeit\n","\n","start = timeit.default_timer()\n","#Your statements here\n","y_pred = model.predict(X_test)\n","print(f'My predicted Y_test values are:\\n' ,y_pred)\n","\n","stop = timeit.default_timer()\n","print('\\nTime: ',stop - start,'sec')"],"execution_count":null,"outputs":[{"output_type":"stream","text":["My predicted Y_test values are:\n"," [[9.9991727e-01 8.2722137e-05]\n"," [2.0833357e-12 1.0000000e+00]\n"," [9.9999917e-01 8.7726909e-07]\n"," ...\n"," [9.9992621e-01 7.3832161e-05]\n"," [7.8759923e-09 1.0000000e+00]\n"," [9.9999154e-01 8.4888525e-06]]\n","\n","Time:  8.099131862999911 sec\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"aDvD1tKvmzup","outputId":"f6e4909e-6753-4937-fda7-866857567a93"},"source":["start = timeit.default_timer()\n","#Your statements here\n","\n","#Now let's check the accuracy between the original & predicted (Y_test , y_pred)\n","print(f'My accuracy on Teacher model with ResNet50 on the Test set is:',accuracy_score(np.argmax(Y_test, axis=1), np.argmax(y_pred, axis=1)))\n","\n","stop = timeit.default_timer()\n","print('\\nTime: ',stop - start,'sec')"],"execution_count":null,"outputs":[{"output_type":"stream","text":["My accuracy on Teacher model with ResNet50 on the Test set is: 0.991\n","\n","Time:  0.0009553229997436574 sec\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Wy97eTzunYLp","outputId":"ff6c071d-53df-479f-8be2-662cac062a23"},"source":["# Classification_report\n","print(f'Classification Report of Resnet50:\\n',classification_report(np.argmax(Y_test, axis=1), np.argmax(y_pred, axis=1)))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Classification Report of Resnet50:\n","               precision    recall  f1-score   support\n","\n","           0       1.00      0.98      0.99      1500\n","           1       0.98      1.00      0.99      1500\n","\n","    accuracy                           0.99      3000\n","   macro avg       0.99      0.99      0.99      3000\n","weighted avg       0.99      0.99      0.99      3000\n","\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"W5TaVx7prspE"},"source":["**AUC ROC**"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":409},"id":"gedmLVmMrsWF","outputId":"b13634f4-5119-4e1e-c8d9-e61921909c18"},"source":["# https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html\n","\n","from sklearn.metrics import roc_curve, auc\n","from numpy import interp\n","from itertools import cycle\n","\n","num_of_classes = y_train.shape[1]\n","print(f'Auc Curve on Validation:\\n')\n","\n","\n","# Compute ROC curve and ROC area for each class\n","fpr = dict()\n","tpr = dict()\n","roc_auc = dict()\n","\n","for i in range(num_of_classes):\n","    fpr[i], tpr[i], _ = roc_curve(y_val[:, i], Y_val_pred[:, i])\n","    roc_auc[i] = auc(fpr[i], tpr[i])\n","\n","# Compute micro-average ROC curve and ROC area\n","fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(y_val.ravel(), Y_val_pred.ravel())\n","roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n","\n","\n","lw = 3\n","# Plot all ROC curves\n","\n","colors = cycle(['blue', 'orange', 'cornflowerblue'])\n","for i, color in zip(range(num_of_classes), colors):\n","    plt.plot(fpr[i],tpr[i], color=color, lw=lw,\n","             label='ROC curve of class {0} (area = {1:0.2f})'\n","             ''.format(i, roc_auc[i]))\n","    \n","plt.style.use('ggplot')\n","plt.plot([0, 1], [0, 1], 'k--', lw=lw)\n","plt.xlim([0.0, 1.0])\n","plt.ylim([0.0, 1.05])\n","plt.xlabel('False Positive Rate')\n","plt.ylabel('True Positive Rate')\n","plt.title('Some extension of Receiver operating characteristic to multi-class')\n","plt.legend(loc=\"lower right\")\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Auc Curve on Validation:\n","\n"],"name":"stdout"},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 576x396 with 1 Axes>"]},"metadata":{"tags":[]}}]},{"cell_type":"code","metadata":{"id":"SrqGDS-WpM0c"},"source":["# https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html\n","\n","from sklearn.metrics import roc_curve, auc\n","from numpy import interp\n","from itertools import cycle\n","\n","num_of_classes = y_train.shape[1]\n","print(f'Auc Curve on Test set:\\n')\n","\n","\n","# Compute ROC curve and ROC area for each class\n","fpr = dict()\n","tpr = dict()\n","roc_auc = dict()\n","\n","for i in range(num_of_classes):\n","    fpr[i], tpr[i], _ = roc_curve(Y_test[:, i], y_pred[:, i])\n","    roc_auc[i] = auc(fpr[i], tpr[i])\n","\n","# Compute micro-average ROC curve and ROC area\n","fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(Y_test.ravel(), y_pred.ravel())\n","roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n","\n","\n","lw = 3\n","# Plot all ROC curves\n","\n","colors = cycle(['blue', 'orange', 'cornflowerblue'])\n","for i, color in zip(range(num_of_classes), colors):\n","    plt.plot(fpr[i],tpr[i], color=color, lw=lw,\n","             label='ROC curve of class {0} (area = {1:0.2f})'\n","             ''.format(i, roc_auc[i]))\n","    \n","plt.style.use('ggplot')\n","plt.plot([0, 1], [0, 1], 'k--', lw=lw)\n","plt.xlim([0.0, 1.0])\n","plt.ylim([0.0, 1.05])\n","\n","plt.xlabel('False Positive Rate')\n","plt.ylabel('True Positive Rate')\n","plt.title('Some extension of Receiver operating characteristic to multi-class')\n","plt.legend(loc=\"lower right\")\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"W1EPv8aFnYos"},"source":["**Student Model**"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"sgVqzo_jvs9x","outputId":"d2177d8b-3730-46d2-c0c6-a43eda6fb913"},"source":["# Define the student model\n","# Student model that is stand-alone. We will evaluate its accuracy compared to a teacher trained student model\n","# Hyperparameters\n","input_shape = (224, 224, 3) # Input shape of each image\n","nb_classes = 2 \n","\n","customstudent = Sequential()\n","customstudent.add(Conv2D(128, kernel_size=(3, 3),activation='relu', input_shape=input_shape))\n","customstudent.add(MaxPooling2D(pool_size=(2, 2)))\n","customstudent.add(Conv2D(64, (3, 3), activation='relu'))\n","customstudent.add(MaxPooling2D(pool_size=(2, 2)))\n","customstudent.add(Conv2D(32, (3, 3), activation='relu'))\n","customstudent.add(Dropout(0.25)) # For reguralization\n","\n","customstudent.add(layers.Flatten())\n","\n","customstudent.add(layers.Dense(nb_classes))\n","customstudent.add(layers.Activation('softmax')) # Note that we add a normal softmax layer to begin with\n","\n","\n","customstudent.compile(loss='categorical_crossentropy',\n","              optimizer='adadelta',\n","              metrics=['accuracy'])\n","\n","print(customstudent.summary())"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Model: \"sequential_3\"\n","_________________________________________________________________\n","Layer (type)                 Output Shape              Param #   \n","=================================================================\n","conv2d (Conv2D)              (None, 222, 222, 128)     3584      \n","_________________________________________________________________\n","max_pooling2d (MaxPooling2D) (None, 111, 111, 128)     0         \n","_________________________________________________________________\n","conv2d_1 (Conv2D)            (None, 109, 109, 64)      73792     \n","_________________________________________________________________\n","max_pooling2d_1 (MaxPooling2 (None, 54, 54, 64)        0         \n","_________________________________________________________________\n","conv2d_2 (Conv2D)            (None, 52, 52, 32)        18464     \n","_________________________________________________________________\n","dropout_3 (Dropout)          (None, 52, 52, 32)        0         \n","_________________________________________________________________\n","flatten (Flatten)            (None, 86528)             0         \n","_________________________________________________________________\n","dense_3 (Dense)              (None, 2)                 173058    \n","_________________________________________________________________\n","activation (Activation)      (None, 2)                 0         \n","=================================================================\n","Total params: 268,898\n","Trainable params: 268,898\n","Non-trainable params: 0\n","_________________________________________________________________\n","None\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"uH990HN_0Ovn"},"source":["# Define a new model that outputs only teacher logits\n","# Raise the temperature of teacher model and gather the soft targets\n","\n","# Collect the logits from the previous layer output and store it in a different model\n","teacher_WO_Softmax = Model(model.input, model.get_layer('dense_2').output)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"jKo9WI4Y0WWh"},"source":["# Define a manual softmax function\n","def softmax(x):\n","    return np.exp(x)/(np.exp(x).sum())"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"O0xHXnJD0YXu","outputId":"ea34e351-6318-4889-826c-55d0a46957dd"},"source":["# Prepare the soft targets and the target data for student to be trained upon\n","# From our temperature experiment we get temp = 10 is gave is best results\n","temp = 10\n","# This model directly gives the logits ( see the teacher_WO_softmax model above)\n","teacher_train_logits = teacher_WO_Softmax.predict(x_train)\n","teacher_test_logits = teacher_WO_Softmax.predict(x_val) \n","\n","# Perform a manual softmax at raised temperature\n","train_logits_T = teacher_train_logits/ temp # temp = 10\n","test_logits_T = teacher_test_logits / temp \n","\n","Y_train_soft = softmax(train_logits_T)\n","Y_test_soft = softmax(test_logits_T)\n","\n","# Concatenate \n","Y_train_new = np.concatenate([y_train, Y_train_soft], axis=1)\n","Y_test_new =  np.concatenate([y_val, Y_test_soft], axis =1)\n","\n","#Print the Shape \n","print(train_logits_T.shape)\n","print(test_logits_T.shape)\n","print(Y_train_new.shape)\n","print(Y_test_new.shape)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["(5596, 2)\n","(1400, 2)\n","(5596, 4)\n","(1400, 4)\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"2UEnZ3Ya0bko","outputId":"b6da1081-3867-4233-f149-c8b0da01141f"},"source":["# Prepare the student model that outputs probabilities with and without temperature\n","# Remove the softmax layer from the student network\n","temp = 10\n","customstudent.layers.pop()\n","\n","# Now collect the logits from the last layer\n","# This is going to be a tensor. And hence it needs to pass through a Activation layer\n","logits = customstudent.layers[-1].output \n","probs = layers.Activation('softmax')(logits)\n","\n","\n","# softed probabilities at raised temperature\n","logits_T = Lambda(lambda x: x / temp)(logits)\n","probs_T = layers.Activation('softmax')(logits_T)\n","\n","output = concatenate([probs, probs_T])\n","\n","# This is our new student model \n","customstudent = Model(customstudent.input, output)\n","\n","customstudent.summary()"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Model: \"model_1\"\n","__________________________________________________________________________________________________\n","Layer (type)                    Output Shape         Param #     Connected to                     \n","==================================================================================================\n","conv2d_input (InputLayer)       [(None, 224, 224, 3) 0                                            \n","__________________________________________________________________________________________________\n","conv2d (Conv2D)                 (None, 222, 222, 128 3584        conv2d_input[0][0]               \n","__________________________________________________________________________________________________\n","max_pooling2d (MaxPooling2D)    (None, 111, 111, 128 0           conv2d[0][0]                     \n","__________________________________________________________________________________________________\n","conv2d_1 (Conv2D)               (None, 109, 109, 64) 73792       max_pooling2d[0][0]              \n","__________________________________________________________________________________________________\n","max_pooling2d_1 (MaxPooling2D)  (None, 54, 54, 64)   0           conv2d_1[0][0]                   \n","__________________________________________________________________________________________________\n","conv2d_2 (Conv2D)               (None, 52, 52, 32)   18464       max_pooling2d_1[0][0]            \n","__________________________________________________________________________________________________\n","dropout_3 (Dropout)             (None, 52, 52, 32)   0           conv2d_2[0][0]                   \n","__________________________________________________________________________________________________\n","flatten (Flatten)               (None, 86528)        0           dropout_3[0][0]                  \n","__________________________________________________________________________________________________\n","dense_3 (Dense)                 (None, 2)            173058      flatten[0][0]                    \n","__________________________________________________________________________________________________\n","activation (Activation)         (None, 2)            0           dense_3[0][0]                    \n","__________________________________________________________________________________________________\n","lambda (Lambda)                 (None, 2)            0           activation[0][0]                 \n","__________________________________________________________________________________________________\n","activation_1 (Activation)       (None, 2)            0           activation[0][0]                 \n","__________________________________________________________________________________________________\n","activation_2 (Activation)       (None, 2)            0           lambda[0][0]                     \n","__________________________________________________________________________________________________\n","concatenate (Concatenate)       (None, 4)            0           activation_1[0][0]               \n","                                                                 activation_2[0][0]               \n","==================================================================================================\n","Total params: 268,898\n","Trainable params: 268,898\n","Non-trainable params: 0\n","__________________________________________________________________________________________________\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"brOe8JSp0gA_"},"source":["# Declare knowledge distillation loss function\n","# This will be a teacher trained student model. \n","# This uses a knowledge distillation loss function\n","# Declare knowledge distillation loss\n","def knowledge_distillation_loss(y_true, y_pred, alpha):\n","\n","    # Extract the one-hot encoded values and the softs separately so that we can create two objective functions\n","    y_true, y_true_softs = y_true[: , :nb_classes], y_true[: , nb_classes:]\n","    \n","    y_pred, y_pred_softs = y_pred[: , :nb_classes], y_pred[: , nb_classes:]\n","    \n","    loss = alpha*logloss(y_true,y_pred) + (1-alpha)*logloss(y_true_softs, y_pred_softs)\n","    \n","    return loss\n","\n","# For testing use regular output probabilities - without temperature\n","def acc(y_true, y_pred):\n","    y_true = y_true[:, :nb_classes]\n","    y_pred = y_pred[:, :nb_classes]\n","    return categorical_accuracy(y_true, y_pred)\n","\n","customstudent.compile(\n","    #optimizer=optimizers.SGD(lr=1e-1, momentum=0.9, nesterov=True),\n","    optimizer='adadelta',\n","    loss=lambda y_true, y_pred: knowledge_distillation_loss(y_true, y_pred, 0.1),\n","    #loss='categorical_crossentropy',\n","    metrics=[acc] \n","  )"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"2XLkOCYK0lBz","outputId":"e709ca8a-7801-41cc-a4b1-fac11b0af9de"},"source":["# Train the student model\n","epochs = 20\n","batch_size = 64\n","customstudent_student_his = customstudent.fit(x_train, Y_train_new,\n","          batch_size=batch_size,\n","          epochs=epochs,\n","          verbose=1,\n","          validation_data=(x_val, Y_test_new))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Epoch 1/20\n","88/88 [==============================] - 16s 184ms/step - loss: 0.0441 - acc: 0.8710 - val_loss: 0.0442 - val_acc: 0.8750\n","Epoch 2/20\n","88/88 [==============================] - 16s 184ms/step - loss: 0.0439 - acc: 0.8733 - val_loss: 0.0448 - val_acc: 0.8671\n","Epoch 3/20\n","88/88 [==============================] - 16s 185ms/step - loss: 0.0434 - acc: 0.8788 - val_loss: 0.0442 - val_acc: 0.8750\n","Epoch 4/20\n","88/88 [==============================] - 16s 185ms/step - loss: 0.0439 - acc: 0.8740 - val_loss: 0.0443 - val_acc: 0.8721\n","Epoch 5/20\n","88/88 [==============================] - 16s 185ms/step - loss: 0.0437 - acc: 0.8763 - val_loss: 0.0442 - val_acc: 0.8750\n","Epoch 6/20\n","88/88 [==============================] - 16s 186ms/step - loss: 0.0439 - acc: 0.8742 - val_loss: 0.0444 - val_acc: 0.8721\n","Epoch 7/20\n","88/88 [==============================] - 16s 186ms/step - loss: 0.0435 - acc: 0.8783 - val_loss: 0.0442 - val_acc: 0.8743\n","Epoch 8/20\n","88/88 [==============================] - 16s 186ms/step - loss: 0.0435 - acc: 0.8794 - val_loss: 0.0439 - val_acc: 0.8764\n","Epoch 9/20\n","88/88 [==============================] - 16s 187ms/step - loss: 0.0436 - acc: 0.8769 - val_loss: 0.0440 - val_acc: 0.8771\n","Epoch 10/20\n","88/88 [==============================] - 17s 188ms/step - loss: 0.0438 - acc: 0.8754 - val_loss: 0.0441 - val_acc: 0.8757\n","Epoch 11/20\n","88/88 [==============================] - 17s 188ms/step - loss: 0.0436 - acc: 0.8776 - val_loss: 0.0440 - val_acc: 0.8764\n","Epoch 12/20\n","88/88 [==============================] - 17s 188ms/step - loss: 0.0440 - acc: 0.8729 - val_loss: 0.0440 - val_acc: 0.8779\n","Epoch 13/20\n","88/88 [==============================] - 17s 188ms/step - loss: 0.0437 - acc: 0.8754 - val_loss: 0.0439 - val_acc: 0.8779\n","Epoch 14/20\n","88/88 [==============================] - 17s 188ms/step - loss: 0.0439 - acc: 0.8738 - val_loss: 0.0438 - val_acc: 0.8779\n","Epoch 15/20\n","88/88 [==============================] - 17s 189ms/step - loss: 0.0435 - acc: 0.8769 - val_loss: 0.0439 - val_acc: 0.8779\n","Epoch 16/20\n","88/88 [==============================] - 17s 189ms/step - loss: 0.0433 - acc: 0.8794 - val_loss: 0.0441 - val_acc: 0.8750\n","Epoch 17/20\n","88/88 [==============================] - 17s 189ms/step - loss: 0.0438 - acc: 0.8751 - val_loss: 0.0438 - val_acc: 0.8779\n","Epoch 18/20\n","88/88 [==============================] - 17s 189ms/step - loss: 0.0434 - acc: 0.8785 - val_loss: 0.0430 - val_acc: 0.8871\n","Epoch 19/20\n","88/88 [==============================] - 17s 189ms/step - loss: 0.0437 - acc: 0.8758 - val_loss: 0.0436 - val_acc: 0.8800\n","Epoch 20/20\n","88/88 [==============================] - 17s 189ms/step - loss: 0.0434 - acc: 0.8788 - val_loss: 0.0436 - val_acc: 0.8786\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"eKFlkPr831Yi"},"source":["#https://machinelearningmastery.com/display-deep-learning-model-training-history-in-keras/\n","# summarize history for accuracy\n","plt.style.use('seaborn')\n","plt.plot(customstudent_student_his.history['acc'])\n","plt.plot(customstudent_student_his.history['val_acc'])\n","plt.title('model accuracy')\n","plt.ylabel('accuracy')\n","plt.xlabel('epoch')\n","plt.legend(['train', 'val'], loc='lower right')\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"rhqcGEUm35Cf"},"source":["#https://machinelearningmastery.com/display-deep-learning-model-training-history-in-keras/\n","# summarize history for accuracy\n","plt.plot(customstudent_student_his.history['loss'])\n","plt.plot(customstudent_student_his.history['val_loss'])\n","plt.title('model loss')\n","plt.ylabel('accuracy')\n","plt.xlabel('epoch')\n","plt.legend(['train', 'val'], loc='upper right')\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Eflf3u3938Pl","outputId":"2f12333c-a399-43e3-c525-06f0151e5e7c"},"source":["Y_val_pred_student = customstudent.predict(x_val)\n","print(f'The CustomStudent model Accuracy on the Validation Set:',accuracy_score(np.argmax(y_val, axis=1), np.argmax(Y_val_pred_student, axis=1)))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["The CustomStudent model Accuracy on the Validation Set: 0.8785714285714286\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Q4CmzFLB4Lew","outputId":"7dc80b1c-12a0-4c21-f3fe-73d991e79115"},"source":["#Now let's check my Y_test values\n","print(f'My Y_test values are:\\n' ,Y_test)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["My Y_test values are:\n"," [[1. 0.]\n"," [0. 1.]\n"," [1. 0.]\n"," ...\n"," [1. 0.]\n"," [0. 1.]\n"," [1. 0.]]\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"ZXiWzbBA4jgs","outputId":"681fc4c8-2342-4abe-92e5-0738cdba47fd"},"source":["#Now let's check my predcited values from X_test dataset\t\n","import timeit\n","\n","start = timeit.default_timer()\n","#Your statements here\n","y_pred_student = customstudent.predict(X_test)\n","print(f'My predicted Y_test values are:\\n' ,y_pred_student)\n","\n","stop = timeit.default_timer()\n","print('\\nTime: ',stop - start,'sec')"],"execution_count":null,"outputs":[{"output_type":"stream","text":["My predicted Y_test values are:\n"," [[0.73105854 0.26894143 0.5249792  0.4750208 ]\n"," [0.26894143 0.73105854 0.4750208  0.5249792 ]\n"," [0.73105854 0.26894143 0.5249792  0.4750208 ]\n"," ...\n"," [0.73105854 0.2689415  0.5249792  0.47502083]\n"," [0.31061557 0.68938446 0.4800795  0.5199205 ]\n"," [0.73105854 0.26894143 0.5249792  0.4750208 ]]\n","\n","Time:  2.5788797919994977 sec\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"dvQZH84Z4p9D","outputId":"42d7d3fe-d053-4cb6-c555-fdc58c702016"},"source":["start = timeit.default_timer()\n","#Your statements here\n","\n","#Now let's check the accuracy between the original & predicted (Y_test , y_pred)\n","print(f'My accuracy on Custom Student model on the Test set is:',accuracy_score(np.argmax(Y_test, axis=1), np.argmax(y_pred_student, axis=1)))\n","\n","stop = timeit.default_timer()\n","print('\\nTime: ',stop - start,'sec')"],"execution_count":null,"outputs":[{"output_type":"stream","text":["My accuracy on Custom Student model on the Test set is: 0.9173333333333333\n","\n","Time:  0.0009702650004328461 sec\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"fZQKmsH7ydM3","outputId":"7f734761-fa65-494c-8109-a2c44756ae65"},"source":["# Classification_report\n","print(f'Classification Report of Resnet50:\\n',classification_report(np.argmax(Y_test, axis=1), np.argmax(y_pred_student, axis=1)))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Classification Report of Resnet50:\n","               precision    recall  f1-score   support\n","\n","           0       0.88      0.97      0.92      1500\n","           1       0.96      0.87      0.91      1500\n","\n","    accuracy                           0.92      3000\n","   macro avg       0.92      0.92      0.92      3000\n","weighted avg       0.92      0.92      0.92      3000\n","\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":409},"id":"hKBaOwEJydE1","outputId":"cf387667-4121-4069-bbd5-9120d37d5c43"},"source":["# https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html\n","\n","from sklearn.metrics import roc_curve, auc\n","from numpy import interp\n","from itertools import cycle\n","\n","num_of_classes = y_train.shape[1]\n","print(f'Auc Curve on Validation:\\n')\n","\n","\n","# Compute ROC curve and ROC area for each class\n","fpr = dict()\n","tpr = dict()\n","roc_auc = dict()\n","\n","for i in range(num_of_classes):\n","    fpr[i], tpr[i], _ = roc_curve(Y_test_new[:, i], Y_val_pred_student[:, i])\n","    roc_auc[i] = auc(fpr[i], tpr[i])\n","\n","# Compute micro-average ROC curve and ROC area\n","# fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(Y_test_new.ravel(), Y_val_pred_student.ravel())\n","# roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n","\n","\n","lw = 3\n","# Plot all ROC curves\n","\n","colors = cycle(['blue', 'orange', 'cornflowerblue'])\n","for i, color in zip(range(num_of_classes), colors):\n","    plt.plot(fpr[i],tpr[i], color=color, lw=lw,\n","             label='ROC curve of class {0} (area = {1:0.2f})'\n","             ''.format(i, roc_auc[i]))\n","    \n","plt.style.use('ggplot')\n","plt.plot([0, 1], [0, 1], 'k--', lw=lw)\n","plt.xlim([0.0, 1.0])\n","plt.ylim([0.0, 1.05])\n","plt.xlabel('False Positive Rate')\n","plt.ylabel('True Positive Rate')\n","plt.title('Some extension of Receiver operating characteristic to multi-class')\n","plt.legend(loc=\"lower right\")\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Auc Curve on Validation:\n","\n"],"name":"stdout"},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 576x396 with 1 Axes>"]},"metadata":{"tags":[]}}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":411},"id":"kjoxO7sSyrJN","outputId":"249609eb-3198-44d4-a25d-9708feb3c122"},"source":["# https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html\n","\n","from sklearn.metrics import roc_curve, auc\n","from numpy import interp\n","from itertools import cycle\n","\n","num_of_classes = y_train.shape[1]\n","print(f'Auc Curve on Test set:\\n')\n","\n","\n","# Compute ROC curve and ROC area for each class\n","fpr = dict()\n","tpr = dict()\n","roc_auc = dict()\n","\n","for i in range(num_of_classes):\n","    fpr[i], tpr[i], _ = roc_curve(Y_test[:, i], y_pred_student[:, i])\n","    roc_auc[i] = auc(fpr[i], tpr[i])\n","\n","# Compute micro-average ROC curve and ROC area\n","# fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(Y_test.ravel(), y_pred_student.ravel())\n","# roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n","\n","\n","lw = 3\n","# Plot all ROC curves\n","\n","colors = cycle(['blue', 'orange', 'cornflowerblue'])\n","for i, color in zip(range(num_of_classes), colors):\n","    plt.plot(fpr[i],tpr[i], color=color, lw=lw,\n","             label='ROC curve of class {0} (area = {1:0.2f})'\n","             ''.format(i, roc_auc[i]))\n","    \n","plt.style.use('ggplot')\n","plt.plot([0, 1], [0, 1], 'k--', lw=lw)\n","plt.xlim([0.0, 1.0])\n","plt.ylim([0.0, 1.05])\n","\n","plt.xlabel('False Positive Rate')\n","plt.ylabel('True Positive Rate')\n","plt.title('Some extension of Receiver operating characteristic to multi-class')\n","plt.legend(loc=\"lower right\")\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Auc Curve on Test set:\n","\n"],"name":"stdout"},{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAfgAAAFrCAYAAAA92puSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd1wT9xsH8E8GU0BBBaWIotRZFJDhHnVQUcBV98C9fmqtewJaJ1oHVeuqu64qlGrrqnXUVq0bq7aKC1QEWQGBEJLv7w/KkYOEMBLCeN6vly+5713unhxHnnzXnYAxxkAIIYSQCkWo7wAIIYQQon2U4AkhhJAKiBI8IYQQUgFRgieEEEIqIErwhBBCSAVECZ4QQgipgCjBkyIbPXo0VqxYobfjf/nll3BxccH27dv1FoMmTk5OOHfunL7DKDMWLVqE//3vf6V+3OjoaDRq1Aj//vtvqR9bl4p7fYWFhcHT01MHEZW+4cOHY+nSpSrXleR95lwzERERJQmvTBDrO4DSIJfLsWPHDvz000948+YN5HI5HBwcMGzYMHz++ef6Dk8rzp8/j3r16sHR0VHnx/ruu+90fgx1Hj9+jFOnTuH7779Hy5Yt860/ceIE5s+fD0NDQ65MLBajTp06GD58eKn9vivCh0NJREdH486dO/Dx8QEAfPXVV3qOqOy4fv06DAwM4OrqWux9FPb6UigU2LlzJ8aPHw8A6N27N3r37l2sYz569AixsbHo2LFjsV6vS9p8nxVJpajBr169GqGhoVi5ciVu3LiBmzdvYsKECVi2bBnCwsL0HZ5WbNy4EU+fPtV3GDonkUgAAA4ODmq3MTU1RUREBPfv+vXr+N///oelS5fi559/Lq1QK7WzZ8/i5MmT+g6jTNq9ezfu3LlTKsd6+PAhtm7dqpV9/fDDD7h06ZJW9qVt2nyfFUmlSPBXrlxBjx490Lx5cxgYGMDQ0BDe3t4ICQlBw4YNue0uXbqEvn37wsXFBe3atcOqVasgk8kAZNcMu3btivDwcHTs2BEuLi5YsWIFnj17hgEDBsDZ2RmDBg3Cu3fvuP1duHAB/fv35/YXHBwMuVyuNk512zPGMGzYMCxYsIDb9t69e3BycsKjR4/g5eWFf//9F7NmzcK4ceMAALGxsZg2bRratm0LFxcXjBkzBi9fvuRe36hRI5w+fRqjR4+Gi4sLPv30U5w5c4ZbHxYWhh49esDZ2Rlt27bF0qVLkZmZCSB/01hoaCh8fHzQokULdO7cGdu2bUPODRJDQkIwevRoHDp0CJ07d4aLiwsmT56M1NRUtedB3f4uXLiA0aNHAwA6duyILVu2FPBbz2VoaIju3buja9euvPd4584dDBs2DG5ubvD09MTixYuRlpbGrb9x4wb69esHZ2dndOvWDcePH+fWFfb8rl27Fn379uXF8/r1azRq1Aj3798HkP3B6ePjA2dnZ3z66afYtWsXt21ISAiGDx+OJUuWwNnZmXd95cipvXh5eaF58+bw8vLCsWPHuPXz5s3DjBkzsHbtWnh6esLV1RXBwcHc74gxhu3bt8PLywstWrSAl5cX74vvvHnzMGvWLEycOJGrdUokEsyaNYt7/wMHDsS9e/cAAFu2bEFwcDAuX74MJycnvHv3DvPmzcOECRMAZP8teXl54ezZs/Dy8oKzszOGDx/Oe2/bt2+Hp6cn3N3dsXr1aixdupR7vSqnT59Gr1694OzsDB8fH/z222+89a9evcKgQYO485Nz7oHsGvWAAQPQsmVLtGnTBvPnz+eug5zm2sOHD6NNmzZct9Dp06fh6+vL+6xQ/ttWd+2MHj0av/32G77++mv07NkTAJCamoqFCxeiY8eO3OeIcnyffvopNm/eDG9vb66GmnN9AcD9+/cxePBgtGzZEu7u7hg/fjzevn2Lv/76CwMHDkRaWhqcnJxw8uRJnDhxAi4uLty+//nnHwwfPhwuLi7o1KkTtm3bpvL8Llq0CAcPHsThw4e512dmZiI4OBhdunRB8+bN4evri19//VXt72j48OFYv349Zs+ezX3m/PHHHzhy5Ag6dOgANzc3rFmzhve+lf8WEhIS0KhRI1y/fp2338K8T1U0XTM53rx5g0mTJqFVq1Zo2bIl/P398fz5c2795cuX0adPH7i4uMDT0xMzZ87kKiIvXrzAmDFj4O7uDldXVwwfPhyPHz8uMC6tYpXA1KlTWefOndmtW7fUbvPkyRPWuHFjFhoayjIzM9mjR49Yhw4dWEhICGOMsePHj7MWLVqwlStXsvT0dBYeHs4aNmzIRowYwaKjo1lcXBzr0KEDW7t2LWOMsYcPHzInJyd2+vRplpWVxZ48ecK6dOnCdu3apfL4mrZ/8eIFc3Z2Zrdu3WJZWVmsd+/ebNOmTdzrGzZsyH755RduuV+/fmz27NlMIpGwlJQUtnDhQtarVy/e9r6+vuzhw4csMzOTBQYGMg8PD6ZQKNjbt29Z48aN2ZUrV5hCoWDR0dHMx8eHHThwgDHG2LBhw1hQUBBjjLFLly4xJycndvnyZSaTydiNGzeYi4sLCw0NZYwxtmnTJubp6clWrVrF0tLSWGRkJHN2dmZ79+5VeR407e/atWusYcOGLD4+XuXrjx8/zpydnVWumzJlCps2bRpjjLF3794xV1dXtn//fpaZmclev37N+vfvz5YuXcoYYywmJoY5Ozuzo0ePMqlUyv744w/WrFkz7hoqzPn95Zdf2KNHj1jDhg1ZdHQ0t27Xrl2sW7dujDHGfvvtN+bi4sJu3LjBsrKy2J07d5i7uzs7ffo0d/48PDzYtm3bmEwmYwqFIt/7+v7771mrVq3YvXv3mEwmY2fOnGFNmjRhN27cYIwxNnfuXObq6sp27drFpFIpu3XrFnN2dubO6YEDB1iHDh3Y48ePWVZWFrt48SJr1qwZu3//Pvd6Dw8PFh4ezuRyOWOMsUWLFrGBAwcyiUTCpFIpW7ZsGevQoQMX09y5c9n48eNVLuf8jubNm8ckEgmLiYlhnTt3ZitWrGCMMXb27FnWpEkTdvHiRZaRkcGdA+X9KXvw4AFzcnJiFy5cYDKZjP3444/sk08+YVFRUSwqKoo1bNiQDR8+nL169YqlpKSwUaNGsSFDhjDGGEtPT+fOjVwuZzExMaxr165s/fr1jDHGvX7s2LEsISGBKRQK9vr1a9akSRP2888/M8YYe/r0KXNzc2NHjx4t1LXTuXNntnPnTi7+qVOnslGjRrG4uDiWkZHBQkJCWKtWrVh6ejq3fdeuXdnjx4+537/y33v37t3Z+vXrmUwmYykpKWz27Nls+vTpvHOdQ3k5LS2NtW/fnm3cuJGlp6ezR48eMTc3N/bTTz+pPM/Kf/eMMRYcHMy6d+/Onj59yqRSKdu/fz9r1qwZe/nypdrXt2nThv3xxx8sIyODTZgwgbVr144tX76cZWRkcJ+pkZGRKs9TfHw8a9iwIbt27Vq+eAp6n6oU5prJuf5HjRrFpk6dytLT01laWhqbOnUqGzx4MGOMsczMTObs7MyOHDnC5HI5i4+PZ/7+/mz16tXca+fNm8cyMjJYRkYGCw4OZv3791cbl7ZVihr8woULUadOHQwePBjt2rXD1KlTcfDgQSQkJHDbHD16FM7OzujduzcMDAzQuHFjfP7557wm3fT0dEyYMAHGxsbo2rUrAKBz58746KOPUKNGDTg7O3O1uOPHj8PT0xNeXl4QiURwdHTEyJEjceLECZUxatq+bt26mD59OoKCgrB//34oFApMnDhR5b7+/vtvREREYM6cOTA3N4eZmRnmzp2Lp0+f8vruPvvsMzRp0gQGBgbw9vZGUlIS4uPjkZqaCoVCATMzMwgEAnz00UcICwvD0KFD8x3ryJEj6N69O9q3bw+xWAx3d3d4eXnh1KlT3DZSqRQzZsyAiYkJ6tevDycnJ0RGRqqMvTD7K6qMjAycOnUKFy9ehJ+fHwDg1KlTsLGxwbBhw2BgYABbW1tMmjSJO9+//PILqlevjs8//xyGhoZo3bo1QkJCYGVlVejzCwCNGzdGgwYNeAOizpw5w/VNHz58GL6+vnB3d4dIJIKzszP69u3Lu04yMzPh7+8PsVgMgUCg8pwNGDAAzZs3h1gsRvfu3eHm5sY7ZxYWFhg9ejQMDQ3h6uqKDh064Pz581wMw4YNQ6NGjSASidCxY0d07twZoaGh3OurVq0KHx8fCIXZHxmLFy/Grl27YG5uzrWIxcTEIC4urlC/k7S0NHzxxRcwNzeHjY0NPD09uWvi0qVLaNmyJTp27AgjIyNMmTIFZmZmavcVGhoKFxcXdO7cGWKxGL6+vli9ejUMDAy4bQYNGoQ6derAzMwMXbt25bqzjI2NcenSJYwYMQJCoRA2NjZo1apVvt+jj48PLC0tIRAIYGtriz///BM9evQAADRo0ABOTk7cawq6dvJKSEjA2bNn8cUXX6BGjRrc+1UoFLh48SK3naenJxo1aqTy9y+RSGBqagqxWAwzMzOsWrUKGzZs0Pg7+P333yGRSDBx4kQYGxujcePGCAkJQYMGDTS+Fsj+zBw7diwaNGgAQ0NDDBs2DDY2NrxWsrycnJzQunVrGBkZoX379oiNjcWUKVNgZGTEfaYqt4TpSmGumRxbtmzBmjVrYGxsDBMTE3Tr1o37XUulUmRkZKBKlSoQCoWwsrLCrl27MGfOHADZvxtDQ0MYGhrCyMgIM2fO5LWu6VqlGGRnY2ODvXv34tWrV/jzzz9x69YthISEYO3atdiwYQM6duyIqKiofAPU6tati1evXnHLxsbGsLS0BACYmJgAAKytrbn1JiYmSExMBAA8f/4cf/75J5ycnLj1jDEYGRmpjLEw248YMQKnT59GcHAwfvjhB5UXI5DdLARkf/lQJhQK8fr1a+4YdevW5b03IDsZNmjQAIMHD8aQIUPQvHlztGnTBr6+vqhXr16+Y0VFRcHb25tXVrduXdy+fZtbrlWrFm/Qm4mJCaRSqcrYC7M/TXKa6nLIZDI4OjoiODgYn376KYDs8/38+XPedkD2gMyEhAS8evUKdnZ2vHU55zMncWo6vzm8vb1x9uxZ+Pv7IyYmBvfu3cPq1asBZP+urly5wmv+Z4zxxhhYW1vzzl9e6q7dqKgobjnvmAU7OzvcuHGDi2Hjxo3YtGkTL4Z27drxtlcWHR2NVatW4d69e/jw4QNXru73mpeRkRFsbGy4ZeVrIi4ujnc8oVAIJycnpKenq9xXVFRUvvhyrqHo6Oh88RsbG3PdTQBw7tw5fPfdd4iKioJcLodcLs83gDPv/o8dO4Zjx44hJiYGCoUCWVlZ3JfHgq6dvF69egXGWL4vzwqFAm/evFF7fGWzZ8/GsmXLcOLECbRt2xZeXl7w8PBQu73ysWvWrMm7tlq1aqXxdQCQnJyM5OTkfF8G8l53edWqVYv72cTEBMbGxqhatSq3DBT+GiqJwlwzOR4/fox169bh0aNHkEqlYIxxXbdmZmaYNm0a5s6dix07dqBNmzbo1asXmjZtCgCYNm0aZs+ejUuXLqFdu3bo0qULOnXqpPKLmi5UigSfw97eHvb29hg4cCAyMzMxZcoUrF27Fh07duT9wStT/kXk1F6UqSoDsj9EfHx8uA9yTQqzfUZGBmJjY2FoaIgXL16gSZMmKrczMjKCUCjE3bt3IRKJ1O5PXewCgQCBgYEYO3Ysfv31V/z666/Ytm0bvvnmm3wfVIU5bwXFkFdh9qeJqakpbxDTvHnz8OzZM3Tv3p0rMzY2RsuWLXHgwAGV+xAKhVAoFCrXFfb85ujZsyc2b96MuLg4nD59Gp988gn3ZcnY2BgTJkzAtGnT1L5e3Re5HOrOmbK8Yz8YY9w5NTY2xrx589CvX79CxaBQKDB+/Hg0btwY4eHhsLGxwb179zBgwACNceQo6LwpFIp871ndtQpkXxvqflfK26hy7do1zJ8/H1999RV8fHxgZGSEgIAAPHv2jLedcjwnTpzApk2bsGHDBrRv3x4GBgYYO3YsL1ZN8eTI+WL9888/o06dOmq3K+ga6Nu3L7p27YrffvsNFy9exJgxYzBy5EjMmjWrwGMXJc68CnPNqTtmQcsFKW6sW7Zs4Q3Ai4iIKNQ1AwApKSkYO3YsevXqhU2bNsHS0hI///wzZsyYwW0zadIk9O/fH7/99hs3jmrRokUYMmQIOnTogIsXL+Ly5cu4ePEiZs6ciY4dO2L9+vXFei9FVeGb6N++fYvAwEBeczwAruksp9ze3j7fXNknT56orLUWRt26dfHo0SNeWUJCAm8QV1G3X7duHerXr4/g4GAsXbo033vKUa9ePSgUCvzzzz9cGWMs3zdTdRQKBZKSkmBnZ4eRI0di37596NmzJ44cOZJvW22fN23vD8hO8NHR0bwBO3Xr1sWTJ0+4b+JA9h9zcnIyAKBOnTp48eIFNxANAE6ePIlbt24V+fw6ODigSZMmuHDhAq95PieOvL/3d+/eFekDtDDnLG+tKjo6mqtNqYohZzqpKvHx8YiKiuKaZAHgwYMHhY5Xk+rVq/POJWOswP3b29vzBj0B2d0OhZn7fv/+fdSuXRv9+/fnWsv+/vvvAl9z9+5dNG/eHJ9++ikMDAwgk8l4xyro2snLzs4OIpEo38CrgmrBeSUkJMDCwgJ+fn5Yv349AgIC8P3332t8XZ06dfDu3TteC8ylS5cKNVK+evXqqFKlCu99KxQKREZGluhvVZmRkRGv1Ua5NbUoJk+ezJtVAxT+momMjERKSgrGjBnDtd7mvRYTEhJQs2ZNDBgwAN9++y0mTJiAQ4cOcetMTEzg5eWFlStXYvPmzfj555+RlJRUrPdSVBU+wVevXh1//PEHZs2ahX/++QdZWVmQyWS4efMmDhw4wI1k7dOnD+7fv4/w8HBkZWXhwYMHOHbsWIG1moIMHDgQkZGR2L17NzIyMvDmzRtMnDhR7Tc3TdvfvHkTJ06cQEBAALp27QoXFxfeSHYjIyO8fPkSKSkpcHR0hIeHB1auXIl3795BKpVi8+bNGDRoUKGav37++Wf4+vri8ePHYIwhPj4er169Ujk1rV+/fjh79iz++OMPZGVl4Y8//sDZs2eLfd60vT8AqFatGhYtWoSQkBCun9fHxwcKhQLr1q1DamoqEhISMGfOHMyfP59bL5FIsHv3bmRmZuL27dtYtGgRGGPFOr/e3t746aefEBERwV1zADB06FBcunQJJ0+ehEwmw9OnTzFs2LBCfUArn7Njx47h77//hkwmQ3h4OO7du8ebB5yYmIgDBw5w7+XKlStci8bQoUNx/PhxXL16FVlZWbhz5w769u2rdlSxpaUlTE1Ncfv2bWRmZuLKlSvctjkj4Y2MjPD27VtIJJIi1/ZatWqFGzdu4Pr168jMzMTWrVsLnHXRr18/RERE4NSpU5DJZDh37hxWrFjB1Y4LYmdnh/j4eDx//hzJycn4+uuvwRhDXFyc2i84dnZ2ePHiBd6/f4+4uDgEBgbCysqKe+8FXTs55+bVq1dITk6GmZkZ/Pz8sGHDBrx48QJZWVncrIrY2FiN8cfExKBDhw44c+YM5HI5MjIy8PjxY14LUUZGBl6/fp2vctGhQwdYWVlh48aNSEtLQ2RkJBYsWKA2+RgZGSE6OhoSiQSMMfTp0we7d+/Gy5cvkZmZiZ07dyI5OTlfF1txOTg44MqVK9zf5549e9RuW9D7VKWw10zt2rUhFApx69YtSKVSnDx5kpst8u7dO9y5cwddunTBjRs3oFAokJKSgsjISDg4OCAjIwNeXl7Yv38/MjMzIZPJ8ODBA1hZWcHCwqJE56awKnyCNzQ0xMGDB2Fvb4/JkyfDzc0Nbm5uCAoKwtChQzF37lwAQPPmzbFu3Tp89913cHd3x8yZMzF+/HiMHDmyWMetW7cuNm3ahNDQULi7u3NTdGbPnl3k7TMyMrBw4UJMmjSJa8ZbsmQJLl26hLNnzwIAhgwZgm+++QZjxowBAKxduxbVqlVDjx490LZtW9y8eRM7d+5UOwZAWc+ePTFgwABMmjQJLVq0gJ+fHz7++GNMnTo137ZeXl6YO3cuvvrqK7i7u2PlypX46quv0K1bt2KdN23vL4e3tzfatm2LuXPnQi6Xw8LCAt9++y3u3r3L9ZtZWFhwd+izsrLC3r178eOPP8LNzQ3z58/H4sWL4ebmBqDo57dnz564efMmPD09UaNGDa7cw8MDQUFBCAkJgaurK8aPH4/evXsX6brz9/fHoEGD8MUXX8DT0xN79+7F9u3beWMBPDw88Pr1a7Rv3x5jx47FsGHD0KtXLwDZNwWZOHEiFi5cCFdXV8ybNw/Tp0/nBj3lJRaL8dVXX+Hw4cPw9PTE0aNHERwcjFatWmHs2LG4f/8+fHx8EBcXh44dOxb5LnK+vr4YPnw4Jk6cyPVXtm/fXm0ze6NGjfDNN99g06ZNcHNzQ0hICDZu3Ah7e3uNx+revTu8vLzQt29f+Pj4oEaNGggKCkJycrLaLofBgwejadOm6NatGwYNGoS2bdviiy++wP379zFt2jSN187AgQMRFhbGfdFbuHAhmjdvjoEDB8Ld3R3Hjh3D9u3beeN71KlVqxbWrl2Lb775hhuY+OrVK6xduxYA0Lp1azg6OsLLyyvfAF9DQ0Ps27cPERERaNWqFcaNG4cRI0ZwYwny6tevH27duoUuXbogMTERs2fPRuvWreHv7482bdrg0qVL2L9/P6+fvSSmT5+OzMxMtG3bFiNGjOAGQqpS0PtUpbDXjI2NDebOnYvVq1ejbdu2uH79Oje9umfPnrC1tcWsWbOwaNEiuLi4oHv37hAKhVi8eDGMjY3xzTffIDw8HJ6enmjdujUuXbqEb7/9tkhdEyUhYMrtSISQCmfevHlITExUO8e5LJJKpbwvS/7+/qhXrx4CAwP1FxQh5UyFr8ETQsqXO3fuwNXVFX/++ScUCgV+//133LhxQ+1IdEKIapVqFD0hpOxzcXHBwoULsWTJEsTFxcHGxgYLFiwok/dAJ6QsoyZ6QgghpAKiJnpCCCGkAqIETwghhFRAlOAJIYSQCqhcDrJTvkcz0T5bW1s6x6WAzrPu0TnWPTrHpcPW1rbIr6EaPCGEEFIBUYInhBBCKiBK8IQQQkgFRAmeEEIIqYAowRNCCCEVECV4QgghpAKiBE8IIYRUQJTgCSGEkAqoVG508+rVKwQHB6Nnz5747LPPeOvu37+PQ4cOQSgUwsXFBf379y+NkAghhJAKTec1+IyMDOzevRuffPKJyvW7d+/GzJkzsWzZMty/fx/R0dG6DokQQgip8HRegzcwMMD8+fMRFhaWb927d+9gZmaGGjVqAMh+DnRERATs7Ox0HRYhhJBKgDFAocj+J5cDjAm4n3PKFQqB0s/8ZVWvyd6nQIv7YBAjFWJFKsRIgSEkMEAKDAUpyJLGwbyKAWynTi/ye9d5gheJRBCJRCrXJSUlwcLCgluuWrUqYmJidB0SIYQUifIHt+oP64KThvJriruPwiYNuTx3m7zLyvvIfr2qZfWvUbUPY2Pgw4dq3Gvy7iM7htzX5F3mn1tBnoQsUNpf9mtyX5973tSfd4GOrwwGY4MMWJhIUNU0WeX/FiYSVDVRUZaznUkyzE1SIBIq+HtmwIE/DREQZoJ9Yz8AKIMJvigYY4Xarjg33SdFQ+dYu5Q/tHI+rFJTATMz23wf6up+1sZ2pXksfW2Xf51tiY9FNDHVdwBFJhbJ8iVedQm4oHUG4iytxxYZK8SMQ6b4/YkBAGDGIVP8FVj0/eg1wVtaWiIpKYlbTkhIgJWVlcbX0ZOLdKs4T4dKSBAgMtIA6ekCZGTgv/8FkEpzvk3nfssuXPOW6ppGwTUV1TUN5ZpJ3uX8tQ5VtQT1seXGV3BtjDFd1yQIqRyEAjnMTVLyJWCVteicdaYSVOMSdPb/JoYZ+n4rPBlZpkjPMkeMxAzdVyfigzS3wpsqq1qsfeo1wVtbWyM9PR2xsbGoXr06bt++jalTp+ozpErrw4fsZAwAhoZAQgJ//GVGBvD770aIj+eXKxQCrF1rDoUCyMqiJEYqLpGIQSjEf/+Uf+Yvi0SAQJBdJhJll6la5u9P/X5z95d/OWcf2fvTHFve1+TEKxSyIu8j5/U1algiOTkRAgFT2p+KfQgUMBR+gKEwBUYCCYyEKTCABIaC7L5mA0hgwLL/FyMFBiwVYiaBmKVAxFIgVqRApEiBiH3Q96XAwwSGUIjNwUTmUIjNwMTmUIjMwbgy8//KzMDEFrn/i81y14vMAGF2bb0qgKExm7B9+3aIRCKMGDECkydPLlZsAlbYdvFievbsGfbt24e4uDiIRCJYWVnBzc0N1tbW8PDwwMOHD3Hw4EEAgKenJ3x9fTXuk2rwhcMYcOuWAV69EuPmTUNUq6bAxo3mAIDateXcdm/fqh4jQbRLIGBKH36AUCiAUKgoVNLI+4GvzaSR/wO/eEmDnzA0Jw3l16jbR96kkf8cFhxHrVrWiIt7x3tNQftQf1x9Xz16xBigyIAwKwUCeQqEWakQyCXZ/2dJYGkmgiQ+CkJ5KgRZKf9tlwphlgQCefY22a9JgQA6TTdFwiBSSrzmSknaXClJm0EhsgATKyfn3ASuEJsDQqOSxcEYBHkuMKlUigULFmDs2LFo0qQJgOJ1m+o8wesCJfhsEREG+OyzmjAxUcDAIP96iaT072PUtq0UxsaM908szv0QLVnSUJ1Eipp48n7Aa/rAz/mwL0qiUVWjy5skitMVQoqm0p9jRSaXkAVZqRDKU5SScJ5knJUKYc52XHJOyX4N034/c0nkS7RKCZeJzKAQW+T+LzZTWaNmQhO9f3O7cuUK1q1bh61bt6J27doFblucBF+mBtkR1RQK4MQJE0yfbommTWUQiRgiIgy59enpQqSna+dYlpZyCIUiKBTyfOuEQiA1VYhRo/hNZFZWCjRtKkOnTlJ9/70QUjEw+X/JNVVFQk7hJWHe/8pJXJ4KgaJs9TMrhCb8JmxeTdk8f02aa/bObdpmoiqAoPQrL9oUHx+PNWvW4NSpUwCApUuXYsuWLflq8iVFCb6MyswEunSxxrNn/F/Rw4cqquqF0KVLBt68EaFnz3QkJgoxcEDC+KQAACAASURBVGAaqlXLHR5sYsJgZZXdmJNd63lX/OAJqayYAgJ5Wm4yzqkB85K0Uo2aS85K67IkECrS9P1OePj9zPyEbGpRCylSYZ4atXI/c87/uf3MlRVjDOHh4VizZg2Sk5O58oiICLx9+1brs5cowZdB6ekCODoW3FyjzNNTiq1bE2FsnL+3RSQCzMzKXS8MIaUrXz9zSp4k/V/iLa/9zFzTtap+5txaNG8QmFLfdEH9zKa2tkipzN0ghfTq1SssXboU165d45X37NkTc+fOLdQMsqKiBF/GJCQI4OSkPrk3aCBDSEgSBALA3FwBB4f8TemEVCp5+5mVasVIFcIsPlqpJp2/n5lL0mWunzlP07XKJuz8/cw568tKP3Nll5WVhX379mHLli3IyMjtMrG1tcWSJUvQrl07nR2bEnwZkZAgwIABNfDoUf4mrLCw92jWTAZT07JTMyCkxHj9zLk14Ly1Z9X9zDn/a+5ntihwrfap72dWM2JbxVSqitDPTIDHjx9j8eLFePToEVcmFAoxbNgw/O9//4OpqW5vEEQJXo+uXTNEv341YGqqQFqa6j/mf/99iypVKLGTMiSnn1m5yVrl6Oy8g8HKYz/zf1OkVDVrKw8CE+XOa4aQPlZJtvj4eF5yb9SoEQIDA+Hk5FQqx6crUQ8YA3x8auDOneyR8OqS+5kzsZTcifYwBoEi479asap+5pQCRm6Xp35mC66/WdUAMHU3HSnpfGZC8mrbti169eqFc+fOYdKkSRg5ciQMVM1p1hFK8KWMMcDOruCRkmFh7+HunllKEZFyQW0/s1LtmJekU1QPBitD/cwMAjCRGa+mrLKfuYCpVExsASY0VtvPTAPASGlJTExEdHR0vtr53LlzMXnyZNjb25d6TJTgS5G65G5kxHD2bCysrRWwsCg7NSOiBYqs7ATLqwFn/48PIpjFR/Fr1CoHg6VAwKT6fic82f3MuSOt1U+RUpeszamfmVQIjDGcOnUKq1evhoGBAX788UeYm5tz6y0tLWFpaamX2CjBl4KnT0W4d88Q06bl/yV/910CvLzK1s0oCFT0M+edIqVuMFieZK2hn7m0B4AxgVGe+2Ur1Z7/a9pWP2LbnPqZCVHy+vVrLFu2DL///jtXtmHDBixevFiPUeWiv1Id++gj9c3x9+/HoHp1ehalVvH6mXPvl616MFj+hMzrcy4X/cx5mrbVjtymfmZCtEUul+PgwYMICQlButJtRG1sbNC+fXs9RsZHCV6HfvnFWO26GzfeUXLPS5FZxFtxqr6vdpnvZ/4vOZtY2CBVKlJx0xGzIvUzE0JKz+PHjxEYGIgHDx5wZQKBAIMHD8b06dNRpUoVPUbHRwleRy5fNsTYsfw7E33ySSZMTBiOHYtX+XCYciunn1nN06Zyas+qR2ynlJN+5rw1ZVW34ixaP7OJrS0kNACMkHIhIyMDW7duxZ49eyCX595gzNHREUFBQWjRooUeo1ONEryODB5cg7fs7Z2OHTsS9RSNGkwBgfxDvltxQiaGadyrAqZSpRapn7m05e9nVupv5vqZLQq+6YjIjPqZCSEAsgfSjRo1ChEREVyZgYEBJk6ciNGjR5fq1LeioE8wHZBI8jelbt+uxeRe5H5m/lSqwvQzV9NetIXG72dWdSvOPI9+VHPTEepnJoRok0AgQL9+/bgE7+bmhoCAADg4OOg5soJRgtcyxoAePWryyqKi3qjsPhVkSWCQ+vd/fctqnstcjvqZc/uM8wwCy1lXwFQq6mcmhJRl/fr1w+XLl9G+fXv069cPQmHZn+JJCV7Ldu2qghcv+Kc173UgyohGlajtMH37PYQKLT3IvZgUQlP+PbDFZjAys0aaTKy6n1m5aZvmMxNCKpi3b99i5cqVGDduHO+mNQKBAJs2bdJjZEVHCV6LFAogIKAqr2z7tncQpT2DUJ4KcdpTGMWfh0nsSQhQsqfAqe9nzm3aznsrzsL2M9va2iKJBn8RQioRuVyOw4cPY+PGjUhLS0N0dDSOHDlSZvvXC4MSvJa8jmY4EnQIG4ZHYWjbg6hhHg+p3BRGojTghvrXyUwaQG7qUMSbjlA/MyGEaMuTJ08QGBiIe/fucWX//vsvrl+/rtPHueoaJfgSEsgSUPuqE2wBuA/lrzMSqR9dLq3WGql1JkNq1Zn6nQkhRA+kUil27NiBnTt3Iisrd1yTg4MDgoKC4OrqqsfoSo4SfFExBvPna2AWvV3jc6hzKETmkBvVRpaJA7KqfIyM6t0gq+qm40AJIYSoc+vWLQQGBuL58+dcmVgsxrhx4zBu3DgYGhrqMTrtoARfAEFWKqq83gOzqK0QZiVBITKHUJ5S4Gsu/N0Zrn6fQqhIR4ZVF8iN64CJy86djQghpDKTSCRYv349jh07xit3dnZGUFAQGjRooKfItI8SfF5Mger3BsAw+RYEjP/IVk3J3WZSDFp3NseWKUm6jJAQQkgxxcbGIjQ0lFuuUqUKZsyYgQEDBpSLqW9FUbHejRbYXqoDo6Q/8yV3VSQO8/HS7T6MRysgGMoQK7HB0qWSUoiSEEJIcTg6OmLMmDEAgM6dO+PHH3/EoEGDKlxyB6gGzxFkfUCNWz3UrpfUmwVp9S6QG33EG8V+MtQEUmn2ILmPPsqiB8gQQkgZoVAo8PTpUzRs2JBXPn78eDg5OaFjx44QVOBBzpU+wYs/PIX1Xx1VrktuEIiMmj0gN7ZTuf7wYRPMnJn7jPc6deQ0IJ4QQsqAyMhIBAUF4dGjRwgLC8NHH33ErTMyMkKnTp30F1wpqXhtEoUkyoiG7cWP1Cb39Bre+FBnnNrk/vffYl5yNzZmmDgxVSexEkIIKRyZTIatW7eif//+uH37NtLT07Fs2TIwpvq5GxVZpazBV/13Iaq82aN2fZzrKcgsnAvcx/37uVMo6tXLwq5dCWjcuOzcH54QQiqbO3fuIDAwEJGRkVyZWCxG06ZNIZfLIRZXrpRXud4tACgy1Sb3Nx2eA8LCzX18/lzE/dynTzold0II0ZPU1FRs2LABR44c4dXUmzdvjsDAwHx98JVFpUrwAnk6al9x5JUxgQFi2j4AE5sVaV/Pn+eeOgcHSu6EEKIPv/32G7766iu8e/eOKzMxMcH06dMxePBgiESiAl5dsVWaBG8guYuat3vmK3/b8UWx9qec4OvVowRPCCGlLTg4GHv37uWVtW/fHkuWLEHt2rX1FFXZUbETvCITNe70hWHKHZWr33lcKdZuGQNevMj9Vkg1eEIIKX1t27blEryVlRXmzZuHHj16VOipb0VRcRO8PAO2V9TfcjCmzT0oDGsUa9fv3gmRnp49AaFqVQUsLSvf6ExCCNG3Nm3awNfXF0KhELNmzUK1atX0HVKZUmETvPXNLirL02v0QGKTEEBkUux9v3jBb56nL4uEEKI7MpkMu3fvhqOjIz799FPeumXLllXqfvaCVMgEb5h4BeL0F7yyhKbbkGHdSyv7pwF2hBBSOu7fv4+AgAA8efIENWvWhJubGywsLLj1lNzVq5A3uqlxbxBvOc4lTGvJHeD3v9erJ9fafgkhhGRLS0vDqlWrMHToUDx58gQAEBcXh0OHDuk5svKj4tXgGf9e8ApxVciqumv1EM+eUQ2eEEJ05fLly1i2bBnevn3LlZmYmGDq1KkYMmSIHiMrXypWgmcK1LzRiVcU53ZO64fJ2wdPCCGk5OLj47Fq1Sr88ssvvPK2bdti8eLFsLNTfetwolqFSvBVnyyAQXokr0xuVEurx8g7Ra5+fWqiJ4SQkmCM4ccff0RwcDCSk5O58mrVqmHu3Lno1asXTX0rhgqV4IWZ8bzlxEbrAIF2B2DExgqRlpY9dMHCQgFLS3o8LCGElERSUhLWrFkDiUTClfXq1Qtz5syBlZWVHiMr3yrWIDulb3gfbEcivfagAjYuHuXmeQcHmiJHCCElZWlpiZkzZwIAPvroI2zbtg2rVq2i5F5CFaoGr0xarbVO9qv8kBnqfyeEkKKLjY2FtbU1r6xv377IzMyEn58fTE1N9RRZxVKhavAmcad0fgz+HHjqfyeEkMJKS0tDcHAwunfvjoiICN46gUCAwYMHU3LXogqT4EXpr/KU6KbtnB4yQwghRXf16lX07dsXe/fuRVZWFpYsWQKZTKbvsCq0CtNEX+UN/4lCmdVa6eQ4efvgCSGEqJeYmIg1a9bgp59+4pVXr14dKSkp1M+uQxUmwZu8C+V+VoiqFPtBMgVhjN8HT030hBCiGmMMp06dwurVq5GYmMiVW1hYYM6cOfDz86OpbzpWMRK8IhOizHfcYlrtoTo5TFxc7hQ5c3MFrKxoihwhhOT1+vVrLF26FFevXuWVe3t7Y+7cuahevbqeIqtcKkSCF+fpf/9gq5sEn/chM/TlkxBC+M6cOYNFixYhPT2dK6tVqxaWLFmCDh066DGyyqdUEvyePXvw5MkTCAQC+Pv7w9HRkVt3+vRpXLlyBUKhEA0aNIC/v3+Jjyc3ddS8UTHQQ2YIIaRgjo6O3OA5gUCAIUOGYNq0aahSpYqeI6t8dD6K/uHDh4iJicHy5csxceJE7N69m1uXlpaGn376CUuXLsWyZcsQHR2Nf//9t8jHMEi5y/0sM2mglbhVoYfMEEJIwRo0aICxY8fi448/xsGDBzF//nxK7nqi8xp8REQE3N2zn+ZmZ2eHDx8+IC0tDaamphCLxRCLxcjIyICxsTGkUinMzMyKfAxRZiz3c9570WsTPWSGEEJyXb9+HVKpNF/T+4QJEzBhwgQYGBjoKTIClEKCT0pKQv369bllCwsLJCUlwdTUFIaGhujfvz/+97//wdDQEG3btoWtrW2Rj8GU5rynWftpJW5VlJvoqQZPCKmskpOTERwcjLCwMJiamuLEiRO8J71RYi8bSn2QHWOM+zktLQ2hoaHYuHEjTE1NERQUhBcvXqBevXoF7iPfl4AkC+5H0+ofw7QYXxI0yX6KXO5y69Y1kedOixVKcb5okaKj86x7dI61hzGG0NBQzJ8/H3FxcQCyP8e3bNmCPXv26Dc4ko/OE7ylpSWSkpK45cTERFhaWgLInkphbW0NC4vsBN2kSRM8e/ZMY4J/8+YNb7mKRIKq//2cmpoKSZ712hAXJ0RqavajZ83NFZDJYqCDw5QJtra2+c4x0T46z7pH51h73r59i2XLluHy5cu8cl9fX8yYMYPOs44V54uqzgfZtWjRAteuXQMAPHv2DJaWljAxMQEA1KxZE69fv0ZmZiYAIDIyErVr1y7yMcQZUdoLWI28t6ilKXKEkMpALpfj4MGD8PPz4yV3GxsbhISEYM+ePahZs6YeIyTq6LwG36hRI9SvXx+LFi2CQCDAmDFjcPHiRZiamsLDwwO+vr4ICgqCUChEo0aN0KRJk6IdgLE8t6nV1T3o6Q52hJDK5d9//0VgYCDu37/PlQkEAgwcOBBffPFFsQZFk9JTKn3wQ4fybzyj3ATfrVs3dOvWrdj7Fsg/8JalOroHPT1khhBSmSgUCsycORPPnz/nyho0aIDAwEC4uLjoMTJSWBXmaXI5pNW76mS/NEWOEFKZCIVCLFy4EED2qPgpU6bg2LFjlNzLkXJ/q1qBPIX7WSHSXXORchN9/frURE8IqVjS0tJgYmLCewBMq1at8OWXX6Jjx45o0EB3NxEjulHua/A17vTnfpab1NXJMbKnyFENnhBS8TDGcO7cOfTs2RPnz5/Pt3706NGU3Mupcl2DF8gSIM54wS1Lq7XWyXHevxciNTX7u5CZmQI1atBT5Agh5d+7d++wfPlyXLhwAQCwfPlyeHp6clOXSflWrmvwRsl/8ZZT6n6hk+Pkrb3TFDlCSHmmUChw+PBh+Pn5cck9x8uXL/UUFdG2cl2DN5DkPmQmtc5EMANLnRyHpsgRQiqKyMhIBAYG4s6dO7zyzz//HDNmzKDaewVSrhO88hQ5uaGNzo5DU+QIIeVdZmYmduzYgR07diArK/dzzMHBAQEBAXBzc9NjdEQXyneCZ7kXKRMa6uw4yk309JAZQkh58+TJE8ycORPPnj3jysRiMcaMGYPx48fDyMhIj9ERXSnXCR5MlvuzQHdvhZroCSHlmaWlJd6/f88tt2jRAoGBgfj444/1GBXRtXI9yE6gyOR+ZgLdPJ4w7xQ5qsETQsqbGjVqYPbs2TA1NcWCBQuwb98+Su6VQDmvwSslWx010cfHC5GSkv09qEoVmiJHCCnb4uLi8Mcff8DPz49X3rt3b7Rr144eDFOJlOsEz6/B6+atKDfP16snpylyhJAySaFQ4MSJE1i3bh1SU1Ph4OCA5s2bc+sFAgEl90qmXDfRl0YNXnkEPTXPE0LKoufPn2P06NEIDAxESkoKGGMICAiAXE5jhiqz8l2DVxpkp6saPN2ilhBSVslkMnz33XfYtm0bMjNzWzTr1KmDefPmQSQSFfBqUtGV7wRfCoPslGvw9etTgieElA33799HQEAAnjx5wpWJRCL4+/tj0qRJMDY21mN0pCwo1wm+NJroX7zg98ETQog+ffjwAZs2bcL3338PxhhX3qxZMwQFBaFx48Z6jI6UJeU6wet6kB1NkSOElDUBAQE4ffo0t2xiYoKpU6di6NCh1CRPeGiQXQESEoSQSHKnyNWsSVPkCCH6NWnSJBgYZHdJtm3bFmFhYRgxYgQld5JP+a7B63iQHU2RI4ToE2MMCoWCl7wbNGiAL7/8EpaWlujZsycE9MFE1CjXNXjlJnoItF+Dp4fMEEL05dWrVxg3bhz279+fb93w4cPRq1cvSu6kQOW6Bg/ew2a0P4qe+t8JIaVNJpNh37592LJlC6RSKe7evYsuXbqgTp06+g6NlDPlOsHrepAd/yEzlOAJIbr1999/IyAgAI8fP+bKMjMz8ddff1GCJ0VWrhM872lyOhhkx6/B0xQ5QohupKWlYfPmzdi/fz8UitzBvE2aNEFgYCCaNWumx+hIeVWuEzzvefBarsEzRn3whBDdu3r1KpYuXYrXr19zZUZGRpgyZQpGjBgBsbhcf0wTPSrfV44OB9klJuZOkTM1VcDamqbIEUK0RyKRYMWKFTh58iSvvFWrVliyZAns7e31FBmpKMp1ghfocJDds2c0RY4QojuGhoa4f/8+t1y1alXMmTMHvr6+NDqeaEWhpsndvn0b3377LTZu3AgAuHfvHqRSqU4D04gx3jx4aPle9PSQGUKILhkbGyMgIAAA4O3tjfDwcPj5+VFyJ1qjMcGHhobi6NGjsLe3x9OnTwEAkZGR2L59u86DK1Dem9xo+Y9COcHTQ2YIISWRlZWFc+fO8e4dDwCenp44ceIE1qxZg+rVq+spOlJRaUzwv/76K5YuXQpvb29usEefPn3w7NkznQdXEP4AO+3Pgc97FztCCCmOx48fY8iQIZgxYwbOnj2bb33Dhg31EBWpDDQmeJFIlO8ex3m/heoFb4Ad3eSGEFK2pKen4+uvv8bAgQPx8OFDAMCKFSuQnJys58hIZaFxkF2LFi2wcuVKdO/eHZmZmbh9+zZ+/fVXtGjRojTiU0uXA+xoihwhpCSuXbuGoKAgREVFcWWGhoYYOnQoTE1N9RgZqUw0JvgRI0YgLCwMYWFhEIvF+Omnn+Dm5obPPvusNOJTT4c1+MREAZKTsxs3TEwUsLGhKXKEEM2SkpKwdu1ahIWF8crd3d0REBCAevXq6ScwUilpTPB//fUX+vfvj/79+/PKT506hZ49e+osME14T5LTcg2eX3unKXKEkIIxxvDLL79g1apVSEhI4MotLCwwc+ZM9O3bl0bHk1KnNsHHx8cjLi4OBw4cQPXq1Xn97h8+fMDRo0f1muBRSlPkqP+dEKLJnj17sG7dOl6Zl5cX5s+fjxo1augpKlLZqU3w0dHROHXqFBISErj579yLxGJ4eXnpPLiCCBTK0+R0V4OnBE8I0cTX1xc7d+5EcnIybGxssHjxYnTq1EnfYZFKTm2Cb9GiBVq0aIEjR45g4MCB+dbHxsbqNDBNdDnI7sULmiJHCCm86tWrY86cOXjw4AGmT58OMzMzfYdEiOY++IEDByIhIQGxsbHcU44yMjKwbds2bNu2TecBqqXDQXZUgyeEqCKVSrFt2zZkZGRgzpw5vHV+fn7w8/PTU2SE5KcxwZ88eRKHDh1CtWrVkJSUBHNzc0ilUnTr1q004lNLl4Ps6Da1hJC8/vrrLwQFBeHFixcQCATo3r07nJ2d9R0WIWppTPBnzpzB+vXrYW1tjRkzZmD9+vW4ePEiMjMzNb1Ut3Q0yC4hQYCkpOwpcsbGCtSqRVPkCKnMkpOT8fXXX+P48eNcGWMMJ06coARPyjSNd7ITi8WwtrYGAK6JvlOnTjh37pxuI9NAV4Ps+CPoaYocIZUVYwxnz56Fn58fL7mbmZlhyZIlCAwM1F9whBSCxgRfs2ZN7Nq1CwqFAjVq1MD58+cRGRmJlJSU0ohPLd6T5LTYRE9T5AghMTExmDZtGr788ku8f/+eK+/SpQt+/PFHDBgwAEJhoR7GSYjeaGyinzJlCo4fPw6hUIjBgwcjJCQEEolE5cj6UqWjGjzdopaQykuhUODo0aNYv349Pnz4wJXXrFkTCxcuRNeuXfUYHSFFozHBV61aFaNHjwYAODo65psTry+6GmSnPEXOwYGmyBFS2fz888+85P75559jxowZsLCw0GNUhBRdgW1MFy5cwHfffYerV6/yyt+9e4evv/5ap4FppKNBdlSDJ6TyEgqFCAgIgIGBARwcHLB3714EBARQciflktoa/IEDB/Do0SM0a9YMP/zwAz58+IA2bdrghx9+wIULF9C5c+fSjDMfXQ2yoznwhFQeERERaNKkCcTi3L/7Bg0aYNu2bWjRogWMjIz0GB0hJaM2wf/1119YvXo1jI2N8dlnn2HevHk4evQoXF1dsW7dOtSsWbM048xPB4PsEhP5U+ToKXKEVEwpKSnYsGEDjhw5gpkzZ2LUqFG89R4eHnqKjBDtUZvgBQIBjI2NAQBWVlYQi8VYsGAB7OzsSi24guiiBp93ihwNkiWk4vn111+xfPly7nbbmzdvRpcuXWBvb6/nyAjRrgITvDIjI6Myk9wB3UyTo/53Qiqu2NhYrFixAufPn+eVe3p6wtDQUE9REaI7GkfRa8OePXvw5MkTCAQC+Pv7w9HRkVv3/v17bNy4EVlZWXBwcMD48eMLt1Omixo8PWSGkIpGoVDg+PHj+Prrr3n377CyssKCBQvg5eVFz2onFZLaBP/mzRsMHjyYW1YoFLxlADh06JDGAzx8+BAxMTFYvnw5oqOjsXXrVixfvpxbv2/fPvj4+MDDwwM7d+7E+/fvC/X8ZOUmem2NoqcBdoRULE+ePMGUKVNw8+ZNXnmfPn0wa9YsVK1aVU+REaJ7ahP8N998o5UDREREwN3dHQBgZ2eHDx8+IC0tDaamplAoFHj8+DG++OILAMDYsWMLv2MdzIOnJnpCKo4bN25g0qRJkEqlXJm9vT0CAwNpEB2pFNQmeG2Nkk9KSkL9+vW5ZQsLCyQlJcHU1BQSiQQmJibYs2cPnj9/jiZNmmDIkCGF2i9/kJ12+s/4N7mhBE9Ieda8eXPY2dkhMjISYrEY/v7+mDhxIjd4mJCKrlT64JUxxnjLCQkJ8Pb2hrW1NVauXInbt2/D1dW1wH3Y2toCb3KTetVq1VHV1rZEcSUmZv8DAGNjwNW1VqUeRW9bwvNJCofOs26tX78egYGB2LBhAz755BN9h1Nh0XVcNuk8wVtaWiIpKYlbTkxMhKWlJQDA3NwcNWrUQK1atQAATk5OiIqK0pjg37x5g6qpSajy33JSShrS3rwpUZx37xoAyG61qFdPhpiYuBLtrzyztbXFmxKeT6IZnWftuXTpEi5evIglS5bwBsy1a9cOe/fuhUAgoHOtI3Qdl47ifInSeR21RYsWuHbtGgDg2bNnsLS0hImJCQBAJBLBxsYGb9++5dYX+k1oeZAd9b8TUv68f/8es2bNwpQpU3Ds2DGcPn063zY0Qp5UVhpr8DKZDIcPH8aNGzcgl8uxZcsWhIeHw83NrVDJuFGjRqhfvz4WLVoEgUCAMWPG4OLFizA1NYWHhwf8/f2xefNmMMZgb2+Pli1bFipwAcvkftbGIDt6yAwh5QdjDGFhYQgODoZEIuHKt2/fDi8vL3qUKyEoRILfunUrTE1NMXPmTKxfvx4AULt2bezYsQMBAQGFOsjQoUN5y/Xq1eN+rlWrFpYtW1aEkLMJFLm1bG0Msnv2jGrwhJQHr169QlBQEK5fv84r9/X1xezZsym5E/IfjQn+33//5abM5fzhuLu7F2oOvE7x7mRX8qEE/NvUUoInpKyRyWTYu3cvtm7dypv6ZmdnhyVLlqBNmzZ6jI6QskdjZjQwMEBSUhKqVavGlUkkEr33awkUSk30WumDV76LHSV4QsqSBw8eICAgAP/88w9XJhQKMXLkSEyePJkb10MIyaUxwffs2RNz5sxBmzZtkJKSggMHDuD69evo06dPacSnHlNKwsKSNdEnJQmQmJid4I2NGWrXpqfIEVKWHDhwgJfcmzRpgqCgIDRt2lSPURFStmlM8F27doWdnR1u3rwJDw8PGBkZ4csvv4SDg0NpxKcWb5CdoGRN9MrN83XrZlXq+e+ElEVz5szB77//joyMDEyZMgXDhw/nPcOdEJKfxr+QjRs3ok2bNhg0aFDZ+oNSGmSHEg6yU07w1DxPiH4lJCTA0NAQZmZmXJmVlRXWrFmDOnXqoE6dOnqMjpDyQ2Nd9eOPP8apU6cwbtw4hISE4ObNm8jK0n8SFPDuRV+yLx7K/e80RY4Q/WCMITw8HL6+vtiwYUO+9W3atKHkTkgRaMyM3t7e8Pb2hkQiwa1bt3DhwgXs2LEDzZs3x5QpU0ojRpX4g+xKVoOnm9wQol/R0dEICgrCn3/+CQA4cuQIevbsCRcXFz1HRkj5A2fTzgAAIABJREFUVeiqr4WFBZo3b47MzExkZWXhzp07uoxLM94gu5KNoqcpcoToR1ZWFvbv34/NmzcjIyODK69VqxZkMlkBrySEaKIxwT9//hw3b97EzZs3kZCQAHd3d/Tq1UvvD27Q5iA7aqInpPQ9evQIAQEBePjwIVcmFAoxdOhQTJ06FaampnqMjpDyT2NmXLVqFTw8PDB8+HA0bdq07NwlSkuD7JKTBUhIyE7wRkYMtWtTgidEl9LT07Flyxbs27cPcnnu31vDhg0RFBQEJycnPUZHSMWhNsFLJBJYWFhg+fLlXFJXfiockD2yVV+0NciOpsgRUnpiYmLg7++P6OhorszQ0BCTJ0/GyJEjYWBQ8ptWEUKyqc2MAQEBWL9+fYED6Y4cOaKToApFaZBdSWrw/IfMUP87IbpkbW0NGxsbLsF7eHggICAAdevW1XNkhFQ8ahN8zoNlDh48qHL++/v373UXVSEIlAbZleRpcvyHzFDzPCG6JBQKERgYiFGjRmHatGno06eP3m97TUhFpbFBevbs2fnKFAoF5s2bp5OACku5ib4kz4Onm9wQohtv3rzBqlWr8o2Gd3BwwNmzZ9G3b19K7oTokNoa/K+//orw8HC8f/8e06dP563LyMiAhYWFzoMrkEKpD74ECV55Djw10RNScnK5HN9//z02bdqE9PR0WFtbY/To0bxtDA1L/ohnQkjB1Cb4Ll26oGXLlli8eDEmTJjAWycSifTbZ8bkECC7OZ1BAAhEGl6gHr8PnproCSmJf/75B4GBgYiIiODKtm7din79+qFq1ap6jIyQyqfAUfTVqlVDUFCQyvVpaWkwNjbWWWAFUuRpni9mM59EIkB8fO4UOVtbSvCEFIdUKsW3336L3bt3825l7ejoiMDAQEruhOiBxlH0kyZNUvtifY2i19YAO+X+d3t7miJHSHHcuHEDQUFBePnyJVdmYGCACRMmYMyYMTT1jRA90TiKXq9T4dRhylPkStL/TlPkCCmu5ORkfP311zh+/DivvGXLlggICED9+vX1FBkhBCjEneyio6Nx+/Zt+Pr6IioqCjt27IBAIMCoUaNQr169UggxP4EOBtjRFDlCiubw4cO85G5mZoYvv/wS/fv3Lzt3vCSkEtP4V7h161ZYW1sDAHbu3AlnZ2f06dMHO3fu1Hlw6uiiiZ5q8IQUjb+/P/clv2vXrggPD8eAAQMouRNSRmiswaelpaFVq1ZITk7Gy5cvsWTJEohEIuzfv7804lNNoa0mepoDT0hhKBQKpKam8qbHGhkZYenSpUhISEDXrl31GB0hRJVC3cRdKpXi6tWraN68OUQiEbKysngjZUub9mrwuX3w9etTEz0hqjx9+hQBAQGwsLDAli1beDencXV11WNkhJCCaEzwXl5emDhxIoRCIRYvXgwA2LRpE9zd3XUenFpaGGSXkiLA+/fZCd7QkJ4iR0hemZmZ2L59O3bu3Ml9of/ll1/g7e2t58gIIYWhMcF/9tln6NSpEwwMDCASZSfE/v37w97eXufBqaONQXZ5nyInKv69cgipcG7fvo2AgAA8f/6cKxOLxYiLi9NjVISQotCY4BljuHnzJu7duweJRIKqVavC1dVVrwkeyvehL2YT/bNnuRmdRtATki0lJQXr16/H0aNHeeUtWrRAUFAQHB0d9RQZIaSoNCb4/fv34/Hjx2jXrh3MzMyQkpKC0NBQREVF4fPPPy+NGPPRdg2eBtgRApw/fx4rVqxAbGwsV2ZqaooZM2Zg4MCBNDqekHJGY4K/e/cuVq1axXs4RJcuXbBgwQL9JXilQXbFrcHTFDlCsslkMsyePRvnz5/nlXfq1AkLFy5E7dq19RQZIaQkNCZ4hUKR71aThoaGYIzpLCiNlAbZFbcGz7+LHTXRk8rLwMAAJiYm3HL16tWxYMECdO/enR7nSkg5pjHBN2vWDKtXr0bXrl25JvoLFy6gWbNmpRGfStpuoqcaPKns5syZg6tXr6Jz58748ssv6eEwhFQAGhO8v78/Tp06hZ9++ok3yK5Hjx6lEZ9qJRxkl5IiQFxc7hQ5eoocqSxkMhn279+Pzz//HObm5ly5paUlwsPDUa1aNT1GRwjRJo0J3sDAAL1790bv3r1LI55CKWkN/uXL3OZ5e3uaIkcqh7t37yIwMBBPnz5FdHQ0lixZwltPyZ2QikVtgk9JScGuXbsQEREBsVgMT09PDBs2jDfYTm9KOMju2TN6yAypPFJTU7Fx40YcPnyYGztz9OhR9OnTB05OTnqOjhCiK2rnvXz33XcwNzdHUFAQ5s+fj/T0dBw8eLA0Y1NLUMJBdtT/TiqLixcvws/PD4cOHeKSu4mJCebOnYumTZvqOTpCiC6prcE/e/YMGzdu5JYnTJiAuXPnlkpQmig30RfnVrX0kBlS0b1//x4rV67EmTNneOXt27fH4sWLYWtrq6fICCGlRW2Cz3tTC7FYDIVCofOACkVpkF1xHjZDD5khFRVjDKGhoVi7di0kEglXbmVlhXnz5qFHjx409Y2QSqJQT5Mra0o6yI5q8KSiunjxYr7Bc71798asWbNoEB0hlYzaBP/+/Xt89dVXBZYtWrRId5EVpATT5FJTc6fIGRjQFDlSsXTq1Alubm64efMm7OzsEBAQgNatW+s7LEKIHqhN8GPGjMlX1q5dO50GU1gCVvwavHLzvL19FsTlsg2DkGwymYx3p0mBQIDAwECEhoZi4sSJvDvUEUIqF7XprVOnTqUYRhGVYJAdv3meau+kfEpLS0NISAhu3ryJ77//npfk69WrhxkzZugxOkJIWVAuHw8lKMEgO5oiR8q7K1euoHfv3ti/fz8ePXqEvXv36jskQkgZVC4bqEsyTU65Bk8JnpQnCQkJWL16NU6dOsUrv3fvHhhjNDqeEMJTLhN8SabJKffB01PkSHnAGEN4eDiCg4ORlJTElVerVg1z5syBj48PJXdCSD6FSvC3b9/GjRs3IJVKMX36dNy7dw+NGzeGkZGRruNTiT/Irmi3zqUpcuT/7d15VNRV/8Dx98ywCCoIoiLu5oKaoSmKpscnj1auSZpJpQ+5YqaY+xoguWWPK7ig5ZqmZZplVqYZZZYpueWGW4IIqCDIvsz8/uDHyMg2IOPwxc/rnOcc535n+XAf4jP3fu+9HyWJiIhg3rx5HDt2zKC9T58+TJ8+HUdHRzNFJoQo74q9B79nzx527dpF/fr1uXLlCgBXr14lJCTE5MEVymCK3vhJiORkFbGxD7fI1akjI3hRfm3duhVPT0+D5O7i4sLatWtZvHixJHchRJGKTfCHDh1i3rx59O7dG4v/31Pm6enJtWvXTB5cYUq7yO769YfT8/XqZcsWOVGuJSQkkJaWBuScLDls2DD27t1bbrarCiHKt2JTnEajQfNIPdXcohVmYzCCN36KXlbQCyUZNWoUP/zwA1ZWVvj7+0vlNyFEiRSb4N3c3Fi4cCEvvfQSGRkZhIWFcejQIdzc3J5EfAUyHMEbPwyX+++ivPr9999p0KABderU0bdZW1uzdu1aatasabDPXQghjFFsdsydFty7dy8WFhZ88803tG/fnpdfftnoD9m0aRPh4eGoVCq8vb1p0qRJvuds376dy5cv4+/vX+z75U3wJRvB5y0yIwlemN/9+/f56KOP2LdvHy+88AJr1641WBGfN+ELIURJFJvgLSwsGDRoEIMGDSrVB5w/f57o6Gjmz59PZGQka9asYf78+QbPiYyM5MKFC/luBRTKoNhMaUfwssBOmI9Op+PLL79k+vTpxMfHA3D06FG+++47+vTpY+bohBAVQbHZccKECYXusc1bL74wZ8+exd3dHYC6deuSnJxMSkoKtra2+uds2bKFIUOG8MUXXxgVdGkX2eW9By9T9MJcoqKimDdvHr/99ptB+yuvvELHjh3NFJUQoqIpNsH7+PgYPE5KSuK3334zesHP/fv3ady4sf6xnZ0d9+/f1yf4I0eO0LJlS2rUqGF81KVYZJeSoiImJmeGwMJCR926MoIXT1Z2djbbt29n5cqVpKam6ttr1arF3Llzy3f9ByGE4hSb4Fu2bJmvrX379vj5+dGzZ88Sf2DeFfhJSUn8/PPPzJ07l7i4OKPfw8ri4XvUqOUCDi7Fvub06Yf/btRIRf36xb/maebiIv1Tlv755x98fX0JCwvTt6lUKkaNGsXs2bOpWrWqGaOr2OR32fSkj8unUu0ET0pK4s6dO0Y918HBweB4zfj4eBwcHAA4d+4ciYmJ+Pn5kZmZSUxMDJs2bcLb27vI98zMSCV3Yj727n2yUqOKjeP48UpAzsEg9eqlERVl/BeKp42LiwtRUcX3qTBOZGQkffv2JSvr4W2hJk2aEBwcTJ06dXjw4AEPHjwwY4QVl/wum5708ZNRmi9RJb4Hr9VqiY+P58UXXzTqA9zc3Ni1axc9e/bk2rVrODg46GtUe3h44OHhAUBsbCyrV68uNrmDYbEZYxfZSZEZYS5169ald+/e7Nu3D0tLS3x8fBg+fDgNGjSQP4xCCJMp8T14tVpNtWrVcHZ2NuoDmjdvTuPGjZkzZw4qlYoRI0Zw5MgRbG1t6dChQ6mCVuky8gRk3D14wyIzkuCF6RRU2W3atGkkJyfj6+trsCZFCCFMpdgEf+jQIcaPH/9YH/LWW28ZPG7YsGG+59SsWdOoPfAAaB8maJ2R5WJli5wwNZ1Oxw8//MCGDRv49NNPsbOz01+rVq2aUbtOhBCirBR7Fn1WVhbnz59/ErEYrTQn2ckxtcKUbt++zXvvvceUKVO4ePEiy5YtM3dIQoinXLHZMS4ujgULFmBtbU2VKlUMrpltRFLCk+xSUlRER8sWOVH2srOz+fzzz1mxYgUpKSn69tDQUB48eCCr44UQZlNogk9LS6NSpUp4eXk9yXiMUtJFdnnvv0sVOVFWwsPD8ff353TePZjAG2+8wcSJEyW5CyHMqtBUN3PmTJYtW1bgPnhzM1xkV/w9eFlBL8pSeno6ISEhfPLJJwZb3xo1akRAQADPP/+8GaMTQogcih7L6tCAqvjz6+WIWlFWwsLC8PPz4/r16/o2CwsLRo0axahRo7CyMr74kRBCmFKhCT4jI4PLly8XWfu9efPmJgnKaEaeQ2+4RU7uv4vSu3HjhkFyb9OmDf7+/gVWSBRCCHMqNMHHxcWxcuXKQhO8SqUiKCjIZIEZo3Rb5GQEL0rP09OTb7/9ln/++Yf333+fwYMHo1YXuxlFCCGeuEITvLOzc7nf6mNsJTm5By9KIyYmhgcPHhiMzlUqFYGBgWg0GqMPexJCCHNQ9tDDiBF8aurDLXIajWyRE8XTarXs3LmTV199lalTp5KZmWlwvU6dOpLchRDlXqEJvlWrVk8yjlIxZor+0S1ylsaXjxdPoatXr+Lt7U1gYCBJSUmEh4ezceNGc4clhBAlVugU/ciRI59kHKVjxCl2Mj0vjJGRkcGGDRtYv369wYi9QYMGtG3b1oyRCSFE6Sh7m5wRp9jJEbWiOH///Tf+/v5cvXpV32ZhYcHw4cMZM2YM1tbWZoxOCCFKR9EJ3rhDbh5O0UuRGZFXUlISy5cvZ+fOnQa7RVq3bk1AQADNmjUzY3RCCPF4FJ3gjbkHL1P0oiAZGRkMGjSIyMhIfZuNjQ2+vr54eXmh0RR/gJIQQpRnil5FX9IEL3vgRS4rKyv69u2rf9y1a1f27dvH22+/LcldCFEhKHoEX9wiu0e3yNWrJ1P04qHRo0dz4sQJBg8eTK9evVCpVOYOSQghyozCR/BFL7L791/ZIidyjpcdO3aswXQ85IziN27cSO/evSW5CyEqHEUn+OIW2cn0/NMtMzOTdevW8dprr/Hrr78SGBiY7+hlSexCiIpK0Qm+uHvwhkVmJME/Tc6cOcPgwYNZtWoVGRk55YX/+OMPLl26ZObIhBDiyVD2PfhiErzhCF7uvz8NUlJSWLlyJZ999pnBaL1ly5YEBATg6upqxuiEEOLJUXSCL67YjGyRe7qEhoYSGBjI7du39W02NjaMGzeOt99+GwsLRf+6CyFEiSj6L15xU/RyD/7pcO/ePRYtWsSBAwcM2jt37swHH3xA3bp1zRSZEEKYj6ITfFGL7FJT4fZt2SL3NLhy5YpBcq9WrRrTp0+nb9++sohOCPHUqrCL7P799+F3l7p1s7Eq/th6oVAdO3ZkwIABAPTt25d9+/bRr18/Se5CiKeaskfwRSR4KTJTMWVlZXHz5k0aN25s0D516lR69erFCy+8YKbIhBCifFH2CL6IKXopMlPx/PPPP3h5eTF8+HASEhIMrtnb20tyF0KIPBSd4IsawcsK+oojJSWFJUuW4OXlxYULF7h79y7Lli0zd1hCCFGuKXqKvqgRfN4pellBr1xHjx4lMDDQ4JhZa2tr6tevj06nk/vsQghRCEUn+KJH8Hmn6CXBK018fDwfffQR33zzjUF7x44d8fPzo379+maKTAghlEHRCb6wVfSpqRAVlfOjqdU66teXe/BKodPp2L9/P4sXLyY+Pl7fbmdnx9SpUxkwYICM2oUQwgjKTvCFTNHfvClb5JRqxowZ7N+/36CtV69eTJ8+HScnJzNFJYQQylMhF9nJFjnl8vDw0P/b2dmZ4OBglixZIsldCCFKqEKO4GWLnHINGDCA7777jsaNGzNhwgQqV65s7pCEEEKRFJ3gCxvByxa58i8tLY01a9bQvXt33Nzc9O0qlYo1a9ZIYRghhHhMiv4rWtgiOykyU779+eef+Pv7ExERwS+//MIXX3yBpeXD/y8luQshxONT9D14nbrg1XM3bjycopcRfPmRkJDAnDlzGDFiBBEREUBOoZhvv/3WzJEJIUTFo+yhkip/+GlpEBWVk+Bli1z5oNPpOHDgAIsWLSIuLk7fXrVqVSZPnsyrr75qxuiEEKJiUnSCL2iR3c2bFuh0OfukZYuc+d2+fZvAwEBCQ0MN2nv27MmsWbOoUaOGmSITQoiKTdEJHlX+7J13el7uv5tPdnY2O3bsYOXKlaSkpOjba9WqxezZs+nevbsZoxNCiIpP0QleV8AU/bVreRfYyfS8udy6dYv//e9/ZGZm6tuGDBnCxIkTqVKlihkjE0KIp4OiF9lRwCI7OeSmfKhfvz6jRo0CoHHjxmzZsoU5c+ZIchdCiCekwo3gZYucedy9ezffaXMjR46katWqvPHGG1jJYgghhHiiFD2CL2iRXd578I0byxS9qSUmJuLv70+vXr30W99yWVlZMXToUEnuQghhBopO8I8usktLg1u3Hm6Rq1dPRvCmotPpOHjwIP379+fLL78kNTWVefPmodPpzB2aEEIIKtgUfUTEwy1ydepkY21tjqgqvpiYGObPn8/hw4cN2m1sbEhNTcXW1tZMkQkhhMil6AT/6CI7KTJjWlqtll27drF8+XKSkpL07U5OTsyePZsePXpIrXYhhCgnFJ3gHx3BS5EZ07l69Sr+/v78/fffBu2DBg1i0qRJ2NnZmSkyIYQQBVF0gs8/gpcV9Kawc+dOFi5cSFbWwz5t2LAhfn5+uLu7mzEyIYQQhXkiCX7Tpk2Eh4ejUqnw9vamSZMm+mvnzp1jx44dqNVqateujY+PD2q1cWv/Hq0mJ3vgTaNRo0b65G5hYcHw4cMZM2YM1rLIQQghyi2Tr6I/f/480dHRzJ8/Hx8fHzZu3GhwPSQkhEmTJhEYGEhaWhqnTp0y/s3zTdHnrSIn9+DLSocOHfD09OS5555j165dTJgwQZK7EEKUcyYfwZ89e1Y/jVu3bl2Sk5NJSUnRr7RetGiR/t92dnYGi7eKolNZQp4FXenpD7fIqVQ66teXEXxpHD58GCcnJ5577jmD9pkzZ2JtbY1GoynklUIIIcoTk4/g79+/b7AAy87Ojvv37+sf5yb3+Ph4Tp8+Tdu2bY1630en52WL3OO5c+cOkyZNYsKECUycOJGEhASD67a2tpLchRBCQZ74IruCDkJJSEhg8eLF+qNNjaHWWOHi4qJ/fPLkw2vNm1sYXBOF02q1bN26FT8/PxITEwGIjY1ly5YtLFy40MzRVXzye2p60semJ31cPpk8wTs4OBiM2OPj43FwcNA/TklJYcGCBXh5eeHm5mb0+2ZjQUxUlP7xyZOVAXsAXFySiYpKKOSVItf169cJCAjgxIkTBu1vvvkmw4YNIypP/4qy5+LiIn1sYtLHpid9/GSU5kuUyafo3dzc+OOPPwC4du0aDg4O2NjY6K9v2bKFPn360KZNm5K9cRF74GWLXNEyMzNZt24dAwcONEju9erVY8OGDQQFBWFvb2/GCIUQQjwuk4/gmzdvTuPGjZkzZw4qlYoRI0Zw5MgRbG1tcXNzIzQ0lOjoaP2xp126dKFHjx7Fvq/ukT3whkVmJMEX5syZM/j5+REeHq5v02g0eHt74+PjY/DlSwghhHI9kXvwb731lsHjhg0b6v+9ffv2Ur3no4vsDEfwskWuIGlpabz33nvExcXp21q2bMm8efNwdXU1Y2RCCCHKmnKryeUpFStb5IxTqVIlJk+eDOQUhpk6dSrbt2+X5C6EEBWQYo+qzTuCj4iwQKvN2SLn4pJNpUrmiqp8SU1NzTfl3r9/f27evImnpyd169Y1U2RCCCFMTbkj+DyL7OQEO0M6nY49e/bQs2fPfCcDqlQqxo8fL8ldCCEqOMUm+LyL7GQF/UM3b95k1KhRzJ07l/v37+Pv709mZqa5wxJCCPGEKTbBk2eKXorM5Gx9++STT/D09NRvS4ScaXrZoyqEEE8f5d6DV+dN8E/3FP0///yDn58fFy9e1Lep1WqGDh3KuHHj9McBCyGEeHooN8HnGcE/rVP0KSkpBAcHs3XrVrRarb7d1dUVf39/nn32WTNGJ4QQwpwUm+BzF9llZEBk5MMtcg0aPB0J/tSpU0yfPp1bt27p26ytrRk3bhxDhw7F0tKyiFcLIYSo6BSb4HMX2d28qdFvkatd++nZImdnZ0dsbKz+sYeHBx988AH169c3Y1RCCCHKC8UvsjNcYPf03H9v3LgxY8aMwc7Ojg8//JD169dLchdCCKGn4BF8ToJ/Gu6/R0ZGcuHCBXr27GnQPmLECF5//XWqV69upsiEEEKUV4pN8AWN4CtakZmsrCw+++wzgoKC0Ol0NG/e3GCUbmlpKcldCCFEgRQ7Rf9wBP9wi1xFKjJz8eJF3nzzTZYsWUJqaippaWl8+OGH5g5LCCGEQlSoEXxFOOQmNTWVNWvWsHnzZrKzH35hadq0Ke+9954ZIxNCCKEkik3wOpUlGRkQEfFwBK/0KnJ//PEHAQEBRERE6NusrKzw8fHhnXfeka1vQgghjKbcBK+2JCJCk6eKXBaPFE5TjISEBJYsWcLevXsN2tu3b4+/vz8NGzY0T2BCCCEUS7EJHpWlwfS8ku+/T5gwgZMnT+ofV61alcmTJ/Paa6+hVit2mYQQQggzUmz20KktDbbIKfn+e9576y+99BL79u1j0KBBktyFEEKUmsJH8HmLzCgjwWdnZ6NWq1GpVPo2d3d3Ro8ezbPPPkv37t3NGJ0QIld0dDTDhw+nWbNmQE7FxkaNGvH++++j0WhIS0tj9erVXLhwAQsLCxwcHJg4cSI1a9YEcs6vCAoKIiEhgezsbJ599ll8fHywsrIq6mOfuFOnTvHxxx8zcuRI/vOf/xT6vOjoaPz8/Fi3bl2ZfXZSUhIffvghycnJ2NjYMGfOHOzs7Ayek52dzezZsxk/fjx16tQps88uKWNi3bhxI8ePH0ej0TBmzBhat27Npk2b+Omnn3BycgKgZ8+eNG3alO3bt+Pv72/SmBU7RNSpLB855Kb8T9FfvnyZoUOHcuDAgXzXJkyYIMldiHKmXr16LF++nOXLlxMcHExWVhaHDh0CYPXq1VSvXp3169ezZs0avLy8mDZtGllZWWRnZ+Pn58eQIUNYs2aNPilu2bLFnD9OgU6fPs2AAQOKTO6msnv3btq0acOqVavo2rUrO3bsyPecffv20bp1a7Mmdyg+1vDwcE6ePElwcDALFy40+CI0cOBA/e9Rnz59aNasGdWrV+eXX34xaczKHcGrLRWzRS49PZ1169bx6aefkpWVxaJFi3jhhRewt7c3d2hCiBJo0aIFkZGRpKSkcPz4cT777DP9tdatW9OiRQuOHj2KjY0N9erVo02bNgCoVCrGjBljMHMHOYdZLVy4kJiYGKysrJg5cyYnT57k+vXrjB07ltTUVN555x0+//xz3n77bTp27IiDgwM//PADW7duBeD777/n6tWrvPHGGyxZsoTMzEw0Gg1TpkyhVq1aBp+3du1azp07R3Z2Np6enjRp0oQDBw5gYWGBo6OjwSBjx44dhIaGolKpGDVqFLVr19ZfO3jwIHv27EGtVtOqVSvGjh1LTEwMCxYsQK1Wk52dzaxZs1CpVPnanJ2d9e8TFhbGtGnTAOjcuTMzZ87M1+d79uwhKCgo3+c2bNiQKVOm8P333/Pnn39y79495s6dy2+//cahQ4dQq9V06dKFwYMHc+fOHRYsWKDv8xkzZhh8YTh27Bg7d+40+Ny+ffvSo0cPo2ONjIykWbNmqNVqqlatSpUqVYiOjs738+R67bXXWLRoEd26dSv0OY9LsQk+S2tpsEWuQYPyOYL/66+/CAgI4MaNG/q2xMREwsLCePHFF80XmBAKsnZtZZYurUpycmkmHV0KbK1cWcukSQ/w8Uk26l2ysrI4evQo/fv3Jyoqinr16qHRaAye06RJEyIiIqhUqRJNmjQxuGZtbZ3vPX/44QccHR2ZO3cuhw8f5vfffy/webmf37FjRzp06EBYWBjXr1+nUaNG/P777wwePJhPP/2UwYMH065dO/744w+2bt3KlClT9K8/ffo0N27cICgoiNTUVEaOHMn69et55ZVXsLe3N0jukZGRhIaGEhwczO3bt9m+fTtDhw7VX09LS+OJC4/SAAAYXElEQVSjjz6iSpUqTJ06lWvXrnHixAnatWvHsGHDuHz5MnFxcZw7dy5fW94EHxcXpx/oVKtWjbi4OIOfOSYmBktLS/1UeN7P9fX15dq1awDExsYSFBREdHQ0oaGhrFq1CoDx48fTrVs34uPjGTZsGG3btuW7777j66+/5t1339V/TqdOnejUqVOB/W5srI0aNWLbtm2kpaWRkpLClStX9M85cuQIR48exdLSkgkTJlC7dm3q1KlDbGwsaWlpVDJRlTTFJvi7cdZkZz+sImdjozNzRIYSExNZunQpX375pUF727Zt8ff355lnnjFTZEIoT0hIlVIm98IlJ6sJCalSZIKPiIhg4sSJAFy7dg0vLy+6dOnClStX0Gq1+Z6v0+n0i2MLuv6oy5cv8/zzzwPoE+z3339f6PNdXV0B6Nq1K8eOHaNOnTrcuHGDVq1asWTJEiIiIti6dStarZZq1aoZvPbSpUu4ubkBYGNjQ4MGDYiMjCzwc8LDw2nRogVqtZo6deowdepUg9GonZ0ds2fP1vdRYmIi7u7uzJ07l6SkJLp160arVq2wsbHJ11YS9+7do0aNGgV+7r///ktiYiIAzZs3R6VSceHCBSIjI3n//fcBSElJITo6mtq1a7Nq1So2bdrEgwcP9OsqylLDhg3p27cvU6ZMoXbt2vq/8R07dqRt27a4ublx+PBhVq5cycKFCwFwdHQkLi4OF5eCv4Q+LsUm+OjYh994ylORGZ1Ox8GDB1mwYAF3797Vt1euXJlJkybx+uuvy+p4IUpo9OikxxjBF6xyZS2jRycV+Zzce/AAfn5+1K1bFwAXFxciIiLIzMw0OIDq6tWrdOnSBUtLy3znWmRkZHDr1i0aNWqkb9NoNOh0hQ9OsrIM/7blflbXrl0JCAigUaNGtG/fHpVKhYWFBf7+/oXWp1CpVAaflZmZWejfIrVaXegXlMzMTFasWMGGDRtwdHQkICAAyBnBbtiwgRMnTrB+/Xp69erFyy+/XGBbrurVqxMXF0eVKlW4c+dOkbU1Hv3cvFPkuf1iaWmJh4cHkydPNnjt4sWLcXd3p3///vzyyy8cO3bM4LoxU/TGxOrp6YmnpycA48aNw9nZGUdHR/31zp07ExISUujPWNYUm2nyJvjyUmTm7t27+Pr6MmnSJIPk3r17d/bt28cbb7whyV2IUvDxSeby5Whu3Yoq0f90Ogq9dvlytNHT8zkx+LB+/XrS0tKwtbWlU6dObNq0SX/93LlzhIeH4+HhQfv27YmJieH3338HckbzISEh/Pzzzwbv2bx5c/7++28gJ8ls27aNypUrc+/ePQDOnj1bYCxOTk6oVCoOHTqkv4fbokULfvvtNyDnfvFPP/1k8BpXV1dOnToF5ByJHRUVVejCtebNm+vv1cfFxTF37lz9tZSUFDQaDY6OjsTGxnLu3DkyMzM5fPgw169fp0uXLowYMYJLly4V2JZX+/bt9QvNQkND6dChg8H16tWrc+fOnQI/99KlS2RmZho8v1mzZpw6dYq0tDR0Oh2rVq0iPT2dhIQEXFxc0Ol0HD16NN/rOnXqpF8El/u/vMndmFjv37/PjBkz0Ol0XL9+Ha1Wi6OjI6tWreLMmTNAzo6FvAeXxcfHG3wBKGuKHcHfup13BF8+7r+r1WrCwsL0j52cnJg9ezY9evTIt7hGCKEstWvXpmvXrmzdupVRo0bx3nvvERISwogRI7CyssLe3h5/f3/9ffmPPvqI//3vf2zevBlLS0vatWvHf//7X4P37N69OydPnsTX1xcLCwtmzJiBra0t27ZtY+LEiXh4eBQ6KOjcuTO7d+9m1qxZAHh7e7N48WIOHz4MwIwZMwye37p1a5o1a4avry9ZWVmMHj0am0KO/3R2duall17C19cXnU7HyJEj9dfs7e1p164dPj4+PPPMM4wcOZLg4GCmTZvGypUrsbGxQa1WM378eNLT01m2bJlBW14DBw5k/vz5TJgwgSpVquh/lly1atUiIyODBw8e5PvcIUOGEBwczKBBgwyeP3DgQHx9ffWL7KytrenXrx8rV67E2dkZT09Pli5dyl9//YW7u3uh/38/qrBYg4KCGDhwoH5afsyYMWg0Gv0sQp8+fVi6dCkajQa1Wq1fF3Hr1i2cnJxMdv8dQKUran6ovNquYtL+71m2PWeqZ8OGOHr1SjNzUDn27dvHrFmzeP3113n//ffz7ZNUAhcXF6KioswdRoUn/Wx60semZ+o+3r17NxkZGXh5eZnsM8whODiYli1bGr3YujT36RU7X3wz0rz34DMyMgrcw9ivXz+++OIL/Pz8FJnchRCiPBkwYACnT5+uUF/Urly5wp07d0y+k0qxCd6cU/RhYWEMGjSIcePGGUzJQ85ClhYtWjzReIQQoqLSaDQsWrTIZCvNzaFJkyYmP8UOFJzgUzNy9oo6Oz+5LXIPHjwgMDCQYcOG6fdf+vv7k5GR8UQ+XwghhDCWYhfZZWTlnOf8pE6wO3ToEPPnzyc2NlbfZmtry5AhQ/IddiGEEEKYm2ITfGZWzr5HUyf42NhYFixYkG/LSbdu3ZgzZ47B8Y1CCCFEeaHYBJ+RnTOCN9X9d61Wy+7du1m6dCkPHjzQtzs6OjJr1ixefvll2fomhBCi3FJsgjf1CD53/2penp6eTJkyRYrECPEUkHKxhkxRLhZyzmlfvHgxq1evNjjlL5eUiy09xSb43HvwptoiN2jQIHbs2EFGRgb16tXD39+fjh07muSzhBDlU96jagEWLVrEoUOHeOmllwzKxULOqXPTpk1jw4YNqFQq/Pz8GD9+PG3atNGfqrZlyxaDQ2PKA3OWiz116hR//vlnkbU5ylu52CFDhvDNN9+wY8cOxowZo7+et1xscnIyM2fO1FfBGzhwoP4I21y55WKlmlwBTD1F36hRI8aNG0diYiJjx4416WlDQghlkHKxOcqqXGyzZs1o06aNvqBPQaRcbOkpNsFnZlni7JyNre3jbZFLTk5mxYoVODs7M3z4cINrI0aMeKz3FkKUjcoRa6l6YynqbOPPjs9V2O5praYyDxpOIrmej1HvI+Viy75crK2tbZF9LuViH49iE3xGltVj338/cuQIH374IdHR0VhbW9OjRw/q169fRhEKIcpKlYiQUiX3oqizk6kSEVJkgpdysVIu1lhSLraMaLUqtDoNDRuW7vz5u3fvsmjRIoP/kNLT0/n666/zFUMQQphfUr3RpR7BF0arqUxSvdFFPkfKxeZXluViS0LKxZacIhP8w0NuSnb/XafTsWfPHj7++GP9Nz8ABwcHZsyYQe/evcs0TiFE2Uiu52P0VHpeZVkIxcfHh+nTp+Pu7m5QLnbUqFHAw3KxU6ZMQaVSsW7dOn7//Xc6d+6sLxdra2trkOBzy8X+5z//4dixY1y9epUGDRqUqFxsv379gIflYl999VXCwsKIi4szSFCurq5s3bqVN99806hysVu3biU7O5uEhASWLVvGuHHjgILLxfbu3ZvDhw9Tu3ZtunTpgr29PT///DOWlpb52kqS4EtTLjYkJIS0tDSsra0JCgpi9OjR+crFZmcb5g5jpuhzy8UOHTq00HKxixYtYuHChdy4ccOgXGy3bt147rnnpFysMR4usDN+iv7mzZsEBATw559/GrT379+fqVOn4uDgUKYxCiEqFikXm6Msy8Xu37+fgwcPcuXKFRYvXkz9+vUNSsZKudjHo8hysffWVcfJ5x4//hhLq1ZFJ/nMzEw2b97MmjVrSE9P17fXrVuXDz74gM6dO5s6XMWREptPhvSz6Ukfm56Uiy0dKRdbiJJM0Wu1Wvbu3atP7mq1Gm9vb7766itJ7kIIUc5JudjSU2aCz7aiVi3jtshZW1vj5+cH5Nyj2rFjB1OmTCl2e4YQQgjzk3KxpafIe/CZWZaFbpE7e/Yszz77rMGBEu7u7qxduxYPDw8sLBT5IwshhBAlotgR/KML7OLi4pg+fTpeXl4cOHAg32u6dOkiyV0IIcRTQ5EJPmcEn3P/XafTsW/fPvr378/+/fuBnPOi79+/b84QhRBCCLNS5JA2IytnBB8ZGUlAQEC+QwuK288ohBBCVHRPJMFv2rSJ8PBwVCoV3t7eBmc0nzlzhh07dqBWq2nbtq3BnsbCpGZacu7cOvz9V5GW9vA0OxcXF+bOnUvXrl1N8nMIIYQQSmHyKfrz588THR3N/Pnz8fHxYePGjQbXN27cyOTJkwkMDOTMmTOFno2c16Sd/7Jt2xJ9cler1QwdOpS9e/dKchdCCCF4AiP4s2fP6k8Lqlu3LsnJyaSkpGBra0tMTAxVqlTByckJgLZt23L27Fn9ec+FuXYnVf/vpk2bMm/ePFq3bm26H0IIIYRQGJOP4O/fv68v9Qc51YByF8A9es3e3p74+Hij3tfKygpfX1927dolyV0IIYR4xBNfZFfUybjGnpr7aB1eUfYq0qES5Zn0s+lJH5ue9HH5ZPIRvIODg8GWtfj4eH1hl0evxcXFmbSyjhBCCPG0MHmCd3Nz448//gDg2rVrODg46CsY1axZk9TUVGJjY8nOziYsLIznnnvO1CEJIYQQFd4TqSb32WefceHCBVQqFSNGjODGjRvY2trSoUMHzp8/z2effQZAx44d6d+/v6nDEUIIISo8RZaLFUIIIUTRFHlUrRBCCCGKJgleCCGEqIDK9Vn0ZX3ErcivqD4+d+6cvo9r166Nj48ParV8Jyypovo41/bt27l8+fITqRFdERXVx3fv3mXFihVkZWXRqFEjRo8ebcZIla2ofv7+++/59ddfUavVPPPMM3h7e5svUAW7efMmS5YsoU+fPrzyyisG10qa98rtX2tTHHErDBXXxyEhIUyaNInAwEDS0tI4deqUmSJVruL6GCAyMpILFy6YIbqKobg+3rJlC/369WPhwoWo1Wru3r1rpkiVrah+TklJ4ZtvvmHevHkEBgYSGRnJ5cuXzRitMqWlpbFx40aeffbZAq+XNO+V2wRf2BG3gMERt7nfZM6ePWvOcBWpqD6GnLK71atXB3JOIExKSjJLnEpWXB9DTgIaMmSIOcKrEIrqY61Wy8WLF2nfvj0AI0eO1B+NLUqmqH62sLDAwsKCtLQ0srOzSU9Pp0qVKuYMV5EsLS2ZOXOm/qyYvEqT98ptgjfVEbfioaL6GMDW1hbIOZzo9OnTtG3b9onHqHTF9fGRI0do2bIlNWrUMEd4FUJRfZyYmIiNjQ2bNm1i7ty5bN++3VxhKl5R/WxlZcWgQYN47733ePfdd2natKmcblcKGo0GKyurAq+VJu+V2wT/qLI44lYUraB+TEhIYPHixYwcOZKqVauaIaqKJW8fJyUl8fPPP9O3b18zRlTxPPp7HBcXR+/evQkICOD69euEhYWZKbKKJW8/p6SksGfPHlasWEFwcDDh4eHcuHHDfME9BYzJe+U2wcsRt6ZXVB9Dzn+0CxYsYMiQIbi5uZkjRMUrqo/PnTtHYmIifn5+fPzxx1y/fp1NmzaZKVLlKqqPq1atipOTE87OzqjValq3bk1ERIS5QlW0ovr51q1b1KxZEzs7OywsLGjRogXXrl0zV6gVUmnyXrlN8HLErekV1ceQc2+4T58+tGnTxlwhKl5Rfezh4cGyZcuYP38+U6ZMoVGjRrLyuBSK6mONRkOtWrW4ffu2/rpMHZdOUf1co0YNbt26RUZGBgBXr16ldu3aZou1IipN3ivXJ9nJEbemV1gfu7m58c4779CsWTP9c7t06UKPHj3MGK0yFfV7nCs2NpbVq1fLNrlSKqqPo6OjCQ4ORqfTUb9+fUaOHCnbPUupqH4+ePAgR44cQa1W07x5c95++21zh6s4165dY8uWLdy5cweNRoOjoyPt27enZs2apcp75TrBCyGEEKJ05GusEEIIUQFJghdCCCEqIEnwQgghRAUkCV4IIYSogCTBCyGEEBVQua4mJ0RFMHjwYGrVqoVGo9G31ahRg9mzZxf6mtjYWCZMmMDnn3/+2J//zz//8OGHH1KrVi0g53z22rVrM3z4cH1bSc2bN4+3336bxo0b89NPP+m3T+Ztf1yP9lt2djYtW7bknXfeoVKlSkW+Njw8HCsrKxo0aPDYcQihVJLghXgC/P399YV7zMHJyYnly5frH+/du5eVK1cyf/78Ur3fBx98AOR8Wdi2bZs+wee2l5W8/ZaZmcny5cvZs2cPXl5eRb7u559/xtXVVRK8eKpJghfCjKKiolizZg1JSUlkZWXxxhtv0KVLF4PnxMXFERQURHx8PFlZWXTu3BkvLy90Oh27d+/m119/JTMzE3d3d/773/8adYjLK6+8wvbt20lJSaFSpUrs3LmTP//8E4CmTZsyYsQIKlWqxLFjx/jyyy/RarVoNBreeecdWrVqxbhx4xg/fjw7d+4kJSWFiRMnMmvWLAICAhg/fjybN2/m1VdfxcPDA4Djx4/z9ddfM3/+fP766y8+//xz0tPTcXZ2ZsKECQZFNApjaWlJmzZtOHHiBADp6emsXr2aGzdukJWVRceOHRk2bBg//vgjoaGhnDx5ksTERPr06VPqfhJCyeQ3XAgz2rJlC+3atWPZsmWMHTuWtWvXkpWVZfCc/fv306JFC5YtW8bHH39MTEwM8fHx/Prrrxw7doyFCxeyatUqYmJi+PHHH436XK1Wi0qlwsLCgmPHjnHq1CkWLVrE0qVLSU5OZv/+/QBs2LCBGTNmsGzZMkaOHKlPrrnGjh2LWq1m+fLl1KxZU9/u4eFh8Nzjx4/TqVMnYmJiCAoKwtfXl6CgIFq1asX69euNijkpKYnffvuN5s2bA/Djjz+SlpbG8uXLWbx4Mb/88gsXL17kpZdeokmTJrz11lv07dv3sfpJCCWTEbwQT4C/v7/BPXhXV1d8fHyYNm2aQVtmZqZBQQnIKQt5/PhxWrduTbNmzZg4cSIAJ06c4MUXX9SX9e3evTsHDhzglVdeKTIWrVbL119/TZs2bbCysiIsLIxu3brp72u/+OKLfPvttwwcOBB7e3sOHjxIz549cXV1xdXV1aif18PDg3379qHVatHpdPz9998MGTKEkydP0rJlS+rXrw9Az549GTVqFFqttsARdW6/ZWVlkZSURN++fXn11VcB6NevH7169UKlUlGlShXq1q1LTExMvhhL209CKJ0keCGegMLuwZ8+fZqvvvqKxMREVCoVOp0OrVZr8Jw+ffqg1WrZsGED8fHxvPzyy7z++uukpKTwzTff8NNPPwE5i9AKm+q+e/eu/osBQJMmTRg3bhyQUzO9cuXK+muVK1cmISEBgGnTpvHVV18xY8YMqlevjre3Ny1btiz2561VqxZOTk5cunSJ7OxsXFxccHJyIjk5mQsXLhjEYmtry4MHD7C3ty+03xITE/H19aVz5876L0q3b99m8+bNREVFoVaruXfvHi+++GK+9yhJPwlRkUiCF8JMsrKyWLp0Ke+//z7PP/88mZmZBRbo0Gg0DBgwgAEDBhAVFcXChQtxdXXFwcGB9u3bGzUSfXSRXV729vY8ePBA/zgpKUmfbJ2dnXn33XfRarWEhoayYsUK1q1bZ9TP17FjR06cOEFmZiadOnUCwNHRkdatWzN58mSj3iOXnZ0dvXr1Ytu2bfpZj08++YTGjRszbdo01Go1c+fOLfC1JeknISoSuQcvhJmkp6eTnp7OM888A8B3332HhYUFaWlpBs8LCQnhzJkzQE7CrVatGgDu7u6EhoaSnp4OoK/mVVLt2rXj119/JT09nezsbA4fPszzzz9PYmIigYGBpKSkoFaradq0KSqVyuC1FhYW6HQ6UlNT872vh4cHZ8+eJSwsTL/Yzs3NjYsXLxITEwPAlStX2Lhxo1Fx9uvXj0uXLnH+/HkAEhISaNiwIWq1mjNnznD79m1932k0GlJSUsq0n4RQGhnBC2EmlStXpn///kybNg17e3tee+013N3dWbx4MTNmzNA/r2fPnoSEhPDpp5+i0+lo164drVu3BiAiIoLp06cDOdPiY8eOLXEcHh4e/Pvvv8yYMQOdTkerVq3o1asXVlZWtGnThpkzZ6JWq7GwsMDHx8fgtdWqVcPV1ZV3333XIGYAFxcXdDodjo6OODo6Ajmj6TFjxvDxxx+TlZVFpUqV8Pb2NipOGxsbBgwYwNatW1mwYAEDBw5k8+bN7N69G3d3dwYNGsSuXbto2LAhHTp0YNu2bcTExDBs2LAy6SchlEbKxQohhBAVkEzRCyGEEBWQJHghhBCiApIEL4QQQlRAkuCFEEKICkgSvBBCCFEBSYIXQgghKiBJ8EIIIUQFJAleCCGEqIAkwQshhBAV0P8B3GCzIrGLmPoAAAAASUVORK5CYII=\n","text/plain":["<Figure size 576x396 with 1 Axes>"]},"metadata":{"tags":[]}}]},{"cell_type":"markdown","metadata":{"id":"vHcgXahESLKc"},"source":["-----"]}]}