ANLP_WS24_CA2/cnn_reg_test.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNN Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import json\n",
    "import math\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from tqdm import tqdm  # Fortschrittsbalken\n",
    "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# local imports\n",
    "import ml_evaluation as ml_eval\n",
    "import ml_helper\n",
    "import ml_history\n",
    "import dataset_generator as data_gen\n",
    "# class imports\n",
    "import HumorDataset as humor_ds\n",
    "import EarlyStopping\n",
    "import BalancedCELoss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(0)\n",
    "np.random.seed(0)\n",
    "\n",
    "\n",
    "best_model_filename = 'best_cnn_reg_model.pt'\n",
    "\n",
    "device = ml_helper.get_device(verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_matrix, word_index, vocab_size, d_model = data_gen.create_embedding_matrix()\n",
    "\n",
    "vocab_size = len(embedding_matrix)\n",
    "d_model = len(embedding_matrix[0])\n",
    "vocab_size, d_model = embedding_matrix.size()\n",
    "print(f\"vocab_size: {vocab_size}, d_model: {d_model}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN_HumorRegressor(nn.Module):\n",
    "    def __init__(self, embed_dim, filter_sizes, num_filters, dropout=0.5):\n",
    "        super(CNN_HumorRegressor, self).__init__()\n",
    "\n",
    "        # Convolutional Layers mit verschiedenen Filtergrößen\n",
    "        self.convs = nn.ModuleList([\n",
    "            nn.Conv2d(in_channels=1, out_channels=num_filters, kernel_size=(fs, embed_dim)) \n",
    "            for fs in filter_sizes\n",
    "        ])\n",
    "\n",
    "        # Highway-Netzwerk für bessere Feature-Extraktion\n",
    "        self.highway = nn.Linear(len(filter_sizes) * num_filters, len(filter_sizes) * num_filters)\n",
    "\n",
    "        # Dropout zur Vermeidung von Overfitting\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "        # Fully Connected Layers\n",
    "        self.fc1 = nn.Linear(len(filter_sizes) * num_filters, 256)\n",
    "        self.fc2 = nn.Linear(256, 128)\n",
    "        self.fc3 = nn.Linear(128, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.unsqueeze(1)  # [Batch Size, 1, Seq Length, Embed Dim]\n",
    "\n",
    "        # Convolution + ReLU activation\n",
    "        conved = [F.relu(conv(x)).squeeze(3) for conv in self.convs]\n",
    "\n",
    "        # Max-Pooling über jede Feature-Map\n",
    "        pooled = [F.max_pool1d(c, c.size(2)).squeeze(2) for c in conved]\n",
    "\n",
    "        # Feature-Vektor kombinieren\n",
    "        cat = torch.cat(pooled, dim=1)\n",
    "\n",
    "        # Highway-Netzwerk\n",
    "        highway = F.relu(self.highway(cat))\n",
    "        highway = self.dropout(highway + cat)\n",
    "\n",
    "        # Fully Connected Layers\n",
    "        fc_out = F.relu(self.fc1(highway))\n",
    "        fc_out = F.relu(self.fc2(fc_out))\n",
    "        return torch.sigmoid(self.fc3(fc_out))  # Sigmoid für Wertebereich [0, 1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_preprocess_data(path_data='data/hack.csv'):\n",
    "    df = pd.read_csv(path_data)\n",
    "    df = df.dropna(subset=['humor_rating'])\n",
    "\n",
    "    df['y'] = df['humor_rating']\n",
    "    X = df['text']\n",
    "    y = df['y']\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X,y = load_preprocess_data()\n",
    "\n",
    "ret_dict = data_gen.split_data(X, y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    # used for class balancing\n",
    "    'equalize_classes_loss_factor': 0.15, # 0.15 (0.1 to 0.2)\n",
    "    # training parameters\n",
    "    'batch_size': 32, # 32 (16 to 64)\n",
    "    'epochs': 10, # 100\n",
    "    'lr': 1e-4, # 1e-5 (1e-6 to 1e-3)\n",
    "    \n",
    "    # CNN parameters\n",
    "    'filter_sizes': [2, 3, 4],\n",
    "    'num_filters': 150,\n",
    "    \n",
    "    # patience for early stopping\n",
    "    'early_stopping_patience': 5, # 5 (3 to 10)\n",
    "\n",
    "    # learning rate scheduler\n",
    "    'lr_scheduler_factor': 0.5, # 0.1 (0.05 to 0.2)\n",
    "    'lr_scheduler_patience': 3, # 3 (2 to 5)\n",
    "\n",
    "    # model parameters\n",
    "    'nhead': 2, # 5\n",
    "    'num_layers': 3, # 6\n",
    "    'hidden_dim': 10, # 50\n",
    "    \n",
    "\n",
    "    # regularization parameters\n",
    "    'positional_dropout': 0.5, # 0.1 (0.1 to 0.5)\n",
    "    'classifier_dropout': 0.5, # 0.1 (0.1 to 0.5)\n",
    "    'weight_decay': 1e-2 # 0.0  (1e-6 to 1e-2)\n",
    "}\n",
    "\n",
    "# Model initialization\n",
    "model = CNN_HumorRegressor(embed_dim=d_model, filter_sizes=params['filter_sizes'], num_filters=params['num_filters'], dropout=params['classifier_dropout'])\n",
    "model.to(device)\n",
    "print('model created')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: Info comes from data explore notebook: 280 is max length,\n",
    "# 139 contains 80% and 192 contains 95% of the data\n",
    "max_len = 280\n",
    "\n",
    "train_dataset = humor_ds.TextDataset(ret_dict['train']['X'], ret_dict['train']['y'], word_index, max_len=max_len)\n",
    "val_dataset =  humor_ds.TextDataset(ret_dict['val']['X'], ret_dict['val']['y'], word_index, max_len=max_len)\n",
    "test_dataset =  humor_ds.TextDataset(ret_dict['test']['X'], ret_dict['test']['y'], word_index, max_len=max_len)\n",
    "\n",
    "print('datasets length:', len(train_dataset), len(val_dataset))\n",
    "#NOTE: overfitting test\n",
    "#train_dataset.labels = train_dataset.labels[:100]\n",
    "#train_dataset.texts = train_dataset.texts[:100]\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=params['batch_size'], shuffle=True)\n",
    "val_loader = DataLoader(val_dataset, batch_size=params['batch_size'], shuffle=False)\n",
    "test_loader = DataLoader(test_dataset, batch_size=params['batch_size'], shuffle=False)\n",
    "\n",
    "# NOTE: samller because of batches not all data\n",
    "print(f\"train: {len(train_loader)}, val: {len(val_loader)}, test: {len(test_loader)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TODO: change to RMSE\n",
    "\"\"\"\n",
    "criterion = nn.MSELoss()\n",
    "loss = torch.sqrt(criterion(x, y))\n",
    "loss.backward()\n",
    "print(x.grad)\n",
    "\"\"\"\n",
    "criterion = nn.MSELoss()\n",
    "\n",
    "optimizer = torch.optim.Adam((p for p in model.parameters() if p.requires_grad), \n",
    "                            lr=params['lr']) #, \n",
    "                            #weight_decay=params['weight_decay'])\n",
    "\"\"\"\n",
    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', \n",
    "                                                        factor=params['lr_scheduler_factor'],\n",
    "                                                        patience=params['lr_scheduler_patience'],\n",
    "                                                        verbose=True)\n",
    "\"\"\"\n",
    "early_stopping = EarlyStopping.EarlyStopping(patience=params['early_stopping_patience'], verbose=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training loop\n",
    "\n",
    "for epoch in range(params['epochs']):\n",
    "    epoch_start_time = time.time()\n",
    "    model.train()\n",
    "    \n",
    "    train_loss = 0.0\n",
    "    \n",
    "    for batch in train_loader:\n",
    "        optimizer.zero_grad()\n",
    "        input_ids, labels = batch\n",
    "        input_ids, labels = input_ids.to(device), labels.to(device).float() \n",
    "\n",
    "        outputs = model(input_ids)\n",
    "        outputs = outputs.squeeze().float()\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        #torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=params['clipping_max_norm'])\n",
    "        optimizer.step()\n",
    "        preds = outputs\n",
    "        \n",
    "        train_loss += loss.item()\n",
    "\n",
    "    train_loss /= len(train_loader)\n",
    "    \n",
    "    # Validation\n",
    "    model.eval()\n",
    "    val_loss = 0.0\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for batch in val_loader:\n",
    "            input_ids, labels = batch\n",
    "            input_ids, labels = input_ids.to(device), labels.to(device).float() \n",
    "            outputs = model(input_ids)\n",
    "            outputs = outputs.squeeze().float()\n",
    "            loss = criterion(outputs, labels)\n",
    "            preds = outputs\n",
    "            \n",
    "            val_loss += loss.item()\n",
    "\n",
    "    val_loss /= len(val_loader)\n",
    "    \n",
    "    epoch_end_time = time.time()\n",
    "    \n",
    "    print(f'Epoch {epoch+1}/{params[\"epochs\"]}, '\n",
    "          f'Train Loss: {train_loss:.4f}, '\n",
    "          f'Val Loss: {val_loss:.4f}, '\n",
    "          f'Time: {epoch_end_time - epoch_start_time:.2f}s')\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics on Test Data:\n",
      "Mean Squared Error (MSE): 0.3358\n",
      "Root Mean Squared Error (RMSE): 0.5795\n",
      "Mean Absolute Error (MAE): 0.3900\n",
      "R² Score: -0.3445\n"
     ]
    }
   ],
   "source": [
    "# TODO: Evaluate model\n",
    "'''\n",
    "def evaluate_metrics(model, test_loader, device):\n",
    "    model.eval()\n",
    "    predictions = []\n",
    "    actuals = []\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in test_loader:\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            outputs = model(inputs)\n",
    "            predictions.extend(outputs.cpu().numpy().flatten())\n",
    "            actuals.extend(labels.cpu().numpy().flatten())\n",
    "\n",
    "    mse = mean_squared_error(actuals, predictions)\n",
    "    rmse = np.sqrt(mse)\n",
    "    mae = mean_absolute_error(actuals, predictions)\n",
    "    r2 = r2_score(actuals, predictions)\n",
    "\n",
    "    return mse, rmse, mae, r2, actuals, predictions\n",
    "\n",
    "mse, rmse, mae, r2, actuals, predictions = evaluate_metrics(model, test_loader, device)\n",
    "\n",
    "print(\"Evaluation Metrics on Test Data:\")\n",
    "print(f\"Mean Squared Error (MSE): {mse:.4f}\")\n",
    "print(f\"Root Mean Squared Error (RMSE): {rmse:.4f}\")\n",
    "print(f\"Mean Absolute Error (MAE): {mae:.4f}\")\n",
    "print(f\"R² Score: {r2:.4f}\")\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#TODO: Plotting\n",
    "'''\n",
    "# Definiere korrekte und falsche Vorhersagen basierend auf einem Schwellenwert\n",
    "threshold = 0.5\n",
    "predicted_labels = (np.array(predictions) > threshold).astype(int)\n",
    "true_labels = (np.array(actuals) > threshold).astype(int)\n",
    "\n",
    "# Bool-Array für korrekte Vorhersagen\n",
    "correct = predicted_labels == true_labels\n",
    "\n",
    "# Farben zuordnen: Grün für korrekt, Rot für falsch\n",
    "colors = ['green' if is_correct else 'red' for is_correct in correct]\n",
    "\n",
    "# Scatter-Plot\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(actuals, predictions, c=colors, alpha=0.6, edgecolor='k')\n",
    "\n",
    "\n",
    "# Legende anpassen\n",
    "import matplotlib.patches as mpatches\n",
    "green_patch = mpatches.Patch(color='green', label='Correct Predictions')\n",
    "red_patch = mpatches.Patch(color='red', label='Incorrect Predictions')\n",
    "plt.legend(handles=[green_patch, red_patch])\n",
    "\n",
    "# Achsen und Titel\n",
    "plt.title('True vs. Predicted Humor Scores')\n",
    "plt.xlabel('True Humor Score')\n",
    "plt.ylabel('Predicted Humor Score')\n",
    "plt.show()\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "239\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVstJREFUeJzt3Qm8zPX+x/HPIWuFZA2hlCV7yNKlopC6tF/1vyTpaiVSV4uljVJJUVou2lyl0L0lS7Ika6JClBIqW4s1u/k/3t/bb5oZM8c5x5wzM7/zej4eP37zm9/MfH+/mTO/z3y/n+/3mxYIBAIGAADgE3kSXQAAAIB4IrgBAAC+QnADAAB8heAGAAD4CsENAADwFYIbAADgKwQ3AADAVwhuAACArxDcAAAAXyG4AVJQWlqaDRgwINHF8KXzzjvPLZ7vv//ene8xY8bE7TUqVapk119/vSXC4sWLrWnTpnb88ce741q2bFlCygFkJ4IbxJUuAPrC/PTTT6Per4tGzZo1zW90sdJxe4suHI0aNbJXX301y885efLkXBfAzJo1K+w85suXz0477TTr1KmTfffdd5ZK5s2b596/bdu2WbI4cOCAXXXVVfbrr7/a0KFD7bXXXrOKFSvmyN9ErCVeQeOjjz5qkyZNyvD+W7dutR49eli1atWsUKFCVqpUKfc3e88999iuXbt88X7nZsclugCAX9StW9d69+7t1jdu3Ggvv/yyde7c2fbt22fdunXLUnAzYsSIqAHOnj177Ljj/Pvne8cdd1jDhg3dxfizzz6zF1980d5//3378ssv7ZRTTsnRsujir/OtQCuzF7uBAwe6GppixYqF3bd69WrLkyfnf1t+++23tm7dOnvppZfsxhtvzNbXevrpp8OCBH2e//3vf7ugqkSJEsHtqkWKV3Bz5ZVXWocOHY66r4K7Bg0a2I4dO+yGG25wAc4vv/xiX3zxhT3//PN288032wknnBC39xs5z7/fjkAcHTx40A4fPmz58+ePuU+5cuXs//7v/4K39SWnWgd9mWcluElPwYIFzc/+8pe/uAuVdOnSxc4880wX8LzyyivWt2/fqI/ZvXu3qzGLN9UuxPt8FyhQwBJhy5Yt7v94XnxjnffIIGPTpk0uuNF21eok0r/+9S9bv369ffLJJ0cEVwp40vs7R2qgWQoJlV4+Q2Reida17euvv3ZBRNGiRa1kyZL2wAMPmCa337Bhg7Vv396KFCliZcqUsSeffDLql3vXrl2tdOnS7oJVp04dd8GMVqYnnnjC/fo8/fTT3cVo5cqVmTo2lU2/CPVrOdTHH3/smgZOPfVU97wVKlSwO++809UOhAZGqrXxzoO3HO3crFmzJvjLUedHgcHvv/8e9vp6HQUK+vV84okn2l//+lf78ccfj5rHs3nzZldbpF+nkVQToccPHz7c3VaNi/Y744wz3Hk++eST7dxzz7Xp06dbVlxwwQXu/7Vr14Ydr96Ta6+91k466ST3/J7XX3/dzj77bNfcULx4cfvb3/7mPh+RVCOk91f7qUlC701GP6OrVq2yq6++2r3PenzVqlXtvvvuC5avT58+br1y5crB90/PFSvnRs1u+lyovIULF7bGjRu72qpozXZvvfWWPfLII1a+fHl3flu2bOne+/To9Vq0aOHW9Tp6ntDcoo8++sgFlQpU9PnR39JXX30V9hxHO+9ZkZH36ptvvrErrrjC/V3reHXc2m/79u3ufpVJQZb+lr1znV5Ok/4m8+bN685xJH1/RAazCxcutDZt2ri/Kb03Oo8KjELPS3rvN3IeNTfIFvrS+fnnn4/YrovesbrmmmusevXqNnjwYPfl//DDD7svxRdeeMFdBB977DF744037K677nJNG82bNw9e1PVlrovAbbfd5r6Exo8f774E1U6u9vdQo0ePtr1799pNN93kghC9RmZre3744Qd3AQil11TAoapvXfQXLVpkzz77rNtX98k//vEP++mnn1wwoLyIjNLFVsc1aNAg15yjpjHlEuiceHS8ujj+/e9/d1/us2fPtnbt2h31uRUQ6ktdj+3fv3/YfW+++aa7WOii6X3Zqwxq+lDQoF/DysNSmS688ELLLC9A1PkKpddTAKUmCQW4oou+Al6dC72+cit0fvU5WLp0abDWQr/edZ71y71nz54uuFCgp/dZAWd61HyhQEBNVfp8KFhRGf/73/+617/88stdEB7ZDKNAKFbgqHLoc6HAU8epC7XK8/bbb9tll10Wtr8++2rW0mdcf2uPP/64XXfdde4iHIuOVbWLOldes5/eU/nwww+tbdu2rqZR753+VnTOmjVr5t6zyJqWaOc9KzLyXu3fv99at27tmndvv/12F+AoGH/vvffc360CDv2NeJ81vR+ioDW9psZDhw65x6npOD0K+nRuFIDpc6/zru8GfdcoGNZrZvb9Rg4IAHE0evRofdOlu5x11lnB/deuXeu26XGRtL1///7B21rXtptuuim47eDBg4Hy5csH0tLSAoMHDw5u/+233wKFChUKdO7cObjt6aefdo9//fXXg9v2798faNKkSeCEE04I7NixI6xMRYoUCWzZsiVDx12xYsXARRddFNi6datbvvzyy8Df//539zy33npr2L6///77EY8fNGiQO4Z169YFt+lxsf5EY52bG264IWy/yy67LHDyyScHby9ZssTt17Nnz7D9rr/++iOeM5oXXnjB7afjC1WjRo3ABRdcELxdp06dQLt27QKZNXPmTPf8o0aNcufxp59+Crz//vuBSpUqufOzePHisOPt2LFj2OO///77QN68eQOPPPJI2HaV97jjjgtu1/teqlSpQN26dQP79u0L7vfiiy+6523RokW6n9HmzZsHTjzxxLD3Sw4fPhxcHzJkiHucHh/t8xL62dT7oX0//vjj4LadO3cGKleu7I790KFDYeenevXqYeUeNmxY1Pcl1vkdP3582HadB52PX375Jbjt888/D+TJkyfQqVOn4LZY5z0jIs9HRt+rpUuXRi1zpOOPPz7snKZn06ZNgZIlS7rnrVatWqB79+6BsWPHBrZt23bE+3nGGWcEWrduHfbe6m9Y782FF14Y8/iQWDRLIVuoSUW1DpFL7dq1j/m5QxMhVVugxEBd79Xc5NEvPjUThPawUUKjfvV17NgxuE2/vPUrVomPqsEIpWrwzPzymjZtmttfS61atdyvQjULDRkyJGw/Vb97VJWuGi79atcx6NfqsejevXvYbdUuKFFSNScyZcoU9/8tt9wStp9+EWeEfqGqaUo1NZ7ly5e7ZgrVqIWe/xUrVrjmhKxQkqfOo5KHVavkNTnovU7veCdMmOByo1QToPPqLXrfVdMwc+ZMt59qkdREqceH5leoVks1AelR7cKcOXNcGdW0GCq06TAz9NlUDUBoE48SWlULoaaNyCZRfa5Cy633WbLSo0zJ7+oOrmMPrZ3U36pq2VS2SJHnPSsy+l5578fUqVOPaGLNKtVYff755+44fvvtNxs5cqRrZlMt50MPPRSsjdJ50WdY9+nvyCujPo9qCtTnQMeA5EOzFLKFvqgjL0SiJppozVWZEXlB0Zef2shDe2B42/WF5FEvEX1pRvZSUROXd38oNe9kxjnnnOOayFTdrQu+1vXFGZmcqETGfv362X/+8x93fygvhyBe58ZrEtPrKJdAx6jjjzy2KlWqZOj5dY71pa6mKV0ERIGOAh4FPp4HH3zQ5WwoEVhd/5WvoGawjAa3Oj+6YCt41WvqPYrWOyzyOHQh0oVJ73M0Xo8n772O3M/rep4eL4CI55AGKo8+P5FCP5uhr5fe+5yV1xb9GIj2+goqIpOGM/u3EU1G3yu9Vq9eveypp55yzc36XKi5zsu7y6qyZcu6nlHPPfecK4uOU823+uzpPv2I8oLz9Jqu9Dcb2fSMxCO4QULF+qWrACEWXfAysk2OJR8gtIYlI3QRbtWqlVtXjoCSiS+55BIbNmyY+3L2jku/htUVVeNpaB9dNJRDoF/Ox/orMDvOQyQlcqrmQL9q1f1dgY4CntDgUjkTykF59913XY2Wcn+Ui6BfyBnpgqyaL+9cZuY90vnTZ+qDDz6Iei4y2703WeXE+xzPv41oMvNeqXOA/j68z5NqW5XTtWDBApdcfCxUBgXhWlRLqGBLQZQ+p97fo2pf9VmPxi+fKb8huEFCeb94Ige+iqxFiQclESoRVF9YobU36vXi3R9P+qJUAq6SLpXMqSBG47Qo8VBNLBqYzhOtF1FWmzjSo2PU8avXUegv5qP1tAmlrrw6Hq9pSscTrXu2mjgUBGlRs58CHiWrZuf4Kkoi1QVev/Z1sYrFe6/1y9zrieUlvOvcqBddLF7Njmrn0pOZ90/lUY+zSNn12Yx8bYn1+gpas6OLfUbfq9CAV8v999/vxpRRsrOCZdWQxuvvRe+tvpPUVOeVUVTrebRgOzv+XpF15NwgofSloS9PtV2HUlVxvF188cVurI3QfBH1aFLvDP368rrJxpNqZ9Q0pkHTxPuFGvoLW+uq3YnkXVDiOeKpapSinV+dg4xSPo2eRzU248aNc81ukWOahDYHis6vmr7U4yU7qWlM51jd0CNrMXTbK5eaTJXTo4ujeuN41N37aOdbj1OgNmrUKNfEGPkaWXn/9NlUr7n58+cHt6kpSF3V1VOpRo0all3UBKNaCQXcoWVV8KZaEpUtke+V8sX0dxpKQY5+oIR+nnS+M/q3ol5lOr+R9B7odb0mOvWQUoCjYSGijVqs/KvQ1xdGKE4O1Nwg4fRLXl1b9b8uOgp0VBsQb0rOVHdxVW8vWbLEXTTUzVbjVWg8G435Em/qQqpcCeUL3Hrrra4ZSl+W6sKrpigFd++8807UXAl9sYqq4BVM6EKgJqFjoedUorSOV1/iXldw73xn9NenkoeV86AgSWWLHBROF2N1u9frqQZHCbw61+qCn510bvVLXjVJSsRV0KX3VbUxEydOdJ8BnXvlc2g/1UCp5kbHo33UxfdoOTfyzDPPuOTf+vXru+dU7YNeT0MTeHM1ee+fxr7R+6bXvPTSS6PWgvzzn/903Yj1edH7rXOmYENl0ucju0czVrOLXrtJkyYuMd/rCq6cluyaAiSj75W6Yutzo+7nquFRoKNkff096LPs0flWl3b9rSkRXe9JtDwm0ePV9KQu9nqcAnSN6aOAVfl79957r9tP511Nqjo3Z511lquFVHd6/e0q4Vl/v+r+771+Rt9v5IAE99aCT7uCe112I6mLbWhXcK9bZdeuXQNFixZ13Wuvvvpq1wU7VndndREOpe6f6gaakdfavHlzoEuXLoESJUoE8ufPH6hVq9YR3dC9rr/q2plR6tobq+vzmDFjwroSr1y5MtCqVSvX/Vzl6Natm+t2G9ndWN3cb7/9dtdlVd2gQ/9cM3puvPcjtHvq7t27XTfz4sWLuzJ06NAhsHr1ardfaHf69KjbvLraR3at9zz88MOBRo0aBYoVK+b2U3dbde1VF+ysdFWOFOt4Pe+8807g3HPPdZ8LLXp9HbOOM9Rzzz3nuvQWKFAg0KBBg8CcOXPc5+ZoXcFl+fLlrqu9jrFgwYKBqlWrBh544IGwfR566KFAuXLlXJfq0Pchsiu4fPvtt4Err7wy+Hw6f++9916Gzk96Qypk5PHy4YcfBpo1a+beLw2DcOmll7rPambOe3pidZU+2nv13XffuSEOTj/9dHde9Lk9//zzXXlDrVq1ynXR9z6X6XUL/+KLLwJ9+vQJ1K9f3z2fup6XLVs2cNVVVwU+++yzI/ZXd/TLL7/cDaugz4reP31PzZgxI0PvN3Jemv7JiSAKQPJSbUO9evXcaLEaDA4AUhk5N0AuEzrNg0fNVKqC90ZzBoBURs4NkMtoqH7lHJ1//vlu7Bh1xdWiHIejTTsAAKmAZikgl1G3c/VQ0ai36gGiAeE0wJ4SIaMNlAcAqYbgBgAA+Ao5NwAAwFcIbgAAgK/kugZ2DT3/008/ucGiGC4bAIDUoCyanTt3ukEajzawZa4LbhTY0CMEAIDUtGHDhqNOmJrrghtviH2dHA2dDSB1aD4g/WrzfqgwtD2Qe+zYscNVTmRkqpxcF9x4TVEKbAhugNTiTTwq+vsluAFyn7QMpJSQUAwAAHyF4AYAAPhKrmuWApC6NIJy586dg+sAEA3fDjEcOnTIDhw4kOhiADkmX758YTktyahAgQI2ZsyYRBcDQJIjuInSj37Tpk22bdu2RBcFyHHFihWzMmXKMAYUgJRGcBPBC2xKlSplhQsX5kseuSao//33323Lli3udtmyZS2Zyyn8fQKIheAmoinKC2xOPvnkRBcHyFGFChVy/yvA0d9AMjZRKbA54YQT3LpmNKcrOIBo6C0Vwsux0S9CIDfyPvvkmwFIZQQ3UVDVjdyKzz4APyC4AQAAvkLOTQat377efv795xx7vRKFS9ipRU/NsdfD/6ibcc+ePYO95QYMGGCTJk2yZcuWZfk54/EcAICMI7jJYGBTdXhV23twb469ZsHjCtrq21ZnKsBRT69HHnnE3n//ffvxxx9dUmjdunXdxbply5aW7IFEevt16dIl2GyiiRMvvPBCe+yxx9wxZqe77rrLbr/99gzvr/JNnDjROnTokOXnAAAcG4KbDFCNTU4GNqLX0+tmNLj5/vvvrVmzZm6ckiFDhlitWrVcUujUqVPt1ltvtVWrVmWpHPv377f8+fMfsV3PrUHfcoomSVy9erUdPnzYPv/8cxfsaFZoHV+0Xm8KMvLkOfZWV/XM8XrnJPI5AAAZR86NT9xyyy3ugr5o0SK74oor7Mwzz7SzzjrLevXqZQsWLAjut379emvfvr272CpguPrqq23z5s1hTSiq7Xn55ZetcuXKVrBgQbddz/3888/bX//6V9f9VjVE8u6771r9+vXdfqeddpoNHDjQDh48GHw+1cr84x//sNKlS7t9atasae+9957NmjXLBSjbt293z61Frx2L7tfgcqq1adu2rd1xxx324Ycf2p49e1zNjoK6//znP1ajRg03iq2Oc9++fa7WpFy5cq7M55xzjnvdUHrsqaee6noJXXbZZfbLL7+E3e+dj1CjRo1y51avo/FgbrvtNre9UqVK7n89j8rr3Y58DgVoDz74oJUvX949h+6bMmVKWKCqx0+YMMHOP/98V7Y6derY/PnzLbdT9/Qrr7zSLcnYVR1AciC48YFff/3VXRxVQxNt3A9d+L2LqgIb7T979mybPn26fffdd3bNNdeE7b9mzRp755133MU1NE9EF2lduL/88ku74YYb7OOPP7ZOnTpZjx49bOXKlfbCCy+4YMELfPR6CkQ++eQTe/31190+gwcPdhelpk2b2tNPP+0CrI0bN7pFgUhmxmTR83uBlMY/UTOVgrIVK1a45ioFHQoIxo0bZ1988YVdddVV1qZNG/vmm2/cYxYuXGhdu3Z1++k4FUg8/PDD6b6uAjyd55tuusmdBwVUVapUcfctXrzY/T969Gh3PN7tSMOGDbMnn3zSnnjiCVeu1q1bu6DRK5fnvvvuc+dEZVOw2rFjx7DAMTdSgDx+/Hi3eIE3AESiWcoHFIxo5NZq1aqlu9+MGTPcBXnt2rVWoUIFt+3VV191tRC6EDds2DDYFKXtJUuWDHv8tddeG8x9EQU4//znP4MTGarm5qGHHrK7777b+vfv72pWVJP01VdfuYuzt4+naNGiwRqZzFAQMHLkSGvQoIGdeOKJwWay5557ztVwiGpuFGTof9X2iAIFBYHa/uijj7ogQ8GOyisq47x588JqUSIp+Ondu7cL6DzeefPOlzeFQSwKau655x7729/+5m4rKJs5c6YL9kaMGBHcT+Vt166dW1eNmN4nvddHe58BIJHSBqZZoH8goWWg5sYHFNhkhIIMBTVeYCNqxtHFWPd5KlaseERgIwomQin3Rc0rXk6Jlm7durlaC9WkqMZBTS9eYHMs1Hyl51cTTdWqVV0z1xtvvBG8X3lBtWvXDt5WEKfcG712aPlUY/Xtt98Gz4eaqkI1adIkZhk0cq/yfI4lOXvHjh3uOZQfFUq3Q98DCT0ebzoEb3oEAEBs1Nz4wBlnnOFqQLKaNBwp1pD2kds1/L1qFC6//PIj9lWTgTecfzyohuazzz5zScK60Ec+t26HDkCnsqn5a8mSJUfkZmQ1uTeex5MRoQnb3rGpKS432717N9MvAElea5MMqLnxgeLFi7u8DTVp6Ms/ktfVunr16rZhwwa3eJQHo/tVg5NZSiRWDyblnEQuCkJU8/DDDz/Y119/HfXxqm1R7UpG6Pn0vGrWykiQUa9ePffcqumILJvXZKTzobybUKHJ19ECLCUJq3kvvYAkvWNSjpGayZSHFEq3s/IeAACORHDjEwpsdFFt1KiRSwZWXoqaOZ555plgU0urVq1cF/HrrrvO1YIoH0YJwS1atDiiySkj+vXr53JzVHujJF69npJ377//fne/nrd58+au95aSl5Xr88EHHwRzWhQo6Ne3goWff/45ONtzPKg5Ssep41NitF5bxzto0CA3DpCox5XKohwYna/hw4enm2/jJVUrGVjnVY/ReXz22WeD93vBj8Yc+u2336I+R58+fVyezZtvvumCQ+UtqQkvNI8HAJB1BDc+oRoNXWjV40cJr+pyrYHudKFVDx+vaUNdt0866SQXdCjY0eN0kc0K1RapW/e0adNcUm3jxo1t6NChLmfHo0BL96mnj2omlLzr1Wyox1T37t1dby3l+Dz++OMWT0ocVnCj86E8HQ2sp8Rpdf0Wlfell15yicVKRNZxeIFZLEqeVuKvkpeV4HvJJZeE9XJS4KNATnlNqj2KRkGVuuirXAo2FVCp15WaFwEAxy4tkNFsVJ9QQqd66ShBVU0Eofbu3et+4YeO75JKIxQDxyrW30CyIOcGSI2cm0A29JZK7/odiYTiDFCAoUCDuaUAAEh+BDcZpECDYAMAgORHcAMgZahb/8UXXxxcB5A80pKkG7gQ3ABIGcoD8nq7AUAs9JYCAAC+qbURghsAAOArBDcAUoa6gqv7t5Zoo3EDQMKDGw0upyH61V9di0bS1Qi2sYwZM8YNRBe6JONYHACyj0ayjudo1gD81SSV8IRizRg9ePBgNzKrxhJ85ZVXrH379rZ06VI3+ms0CoI0ZL0ndLJEAACAhAY3l156adjtRx55xNXmaPLCWMGNghlv4sMctX692c85N4iflShh9sc0AUhO5513ntWtW9dNx+DNK9WzZ0+3ZFU8ngMAcruk6Qqu+YbGjx/v2tG9iR6j0ZDrmrvo8OHDblbqRx99NGYgFNfApmpVjU1vOUbNbaqhymCAc/3117vZvSdNmmS5IZBIb7/Zs2e79QIFCri5s2677Ta75ZZbsr2Mmrcqo9MBqIlVAYw3Y3tWngMAkKQJxV9++aWbK0YXIk2iOHHiRDfBYjSa/HDUqFFu8sfXX3/dBTiafPGHH36I+fz79u1z81GELpmmGpucDGxEr5eTNUVxsH///qhBq96nnNStWzfbuHGjrVy50q6++mq79dZb7d///neGy5xVmvyzcOHCCX8OAMjtEh7cKGBZtmyZLVy40G6++WY367IuStGoRkezPOsXfIsWLWzChAnuYvDCCy/EfP5Bgwa5iba8RbM15waqwdDs05qFu3jx4q4pb8CAAWH7qNbgH//4h5UuXdolZmsmcc3yHTqjt2rFFHiquUQzXofStoceesi9J8qFuummm1yNRLFixdws1wpS9dj169e7IPOuu+6ycuXKuZqJc845x2bNmhX2fJ988okrty7umrlcs47/9ttvrlZKtTGavdtLJP/+++9jHrser+NVrY2OWTldKo93XlSTo1qTEiVKuNeQ5cuXW9u2bV2grfPx97//3X4OCS5Vo6jj1P1ly5Y94lx45yO0ZinW+dVxd+nSxU3+5h2P995EPofOnfLQ9Lo6xwrWNm/eHLxfj9Pfw2uvveYeq8/43/72N9u5c2e6nw8A8LOEBzf58+e3KlWq2Nlnn+0CkTp16riLWEbky5fP6tWrZ2vWrIm5T9++fd1FxFs2bNhguYUStBVIKHB8/PHH7cEHH7Tp06e7+1Sboou5AgrVgimgVHK3N6T9kiVL3IVUF0rVruki+sADD7jgJdQTTzzh3jMlget+UU+Wxx57zF5++WVbsWKFlSpVygUU8+fPt3HjxtkXX3xhV111lbVp08a++eYb9xgFuC1btnQBkfabO3euy8lSzY8+DwpsvRoZLZkJUgsVKhRWQ6Pzos+djn3kyJEuCLngggvcZ+nTTz+1KVOmuABCx+/p06ePC7BUazht2jQXoHz22WcxXzO986vaRgUwCla841HgF+05FNj8+uuv7rX13n333Xd2zTXXhO337bffuuZIBU5atK9ey4/y5Mnjftho0ToARBVIMueff36gc+fOGdr34MGDgapVqwbuvPPODD//9u3bNQ+7+z/Snj17AitXrnT/h1myJBDQqcrpRa+bQTpn7du3D95u0aJF4Nxzzw3bp2HDhoF77rnHrU+dOjWQJ0+ewOrVq6M+37XXXhu48MILw7b16dMnUKNGjeDtihUrBjp06BC2z+jRo935XbZsWXDbunXrAnnz5g38+OOPYfu2bNky0LdvX7fesWPHQLNmzWIen46nR48e6Z6DyP30+XjttddceYYPHx68v169emGPeeihhwIXXXRR2LYNGza4x+n87Ny5M5A/f/7AW2+9Fbz/l19+CRQqVCisTDofQ4cOzdD51XkqWrToEdtDn2PatGnuvK1fvz54/4oVK1y5Fi1a5G73798/ULhw4cCOHTvC3qdzzjknkBUx/wYAIAYbYEcs2SG963ekhCYUq1ZFv25PPfVUV40+duxY94t46tSp7n41A6gZQzU6opqHxo0bu5oe/doeMmSIrVu3zm688cZEHkbS0hhCodScsmXLlmBNibrin3nmmVEf+9VXX7lag1DNmjVzNQ6qTfFqeBo0aHDEY1UrEvraqvnRYyJfS01VJ598crA8qs2Jh+eee87VGqm2RuW88847XZOnR7WEoT7//HObOXOma/qJpFqRPXv2uOdSU5pHTX1qUo3laOc3I/QeqIYqtJZKNVtq9tN9DRs2dNvUHHXiiSdGfZ8BILeNcSMJDW70BawARtXyyhXQBVGBzYUXXhjMNwitelb+hZomNm3a5HIydJGaN29ezATk3E7NdqGU2+El96qpJh6i9ezRc4eOP6Qebgoy1NQVOZOzF1DEqzxy3XXX2X333eeeUxf6yOaLyDKrfGoCU1NaJD0+vWbPWOJ5PMfyPgNAbpTQ4OZf//pXuvdHJpwOHTrULTh2CiTVy+zrr7+OWrtQvXp1ly8SSre1b2SAcjTKZVHNjYLZv/zlLzHLM2PGDBs4cGDU+1UbpOfICAXKqt3LKA0poORp1YAcd9yRfxKnn366CyCUu6RaRi/Q1rlT7kdWzm9GjkfvgXLEtHi1N8rdUa1lbg3oldit90mUVE63eQDRkJGXS+mi3Lx5c7viiitcouratWvd1BdKppXevXu7YEO9oXSBVhLu8OHDoya+Ho0u7qpNUS2derjptRYtWuSaG99///1gE6XGeNF4NEo4XrVqlRvQ0euxpAuaggtd0LQtnjUT6iqupN2OHTu6MqgpSjWI6tGkAES1S127dnVJxR999JHrWaUeXOkltB7t/Op4VGOkc6zjiTadQKtWraxWrVru3Cl5WedM51DPHa05MLfQ+QrtyQYAkQhucjHVVihvQxd11QSo27hXm6DajLfeesv1blIX5n79+rmcJ13Us2L06NHuwqygSbkqHTp0cIGEVxOiAEi9kJT/0qhRI9c7Sj2TvJoUBVWqMVI51f1fTZbxcsopp7haKR37RRdd5AIKdRVXbosXwCi/S7VOar5S0HHuuecekbuTmfOrHlMa10k9n3Q86s0WSc1LOgdqglWgpNdV9/Y333wzbscOAH6U5jKdcxEN4qdmC3ULV1fcUHv37nW/sCtXrhw+IWcKjFAMxEPMv4Ekapby8rRU80WzFJCcCcWB/oEcvX4n7fQLSU0BhgIN5pYCACDpEdxklAINgg0AAJIeOTcAAMBXqLkBkDKU4O31FGP6BQCxENwASBkaHFG97AAgPfz0AQAAGe4dlaxTLoQiuAEAAL5CcAMgZWgkZ43urCXaqM4AIOTcAEgZGnN03bp1wXUAiIbgJoM03H9OzmdTokSJ4NQEGXHeeedZ3bp17emnn87WcqUqTRuhCScnTZpkucWmTZvs73//u82bN89N/Knjj7YNAPyG4CaDgY3mQ9LQ9DlFQ9+vXr06UwEO/jdTtKYOWLp0qQv2PMOGDUuJX/pjxoxx81rFI+gYOnSobdy40ZYtW+aGLI+1DQCOJhWSiEMR3GSAamxyMrARvZ5e14/BjYIMTSDpTYqZEfv377f8+fNn+TVz44Vcs5trcs8zzjgj3W0A4DckFPvI4cOH3czTxYsXtzJlytiAAQPCajQ0y7R+sXtUO6Bts2bNcrf1v25PnTrV6tWr58YUueCCC2zLli32wQcfWPXq1d1kZddee21YMue+ffvsjjvusFKlSrkaJ82YHToWife8eg5dWAsUKGBz585N91hUdtW8vPzyy2GTOE6ZMsU9v2bsPvnkk+2SSy5xF2yP9hWVX6+p5jqvWUozkXu0XWWOdb5k1apV7rX02prV+8MPP3TPmV7Tlt4DzfBdpUoVd5wKTh955JGw8xBaK6P3Q9v0/uj+Ll26uEnhtE1LZJlCPf/883b66ae7oE81i6+99lrwPiXcalbyV1991T2Pjj/aNgDwI2pufOSVV16xXr162cKFC23+/Pnu4tWsWTO78MILM/U8uqAOHz7cChcubFdffbVbdKEeO3asm4n5sssus2effdbuuecet78CBF009foVK1Z0F/fWrVvbmjVrXODg+ec//2lPPPGEnXbaaXbSSScdtRx6vJ53woQJljdv3uCs0DrG2rVru7L069fPlUdBgkasXbRokTVq1MgFImeddVa6tT3pnS/VLCkYUnCi+3fu3Gm9e/c+apn79u1rL730kmv+UWCkJiAFSRnRtGlTlzOlY1KTpHgzYEeaOHGi9ejRw+3fqlUre++991xgVL58eTv//PNdcNmpUycXjKpJToGqar8itwGAHxHc+Igu+P3793franZQgDJjxoxMBzcPP/ywu8hL165d3QVbtSMKSuTKK6+0mTNnuuBGwYZqEJQr0rZtW3e/Lu7Tp0+3f/3rX9anT5/g8z744IOZKosuxqplKFmyZHDbFVdcEbbPqFGj3P0rV660mjVrBvdVrY5qY7J6vlR+HbNqU7znUQ1MeuVXAKSgQc/TuXNnt001KwpyMkKBmJrPVKtytLIrSFQwdsstt7jbCtIWLFjgtiu40XlQQKoAJvS5om1LJTo3qkXz1gFkv7QUy7cRmqV8RBfrUGXLlnVNSsfyPKVLl3Y1OF5g423znlcBwIEDB4LBkKgXjmpPvvrqq7Dn9eYEyijVAoUGNvLNN99Yx44dXXlUA6GmFi/pO57nSzUnFSpUCAsCdEzp0fGqia5ly5aW3fRaoedcdDvynPuNPosrVqxwi9YBZHNQk5Z6gY1Qc+MjCipC6ZetckBCJxkM7TGkoORoz6PnSO95M+P4448/5v0vvfRSF/SoduiUU05x5VCNjWp5Mitex+U5WjNPZt4DAEDWUXOTS3g1IMoB8YQmF2eVl9D6ySefhF2wlfPhNR/Eyy+//OJqVO6//35XO6IE599++y1sHy/HRjkzx0IJuhs2bLDNmzcHtx1twkY1bSnAUdNWVt8DlT8jZdexh55z0e14n3MAuVRaatbYeKi5ySV00W3cuLENHjzY9ShS84uChGOl2pWbb77Z5dYoeVgJuEooVm8q5evEk5KQlUvz4osvuiYkNUUpSTmUemzpWNWrSsm16umUlW7gyq1R4KbcGR2P8mm88xUr10OvpTwkJVgrSFEz0datW10Tis6FelCpqUsJ28rf+frrr+3JJ58Mew41sylRWgFSnTp1XNNLtOYXnW8leqtXmBKK//vf/7rEayVS+5k+Vw0bNgwGmzRNAYiGmptcRMm3Bw8edN2xNVCcEofjQQGTEn018m39+vVdLyd1J89Ij6jMULPOuHHjbMmSJa4p6s4777QhQ4aE7aOxc5555hl74YUXXLNV+/bts/Ra6p2lLt8KNHQxvfHGG+2+++5z93nd0qN54IEHXK8q9XhS7co111wTzONRM9i///1v13tK+T6PPfbYEe+Bekx1797dPU41PQqsolFPLiUvK4FYvcJ0vKNHjw52ffcrNekpeVxLKgzKCKSktNSutZG0QC77htixY4f7Ja+xRJSQGjlw3tq1a8PGVRFGKIbX7KOeTwreVKvjR7H+BpKFeud53eMVeGY2jwtAxoObtAFmgQH/+z9SoH8g3Z5U3v05df2ORLNUBijAUKCRzHNLIf40lowupMqlUUCjcWXU1OTXwAYA/ILgJoMUaBBsxI+aUrzZnSOpieW6666zRFOejXJoVHOnYFO5LZE5MgCA5ENwg4SYPHlyzG7QGkcnGWg0Xy0AgNRCcIOE0Fg1AIDES/sjbyY78mQSheAmilyWYw2kzGdf3fC9wJjpFwDEQnATZcRajaXBpILIjbzZ3iNHb04WGtdGM6gDQHoIbiLGNilWrFhwXBJ9kfLrELmlxkaBjT77+hvwZmEHgFREcBPBmygxKxNOAqlOgU2qzhgOIHfM+J0RBDcRVFOjof01jD+TGiI3UVNUstfY7Nmzx5o3b+7W58yZQ/MxEE1aWtjAe0cbcM+PCG5i0Jd8sn/RA7mNZm3/9NNPg+sAEA1zSwEAAF8huAEAAL5CcAMAAHwlocHN888/b7Vr13aze2pp0qSJffDBB+k+Zvz48VatWjU3Y3GtWrXcMP4AAORGShL2FpdInIuShpM2uClfvrwNHjzYlixZ4pIEL7jgAmvfvr2tWLEi6v7z5s2zjh07WteuXW3p0qXWoUMHtyxfvjzHyw4AAJJTQoObSy+91C6++GI744wz7Mwzz7RHHnnETjjhBFuwYEHU/YcNG2Zt2rSxPn36WPXq1e2hhx6y+vXr2/Dhw3O87AASQzO0awGApO8KfujQIdfktHv3btc8Fc38+fOtV69eYdtat25tkyZNivm8+/btc4tnx44dcSw1gJx0/PHH29atWxNdDABJLuEJxV9++aWrrSlQoIB1797dJk6caDVq1Ii676ZNm6x06dJh23Rb22MZNGiQFS1aNLhUqFAh7scAAEB2Ia8mBYObqlWr2rJly2zhwoV28803W+fOnW3lypVxe/6+ffva9u3bg8uGDRvi9twAACD5JLxZKn/+/FalShW3fvbZZ9vixYtdbs0LL7xwxL6a82bz5s1h23Q7vblwVCOkBUDq0/QLbdu2devqWcn0CwCSsuYmkoZUD82RCaVcnBkzZoRtmz59eswcHQD+ou+H2bNnu4XpFwAkZc2Nmoz0K+zUU0+1nTt32tixY23WrFk2depUd3+nTp2sXLlyLm9GevToYS1atLAnn3zS2rVrZ+PGjXNdyF988cVEHgYAAEgiCQ1utmzZ4gKYjRs3umRfDeinwObCCy90969fv97y5Pmzcqlp06YuALr//vvt3nvvdV3I1VOqZs2aCTwKAADiM4t36AzegQEWNrs3UiS4+de//pXu/arFiXTVVVe5BQCAVOeCmEQXwoeSLucGAIDcgC7d2YfgBgAA+ErCu4IDQGYULlw40UUAkOSouQGQUtMvaIoWLVoHUoo3unDaHwuyDcENAADZIBjIIMcR3AAAEE/UzCQcwQ2AlLF37143gKcWrQNANCQUA0gZhw4dssmTJwfXASAaghsAALIwPo03mnDoCMNue4LKhT/RLAUAQAZ6OZEgnDoIbgAAgK8Q3AAAAF8h5wYAkOt5s3Bb4M9ZuT3k0KQeghsAQO4SkgCsgCY0GRj+QHADIGVoyoXAH7+sASAWcm4AAICvENwAAABfIbgBkDI05cJVV13lFqZfQEaFJgeHrsO/yLkBkDI05cLbb7/t1seMGZPo4iBZ/THQHonCuRc1NwCAlBccPZgRhEFwAwAA/IbgBgCQ2qitQQRybgAASSky+Td0wL3Q0YSBSNTcAAAAXyG4AQAkzh9JwF5CMF21EQ80SwFIGYULF7Zdu3YF15HiyJVBNiG4AZAy0tLS3PxSAJAeghsAQFypackl/IYMpBfoHzhyRu4ElQ/+R84NgJSxb98+u/76692idSQhmpqQBKi5AZAyDh48aK+88opbHzFihBUoUCDRRcIfvERgamOQDKi5AQAAvkJwAwDIUDftyC7bdNtGsiK4AQAAvkJwAwAIojYGfkBwAwAAfIXgBgDwZ14N4AN0BQeQMjTlwpYtW4LryIA/Bs0LDqL3x7bg6h8D6gF+ktCam0GDBlnDhg3txBNPtFKlSlmHDh1s9erV6T5mzJgxbgj20KVgwYI5VmYAiaO/95IlS7pF6wCQdMHN7Nmz7dZbb7UFCxbY9OnT7cCBA3bRRRfZ7t27031ckSJFbOPGjcFl3bp1OVZmAEhKEV22mWEbuVlCm6WmTJlyRK2ManCWLFlizZs3j/k4/WIrU6ZMDpQQQDLRlAu9evVy60899RQjFANI/oTi7du3u/+LFy+e7n67du2yihUrWoUKFax9+/a2YsWKdL8Md+zYEbYASN3pF5577jm3aB0Akjq4OXz4sPXs2dOaNWtmNWvWjLlf1apVbdSoUfbuu+/a66+/7h7XtGlT++GHH2Lm9RQtWjS4KCACgJQRZYTg0FGCASRxcKPcm+XLl9u4cePS3a9JkybWqVMnq1u3rrVo0cImTJjgkgtfeOGFqPv37dvX1Qh5y4YNG7LpCAAAQDJIiq7gt912m7333ns2Z84cK1++fKYemy9fPqtXr56tWbMm6v1qk6ddHgCA3COhNTeBQMAFNhMnTrSPPvrIKleunOnnOHTokH355ZdWtmzZbCkjAOQUJqMEfFBzo6aosWPHuvwZjXWzadMmt125MYUKFXLraoIqV66cy52RBx980Bo3bmxVqlSxbdu22ZAhQ1xX8BtvvDGRhwIAAJJEQmtunn/+eZcHc95557maF2958803g/usX7/ejWXj+e2336xbt25WvXp1u/jii13vp3nz5lmNGjUSdBQAkPUk4dAEYQA+qLlRs9TRzJo1K+z20KFD3QIg91GN7tq1a4PrKT0FAoDkCW5OOumkqMOee9MgqLno+uuvty5dusSrjADg5MmTxypVqmTJTjUxgQH/m7dJ/wNI8mapfv36uS+Ydu3a2cCBA92idW1TDs2ZZ55pN998s7300kvZU2IASGY0LwGpV3Mzd+5ce/jhh6179+5h2zXOzLRp0+ydd96x2rVr2zPPPONyYwAgXvbv32/33XefW3/kkUcsf/78CSuL16sptKnJ1dgkrEQAslxzM3XqVGvVqtUR21u2bOnuEyX6fvfdd5l9agBIlybXfeKJJ9yi9YShdgbwV3CjeZ/++9//HrFd27w5oTSrt7p2AwAAJH2z1AMPPOByambOnGmNGjVy2xYvXmyTJ0+2kSNHutvTp093UyMAgF+EJQknujAA4hvcKI9GY8oMHz7czevkTWY5e/ZsN4Gl9O7dO7NPCwDJS81Q9HoC/D3OjWbu1gIAfq2hMW8cLvJrgNwR3Bw+fNhNVLllyxa3Hqp58+bxKhsAAED2BzcLFiywa6+91s3nFDnCsAby00SWAJDsIieo9PJpAOTC4Ebj2zRo0MDef/99Nw9UtNGKASA7aMqF5cuXB9czjOkPgFwl08HNN998Y2+//babZgEAcpJGQj/rrLMSXQwAfhvn5pxzznH5NgCQcKo5Dqk9Ds6unRYx4zaAXCXTNTe333676+q9adMmq1WrluXLly/sfk29AADZNf3Co48+agNnDTT7C+PNAIhTcHPFFVe4/2+44YbgNuXdKLmYhGIA2elAgQI20LvBaBQA4hXcrF27NrMPAYBjR+cFANkV3FSsWDGzDwGAYx9UDwDiGdz85z//sbZt27r8Gq2n569//WtGXxtAbvZH9+zIMWaC8zfRbRtAdgY3HTp0cAnEpUqVcuuxkHMDAABSIrgJnWIhcroFAACAlB7n5tVXX7V9+/ZF7aKp+wAgOL5M5HgzJAUDSMbgpkuXLrZ9+/Yjtu/cudPdB8DfIgfKCwtY/ghksktBM1uklW5ZnfYXQG6Q6a8HbzybSD/88IMVLVo0XuUCgCPkNbOGWimX6JIA8EVwU69ePRfUaGnZsqUdd9yfD1USsca/adOmTXaVE0CCMY0BAN8FN14vqWXLllnr1q3thBNOCN6XP39+q1SpUnD0YgA+o9raJBhrZr+ZDdPKJ5roLtGlAZDywU3//v3d/wpirrnmGitYUK3fAPw6aF4yjjVzwMzu1sp0r30KAOKQUNy5c2cCG8BHicFHJAgDQG5LKFZ+zdChQ+2tt96y9evXuy7goX799dd4lg8AACB7a24GDhxoTz31lGuaUpfwXr162eWXX2558uSxAQOSoFEeAADkapkObt544w176aWXrHfv3q7HVMeOHe3ll1+2fv362YIFC7KnlAAAANkV3GiOqVq1arl19ZjyBvS75JJL7P3338/s0wGIt7ToIwMH1wHA5zId3JQvX942btzo1k8//XSbNm2aW1+8eLEVKFAg/iUEEF1IwELQAgDHENxcdtllNmPGDLd+++232wMPPGBnnHGGderUyW644YbMPh2ArMilvZrUT3OmVjoz/QKA2DL99TB48ODgupKKK1asaPPmzXMBzqWXXprZpwOATE2/cJ5WKie6JACS2TH/9mncuLFb5NNPP7UGDRrEo1wAYsmltTYAkG3NUrt27bI9e/aEbdOUDKq1OeccxkMHskNoYnBuphGKR9gfU4MfSnRpAKR8cLNhwwZr0qSJm/lbi8a3+f33312ujYKa448/3jVPZcagQYOsYcOGduKJJ1qpUqXc/FWrV68+6uPGjx9v1apVcyMlq+fW5MmTM/W6QEKFBCiRowSHBTG5PJCJRkOG3qYV/ckT3AA41uCmT58+tnfvXhs2bJide+657v8WLVpYkSJF7Ntvv7Vx48ZluuZm9uzZduutt7rxcaZPn24HDhywiy66yHbv3h3zMQqgNLZO165dbenSpS4g0rJ8+fJMvTYAAMjlOTdz5syxCRMmuPyaq6++2sqUKWPXXXed9ezZM8svPmXKlLDbY8aMcTU4S5YssebNm0d9jIKqNm3auGBLHnroIRcYDR8+3EaOHJnlsgAAgFxWc7N582arXPl/XRQUgBQuXNjatm0b18J4AwIWL1485j7z58+3Vq1ahW1r3bq12x7Nvn37bMeOHWELAADwr0wlFGv+qND1/Pnzx60ghw8fdrVAzZo1s5o1a6Y7QnLp0qXDtum2tsfK6/HyhLRUqFAhbmVG7hY6gF7YIHoRM21HjhIMAEiSZqlAIGBnnnmmpf2R5KheU/Xq1QsLeI5lVnDl3ihvZu7cuRZPffv2dcnPHtXcEOAAAOBfGQ5uRo8enW2FuO222+y9995zeT2a3iE9yvVRE1ko3db2aDQlBNNCAACQe2Q4uOncWeOdx5dqgzSFw8SJE23WrFnBnJ70qDu6pn8ITWRWQrG2A/A3/Ux5TxP1XvvHcMUAEEVCZ2dRU9TYsWPt3XffdWPdeHkzyo0pVKiQW9c4OuXKlXO5M9KjRw/XBf3JJ5+0du3auS7oGhn5xRdfTOShAMihL6x2Wjkz0SUB4KsRiuPp+eefdz2kzjvvPCtbtmxwefPNN4P7rF+/PjgLuTRt2tQFRApm6tSpY2+//bZNmjQp3SRkIEsiEoDDkocZYA8AklZCa27ULHU0aq6KdNVVV7kFiJs/gpW0AWaBAYkuDNKbfuENrSw1s9qJLg2AZJXQmhsgKVALk1LTL3TRyrtMvwAgTsGNpkc4/fTT7auvvsrMw4CkxbgzAJDLg5t8+fK5+aUAAAB80yylHk6PPfaYHTx4MHtKBGQzamsAwN8ynVC8ePFiN87MtGnTrFatWnb88ceH3a/JNYGk6vH0R4KwEoW9dQCAf2U6uClWrJhdccUV2VMaAACAnA5usnMaBgAAgISNc7N161ZbvXq1W69ataqVLFnymAsDAEebfuEtM7taw1wx/QKAeCUU796922644QY3knDz5s3dcsopp1jXrl3t999/z+zTAdmCUYT9+2vMDd95FsENgDgGN7169bLZs2fbf//7X9u2bZtbNDeUtvXu3TuzTwfEb5oEghkAQFaapd555x03n5Pmg/JcfPHFbqLLq6++2s0XBQDZQQNQTNTKCjOrlujSAPBNzY2ankqXLn3E9lKlStEsBSBb7VO+jVbGM/0CgDgGN02aNLH+/fuHjVS8Z88eGzhwoLsPyC7Bpqc/mqGCM3QDAHAszVLDhg2z1q1bW/ny5a1OnTpu2+eff24FCxa0qVOnZkcZAQAAsi+4qVmzpn3zzTf2xhtv2KpVq9y2jh072nXXXefybgAAAFJunJvChQtbt27d4l8aAACARAQ3P/30k82dO9e2bNlihw8fDrvvjjvuONYyAUHKqQn0DyS6GAAAPwc3Y8aMsX/84x+WP39+O/nkky0tZGwRrRPcICu8xGAmtwQA5Hhw88ADD1i/fv2sb9++lidPpjtbAUegxxMyKr/mtzOzLu0ZoRhAnMe5+dvf/kZgAyDH5TOz67VSj+AGQGyZjlA0h9T48RpBCzgGTJUAAEiWZqlBgwbZJZdcYlOmTLFatWpZvnz6LfWnp556Kp7lA4Cw6RfcaFpfm9npiS4NAF8FNxqsr2rVqu52ZEIxEEajCQ/4X6JwcJNuJ7JMSOnpFy7RylgzuzfRpQHgm+DmySeftFGjRtn117uWbyA2gl0AQCrk3BQoUMCaNWuWPaWBfxDYAABSJbjp0aOHPfvss9lTGgAAgJxullq0aJF99NFH9t5779lZZ511RELxhAkTjrVMAAAAORfcFCtWzC6//PKsvyJ8lSgsXrKwSxRmqgQAQKoFN6NHa3xQAACA5MQww8g8koWRwOkXhmvlYkYoBhDHmpvKlSunO57Nd999l9mnRKrN0p3oQiDXUobfrWZ2W6NElwSAr4Kbnj17ht0+cOCALV261I1Y3KdPn3iWDQAAIPuDG3UFj2bEiBH26aefZr4ESG5eLV2A+hok3iEz+1gra82sYqJLA8D3OTdt27a1d955J15PhyRoftICJJO9Zna+Vl75Y6IpAMjO4Obtt9+24sWLx+vpAAAAcqZZql69emEJxYFAwDZt2mRbt2615557LmulQFKgpgYAkCuDmw4dOoTdzpMnj5UsWdLOO+88q1atWjzLhhxCUAMAyNXBTf/+/eP24nPmzLEhQ4bYkiVLbOPGjTZx4sQjgqdQs2bNsvPPdy3uYfTYMmXKxK1cAAAgFwQ3O3bsyNB+RYoUyfCL79692+rUqWM33HBDpqZ0WL16ddjrlCpVKsOPBQAA/nZcZuaUSm/wPuXe6P5Dh9RZM+M9rLRkloIZlQcAACDLwc3MmTPDApmLL77YXn75ZStXrpzltLp169q+ffusZs2aNmDAAGvWrFnMfbWflszWQAFIzhGKHzezuy9k8hgAcQhuWrRoEXY7b9681rhxYzvttNMsp5QtW9ZGjhxpDRo0cAGLgislMi9cuNDq168f9TGDBg2ygQMH5lgZUyl5mBm8kYpzS2kc9Ltj/54BgMwnFCdS1apV3eJp2rSpffvttzZ06FB77bXXoj6mb9++1qtXr7CamwoVKuRIeQEAQM5LqeAmmkaNGtncuXNj3l+gQAG3AEh9yuj7TCs/qio30aUBkKyOqdU6vQTjnLJs2TLXXAUgd0y/4CYEf4npFwDEoeYmsqv23r17rXv37nb88ceHbZ8wYUJGn9J27dpla9asCd5eu3atC1Y0jcOpp57qmpR+/PFHe/XVV939Tz/9tFWuXNnOOuss9/rKufnoo49s2rRpGX5NAADgbxkObooWLRp2+//+7/+O+cU1i3jooHxebkznzp1tzJgxbnC+9evXB+/fv3+/9e7d2wU8hQsXttq1a9uHH34YdWA//JlAHBhgljYg0SUBACDJgpvRo0fH/cXV00ndymNRgBPq7rvvdgsAAEAsjBQBAAB8heDGx5gQEwCQGxHcAAAAX0n5cW7g+uSHJQwz8jD8PP1CfzMbqAHT+WkGIAa+HgCk1PQLLo5XB0l+mgGIgeAmxZFXAwBAOIKbFEZgg9zmsJmt0MqWP24AQBQENwBSxh4zq6mV55h+AUBsBDcAAMBXCG5SVRJMWgoAQDIiuEnFbt/k2gAAEBPBDQAA8BWCmySnWhpqagAAyDiCGwAA4CsEN0mMGhvgyOkX7tJKU769AMTG1wOAlJp+YYhWLmL6BQCxEdwkKWptAADIGoKbZMQYNkBUmnHhe638xvQLAGIjuAGQUtMvVNbKMKZfABAbwQ0AAPAVgpskQ64NAADHhuAGAAD4Cp0pkwQ1NgAAxAc1NwAAwFcIbgAAgK8Q3ABIqXb0W7TSkG8vALHx9QAgZRQwsxFaaUfGIIDYCG4AAICvENwASBkBM9uqld1/3ACAKAhuAKSM382slP0xNfiBRJcGQLIiuEkgxrYBACD+SMnLYQQ0AABkL2puAACArxDcAAAAXyG4AQAAvkJwk5PSyLcBAMDXwc2cOXPs0ksvtVNOOcXS0tJs0qRJR33MrFmzrH79+lagQAGrUqWKjRkzJkfKCiA5ekB01kqdRH97AUhmCf162L17t9WpU8dGjHADqh/V2rVrrV27dnb++efbsmXLrGfPnnbjjTfa1KlTs72sAJJj+gX3c+Yy+noCiC2hXw9t27Z1S0aNHDnSKleubE8++aS7Xb16dZs7d64NHTrUWrdunY0lBQAAqSKlKnbnz59vrVq1CtumoEbbAfhf4I+ZF2w/0y8A8Elws2nTJitdunTYNt3esWOH7dmzJ+pj9u3b5+4PXQCk7vQLJ2jlUaZfAOCT4CYrBg0aZEWLFg0uFSpUSEg5GJkYAICckVLBTZkyZWzz5s1h23S7SJEiVqhQoaiP6du3r23fvj24bNiwIYdKCwAAEiGl+hs0adLEJk+eHLZt+vTpbnss6jKuBQAA5A4JrbnZtWuX69KtxevqrfX169cHa106deoU3L979+723Xff2d13322rVq2y5557zt566y278847E3YMAAAguSQ0uPn000+tXr16bpFevXq59X79+rnbGzduDAY6om7g77//vqut0fg46hL+8ssv0w0cAAAkR7PUeeedZ4FA7P6c0UYf1mOWLl2azSUDAACpKqUSilMVPaWA+MhrZldqpYb+sBJdGgDJKqUSigHkbgXNbLzimqsTXRIAyYyaGwAA4CsENwAAwFcIbgCkjN1eqs2AP+aXAoAoCG4AAICvENwAAABfIbgBAAC+QnADAAB8heAmmzGAHwAAOYvgBgAA+ArBDYCUmn7hYq2cwfQLAGJj+gUAKTX9wvuKa65LdEkAJDNqbgAAgK8Q3AAAAF8huAGQUtMvHK+VR5h+AUBsBDcAUsrv+udAoksBIJkR3AAAAF8huAEAAL5CcAMAAHyF4AYAAPgKwQ0AAPAVgptsxKSZQPy/sFpopSLTLwCIjekXAKSMQmY2S3FNl0SXBEAyo+YGAAD4CsENAADwFYIbACk1/UJJrTzO9AsAYiO4AZBSfg7OwQAA0RHcAAAAXyG4AQAAvkJwAwAAfIXgBgAA+ArBDQAA8BWCGwApQ19YDbRyCtMvAIiN6RcApNT0C4sV19yU6JIASGbU3AAAAF8huAEAAL6SFMHNiBEjrFKlSlawYEE755xzbNGiRTH3HTNmjKWlpYUtehwA/9PAxJW0MpTpFwAkcXDz5ptvWq9evax///722WefWZ06dax169a2ZcuWmI8pUqSIbdy4MbisW7cuR8sMIDECZub+2rcnuiQAklnCg5unnnrKunXrZl26dLEaNWrYyJEjrXDhwjZq1KiYj1FtTZkyZYJL6dKlc7TMAAAgeSU0uNm/f78tWbLEWrVq9WeB8uRxt+fPnx/zcbt27bKKFStahQoVrH379rZixYqY++7bt8927NgRtgAAAP9KaHDz888/26FDh46oedHtTZs2RX1M1apVXa3Ou+++a6+//rodPnzYmjZtaj/88EPU/QcNGmRFixYNLgqIAACAfyW8WSqzmjRpYp06dbK6detaixYtbMKECVayZEl74YUXou7ft29f2759e3DZsGFDjpcZAADkkkH8SpQoYXnz5rXNmzeHbddt5dJkRL58+axevXq2Zs2aqPcXKFDALQAAIHdIaM1N/vz57eyzz7YZM2YEt6mZSbdVQ5MRatb68ssvrWzZspYM0gYyJjyQXfTXVUMrJRNdEgDJLOHTL6gbeOfOna1BgwbWqFEje/rpp2337t2u95SoCapcuXIud0YefPBBa9y4sVWpUsW2bdtmQ4YMcV3Bb7zxxgQfCYDsVtjM1H0g7dZElwRAMkt4cHPNNdfY1q1brV+/fi6JWLk0U6ZMCSYZr1+/3vWg8vz222+u67j2Pemkk1zNz7x581w3cgAAgIQHN3Lbbbe5JZpZs2aF3R46dKhbAAAAfNFbCkDunn7hLK2MYPoFALER3ABIqekXVmpla6JLAiCZEdwAAABfIbgBAAC+QnADAAB8heAGAAD4CsENAADwFYIbACk1/UJFrRRNdEkAJLOkGMQPADI6/cL3CnLuTHRJACQzam4AAICvENwAAABfIbgBkDL2mFlDrbxoZgcSXRoAyYrgBkDKOGxmn2rlpz/mYgCAKAhuAACArxDcAAAAXyG4AQAAvkJwAwAAfIXgBgAA+ArBDYCUUsIbqhgAYmD6BQAp43gz26rpF+5OdEkAJDNqbgAAgK8Q3AAAAF8huAGQUtMvnKeV0Uy/ACA2ghsAKTX9wmytrGP6BQCxEdwAAABfIbgBAAC+QnADAAB8heAGAAD4CsENAADwFYIbACnFzbyQL9GlAJDMmH4BQEpNv7Bb0y/cl+iSAEhm1NwAAABfIbgBAAC+QnADIGXsNbN2WnmD6RcAxEZwAyBlHDKzyVr5hukXAMRGcAMAAHwlKYKbESNGWKVKlaxgwYJ2zjnn2KJFi9Ldf/z48VatWjW3f61atWzyZPdbDgAAIPHBzZtvvmm9evWy/v3722effWZ16tSx1q1b25YtW6LuP2/ePOvYsaN17drVli5dah06dHDL8uXLc7zsAAAg+SQ8uHnqqaesW7du1qVLF6tRo4aNHDnSChcubKNGjYq6/7Bhw6xNmzbWp08fq169uj300ENWv359Gz58eI6XHQAAJJ+EBjf79++3JUuWWKtWrf4sUJ487vb8+fOjPkbbQ/cX1fTE2h8AAOQuCR2h+Oeff7ZDhw5Z6dKlw7br9qpVq6I+ZtOmTVH31/Zo9u3b5xbP9u3b3f87duywbLE35LnVbzXEjmjbouyb7n7ea4TsE7l/5HNGe75Yr33EPn/uHP7akc/v3RftvIY+JvR2Zo89ymuHPmZHRsrprUfbL9btY3mPorx+1HJGe0+jnKMjzm609z3K/ekee6xzEPl+Rh5/+MGnv19oOaLsG+3zHO090ujEQfuO8vlM7zkjyhm1DJHnM9Z7FeNv84hzuzfjf8dHvJfpfZ5ife4iyxHrOy/a39JRXj/W5ynsOSLLG+t9T6+smXmPIo898tiifO7Tfc4Yf+/pvfdh+4e+Vga/G9IrZ2RZ0vte2pHOsacn5vuehetHdlxjvecMBDLQVTKQQD/++KNKGJg3b17Y9j59+gQaNWoU9TH58uULjB07NmzbiBEjAqVKlYq6f//+/d1rsLCwsLCwsFjKLxs2bDhqfJHQmpsSJUpY3rx5bfPmzWHbdbtMmTJRH6Ptmdm/b9++LmHZc/jwYfv111/t5JNPtrS0NIt3VFmhQgXbsGGDFSlSJK7PjSNxvnMO5zrncK5zDuc6tc63amx27txpp5xyylH3TWhwkz9/fjv77LNtxowZrseTF3zo9m233Rb1MU2aNHH39+zZM7ht+vTpbns0BQoUcEuoYsWKWXbSm8YfSs7hfOccznXO4VznHM516pzvokWLpsas4KpV6dy5szVo0MAaNWpkTz/9tO3evdv1npJOnTpZuXLlbNCgQe52jx49rEWLFvbkk09au3btbNy4cfbpp5/aiy++mOAjAQAAySDhwc0111xjW7dutX79+rmk4Lp169qUKVOCScPr1693Pag8TZs2tbFjx9r9999v9957r51xxhk2adIkq1mzZgKPAgAAJIuEBzeiJqhYzVCzZs06YttVV13llmSj5i8NRhjZDIbswfnOOZzrnMO5zjmca/+e7zRlFWf7qwAAAOSWEYoBAADiieAGAAD4CsENAADwFYIbAADgKwQ3cTRixAirVKmSFSxY0M455xxbtGhRoouUcubMmWOXXnqpG4FSI0irm38o5b9r2ICyZctaoUKF3CSq33zzTdg+GoH6uuuuc4NEacDGrl272q5du3L4SJKfxo5q2LChnXjiiVaqVCk3kObq1avD9tm7d6/deuutbkTvE044wa644oojRgjXcA0ac6pw4cLuefr06WMHDx7M4aNJbs8//7zVrl07OHiZBh394IMPgvdznrPP4MGD3XdJ6MCvnO/4GTBggDu/oUu1atUSf64zMxcUYhs3blwgf/78gVGjRgVWrFgR6NatW6BYsWKBzZs3J7poKWXy5MmB++67LzBhwgQ3h8jEiRPD7h88eHCgaNGigUmTJgU+//zzwF//+tdA5cqVA3v27Anu06ZNm0CdOnUCCxYsCHz88ceBKlWqBDp27JiAo0lurVu3DowePTqwfPnywLJlywIXX3xx4NRTTw3s2rUruE/37t0DFSpUCMyYMSPw6aefBho3bhxo2rRp8P6DBw8GatasGWjVqlVg6dKl7v0rUaJEoG/fvgk6quT0n//8J/D+++8Hvv7668Dq1asD9957r5snT+deOM/ZY9GiRYFKlSoFateuHejRo0dwO+c7fjR/41lnnRXYuHFjcNm6dWvCzzXBTZxoos9bb701ePvQoUOBU045JTBo0KCEliuVRQY3hw8fDpQpUyYwZMiQ4LZt27YFChQoEPj3v//tbq9cudI9bvHixcF9Pvjgg0BaWpqbqBWxbdmyxZ272bNnB8+tLsDjx48P7vPVV1+5febPn+9u64soT548gU2bNgX3ef755wNFihQJ7Nu3LwFHkTpOOumkwMsvv8x5ziY7d+4MnHHGGYHp06cHWrRoEQxuON/xD270YzKaRJ5rmqXiYP/+/bZkyRLXROLRqMq6PX/+/ISWzU/Wrl3rRrEOPc+aZ0RNgN551v9qitJ0Hh7tr/dj4cKFCSl3qti+fbv7v3jx4u5/faYPHDgQdr5V3XzqqaeGne9atWoFRxSX1q1buwnyVqxYkePHkAoOHTrkpo3RNDNqnuI8Zw81haipI/S8Cuc7/pQaoFSC0047zaUEqJkp0ec6KUYoTnU///yz+8IKfXNEt1etWpWwcvmNAhuJdp69+/S/2mxDHXfcce6C7e2DI2nCWuUkNGvWLDiVic6XJreNnGg28nxHez+8+/CnL7/80gUzykFQ7sHEiROtRo0atmzZMs5znCl4/Oyzz2zx4sVH3MfnOr7043LMmDFWtWpV27hxow0cOND+8pe/2PLlyxN6rgluALhfufoymjt3bqKL4lv68lcgoxqyt99+200YPHv27EQXy3c2bNjgJliePn2669yB7NW2bdvgupLmFexUrFjR3nrrLdfpI1FoloqDEiVKWN68eY/IANftMmXKJKxcfuOdy/TOs/7fsmVL2P3KulcPKt6L6DSv23vvvWczZ8608uXLB7frfKnJddu2beme72jvh3cf/qRfsFWqVLGzzz7b9VSrU6eODRs2jPMcZ2oK0XdA/fr1Xa2tFgWRzzzzjFtXrQDnO/uolubMM8+0NWvWJPSzTXATpy8tfWHNmDEjrJpft1UNjfioXLmy+7CHnme1yyqXxjvP+l9/SPqC83z00Ufu/dAvCvxJOdsKbNQ8onOk8xtKn+l8+fKFnW91FVd7euj5VnNLaECpX8zq7qwmF8Smz+S+ffs4z3HWsmVLd65US+YtysFTLoi3zvnOPhp249tvv3XDdST0s53lVGQc0RVcvXbGjBnjeuzcdNNNrit4aAY4MtbDQd0Btejj+dRTT7n1devWBbuC67y+++67gS+++CLQvn37qF3B69WrF1i4cGFg7ty5rscEXcGPdPPNN7tu9bNmzQrrxvn777+HdeNU9/CPPvrIdeNs0qSJWyK7cV500UWuO/mUKVMCJUuWpMtshH/+85+uF9ratWvd51a31YNv2rRp7n7Oc/YK7S0lnO/46d27t/sO0Wf7k08+cV261ZVbvS8Tea4JbuLo2WefdW+ixrtR13CNs4LMmTlzpgtqIpfOnTsHu4M/8MADgdKlS7tgsmXLlm7ckFC//PKLC2ZOOOEE152wS5cuLmhCuGjnWYvGvvEoaLzllltct+XChQsHLrvsMhcAhfr+++8Dbdu2DRQqVMh9qenL7sCBAwk4ouR1ww03BCpWrOi+G/TFrc+tF9gI5zlngxvOd/xcc801gbJly7rPdrly5dztNWvWJPxcp+mfY6uEAgAASB7k3AAAAF8huAEAAL5CcAMAAHyF4AYAAPgKwQ0AAPAVghsAAOArBDcAAMBXCG4A+EpaWppNmjQp0cUAkEAENwCSxvXXX28dOnRIdDEApDiCGwAA4CsENwCS0nnnnWd33HGH3X333Va8eHE3I/yAAQPC9vnmm2+sefPmVrBgQTeDsGYTjrRhwwa7+uqrrVixYu552rdvb99//727b9WqVVa4cGEbO3ZscP+33nrLChUqZCtXrsyBowSQHQhuACStV155xY4//nhbuHChPf744/bggw8GA5jDhw/b5Zdfbvnz53f3jxw50u65556wxx84cMBat25tJ554on388cf2ySef2AknnGBt2rSx/fv3W7Vq1eyJJ56wW265xdavX28//PCDde/e3R577DEXLAFITUycCSCpcm62bdvmEoJVc3Po0CEXlHgaNWpkF1xwgQ0ePNimTZtm7dq1s3Xr1tkpp5zi7p8yZYq1bdvWJk6c6HJ3Xn/9dXv44Yftq6++conGoqBGtTh6jYsuushtu+SSS2zHjh0uUMqbN697Hm9/AKnnuEQXAABiqV27dtjtsmXL2pYtW9y6ApYKFSoEAxtp0qRJ2P6ff/65rVmzxtXchNq7d699++23wdujRo2yM8880/LkyWMrVqwgsAFSHMENgKSVL1++sNsKOtQclVG7du2ys88+2954440j7itZsmRYELR7924X3GzcuNEFUQBSF8ENgJRUvXp1lywcGowsWLAgbJ/69evbm2++aaVKlbIiRYpEfZ5ff/3VNYfdd9997rmuu+46++yzz1xSMYDUREIxgJTUqlUr15TUuXNnV/Oi3BwFKKEUqJQoUcL1kNL9a9eutVmzZrleWEoeFiUQq3nr/vvvt6eeesrl+dx1110JOioA8UBwAyAlqQlJicN79uxxicY33nijPfLII2H7qJv3nDlz7NRTT3U9q1Tb07VrV5dzo5qcV1991SZPnmyvvfaaHXfcca5nlpKQX3rpJfvggw8SdmwAjg29pQAAgK9QcwMAAHyF4AYAAPgKwQ0AAPAVghsAAOArBDcAAMBXCG4AAICvENwAAABfIbgBAAC+QnADAAB8heAGAAD4CsENAADwFYIbAABgfvL/LD/ANShCoRMAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "#TODO: Plotting\n",
    "import pandas as pd\n",
    "\n",
    "# Load the data from csv\n",
    "df = pd.read_csv('data/hack.csv')\n",
    "df_test = df.iloc[test_dataset.original_indices].copy()\n",
    "df_test['prediction'] = predicted_labels\n",
    "df_test['label'] = true_labels\n",
    "df_test['pred_correct'] = (df_test['prediction'] == df_test['label'])\n",
    "\n",
    "df_test_sorted = df_test.sort_values(by='humor_rating').reset_index(drop=True)\n",
    "\n",
    "from matplotlib import patches as mpatches\n",
    "\n",
    "median_rating = df['humor_rating'].median()\n",
    "# get first index where humor_rating is greater than median_rating\n",
    "median_idx = df_test_sorted[df_test_sorted['humor_rating'] > median_rating].index[0]\n",
    "print(median_idx)\n",
    "# range idx for len df_test\n",
    "range_idx = range(len(df_test))\n",
    "colors = df_test_sorted['pred_correct'].map({True: 'g', False: 'r'})\n",
    "# bar plot for each df_test humor_rating value \n",
    "plt.bar(range_idx, df_test_sorted['humor_rating'], color=colors)\n",
    "# vertical line for True/False cut off\n",
    "plt.axvline(x=median_idx, color='black', linestyle='--')\n",
    "# Create a legend handles\n",
    "green_patch = mpatches.Patch(color='g', label='Correct Prediction')\n",
    "red_patch = mpatches.Patch(color='r', label='Incorrect Prediction')\n",
    "line_patch = mpatches.Patch(color='black', label='humor_rating cut off')\n",
    "plt.title('Humor Rating vs Prediction for Test Set')\n",
    "plt.xlabel('Index')\n",
    "plt.ylabel('Humor Rating')\n",
    "plt.legend(handles=[green_patch, red_patch, line_patch])\n",
    "plt.show()\n",
    "''''''"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}