{"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":30201,"databundleVersionId":2750748,"sourceType":"competition"},{"sourceId":8331365,"sourceType":"datasetVersion","datasetId":4279913}],"dockerImageVersionId":30664,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# intro\n## Take two models, run for 10 epochs. Best result goes for further workflow","metadata":{}},{"cell_type":"code","source":"!pip install segmentation_models_pytorch\n!pip install pycocotools\n!pip install optuna\n# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport os\nimport random\nimport numpy as np\nimport pandas as pd\n\nimport optuna\n\n\nimport json\nfrom PIL import Image, ImageDraw\n\nimport colorsys\nimport cv2\nimport albumentations as A\nfrom tqdm.auto import tqdm\n\nimport torch\nfrom pytorch_lightning.loggers import CSVLogger\nimport pytorch_lightning as pl\nfrom pytorch_lightning.callbacks import (\n    EarlyStopping,\n    LearningRateMonitor,\n    ModelCheckpoint,\n)\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader, Dataset\nimport segmentation_models_pytorch as smp\nfrom albumentations.pytorch.transforms import ToTensorV2\nfrom sklearn.model_selection import train_test_split\n\nimport matplotlib.pyplot as plt\nfrom torch.optim.lr_scheduler import OneCycleLR\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:34:32.190433Z","iopub.execute_input":"2024-05-06T04:34:32.191228Z","iopub.status.idle":"2024-05-06T04:35:10.549193Z","shell.execute_reply.started":"2024-05-06T04:34:32.191196Z","shell.execute_reply":"2024-05-06T04:35:10.547941Z"},"collapsed":true,"jupyter":{"outputs_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"in_path = \"/kaggle/input/\"\noutput_path = \"/kaggle/output/\"\n#https://smp.readthedocs.io/en/latest/quickstart.html","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:15.634737Z","iopub.execute_input":"2024-05-06T04:13:15.635101Z","iopub.status.idle":"2024-05-06T04:13:15.639708Z","shell.execute_reply.started":"2024-05-06T04:13:15.635054Z","shell.execute_reply":"2024-05-06T04:13:15.638790Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df = pd.read_csv(in_path+'sartorius-cell-instance-segmentation/train.csv')","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:15.641038Z","iopub.execute_input":"2024-05-06T04:13:15.641406Z","iopub.status.idle":"2024-05-06T04:13:15.987995Z","shell.execute_reply.started":"2024-05-06T04:13:15.641382Z","shell.execute_reply":"2024-05-06T04:13:15.987197Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.head()","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:15.989162Z","iopub.execute_input":"2024-05-06T04:13:15.989494Z","iopub.status.idle":"2024-05-06T04:13:16.003386Z","shell.execute_reply.started":"2024-05-06T04:13:15.989468Z","shell.execute_reply":"2024-05-06T04:13:16.002366Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## YOLOACT data prepare","metadata":{}},{"cell_type":"code","source":"# Convert data to COCO like json files\n\nclass DatasetConverter:\n    def __init__(self, df, img_folder, output_file_name='your_dataset.json'):\n        self.df = df\n        self.width=704\n        self.height=520\n        # Assuming cell_types are unique and mapping them to category IDs\n        self.cell_types = df['cell_type'].unique()\n        self.cls_map = {cell_type: index + 1 for index, cell_type in enumerate(self.cell_types)}\n        self.img_folder = img_folder\n        self.output_file_name = output_file_name\n        self.coco_format = {\n            \"images\": [],\n            \"annotations\": [],\n            \"categories\": []\n        }\n\n        # Adding categories to COCO\n        for cell_type, id in self.cls_map.items():\n            self.coco_format['categories'].append({\n                \"id\": id,\n                \"name\": cell_type\n            })\n\n    def get_targets_masks(self, img_id):\n        \"\"\"\n        Retrieves targets and masks for a given image ID.\n        \"\"\"\n        targets = self.df[self.df['id'] == img_id]['cell_type'].apply(lambda x: self.cls_map[x]).values\n        rles = self.df[self.df['id'] == img_id]['annotation'].values\n        return targets, rles\n    \n    #@staticmethod\n    def decode_rle_mask(self, rle_mask, shape=(520, 704)):\n        \"\"\"\n        Decode run-length encoded segmentation mask string into 2d array\n  \n        Parameters\n        ----------\n        rle_mask (str): Run-length encoded segmentation mask string\n        shape (tuple): Height and width of the mask\n\n        Returns\n        -------\n        mask [numpy.ndarray of shape (height, width)]: Decoded 2d segmentation mask\n        \"\"\"\n\n        rle_mask = rle_mask.split()\n        starts, lengths = [np.asarray(x, dtype=int) for x in (rle_mask[0:][::2], rle_mask[1:][::2])]\n        starts -= 1\n        ends = starts + lengths\n\n        mask = np.zeros((shape[0] * shape[1]), dtype=np.uint8)\n        for start, end in zip(starts, ends):\n            mask[start:end] = 1\n\n        mask = mask.reshape(shape[0], shape[1])\n        mask = np.uint8(mask)\n        return mask\n    \n    def calculate_bbox(self, mask):\n        \"\"\"\n        Calculate the bounding box of a mask.\n\n        Parameters:\n        mask (numpy.ndarray): A 2D numpy array where the mask is.\n\n        Returns:\n        list: Bounding box [x_min, y_min, width, height].\n        \"\"\"\n        # Find all non-zero points (i.e., mask points)\n        rows = np.any(mask, axis=1)\n        cols = np.any(mask, axis=0)\n        y_min, y_max = np.where(rows)[0][[0, -1]]\n        x_min, x_max = np.where(cols)[0][[0, -1]]\n\n        # Calculate bounding box\n        width = x_max - x_min + 1\n        height = y_max - y_min + 1\n\n        return [int(x_min), int(y_min), int(width), int(height)]\n    \n    def rle_to_polygon(self, rle_mask, shape=(520, 704)):\n        \"\"\"\n        Convert RLE mask string to polygon points.\n        \"\"\"\n        # First, decode the RLE mask to a binary mask\n        mask = self.decode_rle_mask(rle_mask, shape)\n        \n        \n        # Find contours from the binary mask\n        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n        \n        # Assuming the largest contour is the object to find\n        # This part might need to be adjusted based on your dataset\n        contour = sorted(contours, key=cv2.contourArea, reverse=True)[0]\n        \n        # Simplify contour to polygon\n        epsilon = 0.005 * cv2.arcLength(contour, True)\n        polygon = cv2.approxPolyDP(contour, epsilon, True)\n        \n        # Flatten the polygon array and convert to list\n        polygon = polygon.flatten().tolist()\n        \n        # Ensure the polygon is closed by making the last vertex the same as the first\n        if polygon[:2] != polygon[-2:]:\n            polygon.extend(polygon[:2])\n        \n        # Convert the coordinate pairs to the COCO polygon format, which is [x1,y1,x2,y2,...]\n        # Optionally, you might want to scale or transform these coordinates depending on your image dimensions or requirements\n        return [float(coord) for coord in polygon]\n    \n    def convert_to_coco(self):\n        annotation_id = 1\n        img_id = 1\n        \n        \n        for uid in self.df['id'].unique():\n            self.coco_format['images'].append({\n                \"id\": img_id,\n                \"width\": self.width,\n                \"height\": self.height,\n                \"file_name\": f\"{uid}.png\"\n            })\n            \n            \n            targets, rles = self.get_targets_masks(uid)\n            for target, rle in zip(targets, rles):\n                segmentation_polygon = self.rle_to_polygon(rle, shape=(self.height, self.width))\n                mask = self.decode_rle_mask(rle, shape=(self.height, self.width))\n                area = np.sum(mask).tolist()  # Calculating the area of the mask\n                bbox = self.calculate_bbox(mask)\n                bbox = [float(coord) for coord in bbox]\n                self.coco_format['annotations'].append({\n                    \"id\": annotation_id,\n                    \"image_id\": img_id,\n                    \"category_id\": int(target),\n                    \"segmentation\": [segmentation_polygon],\n                    \"area\": area,\n                    \"bbox\": bbox, \n                    \"iscrowd\": 0\n                })\n               \n                annotation_id += 1\n            img_id +=1\n\n        with open(self.output_file_name, 'w') as outfile:\n            json.dump(self.coco_format, outfile, indent=4, default=lambda x: x.tolist() if isinstance(x, np.ndarray) else x)\n\n\n\nunique_ids = df['id'].unique()\n\n# Split the unique IDs into training and testing groups\ntrain_ids, test_ids = train_test_split(unique_ids, test_size=0.1, random_state=42)\n\n# Create DataFrames for training and testing based on the split IDs\ntrain_df = df[df['id'].isin(train_ids)]\ntest_df = df[df['id'].isin(test_ids)]\n\n# Proceed with your DatasetConverter instances\nimg_folder = in_path+'sartorius-cell-instance-segmentation/train/'\n\ntrain_converter = DatasetConverter(train_df, img_folder,'train_json.json')\ntest_converter = DatasetConverter(test_df, img_folder,'test_json.json')\n\ntrain_converter.convert_to_coco()  \ntest_converter.convert_to_coco() \nprint('done')","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.066335Z","iopub.status.idle":"2024-05-06T04:13:16.066683Z","shell.execute_reply.started":"2024-05-06T04:13:16.066514Z","shell.execute_reply":"2024-05-06T04:13:16.066528Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Data check using visualization\n\ndef visualize_random_images_segmentations(json_path, samples=4):\n    # Load data from the JSON file\n    with open(json_path, 'r') as file:\n        data = json.load(file)\n    \n    # Randomly select four images, ensuring no duplication\n    selected_images = random.sample(data['images'], min(samples, len(data['images'])))\n    \n    for image_data in selected_images:\n        image_id = image_data['id']\n        \n        # Filter annotations for the selected image\n        annotations = [ann for ann in data['annotations'] if ann['image_id'] == image_id]\n        \n        # Load the original image\n        img_path = f'/kaggle/input/sartorius-cell-instance-segmentation/train/{image_data[\"file_name\"]}'\n        img_original = Image.open(img_path)\n        img_with_segmentations = Image.open(img_path)\n        img_with_bboxes = Image.open(img_path)\n        \n        # Draw segmentation polygons on the second image\n        draw_seg = ImageDraw.Draw(img_with_segmentations)\n        for ann in annotations:\n            # Assuming 'segmentation' is a list of polygons, each represented by a list of points\n            for segmentation in ann.get('segmentation', []):\n                # Draw each polygon, assuming segmentation points are [x1, y1, x2, y2, ..., xn, yn]\n                draw_seg.polygon(segmentation, outline='black')\n        \n        # Draw bounding boxes on the third image\n        draw_box = ImageDraw.Draw(img_with_bboxes)\n        for ann in annotations:\n            bbox = ann['bbox']\n            draw_box.rectangle([bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3]], outline='red', width=2)\n        \n        # Display images side by side\n        plt.figure(figsize=(35, 10))\n        \n        plt.subplot(1, 3, 1)\n        plt.imshow(img_original)\n        plt.title('Original Image')\n        plt.axis('off')\n\n        plt.subplot(1, 3, 2)\n        plt.imshow(img_with_segmentations)\n        plt.title('With Segmentations')\n        plt.axis('off')\n\n        plt.subplot(1, 3, 3)\n        plt.imshow(img_with_bboxes)\n        plt.title('With Bounding Boxes')\n        plt.axis('off')\n\n        plt.show()\n\njson_path = '/kaggle/input/weights/test_json.json'\nvisualize_random_images_segmentations(json_path, samples=2)\n\n","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.068170Z","iopub.status.idle":"2024-05-06T04:13:16.068482Z","shell.execute_reply.started":"2024-05-06T04:13:16.068329Z","shell.execute_reply":"2024-05-06T04:13:16.068342Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![jsonVis.JPG](attachment:fe2b2402-90f7-408f-bb9f-99fee137bd93.JPG)","metadata":{},"attachments":{"fe2b2402-90f7-408f-bb9f-99fee137bd93.JPG":{"image/jpeg":"/9j/4AAQSkZJRgABAQEAYABgAAD/4RDoRXhpZgAATU0AKgAAAAgABAE7AAIAAAAKAAAISodpAAQAAAABAAAIVJydAAEAAAAUAAAQzOocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5QQSBBT0kgMwAABZADAAIAAAAUAAAQopAEAAIAAAAUAAAQtpKRAAIAAAADNDUAAJKSAAIAAAADNDUAAOocAAcAAAgMAAAIlgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIwMjQ6MDM6MjcgMDk6NTQ6NDcAMjAyNDowMzoyNyAwOTo1NDo0NwAAAE4AUABBACAAQQBPAEkAIAAzAAAA/+ELHGh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0IGJlZ2luPSfvu78nIGlkPSdXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQnPz4NCjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iPjxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iLz48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyI+PHhtcDpDcmVhdGVEYXRlPjIwMjQtMDMtMjdUMDk6NTQ6NDcuNDU0PC94bXA6Q3JlYXRlRGF0ZT48L3JkZjpEZXNjcmlwdGlvbj48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyI+PGRjOmNyZWF0b3I+PHJkZjpTZXEgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj48cmRmOmxpPk5QQSBBT0kgMzwvcmRmOmxpPjwvcmRmOlNlcT4NCgkJCTwvZGM6Y3JlYXRvcj48L3JkZjpEZXNjcmlwdGlvbj48L3JkZjpSREY+PC94OnhtcG1ldGE+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgIDw/eHBhY2tldCBlbmQ9J3cnPz7/2wBDAAcFBQYFBAcGBQYIBwcIChELCgkJChUPEAwRGBUaGRgVGBcbHichGx0lHRcYIi4iJSgpKywrGiAvMy8qMicqKyr/2wBDAQcICAoJChQLCxQqHBgcKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKir/wAARCAJaBQsDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDe/Z98M6DrXw/vrjWNE07UJ11ORFlurSOVgoiiO0FgTjJJx7mvU/8AhAfB/wD0Kmh/+C2H/wCJrgP2av8Akm9//wBhaT/0TDXr9MDn/wDhAfB//QqaH/4LYf8A4mj/AIQHwf8A9Cpof/gth/8Aia6CikBz/wDwgPg//oVND/8ABbD/APE0f8ID4P8A+hU0P/wWw/8AxNdBRQBz/wDwgPg//oVND/8ABbD/APE0f8ID4P8A+hU0P/wWw/8AxNdBRQBz/wDwgPg//oVND/8ABbD/APE0f8ID4P8A+hU0P/wWw/8AxNdBRQBz/wDwgPg//oVND/8ABbD/APE0f8ID4P8A+hU0P/wWw/8AxNdBRQBz/wDwgPg//oVND/8ABbD/APE0f8ID4P8A+hU0P/wWw/8AxNdBRQBz/wDwgPg//oVND/8ABbD/APE0f8ID4P8A+hU0P/wWw/8AxNdBRQBz/wDwgPg//oVND/8ABbD/APE0f8ID4P8A+hU0P/wWw/8AxNdBRQBz/wDwgPg//oVND/8ABbD/APE0f8ID4P8A+hU0P/wWw/8AxNdBRQBzzeBPBqIWfwroaqoySdOh4H/fNZtlofw6v932fw/oGFUPl9OhXcp6MMryD611l7apfWFxaSkhJ42jYjqARj+tcufBlzeXFjLq11bTiyWOJESAhXRSCdwJPJwPagCaPwn4EkC/8U1oKFiQqvp8KluccArzzRD4S8CTxoyeGtABdBIEbT4QwBGeRtyOKxr/AMIX0Ws2q2kSXEUl1BNJO0QAt1juDKQp3ZGRxgA546Vdt/AUlraoIbyJbpI44xP5POFi8vHXoeuKALa+FPAj3kNrH4Z0GSSaN5U2adCQVQqG5C46utNh8MfD+aPzE8P+HQuWHzWMAPysVPVfUH8qd4Z8I3Gh3UU9xepP5a3C7VQgDzWjbjJ7eWfzqvF4BjF151zLBOftCS/NDn5RLK5Xr38wD8KALo8GeB2cIvhvw+WK7gosIMkev3elNHhDwGyB18PeHSpO0MLKDBPp92sef4eX0htwdWAit7aSECKMh8NbyRYBzjq4bn0qtZ+Br/U/Mur2OHTybouLUR7EKeWi52qxwcqe5oA6j/hAvB//AEKmh/8Aguh/+Jo/4QHwf/0Kmh/+C2H/AOJrejTy4lT+6oFOoA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mo7jwR4LtbaSebwroaxxIXc/2bFwAMn+GukpsiCSNkYZDAgg0AcYdH+HO6RV8PaC7RsiMqabETll3KPu9xzTo9F+HMtxHCmg+Hy8hkA/4l8OAYyAwJ28EFhxVWz+HEttHbq+pLIY7eWKU+Wf3rFdkbHn+FAB71OPh8GililktGQpdhCLf5g0+MMeeSpBxQBZvPDHgOxuoba48MaIJphlEXS4mOM4zwvAyRzU58HeBVEhbw54eAjOHzYwfKff5eKm13w9car9ja2nhgmtwB9pKt5i8gnaQQOcdDmuek8C3OmW0txC41GZJkkSNo95nAZuJFZgpxvz1HIH0oA2T4R8BLjd4f8ODI3DNlB09fu08+DfAysVbw54eBC7yDYwcL6/d6e9Y+k/D8nT7STUVt1uBHDvjMQbZtD5TOenz/TimyfDaWRbxX1BJPtFnJbq7q2Yy8Bh4GcFec4oA1D4X+H4uI4P7A8OeZIrOi/YYPmA6n7vbNMm8OfD6BireHvD7v5LzqkenwszovUgBeaSfwS41K4urCa1h81pPLVrfPkq6Rj5eeDlCf+BVQg+HVzFYTwPe2zyT2l5bGRoCTGJhwV54wTz6gmgDYbwd4FUuG8OeHQYzh82MHy/X5eKVfBfgd5FRPDfh9nZdyqLCAkj1Hy9KojwGz6kZri4t3hFw0uzyfmlDTeaQ5z8xH3R7VZ0jwjPpWs2t3Hcw+VDEY3VYzukGCAOTgAZHT0oAtf8ACA+D/wDoVND/APBbD/8AE0f8ID4P/wChU0P/AMFsP/xNdBRQBz//AAgPg/8A6FTQ/wDwWw//ABNH/CA+D/8AoVND/wDBbD/8TXQUUAc//wAID4P/AOhU0P8A8FsP/wATR/wgPg//AKFTQ/8AwWw//E10FFAHP/8ACA+D/wDoVND/APBbD/8AE0f8ID4P/wChU0P/AMFsP/xNdBRQBz//AAgPg/8A6FTQ/wDwWw//ABNH/CA+D/8AoVND/wDBbD/8TXQUUAc//wAID4P/AOhU0P8A8FsP/wATR/wgPg//AKFTQ/8AwWw//E10FFAHP/8ACA+D/wDoVND/APBbD/8AE0f8ID4P/wChU0P/AMFsP/xNdBRQBz//AAgPg/8A6FTQ/wDwWw//ABNH/CA+D/8AoVND/wDBbD/8TXQUUAc//wAID4P/AOhU0P8A8FsP/wATR/wgPg//AKFTQ/8AwWw//E10FFAHP/8ACA+D/wDoVND/APBbD/8AE0f8ID4P/wChU0P/AMFsP/xNdBRQBz//AAgPg/8A6FTQ/wDwWw//ABNH/CA+D/8AoVND/wDBbD/8TXQUUAc//wAID4P/AOhU0P8A8FsP/wATR/wgPg//AKFTQ/8AwWw//E10FFAHP/8ACA+D/wDoVND/APBbD/8AE0f8ID4P/wChU0P/AMFsP/xNdBRQBz//AAgPg/8A6FTQ/wDwWw//ABNH/CA+D/8AoVND/wDBbD/8TXQUUAc//wAID4P/AOhU0P8A8FsP/wATR/wgPg//AKFTQ/8AwWw//E10FFAHP/8ACA+D/wDoVND/APBbD/8AE0f8ID4P/wChU0P/AMFsP/xNdBRQBz//AAgPg/8A6FTQ/wDwWw//ABNH/CA+D/8AoVND/wDBbD/8TXQUUAc//wAID4P/AOhU0P8A8FsP/wATR/wgPg//AKFTQ/8AwWw//E10FFAHP/8ACA+D/wDoVND/APBbD/8AE0f8ID4P/wChU0P/AMFsP/xNdBRQBz//AAgPg/8A6FTQ/wDwWw//ABNH/CA+D/8AoVND/wDBbD/8TXQUUAc//wAID4P/AOhU0P8A8FsP/wATR/wgPg//AKFTQ/8AwWw//E10FFAHP/8ACA+D/wDoVND/APBbD/8AE0f8ID4P/wChU0P/AMFsP/xNdBRQBz//AAgPg/8A6FTQ/wDwWw//ABNB8BeDwP8AkU9D/wDBbD/8TXQUUAcSNJ+G7fd0DQCTFHMANNi5WR9iH7vduPxFL/Y/w5BQN4f0BWZ0Qq2nQgoXGV3Dbxx602L4fPHqUNwb9TCl805i8v8A5Y/I0cQOf4ZIo2z7H1p9p4AEDQrPJazRIYGfdB8zmNdpBOeh9KAJtR8N+AtLjge78MaLidisezS4m3EKWPRfQE1ND4S8BXEcckPh7w86yRiVMWMHKEZDfd6Gm6j4QmvNF0eyE9vI2nMS3no22QGNk/hYEfez17Vnp8PbhI0jbUInCRKBMYf3jMsSpgnP3MpnHuaANV/BvgaN1V/Dnh5WY7VBsYASfT7tVZPDngCPUFsv+Ea0Jp2XcVTTYW2jIHJC8ckVE3gW4uvtEt/d2z3MscwR0hIETu6MGXJyCNn1qMeAbj7aZTeWwUF9pWAh33Sl8uc8nnGaANH/AIRDwH5Zk/4R7w7sDbS32KDGfTO3rVbUvD/w/wBKEJvfDWiKJgShXTImGAMk8L0x3rO1bwXcafYK+mQR3rqoT7KsClGbymQuQWUZ6YPUe9aOq+DrjVNG0i1863SSytfIfzVZhkxhcjBHIPPNAFlPB/gV/ueHPDxOAcfYYM4PT+HvkU7/AIQ3wNvC/wDCOeHtxBIH2GDJA6/w+1ZkngC4k89DfQ7JY5I/N8k+aRIyEktnqoQ7PQ4PamwfDySK6ikku4p0jgWHaysv3QwB4PcHJ9TmgDYi8D+Cp4w8PhfQZEPRk0+Ej89tO/4QHwf/ANCpof8A4LYf/iat+HNJm0XR0sriZJijsVMabQqk8D8PWtWgDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jo/4QHwf/wBCpof/AILYf/ia6CigDn/+EB8H/wDQqaH/AOC2H/4mj/hAfB//AEKmh/8Agth/+JroKKAOf/4QHwf/ANCpof8A4LYf/iaP+EB8H/8AQqaH/wCC2H/4mugooA5//hAfB/8A0Kmh/wDgth/+Jr5Z+MlhZ6X8WtZs9MtILO1j8jZBbxiNFzBGThRgDJJP419jV8g/HL/ks2u/9u//AKTx00B6z+zt/wAkp1b/ALCU3/oiKvP9zf3j+degfs6/8kp1b/sJTf8AoiKvPuldVDqfP5xvD5/oLvb+8fpmje394/nSUn410ngjt7f3j+dAZhjk/nSZx6D8aKAF3N/eP50bm9T+dJRQAu5v7x/Oguw7n/Ckx068GigBdzf3j+dG9ueT+dJnHXpR0pALub+8fzo3HOCx5pO/4Zo/iNAai72z95uaN7EY3MPf0pNp9CaesTspYIxUDk4pNpbh6DdzcZYnp+P+cUu/OS6KzEbcnOfzpSUDuo+dkYqQO2O/uMZ5pCAsnlsy+ZnB9BS5ky+WaYF3JyWJJ6nNJuYck8elIQVzxlgOmec+lGOaogXcwHLnijcRnEncjIPpxSAfN6cY59aUHLD+nagYp3soIJOSe9KWcscNkZ6gf1qJgAwbY3LYG0dPf/PpUrLtPzDJ2jODzn6VNyuVpDdzZHJ/M0B34+Y+/NIeKKogXc3d/wAqUFiQoc89qbR0PHY8UACzb0DxTb155BPXpSlmLZ3ZozzTfb0oQ766Dt7H+I/nRvb1P50lH1piF3t/eP50b25+ZvzpKPxH0oAXc3dj+fSgM2AMnjjr0pB6igDt74pALubGC7fgaUSOAQGYZPrTeh9MnNHf3oAd5zmZ0/ejbnG4cN7jnik3N/eI/Gkzlm459aPx/wDr0krFSeuwu5uzUb2/vH86SiqJF3t2J/Oje395vzNJRQAu9ufmP50b2/vH86T+dA96QC75NzZl3IQMJtwQfXPerFk5Go22W/5bJjn3qvnOcKyEEjDd/ep7DjUbbH/PZf50uhevMrn09RRRXmn3YUUUUAFFFFABRRRQAV4f8VWI8cyYJA+zx9/Y17hXh3xW/wCR5f8A64R/yraj8R5Obf7v80cZuYfxN+dG9v7x/Om/lR+Ndp8sO3t/eP50bm5+Y/nSf560gOemD+NAajtzf3j+dG5v7x/Ok/nRQAu5vU/nRub+8fzpKMYwKAF3tj7x+maNzcAsTz60lHuO1AC72/vH86N7dSxx3pDx16UHt+VAIXe2Op9aNzf3j+dJjPbNKsbswCoxJOMAdaV0gDc2T85OccHtQGyNrAMuQcNnHBzT2VYiom+UsTgEenr6U1gFUNKNinoCfTFTzJ7F8s9wLlunyqTnaDgZpNzn+I/jSEfKGyuCMjt+H1pOvbv371St0Jd76jtx/vGjcf7/ADjOMnp0ppGR7+vanFsfSgBQzMeHJNGXCjnnBPrn/OKaw3BQVJ7kgc49KVF32/QqMgAMcd/8/mKTdiox0uBZu7H86NzAcMfag8nIBGaSqIF3v/fpC5AJ3kADNHSigBfMxJs83DkFguTnHrQWdhgsTj1pM8Y/Cj+tId+wu9sY3flRvb+8fzpKKYhd7f3j+dG9v7x6+tJSfUgcjrQA7c395vzo3Nk4J6dM96T+dHcUALub+8cY9aVXcMCGOfrTccA9cDmjsOePWkA553WNSDMwZiNy/wAI9/8AChnbd1OPc4zTWPyjPTPT0+tB/L+lJIpvRaC7m/vc+tG5vU/nSdaKokXe3qaN7f3j+dJSUAO3Nx8xo3t/eP50np6UUAKWk2/u5dhyDkruyO4pdzFuCQCfWkyMqNrfNn5uw6YH8/ypKSG72R7l8KW3eBISDkedJg/jXZ1xnwqOfAsWf+e8n867OuCfxM+0wn+7w9EFFFFQdQUUUUAFFFFABXJfE048C3WP76fzrra5L4m/8iLdf7yfzq4fEjmxX8Cfozwfc394/nRvb+8fzpKK9E+KF3t/eP50bm/vH86SkyPb6ZoAdubn5j+dG9v7x/OkooAXc3qfzo3N/eP50lGOc80ALvbP3jz3z1o3t/eP50lHtQAu5gPvH86Nzf3j+dJR60g1FDt/eORRvb+8fzpByOKXac/dP4CgALMejsCCD65x2o3sDkMfwNSLC+0M6lVOfmI44BP9KYmJVBiGQRu3HjH1Hap5kUoyaFD4xsVUbcW3Lweev1+lNDMBgE/nQNrkiI5I5Pqf/r03p0wfoelNWB83UcWbGC3ODigv1JfAAyc0mPTn2FKOM49c80xC7yG++R/Wl+cHJJwB3NNBHOfmHOR1zTY1xIo2sGYZJ7UmOKuP3P8A3j/LNJvb+8aUrgsCO5OQc02haoT3F3v/AHj+tBZu7Gk60dfxpiFaXYrPJKVVBlie35Uu9h0kJBAwQaaD+vWg80BpYUMynOfxo3t/eP50lFMLi7m/vH86N7f3j+dJRQAu5j/E350FmI+83tzSZx3Bwe3ajGFwOmOKAFLuc4Y+o5pSzZ+835036enFAHb0HSkBIkjlgNzcA8DnP4UyOZ5I9xEgJxlXOSv49/8APSgHGT7Hv+lIPunAxyRStqVf3bWF3N3Y/nRvb+9+VJ/nHpRVEi727k/nRvb+8fzpP5UUAODNn7zfmaQM2Blj+dIOv40DlR9OfakA4Ocj5j+dIry7cSS+YdxIYLtwD0GKQcAnazEAkKO5x0peMDGQMdD2pdR68p1/wxY/8J3bAtkmJ+Pwrzf45f8AJZtd/wC3f/0njr0f4Xn/AIrq2/65v/KvOPjl/wAlm13/ALd//SeOuWt8Z9NlX8B+p6z+zt/ySnVv+wlN/wCiIq8++nFeg/s7f8kp1b/sJTf+iIq8+q6HU5s43h8/0DBoowN27HJAGfYf/roroPBDOKKKKYgJAxuKjcdoBOMnGcUfUDP0owDgEA4ORkZwaO9IenQT8KX9MUdqKYB9M0Y5HA9qP4s+1CrnikADkHnjPSjrzycnqcDv04pcNgHv3x/D05P6fnSfgcew60tGUBQY5A/E9aXCdAhZgdytnG31pMYOc5PrijPb9Ke4KTWzJFMi4BklAU/u9rdDgjODkH7x4qMgKP4lO3k+v044+lGeR9DQCe3TPrUqKTuPnbVmGSfXGeRgD+lHJ9j3zQeeuetKVwxG5SVxlQckZ6Zp6InfWw0glR8xyMfhS7gFLEnCjnkgAfhR+dH602HXUcCOMNkY4I5GD6ZpZHXCZWPsThMEevOeaZntx1wMdqcuSy88Z5GO1S11Y09WN4xhc49CelHB9eDSgZHDbhnCtng03cpwM8sDtHc4qris76C0Udz60d8cjPPSgQUfQ4PY4ziigdskDJwATjJ/rQCuFFH60A9wKYB1oyBjcwXcdq5OMn0oHQZOffHWjPqPf6UtQ0vqAGT7+tG4DBJXHcjn/wDVSFlVkDZ+dtoOP8+lKqouAiALnJC8UMaXcU7VKkHjIO0jqO/Wk4Xqfr70YG5l2bQDnBFL0XB6Z49KSKkrCdsHpR+VFFUZidTnnOMdf6UtFFAxOlLRRQID/PPeijpz6e1A9PT9aQw6/nU9jzqFt/11X+dQVYsP+Qjbevmr/wChCh7DjufT1FFFeYfehRRRQAUUUUAFFFFABXh3xWx/wnMn/XvH/Kvca8O+K3/I8yf9e8f8q3ofEeTm3+7/ADRxfJopCARgjIznFLmuw+WCjOaKKBB27AYJJPHFICGAIIZWGQeuaUcdKQAKAFAAHQDigelg/AUY7YopaAD8/wAKOcE9eKQ9KUjJ/D0oAOmBnB7UdeBk8fdwACc9fXPal2nPoOtIQeARz3GPu/5xU3TKDbnnH60ARr1XcvIZV/iBHPNJjPX9aXJHQ4pgm09xyiROIyyLjaQGIwtI/K5YysoAC7jkoBnjIHPrn60nrSgncMdf51PKr3H7SVrCbiWOCST3wD/Sjn3/AM/hRk7V5/XNG0bRllUM2wBmxuPoKrRE79AGect19BQox8pPtnpR9aPzpiF3A7gD8ykBlycjjIzmnq67CWCNjk7k3ZGDkA9vrUeenQevvSj64B6mocbqzKvZ3Q1cEDHynHJ7Glz/AJzTBOjSKgf94RgqeM/5xT2ZVVizABVLk+gGf8KocoSvawgGBjml/wARQfX16ZoyOvP5UyOoUUUD64wMknsKA3D15z6cdOKKTjAIIIIyCDnNKPT+lABQBkgDucUZP6dMdOTQDhv5UAICrorKwdGGVIOQRS+oJGcZ56/l3oGMdMYHQCkTy5NkqjkrwSOcUh6b9By7CuckbRkkD/IpBgqp4PXkfz96D8qxny2Ddz198UoG1htHGMcUi2kkID3Bz7+tFH0oqjMTqMHP4HFL0oooATFLR29qKAD/AD1oo6+lJ2+vH0oAWj69KDRQB7l8Kf8AkRYv+u8n867OuM+FX/IjRZ/57yfzrs68+fxM+1wf+7w9EFFFFQdQUUUUAFFFFABXJfE3/kRbrP8AfT+ddbXJfE3/AJEW6/3k/nVw+JHPiv4E/Rng3tRz3oz6UAAdBjJyfrXoHxIUZpOtLTAKMjdtDLuxu255x64oowM5wMgY3Y5xSBW6h+Aox7UUUwD+vvR+f40d6THBH9KAF6E54xR/DncRkYBABx+dKBwSo5yPxo24HXgj72OvtU3Q13ExntxRsXIyB+eaOvXIz+QoAA6UwF2qxyqMrcK75+96cU4mRsmR5dxADDdlSB25HH1pmc9ee1GetS4p7lKpJMMhem4AHO088/iKMscdTx6f/WpQW9e3Y0irvYY6npzT0JvcOT34HPPOaCOc7ifXIoGCoZWVw3RlOQaKYap2Aso272xvbaCzHGSDgU9WAk+bkE8hhnPNN9R1HuKTOT6nqaVrg7WFkKlyCqk4HKLtzz6euKQ+uSRTXmRC4kk6KCTj7v8Anp+NKrhlJOQR1yMGhKyLkpP3rC8Zz1o70AqWKg8qRux2yMigY4/pTM2mtw+nrRR1/DsRiimAenPfnjORRRx03DIAJGeQPpR/npSDUKKOcHHHTnHuKD9KADI3EBhuxuIzzjpmjgZPA9c9KD/TrjmkJRmaJxn5dxBHBHSge+wuVDEN0Pp/nml4EhXdkgHII5H9aAoORsLDbgAHv6fpTQA0eQO3GfTr/WpKSVri8dP0oJzyaUnOM9aSqICjGM4zzzySaKO1MAo9KKKBBR7f1oo7/wCHtSGGcflRR6n1opgdf8MP+R7tv+ub/wAq84+OX/JZtd/7d/8A0njr0f4Yf8j1b4/55v8Ayrzj45f8lm13/t3/APSeOuOt8Z9PlP8AAfqes/s6/wDJKdW/7CU3/oiKvPjXoP7Ov/JKdW/7CU3/AKIirz6rodTmzjeHz/QKM9aPSjtXSeCJnPTHXnJxS/pQTQaACjI7fnRRQADnp+lHryPrRgEEOCR3AOM45pFJKL5ibHI5UHOPxpX1HbS4vA79+aXP93lu1J19h6+tGdmX9ByRQJbiKiltwABBJyV554xz+BpecfMOfrmg/KFGeOg598/40EY6UFSd2FFH+eaP8mmQA/WggEfMAcHI9qPaj6CgYZUuUzlgoYjHY5/wpPl3bgqgt1IGCfr60ucgelH1pB6B/OjjvR26UdPpmmAf5zilJxDKVIDAdzjHNJSgkdOv061LV0OLs7iZGT83XryTn8aXcenOPegsXUgdxnjjJpMggEULzCWrCj/HNFHbk55znGPwpiD6UZ9R34yOlFH+FMApOcfKQPqucfrS0mQWIB5XGRj1pAhaKKQkBSWIAHemA4HnAJGfQ0g9cYzxjNHTIo/p+lIBQQCcDHcgHgn1570nT2z6Uf1o6/XNFrDu29Q5+ox0pCflJUqp4xvHFL6UZ9OT3oBaMUjBNJ060cUUyRce4yegzyce1J+Z49KTA3B8DeBgNjnB7UtLUrToHQE88dTSgcHKghQTw3UikIyMMOOvSlz82eCfzoYII2DYWTCvjKkZww/HvU1h/wAf1t3/AHqnr/tVAoRXDRxgHGCOxqew51C2x081efxpF3TlofT9FFFeafdBRRRQAUUUUAFFFFABXh3xW/5Hh/8ArhH/ACr3GvDvit/yPEn/AF7x4reh8Z5Obf7v80cX1pP89KXNFdh8sGR3pO3IGfY5xS84ooATvRkD69cCjNLQAd+tB4/+vSg459KaBhmXy8JtBDl85Y9RilcaV0L3zkUDHc/WjPoM/XtQRx/exyPrTEIQHwHXPpkZB/pS4IwOq4HI74ozlmwTlflPNHBwfxpIpvSwf0opP8aXt/KmSFAJDAjtzRR3oAT5I0HRFyFHU8npSlVPDKpKnIJA4PqPyoBopDv16hnjPajHage1A9hTEH0/KkfO3CnDHp9aXrR/n6UAtGVS6NaYEiny2G35s7ecdM9athiOQSfembE3Bti5Hcrj8ad03Dv1Az1pbm1SSlsGcnJo7j2oo/i69umPpzmmYoKM+tJS0AHbgcdOB0o/SjvSEgYBJG47QfwNALUBn+LBOT0GO/HelopKAFzjvig8nnPruJpPXBBwcHHrS/j1oDYXI6jg9iCcikJHB7L+eKP6daKVh3egHPODg+tA5YDHU0nTj2pc+tMQg+Zc5RgSdpXgEZ9+9L/Kg8/eHNJQD3F4wSSAAMkk8AUEYOD69uaRlV1KuAysMEGlyScnmlrcNLBSMxVWKgMVBxk4pRwO598UDA4HA64pjViAJIjZaZiigZAHHPOf16frUqOJASDnGVPNMaLA+VVOfXt9KdGpRQpGW7kd6ZvUlGUbrc91+FX/ACI0f/XeT+ddnXGfCr/kRov+u8n867OvOqfEz63B/wC7w9EFFFFQdQUUUUAFFFFABXJfE3/kRbr/AHk/nXW1yXxN/wCRFusf30/nVw+JHPiv4E/Rng1FHSivRPiQz60d+AMfXn8qOeKKQB+dHHfAo70ZpgGfw+tGMjOaKR87cpH5jr90bsdetJjiruwvXqQKOB3wKU4ydvr2pOfp7UCFJ7DJ/vY54/D8KaqhVygGSBxjGfelO0LtPAc4H5ZP9aCctyST160i72VkHTr3ooxjGPWgexqiAP50fSijg8UAGAWBx82MZoDK2SpDAMUPHccEUdKUnPWkF9BoCj5UVVHYKMAUvvRQfTFAbgAOP50euf5UfUUY7d6AIg226BV8KeDzjP8Anr+FLEQJHUEYGMAZpZIo35dfTPt/nmlVFj+6oUA4ODVaGzlFxsPLEjBNJQe9IfunnHvjOKkxF7fhRz/9ajvR9KYBxnoM/TmjPej/ABoHP49qADnI5BHOQRyfTmikVgy7lOQfUYpaAd9mFGfl7kDtmkyMjJ5PTPel60AKOCM465xzigEBQAOAAoXOQoHYfy+mKTOMnrR049KVgu7WAenPWjnvz6e1IfX86U8E0wD+JQCvIJII5x6ijHpRnPTpRxSAKXGMjIyCMgEZGRn+RpD0OKMAM5VQC53Nj+I4xmjUNLB+fPtR6Y/U9aO/6UdwSMEdM9qAIZVlZzsdkwABtOaVuFXErl9211OMfUEDp/L9acQwkJ2q6kDINN2t/DGETcCec1R0qS5bf5HafDHjx3bf9c3/AJV5x8cv+Sza7/27/wDpPHXo/wAMM/8ACdW3b92/8q84+OX/ACWbXf8At3/9J464q3xHvZT/ALu/U9Z/Z2/5JTq3/YSm/wDREVefZGcjHTkA16D+zt/ySnVv+wlN/wCiIq8+zj6VVDqc2cbw+f6B39j19jSEAjBz+BIIpfrij0711Hgh/k0Dg9M0dR/hR3oEIAQoBYsR3OBn8qX/ACKTrggnjIx2Ocf4frS/T8KQ2A6+5680dR1P+NH+HNFMA60noehxgcml6f8A66MNkYwR3z1/CkCA8jHr0zR2GBwaMYzwKPTGCOc560AH6UdD1/DFHSj37UAHrRThG5XKoxXdtBxwabjOeCR7UXTAKKKKYgoA9KPWhuQpJYbewGc5pFJJ6ByPTPb0owM8daCQME8DOOBR0wD6UCFwS2QCe+R2pMc/Q56UjAYVsZ2Ekeo4wf0pSMMfXPc0DEONpPbFKfbn6mj6Udfp/OmIPp070fpR2o69KAD/AD9aOR/QZo+vApPqBn2pAL7A0UY49O9GCeg/xoAOtHUY7d6KKYATR/jRRQAdOvAPaj/P0ox196Op/wAaAELKHVGbDPnaME5x/KloMgVRlgATgknpR/nikNrRB+dH6UUfSmIB6gt06Z4ooxzR64NINwqxYf8AIStvlJHnJk+nIqv6VPZPs1C3dmCqrjd+Y5pPYqGskfT9FFFeafeBRRRQAUUUUAFFFFABXhvxXx/wnEgOAfIjxz7Gvcq8O+K3/I8yY/54R/yraj8R5Wbf7v8ANHFk5yR17eho96Ov0pPpx7V2nyoAYGBnr3JOKWijp+dABzn7xxjG3j86P88UdRjJBIxx1pPU/nQAvX6dsGjv1wcdu3vQenpR0oAP89aQgHII4784/lS/560nb5cZwcA9PxoBbi5PXNJjGcY9aXB6kAUh/ixjODgHpntQAv4YpCOOD9OKU45P8qOp460ABPp+FFIzKgDMwVfUnGKFIZQV5B6YoHZ2uLSUuMZxnrnrRQIKP8Oc0fWlHcZIDArkdsjFDBWvqIQf0pOD1oXlQOSemSMH0ozlSR6dxQO1nYXGRjrjtQQeAQRngg0YByOxGKQAbFzkBeMZ9O1IFsL7d/pR68nrR7cUe3f6UxB/Ok69aWk6UALR9P50Yo6+mP60AJ7nvS0UdKADPNFGMdRg9aKAD19+T9aO9JS0AJycY9OtL1+lHp7UnT/PWgAJCqSxwBSggqGQ5VhkHBHFKGCnOe2RSBg6hgQfUA5wfSl1Hb3bh+fpRSUtMQmMjGWHTkHnrSnmjFHTFAXDvR3HBPqB3o9f50hzt+U4PY+lALc9z+FX/Iiw5GD50mRnOOa7OuM+FbhvBK7TnbcyA47HNdnXnT+Jn22E/wB3h6IKKKKk6QooooAKKKKACuS+Jpx4Gus4xvTOTjvXW1yXxN/5EW6/30/nVw+JHPiv4E/Rngwx2557UD/9VGfXij8Bn1r0D4kTAJB5yM4wTS/yoNFAAQSpAJX0Yc4oo/z0oxz1ODzz2oAPp196OinsPXOaPoOaO+femAH1/T0oPr70fnR7e3rQAYwfTJyec0HnGccUYJJ4GOMEdenOaD0/zxSDqH4UUdSRxjjH5f40fjQAD0znuOKO1GPX0yKYJozj5gOPWnuNJvYfRRjoTn25ooEFFFH+NAB60UH7+SWO5RwRwMcUHGcevtxSQ2rbAMDp070oU88HHTPrSdc59e1AA8zOOWGCR7dqGIO2T39qPTnHpg0AAY5z70dOe3emAfX60fXp6UUUAH40dfX2oo5HTGe2aAA88H8aOvSkx/8AX96XH+FABmgf/qoxkZxwB27UUAHXB9OlFFFAB29TjpR04Jye1FFABSBlZmQNl1AJAB7+/wBc0vY9sfrSl1L7CwHHyknqe4x+dLUaV7if54ooopiDtR0zyxyxPJ9Tn8qOtHrSDpYO1A7Zo9PSjv8A40wOv+F//I9W2QR+6fnPXivOPjl/yWbXf+3f/wBJ469G+GDbfHNsGP3lcKMf7Nec/HL/AJLNrv8A27/+k8dcVb4z6jK/4D9T1n9nb/klOrf9hKb/ANERV591HFeg/s7f8kp1b/sJTf8AoiKvPvpxjpmtKHU5c43h8/0D+vNJuUMqk/ePHBo6Dninc4xng10Hg6dQxnnr7UKu9lQHYSRk/wCe1HDKAQ2cg5VsYI9fUUh9e/vS3GtBquskW9cnk4BGOlOPfv704BpGJ555P+JpuM4J6Y9aLg7brYMjHHT9KCcDLMq89SaCSVcB9pIwGGDjn/I/GlyecdO9PUNOomPx96COTkfLjg57/SiigQcZ6e9HPbHXoaUAkDpywUZPU+lJ+tAB64z+VOAJBKEA8HnvTaXJByOOeDmkwQxIvNZGzuiUD971zjryOM8dOtPbBYkAD2FBPyjAAGc8Dr+H40lCv1LnLmemwdOw/KkOB14paBnpwPpVEB+P4UdT1+vFHXGd1H4mkAUelH45o/AfnTAM4H407ZgugO7YSSR2FCsF+ZkZgDkj1xUILk/Mods7zhM4OecH86nW+hpCN07kh569O3vRSsQWO3pnPNJTRmA456H1oHG3dl8cHPeijnPG3bzk559v60MEAGFxvL9fmYAfyooo9aAbu7hSMAyMp3cj+E4P50tFME2ncCQWILDPBIHvRRnK/McAfkKFwyqwO5GG4EdwRxUjt1CjOTnkDkBd2Vxk4PTrQM4GRgkcjOaO4phtoFH0+tFA4/KmIXOeoz7GkHQemKOhFA7UgDt07Uf56UY/Kjp1NMA6flQpYqdyhSOPv7tx7njt0xR6n9aOv0pDvpYKnsDjUbbk/wCtX+dQfQDH15qeyI/tK2BIBaVQAT15o6Djuj6fooorzD7wKKKKACiiigAooooAK8O+K3/I9Seot4/617jXh3xW/wCR5k46wR/yNbUfiPJzb/d/mji/8ikJABJ7An60fypQf7p5Fdp8sAwyjB4PI4o+7yQPY0oOGycnvSBQFCjdgdAzZI+ppD0DgOEZmYkFske/Q0dse9GTtxn5Rz9KjWaN5GiDfOOoII9PzoRVubVIk4B9/QUAE9MfnigHBHTrzzRk8/NuOSRxjHPSjUnoICrDKsGHtg0pzt+UAtxwWx35/Sg0UxXVxDgZOM89xS96UAs2BSdgQeDyCO9AAM8Z6+1Kp+YZ9e/am0vp35OeenpSYFW9IjlXz5FZR95eoHoSP0z0qWJEGTHgowBBHQn1H6D8PepgxyDxkA49R+NJ2+lNN2szeVW8FFITHtS9elFHfpx3zQYCDB6N+NL268k8cde9Hrkk9+lB+p+mfegYf5+tFHPPP6Uc+1AgHbNQtdRRSoHLksSuFQnPGe3HTP5VMOvKnr2rNkuS8iQRRuHidGY7NwPzAt+HJ/A00rnTh6SqN3NEHcDt6g4Oex/xpeO3TrVe3YCV414UHIwDj0NWKVrGNSPLKwn1pecn5iR6dhRSHdtOzaWwcbjxnHFBC1dhfTkjggqAMHpznrRQcZOKKSC9xKWikpgGAoYkkAuTljkkn09qKcCQT2+lIMEsFYFlxkZ6ZGRS2Hq9QoyTwCy8AllOCOc+nTAo79OMZyT3zR2OOvajcFowz34HfFHb/IoopkgDxij12qBnsKMZ60nWgYv0o9qP5+tJjHIPvQAuOtAJ3BQuQ38ZYfL68dc/40Y5x70Z9Ov8qT1GnYKP8O1J/ugZ96M4GTwByTnpTEe5/Cs58DRHn/XydfrXZ1xfwp58CxEc5nkOfxrtK8+fxM+1wn+7w9EFFFFQdQUUUUAFFFFABXJfE3/kRLvP99P511tcl8Tf+RFuv99P51cPiRz4r+BP0Z4N2o+vSk/mfXvS59eK9E+JEDAuy5+ZQM8HuPWl29wM0pzxnt0oOMgjcCBj73GPp60h6DWICl9xCorHaBnPQ/nxx9aUgZBBz70bvL+YHG386Z5q7QcsFzwdposyrOS0Q84xz0oz6frSKQRuHc8e1OyTtw+MZyMD5qCbdBpIDBSwDEZAzyQP/wBX86XvS5P4dv8AP40lAnboH+8MfMcYOcjtRxyMdKKXB9ecZ69vWjYNxOc9sd/WjPTr+Io60DrigBtwP9FYmQRptIJzgqevH8vxqrAITbFiV3gYAxgk1cz8hBGAV+YHn8KUnLfhjinFtKxvGryx5RuBjoKX8AKKPb+dBgHGR69ce1ABOOc0Z4549gKPXk59c0gDgjI5HUduKKPocc0flQAev0pruAQrZ5B6LmncjHH5Gq9zMYZIyFPzAqQR600ruyNKUeaSRKLhCm/59o+UttPUU8Hu2M9QB2qCPKxSMYzjY4LbTkg9P1xUy/dH0oaSHUjGOwtHb5WK+4oo/lQZARuVhuKFgQHAyVyOvNBOST6+tHJzuCgdsH270Ul3G77BSUtFMQYyyH5iVJx82AMjuO9GQc4YHBI49QcUHgUMwGGdsZIGWPUmlsPV6BSE4UkYJxwCcc0pBAbAyw6DOM80HqcdM0C8wPfJY5OfmOcewoo9aKFoDDocjP4UHnsDzkHFFJ0/z3pgL/PtR/nmg9CD+VGKADFByAcDJHOM4z+JoHHU9D60DhRSAXkgEgDP8IOcD0z3NJR16/lRznkD8DQtAerudf8ADA/8V1bjnHlv/KvOPjl/yWbXf+3f/wBJ469G+GBB8d24yCRG5Iz04rzn45f8lm13/t3/APSeOuSt8Z9PlX8B+v8Akes/s6/8kp1b/sJTf+iIq8+r0H9nb/klOrf9hKb/ANERV59irodTmzjeHz/QO/FBBHRev8VGcnAo25/1YRSzAvknkf410HhIMYJ25YZzkYB/KpEVlO5Uyu7DmTACen1zUeQWC4PKlgccfn604x+bG3Cl0Pygr97HUColtuaQte0luLIlw6rH5beVgMY4xk+xYDkd8ZpoXam19ytkkgnp+HahCTCScqHIIUj0HX9aT9ADRFPqE5dErByRmjHOcUYOMqhY5GcNggZ5PvQepwT9asztbUMYHf8AHmjn0H59KO+eaTHpn86YgIDFSyq205XIBwexH5ml6difpR+tH5Uguxdrbc4ZRnrj9P1pDnuW/P8A+tSBU80y7fnK7N2e3+QKXjtkD2oG7dA7/e7559KCMcFTjtk0hwOoPvxS49Rj370AH6UUqqS23B6Uh96BB1JAzx1JU4o/xoOSMgc9P8/lR0agAByMggjsQaKM8/zoA+vJyc+tADkO2WMn+E55FIHfy0Ut9xduM+lJ3J/Kjjn655+gNKyvcfSwHBznPqDRk5OSCOxxR3x3xR7UxAOuPzo7UdOB0o+lMAo96KKADjnBBwcHB6UEEqdpUMR8rMMhT9KOhGFzlvmI4xx19+1FLcezuhW5J4GPSkJJOfak7UtFrCCijn0oxzjPOM470AFISApLHAHJPpS0DIIxTAPpggjr60D0PY9fWj68UUgD/PIpwA2hiVUZA3MQFGabnqc9Bn60TRecEiRmaQknBwFIApSdi6ceaVmLtIQMw4PIOeGpKkkK+RDErFliTb7dc/1qPvSg21dkytzaB/PPSrFjxqVuPSVf51WZd8bIWZAw5ZOtWrNt2qQH1mX/ANCpjVro+naKKK80+8CiiigAooooAKKKKACvDvit/wAjxJz/AMu8f9a9xrw74rf8jxJ/17x/yNbUfiPJzb/d/mji/p1oIz/Dux0HpR06+tAC7lLAEqcqTn5Tiuxny6DHQ9/7v/16CcKCFkMgzsXAO9v4Vz70mWSLMgywGW8sE96JIt6hCBgnPT0/+vSeqNIWU1zbFe6ugAGeMxRqMM7IQqt6ZPFJA8VyyPbktFGSTIDjnHTke4yPSklfAFu42S7gQAPvLnqMVb6Hj86vZWOipKMIpJWfrp67B7Dn9KDz2yKFAJAxnHbNAztXcrK3dSc4qepx20uH0z+HFHPsf0o+p4o/E0xB7ccjB70gUKoVFCoowFUYxR+NL+VA7u1hVDMflVifYUmCOCzdOuQP6U10SVNkq7lyDjPpTickk9aXUNLB17n3owfc+pHHaj86QYP8PGcHI6UALj2xSfWl5A4zj+VKVI9R9RTEJkDGc5PTAzRjBwfTsKBzx1o9yMc0AHfGRnGSM8/54ooPb0pOpHr0GP8APtQAv8J+npSGNQz4yA6ruAYgHGR079BSkdB+Jo7j8R+mf6UioycdhMBQPQHpRgrwp49D2pTwOenSg+9MkD60UnTJHel/nQAUUUlAgGOOQM9BnrRS8HGee4pASVG4YOORnOKCulxxz82dpBYldoxtGBwfXnNJn5SMe+B3pOtFJKwt2L/n60Ud6O3zELzjmmAdKKCMGj6daAEBB3AEEqcEehwD/I0v8Q96M5wTzR29jQAnp/hRwByCe2B1Oe1GajuHWNUeVnEatligyR8pwfwNJ7F0480khySMxVjsIYcFHB28kfN6Ht+FP+nSoo4xHGyEkPJsYBf7uQ2c/kMfWpaFq2aVoxi9A/lR2BP4UDrmj7qkbmfJLfN2/wDrUGHQ9y+FX/IjRf8AXeT+ddnXGfCr/kRov+u8n867OuCp8TPtcH/u8PRBRRRUHUFFFFABRRRQAVyXxN/5EW6/30/nXW1yXxN/5EW6/wB9P51cPiRz4r+BP0Z4N35+tAz9KO554oB7+nY969A+JALg4K7B3OM/ocUqg9NrHjHykc/hTQNu0IFWFEwBk5BpQcs3BBQ919s/jSuU/LYZJKBHInlsYimY5WjI34Azx7EkfhUJvVmI81iWUYRcYUD8qejRpbRy7kYglXAA3c9D/T8qWJRuc5DAnIxzVRSS1OyXJFPQWDiP727DHHvz61JR9fTAoxhvuELj74bv6YpN6nG/ebYAe2OO1HP/ANY80dh2o/E0yQ59vzpMDcX2qHIxuwM49M0vpyaKQXa2D22sfpSlWHXcOOARjNIDjn0pFREVgq43MWbnqTQPSwvQ8lvXqP8ACgLnjOaPpn6UnGeM+3FAC49QcjnntR06UYzjAwT6UoBYE4NAmJ1/LPrR1XI6epGKOhoxnGB1oDQDxySAOBycDJIA/UiigcdKTqMc4PBoAX/CmSRCQl8lWTBUgY/z1p4456gfrQo+XB5z1ouVFuLuhrI0jHfNIwbg/N1pVHygg4IGM0o5HHcUZznHrQDb2YDJ64z7UdaMZ680detMkO1FHf2ooAMZOO5pAQVDKQQRkEHg5pR7UDjhVwu3gjj8MUhijOVI24BO4MM7hg8D05xQDgg45HTPak60UWEwoo5xx1oxzx0pgFFHbIOeccUfWgBCQNu4gbjtGe5wT/Sl7EflQM8jtQORyMHHIpAHX2OKP8PSjvn86B9cUARhpNm7ES7hkB5MFsHHHv2p6klfmXawJUj0wcfzFRCOOdk3SYRSBIWI+XJPIFTNL9ollm/56Su30yxNF9TpqwjGGi1CjHT6c+1HWl7q25l2EnA6HIxzQzmR13wwOfHNt/1zf+VecfHL/ks2u/8Abv8A+k8dej/DD/kerb/rm/8AKvOPjl/yWbXf+3f/ANJ465K3xn0+U/wH6nrP7O3/ACSnVv8AsJTf+iIq8+6+uMc16D+zr/ySnVv+wlN/6Iirz7q3eqodTmzjeHz/AED+eKMH3ozz9f1o7/jzXSeCKnO0DofWhSyruUc8EdTkn+VABK47kY+nalJy2R0H86TGIeOM59TSfXj096Mc49smj6fiaYg7/wBKOCSM8r1o9KMn8KYBRRzRQAUUUfhQAnoDjP1paKKADOKOPQflRRQIDEHUhGMb4+U570K7jCvtbHB68+/P9KO/Tj1zTw52bWJI7Acc+tS7lqXRineQj7JNvJXAwpx97g5J6j86ZjCndkjHX1pSrOuE2IQehHUH0PtTpCC52fNgYyT973/Goi3cqSjpYjPsR07U7b83zAHaQST2PamZHGTtx3PTvRIzxTM0Z8sSOwTupHb2PFW77BGDYoHAx680v+Pr04FSbZDGpSDMqjLRs4XOPTP8qaQxj37SM4zjkVKmmxOLWrGe1FB9+MnjJoHzdDn6VZAUcjOOtFHToKYB25/Sj8O3Sij328dvekAdqKOnbPoKMc9aAA8deKOD0IPsOaRSMAqMc9xilzkCmAfN2XPHQnFDSKpRgpbkq3sPp9fejGe2QKOCMHmla400gHK7hg+wo7/WjAByBgZ6e9Az3O714xQIPxo9+v4UDjoPyoBzwM9BzjjvxTAPT5guSFHfk8ClBwOW4x1z160gPI5NIOBkDqOQo60h9LC9Op7Dijv7UDOBxgUf5NAgqex/5CFt6ean86gqex/5CNt3/er+HNDHHdH0/RRRXmH3oUUUUAFFFFABRRRQAV4d8Vv+R4kx18iP+Rr3GvDvisf+K4cf9MI/5VtR+M8nNv8Ad/mji/XP8zR9OaOgGefejggH8q7T5YM8nr0pcfOCBngDr0yT/n8aQc4pxzt+U4Zjke3b+lJjQh+9uOMrwvBH40nJ4H5+lBwBwOBwKD79f50IV7iHpx+BpSRxzjJwPrR/nigHjg4zTAKKKPrQIKKSigYZ6+lGfxpRRQAdKOvWk/KloAMKfvD8qTEkLsFkDq33C2fl6fgfxo5+tPRmVhhtvTp2/GkxqTQqMWBCI3C5YxjkDvz0/KmkMCBhuMDBxn69KdnLZC4B4yRnH/1qMFYsSEOxbPyngD0/rWd2maNR5dBnHOD+dKMjGSAScLnpmkJwfmHHqMkVWdQLrdIy4ZfkYdVIHT/PrWq1CEOZlhdowExgDAHcUvReT0B/l/8AXqGOXddIDsbzBklSBnA7+vJ61aVZc7ZIdrKcja4bcOuePpUSfK7Mc6bjqyM9f6elFLg985HWm5z0YZ9jmqRiLR9aMEdePrQf1pgJz39KX8MUGjByMDPqfQUAFFHuBj1o5OO39aADrSZH94fSjjd05xnOKXJoATnsDntmlONrq4x8pxgjk9v19qPp+nagfLx+lJ6jTs7gJPOwcbGIywPY0c0bV7DB65o9OeOwxTB26B6Gk9s0uBnOBmjOOueo4H160C32Ac8DigH+IPuHX2H0o9iaOvXkjvSHoB+vcc5o9xRkktwcjHP97jqPx4oNMWwGj6UdP/1UfX8vWgD3L4U/8iLFj/nvJ/OuzrjPhV/yIsX/AF3k/nXZ159T4mfa4P8A3eHogoooqDqCiiigAooooAK5L4m/8iLdf76fzrra5L4mHHgW6/3k/nVw+JHNiv4E/Rng3+PANH0J/nR3/Cgen5ivQPigP3Tn3pSNwYd+n603oCB6d6eOo/E5oYDfLGB8qjdnPBOAOc5/IfjQAB90AD0pfU9c8D2H/wCuk9fb9KENtsPr1Pb0oHJx+VH6CjvTEICGUMpyD0paOT1ooAKKKKAD6daM+lH4UUCDrRmj8vxooGHHoKR4yV3QybSDyp6EfhS/WgZ+h/OkNNp3Qvmk5LKpHYcnH9fzpzhwxLrIpwPvYwAeRgY4FBbeoBG8+/TGemP1pVBMiuWUIPvL0Y/45rJ6dDRcrTYwjpu4Pv0oAJOBihuQcDg5zz+oqC5+eIhSAxI4atY6kxjzOxKdu0kFclSASeo5/WnDk5HTHFQrGY5DGkSs3DNGyckdSB3HTrUsIZYI2jiV48YZjIAV5PalJpI0lS00D2HP49fajrTmVlxlWA5xkf59qaeOpA+poTMNwoowevUetHaqEJzjj9aX8CaKOn9fegYUUY4+ZcH09KMn/GkAe1HTrx9aQ8Kc5b/9fpS9BwBigAHt830oyQMkfKPQ9KOpyaMcAkY/pQANIqyMoXggEMeme/Tp+tKRjHcHmkO1iCwzRjHCnHGB34oSsNtMPz9aDx14x2oxkc80fpTEFHtv2nk4HXAx/jRnOSMjB7jrR9TkHsaQ9nqB9DjOegpBjp1OT2oJwMYJGe3b3pxzk5oEJR+tFH0pgdf8MP8AkerbP/PN/wCVecfHL/ks2u/9u/8A6Tx16P8ADD/kerb/AK5vz+FecfHL/ks2u/8Abv8A+k8dcdb4z6fKf93fqes/s7f8kp1b/sJTf+iIq4AI29VAGW4Axya7/wDZ2/5JTq3/AGEpv/REVcA0JmlZ8qIuP4snp0p0Xa5hm6TcL+f6DSCFxnbjoSOhFHXrx6ilbGSQuwdgB0p7fLEWwCRwNvOa6WzwFqIFwquQSpk/h9uenfqKRlZQM9cbjkdKYxMkp3YDEDPHQYz/ACFSbi6kbNp9AOB7471Oq1KcegzGOF5yeTmj6DI/SlIyR3zz94Ht2xRtbvuPPWruQ9BOo79O1HByRzn3oIxwcjPHIo570AH4fTijp/8Aqo4NHTgdO1MA5IG1tpDAk4zkdx/n0o/zij8T+dFIAoPBUHgscDg0YByCMg8EeoozjOOAfQ0BoFAHXAyccDIGT9TRR7UAtwPHsO/OcUdDnvR378Uf40AHtz/hR/nFFB+nPrTAUc4BAIznkVKiy+bGIMLbqu6WQqML/hntxUIPPXj09aNgC+vHGDgis5xurF05KMtRVSO4CEfJu38xkMS3Hze/f8/pRPn7RI2NoJ3ADr1PXOcU5zv/ANYc5PoBxxjp/nmmHBwSg9uOlEU9y5VE2KwAbPXPXcoz+lIRnqv40fqKOMjPBJwOKvYy1E477h9QaX6E0Z/L2peNwBGSxA4PP1obsCTewg+9gkHGMjIBwaMnqwAOOVz9098mlwTwCTznJOaQEfdHYcg0Bp0DpR+NHQEevTnqaDkg7SCexNAg+v6Uc9+PpR0bPHvikG8BckMR17BuOtAJXF+vP17UUZ5Hyn8KMccDFMAo9c0deR3oyOKAD+VA5PP69qTjjHrSjNAAu7b+927s5+TOMUdcjOPpSfhS556+1IAAJY4y3bFGQcbSjd+HB4/D6Gj6HkUqxhmZo0GWUBiPQZx9OppPQegh7/1qxY/8hG29fOUdfcVAVKrubkdiOc/jU9h/yEbcsefOXp2+YUXuhx3R9PUUUV5p94FFFFABRRRQAUUUUAFeH/FVc+OJD/0wi6j617hXh/xXUyeNGRMbvLjY7mwCNp/z+Va0dJHl5or0PmcXtYBWIHIz7GkAxld3HODjp7UpiEQ2YBbPzOO9PiXfkHaQflOTgj3/AK12c1lc+V0vZCINz8dgT6UgU+WGAYBQFOR370xpCwwwwuePl68U9DswCo5OdwXocev0xSdyuXQbj5ueSO2elH1646CnEHntjnbux+fc0gU8YzjHbpTTuS1bcT9KTA6c07advQ4pvbrnP+f8KoQUuKOnWkxjpQA5T8wzyPcU0ZCDe24gctjGaPxNL+f50AH0o/wz0o60dOQBnOSfU0BoICCoIOQRkGl/zmjOTk8n3pKA9Bx6n5eM8HcDu49B059aT8jj+dH17+lH9BSQBk+/pR0+maKTj6imAoOOlKYwbdxHEJJuAqBAS2e3XJPtTfocU4AE7j2HPvxSkVF8ruIYI4cW7JD5yQ5dlwPLY87cfkOvWnyoEhTys7Qc7nHIz6YPPTFAJClQcAEhs4PP40whcFQoI75HWs4p9WbTqqTAD5MEk7TxlQR/jQef4VPsBScYG0bfbFLwevA7nFaGD1YmMHG0j3H/ANagYHQmlzlRtPUZ560qgMwDEAZxk9qL6XDVuwh4/iA5xzijn0Ax0JOc8fpQpyiNhlJXJUn19aPu43HluAaB7aB1GelJ17ilI5zRkdQcimSH40d//rUYPOcdePWjDHPzYBGOOoyMdfxpBZB2wSTR0pMkrll5x2OaX8DTAKP8ik/pR0+vpQAfT8aWkyOOeo9KPSgBRuDjGzywDnGd3+c0dPSj8PpR2x0oACCQRuPJ+lBIHLFQfQsBn/OKPqe9IQhA3hSVYMM9j2pa9Bq3UXHrx7Cj24/OkDAyBejOCQp6nHt2pfvHGfl9fWi4OLW57l8Kv+RFi/67yfzrs64z4VHPgaL/AK7yfzrs64J/Ez7TCf7vD0QUUUVB1BRRRQAUUUUAFcl8TBnwNdf76fhzXW1ynxJYL4KuC3Temecd6qPxI58V/An6M8FCMdwwOBkgdRyf0pGyCDnnuMdRRHblUEk21/Rc5yfU/nSgfMBkDPr0r0LnxcrJ2Qcev59uKfsO4LggsowQM9aHZo2XYvzNgnHIHOM/jjNRR9mUA49V6n/OanVq41HqxzDBOflHTn+VJ04xhcd6fncqso2jgegHtz06E5pu0gkDr65yaafQlppaie+PzoPHJzS7WzjDZxSY59D6VQgxij8P0o9c/pQcGmAf56Uc7gc/Ljlcd/Wj9KPzpAHfr/8AWoH40UcHqM9/xpgGRuK9wASMHv8A/qoozxjt6ZopBoHYYXd82D8wXaMHnnrzjgevtR/ke9Aoz1IzzQAdsDv6UZJOeaKOlAAPzx6UFFlwJfu9Dxk0n04peuQTnP6UBezuhrW23zrmcbYlxHDubHmk9s5ORgEHHQkVNFFGGLKGX5VKovIAK9Dg54701fkdSv3uxHTOPTpQcdW+Y4HYegrK0no2dMq14pDI8iQbjtO7aQoBA59+tKBjgAfiOaOAxO0A/wB4DFH15/CtTCTuJjvs/Kjjjkj86UYycHnA46UDn8aCdQx7n9KAc9MNzg4YDGDzRwcjp8ucqehORj696XBOOpAGOeppXKty7iD04PuOBR7fzoB3DrkUexOD1xTJD8RR+VHPGMe+aTBxhSB74zQAvfr+VGOfU+poy24/xAjpnpR1z8poC1go/wD1UHjkjNGMfhTAOKKTPX07cUv0oATnBKhS2MAPxn8qXnC7iCwUbiOhOOfwzmijPtSDoHXvj6UDoSTxkkknp09aPx96Mgc9snr9aBh34IPuGB/lR0xUZkiij4+VAx5xxn60/d8uRyegyPzo16jlFrW2h2Hww/5Hq2x/zzf+VecfHL/ks2u/9u//AKTx16P8MOPHVtzz5b5/KvOPjl/yWbXf+3f/ANJ465K3xn0uU/wH6nrP7Ov/ACSnVv8AsJTf+iIq8+25xtV92eDjpXoP7O3/ACSnVv8AsJTf+iIq8/B54IJH51VHqc+b3vD5/oLCElP7uVc903gMPoOp/DNOMSTFBE7xvu5LfNgev4U1o0llUyNjewJBTPPQ4pSGM7MWKK5LEAfnWju3v/X6njLlXvIcsSG8MYXzYgzKHTLZI9D3P+c03zzLF5v2QZL7S0SZVRj3/nS+ayoqqqqR/EoA+v8An2pryNK26Ri57luaSjK+v9f8OJzT6DSFz92P8FxQAgxkEc880eucmg1sZ3YANnaVjGXO3ytx47ZyaTnBBJB/vLilPK87sZ3DHej6cA0JDbu7hzgck+5HX8qQ52sEKh8cbumaOB7fSlPvyKCVowPbdtBxztPH4Uf55o7kd92OCOmDzR60IGJlQwBZQzZ2gsAWxycDvS9GCnIbGcEdvr0pckDGeKTcOgIz1x3o1GtgPGKP89aO9IrKV3K24A449aBWYozjrnPP0o/zijsM5HtRTASlo5449c80UAH86D0O3jOKPY/jQexOT1pAgPJ/P+lH9feg9fTrQOtAB05owQMc9PSjsQce4pMDnHGTk/WmAvvyPcGjp3IIpMZ65pT9TQAjhwpAxjAwxGc8+g5pzdTuUjk9SD/I0mcdDjijv6dsUh30sHbgAUZo/SimIKM/MowcHOTnpSUv5/hQAY//AFk9KPp0/nSEAjDcgdqU80gD/eox19/aj69O9H1HPtTAOtHUUUfj+lAgxnvRz25+go756jHejGcfoc0DDIz06dKHjnlt/JhRQGYGQtIBwPr7npR35+tAH3SBjaCD+OP8Kl+RcJcruKkUcUSxqqvz98Z5+gPaprDI1K2XyyBvU7z93O4fL9e9V8DByM5655zViwGNRtsYH71cY+oos7D5uaV2fT9FFFeafdBRRRQAUUUUAFFFFABXh3xVAPjp9ysR5EfA78V7jXh/xV/5HlwcYMEYwfoa2o/EeVmv+7/M4QTYm2Y246F3Ckj8eP1FSJPHMxRN7bQAzFiApPOMEemD+IpskLPIJUfawHQjKt9aqxQSQqtzAVVZnDOpXAxgLn8x/Ku18rWp4UYQlG63/UtruWMRt804BJjGSdvUfpn0q1lVuI7dLZWRgHHykscj8to9celRRAwZLkTOy4ZmXmlM8jIFZ2K9l7Vi4uRjKpG+iI929QzRBGI5WRMMvsaNqg/d/I4pemO34UVsYt9gHG0oI8AHcWLbvbHOKCDwSDyM47igHHT9KQALgDcSB1PU0ht3Woozk/Mxz2OMD6Yo6den8qTGeTg0vPUfrTJD5hu37CufkIJzj34xRR0I9DnPNHp2yKS7DeuohIVSWKqFGSScACg4CM5PyLjLD5hyQB09yPzpQSDkfyo3AHcxAOQMt7nA/Wh3BasMYznt1oH+eaOtJld+zd8xXcF9s4zTFYXv16UfpR1zwQOmT3o/E0AFJS/564o+tACUvTBIzg5x6+1H4UuM980mAmCBg88mg0dRwKKYB16d6Bn7wz6Udx+lGBkHuO/6UAHU96PxPT1pP5UuMDjNAC/NjK/MRjg4HHr70gzj5hkZPI4/TOfxpB9T+NKTn169fSlYd9LAMDoB+VHSj3/XNHWmIKQnCkgZIHAHel6UUABHpnp0zR9Ov8qPXryfypMADCjAoAXn3xQOe1FJx1wCKAFz+tH0pKX/AAoAMfhzSc+tL16H/CgewoAM+o+uaZIzxqJY4zIYznAPPtxjnBwfwpwGFHpxQQGVlIyGGKWjLhJRkmVYIi9xvkQmRSTJkEYP1I+b8M96tsNqlkhZ+mFTqef6daD8xy3J789/WkAHJAHPXgc03dl1KnO03se5/CsY8Dx4IP7+TkfWuzrjPhV/yIsX/XeT+ddnXnz+Jn1+D/3eHogoooqDqCiiigAooooAK5L4m/8AIi3XBPzJ0+tdbXJ/EzP/AAg11jrvT+dXD4kc+K/gT9GeAzOIVVgp+bhicgGnhmEe8FJF6fu5ufxAGRQ2T5bx4OCG47/nVaWF5ZNqo3yDIJxkDPc16KSeh8nTjGS97csOGBMoAWMKd+ZCTzkAZ29en/1s1KjeXFJOYQzJgqXB2lT3PtVRVuT5kb/dBAKsenQ/jV03Lh8x/u+MZXjNZzi9l+YTko2TGu2dgNtsVow29o/lY5PH14zj0xUe1T/Cv4CnEktk5J6Akc0n51UVZHO5XegAL2AztOA7HGe2cc9aAGK4baGVRnbnb+pNFBxuy27gYx2+tFtQu7WDkgfMyEEHjHPtyOlBz/8ArFHt296Bx04+lMkPmO0x7OG+dXJ5Xv0HWg47UDrzjPagHIH+7z9aNh7oKQEFioKlh1UMMil9PrQSdvzdPSgQcZYA8qxUggjBHUUd8Ubg33SCBkcdsf8A16RiqIzOQqqMk+lCHbWyFPAox260HtjLbumPSg9TzQITtzzS0Uc9x29e9ACUoo9u+aOvSgBR95cdB+vekHQfQUvRumT1pPagA9vT3oxnjnn0o6jj6UdRzgimAEnv2ox25/OkAxjHGBgUuPrQAfRsZ9s0Hfu5A4JwBgkjnBz0HrSdzyaXPTBpMadgOO459+aPTj8qM+n1wTR9KYg6mijt9OaKAAHO4YIxjBz1o9c8fU9aOvrwc0YGd3ft7Ug0Dnt+AzR39fqKKP8AIpiDpj2oo4Haj/CgA/yKMcdfzo+pox68n170DDn0zR17ZJ689aP4s96D0PGecfrSBFdlNyoWaSGKGPIw0gyDnn5eufepYdjRkomRubGTnjcaeeCxHG7ng96TavA2jg555/nT6G9Srzxsdh8MMnx1BlGTCuBux8wx1HtXnHxy/wCSza7/ANu//pPHXo/ww/5Hq2/65v8Ayrzj45f8lm13/t3/APSeOuKt8R9DlX8B+v8Akes/s6/8kp1b/sJTf+iIq8+ySR/gea9B/Z1/5JTq3/YSm/8AREVefe38zWlDqcucbw+f6EkT7JEMSGRlJYr1DY5A9ulGVMLNCjiMEsVkk+YZ54wMHFNwWZdnJyc5PXP/AOr9aPlAbHVSDyeMZ6GrcVe540ZNx5RD944I9jSds9h37ChWSU4XOQMENxg80H5fvcf1rRdjOzTswzzjOfTFH1oO7KkbcZO8EdscYo4pgwB59CetHJB7Ue2cUDn1/EUCFA3EAfSkO/a3loUcMQBN8mcHrg9qOqlSSoYYJ74oGRtRUfYqDDMcj6VLvcqNreYpBIG0DOcbc4x15zTQecE4OeA2AT/j9RSkZI7EHIP4YoJGMOMgnpjNUGlrA2FUMxCrnGT6kgAfmaM59/egO0bctkY+8eo/yKCMZz+NHqJgMk8ZzmnPG8ZCupUg8gjBz9KWMthlgwGcbVlLYC+pH4ZpsUHkec7kR7ztVVI4xxmoctS1D3W+olFH60VoZhRj0o/z9aOg9aQCBlLMocFkxuU9Rmlxlvbvilzz0GeM8daQdD9aB6dA+v4Glxz75xSA/wA6OgGPx96BAOg/zmj60D8qKYBRR/OigQfXrR7d+1FGaBhR060UUAIeP89u9Ljmge/TPX0oDIFwxIIODx0pDs3sHailIGRjkE4GKTsM/wD6qBCclTtYKSPlLDgHsaXnADEFsAEgYBPeg/mfpR6/yoAKOlHrj/8AXRTAKP8AJo/yaKQACMgjvxSDgDNL6Zo/D3/OgA9uR6VPYf8AIRt/XzVz+YqD/H1qex/5CNt/11X+YoHHdH0/RRRXmH3oUUUUAFFFFABRRRQAV4d8Vj/xXEmP+fePt7Gvca8O+K3HjiT/AK94+/1raj8R5Wbf7v8ANHGAqqknO7HGM9aY6SvKITHtAjaNGJ25UsWyQAf72O3anjlSO5GBzS4ClPMHXjr19K6WkfN06jhewN34AIbBG7P5HHNNPUj/APXQXVWKNkEk479+hPrSlCO3HHQ5A4qk9DOUWmJ3+8B68Udu4FHVGCkZ2nBPrSZOBuxuxzj1xTF0Fz6jpRzkfTrSUvXjnpTEH4nmlxtdAUchl3b9uEHJGCfXik6ds0fd8x0EkjuV3AHqQMA47cVLKjZgN+D5mwHnBU547UhyuNw2jHPPyj057fQ0p9xQPlHXgDGaYXXYAN33fmz0waRWVlGxgw9vajopaPgdSuMA/T0pzNvOc0C2QlMFwhVGVt6s3lhlBYZ64JHAxTd3mMeR5YPzAHkjvz2p7xefcQFpYl3NuDCQZA6BR9Bx+NJtJ6m8KSfxCjBVdpBXAwfWlpkWDFlSSrEkA9hk4p9UYSVpNCUvv2oooEIWVcb327jtGfX0+tKeeh55xjmgHjkDrkcdKO4pD0DoB+tGOPajpR1Oe+MA0xB9R2opPelNACUv40fyooAOnXgUe9FFAB04/KjvR70DqPrQAcYz2pO3P40o7YqNplWQxgMz7clQOnpQVGLk7Ik7/hRUYmLAkxlRnnJBxTwdwBHQjg+tAOLW4vf3+lADDdllZf4QBgj60dB7Uc/T3oJCij8PpRQAdqKKKAE45zj1pTySf5Uepo/l0oAD6/nzQff8KOe9H+TQB7l8Kv8AkRo8/wDPeT+ddnXGfCr/AJEWL/rvJ/Ouzrz6nxM+1wf+7w9EFFFFQdQUUUUAFFFFABXJfE3jwLdf76fzrra5L4m/8iLdf76fzq4fEjnxX8CfozwYdTn+oxSh8PN+5aS3aIoSDgqTznP1FIDz/ninbSdxH3cevT3rukl1PjacuR3Qihixdoygc4XL5PCgcjHseaQ9O3X1pSyhEZQf4sjrzxnA9f8AGhdsnzR888c4P5ULQJ3b5rCfXjPc0de+fcUdPY+mKOQ7ZKlCBjjnPeqIsH86M8HHp0opCeD16dqYhTz14HUYpcHY7BXfaM7UXJPsBSY/zigqGADlgFYMApxyOlS720HG19dgO/5Nqrswd4dsMOOBj/ChgeSPmGOq9QfTHelySTuRk5wN3f3pMc5HpgihD2eqEB3dxnHIzyPw7UpIVgCQGIyB3OKDhmA5DDowHIpVdgGRj6cjvxT1DQY8ioRu79NozmhH8w7UWRjjoI2P9Ka2BNHuIUc8mp8PJb7EQADLMGYDf6ce1KTSRcYxdrkIlVnwM5I4ypHFPpnlfZ0t4S3zYZiAeF7Yp/8AnrTunqiakVF6BRRR2/zxTIFxk8Z9OKarpIoaN1ZTkZB/ClB2sMdufpRkbeAAPQDFINLABz+HHFA/UUDtzSdVwRwetAbikcGgjk44oPce3AoNMAoo+lFABzR/OiigQf060UdeKPrQMPajvR2/CmyP5cZYg8enegaTbsO7Gg+3So/OyRiNuemT7UoY+ZtKc4znOR6UWY3CS3H9OfeghuNjqpzzuGcjuKO/vR9OaRK0DqeKPp+dHofSkAAAAGAOMelMBenvR3NGaMdKAEPAz2HPWlPGRx15oo6/yoAPX/HGaM/pR/XrRSA674Yf8j1bY6bH/lXnPxy/5LNrv/bv/wCk8dej/DD/AJHq2/65v/KvOPjl/wAlm13/ALd//SeOuSt8Z9PlP8B+p6z+zt/ySnVv+wlN/wCiIq8+/wA8CvQf2df+SU6t/wBhKb/0RFXn5yFOxcuOgI+97VVF7nPm6u4L1/QcOgJHC5BDHhj6D8MUokYM6xO2B0woKkHvkEn2puAp9ewz6enH0pHyzZYknoM+lauN2eImldBsiDAojKem3d9316/hSADexAIJ9e1Hfj86Oo4APt0q7E8ze4de9H4UHP8AdJPcKc4oI9Pzpk2Dp+VBHXI70fl2JPtR0NMA/wAaP1oo5oAPp60c4NHU4xyDRSAP4cYyO4Pfikyq4WR1BJ+UE8n+lL3pdxC/KcY7Y4I9KGNPow9snHcZoOTzuJwMcelIMbcjOR1FH4YFFkGqD1PJGep4x9fSjp1/KkIBGH+YcjB6Uv0xQLQPT+VH+c0Z+br+NA6D6d6ADOOpxRQOKMUwCj04o756e1FABz6Gj6fmaMeho9/5CgA+lH5UYB69z+dGPqfypAHUHB/Kgj14z7UMZDGfLRSSQOe1A37B5ihW77TQO2lw/CjGScCgdRnp9aBwu6VTgeh60AtRR2ztxnnmkOdwZHV1AwYjklunAJ/xojaSTLkAIOwAwD/PNOV2G3axHHr+nNS7l/A7MashdtqopQ8jaCcdqOT0XjPrz+VODhUKxqEVjlgO/wCNMxnkgZxjNNEOzegv4UY6d/ejuMdMdO+c0gOVyO44zxTEL+tFFHXPp9etMAo/z1o/kKPf3oAOM4H5UUemDQfwxigA6VYsP+Qlb8jHnL/MVX/Gp7D/AJCFtx/y1Xn/AIFSY47n0/RRRXmH3oUUUUAFFFFABRRRQAV4d8Vv+R4k7/uI+2e1e414f8VR/wAVy5IyPs8f4cGtqPxHlZrrh/mjjADggBskcEHGP8ilZ1TG1yCTsLRhScY64J6EjH40zaSDuH0PTcPWnMxZSB937xHYnoP6V0tXPmY2iwlCyuTOG3nqwyuR6Y/rTWAO3KsOQRznsf8APNHbv1o9fXHpVJWJ5nsKTz7dsCk/WgcdgOePmoHK5KkZ7NxTJtYP0o6kZH6Ucjrz9aTHGP8AIpgAx2oH8u1L1xSUALx0o/zijOOvfiigA/iz3oPBLMQq4O4k8fX9KSlB5oBOxGsMBUMgUq3OQeDThGnHAHIPQdjkfyqNLgtzMMA8Bv0596lznpgn1NDT6ms+eL1YvXA+Yt70EH/d9z/nigj0Jxjn3o4HKgAn07+9IzD1xxRSdBzS/jTEFJ16Yo/Gl7igA/SjtzSf5zS0AHP/AOqk/P6Up6/0o/pQAUcj0o6470D2P5UAH40AHHfj1FKucgAZ9M01POJJkjQDtz0NIdtA/X3pe445z0o/OgAk4AyD156UCEJ2gsdowCeaqsk8cCy2bR+a4BdXY/Nz+XSgfv1AJyccggcHvj6UtobmOMg7Sm4lcsQcds1drI7Yx9lG9yupvJEeRbsI6/eTy14OOccHj3rQi5jjwuAQDzxTViUzGWZRJIcEE8jv26E89T7VIfmyG5B60m7mdapGVkl+Fv8AhxOnUc+1L9PypOu7BAPr2/KlJyx4xikcwUlFL6fXrQAUfp9TSdOlLjnFACHA5bijtSj7v4Uc/wD66AE9f60v5UUdz3/GgD3L4Vf8iLF/13k/nXZ1xnwq/wCRGi/67yfzrs68+fxM+1wf+7w9EFFFFQdQUUUUAFFFFABXJfE3/kRbr/fT+ddbXJfEwZ8C3X++n86uHxI58V/An6M8HGfQ/kRTwFJ+chQ3A3n7o9e2KYecbV4P3hjpxnP17UqnZ937w5znnNdr12Pi7WFEhlh/eB3Rjl43XGD/AHQV9OPc4pqqin5AzZ5JLUYw3J+p/wA/jSZ49vzojFJaDlJt6CIAsYCcD360vX1NBB7AHtnOOMUdW4BI9e1WS7t3CijB69Ofzo+uB/WgQY6euKO/pQO9H0FMA4HWigZOMUA5we1AAeVwentQwLLj8uelA96SgFoNZY5ZNpYGRQCVDcjNJ5Cnq7/99UsksgZlUBhtDEH1z2oLOozhSMeppq5r71lZipEqEt8xznnryacAeOM/1pFJZATwSOAKMA9Rk9QT2pO5Dbb94X6889qKO/4UevNIkP8AOKPyo5zQOmKYBRR6UAf/AKvSgA+gGaPrkUdiPrR/nmgA+v68UYNA4pMdO3HHNAC/UijrjGfwo78ZNI5mOzy41Ix1pDSuxSOo7jtR+H/1qU5B5GPYdKTnqOvbmgQfw9OMd6glQNI2QrEIDjdjv/OnSbVkzIm5to2gtwOevFRCGSGVJEUkOflJPXr+lXE6qcbe9fUifeGYhcAMCvQ4B9TU8DStMRMv3EwBjoKWRXd8lSOm4bzyM1Ksax/czgcAEk03JWsOpVi426juccgYx2NB/L3pMDPpnrSk4685PAA6cD+uazOQOnXtR/OiimAD9aP1o64zx/Sj1JoAAPy+tIMHp270uOfrRn5qQB9aPrijnvijt170wOv+F/8AyPNt/wBc3/lXnHxy/wCSza7/ANu//pPHXo/ww/5Hq24x+7f+VecfHL/ks2u/9u//AKTx1x1vjPp8p/gP1PWf2df+SU6t2/4mU3/oiKuA6nIw4PC+9d/+zr/ySrVv+wlN/wCiIq8+4Off3606PU5s43h8/wBAIwOF3HPrQy5Pcc8e1H0orqPCuHzZIOCckjHajI79DQeRg9M0dOv60CFQbpADkZxx3B5z/SmrIVALHPAxk4pwJ4I/lSY2ofnKrg55IwKXqUmAJ25Jydx/EdjRz2B/GjcHXg5BAwR3FHI6H9KYm9Qoo47cZpQrEZxxnrigkSijt9aVtsYXzCckZIAzge9F7DSb2G9aUED5idoHUngfmaUgq5XqR19u9IRuXaxJBxkf3vY0r3Wg1a+ooUiYBRvL87V5zSY+UH1HGOlLIA6KmNo+98vfHalRWW0ldWTamPU8+mM0nKyuylHmWg0Y3Dnjr1pAx3LlcqR8xHRT9alfa0avGjLuLDB56fT60zOQCQV9gaE7q4muV6iD25z6d6NvoBnPOc9KDyrAkgMpUkHBAIxx70nGAAMADAzzVCF5HWgDrjBo6dKCBxkDuaBB36Unv60vb73tzQc9x+VMAxn3z2oJ4yT+dH50A+5/GgAJXHO0jOc5BxR9MCjmikAH7pGD/wDX7UrcMSfrmkGdp2H5sfLzxntn2zQowijsB0FA+lxMZBHIHqDyad39aT0zRQIUtu6flSZyPXNA4x60dvw5FAAfwo70cemP60DOMHr3pgH+PrR9aMA9ee4zR+H0oAP88CjvxjFH4/pR3weDSAD0xQaAMdKP6GmAY+uQaMg5weO1HTk5+g70pznrk4A/TmkPoJ6ZHPX8KnsP+QhbZ/56pj8xUA4xjp161PYf8hG3/wCuy/zFAR3R9P0UUV5h96FFFFABRRRQAUUUUAFeIfFXB8cOAQT5CEj04xzXt9eHfFbB8cSD0t4+/TitqPxHlZr/ALv8zjMDOcYB/wA5pACVGV2nJzjmg4znOCefWiuw+VuJyqgggr6HrS9/xyKM4oxjp+OO9MbdwznpwM9T0PqOtV+ZZ5QXby42A2ZwCduck/j+lWM56fyqMowkLxEZIwQSRn3oWhcJWbEQBJwFbClTlc5wR3zUv0Bzj9e1MUfvGLvvkGM8/dp+OevNAVJXeofXij/Gj69fpSE4PUdM80GYv16UU2ORZFyjAj2pHfbkDG7GQCevIH9aClGTly9R1L9KiimLNtkXa/oDUwyCCePah6BKLi7MgIUXJ+Ycrk8jgj2piXUCXRt2njV2AKoWG4HpjH+etPuUXyCcHO4FnzhjzySR1pkyRxQhEZB5hWNdxPJZgAePqB9DTuranVCMJ6a66Fg9M0MSEbaMkDIxyT+FVp5JLVfLMplw+wyMozj8KkBkiuFXczBz0I+7gZyPypWurmTpOOr/AKsTEgnOADgZXPQ96UAblLg7cjP0pPbmk4BY8kt1ycj8PSl5GOgANtG7buxyBnH50vcdM0Y5zQeQc4OAaYt2GMdaOtGB0U49hRz7EevSgBP89aXp7Ug/Glzz1NACA+4z3GaBjGFC/hS5PY/rRQAd+OvajHy/7PvQMdPz5oAYOxzjPTucf0pD6B34GT069KMY9+e9H0pOn5UxCeXGW3FADnkmnZ5680f4Udc9Pagbbe4UZ70cZ6c0nOT06frQLcX0x/Oj+tHv+dGMDgYHtQAn8qXt7/Sjnvx7UmSOT09RQAvTk/pQB+dGOf60fWgAHTnoaPQd6THGD+NO6g9h3+lIaEz1PbqcUAY4/OjvnvijuPypiPcvhV/yIsX/AF3k/nXZ1xnwq/5EWL/rvJ/Ouzrz6nxM+1wf+7w9EFFFFQdQUUUUAFFFFABXJ/EshfA10WbGGX8ea6yuS+Jpx4Fu/wDeX+dVD4kc+K/gT9GeDkcYIGQOT6dqTHzABMjHPPSjAx7A5+lHFeifE3E2ndkHBx3HFKM455I6470en6+9HXryR0oHe4dMDBJ7AHk+vWmSgsoAfBLYyOOKeeP/AK9MmVmUYGcEHrimtyoOzQ0xr5e0sQf72/2+tPjOYl5ydv60xpJVUbxhdwA+fgselPjUiJVbqOopvYubfLqO79Djtmjv1o6deR9KRmCqSSAPekY77C0UzzUz94cYpzHapPXAoHZi/WjNV/tLdfL+XswPBqwp3KGXoehptNblSpyhuMUgXW0sAWTABIGeaRpERHj3LnBxk9KV4Y5HDupZlHHPT3+tRfZonZ2JwQxGSx/OhWe5rH2btcliZTGuGBwBnFPHHocHGM1WhIWU4fCluVT057npzinKHYFt8gGemB0oa1CdKzbvoT7uXDDaARtc8A560AZGAPwFMhYmMEsc+/408jKjO7g5wGxmps0YySUrBg54wBjnOSc5/ljFHrmg8/8A6qO2PagkBnHHIo6UYG48AH2o57HP1pgHT/8AXR+tHPp+XNB/GgAJA6kfiaOMjIXOMUZ44P60GkAYpRyRjOe1N470rKSox685PagFqH1/H3oxkgnI5PAP86D9cmg0ANaNGYMVJPscZpBGqsG3E4J70/scUHg8U7srmla1w/pR3xQfzHbijtheCOgoJDqD9KOvP48UZpMD6kcZPWkAvWijkn+ZNHPY0wD2o6mjqD/WjHHt6UgDuKOBz09aPcUo4Pfr+XShgtxOwx19KO/uBz9ev9aDyCD074NH/wCqgDr/AIYf8j1bf9c3/lXnHxy/5LNrv/bv/wCk8dej/C//AJHm2/65v/KvOPjl/wAlm13/ALd//SeOuSt8Z9PlP8B+p6z+zt/ySnVv+wlN/wCiIq8+HOMZ+vrXoP7O3/JKdW/7CU3/AKIirz7AwQRxV0OpzZxvD5/oGf0pCwB2k/MF3bTxketL9MUZ+Xtiug8JW6gcjvR39fej8QecUfrQIPejv2I7gjg0cdaTI2nnigFcU89fy6Ucg+vtR/SkAx0/OgBeuOV5/T/OabKrGQ54JPybWyB7cU7vz1pd2Uw6K6g5+ZQSMe+PSk7p3RcGluOYASEBlx0LY4+tM2lvKN0FLAZb5sZweOPSgA7QGJJHXOKOR04+lLlCMnHRCsQzFtoG45JB60lHXp/+qg5yTnIOMLtGF49epqttCABxxwanHKMETII5GAAOPf8A/XUHX2/ClGCenJ7YqJRuVGTiwTb5Oza20AKAOT17/pScZ4/+vSkgjJGQRnGPwP06frSdcA/N6ZqkEtWH+c0fhQPy+tFUSHegdunSgfXpQOn4UAH+I/nR9OvajoCfp/OigA/DHvR+uKB2ozwO1ABj2o5HvRR/P27UAB7j8PpRRnP0ooAP88UHvR9Rj6c0flnvQAfpR7jpRR/P60AHSjr/AEo74xRz2wT78UABzjmgjHQEUAflSDIB6575pALn86CMqR17/Sj1owN3OaAA0Y9PSgHHXnBx70YypxyOn0NABnKjjHqD1FHPfGeh59ODTjjIHTPO4DjpQ2RnOVwoYscc+wpXKtfYb0GeBz36VPY86lbYyAJlHTryKhzvQtgqueeOTU1kc6jbcf8ALVf5ijcErSR9P0UUV5p94FFFFABRRRQAUUUUAFeHfFYj/hOZB1/0eM/Tg17jXh3xW/5HiTjrBH/KtqPxHlZt/u/zRxfTGf5UhZVUsx2qBycE4pcDnFAOD29Oldp8srX1Dn5ugxx1pP1pe/JFH+HSgQdaDkg44Pajt/jSZGevOKAHE9eAPU460mMDj9aT6evrS98nn+lAAD64H9aruhaf95tIwAqg/e5547n2HtVg+9HUYKqwx0YAj8jRdrY0py5XchgGJZSDlcjaetOnilk3MroAo3KTwAcYIJ6+pp6oqHEaLGnQKigDP0ApRxg9KTu9Svacs+ZDEjCYDKjFc4K07HFL7HNHPy4bbhsnCg7hg/Lz05o2M3Jyd2w/zzVVrKGe8iSQMyL85XPQ9Bj06np3Aq19P1pkkXmY+ZkZTkOuMj25Bpl0ajpyunYqzWAjkLySzF9ysdzg4+mOM1bEcaMWVWBPdzz+dIIiFVXkLBTuyVGTz39fyp/rjjnkCi7Lq1ZSSVwwfQ0UnAHTH8qWg5wpP/rfzpf0zR/9agA6miij/E0CDv0yO3NHr79qKKBhR9KKKADP/wBb3pP0pen+FJ/OgBfaik59M/jS9aAD8KPofzpKKAFPY+lGf/r0dO3H1o78/kaADBHTpRjjOOenFIB64z7UY+Yfl+NAC5oH+RR6c9+aQjK459+KAFwBke9J24HWlPBGO4o69OvUD1oHqH8ePXkHt1oHTnG3rxSjjJxkBs4284peiArlxwAB2qbjtfYbg55Az3xSZ/En07U4EmQxp87AnDcEUnHOMn1Jppg1bc9y+FX/ACIsXJP7+Tk/WuzrjPhV/wAiLF/13k/nXZ1wVPiZ9ng/93h6IKKKKg6gooooAKKKKACuS+Jpx4FuucfOn8662uS+Jv8AyIt1/vp/Orh8SOfFfwJ+jPBsegx/n/69HXpRgHqPzoNeifEiBg2dhyQ21u2D+NL35PFKTnrj/P8A+qkpIenQAf8AIo6UUnAznApiFHfOCM5GRnHuKOp9TRxxz34o69eM0gDJGen1pk2do2leven/AEpCAykEbvY0youzuQSx7VP94Hk5zkZ656HpU8gdoiIiA2c8jr7UjRoybRFGD2YIAR+ntTuD+NF21qaSmtGiLyym75It2woBvJAyMZ+tSBQAABtA7ClyffHTApVIDAkZHv3pdCZ1JT3E/SoJYgI3IZu5wDUwyqgMxkYDltoGfwFDqWQr68dKadhRfLLchWxEVqSNzBiPmIGR14HOabFCwZsu2M5G3kVMqyIudyHaCf8AV/8A16VY9jNuOWJxuAxT5nrdm8qzad3cI02LgHOO+ad09qQ8k55I796X6YpHK7t3D8KTtxzS/WjP40AH5UelFHpQAfT155o6+ooooAOvpRj8KKKBAM0daP8AP1o780DCik57DPpS/wCRQAelH6UfyooAPryKOnB7UD2H60A8emOpoAPp1FGMnB5o+vIxzRg44/SkAfmPrR6dqB29DQD05z1pgGPun3xmj/8AX1oxwcZ3daMg89uvFIAJwCcZ9h1NHOQRjoT1pVHzLnGM9SMihRn5RlWAxgjGeaTY0IenGD/jR068DH40rNsG4gjkgJxk+9BGNpbgEfKAPbufqDRcfK+p13wv/wCR6tjz/q34/CvOPjl/yWbXf+3f/wBJ469H+GH/ACPVt/1zf+VecfHL/ks2u/8Abv8A+k8dctb4z6XKv4D9T1n9nbP/AAqnV8df7Smx/wB+Iq89AYAByCwGCV6E16F+zr/ySnVv+wlN/wCiIq8+69fTpVUOpzZx9hev6B3+tKVYYJHH4HNB+T5jgbTg+3tSbIwxMUaoWOWIJO4/Uk10X1PCsragaP8APWj+vU0Y9aokPXj8c9aM0Y4oII6j86QxSDlsqAvGxtwJb14/KkJwMnj2HJo/zmjpxQO6uHTgUdMdvej/ACKBwaCQ3LGEZycE4yoyPx/KlI2kqO1IVVh831/L2/L8qCc84Ue1LqW7W0D0xjvn39P60Yo9ePzo7+v04pkh3A7d/wDCj/J5xR0GAT+NH0oAOg452nP4Gjpx27Uenp349aPTPPFABRijt1opgH6fhR2FGcdKTGOnGKAF/wAR/OiijvQAUevHf1ooxnHJGDn60AFH+FHXrRQAUUUUAGcY689ODRx6d6KKADjpzR+OaB9aPwoAOlGPbNH+etH1HT1oAMHPGQSaO/qRjJHak4A7daXOOBz7DjFIYcMvLY9Qc5NIrrIcMkm5skARkg9zjFLtUsu9iQP4upqRJDFGVQkPJw7r1x3HsKl7aFrl6jGHl/M6TKTzgIeR64IpU3yq37ogqNzNnr+Hr9KQqrMG3lSOCNoYGlKqqbIQqDAyzZJY49v8KX5jUo2FZRHGrjlSMZySCe/POMDtSBVMYDnMfzbWzycdOD/P604KwYbvuP8AeIfcAe3y96QOBKqCGNVb/WSbScHHUE5x+HFRd9DRJNgTuA8vHTB+bJ/SpbFG/tC2OD/rl5x71FJ5cjHCAMv3gwznPcGnWEcX9pWxEQX94mdrED73pWkdjFJcx9Q0UUV5x92FFFFABRRRQAUUUUAFeG/FUMPHUpZl2mCLaAORwcn/AD6V7lXh3xW/5HiQf9O8f8jW1H4jys1f+z/NHF4/yaUKxHyjPHrQFz+Jx9aQiKQKXjV2QkKxJ+X14zj8a7G+x8skuof5NJ9f0pfrzjpRimIPwzz60ZoHWjBx0OKADDHG1Q3OGy2No9aPp+BNH+cUe/WkMQEEZGeuMkUvrmjrRTEAG45zkAc45NAZXQOh+9xyMYx2/Pml+vOPekwFG0AYA6+pqepV1YPyz2zRjP8AKj8O9H14qiQ/zij8fxo6Hv8AnRQAcbsnHJwec0c8eo4NHX0/Kjrz+fFA9wpKWk/HNAhenb8qOvv+FFHXt+NAB1pO1KKP8aAEpfw/X6f/AF6P88UD/PtQAUf0IpAMKBktgDk0v0oAOg47UUnal78UAFGeAevfkUfpR3oATAA9O3FL360fjzSHPP0oAUc/4Unal9eOKOf8mgAx7Y57dqMYxk8E8CkAGR0GKAQOePfHegYhlWPAkYrnoG/lx3qIzycnyyqgZJ2liB9B0p8kXmEMrbXxgA8j3zRGWDjcgKqMgtjH5A0aWubw5LX+/wDr/hyOa4NsF86NjuPyhQyk/TI5pytc453bs4+ZcbT/AIUs0TTsJXkZpidxkkPzMcdPb+XtUckErr83lv2ZcY3Dp1GPWhWtruap0rK1vmOgufNRXaJ49+ApJ6Z7gdSPfFWVbLEpjgHIJIAA9/6VWV8xCKaHHHABwo68VCyLPgwecI1PzA55Pcep575pNJsr2cZPay+80AI1BSPnIGMsOvfp+FN2uT0P0AzVSG8Y2bSSQqY92EbOdo/iGMeucVYMcZ6xLn+8CQaSTW5zVKfJL3j3T4VDHgaL/rvJ/Ouzri/hSAPAsW0YHnyd8967SuGfxM+vwn+7w9EFFFFQdQUUUUAFFFFABXI/E4O3gW52FVO9CSwzxmuurkvib/yIt1/vp/Oqh8SOfFaUJ+jPBu1AHYf4UAZOBzk0oKjhsMrjGMkBh9RivRbPiUgKsrcgj0pO9IFVFAiRY0xgKo6UoHYD8BQDtfQP88mgdOmOfXNFGD2zQAq8sATjtSDdtG9ArnqoYHFB49qKA0sBxuCnvyAB/Oj+VGcjFFAB6jOD/WlG3f5TZ3EZPy8GgHFIQo+YDJAwMn9aTHFoOvvR+AxR34xjPajn6UxBijPP8vejGQevPocUZz3oAODgHp169/8AOaPTPTGD+FGaP5Y44oDyDnvRRR+NMAoz/nFFFABRj0oo7igAo/Cj8aPzoAKKO+dx6AY7CikADAo+tFH1pgFGecd8Z6UelFAgwM9B0o9cE0fWjtQMOe1FH+c0fQfXmgAHPbmgA/w8Y9aTjv8ArRxwODQAjttjZlzwM8DrTS8gTd+7PsCTTpMvEyg84POaaD8pOxlYgYwByPzo6am0bWuETSyEgQuHXjGxv6CmQvJ5bf63dnjC/KM846VYNw3lCKOJwi8lQRhj6mqkEbJnchKMc7QV/HmnG7TujZclnt0HpJKzIrI5DDG4kAdevbA+tPkldCVNvIoblct0XqPrnrmmQS/vlJCRqvGM4J59adI482KJm+VTyRJkdOfpzSa97VFOKv8ACSpIki+ZKCrrxgkDjPPWnNksdoG09MHNVIG2znbD8u/hd7LkckipEdZnfdCnGBtNLlaZlVpWeh2vwwVh45tsgj92/UY7V5v8cv8Aks2u/wDbv/6Tx16L8Lo0Xx3bFU2/I+PmJ7V518cv+Sza7/27/wDpPHXJW+I9/Krewdu56z+zt/ySnVv+wlN/6Iirz4cHtXoP7O3/ACSnVv8AsJTf+iIq8+HJ4/A1VDqcucbw+f6C5YM+WDBjkf5/z2pOD1wcHigfjg80AZz9MjiujRI8J3bAUHBDbSwLtuJPPP0PSkB3KDhlJAOGHIpeT0/WnZMLtaAMCVZMtkKVC54PPp60iqEXau4jJOSc8nrS4xRjuf50WQcztYKOtH/6/wBaOuRQIPrxRR1pCcDJpgL2HbPTPr/kUq4Dc9KT64/KnHHODjpjp+NS+wxoGFUFixAwSe9Haj6/TNHfoeQST2p7Bu7h3oo+tFMkO3NBPGc45o/EjgjjqOOtHqM556+v5Uhgeh+mKKDwaO+MHpnNABRR1wR+FH9aYAe9Hc0Uf0oAO9Hpmj/Gj/PSgAoo7H6UUCD/ABooooATtS984oooGHXrzRR/nrRj8T2oAKO/vR16fWjp06dscUAGeM0e+eego6dOOKP5dvpSAOCemR70DkDd16kjvR/nijqPagA6cnrRnt60dP6UfrjvQAqkDA7bh3p28mLbuOBzg8jB60zuD/dyf0pRwR7CpaTHdoFbMeAMORznuKmsP+Qjbf8AXVf5ioMfLg43L90+tT2J/wCJjb5BH75R9OR1plfaPp+iiivNPuwooooAKKKKACiiigArw74rf8jzJ/1wj/ka9xrw74rf8jzJjr5Eea2o/EeTm3+7/NHGEnC4YDb1FITk9uaD1/CiuxJHy7b0EGMYGMCnZB2bs5Qkrg46gA/XpSdCRhsY644NH0/lRow1ixGXerKWbBOdy8EUrYZw/wA2du0YPbr0oI9aOTmiyDmYUUf59aP6nA/z+FMQe2OKDRR+tABR1wRgj1/CgHOfrjpTlxtHbkZ6fdAJP8gPxpN2VxpdBPX5mwQBtxwD60lJ+oo7EgFsAkAdTRsG4tFB4J70f5zTEFA60fpR3zk89uOOn+fxoAQdOuaX1oI/nR24yeQOPrQAUUe1H9KACj/Gk+tL3oAPrR3pP5UtACDpxSiiigA9Paj60UlABR160tFAB9KPYUUCgAo6cnpSDgY6Clxg0AHPc84o696KOx5z2P5UAGc+uT0+lA+gx2GOlH1ooAMduoHr3o9TSYwP6Up9Dz7UAAPzA9SaYYVdSUeSIsCCUfHWn+tB4H0H8qRUZSi7ohWJh8k23ywMlUXAJqY9eetKfvcgFSNp9vSkAxwBkdqLjlJz1Z7l8Kv+RGi/67yfzrs64z4VHPgWLH/PeT+ddnXBU+Jn2WD/AN3h6IKKKKg6gooooAKKKKACuS+Jv/Ii3X++n8662uS+JuP+EFus/wB9P51cPiRz4r+BP0Z4OpxnnbkEZxyKQEhcMQcUfwnPHrR/+rmvQtqfFXdg4znjPrSg7c+mCD/KkJwpOCxBxhRz1/yaD/nijR6BqtQAAVApIVBjB5yOMc0hRSsiksRJ1+bp9KXBP0o+lFkHM73A8+v40UEY60Y5wPpQIP50UnUZ/EdqWmAdu5o74yM+maM8gdCc4/ClXG8bunfjtSATG5CNxRiB8y9uR/ShjliexOcelKfujpnqR168460n+cUl3G9NAoo9eCMevfiimIKDR/KjsQGI9xigA/i69qP8aOuP5UUAFFH4Eckc0d/50wCj0o+lHX3oAP0+tH0o+nXFH6UAH+cUUf56UUAFHaijFAg+lFFFAAOPaj6jmiigYUUh9cduTS4znNAB2/nRnmj60fjSABx3+tJ2yB24J64peaOKADHpx2o6f1oxn2o9e1AB1yDSMquybiRtBwVPrxS/hijufwH6/wD66BptPQikSXeJFkLY6BuTmnKuGdvlGTyBnin4yCo4z60few+3a38QB/P9aL6GjnKSszr/AIYf8j1bf9c3/lXnHxy/5LNrv/bv/wCk8dej/DD/AJHq2z18t/x4rzj45f8AJZtd/wC3f/0njrkrfGfRZT/Afqes/s7f8kp1b/sJTf8AoiKvPj9046gcda9B/Z1/5JTq3/YSm/8AREVefZ+cqCc/SqodTmzjeHz/AEA98856n3o+lHvij8eK6TwQPvQcFWU9GXB4o6Z/rR36/QUbgnZ3QE5OfX2owCxIBy2Acn+lHpR+nPpRYLsAQzOyuSG2jb2XA7fXNFHXr+tFCVgbuHSjp7UUUxBRRRQAfWij6UdvvM3JPIAx7cCkMPUEY/rRR/nNH50wDH4E8UpGFOQeSR8tAycBGZG3Kdw54HUfjTcHDKifxYXJ4xU31Lik+o4qV6/r2pKdIFDYXkDjPPPvTTgHBIz6UJ6EbhRRRj8qoAooo+goAKKP849aPxoAPrQOg9cc0dOlFAB39sdMd6KPWj9KAD0o6e1H0o/z1oEFFH+elHrgAZJJ4pDD1+tH44o9PXtQPbn070AHPUY69KMYFHvwaOnSmAc0duaMZooEIRlSBwccH0NOPPIHXtSe/XFIVG4ZAI65P971/WkP1Fx1x6UH+R5o/wADzmjHFAATjBJx2NT2P/IStiP+eq59xkVBng4/CrFj/wAhK29PNX+YoHHdH09RRRXmH3oUUUUAFFFFABRRRQAV4d8VsDxzIf8Ap3jz+Rr3GvDviudvjaQ5P+oj6DPatqPxHlZr/u/zRxZyGI7A8Cig5780n0OK7UfKi9uaKP1oz7455xQAEglj/eO48e2KOCBnPBDDBxyP/wBdFFKytYfM73AkYUbmQ7t3y9x6fSj/ADxRnjHaiiwr9AooopgH1/nRRR3/AAoAKPeijuDuPAI2gDDe/TNAIPw/HPSk+nejp059qX3GaADtzTXO3tuJBIA64xT1wGGRkZ9etQQHCq0rs8nIkZjjb7UjSEU02OR2ZvnRoy3IDHINSfT+dVkuI5JdxbAycNzg/j0qz2ycAEgZzTHVi1JKwUUn6/Sl+mP50GQdBR244oxR1oAKKOvqKKACj1o+nNFAB+PP0oo+n6UfhQAUdxSZ4yOaXvQAn60tHbNB6juR04oAPSjp/wDXo+v6Ucd/8igAHsffOaMeuKQ+/wCVL37UAH0o7+lH15ooEH60eo7dRRRyVOPvDpmgYH/PvR/FyaTChcIPlUfKPSl7mgBByuMnpj8qM7h1/wDrGl/x/Kj1oA9y+FX/ACI0Wevnyfzrs64z4Vf8iLF/13k/nXZ158/iZ9rg/wDd4eiCiiioOoKKKKACiiigArkvib/yIt1n++n8662uT+Jn/IjXX+8v86uHxI58V/An6M8F5wCvB3Y78cZo/wAihWznGeD3GKOnt9K9A+KfYKO9H1o9KZIZyF/2W3Dj2I/qaAdpz6Gj8cnvR60rIeoJtjxgHYvPzNn360Lwo+dn5Jy3XrR0PGRRRYbbYelFFFMkP0ooo7GgYfSjrxRR2OCRkYyACR788UgW4fzxR168H+VB57njoeKPrQAUxmw21V3HGSM0/wDWmSSIjDfn7pyBzup9S4K7sIWk4XyTkYPDcU5G3oD601Zkdo92VXqxOeMDjp36frSW7h41VeSB0p27o0nG0b2JaKTIPQj8KX0pGFgoox680f56UCD9aKP85o9eaBhR/jRRQAUfrzxx2oooAKKKKACjvRR6/wCHXigAHvQMkDPWkxxjoMcYpT17+/NAAOvbjtmjnAyR0/Kj1/nR2PTnrSAKOaP5UUxBR05H4/Sij+RoGLjn1pB068cfjSAAMTgA9Ae+KXHUYxyKQbB/hRnDHnryM+tHpQOg+tAHX/DD/kerfHTy349OK84+OX/JZtd/7d//AEnjr0f4Yf8AI9W2f+eb/wAq84+OX/JZtd/7d/8A0njrkrfGfT5T/Afqes/s7f8AJKdW/wCwlN/6Iirz8YMPmkhFXqc8A/XvmvQP2dv+SU6t/wBhKb/0RFXnyKixsuxcE8jHAOPbvTo9THNuX3L+f6AeuKBS9RkkAZCjJxknoPrSdq6j56zD/Joo55xR+NMQUdMCj9M0fTigYCjse/H50fn27ZxRSAKKKOik7WbH8Kjk/SjYFroFHb3pBkqCylGI5U9qWmGwen45460UduaPrSAKSlo+tMBQcc9ORj1pORgA/TA74o6kZ7c/SjPGaQB+vPpQCQMDpR1PbPv3oB4B5BPY0AHXpSEZKkEjHb1penrRwCNxxk8ds0DV+gdxj3ooxhmJbcSSQMAAew/xoxxwKEJ7h9aAclgM5B54xRRQAUUUetMAo7UAfN9TQAfSkIKKPXHp1o/n/KmMPqf0oA/+uKUfe+8frimopDFn4GDwOc0gsO746HHSk7DHSj5d+4AB8Y3A9vSj6c/SgAz6nij696OaPpQAdfXj9aKKKYB9aOPzo/l70fT65pCDr/Wij07UUxhnH4VPYDGoW3vKn8xUB6cHBzgZ6c1YsuNStxg/61OSOvNIcd0fT1FFFeYfehRRRQAUUUUAFFFFABXh/wAUvn8eSR4+Y28W0jnOc8Y/z0r3CvDvimoHj5pNo3LBHg456H8f/wBda0tzzM0t9X17nF8c4YNg4ODnB9KKUDc21FC5PRRikBBAIIIYcEHOa7Uz5R91sHWij9KPXNMQUepoo7frmgBPp/Klo9M0g5x1HsRigBf859aKKKAD60UZO5gY2UDgMf4qP8aE7g01uJ9KWj60UAH04o/nRR1oEA7Y/WoEjWR3Z8M4fbyO3ap+3FMeKNyNyA4HBx0pmkJctyN5FeMxRfPxgYHAFTINqjHpigBVXaAABxgdqO/P5jvQEpJqyFz69aMcEZIOODjoexo980D19B19KRC30EAwuOuB17ml/niggMFKycDPTHzenPp1oOCTwPypXGw6UhIUrnPOQMD8aWjJximJW6ge4NH50UelAgopKCQOpA980DFopMg9Dml+tAB+n4Uf/qBo6dT+Gaa6M+ADxjBPTFA0rscRgEngepo/nRIEckMoZTjIPHNGc980kLoGfftR+NHY/wBaP5imAf1NH+eaO9A9qAAe1HU0f5+lH059hQAnT8aXGOtHr0NH+c0AH6UdTRj60dV3A7gx6gdKQHuXwq/5EWL/AK7yfzrs64z4Vf8AIjRf9d5P512dcFT4mfa4P/d4eiCiiioOoKKKKACiiigArkfic23wLdHAb504Jxnmuurkficu7wLdAgEF06/Wrh8SMMT/AAZX7M8JdQu1t4Al+5n+LGe1NpflEaAKvygbTjkdentyaCPUjJGcZruWm58VKzfuie1FHcUenPFWSFHX8aOlH/66AD19qKKO/f64pAH4Zyccf59qKKKYBRSMSqjZG0hOeF7d+aU9eD3pXHZpXCj8f0oopiDp2o+tFFAg/Oo5IxJLEGxznP0qSmvGrnLckdCCRQmXCVncasKccdOv06UiKBIQBxtGKXyU9W5/2z/jSrGsfKDr15yf1p3Lcrp6j8k9aKPpR+dSYibfmJzkH+E9qXufwpRwzLkBtpAB5wcHBx7HmkwAoGS/uepoKe12GP8ACjr+vvR/nij6ZoJANuUMM4PqMUfnRR3pj9A7UUDqKQEcDI4HrQAv40dKTI9f16Uo5HHqaACj2/pR+PHrR1U4J6dD3pAGOOOf6Ucc89OvPQ0KuxDv6k5x6UDaCduF3Hc2D1PrQPQCcZo+po/zxR9aBBjJ96Bzg8/Q0H86OppgFH1o/lR9e9IQY447dKPcdKOcf55o7n+VAwoPSijGWADc9cdf8/8A1qAOv+GH/I9Ww/6Zv/KvOPjl/wAlm13/ALd//SeOvR/hgf8Aiurbgj92/B+lecfHL/ks2u/9u/8A6Tx1yVviPp8p/gP1PWv2dFL/AAs1VVGWbU5gB6nyIqwF+H3ikLj+x5R3++n/AMVXKfDXxt488N+G7iz8HeGf7WsXu2lkn+wTz7ZCiArujYAcKpx15966/wD4Wv8AGH/oQv8AyjXf/wAXUQm4bHVicJDE25m1bsNHgDxUOmjyev30/wAfek/4V94p/wCgPL/32n+NP/4Wv8Yf+hC/8o13/wDF0f8AC1/jD/0IX/lGu/8A4ur9tLscn9k0f5n+H+Qz/hXvinH/ACB5Oevzp/jSf8K+8U5P/Enl/wC+0/xqT/ha/wAYf+hC/wDKNd//ABdH/C1/jD/0IX/lGu//AIuj28hf2RR/mf4f5DP+Fe+KT/zCJf8AvtP8aP8AhX3in/oDzf8Afaf/ABVP/wCFr/GH/oQv/KNd/wDxdH/C1/jD/wBCF/5Rrv8A+Lo9vIP7Io/zP8P8hn/CvvFP/QHl/wC+0/xo/wCFe+Kf+gPL/wB9p/jT/wDha/xh/wChC/8AKNd//F0f8LX+MP8A0IX/AJRrv/4uj28g/sij/M/w/wAhn/CvvFP/AEB5f++0/wAaP+FfeKv+gRL/AN/E/wAaf/wtf4w/9CF/5Rrv/wCLo/4Wv8Yf+hC/8o13/wDF0e3kH9kUf5n+H+Qz/hX3in/oDy/99p/jSf8ACvvFP/QHl/77T/GpP+Fr/GH/AKEL/wAo13/8XR/wtf4w/wDQhf8AlGu//i6PbyD+yKP8z/D/ACI/+Fe+Kc5/sibvx5iYP60v/CvvFP8A0B5f++0/xp//AAtf4w/9CF/5Rrv/AOLo/wCFr/GH/oQv/KNd/wDxdHt5B/ZNH+Z/h/kM/wCFfeKf+gRL/wB9p/jR/wAK98Uj/mESn/gaf40//ha/xh/6EL/yjXf/AMXR/wALX+MP/Qhf+Ua7/wDi6PbyD+yKP8z/AA/yGf8ACvvFP/QIl/77T/Gj/hX3in/oES/99p/jT/8Aha/xh/6EL/yjXf8A8XR/wtf4w/8AQhf+Ua7/APi6PbyD+yKP8z/D/IZ/wr7xT/0B5f8AvtP8aP8AhX3ik8/2PLn3dP8AGn/8LX+MP/Qhf+Ua7/8Ai6P+Fr/GH/oQv/KNd/8AxdHt5B/ZFH+Z/h/kM/4V94pyf+JPJ9d6f40H4eeJ2+/o0h4xksnH60//AIWv8Yf+hC/8o13/APF0f8LX+MP/AEIX/lGu/wD4uj20hrKaK2k/w/yGf8K+8U5/5A8oz1/eJ/jR/wAK98U/9AeX/vtP8af/AMLX+MP/AEIX/lGu/wD4uj/ha/xh/wChC/8AKNd//F0e3kL+yKP8z/D/ACGf8K+8Vf8AQIl+m9P8aP8AhX3in/oDy/8Afaf40/8A4Wv8Yf8AoQv/ACjXf/xdH/C1/jD/ANCF/wCUa7/+Lo9vIP7Io/zP8P8AIYPh94pGP+JPL/32n+NA+H3inqdHlz3+dOf1p/8Awtf4w/8AQhf+Ua7/APi6P+Fr/GH/AKEL/wAo13/8XR7eQf2RR/mf4f5DV+H3igsFk0aQA9w6HH15pn/CvvFpf5NKmTnGDImMfnUv/C1/jD/0IX/lGu//AIuj/ha/xh/6EL/yjXf/AMXR7aRayqiur/D/ACGn4feKt2DpMpHqHT/Gk/4V74pBP/Enlx6b0/xp/wDwtf4w/wDQhf8AlGu//i6P+Fr/ABh/6EL/AMo13/8AF0e2kT/ZNH+Z/h/kM/4V94q/6A8vX++n+NH/AAr7xT/0CJf++0/xp/8Awtf4w/8AQhf+Ua7/APi6P+Fr/GH/AKEL/wAo13/8XR7aQv7Io/zP8P8AIYfh/wCKhyNIlJ/66J/jR/wr3xT20eT/AL7T/Gn/APC1/jD/ANCF/wCUa7/+Lo/4Wv8AGH/oQv8AyjXf/wAXR7eQf2RR/mf4f5DP+FfeKc/8geX/AL7T/Gj/AIV74p/6A8v/AH2n+NP/AOFr/GH/AKEL/wAo13/8XR/wtf4w/wDQhf8AlGu//i6PbyD+yKP8z/D/ACGf8K+8U/8AQIl/77T/ABo/4V74pySNHkBPX50/xp//AAtf4w/9CF/5Rrv/AOLo/wCFr/GH/oQv/KNd/wDxdHt5B/ZFH+Z/h/kM/wCFfeKf+gPL/wB/E/xpP+FfeKyzhtGcLn5SJEyRx15+tSf8LX+MP/Qhf+Ua7/8Ai6P+Fr/GH/oQv/KNd/8AxdHtpD/smh3Yw/D7xT0/seXp13p/jQfh94p/6A8v/faf40//AIWv8Yf+hC/8o13/APF0f8LX+MP/AEIX/lGu/wD4uj28hf2RR/mf4f5EbfDzxPJGVk0WRlPYunX/AL6qe18A+J47+F30mUKsisTvTgA/Wmf8LX+MP/Qhf+Ua7/8Ai6P+Fr/GH/oQv/KNd/8AxdHtpD/smj/M/wAP8j3+ivAP+Fr/ABh/6EL/AMo13/8AF0f8LX+MP/Qhf+Ua7/8Ai6wsewe/0V4B/wALX+MP/Qhf+Ua7/wDi6P8Aha/xh/6EL/yjXf8A8XRYD3+ivAP+Fr/GH/oQv/KNd/8AxdH/AAtf4w/9CF/5Rrv/AOLosB7/AEV4B/wtf4w/9CF/5Rrv/wCLo/4Wv8Yf+hC/8o13/wDF0WA9/ryb4h+E9c1fxe95punPPD5KIJFZRkgHPU1zP/C1/jD/ANCF/wCUa7/+Lo/4Wv8AGH/oQv8AyjXf/wAXVQk4u6OfEUI4iHJIaPh/4pByNIl46fOn+NB+H/in/oES+mA6f407/ha/xh/6EL/yjXf/AMXR/wALX+MP/Qhf+Ua7/wDi619tLsed/ZFH+Z/h/kM/4V94p/6A8mP99P8AGj/hX3inAxo8oPs6f40//ha/xh/6EL/yjXf/AMXR/wALX+MP/Qhf+Ua7/wDi6PbSD+yKP8z/AA/yG/8ACvvFP/QIl/77T/Gk/wCFf+KR/wAweXH++n+NP/4Wv8Yf+hC/8o13/wDF0f8AC1/jD/0IX/lGu/8A4uj20g/sij/M/wAP8hv/AAr7xT/0CJf++0/xpP8AhX3in/oES/8Afaf40/8A4Wv8Yf8AoQv/ACjXf/xdH/C1/jD/ANCF/wCUa7/+Lo9tIP7Io/zP8P8AIZ/wr7xT0/seX/vtP8aP+FfeKf8AoDy/99p/jT/+Fr/GH/oQv/KNd/8AxdH/AAtf4w/9CF/5Rrv/AOLo9tIP7Io/zP8AD/Ib/wAK+8U/9AiX/vtP8aT/AIV94p/6A8v/AH2n+NP/AOFr/GH/AKEL/wAo13/8XR/wtf4w/wDQhf8AlGu//i6PbSD+yKP8z/D/ACGH4e+KSMf2RMPcSJkfrR/wr7xT/wBAiX/vtP8AGn/8LX+MP/Qhf+Ua7/8Ai6P+Fr/GH/oQv/KNd/8AxdHtpB/ZFH+Z/h/kN/4V94p/6BEn/faf40n/AAr7xSf+YRLj03p/jT/+Fr/GH/oQv/KNd/8AxdH/AAtf4w/9CF/5Rrv/AOLo9tIP7Io/zP8AD/Ib/wAK+8U/9AiXr/fT/Gj/AIV94p/6BEv/AH2n+NO/4Wv8Yf8AoQv/ACjXf/xdH/C1/jD/ANCF/wCUa7/+Lo9tIP7Io/zP8P8AIb/wr7xT/wBAiX/vtP8AGj/hX3ik9dIl/wC+0/xp3/C1/jD/ANCF/wCUa7/+Lo/4Wv8AGH/oQv8AyjXf/wAXR7aQf2RR/mf4f5DP+FfeKeP+JPJ9N6cfrSn4feKCpB0eQg9QXT1z607/AIWv8Yf+hC/8o13/APF0f8LX+MP/AEIX/lGu/wD4uj20g/sij/M/w/yGf8K98UD7ujSjnPDoOfzpf+FfeKf+gRL/AN9p/jTv+Fr/ABh/6EL/AMo13/8AF0f8LX+MP/Qhf+Ua7/8Ai6PbSD+yKL+0/wAP8hv/AAr7xT/0CJf++0/xpP8AhX3in/oDy/8Afaf40/8A4Wv8Yf8AoQv/ACjXf/xdH/C1/jD/ANCF/wCUa7/+Lo9tIP7Io/zP8P8AIZ/wr7xT/wBAiX/vtP8AGl/4V94pPXSJen99P8ad/wALX+MP/Qhf+Ua7/wDi6P8Aha/xh/6EL/yjXf8A8XR7aQf2RR/mf4f5GfJ4F8aEMU0O4HHC7o/57qePh94o2ID4fuskZZt0ZOfxarv/AAtf4w/9CF/5Rrv/AOLo/wCFr/GH/oQv/KNd/wDxdP6xLsdH9nUErK6KUXgDxczRE6FPGed2WjHGPZqtn4e+KO2kS9eu9OP1p3/C1/jD/wBCF/5Rrv8A+Lo/4Wv8Yf8AoQv/ACjXf/xdDryfQznldGbvd/18hv8Awr/xTnjR5R/wNP8AGk/4V94p6/2PL/32n+NP/wCFr/GH/oQv/KNd/wDxdH/C1/jD/wBCF/5Rrv8A+Lpe2kZ/2RR/mf4f5Df+FfeKf+gRL/32n+NJ/wAK/wDFJ66PL/38T/Gn/wDC1/jD/wBCF/5Rrv8A+Lo/4Wv8Yf8AoQv/ACjXf/xdHtpB/ZFH+Z/h/kM/4V94p76PL/32n+NH/CvvFJ/5g8v/AH2n+NP/AOFr/GH/AKEL/wAo13/8XR/wtf4w/wDQhf8AlGu//i6PbSD+yKP8z/D/ACG/8K+8U/8AQHl/77T/ABpP+FfeKTjOjyEjp86f40//AIWv8Yf+hC/8o13/APF0f8LX+MP/AEIX/lGu/wD4uj20g/sij/M/w/yGf8K+8Vf9AiX/AL7T/Gg/D/xXldujPjPzZkTI+nNP/wCFr/GH/oQv/KNd/wDxdH/C1/jD/wBCF/5Rrv8A+Lo9tIayih3f9fIYfh94oCkjR5vpvT/GlPw+8UZ/5A8uP+uif407/ha/xh/6EL/yjXf/AMXR/wALX+MP/Qhf+Ua7/wDi6PbSF/ZFH+Z/h/kNHw/8Uj/mDyfXen+NIPh54nTPl6NIoJzgOnX/AL6p/wDwtf4w/wDQhf8AlGu//i6P+Fr/ABh/6EL/AMo13/8AF0e2kP8AsmjtzP8AD/I9X+Hml3uj+Eo7TUoGgnWV2KMQTgnjpXUV4B/wtf4w/wDQhf8AlGu//i6P+Fr/ABh/6EL/AMo13/8AF1i7t3PUpQVOCguh7/RXgH/C1/jD/wBCF/5Rrv8A+Lo/4Wv8Yf8AoQv/ACjXf/xdKxoe/wBFeAf8LX+MP/Qhf+Ua7/8Ai6P+Fr/GH/oQv/KNd/8AxdFgPf6K8A/4Wv8AGH/oQv8AyjXf/wAXR/wtf4w/9CF/5Rrv/wCLosB7/XN+PtNu9W8I3Fnp8BnndlwgI9fevJP+Fr/GH/oQv/KNd/8AxdH/AAtf4w/9CF/5Rrv/AOLpq6dyKkVODi+oz/hX3ik4/wCJPL/32n+NL/wr/wAVbcf2RJj/AH0/xp3/AAtf4w/9CF/5Rrv/AOLo/wCFr/GH/oQv/KNd/wDxdbe2l2PK/smj/M/w/wAiP/hX3into8n4un/xVL/wr7xT/wBAeX/vtP8AGn/8LX+MP/Qhf+Ua7/8Ai6P+Fr/GH/oQv/KNd/8AxdHt5C/sij/M/wAP8iMfD7xVjnR5f++0/wAaX/hXvikf8wiX/vtP8af/AMLX+MP/AEIX/lGu/wD4uj/ha/xh/wChC/8AKNd//F0e3kH9kUf5n+H+Qz/hX3in/oDy/wDfaf40f8K98U/9AiX/AL7T/Gn/APC1/jD/ANCF/wCUa7/+Lo/4Wv8AGH/oQv8AyjXf/wAXR7eQf2RR/mf4f5DP+FfeKRz/AGPL/wB9p/jR/wAK+8U/9AeX/vtP8af/AMLX+MP/AEIX/lGu/wD4uj/ha/xh/wChC/8AKNd//F0e3kH9kUf5n+H+Qz/hX3ir/oES/wDfxP8AGj/hX3in/oDy/wDfaf40/wD4Wv8AGH/oQv8AyjXf/wAXR/wtf4w/9CF/5Rrv/wCLo9vIP7Io/wAz/D/IZ/wr7xT/ANAeX/vtP8aQfD3xSCf+JRN9DInH61J/wtf4w/8AQhf+Ua7/APi6P+Fr/GH/AKEL/wAo13/8XR7eQ/7Jo/zP8P8AIZ/wr3xT/wBAiT/vtP8AGj/hX3in/oES/wDfaf40/wD4Wv8AGH/oQv8AyjXf/wAXR/wtf4w/9CF/5Rrv/wCLo9vIX9kUf5n+H+QwfD7xT/0CJf8AvtP8aP8AhX3inj/iUS/99p/jT/8Aha/xh/6EL/yjXf8A8XR/wtf4w/8AQhf+Ua7/APi6PbyD+yKP8z/D/IZ/wr7xT/0CJf8AvtP8aP8AhX3in/oDy/8Afaf40/8A4Wv8Yf8AoQv/ACjXf/xdH/C1/jD/ANCF/wCUa7/+Lo9vIP7Io/zP8P8AIZ/wr3xTn/kESD/gaf40D4feKf8AoDyD/gaf40//AIWv8Yf+hC/8o13/APF0f8LX+MP/AEIX/lGu/wD4uj28g/sij/M/w/yGH4e+J927+xZN2Sc7kyc/jQPh74px/wAgiXH++n+NP/4Wv8Yf+hC/8o13/wDF0f8AC1/jD/0IX/lGu/8A4uj20hvKaL3k/wAP8hn/AAr3xT/0B5f++0/xo/4V94q/6BEp/wC2if40/wD4Wv8AGH/oQv8AyjXf/wAXR/wtf4w/9CF/5Rrv/wCLo9vIX9kUf5n+H+Qz/hX3ik/8weX/AL7T/Gj/AIV94q/6BEv/AH2n+NP/AOFr/GH/AKEL/wAo13/8XR/wtf4w/wDQhf8AlGu//i6PbyD+yKP8z/D/ACIJPh94tDAR6RKBx/En/wAVTI/h54q3StNokjN/D8yc/wDj1Wv+Fr/GH/oQv/KNd/8AxdH/AAtf4w/9CF/5Rrv/AOLp/WJWtY1WWUUrXf4f5FRfh14qEv8AyBZtpHJLR/41LB8PPFSwqH0eUEdt6f8AxVTf8LX+MP8A0IX/AJRrv/4uj/ha/wAYf+hC/wDKNd//ABdN4ibFLLKUlZt/18hg+H3ikf8AMHlPP99OP1o/4V94pxg6RL0/vp/jT/8Aha/xh/6EL/yjXf8A8XR/wtf4w/8AQhf+Ua7/APi6n20jP+yKP8z/AA/yGf8ACvvFXbSJf++0/wAaP+FfeKen9jy4/wCuif40/wD4Wv8AGH/oQv8AyjXf/wAXR/wtf4w/9CF/5Rrv/wCLo9vIP7Io/wAz/D/IZ/wr7xT/ANAeX/vtP8aT/hX3inn/AIk8v/faf41J/wALX+MP/Qhf+Ua7/wDi6P8Aha/xh/6EL/yjXf8A8XR7eQf2RR/mf4f5DP8AhX3ikf8AMHl/77T/ABo/4V94p/6A8v8A32n+NP8A+Fr/ABh/6EL/AMo13/8AF0f8LX+MP/Qhf+Ua7/8Ai6PbyD+yKP8AM/w/yIx8PfFIGBo8gHpvT/Gl/wCFfeKf+gPL7fvE/wAaf/wtf4w/9CF/5Rrv/wCLo/4Wv8Yf+hC/8o13/wDF0e3kH9kUf5n+H+RGvw+8VFBv0eRW77ZEI/nS/wDCvvFPP/Enm4P99PT60/8A4Wv8Yf8AoQv/ACjXf/xdH/C1/jD/ANCF/wCUa7/+Lo9tIf8AZNHu/wCvkM/4V94pHTR5f++0/wAaD8PPE7MrNo0hZfutvTj170//AIWv8Yf+hC/8o13/APF0f8LX+MP/AEIX/lGu/wD4uj20gWU0VtJ/h/kdF4B8Ia9pPi6C71HTpIIFRgXLKcZHsa8e+OX/ACWbXf8At3/9J467/wD4Wv8AGH/oQv8AyjXf/wAXXkHjnVtY1zxnfaj4lsP7O1Oby/PtvJeLy8Rqq/K5LDKhTz65rOUnJ3Z34fDxw8OSLPf/ANmr/km9/wD9haT/ANEw16/Xj/7NriP4Z6i7nCrqspJ9vJhrt/8AhZXhP/oLf+S0v/xNTyt7Gs6tOn8ckvVnU0Vy3/CyvCX/AEFv/JaX/wCJo/4WV4T/AOgr/wCS0v8A8TRyS7Gf1qh/OvvR1NFct/wsrwl/0Fv/ACXl/wDiaD8SvCQxnVuv/TtL/wDE0ckuwfWaH86+9HU0Vy3/AAsrwkP+Yt/5LS//ABNH/Cy/CX/QW/8AJeX/AOJo5Jdg+tUP5196Oporlv8AhZXhL/oLf+S0v/xNH/Cy/CX/AEFv/JeX/wCJo5Jdg+s0P5196Oporlv+FleE/wDoLf8AktL/APE0D4leEz01b/yWl/8AiaOSXYPrVD+dfejqaK5b/hZXhL/oLf8AktL/APE0f8LK8Jf9Bb/yWl/+Jo5Jdg+tUP5196Oporlv+FleEv8AoLf+S0v/AMTR/wALK8Jf9Bb/AMlpf/iaOSXYPrVD+dfejqaK5b/hZXhL/oLf+S0v/wATR/wsrwn/ANBb/wAlpf8A4mjkl2D61Q/nX3o6miuW/wCFk+E/+grx/wBe0v8A8TR/wsvwl/0Fv/JaX/4mjkl2D6zQ/nX3o6O7uY7KymupziOGNpHI9AMmueTxmLeSCPVrCW3e6iSa3SL96zhiAAQOhyRUcnxG8ITRNHJqgZHBVlNtLyD1H3axrbXvh9bSRSLqc0jQFPKaVZ38sL91RleF9qOSXYPrVD+dfejok8Z6eHSOUS72lSImOJisZeXy0DHsS1Fj40066EKkS73hWQusR8vLJvwGOOcVx17qvgy41a2ntdcNtBHPHNPH9muMzMkhlXn7uNx/unv07Xhrnw6FmLUXz+UAqgeXP/Cmwc7fSnyS7B9Zofzr70dRpvim11fUreCwBeKWKd2ZuGRo2jXbj38z9KrReOtPJEcsF15xkMe2KEuM+Y6KMjuTGeKxNJ8R/D/RplksNRcSKJAGeOdid5Ut1X/YX8qWHxH8PreTzIr9g3mrN/qp/vK7uD931kb86XJLsH1qh/OvvR0DeNtFjMPmztGk8DTo7rgbVRnP4hUY/hUcnjzRoeLg3EEgk8topYSrqdobJB7YYfnXKvffDVnVxesSiMiq8c5Q7omiOV28/I5H41DpuoeCYUaTVNeku7tpzMJ0huFIG1V25O4kYUdTRyS7B9Zofzr70epowdFdDlWGQfUUtcqvxJ8JKoA1bgDH/HtL/wDE0v8Awsrwl/0Fv/JeX/4mjkl2D6zQ/nX3o6miuVX4meEmQMNW4PT/AEab/wCIpf8AhZfhL/oLf+S0v/xNPkl2H9ZoL7a+9HU0Vy3/AAsrwmf+Yt/5LS//ABNK3xJ8KIwDaqQSobH2aXoen8NLll2D6zQ/nX3o6iiuZHxF8LGJpP7TIRCAzG2lABP/AAGmf8LL8JEZ/tbj/r2l/wDiaSi3sg+s0P5196Oporlv+Fl+Ev8AoLf+S0v/AMTR/wALK8Jf9Bb/AMlpf/iafJLsL61Q/nX3o6miuW/4WV4S/wCgt/5LS/8AxNH/AAsrwl/0Fv8AyWl/+Jo5Jdg+tUP5196Oporlv+Fl+Ev+gt/5LS//ABNH/CyvCX/QW/8AJaX/AOJo5Jdg+tUP5196Oporlv8AhZXhL/oLf+S0v/xNH/CyvCeM/wBq8f8AXtL/APE0ckuwfWqH86+9HU0Vy3/CyvCX/QWH/gPL/wDE0f8ACyvCf/QW/wDJaX/4mjkl2D61Q/nX3o6miuW/4WV4T/6C3/ktL/8AE05PiP4VkkWNNVyzkBR9nl5P/fNHJLsH1mh/OvvR09FFFSdAUUUUAFFFFABRRRQAUUVh6r4y0HRL42eqX/kThQxTyZG4PTlVIppN7ETnCCvN2XmblFct/wALK8J/9Bb/AMlpf/iaP+FleE/+gt/5LS//ABNPkl2MvrVD+dfejqaK5b/hZXhP/oK/+S0v/wATR/wsrwnjP9rcf9e8v/xNHJLsH1qh/OvvR1NFct/wsrwkRn+1v/JeX/4mj/hZXhL/AKC3/kvL/wDE0ckuwfWqH86+9HU0Vy3/AAsrwn/0Fv8AyWl/+Jo/4WV4S/6C3/kvL/8AE0ckuwfWqH86+9HU0Vy3/CyvCZ/5i3/ktL/8TR/wsrwl/wBBb/yWl/8AiaOSXYPrVD+dfejqaK5b/hZPhPP/ACFv/JeX/wCJo/4WV4S/6C3/AJLS/wDxNHJLsH1qh/OvvR1NFct/wsrwn/0Fv/JaX/4mj/hZXhP/AKC3/ktL/wDE0ckuwfWqH86+9HU0Vy3/AAsrwn/0Fv8AyWl/+Jo/4WT4T/6Cv/ktL/8AE0ckuwfWqH86+9HU1FdyvBZzSxR+a8cbMqZxuIHArmx8SfCZzjVc4Gf+PaX/AOJoPxJ8JEEHVvY/6PL/APE0ckuwfWqH86+9FaP4hW1xv+z2xxhGiZm4dDF5jNxzhcgGnr8QLfzI2lsLpbfNyJJBGTjySoLAd15JJ7YrFg1T4bWyQLDeMot4ZYY/3c/CSHLD7v4D0HAqZde+HyeYBqMpWRJkKlJyAJcb8DbxnAo5Jdg+tUP5196Oo1jxENL1Cyt/KUpdDPnyNtQcgYzjqc55qunjrRZpJI7eSaaRXVESKPcZSSR8gHX7pP0FY+peLfA+qRRQ3er3BhjwvlRx3Co2CCNwC4PTvWZc6r4FWxkj0rVzaytIskTNDcFYWBPKhdpHBYcEdaOSXYPrND+dfejqR490htnlpeSb0VhstmP3t20fU7Tx7US+PtBhaUNcORFA87lYycBYzKR9dgJx7Vzel634C0/T7aGTVnmlhSMNKYZhvZAcHG3j7xo/tP4cbZ1W/kVLmBoJUVJwHVk2H+HrtOM0ckuwfWqH86+9HTr4ys31IWiWt5kJIZWaLHlFApIYHpkOD+NVpPH1g8cr2cM0iR2dxctKyHZH5WdytjJHTtmsi68QfD+8uJppdSlEk7M0hRJ13blVSDhemEXj2qvHqXw4itXgTUZxHJFPFIMXH7xZRhwfl59vQ9KOSXYPrVD+dfejqpPGmlRSvGRcsyyGNNsJPmsH8s7PXDcGrGn+KNO1S+jtbTzmkkiEvzR4AHvnvXKJr3w9jvTdDUZDJ5plUFJyqMX3naNuAC3JA6mn23iTwDa39vdw6nL5lsCIgyTlVyCDxtx3P50ckuwfWqH86+9HoFFcqPiX4SLlRq2SBk/6NL/8T7Uv/CyvCX/QW/8AJaX/AOJo5Jdh/WaC+2vvR1NFct/wsrwl/wBBb/yWl/8AiaX/AIWR4U2b/wC1PlyBn7NL1P8AwGjlkugfWaD+2vvR1FFcxH8RfC00ipHqbMzHAAtpeT/3zTT8SfCYYr/a3I6/6PLx/wCO0uV3tYPrNDfnX3o6miuW/wCFleE/+gt/5LS//E0f8LK8J/8AQW/8lpf/AImnyS7C+tUP5196Oporlv8AhZXhP/oLf+S0v/xNH/CyvCf/AEFf/JaX/wCJo5Jdg+tUP5196Oporlv+FleE/wDoLf8AktL/APE0f8LK8J/9Bb/yWl/+Jo5Jdg+tUP5196Oporlv+FleE/8AoLf+S0v/AMTR/wALJ8Jn/mK/+S0v/wATRyS7B9aofzr70dTRXLf8LK8J8/8AE2xg45tpf/iaP+FleE/+gt/5Ly//ABNHJLsH1qh/OvvR1NFct/wsrwn/ANBb/wAlpf8A4mj/AIWV4T/6C3/ktL/8TRyS7B9aofzr70dTRVLStXsdbsReaXP59uWKh9jLyOvBANXanY3jJSV1sFFFFAwooooAKKKKACiiqmp6pZ6PYteajN5MCEBn2lsZ9gCaBNqKuy3RXLf8LK8J/wDQW/8AJaX/AOJo/wCFleEv+gt/5LS//E1XJLsYfWqH86+9HU0Vy3/CyvCX/QV/8lpf/iaP+FleEv8AoLf+S8v/AMTRyS7B9Zofzr70dTRXLf8ACyvCW7H9rc/9e0v/AMTR/wALL8Jf9Bb/AMlpf/iaOSXYPrND+dfejqaK5b/hZXhL/oLf+S8v/wATR/wsvwl/0Fv/ACWl/wDiaOSXYPrND+dfejqaK5b/AIWV4T/6C3/ktL/8TR/wsrwmP+Yt/wCS0v8A8TRyS7B9aofzr70dTRXLf8LK8J/9Bbvj/j2l/wDiaP8AhZXhP/oLf+S0v/xNHJLsH1qh/OvvR1NFct/wsrwl/wBBb/yWl/8AiaP+FleEv+gt/wCS0v8A8TRyS7B9aofzr70dTRXLf8LK8Jf9Bb/yWl/+Jo/4WV4TP/MW/wDJaX/4mjkl2D61Q/nX3o6mg9OK5b/hZXhL/oLf+S0v/wATQfiT4THXVf8AyWl/+Jo5Jdg+s0P5196K8fxAiklWJbJ97pEANw/1rypGyH/d81GPsT6Uq+P42WMpp9xKDJCjPHGSrCRd3ydyR6cVkprXw4S+S7W9ImjvJL0Hyp/9a67WONvTGOOgIB7VJb+IPh9ayxPBqUq+UI9q7JyoKDCnG3rg9aOSXYPrND+dfejf1vxbFpunabeWsYnjv3KoWJGAI2fsCc/LiiHxxpUkMLyiePzI0cny8qrMivs3DgsAwrDn8TeA57OytRq08SWJJgMKzoy5UqeQuTwxqrHq3w3RFWO9kSJYxGsXl3AVcIEDbdvDbVAz14FHJLsH1mh/OvvR1dz4x0u0uTBJ9oZlLb2SElYwrKrMx7AFhzVSTxva/wBqrbRRP5GGzPIjAMRJsO3jkZzz7VhRa38PIoZov7SmkE0ckcjSLcMzByC3JX1UUg1j4dC4ab+0ZmOSQpW4Kplt5CjbwN3PFPkl2D6zQ/nX3o6VfG+lPAJFS7LE8RfZzvK7N+8D+7jvUWveMotItNPuYIPPivYzMpYlTtC7vQ8ketctrGr+C7yzCaZrQs7lVCCdre5YqmwpgbdvY+uD3FXbnxD4DvLCytLjV7jbZw+QhjSdCy7dpB2rzkUuSXYPrVD+dfejo/8AhNdKUOZTOixozvJ5RKAKVD4PfbuGfQZpn/Cd6J50cfnS5kjEq/uz90glffkDI9sVzZ1f4clnzfybGUqYtk+wAlSwC7cANtG71HBpYda+HltOstvqU0TLGIxsWcfKM4H3ewOB6DFHJLsH1qh/OvvR3el6lBq2nx3lqHEUmdu8YNW64jTfG/gfRLE29pqriLeXO+GZ2LMfdc9TV4/ErwmOurY/7dpf/iaOSXYf1mha/OvvR1NFct/wsrwn/wBBb/yWl/8AiaVfiT4UcgLquSegFtL/APE0ckuwvrND+dfejqKK5b/hZXhPdgark5xxbS//ABNOf4jeFY4kkfVNqyAlCbaX5sEjj5fUGlyvsP6xR/nX3o6eiuW/4WV4TH/MW/8AJaX/AOJo/wCFl+Ev+gt/5LS//E0+SXYX1qh/OvvR1NFct/wsrwl/0Fv/ACWl/wDiaP8AhZXhP/oLf+S0v/xNHJLsH1qh/OvvR1NFct/wsrwl/wBBb/yWl/8AiaP+Fl+Ev+gt/wCS0v8A8TRyS7B9Zofzr70dTRXLf8LK8Jf9Bb/yWl/+Jo/4WV4T/wCgt/5LS/8AxNHJLsH1qh/OvvR1NFcsfiV4TGM6r1/6dpf/AImj/hZXhL/oLD/wHl/+Jo5Jdg+tUP5196Oporlv+FleEv8AoLf+S0v/AMTR/wALK8J/9Bb/AMlpf/iaOSXYPrVD+dfejqa+Qfjl/wAlm13/ALd//SeOvqHS/Gvh/Wb5bPTdQ864YEhPJkXOPcqBXy98cv8Aks2u/wDbv/6Tx0WaeprGpCavB39D1n9nb/klOrf9hKb/ANERV570yTwScmvQv2df+SU6t/2Epv8A0RFXn1dNDqeFnG8Pn+gUdacYnABIwO2ehptdCaex4AUZ5OfSigdOe9AwHAx6dc0d6P5+g7ij60wAeh79aM56jnvRz9f50UAIBj2p2G25DYHekpZOI0Pbccik9xrVhj5c4PBwTjigg7eh/KkVGSMbyOR90mg7jgkDdjHB5xS9AsrhnPQ0UA7jx19O9G5AwVpFViehqhWb0QUUMURQ0j4BYIMKTknOOn0oPBx70rhZpXD6dKKCMDn8cGjr/WgAooopiCiij9aADr70nIzjkAcUuKUF/Mj2svljO5dvLE9OfSkyopPcT8O/ajIxkEEeooILL8vXGR+HNBwT8pGD0xQLoH16DmjpgH8aD+f40Hftbyym/tuBx70Ald2DHGBQeOuB+NDY3cjA9M5oACrnaAMdTyT+FFw3HhhFbyTcO4GEGOM+p9hUZ2N+9lflsl229T26U755P9Y3HYdgaXbHu3iRguOgUk9v0qNFq9zWLWyEilMQ+UBg5+ZJG4zjg0nmK4y0bI3qpyP8acRGmQiD/eJyaQnPp9AMU7Ju6E5J7iAqWAHU9qOe45ozu46+ozSZx1LEc4I7iqMxefT9aPrQNvy5ZvmbA2j9T7Uc96AsHTGaOe/XvSqpYgDqeOuKQbSqsrBlYZVlOQR6ii4dLhg/hRj7x5+brzntR0ZcDIGT1xz9KPbn8aA2A89QPyoz8wXnJBP+fzo6c4470dOKYB06cVPY/wDIRtv+uq/zFQVPY/8AIRtuf+Wy/wA6Q47o+n6KKK8w+9CiiigAooooAKKKKACvDvitz46fI6QR/wAq9xrw74rf8jw//XvH/Kt6HxHk5t/u/wA/8zi6KcI2bO1T7kU0jBwa7Lo+VCj0+o/z+lFH9B+tAw/i+tHTrRx3IA/lR2oAPr2o9vyo6dPyNFACEc5psshjjyMsSQoHHUnH9afUVyCYCR/CQSfoQaC4K8kmPjfzCQclgcFcdDT8deDwOeKghRnuDIjbVVQGPqe1TH5gVIXaeoz15/8ArUno7Ic4xUgPBweDnoaT8aUt2br796DhF3O21QM5NMzsFFKoDkbZFIPcdqarpJGrxtuVhkcEfzpXHyu1xfp1ooA4pOPqTTELRR+tFABR+lFFAgzSYwQRgc8/T/JpcUh3+XIImVJChCMy5AP0/wA80MqOrsL3PHf160nXjvjOPx/+tTickd8AZOOuP/1UmMAgkZHv260hB9KKKPyGaYB1574x1ox+FHzEHzAv3iVKkjC9gfekAB6KD7ngUug2rMdGoeQKWAHfvgUkj/aGkToqZES46e5+tLuc/KjbV6EqMZ+lDRoYyA+DwckcdanrdlxaiyGeXyVaW1di0fKnkAH6VHJcXCKHKxSjj5U4J+narjJFknDSEHb8/wAvQ46e+KiWOJCTHGiE9Tj+tVFp62NVOKVmri7l25OR7EUuPbgjj3ozjvj8aDweM/7Q/rQc+gfgPzooGCeWI9cjkUZBUMu7DDOGGCKL6hZ2uH0o/lR+tGOTyu7AJUHkDtTEGD2FBHI68HIwcdsUh6Hbyccc4/WlOOOuOlAB9RSEhVLEcAZ4FKR7c9QaM98YPegAIw3qemaKKOgoEe5fCr/kRYv+u8n867OuM+FX/Iixf9d5P512defU+Jn22D/3eHogoooqDqCiiigAooooAK5L4m/8iLdY/vJ/Outrkvib/wAiLdf7yfzq4fEjnxX8CfozwXAAAHA6AUtKBn3pWjZM7gR7HtXoXR8QNoHUUUdj60wDqn1yf1o60GjOT6+uO1IYdQcfSjPp2o7+9FMAOCKB6ZoooAjMkh5VcjdgZI7cVIp3RqwDAMM9OtV1DYcYPzMdo/E/4GpYciBAMHj16U2rbG04pIkIx1yPc/hScfhR0JOBySWx6+tA55HP0qVe2pi7dAooDISVWVSw7UEoHCF/nKlgMHp9elFx8r7B9aPrR1PFBHv+vBpiCj+dHXkfhRQAUUUfyoEFHB6/nRzRQMOdoB5OcH/P5UhOPvcYHJzTsvvk3srISvlqq42gcc+/NJjoTjHQ596lMppJh3waO1Hc8ijv/nimSHUY/lS8k0mXyuNhXneDnJ44wfrzSEDuOfTrQOwvA6kD8afJJ5EKCMgPIfmbH3V/xNNyU+6qhuwHJ/HsP1oAzgzOWNS9dxqy1YwrGmQGYEkbVAIOKiMtwd0cciBI+F3DkdyB+JNWRFH8yvIzBmPCg9vf15/Q0xo4S3EKA56/ezTjJddTVTUdyNG/eYbd93PIHX8KlBDZ28kdaRUVTlVAPqKU/MMk/jnoaozm03dB+FH4frRn+9kH6cUcZ25Yttz04HOMfXvSvYizD+faj6Uf40HAUliqgcklsCgN2FKMjtSEYODQOp49AOc8Y9O3egBAMKAM4Hqc0uPYUdaB6Y47UwDg5HocHIooo7UCOv8Ahh/yPVt/1zf+VecfHL/ks2u/9u//AKTx16P8MP8Akerf/rm/8q84+OX/ACWbXf8At3/9J46463xn1GU/wH6/5HrP7Ov/ACSnVv8AsJTf+iIq8++vSvQf2df+SU6t/wBhKb/0RFXn361dDqc2cbw+f6CFIyseYt+2QsMn7pPJb65/rS96KK6ErHhOTluH9eKDwM4zjsKO/wBKO34UxB/Kgc/XoaKSgBaOPWj6Cj6UAA/GgODIv90NxkflRmg43qccN8pA6ZNJjjuOfG48nfnkEY7A8fnTaDkcH5sd+9FC0QmB5HIz9aOMjIyAc4JyKKKAuwHyjj88c0UZAKgnlsgfgM0UA77sFjxuKKFySTjAyccn34FH1oaMExs6ZKklSR0zwcUZB3gxsm1sLls7h6+30pX1KtdXQUfpRRk8/MxBxhT0X6UyROO/pS4HaiimAnTqKXHH8qPx/WlXAbIwe5UHr/hSASQkfKvAPzcn1p7BjEjlUTIBAB5x0zjt0qPO4FjngenT/PSpZfnYY6RqEGcZ/wA5qHe6NPdS1Ix04A59aOfp7DtS5+Yn6ZoA4GfbNWZidBnp7+tIOcNggdhS9euB3NBP5dqBgfccdKCWCMUQO+PlVjgE0UflR0EnZ3HDaZB8uM9QO/40xfur5gRWZsAZ60p3FcLIyc5+X1pzHczb1j2n5lIzuB/l61OqLVhpHrzz0NGTnjk56UZ/Gjp/WrIDsevPoetGcY3dPU0UfqPekALnP7xUznoBwR70RqQqpxx0wMACjtR7Giw7vYAQTtxt6kc5zR1/wpFVY1UIpAUEAZpc+1AO19A9+v1oBHPYe9A4HHGKKYg7A5BHUVPY/wDIQtv+uq/zFQZwOh9wB0qewwdQtiP+eqdPqKXQa3Pp+iiivMPvQooooAKKKKACiiigArw74rf8jzJ/17x/yr3GvDvit/yPMn/XvH/Kt6Hxnk5t/u/zRxYCFiSpJ2kcHqPT86RVCxqqIIwBwo/hpaSuux8vzNqzFoH8+tHUY9aKYhB9Onr3o749elLRQAUnHc0fUUtACfrSswG38zkenT+tFBG5CD1wcEdaBrcVFjS3jVRsToAq8A+9JRnKhh/EOVI79KBz+FJDkFJgDoMH2NLRTJDAGMAce1BJPU0nYntjNLnPIOeMigNXqw2hmBKgsuSGPUfjSkFThqTbuVgV3LjB47UDCCNBEduCCynhMDjjvUt6lJcysH0pO9L9KMsMbWZcMCdp+97H2qiV5idBz0owMmlpP59vegAx+NA9vypfp/OkOO5GfXPNADZnaOMGL724KpPQZot5HLmGRYweDv3cckKB+eKS5yVAUcoQ2B/EaISZPNADBZNq4YY6ZPfnqaT+E6YqPJeS0JBwTwMj36Uc8kAD6Up44I70nXp60HOA5PTP17Umc5AyfU0p7Y5+tHQfzpgHbAFGaPWigQpO4uGjVQrfuznOR6n0o58wfKAu3JYnvSAleh2nsQOlKrOqKAVkKtk+aTyM8jI9s1GqWhas2IMFQyEbWGQVPBoHA44FHyjheFHQAdKT6/hVkegoOcZ7Cj6ZP1NHvR0oAOSRgKUxye+f84pMYcsNvIwcLyfcmlPWiiw+Zg3ydVJ4ycHpSnhsU3agZmCnLDBOe3+RSk5pA7dAx7njmkzz059RR36c4pf8KYgyD0IPqPSijn9OoFICCcdD6GgPQ9z+FX/Iixf9d5P512dcZ8Kv+RGi/wCu8nX612defU+Jn2uD/wB3h6IKKKKg6gooooAKKKKACuS+Jv8AyIt1/vp/Outrkvib/wAiLdf7yfzq4fEjnxX8CfozwUgMpVhkEYIz270pVPM3iLDbAPMJyT7UUV6Fj4pSaVgo/wD10d6O31piD8Dz6dqPw5FH+NFIA+lFB/Oj6UwE47GlBAznOMUUoODjr6ikAyOKOSQ5Ubiuf15/nTgECgR52+hGCKAPnZcnpuU+mMD+tGeRnr0yO9GrZcm2gowCckZo6UUzMQgHPrggEnOM07PpgD2FJSZGSM8gAmkPVi/Xn2NKI9kYCgKoGAB2H0pKPLVZGYx/NtwccE46DNJjVnoHWjtQDuVSV2EgZUnOD9aUcEGmJqzsJScHORSjO0BnZyP4mOSaKNQe+gYpOPpS/wCRR268e9MBVHzrnudpx6GoBJNkMdmFOAp56Gpt2yMlfm7DB+6f89qihmhVl82TkMSeOTyaFs9DaCdrpXHq3mQpJlTuBztPf0pxz02imwLiFXHRjmnf49MUupE7KTsHPr39aCQvb8B3pcY7c9APxpB+nb396CAAxyRye1HfnrRn1o//AFUwFDFdm2MMC3zknG0e3vSYxGRGgJA4HQCj8qUM3mBt7bQMBe35fWps0UmhOCcZXeFyVB5FH8QPU+tHuwjDjIDITyvbrR9KFcUrJ6BnHvxz7Udh1BHbPSjoPaj6mqEGTzgLu7bulIy7o8ELnryuQD6gGl/h57c0UhptbC9QSRkAc84zSZyCcYI4IprokiFXG4HtnFPJyzHux55oDS3mJ75/KjoMHmk4I5GRS0xBkdzjPTNH1oPTj9aCcdc49cUg9Dr/AIYf8j1bf9c3/lXnHxy/5LNrv/bv/wCk8dej/DD/AJHq29PLf+VecfHL/ks2u/8Abv8A+k8dclb4z6fKf4D9T1n9nX/klOrf9hKb/wBERV59XoP7Ov8AySnVv+wlN/6Iirz6rodTmzjeHz/QKKKP510ngh/k0fSigAk4Aye1ABRSkYOCOfQ0n1oEH0o/Sij6UDDpSjuD0NJSMSEZkQyMBnaOp+me9IFqx33hnv3+tIPTvjIoP3wU/i4IPGe+PrQcn7vyMOeRQMKKPvLkd+PoaOvSmIDu2NswW2naGPBNGSQGK7WwMrnOD6UUfpSC+g4RgCRkcOC+GO7OGwOPbtTSCCQRgjqKR0SRZVdRiX7/APtcYz+tKSSeSaUU1uVJp6oXLBsg5BUqVOcdQQfTsfzpMUfTmjgHce3ena2xN7hg0HpwMknHWkG3aVVWVUYqNy/eHqPajHt+dG42rMXlnUo+VwVKcc+/14FOZgiNkqGPG0cmmEAjDDA749KUru27UVWwSwHT60rIrR79BSgkg3bQVZ8AHHUcg+3OKV1+ZvunGBuVs5PfI7dqacKmA2RkZJAH5fhSkgMeApJywwASf60rO421YQkhc54bj/P+e9KRz1OM4APemzSNGiqm0Z5BZc7uenPapJRhxn7w6+g/z609RWskxgI20de1Lz34pOcdc0yA5OcjHXBB7YoPtSEAgg8gjBB5yKXOfrQGge9GPT8qSlpgHWij17c8c9aMtuYERhOChUnd05znjrSCwfyo7iij0pgHr65o69KO2fegfzoACMdeDR+NIoZAQzhlzlQRyKB24/PikNoWj8/yo/zgUUxB+Bqew51K2OCD5q859xUFT2POo227/nqn86T2HHdH0/RRRXmH3oUUUUAFFFFABRRRQAV4d8Vv+R5k/wCveP8Aka9xrw74rf8AI8Sf9e8f8jW9D4zyc2/3f5o4uiij612Hyof0ooFFAwopdpAyQQCeDTf5UAL9aP8APNJ9KWgAo96KO43dKBCk849eR9aaeOT0/pRyysHjZGU/L6N6EUueMuOCPvDkf/WpItpgRg0UDIyrHJA+U46ijrTJaDvSZYs4dFADfIwOcjHf3zS0UBcUIHZPnw4JKruxu45470FSOo/Gk4O3IyVO5T6GkChNwQY3NuI96lJ3KbTSFOShAYofUE/0pW+ZicYJ9BTfzJpcZ4I69qdle5N9LBj05FKByM/jSZUMoCsS2QWA4Ue9Jgen9KBtWDJaMjd5bMOCMHFNeUIQp2lyM4BHNO6DoPrzUckfWSNV39yeM89P500lc0jyvRixvJJdDdtwxOMAcdxUqxgRqFCfMxwu7B4BLEfzxUHlyvjzB5PQheCw+vYfrUwwADgZGdpIHH49qmS7Fya0/T8AAJOFPv0oHzckkZ+8cdBUdw7pCGiODnBbGdo9aZaFtksbuZFVgVdjznuCfTv9PpVWdrkqF4c1yYH1pc57GgZx+mKOSeDQYuwZPoMd+aDRSfl70BoH40vv0pKWgA6dqSl9OOO5z0/CjLDbsEZ+Yb95PT2x3oHa4UdjR0PHSkoEL1xSUvp+NJQAuPUUfjRht6urhcH5lIyCPT8qM5zjke1A7BSZH/6qPpx9KWgQfgfyo68EE/jRR/L2oA9y+FX/ACIsX/XeT+ddnXGfCrH/AAg0WP8AnvJ/Ouzrz5/Ez7XCf7vD0QUUUVB1BRRRQAUUUUAFcl8Tf+RFuv8AfT+ddbXJfE3/AJEW6/30/nVw+JHNiv4E/Rng1FFFeifEh9KPp07Uf0ooGH0/KilClj8oJ+lJ9KADtR+ooooEH+eKPaj/ADiigBcnHHUdP8/p+NIR6cj+lGSrJiMshOHZeqdcE+3SgDDEKMr1xn+VT1KtoA6e+cGikPHzL06MuOaCR2IPoaYWFoZmAUoqv82GBOMD1FJkdjS0CWjFUfP12juc4x70LHtijCHemwFTnOR60AkMCO1MCIFQKu3yzlMdqWtyk1azHDrRk4YFtwLbhnJxR9TR+FOxN7BijBzRtQ5D/dIOQOSaQN5iK5VlLDJUjlfY0dR20uKTg+wGS2elMkZ1DsrBgcYBAwvb8qdj2H0NMmUuvC7iCCF//XTSVy4NXsDs6xqokjY5ydq/1p0KO0oEoUEDcregPX+VNYksxSF1TOOxx+tEY/es2GKnoGxn8qHsabRaJOgDcDIyNrZGOxzS8htrdOvApBjpwFA4AGMCqhaQNu3tlWPy59DRGLehMYqbfQtnjqecfl/nFBI7fhil/i+Xv3NIcnvikjJgOo4oGdo3cHjOD3o+tH60CEpf60UUwD9aKP8APWhT93dgeoz0NAB2o70gLlR5gQPnkR5xj8aWkD0dg7mjsPpQeh+hoPFMAx7Zo6GjGcjOPekG4RqruHYDG7HJ+v4Uh20F/Wj8aPw/E0fU5piDP1/KjOPXpRR2oEdf8L/+R6tsDGY379eK84+OX/JZtd/7d/8A0njr0f4Yf8j1bZ6+W/8AKvOPjl/yWbXf+3f/ANJ46463xn1GVfwH6nrP7Ov/ACSnVv8AsJTf+iIq8++teg/s6/8AJKdW/wCwlN/6Iirz6rodTmzjeHz/AED6nn1o/XtRQMHBGfXPT9K6DwfMMYzz17elA4DAbl3AjcDyKKKLXVgu07gBhVXPTjJ70f4dcUZHUnA7eme+f0/WigfmHPtR/kUUUxBRR+tH+cUCEP3cYzyOnal+8pIHI6YbofpRnHSlB5554zSZSdhd6iQ+UeQvKv8AxEf/AK6UYkjdgpXYwG304qLyQTgyfLnIyOf0/wAaViFbe20E8Ejv71PKr6GmjVkLj5snP0/rSAHaATk9zSthSRwKTiqMhfxzRz/+ujPpR9KYB/nik4/+vS/rRQAZ59sdaKKOnXj8aAAdeRxSA7lB5BPPvml6DkgD3opAHDYBHX1oDIXCZw23JAPvj+lB59OtBcr15X19PxpNPoUrCg/Mqtjr1IHekwG3Z46CntEQg3narDhj26kH9DSKpaIEjGSd3Xg+lK66B5jRyRkCkAHZucAkZ6UuMq30/p/+qg/eJ4z0JHeqFsHSikI44JHPOO/tS96Ygooowe/FAg+p/GijH16ijr7/AFoGFA9MUUDqMcGgAHT8aPcc8/lTo2P25YmGImcISOME8Z9epBppXDYxjBqb62KcWkn3Dv70f40eh7UYPfj6VRIUY/Gj8KP1oAPp1zVix51G3yMfv1C89Rkc1XPQ/SrFjzqFtkYPmrwO3PSkxx3Pp6iiivMPvQooooAKKKKACiiigArw74rf8jxJ6fZ4/wCRr3GvDvit/wAjy/8A17x/yNb0PiPJzb/d/mji+/t6UdePWikyDnOeewH9a7D5YOp9MHnil/A/nR6flRQAcmR23Md+OD0GPSk7E9eM8d6X169O1HB5BBHTiktNENtvVh9MGiiimIPwoo6dKPrQADg8Yz6UJ2UDn0JxRQScE+nY96GNEF1LGtuUO8ncMAc4XNOVlSaHbgRSPglehBAAPtg0jwuLhnhK4brvYjn8AagWFoIJI5lV43LMDGSfLyMHqO+e1HKmtDtg4ONv61LpBHHKnPakxyeTjsPSkjJaFXkxu6NgdDS8eooOJpp2Dj1/Wl+lJkD/AOtR9fyoELzz/SkOD1/Wj60tAAT8vyjPtR9KP0ooATtxSg/N06e3HSj6UgIxkHNAAOBjqMcZoZkjjZ3wowCDngZOP54pfyoGQvy45424yD7YpMqNr6g6gcH5lIIII/z6UixoqIiDAPP6GpI1aRWdQTtzuHp7VGWSKT55FAx8uT1JHQfSkuxS5mrC9zjoTnmjAyBkKWZVXnGTnp+lIGVuQwI68frSkeoHXP4jvT8iNnqFFH60gGFxkt7nvTELSUtGD6UCCjvRijHHU0DD60UmKX9aBB3/AD/pR3/pVe43uyIpIOCcjjNSQP5kK7uZAdrZ9fWi1lc2dNqHNcfS0Dtij6UGQUdaTp70f4dqAFoGePTnJz0o+nGaM8kY4/nQCPcvhV/yIsX/AF3k/nXZ1xnwq/5EWL/rvJ/Ouzrz6nxM+1wf+7w9EFFFFQdQUUUUAFFFFABXJfE3/kRbr/fT+ddbXJfE3/kRbr/eT+dXD4kc+K/gT9GeDdQccHIooozjHOPfGa9A+JD8OtIBgAEk/pS+uM89c+1A5pgIw3R7MsvzBuD1xng/nSnk/rRQcbuvJ6Z7/Slsx3bXoH+frR9RRRTEH+etFHWigApCcMDjgDriloBPagAZ1j2s+QG6kNnI7VFHNAHJMaOGc4Vl5FOmUugwOQ46d/X61VRmSQAqQVbJLc5pxgpI66STjoWmjRWt5EUfOpycAfypxBx94g5/yKijKtcIiYAweMYGcdP0qXj1FLVaMxqXuhf89aPpmk49qX+VBkHPtR+dH0ooEAwOnFGTzxjnj3o+tFAwozjkjqcfSijvyRnHSgA9MemCPWjg5OOnJz1ooxlvwpAAKv5gjb7pK464PT+tRrBGWJIOcDPJ5/8A11JuLNtbgnO0gfePanToY9275SvbufwpJtO1zRN7RGgAKpHX736UYz0ApGmiGMSKQoGCD19aRXRvljcMQexp67icZb2HDBXKtuUk4IPvRRjHQYHoBijHPBIGOnagl2uFFFGD6UyQoowaMdOtIYUUUUxCH7p+hH6Up4NMlz5L7Tj5c1EjYU+ZuBcqU+bjryPyp2urm0KfMr3LHTp+dHrR70f4cUjIKKMZ60flQIO3+NA6+vB49aKMkDIGTnjPFIZ1/wAMP+R5ts9fLfPtxXnHxy/5LNrv/bv/AOk8dej/AAwx/wAJ1bY/55v+PFecfHL/AJLNrv8A27/+k8dclb4j6fKf4D9T1n9nX/klOrf9hKb/ANERV59XoP7Ov/JKdW/7CU3/AKIirz8MGY7iF9CBwT/SqodTmzhXcPn+gn1o/nQaOOR6gj866TwQopF37cSSeY2ThguOKWgHowBweDijGOB6Yo54z1xzSfoKYC0UfrR9Dj8M0AH+etHQHJJI59+tHQZwTyAQD0Hc/hR0pAHT6UHp78UfTij0+tMA70oPb3PH400l9yBEQpk72ZsEDHGBSjORtIwGORgHP+FIdhAcfKc47H09qX/OKQcrz3PbsaUHNMTDNH40AZYA8ZNIssbKCFm5cp/q/u9eTzkDik3Yai3sLRRjH/1qOfbH1piCj36n3o/SigA57kE89qOg+lH1oX5jgYLDrjoKWwbh9PzpVOO3HcUhOACvzhuchh0x19+350f55oCwjKY2ZF6Ft3T71OJbYjjK4G1ueCRzz/ntRMTvhwCSBtx6nJ/xp5i8sMkrKTnaQvJBHOc/pUX0RrfqxgICkl1GQcDHQ5FNLYOC6D8DS4WPduJYHG0levqPr0+tLlueSfXJqkQxuR/fx+VGR2Zj9BS0ZqiQXAZSVJGckHjIoQtsVZcO2488D04/nRmjNS0PmdrDRIwn2yKApcZUdR9KeRgkelBYkHKjPrgGk6HIz+dMJNMKUZ6j8/SkowCwbuBwfrQIFUKEHLMnRmPJ570HPHpQq73QbQzbgV479qRCkkfmRSLKm4ruU5GR1FLRMp3a5haOOnpxQOOv0oA4BP0OKZIdeaKPTqM+x5oAAPAIyfWgAx2PU8VPYnOo2x9ZU/mKgBOOTk5POMVPYZGowA4x5y7cDpyOtBUdz6fooorzD7wKKKKACiiigAooooAK8O+Kw/4rl/8Ar3j/AK17jXg/xVlkPj642kMEhjXZgZxtBzn1reh8R5maRcsP80clRQGV1yhyPcEY9jR712HybVnZhRSEv5mRINmMFNvf1zmloBpIPajqAaKPegApP89KX8aKAA0dycnnjHagcsNx79cYpAcqCQVPcZzigBfXrwcUcfgD+dFA6gdaAEpf4vw/rSZPlkooZtvyhjgE9s0oJ+UsFVtvIByAfxpMdtLicht2M5HPvS9ehI96BkFcnJC9cY3UnA6HjrTBi0dutFCtH5yRt5mWXd8qZGM4x9fak3YEm9gopAQ8auAy7hkq4wy+xFL9P1piaadmFH+cUnfpz9aWgQc+23BGMdaKKTIBGTgHoKB7i5/woH60uOTnG4YJXIyAelNBJUfKQfTIOKV0wsRXi/u0lHAVsPg+veoQrw3USDd5ZyVOSSCBn69Kuuu61mQ9GGPy5qv9lmnhiaV44gjb0fOWJUEjjHHQDvQpWTudlGa5UpPTYWSMFWkBVZAM7iOW9ial8wOodWXDcjKmozZxbg2+V1zlkJzx9On4VKCP+WfAB4wODRp0MZtOK6iZB6OPwoyOz5pc569aMmmYicH+8fqKUMwYHjaEIK8fMfWkz/nNLSauUpNFV3kachX8vaeMHOeBU0LmRORgg4JHQ/SnOiv95A3ue1CoqrhRgVTaaLlOLhaw7mik6+v0JzQQGUqw4YYNIyGTQeZIHDsGA244IAzTo08qMqDnknP1p3fmhQm5Yw6hyhYRg84B6/rSbsrM05pyjy9gpO/Pelo45yQB1zmmZh/+uikV1ZcqcgDkgdKMA4JB45zmgGrbi/Xp2ozRzxzxjpjv9aOcrgjHfI6j2oA9y+FX/Iixf9d5P512dcZ8Kv8AkRov+u8n867OvPqfEz7XB/7vD0QUUUVB1BRRRQAUUUUAFcl8Tf8AkRbv/eT+ddbXH/FFivgO62kAl0GSPerp/GjnxKvRmvJnhPT+lFRMHELP53zjquzqPrUo5HNeifFyjZB1opDkqQj7G7Ntzg9uKXnA3HJxyQMZpE20Cij6e3ajr7imAUUfjR/nNAgpDyMZI9welLz/AIjH9fz/ADo7gYPI6g9PakMD268nBx24o6fWij/OKADGMY7D9aD900d/wpMuWcFEEe0bWDfMT3yKBpXHMNwIPNIG3dc7u/vQScMcgjbwMdMdeaCOnPK9/WgOlg/HP17UUUjMqIzNuwozhRkmmJJt2Qv40UbkY7VEn3AwZkwp5xgHPWj/ADxSTuNprRhR/nNHOOcH2BopiDnHy8Eg8+nvR19MnrxRR/nJpAGenvR1+lAIK7twCZALE4GT060HIbaVPTrnv6YouFmKPmBBOOPlPoe1VEiH2Zdm77nTJ4q1tLDHc8VDDHKf3IiO7bz8wHbOc/jVRdru5tTvyuzEtWIhwXZlzjn0z2p+MXn31J2dcewpsEMnlgSSGMr02qDweaeiFGyzln5HAx+INDauzSbXNJpjtw/vr+AoyO7/AJYp2T3OR60lSconHqx+goOQpC8ErgEjofWlNA60DTtqhk5ZtiqMseCQRk8H0qFSylN7sxyAOenNTsu4Dkgg5BBxg0wQLkE785zgtmrjZKxtGpG2pLzRSdOmQD3zS9KkwGyxmSFkBK7u4prRu8hdtn384AxjmngAEkcE9aDsUNI7Kiqh3O3GB3/kKL2NIyl8KF5zzR2pSvQg5BGQQaSkZhkdfxoximtIi5y4z7U49SCD7jmmOzD0x69aOnSkxhSEO044OM4/CnHk/h3pC0Ou+GH/ACPVt/1zf+VecfHL/ks2u/8Abv8A+k8dejfC/P8AwnFruILeW+SowOlec/HL/ks2u/8Abv8A+k8dclb4z6fKv4D9T1n9nb/klOrf9hKb/wBERV56oKKwljOOwPrXoX7Ov/JKdW/7CU3/AKIirz/c3rVUOpz5w2nD5/oIWQABjg4wDsPP+NKNrLujbcM+lGVZSsi7kPYcEH1B7U3y/LPysXVjgEjbg+/Wug8O0WvMWijdmPf15wQFyQc4o/H9KZFmgoo+ho59f/HaYBRSHr1HTpS5/wB0fjQAUUmfb8jRkd+PrQAtFGPYmgnH8umaAD+dC4DDPUn0o9aKQCLwvXFDEgAgKR3459sUuf3jJsO3aGVz3PcfpRmjcezA5A+UfTJpSxPJOc+9J9aSgQvT2o/Wij19xjigA788UcDGSBk459aAMAAdAMCjoPTvQGlw6fWgkFSG+YHgg+npR60UBtqA64H4Cjhg2FOAeCwGG9xR3pV5I5P59qTC9hylUlaRlc+VGzALyS3OP1pG4YY6Z6HtTVPDHrub8/8APNH8x3pW1uU30FBxj09PWmjKjaWLDnGcdPSl9f8AOBSgFgcdqom4nX8aKOlFMAooooEFA9qKBz0oAO/Sk+tKRj736ij69P5UDD6H6UmEUfIioDzhRgZpSdoLMQAoySTgCggqxDDDKSOue9INbAfpz9abNvZFQA7RnBX19/8APeneuTgDkn0FHPfqecentR1KjJxdx80ik5ZeSVXCnjJ4zTTwaQHrjv70uWGdsrAkjG5Q4XjHAPFTZpWQKz0eglT2P/ISt/8Arqh/WoCSfvNk/wB7aFz+A4qex/5CVtn/AJ6r/wChVXQS3Pp+iiivMPvQooooAKKKKACiiigArwX4q74viBcOIZH3RRH5R1G0D/Gveq8P+KxP/CcPj/n3j/lW9D4jzMzny4f5o4TescksrIUjOOACTn19qWK5jlIA3oWJADrj3qUnPXB+ozmqjW03KRBWTbkfN82fQAj9c12pLqfNx9nNe9oy2RjrSfhiiFmkVA+FZlzyc89+2aAdwyMjPZlwaRg4tPUWij8fypOfX/x2gQtJR25I4pc/Tr60AFFJn6E+zUZ/CgNRfrRSfTmlx+GaAE+tHuRwPQUA5GR0+mKWgNmHG4Y9KBk5xgt/DkcZ9/akY7VDKhc5AIHGB60p4PH4Uh7WYiksucf4UuWxgnHsKOppKYmKeucc+tFFFABggDjH1oAyRjr0FGMEkdTgHJ9P/wBdHfPf19KAEBDKGUgqRkEHrSg49h6UnFLQDsIABkgAEn5iD1OMfyAp3GVBDHd1I/hGOppP8ijPufzpW00HfW71AgeWeMbuBipZCnmbUVgEIQbu9R/xJkk/xdaTqee9Ta7uNvSwA/KPp/n+lBznduOMYZex96PT2oHUDvVCvrcPr260lKVwTnscUe9MQf54opKU9PwoEAORSfjSn6UUAJ70tG04zzj6UfT8fegYgI7UYXrtXcOjbecUv0oxz/CR0JDZwfSgav0D6AY/KoboOYPkBwWAYDklam7CjoevT+dGw4S5ZKXYhswv74xgCORwRz3xz9eoGfapgQ67lBAJ4BpOBwBgDpThncp3MMHJA6NxjB/Ok73uipSU5NsSj0+tAZ9vzSBx2HlquPxHJ/GkPQ96FchpJ6M9z+FX/Iixf9d5P512dcZ8Kv8AkRov+u8n867OuCp8TPtMH/u8PRBRRRUHUFFFFABRRRQAVx3xTBPgG6wC37xDgDPeuxrkviYceBbrH95P51dPSaMMQ7UZPyZ4BI6tbFGRt/OCQenb/CnfaIhwd4xwcJUu449qhATLLJFJncSJExn6YJ5r0tLHx8XGWjX4j1feSACOM8+lO+gqGMMkpZkYYTIJwMjJ/wA4qckAgDnIyCF4pPRmc42eglFH1P6UfifyzQQFFHPqPyo79QaACikz/u/99UZ9vyNAC0UnB70vOehoAP8ACj6fjRnnH49Pw60UAHGGAz0wePWjPTmlUAsA3TIz+dNQlkO5CjKcYJ6jsaQ+lxSSH24GDjbgc++aXLKeOPfPSkzxRQJ6h9eaB6dB2FFFMAAJPAJopCARg9Mg8HuCD/Sl69eaQaB/FtyM7d2M84zjNGcdPzoP/wBajPpzQAHaxXeA2Dlc9jgjP5E/nSjB+8eO5pKAe449KLBcVQG2koVJHKt1HqKchQRuzK5MjBOOwxzmm5+VjkgAHv8AhR/Co74zUtX0KutwJ+Y/T+v+GaQjIKkkdgR296O/TrxQOnPbqaokM/3jk9z/AFoIxx0pcZUHt0/z+lJ7e/NAPuFFFFMQZo/Gik7c8etAxf1ooAJ6c/hQfegQnHeghW+8Aw6EMM5pefxoxxxjPYE4zSGr30DpgKAPQY6UDnjGPxoo7foPrQBRfaSxBG8E9T1HpV/K7lXB3EZz6DgH+dNwB2zjvinA46ZqpO+xtOqp20Eo70DeqqFnPA5Zo1ct9Sf50ZJ9vpUq5k0lszr/AIYf8jzbf9c3/lXnHxy/5LNrv/bv/wCk8dej/DD/AJHq3/3H/lXnHxy/5LNrv/bv/wCk8dclb4z6bKf4D9T1n9nX/klOrf8AYSm/9ERV59XoP7Ov/JKdW/7CU3/oiKvPsHtV0OpzZxvD5/oH86MnpnPt2oo7HtXQeChMDcWHBOM4/wAKU5Pc0H8qOnTPP6UBe4Y9zQFLHAJJ7Cj9e9IRuRlPRgVOKAQ750yAoyD0PFIMiNQxywGGI4yfWjpgDOAMDmjuCeo9zRYd9LC46AsAW+6CeT64pM+ppMLkHb8y/dbGSPxpefU0C0DGe1APoaORjHPPJLdB647/AE4o7fh3pgHsePpRQTyAFBXnc27oeMDHfvQM849CRk9fT6UgsHUn0BFH+eaQcoueCeSByAfrS9uPXvQAfh1oo65Hr0o68/1pgH1/P1o/nRyaMjgZGWPAJ60Bqw/zijj0opQCTxQIawLIRvZM45XqOc0rHO5se+AKRWV0Do+9W6EUozls7evy7fT35pFarR9Az3Hp6UfdU57cUfXmgDJC579+aBARtGD25/nR3oPLc0dRQAdsUjKJAA2eGB4OORSnofYUH0BOT0oGm07oCcnLd+aM/MF2NyCS+eB7UfTpR2osK4UUUUxBSEblIJIDDBKnBFGSdwCkY6FsYPFDsscbudxCjOFGTSKSd9BWYhDtyxA6u2e3Umg/eOOlHXBHcZ6UfzoStsJtvcQqGUqwDKeoPNKTkkkkknNH5Ue/f1pgHJ6evfvRndyM8+vWiikHQKPrRR/WmAVPY/8AIRtu+JV/mKgqaxYf2laqQ2WkBBA4GCOp7e1JlQTckfUFFFFeYfeBRRRQAUUUUAFFFFABXh3xW/5HiT/r3j/ka9xrw74rf8jzJj/n3jreh8Z5Obf7v80cVSgkYwcfSjp160dK7D5YQgMoBH3eQRwc/WlyfU0evfmkxQFw+pP50pHuQKM96TpwKAHbWXBK8HoSOtIpfJ8zbyMLjtz/AFB/SkwAzMMkucnJoP3SDkAgjg47UrX3GnbQUd8nAHJJPAoPHfjsc0hAOQw3AjBB5H5UvTAXIA6DtQLSwnB9DRwOhpfxJ/HFICcfMMH0ByB+NMBcnOaQ46dcigkhW2qGbHyqWxk/Wl78enr0oC2lw7jGM5pMY6cUvO45xwBgg5J9eO1A96A2CikGe+M98Cl7mgA5ye/oMdKP5UUepJAxyT0xxQAc0mKOoBByCMg+tL/npQAD+tA4AG5m5Jy3XmjIL7Nw37d232pOcr93Gfmz1x7f5NIeq0YvHI549RQKKToGPbaf5Uxbi9Tu7Zx/n9KO2KCCFwcep4o/+tSBh0/KlUlXBHUHIpP6n+lHGTk4HUn2oAaiCONUTO1Rxk5PJPeldtkbsqF2UcIvc5oHTnqecHtS0x39671FbAY46U2j8PzooEFLQTjHDHJxxjj3oxk84oABgMSGYljnBYkDjHA/CkGSOQB7A0K6uZAoYGNtp3DGeAePzpfrSSG29mJ/OgAAcACl/D9aPrz7UxB+H50Z/hOc9c9qPbr/AIUUAFFFFAB9OxpP60UMwRWZgSFGSFGSfoKASu7I9z+FX/IixZ/57yfzrs64z4Vf8iNFjp58h/lXZ158/iZ9thP93h6IKKKKg6QooooAKKKKACuS+Jv/ACIt1/vp/Outrkvib/yIt3/vJ/Orh8SOfFfwJ+jPBqPp+dGDz6Ufyr0T4gUNznrxgZHTmmqNn3cjvjt/9al9Oe/9KKVkVdh+dGPQmjpRTEKqM2duW9eM01vM24XaB3oZQ4UNn5WDDBxk0vPWkNOzuKxy2V4B6UY6gMCQMkA8im469ecfxH0FKAoJZRtJGCQOSKBaBn1owMen0o5PUmk5z049d2T+VMBfYcj3o7c0Umc7uAF42sGyW49O1ILCjGfqec0g5UE+nFKS20kAHkAgtjgnBP8A9ag9eOn0xQHQPpzRij+IemOeOf8APWjsPWmAduDjkdfr/hR+lHSikAfSj680dyoIyoGRnpnpRTDYOBR/EDuYYzx2P1pGdY42kkYKiLkk9qcV2nGQeOCaWgarUTOMZB5IHAzRSLnaN2N3fb0pev8A+ugA64XOCc//AF/0zR6fiKP4ic/dAHT1FHr+ZoDyD1+n9RRmj0x6/wBDR79qADHzh+dwXaOeOT6fWjp+AxR36njk0dKAbYA53jYyhWwCT94Y60Ud6OaED3D60UDqOwpFJKAlSnqrYyPyoAX+7lmUq24bWIz27fWjJ4AAxjGSaQuqNGrbvnbaCBnHBPP5UvSiyuPWyvsFJgZBI6dD6Uv05o/T9aYg/wA8UE4+bnAHQdaOnT8aKQB7Uf8A66BSdh9KYhfSij+lHSgDrvhgf+K7tvTy3/lXnPxy/wCSza7/ANu//pPHXo3wvYHx5ABuBVGzkYByO3rXnPxy/wCSza7/ANu//pPHXHW+M+pypNUH6/5HrP7O3/JKdW/7CU3/AKIirz4AnGM5Bz8pr0H9nX/klOrf9hKb/wBERV56QGVlYcMCCPUEYqqHU5c33h8/0FIKnHoRkGkJx24x1z/SgAKoUDgDAGfSl7Guk8K4dKQ5CngkgdAetL1zyRnuDijt3H40CD9KKP8AIzR+lMAooo9qAD8McnvRRRj1pAFFIrK6KyNlWGQRxml/SmFrOzDOOfSjpjPPag9OPzNFIBAXKAyhVc9Qh4paKKAerCj+h/KijqfrTEH+c0dOuPqaB0ooGFA60Yo69aADrj8umKMErhSFORyRnig9Of50HvmkF9bh3+tLn5xj05pCMggdccfWnfe37f7y4xQxobnqT07HFPCjYHYqFJwGzwfpSOuw4cYI5AHBpJAGYsxAZTjBbn8ycmpbuVFIdKyxxYT5nk43EHCjv+NNVmZWZ8kk4DH9f6U1MbxtTd3Zcnke/wDkU+R98h+ZR6BVwB9M0JW0HJ2VhtH1ox65/lScDPB4qzMWijoetA46H6UCAdhnOO9AOOnX2oOefmY+xPA+gopDA+9FFHamAUUUmRuKggsACQDyAen8jQAtJ2pexJIAUbiScAAd80rBkk2MjDrlsjAI7etK6vYLCUAEgkDviikIBeM7GYg5DDGF9z+lDGlfcXpmrFgf+JjbjqPNX+dV/pU9hxqNt/12X+YoewR3R9P0UUV5h96FFFFABRRRQAUUUUAFeHfFb/keX9fs8ePyNe414d8Vv+R6f/rhH/I1vR+I8nNv93+f+ZxgUqFzux23elNOQv3QzAdAcAmgKAzMBy33jnril/A11ny7eocZOPWijufrR/F1J75J9aYhM/MQVIAPBJ60tH4/nzR9ePSgBKWik6dPy9aAF7jjt1z0ooooAKOhpMqWKhvnUAlfY9KX/OaAtbcKKM/jR9Tn6CgBAzFsbV8vGQcndmlpPTtS0A3cKO4zSUvQfiKADt/Sj9RR0NHbvQAg9vpxS0d6On09aADPBHtjpQCNwzyM8ij6Uf40AIAQuGYMckkgY/ShseWwOeaWnJxIn++G/LmlsO93cRiSwzjPfAppkjTl3VR78H8qeEYR7m+6DgsRx1xUMoXcpcfusEZc8DnrzgAf5+iVtjSnFOVhr3P7neFYZPORwvbmonDKolJLNvDbQevOMfiOPxqdxHsbfhhjrn/CmwRkQKZGI5O0Nk8difwq9LGsZRjG6X9diY8nJ70UY98/QCkx65/OkcotFH09cUfjQAZ5+91HSijn+8w57cZ/+tRQAEk9z+NFJS4oEFFFISFxuIGTgZ7mgYvcUlL/AI0OGRGIUuQD8qsM59Pai6BJsKACSABk+1B4b1pCBtIYMwIIIXqQeMD86OgLVikY60Zx0PNIBhVG0rhR8p6r7fWl9KAZ7l8K/wDkR4v+u8n867OuM+FX/IjRf9d5P6V2defP4mfa4P8A3eHogoooqDqCiiigAooooAK5L4m/8iLdf76fzrra5L4m/wDIi3X+8n86uHxI58V/An6M8GClj8u7oAR2x/k0c/UfrTWUOihhkAhhyeop34flXoHxQmeSCMc4Bz14H+P6UtGen1oPTqw9s0CEJI24Utzg4PTg8/ypaPz/ADo/WgAoo9qMZpiD1x6Ufhj2o60UDCikZlRC0jbV4GcZxk4H6kClIw2D2pBZ7h6Yooo547UxCMzqpMSq0nGA5OOtKaPw7UUh30sHSjtSUtMA+n50fSjt9KKAA4PHGSMfWiij6DNAB/nmjqaKO4Of1pAHOVIIwFIK46n1zQKKUYyD6UBe4gON+Pu5/GkZgi5bggelPVWfYFGcqeOuef8A69NkA2sB97BBAOMfXFJNXLSTY1pPLIDRyA4yBjnoarlkZVQI6/M25yeTycCrG1QAeCTjIBxnvk/h61EqSpIpV12hjjKEgH6VcbWOiLir20HQqVLqcjkHk57VL9KaqnczGTezHn5adj1z+dD1ZzTd5BR3owPej60iQ/HHPX8aM5560A+/6Zo7YJZvdjkmkHQASOATz6UUUUxBmiiigAo7D6UilWGUIIzjIPFOVSRxjrgc9fYUrpLUdmJnmikzy2VKgdCSOffilpgLg4BI4pvYc+1AA8xiEYHABc4wfYd6X/CkhtJHX/DA58c22eyPj8q84+OX/JZtd/7d/wD0njr0f4Yf8jzbf7j/AMq84+OX/JZtd/7d/wD0njrkrfGfTZT/AAH6/wCR6z+zt/ySnVv+wlN/6Iirz7+L8K9B/Z2/5JTq3/YSm/8AREVefAEuAByeB71dDqc2cbw+f6Af4cehz+lHORgKRzuz1HHGKXA4w2TjOQvA/HP40n16+tb7nharcOq8d6Dyc0dGOPqPagA+nFMQUUUUxBQBkgZwPX0oooGIp3KCVKE9j2oGAxIABPUjvS/ifzo/lSAOvWij6UdDz/OmIO34UUg9/wCVGMjpn60DFo/lR+lHf3oAKMnKkOV2nJAGQ3HSlA6HDEbgp29s9/oP60np9aWj0GrrUVMB1z0HWmpvESCZg0gUb2UYyaXr/SjvQK+lgoyB6UdKPb+VMAx+GaT+HnjNOAyw5x9KauSqnJ+lADlxvHzDOfWmM7ouwfNzkjGMVIu4ttB9s+lNCrIsec84Bx3paX1Ki7MkZ8IANpVl3F2di4Y/XtTQ+wfKAR/tY5oZy7FvwHPbtTSyqCzkKq8kntURikgcnKQ4fIMLwc9Rxnim57daD/kjvR36Y9MHOatEiYGCO3cUv1o5+bO0jPG0Hgeh9+tHOcfjnpQDCigFWCsjblYHDDoaKA23AdOaKKP73XhiOe49foaYCc8YYjBzx3pcZP40dKQgFSp+6R2NIBcYo6Z2gE44HTNIAFUKgCqOgFL+JH0OKA6gQSUy3yjO5CMhuO9KW3sWbqeeaSiiw221YOaCOmff+lOJjSP940iswOGiUEqOmeWHNOMW2CPY0hVgSjyKAzKT94jJx9P1qOdXsX7NqPMR4/yKnsOdSth/01X+dQYIXjmrFh/yE7b/AK6r/Or6ELc+nqKKK8w+9CiiigAooooAKKKKACvDfiv/AMjvJ7W8f8jXuVeG/FcZ8byY/wCfeP8Aka3ofGeVmv8Au69UcYepo7NjG7B256Z7UuMDLH0woUknP40hB4BOfpxXXdM+Ws0lcASSNwAbbzjpmgdKD6/nRyTjGaYg+lFFAoEHHWj8aKSgYfxY2nGM57fSjAOMgHByMjofWl/zxR9OtABmij9aOfagQevSijPP+TRQMKPpSAe2PpS0AHWgHB6444OOh9aUDcQO/akHIHDL6q3UUvIPMRchACxfCgFiOT70vzbmyV2bRtGOQe/NIOn9c0tFh3d2FJ/nml/Ojp1pkgDkZH6Ud+OaOvt+HNHc4YjigYmRjJP602aZ4miMbDcxwvAPTr+lPyR0Of602aEzcBwsgwVbbnHOOnfilp1Lhbm1GW80qMVfa8gBZA7ELk9cgcfjU24biy8n0zwKihj2Ipdt0jAFmAwPYAZNSZ55oaXM2i6s+Z2RH9lgabzmiXdjbhT8vHt0qTJ457YpAVIwrKxUgMB2OM8/nS9O2eeucY/xoIlKT0kxPfp7ij1peeMbcfxDByeO2KOQefxpkh2NFHGSu4Fgu4qOuM9fzooFawnf2xj6UtJS+g5xg/QdOP1/SgNwFIBwASWPqe9LRnuKADHANB7f4UgRFdmVcM3U5ooD0Fy3zYOw5wrA57Dn88/lRnChT9WOOvvR+Z57n2xRSsO+lgowe/APFRTytDHmNN787VJwM+maSxknnlm+0x7GC/dWTeqDtjOOc9se9D0VzWNGUoufYmpOn+JpSpDZzzjoe3+eaTqORj2pmJ7n8Kx/xQ0X/XeT+ddnXGfCr/kRYv8ArtJ/Ouzrz5/Ez7XB/wC7w9EFFFFQdQUUUUAFFFFABXJfE3/kRbr/AH0/nXW1yXxN/wCRFuv99P51cPiRzYr+BP0Z4KB1+tLQqnntz6dOg/maO52t0OM7cZr0Lq58XZ2uBJy/C7MDaR1zjBz+NB+8KABj/wCvQM4x+BoE2FFHOMkUUwD2o4NFFACE4UkAsQMgDv7UvQ/1oo+ufzpAIoCjCAKPQcClo+tFMA7flRR0z/jQfc/pQAUUfh+NFAg/r0o+n60Dv+tLjHUNgjIbt9KVx7ic7zhzgqAEIHHOc0jb9p8shW4wWGfrS9/wo9/zosh8zvcCeT/SiijmmSGRnHH0oPSjP+e1B6Hk0DDvg8cUDlW2sM4PfNHP94n69qUklDk8fzpAisJZ3VW8xlG3aGHBXPHbnvVgP5kCrIEA2jaVY5YY7575zUaxPGcq6naMjKcd8d6ei7I1XOcAA05KLd0dFSorWQz7OjMFIIHb5skU4RqMbdwHoSetOyoKgsqljhQeMnk4/IUf4nii7MnOdtWHXrzR+OfrQvUbgPcZzSDdsXeQWwNzKDgnHUA0iRaKQsqKWkYIq9WPQc04jazKQcjg0Cs7XE7cUUUevfjt3pgFHOQSxxj7vaiikGwBc/WikZFkAEgyAcgZpTTABn5QoBGee2B/+vFKCwcsW3DA2qR93r0/Ok/Pr60f/qqbXHdrYP50d6P8/Wqj3MrxEIjIu7GVflh6fn/KrSb2Lp03N6FvHrR7+1OY+YocHbuAPGMZ9KaeCBjjpmpTuQ007HX/AAv58c22f+eb/wAq84+OX/JZtd/7d/8A0njr0f4X/wDI9W//AFzf+VecfHL/AJLNrv8A27/+k8dclb4z6bKf4D9f8j1n9nX/AJJTq3/YSm/9ERV58pw24clT+Veg/s7cfCnV/wDsJTf+iIq8+5I4UNkDkHFVR6nPm904Nef6CBcFeMsF2htvJH1pwBJwBk+lJlS2H3KO5K9PypXuQqrHbhg2ctKDhj6BfT610a7JHhqLm9QxtYA5yV/ln/GmkZZSWYbSeA3B+opw3sriWRySRw7Z6Z5P50mCBhW4Hbb/APXo9RXs9GFFHPpz3waBz0/KqJCiiigA+tFFFAgoFFFAxB2+lKaKPXoOe3pQAUYz05opCARgjvnrQAvfJOeAMHtijuPrRR/nikAf5FFFFMQemAMZ5yegx/jRRR+NIYUdSVPHOfwo+o/Kgct+FMA6cn0peiR/XPH4/wD1qbgEEcDPFOOGYMpyq8DjHNSxrRCZ6dOmDR0P+TQeSOOc0oIDDPTPOafQQmUbOx1bBwdp6GjrQDJsxKYyxY5MSbBg+1B5HIGPc0K9htJPQCASMgZU5B9O39aM88fWjrnvRjPJIx1NAgPJFFBBHse3NH0pgFHNH6UjEqhZYzKQOFDBc/jSBK7sOCsRkA4pKGRPNV9oLqeG79/8TQfU8UBp0Cij8PzopgFFGaPX0oACquOQSccc/pTnbfnDEBlC5HBwBgfkKQZU5I6c00DChfQAcGpsmNSa2Y7JOM/NgAfWp9PGdQtuPl81QDn3qvz61PYhTqVpuH3Z1ZeSBnNFrKyHF3lqfT9FFFeafeBRRRQAUUUUAFFFFABXh3xWx/wnLgnrbx8evFe414d8VTnxxJgA7YY+Mc9DW1H4jys1/wB3+ZxbDdncNwOOCuenSg+9BOOqsPTHIqK4njiVNnzljyDlQvGevX8q7EuyPmYxlUkkSspVSSp9vzoYdRkgMCMg4IrPWxt550k8nLbwzTHHUehrQK4bIbGfQf1702ktCpxjBqz1/rzYgGFAyTgYyTR9aOe+D9OKPrx9aDEKKXvRQAUUlLQAUUUlAC0UUnpwMfXn/PWgBev0ooo7+9AgII4yRzk+9HT2pAAOBwM5paBsQdB9KP8AOaWjrQAfhzj160c8ZGD3waP8/Wk6f1oAX60Zxg9uQfyo/UUhPynOe2PzoAXHX8yaVf8Alof9kj07Uh6jjk+tKMEFVPLHnjoPX9Kl7DjvcQElfqB1o9z+lH8I44xwKB2z9aoQblyoZ1DNyFPU4ozg0u59y/6vywvI2fNn/e9PakGfTPuT0pK42l0Dp16cjmk4VcdlGAPagdPTk/zpevFMQZPQ9qPT6UEY/A4ODSfzoAKWj6ij8aBAAWOByaCCOtBAcMJIsLuICswbcB0bj19KRRhUVeijApXKaS9QooBz05+lLTEJ9aWjpSUAI6LIu1s4PPFEUYiVgrMWJBy3JzjH9adg9qDwT+ApPXQtTklZMMkFzuJDkEg9uOg9skn8aACWAA5+vWkpfXPQgg44OMUWtsTdt6nuXwr/AORHix0M8nf3rs64z4UgL4EhVRhVmcAZz3rs64J/Ez7TCf7vD0QUUUVB1BRRRQAUUUUAFcl8Tf8AkRbv/eX+ddbXJfE048D3PvIg5+tXD4kc+K/gT9GeDZ+Xg/eIOR3wQw/UUADJwAMnJ4xn3o5wMJwP7uP5UmUIO4sp7ZQ816Gx8X7zVhQC3QZ+lLjlgOxqoqpcCPbBs2qBhG5Y9y3+HYfnUkEYG8cdfrVW7mk6cY3VyXHzs+5iWAG3dkDHoO1LR8x/iB+oo/Dj2Oakybb1YUlL1GRyPaimIKOlFFABRRRQAUd6KPpjOOM0AHt3ooo+tABjvjgUdM8knJ5PWkwNwOOQCPw/yKWkHQPX0xRR6UUwDqPUGjJz04x1z1NFFIAoHP40fQ80Z9qYCDkAnt2pT6dyRQMENnkc+9AxkbiB3zjNIfUc3+sIH+z7g03kk+/NL6t3bn6Ck/iOOBSSBvUNwAJJCqoyS3QYoyCoKsGHYjvQd2x1iMYcqQpkTcoz7d+KUkkgn05AGBRrcNLCdaOM7sYJGCfbrR3GQBwaP1qhAD19OlHr9KULnHqenvSf5NIA+v5UUfhRTEFKVYDkHFJnBUBCwOcvuACcenfNIFRXZ0UBmXDEd+c/4flU3Ksrai0Un+cUv+eaoQUd+KKKBBUSQmNgQ54PHHSpcE49aMfL07jrRfoXGTjsAG0IA5AjYEDsfY+ooJ655/GjrzR/nkUrLcHJvc7D4YA/8JxbZGD5bkc+1eb/ABy/5LNrv/bv/wCk8dej/DAL/wAJ3bt/EYmUnJ6Y9K84+OX/ACWbXf8At3/9J46463xn02VW9g7d/wDI9Z/Z1/5JTq3/AGEpv/REVefd/U16D+zt/wAkp1b/ALCU3/oiKvPq0odTkzjeHz/QWOQAhoyrAHHykEZFL5jKsQdndgu3ftyT7mmkk/X1o4OQc4rdxTdzw00KeWGeCD1pMk53KqncQAp7Z4oyc/N+B9aKdhdLB7jtRjuDz2oopgGecdDRR/KlJYIAjBSGBJ2Btw9Oen1pMaSbE9KO1B9qOlMkPTNAo+lGBz6AUhhRRyevWj+VABRzuUBcqc7jnp6UUD6H8KGCDp9ewoozkngjAwD6+v8ASgsi8u4UEgDOeSaB2bdkFFB3BTtK7scZHAoOMnHOKYgoIIOCMH0oBKsGHUHNIqrHGEQYVRgCkGlhaOuKKOccg/gc0AOB8tRKvVWG0Yzk/SlA3W8Z3EsCRJk9+ufxzTjEXQoDk7d33Sccdx75xSInlsEY5R13dQCeKycl31NV8LVtxhGM54pO/HUUpTB+6AecA8DpSD5lyeM/w54HFa7mQf56UHFB6dSPxoOdyhUJBPLBsbf8aBpXAckdvxppAlChoAIsnekw+YgcAj8Rmn96QHJYZBK8MAR6dKl6lQlyptIOmAOB0ooPTjsc0VRAdPaijpRTEFA9RRR9aBgKMUc/5NFAABlgCcc9qASVBI2n0znHNA68Un+FIAZchcMy4kDnafveuaUnPPUUUf5+tA229xKsWPOoW4/6ar/OoPf/ACKnsf8AkI22f+eqc/8AAhQEfiR9P0UUV5h96FFFFABRRRQAUUUUAFeHfFb/AJHh/wDr3j/lXuNeHfFb/keZP+veP+Rraj8R5Obf7v8ANHFZUMBld2MgZ5xT2/eK6yHcjIF2FQQOvI9+abnt2ozgj1zxXY1c+XUrO6FL71BwwBHAYYIpDncowCm0ksTznPT8sfnSdF+XlfT0pf8AOaLBotgo6jB/Gj60fWmITOOvI9f8aWge1KhCyKxG5QeVNJ6IBvUUv+FIu7Yokfe46sFC5/AUtMHo7BR2P0oo7UAFH+RR/L+tH+fpQAUc7TtGWwcA9zjj9aKOfQ0AHXGRtJAyM5waOvP5fSjPGNpOevtSgbnAHUnAzSASkoVldVeNwyMOCAf60v8AvY9gBTBpp2YdaMEDJHHrRSYG7dj5sAE+3P8AjQGnUWjPGO1H04o59PyNADWO2NiP4VJBPfio4JZfMTe5KuuFLDG3ALfrjH41Y2gwuWYqMYOePyqtFGVPmGZXVOY/3ewYx6k8nGf1qbqzR1UUuV6FjbwPTFJx0Pf/ACf0qSVBuyFPucZ5qPndjhQOQQevH6d6E7o5gPXn+VJxjmlHt/Ok/hOAWIBIGeT7e1UIPX60u5lbEaEuELK7fcDYOAfqcfnQuSoLDacZKk5x7Z74oJwVzgbjwCfb0qXqrFx0ltcRY0jXCIqE4L7RwWxyaXrR0OD1HqetA4/CqRMm5O7Cj9aTFLQSFJxS0UDCjr/+uk+n60fX9DQAflS98Y4x1z3pOKWgAGNyk8EZwfTPWmxrsjCbmbb3Y5NLSmgd3awlLSfX/wDXS9v6GgR7l8KhjwNH/wBfEn867OuM+FX/ACIsf/XxJ/Ouzrz6nxM+1wn+7w9EFFFFQdQUUUUAFFFFABXJfEz/AJEW6/3k/nXW1yXxN58C3X++n86uHxI5sV/An6M8FJABZiAAMkk4GKduOwhHK7sYZcdKTJ696P0r0GrnxW2o3y4g7KqOu4buM7cdMZ9e9CoI0cxKC2MhWPBNO64IOD2PtmjPqMH0o1tYtzbYfgOnaj+tFH4UzMMc8fiPWgHNA/z7Udfb3oGFHrSksWXkBAm0oEHLZzu3denGPakpJg0kH86KKPSmAf5/Sij0I654/wA/SikAUUdKKYg53MCuFG3a2evHPH1o9vzoHuDRnIJwVyelIrzCijK5C7wHK7gvPTOKOeORjvxzQKzW4UAE9Bn2o+nekKhlKsMg9RQHXUXv70UHn/OKTn2P1OKYC+pPPr/jUTtIJSiswGwZC9/WplBLgfMCT6UySNmlZkkyFwuFQtj2B/z3pXSeprS3FjYPuMZdlDYXd1IzS4xiktlVoHU/MVc4GO/U8UpGwZCjPGQTjHrildXshVF77Dtx0NGf5UEdiScdKO/JPT1pmYZHFITtVm2s+BnanJPsKUE7yNhCgDDZ4b8PalGe2OO+eKTZVrNdRpQM4aSKM7MGM/xIcHcD+dLz0oU7kDDkHjII/Oj0P4HmhKwTk5MKOlH1o+lUQH6UfWiigYdKKKOfb86ADFHODgZOOBnFHX/69A5APUdqAA9x2IpNuJEYMwCpsCg/KPTilopWGpNAaKTp9P5Uv0piOu+GHPjq1/3H/lXnPxy/5LNrv/bv/wCk8dejfDD/AJHu27fu3/lXnPxy/wCSza7/ANu//pPHXHW+M+nyn/d36nrP7Ov/ACSnVv8AsJTf+iIq8+r0H9nX/klOrf8AYSm/9ERV5964/KrodTmzjeHz/QP50UH1/AUV0ngBn6cnpRiijGeo/KgYUfSjP1/P+lJz3z+AoAX04HNGB2x+dH/ATx75pMr1Py+/INADsHDMOgGTmlaNgpYA4BwTjofQ01lV4mTHmKSGZSu4cfXp9KbhlkDqWRyfvoCKnVlqKaHqu5gB3/yf6VJJEIWVJnEcjYYRsDuOenb+dJh5vkbbGzZbazbQwA6/XB/HNNdElvDO1xk/KSp5LYAH0/Ws+Zt2uaRhFK8xGQqxDj5gcEUmPx75qSc7pC4ydxyGfKj9eTUZx3+b68D8quLukzFpoMg9Pm9+350Y9f0o69+PairEBOOp4/lQCRR2P0oPBPpSATt+FL7ijnI5bGCMZ4PTn68UfzoAKMelFFMApQuQWx8o6nsKTp2yewFGF3q7BWcDC88L/n1qWxpdx80ZZDJHkFiu7J+9gEY9u1Ojn8me2sfJyMYfDEs2ew9hSRyEOpzgK2c+p9fwHSlE7CJV2qvy4IUYyD1HFYuLa5WjeNRLfUSVWjmcB9yk8AnGQKjBOPun32kGgbhwSG9MjJI/xo/XjvWsVZWMZPXUTd6gj6igsBzj8hS5x0OKXJz1OTVE6DVEW92z5ZY/Mw74GAaFbGPNYEkckLwSetOz8wPfPX8KGXzFO3745zmkXzX0YYB4V1b6HkfhSduaSDd5yBQASQvBx1pRjc2AfvdM5NPZ2E422D8qKKKZIUdKTAIIIBB6g96WgAo+tHtR3oAKPofwpKX60AHXrQDkev8ASj/PWjr15+tAB7g49xViw51K2yP+Wq/TqKr9T3z2NXNKTOsWglU481eQO2f06VMmkmyo7o+mqKKK80+8CiiigAooooAKKKKACvDvit/yPMn/AF7x/wAq9xrw34rY/wCE5ft/o8fP4VvQ+I8nNv8Ad/mcZR70Y7Uda7D5UP0pO3FLR+FAwopPoD9M4pef880AH1waTAP5UfgT9TSnHcfmKAADPA69sU4RszbRy3IwO+DzikVlDBg5+XkdT/PrUXlrtICAgEk7V98nn60tblqKa1JPXPUUTf6Pb+fIDsLbFIHVjzj8hmj7SYox50h2gf6xjyv09agvISGRjcR4jOQPMyoJA54zz0H4e1Tf3kmbU6SbvPYljkSWMMn3fQ9fxp2B/wDWp0UYjtQmS7BizbVOMn36U38cD0Q/1/wpqV9jKaSl7uwHAOD19BRz9PpQPRQB7CkqjMX1x+tAPcf/AKqKOv17ZoAM560UdVIBZe2VOCKDz1oAKKKKADBoALHAGT6UYx1wKRlV0KSDEZHzDOCw/oKTGlqPeHz7d4BuDbgRg/dPv/hWa73McijZ5ZGC0pbjIIxj8e/+NaQcgjbgddoHG33ofy5Yyk0MUifIuHQHjcP6GpjJxequjppVVCyepHFK06B0kJKkbyT/ABD+Yxj86dk56Ak+jDmg5zuGB/eGP1FHJ6//AFqaRlUkpO/QTdj+FvxWjcMdKXvxxRkkZJ6c1RloNOxyodc7WyCRjaQOtMmk2MgV/MDMFGeo4JPP4VMSSMEk01lWSPY+cEcY7HsRS6mkZrZ7Ef2lQ370eWCcA9jUuME54BGar5yWjkVSw4Iz/KpoyWjjL5J5G4nOcVTstipwVrodSUvPofxo/wA9KRiFFJRgDOABnk4HWgBfrRSUtABSfjilooAPrSf5waWj/OKAD2P5Un60fy9M07aSPull70DPcfhV/wAiLFjvPJ/OuzrkPhgqr4HgC5/1jE59TgmuvrzpO7bPtMJ/u8PRBRRRUnUFFFFABRRRQAVyXxN/5EW6/wB9P511tcl8Tf8AkRbvIz8yfzq4fEjnxX8Cfozwb/Gj/JoHTrmjp/WvRPiAo9uuPQ0UdaAAUUfX9KOfx9zmgYc9v1pDjvgUvPv/ACo6dQf50AHANKFIHP3Tn6jFNyoPXafQZocKdh+VgoIBK5xnqAaTuVFX3HujJjcOCMj3FNPCE9Qo7U1Xa3ZipZBj5lxw2fUU2aZZkwsqqxGNpbG32HSlqaRptvyGi7jMhUBgQcDI461NgdqqQRgJtOTtYKBwe4JPXP6VdYYYgjaf9rr+VVKydkOtCMX7o3GBnoPUmgH0/M0cZz1Pqxyf/rUfXmkYBj6mjvyevSiimAEnGKOlHTr+Bo555Y5PQnp9KQBRRRTEH0o6daMZoHB4AJHr0FIY+PMTo+CMMCpweT7etUriMwTOAriJmyoBzjn1q2u1GYpgO3Luev8A9b6U7fmMqQNrKF2nnA7f4/jUptSub05qBBBM8v2nHmYQrImDwh8xRz/31UmGVQrHdt7FuRQ6RtuwgQ84K9iDwaAT0JHH90dP/rUJK90VVqKa0DP+y3tgAj9KTdzyMfUUv4UuSOhNUc2ggfDL25449s0xFRIFWFhFwMJ1HJ5GKkBI6EigHBOOOKLFKVtiFZScgIMZ6k//AFqcXbeBtUg/xK2RTUTMG4c8/MD35/8A1ULlpVBXg5JAPt1qtDVqLb0JT1o/KgfdGAelFIwCiikwDjIBwcjI6UALRR9aP50AFH+c0UUAH45pPelo/T8aAD/OaPcd+3rR/P1BwaAD26+nrSA6/wCF/wDyPVt/1zfr9K84+OX/ACWbXf8At3/9J469L+FqD/hNImZSGEbY/KvNPjl/yWbXf+3f/wBJ464qrvM+oyr+A/U9Z/Z1/wCSU6t/2Epv/REVefeleg/s6/8AJKdW/wCwlN/6Iirz7nscAjPFaUOpy5xvD5/oHTrRn3o6duT15xRyeDmuo8EPoaMGjg9vzowPQUAGKMH0pMDuMD2JFKP91fxJpAH057cDpTvusd7CP69fypoGGxkle+3p9KFA5wgAz8vP9KTHZbsJZHkYLHujjHQvwT7+v4U9JXLFo9znu2cD+VN3MRgnK55B70E5JJ70uVWtYtzv0JViE155l0jSJuXdEcAMfTceAKchlmvLu1uYDCsO4nCkeX6AeuagDbefT5vyIP8ASpJbmeWBYpZXkWEhkVmJAx/9asJ05N6f8N6f1/kbU6y5eWSI2kBx5iiN+4Ixn3/Gkwc46EdcDpSlskqCSp5GSf8AINJjA4zj0xkfl/UYrdaIw0bDvzzRRhsZwceq/MP8RRjmquTawUUUUyQ+gz7UZ/zigc9Pzo9sZ5656UhgeO2KME9ePp3oHH/6qPrz9aYB24HB/WjJHPej6/nRSAQj5CP9kj9KceXJHXNJRQAD5uCO/wCRo5xnrxSEZB7HGAR3pSRu5xk+np/k0D1An/axxz7UfiaOn9aPr+dAgPT8fSlBOc5BOc/Sk/Wj69sfjQA4rvyGB4BAK9jj/HFNVvM3PgnpliOpxk4/OgA8AdSRSk5dz/D/AAj0Hp+RpW1Kv7rQlH6DHekIHYA+1KePuhevcdqZIm4HuOfeloJJz70Dk0wDt7UdwME5zyBwPrSKVdd6FtpPWl59c+9LcdmnZifTrS/QUUfr9aYhGeKNV82ZQffnj1OPrSkYJByD7Cg7WA3qHC9NwyB3oJJJJPJqVcbaa03DHT5Sfqas6cWTUrZlCq3mqQAMk8iq30qew/4/7fH/AD1XOe/ND1Q4vVH0/RRRXmn3gUUUUAFFFFABRRRQAV4d8Vv+R4k/69469xrw74rf8jzJjHFvHmtqPxHlZt/u/wA0cV6Ht9aM+9KRk/Mc+9GTx1H0Oa7T5UPqaKT8zRgegoAXBox7Um0en5cUYHYZHfJP+NAC4/Pt70uDtBxhc4y3AppHcYB9AT/WlwCwO3Lc7mJ5/rn9KQ0kRXbblQRl5PmO8oOB7ZNMtY9kn3SFIwI1J556nHv/ACqyGK/cO327CjceB6c/jzRsrG3trQ5Uhk63EkqEozAnsAx4qvChs40H2VGM0jBgF3BuSAuB04Gfzq0DilDYBDAMpOGUjg4PFTJO1raGtLE8is0BIiklTZmINlW6hSQMgHuM5pOMZBXHQEevpQv7tNq5GwkcHqOooxg5GQfVTj8j/Q5FEVZGM2pSuByOD+RFJ9KM4B9B1x8p/LoaUHcMjkfTFVcycWtQopO3NL9KYg68/lR68Yo/Wjpg9/SgA9wOPU8Uc9gPc0g4x/8Arpe3rQAYwfU+tH+cUnrjpnpS/WgA6k5+lB5GD3o5xz16migAycj/ADmkxjp0yOKX6jIzzR06njOM9/QUh6sOR3x6e9J16MaXrRnPv7UxB6c/mKQHjGRgfrS0c/hQAjoJFAdQe3uB9aREWLESbyCxIDc7eMnNOHX9OnvQclU7An5vfr/jUmkZO3K9gP3iMY9qMelBxntQAARlRiqMxMjJGRxRkHoc0AttG7G7vtGBS9aAD6Uh4UkAnAJwo5PFL8pkVOd+3dgemcUfifpSHZrcDwaPwoySOaT86YhchcmRwqgd/wDPWgFWUFGDD2HSgcdehGCB6UcBdqKqgdlGAKWtyrq3mJjPYn68ClA/2VHu3aij+fUZ7UCue5/CxmbwNDu5xNIAcYyM12VcZ8Kv+RGj/wCu8nPrzXZ1589JM+1wn+7w9EFFFFSdIUUUUAFFFFABXJfE3/kRbv8A3l/nXW1yXxN/5EW7/wB5P51cPiRz4r+BP0Z4N1J/xoz7/Wg5wRn8KOnTpj1r0D4kM8daPoaPrn+VGPb86YBg0UYHdR+FJgen0G40ALj/ACaVQSQFBb0wKTGQRhQO5yf8aBggiTLL2HakNJCkgIdz4JB+VBuYnFU1w/zOdjKmOVPp6Yq2PlUEja2OcHOPYU7e2cnnA49qE7GsKnIrJDRJIlupVHI3Kx55JDD/AD+FRGNjNF5cMk8mWKoYzyOfzqXPA9hSFQxXOcrnBB6UrW2Kp1lF6rQVMzael20QEqzBE+XHm8cjHoOB+JpSys5CAA/3SP0pnlpvRyp7qTuPBPIP86cTu4bnHH+fapjG39fgOtUjNpoO2QePUCjig9eTn/eyfyPUfrSFtuNx2/73IP41Zhy9haPSj6UUyQo6ds+/pR05NH6CgA9up+lH+cZo6+3TnPWikAY4y35A8UfTjH6UY/PPWimAdsDoeKXPNJRSAOme47j+f6UdcHv60UfTg5OQe9ABgj88fSj/AIF34o69Dz/Wjp049KA9Q+pP5UdMcjOPSjv6fSj6c0wI0hdThZTtPXinBCGEzu27PYAAjv8ApTiMjB7jH+NOB+bpzgn6Gk2zRVHe40Y8sHaVDdMjB/GjtQPuDdye+aTA9Ae1BD3YHjqcdhRkHoQfxpeQeMAY7DnNGfWgQcetHpnrSMyxxs78KoycelKV28fMPrQOztcPXgjGOSODSduOaXn/ACaPxNAgIO3glfcUF4zJtEilsdB6+lH+c0uRu3lRvxjcevTHX6UncatbUTj3+gFGOvydfU/zoo7eg68UxI7D4Xll8cW4G3BjfIUcDj1rzf45f8lm13/t3/8ASeOvR/hj/wAj1bdPuPgenFecfHL/AJLNrv8A27/+k8dcdX4z6jKv4D9T1n9nX/klWrZ/6CU3/oiKvPztYbkOVOegxXoH7OvPwp1b/sJTf+iIq4BiRxt27eMZz+PSqo7s5s4+x8/0EUDIB6U1S3lr5gCuRyoOQDS/jj8aMY9RXUeB0DnsM+lH5D9aPrzR+dMAoox60UCCjrRRnGTzx6DNIYUD+XrShT+VJ065FACH7p+lO6scHrSe38qBnBwMcE5NACdVH0H/AOulHPSjpgZwAcdKMDq3P170ADqX2mIgMow53475H40fOEAchmH3mHU0q43KG/GkBYqC6lSDjrkNx1+lLZ2NOZtW7B9R154Pp7UDOMMDkHFB6EnjoKCMnHf1NMi4Dk44+lABOABye1HUYbFAIVhg4OM7c9qBCsCrYYEEdiKSkVVSNURQqIMADtS0B6BRRij9KYg649c4o4IypDDJXjsR1FA9u9B6fKAOpCj5eaWo9A+lGfTkGlXlh29ec01GV41ZDuVlBBx2oCztcUe3I9PSjGOxH1oBIII6jpSKqooEahFHYCgAPC5xnHJ59KUjBxnpQ27awj2q+Bgv0HP/ANalYjcdgwvYelAdBP7p75pe78YwR/L/AOtSAZK+uQBQDkEjoTn6UD6BR0ztAJxkAnjNHsfpR1oEH+TR0oopgBPU+vU+tFFH6UgDp7+nrR9OaO9Ix2ozlGcqMgKOaBpXdhaO1KwI4O1sHqOMikGCOOlAgAzgDPPrU9h/yEbbP/PVcfmP8agFTaeoW+tFQYVZEAA7DNA47n1BRRRXmH3oUUUUAFFFFABRRRQAV4f8VdreOJFB+dbaMkYr3CvEPir8vjaQhfvW8fzA+meMYrWl8R5ea/7v8zifU+1HzeY2QAm0FWzyT3yKOe+PzpMeuTz612nyooo/DH1NH+TR+Y9qYhMZ6nNLRRQIKM//AKqKPT60DCjuPpR3OM8cdKCD0waACj/E0maX6A0AHIbGewoHoOKOQxoxkdSfocUhkVzEZYfLAViSMKT1pIFmicKVAjA4RjkA+2Km47AAdOB1o5yBtJUg5YNjbgf44/Wi+hrGpLk5OgDI/Dnk4/KjkHoduM8Hv6frR1P9cUDpwc8+tBlcM/8AAfTNGMUdO/FGAASTtHc598UxbilWC7ipwehxxSUYG8vj5yoUt1yBz/Wikrhp0Ck//XS0UwCjjIGRu2k7e5AOP60Ue+Fz0zjnHp+dAKwlL9Ooo55yPod2f/1UmVLMu7JUDIx0z0pBZi989M/rRj2PvR+FJtUtnaN2Mbsc4znFMBf84oxhenPTFA9/xoycfNtzkkbc9KXUfQB+mKUZ/d/XP6Un1/Ggfw+w/nx/I0Ag7e1IePrS0n0piF7nIAAI2kHqMd/xooooDcM8AdcHI9qKKSgBf8mk6/0opetABR+lAOd21SqhmXDg546H6HmkHXHQ0k7jaadhe/8AnFGD36YopAACSAASME0xHufwq/5EWL/rvJ/OuzrjPhV/yIsX/XeT+ddnXn1PiZ9rg/8Ad4eiCiiioOoKKKKACiiigArkviayr4Euy5wNy9s9662uT+JYz4Huvl34dDtzjPNVH4kc+J/gyv2Z4My4JHvTX3BT5ahmBHDHAx3pzEnn19aT8T9Aa9DWx8UtGDfewD+lH4fjmjpx0o+v5imIOfp9KPpRRimAUZ//AF0UDrQIP8ijtSfwjrk8Dj2z/SnYOMj+VIYnajuKOlGR7/hTAOdp57rn/voUE9/rQQSvoMj/AB/pRk55OOO1IOguP/15qpIjMzFYvlJyMEc/hVnA9Mk+vOKXPUgZOOlNO2ppTm4PQjhDLEuVK49P61I2dpIHI5GGzmjJ44KkgEqTnafrQO3bPbpile+pMnd3YfgSe+aOvfP0o9x1/nRweTg0EiqrOcKpJ9hSUjIkkbxv86kgFSTwQc/zApzEscnv6UBYSiij8KYBQSBkscADJJ7UUcYIIBHQgjINIPUDx9PWig5JHAPPPOMD8qRmVVy7bRkD86ASb0Qvse1GM+9B4z7elIQrKQyhlPUEcGgBfzFGOnHHQHPWjv7HtRk7l+7tBO4HOTx2oBBSr9/I54pM8c80dM+uDn60MAH3V+lFGOAPTgGj/wDXzQD3DnjABGcNk9B7UUUUAAOOlH6DJP4kkn+dFFABR9fzo/xopgFFIeCNqnc2fmwcDA74pWIHJHH8qVx2egfr9KMZ6UfrSMqsuGUMPQ0xHYfDD/kerb18t/5V5x8cv+Sza7/27/8ApPHXo/wx/wCR7tv9x/5V5x8cv+Sza7/27/8ApPHXHW+I+nyn+A/U9Z/Z2/5JTq3/AGEpv/REVefntkhvTtXoH7Ov/JKdW/7CU3/oiKvPxwWxt5B2hugbHBp0epzZxvBev6CZB6/rRjHUUZzwxBPr70YwOCV/Guo8EKMdP85o6/xfpSHIXIUE+7Ef0pgheAOnfHT/AD6UmV9V/OlIHX72KO2MkZGODjFAAzBYs+Z5Y8xfmPG7r8uT6/0pSDuOeOfypDnH3VZhyu8Zw2OOe3Wg8ZPbFSlqU3dJCEBlXd/Cdw2kjn/IFKeST1+tHBAYfgSKAylnVXBZDhgD04p6B7zXoHbmg9G+VhjABJ+9QO1GSB6ZP1oEgPXn8qPrz+FKAN2MnBPPFNVhJCjhWXcM7WGCPagLaXF53L8xAGcqOjZx1+mP1o+tH40UCuB6f56UH1/pSZXgblBckKCfvEDP8qU8E5/yKB2YjMiI8knCquSQMnj2px4yByKQHurEd8jqKOTnPXvQLoH1/WkA/wAetB5U/lSnk0wE7Ucf5NLRQAenP60dOuaUDcQCe9NUq6CRcYYccUgtpcUHB64PtQeaKKYgoyF5bI5A4Gck8UUfWkNWvqBBBIPODwRRkZ5OPrxR19/rQCRk7e3rQMCfl45JOBSkYPynjtxSAAbNvPBJ+v8AkUUA9Aoo7UUxBR9OaKP0oAOlBwAWchQBkknpQOOBR25AIIwRjIP4UBpcCMYz35+tFFFIAo70fh+tH5j8KYBzjtxViw/5CVt/11X+dV+9T2JxqNt2/er/ADpdBrdH0/RRRXmH3oUUUUAFFFFABRRRQAV4f8VePG8vPBgjyMfWvcK8O+K3/I8Pjgi3TB/CtqPxHlZr/u/zOKJ9R/UUuO+OM0rNzxtC8bQO31/GkwOv6g4rsWp8qFFJ7bvzFLj8f0pgAHQHn3xSZHB4HHfigc53AD2DZpemcDH0FAxYyPMUjnBycDNMQloI/wB55vBBkBHzcmnZOSck+xOaQDAwFVVHCheAB9O1K2tx3XLYUZ56cgg0gGECqWwM4JOcd+v1peCxGDx14pCyKUDuFLkqgJ6kDP8ASjTcFzbIXv6Uf3flZtzYJBwFHqaOnWlAO4ChkoT1PvR/L09aQcqD37UoILugDfKqnJHBz6fSgdnrYTqvBK5HUdqUnP8A9fvSfX9O9L3p+Yr9AopOO5AwM5PajqoIIKnkMOfTBo6jsw7cDntSgoS3lsflbaflxzRnn3HajJOASSO2T09qQumoevHek4z9OKX/ABFFMAx/nNJS0UAJx/k0ozx1o5pPlLFMgsoDHI/z60Ak2H48UuTjFH0/KigBKXGSOOe1JS0AGcgMmSuSORgnBxRnGOoHuKTPPXr2zSjg9Oh9aQ9OgAjjkEexoH3ck4JOelBwdxPBC4H1pT0H6UB0Eo/Cj+VFMQn8/elooz6UAHbmjrSY5ySSenJo60ALwd2CDtOG9jjOPyNFHr6k5JA6n1NJQr9Q9BaPrR/nrR68GgA5HT9aOmaTtR06/nQB7n8Kv+RFi/67yfzrs64z4VHPgaL/AK7yfzrs68+fxM+1wf8Au8PRBRRRUHUFFFFABRRRQAVyXxM/5Ea65wQ6EH8a62uS+Jv/ACIt3npuXOfrVQ+JHPiv4E/Rng5PJ7/z/KkGDwOv60oJC8Fd2QctydvcD36Un3uv869FHxIUUH2YjHvmj/gWaYBjvyeOlHH079MCkOQw4GO7bjkUuMdvx70gEyvqPwp2f3ijfj5D+7OATz1pMk9z1zwcZo/iBCrnoWxg4+tJq5SaQc4oI/eb8ndt28E4x9KCQAM55IHApQPm9M8mm7CTa2E/zz2pRyRn8cU1WWSNXjYMrDIINL64/WgTTTsxAchCUKMckqTkjt/I0v8AP19KP4gO2PT/AD6UjMEjJIZsEABBk8mgq13ZC9frjPSjnJ+YnOOD0WhhhiB+dHbr+dG5N9A/zmjkYo+vpQMEkBlJA3Fe4BoBJsOlJlFIDHBdsLhc/wD6qM4HPAzj6GnZI+6T+B4NA/UTnjPPag4/pR2Bo9PxpiDijiiigBOP8ml69DRSMwRS7ngUArvRC0A46GjGzjj6iikAd6KKKYgGPu8hipI44AH/AOuj6gg+oGaO3XHpg0Z7jn36UigBHqOnQ0dWUdsbjQT8mCMD86XADsF6AAD8v8aAE6d/0ooopiDpyaKKP1oAP85ooxkYJOPQGj6UAHA2gnDMdqj1Pp+lFHp7HIyM49x6UUtQ0Ciik/D8qYC+uOtHXk4zk9PTPH6Yo/z0o75pAdf8L/8Akerf/rm/8q84+OX/ACWbXf8At3/9J469H+GB/wCK6th/0zfj8K84+OX/ACWbXf8At3/9J465K3xn0+U/wH6/5HrP7Ov/ACSnVv8AsJTf+iIq8+wPSvQf2df+SU6t/wBhKb/0RFXn1XQ6nNnG8Pn+gfUDP86OntSqASA3TPNNBJUFxtYjJX0roPBtoL9e1FBJDMxldlZuFbkLnAwPbij9MetCemo2uwdQDR+FGMZ7HBXPpSLv2DzSrMAMlehNAugv86KPr+FH1FMA756EgA5Ppn/Gl3Ft25ChVsDOPnHYikz6596OP1zSsO/cVfvDPTPOKQbsbZtu5SSNgOMHp+OKOOp6UcgAHjufrS6gnZMPXsaOvJooqhB9aCuO+OmRnkfhR689880cAnAALHkgYJ+tLXoNWF5PbOOh9KTJ9CSPSgAE80qlx1+U5IGDzjsc+tJ6AkG3pgEAnHSlKlZNp5YcHH8qQKApHzcjgZ3bj7mkhj/fKpGBnkjjj/IpN6XZSinoOKMoxj7vOfb/ACab07U9Ljz1uZI4kUom5ZRktnsrE5Bzk9qJ1EcxHzDuQeKmMm3ZrUc4OIyjvSZFHWtTMUEgg9x09qO2BgAcADtRRSAKVRkjoBnHJApKMAlSVBKnKk9jQ79AVuogyVBYFD3XOaWiimAfWlQZkA9TSU5CBIh7Kwz9KT2AYpDTlO2TwOvFL0PIY888UsY/fynJwGOCPfNJ3/pR1KnZOwKeeKQfdGaXqD60dMj0JpkhRS5Ofvtt27dnbOc5+vakpIGFH8XTt1oopgFFFLzuHKhOdwxyeOOe1IBKKKO9MQVPYlxqFr5e04nTcD3GeQKg9ansR/xMbb0Eq5H4ik9i4O0kz6fooorzD7wKKKKACiiigAooooAK8O+K3/I8yf8AXvH/ACr3GvDvit/yPEn/AFwj/lW9D4zyc2/3f5o4v8OD+lFA60HjPGFC7s+p5/w/Wuw+XSbD8aKDk7Qsjpg8hejfWjcG5Hf2pBbTQKP1NBHY8ij597EspjONoxyvXP8ASi4rCUdOtLR06CmAHnrnjnrS7iGUbCytnLqQdh560n5ijIyP60rDTsGf5UfMpUnaIyCrdd24ngj6DNJ2xS9MkduAffOSf5UPUcXZhwD6D+VGSeD+VFJ+tMkWgDoenOAScZJ7e54PFHcUmAdpYKSjblJH3T6ik79Bq3UVegA+YYo5B6fhScHrSjIYAD5cHLehoDcAC3G1uOnFRtMFO1VZz0wq9Kl5LBjuzjA+bIUewqvJE8czvEnmRuQeeG9P6CiOr1NYRi3r/TJ0PmIHTPPGPQ/5FBBHBGMdapyyvE+xtnUP5bZIYnoBz1P51oyDMbOSSFkKq3HSpvZrzKqUeRcyIqT/ABA/XFHH1+ppe/B5qznE/lS59MelJS+nWgAoALEKOSaKOuQQCCMEHuKADrjAyrLkOrAg0fXn3NIMBQqgBVGAB2ooG7X0F5o7j8jR34oGDweh4oEV53czKiSbCq7jxnOen8jUsb74lbkNjBAHGainSXz0aMZ3xhDzjBBP+NThBEiqvYcmnpZHRU5VBJf13DPI6jPrS/pR7dqP4vqKRziUtHJUhXaMn+JeooY5bOMZoDoFIfunAz7ZxS0UAB9qKKQ7tjBCFcghWYZAPrigELSU5iC3HoM+570n1oAP8aB17e2elFH8zQB7j8KN/wDwgcHmgbxNIGI6E5612lcZ8Kv+RFi/67yc+vNdnXnz+Jn22Ed6EH5IKKKKg6QooooAKKKKACuS+Jv/ACIt1/vJ/Outrkvib/yIt1/vp/Orh8SObFfwJ+jPBvoKOvb8KKDnaSoywHHNegfFLUPoaKUEK/B6Ht24/wDr01cqqq0jyHH3n6mi47aC0GjHH16e9Id20eUQjbgTuHBHegSQp+lHXpRn8/aj+dMAz6Uo4zt5PJALdfzpPw5o7Y56dDSGG7coJUoSuSp6rRh2DeXt3lcLu6A+9H0oIyCO54FHQL63FzvG4fe74HHHH+frSA+hx60E5Ptnpij8aEtBN3dw6UAbiABk9MUD8qASMY+nSgA44IYHjgggg0pzjpj3poAVQiBVVegXoPwoxwSgy3YZxk0eo+ugufY8jnikc+X2OT0GKdyVwdwBAJCttPBBx9KZMhaNQgYspB244AoT1Kik2riLJvyvlyAMOuMAZ4/mRUrA/eKnB/n6VTm8wwkiMoFYZOcd6lsN3mbGl3BmwQAORzzTkrLmN5Ufc5kS+1Heg4HQn86TI7cfSg5RfX8qPrg560UUgDOTkmj6UDjFFMAIIViqh2C7gm4AmgjB4JP40mAGLBQHYAFvUelLSVxu3QBx04xRRRTENkZlgYr1AHX64/rUaM/mAFtwOegqSVS1vKF6snH1BB/kKZHvOwlCBzkk9eMU1szeKXs7+pLnrw2PXFHUZo7e9BHHH41JgHf3o+lHb8KXJ+bc7Plsjd/AP7o9qA6CUUUUxCevGOfrS0UUDCijJ+bcVIONgAxt9cnvRSQbB/Wj/wCv/OgdaB0pgdf8MC//AAnlt90x+U/1BxXnHxy/5LNrv/bv/wCk8dej/DD/AJHq2PX92+Pyrzj45f8AJZtd/wC3f/0njrirfGfUZU70Pmes/s7f8kp1b/sJTf8AoiKvPq9B/Z1/5JTq3/YSm/8AREVefVpQ6nLnG8Pn+gfTr/OjPpRR/k10ngh0pGVZIykihlJ6Gl9M9fbpR/nrQGqd0HUmij60n0OD3oAX6UgIZQV5BGRS5oOepoAKPT2OaD370dOnWkAEDgH+927+386D1/xoAG70+tHv60AHXv8ArRR19aP88UwD/PFHSj6jvxQMZ+tIA9vzowM+v1pQDx9M0n86AAdeAMY7cGnqzGNlXdnGVA55pn6/WlBwc/5zSaug6j3F7NDDHGNiqwMhJCj1BbPQY7068lSW8le33GFnO3cPmX2I7VHuIUhtrck8LjIwvGPpmmDhtueQvXP3h2/EdKyjC0r+v4/1odEpKULC5oo+nH9aPwrc5woo5o/z1oEHpiij86KBhRR+FHP1oAPXHp3NOGVJJ4+tC555ZCVOCODnB6e9KgUKN/7sqAz5bdk4x+PaolLWxSjdDYwMuxyCpyQfT1pOo4BH1GKcm1mSXG0GQ7iQOO+T9BSMCGO4YPQ5oT1HJWYKMsBkAdKapZo1Z4zExHKZzt5xzS0ZC5LbiACTgZJ+lPzJWugdPXP/ANY/4frR3oHRTggEZweo9qQdB/WmJi/Wiij6UwCkJVVLOyoqjLMx4ApaCBghgrAnaQRkfSkCtfUCMfz470UZyaOcgY6g5PYdOP5/lQAevr2qexH/ABMbYD/nqv8A6FUA6549KnsMnULfP/PVfx5oHHdH0/RRRXmH3oUUUUAFFFFABRRRQAV4d8Vv+R5k/wCveP8AlXuNeHfFb/keJP8Ar3j/AJGt6Hxnk5t/u/zRxdJ3569qWjtXYfLBRnnNJ19Me1L/AJ60CEVVQfIoUFixx6mlopOPoPWgd23dhRnkrxkYyKXnucmjOeM0AFAOCD+NHX86P0oAAAAAOgGBmgY2Lj88de9IeRz+FL1P06UDE9if1paM0lAhf84oo7+3rR2oAM//AKqTH6ntS479sUEYPJxQAnGOAM+9PRijAjP50yl+lK1wI7q3lkLtHGWweCR1B54P506ASRaekbk+Zl3ER/u/45zx2qTceOV29MbeeOc5/GmOcZJOASMn0PQH+QPtj0qNXZPodaqp0/ZsXPPejr70Ec89jSfqfbvWhyC0UUUAJ/nilo7H+lFABR/iKPzo+mB/WgBP1NLgkEjpRg88fpTujbmyeQEYsMKSMcDsOn61LlYqMblSZ2aZ5B0iYKAOh4Gf5/pVrOccHIHcdOPWqQX7RcRcYiYFuP4mxkfj6/Sr55jU44x09/8APNOVlZG9aPKkmM/Hn3o+bJBT5QoO/PU56Yo/nSHpQc6YoGTzR2B5Hse1GQzPgMCmMkjhsgHj86O9C1Bq2jE/ziloo+tMQUnTr0oHv1pQM/j70AHBLAMrGNtj7T91uuD+dFGQckKo3fMcDGT6mkJIUkLuIHAHekr21Ho3ZC+n1o96GHOAQRnrQSc9vypiPcvhV/yI0X/XeT+ddnXGfCr/AJEaL/rvJ/Ouzrz6nxM+1wf+7w9EFFFFQdQUUUUAFFFFABXJfE3/AJEW6/30/nXW1yXxN/5EW6/30/nVw+JHPiv4E/Rng1H8u/tRRXonxIfyoz2o5wcY9s0d6BCFVLoxUFkztPpnrS44oo/Dmgd2FISAMngZxml+h4x0x3/z/OgEjpSAOn50dKO4o9KYBjn3xigYLD6dv50e350DgUgCgexo6fTFH86YB39KOcfr0o/zigc445pAH0o649P50djjrSkHkfhQA3A/Ol9Tge2Dignr+tFMBZ0a4gVQGYhsEcnGen64qlFFskmdzGm1WwDIARz6ZzmroJHAIBJHJGcYOf6UHLAdA3XIHQ/5FSpOKstjqo1VCNmJlud2O2CDwaP0+tIp+XjgZIx6H0pfp09KZzSVmFAo/CjmmISl/wA80f560evWgA+tFH50UAGcUAE8Af1oGfrz1p2GIwu7O4fKDtyM9/apk7IcUm7Eco+VFbPLdB1OAabFtQlVJ+7yMZOcn8+KSWT96PKUYjBCpnnoR6U62G53baqkoANvfHX8+ap35dTo5Wqeo/8AQfSkJYIzIvmEDIXOM/jS4opHPezFIwxFJx056Z9vpSEgKMqzbmCgKPY8n0HFK3BIznHp3peQW6h9MfjRRRVEh35o7D1pP5UvWgYZUFQXVS7bUBP3jjOBR/KjjjIUkcqSM49xRSQOwUdcD65o9eMY6Z70c4PTJ5NAHX/DD/kerb/rm/8AKvOPjl/yWbXf+3f/ANJ469H+GH/I9W2f+eb8fhXnHxy/5LNrv/bv/wCk8dclb4z6fKf4D9T139m9BL8MdSjPAbVZVOPeGKtwfBvSe+pXp59E/wAK+RqKyUnHZnoVaFKtb2ivY+uv+FN6T/0Eb3/xz/Cj/hTekf8AQRvf/HP8K+RaKr2k+5j9Rw38h9df8Kb0n/oJXv8A45/hR/wpvSf+gje/+Of4V8i0Ue0n3D6jhv5D66Hwb0gf8xG9/wDHP8KP+FN6T/0Eb3/xz/CvkWij2k+4fUcN/IfXX/Cm9J/6CN7/AOOf4UD4N6TjnUr0n1wn+FfItFHtJ9w+o4b+RH11/wAKb0j/AKCN7/45/hQPg3pI/wCYle/+Of4V8i0Ue0n3D6jhv5D66Pwb0nAH9pXvf+53/D6UrfBzSCxI1C9Ht8n+FfIlFHPPuH1HDfyH11/wpvST/wAxG9/8c/woHwc0j/oI3p/74/wr5Foo9pPuH1HDfyH11/wpvSP+gje/+Of4Un/Cm9KBQpqd8pVtwxs/wr5Goo559xrBYdO6gfXI+DekhSp1K9Kk55CcfpS/8Kb0n/oI3v8A45/hXyLRR7SfcHgsO94H11/wpvSf+gle/wDjn+FH/Cm9J/6CN7/45/hXyLRR7SfcX1HDfyH11/wpzScg/wBo3vBz/B/hSf8ACm9J+X/iZXuV7/J/hXyNRR7SfcPqOG/kPrr/AIU3pH/QRvf/ABz/AAo/4U3pP/QSvf8Axz/CvkWij2k+4fUcN/IfXX/Cm9I/6CN7/wCOf4Uf8Kb0j/oI3v8A45/hXyLRR7SfcPqOG/kPrr/hTek/9BG9/wDHP8KP+FN6R/0Eb3/xz/CvkWij2k+4fUcN/IfXR+DmkE/8hC9H/fH+FJ/wpzS9yFdUvl2tkgbPm9jxXyNRRzz7gsFhk78iProfBvSAzn+0r4hznBKnH04oPwc0koU/tG92lgf4P8K+RaKXPLuP6nh278p9df8ACm9H8pk+33nzdD8vH6Up+DmknrqN70x/B0/KvkSijnn3D6lhn9g+uv8AhTek/wDQRvf/ABz/AAo/4U3pPbUr3/xz/CvkWin7SfcX1HDfyH11/wAKc0n/AKCN79fk/wAKP+FN6T/0Eb3/AMc/wr5Foo9pPuH1HDfyH11/wpvSf+gje/8Ajn+FH/Cm9I/6CN7/AOOf4V8i0Ue0n3D6jhv5D66/4U3pH/QRvf8Axz/Cj/hTekDONQvBlixwE6nqelfItFHtJ9w+o4b+Q+uv+FN6T/0Eb3/xz/Cj/hTek/8AQRvf/HP8K+RaKPaT7h9Rw38h9df8Kb0n/oI3v/jn+FPh+EGkwzxyjULwlGDAHbjg59K+QqKPaT7h9Rw38h9/UV8A0VnY7D7+or4BoosB9/UV8A0UWA+/qK+AaKLAff1ch4j+Hdj4l1g6hdXtzC5jCFIwuOOh5Ga+MKKaundGdSnCrHlmro+uv+FOaT/0Eb3/AMc/wo/4U3pP/QRvf/HP8K+RaKv2k+5zfUcN/IfXX/CnNJ/6CN7/AOOf4Uf8Kc0n/oI3v/jn+FfItFHtJ9w+o4b+Q+uv+FOaT/0Eb3/xz/Cj/hTmk/8AQRvf/HP8K+RaKPaT7h9Rw38h9df8Kc0n/oI3v/jn+FH/AApzSc/8hK9xjphPz6V8i0Ue0n3H9Rw38h9df8Kc0n/oI3v/AI5/hR/wpvSc/wDISvf/ABz/AAr5Foo9pPuH1HDfyH11/wAKc0n/AKCN70x/B/hS/wDCndI2gf2je5znPyc/pXyJRRzz7h9Rw38h9df8Kc0n/oI3v/jn+FH/AApzSf8AoI3v/jn+FfItFHtJ9xfUcN/IfXZ+DmkdtQvR/wB8f4UD4OaSDkaje5/4D/hXyJRRzz7j+o4b+Q+uU+DeloI/+JrfN5a7Ru2HI9+KUfBvSB/zEb3/AMc/wr5Foo55dxvB4eW8T66/4U5pP/QSvf8Axz/Cj/hTmk5/5CN7/wCOf4V8i0Ue0n3J+o4b+Q+uv+FOaT/0Eb3/AMc/wo/4U5pHfUbwjGCPk5/SvkWijnn3H9Rw38h9dD4N6SFAOpXpwMZ+T/Cj/hTmk/8AQRvf/HP8K+RaKPaT7h9Rw38h9df8Kc0n/oI3v/jn+FH/AApvSP8AoI3v/jn+FfItFHtJ9xfUcN/IfXX/AApzSf8AoI3v/jn+FH/CnNJ/6CN7/wCOf4V8i0Ue0n3D6jhv5D67/wCFOaRtx/aF7n1+T/CkHwd0kdNSvQe33OP0r5Foo559w+o4b+Q+uR8G9K8uJW1TUGaPq2VG/wCvHvTj8HNI5xqN6Mgg/c5yMelfIlFLml3LeDw7d+U+s4vgnpKFN+q30iqQcFYxnHTotWD8HNI+bGo3oDHOPl/wr5EopupNu9wlhKEt4o+uv+FOaT/0Eb3/AMc/wo/4U5pP/QRvf/HP8K+RaKPaT7kfUcN/IfXf/CndJ76jen/vn/Ck/wCFOaT/ANBG9/8AHP8ACvkWijnn3D6jhv5D66/4U5pP/QRvf/HP8KP+FN6T/wBBG9/8c/wr5Foo9pPuH1HDfyH11/wpzSf+gje/+Of4Uf8ACm9IyD/aF5kDAOE6flXyLRRzz7j+o4ZfYPrr/hTmk/8AQRvf/HP8KP8AhTmk/wDQRvf/ABz/AAr5Foo9pPuL6jhv5D66/wCFOaRn/kI3v/jn+FH/AApzSf8AoI3v/jn+FfItFHtJ9x/UcN/IfdPh3QYPDekLp9rLJLGrs4aTGefpWrXwDRUPXU6oxUIqMdkff1FfANFKxR9/UV8A0UWA+/qK+AaKLAff1ZniDRIvEOjS6dcSyQpIQS8eMjH1r4UoprTUUkpKz2Prr/hTek/9BG9/8c/wo/4U3pP/AEEb3/xz/CvkWir9pPucn1HDfyH11/wpvSf+gje/+Of4Uf8ACm9J/wCgje/+Of4V8i0Ue0n3D6jhv5D66/4U3pP/AEEb3/xz/Cj/AIU3pH/QRvf/ABz/AAr5Foo9pPuH1HDfyH11/wAKb0n/AKCN7/45/hSH4N6SRxqV6D64T/Cvkaij2k+4fUcN/Ij66/4U5pH/AEEb3/xz/Cj/AIU3pGP+Qje/+Of4V8i0Ue0n3D6jhv5D66/4U3pP/QSvf/HP8KUfBzSA2TqN6Rjp8n+FfIlFHPPuH1HDfyH11/wpvSf+gje/+Of4Uf8ACm9I/wCgje/+Of4V8i0Ue0n3D6jhv5D66/4U5pGP+Qje/X5P8KP+FN6Qf+Yje/8Ajn+FfItFHtJ9w+o4b+Q+uT8G9K3MRql8AybCvyYxnPpS/wDCm9KKqG1K9O3ocJn+VfItFHPLuP6nh7W5T66/4U3pP/QSvf8Axz/Cj/hTek/9BG9/8c/wr5Foo9pPuL6jhv5D66/4U3pP/QRvf/HP8KP+FN6R/wBBG9/8c/wr5Foo9pPuH1HDfyH11/wpvSNxP9o3vIwfufn0o/4U3pP/AEEb3/xz/CvkWij2k+4fUcN/IfXX/Cm9J/6CN7/45/hR/wAKb0j/AKCN7/45/hXyLRR7SfcPqOG/kPrr/hTek/8AQRvf/HP8KP8AhTekf9BG9/8AHP8ACvkWij2k+4fUcN/IfXQ+DmkA/wDIRvT/AN8f4Uf8Kb0jJ/4mN7/45/hXyLRR7SfcPqOG/kPrtPg7paTFjqd8V24CfJgHOc9OtNj+DOkJEiHUr5toxuYqSfxxXyNRS55dx/U8O1bkPrhvgxpDOGOpXuQoHRP8KVfg1pCoANRvchi275M/yr5Gop+0na1x/U8P/KfXR+Dmk8/8TG99f4P8KP8AhTekf9BG9/8AHP8ACvkWij2k+5P1HDfyH11/wpzSf+gle/8Ajn+FB+DmkHpqN6P++P8ACvkWij2k+4fUcN/IfXX/AApvSf8AoI3v/jn+FH/Cm9J/6CN7/wCOf4V8i0Ue0n3D6jhv5D66/wCFN6T/ANBG9/8AHP8ACg/BvSCCDqN4QRg52f4V8i0Ue0n3D6jhv5D66/4U3pHH/ExveBgfc/wo/wCFN6R/0Eb3/wAc/wAK+RaKPaT7h9Rw38h9df8ACm9Jx/yEb3/xz/Cj/hTek/8AQRvf/HP8K+RaKPaT7h9Rw38h9m+H/hxp/h3WI9Qtry5lkQEBZNuDn6CvnL45f8lm13/t3/8ASeOvP6Kltt3Z0U6UKUeWCsj/2Q=="}}},{"cell_type":"markdown","source":"## Yolact model prepare","metadata":{}},{"cell_type":"code","source":"!git clone https://github.com/dbolya/yolact.git","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.069596Z","iopub.status.idle":"2024-05-06T04:13:16.069904Z","shell.execute_reply.started":"2024-05-06T04:13:16.069752Z","shell.execute_reply":"2024-05-06T04:13:16.069764Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# got some issues with model, had to change some code parts\n\ndef bug_killer(start_line, end_line, new_lines, file_path):\n    \"\"\"\n    Replaces lines in a file between `start_line` and `end_line` (inclusive) with `new_lines`.\n    \n    Parameters:\n    - start_line: The first line to be replaced (1-indexed).\n    - end_line: The last line to be replaced (1-indexed).\n    - new_lines: The new content to insert in place of the specified range.\n    - file_path: The path to the file where the replacement should occur.\n    \"\"\"\n    \n    # Read the original file. Open the file at the given `path` in read mode ('r')\n    with open(file_path, 'r') as file:  # The variable `file_path` is corrected to `path`\n        lines = file.readlines()  # Read all lines of the file into a list\n\n    # Replace the specified lines. Open the file again in write mode ('w') to make changes\n    with open(file_path, 'w') as file:\n        for i, line in enumerate(lines):  # Iterate through the list of lines with their index `i`\n            if start_line <= i + 1 <= end_line:\n                # If the current line number is within the range to be replaced,\n                # write `new_lines` only once at the start of the range\n                if i + 1 == start_line:\n                    file.write(new_lines)  # Insert the new content\n            else:\n                # For lines outside the specified range, write them back to the file unchanged\n                file.write(line)\n","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.071515Z","iopub.status.idle":"2024-05-06T04:13:16.071986Z","shell.execute_reply.started":"2024-05-06T04:13:16.071760Z","shell.execute_reply":"2024-05-06T04:13:16.071779Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Problem & solution\n# https://github.com/googlecolab/colabtools/issues/3497\n\nfile_path = '/kaggle/working/yolact/utils/augmentations.py'\n\n# Lines to replace the original code with\nnew_lines = \"\"\"    def __init__(self):\n        self.sample_options = np.array(\n            [\n            # using entire original input image\n            None,\n            # sample a patch s.t. MIN jaccard w/ obj in .1,.3,.4,.7,.9\n            (0.1, None),\n            (0.3, None),\n            (0.7, None),\n            (0.9, None),\n            # randomly sample a patch\n            (None, None),\n        ],dtype=object,\n        )\\n\"\"\"\n\nstart_line = 292\nend_line = 303   \n\nbug_killer(start_line, end_line, new_lines, file_path)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.073089Z","iopub.status.idle":"2024-05-06T04:13:16.073579Z","shell.execute_reply.started":"2024-05-06T04:13:16.073337Z","shell.execute_reply":"2024-05-06T04:13:16.073357Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Problem & solution + some additional changes\n# https://github.com/dbolya/yolact/issues/515\n\nfile_path = '/kaggle/working/yolact/utils/augmentations.py'\n\n# Lines to replace the original code with\nnew_lines = \"\"\"            cv_limit = 512\n            if masks.shape[2] <= cv_limit:\n                masks = cv2.resize(masks, (width, height))\n                if len(masks.shape) == 2:\n                    masks = np.expand_dims(masks, axis=-1)\n            else:\n                resized_masks = [cv2.resize(masks[:, :, i:min(i + cv_limit, masks.shape[2])], (width, height))\n                                 for i in range(0, masks.shape[2], cv_limit)]\n                resized_masks = [np.expand_dims(mask, axis=-1) if len(mask.shape) == 2 else mask for mask in resized_masks]\n                masks = np.concatenate(resized_masks, axis=2)\"\"\"\n\n\nstart_line = 158  \nend_line = 159    \n\nbug_killer(start_line, end_line, new_lines, file_path)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.075275Z","iopub.status.idle":"2024-05-06T04:13:16.075608Z","shell.execute_reply.started":"2024-05-06T04:13:16.075444Z","shell.execute_reply":"2024-05-06T04:13:16.075458Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# weights actually are resnet50-19c8e357 just wrong naming\n!mkdir -p /kaggle/working/weights  \n!cp /kaggle/input/weights/resnet101_reducedfc.pth /kaggle/working/weights  \n!mv /kaggle/working/weights/resnet101_reducedfc.pth /kaggle/working/weights/resnet50-19c8e357.pth","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.076599Z","iopub.status.idle":"2024-05-06T04:13:16.076903Z","shell.execute_reply.started":"2024-05-06T04:13:16.076747Z","shell.execute_reply":"2024-05-06T04:13:16.076760Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# add custom dataset\n!sed -i \"s/'name': 'Base Dataset'/'name': 'CIS_Dataset'/g\" /kaggle/working/yolact/data/config.py\n!sed -i \"s|'train_images': './data/coco/images/'|'train_images': '/kaggle/input/sartorius-cell-instance-segmentation/train'|g\" /kaggle/working/yolact/data/config.py\n!sed -i \"s|'train_info':   'path_to_annotation_file'|'train_info':   '/kaggle/input/weights/train_json.json'|g\" /kaggle/working/yolact/data/config.py\n!sed -i \"s|'valid_images': './data/coco/images/'|'valid_images': '/kaggle/input/sartorius-cell-instance-segmentation/train'|g\" /kaggle/working/yolact/data/config.py\n!sed -i \"s|'valid_info':   'path_to_annotation_file'|'valid_info':   '/kaggle/input/weights/test_json.json'|g\" /kaggle/working/yolact/data/config.py\n!sed -i \"s/'class_names': COCO_CLASSES/'class_names': ('shsy5y', 'astro', 'cort')/g\" /kaggle/working/yolact/data/config.py\n\n# set custom dataset, classes \n!sed -i \"s/'dataset': coco2017_dataset/'dataset': dataset_base/g\" /kaggle/working/yolact/data/config.py\n!sed -i \"s/'num_classes': len(coco2017_dataset.class_names) + 1/'num_classes': len(dataset_base.class_names) + 1/g\" /kaggle/working/yolact/data/config.py\n!sed -i \"s/'max_size': 550/'max_size': 520/g\" /kaggle/working/yolact/data/config.py\n\n# bug fix\n!sed -i 's|generator = torch.Generator()|generator = torch.Generator(device='\"'\"'cuda'\"'\"')|g' /opt/conda/lib/python3.10/site-packages/torch/utils/data/sampler.py\n!sed -i 's|torch.randperm(n, generator=generator).tolist()|torch.randperm(n, generator=generator, device='\"'\"'cuda'\"'\"').tolist()|g' /opt/conda/lib/python3.10/site-packages/torch/utils/data/sampler.py\n\n# set epochs number\n!sed -i \"s/num_epochs = math.ceil(cfg.max_iter \\/ epoch_size)/num_epochs = 10/g\" /kaggle/working/yolact/train.py","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.078318Z","iopub.status.idle":"2024-05-06T04:13:16.078629Z","shell.execute_reply.started":"2024-05-06T04:13:16.078478Z","shell.execute_reply":"2024-05-06T04:13:16.078490Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# train\n!python /kaggle/working/yolact/train.py --config=yolact_resnet50_config ","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.079521Z","iopub.status.idle":"2024-05-06T04:13:16.079822Z","shell.execute_reply.started":"2024-05-06T04:13:16.079668Z","shell.execute_reply":"2024-05-06T04:13:16.079680Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### # Result after 10 epochs\n![yolact10epoch.JPG](attachment:38b49e82-6aef-49c8-a492-26c800965f16.JPG)","metadata":{},"attachments":{"38b49e82-6aef-49c8-a492-26c800965f16.JPG":{"image/jpeg":"/9j/4AAQSkZJRgABAQEAYABgAAD/4RCQRXhpZgAATU0AKgAAAAgABAE7AAIAAAAKAAAISodpAAQAAAABAAAIVJydAAEAAAAUAAAQdOocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5QQSBBT0kgMwAAAeocAAcAAAgMAAAIZgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATgBQAEEAIABBAE8ASQAgADMAAAD/4QpiaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLwA8P3hwYWNrZXQgYmVnaW49J++7vycgaWQ9J1c1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCc/Pg0KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyI+PHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIvPjxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSJ1dWlkOmZhZjViZGQ1LWJhM2QtMTFkYS1hZDMxLWQzM2Q3NTE4MmYxYiIgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIj48ZGM6Y3JlYXRvcj48cmRmOlNlcSB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPjxyZGY6bGk+TlBBIEFPSSAzPC9yZGY6bGk+PC9yZGY6U2VxPg0KCQkJPC9kYzpjcmVhdG9yPjwvcmRmOkRlc2NyaXB0aW9uPjwvcmRmOlJERj48L3g6eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgPD94cGFja2V0IGVuZD0ndyc/Pv/bAEMABwUFBgUEBwYFBggHBwgKEQsKCQkKFQ8QDBEYFRoZGBUYFxseJyEbHSUdFxgiLiIlKCkrLCsaIC8zLyoyJyorKv/bAEMBBwgICgkKFAsLFCocGBwqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKv/AABEIAG8CvAMBIgACEQEDEQH/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/xAAfAQADAQEBAQEBAQEBAAAAAAAAAQIDBAUGBwgJCgv/xAC1EQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APEq0p/Dut22lJqlzo9/Dp8gUpdyWrrEwboQ5GDntzzVbT5YINStpbyMyW8cyNKg6soIJHPtXaeL9P8A7Y8fXGtPrmmzaVf3yNHd/boZXihdht3QFvMGxTgqVGNuOlXbbz/4H5k30bfT+vwOItLaS9u47eFoleRtqmaZIkH1dyFA9yRVjWNHvtA1abTdVhEN3Dt3oJFcDcoYfMpIOQQeDXpHjvTtDvdBtoNIk0VdTXVZIoniv7BTJbbDh3MCRRoCVBAfJGcZ5AqTV49Hl+L11f391o15bXNl/wAS55L2Ge2NyluiqJtrHau8EfPgHHcZqU7/ANeVwen9edjyWtTRfDuo+IZJo9JjglkhQyNE91FE7KAWJVXYF8BSTtBxXX2lmup2HiLT9al8NQ6zNbWzWEkUtlDCoWb59skWI1baeRncR61r2MOkx/Gi+vNJvdFt9It7Ro1lW9gt4iz2RQbAzLuy5OcDgnnFPXlb8m/u/wCDoNbnktTmzuRYi9NvKLUyGIT7DsLgZ27umcHOOteo/DzTdDsLVF1+70SeQ6n5V3DcXVhthgCgl98kcjyBs4AiYD/aByRWTVzP8NrrSNIuNBMtjq8uI7yOyRntvKwsimUDe2QRvXL9OelKUrJ2/rb/AD/PsEdd/wCt/wDI4AaHqJ8OnXRb/wDEtFz9kM+9f9bt3bdud3TnOMVn13ktjHdfCCMyPoC6lBfCaPy7mzjujaiJshtrCRjvI+VstnHFdNrEnhfWdT1nTLe00IW9veaaumixijjecOwE4DxjfJwxyBnGBgAin9rlXkK65eZnjtFetfE61gt/D91HpOkWJt4dWdZb22trBGtUwRHbnyHd+qsdz7CcYIJPHL/DWbSbfWtSm1xNOkjj0yVoF1FUaMzBk24D8FuvH196UXzf15XHL3Tk7S0ub+7jtbG3lubiVtscMKF3c+gA5Jq7Y+Gtd1Oe4h03RdRvJbVtlxHb2jyNC2SMMAPlOQeD6GvYdbu/BNsZtbsrzS9Ols0vrWBNESFpmMkvlRSCMOu/Ee9skjqCD0FZur6z4XXTPEOpm4+3xau+nXy2lveR2tx5o80SZGJCpDDcQM43jnvTTTjd/wBXdvy1+4bTTa7HkE0MtvPJDcRvFLGxR43UqyMDggg9CD2pldNfzz+PvE2s6xd3em6ZKYnuylzN5ayBQAIo+DucjGB3wTWVZaR9s0fUNQ/tCxg+w+X/AKNPNtmuNxx+6XHzYxk9MChX5bsLa6GdRWiNIz4bbV/7QsRtuRb/AGIz/wCkn5d3mBMfc7Zz1rOoEFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFS2tzNZXcN1aStFPA4kjkU4KMDkEfjUVFNNrVC3NzWPGGta7aPa6hPB5Mk/2iRLezhtxLLgje/lou9uTy2eprDoopWGFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVsWmkwT+DtT1Z3kE9pd20CKCNpWRZSxIxnP7sY59ax66bTv8AkmOvf9hKx/8AQLiqXwyfp+aKgrvXz/JnM0o56UlWLGS3i1G2kvoTPbJKrTRK20yICNyg9sjIzSVr6kPRFy88Pano01t/wkemalpdvO+BJPZsrFRjcUD7QxAPTI7citDW/DenaH4gsbSfU7qSwu7OG7FylkvmqsqblHlGXGeQD8/rXQeK/GPhvWvD39j6bHcW0D6wL3dFpFtbC3g2MuwLG/7xlBHzMRu9Ris7xNqvhjXdU0maC+1aKG1sobOYvpsW7EUe0OoE+DuIHBIwD1PSnG11zd191tfudiv8v1/yMPxVoX/CM+KtQ0b7R9q+xymPzvL2b+Ou3Jx19TWRXS+PdX0rxB4uvNY0aS8Md7IZXju7dYjGemAVdt3Trx9K5qs4X5Vzbg7X0Nzw1otvrKaybp5U+waXLeReWQMupUAHIPHzHpj61h11vgP/AFXij/sAXH/oUdclSu/aNeS/NiW3z/RBSqNzADucUlac39hjw9a/ZjqA1rzm+0l9n2fy+duzHzbumc8VorXVwNXVfAt3pviBNCt9TsNS1drkWxsrMTblY9y0kapj3DHr6ZIr654Pu9E0qHVEvbPUdPluHtftVn5mwSoMlf3iKTx0K5U4PNdZb/E+PS49LUX+reI5bXUlvHuNXQI8UYQo0Uf7yQ/MGJJ3ADC8dTWb4z8bWWteH00jTHvJoftv2oNcwJbpboqFI4IokdgEUEnORkknGSTU62/ry/4P9bnX+vP/AIH9bcLW74L0S28R+MLHSr55Y4LguHaEgMMIzcEgjqPSsKuu+Fn/ACUzSP8Aek/9FPTewHI0UUUAFdDq/hM6JpttcXutad9ourSK7isUE5lMcgyvPlbAcdRv7VRh/sP/AIRy5+0f2h/bXnL9n8vZ9m8rjdvz827rjHFdJH4zhtvA95pEuq6xrEl3bR28dnfxqLWx2kEvHmRySMbVwqcEk9hQ9nb+tAW5k+JPCf8AwjEsltea3ps99GEL2duJy6h1DA7miCdGHRq56u31Xxlb3Hgm50V9V1nXp7mWF0k1aMKtiI858r97IctnaT8vHauIo6sOiL2i2Ueo69p9jOWWK5uY4XKHDAMwBxnvzTtesYtL8R6lp9uztFa3csCM5BYqrlRnGOcCpvCv/I46N/1/wf8Aoxaf4v8A+R413/sI3H/oxqHuvn+gLr8v1MaiitLS/wCxPsuof21/aH2jyD9h+ybNvndvN3c7P93mgRatfDEsmgrrF/qNjplrMzJbfamkL3LL94IsaMcA4BLbRkgZ64up8P8AVJNJe7S4tGuU0/8AtNtOBkM4tc48wnZ5Y4Ibbv3YPTtXQeG/iRaaV4b0mxu5dSQaWLlZNPt0U22prJkqszFwQAWYEbHGORgmp5fijZyaKGVLuK+bSTYS2cUKLBNKY/J+0PLu3PiPohTAOcHkkt9bfL7n+v8AS3Kja6v/AFr/AJf09jy+iiikI3PF2i2+ga8LKzeV4vstvNmUgtukhVz0A4yxx7Vh11vxK/5HAf8AYPsv/SaOuSpvdh9lei/JBW1pPhqbU9MuNTuL6z0zToJBE11eM+1pDyI1WNWdmxk8LgAckcVV0T+yP7Yh/wCEk+3f2bhvN+wbPO+6du3f8v3sZz2zXX+DfHltoPh8aXLfatpoi1Rb5ZtNRXa4TaFaF8um0Hapz8wPdTgUdP67/wCWojDTwiP+Eeg1m713TLO2uZZYrdZluGaUx43YCRMAPmGNxHXtXOV6FoXj610vULzUHu9US2nmuZB4bhQGwcSBgEZjJjHzDP7o9OPbz2p6/JD/AOCFbGsaTBp+j6FdwvI0mo2jzyhyCFYTyRgLx0wg655zWPXTeJv+RY8I/wDYNl/9K56v7F/Nfkyoq6fp+qOZooqxY/ZP7Qt/7T877H5q+f8AZ8eZ5efm2543YzjPGaS1ZJY0vTbbUDILrWbLTNmNv2tJ28zPp5Ub9PfHXvXRS/DXUbbVr2yvNT023SznitTdOZjHLPIu5YkCxly+Oo28Y5xVLQ9T8P6L40k1MW17dafZs82nQTBN7yD/AFPnEEAAHBbbnpjBBrZ8M/ECOz0XUbDWLi8t7i7vjfLqdnbJNOjupWULudAjMP4wcjJwOaW/9en6X/DfYT0uv6/r+tNzjtY0m70LWbvS9Sj8u6tJTFIucjI7g9weoPpVKtjxXrx8T+Kr7WDB9nF1ICsW7dsUAKoJ7nAHNY9KN7K5UrXdjcOi24+H6a5vl+1NqjWZTI2bBEHzjGc5Pr+FYdda3/JGY/8AsPv/AOk61yVTFvmkvNfkhdF/XVhVvTrOC9uvKudRttOTaT510srJn0/do7Z/DFVR156Vtznwuvi2FrMaq3h9ZIzKtwIzcsuBvA2kLycgc9MVohPZs1j8OLoSjOu6T9n/ALM/tQ3J+0BVg3hASvk78knIG3pz6Vyt7bxWt5JDBeQ3sa4xcQBwj8Z4Dqre3IHSul/4S6S+8aX+tSaxqmgLcKUibSU3OkY2hIceZH8oVQOvVRx3rP8AGevxeJ/Fl3qtvA0MUuxV8zHmSbVC73xxubG447nqetLt/XUrTb+v63MKtzTNFt73whruqyvKJ9Oa2ESqRtbzHYNuGM9hjBFYddboH/JM/F//AF0sf/Rj1E20tO6/MRyVFFFWBa03T59W1W10+0Cm4u5khiDHA3MQBk9uTXTSfDbVBNbLa3tjdRTTTwyTr50S2xhAMpkEsaMFUHkgHpjrgGlaXvhjTdT0C9gsr6+FuVk1W2vfL8uVgQSseOq9eG612yfFLSINQtpLpL7XQzXUVzdahZxRyLazDiAIsjCRVf5sFlGMqAAeC/u6b6/1/VvXulvr5fr/AF+nbgNf8M3egQ2FzLNDd2eoxGW1urcSBJQG2tgSKrDB9VHUEZFYtdd438XR+JLbS7SCe8vFsBKz3l6ixyTPKwJ/dqzKiqFVVUE4A7dK5Gkhm74X0S21ttXF08qfYtLnvI/LIGXQDAOQeOeeh96wq674f/f8Sf8AYv3n8lrkab+L5fqxLZ+v6IKUDJAHU0laobQU0K1YJfyautzm4Rygtmg7BSPnDZ/CmrX1BuxuX/w11SwYxtfWMs0d7BY3ES+cpgllBKAl41VhxnKFuMHkHNY/iHw/H4fvJbRtZ0+/uoJngnhtFnzEynByZI1B5BHBNdf4m8eaPrGmy29rJqQ3XkM9gr2sUQ0VFGGSBkfLAgKAuIx8u4881k+KvF1vrHhmz0lb/VNauILp7ltS1dAsqBlC+Ug8yQhONx+brjipu/6+X/BHp/Xz/wCB/kcbWz4R0iDX/GGmaVePIkF3cLFI0RAYA+hIIz+FY1dR8Nf+SmaB/wBfqfzq46tEVG1BtHNSqEmdB0ViBmmVLcf8fUv++f51FULY2qJKbSCunbwLfjSmuRfWDXaWA1F9OWRzOlucYc/Ls+6Q23fuwRx2rKt/7E/4R+8+1/2h/bHmJ9k8rZ9n2Z+ffn5s46Yrqrbx+th4Rmskuri/v7iwGnjztPghW2hP3h56lpZQBwqttAznHAFVpb+u3+djNav+u5m6l8P9U0zSb29kuLSaTTVhbULOIyGW0Ev3N5KBCeQCFZiM89Djla9O8S/FC01bS9W+wLeR3GrwpE9mYUjt7Yko00m8MTM7GMAMyqVU46ACvMalXK0sT2UK3OoW8DkhZZVRiOuCcVe8UaZDonizVdLtWkeCzu5II2kILFVYgE4AGePSqulf8hmy/wCviP8A9CFa/j//AJKN4h/7CM//AKGap9Pn+go/a+X6nO0UVo6R/Y2bz+3vt2Psz/ZPsWz/AF/Gzfu/g65xz0oA1tK8CX+rafZXEd9YQT6l5v2CzmkcS3fl/e24UouSCo3suSKhvvCf9m6HZ6hfa1psMl9a/arezInaV03FRyIigOVPVhW14Q8eL4X0yJ3urm6ubMytZ2T2EBjiZxjIuWYyovcoijd0zyTUem+M4dO8I32n3Oraxqpu7F7VNMuowLO2ZmBEikytkrjIwinJ6jupbO39b/8AA12FHfX+ttTiKKKKBmx4l0mDRtRtre1eR0lsLW5YyEEhpYUdhwBxljj29ax66bx3/wAhux/7BGn/APpLHXM1UtJNeb/MqStb0X5IKKK0b7xDrWqWkVrqer395bwEGKG4uXkSMgYG1SSBxxxSJM6itS88T69qFxbT3+t6ldTWj77eSa7kdoW4OUJOVPA5HoKJfE+vT6pFqc2t6jJfwrsiu3u5DLGvPCvnIHJ6HuaQGXRWqnifX49Vk1OPXNSTUJU2SXa3cgldePlL5yRwOM9hSWniXXbC8uLyx1rUba5ujuuJ4bt0eY5zlmBy3JPWgDLrStdDubzw9qGsRPELfT5IY5VYnexk3bdoxjHyHOSO3WnWXiXXdNFwNO1rUbT7SxefyLt081j1LYPzHnqa2NM+IuvaX4TvNEg1PUh5zQ/Z5kv5F+yom7KIo6BtwyAR90daPsvvp+av+ALfU5OitH+39ZGj/wBkf2tff2b/AM+X2l/J67vuZ29eenXmi68QazfadDp97q19c2UG3yraa5d449owNqk4GBwMUwM6itS88Ta9qE1tLf63qN1JaPvt3nu5HMLccoSflPA5HoKJ/Euu3Opw6lc61qM19bjbDdSXbtLGOeFcnI6noe5pAZdFap8T6+dWGqHXNSOoBPLF39rk80L/AHd+c49s0QeKPEFtqM+oW2ualDe3IAnuY7uRZJQOm5gcnoOtADdG0K51z+0PsjxJ9gspL2XzSRuRMZAwDzzxnA96zK6vw18Qtb8Ox6mkd/qEq39tNGFW+dBFNIQfP75cY68E561kp4o8QJBdQJrmpLDeOz3MYu5As7MMMXGfmJHBJ60dQXmZVFaI8QayujnSV1a+GmnrZC5fyTzu+5nb156daJvEOtXGkppdxq9/Lp8YAS0e5dolA6YQnAx9KH5AZ1Fad74l13Uo4I9R1rULtLdg8Kz3TuImHQqCeD9Kdc+KPEF7e295ea5qVxdWpJt55buRnhJ67WJyvTtQLUyq0/D2hXPiXX7XSLF4o7i6YqjTEhBhS3JAJ6D0ofxLrsurR6rJrWovqMS7I7xrpzMi8jAfOQOTxnua2PDHxC1vw/4rXWp9Q1C/LkG6ie+dftQClVDsc5254yDigZylFbSeMfE8V5NdReI9WS5nVVlmW+lDyBc7QzbskDJxnpmq9h4j1vS7eaDTNY1CzhnJaWO3unjWQkYJYAgHj1o1AzaK0YvEOtW+ktpcGr38WnOCGs0uXELA9coDg5+lEniHWptIXSpdXv305QAtm1y5hGDkfJnbweelAGdRWjdeINZvtOh0+91a+uLKDb5NtNcu8ce0YG1ScDA4GOlPvPE2vajPbT6hreo3Uto2+3knu5HaFuDlCT8p4HI9BTAp6fZSajqVtYwFVluZkhQucKCxAGcduafqmny6TrF5p1yyNNZzvBI0ZJUsjFSRkA4yPStaw8ceIbTxFa6xPrWp3M8BVWZ76TdJEHDGIsSTtJHTke1O1bx14g1LxNc6zDrGpWsskkhgCX0ha3jdt3lK2RhRwMDA46UuwHOUVq2/inxBaX1xe2uu6lBd3WPPnjvJFkmx03MDlvxpLLxLrumi4Gna1qNp9pYvP5F26eax6lsH5jz1NGoGXRWjaa/rOn6dNp9hq19bWU+fNtobl0jkyMHcoODkDBz2o/t/WRo/9kf2tff2b/z5faX8nru+5nb156deaYGdRWjc+INZvdNh0681a+uLGDb5VrLcu0Ue0YG1ScDA4GKnm8W+I7i6trm48QapLPaEm3le9kZoSRg7CTlcjjigCHXdDufD2pCyvXieUwRT5iJK7ZEDqOQOcMM+9ZtdX4l+IWu+IdWt7xdR1C1W2SLyYhfOwjlSMIZVPGGbk5HPzHk1knxR4gbVV1Ntc1I6gqeWt2buTzQn93fnOOTxml1DovRff1MqitOHxLrtvqk2p2+tajFfzrtlu0unWWQccM4OSOB1PYUtp4n17T7i5nsNb1G1mu233EkN3IjTNzy5Byx5PX1NAGXRWjaeIdasLGaysNXv7a0uCxmt4bl0jkyMHcoODkcHNEXiHWrfSW0uDV7+LTnBDWaXLiFgeuUBwc/SgDOrS1DQ7nTdI0vUZ3iaHVI5JIVQksoSQod2RgHKnpninHxNrx0+GxOt6ibOAqYbf7XJ5cZU5UqucDB5GOla+t/EPXdb0DS9MuNR1H/Q0YTyPfO/2pvNLq7A914AyT90dKHt8/ws/wBbAcpRWneeJdd1G7trrUNa1G6uLVt1vNPdO7wnIOUJOVOQDx6CnSeJ9fm1SLU5tc1KS/hUpFdtdyGWNTnhXzkDk8A9zTAyqK1I/E+vRarJqcWt6imoSpsku1u5BK68cF85I4HGewotPEuu2F5cXljrWo21zdHdcTw3bo8xznLMDluSetIDLorUtPE2vafHcR2Gt6japcuXnWG7kQSsepYA/MT6mmQeIdatdKk0y11e/hsJQwktI7l1ifPXKA4Oe/FGoCvodynheLXS8X2WW7e0VATvDqiuSRjGMMO/4Vm11lz8Rdeu/Ba6BPqepOftDySXD38jebEyKnklT1UYJxnHzHisS68QazfadDp97q19c2UG3yraa5d449owNqk4GBwMU3u+2n5a/iHRGdRWpeeJte1Ca2lv9b1G6ktH327z3cjmFuOUJPyngcj0FE/iXXbnU4dSuda1Ga+txthupLt2ljHPCuTkdT0Pc0gMuitX/hKfEH9q/wBp/wBu6l/aHl+V9r+2Sebs/u785x7Zot/E+v2uoT39rrmpQ3lzxPcx3ciyS/7zA5P40AZVadjoVzf6DqmrQvEsGl+T5yuTubzGKrtGMHkc5IosvEmuaZNczabrWoWkt02+4eC6eNpm5OWIPzHk9fU1taN8Rdd0bwvqOj2+o6iPtPlC2ljvnT7Hscs2xR03ZwcEfjQwOSorR/4SHWv7JbSv7Xv/AOzm62f2l/JPzbvuZx156deaLrxBrN7pkWnXurX1xYw7fKtZbl3ijwMDahOBgcDAoHoZ1Fad74l13Uo4I9R1rULtLdg8Kz3TuImHQqCeD9Kdc+KPEF7e295ea5qVxdWpJt55buRnhJ67WJyvTtQTqZVFab+Jddl1aPVZNa1F9RiXZHeNdOZkXkYD5yByeM9zTo/E+vw6rLqcWuakl/MmyS7W7kErrxwXzkjgcZ7CmMbouhXOutfLaPEhsbKW9k80kZSMZYDAPPp0HvWZXV+G/iFrfh1tUK6hqE39oW8yEC+dNk8gA+0d8uMdeD7isseK/ESxXUa69qYjvGZrlBeSYnJGCXGfmJAwc9qXX+twRkUVoxeIdat9JbS4NXv4tOcENZpcuIWB65QHBz9KJPEOtTaQulS6vfvpygBbNrlzCMHI+TO3g89KAM6itG+8Q61qlpFa6nq9/eW8BBihuLl5EjIGBtUkgcccU+88T69qFxbT3+t6ldTWj77eSa7kdoW4OUJOVPA5HoKYGXWhoWj3HiDXrPSbJ40nvJRFG0pIUE+pAJx+FSS+J9en1SLU5tb1GS/hXZFdvdyGWNeeFfOQOT0Pc1qeHfH2uaH4si1ybUdQvX8xGuo3vXBu1TojtzkY45BxQrX1FK9nY5qRDFK8bYyrFTj2plbjeNPE39pTX0XiHVo7iZQjSrfSBygJIUtnJAycD3NV7LxLrumi4Gna1qNp9pYvP5F26eax6lsH5jz1NSr2LlbmfLsZdFaMHiHWrXSpNMtdXv4bCUMJLSO5dYnz1ygODnvxR/b+sjR/7I/ta+/s3/ny+0v5PXd9zO3rz0680yV5mdRWjc+INZvdNh0681a+uLGDb5VrLcu0Ue0YG1ScDA4GKdfeJNc1OS3fUta1C8e1bfA1xdPIYW45XJ+U8Dp6CmBRt4WubmKBCA0rhFJ6ZJxVnWtKn0LXL3Srto3nsp2gkaIkqWU4JBIBx+FaEPjbxKmr2+oza/qs1xB8oke+k37CQWTdnIBwMjpVnXfH2v6x4quNag1XUrN2lka2RL6Qm1RzkxowIwOg4ABx0pdvn/wA7/L9b/ocxRWrB4o8QW2oz6hba5qUN7cgCe5ju5FklA6bmByeg602y8Sa5pk1zNputahaS3Tb7h4Lp42mbk5Yg/MeT19TQBmUVo2niHWrCxmsrDV7+2tLgsZreG5dI5MjB3KDg5HBzQPEGsro50ldWvhpp62QuX8k87vuZ29eenWgNDOorRm8Q61caSml3Gr38unxgBLR7l2iUDphCcDH0qeXxd4kme2ebxBqsjWrbrdnvZCYTjGV+b5Tg447UAQ61odzoU9rFdvE7XVpDdoYiSAki7lByBzg8/zrNrpvFvjjVPFws4725vPs9rbQxGCa7aVHlRNpmweAzck9+Tya5mjq/V/d0AKKKKACur8AaDZeItS1W11DylEWk3E8Ms8rRpDIoG2RiOy5yev0NcpWv4d8RTeHLy5ngtLa7W6tZLSaG6D7GjfAYfIysDx1Bo6MRrS/D68gje6m1bS00tbWK6GplpjCyyMURQoj8wsSrcbONpzipI/hnrU+pXmnWk9jcX1o0TG2ilYtLDJt2zplcGPDKSSQVByQKhbx/eyrPbXOl6bPpctvFbLpjJKIYliYshVlkEgbLOSS5J3nOeMPT4k63Dql3qdpHaWt/dSRE3MMRDRxR4226fNgRfKuRjLAYJIzR1/r+v67j6f1v/X426XOa1C0Ww1Ge1ju7e8WFyn2i2LGOTHdSwBI98VsWFtA/wAO9auXhjaePULNElKAsisk+4A9QDtGR3wPSsjUbxL/AFKe6js7eyWZt32e1DCOP2UMSQPbP044rTstRtYvAuradJLi6uL61lij2n5lRZgxzjAwXXr60435Hfey/NFxtzff+TMKr2i6Y+ta9YaXC6xyXtzHbq7DhS7Bcn86o1PZ3k+n30F5ZyGK4t5FlikAztZTkHn3FONrq+xm720O68W+AbHSvDFxq2mLe2z2d6IJLe+uEeSWF9wjn2qimMMUbCncSMEHHJwPBfhtfE2tTQTC4e3tLWS7mitRmaVUHEcYwRuZioHB6556UviDxre+ILSa2ezs7GO6uzfXX2USZuZyCN7mR2PGWwq4Ubjx0qSLx3fWniVNZ03T9N05xa/ZJLaygaGGaMjDbgrbsnPLAg5AIIqFzL+vL/P/AIboVKz2/rX/AC/4fqdlL8I7ceXqFvHe3Np9lzJpttdxy3AuvN8ryfOCbAATlm2HbtYds1xnjrwzbeF9atobC5+0Wt5Zx3cR81ZdobIK+YoAcBlbDAAEYOKsRfEXU4JDFDZ2UemGyax/spfNFv5TNuYZEnmZLclt+ecZxxWLr2vXXiHUEurtIYVhhS3gggUrHBEgwqKCScD3JPPWjXT+u/8AwP63Xr/W3/B/rbT8F2lvdR+IzdW8U3k6JPLF5iBtjhkwwz0IyeR61zFdF4S1Sz0yPXhfTeUbvSJraD5Sd8jMhC8DjoeTxXO1OvtH6L82C2+f6IK9Q1P4WWtjoOqZa6h1HTbIXPnzXCeTeMqq0yxRbA+xA4HmFsFuMDPHl9dVqPxC1bUtPmhnhtVu7m1SzuNQUSGeaBMYjOXKKDgZ2qpOOTyc1K/Lp/X9f12BfEr/ANf1/Xcy/C+hSeJvFFho8UwgN3LsMpGdi4yxx3wAeO9ehp8JrG+tItRtV1KzghklN5p8syXF2Yli8yPAVF8uRwMbGBI3Keeh4RfFl1Bc6LdadZafp91owXyri0t9jzsCDulOfnPH5E1rJ8UdZtr6GfTbSx0+NLiW5lt7cSlLmSVSrtIzSM5ypI4YY6jB5pu9tN9f+B/X4PpOt/6/r+vvj8c+ELfw1a6Td2hkjW/SVZbSW5S4e2ljYBkMiKqsfmXIA+U5BzioPhvaW198Q9Ltr63iuYJGk3xTIHVsRseQeDyKztc8R3GuQ2VsbW2sbKwjZLa0tVYRx7juY5dmYknkksat+AdVs9F8c6dqGpzeRaws5kk2ltuY2A4AJ6kUujK6HOUUUUwPUNF+FlrqGj2QuWuo72/083cN4bhEthIwZooAhQtI5VCzbWG0HP18yhieeeOGIZeRgqjPUk4FdPb/ABC1a30q1tRDavcWVs9pZ37iQzW0T53Kg37AcEjcULAHrwMY8ms+Z4cg0gadYJ5NwZ/tqQYuXyMbGkzyo6gYoXx3e3/B/wAv66ta8tuv/A/z/rovSn+DlvdS3WnWM11a31ncQRCe7mQreK0gilkSEKHRFc8EswbBA5zjA8W+B7DSfC7axpy3lo0N8LZ7W+uElleJ1LRTFVRTFuCt8jZOCDnGM07v4na5cySXMUdpa6jO9u91qEKOZrgwYMe7czIoyqkhFUEgZ44qj4g8aXviC0ltWs7OxhuLtr65W1EhNxORjexkdjwCcAEKMnih7ef/AA3/AAf62pW6/wBaf5mf4bijn8V6TDPGskUl7Cro65VgXAIIPUU/xVDFb+MdZht40iijv50SNFCqiiRgAAOgA7VFoF1DZeJdMurp9kMF3FJI2Cdqq4JOBz0FO8SXcN/4q1a8tH8yC4vZpYnwRuVnJBweRwe9D3Xz/QS6/L9TMr0Twf8AD2z1jRNP1DVhdmLUblolmguEhis41ZULyM6NvZncBYxtLYODzx53XT6H461DQ9Jg08WlnfQWt39ttPtYkb7NNjG9QrqD2OGDDPbk5eltf6/r+u5Lv0MTV9PbSNbvtNkcSPZ3EkDOBgMUYrn9K9DT4W2p0WRJWu4dQXSft63ck6LBLLsEpt0i27nxGRmQPgHqOQDwyeIJvsWrQ3VnY3k+qOskl5cQbp4WDFiY2z8u4nnjkVqt8QtVbSY7U29p9pj0/wDsxNRKuZ1ts/6sDf5Y4O3cE3Y796I2Ufe3/wCB/n/XR3pzX6f8N+l/61Oj1/4X2ml6HrDQtdxX+kRJJ5lxOmy/AKrO0UWwMqIzgByzAkEdc48xrqtY+IGqa1Y3cVxb2cdzqEcMd9fRq/nXSRAbVbc5VRlVJ2KuSBmuVqVcNLHT/EC0t7LxUIrO3it4vsNo2yJAq7mt0JOB3JJJ9zXMV0XjfVLPWPEgutOm86H7HbRbtpX5kgRWGCAeCCK52qe7F9lei/JHX+DfCEeu6VqOp3Vvd3cVo8cMdtazpAXd9zM7yurLGiIjEkjHTkVn+NvD0PhfxZdaZaXX2u1UJLBMerRugdc+pw2M4GcZwOlR6F4nudCstQsRbW99YaiqLc2lyZAjlG3IcxurAg574OeQaml8Y3d1rWp6nqNhpt9PqFs1ttuLbclspACmIZGxlCgKecD1odr6f1p/mONuv9f0jqfCXw2sda0fSJ9Ra8RtXMu28jnSOCzw5iiVgyEyu8gOEVlOOexIt6d8JIZrG3tb83UWo3Vk1wl59oRLZZSGMduqFC0rlULMVYbQc/Xk9J8f6npGl2NnHbWdw+mPLJp1xcK5ezaQfMUAcIxzyN6tg06H4h6vDpdtbGK2kurO2ktbTUJPMM9vE+dyqN+zOCRuKFsHrwMTO7vy/wBdv6/4ZkbaX/rX/L+upyldD4itoIPDvheSGGOOSfT5HldEAMjC6mUFj3OABk9gK56t3XdRtbzQfDlvbS75bKxkiuF2kbGNxK4GSOflZTxnrV/Y+a/Jjjaz9P1RhV0ngrw0niXUrxJ0upobKze6a3sx++uCCqrGmQ2CWdecHjPBrm61vD3iK88N301xZLHKtxbyWtxBLu2TROMMpKkMOxypB460lbqSavjvwnB4YutOksZWe2v7XzdjXCTtBKrFJIjIgCvtZfvAAdu2Tc8GeCrbW9Dn1fUorqe3W7W1C21wluIQE3yTSyOjKsarjtyTjjjOW3jO4k8QWGpTaVpc8GnwC3ttMmtzJapGAeCrMWbli2WYnJzntTdG8YXWkaddaa9lZ3+nXU6XD2d15gjEi9GHlupP0JIOBxwKS/r7/wDL/h+oS12/rT/P/huh36/BuxsdTW01Sa8mguruSOK+hnSGK1hBVY2k3Id8js4AjUgnBwfTynUrGTTNVu7Ccq0lrO8LlehKsVOPyrqU+KGuth9QjtNRniu3vbWa6R82szD76KrKhxgEBlYDHA61yE00lxPJNO7SSyMXd2OSxJySalJ6X/rb/g/1s9Nf67/8D+t926toF+G2mXSwxi4fVLqN5Qg3soigIUnqQCxIHufWuerdudRtZPAOn6akubuHUrmeSPaeEeOEKc4xyUbjOeKwq0l8X3fkhu3LH+urNvwfoC+JvFVppcsrQxSb5JXQZYIiF22j+8QpA98Vs+M/BtvoWhaZq1lHcWv2qSSC6sLu5SaW1lUBlDMqJglGBKlcr0PPA5zQNcvfDWvWur6W4S6tX3IWGQeMEEehBI9ee1XdQ8WT3502JdPsbax02RpYrGJHaJ3Zgzs5kdnfdgA5boMDFJ62t/X9IlaXL3gjwiPEqalczW93dxWCRhbSykVJZ5JH2qN7KyoowzMxBwF/EdZdfCaxsZZ74SXOpaXIsJtBbXkcexXQu8ktw0ZQRoEb5toDZXGOh4238cXdrqmrXMGm6dFaavH5V1psMbw2zKMEBQjqy4Izw3c5yDirI+I+qSfbYb6ysb3T7sQr/Z0yyLBEsP8AqlQI6thRxgk575PNLXR/15/1+Qu/9f1/W5meMtATwv4vv9IhuDcw27qYpSMFkZQ6k++GFW9EtLeX4e+KbmW3ieeB7IRSsgLR7pHDbT1GcDOOtY2s6xea/rNzqmpOJLm5fc5VQoHGAAB0AAAH0rU0jVLO18DeI9Pnm2XV69obePaTvCOxbkDAwCOuKzafIl6fmV1Odq1ptjLqmq2lhblVlupkhQucAMzBRn2yaq1Jbzy2tzFcW7mOaFw8bjqrA5B/OtVa+pLvbQ9D8V/Dqx0jwzqOo2H2yCbTLlInjvZ0ZrqFmMYnWNUBiUuDtDFtwyQeOeY8GeHB4m117aUzfZ7a3ku51tl3SyIgzsjHPzscKODjOcHGKm17x1qOv2t1DLbWlqb6dbi+ltxJvu5FGFLl3bAGSQq7V56cDBb+Ob6y8S2mtaZYabp81tbC2MNnAYop02lWLgNkswPLAg8AjBFTG6vff/gf5/8ADdBvpb+tf8v+H6nYSfCe23W95FHfPbmzmkn0yC5juLgXCSLGIBKqBclpEydh24YHJFcj458L23hnULD7BOZba/skuVQzrMYWyVePzEAV8Mp+YAA/qZoviLqdtPEtpZWNvp8VlLYjTY1kELRSnMgJ3+ZliAd2/PA5xxWLruv3Ov3UElxFBbw2sC21tbW6kRwxr0UbiWPJJJYkkk80/T+t/wDgf1uR2d/62/4P9bavge0trtvEH2q3in8nQ7qWPzEDbHAGGGehHY9a5auj8H6rZ6W2tm/m8r7Vo9zbQ/KW3SOBtXgHGcdTxXOUP4vl+rEtn6/ogr0+8+FltZ6HqAma6h1Cx077Z9plnQQ3TqqySRxQ7N5VUcAyb8buMc4HmFdZdfEPVrvS2tpbez+1SWK6dJqO2Qzvbr/yz5coAeMkKCe560P4dP63/r+rM15l/X9f16rE8P6PJ4g8R6fpEDiN724SESEZCbjgtjvgc4r0mP4TadqCR3No2o2EEF263VvcTRz3D2wiaVJVRUUxs4jYBGDH5lPTr58/iW4C6M1lZWFhc6Od0V1a24WWZwwYPKSTvII44rc/4WjrUOpRXum2tjpzrevfzrbrIRdTMpVjIXdmxtZhhSoG4kYOCHpbz/r/AIP9bEd7v+v60/rRx+NfB9v4f0nStRtFmtjeNNDcWNxcpcSWssZHys6KoyVdSV2gqcg88Cj8PrWC9+IeiW15BHcQS3aLJFKgZXHoQeCKq634kn1q1s7MWlrYWNkHMFrah9oZzl3LOzOzHA5LHgDGKl8D6laaP460jUNRl8m1trpZJZNpbao6nABJ/CiPxCqfA7djFnAFxIAMAOcAfWo6kmYPPIy8gsSPzqOpWxrUtzux6f4f+Fltqel6at611Hc6naG4ivfPSO3hZgxhhCFC0znYWYKy7VOe2T5iBuYAdScV1dh8Q9W0/SrK0S3s5Z9Oilhsb6VZGmtUk+8EG/Z3OCVJGeDwMYg1fHhz+yP7Psf+Pr7R9t8n/SR8u3y/Mz9zvtx15qtOdt7f8H/L+urzV7a/1p/melS/By3na502zlurbU7WSBFnup0Md7l0SZ44ggZURpBhizBsEdc4xfFvgGx0rwxcatpi3ts9neiCS3vrhHklhfcI59qopjDFGwp3EjBBxyc67+Jmt3XmTxx2ltqM5t/tOoxK5muPJwYwdzFFGVUkIq5KjPHFUvEHjW98QWk1s9nZ2Md1dm+uvsokzczkEb3MjseMthVwo3HjpUu9tN/+G/4P9bVGy3/rT/P+uhjaaiyataI6hladAykZBG4cVqeN7eG08fa7b2sMcEEV/MkcUahVRQ5wABwB7VlafKkGpWssp2pHMjMcZwAQTWh4wv7bVPGus39hJ5ttc3sssUm0ruVnJBwcEcetU+nz/QUftfL9TGrvvB/gWy1fQbfVdXS8eC6vTb77e4SCO1iULvmkd0YHmRVVOCxyASSBXA10eheNLzQ9K/s02VlqFml4t9FDeCQrFOowHAR13cY4bcvHTrTVuonfoZuv6S2g+I9Q0mSUTNZXMkBkAxv2sRnHbOOld9afC60uNDjDtdx382k/b4bt50S3llKGVbdIym5z5YyzB8LnkdM8R/wklxLBrAvrSxvrnV3Ekt5cwBpoWDFiYmGAm4nB46cVpf8ACwNUOkx2jW9o1zDp502LUGVzPHbEnMYG/wAscEru2bsHr3qNeS3X/gf52/rQv3ea/T/hv0v/AFqum1P4WWtjoOqZa6h1HTbIXPnzXCeTeMqq0yxRbA+xA4HmFsFuMDPHl9dVqPxC1bUtPmhnhtVu7m1SzuNQUSGeaBMYjOXKKDgZ2qpOOTyc8rRrzP8Ar+un9auV8K/r+uv9aLofGltBa6xZpawxwo2l2MjLGgUFmtoyzcdySST3Jrnq3fFmo2up6pazWMvmxx6bZwMdpGHjgRHHI7MpGelYVXL4nbu/zKlbT0X5IKKKKkk3fCPh6LxNrb2Vzf8A9nwx201zJceSZdqxoWPygjPArr9X+ES6Zqlna2+rz38czzi4kiskj+zrFGkm8+ZMqbcSLksygHPJ4z5/puq3uj3Ek+nTeTJLDJA7bFbKOpVhyD1BIz1rcf4j+KpLgzS6msjESBlktYWRxIio4ZCm1gVjQYII4p/5fiEdN/6VtPxNaT4a20HiRdNm15DFPp0d9aGNIWmut77REi+eI2fO7hZTkDjJOBd8M+B49V0TxTppikt57S7tD9ov7HZcwRAStJiIFm3FV+4pJOB25HKXHjbWru+S7vGsbmWO3W1jE+mW0iRxKSVVUaMqoGT0A446cUxfGniFLq7uU1ORJ7y4iuZpFVQxkiz5ZBA+ULkgAYGOMYFJ7Nf1un+X9dQvp/Xb/P8AroZN4tql5IthNNPbg/u5J4hE7D3UMwH/AH0a39O/5Jjr3/YSsf8A0C4rC1C/n1TUJr288szztukMUKRKT67UAUfgPer9pq0EHg7U9JdJDPd3dtOjADaFjWUMCc5z+8GOPWnH4Gnvp+aLi0pff+TMetLw9pia14m0zS5ZDEl7dxW7SAcqHcKT+tZtPilkgmSaCRo5Y2DI6NhlI5BBHQ04tJpszeqPSfGnhPRrPwrf3tla2unahpupLbvbW9xLLmF94RZWdmXzv3e4qmMA8gHgc98PPDkXiTxDcQ3Fv9rW0sprtbTzPLFyygBYy+RtBLAk5HAPI6jN1jxZrOvQLDqVzG0Qma4ZILaKBZJWGDI4jVd74/ibJ5PPJp9x4y1678Str9xf79SdPLeUwx7XTZs2sm3ayleCCMHvUJNLf+rf5lSae39a/wCR6Z/wrnQbmxTXdNi066RLBjJZrdSx2RmWby3l8138zyUBJJ3DJTg4ODwfxC0TTNF1qxbQ2Bs7/TobxQgcIpbIOwOS4UldwDEnBGapf8Jrrw1L7b9ri3/Zvsnk/ZIfIEPXy/J2+Xtzzjb15681m6tq99rmoNe6pcGedlC52hQqgYCqoACqB0AAAos9P67/APAF/X5f8E6DwH/qvFH/AGALj/0KOuSrc8Na1b6Mmsi6SV/t+ly2cXlgHDsVIJyRx8p6Z+lYdTZ+0b8l+bBbfP8ARBXsGs/D3RNP0jWLB4raC+0/S1vbW5WeR7i62BTJJIm8xxxksUUYDHGckAk+P1t3XjDXL3SW064vFaB0SORlgjWWVE+4ryhQ7qMDAZiOB6CqldxsgXxJsXwZocXiXxlpmj3MrRQ3UwWRk+9tAJIGe5xge5rsvEXh/wAO6XodprU2k26zW+qmzvdM0+9lMYBjLrG8rl8uuAH2ED5sDBGRxNz4r1q7XSRNft/xJkCWDIioYACCMFQCTkDk5NT3fjXW76e3kuprSRbZ3kjg/s+3EG9vvO0QTYzH+8yk1Se1+/8Al+n3dBa3/rzLPxI0ix0H4happuk2/wBns4Gj8uIOzbcxqx5Yknknqam+Fn/JTNI/3pP/AEU9Y2v+JNT8T3wvdakgmucYaWO1ihZ+g+Yxqu7gAZOcVY8F63beHPGFjqt8kskFuXLrCAWOUZeASB1PrUJPlsxswqKKKoD2DRPh7ok2k6Ra6lFbLLq+ltcw37zyfaGuCrOFjjV9gjjVRuZ1OScA5OB5HDH51xHFuVN7BdzHAXJ6n2rXg8Ya5b6R/ZsN4qwCFoFfyIzMkTHLRrKV8xUOTlQwHJ45NVpfEGpzeG4dBkud2mQTm4jg8tflkIwW3Y3Hg9M4oWk7vVf8H/IWvLb+tv8APoeleJvA3h/StN1+B7SOC40TyJYfIuZDc3MPmLG7TFi0aF925AqggYJGMbuU+IWmaRYNoFzoWnf2dDqOlR3bw+e8uGZ3H3mPoB0wPYVm3njbX9QtPs13eRyRlomlP2WINcGMYTzmC5mx6OWqPW/Fur+IrW2t9Ve0kjtVCQeTYQQmNRnCBo0U7eT8ucd8Umv6+Raa10/rT/g/eReFf+Rx0b/r/g/9GLT/ABf/AMjxrv8A2Ebj/wBGNVTRb2PTte0++nDNFbXMczhBliFYE4z34p2vX0WqeI9S1C3V1iuruWdFcAMFZywzjPODTe6+f6Err8v1M+vUPBfg3R5/DWk6prVva3EOqX7W801xPIpgAZUWKFI2UvM5YnLZVQuSAM58vrb0fxdrWg2n2bS7pI4hL5yCS2ilMUmNu+MupKNjHzKQeB6U+hLv0Keu6emk+ItR06JzIlndSwK56sEcqD+lenD4f6GmkfYbmK2juJNB/tC2vRPI1xPMIxMzBA3lrAB+7yyhiRwTyR5rbeIdVtNL1LToLtha6qUN4jKrGYoxZSWIJHJJ4Iz3qz/wmOu/2N/Zf21Rb/Z/su8QR+cYc58rztvmbM/w7sY4xiiNlGz1/wCG/wAy9Oa/9dD0DxP4C0PTdI8Q2aQ21rfaPbxT20y3Ejz3CAosjzAsY0Dl/kUBWOM9OW8jrc1DxhrmqaY9he3qvDIIxMywRpJceWMJ5siqHkx23k9AeorDqVf+v6/r8A0tY634lf8AI4D/ALB9l/6TR1yVbni7WrfX9eF7ZpKkX2W3hxKAG3Rwqh6E8ZU49qw6p7sX2V6L8kdx4H8N2eo+HdZ1m9gs7o2LwxBL6eSK3gV9xaaTy2VzgJtUKclmxgnArM+IGi2GgeNLqz0cubFkingWTO5FkjV9vPPG7HPOOpJ5rM0jxBqOh/aF0+WIR3KhZ4Z7eOeKQA5XKSKykg8g4yOcdasxeL9eh1PU9QXUXN3qsD295K6K5ljfG5eQdo4AGMYAwMUOzen9af5/d5jjbr/X9fj5He+DvA+h3mh+HZNZtoHTXXmR7qSeQTRvv8qOO3jRgGYEb2Z1ZQOuOAbunfDbRI7XTtN1JbRpdS0+SaHUvPkM0lxh2AijV9giRUBZnU5zgHJwPNtN8Ya5pGnrZWF6scUZkMLNBG8lvvGH8qRlLxZHXYR69aSDxhrlvpH9mw3irAIWgV/IjMyRMctGspXzFQ5OVDAcnjk1M7u/Lp/X6f1rqEbK1/61/rT+liV03ib/AJFjwj/2DZf/AErnrma2NY1aDUNH0K0hSRZNOtHglLgAMxnkkBXnphx1xzmr+xbzX5McXZP0/VGPXWfD7w9B4g1TUTc2y3gsNPlu0tZJvKjmcFVAd9y7UBfcTkcL1FcnV7StYvtEvTdabMIpGjaJw0ayJIjDDKyMCrKR2IIpIk6P4haDpWkzaRd6G8HkajZeZJHbtIYllR2RzH5hL+WSuVLEk8npgVf8EeGNMuvCV34g1a3s7mGK+S2lN9NJHFaxBN7yYjZXkdsqioO56HtzsXjTX4PEltr0N8I9QtYxFbusEYSFApUIke3Yq4J4C45J61BpPijVtF84WE8WyaRZXjuLaKdC652uFkVgGGThgM80lp/Xn/kEtdv60/zPXJfhf4c0TVLeK9ggudP1DUXh+0XU8iywKSqxQQpG43yksSWYFQFyQO/jGr2I0zW76wWTzRa3EkIkH8W1iM/jitS08ceIrNZPK1Eu8kzziaeGOaWORxhnjkdS0bHuykHgelYBJZiWJJJySe9Sk1a7/rT/AIPqPTX+u50t5/ySzSf+wvef+ireuZrYn1aCXwXY6QqSfaLe/nuXYgbCrpEoAOc5zGc8elY9aS1l935IbfuxX9bs6PwFoMHiXxtYaZeLJJDJ5kjxRnDShI2fYD23bcZ961/G/h7SrLwxpOraallbXUs81re21jNJLAHUKw2PIzFiA4VirFdw49Tx+najd6TqUF/ps7291buHjlTqp/qOxB4I4NXrzxTq99d2FxNcRodObdaRwW0cMUJ3bsrGihAS3JOOcDOcUnrb+v60/wA+95Wlzd+H/hi31y11vULm3trs6bDGUgvJ2ggBkfBlldWVgiKGJAIJOB7Hsr74eeHLC1uNftEsrnTJo7aRVvpZ47ezjdCzykK4lckqAiZLHfggnp5qfGeuvrl9q0t4k13qA23fnW0Ukc444aJlKHG0EfLwRmnw+OPEEN/d3ZvY5pLwoZluLWKaNtn3MRupRdvRcAbRwMClro/6/r8Rd/6/4b+vMd490S08O+OdS0zTDIbSJ1aESHLKrorhT9N2Pwq3oH/JM/F//XSx/wDRj1zV9fXWp3817qE73FzO5eWWQ5Zie9amma1b2XhDXdKlSUz6i1sYmUDavluxbcc57jGAazcXyJen5ldTDq5pFh/amt2OnmTyvtdxHB5hGdm5guce2ap05HaN1dGKspyrA4IPrWq0epLvbQ9S8Z+C9EsPDOty2lrbWGoaPdxKsUNxJNI8DsUUzlmKCRsb9qAbR1AyK5T4feHIfE3iZ7a4ha5S3tZboWiyeWbpkXKxbsjaCcZORgZ5HUUNX8W61rlp9m1K6R4jL50git44vOkxjfIUUGRsZ+Zsnk88mnz+NNfudctNYm1AtfWcC28EvkoAsQBAQqF2sMMQcg5B5zUxTV7v+rf5jfS39a/5dT0dPh5oV5BbatYQ2F0y6dcyS2VvdSpZyTxSpHvEkj7/ACl8zLNvAPl5Bwa4n4g6HpekXmlXGhtH9n1HT0uGSEyGJZAzI3l+Zl9hKZG455/AUD43186hFefbY1aK3a1SFbWJbcRN96PyAvl7T1I28nnrWdq2s3+uXoutTn82RY1iQKiokaKMKiIoCqo9AAKf9fn/AMAa0Tv/AFt/wfvOg+H/AN/xJ/2L95/Ja5Gt3wvrdtojaubpJX+26XPZx+WAcO4GCckccc9T7VhUP4vl+rJWz9f0QV69qPw90Sw0jUrGaK2ju7XRjf2t0s8jXN0yorvIyhvLSHLGNQVDEjIJwTXkNbsvjLXZtG/suS9X7MYVt2KwRrK8S/djaULvZB/dLEcD0oesbL+tw15kyDwvpEeveLNL0mebyYr26jheQHBUMwBxnv6e+K9WtPhxoGsyZFhBaXVjqEkc2m2N1I7TReS8iQyO7MPOzFhthAAY9GGF8ou/E2sXtrpVvcXr+Xo6lbHYqo0GSG4ZQCTkA5JJq9P498ST3dtc/wBoLDJbXDXSfZraKBWlYYZ3VFAdiOCWByCR0JqtLW/ryCO92avjnw/pen+H9F1TTFs4ri4kntryGwlkkthJGVOY2kZmbhwCQxUlfl45Of8ADX/kpmgf9fqfzrJ1fX9R1z7ONQmjMdqhSCGCCOCKIE5O2ONVUEnkkDJ71P4R1eDQPGGmareJI8FpcLLIsQBYgegJAz+NKOkriqawaXYy7j/j6l/3z/OoqfK4eZ3HRmJGaZUrY1qNObaPXvDvw90S403QrfVIrbOt2TzJevPJ9oMxDlUhjVgoWMIGdnUj5sA5IA8iUbmA6ZOK3LPxlrun6SunWl6scCI8cbeRGZYkfl1SUrvQHJyFYDk+pqmNe1IeGzoP2n/iWG5+1+R5a/63bt3bsbunGM49qrTnbe3/AAf8upmtrP8ArT+v60PXJvhfoFxf33h8rb2F3aPaiC5SeSSeaMyRxySTKWMaBzJlFAVjjPTlue8aeE9Gs/Ct/e2Vra6dqGm6ktu9tb3EsuYX3hFlZ2ZfO/d7iqYwDyAeByN1428QXlmLabUCFJiZ5YoY45pTEP3ZklVQ8m3jG5jggHqBUWs+K9Y1+3EGpXMbQiZrho4LaKBZJWGDI4jVd74/ibJ5PPJqXe39eX9f1YqLS6f1Yo6V/wAhmy/6+I//AEIVr+P/APko3iH/ALCM/wD6GaxLKZbbULedwSsUquwHXAOaveKNUh1vxZquqWqyJBeXck8ayABgrMSAcEjPPrVPp8/0FH7Xy/Uyq9I8F+FdIm8KW2t6za2l1Dcan9lnkup5VW3iUL8saxMrNM5f5QcgBckAZI83rZ0bxXrGgW5g0y5jWIzLOqTW0U4jlUYEieYrbHx/EuD054FNW6idyPxPpUWheLNV0q3kaWKyu5IEd8bmVWIBOO+BXpFr4A0M6Lb2d5DbQ3F5oX2+3vmnkNxJP5ZmJ2Btiwqq7CzLkngEnO3za38SavbafqllFeuYNXKm+DqrtOVYsCWYFgcknIIz3qwPGGuLo39mC9UW/wBn+y7/ACI/O8jdu8rztvmbM/w7sY4xjio+xy9e/wAv8y7x5ua3y+7/AIY9E1n4e6Jp+kaxYPFbQX2n6Wt7a3KzyPcXWwKZJJE3mOOMliijAY4zkgEnx+tu68Ya5e6S2nXF4rQOiRyMsEayyon3FeUKHdRgYDMRwPQViUa8zZK+FI6bx3/yG7H/ALBGn/8ApLHXM1seJdWg1nUba4tUkRIrC1tmEgAJaKFEY8E8ZU49vSserlrJvzf5lSd7ei/JBWjfaZaWlpFNb63YXzyEBoLdJw8fGcsXiVeOnBP9azqKRJqXmk2VtcW0cPiDTbxZn2vLDHchYBx8z74lJHP8IY8Hjpkl0mzj1SK0TxBp0sMi5a9SO58qM88MDEHzx2Ujkc9cZdFIDVTSbJ9VktG8Q6akCJuW9aO58pzx8oAh3557qBweemUtNKs7m8uIZtf060jhOEuJo7gpPz1UJEzD1+YL1rLooA1LLSrO6Fx5+v6dZeUxVPPjuD5w/vLsibA/3tp9q6TRfCmjXvw91fU7nWtNS8hltRHI4uv9F379yOFiIJbAwRuA2nkd+HqZLy5itJbWK4lS3mZWlhVyEkK52ll6EjJxnpk0fZa9PzQLct/2ba/2P9t/tqx+0f8APhsn87rjr5fl9Ofv9Pfii6021t9OhuYdasbqWTbutIUnEkWRk7i0apx0OGPtkc1nUUwNS80mztprZIfEGnXizPtd4I7kCAcfM++JSRz/AAhjweOmSfSrOLU4bWPX9OnhkGWvI47gRRdeGDRB+38KnqPesuikBqnSbIasLT/hINNMBTd9t8u58oH+7jyd+f8AgGPeiDSLKXUZ7aTxDpsMUQBS6kjuTHN7KFhLjH+0o6VlUUAdv4J8K6NrEevNqOr6e5tNNuZIVYXIMbIV2z/LHgpz05bn7lc6mkWTQXUh8RaarQOyxxGO53XAA4ZMQ4APQbip9QKo295c2fm/ZLiWDzozFL5TlfMQ9VOOoOOQeKgo6gtDRGm2p0c3p1qxFx/z4FJ/OPOOvl+X05+/09+KJtMtItJS7TW7CadgCbJEnEq56gkxBOPZz7ZrOooYGne6VZ2scDQa9p96ZWCukEdwDCPVt8SjA/2ST7U650iygvbeCLxDptzHMSHuIo7kJB7sGhDH/gIasqigRpvpVmmrR2a6/pzwOu5r5Y7jyUPPBBiEmeOyEcjnrjpPAXhXR9Y+IFtpuo6vp97ab8bEFyn2vKMcIfLUjaQM7tvtmuIqe0vLmwukurG4ltriM5SWFyjrxjgjkcUDNNND097yaFvFOkpHGqlZ2iu9kuc5CgQFsjHOQOvGar2Gl2l5bzSXGu6fYNGSFiuEuC0vHVfLiYe3JFZtFAGjFplpJpLXb63YRTqCRYuk/nNjsCIjHz7v9cUSabappC3i63YSTkDNiqT+cMnHUxCPjr9+s6igDRutNtbfTobmLW7G6lk27rWFJxJFkZO4tGqcdDhj7ZHNPvNJs7We2jg8QadeLM215II7kLAOPmffEpI5/hDHg8dKy6KYHTaL4d0y58X6fp8/iDTLm1llj3yIl0qyZkAMQzCGDEHrgL/tA1J4j8OaVZeNtR06117Tba1juZ1Qul0y24WQgRN+6LFsdxuHH3q5iKWSCZJoJGjljYMjo2GUjkEEdDSzzy3NxJPcyvNNKxeSSRizOxOSSTyST3pdgNG30iymvriCTxFptvHDjZcyR3Jjn/3QsJYY/wBpVpLLSrO6Fx5+v6dZeUxVPPjuD5w/vLsibA/3tp9qy6KANG0021udOmuZtasbSWPO21mScyS4GRtKRsnPQZYc9cDmj+zbX+x/tv8AbVj9o/58Nk/ndcdfL8vpz9/p78VnUUwNG5021g02G5i1uxuZpNu60iScSx5GTuLRhOOhwx9s1PNo1hFdW0SeJdLmSYkPMkV0FgwM/PmEE56fKG98Vj0UAdv458K6No/iK2ttO1jT7eGW3ti8ZF0xiLQqzSsTGflYnOFJI3D5RyBzp0iyGqraDxDppgKbjeiO58oH+7jyd+f+A4561Qury5vZvNvbiW4lCqm+Vy7bVGFGT2AAAHYCoaXUOi9EacOlWcuqTWj6/p0MMa5W9eO4MUp44UCIvnk9VA4PtlbTSbO5uLmObxBp1okLYjlmjuSs455TZExA4/iCnkcdcZdFAGjaabaXNjNPNrdhaSRltttMk5klwMjaUiZeeg3MPfA5oi0y0k0lrt9bsIp1BIsXSfzmx2BERj593+uKzqKANQ6TZjT4bj/hINOMshUNa+Xc+ZFk8lj5W3jqcMfbNdH4m8K6NpvhHw9e2Ws6c9xdQyGZ0F0ftRE7KHUNEAoVeCDtJ2nAbjPEVNLeXM9vBBPcSyQ26lYY3clYgTkhQeACSTx3oe3z/R/1/SAu3mlWdtd20MOv6deJM2HngjuAkAyOXDxKxHOflDHg+1Ok0myTVIrRfEOmyQyKWa9WO58qM88MDCHzx2Ujkc9cZVFMDUj0mzfVZLRvEGnRwIm5b1o7nypDx8oAiL557qBweemS00qzuby4hm1/TrSOE4S4mjuCk/PVQkTMPX5gvWsuikBqWmlWdzHcNNr+nWhicqizR3BMwH8S7ImAB/2tp9QKZBptrNpUl3JrdhBMgbFlIk5lfHTBWIpz2yw98VnUUAdxd+FNGg+GMOrRa1psl8dQljMyC6/eqIkYQgGIAMCSckAcj5vTmLrTbW306G5h1qxupZNu60hScSRZGTuLRqnHQ4Y+2RzVQ3lybJbM3EptVkMqwFzsDkAFgvTOABn2qGm92/T8g6I1LzSbO2mtkh8QadeLM+13gjuQIBx8z74lJHP8IY8Hjpkn0qzi1OG1j1/Tp4ZBlryOO4EUXXhg0Qft/Cp6j3rLopAav9kWX9q/ZP8AhItN8ny9/wBt8u58rP8Adx5O/P8AwHHvRb6TZTahPbyeINNgii+5dSR3Jjm/3QsJcf8AAlFZVFAGnZaVZ3c1yk+vafZLC2EknjuCs455XZExA4/iCnkcdcdN4d8KaNqPgPXtRvNZ05Lu3+zeVJILr/Q90hDbwsRDbgMDG/HfFcNU8V5cw2s9tDcSxwXG3zokchZdpyu4dDg8jPShgWv7MtP7Ja8/tuw88dLHZP5x+bHXyvL6c/f6e/FF1ptrb6ZFdRa1Y3U0m3daRJOJY8jJ3FownHQ4Y+2azqKBmne6VZ2scDQa9p96ZWCukEdwDCPVt8SjA/2ST7U650iygvbeCLxDptzHMSHuIo7kJB7sGhDH/gIasqigk030qzTVo7Ndf054HXc18sdx5KHnggxCTPHZCORz1w6PSbJ9VltG8Q6bHCiblvWjufKkPHygCEvnnuoHB56ZyqKYzt/BXhXR9Xk10ajq+nyC0066kgBFyuGRQVuPlj5QZ6H5v9iufGj2JiumPiTTAYGYRoY7rNxgZBT9zgA9BuK89cDms+2vLmzMptLiWAzRtFJ5Tld6N95TjqD3HQ1BS6gjRi0y0k0lrt9bsIp1BIsXSfzmx2BERj593+uKJNNtU0hbxdbsJJyBmxVJ/OGTjqYhHx1+/WdRQBo32mWlpaRTW+t2F88hAaC3ScPHxnLF4lXjpwT/AFp95pNlbXFtHD4g028WZ9rywx3IWAcfM++JSRz/AAhjweOmcuimBqS6TZx6pFaJ4g06WGRctepHc+VGeeGBiD547KRyOeuN7wV4Y0jVfiBY6Zf6xp93ZtcRqVQXKi7DdUQ+WGBHTLbB6E1xtTWt1cWV1Hc2U8lvPE26OWJyjIfUEcg0LRildppGxLoOnDVbi2HifSY4oxlZmiuyjHJGwYgLZGOcjHIwTzVWy0qzuhcefr+nWXlMVTz47g+cP7y7ImwP97afaswksxLEkk5JPekqUtC5NOTaNGDTbWbSpLuTW7CCZA2LKRJzK+OmCsRTntlh74o/s21/sf7b/bVj9o/58Nk/ndcdfL8vpz9/p78VnUUyUaNzptrBpsNzFrdjczSbd1pEk4ljyMncWjCcdDhj7Zp19pVnaSW6wa9p98Jmw7W8dwBAOOW3xKSOf4dx4PHTOZRTA6G00DTX120tG8S6VNDKwLypHdhPvAbOYQ2Tk4IGOOSKv+L/AAzpOm+PNQ02y1zTbS0S5mVQ63TC1CtgRufKJJ7ZXcOOTXIo7RuroxVlOVYHBB9afc3M95dSXN3NJPPKxeSWVyzOx6kk8k+9Lt8w7/L9TQg0iyl1Ge2k8Q6bDFEAUupI7kxzeyhYS4x/tKOlNstKs7ua5SfXtPslhbCSTx3BWcc8rsiYgcfxBTyOOuMyigDRtNNtLmxmnm1uwtJIy222mScyS4GRtKRMvPQbmHvgc0DTbU6Ob061Yi4/58Ck/nHnHXy/L6c/f6e/FZ1FAGjNplpFpKXaa3YTTsATZIk4lXPUEmIJx7OfbNTy6LYRvbKvibSpRM2HZIrrEAxnLZhGR2+Xcc+3NY9FAHY+P/DelaDJph0m/s5DPp1tJJBD55d2aPc02ZEACseQM5GR8o7cdU1zeXN4yNd3Es7RxrEhlcsVRRhVGegA4A7VDR1b82B//9k="}}},{"cell_type":"markdown","source":"## FPN with resnet34 weights data prepare","metadata":{}},{"cell_type":"code","source":"class Sartorius(Dataset):\n    def __init__(self, df, img_folder, split='train', transform=None, test_size=0.1, random_state=42):\n        \"\"\"\n        Dataset class for loading and preprocessing cell images and masks.\n        :param df: DataFrame containing the dataset information.\n        :param img_folder: Path to the folder containing images.\n        :param split: Specifies if the dataset is for training or testing. Expected values are 'train' or 'test'.\n        :param transform: Optional transformations to be applied on the images and masks.\n        :param test_size: Proportion of the dataset to be used for testing.\n        :param random_state: Seed for reproducible splits.\n        \"\"\"\n        self.df = df\n        self.img_folder = img_folder\n        self.transform = transform\n        self.split = split\n        self.cls_map = {cell_type: idx for idx, cell_type in enumerate(df['cell_type'].unique())}\n\n        # Splitting the dataset into training and testing\n        train_df, test_df = train_test_split(df, test_size=test_size, random_state=random_state)\n        if split == 'train':\n            self.images_filenames = train_df['id'].unique()\n        elif split == 'val':\n            self.images_filenames = test_df['id'].unique()\n        else:\n            raise ValueError(f\"Invalid split name: {split}. Expected 'train' or 'val'.\")\n        \n    def decode_rle_mask(self, rle_mask, shape=(520, 704)):\n        \"\"\"\n        Decodes a run-length encoded mask.\n        \"\"\"\n        rle_mask = rle_mask.split()\n        starts, lengths = [np.asarray(x, dtype=int) for x in (rle_mask[0:][::2], rle_mask[1:][::2])]\n        starts -= 1\n        ends = starts + lengths\n        mask = np.zeros(shape[0] * shape[1], dtype=np.uint8)\n        for start, end in zip(starts, ends):\n            mask[start:end] = 1\n        mask = mask.reshape(shape)\n        return np.uint8(mask)\n\n    def __len__(self):\n        \"\"\"\n        Returns the total number of images in the dataset.\n        \"\"\"\n        return len(self.images_filenames)\n\n    def __getitem__(self, idx):\n        \"\"\"\n        Returns the image and mask for a given index.\n        \"\"\"\n        img_id = self.images_filenames[idx]\n        img_path = os.path.join(self.img_folder, f\"{img_id}.png\")  # Adjust the extension if necessary\n        image = cv2.imread(img_path)\n        if image is None:\n            raise ValueError(f\"Image at {img_path} cannot be read.\")\n\n        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n        \n        # Handling multiple masks per image, if necessary, can combine them here\n        _, rles = self.get_targets_masks(img_id)\n        #mask = np.zeros((520, 704), dtype=np.uint8)  \n        masks = [self.decode_rle_mask(rle, shape=image.shape) for rle in rles]\n        # Assuming decoded_masks is a list of 2D numpy arrays (binary masks)\n        combined_mask = np.zeros_like(masks[0], dtype=np.float32)\n\n        # Overlay masks - this simple approach adds them up\n        for mask in masks:\n            combined_mask += mask\n\n        # If you want to cap the values to a maximum (e.g., 1 to keep it binary-like), you can do:\n        mask = np.clip(combined_mask, 0, 1)\n\n        if self.transform is not None:\n            transformed = self.transform(image=image, mask=mask)\n            image = transformed['image']\n            mask = transformed['mask']\n\n        return image,mask\n\n    def get_targets_masks(self, img_id):\n        \"\"\"\n        Retrieves targets and masks for a given image ID.\n        \"\"\"\n        targets = self.df[self.df['id'] == img_id]['cell_type'].apply(lambda x: self.cls_map[x]).values\n        rles = self.df[self.df['id'] == img_id]['annotation'].values\n        return targets, rles\n    \n    def encode_rle_mask(self, mask, shape=(520, 704)):\n        \"\"\"\n        Encodes a binary mask to run-length encoding (RLE).\n        :param mask: Binary mask to encode.\n        :param shape: Shape of the original mask before flattening.\n        :return: Run-length encoded mask.\n        \"\"\"\n        pixels = mask.flatten()\n        pixels = np.concatenate([[0], pixels, [0]])\n        rle = np.where(pixels[1:] != pixels[:-1])[0] + 1\n        rle[1::2] -= rle[::2]\n        return rle.tolist()\n","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:39.973328Z","iopub.execute_input":"2024-05-06T04:13:39.973698Z","iopub.status.idle":"2024-05-06T04:13:39.993553Z","shell.execute_reply.started":"2024-05-06T04:13:39.973668Z","shell.execute_reply":"2024-05-06T04:13:39.992561Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Sartorius(df,in_path+'sartorius-cell-instance-segmentation/train',split=\"train\").__getitem__(0)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:40.451134Z","iopub.execute_input":"2024-05-06T04:13:40.452039Z","iopub.status.idle":"2024-05-06T04:13:40.782281Z","shell.execute_reply.started":"2024-05-06T04:13:40.452005Z","shell.execute_reply":"2024-05-06T04:13:40.781270Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_dataset = Sartorius(df,in_path+'sartorius-cell-instance-segmentation/train',split=\"train\")\nval_dataset = Sartorius(df,in_path+'sartorius-cell-instance-segmentation/train',split=\"val\")","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:40.913518Z","iopub.execute_input":"2024-05-06T04:13:40.913836Z","iopub.status.idle":"2024-05-06T04:13:40.975214Z","shell.execute_reply.started":"2024-05-06T04:13:40.913810Z","shell.execute_reply":"2024-05-06T04:13:40.974329Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def display_few_examples_from_data(dataset, n=1):\n    figure, ax = plt.subplots(nrows=n, ncols=2, figsize=(10, 24))\n    for i in range(n):\n        image, mask = dataset.__getitem__(i)\n        ax[i, 0].imshow(image, cmap='gray')\n        ax[i, 1].imshow(mask, interpolation=\"nearest\")\n\n        ax[i, 0].set_title(\"Image\")\n        ax[i, 1].set_title(\"Mask\")\n\n        ax[i, 0].set_axis_off()\n        ax[i, 1].set_axis_off()\n    plt.tight_layout()\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.086266Z","iopub.status.idle":"2024-05-06T04:13:16.086626Z","shell.execute_reply.started":"2024-05-06T04:13:16.086453Z","shell.execute_reply":"2024-05-06T04:13:16.086477Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"display_few_examples_from_data(train_dataset, n=2)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:16.087554Z","iopub.status.idle":"2024-05-06T04:13:16.087874Z","shell.execute_reply.started":"2024-05-06T04:13:16.087716Z","shell.execute_reply":"2024-05-06T04:13:16.087730Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"aug = A.Compose([\n    A.RandomResizedCrop(640, 640, scale=(0.8, 1.0), ratio=(0.9, 1.3)),\n    A.HorizontalFlip(),\n    A.RandomRotate90(),\n    A.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.2, p=0.5),\n    A.GaussianBlur(blur_limit=(3, 7), p=0.5),\n    A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.5),\n    A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.5),\n    A.CoarseDropout(max_holes=8, max_height=64, max_width=64, min_holes=1, min_height=32, min_width=32, fill_value=0, p=0.5),\n    A.Normalize(mean=[0.485], std=[0.229]),\n    ToTensorV2()\n])","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:44.412655Z","iopub.execute_input":"2024-05-06T04:13:44.413322Z","iopub.status.idle":"2024-05-06T04:13:44.420979Z","shell.execute_reply.started":"2024-05-06T04:13:44.413291Z","shell.execute_reply":"2024-05-06T04:13:44.419998Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class CellTestDataset(Dataset):\n    def __init__(self, image_paths, transform=None):\n        self.image_paths = image_paths\n        self.transform = transform\n\n    def __len__(self):\n        return len(self.image_paths)\n\n    def __getitem__(self, index):\n        image_path = self.image_paths[index]\n        image = cv2.imread(image_path, cv2.IMREAD_COLOR)  # Assuming you're working with RGB images now\n        if self.transform:\n            image = self.transform(image=image)['image']  # Use the correct key for albumentations\n        return image, os.path.basename(image_path)\n        \n        # Apply transformations\n        if self.transform:\n            image = self.transform(image)\n        \n        return image, os.path.basename(image_path)  # Also return filename for future use\n    \ntest_image_paths = ['/kaggle/input/sartorius-cell-instance-segmentation/test/7ae19de7bc2a.png',\n                    '/kaggle/input/sartorius-cell-instance-segmentation/test/d48ec7815252.png',\n                    '/kaggle/input/sartorius-cell-instance-segmentation/test/d8bfd1dafdc4.png']\ntest_dataset = CellTestDataset(test_image_paths, transform=aug)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:23:38.720230Z","iopub.execute_input":"2024-05-06T04:23:38.720626Z","iopub.status.idle":"2024-05-06T04:23:38.730369Z","shell.execute_reply.started":"2024-05-06T04:23:38.720596Z","shell.execute_reply":"2024-05-06T04:23:38.729341Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_dataset = Sartorius(df,in_path+'sartorius-cell-instance-segmentation/train',split=\"train\",transform=aug)\nval_dataset = Sartorius(df,in_path+'sartorius-cell-instance-segmentation/train',split=\"val\",transform=aug)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:45.962898Z","iopub.execute_input":"2024-05-06T04:13:45.963581Z","iopub.status.idle":"2024-05-06T04:13:46.024250Z","shell.execute_reply.started":"2024-05-06T04:13:45.963549Z","shell.execute_reply":"2024-05-06T04:13:46.023324Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def IoU(preds, targs, eps: float = 1e-8):\n    \"\"\"Computes the Jaccard loss, a.k.a the IoU loss.\n    Notes: [Batch size,Num classes,Height,Width]\n    Args:\n        targs: a tensor of shape [B, H, W] or [B, 1, H, W].\n        preds: a tensor of shape [B, C, H, W]. Corresponds to\n            the raw output or logits of the model. (prediction)\n        eps: added to the denominator for numerical stability.\n    Returns:\n        iou: the average class intersection over union value\n             for multi-class image segmentation\n    \"\"\"\n    num_classes = preds.shape[1]\n\n    # Single class segmentation?\n    if num_classes == 1:\n        true_1_hot = torch.eye(num_classes + 1, device=targs.device)[targs.squeeze(1)]\n        true_1_hot = true_1_hot.permute(0, 3, 1, 2).float()\n        true_1_hot_f = true_1_hot[:, 0:1, :, :]\n        true_1_hot_s = true_1_hot[:, 1:2, :, :]\n        true_1_hot = torch.cat([true_1_hot_s, true_1_hot_f], dim=1)\n        pos_prob = torch.sigmoid(preds)\n        neg_prob = 1 - pos_prob\n        probas = torch.cat([pos_prob, neg_prob], dim=1)\n\n    # Multi-class segmentation\n    else:\n        # Convert target to one-hot encoding\n        # true_1_hot = torch.eye(num_classes)[torch.squeeze(targs,1)]\n        true_1_hot = torch.eye(num_classes)[targs.squeeze(1)]\n\n        # Permute [B,H,W,C] to [B,C,H,W]\n        true_1_hot = true_1_hot.permute(0, 3, 1, 2).float()\n\n        # Take softmax along class dimension; all class probs add to 1 (per pixel)\n        probas = F.softmax(preds, dim=1)\n\n    true_1_hot = true_1_hot.type(preds.type())\n\n    # Sum probabilities by class and across batch images\n    dims = (0,) + tuple(range(2, targs.ndimension()))\n    intersection = torch.sum(probas * true_1_hot, dims)  # [class0,class1,class2,...]\n    cardinality = torch.sum(probas + true_1_hot, dims)  # [class0,class1,class2,...]\n    union = cardinality - intersection\n    iou = (intersection / (union + eps)).mean()  # find mean of class IoU values\n    return iou","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:46.418877Z","iopub.execute_input":"2024-05-06T04:13:46.419718Z","iopub.status.idle":"2024-05-06T04:13:46.430156Z","shell.execute_reply.started":"2024-05-06T04:13:46.419683Z","shell.execute_reply":"2024-05-06T04:13:46.429015Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class CombinedLoss(nn.Module):\n    def __init__(self, weights=None):\n        super(CombinedLoss, self).__init__()\n        if weights is None:\n            weights = [1.0, 1.0, 1.0, 1.0, 1.0]  # Default weights: equally balanced\n        self.jaccard_loss = smp.losses.JaccardLoss(mode='binary')\n        self.dice_loss = smp.losses.DiceLoss(mode='binary')\n        self.tversky_loss = smp.losses.TverskyLoss(mode='binary', log_loss=False)\n        self.focal_loss = smp.losses.FocalLoss(mode='binary')\n        self.lovasz_loss = smp.losses.LovaszLoss(mode='binary')\n        self.weights = weights\n\n    def forward(self, inputs, targets):\n        jaccard = self.jaccard_loss(inputs, targets)\n        dice = self.dice_loss(inputs, targets)\n        tversky = self.tversky_loss(inputs, targets)\n        focal = self.focal_loss(inputs, targets)\n        lovasz = self.lovasz_loss(inputs, targets)\n        total_loss = (self.weights[0] * jaccard + self.weights[1] * dice + \n                      self.weights[2] * tversky + self.weights[3] * focal + \n                      self.weights[4] * lovasz)\n        return total_loss\n","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:13:47.282872Z","iopub.execute_input":"2024-05-06T04:13:47.283547Z","iopub.status.idle":"2024-05-06T04:13:47.292633Z","shell.execute_reply.started":"2024-05-06T04:13:47.283514Z","shell.execute_reply":"2024-05-06T04:13:47.291652Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n\nclass SegModel(pl.LightningModule):\n    def __init__(self, train_dataset, val_dataset, test_dataset=None, encoder_name='tu-resnext26ts',\n                 learning_rate=8e-6, weight_decay=1e-4, freeze_encoder_until_epoch=5):\n        super(SegModel, self).__init__()\n        self.batch_size = 4\n        self.learning_rate = learning_rate\n        self.encoder_name = encoder_name\n        self.freeze_encoder_until_epoch = freeze_encoder_until_epoch\n        self.net = smp.MAnet(encoder_name=encoder_name,#PSPNet\n                           encoder_weights=\"imagenet\",\n                           in_channels=1,\n                           classes=1)\n\n        # Initially freeze the encoder\n        for param in self.net.encoder.parameters():\n            param.requires_grad = False\n        \n        self.trainset = train_dataset\n        self.valset = val_dataset\n        self.testset = test_dataset if test_dataset is not None else val_dataset\n        self.weight_decay = weight_decay\n        self.criterion = CombinedLoss(weights=[1.0, 0.5, 0.5, 0.2, 0.2])\n\n    def forward(self, x):\n        return self.net(x)\n\n    def training_step(self, batch, batch_nb):\n        img, mask = batch\n        out = self.forward(img)\n        loss_val = self.criterion(out.squeeze(1), mask)\n        iou_score = IoU(out.float(), mask.long())\n        self.log(\"train_loss\", loss_val)\n        self.log(\"train_iou\", iou_score, prog_bar=True)\n        return loss_val\n\n    def configure_optimizers(self):\n        optimizer = torch.optim.Adam(self.net.parameters(), lr=self.learning_rate, weight_decay=self.weight_decay)\n        scheduler = OneCycleLR(optimizer, max_lr=0.01, total_steps=None, epochs=self.trainer.max_epochs, steps_per_epoch=len(self.train_dataloader()))\n        return [optimizer], [scheduler]\n\n\n    def train_dataloader(self):\n        return DataLoader(self.trainset, batch_size=self.batch_size, shuffle=True, prefetch_factor=2, num_workers=1)\n\n    def val_dataloader(self):\n        return DataLoader(self.valset, batch_size=self.batch_size, shuffle=False, num_workers=1, prefetch_factor=2, persistent_workers=True)\n    \n    def test_dataloader(self):\n        return DataLoader(self.testset, batch_size=self.batch_size, shuffle=False, num_workers=1, prefetch_factor=2, persistent_workers=True)\n\n    def validation_step(self, batch, batch_idx):\n        img, mask = batch\n        img, mask = img.to(self.device), mask.to(self.device)\n        out = self.forward(img)\n        loss_val = self.criterion(out.squeeze(1), mask)\n        iou_score = IoU(out.float(), mask.long())\n        self.log(\"val_loss\", loss_val, prog_bar=True, sync_dist=True)\n        self.log(\"val_iou\", iou_score, prog_bar=True, on_epoch=True, sync_dist=True)\n\n    def on_epoch_end(self):\n        # Unfreeze the encoder gradually or all at once based on the current epoch\n        if self.current_epoch >= self.freeze_encoder_until_epoch:\n            for param in self.net.encoder.parameters():\n                param.requires_grad = True\n","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:17:06.959145Z","iopub.execute_input":"2024-05-06T04:17:06.959499Z","iopub.status.idle":"2024-05-06T04:17:06.978265Z","shell.execute_reply.started":"2024-05-06T04:17:06.959471Z","shell.execute_reply":"2024-05-06T04:17:06.977259Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## FPN hyper parameter search","metadata":{}},{"cell_type":"code","source":"'''def objective(trial: optuna.Trial, train_dataset, val_dataset, out_path):\n    # Define the hyperparameters to be tuned\n    encoder_name = trial.suggest_categorical('encoder_name', ['resnet34', 'mobilenet_v2', 'timm-efficientnet-b3'])\n    learning_rate = trial.suggest_loguniform('learning_rate', 1e-5, 1e-3)\n    weight_decay = trial.suggest_loguniform('weight_decay', 1e-10, 1e-3)\n    optimizer_name = trial.suggest_categorical('optimizer_name', ['Adam', 'SGD'])\n    \n    logger = CSVLogger(save_dir=out_path, name=\"optuna_hpo_logs\")\n    \n    # Create the model with the suggested hyperparameters\n    model = SegModel(train_dataset, val_dataset,\n                     encoder_name=encoder_name, learning_rate=learning_rate,\n                     optimizer_name=optimizer_name, weight_decay=weight_decay)\n\n    # Define the PyTorch Lightning trainer\n    trainer = pl.Trainer(\n        logger=logger,\n        accelerator=\"auto\",\n        devices=\"2\",\n        strategy=\"ddp_notebook\",\n        max_epochs=5\n    )\n\n    # Fit the model\n    trainer.fit(model)\n\n    # Objective metric to optimize\n    val_iou = trainer.callback_metrics[\"val_iou\"].item()\n    \n    return val_iou'''","metadata":{"jupyter":{"source_hidden":true},"execution":{"iopub.status.busy":"2024-05-06T04:13:16.100132Z","iopub.status.idle":"2024-05-06T04:13:16.100440Z","shell.execute_reply.started":"2024-05-06T04:13:16.100290Z","shell.execute_reply":"2024-05-06T04:13:16.100302Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"'''def run_optimization(train_dataset, val_dataset, out_path, n_trials=100):\n    study = optuna.create_study(sampler=optuna.samplers.TPESampler(),direction=\"maximize\")\n    study.optimize(lambda trial: objective(trial, train_dataset, val_dataset, out_path), n_trials=n_trials)\n\n    print(\"Best trial:\")\n    trial = study.best_trial\n\n    print(f\"Value: {trial.value}\")\n    for key, value in trial.params.items():\n        print(f\"  {key}: {value}\")\n\n# Assuming train_dataset, val_dataset, and out_path are predefined\nrun_optimization(train_dataset, val_dataset, output_path, n_trials=90)'''","metadata":{"jupyter":{"source_hidden":true},"execution":{"iopub.status.busy":"2024-05-06T04:13:16.101331Z","iopub.status.idle":"2024-05-06T04:13:16.101631Z","shell.execute_reply.started":"2024-05-06T04:13:16.101482Z","shell.execute_reply":"2024-05-06T04:13:16.101494Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Best trial:\n#### Value: 0.6400721073150635\n  * encoder_name: timm-efficientnet-b3\n  * learning_rate: 0.0008554651674380874\n  * weight_decay: 3.002610219457659e-10\n  * optimizer_name: Adam","metadata":{}},{"cell_type":"code","source":"FPN = SegModel(train_dataset, val_dataset,test_dataset, encoder_name='tu-resnext26ts',\n                 learning_rate=8e-6, weight_decay=1e-4)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:17:09.686536Z","iopub.execute_input":"2024-05-06T04:17:09.687364Z","iopub.status.idle":"2024-05-06T04:17:12.127262Z","shell.execute_reply.started":"2024-05-06T04:17:09.687335Z","shell.execute_reply":"2024-05-06T04:17:12.126425Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Assuming SegModel and all necessary imports and dependencies are already defined\nmodel = SegModel.load_from_checkpoint(checkpoint_path=\"/kaggle/input/weights/modelo.75.ckpt\",\n                                      train_dataset=train_dataset,  # you need to provide the datasets again\n                                      val_dataset=val_dataset,\n                                      test_dataset=test_dataset)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:19:31.413987Z","iopub.execute_input":"2024-05-06T04:19:31.414735Z","iopub.status.idle":"2024-05-06T04:19:34.807907Z","shell.execute_reply.started":"2024-05-06T04:19:31.414701Z","shell.execute_reply":"2024-05-06T04:19:34.806892Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"trainer = pl.Trainer(\n    accelerator=\"auto\",\n    devices=\"auto\",\n    strategy=\"auto\",\n    max_epochs=20,#75#\n    callbacks=[\n        ModelCheckpoint(save_weights_only=True,\n                        dirpath=\"./best_model.pth\",\n                        mode=\"max\",\n                        monitor=\"val_iou\"\n                        ),\n        LearningRateMonitor(\"epoch\"),\n        EarlyStopping(monitor=\"val_iou\", mode=\"max\", patience=15),\n    ],  \n)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:17:12.190476Z","iopub.execute_input":"2024-05-06T04:17:12.190801Z","iopub.status.idle":"2024-05-06T04:17:12.246931Z","shell.execute_reply.started":"2024-05-06T04:17:12.190773Z","shell.execute_reply":"2024-05-06T04:17:12.246085Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"trainer.fit(FPN)","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:19:41.742493Z","iopub.execute_input":"2024-05-06T04:19:41.742836Z","iopub.status.idle":"2024-05-06T04:22:16.319509Z","shell.execute_reply.started":"2024-05-06T04:19:41.742811Z","shell.execute_reply":"2024-05-06T04:22:16.317867Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"trainer.validate(FPN,\n                 ckpt_path='/kaggle/input/weights/modelo.75.ckpt',\n                 dataloaders=FPN.val_dataloader())","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:17:13.800572Z","iopub.execute_input":"2024-05-06T04:17:13.801288Z","iopub.status.idle":"2024-05-06T04:18:00.308046Z","shell.execute_reply.started":"2024-05-06T04:17:13.801255Z","shell.execute_reply":"2024-05-06T04:18:00.306958Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def visualize_segmentation(model, device, dataloader, num_samples=3):\n    model = model.to(device)\n    model.eval()\n\n    fig, axs = plt.subplots(num_samples, 2, figsize=(10, num_samples * 5))\n    sample_count = 0  # Initialize sample count\n\n    for images, _ in dataloader:\n        images = images.mean(dim=1, keepdim=True)\n        images = images.to(device)\n        preds = torch.sigmoid(model(images))\n        preds = (preds > 0.5).float()\n        images, preds = images.cpu(), preds.cpu()\n\n        for idx in range(images.shape[0]):\n            if sample_count >= num_samples:  # Check if we have displayed enough samples\n                break\n\n            # Visualize the original grayscale image\n            axs[sample_count, 0].imshow(images[idx].squeeze(), cmap='gray')\n            axs[sample_count, 0].set_title('Original Image')\n\n            # Visualize the predicted mask\n            axs[sample_count, 1].imshow(preds[idx].squeeze(), cmap='gray')\n            axs[sample_count, 1].set_title('Predicted Mask')\n\n            sample_count += 1  # Increment sample count\n\n        if sample_count >= num_samples:\n            break\n\n    for ax in axs.flat:\n        ax.axis('off')\n    plt.tight_layout()\n    plt.show()\n\n# Example usage\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\nmodel = FPN  # Assuming 'FPN' is a pre-defined model instance\nmodel.to(device)\n\ndataloader = FPN.test_dataloader()  # Adjust the batch size if possible in the dataloader definition\n\nvisualize_segmentation(model, device, dataloader, num_samples=3)\n","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:24:46.312588Z","iopub.execute_input":"2024-05-06T04:24:46.313676Z","iopub.status.idle":"2024-05-06T04:24:47.729985Z","shell.execute_reply.started":"2024-05-06T04:24:46.313637Z","shell.execute_reply":"2024-05-06T04:24:47.728797Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def rle_encoding(x):\n    \"\"\"\n    x: numpy array of shape (height, width), 1 - mask, 0 - background\n    Returns run length as string formatted\n    \"\"\"\n    dots = np.where(x.T.flatten() == 1)[0]  # Transpose and flatten to row-major order\n    run_lengths = []  # list of run lengths\n    prev = -2\n    for b in dots:\n        if b > prev + 1:\n            run_lengths.extend((b + 1, 0))  # We start positions at 1\n        run_lengths[-1] += 1\n        prev = b\n    return ' '.join([str(i) for i in run_lengths])\n","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:24:53.748063Z","iopub.execute_input":"2024-05-06T04:24:53.749105Z","iopub.status.idle":"2024-05-06T04:24:53.756227Z","shell.execute_reply.started":"2024-05-06T04:24:53.749060Z","shell.execute_reply":"2024-05-06T04:24:53.755302Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n# Function to process and predict the dataset\ndef process_dataset(model, device, dataloader):\n    model.eval()\n    submission_dict = {'id': [], 'predicted': []}\n    with torch.no_grad():\n        for images, image_ids in dataloader:\n            images = images.mean(dim=1, keepdim=True)\n            images = images.to(device)\n            preds = torch.sigmoid(model(images))  # Assuming binary classification\n            preds = (preds > 0.5).float()  # Threshold predictions\n\n            preds = preds.cpu().numpy()  # Convert to numpy array for RLE encoding\n\n            for pred, image_id in zip(preds, image_ids):\n                rle = rle_encoding(pred.squeeze())  # Squeeze to remove channel dimension\n                submission_dict['id'].append(image_id.replace('.png', ''))\n                submission_dict['predicted'].append(rle)\n\n    return submission_dict\n\n# Assuming your DataLoader and model are correctly defined and loaded\nsubmission_dict = process_dataset(model, device, dataloader)\n\n# Convert dictionary to DataFrame\nsubmission_df = pd.DataFrame(submission_dict)\nsubmission_df.to_csv('submission.csv', index=False)\n","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:48:03.344349Z","iopub.execute_input":"2024-05-06T04:48:03.345190Z","iopub.status.idle":"2024-05-06T04:48:03.552626Z","shell.execute_reply.started":"2024-05-06T04:48:03.345159Z","shell.execute_reply":"2024-05-06T04:48:03.551768Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission_df.head()","metadata":{"execution":{"iopub.status.busy":"2024-05-06T04:48:04.848288Z","iopub.execute_input":"2024-05-06T04:48:04.848989Z","iopub.status.idle":"2024-05-06T04:48:04.858621Z","shell.execute_reply.started":"2024-05-06T04:48:04.848960Z","shell.execute_reply":"2024-05-06T04:48:04.857808Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Conclusion\n* I took MAnet model, because YOLOACT did not show any result\n* To improve MAnet results add CombinedLoss got 10% better results\n* Model got 0.75 score\n* While was doing submission noticed that 'Each row in your submission represents a single predicted nucleus segmentation for the given ImageId'\n  * I was teaching model on whole images. I lost motivation to change everything, but it is totaly my falt, had to make better research before start","metadata":{}}]}