Experiment 1 - MNIST biased training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bea250c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import numpy as np\n",
    "from scipy import stats\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",
    "import random\n",
    "\n",
    "from sklearn.utils import resample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "952c7ca0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class UNet(nn.Module):\n",
    "    def __init__(self, embedding_size=64):\n",
    "        super(UNet, self).__init__()\n",
    "\n",
    "        # Define the encoder part\n",
    "        self.enc_conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1)\n",
    "        self.enc_conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "\n",
    "        # Define the bottleneck part\n",
    "        self.bottleneck_conv = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc = nn.Linear(7*7*64, embedding_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Encoder\n",
    "        x = F.relu(self.enc_conv1(x))\n",
    "        x = self.pool(x)\n",
    "        x = F.relu(self.enc_conv2(x))\n",
    "        x = self.pool(x)\n",
    "\n",
    "        # Bottleneck\n",
    "        x = F.relu(self.bottleneck_conv(x))\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "model = UNet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f6d804c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5,), (0.5,))\n",
    "])\n",
    "\n",
    "train_dataset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
    "test_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bb753efb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_data(train_dataset):\n",
    "    data = {}\n",
    "    for x in range(10):\n",
    "        data[x] = [data for data in train_dataset if data[1] == x]\n",
    "        random.shuffle(data[x])\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e07cc921",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_biased_dataset(data, probs):\n",
    "    '''\n",
    "    probs: [p_0, p_1, ..., p_9]\n",
    "    returns a biased dataset according to probs\n",
    "    '''\n",
    "    max_p = max(probs)\n",
    "    max_x = np.argmax(probs)\n",
    "    max_n = 0.9 * len(data[max_x])\n",
    "    res = []\n",
    "    for x, lis in data.items():\n",
    "        n = int(max_n * probs[x] / max_p)\n",
    "        res += data[x][:n]\n",
    "    random.shuffle(res)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "954e8613",
   "metadata": {},
   "outputs": [],
   "source": [
    "def encode_data(dataset):\n",
    "  model.eval() # UNet\n",
    "  return [(model(image.unsqueeze(0)), label) for image, label in dataset]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d8a3b1d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\tCPU\n"
     ]
    }
   ],
   "source": [
    "# Getting device\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\\t\" + (f\"{torch.cuda.get_device_name(0)}\" if torch.cuda.is_available() else \"CPU\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "eade4560",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BiasedRandomForestClassifier(RandomForestClassifier):\n",
    "    def __init__(self,\n",
    "                 n_estimators=100,\n",
    "                 criterion='gini',\n",
    "                 max_depth=None,\n",
    "                 min_samples_split=2,\n",
    "                 min_samples_leaf=1,\n",
    "                 min_weight_fraction_leaf=0.0,\n",
    "                 max_features='sqrt',\n",
    "                 max_leaf_nodes=None,\n",
    "                 min_impurity_decrease=0.0,\n",
    "                 bootstrap=True,\n",
    "                 oob_score=False,\n",
    "                 n_jobs=None,\n",
    "                 random_state=None,\n",
    "                 verbose=0,\n",
    "                 warm_start=False,\n",
    "                 class_weight=None,\n",
    "                 ccp_alpha=0.0,\n",
    "                 max_samples=None,\n",
    "                n_classes = 10):\n",
    "\n",
    "        super(BiasedRandomForestClassifier, self).__init__(\n",
    "            n_estimators=n_estimators,\n",
    "            criterion=criterion,\n",
    "            max_depth=max_depth,\n",
    "            min_samples_split=min_samples_split,\n",
    "            min_samples_leaf=min_samples_leaf,\n",
    "            min_weight_fraction_leaf=min_weight_fraction_leaf,\n",
    "            max_features=max_features,\n",
    "            max_leaf_nodes=max_leaf_nodes,\n",
    "            min_impurity_decrease=min_impurity_decrease,\n",
    "            bootstrap=bootstrap,\n",
    "            oob_score=oob_score,\n",
    "            n_jobs=n_jobs,\n",
    "            random_state=random_state,\n",
    "            verbose=verbose,\n",
    "            warm_start=warm_start,\n",
    "            class_weight=class_weight,\n",
    "            ccp_alpha=ccp_alpha,\n",
    "            max_samples=max_samples)\n",
    "        \n",
    "        self.n_classes = n_classes\n",
    "        self.thresholds = np.array([1/self.n_classes for _ in range(self.n_classes)])\n",
    "\n",
    "    def fit(self, X, y, sample_weight=None):\n",
    "        return super(BiasedRandomForestClassifier, self).fit(X, y, sample_weight)\n",
    "\n",
    "    def fit_thresholds(self, X, y, alpha = 0.01, batches = 50, sample_weight = None):\n",
    "        X_batches = np.array_split(X, batches)\n",
    "        y_batches = np.array_split(y, batches)\n",
    "        cnt = 0\n",
    "        for X_batch, y_batch in zip(X_batches, y_batches):\n",
    "            cnt += 1\n",
    "            y_pred = self.predict(X_batch)\n",
    "            for y_p, y in zip(y_pred, y_batch):\n",
    "                if y_p != y:\n",
    "                    diff = alpha * self.thresholds[y]\n",
    "                    self.thresholds[y_p] += diff\n",
    "                    self.thresholds[y] -= diff\n",
    "#             print('Batch No: ', cnt, '\\nThresholds: ', self.thresholds)\n",
    "        return self.thresholds\n",
    "\n",
    "    def predict(self, X):\n",
    "        proba = self.predict_proba(X)\n",
    "        return np.argmax(proba - self.thresholds, axis = 1)\n",
    "    \n",
    "    def predict_biased_label_shift(self, X, train_ratios, test_ratios):\n",
    "        proba = self.predict_proba(X)\n",
    "        for i in range(10):\n",
    "            proba[:, i] *= test_ratios[i] / train_ratios[i]\n",
    "        proba /= proba.sum(axis = 1, keepdims = True)\n",
    "        return np.argmax(proba - self.thresholds, axis = 1)\n",
    "    \n",
    "    def predict_biased_online(self, X, y, alpha = 0.01):\n",
    "        res = []\n",
    "        threshold_history = []\n",
    "        for (xi, yi) in zip(X, y):\n",
    "            proba = self.predict_proba([xi])\n",
    "            predicted_class = np.argmax(proba - self.thresholds, axis = 1)[0]\n",
    "            res.append(predicted_class)\n",
    "\n",
    "            threshold_history.append(self.thresholds.copy()) \n",
    "\n",
    "            if predicted_class != yi:\n",
    "                diff = alpha * self.thresholds[yi]\n",
    "                self.thresholds[predicted_class] += diff\n",
    "                self.thresholds[yi] -= diff\n",
    "        return np.array(res), threshold_history\n",
    "    \n",
    "    def predict_biased_online_recall(self, X, y, alpha = 0.1):\n",
    "        res = []\n",
    "\n",
    "        threshold_history = []\n",
    "        for (xi, yi) in zip(X, y):\n",
    "            proba = self.predict_proba([xi])\n",
    "            predicted_class = np.argmax(proba - self.thresholds, axis = 1)[0]\n",
    "            res.append(predicted_class)\n",
    "\n",
    "            threshold_history.append(self.thresholds.copy())\n",
    "\n",
    "            if predicted_class != yi:\n",
    "                new_yi_threshold = (1-alpha)*self.thresholds[yi]\n",
    "                self.thresholds*=((1-new_yi_threshold)/(1-self.thresholds[yi]))\n",
    "                self.thresholds[yi] = new_yi_threshold\n",
    "        return np.array(res), threshold_history\n",
    "    \n",
    "    def predict_biased_online_precision(self, X, y, alpha = 0.1):\n",
    "        res = []\n",
    "\n",
    "        threshold_history = []\n",
    "        for (xi, yi) in zip(X, y):\n",
    "            proba = self.predict_proba([xi])\n",
    "            predicted_class = np.argmax(proba - self.thresholds, axis = 1)[0]\n",
    "            res.append(predicted_class)\n",
    "\n",
    "            threshold_history.append(self.thresholds.copy())\n",
    "\n",
    "            if predicted_class != yi:\n",
    "                new_predicted_class_threshold = self.thresholds[predicted_class]+alpha*self.thresholds[yi]\n",
    "                self.thresholds*=((1-new_predicted_class_threshold)/(1-self.thresholds[predicted_class]))\n",
    "                self.thresholds[predicted_class] = new_predicted_class_threshold\n",
    "        return np.array(res), threshold_history   \n",
    "             \n",
    "    def predict_biased_online_n_dependant(self, X, y, alpha = lambda x: 0.2/np.sqrt(x)):\n",
    "        res = []\n",
    "        threshold_history = []\n",
    "        for (n, xi, yi) in enumerate(X, y):\n",
    "            proba = self.predict_proba([xi])\n",
    "            predicted_class = np.argmax(proba - self.thresholds, axis = 1)[0]\n",
    "            res.append(predicted_class)\n",
    "\n",
    "            threshold_history.append(self.thresholds.copy()) \n",
    "\n",
    "            if predicted_class != yi:\n",
    "                diff = alpha(n) * self.thresholds[yi]\n",
    "                self.thresholds[predicted_class] += diff\n",
    "                self.thresholds[yi] -= diff\n",
    "        return np.array(res), threshold_history\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a24a3a95",
   "metadata": {},
   "outputs": [],
   "source": [
    "# code to draw a graph of majority changes over each iterations\n",
    "\n",
    "def plot_threshold_history(threshold_history):\n",
    "    \"\"\"\n",
    "    Plots the history of threshold values over iterations with distinct colors for each threshold.\n",
    "\n",
    "    Args:\n",
    "    threshold_history (list of list of float): A list where each element \n",
    "                                               is a list of threshold values \n",
    "                                               at a certain iteration.\n",
    "    \"\"\"\n",
    "    # Transpose the threshold_history to get a list for each threshold across all steps\n",
    "    transposed_history = list(zip(*threshold_history))\n",
    "\n",
    "    # Set up the plot\n",
    "    plt.figure(figsize=(10, 6))\n",
    "\n",
    "    # Plot each threshold's history\n",
    "    for i, history in enumerate(transposed_history):\n",
    "        plt.plot(history, label=f'Threshold {i}')\n",
    "\n",
    "    # Labeling the plot\n",
    "    plt.xlabel('Iteration')\n",
    "    plt.ylabel('Threshold Value')\n",
    "    plt.title('Threshold Values Over Iterations')\n",
    "    plt.legend()\n",
    "\n",
    "    # Display the plot\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d89d016f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 64])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "# Get one batch of images from the train loader\n",
    "images, labels = next(iter(train_loader))\n",
    "\n",
    "# Select the first image from this batch\n",
    "# The shape of 'image' will be [1, 1, 28, 28], which is what the model expects\n",
    "image = images[0].unsqueeze(0)\n",
    "\n",
    "# Forward pass to get the embedding\n",
    "embedding = model(image)\n",
    "\n",
    "embedding.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a2df75dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "encoded_train = encode_data([data for data in train_dataset])\n",
    "encoded_test = encode_data([data for data in test_dataset])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "cfb83012",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_biased_dataset(balanced_data, ratios):\n",
    "    biased_datasets = {}\n",
    "    encoded_biased_datasets = {}\n",
    "    data = split_data(balanced_data)\n",
    "    n = 10\n",
    "    for ratio in ratios:\n",
    "        probs = [ratio] + [(1 - ratio)/(n - 1)] * (n -1)\n",
    "        biased_datasets[ratio] = create_biased_dataset(data, probs)\n",
    "        encoded_biased_datasets[ratio] = encode_data(biased_datasets[ratio])\n",
    "        \n",
    "    return encoded_biased_datasets\n",
    "\n",
    "ratios = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n",
    "# encoded_biased_train = make_biased_dataset(train_dataset, ratios)\n",
    "# encoded_test = make_biased_dataset(test_dataset, ratios)\n",
    "encoded_test_single = make_biased_dataset(test_dataset, [0.9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fe43be47",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5915"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# len(encoded_biased_train[0.9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "e9f789d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "972"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(encoded_test_single[0.9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "666361a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def clipped_imbalance_classes(X, y, imb_type='exp', imb_factor=0.01, total_samples=1000):\n",
    "    np.random.seed(42)\n",
    "    unique_classes = np.unique(y)\n",
    "    num_classes = len(unique_classes)\n",
    "\n",
    "    proportions = []\n",
    "    if imb_type == 'exp':\n",
    "        total = sum([imb_factor**(i / (num_classes - 1.0)) for i in range(num_classes)])\n",
    "        proportions = [(imb_factor**(i / (num_classes - 1.0))) / total for i in range(num_classes)]\n",
    "    elif imb_type == 'step':\n",
    "        half = num_classes // 2\n",
    "        total = half + half * imb_factor\n",
    "        proportions = [1/total] * half + [imb_factor/total] * half\n",
    "    else:\n",
    "        proportions = [1/num_classes] * num_classes\n",
    "\n",
    "    img_num_per_cls = [int(p * total_samples) for p in proportions]\n",
    "\n",
    "    # Adjust to ensure the total is exactly total_samples\n",
    "    current_total = sum(img_num_per_cls)\n",
    "    while current_total != total_samples:\n",
    "        for i in range(num_classes):\n",
    "            if current_total < total_samples:\n",
    "                img_num_per_cls[i] += 1\n",
    "                current_total += 1\n",
    "            elif current_total > total_samples:\n",
    "                img_num_per_cls[i] -= 1\n",
    "                current_total -= 1\n",
    "            if current_total == total_samples:\n",
    "                break\n",
    "\n",
    "    X_imb, y_imb = [], []\n",
    "    for cls, img_num in zip(unique_classes, img_num_per_cls):\n",
    "        idx = np.random.choice(np.where(y == cls)[0], img_num, replace=False)\n",
    "        X_imb.append(X[idx])\n",
    "        y_imb.append(y[idx])\n",
    "\n",
    "    X_imb = np.concatenate(X_imb)\n",
    "    y_imb = np.concatenate(y_imb)\n",
    "\n",
    "    return X_imb, y_imb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "354a8fce",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train = zip(*[(x.detach().numpy().flatten(), y) for x, y in encoded_train])\n",
    "X_train = np.array(X_train)\n",
    "y_train = np.array(y_train)\n",
    "\n",
    "\n",
    "X_test, y_test = zip(*[(x.detach().numpy().flatten(), y) for x, y in encoded_test])\n",
    "X_test = np.array(X_test)\n",
    "y_test = np.array(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9b8efd0a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 64)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "fd8a1fcc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10000, 64)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "092deb27",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_encoded_biased_train_exp, y_encoded_biased_train_exp = clipped_imbalance_classes(X_train, y_train, imb_type='exp', imb_factor=0.01, total_samples=5915)\n",
    "X_encoded_test_exp, y_encoded_biased_train_exp = clipped_imbalance_classes(X_test, y_test, imb_type='exp', imb_factor=0.01, total_samples=972)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2e9ddfac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(972, 64)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_encoded_test_exp.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "18189b77",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_models_label_shift(training_dataset, test_datasets):\n",
    "    # Prepare the test data\n",
    "    \n",
    "    accuracies = []\n",
    "    precisions = []\n",
    "    recalls = []\n",
    "    ratios = []\n",
    "    og_accuracies = []\n",
    "    og_precisions = []\n",
    "    og_recalls = []\n",
    "    \n",
    "    X_train, y_train = zip(*[(x.detach().numpy().flatten(), y) for x, y in training_dataset])\n",
    "    X_train = np.array(X_train)\n",
    "    y_train = np.array(y_train)\n",
    "\n",
    "    model = BiasedRandomForestClassifier()\n",
    "    model.fit(X_train, y_train)\n",
    "    og = RandomForestClassifier()\n",
    "    og.fit(X_train, y_train)\n",
    "\n",
    "    for ratio, test_dataset in test_datasets.items():\n",
    "        print('Test Bias Ratio: ', ratio)\n",
    "        #print('Fitted thresholds: ', thresholds)\n",
    "        \n",
    "        X_test, y_test = zip(*[(x.detach().numpy().flatten(), y) for x, y in test_dataset])\n",
    "        X_test = np.array(X_test)\n",
    "        y_test = np.array(y_test)\n",
    "\n",
    "        predictions = model.predict_biased_label_shift(X_test, [0.1] * 10, [ratio] + [(1-ratio)/9]*9)\n",
    "        accuracies.append(accuracy_score(y_test, predictions))\n",
    "        og_accuracies.append(accuracy_score(y_test, og.predict(X_test)))\n",
    "        og_precisions.append(precision_score(y_test, og.predict(X_test), average='macro'))\n",
    "        og_recalls.append(recall_score(y_test, og.predict(X_test), average='macro'))\n",
    "        precisions.append(precision_score(y_test, predictions, average='macro'))\n",
    "        recalls.append(recall_score(y_test, predictions, average='macro'))\n",
    "        ratios.append(ratio)\n",
    "\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_accuracies, label='RF Accuracy', color='blue')\n",
    "    plt.plot(ratios, accuracies, label='Label Shift Accuracy', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_precisions, label='RF Precision', color='blue')\n",
    "    plt.plot(ratios, precisions, label='Label Shift Precision', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_recalls, label='RF Recall', color='blue')\n",
    "    plt.plot(ratios, recalls, label='Label Shift Recall', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "935c40d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Bias Ratio:  0.2\n",
      "Test Bias Ratio:  0.3\n",
      "Test Bias Ratio:  0.4\n",
      "Test Bias Ratio:  0.5\n",
      "Test Bias Ratio:  0.6\n",
      "Test Bias Ratio:  0.7\n",
      "Test Bias Ratio:  0.8\n",
      "Test Bias Ratio:  0.9\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAAIjCAYAAADvBuGTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA9hAAAPYQGoP6dpAACxL0lEQVR4nOzdeZxN9R/H8dedMasxhGEY+9j3In5SZIkaZUu2ZFeUZA/ZS0K2KCRbpGRJKlkiLQjZkn2Xfd+GWe/5/XGay5ihuePeuXdm3s/H4z7m3HPP/X4/937vcD/z3SyGYRiIiIiIiIjIQ/FwdQAiIiIiIiJpgZIrERERERERB1ByJSIiIiIi4gBKrkRERERERBxAyZWIiIiIiIgDKLkSERERERFxACVXIiIiIiIiDqDkSkRERERExAGUXImIiIiIiDiAkisRSXFjxoyhUKFCeHp6Ur58eVeHI07Qtm1bChQokGL1xcTE0LdvX/LmzYuHhwcNGzZMsbqTqkCBArRt2zbeuYMHD1KnTh0yZ86MxWJh6dKlAGzZsoUnnniCjBkzYrFY2LFjR4rHKwkl1oapSWqPXyQ1UHIlIsyePRuLxWK7+fr6UrRoUbp27cq5c+ccWteqVavo27cvVatWZdasWbz//vsOLT+9adu2LRaLhcDAQG7fvp3g8YMHD9ra9cMPP7S7/Fu3bjF06FDWrVvngGidZ+bMmYwZM4YmTZowZ84cevTo4dT6nn76adv76uHhQWBgIMWKFeOVV15h9erVSS6nTZs27Nq1ixEjRjB37lwqVqxIdHQ0L730EpcvX2b8+PHMnTuX/PnzO/HVJF9yPh/Hjh2jXbt2hIaG4uvrS3BwMNWqVWPIkCHOC9RN3f05slgs+Pn5UbZsWSZMmIDVak1WmRs2bGDo0KFcvXrVscGKSJJkcHUAIuI+hg8fTsGCBYmIiOD3339nypQpLF++nL///ht/f3+H1LF27Vo8PDyYMWMG3t7eDikzvcuQIQO3bt3iu+++o2nTpvEe++KLL/D19SUiIiJZZd+6dYthw4YB5hfBpJo+fXqyvxwmx9q1awkJCWH8+PEpVmeePHkYOXIkAOHh4Rw6dIglS5Ywb948mjZtyrx58/Dy8rJdv3//fjw87vxN8/bt22zcuJF33nmHrl272s7v27eP48ePM336dDp27Jhiryc57P18HDp0iMcffxw/Pz/at29PgQIFOHPmDNu2bWPUqFG2stKTuz9HFy9eZP78+fTo0YMLFy4wYsQIu8vbsGEDw4YNo23btmTJkiXeY/d+BkXE8ZRciYjNc889R8WKFQHo2LEj2bJlY9y4cXz77be0aNHiocq+desW/v7+nD9/Hj8/P4clVoZhEBERgZ+fn0PKS418fHyoWrUqX375ZYLkav78+dSrV4/FixenSCzh4eFkzJgxXlKREs6fP5/gi+TDsFqtREVF4evre99rMmfOTKtWreKd++CDD+jWrRuffPIJBQoUYNSoUbbHfHx84l174cIFgARxnz9/PtHzDyOuXVxt/Pjx3Lx5kx07diTojYt73enNvZ+jzp07U7x4cSZNmsTw4cPx9PR0WF33fgZFxPH05wsRua+aNWsCcPToUdu5efPmUaFCBfz8/MiaNSvNmzfnn3/+ife8p59+mtKlS7N161aqVauGv78/AwYMwGKxMGvWLMLDw23DYGbPng2Yc2beffddQkND8fHxoUCBAgwYMIDIyMh4ZRcoUIDnn3+elStXUrFiRfz8/Jg2bRrr1q3DYrHw9ddfM2zYMEJCQsiUKRNNmjTh2rVrREZG0r17d3LkyEFAQADt2rVLUPasWbOoWbMmOXLkwMfHh5IlSzJlypQE70tcDL///juVKlXC19eXQoUK8fnnnye49urVq/To0YMCBQrg4+NDnjx5aN26NRcvXrRdExkZyZAhQyhcuDA+Pj7kzZuXvn37JojvQVq2bMmPP/4YbyjQli1bOHjwIC1btkz0OVevXqV79+7kzZsXHx8fChcuzKhRo2w9TseOHSMoKAiAYcOG2dps6NChgDkkMSAggMOHDxMWFkamTJl4+eWXbY/dO+fKarUyceJEypQpg6+vL0FBQTz77LP8+eeftmtWr17Nk08+SZYsWQgICKBYsWIMGDDgvq/72LFjWCwWfv75Z3bv3m2LMW6YWnh4OL169bK9xmLFivHhhx9iGEa8ciwWC127duWLL76gVKlS+Pj4sGLFiv983+/l6enJRx99RMmSJZk8eTLXrl2zPXb3fJehQ4fakos+ffpgsVhsj1evXh2Al156CYvFEq9HaN++fTRp0oSsWbPi6+tLxYoVWbZsWbwY4ob5/vLLL7z++uvkyJGDPHny2B7/8ccfeeqpp8iYMSOZMmWiXr167N69O14ZcW176tQpGjZsSEBAAEFBQfTu3ZvY2Fjbe/+gz0diDh8+TJ48eRId5pgjR45497/99lvq1atH7ty58fHxITQ0lHfffddWf5y4f2/++usvqlevjr+/P4ULF2bRokUA/PLLL1SuXBk/Pz+KFSvGTz/9FO/5Q4cOxWKxsG/fPpo2bUpgYCDZsmXjrbfeSlKP73/9HtnL19eXxx9/nBs3bsRLOP/66y/atm1LoUKFbMMp27dvz6VLl+K9lj59+gBQsGBBW5scO3YMSHzO1ZEjR3jppZfImjUr/v7+/O9//+OHH35IENekSZMoVaoU/v7+PPLII1SsWJH58+cn6zWKpGXquRKR+zp8+DAA2bJlA2DEiBEMGjSIpk2b0rFjRy5cuMCkSZOoVq0a27dvj/eX9kuXLvHcc8/RvHlzWrVqRc6cOalYsSKffvopmzdv5rPPPgPgiSeeAMyesjlz5tCkSRN69erFpk2bGDlyJHv37uWbb76JF9f+/ftp0aIFr732Gp06daJYsWK2x0aOHImfnx/9+vXj0KFDTJo0CS8vLzw8PLhy5QpDhw7ljz/+YPbs2RQsWJDBgwfbnjtlyhRKlSpF/fr1yZAhA9999x2vv/46VquVN954I14Mhw4dokmTJnTo0IE2bdowc+ZM2rZtS4UKFShVqhQAN2/e5KmnnmLv3r20b9+exx57jIsXL7Js2TJOnjxJ9uzZsVqt1K9fn99//51XX32VEiVKsGvXLsaPH8+BAwdsCxz8l8aNG9O5c2eWLFlC+/btAbPXqnjx4jz22GMJrr916xbVq1fn1KlTvPbaa+TLl48NGzbQv39/zpw5w4QJEwgKCmLKlCl06dKFRo0a0bhxYwDKli1rKycmJoa6devy5JNP8uGHHz5w+GiHDh2YPXs2zz33HB07diQmJobffvuNP/74g4oVK7J7926ef/55ypYty/Dhw/Hx8eHQoUOsX7/+vmUGBQUxd+5cRowYwc2bN23Dq0qUKIFhGNSvX5+ff/6ZDh06UL58eVauXEmfPn04depUgiGEa9eu5euvv6Zr165kz5492QtyeHp60qJFCwYNGsTvv/9OvXr1ElzTuHFjsmTJQo8ePWjRogVhYWEEBASQM2dOQkJCeP/99+nWrRuPP/44OXPmBGD37t1UrVqVkJAQ+vXrR8aMGfn6669p2LAhixcvplGjRvHqeP311wkKCmLw4MGEh4cDMHfuXNq0aUPdunUZNWoUt27dYsqUKTz55JNs37493muOjY2lbt26VK5cmQ8//JCffvqJsWPHEhoaSpcuXZL0+bhX/vz5+emnn1i7dq3tjzf3M3v2bAICAujZsycBAQGsXbuWwYMHc/36dcaMGRPv2itXrvD888/TvHlzXnrpJaZMmULz5s354osv6N69O507d6Zly5a2eXn//PMPmTJlildG06ZNKVCgACNHjuSPP/7go48+4sqVK4n+0SROUn6PkiPujwZ3/5u6evVqjhw5Qrt27QgODmb37t18+umn7N69mz/++AOLxULjxo05cOAAX375JePHjyd79uwAtiT4XufOneOJJ57g1q1bdOvWjWzZsjFnzhzq16/PokWLbJ+p6dOn061bN5o0aWJLOv/66y82bdp03z/eiKRbhoike7NmzTIA46effjIuXLhg/PPPP8ZXX31lZMuWzfDz8zNOnjxpHDt2zPD09DRGjBgR77m7du0yMmTIEO989erVDcCYOnVqgrratGljZMyYMd65HTt2GIDRsWPHeOd79+5tAMbatWtt5/Lnz28AxooVK+Jd+/PPPxuAUbp0aSMqKsp2vkWLFobFYjGee+65eNdXqVLFyJ8/f7xzt27dShBv3bp1jUKFCsU7FxfDr7/+ajt3/vx5w8fHx+jVq5ft3ODBgw3AWLJkSYJyrVarYRiGMXfuXMPDw8P47bff4j0+depUAzDWr1+f4Ll3u/v9bNKkiVGrVi3DMAwjNjbWCA4ONoYNG2YcPXrUAIwxY8bYnvfuu+8aGTNmNA4cOBCvvH79+hmenp7GiRMnDMMwjAsXLhiAMWTIkETrBox+/fol+tjd7+/atWsNwOjWrdt934vx48cbgHHhwoUHvubEVK9e3ShVqlS8c0uXLjUA47333ot3vkmTJobFYjEOHTpkOwcYHh4exu7du5Nd392++eYbAzAmTpxoO5c/f36jTZs2tvuJtYth3PksL1y4MN75WrVqGWXKlDEiIiJs56xWq/HEE08YRYoUsZ2L+31+8sknjZiYGNv5GzduGFmyZDE6deoUr9yzZ88amTNnjnc+rm2HDx8e79pHH33UqFChgu3+gz4fifn7778NPz8/AzDKly9vvPXWW8bSpUuN8PDwBNcm9vv42muvGf7+/vHeg7h/b+bPn287t2/fPlub/vHHH7bzK1euNABj1qxZtnNDhgwxAKN+/frx6nr99dcNwNi5c6ft3L1tmNTfo/upXr26Ubx4cePChQvGhQsXjH379hl9+vQxAKNevXr/+X58+eWXCf4tGjNmjAEYR48eTXD9vfF3797dAOL9+3Pjxg2jYMGCRoECBYzY2FjDMAyjQYMGD/y8i8gdGhYoIja1a9cmKCiIvHnz0rx5cwICAvjmm28ICQlhyZIlWK1WmjZtysWLF2234OBgihQpws8//xyvLB8fH9q1a5ekepcvXw5Az549453v1asXQIIhKgULFqRu3bqJltW6det4830qV66MYRi23py7z//zzz/ExMTYzt09b+vatWtcvHiR6tWrc+TIkXjDuwBKlizJU089ZbsfFBREsWLFOHLkiO3c4sWLKVeuXIIeBTCHoQEsXLiQEiVKULx48Xjva9xf9e99Xx+kZcuWrFu3jrNnz7J27VrOnj17378qL1y4kKeeeopHHnkkXr21a9cmNjaWX3/9Ncn1dunS5T+vWbx4MRaLJdEV4eLei7i/0n/77bcOWQxj+fLleHp60q1bt3jne/XqhWEY/Pjjj/HOV69enZIlSz50vQABAQEA3LhxwyHlXb58mbVr19K0aVNu3Lhha69Lly5Rt25dDh48yKlTp+I9p1OnTvHm66xevZqrV6/SokWLeG3u6elJ5cqVE/2sde7cOd79p556Kt5n3F6lSpVix44dtGrVimPHjjFx4kQaNmxIzpw5mT59erxr7/59jHvNTz31FLdu3WLfvn3xrg0ICKB58+a2+8WKFSNLliyUKFGCypUr287HHSf2Gu7tnX7zzTeBO/8+JcYRv0f79u0jKCiIoKAgihcvzpgxY6hfv75tyHScu9+PiIgILl68yP/+9z8Atm3b9p/1JGb58uVUqlSJJ5980nYuICCAV199lWPHjrFnzx7A/N08efIkW7ZsSVY9IumJhgWKiM3HH39M0aJFyZAhAzlz5qRYsWK2laUOHjyIYRgUKVIk0efeu4BBSEhIkhetOH78OB4eHhQuXDje+eDgYLJkycLx48fjnS9YsOB9y8qXL1+8+5kzZwYgb968Cc5brVauXbtmG/a4fv16hgwZwsaNG7l161a8669du2YrK7F6AB555BGuXLliu3/48GFefPHF+8YK5vu6d+/e+w7bsWeSf9y8pwULFrBjxw4ef/xxChcubJtvcW+9f/3110PXmyFDhnjzee7n8OHD5M6dm6xZs973mmbNmvHZZ5/RsWNH+vXrR61atWjcuDFNmjRJ1gpnx48fJ3fu3AmGf5UoUcL2+N0e9Lmy182bNwES1J1chw4dwjAMBg0axKBBgxK95vz584SEhNju3/t6Dh48CHDf4XiBgYHx7sfNi7vbvZ/x5ChatChz584lNjaWPXv28P333zN69GheffVVChYsSO3atQFzGOTAgQNZu3Yt169fj1fGvX/syJMnjy1Jj5M5c+ZEf++BRF/Dvf+2hYaG4uHhkejvTxxH/B4VKFDAtrrm4cOHGTFiBBcuXEiwmMrly5cZNmwYX331VYJy730/kur48ePxks84d/+OlC5dmrfffpuffvqJSpUqUbhwYerUqUPLli2pWrVqsuoVScuUXImITaVKlWyrBd7LarVisVj48ccfE129Ku4v9XGSs3rfvV+O7udBZd9vZa37nTf+Xdjg8OHD1KpVi+LFizNu3Djy5s2Lt7c3y5cvZ/z48Ql6Uv6rvKSyWq2UKVOGcePGJfr4vV8OH8THx4fGjRszZ84cjhw58sCFBaxWK8888wx9+/ZN9PGiRYsmuU5HLe3s5+fHr7/+ys8//8wPP/zAihUrWLBgATVr1mTVqlUOXTXtfvU7yt9//w2Q4A8GyRX3+evdu/d9e23vreve1xNXxty5cwkODk7w/AwZ4n8lcPb77enpSZkyZShTpgxVqlShRo0afPHFF9SuXZurV69SvXp1AgMDGT58uG1PrG3btvH2228n+ffxYX5Pk/LvkSN+jzJmzGhLKAGqVq3KY489xoABA/joo49s55s2bcqGDRvo06cP5cuXJyAgAKvVyrPPPuv0bQ9KlCjB/v37+f7771mxYgWLFy/mk08+YfDgwely+XyRB1FyJSJJEhoaimEYFCxYMMlfvJMqf/78WK1WDh48aPuLKZiTra9evZoiG6h+9913REZGsmzZsni9UvYMy7tXaGio7Uv2g67ZuXMntWrVSnJy+SAtW7Zk5syZeHh4xBsmlVi9N2/ejPelLjGOiCmuvpUrV3L58uUH9l55eHhQq1YtatWqxbhx43j//fd55513+Pnnn/8z1nvFLZ5w48aNeD1IcUPKnPW5io2NZf78+fj7+8cbbvUwChUqBJg9xPa+D3FCQ0MBc1W+5JZxL0d9PuL+qHPmzBkA1q1bx6VLl1iyZAnVqlWzXXf3yqWOdvDgwXi9fYcOHcJqtT5wYZOk/h7Zo2zZsrRq1Ypp06bRu3dv8uXLx5UrV1izZg3Dhg2LtwhPXG/k3expk/z587N///4E5xP7HcmYMSPNmjWjWbNmREVF0bhxY0aMGEH//v0fuGWBSHqjOVcikiSNGzfG09OTYcOGJfirr2EY8ZYDtldYWBhAgpW14npzElttzdHi/sJ992u7du0as2bNSnaZL774Ijt37kyw2uHd9TRt2pRTp04lmG8C5iazcau8JVWNGjV49913mTx5cqK9E3GaNm3Kxo0bWblyZYLHrl69apuLFrf6391LvCfHiy++iGEYif6VO+69uHz5coLHypcvD2DXsvRxwsLCiI2NZfLkyfHOjx8/HovFwnPPPWd3mf8lNjaWbt26sXfvXrp165ZgqF1y5ciRg6effppp06bZEpC7xe2Z9SB169YlMDCQ999/n+jo6GSVcS97Px+//fZbonXHzWuKW/kzsd/HqKgoPvnkE7tjTKqPP/443v1JkyYBPPBzktTfI3v17duX6Oho27+Bib0fkPDfTMC2n1lS2iQsLIzNmzezceNG27nw8HA+/fRTChQoYJuDeO+/797e3pQsWRLDMBJtT5H0TD1XIpIkoaGhvPfee/Tv359jx47RsGFDMmXKxNGjR/nmm2949dVX6d27d7LKLleuHG3atOHTTz+1DQfavHkzc+bMoWHDhtSoUcPBryahOnXq4O3tzQsvvMBrr73GzZs3mT59Ojly5Ej0y2xS9OnTh0WLFvHSSy/Rvn17KlSowOXLl1m2bBlTp06lXLlyvPLKK3z99dd07tyZn3/+mapVqxIbG8u+ffv4+uuvbft5JZWHhwcDBw5MUmzLli3j+eefty0hHx4ezq5du1i0aBHHjh0je/bs+Pn5UbJkSRYsWEDRokXJmjUrpUuXpnTp0na9FzVq1OCVV17ho48+4uDBg7ahTL/99hs1atSga9euDB8+nF9//ZV69eqRP39+zp8/zyeffEKePHmS1QP0wgsvUKNGDd555x2OHTtGuXLlWLVqFd9++y3du3e39eQk17Vr15g3bx5gLsl96NAhlixZwuHDh2nevDnvvvvuQ5V/r48//pgnn3ySMmXK0KlTJwoVKsS5c+fYuHEjJ0+eZOfOnQ98fmBgIFOmTOGVV17hscceo3nz5gQFBXHixAl++OEHqlatmiAR/S/2fj5GjRrF1q1bady4sW3J9m3btvH555+TNWtWunfvDphbNDzyyCO0adOGbt26YbFYmDt3rt3Dbu1x9OhR6tevz7PPPsvGjRuZN28eLVu2pFy5cvd9TlJ/j+xVsmRJwsLC+Oyzzxg0aBDZsmWjWrVqjB49mujoaEJCQli1alWiPXkVKlQA4J133qF58+Z4eXnxwgsvJLqJdL9+/fjyyy957rnn6NatG1mzZmXOnDkcPXqUxYsX24b81qlTh+DgYKpWrUrOnDnZu3cvkydPpl69eg6bVyiSZqT08oQi4n7ilm7esmXLf167ePFi48knnzQyZsxoZMyY0ShevLjxxhtvGPv377dd86BlqhNbit0wDCM6OtoYNmyYUbBgQcPLy8vImzev0b9//3hLLhuGuZTwvUsUG8b9l6++32uLW3757mW/ly1bZpQtW9bw9fU1ChQoYIwaNcqYOXNmgmWN7xdD9erVjerVq8c7d+nSJaNr165GSEiI4e3tbeTJk8do06aNcfHiRds1UVFRxqhRo4xSpUoZPj4+xiOPPGJUqFDBGDZsmHHt2rWEb+Jd7vd+3u1+S37fuHHD6N+/v1G4cGHD29vbyJ49u/HEE08YH374Ybzl7Dds2GBUqFDB8Pb2jrfs9oPqvncpdsMwjJiYGGPMmDFG8eLFDW9vbyMoKMh47rnnjK1btxqGYRhr1qwxGjRoYOTOndvw9vY2cufObbRo0SLBMteJud9n7saNG0aPHj2M3LlzG15eXkaRIkWMMWPG2JZ/jwMYb7zxxn/Wc3d9gO0WEBBgFClSxGjVqpWxatWqRJ/zsEuxG4ZhHD582GjdurURHBxseHl5GSEhIcbzzz9vLFq0yHbNf/0+//zzz0bdunWNzJkzG76+vkZoaKjRtm1b488//7Rdc7+2jfu9udv9Ph+JWb9+vfHGG28YpUuXNjJnzmx4eXkZ+fLlM9q2bWscPnw4wbX/+9//DD8/PyN37txG3759bUup//zzz7br7tf29/s9vbet417Tnj17jCZNmhiZMmUyHnnkEaNr167G7du3E5R5dxsaRtJ/jxLzoH8r161bF+/9PHnypNGoUSMjS5YsRubMmY2XXnrJOH36dKLv+bvvvmuEhIQYHh4e8f79Siz+w4cPG02aNDGyZMli+Pr6GpUqVTK+//77eNdMmzbNqFatmpEtWzbDx8fHCA0NNfr06fOf/z6JpEcWw3Din4FERERE3NjQoUMZNmwYFy5cSFYvk4jI3TTnSkRERERExAGUXImIiIiIiDiAkisREREREREH0JwrERERERERB1DPlYiIiIiIiAMouRIREREREXEAbSKcCKvVyunTp8mUKRMWi8XV4YiIiIiIiIsYhsGNGzfInTu3bXPt+1FylYjTp0+TN29eV4chIiIiIiJu4p9//iFPnjwPvEbJVSIyZcoEmG9gYGCgS2OJjo5m1apV1KlTBy8vL5fGIia1iftRm7gXtYf7UZu4H7WJe1F7uB93apPr16+TN29eW47wIEquEhE3FDAwMNAtkit/f38CAwNd/sESk9rE/ahN3Ivaw/2oTdyP2sS9qD3cjzu2SVKmC2lBCxEREREREQdQciUiIiIiIuIASq5EREREREQcQHOukskwDGJiYoiNjXVqPdHR0WTIkIGIiAin1yVJ425t4unpSYYMGbRtgIiIiIiLKblKhqioKM6cOcOtW7ecXpdhGAQHB/PPP//oy7ObcMc28ff3J1euXHh7e7s6FBEREZF0S8mVnaxWK0ePHsXT05PcuXPj7e3t1C/YVquVmzdvEhAQ8J+blknKcKc2MQyDqKgoLly4wNGjRylSpIjLYxIRERFJr5Rc2SkqKgqr1UrevHnx9/d3en1Wq5WoqCh8fX31pdlNuFub+Pn54eXlxfHjx21xiYiIiEjKc/03w1TKHb5Ui8TR51FERETE9fSNTERERERExAGUXImIiIiIiDiAkisREREREREHUHKVjrRt2xaLxYLFYsHLy4uCBQvSt29fIiIi4l0Xd83dtyeffPI/y9+4cSOenp7Uq1fPWS9BRERERMRtabXAdObZZ59l1qxZREdHs3XrVtq0aYPFYmHUqFHxrps1axbPPvus7X5S9k+aMWMGb775JjNmzOD06dPkzp3b4fEnVVRUlPZ8EhEREZEUpZ4rBzAMCA9P+Zth2B+rj48PwcHB5M2bl4YNG1K7dm1Wr16d4LosWbIQHBxsu2XNmvWB5d68eZMFCxbQpUsX6tWrx+zZsxNc89133/H444/j6+tL9uzZadSoke2xyMhI3n77bfLmzYuPjw+FCxdmxowZAMyePZssWbLEK2vp0qXx9hcbOnQo5cuX57PPPqNgwYK25chXrFjBk08+SZYsWciWLRvPP/88hw8fjlfWyZMnadGiBVmzZiVjxoxUrFiRTZs2cezYMTw8PPjzzz/jXT9x4kTKlCmD1Wp94HsiIiIiIumLeq4c4NYtCAhwVukeQJZEH7l5EzJmTH7Jf//9Nxs2bCB//vzJL+RfX3/9NcWLF6dYsWK0atWK7t27079/f1sC9MMPP9CoUSPeeecdPv/8c6Kioli+fLnt+a1bt2bjxo189NFHlCtXjqNHj3Lx4kW7Yjh06BCLFy9myZIleHp6AhAeHk7Pnj0pW7YsN2/eZPDgwTRq1IgdO3bg4eHBzZs3qV69OiEhISxbtozg4GC2bduG1WqlQIEC1K5dm1mzZlGxYkVbPbNnz6Zly5Za/lxERERE4lFylc58//33BAQEEBMTQ2RkJB4eHkyePDnBdS1atLAlKADz5s2jYcOG9y13xowZtGrVCjCHHl67do1ffvmFp59+GoARI0bQvHlzhg0bZntOuXLlADhw4ABff/01q1evpnbt2gAUKlTI7tcWFRXF559/TlBQkO3ciy++GO+amTNnEhQUxJ49eyhdujTz58/nwoULbNmyxdY7V7hwYdv1HTt2pHPnzowbNw4fHx+2bdvGrl27mDt3rt3xiYiIiEjapuTKAfz9zV4kZ7BarVy/fp3AwMAEPSX+/vaXV6NGDaZMmUJ4eDjjx48nQ4YMCRIQgPHjx9sSHYBcuXLdt8z9+/ezefNmvvnmGwAyZMhAs2bNmDFjhi252rFjB506dUr0+Tt27MDT05Pq1avb/4Lukj9//niJFcDBgwcZPHgwmzZt4uLFi7ahfCdOnKB06dLs2LGDRx999L7DHhs2bMgbb7zBN998Q/PmzZk9ezY1atQgX758DxWriIiIiNyfx6efkik5c2BcTMmVA1gsDzc870GsVoiNNct3xCi0jBkz2npmZs6cSbly5ZgxYwYdOnSId11wcHC8HpwHmTFjBjExMfEWsDAMAx8fHyZPnkzmzJnx8/O77/Mf9BiAh4cHxj2/XNHR0Qmuy5hII7zwwgvkz5+f6dOnkzt3bqxWK6VLlyYqKipJdXt7e9O6dWtmzZpF48aNmT9/PuPHj3/gc0RERETkIRw8iEe3btQwDGLq1IGiRV0dUZJp0kg65uHhwYABAxg4cCC3b99OVhkxMTF8/vnnjB07lh07dthuO3fuJHfu3Hz55ZcAlC1bljVr1iRaRtziEL/88kuijwcFBXHjxg3Cw8Nt53bs2PGfsV26dIn9+/czcOBAatWqRYkSJbhy5Uq8a8qWLcuOHTu4fPnyfcvp2LEjP/30E5988gkxMTE0btz4P+sWERERkWR6/30sVivnKlSAggVdHY1dlFylcy+99BKenp58/PHHyXr+999/z5UrV+jQoQOlS5eOd3vxxRdtK/4NGTKEL7/8kiFDhrB371527dplW/69QIECtGnThvbt27N06VKOHj3KunXr+PrrrwGoXLky/v7+DBgwgMOHDzN//vxEVyO81yOPPEK2bNn49NNPOXToEGvXrqVnz57xrmnRogXBwcE0bNiQ9evXc+TIERYvXszGjRtt15QoUYL//e9/vP3227Ro0eI/e7tEREREJJmOHIF/57bvb9rUxcHYT8lVOpchQwa6du3K6NGj4/UMJdWMGTOoXbs2mTNnTvDYiy++yJ9//slff/3F008/zcKFC1m2bBnly5enZs2abN682XbtlClTaNKkCa+//jrFixenU6dOtniyZs3KvHnzWL58OWXKlOHLL79k6NCh/xmbh4cHX331FVu3bqV06dL06NGDMWPGxLvG29ubVatWkSNHDsLCwihTpgwffPBBvMU8ADp06EBUVBTt27e3+z0SERERkSQaORJiY7HWrcvVVDQcMI7FuHcyi3D9+nUyZ87MtWvXCAwMjPdYREQER48ejbeXkjM9aEELSTnvvvsuCxcu5K+//nLLNknpz6W7iY6OZvny5YSFheHl5eXqcNI9tYf7UZu4H7WJe1F7uInjx6FwYYiJIebXX/nh8mW3aJMH5Qb3co9vhiJu6ubNm/z9999MnjyZN99809XhiIiIiKRdI0dCTAzUro3xv/+5OppkUXIl8gBdu3alQoUKPP300xoSKCIiIuIs//wDM2eax4MHuzaWh6DkSuQBZs+eTWRkJAsWLEgwD0tEREREHGTUKIiOhho14KmnXB1Nsim5EhERERER1zl1CqZPN49Tca8VKLkSERERERFXGj0aoqLMHqvq1V0dzUNRciUiIiIiIq5x5gx8+ql5PHgwWCyujechKbkSERERERHX+PBDiIiAKlWgVi1XR/PQlFyJiIiIiEjKO38epkwxj4cMSfW9VqDkSkREREREXGHsWLh9GypVgjp1XB2NQyi5EhERERGRlHXxInz8sXmcBuZaxVFylY60bdsWi8WCxWLBy8uLnDlz8swzzzBz5kysVqtdZc2ePdtWlsViISAggAoVKrBkyZIE137//fdUr16dTJky4e/vz+OPP87s2bNtjw8dOjReWYnd/kvx4sXx8fHh7Nmzdr0OEREREXGBceMgPBwqVICwMFdH4zBKrtKZZ599ljNnznDs2DF+/PFHatSowVtvvcXzzz9PTEyMXWUFBgZy5swZzpw5w/bt26lbty5NmzZl//79tmsmTZpEgwYNqFq1Kps2beKvv/6iefPmdO7cmd69ewPQu3dvWzlnzpwhT548DB8+PN65B/n999+5ffs2TZo0Yc6cOfa/KQ4WHR3t6hBERERE3NflyzBpknmchnqtQMmVYxiGmXmn9M0w7A7Vx8eH4OBgQkJCeOyxxxgwYADffvstP/74Y7zepKtXr9KxY0eCgoIIDAykZs2a7Ny5M15ZFouF4OBggoODKVKkCO+99x4eHh789ddfAPzzzz/06tWL7t278/7771OyZEkKFy5Mr169GDNmDGPHjmXTpk0EBATYygkODsbT05NMmTLFO/cgM2bMoGXLlrzyyivMnDkzweMnT56kRYsWZM2alYwZM1KxYkU2bdpke/y7777j8ccfx9fXl+zZs9OoUaN4r3Hp0qXxysuaNSvz588H4NixY1gsFhYsWED16tXx9fXliy++4NKlS7Ro0YKQkBD8/f0pU6YMX375ZbxyrFYro0ePpnDhwvj4+JAvXz5GjBgBQM2aNenatWu86y9cuIC3tzdr1qx54PshIiIi4tYmTICbN6FcOXjhBVdH41BKrhzh1i0ICHDKzSMwkCx58uARGJjw8Vu3HBJ+zZo1KVeuXLwhfS+99BLnz5/nxx9/ZOvWrTz22GPUqlWLy5cvJ1pGbGysrdfoscceA2DRokVER0fbeqju9tprrxEQEJAg4bDXjRs3WLhwIa1ateKZZ57h2rVr/Pbbb7bHb968SfXq1Tl16hTLli1j586d9O3b1zYM8ocffqBRo0aEhYWxfft21qxZQ6VKleyOo1+/frz11lvs3buXunXrEhERQYUKFfjhhx/4+++/efXVV3nllVfYvHmz7Tn9+/fngw8+YNCgQezZs4f58+eTM2dOADp27Mj8+fOJjIy0XT9v3jxCQkKoWbNmct8uEREREde6cgUmTjSP01ivFUAGVwcg7qF48eK2Hqfff/+dzZs3c/78eXx8fAD48MMPWbp0KYsWLeLVV18F4Nq1awQEBABw+/ZtvLy8+PTTTwkNDQXgwIEDZM6cmVy5ciWoz9vbm0KFCnHgwIGHivurr76iSJEilCpVCoDmzZszY8YMnnrqKQDmz5/PhQsX2LJlC1mzZgWgcOHCtuePGDGC5s2bM2zYMNu5cuXK2R1H9+7dady4cbxzdyeVb775JitXruTrr7+mUqVK3Lhxg4kTJzJ58mTatGkDQGhoKE8++SQAjRs3pmvXrnz77bc0bdoUMOe5xc2bExEREUmVPvoIrl+H0qWhYUNXR+NwSq4cwd/f7Np0AqvVyvXr1wkMDMTD456ORn9/h9VjGIbtS/vOnTu5efMm2bJli3fN7du3OXz4sO1+pkyZ2LZtGwC3bt3ip59+onPnzmTLlo0XUqiLd+bMmbRq1cp2v1WrVlSvXp1JkyaRKVMmduzYwaOPPmpLrO61Y8cOOnXq9NBxVKxYMd792NhY3n//fb7++mtOnTpFVFQUkZGR+P/bZnv37iUyMpJa99ksz9fX1zbMsWnTpmzbto2///6bZcuWPXSsIiIiIi5x7Zo5JBBg0CC497ttGqDkyhEsFsiY0TllW60QG2uW78QP4N69eylYsCBgDqXLlSsX69atS3BdlixZbMceHh7xeoHKli3LqlWrGDVqFC+88AJFixbl2rVrnD59mty5c8crJyoqisOHD1OjRo1kx7xnzx7++OMPNm/ezNtvv207Hxsby1dffUWnTp3w8/N7YBn/9bjFYsG4Z25bYgtWZLyn/ceMGcPEiROZMGECZcqUIWPGjHTv3p2oqKgk1Qvm0MDy5ctz8uRJZs2aRc2aNcmfP/9/Pk9ERETELU2eDFevQsmS0KSJq6NxirSXLord1q5dy65du3jxxRcBc87U2bNnyZAhA4ULF453y549+wPL8vT05Pbt2wC8+OKLeHl5MXbs2ATXTZ06lfDwcFq0aJHsuGfMmEG1atXYuXMnO3bssN169uzJjBkzADPh27Fjx33nipUtW/aBC0QEBQXFW63w4MGD3ErCXLf169fToEEDWrVqRbly5RIMgSxSpAh+fn4PrLtMmTJUrFiR6dOnM3/+fNq3b/+f9YqIiIi4pRs3zOXXAQYOTJO9VqCeq3QnMjKSs2fPEhsby7lz51ixYgUjR47k+eefp3Xr1gDUrl2bKlWq0LBhQ0aPHk3RokU5ffq0bfGHuCFwhmHY9pW6ffs2q1evZuXKlQwePBiAfPnyMXr0aHr16mUb5ubl5cW3337LgAED6NWrF5UrV07W64iOjmbu3LkMHz6c0qVLx3usY8eOjBs3jt27d9OiRQvef/99GjZsyMiRI8mVKxfbt28nd+7cVKlShSFDhlCrVi1CQ0Np3rw5MTExLF++3NYTVrNmTSZPnkyVKlWIjY3l7bffxsvL6z/jK1KkCIsWLWLDhg088sgjjBs3jnPnzlGyZEnAHPb39ttv07dvX7y9valatSoXLlxg9+7ddOjQId5r6dq1KxkzZoy3iqGIiIhIqvLxx+YS7EWLwr/zydOitJkyyn2tWLGCXLlyUaBAAZ599ll+/vlnPvroI7799ls8PT0Bcyjc8uXLqVatGu3ataNo0aI0b96c48eP21azA7h+/Tq5cuUiV65clChRgrFjxzJ8+HDeeecd2zXdu3fnm2++4bfffqNixYqULl2a+fPnM2XKFD788MNkv45ly5Zx6dKlRBOOEiVKUKJECWbMmIG3tzerVq0iR44chIWFUaZMGT744APba3366adZuHAhy5Yto3z58tSsWTPein5jx44lb968PPXUU7Rs2ZLevXvb5k09yMCBA3nssceoW7cuTz/9NMHBwTS8Z9LmoEGD6NWrF4MHD6ZEiRI0a9aM8+fPx7umRYsWZMiQgRYtWuDr65uMd0pERETExW7ehLiRTAMHwr/fw9Iii3HvhBLh+vXrZM6cmWvXrhEYGBjvsYiICI4ePUrBggVT5MvuAxe0EJdIyTY5duwYoaGhbNmyxbbEfWJS+nPpbqKjo1m+fDlhYWFJ6lkU51J7uB+1iftRm7gXtYeTffgh9OkDhQvD3r2Q4b8Hz7lTmzwoN7iXhgWKuKHo6GguXbrEwIED+d///vfAxEpERETEbd26BWPGmMfvvJOkxCo1U1eIiBtav349uXLlYsuWLUydOtXV4YiIiIgkz7RpcP48FCwIL7/s6micLm2njiKp1NNPP51gCXgRERGRVOX2bRg92jweMADSwZBL9VyJiIiIiIjjffYZnD0L+fLBv6tSp3VKrpJJvQriTvR5FBEREbcSEQEffGAeDxgA3t6ujSeFKLmyU9xqJUnZSFYkpcR9Hl29mo6IiIgIADNnwunTkCcPtG3r6mhSjOZc2cnT05MsWbLY9iPy9/fHYrE4rT6r1UpUVBQRERFait1NuFObGIbBrVu3OH/+PFmyZLHt3yUiIiLiMpGRMHKkedyvH/j4uDaeFKTkKhmCg4MBEmz46gyGYXD79m38/PycmsRJ0rljm2TJksX2uRQRERFxqTlz4ORJyJ0bOnRwdTQpSslVMlgsFnLlykWOHDmIjo52al3R0dH8+uuvVKtWTUO+3IS7tYmXl5d6rERERMQ9REfD+++bx2+/Db6+ro0nhSm5egienp5O/1Lr6elJTEwMvr6+bvFFXtQmIiIiIvc1dy4cPw45c0KnTq6OJsVpEo+IiIiIiDy86GgYMcI87tsX/PxcG48LKLkSEREREZGHN38+HDkCQUHw2muujsYllFyJiIiIiMjDiYm502vVuzdkzOjaeFxEyZWIiIiIiDycBQvg4EHIlg1ef93V0biMkisREREREUm+2Fh4913zuFcvCAhwbTwupORKRERERESSb+FC2L8fHnkE3njD1dG4lJIrERERERFJHqv1Tq9Vjx4QGOjaeFxMyZWIiIiIiCTPkiWwZw9kzgzdurk6GpdTciUiIiIiIvazWmH4cPO4e3czwUrn3CK5+vjjjylQoAC+vr5UrlyZzZs33/fa6Ohohg8fTmhoKL6+vpQrV44VK1bc9/oPPvgAi8VC9+7dnRC5iIiIiEg69e23sGsXZMoEb73lsGINA5o29WTZskKEhzus2BTh8uRqwYIF9OzZkyFDhrBt2zbKlStH3bp1OX/+fKLXDxw4kGnTpjFp0iT27NlD586dadSoEdu3b09w7ZYtW5g2bRply5Z19ssQEREREUk/DONOr1W3buZiFg7yyy+wdKkH8+aVVHJlr3HjxtGpUyfatWtHyZIlmTp1Kv7+/sycOTPR6+fOncuAAQMICwujUKFCdOnShbCwMMaOHRvvups3b/Lyyy8zffp0HnFgY4uIiIiIpHvffw87dpjLrvfo4dCix4wxf9aseYIcORxatNNlcGXlUVFRbN26lf79+9vOeXh4ULt2bTZu3JjocyIjI/H19Y13zs/Pj99//z3euTfeeIN69epRu3Zt3nvvvQfGERkZSWRkpO3+9evXAXMIYnR0tF2vydHi6nd1HHKH2sT9qE3ci9rD/ahN3I/axL2oPexkGHgOG4YHENulC9bAQHDQe7drFyxf7oXFYtCgwWGio3M6pNyHYc/nwqXJ1cWLF4mNjSVnzvhvWs6cOdm3b1+iz6lbty7jxo2jWrVqhIaGsmbNGpYsWUJsbKztmq+++opt27axZcuWJMUxcuRIhg0bluD8qlWr8Pf3t+MVOc/q1atdHYLcQ23iftQm7kXt4X7UJu5HbeJe1B5Jk+PPP6mydSsxPj6sLl2aqOXLHVb2xImPAvmoUuU0uXKFu0Wb3Lp1K8nXujS5So6JEyfSqVMnihcvjsViITQ0lHbt2tmGEf7zzz+89dZbrF69OkEP1/3079+fnj172u5fv36dvHnzUqdOHQJdvFZ/dHQ0q1ev5plnnsHLy8ulsYhJbeJ+1CbuRe3hftQm7kdt4l7UHnYwDDzffx8AyxtvULtFC4cVffIk/PabmZ6MHJmNK1dwizaJG9WWFC5NrrJnz46npyfnzp2Ld/7cuXMEBwcn+pygoCCWLl1KREQEly5dInfu3PTr149ChQoBsHXrVs6fP89jjz1me05sbCy//vorkydPJjIyEk9Pz3hl+vj44OPjk6AuLy8vlzdmHHeKRUxqE/ejNnEvag/3ozZxP2oT96L2SIJVq2DzZvDzw7NvXzwd+H59/DHExED16lCliifLl7tHm9hTv0sXtPD29qZChQqsWbPGds5qtbJmzRqqVKnywOf6+voSEhJCTEwMixcvpkGDBgDUqlWLXbt2sWPHDtutYsWKvPzyy+zYsSNBYiUiIiIiIklgGBA3laZzZ8jpuPlQV6/Cp5+ax336OKzYFOfyYYE9e/akTZs2VKxYkUqVKjFhwgTCw8Np164dAK1btyYkJISRI0cCsGnTJk6dOkX58uU5deoUQ4cOxWq10rdvXwAyZcpE6dKl49WRMWNGsmXLluC8iIiIiIgk0dq1sGED+Pg4PAOaNg1u3IBSpeC55+Cu5RRSFZcnV82aNePChQsMHjyYs2fPUr58eVasWGFb5OLEiRN4eNzpYIuIiGDgwIEcOXKEgIAAwsLCmDt3LlmyZHHRKxARERERSQfi9rV69VXIlcthxUZGwsSJ5nGfPuDhoeTqoXTt2pWuXbsm+ti6devi3a9evTp79uyxq/x7yxARERERETv88gv8+it4e8O/I8Yc5Ysv4MwZCAkBB66P4RIu30RYRERERETcXFyvVceOkCePw4q1Wu9sGty9u5m7pWZKrkRERERE5P5+/92cb+XlBW+/7dCif/gB9u2DwEBztGFqp+RKRERERETuL67Xql07yJfPoUWPHm3+7NzZTLBSOyVXIiIiIiKSuI0bYfVqyJAB+vd3eNG//252iL31lkOLdhklVyIiIiIikrh33zV/tm4NBQo4tOi4uVatWkHu3A4t2mWUXImIiIiISEJbtsCPP4KnJwwY4NCiDxyApUvN4969HVq0Sym5EhERERGRhOLmWrVqBaGhDi167FgwDHj+eShZ0qFFu5SSKxERERERiW/bNvj+e3NHXwf3Wp07B3PmmMcO3jLL5ZRciYiIiIhIfHFzrVq0gKJFHVr0pEkQGQn/+x88+aRDi3Y5JVciIiIiInLHzp3mhCiLBQYOdGjRN2/CJ5+Yx336mFWkJUquRERERETkjvfeM382awbFizu06Bkz4MoVKFIEGjRwaNFuQcmViIiIiIiY/v4bFi0yjx3caxUdDePGmce9epmLEKY1Sq5ERERERMQU12vVpAmUKuXQor/+Gk6cgBw5zG2z0iIlVyIiIiIiAnv3mhkQwKBBDi3aMO5sGtytG/j5ObR4t6HkSkREREREYMQIMwtq1AjKlnVo0atXm+tkZMwIXbo4tGi3ouRKRERERCS9O3AAvvzSPHZwrxXc6bXq2BGyZnV48W5DyZWIiIiISHo3YgRYrfDCC/Doow4tets2+OkncwGLHj0cWrTbUXIlIiIiIpKeHToEX3xhHg8e7PDi43qtmjWD/PkdXrxbUXIlIiIiIpKejRwJsbEQFgYVKzq06KNHYeFC87hPH4cW7ZaUXImIiIiIpFdHj8Lnn5vHTphrNX68mbc98wyUL+/w4t2OkisRERERkfRq5EiIiYE6deB//3No0ZcuwYwZ5nHfvg4t2m0puRIRERERSY+OH4fZs81jJ8y1+uQTuHXL7LGqVcvhxbslJVciIiIiIunRqFEQHQ01a0LVqg4t+vZtmDTJPO7bFywWhxbvtpRciYiIiIikNydP3hmzN2SIw4ufMwcuXDBXB3zpJYcX77aUXImIiIiIpDejRkFUFFSvDtWqObTo2Fj48EPzuGdPyJDBocW7NSVXIiIiIiLpyenTMH26eeyEuVZLl8Lhw5A1K3To4PDi3ZqSKxERERGR9GTMGIiMNOdZ1ajh0KINA0aPNo9ffx0yZnRo8W5PyZWIiIiISHpx9ixMnWoeDxni8JUmfvsNNm8GHx94802HFp0qKLkSEREREUkvPvwQIiLMPa1q13Z48XG9Vm3bQo4cDi/e7Sm5EhERERFJD86fhylTzOPBgx3ea7V7N/zwg1lsr14OLTrVUHIlIiIiIpIejBtn7upbsSI8+6zDi49bIbBxYyhSxOHFpwpKrkRERERE0rqLF2HyZPPYCXOtTp2CL74wj/v0cWjRqYqSKxERERGRtG7CBAgPh0cfhXr1HF78xIkQHW1umVW5ssOLTzWUXImIiIiIpGWXL8NHH5nHTphrde3anQUI03OvFSi5EhERERFJ2yZOhBs3oGxZqF/f4cVPm2YWX7IkhIU5vPhURcmViIiIiEhadfWqmVwBDBoEHo79+h8Zeaf4Pn0cXnyqk85fvoiIiIhIGjZpkjlur1Qpcxk/B5s/H06fhty5oWVLhxef6ii5EhERERFJi65fh/HjzWMn9FpZrXeWX+/eHby9HVp8qqTkSkREREQkLZo8Ga5cgeLFoUkThxe/fDns2QOZMsGrrzq8+FRJyZWIiIiISFpz4waMHWseDxwInp4Or2L0aPNn586QObPDi0+VlFyJiIiIiKQ1U6aYS7AXLQrNmzu8+D/+gN9+Ay8veOsthxefaim5EhERERFJS8LD70yGeucdp/RajRlj/nz5ZQgJcXjxqZaSKxERERGRtGTqVLhwAQoVcsoSfgcPwjffmMe9ezu8+FRNyZWIiIiISFpx69adbqV33oEMGRxexdixYBhQr565wrvcoeRKRERERCStmD4dzp2DAgXglVccXvy5czB7tnnct6/Di0/1lFyJiIiIiKQFEREwapR5PGCAudqEg02eDJGRUKkSPPWUw4tP9ZRciYiIiIikBZ99BmfOQN680KaNw4u/eRM+/tg87tsXLBaHV5HqKbkSEREREUntIiPhgw/M4/79wdvb4VXMnGnuSVy4MDRs6PDi0wQlVyIiIiIiqd2sWXDqlLkuevv2Di8+JgbGjTOPe/VyyuruaYKSKxERERGR1CwqCkaONI/79QMfH4dXsXAhHD8OQUFOGXGYZii5EhERERFJzebMgRMnIFcu6NjR4cUbBowebR6/+Sb4+Tm8ijRDyZWIiIiISGoVHQ3vv28e9+0Lvr4Or+Knn2DHDvD3h9dfd3jxaYqSKxERERGR1GrePDh2DHLkgFdfdUoVcXsSd+wI2bI5pYo0Q8mViIiIiEhqFBMDI0aYx336mF1LDrZ9O6xebS5g0aOHw4tPc5RciYiIiIikRl9+CYcPQ/bs0KWLU6r48EPzZ9OmUKCAU6pIU5RciYiIiIikNrGx8N575nHv3pAxo8OrOHYMFiwwj/v0cXjxaZKSKxERERGR1GbBAjhwALJmddoqE+PHmzlc7drw6KNOqSLNUXIlIiIiIpKa3N1r1bMnZMrk8CouXYLPPjOP+/Z1ePFplpIrEREREZHUZPFi2LsXsmQxN55ygilT4NYtKF/e7LmSpFFyJSIiIiKSWlitMHy4edyjBwQGOryK27dh0iTzuE8fsFgcXkWapeRKRERERCS1+OYb2L3bTKq6dXNKFZ9/DufPQ7588NJLTqkizVJyJSIiIiKSGtzda/XWW+awQAeLjYWxY83jnj3By8vhVaRpSq5ERERERFKD776Dv/4yF7Do3t0pVXz7LRw8CI88Ah06OKWKNM0tkquPP/6YAgUK4OvrS+XKldm8efN9r42Ojmb48OGEhobi6+tLuXLlWLFiRbxrpkyZQtmyZQkMDCQwMJAqVarw448/OvtliIiIiIg4h2HAsGHm8ZtvmkuwO6GK0aPN49dfh4AAh1eR5rk8uVqwYAE9e/ZkyJAhbNu2jXLlylG3bl3Onz+f6PUDBw5k2rRpTJo0iT179tC5c2caNWrE9u3bbdfkyZOHDz74gK1bt/Lnn39Ss2ZNGjRowO7du1PqZYmIiIiIOM4PP8D27eZmwT16OKWK33+HTZvAx8dpixCmeS5PrsaNG0enTp1o164dJUuWZOrUqfj7+zNz5sxEr587dy4DBgwgLCyMQoUK0aVLF8LCwhgbNzgUeOGFFwgLC6NIkSIULVqUESNGEBAQwB9//JFSL0tERERExDEM485cqzfegOzZnVJNXK9VmzaQM6dTqkjzMriy8qioKLZu3Ur//v1t5zw8PKhduzYbN25M9DmRkZH4+vrGO+fn58fvv/+e6PWxsbEsXLiQ8PBwqlSpct8yIyMjbfevX78OmEMQo6Oj7XpNjhZXv6vjkDvUJu5HbeJe1B7uR23iftQm7sXd28OyciUZtmzB8Pcnpls3cEKce/bA9997YbEYdOsW44wq7OJObWJPDC5Nri5evEhsbCw570mNc+bMyb59+xJ9Tt26dRk3bhzVqlUjNDSUNWvWsGTJEmJjY+Ndt2vXLqpUqUJERAQBAQF88803lCxZMtEyR44cybC4Max3WbVqFf7+/sl8dY61evVqV4cg91CbuB+1iXtRe7gftYn7UZu4F7dsD8PgqX79yAocfuYZdv/5p1OqmTSpPJCfypXPcOjQFg4dcko1dnOHNrl161aSr7UYhmE4MZYHOn36NCEhIWzYsCFer1Lfvn355Zdf2LRpU4LnXLhwgU6dOvHdd99hsVgIDQ2ldu3azJw5k9u3b9uui4qK4sSJE1y7do1Fixbx2Wef8csvvySaYCXWc5U3b14uXrxIoBM2ZrNHdHQ0q1ev5plnnsFLa2G6BbWJ+1GbuBe1h/tRm7gftYl7cef2sPz0ExnCwjB8fYk5cACCgx1ex6lTULRoBqKjLfz2WwyVK7ssPbBxpza5fv062bNn59q1a/+ZG7i05yp79ux4enpy7ty5eOfPnTtH8H0+OEFBQSxdupSIiAguXbpE7ty56devH4UKFYp3nbe3N4ULFwagQoUKbNmyhYkTJzJt2rQEZfr4+ODj45PgvJeXl8sbM447xSImtYn7UZu4F7WH+1GbuB+1iXtxu/YwDBgxAgDLa6/hlTevU6qZMsUcafjUU/Dkky5NDxJwhzaxp36XLmjh7e1NhQoVWLNmje2c1WplzZo1950fFcfX15eQkBBiYmJYvHgxDRo0eOD1Vqs1Xu+UiIiIiIhbW7cO1q83l+/r29cpVVy/DlOnmsd9+jilinTF5alpz549adOmDRUrVqRSpUpMmDCB8PBw2rVrB0Dr1q0JCQlh5MiRAGzatIlTp05Rvnx5Tp06xdChQ7FarfS96wPXv39/nnvuOfLly8eNGzeYP38+69atY+XKlS55jSIiIiIidotbIbBTJ8id2ylVfPqpmWCVKAH16jmlinTF5clVs2bNuHDhAoMHD+bs2bOUL1+eFStW2Ba5OHHiBB4edzrYIiIiGDhwIEeOHCEgIICwsDDmzp1LlixZbNecP3+e1q1bc+bMGTJnzkzZsmVZuXIlzzzzTEq/PBERERER+/36q9lz5e0Nb7/tlCqiomD8ePO4d2/wcPkmTamfy5MrgK5du9K1a9dEH1u3bl28+9WrV2fPnj0PLG/GjBmOCk1EREREJOXF9Vq1bw958jilivnz4fRpyJULXn7ZKVWkO8pPRURERETcyfr1sGYNZMgA/fo5pQqrFT780Dzu3t2c1iUPT8mViIiIiIg7efdd82fbtpA/v1Oq+PFH2L0bMmWC115zShXpkpIrERERERF3sWkTrFwJnp4wYIDTqhkzxvz52muQObPTqkl3lFyJiIiIiLiLuLlWrVtDwYJOqWLzZvjlF3PU4VtvOaWKdEvJlYiIiIiIO/jzT1i+3Fy2LwV6rV5+2WlrZaRbSq5ERERERNxB3Fyrl1+GwoWdUsWhQ7B4sXncu7dTqkjXlFyJiIiIiLja9u2wbJnZa/XOO06rZuxYMAwIC4PSpZ1WTbql5EpERERExNXieq2aN4dixZxSxfnzMHu2edy3r1OqSPeUXImIiIiIuNJff8E334DF4tReq8mTISICHn8cqlVzWjXpmpIrERERERFXeu898+dLL0HJkk6pIjwcPv7YPO7b18zjxPGUXImIiIiIuMru3bBokXk8cKDTqpk5Ey5fhtBQaNTIadWkew+dXMXGxrJjxw6uXLniiHhERERERNKPESPMFSZefBHKlHFKFTExMG6cedyrl7k/sTiH3clV9+7dmTFjBmAmVtWrV+exxx4jb968rFu3ztHxiYiIiIikTfv2wVdfmcdO7LVatAiOHYOgIGjb1mnVCMlIrhYtWkS5cuUA+O677zh69Cj79u2jR48evOPECXgiIiIiImlKXK9VgwZQvrxTqjAMGD3aPO7aFfz8nFKN/Mvu5OrixYsEBwcDsHz5cl566SWKFi1K+/bt2bVrl8MDFBERERFJcw4ehPnzzeNBg5xWzdq15hZa/v7wxhtOq0b+ZXdylTNnTvbs2UNsbCwrVqzgmWeeAeDWrVt4agCniIiIiMh/e/99sFrh+eehQgWnVRPXa9W+PWTL5rRq5F8Z7H1Cu3btaNq0Kbly5cJisVC7dm0ANm3aRPHixR0eoIiIiIhImnL4MMydax47sddqxw5YtQo8PKBnT6dVI3exO7kaOnQopUuX5p9//uGll17Cx8cHAE9PT/r16+fwAEVERERE0pSRIyE2Fp59FipVclo1H35o/mzaFAoWdFo1che7kyuAJk2aJDjXpk2bhw5GRERERCRNO3YM5swxjwcPdlo1x4/fWYiwTx+nVSP3sHvOVbdu3fjoo48SnJ88eTLdu3d3REwiIiIiImnTBx+YG0/Vrg1VqjitmgkTzM6xWrXgscecVo3cw+7kavHixVStWjXB+SeeeIJFcbtLi4iIiIhIfCdOwMyZ5vGQIU6r5soVmD7dPFavVcqyO7m6dOkSmTNnTnA+MDCQixcvOiQoEREREZE0Z9QoiI6GGjXgySedVs2UKRAeDmXLQp06TqtGEmF3clW4cGFWrFiR4PyPP/5IoUKFHBKUiIiIiEiacuoUfPaZeezEuVYRETBxonncty9YLE6rShJh94IWPXv2pGvXrly4cIGaNWsCsGbNGsaOHcuECRMcHZ+IiIiISOo3ejRERcFTT0H16k6r5vPP4fx5yJvXXCVQUpbdyVX79u2JjIxkxIgRvPvuuwAUKFCAKVOm0Lp1a4cHKCIiIiKSqp05A59+ah4PGeK07qTYWBg71jzu2RO8vJxSjTxAspZi79KlC126dOHChQv4+fkREBDg6LhERERERNKGMWPM8XpPPAH/jvxyhmXL4MAByJIFOnZ0WjXyAMlKruIEBQU5Kg4RERERkbTn3DmYOtU8HjzYab1WhmGOPAR4/XVQ34drJCm5euyxx1izZg2PPPIIjz76KJYHfCi2bdvmsOBERERERFK1sWPh9m2oVMmpS/etXw9//AE+PvDmm06rRv5DkpKrBg0a4OPjA0DDhg2dGY+IiIiISNpw4QJ8/LF57MReK7jTa9W6NQQHO60a+Q9JSq6G/LvJWWxsLDVq1KBs2bJkyZLFmXGJiIiIiKRu48bBrVtQoQKEhTmtmr174bvvzNytVy+nVSNJYNc+V56entSpU4crV644Kx4RERERkdTv0iWYPNk8dnKv1Ycfmj8bNIBixZxWjSSB3ZsIly5dmiNHjjgjFhERERGRtGHCBLh5E8qVgxdecFo1p0/DvHnmcd++TqtGksju5Oq9996jd+/efP/995w5c4br16/Hu4mIiIiIpGtXrsBHH5nHTu61+ugjc2/iJ5+EKlWcVo0kkd1LsYf9O160fv368VYNNAwDi8VCbGys46ITEREREUltPvoIrl+HMmXAiYvBXb8OU6aYx336OK0asYPdydXPP//sjDhERERERFK/a9fMIYEAgwaBh90DxZJs+nQzwSpeHJ5/3mnViB3sTq4KFixI3rx5E+x1ZRgG//zzj8MCExERERFJdSZNgqtXoWRJePFFp1UTFQXjx5vHvXs7NYcTO9jdDAULFuTChQsJzl++fJmCBQs6JCgRERERkVTnxg1z+XWAgQOdmvF89RWcOmXuadWqldOqETvZ3eJxc6vudfPmTXx9fR0SlIiIiIhIqvPxx+ZiFsWKQdOmTqvGMGDMGPO4e3fw8XFaVWKnJA8L7NmzJwAWi4VBgwbh7+9veyw2NpZNmzZRvnx5hwcoIiIiIuL2bt68s+HUwIHg6em0qlasgL//hoAAeO01p1UjyZDk5Gr79u2A2XO1a9cuvL29bY95e3tTrlw5evfu7fgIRURERETc3ZQp5sbBhQtD8+ZOrWr0aPPna69BlixOrUrslOTkKm6VwHbt2jFx4kQCAwOdFpSIiIiISKpx69adcXrvvAMZ7F4zLsm2bIF168wq3nrLadVIMtk952rWrFkEBgZy6NAhVq5cye3btwGzR0tEREREJN2ZNg0uXICCBeHll51aVVwO17Il5M3r1KokGexOri5fvkytWrUoWrQoYWFhnDlzBoAOHTrQq1cvhwcoIiIiIuK2bt++M07vnXfAy8tpVR0+DIsXm8eajeOe7E6uunfvjpeXFydOnIi3qEWzZs1YsWKFQ4MTEREREXFr06fD2bOQPz+88opTqxo3DqxWeO45KFPGqVVJMtk9IHTVqlWsXLmSPHnyxDtfpEgRjh8/7rDARERERETcWkQEjBplHvfvD3ct+OZoFy7AzJnmcd++TqtGHpLdPVfh4eHxeqziXL58GR8tsi8iIiIi6cXMmXD6NOTJA23bOrWqyZPNXK5iRahe3alVyUOwO7l66qmn+Pzzz233LRYLVquV0aNHU6NGDYcGJyIiIiLiliIjYeRI87h/f6fu5Bsebu5PDGavlcXitKrkIdk9LHD06NHUqlWLP//8k6ioKPr27cvu3bu5fPky69evd0aMIiIiIiLuZfZsOHkScueG9u2dWtWsWeYWWoUKQePGTq1KHpLdPVelS5fmwIEDPPnkkzRo0IDw8HAaN27M9u3bCQ0NdUaMIiIiIiLuIyoK3n/fPH77bfD1dVpVMTHmQhYAvXqBp6fTqhIHSNYOZ5kzZ+add95xdCwiIiIiIu5v7lw4cQJy5oROnZxa1eLFcPQoZM/u9Gld4gBJTq5OnDiRpOvy5cuX7GBERERERNxadDSMGGEe9+0Lfn5Oq8ow7myh1bUrJLKmnLiZJCdXBQsWtB0bhgGYi1ncfc5isRAbG+vA8ERERERE3MgXX5hdSTlyQOfOTq3q559h2zYzf3vjDadWJQ6S5OTKYrGQJ08e2rZtywsvvECGDMkaUSgiIiIikjrFxNzpterd2+ldSXG9Vu3bm8MCxf0lOUM6efIkc+bMYdasWUydOpVWrVrRoUMHSpQo4cz4RERERETcw1dfwaFDkC0bdOni1Kr++gtWrgQPD+jZ06lViQMlebXA4OBg3n77bfbt28eiRYu4cuUKlStX5n//+x/Tp0/HarU6M04REREREdeJjYX33jOPe/WCgACnVjdmjPnzpZfMJdgldbB7KXaAJ598khkzZnDw4EH8/f3p3LkzV69edXBoIiIiIiJuYuFC2L8fsmY1V5dwohMnzE4ygD59nFqVOFiykqsNGzbQsWNHihYtys2bN/n444/JkiWLg0MTEREREXEDViu8+6553KMHZMrk1OomTDCnd9WsCRUqOLUqcbAkz7k6c+YMn3/+ObNmzeLKlSu8/PLLrF+/ntKlSzszPhERERER11q8GPbsgcyZ4c03nVrVlSvw6afmsXqtUp8kJ1f58uUjJCSENm3aUL9+fby8vLBarfz111/xritbtqzDgxQRERERcYm7e626dzcTLCeaOhXCw6FMGahb16lViRMkObmKjY3lxIkTvPvuu7z372S+uP2u4mifKxERERFJU779FnbtgsBAeOstp1YVEQETJ5rHffvCXVvKSiqR5OTq6NGjzoxDRERERMS9GAYMH24ed+sGjzzi1OrmzYNz5yBvXmjWzKlViZMkObnKnz+/M+MQEREREXEv330HO3aYy6537+7UqqzWO8uv9+gBXl5OrU6cJFmrBYqIiIiIpGl391p17WpuHOxEy5bBgQPmlK6OHZ1alTiRWyRXH3/8MQUKFMDX15fKlSuzefPm+14bHR3N8OHDCQ0NxdfXl3LlyrFixYp414wcOZLHH3+cTJkykSNHDho2bMj+/fud/TJEREREJK348UfYuhX8/aFnT6dXF9dr9frrTl/pXZzI5cnVggUL6NmzJ0OGDGHbtm2UK1eOunXrcv78+USvHzhwINOmTWPSpEns2bOHzp0706hRI7Zv32675pdffuGNN97gjz/+YPXq1URHR1OnTh3Cw8NT6mWJiIiISGplGDBsmHn8xhsQFOTU6tavhw0bwNvb6Su9i5O5PLkaN24cnTp1ol27dpQsWZKpU6fi7+/PzJkzE71+7ty5DBgwgLCwMAoVKkSXLl0ICwtj7NixtmtWrFhB27ZtKVWqFOXKlWP27NmcOHGCrVu3ptTLEhEREZHUatUq2LwZ/PygVy+nVxfXa9W6NeTK5fTqxImSvKDF3WJiYli3bh2HDx+mZcuWZMqUidOnTxMYGEhAQECSy4mKimLr1q3079/fds7Dw4PatWuzcePGRJ8TGRmJr69vvHN+fn78/vvv963n2rVrAGTNmvW+ZUZGRtruX79+HTCHIEZHRyftxThJXP2ujkPuUJu4H7WJe1F7uB+1iftRm7iXeO1hGHgOHYoHEPvqq1izZgUnttO+ffDtt15YLAZvvRXjzKpSFXf6HbEnBotx72ZV/+H48eM8++yznDhxgsjISA4cOEChQoV46623iIyMZOrUqUku6/Tp04SEhLBhwwaqVKliO9+3b19++eUXNm3alOA5LVu2ZOfOnSxdupTQ0FDWrFlDgwYNiI2NjZcgxbFardSvX5+rV6/eNwEbOnQow+K6fu8yf/58/P39k/x6RERERCR1y75zJ1WHDCHWy4vV06YReZ8/zjvK5Mnl+emn/FSqdIYBA+6/7oC4zq1bt2jZsiXXrl0jMDDwgdfa3XP11ltvUbFiRXbu3Em2u1ZNadSoEZ06dbI/WjtNnDiRTp06Ubx4cSwWC6GhobRr1+6+wwjfeOMN/v777wf2bPXv35+ed01UvH79Onnz5qVOnTr/+QY6W3R0NKtXr+aZZ57BS2tyugW1iftRm7gXtYf7UZu4H7WJe7m7PXzjppq8+iq1WrVyar1nzsCvv5pfx8eMCaJKlTCn1peauNPvSNyotqSwO7n67bff2LBhA97e3vHOFyhQgFOnTtlVVvbs2fH09OTcuXPxzp87d47g4OBEnxMUFMTSpUuJiIjg0qVL5M6dm379+lGoUKEE13bt2pXvv/+eX3/9lTx58tw3Dh8fH3x8fBKc9/LycnljxnGnWMSkNnE/ahP3ovZwP2oT96M2cS/eGzbg8dtv4O2NZ//+eDq5baZMgagoeOIJqFYtWbN10jx3+B2xp367F7SwWq3ExsYmOH/y5Eky2blupLe3NxUqVGDNmjXxyl+zZk28YYKJ8fX1JSQkhJiYGBYvXkyDBg1sjxmGQdeuXfnmm29Yu3YtBQsWtCsuEREREUl/PEaMMA86doSQEKfWdeOGmVwB9O3r1KokBdmdXNWpU4cJEybY7lssFm7evMmQIUMIC7O/K7Nnz55Mnz6dOXPmsHfvXrp06UJ4eDjt2rUDoHXr1vEWvNi0aRNLlizhyJEj/Pbbbzz77LNYrVb63vWpfOONN5g3bx7z588nU6ZMnD17lrNnz3L79m274xMRERGRtC/r7t14rFsHXl7w9ttOr2/6dLh2DYoVgxdecHp1kkLs7n8cO3YsdevWpWTJkkRERNCyZUsOHjxI9uzZ+fLLL+0OoFmzZly4cIHBgwdz9uxZypcvz4oVK8iZMycAJ06cwMPjTg4YERHBwIEDOXLkCAEBAYSFhTF37lyyZMliu2bKv38GePrpp+PVNWvWLNq2bWt3jCIiIiKSthX7+mvzoF07yJfPqXVFR8P48eZx797g4fLNkcRR7E6u8uTJw86dO1mwYAE7d+7k5s2bdOjQgZdffhk/P79kBdG1a1e6du2a6GPr1q2Ld7969ers2bPngeXZuQCiiIiIiKRjlj/+IMfOnRgZMmC5a8SUs3z1FZw8CcHB4OQ1MySFJWvmXIYMGXj55Zd5+eWXHR2PiIiIiEjK2LMHPv0UzzlzADBeeQVLgQJOrdIw7mwa3K0b3LN9q6RydidXI0eOJGfOnLRv3z7e+ZkzZ3LhwgXeToExqiIiIiIiyXL7NixeDNOmwb9b9ViAGyEh+A4caP+CBHZauRJ27YKAAOjc2cmVSYqz+/Mzbdo0ihcvnuB8qVKl7NpAWEREREQkxezdCz16mKsAvvKKmVh5ekLDhsR89x1rP/oI8uZ1ehijR5s/X30VHnnE6dVJCrO75+rs2bPkypUrwfmgoCDOnDnjkKBERERERB5aRITZS/Xpp/Drr3fO58sHnTpB+/aQOzdGdDQsX+70cP78E37+GTJkgO7dnV6duIDdyVXevHlZv359gr2j1q9fT+7cuR0WmIiIiIhIsuzbZ651PmcOXLpknvPwMNc8f/VVqFvX7LVKYXFzrVq0SJFOMnEBu5OrTp060b17d6Kjo6lZsyYAa9asoW/fvvTq1cvhAYqIiIiI/KfISFiyxJxL9csvd87nzWtuCtyhg9M3Bn6QI0dg0SLzuHdvl4UhTmZ3ctWnTx8uXbrE66+/TlRUFAC+vr68/fbb8Tb7FRERERFxugMHzGF/s2fH76WqVw9eew2efdYlvVT3GjcOrFYznLJlXR2NOIvdyZXFYmHUqFEMGjSIvXv34ufnR5EiRfDx8XFGfCIiIiIi8UVGwjffmEnVzz/fOZ8nj9lL1b69W427u3gRZs40j/v2dW0s4lzJ2ucKICAggMcff9yRsYiIiIiI3N/Bg+ZcqlmzzIwFzF6q554ze6mee85cLcLNfPyxuQJ8hQrw9NOujkacye5PX3h4OB988AFr1qzh/PnzWK3WeI8fOXLEYcGJiIiISDoXFQVLl5pzqdauvXM+d+47c6ny5XNZeP/l1i2YNMk87tsXLBbXxiPOZXdy1bFjR3755RdeeeUVcuXKhUWfEBERERFxtEOH7vRSXbhgnrNY7vRShYW5ZS/VvWbNMqeCFSwIjRu7OhpxNrs/kT/++CM//PADVatWdUY8IiIiIpJeRUXBt9+ac6l++unO+dy5zR6qDh0gf37XxWenmBhzIQuAXr1SRS4oD8nuJn7kkUfImjWrM2IRERERkfToyBGzl2rmTDh/3jxnsZhL6736Kjz/fKrMTJYsMV9atmzQrp2ro5GUYPen9N1332Xw4MHMmTMHf39/Z8QkIiIiImlddDQsW2bOpVq9+s754GCzh6pjRyhQwGXhPSzDgNGjzeOuXUFfm9MHu5OrsWPHcvjwYXLmzEmBAgXw8vKK9/i2bdscFpyIiIiIpDFHj97ppTp3zjxnsUCdOuZcquefh3u+X6ZG69bB1q3g5wdvvOHqaCSl2J1cNWzY0AlhiIiIiEiaFR0N331nzqVatcrs1gHImfNOL1XBgq6N0cHGjDF/tmsHQUGujUVSjt3J1ZAhQ5wRh4iIiIikNceOwWefmb1UZ87cOf/MM2YvVf36aaKX6l5//QU//mhuwdWzp6ujkZSU+mYGioiIiIj7iomB778351KtXHmnlypHDmjfHjp1gkKFXBujk334ofnzxRchNNS1sUjKsju5io2NZfz48Xz99decOHGCqKioeI9fvnzZYcGJiIiISCpx/LjZSzVjRvxeqtq1zRX/GjQAb2/XxZdC/vkHvvzSPO7Tx7WxSMrzsPcJw4YNY9y4cTRr1oxr167Rs2dPGjdujIeHB0OHDnVCiCIiIiLilmJizH2p6tUz50y9956ZWAUFwdtvw8GD5kqAL72ULhIrgAkTzLelRg14/HFXRyMpze6eqy+++ILp06dTr149hg4dSosWLQgNDaVs2bL88ccfdOvWzRlxioiIiIi7OHHC7KGaMQNOnbpzvlYts5eqYcN0k0zd7epVc80OUK9VemV3cnX27FnKlCkDQEBAANeuXQPg+eefZ9CgQY6NTkRERETcQ0yMuUrDtGnmT6vVPJ89u7kkXqdOUKSIa2N0salT4eZNKF3a3P9Y0h+7k6s8efJw5swZ8uXLR2hoKKtWreKxxx5jy5Yt+Pj4OCNGEREREXGVkyfvzKU6efLO+Ro1zBX/GjYEfQckMhImTjSP+/Qxt+6S9Mfu5KpRo0asWbOGypUr8+abb9KqVStmzJjBiRMn6NGjhzNiFBEREZGUFBsLK1aYvVQ//HCnlypbtju9VEWLujZGNzNvHpw9C3nyQPPmro5GXMXu5OqDDz6wHTdr1ox8+fKxceNGihQpwgsvvODQ4EREREQkBZ06ZfZQffaZuexdnOrVzV6qxo3VS5UIq/XOpsE9eqTL6Wbyr4fe56pKlSpUqVLFEbGIiIiISEqLjTX3o5o2zdyfKq6XKmtWaNvWXKCiWDGXhujuvv8e9u+HzJnNTj1Jv5KVXJ0+fZrff/+d8+fPY437BfyXVgsUERERSQVOn4aZM2H6dHP1vzjVqpkJ1Ysvgq+v6+JLRUaPNn926QKZMrk2FnEtu5Or2bNn89prr+Ht7U22bNmw3DVbz2KxKLkSERERcVexsea+U9OmwXffmfcBHnkE2rQxk6oSJVwbYyqzYQOsX28OBdTXYLE7uRo0aBCDBw+mf//+eHjYvQexiIiIiKS0M2fu9FIdP37n/JNPmnOpmjRRL1Uyxc21euUVyJXLtbGI69mdXN26dYvmzZsrsRIRERFxZ1brnV6qZcvu9FJlyXKnl6pkSZeGmNrt3w/ffmse9+7t2ljEPdidIXXo0IGFCxc6IxYREREReVhnz8L770NoqLmT7TffmIlV1arw+efmXKsJE5RYOcDYsWAYUL8+FC/u6mjEHdjdczVy5Eief/55VqxYQZkyZfDy8or3+Lhx4xwWnIiIiIgkgdUKa9aYvVTffgsxMeb5zJmhdWuzl6p0adfGmMacPQtz5pjHffu6NhZxH8lKrlauXEmxf5fkvHdBCxERERFJIefOwaxZ5lyqI0funK9SxZxL9dJL4O/vuvjSsEmTICrKfKurVnV1NOIu7E6uxo4dy8yZM2nbtq0TwhERERGRB7JaYe1as5dq6dL4vVSvvGL2UpUp49IQ07obN+CTT8xj9VrJ3exOrnx8fKiq9FxEREQkZZ0/D7Nnw6efwuHDd87/739mQtWsmXqpUshnn8HVq1C0qDnfSiSO3QtavPXWW0yaNMkZsYiIiIjI3eJ6qZo1gzx54O23zcQqMBBefx127ICNG6FdOyVWKSQ6GsaPN4979wYtoC13s7vnavPmzaxdu5bvv/+eUqVKJVjQYsmSJQ4LTkRERCRdunDhTi/VoUN3zleqZM6latYMMmZ0WXjp2YIF8M8/kDOnOQpT5G52J1dZsmShcePGzohFREREJP0yDFi3zpxLtWSJ2UUCkCkTtGplDv0rX96VEaZ7hnFn0+Bu3bTvsiRkV3IVExNDjRo1qFOnDsHBwc6KSURERCT9uHjxTi/VwYN3zj/+uJlQNW8OAQEuC0/uWLUK/vrL7DTs0sXV0Yg7siu5ypAhA507d2bv3r3OikdEREQk7TMMsv39N55ffmlu8hsVZZ4PCICXXzaH/j36qGtjlARGjzZ/duoEjzzi2ljEPdk9LLBSpUps376d/PnzOyMeERERkbQlMtLskdq7F/btg717ybBlC0/ePZeqQgUzoWrRQr1UbmrrVnNtEU9P6NHD1dGIu7I7uXr99dfp1asXJ0+epEKFCmS8ZzJl2bJlHRaciIiISKpx/Xq8BMp2O3IEYmPjXWoBYnx9sbRqhWfnzmZyJW4tbq5VixaQL59rYxH3ZXdy1bx5cwC6detmO2exWDAMA4vFQuw9/3iIiIiIpBmGAWfPJkyg9u6F06fv/7zAQChRwrwVL05MkSKsjIqizosv4nnPysvifo4ehYULzePevV0bi7g3u5Oro0ePOiMOEREREfcRGwvHjiVMoPbtM3ePvZ9cuWwJlC2ZKlHCPG+x2C4zoqOJWb7c6S9DHGPcOHPLsbp1oVw5V0cj7szu5EpzrURERCTNiIiAAwcSJlEHDphzpRLj4QGFCiVMoIoXhyxZUjR8cb6LF2HGDPO4Tx/XxiLuz+7kCuDw4cNMmDDBtmpgyZIleeuttwgNDXVocCIiIiIOcfVqwgRq715zvJdhJP4cHx8oVix+AlWiBBQpog2O0pFPPoHbt+Gxx6BmTVdHI+7O7uRq5cqV1K9fn/Lly1O1alUA1q9fT6lSpfjuu+945plnHB6kiIiIyH8yDHPeU2JD+c6evf/zsmRJmECVKAH585tLw0m6desWTJpkHvftG29kp0ii7E6u+vXrR48ePfjggw8SnH/77beVXImIiIhzxcSYK/Ddm0Dt22eu2Hc/ISEJE6jixSFnTn1rlkTNmWMOCyxQAF580dXRSGpgd3K1d+9evv766wTn27dvz4QJExwRk4iIiIjZbbB/f8LlzQ8evLPp7r08PSE0NGECVby4uWKfSBLFxsLYseZxr16QIVmTaSS9sftjEhQUxI4dOyhSpEi88zt27CBHjhwOC0xERETSiUuXEt8f6vjx+8+H8vOLv6BE3HHhwuZcKZGH9M03cPgwZM0K7dq5OhpJLexOrjp16sSrr77KkSNHeOKJJwBzztWoUaPo2bOnwwMUERGRNMAw4OTJxBeVuHDh/s/Lli1hAlWihLmLq4dHysUv6YphwOjR5nHXrpAxo2vjkdTD7uRq0KBBZMqUibFjx9K/f38AcufOzdChQ+NtLCwiIiLpUHS0+ef+xBaVCA+///Py5Ut8f6igoJSLXeRfv/wCW7aYi0J27erqaCQ1SVJytWzZMp577jm8vLywWCz06NGDHj16cOPGDQAyZcrk1CBFRETEzYSHJxzGt3cvHDpkLjiRmAwZzGXM702gihWDgICUjV/kAcaMMX+2a6f8XuyTpOSqUaNGnD17lqCgIDw9PTlz5gw5cuRQUiUiIpLWXbiQeC/UiRP3f07GjAkTqBIlzIUmvLxSLnaRZPj7b1i+3Bx1qhkvYq8kJVdBQUH88ccfvPDCCxiGgUXLlYqIiKQdVquZLN2bQO3day42cT9BQYnvD5Unj5Y2l1Trww/Nn40bm+ujiNgjSclV586dadCgARaLBYvFQnBw8H2vjY2NdVhwIiIi4kBRUXDgQMIEav9+c9nzxFgs5ma6ie0PlS1bysYv4mQnT8IXX5jHffu6NhZJnZKUXA0dOpTmzZtz6NAh6tevz6xZs8iSJYuTQxMREZGHFhuLR//+1PrySzKcO2du3pMYLy8oWjRhAlWsGPj7p2zMIi4yaZIHMTHw9NPw+OOujkZSoySvFli8eHGKFStGmzZtePHFFwnQxFMRERH3N3QonmPHYvtfO1OmhAlUiRJQqJB2SZV07ebNDHz2mbm8f58+Lg5GUi27/hU1DIMvvviCAQMGJNhEWERERNzMsmXw3nsA7OrQgeIDB+KVP7/mQ4kkYtWqAty4YaF0aXjuOVdHI6mVXbvveXh4UKRIES49aHKriIiIuN7Bg/DKKwDEvv46R154AUJClFiJJCIyEr77LhSA3r31ayLJZ/fW5h988AF9+vTh77//dkY8IiIi8rDCw82lzq5fhyeewDp6tKsjEnE7hgEXL8KGDTBkiAdXrvgSEmLQooWrI5PUzO7B1a1bt+bWrVuUK1cOb29v/Pz84j1++fJlhwUnIiIidjIM6NTJ3KwnOBgWLgRvb1dHJeIy4eFmR+6BAwlvV67EXeUJwJtvWvH29nRZrJL62Z1cTZgwwQlhiIiIiENMmgRffgmenvD115A7N0RHuzoqEaeKjoajRxNPoE6devBz8+WDIkWsZMp0mNdfL0BcoiWSHHYnV23atHFoAB9//DFjxozh7NmzlCtXjkmTJlGpUqVEr42OjmbkyJHMmTOHU6dOUaxYMUaNGsWzzz5ru+bXX39lzJgxbN26lTNnzvDNN9/QsGFDh8YsIiLiln7/HXr1Mo8//BCeesq18Yg4kNUKp08nnkAdOXL/XQYAsmc3dxq491a4MPj5QXR0LMuX78HXt0CKvR5Jm5K15urhw4eZNWsWhw8fZuLEieTIkYMff/yRfPnyUapUqSSXs2DBAnr27MnUqVOpXLkyEyZMoG7duuzfv58cOXIkuH7gwIHMmzeP6dOnU7x4cVauXEmjRo3YsGEDjz76KADh4eGUK1eO9u3b07hx4+S8PBERkdTnzBl46SWIiYHmzeGtt1wdkUiyXL6ceAJ18OD997oGczu2xBKoIkUga9aUi1/SN7uTq19++YXnnnuOqlWr8uuvvzJixAhy5MjBzp07mTFjBosWLUpyWePGjaNTp060a9cOgKlTp/LDDz8wc+ZM+vXrl+D6uXPn8s477xAWFgZAly5d+Omnnxg7dizz5s0D4LnnnuM5rZ8pIiLpSXS0mVidPQulS8Nnn2m5M3Frt27BoUOJJ1EPWpQ6QwZzS7bEkqjcufWxF9ezO7nq168f7733Hj179iRTpky28zVr1mTy5MlJLicqKoqtW7fSv39/2zkPDw9q167Nxo0bE31OZGQkvr6+8c75+fnx+++/2/kqEpYbGRlpu3/9+nXAHIYY7eJx6nH1uzoOuUNt4n7UJu5F7ZHyPHr2xHP9eozAQGIWLDAXsLjr/VebuJ/00CYxMXDsGBw8aPn3duf4n38enAXlyWNQpEjcDdtxgQLg5XX/+pIrPbRHauNObWJPDHYnV7t27WL+/PkJzufIkYOLFy8muZyLFy8SGxtLzpw5453PmTMn+/btS/Q5devWZdy4cVSrVo3Q0FDWrFnDkiVLiH3QINskGDlyJMOGDUtwftWqVfj7+z9U2Y6yevVqV4cg91CbuB+1iXtRe6SMkF9+oeK/f9zc3LUrZ81vsIleqzZxP6m9TQwDrlzx5dSpjJw+HfDvzTw+ezYjsbH33/UnICCKkJCb5M59k9y5w//9eZNcucLx9U343e4BH22HSe3tkRa5Q5vcetB41HvYnVxlyZKFM2fOULBgwXjnt2/fTkhIiL3F2WXixIl06tSJ4sWLY7FYCA0NpV27dsycOfOhyu3fvz89e/a03b9+/Tp58+alTp06BAYGPmzYDyU6OprVq1fzzDPP4HW/P9VIilKbuB+1iXtRe6Sgv/4iw9SpAMT268djQ4cmepnaxP2ktja5cgUOHbL8O/fJEq83Kjz8/r1Qfn4GhQtzVy+U8e88KINs2SxApn9vrpXa2iM9cKc2iRvVlhR2J1fNmzfn7bffZuHChVgsFqxWK+vXr6d37960bt06yeVkz54dT09Pzp07F+/8uXPnCA4OTvQ5QUFBLF26lIiICC5dukTu3Lnp168fhQoVsvdlxOPj44OPj0+C815eXi5vzDjuFIuY1CbuR23iXtQeTnb1KjRrBrdvQ506eL73Hp6eD15CWm3iftypTW7fhsOHE58HdeHC/Z/n6QkFCyY+DyokxIKHB0DqmAzlTu0hJndoE3vqtzu5ev/993njjTfImzcvsbGxlCxZktjYWFq2bMnAgQOTXI63tzcVKlRgzZo1tqXSrVYra9asoWvXrg98rq+vLyEhIURHR7N48WKaNm1q78sQERFJvaxWeOUV85tw/vwwf775DVfkP8TGwvHjiSdQJ06Yw/zuJ3fuxBOoggW1T7VIHLuTK29vb6ZPn87gwYPZtWsXN2/e5NFHH6VIkSJ2V96zZ0/atGlDxYoVqVSpEhMmTCA8PNy2emDr1q0JCQlh5MiRAGzatIlTp05Rvnx5Tp06xdChQ7FarfTt29dW5s2bNzl06JDt/tGjR9mxYwdZs2YlX758dscoIiLidkaMgO+/Bx8fWLIEsmVzdUTiRgzDXDgysQTq8OEH7ymdOTMUK5b4cuYBASn3GkRSqyQnV1arlTFjxrBs2TKioqKoVasWQ4YMwc/PL9mVN2vWjAsXLjB48GDOnj1L+fLlWbFihW2RixMnTuDhcWciZEREBAMHDuTIkSMEBAQQFhbG3LlzyZIli+2aP//8kxo1atjux82latOmDbNnz052rCIiIm5hxQoYMsQ8njIFHnvMtfGIy1y7Zi7wcOAA7N8fP4m6efP+z/PxMZOlxHqhsmfXcuYiDyPJydWIESMYOnQotWvXxs/Pj4kTJ3L+/PmHXkyia9eu9x0GuG7dunj3q1evzp49ex5Y3tNPP43xoD5tERGR1OroUWjZ0uyaePVV+Hekh6RdERFmb1NcEnX37Z5p6/F4eECBAoknUHnzgsf9F/ETkYeQ5OTq888/55NPPuG1114D4KeffqJevXp89tln8XqXRERExAlu34bGjc1l2ypVgo8+cnVE4iCxseZ8p8SG8R0//uB5UMHBiSdQhQqZPVQikrKSnFydOHGCsLAw2/3atWtjsVg4ffo0efLkcUpwIiIigvntuksX2LHDHLe1aJG+Oadily/DuHEe/PRTJfr3z8DhwxAVdf/rAwMTT6CKFDEfExH3keTkKiYmBl9f33jnvLy83GLXZBERkTRt2jSYM8ccy7VggTmuS1Kl3buhQQM4fNgTyGU77+0NhQsnnkTlyKF5UCKpRZKTK8MwaNu2bbz9oCIiIujcuTMZM2a0nVuyZIljIxQREUnP/vgDunUzj0eOhJo1XRuPJNu330KrVuZiE/nzGzzzzN80bFiCkiUzkC+fVtMXSQuSnFy1adMmwblWrVo5NBgRERG5y/nz0KSJuXZ248bQp4+rI5JksFrN1fMHDzbvP/00zJ8fw+bNR6hTpzjas1Yk7UhycjVr1ixnxiEiIiJ3i4mBZs3g1CkoXhxmzdLYsFTo5k1o2xYWLzbvd+0K48a5NCQRcSK7NxEWERGRFNC/P6xbZ+7cumSJVi5IhY4eNedX7doFXl7wySfQsaP5mKasi6RNSq5ERETczcKF8OGH5vGsWVCihGvjEbv9/DO89BJcugQ5c5r58RNPuDoqEXE2bVAlIiLiTvbuvbM5cJ8+5pwrSTUMAyZPhmeeMROrihXhzz+VWImkF0quRERE3MX169CoEYSHQ40a8P77ro5I7BAZCZ06wZtvmhsDv/wy/PoraDtQkfRDwwJFRETcgWGYPVb795vfxr/6CjLov+nU4uxZc0HHjRvN7chGjYJevbQGiUh6o3+1RURE3MGYMebEHC8vWLTI3DlWUoUtW8wOx1OnIHNmMy9+9llXRyUirqBhgSIiIq62Zo25OiDARx9B5cqujUeSbN48eOqpOyvmb96sxEokPVNyJSIi4konTkDz5uZOs23bwmuvuToiSYLYWHO9kVdeMedaPf88bNoERYu6OjIRcSUlVyIiIq4SGWmuBnjxIjz6qLkRkibpuL0rV6BevTur5b/zDnz7rbYiExHNuRIREXGdbt3MCTuPPAKLF4Ofn6sjkv+wdy/Urw+HDpnNNXs2NG3q6qhExF0ouRIREXGFmTPh00/Nnqovv4SCBV0dkfyH774zl1e/cQPy5TN7q8qXd3VUIuJONCxQREQkpW3dCq+/bh4PHw5167o2HnkgwzC3HGvQwEysqlUzNwZWYiUi91LPlYiISEq6dAlefNGcb/XCCzBggKsjkgcIDze3H1u40Lz/+uswYYK5Yr6IyL2UXImIiKSU2Fho0QKOH4fCheHzz80dZ8UtHT8ODRvCjh1mMjV5Mrz6qqujEhF3puRKREQkpQweDKtXg7+/uWFwliyujkju45df7izkmCOHud7Ik0+6OioRcXf6c5mIiEhK+PZbc+IOwGefQZkyro1HEmUYMGUK1K5tJlaPPWbOr1JiJSJJoeRKRETE2Q4cgNatzeNu3cyhgeJ2oqKgc2dzXlVMjNlMv/0GefO6OjIRSS00LFBERMSZbt6Exo3h+nWz+yNu51lxK+fOmeuMrF9vro7/wQfQp4/2dBYR+yi5EhERcRbDgI4dYfduCA6Gr7/WMnNuaNs2c+GKf/6BzJlh/nwIC3N1VCKSGmlYoIiIiLNMnAgLFkCGDOZa3rlyuToiuceXX0LVqmZiVawYbNqkxEpEkk/JlYiIiDP8+iv07m0ejx2rFRHcTGws9OsHLVtCRISZUG3aZCZYIiLJpeRKRETE0U6fhqZNzW/wLVvCm2+6OiK5y9Wr5v7No0aZ9/v3h2XLzCGBIiIPQ3OuREREHCkqCl56yVwhoUwZ+PRTrYrgRvbtgwYNzAUc/fxg5kxo3tzVUYlIWqHkSkRExJF69YING8xukCVLIGNGV0ck/1q+3Fxe/fp1c3n1pUvNfaxERBxFwwJFREQcZd48mDz5znHhwq6NRwBz0cZRo+D55++siP/nn0qsRMTxlFyJiIg4ws6d8Oqr5vGgQeY3eXG5W7fMaW/9+plJ1muvwZo1kCOHqyMTkbRIwwJFREQe1pUr5kbBt29D3bowZIirIxLgxAlz/6rt283V8CdNgs6dXR2ViKRlSq5EREQehtUKrVrBkSNQoIC5A62np6ujSvd++w1efBEuXICgIFi0CKpVc3VUIpLWaVigiIjIw3jvPXOlBF9fcwGLrFldHVG6N20a1KxpJlbly8OWLUqsRCRlKLkSERFJrh9/hKFDzeMpU+DRR10aTnoXFQWvv24O/YuJMbca+/13yJ/f1ZGJSHqhYYEiIiLJceSIuVKCYZjf5tu2dXVE6dr58+b2Yr/+am4rNmKEuYiFthgTkZSk5EpERMRet26ZC1hcvQqVK8OECa6OKF3bvt1cuOLECciUyZz2psUaRcQVNCxQRETEHoYBXbqYS6/HrZTg4+PqqNKtBQugalUzsSpSBDZtUmIlIq6j5EpERMQeU6bA55+Dh4f5zT5PHldHlC7FxsKAAdC8ubkC/rPPwubNUKKEqyMTkfRMwwJFRESSauNG6N7dPB41CmrUcGk46dW1a/Dyy/DDD+b9vn3h/fe1Ar6IuJ6SKxERkaQ4dw6aNIHoaPNnr16ujihdOnAAGjSAffvM1e8/+8xMtERE3IGSKxERkf8SEwPNmsHp0+a4s5kztQydC6xYYQ4DvHbNHI35zTdQsaKroxIRuUNzrkRERP5Lv37wyy/mUnRLlpg/JcUYBowZA/XqmYnVE0+YGwMrsRIRd6PkSkRE5EG+/hrGjjWPZ8+G4sVdGk56c/s2tGplzquyWqFjR1i7FoKDXR2ZiEhCGhYoIiJyP7t3Q/v25nHfvubeVpJiTp4096/auhUyZICJE81V8DUiU0TclZIrERGRxFy7ZiZT4eFQsyaMGOHqiNKV9evhxRfNdUSyZ4eFC+Hpp10dlYjIg2lYoIiIyL0MA9q2NZemy5MHvvrK7DqRFPHZZ+Yq9+fOQdmy5vwqJVYikhoouRIREbnXqFGwdCl4e8PixRAU5OqI0oXoaOjaFTp1urPi/YYNUKCAqyMTEUka/RlORETkbj/9BO+8Yx5PmgSVKrk2nnTiwgVo2hTWrTPvv/ceDBig+VUikroouRIREYlz4oS5kZLVai5k0amTqyNKF3buNDcGPn7cXOV+3jyoX9/VUYmI2E/DAkVERAAiIswVFC5dggoV4OOP1W2SAhYtMvetOn4cCheGP/5QYiUiqZeSKxEREYA334Q//4SsWc1v/L6+ro4oTbNaYdAgeOkluHUL6tSBzZuhZElXRyYiknwaFigiIvLZZ+bNYoEvv9QKCk52/Tq88gosW2be79ULPvhACzKKSOqnf8ZERCR9+/NPc4k6MFdRqFPHtfGkcYcOmfOr9uwBHx+YPt1MtERE0gIlVyIikn5dvGjOs4qMNCf69Ovn6ojStFWroFkzuHoVcuc2V7t//HFXRyUi4jiacyUiIulTbCy0aGGuEFikCHz+OXjov0VnMAwYNw6ee85MrKpUMTsMlViJSFqj/0VERCR9GjTI3NPK3x+WLIHMmV0dUZoUEQFt25rzquJWuP/5Z8iVy9WRiYg4noYFiohI+rN0KYwcaR7PmAGlS7s0nLTq1Clo1Ai2bAFPT5gwAd54Qyvci0japeRKRETSlwMHoHVr87h7d3PTYHG4jRuhcWM4exayZYOvv4aaNV0dlYiIc2lYoIiIpB83b5pdKTduQLVqMHq0qyNKk2bNgqefNhOrMmXMnislViKSHii5EhGR9MEwoEMHcw3wXLlgwQLw8nJ1VGlKdDS89ZY5ryoqyuy52rABChZ0dWQiIilDwwJFRCR9GD/eHJuWIQMsWgTBwa6OKE25dAmaNoW1a837w4fDO+9oAUYRSV/c4p+8jz/+mAIFCuDr60vlypXZvHnzfa+Njo5m+PDhhIaG4uvrS7ly5VixYsVDlSkiImncL79A377m8fjx8MQTro0njdm1y1xWfe1aCAiAb74xF2NUYiUi6Y3L/9lbsGABPXv2ZMiQIWzbto1y5cpRt25dzp8/n+j1AwcOZNq0aUyaNIk9e/bQuXNnGjVqxPbt25NdpoiIpGGnTpldKrGx0KqVuVydOMySJea+VUePQqFC5kIWDRu6OioREddweXI1btw4OnXqRLt27ShZsiRTp07F39+fmTNnJnr93LlzGTBgAGFhYRQqVIguXboQFhbG2LFjk12miIikUVFR0KQJnD8PZcvCtGlaB9xBrFYYOhRefBHCw6F2bXPhCq1qLyLpmUvnXEVFRbF161b69+9vO+fh4UHt2rXZuHFjos+JjIzE19c33jk/Pz9+//33hyozMjLSdv/69euAOQQxOjo6eS/OQeLqd3UccofaxP2oTdyLO7WHR/fueP7xB0aWLMTELWDhBnGlNEe3yY0b0K6dJ8uWmX+j7dYtlg8+sJIhQ7p8e5PFnX5PRO3hjtypTeyJwaXJ1cWLF4mNjSVnzpzxzufMmZN9+/Yl+py6desybtw4qlWrRmhoKGvWrGHJkiXExsYmu8yRI0cybNiwBOdXrVqFv79/cl6aw61evdrVIcg91CbuR23iXlzdHnl+/pkKU6YAsKlrV87t3w/797s0JldzRJucOePPyJGVOXEikAwZYunSZSc1a/7DqlUOCDAdcvXvicSn9nA/7tAmt27dSvK1qW61wIkTJ9KpUyeKFy+OxWIhNDSUdu3aPdSQv/79+9OzZ0/b/evXr5M3b17q1KlDYGCgI8JOtujoaFavXs0zzzyDl5YMdgtqE/ejNnEvbtEeO3aQYdo0AGLfeYcKgwe7Jg434ag2WbvWwjvveHL5soVcuQwWLjSoVKkMUMZxwaYTbvF7IjZqD/fjTm0SN6otKVyaXGXPnh1PT0/OnTsX7/y5c+cIvs8SuUFBQSxdupSIiAguXbpE7ty56devH4UKFUp2mT4+Pvj4+CQ47+Xl5fLGjONOsYhJbeJ+1CbuxWXtceUKNGsGERHw3HN4Dh+Op5atA5LfJoYBH30EvXqZ64JUrgxLlljInTvV/Y3W7ejfLfei9nA/7tAm9tTv0v9tvL29qVChAmvWrLGds1qtrFmzhipVqjzwub6+voSEhBATE8PixYtp0KDBQ5cpIiKpnNVqrgh49Ki5c+28eVoP/CFFRJibAnfvbiZWbdrAunWQO7erIxMRcT8u/5NTz549adOmDRUrVqRSpUpMmDCB8PBw2rVrB0Dr1q0JCQlh5MiRAGzatIlTp05Rvnx5Tp06xdChQ7FarfSN278kCWWKiEgaNXw4LF8Ovr7mGuFZs7o6olTt9Glo3Bg2bQJPTxg7Frp104KLIiL34/LkqlmzZly4cIHBgwdz9uxZypcvz4oVK2wLUpw4cQKPu/7qGBERwcCBAzly5AgBAQGEhYUxd+5csmTJkuQyRUQkDfrhB4hbnGjaNChf3qXhpHabNkGjRnDmDDzyCHz9tbncuoiI3J/LkyuArl270rVr10QfW7duXbz71atXZ8+ePQ9VpoiIpDGHD5vDAQFefx1at3ZtPKncnDnw6qvmNmGlSsG330JoqKujEhFxfxqILiIiqdutW+ZOtlevwv/+B+PHuzqiVCsmBnr2hLZtzcSqYUPYuFGJlYhIUim5EhGR1Msw4LXXYOdOyJEDFi0Cb29XR5UqXb4Mzz13JzcdMgQWL4ZMmVwbl4hIauIWwwJFRESS5ZNPzBUBPT3NSUEhIa6OKFXavRvq14cjRyBjRvj8c3MhCxERsY96rtzcyZNw4oT+bCgiksCGDeb64ACjR0P16i4NJ7VautQcTXnkiLl6/caNSqxERJJLyZWb+/BDD7p1q0n9+p6sXWuOgBERSffOnoUmTcxJQk2bQo8ero4o1bFazZXrGzWCmzehZk3YsgXKlHF1ZCIiqZeSKzd3/boFi8VgxQoPatWCChXgiy8gOtrVkYmIuEh0NDRrZq4RXrIkzJihjZfsdPOmmZMOGWLe79YNVqyAbNlcG5eISGqnOVdububMWKpWXcdff9VkzhxPtm83Vxvu188cDdOpEwQGujrKNMZqhfBwuHbNvF2/Hu/Y4/JlChw5giUgwNxHR99GRFLW22/Dr7+aKy0sWQIBAa6OKFU5ehQaNIBdu8y1P6ZMgfbtXR2ViEjaoOQqFciV6xYdOlh5911Ppk6FSZPMuVi9e5tDOl591fyrY968ro7UDURFJUiGknx8988HjL/0BMoBfPqpeSJXLihdOv6tZEl94RNxhq++urOc3Zw5UKyYa+NJZX7+2ULLlnDpEgQHm7lplSqujkpEJO1QcpWKZMsG77wDvXqZQwM//BD27TN/TpgAzZubj5Uv7+pIk8EwzHEqD0p6knIcEeG4mDJkgMyZzVtgoO3YGhDA+QMHyHnxIpZjx8yhSWfOwOrV8Z9fsGDCpKtYMfDxcVyMIunJ7t3QoYN53K+fOVlIksQw4PvvCzJrliexsfD44/DNN1pcUUTE0ZRcpUK+vub3i3bt4McfzeRq3TpzNeJ586B2bbNXq06dFJqGEB2d/N6iuOPr183heI6SMWOiidF/Ht99ztc30TcwNjqaTcuXExYWhldEBOzZA3//Hf929qw59uboUfjuuztP9vSEokUTJl2hoeZjIpK4a9fMZOrWLfMfuffec3VEqcaZM9CnjydffFEWgFdeMTvefX1dHJiISBqk5CoV8/CAevXM259/wtixsHAh/PSTeStd2uzJatHiPp0lhmHOLXrYxOj2bce9KE/PO8mNvclQ3HGmTGavU0rIlAkqVzZvd7t40fwr+90J165d5nu2d695W7jwzvW+vlCiRMKkK29eTdQXsVqhTRs4eBDy5YMvv9QfI5Lg0iUYNQomT4bbtz3w8DAYNcpKr16e+mdFRMRJlFylVjEx8RKdiuHX+LLldT6qdI1fvrvG3+uv4/v3NW61u84PXa5RNv818me9jlf4Pb1FsbGOiyljxuQlQ3cf+/mljWQie3Zzz527990xDDh9OmEv1+7dZoK6fbt5u1tgIJQqdSfZKlPG/BkUlLKvR8SVRo2Cb781V19YtMj8/ZL7un7dnJY2dizcuGGeq1LFSv3663nrrf9hsSgxFRFxFiVXbs7jgw+osngxniNGxJ+DdOtWotcHAU3+vdlEAPsfUElcb1FykqG448DAlOstSq0sFnOCQ0gI1K1753xsLBw7ZvZs3Z107d9vtvXGjebtbjlyJOzlKlVKS0dK2rN6NQwcaB5//LE5WUgSdfs2fPIJjBxp9lqBOQd3xAioXTuWH3+87NL4RETSA30bdnOWXbvIsXPn/S/w939gMhQbkJlthzPz/a+B7D6VmWtk5qYlkCrPZqZNt8yUeyrQLCMt9BalVp6e5pyr0FBo2PDO+agoOHAgYU/XkSNw/jysXWve7pYvX8Kkq3hxs0dQJLU5ftwc12y1QseO5k0SiIoyt/p67z2zcxzMtXOGDzf3Wfbw0N6IIiIpRcmVm7O++v/27jw+xnPtA/hvMlkNWRTZRMSaWoIimlC0TY/z6nF4q7W1SrWcFq2lKCWovYrS2sopVaW6oD1tHbRa+kYVJ/Yglc2eWCuRSGS53z8u2SeOSSbzTGZ+38/n/sjc82RyPe7MZK657/t6huGwvz9ade4Mx4ceKp481agBODnd9/v1ANoDaKfkA+AFC4DffwR+/zfw/r9l1dq4cUD37vIHmKyIs3NhglRUerrs2SqZdF28CJw7J23btsLjHRyARo1KJ12NG3O2kaxXZibQu7dMwbRrJ9egoGJyc4GNG+VCwImJ0hcYKLcHDuTTm4hIC3zptXKqSxdcSE9HSPfu/zWRuh+dTqoH/uUvwNGjshb/88+BPXukBQcDY8fKH2RWkLJyBoO82WzXrnj/zZvGi2jcuCEzYH/8IRe1yefsLANfMukKDGSmTdobORKIjpZrUHz9NV+YilBKyqhHRkqxUgDw9pbVk0OH8moPRERaYnJlh1q1Aj79FJgzB/jgA+Cjj+R6WcOGyR/nkSOB117jnvEqx8sL6NRJWj6lgJSU0rNcJ07IDNixY9KKMhiMF9Hw9ubyUbKM1atlnZuDg1w0ODBQ64isglLAzp1yvcPoaOnz8gLeektetw0GbeMjIiImV3atbl1g/nxJqD7+WKpLnT8PTJ0qG6JfegkYM0ZWlFEVpdMBPj7SIiIK+/PyZPlgyYTr1ClJug4ckFbUQw8ZL6Lh5WXZcyLbduCAZApAfiUGbeOxElFRklT9+qvcNhhktcHYsYCnp6ahERFREUyuCO7ukkSNHCmrbxYsAA4dkqpTK1bIdTvHjQPCwrSOlMzGwQGoX1/a3/5W2J+TA8TFlU66zpyRvS/560iL8vcvnXQ9/DA/RifTXb0qFRju3pXiLm+9pXVEmjt0SD4A+/e/5baLCzB8ODBxohQNJSIi68Lkigo4OUlhrn79gN27Jcnatk226WzZAoSHy0WJe/bk9TttlqOj7MMKDpY3ufnu3JG1oyWTrnPnpJDGxYvAjh2Fx+t0QIMGpZOuJk1krxdRSTk58gJ0/rz8nqxbZ9fLUE+dklUEX38ttx0dgSFDZJ9V3braxkZERGVjckWl6HTA449Li4kBFi0CPvsM+O03aQ0bylKUwYOlijvZATc3oE0baUXduiU76ksmXVeuAPHx0r79tvB4R0epEV0y6QoKYsZu76ZMAXbtkhnPLVvs9pptiYnAO+8A69fL6l2dDhgwAJg+nUu0iYiqAiZXdF/Nm8t+rNmzgaVLZalgfDwwYoR8qjp8uHzt7a11pKQJDw9ZL1pyzeiVK6UrF544IRdFjomR9sUXhce7uQHNmhUWz8hvfn52PXthN7ZsAd59V75es0ZeeOzM5cvyOrtqVeE1qXr1AmbOLH01BiIisl5MruiB+PjIBSonTQLWrpXZrMRE+cM/fz7w4osymxUcrHWkZBXq1JH2+OOFfUoBFy6UTrhOnpRlh9HRhSXQ8nl6lp7latFCimuQbTh9WqbBAXkR6dNH03As7fp1eQ398EN5GgDAU0/J621oqLaxERGR6ZhckUkMhsJS7Vu3Au+9J8W9Vq+W1qOHFL947DFOOFAJOh0QECDtf/6nsD83F0hIKJ10xcYCf/4pZdKiooo/lo9PsWRLFxwMp9RUSeCo6khLA555Rv7t0qVw9soOpKVJhdaFC2VCF5B9rbNnA127ahoaERFVAJMrKhe9Xuod9O4N7N0rxS/+9S/gu++ktW8vxS9695ZtNkRl0uuBxo2l/e//FvZnZcmFj0smXQkJQHKytJ9+AiAvZN0BqBEjpAJiUFDpf4OC7HYfj1VSCnj5Zanc4Ocny0Tt4MXizh1ZXj1vHnDtmvS1aiVJVffu/FCKiKiqs/2/ZFSpdLrC69bGxsonsevWAQcPStXBwEAp8/7yy0D16lpHS1WKi4vswWrZsnj/7dvyhrxIwqVOnIDu0iXo0tKA48elGePlVXbiFRjI8vGWtGgR8NVXUqb0669tfuNmdrbsX505E7h0SfqaNJHbzz4rV0cgIqKqj8kVmU3TpsDKlfJmYflyKYBx9iwwerRUunr1VeD11+VDaqJyq15dpkbbty/oysnOxvatW/HXZs3gdOECkJQkmwITEwu/vnYNuHlT2qFDxh+7Tp2yZ74CAyXho4rbvbvwGlaLF9v0RfRyc4GNG+U1MCFB+urVk9sDB9rFZB0RkV3hyzqZXe3awLRpwIQJwKefyp6CM2dkGczChcDzz8uSQVbAInPKc3EpLPNuzO3bkmgZS7ySkmR/15Ur0g4cMP4Yfn5lz3zVrSuzMHR/Fy5I0YrcXKmE89prWkdUKZSSfamRkVKzBZDJuSlTgKFDmacTEdkqJldUadzcgH/8Q95IfPed7MuKigI++UTaX/8qSdaTT3KfAVlA9eqFRTCM+fPPshOvxEQgPV3Wc126JBsNS3JwkGIdxhKv+vUlMbP3a3llZckauKtXZaPRihU29+RXCvjxR2DyZOA//5E+Ly/5sOn117nylIjI1jG5okrn4AD07Cnt999l9mrLFmD7dmmtWkmFwb59+cE/acjTE2jdWlpJSknN7LISr6QkSRzOnpW2Z0/px3BykvVgxhKvoCCZ1rCxRKOUMWOA/fsl29iyxeauQh4VJUnVr7/KbYNBTvnNN+XXi4iIbB+TK7KoRx+VPewJCbLV4uOPgaNHZe/BpEnAqFEy0+XhoXWkREXodECtWtKK7PUqkJcHpKSUnXidPSsVDeLjpRnj6iqJVlkzXw89VLWTr3XrCmeqNmwAGjTQOiKzOXxYlvtt2ya3XVzkAusTJ8o2PiIish9MrkgTDRoAH3wgm7pXrpSvL1wAxo8HZswAhg2TRCsgQOtIiR6AgwPg6ystPLz0/bm5wMWLxhOvxET55c/MlAvqnj5t/GdUr1524hUUZN2fSBw+LBVtANmQWfQ6Z1XY6dPA1KnygREgqz5ffln2WdWtq21sRESkDSZXpKmaNYG33wbGjpWKWgsWSJXthQuBJUtkqeCbbwJt2mgdKVEF6PWyJLBePaBz59L3Z2cD58+XPfN16ZIU5MgvP2+Mp2fZiVf9+tpt9rlxQy54l5kJPP20ZB5VXFIS8M47UrAnL08m4/r3l75GjbSOjoiItMTkiqyCqyswZAgweLDsw1qwAPjlF1k9tGGDFL14800pglGVV0YRGeXkJNO5ZS2Vy8yUpYVlzXxdvSoFOQ4flmZM7dplz3wFBsqT0Nxyc6U8aGKinNv69VX6gk6XL8vFfletknwYAHr1ktn2kpdjIyIi+8TkiqyKgwPQvbu06GiZwfryS2DXLmnNm0uSNWAASxmTHXF1lTLzTZsav//2bUm+jCVeiYmSeF29Ku3gQeOP4etb9sxXQEC5qs04zJoln5a4uUkBCy8vkx/DGly/DsyfD3z4IXDnjvRFREiiFRqqbWxERGRdmFyR1WrbVpYKzpsnSwRXrQJiYmSG6+23gTfekG0cVfT9GpH5VK8unzw0b278/vwy88YSr/wy85cvS/vtt9Lf7+Agm4jKWnLo71+qzLz3wYPQz54tN1atkrKgVUxamhTeWbAASE2VvrAwSaoef1zT0IiIyEoxuSKrV6+ezGBFRgKrV0uidfGiJFizZ8sG8tGj5X0eERnxIGXmjSVe+QlZZiZw7py0/DrjRTk6Fisz7+Dvj7bvvy/3jRwJvPBCJZ1Y5bhzRwobzp0LXLsmfa1ayetN9+5cmkxERGVjckVVhqenVBMcNQr44gv5NPnYMak0uHSpXJt03DjjlbKJqAxFy8y3a1f6/rw84MoV44lXYqIkXNnZcn2FhAQAgP5eywsLg8PChRY8mYrJzgbWrJE9VJcuSV+TJnL7ueeq9HYxIiKyECZXVOU4O8t1sV54AfjpJ0mydu6UvVlffinF2MaNk8JkfDNEVEEODoCPj7SwsNL35+ZKJlIk8cpLSMDFpCT4rF8PB2dni4dsqtxc4PPPpUr8vfwQ9erJ7RdflIk5IiKiB8E/GVRl6XTAU09JO3ZMlg5+/rmsWvr1V9n7P3asJGJublpHS2Sj9HopeBEQADz2GAAgNzsbh7ZtQ3dfX42Duz+lgG++kSXHMTHSV6eOXBB42DAWzSEiItPxc32yCSEhwLp18sH5W2/J9VRjY4F//EOqTM+YUbh3gojsm1Iy292hA/DMM5JYeXrKHquEBOD115lYERFR+TC5Ipvi7y/VBc+fB95/X5b2XL0qy3vq1QOGDwfOnNE6SiLSyt69UumvWzepSm8wyExVYiIwcaJ211omIiLbwOSKbFKNGlJBMD5elgo+8khhBbCmTeXTamMVp4nINh0+LPswO3UC9uyRmanRo2WmauZMmbkiIiKqKCZXZNMcHYF+/YD//Af45Rd5c6UUsHUr0LGj7M/fvFk2tBOR7Tl9GujTRz5g2bZNtogNHSoz2O+/L3usiIiIzIXJFdkFnQ7o2hX4/nvg5EnglVek6uDvv0sJ96ZNgWXL5FqqRFT1nT0rFxxv3hz46it5DRgwADh1Sq5pHBCgdYRERGSLmFyR3Xn4YbkY8dmzsteiZk1ZPjhypOzLiowEUlK0jpKIyiM5WQpSNG4MrF0rl+nq2RM4ehTYsEH6iYiIKguTK7JbPj6y1+LcObkIcYMGwI0bwKxZUmFw6FD5lJuIrN+NG1KQokEDeT5nZwMRETI7/c03QMuWWkdIRET2gMkV2T2DARgxAvjjD+Drr6U8c1YW8M9/As2aAT16yAZ4pbSOlIhKSkuTD0mCgoB335XCNWFhwM8/Az/+KM9nIiIiS2FyRXSPXg/07g3s2wdERQG9esk+je+/l/1aoaHAF18AOTlaR0pEd+4AixbJTNXUqUBqqlzv7rvvCsutExERWZqj1gEQWRudTioJduxYWFFs7VqpONivHxAY6IiwsKbIy9OhbVvZGK/TaR01kX3IzgbWrJHZqosXpa9xY7n93HOAAz8yJCIiDTG5IrqPxo2B5cuBd96Ra2QtXQqcPavD2bPB2LRJjvHwkE/MW7WSf0NCgBYteDFSInPKzQU2bZILgsfHS19AADB9OvDii3LZBSIiIq3xzxHRA6hdW5YejR8PrF+fg40bL+PGjbo4dUqHW7eA//s/afl0OqBRo+JJV6tWUiiDs1xED04p4NtvpbJnTIz01akjt4cNk4sBExERWQsmV0QmcHMDXnpJwdv7ELp394FSTjh9Wso8Hzsm7ehRKeV+5oy0zZsLv9/dXaqWFZ3latkSqF5du3MiskZKAT/9BEyeDBw8KH2ensCECcAbb3BmmIiIrBOTK6IKcHYuTJKKSkkBjh8vTLqOHpWLF6emymb7vXuLH9+wYelZrvr1uX+E7NPevZJU7dkjtw0GYPRoYNw4SbCIiIisFZMrokrg7S0tIqKwLzsbiI0tPct1+bLsIYmPB7ZuLTy+enXjs1zu7pY/HyJLOHJElvv98IPcdnYGhg8HJk2SpYBERETWjskVkYU4OUmhixYtgOefL+y/erX0LFdMDHD7tpSF37ev+OMEBZWe5WrQgLNcVHXFxsqexi+/lNt6PTBkCBAZKUUriIiIqgomV0Qaq10beOIJaflycuSixiVnuS5eBBITpX37beHxBoMkbUVnuUJCpJIhkbU6e1Yqca5bB+TlSbGXfv2kr3FjraMjIiIyHZMrIivk6Ag0ayatf//C/uvXi89yHTsGnDgBpKcD+/dLKyowsHSZ+EaNZGaASCvJycDs2cBHH8lyWQD4+9/lWlUl9y8SERFVJUyuiKqQhx4CunaVli8nB4iLK5zdyv/3/HmZGTh7Fvjuu8Lj3dyMz3J5eVn6bMje3LgBvPcesGQJcOeO9D35pCRaHTpoGxsREZE5MLkiquIcHYHgYGl9+hT237xZepbr+HF5U3vwYGF563wBAaVnuRo35sVZqeLS0iSheu89qZgJAI8+KklV0eWwREREVR3fNhHZKC8voHNnaflyc6UqYdFZrmPHgKQkmek6f76wUhsAuLoCzZuXnuV66CGLnw5VQZmZwNKlwJw5wLVr0hcSIknV00/zgtpERGR7mFwR2RG9HmjSRNqzzxb237plfJYrPR2IjpZWlL9/6YqFTZpwlsve5eTIzNS1a8COHYEYMcIRFy/KfY0bAzNmyOwqK1sSEZGt4lshIoKHB9Cpk7R8eXlAQkLpWa6EBKlaePEi8O9/Fx7v4iIFOIrOcrVqBdSqZfnzIdPdvStJdtGWmlq6737HpKfnP5oTgNYAZLnptGnAoEFMvomIyPZp/qdu2bJleO+995CcnIxWrVrhww8/RGhoaJnHL168GCtWrMC5c+dQq1YtPPvss5g7dy5cXV0BAGlpaYiMjMTWrVtx5coVtGnTBkuWLEH79u0tdUpENsHBQSoLNmoEPPNMYX9qqlQoLJpwHTsm1+U6fFhaUb6+pWe5mjaV635RxSkly+8qmhhlZpovJjc3BQ+PdEyY4IbXXtPj3sszERGRzdM0ufriiy8wduxYrFy5Eh06dMDixYvRrVs3xMbGok6dOqWO37hxIyZOnIg1a9YgPDwcf/zxBwYPHgydTodFixYBAF555RWcOHEC69evh5+fHz777DNERETg5MmT8Pf3t/QpEtkcd3cgPFxavrw82bdVcpYrLg64fFnajh2Fxzs5GZ/lMvK0t2lKyWyPqYlRyfvzy5mbQ/XqMpOZ39zdi98u2Ure7+4O6HQ52LZtF7p37w4nJ9b9JyIi+6FpcrVo0SIMHToUL730EgBg5cqV+OGHH7BmzRpMnDix1PG//fYbOnbsiAEDBgAA6tevj/79+2P/vYv73LlzB5s3b8a3336Lzvd28U+fPh3fffcdVqxYgVmzZlnozIjsi4MD0KCBtF69Cvtv3zY+y5WaKn1HjxZ/HG/v0rNcwcGAs7NFT+eB5OVJFbyKzBalpkqREXPQ6YwnOqYmRua4Bpo5kz0iIqKqRLPk6u7du4iOjsakSZMK+hwcHBAREYF9+/YZ/Z7w8HB89tlnOHDgAEJDQ5GQkIBt27Zh4MCBAICcnBzk5uYWLBHM5+bmhqioqDJjycrKQlZWVsHt1Hu1grOzs5Gt8buE/J+vdRxUiGPy4FxcgLZtpeVTSq69dfy4DseO6XD8uLS4OCAlRYcffwR+/LHweEdHheBgICREoWVLaSEhCt7ehdXmTB2T/MILhUmOruB2aqquRCIk9xX9+tYtSayUMk+5O71eFUtw3N1VkcRHFUuC3N1VsePy+6tXr3ihiLw8aRXF54j14ZhYH46JdeF4WB9rGhNTYtAppVQlxlKmS5cuwd/fH7/99hvCwsIK+idMmIA9e/YUzEaV9MEHH2DcuHFQSiEnJwevvvoqVqxYUXB/eHg4nJ2dsXHjRnh7e+Pzzz/HoEGD0KhRI8TGxhp9zOnTp+Odd94p1b9x40ZUq1atgmdKRA8iM1OPc+dqICnJA0lJ7jh71h2JiR7IyDC+OcvDIwuBgamoX/8WAgPToNMpZGQ4IT3dERkZTsjIcER6uhMyMpxw507+13JfZqb5PldydMyFwZCDatWyUa1a8X8NBuNfF/bJvy4uuSxLTkREZKUyMjIwYMAA3Lp1C+7u7vc9VvOCFqbYvXs35syZg+XLl6NDhw6Ii4vDqFGjMHPmTERGRgIA1q9fjyFDhsDf3x96vR6PPPII+vfvj+iStaSLmDRpEsaOHVtwOzU1FQEBAfjLX/7yX/8DK1t2djZ+/PFHPPXUU3BiBQCrwDGxHKWA8+ezS81ynTkD3LrlgmPHauPYsdrlfnwpvJC/PE7dmw0yNmNU/L6iM0YyUe4AwOVeIz5HrA/HxPpwTKwLx8P6WNOY5K9qexCaJVe1atWCXq9HSkpKsf6UlBT4+PgY/Z7IyEgMHDgQr7zyCgCgZcuWSE9Px7BhwzB58mQ4ODigYcOG2LNnD9LT05GamgpfX1/07dsXDRo0KDMWFxcXuLiUflPk5OSk+WDms6ZYSHBMLKNhQ2lF93JlZAAnTxYW0IiJycONG1fRsGFteHk5PPD+ImfnotNFnDoyNz5HrA/HxPpwTKwLx8P6WMOYmPLzNUuunJ2d0bZtW+zatQu97r1rysvLw65duzBy5Eij35ORkQGHEpsK9Pd2X5dc3WgwGGAwGHDz5k3s2LED8+fPN/9JEJEmqlUD2rWTBgDZ2bnYtu33e9XpeIVaIiIi0oamywLHjh2LQYMGoV27dggNDcXixYuRnp5eUD3wxRdfhL+/P+bOnQsA6NGjBxYtWoQ2bdoULAuMjIxEjx49CpKsHTt2QCmFpk2bIi4uDuPHj0dwcHDBYxIREREREVUGTZOrvn374urVq5g6dSqSk5PRunVrbN++Hd7e3gCAc+fOFZupmjJlCnQ6HaZMmYKLFy+idu3a6NGjB2bPnl1wzK1btzBp0iRcuHABNWvWRO/evTF79mzNpxOJiIiIiMi2aV7QYuTIkWUuA9y9e3ex246Ojpg2bRqmTZtW5uP16dMHffr0MWeIRERERERE/xU3JxAREREREZkBkysiIiIiIiIzYHJFRERERERkBkyuiIiIiIiIzIDJFRERERERkRkwuSIiIiIiIjIDJldERERERERmwOSKiIiIiIjIDJhcERERERERmQGTKyIiIiIiIjNgckVERERERGQGTK6IiIiIiIjMgMkVERERERGRGTC5IiIiIiIiMgMmV0RERERERGbgqHUA1kgpBQBITU3VOBIgOzsbGRkZSE1NhZOTk9bhEDgm1ohjYl04HtaHY2J9OCbWheNhfaxpTPJzgvwc4X6YXBmRlpYGAAgICNA4EiIiIiIisgZpaWnw8PC47zE69SApmJ3Jy8vDpUuXUKNGDeh0Ok1jSU1NRUBAAM6fPw93d3dNYyHBMbE+HBPrwvGwPhwT68MxsS4cD+tjTWOilEJaWhr8/Pzg4HD/XVWcuTLCwcEBdevW1TqMYtzd3TX/xaLiOCbWh2NiXTge1odjYn04JtaF42F9rGVM/tuMVT4WtCAiIiIiIjIDJldERERERERmwOTKyrm4uGDatGlwcXHROhS6h2NifTgm1oXjYX04JtaHY2JdOB7Wp6qOCQtaEBERERERmQFnroiIiIiIiMyAyRUREREREZEZMLkiIiIiIiIyAyZXREREREREZsDkygosW7YM9evXh6urKzp06IADBw6Ueezq1avx2GOPwcvLC15eXoiIiLjv8VQ+pozJli1b0K5dO3h6esJgMKB169ZYv369BaO1D6aMSVGbNm2CTqdDr169KjdAO2PKeHzyySfQ6XTFmqurqwWjtQ+mPkf+/PNPjBgxAr6+vnBxcUGTJk2wbds2C0VrH0wZk65du5Z6nuh0Ojz99NMWjNi2mfocWbx4MZo2bQo3NzcEBARgzJgxyMzMtFC09sGUMcnOzsaMGTPQsGFDuLq6olWrVti+fbsFo31AijS1adMm5ezsrNasWaNiYmLU0KFDlaenp0pJSTF6/IABA9SyZcvU4cOH1alTp9TgwYOVh4eHunDhgoUjt12mjskvv/yitmzZok6ePKni4uLU4sWLlV6vV9u3b7dw5LbL1DHJl5iYqPz9/dVjjz2mevbsaZlg7YCp47F27Vrl7u6uLl++XNCSk5MtHLVtM3VMsrKyVLt27VT37t1VVFSUSkxMVLt371ZHjhyxcOS2y9QxuX79erHnyIkTJ5Rer1dr1661bOA2ytTx2LBhg3JxcVEbNmxQiYmJaseOHcrX11eNGTPGwpHbLlPHZMKECcrPz0/98MMPKj4+Xi1fvly5urqqQ4cOWTjy+2NypbHQ0FA1YsSIgtu5ubnKz89PzZ0794G+PycnR9WoUUOtW7euskK0OxUdE6WUatOmjZoyZUplhGeXyjMmOTk5Kjw8XP3zn/9UgwYNYnJlRqaOx9q1a5WHh4eForNPpo7JihUrVIMGDdTdu3ctFaLdqejfkvfff1/VqFFD3b59u7JCtCumjseIESPUE088Uaxv7NixqmPHjpUapz0xdUx8fX3V0qVLi/U988wz6vnnn6/UOE3FZYEaunv3LqKjoxEREVHQ5+DggIiICOzbt++BHiMjIwPZ2dmoWbNmZYVpVyo6Jkop7Nq1C7GxsejcuXNlhmo3yjsmM2bMQJ06dfDyyy9bIky7Ud7xuH37NgIDAxEQEICePXsiJibGEuHahfKMyb/+9S+EhYVhxIgR8Pb2RosWLTBnzhzk5uZaKmybZo6/7x9//DH69esHg8FQWWHajfKMR3h4OKKjowuWqSUkJGDbtm3o3r27RWK2deUZk6ysrFJLyt3c3BAVFVWpsZrKUesA7Nm1a9eQm5sLb2/vYv3e3t44ffr0Az3GW2+9BT8/v2K/nFR+5R2TW7duwd/fH1lZWdDr9Vi+fDmeeuqpyg7XLpRnTKKiovDxxx/jyJEjFojQvpRnPJo2bYo1a9YgJCQEt27dwoIFCxAeHo6YmBjUrVvXEmHbtPKMSUJCAn7++Wc8//zz2LZtG+Li4jB8+HBkZ2dj2rRplgjbplX07/uBAwdw4sQJfPzxx5UVol0pz3gMGDAA165dQ6dOnaCUQk5ODl599VW8/fbblgjZ5pVnTLp164ZFixahc+fOaNiwIXbt2oUtW7ZY3YdCnLmqwubNm4dNmzZh69at3ByusRo1auDIkSM4ePAgZs+ejbFjx2L37t1ah2WX0tLSMHDgQKxevRq1atXSOhwCEBYWhhdffBGtW7dGly5dsGXLFtSuXRsfffSR1qHZrby8PNSpUwerVq1C27Zt0bdvX0yePBkrV67UOjSCzFq1bNkSoaGhWodit3bv3o05c+Zg+fLlOHToELZs2YIffvgBM2fO1Do0u7VkyRI0btwYwcHBcHZ2xsiRI/HSSy/BwcG60hnOXGmoVq1a0Ov1SElJKdafkpICHx+f+37vggULMG/ePPz0008ICQmpzDDtSnnHxMHBAY0aNQIAtG7dGqdOncLcuXPRtWvXygzXLpg6JvHx8UhKSkKPHj0K+vLy8gAAjo6OiI2NRcOGDSs3aBtWkdetfE5OTmjTpg3i4uIqI0S7U54x8fX1hZOTE/R6fUHfww8/jOTkZNy9exfOzs6VGrOtq8jzJD09HZs2bcKMGTMqM0S7Up7xiIyMxMCBA/HKK68AAFq2bIn09HQMGzYMkydPtro39FVNecakdu3a+Oabb5CZmYnr16/Dz88PEydORIMGDSwR8gPjb4aGnJ2d0bZtW+zataugLy8vD7t27UJYWFiZ3zd//nzMnDkT27dvR7t27SwRqt0o75iUlJeXh6ysrMoI0e6YOibBwcE4fvw4jhw5UtD+/ve/4/HHH8eRI0cQEBBgyfBtjjmeI7m5uTh+/Dh8fX0rK0y7Up4x6dixI+Li4go+eACAP/74A76+vkyszKAiz5OvvvoKWVlZeOGFFyo7TLtRnvHIyMgolUDlfxihlKq8YO1ERZ4jrq6u8Pf3R05ODjZv3oyePXtWdrim0bight3btGmTcnFxUZ988ok6efKkGjZsmPL09CwoUzxw4EA1ceLEguPnzZunnJ2d1ddff12sZGtaWppWp2BzTB2TOXPmqJ07d6r4+Hh18uRJtWDBAuXo6KhWr16t1SnYHFPHpCRWCzQvU8fjnXfeUTt27FDx8fEqOjpa9evXT7m6uqqYmBitTsHmmDom586dUzVq1FAjR45UsbGx6vvvv1d16tRRs2bN0uoUbE55X7c6deqk+vbta+lwbZ6p4zFt2jRVo0YN9fnnn6uEhAS1c+dO1bBhQ9WnTx+tTsHmmDomv//+u9q8ebOKj49Xv/76q3riiSdUUFCQunnzpkZnYByXBWqsb9++uHr1KqZOnYrk5GS0bt0a27dvL9jgd+7cuWKfnKxYsQJ3797Fs88+W+xxpk2bhunTp1sydJtl6pikp6dj+PDhuHDhAtzc3BAcHIzPPvsMffv21eoUbI6pY0KVy9TxuHnzJoYOHYrk5GR4eXmhbdu2+O2339CsWTOtTsHmmDomAQEB2LFjB8aMGYOQkBD4+/tj1KhReOutt7Q6BZtTntet2NhYREVFYefOnVqEbNNMHY8pU6ZAp9NhypQpuHjxImrXro0ePXpg9uzZWp2CzTF1TDIzMzFlyhQkJCSgevXq6N69O9avXw9PT0+NzsA4nVKc2yQiIiIiIqooftRLRERERERkBkyuiIiIiIiIzIDJFRERERERkRkwuSIiIiIiIjIDJldERERERERmwOSKiIiIiIjIDJhcERERERERmQGTKyIiIiIiIjNgckVERHZr9+7d0Ol0+PPPP7UOBXv37kXLli3h5OSEXr16aR0OERGVA5MrIiKyuMGDB0On05VqcXFxlfYzu3btitGjRxfrCw8Px+XLl+Hh4VFpP/dBjR07Fq1bt0ZiYiI++eQTo8copTB16lT4+vrCzc0NEREROHPmjGUDJSKiMjG5IiIiTfz1r3/F5cuXi7WgoKBSx929e7fSYnB2doaPjw90Ol2l/YwHFR8fjyeeeAJ169aFp6en0WPmz5+PDz74ACtXrsT+/fthMBjQrVs3ZGZmWjZYIiIyiskVERFpwsXFBT4+PsWaXq9H165dMXLkSIwePRq1atVCt27dAACLFi1Cy5YtYTAYEBAQgOHDh+P27dvFHnPv3r3o2rUrqlWrBi8vL3Tr1g03b97E4MGDsWfPHixZsqRgliwpKcnossDNmzejefPmcHFxQf369bFw4cJiP6N+/fqYM2cOhgwZgho1aqBevXpYtWrVfc81KysLb7zxBurUqQNXV1d06tQJBw8eBAAkJSVBp9Ph+vXrGDJkCHQ6ndGZK6UUFi9ejClTpqBnz54ICQnBp59+ikuXLuGbb74xfQCIiMjsmFwREZHVWbduHZydnbF3716sXLkSAODg4IAPPvgAMTExWLduHX7++WdMmDCh4HuOHDmCJ598Es2aNcO+ffsQFRWFHj16IDc3F0uWLEFYWBiGDh1aMEsWEBBQ6udGR0ejT58+6NevH44fP47p06cjMjKyVLKzcOFCtGvXDocPH8bw4cPx2muvITY2tszzmTBhAjZv3ox169bh0KFDaNSoEbp164YbN24gICAAly9fhru7OxYvXozLly+jb9++pR4jMTERycnJiIiIKOjz8PBAhw4dsG/fPlP/i4mIqDIoIiIiCxs0aJDS6/XKYDAUtGeffVYppVSXLl1UmzZt/utjfPXVV+qhhx4quN2/f3/VsWPHMo/v0qWLGjVqVLG+X375RQFQN2/eVEopNWDAAPXUU08VO2b8+PGqWbNmBbcDAwPVCy+8UHA7Ly9P1alTR61YscLoz719+7ZycnJSGzZsKOi7e/eu8vPzU/Pnzy/o8/DwUGvXri0z/r179yoA6tKlS8X6n3vuOdWnT58yv4+IiCzHUevkjoiI7NPjjz+OFStWFNw2GAwFX7dt27bU8T/99BPmzp2L06dPIzU1FTk5OcjMzERGRgaqVauGI0eO4LnnnqtQTKdOnULPnj2L9XXs2BGLFy9Gbm4u9Ho9ACAkJKTgfp1OBx8fH1y5csXoY8bHxyM7OxsdO3Ys6HNyckJoaChOnTpVoXiJiMi6cFkgERFpwmAwoFGjRgXN19e32H1FJSUl4W9/+xtCQkKwefNmREdHY9myZQAKC164ublZLHYnJ6dit3U6HfLy8ir1Z/r4+AAAUlJSivWnpKQU3EdERNpickVERFYvOjoaeXl5WLhwIR599FE0adIEly5dKnZMSEgIdu3aVeZjODs7Izc3974/5+GHH8bevXuL9e3duxdNmjQpmLUyVcOGDQv2j+XLzs7GwYMH0axZswd+nKCgIPj4+BQ7x9TUVOzfvx9hYWHlio2IiMyLywKJiMjqNWrUCNnZ2fjwww/Ro0ePYoUu8k2aNAktW7bE8OHD8eqrr8LZ2Rm//PILnnvuOdSqVQv169fH/v37kZSUhOrVq6NmzZqlfs6bb76J9u3bY+bMmejbty/27duHpUuXYvny5eWO3WAw4LXXXsP48eNRs2ZN1KtXD/Pnz0dGRgZefvnlB34cnU6H0aNHY9asWWjcuDGCgoIQGRkJPz8/XnSYiMhKcOaKiIisXqtWrbBo0SK8++67aNGiBTZs2IC5c+cWO6ZJkybYuXMnjh49itDQUISFheHbb7+Fo6N8jjhu3Djo9Xo0a9YMtWvXxrlz50r9nEceeQRffvklNm3ahBYtWmDq1KmYMWMGBg8eXKH4582bh969e2PgwIF45JFHEBcXhx07dsDLy8ukx5kwYQJef/11DBs2DO3bt8ft27exfft2uLq6Vig+IiIyD51SSmkdBBERERERUVXHmSsiIiIiIiIzYHJFRERERERkBkyuiIiIiIiIzIDJFRERERERkRkwuSIiIiIiIjIDJldERERERERmwOSKiIiIiIjIDJhcERERERERmQGTKyIiIiIiIjNgckVERERERGQGTK6IiIiIiIjM4P8BbVJwR4G0ZJcAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def evaluate_models_online(train_datasets, test_datasets):\n",
    "    # Prepare the test data\n",
    "    \n",
    "    accuracies = []\n",
    "    precisions = []\n",
    "    recalls = []\n",
    "    ratios = []\n",
    "    og_accuracies = []\n",
    "    og_precisions = []\n",
    "    og_recalls = []\n",
    "\n",
    "    for ratio in [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]:\n",
    "        print('Test Bias Ratio: ', ratio)\n",
    "        test_dataset = test_datasets[ratio]\n",
    "        train_dataset = train_datasets[ratio]\n",
    "        X_train, y_train = zip(*[(x.detach().numpy().flatten(), y) for x, y in train_dataset])\n",
    "        X_train = np.array(X_train)\n",
    "        y_train = np.array(y_train)\n",
    "        X_test, y_test = zip(*[(x.detach().numpy().flatten(), y) for x, y in test_dataset])\n",
    "        X_test = np.array(X_test)\n",
    "        y_test = np.array(y_test)\n",
    "        model = BiasedRandomForestClassifier()\n",
    "        model.fit(X_train, y_train)\n",
    "        og = RandomForestClassifier()\n",
    "        og.fit(X_train, y_train)\n",
    "        \n",
    "        predictions = model.predict_biased_online_recall(X_test, y_test, alpha = 0.1)[0] # chage this to \n",
    "        accuracies.append(accuracy_score(y_test, predictions))\n",
    "        og_accuracies.append(accuracy_score(y_test, og.predict(X_test)))\n",
    "        og_precisions.append(precision_score(y_test, og.predict(X_test), average='macro'))\n",
    "        og_recalls.append(recall_score(y_test, og.predict(X_test), average='macro'))\n",
    "        precisions.append(precision_score(y_test, predictions, average='macro'))\n",
    "        recalls.append(recall_score(y_test, predictions, average='macro'))\n",
    "        ratios.append(ratio)\n",
    "\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_accuracies, label='RF Accuracy', color='blue')\n",
    "    plt.plot(ratios, accuracies, label='DeBOT Accuracy', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_precisions, label='RF Precision', color='blue')\n",
    "    plt.plot(ratios, precisions, label='DeBOT Precision', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_recalls, label='RF Recall', color='blue')\n",
    "    plt.plot(ratios, recalls, label='DeBOT Recall', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "evaluate_models_online(encoded_biased_train, encoded_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f8282c2",
   "metadata": {},
   "source": [
    "Heuristic penalizes the threshold for class which label wrongly classifies into"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d7c81c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_models_online(training_dataset, test_datasets):\n",
    "    # Prepare the test data\n",
    "    \n",
    "    accuracies = []\n",
    "    precisions = []\n",
    "    recalls = []\n",
    "    ratios = []\n",
    "    og_accuracies = []\n",
    "    og_precisions = []\n",
    "    og_recalls = []\n",
    "    \n",
    "    X_train, y_train = zip(*[(x.detach().numpy().flatten(), y) for x, y in training_dataset])\n",
    "    X_train = np.array(X_train)\n",
    "    y_train = np.array(y_train)\n",
    "\n",
    "    model = BiasedRandomForestClassifier()\n",
    "    model.fit(X_train, y_train)\n",
    "    og = RandomForestClassifier()\n",
    "    og.fit(X_train, y_train)\n",
    "\n",
    "    for ratio, test_dataset in test_datasets.items():\n",
    "        print('Test Bias Ratio: ', ratio)\n",
    "        #print('Fitted thresholds: ', thresholds)\n",
    "        \n",
    "        X_test, y_test = zip(*[(x.detach().numpy().flatten(), y) for x, y in test_dataset])\n",
    "        X_test = np.array(X_test)\n",
    "        y_test = np.array(y_test)\n",
    "\n",
    "        predictions = model.predict_biased_online_precision(X_test, y_test, alpha = 0.1)[0] # chage this to \n",
    "        accuracies.append(accuracy_score(y_test, predictions))\n",
    "        og_accuracies.append(accuracy_score(y_test, og.predict(X_test)))\n",
    "        og_precisions.append(precision_score(y_test, og.predict(X_test), average='macro'))\n",
    "        og_recalls.append(recall_score(y_test, og.predict(X_test), average='macro'))\n",
    "        precisions.append(precision_score(y_test, predictions, average='macro'))\n",
    "        recalls.append(recall_score(y_test, predictions, average='macro'))\n",
    "        ratios.append(ratio)\n",
    "\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_accuracies, label='RF Accuracy', color='blue')\n",
    "    plt.plot(ratios, accuracies, label='DeBOT Accuracy', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_precisions, label='RF Precision', color='blue')\n",
    "    plt.plot(ratios, precisions, label='DeBOT Precision', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_recalls, label='RF Recall', color='blue')\n",
    "    plt.plot(ratios, recalls, label='DeBOT Recall', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "evaluate_models_online(encoded_train, encoded_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbf63239",
   "metadata": {},
   "source": [
    "Heuristic boosts the threshold for true class which the label was not classified into"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a4d5d245",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Bias Ratio:  0.2\n",
      "Test Bias Ratio:  0.3\n",
      "Test Bias Ratio:  0.4\n",
      "Test Bias Ratio:  0.5\n",
      "Test Bias Ratio:  0.6\n",
      "Test Bias Ratio:  0.7\n",
      "Test Bias Ratio:  0.8\n",
      "Test Bias Ratio:  0.9\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAAIjCAYAAADvBuGTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA9hAAAPYQGoP6dpAACuJ0lEQVR4nOzdeZxN9R/H8dedfcYY6zCMfex7URIle41d9mTXj5LsW3ZJEhFCshQRIUvZibJEkSVkl33fjVnv+f1xmss1gxlm5l4z7+fjMY+c7/3ecz73fu9M85nv93y+FsMwDEREREREROSpuDg6ABERERERkeRAyZWIiIiIiEgCUHIlIiIiIiKSAJRciYiIiIiIJAAlVyIiIiIiIglAyZWIiIiIiEgCUHIlIiIiIiKSAJRciYiIiIiIJAAlVyIiIiIiIglAyZWIJLlRo0aRJ08eXF1dKVmypKPDkUTQqlUrcuXKlWTXi4yMpFevXmTPnh0XFxfq1q2bZNeOq1y5ctGqVSu7tsOHD1OtWjXSpEmDxWJh8eLFAPzxxx+8/PLLpEqVCovFwq5du5I8XokptjF8ljzr8Ys8C5RciQgzZ87EYrHYvry8vMifPz+dOnXiwoULCXqt1atX06tXL8qVK8eMGTP4+OOPE/T8KU2rVq2wWCz4+flx9+7dGI8fPnzYNq6fffZZvM8fEhLC4MGD2bBhQwJEm3imT5/OqFGjaNCgAd988w1du3ZN1Ou99tprtvfVxcUFPz8/ChQowNtvv82aNWvifJ6WLVuyd+9ehg8fzqxZsyhdujQRERE0bNiQq1ev8vnnnzNr1ixy5syZiK/myT3J5+PEiRO0bt2aoKAgvLy8CAgI4NVXX2XQoEGJF6iTuv9zZLFY8Pb2pnjx4owdOxar1fpE59yyZQuDBw/m+vXrCRusiMSJm6MDEBHnMXToUHLnzk1oaCibNm1i0qRJLF++nL///hsfH58Eucb69etxcXFh2rRpeHh4JMg5Uzo3NzdCQkJYtmwZjRo1snvsu+++w8vLi9DQ0Cc6d0hICEOGDAHMXwTjaurUqU/8y+GTWL9+PYGBgXz++edJds1s2bIxYsQIAO7cucORI0dYtGgRs2fPplGjRsyePRt3d3db/4MHD+Licu9vmnfv3mXr1q18+OGHdOrUydb+zz//8O+//zJ16lTatWuXZK/nScT383HkyBFeeOEFvL29adOmDbly5eLcuXPs3LmTkSNH2s6Vktz/Obp8+TJz5syha9euXLp0ieHDh8f7fFu2bGHIkCG0atWKtGnT2j324GdQRBKekisRsXnjjTcoXbo0AO3atSNDhgyMGTOGJUuW0LRp06c6d0hICD4+Ply8eBFvb+8ES6wMwyA0NBRvb+8EOd+zyNPTk3LlyjF37twYydWcOXOoUaMGCxcuTJJY7ty5Q6pUqeySiqRw8eLFGL9IPg2r1Up4eDheXl4P7ZMmTRqaN29u1/bJJ5/QuXNnvvzyS3LlysXIkSNtj3l6etr1vXTpEkCMuC9evBhr+9OIHhdH+/zzz7l9+za7du2KMRsX/bpTmgc/Rx06dKBgwYKMHz+eoUOH4urqmmDXevAzKCIJT3++EJGHqlSpEgDHjx+3tc2ePZtSpUrh7e1N+vTpadKkCadOnbJ73muvvUbRokXZsWMHr776Kj4+PvTr1w+LxcKMGTO4c+eObRnMzJkzAfOemWHDhhEUFISnpye5cuWiX79+hIWF2Z07V65c1KxZk1WrVlG6dGm8vb2ZMmUKGzZswGKxMH/+fIYMGUJgYCCpU6emQYMG3Lhxg7CwMLp06UKmTJnw9fWldevWMc49Y8YMKlWqRKZMmfD09KRw4cJMmjQpxvsSHcOmTZt48cUX8fLyIk+ePHz77bcx+l6/fp2uXbuSK1cuPD09yZYtGy1atODy5cu2PmFhYQwaNIi8efPi6elJ9uzZ6dWrV4z4HqVZs2asWLHCbinQH3/8weHDh2nWrFmsz7l+/TpdunQhe/bseHp6kjdvXkaOHGmbcTpx4gT+/v4ADBkyxDZmgwcPBswlib6+vhw9epTg4GBSp07NW2+9ZXvswXuurFYr48aNo1ixYnh5eeHv78/rr7/On3/+aeuzZs0aypcvT9q0afH19aVAgQL069fvoa/7xIkTWCwWfvnlF/bt22eLMXqZ2p07d+jevbvtNRYoUIDPPvsMwzDszmOxWOjUqRPfffcdRYoUwdPTk5UrVz72fX+Qq6srX3zxBYULF2bChAncuHHD9tj997sMHjzYllz07NkTi8Vie7xChQoANGzYEIvFYjcj9M8//9CgQQPSp0+Pl5cXpUuXZunSpXYxRC/z3bhxI++++y6ZMmUiW7ZstsdXrFjBK6+8QqpUqUidOjU1atRg3759dueIHtszZ85Qt25dfH198ff3p0ePHkRFRdne+0d9PmJz9OhRsmXLFusyx0yZMtkdL1myhBo1apA1a1Y8PT0JCgpi2LBhtutHi/55s2fPHipUqICPjw958+ZlwYIFAGzcuJEyZcrg7e1NgQIFWLt2rd3zBw8ejMVi4Z9//qFRo0b4+fmRIUMGPvjggzjN+D7u+yi+vLy8eOGFF7h165Zdwrlnzx5atWpFnjx5bMsp27Rpw5UrV+xeS8+ePQHInTu3bUxOnDgBxH7P1bFjx2jYsCHp06fHx8eHl156iZ9//jlGXOPHj6dIkSL4+PiQLl06SpcuzZw5c57oNYokZ5q5EpGHOnr0KAAZMmQAYPjw4QwYMIBGjRrRrl07Ll26xPjx43n11Vf566+/7P7SfuXKFd544w2aNGlC8+bNyZw5M6VLl+arr75i+/btfP311wC8/PLLgDlT9s0339CgQQO6d+/Otm3bGDFiBAcOHODHH3+0i+vgwYM0bdqU//3vf7Rv354CBQrYHhsxYgTe3t706dOHI0eOMH78eNzd3XFxceHatWsMHjyY33//nZkzZ5I7d24GDhxoe+6kSZMoUqQItWvXxs3NjWXLlvHuu+9itVp577337GI4cuQIDRo0oG3btrRs2ZLp06fTqlUrSpUqRZEiRQC4ffs2r7zyCgcOHKBNmzY8//zzXL58maVLl3L69GkyZsyI1Wqldu3abNq0iXfeeYdChQqxd+9ePv/8cw4dOmQrcPA49evXp0OHDixatIg2bdoA5qxVwYIFef7552P0DwkJoUKFCpw5c4b//e9/5MiRgy1bttC3b1/OnTvH2LFj8ff3Z9KkSXTs2JF69epRv359AIoXL247T2RkJNWrV6d8+fJ89tlnj1w+2rZtW2bOnMkbb7xBu3btiIyM5LfffuP333+ndOnS7Nu3j5o1a1K8eHGGDh2Kp6cnR44cYfPmzQ89p7+/P7NmzWL48OHcvn3btryqUKFCGIZB7dq1+eWXX2jbti0lS5Zk1apV9OzZkzNnzsRYQrh+/Xrmz59Pp06dyJgx4xMX5HB1daVp06YMGDCATZs2UaNGjRh96tevT9q0aenatStNmzYlODgYX19fMmfOTGBgIB9//DGdO3fmhRdeIHPmzADs27ePcuXKERgYSJ8+fUiVKhXz58+nbt26LFy4kHr16tld491338Xf35+BAwdy584dAGbNmkXLli2pXr06I0eOJCQkhEmTJlG+fHn++usvu9ccFRVF9erVKVOmDJ999hlr165l9OjRBAUF0bFjxzh9Ph6UM2dO1q5dy/r1621/vHmYmTNn4uvrS7du3fD19WX9+vUMHDiQmzdvMmrUKLu+165do2bNmjRp0oSGDRsyadIkmjRpwnfffUeXLl3o0KEDzZo1s92Xd+rUKVKnTm13jkaNGpErVy5GjBjB77//zhdffMG1a9di/aNJtLh8Hz2J6D8a3P8zdc2aNRw7dozWrVsTEBDAvn37+Oqrr9i3bx+///47FouF+vXrc+jQIebOncvnn39OxowZAWxJ8IMuXLjAyy+/TEhICJ07dyZDhgx888031K5dmwULFtg+U1OnTqVz5840aNDAlnTu2bOHbdu2PfSPNyIpliEiKd6MGTMMwFi7dq1x6dIl49SpU8b3339vZMiQwfD29jZOnz5tnDhxwnB1dTWGDx9u99y9e/cabm5udu0VKlQwAGPy5MkxrtWyZUsjVapUdm27du0yAKNdu3Z27T169DAAY/369ba2nDlzGoCxcuVKu76//PKLARhFixY1wsPDbe1NmzY1LBaL8cYbb9j1L1u2rJEzZ067tpCQkBjxVq9e3ciTJ49dW3QMv/76q63t4sWLhqenp9G9e3db28CBAw3AWLRoUYzzWq1WwzAMY9asWYaLi4vx22+/2T0+efJkAzA2b94c47n3u//9bNCggVG5cmXDMAwjKirKCAgIMIYMGWIcP37cAIxRo0bZnjds2DAjVapUxqFDh+zO16dPH8PV1dU4efKkYRiGcenSJQMwBg0aFOu1AaNPnz6xPnb/+7t+/XoDMDp37vzQ9+Lzzz83AOPSpUuPfM2xqVChglGkSBG7tsWLFxuA8dFHH9m1N2jQwLBYLMaRI0dsbYDh4uJi7Nu374mvd78ff/zRAIxx48bZ2nLmzGm0bNnSdhzbuBjGvc/yDz/8YNdeuXJlo1ixYkZoaKitzWq1Gi+//LKRL18+W1v093P58uWNyMhIW/utW7eMtGnTGu3bt7c77/nz5400adLYtUeP7dChQ+36Pvfcc0apUqVsx4/6fMTm77//Nry9vQ3AKFmypPHBBx8YixcvNu7cuROjb2zfj//73/8MHx8fu/cg+ufNnDlzbG3//POPbUx///13W/uqVasMwJgxY4atbdCgQQZg1K5d2+5a7777rgEYu3fvtrU9OIZx/T56mAoVKhgFCxY0Ll26ZFy6dMn4559/jJ49exqAUaNGjce+H3Pnzo3xs2jUqFEGYBw/fjxG/wfj79KliwHY/fy5deuWkTt3biNXrlxGVFSUYRiGUadOnUd+3kXkHi0LFBGbKlWq4O/vT/bs2WnSpAm+vr78+OOPBAYGsmjRIqxWK40aNeLy5cu2r4CAAPLly8cvv/xidy5PT09at24dp+suX74cgG7dutm1d+/eHSDGEpXcuXNTvXr1WM/VokULu/t9ypQpg2EYttmc+9tPnTpFZGSkre3++7Zu3LjB5cuXqVChAseOHbNb3gVQuHBhXnnlFduxv78/BQoU4NixY7a2hQsXUqJEiRgzCmAuQwP44YcfKFSoEAULFrR7X6P/qv/g+/oozZo1Y8OGDZw/f57169dz/vz5h/5V+YcffuCVV14hXbp0dtetUqUKUVFR/Prrr3G+bseOHR/bZ+HChVgsllgrwkW/F9F/pV+yZEmCFMNYvnw5rq6udO7c2a69e/fuGIbBihUr7NorVKhA4cKFn/q6AL6+vgDcunUrQc539epV1q9fT6NGjbh165ZtvK5cuUL16tU5fPgwZ86csXtO+/bt7e7XWbNmDdevX6dp06Z2Y+7q6kqZMmVi/ax16NDB7viVV16x+4zHV5EiRdi1axfNmzfnxIkTjBs3jrp165I5c2amTp1q1/f+78fo1/zKK68QEhLCP//8Y9fX19eXJk2a2I4LFChA2rRpKVSoEGXKlLG1R/87ttfw4Oz0+++/D9z7+RSbhPg++ueff/D398ff35+CBQsyatQoateubVsyHe3+9yM0NJTLly/z0ksvAbBz587HXic2y5cv58UXX6R8+fK2Nl9fX9555x1OnDjB/v37AfN78/Tp0/zxxx9PdB2RlETLAkXEZuLEieTPnx83NzcyZ85MgQIFbJWlDh8+jGEY5MuXL9bnPljAIDAwMM5FK/79919cXFzImzevXXtAQABp06bl33//tWvPnTv3Q8+VI0cOu+M0adIAkD179hjtVquVGzdu2JY9bt68mUGDBrF161ZCQkLs+t+4ccN2rtiuA5AuXTquXbtmOz569ChvvvnmQ2MF8309cODAQ5ftxOcm/+j7nubNm8euXbt44YUXyJs3r+1+iwevu2fPnqe+rpubm939PA9z9OhRsmbNSvr06R/ap3Hjxnz99de0a9eOPn36ULlyZerXr0+DBg2eqMLZv//+S9asWWMs/ypUqJDt8fs96nMVX7dv3waIce0ndeTIEQzDYMCAAQwYMCDWPhcvXiQwMNB2/ODrOXz4MMBDl+P5+fnZHUffF3e/Bz/jTyJ//vzMmjWLqKgo9u/fz08//cSnn37KO++8Q+7cualSpQpgLoPs378/69ev5+bNm3bnePCPHdmyZbMl6dHSpEkT6/c9EOtrePBnW1BQEC4uLrF+/0RLiO+jXLly2aprHj16lOHDh3Pp0qUYxVSuXr3KkCFD+P7772Oc98H3I67+/fdfu+Qz2v3fI0WLFqV3796sXbuWF198kbx581KtWjWaNWtGuXLlnui6IsmZkisRsXnxxRdt1QIfZLVasVgsrFixItbqVdF/qY/2JNX7Hvzl6GEede6HVdZ6WLvxX2GDo0ePUrlyZQoWLMiYMWPInj07Hh4eLF++nM8//zzGTMrjzhdXVquVYsWKMWbMmFgff/CXw0fx9PSkfv36fPPNNxw7duyRhQWsVitVq1alV69esT6eP3/+OF8zoUo7e3t78+uvv/LLL7/w888/s3LlSubNm0elSpVYvXp1glZNe9j1E8rff/8NEOMPBk8q+vPXo0ePh87aPnitB19P9DlmzZpFQEBAjOe7udn/SpDY77erqyvFihWjWLFilC1blooVK/Ldd99RpUoVrl+/ToUKFfDz82Po0KG2PbF27txJ79694/z9+DTfp3H5eZQQ30epUqWyJZQA5cqV4/nnn6dfv3588cUXtvZGjRqxZcsWevbsScmSJfH19cVqtfL6668n+rYHhQoV4uDBg/z000+sXLmShQsX8uWXXzJw4MAUWT5f5FGUXIlInAQFBWEYBrlz547zL95xlTNnTqxWK4cPH7b9xRTMm62vX7+eJBuoLlu2jLCwMJYuXWo3KxWfZXkPCgoKsv2S/ag+u3fvpnLlynFOLh+lWbNmTJ8+HRcXF7tlUrFd9/bt23a/1MUmIWKKvt6qVau4evXqI2evXFxcqFy5MpUrV2bMmDF8/PHHfPjhh/zyyy+PjfVB0cUTbt26ZTeDFL2kLLE+V1FRUcyZMwcfHx+75VZPI0+ePIA5Qxzf9yFaUFAQYFble9JzPCihPh/Rf9Q5d+4cABs2bODKlSssWrSIV1991dbv/sqlCe3w4cN2s31HjhzBarU+srBJXL+P4qN48eI0b96cKVOm0KNHD3LkyMG1a9dYt24dQ4YMsSvCEz0beb/4jEnOnDk5ePBgjPbYvkdSpUpF48aNady4MeHh4dSvX5/hw4fTt2/fR25ZIJLS6J4rEYmT+vXr4+rqypAhQ2L81dcwDLtywPEVHBwMEKOyVvRsTmzV1hJa9F+4739tN27cYMaMGU98zjfffJPdu3fHqHZ4/3UaNWrEmTNnYtxvAuYms9FV3uKqYsWKDBs2jAkTJsQ6OxGtUaNGbN26lVWrVsV47Pr167Z70aKr/91f4v1JvPnmmxiGEetfuaPfi6tXr8Z4rGTJkgDxKksfLTg4mKioKCZMmGDX/vnnn2OxWHjjjTfifc7HiYqKonPnzhw4cIDOnTvHWGr3pDJlysRrr73GlClTbAnI/aL3zHqU6tWr4+fnx8cff0xERMQTneNB8f18/Pbbb7FeO/q+pujKn7F9P4aHh/Pll1/GO8a4mjhxot3x+PHjAR75OYnr91F89erVi4iICNvPwNjeD4j5MxOw7WcWlzEJDg5m+/btbN261dZ2584dvvrqK3LlymW7B/HBn+8eHh4ULlwYwzBiHU+RlEwzVyISJ0FBQXz00Uf07duXEydOULduXVKnTs3x48f58ccfeeedd+jRo8cTnbtEiRK0bNmSr776yrYcaPv27XzzzTfUrVuXihUrJvCrialatWp4eHhQq1Yt/ve//3H79m2mTp1KpkyZYv1lNi569uzJggULaNiwIW3atKFUqVJcvXqVpUuXMnnyZEqUKMHbb7/N/Pnz6dChA7/88gvlypUjKiqKf/75h/nz59v284orFxcX+vfvH6fYli5dSs2aNW0l5O/cucPevXtZsGABJ06cIGPGjHh7e1O4cGHmzZtH/vz5SZ8+PUWLFqVo0aLxei8qVqzI22+/zRdffMHhw4dtS5l+++03KlasSKdOnRg6dCi//vorNWrUIGfOnFy8eJEvv/ySbNmyPdEMUK1atahYsSIffvghJ06coESJEqxevZolS5bQpUsX20zOk7px4wazZ88GzJLcR44cYdGiRRw9epQmTZowbNiwpzr/gyZOnEj58uUpVqwY7du3J0+ePFy4cIGtW7dy+vRpdu/e/cjn+/n5MWnSJN5++22ef/55mjRpgr+/PydPnuTnn3+mXLlyMRLRx4nv52PkyJHs2LGD+vXr20q279y5k2+//Zb06dPTpUsXwNyiIV26dLRs2ZLOnTtjsViYNWtWvJfdxsfx48epXbs2r7/+Olu3bmX27Nk0a9aMEiVKPPQ5cf0+iq/ChQsTHBzM119/zYABA8iQIQOvvvoqn376KREREQQGBrJ69epYZ/JKlSoFwIcffkiTJk1wd3enVq1asW4i3adPH+bOncsbb7xB586dSZ8+Pd988w3Hjx9n4cKFtiW/1apVIyAggHLlypE5c2YOHDjAhAkTqFGjRoLdVyiSbCR1eUIRcT7RpZv/+OOPx/ZduHChUb58eSNVqlRGqlSpjIIFCxrvvfeecfDgQVufR5Wpjq0Uu2EYRkREhDFkyBAjd+7chru7u5E9e3ajb9++diWXDcMsJfxgiWLDeHj56oe9tujyy/eX/V66dKlRvHhxw8vLy8iVK5cxcuRIY/r06THKGj8shgoVKhgVKlSwa7ty5YrRqVMnIzAw0PDw8DCyZctmtGzZ0rh8+bKtT3h4uDFy5EijSJEihqenp5EuXTqjVKlSxpAhQ4wbN27EfBPv87D3834PK/l969Yto2/fvkbevHkNDw8PI2PGjMbLL79sfPbZZ3bl7Lds2WKUKlXK8PDwsCu7/ahrP1iK3TAMIzIy0hg1apRRsGBBw8PDw/D39zfeeOMNY8eOHYZhGMa6deuMOnXqGFmzZjU8PDyMrFmzGk2bNo1R5jo2D/vM3bp1y+jatauRNWtWw93d3ciXL58xatQoW/n3aIDx3nvvPfY6918PsH35+voa+fLlM5o3b26sXr061uc8bSl2wzCMo0ePGi1atDACAgIMd3d3IzAw0KhZs6axYMECW5/HfT//8ssvRvXq1Y00adIYXl5eRlBQkNGqVSvjzz//tPV52NhGf9/c72Gfj9hs3rzZeO+994yiRYsaadKkMdzd3Y0cOXIYrVq1Mo4ePRqj70svvWR4e3sbWbNmNXr16mUrpf7LL7/Y+j1s7B/2ffrgWEe/pv379xsNGjQwUqdObaRLl87o1KmTcffu3RjnvH8MDSPu30exedTPyg0bNti9n6dPnzbq1atnpE2b1kiTJo3RsGFD4+zZs7G+58OGDTMCAwMNFxcXu59fscV/9OhRo0GDBkbatGkNLy8v48UXXzR++uknuz5TpkwxXn31VSNDhgyGp6enERQUZPTs2fOxP59EUiKLYSTin4FEREREnNjgwYMZMmQIly5deqJZJhGR++meKxERERERkQSg5EpERERERCQBKLkSERERERFJALrnSkREREREJAFo5kpERERERCQBKLkSERERERFJANpEOBZWq5WzZ8+SOnVqLBaLo8MREREREREHMQyDW7dukTVrVtvm2g+j5CoWZ8+eJXv27I4OQ0REREREnMSpU6fIli3bI/souYpF6tSpAfMN9PPzc2gsERERrF69mmrVquHu7u7QWMSkMXE+GhPnovFwPhoT56MxcS4aD+fjTGNy8+ZNsmfPbssRHkXJVSyilwL6+fk5RXLl4+ODn5+fwz9YYtKYOB+NiXPReDgfjYnz0Zg4F42H83HGMYnL7UIqaCEiIiIiIpIAlFyJiIiIiIgkACVXIiIiIiIiCUD3XD0hwzCIjIwkKioqUa8TERGBm5sboaGhiX4tiRtnGxNXV1fc3Ny0bYCIiIiIgym5egLh4eGcO3eOkJCQRL+WYRgEBARw6tQp/fLsJJxxTHx8fMiSJQseHh6ODkVEREQkxVJyFU9Wq5Xjx4/j6upK1qxZ8fDwSNRfsK1WK7dv38bX1/exm5ZJ0nCmMTEMg/DwcC5dusTx48fJly+fw2MSERERSamUXMVTeHg4VquV7Nmz4+Pjk+jXs1qthIeH4+XlpV+anYSzjYm3tzfu7u78+++/trhEREREJOk5/jfDZ5Qz/FItEk2fRxERERHH029kIiIiIiIiCUDJlYiIiIiISAJQciUiIiIiIpIAlFylIK1atcJisWCxWHB3dyd37tz06tWL0NBQu37Rfe7/Kl++/GPPv3XrVlxdXalRo0ZivQQREREREaelaoEpzOuvv86MGTOIiIhgx44dtGzZEovFwsiRI+36zZgxg9dff912HJf9k6ZNm8b777/PtGnTOHv2LFmzZk3w+OMqPDxcez6JiIiISJLSzFUCMAy4cyfpvwwj/rF6enoSEBBA9uzZqVu3LlWqVGHNmjUx+qVNm5aAgADbV/r06R953tu3bzNv3jw6duxIjRo1mDlzZow+y5Yt44UXXsDLy4uMGTNSr14922NhYWH07t2b7Nmz4+npSd68eZk2bRoAM2fOJG3atHbnWrx4sd3+YoMHD6ZkyZJ8/fXX5M6d21aOfOXKlZQvX560adOSIUMGatasydGjR+3Odfr0aZo2bUr69OlJlSoVpUuXZtu2bZw4cQIXFxf+/PNPu/7jxo2jWLFiWK3WR74nIiIiIpKyaOYqAYSEgK9vYp3dBUgb6yO3b0OqVE9+5r///pstW7aQM2fOJz/Jf+bPn0/BggUpUKAAzZs3p0uXLvTt29eWAP3888/Uq1ePDz/8kG+//Zbw8HCWL19ue36LFi3YunUrX3zxBSVKlOD48eNcvnw5XjEcOXKEhQsXsmjRIlxdXQG4c+cO3bp1o3jx4ty+fZuBAwdSr149du3ahYuLC7dv36ZChQoEBgaydOlSAgIC2LlzJ1arlVy5clGlShVmzJhB6dKlbdeZOXMmzZo1U/lzEREREbGj5CqF+emnn/D19SUyMpKwsDBcXFyYMGFCjH5Nmza1JSgAs2fPpm7dug8977Rp02jevDlgLj28ceMGGzdu5LXXXgNg+PDhNGnShCFDhtieU6JECQAOHTrE/PnzWbNmDVWqVAEgT5488X5t4eHhfPvtt/j7+9va3nzzTbs+06dPx9/fn/3791O0aFHmzJnDpUuX+OOPP2yzc3nz5rX1b9euHR06dGDMmDF4enqyc+dO9u7dy6xZs+Idn4iIiIgkb/rTewLw8TFnkRLj6+ZNK6dPX+fmTWuMx3x84h9rxYoV2bVrF9u2baNly5a0bt06RgIC8Pnnn7Nr1y7bV9WqVR96zoMHD7J9+3aaNm0KgJubG40bN7Yt6wPYtWsXlStXjvX5u3btwtXVlQoVKsT/Bd0nZ86cdokVwOHDh2natCl58uTBz8+PXLlyAXDy5EnbtZ977rmHLnusW7curq6u/Pjjj4A5a1WxYkVy5MjxVLGKiIiIyEMYBpYtWwjcuNHRkcSbZq4SgMXydMvzHsVqhago8/wJsQotVapUtpmZ6dOnU6JECaZNm0bbtm3t+gUEBNjN4DzKtGnTiIyMtCtgYRgGnp6eTJgwgTRp0uDt7f3Q5z/qMQAXFxeMB24wi4iIiNEvVSyDUKtWLXLmzMnUqVPJmjUrVquVokWLEh4eHqdre3h40KJFC2bMmEH9+vWZM2cOn3/++SOfIyIiIiJP4OxZ+PZbmDEDt0OHKO7rC0OGgLu7oyOLM81cpWAuLi7069eP/v37c/fu3Sc6R2RkJN9++y2jR4+2m+navXs3WbNmZe7cuQAUL16cdevWxXqO6OIQGx/y1wl/f39u3brFnTt3bG27du16bGxXrlzh4MGD9O/fn8qVK1OoUCGuXbtm16d48eLs2rWLq1evPvQ87dq1Y+3atXz55ZdERkZSv379x15bREREROIgPBwWLoQaNSB7dujbFw4dwkiVinNlysCtW46OMF6UXKVwDRs2xNXVlYkTJz7R83/66SeuXbtG27ZtKVq0qN3Xm2++aVsaOGjQIObOncugQYM4cOAAe/futZV/z5UrFy1btqRNmzYsXryY48ePs2HDBubPnw9AmTJl8PHxoV+/fhw9epQ5c+bEWo3wQenSpSNDhgx89dVXHDlyhPXr19OtWze7Pk2bNiUgIIC6deuyefNmjh07xsKFC9m6dautT6FChXjppZfo3bs3TZs2fexsl4iIiIg8xp490KULBAZCgwawfLm5ZKt8eZg+nchTp9j1/vvwwC0fzk7JVQrn5uZGp06d+PTTT+1mhuJq2rRpVKlShTRp0sR47M033+TPP/9kz549vPbaa/zwww8sXbqUkiVLUqlSJbZv327rO2nSJBo0aMC7775LwYIFad++vS2e9OnTM3v2bJYvX06xYsWYO3cugwcPfmxsLi4ufP/99+zYsYOiRYvStWtXRo0aZdfHw8OD1atXkylTJoKDgylWrBiffPKJXTEPgLZt2xIeHk6bNm3i/R6JiIiICHDtGkycCKVLQ4kSMG4cXL4MWbOaM1YHD8Jvv0Hr1olZijtRWYwHb2YRbt68SZo0abhx4wZ+fn52j4WGhnL8+HG7vZQSk9Vq5ebNm/j5+an0twMNGzaMH374gT179jjlmCT159LZREREsHz5coKDg3F/htZlJ1caD+ejMXE+GhPnovFIRFFRsG4dzJgBP/4IYWFmu7s71KkDbdpA1argZl8KwpnG5FG5wYNU0ELkEW7fvs2JEyeYMGECH330kaPDEREREXk2HDsGM2eaX6dO3WsvXhzatoVmzSBjRkdFl2iUXIk8QqdOnZg7dy5169bVkkARERGRRwkJMYtTTJ8OGzbca0+XDt56y1zu99xzZqntZErJlcgjzJw5M07FM0RERERSJMOAbdvMhOr77+9V97NYoFo1M6GqUwdSyG0LSq5ERERERCR+zp+HWbPMpOqff+6158ljJlQtW5ql1VMYJVciIiIiIvJ4ERHw889mQrV8uVmsAsDHxyyn3qYNvPIKOEnBL0dQciUiIiIiIg+3b5+ZUM2eDRcv3msvW9ZMqBo1gsdU0UsplFyJiIiIiIi969fNe6hmzID79iYlIABatDCX/hUs6LDwnJWSKxERERERAasVfvnFTKgWLoTQULPdzQ1q1TJnqV5/PcaeVHKP3hkRERERkZTsxAn45hszqfr333vtRYqYe1K99RZkyuSw8J4lSq5ERERERFKau3dh0SIzoVq37l57mjTmBr+tW0Pp0sl6T6rEkHJLeaRArVq1wmKxYLFYcHd3J3PmzFStWpXp06djtVrjda6ZM2fazmWxWPD19aVUqVIsWrQoRt+ffvqJChUqkDp1anx8fHjhhRfs9o4aPHiw3bli+3qcggUL4unpyfnz5+P1OkRERERSDMMw75/q2BGyZIHmze8lVlWqwHffwblz8OWX8MILSqyegJKrFOb111/n3LlznDhxghUrVlCxYkU++OADatasSWRkZLzO5efnx7lz5zh37hx//fUX1atXp1GjRhw8eNDWZ/z48dSpU4dy5cqxbds29uzZQ5MmTejQoQM9evQAoEePHrbznDt3jmzZsjF06FC7tkfZtGkTd+/epUGDBnzzzTfxf1MSWEREhKNDEBEREbnn4kUYMwaKFYMyZWDyZLhxA3LlgsGD4fhxWLPGnLHy9nZ0tM80JVcJwTDgzp2k/zKMeIfq6elJQEAAgYGBPP/88/Tr148lS5awYsUKu9mk69ev065dO/z9/fHz86NSpUrs3r3b7lwWi4WAgAACAgLIly8fH330ES4uLuzZsweAU6dO0b17d7p06cLHH39M4cKFyZs3L927d2fUqFGMHj2abdu24evraztPQEAArq6upE6d2q7tUaZNm0azZs14++23mT59eozHT58+TdOmTUmfPj2pUqWidOnSbNu2zfb4smXLeOGFF/Dy8iJjxozUq1fP7jUuXrzY7nzp06dnzpw5AJw4cQKLxcK8efOoUKECXl5efPfdd1y5coWmTZsSGBiIj48PxYoVY+7cuXbnsVqtfPrpp+TNmxdPT09y5MjB8OHDAahUqRKdOnWy63/p0iU8PDxYd//UvYiIiEhsIiNh2TKoVw8CA6F7d7OkupeXeQ/VunVw9CgMGmQmWZIgdM9VQggJAV/fRDm1C5D2YQ/evg2pUj31NSpVqkSJEiVYtGgR7dq1A6Bhw4Z4e3uzYsUK0qRJw5QpU6hcuTKHDh0iffr0Mc4RFRXFt99+C8Dzzz8PwIIFC4iIiLDNUN3vf//7H/369WPu3LmUKVPmiWO/desWP/zwA9u2baNgwYLcuHGD3377jVdeeQWA27dvU6FCBQIDA1m6dCkBAQHs3LnTtgzy559/pl69enz44Yd8++23hIeHs3z58njH0adPH0aPHs1zzz2Hl5cXoaGhlCpVit69e+Pn58fPP//M22+/TVBQEC+++CIAffv2ZerUqXz++eeUL1+ec+fO8c9/O5y3a9eOTp06MXr0aDw9PQGYPXs2gYGBVKpU6YnfLxEREUnmDhww76P69lu4cOFe+4svmtX+GjeGtGkdFl5yp+RKAPOepegZp02bNrF9+3YuXrxo+8X+s88+Y/HixSxYsIB33nkHgBs3buD7X1J59+5d3N3d+eqrrwgKCgLg0KFDpEmThixZssS4noeHB3ny5OHQoUNPFff3339Pvnz5KFKkCABNmjRh2rRptuRqzpw5XLp0iT/++MOWFObNm9f2/OHDh9OkSROGDBliaytRokS84+jSpQv169e3a7s/qXz//fdZtWoV8+fP58UXX+TWrVuMGzeOCRMm0LJlSwCCgoIoX748APXr16dTp04sWbKERo0aAeZ9btH3zYmIiIjY3LwJ8+aZG/3+/vu9dn//e3tS/fe7kiQuJVcJwcfHnEVKBFarlZs3b+Ln54eLywOrOH18Euw6hmHYfmnfvXs3t2/fJkOGDHZ97t69y9GjR23HqVOnZufOnQCEhISwdu1aOnToQIYMGahVq1aCxfYo06dPp3nz5rbj5s2bU6FCBcaPH0/q1KnZtWsXzz33XKyzbQC7du2iffv2Tx1H6dKl7Y6joqL4+OOPmT9/PmfOnCE8PJywsDB8/huzAwcOEBYWRuXKlWM9n5eXl22ZY6NGjdi5cyd///03S5cufepYRUREJBmwWuHXX82EasECs/ofgKsr1KhhzlIFB4O7u2PjTGGUXCUEiyVBlufFymqFqCjz/A8mVwnowIED5M6dGzCX0mXJkoUNGzbE6Jf2vmlkFxcXu1mg4sWLs3r1akaOHEmtWrXInz8/N27c4OzZs2TNmtXuPOHh4Rw9epSKFSs+ccz79+/n999/Z/v27fTu3dvWHhUVxffff0/79u3xfsxNmY973GKxYDxwb1tsBStSPTD+o0aNYty4cYwdO5ZixYqRKlUqunTpQnh4eJyuC+bSwJIlS3L69GlmzJhBpUqVyJkz52OfJyIiIsnYyZPmnlQzZ8KxY/faCxUyE6rmzeEx96tL4lFBC2H9+vXs3buXN998EzDvmTp//jxubm7kzZvX7itjxoyPPJerqyt3//vLyZtvvom7uzujR4+O0W/y5MncuXOHpk2bPnHc06ZN49VXX2X37t3s2rXL9tWtWzemTZsGmAnfrl27uHr1aqznKF68+CMLRPj7+9tVKzx8+DAhISGPjW3z5s3UqVOH5s2bU6JEiRhLIPPly4e3t/cjr12sWDFKly7N1KlTmTNnDm3atHnsdUVERCQZCg2F77+H6tXN4hMDB5qJVerU8M47sHWrWayiRw8lVg6mmasUJiwsjPPnzxMVFcWFCxdYuXIlI0aMoGbNmrRo0QKAKlWqULZsWerWrcunn35K/vz5OXv2rK34Q/QSOMMwbPtK3b17lzVr1rBq1SoGDhwIQI4cOfj000/p3r27bZmbu7s7S5YsoV+/fnTv3v2Ji1lEREQwa9Yshg4dStGiRe0ea9euHWPGjGHfvn00bdqUjz/+mLp16zJixAiyZMnCX3/9RdasWSlbtiyDBg2icuXKBAUF0aRJEyIjI1m+fLltJqxSpUpMmDCBsmXLEhUVRe/evXGPw/R6vnz5WLBgAVu2bCFdunSMGTOGCxcuULhwYcBc9te7d2969eqFh4cH5cqV49KlS+zbt4+2bdvavZZOnTqRKlUquyqGIiIikswZBuzcaRan+O47uH793mMVK5r3Ub35ZoLeJiJPT8lVCrNy5UqyZMmCm5sb6dKlo0SJEnzxxRe0bNnSdk+XxWJh+fLlfPjhh7Ru3ZpLly4REBDAq6++SubMmW3nunnzpq1YhaenJzlz5mTo0KF2S/S6dOlCnjx5+Oyzzxg3bhxRUVEUKVKESZMm0bp16yd+HUuXLuXKlSuxJhyFChWiUKFCTJs2jTFjxrB69Wq6d+9OcHAwkZGRFC5cmIkTJwLw2muv8cMPPzBs2DA++eQT/Pz8ePXVV23nGj16NK1bt+aVV14ha9asjBs3jh07djw2vv79+3Ps2DGqV6+Oj48P77zzDnXr1uXGjRu2PgMGDMDNzY2BAwdy9uxZsmTJQocOHezO07RpU7p06ULTpk3x8vJ60rdLREREnhWXL5vJ1PTp8F+xMQCyZ4dWrcyvPHkcFZ08hsV48IYS4ebNm6RJk4YbN27g5+dn91hoaCjHjx8nd+7cSfLL7iMLWohDJOWYnDhxgqCgIP744w9bifvYJPXn0tlERESwfPlygoOD4zSzKIlL4+F8NCbOR2PiXBw+HpGRsHq1mVAtXQrR93d7epr7VLVpA5UqmcUqUgiHj8l9HpUbPEgzVyJOKCIigitXrtC/f39eeumlRyZWIiIi8ow6dMhc9vfNN3DfPd6UKmUmVE2bQrp0jotP4k3JlYgT2rx5MxUrViR//vwsWLDA0eGIiIhIQrl1C374wZyl2rz5XnuGDPD22+a9VMWLOy4+eSpKrkSc0GuvvRajBLyIiIg8owwDNm0yE6offoA7d8x2Fxd44w1zlqpmTfDwcGyc8tSUXImIiIiIJIYzZ8wlfzNmwJEj99rz5zcTqrffhgf2ApVnm5KrJ6RZBXEm+jyKiIg4ibAwsyjFjBmwahVYrWa7ry80bmwu+3v5ZbBYHBunJAolV/EUXa0kJCQEb29vB0cjYore2NjR1XRERERSrF27zIRq9my4evVe+6uvmglVgwZmgiXJmpKreHJ1dSVt2rRcvHgRAB8fHyyJ+JcHq9VKeHg4oaGhKsXuJJxpTAzDICQkhIsXL5I2bVpcU1CJVhEREYe7ehXmzDHvpfrrr3vtgYHQsqW5J1W+fA4LT5KekqsnEBAQAGBLsBKTYRjcvXsXb2/vRE3iJO6ccUzSpk1r+1yKiIhIIoqKgrVrzYRq8WIIDzfbPTygTh3zXqqqVVPUnlRyj5KrJ2CxWMiSJQuZMmUiInqTt0QSERHBr7/+yquvvqolX07C2cbE3d1dM1YiIiKJ7cgRmDnTLFBx+vS99pIlzYSqWTOznLqkaA5PriZOnMioUaM4f/48JUqUYPz48bz44oux9o2IiGDEiBF88803nDlzhgIFCjBy5Ehef/11u35nzpyhd+/erFixgpCQEPLmzcuMGTMoXbp0gsbu6uqa6L/Uurq6EhkZiZeXl1P8Ii8aExERkRTjzh1YsMCcpfr113vt6dJB8+bmvVTPPee4+MTpODS5mjdvHt26dWPy5MmUKVOGsWPHUr16dQ4ePEimTJli9O/fvz+zZ89m6tSpFCxYkFWrVlGvXj22bNnCc/99sK9du0a5cuWoWLEiK1aswN/fn8OHD5NOu1uLiIiIyOMYBmzdaiZU8+bB7dtmu8UC1aubCVXt2uDl5dg4xSk5NLkaM2YM7du3p3Xr1gBMnjyZn3/+menTp9OnT58Y/WfNmsWHH35IcHAwAB07dmTt2rWMHj2a2bNnAzBy5EiyZ8/OjBkzbM/LnTt3ErwaEREREXlWeV69isuoUfDtt3Dw4L0HgoLMhKpFC8ie3XEByjPBYclVeHg4O3bsoG/fvrY2FxcXqlSpwtatW2N9TlhYGF4P/JXA29ubTZs22Y6XLl1K9erVadiwIRs3biQwMJB3332X9u3bPzSWsLAwwsLCbMc3b94EzGWIiX1P1eNEX9/Rccg9GhPnozFxLhoP56MxcT4aEydy+TKWXr2oNmcOLv/tSWX4+GC8+SbWVq0wype/tyeVxivJONP3SHxisBgO2n307NmzBAYGsmXLFsqWLWtr79WrFxs3bmTbtm0xntOsWTN2797N4sWLCQoKYt26ddSpU4eoqChbchSdfHXr1o2GDRvyxx9/8MEHHzB58mRatmwZayyDBw9myJAhMdrnzJmDj49PQrxcEREREXEmhkH29espMnMmnrduAXClYEFOVq7M2fLlidR+pvKfkJAQmjVrxo0bN/Dz83tk32cqubp06RLt27dn2bJlWCwWgoKCqFKlCtOnT+fu3bsAeHh4ULp0abZs2WJ7XufOnfnjjz8eOSP24MxV9uzZuXz58mPfwMQWERHBmjVrqFq1qoonOAmNifPRmDgXjYfz0Zg4H42Jg/3zD66dOuHyX5EKa9GibGrenNLvv6/xcBLO9D1y8+ZNMmbMGKfkymHLAjNmzIirqysXLlywa79w4cJD9+vx9/dn8eLFhIaGcuXKFbJmzUqfPn3IkyePrU+WLFkoXLiw3fMKFSrEwoULHxqLp6cnnp6eMdrd3d0dPpjRnCkWMWlMnI/GxLloPJyPxsT5aEySWGgojBgBn3xi7k/l7Q1DhhD13ntcW7NG4+GEnGFM4nN9l0SM45E8PDwoVaoU69ats7VZrVbWrVtnN5MVGy8vLwIDA4mMjGThwoXUqVPH9li5cuU4eP9NiMChQ4fImTNnwr4AEREREXl2rF8PxYvD0KFmYhUcDPv3Q8+eoIRKEohDqwV269aNli1bUrp0aV588UXGjh3LnTt3bNUDW7RoQWBgICNGjABg27ZtnDlzhpIlS3LmzBkGDx6M1WqlV69etnN27dqVl19+mY8//phGjRqxfft2vvrqK7766iuHvEYRERERcaBLl6BHD7MKIECWLPDFF/Dmm/cKVYgkEIcmV40bN+bSpUsMHDiQ8+fPU7JkSVauXEnmzJkBOHnyJC4u9ybXQkND6d+/P8eOHcPX15fg4GBmzZpF2rRpbX1eeOEFfvzxR/r27cvQoUPJnTs3Y8eO5a233krqlyciIiIijmIYMHOmmVhdvWomUu++C8OHQ5o0jo5OkimHJlcAnTp1olOnTrE+tmHDBrvjChUqsH///sees2bNmtSsWTMhwhMRERGRZ80//8D//gf/FaygeHH46isoU8axcUmy57B7rkREREREElRoKAwaZCZTv/4KPj4wahT8+acSK0kSDp+5EhERERF5auvXQ4cOcPiweRwcDBMnQq5cDg1LUhbNXImIiIjIs+vSJWjRAipXNhOrLFnghx/gp5+UWEmSU3IlIiIiIs8ew4Dp06FgQZg1yyxY8d57cOAANGigSoDiEFoWKCIiIiLPlgMHzCWA0QUrSpQwC1a8+KJj45IUTzNXIiIiIvJsCA2FgQPNZCq6YMVnn5kFK5RYiRPQzJWIiIiIOL9166Bjx3sFK2rUMAtW5Mzp2LhE7qOZKxERERFxXtEFK6pUuVewYsECWLZMiVUyFhUFV654OTqMeNPMlYiIiIg4H6sVZsyAXr3g6tV7BSs++gjSpHF0dJKAbtyAPXtg9+57X3//7YaPz6u8/bajo4sfJVciIiIi4lz27zcLVvz2m3msghXJgtUKx47ZJ1F79sCJE7H1tmC1unPzpkGGDEkc6FNQciUiIiIiziE0FIYPh5EjISLCLFgxbBh07gxu+rX1WXL7Nuzda59I7d1rtscme3Yzh47+KlQogkOHluPnF5y0gT8lfUpFRERExPHWrjULVhw5Yh7XrAkTJui+KidnGPDvv/ZJ1O7dcPRo7P09PaFoUShe/F4iVbw4pE9v3y8i4uHncGZKrkRERETEcS5ehO7dYfZs8zhrVvjiC6hfXxsBO5mQEPj7b/v7o/bsMe+Zik2WLPazUSVKQP78yXsSMhm/NBERERFxWtEFK3r2hGvXzESqUyezYIWfn6OjS9EMA86ciTkbdfiwOWwPcneHwoXvzUJFJ1L+/kkfu6MpuRIRERGRpPVgwYqSJWHKFBWscIDQUHM47p+J2r3bLNAYG3//mLNRBQuCh0fSxu2slFyJiIiISNK4e9csWPHppypY4QDnz8ecjfrnH3NPqQe5uppJ04OJVObMWq35KPoUi4iIiEjiW7vWnK2KrlJQqxaMH6+CFYkgPNxMmh4seX7xYuz906ePuaSvcGHwevb28HU4JVciIiIiknguXoRu3eC778zjrFnNpKpePU2BJIBLl2JuwLt/vzkx+CAXF8iXL+ZsVGCghiKhKLkSERERkYRntcL06dCrlwpWJIDISDh0KOayvnPnYu/v52efQBUvbpZA9/FJ2rhTGiVXIiIiIpKw9u+H//0PNm0yj597zixY8cILjo3rGXHtmn1xid27Yd8+s/hEbPLmtV/SV6KEudpSs1FJT8mViIiIiCSMBwtWpEplFqx4/30VrIhFVJR5C9qDs1GnTsXeP1WqmElUsWLg65u0ccvD6VMuIiIiIk9vzRro2NG+YMWECZAjh2PjchI3b96biYr+79695sa8scmVy35JX4kSkCePed+UOC8lVyIiIiLy5B4sWBEYaBasqFs3Ra5Ls1rhxImYs1HHj8fe39vbvBfqwfuj0qRJ0rAlgSi5EhEREZH4i61gxfvvm8sAU0jBijt3zNmn+5OovXvh1q3Y+2fLFrNSX9685p5SkjwouRIRERGR+Nm3zyxYsXmzeZzMC1YYBpw8GbPk+ZEj5mMP8vSEIkXs748qXhwyZEj62CVpKbkSERERkbi5e9cspf7pp2Zt8GRYsOLuXTN3fHAD3uvXY+8fEBBzNip/fnB3T9KwxUkkj+8CEREREUlcq1ebBSuOHTOPa9c27616hgtWhIXBzp2waZMLy5aVok8fNw4dMlc8PsjNDQoXjnlvVKZMSR+3OC8lVyIiIiLycBcumAUr5swxjwMDzSqAdes6NKwncfYsbNkCW7eaXzt2QHg4gCuQzdYvY8aYs1GFCoGHh6Mil2eFkisRERERiclqhWnTzIIV16+bNcCjC1akTu3o6B4rIgJ27bqXSG3ZYt439SB/f3jpJStp0vxD48b5KVXKjYCAFFnoUBKAkisRERERsfdgwYrnnzcLVpQu7di4HuHixXtJ1Nat8Oef5v1T93NxMZfylS0LL79s/jdPHoiMjGL58sNUr55P90rJU1FyJSIiIiKmu3fNmalRo+4VrPjoI+jUyakKVkRGwt9/2y/xi967+H7p08NLL91LpF544ZmYdJNnmPN8l4iIiIiI46xaBe++e69gRZ06ZsGK7NkdGxdw5Qr8/vu9mant2809pu5nsZjlz8uWvTczlT+/lvdJ0lJyJSIiIpKSXbgAXbvC3LnmcbZsZlLloIIVVivs32+/xO/gwZj9/PzMWanoRKpMGUiTJunjFbmfkisRERGRlMhqha+/ht697xWs6NwZhg5N0rVzN27Atm33Eqlt28y2BxUoYH+vVOHCZsgizkTJlYiIiEhK8/ffZsGKLVvM4+efh6++glKlEvWyhmHOQt1fwW//frP9fqlSmTNR0Uv8XnoJMmRI1NBEEoSSKxEREZGUIiTELFARXbDC19c8fu+9RClYcfu2eX9UdCL1++9w9WrMfkFB9vdKFS3qVPUzROJMH1sRERGRlODBghV168IXXyRYwQrDME99/71Se/aYqw/v5+VlVu2LXt5XtixkypQgIYg4nJIrERERkeTs/HmzYMX335vHCVSwIiTE3Esqeonf1q3mXlMPypHjXiL18stQogTaS0qSLSVXIiIiIsmR1QpTp5oFK27ceKqCFYYBJ0/a3yu1a5e5svB+Hh7mbVv3F57ImjXhXpKIs1NyJSIiIpLcPFiwolQps2DF88/H6elhYbBzp/0mvWfPxuyXNat9IvX88+DpmYCvQ+QZo+RKREREJLkICYFhw+Czz+4VrBg+3CxY4er60KedPXsvkdqyxUyswsPt+7i5QcmS9vdK5cihTXpF7qfkSkRERCQ5WLnSLFhx/Lh5XK+eWbAiWza7bhER5pK++wtPnDwZ83SZMtlX8CtVCnx8Ev9liDzLlFyJiIiIPMtiK1gxYQLUqQOYRSbuT6T+/BPu3rU/hYsLFC9uv8QvTx7NSonEl5IrERERkWdRLAUrrO9/wN8Nh7Bpd2q2vm0mU0ePxnxq+vT3ZqXKloUXXzRXEIrI01FyJSIiIvKs2bvXLFixdSsAZwJKMTTbV3z39fPcGWff1WKBIkXsl/jlz69ZKZHEoORKRERE5BlgtcKBHSFEDBxG0VWf4WZEcgtf+vExX55/F+t5s2CFnx+89NK9RKpMGUiTxsHBi6QQSq5EREREnND167Bt271S6Kk2reSzkHcpglmwYiH1+YBx+BbIRov77pUqXNi8h0pEkp6SKxEREREHMww4eNB+k979+832AM7xOV1pwjwALnhmZ03tCaRrWZvdL0GGDA4OXkRslFyJiIiIJLHbt2HPnozs3u3Ctm3w++9w9ap9HwtW+mf8ij43+pAq4gaGiwtG5y5kHjaE5qo+IeKUlFyJiIiIJKEvv4Tu3d0IDS1n1+7lBS+8YC7vq5ZlL6/Megf3Hb+bD5YujWXKFCzPP++AiEUkrpRciYiIiCSBiAj44AOYNAnAQsaMIVSq5EW5ci68/DKUKAHuESEwdCj0GA2RkZA6NQwfbm4O7Orq6JcgIo+h5EpEREQkkV25Ag0bwi+/mCXQhw+PolChNdSoEYy7+3/VJ1asMJOoEyfM4/r1Ydw4c1NgEXkmqJaMiIiISCLav9/cpPeXX8yNepcuhR49rPf2mTp3Dho3huBgM7HKkcPstHChEiuRZ4ySKxEREZFEsny5uefUsWOQO7dZCbBmzf8etFpxmTIFChaE+fPN+undu8O+fVCrlkPjFpEno2WBIiIiIgnMMGD0aOjVy/x3hQqwYAFkzPhfhz17eKVvX1wPHjSPX3gBpkyB555zWMwi8vQ0cyUiIiKSgMLCoHVr6NnTTKzeeQdWr/4vsQoLgwEDcHvpJdIfPIiROjWMH29OaSmxEnnmaeZKREREJIFcuAD16pm5kqsrjB0L771nFrFgxw5o1Qr+/hsLcPall/CfOxf3XLkcGrOIJBwlVyIiIiIJ4K+/oE4dOHUK0qY1b6OqWhVztmrYMPjkE4iKAn9/Ir/4gj+8vQkODHR02CKSgLQsUEREROQpLVwI5cubiVX+/LBt23+J1Z9/QunS5l5VUVFmVcB9+zDefNPRIYtIIlByJSIiIvKEDMOclGrQAEJCoFo1M7HKnzMMPvzQLBX499+QKZNZ0eL778Hf39Fhi0gi0bJAERERkScQEmIWrpg/3zzu0gVGjQK3XX+a91bt22c+0KSJWbTCVipQRJIrJVciIiIi8XT6NNSta9aocHeHL7+Edm+HwcAh8Omn5hLATJlg0iSoX9/R4YpIElFyJSIiIhIP27aZidX58+Zk1MKF8Kr3H/B8K9i/3+yk2SqRFEn3XImIiIjE0XffmRsCnz8PRYvCH5vCeHVFX/Peqv37zdmqhQth7lwlViIpkFMkVxMnTiRXrlx4eXlRpkwZtm/f/tC+ERERDB06lKCgILy8vChRogQrV6606zN48GAsFovdV8GCBRP7ZYiIiEgyZbVC377QvLlZWb12bfj9i+3kqv+8WWLdaoVmzcwES8sARVIshy8LnDdvHt26dWPy5MmUKVOGsWPHUr16dQ4ePEimTJli9O/fvz+zZ89m6tSpFCxYkFWrVlGvXj22bNnCc/ftbF6kSBHWrl1rO3Zzc/hLFRERkWfQrVtmUrV0qXk8oGcoQyyDsVQZZSZVmTPD5MnmWkERSdEcPnM1ZswY2rdvT+vWrSlcuDCTJ0/Gx8eH6dOnx9p/1qxZ9OvXj+DgYPLkyUPHjh0JDg5m9OjRdv3c3NwICAiwfWXU1LyIiIjE0/Hj8PLLZmLl6Qkrhmxn6E/PY/l05L3Zqn37lFiJCODgmavw8HB27NhB3759bW0uLi5UqVKFrVu3xvqcsLAwvLy87Nq8vb3ZtGmTXdvhw4fJmjUrXl5elC1blhEjRpAjR46HnjMsLMx2fPPmTcBcghgREfFEry2hRF/f0XHIPRoT56MxcS4aD+ejMXkyv/1moXFjVy5ftpAz8102VR1E4JDRYLViZM5M1IQJGHXqmJ3j+d5qTJyLxsP5ONOYxCcGi2EYRiLG8khnz54lMDCQLVu2ULZsWVt7r1692LhxI9u2bYvxnGbNmrF7924WL15MUFAQ69ato06dOkRFRdkSpBUrVnD79m0KFCjAuXPnGDJkCGfOnOHvv/8mderUMc45ePBghgwZEqN9zpw5+Pj4JOArFhERkWfBmjU5mDKlBJGRLtQPXMu0qDakPX8KgFMVKrC3XTsiYvmdQkSSn5CQEJo1a8aNGzfw8/N7ZN9nLrm6dOkS7du3Z9myZVgsFoKCgqhSpQrTp0/n7t27sV7n+vXr5MyZkzFjxtC2bdsYj8c2c5U9e3YuX7782DcwsUVERLBmzRqqVq2Ku7u7Q2MRk8bE+WhMnIvGw/loTOIuMhJ693Zh/HhXPAllXoGB1D48GovVihEQYM5W1a791NfRmDgXjYfzcaYxuXnzJhkzZoxTcuXQZYEZM2bE1dWVCxcu2LVfuHCBgICAWJ/j7+/P4sWLCQ0N5cqVK2TNmpU+ffqQJ0+eh14nbdq05M+fnyNHjsT6uKenJ56enjHa3d3dHT6Y0ZwpFjFpTJyPxsS5aDycj8bk0a5fh8aNYfVqKMPv/JSxNRkP/mM+2Lw5lnHjcEufPkGvqTFxLhoP5+MMYxKf6zu0oIWHhwelSpVi3bp1tjar1cq6devsZrJi4+XlRWBgIJGRkSxcuJA60WueY3H79m2OHj1KlixZEix2ERERST4OHYIyZWDj6lDGuPViq0s5Ml7+BwICYMkSmDULEjixEpHkx+HVArt168bUqVP55ptvOHDgAB07duTOnTu0bt0agBYtWtgVvNi2bRuLFi3i2LFj/Pbbb7z++utYrVZ69epl69OjRw82btzIiRMn2LJlC/Xq1cPV1ZWmTZsm+esTERER57ZmjZlYpTv0O3vdnqNr5CgsViu8/bZZCTABlgGKSMrg8M2fGjduzKVLlxg4cCDnz5+nZMmSrFy5ksyZMwNw8uRJXFzu5YChoaH079+fY8eO4evrS3BwMLNmzSJt2rS2PqdPn6Zp06ZcuXIFf39/ypcvz++//46/v39SvzwRERFxUoYBEyZA3y53GWQdSDfG4BpphSxZYMoUqFXL0SGKyDPG4ckVQKdOnejUqVOsj23YsMHuuEKFCuzfv/+R5/v+++8TKjQRERFJhsLDoVMn2Dt1K3/SmoIcNB9o0QLGjoV06Rwan4g8mxy+LFBEREQkKV2+DDUq3SX/1B5sphwFOYiRJQssWwbffKPESkSemFPMXImIiIgkhb//hsHVtjDhXGsKcMhsbNECi2arRCQBKLkSERGRFOHnBXc51qw/8yM+xwWDiExZcZ82BWrWdHRoIpJMKLkSERGRZM0wYM57myk9qQ01/putCm3aCq+JYzRbJSIJSsmViIiIJFuhV0PYUL4/TQ+MxQWD66my4vvdV3jVqeHo0EQkGVJBCxEREUmWrizdzMXAkrx+wFwGeOClVqQ9vQ83JVYikkiUXImIiEjyEhLChebdSFfnFXKEHuasJZBdw3+m0NYZcN++mCIiCU3LAkVERCT52LSJWw1bk/n8EQAWpmnNc+vHUPL5tI6NS0RSBM1ciYiIyLMvJASjS1eMV14l9fkjnCaQAaWWU+Xf6eRRYiUiSUQzVyIiIvJs++03rK3b4HLUnK2aRhuOdxrDkLFpcHV1cGwikqJo5kpERESeTXfuQJcuGBUq4HL0CKfIRk3XFbhMn8ZH45VYiUjS08yViIiIPHt++w1at4ajR7EAX9OWERlG8+2SNJQr5+jgRCSlUnIlIiIiz447d6BfPxg/HgyDU2SjHV9zoUR11i+BnDkdHaCIpGRaFigiIiLPhl9/hRIl4IsvwDCYSjuK8jep6lVn0yYlViLieEquRERExLnduQOdO0OFCnD0KBe9slOdlbzDVDr3T8OCBeDr6+ggRUS0LFBERESc2caN0KYNHDsGwIK07Wh7/TPCvdIwdwY0aeLg+ERE7qOZKxEREXE+d+7A++/Da6/BsWOEZspOg9SraHh9Kr5Z0/Drr0qsRMT5aOZKREREnMuGDdC2rW226sAr71BuyyiuRfnxwguweDFkzerQCEVEYqWZKxEREXEOt29Dp05QsSIcO4aRPTsT66ym8G9TuBblR9Om5ipBJVYi4qw0cyUiIiKOt2GDeW/V8eMAhLV8h0b/jmLpEj8Ahg+Hvn3BYnFgjCIij/HUM1dRUVHs2rWLa9euJUQ8IiIikpLcP1t1/DjkyMHJaWsotmUKSzf4kSoV/PijubWVEisRcXbxTq66dOnCtGnTADOxqlChAs8//zzZs2dnw4YNCR2fiIiIJFe//ALFisHEiebx//7H2rF/U7xbFQ4fNvet2rIF6tZ1aJQiInEW7+RqwYIFlChRAoBly5Zx/Phx/vnnH7p27cqHH36Y4AGKiIhIMnP7Nrz3HlSqBCdOQM6cGKvXMLbgZKo3SM2NG1C+PGzfDsWLOzpYEZG4i3dydfnyZQICAgBYvnw5DRs2JH/+/LRp04a9e/cmeIAiIiKSjKxfb85WffmledyhA+E79tJ+XhW6dgWr1bz1au1ayJTJsaGKiMRXvJOrzJkzs3//fqKioli5ciVVq1YFICQkBFdX1wQPUERERJKBW7fg3XehcmXbbBVr13Jp6CSq1EvNtGng4gKffw5ffw2eno4OWEQk/uJdLbB169Y0atSILFmyYLFYqFKlCgDbtm2jYMGCCR6giIiIPOPWrzeno/791zzu2BFGjmTP8dTUfsFs9vODefPg9dcdG6qIyNOId3I1ePBgihYtyqlTp2jYsCGe//1pydXVlT59+iR4gCIiIvKMunULevWCyZPN41y5YNo0qFSJJUvgrbfgzh3ImxeWLQP9jVZEnnVPtM9VgwYNYrS1bNnyqYMRERGRZGLdOmjb9t5s1bvvwsiRGKl8+WQEfPghGIa5SnD+fEif3rHhiogkhHjfc9W5c2e++OKLGO0TJkygS5cuCRGTiIiIPKtu3YIOHaBKFTOxypXLXBY4cSJ3XX1p3tzcs8owzO2tVqxQYiUiyUe8k6uFCxdSrly5GO0vv/wyCxYsSJCgRERE5Bm0di0ULQpTppjH774Le/dCxYqcPQsVKsCcOeDmZq4UHD8e3N0dG7KISEKK97LAK1eukCZNmhjtfn5+XL58OUGCEhERkWfIzZvQsyd89ZV5nDu3eW9VxYoA/Pkn1KkDZ8+as1QLF8JrrzkuXBGRxBLvmau8efOycuXKGO0rVqwgT548CRKUiIiIPCPWrDH3rYpOrDp1gj17bInVvHnwyitmYlW4sLkxsBIrEUmu4j1z1a1bNzp16sSlS5eoVKkSAOvWrWP06NGMHTs2oeMTERERZ3TzJvToAVOnmse5c8P06bbMyWqFQYPgo4/Mh2vUMJcE+vk5JlwRkaQQ7+SqTZs2hIWFMXz4cIYNGwZArly5mDRpEi1atEjwAEVERMTJrF4N7drBqVPmcadOMGIE+PoCZnn1Fi1g0SLz4Z49zYddXR0Ur4hIEnmiUuwdO3akY8eOXLp0CW9vb3z/+2EqIiIiydiDs1V58pizVRUq2Lr8+695f9Xu3eDhYXbV315FJKV4ouQqmr+/f0LFISIiIs5s1Spo3/7ebNX775vTUalS2bps2QL16sHFi5A5M/z4I5Qt66B4RUQcIE7J1fPPP8+6detIly4dzz33HBaL5aF9d+7cmWDBiYiIiIPduGHOVn39tXkcy2wVwMyZ8L//QXg4lCwJS5ZAjhxJHq2IiEPFKbmqU6cOnp6eANStWzcx4xERERFnsWqVeW/V6dPmcefO8PHHdrNVUVHQuzeMHm0ev/kmfPONXRcRkRQjTsnVoEGDAIiKiqJixYoUL16ctGnTJmZcIiIi4ig3bkD37uZeVQBBQeZs1auvxujWrBksX24eDxxoVgh0ifdGLyIiyUO8fvy5urpSrVo1rl27lljxiIiIiCOtXAlFi5qJlcUCH3xgVqd4ILE6csS8n2r5cvD2NvezGjJEiZWIpGzx/hFYtGhRjh07lhixiIiIiKNcvw5t28Ibb5jLAIOCYONGGDs2xhq/9euhTBk4cAACA+G336BRI4dELSLiVOKdXH300Uf06NGDn376iXPnznHz5k27LxEREXnGrFhhzlZNn27OVnXpAnv2wCuvxOg6aRJUqwZXr5oJ1h9/QKlSSR+yiIgzincp9uDgYABq165tVzXQMAwsFgtRUVEJF52IiIgknuvXoVs3mDHDPM6b1/x3+fIxukZEmDnXl1+ax82bm3tYeXklWbQiIk4v3snVL7/8khhxiIiISFJavhzeeQfOnLl3b9Xw4eDjE6Pr1avQsKG5HNBiMbe36tXL/LeIiNwT7+Qqd+7cZM+ePcZeV4ZhcCp6Y0ERERFxTtevQ9eu5sZUAPnymcsBY5mtAvO+qlq14OhR8PWFOXPMYxERiSne91zlzp2bS5cuxWi/evUquXPnTpCgREREJOFZVqyAIkXMxMpiMZcE7tr10MRqxQp46SUzscqVC7ZuVWIlIvIo8Z65ir636kG3b9/GSwuvRUREnM+1azw3bhxu0Uv78+Uz760qVy7W7oYBY8aYS/+sVrMK+4IF4O+fhDGLiDyD4pxcdevWDQCLxcKAAQPwuW9NdlRUFNu2baNkyZIJHqCIiIg8hX//xa1CBXL8+y+GxYKla1cYNizWe6sAwsKgQ4d7qwbbtYOJE8HDI+lCFhF5VsU5ufrrr78Ac+Zq7969eNz3U9bDw4MSJUrQo0ePhI9QREREnsy5c1C5MpZ//+VO5sx4zp+P2wObAd/v4kWoVw+2bDE3A/78c3j/fRWuEBGJqzgnV9FVAlu3bs24cePw8/NLtKBERETkKV25Ym5IdfQoRu7cbOrfn0plyz60++7dULs2nDwJadLA/Pnm00VEJO7iXdBixowZ+Pn5ceTIEVatWsXdu3cBc0ZLREREnMDNm/DGG/D335AlC5ErVhCaIcNDu//4I7z8splY5c8P27YpsRIReRLxTq6uXr1K5cqVyZ8/P8HBwZw7dw6Atm3b0r179wQPUEREROIhJMQs6ffHH5AhA6xdC3nyxNrVMOCjj6B+ffNp1arB779DgQJJHLOISDIR7+SqS5cuuLu7c/LkSbuiFo0bN2blypUJGpyIiIjEQ3g4NGgAv/4Kfn6wahUULhxr17t3oVkzGDDAPP7gA/j5Z0iXLgnjFRFJZuJdin316tWsWrWKbNmy2bXny5ePf//9N8ECExERkXiIioLmzc3Nqby9zUypVKlYu545A3Xrwp9/gpsbfPkltG+ftOGKiCRH8U6u7ty5YzdjFe3q1at4enomSFAiIiISD1armR398INZM33x4oduDLx9u5lYnTtnrhpcuBAqVEjSaEVEkq14Lwt85ZVX+Pbbb23HFosFq9XKp59+SsWKFRM0OBEREXkMw4CuXc1NgV1d4fvvH1qNYu5cC6++aiZWRYuat2UpsRIRSTjxnrn69NNPqVy5Mn/++Sfh4eH06tWLffv2cfXqVTZv3pwYMYqIiMjDDBoEX3xh/nv6dHOjqgdYrTB7diEWLDD/t1+rFnz3HaROnZSBiogkf/GeuSpatCiHDh2ifPny1KlThzt37lC/fn3++usvgoKCEiNGERERic2oUTBsmPnvCROgRYsYXe7cgUaNXFmwID8AffqYpdeVWImIJLx4z1wBpEmThg8//DChYxEREZG4mjIFevUy/z1iBLz3XowuFy5EV2V3wd09iq++MmjV6on+1y8iInEQ55+wJ0+ejFO/HDlyPHEwIiIiEgfffQcdO5r/7tvXnI56wIEDEBwMJ05AhgwGPXtu5q23yiZtnCIiKUyck6vcuXPb/m0YBmAWs7i/zWKxEBUVlYDhiYiIiJ0lS6BlS7OQxXvvwfDhMbps3GhWBLx+HfLmhSVLIjl8+FqShyoiktLEObmyWCxky5aNVq1aUatWLdzctKxAREQkSa1dC40amXtatWhhFrK47w+dAHPmQOvW5n7CZcvC0qWQJg0cPuygmEVEUpA4F7Q4ffo0HTt25Pvvv6dGjRrMmjULDw8PSpQoYfclIiIiiWDLFqhTx8ya6teHadPA5d7/xg0DPv4Y3nrL7NKgAaxbBxkzOjBmEZEUJs7JVUBAAL179+aff/5hwYIFXLt2jTJlyvDSSy8xdepUrFZrYsYpIiKScu3aZd5AFRIC1aub01P3rSCJiIB33oHoWlM9esC8eeDt7ZhwRURSqniXYgcoX74806ZN4/Dhw/j4+NChQweuX7/+xEFMnDiRXLly4eXlRZkyZdi+fftD+0ZERDB06FCCgoLw8vKiRIkSrFy58qH9P/nkEywWC126dHni+ERERBzmn3/MTYFv3IBXXoFFi8DT0/bwrVtmRcCvvzYnsiZMMCu0uzzR/+FFRORpPNGP3i1bttCuXTvy58/P7du3mThxImnTpn2iAObNm0e3bt0YNGgQO3fupESJElSvXp2LFy/G2r9///5MmTKF8ePHs3//fjp06EC9evX466+/YvT9448/mDJlCsWLF3+i2ERERBzqxAmoUgUuXYLnn4dly8DHx/bwmTPw6quwapXZvHhxrBXZRUQkicQ5uTp37hwjR46kYMGC1KtXDz8/PzZv3sz27dvp0KEDLk/4J7IxY8bQvn17WrduTeHChZk8eTI+Pj5Mnz491v6zZs2iX79+BAcHkydPHjp27EhwcDCjR4+263f79m3eeustpk6dSrp06Z4oNhEREYc5exYqVzYzqMKFzQwqTRrbw3v3wksvmSsGM2c2KwTWquW4cEVEJB7VAnPkyEFgYCAtW7akdu3auLu7Y7Va2bNnj12/+MwShYeHs2PHDvr27Wtrc3FxoUqVKmzdujXW54SFheHl5WXX5u3tzaZNm+za3nvvPWrUqEGVKlX46KOPHhlHWFgYYWFhtuObN28C5hLEiIiIOL+exBB9fUfHIfdoTJyPxsS5aDwSwOXLuFWpguXYMYw8eYhcvtxMrP57T9eutdC4sSu3blkoWNBg6dJIcuWyPRyDxsT5aEyci8bD+TjTmMQnBosRvWnVY9w/MxW9v9WDT43vPldnz54lMDCQLVu2ULbsvY0Ne/XqxcaNG9m2bVuM5zRr1ozdu3ezePFigoKCWLduHXXq1CEqKsqWIH3//fcMHz6cP/74Ay8vL1577TVKlizJ2LFjY41j8ODBDBkyJEb7nDlz8Llv+YWIiEhicwsJodyAAaQ9epS76dOzacQIQjJntj2+bl0OvvyyBFFRLhQpcpm+fbfj6+v4Xz5ERJKrkJAQmjVrxo0bN/Dz83tk3zjPXB0/fvypA0sI48aNo3379hQsWBCLxUJQUBCtW7e2LSM8deoUH3zwAWvWrIkxw/Uwffv2pVu3brbjmzdvkj17dqpVq/bYNzCxRUREsGbNGqpWrYq7u7tDYxGTxsT5aEyci8bjKYSE4FqzJi5Hj2JkzIjbunW8VqgQYJZaHzLEhfHjXQFo2tTKV1+lwdOz6mNPqzFxPhoT56LxcD7ONCbRq9riIs7JVc6cOZ8omEfJmDEjrq6uXLhwwa79woULBAQExPocf39/Fi9eTGhoKFeuXCFr1qz06dOHPHnyALBjxw4uXrzI888/b3tOVFQUv/76KxMmTCAsLAxXV1e7c3p6euJ5X+WlaO7u7g4fzGjOFIuYNCbOR2PiXDQe8RQWBo0bw6ZNkCYNltWrcf9vqX14OLRrB7NmmV0//BCGDXPBYonf/c4aE+ejMXEuGg/n4wxjEp/rO7RQq4eHB6VKlWLdunW2NqvVyrp16+yWCcbGy8uLwMBAIiMjWbhwIXXq1AGgcuXK7N27l127dtm+SpcuzVtvvcWuXbtiJFYiIiIOFxlp7v4bXfbv55/huecAuH4dXn/dTKxcXWHqVPjoI/hvhb6IiDiROM9cJZZu3brRsmVLSpcuzYsvvsjYsWO5c+cOrVu3BqBFixYEBgYyYsQIALZt28aZM2coWbIkZ86cYfDgwVitVnr16gVA6tSpKVq0qN01UqVKRYYMGWK0i4iIOJzVCu3bw8KF4OFh1lMvVw6Af/+FGjVg3z7w9YUFC8w9hEVExDk5PLlq3Lgxly5dYuDAgZw/f56SJUuycuVKMv938+7JkyftimmEhobSv39/jh07hq+vL8HBwcyaNeuJ99kSERFxGMOALl1g5kxzWmrePKhq3kO1c6eZWJ0/D4GB5mRWiRIOjVZERB7D4ckVQKdOnejUqVOsj23YsMHuuEKFCuzfvz9e53/wHCIiIk5hwAAYP97898yZULcuYCZSjRvDnTtQvLh5nC2bw6IUEZE4eqJ7riIjI1m7di1Tpkzh1q1bgFlW/fbt2wkanIiISLI1ciQMH27++8svoXlzACZNgtq1zcSqalX47TclViIiz4p4z1z9+++/vP7665w8eZKwsDCqVq1K6tSpGTlyJGFhYUyePDkx4hQREUk+vvwS+vQx/z1yJHTsiNVqNo0aZTa3aQOTJ4MKl4mIPDviPXP1wQcfULp0aa5du4a3t7etvV69enZV/0RERCQWs2bBe++Z//7wQ+jVi9BQaNr0XmI1bBh8/bUSKxGRZ028Z65+++03tmzZgoeHh117rly5OHPmTIIFJiIikuz8+CP8Vw2X99+HYcO4csW81WrTJjOZmj7dtkJQRESeMfFOrqxWK1FRUTHaT58+TerUqRMkKBERkWRnzRpo0gSioqBVKxg7lqPHLAQHw6FDkCaNmXtVrOjoQEVE5EnFe1lgtWrVGDt2rO3YYrFw+/ZtBg0aRHBwcELGJiIikjxs3mxOT4WHQ4MGMHUqv293oWxZM7HKmRO2bFFiJSLyrIv3zNXo0aOpXr06hQsXJjQ0lGbNmnH48GEyZszI3LlzEyNGERGRZ9fOnRAcDCEh8Prr8N13/LjMjWbNIDQUSpWCn36CgABHByoiIk8r3slVtmzZ2L17N/PmzWP37t3cvn2btm3b8tZbb9kVuBAREUnxDhyA6tXh5k145RVYuJCxX3rQrZu5f3DNmjB3Lvj6OjpQERFJCE+0ibCbmxtvvfUWb731VkLHIyIikjwcPw5VqsDly1C6NFFLfqJbXx+++MJ8uGNH+OILcHui/xOLiIgzivc9VyNGjGD69Okx2qdPn87IkSMTJCgREZFn2pkzULkynD0LRYoQsmglb7b2syVWn34KEycqsRIRSW7inVxNmTKFggULxmgvUqSINhAWERG5fBmqVjVnroKCuDx3DRUbZGDJEvD0hHnzoGdPsFgcHaiIiCS0eP/N7Pz582TJkiVGu7+/P+fOnUuQoERERJ5JN26Y91gdOACBgRydspaqdbJw/DhkyABLlkC5co4OUkREEku8Z66yZ8/O5s2bY7Rv3ryZrFmzJkhQIiIiz5w7d6BGDbM6oL8/f36ylhca5oqewGLrViVWIiLJXbxnrtq3b0+XLl2IiIigUqVKAKxbt45evXrRvXv3BA9QRETE6YWFQf365n5WadKwsttq6rQtSHg4vPQSLF0K/v6ODlJERBJbvJOrnj17cuXKFd59913Cw8MB8PLyonfv3vTt2zfBAxQREXFqkZHQrBmsXo2RKhWzmq6gZd+SgJlvzZ4N2qlERCRliHdyZbFYGDlyJAMGDODAgQN4e3uTL18+PD09EyM+ERER52W1Qtu2sGgRhocHY19bQrfJZQHo2hVGjQJXVwfHKCIiSeaJi8D6+vrywgsvJGQsIiIizw7DgM6d4dtvMVxdGVZ0PoN+rozFAuPGwfvvOzpAERFJavFOru7cucMnn3zCunXruHjxIlar1e7xY8eOJVhwIiIiTuvDD2HiRAyLhf7ZvuHjnXXw9oa5c6FOHUcHJyIijhDv5Kpdu3Zs3LiRt99+myxZsmDRRh0iIpLSjBhhfgH90k7ik3/fIlMmWLYMXnzRwbGJiIjDxDu5WrFiBT///DPlVE9WRERSookToV8/APp7juKTa/+jQAFYsQJy53ZwbCIi4lDx3ucqXbp0pE+fPjFiERERcW7ffAOdOgHwkWUAw8N68OqrsGWLEisREXmC5GrYsGEMHDiQkJCQxIhHRETEOS1ciNGmDQBj+YABxhCaNoXVq0F/cxQREXiCZYGjR4/m6NGjZM6cmVy5cuHu7m73+M6dOxMsOBEREaewahVG06ZYrFam0YZujKFvXwsffQQu8f4zpYiIJFfxTq7q1q2bCGGIiIg4qU2bMOrVwxIRwXwa0tHlKyZPcuGddxwdmIiIOJt4J1eDBg1KjDhEREScz44dWINr4HL3Lst5gw6pZrPkB1feeMPRgYmIiDN64k2ERUREkrX9+4msUh23WzfZQAXez7KQ9cs9KFnS0YGJiIizindyFRUVxeeff878+fM5efIk4eHhdo9fvXo1wYITERFxiGPHCH2lCl7Xr7CdF+hTaCkbVnmTPbujAxMREWcW79twhwwZwpgxY2jcuDE3btygW7du1K9fHxcXFwYPHpwIIYqIiCShM2e4+WJlvK6eYy9F+eTVFaza6qfESkREHiveydV3333H1KlT6d69O25ubjRt2pSvv/6agQMH8vvvvydGjCIiIknCeuESF4tXwe/KCQ6Tl2mNVvP9mgykSePoyERE5FkQ7+Tq/PnzFCtWDABfX19u3LgBQM2aNfn5558TNjoREZEkEnbhOv8Wqk6mq/9wimws77qWz7/PgoeHoyMTEZFnRbyTq2zZsnHu3DkAgoKCWL16NQB//PEHnp6eCRudiIhIErh66g6H8tcg97W/uEAm/hy5jg/G5MRicXRkIiLyLIl3clWvXj3WrVsHwPvvv8+AAQPIly8fLVq0oM1/O9eLiIg8K44dCONAwXoUu7mF66Tl369WU69XfkeHJSIiz6B4Vwv85JNPbP9u3LgxOXLkYOvWreTLl49atWolaHAiIiKJafuWSC5XbEJw+BruWFJxdfYKXmxWwtFhiYjIM+qp97kqW7YsZcuWTYhYREREksziRVZCGrWmWdRiwiyehM5bSp6GLzk6LBEReYY9UXJ19uxZNm3axMWLF7FarXaPde7cOUECExERSSzjxhp4dO1ER2YTZXHF+v0PZGhYydFhiYjIMy7eydXMmTP53//+h4eHBxkyZMBy392+FotFyZWIiDitqCjo3s0gyxd9+IBJWLHAt7PwbqRl7SIi8vTinVwNGDCAgQMH0rdvX1xc4l0PQ0RExCFCQqB5cyj44wh68ykAlilTcGne1MGRiYhIchHv7CgkJIQmTZoosRIRkWfGxYtQqRIE/jiej/nQbBw9Gss77R0bmIiIJCvxzpDatm3LDz/8kBixiIiIJLhDh6BsWSi4bSbj+W/p+qBB0K2bYwMTEZFkJ97LAkeMGEHNmjVZuXIlxYoVw93d3e7xMWPGJFhwIiIiT2PTJqhTBypeXcA02pqNXbuayZWIiEgCe6LkatWqVRQoUAAgRkELERERZzBvHrRsCa+FrWSupRmuhhXatYPRo0H/vxIRkUQQ7+Rq9OjRTJ8+nVatWiVCOCIiIk/HMODTT6FPH3iFX1niWh/3qAho3BgmT1ZiJSIiiSbeyZWnpyflypVLjFhERESeSmQkvP++mUOV4k9We9TEM/wu1KgB334Lrq6ODlFERJKxeBe0+OCDDxg/fnxixCIiIvLEbt+GunXNxKoof/ObT3W8wm/Ba6/BDz+Ah4ejQxQRkWQu3jNX27dvZ/369fz0008UKVIkRkGLRYsWJVhwIiIicXHuHNSsCTt3QhHPI/zhUxWva1fhxRdh6VLw9nZ0iCIikgLEO7lKmzYt9evXT4xYRERE4m3fPggOhpMnoXj602z3qILn+fNQrBisWAGpUzs6RBERSSHilVxFRkZSsWJFqlWrRkBAQGLFJCIiEifr10P9+nDjBryU5yIbqYLHsX8hXz5YvRrSp3d0iCIikoLE654rNzc3OnToQFhYWGLFIyIiEifffguvv24mVq+/dI3ffKrhcewgZM8Oa9eC/ggoIiJJLN4FLV588UX++uuvxIhFRETksQwDhg4197CKiIAW9W/zs1EDt793Q+bMsG4d5Mjh6DBFRCQFivc9V++++y7du3fn9OnTlCpVilSpUtk9Xrx48QQLTkRE5H4REfDOOzBzpnn8YfdQhu2qi2XbVkiXzlwKmC+fQ2MUEZGUK97JVZMmTQDo3Lmzrc1isWAYBhaLhaioqISLTkRE5D83bkCDBuaKPxcXmDw+gvarm5gzValSmcUr9Ac+ERFxoHgnV8ePH0+MOERERB7q1ClzH+C9e808av73VoLntoIlS8DTE5YtgzJlHB2miIikcPFOrnLmzJkYcYiIiMRq1y4zsTp71qxR8fNPBs9PfRfmzAE3N1iwACpWdHSYIiIi8U+uAI4ePcrYsWM5cOAAAIULF+aDDz4gKCgoQYMTEZGUbeVKaNgQbt+GIkVg+c8GOSb0gilTwGKB2bPN3YNFREScQLyrBa5atYrChQuzfft2ihcvTvHixdm2bRtFihRhzZo1iRGjiIikQFOnmnnT7dtQqRJs2gQ5Zg2Hzz6716FxY8cGKSIicp94z1z16dOHrl278sknn8Ro7927N1WrVk2w4EREJOUxDOjfHz7+2Dxu0cLMozwmjYMBA8zGzz+Htm0dF6SIiEgs4j1zdeDAAdrG8j+0Nm3asH///gQJSkREUqawMGje/F5iNWiQWXbdY/Z06NLFbBwy5N6/RUREnEi8kyt/f3927doVo33Xrl1kypQpIWISEZEU6OpVqFbtXp2KGTNg8GCwLPgB2rc3O3Xvfm/2SkRExMnEe1lg+/bteeeddzh27Bgvv/wyAJs3b2bkyJF069YtwQMUEZHk7/hxCA6Gf/4BPz9YuBCqVAGWL4e33gKr1UywRo0yC1mIiIg4oXgnVwMGDCB16tSMHj2avn37ApA1a1YGDx5st7GwiIhIXPzxh1m44uJFyJbNzKeKFQM2boQ334SICGjSBCZNUmIlIiJOLU7LApcuXUpERAQAFouFrl27cvr0aW7cuMGNGzc4ffo0H3zwARb9T09EROJhyRKoUMFMrEqWhG3b/kustm83M67QUKhVC779FlxdHR2uiIjII8UpuapXrx7Xr18HwNXVlYsXLwKQOnVqUqdOnWjBiYhI8jV+PNSrB3fvwuuvw6+/QtaswN69ZkN0Dfb588Hd3dHhioiIPFackit/f39+//13AAzD0AyViIg8MavVrEvRubNZdv2dd2DZMkidGjh8GKpWhWvX4KWXzKktLy9HhywiIhIncbrnqkOHDtSpUweLxYLFYiEgIOChfaOiohIsOBERSV7u3oW33zYLVgCMGAG9e/93K9WpU2YViwsXoHhx8+YrX1+HxisiIhIfcUquBg8eTJMmTThy5Ai1a9dmxowZpE2bNpFDExGR5OTSJahTB7ZuBQ8Pc/+qpk3/e/DCBTOxOnkS8ueH1ashXTpHhisiIhJvcd7nqmDBgtSoUYOWLVvy5ptvUqdOnVi/nsTEiRPJlSsXXl5elClThu3btz+0b0REBEOHDiUoKAgvLy9KlCjBypUr7fpMmjSJ4sWL4+fnh5+fH2XLlmXFihVPFJuIiDy9w4ehbFkzsUqXDtasuS+xunbN3ODq0CHIkQPWroXMmR0ar4iIyJOI1ybChmHw3Xffce7cuQQLYN68eXTr1o1Bgwaxc+dOSpQoQfXq1W1FMx7Uv39/pkyZwvjx49m/fz8dOnSgXr16/PXXX7Y+2bJl45NPPmHHjh38+eefVKpUiTp16rBv374Ei1tEROJm82YzsTp6FHLlgi1b4NVX/3vw9m1zg6s9eyAgANatg+zZHRmuiIjIE4tXcuXi4kK+fPm4cuVKggUwZswY2rdvT+vWrSlcuDCTJ0/Gx8eH6dOnx9p/1qxZ9OvXj+DgYPLkyUPHjh0JDg5m9OjRtj61atUiODiYfPnykT9/foYPH46vr6+tKIeIiCSNH36AypXhyhV44QX4/XcoWPC/B0NDzXWCv/9uTmetXg158zo0XhERkacR702EP/nkE3r27MmkSZMoWrToU108PDycHTt22DYjBjOBq1KlClu3bo31OWFhYXg9UDnK29ubTZs2xdo/KiqKH374gTt37lC2bNmHnjMsLMx2fPPmTcBcghi9v5ejRF/f0XHIPRoT56MxcS4REREYBnz6qUH//mZbrVpWvv02ilSpzD2BiYjAtVEjXNavx/D1JeqnnzAKFvzvQUlo+h5xPhoT56LxcD7ONCbxicFiGIYRn5OnS5eOkJAQIiMj8fDwwNvb2+7xq1evxvlcZ8+eJTAwkC1bttglPr169WLjxo1s27YtxnOaNWvG7t27Wbx4MUFBQaxbt446deoQFRVllyDt3buXsmXLEhoaiq+vL3PmzCE4ODjWOAYPHsyQIUNitM+ZMwcfH584vx4REYGoKAtff12MFStyA1Cz5lFat/773h7AUVGUGjuWbL/9RpSHB1sHDOBKsWKOC1hEROQRQkJCaNasGTdu3MDPz++RfeM9czV27NgnjStBjBs3jvbt21OwYEEsFgtBQUG0bt06xjLCAgUKsGvXLm7cuMGCBQto2bIlGzdupHDhwjHO2bdvX7p162Y7vnnzJtmzZ6datWqPfQMTW0REBGvWrKFq1aq4axNNp6AxcT4aE+dgGPDzzxaGDXNh1y4XLBaDUaOsdO6cA8hh6+T67ru4/PYbhpsbxg8/UOaNNxwad0qg7xHnozFxLhoP5+NMYxK9qi0u4p1ctWzZMr5PeaiMGTPi6urKhQsX7NovXLjw0L20/P39Wbx4MaGhoVy5coWsWbPSp08f8uTJY9fPw8ODvP+t3S9VqhR//PEH48aNY8qUKTHO6enpiaenZ4x2d3d3hw9mNGeKRUwaE+ejMXEMw4CffoLBg2HnTrPNyyuSb76BRo3cANd7HXv0gGnTwMUFy5w5uNWu7aiwUyR9jzgfjYlz0Xg4H2cYk/hcP14FLaIdPXqU/v3707RpU1tVvxUrVsS7Gp+HhwelSpVi3bp1tjar1cq6deseen9UNC8vLwIDA4mMjGThwoWPLQNvtVrtlg2KiMjTMQxYuhRKl4batc3EKlUq6Nkziq++WkO9eg+sOh82DMaMMf89dSo0bJj0QYuIiCSieCdXGzdupFixYmzbto1FixZx+/ZtAHbv3s2gQYPiHUC3bt2YOnUq33zzDQcOHKBjx47cuXOH1q1bA9CiRQu7ghfR1z127Bi//fYbr7/+OlarlV69etn69O3bl19//ZUTJ06wd+9e+vbty4YNG3jrrbfiHZ+IiNiLTqpKlTKL/UUnVX36wIkTMHy4FT+/cPsnff45RP8/YuxYaNMmqcMWERFJdPFeFtinTx8++ugjunXrRurUqW3tlSpVYsKECfEOoHHjxly6dImBAwdy/vx5SpYsycqVK8n83waSJ0+exMXlXg4YGhpK//79OXbsGL6+vgQHBzNr1izSpk1r63Px4kVatGjBuXPnSJMmDcWLF2fVqlVUrVo13vGJiIgpOqkaMgSitxZMlQrefx+6d4eMGc22GEWVpk2D6Ptahw2DDz5IsphFRESSUryTq7179zJnzpwY7ZkyZeLy5ctPFESnTp3o1KlTrI9t2LDB7rhChQrs37//keebNm3aE8UhIiIxxZZU+fqaSVW3bveSqljNmwft25v/7tEDPvww0eMVERFxlHgnV2nTpuXcuXPkzp3brv2vv/4iMDAwwQITERHHMgxYssRMqnbtMtvinFQBluXLoXlz80TvvAOffgoWS6LHLSIi4ijxvueqSZMm9O7dm/Pnz2OxWLBarWzevJkePXrQokWLxIhRRESSkGHA4sXw/PNQr56ZWPn6Qr9+5j1VH3/8+MQq4969uDZuDJGR0KwZfPmlEisREUn24j1z9fHHH/Pee++RPXt2oqKiKFy4MFFRUTRr1oz+/fsnRowiIpIErNZ7M1W7d5ttvr7QubM5U5UhQ9zOY9m2jTLDh2MJCzPLCM6cyb0dhEVERJKveCdXHh4eTJ06lYEDB7J3715u377Nc889R758+RIjPhERSWQPS6o++AC6do17UgXAihW4NmiAJTQUa6VKuMybB9ozRkREUog4J1dWq5VRo0axdOlSwsPDqVy5MoMGDcLb2zsx4xMRkURitZrL/4YMgT17zLbUqc2ZqngnVQAzZkD79liiorhYsiTpFizAxcsrocMWERFxWnG+52r48OH069cPX19fAgMDGTduHO+9915ixiYiIonAaoVFi+C55+DNN83EKnVq6N/fvKfqo4/imVgZhvmkNm0gKgrrW2/x+4cfmtNfIiIiKUick6tvv/2WL7/8klWrVrF48WKWLVvGd999h9VqTcz4REQkgVitsHAhlCwZe1I1bBikTx/Pk0ZGQseOMGCAedy3L1HTp2NoKaCIiKRAcV4WePLkSYKDg23HVapUwWKxcPbsWbJly5YowYmIyNOzWuHHH83lf3v3mm2pU0OXLuZXvBOqaCEh0LSpuQmWxQJffAGdOsWyi7CIiEjKEOfkKjIyEq8H1s67u7sTof+Jiog4pdiSKj8/s1DFUyVVAFeuQK1asHUreHrCnDlQv35ChC0iIvLMinNyZRgGrVq1wtPT09YWGhpKhw4dSJUqla1t0aJFCRuhiIjES/Q9VUOGwN9/m21+fvdmqtKle8oLnDgBr78OBw9C2rSwbBmUL/+UJxUREXn2xTm5atmyZYy25s2bJ2gwIiLy5BI9qQL46y8IDobz5yF7dli5EgoXToATi4iIPPvinFzNmDEjMeMQEZEnFF2oYuhQ+6Sqa1dzCWCCJFUAa9eaS/9u3YLixWH5cggMTKCTi4iIPPvivYmwiIg4h+ikasgQ2LfPbEuTxpylStCkCuC776BVK7M6YMWK5s1cadIk4AVERESefUquRESeMVYrLFhgzlTdn1RFz1SlTZuAFzMMGDUKevc2j5s0gZkzzSIWIiIiYkfJlYjIMyJJkyqAqCjo1s0ssQ7mv0eNApc4b5EoIiKSoii5EhFxclFR95Kq/fvNtjRpzFync+dESKoAQkPh7bfNCwOMHm1eUERERB5KyZWIiJOKLalKm9acqUq0pArg2jWoWxd+/RU8POCbb8zlgCIiIvJISq5ERJxMVBT88IOZVB04YLalTXtvpipR60icOmXuYbV/v1lycPFis4CFiIiIPJaSKxERJ+HQpApg71544w04cwayZoUVK8yS6yIiIhInSq5ERBwsKgrmzzeTqn/+MdvSpoXu3eH995Oo4vmGDeZSwBs3oFAhc3PgHDmS4MIiIiLJh5IrEREHiS2pSpfOnKlKsqQKzCDefhvCw6F8eViyBNKnT6KLi4iIJB9KrkREklhUFMybB8OGOTipAhg3zqyQYRhQv765WbCXVxIGICIiknwouRIRSSLRSdXQoXDwoNmWLt295X9+fkkYjNVqbgz82Wfm8XvvmYmWq2sSBiEiIpK8KLkSEUlkUVHw/ffmTJXDkyowl/+1bg1z5pjHn3wCvXqBxZLEgYiIiCQvSq5ERBJJbElV+vRmUtWpkwOSKoCbN83lf+vWgZsbTJ9u3m8lIiIiT03JlYhIAnPKpArg7FkIDobdu8HXFxYuhGrVHBSMiIhI8qPkSkQkgURG3kuqDh0y29Knhx49zKQqdWoHBnfggLk58MmTkDkzLF8Ozz/vwIBERESSHyVXIiJPyamTKoDNm6FWLbh2DfLlM/ewypPHwUGJiIgkP0quRESeUGQkzJ1rJlWHD5ttGTKYSdV77zlBUgWweDE0bQqhoVCmDPz0E2TM6OioREREkiUlVyIi8fRMJFUAkyaZU2dWqzlz9f334OPj6KhERESSLSVXIiJxFBlpVi8fNgyOHDHbMmSAnj3h3XedKKkyDOjfHz7+2Dxu3x6+/NKsDigiIiKJRv+nFRF5jEclVe+9ZxbecxoREWYy9c035vHQoWaipT2sREREEp2SKxGRh4iMhO++g48+updUZcx4b6bKqZIqgNu3oUEDWLUKXF1hyhRo29bRUYmIiKQYSq5ERB4QnVQNGwZHj5ptTp1UAVy4ADVqwI4d5n1V8+ebxyIiIpJklFyJiPwnMhJmzzZnqu5Pqnr1go4dnTSpArOqxuuvw7FjZsA//wwvvujoqERERFIcJVcikuI9s0kVwPbt5gzV5cvm3lUrV5p7WYmIiEiSU3IlIilWRMS9pOrYMbPN3/9eUpUqlWPje6yff4ZGjSAkBEqVMo8zZ3Z0VCIiIimWkisRSXGe+aQK4OuvoUMHiIoylwT+8IOTT7GJiIgkf0quRCTFiIiAWbPMpOr4cbMtUyYzqerQ4RlJqgzDrLQxaJB53KoVfPUVuLs7NCwRERFRciUiKUCySKrAvDns3Xdh6lTz+MMPzURLe1iJiIg4BSVXIpJsPSyp6t3bTKp8fBwbX7yEhECTJrBsGbi4wIQJ5hpGERERcRpKrkQk2YmIgG+/heHDk0FSBWYlwJo1Yds28PKCuXOhbl1HRyUiIiIPUHIlIslGdFL10Udw4oTZljmzmVT973/PYFIFZnZYvbq5l1W6dObMVblyjo5KREREYqHkSkSeeRERsGZNDrp0cUs+SRXAzp0QHAwXLkCOHOYeVoUKOToqEREReQglVyLyzLJa4bvvYOBAN06ceA5IJkkVwOrV8OabcPs2lCgBy5dD1qyOjkpEREQeQcmViDyTVq82q/3t3g1gIW3aUPr3d6djR9dnO6kCswpHmzZmdcBKlWDRIkiTxtFRiYiIyGMouRKRZ8rOnebM1Nq15nGaNNCzZxT58q2lXr3quLu7OjbAp2EYMHIk9O1rHjdrBjNmgIeHY+MSERGROHFxdAAiInFx/Di89RaUKmUmVh4e0LUrHD0KvXpZ8fSMcnSITycqCt5//15i1bOnOYOlxEpEROSZoZkrEXFqly+bJdW//BLCw822t94yKwLmymUeR0Q4LLyEcfcuNG9uLv+zWODzz+GDDxwdlYiIiMSTkisRcUohITBuHHzyCdy8abZVrWqumnvuOcfGlqCuXoU6dWDTJnOWatYsaNTI0VGJiIjIE1ByJSJOJSoKZs6EQYPgzBmzrWRJM6mqVs2RkSWCkyfh9dfhwAHz5rElS6BCBUdHJSIiIk9IyZWIOAXDgJ9/NotV7N9vtuXMaS7/a9YMXJLbHaJ79sAbb8DZsxAYaO5hVbSoo6MSERGRp6DkSkQcbts2s6z6r7+ax+nSQf/+8O674OXl2NgSxS+/QN265nrHIkVgxQrInt3RUYmIiMhTUnIlIg5z+DD06wcLFpjHXl5mHYc+fSBtWoeGlnjmzYMWLczqHK++CosXm9mkiIiIPPOS20IbEXkGXLgA770HhQubiZXFAq1awaFDZgGLZJtYjRkDTZqYiVWDBrBqlRIrERGRZEQzVyKSZG7fNvOLUaPMfwMEB5sJVbFijo0tUVmt0KOHWWIdoHNn841wfYY3PBYREZEYlFyJSKKLiIBp02DwYHPWCuCFF+DTT+G11xwZWRIIC4OWLc3lgGC+6B49zOk6ERERSVaUXIlIojEM+PFH6NvXXPIHEBQEH38MDRumgPzixg2zcMWGDeDuDjNmmDsgi4iISLKk5EpEEsWmTWYFwK1bzWN/fxg4EN55x9wrN9k7c8Ystb53L6RODYsWQZUqjo5KREREEpGSKxFJUAcOmDNVS5aYxz4+0L27uRLOz8+xsSWZ/fvNzYFPnYKAALPUesmSjo5KREREEpmSKxFJEGfPmvdUTZtm1m9wdYW2bc22LFkcHV0S2rQJatWC69ehQAFzc+BcuRwdlYiIiCQBJVci8lRu3jRrNIwZA3fvmm1168KIEVCwoENDS3qLFkGzZmYRi7JlYdkyyJDB0VGJiIhIElFyJSJPJDwcJk+GYcPg8mWz7eWXzUSrXDnHxuYQEyfC+++bVTxq14a5c801kSIiIpJiaBNhEYkXq9WsKl6oEHzwgZlYFShgVgXctCkFJlaGAf36QadO5r//9z9YuFCJlYiISArkFMnVxIkTyZUrF15eXpQpU4bt27c/tG9ERARDhw4lKCgILy8vSpQowcqVK+36jBgxghdeeIHUqVOTKVMm6taty8GDBxP7ZYgke7/8AmXKQJMmcOyYWath8mT4+29zKWCyL63+oPBwaNXKXAMJ8NFHMGkSuGlRgIiISErk8ORq3rx5dOvWjUGDBrFz505KlChB9erVuXjxYqz9+/fvz5QpUxg/fjz79++nQ4cO1KtXj7/++svWZ+PGjbz33nv8/vvvrFmzhoiICKpVq8adO3eS6mWJJCt79kBwMFSqBH/+Cb6+MHQoHDliTtSkyFzi1i2zcMW335rVO2bMgA8/TIEZpoiIiERzeHI1ZswY2rdvT+vWrSlcuDCTJ0/Gx8eH6dOnx9p/1qxZ9OvXj+DgYPLkyUPHjh0JDg5m9OjRtj4rV66kVatWFClShBIlSjBz5kxOnjzJjh07kupliSQLJ0+aEzMlS5rVxN3czNVv/2/vzsOiKts/gH+HYRUQNUAWccPUzAXTMNTSDDMps01RzK2yXyltVKiJipqipqaVy5vlkom0uPWaoa+YeaFGvfhiblmyhAuQmsomMMw8vz+eGESBBGfmHGa+n+s6V55nzszch9sx7nmec5/0dGD6dMDVVekIFZKbC/TrB+zeLX8I//63/EERERGRTVP0++aysjKkpqZi6tSpxjE7OzuEhobiUMWdR29QWloKZ2fnKmMuLi5ITk6u8X2uXr0KAGjWrFmNr1laWmrcz8/PByCXIOp0uls7GTOpeH+l46BKtpCTy5eBBQvssHy5HUpL5UzM008bMGeOHu3ayWPUdPoWzclvv8H+scegycqC8PKCfvt2iJ491fUDUZgtfEYaGuZEfZgTdWE+1EdNOalLDBohhDBjLLU6f/48/P39cfDgQYSEhBjHo6Oj8cMPPyAlJeWm50RERODIkSPYtm0bAgMDkZSUhKFDh0Kv11cpkCoYDAY8/vjjuHLlSo0FWGxsLGbNmnXTeHx8PBrxonSyIWVldti5sw2+/ro9CgsdAQB3330RY8ceR/v2V5QNTgWanjqFXu++C6eCAhT6+ODQzJkotqmbeBEREdme4uJiRERE4OrVq2jcuHGtxza4KyWWLVuGCRMmoGPHjtBoNAgMDMT48eNrXEY4adIkHDt2rNaZralTpyIqKsq4n5+fj4CAADz88MP/+AM0N51Oh//85z8YOHAgHBwcFI2FJGvMicEAxMdrEBurRXa2nKnq1Elg3jw9Bg/2gEbTW+EIa2eJnGh27IA2Nhaaa9dg6NEDTtu3o7+3t1neq6Gzxs9IQ8ecqA9zoi7Mh/qoKScVq9puhaLFlaenJ7RaLfLy8qqM5+XlwcfHp9rneHl5Ydu2bSgpKcGlS5fg5+eHKVOmoG3btjcdGxkZiR07dmD//v1o0aJFjXE4OTnBycnppnEHBwfFk1lBTbGQZA05EUJeNjR5MnDkiBzz95f3rhozRgOttmF9/2K2nKxeDbz0kqxCBw+G3Zdfws7NzfTvY2Ws4TNibZgT9WFO1IX5UB815KQu769oQwtHR0f06NEDSUlJxjGDwYCkpKQqywSr4+zsDH9/f5SXl2Pz5s0YOnSo8TEhBCIjI7F161bs3bsXbdq0Mds5EDVUhw8DAwcCjzwiCysPD9lR/PffgfHjZQM8mycEEBsLvPiiLKyeew7Yvl22SyQiIiK6geJfS0dFRWHs2LHo2bMngoODsXTpUhQVFWH8+PEAgDFjxsDf3x9xf99HJiUlBefOnUNQUBDOnTuH2NhYGAwGREdHG19z0qRJiI+Px/bt2+Hu7o7c3FwAgIeHB1xcXCx/kkQqkpkpO4Zv2iT3HR2BSZPk2B13KBubqpSXy9mqTz+V+9OnA7NmsdU6ERER1Ujx4io8PBwXLlzAjBkzkJubi6CgICQmJqJ58+YAgOzsbNjZVU6wlZSUICYmBhkZGXBzc0NYWBg2bNiAJk2aGI9ZuXIlAKB///5V3mvt2rUYx3bJZKMuXgTmzgWWL69sbDdqlLzvbevWioamPkVFQHg48O23gJ0dsGKFvKEXERERUS0UL64AeW1UZGRktY/t27evyn6/fv1w4sSJWl9PwQaIRKpTXAwsWwbMnw9UXI85cCCwYAHQvbuysanShQvAY48BP/0EuLgACQnA448rHRURERE1AKoorojI9PR6YN06YOZM4Nw5ORYUJIuqhx9WMjIVS0+XF6GdPi3XSP7738A/XP9JREREVIHFFZGVEUKuZps8GaiY5G3VSi7/i4iQq9yoGv/9L/Doo8Cff8p1komJQIcOSkdFREREDQiLKyIrkpICREcD+/fL/aZNgZgYYOJEwNlZ2dhULTEReOYZea1VUBCwcyfAmwMTERFRHfE7bCIr8PvvwLBhwH33ycLK2VnOXGVkAFFRLKxqtX49MGSILKxCQ4EffmBhRURERPXC4oqoAcvLk23UO3UCvv5adgkfNw747TfZwOK6Jpp0IyGAefPkD6y8HHj2WbmesnFjpSMjIiKiBorLAokaoMJCYPFiYNEi+WcACAuTBVWXLsrG1iDo9cCrr8oW64Cc5ps3jxekERER0W1hcUXUgOh0wCefyHvZ5uXJsXvvBRYuBG64rRvV5No12dlj2zY51bdsGfDKK0pHRURERFaAxRVRAyAEsHUrMHWqXPIHAIGBcrJl2DBZI9At+OsveX3VwYOAkxOwcSPw9NNKR0VERERWgsUVkcolJ8sOgIcOyX0vL2DGDODFFwFHR2Vja1D++EPew+rXX+XFaN98A9x/v9JRERERkRVhcUWkUidPAlOmyBoAABo1At58E3jrLfZcqLO0NHlRWk4O0KKFbL1+991KR0VERERWhsUVkcqcPw/MnAmsWQMYDIBWCzz/PBAbyw7h9ZKUBDz5JFBQAHTuDHz3nSywiIiIiEyMxRWRSuTny8YUS5bIngsA8MQTQFwc0LGjoqE1XPHxstW6Tic7fmzdyv70REREZDbsO0yksLIy4IMPZIOKuXNlYdW7t7zWautWFlb1IoTsUz9qlCyshg+XSwFZWBEREZEZsbgiUojBACQkAHfdBbz2GnDxItChgyyokpOBPn2UjrCBMhiAqCjg7bfl/uuvA5s2ye6ARERERGbEZYFECti7V3YATE2V+z4+8pqq558H7PmprL+SEuCFF4Avv5T7ixbJLiBEREREFsBf44gs6JdfZAfA776T+25ussiKigJcXZWNraGzLyyE9rHHgP37AQcHYP16YORIpcMiIiIiG8LiisgCsrPlvak++0xeDmRvD7z0EjB9OuDtrXR0VuDsWdz/zjuwy86Wfeq3bgUGDFA6KiIiIrIxvOaKyIwuX5YzU+3by4kUIYBhw+Q9rD78kIXVbRMC2LED9g88gMbZ2RC+vnLmioUVERERKYAzV0RmUFICfPQRMG+eLLAAoF8/2Wo9OFjZ2KxGaqq8o/K+fdAAKGjRAs7ffw+Hdu2UjoyIiIhsFIsrIhMyGICNG4GYGLkUEADuvhtYsAAICwM0GmXjswpZWcC0afIeVgDg5AR9ZCT233MPHm7VStHQiIiIyLZxWSCRCQgB7NoF3HMPMGaMLKz8/YE1a4AjR4BHH2VhddsuX5bt1Tt0qCysnn0WOHUKhrg4lLMjCBERESmMM1dEt+nwYXldVVKS3PfwkB0BX3sNcHFRNjarUFYGrFgBzJkD/PWXHBswAHjvPVnNAvJGwUREREQKY3FFVE+ZmfLeVJs2yX1HR2DSJLli7Y47FA3NOggBfPUVMHUqkJEhx+6+W164NngwpwKJiIhIdVhcEdXRxYvAJ590xq5d9sYJk1GjgHffBVq3VjQ065GcLJtVpKTIfV9fYPZsYNw43mWZiIiIVIu/pRDdguJiYMcOeanPd9/Zo6wsEAAwcKBsVtG9u8IBWotTp+Saym3b5L6rq1xz+eabvMsyERERqR6LK6Ia6HTAnj2yoNq2DSgsrHhEg8DAK/jgAzeEhfEjZBJ//gnMmgX861+AXg/Y2QEvvCDHfHyUjo6IiIjolvA3Q6LrGAzAwYOyoPrqK7kEsEKrVsDIkcCwYTqcOfMDBg4MUy5Qa1FcDLz/vpz+KyiQY489Jvc7dVI2NiIiIqI6YnFFNk8I4JdfZEG1aRNw5kzlY15eQHi4LKpCQmQPBZ2u6jFUD3o9sGGDvCHYuXNyrEcPYNEioH9/RUMjIiIiqi8WV2Sz0tNlMRUfD5w8WTnu7g489ZQsqB56iP0TTG73bnm/ql9+kfutWgHz5gEjRsjlgEREREQNFH9tJJuSkwN8+aUsqH76qXLc0VGuRhs5Ut7wl/enMoNffpFF1e7dct/DQ85cRUYCzs7KxkZERERkAiyuyOpduQJs2SILqu+/l9dVAXKS5KGHZEH15JNAkyZKRmnFzp4Fpk8H1q+XazAdHOQNwWJieEMwIiIisiosrsgqXbtW2Tp9506grKzysfvukwXV8OFsRGdW+fmyMcX778uEAPKHPm8eEBiobGxEREREZsDiiqyGTgckJcmCauvW61uny8Zzo0bJy3ratlUuRpug0wGrVwOxscCFC3Ksb1/ZrKJXL0VDIyIiIjInFlfUoFW0Tt+0SV5LVV3r9JEjgS5dZKc/MiMhgO3bgcmTgd9+k2Pt28vZq6FDmQAiIiKyeiyuqMGpaJ2+aZPcsrMrH/PykivPKlqns/mchaSkAG+9BSQny30vLzlzNWGCvMaKiIiIyAawuKIGIyOjsnX6iROV425usnV6RARbp1tcRgYwdaqcNgRk17833wSio4HGjZWNjYiIiMjC+GsoqVpuLvDFF7KoSkmpHHd0lC3TIyLYOl0Rly4B774LLF8ur7HSaICxY4E5c4AWLZSOjoiIiEgRLK5IdSpap2/aBOzdW7V1+oABsqBi63SFlJQAH34oO/5duSLHHn4YWLgQ6NZN0dCIiIiIlMbiilShonX6pk3At99WbZ3eq5csqNg6XUEGA5CQALzzDvDHH3Ksa1fgvfdkcUVERERELK5IOeXlwJ49sqDauhUoKKh8rFMnWVCNGMFbIilu3z7ZrCI1Ve77+8slgaNHA1qtoqERERERqQmLK7IogwE4dKiydXrFbZAAoGVL2eUvIoKt01XhxAnZVn3HDrnv7g5MmQK8/jrQqJGioRERERGpEYsrMjshgKNHZZe/hITKVWUA4Okpl/tFRLB1umrk5gIzZwKffCKrYa0WeOklYMYMwNtb6eiIiIiIVIvFFZlNRev0TZuA48crx93cZEOKitbpvA2SShQVAYsWyeuoiork2JNPAnFxQIcOysZGRERE1ACwuCKTys2Vy/02bQJ+/LFy3NERCAurbJ3OVWUqotcDa9fKmamcHDnWq5cstPr2VTY2IiIiogaExRXdtqtXZev0+PibW6c/+KAsqJ56iq3TVUcI4Lvv5A1/K6YW27aVM1XDhvGiNyIiIqI6YnFF9XLtmmyZHh8P7NwJlJZWPhYcXNk63ddXuRipFocPA2+/LathAGjWDJg+HXj5ZcDJSdnYiIiIiBooFld0y8rLgaQkWVDd2Dr9rrsqW6e3a6dcjPQPsrOBadOAzz+X+05OwKuvAlOnAk2bKhsbERERUQPH4opqJYRsnR4fX33r9BEjZFHVtStXkanalStyud+yZZXTjKNGAXPnAq1aKRoaERERkbVgcUXVur51elZW5binp7wcJyIC6N2brdNVr6wMWLkSmDMHuHRJjvXvLzsC9uypaGhERERE1obFFRllZla2Tj92rHLczQ144glZUIWGsnV6gyAEsHmzvOlverocu+suWVSFhXGakYiIiMgMWFzZuLw8udwvPr761ukjRwKPPcbW6Q3KwYPAW2/J9ZwA0Lw5MHs28NxzgD0/8kRERETmwt+0bNDVq7IhRXy8bFBR0TpdowEGDJAF1VNPsb9Bg/P773KmassWud+okewI+NZbcvqRiIiIiMyKxZWNuHZNtkyPj5ct1G9snT5ypGyd7uenXIxUTxcuyJmpVatkS0c7O+D554FZs9gLn4iIiMiCWFxZsfJyeRuj+Hg5mXF96/SOHeU1VCNHsnV6g3XtGrB0KTB/PpCfL8fCwoCFC4G771Y0NCIiIiJbxOLKygghr52qaJ3+55+VjwUEVLZO79aNPQ0aLIMB2LABiIkBzp6VY927A4sWyXWdRERERKQIFldW4tgxWVBt2lS1dfodd8jlfiNHAn36sHV6g7dnj7yOKi1N7rdsKe9VFRHB5BIREREpjMVVA5aZKe9DFR9ftXW6qyvw5JOyoBo4kK3TrcLRo0B0NJCYKPc9PIB33gFefRVwdlY2NiIiIiICwOKqwcnLA776ShZUFZ22AVlAVbROHzKErdOtxrlzwIwZwLp1cjmggwMwcaJcEujpqXR0RERERHQdFlcNQFGRPT77TIMvv5Srwq5vnf7gg3JFGFunW5mCAtmYYvFi2bgCAIYNA+LigMBAZWMjIiIiomqxuFK5l1/W4rPPHoFOpzWO3XuvLKjYOt0KlZcDn3wCzJxZ2Y2kd2/ZrCIkRNnYiIiIiKhWLK5UzvfKCXTRlcKhbQAeHeuFESM1uPNOpaMikxMC+Pe/gcmTgV9/lWN33inbrD/5JFs7EhERETUALK5U7k3dfMzBRiADQJwzsLEl0KqV7BJ3/daqFdCiBeDkpHTIVFc//wy89Rawf7/c9/SUM1f/93/sRkJERETUgLC4Ujl3XzeUNG0K58uXgZIS4Lff5FYTH5/KYuvG4qtlS6BZM86CqEVmpuz4l5Ag952dgTfekLNXHh7KxkZEREREdcbiSuUMH36IXYMHI+yhh+CQlwdkZ1duf/xRdf/aNSA3V24//VT9CzZqdHPBdf2+vz/g6GjZk7Q1f/0l70310UdAWZksdseMAebMkXd6JiIiIqIGicVVQ+HkJLvE1dQpTgjg4sXai6+8PKC4WF7TU3Fdz400GsDXt/bZryZNOPtVH6WlsqCaOxe4fFmOhYYC770HBAUpGhoRERER3T7Fi6vly5fjvffeQ25uLrp164YPP/wQwcHB1R6r0+kQFxeH9evX49y5c+jQoQMWLFiARx55xHjM/v378d577yE1NRU5OTnYunUrnnjiCQudjYI0GsDLS249elR/TEkJcOZM7QVYaSlw/rzcfvyx+tdxc6t99svPj9cKXc9gAL74Qi4BzMqSY126yFbrgwaxUCUiIiKyEooWV1988QWioqKwatUq9OrVC0uXLsWgQYNw6tQpeHt733R8TEwMPv/8c6xevRodO3bErl278OSTT+LgwYPo3r07AKCoqAjdunXDc889h6eeesrSp6Ruzs6yA11N7QaFkO2/ry+2bizALlwACguBEyfkVh07O1lg1VaA2co1Rfv3y2YVP/8s9/385PK/sWMBrbb25xIRERFRg6JocbVkyRJMmDAB48ePBwCsWrUK3377LdasWYMpU6bcdPyGDRswbdo0hIWFAQBefvll7NmzB4sXL8bnn38OABg8eDAGDx5suZOwJhoN0Ly53O69t/pjiotvnv26vgA7c0ZeR3T2rNwOHqz+dRo3rrn4atlSFiH2ik+s1t+vv8rGFN98I/fd3OT+G28Arq7KxkZEREREZqHYb69lZWVITU3F1KlTjWN2dnYIDQ3FoUOHqn1OaWkpnJ2dq4y5uLggOTn5tmIpLS1FaWmpcT8/Px+AXIao0+lu67VvV8X7Kx2HkYMD0Lat3KpjMAB//gnN30WX5swZ4MwZaP74o/LPly4B+fnAsWNyq4bQagF/f4iAACAgAOLvoksEBMixVq0Ad3cznmjNas1JXh7s5syB3aefQqPXQ2i1MLzwAgwxMbJolU+0YLS2QXWfExvHfKgPc6I+zIm6MB/qo6ac1CUGjRBCmDGWGp0/fx7+/v44ePAgQkJCjOPR0dH44YcfkJKSctNzIiIicOTIEWzbtg2BgYFISkrC0KFDodfrqxRHFTQazS1dcxUbG4tZs2bdNB4fH49GjRrV/eSoVtqSErhcuACXixfR6MIFuFy4YPyvy8WLcLl4EXZ6/T++TpmrK655eeGapyeKvb1xzdMT17y8UPz3WEnTphZbeqctLUXg9u24c8sW2JeUAABygoNxYswYFLZoYZEYiIiIiMj0iouLERERgatXr6Jx48a1Htug1l0tW7YMEyZMQMeOHaHRaBAYGIjx48djzZo1t/W6U6dORVRUlHE/Pz8fAQEBePjhh//xB2huOp0O//nPfzBw4EA42EiTCL1eD31eXu2zX5cvw7GoCI5FRfCoaBJxA2FvD7RoUWX2S7RsKf8cECCXH7q51Tm+Kjmxs4NmwwZoY2OhOX8eAGDo2ROGBQvgef/9eOB2fhB0y2zxc6JmzIf6MCfqw5yoC/OhPmrKScWqtluhWHHl6ekJrVaLvLy8KuN5eXnw8fGp9jleXl7Ytm0bSkpKcOnSJfj5+WHKlCloW9MStVvk5OQEJyenm8YdHBwUT2YFNcVidg4Octlfq1Y1H1NQIK/vurHbYcX+2bPQlJcDWVnQ1FB8AZA3Va6u3XzF5uMjG3TcSAg47t0L+3feAY4elWNt2gDz5sFu+HDYVfccMjub+pw0AMyH+jAn6sOcqAvzoT5qyEld3l+x4srR0RE9evRAUlKScdmewWBAUlISIiMja32us7Mz/P39odPpsHnzZgwfPtwCEZOquLsDnTrJrTp6PZCTc3PxdX0BdvWqvKHvX38BaWnVv46Dg7yx73UFl52vL0I+/hj2R47IY5o2BWJigEmT5P3IiIiIiMgmKbosMCoqCmPHjkXPnj0RHByMpUuXoqioyNg9cMyYMfD390dcXBwAICUlBefOnUNQUBDOnTuH2NhYGAwGREdHG1+zsLAQp0+fNu5nZmYiLS0NzZo1Q8uWLS17gqQcrRZo0UJuffpUf8zVq7XPfp07J5tPZGTIreKlAXgDEI6O0LzyCjBtmiywiIiIiMimKVpchYeH48KFC5gxYwZyc3MRFBSExMRENP+7q1p2dnaV5VUlJSWIiYlBRkYG3NzcEBYWhg0bNqBJkybGY/773//iwQcfNO5XXEs1duxYrFu3ziLnRQ2Eh4fcOneu/vHycnkz5Rvu9WXIykK2Xg//jz6CQ/v2lo2ZiIiIiFRL8YYWkZGRNS4D3LdvX5X9fv364URNN679W//+/aFQA0SyNvb2lcsB+/Y1Dut1OhzZuRP+bdooGBwRERERqQ2vuiciIiIiIjIBFldEREREREQmwOKKiIiIiIjIBFhcERERERERmQCLKyIiIiIiIhNgcUVERERERGQCLK6IiIiIiIhMgMUVERERERGRCbC4IiIiIiIiMgEWV0RERERERCbA4oqIiIiIiMgEWFwRERERERGZAIsrIiIiIiIiE2BxRUREREREZAIsroiIiIiIiEyAxRUREREREZEJsLgiIiIiIiIyARZXREREREREJmCvdABqJIQAAOTn5yscCaDT6VBcXIz8/Hw4ODgoHQ6BOVEj5kRdmA/1YU7UhzlRF+ZDfdSUk4qaoKJGqA2Lq2oUFBQAAAICAhSOhIiIiIiI1KCgoAAeHh61HqMRt1KC2RiDwYDz58/D3d0dGo1G0Vjy8/MREBCAM2fOoHHjxorGQhJzoj7MibowH+rDnKgPc6IuzIf6qCknQggUFBTAz88Pdna1X1XFmatq2NnZoUWLFkqHUUXjxo0V/4tFVTEn6sOcqAvzoT7MifowJ+rCfKiPWnLyTzNWFdjQgoiIiIiIyARYXBEREREREZkAiyuVc3JywsyZM+Hk5KR0KPQ35kR9mBN1YT7UhzlRH+ZEXZgP9WmoOWFDCyIiIiIiIhPgzBUREREREZEJsLgiIiIiIiIyARZXREREREREJsDiioiIiIiIyARYXKnA8uXL0bp1azg7O6NXr1746aefajx29erVuP/++9G0aVM0bdoUoaGhtR5P9VOXnGzZsgU9e/ZEkyZN4OrqiqCgIGzYsMGC0dqGuuTkegkJCdBoNHjiiSfMG6CNqUs+1q1bB41GU2Vzdna2YLS2oa6fkStXrmDSpEnw9fWFk5MT2rdvj507d1ooWttQl5z079//ps+JRqPBo48+asGIrVtdPyNLly5Fhw4d4OLigoCAALzxxhsoKSmxULS2oS450el0mD17NgIDA+Hs7Ixu3bohMTHRgtHeIkGKSkhIEI6OjmLNmjXi+PHjYsKECaJJkyYiLy+v2uMjIiLE8uXLxf/+9z9x8uRJMW7cOOHh4SHOnj1r4citV11z8v3334stW7aIEydOiNOnT4ulS5cKrVYrEhMTLRy59aprTipkZmYKf39/cf/994uhQ4daJlgbUNd8rF27VjRu3Fjk5OQYt9zcXAtHbd3qmpPS0lLRs2dPERYWJpKTk0VmZqbYt2+fSEtLs3Dk1quuObl06VKVz8ixY8eEVqsVa9eutWzgVqqu+di4caNwcnISGzduFJmZmWLXrl3C19dXvPHGGxaO3HrVNSfR0dHCz89PfPvttyI9PV2sWLFCODs7i8OHD1s48tqxuFJYcHCwmDRpknFfr9cLPz8/ERcXd0vPLy8vF+7u7mL9+vXmCtHm3G5OhBCie/fuIiYmxhzh2aT65KS8vFz07t1bfPLJJ2Ls2LEsrkyorvlYu3at8PDwsFB0tqmuOVm5cqVo27atKCsrs1SINud2/1/y/vvvC3d3d1FYWGiuEG1KXfMxadIkMWDAgCpjUVFRok+fPmaN05bUNSe+vr7io48+qjL21FNPiVGjRpk1zrriskAFlZWVITU1FaGhocYxOzs7hIaG4tChQ7f0GsXFxdDpdGjWrJm5wrQpt5sTIQSSkpJw6tQpPPDAA+YM1WbUNyezZ8+Gt7c3nn/+eUuEaTPqm4/CwkK0atUKAQEBGDp0KI4fP26JcG1CfXLyzTffICQkBJMmTULz5s3RuXNnzJs3D3q93lJhWzVT/P/9008/xYgRI+Dq6mquMG1GffLRu3dvpKamGpepZWRkYOfOnQgLC7NIzNauPjkpLS29aUm5i4sLkpOTzRprXdkrHYAtu3jxIvR6PZo3b15lvHnz5vj1119v6TUmT54MPz+/Kn85qf7qm5OrV6/C398fpaWl0Gq1WLFiBQYOHGjucG1CfXKSnJyMTz/9FGlpaRaI0LbUJx8dOnTAmjVr0LVrV1y9ehWLFi1C7969cfz4cbRo0cISYVu1+uQkIyMDe/fuxahRo7Bz506cPn0aEydOhE6nw8yZMy0RtlW73f+///TTTzh27Bg+/fRTc4VoU+qTj4iICFy8eBF9+/aFEALl5eV46aWX8M4771giZKtXn5wMGjQIS5YswQMPPIDAwEAkJSVhy5YtqvtSiDNXDdj8+fORkJCArVu38uJwhbm7uyMtLQ0///wz5s6di6ioKOzbt0/psGxSQUEBRo8ejdWrV8PT01PpcAhASEgIxowZg6CgIPTr1w9btmyBl5cX/vWvfykdms0yGAzw9vbGxx9/jB49eiA8PBzTpk3DqlWrlA6NIGetunTpguDgYKVDsVn79u3DvHnzsGLFChw+fBhbtmzBt99+izlz5igdms1atmwZ7rzzTnTs2BGOjo6IjIzE+PHjYWenrnKGM1cK8vT0hFarRV5eXpXxvLw8+Pj41PrcRYsWYf78+dizZw+6du1qzjBtSn1zYmdnh3bt2gEAgoKCcPLkScTFxaF///7mDNcm1DUn6enpyMrKwpAhQ4xjBoMBAGBvb49Tp04hMDDQvEFbsdv5d6uCg4MDunfvjtOnT5sjRJtTn5z4+vrCwcEBWq3WOHbXXXchNzcXZWVlcHR0NGvM1u52PidFRUVISEjA7NmzzRmiTalPPqZPn47Ro0fjhRdeAAB06dIFRUVFePHFFzFt2jTV/ULf0NQnJ15eXti2bRtKSkpw6dIl+Pn5YcqUKWjbtq0lQr5l/JuhIEdHR/To0QNJSUnGMYPBgKSkJISEhNT4vIULF2LOnDlITExEz549LRGqzahvTm5kMBhQWlpqjhBtTl1z0rFjRxw9ehRpaWnG7fHHH8eDDz6ItLQ0BAQEWDJ8q2OKz4her8fRo0fh6+trrjBtSn1y0qdPH5w+fdr4xQMA/Pbbb/D19WVhZQK38zn56quvUFpaimeffdbcYdqM+uSjuLj4pgKq4ssIIYT5grURt/MZcXZ2hr+/P8rLy7F582YMHTrU3OHWjcINNWxeQkKCcHJyEuvWrRMnTpwQL774omjSpImxTfHo0aPFlClTjMfPnz9fODo6iq+//rpKy9aCggKlTsHq1DUn8+bNE7t37xbp6enixIkTYtGiRcLe3l6sXr1aqVOwOnXNyY3YLdC06pqPWbNmiV27don09HSRmpoqRowYIZydncXx48eVOgWrU9ecZGdnC3d3dxEZGSlOnTolduzYIby9vcW7776r1ClYnfr+u9W3b18RHh5u6XCtXl3zMXPmTOHu7i42bdokMjIyxO7du0VgYKAYPny4Uqdgdeqakx9//FFs3rxZpKeni/3794sBAwaINm3aiMuXLyt0BtXjskCFhYeH48KFC5gxYwZyc3MRFBSExMRE4wV+2dnZVb45WblyJcrKyvDMM89UeZ2ZM2ciNjbWkqFbrbrmpKioCBMnTsTZs2fh4uKCjh074vPPP0d4eLhSp2B16poTMq+65uPy5cuYMGECcnNz0bRpU/To0QMHDx5Ep06dlDoFq1PXnAQEBGDXrl1444030LVrV/j7++O1117D5MmTlToFq1Off7dOnTqF5ORk7N69W4mQrVpd8xETEwONRoOYmBicO3cOXl5eGDJkCObOnavUKViduuakpKQEMTExyMjIgJubG8LCwrBhwwY0adJEoTOonkYIzm0SERERERHdLn7VS0REREREZAIsroiIiIiIiEyAxRUREREREZEJsLgiIiIiIiIyARZXREREREREJsDiioiIiIiIyARYXBEREREREZkAiysiIiIiIiITYHFFREQ2a9++fdBoNLhy5YrSoeDAgQPo0qULHBwc8MQTTygdDhER1QOLKyIisrhx48ZBo9HctJ0+fdps79m/f3+8/vrrVcZ69+6NnJwceHh4mO19b1VUVBSCgoKQmZmJdevWVXuMEAIzZsyAr68vXFxcEBoait9//92ygRIRUY1YXBERkSIeeeQR5OTkVNnatGlz03FlZWVmi8HR0RE+Pj7QaDRme49blZ6ejgEDBqBFixZo0qRJtccsXLgQH3zwAVatWoWUlBS4urpi0KBBKCkpsWywRERULRZXRESkCCcnJ/j4+FTZtFot+vfvj8jISLz++uvw9PTEoEGDAABLlixBly5d4OrqioCAAEycOBGFhYVVXvPAgQPo378/GjVqhKZNm2LQoEG4fPkyxo0bhx9++AHLli0zzpJlZWVVuyxw8+bNuPvuu+Hk5ITWrVtj8eLFVd6jdevWmDdvHp577jm4u7ujZcuW+Pjjj2s919LSUrz66qvw9vaGs7Mz+vbti59//hkAkJWVBY1Gg0uXLuG5556DRqOpduZKCIGlS5ciJiYGQ4cORdeuXfHZZ5/h/Pnz2LZtW90TQEREJsfiioiIVGf9+vVwdHTEgQMHsGrVKgCAnZ0dPvjgAxw/fhzr16/H3r17ER0dbXxOWloaHnroIXTq1AmHDh1CcnIyhgwZAr1ej2XLliEkJAQTJkwwzpIFBATc9L6pqakYPnw4RowYgaNHjyI2NhbTp0+/qdhZvHgxevbsif/973+YOHEiXn75ZZw6darG84mOjsbmzZuxfv16HD58GO3atcOgQYPw119/ISAgADk5OWjcuDGWLl2KnJwchIeH3/QamZmZyM3NRWhoqHHMw8MDvXr1wqFDh+r6IyYiInMQREREFjZ27Fih1WqFq6urcXvmmWeEEEL069dPdO/e/R9f46uvvhJ33HGHcX/kyJGiT58+NR7fr18/8dprr1UZ+/777wUAcfnyZSGEEBEREWLgwIFVjnn77bdFp06djPutWrUSzz77rHHfYDAIb29vsXLlymrft7CwUDg4OIiNGzcax8rKyoSfn59YuHChcczDw0OsXbu2xvgPHDggAIjz589XGR82bJgYPnx4jc8jIiLLsVe6uCMiItv04IMPYuXKlcZ9V1dX45979Ohx0/F79uxBXFwcfv31V+Tn56O8vBwlJSUoLi5Go0aNkJaWhmHDht1WTCdPnsTQoUOrjPXp0wdLly6FXq+HVqsFAHTt2tX4uEajgY+PD/78889qXzM9PR06nQ59+vQxjjk4OCA4OBgnT568rXiJiEhduCyQiIgU4erqinbt2hk3X1/fKo9dLysrC4899hi6du2KzZs3IzU1FcuXLwdQ2fDCxcXFYrE7ODhU2ddoNDAYDGZ9Tx8fHwBAXl5elfG8vDzjY0REpCwWV0REpHqpqakwGAxYvHgx7rvvPrRv3x7nz5+vckzXrl2RlJRU42s4OjpCr9fX+j533XUXDhw4UGXswIEDaN++vXHWqq4CAwON149V0Ol0+Pnnn9GpU6dbfp02bdrAx8enyjnm5+cjJSUFISEh9YqNiIhMi8sCiYhI9dq1awedTocPP/wQQ4YMqdLoosLUqVPRpUsXTJw4ES+99BIcHR3x/fffY9iwYfD09ETr1q2RkpKCrKwsuLm5oVmzZje9z5tvvol7770Xc+bMQXh4OA4dOoSPPvoIK1asqHfsrq6uePnll/H222+jWbNmaNmyJRYuXIji4mI8//zzt/w6Go0Gr7/+Ot59913ceeedaNOmDaZPnw4/Pz/edJiISCU4c0VERKrXrVs3LFmyBAsWLEDnzp2xceNGxMXFVTmmffv22L17N44cOYLg4GCEhIRg+/btsLeX3yO+9dZb0Gq16NSpE7y8vJCdnX3T+9xzzz348ssvkZCQgM6dO2PGjBmYPXs2xo0bd1vxz58/H08//TRGjx6Ne+65B6dPn8auXbvQtGnTOr1OdHQ0XnnlFbz44ou49957UVhYiMTERDg7O99WfEREZBoaIYRQOggiIiIiIqKGjjNXREREREREJsDiioiIiIiIyARYXBEREREREZkAiysiIiIiIiITYHFFRERERERkAiyuiIiIiIiITIDFFRERERERkQmwuCIiIiIiIjIBFldEREREREQmwOKKiIiIiIjIBFhcERERERERmcD/AygSMz9YiwRrAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def evaluate_models_online(training_dataset, test_datasets):\n",
    "    # Prepare the test data\n",
    "    \n",
    "    accuracies = []\n",
    "    precisions = []\n",
    "    recalls = []\n",
    "    ratios = []\n",
    "    og_accuracies = []\n",
    "    og_precisions = []\n",
    "    og_recalls = []\n",
    "    \n",
    "    X_train, y_train = zip(*[(x.detach().numpy().flatten(), y) for x, y in training_dataset])\n",
    "    X_train = np.array(X_train)\n",
    "    y_train = np.array(y_train)\n",
    "\n",
    "    model = BiasedRandomForestClassifier()\n",
    "    model.fit(X_train, y_train)\n",
    "    og = RandomForestClassifier()\n",
    "    og.fit(X_train, y_train)\n",
    "\n",
    "    for ratio, test_dataset in test_datasets.items():\n",
    "        print('Test Bias Ratio: ', ratio)\n",
    "        #print('Fitted thresholds: ', thresholds)\n",
    "        \n",
    "        X_test, y_test = zip(*[(x.detach().numpy().flatten(), y) for x, y in test_dataset])\n",
    "        X_test = np.array(X_test)\n",
    "        y_test = np.array(y_test)\n",
    "\n",
    "        predictions = model.predict_biased_online_recall(X_test, y_test, alpha = 0.1)[0] # chage this to \n",
    "        accuracies.append(accuracy_score(y_test, predictions))\n",
    "        og_accuracies.append(accuracy_score(y_test, og.predict(X_test)))\n",
    "        og_precisions.append(precision_score(y_test, og.predict(X_test), average='macro'))\n",
    "        og_recalls.append(recall_score(y_test, og.predict(X_test), average='macro'))\n",
    "        precisions.append(precision_score(y_test, predictions, average='macro'))\n",
    "        recalls.append(recall_score(y_test, predictions, average='macro'))\n",
    "        ratios.append(ratio)\n",
    "\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_accuracies, label='RF Accuracy', color='blue')\n",
    "    plt.plot(ratios, accuracies, label='DeBOT Accuracy', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_precisions, label='RF Precision', color='blue')\n",
    "    plt.plot(ratios, precisions, label='DeBOT Precision', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_recalls, label='RF Recall', color='blue')\n",
    "    plt.plot(ratios, recalls, label='DeBOT Recall', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "evaluate_models_online(encoded_train, encoded_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1acb8dd3",
   "metadata": {},
   "source": [
    "Original heuristic which penalizes the threshold for wrongly classified class and boosts the true class it wasn't classified into"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8a8b530c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Bias Ratio:  0.2\n",
      "Test Bias Ratio:  0.3\n",
      "Test Bias Ratio:  0.4\n",
      "Test Bias Ratio:  0.5\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[16], line 70\u001b[0m\n\u001b[0;32m     68\u001b[0m     plt\u001b[38;5;241m.\u001b[39mgrid(\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m     69\u001b[0m     plt\u001b[38;5;241m.\u001b[39mshow()\n\u001b[1;32m---> 70\u001b[0m \u001b[43mevaluate_models_online\u001b[49m\u001b[43m(\u001b[49m\u001b[43mencoded_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencoded_test\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[16], line 29\u001b[0m, in \u001b[0;36mevaluate_models_online\u001b[1;34m(training_dataset, test_datasets)\u001b[0m\n\u001b[0;32m     26\u001b[0m X_test \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(X_test)\n\u001b[0;32m     27\u001b[0m y_test \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(y_test)\n\u001b[1;32m---> 29\u001b[0m predictions \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict_biased_online\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malpha\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m)\u001b[49m[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;66;03m# chage this to \u001b[39;00m\n\u001b[0;32m     30\u001b[0m accuracies\u001b[38;5;241m.\u001b[39mappend(accuracy_score(y_test, predictions))\n\u001b[0;32m     31\u001b[0m og_accuracies\u001b[38;5;241m.\u001b[39mappend(accuracy_score(y_test, og\u001b[38;5;241m.\u001b[39mpredict(X_test)))\n",
      "Cell \u001b[1;32mIn[8], line 79\u001b[0m, in \u001b[0;36mBiasedRandomForestClassifier.predict_biased_online\u001b[1;34m(self, X, y, alpha)\u001b[0m\n\u001b[0;32m     77\u001b[0m threshold_history \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m     78\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m (xi, yi) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(X, y):\n\u001b[1;32m---> 79\u001b[0m     proba \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict_proba\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mxi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     80\u001b[0m     predicted_class \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39margmax(proba \u001b[38;5;241m-\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mthresholds, axis \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m)[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m     81\u001b[0m     res\u001b[38;5;241m.\u001b[39mappend(predicted_class)\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\sklearn\\ensemble\\_forest.py:850\u001b[0m, in \u001b[0;36mForestClassifier.predict_proba\u001b[1;34m(self, X)\u001b[0m\n\u001b[0;32m    845\u001b[0m all_proba \u001b[38;5;241m=\u001b[39m [\n\u001b[0;32m    846\u001b[0m     np\u001b[38;5;241m.\u001b[39mzeros((X\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], j), dtype\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mfloat64)\n\u001b[0;32m    847\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m np\u001b[38;5;241m.\u001b[39matleast_1d(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_classes_)\n\u001b[0;32m    848\u001b[0m ]\n\u001b[0;32m    849\u001b[0m lock \u001b[38;5;241m=\u001b[39m threading\u001b[38;5;241m.\u001b[39mLock()\n\u001b[1;32m--> 850\u001b[0m \u001b[43mParallel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    851\u001b[0m \u001b[43m    \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    852\u001b[0m \u001b[43m    \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    853\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m_joblib_parallel_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrequire\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msharedmem\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    854\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    855\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_accumulate_prediction\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43me\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict_proba\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mall_proba\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlock\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    856\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43me\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mestimators_\u001b[49m\n\u001b[0;32m    857\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    859\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m proba \u001b[38;5;129;01min\u001b[39;00m all_proba:\n\u001b[0;32m    860\u001b[0m     proba \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimators_)\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\joblib\\parallel.py:1046\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[1;34m(self, iterable)\u001b[0m\n\u001b[0;32m   1043\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdispatch_one_batch(iterator):\n\u001b[0;32m   1044\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_iterating \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_original_iterator \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m-> 1046\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdispatch_one_batch\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[0;32m   1047\u001b[0m     \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[0;32m   1049\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pre_dispatch \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mall\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m n_jobs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m   1050\u001b[0m     \u001b[38;5;66;03m# The iterable was consumed all at once by the above for loop.\u001b[39;00m\n\u001b[0;32m   1051\u001b[0m     \u001b[38;5;66;03m# No need to wait for async callbacks to trigger to\u001b[39;00m\n\u001b[0;32m   1052\u001b[0m     \u001b[38;5;66;03m# consumption.\u001b[39;00m\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\joblib\\parallel.py:861\u001b[0m, in \u001b[0;36mParallel.dispatch_one_batch\u001b[1;34m(self, iterator)\u001b[0m\n\u001b[0;32m    859\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m    860\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 861\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_dispatch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtasks\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    862\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\joblib\\parallel.py:779\u001b[0m, in \u001b[0;36mParallel._dispatch\u001b[1;34m(self, batch)\u001b[0m\n\u001b[0;32m    777\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n\u001b[0;32m    778\u001b[0m     job_idx \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs)\n\u001b[1;32m--> 779\u001b[0m     job \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_backend\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_async\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallback\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    780\u001b[0m     \u001b[38;5;66;03m# A job can complete so quickly than its callback is\u001b[39;00m\n\u001b[0;32m    781\u001b[0m     \u001b[38;5;66;03m# called before we get here, causing self._jobs to\u001b[39;00m\n\u001b[0;32m    782\u001b[0m     \u001b[38;5;66;03m# grow. To ensure correct results ordering, .insert is\u001b[39;00m\n\u001b[0;32m    783\u001b[0m     \u001b[38;5;66;03m# used (rather than .append) in the following line\u001b[39;00m\n\u001b[0;32m    784\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jobs\u001b[38;5;241m.\u001b[39minsert(job_idx, job)\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\joblib\\_parallel_backends.py:208\u001b[0m, in \u001b[0;36mSequentialBackend.apply_async\u001b[1;34m(self, func, callback)\u001b[0m\n\u001b[0;32m    206\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mapply_async\u001b[39m(\u001b[38;5;28mself\u001b[39m, func, callback\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m    207\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Schedule a func to be run\"\"\"\u001b[39;00m\n\u001b[1;32m--> 208\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[43mImmediateResult\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    209\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m callback:\n\u001b[0;32m    210\u001b[0m         callback(result)\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\joblib\\_parallel_backends.py:572\u001b[0m, in \u001b[0;36mImmediateResult.__init__\u001b[1;34m(self, batch)\u001b[0m\n\u001b[0;32m    569\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, batch):\n\u001b[0;32m    570\u001b[0m     \u001b[38;5;66;03m# Don't delay the application, to avoid keeping the input\u001b[39;00m\n\u001b[0;32m    571\u001b[0m     \u001b[38;5;66;03m# arguments in memory\u001b[39;00m\n\u001b[1;32m--> 572\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mresults \u001b[38;5;241m=\u001b[39m \u001b[43mbatch\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\joblib\\parallel.py:262\u001b[0m, in \u001b[0;36mBatchedCalls.__call__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    258\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m    259\u001b[0m     \u001b[38;5;66;03m# Set the default nested backend to self._backend but do not set the\u001b[39;00m\n\u001b[0;32m    260\u001b[0m     \u001b[38;5;66;03m# change the default number of processes to -1\u001b[39;00m\n\u001b[0;32m    261\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m parallel_backend(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backend, n_jobs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_n_jobs):\n\u001b[1;32m--> 262\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m [func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    263\u001b[0m                 \u001b[38;5;28;01mfor\u001b[39;00m func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mitems]\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\joblib\\parallel.py:262\u001b[0m, in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m    258\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m    259\u001b[0m     \u001b[38;5;66;03m# Set the default nested backend to self._backend but do not set the\u001b[39;00m\n\u001b[0;32m    260\u001b[0m     \u001b[38;5;66;03m# change the default number of processes to -1\u001b[39;00m\n\u001b[0;32m    261\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m parallel_backend(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backend, n_jobs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_n_jobs):\n\u001b[1;32m--> 262\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m [func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    263\u001b[0m                 \u001b[38;5;28;01mfor\u001b[39;00m func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mitems]\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\sklearn\\utils\\fixes.py:209\u001b[0m, in \u001b[0;36m_FuncWrapper.__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m    207\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m    208\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m config_context(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig):\n\u001b[1;32m--> 209\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\sklearn\\ensemble\\_forest.py:629\u001b[0m, in \u001b[0;36m_accumulate_prediction\u001b[1;34m(predict, X, out, lock)\u001b[0m\n\u001b[0;32m    622\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_accumulate_prediction\u001b[39m(predict, X, out, lock):\n\u001b[0;32m    623\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    624\u001b[0m \u001b[38;5;124;03m    This is a utility function for joblib's Parallel.\u001b[39;00m\n\u001b[0;32m    625\u001b[0m \n\u001b[0;32m    626\u001b[0m \u001b[38;5;124;03m    It can't go locally in ForestClassifier or ForestRegressor, because joblib\u001b[39;00m\n\u001b[0;32m    627\u001b[0m \u001b[38;5;124;03m    complains that it cannot pickle it when placed there.\u001b[39;00m\n\u001b[0;32m    628\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 629\u001b[0m     prediction \u001b[38;5;241m=\u001b[39m \u001b[43mpredict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[0;32m    630\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m lock:\n\u001b[0;32m    631\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(out) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n",
      "File \u001b[1;32mc:\\Users\\ronsh\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\sklearn\\tree\\_classes.py:972\u001b[0m, in \u001b[0;36mDecisionTreeClassifier.predict_proba\u001b[1;34m(self, X, check_input)\u001b[0m\n\u001b[0;32m    970\u001b[0m check_is_fitted(\u001b[38;5;28mself\u001b[39m)\n\u001b[0;32m    971\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_validate_X_predict(X, check_input)\n\u001b[1;32m--> 972\u001b[0m proba \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtree_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    974\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_outputs_ \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m    975\u001b[0m     proba \u001b[38;5;241m=\u001b[39m proba[:, : \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_classes_]\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "def evaluate_models_online(training_dataset, test_datasets):\n",
    "    # Prepare the test data\n",
    "    \n",
    "    accuracies = []\n",
    "    precisions = []\n",
    "    recalls = []\n",
    "    ratios = []\n",
    "    og_accuracies = []\n",
    "    og_precisions = []\n",
    "    og_recalls = []\n",
    "    \n",
    "    X_train, y_train = zip(*[(x.detach().numpy().flatten(), y) for x, y in training_dataset])\n",
    "    X_train = np.array(X_train)\n",
    "    y_train = np.array(y_train)\n",
    "\n",
    "    model = BiasedRandomForestClassifier()\n",
    "    model.fit(X_train, y_train)\n",
    "    og = RandomForestClassifier()\n",
    "    og.fit(X_train, y_train)\n",
    "\n",
    "    for ratio, test_dataset in test_datasets.items():\n",
    "        print('Test Bias Ratio: ', ratio)\n",
    "        #print('Fitted thresholds: ', thresholds)\n",
    "        \n",
    "        X_test, y_test = zip(*[(x.detach().numpy().flatten(), y) for x, y in test_dataset])\n",
    "        X_test = np.array(X_test)\n",
    "        y_test = np.array(y_test)\n",
    "\n",
    "        predictions = model.predict_biased_online(X_test, y_test, alpha = 0.1)[0] # chage this to \n",
    "        accuracies.append(accuracy_score(y_test, predictions))\n",
    "        og_accuracies.append(accuracy_score(y_test, og.predict(X_test)))\n",
    "        og_precisions.append(precision_score(y_test, og.predict(X_test), average='macro'))\n",
    "        og_recalls.append(recall_score(y_test, og.predict(X_test), average='macro'))\n",
    "        precisions.append(precision_score(y_test, predictions, average='macro'))\n",
    "        recalls.append(recall_score(y_test, predictions, average='macro'))\n",
    "        ratios.append(ratio)\n",
    "\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_accuracies, label='RF Accuracy', color='blue')\n",
    "    plt.plot(ratios, accuracies, label='DeBOT Accuracy', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_precisions, label='RF Precision', color='blue')\n",
    "    plt.plot(ratios, precisions, label='DeBOT Precision', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(ratios, og_recalls, label='RF Recall', color='blue')\n",
    "    plt.plot(ratios, recalls, label='DeBOT Recall', color='red')\n",
    "\n",
    "    plt.xlabel('Fraction of 0')\n",
    "    plt.ylabel('Performance Metrics')\n",
    "    plt.title('Performance Metrics for Different Sample Ratios')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "evaluate_models_online(encoded_train, encoded_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c4794ed",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'histories' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\myuhk\\Downloads\\Experiment 1 - MNIST.ipynb Cell 17\u001b[0m line \u001b[0;36m1\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/myuhk/Downloads/Experiment%201%20-%20MNIST.ipynb#X21sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m plot_threshold_history(histories[\u001b[39m0.9\u001b[39m])\n",
      "\u001b[1;31mNameError\u001b[0m: name 'histories' is not defined"
     ]
    }
   ],
   "source": [
    "plot_threshold_history(histories[0.9])"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}