1_basic_feature_benchmark.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Feature Benchmark\n",
    "\n",
    "https://www.kaggle.com/inversion/basic-feature-benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sample_submission.csv', 'test', 'train.csv']\n"
     ]
    }
   ],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load in \n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "# Input data files are available in the \"../input/\" directory.\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n",
    "\n",
    "import os\n",
    "print(os.listdir(\"../input\"))\n",
    "\n",
    "# Any results you write to the current directory are saved as output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.svm import NuSVR\n",
    "from sklearn.metrics import mean_absolute_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv('../input/train.csv', dtype={'acoustic_data': np.int16, 'time_to_failure': np.float64})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>acoustic_data</th>\n",
       "      <th>time_to_failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>12</td>\n",
       "      <td>1.4691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>6</td>\n",
       "      <td>1.4691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>1.4691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5</td>\n",
       "      <td>1.4691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8</td>\n",
       "      <td>1.4691</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   acoustic_data  time_to_failure\n",
       "0             12           1.4691\n",
       "1              6           1.4691\n",
       "2              8           1.4691\n",
       "3              5           1.4691\n",
       "4              8           1.4691"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pandas doesn't show us all the decimals\n",
    "pd.options.display.precision = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>acoustic_data</th>\n",
       "      <th>time_to_failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>12</td>\n",
       "      <td>1.4690999832</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>6</td>\n",
       "      <td>1.4690999821</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>1.4690999810</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5</td>\n",
       "      <td>1.4690999799</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8</td>\n",
       "      <td>1.4690999788</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   acoustic_data  time_to_failure\n",
       "0             12     1.4690999832\n",
       "1              6     1.4690999821\n",
       "2              8     1.4690999810\n",
       "3              5     1.4690999799\n",
       "4              8     1.4690999788"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# much better!\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4194/4194 [00:05<00:00, 780.04it/s]\n"
     ]
    }
   ],
   "source": [
    "# Create a training file with simple derived features\n",
    "\n",
    "rows = 150_000\n",
    "segments = int(np.floor(train.shape[0] / rows))\n",
    "\n",
    "X_train = pd.DataFrame(index=range(segments), dtype=np.float64,\n",
    "                       columns=['ave', 'std', 'max', 'min'])\n",
    "y_train = pd.DataFrame(index=range(segments), dtype=np.float64,\n",
    "                       columns=['time_to_failure'])\n",
    "\n",
    "for segment in tqdm(range(segments)):\n",
    "    seg = train.iloc[segment*rows:segment*rows+rows]\n",
    "    x = seg['acoustic_data'].values\n",
    "    y = seg['time_to_failure'].values[-1]\n",
    "    \n",
    "    y_train.loc[segment, 'time_to_failure'] = y\n",
    "    \n",
    "    X_train.loc[segment, 'ave'] = x.mean()\n",
    "    X_train.loc[segment, 'std'] = x.std()\n",
    "    X_train.loc[segment, 'max'] = x.max()\n",
    "    X_train.loc[segment, 'min'] = x.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ave</th>\n",
       "      <th>std</th>\n",
       "      <th>max</th>\n",
       "      <th>min</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4.884113333333334</td>\n",
       "      <td>5.101089126891323</td>\n",
       "      <td>104.0</td>\n",
       "      <td>-98.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.725766666666667</td>\n",
       "      <td>6.588801819164257</td>\n",
       "      <td>181.0</td>\n",
       "      <td>-154.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.906393333333333</td>\n",
       "      <td>6.967373808828945</td>\n",
       "      <td>140.0</td>\n",
       "      <td>-106.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.902240000000000</td>\n",
       "      <td>6.922282112791032</td>\n",
       "      <td>197.0</td>\n",
       "      <td>-199.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4.908720000000000</td>\n",
       "      <td>7.301085852684289</td>\n",
       "      <td>145.0</td>\n",
       "      <td>-126.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 ave                std    max    min\n",
       "0  4.884113333333334  5.101089126891323  104.0  -98.0\n",
       "1  4.725766666666667  6.588801819164257  181.0 -154.0\n",
       "2  4.906393333333333  6.967373808828945  140.0 -106.0\n",
       "3  4.902240000000000  6.922282112791032  197.0 -199.0\n",
       "4  4.908720000000000  7.301085852684289  145.0 -126.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = StandardScaler()\n",
    "scaler.fit(X_train)\n",
    "X_train_scaled = scaler.transform(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4194, 4)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_scaled.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "svm = NuSVR()\n",
    "svm.fit(X_train_scaled, y_train.values.flatten())\n",
    "y_pred = svm.predict(X_train_scaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAF6CAYAAAA6fn5vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xd4VGX2wPHvmckNTFAJKCpEwLIKikiLEGSLuruiIoqgIsLaxY5tWbGtfWWXVQR7r4joorGgor+VXVclIBAQUbAgLSCgEBASmPb+/kgmToapyczcKefzPHmS3Ew5SWbuuW87rxhjUEoppZLFYXcASimlcosmFqWUUkmliUUppVRSaWJRSimVVJpYlFJKJZUmFqWUUkmVlsQiIh1FZJaIfCUiS0TkqvrjbUXkAxH5pv5zmwj3P6f+Nt+IyDnpiFkppVTTSDrWsYhIe6C9MWaBiOwOzAeGAOcCm4wx40VkHNDGGHN9yH3bAvOAUsDU37ePMWZzygNXSimVsLS0WIwx64wxC+q//hn4CigBTgGeq7/Zc9Qlm1ADgQ+MMZvqk8kHwPGpj1oppVRTpH2MRUT2B3oBc4B9jDHroC75AHuHuUsJsDro+zX1x5RSSmWggnQ+mYjsBkwHrjbGbBWRuO4W5ljY/jsRGQ2MBmjVqlWfrl27NjVUpZTKG9s3rKCVdzPz1/l/NMa0a+7jpS2xiIhFXVKZYox5rf7wehFpb4xZVz8OsyHMXdcARwd9vx/wn3DPYYx5HHgcoLS01MybNy9J0SulVO7x+3zMe/Bs+m7+hop9L6b/pY+sTMbjpmtWmABPAV8ZY+4L+tGbQGCW1znAG2HuPhM4TkTa1M8aO67+mFJKqSbyeb3MnzyCvpvfpmK/C+g3+sGkPXa6xlgGAH8CjhWRhfUfJwLjgT+KyDfAH+u/R0RKReRJAGPMJuBO4LP6jzvqjymllGoCj3snCyedzpFbZjK78yWUXXgf4kheOkjLdGM7aFeYUkrtyr1zB19MPp3e2z+i4sAxlJ19Z8PPRGS+Maa0uc+R1sF7pZRS9tm5o4avJg+ld81sKg75M2Vn3ZKS59HEopRSeWBHzTa+njyEnjs+Y85hN1F2xl9S9lyaWJRSKsfVbNvC8gdO5vAdi5h7xO30G3Z1Sp9PE4tSSuWwbVs3s+rBwRy68wvm9/4bfU+5LOXPqYlFKaVy1Nbqn1j74CAO8Syjsu8Ejhx0UVqeVxOLUkrloC2bNrL+4RM5yPMdn/efSOnx56btuTWxKKVUjtm8cR0/PTqI/b0rWfKbh+j9hxFpfX5NLEoplUN+Wr+GrY8NYj9fFUuPfoyex5yW9hg0sSilVI74ce1Ktj85iH196/n2D09xxG9OsSUOTSxKKZUD1q/5DvdTJ9HO/xPLBz7H4UedaFssmliUUirLrVu5DP+zgyn2b2XVoCl06/tHW+PRxKKUUlmsavkSnM+fwu7UsO6UaXTt/Tu7Q9LEopRS2WrV1wtp+dKpFOJmw6mvckiPAXaHBGhiUUqprLTyq/m0mjYUB342n/4av+rWz+6QGqR9z3ullFLNs/yLOew+bQgAPw8v54AMSiqgiUUppbLKt4s+pu2/huKlgNqRb9L50D52h7QL7QpTSqks8fWC/7Dvm2exnSL8Z79FxwMPtTuksLTFopRSWWDpnPfp8MaZ/Cy7wXkzKMnQpAKaWJRSKuMt+fQdOr0zis2ONhRc8C7tO3exO6SoNLEopVQGW/zRGxw48xw2OPfGddF77LPfQXaHFJMmFqWUylCLZr3KIf++gB+cHdj94vfYq0Nnu0OKiw7eK6VUBlr4wUsc9vGVrCrozF6XvkPxXvvaHVLctMWilFIZZsF7z9Lt4ytYYR1Iu8tnZlVSAU0sSimVUea9/ThHzL6G7wq70P7KmbRu287ukBKmiUUppTLEZ+UP0uuzv7CsRTc6jnmX3Vu3tTukJtHEopRSGWDu9In0qbyZL1v25MCr3qXV7sV2h9RkOnivlFI2mzPt7/T76m8sch1Jl6veoKWrld0hNYsmFqWUslHFS3dS9vU/qSw6isPGTKdFyyK7Q2o2TSxKKWWT2c/fQv/lk1nQ6rccPuZVClu0tDukpNDEopRSNpj9zPX0X/ko83b/PT3HvEyBVWh3SEmjiUUppdLI+P1UPHUt/aue4bPWA+l95Us4C3LrVJxbv41SSmUw4/cz5/Er6P/DFOa2OYnSK57H4XTaHVbSpSWxiMjTwEnABmPM4fXHpgGBEp3FQLUxpmeY+64AfgZ8gNcYU5qOmJVSKpmM38+cRy+mbMMrzNlrKEde+mROJhVIX4vlWeBB4PnAAWPM8MDXInIvsCXK/Y8xxvyYsuiUUiqF/D4fnz18PmU/lVOxz5n0u/gRxJG7ywjTkliMMR+JyP7hfiYiApwBHJuOWJRSKp18Xi/zH/wT/arfYXaHsym7cFJOJxXIjJX3vwHWG2O+ifBzA7wvIvNFZHS0BxKR0SIyT0Tmbdy4MemBKqVUIrweN5WTz6Rv9TvM7nhhXiQVyIzEMgKYGuXnA4wxvYETgMtF5LeRbmiMedwYU2qMKW3XLvsKtymlcofHvZNFk8+gdOsHzN7/UvpfcG9eJBWwObGISAEwFJgW6TbGmLX1nzcArwN90xOdUko1jXvnDr6YNJQ+P8+i4ldX0//c8XaHlFZ2p88/AEuNMWvC/VBEWonI7oGvgeOAL9IYn1JKJWRH7Xa+vP8Uem3/mIouf6Fs1O12h5R2aUksIjIVmA10EZE1InJB/Y/OJKQbTEQ6iMg79d/uA3wsIouAucAMY8x76YhZKaUStaNmG19PGkzP2grmHHYzZSNusjskW6RrVtiICMfPDXNsLXBi/dfLgR4pDU4ppZKgZtsWlj9wMofvWMRnPe6g39Cr7A7JNrryXimlmmnb1s2seuAkDnUvYUGfezjy5EvtDslWmliUUqoZtlb/xNoHB3GIZxkL+/6T0kEX2h2S7TSxKKVUE235aT0bHhnEgZ7lfH7UZPoM/JPdIWUETSxKKdUEmzeuY9OjJ9LZu4ovf/swvX9/pt0hZQxNLEoplaAff1jNz48PosS3lqXHPE7Po4fZHVJG0cSilFIJ2Lh2BTVPDmIf30a+/ePTHPHrk+0OKeNoYlFKqTj9sPpbvE+fxF7+zaw44XkOLzve7pAykiYWpZSKw9oVy+C5wbT2b2X1SVM47Mg/2B1SxtLEopRSMVQtX4Lz+ZMpopZ1p0yja+/f2R1SRtPEopRSUaz6eiEtXzoVCw8bh/6LQ444yu6QMp4mFqWUimDFV/PYbdowBEP1Ga9z0GFH2h1SVrC7urFSSmWk7xZX0HraqRiEbSPe5ABNKnHTxKKUUiG+Wfg/9po+FDcWO0a9RecuPe0OKatoV5hSSgVZNu9D2r89ku20wpzzNh0P6Gp3SFlHWyxKKVXvqzkzKXnrLLbKHsj579JBk0qTaGJRSilgyScz6PzOn9jkbEvhhe+xb6eD7Q4pa2liUUrlvcUfvc6B75/LBufeFI1+j71LDrA7pKymiUUpldcWffgKh/z7ItY5O7DHJTPZa99OdoeU9TSxKKXyVuX7L3Lofy9hdUEn2l42k7Z7l9gdUk7QxKKUykvz33mGwz8Zw/fWr2h3xfsU77Wv3SHlDE0sSqm8M++tx+g55xq+LexKhyvfo3WbvewOKadoYlFK5ZW5rz9A73nXs7RFdzqNeYfdW7e1O6Sco4lFKZU35rx6L30X3cySlr048Kp3aLV7sd0h5SRdea+Uygtzpo2n31f3sMjVly5jymnpamV3SDlLE4tSKudVTLmdsm/uo7LoKA4bM50WLYvsDimnaWJRSuW02c/dSP/vH2LBbr+j+5hXsQpb2B1SztPEopTKScbvp+LZ6+m/6nHm7fEHel45lQKr0O6w8oImFqVUzjF+PxVPXUP/qmf5rPgEel/xIs4CPd2li/6llVI5xfj9zHnsMvqvn8qctidz5OXP4nA67Q4rr2hiUUrlDOP3M/eRiyjb+C/m7DWMvpc9iTh0VUW6aWJRSuUEv8/HZw+dS79Nb1Kxzwj6XfywJhWbaGJRSmU9n9fLggdH0a/6XWZ3OIeyC+/XpGKjtPzlReRpEdkgIl8EHbtNRKpEZGH9x4kR7nu8iCwTkW9FZFw64lVKZQ+vx03l5OEcWf0uszuN1qSSAdL1138WOD7M8YnGmJ71H++E/lBEnMBDwAnAYcAIETkspZEqpbKGx72TzyedRunW/2P2AZfT//wJmlQyQFr+A8aYj4BNTbhrX+BbY8xyY4wbeBk4JanBKaWy0s4dNXxx/6n03vZfKg6+lv7n/M3ukFQ9u1P7FSLyeX1XWZswPy8BVgd9v6b+WFgiMlpE5onIvI0bNyY7VqVUhthRu52lk4bQq+YT5nQdR9nIW+0OSQWxM7E8AhwE9ATWAfeGuY2EOWYiPaAx5nFjTKkxprRdu3bJiVIplVFqt//M15MG06N2DnO6/ZV+Z95gd0gqhG2JxRiz3hjjM8b4gSeo6/YKtQboGPT9fsDadMSnlMo8Ndu2sHzSIA6vXcDcHnfS7/Tr7A5JhWFbYhGR9kHfngp8EeZmnwEHi8gBIlIInAm8mY74lFKZ5ectm1g56QS67vycBX3G0/fUMXaHpCJIyzoWEZkKHA3sJSJrgFuBo0WkJ3VdWyuAi+tv2wF40hhzojHGKyJXADMBJ/C0MWZJOmJWSmWOLZt/5IeHTuRgzzcs7DeR0hPPszskFYUYE3HIIquVlpaaefPm2R2GUqqZtvy0ng0Pn0hn7/csGTCZXseNsjuknCUi840xpc19HF15r5TKWJs2VLH5sUF08q7hq989TK9jz7Q7JBUHTSxKqYz04w+r2Pb4IEp86/j62Mfp8buhdoek4qSJRSmVcTZUfc+Opwaxt+9Hvj3uGboPGGx3SCoBmliUUhnlh1Xf4H3mJPb0V7PyxBc4vN9Au0NSCdLEopTKGGu/XwrPD2YPs43Vg1/i0NLf2x2SagJNLEqpjLDm2y8oePEUXNSyfsgrdO35G7tDUk2kiUUpZbuVyxZSNHUIBfj4cdhrHNy9zO6QVDNoYlFK2er7Lz9jj1eGYRC2DH+dgw5t9jIKZTO7qxsrpfLYd59/SvErp+LHwfYRb7C/JpWcoIlFKWWLbyo/Yq/XTmMnLdg56m06d+lpd0gqSTSxKKXSbum8f7Nv+Rlsl1b4z32H/X51uN0hqSTSxKKUSqsvK96j41tnscVRjOP8d+mwfxe7Q1JJpoP3Sqm0+eKTtzjw/Qv40bkXrgvfoV2H/e0OSaWAtliUUmmx+L+v8av3z2ODcx+KRs/UpJLDNLEopVJu0Ycv0+XDi6gq2I89LnmPvfbtGPtOKmtpV5hSKqUWzHyBwz+9ipXWgex96Qxa77mP3SGpFNMWi1IqZea/8xRHfDqG762D2eeKmZpU8oQmFqVUSsx78xF6zrmObwoPpWTMe+xRvKfdIak00cSilEq6ua9Ppvf8G1ja4gg6X/Uuu+3Rxu6QVBppYlFKJdWcV/9J30W38IWrNwdeNYOi3VrbHZJKMx28V0olTcXUv1G27O8scvWjy5jXaelqZXdIygaaWJRSSVHx4q2UfXs/la1+Tbcx0yls0dLukJRNNLEopZqt4tkbKVvxEPN3O5ojxryCVdjC7pCUjTSxKKWazPj9VDzzF/qvfoJ5e/yRnle+RIFVaHdYymaaWJRSTWL8fiqevIr+a59nbvGJ9LniBZwFekpRmliUUk1g/H7mPHYp/de/zJw9T+HIy57B4XTaHZbKEJpYlFIJ8ft8fPbIhZT9+Bpz2p1G30ufQBy6ckH9QhOLUipufp+PeQ+dQ79Nb1Gx70j6jX5Qk4rahSYWpVRcfF4vCx4YSd8t7zG75DzKLrhPk4oKSxOLUiomr8fNwgdGcOTW/2N250vof97f7Q5JZTBNLEqpqDzunSyefBql2z5i9gFX0P+cu+0OSWU4TSxKqYh27qjhy8nD6F3zKRUHX0f/kX+1OySVBdLSQSoiT4vIBhH5IujYBBFZKiKfi8jrIlIc4b4rRGSxiCwUkXnpiFcpBTtqt7N00in0qvmUOYfeQJkmFRWndI28PQscH3LsA+BwY8wRwNfADVHuf4wxpqcxpjRF8SmlgtRu/5lv7h9E95rPmHv4rfQbPs7ukFQWSUtiMcZ8BGwKOfa+McZb/20FsF86YlFKRbf952qWTzqRbjsWMr/XXfQ97Vq7Q1JZJlPmCp4PvBvhZwZ4X0Tmi8joaA8iIqNFZJ6IzNu4cWPSg1Qq1/28ZROrJp9Al51fsKD07xw55Aq7Q1JZyPbEIiI3AV5gSoSbDDDG9AZOAC4Xkd9GeixjzOPGmFJjTGm7du1SEK1SuWvL5h9Z+8Dx/Mq9jM/L7qN08MV2h6SylK2JRUTOAU4CRhpjTLjbGGPW1n/eALwO9E1fhErlh+off2Djg8dxgOdbvhgwmd4nnGd3SCqL2ZZYROR44HrgZGNMTYTbtBKR3QNfA8cBX4S7rVKqaX5av4ZNDw+ko3cVXx39GL2OG2V3SCrLpWu68VRgNtBFRNaIyAXAg8DuwAf1U4kfrb9tBxF5p/6u+wAfi8giYC4wwxjzXjpiViof/Lh2JT8/djztfWv5+vdP0eOY0+0OSeWAtCyQNMaMCHP4qQi3XQucWP/1cqBHCkNTKm9tqPqenU+eyN7+n1h+3LN0HzDI7pBUjtCV90rloR9WfYP3mZNo49/CqhNfpFu/4+wOSeUQTSxK5Zmq5V/heH4we7CdqsEv0bX0WLtDUjlGE4tSeWT1t4spfPEUWrCTDae+Spcev7Y7JJWDNLEolSdWLl1A0ctDKcDHT8Om86vuZXaHpHKUJhal8sD3X37GHq8MwyBsGf46Bx2qZfdU6ti+8l4plVrfLvqE4ldOxYeTmrPeYH9NKirFNLEolcO+XvBf9n79dHbSEs/Zb9PpkJ52h6TygCYWpXLU0rkf0P6N4WyT3fCfO4OSA7vZHZLKE5pYlMpBX85+l44zRlHtaIPj/HfosH8Xu0NSeUQH75XKMV/87w0O/L+L2OhsR6sL32GvDp3tDknlmaiJRUQOjOdB6kuvKKVs9vl/pnPIrItZ5+zA7qNnsNe+He0OSeWhWC2Wb6nbaEvqPweEfu9MclxKqQQt/L+pHPa/K1hd0Im2l7xDm3bt7Q5J5amoYyzGGIcxxmmMcQAXAi8DXYGW9Z9fAi5IeZRKqagqZz5Ht/9dzgrrQPa6/H1NKspWiYyx3AkcbIyprf/+GxG5GPgaeDbZgSml4jN/xpP0mDuWb60udLhiBnsU72l3SCrPJTIrzAHsH3KsM9oNppRtPnvjYXrO/TNft+jGfmPe1aSiMkIiLZaJwIci8gywGugInFt/XCmVZp+9Nok+i27ly5Y9OPDKNynarbXdISkFJJBYjDETRGQxcDrQC1gHnK87OiqVfnNe+Qf9vrybz12lHDLmDVoW7WZ3SEo1SGgdS30S0USilI0qXrqLsq8nsNBVRtcxr9HS1crukJRqJO4xFhFpISJ3i8hyEdlSf+w4EbkideEppYJVvPBXyr6ewIJWv+Gwq9/QpKIyUiKD9xOBw4GR/LKGZQlwabKDUkrtavYz11P23STm734s3a+aTmGLlnaHpFRYiXSFnQr8yhizXUT8AMaYKhEpSU1oSikA4/cz5+k/03/NU3zW+jh6XzkVZ4FWY1KZK5FXpzv09iLSDvgpqREppRoYv5+KJ66i/7rnmdtmEH0uf16Tisp4iXSFvQo8JyIHAIhIe+BB6lbjK6WSzPj9zHn0Evqve545ew6h9IoXNKmorJBIYrkRWAEsBoqBb4C1wB3JD0up/Ob3+Zj78AWUbZhGxd5n0PfyZ3A4dS2yyg6JrGNxA1cDV9d3gf1ojDEx7qaUSpDf52Peg2fTb/PbzG4/irKLHkAcunWSyh6JTDfeFPjaGLMxkFREZEMqAlMqH/m8XuZPHkHfzW8ze7/zNamorJRIh60VekBELLRWmFJJ4fW4WTR5OEf+/CGzO19C//P+bndISjVJzMQiIv+jbt1KSxH5KOTH+wGfpiIwpfKJe+cOvph8On22f0TFgWPof/addoekVJPF02J5krqNvY4Engo6boD1wIcpiEupvLFzRw1fTR5K75rZVBzyZ8rOusXukJRqlpiJxRjzHICIVBhjlqY+JKXyx46abXw9eQg9d3zGnMNuouyMv9gdklLNlsio4GUiclTwARE5SkTuT3JMSuWFmm1b+HbSIA6vncfc7rfTT5OKyhGJJJYRwLyQY/OBs+K5s4g8LSIbROSLoGNtReQDEfmm/nObCPc9p/4234jIOQnErFRG2rZ1MysmD+LQHYuY3+tu+g672u6QlEqaRBKLCXN7ZwKP8SxwfMixccC/jTEHA/+u/74REWkL3Ar0A/oCt0ZKQEplg63VP7HmgRM5ZOcSKvtO4Mghl9sdklJJlUhi+R9wl4g4AOo/31Z/PCZjzEfAppDDpwDP1X/9HDAkzF0HAh8YYzYZYzYDH7BrglIqK2zZtJEfHjyeg9zL+Lz/REoHXWR3SEolXSLrWK4C3gbWichKoBN1u0gObsbz72OMWQdgjFknInuHuU0JdVshB6ypP6ZUVtm8cR0/PTqI/b0rWfKbh+j9hxF2h6RUSiRS0mWNiPSmrktqP+pO9nONMf5UBVdPwoUT9oYio4HRAJ06dUplTEol5Kf1a9j62CA6+qpYevRj9DzmNLtDUiplEqoVYYzxG2NmG2NeNcZUJCGprK+vkhyolhyuPMwaoGPQ9/tRV/wyXHyPG2NKjTGl7dq1a2ZoSiXHj2tXsu2x49nXt5Zv/vAUR2hSUTkuamIRka+Cvl4tIqvCfTTj+d8EArO8zgHeCHObmcBxItKmftD+uPpjSmW89Wu+o/aJ42nn28Dygc9x+G9OsTskpVIuVldY8MjiqOY8kYhMBY4G9hKRNdTN9BoPvCIiFwCrgNPrb1sKXGKMudAYs0lE7gQ+q3+oO4wxoZMAlMo461Yuw//sYIr9W1k1aArd+v7R7pCUSgvJ1cr3paWlZt680GU3SqVH1fIlOJ8/hSJq+OHklzik99F2h6RUTCIy3xhT2tzHidpiEZG4NvEyxvy1uYEolStWf7OIFlOGUIibDae+wiE9fm13SEqlVayusOBB85bAMOq6pALTjfsC01MTmlLZZ+VX82k1bSgO/Gw+/TV+1a2f3SEplXZRE4sx5rzA1yLyMjDCGDM96NhQ6sdFlMp3y7+YQ/G/TsOPg5+Hl3PAoX1S+nzllVVMmLmMtdW1dCh2MXZgF4b00iVeyn6JLJA8ARgZcuwN4JnkhaPULwInzqrqWpwi+IyhJI0n0PLKKm5/awmbazwAFLssTurRnllLN+5yMv920cfs9fpw3BSyc2Q5nQ/ukfLYbnhtMbUeHwBV1bXc8NpigIa/jSYeZZe4B+9FZD7wnDFmctCxK4HzjDG9UxRfk+ngfXYLPXEGE+pWyKYyyZRXVnHdq4vw+aO/P1yWk1t713LiosupoQjf2W9QcmC3Jj1fIklgwPgPqaqu3eV4SbGLT8YdG/bv57Kc3DO0uy3JRZNcdkjL4H2IC4HXReQvQBV1ZVW8wNDmBqFUqAkzl4VNKvBL2YVwV+nNEXzyE4EYOQWAQ71fMWjh39kie3C5dRufP76CDsXrEzpxxmp9BMdVXGRhDFTXesI+1tr6ZBPu71fr8TFh5rK0n9DjaV2p3JJISZdKETkYKAM6UFcnbLYxJvwrXKlmWBvmajycaCfLRLrSQk9+8TTk+8lXPF34D34wbTnfdzMrd7QGEj9xRkoC172yiFfnreLT7zY1JNNAt1wkxUVWQwzhVFXXUl5ZldYTut1JTltL6ZdIi6URY8xHItJKRAqNMduTGZTKbfG80TsUuyKeHEOFO1mGJgpffaaoqq7l6mkLue3NJdx2creG+0RrIYUzwLGYJ617WW3a8Sf3jayn8U4OiZw4I/2ePmP45LvE1gJv2+GlvLKqIZGGM/bVRUD6WguRLhICx5sylhZvstDWkj0SGWPpTl0Jlp3AfsaY3UTkROAcY8zwFMbYJC3aH2zan3M/IjCyXyfuGtLd7pAUkcdO2hRZ3Dr4lxP9zeWLebEi8WpBJcUujunajqlzVkc8sQYExmqKXVbErqVwjnYs5DFrIsvNvpzjuZENpnXEx/9+/KCYj3fQDe/EjDXZiiwHX955QrMeI1wX3ZZaD0WFTra7f/n/Bv7OiYo0JhTuNWQ5hVaFBWyp9TRKNLHGolRjyRpjSSSxfAw8Zox5QUQ2G2PaiEgr4GtjTMal/kBiCRhwUFumXNTfxogURB50hl9OJEDEgXu7/cExn4esSXxj9mOU+wY8hcXs8PjDJoZ4T177j5uRilBjGlX2ywVXIt1FobPlUin4bxjcsoklVjKLN+nnGzsG77sBL9Z/bQCMMdtFxNXcINLhk+82pb1vWdUJPmlFe7MHuo8CX2ea4x1zecB6gCVmf852X89WdgN35Di37/TGfM2VV1Y1+Yq+uQItwtLObePuLoo2Wy8VgrvLEnneWH/PDsVZcdrKWomUzV8BNFrxJSJ9gW+TGVAqBU5aKn0CJ4SqGEkloKq6Nu6xlXQ62fEpD1qTWWQOYpT7hrqkEkN1rYexry6i1x3vc8C4GQwY/yHllVWNbjNh5jJbkkrAlIpV3PbmkoiD66ESHYtqrtYuK+nP67KcjB3YJSmPpcJLJLHcAswQkduBQhG5AXgVuDklkaVAvDONVPKk+0SUCsMcHzHReoj55hDOdo9jG0Vx39fjN2yu8WD4ZeJAz9vfb0gwdr8mDbGnLsc6lkoenz9q92kihLqutcC4TXllFQPGfxgx6aumS2S68dsicgJ161n+C3QGhhpj5qcquGTT5m/62X3ibK7hzlncU/Akn/oP4yLPddTSstmPWV3raZiZZjkFty8zK4w7RDhg3IxGYy6JzNZLhu1uH9vd0Z+vTZHFth1ePFEWHhW7LBbeehxQ14rudcf7jcaIqqprGfuv9M6Wy2VxJRYRcQJPA6ONMZelNqTU0eZv+hUXWWkZ5E2FUc4PuMt6hv/4enCx5xp2UpjUx09kJloqtSmy2OHx79KZpmQzAAAgAElEQVSyDJ6iHRhzGTuwC9dMW2hr912Ay3IyrE8Js5ZuZHONB0eURa0idTMNX5qzKuJtPD7D7W8t0cSSBHF1hRljfNTt3Jjq/e1TSl8w6VVeWcWWDDl5Jup857vcZT3DB74+jPZcGzWptKlflJjJil0Wo8o6ISHHXZaTWwd3456h3aP+HoEFmwAjyzqlMNL4FLsshvUpYfr8qoYWVLRKCZtrPLxYETmpBN9ONV8iYywTgdtFJPPfRWGMyoA3Q7657c0lcZVFyTSXON/kr9YLvOPry2Weq3AT+SUvxLdK324n9WjPXUO6M3F4T0qKXbuMNwzpVUJRYfQODJ8x3PDaYko7t7U9mYrArKUbUzJ+p2MtzZfIdOMrgX2Ba0VkI3XjfnXvK2My/qz9/cZtdoeQlSItgotnrUOmdPUk4krna1xn/Ys3fEdxredSfDij3j7a4HcmmbV0I0BDEgknnrGTwGyxapuv7DfXeFIWg67Mb75EEkuz9ry3W76vY2lKvaTQtQOhg51XT1vI7W8tabRiPiD7pnYbri14lTEF5Uz3/YaxnovxJ9Sgz2yxJlEksp4m8Bqye1p46wQrJsTLrmKduSSRxDKbuqnFI6grQrkWeBm4OwVxpUS+vljirZcUmny27/TG7GrYXOPhmmkLuXrawkb1nbJrNphhXMFULil4m6neY7jRewEmh5IKxJ4Rmch6mg71ZXOmVKyybRC/2GUhoQNGSZRdr9/Mk8i75xHgWGAMcGT9598BD6cgrpTI1xdLPAvgQhcyVlXXxn01GFrGvryyKoumdhv+WvAClxS8zfPeP+ZkUgHYf8/o/49E3htV1bW2JhWo635szkC7U4RRZZ0oifA6zZ7Xb2ZKpMUyBDjIGFNd//2XIjKHupX35yc9shQoLMi9E0Ys0cY6gk8m4ZJPUwQS1tiBXRj76qKoawvsJvi5s+AZRhX8m6e8J3CndxTsMm8qN3zy3SZuLq8beA/XJZpo11bm/lejC66PBuFLxejK/OZLJLH8ABQB1UHHXNTty5IVdnqzerZ0k0Qb6whclSV7oH1tdW1DF1umrHkI5cDPPQVPMrzgPzziHczfvWeSq0klYErFKqbPr2rUJTr2X4u47c0lWTEBobnaFFlhq5y3tBwNf5Nil9VoOwXVNIkklheA90TkAWAN0BG4HHheRBpKuBpjPkxuiKo5onVxVFXXsv+4GUk/nQZ3I2RiUnHi4x/WYwxzfswk71AmeoeR60kF6v4Xoa1Sj8/kVFIpdlmc1KN9owQKv6zXCRautZKPF5+pkEhiubj+840hxy+p/4C61+6BzQ0qlfJtZlg8XRxNOfkHNmQKnUkkwDFd21FeWdVQIiOTFOBlovUwg50VTPCcwUO+IXaHlDecDsGXgq7RcNsTROryC2b3zpa5LJFaYQekMpB0yfUXTejMrmO6ttvl6i0ZAuU+ChzgCbrIM9SVY2/KJl2pZuHlAesBjnd+xt2es3jCd5LdIeWVpiaVwMVLuJpgkcZDQtfrBApOBieaWDtbqqZr8tbE2SqXXzThphVPn1/VUE8p1n4oTeHJkp6DFrh5yJrEH5yV3OY5m2d9x9sdkopTy6CdJGOtxwr3cyDsdPtI62B0Rljz5V1iyeUXTaSm/aylGxu6CuIpQd6mfoV9rvS9t8DN49Z9/M75OTd5zmeK7w92h6QSENw9Fa1yQKT1Wi0KHGHfF+Fa8TojLDnyav6t5ZCcftFEShjBu/Bt3+mN+hhOEW4d3I2TerRPenx2cLGDp60J/MaxmLGe0ZpUslQ8PQ2RLqzivUASYFifyIlLxS+vWix9D2iT8S+aSE39eLoAIpXk6FDs4ubyxXEtavMZw9XTFibzV7JNK2p5unACpbKMaz2XUu7/td0hqSYy1LW2o5Uiam43twGmz6+itHPbjD9PZLq8arEE6oVlqnCr3294bTE3ly8Oezz4d4lUkiMwS8vuldLptjs1PF84nj7yNVd5rtCkkgPCve6DJaObO9KWzCoxeZVYoG6FeaaK1JSfOmd1zJIska7WDHWVbfMpqezBNl4s/BvdZTmXe67ibX9/u0NSSRLtxH9M13ZJWY2UyxN80sXWxCIiXURkYdDHVhG5OuQ2R4vIlqDb/LU5z5nJA9KRXtC+CBt+BN8+0tVaSbErr94obdjK1MK76SqruMRzDTP9R9odkkqycK/n8soqps+viusCynJGTz+5PMEnXWxNLMaYZcaYnsaYnkAfoAZ4PcxN/xe4nTHmjvRGmT6tXeE3T3JGKOMa/AYYO7ALLqvx3iGBGS758kbZiy1MLbybg2QtF3mu40N/b7tDUilggP3HzWDA+A8busXCtfbDKSl2MeG0HhE3KtNZYcmRSYP3vwe+M8asTOWTtCqMvnGTXcorq9ju3nXGluUQhvftGLZERfAbIDDYGGmAf+y/FuHx5W6H2N5s5qXCu+kgP3Ge5y/M9neLfSdlu0AFh5L6bRoS6VEI3v4h3lZ5YFZk5V+PA5q2T5GKLZMSy5nA1Ag/6y8ii6jbA+bPxpiwAyUiMhoYDeDco13YB/JnyD6yoS/oGrc37Il/t5YF3DWke9QSFaGPNXF4z0ZvjiG9SnK60GB7fuKlwrtoJ1s4x309n5mudoek4uQzptFFUmjtrlgCYy6RShc5hEbbY1fXehrtRRRtXYxqOjEZcKIVkULqkkY3Y8z6kJ/tAfiNMdtE5ERgkjHm4FiP2aL9wab9OfeH/dmK8YOSEHXiAgmgqro27t36BPg+SrzhCulZTqFVYUHDFsLHdG2XkSVWkmE/2chL1l0UyzbOdV/PAnOI3SGpZiiyHNR6/AlNNhFg4vCeYcvftyhwhL2gCldfTIGIzDfGlDb3cTJlVtgJwILQpAJgjNlqjNlW//U7gCUie6U7wOYKnkoM8Rd+jGfnv0gVawNTk3M1qXSS9bxceCetZTuj3DdqUslAjgSnadV4/AnvDFlcZDGkVwn3DO1OSbELoS5x3DO0O1vi2ItIJV+mdIWNIEI3mIjsC6w3xhgR6UtdMvypqU8UadAu1eIdXAwWz0Bivr5BDpS1vFR4N4V4GOG+mS/N/naHpEIUOoWiwoKEu2ATrVW5ucbDzeWLuWtI97AVjMN1keXLhBa72N5iEZEi4I/Aa0HHLhGRQCn+04Av6sdYJgNnmmb03w06wp5SJfEkgGKXtcsVV6z+33x8gxwsa5hWeCdOfJzpviXnkkq27wxT7LJoVejEHbLXi4R8TqYpFavCLpyMNltSpY7tLRZjTA2wZ8ixR4O+fhB4MFnPN2vpxmQ9VEJi7Yvispy77FwXrtR3aKIZO7BLwgOe2exQWcmLhX/Di5Oz3DfzncmdgdfAJlXT5q7O6C2doymyHGzf6Q0bv6HugmnswC5c98qiiOuzmsIQfkuMWLMlVWrYnljSLd1dR9EG7APfl0So/RWuUiuwy4wvIOlv1Ex0uCznxcJ7qKEFZ7lvYoXJjUKZDoGz+nVi1tKNzRoPC0zdtVNNjH0UAttWX5OCenSR3ts68yv98i6xpLPrKDQ5GKInk2CRyrvc9uaSiFdlY19dlLVXurH0lG95vnA8WyniTPfNrDF72x1S0vgNSanlZndSiUfg/RfPzqaJiqdQpUqPvEss+++ZusQSbm1KaHIw1F1Zrq2ubah5FO5NEOnqq7rWw2G3vMvfhh6x6/2yvXM+glJZyjOFE/jJ7MFZ7ptYS9ZNCowpnSkhdG1HOgXGNsJ14bosJy0tB5trmr7eKlLLXqVX3iWWiuWb475tuG1+AzsxhlukGNp1FUngyrKqurZhX/jQN0G0K7oaj5+rpy3ktjeXNIzLTJi5LCdX1pc5vuQpawI/mLac5b6J9bS1O6SsZ1dSccgvr/NIYx8Qe5GkAEcd1JYVP9WGfY/ovvX2y7vEEm93QbhEEdz/HbgymrdyE7OWbmxys97jM9z+1q7dW2MHdom5L0rwKuJcnHb8a8dinrDuZbVpx0j3TWyk2O6Q4uaqX+iXieJdnJtsoQkt2thHpDFDpwj3ntGj4X4HjJsR9nfJxfdDNsm7xBJOuHpB8aw7qfX4ktI3vrnGwwHjZjRqBQ3pVcLtby2J2S0QuDqLtH93tjraUclj1v0sN+0Z6b6RTexhd0gJydSkAqlPKpESV0mc45uBpBGuqyx0Cn6kln0+TsPPJLavY7FbpM214m2BJOtNGnjua6YtbKjcGu+am6rq2pxKKn90zONx6z6+NiWMcN+UdUklV5UUu1gxfhD3D+/ZkCRCh/VclpORZZ2avXYk0kr6cC17XaeSeTKiVlgqRKsVFjwja8D4D8MmkVRM3Uy0C8JlOfNmfUrAiY4KJlkP8YU5gHPc17OVVnaHpKh7LQ7rU7LLGCOEXyOSzqrBWqE4eZJVKywvEwv80qy+ZtrCiCf7ZJ7YLafg8xvbBk6zwcmOT5hoPcwCczDnuf/CNorsDimvOUXwG9MwcSXc1g3xVIdQ2SPXilCmXXC57XACTe/m1BYLdBOUFLtoVVigSSWKYY6PuN96mLn+QznHPU6Tis0sR90g+ffjB/HJuGOZtXRj2HVVt7+VuVt9hxOoZnFAyEZhKrlyNrHEU1V1bXVtzD7aHc0YhDXUFb38ZNyxEausKjjT+SETrMf42H8453nGUkNLu0PKayIw4fQejVoikWZZba7xZM3JOdJ4arbEn01yNrEUFcae8Nah2BV1kLApFYlDBd54OkslvD8532e89ST/8ffgIs917KCF3SHlNZflZOIZPcOuq4oksNA300WqZpEt8WeTnJ1uvG2nl92j/FyAY7rW7TIZaT59vDPDYq1kvv2tJQw6on3O7ovSVBc4Z3CLNYX3fX24wjMGN/ZsaaDqBIpgTpi5jGumLWw0EB5tXVW2rBmJFGe2xJ9NcjaxxGKA6fOrKO3ctmEWS/C6EZcVX2POcgoTTusBEPGNt7nGo0klxKXON7neepkZvr5c5bkCb/6+FDOGCI0G6APT3+et3MRdQ7pH3N46W1rjuuYlffJ2VlhAJlSEzS+GMc7Xudb6F+W+o7jOcyk+nLHvpmwT2PoX4lu0mKnCbeOdTfGnQ7JmheX9ZaImlXQy/LngFa4oeINXvb/leu9o/Lk7zJd2gRmMzSniGE5gr5PAHvHZumZE92ZJn7xvsah0MdxY8BKjC2bwkvdYbvKej9GkklT3D+8ZcStepwgj+nVsqGsXuljXZTlpUeCIWsFBIGUn4+B9iwK9CLG2llDJpy0WlUUMtxY8z3kFM3nWexy3ec8h22r821W4MRHRNtDyG8NdQ7o3fB9utToQdcFw8BTdwPMFa+oK+NAuquDq31oCPzvlbGLJrtNW7hL83FXwDCML/s0T3hO52zuSbPvvWA7J+A3USopdlFdW4YgwZhg6QB1pJuS8lZtiFlYNV5Y+XDXwsf9axG1vLmFLrSdqook2rV9L4GennE0smX0ayA8O/IwveIIzCv7LQ96TmeAdTrYlFSCjkkqxy2Kn19/oRCz8MoMrXKSxijKGtjRGlnWKuRVEYIpucBdWKI/PNHStRWt9xJruq9OBs492cquUcOLjXusRzij4LxM9w7I2qWQSl+XktpO7MaxPCU755W9pQj4Hcwi0KHBwzbSFYUuYhFuNPqViVcNYRyQd6ltIiVQCj7QYMdZ0X50OnH1ytsWi7FOAl/uthzjJOYd/eM7gYd8Qu0PKeiX1hSDj2aMnmN/QqNUQ2j21afvOXfaOCSSoaDMm492zKFS41ke4bYoDtAR+dtLEopLKwsuD1mQGOudxl2ckT/oG2R1S1rMcQnWNOymLbEO7p5qiTZEVdaJANOFaH8HTgCPNCtPS+NlFE4tKmha4ediaxO+dldzqOYfnfAPtDiknePwGjzsz9uVxWU5uHdwNiLySHeqSz7Yd3kbjU9FaH9G2KQ43MUBni2U2HWNRSdGSnTxh3cvvnZXc4LlAk0oOcYqE3cUxUmXw+4f3pPKvxzHh9B4xd4CMhxaPzD7aYlHN5mIHT1n/pMzxFWM9o3nVd7TdIakkGtGvY6M1MAGxVrJHa4UkQotHZh9NLKpZdqOGpwsn0Ee+5hrPpbzh/7XdIWU0p6NuJ9FsMm3u6oZiraGSlTyi0eKR2Ue7wlST7cF2ni8cT2/5hjGeKzWpRCHAqLJOjOjbMebtgIapvsUuC8tp7zRtj9/Y2u0UazM+lXm0xaKapDXbeKHwHrrKKi7zXMX7/iPtDiljOaVum98hvUoYMP7DqLc11I1HBAo+lldWNSpX36rQieWMXtMroKTYRY3bG3Z6crHLolWLgrB1w8Kxs9tJi0dmH00sKmFt2cqLhfdwkKzlYs+1zPL3sjukjOY3puEkGM8Juqq6lpvLF1Paue0u6zv8Bm47uVvE1e7BAlf04UrF33Zyt4aYoq2eD7C72ykdXW4qebS6sUpIO6p5sfBvdJb1XOS5jv/5j7A7pKww4KC2rPipNqG1I0WWg5qQxYtQ1xJZW79SPprAXiMQ39V+eWUVY/+1CI+v8SNbDmHC6T0y7sSua1uSL1nVjTWxqLjtzWamFt5Fe9nEBZ4/M9vfze6Q8lKgfH08SapNkUXlX48D4jsRh+6kWuyyGrVuMoVu2pUaOVU2X0RWAD8DPsAb+ouJiACTgBOBGuBcY8yCaI/piFLnSCWuPT/xUuFdtJMtnOO+ns9MV7tDyluBpBCpDEqwzTWehvpg8SwyzJYup2hrW7Ih/lyXEYml3jHGmB8j/OwE4OD6j37AI/WfIyousrJiD41ssJ9sYKp1N61lO39y30ClOdjukPKW5ZCGlsa8lZuYOmd1zF1QAzO6culErGtbMlu2TDc+BXje1KkAikWkfbQ7/LzDq0klCTrLD0wrvJPdpYaz3DdmXVIR6sY3ckZ9Q7y8sorp86vi2lp7bXVtzp2II00msHuSgaqTKYnFAO+LyHwRGR3m5yXA6qDv19Qfa0RERovIPBGZt+PnzSkKNX8cJFW8UngHLXEzwn0zX5gD7Q4pYQb4ct3PDfvBZzuPr25NSSKVhTsUu3LuRKxrWzJbpiSWAcaY3tR1eV0uIr8N+Xm4AZNdLtWMMY8bY0qNMaXOotapiDNvHCKrebnwThwYRrhv5ivT2e6QmmxzjYfD2u+eM7vBRGuBhAqcbHPtRDykVwn3DO2elFpkKvkyYozFGLO2/vMGEXkd6At8FHSTNUDwkuX9gLXpizC/HCorebHwb3hxcpb7Jr4z9r9ZHVK3hqOpPv1uU1xdo22KrIT2O4nGAbSuf7x4xvuKLAeFBc6GvVIiLW4MtDJizQpziuxyss2l6bnZMtEgH9meWESkFeAwxvxc//VxwB0hN3sTuEJEXqZu0H6LMWZdtMeNtvudiqy7LOeFwnvYTkvOct/ESrOv3SEBcFa/Trw0Z1WTk0s8dwuseO91x/vNTi4C+IGttV4AXBHWpARr06pFw4p7iDylNtDKuDrKfijhpt7qiVilSyZ0he0DfCwii4C5wAxjzHsicomIXFJ/m3eA5cC3wBPAZTEfVfNKwnrJN0wpvJufTRHD3bdkTFIBeLGi6UklXsd0bQfArYO77dJt5HQk9oIK3YUxVlKBXQfSo3X3xEoQ2i2k7GR7i8UYsxzoEeb4o0FfG+DyRB432yrI2q1UlvJs4T/40bTmLPdNrGUvu0NKmninnc/4fB13DeketjbVMV3bMePzdQ0tmVRMZY+0u2KkBCEC4SaFiegGWMpetieWVEn0CjOf9Xcs4Snrn6wzbRnhvpkNtLE7pKT61d6t+HbD9piJILj7K/iEHq5LqsApYGi0Q2JzBVpM8Yo00zhHi2moLJKziSVXS9Uk228cn/OEdS8rzT6MdN/Ej+TebLp4kkrAzeWLGxYdOkUY0a8js5Zu3GVqr8dnaFNksbXWG9daknjMWroxoduXRCjrUtKEKcRad0slUyaMsaSE9oTFdoyjkietf7LcdGCE++acTCoQf5eV5agbywkkCp8xvFixKuLsq801Hu49Y5de3Carqq5lwPgPG0qwxJKsKcSBFllVfWHLQLmXeONQKlTOJhYV3UDHZzxm3ccy05ER7pvYxB52h2S7OMbXGxEh6RtgJXJST9ZaDt1TXiWbVjfOQ4McFUyyHuRzcyDnuq9nK63sDillMrVeXLxxBbrjwu05nywHjJsRNhYBvh8/KKHH0i617Jas6sbaYskzpzg+ZrL1AAvMwfzJfUPGJJWSYhejyjol/XEzIamETiNxWU5GlnWKaywk0B13c/ni1ARH8upuaZeaCsjZxGI5c/ZXa7LTnf9hovUIc/yHco77eraTOXWiatxeSju3zZmaXgGhScQpQq3Hx6ylGxk7sEvcA+1T56yOfaMmStZYjXapqYCcPfvuu0fLXd4s+ews57+ZYD3Ox/7DOd8zllpa2h1SI5trPFwzbSGHtd8dy5m9U8XbFFm7jHncNaR7w8k7MDEgcDV/TNd2cb1OkzXzLJwhvUoY1qekoVqFU4RhfRJfpZ9rFZRV0+XsdOPiIosunVrzyXeb7A7Fduc4Z3K79Rz/9vXiMs9V7KTQ7pDCMsAn322iVaETy2HiWq2eSVyWk1sHh99tMdLV/KylG7lnaPeGcYlI6SOVJYpCS/D7jGH6/CpKO7dNKLlE2tUyWysoq6bL2RZLdY2HTzWpcKFzBrdbzzHTV8olnmsyNqkE2+72UevxU5hAy8VlOZJWxcdlObl/eM+Y3VSWUyh2WXHNyIp2NT+kVwmfjDuW78cPijjONKJfx7DHkyFZXVi5VkFZNV3Otlh+2Lojh4qSNM1lznL+Yr3C274yrvZchjeL/t0GcPvi6/4RoNbjp02RhTFQXRt/AUkBjjqoLSt+qqWqurZhDGTCzGVRqweXhJnxVF5ZxYDxH4adERXpat4hQnllVcPtArO/psxZ1bCCvshyUNo5dZuVJasLK1wpHJ0Vlp+y50yTII8vu7pRkstwdcF0ri54jdd8v2as52J85OZ4U/C03c01HlyWkwEHtY27C9QAK36qrduz5NVFDSVa4kkqE2Yu45ppCxtqiU2fXxVxT/lIe9T7jNll7/nSzm0bPVaNxx92f/pkSWYXllZQVpDDXWH5OyvM8JeCaVxd8BqveH/Hnz2XZFRSsZL4b3GK7DImUevxJTyutra6ltveXBJX3S+X5eSYru12mVY7pWJVzO6klhF++dDbpXt2lXZhqWTL2bNvfs4KM9xUMIXLCt5kivf3XO+9CH+G/YuTOR6frJlSHYpdcXWfFbss7hnaPWztsEiRrK2ubVjfEW2Pl6r62wXuE+mxUkF3Y1TJlrNdYcVFFsf3KWFKxaqMWCSXaoKfWwue59yC93nGO5DbvWejm9I01qbIYofHH3bjrGibZgW0alHAkF4lXBPHbQM6FLvi3p8+0N1lx+wq7cJSyZRZl7NJNmvpxrxJKncXPMW5Be/zmHdQXiSVRFujQt0GXpGuzONZmBloMUQ6wYdbYT92YJe4WxqB7i7tmlLZLqcTSz4szHLgZ4L1OGcVzOIB7xDu8Z5FriWVQLmX0IQQaTpw6G8vwMiyTg1X5YGpvZ+MO7bhKv3Wwd1iLswMJJRI+6YcdVDbsEkrkZZGYPqxdk2pbJazXWFQ1x3W3L3LM5kTH/dajzDE+Sn3eU5jsm+o3SElXWAf+vLKql32Kwk30yp4+nAiU16Dp8pWVdfuUiRSqBsHOeiGdyKO7az4qbbRnvUBx3Rtx4sVq+L5dRuSkHZNqWyWs4mlusaD7PDaHUbKFOBlkvUgg5xz+bvnTB7xnWx3SClRVV1LrzveZ9sOb6OpwDe8tph7hnand0h1BQMsWLUl5hV+pCq8wbtGhksy0SYMRGohR9rAKzR5aXeXyhU52xX2w9YdSd02NpMU4uFhaxKDnHO50zPKlqSSzs62zTWeXf6XtR4fN7z2edjqCrGm5sZThTfQZVbssuIepwssdgwVKeEY0O4ulZNytsWSqwskW+DmEet+jnUu5BbPubzgOy7tMZSEWRDYHJZT8MS5yj5YbZS5y9HG16KtEwldSZ/IKv5wix0h8iyvQDefUrkmZ1ssubhAsiU7edL6J0c7FjHOc2Fak0qxy+L+4T25f3hPAKZUrKJFgYM2RXW1sopdFk5H4u2YVoVOJpzWo0n7tEfT2mUxYPyHHDBuxi7b/ca7TqQpCxLDtZZ0lpfKN7l39q237x4tc2puVBE7eMaawADHEv7iHc3LvvRd6d4/vCcLb61LYsFdSNW1HnZ4/Ewc3pNWLQrwNaHrcbv7lym2yUwu293eiF1d8WxsVV5ZFbWsSzShCUpneal8k7NdYcVFFj/aHUSS7EYNzxT+g17yLVd7LuNN/wBb4ojWhdScqd2BE/+wJCxoFeoqHYeW3A/u6go3myy4BREYg4nGKcLuLQvCdpWFS1w6y0vlk5xtsQA0oWcm4+zBdl4oHE9P+Y4rPVfaklQCXTuRruDXVtdSHGOBYawaYYG9SUaWdWpyS7Ok2MXE4T0jjr1UVdcyYPyHXDNtYaNuvNAWRKyV8pZTuPeMHtx2cjft4lIqjJxtsQBk+6SwYn7mhcJ76CKrucxzFR/4S22JI1DvKnR6bECHYhfbd0ae2m05pf6O0f8hVdW13DWkO6Wd28ZVYiWYQMNAeKSS94G1KFDXjeeynEwc3nOXlkS01lebIotBR7RvaKUVF1m0KHCwpdajZeKVqpfTLZZstidbmFp4N4dIFaM919qWVKBuGu1tby4JmxaEusHpLVFmT3l8Jq6p34FdEof0Kkl4vKW165cWU7jB8nBJMdK05EhjMCXFLgYd0Z4pFasaxm8213jY6a0bZwpeya9UPsvpxFKUzBrtadSOaqYW3sX+8gMXeP7Mf/y9bI3HZ0zEabcGEi5bEu15AgPsiXYnBe/cG26wPFr14VCRZnEd07Vd2DGgVJa0Vyob5XRXWDb2hO3DJl4qvJt9ZRPnef5Chf8wu0OKqiSofla8ZUuiib7S1UsAABbISURBVDVoHkl1SOme0MHyAeM/jLticKSdECfMXJZQglIqX+V0Yom2gC4TdeBHXiq8mz1lK2e7xzHfZPYgcPBAdaSyJYlq6tV/h2IX5ZVV3PbmkobWVZsii1sHd4trJliocLO4opXLT2VJe6WyTU4nlmzSUdYztfBu9qCGP7lvYKH5ld0h7SJQWj5Q2LNFwS9djU1d8xFOoD5XvCyHcEzXdo22Foa6OK+etpCrpy2kpNjFsD4lzFq6scn7sUdaQR8YZ1JK1cnOQYg4xbPHRibYX9YxrfBOWrGDs9w3ZmRScVlOBh3Rnh1BrcDqWg83vLaYm8sXJ3UxqtB4MD5YmyKr0f+12GUx4fQezFq6MeoEgarqWqbPr2LswC58P35QQ9dWuJX5kUSaFBAoya+UqmNri0VEOgLPA/sCfuBxY8ykkNscDbwBfF9/6DVjzB3xPP6tg7slPG013Q6SKl4qvJsCfJzlvomvTOe0PXek6cOhnCINV/vhFkhOnbM6qeNZhrrBeJflbPR8llMwBrbUeigJaXHE838O7mYL7hYLLNAEoiaISGMvmlSUakxMkvYNb9KTi7QH2htjFojI7sB8YIgx5sug2xwN/NkYc1Iij11aWmrmzZvH/uNmJDXmZDpEVjOl8G5AOMt9E9+Y/dL6/IFWRjyvgNCTfFO5LAc7PP6YzynAxOE9G60XCS6dH4gpsLAx2j4poY+rRSGVCk9E5htjmr22wdauMGPMOmPMgvqvfwa+ApJ6+Zfs4obJ0k1W8HLhnfhwMtx9S9qTCtQllHgvK2o9voZ1JqEiHQ/lspy0tJxxPWeHYlej3R6LCgvCls4PtEDiSSqBx423CKVSqmkyZoxFRPYHegFzwvy4v4gsEpF3RaRblMcYLSLzRGTexo11s5QycVD1CPmOlwrvooaWnOH+K8tNB7tDiovPmLDrO0b06xhzD3qnCPcM7b7LtOBwws3WipUM4rmACDxuPEUo8115ZVXE6tBKxZIRiUVEdgOmA1cbY7aG/HgB0NkY0wN4ACiP9DjGmMeNMaXGmNJ27er2Jc+0/u/e8jUvFv6NLaYVZ7pvYZXZx+6Q4uYUadRyCdTYumtI96h70AP4jYlrIWUgAYX+32Ilg3AD65ZDwtYDa0oZ+2ScaLPlZB3PRmhKRWPrGAuAiFjA28BMY8x9cdx+BVBqjIlavDgwxtLv7g9Y/7M7OcE2U1/5iqcLJ7DBFDPSfRPr2NPukJrMZTkbBvSrqmtxiuAzpuFzKKfUFW6EuvUgkV51Anw/ftAuxwMnu9B1KMFJKNJ2w+EkettYzx1LMh4j2SL9DSItJtUxqNyXrDEWuwfvBXgO2GSMuTrCbfYF1htjjIj0Bf5FXQsmauClpaXGeeo9GZNUjnJ8wZPWvaw1ezLCfRMbaZPW5w8kgnjL0juom6aX7BjuGdo96gyuaCevRJJBMiXjRJtpJ+toiS5S4o+U9FXuSFZisXuB5ADgT8BiEQmcbW4EOgEYYx4FTgMuFREvUAucGSupBGRKUvmtYxGPW/exwuzLKPeN/EjrpD22Q2JXcS6JoyQJ/DL9uKTYRY3b27AQMlkCg+0lEWZlQV1pmEjs2tMkGYP9mTZhINreOpFmzekYlIqX3bPCPjbGiDHmCGNMz/qPd4wxj9YnFYwxDxpjuhljehhjyowxn9oZc6KOdSzgCetevjMdGOG+KWJSacpiTssp3HdGz4hjGyXFLlaMH9RQdTfaScwp0pBUxg7sEtcge1Osra4NO8YRMH1+Vcb15SdjsD/TJgxES3S6lbJqrowYvM9VAx2f8ag1kaWmE2e5b2Ize0S8bVNaB8OP7JjQYHS0k1hgXCQwUBtr465YIk1BDkwjvmdo97C3ibdWWDoHwmP9feOJJdNO1tESnW6lrJorpxPLPrsX2vbcJzlm85A1icXmQEa5b2QLuyX9OWZ8vg6If0/1sQO71G26FUOtx4cxxJxCHEmkKcjBJ9IhvUrwR+jRjNU9lO5ZS9H+vvHGkmkn61iJLngNke4zoxJl+6ywVLFz5f2pjv/xT+tR5pkunO8ey3ZS192xIsHB1J63vx9xb5VggZXvsUqlBMZlArPBgkutBAbbg2eNlSRh9lEmDYRnUiyJsmsyhMpcuTJ4n3Lx1sNKltOd/+HvBU8w238YF3quo5aWaXz28IJPIPH+LQJdIsFl6EOF1usKFTgeqS5XoqXsAzJpIDyTYkmUXZMhVO7L+cQSaYZLKox0/h93W0/zX98RjPZcy05S3xVXXlkV9eQQblppLMEn90jVWtoUWXFdkUebfRS6R31gAeaEmcuYt3JTxBL3mTRrKZNiUSpT5PQYC4TvS06Fc53vcbf1NP/n65W2pALEHOgOd2IPZTmFYteuK9Rh150ZA+KdNRbrij548kHwBIIXg/aVDx23yKSB8EyKRalMkfMtltBS58nsFit2WXh8fkb6yrnRmsq7viMZ47kSTxr/rLG6XKL9PFDpN1p3VqQrckPd+EKsfvnWLitsV1rwFX08yS/QkgnuvsmE8YFMikWpTJHziQUa9yX3uuP9Zi/8K3ZZ3HZy3Za3b06+mpM3TeUtXxnXeC7Dm+Y/aawul+IiK+zv6xSJOCsrWLhxkIBY+5iUV1ax3e3d5bjlkEZX9PGORwTfLpPGBzIpFqUyQV4kluDB6+L6ooTRalWF+5nlECac3oMhvUq4uXwx106rZOX0m7iq4HVmyG+51nMRXlLf5RYaa7SV6uWVVWzbseuJHXZdtwLhk0PwFXm4lktwSyLUhJnL8Ph2/Wvu1rKg0e3jHQfTcQulskPOj7GErjPYXOPBAFaE3zxSwvH4DTe89jk3ly/mxYqVjC14masKXmea92iurB2NJ81JBepinVKxipvLFzc6Hliwd/W0hVG36w2ItSgxsKYh0gqYRGdGhY7PxDMOpuMWSmWPnE8skfrvPU2osFjr8fNixUpuKXiRSwve4gXvHxjnvRC/jX/GQHIJDGwHJ9JExNMdlWhZkniPh1s8OKqsU8YsJlRKJSbnu8KSuZ5A8HN7wXOcXfABT3uP5w7vnyDidXz6GOr2fJ8wcxk1bm+TthCO1c1UXlnF9p27dqtFa0kksk5FxymUyh05n1iStY5F8PO3gqcYUTCLR70nMd47guYmlXgqEycint/TcgoYdtk7PtYmV+EG8NsUWdw6uFvMBZI6Y0qp/JLzieWYru14sWJVsx7DgZ8J1mMMc/6Pyd4h3Oc9neYmFZflpEWBI67yKskSWCkPiZ3sI3UnFhUWxEwS2hJRKv/kfGKZtXRjk+538N6t+HbDdhz4uM96hFOcn3Kv5zQe8A1tcizB+52MHdiFa2LU4QrVJsLU4VjC7VSYyMk+3sF5rT2llII8SCxNHWNZs3kHI0v35TeLxzFQ5nKPZwSP+QY3OY7gtS8BkabwhrvvwluPY8D4D+NKLMUui1YtChqd4KFuQWNTTvrxlC0J7S6LNY1ZKZW7cn5WWFPXPvg8Ozj287EMlLn8g3PjTiqFEcrSt2qxa7dRvGXst9R3l8WTJF2Wk9tO7tao5DnQrDLz8ZQtiVYTTCmVX3K+xRLockpkjLwFbh6zJnK0YxFzDr2RRyoPj/u+7jALAqHuZB7cYjimaztmLd0YdgFhKIcI5ZVVMScihGsVQfSTfjytiXgG4bO5yq9SKrlyPrEM6VXCvJWbIg7gC43rWbVkJ09Y9zLAsYRxnosoO2QUHb6Pr8sqGuGXWVuBIovx8hnDNdMWctRBbdm03Z3w7KxknPRjDcJrlV+lVEDOd4UB3DXk/9u78yApyjOO49+fyy5yCYtgRAQRMSYhlAQoCs1lokElxiOJLkEjpSaelCEJJCRQRCEmgqWi0TIeUB4xSvDEBOORpCpVRFRAEMGDXYMGJMglhxx7Pfmje8g4TM/OQs/0zNbzqdqa3ul3Zp59t/d99n27+30HMatmMB0ybrfvVFXBrTWDue7sgVRWiI7s4f6qmZx8yEomNFzBo01fY+Jjy+l3eIeDugYsjjVhDPhX3Ra+M7T3J24cnFUzmNemjmyx0W/N8wfCZ/l1zqW0+R5LSkv/cd/09CvcVnEjg1XL+IZreKb5ZAAamoyFdVsO6rPjulXFCK5yS18HJTV9S66T8ge6oFZr+D0rzrmUNp9YWloeF2Dblo3c2TyNgXqPcQ3X8tfm4bF9fu+wVxDXYmPpw1f5XolVrEbf71lxzkEbTyyZDW+2GX1P6VPBprtG8Vm9z1UN43mxeWhsny/Y1yto7SqOUVpaxyTqpLw3+s65YmnTiSXXAlK7G5q4e8EiTmyaRp+mdVxrE3mxeVCsn2+w330rmVeFtaYnkzl85VdiOedKUZtOLLka2J5s5fa9v+FIbWT1abN5/i+tq4rqjpV8tKuBrh0q2bangWxrZvVO611E9Rieem0dP523nKYWJg3LHL4DvxLLOVea2vRVYVEN7JFsZm7VdI7SJp4eeDtXLOzSqhPsF43oy2tTR3JrzWD2NjZnTSr5nhy/6bm3cyYVAbNqBrNw0teznpT3K7Gcc6WmTSeWbKsr9mYjc6um01PbuKP3TK5fUd2q4ajqjpX8+txgyCxqqK1Cynv9kJbWpL9wRN+cswdnrmPi65Y455LWpofCMieg7KMNPFJ1A13YxUX1v2DTlr7sbmjd+Yj01Q+jkkKz2UHPw1UhcfMFJ/rswc65stOmeyzpDf+xWs+fqqbTiT2MqZ/Mpq6DIhND6r//bNKH1+K48TBqOCufpOKcc6WoTSeWVAM/QGuZWzWdShoZXT+FVXYsE08/IWdiyOf8RRznOHw4yznX1rTpobCJp5/AnMefYU7FDTRzCKPrp1BnR3/ivEXUHen53FQY142HPpzlnGtLZNkuaSpmANIZwG1ABXCfmd2Ysb898CAwFNgM1JjZmpbed9iwYfbo7Fn0eKKG3VQxpn4y9V3777eCYreOlZgFU9OX4jQkvniWc65YJC0xs2EH+z6J9lgkVQB3At8A1gKvSppvZqvSil0GbDWzAZJGAzOAmpbee8+uHRzx5AV8rA5c0+561uyt5ihg8XtbeHzJun29lK27GuhQGUxGWWoNti+e5ZwrR0mfYxkO1JrZu2ZWDzwKnJNR5hzggXD7MeBUSS1ONlz10btspzNjGn/F0p3V+xa4enjR+2WzIJUvnuWcK0dJJ5bewH/Svl8bPpe1jJk1AtuAw1t640bacVXldP7d+MmiUQN/pTgNik/Z4pwrR0mfvM/W88hs+/MpExSULgcuD7/d+/YdU9rnG4g1NdZrxlkr8i2fckiHw7pXdO7eWxXtqqypsb5p55Z1zbu35zvPfg9gU9TOyp79BqmiXVVcsR6EnHGWEI8zXh5nvMohzlim7Ug6sawF+qR9fzTwQUSZtZLaAV2BrA23md0D3AMgafHe9asP+iRUIUlaHMeJskLzOOPlccbL44yPpMVxvE/SQ2GvAsdLOlZSFTAamJ9RZj4wNtz+LvB3S/pSNuecc5ES7bGYWaOkccBzBJcbzzGzlZKmAYvNbD4wG3hIUi1BT2V0chE755xrSdJDYZjZAmBBxnNT07b3AOcfwFvfc5ChFUM5xAgeZ9w8znh5nPGJJcbEb5B0zjnXtiR9jsU551wbU9aJRdIZkt6WVCtpUpb97SXNDfe/LKlfAjH2kfQPSW9KWinpR1nKnCJpm6Rl4dfUbO9VhFjXSFoRxrDf1SEK3B7W5+uShiQQ4wlp9bRM0nZJ4zPKJFKfkuZI+lDSG2nPdZf0gqTV4WN1xGvHhmVWSxqbrUyB47xJ0lvh7/VJSd0iXpvzGClCnNdJWpf2ux0V8dqcbUOBY5ybFt8aScsiXlvMuszaDhXs+DSzsvwiONlfB/QHqoDlwOcyylwN/D7cHg3MTSDOXsCQcLsL8E6WOE8B/lwCdboG6JFj/yjgWYJ7i0YAL5fAMfBf4JhSqE/gK8AQ4I2052YCk8LtScCMLK/rDrwbPlaH29VFjnMk0C7cnpEtznyOkSLEeR0wIY/jImfbUMgYM/bfDEwtgbrM2g4V6vgs5x5LwaaDiZOZrTezpeH2DuBN9p9doFycAzxogUVAN0m9EoznVKDOzN5LMIZ9zOyf7H+PVfox+ABwbpaXng68YGZbzGwr8AJwRjHjNLPnLZjZAmARwT1liYqoz3zk0zbEIleMYVtzAfBIIT67NXK0QwU5Pss5sRRsOphCCYfivgC8nGX3SZKWS3pW0sCiBvZ/BjwvaYmCWQwy5VPnxTSa6D/aUqhPgE+Z2XoI/riBI7KUKbV6vZSgZ5pNS8dIMYwLh+zmRAzdlEp9fhnYYGarI/YnUpcZ7VBBjs9yTiyxTgdTaJI6A48D481se8bupQTDOScCvwOeKnZ8oS+a2RDgTOAaSV/J2F9K9VkFnA3My7K7VOozX6VUr5OBRuDhiCItHSOFdhdwHDAYWE8w1JSpVOrze+TurRS9LltohyJfluW5nPVZzomlNdPBoBamgykkSZUEv8yHzeyJzP1mtt3MdobbC4BKST2KHCZm9kH4+CHwJMGQQrp86rxYzgSWmtmGzB2lUp+hDanhwvDxwyxlSqJew5OyZwEXWji4nimPY6SgzGyDmTWZWTNwb8TnJ16fYXvzbWBuVJli12VEO1SQ47OcE0tZTAcTjrPOBt40s1siyhyZOvcjaTjB72Vz8aIESZ0kdUltE5zMfSOj2HzgYgVGANtS3egERP43WAr1mSb9GBwLPJ2lzHPASEnV4dDOyPC5olGw4N7PgbPNbFdEmXyOkYLKOKd3XsTn59M2FNppwFtmtjbbzmLXZY52qDDHZzGuSCjglQ6jCK5uqAMmh89NI/jjADiUYKikFngF6J9AjF8i6Da+DiwLv0YBVwJXhmXGASsJrl5ZBJycQJz9w89fHsaSqs/0OEWwMFsdsAIYltDvvSNBouia9lzi9UmQ6NYDDQT/5V1GcE7vb8Dq8LF7WHYYwYqpqddeGh6ntcAlCcRZSzCOnjpGU1dTHgUsyHWMFDnOh8Jj73WCRrFXZpzh9/u1DcWKMXz+/tTxmFY2ybqMaocKcnz6nffOOediVc5DYc4550qQJxbnnHOx8sTinHMuVp5YnHPOxcoTi3POuVh5YnGuzEgySQOSjsO5KJ5YnCuwcHr005KOw7li8cTinHMuVp5YnGsFSZMk1UnaIWmVpPPS9v0wXEgptW+IpIeAvsAzknZK+pmChcjWZrzvvl6NpOGSXpL0kaT1ku4IpyZxrix4YnGudeoIpkPvClwP/EFSL0nnEyxCdTFwGMHMy5vN7PvA+8C3zKyzmc3M4zOagB8DPYCTCNaduTruH8S5QvHE4lwrmNk8M/vAzJrNbC7BHEvDgR8AM83sVQvU2gEuQGZmS8xskZk1mtka4G7gq7H9EM4VWLukA3CunEi6GPgJ0C98qjNBz6IPQW8mjs/4NHALwUSAHQn+TpfE8d7OFYP3WJzLk6RjCNYAGQccbmbdCKY6F8HMwMdFvDRzptePCRJG6n0rgJ5p++8C3gKON7PDgF+SfbEl50qSJxbn8teJIElsBJB0CfD5cN99wARJQ8P1agaEiQhgA8E06SnvAIdK+ma4+NIUoH3a/i7AdmCnpM8AVxXsJ3KuADyxOJcnM1tFsBTuSwTJYhCwMNw3D7gB+COwg2A55O7hS38LTAmv8ppgZtsITsbfB6wj6MGkXyU2ARgTvs+95FiF0LlS5OuxOOeci5X3WJxzzsXKE4tzzrlYeWJxzjkXK08szjnnYuWJxTnnXKw8sTjnnIuVJxbnnHOx8sTinHMuVp5YnHPOxep/2LnC5t95wiYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 6))\n",
    "plt.scatter(y_train.values.flatten(), y_pred)\n",
    "plt.xlim(0, 20)\n",
    "plt.ylim(0, 20)\n",
    "plt.xlabel('actual', fontsize=12)\n",
    "plt.ylabel('predicted', fontsize=12)\n",
    "plt.plot([(0, 0), (20, 20)], [(0, 0), (20, 20)])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score: 2.314\n"
     ]
    }
   ],
   "source": [
    "score = mean_absolute_error(y_train.values.flatten(), y_pred)\n",
    "print(f'Score: {score:0.3f}')\n",
    "# This is totally crap. He validated on the same dataset that he trained."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission = pd.read_csv('../input/sample_submission.csv', index_col='seg_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test = pd.DataFrame(columns=X_train.columns, dtype=np.float64, index=submission.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "for seg_id in X_test.index:\n",
    "    seg = pd.read_csv('../input/test/' + seg_id + '.csv')\n",
    "    \n",
    "    x = seg['acoustic_data'].values\n",
    "    \n",
    "    X_test.loc[seg_id, 'ave'] = x.mean()\n",
    "    X_test.loc[seg_id, 'std'] = x.std()\n",
    "    X_test.loc[seg_id, 'max'] = x.max()\n",
    "    X_test.loc[seg_id, 'min'] = x.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test_scaled = scaler.transform(X_test)\n",
    "submission['time_to_failure'] = svm.predict(X_test_scaled)\n",
    "submission.to_csv('../output/submission_bfb_{:0.3f}.csv'.format(score))"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}