From 8c265b7e7985877f19cd4ddad3da79e8843428a1 Mon Sep 17 00:00:00 2001 From: mohammed-majeed Date: Sat, 23 Dec 2023 23:52:17 +0100 Subject: [PATCH 1/3] group 3 --- projects/ai2thor/team3/AI2THOR_Group_3.ipynb | 1033 +++++++++++++++++ projects/ai2thor/team3/AI2Thor_graph.png | Bin 0 -> 52211 bytes .../processed_room_classification_data.csv | 444 +++++++ projects/ai2thor/team3/readme.md | 28 +- 4 files changed, 1504 insertions(+), 1 deletion(-) create mode 100644 projects/ai2thor/team3/AI2THOR_Group_3.ipynb create mode 100644 projects/ai2thor/team3/AI2Thor_graph.png create mode 100644 projects/ai2thor/team3/processed_room_classification_data.csv diff --git a/projects/ai2thor/team3/AI2THOR_Group_3.ipynb b/projects/ai2thor/team3/AI2THOR_Group_3.ipynb new file mode 100644 index 00000000..b64d04b5 --- /dev/null +++ b/projects/ai2thor/team3/AI2THOR_Group_3.ipynb @@ -0,0 +1,1033 @@ +{ + "cells": [ + { + "cell_type": "code", + "source": [ + "!pip install transformers -q\n", + "!pip install --upgrade ai2thor --quiet\n", + "!pip install ai2thor-colab prior --upgrade &> /dev/null" + ], + "metadata": { + "id": "37da95xo4aTf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "qfMjAKLNFR-R" + }, + "outputs": [], + "source": [ + "import warnings,logging\n", + "warnings.simplefilter('ignore')\n", + "logging.disable(logging.WARNING)\n", + "import time\n", + "import random\n", + "import os\n", + "import numpy as np\n", + "import pandas as pd\n", + "import prior\n", + "\n", + "from statistics import mode\n", + "\n", + "os.system('apt-get update')\n", + "os.system('apt-get install xvfb')\n", + "\n", + "import ai2thor_colab\n", + "from ai2thor.controller import Controller\n", + "from ai2thor.platform import CloudRendering\n", + "from PIL import Image\n", + "\n", + "from transformers import pipeline\n", + "from transformers import BertTokenizer, BertModel\n", + "\n", + "from sklearn.metrics.pairwise import cosine_similarity\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.feature_extraction.text import CountVectorizer\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import accuracy_score, classification_report\n", + "\n", + "import torch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9D1eXeiRf0AR" + }, + "outputs": [], + "source": [ + "# Image to caption model\n", + "captioner = pipeline(model=\"ydshieh/vit-gpt2-coco-en\")\n", + "caption = pipeline('image-to-text')\n", + "def image_to_caption(img):\n", + " image_text= caption(img)[0]\n", + " return image_text\n", + "\n", + "def encode_text_with_bert(text):\n", + " # Load pre-trained BERT tokenizer and model\n", + " tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n", + " model = BertModel.from_pretrained('bert-base-uncased')\n", + "\n", + " # Tokenize the text\n", + " input_ids = tokenizer.encode(text, add_special_tokens=True)\n", + "\n", + " # Convert input IDs to PyTorch tensor\n", + " input_ids = torch.tensor(input_ids).unsqueeze(0)\n", + "\n", + " # Get BERT embeddings for the input text\n", + " with torch.no_grad():\n", + " outputs = model(input_ids)\n", + " # Use mean pooling to get a fixed-size embedding vector\n", + " bert_embeddings = outputs.last_hidden_state.mean(dim=1)\n", + "\n", + " return bert_embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "juD7gnn7Lh58" + }, + "outputs": [], + "source": [ + "# Robot movement and decisions\n", + "\n", + "def right_side(rotate=False):\n", + " if not rotate:\n", + " frame_right = controller.step(\"RotateRight\", degrees=90).frame\n", + " controller.step(\"RotateLeft\", degrees=90)\n", + " else:\n", + " frame_right = controller.step(\"RotateRight\", degrees=90).frame\n", + " return Image.fromarray(frame_right)\n", + "\n", + "\n", + "def front_right_side(rotate=False):\n", + " if not rotate:\n", + " frame_right = controller.step(\"RotateRight\", degrees=45).frame\n", + " controller.step(\"RotateLeft\", degrees=45)\n", + " else:\n", + " frame_right = controller.step(\"RotateRight\", degrees=45).frame\n", + " return Image.fromarray(frame_right)\n", + "\n", + "def left_side(rotate=False):\n", + " if not rotate:\n", + " frame_left = controller.step(\"RotateLeft\", degrees=90).frame\n", + " controller.step(\"RotateRight\", degrees=90)\n", + " else:\n", + " frame_left = controller.step(\"RotateLeft\", degrees=90).frame\n", + " return Image.fromarray(frame_left)\n", + "\n", + "def front_left_side(rotate=False):\n", + " if not rotate:\n", + " frame_left = controller.step(\"RotateLeft\", degrees=45).frame\n", + " controller.step(\"RotateRight\", degrees=45)\n", + " else:\n", + " frame_left = controller.step(\"RotateLeft\", degrees=45).frame\n", + " return Image.fromarray(frame_left)\n", + "\n", + "def back_side(rotate=False):\n", + " if not rotate:\n", + " frame_back = controller.step(\"RotateLeft\", degrees=180).frame\n", + " controller.step(\"RotateRight\", degrees=180)\n", + " else:\n", + " frame_back = controller.step(\"RotateLeft\", degrees=180).frame\n", + " return Image.fromarray(frame_back)\n", + "\n", + "def back_left_side(rotate=False):\n", + " if not rotate:\n", + " frame_back = controller.step(\"RotateLeft\", degrees=135).frame\n", + " controller.step(\"RotateRight\", degrees=135)\n", + " else:\n", + " frame_back = controller.step(\"RotateLeft\", degrees=135).frame\n", + " return Image.fromarray(frame_back)\n", + "\n", + "def back_right_side(rotate=False):\n", + " if not rotate:\n", + " frame_back = controller.step(\"RotateRight\", degrees=135).frame\n", + " controller.step(\"RotateLeft\", degrees=135)\n", + " else:\n", + " frame_back = controller.step(\"RotateRight\", degrees=135).frame\n", + " return Image.fromarray(frame_back)\n", + "\n", + "sm_s=[]\n", + "def front_side(action=None,move=False, similarity_score=None):\n", + " global sm_s\n", + " if move:\n", + " sm_s.append(similarity_score)\n", + " sm_s = sm_s[-2:]\n", + " # To check the robot stays in the same position (bump into an object)\n", + " if sum(sm_s)/2!= similarity_score:\n", + " controller.step(\"MoveAhead\")\n", + " actions[time.perf_counter()]=(f'MoveAhead')\n", + " else:\n", + " move_to_closest_point(action)\n", + " actions[time.perf_counter()]=(f'move_to_closest_point')\n", + " sm_s=[]\n", + " frame_front = controller.last_event.frame\n", + " return Image.fromarray(frame_front)\n", + "\n", + "def move_to_closest_point(direction):\n", + " current_rotation = controller.last_event.metadata['agent']['rotation']['y']\n", + " current_position = controller.last_event.metadata['agent']['position']\n", + " reachable_positions = controller.step(action=\"GetReachablePositions\").metadata[\"actionReturn\"]\n", + " front_points, back_points, right_points, left_points = extract_directional_points(current_position, reachable_positions)\n", + " event = controller.step(action=\"Teleport\", position=right_points[0])\n", + "\n", + "\n", + "def extract_directional_points(current_position, reachable_positions):\n", + " # Calculate Euclidean distance for each point from the current position\n", + " distances = [\n", + " np.linalg.norm(np.array([pos['x'], pos['z']]) - np.array([current_position['x'], current_position['z']]))\n", + " for pos in reachable_positions\n", + " ]\n", + " # Combine reachable positions with their distances\n", + " positions_with_distance = zip(reachable_positions, distances)\n", + "\n", + " # Sort the positions based on the distances\n", + " sorted_positions = sorted(positions_with_distance, key=lambda x: x[1])\n", + "\n", + " # Extract sorted reachable positions\n", + " sorted_reachable_positions = [pos[0] for pos in sorted_positions]\n", + "\n", + " # Function to project points along a direction\n", + " def project_points(direction_vector):\n", + " projected_points = []\n", + " for pos in sorted_reachable_positions:\n", + " relative_position = np.array([pos['x'], pos['z']]) - np.array([current_position['x'], current_position['z']])\n", + " projection = np.dot(relative_position, direction_vector)\n", + " if projection > 0:\n", + " projected_points.append(pos)\n", + " return projected_points\n", + "\n", + " # Direction vectors\n", + " front_vector = np.array([0, -1])\n", + " right_vector = np.array([1, 0])\n", + " back_vector = np.array([0, 1])\n", + " left_vector = np.array([-1, 0])\n", + "\n", + " # Extract points in each direction\n", + " front_points = project_points(front_vector)\n", + " right_points = project_points(right_vector)\n", + " back_points = project_points(back_vector)\n", + " left_points = project_points(left_vector)\n", + "\n", + " return front_points, right_points, back_points, left_points\n", + "\n", + "def teleport_randomly():\n", + " event = controller.step(action=\"GetReachablePositions\")\n", + " reachable_positions = event.metadata[\"actionReturn\"]\n", + " position = random.choice(reachable_positions)\n", + " # rotation = random.choice(range(360))\n", + " controller.step(action=\"Teleport\", position=position)\n", + "\n", + "\n", + "\n", + "def low_score_actions(action, similarity_score):\n", + " if action == \"front_side\":\n", + " front_side(action=action,move=True,similarity_score=similarity_score)\n", + " else:\n", + " temp= 'rotate '+ action\n", + " actions[time.perf_counter()]=temp\n", + " if action == \"right_side\":\n", + " right_side(rotate=True)\n", + " elif action == \"left_side\":\n", + " left_side(rotate=True)\n", + " elif action == \"back_side\":\n", + " back_side(rotate=True)\n", + " elif action == \"front_right_side\":\n", + " front_right_side(rotate=True)\n", + " elif action == \"front_left_side\":\n", + " front_left_side(rotate=True)\n", + " elif action == \"back_left_side\":\n", + " back_left_side(rotate=True)\n", + " elif action == \"back_right_side\":\n", + " back_right_side(rotate=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "GvRMJVTfKZ-g" + }, + "outputs": [], + "source": [ + "# Save all actions and movements\n", + "def save_to_txt(file_path):\n", + " with open(file_path, 'w') as file:\n", + " for key, value in actions.items():\n", + " file.write(f\"{key}: {value}\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VLnxMWPKKeja", + "outputId": "c7c17059-3d72-4a88-cab7-695c7f5cb1d9" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Accuracy: 0.8651685393258427\n", + "Classification Report:\n", + " precision recall f1-score support\n", + "\n", + " 0 0.78 0.64 0.70 11\n", + " 1 1.00 0.75 0.86 20\n", + " 2 1.00 0.80 0.89 15\n", + " 3 0.81 1.00 0.90 43\n", + "\n", + " accuracy 0.87 89\n", + " macro avg 0.90 0.80 0.84 89\n", + "weighted avg 0.88 0.87 0.86 89\n", + "\n" + ] + } + ], + "source": [ + "def train_model_and_vectorizer(data, text_column, class_column):\n", + " # Split the dataset into training and testing sets\n", + " X = data[text_column]\n", + " y = data[class_column]\n", + " X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + " # Vectorize the text data using CountVectorizer\n", + " vectorizer = CountVectorizer()\n", + " X_train_vec = vectorizer.fit_transform(X_train)\n", + " X_test_vec = vectorizer.transform(X_test)\n", + "\n", + " # Initialize and train a logistic regression model\n", + " model = LogisticRegression(max_iter=1000) # You can adjust hyperparameters as needed\n", + " model.fit(X_train_vec, y_train)\n", + "\n", + " # Make predictions on the test set\n", + " y_pred = model.predict(X_test_vec)\n", + "\n", + " # Evaluate the model\n", + " accuracy = accuracy_score(y_test, y_pred)\n", + " classification_rep = classification_report(y_test, y_pred)\n", + "\n", + " print(f'Accuracy: {accuracy}')\n", + " print(f'Classification Report:\\n{classification_rep}')\n", + "\n", + " # Return the trained model and vectorizer\n", + " return model, vectorizer\n", + "\n", + "# The training data that we built\n", + "url = 'https://raw.githubusercontent.com/Mohammed-majeed/Communicative-Robots/main/processed_room_classification_data.csv'\n", + "data = pd.read_csv(url)\n", + "\n", + "# Column names for text and class labels\n", + "text_column_name = 'text'\n", + "class_column_name = 'labels'\n", + "\n", + "# Train the model and get the trained model and vectorizer\n", + "trained_model, trained_vectorizer = train_model_and_vectorizer(data, text_column_name, class_column_name)\n", + "\n", + "def predict_room(text):\n", + " X_test_vec = trained_vectorizer.transform([text])\n", + " predicted_labels = trained_model.predict(X_test_vec)\n", + "\n", + " return predicted_labels[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7471K4kGKgOH" + }, + "outputs": [], + "source": [ + "# Get views of the room and their captions\n", + "def images_to_room():\n", + "\n", + " # Define side views\n", + " side_views = {\n", + " \"front_side\":front_side,\n", + " \"right_side\": right_side,\n", + " \"left_side\": left_side,\n", + " \"back_side\": back_side,\n", + " # \"front_right_side\": front_right_side,\n", + " # \"front_left_side\": front_left_side,\n", + " # \"back_left_side\": back_left_side,\n", + " # \"back_right_side\": back_right_side\n", + " }\n", + "\n", + " view_room_predictions = []\n", + " images = {}\n", + " for view_name, func in side_views.items():\n", + " actions[time.perf_counter()]=f'{view_name} View'\n", + " image = func()\n", + " generated_caption = image_to_caption(image)['generated_text']\n", + " view_room_predictions.append(predict_room(generated_caption))\n", + " images[view_name] = (generated_caption, predict_room(generated_caption), image)\n", + "\n", + " robot_room_prediction = mode(view_room_predictions)\n", + " return robot_room_prediction, images\n", + "\n", + "# Check similarity between input text and captions\n", + "def check_similarity(input_text, captions):\n", + " input_text_embeddings = encode_text_with_bert(input_text)\n", + " similarity_score = {}\n", + " for view_name, (caption_text, _, image) in captions.items():\n", + " robot_text_embeddings = encode_text_with_bert(caption_text)\n", + " cosine_sim = cosine_similarity(input_text_embeddings, robot_text_embeddings)[0][0]\n", + " similarity_score[view_name] = {'cosine_similarity': cosine_sim, 'caption': caption_text, 'image': image}\n", + " highest_view = max(similarity_score, key=lambda key: similarity_score[key]['cosine_similarity'])\n", + "\n", + " return highest_view, similarity_score[highest_view]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "3JMEJWbgKh5w" + }, + "outputs": [], + "source": [ + "# To find the object in the scene\n", + "def find_object(target_name,caption):\n", + " target= target_name.replace(\" \",\"\")\n", + " for object in controller.last_event.metadata[\"objects\"]:\n", + " if object[\"visible\"] and target.lower() in object[\"name\"].lower():\n", + " # frame_front = controller.last_event.frame\n", + " # display(Image.fromarray(frame_front))\n", + " print(f'I see {caption}')\n", + " user = input('Please enter (Yes or No): ')\n", + " if user.lower() == 'yes':\n", + " actions[time.perf_counter()]=\"Yes, I found the object\"\n", + " return True\n", + " else:\n", + " actions[time.perf_counter()]=\"No, I will continue looking for the object\"\n", + " print('I will continue looking for the object')\n", + " teleport_randomly()\n", + " actions[time.perf_counter()]=\"Teleport_randomly: It is not the same object\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rFvqCuaFiGbu" + }, + "outputs": [], + "source": [ + "# Main processing function\n", + "def process_scene(input_text,target_name):\n", + " input_room_prediction = predict_room(input_text)\n", + " for iteration in range(MAX_ITERATIONS):\n", + " actions[time.perf_counter()]=f\"{str(iteration)}\"\n", + " robot_room_prediction, images = images_to_room()\n", + " if robot_room_prediction == input_room_prediction:\n", + " actions[time.perf_counter()]= f\"Same Room\"\n", + " similarity_view, highest_details = check_similarity(input_text, images)\n", + " similarity_score = highest_details['cosine_similarity']\n", + " if similarity_score >= COSINE_SIMILARITY_THRESHOLD:\n", + " actions[time.perf_counter()]=f'Place Found'\n", + " if find_object(target_name, highest_details['caption'] ):\n", + " actions[time.perf_counter()]=f'object Found'\n", + " break\n", + "\n", + " actions[time.perf_counter()]= \"I found a different object\"\n", + " low_score_actions(similarity_view, similarity_score)\n", + "\n", + " elif CLOSE_OBJECTS_THRESHOLD_LOW <= similarity_score < CLOSE_OBJECTS_THRESHOLD_HIGH:\n", + " actions[time.perf_counter()]= \"close to the scene\"\n", + " low_score_actions(similarity_view, similarity_score)\n", + " else:\n", + " teleport_randomly()\n", + " actions[time.perf_counter()]=\"Teleport_randomly: similarity score below threshold\"\n", + " else:\n", + " teleport_randomly()\n", + " actions[time.perf_counter()]= \"Teleport_randomly: Not in the same room\"\n", + " if iteration % 10==0:\n", + " print(\"I'm searching\")" + ] + }, + { + "cell_type": "code", + "source": [ + "# Import the house\n", + "\n", + "dataset = prior.load_dataset(\"procthor-10k\")\n", + "#house = dataset[\"train\"][11]\n", + "\n", + "dataset[\"train\"][5808][\"objects\"][9][\"children\"][2] = {\n", + " 'assetId': 'Laptop_13',\n", + " 'id': \"Laptop|surface|10|71\",\n", + " 'kinematic': False,\n", + " 'openness': 0,\n", + " 'position': {'x': 5.308516502380371,\n", + " 'y': 0.960530161857605,\n", + " 'z': 3.317396640777588},\n", + " 'rotation': {'x': -0.0, 'y': 0.0, 'z': 0.0},\n", + " 'layer': 'Procedural1'}\n", + "\n", + "new_house = dataset[\"train\"][5808]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uW09UG1P7tTu", + "outputId": "09c1f09b-64da-4f62-81b1-bc388d142195" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[AI2-THOR WARNING] There has been an update to ProcTHOR-10K that must be used with AI2-THOR version 5.0+. To use the new version of ProcTHOR-10K, please update AI2-THOR to version 5.0+ by running:\n", + " pip install --upgrade ai2thor\n", + "Alternatively, to downgrade to the old version of ProcTHOR-10K, run:\n", + " prior.load_dataset(\"procthor-10k\", revision=\"ab3cacd0fc17754d4c080a3fd50b18395fae8647\")\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Loading train: 100%|██████████| 10000/10000 [00:01<00:00, 6818.23it/s]\n", + "Loading val: 100%|██████████| 1000/1000 [00:00<00:00, 7283.80it/s]\n", + "Loading test: 100%|██████████| 1000/1000 [00:00<00:00, 7369.50it/s]\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 877 + }, + "id": "0XRNnjpjBkme", + "outputId": "7968be56-443b-4890-f8d5-cc52c026edf9" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " 100\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "please describe what objects you saw : bedroom with a bed and yellow sheet and black blanket and a laptop\n", + "what object are you looking for? : laptop\n", + "I'm searching\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "I see a bed with a blue blanket and a blue wall \n", + "Please enter (Yes or No): no\n", + "I will continue looking for the object\n", + "I'm searching\n", + "I'm searching\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "I see a bed with a blue blanket and a blue pillow \n", + "Please enter (Yes or No): no\n", + "I will continue looking for the object\n", + "I'm searching\n", + "I'm searching\n", + "Search is done\n" + ] + } + ], + "source": [ + "# For testing\n", + "actions = {}\n", + "COSINE_SIMILARITY_THRESHOLD = 0.85\n", + "CLOSE_OBJECTS_THRESHOLD_LOW = 0.80\n", + "CLOSE_OBJECTS_THRESHOLD_HIGH = 0.85\n", + "MAX_ITERATIONS = 50\n", + "\n", + "\n", + "ai2thor_colab.start_xserver()\n", + "controller = Controller(scene=new_house)\n", + "controller.reset(scene=new_house)\n", + "controller.step(action=\"AdvancePhysicsStep\",timeStep=0.05)\n", + "\n", + "# frame_front = controller.last_event.frame\n", + "# display(Image.fromarray(frame_front))\n", + "\n", + "# e.g. bedroom with a bed and yellow sheet and black blanket and a laptop\n", + "image_description= input(\"please describe what objects you saw : \")\n", + "# e.g. laptop\n", + "target =input(\"what object are you looking for? : \")\n", + "\n", + "process_scene(image_description,target)\n", + "print(\"Search is done\")\n", + "# Save the actions and interactions\n", + "save_to_txt(\"saved_actions.txt\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "mce-ONsriUYM", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "1f24c72c-4f20-4b9b-b0da-640a4bbab14c" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['2193.512678543: 0\\n',\n", + " '2193.512684623: front_side View\\n',\n", + " '2196.650457004: right_side View\\n',\n", + " '2200.905501814: left_side View\\n',\n", + " '2204.246856619: back_side View\\n',\n", + " '2207.491448141: Teleport_randomly: Not in the same room\\n',\n", + " '2207.491548372: 1\\n',\n", + " '2207.491554901: front_side View\\n',\n", + " '2209.202172251: right_side View\\n',\n", + " '2211.549979987: left_side View\\n',\n", + " '2213.534276124: back_side View\\n',\n", + " '2215.579294155: Same Room\\n',\n", + " '2229.172659409: close to the scene\\n',\n", + " '2229.88668707: MoveAhead\\n',\n", + " '2229.892276559: 2\\n',\n", + " '2229.89228445: front_side View\\n',\n", + " '2231.58727091: right_side View\\n',\n", + " '2233.860391623: left_side View\\n',\n", + " '2235.973765809: back_side View\\n',\n", + " '2238.432563886: Teleport_randomly: Not in the same room\\n',\n", + " '2238.432568436: 3\\n',\n", + " '2238.432573296: front_side View\\n',\n", + " '2240.143938045: right_side View\\n',\n", + " '2243.232789411: left_side View\\n',\n", + " '2245.989890534: back_side View\\n',\n", + " '2248.444916361: Teleport_randomly: Not in the same room\\n',\n", + " '2248.444920152: 4\\n',\n", + " '2248.444925692: front_side View\\n',\n", + " '2249.949702568: right_side View\\n',\n", + " '2252.556817303: left_side View\\n',\n", + " '2254.849330554: back_side View\\n',\n", + " '2261.277150275: Same Room\\n',\n", + " '2270.564315207: Place Found\\n',\n", + " '2283.061674547: No, I will continue looking for the object\\n',\n", + " '2283.764094769: Teleport_randomly: similarity score below threshold\\n',\n", + " '2283.764141089: I found a different object\\n',\n", + " '2283.764143519: rotate left_side\\n',\n", + " '2284.111907651: 5\\n',\n", + " '2284.11191442: front_side View\\n',\n", + " '2286.413480021: right_side View\\n',\n", + " '2288.85060397: left_side View\\n',\n", + " '2291.39549559: back_side View\\n',\n", + " '2294.061239751: Teleport_randomly: Not in the same room\\n',\n", + " '2294.061244281: 6\\n',\n", + " '2294.061250131: front_side View\\n',\n", + " '2295.714297045: right_side View\\n',\n", + " '2298.20332611: left_side View\\n',\n", + " '2300.602206022: back_side View\\n',\n", + " '2303.154439612: Teleport_randomly: Not in the same room\\n',\n", + " '2303.154444012: 7\\n',\n", + " '2303.154449942: front_side View\\n',\n", + " '2304.800472776: right_side View\\n',\n", + " '2307.152214973: left_side View\\n',\n", + " '2309.569756044: back_side View\\n',\n", + " '2312.213251266: Teleport_randomly: Not in the same room\\n',\n", + " '2312.213254836: 8\\n',\n", + " '2312.213259926: front_side View\\n',\n", + " '2314.136888638: right_side View\\n',\n", + " '2316.354513845: left_side View\\n',\n", + " '2319.598322769: back_side View\\n',\n", + " '2322.717439451: Teleport_randomly: Not in the same room\\n',\n", + " '2322.717443481: 9\\n',\n", + " '2322.717448041: front_side View\\n',\n", + " '2324.30979149: right_side View\\n',\n", + " '2326.820627324: left_side View\\n',\n", + " '2329.459606936: back_side View\\n',\n", + " '2332.186599861: Same Room\\n',\n", + " '2337.940652587: Teleport_randomly: similarity score below threshold\\n',\n", + " '2337.940656867: 10\\n',\n", + " '2337.940663247: front_side View\\n',\n", + " '2339.47436072: right_side View\\n',\n", + " '2341.776740948: left_side View\\n',\n", + " '2343.881112014: back_side View\\n',\n", + " '2346.692861792: Teleport_randomly: Not in the same room\\n',\n", + " '2346.692961052: 11\\n',\n", + " '2346.692967872: front_side View\\n',\n", + " '2348.521548652: right_side View\\n',\n", + " '2350.830401192: left_side View\\n',\n", + " '2353.461534095: back_side View\\n',\n", + " '2356.431222631: Teleport_randomly: Not in the same room\\n',\n", + " '2356.431226851: 12\\n',\n", + " '2356.431231901: front_side View\\n',\n", + " '2358.055504617: right_side View\\n',\n", + " '2360.20228357: left_side View\\n',\n", + " '2362.860485971: back_side View\\n',\n", + " '2365.716932926: Teleport_randomly: Not in the same room\\n',\n", + " '2365.716937836: 13\\n',\n", + " '2365.716943016: front_side View\\n',\n", + " '2367.201543093: right_side View\\n',\n", + " '2369.239702896: left_side View\\n',\n", + " '2371.577777643: back_side View\\n',\n", + " '2374.561585208: Teleport_randomly: Not in the same room\\n',\n", + " '2374.561589068: 14\\n',\n", + " '2374.561594518: front_side View\\n',\n", + " '2376.177233524: right_side View\\n',\n", + " '2378.713671746: left_side View\\n',\n", + " '2380.84303307: back_side View\\n',\n", + " '2383.365658693: Teleport_randomly: Not in the same room\\n',\n", + " '2383.365662462: 15\\n',\n", + " '2383.365667773: front_side View\\n',\n", + " '2385.609743138: right_side View\\n',\n", + " '2388.069039485: left_side View\\n',\n", + " '2390.780485062: back_side View\\n',\n", + " '2392.848470602: Same Room\\n',\n", + " '2398.472693219: close to the scene\\n',\n", + " '2398.472698119: rotate left_side\\n',\n", + " '2398.778141284: 16\\n',\n", + " '2398.778148894: front_side View\\n',\n", + " '2400.931227307: right_side View\\n',\n", + " '2403.549411941: left_side View\\n',\n", + " '2405.434030396: back_side View\\n',\n", + " '2407.973077057: Same Room\\n',\n", + " '2413.001217668: close to the scene\\n',\n", + " '2413.298658333: MoveAhead\\n',\n", + " '2413.300301012: 17\\n',\n", + " '2413.300306202: front_side View\\n',\n", + " '2415.018746665: right_side View\\n',\n", + " '2417.397087449: left_side View\\n',\n", + " '2419.567520788: back_side View\\n',\n", + " '2421.887322558: Same Room\\n',\n", + " '2426.996402554: Place Found\\n',\n", + " '2426.996469434: I found a different object\\n',\n", + " '2427.306676847: MoveAhead\\n',\n", + " '2427.308348486: 18\\n',\n", + " '2427.308352566: front_side View\\n',\n", + " '2429.1107181: right_side View\\n',\n", + " '2431.821486583: left_side View\\n',\n", + " '2433.702326987: back_side View\\n',\n", + " '2435.99995349: Same Room\\n',\n", + " '2441.610722655: Place Found\\n',\n", + " '2441.610784255: I found a different object\\n',\n", + " '2441.958190533: move_to_closest_point\\n',\n", + " '2441.959830423: 19\\n',\n", + " '2441.959835383: front_side View\\n',\n", + " '2443.917826387: right_side View\\n',\n", + " '2446.30465309: left_side View\\n',\n", + " '2448.315409638: back_side View\\n',\n", + " '2450.586897114: Same Room\\n',\n", + " '2456.466255146: Teleport_randomly: similarity score below threshold\\n',\n", + " '2456.466259246: 20\\n',\n", + " '2456.466264546: front_side View\\n',\n", + " '2458.091347211: right_side View\\n',\n", + " '2460.118316817: left_side View\\n',\n", + " '2462.446431386: back_side View\\n',\n", + " '2465.228723811: Teleport_randomly: Not in the same room\\n',\n", + " '2465.228826671: 21\\n',\n", + " '2465.228834021: front_side View\\n',\n", + " '2466.758160497: right_side View\\n',\n", + " '2469.053083421: left_side View\\n',\n", + " '2471.190460424: back_side View\\n',\n", + " '2473.752372275: Same Room\\n',\n", + " '2478.743830385: Place Found\\n',\n", + " '2478.743911185: I found a different object\\n',\n", + " '2478.743914334: rotate back_side\\n',\n", + " '2479.102616471: 22\\n',\n", + " '2479.102623431: front_side View\\n',\n", + " '2480.9423017: right_side View\\n',\n", + " '2483.020244369: left_side View\\n',\n", + " '2485.50649502: back_side View\\n',\n", + " '2487.620209726: Same Room\\n',\n", + " '2492.538632253: Place Found\\n',\n", + " '2492.538701453: I found a different object\\n',\n", + " '2492.882393882: MoveAhead\\n',\n", + " '2492.884054552: 23\\n',\n", + " '2492.884059652: front_side View\\n',\n", + " '2494.608473644: right_side View\\n',\n", + " '2497.026308343: left_side View\\n',\n", + " '2499.144060768: back_side View\\n',\n", + " '2501.774246071: Teleport_randomly: Not in the same room\\n',\n", + " '2501.774250242: 24\\n',\n", + " '2501.774255631: front_side View\\n',\n", + " '2503.2787072: right_side View\\n',\n", + " '2505.52277928: left_side View\\n',\n", + " '2508.630734026: back_side View\\n',\n", + " '2511.480840423: Same Room\\n',\n", + " '2516.56981704: close to the scene\\n',\n", + " '2516.569821831: rotate left_side\\n',\n", + " '2517.002773288: 25\\n',\n", + " '2517.002780438: front_side View\\n',\n", + " '2518.966212062: right_side View\\n',\n", + " '2521.116759213: left_side View\\n',\n", + " '2523.981939888: back_side View\\n',\n", + " '2526.287661901: Same Room\\n',\n", + " '2531.687769541: close to the scene\\n',\n", + " '2532.117289259: MoveAhead\\n',\n", + " '2532.118958229: 26\\n',\n", + " '2532.118961889: front_side View\\n',\n", + " '2533.829233993: right_side View\\n',\n", + " '2536.068746034: left_side View\\n',\n", + " '2538.467754275: back_side View\\n',\n", + " '2541.33047472: Teleport_randomly: Not in the same room\\n',\n", + " '2541.33047891: 27\\n',\n", + " '2541.33048266: front_side View\\n',\n", + " '2543.07615621: right_side View\\n',\n", + " '2545.410792449: left_side View\\n',\n", + " '2547.437361055: back_side View\\n',\n", + " '2550.22362149: Teleport_randomly: Not in the same room\\n',\n", + " '2550.22362544: 28\\n',\n", + " '2550.22363103: front_side View\\n',\n", + " '2551.972446859: right_side View\\n',\n", + " '2554.224491078: left_side View\\n',\n", + " '2556.342566323: back_side View\\n',\n", + " '2558.792856718: Teleport_randomly: Not in the same room\\n',\n", + " '2558.792861588: 29\\n',\n", + " '2558.792867958: front_side View\\n',\n", + " '2560.407457874: right_side View\\n',\n", + " '2562.919225641: left_side View\\n',\n", + " '2565.418835571: back_side View\\n',\n", + " '2567.800442054: Same Room\\n',\n", + " '2573.004151458: Place Found\\n',\n", + " '2573.004274978: I found a different object\\n',\n", + " '2573.004277658: rotate right_side\\n',\n", + " '2573.5684644: 30\\n',\n", + " '2573.56847269: front_side View\\n',\n", + " '2575.363852174: right_side View\\n',\n", + " '2577.760397885: left_side View\\n',\n", + " '2579.874973431: back_side View\\n',\n", + " '2581.936863603: Same Room\\n',\n", + " '2587.420138112: Place Found\\n',\n", + " '2599.499932238: No, I will continue looking for the object\\n',\n", + " '2599.966938242: Teleport_randomly: similarity score below threshold\\n',\n", + " '2599.967021072: I found a different object\\n',\n", + " '2600.282804534: MoveAhead\\n',\n", + " '2600.285000054: 31\\n',\n", + " '2600.285032494: front_side View\\n',\n", + " '2601.806068081: right_side View\\n',\n", + " '2604.188669424: left_side View\\n',\n", + " '2607.369447561: back_side View\\n',\n", + " '2610.193976361: Teleport_randomly: Not in the same room\\n',\n", + " '2610.193981711: 32\\n',\n", + " '2610.193988681: front_side View\\n',\n", + " '2612.461646638: right_side View\\n',\n", + " '2614.812397065: left_side View\\n',\n", + " '2616.960487286: back_side View\\n',\n", + " '2619.389350874: Same Room\\n',\n", + " '2624.805743002: Teleport_randomly: similarity score below threshold\\n',\n", + " '2624.805747722: 33\\n',\n", + " '2624.805753022: front_side View\\n',\n", + " '2626.749498908: right_side View\\n',\n", + " '2629.243784448: left_side View\\n',\n", + " '2631.275441813: back_side View\\n',\n", + " '2633.695638592: Same Room\\n',\n", + " '2639.098512801: Teleport_randomly: similarity score below threshold\\n',\n", + " '2639.098517401: 34\\n',\n", + " '2639.098522601: front_side View\\n',\n", + " '2640.835632432: right_side View\\n',\n", + " '2642.918825931: left_side View\\n',\n", + " '2645.470178744: back_side View\\n',\n", + " '2647.713051214: Same Room\\n',\n", + " '2653.443610834: Teleport_randomly: similarity score below threshold\\n',\n", + " '2653.443614924: 35\\n',\n", + " '2653.443620974: front_side View\\n',\n", + " '2655.203906872: right_side View\\n',\n", + " '2657.04657218: left_side View\\n',\n", + " '2659.188577992: back_side View\\n',\n", + " '2661.873347959: Teleport_randomly: Not in the same room\\n',\n", + " '2661.873352609: 36\\n',\n", + " '2661.873359019: front_side View\\n',\n", + " '2663.849986241: right_side View\\n',\n", + " '2666.143332087: left_side View\\n',\n", + " '2668.630433358: back_side View\\n',\n", + " '2671.306734356: Teleport_randomly: Not in the same room\\n',\n", + " '2671.306738046: 37\\n',\n", + " '2671.306744136: front_side View\\n',\n", + " '2673.05388432: right_side View\\n',\n", + " '2675.751118227: left_side View\\n',\n", + " '2677.995704925: back_side View\\n',\n", + " '2680.393646303: Teleport_randomly: Not in the same room\\n',\n", + " '2680.393650913: 38\\n',\n", + " '2680.393656833: front_side View\\n',\n", + " '2681.907640284: right_side View\\n',\n", + " '2684.345190599: left_side View\\n',\n", + " '2686.568279559: back_side View\\n',\n", + " '2689.119489895: Same Room\\n',\n", + " '2694.103018867: close to the scene\\n',\n", + " '2694.103023697: rotate back_side\\n',\n", + " '2694.47624487: 39\\n',\n", + " '2694.47625201: front_side View\\n',\n", + " '2696.764118135: right_side View\\n',\n", + " '2699.238020818: left_side View\\n',\n", + " '2701.558969971: back_side View\\n',\n", + " '2703.594490524: Same Room\\n',\n", + " '2709.164569434: close to the scene\\n',\n", + " '2709.543072296: MoveAhead\\n',\n", + " '2709.544729486: 40\\n',\n", + " '2709.544734726: front_side View\\n',\n", + " '2711.292972631: right_side View\\n',\n", + " '2713.480317783: left_side View\\n',\n", + " '2715.821197395: back_side View\\n',\n", + " '2718.178809666: Same Room\\n',\n", + " '2723.177901066: close to the scene\\n',\n", + " '2723.559084648: MoveAhead\\n',\n", + " '2723.561170018: 41\\n',\n", + " '2723.561177948: front_side View\\n',\n", + " '2725.368555598: right_side View\\n',\n", + " '2727.57578926: left_side View\\n',\n", + " '2730.087023849: back_side View\\n',\n", + " '2732.185361248: Same Room\\n',\n", + " '2737.187182938: close to the scene\\n',\n", + " '2737.58039598: move_to_closest_point\\n',\n", + " '2737.58211701: 42\\n',\n", + " '2737.58212344: front_side View\\n',\n", + " '2739.599729455: right_side View\\n',\n", + " '2742.074073607: left_side View\\n',\n", + " '2744.270951849: back_side View\\n',\n", + " '2747.127306614: Teleport_randomly: Not in the same room\\n',\n", + " '2747.127311324: 43\\n',\n", + " '2747.127318064: front_side View\\n',\n", + " '2748.937527404: right_side View\\n',\n", + " '2751.457335342: left_side View\\n',\n", + " '2753.782599845: back_side View\\n',\n", + " '2756.258210957: Teleport_randomly: Not in the same room\\n',\n", + " '2756.258214957: 44\\n',\n", + " '2756.258221087: front_side View\\n',\n", + " '2758.202061658: right_side View\\n',\n", + " '2761.336225532: left_side View\\n',\n", + " '2764.130502341: back_side View\\n',\n", + " '2766.812071958: Teleport_randomly: Not in the same room\\n',\n", + " '2766.812076198: 45\\n',\n", + " '2766.812082408: front_side View\\n',\n", + " '2768.757369769: right_side View\\n',\n", + " '2771.075389212: left_side View\\n',\n", + " '2773.365346497: back_side View\\n',\n", + " '2776.190832404: Teleport_randomly: Not in the same room\\n',\n", + " '2776.190836804: 46\\n',\n", + " '2776.190842704: front_side View\\n',\n", + " '2778.130109375: right_side View\\n',\n", + " '2781.201741294: left_side View\\n',\n", + " '2783.649604268: back_side View\\n',\n", + " '2786.713781997: Teleport_randomly: Not in the same room\\n',\n", + " '2786.713786648: 47\\n',\n", + " '2786.713793068: front_side View\\n',\n", + " '2788.642736679: right_side View\\n',\n", + " '2791.039366366: left_side View\\n',\n", + " '2793.394092347: back_side View\\n',\n", + " '2795.71767934: Same Room\\n',\n", + " '2800.852241031: close to the scene\\n',\n", + " '2800.852245761: rotate left_side\\n',\n", + " '2801.218144795: 48\\n',\n", + " '2801.218152545: front_side View\\n',\n", + " '2802.886931465: right_side View\\n',\n", + " '2805.366616956: left_side View\\n',\n", + " '2807.647806452: back_side View\\n',\n", + " '2809.877229952: Same Room\\n',\n", + " '2815.013272413: close to the scene\\n',\n", + " '2815.355058148: MoveAhead\\n',\n", + " '2815.356694308: 49\\n',\n", + " '2815.356700568: front_side View\\n',\n", + " '2818.021619147: right_side View\\n',\n", + " '2821.147533902: left_side View\\n',\n", + " '2823.302243057: back_side View\\n',\n", + " '2825.910723899: Same Room\\n',\n", + " '2831.5996997: close to the scene\\n',\n", + " '2831.960163635: MoveAhead\\n']" + ] + }, + "metadata": {}, + "execution_count": 29 + } + ], + "source": [ + "# Specify the path of the save action\n", + "file_path = 'saved_actions.txt'\n", + "\n", + "# Open the file\n", + "with open(file_path, 'r') as file:\n", + " # Load the data\n", + " data = file.readlines()\n", + "\n", + "data" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/projects/ai2thor/team3/AI2Thor_graph.png b/projects/ai2thor/team3/AI2Thor_graph.png new file mode 100644 index 0000000000000000000000000000000000000000..4e9c7d520d3c479e753a6ae5074c9eb0bc8b57ba GIT binary patch literal 52211 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 Date: Sun, 24 Dec 2023 00:06:48 +0100 Subject: [PATCH 2/3] group 3 --- projects/ai2thor/team3/AI2THOR_Group_3.ipynb | 100 ++++++++++--------- 1 file changed, 51 insertions(+), 49 deletions(-) diff --git a/projects/ai2thor/team3/AI2THOR_Group_3.ipynb b/projects/ai2thor/team3/AI2THOR_Group_3.ipynb index b64d04b5..e3631d9a 100644 --- a/projects/ai2thor/team3/AI2THOR_Group_3.ipynb +++ b/projects/ai2thor/team3/AI2THOR_Group_3.ipynb @@ -2,16 +2,16 @@ "cells": [ { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "37da95xo4aTf" + }, + "outputs": [], "source": [ "!pip install transformers -q\n", "!pip install --upgrade ai2thor --quiet\n", "!pip install ai2thor-colab prior --upgrade &> /dev/null" - ], - "metadata": { - "id": "37da95xo4aTf" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "code", @@ -277,8 +277,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Accuracy: 0.8651685393258427\n", "Classification Report:\n", @@ -409,7 +409,9 @@ " print(f'I see {caption}')\n", " user = input('Please enter (Yes or No): ')\n", " if user.lower() == 'yes':\n", + " print(f\"The object ID {object['visible']}\")\n", " actions[time.perf_counter()]=\"Yes, I found the object\"\n", + " actions[time.perf_counter()]=object[\"visible\"]\n", " return True\n", " else:\n", " actions[time.perf_counter()]=\"No, I will continue looking for the object\"\n", @@ -460,25 +462,7 @@ }, { "cell_type": "code", - "source": [ - "# Import the house\n", - "\n", - "dataset = prior.load_dataset(\"procthor-10k\")\n", - "#house = dataset[\"train\"][11]\n", - "\n", - "dataset[\"train\"][5808][\"objects\"][9][\"children\"][2] = {\n", - " 'assetId': 'Laptop_13',\n", - " 'id': \"Laptop|surface|10|71\",\n", - " 'kinematic': False,\n", - " 'openness': 0,\n", - " 'position': {'x': 5.308516502380371,\n", - " 'y': 0.960530161857605,\n", - " 'z': 3.317396640777588},\n", - " 'rotation': {'x': -0.0, 'y': 0.0, 'z': 0.0},\n", - " 'layer': 'Procedural1'}\n", - "\n", - "new_house = dataset[\"train\"][5808]" - ], + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -486,11 +470,10 @@ "id": "uW09UG1P7tTu", "outputId": "09c1f09b-64da-4f62-81b1-bc388d142195" }, - "execution_count": null, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "[AI2-THOR WARNING] There has been an update to ProcTHOR-10K that must be used with AI2-THOR version 5.0+. To use the new version of ProcTHOR-10K, please update AI2-THOR to version 5.0+ by running:\n", " pip install --upgrade ai2thor\n", @@ -499,14 +482,33 @@ ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ "Loading train: 100%|██████████| 10000/10000 [00:01<00:00, 6818.23it/s]\n", "Loading val: 100%|██████████| 1000/1000 [00:00<00:00, 7283.80it/s]\n", "Loading test: 100%|██████████| 1000/1000 [00:00<00:00, 7369.50it/s]\n" ] } + ], + "source": [ + "# Import the house\n", + "\n", + "dataset = prior.load_dataset(\"procthor-10k\")\n", + "#house = dataset[\"train\"][11]\n", + "\n", + "dataset[\"train\"][5808][\"objects\"][9][\"children\"][2] = {\n", + " 'assetId': 'Laptop_13',\n", + " 'id': \"Laptop|surface|10|71\",\n", + " 'kinematic': False,\n", + " 'openness': 0,\n", + " 'position': {'x': 5.308516502380371,\n", + " 'y': 0.960530161857605,\n", + " 'z': 3.317396640777588},\n", + " 'rotation': {'x': -0.0, 'y': 0.0, 'z': 0.0},\n", + " 'layer': 'Procedural1'}\n", + "\n", + "new_house = dataset[\"train\"][5808]" ] }, { @@ -522,24 +524,24 @@ }, "outputs": [ { - "output_type": "display_data", "data": { - "text/plain": [ - "" - ], "text/html": [ "\n", " \n", " 100\n", " \n", " " + ], + "text/plain": [ + "" ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "please describe what objects you saw : bedroom with a bed and yellow sheet and black blanket and a laptop\n", "what object are you looking for? : laptop\n", @@ -547,18 +549,18 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASwAAAEsCAIAAAD2HxkiAAEAAElEQVR4nMz9d6B1yVUfiP7Wqtr7nHPv/WIndbfUEkqgjBBCCCwEQgQhogU4YGzA9thj+8147GFmbD8bh8cYe8Zjz4zTs3Hg+eGAQdgkE4URGGsAExRQ7pY6d3/dX7z3nLN31Vpr/qiqnc4+9/u6Jfu9/X333nP2rrSrVl6rVtF3/82/Q0QoF838gNInAuUb6euoGg2fDBvrCw1q0G4nueS4HbIyhFGjw7qD9icD6QvvNDLXYjfI8cfx08k1fUinPbyFy7pfg+83qdHXoXFdG5cbfZw+LF/LfcP0b9fN9BbZoHHrR2OjP5NPXU/jopNfXbs2GG+p1z02G9ydvMJsa8PmhqUHb2c2c29uqLtjmCnYF7l4WNEORPPsG85fo0aHnc4UO6WFm123NphPrY9P13VqZ/9lh/9MUP7Zz1GBgdLCvl5t58MpI5grY+O7tNPVhFqcfg1Lme3UmZKcm7Tw7MYwxsByEQh8Sp/PABtsNGn738l2vu1SuGm1Z4Pqu63sa+BZsKubN/pf6ppA6lzv0/f7FEa4U5VuZQCnNbMXG57ZWMh2703LZliz8X2b+zz+asPPe0aw89mmg5mZu/7imTL7oX70srdIg2bnfGeQ3c098zlLEEqF/Sg3Jsizve6vAzNYWYRbw+zR9Uzx+1PAj52u7FmNYN/1TN/8mTb+6a/SI94UtE9F1fxpLxexOZCb/drVt67m3qtwwptKpDPIYdMbz5qt30rJPWz1ltjmTTqw8RI8o2H9/xd0fnp77JfzFgnuXCOzTc+S4OlF42dzy71T3cxmCp1K8fcA1t6at8SyRg8NAG479JS+UFclWzD2iKM2+Lkl3Jqu1P4qz+ZOz3tvpfZNaMCQcP1nIPGfSnvPru4sv7NPiQ0+k3k5reAcSNxagzT5PttuxqS9XGYGyWz0J33eT2T2jX+ObeambuFFO9tfnmY/qG+d9dJO1bipK2A2tU7OVrFRt10fNrB+7jyGdbL+ZFA2oZG7TaOffsIpQzSarPWzhNtpzWfT0rPFXZqve2r/N2Pmt0Dcb37dqjR0K4xz8sBoTgybqz7iabcy8tOkxvGzNzz2bkf4wJPXUstExsTps5rBTMwKIBATFKZq6LwAVBBoLyccvMNUUDuV158iTs9X2L23S9huIl0MOdtp1w4NvPkaYn6xbxEObx2v9lPsT/m6xXn5NIgEMxP7zCS9vdN8+uCeBcnYU2W4DDZnRe2ev+Hxd1ORJCm77sjMzExM1UzMADiiiqliMPVNJ+adKDUzgcB7BYYxyg3/nkqldr/tVtmd7V0yNV3IAajsFH3W4DtX9Nlxwz3DvyXi+6w6zKLErRbd82U8mzeD2B3i+KlTilELNLjbr/98kbmmbOClPK234SsP/IST/4MyY4nVYJ7IE33w0jUQiMCdSEVgEJMxjAmc2B0sqkbV1BkB3HndzQD4kew0EBxPE6ksiXm9RHpa4Z3mbDzbNF3kXubcC2bzYrBN5MvpUG8yrp1vk0E+U4mzTBCAm/vTPnU2+Cng+80kj0+5/3l7weA7dQ9OlTp2vpzCc8d2+Vsj1HOrMWEC6SJCFiUBaFbQMrsjwNjYLCMgAGMCQNnUnqVUJSMC1NTjFIBK0Fcgew4WZ6oYDSvsLQaa4JLZBDl3y59249QxTdTKnRunVnrm3cz3jPH7jYs9i+tZsezTkGFfDev6261xGs7cosS02/CpA7PBz77iE473jBBwTxuTzpMFZrCqQzVV81OjAuapMhHUoAaYEVlXY6oT3kL0TNfXNMRp/4sNRtzd2R+3sK+ZU9bm0yuRPuua87ds8sX2PH12I5orvoei2/TerV8jWnLz8cyW65xsk8J7P437hqGXDHdR8VbAZGZE4yqns/N8fcETv8hEH7p0LYGxA9yIk5vBFAaAuwEP4uQyUwTMIAZV40Tqbkp7pt/2CwajQrvwN12j/WTsdHPvPq15vr1TjF6jR7RnaKcO5RYu2/P/U2tyz5fTCt784UzxJNc8w3a6lba9JU+lPwlaiiF0EDNx+nULjOEmrHAvXpcHnogJDnBEoCJamXHRnhzIF8eDmalCSwsEMMwxMXNmlzZwUfQdD3wVsKFHYvTXZrQt6zQ5Gox/4jgYfqSxHmenCFk7z+b6PqX4LXRxs6e3UvwZtjDT4qfrmjb1DGBv+HSvuL6vwuk97mGU+4ntTYrclDzOR1TepPu9qNxxCMREIAwBVkRLKn+o4A0FNYIxSEGUyAiTIzIQMYlCqUPCOaMGehyc86j1GNd9ng2f6h8McXTvZMzrgjbV5k6pu1voZpi312E4+XhrGJbpy80Lzld8JiXnwfxW2tlX5hZRd1JgzComn0/nodMuhlh6CmreAvLd5LpVWXRMNt705C+a4b2PX7HSSFQjwBExW6capr9mygRHRERsQPJHUOGcZOQIRDzb/R7hwgYTuk/IyEOe0p5TXnBsuRqtwYRsTvucXd290LV/sm3vl5s3fwsk/NauZ88DZ4B4X5FPidH2QDuDIwZM4mz3D3JHergVdofTycsQ7k4r9QzkgVmwiGqabhiCWMJAEJjhKLsNOXsOE3KCiQjgtPmv8y4CROSImOB74j4k89lu2VP/WW9BKjXPpHp2MLaBdrd3q9zkunnp3SHcavO3zgyfycBukSU+W8z4VBje5OF+0jrhODNfn+FVXFK7VWfEoO7jfuS8yRveqiy6+1KzA4QnimZqIDLHKGiV/RPZK5HxwZCto6Wp/vWIiGBI/n0edDD1SE6HMlyp/bxy7zVoe2dO907BrnlmTJ9mucDNzTPPmhme8u6nVNnHnfY9Ov26tUm+pft7RIkSk7l/gHu478w6zqzdnsp0WqlRhVtAvptcN7XsD593hd70xC8q8P7Hr3qCI6qZfOJy3cDSlOWruwEDNPdJyUVvZmZqUE0mnDEzLN/2coDu25BPDv3SA9ZoM8xw+q47SudpHGzn2enc7xkxw72uyd1WZtq9SVfPlt3drL09AH160T20v/v7zPTZHWq952XnHI0TevwsMSu/z/S1dkrdhBTtZfEF6cUsKjwDyLaZ4vQb+bvVNKF5gn/OBhkQwRHUzCz9NgBM5icIMgSlCTpOMXSIf8Mi+yOmT4Xr+XLj74NublL35tEzk0YmdqVTungGiP3pvm4Zk/ez/Ju3Mlj/U/D0GTW7Q8Vv3sKAYuwieXfjJki7Rxbd6Wcv9k1uRAVgmvgYiuOBOhnS0nDFjAHp7mXfPTFBOVVPg1MmUuKdTb3DV9vz9qM1nt9IMmDmw8ZOedkZ80z3ZHeEeyve7HpGpPamlPG/3GWncq78bepLmyt2GryNHpyy7Db3Z67GiLNmxWI8gDlz+k5b4/HfAvLd7OZcJ3ufl1Kf9+i7CfbBJ6+qmpiJwtTUTDSLmmoQhahm8wyIC4skEBEZTBQJCVVUFYn4ewCnMMPJvSEznLzFaL/SDDPcZWITRjtbfHZ+bsIM+95tP4PbfbTT67TIDjm/RY/Fp3LtQ4e9ZW+h8j7a/+yoyi6h3iXjsx+AYdjwLfaz98msLHrat+7WDJOYnzMiOJB0dpS0aynvTkr2l4STSil0m0BGAKfI8jRCKtwSRESkBlPzw352NcOBlXQ69uHuw4HoNwbz8kKzKG5DSRZ9bzsFc/zAeITD8QzDC+Z6Gt8/bRPkLqbtKznFw08vOt4Ce5+ywdOePqsh7H68CSbsu3FL1eZFx09JFt3Tz+TWnmZ2kNoRCHAgJHh3qZPE7Ahm5EAKAGokahk3yQjZiJqg3ZJSSAkvydC5KJ4RM5y7P2ljgk8lhuZUZXEX1T91ZrinpQ5/pjQDu8rkXmZ4s3E+u2uPdL/7Ajb5vltn5+4MLM7Wm3tus89PQYRdPjRjGZllVnvf7NnLonvefI667PSebxDhQ09crR11LDzRfgNUESlDHRMDprmMqWU/oXcEs6iWTDVpRdVMzfyUBfafRujZ7duYsqfuLfczw+mMTH2Qn05m+NSv/FySDTiTqOIkBToTFhMVKpWEgvy9+zCY+F6uIE43idOCZPKWP3OqTcRda5zvJ8Wg+1cGk9pK/qLOvJZfSbPmny/Nm2WKVGOQbOTuyuVHWSqycqezxHcm8zTHSZcv2nYHiqlU2gOedt2A0j5xWKHgQ/s7+p12hkzU7Nxrv3h30btF2/Pl9OsmrHRGFr2FsKFpnR0KMGzhCx5/twy+DkHUDApo2k6vJmZHdTXDZ82M4BJUdFwRhpGL4tPNDEeY+eyY4d5rLzPkkqg4IwWQtjsmoEzokUBVDZzIgKkhowiX0afKnMPdQZSsvj0iUYfTHdbl5zDK+JkQOIUwabpN5ohgUDMimIKod4USaAw8xGSa7yPRwjQCT6mkqaUN3clCR5rbyYNNOKMFH7uIC8kYXZ4WdLUOdzvLYmG5ZsgvR5QGbWkveZratLo3Yyw0ujNCgDnYf8ay6Fz/435uxsBHzwelFMi0Dxi+hyUrS55uGHBQ+Un3lPu1IWb0M0zkS3NzzBAZpfZGxsygWd9Mt3YzEtypzLB/yUkYyy0wwxJ8kDEkERuybo8zAFMzFEEi6cjIIgYV7ZlKPZM0+6RpozQRCcFhiK6ZsHX5ujnz1byIVNTwvGZqQ4Jjwzef4CBMemQpM1ZejwiqSKNNmXQMxgZNiGKmgOaFJiqNW7mZSHh5noaZOhrR7oyiCRYKDBf+PSAP1HHdxNF3VbJZdoXdb3u55a4sejOMGtbbuTlG2b1N5YdUAhcyaA4+mYHzW0MZZft8Joid1EAAc4GBtJ4FJPLO+r3McMprnjEz3MHYmzPDW3Pcz4/k/OvfcuVXf85gXGKHEh9DhsR+vrpM/Eku5cTJrJTLgmXRupPwSXnapQQ/FIgjIiIzZk6dssEyU8wIyAQzMBWUHw4iyaX90naEAQAl0TR3Taaa/mYMyl6JjDyURKO0hVsLXiT+lbloarRbKwIXFqdEqmBGXytTiQQzifNmtjeVZssyqHVBzHmR9q7e3m+jezeVK3fQ56buQZt5ttPU8NnnP/buqPbRp65y95A6Rji6UvBapIP+ViJwMACaPwOZwGUKOAxbK68wR4tGzrpd+rTzefhxdhatf7bb6lwzZejA/BR3j/N/w8NPHzPIFZaUcCDVL3oaMlkwmGIot8E6p6xRjrhNUmfhA1m6oH5SkUMlOi7HA6adEKlnFkVkzbe0kxoBKxEWBphx0SOTLMyZ8eWLqMfbZGxLeA4ih0JEACpiJAjcRxgTWZKYE4suN8uwqei6TMRMBGIGM3XCdpbM8/tZx19v4bL5RbTZEpiUOAWiTrs519Ec1E37iUV46WgywdLcMcERmPOsOuZ7z9bPP4oVk2fynLZJGBdBadBHyT9hyUVhnRrRfcnr8OyYof7/lBlyedWXPvfO6ycn7/3kE50mQEUATNjduRMLrpfvgzY7yk5DnSfL55aEsf3UugekXmy34YqaFUlz+FY7H6k0NuqLxmMtbH/ccSpZ1nvUYN/F5MU7sXzuZXbG+saX3cecNaKzn/PmHcKJjpjux88Z8j66sUcWnW33tG/DqvuLTPrJJKkTUqjoWvk+GVKytUx5OxlH0955gFKcGgwDswWDjE2VOhfFsLsJWA8xcg7wdzTDndt7NMOiFNGMZjjotc9ak9pKmqGNx9r1apoNpfaC59z22w9s/sTXftHly7/xDW/7wvbq+uXf/o+J2GDe8dlD55m2m2igxYJDsBDAZN4nBGEiUtGkdvvKaYxv/qwXnrvtzNWThqSpmcgtWth2vY3ijltlB9KwWi4efeppAGSmYkdL7z1XjhUqZhA1cLXwywWvFvVq4cmwOqiXB/XlS8fH1zfO+eXBktWabTQGMYfIYDp//iCKrJvoiByhbePS82rhDWZkrQiJrreRPR8d1AerynsWESiOzq+uXV0//eQ1EXBVtSFs162aGaEJZvDLA+8cXb62ds4xgw2VY4aKqpk2FlXQboMSlstqufSLyhOgot/29pdcPdma2gceooGdYZbJTBZ+hABzxU7DyVM53q4uOulz/6CGPQxKvf6RXwDw8aeuUo/z3eEXXaVkGzUmUoOaWjgmQGGinQUkp5wZmM0hYqbGewd62lR25Wz2PsbzPJmXW6KJEzGiqD5zLc6OBAD99gMP5ZpqaPR4vfnVv/N7f/KvfxNAamiDRrGqdsuFZ8cwYiaAVE3VRCxGVbUoasXqH6KcnDSebNvIyTbEGESMnVssXeXATGoWRGMUVRUVhQbRKALSJLEYSBVmCFFDFHLkau8qv220Dbmn0Mh6E5NFpI2mBGN+6ur6eBNM1ExFJKULiqrESRbKoiwBUS1EdY69935VidLJpomiohpaaTeSoqs2rQQlODpet5evb0IUU1ERwACLqmKaHM2mJmopQ1FoRQ1G9I//4X9npir2+le9TdSKZLETA7MHa+aXfwYUB6s7s/77oQiGzntSvvY3h4DeazCzPcMxapeYhaomUxnUEMyCmiiiIgiCmIAuLn0jGtSiWTCLmoDXRNUAxwnGMkRHgahJEkcH/GckhfXh2p1H8GbMcMK2TmOGw177zjqbhE0E4VHPvbV2eDtfF17/lqu/9vNphApTVVUNEpf1YrPdAvLj3/MNAL/jz/8Q1OqFJ4cYU/wQHIGYTFRMCdyF6GpUMtJoIlbXtAnWNPGscr1yRlRXXHmmym9ia4AlpRtqIIU5JpiJQkIik1CFKUdB26r3wLY9PgltI0ysRiEozNixgU8CROJiYUdHi7rym5PG1ECS6Kr37J2JmAVqW1MlNVZBG0zERAVK169vT05iMjwFMSMQsZhsohPVCvHgoAYhXo+q5liNSGFGcGRqpi1iMBEiIlVE4J9817fBOTStCQgWJf6+L3vTP/+ZX+o103L1Bpoh3d2PkqdKhTOPbOfjiMSfJm/u6XqGAcATuWLVBECAEor6nk3NKb1aLHt8nzgJiQ1a0cgZ5DmJscbIUhyTEcgx9TphHsZsyvrpk/7hWBQdPZxVMtHXsbJME/2k3Jvv8JTp7EeimjJ62Btf9RIzi1FDkKjinT9a0roJm234F3/uq6vKfcv//OMhiIiZWRSAid0wIXI2Z5ho4qiVp6pyS++un8jldXtn7etFBWIQnGNmZkCUjExUmYgXVNWOyBAMAIOYyTERUYx29XqzrDkGXW+Dd3xUVzCAoUaqafFMCWp24cKhYzq+sU0QoKqHS6oX7AmNGBNVnqOoYyJCG+XpqxvH2G7b43VbVb72LjZiqlEgBjXyDBEw0blzK1G9evWEAFFbORCBHRxx24iaMRNTtsf80Pf8obYJ9SEg0mxjCCqiKKrtLgTPL9RwzWZuF+fjXJVZMepUAXXYzY6Id2pLBnzRE+8G0XsffTrbhztWlM1aZgkPC3gmIZMZhJzPIm3DJyKXtOaCyYkbJvVw92i0/SPevT1H4aaursHH4mvpSE6/bvNqgk1lg763CcXbWYdkD4wiv/rB+xeV+4l3/8qN9eb6ZstMhwt/sHQqoW2af/qdX/H//Z/etmmljYhqQS2ZSQGQz1EvKqKabZeVw+GBO3t26b2LotI2YdvGEFMBdkwE5+n8xSPnazUiMyJyrgTQMOqKHZOvuF66quIYpGlbmDKhXvp65auFM0aQqCqVx6rmg0W1cExq7HDh4qHztRlzoq8V+9o7dp55UbF3VNVusfDseLNttttAQO15dVDXK08ViUlUBVld0aKi1bJaONYgvqJzFw7IeQM7gA3McC4HAFWevacf+mvfvm4DQ0CKGAFdVBxEL984IQKxTaVR6xdzZx27jx34dGKhTaBmii1TqNsDeXPX7vgmf+ZMsglbyEqieyvhDZrMLZoHfPdR7Yr/KetBuTVKTiMrXRigpmkrhuSUh9OJmSNPOyMcC9w7dCVhlnUlh66Pvuyoxp6F2ntzBw+7IXUxLKqmpsuzr6x9ddedF4zwR//6v/5jf+OHKraDZVU7ckRHR4c/8Vd/549+99d89EM/QeCoMBAzMRG4zDWgZO958GFVve2Cv+P8wns2gwChCc16C4NzzgBm3HfPc+rKrZZ1XXsCTAxE3hMl+z4AQl1XVeWrhQfBe7dY1L7yIFy4eHTh/OGy5kXFjsk5Wq7qO24/wwATOUcHq3q1rJfLauE9A2aoPFcV+8SHHS9Xi7qu6oUzoK79arX0znnPFy4enT9/tFpWtUvKCc6cWV64cGBmIuodrxZ+saiqKonPBoAds8tqzA/+tW+PUcjUV/Ttf+bvoG3ryvvK/+C7fvkn3/MblA2CU4Vj/G0MAzYH8PMi4c6CnwYpOzT9dKayp6XUSlALSQiCwfJeXbMU1mdI/JAHwqPhsZO2YGXvgVPrthEW63NhiTSMmBkJoruSZK/1DXW1XrLs2il3Z699mqFNZM1BD6MdEoMB7dQZDKgLFv2tj37S1EyNiDy7xcL/jT/+VZ+g1/9vP/KvH/zEB77nD31FNFPg4OiQzB74ke/94b/4tqYN3/43fk7VNMSk41DKRwCAsdm0m3VYLnxVO2wpitbOhVaMQSrMLCreY7tt69qJsPfGbCqonMNCTOAdE7N37L27cdyosa88sWubRhTsfVVX/rhJVFZMiaCwRtQzE3Fs42LpCFVdk3cMgJmWC2sIasyVX1S+CfHGcfS+JiIRDVFqrRaL+sC5q9dOKBIkv1gUhSMjpGJVxVD1DmykagTUFTVq//Zv/aEmRANWnr7tL/6Db/2Dfxb61JWT7WpZIxnliWyQK6Un0RMxaR92jZBzvJyTOvvY4N5rL0fZ2+zgUrGPPnWl2BeSbTPNHBLZ6fxhUpJcJMuLDlhQ+umAmAkgo966b34IyoPPQzybc1cMv2S8nOBnQe0SIEY7rRbs7h0gc4RgfE1Gs8dCc/5z33Ll195VpoHM0ASRNIFEDzzy9Dd97dfV7huuqF76xL9/xeFB0vzq5ZJABv1n3/mlzvM3/6WfShaxbDg1qNpmGx5/Ynt4tKwrR861UQE1USi1TTS1TSMrkuPjra998mebaQwwhWMoKUFV0DSBiZpWYXp0ZrWo62vXTA3rTbvixIHT/MjqoE422zPnVut1c/X6plp4JnJMBg0hefPBpJUnA0KQEGS9kTNHi4ODSsTWxxsFtpvWGJKsLmSOsTpYtEEc+6PDxfGNzfFxQ448jJyZWdsKyL7vL/8BjRKiiMgf/1//2Re99r7/9k/8WRBBVNW2TTBzxYVqh699cwfRM2LNDmfcd9ncxz1o0j+2uVI3ZYM77K/8NXvdI/9etL/DOxXzhkGDGu4+rIs1lpIIpUZd2GiC/oSxaj1pST9+wMzGW1jnmGGxTaKEdw0KDsc2RpYx4hbO1tWb5WjDmhNmuPcEmiEf7sOiX/3C56UN0KZBRJlIRFTMV2JE915cve/GS9/1oz/66EMf+l//2290VeUlCMiAH/iLX3VmyV/xnT8mJlBmzyrWBt1s4iZsmkaYyYiPN7JgYjNTc8zrVuGCGQ6WVYxyfdNULSRq1gxBTFIt/MXDqmmDxlDXvF03y8pfOLvarrfr4+12EySqmakoO1pWLplGfEI24MxBfXKyffpGa6ptKyA4R6Yg5jNnvKls182yYpPQrO3C+UNW3W6b42ttUEU2z5pnOlj60Ip3ZKZR9OzBAtBr1zfbjSbG+GN/6w+HoBLFVe6P/43vf8fv/dPh/h9iKBFDUuieKYz3uhBmVij/nS88YwM4ldXt0eD66nMd7vJPm2/KzJLbybIUmpohHgJjh90EAp48CUiSWMLRAZAmBLLk2C2mp7Qlf5qBe8wMJzenRs5eEJ1jZwVXZ8Jkus8FywY15k8U3S+UDoPL+2c5LoUIavqBjz3y8nvp3737P33mC54rIqoaREIkqD3wwCOXFk990Rd9RYxf+ouP4Zf+wzv/5Fe+GkxkbCYhZslDTMkgBjGQaeUrJoGZSAZAU/OO/MK5k6oJkcDtpmGybatbYo1QU3bEjpl0ae15cdqS0+jJb47bsG1WtSciZm0lkiPHDJhGaBtaM1O5eLbyjmKUuN1qG683BuPYihHIAURMODSV2Lab5uDAbxrdxmChUTWAQhPaoOzApiEEQxWasD5uVhWqGo6o3TZkcb1porJGFVGYEqyq3X/3vT/+jt/z33z1Sy69834NKp974fFf+Y33O8feDwWXAUQPIOgWHMP7nu0gxrAl27k5X3za9wjNd/F8jK4fvnSFCVn+TOG36SoMMCt31gmlRkaa96alWP0S5puOgEkDLd7rBLc86DiVHdKlftgTE9V4Xk81qeRed199t8G5a/bBhJBZ93v4HkkZtPc/8AiIzL+0jcnvTWr2gU9eaYM0MYrolz73AYjC1KseeP7g5lXf94tPfvc/f1dCYAMU0OJe37ZRRA4W7IAYRATLmirPasZst12ol7VTtYvnF0nsO1wtK+81GamdI5CaRbHNJrDD0ZkqpWYW0baNm600rYYoEgVqBDLBtomixp6Pj8OZw/rosI5R2bnVYgEAxC6FuhhAFIIa6MyZ2jkSBTGFKG3Qk3VsWjEzqJmqClRsuxHnXVSD0tmjBcyiWOUr55yaggEIM/4ff+cnF4x0ooIaiUgIUY3U7LbbXkuAqHaGilPWcsiV5hZ+wFXm6w7anwHJcXu3zgZ7CBpdn/3guwwJhJJTp+APLKhG0VY0qIpaVJw/qBqxB280US3Z2FvRVjWqBbGgGszETLKlx4KYKAxwQJV2AU9JxR483Hm12ZJz1SYTNPvaexC+/7grqthgdndW9bbPeyt1bDbvIrDz588xoKIECiKqyp4l6sNPXDuo+WBBd5+tPvnIE6989Rvf8uV/4H/7ifcxQc0EpIDkKAdrgzKh8i6FEDpHzFDTpmlNtarYFOfOVs+9+8xqUaWjWBfLmr3LKGAGYNNoUN1G27QSNLJjAaKaCFTMBBqUjEzhmI4O3Lkzi2rBywU97+7DOy6uiMjIfO1d7ZBDpQCzppUQTQg3NrGJkuzDKarDlMjIgpImBdWtlu7cmXq18r7mixequ+868M4ZETn4uiJmRP2T/+DH3vIV73j+bauDin71fR8ShYoRtFVhRoz6xa95+TjO99PEBoeeCeuBdJbez/ZxU+o9YIPUC3LlItjAfZfiL7oIezOzFN/EyfebZdC0hRvZt1+i/wFoLp+CvFF7OE6RIVCAu/fcx5PHLzBFntl5mJKbATMcYecMd+1KT8uOJq4f4ri9yeAoC2mJ9zOTY9e28U13fcxERVTN7vnMt7mDSg21p6Xnu87WX/OSx1RSzKiyIzA5x+wcETO79z7yuETdbmPlUdXegCAaxVSx3cqlp7YpOfO5M9Vz7lwtF05E2fFqWdd1laagqrxzjsDrrT55pbl6IieNhmgSjR0ne3cMEmIkEDuuHK+WfLCiO26rzp/1z33OwYVziwQNyQMBIjN476rKM1OI9uTl7ZUTWTca1EJUYnKeiRBiVDUiJmbv+eDAHR3ShfP+wjl3+4XlhXN1crs74tVq4bxLviURuevssnIkone//GsNZmoxRucYBFFF2otBg5WYBx7cEhu0wf++1M1wbAoNXWXb6Y4GitG0qe5z5ZxjtmJyLH6+YlSxhEVEhLuOaiJisGP2KRIjgx6Sc9EReaaKuWaq076Kolgm6ultoLmNgl9mLTTdTA42BXxKFppht8Nm56Z4R/8bNWq9elm6LvP/0nufE0W89XsCWwlRNMmsyggiADlPh2eP8mFxakl0XCwqX3nnXdvEZhtE1JgkCsMtPW+CqQocJ3N/CKJCgK1PQrOVTRAQHNNm2xiInYPZ4cHCRIKqicBQeQJ7M5CjpH6YQtTgTJx6R5s20kkTW3amvnIx2OXrbRT1zjdtEDViZuBgWTtHsW2aVghuUZGymSKpM6qiqlGsqpgdVUaicvX6tvIEFe9ZzU427bqJxKRqm6YBETG/8U3f+Ls+8/jfHR94xwRVlWgURAhgRoySXBfJWocRGtwyG9xFghnMyeu/e/fW2eCoQM8GRmNJ1xc+8W6q3HsfvuRAWVgEaefaLKEzRHDOV44BXFqHBSP5A5RT2AKpaadEFq2yMFaDwtJOsb0n9c5gRLGw2LwdtbzVs7LQjL93tXerjIyjlq0wkw34oIH1Ns3FRx9+8sV34Wfe81uvfsFdXDkTa6KYA0y31EqIYuZAZ+/5HVX9USJyjr/g879G4/3/5rve+vv/1n8gZpiaskSyvG3eEnlDCp0nilEdGROJ2FNX2raVpP5pVANiFAIxU7ONgC09MVBVdnTAznkHU9G2FYJJNMdMRKIiClmbEdGy2hxvlofVphFRDaoxBiOSJOWA2qAUzQHEfLDEsnYwUpWmidttG1qRaEysBrHsBJVjnD1aXnqy8TUdb0OIsY3aBAOTiqnpn/n//Mxr3/D1Iuq9F8CziUYFqSiM2xa/9cBHKPnKaMS7dmCpB/QZ8WbOPjKuO4djO6h7UzZokwo7nXafV7Ur0WcF0gwEKzFocFTs8AQuiEWc8n0YQCWWL4EodXs0s8/K8kFORpQOCR0MfSwq9DM2nbnZSRgU3Ftoonx3BHPPpNiw1M7n+Yf9RUxMIMYDjz1lZvDPJ5U2SBNELUZRFVGTD97/sABNK22IoYkPXts89OiVMwf+zGH9ro88new7bRslKIy8c9WqWhx4djh7wHXlADhHILRRVbXyRKAmpnAZ9syhldiKRjU1VQtBiNjXKRCKYtQQYhQNAlEkl6CIqCEES2xGmgDTqsLB0q+WFUCOObTSNlGiqsIUbYgG+CpBAmLUKDFECVHbqKIIoinSY7sVEWJ2FoVMlzWvVn658DBiZlULbZoYe+Vn3HFmVQMWYysxqoiKxSgp6CpFeAPJS0lnX/fm09igTcDnvwAbpF3Jc9TULKwDAA4qd1BXvfsbWdtL+3S5KHGmdvuqEjM1i6rbKE2UdFSTWY6rETOFJp1QS6hNv9sa2e00HM9ehLC5CbrZZGEfekwLDLvNuu9c08MOJmRthNZZpbzwuV+aOKWYEpOomtFtd1wQURP9yEPXU+AfG9523ye3zbbZNk3bPHHpKVXzsJWni0e+cqaizSaEVmKMMYSoevb8clG7ysWlT9lfsaid9y60AsA5VsNq4QB2jqvKM7Njdt4TOzUTEQkCmCqCJWe/1RU551RhjKBy0sQb67BtBQYGYhOWC7dY8mLBZuSdr2qfosq8q8CsplE0tinMFQISU4P5ik1NBEF1G+JJEzZBAPKOK+awDcsFr1Z+WbMZeXbee8fswL6q7jrja28/9Sv/yd3+xrZtHn3quqVNhkEuH2/yBvudJehv2fDRTJEhvHz62CAy7j1DNthdX3P8Hu/43R95OHF3URM1UUXJnceczSoCjqKi9uiNRlRNtXSslHIsEBzBgdIu0PTUEXzOlQCGpX3348mYvvAMStn4V+FxM/N2C8xwp/Vxz/NEczeod4TF3euYJGUoUabktVFst+GNd31SYxQxFWVAVD/yyeuqBsXTV47NbNM0m+32xo0bUDVTqDnPzlEUaRo9WYemiQZzUAKJ6NGhO3N2mVTWRUVMCEGcgyNa1Fw7Xi6qumIiWi5rIpJoaolXkylMFWQgi7DWqCW3DRYMTBTaqCIw2m7CjRtNsw2O4QkLz7Xjg2VVeRBhUdcExChIIdgwlZwLRkxbk63aOtqmFWbv2Gk0JlK17TaeHDdNI8RwTAvPtefVsnKMa9eutU2TWG2Se6MqVNeb4IqOkGZYVDPptH595q//QmxwdGOfeIUylnEBy1HZ/UGCJRdJdpcnDckSKjoCwzjn++i0tX7IybQuZqIWVYNoHDh0YOZHbnCbtdDYIFJm6DYfPBu/9mzew9IK+li2cVDO2EazExTwDJXDNPedy/75d11MHvxFXYtqisNRUyIc3ffFYr+dQzWJnXMSNYq6tIPJYGrsYIqq8m2wGPHEk8caUVVmao4oFap9DWdVxQdCNwQhSjIVEaiuPFMaHbFajGqe4bBYuEXtpEmhZwYmV/sj59TQtjFGaUUPD7x3jh2JYruJAgCkgHPs2DlCK2LGIUQRZeeYaLkkU2slwY2xZ090tKhC0KYJACJ05f2iIgNENWy1jeKYghgzL2vHBGtt08pChJlNYaYo4ZHv++iHFEQqRHWXlXQC92MM2McK/3OwwdzwHn53EzaIsgu+YFLJ1WtEnILOQEiZvvjeM4vOP5rSnWhJi5h+MVPhO9ZfAHcbnAB0W5nGwxpN6gxR28PohyVvxW2Yqw/mdSyW7punvq3Tl8OAYjVmAh66dEVVjtdbZlJTVW0lOX90sfCiGrO8Tt/4mU9I2prERIT1OoRWYpAYNEWZbjfRO4tRVMSxmVGIMUSpFt578mwGqObAgKMlLpyhM4d8sPDLyiHjP0Ss2QZTdZ6NzBQL7267sLj3njN333l0/szy6GAJR2JWL93hUc2MbYgpzIKhFw75jnN89pCXlSOTGCKZiWgQaZpApMV2YGcPF3fdfvjce8/ddtvBalk5JgVcxfXSH56pDdgGYWIiqh1uO+svnuWDJf27/+UdzrFqTjv1ugtPmJGZvvzM4wBMrVp+JgGe2TFXzs0v/fzSfQpscCTv7GODNrzxjNjgV13/ZTL87Ece0eLlI0AV3a6lFAcjBoMm1/wjx1uBSabiOWEYJctniSkrkSMJqfOLdsel8vTd52bQ5tDIRr/Kc5s+nMxERxKTpclGtSY97HQzmXjb6T2/S/c/z4uofOKJywZEesF//I0PtiGm8I+ERa1oCDEmwRV28JwvFEGMolBTjSnSQU1EQhtN9Tfuf7iJFkVD1LaNiXiqEcG22yiikrK5sUvxoo6j50gaENuawtKjdo4dqUKitk0wUiaICLHUFURkvQ6mVldcL/3B2cXRxcOzty0v3rmiJL8yMcNR49BKaBGbCrFiOKIokoynMQixiQrMfIW6prYJm5PWEfmKlwfVwbnF0fnVhdtXZ84tkbZ1OK4rWrjgOWqMEloAMD3ZxmTBS6JUSbBGKvbqz3ie5pOJtAOV0dJ9OtngDmwaAWQ7fvadQXT1J7cnZMBgObaMAE0p67PZKbHHLJc65sqxaJcLGCUMAyk3ipmJQdSiaDSLZqr9ViYtgFzCurqogCke7FpoJgaXvcRmdsqm3v/CpOcbtOmtftbMxpQxvcl4sINqF17/par95suoSkTPveeOunYq+tEHrwcxFf3IJ5/88nsfjlEJpmSfvLGOBhNd3fmFEvUn/uqXm6ipkimbkmmItm405STzDHYcRVVss5Fm20oUJjq+sV2vW8cEcNNI3oRueaWZ4DwjRbTEmAYZRUTk+Ma2bWLTtutNu96GqMqM69e263VYr9urVzabTeMqjmKbrTRNjDHCjGCqwkwgErMQJYqIqqhJVFU9vt60bdhsm5N1s20lRfmcHLfbNm7X4fj61lQXtYuCzUZDKzFEAkxhQFQFQZNzQ61pQ5r1TdMmUUJ0hwntAY8JKe0f35wNzpJ1G4lR0/9dZ7ZTeYawW9LGUpJLAoBgppoyt6OkqiAiWrdy+2FtBkZKLQmUPIgpMTTDgLzQnO9kCZc6L7ZpMqGOxNHpm9roFfvpKtMzy9VPE0ptSqVGqDycTRvUmbDhXYowrjN4bADKLKSoyUy2mfG2lzz9F/7w601UVUWwWPiPPXJsBobB8MlHj0WhZr98/5MaM4EEivfRrBVTJWQA5DaiaaKIxqBRhM3qih1paJttE5omtk2QEEIbTWLaZOgcmFkUxC6aGagN2GyjinpH7L2CHPj61eaxR65dunT89NNrz6g9mYTN8XqzDjeOm5PjzXbTxDYCYiRqQmxRFIaoqoao1AYLbYRZVbGxY+cs6lOXTi49eXLpqZPj69tlzY5NYiMhtq1sNyGENrE2NSNmqP76b39wee8Xff03fV7M51SQqX7kkSdKYtLJes4gX19gbgVnyvbfbGbFhzeHnZ2OzLPAMyhAsJ/76GNBTS2hDcSQQj3FIJo3CjqiiqhmemrdcNndQoAnYiZHGeo8kSdKxhtHYCaH/JUJKd0CD5L/niaU7qNyo/kaUqcJ4tpo+gdrtat8djN+Ghvuio9W2nYep7t5ky/dc/GcqqUj4ZI4+o4/9hfv8fffQx/7zOfdyUxf95LHv+FrXgHDE09dTYUSo11vGuu8rTDnyFeOi5oeo5w5qAQsElU0RDEFYJVPwr9tN7FpNYpGsRjFTD3balVVdRWTxCKI0aJZCHrlyvbkOBwftzEoQKtlTaDj4/b6jc3JpiEHQE21bePxSbttYhs1RFEVJqucrQ7rKLZtYxMkRgQxETvZxKvX2s0mbtcCw6KqnOf1STg+3p6cNAawp5SEaLsNm620QWLUZDkzKBE+/46nX/fKl73p3mv/1Xf8D6qm0WD2gQcfydMLnPucLxmv6/hnzzVkg/26DTxUOwLaHDyMUXba/vTJroLZ//rqa7+UPqkipKRpYkG0VWvFmiBN1CbINgoYRlBAYJqYG+XlRlH+DKZpTz0glpTGvHdpiCdEGG/qnbOUDiJgBobNzmC6x1JaPttcOM3wo5US4/awE7FTrKHp4SQUZzbuzcr5DQU67IlrN85cpJNNA6iBX/bKL//Y9siBPNMLzz74q0/c/f/6tj8L0J//5te/Hpeq6mnA+MxFUbXsXbV0OmtVuRhjmlARY7Jl7ddNJCCqOc6ir0awc6YKaN5WRVAjDrBaDs+uYowicrJVNVo4bkOsmdiiaSRmEAk7U2tVPFMbBS6yJrCn5DSXzNuNVIno8JwX0xDdVrDZxtr7tPsBorGVGIWYARWxbZBoZGJLkPdQAbNXiSo5FYOofdXrXsF8le571Xd+78985evuOT547Zu/+KuBK8wk6YiNAUacZo8ZlBrLPDtEeVJp5/PuzXGzM1T+JmMbNCVqAutAnIg0J5AplIEUIDK+87CW5PDK/DiXBDLIIacX7a8CilBLu3v7ieCRDDEe1j7js43ncUxaBvNZWNVYDDXsaXU0HzuNjf6Ome2AoE7fJr+FwQyPXb6uYtfjvR9+4FFVg0HNmqBmElXaoI9fDV/7tm/8xq/9xvc/cima/drx5/z6yev/8g+9F6ZACuXNOmimfMwpCee2ic4xO2YmZmcKVT08e3tKuJhC8FQtRAtBQ5Ag4hn33L686/bDg9UC7Lyvk/SbAy00NYzk/wUxMYuibWPakSzRRCQE2TZhsw3bJsQoAO44v3juHQdHhxUR+apWo6ggohgl5fjI5C4fJUMKRFGVfBa7mYlqFA1BxfD33n3FDD/16+9/y1u+btM0ZqpqC8+oFuTIOtP7SHLpNIghjg7wZbhWO9deo/rOfcvIMVzruQZHVYfC1gg2uwI///EnJHnLCASrmGpHC+bawTt4ZmJO4WxqePzGNps7Kbng80GijMwv8rwYkE2sVtwYxXdtMBvtJ0zD3H2T0dzNMPkJW7ex+WT4bKy3DZFnfrYnvU5Q1+ZKTvDQcOENX2rFfpPjKIjqxVLNosQHHrmRUibf/9DjZDjexCYIEZnq+sbjLj719Z9/L0reGrMULs9K5jw7TiHStt1GoJxM4ByIRCQ71phAFqOIpoMjObluT7bh2vGmqsiMVouq8uQcr+o6GeMMMBFHVlV+taodGZH5imLUaAY2hbRBtkEUTOwMFA3bKJdvrAUxCirnFxU7olVdsSPLWeqVoVXl6lVOE+U9mVqMyo6IEUTbINEI5H7yV3/rxS98vmg+j33dRkAJypzyDTPlzdNDAWsvoOx3S0y51riNcYMFecYwOjUiThvsAHPv2ADgbZd/gWBprwMTaXeibtbiqGKuHFVEBCOgopS6EgXXMpFOwIZ8KpOhoAJl1ZG4nN3bCYNz2dYG2AHbGfroYfe3rzQlPDvXLB6OqN4uw5t7NhzQ6OMOP0yiuWTTszK7HMeZbKamUBPRL73vUcBMzM6+9mqwGLUNMRy+rkRIgIgU5ir3Ww891sZoeTeKmurhwq1qX4J02UAxChFFsRhTcjszgJg8OzNsG7l0edtGrbxTNSKqPDOTJXskmYiArFp4zVSZiGixqB25GG3bxhBFxJK5zjGbWoh65XrYNras67TA3jsDNKqaqamKkkO9TMlmlUFEqCrP7ESsDZKIRYqnUjUR/Y+//VE5//qclk9NVJs2GEDEWlZPhxrd3GLvkOO9XCv/6Wi4dX9niTqmf2YkrPnmp4WTR0Etm0yAijiFYYhZzPHWcCA1u/1woYbHjrc5kMYIamIq45RqrtjwUk/52B105wuho2LcjW/MZEZEaWiuHNybzMyuXr47ZbsEcYA78+g75c1T69d07IMxlytZmBm4/cyBFEeqwb72FVc1wXzK8Gv66NPryjEzg91jlzdJNnvvg5f/9Z97U2qXibx3qipiSOm6DTGoYxwsubwhmZmqtCGGGFO4rwEJEUKMMSoZKsdktlq6c6vq/IE/WvHhiivHZDAjMMNzE9r1tlEzX3O9qKrab9t2G9qiqyBKDDFsm9AGYeBg6ZjoYMFnV/62M4szKzpYgKCcEsYxu9q3IW7b1gj10tWLerGs2jY2IUSTIiDlZPti6uoq5eSoHIPwO+65/t4PfwimTbz7Jc+5K6lKnRq/j9VM8GVMLguGTSAur9vuws7cmKP1BUxm0HUw2sGQDPZ/ffKpDC1dPBoByWeY8h0CVk7dUlA6ATIZYKRsno6KKIjS7aA3UYumrWpQS/791FoXbMT9pO1QpyHnL1g3eRHAeqQYcqqexe3Bw8kszszYyGK2l0ZMEX+w7l3Xye3DRGZ2+foGpt2hC0ib95Inh9MR40xMi9USRCoCUzAlOdRXvDpcsnfpSIYYxdeVY04nT7jKpVgcYjBBRTUJIUygbhNnEoqR7KghCJPVNR0eOsdaVXCcRRpXOxCuXTs5WW9B1rYxvZakiFPHIDBzceXl9kPU0MS05WK1JKLIrGo5qtvXzghXrx2vNxtmtEGSfqPJjGDlA6CaThS2xXLJjLxn3ExENe8KSOJ33k8+sxhzANDBTAbnydr1pVOm3R2k3QtLE8jalWx30HBc4MufeldFSGdIwIw0D5RyziYETRYuU4UM8qWpQdREim6Y6H1+lF5VNS/pTLh7esCjqSsSfnq++3LDB3PkZ4fPDd93PHfzyDpZsQEe4hQ8nLS1U+niG96ahPenjzdm9uTxHfc/8qQlaZSsjaYKPv+6rZjCJEqM8tgTT6XzOCntRHfOALfwIGs2jYgm2YyY2RHBQojsyFWsKsTKDipa17XzlXPe+7RRO6VNS8FMpkGaJsQQFeo8M3PlnBKMsTj0y4N620YoOeeIuQ3xZL2NIsvlwjnP7HxVe+/IpZS/2Q0jIWy2bRujQckjZa9XwBjLo3qxqjZNgJFnT0xtE9q2MbPFonbsiZ333jufMAvkoSYSQoifc+5xU4ho7KLhzdoQc6/jpRqDCTpKbt2KjBZyBCFjJJks6BAaht2M8HunRt+9dQVGjKMvE8RUTGE5uKPrsxxKGaLdeVgDuHTSZJGydEjFJJOdhJa909kUY50Iap1fsWMuPJ29KTsbAnTKaVqUgCEW2KTy3ukbNrdLrSY0L0/YfJXxku3Dw27g/cnPiSgxuSrpg1EEUCNsm9ZUt227Ptk8fenK21/4mAHMFoO0bXTeLVcLIpRQEgtBYlRROGYziCgzVC2KAMZMxBCzKHmHu3Oc+IxjXi58UiejyrZp15smpREMUcFYHtabbbPdBBBp1LYNAEIMm21oYyxuQDWQd44JBK5qVy/YVEwtxJispqnNJghXbnVYHZ9s2iYCpGm/MCPJxmoaiz5DTMzunf/z19cLB7KrV65vNhs1dY6MTESzaG/2iSefThGRZ1775uGcD9WUGfPllP3NMCebfrOdFTb0JxHvQkPf9Qwkow9a6Z6kmO10HJAaollMAWgpA4Vmx30CnrInR80siAaRlM0+aE79lPyB3e7BIaXgtDURSC2kd0k6ejnRb8bRlz5Y2egwOmTeBm69Lp1oV7wUGrgARw/7XoZdYO4kmb6KTc9CHDg5552H6NC3bAGhHNsFUSXYg0+sX/GCs4A9fW1tZiLimVRVREPQyhOLblpZePZk6sg7hprjHJgKgvMuGZ+Xtds0MS0PE4WwjaJV5U1ywcqzmPOOXe2NTAFVIsh2Exa1N8Kq9stltVq4G9esYiImFcQQnGNmF0JsY6y8d+xaUUCZqa4rNasqdp5EldigEqMYPBMZdFVXh4c1HJmoJzKiqJAQAVDlmmYTRZg56awEpJOeYhTJMe76vk88GM99NknaI0fE9NHHnuwcXzvKfEd6dxFshBQ7VnmaIOCEnp7KIWaQGZMi4+/d9ZbHf9aI/8MjTy08M5OqpUx3WbhUOCLHpGYXV1VUM0MUBUEsKSsgMjXKMgJlXFIoAZ6pHNicuWpncupG0u2sH+ipE3pl8zTFxl+Hcz6dq2HV4S/DoOCorPXFhgs7JpGjPodNzfDDvO3N9MLBIoqSmakQ7O2fdTnEdBKhEuGrXnwpWbyq21//6HGzjTFE3bZiqnXtAKsrt6idY1t6ODJVdWzOUYgKwqKiynN2IhKiGiif3eMc1RVVNS8WDrAY0imG+czt0IrzzGyLipc1e8bBghZOKtK6ApERrKpcG0LTRjVTFXaoK17UvFy4yvM2yLWTpg2aUidoFI3qayayw5Vf1FQxDmqqKVbOvANB2JH3Lkg6w4rMwER1RYuFE9U2mkpeoaROZ1NeomGUzYmqQxCY/Ygsf3QrPhFxgLJdYQQPIxCYtjpFzykMTGS1gYlnF8FTCAgVq0F6nNI1iRkzVUwGXN+2QS2oPnp9EyULOEzmiBh5ey4V/2ARvND97/hnifE2Qwr9sMExYLskZw+Fy62OUGnYxBhn5r+PK49V6vRZd/BwMneYPhp+2yEmxRgAwvVNa2IgVs0mZREVMYa1rd7/+AkAhTmix57eajQ691oTabZhu25jFGZiJnbkmKvKq4E541rbBAac98TpsDQHQ4gKg2PH3jFTF8yUdqkDBiLyLKpqCCZXb2wuX90YOXLeyAARI6qq5dHy4GhZe0hs2mZDFhwrOwsSg0TTCCuba8nBeTBiUDFsQ7h6bXP9pAU7OJdAIsKtjlZVvUiJwaOImVWVc9475hDFjJJABRAsB9JEEXCtUQt8DJWFNMWdEbFbibKmU0Pf7rWjGu0HGxuVGiPpjgVxlg12zSaUcIUPJ2zsXinlyuLcrjmiypF3VDlaelo4TlGgnqliqhwtHHkmT3Bpz2y5Mqjl/8U7BiDt0izIOqY6Q3Y2nqFd5mbTMl3lyVTbzISWn/G0Ylp5yGj3G2mmYyit3PEFX548FZePt2oWRD7xyCWVfMxx2tO0Xb2y1TaZutLuATVNe6I/+NiN//OPvLZtQttEMxDRr9//KODYO0vnkIoSETs20ZwuTe3O2+5I1jMF1Egi0vkuzJZooIhFEWLy3jv2znuN0my2zbZpt43EKDFG0eRv3Gzapg1qiJJYFEUxien1U7IMNdM2xCjRe2bnmR0M7bZttk27bWOMlsLVASJug2ybkI4UFjHHzHAiEKOEe6oqQDkSTNU0ijQhhBhNc6YwmoDNGFQ66jd8uKfwEDN2C00L7gDL+AmNC0ybHQOM2q8/di0/7q392edrheU879zBoXcLxyk4JmU3TNEzTPAMn8JrHC2Yak+1I5+MABOraBJaB6/rE3MYzAcBo4yGw/zzKKWtDyy1iZ430s2KIlh+Bs932kRpcHBu70QhHJwYPHeQfd9iN4ZUrGvCoDAye3pzx22Hl0TUnAMsqNbmAIgixHS2Ma4fbwFEjR5cTijU7PYWIyBI1E13XDmy7Altg6YjQiXtUCIYoKppgz6IVC0GJQOzsKMKjgkhyrYJIYoZTJODnUQtiCqpy1KfpRCzdHpZFANJ2jYTQuyS9lee64VPqbLX2+xUlBhTZGgbJIBAoCaCKLbiOMFcDhNJU9eeefXvuPPy/3UDgAbJeOgcmYEcip0Cg02qBcwG4LVDWG18d1efnBYa87jSxRB2ptUtwRB2yswykTc++JPmUj6ejCAJUtIpaISUOUGiWLWqAHvixtblLIBgQndiTLKgpqaJQUaunABDgDFZcT6k7b/dIInABTun07T/PUezs8MDx9Ox59Vt+rDva8IjbVLsWfDDYjxI6rVjSkHPlefV0aptRNU+9tD1RH80bVJQVVMQve35j4ooVLetbkNEYmBRYQTiNiLpmapqghi0DZIlXCIzxKgKSLSYtiox1CypgmAQIGqhlfW6PT7ZPnX5xtNPH4eo2fmXvE+AKKKY9/7oaFXVVVREsRBTtIAZLIi0IbFGmFmIerJpb9zYXr22fvLS9ZOTJlmiuhghMRIxZj44XK5WtVnuQhWApfw0hkJz0lYSSrdw/4MPkaNtvPf5d1x0zGk+Z9T/yQrNiTmThZ9lbztwtGsfH4DX2OA539sufpMpEMskREnJ6jUkbY1AZKJdOpkUu5QdpAmOu7RpVoRPTSJ5MQ0wpURP5IiA5L7PoaQp+N5PWFPPe3rb44jNDK2choEZc8y3ukY7hlg+T8sWiB2ZZwdc1kb7NkbDmeWH3XwPN1eMrLXnDuqsOSu8yx6XF7385Y7pS1740q83RkU/9eP/jlaHCrzqwoOVY754zkxK2GBuzxT10jfboGZk2DYxRVGngBuYEGi5Wm23wcTIOecISE4Ec8zsXDqaO0QNqqGNIrpcrha1T1kP08btypN3rl4sfOXbIKuDpaptNgGc/I4mbcqQCOeY2DNBBKENMYbQymJVLw4WEjWu23T+gfcgQ71YLBZ1COIXC+9ou4nGDmxMEDMivOXeqyHic17wnFd/zefh6df83HtvHD79S584UVC23U8gei/CjMn5mG7uYsYMGu0pOEZtmlQpBabNjik1QMCvPHIt8c8ESpqDPgEqWS3M7jmz6t+HgJxA1DoPQgrDyGfYD1lCCV5TQFVj9kvYAI/M72DJANyH0zWLhxihywBvR685i4ejegUP+4m5OR5iBw8nwu4A5QEk2o4UnpaovobQrpb1Oz77pGna9uM/0rTxZx9YOl99388/+MbPfaMp3VXf/5Gn7ju79PX2t1/6nKNke045qqMYwZxLfnxzDHYcQvBVFQO5yls0duS8Wyw5tCGxQefAnJfWMy3qihxJiKJS1a6GZ6ZqVXnnjBo9iaLmmOplXdcuKQvsnSOKMYVxGyFHJarCOV4svHfchtjG6J2vVp4d17XnA1ZDkFaiMbBY1X5ZJz3Pe1dXHII5LsBK9vPv+/j26DVnN79xbfmaf/7nvvdbv/Ceu0SPYTD1DtoWGx9w9rVfPIuBI8mow4I94tJeu/rw7wSHpu0XAWuKwNO/w9Y//8GfGAw5C5nJ784Z/UAwz5SiXp640eQuyqY6QhZAtEvXYmaprWLpMSIYpORZSwBJ1I+X+zGMJmyX+c8ZacrvMfmboY1jEjbX45BSTeYuv5ntneGJ8GKjT51Z9OIb3soEAtZNPGmDY7p87TgZTn7kg+c+cuO+x+XFD1+6BtPDi58FM7ASJ7HMwuoVzFzV3nlmz2lTgiPzTMtlDYAYxOQrXy2cd8Sc3EPWhqgmzoGSVyQaMTkHkIlGNWGYRFWDd945J8WNnsoAOb1CjCpizlHbxKYJxEakqiEESYFyII0aVcVgIUSFee+cd2oWRUDmfBKgLNERS7usABVt2sjOiJU5pbCw4rAjmP7+L7z3Aw8+/ktPnHdEzsE5/uSly49evTagb5M1HdplRrAxC0wj3jRqbMpXx81O6u1y0JmGJ0BuWdbOeXM4BwAZWZZ5cs5ItZg315toSdGgnaZjfY+W81dmozKo27EkqrHsYML4vKdB7OieCRi8+YzW1WHjeK7n8HCKYoPn42nMqDNtYEzpRss6xcMB7tnwHbRkvXLMD16+DeROTrbbpiWjbdAotl29Yt0GI5IisD/8xA01YiYi+uvf9srFwWKxWi4qV3v2nrzLh8U7BhMbcU5SQimPkwB5jYPItonHm3a9CU0b25C2QWgIsY1igPNuuay9d80mrG9s2+QmVwDmE0KSVZ6z88nQtPFkE67d2B6fhE3TbpuYkso0bWhLDuLFoqprHxo5ud60TVSBCQzwnswMZHVFVua7DXHTxM06rDeBnM/TqNrGlGPaYjqPUeGY8xYU21n54RrvszLMrPloFbvvk+WeLTeGyZkiM3BXLjX7zSduAMkAY5zNLZx3G5nBjEB3Hi0AeuJ42yVTUzMxjapR85b5tFEmY2nZuFNEU4iUEJwcut2zCiaUsyhsJLthn5A5+GxTq+hQfMRYdi2dzBtL89XVHpYeNzBSIPPi0uBAm67I1J6bB6eFjqgI4KJicbBq1zcMFqKJ1xpOVBgURR3T09c3nCkkP3Qj3L00V3kPxOAgwo5CFEt5RwkiwsxqRmZM1kaLEj0hRFXRNoiIRFFOediARU31UlRJTCF2crJx6QwKoF0X6FVThWkQcQG6rLlyaIOEIJsmisQQJCV2A7Ba8CrnjFNEO5atdznCOwSBWZKbLAIaxZhZnYMjS6cjNm0QzYktVkdHG6WkbIrKU/xS0tS0KVhN9/noe2zbRaju8zwd3f1scw9HH4fE/hkJooC99uM/ZkQu+xiSUyDLijGlDzWDQSntmc97TFJXmg+wL5FmqWz6a0BWGYuwCouqYt02QkMmzcnKMzypd4o+AzQbGGlGCXYTSkxyYuRH/d0x0gxtJBMNcqJs7ng1dvEQebG7lMU27HzYVLHaJO3xaOFVra6cIyIw2J64vD5/31lmXm/avNsQpGogClEcJTXdQohV7Y1Ijd730JOvedG93vt1g/U2EoMdWTK9aBS1bat//i9/7z/6pY8jWbDZve9ffqcyWBmmCNq2sa585Tm2MYpQhEvnFKTtw8zJ4hKCwDNgBFvWHIIYwM4FNYEyOKWcCtHaEJ1j5yi0omIhva+aatq9lagPoigxkRET6orXMaoa2KlYVP23f+Vt//H+S5G0pspgDzz+uHMXAYBseXiWvVMzzrsuJvhQiNz49i2pghMc6ZvYEURp2P4MBs4Koki2tEEnbInw58zZnZFTkEOFMr02iwpLOUQAU0v6YXbpd474xN86/zuBSyLuVCQ7VJNZgXLC32ST992gRuyq3Oo53T5jaQffNGqllOsmqjNoDnvIjQ7tJ1OjT8nfPRqVFjwcDGNYGsV0M0nR3S1wYonsyHneBnnrCy799Mdvg6kaGUhUt0FWtRPRr3rJpfddW5HFq+uTO6pl27QxBXqlRs0qR6K4chKqKp5ZOIkGYzIsF9Wmjf/Nn/vGV99155Vr7Xqr0XRx+53hylMmmuKb2iAJMtogZKgcRVWXrHIAcdYumGm5dIsFV56WC1ou+dLT26iovDMzialQbtCpiFjbiGdmhkRjg6oqkRHUjImqin3tFjUzY1HRakGPP60qpnBeVQTXr98IhyE5KZi6FMDgKhl5kyu1c2SPMbCH/BGv20GVMaLsIKLNlqMexQZoOm5oh6POFQOTffjyugTHZFYGMrWMXACY6d4zB4A9emOTM8oV4axjgdnvh6IB5cEnwQM57qPI3VRAVYrNnoa7KGYoVGkO02tmujtdZc8E2ojs2WACbSJtTPSEvrHRqCy3aaOqw9EOlqDcu/0NX5bcNdso2zaa2dNXbqS8IE2QpKo1TXjHK68n5XtTvTSKRVERkRjUoDE26600Me1KkjaGEGAmihDysTOqWnmcPaocu8/+3G89XPGyppRshk+ueeeIyVfOOSdK20ZONrENJZ0eCCBRtEFjOt+TSSUSomOtKyxrWtX56CWAvfdpc0ZdO3YsgvVGT9YShNIy50Qy0dpWVIwpBYWLI/XeljWWC/YehOy89N5vg4QQRaIBpti2QVSCCAgx6KOXzlq/ytYvyGhJ56Bn7xKfogqOQGOmMbPBlx0MHPc6rPO6j/4IYyisdZJm4YpJPs1Pyh4lwDHy9jXAzBLLZELKgOiZvINzKXN+6spg+aTeNEIrJ9x3/i6/w/zGPNBG7oSRKJpVtql0WvjRsOawwGCex+4+DPdk7Mql6f5A3Ut0CzlOZcixR3qr9a49AlD5krDd46MPu5fefVJ7atMWehFzedYfePTGy59/loDrrSTZI51CqCEbuJx3gIYQa62WC1831oZ2GxTJ7GjqHYjoCDcuX99ut0HEcjiYgZm8JyZSMQMzUC+ICcwWVWO0KIW6iBLRZh0JkCBtzY5ps42bbRsjR0mQQ95T5RhmEgHjReW8JyZV1aiq0cSIij2A1DYnLUElusaziJ6s26aJUV3yzUexyruInH8hmepV9dEnnhS3JOB5t51/6PLVAWDfAgYOsGIPke2p5tzDUSsjFB2UGMaC0WhYu4qoFely3D4lLSlz3GTSJJAUHAXAxDkqlIgti4GZQQ6E5bx7Lu1YswyAvkvCRrDcSbepd45+7LBIK7xnPCE7ZGzPSuxw1DF3HE9oeWWbEMCJhba7N2CKRU+GGaBd62kaXY6+ZefIgNWyWp090wQVsxCNHa0XLztpYjrrU81U9aEnN2q2rl4qmk7GVkvSv8LUvOezR7WvHJi3rUSDmm3WYbMJqnr/J37zrb/re0JIrloV1SiiajFqTMcRAsnf4NgAU9OQ7B8GM22jhCChlbaNzTasT+J6E082Qcpx36nBFIyWrd8AwThFk5rGqDFaLizaxihiIUhstdnKZhNP1mG9iTk8QFVEQoxJxwhBRIVdlVaUKOW2spj3zNn5171lvGj7MXCKAx2wjKFszPbGkNV9z6A4aK77398ZY+CkANTsQ1e3CQOzzVwhhqgWTU0TwbLzq2Ur9uj1tUrJElT8FujoPpmlDYR99EzuNhVmgndUu5RCCsX5kQwzSRwdvaENCNUAsiea8WDGJoSwr7sHD3cEyL6qjf50H3cH0Mnegx6GnQ1/9aic63piT+yYEFMQJnvHbVACPvjQdQY5RuXy3jAYNtt0SoXB7PHr27/yrS8zIxBJVFMlxaLGuXNVnZQlImZSRdPEGOT3/eG/YPU97/yhv+kcvCsSpGPKm9aSF9fMEEWD5KyEZhC1NkrTSgwaRA0mAlHzFfmaicCOiCxtv0pJLjp/lMEU2kYRzcpIOhShDdKEKJLnso1KZFXN7IgIzlOCLMccYrzuX/KFd183MxNxnkntNReeSoZ4Ah67cm008WXJptS4X7EBdOwS0fGfMcRYD4e7hHrazRQAdgul0b7qIz+MvLvNJO8ryrUTVqQmPNOy4hSxzQzPcJScVUnZy6QShsQ5i/HRUspDQhLniuEnm3BS5ihtJZ0oqiEal70nmL7n5DVuiofj99ydlGmFvrUh2g/aykvWtWU7bYx7OA0P+z/+VW9Kq5pOZDpz7mC5WprZV7z0apJXHZkHclYWMsckopJn21SFiNKhh6oQ09DKditpEzAMzDAgirLDv/jRf2m6PbjwAjN2zi0qVzleVN4zVZ6ZIKKAOceOk4+KmFiBtNW/EduKRaSMJypR21Y2W4kCIld5VzMvKr+snGM4TqeRqEspL4jzybvpSBygVdsEEyMjZiZTjcHaVttgauzZVZ5rz4vaJXBpQ3vNvVDNvE/h4gai1eHqoaevWmfzm651v2yD5d29P8KrQuitnJUyhZA9je1qljuL3YPXsK2MMOVwiK5LS0dkZ2QyqxzXLm+GcEye2RM7sOvS9Za8MkNrUVLRurGlxsjMyCTNG0HUWrFt1EY0mPmh+mUTr4ANDaQjZQtDZS99tqHXoHzttMmiH2KkY/Y2UcubX62kYNlnoe39ggOfCfr9Fxh+L9Uzlevj2wi0qhcGY+KqSkkHjYnaIGQUnbz9ZVc/dP3IMYHo7Z91ZfnCz/uqL30unn7ZD7/zJ5BTJ0LZPvr05Wrp11sJQVRNXTlBJapEJbO77nzeU1cuC5ih51YwODNsAoeUrQUGkDc4dmYGMmZaHdbeOzOcrMO2iWIAc1U7IjTbKOTTJoozC+OVA2jd6rqFZB5nXlMAaWa8y1W9OiRm3mzjjZMQzYypXngiiyLbExiRgWtvB7VTQxAjwp/+ls/5x//k++HPEiEEiaoplMTnTIfJGjChhUNMSzdoiAGjMhN8mWDoLjvbLTDGwOE1lUNHA+jZHTLTswJtKe1Loje6rPzthwsxPHljk9tJ3h7rvfDDltNemmHHIwaCjLFpDMnMk8RQSn5Cs2RCy/rhTIz1rusOBXNGLz8wN3VFbYIQHUZ2nzvHRyk+xOk5PMQUD0eIjSH6D9ao2IwS9TIiVtWf+7X1F72qIcABphZEmGgTVE1f86qXK+xrvvQr3vmP/h4e/tnv/AvuvsNrL7hjlYTTNIFm1oa4WHifJEwhcwTCcRtXQQA6vv40oDfc+Qt0pXb67X/qb+Sz32NUU+ccO17U1d/9638qZRJm5oOlX63qtpUQDSARXS6rw7MLZrStbrapd62d1h5R0TAIlNPHsUURr3CZn9Fy5ZarSgVRbLVAFKlrf3C08BWHVk7WMW3urykuPNJRHb/20QdF3/Udf+Jbf+RnL128/mv3P6lRFKoi2raNwXJ6NSsLN0WATqIZY+D0Z3R/yq6GOLrD4+ZEtZmGphhYvlaM91/ZjPzsACUDcWKMigBrxQCL2sWrG4CcGSbhGBmMuLgicjsottaJumtFjzQkroscFd35CYfmSOzA9dRYOoOHXfcjPCyfCndKdwdonh5O9NkeDzGzwTD/IN9FkSq6gIdco0NYGjcNSxhvmaqdnKzvvP3gypWNmbWt1uQf1eedCR/63S+N//qnfvoH/xEp+//w8O23nfOsN5gZIFMRgoMTMYnqGXXlKu8NQoTFwkVgUfsG9tznvuTu++7Ddn14dP65d5xr2wjDT//cO9ORuut1o6ZR9fwLXu1hy8XyHb/zWzZN+Bff+xfW6xCDAMQE79l5V3lWDSLBFFXFADXB2qgxwjEq72DKlDa7ZcNc/lHbbELTBDMwoarYV847Ng/VEEW8Y2YKom3UNhiAdz969L7//Z+++O47hXtYU9XQZqTNMHkaBu4iwC4GjllYf2uKgT2WFeq9g8k2bYds8K3/ed1HfpiIEhlNrSQgVyiVFEyWM/wagLTxDR3b7JrsXAMFczEE+BSoneGxr0idz956gW8YMZPDbAa4OMfG5iXJAf6OfPSplwkmF1QaVRkxr072zUTK8pAx5tVj18p4tFZeeGdbcreAm20Dg/Mu0bLf/fbXf/WXPH/9iQ//83/7U3D8+//mr7zsec/zjp938NBDl2581nPPOlfaJGTTpGUvone+dhSFAVssmZz7ht/3p86ePd+2Tdn5wET20Y99+OFHPsnOp6Pq2fkYWjN82+/+gx/82Ed+8zd++ft/4PvuuO3OzSbt3zeNQqBmG06uo3jeTVQlWmAV0Taqijkwg4xZCSmyzCHpICzRmq2akmOKIcIQmrC5ARCJKKlCU74ii1HbqBKtI16/8tSFz7vj8u//w9+kl8Mv/PzP1EdHeRPKELgH4PNsMHCIQPsxcGAmGIA9dhsY1CxVdgoaAMfE6ezrgkfW9WO29M4zDPTYtZPkSe/MNvl3DnPrG+1VQTLqQreAnFY6qUAZKYv5QnPm/B4JB0xmV+m6KR525YfIUdaDCvvLjLD0ZjN4OGDGo3AZ7NddsW+0mZNOB+hf+ab2ve9OWWsV5ipWEce4/pGf+L4P2RP6Ir/4zOcfPoYHTVWVKSglYnjML4I9omlzNChZb0LQZhtRuUXFIprM92b41//2X6mZ5fMhkcI4neOKyTmuvPOOFyy+gqL6oR/7l444xKDAptkeXw+JhzHDe25DvHY9OibvnWdSMpPYBBW1ZA0igInqRWXe3ThuRYzTzjbT7YYMQcXElAjOc4hy9YY4Iu85p98TaUVj1CBqhqpaEBH7GtCHn77yV//+L3/+nU+HYOz48Utnn3fRHnz6GsbXpwUDR38GbGyIgcPao3tjDLTp4x67Cfjtq23y9GUiXw6Xt3R0mVlQbUUViDnkOrsTk3DW4S3Quxm0Ow4gxfJN+HAPtYN7lDgEeJ/cPP1cXi2/TZJFxpO6sxKD+gO3zZy5rJ9as/FSDQtYT4Vt0g4KNct1JkpxP8Dh6tZ1dbBaJHz1jLp2P/PxO1JisRS7HFM6+CgEShnZHru+/Z7veDmlAE127JwixTDJQa0LT2ZIqYGZuDupPBNAQCTpgzH596JEZsfEIgLAVGIITduqIDv31BQWxJoo61Y2TYg50UZK/KyiFjWF8wvYjg6rwwNPzG2kJlKISKwuRJOoMFOzINoE2bRx20ZJzkVCFKQwf01HfpmKKhRMTGbveeLitg0pS3em54SLr3/L7lo/YwwsqzZ4fhMMHCLeTvfjssMbBgM+58PvBHJ+gzZKSLMHi0V+Twh0brUMak9eO7HsQiwLmQCq7KVIsn63NQfpuOwkzo4OIgQhnzPbe0OsWHIoCcaTNywTM8CBgm8zLzzC+Ml67FiMJhM5xsPS32TBzMbTOhmuDWr2dUa3pgYC6xAWpvjF96oIDKSSkoqRAGR464uejEEMENGveMnl5F4PbRDTs2dXF287Ojpa1rUnx65yzjkzYTKj7NIwVYumMR0jqabRwUwEIO+9mTXNtm22MUaCkaHZbok5wT/IAAUZeXKefeWgBJAaxWKbSw4JEZWYs8WZ2qLmgwPvfS5s5EDJJCXEIM++cs47KAOsRlJy2qW2JOp3/+HPk0QqRFMuRFNT1avrNaWcN1GN+nV9xhjYzf5YobTxr9FST+FzvJb7AHICEgAAZgDooj2BorQkk2hBNk+o8qa0jEwES1kfOytMAh8q+mk2VSXGyOAikVIRWoGcqFYlhViYpJMqJKc87BstuGf94IfvfMprDyG+x5sxmt0UD0trw7me4tgED7ufsZEAHR4W6jFkomm/LCGdKwDP/sa63TSByMgxK2CUQihg9rQ8H5bDnIIQTBcLdp4dU+Xd6qCuDzwYIoApE0exdhu7zFAxJp4XJAaCAvlmDEHVYmgTum1Dmza2fPw33tOd7srM9cJXlWf2lau898hHPplElaj59FEiM1pv4smmTcl5vWdml/eCqRKpwZx31cJX3jM7571zHuTMOIpJVBUjkOZ4YwOgpvXBGRg+/44rKTO+mT1+7UZncrglDBwwhKE6uQ8DByUwvuYxcLrmc5+6ckkWpZKmiUq0RKJoWnJma85QmH+SNyHlm+lBCIYBMhtKrqgk8xSoK5sM+//RLJ283aptRFtVj2IOGWloA41toJvBBjpf+TxQEwdz2m+tGDWWZr/EjFq2fvYFBo1aaYgAQGE8DkPtnX42thJhaljCYANIHgZngxFtmg0B5tzd91x88onLMG2CLB09eHL3cw8e+sTHT171wnOARaKUhM07l9IfNY2EVlTk448+ffbMc0ITQwgq7Be+DWrAIw98xDGdvet5FddMHaUkVdV0aiEISKad+Nsf/cDm+rVl5S8eLCpHIe2iIHKOY5TYKjE7T1XlNEWSZ7Kd6GdSjMkRq2KxoEXluHJmaFrZbvIOUueccxRDbFtN1lHvKbRRy7kaCfsU5p1TmHNs0VQkbxNnFtAjV64xJbVoDwbOGEL6Jes/jjCn/zXhed2TUzBwSMznx1Ca/JwP/1De/Nm1SAXQyk0i3HnmCMAT124AhpwKrbPVA33qityVAVAIeqDsRJXBrMByDrEcpBYTghMZ4DGC4Ynx45bxMIN7b/MsDPYmeFjQdx4PBwXKKLqxds7//tfA9EpDApEmLo8tTYx/5ZvC+9/drSwzm7KomumHHrj66s84CwKxS3Mspkh5CjSSpxRfJlGYIWIidvXq9rDmxPm8o6gOMbJjIrr66Ceqhb+ULBmm973kFQIfRZzjGJrN+nhz7Ymq9gB8xb7CckExom017bQAbLuJTFQ5UqjlTNjpQANO201NoTAmoyxUkndYeE7JEbcbMzPn2Nc+BIlRHDtCzqlgxXmVzoBJ2uYle97n3X7lPY/fa7D1eiNyJGbsnXW7QjtZrkegOeg/BQNHKLaDgVMMw7TKHAZOqsyMoQiEOVcQjUon+ImakSdkBTDb/ajfODd0Q3QDJweAB48UQxtpCjS2bptvYpj5QIaSWXiWRo1fbY9cujPRNpnNmXlCXv2dpbRiP7Fxf2UNbDLXNgaEQYXZJRn0aRl/Fov6YLkgBhF5x1/xWdfUzKBMVnkPaBQJUddNfPjScRR9MtwjajEIYEzknAdzCBqiAJT23VVVf1gYQCrGHsRKjFXtb1x94spTDx/fuHL16iXnKIV1m+Zt7yBxTol1ufJV7XLKClOFiESRyGzkFU68h/f5oCdmZudAFIPEVs1ATpUEUCapFrQ6rAGNIaqoQQQxSjCoS6llHJwjdkREFjWfCmB5Kz0AFWUmmCWPtpQYvckEf9ow0PrHmIG9m2DgLkB0rb7/SpMER6Js2BwOKh1kLSlfcz7XJYUQIu0fLfzFcv6LrCvmRBjF1GJkSGm5mcD5qCaqmGvmylHK4F4x1UyeiEC+5zjY5VO3wA8nnoaZTU/oG9gt3IfJFKY1iNgZ8K9h73aaW2JXNB3dL+yUkE4zSqv3C7/Rfv5naV27WDJZA2hbMapCEMf5MEg1c4AqtttgxtlwbVDDptWKSU3bIK72TJTjXxggqEoiGNe3zfLgbLU6IphzVFeLFK5HgIhGJoMR0WJZLQ4WzaYNQYhS/lJxTIhWEUWJDE6DdC5BE/mqcj4bDWKUpgFgIJCng+VS1U42bTLhhSDOg42ZzMTEjAxiSfolUVGVjz1+yejo9XdcffwkJ4RilA8pGrmoCwMQ72SbXeAfA/sOvpyCgVPkHtXcxfe9zb7yQz9E+VCsLHBlip9JcybQtx8dmtmTN250JdP7UD6zsMiw+Qz6fDRU/2Ldlvkh/8neSDIg5cWg4ttIJbjjM7MC+eQ1e1PHPrLXtTNfYIdGduXGfwf9DblasR+Nfga1e/bYdZdneGgSAizp4hJN00TCDAhB2jaYWVQT0SbIFz//UtohRERf+ZIrf/k7v+bPf+triOj/+XteDBUVMRFSMTFRpEjJEMQ7LBbMQLZJgvJOfMKjH/uAc1XlF0cHR8vFqqrq7jgKVaQkFK5y1aJ2jonhHHtmx5QOCgJRm0+0hhmYyHuqa+cqb6bZQmopDYcQgZkWi9p5l5yijtkxp1Q7jimKBokpOpsJ3qOu+YMPX/quP/mFBMrG97TXAAa/UI1RkhdDhwrPaG5vHQMHwty0+HzTO81MWXFBqxFAZAgq3vVsNSl2T0M5QBaAqnJiXwVPkJYNWfW28lekeIYk53dKZ/RaMsOUHRbpPzBoi0HdAcB5IMb9iEcTuGO86ujGFPAnz0czMF6P6fz3zYzxr3OlzCxFvwiDn9Jbh2+7S27Td0Lx89jxZpNsYufOn1UxVQkxJ4C1FCfJuKLPg3P/5G//nb/0z37rONLv+e6fTmNJRJE5RR5CYarKjLri2udd9kQG4vRexKyASGiCgLyB024YIhCRGoOcKcUQmk1DoNpROrcZBl9Vi+UiJSAOIgCqylWVc44YYipRYmLyRKxgkBdFjNqsG4nimRybIxjI+WqxWhKzIeeVq7yrfPX3vv/nQPjx7/8x733aG/Bwc1cSwtTskceP7j1/Nk3sxde/tcxsVnA+rRhow6YHwGej1R6qPmOL+RA90wMGPnS1VTPJmi9K7FOubWaZU3bcsiPYSe1LujNyNS4pEgd81IBscMtFU+9F2usxJb9pSV8yGvcsHtr01z48zL/GlGiIUKfjoVm3rarcm1misiSldI97/Tj6HkZo1002AGDx6jen7X+pPCc8YFjatGp4on3O0dHR6172or/0R77kTnd/K/Tb1+4xkTbaz77rA//LD3yAsvQI79g5TtF1IhKjek8HC2+wLvZOsxGTxECuBlfMnrmyfNyksmNmx84b0G6bZtvEphWJqiJqIBfF2lZS9ksz5KyKmmx1ZiaWFcfIDr7y7BxAoW2abdO2rUqKHBcCm6JtE+NEFCNiEP/dH3vfi19+twHveeLMc84f/I/f9Jqnj0+SHpjmhWDJ5jWwbn8KPLCHywG+dVg2IOjD0sO+OvC0m2EggKgpSaHlfCWq6Uz5VrQRbaMy8V1nDkF48vqNVCV7JgAiKBKLU+kPr8/dlRRtuVctkmqWOYtjMb1JkneKr2Kad/RTxcORQDghc6MW+3LWL0HX+aQvs+GqDAlfv7Y2aG44/QVKbNhm31B6pmrLZb1cLVUMqiHaW1587WOP3CAyR7Ssq7e/kv/h937fJ7b3AhYkRjNVuXz95JO/+ZO5LZGHrlzNp/CSwiBBwKh8TgCs+WCHTGoo2V1BxJTOMtMUfQao6vFJ0zQhKaBRREWTfzxGiVEkWkjQpIX8pFnIBzxpLqCmoutNu1436dDntJ9f1JqoKd9pFAkhbbjPaR5++kff+aH3PqSqpvqJJ6//zM//e6N8MNjjV65oNOQEGZ0TbTilEwzsAHWoQUzI5XBB+j82WNS9YtegL4wQcAiA/ZNXf+gHGYjZF5/CfpP7TpPHPIlFKYi2a99KQrA0dLWiB6pFtSDaioaSa1QySlsjuk2IXQ7/CGpBbSvWiAUxMQRDsC6rUBdKPnqrIbiPQPvW8bAvVZrZwfYBDvVzO1qnwQj6lRuzxwEOYoTi01JTPOxQMdXTX/4QNU1Ix2V+05d/9ktf9IL/+m33Xb9+47/6++99YHsPTJmovu3VKY7EzF7w3LuzS9IxiESNmF06wB6AwTHlszXV7rnzdjCn0GjvKs+sJjHGEAMTWVJBm9Bs2+vXTrablquci0SNssxLvFwtVwcL9h7OBTG1fPJyMq8SkWNWs9DKybq9fn1z+enjzSawY2ZWgwpSICsxL5aLg4OlcxWxEyEBwPTD/+C7VA3s01bjX350ddvB4Xf97te9+Ln3mCHGaGaPXbletKkRWAxm3dJh77vQM8SeXQy0Gazeg4GjpR0t6bCPIY9OCZqQHO4lgjOpEkTmgHQQr8Gks7gU4LBBLx1ui2j2nwIEOIZ35B2VswqRLJ+csyIiKhL3S69CgANSsZrTsVpD6jR88VvDw9nJtWGp6YR1NTsqM5ZsrBfE+zs9Ztm+qbfc9GjKykcb/Cp3C2HMewNUiGAq3/Sl9136yM//rR+9HwZRjYoYbdPIQe3McEXuPfml/9Es5X9FMne0MSaVj5nSUROaD3cygzFTVS+cq8B8sHDpJdTU++o5L3yV8945RwYHIyJXucWiXh0tfV0lPKuq6uBgWVUVEXlfHRysfL0gdsSUdrAktdJ5ruuqqn2CEmaqKrdYLVZHK19VIEfkKl8dHKwWixogrvzB0YGrKk5Zh5meeOppJjYyAczssWsnP/4zP3t0/bck6HbbPnzlelmtnuoORZsJjXxGGIjh9alh4G5fYvb+y9sU9ZJOknJM6WRPV4wwFw8OFXjy+vWMosXz3GmIA69TbiedClr23VPFVDuqHFWOK0eVo3QQWO2odkhHF9aO0+mitedU1zsqZ1EMAftZ46FNag3xsCN3NpmseUWxPBuRxskCDBanILH1DeUOd6SVAdFevuaL04PNujGYqt12bmWQv/f3/8nj8T5TY6Y33ffUtlU1i6of/eCvpAW50ZioguAqVy+qZPyMqqJgTqNOZxcZOU9EaQOxc8wMgnk2M3PMt58/4xkuMStYOrCeQQqrFr6qvXMAwITaO5S0XkHUOWZnKXlUSjqcDALJc6iq3rvFokqwUy18vXCpa8eUYgMSkIUgzpFjEKmKmplzLoWHJE77nscOQLRtJUYpiuAAA/u57Ahlt0DDhZxiRUd98Z8fA1/+gR8w0+wrMnQqbTGA5i1G+bhPZOsoCpfDQLWjZEoFHLNncg6cs85QIohM5DmdDZrdYsyUEo6kExNcppvZdpNeisfvtfsaw0nubnUQPnlxG/wpzNwK/kzaHPQzaHrALsuz4RKNlmEimo5/Riyxkyv60eUqnPb5wQBsg0RVx/xzHzvfioraA8d3iOKJK9sUY/HlLzlOB5alfRLkUS8rVWvbkLKVgYxdifoxO6q8c45SHiY1EFT16OBA1S6ePbrtzCGTHi68qSaX/KL23vmq9hp1fdyGNqpmpYoYUSSJPRIVsBBl04bjTbteh6aNQWKy4WzbVsSc46qqqqqSIJvjps0n3Vsy5Ipq0mFNlQhtiNs2nmzaa62JmKqxI6aUUC7FpmpMUe6JNRP1S92v0nAVd9ekJ4EjQPrPiIH5T0YoI845lzJ6pcBtBrnixn7q+g0adtKPMt+igeE0rTJRTlbTYbR1myq4M73mNFxiFs2iWiyejPTfV2RhkKnNuj26NohPyz0OP/d4ON6BaKN0L+h3v9tgn7uV78Nos9mgthSKt5NutJMNsp1wuB5l9+/US5+6SsMuTqNc72C5FEsxYZK2XN7/yI0XP/ewclQzzNQxPdXefW71VPKZtYLffN+v13VV1W67aXLCgxz5zKYWokRVZmJjEwlRiEzF0nnV3rN3WNX1jc12VXvNbNUkxJMo7JgUqoqUUlVNo5rEdOB2xdZCY9BtI6oSYmRiYgB0yCYSRRXQ9aZxLiZlQ4IBRgpTNc3WIFTmGdugMWgT0jEZKZehvvHe4/c8dhcsn74AM8cwBxpHF5flmUWJEVZMyW9X/9OOgcP7pQlH9OHrLQyZ6Q13eCMZmfX2o8MUrpu5hxky6KYIN4N2/j0qpIQw9rlbiRel3GwaLcRswJQSGPaf0R2NNuY2k9caiv25qVMnwoaiyYQo2vi7jbuZzHNPU3sV0cZMrpQefh3+jJTJ/tULVc4RfWpGwAcfO9cEM9CXfdb1aBpNc6CDGVQBtDFv7mTi5179kWXlKkd15WqPysF7R84lKbRpohmcYyKKiqaV5DNnJu997bypNW27qCojjlEJVnmOoiFK24S2CTFEif1BwCB4x8xY1LxaeO+InSPnDE6MRFkUMUoUcUQGSNQQQtvEdhslxrxLQFQl9+UYywXVnkFg58BODYv3/rXH452WhdEysUyRFgbqVPULn/uWwVIPl22wzuXrEKv2YqCNnj97DBwyLwOAV3zgB1JIUscRM+sy5E0R1nXR2SZ6pEmvwJblTKbiAiw+/eQt9F2gTFbRqfPUa96EkWw28ASfmioyRd70XXGXLX84CTYE9rH6PQX9ftbnPQKjOzYmgENdYtikDQp0KLt3bXbowhAKrBCG4VKlvyIaLe06JzVbVCxmDIIhTTrVFQAxAFDRJ642IPPeJyu/ilaVc4Q6K/jIx4YY2JFzOWI8Rj06qo6OKu9os12LqZgy+8oRuypl45VWm1ZL0j+YIgaJQZGC7MiODunw0J05cnfevjhz6IngvFssUoicOc9m3DR6sm7X63RmTM58nA5dSpjMjuoaR0d8eOjPnaluO19VnojIeVdVKfUePXTpWM3ecMcJcdq9pMy2Dffee/5sjp/ZWbhuOWy4XMOZHuqCE1waIs3k06eGgWnRpUcwSkspmnZjphMC7fajIwOeOj5JQU9WGksnWhuhhCtAFKKWXR1A8gWqWjRLB253Ho6E7kQ5VWnWATtDzxABkouih9sRkE+nYcy3yh0bsZfR4syYVXoUs2FLEyq4g+V91R08vCWWOGhpQKwBYPXZX5KebjbbpKRfOHNIaR+ukhk5cgZTU1MLgrd/3ou/+1tf+6d+75cb0Gy2m3WrasT8iSevhKghJtED3jMAFVk4VIkfBoltVNWEoo7dYrGsqqquKlOYcu1z+AsATT5lTUc3kwo2m3a7bpt127TxZN1sNq2KSjBVsKOqcnXlCBQiJLL33uesh4hqUfIR0EQsou06tNvQbNpmG042bQhRxDRaypHyPX/wlQSCghgP3bgIIxVznE4ByIxiABQd6JRl7Bd08HBO1OrX4z8bBgIg0MdvRGZyzFxsJ2knYfqc3KTcJ34BkXHZkIty6E06VLBkNoEVlUjUxBA7dwXDUQ5y4rKPIme2pBKzxvlD9zL5fMKkGaZX7Xcflbcb5TkselavlXVa7iROmjA+Ny0XRacF9plAuxr9w7KtKddJ8000mN08/9OgcEy0xDKkQUA3eq2xCOgpBYtYCuwyJoQoSwcVefML1g+tD0Fwjn/XF9z+t//VTzjH3rGqglQ1Hwsipvl8whzORCpxUXOs3bYJTRtDm47Bhfd+tayryqHYPiqXzhs1JgSYlMOoDYhRiIgaeMcS1TUURdtWVE3S2YZmzkFEHREBzsF7cLfdIULVHLNIytZHrSMihEAGbDZBRGOEQtPegn/zE7/GjsD24NM3RJdElNz8avro1et9qMyYht4ckRJ4jKn4rmTy6cXAz3z/D4CHmmxpYZjcCZCsAaYjq+A4RULBDNJRbeTx5+0XBUfSRl4uQWrJ8qrIh9cn1EVniEWPOIZ8dhoGafB3XniX4w0mAVOD53Aa+ntTfjhTZi+3LNrnrtaxs+ZzLHEgznbTPdQQreOKSeE+WC59Va8WbrmoUnxLwo8H13cw6JUvvu+VL3r+H/jKN3zfj/1cVVHt4R3+9De9FIaUEQPEZrRYVOQcEYlqiBKjMJtzGQ3SniOxFGpP149vmJpIBKxybDBRTcJwUspEtAkxCZIwi0EMVtUp2T4SqOQjRyk7l9OVsl0kQEtBUkGkjcmySylNXDqZEQAzExuAZEBnpj/+zW95+fPvyenh1U4kek9qxjkHfKGJeRYHkoZNcbHHQIykn24Z5zFwV8AZgs+tYSDyIRMJGUb/u/YIuP3okECXT06o7LW3ju8BMMqQkECKCnm14ny3vCOn+B47U00G1c7BmBhmipWLUjRGhWgXOwr4YX6oXu4YzkWvuo5mYjwBk3nNeGizBXfmuEeUwaTvrF+5O178Me3sey3PR5UymiqgBOqSl7/no8smRlN85WeePPj4FiA2LJY1O3zT61fv/KX3VnW1rH06tjptJsqHbyoIxgx2rJaizKKKhkZCG0EIrZoSEbmqrheLqq6ZPbMD8Hlv/KLke2B2hF7fZ+8UHA2STrAgxKCbdWwDFFx7Pli4g6VfVgnB01YjTcfKExGB07Y2552CWoGAyKWz1rTZStOaGjvmVcWHC7esGIBn+pF3/eq3veUOdtytB0CPXj3uc1YOJnTCAKdLD0yLjRHICkLOVxzbAYbq5kgPKtR63JJ5po/diKJJCcwQn1JaScFTn6TTXCcpjSbDtE4AQGbpP2BlB3mSO5iY86lplHljlmwpn6PWOSM7ryMxDxgjwQ8mp8xxmZ4iMBcJc7TJcOiWyDVtsCtwsvEwrwIN3BgYbYcfpaXoRFMbSb1dslSDoatgo76KcRkDcBk221Uqi4dyhnYylyEfJeecunw8BOrKf9PnLL//Xf+JCW0TKodssmRyjs0QLSYXXEpmuWmiAZUjU7RNXB3UJ0xVvfiCN3wRgKe2wXFVe0hdg9lXK5LwHd/4jgwFZXBWgKLwng54+y/DYj2kDqakg+gxOUUhsb2DIRUQfSDlN3rnT/5yXTmCveHu9eW1qFI6LnRYeqJ/97jSUcNdJreflY2p6KmUeqavHQINM8AXrQ89rGScV8o426gRIJZFzYxy3VG7RIUKlX4Goq1l4ZJkhxVQF3FTxpRQ0eehUBJW05eeEwKoxrzEBpNlYz6zbypn6KKZ9SSsa80GVUpn47WyjuYNOh2wROvp4ciBMdtYoZBWCnfNAPWr35xwuGkaEInIHRdXZnj7F3zWZ953z5/7Pa+9fP36P/3JX4bq+mQTQkhG0SdviIkuDurl4XJRV95nEqWGTaNN0HQCkqg5QuXojW94U2LCz7nzOcuDw3qxPDw6d3B0tl4un/e8F3G/NaaPvcgxVkQMuCIsdSVLnMagIlHSWHjwoTzqaoEo7/XmHH4F5qzVfOzxKzGKGQz0R9/xJS9+7nNEjcwE0kMVBhM9Ws6yXqdgYDf1PSvr+M0IAw2Tathp7iYY+Fnv/4Ecbl7GrVZiuNPJ52IXDg6I8NTJCRLXSl4ERsVIW+CLRwJE5EBFGieUZE6q2TYjZqowRZHicxLEpA1y3pCRWzCYdnIlxkhYwL5D6okmPXXt7MPDCY7ZqHhXdgcPMdb/OlwaL8pwvbpF7OqO0TjNRw8W03qlQonKhsGCUIgA4Ct861vu+T++/52mFmPcrDciEYCpfejK7SiZYP3Cs3cAsaNs9SJKCUMBRNEY5Mvf9MUvvP3MvecPYLj//o9EdebP33Pv8+98zn0K/ujHP0gdgpXEXo6QN2aQccEi18uq3VfqypcPNCrZ4xiV3VoFRYFyJ7dAzAl6CPiXP/5Lf+TtzwVRUBNzppay9N32+rdOUGKCPAOkGqoLI9v7DmjsNjJYxHF3PfTtx8D05+PHgiI35uUmWLFbOjKg3wifsCKpglS89p0dkZHtjgX3rGhnHW3P251Ge3nLe5eKGTllwAbUhmnwAQCeLNpYyLShFTNrp92bD+VSDOyoSSKygT2zj8NJLzeUSjtDZ+qhp7mpUD7/ZxB8A8wfPmMYmnIHJtJeIuk+dfdLheVqYWqCdulIdPOO1y7+z3/2TkpxNFHIgZ1zTD/xweUL78KVeMdteKptQtkIg4cvXfuMe7xnVN61MdFfiqpgvuvsigi158+6+9xHH3308Uc/7tg9/rATCczk2HMvQqfJMe5XAN34Mc5ql9+hmCxHxt+hUXoMwX1GsP6YKiLgAt7/BNO7H3Rf9PyQZuVf/vC7vSOQM1R3nD28dOOkiBiD/O9dLzb8M5Gbdr8MsWmEPmOU21vxdAyEIW1fRt7GkN4SDmxmTASyNlor5jjv/dPBiCIZiqzYy4OZiA+hEMXhXwqke8gzJOU+8v0B2A/UUD+cx/510zoWYkBZCStAnbaq0qAohsFtue20WtbpkkOUxVh/7KuUVnZwE91gCmQWhXWIT+Uj9QrpcFid4wMTVNT0ggbg/Z/wr3thDFH/4Y/8e89sSKeOGQDn+Opx+2Uvjh+5tvKOVGFRtk0shElDK2fP1U1ElKgGJmPnvuGtX4bBa3zd575svAR5BXJUY5GAhqp8V75M5lhxzPpG1loI0BQj3CWdzfp0dgontLMUR5KLUVoFNSPYL3yC3/wCIWKDgtGaP1lfRDpAJwGU9bDeL83g+5B5jZFqUCxj8y1h4Fz7p2Hgaz78g3CUN1V1c51JHCWmcvHgwIDL6zV3Ez9mwjmpTLHEYDQG6swNNnjJlPQjxeIIp9hMwIagW3opL8gl2mZ0FTPpRHAciXs7RAoDuXA6az05yD9FUJlO7aBe6ddKx/3N0khpa8DsMRiqWVd+UqPrbfhCHfITYRMsWVzUkjoNVSXCh54688T29rzVXfW40W//snskSowxvROTLRaOYDGqGSrPf+Dr307onEvoVYqBqtbf5yxGuhTXX5S6LripZECxoUTaVe/Llx6TyY7TznkCBt2VsKk0nmQdJhX9wucJDGrmXaYLZkYpeCjNzlhhma6I3RIGdkzDxk0MCj97DASgah++oR3lkrwNFyndfTrozTEqhidyRJ7IFcGVR8aXLPelaXR5eonLGYP5+GtOTiOkLRSO4VyOlckrwl3qmoETAkicxw9pUf+oZ1QDkS9T4sKIMOSOQz7XYULn0uzkRPQGytxYTyL6siMGh+L0L8wXPX8ub5HJT2qlX91pSx35GthlARhWr/mSzW/9PID1piGg8nSSPRD5qBBV/ekPLT7jOQBZkGQxy43lpIBRkc5by046A1lR7UdzXk6GLK9A/ZlWSQTNZywXmLAuioEHC5JoWK7VyzmpE9e9Glk/h4ndIe0ZsSzgjFYIj2wuPB9tUnXSXjgrWYkevXajG3KPTzPo0UNQmfQOA2eKTZ+Nak672KHS8xiY6AETdWl6E08q+xRMLevG/fiQFrQwrtIwExGDLTl8hnEeZRXT0UBAJwJaP6YdLYtgBk+cIac8neGEADx3xpDJDE1ncBC3NqFm6LjU+BoVmxDC4YRPiWino/fvOhpbGu/YOFNa0sHX0qGNO0wkvEynPeeOi965PAVmVVWljCx5qwQzOw45lZ1CRSQa0La6XgfAHJOqffNXflXhe4VZJVmlfEVBLgIcEbExW6KXPR9LkF8AZtBgNuRQaYEx/kod5ywMcFA3S70FmLIAS/zQU9cIePipG2bGjh5/6hpgj1+9gZTrosQE2HjRdhjggPHdDANHKzYGmak8NWGywybLVwNe9oEfSKcbJN7lsyedPVMyZXmms8uFmj213iigIOkpRmFfTC4ldM1xZiXarJu7ImR1WkNhvJTyIej4GTMoJ21OO6qyjcxsDxIOYbaXRvsZ35mpwXRM1qOgDsbr0tGxToqdEFVMWup6GK6b9c3047XRkAop2aUHY1RM3xaLerlcRJU2BOcYZh+7dttjzV0A3vyiY4USQY0efPSa5WW2NN2p+SgxBqk8V46/4xu+Nntpx9CPHhuNixLvsnM9IwhTwr1OiO3kxhE+JztnlyGzE3FT0aHc29tdC6J2BXkAQWKimrLd2s/fT2pwzquomnVG9RmaOWaAk8kfQdKImk9YXg8p48IddIwoZt/MTjdiaKXX46IhnQYR86ZOpNw6KRJ9PEtlVjp+aPmEUAPy8SBq0SxEK3miUl6Z/CGkDIgKM3RLljXuIn5ZP3cZ8fscb5PLk3aMeTpb/WQPbk2QaKwzdng4fD7UIm1QZ4RaI147XqAxGtto2XZQsYDPFBktDyXjC5Gm1IUGUfupjyw1HxSSZThDjr59xYvu/TPf+nUgKhk4CYaUmtoxllWHe1SwqV+Vnqt1bj3ORvCBdlewpRi2kE6fzFaYotoVj+KgPNBn3etRkkCcht6VLNJ9Rw5e/vznAFQONsnH8iVA7ByRE7a2jwH2gDJa2w4ehrjTccTh1wFkTcDrVAyEIYo90pCYNdEa0Va0VQtqKbVZ1CwgXGsaKiiRqncuPlOodUFuKYTQgpTNuJIABGL5f5oHTdnTOsQDUpm0GyPt6C1+Rcs7Lgzo9hMO32xnEsuk2BBN8lxO6JONJ3CH8O0jYx3SjQngYM3m6pbIovGyDBZlLMLYflQElq/5kvKAfuvBGmZq9mUv2Xz8sRMzPLS+WFXu/kdOiBANb3nJ5ve/9QV/+1/8m3xKWM5vpqIIQVXt97z9q7teCQl/CiPsEDHLopTMMEQdcuYrKYgdI+34Xu+VR4dJRcnsmur47RDpkxWh57Gd7xCAfeyxy9/xlvus8iWlGmCICiJXvtntr/+y8eINpnbMAHvMs7mSw2t+Bfs25jBwIA53j2AwvPC9/wqwvO3ITC171bPqRTDY2UWNjkiCUDzvQ2ndpXz1LosuRb/rF4cmdhfuJFUY0qanlN8JCtPieJTiJEy+RAG0OCGnV3q1qt/e0THFDrX6ydhlhEN5cSqaTtevw5Oe/w0Xb1iwq7uLxhMQmKLihJF3dcYqZNq6sGm2BBMBAOJ8Jg8K4wLsifVtova3/9k7P3H9jnUrlgQVtSj6+OUbZvrNX/m2slADvkddOz3KJfOmoXM8FCkUA+wowlIeQ7lyI9Z1VLCbqDMHdQYoGtek4TA62CF4ismwrF1uBrKUaXTkbL8pAxzgyJQBDjFwd3HG6Dah8iOgw3DB0ZP8ge7BRI6RjJ81s89nPwAwLSnhrEwJoxg/e9kDZjAy7dPhjgglgxzBu4yKjuBQ7D3Wjz+xi5xPesADuv/cjWNKn4ZzOuBws3hooymaLbAzzbtCv/Vt7UNjG7SJyYIOFLzdioP1HErC3bfuZjKPUVBbLVZIxkQwEYmIwV7+Gc97xYue62r3wcvn02z/11/3Au+d956IFcSVRwlWgmUdYMzcMu3NyVoSvhklabNglfVC5FC7Q49CpcUBdBSFk4pbojTTFUj6iU3IQW7V7I/9/f/4R77mza/4jHuSUmpEZKRqd587yuFHO8sxzwB7yBkvAAYlbXeJJvAwopxzGFiaKaDwp/7g/0RMj7ZpowmlrJPZA1EmMx2CfbWJiiw9DvP5WjqctbNeUSZCiVZxoXGJzBkB0yMLyzATGA0WcKCeZIrIGY1pEDFD42kDUPYZFjCyPmBj9LH3hPcAZ5OTAWerdvAA9GQ7TSgNfSRmAHU+iXIzt1UYCTCoiq59oHAUG4bHJEJdONDgxReLGgAjgJCPq7a8yeJrvvAzCfbNn3/hH/wbiWpNlFZQsZ05u1TDdhvbVn7v27+6G2+a6HyedtdLGhKXtzXDgBMmJOn8t9Y5F7JAVIzuyWFXZjQ5LwZhkiCkxAo0oq0GJtLSZsmnQOntkkn97IEnomQKFUEAbba3i2rHGzpYGSBGebCLfta/47jksNSOeWFPs32dubv3//p//JH3fU7v5SPc9i3vvBKrNjR/9ds/48+//XUgqNm5ujsEKa98Aou8fV4TENEEy/M8D0ZdhjDRBwalCxXu8DKtZuai1NXaCVubuay0mDGkP/3PMMz81EF5jxKDtxu486wct4QOzya/gNLRBDephNGltyoIOtiQMeyoe4MM6JMdHn3lvmQCXzMyAZGIvfqlL1qvn0xJAteXfuvbf+/X/A//7//wnAO97fw9N44fAyBqf+wbf6f1XMU6rE90F+inKwuN3MFJT1oG48ojTbts+9ktuDyA8YyERkT9RAxAOG0FKIAx8jNS56jKXCepNX/ln/67//73ffX/8QO/bYYQNDlAn7xxMsa3HfmzzOXg63Duh7M9qjjA0EkzezraweC8prDDxSK9kYIIeNEf+4UPfPKxp9/3D69eeuBbfuHwHX/8B3/j735jMpCA+uoJVIo8lGhWArveHtZlyO5qDbEhfSioWKCsrMYOX+shs4M6Hjwa3B5U9dz3Px7JHPErt/qvY9E0E9/ups2Usn5ibVzd+lvWfS3tzMmxYzbQayojXbA0e/Cat3Tv85sP1iKisAv6/sODOxV4dH2bgf7+P//RohwZM6ki27CHqAyzXg7sbOUGZDkzCTOc2IkVlyFRPtyiR4vpnBcM7BTAfsoL9BQAzeJP/lrk3GwtLXdze2Z2oO9PE/Ho5sIK29RciJLPgC700carW5ZjqAFaN78jaXOMgTYaNrpx7sNA619s0MxgqQHc+YrXmuHBhgn4hv/+fz+nH74oH3nZm/7oi7/iu4+vPP74x94DokPPqnaj1alQX+SNTmhPz7RI4N3YqFuEVMuos6D2rQ0+dNFL1BnKMerb9nPCGQTuVmK4zdB68bCMLM3SmCVmMAWGnDPfzFAFG4WLWqmeOQhG0d4THjmEx+mz0nzpdSjbGsqIcv106m3TNkA6iMCY2YCXveDeb/mie/7uD/z043i52qNQwEHVnm4v3nd0GWbEoywbaVBaID0LDZyxJy0sUS9JUzlomQY4m2TUFHBcBIpcazjX3OmFnTiqQDa7ESyJxD38FhkMBJPUFQEwEf2C++SXH/i/S/vPoNuW6zAMXKt773O++wJI5CRKTCOIQRQdSNEMAElXDYMBEJBkRc+MCYmUTFOWyy6XXDU1NX9mXOJoJDOZHkpUqBoFpmEQzSBSjGAASLoYTDGJYAAIAngAIbz37r3fOXt395ofK/TqsL97KW9cvO/s3h1Xr9SrV6/Gf/oDP/tX3/i6f/LW99LlnYXgvc/eB1CD+lzcVdh7sjGgdsjU5WyZuSUNVY0UOPwnyhYMfP9bf/aS7/3nr//0H/6FX/xP/6PPfOur/jHF7T0/811/9r/8qrf9Pz//t973TGjacnjq6M2PgmfRFuUDdwFQlDYlByqS13REjKoA2hibQ73jw4NeLDapYXnrv2aEVNvzxOrWE+YybPhHTtdUktF5saWSoy7gaJyS4H3AnRp8RIpkAHK/HCmynoyOn8eIf/QVKwKm6/XJJ5YPPIA90/uuL3n1+Rc/lF/MAYRkH6F6Beo8oa4JqfJajpgUAprWKtNrBMx0Kst5CjqZVgO2PK4ABSV4r+jIqiMgkC5HVAJWvFcWR4C/t73oo3ICjATwwqfOIYQPPXgAEEDv5LXhdRQ4IwewEhMKrJSsLGcmAOmo2EGTH/tL34xBMn3/W7/zw1/wkX/lX/1/y3p6y5/9wn/4TV/5nt/91+cnXvBt//D/9uzvvc9ToO0qFJ06hmzFCuUGQpxu1adrjgYsZKzC6Nb6qHjhiJyAb+rtnl6Jq7/axV57eALcyRhyhOSEGqmYVDkq+czgQioSdYTjIhNkGYEqPMHKoKemA1IUsaM1YdOUFiC+qoHowYffO19zQQz/p89+1f/1H73tI19A1sB6c/7kV37EEuL9Dz4na1PbIpeRCkAQAFUFdZSqHMVrOGTAABWI4EAlCibHPsHGqmXUKSPhOouqtKQBPJjtl6pzMW1SQPxbf+ETvu5bfwjgZe/+/Q/+8+/76b/42Z/yDd/yS4BYiO/Khpf9yc97XPITeDSPZGnwb5Q53TJwkjBWBIpKv3PhfT3Iz3/o53/rR5/+sBfHB8//d//DV7/wyfWjP/ITU9pjXF787p+RkZNRG5J2l/+UpnWZGiPGylp0OknhybhRdGiorFAXUTLROh9ile3U0ZEk5VmRdjXMcUY0zK/iSkUimCUEPBNzwrOe8miOQQHBjJL9eqsehSJTbgnAvLLvJMX2fBQp9ZsQMsxBJMTAZ2H+9L//9H/7937qvMjltUtAIr5TG9/wHz79z78fPvDeH3vRyz9Laq1TaxZMUgnGX2TjSMbYadfUK9g28kIs8Rj4QvNUS+h4Ec0kKu2gCh2S3iHUDhgUXvjUKQvA8Cd+u+QffnuIga1BpWi+WrPn8C3qjAKwrnTB5gsUTR9RsP9eW2vFEkQA0kMDn/vSBV/6YgJAOH3HD/7zP/knPuV6eVgovuP33vPZT/A8AV9NWYxzIhBRASxEDtuk3YCS31CLYz2B7jhQ7SsRGVVTUSWH9E4otKnmPY/ed3TkXdT9rklmL9JFuEHXpqVnhkSTinRqLbFaVGoet8gn1zQ06U311E0ZucoHzmqWhaf+vc8FAMbiX3r3DYZABP/ge9/6xL1X8OL7peGXcwEgur3uf+m1r/ymH3i76BuCoozDfK7MrCXI5O2TCMQHhWeLrBQ2mwokdUuaeJF5ePN0o9VSmXd9U9TgVzYkcSw5g1ku9M//1c8TIFEJEED8SxAxFDC57CeO3C/DCe1eB1topqmfRDddtYFasL5WNNJptPwf+799E7ETPO+28K0PRHspr3zFx/zIT/7Qb/7u7/3hD/3sZ5zfzXVwCOCkTmQc2UlviZC7OxW3Ieh1Mf4fUPWPN05r+74BxWtcAtRJzBEN8IS1ctB9wo74Jk+lkipLTL6pcPIqnwGM3NpHmV97sldqVkOvrvec3UWnp1kkGhP1wk9Thg/6zcRv80kZnvX59nqV6UZhXdsOv/Psh7/k9H7FafiGb//BdQ0lm9FEODGVCoNWkxZMY1nFyjASs140NCOgamuR0ZBB1xKdkAMX+QAaWmwQWLtCogUwwLmlVGgJQBgAIBEWwkI5EOxEr3jBE+999kE7DGj/1qluE2qujuLa8gSTmql9rclto5LvFPCd1wBqpuJL5AGgAH1S+eU/8UfORO/bMzzYMyZ8csVcKAYNCwYAGt4C3DopYN3x0aUSUD2TIxpPKaw3YbElCShlou+pgxEBiLcaktxZD56btXzMPavqv0Rdfg9lLxJrhp67k8vsG6MG3jRMLBkDcaxRGQSB80Wi9kMzJsfEayuawwXwFCsmQIDMghCefureJ37Mq//4x37EX/2i1xYqJWeNn4dKsJW+eSnlh2gLA8sm3/lIC/Lc15h5lTko96nDQOOqCEChsui6fdyeTyWqFVItW70i8f/+n/3Hn/hRr2YLWS7lkuD+7YsURs0EtSAdJsoEmznZqPjyFOhr7aZeZson0yEFAohY2+vVuYwNhTtQiG5T+eA18YSkQhmAGTICUOGrRgAsgiiCbvc1aJ7V55NUThaOQSoHNcT/hnNCPbCiXjOk3jN6Koq13GXgQVU0dYxNOlIFWZUtbFNptgweQySCMIKaKvWRZyF1p73m0ZUk1QXpo6SikwbVYDXs2kuDCOfTCQAQt1OEvdDGp1OAoOQQwl943au/7hu/r1ABCIXCS17xGYwgqHvPQa9xUIJDCLbgpGqtVKLUdWJd2aPUxwy5mHFT+17tMqpP8O17brceLfyzST7VgJQDqWZRAAhC+Mff89Nw/siSC3JUcQREfM+Hnjewt3jRiqtGanmC6RGsq8eQDfsafRFqXtsW/tDPf+MWMPOWHRRduiEA6u4OZSjnCDEgEt0mKkB8VYHyB9nQs84wpAy7zL4hG7R6PIrhacc4AcwUA0SUSSYaUNxVSaLiE6hHPlA9RfFYzxpmnMsg9wcUiQZbmolKasp2XoucR2HVMtEq/AhgqKf71vkPA8e01t084yTPX7ZSCAm2lP7Sa1/+Nf/sezEEAuRQyipZZTnOji3FhsUZJIYzEB/Gl8Y1URx8OfhCcQtIQiLjFo12IwiCBg0NTmtDEQhXBRUA5FQWALjA0gTX+HEsAP78Z76MSuGvqBTOq5kGljbDDsi1zZYCSVmglmq+U+3flAK9plJnzU8bT9btXrZS9kKb3tlCZP+FiJgLPNwzFUIgJNoLLwLLVkoquQiblZrZ6bQe4HLYbbPGTWvkX82qqoX2T65MLwTJYi4WubCJV+bdoV4706E7OI4FDkBtvlR545Q9A21LTg0lKjgrYKczZHTXlLV0T4q1VBEe301bnU+b5Pr9iU/+XK4OAX7pd88FiKggQQEkgpzp+eeeRb2fNRO98KWfJjOElFVzdFqYJBJa4CDS84kVd7MCrsbSMxcMRPV+qmpqMyHGTAyb3bqFuUNRbbCIDAUyRqPTkUuiAC+6h8wLEEomes+H7hMoHVP9Z9M/mdyWDfh5aSYXbD77SjsO2k2bRwBtEn71PjDz4sQMwPd5yNVLBSJgQFgQEhFHhbRjoiviGkIIACAKZ9dHFnoazlC1CRDdVU02UkbX5kByIlPOqgL67Yq6FUVAC0A/qvHxUFgD7cVUUq3NdiwETt4pFFpXboN+o2KqhcbKOmWWGr0RCAh035pMOhibcvoweDMSGi7ZZj+gqwDq9wIFALdt465nKq954W+fP+zjbk7xz33Wv//3v/2Hoigk8OKXfToRYUDWHzVyoTJ+M5agxCorsr3HqikCyDVsChVVfgAQxWCDRFQoBBkOKNfhOSBw6rWfMqJStXSjIOUNWJG76LcH8JoVfvGffO/P/pU3ftY3v+0Dz7z/V0oJoAzl5X/y8xtkqBV4i1DTjU6F7L4NtDTkauRJJyZrJR/x899ERBEDIkREYNQvVEDiCYAeWwpAiFAA9lKAqABx9KoFIThmERAhGA+wdZO0aSdxeW1X6pglC+d3cUcBRA2SWGycmExxmriteaD1LLfJ0NAfyAKjTkulvqNVoqpubeNGPYfeZzolpOap5ovvA4AVhIaqRWBJGw7EFXDMj0myYww3a/yLn/Pqr/pn33NzWgIiz7OYXpR5iOOM9qleuEXi12KHIOw/pJzDvRrI9GLqujRpyNtNjkyBiRzdbDVKQSDQdW3lAUV8hORePb6W6MVPnUm8moh0Z79RTxpaGIhvoKiBvloKHOmrIz+AWROSsEYsBZaAEUSxC4RRDykgiF8DESwBEbBQCcqHC0H0KODQoIW09sM0cK5ctJBqabCBofJKYoZYZQefERP8BQREWHqO1A11lljvUbPJV7Zs7p5+x30UiXVsQg+IrCm1YqslRaMot7WvXGoQe+QW1XDYuFJo3Z51q/Dz6UxERLdPrCEBFsrPPfsh7m8BShle+spPr+SnA1VhC+YcE8xHwTyn6yCVCSmMyLnv2/wHGaWpCpXlMJ3ILZOqHRh1VS4FVZWvO0zGnGwrnQCIvukHfpboFRgoFGdAn9LCSBvu/22K9qLLP9JpR6BjK60UjQF/9xJWrLH9ChDI4CHlRASZ12zKbfk2pSXAGhBAraiKzwRQdipub10SiQgkGhAJ8EUe6tTwAcVeSQCAAJiBit65/bI1/X5eWd9BwEYS9iR3SJ/Uorc7T0iGbWR4A41IhCPtFMzgV88l0iHdOp+ztlEjRQKA7p4Z+Q/qf1wHXUF48k987oNf+CFgoyTPQ6E3f+qH/6Pv/QlESIVyoRe+/NNN4jUQAeGRainluAY2xX6CZM+Ss0Ww/oKriekCMRDojn+nfWLz21y9QdkAFnUWJwYV1mmTcFWSGfebT1r3X8IQXrD97u8jhogvf8GTzzz/0HW7osC/I/m5WXPvPod7GzBwUGMB2R6p6AAyvSzi4ASlALzwZR8VA6I40gJvY8hB+yD4owtmIF5PAvEtIMwnbTW4BH0FQmGihLoY06W+6LEhgM1aKVSInv3AuxDh98tJt4hA1oSPeGaycsGSSrD570Sif0eXowoAMPoSVHGCVepxdSndqjxx3XKOAp0MNX0MqjrXC0YdGpqYkTqEgLbr/kvvuvcn/sil5PKPv+etIcQEUOR4DxARIgZqmIapbjy+oNqIibwqvYu7IbbKAgQADCISrUNap88pYy4c1x3ABCNB7Y5RmqSTnqZzs6rVEhBkKuzoSmZz7xCfxqLYUcwo0DqKu1sAdvrpIZkC/LF//S0mAHkrBxRxCOjhlu4hAcL73/c77v4z2AohQAy6ficMRopszZMDNBjRThxAIbmxThHdFiCMDLWrcvMriMMwW9kI4CGcX4D48iV9oJyIKKuq3xLhhNzGh9ycdVt84rYMDUnwX8vRnL4HkPwVcgha3KWbC0xNcp0h0xA6UtSMWsx7PIM7eUSmjyrUPBaEZcmXi60fiOjDX/oZpRRgThnEmo/idojiwMIGGJTowIypVPkSgVpUOGC+6NBywbFscwEqW9U9pdotBHUP13NQ7iI7Y0UcOMyEH+nM6XCRB2JjZpshIlKI9x++NDgSHEjgkdLPFeopiipfvlMAkkseWgIA+O2HwhB5f9x0TtAAIrckzIRV9MyAUfoDxRDj/6UU0/j9Mpt5rmYrwPTYdl8IEhCBoulZhAQUAT4MtpfG/MFyIonLJrKlblH4+XXMbmRZ8qyBO2bMV9hBg78Odj6lYepkf+pPN9/CvqnNSuQ7M9rFhzqlWvIlqRUvPB5uLMsVoERUUioEfGNrAYCcC8+0rO9ZyeMr3VEqFbWRKgoTQXNcRnMpa8Li5ttPgpXnqgwyBYBQ+290rRqIliXOVio6Sb6iETUBoO6QAVxPn1RKQVGfyrs/dL9A8bfbNhPdUktHj+2kub/al6GGhgI7nGnrrgBKOaeSUymJt1+FiRMAPRlJNSIgAiog1745td+gVw2YEugegSBzAETSrQ4AEKffYah1HBARFuGZPESKAM/RiX/vhTiclkYTviO8hfIV54IxyQAKeid0RNYJejE6+oVTu6bTbAZaVL5u5epQXbleKjo54HPwrxYBmTs5bbcVkPKHAE6nExCUst07xfu3pWRCwBe9/DNrbUQkJ3qJWyzaZ3RIWXHGTo2osCulyvGgCwUeurOquLA5zABkcnu5p1oS6Vq0QfRuYUFQ3ZRZ39AZM+8aRiTl7w0AO4jVpeiMaA44i6Vhn/o45PfR/9u37KiOuIp95p6eS7nnzj97s3S0K1gQKzg54CrwPofaM6FCWG5uQXOOdMstNOR2ElWN65z5adxesuT35dXfDUwADz/8VW6zfkppdz7NDdsOcp5vVig6dkgmczTJo0ozZYMB/A6p2L1TrWBczwM5wdghKwA8/e/9x0JiQHFdl9MpZcq5fNhLP0MKAALWW3gAjD0INVJbq/yq2hLqkk8cLYJVA3LLp3bHK+/1QRJN1DwTNXSN8RmxnnuuL+BhpBUck8PUNRdfxR7i7/3b5znl5X/y8yrkW1IhhbHW3ao6fuZ1LhukoTaVXCt3UiDD+3cegt74R0mPQeyF9iK9uBTzIgNQ35TgzMZEZJfbyTKeGRKbRkVtRZDrd4SFot4Xyr1l6hUnQV3Ay8X3BAXg2bLygNYAMejFkigtBTe+x6LCEZlbkFakcyqi6R99SbfgcKTYTdaMiKak6CjcdwUU2pXwLZlcyyR5FBEIAOC6bT/3DlxPJ709Ew2LQWnIcB54280JZXMSY2LQtQZrs2gEBCgBK/UKT5AFIffTKKmqDzJ/qCIAEVAC3aLZsbjhDurcV2+GJU3m3w9OfxwAMUY/rYMUNUD5CbyL/GqX6nS3tVIzhzWXkmbX3qJ7faRA4cGWUnKhGyyO1QDL9qzEyeZNWW+Lb00h0v3RCl0MOh0anUs/qDQrYuNTd3CmQO0T2wuewu3Vp/JBWkHxrBBkossLXxVQHbg9LPziwUZncwXtsyDtpdnpJNNHpQLTRXkeXFYwC0qjsHINBKaF+UV0u7kvZEC1Lifoa4c792/N7pz8GqdxcjWwNLl9+BAIXvzK1/KMBzD/m7ohwo2T0w6Kjl5oCsWlm9ThR7oR2M/Ydd+AiEovPI4qBWrXiaAgRBCnb6YwKrIA9ZOGCMxGSl2Vybfizk8VgHd/8FmIESD4A64KnE41aViddd3yuo9j8lGVB1LQvX3Mv/5WQlgaOSe2GQCMWFB2xoEklKioL2zwZPsnW1pInBcM78zVXlkeEQfbBlDuS/YJNBFQ1XtQxOGvz+b4gpDes0cgIttSQAK+ELIeZeqentYekYE6CKkcavhd5W6OXU65ZSMS65vA426paBrmpNQw9b7VIYv5bBJByinwu2JlUQ5jpUHlKZAuCZg7oml/btcBGhklR24UGwmEG8ua05aZlSKYZ9faCECcvQGJ+DhBnSmFJ1qKvRkMizEogg976X/EL2b6IYWRn2fT9r0G6WRXP5/24huuVdbpql0GV69rF0qB33lYC3tvLY7yWIhuSyAhQqJS/cp4yw6rICVgtRCBAC2F2N1Q741RNtqhMZkqVFRjK9ovAnielidhf9WJWC8lCTcMudDlha/iPEt58hNheFCnvKFRxFYOye+zvbRME+/6aTYUVbVkJGaHr7NyB0NwK+H5N6A2E057ZdMnsP9s/EYA+DYCADifTm9+3SsAABD/0dseppxTziXT/YcP/+YX3gCIqBw7Su1/2vT65jnKfKRH8qP5dNCEisbDDjT00Xb9hX/42efvf+D5B0Dwaaef6wo6gvWPW74ednZ8xSZ/C0xqUmvKM8oDiWQjDwEDAAaIgCvtReJTMS0BBDk0mEDvtxFWUXtb9SWzSyFA3S8FtXYpNRNUgtWlNbDZWbkQFaIAv7cF1IWoFYghRAACWlrXFSM/HqDqecqIOzg2mmHNDYrQnmbRyMAIw3IrFBA1xg7WL21BaD6P3XC7cM231s7KOay7rggBAfww/Xki+vDXCkv4/uv24MFzD55/Nrw0be/8hVxKLuVd7/oVgE923aw9VAXb98PDqfnk+9txhZqbCDpoD7jvSRRd2cHu2Kvr1vGuPAJ85ic/RfBU24r+ruKh0nBVlhuKdnzXD9wPRidBPQnGp+nd7//sL8dg3mOKa9rt+9f9XpT6TT9kGihO/UHxKjWB3wgYlefKVggIyfQFUPkshgBUl2GpkU9jlPu0PIX7R5zhvUksolk7s73wlVhyxPB7z19FRdWzUBq3EeRNrkjUg1LoVqv1nmdkjzgN0i/XvAU1GqDKOx2mCD50doUe0gQgR9pBmwXXA1Px6q/aSZ2p5h8BEKD/5+/qA32lejkHWw2xEKW0X28flpz3bdtzTjk/ePgAiP763/uFik3MUt1Y3YRqPxUZJjh2KM4JgYYaFexDIw1voorvrEqrbknM6/1VFQrrvnnVyV2pKj9qYjMIz9yERdm/+SCtXdb2VNEm4xEdACLgux7ymkrMjxzPIhPthZ6IBQAuJSJw/5unEGXg833Ad4MyPpqyCmpi8TTOX+qZeqVAplQiOTZFRHYDObcFBL9PyyniGsIS8BzxFMMaGM0olUylLP219ShGlsZyQM36AcRO2xTTs0huMkYx2NYA46zPC3iAQDOXOvuOK7a1No3MhVMvl0gvtCYion3fbh/eT3lPaUtp+43f+EUESHmPIYB5onArRM5yUrviWOek3e5dTE1tZldr90G66euYCz2ZTzGb9qqf5hunY3TCATc7VZFzU9+gyuwojktpWYarwQ15HJA4KgjM1VlPXgxxkZIWKyR+S1KXbC7WBthHVHXQOipe8hWiQGLdAcAgREgAbCNA0rJBDWYR8dmML8D8qhv4kLaqeh09+/TLQ6EQ8H3Pp1e84LzU3cap4ieCGJyEqV332qYB2LmlNRCe0JwkqXxUluwaMliYy1nRtmQSxhrHn/rG/1Fu4XHBfpMcdmXI5rRdr5fr9Tbv+75vpZRP+qw/+4tv/SY24rgOaz/92G3CQVR+T0vgYezQY84nXLo7A+E6X1tzNdicUJMBJrRaCbnrADrPMhw6hgM9+4dG8CrgNcHBwCPTMP6GNuRAoBulPhHxdtufCHBb2KOMUPfryDs3an+rzMY6Rm6nGhM56Aii7Amr1QdqeFKxqIUQIkh0GQJ6GgkA3p8igBGpgINbKwQE5b3PXRcn09C64cgRwgDdxjzje68ytGaE2eQ0dQmDbs5J+BoQyW3R2K2m1WzPYCDwsR0OHj40B8pUalerZbLapkspebs8vDy8TyXv+7bvW4xLjAsQxLhozlYymchw62P/B1tcrJRnwqgFQEea1YVmRkijiAOHp75pV6V2vMph6opL7zyOuo6hScheTFaL5bRjE0YA0k9q6+med7/tl4MZbZshAhE8GTNR5TscWKGowER1iwFoqILFZAA9lmY7DbI17zKTs4LqFggBBb2Biz9+MOFTgV59A+9PzegAYX/xqwIRAL7vucvLXnB+3/PbgsHFWe+lh5EnNnNT1REPXQ/eOQg93tesYP5a/ScV+s5QpStW5g81WbCnMaCDY8b1Ewq+NtxVVpMosCXIpVwvtw/vP7dv123b9v1aco5xWdbTZ77xy378X3ydeWP2eAnaH/Tz3A5Y5VWd7okr85DsaGlCSI3e2BVqaLcBdWvhRE/lrvioD/tKmr3RdhwKUmiE0NCEkR9LSVTh0o6yKm2/e8tJPMVIHAwEARFWjuwUAIhv6rVJIB0HGUIrc9ftJd2V5YNLwWwM5I2ldb8Llc4BIAQgIL5ILxV4EkpAFoPSb65te9GrGIERADG8//mdzSt1YYrQ/OOJRQRsDpKCGpjEZiA2HBknWasdvA1HGM7ODlTlRLX91L/6yrUVc6ctVDL/g6KxZNparAZROORadySxOCFgYBuTdhFDCCEsGGIp5XK5vVxv075t19u07zHG8/nesp5iiJ/1RV8OqpxABY3aMByh4PBPYUEGLktTMxV1XxuyQTfGmtBYnRB6a4Tll8xgMwgIjRf/pLcVqoRIoemejtesXaAoo8TDpRAogNzz0Q6lHZphTUOy5DIz4VW/pqK2Y0QsOQHBwxKJKOuGsvPUoDprbIhztxpbc1TdPmVG1MRKqKoSIhBQAdpLyaVEjaJARLnAswVDgFedEUCMomSuvDrK9zx3fcULzojw2V/wJouMaACsJNLQpQeVUFCAEFECKAIiYoiISwhBE81SKiZVta2KONP5QkBEpRDDLLO7gimPQkj14nZlU+LorxHOBPzCW0IIGEOIIcSAi8SVDPwvIMp146rgEgGVnNO+p/1KJW/b9Xq5TSnFZV1P5/P5Xlziuq6MD1/+9b/IzBHFnlPJbAI5+WLaVoW8/eOTGa2lt+Krq01MlCj/BiJvqK5JN/7kexXaS7wAWTB1NlX5Txj6o9yjUqbbPDcaAOERSB2dQZOpnf36lQDonT/1KyARlixGKEbEJWBEeDJkUkmVia0ZoEGyJXTDEsQPm0FQbCXiFhjZXEKkm3bSTbIxlXJkKTkwoX4DBPAkZkR43x5YEy7ap+uLXqlV0itfcH7v81cBvggNaMz+4CCBJimr9LIyCqA6tULwqJoq2oB7k3rlnpX72/TYfg4JhxkFCxj5hoAh8g8jev2usPUo0fUDQHdXImIEgj3tl9sHKe0ppe16uVxuA4ZlXdf1tKynZT0DwGe+4ct0glQRVKQ3hJbKoXv4i4iIyWcTVli9s9uv0NKX55/6z8PWVaux+wgsaACOlVNoFPtJM75aP7COcrBSo+s0GRkLhWNV7K2+up3Xgojec62IZzTGpKj7dhKOiQySLj9/QSKU4Fs1gxo8a9g20RmMJOW/csApZQIi9ZxjRQ2eKwgArzjLColMsUYoUjW977n9Pc9tRPC6L/giAFiAlTE74q3dBDcN7LYMAF6LroeUKn05cc900JtmKvslW2eQGWVMWmNlk15Io/DnYW3Z7qjoALSfQL165oqb/4IAuaSUtu32cnm4b9e0X/ftCgDr+bys57is6+kUEEtOeqNOw8F9x8H6DXVN1dpHa57avkvXxHFUDBhqUiqqA4BzwRAyJzvL6IYufZvWYdZ23y9U1IBmWttR9UPsoNIQWlfMDdOMALL0Nv3Qy1BGDt67vFy3exEeZkEk1Y5l95xNLEHcRE3cKZeupC6xJkONvAqkB99Y4rEXeCZCgIXVKC2Yie4hfeQTy7svXvNGItpf/Cqmmvc+t7306dMzz2+f+4VvZvRcoHG5N1sDG9arQFFq8lwtIALYapClP/e1VXV6ArFE6WVzuAsUdBXIbWXGd2qF5Nme1o7oJvKORxGKCAByLvv14e3959K+7ft1266Fys29J06n8xL4qHSIyxJCfPD8s//B5/yff+5H/gmoUixg6DHORnvk32ZsyHfIdVu5E+gAG1I8GFUtpE2OmM/WCW9V6dxrjOR8txGg627feUf//VgcouGQ2mZ2llppnt719l9VL3M7c1oZ3RlTLtoyA5sAkXTPQKLOFOWcLLSpOFZKQI72jAKtc4is5fKiBWLEaJvKgLmU5yg8iTlRIc/72W3bzeMzz21ewi9u7FydXaqnNhtQQPiNDgw6Q5Ux6UW02M1FM0topFxFnNYKzd4b1O8mLmY1emxVCiUylK/C2PMGVILxwjkTlbLv+7Zft+tlu16362VZ15ube8t6YtoLCCEucT2dTueUE/nGAYCmgqUOcBRrqjnYizsb2wJNflH3pb5QP5VWZfPaMAKe79ZI6utsBXVTs29yzlxsrlvtoIq8fpzDY+yNBLfeeaniGZSQAgHyZYw2/3pJoITrU82c9crgQM4ON+LozTkYkwh4Q7+QGe8LWx6IgKigRJuRjaNcKJVyQ/mPPLW+++qnjAAwvYSNovC+57eXPX165vntc77wzSY3FvRYhKDXtnEGowgC28HQY8E1jCUINFqIItlQB3J0gs7+qEqpxbD93gjAtrah9pqdrcZiRkaUzRDUTbXiCgOVkrbt8vDh8zmltF+vl9tS8ul8bz2d12UNcQE7NIVhPZ3f9W/e8cmv+0sIvziniYqabhPQIZ87Sls3kbQvvng/aITmQzfqdteuF1zGS2tTzIkEIbQjLUEbLfT9GTrcMgWpqivYI0pbyVx4ag9yPdPAYTILEAQI1+32XoCHOQQU5zUiiAELn28iESmVUEkos5AKeyQkzOL4ggRUCpIeF+RxFYJcSiHIQBF0RVuICFIuD3B9ArbfveqokUAlU3Lb8c88v3VChK1x/H9vsPW2R5JXCIAs0jNR4lVGXYqLDt54mnpbm7PWdX9a4wOCjc7/G1dTnF6NDd5u7Q05ZuwFIL6OrmS3+pL6S8n79XJ5+CCnfd+u23a9Xm9jXNbTaVlPYVkQEUrJaU/7bhfNbdfL1/3yJ+oIlRDQkIagX466R1ba5AtVinKcBQHUCsrj7Y0uPqcP6V0h6saqBR14q1Wzr813yex3OGbrc08qGntbHxNEQzar4J1v+1Ui2VdAxAAQAq4YziGsEW+CbMIXor1QLuLLybiDei6CiBh0pV4NwqplAYJCJUuQJyKiwunMyUULFdMMHwJmA04mSqVkopuyfezTpwAQxVAkF6lfX/hKbua9z19f/vQJET77899UBw6w2MlhhTR/Mz2D0Tcoi7Nobl6YieedvupCtZ+RXu4d5vBzY3/8+g67DG1BHHQgUEYhr4UP3HE6Z09pv14fXi4P076lfdu3DQCX5bSu5/V0jiEyn8o5435FDDGuiOGDH3jmfe94K378H7f2dFite4vrZCP9BrHWFag3OR2Aycm+mis4MmzkXk1v99eN4J0Y6lTQrjkcujzK2Fq/Dcd1yecU09wABJ8QEH77QbHIFGyEKAAB8bmHt/ciqLJGRsuo8pMZcSmkx5sgU5Ho5qqsEkj8JQS0sKIAEAOKzqRRMJR+TUmlTHQb1idof/cVo1pqmGq3l/whCTwK9NInT+997vo5X/hmcGsrrCEP0Rs1RHYiRuFCBUDuNTFI2uadmxBFaKvSg9qRp0NYy9wAXwmmNQBWkd7MqhG1q8OiRk8wRT4TiFJCALnktF9vb1kMbvu25ZzO5/OyLiGGEEJcVildyrZdMYS4rq949Uc88973NopfVV0qEnTYbAivCD3qm/5F6jDAThAVe+0R/Jy0pe4gN4DGqtT5hdZMA+PoZtzmbE6NUxORtd51zmULcpMpoiMzpkMCyIU2iksAlpaAeoKWF2wEEHTdy4GsEANgIuJAWwSUiacPQZl0UAM0y0CWg3yhL/Llk7rrUKjcw+0PP3X6/SS9IgI+9iTxExGeub+RqRGirErmxeyejjojRsWlQnq/sgovyW4bhY4GGjqTpqTWmS6CzWtLsuOHyWNoiRV+TSG3UFVwEkB1IuUhlrxdL7cP7qdt27frvl/37RpCON3cO53uLcsaQozLClRKKZTznnZEDDHe3Hvqd3/lX4VgagI0XVDyawbWG0/qcnEmBxrClSHV3Y7mmzNskvsgdNWRIgD4i+0bijXTTzWhHVLOgfzujUtYxefAFaaPK84/f+unfnUNcIohoFov+dRKQAS8F3KW/To+sAsIiOQceIlKQSK+iRiJKCAvF4vyBeKYvzHwUUCKHJGV8VpRO8s+H+k5Pbmt6RJOT1B6/853UpJGRYD04lcTESG+//nt5U+fn7m/ffYXvMmGZhi7mGFMHFzEuYAAMukRS7OZ8ISi3ArrIIY6bw7A6P7vMntEdW48R5NBTSmPZG6+mA6rquUsMS6jRlzmvWgtWXLK2/X2cvtgF0X0mks+nc7rup7O5xAXIL74JZaSU045baXQ6eZeXE9mmbL7IgFg0Tgi3chM/zSX0g77a0Zqvo5Q6asFqMdsawW1ZkO1hg6nmmH7bocSJ7SHhwqkCnnfVoMb1S7txGnTB+YCWqgAvOth0VteAPQIbUB87vbhGeFa4qIeBhatsEBBCggUEDNpiGRuHiV+qCwM+Q4sBNQIenZmwuz1RX1lCsmtTexiWgrdg/2VT64fYquORgEXSSUSlN77/GUAluh2i5hk7JxCIQsVZTJOjYoKODcfHTFWJlj1W9sZCHXaSW352BTucaGeyvbaUNNqW8DNtC5S7a92j6OaiS9vSZTSdrl9mPZt3273/bpvW4zxdDqf1ptlPYW4hABAEEIkgpz2nHNJaY8RMTB8f+eD+4cumXv76g9bXvxUtM73SA86tYNupsNwYBm34NpP5AHu80BfUGaKZL1QraDoCmrLXgAaZc8p1ibDESrW5S7WSuRT5dZCKe2+b63fiuoZJx8cmUuq6IMLBb4igorIMQCVZkQhYBEZA7apsGscGDZ4EMilhZmPe7OYlaUAAVAByIVNPhQDrIhEZcuQi2itH0zm7SLqbn7JH+Ll5jP3t1c+ffO+57fXfcGb2jgWAosFQ+SVLlTzj98q77cL2regr81X6koIumU/pT0Zof85s5FB20w/b2EmNY7yC11SKTnt1+utycDr5bZQOa/3lvUU11OIS4wL3x9ZqABRKSXtOwDlfXvb930DKx//wzf/6pf8Jx/LM/r7D/OT53Bv5Zlt+X877s7jxWdwCmfHfTRJoNjtR3SMcKi+0kwvMsdVpfWm0qd2rXeg6WtGZTfGUBpKUwxBcOevGIvoAB4IcM0FhH/pDUxAVOiJ89n8ypYYzyjLMJDISwAgKyo+GCEBfBVuJLvzHECdovKVoJ+4b4VgDXBCXYUSENF5kXGFgACyhkPVHkop6q2J7xu2JdwM4SLCkvSmb54QQCW/pihWFcFg6/F8EqwDutxUOSf5umSap/Kx+UkwtFtnC7zCddAXsjpS3rftcvvg+bRve9q26zXt+3I6nc7n9XRe11MIGGKMIQBQyezWW0pJZra8bNcn7z1hmigRRInBO4yjR68q5gbMA1SB6aixQeJaBY4CU80rI6l0TXtZfbACrB2yfLUu4wa+oOmSNV191q1X2Exs3Z8kpS1vCodffeuvvevBzgKBCECv+iAVpYhClux8ybmy7lCAOsEoZULRqKDqA6lNS9AZASJf4wFOPUHdCxNGI7t3wpkK2qkuur7wVVzV+57fX/bk6ZkH18/5/Dfb9FRaAwCihcnPaES3BxEAfudnvqPFjxb8Jnyx571e0XIYgTcn/MOf8qd5p0qBoqxDSLLzeKtz6bpeVZrJ021jTdi7PDmntG0XtojuV94bJIJ1Pa3LeT2dY5SzFzHGnFJOeymZqFApBQDSBgBPPfFksajoAAD09A3eLK3GwX1F/953mWD+1WZruk/ayj3Bl9qOx/RGgB1CyHjihC9YYhXW1RjUSeDqh6AysdaPY0+wC7tR3WIJQc7MQOAzewSIWNRayfjCx3ZADjewHd9v69Xx6g0c6EZpUpqwjaKtP6oFS5wzK367S5sQSuE6KbiqX/bk6ZkH22d/PvvHkBcNhsNqHbXlJyAA/PpPfTsQlAZ6+rtnqvyH2vl3P8Spp6RClz2+9zv/7qe+6b+1WOOuYHXCc9pKxYDuMXTxNNdPrQO/Q0LGgpz2/XJ5cHn4YN+3fbvu25ZzXtfTup7YIoohBGT/ISTEUkpKOzPRUvLP/cg/9fPHc/TkKZwX1PubFAADgxoBaXR0xDSapVPLGQdB19ZZM3U7CC2EjJ70y4RiffkJrbueYF/qDm5oCD0JL4BEuvfNfMxMNaqIqx+aAq+KP++Q4bYf5J3JhV3e9CwLkRxQCHzPD1IAIL06ktUdNn2S6oQcuFkgq/J7e9GrA0Ap9Mz9UQs1WqzP4kUfAPzm2789ZdbYqC3Zg7LinpFO6bVC7hxT4GkJzz/3wc94038n5Aeknv1u494rPdSFPa1T435ijyQe07wDAQh/5nHllPf9erl9mNK+71vaOHpFOJ3Py3peTmuIIYQY44KIpbArBZWcmC3+/I9+o3NpZ72IAODBtTx7W54+xxhEBDRToJ1gvWayDDMz9IzamnES0fCJXKaJK/Z82dfndD2RSrs593qPIY7TjJrO9QTcpjd0brKj+hEQAPzaj//aqmXZ3B9bCkdZuTl8rBJVBpixSQelpTp9VSYCiJe2S5cxil8pYl3Pi4qqG4+AcH3hqwAAET/wcHv50yfblvA8wHgzY/3ipcxv/NS3Z7JMLZz8RGCDJeQvNmi+AhGkUnKh0xKe+9Dvv/bNXy4b+iRbCFi74obbwZi8vOuIUH91vKWyFfICkGsrJaV9u15u037Nadv363W75JzP55v1dFqWJWCQQ8AxElDJe86Z/ZTQa00Azz94cO/mxtIQ4WbBU8TZJryARJmmzspUz8QKeo88jtgavwUdoSuCXjVxWyL816P5IA/BT7uH92DwqVRUCyrrca7mc1naoVjVcq1ymcXfup9U5AEC5pYDFepmu1joWkQ1gus5lWqXrtFkgLf/RQSg9Q3Zw814OX+12yzABCwBIAaAggTZhBKFgM882BQ3aQYGGbGFpYBf/8lvy8rTpR2Dhopi7jv5z6oSe9Fvn/dccqEl4K/90k++7k/9ddY/xfFND2IJHYM7H+6f2taAq6SgVuA2DpZNkQKUiTgcRsr7tl1vr7f3077v23W/bjnty7Ksp/O63sS4hBjZKMqmgJILLwgBiKD83A//M98HXkl+w/e+gwDureGJs4oKRW7/zz+2BTfL0FCBfcIhpSGhtohOMUHXDWpyNgU1U2s5cRWiT+ubJP+xPVDSP66Cpi5t3WYzMsq4rVU13ohoNBkJAEQl88HZwh1g3ZR4VRmDxLOwf+jC43r4kpIIHxfiQ8OLnBivc8P3aaMFdylwffGrGJmfub+99MkTALzu894EUwx27GYBone8/dtTe28BdH8rj23rIZcRm2IIsKVMgEug3/iVt/+5v/G1ut0iApBhJnRdrSlu/tU6XDP6iZUrAEauKlipmMAJQfUGKHnbr5fL7YOU0p62fd+27VJyOZ3vnVgMRol8EQJfgwqFSimJ/SeoFAK5nvr+w4cAkHIxUBDR7Ub3Vjrp3DrZQQDtTkDzVf7gCGWwMXW5PepMFFgEcCqKs8148iEHpQ6OJluGzqjY9D1i8exfrFEnMNua2jVg3woAvOMnfi36WIMgtxzVadfZtVVZ1P5hXxnoFDlReKCu1HImUUjb5eALsnsgtkQRJ7o1AgRU6H3PX1tQk11s7cQiAeDyb972HcVEnytQwYQ9mDocQUfVpHh2zRkRIuTf+rX/9c/+9a9hbuX0T46ZU3quy7XLeqte2za6erRs1qDeVOXmXgiiUM4lXa+X7XKb9j1t133bitlj1nOISwwxxoisyxCUUkopOWWgTERv//5/3Ntv3fvDnd75b3cAeNnTy4Ku16gH2+qauQGi58SDi6zjjYMDgH1HaD60jNFoqd8apxZfO2qh9lufzW6yqu0LHXc5rW99r6wMTvqPAAHw15+9ItYLrtxxK0Aje5CrlBU+RNYVGaZsW6Jng9R01WCr7tkKsQDARkqpQRkUMzXUTVGC64tfxbP6/vvXlz51ev/97XWf/2amCGumtGG1eNiL7ZkADIIOanxTG/dovG6ogSkwZQwQoLzrHT//p//Lr5QswbxySHciO8OLIR/VOcGAhBp51HFAHpF5Iom9w8jRsF77DUCUc9r36+V6fZjSvm2Xfd/3fQPE5XReT6cYY4hLiDGEiHJlTy4lUymFCuWSc7b6b2/VC4l0fkBGGQMs7CI+YDcq+Y1472Dckt1AEk1ZlWLYSKahXhySFEk7yewhjI5n2yHxpj+d9GzKAUDdtveCseuYI9+JzORoLgCAQAGCWWD9TgGZTkU9e0MgibxLGBrBJ5KM/c6yzpXACUXUMWETizv92Y2AQC7A4t02Inj50+dnHmyv+4I394OlhsFaRQuBoVEzeJpM2VxzEI4AjLW0p4IBsOT3vPNfv+mv/R03YqgT57Qk93NSuYT80PgAahkmACJb0IoMNKMAcexJVz0CUCmU9u329sG+XVPa0r5dr7c5pdP5Zj2dYlxDiEuMYVlEFy1Uci455ZIBgIje/i//wdBN4ZkGn3sL3lsHq67HYBMeIxm0+btFwJgTm++j3Gv66Ys7gPXVojXsRUnFh57g+G1QZpoa6+jb0o5YGy7Bff21H/+1qPEbuFyBwgtpIixALFVikKvImjGQU1EY6tZF3Y7jFlkNDDZwE48efaQaAvFxq4YPE6zXF70KiQLi+x9cnaNUo/6AT3UvAWzB5eBHbZkJltiCuLIkKlS2lEMAyOnfvvfXX/8lXwFVZyAAkvhvFVTeP25sowWqeEiQnofn4GocZy3qGjuowusHi8C3t+77tt1eb293frYt7RuGsCzLurAYlL1BPrNbSs45l1IoFyBiUvT9rIKbCAj+4fe9gwBuVry3moHDj4x8Eo7/WvhWhkVjVR6EM744VK4MrK3hKB30hLZPsaq0pFXc1YNjTESqNdR2j7rtWv/VD96K8JA1mAqlSsxyD1k3LfVYubgKy8oNG6uMg4GUAQuFW7kPTzAVIEA+akiK+UAF9LZDQKLyzIPtJU+eAOi1n/dFU4nlHfOMcS9uR7P5O/JI/9CQIxPtqcSAlPfbD73r//h/+X+Iwmw4yGbicDQDQ3e71vXdmbJ59djBzO2PkB7FAsopXa+3l4f3c9737bpdL9t+zTnf3HtiOZ3jEmNcY1xijCGEgEiFSklUcsl8dQ+8/fv+oeHZl77+/wAAX/ktv8Ddum6XJ+49AYSnBV5wE06xHyDaf2ZKITpZZyVazaRR9VTQVYEiiQ5xvMjpRNrQsebjkcDD4Zdppu1R1L498Dls90I4JI4nsGw4biONm5ObJRIUEPe0fjyoF3QCFmD9UwJbMDZU7xCOupZKccUJq3sKb0mibEI0uoMIyyJbiQAE6aV/KACEEKik99/fGuNiNwyuu9EM7VCvB0NLje5l0En1VyplTxQj5rR92hd+MfcYMQAGO90hxzXU0a4zbzgwQtUYwKGF6AmKNiZegQAIx/UQO1YiEkBO23a9vTy8v1+vHNV3264l52U9nZbTsixCfjFymGAEzCWVQqXkrBG/dX3dbRUTEPD1JARwb8V7qyelEY6W1qwYW7UHwEk4r4oayjqqdrZ7q0F/CTYbNTLeg/Ew1+ioIkKDS13/+asiReu/hvrSUCMCeAOJlkL/rRnxaz7zNa/xJOIZrUvt2xn0uKkkmYy9Tkyfs51G7D8D/C8/834iev+D/SVPrR+4v7/2897oC/Ivk1kj4mtQ89nDGqdmmGcipsBMMULeL5/2n3wxiGSPdocUAEebj2rVZe+CABgBI+JS/2lgbED9F4J4j4miaGqGwAPrpMs/UzwAAKAAFb5a8PbB89u+pbSltKd9yyXFuIR1jXENcYkxxhi5BQIqvKOYRfUoKdv4v/T1f3QKCAK4WcK9RY99zSjQnpplmHMLIWM5u2KNBjvVfOv89Y26NtpPTtscdZXuk++b9cRptTbLtWNofa9qi27nknLYdnOhFmvGQ37MrmEyhHUoMVYygSpWO0O/frOcbbUtT0J6/ae8lPHtAw/SoIg2Yh6UAfoqlimSfPnf/Lqv+YovM2MkznCJ60mFUqEYIF1vP/2NX4J165IzFAQzklQO69QYbNMnMDKObAzFDWsmUEnDCCAixUyZbTClpP162bbLvl1LyTGs6yoqaIxLiEsIEUMEAGLvmEKlZN6jeNv3/QOvWs8fghfchJu18QzsfJp1HP3YvLT3QJjsLjaFGxD4s8L8p0JWQOZ25mauvuBgPfnaiqJWZla0H2vrxGzdamAR5ncw0UvFKloFUXowqbWpClb5Sr41tZuPhv36kEOy2eNJkfGw4ZMIr//Ul/CHd1SwtT6igxDUBPJxRxEAvvxvfh0BGAVa7qHPAOoQEyPs19vPfOOXglBg494Ac0JhlEFo9pNVQXFYhVDH0gqHOwlCz4GVUnJOKW1p33Mu+369Xi4pJUQ8nU5yXikuy7LEJfJ9MECUS6GSc068rCwlM4tE6rCqagjMz1kXxWa2JL/jGdiUBKikin16rwO1zAyadRFhX9zRCfa1jQtI6LDbfR1QYcr7wPfGPx5oDZNBMNaB7reW6E9pVLbUIK16xWoZs4wPI2suB2062xDUKL2aIoaeTTXqhfgx28+84/QplcLYQdxmzv667YrFmvry//7r2ObztX/ry4bWjVVXFrPlUgrEANfbB69901/j0/dU9deDRV9LSl0mQgCNiKXYcCCAptLZCJgZX2EheHt5eL+UxIrow4fPA+D55kbulljWZVkx8i0xAQEyUcm5lCIHCAv95Pf8fav+S9/wR20WX/D0U88+dx8BiCjtezyf763BY3hln+MIjjmuW956RwCy/48u1/4UX1exk17YYo++VNxt5sbTc2UoOEm3F3SfppPjP5jExUYqQn0BwEpIKnvbfUWo69xar2Ywsc9f+cSg2ETmpKjGBXSS7kh8GvHpO0MIAeFj9p9+x/qpflfQwDyl3MVA9jV/678YW2qnqwqALRUiiIGut8+/9s1frjuZpFBCa/lAfLVzpdmdAsI/GwpUJKh05jo4UecLlZS26+V2T2nf97SntKeSCwaMcTmdzsuyxGWJ6xrjgjHGEHk1yOKzEAHlnLOvllzH//PP++iv+pZf5Ndt2//HL/nkm2XCG3ynKgNHBwLq8w8T7/j16GrVFa96xKwfDsL8Poq+2o0Gt5uqjBT7crzjf2C6rEKtHzLW6I4NmXlCanrbcqJGzVZakEqazuqZhxY0BnPb06zDv4MUB9lvCfgx+8+8Y/0USa1HDiuj8yxvviacNOdQ5boXAIiBbh88+zl/5r+WhuTwckMJA/6ZWgaOzSvMGh1uJjwq8ljUJpXqxIN1iE2U9v16vb1eHqZ9269XvnQeAy5xWeKyrOe4nEII7CPD5hTZk8illAxUSqGf+O6vt9a+9PWvqeBoHwx4bx1k9qiYNaOUTo/wag2FQ1vtikQYU6N79Zpf/doSTSdnuvYamh+pcZCK9uYlU19hS4qWQi3xGTH7pmr9mtStlqseMfQKHVjasCANlyf3S72wjp0luqatSkIA+Jj9ZwDgHadP9XDoiZGA0LYoakYF7JQ1CgVSRPqNX3n7f/bffD3U/Xo9NtzyMNdNpTxHe6hQAdAKsEKtHa6bcyp6goRzcfQ0VE+1AkA57fv1ViJq79u2XbbrJZeix3blqESMK8aAIYYQOHZFyblQLhLKInlL7Khq/Y3/9JP4xyueXu6t9VZv22Jucrs5rwok+o9+vAwSmnxtS8kKoP2udfRH+8hlcVUbP9SJPBLo46c7072W25Bi2y/Pt71/3CiGPCWgq5q6DAe9asgM9IQpwITpawY/ypmS0qRr60oBCB9z/el3nD+1RWgyjifoW2eR2k4Ty5P6pRBd9gJIAco7fvXtf+m/+Z+JMlEG4msy+LhQISoIRagL2ChdD44Aol3g1zYCvpuVQfKOeylQMlDmECHeVwWAyAJMBN4NiQSYS9m2K7vGJI4muu8IsJ5Op/M5xgUBOKov3xIKiBravOSS+XbHn/juv9/amCb4DgDniGwXrf13J6kQ6qmlduKceb91bgFf0dTE7iZ0LIwAep7L3aragRhkL6TrFU9Yh7jYvlhK/dSmHxRu2sHKb8lnlB/oN4VrJVM6h9Zf46hXk47UgrUbY/99hXgwpkkrPOtIH3N9u6VVPm60RiIJ5+wWHIlnoj0RIgQqv/3rP/MX/8bXQk6qGBkz040BAPKx8euIpzhMNe4Y1uHwLMg6ejaR1PwuQOzWj0Q552273l4vtzntadv4lqVSMhtj+K5PRA4fEwPHUiY+OJhLySUXIirFlp8IAF/Sbg96kN0TV7VutDWLfeukotEMgNNBOo5rOlSToLzBiQLP4wEGk7zkxPqhZfYN4TkVv6nVoWrrOTBJrwWHnSWoY6Kq4DRkBeJtYbrAUW8lK1ALt6ZXnTdnhzy1GLlueXAQgNwv7CucSkUYm0D46O2nf/P0qT0aK+1w5EyWL+5rKxpzKVsqCISU3vkb/+uf/6++GhDk+uugznYhQJBdeJILgF0vcEqBwq0rJ6egmZUUm550I+1JkwCISk77drm93N5PaReP0es1pQREMSxxWZf1FJc1xAAAGDDECAGLbA1mMYoClSKhRHvQed0BAABu1nBvmYTi6Kak5+Ier4c9rE74NP8OgCHzQBSIb6K1RpywdeD2ZWmoT35gx0nbjo0SzDrTV0i23d+m9w2QHMgGVORvWJXrda2knaTmk6FR28k+T1MDVczshmrgb8f+GA999PXtE6UdiOrNu0e4ApAKbIkCAFD6vd/8+T/3X32N3E2NtiOuvhFylfYAVVE5K/M2Z1qomioiBgms1T6tAoDsRqPhiFv5g8RUd7k8vF5u03bZtmvKKW1bKSWu67Iuy7Iu63lZ13VZEQCI+PIcdteWm5KpUKGf+t5vsIq/9A1/tAKnBdDN2uuiU6bhVc/+weqjjdhjzFjkrkTF2jopXcZeFrfda/Guo6v+GVhBx2Xa8SLw6Rbs8FtwqC5La2Wkbm5C1pWiZjQwJXLXRE/AHZLaJrBP7ceNIP2nymiO6HAs+9Hb221sdZRAzQlDB0Rh9XsueyoBAcr+vnf+0p/56181Y8wotAQdlvE8iAOaEVudWRToEyBBIHZPQw0oPBmRIzqqiKPO8QgEiU8M3j7gTYntertvGwGFEGJcluW0LGuMMS4rm0aBCNgNntXRkkvJAMDBLGw4lfwGzONjExwKw3DJw0b+ubIDcbTQvOPYBPfloKRj+RXCNif2petkD2j52qxQXIIr2EuKocJR/zRpjH0IEoSGedcKZeVa/ailUEtRbefnHGMk4IbLAAA1tKrlOhMjAiJhHzfrDlKsXwk+WtaHTfbpFoWsTvZMhSggUNn/7Xt//U992VcqBoiNVWtymhiHz6mRa1ro2grGlbY9HyflsRaebFUIsNwSSvSXUlLetuvldt+2lLbtetm3675diGBdT6fTKS6LnJ1fliUsLKD5mjn+b86ZiAoV26BHgi9542vqcLo+A9xbAttFBeWoMWygwXOGF1h/ur8u53xJBhWTuo6hRxmrDNvjagozrr9OSfO56eF0KVXbIl+iTl7N1lXOaXWPwcbEHLkBGFlDTpMaDcK+Fb+F0y0RwW0AWilUjASods22fvMRsNoQsDs2cABJ3zcEAKHD3zx/mnWpW8kQqNPLligXQqCStocf/K03fMnf1mpQBgrI14ZWVQadGa7mdWRkkQNAtVRBBTauFigcnbW4NRK11lt5JbJArUqTpaR937bL5fIgpz3tTIfXlFKIcVlPKgb5HGLEGJdlRcCU9px2pcMCRCVnVewMWxsYgRpCvC4qUqcVMnryZQRzP0/TeCcetJoTXfIojVxKK0zdz0Eoj+1SewrdhGovFBrxYq136WMjDCYkVwYAgGRBOHTbOmBg6UY+sphGBLl0QNE8vTAM7lwvoiojjWJnarEbFoIdBbGc/ixlTwpWE8BHX99mCX6fsE7MdS+FICCVdP2sL/prPfBqzcJLcajDQaCSUwtbFl7MDlu1xIk6oLaO/tEtykK5pH27Xq+XkvOeeGvwmvLOuuh6Oi2nkzhqLwsfWQoIRDFfb5ms5eZVoJ/47q+vXXGtU8M5AVQXjarAYVNo9EJpAdOM42CEnZQDgEbxmAc0q3C3Ka1zJd+N40PL571UgsZHAywzQLNL7tMnwnNIry0wlFy7U8niG2pqOzq+6HWtVt1okGw8QKA9QWxyujyNU5dUj3WqPeXbiHpprB36qMvbfuvm0wD0ZD078/A/oUCgsl8+602OAruRyM/CW2run+k+VPPILRoNOrLioTboyj5It6qqhKQC7kw+WeWyjymXXW/Xh/v1lk8qpcwOM7dAtMQlhoXtMTFEORYVAga5xIwlJ0vCkgu4Dn3J619TR91wBAKEe2u40ZvQsDE4NGv6kTW2AKUuW32w+dfZTgRwVVo2FVRMscpUenZy0CiwL+HFmbaInhjGZxgktj3p6rf9QhyLWJ4Rbq62qbnLF+d/NDOM4Sxznzjm6ckZ6/Eza87V3hgPvRBD+KjL24AlISoaEIhTaMCSt8vr3vzXHId2lmJhYX0vqX4/kAEIzG6wapgtWBAA5CigOztRvXBIlcTKaQGIaN+3fbtwRG2+Vj5t275tiLiuJ14G8tY8n11qQiQglpxz4airmPLu+1OhOQidmwWfPod7J4ML+A1PEvhLWQfHWlHLVd1D7qNrfCpbmq41OUAd2vp8JhitDKpoG/U6aYp8y70ggpbli3jomm273WSWk/K+PkVLIfpKG1ZbN+raIrU5fcEu5/TBRsHoBX79ZTxwFP9OlqrKIWK2IwiEj76+zcJbUCHcUiGAACVfb1/3p/6LhqfCEDaxGZYpCK6/0CXImhsrbB0FCvFinXajMWWYALoOdAhIRDnvabtcL7dp3ySe775dr7cpp9PptK7nuJyWdYkhxGWJcQ0B5WrBUq0yeukS/dT3/n3BC4C/8oY/1sxDy3t4jz7WXR6YwKCf7+atQxT7jsPHCsB5iaMKJwf0HfPxPUTZF59tQwvJOWfvqmu53A11odPuupHMTq9zXc5I4/80JGcyo++nUf4BtVt+wp4Oa1Ut2RMcVgKTgXc8ioGmQgknXeJneXBNAEAEqRBRiUBYLp/7Z77cUxIPuVmU1+ZJF7Et1No3IdHWB6zdbwjtLpUuFnjXy0AWKpqzfKTCrqHX60UUUb7gZdsuALCebpZ1XdY1IAePCcsSbT+jFBGAHFsUAHJOjkH00OqY4s2CN2Ngte5pVtHk/n+QHZuMUCfO2lXqFiToV54Hr0oR7p0b6XHxDnJ3YtYfnoKW6zdoqg319NnKBKzpTp517MRBxUHpmKvN8B1dn7EdvhtchZ31pk2u8k2r8GjpeZQTiSCAwoHNhVRKKiXJci696zfe3lEgDxrN6GO1A0iF6NRLJ6i8/QmtR7JzaKuTABAgxGaPSBaKzT6SNeyYIwJALpRT2q6XlJj2rtv1ernc5lxOp9O6ntbTeV1O6+nMnquIIcYlYCAqcm6wZAA5S/8T3/33BinOAzIvWpmMmzW84CZyYLXHeGpZWzv4EQVnoBO0RuR/Te7uQcfIHHBkO3xgiJ1ZzXAR+2w19/jJsVvEsVTbE2sINb0me8Nv26+6wh2GCyqmjOC7XP1G37DGMxKalm9kCfVAaHAD1SVYanRcqfYSbDY4i5xyaBtdYrkgwAfe82/2tP+Fv/G1AH9VS7ZNe3JGqHf0eu5cGZrfKLOfI//3J7YAgJBIdo4Cu9N73jgRIaWkvF+37ZZ9tbftum0SwCLEeDrdLMvC/qIaxwmB1EMgcSCZTBzdma2jGgoBEf7K6//YocQi0UXX4F35j3P7B7u/c3k70t1ERfTLulGwdHx9Vh0eiD6bSQK4Y3XnG54qaVORiFhtEPX7LPwEtomdTgtOXQTXj2p8GgSaVQtepx2gV0dmEm+qnfYKMDnFE7pZqY36w5EEALB89pu/TBt1VjO0AXpibFc/wqlaPZ6XqXrvL8npftJgoQFqVqi0SiL02LCKAEiB1DzTrSCsD8U2Bh8+SPsmG4Pbdd83DOF0vllP52U9LXGNi8TVDhLujQCwaBiLItf4wE9+79+zsVVAz0gEEW6WwLqoY5pdrrHL89q6bBNLyjF948CcPJbUydZ6GvKBFiGm9NZScoeCIPtTssgfSLTva0Wl6X56w1cEw71Xxqz1Q32ypYCJMcYoXLYYRhhaVbx9ORKqr1mEH7mheHhrdiYt1y4SLFhlvOVycs28gDzrani5utIBAPKhIgZaxWFrv8dVJ8rlfBnTrNOxbF3byQfelUjb9Xr7MOkicLte921LKZ1P5/PpvLIMXBYMATHGsGBAAKRCRGKG4TgW3ANf/19+/R/TLrpH327W8DTv0WvfOu/+To7NgKcv8m2UfG02j4Kj7BnwHvuuN6kHBNOgas9cpsSg2Kq9J2hrdvM1HxSNAG5oXvfgjlv3MrwTlf3ghubq9unMXurl1Xh6o6NDML867aiZKtuOMJ5xw6KdLizftAAS+v5UC3sjHbw7i9Tm0cwNQVrEfk4AUMMmyZlg6TaaZ6Fvt8VsAkDelrheH97ePtz2bd+3tO9p33NOIca4LAvHj1nXuCyBfUtjCCEAAJWUkviIUi7safbj3/P1oNzIo1R93Bvv0Z+iStV2pqED0l1P5/nUtzjK0EpyHsKcAfuyjTy8oz+V+jQS0kCKMBD2BKf9vrUVHIWYq22QfmM2B1FsOjaKxE76cc2+n4pwTQ+nYrmpBpsejqMwdtB+qqQ45BVgc7ULn+utoSZUU65ZrbP9Q/2Auq/SkN6DbV1B7jAnqYcagh6DUsGueZm+EZBIVVQqiXchHj5gebirOlpyPp1ulmXlEBYcVzuEyAGSQ4illJxzSjtLwkIFCIgMdWwlPqdAAgjIF06g0cMo/Wgm2gYa6RIdSs+g6omqlzhjsYEDtzM8eEeaodpgPMrVwazXkRBzcT+WTkr3xakdUTdaLdXgf0uHYHg9pcMW8RlhARvhiTqQOsBJbzr5LD/7Fqv+5gWmp9+G0pn7E8GixZxw6z0EPSAG4uy/N28tBZryFpj5IEf1l6mSLQpDBs9AABAKoWAIpZQ2Dh6Ttn3f+LxESinnHOKyrEtclmU5xeUUY9CAoqp3A5TMl0xoEHS5B7ui6V/WWDKe9uy5WcPTN/Fm6U97THG6SWrRegAYGsfp2a8rVVFnYOq985nxFYdzBm7rUNcGWmfGSCwz20mHLorBdSlXyWCkw4O9xFHKaR6klg6b+pWqq+hsm5CslmNKaY9UTaEZyJRgYTIcHIpWXWDpKsEBfWy8Nilt+oTlQ0N+aAACQOKbvQsRFrnyClFMPjpxCiUbCMkefUAEzDml7bpdL9fbh2nfc+J/Kac953w+nePCsQyXZV1DXAIiXz8PACWXQnxQgg/RF0QsAD/2L77WmjRmNo6UH7aLnhctYEM+VArmE3U0ebUL/VKryhXoNIWevN0SphEmnWSYUVazgdZxbm2RbFEzcy7Ryju/0+7sQtfdkQ6nPa90CJU+G1lE88FW8wkdiOUKkvk2aTsY36Uhcy+zoTUzo2uNAIZAT+RM7kx1zay7GcTmP9oT2QBoVFA9aYoUEIiv0ihQCAEouP3HKgUqOyMgJKIgphoqlPa079fr9TZn3prfc04p7SmnEELkaKLraVlW9lVDlCj6AJT2lHMqOQEAH+GNy0plU28gBIS//IbXwGwO+AkINwuav+gwP3UWKrA8cx7yjMUn7VYI907VQ3tdQq9WUNc3MFpvdKGKuB3JcuVYsWm+TgOmhwbzu271lH9IzP2gqst31RzaqnQw1Dbd+dNMH6PbyX7JMR32X8EB0A2rEknLPRY3WhtQZ2zru0PQBH7R0REAsvnREa5kJNuul2NK1AtA9BKwYgXv2VmU9VySHRRMKeWUzB4DgOfz+XQ6L+vKa0IOa683jQeCQpRzTiXnIh5rJVD5ke/8Gj8WuGOhwrroOTa3vhzQGDV/Dp62bJe3IfP6rbd84Pih5/DVpQXbUoaUo/+KLNUNHVubRlPP8S7ChA71ZcRaX0mVISM9GJkNnYE+40CH4Ferd9Ejuk408tnzCDdkex5Fil1eBAmD34yycYNo/vbfeQJQ13XO74xcPgTS2ylQzwqhCcDK37U6YW4G4NqdUnJK285Rm1j6pS2nLaU9l7Isi0XUXjier0R4CwhIUKhQIeCrzkouBQhKSTkDzaNJTQF3b8F7JzyPVy8NxXGoYrLib1OmHWjEwiAFDS3mmGQ1jCb2jlQdl+46w7PHk9ydJ/ekOHciVVMNdZx9RodWSQ+kYY9OU6HXeH0RmJG6ZybSr04Mt0xtYArNqxsSjV/doIaTX+TK4UJUbAuhYuIhc3AVIUcoKyCGzcZJzqojrH5terdE7IZL9Y23KwogyLk5ZVwEJectbdf9ekkpsRjc9z2lPaU9YFhPp2VdFwkrusYlhijrNgwIBXJOUArJUfrM6PEj3/aVdUwIb3n9a6ZDt1HdrNVfdCb/ugLDmxNWNMtTnxahAYb8LVndNW+V6YM3ew4coBVZI+9V1aTTiE3gwLGpx1aaTf1TOpzqIEOSIvew8nS/7f1ISDKTmNKqNQGg+xxH3XHibtr/kQ7bSmhRC0qAOp3dRfWcqjKrEjIB6M5e3dN3MoVdH0EXgSJwbDVlvB2UrRGU4uDnHyppz/uW9uv18rDkncNpp33f91QKradlWdZ1Oa3ruiynEJcQFlkQAkCBAmyKyRgipJ1KQb7k1bV3N1ERwBNreOoc7y13+ItOZ7Op5c7PTU3KqWvVVr+pkQBNtqp9wKhNKaUoYk26q22Mmph91VUCdXmOEb2VjB0dQo+dOPjK1WJjx4zDN6RtYwUv5qZk4+iwt6xVojpYItZKsR5W6umQdCqHCbVKbLPeUsuQqyE/HaRyRWxNFDViARKgnNl1i0Bfs2SQnmah/QDQB93gKwbzvm3Xy6XkXLfmSyolxRBECz2dlvUUYuCHVVFELJT5ojO2jnKbRJRTko4BAMBbxEumnwn7dbPgE50uWiE55+D9M9m6aJoYP/j8pUlwLQ6o5pF9KiSrs4h8reXs76w7vklQda4d/BEYpJPSILXpE6Q7Om3Uvk5Jewy0M5ke9HQI7Pk5UogKlGMv1qFP6BMcy3NAaOpZ0BWvFFiFVaU9LuO0mfkpHlJGjOzDZvY1AoACgGIpNblJBKUwvxl84GUAOee0X7ftsm+XxGd29y2lLacEiMt6XhcxxixxXeIaQlQdOyBAoZJz4hvOSspEfN9y+fHv/v/MYDkAGgAAYoB7K95bgvPhcTRVt9X+dzwt6thr51CiWRySDIyaugI1CEmrvyEACW1PcBT6xZiyXqMQQ9+BDsfGwIvotrV2A933bSROE3vWKAgNzvgA9pl9he3BJQTqINw8A9tqv44VetlmszRQILJ1dFQ5hFT4l9AHiH+ZVOpcsS2N/2MKAcnF3815FRQJqXMpKige32XP4Xz37Xq9vU1pZxftlPaccs45Rt6VOC/LGpc1LAvK9S6IGlaVI9DklDT0BhHH9q2aAvzlN1QxOKElgptTeOocb9bWMGxY0rqetkWxT2gfHD5Op58/OJbqcmJj/yQYEMVh34iIQUcwyrCpUaQnIudjMyJol2LE0ss/xo6BaB3BT55GCREaNSLtx85/w3QClCDcIOYSfaqa2gi1G2ST1rGVqW120faKVlWPzWIFA9T7HtrrypqpDfap8DIVA9ZFYPUfp3qVGttgZF2KjRaCgAClUMp74ss98672mC3t2552RFxPp3Vd47KGdV3iGiMflQh8chAACxXekCAqOWVRjgv92L/4n22Qw2gm8L234BMnvFkR6lYqV6Cv7VLRoN0tNe6WlqSQH1CpwoRrmZOyYCJMtsT0hVqathf0vLGTlm0SGpbNVjgNKbYEUItPEXwyXJW9NBSHFvdqZl3n+HrswMS0fv+rIbJBO3BZJmyO/xL4Oe95kIlEB5mgx4iQIIDGtdZyqAKtSA0YsB+IpPO2OwEAqTOahP0F0z+JQAw5docMeAoET4EASASZaW6/bNtDPq/Eu+37nnJKIcQlLjGe2GebT+uibtCHgARyWS9H9S2UOahhG1XREHt4VH+IAW9WvFk07rgvypyni7LUntylx0I5ra8CAJpafL+w5p+U591Vx9E9z0BlDZ3zODg24ov7gn0/m2ZE5UGXx3exK+76Mtbb5xyLY5sZXbpZCe1fp6X4RnpyaaTMoXZjWQ7mxxIrjXtk6CYmNMMw8iOxRFvoNA2ePWsOg+3Jc+Q1kBD3AABk5EekDolMgSTBuaGqvo4CAdgck7a0Xa+3l5x4Y3Bn97ScEyIu6xLiEmIIcYlxCYF39lkWBjY5FT4xyCRPErSt8M6KDvotb5id33VJNys+eY41yC8CttMMHZm1UOVT8oL4qp4fzZ+vo8E2j3M0yzZ0AIXcap9nGdpy2JDiWOckoZcv+IgMlqsaHNoiEz7fHDOfVu7h0OHqXXRScV76I/LJqZNN/xzRHhEEDADo20VtkQAQFpWsKFJI/cO8PtSsAF1vUMkP2LnMBGBlE/xR1ARRQfVlUmcFDAG7t2zbdr3s+7anPe87Xza4b9dc8rqelrjEZYmBL1eKKEZRYHWUCNgoyid3SfzFiQh+7Du/9pAIZjLrZsUnTzXI7xyys980STOQ3PGQ/ZkTqs6Sz93zgp6WBl2TKYCspkYFJS3RfMIGPmT/bdOPuNJ046GaKL1uiH2bXWIzRHSDqonNhiZCbzKdaIxMh7UMOltK3SgFqBNjqulkdTBMMbazYw0FJUolTCqyqaAKW8NUOCfxsi6wvERR8AgAzG2NUKdWGYxIvx6CM6YHAMAW0W1P1+v1YU5blguvE185GDAsyxqWJcaIURVRXQ0GAETkM7scyonDqrJvK/uOKp/At5hJ5kBrjAFvlnCzNJEFHvPB4Z+kt/JwYAiShu5Fejir3XPzaQf4h5HhTCRWuefr6ZhIVxj7b3V4cyYzyH90iV7UTYUewqEGMWjWVvOszhHzzHRIXT8Ohujki9d+j59eLxWmgAAEC0Bwe0zU8Og6hpZ/idQuWCqv4Q0G0h9cxtHvhFNIeg8/QoRSSk572q7b5cLKJ//jZSERrOu6nk7LsoYQNayo+KiFEDEGAL7phe85Yy4hezY/8u1fPd0LmXIvALhZ8alTeHRgtUc9R3h5nHXgWTj9Mvj+tyxfE8QjogoWVzVVJAG/j9AetVeZNxNT0KXrrRI9UJF5QSOIppsLU+k6DP1Rj3jVgAeMiW7fQoVJL5fvMtVghayWouZTMxhVqZtTIwhLA3ZXGfY75kx5VS4iixZQaYnKp4QLop7RL6IrWDdr59qLY1BHTJQ5fvZ2uV5vc0qZTwDmfU97zinGKLpoXENcFzkxGNklFUMACFRy5pstih7fBQCEkkuP+BV+/Qxyws2CT567y88awDwmXhxxyolehJp8pNK0KFlpYJRynVuXlupl6mB5t4YcYrUU0rVu5OTTmS83J4TnWqUPplRb0No6vCeYaLZwxxCmmxxti6hiYz4dlfnhWNvYvTmcNPAAKcD56+K6wJ2aGWCQr4NHCgBMe7zaR0TgA0pCQsZmxQ2NOyAuAIokdZQFqFveEgHkXPZt26+X6+VhzmnfN7bK7HvKaQfAdT2t68LX7C5L5ItK0d29BqQR7anIbdsKkB/5jq820KD3kulki/5YAse6x4hu3o5mYHzuZODToui+PZq6Xf3GenmejXCaVx3CfHOca7KTuYagXLNSPx5QpefuVruwbkeHU4LhDwQwHq1q27E6Z96Yc389k4dO3HMGZVsyTC+gfG+rFzoo9IxN1gr7AUIPHJ0MOSNmvV1szhznabvGRVnICSj5GpegohggoDQpx5zc8o+ckAOwWIlkrTQ0CKXktF/37bJdL2m/prSXknizno8vxWWJvC/Pt7tw9ArUJwRA5IjaORfKBYhDG5aAmIuOXvsETeM9NAHgZg1PsC46M7g559P6pa3kLmKaysaqBfX8fsChWV2ofwRtJsceevZ/x3OQAb3K2nVlLNLQp69iEFxGn+S/D0ISHB3C8RB8EcJWIg5NwwFhT+sbI2u5zzSdWFeCRFlXJrVgkwW77EJ+/F6cuqt4rMGalNj4F7VDbR3cEOx4oRf+0gZvS+zb5XJ5mHlrftt3+f8GgMuyLssSOJAoXzkfAgfYxhA1lFMpOZWSCpUs8e0BAUpOjuNPnEXHCfC6qOduKiKmdKSw9rxxnJpHi7mOQ/XlPTXeQZlTTK1icy5PJg5mrYQy3anvLLXY5FjHMGBHXX5s6gbQy9lJc4Nqii2cUDtcZZH7OyHsA76jEt56pjJ7QoemUUzG3Ygf0U1lM51HYyYVEK5kEaB1w5CFnlIgEugKUClwMi1/AAqkkkva923ftuuFJCTTzoFk0r6VkqMeGuQLBkNYMMSATH0xhACIHNY+lywe2yWzg0Ip5Ue/42uaKWxanzxLwJs13FtwCY18c6bN+WMjrCbQMS/O/g0dQ1dbqzioPD+yjpJOuMvjqtS2ZvbGrsM+w7gLePzTJSLYCMZqp4KjB8YMOG3meQds5xO77z0FaT9n80pg5ktsKjjavfS/Rvi2HxanUjRToxOr6oxdYSX7EqjOW7bAQJDAA6pZz9o8pkAsVBJrntfrvm8pp1xySimLu/YeMK7riR1E+dbrENhDZgkh6A0TcrEEFXEQLbnIzkTZdVx9545kkm4PBmWRc1J6TGXzEWRP9c9RzkbC+DTmqJ2q1TH/6eLQRMdgKgQArxJ6+T+MqTbTcGDyY6qyx7o/8Q5vX3vYekbYpdk+eyPvJt1tQHIUxmLQSyvWUPeLpvLQnuqhhod9Cx03rZNKAGShp1CXhWoF1Z0FdgUBhLrTyOhA/aHEOygQAIAKpZy3bd/4xGCSo/Np39OW0k5U1tPpdDotGrcixjWEGDCqnxoCIBGVnHMphXLJhUqRTRSiH/2Or60AQnjL6z8ORunRPjcrPnkO53XCyiomtYmDYDt8JjXOGAQMtR0IkJkbjr6iq76TcEaxnRbnGTK4Fmd9bLJXyAw9RumlJvcDsJJVq5vI6bZaP4M4DLkW6gSNgmS6njBA4Sy9q7E/fDFUUhnYFCFQNgktvJPmqosA28XkpsTl0G1MWXRV48MF2SWt7RAhqlVmlAFUSk553/fL9XrLW4KlpJz3LK5qKYa4iBlm4eVgiKyBRrWKIjAB5kQlA1tFlReUnA0ycACN7lki3izh3oJrqJM7pQcE1U2xAq9DjjuKd1NyBxGj+9VQRQUlLysGI5JHQexUzdr3GVVUZPTdnuE6tgUHcnXfKx8ZNElfyvGatnLOp7Rayb5ta7LU7DpifWiTyOU7pEPSGmlOh0ZS4rTY1um7vUhNc2DVd/GAqXStZwlItYpB9PnySoGjYwMQiGuL3ql0yVliOKW0pbSXQoHPK/E9u4HdtpcYlhCYHBcMMkpeDZaSU07Eq0EAAvjR7/hqP7Qvfv3H3SEA+blZ8MlTOK+HfjJHcMPmrcnQr9lmORsHfWw+NDuBQ3glAL8m78z1AP3JglHVm2ho6DFy2FWznmLtyFDp3OSI5hh5N0PEqsp1fTl4jlVcP7o7PrlhDQ131ZqWT4RILphrrQTrhPbds2dx32eEz72rUq66ARACVitoS4FtpWrxmS+CWH9M23XfLtvltuSUUtJwhltOGYhCtGC+cYmRd+dDjOwsw1sTBESFgMRXlEouhYAdCkq+c4Tz52bFJ894s7T5H1n6zgz1owPG4y0pD2wAY1gXxaA+WuWAZ4Pji1J3H3678e5s6PCYk3mxWRdEDTpL9w/37v0r+R42S9m+lba2KbFBrbDJMl0iTk9d9RwOrWUaMd1kvi9B7lNoc3ZNBdsMBBGgVVsXCqR2+cfkppuBCEjqz03NP1Q9gqjkvO+8Mcj2mJJ5NZjSvueSAUAj+cYQox6Y4Ds/2VKLGNgkk1kM5pL5Bl52VUutLvqWN3zcZLAONKC66M0STnGmQAyQuvtz08CwDMX2R1NXrdIWfH0rONTAv1y6qw+r9tVJ8qbenvNo056NjaNA6BU7V1s3IvvbdWP6tEZLV9PQfwSn7I5DmUO+gfKkwhncp6+2eLt7QNTmWA46w/xvOrsoVNcc1m/UaiHSHrpjx4gIcil7unA8XypUSmYX7W3jnfoSQozLGuMaWfStaw0hA+ojQ0Ac05CvnufDE+o0+uPf9T/dCZNeKSKni95JeGM1d2RmtjuvTjm8as/M9tF945/yve3sUbMqO0YlC5TrV5nTCAVm7P02f99Ob27t0KhxkRkNsG1z5EVfL9snRdqa+/7PeuvLY6OXQgNS6vUFAFBY1Uwg/XbvqPy1cRDt22eqoloJOO9NAhD3CgSEekapQVBiCiRTdphBBcdaAUCvmD2kQGmOfUTzvuVt2y4XyjnllFMq6qudcyYCpj2MIcYlLqcY9bLBEKxp3pMoueScKWc+sMiwzKaLHpATuT6BYoDs0S/TMjhw4ZqKzU/PFh+XP3obT8eMBd6dlEP0Rr5eoPUCtP5E19fxc3sCwWpGn20Chfqt70gtPwHD0Os2D/W5Zr+OP3R5uvM8d/BO0NGECSimeaGS0nhoGgBquJgKiib8GUj8wqZKg3pdBPp4rn72qe5hjAeXav80NxGVnPb9um3XlHd+zRzHKW05JyoUo0ZS40CGcm4woiijOu5SCuRSEqugdrQKCN76nV9bG5/poj2kCE4Rz2s4L3huoht6Vc7q62mvrqwcNo4UOXuaj9jB3/3myRvkEtrs9Q3p+4iWjcFw6Jnzl6rj9doe1Xyz8bT2/8pE3PCw9q1nknNvAWz/M+u8h1KHzNLbdvthpK+pK0Y//X0hz/EAgMUXjfl1IOyNDVDvokBN17uGWnMMb00QoW7HS6Hgq67xTWBgZcPymEPS57Snfdu2C9+UlFPiffm0syKKMa5xWWNcYgwcwYLPzduxJTYjkHrHlFyEDoEAoKgYvOMZtSy3R2+UhuCUgjkh4fEnbQgP+C5WA4DMxEHntIbDEO4iwOp1V/1HUyANPQlMd9RKm4IusWsRDSYHXpfNRbuekKiepnPVysJiqAa64tTUp/vhvqKmD02iL+o3DpwepD6pR76pOIBorL0CWhy+ewLQNCTUuygIEAME1TKtBf4kgy44adb3do6iI14SFMqZrxbcrpeSUik5pT3nXTfpdyCKGk47xBjCssQFQwwhIkYzyID4yBAHFhVrjM7Sj5kYBASAt7zh4ycw1T7Zr/OKT53DzYJGe3QgxDqT12TULuLSHDpUvxI2pV3K4IVtZ86mWAKAnYnTNzjlBEfsAayxAYvqyNya6DFq5cx3IvFh+UMWdvy5q8MYh0/se+IPaI5POxc9m7OVfeXfR5xZSgfNGEhigVaeTwhifaEybANWwaxea3dNYzeEQpQpp/2679d9uxQqelhpS3tiXTRwSN91WdZ1WZa4MAUGCeHELjIooOJ9CY5wU+/GePynygE6LXheWBfVcPf97najmXRKqf2TivVl/FSra998NpNWzuqGPucd4nfqDEKulG8fve6CvuFeJiJMhwGHyW0vuxX4QUN90b63eJDrDmw/fGtSmnoIpuA1fRxrlrE21UyVf92RLTi3mPqIFKWG/Jq5UMNyS4FzGJADOgGIh9q+pX3brpdSmAITLwh5TRgwrOt51RvOQuTTg5FVUFZGdeL0qFKRMNsW0ibnNIU0TnsGopOdl8C6aJ0PEvXDFrweGgcIKR/bHQFsSbguPZQSRqzT+nte7WhQJ3BGAP3p0AnJ3bXM8Z/Rf0Ihcs8KDlDWtzdOgb6QDaTtz+PT4axqSQgwW+O1lUyY42Rve1J2oqy6XJUOD9gWAAQcOCZLwX4DsAF0hQy1H+54rM+lUJLDEtc97SXnlPWOwZRS2gGINwYXuXB3lUP0gY9KyI2DIFyiyAH6opFkeDVI5cf+xf/kW//iN3x8JTq/BHL8ATiYBdtFjeGZsakZzh3UV7GzH/2YhSdAKJJsQ6wvPyezyhmg0WbbTEd24YEOu4zWB2fvmeL+MR3OenzUl1pDG9v2MelwrNlSZILnfOruBJy1X5scZ4oLTaibaJJTeETbhCIbQX8tDE9BULbCYztWd4eHVLjmkvVql1u+ZCLve2Z7TNpTThjiuvI1gycWgHHR+yUChhrREEQPJQ4oSiRX+iIAh7E4fioLaRYIqouG8xKQevgqgs2A6WXbI59H4oJDeWynZ9qCyuk5skIrtZqvs3F03cGO1o/FDjYFjFb6VtHl8iUPVakD3AXooIHW1T6b/ndswgMBXeJdxOeLD2XtfWBxA4fSZ6EGFCoTGiNP1z15FNv7eb1rXcg+LWkTewx7t/CRpbznfc85I+DKt0osa1yWuCwxLmIJDTHqqaWACASpZGLyKyL9WKUkgh/9jq/2m2df/MaPd93ou2W/VBedBlYbk8gw35l1muzo0mq22WSQYWJTT7N0qnW3EZ+0ZmyP4zaNygq2jfOEUI2K6PUmOjxmji6vNDkzVGA/AjcIsd/29frEZlizhrqhjbXNjTTHZ5esSd9r/VSzTCru5saPaIyeyBFq2kWiXbVHWG0wUky3HGYU2DGctkvTfwBUiOTUbtr27VpKySmXvOe05T2llKjkuMSot3xGCeXUHJVAPVVMoNHhtOf2lQMQT7s3kEuTTXTROLLLnuejkz2NmuqWet3sEDY1UVewA1fl6kPrXdeaLorQGkWZda8VD01FdVYP7Fpuddsx+mPhUYs03Zl24nB4TAAHudvKNeUAbIeayiy9s2M9QsbM6kTfJ3JKqWtucS40bnsdrYaDPo5WNgDP3QY2D0BEec/7Ne/X/Xohviop7TsHsEhbzjsAxLCcVt6dX+Oy8Ll5XQ1G58rK5411RQhEBAERMBDQj3zbVz6WWtiC9KSK6Hk9dqkdFPAGOUZ+3OLHnX2iyh+7IwNW3MVI6TNQ87PZmmrFCg6ikv+QEweoDGoaD2oM89SYMNqIFeQyom9WQy95VmWVH8q9lg6asjP52RefvLh6DtKP22/60PHcSRfQhR10+RdX0GlChg4NJ6pvAudB4WhyN6tK5Auu877t21Zy4pBOJW057TnznbtJtiLkpMSyLOsSVwwcVjSEem4QOBpN4WP0pZDs0RcEFwpHn7e84eMfh4PdrPjkakF+B4Y+0qNPoS4RoYa0A0s6fjwBNrDvzh/ZIVwCmGyENzqV/DUv0AZdnL/mJESL0cBB/LI7Ua3pdIe8HR1O1GY/ogM6nMc7hJ5lYEtXd8gxIyHfT/BdUsAc1VPZR8c9eCptBpQ/2bF4IFjkclxrtgG4HfaVz6SXTmB1yTh6mp6oAWbbt23bLhwNLaWNvWT4jpcQQlxP67Iuix2fD0p+IcQIIUiAU6LCVy3l7PxjCAAQseT9uFeTvtlzXvCpm3BewjiuZg+trUkItqZjU+hx5DE0LK4/9ydiv68eq/9uS4rTwT0SF4ekKotGyVMlnekkh83dnThJUxpzqN+Q9N1VdZQ+pcOGyxz39w/6IE4gUQfVsUtzqkFYqAEn+Gz1F+lGRj1CjNDNBECntoCMFImoUMop7Wm/bhde+6V9Y7osOZWcA2KIcV3WZV2XdY3LaVlPS1zYPS1glCtmEJEvXiNy0bXtHigshX74275KmicAhLe84RNaeBxRYLhZwnnRIL8Hxnh7M/XpcehszGFKl/5uwO8ASj6p0Tyqa5SjBleTU/YQVB6OTLqWp/rmmplrhtBv2NwlZI7zzYVhI46mJw6PHzemR/GlAwvWlGEN3OCoee2ul6T6E/0MOnVlEWRzGzM2bb5mqD48Dj0RjvvFjpdCI5nvkLhe9m0rJWf20d63tO972qiUECJvzXNEw2VZImuhfN+g0CAGDKx2yv9kX7CuZvsN+v45hOJ5wZs1nBc2vLZPS2k4U9bnzyyTZ4cNa5z10WDNBFJlJVTsUFKEXmqiTkCtTJ2g7LvvgatIUscVmicP6xiOhILolCUPdBpSjqRmm6O31I6sgRQy6MdvmeEOPXPoyZGkteHb9I1khi7jkQLiXxCWGujQ+nUIDVNmpzm7JAl6TWYR3a/bdmVf610ctdO2bzmlQiXGZVlOK3uoxYUDWIQQeWdCzw0isO7DtYjfdlFXUQQqP/Stf/eoc3fzsfOKT9+Em8XtTeD4p8XEuwHQMLujLH3HeqHoptDxwYHX9p7ZjRBrMQEsjLufRsvQH773dNgNoKEk5tPDcmhE5XHNdKcw7PJNzP5tax0vONJLj+jjMQRo+3MIioEqh4/oEP0sEwCpYWaMWOraUibITMabY0RETKeFSxBfriQhtFPiI7u8Nc8RtUspAKhn5xfk0BXNxjyqqxryliCHtid5ioEj+Q16Amh00TnZcCobRW8WDqzmANyA3ekQj6C2KfU9lkrVl2gJEt1fEXoO9o4sa+pAh+DxPowxV9DRutEhvxxtsh2ORYwHd+Th/lrN1PakdsIq7JqYdmmWCNBA0+koxzE6NFNF+Nl4u+Z0CI5PtmVGPrXUgxsCjb7jXZ80zCjWpPGR70S5lLTnfd+363a9ABUN4ZT5yBJH5o1LDHHFEEIQH9EYI7L2ZAEsVNUiKFQy+4hWzosIQGnf/Njufvz3mxXvreG84KJO4bOxTQjPeFtNdQTYd+EAWgBTH8VBlxt4XbN+s+2ERioCTOQhKIGAVyPR0KxBzprcjQpHAj7G/2a0vQRTMV/tDX6UfZHOODpvsiflhtQP8z7G8+jRtXQI7byNbBkRgkwXWdhx3fsGNzkAwCcKzeG7EYC+A/YXC1EuvBi87ttV42LzPWdbSinnXHJBRNkSDEtYYghLiIvcNBgQkMz3sR5TErcYPb8LAACllB/+9q/2oGpNMrW31E0wwM0SXnATb1ZeDh5t87oCbhMWa1KrPzgwPfpfd0wC4Q44m6+W++Y4+9hX6PNjN/7JTyWOWloz3AGa2We16D3yqSeShzrHfs7ruxs1e1X/oOQdrPIIMTrZZYhRHf4PKuVki6FCCARUEMjO9XLp6neKymMBFJOnLAiYrVEufGZ33677vqs5Zk9ydn7ny5J4S7D+Ny4hBPZotks/+apgueGsQKlhtrPRZNr32Xw1z7TH5yWcFmSvUZroAu3gnF93M+Pos9xR+i5E6YvX5iaFPCn63DbrHXE1DowoPLUnsqE3d9PhBODjgQCYpnQsS39PyaAi40E/Yfbt7mno1sltBhxKdGUntR6SqIHwEM4BSWP5yizXy66p6594h0Hzb06NRLnkvKdt2/frdr1SSTnzsd2U055SKoUAIETWQOVypRhZGPIpiQAAiCGECJUC2V2bT/CqooQIAD/4//u7vgdveeMntB075IPnFZ9Yw82Ka5zaRevvlvwmj0fK0JLOo0nujkobP7imys5FTrPqdm7jdd3K1oruA4k2vTOnNBzoekYwtROPGKwvPmn8ABItQdgw3O955oMuKix65nsHHT5OepvqDwJM82t4i+AHgPC46xnnR1xVHCQqWeIW8v3yKQkF5rxv+74xNSLiEtdlWWNc5PZ53pCQ0BV8ZCmgBrDQzYlCpUDRsIkEAJjSNuXL0rfjBxHOS3jqJtoR3r6o3xAdsQibvM3kVWX+btzqjC/NUq/pPfdAFxxuoSa2k3ap5MzYdYNhiAwhlSGMhtCZljO5wU9fhsQ2ATk8w+ROsRY61p22wvksoisz1tKnj9mspzgfwqyx9su8wllB8SSaucUvIJqeF5tVajgO4VaJ00enmYQE97Rt+3bZrleOnlZyLjmnnFJOOSciihJAbYlxldMS4iAakA86hqCHd5kAaygLOzDBX3/gm//2Ea7fvZI+L+FmQX+OvgeeIlRX/+hD05d/LOdVK+9ooyXsyTUv0NBYRfnG1VNsk66k9Io8henAyGIS+oYmsMOmrBHtPALNXVETK5oN1h2rCV1nrK5qSWyG1Xu0opo9oKL3HbF7ZuSkHRkFknyhcfJqK4dNDHS4tGDpCt9NgYYszupDfEFuymlL+2XbrlQ4imHOhcPa55Iy5RJCXJbTup6WeJL7BiOf2EW59NM8RRGpQAEqlHMuKhX1vkSEnPpoTm954ycoNO6mQTgveG8NN6sL8quT3BKevHVKy/zvAJ0xEXpwHus1Goipr7Bx0lRO0eONoJ5HC93Sk8paaVVbMEQe7wnsxAVNhmMirXfnxFpxk7MvPfqAOTl8LNSaXziQx3xWYCK6fbaRv9TBTDGsMrROZlaW43UKi7Y2KFqVsh6Bx3XpiFCIcik57fykfc9iDk2JX9Oe8k6IS+QjS8uyLGFZlmUJYZFjgygxLAJGdC4yJKGcSmFnNR4BwXa9dBB4zAcRblbWRY0CoQ0XyVBoKVB1HZetE2B9K9PeNQzOPTNHTBVg/N5uP3AdTYh4nWtPTHNSaRWfqWKHHR0Opn5D4F57HEQfZ7UdzbmsbXvWbVvewVa5/nHIB8MC/7UZhvXfvt1JAXdrDPbVicn6gT8t0+LuuVuWqDoi8018F0va95Su23bRiPQl8/USKaW0l1z4tO4SI2KMbJgJ4h9j0o+XhQBERJlj+3K4YAtqSABAuZQf/vav9H1iMfhIGQi8Rx9NF0U/FC/eJkTktgOx/WjIhwjNcv+RvEHJpqofrSCoTLyVbNKfIZChoKOqZezO0iEVAg4OYe1Yat/teBORkDn5b91qxzB7cnj3YGE5YDMi+JyNfGs99HpoKAweAwnaQtS2cmf3Ov1g/mnWkPTLmBmHPDxAlUfvuwLY5Egc+pzSlvbrfr3KKSPeGsz7vu057zklRFzWdVlPfFiJhWKIEUOAYH7agLJLSKVkIAIopKFFZZ8QCAFsg74VX4/1nFe8WcN5Dac4jYfUSr++FfSf7GQRuo+Ptypsqq6URk3cWGXw0qmBCgdlyl1dSb5PSor9jSvuBaEaUaqQtOYGHq99OnRx7gSYnd23uivn6iroKfYuUTjSMI+E5l/niXcL514udn4NQ0V3UaKjw9Bxejky7y3fh/8sAhnzXdmWyPuWti3tO4vFUnJJSQ8NboVKXHVXcFlDDOwjqvsSul2OyJuFevG1BLnnMBbsPAqAheAHv/XvdMOjx6NCRDjH8PRNvIkBnQQ0asC6SyapHSWS3x7Qbo+bBsftIxzn0zgCksftANbujOHS29pbyz3qh3Y4CLUZX1wZi422+9q26WA33wDs+uZqGCXYnY+fk+neRPPQGAVcf2GXAh2kxmZ59XMwojH9eGOwa3TBrtmJIdAXHNFbWDLbY8q+5bSldOUb52VPvYijWiklIMbAp3WZFFcmSBAvUfMUDQgoi8BSCuWc2VWtEBXjhjntbffgLT6WzJ0Pn6D3/qItlrqRD0ISzQ2kstnJllkjbA5n1j1Hq3ytgtQ+Y4LQ65OmoTkJNokBbGjpvTqxxj6ZtdysxxBGl9QGFL00A5hovWIGGgY8ShuvZ48ys0r8AznWa8jg4DOKdKgARrWq2hiPogGDyrTHlLdd8rgm7PWcCSccKivskpbYLXvLKVFJpWQOJcoBtokgYAgxLKJ+LrIUjBFRSTAghsikSEC5lJwTm3bkHD01OPUD3/z/OoTKnQ+xXXTB04In25xotgQBepbPS6tW9viJ7f4ecbOhJ10h8l9ao6ieI4HW05KFv6qZWEspbToVdES3qk01FhdhM+36zeMtdgeY/M5kbd21NaOPZvjamyNUa1oavyn1dEPUOzWbSE0HhFF7zwAel7RTSVjbGhPvclgVEC9N9skz6sxDXezGwrfLb9u2X5n4xE00bSmnUjJgiTHEZY3LusSVHWWYIN3lLlUvKpnYlkM5U6FsNKjSIO/9CXrdmXjEQwAB8byGp29ic3ZpOkKVHMQ7qqMm1r/csRKsxDwrS+03BL9y83eHIYBHQ4t3YOTb0AoAiJhD6JaCTNJOmA1rrlGmOdnH9SI4ajIJMtLhsF3hEw9a5DyP8gpv+Mts2Th2htoPj8s1plaltsj4yVmxxuwAjSTszmbdLdt1wERQCqW8p7Tt+2XbbjmIYc4l55z2PbMimgsUwhBPp/MSV7nok8/shhgwImCNXoFIBIUyC79UZKM/5wxgvhewb9cRDo/53Kx4s4Sb1emiHjtbfOexjgcNHaiOlf/Jh7uYXW2v++xspl35qn5qwEMnw/zRCrHfPwKfnTFDklqJp79swciaXWOdFRHd0Vy/26HKQt9ck9Dp+/2+qNV/h6I41Ntj9rFeOhGGTTdmjc1I+u7sCw2pWmjWr6ESAo0Xs+/7tqV9LznlkkpJiQOKpsSRYABx5TBqHFpbvNSWwOZQZ5EBANmLYLsORyfNuZSMiIiRrUA/8h1fVYf4KLXPsvBoTgverM5RplWIRuVyDP1kLxMC1GWK93UYM42qYcOem5/+GC4qdoiNmImknvef7OLV34L45NVOyVHFF1a3mrkPqGfXjyOmJmk6LsCe7GbFjfE4lzrTSSYbq168Oi5wQIfHbas20jZBMzh3Pe7SDrQDzt6vCb1Of1f/AJiFUSmlpMLRKvYrlZJSyvu2bTvfgs3iDOppibjEyEQoEQ1DCCEiIi8OAYBIIjjx/RJEmemcCAJCgQJA+7BBf4cu2tFACHizhKfP8bz0xmHR6zoyaBGxis7xzIVRpJKyStEJk6DWcmeKnaF1g+p+vVUNMRLqFxnxlFSbzXrX50aqNDv+DRU4BdaBxVlWHLvXvoGYXox7c77BGgNOeTXttb0dt4Fc/3KIjzMpNjwHpQ/URTA2RK1GKYzhEQyo79Fx5slmPbjZgmEifS4S/5i0pX3friXlXEopJeWS87ZtG3vMAMYYcYm8JyEW0cAbEwhyWknMogEAZX8xywUvvLoshQCIIFApRKWKQZiya+m5AcIP/xzxvISbNZyaO0BbQq3vMwE4HpKbmsJ9IroO4aTXaPQEIuVMOJoAFHtiq5la7ELBFEdqgjq+Ia2Ld/y9monqH1dzDRTUrP2gwUrjC435R+n1r6TdMwAAG4VJREFUkbqZJ1jF176ZKV16yeYlrFcy/Yim4mhoamynZwxEE/MQOiE9GkuP1Mo5EdaRtK/dbJJFLty2fdsK5ZJTKeykLbdes6O2xI9RR+0YlxgWWQIiIBICG2dQvLQpF/lfYmWUKANggUKlJG+SIUCciEE6HvPNGm5WOUDIsFEfPZGB7kImD0HG6wnBt/LPkddUoo6yVTrc3EiAFbnIRqRqUMe71XKkJEyyBrRVoZNgjupUsRX8VPtOE4HGD4D6fYoOCDaGA8ULmkS8c46c6PddmGS2poITNUfVej3yMM/xc0iT+nQk12c7aHLpaevOp+Fnshjc0r7t+5X4ngkOIyoH5wuVIhe6LEuIMbAMjBH5n/qIAsnl80hQQHYXC/GpC14PJnaW4oCjP/FdX3vYxRYE4xMRzws+fY43awg6gaQ0prjUaak6+m7HcBCHrXmH/2NIYjUP/ZtNDNXtCvMkIPsEpHuVlmj3vlrt9biBcmZr2rXIuijWdCcunAo1wd4Bv3pZ5EHiOAH610HhGp66FdrkdC+mGOIBHfrhtlU/mkIQTHvvADexlE45C7bQGJXSBYAO7ow6fJjlFSpsjdm3a0qbGk9yStu+b6xRAkAIYVlOy7LGZV3XVSKpxRiQ752PAABBnDYICPiyXbl6lzc7UhFfGTlAUbtyzEGOJvW8Im/Tn9zZJd0YMbpxIklH3KiWXvS1lGhffLIt/+adFfllTflk/kPCFyrF6af+nhIEi2uoMom/kS4hTdGbqF6ussehwx4r5dy30ocW8BqjyzuAwZ1OdX2s+RxHadlIB65BkvdF7rCUPkLEtUSkDGX+tKzPd7dLXMTTmKzKRz8EUDIVuXH+yiSXkzpqp1RyTvtGACHGuJ7iusZlXU8Sz5e3JdgnRt2rkBGbdxypcFztUojkFhm+iJe5f39rIpou+jjaBYf3PS94jkZBjXAaKLAhS2UWHlTN/j3OwNiXmjHMuvMgIq1+oba9fr9CqVeIoI7JViUuIm2zRQBwh9o21zrbxJmBx5Fgg+cjrvtEtXN1srZZhdIdHXad6uE8PtwIzk9LdeW6CuabFq1g92xjDsCWUyzAM3kHnx6HUKhQ1vgxe+Yj86yJpi3tW86ZABa5TGIRc+iqh+j5wglAxAABUA7QBwIslNXpO1FOkBNLRaCitzHhT37v13Xg8Sh19xMRTws+fRNv1hDRlVFHgU5H6t260TFdbPxrEHo6Q9MxejdFg3UTaLI5jwv+3emdUlRxmqrZEl2pqpLVXcNBnnlaccjvv6m8azYYDYEq6CamxQY0rM+NltKZtXC0k/Z02LCjtrD1sBL9jN9JI9N9kYFopkJ/LIUe7MMY533WES0OFbAb4fRhRTTnlNKW9i2ljXcpiEknJV7RyVGJ5bTEZVlWloHrsvJZ+hAWAIAAASMLQZKYooWyVFRylkOEQEgEIYQQqBWDMDPJ3PGcV713KQZvPullIie3+ic1MDZyREcdncx01Hc0Cf5Xr9kg1UWoooE7A2OSZKJQdYhslOzkVJN/QoetMOQhO+eaoxNQCqiO3JTYpxKmH8D4rgxpXIY1eeu4jwR4bbdVs+fdnXUIp8JwVo9R05ymHGp46ygBTY6U9w+fKEo7U6CqoSWnPe9byomAgpyOj0tc1nVd1hNLRVFEOaa2YizfZyabg3JoNwPxMcRccoJCep6Afvy77AZsZbCPYlL+OS94b8Xzgqe1HaQnnpkA5P/WdZ5KF7/yw56Oq37RcDeXoz2krlRXJ1z1K2coQf+N6YpQVhQqD0lXsOS0UOuokKSdVoJeHoKRubOIdOoGecnUUiTX3a2dptyiIxr3fS5erbKm4iM69D2g7m+f45EohA5WMFUzB420cmkQpQhU5enaWloZWl2gRmMNgsYazDtvDe77RqXkvKe085klEN9OjMtyOp1Op3Nc13VZo1y+u4QQ2AczhAhAfMMEgvjdUMm8y6gh7nPhS6NCAEQqR2EsHuuJQeyi5yVEbMiuysIKNh11t/3uKKhdPfrFYKPCEFQ9FlqC9At70QjcbNYj/qJk+jpqGwjNL1FTdUdB8qv1sIa1cEqbZp45ZXeq5yB06+jd7v6wXahU5hAQ3QdAFb8j+FxxX6tXBGYU71Kw5XZD72GkwDt24Y/p9VBuuW/TPNN9QmdXd+UIVBPd97Tvab+yCsoennnf9OwSxRiXZY1xDcu6LmtcVzk+j3zLJ28PIshLkMAVIvpyyZljipaSgRAD+1HRj/8vX9d18zEFID/nJZyWwBqpVODoS/mWg5Inzkq0NUtNahZAahh1crFj3gO4m9+ya+6xSNRBxSViQ6ltSrhYLmTyWSiDQAWVDdZsH70lte1Vi4gm+00jBjCxMH86cSaEZCf8G123grEl0qb4KDGb/o38wdHhdC/+DmF4R31zMmy4gnGCSfHRS36pNTi5wNV5nk3AimgSX+2NjaJMLezRkjkOBSKwHYZD2oe4xCA+ony5UmDSU/8YBMilEEtZKoUKgLjDMfdjSM3uwLuL9YyP6aLnxR9irWTWEEO3/z59OrKUcxYDRH0aY55pJi2q2R/fn0qQhp5ihEQjRq6cRPahXhRXlT0VqiYOG3xrtEInb1hYmp3WS+m+pBtdB6Fmcx9doQM0byAy5HkkqVijg4Q8yO+Ug4OuN8VhILSmpJ/yCTRUK28rX1r9qH/q3JPc85nTltOe0i6LuCwijOmGANZ1Pa036+m8LichQNmwj4gh8B49AvuLCoFlACIkMfogMbZQCAgQCvFWhb/zDBHgLW/8hMeXhKyLPsW6aJQtN6c/4gwEYtt0+o+eJ2z90UjjthKN60n3G+QmeGtXt4aCrui4VVMTK0GCLCuMtrGWNvrSBaXXzQJCIROVKhTHkwpq3xtkjRC72nSmJ/ncAK1b1TBYzSqWD8rd7M1G2EvEO4wi0Ci0CMKUDum5a6myISOIgyLdMs93r8tGwydPh/ZpAQGczbejUM8CiYPF7DmltO8lJRFcfHiXcs57zinoxRJ6TIIvG1zXdQ1Bbp+XE7yAHreISqZccuYUIkKQQE9YQgr0E9/19e0Y/0CqKNwseJKzS3wBocBHhHIDO6cS8O8g2focnKs6YiOGRsCZtmobGANnxfZnpaqKRDpc3alwGxCibQKpUsdExq5AJj2laqNC3dIwujfDSsV7tdI4Q6x20yPIIwXNlAiOsXxOYePTFZwWqVpAQwxNUferEnsV2jUzdtlBppUOm9fiR5Tskps14Ui4ll4K8TF5NsMQsNDiOE5JDvsRLetpiatQoJyUWE/rOSxRKI8tMYJoRARFjiyxPZRP7hYACDEAFQIExB/71r8LDSbAF7/xE/9AVKhnl8I5shCsq7Wp5DIPF3SvzRJR9w84MlWlPWeiwW5TLYjdsDJtU81QtcnGvMFUB+Td+NG8PEFOMIkHAwJ5i+b8sXpoRLv+BzoPFleho0PjCwBtDk9vj3qmWGrcjPrGYWp5PXzuJoCmcFuTI9o72hoUh0d3oG8deyIsTv9xTLgUKhJFO+18nxmbLi2GRSo5R94SXHhH8HQ6nTWgU1RbqGigUi9RSTnllNNOJVHJBIV3UQMiiWTBlDuj6KP0mBYCCLAEPMvZJVyj3YFTNT159RSITJ9u2UeOQkFlaC3LFaIyyGo7dYZRUokoRUk/M38ioSIBjohDb3ZVyaY0AKVYI6qPegskrx6F2lozSbtJoQpRR5lCi84UJNkaKHskbEjUBl35O9eIJkUHLO5md85VtIDqMuAqc1NyLFU9JTgPpeP1qoFlWtu/qzWVwb0ABzADAEBS/ZCXZAhsumTPMQ7XJLcpFb7WLHNAUT5uC3LZ9XqSi6/XUwxhiYtGEK3WTO4Y5ZLyXvaUM+u3sqklFhsAAChEP/it/2MnBh//4cxn1UVPi6NAJaX6YkUcBVZaM2qstOuRTdRalK1LLaSt+Kxuc6Q+5FzOqBI6QwoAmALUKqqEGgJKIPJKvrqORWoQCq0qp4oy5XvSAXBlquCt60oZlHde6A5FtYKwkvWhVGlUvra/9bMv6KIxzmRa/zxCWk7zqJjyHZjWc7cwvLtpBCCCpdQsfWYC4LAuOaXM8bT3jQMvpZxKSjnnXFLOO5US4rqs63JaQ1yW9bSspxjjspxi1KMSIFsTsvxXa2jOGwtStowGDFSjTVPe+r1BAPjiP8j2IAHIanAJN0uD/Z2o0i6qLqnFW7IFEYm6JAjojTx1IemJU6pzPqC2mQ5VXjmZzO00Yk9PzaKjN0D7P7llnh0W9EcEBVeQuO+lYo7qzFYQABqteXKEABx63aH91mwqV11K6xp+Rw3d/Rm+7UcVrLzi8YpYRhm+798obF0RuFsYQq2hrwRhKd0hzGYLmtgEaqcl+IolCSBTck47H3HAgMuyhmWJQS+dD3y7RJD4oSxCRM+THQg2wHA8Q14WAoA6dhMBENEPfMvfacXg4wpC0qEubo9+XeSw7mhlMfFmMnCsUndMqoQ0JaarULVOrZS7HoItCdvGDc8q3NnIQyr/QHTFuq3Os0VGpt5rtKVD0vLqX+0ET+tryjW3hxnsAxwZOA6M+VUKasUDHbY1jSnyt+UA3XpwlKhtR5p90TkdKtkpHPsoPo/5TM2hjYzDBnyWtrhBqVVAEYsK8FmJnPaU+HZrPjjPd0vw/Uq5FFiWyKvBEKM4x0S5W0I00WBRWpC13UKFt/xTSiklvnIJEPlcE4SAhbbUeooCwKPE4AhktYuinaMfZY4MeEitHts1yExjsml1Wk10tWBTwK/m+j437Wt0CVfEhBPIBjyoLFUhTLxTQkK7gZBExAqlKcP2jFvIrlsxVnTRqj3BcZ8Np5l3NrqvLoz7Ku8UR4PAOMgmuO65gDXaiyNSRWPaXEPONlg4Pn411F8/Krc8AuQdonhp9HHNrahChYgvVMop5Z19tTkCrziw8bp/WU5hWWJc1/XEvmkcMAaZqKKqbwGAj0ER5VxKkrt7+bggAWEIWAgDAUGh8i+/6W/Pe338jHzR6aKBWgq0In6tNiFRlm2aAYygqhj1Fhr5KTEcnfRWq3Bll1XzcX1G+xUQAYsGOw5IxLIN1UAillFg8ykSFK6ylVJYxaYJ0uq1IizZhI/t1bc1ecJt4Ns+LTbhRJP1Wqg7T0xTxD1oZXzupO460o4LeHHUFL/TqHPUhrjS/gEduQBgqRYAj0kBiAlBjDIppx0Q1b+MSkpsmClEMSwQAhtF47LwEV6ObM9eMQgowdSUVcm9vVmOXHA4GUQMECgQFACA7/mnf6vCSYf5yPF0418jnlfZo18XtM04ITxSfzAAgOZKAPXWdkaZfruifyxd9VVRBxv+VvUBVYG6/lNFF1bJg2q/pfDqTeSgVkKuvqqBImLpFmuGaC456FknqDpQQ3gd7qJGnWDbkfcxALfK7SaimZR2htBbNvUrTbvd/jKR3tQ4oD+OrzM3mvHpgOA6DB1cfRlZtXcU3fS75wIEsFggsIbrIwDrh5SppKLqIgHZ/iD7uYQQwhKXuGCIFlE7hCXEBaPEcBJ3EkQAKBwmOG37tvHtTfu+55KhEAQEJCyEiKXflpDnkSaZDgDnGM4x3FvxtATwxMMrt6BWFLW1dEvEaqapCouvwC/qwBa9SnvWnOoEAEQQgnMScw9pN5iTBkIMCLxrBGIIHS5W0kViZ7gQySd9Mc8aROZvSqkHqOKqGAmi0e78/gF2q0By/+1/1tHTkK2nUgBQ77ljI2TTCRzrw0bDfLzn30Eauk4Po5hWxYlChJZDcFH0wcLH53PegYhILmYpOQvHBkAMS1zlYrMQg9pCMQTEqNYYlLET8V29KXHsmMIngEvOBBAwFCpIiBT+5Td9hfTdDePomagTOqTTghzJ4mbtbJa11kbiOe3QG0o7Geg3KuqSTz8H/eYoVjiAsaNxek2emYcKK5kBeFvCLTWUFMmcahAJIAAUFlpcQyAoznVbRZ3axnitiLqTIZotsAeQUrUXhuKa8wjMnCDg4Mft82j1jafrhGJHv+cOcqSgPuigs5tg28vjAfW7L3c+xoPMLf6oUqtOJGHdiwWwH3wXYC4pJ77oM7GBppRUsjmsFUSM6hcaY8QYQoiqfIpogBDErAFAlEjsOhKgm60ypWTEgIGj+qLoo0PfRzFIww//vkbxF71Zwxqb26wDdNRY0Zp91CrRo7yL5AsgtERSQ0+EKvjYzMRpyumGHfxGtxEKUFFpfjKgpUUZEoQlQATnJ9dsNNreh50QJSQkFob6g4SMB8RwuGw2otnTCsFauLr4YJVNLSrrG2tdiFSajxN6Gymz9ZxpnMnHRaayEzMsjaK/1wxEcgxfD9kBWP5pfUdF7IpayckTTIX40vltu27bpSQ+sJRzSuKxnTMRBT6yxC4yy7rGlSkSMRQqUALK3fOMF5BzSTvbWvd937Z939O+7VcqFCJfzBQL0Q9+81dMdJLHf7Qsn126t+IpqpXELYBBhVVLG06igafAmt8LR86oBZr1n9mDSfW/ICspVPTrlDV1ykFZrZJ5K4voY+80rRYJSt0yVBYhpKOeD3U/kgVzUfq2ZoVM7FoJBaCReiUhtKWg1IFeD4SBTtBrqAfiSQfX68cjzs6sPF2OQ99uX6tO3FwZOWr2MZ46XDJ6P6DDdhCLrexFQeFz8xy6Yrvu25XDTLCTaNHA9LkUQAxxCZEV0YAhhhBiXIKwfSolhxCoYAHAEIhjseW07ynnvKe0bdfL5Xa7bhjCChjCQkyBI/DuFIPyMoDwtOANnyG0IL8y37V+oQowjFVqbDswWldC0D36uuKD+gtEAIpoRd54qSqT5IaKf+o6KuTEu6i2kKudZS2UbZ2BgvqRVfWSF46NdyrabfTmjKPubEqCjDQqBRGgFJOsDT4ZmI1v1SViFeyoVNpoiaZuNdjaz6WCeUz2BV21fa4Zz8b6odUF25aGhNrfxxGGvsrpEKYpCwFAYeWG986p6BXz235NHEmNyU9O3KaSM0FZ4hrDEmKMcRUDDCNU9TkDICpMhTnnvG/XTZ/r9XK5vX14+/AhUVlP56JxDifwe8ynHdwa8byEp27iOfrohuS2IZxYNFOb2leAVVbQvPpTyQdAZR0YxJ0IFZkZEAqE0LYGUrYUO+RH1g6n5EIIEELgg0gBsBDHtkBTJp0qTo15BOxgh2iwXYx726o0qidoMyqFYWvwaB70sqTDz3E2dHzUu750Oe5YcHJ72hJOaEm6NdviO6qwTSE3QV36Y9bgPzQawljKfVksjCdfZcAeMnnfElMgFY62JBEnSE7ABwxRgxeyUoocgYIg54JIiAExlxADEUDJKW3btm23l8vt7e3Dbbts18vlcrunDRFDKUHCQ8XaUxh/HkBoluO8Bjk5YUF+QcmoChwAW7CqCQlNLQSjHCEoK+QUVKlaTypXPZU/xagB9WXtU/va0TCPhXXPGMAcaRGBxSkBEB89RCCiCMjXFhMABsRSFVo+Iq3MxZzVlJ03jmmdg6nqogMiy7KTB+dIVaWz2mAffcy3zlsnUHoCPMDxAyI/ftp65jIMFSCTyg8I+4jZuLQ7GIEv7U7WAxKwU/bOLjJsBSWlPmBGRiUEc0rjbYloEZwAgWR3OSMihhIwAkLa99vbB9v18vDB89v1kvaNxWza92VdqWQoRCX/6Lf9v6cdfoQuOhvhaUHeoz8tao6U9RHDVe0pKlKUrhQ3lJpC/WlFXGknJq1c6OhTxCJiY3w9HItaOokK5EIsmVmAoOhGlfBkTUdqO2RkChCKOnaj0g/obrLyBJ7Rqo43gm0QSSNyqf7QErHD2Ym6hl6c9fXWnypmOyzW1ztn3wnLPyDFPk62gx4Nee5cSjqhAESwVLbPymjec045p5KSL8EhiIgyIARApcAo53fFV2aNIepwEACpUAmZMl0vDy+XB9vlsl0vl+vDfbteb29vb29LyWs+ERFixBj7zt6tHlD3Xp91wfMSeI/+vAbTBnkkaMtCVz0GE2EORiYB0RV1Fhj7xrlCENNLFaDejoPYmGitR+TRW/RDBCwB6mkSlaKlANM5E15gs6KQGuZSpLVAyHuCdjzXBkdEzovUcxEhch5rJ5m8Ftiv7hqa9ZuI4MSm+9Dj8UBd/YxWQTRgPSrUDC1sX6HJVKumafrhwxpMV/DOxwPAg21OsQiLoKQ6U6vlJZHGCwICYKeyXHjmMCj18amldV1XuXFX9DfTjBAAIOe0bdfter3c3l6uDy8PH9x//rmUEuPAtu0hLOuaY7uLYI8XgzT5NXlOS7CzS9UbwZZmwvpB7TB8LlcWWl7btIIGPqNALwtRyEskpOmZHE6HKSA0Nfo/VTIQQlH8RsTAHnwARBR00Hx4H3kTP4jRBhXzAqA4uVXTpYh+EIFZCY90aerwAfx+hMDIn+UHMKV0YIKPwui58bJvYlod/76jHVesOgEd5KjU0Ynkyi/GslD9EsZSd+vRePyJn4URkFjRLJlyppRyTrw+BCoARRaDVIAIMcQoTmrLsrC7TIgxBL5TSRQR4XyIBJRy2vft8vDh5fb+w4f3n3/uWa6ZABHDuq439+6db27u3XtiOnZ7pe7bwYwjsl0Uz0s4L8gFq9ucYpKTRLWV4CoRPY3/GyrNsSHSKDGEYCYcdTETsg1oup7rc0+LaHSIABEAnGGz1LJCIAGgABBCKKEAQYBYgPleKSQiUJ1lPM5UwlHRWBXybl2owvsOnxrdXdSNSLKNku72CifbsEl5JCr3eSYfoYq/BrB3PdjmO+IM/nFQOajxmA6t1KSDmiQH7NhHlEriE/Tqoi1htYmJkzIihBAXvmaQL7uGAHxoV1QtIuK9fmkn53y5fXi93O7b5cHD+/ef+xCVrFI6nM+nD/vwF9279+TpfL45nx4BjK73B1MkdtFzPK+qixpgHJTMiKLyUNdLXh11ElF3XgArCQKCikDQtWIVlaHaO1GMskAqvsBjEUIA3jtXU5CoVwGVWdnRWw3plpGgEAJCkOniVomIV4sdKaEsPMTf0zYtBs/N4bGFHPh1p+lniMgHRCfsv55ZbLRRGE8ISq3VI1Q/9+pCJ4y0ftVihiqbH+7TgXlmBgUcEh8l9G2cVYudyENNWiCwnsn3W6e0p5R2cZgpWUQgG2YKYQhCe3ozhJzXFZOH2FdZsWUy3tN2udxeL5cPfeiDD+4/C5SVJ4bT6eYFH/bh9+7duzmf19PpX37jV/RjAPziN35CA9xeBZo8J9mjD+cFF0RoNrKMpsh4orq2QDWr6Jjc8s9koBAbMx6nycnqERyJAiCY7ZXxiCnI6902OcGpXIKRCEQYgAD4TipZ02WS3f8QZCtfjDSAIKctQsBSRP80LiNyiomcEDSqQt0bQAiAJhhlAdnhPFSS6KRZo8eOGYbH4bwToVKmJ9KmnTvlox5cBHBLyK4ndyzw5n1uz0/dMbQ+3VnMqBlyff7//D5m0jkOQYkAAAAASUVORK5CYII=", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "I see a bed with a blue blanket and a blue wall \n", "Please enter (Yes or No): no\n", @@ -568,18 +570,18 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "I see a bed with a blue blanket and a blue pillow \n", "Please enter (Yes or No): no\n", @@ -622,15 +624,14 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "mce-ONsriUYM", "colab": { "base_uri": "https://localhost:8080/" }, + "id": "mce-ONsriUYM", "outputId": "1f24c72c-4f20-4b9b-b0da-640a4bbab14c" }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "['2193.512678543: 0\\n',\n", @@ -989,8 +990,9 @@ " '2831.960163635: MoveAhead\\n']" ] }, + "execution_count": 29, "metadata": {}, - "execution_count": 29 + "output_type": "execute_result" } ], "source": [ @@ -1030,4 +1032,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} From 30844816b26035a6b574a25d1d7a50ade6df329b Mon Sep 17 00:00:00 2001 From: mohammed-majeed Date: Sun, 24 Dec 2023 00:07:43 +0100 Subject: [PATCH 3/3] group 3 --- projects/ai2thor/team3/AI2THOR_Group_3.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/projects/ai2thor/team3/AI2THOR_Group_3.ipynb b/projects/ai2thor/team3/AI2THOR_Group_3.ipynb index e3631d9a..5eb5f8e2 100644 --- a/projects/ai2thor/team3/AI2THOR_Group_3.ipynb +++ b/projects/ai2thor/team3/AI2THOR_Group_3.ipynb @@ -309,7 +309,7 @@ " X_test_vec = vectorizer.transform(X_test)\n", "\n", " # Initialize and train a logistic regression model\n", - " model = LogisticRegression(max_iter=1000) # You can adjust hyperparameters as needed\n", + " model = LogisticRegression(max_iter=1000) \n", " model.fit(X_train_vec, y_train)\n", "\n", " # Make predictions on the test set\n",