From f4433760a322ea453dec2e21f241d0f91937afc6 Mon Sep 17 00:00:00 2001 From: Alexandre D-Julin <53292656+adjulin@users.noreply.github.com> Date: Fri, 4 Oct 2024 16:47:29 +0200 Subject: [PATCH] lab done --- main.ipynb | 1055 +++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 998 insertions(+), 57 deletions(-) diff --git a/main.ipynb b/main.ipynb index 9308e12..7716a95 100644 --- a/main.ipynb +++ b/main.ipynb @@ -28,30 +28,34 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "!pip freeze > requirements.txt\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, "metadata": { "id": "BOwsuGQQY9OL", "tags": [] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-08-16 22:09:18.737563: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - } - ], + "outputs": [], "source": [ "from tensorflow.keras.preprocessing.sequence import pad_sequences\n", "from tensorflow.keras.layers import Embedding, LSTM, Dense, Dropout, Bidirectional\n", "from tensorflow.keras.preprocessing.text import Tokenizer\n", "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.layers import LeakyReLU\n", + "from tensorflow.keras.callbacks import EarlyStopping\n", + "from tensorflow.keras.callbacks import ReduceLROnPlateau\n", "from tensorflow.keras.optimizers import Adam\n", "from tensorflow.keras import regularizers\n", "import tensorflow.keras.utils as ku \n", - "import numpy as np" + "import numpy as np\n", + "import matplotlib.pyplot as plt" ] }, { @@ -63,11 +67,40 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "2634 lines\n", + "93029 characters\n" + ] + }, + { + "data": { + "text/plain": [ + "['\\tsonnets',\n", + " '',\n", + " '',\n", + " '',\n", + " 'to the only begetter of',\n", + " 'these insuing sonnets',\n", + " 'mr. w. h. all happiness',\n", + " 'and that eternity',\n", + " 'promised by',\n", + " 'our ever-living poet wisheth']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import requests\n", "url = 'https://raw.githubusercontent.com/martin-gorner/tensorflow-rnn-shakespeare/master/shakespeare/sonnets.txt'\n", @@ -77,7 +110,16 @@ "\n", "data = open('sonnets.txt').read()\n", "\n", - "corpus = data.lower().split(\"\\n\")" + "corpus = data.lower().split(\"\\n\")\n", + "print(type(corpus))\n", + "print(f\"{len(corpus)} lines\")\n", + "\n", + "count = 0\n", + "for line in corpus:\n", + " count += len(line)\n", + "print(f\"{count} characters\")\n", + "\n", + "corpus[:10]" ] }, { @@ -89,11 +131,15 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "# Your code here :" + "# Your code here :\n", + "\n", + "# initialize and fit tokenizer on corpus\n", + "tokenizer = Tokenizer()\n", + "tokenizer.fit_on_texts(corpus)\n" ] }, { @@ -109,11 +155,26 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vocabulary Size: 3375\n", + "death 157\n" + ] + } + ], "source": [ - "# Your code here :" + "# Your code here :\n", + "total_words = len(tokenizer.word_index) + 1\n", + "print(\"Vocabulary Size:\", total_words)\n", + "\n", + "# access a given word's index\n", + "word = \"death\"\n", + "print(word, tokenizer.word_index[word])" ] }, { @@ -130,11 +191,42 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tsonnets [3, 2]\n", + " [3, 2, 313]\n", + " [3, 2, 313, 1375]\n", + " [3, 2, 313, 1375, 4]\n", + "to the only begetter of [118, 1376]\n", + "these insuing sonnets [118, 1376, 878]\n", + "mr. w. h. all happiness [1377, 1378]\n", + "and that eternity [1377, 1378, 1379]\n", + "promised by [1377, 1378, 1379, 23]\n", + "our ever-living poet wisheth [1377, 1378, 1379, 23, 1380]\n" + ] + } + ], "source": [ - "# Your code here :" + "# Your code here :\n", + "input_sequences = []\n", + "\n", + "for sentence in corpus:\n", + " \n", + " # convert text to a sequence of tokens\n", + " token_list = tokenizer.texts_to_sequences([sentence])[0]\n", + " \n", + " # create n-gram sequences\n", + " for i in range(1, len(token_list)):\n", + " n_gram_sequence = token_list[:i+1]\n", + " input_sequences.append(n_gram_sequence)\n", + "\n", + "for i in range(10):\n", + " print(corpus[i], input_sequences[i])\n" ] }, { @@ -149,11 +241,48 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max sequence length: 11\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 313],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 3, 2, 313, 1375],\n", + " [ 0, 0, 0, 0, 0, 0, 3, 2, 313, 1375, 4],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 1376],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 118, 1376, 878],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1377, 1378],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 1377, 1378, 1379],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 1377, 1378, 1379, 23],\n", + " [ 0, 0, 0, 0, 0, 0, 1377, 1378, 1379, 23, 1380]],\n", + " dtype=int32)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Your code here :" + "# Your code here :\n", + "# length of the longest sequence\n", + "max_sequence_len = max([len(seq) for seq in input_sequences])\n", + "print(\"Max sequence length:\", max_sequence_len)\n", + "\n", + "# padding\n", + "input_sequences_padded = pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')\n", + "input_sequences = np.array(input_sequences_padded)\n", + "\n", + "input_sequences[:10]\n" ] }, { @@ -170,14 +299,27 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "id": "PRnDnCW-Z7qv", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(15484, 10) (15484,)\n" + ] + } + ], "source": [ - "# Your code here :" + "# Your code here :\n", + "# split dataset into predictors and labels\n", + "X = input_sequences[:, :-1] # all but last element\n", + "y = input_sequences[:, -1] # last element only\n", + "\n", + "print(X.shape, y.shape)" ] }, { @@ -197,11 +339,25 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(15484, 3375)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Your code here :" + "# Your code here :\n", + "y = ku.to_categorical(y, num_classes=total_words)\n", + "\n", + "y.shape\n" ] }, { @@ -229,15 +385,36 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-04 13:21:59.307928: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 13:21:59.992911: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 13:21:59.993291: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 13:21:59.995172: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 13:21:59.995450: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 13:21:59.995693: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 13:22:03.802363: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 13:22:03.802601: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 13:22:03.802815: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2024-10-04 13:22:03.802939: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 7393 MB memory: -> device: 0, name: Quadro P4000, pci bus id: 0000:00:05.0, compute capability: 6.1\n" + ] + } + ], "source": [ - "model = Sequential([\n", + "# Your code here :\n", + "model = Sequential()\n", "\n", - " # Your code here :\n", - " \n", - "])" + "model.add(Embedding(input_dim=total_words, output_dim=100, input_length=max_sequence_len-1))\n", + "model.add(Bidirectional(LSTM(150, return_sequences=True)))\n", + "model.add(Dropout(0.2))\n", + "model.add(LSTM(100))\n", + "model.add(Dense(total_words // 2, activation='relu', kernel_regularizer=regularizers.l2(0.01)))\n", + "model.add(Dense(total_words, activation='softmax'))\n" ] }, { @@ -251,11 +428,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "# Your code here :" + "# Your code here :\n", + "model.compile(loss=\"categorical_crossentropy\", optimizer='adam', metrics=['accuracy'])" ] }, { @@ -269,11 +447,41 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " embedding (Embedding) (None, 10, 100) 337500 \n", + " \n", + " bidirectional (Bidirection (None, 10, 300) 301200 \n", + " al) \n", + " \n", + " dropout (Dropout) (None, 10, 300) 0 \n", + " \n", + " lstm_1 (LSTM) (None, 100) 160400 \n", + " \n", + " dense (Dense) (None, 1687) 170387 \n", + " \n", + " dense_1 (Dense) (None, 3375) 5697000 \n", + " \n", + "=================================================================\n", + "Total params: 6666487 (25.43 MB)\n", + "Trainable params: 6666487 (25.43 MB)\n", + "Non-trainable params: 0 (0.00 Byte)\n", + "_________________________________________________________________\n" + ] + } + ], "source": [ - "# Your code here :" + "# Your code here :\n", + "model.summary()" ] }, { @@ -293,14 +501,150 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 17, "metadata": { "id": "AIg2f1HBxqof", "tags": [] }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-10-04 13:24:26.347796: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8907\n", + "2024-10-04 13:24:28.012494: I external/local_xla/xla/service/service.cc:168] XLA service 0x7fbf3400bc80 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", + "2024-10-04 13:24:28.012798: I external/local_xla/xla/service/service.cc:176] StreamExecutor device (0): Quadro P4000, Compute Capability 6.1\n", + "2024-10-04 13:24:28.069481: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1728048268.347511 554 device_compiler.h:186] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "484/484 [==============================] - 27s 30ms/step - loss: 6.9118 - accuracy: 0.0211\n", + "Epoch 2/50\n", + "484/484 [==============================] - 7s 15ms/step - loss: 6.5102 - accuracy: 0.0227\n", + "Epoch 3/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 6.4166 - accuracy: 0.0249\n", + "Epoch 4/50\n", + "484/484 [==============================] - 7s 15ms/step - loss: 6.2943 - accuracy: 0.0296\n", + "Epoch 5/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 6.1935 - accuracy: 0.0362\n", + "Epoch 6/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 6.1136 - accuracy: 0.0394\n", + "Epoch 7/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 6.0423 - accuracy: 0.0406\n", + "Epoch 8/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 5.9660 - accuracy: 0.0447\n", + "Epoch 9/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 5.8683 - accuracy: 0.0495\n", + "Epoch 10/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 5.7647 - accuracy: 0.0532\n", + "Epoch 11/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 5.6536 - accuracy: 0.0610\n", + "Epoch 12/50\n", + "484/484 [==============================] - 6s 12ms/step - loss: 5.5417 - accuracy: 0.0696\n", + "Epoch 13/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 5.4362 - accuracy: 0.0718\n", + "Epoch 14/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 5.3303 - accuracy: 0.0800\n", + "Epoch 15/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 5.2174 - accuracy: 0.0898\n", + "Epoch 16/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 5.1103 - accuracy: 0.0941\n", + "Epoch 17/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 4.9965 - accuracy: 0.1033\n", + "Epoch 18/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 4.8907 - accuracy: 0.1126\n", + "Epoch 19/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 4.7854 - accuracy: 0.1201\n", + "Epoch 20/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 4.6776 - accuracy: 0.1301\n", + "Epoch 21/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 4.5690 - accuracy: 0.1371\n", + "Epoch 22/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 4.4588 - accuracy: 0.1507\n", + "Epoch 23/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 4.3521 - accuracy: 0.1594\n", + "Epoch 24/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 4.2492 - accuracy: 0.1741\n", + "Epoch 25/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 4.1396 - accuracy: 0.1886\n", + "Epoch 26/50\n", + "484/484 [==============================] - 6s 12ms/step - loss: 4.0339 - accuracy: 0.2045\n", + "Epoch 27/50\n", + "484/484 [==============================] - 6s 12ms/step - loss: 3.9307 - accuracy: 0.2206\n", + "Epoch 28/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 3.8275 - accuracy: 0.2375\n", + "Epoch 29/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 3.7297 - accuracy: 0.2607\n", + "Epoch 30/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 3.6358 - accuracy: 0.2725\n", + "Epoch 31/50\n", + "484/484 [==============================] - 7s 13ms/step - loss: 3.5436 - accuracy: 0.2966\n", + "Epoch 32/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 3.4427 - accuracy: 0.3171\n", + "Epoch 33/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 3.3724 - accuracy: 0.3339\n", + "Epoch 34/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 3.2801 - accuracy: 0.3484\n", + "Epoch 35/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 3.2025 - accuracy: 0.3679\n", + "Epoch 36/50\n", + "484/484 [==============================] - 7s 13ms/step - loss: 3.1201 - accuracy: 0.3883\n", + "Epoch 37/50\n", + "484/484 [==============================] - 6s 12ms/step - loss: 3.0523 - accuracy: 0.3992\n", + "Epoch 38/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 2.9743 - accuracy: 0.4177\n", + "Epoch 39/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 2.8957 - accuracy: 0.4368\n", + "Epoch 40/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 2.8334 - accuracy: 0.4486\n", + "Epoch 41/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 2.7698 - accuracy: 0.4624\n", + "Epoch 42/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 2.7160 - accuracy: 0.4749\n", + "Epoch 43/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 2.6527 - accuracy: 0.4923\n", + "Epoch 44/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 2.5896 - accuracy: 0.5034\n", + "Epoch 45/50\n", + "484/484 [==============================] - 7s 15ms/step - loss: 2.5364 - accuracy: 0.5196\n", + "Epoch 46/50\n", + "484/484 [==============================] - 7s 14ms/step - loss: 2.4922 - accuracy: 0.5256\n", + "Epoch 47/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 2.4239 - accuracy: 0.5457\n", + "Epoch 48/50\n", + "484/484 [==============================] - 6s 12ms/step - loss: 2.3752 - accuracy: 0.5558\n", + "Epoch 49/50\n", + "484/484 [==============================] - 6s 12ms/step - loss: 2.3262 - accuracy: 0.5634\n", + "Epoch 50/50\n", + "484/484 [==============================] - 6s 13ms/step - loss: 2.2734 - accuracy: 0.5759\n" + ] + } + ], + "source": [ + "# Your code here :\n", + "history = model.fit(X, y, epochs=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, "outputs": [], "source": [ - "# Your code here :" + "# Save model\n", + "model.save('shakespeare_text_generator_model.keras')" ] }, { @@ -319,14 +663,51 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 21, "metadata": { "id": "1fXTEO3GJ282", "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHHCAYAAACRAnNyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJeElEQVR4nO3deVxU5eIG8OfMMAz7AMoqCC4IbuCCIqKZuWtuuZRaaWmm4pbZvXW7t2y7Wt5MzT1NrVxy1yxzy41FxX1HUTYFBRd2GGDm/f1Bzi9yBQfODDzfz2c+1zlzGJ45H7vzeM77vkcSQggQERERmSCF3AGIiIiIHoVFhYiIiEwWiwoRERGZLBYVIiIiMlksKkRERGSyWFSIiIjIZLGoEBERkcliUSEiIiKTxaJCREREJotFhYgqnCRJmDZtWpl/LiEhAZIkYcWKFUbPRETmgUWFqJpYsWIFJEmCJEmIiIh44HUhBLy9vSFJEl588UUZEpbf/v37IUkSNmzYIHcUIjIyFhWiasbKygqrV69+YPuBAwdw/fp1qNVqGVIRET0ciwpRNdOzZ0+sX78excXFpbavXr0aLVu2hLu7u0zJiIgexKJCVM0MGTIEd+7cwe7duw3bCgsLsWHDBgwdOvShP5Obm4t3330X3t7eUKvV8Pf3x//+9z/8/ebrWq0W77zzDlxcXGBvb48+ffrg+vXrD33PGzdu4M0334SbmxvUajUaN26M77//3ngf9CGuXbuGQYMGwdnZGTY2NmjTpg1+/fXXB/b79ttv0bhxY9jY2MDJyQnBwcGlzkJlZ2dj8uTJ8PX1hVqthqurK7p06YITJ05UaH6i6ohFhaia8fX1RWhoKNasWWPYtmPHDmRmZuKVV155YH8hBPr06YNvvvkG3bt3x6xZs+Dv74/33nsPU6ZMKbXvqFGjMHv2bHTt2hUzZsyASqVCr169HnjPW7duoU2bNtizZw/Gjx+POXPmoH79+hg5ciRmz55t9M98/3e2bdsWO3fuxLhx4/DFF1+goKAAffr0webNmw37fffdd5g4cSIaNWqE2bNn45NPPkGzZs1w5MgRwz5jxozBwoULMWDAACxYsABTp06FtbU1Ll68WCHZiao1QUTVwvLlywUAERMTI+bNmyfs7e1FXl6eEEKIQYMGiY4dOwohhPDx8RG9evUy/NyWLVsEAPH555+Xer+BAwcKSZJEXFycEEKIU6dOCQBi3LhxpfYbOnSoACA+/vhjw7aRI0cKDw8Pcfv27VL7vvLKK0Kj0RhyxcfHCwBi+fLlj/1s+/btEwDE+vXrH7nP5MmTBQBx6NAhw7bs7GxRp04d4evrK3Q6nRBCiL59+4rGjRs/9vdpNBoRHh7+2H2IyDh4RoWoGho8eDDy8/Oxfft2ZGdnY/v27Y+87PPbb79BqVRi4sSJpba/++67EEJgx44dhv0APLDf5MmTSz0XQmDjxo3o3bs3hBC4ffu24dGtWzdkZmZWyCWU3377Da1bt0a7du0M2+zs7DB69GgkJCTgwoULAABHR0dcv34dMTExj3wvR0dHHDlyBCkpKUbPSUSlsagQVUMuLi7o3LkzVq9ejU2bNkGn02HgwIEP3TcxMRGenp6wt7cvtb1hw4aG1+//r0KhQL169Urt5+/vX+p5eno6MjIysGTJEri4uJR6vPHGGwCAtLQ0o3zOv3+Ov2d52Of45z//CTs7O7Ru3Rp+fn4IDw9HZGRkqZ/56quvcO7cOXh7e6N169aYNm0arl27ZvTMRARYyB2AiOQxdOhQvPXWW7h58yZ69OgBR0fHSvm9er0eAPDqq69i+PDhD90nMDCwUrI8TMOGDREbG4vt27fj999/x8aNG7FgwQJ89NFH+OSTTwCUnJFq3749Nm/ejF27dmHmzJn48ssvsWnTJvTo0UO27ERVEc+oEFVT/fv3h0KhwOHDhx952QcAfHx8kJKSguzs7FLbL126ZHj9/v/q9XpcvXq11H6xsbGlnt+fEaTT6dC5c+eHPlxdXY3xER/4HH/P8rDPAQC2trZ4+eWXsXz5ciQlJaFXr16Gwbf3eXh4YNy4cdiyZQvi4+NRo0YNfPHFF0bPTVTdsagQVVN2dnZYuHAhpk2bht69ez9yv549e0Kn02HevHmltn/zzTeQJMlwBuH+/86dO7fUfn+fxaNUKjFgwABs3LgR586de+D3paenl+fjPFHPnj1x9OhRREdHG7bl5uZiyZIl8PX1RaNGjQAAd+7cKfVzlpaWaNSoEYQQKCoqgk6nQ2ZmZql9XF1d4enpCa1WWyHZiaozXvohqsYedenlr3r37o2OHTviww8/REJCAoKCgrBr1y5s3boVkydPNoxJadasGYYMGYIFCxYgMzMTbdu2xd69exEXF/fAe86YMQP79u1DSEgI3nrrLTRq1Ah3797FiRMnsGfPHty9e7dcn2fjxo2GMyR//5zvv/8+1qxZgx49emDixIlwdnbGypUrER8fj40bN0KhKPl3W9euXeHu7o6wsDC4ubnh4sWLmDdvHnr16gV7e3tkZGTAy8sLAwcORFBQEOzs7LBnzx7ExMTg66+/LlduInoMeScdEVFl+ev05Mf5+/RkIUqm8b7zzjvC09NTqFQq4efnJ2bOnCn0en2p/fLz88XEiRNFjRo1hK2trejdu7dITk5+YHqyEELcunVLhIeHC29vb6FSqYS7u7vo1KmTWLJkiWGfsk5PftTj/pTkq1evioEDBwpHR0dhZWUlWrduLbZv317qvRYvXiyee+45UaNGDaFWq0W9evXEe++9JzIzM4UQQmi1WvHee++JoKAgYW9vL2xtbUVQUJBYsGDBYzMSUflIQvxtaUkiIiIiE8ExKkRERGSyWFSIiIjIZLGoEBERkcliUSEiIiKTxaJCREREJotFhYiIiEyWWS/4ptfrkZKSAnt7e0iSJHccIiIiegpCCGRnZ8PT09Ow2OKjmHVRSUlJgbe3t9wxiIiIqBySk5Ph5eX12H3Muqjcv+18cnIyHBwcZE5DRERETyMrKwve3t6G7/HHMeuicv9yj4ODA4sKERGRmXmaYRscTEtEREQmi0WFiIiITBaLChEREZksWceo+Pr6IjEx8YHt48aNw/z582VIREREVLL8RWFhodwxzJZKpYJSqTTKe8laVGJiYqDT6QzPz507hy5dumDQoEEypiIiouqssLAQ8fHx0Ov1ckcxa46OjnB3d3/mdc5kLSouLi6lns+YMQP16tVDhw4dZEpERETVmRACqampUCqV8Pb2fuJiZPQgIQTy8vKQlpYGAPDw8Him9zOZ6cmFhYX46aefMGXKFK4yS0REsiguLkZeXh48PT1hY2MjdxyzZW1tDQBIS0uDq6vrM10GMpmismXLFmRkZGDEiBGP3Eer1UKr1RqeZ2VlVUIyIiKqLu4PR7C0tJQ5ifm7X/SKioqeqaiYzDmtZcuWoUePHvD09HzkPtOnT4dGozE8uHw+ERFVBJ7Zf3bGOoYmUVQSExOxZ88ejBo16rH7ffDBB8jMzDQ8kpOTKykhERERycEkisry5cvh6uqKXr16PXY/tVptWC6fy+YTERFVHF9fX8yePVvuGPIXFb1ej+XLl2P48OGwsDCZITNERERmQZKkxz6mTZtWrveNiYnB6NGjjRu2HGRvBnv27EFSUhLefPNNuaOUciMjH9oiHeq62MkdhYiI6JFSU1MNf/7555/x0UcfITY21rDNzu7/v8eEENDpdE91YuDvS4jIRfYzKl27doUQAg0aNJA7isH3EfEIm/EHvt59We4oREREj+Xu7m54aDQaSJJkeH7p0iXY29tjx44daNmyJdRqNSIiInD16lX07dsXbm5usLOzQ6tWrbBnz55S7/v3Sz+SJGHp0qXo378/bGxs4Ofnh23btlX455O9qJii5rUdAQD7L6WhoEj3+J2JiKjKEkIgr7BYlocQwmif4/3338eMGTNw8eJFBAYGIicnBz179sTevXtx8uRJdO/eHb1790ZSUtJj3+eTTz7B4MGDcebMGfTs2RPDhg3D3bt3jZbzYWS/9GOKgrwc4eagxq0sLaKu3sYLAW5yRyIiIhnkF+nQ6KOdsvzuC592g42lcb6mP/30U3Tp0sXw3NnZGUFBQYbnn332GTZv3oxt27Zh/Pjxj3yfESNGYMiQIQCA//73v5g7dy6OHj2K7t27GyXnw/CMykMoFBK6NnIHAOw8d0vmNERERM8mODi41POcnBxMnToVDRs2hKOjI+zs7HDx4sUnnlEJDAw0/NnW1hYODg6GpfIrCs+oPEK3xu748XAi9ly8BZ1eQKng4j9ERNWNtUqJC592k+13G4utrW2p51OnTsXu3bvxv//9D/Xr14e1tTUGDhz4xDtGq1SqUs8lSarwmzeyqDxCSF1naKxVuJNbiGMJdxFSt4bckYiIqJJJkmS0yy+mJDIyEiNGjED//v0BlJxhSUhIkDfUI/DSzyOolAp0CnAFAOw8z8s/RERUdfj5+WHTpk04deoUTp8+jaFDh1b4mZHyYlF5jK6N/xyncv6mUUdfExERyWnWrFlwcnJC27Zt0bt3b3Tr1g0tWrSQO9ZDScKMv4GzsrKg0WiQmZlZIcvp5xfq0PyzXSgo0mP7hHZoUktj9N9BRESmo6CgAPHx8ahTpw6srKzkjmPWHncsy/L9zTMqj2FtqcRzfiUr8+26wMs/RERElY1F5QnuX/7Zdf6mzEmIiIiqHxaVJ+jc0BVKhYRLN7OReCdX7jhERETVCovKEzjaWCKkjjOAkkG1REREVHlYVJ5CN8PsH45TISKqDsx4nonJMNYxZFF5Cl0bl9zr50TSPaRlF8ichoiIKopSWbIa7JNWaKUny8vLA/DgarZlVfWW26sAHhprBHlpcPp6JnZfuIVhIT5yRyIiogpgYWEBGxsbpKenQ6VSQaHgv+fLSgiBvLw8pKWlwdHR0VD+yotF5Sl1beyO09czsfM8iwoRUVUlSRI8PDwQHx+PxMREueOYNUdHR7i7uz/z+7CoPKVujd0xc2csoq/eRlZBERysnu1UFhERmSZLS0v4+fnx8s8zUKlUz3wm5T4WladU39UO9VxscTU9F/supaFvs1pyRyIiogqiUCi4Mq2J4MW3Muj2l3v/EBERUcVjUSmD+0Vlf2w6Cop0MqchIiKq+lhUyiDQSwMPjRXyCnWIuHJb7jhERERVHotKGUiShK6NStZU4eUfIiKiiseiUkb3L//suXgLxTq9zGmIiIiqNhaVMmpdxxmONircyytCTMI9ueMQERFVaSwqZWShVKBTAC//EBERVQYWlXLo9ue9f3ZfuMUbVxEREVUgFpVyeK6BC6xVStzIyMe5G1lyxyEiIqqyWFTKwUqlRIcGLgB4+YeIiKgisaiUU7cmJZd/Np64jmvpOTKnISIiqppYVMqpc0M3uDtYITWzAC9+G4FNJ67LHYmIiKjKYVEpJ3srFbaOD0Obus7IK9RhyrrTmLLuFHK1xXJHIyIiqjJYVJ6Bm4MVVo1qgyldGkAhAZtO3EDveRG4kMIBtkRERMbAovKMlAoJEzv5Yc1bbeDuYIVr6bnotyASP0QncOoyERHRM2JRMZKQujXw26T26BTgisJiPT7aeh5jfjqOzLwiuaMRERGZLRYVI3K2tcTS4cH46MVGUCkl7Dx/Cz3nHsLxxLtyRyMiIjJLLCpGJkkS3mxXB5vGhsGnhg1uZOTjlSWH8fu5VLmjERERmR0WlQrS1EuD7RPaoUcTdxTpBMJXn8TWUzfkjkVERGRWWFQqkL2VCvOGtsDAll7Q6QUm/3wK62KS5Y5FRERkNlhUKphSIeGrAYF4tU1tCAH8Y+MZ/BCdIHcsIiIis8CiUgkUCgmf9W2Cke3qAAA+2noeSw5elTkVERGR6WNRqSSSJOHfvRpifMf6AID//nYJc/Zc4VorREREj8GiUokkScLUbv6Y2rUBAOCbPZfx1c5YlhUiIqJHYFGRwfgX/PDvXg0BAAv3X8Unv1xgWSEiInoIFhWZjGpfF5/3awIAWBGVgH9tPgudnmWFiIjor1hUZPRqGx/MHBgIhQSsOZqMN1bEICOvUO5YREREJoNFRWaDgr0xb2gLWKkUOHg5nXdfJiIi+gsWFRPQs6kHNo0Ng7ezNZLv5uOlhZFcxZaIiAgsKiajkacDfhnfDu39aqKgSI9Ja0/h8+0XUKzTyx2NiIhINiwqJsTRxhIr3miNcc/XAwAsjYjHa8uO4k6OVuZkRERE8mBRMTFKhYR/dA/AwmEtYGupRPS1O+j9bQTOXM+QOxoREVGlY1ExUT2aemBLeBjq1LRFSmYBBi6KxvpjvKEhERFVLywqJszPzR5bx4ehc0NXFBbr8d6GM5i45iTSs3kpiIiIqgcWFRPnYKXCkteC8U7nBlBIwLbTKeg86wDWHk2CngvEERFRFceiYgYUCgmTOvthS3gYGns6IDO/CO9vOotXlhxGXFq23PGIiIgqDIuKGQn0csTW8DD8u1dDWKuUOJpwFz3mHMKs3ZdRUKSTOx4REZHRsaiYGQulAqPa18XuKc/hhQBXFOkE5u69gp5zDiHq6m254xERERkVi4qZ8nKywbLhwZg/tAVc7NW4djsXQ787gqnrT+NuLu8XREREVQOLihmTJAm9Aj2wZ0oHvNqmNiQJ2HD8Op6fuQ/fHbwGbTEvBxERkXmThBBmO3UkKysLGo0GmZmZcHBwkDuO7I4n3sO/t5zDxdSSmxrWdrbBBz0C0L2JOyRJkjkdERFRibJ8f7OoVDE6vcDG49cxc1esYb2VVr5O+HevRgjydpQ3HBEREVhUCECuthiLD17DkoNXUVBUcmPDfs088V73ANRytJY5HRERVWcsKmSQmpmPmTtjsenEDQCA2kKBUe3rYOzz9WGntpA5HRERVUdl+f6WfTDtjRs38Oqrr6JGjRqwtrZG06ZNcezYMbljVRkeGmvMGtwMv4xvh5A6ztAW6zF/31V0/N9+bD11A2bcU4mIqBqQtajcu3cPYWFhUKlU2LFjBy5cuICvv/4aTk5Ocsaqkpp6abB2dBssea0lfGvYID1bi0lrT+GVJYcRe5Or2xIRkWmS9dLP+++/j8jISBw6dKhcP89LP+WjLdZh6aF4fPvHFRQU6aFUSHijrS8mdfaDvZVK7nhERFTFmc2ln23btiE4OBiDBg2Cq6srmjdvju++++6R+2u1WmRlZZV6UNmpLZQI71gfe6Z0QLfGbtDpBZZGxKPT1wd4OYiIiEyKrEXl2rVrWLhwIfz8/LBz506MHTsWEydOxMqVKx+6//Tp06HRaAwPb2/vSk5ctXg52WDxa8FY8UYr+NawQdpfLgddvsXLQUREJD9ZL/1YWloiODgYUVFRhm0TJ05ETEwMoqOjH9hfq9VCq9UanmdlZcHb25uXfoxAW6zDdwevYd6+OBQU6WGhkPBmuzp4t2sDqC2UcscjIqIqxGwu/Xh4eKBRo0altjVs2BBJSUkP3V+tVsPBwaHUg4xDbaHE+Bf8DJeDivUCSw5ew+BF0bh+L0/ueEREVE3JWlTCwsIQGxtbatvly5fh4+MjUyK6fzlo6evBcLRR4fT1TLz4bQT2xabJHY2IiKohWYvKO++8g8OHD+O///0v4uLisHr1aixZsgTh4eFyxiIAnRu5YfuEdgj00iAjrwhvrojBrF2x0Ok50JaIiCqP7CvTbt++HR988AGuXLmCOnXqYMqUKXjrrbee6mc5PbniaYt1+Gz7Bfx0uORyXHu/mpj9cjPUsFPLnIyIiMwVl9Ano9ty8gY+2HQW+UU6eGisMH9YC7SozYX5iIio7MxmMC2Zj37Na2FLeBjqutgiNbMALy+OxorIeK65QkREFYpFhZ6av7s9to1vh15NPVCkE5j2ywVMWHMSudpiuaMREVEVxaJCZWKntsC8oc3x0YuNYKGQsP1MKgYsjELyXU5hJiIi42NRoTKTpJLF4NaOboOadmpcupmNPvMiEHX1ttzRiIioimFRoXIL9nXGLxPC0LSWBvfyivDasqNYGZXAcStERGQ0LCr0TDw01lg/JhT9mnlCpxf4eNt5fLDpLAqL9XJHIyKiKoBFhZ6ZlUqJb15uhn/1DIBCAtbGJGPod4eRnq198g8TERE9BosKGYUkSRj9XD18P6IV7K0scCzxHvrMi8DZ65lyRyMiIjPGokJG9by/a6n1VgYuisLWUzfkjkVERGaKRYWMrp6LHbaEh6Gjvwu0xXpMWnsKX++K5SBbIiIqMxYVqhAOViosHd4KYzrUAwB8+0cc3l13moNsiYioTFhUqMIoFRLe7xGALwc0hVIhYdPJGxix/Cgy84vkjkZERGaCRYUq3MutauP7Ea1ga6lE1NU7GLQoCikZ+XLHIiIiM8CiQpWiQwMXrBsTCld7NS7fykH/BZE4n8IZQURE9HgsKlRpGntqsDk8DA3c7HArS4vBi6Jx4HK63LGIiMiEsahQparlaI31Y9qibb0ayC3U4c0VMfg5JknuWEREZKJYVKjSaaxVWPFGa7zUvBZ0eoF/bjyLWZy+TERED8GiQrKwtFDg68FBmPhCfQDA3D/i8O56Tl8mIqLSWFRINpIkYUpX//+fvnziBt5cEYOsAk5fJiKiEiwqJLuXW9XGsuHBsLFUIiLuNgYvisbNzAK5YxERkQlgUSGT8Ly/K9a9HQoXezUu3cxG/wWRiL2ZLXcsIiKSGYsKmYwmtTTYNLYt6rvaGW5oGHX1ttyxiIhIRiwqZFK8nW2wYUwoWvs6I7ugGMO/P4otJ3n3ZSKi6opFhUyOo40lfhjZGr0CPVCkE5j88ynM3xfH6ctERNUQiwqZJCuVEt++0hxvta8DAJi5Mxb/3nIOxTpOXyYiqk5YVMhkKRQSPuzVCB/3bgRJAlYdScLbPx5HjrZY7mhERFRJWFTI5L0RVgcLh7WA2kKBvZfSMGBBFJLv5skdi4iIKgGLCpmF7k08sHZ0G7jYqxF7Kxt950ciJuGu3LGIiKiCsaiQ2Whe2wnbxoehSS0H3M0txNDvDmNdTLLcsYiIqAKxqJBZ8dBYY/3bbdGracmMoH9sPIPPt1+ATs8ZQUREVRGLCpkda0slvh3SHJM6+QEAlkbEY+RK3iOIiKgqYlEhs6RQSHinSwPMG9ocagsF9sem46UFUUi8kyt3NCIiMiIWFTJrLwZ6Yv2YULg5qBGXloO+8yMRffWO3LGIiMhIWFTI7AV6OWLb+HYI8tIgI68Iry07gtVHkuSORURERsCiQlWCm4MVfn47FL2DPFGsF/jX5rP45JfzXMmWiMjMsahQlWGlUmLuK80wpUsDAMDyyAS8ufIYB9kSEZkxFhWqUiRJwsROflgwrAWsVAocvMxBtkRE5oxFhaqknk09sP7ttnB3sOIgWyIiM8aiQlVWUy8Nto0P4yBbIiIzxqJCVZorB9kSEZk1FhWq8h41yDabg2yJiEweiwpVCw8bZDt48WHcyiqQOxoRET0GiwpVK/cH2da0U+NiahZeWhCFuLRsuWMREdEjsKhQtdPUS4PN49qibk1b3MjIx4CF0YhJuCt3LCIieggWFaqWvJ1tsGFsWzSv7YjM/CIMW3oEv59LlTsWERH9DYsKVVvOtpZYPaoNOjd0Q2GxHmNXncDKqAS5YxER0V+wqFC1Zm2pxKJXW2BYSG0IAXy87Tym77gIvV7IHY2IiMCiQgQLpQKf92uC97r5AwAWH7iGKetOobCYa60QEcmNRYUIJdOXwzvWx8yBgbBQSNhyKgVvrDjKGxoSEcmMRYXoLwYFe2PZiFawsVQiMu4OBi6MQvLdPLljERFVWywqRH/ToYEL1r0dCld7NS7fykG/+ZE4nsjpy0REcmBRIXqIJrU02Do+DI09HXAntxBDlhzBlpM35I5FRFTtsKgQPYKHxhrr3g5F10ZuKNTpMfnnU5i1K5YzgoiIKhGLCtFj2KotsOjVlhjToR4AYO4fcZiw9iQKinQyJyMiqh5YVIieQKGQ8H6PAHw1MBAqpYRfz6Ti5SWHkcYbGhIRVTgWFaKnNDjYGz+ODIGjjQqnkzPQb34kLqRkyR2LiKhKY1EhKoM2dWtgy7gw1HWxRUpmAQYuisLei7fkjkVEVGWxqBCVkW9NW2weG4Z29Wsir1CHt344hrVHk+SORURUJbGoEJWDxkaF5W+0wuBgL+gF8P6ms5i95zKE4IwgIiJjYlEhKieVUoEvBwRiwgv1AQCz91zBvzafQ7GO9wgiIjIWFhWiZyBJEt7t6o/P+jWBJAFrjiZhzE8nkF/I6ctERMYga1GZNm0aJEkq9QgICJAzElG5vNbGBwuHtYSlhQJ7Lt7CsKWHcS+3UO5YRERmT/YzKo0bN0ZqaqrhERERIXckonLp3sQdq0aFwMHKAieSMjBwURSu3+MNDYmInoXsRcXCwgLu7u6GR82aNeWORFRurXydsXFsW3hqrHA1PRcvLYjCxVSutUJEVF6yF5UrV67A09MTdevWxbBhw5CU9OhpnlqtFllZWaUeRKbGz80eG8e1hb+bPdKytRi8KBpRV2/LHYuIyCzJWlRCQkKwYsUK/P7771i4cCHi4+PRvn17ZGdnP3T/6dOnQ6PRGB7e3t6VnJjo6XhorLFuTCha13FGtrYYw78/ip9juNYKEVFZScKEFn7IyMiAj48PZs2ahZEjRz7wularhVarNTzPysqCt7c3MjMz4eDgUJlRiZ5KQZEO764/jV/PpAIARrWrgw96NoRSIcmcjIhIPllZWdBoNE/1/W1RSZmeiqOjIxo0aIC4uLiHvq5Wq6FWqys5FVH5WamUmDekOfxc7TB7zxUsjYjH1fQczB3SHPZWKrnjERGZPNnHqPxVTk4Orl69Cg8PD7mjEBmNJEmY3LkB5g9tASuVAvti0/HSgigk3eGMICKiJ5G1qEydOhUHDhxAQkICoqKi0L9/fyiVSgwZMkTOWEQVolegB9a9HQo3BzWupOWg7/wIHL52R+5YREQmTdaicv36dQwZMgT+/v4YPHgwatSogcOHD8PFxUXOWEQVJtDLEVvD2yHQS4N7eUV4dekRDrIlInoMkxpMW1ZlGYxDZEryC3WYuuH/B9mObFcH/+IgWyKqJsry/W1SY1SIqgtry5JBtpM7+wEAlkXEY+TKGGQVFMmcjIjItLCoEMnk74Ns9/85yDbxTq7c0YiITAaLCpHMegV6YP3bbeHmoEZcWg76zo/kSrZERH9iUSEyAU29NNg2vh2CvDTIyCvC68uOYtWRRLljERHJjkWFyES4OVjh57dD0beZJ4r1Ah9uPoePt55DsU4vdzQiItmwqBCZECuVErNfbob3uvkDAFZGJ2LE8hhk5nGQLRFVTywqRCZGkiSEd6yPxa+1hI2lEhFxt9FvQSSupufIHY2IqNKxqBCZqG6N3bFhTFvUcrRG/O1c9JsfiYOX0+WORURUqVhUiExYI08HbB0fhmAfJ2QXFGPE8qNYGZUgdywiokrDokJk4mraqbHqrRAMbOkFvQA+3naeg2yJqNpgUSEyA2oLJWYODMQ/uwcAKBlkO+qHY8jmSrZEVMWVq6gkJyfj+vXrhudHjx7F5MmTsWTJEqMFI6LSJEnC2OfrYdGr/7+S7cCF0bh+L0/uaEREFaZcRWXo0KHYt28fAODmzZvo0qULjh49ig8//BCffvqpUQMSUWndm3hg3duhcLFXI/ZWNvrNj8LJpHtyxyIiqhDlKirnzp1D69atAQDr1q1DkyZNEBUVhVWrVmHFihXGzEdEDxHo5Yit4WFo6OGA2zlavLLkMLafSZE7FhGR0ZWrqBQVFUGtVgMA9uzZgz59+gAAAgICkJqaarx0RPRIno7W2DAmFJ0CXKEt1mP86pP4du8VCCHkjkZEZDTlKiqNGzfGokWLcOjQIezevRvdu3cHAKSkpKBGjRpGDUhEj2artsCS14Mxsl0dAMDXuy/j3XWnoS3WyZyMiMg4ylVUvvzySyxevBjPP/88hgwZgqCgIADAtm3bDJeEiKhyKBUS/vNiI3zRvwmUCgmbTt7Aa0uP4l5uodzRiIiemSTKeZ5Yp9MhKysLTk5Ohm0JCQmwsbGBq6ur0QI+TlZWFjQaDTIzM+Hg4FApv5PIlB26ko5xq04gu6AYvjVs8P2IVqjrYid3LCKiUsry/V2uMyr5+fnQarWGkpKYmIjZs2cjNja20koKET2ovZ8LNo1tCy8nayTcyUP/BVE4fO2O3LGIiMqtXEWlb9+++OGHHwAAGRkZCAkJwddff41+/fph4cKFRg1IRGXj52aPzePC0Ly2IzLzi/DasiPYePz6k3+QiMgElauonDhxAu3btwcAbNiwAW5ubkhMTMQPP/yAuXPnGjUgEZWdi70aa95qg16BHijSCby7/jS+3hULvZ4zgojIvJSrqOTl5cHe3h4AsGvXLrz00ktQKBRo06YNEhMTjRqQiMrHSqXEt680R3jHegCAb/+Iw8S1J1FQxBlBRGQ+ylVU6tevjy1btiA5ORk7d+5E165dAQBpaWkc1EpkQhQKCe91C8BXAwNhoZCw/Uwqhn53GHdytHJHIyJ6KuUqKh999BGmTp0KX19ftG7dGqGhoQBKzq40b97cqAGJ6NkNDvbGDyNbw8HKAieSMtBvQSTi0rLljkVE9ETlnp588+ZNpKamIigoCApFSd85evQoHBwcEBAQYNSQj8LpyURlczU9B28sj0HS3Tw4WFlg0Wst0bZeTbljEVE1U5bv73IXlfvu30XZy8vrWd6mXFhUiMrubm4h3vrhGI4n3oNKKeHLAYF4qUXl//dLRNVXha+jotfr8emnn0Kj0cDHxwc+Pj5wdHTEZ599Br1eX67QRFQ5nG0tsWpUCHo1LZkRNGXdaczZw3sEEZFpsijPD3344YdYtmwZZsyYgbCwMABAREQEpk2bhoKCAnzxxRdGDUlExmWlUuLbIc3h5WyNxQeu4Zs9l5F8Lw//7d8Ulhbl+vcLEVGFKNelH09PTyxatMhw1+T7tm7dinHjxuHGjRtGC/g4vPRD9Ox+OpyIj7aeg14AYfVrYMGwltBYq+SORURVWIVf+rl79+5DB8wGBATg7t275XlLIpLJq218sGx4K9hYKhEZdweDFkXh+r08uWMREQEoZ1EJCgrCvHnzHtg+b948BAYGPnMoIqpcHQNcse7tULg5qHH5Vg76L4jC2euZcsciIirfpZ8DBw6gV69eqF27tmENlejoaCQnJ+O3334zLK9f0Xjph8i4UjPz8cbyGFy6mQ3rP8exdG7kJncsIqpiKvzST4cOHXD58mX0798fGRkZyMjIwEsvvYTz58/jxx9/LFdoIpKfh8Ya68eEor1fTeQX6TD6x2NYeugaZwQRkWyeeR2Vvzp9+jRatGgBna5y7iXCMypEFaNIp8dHW89hzdFkAMCQ1t74tG8TqJScEUREz67Cz6gQUdWmUirw3/5N8e9eDSFJwJqjyXh92VFk5BXKHY2IqhkWFSJ6KEmSMKp9XSwbHgxbSyWir91B/wVRuJaeI3c0IqpGWFSI6LFeCHDDxnFtUcvRGvG3c9F/QRSi4m7LHYuIqokyrUz70ksvPfb1jIyMZ8lCRCYqwN0BW8LD8PaPx3AiKQOvf38Un/ZtgqEhteWORkRVXJmKikajeeLrr7/++jMFIiLT5GKvxuq32uD9jWew5VQK/rX5LOLScvBhr4ZQKiS54xFRFWXUWT+VjbN+iCqfEALz98Xhf7suAwA6+rtgzpDmcLDisvtE9HQ464eIKowkSRj/gh8WDGsBK5UC+2LT0W9+JK5ykC0RVQAWFSIql55NPbD+7bbw0FjhWnou+s2LxL5LaXLHIqIqhkWFiMqtqZcG28a3Q7CPE7K1xXhzZQwW7I/jSrZEZDQsKkT0TO4Psh0aUhtCAF/9HosJa04ir7BY7mhEVAWwqBDRM7O0KFnJ9vN+TWChkLD9TCoGLIxG8t08uaMRkZljUSEio3m1jQ9Wv9UGNWwtcTE1C33nRyL66h25YxGRGWNRISKjal3HGdsmtEOTWg64m1uIV5cdwcqoBI5bIaJyYVEhIqOr5WiN9W+3Rd9mntDpBT7edh7/2XoOxTq93NGIyMywqBBRhbC2VGL2y83wQY8ASBLw0+EkjPrhGHK0HGRLRE+PRYWIKowkSXi7Qz0s/HNxuP2x6Ri0KBqpmflyRyMiM8GiQkQVrnsTD6wdHYqadiWDbPvNj8T5lEy5YxGRGWBRIaJK0czbEZvHhaG+qx1uZWkxeFE0V7IloidiUSGiSuPtbIONY9uibb0ayC3UYeTKGPx4OFHuWERkwlhUiKhSaaxVWPFGawxs6QW9AP6z5Ry++PUC9HpOXyaiB7GoEFGls7RQYObAQEzt2gAA8N2heIxddRz5hTqZkxGRqWFRISJZSJKE8S/4Yc4rzWCpVGDn+VsYvDgaNzML5I5GRCaERYWIZNW3WS2seisETjYqnL2RiT7zInDmeobcsYjIRLCoEJHsWvk6Y2t4O/i52iEtW4tBi6Lxy+kUuWMRkQlgUSEik1C7hg02jWuLjv4u0BbrMWHNSXyz+zIH2RJVcywqRGQy7K1UWDq8Fd5qXwcAMGfvFUxYc5KDbImqMRYVIjIpSoWED3s1wlcDAqFSSvj1bCoH2RJVYywqRGSSBrfyxqpRbeBsa2kYZHs6OUPuWERUyUymqMyYMQOSJGHy5MlyRyEiE9G6jjO2hoehgVvJINvBi6OxjYNsiaoVkygqMTExWLx4MQIDA+WOQkQm5v6y+y8EuEJbrMfENSfx5e+XoOMgW6JqQfaikpOTg2HDhuG7776Dk5OT3HGIyATZW6nw3evBeLtDXQDAwv1XMWplDLIKimRORkQVTfaiEh4ejl69eqFz585P3Fer1SIrK6vUg4iqB6VCwgc9GmLOK82gtlBgX2w6+s2PxNX0HLmjEVEFkrWorF27FidOnMD06dOfav/p06dDo9EYHt7e3hWckIhMTd9mtbBhTFt4aKxwLT0X/eZFYt+lNLljEVEFka2oJCcnY9KkSVi1ahWsrKye6mc++OADZGZmGh7JyckVnJKITFFTLw22jW+HVr5OyNYW482VMVi4/yqE4LgVoqpGEjL9l71lyxb0798fSqXSsE2n00GSJCgUCmi12lKvPUxWVhY0Gg0yMzPh4OBQ0ZGJyMQUFusx7ZfzWH0kCQDQO8gTXw0IhLXl4/+/g4jkVZbvb9mKSnZ2NhITE0tte+ONNxAQEIB//vOfaNKkyRPfg0WFiADgp8OJmLbtPIr1Ao09HbDk9WDUcrSWOxYRPUJZvr8tKinTA+zt7R8oI7a2tqhRo8ZTlRQiovtebeMDP1c7jFt1AudTstDn2wgsGNYCIXVryB2NiJ6R7LN+iIiMIaRuDWyb0A6NPR1wJ7cQw5YewU+HE5/8g0Rk0mS79GMMvPRDRH+XX6jDextOY/uZVADA0JDamNa7MSwt+O8yIlNRlu9v/pdLRFWKtaUS3w5pjn9094ckAauPJGHY0sNIz9bKHY2IyoFFhYiqHEmSMO75+vh+eCvYqy0Qk3APfedF4NyNTLmjEVEZsagQUZXVMcAVW8aHoW5NW6RkFmDAwihsPXVD7lhEVAYsKkRUpdVzscPm8DB09HeBtliPSWtPYcYO3tSQyFywqBBRlaexVmHp8FYY+3w9AMCiA1cxcmUMMvIKZU5GRE/CokJE1YJSIeGf3QMw55VmsFIpsD82HS9+G4Gz1zluhciUsagQUbVy/6aGtZ1tcP1ePgYsjMLqI0m8TxCRiWJRIaJqp0ktDX6Z0A6dG7qhUKfHvzafxbvrTyO/UCd3NCL6GxYVIqqWNNYqLHmtJf7ZPQAKCdh04gb6L4jEtfQcuaMR0V+wqBBRtaVQSBj7fD2sGtUGNe3UuHQzG33mReL3c6lyRyOiP7GoEFG1F1qvBn6b2A6tfZ2Roy3GmJ9O4PPtF1Ck08sdjajaY1EhIgLg6mCF1W+F4O3n6gIAlkbEY+h3h3Ezs0DmZETVG4sKEdGfLJQKfNCzIRa/1tKw9H6POQfxx6VbckcjqrZYVIiI/qZbY3f8MqEdmtRywL28Iry54hi++PUCCot5KYiosrGoEBE9hG9NW2wc2xYj2voCAL47FI9Bi6KQdCdP3mBE1QyLChHRI6gtlJjWpzGWvNYSGmsVTl/PRK+5h/DrGc4KIqosLCpERE/QtbE7fpvUHi19nJCtLUb46hP4cPNZFBRxgTiiisaiQkT0FGo5WmPt6DYY93w9SBKw6kgS+s2PRFwaF4gjqkgsKkRET0mlVOAf3QOw8o3WqGlniUs3s9H72wisO5bMewURVRAWFSKiMnqugQt+m9QeYfVrIL9Ih39sOIOJa08hq6BI7mhEVQ6LChFRObjaW+GHN0PwXjd/KBUSfjmdgp5zDuFE0j25oxFVKSwqRETlpFRICO9YH+vHhMLLyRrX7+Vj0KJozN8XB52el4KIjIFFhYjoGbWo7YTfJrVH7yBP6PQCM3fG4tWlR7j8PpERsKgQERmBg5UKc19phpkDA2FjqUT0tTvoMecg9lzg8vtEz4JFhYjISCRJwqBgb2yf0A6NPUuW3x/1wzFM23aea64QlROLChGRkdV1scOmcW0xql0dAMCKqAQMWBiF5Ltcfp+orFhUiIgqgNpCiX+/2Agr3mgFZ1tLnE/JQp95EYi4clvuaERmhUWFiKgCPe/viu0T2iHQS4N7eUV4/fsjWHzgKheII3pKLCpERBXM09Ea694OxaCWXtALYPqOSxi/5iTyCovljkZk8lhUiIgqgZVKia8GBuKzfk1goZDw65lU9J8fhYTbuXJHIzJpLCpERJVEkiS81sYHa0e3gYu9GrG3stFnXgT2xabJHY3IZLGoEBFVsmBfZ2yf0A4tajsiq6AYb66Iwbw/rkDP1WyJHsCiQkQkAzcHK6wdHYphIbUhBPC/XZcxcmUM4nkpiKgUFhUiIplYWijwRf+m+HJAU1gqFdgXm44usw5g2rbzuJtbKHc8IpPAokJEJLOXW9XGrxPb4YUAVxTrBVZEJaDDV/uw6MBVrmhL1Z4kzHgyf1ZWFjQaDTIzM+Hg4CB3HCKiZxYZdxtf/HoRF1KzAAC1HK3xXjd/9AnyhEIhyZyOyDjK8v3NokJEZGL0eoEtp25g5s5YpP55B+YmtRzwr54N0bZeTZnTET07FhUioiqgoEiHZRHxWLj/KnK0JYvDdW7ohv/2bwJXByuZ0xGVX1m+vzlGhYjIRFmplAjvWB/733ser4f6QKmQsOfiLXSfcwj7LnHtFaoeWFSIiExcTTs1Pu3bBL9Pao+GHg64m1uIN1bE4LPtF6At5mBbqtpYVIiIzISfmz02j2uLEW19AQDLIuLx0oIoXE3PkTcYUQViUSEiMiNWKiWm9WmMZcOD4WSjwvmULLw4NwLrjiXzjsxUJbGoEBGZoU4N3fD75OfQtl4N5Bfp8I8NZzBx7SlkFRTJHY3IqFhUiIjMlJuDFX4cGYJ/dPeHUiHhl9Mp6DnnEE4k3ZM7GpHRsKgQEZkxpULCuOfrY/2YUHg5WeP6vXwMWhSN6b9dRF5hsdzxiJ4ZiwoRURXQorYTfpvUHn2CPKHTCyw+eA2dvz6AnedvcuwKmTUWFSKiKsLBSoW5Q5pj2fBgeDlZIyWzAG//eBwjVx5D8t08ueMRlQuLChFRFdOpoRt2v9MB4zvWh0op4Y9Laeg86wDm/XGF666Q2WFRISKqgqwtlZjazR87JpXMDNIW6/G/XZfRY84hRMbdljse0VNjUSEiqsLqu9ph1agQzHmlGWraqXEtPRfDlh7BxDUnkZZdIHc8oidiUSEiquIkSULfZrXwx9QOGNHWFwoJ2HY6BV1mHcR6LhRHJo5FhYiomnCwUmFan8bYNr4dmtRyQGZ+Ed7bcAavf3+Ug23JZLGoEBFVM01qabBlXBje7xEAtYUCh67cRrfZB7EiMh46Pc+ukGlhUSEiqoYslAqM6VAPOya1R+s6zsgr1GHaLxcweHE04tKy5Y5HZMCiQkRUjdV1scPat9rg835NYKe2wPHEe+g5JwLz/riCIp1e7nhELCpERNWdQiHh1TY+2PXOc3je3wWFupKpzL2/jcBJ3jeIZMaiQkREAABPR2ssH9EKs19uBicbFS7dzEb/BVEY+9NxxKXlyB2PqilJmPG8tKysLGg0GmRmZsLBwUHuOEREVcbtHC1m7LiEjSeuQwhAIQGDg70xqbMfPDTWcscjM1eW728WFSIieqTYm9mYuTMWey7eAgCoLRQY0dYXY5+vB0cbS5nTkbliUSEiIqM6nngXX+6IxdGEuwAAeysLjOlQD2+E+cLG0kLmdGRuWFSIiMjohBDYH5uOL3+/hEs3S6Ywu9irMaVLA7wc7A2FQpI5IZmLsnx/yzqYduHChQgMDISDgwMcHBwQGhqKHTt2yBmJiIgeQZIkdAxwxW8T2+Obl4Pg5WSN9GwtPth0Fv0XRuHcjUy5I1IVJOsZlV9++QVKpRJ+fn4QQmDlypWYOXMmTp48icaNGz/x53lGhYhIPoXFevx4OBHf7L6MHG0xFBIwvK0vpnRpAHsrldzxyISZ9aUfZ2dnzJw5EyNHjnziviwqRETyu5VVgM+2X8D2M6kAADcHNf7zYiP0auoBSeLlIHqQ2Vz6+SudToe1a9ciNzcXoaGhD91Hq9UiKyur1IOIiOTl5mCFeUNb4Ic3W8O3hg1uZWkxfvVJDF8eg8Q7uXLHIzMne1E5e/Ys7OzsoFarMWbMGGzevBmNGjV66L7Tp0+HRqMxPLy9vSs5LRERPcpzDVzw++TnMKmTHyyVChy8nI4u3xzEnD1XoC3WyR2PzJTsl34KCwuRlJSEzMxMbNiwAUuXLsWBAwceWla0Wi20Wq3heVZWFry9vXnph4jIxFxLz8FHW88jIu42AKBuTVt83q8J2tavKXMyMgVmPUalc+fOqFevHhYvXvzEfTlGhYjIdAkh8MuZVHy2/QLSs0v+kdm/eS38q2dDuNirZU5HcjLLMSr36fX6UmdNiIjIPEmShD5Bntj7bgcMD/WBJAGbT95Ap6/3Y9WRROj1JvXvZDJRshaVDz74AAcPHkRCQgLOnj2LDz74APv378ewYcPkjEVEREbkYKXCJ32bYMu4MDT2dEBWQTE+3HwOAxZF4UIKJ0XQ48laVNLS0vD666/D398fnTp1QkxMDHbu3IkuXbrIGYuIiCpAkLcjtoaH4ePejWCntsDJpAz0nheBL369gFxtsdzxyESZ3BiVsuAYFSIi83QzswCfbj+P387eBAB4aqwwrU9jdGnkxrVXqgGzHkxbFiwqRETmbd+lNPxn6zlcv5cPAGjp44SJnfzwnF9NFpYqjEWFiIjMRn6hDt/+cQVLI+JRWKwHAAR5aTCxkx9eCHBlYamCWFSIiMjspGUVYMnBa/jpSCIKikoKS2NPB0x4oT66NnLn3ZmrEBYVIiIyW7dztPju0DX8GJ2IvMKSFW393ewx/oX66NnUA0oWFrPHokJERGbvbm4hvo+Ix8qoBGT/OSuonostJnbyw4uBniwsZoxFhYiIqozMvCIsj4rH9xHxyCooKSx1XWwxiYXFbLGoEBFRlZNdUISVUQn47lA8MvOLAPAMi7liUSEioiqLhcX8sagQEVGVx8JivlhUiIio2nhYYantbIPXQ30wqKU3NDYqmRPS37GoEBFRtZNVUISVkQlYGvH/hcVapUS/5rUwvK0PAtz5PWEqWFSIiKjayissxtZTKVgZlYBLN7MN20PqOGN4W190beQGC6Ws9+St9lhUiIio2hNC4Gj8XayMTsDO87eg05d83XlorDAspDZeaV0bNe3UMqesnlhUiIiI/iI1Mx+rDidhzdEk3MktBABYqRQYFuKDtzvUhau9lcwJqxcWFSIioofQFuvw29lULI9MwJnrmQAAtUVJYRnToS5cHVhYKgOLChER0WMIIXDwym3M3nMZJ5MyAJQUlqEhtTG2Qz0WlgrGokJERPQUhBA49GdhOcHCUmlYVIiIiMpACIGIuNuYvecKjifeAwBYWigwtHVtjOlQD+4aFhZjYlEhIiIqByEEIuPuYPaeyzj2l8IypJU3xj5fn4XFSFhUiIiInoEQAlFXSwpLTMKfhUWpwMutvDH2+XrwdLSWOaF5Y1EhIiIyAiEEoq/ewey9V3A0/i6AksIyuJUXxj1fn4WlnFhUiIiIjCz6zzMsR/4sLCqlhMHB3hjXsT5qsbCUCYsKERFRBTl87Q7m7LmC6Gt3AAAWCgk9mnrg9VAfBPs4QZJ41+YnYVEhIiKqYEfj72LO3suIjLtj2NbQwwGvh/qgbzNP2FhayJjOtLGoEBERVZJzNzLxY3Qitp6+gYIiPQDA3soCg4O98WobH9SpaStzQtPDokJERFTJMvIKsf7Ydfx4OBFJd/MM259r4ILX2/jgeX8X3rX5TywqREREMtHrBQ5cTscP0QnYfzkd979la9qp8WKgB3oHeaJFbcdqPZaFRYWIiMgEJN7JxaojSVh3LBkZeUWG7V5O1ugd5Ik+QZ4IcLevdqWFRYWIiMiEFBbrERGXjm2nUrDrwi3kFeoMr/m52qFPkCf6NPOET43qMZ6FRYWIiMhE5RfqsPfSLWw7lYL9seko1OkNr7WrXxP/6O6PQC9H+QJWAhYVIiIiM5CZX4Sd52/il9MpiIy7Df2f38gvBnpgald/+FbRGUMsKkRERGYm+W4evtl9GZtP3YAQJQvJDWldGxM61YerfdW6GSKLChERkZm6mJqFr36/hH2x6QAAa5USb7Wvg7eeqwt7K5XM6YyDRYWIiMjMRV+9gxm/X8Lp5AwAgLOtJcZ3rI9hbWpDbaGUN9wzYlEhIiKqAoQQ2Hn+Jr76PRbXbucCAFzt1RjY0guDgr3NdtVbFhUiIqIqpFinx/rj1zF7z2XcytIatrf2dcagYC/0CvQwq3sLsagQERFVQYXFeuy9eAvrjiXjwOV0wywhW0slegd5YlCwt1msesuiQkREVMXdzCzAxhPXsf5YMhLu/P+9heq52GJwsDf6t6hlsrOFWFSIiIiqCSEEjsbfxfrj1/HrmVTkF5WseqtUSHghwBUvB3ub3A0RWVSIiIiqoRxtMbafTsHPx5JxMinDsN3VXo0BLb0w2EQG4LKoEBERVXNXbmVj3bFkbDpxA3dyCw3bW/s6Y3Arb/Rs6i7bAFwWFSIiIgJQMgD3j0u38HNM6QG49moLvNSiFl5t4wM/N/tKzcSiQkRERA9IzczHxuPXse7YdSTd/f8BuG3qOuP1UF90aeQGVSWMZWFRISIiokfS6wUir97Gj9GJ2HPxluEsi6u9GkNa18bQkNpwc6i4GUMsKkRERPRUUjLyseZoEtYcTcbtnJLF5JQKCd0au+HVNj4IrVvD6OuysKgQERFRmRQW6/H7+Zv4MToBMQn3DNvb1a+Jn0aFGPV3leX723zW2yUiIqIKY2mhQJ8gT/QJ8sTF1Cz8dDgRm0/eQCtfZ1lz8YwKERERPVRWQRGEADTWKuO+L8+oEBER0bNysDJuQSkP01lPl4iIiOhvWFSIiIjIZLGoEBERkcliUSEiIiKTxaJCREREJotFhYiIiEwWiwoRERGZLBYVIiIiMlksKkRERGSyWFSIiIjIZLGoEBERkcliUSEiIiKTxaJCREREJsus754shABQcrtoIiIiMg/3v7fvf48/jlkXlezsbACAt7e3zEmIiIiorLKzs6HRaB67jySeps6YKL1ej5SUFNjb20OSJKO+d1ZWFry9vZGcnAwHBwejvjc9iMe7cvF4Vy4e78rF4125ynO8hRDIzs6Gp6cnFIrHj0Ix6zMqCoUCXl5eFfo7HBwc+Be9EvF4Vy4e78rF4125eLwrV1mP95POpNzHwbRERERkslhUiIiIyGSxqDyCWq3Gxx9/DLVaLXeUaoHHu3LxeFcuHu/KxeNduSr6eJv1YFoiIiKq2nhGhYiIiEwWiwoRERGZLBYVIiIiMlksKkRERGSyWFQeYv78+fD19YWVlRVCQkJw9OhRuSNVCQcPHkTv3r3h6ekJSZKwZcuWUq8LIfDRRx/Bw8MD1tbW6Ny5M65cuSJP2Cpg+vTpaNWqFezt7eHq6op+/fohNja21D4FBQUIDw9HjRo1YGdnhwEDBuDWrVsyJTZvCxcuRGBgoGHRq9DQUOzYscPwOo91xZoxYwYkScLkyZMN23jMjWfatGmQJKnUIyAgwPB6RR5rFpW/+fnnnzFlyhR8/PHHOHHiBIKCgtCtWzekpaXJHc3s5ebmIigoCPPnz3/o61999RXmzp2LRYsW4ciRI7C1tUW3bt1QUFBQyUmrhgMHDiA8PByHDx/G7t27UVRUhK5duyI3N9ewzzvvvINffvkF69evx4EDB5CSkoKXXnpJxtTmy8vLCzNmzMDx48dx7NgxvPDCC+jbty/Onz8PgMe6IsXExGDx4sUIDAwstZ3H3LgaN26M1NRUwyMiIsLwWoUea0GltG7dWoSHhxue63Q64enpKaZPny5jqqoHgNi8ebPhuV6vF+7u7mLmzJmGbRkZGUKtVos1a9bIkLDqSUtLEwDEgQMHhBAlx1elUon169cb9rl48aIAIKKjo+WKWaU4OTmJpUuX8lhXoOzsbOHn5yd2794tOnToICZNmiSE4N9vY/v4449FUFDQQ1+r6GPNMyp/UVhYiOPHj6Nz586GbQqFAp07d0Z0dLSMyaq++Ph43Lx5s9Sx12g0CAkJ4bE3kszMTACAs7MzAOD48eMoKioqdcwDAgJQu3ZtHvNnpNPpsHbtWuTm5iI0NJTHugKFh4ejV69epY4twL/fFeHKlSvw9PRE3bp1MWzYMCQlJQGo+GNt1jclNLbbt29Dp9PBzc2t1HY3NzdcunRJplTVw82bNwHgocf+/mtUfnq9HpMnT0ZYWBiaNGkCoOSYW1pawtHRsdS+PObld/bsWYSGhqKgoAB2dnbYvHkzGjVqhFOnTvFYV4C1a9fixIkTiImJeeA1/v02rpCQEKxYsQL+/v5ITU3FJ598gvbt2+PcuXMVfqxZVIiqgfDwcJw7d67UNWUyPn9/f5w6dQqZmZnYsGEDhg8fjgMHDsgdq0pKTk7GpEmTsHv3blhZWckdp8rr0aOH4c+BgYEICQmBj48P1q1bB2tr6wr93bz08xc1a9aEUql8YKTyrVu34O7uLlOq6uH+8eWxN77x48dj+/bt2LdvH7y8vAzb3d3dUVhYiIyMjFL785iXn6WlJerXr4+WLVti+vTpCAoKwpw5c3isK8Dx48eRlpaGFi1awMLCAhYWFjhw4ADmzp0LCwsLuLm58ZhXIEdHRzRo0ABxcXEV/vebReUvLC0t0bJlS+zdu9ewTa/XY+/evQgNDZUxWdVXp04duLu7lzr2WVlZOHLkCI99OQkhMH78eGzevBl//PEH6tSpU+r1li1bQqVSlTrmsbGxSEpK4jE3Er1eD61Wy2NdATp16oSzZ8/i1KlThkdwcDCGDRtm+DOPecXJycnB1atX4eHhUfF/v595OG4Vs3btWqFWq8WKFSvEhQsXxOjRo4Wjo6O4efOm3NHMXnZ2tjh58qQ4efKkACBmzZolTp48KRITE4UQQsyYMUM4OjqKrVu3ijNnzoi+ffuKOnXqiPz8fJmTm6exY8cKjUYj9u/fL1JTUw2PvLw8wz5jxowRtWvXFn/88Yc4duyYCA0NFaGhoTKmNl/vv/++OHDggIiPjxdnzpwR77//vpAkSezatUsIwWNdGf4660cIHnNjevfdd8X+/ftFfHy8iIyMFJ07dxY1a9YUaWlpQoiKPdYsKg/x7bffitq1awtLS0vRunVrcfjwYbkjVQn79u0TAB54DB8+XAhRMkX5P//5j3BzcxNqtVp06tRJxMbGyhvajD3sWAMQy5cvN+yTn58vxo0bJ5ycnISNjY3o37+/SE1NlS+0GXvzzTeFj4+PsLS0FC4uLqJTp06GkiIEj3Vl+HtR4TE3npdffll4eHgIS0tLUatWLfHyyy+LuLg4w+sVeawlIYR49vMyRERERMbHMSpERERkslhUiIiIyGSxqBAREZHJYlEhIiIik8WiQkRERCaLRYWIiIhMFosKERERmSwWFSKqUiRJwpYtW+SOQURGwqJCREYzYsQISJL0wKN79+5yRyMiM2UhdwAiqlq6d++O5cuXl9qmVqtlSkNE5o5nVIjIqNRqNdzd3Us9nJycAJRcllm4cCF69OgBa2tr1K1bFxs2bCj182fPnsULL7wAa2tr1KhRA6NHj0ZOTk6pfb7//ns0btwYarUaHh4eGD9+fKnXb9++jf79+8PGxgZ+fn7Ytm1bxX5oIqowLCpEVKn+85//YMCAATh9+jSGDRuGV155BRcvXgQA5Obmolu3bnByckJMTAzWr1+PPXv2lCoiCxcuRHh4OEaPHo2zZ89i27ZtqF+/fqnf8cknn2Dw4ME4c+YMevbsiWHDhuHu3buV+jmJyEiMcmtDIiIhxPDhw4VSqRS2tralHl988YUQouSOzmPGjCn1MyEhIWLs2LFCCCGWLFkinJycRE5OjuH1X3/9VSgUCnHz5k0hhBCenp7iww8/fGQGAOLf//634XlOTo4AIHbs2GG0z0lElYdjVIjIqDp27IiFCxeW2ubs7Gz4c2hoaKnXQkNDcerUKQDAxYsXERQUBFtbW8PrYWFh0Ov1iI2NhSRJSElJQadOnR6bITAw0PBnW1tbODg4IC0trbwfiYhkxKJCREZla2v7wKUYY7G2tn6q/VQqVannkiRBr9dXRCQiqmAco0JElerw4cMPPG/YsCEAoGHDhjh9+jRyc3MNr0dGRkKhUMDf3x/29vbw9fXF3r17KzUzEcmHZ1SIyKi0Wi1u3rxZapuFhQVq1qwJAFi/fj2Cg4PRrl07rFq1CkePHsWyZcsAAMOGDcPHH3+M4cOHY9q0aUhPT8eECRPw2muvwc3NDQAwbdo0jBkzBq6urujRoweys7MRGRmJCRMmVO4HJaJKwaJCREb1+++/w8PDo9Q2f39/XLp0CUDJjJy1a9di3Lhx8PDwwJo1a9CoUSMAgI2NDXbu3IlJkyahVatWsLGxwYABAzBr1izDew0fPhwFBQX45ptvMHXqVNSsWRMDBw6svA9IRJVKEkIIuUMQUfUgSRI2b96Mfv36yR2FiMwEx6gQERGRyWJRISIiIpPFMSpEVGl4pZmIyopnVIiIiMhksagQERGRyWJRISIiIpPFokJEREQmi0WFiIiITBaLChEREZksFhUiIiIyWSwqREREZLJYVIiIiMhk/R+L/BGrodK5oQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXI0lEQVR4nO3dd3hTZcMG8DvpSPfepXRAKbtAFwURkSJLBGSDtpSlsq36Cg6G+llwIoIgslSmIOAExIIgChRaNhQoqwU6KW26kybP9wcvea1ltaQ9aXr/rutckpNzkjvH0tyc9ciEEAJERERERkIudQAiIiIifWK5ISIiIqPCckNERERGheWGiIiIjArLDRERERkVlhsiIiIyKiw3REREZFRYboiIiMiosNwQERGRUWG5ISK9kclkmDNnTrXXu3LlCmQyGVavXq33TETU8LDcEBmZ1atXQyaTQSaTYf/+/VWeF0LAx8cHMpkMTz/9tAQJ9ePXX3+FTCaDl5cXtFqt1HGIyICw3BAZKQsLC6xbt67K/L179+LatWtQKBQSpNKftWvXws/PDxkZGdi9e7fUcYjIgLDcEBmpPn36YNOmTaioqKg0f926dQgJCYGHh4dEyR5dcXExfvjhB8TFxaF9+/ZYu3at1JHuqbi4WOoIRA0Oyw2RkRoxYgRu3ryJXbt26eapVCps3rwZI0eOvOs6xcXFeOWVV+Dj4wOFQoGgoCB89NFHEEJUWq68vBwvv/wyXF1dYWtri2eeeQbXrl2762tev34dY8aMgbu7OxQKBVq1aoWVK1c+0mfbunUrSktLMWTIEAwfPhxbtmxBWVlZleXKysowZ84cNGvWDBYWFvD09MSzzz6Lixcv6pbRarX47LPP0KZNG1hYWMDV1RW9evXCkSNHANz/fKB/n2M0Z84cyGQynDlzBiNHjoSjoyMee+wxAMCJEycwevRoBAQEwMLCAh4eHhgzZgxu3rx51202duxYeHl5QaFQwN/fHy+99BJUKhUuXboEmUyGTz/9tMp6f//9N2QyGdavX1/dTUpkVEylDkBEtcPPzw+RkZFYv349evfuDQDYvn07CgoKMHz4cCxcuLDS8kIIPPPMM9izZw/Gjh2Ldu3aYefOnXjttddw/fr1Sl+m48aNw5o1azBy5Eh06tQJu3fvRt++fatkyMrKQseOHSGTyTB58mS4urpi+/btGDt2LJRKJaZPn16jz7Z27Vp069YNHh4eGD58OGbMmIGffvoJQ4YM0S2j0Wjw9NNPIyEhAcOHD8e0adNQWFiIXbt24dSpU2jSpAkAYOzYsVi9ejV69+6NcePGoaKiAn/++ScOHjyI0NDQGuUbMmQIAgMD8f777+uK4a5du3Dp0iXExsbCw8MDp0+fxrJly3D69GkcPHgQMpkMAHDjxg2Eh4cjPz8fEyZMQPPmzXH9+nVs3rwZJSUlCAgIQOfOnbF27Vq8/PLLVbaLra0t+vfvX6PcREZDEJFRWbVqlQAgDh8+LBYtWiRsbW1FSUmJEEKIIUOGiG7dugkhhPD19RV9+/bVrbdt2zYBQLz33nuVXm/w4MFCJpOJ1NRUIYQQx44dEwDExIkTKy03cuRIAUDMnj1bN2/s2LHC09NT5ObmVlp2+PDhwt7eXpfr8uXLAoBYtWrVAz9fVlaWMDU1FV999ZVuXqdOnUT//v0rLbdy5UoBQHzyySdVXkOr1QohhNi9e7cAIKZOnXrPZe6X7d+fd/bs2QKAGDFiRJVl73zWf1q/fr0AIPbt26ebFx0dLeRyuTh8+PA9M3355ZcCgDh79qzuOZVKJVxcXERMTEyV9YgaGh6WIjJiQ4cORWlpKX7++WcUFhbi559/vuchqV9//RUmJiaYOnVqpfmvvPIKhBDYvn27bjkAVZb7914YIQS+//579OvXD0II5Obm6qaePXuioKAAycnJ1f5MGzZsgFwux6BBg3TzRowYge3bt+PWrVu6ed9//z1cXFwwZcqUKq9xZy/J999/D5lMhtmzZ99zmZp48cUXq8yztLTU/bmsrAy5ubno2LEjAOi2g1arxbZt29CvX7+77jW6k2no0KGwsLCodK7Rzp07kZubi+eee67GuYmMBcsNkRFzdXVFVFQU1q1bhy1btkCj0WDw4MF3Xfbq1avw8vKCra1tpfktWrTQPX/nv3K5XHdY546goKBKj3NycpCfn49ly5bB1dW10hQbGwsAyM7OrvZnWrNmDcLDw3Hz5k2kpqYiNTUV7du3h0qlwqZNm3TLXbx4EUFBQTA1vffR94sXL8LLywtOTk7VznE//v7+Vebl5eVh2rRpcHd3h6WlJVxdXXXLFRQUALi9zZRKJVq3bn3f13dwcEC/fv0qXQ23du1aeHt748knn9TjJyGqn3jODZGRGzlyJMaPH4/MzEz07t0bDg4OdfK+d+4989xzzyEmJuauy7Rt27Zar3nhwgUcPnwYABAYGFjl+bVr12LChAnVTHp/99qDo9Fo7rnOP/fS3DF06FD8/fffeO2119CuXTvY2NhAq9WiV69eNbpPT3R0NDZt2oS///4bbdq0wY8//oiJEydCLue/WYlYboiM3MCBA/HCCy/g4MGD2Lhx4z2X8/X1xe+//47CwsJKe29SUlJ0z9/5r1ar1e0ZuePcuXOVXu/OlVQajQZRUVF6+Sxr166FmZkZvv32W5iYmFR6bv/+/Vi4cCHS0tLQuHFjNGnSBIcOHYJarYaZmdldX69JkybYuXMn8vLy7rn3xtHREQCQn59faf6dPVkP49atW0hISMDcuXMxa9Ys3fwLFy5UWs7V1RV2dnY4derUA1+zV69ecHV1xdq1axEREYGSkhI8//zzD52JyJix4hMZORsbGyxZsgRz5sxBv3797rlcnz59oNFosGjRokrzP/30U8hkMt0VV3f++++rrRYsWFDpsYmJCQYNGoTvv//+rl/WOTk51f4sa9euRZcuXTBs2DAMHjy40vTaa68BgO4y6EGDBiE3N7fK5wGgu4Jp0KBBEEJg7ty591zGzs4OLi4u2LdvX6Xnv/jii4fOfaeIiX9dUv/vbSaXyzFgwAD89NNPukvR75YJAExNTTFixAh89913WL16Ndq0aVPtPWFExop7bogagHsdFvqnfv36oVu3bnjzzTdx5coVBAcH47fffsMPP/yA6dOn686xadeuHUaMGIEvvvgCBQUF6NSpExISEpCamlrlNefNm4c9e/YgIiIC48ePR8uWLZGXl4fk5GT8/vvvyMvLe+jPcOjQIaSmpmLy5Ml3fd7b2xsdOnTA2rVr8frrryM6OhrffPMN4uLikJiYiC5duqC4uBi///47Jk6ciP79+6Nbt254/vnnsXDhQly4cEF3iOjPP/9Et27ddO81btw4zJs3D+PGjUNoaCj27duH8+fPP3R2Ozs7PP744/jggw+gVqvh7e2N3377DZcvX66y7Pvvv4/ffvsNXbt2xYQJE9CiRQtkZGRg06ZN2L9/f6XDitHR0Vi4cCH27NmD+fPnP3QeIqMn3YVaRFQb/nkp+P38+1JwIYQoLCwUL7/8svDy8hJmZmYiMDBQfPjhh7pLkO8oLS0VU6dOFc7OzsLa2lr069dPpKenV7k0Wojbl25PmjRJ+Pj4CDMzM+Hh4SG6d+8uli1bplvmYS4FnzJligAgLl68eM9l5syZIwCI48ePCyFuX3795ptvCn9/f917Dx48uNJrVFRUiA8//FA0b95cmJubC1dXV9G7d2+RlJSkW6akpESMHTtW2NvbC1tbWzF06FCRnZ19z0vBc3JyqmS7du2aGDhwoHBwcBD29vZiyJAh4saNG3fdZlevXhXR0dHC1dVVKBQKERAQICZNmiTKy8urvG6rVq2EXC4X165du+d2IWpoZEL8az8pERHVG+3bt4eTkxMSEhKkjkJkMHjODRFRPXXkyBEcO3YM0dHRUkchMijcc0NEVM+cOnUKSUlJ+Pjjj5Gbm4tLly7BwsJC6lhEBoN7boiI6pnNmzcjNjYWarUa69evZ7Eh+hfuuSEiIiKjwj03REREZFQkLzeLFy+Gn58fLCwsEBERgcTExPsun5+fj0mTJsHT0xMKhQLNmjXTDeRHREREJOlN/DZu3Ii4uDgsXboUERERWLBgAXr27Ilz587Bzc2tyvIqlQo9evSAm5sbNm/eDG9vb1y9erVaY+VotVrcuHEDtra2jzTqLxEREdUdIQQKCwvh5eX14DHUJLzHjggPDxeTJk3SPdZoNMLLy0vEx8ffdfklS5aIgIAAoVKpavyed240xokTJ06cOHGqf1N6evoDv+slO6FYpVLBysoKmzdvxoABA3TzY2JikJ+fjx9++KHKOn369IGTkxOsrKzwww8/wNXVFSNHjsTrr79eZRC9O8rLy1FeXq57XFBQgMaNGyM9PR12dnZ6/1xERESkf0qlEj4+PsjPz4e9vf19l5XssFRubi40Gg3c3d0rzXd3d9eNQvxvly5dwu7duzFq1Cj8+uuvSE1NxcSJE6FWqzF79uy7rhMfH3/XQfHs7OxYboiIiOqZhzmlRPITiqtDq9XCzc0Ny5YtQ0hICIYNG4Y333wTS5cuvec6M2fOREFBgW5KT0+vw8RERERU1yTbc+Pi4gITExNkZWVVmp+VlQUPD4+7ruPp6QkzM7NKh6BatGiBzMxMqFQqmJubV1lHoVBAoVDoNzwREREZLMn23JibmyMkJKTSYG9arRYJCQmIjIy86zqdO3dGamoqtFqtbt758+fh6el512JDREREDY+kl4LHxcUhJiYGoaGhCA8Px4IFC1BcXIzY2FgAQHR0NLy9vREfHw8AeOmll7Bo0SJMmzYNU6ZMwYULF/D+++9j6tSpes+m0WigVqv1/roNxb/3sBEREdUVScvNsGHDkJOTg1mzZiEzMxPt2rXDjh07dCcZp6WlVbqW3cfHBzt37sTLL7+Mtm3bwtvbG9OmTcPrr7+ut0xCCGRmZiI/P19vr9lQOTg4wMPDg/cTIiKiOtXgxpZSKpWwt7dHQUHBXa+WysjIQH5+Ptzc3GBlZcUv5hoQQqCkpATZ2dlwcHCAp6en1JGIiKiee9D39z9JuufG0Gg0Gl2xcXZ2ljpOvWZpaQkAyM7OhpubGw9RERFRnalXl4LXtjvn2FhZWUmcxDjc2Y48d4mIiOoSy81d8FCUfnA7EhGRFFhuiIiIyKiw3NA9+fn5YcGCBVLHICIiqhaWGyMgk8nuO82ZM6dGr3v48GFMmDBBv2GJiIhqGa+WMgIZGRm6P2/cuBGzZs3CuXPndPNsbGx0fxZCQKPRwNT0wf/rXV1d9RuUiIiM3qFLN9Hcww72VmaSZeCeGyPg4eGhm+zt7SGTyXSPU1JSYGtri+3btyMkJAQKhQL79+/HxYsX0b9/f7i7u8PGxgZhYWH4/fffK73uvw9LyWQyLF++HAMHDoSVlRUCAwPx448/1vGnJSIiQ/XtwasYufwQJq9PRoVG++AVagnLzQMIIVCiqpBk0uf9FWfMmIF58+bh7NmzaNu2LYqKitCnTx8kJCTg6NGj6NWrF/r164e0tLT7vs7cuXMxdOhQnDhxAn369MGoUaOQl5ent5xERFT/qDVavL3tFN7edgoarYCLjQIaCe8RzMNSD1Cq1qDlrJ2SvPeZd3rCylw//4veeecd9OjRQ/fYyckJwcHBusfvvvsutm7dih9//BGTJ0++5+uMHj0aI0aMAAC8//77WLhwIRITE9GrVy+95CQiovolv0SFiWuT8ffFm5DJgP/0bI4XuwZIejsQlpsGIjQ0tNLjoqIizJkzB7/88gsyMjJQUVGB0tLSB+65adu2re7P1tbWsLOzQ3Z2dq1kJiIiw5aaXYixXx/B1ZslsDY3wYLh7dGjpbvUsVhuHsTSzARn3ukp2Xvri7W1daXHr776Knbt2oWPPvoITZs2haWlJQYPHgyVSnXf1zEzq3yCmEwmg1Yr3XFVIiKSxp5z2Zi67igKyyvQyNESy2NC0dzj/mM+1RWWmweQyWR6OzRkSP766y+MHj0aAwcOBHB7T86VK1ekDUVERAZPCIEV+y/j/V/PQiuAcD8nLHmuA5xtFFJH0zG+b216KIGBgdiyZQv69esHmUyGt99+m3tgiIjovsorNHh72yl8d+QaAGBoaCO8N6ANzE0N6/oklpsG6pNPPsGYMWPQqVMnuLi44PXXX4dSqZQ6FhERGaj0vBLEfXcMh6/cglwGvNm3JcZ09jPIcQRlQp/XG9cDSqUS9vb2KCgogJ1d5WODZWVluHz5Mvz9/WFhYSFRQuPB7UlEVP+l3SzB4j2p+D75Giq0ArYKU3w+sj2eCHKr0xz3+/7+N+65ISIioiqu3izGot2p2HL0OjTa2/tBugS6YHa/VmjqZvOAtaXFckNEREQ6V3KLsWhPKrb+o9Q83swV07oHIsTXUeJ0D4flhoiIiHA59/aemm3H/ldqujZzxbSoQHRoXD9KzR0sN0RERA1YcXkFPtiRgm8PXsV/Ow26BbliavdAtK9npeYOlpu7aGDnWNcabkciIsN24OJN/Of740jPKwUAPNncDVO7B6Kdj4O0wR4Ry80/3Ln7bklJCSwtLSVOU/+VlJQAqHpXYyIiklZxeQXm70jBNweuAgC8HSwxf1BbPBboInEy/WC5+QcTExM4ODjoxkqysrIyyOv3DZ0QAiUlJcjOzoaDgwNMTPQ3jAQRET2af++tGRnRGG/0aQEbhfFUAuP5JHri4eEBABwMUg8cHBx025OIiKR159yar410b80/sdz8i0wmg6enJ9zc3KBWq6WOU2+ZmZlxjw0RkYH4996aEeGN8Uaf5rC1MM7TBlhu7sHExIRfzkREVO99tPMcFu1JBQB42Vtg/uC26BLoKnGq2sVyQ0REZKS2JF/TFZsR4T54o08Lo91b808sN0REREboQlYh3tx6CgAwtXsg4no0kzhR3TGsMcqJiIjokZWoKjBxbTJK1Rp0buqMad0DpY5Up1huiIiIjIgQAm9tPYUL2UVws1VgwbD2MJE3rNuasNwQEREZke+OpGPL0euQy4DPR7SHq61C6kh1juWGiIjISJzNUGLWD6cBAK88FYSIAGeJE0mD5YaIiMgIFJapMXFtMsortHgiyBUvdW0idSTJsNwQERHVc0IIzNxyEpdzi+Flb4FPh7aDvIGdZ/NPLDdERET13JqDV/HziQyYymX4fGQHOFqbSx1JUiw3RERE9djJawV49+ezAIAZvZsjxNdR4kTSY7khIiKqpwpK1Zi4LgkqjRY9Wrpj7GP+UkcyCCw3RERE9dCV3GJMXX8U6XmlaORoiY8GB0Mma7jn2fwTh18gIiKqJ8rUGuw4lYkNh9Nw8FIeAMDcRI4vRnWAvZXxjxn1sFhuiIiIDNyZG0psPJyGrUevQ1lWAQCQyYCuzVzxYtcmaNvIQdqABoblhoiIyAAVlqnx4/Eb2Hg4HSeuFejmeztYYmioDwaHNoK3g6WECQ0Xyw0REZGBOXDxJiZ8cwSF5bf30piZyPBUSw8MC/NB56YuDW6sqOpiuSEiIjIgx9PzMe7rwyhWaRDgao2R4Y0xsL03nG0a3hhRNcVyQ0REZCDOZxUiZlUiilUadGrijJWjw2BhZiJ1rHqHl4ITEREZgLSbJXhu+SHkl6jRzscBy6JDWWxqiOWGiIhIYlnKMoxacRDZheUIcrfF6tgw2Ch4cKWmWG6IiIgkdKtYheeWH0J6Xil8na3w7dhwOFg17LGhHhXLDRERkUQKy9SIWZWIC9lF8LCzwJqxEXCzs5A6Vr3HckNERCSBMrUG474+ghPXCuBoZYY148Lh42QldSyjwHJDRERUx9QaLSatTcahy3mwUZjimzERaOpmK3Uso2EQ5Wbx4sXw8/ODhYUFIiIikJiYeM9lV69eDZlMVmmysOAuPCIiqh80WoFXvjuOhJRsKEzlWBETijaN7KWOZVQkLzcbN25EXFwcZs+ejeTkZAQHB6Nnz57Izs6+5zp2dnbIyMjQTVevXq3DxERERDWTV6zChG+O4MfjN2Aql2HpcyGICHCWOpbRkbzcfPLJJxg/fjxiY2PRsmVLLF26FFZWVli5cuU915HJZPDw8NBN7u7udZiYiIio+g5euonen+1DQko2zE3l+Gx4e3Rr7iZ1LKMkablRqVRISkpCVFSUbp5cLkdUVBQOHDhwz/WKiorg6+sLHx8f9O/fH6dPn77nsuXl5VAqlZUmIiKiuqLRCny66zxGfnUQWcpyBLhaY9vEzujb1lPqaEZL0nKTm5sLjUZTZc+Lu7s7MjMz77pOUFAQVq5ciR9++AFr1qyBVqtFp06dcO3atbsuHx8fD3t7e93k4+Oj989BRER0NxkFpRjx1UF8lnABWgEMDmmEn6c8hpZedlJHM2r17vaHkZGRiIyM1D3u1KkTWrRogS+//BLvvvtuleVnzpyJuLg43WOlUsmCQ0REtS7hbBZe3XQct0rUsDY3wXsDW2Ng+0ZSx2oQJC03Li4uMDExQVZWVqX5WVlZ8PDweKjXMDMzQ/v27ZGamnrX5xUKBRQKjqRKRER1o7xCg/nbz2HlX5cBAK297fD5iA7wd7GWOFnDIelhKXNzc4SEhCAhIUE3T6vVIiEhodLemfvRaDQ4efIkPD157JKIiKSVdrMEg5cc0BWbMZ398f1LnVhs6pjkh6Xi4uIQExOD0NBQhIeHY8GCBSguLkZsbCwAIDo6Gt7e3oiPjwcAvPPOO+jYsSOaNm2K/Px8fPjhh7h69SrGjRsn5ccgIqIGLktZhhFfHcT1/FI4WJnho8HBiGrJq3mlIHm5GTZsGHJycjBr1ixkZmaiXbt22LFjh+4k47S0NMjl/9vBdOvWLYwfPx6ZmZlwdHRESEgI/v77b7Rs2VKqj0BERA1cUXkFYlcdxvX8UgS4WGPt+Ah42ltKHavBkgkhhNQh6pJSqYS9vT0KCgpgZ8ez1YmI6NGoNVqM/foI9p3PgYuNOba81BmNnTlGlL5V5/tb8pv4ERER1VdCCLy19RT2nc+BpZkJVsSEsdgYAJYbIiKiGvp8dyo2HkmHXAZ8PqI9gn0cpI5EYLkhIiKqkc1J1/DJrvMAgLn9W/PkYQPCckNERFRNf17IwYzvTwAAXuzaBM939JU4Ef0Tyw0REVE1nM1Q4qU1yajQCjwT7IX/9AySOhL9C8sNERHRQ8ooKEXsqsMoKq9AhL8TPhzSFnK5TOpY9C8sN0RERA9BWabG6JWHkaksQ6CbDZY9HwqFqYnUseguJL+JHxERkaG7VazCC98m4VxWIVxtFVgVGwZ7KzOpY9E9sNwQERHdx4WsQoz75giu3iyBjcIUq0aHoZEj72VjyFhuiIiI7mF3Shamrj+GovIKNHK0xPKYUDT34N3tDR3LDRER0b8IIfDlvkuYvyMFQgAR/k5Y8lwInKzNpY5GD4HlhoiI6B/K1Bq8seUkthy9DgAYGdEYc/q1grkpr8GpL1huiIiI/itbWYYJ3ybhWHo+TOQyzO7XEs939IVMxsu96xOWGyIiIgAnrxVg/DdHkKksg72lGb4Y1QGdm7pIHYtqgOWGiIgavJ9P3MCrm46jTK1FUzcbLI8OhZ+LtdSxqIZYboiIqEH7at8l/N+vZwEA3YJc8dmI9rCz4D1s6jOWGyIiapCEEJi3PQVf7rsEABjT2R9v9m0BEw6nUO+x3BARUYOj1mgx4/uT+D75GgBgZu/meKFrE4lTkb6w3BARUYNSqtJg0rpk7E7JholchnnPtsGQUB+pY5EesdwQEVGDkV+iwpjVh5Gclg8LMzkWj+yA7i3cpY5FesZyQ0REDUJGQSmiVyTiQnYR7CxMsSo2DCG+TlLHolrAckNEREYvNbsQ0SsScaOgDO52CnwzJgJBHrZSx6JawnJDRERGLTntFsasPoz8EjUCXK3xzZhwjupt5FhuiIjIaP184gZe23QCpWoNgn0csGp0GAe/bABYboiIyOioNVrE/5qClX9dBgA83swVS0Z1gLWCX3sNAf8vExGRUclWlmHSumQcvnILAPBi1yZ49almMDXhqN4NBcsNEREZjUOXbmLSuqPILSqHrcIUHw0NRs9WHlLHojrGckNERPWeEALL/7yMeTtSoNEKBLnbYslzHRDgaiN1NJIAyw0REdVrReUV+M/m4/j1ZCYAoH87L8Q/2wZW5vyKa6j4f56IiOqt1OxCvPBtEi7mFMPMRIa3+rZEdKQvZDIOftmQsdwQEVG99FdqLsZ/cwQlKg087CyweFQHhPg6Sh2LDADLDRER1TtXbxZj4tpklKg0iAxwxucj28PFRiF1LDIQLDdERFSvlKgq8MK3SSgoVaOdjwNWjwmDwtRE6lhkQHjRPxER1RtCCPxn8wmkZBbCxUaBpc+FsNhQFSw3RERUb3z15yX8fCIDpnIZvhjVAR72FlJHIgPEckNERPXC/gu5mLc9BQAwu19LhPs7SZyIDBXLDRERGbz0vBJMXp8MrQCGhDTCcx19pY5EBozlhoiIDFqpSoMXvk1CfokabRvZ490BrXkfG7ovlhsiIjJYQgjM2HICZzKUcLY2x9LnQmBhxhOI6f5YboiIyGCt2H8ZPxy7AVO5DItHdYCXg6XUkageYLkhIiKD9HdqLuL/ewLxW31boGOAs8SJqL5guSEiIoNz7VYJJq8/Co1W4NkO3ojp5Cd1JKpHWG6IiMig3LkDcV6xCq297fD+wDY8gZiqheWGiIgMhhACr206gdM3eAIx1RzLDRERGYzFe1Lxy8kMmJnIsPT5EDRytJI6EtVDLDdERGQQfjudiY9+Ow8AeLd/a4T58Q7EVDMsN0REJLmUTCVe3ngMABAT6Yvh4Y2lDUT1GssNERFJKq9YhfHfHEGxSoNOTZzx1tMtpY5E9RzLDRERSUat0WLi2iSk55WisZMVFo/sADMTfjXRozGIn6DFixfDz88PFhYWiIiIQGJi4kOtt2HDBshkMgwYMKB2AxIRUa1456czOHgpD9bmJlgeEwpHa3OpI5ERkLzcbNy4EXFxcZg9ezaSk5MRHByMnj17Ijs7+77rXblyBa+++iq6dOlSR0mJiEif1hy8im8PXoVMBnw2vD2audtKHYmMhOTl5pNPPsH48eMRGxuLli1bYunSpbCyssLKlSvvuY5Go8GoUaMwd+5cBAQE1GFaIiLSh4OXbmLOj6cBAK8+FYSolu4SJyJjImm5UalUSEpKQlRUlG6eXC5HVFQUDhw4cM/13nnnHbi5uWHs2LEPfI/y8nIolcpKExERSSc9rwQvrUlChVagX7AXJj7RROpIZGQkLTe5ubnQaDRwd6/c2N3d3ZGZmXnXdfbv348VK1bgq6++eqj3iI+Ph729vW7y8fF55NxERFQzp64X4PkVh3CrRI023vb4YFBbDq1Aeif5YanqKCwsxPPPP4+vvvoKLi4uD7XOzJkzUVBQoJvS09NrOSUREf2bViuwdO9FDPziL1y5WQIvewssiw6BpTmHViD9M5XyzV1cXGBiYoKsrKxK87OysuDh4VFl+YsXL+LKlSvo16+fbp5WqwUAmJqa4ty5c2jSpPLuTYVCAYVCUQvpiYjoYWQWlOGVTcfwV+pNAEDPVu6Y92xbXhlFtUbScmNubo6QkBAkJCToLufWarVISEjA5MmTqyzfvHlznDx5stK8t956C4WFhfjss894yImIyMDsOJWJGVtOIL9EDUszE8zu1xLDwnx4KIpqlaTlBgDi4uIQExOD0NBQhIeHY8GCBSguLkZsbCwAIDo6Gt7e3oiPj4eFhQVat25daX0HBwcAqDKfiIikU6KqwLs/n8H6xNunArT2tsNnw9ujiauNxMmoIZC83AwbNgw5OTmYNWsWMjMz0a5dO+zYsUN3knFaWhrk8np1ahARUYN26noBpm44iks5xZDJgAmPB+CVHkEwN+XvcqobMiGEkDpEXVIqlbC3t0dBQQHs7OykjkNEZFSW/3kJ83ekQK0RcLdT4NOh7dCp6cNdAEJ0P9X5/pZ8zw0RERmHzUnX8N4vZwHwpGGSFssNERE9stTsIry97RQAYHK3pnjlqWY8aZgkwwOgRET0SMrUGkxel4xStQadmzrj5R4sNiQtlhsiInok7/x8BimZhXCxMcenw9rBRM5iQ9JiuSEiohr76fgNrDuUBpkMWDCsPdxsLaSORMRyQ0RENXP1ZjFmbrl9Y9VJTzTFY4G8KooMA8sNERFVW3mFBpPXHUVReQXC/BwxPSpQ6khEOiw3RERUbfO2p+Dk9QI4Wplh4Yj2MDXh1wkZDv40EhFRtew8nYlVf10BAHw8NBie9pbSBiL6F5YbIiJ6aNduleC1TccBAOO7+OPJ5u4SJyKqiuWGiIgeilqjxZT1R6Esq0A7Hwe81rO51JGI7orlhoiIHspHv53D0bR82FqY4vMR7TkQJhks/mQSEdED7U7Jwpd7LwEAPhzcFj5OVhInIro3lhsiIrqvtJslmL7hGAAgJtIXvVp7ShuI6AFYboiI6J7K1Bq8uCYJyrIKtG/sgDf7tpQ6EtEDsdwQEdFdCSHw5tZTOJOhhLO1Ob4Y1YHn2VC9wJ9SIiK6q3WJafg++RrkMuDzEe15PxuqN1huiIioiuPp+Zj74xkAwH96NUenphw3iuoPlhsiIqokr1iFl9YkQaXRomcrd7zweIDUkYiqheWGiIh0NFqBqeuP4kZBGfxdrPHhkGDIZDKpYxFVC8sNERHpfLrrPPan5sLSzARLnwuBnYWZ1JGIqo3lhoiIAAC7zmRh0Z5UAMC8QW0Q5GErcSKimmG5ISIiXMktRtx3xwAAozv5oX87b2kDET0ClhsiogauVHX7Rn2FZRUI8XXEG31aSB2J6JGw3BARNWClKg1eWJOElMxCuNiYY/FI3qiP6j9TqQMQEZE0CsvUGLv6CBKv5MHSzARfjAqBh72F1LGIHlm167mfnx/eeecdpKWl1UYeIiKqA/klKjy3/BASr+TBVmGKb8eGI9zfSepYRHpR7XIzffp0bNmyBQEBAejRowc2bNiA8vLy2shGRES1IKewHMOXHcTxawVwtDLD+gkdEerHYkPGo0bl5tixY0hMTESLFi0wZcoUeHp6YvLkyUhOTq6NjEREpCc38ksx9MsDSMkshJutAhtfiERrb3upYxHplUwIIR7lBdRqNb744gu8/vrrUKvVaNOmDaZOnYrY2FiDvKulUqmEvb09CgoKYGdnJ3UcIqI6cyW3GKOWH8L1/FJ4O1hi7bgI+LlYSx2L6KFU5/u7xicUq9VqbN26FatWrcKuXbvQsWNHjB07FteuXcMbb7yB33//HevWravpyxMRkR5dyCrEqOWHkF1YDn8Xa6wdFwEvB47yTcap2uUmOTkZq1atwvr16yGXyxEdHY1PP/0UzZs31y0zcOBAhIWF6TUoERHVzKnrBYhemYi8YhWC3G3x7bhwuNnyqigyXtUuN2FhYejRoweWLFmCAQMGwMys6rgj/v7+GD58uF4CEhFRzSVdvYXRqxJRWFaBto3s8XVsOBytzaWORVSrql1uLl26BF9f3/suY21tjVWrVtU4FBERPbqUTCVi/1tswvwcsXJ0GGw5ECY1ANW+Wio7OxuHDh2qMv/QoUM4cuSIXkIREdGjuXarBDErE6Esq0CoryO+HhPOYkMNRrXLzaRJk5Cenl5l/vXr1zFp0iS9hCIioprLK1YhemUispTlaOZug+UxobAy5w3pqeGodrk5c+YMOnToUGV++/btcebMGb2EIiKimilRVWDM6sO4lFMML3sLfD0mHA5WPMeGGpZqlxuFQoGsrKwq8zMyMmBqyn8ZEBFJRa3RYuLaZBxLz4eDlRm+GRsOT3te7k0NT7XLzVNPPYWZM2eioKBANy8/Px9vvPEGevTooddwRET0cIQQeP37E/jjXA4szORYEROGpm62UscikkS1d7V89NFHePzxx+Hr64v27dsDAI4dOwZ3d3d8++23eg9IREQPNm9HCrYkX4eJXIYvRnVAiK+j1JGIJFPtcuPt7Y0TJ05g7dq1OH78OCwtLREbG4sRI0bc9Z43RERUu5b/eQlf7r0EAJj3bBs82dxd4kRE0qrRSTLW1taYMGGCvrMQEVE1/XDsOt775SwA4D+9gjAk1EfiRETSq/EZwGfOnEFaWhpUKlWl+c8888wjhyIiogfbdz4Hr246DgCI7eyHl7o2kTgRkWGo0R2KBw4ciJMnT0Imk+HOoOJ3RgDXaDT6TUhERFVcvVmMSWuTodYIPBPshbf7ttT9HiZq6Kp9tdS0adPg7++P7OxsWFlZ4fTp09i3bx9CQ0Pxxx9/1EJEIiL6J1WFFlPWH0Vh+e27D380JBhyOYsN0R3V3nNz4MAB7N69Gy4uLpDL5ZDL5XjssccQHx+PqVOn4ujRo7WRk4iI/mv+jhScuFYAByszLBzRHuam1f53KpFRq/bfCI1GA1vb2/dOcHFxwY0bNwAAvr6+OHfunH7TERFRJb+fycKK/ZcBAB8ODoaXA2/SR/Rv1d5z07p1axw/fhz+/v6IiIjABx98AHNzcyxbtgwBAQG1kZGIiADcyC/Fq5tvn0A8prM/erTkJd9Ed1PtcvPWW2+huLgYAPDOO+/g6aefRpcuXeDs7IyNGzfqPSAREQEVGi2mbTiK/BI12njb4/XeQVJHIjJY1S43PXv21P25adOmSElJQV5eHhwdHXmmPhFRLVnw+wUcvnILNgpTLBrZHgpTE6kjERmsap1zo1arYWpqilOnTlWa7+Tk9EjFZvHixfDz84OFhQUiIiKQmJh4z2W3bNmC0NBQODg4wNraGu3ateOwD0Rk1PZfyMXiP1IBAPHPtoGvs7XEiYgMW7XKjZmZGRo3bqzXe9ls3LgRcXFxmD17NpKTkxEcHIyePXsiOzv7rss7OTnhzTffxIEDB3DixAnExsYiNjYWO3fu1FsmIiJDkVNYjukbj0EIYER4Y/QL9pI6EpHBk4k7d+F7SCtWrMCWLVvw7bffwsnJ6ZEDREREICwsDIsWLQIAaLVa+Pj4YMqUKZgxY8ZDvUaHDh3Qt29fvPvuuw9cVqlUwt7eHgUFBbCzs3uk7EREtUmrFYhZlYg/L+QiyN0WP0zuDAszHo6ihqk639/VPudm0aJFSE1NhZeXF3x9fWFtXXn3aHJy8kO/lkqlQlJSEmbOnKmbJ5fLERUVhQMHDjxwfSEEdu/ejXPnzmH+/Pl3Xaa8vBzl5eW6x0ql8qHzERFJacnei/jzQi4szORYNLI9iw3RQ6p2uRkwYIDe3jw3NxcajQbu7pUvZ3R3d0dKSso91ysoKIC3tzfKy8thYmKCL774Aj169LjrsvHx8Zg7d67eMhMR1YUjV/Lwya7zAIB3+rdGoLutxImI6o9ql5vZs2fXRo5qsbW1xbFjx1BUVISEhATExcUhICAATzzxRJVlZ86cibi4ON1jpVIJHx+OmktEhktZpsbU9Ueh0QoMaOeFISGNpI5EVK/UeFRwfXBxcYGJiQmysrIqzc/KyoKHh8c915PL5WjatCkAoF27djh79izi4+PvWm4UCgUUCoVecxMR1aYPdqTgRkEZ/Jyt8N7ANrzNBlE1VXv4BblcDhMTk3tO1WFubo6QkBAkJCTo5mm1WiQkJCAyMvKhX0er1VY6r4aIqL5KupqHtYfSAADxz7aFjULSf4MS1UvV/luzdevWSo/VajWOHj2Kr7/+ukbntsTFxSEmJgahoaEIDw/HggULUFxcjNjYWABAdHQ0vL29ER8fD+D2OTShoaFo0qQJysvL8euvv+Lbb7/FkiVLqv3eRESGRFWhxcwtJyEEMCSkESKbOEsdiaheqna56d+/f5V5gwcPRqtWrbBx40aMHTu2Wq83bNgw5OTkYNasWcjMzES7du2wY8cO3UnGaWlpkMv/t4OpuLgYEydOxLVr12BpaYnmzZtjzZo1GDZsWHU/ChGRQfnqz0s4n1UEZ2tzvNGnhdRxiOqtat/n5l4uXbqEtm3boqioSB8vV2t4nxsiMkSXc4vRc8E+qCq0WDCsHQa095Y6EpFBqc73d7XPubmb0tJSLFy4EN7e/MtIRFRdQgi8ufUkVBVadAl0Qf92vAsx0aOo9mGpfw+QKYRAYWEhrKyssGbNGr2GIyJqCL5Pvo6/L96EhZkc/zeAV0cRPapql5tPP/200l88uVwOV1dXREREwNHRUa/hiIiM3c2icvzfL2cAANOjmqGxs5XEiYjqv2qXm9GjR9dCDCKihun/fjmLWyVqNPewxdjH/KWOQ2QUqn3OzapVq7Bp06Yq8zdt2oSvv/5aL6GIiBqC/RdyseXodchkwLxBbWFmopfTIIkavGr/TYqPj4eLi0uV+W5ubnj//ff1EoqIyNiVqTV4c9tJAEBMpB/a+ThIG4jIiFS73KSlpcHfv+quU19fX6SlpeklFBGRsVuYcAFXb5bAw84CrzzVTOo4REal2uXGzc0NJ06cqDL/+PHjcHbm3TSJiB4kJVOJZfsuAQDe6d8KthZmEiciMi7VLjcjRozA1KlTsWfPHmg0Gmg0GuzevRvTpk3D8OHDayMjEZHR0GgFZm45iQqtQM9W7niq1b0HCSaimqn21VLvvvsurly5gu7du8PU9PbqWq0W0dHRPOeGiOg+CkrVeOW74zialg8bhSnmPtNa6khERqnGwy9cuHABx44dg6WlJdq0aQNfX199Z6sVHH6BiKRw+kYBXlqTjLS8EpibyrFgWDv0aeMpdSyieqM639/V3nNzR2BgIAIDA2u6OhFRg7HpSDre2nYK5RVaNHK0xNLnQtDa217qWERGq9rn3AwaNAjz58+vMv+DDz7AkCFD9BKKiMgYlKk1mLnlBF7bfALlFVo82dwNP095jMWGqJZVu9zs27cPffr0qTK/d+/e2Ldvn15CERHVd+l5JRi89G+sT0yHTAa8+lQzLI8OhYOVudTRiIxetQ9LFRUVwdy86l9OMzMzKJVKvYQiIqrPdqdkYfqGY1CWVcDRygwLR7RHl0BXqWMRNRjV3nPTpk0bbNy4scr8DRs2oGXLlnoJRURUH2m0Ah//dg5jVh+BsqwCwT4O+HlqFxYbojpW7T03b7/9Np599llcvHgRTz75JAAgISEB69atw+bNm/UekIiovpi/I0V3c77oSF+82bcFFKYmEqcianiqXW769euHbdu24f3338fmzZthaWmJ4OBg7N69G05OTrWRkYjI4CWn3cJXf94uNh8MaouhYT4SJyJquGp8n5s7lEol1q9fjxUrViApKQkajUZf2WoF73NDRPpWXqFB34X7kZpdhGfbe+OTYe2kjkRkdKrz/V3tc27u2LdvH2JiYuDl5YWPP/4YTz75JA4ePFjTlyMiqrcW7U5FanYRXGzM8fbTPPeQSGrVOiyVmZmJ1atXY8WKFVAqlRg6dCjKy8uxbds2nkxMRA3S6RsF+OKPiwCAd/q3hqM1L/UmktpD77np168fgoKCcOLECSxYsAA3btzA559/XpvZiIgMmlqjxX82n4BGK9C7tQeHUyAyEA+952b79u2YOnUqXnrpJQ67QEQEYNm+Szh9Qwl7SzPM7d9K6jhE9F8Pvedm//79KCwsREhICCIiIrBo0SLk5ubWZjYiIoOVml2IzxIuAABmPd0SbrYWEiciojseutx07NgRX331FTIyMvDCCy9gw4YN8PLyglarxa5du1BYWFibOYmIDIZGK/CfzSegqtDiiSBXPNvBW+pIRPQP1b5aytraGmPGjMH+/ftx8uRJvPLKK5g3bx7c3NzwzDPP1EZGIiKD8vXfV5Cclg8bhSneH9gGMplM6khE9A81vhQcAIKCgvDBBx/g2rVrWL9+vb4yEREZrLSbJfhw5zkAwIzezeHlYClxIiL6t0cqN3eYmJhgwIAB+PHHH/XxckREBkkIgRlbTqBUrUHHACeMDG8sdSQiugu9lBsiooZgw+F0/H3xJizM5Jg/qC3kch6OIjJELDdERA8ho6AU7/9yFgDw6lNB8HW2ljgREd0Lyw0R0QOUV2gQt/E4Cssr0M7HAbGd/aWORET3wXJDRHQfWq3AK98dx4FLN2FtboIPB7eFCQ9HERk0lhsionsQQuDdX87g5xMZMDORYenzIQh0t5U6FhE9AMsNEdE9LN17Cav+ugIA+GhIMLoEukobiIgeCssNEdFdbE66hvk7UgAAb/Vtgf7teBdiovqC5YaI6F/2nMvG69+fAAC88HgAxnUJkDgREVUHyw0R0T8cTbuFiWuSodEKDGzvjdd7NZc6EhFVE8sNEdF/XcwpwpjVh1Gq1uDxZq74YDBv1EdUH7HcEBEByFKWIXpFIm6VqBHcyB5LRnWAmQl/RRLVR/ybS0QNnrJMjZiVibieXwo/ZyusHB0Ga4Wp1LGIqIZYboioQStTazD+6yNIySyEi40C34yJgLONQupYRPQIWG6IqMFSa7SYuDYZhy7nwUZhitWxYWjsbCV1LCJ6RCw3RNQgabQCcd8dx+6UbChM5VgRE4rW3vZSxyIiPWC5IaIGRwiBt7adxE/Hb+iGVYgIcJY6FhHpCcsNETUoQgjEb0/B+sR0yGXAgmHt0S3ITepYRKRHLDdE1KAs2p2KZfsuAQDmPdsWfdt6SpyIiPSN5YaIGoxVf13Gx7vOAwDefrolhob5SJyIiGoDyw0RNQibjqRj7k9nAADTowIx9jF/iRMRUW1huSEio7f9ZIZuIMyxj/ljWvdAiRMRUW0yiHKzePFi+Pn5wcLCAhEREUhMTLznsl999RW6dOkCR0dHODo6Iioq6r7LE1HDtvd8DqZuOAqtAIaF+uCtvi0gk3G8KCJjJnm52bhxI+Li4jB79mwkJycjODgYPXv2RHZ29l2X/+OPPzBixAjs2bMHBw4cgI+PD5566ilcv369jpMTkaFLvJyHF749ArVGoG9bT7z/bBsWG6IGQCaEEFIGiIiIQFhYGBYtWgQA0Gq18PHxwZQpUzBjxowHrq/RaODo6IhFixYhOjr6gcsrlUrY29ujoKAAdnZ2j5yfiAzT0bRbeG75IRSrNHgiyBXLng+Fuank/54johqqzve3pH/TVSoVkpKSEBUVpZsnl8sRFRWFAwcOPNRrlJSUQK1Ww8nJqbZiElE9c/pGAWJWJqJYpUFkgDOWPhfCYkPUgEg67G1ubi40Gg3c3d0rzXd3d0dKSspDvcbrr78OLy+vSgXpn8rLy1FeXq57rFQqax6YiAzehaxCPL8iEcqyCoT4OmJ5TCgszEykjkVEdahe/1Nm3rx52LBhA7Zu3QoLC4u7LhMfHw97e3vd5OPD+1oQGasrucUYtfwQ8opVaONtj1WxYbBWSPpvOCKSgKTlxsXFBSYmJsjKyqo0PysrCx4eHvdd96OPPsK8efPw22+/oW3btvdcbubMmSgoKNBN6enpeslORIbl2q0SjFp+CNmF5WjuYYtvxoTDzsJM6lhEJAFJy425uTlCQkKQkJCgm6fVapGQkIDIyMh7rvfBBx/g3XffxY4dOxAaGnrf91AoFLCzs6s0EZFxyVKWYdTyQ7ieX4oAV2t8OzYCjtbmUsciIolIvr82Li4OMTExCA0NRXh4OBYsWIDi4mLExsYCAKKjo+Ht7Y34+HgAwPz58zFr1iysW7cOfn5+yMzMBADY2NjAxsZGss9BRNLILSrHyK8O4urNEvg4WWLtuAi42iqkjkVEEpK83AwbNgw5OTmYNWsWMjMz0a5dO+zYsUN3knFaWhrk8v/tYFqyZAlUKhUGDx5c6XVmz56NOXPm1GV0IpJYfokKz69IxMWcYnjaW2DduI7wtLeUOhYRSUzy+9zUNd7nhsg4KMvUeH75IRy/VgAXGwW+e6EjAly595bIWFXn+1vyPTdERNWVX6JC9MpEnLhWAEcrM6wdF8FiQ0Q6LDdEVK/kFpXjueWHkJJZCCdrc3wzJhxBHrZSxyIiA8JyQ0T1RmZBGUYuP4hLOcVwtVVg3bgIBLqz2BBRZSw3RFQvpOfdvo9NWl4JvOwtsHZ8R/i7WEsdi4gMEMsNERm8y7nFGPXVQdwoKENjJyusGx+BRo5WUsciIgPFckNEBu18ViFGLT+EnMJyNHG1xtpxHeFhf/fhVoiIAJYbIjJgp64XIHplIvKKVWjuYYs14yLgYsMb9BHR/bHcEJFBOpp2CzErb4/uHdzIHl+PCYeDFYdUIKIHY7khIoNz6NJNjFl9GMUqDcL8HLFydBhsOQgmET0klhsiMih/XsjB+G+OoEytReemzvgqOhRW5vxVRUQPj78xiMhgJJzNwktrk6Gq0KJbkCuWPBcCCzMTqWMRUT3DckNEBmH7yQxMWX8UFVqBnq3c8fmIDjA3lT94RSKif2G5ISLJ/XDsOuK+Ow6NVuCZYC98PDQYZiYsNkRUMyw3RCSp7w6n4/UtJyAEMCSkEeYNagsTuUzqWERUj7HcEJFkvjlwBbN+OA0AeK5jY7zzTGvIWWyI6BGx3BCRJL7adwn/9+tZAMDYx/zxVt8WkMlYbIjo0bHcEFGd+zzhAj7edR4AMKlbE7z6VBCLDRHpDcsNEdWZW8UqfLAzBesT0wEAr/RohindAyVORUTGhuWGiGqdWqPFmoNXseD3CygoVQMA3ujTHBMebyJxMiIyRiw3RFSr/jiXjfd+OYvU7CIAQHMPW8zq1xKdmrhInIyIjBXLDRHVios5RXjv5zPYcy4HAOBkbY5XnmqG4WGNeak3EdUqlhsi0quCEjU+S7iAbw5cQYVWwFQuw+hOfpjSPRD2lhz8kohqH8sNEenNd0fSEf/rWdwquX1eTffmbnizbwsEuNpInIyIGhKWGyJ6ZFqtwPydKfhy7yUAQKCbDd5+uiUeb+YqcTIiaohYbojokagqtPjP5uPYduwGAGB6VCAmd2sKU44NRUQSYbkhohorLFPjpTXJ2J+aCxO5DPOebYMhoT5SxyKiBo7lhohqJLuwDKNXHsaZDCWszE2weFQHdAtykzoWERHLDRFV38WcIsSsTMS1W6VwtjbHytFhCPZxkDoWEREAlhsiqqbktFsYu/owbpWo4etshW/GhMPX2VrqWEREOiw3RPTQdp3JwpT1yShTa9G2kT1Wjg6Di41C6lhERJWw3BDRA2m1AmsPXcXsH09DK4AnglyxeGQHWCv4K4SIDA9/MxHRPZVXaLDt6HUs23cJF3OKAQBDQhrh/WfbwIyXehORgWK5IaIqCkrVWHvoKlb/dQXZheUAAFuFKSZ2a4oXuwZAJuPYUERkuFhuiEgno6AUK/dfxrpDaShWaQAAHnYWGPuYP4aH+8DWgmNDEZHhY7khIpzLLMSX+y7ix2M3UKEVAIAgd1tMeDwA/YK9YG7KQ1BEVH+w3BA1YMXlFZi/IwXfHLiqm9cxwAkvdG2CJ5q58vATEdVLLDdEDdT+C7l4/fsTuJ5fCgDo08YDLzzehDfjI6J6j+WGqIFRlqkR/+tZrE9MBwA0crTE/EFt0bmpi8TJiIj0g+WGqAHZcy4bb2w5iYyCMgBATKQv/tOrOe9XQ0RGhb/RiBqAghI15v58GluSrwMA/JytMH9QW0QEOEucjIhI/1huiIzcb6cz8ea2U8gpLIdMBozt7I9XngqCpbmJ1NGIiGoFyw2RkUq6mocFv1/AnxdyAQBNXK3xweBghPg6SpyMiKh2sdwQGZkjV/LwWcL/So2pXIbxjwdgWvdAWJhxbw0RGT+WGyIjkXg5D58lnMdfqTcB3C41g0MaYVK3pvBxspI4HRFR3WG5IarnDl26ic8SLuDvi/8rNUNCG2HiEyw1RNQwsdwQ1VPJabfw4Y5zOHDpdqkxM5FhSKgPJj7RBI0cWWqIqOFiuSGqZ24VqzB/Rwo2HL59Ez4zExmGhvpgYrem8HawlDgdEZH0WG6I6gmtVmBz0jXEbz+LWyVqAMDgkEZ4uUczlhoion9guSGqB1IylXhr6ykcuXoLwO0Ru98b2Bphfk4SJyMiMjwsN0QGrLi8Ap8lXMCK/Zeh0QpYmZvg5ahmGN3ZD2YmcqnjEREZJMl/Oy5evBh+fn6wsLBAREQEEhMT77ns6dOnMWjQIPj5+UEmk2HBggV1F5SoDgkhsONUBqI+2Ytl+y5BoxXo1coDv8d1xfjHA1hsiIjuQ9LfkBs3bkRcXBxmz56N5ORkBAcHo2fPnsjOzr7r8iUlJQgICMC8efPg4eFRx2mJ6sbVm8UYs/owXlyTjIyCMvg4WWLV6DAsfT4EXjy3hojogWRCCCHVm0dERCAsLAyLFi0CAGi1Wvj4+GDKlCmYMWPGfdf18/PD9OnTMX369Gq9p1KphL29PQoKCmBnZ1fT6ER6V6bWYMkfF7Fk70WoKrQwM5Hhxa5NMKlbU95ZmIgavOp8f0t2zo1KpUJSUhJmzpypmyeXyxEVFYUDBw7o7X3Ky8tRXl6ue6xUKvX22kT6knA2C3N+Oo30vFIAQJdAF8x5phWauNpInIyIqP6RrNzk5uZCo9HA3d290nx3d3ekpKTo7X3i4+Mxd+5cvb0ekT6l55Vg7k9n8PvZLACAp70F3n66JXq39oBMJpM4HRFR/WT0V0vNnDkTcXFxusdKpRI+Pj4SJiK6fQhq2b5LWLwnFeUVWpjKZRjbxR9TnwyEtcLo/1oSEdUqyX6Luri4wMTEBFlZWZXmZ2Vl6fVkYYVCAYVCobfXI3oUqgot/jiXjfd/PYsrN0sAAJEBznh3QCs0dbOVOB0RkXGQrNyYm5sjJCQECQkJGDBgAIDbJxQnJCRg8uTJUsUi0rtrt0rwx7kc/HEuB39fzEWJSgMAcLNV4K2nW6JfW08egiIi0iNJ93/HxcUhJiYGoaGhCA8Px4IFC1BcXIzY2FgAQHR0NLy9vREfHw/g9knIZ86c0f35+vXrOHbsGGxsbNC0aVPJPgfRP5VXaHD48i38cS4bf5zPQWp2UaXnXWzM8WyHRpjyZFPYWphJlJKIyHhJWm6GDRuGnJwczJo1C5mZmWjXrh127NihO8k4LS0Ncvn/bsVz48YNtG/fXvf4o48+wkcffYSuXbvijz/+qOv4RJWkZCrx6a7z+PPC//bOAIBcBnRo7IgnglzxRJAbWnraQS7nnhoiotoi6X1upMD73JC+lak1WLwnFUv+uIgK7e2/Tq62CnRt5oonglzRpakr7K24h4aI6FHUi/vcEBmDw1fyMOP7E7iYUwwA6NHSHdO6B3LvDBGRhFhuiGqgsEyN+TtSsOZgGoDbe2reeaYVevH+NEREkmO5IaqmXWey8Pa2U8hUlgEAhoX64I0+LXjoiYjIQLDcED2knMJyzPnpNH45kQEA8HW2QvzANujU1EXiZERE9E8sN0QPoNZosT4xDR//dh4FpWqYyGUY3yUA06MCOaAlEZEBYrkhugchBH49mYkPd6bo7ibcyssO8we1RWtve4nTERHRvbDcEN3FoUs3Eb89BcfS8wHcvvHetKhmGBHmA1MT+f1XJiIiSbHcEP3D+axCzN+egoSUbACAlbkJxncJwPjHA2DDAS2JiOoF/rYmApBZUIZPd53HpqR0aAVgIpdhRLgPpnYPhJuthdTxiIioGlhuqEHRaAVu5Jfiys1iXLlZgqu5t/+7PzUHZWotAKBXKw+81isITVxtJE5LREQ1wXJDRksIgd/OZOHAxZu4erMYV2+WIP1WCdSau484EurriJl9miPE16mOkxIRkT6x3JBROpaej3d/PoOkq7eqPGduKkdjJyv4OVvB19kafs5WaO5ph1BfR95dmIjICLDckFG5nl+KD3ak4IdjNwAAlmYmGBbmgyAPW/g6W8HP2RoedhYc94mIyIix3JBRKC6vwNK9F7Fs3yWUV2ghkwGDOjTCaz2D4G7HE4KJiBoSlhuq1zRage+TruHD384hp7AcABDh74S3n27JG+0RETVQLDdUb/19MRfv/XwWZzKUAG6P9TSzdwv0bOXOc2eIiBowlhuqd5LTbuGT385jf2ouAMDWwhTTugciOtIP5qa8ezARUUPHckP1xqnrBfhk13ns/u/dg81MZBgZ3hjToprBydpc4nRERGQoWG7I4J3PKsSnu85j+6lMALfvHjyogzemPBkIHycridMREZGhYbkhg3UppwifJVzAj8dvQAhAJgP6B3thWlQz+LtYSx2PiIgMFMsNGZS8YhUOX8nDztOZ+OHYDWi0t+8m3KeNB6ZHNUMzd1uJExIRkaFjuSFJZSnLcOhyHhIv30Ti5Tyczyqq9Hz35m54uUczXtZNREQPjeWG6lROYTn+OJeNxMt5SLySh6s3S6osE+hmg3B/JwwKaYQOjR0lSElERPUZyw3VuvS8Euw8nYmdpzNx5OotiH+MWymXAS297BDu54xwfyeE+TnC2UYhXVgiIqr3WG5I74QQuJBdhB2nMrHjVKbuJnt3tG1kj85NXRDu74QQX0fYWZhJlJSIiIwRyw3phVqjxbH0fCSczcbO05m4nFuse04uAyL8ndGzlTueauUBLwdLCZMSEZGxY7mhGhFC4HJuMfan5mLf+VwcvHQTReUVuufNTeToEuiCnq09ENXCnTfZIyKiOsNyQw8tv0SFv1Jv4s8LOfjzQi6u55dWet7RygyPBbqiZyt3PBHkBhsFf7yIiKju8dungRNCIC2vBJkFZbhVokJesRq3SlS4VaxCXokK+SVq5BWrcKtEhbS8kkonA5ubyBHi64guzVzweKArWnraQS7ngJVERCQtlpsG5mZROY5fy8ex9AIcS8/H8fR8FJSqH3r9Zu42eKypK7o0c0GEvxOszPkjREREhoXfTEZMCIGj6flIvnrrdpG5lo/0vNIqy5mbytHIwRKO1uZwtDKHo5UZnKzN4WBlDidrs9vzrM3R2MkK7nYWEnwSIiKih8dyY4RKVBXYknwdq/++gtTsoirPN3G1RjsfR7TzsUc7H0cEedjC3FQuQVIiIiL9Y7kxItduleDbA1ex4XC67lCTtbkJIpu4oH1jBwQ3ckBbH3veV4aIiIway009J4TA4Su3sOqvy9h5OhP/HWcSjZ2sMLqTH4aENoItywwRETUgLDf1VImqAr+ezMSqvy7j9I3/3QG4c1NnxHbyR7fmbjDhlUtERNQAsdzUI7lF5Ug4m4XfTmdhf2ouyiu0AACFqRzPdvDG6E7+CPKwlTglERGRtFhuDNylnCLsOpOFXWeykJRWedDJxk5WGB7ugxFhjeHIOwATEREBYLkxKKoKLdLySnAltxhJabew60xWlaud2njbo0dLdzzVyh1B7raQyXjoiYiI6J9YbuqYWqPF9VuluHyzGFdyb0+Xb5bgcm4Rrt8q1Z0QfIepXIbIJs7o0dIdUS3cOegkERHRA7Dc6IlGK3CzuBzZynJkKcuQpSxHprIM2coy3ePswjLkFqnu+zpW5ibwc7ZGM3cbdGvuhieC3GBvyaudiIiIHhbLjZ78fTEXz69IfKhlFaZy+Dlbw8/FCn4u1vB3toafizUCXKzhaqvgoSYiIqJHwHKjJ+52FpDLABcbBdztLOBup4CbnQXcbW//2d3OAm52CnjYWcDRypwDTBIREdUSlhs9aepqg/Pv9YapCYcxICIikhLLjZ7I5TLIwb0xREREUuNuBiIiIjIqLDdERERkVFhuiIiIyKiw3BAREZFRYbkhIiIio2IQ5Wbx4sXw8/ODhYUFIiIikJh4/5vhbdq0Cc2bN4eFhQXatGmDX3/9tY6SEhERkaGTvNxs3LgRcXFxmD17NpKTkxEcHIyePXsiOzv7rsv//fffGDFiBMaOHYujR49iwIABGDBgAE6dOlXHyYmIiMgQyYQQ4sGL1Z6IiAiEhYVh0aJFAACtVgsfHx9MmTIFM2bMqLL8sGHDUFxcjJ9//lk3r2PHjmjXrh2WLl36wPdTKpWwt7dHQUEB7Ozs9PdBiIiIqNZU5/tb0j03KpUKSUlJiIqK0s2Ty+WIiorCgQMH7rrOgQMHKi0PAD179rzn8kRERNSwSHqH4tzcXGg0Gri7u1ea7+7ujpSUlLuuk5mZedflMzMz77p8eXk5ysvLdY+VSuUjpiYiIiJDJvk5N7UtPj4e9vb2usnHx0fqSERERFSLJC03Li4uMDExQVZWVqX5WVlZ8PDwuOs6Hh4e1Vp+5syZKCgo0E3p6en6CU9EREQGSdJyY25ujpCQECQkJOjmabVaJCQkIDIy8q7rREZGVloeAHbt2nXP5RUKBezs7CpNREREZLwkHxU8Li4OMTExCA0NRXh4OBYsWIDi4mLExsYCAKKjo+Ht7Y34+HgAwLRp09C1a1d8/PHH6Nu3LzZs2IAjR45g2bJlD/V+dy4O47k3RERE9ced7+2HushbGIDPP/9cNG7cWJibm4vw8HBx8OBB3XNdu3YVMTExlZb/7rvvRLNmzYS5ublo1aqV+OWXXx76vdLT0wUATpw4ceLEiVM9nNLT0x/4XS/5fW7qmlarxY0bN2BrawuZTKbX11YqlfDx8UF6ejoPf9UBbu+6xe1dt7i96xa3d92qyfYWQqCwsBBeXl6Qy+9/Vo3kh6XqmlwuR6NGjWr1PXhuT93i9q5b3N51i9u7bnF7163qbm97e/uHWs7oLwUnIiKihoXlhoiIiIwKy40eKRQKzJ49GwqFQuooDQK3d93i9q5b3N51i9u7btX29m5wJxQTERGRceOeGyIiIjIqLDdERERkVFhuiIiIyKiw3BAREZFRYbnRk8WLF8PPzw8WFhaIiIhAYmKi1JGMxr59+9CvXz94eXlBJpNh27ZtlZ4XQmDWrFnw9PSEpaUloqKicOHCBWnC1nPx8fEICwuDra0t3NzcMGDAAJw7d67SMmVlZZg0aRKcnZ1hY2ODQYMGISsrS6LE9duSJUvQtm1b3Y3MIiMjsX37dt3z3Na1a968eZDJZJg+fbpuHre5/syZMwcymazS1Lx5c93ztbmtWW70YOPGjYiLi8Ps2bORnJyM4OBg9OzZE9nZ2VJHMwrFxcUIDg7G4sWL7/r8Bx98gIULF2Lp0qU4dOgQrK2t0bNnT5SVldVx0vpv7969mDRpEg4ePIhdu3ZBrVbjqaeeQnFxsW6Zl19+GT/99BM2bdqEvXv34saNG3j22WclTF1/NWrUCPPmzUNSUhKOHDmCJ598Ev3798fp06cBcFvXpsOHD+PLL79E27ZtK83nNtevVq1aISMjQzft379f91ytbuuHHnGS7ik8PFxMmjRJ91ij0QgvLy8RHx8vYSrjBEBs3bpV91ir1QoPDw/x4Ycf6ubl5+cLhUIh1q9fL0FC45KdnS0AiL179wohbm9bMzMzsWnTJt0yZ8+eFQDEgQMHpIppVBwdHcXy5cu5rWtRYWGhCAwMFLt27RJdu3YV06ZNE0Lw51vfZs+eLYKDg+/6XG1va+65eUQqlQpJSUmIiorSzZPL5YiKisKBAwckTNYwXL58GZmZmZW2v729PSIiIrj99aCgoAAA4OTkBABISkqCWq2utL2bN2+Oxo0bc3s/Io1Ggw0bNqC4uBiRkZHc1rVo0qRJ6Nu3b6VtC/DnuzZcuHABXl5eCAgIwKhRo5CWlgag9rd1gxs4U99yc3Oh0Wjg7u5eab67uztSUlIkStVwZGZmAsBdt/+d56hmtFotpk+fjs6dO6N169YAbm9vc3NzODg4VFqW27vmTp48icjISJSVlcHGxgZbt25Fy5YtcezYMW7rWrBhwwYkJyfj8OHDVZ7jz7d+RUREYPXq1QgKCkJGRgbmzp2LLl264NSpU7W+rVluiOiuJk2ahFOnTlU6Rk76FxQUhGPHjqGgoACbN29GTEwM9u7dK3Uso5Seno5p06Zh165dsLCwkDqO0evdu7fuz23btkVERAR8fX3x3XffwdLSslbfm4elHpGLiwtMTEyqnOGdlZUFDw8PiVI1HHe2Mbe/fk2ePBk///wz9uzZg0aNGunme3h4QKVSIT8/v9Ly3N41Z25ujqZNmyIkJATx8fEIDg7GZ599xm1dC5KSkpCdnY0OHTrA1NQUpqam2Lt3LxYuXAhTU1O4u7tzm9ciBwcHNGvWDKmpqbX+881y84jMzc0REhKChIQE3TytVouEhARERkZKmKxh8Pf3h4eHR6Xtr1QqcejQIW7/GhBCYPLkydi6dSt2794Nf3//Ss+HhITAzMys0vY+d+4c0tLSuL31RKvVory8nNu6FnTv3h0nT57EsWPHdFNoaChGjRql+zO3ee0pKirCxYsX4enpWfs/3498SjKJDRs2CIVCIVavXi3OnDkjJkyYIBwcHERmZqbU0YxCYWGhOHr0qDh69KgAID755BNx9OhRcfXqVSGEEPPmzRMODg7ihx9+ECdOnBD9+/cX/v7+orS0VOLk9c9LL70k7O3txR9//CEyMjJ0U0lJiW6ZF198UTRu3Fjs3r1bHDlyRERGRorIyEgJU9dfM2bMEHv37hWXL18WJ06cEDNmzBAymUz89ttvQghu67rwz6ulhOA216dXXnlF/PHHH+Ly5cvir7/+ElFRUcLFxUVkZ2cLIWp3W7Pc6Mnnn38uGjduLMzNzUV4eLg4ePCg1JGMxp49ewSAKlNMTIwQ4vbl4G+//bZwd3cXCoVCdO/eXZw7d07a0PXU3bYzALFq1SrdMqWlpWLixInC0dFRWFlZiYEDB4qMjAzpQtdjY8aMEb6+vsLc3Fy4urqK7t2764qNENzWdeHf5YbbXH+GDRsmPD09hbm5ufD29hbDhg0Tqampuudrc1vLhBDi0ff/EBERERkGnnNDRERERoXlhoiIiIwKyw0REREZFZYbIiIiMiosN0RERGRUWG6IiIjIqLDcEBERkVFhuSGiBk8mk2Hbtm1SxyAiPWG5ISJJjR49GjKZrMrUq1cvqaMRUT1lKnUAIqJevXph1apVleYpFAqJ0hBRfcc9N0QkOYVCAQ8Pj0qTo6MjgNuHjJYsWYLevXvD0tISAQEB2Lx5c6X1T548iSeffBKWlpZwdnbGhAkTUFRUVGmZlStXolWrVlAoFPD09MTkyZMrPZ+bm4uBAwfCysoKgYGB+PHHH2v3QxNRrWG5ISKD9/bbb2PQoEE4fvw4Ro0aheHDh+Ps2bMAgOLiYvTs2ROOjo44fPgwNm3ahN9//71SeVmyZAkmTZqECRMm4OTJk/jxxx/RtGnTSu8xd+5cDB06FCdOnECfPn0watQo5OXl1ennJCI90cvwm0RENRQTEyNMTEyEtbV1pen//u//hBC3Ryp/8cUXK60TEREhXnrpJSGEEMuWLROOjo6iqKhI9/wvv/wi5HK5yMzMFEII4eXlJd588817ZgAg3nrrLd3joqIiAUBs375db5+TiOoOz7khIsl169YNS5YsqTTPyclJ9+fIyMhKz0VGRuLYsWMAgLNnzyI4OBjW1ta65zt37gytVotz585BJpPhxo0b6N69+30ztG3bVvdna2tr2NnZITs7u6YfiYgkxHJDRJKztraucphIXywtLR9qOTMzs0qPZTIZtFptbUQiolrGc26IyOAdPHiwyuMWLVoAAFq0aIHjx4+juLhY9/xff/0FuVyOoKAg2Nraws/PDwkJCXWamYikwz03RCS58vJyZGZmVppnamoKFxcXAMCmTZsQGhqKxx57DGvXrkViYiJWrFgBABg1ahRmz56NmJgYzJkzBzk5OZgyZQqef/55uLu7AwDmzJmDF198EW5ubujduzcKCwvx119/YcqUKXX7QYmoTrDcEJHkduzYAU9Pz0rzgoKCkJKSAuD2lUwbNmzAxIkT4enpifXr16Nly5YAACsrK+zcuRPTpk1DWFgYrKysMGjQIHzyySe614qJiUFZWRk+/fRTvPrqq3BxccHgwYPr7gMSUZ2SCSGE1CGIiO5FJpNh69atGDBggNRRiKie4Dk3REREZFRYboiIiMio8JwbIjJoPHJORNXFPTdERERkVFhuiIiIyKiw3BAREZFRYbkhIiIio8JyQ0REREaF5YaIiIiMCssNERERGRWWGyIiIjIqLDdERERkVP4fA8jbuKpyii4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Your code here :" + "# Your code here :\n", + "\n", + "# Plot training accuracy\n", + "plt.plot(history.history['loss'])\n", + "plt.title('Model Loss')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train'], loc='upper right')\n", + "plt.show()\n", + "\n", + "# plot loss accuracy\n", + "plt.plot(history.history['accuracy'])\n", + "plt.title('Model Accuracy')\n", + "plt.ylabel('Accuracy')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(['Train'], loc='upper left')\n", + "plt.show()\n" ] }, { @@ -345,11 +726,15 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ - "# Your code here :" + "# Your code here :\n", + "\n", + "# define seed and next words\n", + "seed_text = \"this morning, Romeo was\"\n", + "next_words = 50\n" ] }, { @@ -365,14 +750,103 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 44, "metadata": { "id": "6Vc6PHgxa6Hm", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "this morning, Romeo was to\n", + "this morning, Romeo was to thee\n", + "this morning, Romeo was to thee i\n", + "this morning, Romeo was to thee i am\n", + "this morning, Romeo was to thee i am thought\n", + "this morning, Romeo was to thee i am thought i\n", + "this morning, Romeo was to thee i am thought i call\n", + "this morning, Romeo was to thee i am thought i call it\n", + "this morning, Romeo was to thee i am thought i call it pity\n", + "this morning, Romeo was to thee i am thought i call it pity such\n", + "this morning, Romeo was to thee i am thought i call it pity such look\n", + "this morning, Romeo was to thee i am thought i call it pity such look what\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine '\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so great\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so great twain\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so great twain free\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so great twain free free\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so great twain free free free\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so great twain free free free done\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so great twain free free free done alone\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so great twain free free free done alone should\n", + "this morning, Romeo was to thee i am thought i call it pity such look what untrue still be ill green thine bright bright new viewest cherish here new bad o'er deeds of youth of thine ' how for you look so see me so great twain free free free done alone should see\n" + ] + } + ], "source": [ - "# Your code here :" + "# Your code here :\n", + "\n", + "def generate_text(model, seed_text, next_words):\n", + " for _ in range(next_words):\n", + "\n", + " # tokenize seed text\n", + " token_list = tokenizer.texts_to_sequences([seed_text])[0]\n", + "\n", + " # pad tokenized seed\n", + " token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')\n", + "\n", + " # predict the next word\n", + " predicted = model.predict(token_list, verbose=0)\n", + "\n", + " # chose the word with the highest probability\n", + " predicted_word_index = np.argmax(predicted, axis=-1)[0]\n", + "\n", + " # get the corresponding word\n", + " output_word = \"\"\n", + " for word, index in tokenizer.word_index.items():\n", + " if index == predicted_word_index:\n", + " output_word = word\n", + " break\n", + "\n", + " # append predicted word to the seed text\n", + " seed_text += \" \" + output_word\n", + "\n", + " print(seed_text)\n", + "\n", + "seed_text = \"this morning, Romeo was\"\n", + "next_words = 50\n", + "\n", + "generate_text(model, seed_text, next_words)" ] }, { @@ -384,11 +858,478 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "And then Alex the\n", + "And then Alex the world\n", + "And then Alex the world do\n", + "And then Alex the world do i\n", + "And then Alex the world do i have\n", + "And then Alex the world do i have betray\n", + "And then Alex the world do i have betray decease\n", + "And then Alex the world do i have betray decease torn\n", + "And then Alex the world do i have betray decease torn torn\n", + "And then Alex the world do i have betray decease torn torn brought\n", + "And then Alex the world do i have betray decease torn torn brought to\n", + "And then Alex the world do i have betray decease torn torn brought to loss\n", + "And then Alex the world do i have betray decease torn torn brought to loss it\n", + "And then Alex the world do i have betray decease torn torn brought to loss it still\n", + "And then Alex the world do i have betray decease torn torn brought to loss it still none\n", + "And then Alex the world do i have betray decease torn torn brought to loss it still none 'will\n", + "And then Alex the world do i have betray decease torn torn brought to loss it still none 'will '\n", + "And then Alex the world do i have betray decease torn torn brought to loss it still none 'will ' might\n", + "And then Alex the world do i have betray decease torn torn brought to loss it still none 'will ' might 'tis\n", + "And then Alex the world do i have betray decease torn torn brought to loss it still none 'will ' might 'tis not\n" + ] + } + ], "source": [ - "# Your code here :" + "# Your code here :\n", + "seed_text = \"And then Alex\"\n", + "next_words = 20\n", + "\n", + "generate_text(seed_text, next_words)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I could not believe that not\n", + "I could not believe that not for\n", + "I could not believe that not for my\n", + "I could not believe that not for my dear\n", + "I could not believe that not for my dear state\n", + "I could not believe that not for my dear state new\n", + "I could not believe that not for my dear state new bright\n", + "I could not believe that not for my dear state new bright friend\n", + "I could not believe that not for my dear state new bright friend grow\n", + "I could not believe that not for my dear state new bright friend grow wide\n", + "I could not believe that not for my dear state new bright friend grow wide face\n", + "I could not believe that not for my dear state new bright friend grow wide face hour\n", + "I could not believe that not for my dear state new bright friend grow wide face hour '\n", + "I could not believe that not for my dear state new bright friend grow wide face hour ' alone\n", + "I could not believe that not for my dear state new bright friend grow wide face hour ' alone are\n", + "I could not believe that not for my dear state new bright friend grow wide face hour ' alone are much\n", + "I could not believe that not for my dear state new bright friend grow wide face hour ' alone are much gone\n", + "I could not believe that not for my dear state new bright friend grow wide face hour ' alone are much gone by\n", + "I could not believe that not for my dear state new bright friend grow wide face hour ' alone are much gone by find\n", + "I could not believe that not for my dear state new bright friend grow wide face hour ' alone are much gone by find room\n" + ] + } + ], + "source": [ + "# Your code here :\n", + "seed_text = \"I could not believe that\"\n", + "next_words = 20\n", + "\n", + "generate_text(seed_text, next_words)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The reason why I hate you is that delight\n", + "The reason why I hate you is that delight rage\n", + "The reason why I hate you is that delight rage hour\n", + "The reason why I hate you is that delight rage hour survey\n", + "The reason why I hate you is that delight rage hour survey rehearse\n", + "The reason why I hate you is that delight rage hour survey rehearse rare\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no '\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade so\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade so deem'd\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade so deem'd so\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade so deem'd so small\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade so deem'd so small part\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade so deem'd so small part are\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade so deem'd so small part are '\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade so deem'd so small part are ' long\n", + "The reason why I hate you is that delight rage hour survey rehearse rare 'no ' 'tis bright shade so deem'd so small part are ' long respect\n" + ] + } + ], + "source": [ + "# Your code here :\n", + "seed_text = \"The reason why I hate you is that\"\n", + "next_words = 20\n", + "\n", + "generate_text(seed_text, next_words)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extra: Improve model" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/100\n", + "388/388 [==============================] - 18s 32ms/step - loss: 6.9621 - accuracy: 0.0232 - val_loss: 6.8017 - val_accuracy: 0.0200\n", + "Epoch 2/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 6.4927 - accuracy: 0.0255 - val_loss: 6.8677 - val_accuracy: 0.0165\n", + "Epoch 3/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 6.3988 - accuracy: 0.0244 - val_loss: 6.9650 - val_accuracy: 0.0171\n", + "Epoch 4/100\n", + "388/388 [==============================] - 7s 17ms/step - loss: 6.2922 - accuracy: 0.0296 - val_loss: 7.0978 - val_accuracy: 0.0245\n", + "Epoch 5/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 6.1802 - accuracy: 0.0375 - val_loss: 7.1588 - val_accuracy: 0.0236\n", + "Epoch 6/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 6.0882 - accuracy: 0.0404 - val_loss: 7.4771 - val_accuracy: 0.0229\n", + "Epoch 7/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 6.0116 - accuracy: 0.0426 - val_loss: 7.4875 - val_accuracy: 0.0252\n", + "Epoch 8/100\n", + "388/388 [==============================] - 6s 14ms/step - loss: 5.9394 - accuracy: 0.0434 - val_loss: 7.5955 - val_accuracy: 0.0245\n", + "Epoch 9/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 5.8649 - accuracy: 0.0479 - val_loss: 7.8860 - val_accuracy: 0.0268\n", + "Epoch 10/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 5.7875 - accuracy: 0.0504 - val_loss: 7.7916 - val_accuracy: 0.0268\n", + "Epoch 11/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 5.6953 - accuracy: 0.0575 - val_loss: 8.0285 - val_accuracy: 0.0313\n", + "Epoch 12/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 5.5961 - accuracy: 0.0604 - val_loss: 8.2555 - val_accuracy: 0.0362\n", + "Epoch 13/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 5.4895 - accuracy: 0.0667 - val_loss: 8.3605 - val_accuracy: 0.0362\n", + "Epoch 14/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 5.3819 - accuracy: 0.0756 - val_loss: 8.4276 - val_accuracy: 0.0349\n", + "Epoch 15/100\n", + "388/388 [==============================] - 6s 17ms/step - loss: 5.2690 - accuracy: 0.0802 - val_loss: 8.7491 - val_accuracy: 0.0384\n", + "Epoch 16/100\n", + "388/388 [==============================] - 7s 18ms/step - loss: 5.1537 - accuracy: 0.0878 - val_loss: 8.8785 - val_accuracy: 0.0391\n", + "Epoch 17/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 5.0337 - accuracy: 0.0976 - val_loss: 9.1288 - val_accuracy: 0.0355\n", + "Epoch 18/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 4.9220 - accuracy: 0.1070 - val_loss: 9.1110 - val_accuracy: 0.0391\n", + "Epoch 19/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 4.8120 - accuracy: 0.1138 - val_loss: 9.4869 - val_accuracy: 0.0365\n", + "Epoch 20/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 4.7008 - accuracy: 0.1226 - val_loss: 10.0490 - val_accuracy: 0.0404\n", + "Epoch 21/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 4.5842 - accuracy: 0.1358 - val_loss: 10.1029 - val_accuracy: 0.0349\n", + "Epoch 22/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 4.4717 - accuracy: 0.1459 - val_loss: 10.6764 - val_accuracy: 0.0378\n", + "Epoch 23/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 4.3735 - accuracy: 0.1579 - val_loss: 10.9336 - val_accuracy: 0.0378\n", + "Epoch 24/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 4.2575 - accuracy: 0.1708 - val_loss: 11.3672 - val_accuracy: 0.0339\n", + "Epoch 25/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 4.1486 - accuracy: 0.1845 - val_loss: 11.5041 - val_accuracy: 0.0387\n", + "Epoch 26/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 4.0257 - accuracy: 0.1979 - val_loss: 12.1010 - val_accuracy: 0.0358\n", + "Epoch 27/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 3.9315 - accuracy: 0.2102 - val_loss: 12.5391 - val_accuracy: 0.0371\n", + "Epoch 28/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 3.8235 - accuracy: 0.2325 - val_loss: 13.1961 - val_accuracy: 0.0336\n", + "Epoch 29/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 3.7178 - accuracy: 0.2497 - val_loss: 13.4267 - val_accuracy: 0.0329\n", + "Epoch 30/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 3.6189 - accuracy: 0.2710 - val_loss: 14.1196 - val_accuracy: 0.0349\n", + "Epoch 31/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 3.5152 - accuracy: 0.2884 - val_loss: 14.4054 - val_accuracy: 0.0313\n", + "Epoch 32/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 3.4093 - accuracy: 0.3123 - val_loss: 14.9396 - val_accuracy: 0.0294\n", + "Epoch 33/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 3.3257 - accuracy: 0.3349 - val_loss: 15.2076 - val_accuracy: 0.0323\n", + "Epoch 34/100\n", + "388/388 [==============================] - 6s 14ms/step - loss: 3.2396 - accuracy: 0.3495 - val_loss: 15.3642 - val_accuracy: 0.0313\n", + "Epoch 35/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 3.1672 - accuracy: 0.3679 - val_loss: 16.0005 - val_accuracy: 0.0345\n", + "Epoch 36/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 3.0586 - accuracy: 0.3950 - val_loss: 16.1493 - val_accuracy: 0.0294\n", + "Epoch 37/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 2.9850 - accuracy: 0.4072 - val_loss: 16.8252 - val_accuracy: 0.0323\n", + "Epoch 38/100\n", + "388/388 [==============================] - 6s 17ms/step - loss: 2.8985 - accuracy: 0.4338 - val_loss: 16.9793 - val_accuracy: 0.0323\n", + "Epoch 39/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 2.8240 - accuracy: 0.4475 - val_loss: 17.3381 - val_accuracy: 0.0284\n", + "Epoch 40/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 2.7448 - accuracy: 0.4686 - val_loss: 17.7424 - val_accuracy: 0.0320\n", + "Epoch 41/100\n", + "388/388 [==============================] - 5s 14ms/step - loss: 2.6680 - accuracy: 0.4834 - val_loss: 17.8755 - val_accuracy: 0.0262\n", + "Epoch 42/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 2.6051 - accuracy: 0.5016 - val_loss: 18.1682 - val_accuracy: 0.0313\n", + "Epoch 43/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 2.5346 - accuracy: 0.5159 - val_loss: 18.1638 - val_accuracy: 0.0242\n", + "Epoch 44/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 2.4803 - accuracy: 0.5268 - val_loss: 18.3972 - val_accuracy: 0.0326\n", + "Epoch 45/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 2.4133 - accuracy: 0.5493 - val_loss: 18.7249 - val_accuracy: 0.0291\n", + "Epoch 46/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 2.3623 - accuracy: 0.5543 - val_loss: 19.2669 - val_accuracy: 0.0300\n", + "Epoch 47/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 2.3055 - accuracy: 0.5747 - val_loss: 18.8510 - val_accuracy: 0.0281\n", + "Epoch 48/100\n", + "388/388 [==============================] - 6s 14ms/step - loss: 2.2395 - accuracy: 0.5865 - val_loss: 19.1688 - val_accuracy: 0.0258\n", + "Epoch 49/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 2.2016 - accuracy: 0.5928 - val_loss: 19.5752 - val_accuracy: 0.0236\n", + "Epoch 50/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 2.1517 - accuracy: 0.6045 - val_loss: 19.5952 - val_accuracy: 0.0258\n", + "Epoch 51/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 2.0845 - accuracy: 0.6232 - val_loss: 19.7475 - val_accuracy: 0.0274\n", + "Epoch 52/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 2.0312 - accuracy: 0.6319 - val_loss: 19.7329 - val_accuracy: 0.0271\n", + "Epoch 53/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 2.0004 - accuracy: 0.6384 - val_loss: 20.0376 - val_accuracy: 0.0262\n", + "Epoch 54/100\n", + "388/388 [==============================] - 7s 17ms/step - loss: 1.9627 - accuracy: 0.6457 - val_loss: 20.0759 - val_accuracy: 0.0265\n", + "Epoch 55/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.9198 - accuracy: 0.6554 - val_loss: 20.0589 - val_accuracy: 0.0258\n", + "Epoch 56/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.8640 - accuracy: 0.6708 - val_loss: 20.3097 - val_accuracy: 0.0200\n", + "Epoch 57/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.8357 - accuracy: 0.6743 - val_loss: 20.3023 - val_accuracy: 0.0278\n", + "Epoch 58/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.7988 - accuracy: 0.6837 - val_loss: 20.5413 - val_accuracy: 0.0232\n", + "Epoch 59/100\n", + "388/388 [==============================] - 7s 17ms/step - loss: 1.7699 - accuracy: 0.6886 - val_loss: 20.4362 - val_accuracy: 0.0242\n", + "Epoch 60/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.7294 - accuracy: 0.6984 - val_loss: 20.7274 - val_accuracy: 0.0252\n", + "Epoch 61/100\n", + "388/388 [==============================] - 5s 14ms/step - loss: 1.6885 - accuracy: 0.7086 - val_loss: 20.7101 - val_accuracy: 0.0249\n", + "Epoch 62/100\n", + "388/388 [==============================] - 5s 14ms/step - loss: 1.6752 - accuracy: 0.7086 - val_loss: 20.6816 - val_accuracy: 0.0229\n", + "Epoch 63/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.6368 - accuracy: 0.7162 - val_loss: 20.7156 - val_accuracy: 0.0249\n", + "Epoch 64/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.6200 - accuracy: 0.7190 - val_loss: 20.7853 - val_accuracy: 0.0236\n", + "Epoch 65/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.5810 - accuracy: 0.7252 - val_loss: 20.7615 - val_accuracy: 0.0252\n", + "Epoch 66/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.5427 - accuracy: 0.7311 - val_loss: 20.8603 - val_accuracy: 0.0242\n", + "Epoch 67/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.5201 - accuracy: 0.7392 - val_loss: 20.7297 - val_accuracy: 0.0265\n", + "Epoch 68/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.4983 - accuracy: 0.7429 - val_loss: 21.0713 - val_accuracy: 0.0271\n", + "Epoch 69/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.4957 - accuracy: 0.7427 - val_loss: 20.9215 - val_accuracy: 0.0262\n", + "Epoch 70/100\n", + "388/388 [==============================] - 6s 17ms/step - loss: 1.4579 - accuracy: 0.7535 - val_loss: 21.0344 - val_accuracy: 0.0245\n", + "Epoch 71/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.4284 - accuracy: 0.7560 - val_loss: 20.9092 - val_accuracy: 0.0268\n", + "Epoch 72/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.4155 - accuracy: 0.7602 - val_loss: 20.9576 - val_accuracy: 0.0245\n", + "Epoch 73/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.3940 - accuracy: 0.7629 - val_loss: 21.0253 - val_accuracy: 0.0239\n", + "Epoch 74/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.3628 - accuracy: 0.7735 - val_loss: 21.0657 - val_accuracy: 0.0242\n", + "Epoch 75/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.3519 - accuracy: 0.7711 - val_loss: 21.0994 - val_accuracy: 0.0226\n", + "Epoch 76/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.3356 - accuracy: 0.7736 - val_loss: 20.9166 - val_accuracy: 0.0200\n", + "Epoch 77/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.3185 - accuracy: 0.7782 - val_loss: 21.1042 - val_accuracy: 0.0226\n", + "Epoch 78/100\n", + "388/388 [==============================] - 5s 14ms/step - loss: 1.2976 - accuracy: 0.7790 - val_loss: 20.9939 - val_accuracy: 0.0249\n", + "Epoch 79/100\n", + "388/388 [==============================] - 5s 14ms/step - loss: 1.2917 - accuracy: 0.7782 - val_loss: 20.9093 - val_accuracy: 0.0239\n", + "Epoch 80/100\n", + "388/388 [==============================] - 6s 14ms/step - loss: 1.2638 - accuracy: 0.7872 - val_loss: 20.8579 - val_accuracy: 0.0220\n", + "Epoch 81/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.2555 - accuracy: 0.7865 - val_loss: 20.8964 - val_accuracy: 0.0245\n", + "Epoch 82/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.2272 - accuracy: 0.7946 - val_loss: 20.8735 - val_accuracy: 0.0216\n", + "Epoch 83/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.2116 - accuracy: 0.7924 - val_loss: 20.8925 - val_accuracy: 0.0210\n", + "Epoch 84/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.2030 - accuracy: 0.7961 - val_loss: 20.9017 - val_accuracy: 0.0226\n", + "Epoch 85/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.1991 - accuracy: 0.7965 - val_loss: 20.9583 - val_accuracy: 0.0255\n", + "Epoch 86/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.1790 - accuracy: 0.7981 - val_loss: 21.0666 - val_accuracy: 0.0249\n", + "Epoch 87/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.1742 - accuracy: 0.7984 - val_loss: 20.8927 - val_accuracy: 0.0262\n", + "Epoch 88/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.1471 - accuracy: 0.8072 - val_loss: 21.0549 - val_accuracy: 0.0239\n", + "Epoch 89/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.1257 - accuracy: 0.8092 - val_loss: 21.0405 - val_accuracy: 0.0258\n", + "Epoch 90/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.1295 - accuracy: 0.8065 - val_loss: 20.9993 - val_accuracy: 0.0236\n", + "Epoch 91/100\n", + "388/388 [==============================] - 5s 14ms/step - loss: 1.1438 - accuracy: 0.8061 - val_loss: 20.9590 - val_accuracy: 0.0262\n", + "Epoch 92/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.1070 - accuracy: 0.8092 - val_loss: 20.8266 - val_accuracy: 0.0213\n", + "Epoch 93/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.0974 - accuracy: 0.8121 - val_loss: 21.1298 - val_accuracy: 0.0265\n", + "Epoch 94/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.0753 - accuracy: 0.8160 - val_loss: 21.0249 - val_accuracy: 0.0271\n", + "Epoch 95/100\n", + "388/388 [==============================] - 6s 16ms/step - loss: 1.0707 - accuracy: 0.8146 - val_loss: 21.0203 - val_accuracy: 0.0252\n", + "Epoch 96/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.0624 - accuracy: 0.8155 - val_loss: 20.9492 - val_accuracy: 0.0242\n", + "Epoch 97/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.0588 - accuracy: 0.8171 - val_loss: 20.8254 - val_accuracy: 0.0207\n", + "Epoch 98/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.0449 - accuracy: 0.8205 - val_loss: 20.9045 - val_accuracy: 0.0252\n", + "Epoch 99/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.0362 - accuracy: 0.8208 - val_loss: 20.9597 - val_accuracy: 0.0220\n", + "Epoch 100/100\n", + "388/388 [==============================] - 6s 15ms/step - loss: 1.0316 - accuracy: 0.8219 - val_loss: 20.7618 - val_accuracy: 0.0284\n" + ] + } + ], + "source": [ + "model2 = Sequential()\n", + "\n", + "model2.add(Embedding(input_dim=total_words, output_dim=100, input_length=max_sequence_len-1))\n", + "model2.add(Bidirectional(LSTM(150, return_sequences=True)))\n", + "model2.add(Dropout(0.2))\n", + "model2.add(LSTM(100))\n", + "model2.add(Dense(total_words // 2, activation='relu', kernel_regularizer=regularizers.l2(0.01)))\n", + "model2.add(Dense(total_words, activation='softmax'))\n", + "\n", + "model2.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n", + "\n", + "# Training with early stopping and validation split\n", + "# early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)\n", + "history = model2.fit(X, y, epochs=100, validation_split=0.2)\n", + "\n", + "# save model\n", + "model2.save(\"model2.keras\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABo1klEQVR4nO3dd3wUdf7H8dduyqYXQiqEBJAuBKRJUeRAiojSFBEVFfVULMhZz1PBhop6nofi6e8EPUUUFVQUFZAqHURAOgIhkAYhve/O74+BhUhAIGWT7Pv5eMxjZ6ftZ0dh33y/35mxGIZhICIiIuJGrK4uQERERKS6KQCJiIiI21EAEhEREbejACQiIiJuRwFIRERE3I4CkIiIiLgdBSARERFxOwpAIiIi4nYUgERERMTtKACJSK1lsViYOHHiee+3f/9+LBYLM2bMqPSaRKR2UAASkQqZMWMGFosFi8XCihUrTltvGAaxsbFYLBauvvpqF1R44ZYsWYLFYuHzzz93dSkiUskUgESkUvj4+DBz5szTli9dupSkpCRsNpsLqhIRKZ8CkIhUiquuuorZs2dTWlpaZvnMmTPp2LEjUVFRLqpMROR0CkAiUilGjRrF0aNHWbBggXNZcXExn3/+OTfeeGO5++Tl5fG3v/2N2NhYbDYbLVq04NVXX8UwjDLbFRUV8dBDDxEeHk5gYCDXXHMNSUlJ5R7z0KFD3H777URGRmKz2WjTpg3vv/9+5X3Rcvz+++9cd9111KtXDz8/Py699FK+/fbb07b797//TZs2bfDz8yM0NJROnTqVaTXLyclh/PjxxMfHY7PZiIiI4Morr2Tjxo1VWr+IO1IAEpFKER8fT7du3fjkk0+cy+bPn09WVhY33HDDadsbhsE111zDP//5TwYMGMDrr79OixYteOSRR5gwYUKZbe+44w7eeOMN+vXrx0svvYSXlxeDBg067ZipqalceumlLFy4kPvuu49//etfXHTRRYwdO5Y33nij0r/zic/s3r07P/zwA/feey8vvPAChYWFXHPNNcyZM8e53XvvvccDDzxA69ateeONN5g0aRLt27dnzZo1zm3uvvtupk2bxvDhw3n77bd5+OGH8fX1Zfv27VVSu4hbM0REKmD69OkGYKxbt86YOnWqERgYaOTn5xuGYRjXXXed0bt3b8MwDCMuLs4YNGiQc7+5c+cagPH888+XOd6IESMMi8Vi7NmzxzAMw9i0aZMBGPfee2+Z7W688UYDMJ555hnnsrFjxxrR0dHGkSNHymx7ww03GMHBwc669u3bZwDG9OnTz/rdFi9ebADG7Nmzz7jN+PHjDcBYvny5c1lOTo7RuHFjIz4+3rDb7YZhGMa1115rtGnT5qyfFxwcbIwbN+6s24hI5VALkIhUmuuvv56CggLmzZtHTk4O8+bNO2P313fffYeHhwcPPPBAmeV/+9vfMAyD+fPnO7cDTttu/PjxZd4bhsEXX3zB4MGDMQyDI0eOOKf+/fuTlZVVJV1J3333HV26dKFnz57OZQEBAdx1113s37+fbdu2ARASEkJSUhLr1q0747FCQkJYs2YNhw8frvQ6RaQsBSARqTTh4eH07duXmTNn8uWXX2K32xkxYkS52x44cICYmBgCAwPLLG/VqpVz/YlXq9VK06ZNy2zXokWLMu/T09PJzMzk3XffJTw8vMx02223AZCWllYp3/OP3+OPtZT3PR577DECAgLo0qULzZo1Y9y4cfz8889l9nnllVfYunUrsbGxdOnShYkTJ/L7779Xes0iAp6uLkBE6pYbb7yRO++8k5SUFAYOHEhISEi1fK7D4QDgpptuYsyYMeVu065du2qppTytWrVi586dzJs3j++//54vvviCt99+m6effppJkyYBZgvaZZddxpw5c/jxxx+ZMmUKL7/8Ml9++SUDBw50We0idZFagESkUg0dOhSr1crq1avP2P0FEBcXx+HDh8nJySmzfMeOHc71J14dDgd79+4ts93OnTvLvD9xhZjdbqdv377lThEREZXxFU/7Hn+spbzvAeDv78/IkSOZPn06iYmJDBo0yDlo+oTo6Gjuvfde5s6dy759+wgLC+OFF16o9LpF3J0CkIhUqoCAAKZNm8bEiRMZPHjwGbe76qqrsNvtTJ06tczyf/7zn1gsFmeLx4nXN998s8x2f7yqy8PDg+HDh/PFF1+wdevW0z4vPT39Qr7On7rqqqtYu3Ytq1atci7Ly8vj3XffJT4+ntatWwNw9OjRMvt5e3vTunVrDMOgpKQEu91OVlZWmW0iIiKIiYmhqKioSmoXcWfqAhORSnemLqhTDR48mN69e/Pkk0+yf/9+EhIS+PHHH/nqq68YP368c8xP+/btGTVqFG+//TZZWVl0796dRYsWsWfPntOO+dJLL7F48WK6du3KnXfeSevWrcnIyGDjxo0sXLiQjIyMC/o+X3zxhbNF54/f8/HHH+eTTz5h4MCBPPDAA9SrV48PPviAffv28cUXX2C1mv/O7NevH1FRUfTo0YPIyEi2b9/O1KlTGTRoEIGBgWRmZtKwYUNGjBhBQkICAQEBLFy4kHXr1vHaa69dUN0ichauvQhNRGq7Uy+DP5s/XgZvGObl4g899JARExNjeHl5Gc2aNTOmTJliOByOMtsVFBQYDzzwgBEWFmb4+/sbgwcPNg4ePHjaZfCGYRipqanGuHHjjNjYWMPLy8uIiooy+vTpY7z77rvObc73MvgzTScufd+7d68xYsQIIyQkxPDx8TG6dOlizJs3r8yx/vOf/xiXX365ERYWZthsNqNp06bGI488YmRlZRmGYRhFRUXGI488YiQkJBiBgYGGv7+/kZCQYLz99ttnrVFELozFMP5wy1URERGROk5jgERERMTtKACJiIiI21EAEhEREbejACQiIiJuRwFIRERE3I4CkIiIiLgd3QixHA6Hg8OHDxMYGIjFYnF1OSIiInIODMMgJyeHmJgY501Iz0QBqByHDx8mNjbW1WWIiIjIBTh48CANGzY86zYKQOUIDAwEzBMYFBTk4mpERETkXGRnZxMbG+v8HT8bBaBynOj2CgoKUgASERGpZc5l+IoGQYuIiIjbUQASERERt6MAJCIiIm5HY4BERKTSORwOiouLXV2G1DFeXl54eHhUyrEUgEREpFIVFxezb98+HA6Hq0uROigkJISoqKgK36dPAUhERCqNYRgkJyfj4eFBbGzsn96MTuRcGYZBfn4+aWlpAERHR1foeApAIiJSaUpLS8nPzycmJgY/Pz9XlyN1jK+vLwBpaWlERERUqDtM0VxERCqN3W4HwNvb28WVSF11IliXlJRU6DgKQCIiUun0HEWpKpX1/5YCkIiIiLgdBSAREZEqEB8fzxtvvOHqMuQMFIBERMStWSyWs04TJ068oOOuW7eOu+66q0K1XXHFFYwfP75Cx5Dy6SowERFxa8nJyc75Tz/9lKeffpqdO3c6lwUEBDjnDcPAbrfj6fnnP5/h4eGVW2hlctjBYgU3HqulFiARETl3hdlQXTc4NAwoLYaiXMjPgJwUyEoy359JaRFkJkJOKtjP7SqhqKgo5xQcHIzFYnG+37FjB4GBgcyfP5+OHTtis9lYsWIFe/fu5dprryUyMpKAgAA6d+7MwoULyxz3j11gFouF//u//2Po0KH4+fnRrFkzvv766ws5M05ffPEFbdq0wWazER8fz2uvvVZm/dtvv02zZs3w8fEhMjKSESNGQF46pGzm8/++Qds2rfD19SUsLIy+ffuSl5dXoXpqE7UAiYjIudn1A3x6MwQ3hL4TodXg01sQ8jLMgFKYDTYbBlBQYj/7cU8EnZI8KC005+1FZpjBKGeHVPCrD4FRYPU4eYz8Y5BzCAwzoPlmH8biGwr+YeAdUKHWjscff5xXX32VJk2aEBoaysGDB7nqqqt44YUXsNlsfPjhhwwePJidO3fSqFGjMx5n0sSJvPLMI0x5+Db+/cEXjB49mgMHDlCvXr2yGxblQE4ylORDwTE4sgesVrB6goc3ePqwYfNvXH/99UycOJGRI0eycuVK7r33XsLCwrj11ltZv349DzzwAP/73//o3r07GRkZLP/pB8hKIjk1nVH3PMorTz7A0IF/IafYwvL1WzHyjoK1GLCY58vTBzxtF3zeajIFIBER+XNH9sAXd5jBJGMvfHYzxF4K/Z6Dhp3h4BpY93+wfwN0fwmyPaAonQLvMFq/vKEKCkoBtp51i233ROFXeAwKj4GHDXxDwCcYvPzOOww9++yzXHnllc739erVIyEhwfn+ueeeY86cOXz99dfcd999J3c0DDPUFWQBcOuIgYwadDkALz76V95870PWLvmeAUNvMLukSosh+xAUZh7f32G2ZBXnnFbT6y+/QJ+eXXjqrmHgaaX50D5s23Q7U155mVvH3EJiYiL+/v5cffXVBAYGEhdVjw6RFsAgObuU0tJShl1zNXFRIQC0bRoNpUfh2NGyH+ThDbZAc/IOAA+vcz9xDof5/T28waNmRY6aVY2IiNQ8RTnw6WgoyobYrtD4clg5FQ6uhv9eCcGNICvR3DYg1vyxwwPsx3/MXSWsOZQeM1tQ7EWQm2pOVi8zCNkCwMvXDEd/DEQOxymtUNCpY8cyq3Nzcpg48Rm+/e47kpNTKC0tpaCggMTfd5ufV1IAjlKzFSdtu3O/dq1bmK1XPsH429IICgwg7eBeSN9p1pSX7mzBwq8+ePqay0PiwLCbxyw169q+ex/X9u9lnmd7MRTl0COhKW+8/R/syVu5snsH4uLiaNKkCQP69WVA93YMHdALv9AoEnq0pU+fPrS94lr6X9mXfr0uZcSgPoQGBwGG2fBmOKC0wDx2/lFzAvANBf8I8C7nTt+lhWYLYEk+FOeb7zHMcBfcEHzr1ZhxRwpAIiLuzmGH35fA/uVma07zgWZ3C5gtGHPvgfQdEBAF139odj11uh0WvwibPjbDj6cPtB0B7W+HfD+o3wgc+fjmprLtnqjTP9PiYf642wLMVgVvX/NH8pxrLoWsZCjMMN97+kJII/DycW7i6+UBlkAIagCFWeZUlA2OEsg/Yk5gfu6JIJSTav7wp/xqrss0g51/zu+QnGF2uRkOHn5kEguWr+HVp8ZzUXwsvj42Rtz1KMXZ6XBs//Fz5zgeZizg7Q+AV/0mEBJrrrcFYrFacWAxg0Juobncy98MC95+5ud52sDvD11kYNbsHwFhzcz97UVm6xaAvZhAMtn43Ycs2biLH3/4nqenvM3E1/7DuvUbCfH0ZMGCBaxcuZIff/yRf//fRzz5/KusWbOGxo0bl/1/ozjXDMFFOcdbs46HSu8ACIg0tyvKNrs97UXl/Le2muchMxEKcyCkodmV52Kur0BERKqOYcCxfZD8K3gHQkA4+B+f0rbD5k9hy2yzZeSEiNbQcwK0GQor/wXbvzFbTUb+zww/AEExcO1U6HYfpG2DJleYP9KFhbBvn/nD7ReOxb8+fgXHzB9RD2/zR9vT1+xGqVBLgCf4NIbCMPNH1y/szAHK6mHW5lfP/CEuyjXDUEm+2VJjOKA4D8g72WIBZkiznvKsKcMOxx/18fP6X7n1usEMHdgHrB7k5hWwPynZ/GH38jODmNXTDCjR7U7WdurDYS0WwAKB0WbLSEmeGSjOsZWkVatW/LxqtRkibeaVaj9v3kvz5i3wCI2D3FQ8KaFvp2b07dSMZx4eR0jzS/lpyRKGDRuGxWKhR48e9OjRg6effpq4uDjmzJnDhAkTyp47n2BzArNVJzfN7FYszoWMPw5IPx72vP2Pnwc/8791bqrZGlZ4DNLzIDTeGQpdRQFIRKSmyjsKexeZrSs+wSfHsPiHn/nHo6QQsg5C0jrYtxz2LYPspD//LN9QM8TsXmgGmi/vgJ+ehcyD5vpBr0Jsl9P3i2hpTmdisZwMH1XBJ+j8trdYzX1O7HdijE7J8a4evzAz+ES2NX/86x1vYYpoBUEBZouI1YNmLdvw5cJVDL7xTixWB0899TwOA/N7hrc4+Vme3n/esmX1gNC4M65OT09n06ZNZZZFR0fzt7/9jc6dO/Pcc88xcuRIVq1axdSpU3n77bchIJx5i1fx+46tXH5JC0JDgvlu1XYcDgctWrRgzZo1LFq0iH79+hEREcGaNWtIT0+nVatWZ6/V2w/qxUNptNldl59x8pzagsxxQqeGxhMCo8x1x/ab5/nILjNEn2hBcgEFIBGRmijzILw/4MzhxRYMQdHmD4tPMGQnm10MuSmnb2v1gqi25mDavPTj40zsZpdPiwHQ7ga4qK/5Y12QCWvfg9VvO7t/6HirOdVFFovZKuVlPmX8REvKaQN2PbxObgO8/s83uP322+neowf169fnscceIzs7u0pKnDlzJjNnziyz7LnnnuMf//gHn332GU8//TTPPfcc0dHRPPvss9x6660AhITW48tvf2Ti5FcpLCykWbNmfPLJJ7Rp04bt27ezbNky3njjDbKzs4mLi+O1115j4MCB51aUp83spgtqYL4/l9Y8b38zHGYePDnI24UshmGUd42hW8vOziY4OJisrCyCgs7zXxciIhWVmw7TB8DRPRAYY45tKcw0u20KMs2BqWfj5W+2WDS+zBywHNu1bIuRw2GO4fDyOXNLUnEebPyfOfD18ofP+VLowsJC9u3bR+PGjfHx8fnzHcT9GIY5ZsgWdEHdoGf7f+x8fr/VAiQi4gr5GWZXVVS7sj8CBZnw0VAz/ATHwu3fm//SPlVhtjmeIvvw8XEVWeY4kpBG5tgK39Cz/7BYrea9cc7G2x8uvftCv53ImVksJ8cUuZACkIhIdTv8C8wcaQ4MDbsIOtwECaPMfxF/cgOkbDHH+dw89/TwAyfHsJwYayIi500BSESkOu36EWbfal7xA2ZLz8KJsOg5M+xkHjDH99w8B+pf5MpKReo0PQtMRKS6bJhhtvCU5JlXXE3YDtdMNcfoGHYz/Hj6wujPzEHLIlJl1AIkIlLZUreZj4bw8DYHD3t4Q9JaWPlvc33CjTD4X+ZVV5fcbE7pu2D712YwatjJpeWLuAMFIBGRyrTlc5hzt3m34fL0egyueOL0QcrhzSH84aqvT0QABSARkcqz9j347hHAgJhLzJvilRaZ998B8/ERCSNdWqKImFw6Bmjy5Ml07tyZwMBAIiIiGDJkCDt37iyzTWFhIePGjSMsLIyAgACGDx9OamrqGY5oMgyDp59+mujoaHx9fenbty+7d++uyq8iIu7MMGDJS/Ddw4ABne+AOxbCTV/ArfNg7A/mpPAjUmO4NAAtXbqUcePGsXr1ahYsWEBJSQn9+vUjLy/Puc1DDz3EN998w+zZs1m6dCmHDx9m2LBhZz3uK6+8wptvvsk777zDmjVr8Pf3p3///hQWFlb1VxKRuqikwHxu1o5vzXE8y1+Ddf9ndnftXmAGnyWTzW17PQZXvVr+4wBEpMaoUXeCTk9PJyIigqVLl3L55ZeTlZVFeHg4M2fOZMSIEQDs2LGDVq1asWrVKi699NLTjmEYBjExMfztb3/j4YfN/vSsrCwiIyOZMWMGN9xww5/WoTtBiwgAW78wL1E/8UiIPzPwFej61yotqaZz5ztBX3HFFbRv35433ngDgPj4eMaPH8/48ePPuI/FYmHOnDkMGTKkQp9dWcepDSrrTtA16jL4rKwsAOrVMx+at2HDBkpKSujbt69zm5YtW9KoUSNWrVpV7jH27dtHSkpKmX2Cg4Pp2rXrGfcpKioiOzu7zCQibm7Xj/DFnSfDjy0IottDm2HQ/iZoNdh8zER0gnk35xHvu334qa0GDx7MgAEDyl23fPlyLBYLmzdvPu/jrlu3jrvuuqui5ZUxceJE2rdvf9ry5OTkc3+O1wWaMWMGISEhVfoZ1anGDIJ2OByMHz+eHj16cPHFFwOQkpKCt7f3aSc8MjKSlJRyHvh3fJ8T25zrPpMnT2bSpEkV/AYiUmckbYDZY8x787S7Afq/aA5ovoDnFknNN3bsWIYPH05SUhING5a98/b06dPp1KkT7dq1O+/jhoeHV1aJfyoqKqraPquuqDEtQOPGjWPr1q3MmjWr2j/7iSeeICsryzkdPHiw2msQkRri6F6YeR2U5EPTPnDtVPO5WQo/ddbVV19NeHg4M2bMKLM8NzeX2bNnM3bsWI4ePcqoUaNo0KABfn5+tG3blk8++eSsx42Pj3d2hwHs3r2byy+/HB8fH1q3bs2CBQtO2+exxx6jefPm+Pn50aRJE5566ilKSsyrCGfMmMGkSZP49ddfsVgsWCwWZ80Wi4W5c+c6j7Nlyxb+8pe/4OvrS1hYGHfddRe5ubnO9bfeeitDhgzh1VdfJTo6mrCwMMaNG+f8rAuRmJjItddeS0BAAEFBQVx//fVlLlr69ddf6d27N4GBgQQFBdGxY0fWr18PwIEDBxg8eDChoaH4+/vTpk0bvvvuuwuu5VzUiBag++67j3nz5rFs2bIy6TsqKori4mIyMzPLtAKlpqaeMe2eWJ6amkp0dHSZfcprNgSw2WzYbOf2pGMRqUMMo2ywyU2Dj4aZT0CPbg/XfwgeXi4rr04wDDNMuoKX3zkFV09PT2655RZmzJjBk08+ieX4PrNnz8ZutzNq1Chyc3Pp2LEjjz32GEFBQXz77bfcfPPNNG3alC5duvzpZzgcDoYNG0ZkZCRr1qwhKyur3LFBgYGBzJgxg5iYGLZs2cKdd95JYGAgjz76KCNHjmTr1q18//33LFy4EDCHePxRXl4e/fv3p1u3bqxbt460tDTuuOMO7rvvvjIhb/HixURHR7N48WL27NnDyJEjad++PXfeeeeffp/yvt+J8LN06VJKS0sZN24cI0eOZMmSJQCMHj2aDh06MG3aNDw8PNi0aRNeXuafr3HjxlFcXMyyZcvw9/dn27ZtBAQEnHcd58OlAcgwDO6//37mzJnDkiVLaNy4cZn1HTt2xMvLi0WLFjF8+HAAdu7cSWJiIt26dSv3mI0bNyYqKopFixY5A092djZr1qzhnnvuqdLvIyK1ROo2WPA07P0JvHzBFmhOhdmQmwKhjWH0bLBV7V/AbqEkH16Mcc1n//2w+VT7c3D77bczZcoUli5dyhVXXAGY3V/Dhw8nODiY4OBg54U1APfffz8//PADn3322TkFoIULF7Jjxw5++OEHYmLM8/Hiiy+eNm7nH//4h3M+Pj6ehx9+mFmzZvHoo4/i6+tLQEAAnp6eZ+3ymjlzJoWFhXz44Yf4+5vff+rUqQwePJiXX37ZOUQkNDSUqVOn4uHhQcuWLRk0aBCLFi26oAC0aNEitmzZwr59+4iNjQXgww8/pE2bNqxbt47OnTuTmJjII488QsuWLQFo1qyZc//ExESGDx9O27bmI2CaNGly3jWcL5d2gY0bN46PPvqImTNnEhgYSEpKCikpKRQUFABmsh07diwTJkxg8eLFbNiwgdtuu41u3bqVuQKsZcuWzJkzBzCbAcePH8/zzz/P119/zZYtW7jllluIiYlxi9HxInIWOanw9QPwTg/Ys8Ac41OcCznJcGSXGX786pv37wmIcHW1Uo1atmxJ9+7def/99wHYs2cPy5cvZ+zYsQDY7Xaee+452rZtS7169QgICOCHH34gMfHcrhDcvn07sbGxzvADlPsP+U8//ZQePXoQFRVFQEAA//jHP875M079rISEBGf4AejRowcOh6PMvfbatGmDh8fJ2zVER0eTlpZ2Xp916mfGxsY6ww9A69atCQkJYfv27QBMmDCBO+64g759+/LSSy+xd+9e57YPPPAAzz//PD169OCZZ565oEHn58ulLUDTpk0DcKbtE6ZPn86tt94KwD//+U+sVivDhw+nqKiI/v378/bbb5fZfufOnc4ryAAeffRR8vLyuOuuu8jMzKRnz558//33bndJpojbMgw4stvsyio4BgUZ5lPX175nBh6AVtfAFY+bLUBFOVCUa66L7QK+oa6tvy7x8jNbYlz12edh7Nix3H///bz11ltMnz6dpk2b0qtXLwCmTJnCv/71L9544w3atm2Lv78/48ePp7i4uNLKXbVqFaNHj2bSpEn079+f4OBgZs2axWuvvVZpn3GqE91PJ1gsFhwOR5V8FphXsN144418++23zJ8/n2eeeYZZs2YxdOhQ7rjjDvr378+3337Ljz/+yOTJk3nttde4//77q6wel3eB/RkfHx/eeust3nrrrXM+jsVi4dlnn+XZZ5+tcI0iUss47DDzetizsPz1DTpCvxcgrvxudKlkFss5d0O52vXXX8+DDz7IzJkz+fDDD7nnnnuc44F+/vlnrr32Wm666SbAHPOya9cuWrdufU7HbtWqFQcPHiQ5Odk5PnX16tVltlm5ciVxcXE8+eSTzmUHDhwos423tzd2u/1PP2vGjBnk5eU5W4F+/vlnrFYrLVq0OKd6z9eJ73fw4EFnK9C2bdvIzMwsc46aN29O8+bNeeihhxg1ahTTp09n6NChAMTGxnL33Xdz991388QTT/Dee+/V3QAkIlLpVr1lhh+rFwQ3NFtz/OqBbz1oMQBaDwVrjbkAVmqQgIAARo4cyRNPPEF2drazJwLM8Sqff/45K1euJDQ0lNdff53U1NRzDkB9+/alefPmjBkzhilTppCdnV0m6Jz4jMTERGbNmkXnzp359ttvncM7ToiPj2ffvn1s2rSJhg0bEhgYeNpFPKNHj+aZZ55hzJgxTJw4kfT0dO6//35uvvnm024Rc77sdjubNm0qs8xms9G3b1/atm3L6NGjeeONNygtLeXee++lV69edOrUiYKCAh555BFGjBhB48aNSUpKYt26dc7xvePHj2fgwIE0b96cY8eOsXjxYlq1alWhWv+M/hYQkbojfSf89Lw5f/U/4cFNcNdic0zP8Pfg4uEKP3JWY8eO5dixY/Tv37/MeJ1//OMfXHLJJfTv358rrriCqKio8xpXarVamTNnDgUFBXTp0oU77riDF154ocw211xzDQ899BD33Xcf7du3Z+XKlTz11FNlthk+fDgDBgygd+/ehIeHl3spvp+fHz/88AMZGRl07tyZESNG0KdPH6ZOnXp+J6Mcubm5dOjQocw0ePBgLBYLX331FaGhoVx++eX07duXJk2a8OmnnwLg4eHB0aNHueWWW2jevDnXX389AwcOdN6Dz263M27cOFq1asWAAQNo3rz5acNdKluNehRGTaFHYYjUQvZSeL8fHNoAF11pXsWle/dUO3d+FIZUjzr5KAwRkQu26t9m+LEFw+B/KfyIyFkpAIlIzbVnIbzW0nzq+tmkbYfFL5rzAyZDcIOqr01EajUFIBGpmRx2mP+4eY+eb8ZD5hkeUWMvgTl3g70YmvWH9jdWa5kiUjspAIlIzbT1Czi625wvzoF54837+/zRgqcheRP4qOtLRM6dApCI1Dz2Ulj6sjnf/ibwsJndYb/+4YqXte/B6uNXigx+E4KikZpB19dIVams/7cUgESk5tn6uXnnZt96MPAl6P2Eufz7xyEnxZzf9SPMf9Sc/8tT0GaIS0qVsk48WqEy75Ascqr8fPPhun+8k/X50o0QRaRmsZfC0lfM+e73mw8p7XY//DbX7Or69m/mIyw+vw0Mh9lCdNnfXFmxnMLT0xM/Pz/S09Px8vLCqvsuSSUxDIP8/HzS0tIICQkp8xyzC6EAJCI1y5bZkLEX/MKgy13mMg9PuPYteLcX7JgH+5abz+2Kv8y84aHG/dQYFouF6Oho9u3bd9pjHEQqQ0hICFFRURU+jgKQiNQc9lJYdqL15wGwBZxcF3UxXPYwLH0JirKgfnMY+T/w9HZNrXJG3t7eNGvWTN1gUum8vLwq3PJzggKQiNQcWz6DjN/N1p/Od5y+/rK/QeIqyD4EN36mp7bXYFarVXeClhpNAUhEaoai3JNXfvV4sGzrzwme3nDLV+bl8BpbIiIVoAAkIq7ncMCcv8Kx/RAQVX7rzwkWi8b8iEiF6Z9QIuJ6i583Bzd72GDkR+Dt7+qKRKSOUwASEdfa/Bksf82cv+bfENvZtfWIiFtQABIR10laD1/dZ873fAgSRrq2HhFxGwpAIuIaWUnwySiwF0GLQfCXp11dkYi4EQUgEal+KVvhv/0hLw0iL4Zh7+qqLhGpVroKTESq1+6FMPtW8wnvYRfBqFnlX/IuIlKFFIBEpPqs+z/47hHzGV7xl8H1H4JfPVdXJSJuSAFIRCrfoY2w6WMz6Fg9zSknBX770lzffjRc/YYeYyEiLqMAJCKV6+Ba+PBaKMkvf/1fnjIfaaGbGYqICykAiUjlSf0NPr7ODD9xPaBxL3CUnpya9oamf3F1lSIiCkAiUkkyfof/DYXCTGjYBUbP1h2dRaTG0nWnIlJx2cnw4RDITYWINjD6M4UfEanRFIBEpGIOroP/DYHMAxDaGG6eA76hrq5KROSs1AUmIhdm/wpY+grsW2q+D4yGW+ZCYKRLyxIRORcKQCJyfg7/Aj88CQd+Nt9bPSFhFPR6DEJiXVubiMg5cmkX2LJlyxg8eDAxMTFYLBbmzp1bZr3FYil3mjJlyhmPOXHixNO2b9myZRV/ExE3kZNqDnQ+8DN4eEOn2+GBX+DaqQo/IlKruLQFKC8vj4SEBG6//XaGDRt22vrk5OQy7+fPn8/YsWMZPnz4WY/bpk0bFi5c6Hzv6amGLpEKMwz45kEoOAZRbWHUpxDcwNVViYhcEJcmg4EDBzJw4MAzro+Kiirz/quvvqJ37940adLkrMf19PQ8bV8RqaBfZ8Gu+WD1gqHvKvyISK1Wa64CS01N5dtvv2Xs2LF/uu3u3buJiYmhSZMmjB49msTExGqoUKQOyzoE8x8z53s/AZGtXVuPiEgF1Zq+oQ8++IDAwMByu8pO1bVrV2bMmEGLFi1ITk5m0qRJXHbZZWzdupXAwMBy9ykqKqKoqMj5Pjs7u1JrF6nVDAO+eQCKsqBBR+j+oKsrEhGpsFoTgN5//31Gjx6Nj4/PWbc7tUutXbt2dO3albi4OD777LMzth5NnjyZSZMmVWq9InXGxg9hz0LwsMGQaeBRa/7aEBE5o1rRBbZ8+XJ27tzJHXfccd77hoSE0Lx5c/bs2XPGbZ544gmysrKc08GDBytSrkjdceyAeck7QJ+nILyFa+sREakktSIA/fe//6Vjx44kJCSc9765ubns3buX6OjoM25js9kICgoqM4m4vdJi+Pw2KM6B2K5w6b2urkhEpNK4NADl5uayadMmNm3aBMC+ffvYtGlTmUHL2dnZzJ49+4ytP3369GHq1KnO9w8//DBLly5l//79rFy5kqFDh+Lh4cGoUaOq9LuI1DkLnoJDG8AnBIa9B1YPV1ckIlJpXNqZv379enr37u18P2HCBADGjBnDjBkzAJg1axaGYZwxwOzdu5cjR4443yclJTFq1CiOHj1KeHg4PXv2ZPXq1YSHh1fdFxGpa36bC2veMeeH/gdC41xajohIZbMYhmG4uoiaJjs7m+DgYLKystQdJu7n6F74Ty+z66vHg3Dls66uSETknJzP73etGAMkItWkpAA+G2OGn0bd4C9PuboiEZEqoQAkIqaCYzD3HkjdAn71YcT74OHl6qpERKqEbugh4u7sJbD+fVgy2QxBWGD4exAU4+rKRESqjAKQiDvb9SP8+CQc2WW+D28FAyZD095n309EpJZTABJxV5tmml1eAH5h0PtJuGSM7vQsIm5Bf9OJuCPDgJ//Zc63vwkGvAg+wa6tSUSkGmkQtIg7SlwF6TvAy0/hR0TckgKQiDtaP918vXi4wo+IuCUFIBF3k58B274y5zvd5tpaRERcRAFIxN1smgn2IohqBzGXuLoaERGXUAAScSeGARtmmPOdbgOLxaXliIi4igKQiDvZvwKO7gbvAGh7naurERFxGQUgEXey/n3zte11YAt0bS0iIi6kACTiLnLTYfs35rwGP4uIm1MAEnEXmz4GR4k58Dk6wdXViIi4lAKQiDs4/Ausfc+cV+uPiIgehSFSpx3bDz89D1tmm+8DosybH4qIuDkFIJG6qCgXFr8I694De7G5rN1I+MtT4O3v2tpERGoABSCRuuj7x+CXj8z5JlfAlc9q3I+IyCkUgETqmtw02PyZOX/dB9BmiEvLERGpiTQIWqSu2TDD7PZq0EnhR0TkDBSAROoSewms+6853/Vu19YiIlKDKQCJ1CXbvoLcFAiIhNbXuroaEZEaSwFIpC5Z8x/ztdPt4Ont2lpERGowBSCRuuLQRkhaC1Yv6KibHYqInI0CkEhdsfZd8/XiYRAY6dpaRERqOAUgkbogNx22fmHOd/mra2sREakFFIBE6oJTL31v2NHV1YiI1HgKQCK1XcY+WPd/5rwufRcROSe6E7RIbVWUA8tfg1Vvma0/QQ106buIyDlSABKpbRwO+HUmLHoWclPNZU2ugKte1aXvIiLnyKVdYMuWLWPw4MHExMRgsViYO3dumfW33norFoulzDRgwIA/Pe5bb71FfHw8Pj4+dO3albVr11bRNxCpZiWFMGsUfDXODD/1msCoWXDzXKjfzNXViYjUGi4NQHl5eSQkJPDWW2+dcZsBAwaQnJzsnD755JOzHvPTTz9lwoQJPPPMM2zcuJGEhAT69+9PWlpaZZcvUr1KCuDT0bDre/D0gSufg3vXQIuBYLG4ujoRkVrFpV1gAwcOZODAgWfdxmazERUVdc7HfP3117nzzju57TbzRnDvvPMO3377Le+//z6PP/54heoVcZnifJh1I/y+GLz84MZPofHlrq5KRKTWqvFXgS1ZsoSIiAhatGjBPffcw9GjR8+4bXFxMRs2bKBv377OZVarlb59+7Jq1aoz7ldUVER2dnaZSaTGKM6DmdcfDz/+MPpzhR8RkQqq0QFowIABfPjhhyxatIiXX36ZpUuXMnDgQOx2e7nbHzlyBLvdTmRk2bvgRkZGkpKScsbPmTx5MsHBwc4pNja2Ur+HyAUrKYSPr4f9y8E7AG7+EuJ7uLoqEZFar0ZfBXbDDTc459u2bUu7du1o2rQpS5YsoU+fPpX2OU888QQTJkxwvs/OzlYIkpph3XtwYAXYguCmLyC2i6srEhGpE2p0C9AfNWnShPr167Nnz55y19evXx8PDw9SU1PLLE9NTT3rOCKbzUZQUFCZScTlinJhxT/N+f4vKvyIiFSiWhWAkpKSOHr0KNHR0eWu9/b2pmPHjixatMi5zOFwsGjRIrp161ZdZYpUjrX/gfyj5qXuCaNcXY2ISJ3i0gCUm5vLpk2b2LRpEwD79u1j06ZNJCYmkpubyyOPPMLq1avZv38/ixYt4tprr+Wiiy6if//+zmP06dOHqVOnOt9PmDCB9957jw8++IDt27dzzz33kJeX57wqTKRWKMyGn98053s9Dh41urdaRKTWcenfquvXr6d3797O9yfG4YwZM4Zp06axefNmPvjgAzIzM4mJiaFfv34899xz2Gw25z579+7lyJEjzvcjR44kPT2dp59+mpSUFNq3b8/3339/2sBokRpt9TQozIT6zaHtCFdXIyJS51gMwzBcXURNk52dTXBwMFlZWRoPJNWv4Bi8kQBFWTDifbh4uKsrEhGpFc7n97tWjQEScQur3jLDT0RraD3U1dWIiNRJCkAiNUneUbP7C+CKJ8CqP6IiIlVBf7uK1CQrXofiXIhqB60Gu7oaEZE6SwFIpKbY8AGsOn5FY+8n9YBTEZEqpAAkUhNs+Ry+edCc73YfNO9/9u1FRKRCFIBEXG3Ht/DlXYABnW6Hfs+r9UdEpIopAIm40p5FMPtWMOzQ7ga46jWFHxGRaqAAJOIqqdtg1miwF0Ora+Dat3TVl4hINdHftiKusvotKC2AxpfD8P/qcRciItVIAUjEFQqzYeuX5nzvJ8HT27X1iIi4GQUgEVfY+jmU5EP9FhDb1dXViIi4HQUgEVfY+KH5esktGvQsIuICCkAi1S15Mxz+BaxekHCDq6sREXFLCkAi1W3jB+Zrq6vBv75raxERcVMKQCLVqTgfNs825y8Z49paRETcmAKQSHXa9hUUZUFIHDTu5epqRETclgKQSHU60f11yc266aGIiAvpb2CR6pK+CxJXgcUK7Ue7uhoREbemACRSXU60/jTrD0Exrq1FRMTNKQCJVIdtX8O6/5rzHTX4WUTE1RSARKqSYcCKf8JnN5vP/WrWH5r1c3VVIiJuT09fFKkqpcUw7yHY9JH5vstd0H8yWD1cW5eIiCgAiVSJwiz45EY4sMIc9DzgJej6V1dXJSIixykAiVSFJS+b4cc7EK6bDs2udHVFIiJyCo0BEqlsxXnwy/Fur+HvKfyIiNRACkAilW3rFyfv9tysv6urERGRcigAiVQmw4C175nzncfqbs8iIjWU/nYWqUxJ6yFlM3jYoMPNrq5GRETOQAFIpDKt+z/z9eLh4FfPtbWIiMgZKQCJVJa8o/Dbl+Z85ztcW4uIiJyVApBIZfnlf2Avhuj20OASV1cjIiJn4dIAtGzZMgYPHkxMTAwWi4W5c+c615WUlPDYY4/Rtm1b/P39iYmJ4ZZbbuHw4cNnPebEiROxWCxlppYtW1bxNxG357DD+vfN+c53gMXi2npEROSsXBqA8vLySEhI4K233jptXX5+Phs3buSpp55i48aNfPnll+zcuZNrrrnmT4/bpk0bkpOTndOKFSuqonyRk/YshMwD4BNsjv8REZEazaV3gh44cCADBw4sd11wcDALFiwos2zq1Kl06dKFxMREGjVqdMbjenp6EhUVVam1ipzVicHP7W8Cbz/X1iIiIn+qVo0BysrKwmKxEBISctbtdu/eTUxMDE2aNGH06NEkJiaedfuioiKys7PLTCLn7OBa2P2jOd95rGtrERGRc1JrAlBhYSGPPfYYo0aNIigo6Izbde3alRkzZvD9998zbdo09u3bx2WXXUZOTs4Z95k8eTLBwcHOKTY2tiq+gtRF9hL4Zrw5n3AjhDV1aTkiInJuLIZhGK4uAsBisTBnzhyGDBly2rqSkhKGDx9OUlISS5YsOWsA+qPMzEzi4uJ4/fXXGTu2/H+dFxUVUVRU5HyfnZ1NbGwsWVlZ5/VZ4oZ+/hcseBp868F968E/zNUViYi4rezsbIKDg8/p97vGPw2+pKSE66+/ngMHDvDTTz+ddyAJCQmhefPm7Nmz54zb2Gw2bDZbRUsVd5OZCEteMuf7PafwIyJSi9ToLrAT4Wf37t0sXLiQsLDz/4HJzc1l7969REdHV0GF4rYMA757BEryIa4HtB/t6opEROQ8uDQA5ebmsmnTJjZt2gTAvn372LRpE4mJiZSUlDBixAjWr1/Pxx9/jN1uJyUlhZSUFIqLi53H6NOnD1OnTnW+f/jhh1m6dCn79+9n5cqVDB06FA8PD0aNGlXdX0/qsu3fwK7vweoFV/9T9/0REallXNoFtn79enr37u18P2HCBADGjBnDxIkT+frrrwFo3759mf0WL17MFVdcAcDevXs5cuSIc11SUhKjRo3i6NGjhIeH07NnT1avXk14eHjVfhlxH0U5MP8xc77HgxDewrX1iIjIeasxg6BrkvMZRCVuaMEz8PMbENoY7l0FXr6urkhERDi/3+8aPQZIpMYpzIJ1/zXn+7+g8CMiUkspAImcjw0fQHEO1G8Bzcu/i7mIiNR8CkAi56q0GFZPM+e73w9W/fEREamt9De4yLna+gXkHIaAKGh3vaurERGRClAAEjkXhgEr/23Od/0reOrGmSIitdkFBaCDBw+SlJTkfL927VrGjx/Pu+++W2mFidQoexZB2m/gHQCdbnd1NSIiUkEXFIBuvPFGFi9eDEBKSgpXXnkla9eu5cknn+TZZ5+t1AJFaoSV/zJfLxkDviEuLUVERCruggLQ1q1b6dKlCwCfffYZF198MStXruTjjz9mxowZlVmfiOsd3gT7loHFAy69x9XViIhIJbigAFRSUuJ8eOjChQu55pprAGjZsiXJycmVV51ITXBi7M/FwyAk1rW1iIhIpbigANSmTRveeecdli9fzoIFCxgwYAAAhw8fvqAHlorUSEf3wpy7zau/ALo/4Np6RESk0lzQs8Befvllhg4dypQpUxgzZgwJCQkAfP31186uMZFaK+N3WDoFNn8Kht1c1vlOiG7n2rpERKTSXPCzwOx2O9nZ2YSGhjqX7d+/Hz8/PyIiIiqtQFfQs8Dc2Jr/wPdPnAw+zfrDFY9Bg46urUtERP7U+fx+X1ALUEFBAYZhOMPPgQMHmDNnDq1ataJ///4XckgR10vfCT88aYafi/rCFX+Hhgo+IiJ10QWNAbr22mv58MMPAcjMzKRr16689tprDBkyhGnTplVqgSLVwuGAb8aDo8Rs9Rn9ucKPiEgddkEBaOPGjVx22WUAfP7550RGRnLgwAE+/PBD3nzzzUotUKRa/PI/SFwJXn4w6FWwWFxdkYiIVKELCkD5+fkEBgYC8OOPPzJs2DCsViuXXnopBw4cqNQCRapcbhoseMqc7/0khDRybT0iIlLlLigAXXTRRcydO5eDBw/yww8/0K9fPwDS0tI0aFhqn++fgMIsiE6Arne7uhoREakGFxSAnn76aR5++GHi4+Pp0qUL3bp1A8zWoA4dOlRqgSJVavdC2Po5WKww+F/gcUHXBYiISC1zQX/bjxgxgp49e5KcnOy8BxBAnz59GDp0aKUVJ1KlCrPh2wnmfNe7IUbhXUTEXVzwP3ejoqKIiopyPhW+YcOGugmi1B55R+GjYZB5AIIammN/RETEbVxQF5jD4eDZZ58lODiYuLg44uLiCAkJ4bnnnsPhcFR2jSKVKzsZZlwFyZvALwxGzQRbgKurEhGRanRBLUBPPvkk//3vf3nppZfo0aMHACtWrGDixIkUFhbywgsvVGqRIpXm2H748FrzNTAGbvkKwpu7uioREalmF/QojJiYGN555x3nU+BP+Oqrr7j33ns5dOhQpRXoCnoURh2VvssMPzmHITQebvkaQuNcXZWIiFSSKn8URkZGBi1btjxtecuWLcnIyLiQQ4pULYcDPrvZDD/hLeHmuRAU7eqqRETERS5oDFBCQgJTp049bfnUqVNp105PzJYaaMc3kL4DfILh1m8VfkRE3NwFtQC98sorDBo0iIULFzrvAbRq1SoOHjzId999V6kFilSYYcDy1835Ln8F//qurUdERFzuglqAevXqxa5duxg6dCiZmZlkZmYybNgwfvvtN/73v/9Vdo0iFbP3J/OKLy8/3elZRESACxwEfSa//vorl1xyCXa7vbIO6RIaBF3HTB8EB1bApffCgMmurkZERKrI+fx+X1ALkEitkbjGDD9WL+h2n6urERGRGkIBSOq2FcfH/iTcAMENXFuLiIjUGApAUnelbIFd35sPOu35kKurERGRGuS8rgIbNmzYWddnZmae14cvW7aMKVOmsGHDBpKTk5kzZw5DhgxxrjcMg2eeeYb33nuPzMxMevTowbRp02jWrNlZj/vWW28xZcoUUlJSSEhI4N///reeU+aOVvzTfG09BMKaurQUERGpWc6rBSg4OPisU1xcHLfccss5Hy8vL4+EhATeeuutcte/8sorvPnmm7zzzjusWbMGf39/+vfvT2Fh4RmP+emnnzJhwgSeeeYZNm7cSEJCAv379yctLe18vqrURvZSSN0Gmz6B+Y/Bb3PM5ZdNcG1dIiJS41TqVWAVYbFYyrQAGYZBTEwMf/vb33j44YcByMrKIjIykhkzZnDDDTeUe5yuXbvSuXNn540aHQ4HsbGx3H///Tz++OPnVIuuAquFFj0Hq96C0oKyy1sNhpEfuaYmERGpVnXiKrB9+/aRkpJC3759ncuCg4Pp2rUrq1atKnef4uJiNmzYUGYfq9VK3759z7gPQFFREdnZ2WUmqUWSNsDyV83w4x0AjbpD13tg6Lsw/H1XVyciIjXQBd0JujqkpKQAEBkZWWZ5ZGSkc90fHTlyBLvdXu4+O3bsOONnTZ48mUmTJlWwYnGZ5a+ar+1GwpB3wFpjc72IiNQQ+qUAnnjiCbKyspzTwYMHXV2SnKuULbDzO8AClz+i8CMiIuekxv5aREVFAZCamlpmeWpqqnPdH9WvXx8PD4/z2gfAZrMRFBRUZpJaYvlr5uvFw6D+2a8OFBEROaHGBqDGjRsTFRXFokWLnMuys7NZs2aN8wGsf+Tt7U3Hjh3L7ONwOFi0aNEZ95FaLH0X/DbXnL/sby4tRUREaheXjgHKzc1lz549zvf79u1j06ZN1KtXj0aNGjF+/Hief/55mjVrRuPGjXnqqaeIiYkpc6+gPn36MHToUO67z3zMwYQJExgzZgydOnWiS5cuvPHGG+Tl5XHbbbdV99eTqrbidcCAlldDZBtXVyMiIrWISwPQ+vXr6d27t/P9hAnm/VrGjBnDjBkzePTRR8nLy+Ouu+4iMzOTnj178v333+Pj4+PcZ+/evRw5csT5fuTIkaSnp/P000+TkpJC+/bt+f77708bGC21XMY+2PyZOa/WHxEROU815j5ANYnuA1QLfP0AbPwALuoLN33h6mpERKQGqBP3ARI5o6wk2DTTnL/8EdfWIiIitZICkNQuhmE+5sJRAvGXQaNLXV2RiIjUQgpAUrusfx92zAOrF/R/wdXViIhILaUAJLVH6jb44e/m/JWTIDrBtfWIiEitpQAktUNJAXx+O5QWwkVXms/6EhERuUAKQFI7/PgPSN8O/hEwZJoeeSEiIhVSYx+GKm4qJxV++xIsHuATDL4hkJkI6/7PXD/0HQgId2mJIiJS+ykASc2Rvgv+NxSyk8pf3/1+uKhP9dYkIiJ1kgKQ1AyHNsBHI6AgA0IbmwOcCzOhINN8jbwY/vK0i4sUEZG6QgFIXG/vYpg1GkryIOYSGP05+Ie5uioREanDFIDEtbZ+CXP+CvZiaNwLbvgYbIGurkpEROo4BSCpfoYBexaZT3M/8LO5rPW1MOw98LS5tjYREXELCkBSfRx22P41LH8dUjaby6xecOnd0HcSWD1cW5+IiLgNBSCpHg4HfH4bbPvKfO/lB51uh27jICjGtbWJiIjbUQCS6rFoohl+PLyh5wTo+lfwq+fqqkRExE0pAEnV2/gh/Pwvc/7at6Hdda6tR0RE3J6eJyBVa98ymPeQOd/rcYUfERGpERSApOoc2QOf3gyOUrh4BFzxuKsrEhERAdQFJpWttMi8q/OBn2HDh+ZdnBt2gWvfAovF1dWJiIgACkBSGfKOwObPYOd3kLQOSgtPrgtpBDfMBC8f19UnIiLyBwpAcmEcdtj7kznAeed8cJScXOcfDnHdIf4yaDNMj7UQEZEaRwFIzt++5TD3Hsg6eHJZTAdIGAVNroD6zdXdJSIiNZoCkJyf9dPhu4fNgc2+odBuJHS4CaLauroyERGRc6YAJOfGXgo//gPWTDPfXzwcrpkK3n6urUtEROQCKADJnyvMgtm3wd5F5vve/4DLH1Y3l4iI1FoKQHJ2xw7AzOshfQd4+sKw/5hPbhcREanFFIDkzA5thJkjIS8NAmNg1CcQ097VVYmIiFSYApA7czhg2SuQm2a26sT3BKuHuW7nfPj8dijJh8iL4cbPILiBa+sVERGpJApA7sowYP6jsO498/36/0JAJLQZCn5hsGQyGA5o2geumwE+QS4tV0REpDIpALmrn54/Hn4s0Poa+H0p5KbCmndObnPJLTDodfDwclmZIiIiVaHGPww1Pj4ei8Vy2jRu3Lhyt58xY8Zp2/r46DEMZfz8L1j+qjk/6DW4/kN4eDeM+hTaXmeO9+k7EQa/qfAjIiJ1Uo1vAVq3bh12u935fuvWrVx55ZVcd911Z9wnKCiInTt3Ot9bdLn2SRtmwIKnzfm+E6HzWHPe0xtaDDAnERGROq7GB6Dw8PAy71966SWaNm1Kr169zriPxWIhKiqqqkurXdJ2wIbpsOY/5vueE6DnQ66tSURExEVqfAA6VXFxMR999BETJkw4a6tObm4ucXFxOBwOLrnkEl588UXatGlTjZXWAA4HFOfAjm9hwwdwcPXJdZ3vgD5Pu642ERERF6tVAWju3LlkZmZy6623nnGbFi1a8P7779OuXTuysrJ49dVX6d69O7/99hsNGzYsd5+ioiKKioqc77Ozsyu79Kq38UNY/hoUZkNJAZQWlF1v8YDmA6DjrdDsSt3FWURE3JrFMAzD1UWcq/79++Pt7c0333xzzvuUlJTQqlUrRo0axXPPPVfuNhMnTmTSpEmnLc/KyiIoqBZc/r3ta/jsFqCc/5QhcebVXO1HQ1B0tZcmIiJSXbKzswkODj6n3+9a0wJ04MABFi5cyJdffnle+3l5edGhQwf27Nlzxm2eeOIJJkyY4HyfnZ1NbGzsBddarQ5tgC/vAgzodDt0+St4+ZqTpw/YAtXaIyIi8ge1JgBNnz6diIgIBg0adF772e12tmzZwlVXXXXGbWw2GzabraIlVr/MRJh5g9nd1awfDJwCHrXmP6mIiIjL1Pj7AAE4HA6mT5/OmDFj8PQs+wN/yy238MQTTzjfP/vss/z444/8/vvvbNy4kZtuuokDBw5wxx13VHfZVasw6+RzuiLbwoj3FX5ERETOUa34xVy4cCGJiYncfvvtp61LTEzEaj2Z444dO8add95JSkoKoaGhdOzYkZUrV9K6devqLLnq5GdA0jpY+W9I2wYBUXDjp2ZXl4iIiJyTWjUIurqczyCqKmcYsPtH2PYVHFwLR3efXOflB7fN1xPaRUREqKODoN2OwwE75sGyKZCyuey6sGYQ2wU6jVX4ERERuQAKQNXI7jD4fMNBereMICLwDM8nKy0yL2tf/hqkbzeXeflDxzHQpDc07AR+9aqvaBERkTpIAagaPfHlZj5bn8R1HRsy5bqEkyscDkhcCZs/g21zzQHOALYg6PpXuPRehR4REZFKpABUjW7o0ojP1icxe0MStyb406b0N9j/s/m4iuykkxsGxkCn26DLXeAb4rJ6RURE6ioFoGp0SelmPon6hPCMDVw083DZlbYgaH0ttLse4nqA1cM1RYqIiLgBBaDqlLiabpnfOO++lBXUnOCWV0Djy+GiK8HrDOOCREREpFIpAFWn5v2gOIdvs5rw9w3++HiH8VOfK/C36T+DiIhIdaoVd4KuM2I6QL/n6TNkDMH1IkjNLuLtJWd+RpmIiIhUDQUgF/Dx8uDJQa0AeG/5PhKP5ru4IhEREfeiAOQi/VpH0vOi+hSXOpj4zW/kFZW6uiQRERG3oQDkIhaLhacHt8bDauGnHWl0fH4B4z7eyPdbkykssbu6PBERkTpNzwIrR3U+C2zuL4d4Y+Eu9p/SDRZg82RQ22hGdomlQ2wIFoulSmsQERGpC87n91sBqBzV/TBUwzDYeiibbzYfZt6vhzmcVehc1yIykJGdYxnaoQGh/t5VXouIiEhtpQBUQa58GrzDYbBufwafrjvIt1uSKSp1AODtaWVQ22huujSOSxqpVUhEROSPFIAqyJUB6FRZBSV8vekQn6w9yLbkbOfyVtFB3HRpI65t34AA3UNIREQEUACqsJoSgE4wDINfk7L4aPUBvvn1sLNVyOZppXeLCAa1i6ZPqwj8vBWGRETEfSkAVVBNC0Cnyswv5vMNScxcm8jv6XnO5T5eVv7SMoLeLSLo1TyciCA9VkNERNyLAlAF1eQAdIJhGGxLzubbzcnM25xMYkbZmym2ig6iV/NwLm9Wn0viQvHx0sNVRUSkblMAqqDaEIBOdeIqsh9+S2HZ7nQ2J2WVWW/ztNKlcT16XFSfnhfVp3V0EFarBlGLiEjdogBUQbUtAP3RkdwiVuw+wtJd6azYc4T0nKIy6+v5e9Pzovpc1qw+lzULJypY3WUiIlL7KQBVUG0PQKcyDIPdabms2H2ElXuPsGrvUfKKy95pukVkIL1ahHNF83A6xdfD21M3CBcRkdpHAaiC6lIA+qMSu4NfEjNZvjudZbuPsDkpk1P/D/Dz9qB70/r0bxNJvzZRBPt6ua5YERGR86AAVEF1OQD90bG8YpbvOcKSnWks25XOkdxi5zpvDyuXN6/P1e1i6NMqgkAfhSEREam5FIAqyJ0C0KkcDvPKsoXbU/l2czK703Kd62yeVvq1iWJYhwZc1qw+nh7qJhMRkZpFAaiC3DUA/dGu1Bzm/XqYeZuT+f3IyXsO1Q/w5pqEBozo2JDWMe57fkREpGZRAKogBaCyDMNgy6Esvtx4iK9/PUxG3slusnYNgxnZOZZrEmLURSYiIi6lAFRBCkBnVmJ3sGxXOl9sTGLBtlRK7Ob/Pr5eHlzdLpobujTSw1pFRMQlFIAqSAHo3BzNLWLOL4eYte4ge04ZL9Q8MoAbOjdi2CUNCPHzdmGFIiLiThSAKkgB6PwYhsGGA8eYte4g8zYfprDEfFirt6eVQW2juenSOLUKiYhIlVMAqiAFoAuXXVjCV5sO88maRLYlZzuXt44O4uZucVzbPkZPrRcRkSqhAFRBCkAVZxgGm5Oy+Gj1Ab7+9TBFpWarUKCPJ9d1jOXmbnE0ru/v4ipFRKQuOZ/f7xp9M5eJEydisVjKTC1btjzrPrNnz6Zly5b4+PjQtm1bvvvuu2qqVk5lsVhIiA1hynUJrPl7H/4xqBXxYX7kFJby/s/76P3qEm6dvpbFO9JwOJTBRUSketX4vog2bdqwcOFC53tPzzOXvHLlSkaNGsXkyZO5+uqrmTlzJkOGDGHjxo1cfPHF1VGulCPEz5s7LmvC7T0as2x3Oh+uOsDinWks2ZnOkp3pxIf5cVuPxozo2BB/W43/X1JEROqAGt0FNnHiRObOncumTZvOafuRI0eSl5fHvHnznMsuvfRS2rdvzzvvvHPOn6susKp34GgeH60+wKfrDpJdWApAkI8no7o04pbu8TQI8XVxhSIiUtvUmS4wgN27dxMTE0OTJk0YPXo0iYmJZ9x21apV9O3bt8yy/v37s2rVqqouU85TXJg/Tw5qzeq/9+G5a9vQuL4/2YWl/GfZ71z+ymL++r/1LN+dru4xERGpEjW6v6Fr167MmDGDFi1akJyczKRJk7jsssvYunUrgYGBp22fkpJCZGRkmWWRkZGkpKSc9XOKioooKipyvs/Ozj7L1lKZ/Lw9ublbPKO7xrF4Zxr/XbGPlXuP8sNvqfzwWyrxYX7c2LUR13WMJdRf9xQSEZHKUaMD0MCBA53z7dq1o2vXrsTFxfHZZ58xduzYSvucyZMnM2nSpEo7npw/q9VCn1aR9GkVyc6UHGauOcCXGw+x/2g+L363g1d/3MWgttHc2LURneJCdU8hERGpkBrfBXaqkJAQmjdvzp49e8pdHxUVRWpqapllqampREVFnfW4TzzxBFlZWc7p4MGDlVaznL8WUYFMuvZiVv+9D5OHtaVNTBDFpQ7m/HKI695ZRf83ljHj531kFZS4ulQREamlalUAys3NZe/evURHR5e7vlu3bixatKjMsgULFtCtW7ezHtdmsxEUFFRmEtfzt5mDoufd35OvxvVgZKdYfL082JWay8RvttH1xYU8+vmvbE7KdHWpIiJSy9Toq8AefvhhBg8eTFxcHIcPH+aZZ55h06ZNbNu2jfDwcG655RYaNGjA5MmTAfMy+F69evHSSy8xaNAgZs2axYsvvnjel8HrKrCaK7uwhLm/HOLj1YnsTM1xLm/bIJibLm3ENQkN8PX2cGGFIiLiKnXmKrCkpCRGjRpFixYtuP766wkLC2P16tWEh4cDkJiYSHJysnP77t27M3PmTN59910SEhL4/PPPmTt3ru4BVIcE+XhxS7d4vh9/GZ/f3Y0h7WPw9rCy5VAWj32xhW4vLeKl+Ts4lFng6lJFRKQGq9EtQK6iFqDaJSOvmNnrD/K/1QdIOmYGH6sF+rWO4pbucXRrEqZB0yIibkDPAqsgBaDaye4wWLQ9lRkr97Ny71Hn8qbh/tx0aRzDLmlIsK+XCysUEZGqpABUQQpAtd/OlBw+XLWfOb8cIr/YDoCvlwfXJMQwvGNDOsWFYrWqVUhEpC5RAKogBaC6I+f4oOn/rT7ArtRc5/IGIb4M6RDD0A4NuSgiwIUViohIZVEAqiAFoLrHMAzW7svg8w1JzN+aQm5RqXPdJY1CGNM9noEXR+PtWaOvCxARkbNQAKogBaC6raDYzsLtqcz95RBLd6VTevx5Y+GBNkZ3bcSNXRsREejj4ipFROR8KQBVkAKQ+0jLKWTmmkQ+XpNIeo75PDgvDwv92kRxY5dGdGsSprFCIiK1hAJQBSkAuZ/iUgfztybzwcr9bEzMdC6PC/Pjhs6NuK5TQ+oH2FxXoIiI/CkFoApSAHJvvx3OYtbag8z95RA5x8cKeXtaGX5JA8b2bKJB0yIiNZQCUAUpAAlAfnEp835N5qM1B9iclOVc3qdlBHdc1oRLm9TTDRZFRGoQBaAKUgCSUxmGwfoDx3hv2e8s2J7KiT8xsfV8GdwuhsEJMbSMClQYEhFxMQWgClIAkjPZdySP/674nS83nrzBIkCziACGdGjAiI4NiQzSFWQiIq6gAFRBCkDyZwqK7Szakco3vx5m8c50iksdAHhYLfylZQQ3dmnE5c3D8dAVZCIi1UYBqIIUgOR8ZBeW8P3WFGavP8i6/cecy2OCfRjRKZbrOjYktp6fCysUEXEPCkAVpAAkF2pPWg6frD3IlxuTOJZfAoDFAj0vqs/1nWLp1yYSm6eHi6sUEambFIAqSAFIKqqo1M4Pv6Xy2bqDrNhzxLk82NeLq9tFM+ySBlzSKFQDp0VEKpECUAUpAEllOpiRz+z1B5m9IYnkrELn8rgwP4a0b8DwSxrSKExdZCIiFaUAVEEKQFIV7A6DVXuP8uUvSXy/NaXMVWSXNqnHdR1jGdg2Cj9vTxdWKSJSeykAVZACkFS1/OJSfvwtlS82JrFizxHnvYUCbJ5c3S6a6zvH0iE2RF1kIiLnQQGoghSApDodyizgyw1JzN6QRGJGvnN588gAru8Uy7BLGlLP39uFFYqI1A4KQBWkACSu4HAYrN2fwWfrD/LdlmQKS8x7C3l5WOjVPJy+rSLp0yqS8EA9lFVEpDwKQBWkACSullVQwte/HuazdQfZcujkc8gsFmgfG8KVrSPp1zpKD2YVETmFAlAFKQBJTbIzJYcff0thwfbUMg9lBWga7k//NlH0bxNFu4bBGjMkIm5NAaiCFICkpkrJKmTh9lR+3JbKqr1HKLGf/ONbP8BGz4vC6HFRfXo2q090sK8LKxURqX4KQBWkACS1QXZhCYt3pPHjb6ks3plW5rJ6MFuHhnZowPWdYonQA1pFxA0oAFWQApDUNkWldjYeyOTnPUdYsecIm5MycRz/k+1htdC3VQSjujTi8mbhWPWAVhGpoxSAKkgBSGq7rPwSFmxP5ZO1iWw4cPIBrfUDbFzWrD49j3eTRaplSETqEAWgClIAkrpkV2oOn6xN5IsNSWQXlpZZ1zwygD6tIhmgQdQiUgcoAFWQApDURSe6yZbvTmfFniNsOZTFqX/6o4N96Nc6kitbR9EpPhQfLz21XkRqFwWgClIAEndwLK+YZbvTyx1E7eNl5dImYVzWLJzLm9XnoogAtQ6JSI2nAFRBCkDibgpL7Py85wjfb01h6a500nKKyqxvEOLLFS3C6d0igu4XhemBrSJSIykAVZACkLgzwzDYmZrD8l1HWLY7nbX7MigqdTjXe3uarUO9mofTq3k4TcP91TokIjVCnQlAkydP5ssvv2THjh34+vrSvXt3Xn75ZVq0aHHGfWbMmMFtt91WZpnNZqOwsPCcP1cBSOSkgmI7q38/yuKdafy0I42kYwVl1jcI8aVXi3C6Nw2jU1w9ooJ1ZZmIuMb5/H7X6HbspUuXMm7cODp37kxpaSl///vf6devH9u2bcPf3/+M+wUFBbFz507ne/3rVOTC+Xp70LtlBL1bRjDpGoO96bks2ZnO0l3prPk9g0OZBcxck8jMNYmAGYg6xYfSKb4e3ZuG0aS+WohEpOap0S1Af5Senk5ERARLly7l8ssvL3ebGTNmMH78eDIzMy/4c9QCJHJu8otLWfN7Bkt3pbNufwbbk7OdN2A8ITLIRvem9eneNIzO8fWIC/NTIBKRKlFnWoD+KCvLfBBkvXr1zrpdbm4ucXFxOBwOLrnkEl588UXatGlzxu2LioooKjo56DM7O7tyChap4/y8PZ2tQwC5RaVsSsxk3f4M1u7LYEPiMVKzi5jzyyHm/HIIgEAfTy6OCebiBkG0bRhCl3h1m4lI9as1LUAOh4NrrrmGzMxMVqxYccbtVq1axe7du2nXrh1ZWVm8+uqrLFu2jN9++42GDRuWu8/EiROZNGnSacvVAiRSMYUldjYeOMbKvUdZufcIWw9nU3zKgOoT4sL86BJfj65NwugYF0pcPT89skNEzludGQR9qnvuuYf58+ezYsWKMwaZ8pSUlNCqVStGjRrFc889V+425bUAxcbGKgCJVLISu4PdqblsPZTFlkNZbDqYyW+Hs07rNvP39qBVdBCtooNoHRNE2wbBtIgKxMvD6prCRaRWqHNdYPfddx/z5s1j2bJl5xV+ALy8vOjQoQN79uw54zY2mw2bzVbRMkXkT3h5WGkdY4aa6zvHApBTWML6A8dY/ftR1vyewbbkbPKK7aw/cIz1pzzHzOZppU1MEAmxIbSPDaFr4zB1nYnIBavRAcgwDO6//37mzJnDkiVLaNy48Xkfw263s2XLFq666qoqqFBEKirQx4veLSLo3cIcR1Rqd/D7kTy2Hc5mW3K2s7Uop7CUjYmZbEzMdO7bqJ4fXRrXo0t8PVpEBRIX5keIn7eLvomI1CY1ugvs3nvvZebMmXz11Vdl7v0THByMr68vALfccgsNGjRg8uTJADz77LNceumlXHTRRWRmZjJlyhTmzp3Lhg0baN269Tl9rq4CE6lZHA6DfUfz2JyUya8Hs9hw4Fi5XWcAwb5exIf50bi+Py2Pd6O1ig4kIlCtRSJ1XZ3pAps2bRoAV1xxRZnl06dP59ZbbwUgMTERq/XkuIBjx45x5513kpKSQmhoKB07dmTlypXnHH5EpOaxWi00DQ+gaXgAQzuY3eA5hSVsOHCMtfsyWH/gGPuP5JGWU0RWQQm/JmXxa1IWbDrsPEb9AG9n11nXJvVoHR2Ep8YUibitGt0C5CpqARKpnfKLS0nMyGf/kXz2pueyLTmb7cnZ7D+Sd1prUYDNk45xobRrGEyb45flNwjx1T2KRGqxOnkVWHVSABKpWwqK7WxPyWb9/gzW/J7B2v0Z5BSWnrZdqJ8XTcIDiA72ISbE1/naqJ4fcWF+egisSA2nAFRBCkAidZvdYbA9OZuNicfYeiiLrYey2ZWaQ2l5g4pOERFoI+74+KITXXJNIwKIDfVVd5pIDaAAVEEKQCLup6jUzq6UXBIz8knOKuBwZiHJWQUcyizgwNF8sgpKzrivt4eVltGBtG0QTELDENo2DKZZRIBCkUg1UwCqIAUgEfmjrPwSDmTksf9oPvvS89ibnsuetFx+P5JLYcnpd7e2WiA80EZkkA+RQT5EBfnQMNSXuDA/Yuv5ERfmT4BNXWoilanOXAUmIlJTBPt50c4vhHYNQ8osdzgMko4VsPlQJluSsvg1KZOth7LJLSolNbuI1OwiIKvcY4b6eREZ5EN0sA9RwWZQalTP7GJrUj+AYD+vqv9iIm5KLUDlUAuQiFSEw2FwJLeIlOxCUrPN15SsAg5mFJCYkU9iRj4ZecV/epx6/t7Hw5A/jcPN1ybhAYQH2PC3eeLtqS42kVOpBUhExIWsVgsRQT5EBJ355os5hSUcyiwgJauQ1OxCkrMKSckq5MDRfPYdySMlu5CMvGIy8orZcMojQU7l5WHBz9uTIF9PYkPNbrX4MPM1KtiHIB9Pgny9CPTxxObpUVVfV6RWUgtQOdQCJCKulldUyv6jefyense+I3n8np7L70fy2JeeR07R6Zfw/xlfLw8ahvoSX9+fxvX9iQ/zJ76+H/Fh/kQF+WC16v5HUvupBUhEpJbzt3nSJsa8SeMfldod5BXbyS8uJa+olMz8Eg4czefAUXOQ9oGjeRzJLSa7oMQZlgpK7OxOy2V3Wu5px/P2tBJ3/F5H4YE+hPl7ExbgTT1/b8L8bYT6ezlf1ZIkdYUCkIhILePpYSXY10qw78lB0p3i65W7rd1hkFtUyrG8Yg5k5LP/iNmitP9oHolHzfFIxaWOM4ajP/L39sDm5YHVAlaLBavFgq/38dalMH/iwvxoVM+PhqF+RAf7EOLnpbtrS42kLrByqAtMRNxFqd1BclYh+4/mceBoPkdyi8jIK+ZoXjEZucUczSsiI6+EY/nF2P/kRpHlsXlazSvcAn0I8PHEz9sDf29P/GweBPl4Uc/fu8wUFaTQJBdO9wGqIAUgEZGyDMMgu9BsSSq2O3AYBnaHgWFAblEpiUfznfdJSjxq3kzySO6fX+lWHl8vD6JDfIgJ9qV+gDe+3h74eHng5+2Br5cHATZPAn28nAO8g3y8CPI1B3wHeHtqPJMb0xggERGpVBaLhWBfrzLdbqe6tEnYacuKSu2kZReRnFVIWk4h+UV28opLyS+2k1tUSnZBifNKt2P5xRzJNecLSuz8nm4OAD//OiHQ5kmInzeh/t6E+nlRz8+bIF8vvD2teHlY8LRa8fY0uxDNG1WaN6ysH2DDQ+HJbSgAiYhIlbB5ehBbz7zz9bkqLLGTklXI4cwCDmcVkplfTEGxnYISO/nFdgpOhKfCEnIKzdfsglJyCksoKnVgGJBdWEp2YSmJGfnnXbO3pxWbc/IgyNeLqKCTd/SOCLIR7OvlbIUK9PHE3+ZZZh8vD4u68GoBBSAREakxfLw8iK/vT3x9//Pet7DETk5hKVkFJWQVFJtjl463LmUXllBiNyixO8yp1CAjv5i04zerTM8twu4wKC51UFzqIOf4MQ9lFrA9+fzqsFjAy2rFagVPqxUPqwWbp5UQPy+zZcrPi1A/b3y8PPCwWvC0WvD0sODj6eF8fMqJ13r+3mqVqiIKQCIiUif4eJljhcIDbee9r91hkJlfTFGp4/hkp7DEQWZ+ManZhaRkFZGaU0hadhHZhSXkFpaSU2S+5hXbKS49+Tw4w4BiuwPsACeXp+UUnXddFgsE+x4fLH68K+/E+KsTU2GJ2SqWW1RKXpGdolI7kUE+zivyGtXzJzzQho+XFR9PD+eYqhA/L8L8vQny8XLLcVMKQCIi4vY8rBbCAs4/OJ3gcBgU20+GJ7vDoNR+PKQYBgXFdjLzzavpMvOLycwvodjuoMRuYHeYrwXFdtJyCknLKSItp4gjuUUYBmTml5CZX8LvnPuYqKRjBSQdK+Bnjp7Tdw/18yLIxwtPDwseViueVouz5cr7eNeezcuKzcOK1WrBw2LBw8N89T1+ZZ+/zRyg7mfzxMfTis3Lw/l6YuyVh9WCl4d57CBf8zNdRQFIRESkgqxWCz5Ws2UFKudHvdTuILPA7MY7MVA8u6AUiwU8Pcx7MHlYza6zAB9PAmzmeCQvDwvJxx+rkpiRT+LRPDLySygssTunghI7mXnmjTLtDoMjucUXfNXehbq7V1MeH9iyWj/zVApAIiIiNZCnh5X6ATbqX0DLVMNQPzqf4eaYpyoqtXMsz7waL6ewxGy5chiUHm+VKrE7KCpxmK1bJXaK7Q7sDnAYJ1q4HBSWOsgpNO9KnldUSl5xqdkSVnKyK7HU4cDuMI63eJnHd/XDfBWARERE3JTN04OoYA+igs/84N66yrXxS0RERMQFFIBERETE7SgAiYiIiNtRABIRERG3owAkIiIibkcBSERERNyOApCIiIi4HQUgERERcTsKQCIiIuJ2FIBERETE7SgAiYiIiNtRABIRERG3owAkIiIibkcBSERERNyOp6sLqIkMwwAgOzvbxZWIiIjIuTrxu33id/xsFIDKkZOTA0BsbKyLKxEREZHzlZOTQ3Bw8Fm3sRjnEpPcjMPh4PDhwwQGBmKxWCr12NnZ2cTGxnLw4EGCgoIq9dhSls519dG5rj4619VH57r6VNa5NgyDnJwcYmJisFrPPspHLUDlsFqtNGzYsEo/IygoSH+gqonOdfXRua4+OtfVR+e6+lTGuf6zlp8TNAhaRERE3I4CkIiIiLgdBaBqZrPZeOaZZ7DZbK4upc7Tua4+OtfVR+e6+uhcVx9XnGsNghYRERG3oxYgERERcTsKQCIiIuJ2FIBERETE7SgAiYiIiNtRAKpGb731FvHx8fj4+NC1a1fWrl3r6pJqvcmTJ9O5c2cCAwOJiIhgyJAh7Ny5s8w2hYWFjBs3jrCwMAICAhg+fDipqakuqrjueOmll7BYLIwfP965TOe68hw6dIibbrqJsLAwfH19adu2LevXr3euNwyDp59+mujoaHx9fenbty+7d+92YcW1k91u56mnnqJx48b4+vrStGlTnnvuuTLPktK5vjDLli1j8ODBxMTEYLFYmDt3bpn153JeMzIyGD16NEFBQYSEhDB27Fhyc3MrpT4FoGry6aefMmHCBJ555hk2btxIQkIC/fv3Jy0tzdWl1WpLly5l3LhxrF69mgULFlBSUkK/fv3Iy8tzbvPQQw/xzTffMHv2bJYuXcrhw4cZNmyYC6uu/datW8d//vMf2rVrV2a5znXlOHbsGD169MDLy4v58+ezbds2XnvtNUJDQ53bvPLKK7z55pu88847rFmzBn9/f/r3709hYaELK699Xn75ZaZNm8bUqVPZvn07L7/8Mq+88gr//ve/ndvoXF+YvLw8EhISeOutt8pdfy7ndfTo0fz2228sWLCAefPmsWzZMu66667KKdCQatGlSxdj3Lhxzvd2u92IiYkxJk+e7MKq6p60tDQDMJYuXWoYhmFkZmYaXl5exuzZs53bbN++3QCMVatWuarMWi0nJ8do1qyZsWDBAqNXr17Ggw8+aBiGznVleuyxx4yePXuecb3D4TCioqKMKVOmOJdlZmYaNpvN+OSTT6qjxDpj0KBBxu23315m2bBhw4zRo0cbhqFzXVkAY86cOc7353Jet23bZgDGunXrnNvMnz/fsFgsxqFDhypck1qAqkFxcTEbNmygb9++zmVWq5W+ffuyatUqF1ZW92RlZQFQr149ADZs2EBJSUmZc9+yZUsaNWqkc3+Bxo0bx6BBg8qcU9C5rkxff/01nTp14rrrriMiIoIOHTrw3nvvOdfv27ePlJSUMuc6ODiYrl276lyfp+7du7No0SJ27doFwK+//sqKFSsYOHAgoHNdVc7lvK5atYqQkBA6derk3KZv375YrVbWrFlT4Rr0MNRqcOTIEex2O5GRkWWWR0ZGsmPHDhdVVfc4HA7Gjx9Pjx49uPjiiwFISUnB29ubkJCQMttGRkaSkpLigiprt1mzZrFx40bWrVt32jqd68rz+++/M23aNCZMmMDf//531q1bxwMPPIC3tzdjxoxxns/y/k7RuT4/jz/+ONnZ2bRs2RIPDw/sdjsvvPACo0ePBtC5riLncl5TUlKIiIgos97T05N69epVyrlXAJI6Y9y4cWzdupUVK1a4upQ66eDBgzz44IMsWLAAHx8fV5dTpzkcDjp16sSLL74IQIcOHdi6dSvvvPMOY8aMcXF1dctnn33Gxx9/zMyZM2nTpg2bNm1i/PjxxMTE6FzXceoCqwb169fHw8PjtKthUlNTiYqKclFVdct9993HvHnzWLx4MQ0bNnQuj4qKori4mMzMzDLb69yfvw0bNpCWlsYll1yCp6cnnp6eLF26lDfffBNPT08iIyN1ritJdHQ0rVu3LrOsVatWJCYmAjjPp/5OqbhHHnmExx9/nBtuuIG2bdty880389BDDzF58mRA57qqnMt5jYqKOu1CodLSUjIyMirl3CsAVQNvb286duzIokWLnMscDgeLFi2iW7duLqys9jMMg/vuu485c+bw008/0bhx4zLrO3bsiJeXV5lzv3PnThITE3Xuz1OfPn3YsmULmzZtck6dOnVi9OjRznmd68rRo0eP027nsGvXLuLi4gBo3LgxUVFRZc51dnY2a9as0bk+T/n5+VitZX8KPTw8cDgcgM51VTmX89qtWzcyMzPZsGGDc5uffvoJh8NB165dK15EhYdRyzmZNWuWYbPZjBkzZhjbtm0z7rrrLiMkJMRISUlxdWm12j333GMEBwcbS5YsMZKTk51Tfn6+c5u7777baNSokfHTTz8Z69evN7p162Z069bNhVXXHadeBWYYOteVZe3atYanp6fxwgsvGLt37zY+/vhjw8/Pz/joo4+c27z00ktGSEiI8dVXXxmbN282rr32WqNx48ZGQUGBCyuvfcaMGWM0aNDAmDdvnrFv3z7jyy+/NOrXr288+uijzm10ri9MTk6O8csvvxi//PKLARivv/668csvvxgHDhwwDOPczuuAAQOMDh06GGvWrDFWrFhhNGvWzBg1alSl1KcAVI3+/e9/G40aNTK8vb2NLl26GKtXr3Z1SbUeUO40ffp05zYFBQXGvffea4SGhhp+fn7G0KFDjeTkZNcVXYf8MQDpXFeeb775xrj44osNm81mtGzZ0nj33XfLrHc4HMZTTz1lREZGGjabzejTp4+xc+dOF1Vbe2VnZxsPPvig0ahRI8PHx8do0qSJ8eSTTxpFRUXObXSuL8zixYvL/ft5zJgxhmGc23k9evSoMWrUKCMgIMAICgoybrvtNiMnJ6dS6rMYxim3uxQRERFxAxoDJCIiIm5HAUhERETcjgKQiIiIuB0FIBEREXE7CkAiIiLidhSARERExO0oAImIiIjbUQASETkHFouFuXPnuroMEakkCkAiUuPdeuutWCyW06YBAwa4ujQRqaU8XV2AiMi5GDBgANOnTy+zzGazuagaEant1AIkIrWCzWYjKiqqzBQaGgqY3VPTpk1j4MCB+Pr60qRJEz7//PMy+2/ZsoW//OUv+Pr6EhYWxl133UVubm6Zbd5//33atGmDzWYjOjqa++67r8z6I0eOMHToUPz8/GjWrBlff/111X5pEakyCkAiUic89dRTDB8+nF9//ZXRo0dzww03sH37dgDy8vLo378/oaGhrFu3jtmzZ7Nw4cIyAWfatGmMGzeOu+66iy1btvD1119z0UUXlfmMSZMmcf3117N582auuuoqRo8eTUZGRrV+TxGpJJXySFURkSo0ZswYw8PDw/D39y8zvfDCC4ZhGAZg3H333WX26dq1q3HPPfcYhmEY7777rhEaGmrk5uY613/77beG1Wo1UlJSDMMwjJiYGOPJJ588Yw2A8Y9//MP5Pjc31wCM+fPnV9r3FJHqozFAIlIr9O7dm2nTppVZVq9ePed8t27dyqzr1q0bmzZtAmD79u0kJCTg7+/vXN+jRw8cDgc7d+7EYrFw+PBh+vTpc9Ya2rVr55z39/cnKCiItLS0C/1KIuJCCkAiUiv4+/uf1iVVWXx9fc9pOy8vrzLvLRYLDoejKkoSkSqmMUAiUiesXr36tPetWrUCoFWrVvz666/k5eU51//8889YrVZatGhBYGAg8fHxLFq0qFprFhHXUQuQiNQKRUVFpKSklFnm6elJ/fr1AZg9ezadOnWiZ8+efPzxx6xdu5b//ve/AIwePZpnnnmGMWPGMHHiRNLT07n//vu5+eabiYyMBGDixIncfffdREREMHDgQHJycvj555+5//77q/eLiki1UAASkVrh+++/Jzo6usyyFi1asGPHDsC8QmvWrFnce++9REdH88knn9C6dWsA/Pz8+OGHH3jwwQfp3Lkzfn5+DB8+nNdff915rDFjxlBYWMg///lPHn74YerXr8+IESOq7wuKSLWyGIZhuLoIEZGKsFgszJkzhyFDhri6FBGpJTQGSERERNyOApCIiIi4HY0BEpFaTz35InK+1AIkIiIibkcBSERERNyOApCIiIi4HQUgERERcTsKQCIiIuJ2FIBERETE7SgAiYiIiNtRABIRERG3owAkIiIibuf/ASRyKyZquKACAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Plot training & validation loss values\n", + "plt.plot(history.history['loss'], label='Train Loss')\n", + "plt.plot(history.history['val_loss'], label='Validation Loss')\n", + "plt.title('Model Loss')\n", + "plt.ylabel('Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(loc='upper right')\n", + "plt.show()\n", + "\n", + "# Plot training & validation accuracy values\n", + "plt.plot(history.history['accuracy'], label='Train Accuracy')\n", + "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n", + "plt.title('Model Accuracy')\n", + "plt.ylabel('Accuracy')\n", + "plt.xlabel('Epoch')\n", + "plt.legend(loc='upper left')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "On her dying bed, my late mom told me: quite\n", + "On her dying bed, my late mom told me: quite friend\n", + "On her dying bed, my late mom told me: quite friend young\n", + "On her dying bed, my late mom told me: quite friend young day\n", + "On her dying bed, my late mom told me: quite friend young day to\n", + "On her dying bed, my late mom told me: quite friend young day to store\n", + "On her dying bed, my late mom told me: quite friend young day to store me\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie '\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain '\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who '\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none who\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none who are\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none who are both\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none who are both word\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none who are both word and\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none who are both word and increase\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none who are both word and increase oppress'd\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none who are both word and increase oppress'd so\n", + "On her dying bed, my late mom told me: quite friend young day to store me purge purge lie ' live had had know boast that that love her a doting will be store me think let store prove prove none who true remain ' live who ' tender'd none who are both word and increase oppress'd so slow\n" + ] + } + ], + "source": [ + "seed_text = \"On her dying bed, my late mom told me:\"\n", + "next_words = 50\n", + "\n", + "generate_text(model2, seed_text, next_words)" ] } ], @@ -414,7 +1355,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" } }, "nbformat": 4,