├── .gitignore
├── README.md
├── capture_img.ipynb
├── deepfake_detection_train.ipynb
└── model_play.ipynb


/.gitignore:
--------------------------------------------------------------------------------
1 | .gitignore
2 | sample_submission.csv
3 | deepfake-detection-model.h5
4 | dataset/
5 | test_videos/
6 | train_sample_videos/
7 | .ipynb_checkpoints/


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # deepfake_detection
 2 | 
 3 | 
 4 | Detect the video is fake or not using InceptionResNetV2.
 5 | 
 6 | 
 7 | The dataset was downloaded from kaggle deepfake detection challenge: https://www.kaggle.com/c/deepfake-detection-challenge/data
 8 | 
 9 | Experimental steps
10 | 
11 | Step1.
12 | run capture_img -> use the dlib face detecter to convert video to face img.
13 | 
14 | Step2.
15 | run deepfake_detection_train -> training the dataset from capture_img and output the model file.
16 | 
17 | Step3.
18 | run model_play -> load model then input video to detect the video is fake or not. [0]: fake, [1]: real
19 | 


--------------------------------------------------------------------------------
/capture_img.ipynb:
--------------------------------------------------------------------------------
 1 | {
 2 |  "cells": [
 3 |   {
 4 |    "cell_type": "code",
 5 |    "execution_count": 1,
 6 |    "metadata": {},
 7 |    "outputs": [],
 8 |    "source": [
 9 |     "import dlib\n",
10 |     "import cv2\n",
11 |     "import os\n",
12 |     "import re\n",
13 |     "import json\n",
14 |     "from pylab import *\n",
15 |     "from PIL import Image, ImageChops, ImageEnhance"
16 |    ]
17 |   },
18 |   {
19 |    "cell_type": "code",
20 |    "execution_count": 2,
21 |    "metadata": {},
22 |    "outputs": [],
23 |    "source": [
24 |     "train_frame_folder = 'train_sample_videos'\n",
25 |     "with open(os.path.join(train_frame_folder, 'metadata.json'), 'r') as file:\n",
26 |     "    data = json.load(file)\n",
27 |     "list_of_train_data = [f for f in os.listdir(train_frame_folder) if f.endswith('.mp4')]\n",
28 |     "detector = dlib.get_frontal_face_detector()\n",
29 |     "for vid in list_of_train_data:\n",
30 |     "    count = 0\n",
31 |     "    cap = cv2.VideoCapture(os.path.join(train_frame_folder, vid))\n",
32 |     "    frameRate = cap.get(5)\n",
33 |     "    while cap.isOpened():\n",
34 |     "        frameId = cap.get(1)\n",
35 |     "        ret, frame = cap.read()\n",
36 |     "        if ret != True:\n",
37 |     "            break\n",
38 |     "        if frameId % ((int(frameRate)+1)*1) == 0:\n",
39 |     "            face_rects, scores, idx = detector.run(frame, 0)\n",
40 |     "            for i, d in enumerate(face_rects):\n",
41 |     "                x1 = d.left()\n",
42 |     "                y1 = d.top()\n",
43 |     "                x2 = d.right()\n",
44 |     "                y2 = d.bottom()\n",
45 |     "                crop_img = frame[y1:y2, x1:x2]\n",
46 |     "                if data[vid]['label'] == 'REAL':\n",
47 |     "                    cv2.imwrite('dataset/real/'+vid.split('.')[0]+'_'+str(count)+'.png', cv2.resize(crop_img, (128, 128)))\n",
48 |     "                elif data[vid]['label'] == 'FAKE':\n",
49 |     "                    cv2.imwrite('dataset/fake/'+vid.split('.')[0]+'_'+str(count)+'.png', cv2.resize(crop_img, (128, 128)))\n",
50 |     "                count+=1"
51 |    ]
52 |   }
53 |  ],
54 |  "metadata": {
55 |   "kernelspec": {
56 |    "display_name": "Python 3",
57 |    "language": "python",
58 |    "name": "python3"
59 |   },
60 |   "language_info": {
61 |    "codemirror_mode": {
62 |     "name": "ipython",
63 |     "version": 3
64 |    },
65 |    "file_extension": ".py",
66 |    "mimetype": "text/x-python",
67 |    "name": "python",
68 |    "nbconvert_exporter": "python",
69 |    "pygments_lexer": "ipython3",
70 |    "version": "3.7.4"
71 |   }
72 |  },
73 |  "nbformat": 4,
74 |  "nbformat_minor": 4
75 | }
76 | 


