{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Geneformer Fine-Tuning for Classification of Dosage-Sensitive vs. -Insensitive Transcription Factors (TFs)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import os\n", "GPU_NUMBER = [0,1]\n", "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \",\".join([str(s) for s in GPU_NUMBER])\n", "os.environ[\"NCCL_DEBUG\"] = \"INFO\"" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/loompy/bus_file.py:67: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", " @jit\n", "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/loompy/bus_file.py:84: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", " @jit\n", "/ibex/user/chenj0i/pretrain_gf/lib/python3.11/site-packages/loompy/bus_file.py:101: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", " @jit\n" ] } ], "source": [ "# imports\n", "import datetime\n", "import subprocess\n", "import math\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", "from datasets import load_from_disk\n", "from sklearn import preprocessing\n", "from sklearn.metrics import accuracy_score, auc, confusion_matrix, ConfusionMatrixDisplay, roc_curve\n", "from sklearn.model_selection import StratifiedKFold\n", "import torch\n", "from transformers import BertForTokenClassification\n", "from transformers import Trainer\n", "from transformers.training_args import TrainingArguments\n", "from tqdm.notebook import tqdm\n", "\n", "import sys\n", "sys.path.append('/ibex/user/chenj0i/Geneformer')\n", "from geneformer import DataCollatorForGeneClassification\n", "from geneformer.pretrainer import token_dictionary\n", "\n", "from GF_CAB import CustomBertForMaskedLM" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load Gene Attribute Information" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# table of corresponding Ensembl IDs, gene names, and gene types (e.g. coding, miRNA, etc.)\n", "gene_info = pd.read_csv(\"example_input_files/gene_info_table.csv\", index_col=0)\n", "\n", "# create dictionaries for corresponding attributes\n", "gene_id_type_dict = dict(zip(gene_info[\"ensembl_id\"],gene_info[\"gene_type\"]))\n", "gene_name_id_dict = dict(zip(gene_info[\"gene_name\"],gene_info[\"ensembl_id\"]))\n", "gene_id_name_dict = {v: k for k,v in gene_name_id_dict.items()}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Model Directory" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "model_path = 'model path'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load Training Data and Class Labels" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# function for preparing targets and labels\n", "def prep_inputs(genegroup1, genegroup2, id_type):\n", " if id_type == \"gene_name\":\n", " targets1 = [gene_name_id_dict[gene] for gene in genegroup1 if gene_name_id_dict.get(gene) in token_dictionary]\n", " targets2 = [gene_name_id_dict[gene] for gene in genegroup2 if gene_name_id_dict.get(gene) in token_dictionary]\n", " elif id_type == \"ensembl_id\":\n", " targets1 = [gene for gene in genegroup1 if gene in token_dictionary]\n", " targets2 = [gene for gene in genegroup2 if gene in token_dictionary]\n", " \n", " targets1_id = [token_dictionary[gene] for gene in targets1]\n", " targets2_id = [token_dictionary[gene] for gene in targets2]\n", " \n", " targets = np.array(targets1_id + targets2_id)\n", " labels = np.array([0]*len(targets1_id) + [1]*len(targets2_id))\n", " nsplits = min(5, min(len(targets1_id), len(targets2_id))-1)\n", " assert nsplits > 2\n", " print(f\"# targets1: {len(targets1_id)}\\n# targets2: {len(targets2_id)}\\n# splits: {nsplits}\")\n", " return targets, labels, nsplits" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "# targets1: 122\n", "# targets2: 368\n", "# splits: 5\n" ] } ], "source": [ "# preparing targets and labels for dosage sensitive vs insensitive TFs\n", "dosage_tfs = pd.read_csv(\"example_input_files/gene_classification/dosage_sensitive_tfs/dosage_sens_tf_labels.csv\", header=0)\n", "sensitive = dosage_tfs[\"dosage_sensitive\"].dropna()\n", "insensitive = dosage_tfs[\"dosage_insensitive\"].dropna()\n", "targets, labels, nsplits = prep_inputs(sensitive, insensitive, \"ensembl_id\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# load training dataset\n", "train_dataset=load_from_disk(\"Genecorpus-30M/genecorpus_30M_2048.dataset\")\n", "shuffled_train_dataset = train_dataset.shuffle(seed=42)\n", "subsampled_train_dataset = shuffled_train_dataset.select([i for i in range(50_000)])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define Functions for Training and Cross-Validating Classifier" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def preprocess_classifier_batch(cell_batch, max_len):\n", " if max_len == None:\n", " max_len = max([len(i) for i in cell_batch[\"input_ids\"]])\n", " def pad_label_example(example):\n", " example[\"labels\"] = np.pad(example[\"labels\"], \n", " (0, max_len-len(example[\"input_ids\"])), \n", " mode='constant', constant_values=-100)\n", " example[\"input_ids\"] = np.pad(example[\"input_ids\"], \n", " (0, max_len-len(example[\"input_ids\"])), \n", " mode='constant', constant_values=token_dictionary.get(\"\"))\n", " example[\"attention_mask\"] = (example[\"input_ids\"] != token_dictionary.get(\"\")).astype(int)\n", " return example\n", " padded_batch = cell_batch.map(pad_label_example)\n", " return padded_batch\n", "\n", "# forward batch size is batch size for model inference (e.g. 200)\n", "def classifier_predict(model, evalset, forward_batch_size, mean_fpr):\n", " predict_logits = []\n", " predict_labels = []\n", " model.eval()\n", " \n", " # ensure there is at least 2 examples in each batch to avoid incorrect tensor dims\n", " evalset_len = len(evalset)\n", " max_divisible = find_largest_div(evalset_len, forward_batch_size)\n", " if len(evalset) - max_divisible == 1:\n", " evalset_len = max_divisible\n", " \n", " max_evalset_len = max(evalset.select([i for i in range(evalset_len)])[\"length\"])\n", " \n", " for i in range(0, evalset_len, forward_batch_size):\n", " max_range = min(i+forward_batch_size, evalset_len)\n", " batch_evalset = evalset.select([i for i in range(i, max_range)])\n", " padded_batch = preprocess_classifier_batch(batch_evalset, max_evalset_len)\n", " padded_batch.set_format(type=\"torch\")\n", " \n", " input_data_batch = padded_batch[\"input_ids\"]\n", " attn_msk_batch = padded_batch[\"attention_mask\"]\n", " label_batch = padded_batch[\"labels\"]\n", " with torch.no_grad():\n", " outputs = model(\n", " input_ids = input_data_batch.to(\"cuda\"), \n", " attention_mask = attn_msk_batch.to(\"cuda\"), \n", " labels = label_batch.to(\"cuda\"), \n", " )\n", " predict_logits += [torch.squeeze(outputs.logits.to(\"cpu\"))]\n", " predict_labels += [torch.squeeze(label_batch.to(\"cpu\"))]\n", " \n", " logits_by_cell = torch.cat(predict_logits)\n", " all_logits = logits_by_cell.reshape(-1, logits_by_cell.shape[2])\n", " labels_by_cell = torch.cat(predict_labels)\n", " all_labels = torch.flatten(labels_by_cell)\n", " logit_label_paired = [item for item in list(zip(all_logits.tolist(), all_labels.tolist())) if item[1]!=-100]\n", " y_pred = [vote(item[0]) for item in logit_label_paired]\n", " y_true = [item[1] for item in logit_label_paired]\n", " logits_list = [item[0] for item in logit_label_paired]\n", " # probability of class 1\n", " y_score = [py_softmax(item)[1] for item in logits_list]\n", " conf_mat = confusion_matrix(y_true, y_pred)\n", " fpr, tpr, _ = roc_curve(y_true, y_score)\n", " # plot roc_curve for this split\n", " plt.plot(fpr, tpr)\n", " plt.xlim([0.0, 1.0])\n", " plt.ylim([0.0, 1.05])\n", " plt.xlabel('False Positive Rate')\n", " plt.ylabel('True Positive Rate')\n", " plt.title('ROC')\n", " plt.show()\n", " # interpolate to graph\n", " interp_tpr = np.interp(mean_fpr, fpr, tpr)\n", " interp_tpr[0] = 0.0\n", " return fpr, tpr, interp_tpr, conf_mat \n", "\n", "def vote(logit_pair):\n", " a, b = logit_pair\n", " if a > b:\n", " return 0\n", " elif b > a:\n", " return 1\n", " elif a == b:\n", " return \"tie\"\n", " \n", "def py_softmax(vector):\n", "\te = np.exp(vector)\n", "\treturn e / e.sum()\n", " \n", "# get cross-validated mean and sd metrics\n", "def get_cross_valid_metrics(all_tpr, all_roc_auc, all_tpr_wt):\n", " wts = [count/sum(all_tpr_wt) for count in all_tpr_wt]\n", " print(wts)\n", " all_weighted_tpr = [a*b for a,b in zip(all_tpr, wts)]\n", " mean_tpr = np.sum(all_weighted_tpr, axis=0)\n", " mean_tpr[-1] = 1.0\n", " all_weighted_roc_auc = [a*b for a,b in zip(all_roc_auc, wts)]\n", " roc_auc = np.sum(all_weighted_roc_auc)\n", " roc_auc_sd = math.sqrt(np.average((all_roc_auc-roc_auc)**2, weights=wts))\n", " return mean_tpr, roc_auc, roc_auc_sd\n", "\n", "# Function to find the largest number smaller\n", "# than or equal to N that is divisible by k\n", "def find_largest_div(N, K):\n", " rem = N % K\n", " if(rem == 0):\n", " return N\n", " else:\n", " return N - rem" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# cross-validate gene classifier\n", "def cross_validate(data, targets, labels, nsplits, subsample_size, training_args, freeze_layers, output_dir, num_proc):\n", " # check if output directory already written to\n", " # ensure not overwriting previously saved model\n", " model_dir_test = os.path.join(output_dir, \"ksplit0/models/pytorch_model.bin\")\n", " if os.path.isfile(model_dir_test) == True:\n", " raise Exception(\"Model already saved to this directory.\")\n", " \n", " # initiate eval metrics to return\n", " num_classes = len(set(labels))\n", " mean_fpr = np.linspace(0, 1, 100)\n", " all_tpr = []\n", " all_roc_auc = []\n", " all_tpr_wt = []\n", " label_dicts = []\n", " confusion = np.zeros((num_classes,num_classes))\n", " \n", " # set up cross-validation splits\n", " skf = StratifiedKFold(n_splits=nsplits, random_state=0, shuffle=True)\n", " # train and evaluate\n", " iteration_num = 0\n", " for train_index, eval_index in tqdm(skf.split(targets, labels)):\n", " if len(labels) > 500:\n", " print(\"early stopping activated due to large # of training examples\")\n", " nsplits = 3\n", " if iteration_num == 3:\n", " break\n", " print(f\"****** Crossval split: {iteration_num}/{nsplits-1} ******\\n\")\n", " # generate cross-validation splits\n", " targets_train, targets_eval = targets[train_index], targets[eval_index]\n", " labels_train, labels_eval = labels[train_index], labels[eval_index]\n", " label_dict_train = dict(zip(targets_train, labels_train))\n", " label_dict_eval = dict(zip(targets_eval, labels_eval))\n", " label_dicts += (iteration_num, targets_train, targets_eval, labels_train, labels_eval)\n", " \n", " # function to filter by whether contains train or eval labels\n", " def if_contains_train_label(example):\n", " a = label_dict_train.keys()\n", " b = example['input_ids']\n", " return not set(a).isdisjoint(b)\n", "\n", " def if_contains_eval_label(example):\n", " a = label_dict_eval.keys()\n", " b = example['input_ids']\n", " return not set(a).isdisjoint(b)\n", " \n", " # filter dataset for examples containing classes for this split\n", " print(f\"Filtering training data\")\n", " trainset = data.filter(if_contains_train_label, num_proc=num_proc)\n", " print(f\"Filtered {round((1-len(trainset)/len(data))*100)}%; {len(trainset)} remain\\n\")\n", " print(f\"Filtering evalation data\")\n", " evalset = data.filter(if_contains_eval_label, num_proc=num_proc)\n", " print(f\"Filtered {round((1-len(evalset)/len(data))*100)}%; {len(evalset)} remain\\n\")\n", "\n", " # minimize to smaller training sample\n", " training_size = min(subsample_size, len(trainset))\n", " trainset_min = trainset.select([i for i in range(training_size)])\n", " eval_size = min(training_size, len(evalset))\n", " half_training_size = round(eval_size/2)\n", " evalset_train_min = evalset.select([i for i in range(half_training_size)])\n", " evalset_oos_min = evalset.select([i for i in range(half_training_size, eval_size)])\n", " \n", " # label conversion functions\n", " def generate_train_labels(example):\n", " example[\"labels\"] = [label_dict_train.get(token_id, -100) for token_id in example[\"input_ids\"]]\n", " return example\n", "\n", " def generate_eval_labels(example):\n", " example[\"labels\"] = [label_dict_eval.get(token_id, -100) for token_id in example[\"input_ids\"]]\n", " return example\n", " \n", " # label datasets \n", " print(f\"Labeling training data\")\n", " trainset_labeled = trainset_min.map(generate_train_labels)\n", " print(f\"Labeling evaluation data\")\n", " evalset_train_labeled = evalset_train_min.map(generate_eval_labels)\n", " print(f\"Labeling evaluation OOS data\")\n", " evalset_oos_labeled = evalset_oos_min.map(generate_eval_labels)\n", " \n", " # create output directories\n", " ksplit_output_dir = os.path.join(output_dir, f\"ksplit{iteration_num}\")\n", " ksplit_model_dir = os.path.join(ksplit_output_dir, \"models/\") \n", " \n", " # ensure not overwriting previously saved model\n", " model_output_file = os.path.join(ksplit_model_dir, \"pytorch_model.bin\")\n", " if os.path.isfile(model_output_file) == True:\n", " raise Exception(\"Model already saved to this directory.\")\n", "\n", " # make training and model output directories\n", " os.makedirs(ksplit_output_dir, exist_ok=True)\n", " os.makedirs(ksplit_model_dir, exist_ok=True)\n", " \n", " # load model\n", " model = BertForTokenClassification.from_pretrained(\n", " model_path,\n", " num_labels=2,\n", " output_attentions = False,\n", " output_hidden_states = False\n", " )\n", " if freeze_layers is not None:\n", " modules_to_freeze = model.bert.encoder.layer[:freeze_layers]\n", " for module in modules_to_freeze:\n", " for param in module.parameters():\n", " param.requires_grad = False\n", "\n", " #############\n", " pretrained_model = CustomBertForMaskedLM.from_pretrained(model_path)\n", " # Extract the word embeddings from the pretrained model\n", " pretrained_word_embeddings = pretrained_model.bert.embeddings.word_embeddings.weight.clone()\n", " model.bert.embeddings.word_embeddings.load_state_dict({\"weight\": pretrained_word_embeddings}) \n", " ########### \n", " \n", " model = model.to(\"cuda:0\")\n", " \n", " # add output directory to training args and initiate\n", " training_args[\"output_dir\"] = ksplit_output_dir\n", " training_args_init = TrainingArguments(**training_args)\n", " \n", " # create the trainer\n", " trainer = Trainer(\n", " model=model,\n", " args=training_args_init,\n", " data_collator=DataCollatorForGeneClassification(),\n", " train_dataset=trainset_labeled,\n", " eval_dataset=evalset_train_labeled\n", " )\n", "\n", " # train the gene classifier\n", " trainer.train()\n", " \n", " # save model\n", " trainer.save_model(ksplit_model_dir)\n", " \n", " # evaluate model\n", " fpr, tpr, interp_tpr, conf_mat = classifier_predict(trainer.model, evalset_oos_labeled, 200, mean_fpr)\n", " \n", " # append to tpr and roc lists\n", " confusion = confusion + conf_mat\n", " all_tpr.append(interp_tpr)\n", " all_roc_auc.append(auc(fpr, tpr))\n", " # append number of eval examples by which to weight tpr in averaged graphs\n", " all_tpr_wt.append(len(tpr))\n", " \n", " iteration_num = iteration_num + 1\n", " \n", " # get overall metrics for cross-validation\n", " mean_tpr, roc_auc, roc_auc_sd = get_cross_valid_metrics(all_tpr, all_roc_auc, all_tpr_wt)\n", " return all_roc_auc, roc_auc, roc_auc_sd, mean_fpr, mean_tpr, confusion, label_dicts" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define Functions for Plotting Results" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# plot ROC curve\n", "def plot_ROC(bundled_data, title):\n", " plt.figure()\n", " lw = 2\n", " for roc_auc, roc_auc_sd, mean_fpr, mean_tpr, sample, color in bundled_data:\n", " plt.plot(mean_fpr, mean_tpr, color=color,\n", " lw=lw, label=\"{0} (AUC {1:0.2f} $\\pm$ {2:0.2f})\".format(sample, roc_auc, roc_auc_sd))\n", " plt.plot([0, 1], [0, 1], color='black', lw=lw, linestyle='--')\n", " plt.xlim([0.0, 1.0])\n", " plt.ylim([0.0, 1.05])\n", " plt.xlabel('False Positive Rate')\n", " plt.ylabel('True Positive Rate')\n", " plt.title(title)\n", " plt.legend(loc=\"lower right\")\n", " plt.show()\n", " \n", "# plot confusion matrix\n", "def plot_confusion_matrix(classes_list, conf_mat, title):\n", " display_labels = []\n", " i = 0\n", " for label in classes_list:\n", " display_labels += [\"{0}\\nn={1:.0f}\".format(label, sum(conf_mat[:,i]))]\n", " i = i + 1\n", " display = ConfusionMatrixDisplay(confusion_matrix=preprocessing.normalize(conf_mat, norm=\"l1\"), \n", " display_labels=display_labels)\n", " display.plot(cmap=\"Blues\",values_format=\".2g\")\n", " plt.grid(False)\n", " plt.title(title)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fine-Tune With Gene Classification Learning Objective and Quantify Predictive Performance" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Please note that, as usual with deep learning models, we **highly** recommend tuning learning hyperparameters for all fine-tuning applications as this can significantly improve model performance. Example hyperparameters are defined below, but please see the \"hyperparam_optimiz_for_disease_classifier\" script for an example of how to tune hyperparameters for downstream applications." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# set model parameters\n", "# max input size\n", "max_input_size = 2 ** 11 # 2048\n", "\n", "# set training hyperparameters\n", "# max learning rate\n", "max_lr = 5e-5\n", "# how many pretrained layers to freeze\n", "freeze_layers = 4\n", "# number gpus\n", "num_gpus = 1\n", "# number cpu cores\n", "num_proc = 24\n", "# batch size for training and eval\n", "geneformer_batch_size = 12\n", "# learning schedule\n", "lr_schedule_fn = \"linear\"\n", "# warmup steps\n", "warmup_steps = 500\n", "# number of epochs\n", "epochs = 1\n", "# optimizer\n", "optimizer = \"adamw\"" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "tags": [] }, "outputs": [], "source": [ "# set training arguments\n", "subsample_size = 10_000\n", "training_args = {\n", " \"learning_rate\": max_lr,\n", " \"do_train\": True,\n", " \"evaluation_strategy\": \"no\",\n", " \"save_strategy\": \"epoch\",\n", " \"logging_steps\": 100,\n", " \"group_by_length\": True,\n", " \"length_column_name\": \"length\",\n", " \"disable_tqdm\": False,\n", " \"lr_scheduler_type\": lr_schedule_fn,\n", " \"warmup_steps\": warmup_steps,\n", " \"weight_decay\": 0.001,\n", " \"per_device_train_batch_size\": geneformer_batch_size,\n", " \"per_device_eval_batch_size\": geneformer_batch_size,\n", " \"num_train_epochs\": epochs,\n", " \"report_to\": \"none\",\n", "}" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# define output directory path\n", "current_date = datetime.datetime.now()\n", "datestamp = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}\"\n", "training_output_dir = f\"Downstream/previous/model_training_record/{datestamp}_geneformer_GeneClassifier_dosageTF_L{max_input_size}_B{geneformer_batch_size}_LR{max_lr}_LS{lr_schedule_fn}_WU{warmup_steps}_E{epochs}_O{optimizer}_n{subsample_size}_F{freeze_layers}/\"\n", "\n", "# ensure not overwriting previously saved model\n", "ksplit_model_test = os.path.join(training_output_dir, \"ksplit0/models/pytorch_model.bin\")\n", "if os.path.isfile(ksplit_model_test) == True:\n", " raise Exception(\"Model already saved to this directory.\")\n", "\n", "# make output directory\n", "os.makedirs(training_output_dir, exist_ok=True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "tags": [] }, "outputs": [], "source": [ "# cross-validate gene classifier\n", "all_roc_auc, roc_auc, roc_auc_sd, mean_fpr, mean_tpr, confusion, label_dicts \\\n", " = cross_validate(subsampled_train_dataset, targets, labels, nsplits, subsample_size, training_args, freeze_layers, training_output_dir, 1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# bundle data for plotting\n", "bundled_data = []\n", "bundled_data += [(roc_auc, roc_auc_sd, mean_fpr, mean_tpr, \"Geneformer\", \"red\")]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAHPCAYAAABOau4WAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAn2RJREFUeJzs3Xd4VEUXwOHflvRKaEpvhl6kQ6hRhADSpUnvEEGKUgQRkN6khCYgICoIUpRPQu9FBFFAulQBDZDey+79/ghcWUJJQpK7Sc77PHmyd27ZszspZ2fmzugURVEQQgghhBAvpNc6ACGEEEKIzECSJiGEEEKIZJCkSQghhBAiGSRpEkIIIYRIBkmahBBCCCGSQZImIYQQQohkkKRJCCGEECIZJGkSQgghhEgGSZqEEEIIIZJBkiYhRLpZuHAhJUuWTNaxmzdvpmTJkty5cyedoxJpwdvbm9GjRyfr2K5du9K1a9d0jkiI9GfUOgAhUmLz5s2MGTNG3ba1tcXNzY2SJUtSv3592rRpg7Ozs4YRZrxTp06xdOlSLl++TEhICDlz5qRUqVI0a9aMd999V+vwkli6dCklSpTg7bff1jqUDLFw4UL8/Pw4fvw4Hh4eWoeTbv766y/8/f1p3bo1BQoU0DSWp/9OPE/+/PnZt2+fWkfPMmHCBDp16pTWIYpMSpImkSkNGTKEAgUKkJCQwMOHD/n111+ZOnUqq1evZvHixZQqVUrrEDOEv78/w4YNo3Tp0nTr1g03Nzfu3LnDyZMn2bBhg+ZJ08CBA+nXr59F2bJly2jcuHGSpKlly5Y0a9YMW1vbjAxRpNKOHTvQ6XTq9l9//YWfnx/Vq1dPkjStXLkyQ2OrVq0aM2fOtCgbN24cFSpUoH379mqZk5OTxTETJkzA0dHRoqxixYrpF6jIdCRpEplSvXr1KF++vLrdv39/jh8/zoABAxg0aBDbt2/H3t5ewwgzhp+fHyVKlOD7779PkmwEBgZqFNV/jEYjRmPy/swYDAYMBkM6RyTSSkqS24xOhAsWLEjBggUtyiZMmEDBggVp2bLlc89r3Lhxlm4NFK9OxjSJLKNWrVoMGjSIu3fv8tNPP1nsO378OJ07d6ZSpUpUrVqVgQMHcu3aNYtjIiIimDJlCt7e3pQrV45atWrRs2dPzp8/rx5z6tQphgwZQoMGDShXrhz169dn6tSpxMTEJInH39+fpk2bUr58eZo3b87u3bsZPXo03t7eFseZzWZWr15Ns2bNKF++PLVr12b8+PGEhoa+9DXfvn2b8uXLP/OfUs6cOVP1PN7e3vTv359Tp07Rrl07ypcvz1tvvcXWrVstjouPj8fPz4933nmH8uXLU6NGDTp16sTRo0fVY54e01SyZEmioqLYsmULJUuWpGTJkuq4mKfHNPXv35+33nrrma+7Q4cOtGnTxqLsxx9/pE2bNlSoUIHq1aszbNgw/vnnnxe+fzt27KBkyZL8+uuvSfatX7+ekiVLcuXKFQAePHjAmDFjqFevHuXKlaNOnToMHDgwVWOwunbtSvPmzfnrr7/o2rUrFStWpG7duixfvjzJsWvXrqVZs2ZUrFiRatWq0aZNG7Zt22ZxTEBAAGPGjKF27dqUK1eOZs2a8cMPP1gcc+LECUqWLMn27dtZsmSJ+sGje/fu3Lp1y+LYmzdvMnjwYLy8vChfvjz16tVj2LBhhIeHq8c8OaZp8+bNfPjhhwB069ZNrdsTJ06or/fxmKaHDx9SpkyZZ3aHXb9+nZIlS/LNN9+oZWFhYUyZMoX69etTrlw5GjVqxJdffonZbE72+51Wfv75Z9q0acObb75J5cqVeffdd1mzZk2GxyG0Iy1NIktp2bIlc+fO5ciRI2oz/LFjx+jbty8FChTggw8+ICYmhm+++YZOnTqxefNmtSvhs88+Y+fOnXTp0oXixYsTEhLCb7/9xrVr1yhbtiyQ+E82JiaGTp064e7uztmzZ/nmm2/4999/WbBggRrHgQMHGDZsGJ6enowYMYLQ0FDGjh1L3rx5k8Q8fvx4tmzZQps2bejatSt37tzh22+/5cKFC6xbtw4bG5vnvt58+fJx/Phx/v33X1577bUXvjcpeZ5bt27x4Ycf0q5dO1q3bs2mTZsYPXo0ZcuW5Y033gASW7mWLVvGe++9R4UKFYiIiODPP//k/PnzeHl5PTOGmTNnJukmKVSo0DOP9fHxYdSoUZw9e5YKFSqo5Xfv3uWPP/5g5MiRatmSJUuYP38+Pj4+tGvXjqCgIL755hvef/99tm7diqur6zOfo0GDBjg6OuLv70/16tUt9m3fvp033ngDT09PAAYPHsxff/1Fly5dyJ8/P0FBQRw9epR//vknVWN4QkND6dOnD40aNcLHx4edO3cye/ZsPD09qV+/PgAbNmxg8uTJNG7cmG7duhEbG8vly5c5c+aM2vX68OFD2rdvj06n4/3338fDw4NDhw4xduxYIiIi6NGjh8XzLl++HJ1OR69evYiIiGDFihV89NFHbNy4EYC4uDh69+5NXFwcXbp0IVeuXAQEBHDgwAHCwsJwcXFJ8lqqVatG165dWbt2LQMGDKBYsWIAFC9ePMmxuXLlolq1avj7+/PBBx8kec8NBgNNmjQBIDo6mi5duhAQEEDHjh15/fXX+f3335k7dy4PHjxg7NixKX7fX+TpDxAGgwE3NzcAjh49yvDhw6lVqxYfffQRkJjknT59mu7du6dpHMKKKUJkIps2bVI8PT2Vs2fPPveYKlWqKK1atVK3W7ZsqdSqVUsJDg5Wyy5evKiUKlVKGTlypMV5EydOfOHzR0dHJylbtmyZUrJkSeXu3btqWfPmzZV69eopERERatmJEycUT09PpWHDhmrZyZMnFU9PT+Wnn36yuOahQ4eeWf60jRs3Kp6enkrZsmWVrl27KvPmzVNOnjypmEwmi+NS8jwNGzZUPD09lZMnT6plgYGBSrly5ZTp06erZS1atFD69ev3wvgWLFigeHp6WpRVqlRJGTVqVJJjH9ft33//rSiKooSHhyd5TkVRlOXLl1u833fu3FFKly6tLFmyxOK4y5cvK2XKlElS/rThw4crtWrVUhISEtSy+/fvK6VKlVL8/PwURVGU0NBQxdPTU1mxYsULr/Usj9+DwMBAtaxLly6Kp6ensmXLFrUsNjZW8fLyUgYPHqyWDRw4UGnWrNkLr//JJ58oXl5eSlBQkEX5sGHDlCpVqqg/s7/88ovi6emp+Pj4KLGxsepxa9asUTw9PZXLly8riqIoFy5cUDw9PRV/f/8XPm/Dhg0t6tHf31/x9PRUfvnllyTHdunSRenSpYu6vX79eovnfKxp06ZKt27d1O1FixYplSpVUm7cuGFx3OzZs5XSpUsr9+7de2GMT3rez52i/FdHT389+bs6efJkpXLlyhY/JyL7ke45keU4OjoSGRkJwP3797l48SKtW7fG3d1dPaZUqVLUrl2bgwcPqmWurq6cOXOGgICA5177yXFSUVFRBAUF8eabb6IoChcuXAASu0quXLlCq1atLAaaVq9eXW21eGzHjh24uLjg5eVFUFCQ+lW2bFkcHR3V7o3nadeuHStWrKBGjRqcPn2axYsX8/777/POO+9w+vTpVD9PiRIlqFq1qrrt4eFB0aJF+fvvvy3er6tXr3Lz5s0Xxphazs7O1KtXD39/fxRFUcu3b99OpUqVyJcvHwC7d+/GbDbj4+Nj8dpy5cpF4cKFX/oe+vj4EBgYaNFFt3PnTsxmM02bNgUS693GxoZff/01Wd2myeHo6GgxvsbW1pby5csneY///fdfzp49+8xrKIrCrl278Pb2RlEUi9dfp04dwsPDLbqXAdq0aWPRnfu4nh8/7+O7T48cOUJ0dHSavNanNWrUCKPRyPbt29WyK1eu8Ndff6nvOST+3FapUgVXV1eL11a7dm1MJhMnT55M07gWLlzIqlWr1K9Zs2ap+1xdXYmOjrbofhbZj3TPiSwnKipKHc9z7949AIoWLZrkuOLFi3PkyBGioqJwdHTko48+YvTo0TRo0ICyZctSv359WrVqZTGg9N69eyxYsIB9+/Yl+ecZERFh8ZzP6nYqXLiwmlxBYjdYeHg4tWrVeuZrSc5g7rp161K3bl2io6M5f/4827dvZ/369QwYMAB/f39y5syZ4ud5/fXXkxzj5uZm8ZqHDBnCoEGDaNy4MZ6entSpU4eWLVum6Z2LTZs2Zc+ePfz+++9UrlyZ27dvc/78eT755BP1mJs3b6IoCu+8884zr/Gygej16tXDxcWF7du3q+/P9u3bKV26tPpzY2try0cffcSMGTPw8vKiYsWKNGjQgFatWpE7d+5UvbbXXnvN4u4zSHyPL1++rG737duXY8eO8d5771G4cGG8vLxo3rw5VapUASAoKIiwsDC+//57vv/++2c+T1BQkMX242Tzscddl2FhYUDiIOqePXuyatUqtm3bRtWqVfH29qZFixbP7JpLDQ8PD2rWrIm/vz9Dhw4FEt9zo9FIo0aN1ONu3brF5cuXn/tz+/Rre1VVq1Z97kDwzp074+/vT9++fcmbNy9eXl74+PhQr169NI1BWDdJmkSW8u+//xIeHv7ccTIv0rRpU6pWrcru3bs5evQoK1euZPny5SxcuJD69etjMpno2bOnOhalWLFiODo6EhAQwOjRo1M1MNVsNpMzZ05mz579zP0puZPHwcGBqlWrUrVqVXLkyIGfnx+HDh2idevWKX6e5NzFVq1aNXbv3s3evXs5evQoP/zwA2vWrGHixIm89957yY77RRo2bIiDgwP+/v5UrlwZf39/9Hq9OuYFEt9DnU7H8uXLnxn307eQP83W1pa3336b3bt389lnnxEYGMjp06cZPny4xXE9evTA29ubPXv2cOTIEebPn8+XX37JmjVrKFOmTIpfW3Le4+LFi7Njxw4OHDjA4cOH2bVrF9999x2+vr4MGTJE/Zlr0aIFrVu3fuY1np5cVK9/dgfDk615o0ePpnXr1mrdTp48mWXLlrFhw4aXjp1LrmbNmjFmzBguXrxI6dKl8ff3p2bNmhY/i2azGS8vL/r06fPMaxQpUiRNYkmOnDlzsnXrVo4cOcKhQ4c4dOgQmzdvplWrVsyYMSPD4hDakqRJZCk//vgjAHXq1AH++1R948aNJMdev36dHDlyWPxTzZMnD++//z7vv/8+gYGBtG7dmqVLl1K/fn2uXLnCzZs3mTFjBq1atVLPebq5/vFz3r59O8lzPn2XUqFChTh+/DiVK1dO0ykSypUrByTe8ZWez+Pu7k7btm1p27YtkZGRdOnShYULF6ZZ0uTo6EiDBg3YsWMHY8aMYfv27VStWtViQH2hQoVQFIUCBQo8s0UxOXx8fNiyZQvHjx/n2rVrKIqCj49PkuMKFSpEr1696NWrFzdv3qRVq1Z89dVXz01G04KjoyNNmzaladOmxMXFMXjwYJYuXUr//v3x8PDAyckJs9lM7dq10/R5H98BN2jQIE6fPk2nTp1Yt24dw4YNe+bxT7eavczbb7/N+PHj1S66mzdv0r9/f4tjChUqRFRUVJq/ttSytbXF29sbb29vzGYzEyZM4Pvvv2fQoEEULlxY6/BEBpAxTSLLOH78OIsXL6ZAgQK0aNECSEyCSpcuzdatW9XuB0gcP3H06FH1LiWTyWRxOzUkfrLMkycPcXFxwH+f0J/8RK4oCl9//bXFeXnz5sXT05OtW7eqY6sAfv31V/X29cd8fHwwmUwsXrw4yetJSEiwiPl5r/lZHo/VepxEvOrzPEtwcLDFtpOTE4UKFVLfr+dxdHRM0fM1bdqU+/fvs3HjRi5dupQkmXnnnXcwGAz4+flZ1A0k1s/TcT5L7dq1cXd3Z/v27fj7+1OhQgWLbtno6GhiY2MtzilUqBBOTk4vfb2v4unYbW1tKV68OIqiEB8fj8FgoHHjxuzcuTPJzxakrvsqIiKChIQEizJPT0/0ev0LX6uDgwNAkt+j53F1daVOnTr4+/vz888/Y2Njk2TCUx8fH37//XcOHz6c5PywsLAkcaanp+tCr9errXjp+TMgrIu0NIlM6dChQ1y/fh2TycTDhw85ceIER48eJV++fCxZsgQ7Ozv12JEjR9K3b186dOhAu3bt1CkHXFxc1FueIyMjqV+/Po0bN6ZUqVI4Ojpy7Ngxzp07p85FU6xYMQoVKsSMGTMICAjA2dmZnTt3PjMBGDZsGIMGDaJTp060adOGsLAwvv32Wzw9PS0SqerVq9OhQweWLVvGxYsX8fLywsbGhps3b7Jjxw7Gjh1r0RX1tEGDBlGgQAEaNmxIwYIFiY6O5tixY+zfv5/y5cvTsGHDNHmeZ2nWrBnVq1enbNmyuLu7c+7cOXXKhhcpW7Ysx48fZ9WqVeTJk4cCBQq8cNbl+vXr4+TkxIwZM9Qk4UmFChVi6NChzJkzh7t37/L222/j5OTEnTt32LNnD+3bt6d3794vjMnGxoZGjRrx888/Ex0dzahRoyz237x5kx49etCkSRNKlCiBwWBgz549PHz4kGbNmr3knUq93r17kytXLipXrkzOnDm5fv0633zzDfXr11cHbI8YMYITJ07Qvn173nvvPUqUKEFoaCjnz5/n+PHjz5yD6kV++eUXJk2aRJMmTShSpAgmk4kff/zxme/9k0qXLo3BYGD58uWEh4dja2tLzZo1k8wX9qSmTZvy8ccf891331GnTp0kU0P07t2bffv2MWDAAFq3bk3ZsmWJjo7mypUr7Ny5k71792bYZJTjxo0jNDSUmjVrkjdvXu7du8c333xD6dKlnzm1gsiaJGkSmdLjOZFsbGxwd3fH09OTTz755Jlrz9WuXZsVK1awYMECFixYgNFopFq1anz88cdqa4K9vb06MeOuXbtQFIVChQrx2Wef0blzZ/W5li5dqo7vsLOzo1GjRrz//vtJZhn29vZm7ty5LFy4kDlz5lCkSBGmTZvG1q1buXr1qsWxkyZNoly5cqxfv54vvvgCg8FA/vz5adGiBZUrV37h+zB58mT27t2Lv78/9+/fR1EUChYsyIABA+jbt6/FIOhXeZ5n6dq1K/v27ePo0aPExcWRL18+hg4d+tIEZfTo0YwfP5558+YRExND69atX5g02dnZ4e3tzbZt26hdu/Yz/wn369ePIkWKsHr1ahYtWgQkDrT28vJKMpno8zRt2pSNGzei0+mStGa99tprNGvWjOPHj/PTTz9hMBgoVqwY8+bNe2Ei8ao6dOjAtm3bWLVqFVFRUbz22mt07dqVQYMGqcfkypWLjRs3smjRInbv3s26detwd3enRIkS6nxCKVGyZEnq1KnD/v37CQgIwMHBgZIlS7J8+XIqVar03PNy587NxIkTWbZsGWPHjsVkMvH111+/MGny9vbG3t6eyMhIi7vmHnNwcGDt2rUsW7aMHTt2sHXrVpydnSlSpAiDBw9Os4HpydGiRQs2bNjAd999R1hYGLlz58bHx4fBgwc/d5yYyHp0ytPt2UKIdNOyZUs8PDxYtWqV1qEIIYRIIUmPhUgH8fHxScZbnDhxgkuXLiWZeVoIIUTmIN1zQqSDgIAAevbsSYsWLciTJw/Xr19n/fr15M6dm44dO2odnhBCiFSQpEmIdODm5kbZsmXZuHEjQUFBODo6Ur9+fT766CNy5MihdXhCCCFSQcY0CSGEEEIkg4xpEkIIIYRIBkmahBBCCCGSQZImIYQQQohkkIHgL6AoCmazDPmyBnq9TurCSkhdWBepD+shdWEd9HpditdCTC5Jml5Ap9MRFhZFQkLKV68Xacdo1JMjh5PUhRWQurAuUh/WQ+rCenh4OGEwpE/SJN1zQgghhBDJIEmTEEIIIUQySNIkhBBCCJEMkjQJIYQQQiSDJE1CCCGEEMkgSZMQQgghRDJI0iSEEEIIkQySNAkhhBBCJIMkTUIIIYQQySBJkxBCCCFEMlhV0nTr1i3Gjx9Py5YtKVOmDM2bN0/WeYqi8OWXX9KgQQMqVKhAhw4d+OOPP9I3WCGEEEJkK1aVNF29epWDBw9SuHBhihcvnuzzli9fzoIFC+jRowfLli0jd+7c9OrVi7///jsdoxVCCCFEdmJVSZO3tzcHDx5kwYIFlC1bNlnnxMbGsmzZMnr16kWPHj2oVasWc+fOxd3dnZUrV6ZzxEIIIYTILoxaB/AkvT7lOdzp06eJiIjAx8dHLbO1taVRo0bs3r07LcMTQgghhBYUBWJi0MXFQoIJXUI8xD/6UhSLQ3WupcFgly5hWFXSlBrXr18HoFixYhblxYsXZ82aNcTExGBvb5/q6xsMVtUYly09rgOpC+1JXVgXqQ/rIXVBYvISHw8x0ehiYtDFxEBUFLqoKHSREegiIyEyEl1kJLqoyP+2oyLRhYejCwtFFxb231dUJMTEoouJRhcb+/KnB1YA7a9dw+2pnCCtZPqkKSwsDFtbW+zsLLNKV1dXFEUhNDT0lZImV1eHVw1RpBGpC+shdWFdpD6sh9XWxaOWGsLCIDQ08Xt4OERGQkTEf99jYiAuzvIrJibxKzr6v+9RUYnnR0T89xUVlaTVJ6M8BPoCW4G3ALd0ep5MnzSlt7CwaEwms9ZhZGsGgx5XVwepCysgdWFdpD6sR4bWRXw8ugcP0Af8i+7hA/QPHqB7+BD9wwfoAh+iCwmxbLUJf/Q9ISF940ojisGA4uqG4uQEDvYodvZg74Bibwc2tig2NmBjBIMRbGz4JTiIjseO8k9MTLrHlumTJldXV+Li4oiNjbVobQoLC0On0+Hm9mr5pslkJiFB/hhZA6kL6yF1YV2kPqxHiutCUdBFhKMLDEQf+BB9UGDi45BgdCHB6IMffQ8KQv/gAfr7/6ILDESnUYuOReh2dihOTihOziiOjolfdvZgZ4fi4JD42MEh8RhHp0ffHf977OT8X5mzC4qrK2ZXN3B0BJ0u2XG43r1DVIPaEBODh4cHuXPnSbfXnOmTpsdjmW7cuEGpUqXU8uvXr5MvX75X6poTQgghUsRkQhcUlJj0PHiI/sF99A8fqN91gYHogwLRBwaiC0p8rIuPT5dQFKMRxdUVxSUxGUl87JKYoDz+/jhpeZz42DuArQ2KjS3YPmrVsU9s7VHs7RP329uhODiCjU26xJ1S+fMXYM6c+XzzzRoWLlyKo6Njuj1Xpk+aKleujLOzM/7+/mrSFB8fz65du6hXr57G0QkhhMiUFAUiI9GHBKMPDkpMhIKD0AU/2g4OQh/06HtwEPrgYAgJxj04ON1agRQbG8x58mLOmxdzntcw530Nc+7cmHPlxpwrF0qu3Jhz5sLsngPF1RXs7VPUYpMZKIrCt99+TYsWrXB1/a8nqUWL1rz7bit06fx6rSppio6O5uDBgwDcvXuXiIgIduzYAUD16tXx8PCge/fu3Lt3T51OwM7Ojv79+7Nw4UI8PDzw9PRk3bp1hISE0Lt3b81eixBCCCsRG5vY9RX4MHHsT+DDxMQnJARdaEhiF1hoCPqQEIsusdS0ACX3X7ZiZ5eY4HjkRMmZE3POnImPPXJizuGB4uGRmPzkyJH43d0dxc09yyVBKREQEMDQoYPYu3c3x48fZdGiLy32p3fCBFaWNAUGBvLhhx9alD3e/vrrr6lRowZmsxmTyWRxTN++fVEUha+++oqgoCBKly7NypUrKViwYIbFLoQQIp3Exz8a1ByK/vEA5/DwxAHOEeHow8Mf3bIehi70UdITHJzYRRYcjD48LN1DNLu5o8+VkwQ3d8zuiYmOOVcuzLnzJLYAqS1CuTF75AQnp2ydAKXUrl3+DB3qy8OHDwHYuHE9/fsPokKFShkah05RrGA0mRULDo6UAZYaMxr15MjhJHVhBaQurEumro+4OHTh4Ynjfe4HJI75uR+A/v599AH/PnockPg4KCjDwjI7OVu27uTwSGz5yZEDcw4PzB4e/5U9bg1yd8dob5t568KKRUVFMWHCWFav/m+Fj9y587Bw4RK8vRs98xwPD6d0my/LqlqahBBCZDIxMU+N+QlC/2iws+5Rl1jioOegxFaiiHB0ERHJmqzwVSgGQ2Ki4+aOkjNXYldYrtyYc+VM3H6cCLm5o7g/+p4jh9UMbhZw7twZBgzozdWrV9Syxo19+OKLReTKlUuTmCRpEkII8Z/HSVBgYGLrz4P7ia0/j1t+ggITu7we3wEWFZluoSh2do8GO+fBnCPHo7u/3B7dmp54V5ji4vLfd2dndRyQ4uwCqViaS2jPbDazePFCpk2bRPyjcWUODg5MmjSNbt16ZsjYpeeRpEkIIbKy+Hj1ji81GXrc7aV+v5/uSZBiMKC4uaE4u6I4O6O4uGB2dk5s9cmTF3OePInfc+dJTJTy5Mn2A5+zq59//olJkz5Vt8uXr8jSpSt54w1PDaNKJEmTEEJkNoqSeJfXgwCICMb2ynVs7917NDboAbrHLUQPH6IPDUn7p9frE8fz5Hg0vscj8e4vi7E+OXMlluXMiTlnLhRXN0mARLI0b96St99+h717d+Pr+yGjR4/D1tZW67AASZqEEMI6RUVhuHkDw43rGG7fwnDrBvrbtxIf/30bXXS0eqjTKz5VYhKUE7OHx3+3vXt4JN7xlTuxBUjJnSfxca5HCZB0fYk0Eh8fj80TY8l0Oh3z5i3mypVL1KljXfMtStIkhBBaUBR09+9j+PtRInT7VmJSdOM6huvXMPxz75Uub3Z2Qcn1aAC0h4fl/D+PJkg0PZogUcmZEwyGNHphQiTfqVO/4uvbjxkz5tKggbdanidPHvLkSb/lUFJLkiYhhEhHuvCwxETor6sYrl7BcO0qxqtXMVz/y6K1KLkUOztMBQthzlcAJX8+7IoWJipHLuLzvJ44LuhRixAODunwaoRIGwkJCcyfP4fZs6djMpkYPHgABw8ex8Mjp9ahvZAkTUII8SrM5sTB1LdvY7h9M7HV6MZ19Uv/8EHKL5kzJ6YixTAVK46paDFMhYtgKlQEc+HCmPPkVbvGjEY9djmciJW5gUQmcuvWTXx9+/Hrr7+oZQUKFCQqKkqSJiGEyAp04WEYrlzGcPUKxiuXMVy9nNh6dOfvFM85pBgMmIoUxVSkKOZChTEVLIypcGHMBQthKlos8a4xIbIYRVH44YfvGTVqBBER4QDo9XpGjBjFsGEfYzRaf0pi/REKIURGUhT0f9/GeP5PjH+exfjnOYznz2G4fSvFlzLlfQ1T0WKYixQloYQnpjc8MZV4A1PhImAldwMJkRFCQ0MYOXIYW7ZsUssKFSrC4sXLqV69hoaRpYwkTUKI7ElR0D14gPGvKxgunsd44QLGi+cxXLqI/tGn4JdewsHhUdfZo1aiQkUwPWotMhUpmri+mBDZ3O+//0bv3t24c+dvtax9+05MmzYLFxdXDSNLOUmahBBZnu7+fWzOnMZ47mxil9r1vzD89Rf6sNBkna84OpFQpiwJpUpjeqMkJk9PEt4oiblAQbn1XoiXcHfPQXBwMABubu7MmvUFrVq11Tiq1JGkSQiRpejCQjH+fhqb33/D+PtpjGd+x3DvbrLPNxUoSELpMiSUK09CuQqYypbDVKSYJEdCpFLRosWYOnUm33//HYsWfUn+/AW0DinVJGkSQmResbEYL1/E+MfvGE+fwua3kxiuXEanKC88TdHpMBcoiKl4CUzFS5BQqgwJpctiKlUqceJGIUSqKIrCpk0b8PFpjtMT3dMdO75Phw6d0WfyDx+SNAkhMoeIiMTB2ef+wHjuLDZnz2C4fBFdQsILTzM7u5BQsRIJFd9M/F6yNKaixWQeIyHSWGBgIMOHD8bf/39069aL2bPnqft0Op2mC+2mFUmahBDWJy4O4x+/Y3PyhJokGf66+vIWJKORhLLlSahSlfjKVUmoXBVTseLStSZEOtu/fy9DhgwkIOBfAL7++iu6d+9F+fIVNI4sbUnSJITQXnQ0NqdPYXP8aOLXqV9fOlu2otdj8ixJQrkKJJSvmJgkVagoLUhCZKCYmBimTJnIsmWL1DIPDw+++GJRlkuYQJImIYQGdEGB2Jz8FZtfjmFz4jjGM7+ji49/7vGKrS0JpcuSUKFiYpJUoSIJpcuCo2MGRi2EeNKlSxcZMKA3Fy78qZY1aODNwoVLyZv3NQ0jSz+SNAkh0l9EBLa/HMXm0EFsDx/EeP7cCw835S9AfC2vxK83q2AqWQqeWAVdCKEdRVFYuXIZEyd+Suyj2fDt7Oz49NOJ9OkzINMP9n4RSZqEEGnPbMZ49g9s9+3Bdv9ejL+dfOGA7YQSbxBfoxbxNWsTX8sLc6HCGRisECIlfvxxM598MlLdLl26DEuWrKRMmbIaRpUxJGkSQqQJ3cOH2B7ch+3e3dge2Iv+4cNnHqfodIljkGp5JSZJ1Wui5M6dwdEKIVLr3Xdb4eX1FUePHqZfv4GMGzcRe3t7rcPKEJI0CSFSRRcRnjho+3GX2xPjGp6WUKw48fUaEFe3AfF16qLk8MjASIUQr8JkMmEwGNRtg8GAn98yLl++iLd3Iw0jy3iSNAkhkkdR0F+9Aof34bz1R4y/HH9ul5vi6ERcvfrEeTcizvtt6W4TIpM6d+4MH3zQn5kz51GjRk21PH/+Apl6Zu/UkqRJCPF8cXHYHD+K7Z6d2O7agfHGdQCeHpKtdrnVrU9cw7eIr1EL7OwyPl4hRJowm80sXryQadMmER8fj69vX/btO4JrNp8xX5ImIYQFXUAAdnt3YbtrBzYH96OPjHjmcaYiRYlr4C1dbkJkMffu3WXw4AEcPnxQLXN3z0FISIgkTVoHIITQmKJguHgBu53bsd3xMza/n372YQYDCbW9sGnVktC63sQVKZ7BgQoh0ttPP23ho48+JCQkBEhc/uSDD4YyatRYbG1ttQ3OCkjSJER2pCgYT/yC3f+2YrfDH8Ptm888zJwzZ+K4pEaNiWv4FoacHuTI4YQ5OBISzBkbsxAi3UREhDN27CjWrftGLcuXLz+LFn2Jl1ddDSOzLpI0CZGN6G9cx37jeuw3rsdw6+Yzj0koU47Yxk2Ie7sxCZWrwhN3zQghsp6zZ/+gT5/u3Lx5Qy1r0aI1s2fPw909h4aRWR9JmoTI4nT372P3vx+x37QBm5MnkuxXjEbia9cltokPcY2bYi5YSIMohRBasbOz599//wHAycmZadNm0aFDZ3Q6ncaRWR9JmoTIgnSBgdht34bd1s3YHD2EzmzZlabodMTXbUDMex2Ia9IUxc1dm0CFEJorWbIUn302mR9++J7Fi5dTtGgxrUOyWjpFURStg7BmwcGRJMjYDU0ZjXpy5HCSuniZ2Fhsd/ljv/5bbPfvfeYcSgmlShPzXidi276HOV/+FD+F1IV1kfqwHpmlLhRFYfv2//HWW40sZvFWFAWTyYTRmPnbUjw8nDAY0mf9u8z/7giRnSkKxj9OY7/+W+y2/ID+0R0vTzIVLkJsq7bEtGyDqWw5kCZ3IbKl0NAQRo4cxpYtmxgw4AMmTZqq7tPpdFkiYUpv8g4JkQnpwsOw2/g9Dmu+wnjxfJL9pnz5iW3VlthWbUio+KYkSkJkc8ePH8XXtx937vwNwNKlfnTq1IXSpctoHFnmIkmTEJmI8dwZ7Fd/hf2mDeiiIi32KQ4OxDZrQUyHzsTXqSd3vQkhiI+PZ9asacyfP4fHo3FcXd2YPXueJEypIEmTEFZOf+8udls3Y7d5IzZn/0iyP75qdWK6dCf23ZYoLq4ZH6AQwipdu3aVgQP78Mcfv6tltWvXwc9vGQUKFNQwssxLkiYhrJAuJBi7n7YmJkrHj6J76n4Ns5Mzse91ILp778RxSkII8YiiKHz77deMGzeKqKgoAIxGI6NHj8PX90MM0gqdapI0CWEtFAWbY0ew/2YNdv/7EV1sbJJD4iu9Scz73Ylt+x6Ks4sGQQohrN3mzRsZPnywul28eAmWLl1JxYpvahhV1iBJkxAa092/j/36b7H/dg3GG9eT7E8oXoLYtu2JbdMOU7ESGkQohMhMWrZsw4oVy/jtt5N07dqTSZOm4uTkpHVYWYIkTUJoQVEw/noCh1VfYrftR3Tx8Ra7zTlyENOuA7EdOpNQvqLc/SaEeC5FUSxm7zYajSxevJyLFy/QtGlzDSPLeiRpEiIjRUZiv2kDDqtWYDx/LsnuuLr1Ewd1+zSHJyaeE0KIZ7l06SJDhgxg1qx5Ft1vRYsWk5m904EkTUJkAN39+zh8tQyHVSvQBwdb7DN7eBDzfneiu3THLH/khBDJoCgKK1cuY+LET4mNjWXAgN7s2XNYuuHSmSRNQqQjw7WrOCz2w37Dd0kGdsdXqUp0jz7EtmwjrUpCiGQLCAjgww8Hsm/fHrXM1taWhw8fSNKUziRpEiKtKQo2hw7gsHIZtjv9LaYLUIxGYlu3I7rfwMSZuoUQIgV27fJn6FBfHj58qJb16zeQceMmWqwlJ9KHJE1CpBFdRDh233+Hw1fLMV69YrHP7OxCTNceRPcbiDl/AY0iFEJkVlFRUUyYMJbVq1eqZXny5GXBgiV4e7+tYWTZiyRNQrwiXUAAjn7zsP/2a/QR4Rb7TK/nI7rPAGK690RxddMoQiFEZnb+/J/069eDq098GGvSpClz5/qRK1cuDSPLfiRpEiKVdPfv4+g3D4c1K9FFR1vsi6tdh+je/Yhr0gxsbDSKUAiRFZhMCdy8eQMABwcHJk2aRrduPS2mGRAZQ5ImIVJI9/BhYrK0arlFsqQ4OBDTriPRvfrK0iZCiDRToUIlRo/+lB9/3MySJSt44w1PrUPKtnSK8tSiVsJCcHAkCQlmrcPI1oxGPTlyOGlfFxEROC71w2HRAvSREWqxYm9PdPfeRH0wFCVvXu3iywBWUxcCkPqwJmlZF/v27aFu3frYPNFKbTabSUhIwNbW9lVDzfI8PJwwGPTpcu30uaoQWUl8PParVpCzRiWcZk5VEybFzo6ofgMJOnmWyM+nZfmESQiRviIiwvnww0F07NiGOXOmW+zT6/WSMFkB6Z4T4nkUBdv//YjT5AkWa8IpBgMxXXoQNWIk5tde1zBAIURWcerUrwwa1FcduzRv3hxat36PkiVLaRyZeJIkTUI8g/HkCZw/G4vNqV8tymNatCZqzDhMxd/QKDIhRFaSkJDAvHmzmTNnBiaTCQAnJ2emT5+Np2dJjaMTT5OkSYgn6G9cx2nKROx/2mJRHudVl8hPJ5JQuapGkQkhsppbt24yaFBfTp48oZZVqVKNxYuXy7pxVkqSJiEAoqJwmjUNhy8Xo4uPV4sTPEsS+dnnxL3dGOT2XiFEGlAUhR9++J5Ro0YQ8WhuN71ez4gRoxg27GOMRvnXbK2kZkS2Z3P8KM5DfS3GLZlz5SZy1Fhi3u8G8gdMCJGGNm3agK9vP3W7UKEiLF68nOrVa2gYlUgOuXtOZF8RETiP+Qj3lj5qwqTY2RE57COCfv2DmO69JGESQqS5d99tRblyFQBo374T+/cfkYQpk5D/CCJbsjl0AJfhgzHcvqWWxVerQfj8xZhKyCBvIUTaURTFYvZuOzs7lixZwcWL52nVqq2GkYmUkpYmkb1ER+M0diTu7VqoCZPi4EDE5OmE/LRDEiYhRJq6du0qLVv6cOnSRYvykiVLScKUCVld0nTt2jV69uxJpUqV8PLyYubMmcTFxb30vODgYMaPH0+DBg2oVKkSzZs3Z926dRkQscgsjGf/IEejejguX6qWxXnVJejAcaL7DQKDQcPohBBZiaIofPPNGt56qy6//HKMAQN6ExMTo3VY4hVZVfdcaGgo3bt3p0iRIixcuJCAgACmT59OTEwM48ePf+G5H374IdevX2f48OG8/vrrHDp0iAkTJmAwGGjfvn0GvQJhlUwmHPzm4TRjCrqEBCBx6ZOI8ZOI6dUP9Fb32UEIkYkFBQUyfPgQtm/fppbFxsbw77//UKRIUQ0jE6/KqpKm9evXExkZiZ+fH+7u7gCYTCYmTpxI//79yfucZSoePHjAiRMnmDZtGm3atAGgVq1anDt3jp9//lmSpmxM/+8/uPTrie0vx9Sy+AqVCF/0JSaZaVcIkcb279/HoEH9CAj4Vy3r2rUnkyZNxcnJScPIRFqwqo/Yhw4dolatWmrCBODj44PZbObo0aPPPS/hUeuBi4uLRbmzszOyHnH2ZXP0MDm866gJk6LXEznsI0K275GESQiRpmJiYhg+fDht27ZQEyYPDw/WrFnHnDnzJWHKIqwqabp+/TrFilnOgurq6kru3Lm5fv36c86C119/nTp16rB06VL++usvIiIi2L59O0ePHuX9999P77CFtVEUHPzm49auBfqHDwAw5S9AyI87iBozHmTRSyFEGrp8+RKNGjXgiy++UMsaNPDm4MFf8PFppmFkIq1ZVfdcWFgYrq6uScrd3NwIDQ194bkLFy5k2LBhNGuW+ANqMBgYN24cjRs3fqWYDAaryiuzpcd1kKy6CAvD6YMB2P7vJ7UovoE3kcu/gpy5rOsHPhNKUV2IdCf1YR0iI8PVu+Ps7Oz47LNJ9Os3EL2Ml9REei7ekCX+hyiKwpgxY7h58yZz5swhd+7cHDt2jKlTp+Lm5qYmUqnh6uqQhpGKV/HSurhwAVq3hitX/iv79FNsPvsMd7kzLk3J74V1kfrQVuPG3owbN45Nmzbx3XffUb58ea1DEunEqpImV1dXwsPDk5SHhobi5ub23PMOHDjAjh07+OmnnyhZMnFV6Bo1ahAYGMj06dNfKWkKC4vGZDKn+nzx6gwGPa6uDi+sC5uftuL0wQB0EREAmN3ciVy2goR3mkCY3OabVpJTFyLjSH1o49ixI9SoUQvDEx/GhgwZwejRo4mLUwgOjtQwOuHm5pBurXxWlTQVK1Ysydil8PBwHjx4kGSs05P++usvDAYDnp6eFuWlS5dm48aNREdH4+CQuk9iJpOZhAT5Y2QNnlkXJhNO0yfjOH+OWpRQtjyhq77BXKQoSN2lC/m9sC5SHxkjKiqKCRPGsnr1SsaNm8CQIcPVfUajHnt7e6KjI6UuNJae939ZVYdrvXr1OHbsGGFhYWrZjh070Ov1eHl5Pfe8/PnzYzKZuHz5skX5+fPnyZkzZ6oTJmHddMFBuHVuZ5EwxbRtT/DPuxMTJiGESCPnzp2hUaN6rF69EoDp0yfz119XNY5KZDSrSpo6duyIk5MTvr6+HDlyhE2bNjFz5kw6duxoMUdT9+7dadSokbpdr1498uXLx5AhQ/jxxx85fvw4s2bNYsuWLXTp0kWLlyLSmf7v2+Ro3BDb/XsBUAwGIiZPJ3zxcnB01Dg6IURWYTabWbRoAU2aeHP1auJ4SQcHB6ZNm03x4iU0jk5kNKvqnnNzc2PNmjV8/vnn+Pr64uTkRLt27Rg2bJjFcWazGZPJpG47OzuzevVqvvjiC2bPnk14eDgFChRg9OjRkjRlQfrbt3Bv01xdO86cKxdhy9cQ71VX48iEEFnJvXt3GTx4AIcPH1TLKlSoxJIlK3jjDc8XnCmyKp0isz++UHCw9E9rzWjUkyOHE8HBkZiv38C9dTMMf98GIKF4CUJ/+Alz/gIaR5k9PFkX8nuhPamP9LNt21ZGjBhCSEgIADqdjg8+GMqoUWOxfcZcb1IX1sPDwyndpuGwqpYmIV5Ef/sWrk8mTCXeIHTz/zC/9rrGkQkhspKNG9fj69tP3c6XLz+LFn2Jl7RmZ3tWNaZJiOe6cQPn5k3+S5je8CR0y8+SMAkh0lyzZi3U7rcWLVpz4MAxSZgEIC1NIhPQX78Gbd7FcOdvIDFhCtn8M8pzFnAWQohX4ejoyNKlKzl//k86dOiMLj2nmBaZirQ0CatmuHwJl+aN4fajFibPkpIwCSHSzK1bN2nfvhXXr/9lUV6+fEU6dnxfEiZhQZImYbWM587g3soH/b+JK4abSpchZNP/JGESQrwyRVHYuHE9DRt6ceDAPgYO7EN8fLzWYQkrJ0mTsErGU7/i1uZd9IGBiQVVqhC+zV8SJiHEKwsNDWHAgF74+vYjIiJx6a7AwCDu3r2jcWTC2knSJKyOzbEjuL3XCn1oCAAJ1WvC3r0oHjm1DUwIkekdP36Uhg292LJlk1rWvn0n9u8/QhFZSUC8hCRNwqrY7NuDW6e26CMTF96Nq1uf8E0/wgsWbBZCiJeJj49n6tRJtGrVlDuPbipxdXXjyy9X4ee3DBcXV40jFJmB3D0nrIbtz9tw7dcD3aNxBbGNGhO24muMTk4aRyaEyMyuXbvKwIF9+OOP39Wy2rXr4Oe3jAIFCmoYmchspKVJWAW7jetx7dPtv4Tp3VaErfoWZLFlIcQrunv3rpowGY1Gxo2bwKZN2yRhEikmSZPQnP3Xq3D5oD+6R+sJxnToTNiyr+AZSxUIIURK1avXgEGDhlC8eAn8/fcyZMhwDAaD1mGJTEiSJqEph2WLcPnoQ3SPlkCM7tGb8PmLwSg9x0KI1Pn9998wmy3Xfxsz5lP27DlMxYpvahSVyAokaRKasfv+O5w/HaNuR/l+SMSMuaCXH0shRMrFxMTw6adjaNy4IStXLrPYZ2dnh5OMjxSvSP47CU3YHD2My/DB6nbkx2OIHD8JZPZdIUQqXLp0kSZNvFm2bBEAkyaN5/r1axpHJbIaSZpEhjNcvYJrj/fVQd/RvfoS9dFoSZiEECmmKAorViylUaN6XLjwJ5DYqvTppxNl3iWR5mTgiMhQuocPcevcTp24Mvbtd4iYPEMSJiFEigUEBDB06CD27t2tlpUuXYYlS1ZSpkxZDSMTWZW0NImMExODW7eOGG7dBCChbHnCv1wlg76FECm2a5c/DRvWskiY+vUbyM6dByRhEunmlf5bxcXFcf78eQIDA6lcuTIeHh5pFZfIasxmXIYMwObUrwCYXnud0G83oDi7aByYECKz2bBhHR980F/dzpMnLwsWLMHb+20NoxLZQapbmr7++mvq1KlD586dGTx4MJcvXwYgKCiIGjVq8MMPP6RZkCKTUxScPx6G/dbNiZuOToR98z3mfPk1DkwIkRn5+DSjUKEiADRp0pQDB45LwiQyRKqSpk2bNjF16lTq1q3LlClTUB7NsQPg4eFBzZo12b59e5oFKTIxRcFp3Cgc1q5K3DQYCPvyKxIqVNI2LiFEpuXi4sqSJcuZNWsea9asI1euXFqHJLKJVCVNq1at4q233mLOnDk0bNgwyf6yZcty9erVVw5OZHKKgtPkCTguX5q4qdcTvng5ce/4aByYECKzuHfvLj16vK8usvtYtWo16N69Fzq5iURkoFQlTbdu3aJevXrP3e/u7k5ISEhqYxJZhOPs6Tgu/ELdDp+3iNjW7TSMSAiRmWzbtpUGDWqxffs2Bg3qi+nRUktCaCVVSZOrqyvBwcHP3f/XX3+RO3fuVAclMj+HhfNwmjVN3Q6fNY/Yju9rGJEQIrOIiAjnww8H0bt3N/UD+O3bt5K0NgmR0VKVNNWrV48NGzYQFhaWZN/Vq1fZuHEj3t7erxycyJxsf96G8+fj1e2IydOJ6d5Lw4iEEJnFqVO/4u1dh3XrvlHLWrRozYEDxyhcuIh2gQlBKqccGDp0KO3bt6d58+Y0bNgQnU7H1q1b2bRpE7t27SJ37twMGjQorWMVmYD+xnVcPvyv7iM/GU90P/lZEEK8WEJCAvPmzWbOnBlqN5yTkzPTps2iQ4fOMnZJWIVUJU158+Zl8+bNzJ07F39/fxRF4ccff8TJyYlmzZrx0UcfyZxN2VFMDK59e6APC03cbNWGqA9HaByUEMLa3bp1k0GD+nLy5Am1rEqVaixevJyiRYtpGJkQlnTKk/MFpFJQUBBmsxkPDw/0WWyF+uDgSBISzFqHkSk4jxqOw6oVACQUK07I7oMoLq6vfF2jUU+OHE5SF1ZA6sK6ZJX62LXLny5dOgCg1+sZMWIUw4Z9jDETrRaQVeoiK/DwcMJgSJ9cJFVXHTNmDGfOnFG3PTw8yJUrl5ownT17ljFjxqRNhCJTsNu6SU2YFHt7wlZ8nSYJkxAi63vnHR969uxDoUJF+OmnnXz88ZhMlTCJ7CNVSdOWLVu4ffv2c/ffuXOHrVu3pjYmkckYrl3FedhgdTti6ixM5cprGJEQwppdvHiBpzs5PvtsMvv3H6F69RoaRSXEy6VL+9X9+/ext7dPj0sLaxMdjWvv7ugjIwCIea8jMe930zgoIYQ1io+PZ+rUSTRoUIvvvltrsc/R0REXaZ0WVi7Z7Z979uxh79696vaGDRs4duxYkuPCw8M5duwY5cqVS5sIhVVzHjsS44U/AUgoWYrwmV+A3OUihHjKtWtXGTiwD3/88TsAY8eOpG7d+hQqVFjjyIRIvmQnTdeuXWPHjh0A6HQ6zpw5w59//mlxjE6nw9HRkWrVqjF69Oi0jVRYHbsN63D4Zg0AiqMjYcvXgJOTxlEJIayJoih8++3XjBs3iqioKACMRiPDh48kf/4CGkcnRMqk6u65UqVKMWvWLN599930iMmqyJ0Qz2a4fIkcjRuge/RHMGzhUmI7dE6X55K7UqyH1IV1sfb6CAoKZPjwIWzfvk0tK168BEuXrqRixTc1jCztWXtdZCfpefdcqm5PuHTpUlrHITKTyEhc+3RTE6bo97ulW8IkhMicDhzYx+DBAwgI+Fct69atFxMnTsFJWqRFJiX3dIqUURRcRg7DeDkxcU4oXZaIqbM0DkoIYU02blyPr28/dTtnzpzMneuHj08zDaMS4tWlOmk6ePAgq1ev5sKFC4SHhye5fRTg4sWLrxScsD72363FfuN6AMxOzoSt/BocHDSOSghhTd5++x1efz0f//xzj4YN32LBgiXkzfua1mEJ8cpSlTTt3LmToUOHUqJECZo2bcq6deto3rw5iqKwb98+ChcuzNtvv53WsQqNGf66ivOYj9TtiLkLMJV4Q8OIhBDWKEcOD/z8lnHx4nn69BmQ5VaKENlXqn6Sly1bRoUKFdi6dSuDBydOati2bVvmzJnDtm3bePDgAQUKyF0RWYrZjPOIIehiYgCI7t6b2NbtNA5KCKG1gIAABgzobTF2CaBu3fr06zdIEiaRpaTqp/natWs0bdoUg8GgTnWfkJAAQIECBejUqRPLly9PuyiF5uy/W4vt8aMAmAoVIWLiFI0jEkJobdcufxo2rMXmzRsZMmQgZrPcNSaytlQlTfb29tjY2ADg6uqKra0tDx48UPfnypWLO3fupE2EQnO6gACcJn6qbofPngeOjtoFJITQVFRUFCNHDqNLlw48fPgQgD//PMedO39rHJkQ6StVSVPRokW5du2aul26dGl+/PFHEhISiI2N5X//+x+vv/56mgUptOU8diT60BAgcZmU+Abe2gYkhNDMuXNnaNSoHqtXr1TLmjRpysGDv8js3iLLS1XS1KhRI/bu3UtcXBwAAwYM4Ndff6VatWrUrFmTU6dO0a9fv5dcRWQGtjv9sf9pCwDmnDmJmDRN44iEEFowm834+c2nSRNvrl69AoCDgwOzZs1jzZp15MqVS+MIhUh/qZoR/FlOnTrFrl27MBgM1K9fn5o1a6bFZTWXnWd31YWHkaNuDQz37gIQtuhLYt/rmOFxyEy71kPqwrpkVH3cu3eXwYMHcPjwQbWsQoVKLFmygjfe8Ey3581M5HfDeljdjODPUrVqVapWrapuR0RE4OzsnFaXFxpwmjpJTZjiGr5FbLsOGkckhNDCqVO/qgmTTqfjgw+GMmrUWGxtbTWOTIiMleapWGBgIHPnzqVhw4ZpfWmRgWx+OYb9V4l3QCoODoTP/AJ0Oo2jEkJooUWL1nTo0Jl8+fKzadM2Pv10oiRMIltKUUtTYGAgW7du5fbt27i5ufHOO+9Qrlw5IHGujiVLlrBlyxZiY2OpXr16ugQs0p8uLBQX337oHvXcRo4ah7lwEW2DEkJkmOvXr1GsWHGLsmnTZhEfH0+OHB4aRSWE9pKdNF27do0uXboQEhKiLpmyYsUKZs2ahU6nY+zYscTFxfHOO+/Qu3dvNZkSmY/z6I8w/H0bgLhaXkT3H6RxREKIjJCQkMC8ebOZM2cGixZ9SZs276n7nJ1dNIxMCOuQ7KRp/vz5REVF8dlnn1G1alXu3LnDtGnTmDp1KuHh4TRs2JCPPvqIggULpme8Ip3ZbfkB+x++B8Ds6ka43zIwGDSOSgiR3m7dusmgQX05efIEACNHDqdGjVrkzy+rOwjxWLKTplOnTtGpUyc6dky8e6pEiRIYDAb69u1L69atmTZNbkXP7PR37+A8cri6HTFjDuaChTSMSAiR3hRF4YcfvmfUqBFERIQDoNfr6ddvoCyyK8RTkp00hYSEULJkSYuyUqVKAcjivFmB2YzLB/3/m8SyTTti27bXNiYhRLoKDQ1h5MhhbNmySS0rVKgIixcvp3r1GhpGJoR1Svbdc2azWV1n7rHH246ypEam57DED9ujhwEw5S9AxIy5GkckhEhPx48fpWFDL4uEqX37Tuzff0QSJiGeI0V3z/3555/Y2dmp25GRkeh0On777TfCw8OTHP/OO++8eoQi3RmuXMZp6kQAFJ2OcL9lKG7u2gYlhEg3P/zwPb6+/dSbetzc3Jk16wtatWqrcWRCWLdkzwj+uCsu2RfW6bh48WKqgrImWX52V0XB7b1W2B7aD0CU74dEfva5xkFZkpl2rYfUhXVJbX3cv3+fBg1q8vDhQ2rXroOf3zIKFJCbeF6F/G5YD6uYEfzrr79OlwCEtmz9f1YTJlPBQkSO/ETjiIQQ6S1PnjzMn7+Yixcv4Ov7IQa5Q1aIZEmzteeyqiz9qSEmBo861THcvglA6FffENe8hbYxPYN8grMeUhfWJTn1ERgYyJQpExg7dgI5c+bM4AizD/ndsB5W0dIksh7HJQvVhCmubgPimr2rbUBCiDS1f/9ehgwZSEDAvwQGBrJ69bfoZDkkIVItfVIxYfX0d+/gOH8OAIrBQMSUGbK2nBBZRExMDJ9+OoYOHVoTEPAvAL/+epw7d/7WODIhMjdJmrIpp0mfoouKAiC6dz9MpUprHJEQIi1cunSRJk28WbZskVrWoIE3Bw4cp6BMVivEK7G6pOnatWv07NmTSpUq4eXlxcyZM4mLi0vWuQEBAYwaNYqaNWtSoUIFfHx8+Omnn9I54szH5vhR7B/NzWLOmZOoj8doHJEQ4lUpisKKFUtp1KgeFy78CYCdnR2TJ09n/frNMru3EGnAqsY0hYaG0r17d4oUKcLChQsJCAhg+vTpxMTEMH78+Beee//+fTp06EDRokX5/PPPcXZ25urVq8lOuLINkwnnT0aqm5GffCZzMgmRyQUEBODr2599+/aoZaVLl2HJkpWUKVNWw8iEyFqsKmlav349kZGR+Pn54e7uDoDJZGLixIn079+fvHnzPvfcWbNm8dprr7FixQr19tlatWplRNiZiv36bzGePwdAfIVKxHTuqnFEQohXdeDAPouEqV+/gYwbNxF7e3sNoxIi60l199y9e/cYP348jRs3pnr16pw8eRKAoKAgJk+ezIULF1J8zUOHDlGrVi01YQLw8fHBbDZz9OjR554XERGBv78/nTt3lvlGXiQqCscZU9TNiMkzQN4vITK99u070qJFa/Lkycv69ZuZPHmGJExCpINUtTT99ddfvP/++5jNZipUqMDt27dJSEgAwMPDg99++42oqCimTp2aoutev36dtm0tp/F3dXUld+7cXL9+/bnnnT9/nvj4eIxGI126dOH333/H3d2dVq1aMXToUGxsbFL+Ih9Jr7ketGC/cimGf/8BIK5pc6jjZV1Njc/xuA6yUl1kVlIX1uHu3bvkz59frQej0cC8eQtISEggV67cGkeXPcnvhvVIzxvBU/U/c9asWbi4uLBhwwYAateubbG/fv36+Pv7p/i6YWFhuLq6Jil3c3MjNDT0uec9fPgQgHHjxtG+fXs++OADzp49y4IFC9Dr9YwYMSLFsTzm6uqQ6nOtysOHMP/RIrx6PbazZmCbw0nbmFIoy9RFFiB1oQ2z2cycOXMYO3YsGzdupGXLlkBifbi6FtA4OgHyu5HVpSppOnnyJL6+vnh4eBAcHJxkf758+QgICHjl4JLLbE6cfbV27dqMHj0agJo1axIZGclXX32Fr69vqpuqw8KiMZky/+yuDp9OwD4sDIDY97sR9XphCI7UOKrkMRj0uLo6ZJm6yMykLrRz9+5dfH37cejQQQB69erF8eMn8fQsJvVhBeR3w3q4uTmg11vRjOCKorwwCQkKCsLW1jbF13V1dSU8PDxJeWhoKG5ubi88DxITpSfVqlWLpUuXcuvWLUqWLJnieABMJnOmnxJff+smdiu/BEBxcCDi4zGYM+Frygp1kVVIXWSsbdu2MmLEEEJCQoDEBdE7d+6Gm1sOQOrDmkhdaC89F4dLVSpWpkwZDh48+Mx9CQkJ/Pzzz1SsWDHF1y1WrFiSsUvh4eE8ePCAYsWKPfe8EiVKvPC6sbGxKY4lK3GaPhldfDwAUf19Mb/2usYRCSGSIyIinA8/HETv3t3UhClfvvxs2rSN8eMnperDqRAi9VKVNPXr14/Dhw/z2WefcfXqVSBxUchjx47Rq1cvrl+/Tr9+/VJ83Xr16nHs2DHCHnUjAezYsQO9Xo+Xl9dzz8ufPz+enp4cO3bMovzYsWPY29u/NKnKyoznzmC/KXHsmdnDg+gPPtQ4IiFEcpw69Sve3nVYt+4btaxFi9YcOHCMOnXqaRiZENmXTlFS15C1detWpk6dSnh4OIqioNPpUBQFZ2dnJkyYQPPmzVN8zdDQUJo1a0bRokXp37+/Ornlu+++azG5Zffu3bl37x67d+9Wy/bt28egQYPo2rUrDRo04Ny5c/j5+dG7d2+GDRuWmpcIkOlXrHZ7ryW2B/cDEPH5NKL7+2ocUcrJ6uHWQ+oiY2zatIEPPuiPyWQCwMnJmWnTZtGhQ2eLBXelPqyH1IX18PBwSre7GFOdNAFERUVx7Ngxbt68idlsplChQtSpUwdnZ+dUB3Tt2jU+//xzfv/9d5ycnGjZsiXDhg2zaIbu2rUrd+/eZd++fRbnbt++ncWLF3Pz5k3y5MlDhw4d6Nev3yut6p2ZfwFsDuzDvX0rAEyFChN09BTY2WkbVCrIHyPrIXWRMe7du0uDBrUICQmhSpVqLF68nKJFkw5RkPqwHlIX1sPqkqbHLUvZQab9BTCbcW9UH5tzZwAIW7KC2LbtNQ4qdeSPkfWQusg427Zt5dKliwwb9jFG47Pv2ZH6sB5SF9YjPZOmVF21bt26TJ48md9++y2t4xFpxG7zRjVhiq9QidjW7TSOSAjxLKGhIYwdO5KwMMu56N59txUffzzmuQmTECLjpeq3sXr16mzatIlvv/2WvHnz4uPjg4+PDxUqVEjr+ERqxMbiNH2yuhn56URIpzkrhBCpd/z4UXx9+3Hnzt8EBQWxZMkKrUMSQrxAqpKmuXPnEhMTw/79+/H392fdunWsXr2a/Pnz07RpU3x8fChdunRaxyqSyWHVcgy3bwEQ18Cb+PoNNY5ICPGk+Ph4Zs2axvz5c3g8QmL37p3cvXuH/PllZm8hrNUrDQR/LCoqin379rF9+3aOHDlCfHw8hQsXZseOHWkRo6YyW/+0LjQEj+oV0QcHo+h0BO85jKl85m4BlLEC1kPq4tVdu3aVgQP78Mcfv6tltWvXwc9vGQUKFEzRtaQ+rIfUhfWwujFNT3N0dKR58+bMmjWLkSNH4ujoyK1bt9Li0iKFHBfOQ/9oaZvYtu0zfcIkRFahKArffLOGt96qqyZMRqORceMmsGnTthQnTEKIjPfKIwyjo6PZt28f/v7+HD58mLi4OAoVKoSPj09axCdSQH/vLg5fLgZAsbUlcvQ4jSMSQgAEBQUyfPgQtm/fppYVL16CpUtXUrHimxpGJoRIiVQlTbGxsRw4cIDt27dz6NAhoqOjyZ8/P127dqVp06aUKVMmreMUyeA4cyq6mBgAonv1w1yosMYRCSEAfv55m0XC1LVrTyZNmoqTk5OGUQkhUipVSVPNmjWJiYkhT548tG/fnqZNm6ZqrTmRdgwXL2C//lsAzK5uRA0doXFEQojHunTpjr///zh9+hRffLEIH59mWockhEiFVCVNbdq0wcfHh6pVq6Z1PCKVnCZ9is6cOPgwashwFI+cGkckRPb14MEDcufOrW7rdDrmz1+CyZTAa7JgthCZVqoGgn/66aeSMFkRmwP7sNubuA6fqUBBovsO0DgiIbInRVFYsWIpVauWY//+vRb7cufOLQmTEJlcslqaTp48CUC1atUstl/m8fEiHZlMOE/4b8B35CfjwcFBw4CEyJ4CAgL48MOB7Nu3B4AhQwZy4MBxcuaUVl8hsopkJU1du3ZFp9Nx5swZbG1t1e3nebw23cWLF9MsUPFsdhvWYbzwJwDxld4kts17GkckRPaza5c/Q4f68vDhQ7WsZcvWMtBbiCwmWUnT119/DYCtra3FttBYZCROUyf9tzlhiiyXIkQGioqKYsKEsaxevVIty5MnLwsWLMHb+20NIxNCpIdkJU3Vq1d/4bbQhuOShRgC/gUgtkkz4mvX0TgiIbKPs2f/YODAPly9ekUta9KkKXPn+pErVy4NIxNCpJdUNUt069aN48ePP3f/L7/8Qrdu3VIdlHg5fcC/OPrNB0AxGon8bNJLzhBCpJXNmzfi4/OWmjA5ODgwa9Y81qxZJwmTEFlYqpKmX3/91aLv/mlBQUHJHiwuUsdxxhR0UZEAxHTvhan4GxpHJET28eabVbC1tQOgQoVK7NlzmO7de71wrKcQIvNL9TIqL/rjcOvWLRkAmY4Mly5i/91aAMwurkSOGK1xREJkL0WLFmP69NlcuXKZUaPGquM9hRBZW7KTpi1btrBlyxZ1e8mSJWzYsCHJceHh4Vy+fJl69eqlTYQiCaeZU/+byPLDESjSHSBEuomICGfevDkMHfoRzs7OanmHDp01jEoIoYVkJ03R0dEEBwer25GRkeifcaeWo6MjHTt2xNfXN20iFBYM585i978fATDlyUt0n/4aRyRE1nXq1K8MGtSXmzdvEBwcxJw5C7QOSQihIZ2iKEpKT/L29mbs2LG89dZb6RGTVQkOjiQhwax1GCrXrh2w2+kPQPjUmcT0yfqzfxuNenLkcLK6usiOsktdJCQkMG/ebObMmYHJZALA2dmFo0dP8vrr+TSO7j/ZpT4yA6kL6+Hh4YTBkD7T76RqTNO+ffvSOg6RDMbTp9SEyZQvPzFdemgbkBBZ0K1bNxk0qC8nT55Qy6pUqcbixcutKmESQmS8ZCVN9+7dAyBfvnwW2y/z+HiRNpxmTFEfRw37GOztNYxGiKxFURR++OF7Ro0aQUREOAB6vZ4RI0YxbNjHGI2pvm9GCJFFJOuvgLe3t8UyKo+3X0aWUUk7xhO/YPtoAVBTocLEdOqicURCZB2hoSGMHDmMLVs2qWWFChVhyZLlVKtWQ8PIhBDWJFlJ09SpU9HpdNjY2Fhsi4zjNGOy+jhyxCiQW5yFSDM//LDBImHq0KEzU6fOxMXFVcOohBDWJlUDwbMTaxjUZ3PkEO5tmgOQUKw4wUdOQjbqKpABltYjq9aF2WymXbsWnDt3llmzvqBVq7Zah5QsWbU+MiOpC+thdQPBnycuLo6EhAQcHR3T8rLZm6LgNP2/Vqaoj0Znq4RJiPQQGhqCm5u7uq3X61m06EtMJhMFChTULjAhhFVLVSr2888/M3XqVIsyPz8/KleuTLVq1fD19SUyMjJNAszubI4cwubXXwBI8CxJbOt2GkckROalKArffLOGN98syy+/HLPY9/rr+SRhEkK8UKqSpq+++oro6Gh1+/Tp0/j5+VGnTh26d+/O4cOHWbp0aZoFmZ05LF+iPo4aMQoMBg2jESLzCgoKpGfPLgwfPpiIiHAGDepLaGiI1mEJITKRVPXz/P3337Ru3Vrd/t///keuXLnw8/PDaDSiKAq7du1ixIgRaRZodqS/dRPbJ+Zlim3eUuOIhMicDhzYx+DBAwgI+Fcta9jwbYxGGw2jEkJkNqlqaYqLi8POzk7dPnr0KPXq1VPnMSlevDj//vvv804XyeTw1XJ0j8bpx/ToDTbyB16IlIiJieHTT8fQvn0rNWHy8PBgzZp1zJkzXxYWF0KkSKqSpgIFCnDsWOJ4gHPnznHr1i3q1q2r7g8MDJTB4K8qMhL779YCoNjZES2zfwuRIpcuXaRJE2+WLVukljVo4M3Bg7/g49NMw8iEEJlVqrrnOnTowJQpU/jrr78ICAjgtddeo2HDhur+06dPU6JEiTQLMjuy/+F79I/GW8S0eQ8lVy5tAxIiE9m6dRODBw8gNjYWAFtbWz79dCJ9+w585kLjQgiRHKlKmrp27YqdnR0HDx6kXLly9OnTB/tHS3qEhITw4MEDOnXqlKaBZiuKgsPKZepmTJ/+GgYjROZTpkw5dQLe0qXLsHjxCsqWLadxVEKIzE4mt3wJLSYqszl8EPe27wIQX6MWIdt2ZujzWxuZNM56ZKa6WLVqBdeuXWXcuInqh7qsJjPVR1YndWE9rHpyy7/++ou7d+8CkD9/fumWSwMOy/+briGq7wANIxHC+kVFRbF0qR+DBg2xSI569uyjYVRCiKwo1UnTnj17mD59upowPVagQAFGjx7NW2+99crBZUeJ0wxsB8D0ej7ifJprHJEQ1uvcuTMMGNCbq1evEBwczOefT9M6JCFEFpaq9quDBw8yZMgQAIYNG4afnx9+fn4MGzYMRVEYPHgwhw4dStNAswuHVSv+m2agZx+ZZkCIZzCbzfj5zadJE2+uXr0CwNq1qyzmYRJCiLSWqjFNHTp0IC4ujm+//TbJ1AJRUVF07twZOzs7vv/++zQLVCsZ2j8dGUnOSqXRh4ag2NkR+PtFuWsOGStgTayhLu7du8vgwQM4fPigWlahQiWWLFnBG294ahKTVqyhPkQiqQvrkZ5jmlJ11cuXL9OqVatnzsXk6OhI69atuXz58isHl93Yb9qgTjMQ27qdJExCPGXbtq00aFBLTZh0Oh2DBw9j+/Y92S5hEkJkvFSNabKzsyM0NPS5+0NDQy1mDBfJoCg4rPhvAHi0TDMghCoiIpyxY0exbt03alm+fPnx81tGnTr1NIxMCJGdpKqlqUaNGnz99df8/vvvSfadOXOGtWvXUqtWrVcOLjuxOXII46WLQOI0AwkVKmkbkBBW5Jtv1lgkTC1atObAgWOSMAkhMlSqWpo+/vhjOnbsSOfOnalQoQJFixYF4MaNG5w9e5acOXPy0UcfpWmgWZ3D8iXqY5lmQAhLffoM4Mcft3Dp0kWmTZtFhw6d1ckrhRAio6R6csvAwECWLVvGoUOHuHfvHgD58uWjfv369OvXj5w5c6ZpoFrJiEF9+ps38KhRCZ2iYMqXn6CTZ+WuuSfIAEvrkVF1ERkZmWQx3Vu3bmI2mylatFi6PW9mI78b1kPqwnpY1eSWJpOJoKAgXF1d+eSTT/jkk0/SI65sxeGr5eo0A9EyzYDIxhRF4YcfvufTT0ezfv1mKlWqrO4rXLiIdoEJIQQpGNOkKApz586lWrVq1KtXjypVquDr60tISEg6hpcNRERg/91aABQ7O2K69NA2HiE0EhoawoABvfD17UdQUBADB/YhMjJS67CEEEKV7JamzZs38+WXX/Laa69Rt25d/v77b/bu3YvZbGbJkiUvv4B4JvuN69GHJd6JGNO2PUoW6dYUIiWOHz+Kr28/7tz5Wy2rUqUaiiLdHEII65HspGndunWUKVOG7777Tl3fafLkyXz33XcEBQXh4eGRbkFmWU9PM9BbphkQ2Ut8fDyzZk1j/vw5PB5e6ebmzqxZX9CqVVuNoxNCCEvJ7p77+++/admypcWCmJ07d8ZsNnPr1q10CS6rszm4H+OjJSDianlhKl9B44iEyDjXrl2lWbO3mTdvtpow1a5dh/37j0rCJISwSslOmkJDQ5O0JuXIkQOA2NjYtI0qm7CczFKmGRDZx7ZtW3nrrbr88UfiXG9Go5Fx4yawadM2ChQoqHF0QgjxbCm6e07mRUk7+hvXsd29EwBT/gLE+TTTOCIhMk6RIkWJj48HoHjxEixdupKKFd/UOCohhHixFCVNc+bMYdmyZeq22Zw4SHPcuHE4ODhYHKvT6fjpp5/SIMSsyf6H7y2nGTCmap5RITKl8uUr8sknn3H9+jUmTZqaZE4mIYSwRsn+T12tWrVnlssA8FRQFOy2bkp8qNMR+15HjQMSIv3ExMSwatUK+vTpj80Tc5ANGjRYWq+FEJlKspOmtWvXpmcc2Yrhz3PqAPD4mrUxv55P44iESB8XL15gwIDeXLx4npCQIMaMGa/uk4RJCJHZpM884+KF7B+1MgHEyl1CIgtSFIUVK5byzjv1uXjxPABLly7i/v37GkcmhBCpJwNpMtqTXXMGA7HvttI2HiHSWEBAAB9+OJB9+/aoZaVLl2HJkpXkyZNHw8iEEOLVSEtTBjP+dhLD37cBiK/XACVXLo0jEiLt7NrlT8OGtSwSpn79BrJz5wHKlCmrYWRCCPHqpKUpg9k90TUX07qdhpEIkXaioqKYMGEsq1evVMvy5MnLggVL8PZ+W8PIhBAi7VhdS9O1a9fo2bMnlSpVwsvLi5kzZxIXF5eia6xevZqSJUvSv7+VLUtiMmH34xYAFFtbmZtJZBkrV35pkTA1adKUAweOS8IkhMhSrCppCg0NpXv37sTHx7Nw4UKGDRvGhg0bmD59erKv8eDBAxYtWkROK1z41uaXYxgC/gUgzrsRipu7tgEJkUb69RtIuXIVcHBwYNaseaxZs45c0vUshMhiXql7LiAggJMnTxIYGEjjxo157bXXMJlMhIeH4+LigsFgSNH11q9fT2RkJH5+fri7uwNgMpmYOHEi/fv3J2/evC+9xqxZs/D29ubevXupeUnpym7LE3fNtZa75kTmFRsbi8Hw35xLdnZ2fPnlKhRF4Y03PDWMTAgh0k+qWpoURWHatGm89dZbfPTRR0yfPp0bN24AiWMbvL29UzWv06FDh6hVq5aaMAH4+PhgNps5evToS88/deoUe/bsYcSIESl+7nQXH4/d/7YCoDg6EvuOj7bxCJFKP/zwA2++WZYLF85blJco8YYkTEKILC1VLU0rVqzg66+/pm/fvtSqVYuePXuq+1xcXHjnnXfYtWsXPXr0SNF1r1+/Ttu2li0wrq6u5M6dm+vXr7/wXJPJxOeff86AAQPS9LZmgyFtejCN+w+iDwoCIL5JU4xuLmly3ezgcR2kVV2I1AkPD2fs2JF8803iB6KBA3uzd+8h7O3tNY4s+5LfDeshdWE90nPe3FQlTRs3bqRVq1YMHz6c4ODgJPtLlizJoUOHUnzdsLAwXF1dk5S7ubkRGhr6wnO/++47oqOjU5yovYyrq8PLD0qOn7eqD227dcE2h6y1lVJpVhcixX755Re6dOnCtWvX1LLy5cvh5GSDq6v8LGtNfjesh9RF1paqpOmff/7hzTefvyK5g4MDERERqQ4qpQIDA1mwYAEzZszA1tY2Ta8dFhaNyWR+tYvExOC+eQs6wOzqRmiNuhAcmSbxZQcGgx5XV4e0qQuRIgkJCcydO4tZs6ZjMpkAcHZ2ZvbsL3jvvY6YTDqC5WdZM/K7YT2kLqyHm5sDen36tPilKmnKmTMn//zzz3P3nz9/ntdffz3F13V1dSU8PDxJeWhoKG5ubs89b/78+ZQsWZKqVasSFhYGJP6xT0hIICwsDEdHR4zG1I15N5nMJCS82i+A7Z496CISX1dc0+YkGGzgFa+ZHaVFXYjku3XrJoMG9eXkyRNqWbVqNVi//jty5Mj7qC4U7QIUKvndsB5SF9pT0vHPUqpSsUaNGrF+/Xr+/vtvtezx4ptHjhxhy5YtNGnSJMXXLVasWJKxS+Hh4Tx48IBixYo997wbN25w8uRJqlWrpn6dPn2aI0eOUK1aNY4dO5biWNKSzaH96uPYpu9qGIkQybN9+/9o2NBLTZj0ej0ffzyGn3/e+cLfRSGEyMpS1fwyZMgQTpw4QcuWLalatSo6nY7ly5czf/58/vjjD0qXLs2AAQNSfN169eqxdOlSi7FNO3bsQK/X4+Xl9dzzPvnkE7WF6bGpU6dib2/P8OHDKVmyZIpjSUu2RxLHdykGA/FedTSNRYjkyJ07N9HRUQAUKlSExYuXU716DYxGGeQqhMi+UpU0ubi4sGHDBr766it27tyJnZ0dJ0+epFChQvj6+tKnT59U3VHTsWNH1q5di6+vL/379ycgIICZM2fSsWNHizmaunfvzr1799i9ezcApUuXTnItV1dXHB0dqVGjRmpeYprR3b+P8dJFABIqvYniknSguxDWplq1GowYMYqbN28wbdosXOTnVgghUj+5pb29PYMGDWLQoEFpFoybmxtr1qzh888/x9fXFycnJ9q1a8ewYcMsjjObzeqgVGtne/S/uwjj69TXMBIhni0+Pp7vvltLly7dLSakHTFilNrtLoQQwgoX7C1evDirV69+4THJmTgzNZNrpgebI/8lTXF16mkYiRBJXbt2lYED+/DHH78TEhLMhx/+NzGsJExCCGEpVUnTmDFjXnqMTqdj6tSpqbl8lmJ76ACQuEBvfDVtuwqFeExRFL799mvGjRtFVFTi2KW5c2fy/vvdZc04IYR4jlQlTSdOnEhSZjabefDgASaTCQ8PDxwcZIIv/e1bGG7dBCC+anVwdNQ2ICGAoKBAhg8fwvbt29Sy4sVLsGTJCkmYhBDiBVKVNO3bt++Z5fHx8Xz//fesWbOGr7766pUCywpsjh5WH8dL15ywAgcO7GPw4AEEBPyrlnXt2pNJk6bi5CQzewshxIuk6f3DNjY2dOnSBS8vLz7//PO0vHSmZHv4oPo4TgaBCw3FxsYyfvwntG/fSk2YPDw8WLNmHXPmzJeESQghkiFdJl0pVaoUJ0+eTI9LZx6Kog4CVxydSKhcReOARHa2ZMlCli71U7cbNPDm4MFf8PFppmFUQgiRuaRL0nTs2LFsP6bJcO0vDP8mLjUTX7MWpPGaeEKkRL9+g/D0LImdnR2TJ09n/frN5M37mtZhCSFEppKqMU1+fn7PLA8PD+fkyZNcuHCBfv36vVJgmZ3No7vmQLrmRMZLSEiwWG/R0dGRL79cDUCZMmU1ikoIITK3NE2a3NzcKFiwIBMnTqR9+/avFFhmZ/vE/EzxdWUQuMg4u3b588knI/n++80UL/6GWi7JkhBCvJpUJU2XLl1K6ziyFrMZm0czgZvd3EkoV0HjgER2EBUVxYQJY1m9eiUAAwf24eef92BjY6NxZEIIkTWkeExTTEwM06ZNe+60AwIM5/9EHxwMQHztOvDE0hRCpIdz587QqFE9NWECeO2119VFd4UQQry6FCdN9vb2fP/99wQGBqZHPFnCk11zcdI1J9KR2WzGz28+TZp4c/XqFQAcHByYNWsea9asw9XVTeMIhRAi60hV91zZsmW5cuVKWseSZdgc+W9+JlmkV6SXe/fuMnjwAA4/MR9YhQqVWLJkBW+84alhZEIIkTWlasqBTz75hO3bt7Nx40YSEhLSOqbMLT4em2NHATDnzoOpZCmNAxJZ0a5d/jRoUEtNmHQ6HYMHD2P79j2SMAkhRDpJdkvTyZMnKV68OB4eHowePRqdTsf48eOZPHkyefPmxc7OzuJ4nU7HTz/9lOYBWzvjH6fRR0YAj7rmZKV4kQ4cHZ0IDQ0FIF++/Pj5LaOOLNUjhBDpKtlJU7du3Zg1axbNmzfH3d0dd3d3ihYtmp6xZUo2x46oj+O95J+YSB916tTD1/dDbt++xezZ83B3z6F1SEIIkeUlO2lSFAVFUQBYu3ZtugWU2dkeP6o+jq/tpWEkIqtISEhg8+aNtGvXAb3+vx71sWM/Q6/Xo5PWTCGEyBCpGgguniMhAeOJXwAw5cmLqVgJjQMSmd2tWzcZNKgvJ0+eICQkmH79Bqn7DDKVhRBCZKgUDQSXT7QvZjx3Rh3PFF/bS8YziVRTFIUNG9bRsKEXJ0+eAGDq1Eky1YcQQmgoRS1NH3/8MR9//HGyjtXpdFy4cCFVQWVWNsePqY/ja0rXnEid0NAQRo4cxpYtm9SyQoWKsHjxcnLmzKlhZEIIkb2lKGmqXbs2RYoUSadQMj+b408MAq9dR8NIRGZ1/PhRfH37cefO32pZ+/admDZtFi4urhpGJoQQIkVJU6tWrXj33XfTK5bMzWzG5pfjiQ89PDB5ltQ4IJGZxMXFMWvWNBYsmKvecOHq6sbs2fNo1aqtxtEJIYQAGQieZgwXzqMPDQEedc3pUzVvqMimFiyYy/z5c9Tt2rXr4Oe3jAIFCmoYlRBCiCfJf/Y0YvPLE1MN1KqtYSQiM+rffxCFCxfBaDQybtwENm3aJgmTEEJYGWlpSiO2x56cn0nGM4kXM5vNFnMuubi48uWXq9Dr9VSs+KaGkQkhhHieZLc0Xbp0ScYzPY+iqC1NZlc3EsqU0zggYc0OHNhH3brVuX37lkX5m29WkYRJCCGsmHTPpQHD1SvoHz4EIL5GTZBJB8UzxMTE8OmnY2jfvhVXr17hgw/6YzKZtA5LCCFEMkn3XBqwWG+ulnTNiaQuXbrIgAG9uXDhT7XMwcGBiIhw3NzctQtMCCFEsklLUxqQQeDieRRFYcWKpTRqVE9NmOzs7JgyZQbr1m2ShEkIITIRaWl6VYqCzaNB4IqjEwkVKmkbj7AaAQEBfPjhQPbt26OWlS5dhiVLVlKmTFkNIxNCCJEa0tL0ivQ3b2D49x8A4qvXABsbjSMS1mDfvt00bFjLImHq128gO3cekIRJCCEyKWlpekW2x5/smpP15kQis9nMw0c3B+TJk5cFC5bg7f22xlEJIYR4FZI0vSKbJ5KmOBkELh55++3G9OrVl3v37jJ3rh+5cuXSOiQhhBCvSJKmV/Q4aVLs7Ul4s7LG0QgtmM1mtm//H82avYtOp1PLP/98Okaj0aJMCCFE5iVjml6B/s7fGB5NUBhfpRrY2Wkckcho9+7d5b33WtKrVxe+/fZri302NjaSMAkhRBYiSdMrsPnlmPo4vqZMNZDd/PTTFho0qMXhwwcB+PTTMQQHB2kclRBCiPQiSdMrsPntpPo4vnpNDSMRGSkiIpwhQwbSp093QkJCAMiXLz9r164nRw4PbYMTQgiRbmRM0yswnkpMmhSdjoQqVTWORmSEU6d+ZeDAPty6dVMta9GiNbNnz8PdPYd2gQkhhEh3kjSlVlQUxvPnADB5lkRxddM4IJGeEhISmDdvNnPmzFDXi3NycmbatFl06NBZxi4JIUQ2IElTKhnPnkGXkABAfNXqGkcj0tucOTOYM2eGul2lSjUWL15O0aLFNIxKCCFERpIxTan05HimhCrVNIxEZIR+/QaSL19+9Ho9H388hm3bdkrCJIQQ2Yy0NKWSxSBwSZqyHEVRLLrccuTwYOnSr9Dr9VSvXkPDyIQQQmhFWppSQ1EwnvoVALOzCybPkhoHJNLS8eNHadSoPgEB/1qU16xZSxImIYTIxiRpSgX9vbvqIr0Jb1YBg0HjiERaiI+PZ+rUSbRq1ZSzZ/9g8OABmM1mrcMSQghhJaR7LhWMT3bNVZWpBrKCa9euMnBgH/7443e1LC4ujvDwMNzc3LULTAghhNWQlqZUsDklg8CzCkVR+OabNbz1Vl01YTIajYwbN4FNm7ZJwiSEEEIlLU2pYDkIXKYbyKyCggIZPnwI27dvU8uKFy/B0qUrqVjxTQ0jE0IIYY2kpSml4uIwnv0DgISixVBy5tQ2HpEqhw4doH79WhYJU7duvdiz57AkTEIIIZ5JWppSyPjnWXSxsYB0zWVmISHB6t1xHh4efPHFInx8mmkclRBCCGsmSVMKyfxMWUOLFq3p2HEX//77DwsXLiVv3te0DkkIIYSVk6QphZ68cy6hqiRNmYGiKOzfvwdv70YW5TNnfoGtrS16vfRSCyGEeDn5b5FCNqdOAaA4OJBQppzG0YiXCQgIoHPndnTs2JZNmzZY7LO3t5eESQghRLLJf4wU0N2/j+H2TQDiK74JNjbaBiReaNcufxo2rMXevbsBGD36I0JDQ7QNSgghRKYlSVMKyCK9mUNUVBQjRw6jS5cOPHz4EIA8efKybNlXMu+SEEKIVJMxTSkgg8Ct37lzZxgwoDdXr15Ry5o0acrcuX7kypVLw8iEEEJkdtLSlAIyCNx6mc1m/Pzm06SJt5owOTg4MGvWPNasWScJkxBCiFcmLU3JlZCAze+nATDlL4D5tdc1Dkg8aebMqcydO1PdrlChEkuWrOCNNzw1jEoIIURWIi1NyWS4dBFdVCQgXXPWqHfv/uTKlRudTsfgwcPYvn2PJExCCCHSlLQ0JZPxz7Pq44Q3q2gYiXiW3Llzs3jxcoxGI3Xq1NM6HCGEEFmQ1bU0Xbt2jZ49e1KpUiW8vLyYOXMmcXFxLzzn/v37zJw5k5YtW/Lmm29Sr149RowYwd27d9MsLn1QkPrYnD9/ml1XpNypU7/y7ruNCQwMtChv0MBbEiYhhBDpxqqSptDQULp37058fDwLFy5k2LBhbNiwgenTp7/wvPPnz7N79258fHxYvHgxo0eP5sqVK7z33nsEPZHsvApdaLD62Cy3rWsiISGB2bOn8+67jTlx4jjDhn2AoihahyWEECKbsKruufXr1xMZGYmfnx/u7u4AmEwmJk6cSP/+/cmbN+8zz6tSpQr+/v4Yjf+9nMqVK9OgQQO2bt1Kr169Xjk2fWio+lh5FJvIODdu3KBjx878+usvatmDB/cJDw/D1dVNw8iEEEJkF1bV0nTo0CFq1aqlJkwAPj4+mM1mjh49+tzzXF1dLRImgNdeew0PDw/u37+fJrHpQkLUx9LSlHEURWHDhvVUrFhRTZj0ej0ffzyGbdt2SsIkhBAiw1hVS9P169dp27atRZmrqyu5c+fm+vXrKbrWjRs3CAwMpHjx4q8Uk8GQmFcawv5raTLk8kBvtKp8M0sKDQ1hxIihbN78g1pWuHARli5dQY0aNTWMLPtSfx8M8vNvDaQ+rIfUhfXQ6dLv2laVNIWFheHq6pqk3M3NjdAnusdeRlEUJk+eTJ48eWjWrNkrxeTq6pD4ICJMLXMvnA+MVvXWZTmHDx+mS5cu3L59Wy3r1q0bCxcufObPiMhY6u+FsApSH9ZD6iJry5L/+RcuXMgvv/zCihUrcHR0fKVrhYVFYzKZcQ0MxAAozi6EhMcCsWkSq3i2c+cuqgmTm5s7y5YtxcenBSaTmeDgSI2jy74MBj2urg7q74XQltSH9ZC6sB5ubg7o9enT4mdVSZOrqyvh4eFJykNDQ3FzS97YlQ0bNrBo0SKmTJlCrVq1Xjkmk8lMQoIZXXAIAGZ3dxIS5BcivbVr15Fdu3by4MF9li5dQfnyJQkOjpT33ko8/r0Q1kHqw3pIXWgvPW+qtqqkqVixYknGLoWHh/PgwQOKFSv20vN3797NhAkTGDJkCO3atUu7wBQFXWhI4kMZBJ7mFEXhxInj1KxZWy3T6XTMm7cIe3t77OxsNIxOCCGESGRVI9bq1avHsWPHCAv7b/zQjh070Ov1eHl5vfDcEydOMHz4cN577z18fX3TNrCoKHTx8UBiS5NIO0FBgfTs2YUWLZqwffv/LPY5OTlhMBg0ikwIIYSwZFVJU8eOHXFycsLX15cjR46wadMmZs6cSceOHS3maOrevTuNGjVSt69du4avry9FihShZcuW/PHHH+rXkwOJU0v/qJUJpKUpLR04sI/69Wuxffs2AIYP/4Dw8LCXnCWEEEJow6q659zc3FizZg2ff/45vr6+ODk50a5dO4YNG2ZxnNlsxmQyqdtnzpwhPDyc8PBwOnXqZHFs69atXzqj+MtYzNEkLU2vLCYmhilTJrJs2SK1zMPDgy++WISLi9wZJ4QQwjpZVdIEULx4cVavXv3CY9auXWux3aZNG9q0aZNuMUlLU9q5dOkiAwb05sKFP9WyBg28WbhwKXnzvqZhZEIIIcSLWVX3nLV6sqVJllBJHUVRWLFiKY0a1VMTJjs7OyZPns769ZslYRJCCGH1rK6lyRrpnmhpkiVUUmfGjCnMnTtT3S5dugxLlqykTJmyGkYlhBBCJJ+0NCWDPiRYfSwtTanTrVtPdU3Bfv0GsnPnAUmYhBBCZCrS0pQMMhD81eXLl5+FC5dhY2PE27vRy08QQgghrIy0NCWDDARPmXPnztChQ2tCn3jfABo39pGESQghRKYlSVMyyEDw5DGbzfj5zadJE2/279/LqFEjtA5JCCGESDPSPZcMlgPBc2gXiBW7d+8ugwcP4PDhg2rZ1atXCA8Pk7mXhBBCZAnS0pQM+idbmpK5cHB2sm3bVho0qKUmTDqdjg8+GIq//15JmIQQQmQZ0tKUDLqwUADMTs5gI4vHPhYREc7YsaNYt+4btSxfvvz4+S2jTp16GkYmhBBCpD1JmpLh8ZgmaWX6z2+/nWTgwD7cvHlDLWvRojWzZ8/D3V26MIUQQmQ9kjQlw+O75+TOuf+cPXtGTZicnJyZNm0WHTp0RqfTaRyZEEIIkT4kaXqZ6Gh0sbGAzNH0pB49erN37y4CAwNZvHg5RYsW0zokIYQQIl1J0vQSFtMNZNOWJkVROHPmdypVqqyW6XQ6Fi9ejqOjE0aj/BgJIYTI+uTuuZfQZfMlVEJDQxgwoBfvvNOAffv2WOxzdXWThEkIIUS2IUnTS2TnxXqPHz9Kw4ZebNmyCYAhQwYSERGucVRCCCGENiRpegl9NpwNPD4+nqlTJ9GqVVPu3PkbADc3dyZPno6zs4vG0QkhhBDakL6Vl8hui/Veu3aVgQP78Mcfv6tltWvXwc9vGQUKFNQwMiGEEEJb0tL0EhZjmrJw95yiKKxdu5q33qqrJkxGo5Fx4yawadM2SZiEEEJke9LS9BLZZbHemTOnMmfODHW7ePESLF26kooV39QwKiGEEMJ6SEvTS1h0z2XhlqYOHTqr45W6du3Jnj2HJWESQgghniAtTS/x5N1zShZeHqRIkaLMnbsAW1s7mjZtrnU4QgghhNWRlqaXyIotTZcuXaRnzy5ERERYlLdq1VYSJiGEEOI5pKXpJbLSlAOKorBy5TImTvyU2NhYcuTIwdy5C7UOSwghhMgUJGl6icd3zymOjmBrq3E0qRcQEMCHHw60mNX7t99OEhERLnMviRQzm03Ex8drHUa2ZzbriIkxEBcXi8mkaB1OtiZ1kTEMBiN6vXadZJI0vcTjMU2ZuWtu505/hg4dRGBgoFrWr99Axo2biL29vYaRicxGURTu3btHYGCQ1qGIRx4+1GM2m7UOQyB1kVEcHJxxdfVAp9Nl+HNL0vQSj8c0ZcauuaioKCZMGMvq1SvVsjx58rJgwRK8vd/WMDKRWYWEBBIdHYmzcw5sbe00+aMlLBkMOmnZsBJSF+lLURTi4mKJiEjsAXJzy5nhMUjS9CJmM7qYmMSHmayl6ezZPxg4sA9Xr15Ry5o0acrcuX7kypVLw8hEZmU2m4iMDMfNzQMHB+nStRZGo56EBGndsAZSF+nP1tYOgIiIYFxccmR4V50kTS/yRDOr4uamYSApd/jwITVhcnBwYNKkaXTr1lNaBkSqmUwmAOzs7DSORAiRnT1OnEymBPT6jB1rLEnTi1gkTe7axZEKAwd+wL59uwkNDWXJkhW88Yan1iGJLEMSbyGEdrT88C9J04s8kTRZ+2K9ly9fomTJUuq2Xq9n+fLVODu7YJuJ7/oTQgghrIVMbvkimaClKSIigqFDfalfvybHjx+12OfhkVMSJiGEECKNSNL0Io/GcIB13j33228n8fb24rvv1mI2m/H17Zdklm8hhBBCpA1Jml7kye45K2ppSkhIYM6cGTRv/g43b94AwMnJmZEjP8HJyUnj6IQQQoisScY0vciT3XNW0tJ069ZNfH378euvv6hlVapUY/Hi5RQtWkzDyITInI4fP8qmTd9z6dIFwsPDcXV1o1Sp0rzzjg9vvfWOprMPf//9t3z//Xc8fPgAL6+6TJs2R7NY0kvfvt1o0qQ5bdu2T7Kve/dOXLt2lUWLllOx4psW+6ZMmcClSxdYu3ZDkvPmz5/D4cMH+OGHbUn2HTlykE2bNnDp0kWio6PInTsP1arVoGPHLhQqVPi5cd66dZMvvpjJn3+exdHRiSZNmtK37yBsbGxe+PqOHDnImjVfcfPmDRwdHahQ4U0GDPiA/PkLJDnW3/9/bNjwHbdu3cTBwYFSpcoydepM7OzSfxLi1L6+5Jx7/PgRvv32a27evE5kZCS5cuWhXr369OzZD2dnZ/U6M2ZMBmDUqHHp8yLTgCRNL2LR0pRDw0ASJ/X64YfvGTVqBBER4UDiYO/hw0cyfPhIjEapSiFSatmyRaxdu4p69RoybNhIcubMRVBQEIcPH+Dzz8fj6upGjRq1NInt779v4+c3j/ff746XV13crKi1O60cPLiff/75h+bNWyTZd/36Na5duwrA7t07kiRNqbFkyUK+/XYNDRq8xahRY3F3z8Hdu3f4+eef+OyzMaxa9d0zzwsLC2PIkAEULFiIKVNm8eDBffz8viAmJobhw0c99/lOnz7FJ598TJMmzejXbxBhYaGsWLGU4cM/4Ouv11skQ2vWrOTbb7+ma9eelCtXntDQEE6dOonJlP7zPqX29SX33LCwMMqUKUu7dh1wdXXjxo1rfPXVl1y/fo0vvlikXuv997vTtWt7OnfuRsGChdL1NaeW/Kd9ESsa0zRr1jRmz56ubhcqVITFi5dTvXoNDaMSIvM6duwIa9euomfPvvTu3d9in7f327z3XkdNP4zcvn0LRVF4991Wz2yVSC5FUYiPj9fkppCXPffGjet4++3Gz2xJ2b17B3q9nkqVKrN//x6GDv34leojsbVjDT169KFPnwFqeaVKlWnWrAVHjx5+7rk//riJqKhIpk6dhatr4px9JpOJuXNn0K1bL3Llyv3M8/bu3UXevK8zZsx49Tb5HDk8GDJkAJcuXVQTwdu3b/LVV18yffpcatXyUs9v0OCtFL/O06dPMWTIAI4cOZXsc1L7+pJ7buPGTS3OqVy5KjY2tsycOYWHDx+o1y9QoCDly1dk8+aNfPjhiJS+9AwhY5pexIq651q1aouDgwMA7dt3Yv/+I5IwCfEKvv/+W3LmzEX37r2fub9MmXJ4ev43jceff55lyJABvP12HRo3rs+ECWMJDrZcg2/KlAl07dqe06dP0bNnZ95+uw59+3bj0qWLFse97FpTpkxg1KhhAHTo0Io6daqyfXtiV9PBg/vo0aMz3t61admyCfPmzSE2NjZJDMePH6F79040bFiLo0cPWew7efIE3bt3xNvbiw8+6Mc//9wjLCyUTz8dzTvv1Kd9+5bs3bsryXuSnLif99xPu3fvLmfO/E7DhkkTA0VR2LNnJ5UrV6VDh/cJDQ3ll1+OPfM6ybV+/bd4eOSkR48+z9zv5VX3uef+8ssxqlatriYFAN7ejTCbzRZDJZ6WkJCAo6OjxbxCTk6J3VGK8t9yKz//vI3XX89vkTBlpNS+vlc51+3RhNFPL/zdsOHb7N7tT0JCQmpeSrqTpOlFrGgguKdnSWbMmMuXX67Cz28ZLi6umsYjRGaWkJDAuXNnqFKlWrJaL/788yyDB/fHycmZiROnMXLkWC5dusDo0Uk/DQcFBTJ//mw6derGpEnTiYuL45NPPlL/CSTnWj169GHgwMEATJkyi6VLV1GrVh2OHDnIuHGjKFKkKFOnzub997uxZcsmPv/8U4sYHj58yLx5s+nQoTNz5izkjTdKWsTn5zePbt168dlnn3P37h0mTRrH+PFjKF68BFOmzKBkydJMmvQp//77T4rfgxc995N+++0kBoOB0qXLJtl37twZ/vnnHo0aNaFGjVq4ubmxe/eOl1XTc6W0vp9269ZNChUqYlHm4uJCzpy5uHXr5nPPa9r0XW7evM7mzRuJiIjg7t07LFu2CE/PkpQvX1E97vz5cxQvXpzVq1fQvHkjGjSoycCBvTh//s+XxqYoCgkJCerX4wWDnyx7WQKS2teX0nNNJhOxsbFcvnyJVatWUKdOPV5/PZ/FMeXKVSAkJIS//rqCNZLuuRd59MOn2NuDffoPxHvs2rWrzJ07izlzFmD/xPN27Ph+hsUgRHLZ/rQFpxlT0Gk03YXi7Ezk6HHEvdsq2eeEhYUSFxdHnjx5La+lKOpyMZA4blCv17N0qR+lSpVm6tRZaqtBsWIl6NatA8ePH6FWrTpPXDuMhQu/pFix4gDY29szZMgAzp//k4oVKyXrWvnzF6BgwcRByZ6eJdV/LF999SVly5ZnwoQpANSsWRtHRwemT5/CtWt/Ubx4CQDCw8OYPXsBZcuWe8Zrt4zv4cMHfPHFLN5/v7vaClOqVFkOHdrPoUMHaN++E0Cy34MXPfeTLl48T8GChZ7Zdbd7905sbe2oX98bo9FIgwZvsXPndqKionB0dHzhdZ/lcX3nzftais+FxNfk7Jx0vUUXFxfCwsKee17Fim8ydepsJk4cx9y5MwB44w1P5sxZiMFgUI8LCgrk8uVLXLt2jREjRmFvb8/XX69i+HBf1q/fQo4cHs99Dn///zF16sQk5Q0a1LTY3rjxpyQJyqu+vpSe267duzx4cB+AGjVq89lnU5KcV7RoMQwGA+fP/0mpUmVe+NxakKTpRR798cyoViZFUfj2268ZN24UUVFR5MiRg8mTZ2TIcwuRWo6L5mO8qu2nQsdF81OUND329HIMBw7s5dNPR6vbbdq8x6BBH3Lu3Bl8fT+0SKgKFixEnjx5uXjxgkXSlCtXbjUhAdS7Wh88CCAmJiZF13pSVFQUV69ewdf3Q4vyt99+h+nTp3D27B9q0uTm5vbcpOXp+B4nZ1WrVlfLXFxccHfPwf37AQApivtFz/2kwMCHuLsnvcEmISGB/fv3UKtWbfXOqkaNmvDjj5s5dGg/TZo0e+m1nyejl984d+4Mn38+nnffbYWXV11CQ0NYvXolH388lMWLl6tjucxmhejoKCZPnkGJEm8AULZsedq1a8GmTRssxmA9zcurLitWfK1uX7p0kdmzp1mUAS8cl5RRZs2aT0xMNDduXGfNmpWMGjWML75YZJFAGo1GnJ2dCQx8qGGkzydJ04s8bmnKgPFMQUGBDB8+RB23ALBv3x4iIyNl7iVh1aI+GIrT9MmatjRFPZVIvIyrqxu2trZqUvBYlSrV1X82o0YNBxI/SZtMJhYsmMuCBXOTXOvpazx5CzWA0Zh423VcXFyKr/WkiIhwFEXBwyPnU8+XuFRSWFioWpYjR86nT39BfIn/BlxcLFsLbGxsiItLHCuVkrhf9NxPiouLw8YmaSvTyZO/EBISjJdXPcLDE+8ULlasBDlz5mL37p1q0mQwGNSuqKeZzSaLbrjE+rYjIODfZMX2NBcXVyIjk/58J05R8fyhEvPmzaZKlaoMHjxMLStbtjxt2zZnx47ttGzZ5tH1XXBzc1MTpscxe3qW5MaNay+Mzc3N3eLOyqioKIAUtdKk9vWl9NzHr69cuQqUKlWGnj07c+jQfho2fNviOBsbW4txetZEkqYXeTRQL72XUDlwYB+DBw+w+IXu2rUnkyZNlYRJWL24d1ulqpVHS0ajkfLlK/LbbycxmUzqJ11XV1dcXRP/2TyeY8bZ2QWdTkfXrj2pV69BkmulZCqAV7nW43OfHnweERFOXFycxUDctG5QSUncyX1uV1dX/vnnnyTlu3fvBHjU5WTZ7RQSEkxwcBA5cnjg7p6DwMDAZ1774cMH5MjxXyvWf/X9KwkJCSke11S4cJEk43MiIiIIDHxI4cJFnnvezZvXqVu3vkVZnjx5cXNz5+7dO2pZ0aLFuHfvztOnA4nJZXpL7et7lXNLlHgDo9HInTtJX3dERLg6UNzayEDwZEivxXpjYmL49NMxtG/fSk2YPDw8WLNmHXPmzJeESYh01KHD+zx8+IC1a1e98DgHBwfKlSvPrVs3KFWqTJKv540TSetrOTo68sYbnhw4sNeifM+e3QBUqFAp2XGkVFq+B48VKlSEf/65Z1EWExPD4cMHqVu3AQsWLLX4mjBhCiaTSb2rr1KlykREhPPHH6ctrhEZGcHp079RsWJli/KOHTsTGBjI119/9cx4jh8/8txYa9aszalTv6otXwD79+9Br9dTvXrN55732muvc/nyJYuyf//9h9DQEIv3LLHrLpSrVy+rZaGhIY8WYi/93Os/S+XKVVM03QCk/vW9yrnnz/9JQkIC+fLltygPDg4mJibmhRONaklampIhPVqaLl26yIABvblw4b+7Ixo08GbhwqWpHqwohEi+2rXr0KVLD1asWMrVq5fx9n6HXLlyERERwZkzvxMUFIijY+IHl0GDPuTDDwcyfvwY3nrrHVxcXHjw4D4nT56gadN3qVy5arKf91Wu1atXP8aM+YhJkz7lnXd8uH37Fl9+uYgGDbzV8UzpJS3fA4Dy5SuyatVy7t8PUAfkHz58gOjoKN57r+Mzr/fdd1+ze/dO2rXrSPXqNalY8U3Gjv2YHj36UqxYcR4+fMB3332NwaCnXbuOFufWqlWHzp278dVXX3Lz5g3eeusd3N3duXfvLj///BORkRHPHU/WsmVbfvjhe8aMGUG3br148OA+ixbNp2XLNhZjhbZv/x9Tpkxk3rzFvPlmFVq2bMuCBXOYN282Xl51CQsLZc2aleTI4YG3939dUnXrNqB06TKMGzeKfv0GYWdnx9q1q7G1taF163YvfB+Dg4MtWq2ex9Oz5HPny0ru6/P3/x/Tp3+uvr7knvvJJx9TqlRpihd/Azs7O/766wrr1q2lePE3krRcXrp0AUjfDwGvQpKmZEiPlqaff/5JTZjs7Oz49NOJ9OkzQNMlG4TIbgYM+IAKFSqxefMG5s6dTkREBK6ubpQsWYrRo8fz9tvvAIn/4BcvXsHKlcuYNm0i8fHx5M6dl6pVq1GgQMEUPeerXKtOnfp8/vl0Vq1awZgxI3B1daVVqzb07eub6vcgI+J+ljffrIKbmxu//HKMFi1aA4ldc3nzvqb+Q35akybNWbBgDnfv3iF//gLMmjWPFSuWsn79Nzx8+ABnZ2cqV67G5MkzyZUrV5LzBw0aQvnyFdi0aQPTpk0iJiaa3LnzUL16TTp16vrcWF1dXZk/fwlffDGLMWNG4OjoxLvvtqJfv0EWx5nNZkwmkzoH03vvdcTW1oYtWzbx888/4ujoSNmyFfj88xkWXZp6vZ5ZsxawcOEcZs2aSnx8PBUrvomf33Jy5kz6Op50/PiRZ94997QX3T2X3Nf3+O7SJ+eYSs65pUuXZd++XXzzzRoUxcxrr73Ou++2plOnLkmWaTlx4hgVK76ZZOyetdApT756Yen6dShenMgRo4gaNTZNL52QkEDLlj5ERISzZMlKypRJOleJSGQ06smRw4ng4EgSEtJ/SQHxbPHxcQQG/kOePPnQ61++HpXIGEajPtP+Xixc+AVXr15mwYKlWoeSJjJzXViDhIQE2rZtzoABH+Dj0/y5xz3+W5Qz5+vPvJnAw8MJgyF9GiCkWSMZ0uLuuZs3b1hsG41GvvrqG3buPCAJkxAiW+rUqSsXLvzJVY2nrBDWYffuHTg4ONKoUROtQ3kuSZqS4VXmaYqKimLkyGHUrl2F33//zWJf3rx5LSavFEKI7CRXrlx88skEQkKCtQ5FWAG9Xs+YMeOtegF6643MiijPmIAtOc6dO8OAAb3VT1EDB/Zh376jqZrRVgghsqInB0SL7O3phX2tkbQ0JUNKu+fMZjN+fvNp0sRbTZgcHBwYOHCwuuiuEEIIITIXaWlKhpR0z927d5fBgwdw+PBBtaxChUosWbKCN97wTIfohBBCCJERpKUpGZLb0rRt21YaNKilJkw6nY7Bg4exffseSZiEEEKITE5ampIhOS1Ns2dPZ+bMqep2vnz5WbToS7y86qZjZEJoQWYpEUJoR8uZkqSl6SUUW1tIxjikxo2bqpN0tWjRmgMHjknCJLKUx+uzWetCmkKI7OHxQtIGQ8a3+0hL00so7u7JWoGyfPkKTJo0DScnJzp06IwurVfMFEJjer0BJycXwsNDMJkUbG3t5OfcCpjNOkwmaf2zBlIX6UtRFOLiYomICMbBwVmTFTQkaXqJZ607d+vWTfz85jN16kyLKeB79+6XgZEJkfHc3XNib29DYGCQ1qGIR/R6PWazzEJtDaQuMoaDgzOurh6aPLckTS/x5BxNiqLwww/fM2rUCCIiwsmRIweffDJew+iEyFg6nY58+fJhZ+dMbGy81uFkewaDDjc3R0JDo6SFQ2NSFxnDYDBqukar1SVN165dY/Lkyfz+++84OTnRsmVLhg4d+tzVmR9TFIXly5fz3XffERQUROnSpRkzZgyVKlV6pXge3zkXGhrCyJHD2LJlk7rvxx83M3ToRzJZpch29HoDNjbSNac1o1GPvb090dEmWfNMY1IX2YNVDQQPDQ2le/fuxMfHs3DhQoYNG8aGDRuYPn36S89dvnw5CxYsoEePHixbtozcuXPTq1cv/v7771eKyezuzvHjR2nY0MsiYerQoTN79hyShEkIIYTIJqyqpWn9+vVERkbi5+eH+6MWHpPJxMSJE+nfvz958+Z95nmxsbEsW7aMXr160aNHDwCqVKlCkyZNWLlyJRMmTEhVPAow/uoVZrVqqt7i6ObmzqxZX9CqVdtUXVMIIYQQmZNVtTQdOnSIWrVqqQkTgI+PD2azmaNHjz73vNOnTxMREYGPj49aZmtrS6NGjTh06FCq47kHzPzjdzVhql27Dvv3H5WESQghhMiGrKql6fr167Rta5mQuLq6kjt3bq5fv/7C8wCKFStmUV68eHHWrFlDTEwM9vb2KY4nT8GCXLt2DQB39xy4ubml+Bri1T2+q93NzQEN5zQTSF1YG6kP6yF1YT30+vQbb2lVSVNYWBiurq5Jyt3c3AgNDX3heba2ttjZ2VmUu7q6oigKoaGhqUqabGxskiRiQjta3jEhLEldWBepD+shdZG1Se0KIYQQQiSDVSVNrq6uhIeHJykPDQ19YdeYq6srcXFxSZZ3CAsLQ6fTSbeaEEIIIV6ZVSVNxYoVSzJ2KTw8nAcPHrywm+zxvhs3bliUX79+nXz58qWqa04IIYQQ4klWlTTVq1ePY8eOERYWppbt2LEDvV6Pl5fXc8+rXLkyzs7O+Pv/v717D2rqTv8H/oZUUO4iWivKKjInUDAiKl7CAlIsBawWlktdqBZR6ZSqpdoK6rBa2I6yXrYgBdYqSOuithWvgKBVUFC2rbow2LFaC11QgwYl0Mot+fz+6HC+xADGQGh/yfOayYx5cj7nPCeP4Tyc88mhkI91dnaiuLgYnp6eWs2ZEEIIIfrhDzUR/PXXX8dnn32G2NhYxMTEQCKRICUlBa+//rrSPZqWLl2KO3fuoKSkBABgbGyMmJgYpKWlwdraGhzHIS8vD48ePUJ0dPTvtTuEEEII0SF/qKbJ0tIS+/fvR1JSEmJjY2FqaoqQkBDExcUpLadQKCCXy5ViK1asAGMM+/bt4/+Myt69ezFhwoSh3AVCCCGE6CgDxuiOEoQQQgghT/OHmtNECCGEEPJHRU0TIYQQQogaqGkihBBCCFEDNU2EEEIIIWqgpokQQgghRA3UNBFCCCGEqEEvm6Yff/wRUVFRcHV1hVgsRkpKCjo6Op46jjGGf/3rX/D29oZIJEJ4eDiuXbum/YR1mCa1aGxsREpKChYtWoRp06bB09MTa9euRUNDwxBlrZs0/Vz0lJOTA6FQiJiYGC1lqR8GUguJRIL169dj9uzZEIlE8Pf3x/Hjx7WcsW7TtB4PHz5EYmIivL294erqigULFiAvL28IMtZddXV1SExMxKJFi/Diiy9iwYIFao0brOP3H+rmlkOhubkZS5cuxcSJE5GWlgaJRIKtW7eira0NiYmJ/Y7ds2cPUlNTsW7dOgiFQhw4cADLli3DsWPH6CaaGtC0FjU1NSgpKcFf/vIXTJ06FQ8fPkRGRgZCQ0Nx8uRJWFtbD+Fe6IaBfC663b9/H+np6Rg1apSWs9VtA6lFY2MjwsPDMWnSJCQlJcHMzAw3b9585uaX/J+B1GPNmjW4ffs23nvvPbzwwgsoKyvD5s2bIRAIEBYWNkR7oFtu3ryJ0tJSTJ06FQqFAureanLQjt9Mz2RmZjJXV1f28OFDPnbw4EHm5OTE7t271+e4trY25ubmxnbs2MHH2tvb2bx589jf/vY3LWasuzStRXNzM+vs7FSK3b17lwmFQrZ3715tpavTNK1FT++//z774IMPWGRkJFu5cqWWMtV9A6nFunXrWHh4OOvq6tJylvpD03o0NjYyjuPYV199pRSPiIhgS5Ys0Va6Ok8ul/P/Xr9+PQsMDHzqmME8fuvd5bmysjLMmTMHVlZWfMzf3x8KhQLl5eV9jrty5QpaW1vh7+/Px4yMjDB//nyUlZVpM2WdpWktLCws8NxzyidJx44dC2trazQ2NmorXZ2maS26ffvttzhz5gzWrl2rxSz1g6a1aG1tRWFhIf76179CIBAMQab6QdN6dHV1AQDMzc2V4mZmZmqfHSGqDA2fvW0ZzOO33jVNt2/fhr29vVLMwsICo0ePxu3bt/sdB0Bl7OTJk3Hnzh20tbUNfrI6TtNa9Oann36CVCrF5MmTBzNFvTGQWsjlciQlJeGtt97CmDFjtJmmXtC0FjU1Nejs7MRzzz2HyMhIODs7QywW4x//+Ac6Ozu1nbbO0rQeL7zwAjw8PJCZmYlbt26htbUVBQUFKC8vR0REhLbTJj0M5vFb7+Y0yWQyWFhYqMQtLS3R3Nzc7zgjIyMYGxsrxS0sLMAYQ3NzM4YPHz7o+eoyTWvxJMYYkpOTMWbMGAQGBg5minpjILX497//jcePH+PNN9/UUnb6RdNaPHjwAACwadMmhIWF4Z133kFVVRVSU1NhaGhIZwE1NJDPRlpaGuLi4vifSwKBAJs2bYKfn59WciW9G8zjt941TUT3pKWl4fLly/j0009hYmLye6ejV6RSKVJTU7Ft2zYYGRn93unoNYVCAQCYO3cu4uPjAQCzZ8/GL7/8gn379iE2NpZ+sRtCjDEkJCSgtrYWO3bswOjRo1FRUYGPPvoIlpaW9Ave/6f0rmmysLBAS0uLSry5uRmWlpb9juvo6EB7e7tStyqTyWBgYNDvWNI7TWvR0+HDh5Geno6///3vmDNnzmCnqDc0rcXHH38MoVCIGTNmQCaTAfhtLkdXVxdkMhlMTExU5p+R/g3kZxTwW6PU05w5c5CZmYm6ujoIhcLBTVYPaFqP8+fPo6ioCMePH+ff91mzZkEqlWLr1q3UNA2hwTx+692cJnt7e5Xr0C0tLbh//77K9c4nxwG/zZ3p6fbt2xg3bhz9BqcBTWvRraSkBJs3b8bq1asREhKirTT1gqa1+Omnn/DNN99g5syZ/OPKlSu4ePEiZs6ciYqKCm2nrnM0rYWDg0O/621vbx+U/PSNpvW4desWBAIBOI5Tijs5OaGxsRGPHz/WSr5E1WAev/WuafL09ERFRQX/WzEAFBUVwdDQEGKxuM9xbm5uMDMzQ2FhIR/r7OxEcXExPD09tZqzrtK0FgBQWVmJ9957D6GhoYiNjdV2qjpP01ps2LABubm5Sg9HR0e4uroiNzcXIpFoKNLXKZrWwtbWFhzHqTSqFRUVGD58+FObKtK7gdRDLpfjxo0bSvGamhqMGjUKI0aM0FrORNmgHr+f6QYFOuDRo0dMLBazyMhIduHCBfbll1+yGTNmsC1btigtt2TJEubr66sUy8rKYi4uLiwnJ4dVVFSwVatWsWnTprGff/55KHdBZ2hai1u3brHp06ezBQsWsO+++45dvXqVf9TV1Q31buiEgXwunkT3aRqYgdTi7NmzTCgUsuTkZHbx4kWWkZHBnJ2d2c6dO4dyF3SKpvVoaWlh3t7ebP78+ezo0aOsoqKCpaSkMEdHR5aenj7Uu6Ezfv31V1ZYWMgKCwtZZGQk8/Ly4p9LpVLGmHaP33o32cDS0hL79+9HUlISYmNjYWpqipCQEMTFxSktp1AoIJfLlWIrVqwAYwz79u1DU1MTnJycsHfvXrobuIY0rcV///tftLS0oKWlBYsXL1ZaNigoCFu3bh2S/HXJQD4XZHANpBY+Pj7YuXMnPvnkE+Tl5WHMmDFYtWoVVq5cOZS7oFM0rYeZmRlycnKwa9cubN++HS0tLRg/fjzi4+MRGRk51LuhM6RSKdasWaMU636em5uLWbNmafX4bcAY3WWLEEIIIeRp9G5OEyGEEEKIJqhpIoQQQghRAzVNhBBCCCFqoKaJEEIIIUQN1DQRQgghhKiBmiZCCCGEEDVQ00QIIYQQogZqmgghhBBC1EBNEyFESWVlJYRCISorK3/vVLRKKBQiLS1NrWV9fHwQHx+v5YwIIX90evdnVAjRVUeOHEFCQkKvr61YsQLr1q0b4ozU92TuRkZGGDduHMRiMd5++23Y2NhoPYcrV66gvLwcS5cuhYWFhda3pw4fHx80NDTwz0eMGAEHBwdERkbitdde02idpaWlqKqqwqpVqwYpS0L0BzVNhOiY1atXY/z48UoxjuN+p2yeTXfuHR0d+O6775CXl4fS0lKcPHly0P8qfFVVFQQCAf/86tWr2L17N4KCglSapqKiIhgYGAzq9tXl5OSEqKgoAMD9+/fxxRdfYP369ejo6EBYWNgzr6+0tBQHDhygpokQDVDTRIiO8fT0xJQpU37vNDTSM/fQ0FBYWVkhOzsbZ8+exYIFCwZ1W8bGxmova2RkNKjbfhbPP/88Fi1axD8PDg7GSy+9hJycHI2aJkKI5mhOEyF6oqGhAZs3b4afnx9EIhFmzZqF1atXo76+/qlja2trsWrVKojFYkyZMgWenp6Ii4tDS0uL0nLHjh1DcHAwRCIR3N3dERcXh7t372qc8+zZswGAz7Grqwvp6enw9fWFi4sLfHx8sHPnTnR0dCiNq66uRnR0NGbNmgWRSAQfHx+VS5c95zSlpaUhJSUFAPDSSy9BKBRCKBTy2+05p6m6uhpCoRD5+fkq+V64cAFCoRDnzp3jYxKJBAkJCZg7dy5cXFwQGBiIL7/8UuP3xNraGvb29vj555+V4t9++y1Wr14Nb29vuLi4wMvLCx999BHa2tr4ZeLj43HgwAF+/7sf3RQKBXJychAYGIgpU6Zg7ty5SExMRHNzs8b5EqJL6EwTITqmtbUVTU1NSjFra2tUV1fj6tWrCAwMxNixY9HQ0IC8vDwsWbIEp06d6vPyV0dHB6Kjo9HR0YHIyEjY2NhAIpHg/PnzkMlkMDc3BwBkZGTg448/hr+/P0JCQtDU1ITPP/8cEREROHr0qEbzhLobAysrKwDApk2bkJ+fDz8/P0RFRaGqqgpZWVn48ccfkZ6eDgCQSqWIjo7GyJEjsXLlSlhYWKC+vh4lJSV9bmf+/Pmora3FyZMnkZCQgJEjR/Lv25OmTJmCCRMmoLCwEEFBQUqvFRQUwNLSEh4eHgCABw8eICwsDAYGBoiIiIC1tTXKysqwceNGtLa24s0333zm96SrqwsSiQSWlpZK8aKiIrS1tWHx4sWwsrJCVVUVPv/8c9y7dw+pqakAgPDwcDQ2NqK8vJxvEntKTExEfn4+goOD8cYbb6C+vh4HDhzA9evXkZeXh2HDhj1zvoToFEYI0QlfffUV4ziu1wdjjD1+/FhlzNWrVxnHcSw/P5+PXb58mXEcxy5fvswYY+z69euM4zhWWFjY57br6+uZk5MTy8jIUIrfuHGDvfjiiyrxvnKvqKhgUqmU3b17l506dYq5u7szkUjE7t27x77//nvGcRzbuHGj0titW7cyjuPYpUuXGGOMlZSUMI7jWFVVVb/b5DiOpaam8s8//fRTxnEc+9///qey7Lx589j69ev55zt27GDOzs7s0aNHfKy9vZ3NmDGDJSQk8LENGzYwsVjMmpqalNYXFxfHpk+f3mtNntzusmXLmFQqZVKplN24cYO9//77jOM4tmXLFqVle1tXVlYWEwqFrKGhgY9t2bKF/z/R0zfffMM4jmPHjx9XipeVlfUaJ0Qf0ZkmQnRMYmIiJk2apBIfPnw4/+/Ozk60trbCzs4OFhYWuH79ep/fxjIzMwMAXLx4EV5eXr2ekSopKYFCoYC/v7/SWS4bGxv86U9/QmVlJd56662n5v7kmRdbW1ts374dzz//PI4ePQoA/KTobsuWLcO+fftQWlqK2bNn82e+zp8/D0dHR62cHQkICEBWVhaKi4sRGhoKACgvL4dMJkNAQAAAgDGG4uJi+Pv7gzGm9L54eHjg1KlTqKmpwfTp0/vd1sWLFzFnzhylWHBwMD744AOlWM/6/vrrr2hra8O0adPAGMP169cxbty4frdTVFQEc3NziMVipVydnZ1hYmKCyspKvPrqq/2ugxBdR00TITpGJBL1OhG8ra0NWVlZOHLkCCQSCRhj/GtPzk3qacKECYiKikJ2djZOnDiBGTNmwMfHBwsXLuQblNraWjDG8PLLL/e6jueeU+9HTXfDJxAIYGNjg0mTJsHQ8Leplw0NDTA0NISdnZ3SmNGjR8PCwoL/ar67uzv8/Pywe/du5OTkwN3dHb6+vnj11VcHbUK3o6Mj7O3tUVhYyDdNBQUFGDlyJD8Pq6mpCTKZDIcOHcKhQ4d6Xc+Tl1F7M3XqVLz77ruQy+W4efMmMjIyIJPJVJrBO3fuIDU1FV9//bXKHKTW1tanbqeurg4tLS0qDVo3qVT61HUQouuoaSJETyQlJeHIkSNYunQpXF1dYW5uDgMDA8TFxSk1UL2Jj49HUFAQzp49i/LyciQnJyMrKwuHDx/G2LFjoVAoYGBggD179ih9jb+biYmJWjn21fD19LSv/hsYGCA1NRXXrl3DuXPncOHCBWzYsAHZ2dk4dOgQTE1N1crlaQICApCZmYmmpiaYmZnh66+/RmBgIN8gKhQKAMDChQtV5j516zkJuy8jR47E3LlzAQB//vOfYW9vj5iYGOTm5vJn3eRyOaKiotDc3Izly5fD3t4eJiYmkEgkiI+P53Ppj0KhwKhRo7B9+/ZeX+9tfhch+oaaJkL0xOnTp/Haa68p3dm6vb2937NMPXV/0+rtt9/GlStXsHjxYuTl5SEuLg52dnZgjGH8+PG9XhocDLa2tlAoFKirq8PkyZP5+IMHDyCTyWBra6u0vKurK1xdXREXF4cTJ05g3bp1KCgo4M8MPelZ78MUEBCA3bt3o7i4GDY2NmhtbUVgYCD/urW1NUxNTaFQKPimZzB4e3vD3d0dmZmZCA8Ph4mJCX744QfU1tZi27ZtSpdZy8vLVcb3tZ92dna4dOkS3NzclC71EUL+D91ygBA90dsZoM8++wxyubzfca2trejq6lKKcRwHQ0ND/qv+L7/8MgQCAXbv3q1y1ooxhocPHw4we8DLywsAsH//fqV4dna20uvNzc0qOTg5OQGAyq0Jeuqeq6VuEzl58mRwHIeCggIUFBRg9OjRmDlzJv+6QCCAn58fTp8+jR9++EFlvDqX5vqyfPlyPHr0CIcPHwYA/hJmz/1mjCE3N1dlbPd+ymQypbi/vz/kcjk++eQTlTFdXV0qyxOij+hMEyF6wtvbG8eOHYOZmRkcHBxw7do1VFRU8F/n78vly5fx4Ycf4pVXXsHEiRMhl8tx7NgxvikAfjtL8e6772LHjh1oaGiAr68vTE1NUV9fjzNnziAsLAzR0dEDyt/R0RFBQUE4dOgQZDIZZs6cierqauTn58PX15efS5Sfn4+8vDz4+vrCzs4Ov/zyCw4fPgwzMzN4enr2uX5nZ2cAwK5duxAQEIBhw4Zh3rx5/V5aDAgIQGpqKoyNjRESEsI3L93Wrl2LyspKhIWFITQ0FA4ODmhubkZNTQ0uXbqE//znPxq9F15eXuA4Djk5OYiIiIC9vT3s7Oywbds2SCQSmJmZ4fTp0702Ot37mZycDA8PDwgEAgQGBsLd3R3h4eHIysrC999/D7FYjGHDhqG2thZFRUXYuHEjXnnlFY3yJURXUNNEiJ7YuHEjDA0NceLECbS3t8PNzQ3Z2dlYvnx5v+OEQiE8PDxw7tw5SCQSjBgxAkKhEHv27IGrqyu/3MqVKzFx4kTk5OTw90waO3YsxGIxfHx8BmUfkpOTMX78eOTn5+PMmTOwsbFBTEwM3nnnHX4Zd3d3VFdXo6CgAA8ePIC5uTlEIhG2b9+OCRMm9LlukUiENWvW4ODBg7hw4QIUCgXOnj371Kbpn//8Jx4/fgx/f3+V121sbPDFF18gPT0dJSUlyMvLg5WVFRwcHAb8twCXLVuG+Ph4nDhxAsHBwcjMzOTnmhkbG2P+/PmIiIhQups48NtZwTfeeAOnTp3C8ePHwRjjLyt++OGHcHFxwcGDB7Fr1y4IBALY2tpi4cKFcHNzG1C+hOgCA/a0GaCEEEIIIYTmNBFCCCGEqIOaJkIIIYQQNVDTRAghhBCiBmqaCCGEEELUQE0TIYQQQogaqGkihBBCCFEDNU2EEEIIIWqgpokQQgghRA3UNBFCCCGEqIGaJkIIIYQQNVDTRAghhBCiBmqaCCGEEELU8P8AK5FwbzUrfEcAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# plot ROC curve\n", "plot_ROC(bundled_data, 'Dosage Sensitive vs Insensitive TFs')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# plot confusion matrix\n", "classes_list = [\"Dosage Sensitive\", \"Dosage Insensitive\"]\n", "plot_confusion_matrix(classes_list, confusion, \"Geneformer\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Weighted Accuracy: 0.7942145185000915\n" ] } ], "source": [ "actual_totals = confusion.sum(axis=1)\n", "\n", "# Compute correct predictions per class (diagonal)\n", "correct_predictions = np.diag(confusion)\n", "\n", "# Compute class-wise accuracies\n", "class_accuracies = correct_predictions / actual_totals\n", "# print(class_accuracies)\n", "\n", "# Compute class weights (based on actual class frequency)\n", "counting_num = confusion.sum(axis=0)\n", "class_weights = counting_num / counting_num.sum()\n", "\n", "# Compute weighted accuracy\n", "weighted_accuracy = np.sum(class_weights * class_accuracies)\n", "\n", "print(f\"Weighted Accuracy: {weighted_accuracy}\")" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.7" }, "vscode": { "interpreter": { "hash": "eba1599a1f7e611c14c87ccff6793920aa63510b01fc0e229d6dd014149b8829" } } }, "nbformat": 4, "nbformat_minor": 4 }