--------------------------------------------------------------------------------
/deepfake_detection_train.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "import os\n",
 10 |     "import cv2\n",
 11 |     "import json\n",
 12 |     "import tensorflow as tf\n",
 13 |     "import numpy as np\n",
 14 |     "import matplotlib.pyplot as plt\n",
 15 |     "import seaborn as sn\n",
 16 |     "import pandas as pd\n",
 17 |     "from tensorflow.keras.preprocessing.image import ImageDataGenerator, img_to_array, load_img\n",
 18 |     "from tensorflow.keras.utils import to_categorical\n",
 19 |     "from sklearn.model_selection import train_test_split\n",
 20 |     "from sklearn.metrics import confusion_matrix"
 21 |    ]
 22 |   },
 23 |   {
 24 |    "cell_type": "code",
 25 |    "execution_count": 2,
 26 |    "metadata": {},
 27 |    "outputs": [],
 28 |    "source": [
 29 |     "input_shape = (128, 128, 3)\n",
 30 |     "data_dir = 'dataset'\n",
 31 |     "\n",
 32 |     "real_data = [f for f in os.listdir(data_dir+'/real') if f.endswith('.png')]\n",
 33 |     "fake_data = [f for f in os.listdir(data_dir+'/fake') if f.endswith('.png')]\n",
 34 |     "\n",
 35 |     "X = []\n",
 36 |     "Y = []\n",
 37 |     "\n",
 38 |     "for img in real_data:\n",
 39 |     "    X.append(img_to_array(load_img(data_dir+'/real/'+img)).flatten() / 255.0)\n",
 40 |     "    Y.append(1)\n",
 41 |     "for img in fake_data:\n",
 42 |     "    X.append(img_to_array(load_img(data_dir+'/fake/'+img)).flatten() / 255.0)\n",
 43 |     "    Y.append(0)\n",
 44 |     "\n",
 45 |     "Y_val_org = Y\n",
 46 |     "\n",
 47 |     "#Normalization\n",
 48 |     "X = np.array(X)\n",
 49 |     "Y = to_categorical(Y, 2)\n",
 50 |     "\n",
 51 |     "#Reshape\n",
 52 |     "X = X.reshape(-1, 128, 128, 3)\n",
 53 |     "\n",
 54 |     "#Train-Test split\n",
 55 |     "X_train, X_val, Y_train, Y_val = train_test_split(X, Y, test_size = 0.2, random_state=5)\n"
 56 |    ]
 57 |   },
 58 |   {
 59 |    "cell_type": "code",
 60 |    "execution_count": 3,
 61 |    "metadata": {},
 62 |    "outputs": [
 63 |     {
 64 |      "name": "stdout",
 65 |      "output_type": "stream",
 66 |      "text": [
 67 |       "Model: \"sequential\"\n",
 68 |       "_________________________________________________________________\n",
 69 |       "Layer (type)                 Output Shape              Param #   \n",
 70 |       "=================================================================\n",
 71 |       "inception_resnet_v2 (Model)  (None, 2, 2, 1536)        54336736  \n",
 72 |       "_________________________________________________________________\n",
 73 |       "global_average_pooling2d (Gl (None, 1536)              0         \n",
 74 |       "_________________________________________________________________\n",
 75 |       "dense (Dense)                (None, 2)                 3074      \n",
 76 |       "=================================================================\n",
 77 |       "Total params: 54,339,810\n",
 78 |       "Trainable params: 54,279,266\n",
 79 |       "Non-trainable params: 60,544\n",
 80 |       "_________________________________________________________________\n"
 81 |      ]
 82 |     }
 83 |    ],
 84 |    "source": [
 85 |     "from tensorflow.keras.applications import InceptionResNetV2\n",
 86 |     "from tensorflow.keras.layers import Conv2D\n",
 87 |     "from tensorflow.keras.layers import MaxPooling2D\n",
 88 |     "from tensorflow.keras.layers import Flatten\n",
 89 |     "from tensorflow.keras.layers import Dense\n",
 90 |     "from tensorflow.keras.layers import Dropout\n",
 91 |     "from tensorflow.keras.layers import InputLayer\n",
 92 |     "from tensorflow.keras.layers import GlobalAveragePooling2D\n",
 93 |     "from tensorflow.keras.models import Sequential\n",
 94 |     "from tensorflow.keras.models import Model\n",
 95 |     "from tensorflow.keras import optimizers\n",
 96 |     "from tensorflow.keras.callbacks import ReduceLROnPlateau, EarlyStopping\n",
 97 |     "\n",
 98 |     "googleNet_model = InceptionResNetV2(include_top=False, weights='imagenet', input_shape=input_shape)\n",
 99 |     "googleNet_model.trainable = True\n",
100 |     "model = Sequential()\n",
101 |     "model.add(googleNet_model)\n",
102 |     "model.add(GlobalAveragePooling2D())\n",
103 |     "model.add(Dense(units=2, activation='softmax'))\n",
104 |     "model.compile(loss='binary_crossentropy',\n",
105 |     "              optimizer=optimizers.Adam(lr=1e-5, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False),\n",
106 |     "              metrics=['accuracy'])\n",
107 |     "model.summary()"
108 |    ]
109 |   },
110 |   {
111 |    "cell_type": "code",
112 |    "execution_count": 4,
113 |    "metadata": {},
114 |    "outputs": [
115 |     {
116 |      "name": "stdout",
117 |      "output_type": "stream",
118 |      "text": [
119 |       "Train on 2996 samples, validate on 749 samples\n",
120 |       "Epoch 1/20\n",
121 |       "2996/2996 [==============================] - 57s 19ms/sample - loss: 0.5870 - accuracy: 0.7196 - val_loss: 0.5837 - val_accuracy: 0.7690\n",
122 |       "Epoch 2/20\n",
123 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.4450 - accuracy: 0.8508 - val_loss: 0.5882 - val_accuracy: 0.7704\n",
124 |       "Epoch 3/20\n",
125 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.3490 - accuracy: 0.9035 - val_loss: 0.5590 - val_accuracy: 0.7864\n",
126 |       "Epoch 4/20\n",
127 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.2736 - accuracy: 0.9346 - val_loss: 0.4907 - val_accuracy: 0.8238\n",
128 |       "Epoch 5/20\n",
129 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.2148 - accuracy: 0.9513 - val_loss: 0.4456 - val_accuracy: 0.8518\n",
130 |       "Epoch 6/20\n",
131 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.1752 - accuracy: 0.9636 - val_loss: 0.4021 - val_accuracy: 0.8678\n",
132 |       "Epoch 7/20\n",
133 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.1363 - accuracy: 0.9760 - val_loss: 0.3899 - val_accuracy: 0.8625\n",
134 |       "Epoch 8/20\n",
135 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.1041 - accuracy: 0.9813 - val_loss: 0.3871 - val_accuracy: 0.8598\n",
136 |       "Epoch 9/20\n",
137 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0867 - accuracy: 0.9863 - val_loss: 0.3565 - val_accuracy: 0.8852\n",
138 |       "Epoch 10/20\n",
139 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0662 - accuracy: 0.9893 - val_loss: 0.3455 - val_accuracy: 0.8959\n",
140 |       "Epoch 11/20\n",
141 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0615 - accuracy: 0.9877 - val_loss: 0.3213 - val_accuracy: 0.9092\n",
142 |       "Epoch 12/20\n",
143 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0474 - accuracy: 0.9903 - val_loss: 0.3126 - val_accuracy: 0.9012\n",
144 |       "Epoch 13/20\n",
145 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0401 - accuracy: 0.9917 - val_loss: 0.3023 - val_accuracy: 0.9105\n",
146 |       "Epoch 14/20\n",
147 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0342 - accuracy: 0.9927 - val_loss: 0.2971 - val_accuracy: 0.9146\n",
148 |       "Epoch 15/20\n",
149 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0292 - accuracy: 0.9950 - val_loss: 0.2920 - val_accuracy: 0.9172\n",
150 |       "Epoch 16/20\n",
151 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0261 - accuracy: 0.9957 - val_loss: 0.3000 - val_accuracy: 0.9159\n",
152 |       "Epoch 17/20\n",
153 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0233 - accuracy: 0.9963 - val_loss: 0.3005 - val_accuracy: 0.9079\n",
154 |       "Epoch 18/20\n",
155 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0190 - accuracy: 0.9963 - val_loss: 0.3069 - val_accuracy: 0.9092\n",
156 |       "Epoch 19/20\n",
157 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0171 - accuracy: 0.9963 - val_loss: 0.2977 - val_accuracy: 0.9146\n",
158 |       "Epoch 20/20\n",
159 |       "2996/2996 [==============================] - 21s 7ms/sample - loss: 0.0142 - accuracy: 0.9973 - val_loss: 0.2997 - val_accuracy: 0.9172\n"
160 |      ]
161 |     }
162 |    ],
163 |    "source": [
164 |     "#Currently not used\n",
165 |     "early_stopping = EarlyStopping(monitor='val_loss',\n",
166 |     "                               min_delta=0,\n",
167 |     "                               patience=2,\n",
168 |     "                               verbose=0, mode='auto')\n",
169 |     "EPOCHS = 20\n",
170 |     "BATCH_SIZE = 100\n",
171 |     "history = model.fit(X_train, Y_train, batch_size = BATCH_SIZE, epochs = EPOCHS, validation_data = (X_val, Y_val), verbose = 1)"
172 |    ]
173 |   },
174 |   {
175 |    "cell_type": "code",
176 |    "execution_count": 5,
177 |    "metadata": {},
178 |    "outputs": [
179 |     {
180 |      "data": {
181 |       "image/png": "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\n",
182 |       "text/plain": [
183 |        "<Figure size 1440x288 with 2 Axes>"
184 |       ]
185 |      },
186 |      "metadata": {
187 |       "needs_background": "light"
188 |      },
189 |      "output_type": "display_data"
190 |     }
191 |    ],
192 |    "source": [
193 |     "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 4))\n",
194 |     "t = f.suptitle('Pre-trained InceptionResNetV2 Transfer Learn with Fine-Tuning & Image Augmentation Performance ', fontsize=12)\n",
195 |     "f.subplots_adjust(top=0.85, wspace=0.3)\n",
196 |     "\n",
197 |     "epoch_list = list(range(1,EPOCHS+1))\n",
198 |     "ax1.plot(epoch_list, history.history['accuracy'], label='Train Accuracy')\n",
199 |     "ax1.plot(epoch_list, history.history['val_accuracy'], label='Validation Accuracy')\n",
200 |     "ax1.set_xticks(np.arange(0, EPOCHS+1, 1))\n",
201 |     "ax1.set_ylabel('Accuracy Value')\n",
202 |     "ax1.set_xlabel('Epoch #')\n",
203 |     "ax1.set_title('Accuracy')\n",
204 |     "l1 = ax1.legend(loc=\"best\")\n",
205 |     "\n",
206 |     "ax2.plot(epoch_list, history.history['loss'], label='Train Loss')\n",
207 |     "ax2.plot(epoch_list, history.history['val_loss'], label='Validation Loss')\n",
208 |     "ax2.set_xticks(np.arange(0, EPOCHS+1, 1))\n",
209 |     "ax2.set_ylabel('Loss Value')\n",
210 |     "ax2.set_xlabel('Epoch #')\n",
211 |     "ax2.set_title('Loss')\n",
212 |     "l2 = ax2.legend(loc=\"best\")"
213 |    ]
214 |   },
215 |   {
216 |    "cell_type": "code",
217 |    "execution_count": 6,
218 |    "metadata": {},
219 |    "outputs": [
220 |     {
221 |      "name": "stdout",
222 |      "output_type": "stream",
223 |      "text": [
224 |       "True positive =  2949\n",
225 |       "False positive =  37\n",
226 |       "False negative =  42\n",
227 |       "True negative =  717\n",
228 |       "\n",
229 |       "\n"
230 |      ]
231 |     },
232 |     {
233 |      "data": {
234 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEdCAYAAAAikTHKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd1gVx/rA8e+hC4jGhmIsWEAFsaBgR0GNSSR27HrFGoOF2LvXqLHG2KLEilxLomKLGo3RWBIVsUfF3rBQVER6298f/DzJkeIBkYPwfu6zz3OZnZ19DxJeZmZ3RqUoioIQQgiRRXq6DkAIIcSHSRKIEEKIbJEEIoQQIlskgQghhMgWSSBCCCGyRRKIEEKIbJEEIoQQIlskgQghhMgWSSBCCCGyRRKIEEKIbDHQdQCvvXr1Cj8/P06ePEl4eDhLlizhyJEjVKtWjWbNmuk6PCGEEG/IEz2Q4OBg3N3dWb9+Pebm5ty7d4+EhASuX7/Ol19+ydGjR3UdohBCiDfkiR7IrFmzKFmyJOvXr8fY2Bh7e3sAFi5cSFJSEj/88AMuLi5Zbjcx/E5Ohyo+cIWsmuo6BJFHJSU8eqfrs/L7xrBEpXe6V16RJ3ogp06dYvDgwZiZmaFSqTTOdevWjRs3bugoMiGE0FJKsvZHPpEneiBGRkbEx8eney4iIgIjI6NcjkgIIbJISdF1BLkuT/RAXFxc+P7777l37566TKVSERERwY8//kiTJk10F5wQQmgjJUX7I59Q5YUNpZ4/f07v3r25f/8+FSpU4Pbt21SvXp3g4GCKFCnCxo0bsbS0zHK7Mgci3iRzICIj7zoHkvD4itZ1jazs3uleeUWeSCAA8fHx7Nixg4CAACIiIjA3N8fR0ZFOnTphbm6erTYlgYg3SQIRGXnnBPLwotZ1jcrVeqd75RV5IoEkJSVhYJDxdMzZs2dxdHTMcruSQMSbJIGIjLxzArl/Tuu6RhXqvtO98oo8MQfy5ZdfkpCQkKb85cuXTJw4kd69e+sgKiGEyAIlRfsjn8gTCeTq1asMGDCAmJgYddmOHTv49NNP2bdvH8OGDdNhdEIIoYUCOImeJxLI5s2befz4Mf369ePcuXP07t2bCRMm4OjoyL59+/jyyy91HaIQQmRKUVK0PvKLPJFAypcvz+bNm4mPj6dnz56EhYWxZs0ali5dipWVla7DE0KItyuAPRCdvUgYERGh8bWhoSFLly5lxIgRREdHU6ZMGY06RYsWze0QhRBCe8mJuo4g1+ksgTRo0CDNsiUArx8K+/zzzzXKr127litxCSFEtuSjoSlt6SyBzJ49O90EIoQQH6R8NDSlLZ0lkI4dO+rq1kIIkfOkB6I7N27c4MyZMyQmJqqHsRRFITY2lgsXLrBq1SodRyiEEJmQHohu/PTTT0yfPh1FUVCpVPz75Xg9PT0aNWqkw+iEEOLtlJSCN4meJx7jXbduHc2bN+f06dP079+fLl26cOHCBZYsWUKhQoVo27atrkMUQojMFcDHePNEAgkODqZHjx4UKVKEmjVrcubMGUxMTGjdujVDhw5lw4YNug5RCCEyJ0uZ6EahQoXUiylWqFCBhw8fEhcXB4CDgwP379/XZXhCCPF2BXBHwjyRQOrUqcPWrVtJSUmhUqVKGBgYcOzYMSB1ct3Y2FjHEQohxFtID0Q3vLy8OHLkCAMGDMDIyAgPDw/GjRtH7969mTNnDi1bttR1iEIIkbkCOAeSJ57CcnBwYN++fdy8eROACRMmUKRIES5evMjAgQMZNGiQjiMUQoi3SE7SdQS5TmcJpEmTJqxatYrq1asDUKZMGQoVKkRKSgp6enp4eXnpKjQhhMi6fNSz0JbOhrDCw8NJTPznuenk5GQaNmwoa14JIT5IipKs9ZFf5IkhrNfywO66QgiRPQWwB5KnEogQQnyw8tHTVdqSBCKEEDmhAPZA8sRjvP8mS7wLIT5IyUnaH1kQFRXF7NmzcXV1pU6dOnTs2JHff/9dfX7hwoXY2tqmOZKS/rnPxo0bcXNzw8HBga5du3Lp0iWNewQHBzN48GDq1q1Lo0aNmD9/vsb1GdFpD2Tu3LkULlxYo2z27NmYm5trlKlUKlasWJGboQkhRNa8pyGsCRMmcP36dWbOnEnZsmXZv38/Xl5erF27loYNG3L9+nU8PDwYPny4xnWvV/fw9/dn/vz5fPPNN1SvXp3Vq1czYMAA9u/fT/HixUlISKB///5YW1uzZcsWHj58yMSJEzEwMMDb2zvT2HTWA6lfvz56enpER0erj/r166NSqTTKoqOjiYqK0lWYQgihnffwImFYWBgHDx5k4sSJNGrUiAoVKjBkyBCcnJzYtm0bkLpaR40aNShZsqTG8ZqPjw89evTA3d2dKlWqMGvWLMzNzdmyZQsABw4c4NGjR8ydOxcbGxvc3NwYPXo0GzZsUC8plRGd9UD8/Px0dWshhMh572EOpFChQqxatYq6detqlKtUKl6+fElkZCRPnjyhSpUq6V4fHh7OvXv3cHZ2Vpfp6+vj6OhIYGAgAIGBgVSvXp0iRYqo6zg7OxMTE8OVK1dwdHTMMD6ZRBdCiJyQhSGsyMhIIiMj05RbWFhgYWGh/trc3JxmzZpp1Llw4QKnTp1i8uTJ3LhxA4A9e/YwadIkEhMTcXJyYtSoUZQqVYqQkBAASpcurdFGqVKluHz5MgAhISHpngd4+vRppp9DEogQQuSELEyO+/r6smzZsjTlXl5eDBs2LMPrbt++jZeXF7Vq1aJr165s3boVSE00S5YsISwsjEWLFtG7d2927txJbGwsAEZGRhrtGBkZkZCQAEBcXBxmZmZpzgPEx8dn+jkkgQghRE7IwhBW37596dChQ5ryf/c+3nTmzBm8vLywsrLCx8cHQ0NDunfvzueff64efqpWrRo2Nja4uLhw6NAhrK2tAdTJ4rWEhARMTU0BMDExSfc8oK6TEUkgQgiRE7IwhPXmUNXb7N69m4kTJ+Lk5MSSJUvUT6qqVCqNuQsAS0tLihYtypMnT2jcuDEAoaGh2NraquuEhoZiaWkJpA5vvbmEVGhoqPpcZvLceyBCCPFBek/Lue/Zs4exY8fy6aef4uPjo/Gaw8yZM2nfvr1G/YcPH/LixQuqVKlCsWLFsLa2JiAgQH0+OTmZs2fP4uTkBKQ+EXvt2jWNOZnTp09jZmZGjRo1Mo1NEogQQuSE95BAnj59ypQpU3B2dmbMmDFEREQQFhZGWFgYERERtGnThps3bzJz5kzu3btHQEAAXl5eODg40Lx5cwA8PT3x9fXF39+fW7duMXnyZKKjo+nSpQsALVu2xNLSEm9vb4KCgjh8+DALFy6kX79+aeZO3iRDWEIIkRPew2KwBw8eJDY2llOnTtG0aVONc3Xr1mXz5s2sXLmSZcuW0aFDB4yMjHBzc2PMmDHo6aX2Dzw8PIiKimLx4sVERERgZ2fH2rVrKVasGADGxsasXr2aGTNm4OHhgYWFBV27duWrr756a3wqJR8vgZsYfkfXIYg8ppBV07dXEgVSUsKjd7o+duMUresW6vnNO90rr5AeiBBC5ARZjVcIIUS2FMDVeCWBCCFETsi/swEZkgQihBA5QXogQgghskUSiBBCiOxQkpN1HUKukwQihBA5oQD2QORNdB1JTk7Gd4s/7j0GUd+tPV/0HMSmbbvJ7LWcfb/9QfteQ6jb4gvcuw/k55373lt8T0LCGD5hBg1ad6JZ2+4sXL6GxMREjTp/nj5L1/7Dqe/Wns+69mfj1l2Zxi9yn6GhITP+O5bbN0/z8sVNfjvwM3Vq2wPQp7cHSQmPMjxEFikp2h/5hPRAdGTl+s2s+d/PDP5Pd2rZVePsxSvMXeJDXHw8nj27pKm/9+ARxv13Hp+4NmPMsIHcexDMwuWreRn5ioF9uuZobAkJCQzynoSJsRHfThnDk5BQFq1YS1xcPJNGDQXgwt/X+GrMNNp+4srIIf24duMW85euIjk5hT7d0q4yKnRj4YLp9OrZiQkTZ3Pnzj28vurPod+2UsexJfv2H6JxE3eN+iVLFmfL5pX8b+N2HUX8AUspeH88SQLRgZSUFDZs8adf984M7tsdgAb16vAi4iXrN21PN4Gs9vuZWvbVWTBjPCqVisbOjhgaGjJvyY90afcpRYtov7Lna6079aXdZ634qn8vjfK9v/3Bw+DH/LptHaVLpW6NaWxszDfzlzK4X3dKFPsIv592UNm6At9M9EalUtGwfh3u3HvIZv89kkDyCAuLwgzo34OJk77F58cNABw/EUDo07/p1bMzs79dTHj4c41rtm9bw737wYz0nqqLkD9sMoQlcsOrqGi+aNOSls0baZRXLP8xzyNeEhObdh/iew+DaeRUF5VKpS6r62BHXHw8Z85fVpf9FXCO7gNH4tiiHW7te7Fs1QaSszi5d+rMearbVlEnDwC3Zg1JSk7mdOAFAEZ7DWTef8dpxGNoaEDCG8NcQneio2No1KQt631/UpclJiaiKArGxmkXyWvdyoV2X7Th66+nvnUvbJGO5GTtj3xCeiA6UMSisHoo6N/+OHEay1IlMC1kkuZc6VIleRISqlEW/CR1u8nHT1O3rTwVeJ4vR0+hVfMmfNW/F3cfBLPEZz0Rka+YPCp1YbSkJM0fXiUlRV2mp6dCT0+Pew8fUbFcWY16RYtYYG5myr2HqWPjZSz/SS6Rr6I4cuIUu/f/zqD/dMvS90K8P8nJyVy4cAVI3TeiQoWPmTZ1NIqisHGTf5r6s2ZN5ODBPzj429HcDjV/KIA9EEkgecS23b9yKvA8E0YOSfd8209cWeW7hTo17WjVvDH3gx+xeOV6VCoVsf/fY1n64wYc7KqxYMYEAJo0qEcRi8JMnvUd/Xp0pmwZS2q7tNVod+X6zaxcvxmAdp+2ZNbkUURHx6S7E5mZaSGio2M0yh4/DaF1p/8AYFetKt06tE1zndC9yZNGMm3qaACmTZ/PjRu3Nc67NGtIndr2tP4kZ+fTChSZAxG68MuBw3yzYCmtWzShR+cv0q0zqE9Xwp+9YPrcxUyb8z1FLAozYeQQJnyzABMTY2Lj4rh87QbDB/XV6GU0cXYkJSWFgHMX6fB5a7asXqw+N2zcf3Fp7ETnLz4F4KOiqTubKcC/RqbUFAVUeponzExNWbtkDuHPX7B01QZ6DvJm6/plFDJJ24sSurNz168cPXqS5s0bMXnSSIyMDJk2fb76/IABPbn89zUOHzmhwyg/cPno6SptSQLRsQ1bdjB/2SpaNGnA3GljNeYU/s3Q0JBpY4cx+qv+PA0No1zZMoQ/f4GiKBSxKEzkqyhSUlL4fuU6vl+5Ls31Yf8/WWpf3eZfbRpQskRxjTIAczNTomNi07QRExtLYTMzjbIiFoVxcqwFQJVKFejYZyi//fEnX7Rxy9o3QrxXly+nbll67PgpCpubM+rrIXwzcxFJSUkYGBjwaRtXvlvko+MoP3DSAxG56fuV61nt9xNftHFjxgRvDAz0M6x7+uwFVCo9nOo6UNm6AgA3bt0FoFrVSpj//5DT4L7dadG0QZrrS5UornVcFcqVJfjxU42yiJeRREXHULH8xwD8fuwvSpUsTs3q/+yzXLVSRQwMDAgNe6b1vcT7Y2lZkjaftGC7/16ioqLV5ecv/o2JiQnFi39ESEgYDRs4UrRoEXa8x/eKCgKlAM6ByFNYOuL3805W+/1Ery7tmDV5VKbJA2D/oaN8+/0K9deKorBlx17KWJbCprI1Zmam2FapxMPHT7CvbqM+DA0N+X7lep6Ghmkdm7Njba4E3dS45vdjJzEwMKDe/7+EtsbvZxYuW61xXcC5iyQlJVG1ckWt7yXen6JFLVizehGdOn6uUd6qpQshIWGEhoYDUL9+bV6+jOTatZu6CDP/kKewRG4IC3/OohVrqVq5Ip+2dOHSlSCN83bVbHj8NIQXES+pZV8dgM5ffMqOvQeZ8/1KWjRtwC8Hj/Dn6bPMmz4Off3U5OM1oDfDJ8zA3MwUt2aNiHgZydJVG1CpVOn+Uj+43Tfd+D5r5YLP+k0M+XoKXgN7Exb+nO9+WEOXLz6lRPHUbTAH9e2G17j/8t95S/jEtSn3Hj5i+Wo/6tdxoFnD+jn43RLZdf36bbb772X+vKkYGRlx9+592rf/jN69OtN/gLd61QA7u2rcuCm7d76zAjiEJVva6sDOvb8xefZ3GZ4/vncLC5atZtf+Q/z95351+aGjf7JslR/Bj59SoVxZBvXtxieumlu0/nHiFCvWbeLmnXuYm5rSsH4dRn7pqfHYrTYeBD9m1nc/cPbC35ibm9K2tSsjhvwHQ4N//uY4cvwUK9dv4vbdBxQ2N+PTli4MG9QnT0+gF7QtbQsVMmHqlK/p0vkLypQpxdVrN/l2zhL8/feq6+zZtQFDQ0PafNZdh5Hq3rsu3xI9Xfvvn9n0ze90r7wiwwQSFRWV7UbNzc2zfW1OyqsJROhOQUsgQnvvnECmav8OlNmMLe90r7wiwyGsevXqZfhEUGZUKhVXr159p6CEEOKDI4/x/qN+fRnHFkIIrRXAOZAME4ifn19uxiGEEB80JSn/PF2lrWw/xhsaGsrNm6mP/SUlJeVYQEII8UFKUbQ/8oksJZC4uDgWLFhAo0aNcHFxoV27dgCsXbuWPn36cOeOTFoLIQqoArihlNYJJDo6mh49erB69WqMjY0pV66c+jnyuLg4AgIC6NmzJ8HBwe8tWCGEyLOkB5KxFStWcPXqVSZPnszhw4dxd/9nJ7Phw4czZ84cXr58yQ8//PBeAhVCiLxMSVG0PrIiKiqK2bNn4+rqSp06dejYsSO///67+nxwcDCDBw+mbt26NGrUiPnz56eZVti4cSNubm44ODjQtWtXLl26pHFemzbSo3UC2b9/P02bNqVXr16oVKo0j/i2b9+e5s2bc/r0aW2bFEKI/CMpWfsjCyZMmMAff/zBzJkz2blzJ61bt8bLy4uTJ0+SkJBA//79UalUbNmyhW+++YZt27axdOlS9fX+/v7Mnz+fkSNH4u/vj7W1NQMGDODZs9Q167RpIyNaJ5DQ0FCqV6+eaR1ra2vCwrRfc0kIIfKN9zCEFRYWxsGDB5k4cSKNGjWiQoUKDBkyBCcnJ7Zt28aBAwd49OgRc+fOxcbGBjc3N0aPHs2GDRvUu0r6+PjQo0cP3N3dqVKlCrNmzcLc3JwtW1JfZtSmjYxonUCKFSvG7du3M61z8+ZNihUrpm2TQgiRf7yHBFKoUCFWrVpFvXr1NMpVKhUvX74kMDCQ6tWrU6RIEfU5Z2dnYmJiuHLlCuHh4dy7dw9nZ2f1eX19fRwdHQkMDAR4axuZ0TqBtGjRgiNHjnD0aPrbXR44cIBjx47RrFkzbZsUQoh8Q1EUrY/IyEiCg4PTHJGRkRptmpub06xZM43loS5cuMCpU6do3rw5ISEhlC5dWuOaUqVKAfD06VNCQlK3u06vzpMnTwDe2kZmtF6N18vLiyNHjvDll1/SrFkzIiIiAFi6dCl///03x44do3jx4nz11VfaNimEEPlHFnoWvr6+LFu2LE25l5cXw4YNy/C627dv4+XlRa1atejatSuHDh3C7I1N3oyMjACIj48nNjZWo+zfdRISEoDUp2gzayMzWieQEiVKsGXLFqZNm8bRo0fVj/AuX74cSF36ZMaMGVhaWmrbpBBC5B9ZSCB9+/alQ4cOacotLCwyvObMmTN4eXlhZWWFj48PhoaGmJiYqBPBa6+/NjU1xeT/V8ZOr47p/29C97Y2MpOl/UDKlCnDjz/+SFhYGFevXiUyMhJTU1NsbW35+OOPs9KUEELkK0qS9i8IFrGwyDRZvGn37t1MnDgRJycnlixZoh7SKl26NNeuXdOoGxoaqj5nZWWlLrO1tdWo8/qP/be1kZlsLWVSsmRJXFxccHd3x83NTZKHEEKkZOHIgj179jB27Fg+/fRTfHx8NOZD6tevz7Vr1zTmTk6fPo2ZmRk1atSgWLFiWFtbExAQoD6fnJzM2bNncXJy0qqNzGQpgaSkpLB161b69OmDs7Mz9vb2NGnShCFDhvDbb79lpSkhhMhX3seLhE+fPmXKlCk4OzszZswYIiIiCAsLIywsjIiICFq2bImlpSXe3t4EBQVx+PBhFi5cSL9+/dTzGJ6envj6+uLv78+tW7eYPHky0dHRdOnSBUCrNjKi9Y6EMTExDBw4kHPnzgGpXRszMzNCQ0OJjIxEpVLx+eefM3/+/GztI/I+yIZS4k2yoZTIyLtuKBXRvYXWdYtuPqJVvQ0bNjBr1qx0z9WtW5fNmzdz//59ZsyYwZkzZ7CwsKBTp06MGDECPb1/+gdr167F19eXiIgI7OzsmDRpEnZ2durz2rSRHq0TyIIFC1i9ejXu7u6MHTuWkiX/2SL19u3bzJs3j2PHjjFmzBg8PT21afK9kwQi3iQJRGTknRNI1ywkkJ+0SyB5ndYJpEWLFhQvXpytW7em28NITEykY8eOxMfHc/DgwRwPNDskgYg3SQIRGXnXBPKiS3Ot63609Y93uldeofUcyLNnz3BycspweMrQ0JAmTZq89cUTIYTIj5QkResjv9D6MV5bW9u37nV+//59KlWq9M5BCSHEByf/bPOhNa17IOPGjePcuXPMnTuX6OhojXPJycmsWbOGY8eO8fXXX+d4kEIIkdcVwP2kMu6BpPeWpImJCevXr2fbtm3Y2NhQvHhxXr16xbVr13j58iVWVlZs3bpV1sMSQhQ8+SgxaCvDBPLmm4n/9urVK86ePZum/NGjRzx+/DhnIhNCiA9IfupZaCvDBBIUFJSbcQghxAdNefsGfvlOltbCEkIIkT7pgbxFQkICgYGBPHv2jOTkf7ZlVBSFpKQkXrx4wfHjx/Hz88vxQIUQIi+TBJKJhw8f0rdvX/UmJBl526vvQgiRLyl5Ywmn3KR1Alm8eDGPHz/GxcWF+vXrs3btWqpXr06DBg24ffs2v/zyC0WLFmXXrl3vM14hhMiTpAeSiVOnTmFnZ4ePjw+Q+pRWWFgYAwcOBKBdu3b079+f7du3M2jQoPcTrRBC5FFKSsHrgWg93hQREaFePx6gWrVqGhuuN2zYkCZNmvDrr7/mbIRCCPEBSElWaX3kF1onEFNTU/697mK5cuWIiYnh4cOH6jJbW1sePXq3BcmEEOJDVBDfRNc6gdja2nL69Gl1EqlcuTKKovD333+r64SFhZGSko++O0IIoSUlRaX1kV9onUA6derEtWvX6Nu3L0FBQVSpUoUKFSowf/58jh07hr+/P/v27aNq1arvM14hhMiTFEX7I7/QehK9ffv2XL9+HV9fX27fvk21atUYNWoUI0eOZPDgwQDo6+szbNiw9xasEELkVfmpZ6EtrTeUei0kJARjY2OKFi0KwKVLl9i7dy/GxsZ89tlnVKtW7b0Emh2yoZR4k2woJTLyrhtK3a3VSuu61hd/e6d75RVZXsrE0tJS42sHBwccHBxyLCAhhPgQFcQeyHtZTDEv9UKEECI3KPIm+j/at2+f4fa1b5PZUvBCCJEf5afHc7X1XhKIEEIUNCnSA/nHnDlzcjMOIYT4oMkQlhBCiGzJT0uUaEsSiBBC5ICC+BSWbN4hhBA5IEVRaX1kl4+PD927d9coW7hwIba2tmmOpKR/9tjduHEjbm5uODg40LVrVy5duqTRRnBwMIMHD6Zu3bo0atSI+fPna1yfEUkgQgiRAxRFpfWRHRs3bmTRokVpyq9fv46HhwcnTpzQOAwMUgeY/P39mT9/PiNHjsTf3x9ra2sGDBjAs2fPgNSdZvv3749KpWLLli188803bNu2jaVLl741JkkgQgiRA97XWlghISEMGTKEBQsWYG1tneb8jRs3qFGjBiVLltQ4XvPx8aFHjx64u7tTpUoVZs2ahbm5OVu2bAHgwIEDPHr0iLlz52JjY4ObmxujR49mw4YNxMXFZRqbJBAhhMgB72sI68qVK5iZmbF7925q1aqlcS4yMpInT55QpUqVdK8NDw/n3r17ODs7q8v09fVxdHQkMDAQgMDAQKpXr06RIkXUdZydnYmJidHY8yk9OnsT3d3dXev2VCoVu3fvznY8QgjxvqVkYRI9MjKSyMjINOUWFhZYWFholLm6uuLq6ppuOzdu3ABgz549TJo0icTERJycnBg1ahSlSpUiJCQEgNKlS2tcV6pUKS5fvgyk9nDSOw/w9OnTTD+Hzt5Et7Oze+8vKsrCeeJNHmWc3l5JiGzISs/C19eXZcuWpSn38vLK0ormrxOIubk5S5YsISwsjEWLFtG7d2927txJbGwsAEZGRhrXGRkZkZCQAEBcXBxmZmZpzgPEx8dnen+dvYkuLyoKIfKTrEyO9+3blw4dOqQpf7P38Tbdu3fn888/Vw8/VatWDRsbG1xcXDh06JB6zuR1sngtISEBU1NTAExMTNI9D6jrZCTPvImelJTEvXv3SEhIUO96qCgKcXFxnD9/noEDB+ZqPEIIkRVZ6YGkN1SVHSqVSmPuAlJXTC9atChPnjyhcePGAISGhmJra6uuExoaql5ZvXTp0mlGjUJDQ9XnMpPjLxI+fPiQcuXKZemawMBAvL29CQ8PT/d8oUKFJIEIIfI0XWw0OHPmTAIDA9m5c6e67OHDh7x48YIqVapQrFgxrK2tCQgIoGnT1CH95ORkzp49S9euXQGoX78+/v7+REZGqpPa6dOnMTMzo0aNGpneP0sJ5OjRo+zZs4fnz5+TnJys0VNISkoiIiKCe/fuZXk13gULFmBhYcG0adPUk+WdOnXi+PHjbNq0iVWrVmWpPSGEyG3JKbn/UGubNm3YvHkzM2fOpFevXoSGhjJr1iwcHBxo3rw5AJ6ensycORNra2scHBxYs2YN0dHRdOnSBYCWLVvy/fff4+3tzZgxY3j8+DELFy6kX79+aeZO3qR1Ajl48CAjRowgsw0MCxUqhJubm7ZNqgUFBfHtt9/SsmVLoqKi8PPzw8XFBRcXF1JSUli+fDlr167NcrtCCJFbdLGae7169Vi5ciXLli2jQ4cOGBkZ4ebmxpgxY9DTS01oHh4eREVFsXjxYiIiIrCzs2Pt2rUUK1YMAGNjY1avXs2MGTPw8PDAwsKCrnrKhjwAACAASURBVF278tVXX731/lonkHXr1qGvr8+CBQuoX78+AwcOxN7enhEjRnDr1i3mzZvH3bt3GT16dLa+ESVKlADA2tqaW7dukZKSgp6eHq1atWLUqFHZalMIIXKLwvtfCyu9uemmTZuqh6cy4unpiaenZ4bnK1SowJo1a7Icj9Z9rhs3btCyZUvatGlD8eLFqVu3LmfPnqV48eI4OzuzZs0ajIyMWLlyZZaDqFKlCgEBAQBUqlSJhIQE9QsskZGRb32UTAghdC1F0f7IL7TugcTHx1OhQgX115UqVWLz5s0kJCRgZGRE0aJFadmypfrtxqzo06cP48aNIyIigkmTJtG0aVPGjBnD559/zo4dO6hTp06W2xRCiNyUkgs9kLxG6x5IiRIleP78ufrr8uXLk5KSws2bN9VlH330kfrNx6z44osvWLRokXr9ltmzZ1OqVClWr16NlZUV06ZNy3KbQgiRmxRUWh/5hdY9kPr163Pw4EE8PT2xtrZWL1fy+++/Y2dnB8C5c+fSPJOsrTZt2qj/f4kSJdiwYUO22hFCCF1IzkeJQVtaJ5BBgwZx8OBB3N3dWbBgAW3atKFFixb4+Phw584dnj17xrlz59J9u1IbSUlJ7N27l1OnThEWFsbkyZM5e/Ys9vb2Gi/ACCFEXqSLp7B0TeshrKpVq+Ln50eDBg0oXLgwAFOnTqVSpUr8+uuvnDlzhpo1a2briakXL17g4eHBxIkTuXLlCn/++SfR0dH89ttvdOvWjYsXL2a5TSGEyE0pWTjyC5WS2YsdWgoKCsLY2JiKFStma/2ssWPHcuHCBdatW4elpSX29vZs376dqlWrqt9A9/X1zXK7BkZls3yNyN9kMUWRkU33d7zT9Xstu7+90v/7PGTzO90rr8iRVyerVauGtbV1thdfPHLkCCNHjqRs2bIabRgZGeHp6fnWNemFEELXUlTaH/mF1nMg3377rVb1VCoV48ePz1IQycnJGBsbp3suKSkp07ffhRAiLyiIj/FqnUDeNoSkUqlQFCVbCaRBgwYsX76cevXqYW5urm4vMTGRDRs2UL9+/Sy1J4QQuS1Z1wHogNYJJKPHamNjY3nw4AGbNm2iRIkSfP/991kOYvz48XTv3p1WrVpRu3ZtVCoVixcv5s6dO0RGRrJp06YstymEELkp5T1vkJcXaZ1AnJwyn3x0d3fH3d2dDRs24O3tnaUgypcvz+7du1m/fj0BAQGUL1+e8PBwWrRoQb9+/TAxMclSe0IIkdsK4kB7ju0HUrRoUT755BN2796tdQJJSEjg1KlTQOqLim8+ApyUlISfnx8rVqxQr5UlhBB5UX56PFdbObqhVGJiosZyJ5m5c+cOAwYM4MmTJwBYWVmxfv169WZUf/zxB99++y3379+nbFl5HFcIkbflp6ertJVjO6AcP36cPXv2UKlSJa3qL1iwgOjoaGbMmMHChQvR19dnzpw5JCYmMn78eL788kueP3/O6NGj2b9/f06FKYQQ70UyKq2P/OKd50AURSE2Nla9Q+GAAQO0au/8+fMMGzZMvStW8eLFGTx4MOPGjWP//v107tyZr7/+mo8++kjbEIUQQmcKYg9E6wTy+vHaN6lUKooXL06lSpXw8PBQb6P4NpGRkeoFGQFq1qxJXFwcf/31F+vWraNBgwbahiaEEDoncyCZOHz4cI7eODk5WWO/3dcvEo4fP16ShxDig1MQn8LSeg5k2bJlnDlzJtM6R44cYcqUKe8UUNWqVd/peiGE0IWCuJRJlhLI2x6lPXr0KLt27XqngLK7npYQQuhSQVyNN8MhrI0bN7Jt2zaNss2bN3Po0KF06ycmJnLnzh0+/vhjrW8+d+5c9dLwr82ePTvNfItKpWLFihVatyuEELktuQD+7ZthAmnXrh3Lly9Xv9ehUqkIDw8nPDw8/YYMDChTpgyTJk3S6sav17eKjo7OtEwIIT4E+alnoa0ME4i5uTl//fWX+utq1arh5eWFl5dXjtzYz88vR9oRQoi8QBJIJjZs2JDhG+Hx8fEZLscuhBAFgTyFlQknJyeio6MZOnQoW7du1TjXpEkThgwZwqNHj3I8QCGE+BDIU1iZuH79Ot26dePIkSO8fPlSXR4XF4e9vT0nTpygU6dO3L17970EKoQQeVluPIXl4+ND9+6aW+cGBwczePBg6tatS6NGjZg/fz5JSUkadTZu3IibmxsODg507dqVS5cuZbmN9GidQJYsWYKiKGzatEljuRITExPWrVuHn58fsbGxLFq0SNsmhRAi30jOwpEdGzduTPP7NSEhgf79+6NSqdiyZQvffPMN27ZtY+nSpeo6/v7+zJ8/n5EjR+Lv74+1tTUDBgzg2bNnWreREa0TyMWLF2nbti116tRJ93ydOnX47LPP1MuzCyFEQfK+hrBCQkIYMmQICxYswNraWuPcgQMHePToEXPnzsXGxgY3NzdGjx7Nhg0biIuLA1J7LT169MDd3Z0qVaowa9YszM3N2bJli9ZtZETrBBITE4OhoWGmdczMzIiPj9e2SSGEyDfe1xDWlStXMDMzY/fu3dSqVUvjXGBgINWrV6dIkSLqMmdnZ2JiYrhy5Qrh4eHcu3cPZ2dn9Xl9fX0cHR0JDAzUqo3MaP0UVpUqVTh69CjR0dGYmZmlOR8fH8/x48e1Xs5dCCHyk6w8hRUZGUlkZGSacgsLCywsLDTKXF1dcXV1TbedkJAQSpcurVFWqlQpAJ4+farezTW9OpcvX9aqjcxo3QPp2rUrjx49YsiQIVy8eJHk5NSRvJSUFC5fvszQoUN58OABXbt21bZJIYTIN1JQtD58fX1xc3NLc/j6+mbpnnFxcRqL0gLqr+Pj44mNjdUo+3edhIQErdrIjNY9kE6dOnHx4kV+/vlnunXrhr6+PsbGxsTHx6v3AunUqRPdunXTtkkhhMg3sjI53rdvXzp06JCm/M3ex9uYmJioE8Frr782NTVV90DSq2NqaqpVG5nJ0pa2M2bM4LPPPuOXX37h+vXrREZGYmpqio2NDV988QWNGzfm5s2bsqKuEKLAycrcRnpDVdlRunRprl27plEWGhqqPmdlZaUus7W11ahjaWmpVRuZyfKe6A0aNEizX0dMTAx79+6la9euXL58matXr2a1WSGE+KDp4gXB+vXr4+/vT2RkpDohnT59GjMzM2rUqIGRkRHW1tYEBATQtGlTIHUvprNnz6qnG97WRmbeaU/0ixcvMnnyZJo0acLUqVO5ePFihjsXCiFEfpaVOZCc0rJlSywtLfH29iYoKIjDhw+zcOFC+vXrp57H8PT0xNfXF39/f27dusXkyZOJjo5WbyeuTRsZyXIPJCIigl27drFt2zZu3bqFoijo6enRsGFDOnbsSOvWrbPxbRBCiA+bLtbCMjY2ZvXq1cyYMQMPDw8sLCzo2rUrX331lbqOh4cHUVFRLF68mIiICOzs7Fi7di3FihXTuo2MqBRF0epznzx5kq1bt3Lo0CESExN5fZmzszNz5syhTJky2fn875WBUfqLP4qCy6OMk65DEHnUpvs73un6CRV7aF3323ub3uleeUWmPZCQkBD8/f3Zvn07jx49QlEUihcvTps2bWjbti3du3fH2to6TyYPIYTITckFcD3eDBPIkCFDOHHiBElJSRQuXJj27dvz2Wef0bhxY/T03mnqRAgh8h3ZD+Rf/vjjDwoVKsSXX37JwIED3zqZIoQQBVlOTo5/KDLsSjRp0oSEhASWLVtG06ZN+frrrzl06FCaF06EEEKkTqJre+QXGfZAVq9eTXh4OLt372bnzp3s27eP/fv3Y2ZmRqtWrfj8889zM06RBUZGRpwNPEhAwHn6D/AGUt82nTRxBF06u1O6dClu3rrLvPnL2bp1t46jFa9Vb2DHlJ9mZnh+eKNBhD8KS1Ne1dEWjzE9qVijEglx8fx94iIbZ/sSGf4ynVbeTbEyxek7fQB2jWqSGJ/Ise1H+HnBJpIT/9k7IjfjyUtkCOsNJUqUwNPTE09PT65fv86OHTv45Zdf2LFjBzt37kSlUnH16lXOnz+f4TLvIvdNnfI11atVJSDgvLps+bJvaffFJ0ydNo/r12/Ttm0rNm9cgaIobNu2R4fRitfu/X2Hqe3HaZQZGhsycsVY7v59h2ePw9NcY1XlYyZt+i+Xj19k2fDvMCtiRpdRPRi/YRpTvhhDclJ2d59Iy8DIgAn/m05CXDw/eC+mRNkSdBvfB+NCxqyfuirX48lrZBI9E7a2towfP56xY8dy4sQJdu3axe+//86lS5fo0aMHZcuWxd3dHXd3d1mRV4dq17bD6ytPwsKeqctKlChG3z4eDBw0inXrU/cA+P3wcSpXqsgo78GSQPKI2KhYbp2/oVHWe6oniqKwfMQi0nvivnXfz4gIfcH3Q+apfzk/vfuEmXvmU7NpLS4cOZflOBaf8OHYtsNs//4njfLG7ZphWaE0I5sM4fnT/9+MKC4Bz1lD8F/yM5HhL99LPB8KmQPR5gI9PZo1a8bChQv5888/mTlzJvXq1ePRo0esWLGCtm3bvo84hRb09fVZ9eN3LPxuBY8e/7MMc+HC5qz02cBvh45p1L9x4zYVK5bP7TCFlspW/ZjWfT/j5wWbePU87dLfAME3HrB31W6Nv+yf3HkEQMlyluoy+ya1mLFzLuuvb2HpqVV0/ro7qiw+TWnfxIF7f99RJw+AwAMBGBgaYN/YIUvx5EcyB5JFZmZmdO7cmc6dO/P48WN27tzJnj3y16yujB3zFUZGhsyZu4x27T5Vl9+9+wCvYRM06urp6fFJmxZcv34rt8MUWvIY3ZMndx9zZPNvGdY55PdrmrK6LesD8Ph2MAB2jWsyzncKAfv+YtuiLVhVKovH2J6Yf1SY9VN+BEBPXzOZqPT01GVKioKiKJS2tuLp3cca9aIiXhETGU0Zayut48mvCmIP5J0SyL9ZWVkxdOhQhg4dmlNNiiywta3MhPHDaf1JVxITE99af/q00VSvVpX2Hf7z/oMTWVayXCkcW9Vn9YQV6Q5dZaRYmeL0mNSX2xdvcuXP1A2DPEb35Nb5Gywd9h0Al46eJyriFUMWDuMXnx2EB4fxvzvbNdrpOMKDjiM8ADi69TA+o5dSyNyU2Ki0W5zGRsdSqHD6y36nF09+JZPo4oOkUqlY5bOQtes2c+r02bfWHzN6KBMnjOC771byy96M/7oVuuParRXRL6M5seOo1tcUK1OcSZtmoKfSY6lXarIwMjGicq0q/DR/k0Yv4+LR8+jp62PXsCZHtx5mUtvR6nOj10zk/O+B/L7pIACvXqQOn6lUKkgnmalUKlJS0v76TC+e/EyRHoj4EHl95Un58h/zRfu+6Ovrq8tVKhX6+vrq3SMBFsybxsiRg/hhxXrGjv9GF+EKLTh+4kzgwdMkJSS9vTLwsU15xvlOQd9An9m9phP6IHUOzKyIOXr6+nQf35vu43unua5oqY8AuHv5trosKSGJFyHPNcoAYl5FY2JeKE0bJqYmxL6K0Sqe/EyewhIfpPbt2vDxx2UID9Xch6V2LTv69O5C5arOPHjwiHVrF9OrZye+nbOEKVPn6iha8TbFrUrwcdVybJq1Xqv6lWtXZZzvFGJfxTKr+1Se3nuiPhcblfqLfceSnwk8GJDm2hchz7WO6+m9J5QqrzkRbl60MKYWZjy+/UirePIzGcISH6QvvxpPYXMzjbING5Zx8+YdvvnmOx4/DmHBvGn06tmJ0WP+y/eLf9RRpEIblWun7uh56/zNt9Yt8XFJxvlO4WX4S2Z1n0pE6AuN83HRcdy7cpdSFUpr9CjKVatAr8n/4ecFm9Jck5Erf17Cc+ZgipUurn4Sq94nTiQlJBIUcFWrePKzlCzMVeUXkkDygRs3bqcpi42N49mzF5w9d4k6te0ZNqw/v/12lJMnA3F2qquul5ycTODZi7kZrniLcjbliXz2kqiIV2nOlSpfGoviFur3RfpMG0Ahc1PWTfmREmVLUqJsSXXd8EdhRIS+YNt3m/l61XhiI2M4c+AUhYtZ4DG6BykpCg+D7qe5x4gmg9ON669dx+kwzINxG6aydeEmPrIsRvcJfTi8+TdehkVoHU9+VfDShySQAsHdvTV6enq0auVCq1YuGueioqIpWsxGR5GJ9FiUKEJMZHS65zoM74JLF1d6VOiAvoE+tVvURd9An2FLR6Wpu3HWevb+uItzh87w3YBv6TDCg2ZdXImNiuXvExfYPMePhDjt17ZLiEtgds9p/GfGQL5a7E3Mq2gO+f3KT/P+B6B1PPlVQXyMV+sNpT5EsqGUeJNsKCUy8q4bSnWv0F7rupvv73yne+UV0gMRQogckFQAeyCSQIQQIgfIeyBCCCGyRR7jFUIIkS35eDo5Q5JAhBAiBxTEp7AkgQghRA6QpUyEEEJki/RAhBBCZIvMgQghhMiWgvgUVpa3tBVCCJGWkoX/ZcWdO3ewtbVNc2zduhWAa9eu0bt3b2rXrk3z5s1Zs2aNxvUpKSksWbKEpk2bUqtWLTw9Pbl/P+0aaNkhPRAhhMgB72sO5Pr165ibm/Prr5rbBRcuXJjnz5/zn//8h1atWjF9+nQuXbrE9OnTKVy4MB4eqTtKLl++nM2bNzNnzhwsLS1ZuHAh/fv3Z+/evRgbG79TbJJAhBAiByQr72cQ68aNG1SuXJmSJUumObd+/XoMDQ2ZPn06BgYGVK5cmfv37/Pjjz/i4eFBQkICa9euZfTo0bi4pC6kumjRIpo0acL+/ftp31779bvSI0NYQgiRA97XENb169epXLlyuucCAwOpV68eBgb/9AWcnZ15+PAhISEhXLt2jZiYGBo0aKA+b25uTo0aNQgMDMzeB/0X6YEIIUQOyMqGUpGRkURGRqYpt7CwwMLCQqPsxo0bVKhQgW7duvHgwQMqVqzI0KFDadKkCSEhIVSpUkWjfqlSpQB48uQJoaGhAFhaWqap8+TJu+8UKQlECCFyQFb6Fb6+vixbtixNuZeXF8OGDVN/HRMTQ3BwMMWKFWPUqFGYmZmxe/duBgwYwNq1a4mLi8PIyEijjddfx8fHExsbq1H27zoJCdrvBZMRSSBCCJEDsjKJ3rdvXzp06JCm/M3eh6mpKWfPnsXQ0FCdBOzt7bl9+zarV6/GxMQkTSJ4/bWpqSkmJibqsn8nkYSEBExNTbWONyOSQIQQIgdkJYGkN1SVETMzszRlNjY2HDlyhHLlyqmHqV57/XXp0qXVLzeGhoZibm6uUefNoa/skEl0IYTIAclKitaHts6fP0+dOnW4dOmSRvnff/9N1apVqV+/PmfPniUpKUl97tSpU1SsWJGSJUtSrVo1zM3NCQgIUJ+Piori6tWrODm9++6ckkCEECIHvI+nsOzt7fn444+ZMmUKZ8+e5fbt28ycOZPz58/z5Zdf0qlTJ2JjY5k4cSK3bt1i586drF+/nsGDBwOpcx29evVi0aJFHDp0iKCgILy9vbG0tKR169bv/JllCEsIIXLA+1gLy9DQkNWrV7Nw4UKGDx9OZGQkdnZ2rF27lho1agCwZs0aZs2aRYcOHShZsiSjRo2iY8eO6jaGDx9OcnIyU6dOJTY2FkdHR1avXp1mYj07VEo+XgHMwKisrkMQeYxHmXfvtov8adP9He90fd0yTbSue+7JiXe6V14hPRAhhMgB+fhv8QxJAhFCiByQXADX45UEIoQQOSArb6LnF5JAhBAiB2R1jav8QBKIEELkAOmBCCGEyBbpgQghhMgW6YEIIYTIlve1oVReJglECCFygAxhCSGEyBZFeiBCCCGyIyvLuecXkkCEECIHyFImQgghskV6IEIIIbIlOUXmQIQQQmSDPIUlhBAiW2QORAghRLbIHIgQQohskR6IEEKIbJFJdCGEENkiQ1hCCCGyRYawhBBCZIss5y6EECJb5D0QIYQQ2SI9ECGEENmSIsu5CyGEyA6ZRBdCCJEtBTGBqJSC+KmFEEK8Mz1dByCEEOLDJAlECCFEtkgCEUIIkS2SQIQQQmSLJBAhhBDZIglECCFEtkgCEUIIkS2SQIQQQmSLJBAhhBDZkmeXMunduzcBAQHpnitRogR//vnnW9vw9/dnwoQJnDx5kmLFiuV0iEJH0vvZ0NfXx8LCgjp16jB69GgqV66cY/cbP348f//9N7/88kuOtSlEfpBnEwhA3bp1GTduXJpyQ0NDHUQj8pI3fzYSEhIICgpi+fLl9O/fnwMHDmBsbKzDCIXI//J0ArGwsKB27dq6DkPkQen9bDg5OWFiYsKUKVM4deoULi4uOopOiILhg54DuXTpEgMHDqRevXrY29vzySefsGXLlgzrP3jwgMaNG9O/f38SEhIAePbsGWPHjsXJyYk6deowZMgQHj58mFsfQeQwc3Nzja/v37/P0KFDqVOnDvXq1WPMmDE8f/5co87u3bvp1KkTtWrVolatWnTr1o0zZ87kZthCfJDydAJRFIWkpKQ0B8Djx4/p06cPpqamLF68mOXLl2Ntbc20adMICgpK01ZYWBienp5YW1uzfPlyjIyMiIuLo0+fPpw9e5bJkyczb948wsPD6dWrFy9fvsztjyuy4M2fjejoaE6fPs2iRYuwsrKiXr16hIeH06NHDx4/fsy8efP473//y4ULFzT+gPj1118ZO3YszZs358cff+Tbb78lMjISb29vdR0hRPry9BDW0aNHsbOzS1N+8uRJbt68Se3atVmwYIF6TqRWrVo4OzsTGBhItWrV1PWjo6MZNmwYRYsWZeXKlZiYmACwc+dO7t69y549e9STrg0bNqRFixb4+fnh5eWVC59SZEd6PxsmJiY0bNiQCRMmYGZmxsqVK4mPj2ft2rXqhygcHBz45JNP2LdvH+3bt+fBgwf07NmTYcOGqdsxNDTEy8uLe/fuYWNjk6ufS4gPSZ5OII6OjkyYMCFNuYWFBS4uLri4uBAfH09QUBD37t3j8uXLAGn+chw+fDjXrl1j48aNGkMcp0+fpkKFClSoUEHdszExMcHR0ZFTp05JAsnD/v2zcfPmTebOnUvDhg2ZN28eRkZGQOq/b+3atbGwsFD/+5YpU4bKlStz8uRJ2rdvz6BBgwCIjIzkzp073L17l8OHDwNpf46EEJrydAIpXLgwNWvWTPdccnIyc+bM4aeffiIxMZHy5ctTr149IO3OYFFRUVSsWJHvv/8ePz8/VCoVABEREdy5cyfdXk7FihVz9sOIHPXvn42aNWtSpkwZ+vXrh5GREfPmzQNS/30vXryY7r9vyZIlgdShzUmTJnHs2DEMDQ2pWrUqZcuWBQrmDnNCZEWeTiCZWbFiBT///DNz587FxcUFU1NTYmNj2bZtW7p1nz59Sv/+/fH396dTp05A6i+hatWqMXPmzDTXvP4rVnwYGjZsSOfOndm6dStt2rTB1dUVc3NzmjVrxvDhw9PUNzMzA2DUqFGEhITw008/YWdnh4GBAUePHuXgwYO5/RGE+ODk6Un0zFy4cAF7e3s+/fRTTE1NATh+/DiQ9i/HYsWK0aRJE1q1asX8+fN58eIFkPouQXBwMGXLlqVmzZrUrFkTe3t71q9fzx9//JGrn0e8u6+//prChQszZ84cEhIScHR05M6dO9ja2qr/fW1sbFi2bBlnz54FUn+OPvvsM2rVqoWBQerfUxn9HAkhNH2wCaRmzZpcvHiR//3vfwQEBLBmzRrGjx+PSqUiLi4u3WsmTJhAbGyseoijc+fOFC1aFE9PT/bt28dff/3FyJEj2bdvn8YkvPgwFCtWjMGDB3P//n38/Pzo168fr169YsCAARw6dIijR48yaNAgTp06hb29PZD6c7Rjxw5+/fVXTp48yYwZM9i4cSNAhj9HQohUH2wCGTRoEO3bt2fZsmUMHjyYX375hSlTptC4cWPOnz+f7jVly5Zl8ODB7Nixg8DAQMzNzdm4cSOVKlVi+vTpDB06lMePH/PDDz/IS2gfqL59+1K2bFlWrFiBiYkJmzZtolChQowZMwZvb29SUlJYt24d1atXB+Dbb7+lcuXKTJgwAW9vb27fvo2fnx+mpqZcuHBBx59GiLxNpUg/XQghRDZ8sD0QIYQQuiUJRAghRLZIAhFCCJEtkkCEEEJkiyQQIYQQ2SIJRAghRLZIAilAli5diq2tbZrDzs4OZ2dnevfuza5du3I1psjISGxtbendu7e6zN/fH1tbW9avX5+tNn/55Zf3sqdLu3btsLW1fWu93r17Y2trS2RkZJbvERwcjK2tLUOHDs1OiJlydXVVrxcnRE74YNfCEtnn5uamfpEOICkpiefPn7N//37Gjh3LnTt38Pb21ll81atXx8vLK1u7Uc6fP5/Vq1ezc+fO9xCZEOLfJIEUQC1btqRjx45pyvv370+HDh1YtWoVHh4e6lVpc1v16tU1ElxWPHv2LIejEUJkRIawhFrFihVxc3MjOTmZEydO6DocIUQeJwlEaLC0tARS99KAf+Yj9u/fT//+/alZsyYtWrRQzzFERUWxYMECWrZsib29PU2bNmXatGnp9gSCg4MZPXo0jRo1ok6dOnh5efH48eM09TKaAwkKCsLb25vGjRtTp04dOnTowLZt29Sr5rq6urJjxw4A2rdvj6urq/paRVHYvHkzHTp0wMHBgfr16zNkyBCuXr2a5v5xcXF89913uLq64uDggIeHxzvvkZ6YmIivry8eHh44Ojpib29PixYtmDp1apo92l87ePAg7u7u1KxZk08++QQfHx8SExPT1Lt//776+/p6heqM6gqRk2QIS2h48OAB8E8ieW3mzJmUKlWK3r17ExwcTLly5Xj16hU9evTgxo0bNGzYkNatWxMcHMzPP//M8ePH2bJlC6VKlQLg6dOndOvWjfDwcFxdXbGysuL48eMMGDBAq7hOnjzJkCFDSE5Oxs3NDSsrK/744w8mTZrE48ePGT58OH369GHHjh0EBQXR8awYywAACPtJREFUtWtXKlWqpL5+3Lhx7Nq1i6pVq9KtWzdiY2PZv38/3bp1w8fHh4YNGwKQkpLCwIEDCQgIwMHBgVatWnH58mU8PT0pVKhQtr+vo0aN4sCBAzg6OuLh4UFCQgInTpzgp59+4sqVK2zfvl2j/oULFzhy5AgtWrSgYcOGHDt2jO+++46goCAWLVqkrnflyhX69u1LXFwcrVu3xsrKisDAQL777jvOnDmDj48P+vr62Y5biEwposBYsmSJYmNjo2zfvj3d85cuXVJq1KihODg4KM+ePVMURVG2b9+u2NjYKM2aNVNiYmI06k+fPl2xsbFR/ve//2mUHzp0SLGxsVGGDx+uLhs7dqxiY2Oj+Pv7q8uio6OVXr16KTY2NkqvXr3U5a/vuW7dOkVRFCUpKUlxdXVVatasqZw7d05dLy4uTnF3d1eqV6+uhIeHK4qiKOPGjVNsbGyUq1evquvt27dPsbGxUb7++mslMTFRXf7gwQPFyclJadq0qRIfH68oiqJs27ZNsbGxUSZMmKAkJyer686dO1exsbFRbGxsMvkOp3r9mV6+fKkoiqKcP39esbGxUUaNGqVRLzExUWnbtq1iY2Oj3LlzR1EURXn48KH6Pr6+vuq6sbGxSp8+fRQbGxvlxIkTiqIoSkpKitK2bVulZs2ayuXLlzXanj17dpp/mxYtWiiOjo5vjV8IbckQVgF06NAhli5dqj4WLVrE8OHD6dmzJ0lJSYwdO5ZixYppXOPi4qLxF3hSUhI7d+6katWq9OzZU6Oum5sbdevW5bfffiMqKoqEhAQOHjxI1apV6dChg7qeqakpo0ePfmu8Fy5cIDg4mHbt2lGnTh11ubGxMePHj2fYsGHEx8dneP3rXSonTZqk3jQKoFy5cnTr1o2QkBD++usvAPbu3YtKpWLUqFHo6f3zn8fIkSMpXLjwW2NNT+nSpZkzZw4jRozQKDcwMMDR0RFIO/lfvnx5je+riYmJ+sm4PXv2AHDx4kVu3LhB586d1fubvDZixAgMDQ3x9/fPVsxCaEOGsAqg33//nd9//139taGhIUWLFqVx48b07NmTJk2apLnmzSey7t69S0xMDMnJySxdujRN/fj4eJKTk7l+/TpFixYlJiYmzS85AHt7ewwNDTONNygoCCDdx3obNWpEo0aNMr3+ypUrGBsbqzeKevNzAFy7do3mzZsTFBSElZUVxYsX16hnZGSEnZ0dp06dyvRe6SldujQdOnQgKSmJK1eucPfuXR48eMC1a9fUiSslJUXjmlq1aqUZerKzs0NPT0/9/bhy5QqQOuyY3r+BmZkZ169fR1EUVCpVluMW/9fe3YU09cYBHP+u0jE0R+mNaIMwVBD0JgmNILIgLIqkC5GEELQbb0ohImhBVltgSmgXUjgaMV8SjZSTkakg+IIk5iKM9UL0phYZuaRprAs5B+eZ086frv6/z41s53nO8/hcnN/O88JPrEUCyP/Q1atXw27jjcRsNod8Vg/JvX79mrq6ulXrff/+XXt4qXnIl9u4cSOxsbER21bbWqvcan78+MHi4uKa/VTbWhk8VFar1VD7AE1NTdTX1zM9PQ1AXFwcWVlZpKSkMD4+rkufm5CQoLtHVFQUZrOZnz9/an2FpRS8ahrecPx+v+GxEyISCSDCEDUYHD16VEsRvJpXr14BSw/ylYLBIPPz8xHrqznv/X6/7trCwgLBYJDo6OiI9WNiYtaV5z4uLi5sPwHtwf23FEXBbreTlpaG3W4nIyODxMREAOx2O+Pj47o64U6xz83NMT8/rwUydVwuX77M8ePHDfVNiP9C1kCEIdu3byc6Oprnz5/rfj0DuFwubt68ybdv37DZbGzevDlsqmGfz7dm7vHU1FQAnj17prumKApZWVnayfNwUzVpaWl8/vyZmZkZ3bXe3l5qamq0aaGMjAw+ffqk2178+/dvXrx4EbGfq+ns7ASgurqa/fv3a8EDlt7gAN0YTkxM6O7z9OlTrY/q/wXg9Xp1ZRcWFnA4HLjdbkN9FmI9JIAIQ8xmM/n5+fh8PhobG0OuDQ8Pc+3aNdra2rBarURFRXH48GHevXsXUjYQCFBdXb1mW9nZ2SQmJnL//v2Qh3ggEMDlcrFhwwZtG666SL78DMSxY8cIBoNcunSJQCCgfT89Pc3FixdpaGjQfs2ri/wOhyPkHrdv3+bLly/rHp/l1Om/lfU7OjoYGRkBljYlLPfy5UsURdE+z83NUVtbi8lk0qYfs7OzSU5O5t69e7rg3NDQQGNjo7ZOIsS/IFNYwrCzZ88yNjaG0+mkp6eHzMxMpqamePToEZs2beLKlSvaTqbTp08zODiIw+FgYGCAlJQUBgcHmZ2d1a2vrKTe69SpUxQWFnLgwAHi4+Pp6+vj7du3nDt3Tju3ov51OBzk5uZSXl5OQUEBT548obu7m8nJSfbs2cPi4iKKojA7O0tFRQU2mw2A/Px8uru7efjwIW/evCEnJwefz8fQ0BBJSUl8+PDhr8fpyJEjdHV1UV5ezqFDh4iNjWViYoKRkRHi4+P5+vWrdnBTZbPZqKys5PHjx2zZsoXe3l7ev39PWVkZmZmZwNL6kdPppLS0lBMnTpCXl8e2bdvwer0MDQ2RnJzMmTNn/rq/QqyXvIEIw7Zu3UpLSwslJSVMTU3hdrsZHR1l3759tLS0sGvXLq2s1WrF4/FQWFjI5OQkzc3NJCQk4HK5Iq5fqHJzc/F4POTk5NDf38/du3exWCw4nU5OnjyplSsqKmL37t14vV7cbjd+vx+TycSNGzc4f/48FouF1tZWFEVhx44d1NfXU1ZWFtLW9evXqaysJBAI4PF4mJmZoa6ujvT0dEPjtHfvXmpqarDZbDx48ID29nZ+/frFhQsXuHXrFgD9/f26OlVVVXi9XpqamrBYLFRVVVFRURFSbufOnbS2tnLw4EFGR0e5c+cOHz9+pLi4mObmZu0gpxD/gikYbgJbCCGEWIO8gQghhDBEAogQQghDJIAIIYQwRAKIEEIIQySACCGEMEQCiBBCCEMkgAghhDBEAogQQghDJIAIIYQwRAKIEEIIQ/4Ae9HrKc0GjwUAAAAASUVORK5CYII=\n",
235 |       "text/plain": [
236 |        "<Figure size 432x288 with 2 Axes>"
237 |       ]
238 |      },
239 |      "metadata": {},
240 |      "output_type": "display_data"
241 |     }
242 |    ],
243 |    "source": [
244 |     "#Output confusion matrix\n",
245 |     "def print_confusion_matrix(y_true, y_pred):\n",
246 |     "    cm = confusion_matrix(y_true, y_pred)\n",
247 |     "    print('True positive = ', cm[0][0])\n",
248 |     "    print('False positive = ', cm[0][1])\n",
249 |     "    print('False negative = ', cm[1][0])\n",
250 |     "    print('True negative = ', cm[1][1])\n",
251 |     "    print('\\n')\n",
252 |     "    df_cm = pd.DataFrame(cm, range(2), range(2))\n",
253 |     "    sn.set(font_scale=1.4) # for label size\n",
254 |     "    sn.heatmap(df_cm, annot=True, annot_kws={\"size\": 16}) # font size\n",
255 |     "    plt.ylabel('Actual label', size = 20)\n",
256 |     "    plt.xlabel('Predicted label', size = 20)\n",
257 |     "    plt.xticks(np.arange(2), ['Fake', 'Real'], size = 16)\n",
258 |     "    plt.yticks(np.arange(2), ['Fake', 'Real'], size = 16)\n",
259 |     "    plt.ylim([2, 0])\n",
260 |     "    plt.show()\n",
261 |     "    \n",
262 |     "print_confusion_matrix(Y_val_org, model.predict_classes(X))"
263 |    ]
264 |   },
265 |   {
266 |    "cell_type": "code",
267 |    "execution_count": 7,
268 |    "metadata": {},
269 |    "outputs": [],
270 |    "source": [
271 |     "model.save('deepfake-detection-model.h5')"
272 |    ]
273 |   },
274 |   {
275 |    "cell_type": "code",
276 |    "execution_count": null,
277 |    "metadata": {},
278 |    "outputs": [],
279 |    "source": []
280 |   }
281 |  ],
282 |  "metadata": {
283 |   "kernelspec": {
284 |    "display_name": "Python [conda env:root] *",
285 |    "language": "python",
286 |    "name": "conda-root-py"
287 |   },
288 |   "language_info": {
289 |    "codemirror_mode": {
290 |     "name": "ipython",
291 |     "version": 3
292 |    },
293 |    "file_extension": ".py",
294 |    "mimetype": "text/x-python",
295 |    "name": "python",
296 |    "nbconvert_exporter": "python",
297 |    "pygments_lexer": "ipython3",
298 |    "version": "3.7.4"
299 |   }
300 |  },
301 |  "nbformat": 4,
302 |  "nbformat_minor": 4
303 | }
304 | 


--------------------------------------------------------------------------------
/model_play.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "import tensorflow as tf\n",
 10 |     "import dlib\n",
 11 |     "import cv2\n",
 12 |     "import os\n",
 13 |     "import numpy as np\n",
 14 |     "from PIL import Image, ImageChops, ImageEnhance\n",
 15 |     "from tensorflow.keras.models import load_model\n",
 16 |     "from tensorflow.keras.preprocessing.image import img_to_array, load_img"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "code",
 21 |    "execution_count": 2,
 22 |    "metadata": {},
 23 |    "outputs": [
 24 |     {
 25 |      "data": {
 26 |       "text/plain": [
 27 |        "'2.0.0'"
 28 |       ]
 29 |      },
 30 |      "execution_count": 2,
 31 |      "metadata": {},
 32 |      "output_type": "execute_result"
 33 |     }
 34 |    ],
 35 |    "source": [
 36 |     "tf.__version__"
 37 |    ]
 38 |   },
 39 |   {
 40 |    "cell_type": "code",
 41 |    "execution_count": 3,
 42 |    "metadata": {},
 43 |    "outputs": [],
 44 |    "source": [
 45 |     "model = load_model('deepfake-detection-model.h5')"
 46 |    ]
 47 |   },
 48 |   {
 49 |    "cell_type": "code",
 50 |    "execution_count": 4,
 51 |    "metadata": {},
 52 |    "outputs": [
 53 |     {
 54 |      "name": "stdout",
 55 |      "output_type": "stream",
 56 |      "text": [
 57 |       "[1]\n",
 58 |       "[1]\n",
 59 |       "[1]\n",
 60 |       "[1]\n",
 61 |       "[1]\n",
 62 |       "[1]\n",
 63 |       "[1]\n",
 64 |       "[1]\n",
 65 |       "[1]\n",
 66 |       "[1]\n"
 67 |      ]
 68 |     }
 69 |    ],
 70 |    "source": [
 71 |     "input_shape = (128, 128, 3)\n",
 72 |     "pr_data = []\n",
 73 |     "detector = dlib.get_frontal_face_detector()\n",
 74 |     "cap = cv2.VideoCapture('test_videos/jzmzdispyo.mp4')\n",
 75 |     "frameRate = cap.get(5)\n",
 76 |     "while cap.isOpened():\n",
 77 |     "    frameId = cap.get(1)\n",
 78 |     "    ret, frame = cap.read()\n",
 79 |     "    if ret != True:\n",
 80 |     "        break\n",
 81 |     "    if frameId % ((int(frameRate)+1)*1) == 0:\n",
 82 |     "        face_rects, scores, idx = detector.run(frame, 0)\n",
 83 |     "        for i, d in enumerate(face_rects):\n",
 84 |     "            x1 = d.left()\n",
 85 |     "            y1 = d.top()\n",
 86 |     "            x2 = d.right()\n",
 87 |     "            y2 = d.bottom()\n",
 88 |     "            crop_img = frame[y1:y2, x1:x2]\n",
 89 |     "            data = img_to_array(cv2.resize(crop_img, (128, 128))).flatten() / 255.0\n",
 90 |     "            data = data.reshape(-1, 128, 128, 3)\n",
 91 |     "            print(model.predict_classes(data))"
 92 |    ]
 93 |   },
 94 |   {
 95 |    "cell_type": "code",
 96 |    "execution_count": null,
 97 |    "metadata": {},
 98 |    "outputs": [],
 99 |    "source": []
100 |   }
101 |  ],
102 |  "metadata": {
103 |   "kernelspec": {
104 |    "display_name": "Python [conda env:root] *",
105 |    "language": "python",
106 |    "name": "conda-root-py"
107 |   },
108 |   "language_info": {
109 |    "codemirror_mode": {
110 |     "name": "ipython",
111 |     "version": 3
112 |    },
113 |    "file_extension": ".py",
114 |    "mimetype": "text/x-python",
115 |    "name": "python",
116 |    "nbconvert_exporter": "python",
117 |    "pygments_lexer": "ipython3",
118 |    "version": "3.7.4"
119 |   }
120 |  },
121 |  "nbformat": 4,
122 |  "nbformat_minor": 4
123 | }
124 | 


--------------------------------------------------------------------------------