notebook-demo-docker/demo/notebooks/pymapd_to_h2ogpuml_to_mapd.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GPU Open Analytics Initiative: PyMapD to H2OGPUML to MapD\n",
    "\n",
    "### In this demo, we will train 4000 regularized linear regression models on the FIFA Football dataset, with the goal to predict the overall rating of the player, given different  feature sets (such as potential, finishing, strength, etc.)\n",
    "\n",
    "### The dataset has 180k rows, 42 cols, Integer/single-precision floating-point values, so it fits onto the GPU memory.\n",
    "\n",
    "### By using multiple GPUs, we are able to speed up this process significantly, and can train around 40 models per second (on Quadro - 6000,  with 4 GPUs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choose to Store predictedictions in DB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# storage=0: Do not store the values in MapD\n",
    "# storage=1: Store the predicted values in MapD\n",
    "\n",
    "storage=1\n",
    "\n",
    "# storage=1: Predicted values will be copied to host memory in the process of inserting records in MapD.\n",
    "\n",
    "family='elasticnet'\n",
    "\n",
    "#Linear Regression: elasticnet\n",
    "#Logistic Regression: logistic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import os.path\n",
    "from pprint import pprint\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load PyMapD and PyGDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pymapd\n",
    "import pygdf\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setup MapD Connection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Established Connection(mapd://mapd:***@localhost:9091/mapd?protocol=binary)\n"
     ]
    }
   ],
   "source": [
    "db_name = 'mapd'\n",
    "user_name = 'mapd'\n",
    "passwd = 'HyperInteractive'\n",
    "hostname = 'localhost'\n",
    "\n",
    "con = pymapd.connect(user=user_name, password=passwd, host=hostname, dbname=db_name)\n",
    "print('Established {}'.format(con))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract Data from MapD to PyGDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total No.of columns: 37\n"
     ]
    }
   ],
   "source": [
    "columns = '''overall_rating,rowid AS map_id,potential,CASE WHEN preferred_foot = 'left' THEN 1 WHEN preferred_foot = 'right' THEN 2 ELSE 0 END,crossing,finishing,heading_accuracy,short_passing,volleys,dribbling,curve,free_kick_accuracy,long_passing,ball_control,acceleration,sprint_speed,agility,reactions,balance,shot_power,jumping,stamina,strength,long_shots,aggression,interceptions,positioning,vision,penalties,marking,standing_tackle,sliding_tackle,gk_diving,gk_handling,gk_kicking,gk_positioning,gk_reflexes'''.strip()\n",
    "print('Total No.of columns: %d'%(len(columns.split(','))))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Select statement is : SELECT overall_rating,rowid AS map_id,potential,CASE WHEN preferred_foot = 'left' THEN 1 WHEN preferred_foot = 'right' THEN 2 ELSE 0 END,crossing,finishing,heading_accuracy,short_passing,volleys,dribbling,curve,free_kick_accuracy,long_passing,ball_control,acceleration,sprint_speed,agility,reactions,balance,shot_power,jumping,stamina,strength,long_shots,aggression,interceptions,positioning,vision,penalties,marking,standing_tackle,sliding_tackle,gk_diving,gk_handling,gk_kicking,gk_positioning,gk_reflexes FROM PLAYER_ATTRIBUTES WHERE overall_rating > 30 ORDER BY ID\n"
     ]
    }
   ],
   "source": [
    "query_select = '''SELECT {} FROM PLAYER_ATTRIBUTES WHERE overall_rating > 30 ORDER BY ID'''.format(columns)\n",
    "print('Select statement is : {}'.format(query_select))\n",
    "\n",
    "df = con.select_ipc_gpu(query_select, device_id=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot response column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7eff91423518>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAFV5JREFUeJzt3X+MXeV95/H3t3gpBrceTAaLtd01FdZEqb1hAQFRttE4\nZMH8UIxWiUtFGxPR+o/SlnRdFWeliDQByZHSpWS1jWTFtE6bhkzdVFiYhFpORt1UgoADGwMuiwMG\nPCI4qY2zTmi2k/3uH/cZuJ5nBg/3jH3vHb9f0mjOec5zzn0e3Xv8mec55x5HZiJJUruf63YDJEm9\nx3CQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSZV63G9CpgYGBvOiii7rdjMZ+/OMf\nc84553S7GY3Zj94xF/oA9uNk2LNnzw8zc3Amdfs2HBYvXszjjz/e7WY0Njo6yvDwcLeb0Zj96B1z\noQ9gP06GiHhxpnWdVpIkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVfr2G9LS\n6WT5pp1vLB/YfH0XW6LThSMHSVLFcJAkVQwHSVLFaw5SH/NahE4WRw6SpMoJwyEi7ouIQxHxVFvZ\noojYFRHPld/nlvKIiM9FxP6I+G5EXNK2z/pS/7mIWN9WfmlE7C37fC4iYrY7KfWL5Zt2vvEjddNM\nRg5/AayZVLYJ2J2ZK4DdZR3gWmBF+dkAfB5aYQLcCVwBXA7cOREopc5vt+03+bWkOc1AUC86YThk\n5j8AhycVrwW2leVtwI1t5V/MlkeAgYi4ALgG2JWZhzPzCLALWFO2/WJmPpKZCXyx7ViSpC6J1r/J\nJ6gUsRx4MDNXlvXXMnOgLAdwJDMHIuJBYHNmfqts2w3cAQwDZ2XmXaX8E8DrwGip/4FS/qvAHZl5\nwzTt2EBrRMLg4OClIyMjnfW6hxw7dowFCxZ0uxmN2Y/O7R07OmX5qiULp6wzXfmExfPh/EULq/J+\n42dq9q1evXpPZl42k7qN71bKzIyIEyfMLMjMLcAWgKGhoeyV/5e1iV76/2WbsB+du2Wa6aQDNw9P\nWWe68gkbV42zzveiZ/RrPzq9W+nVMiVE+X2olI8By9rqLS1lb1W+dIpySVIXdRoOO4CJO47WAw+0\nlX+k3LV0JXA0M18BHgaujohzy4Xoq4GHy7YfRcSVZXrqI23HkiR1yQmnlSLiy7SuGbwjIg7Suuto\nMzASEbcCLwLrSvWHgOuA/cBPgI8CZObhiPg08Fip96nMnLjI/Tu07oiaD3yt/EiSuuiE4ZCZvz7N\npqumqJvAbdMc5z7gvinKHwdWnqgdkqRTx8dnSKcZH7mhmfDxGZKkiuEgSaoYDpKkiuEgSaoYDpKk\niuEgSap4K6s0x/kocHXCcJBOEb9foH7itJIkqWI4SJIqhoMkqWI4SJIqXpCWBHjBXMczHKRZ5j+y\nmgucVpIkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFL8FJekt+qe/05MhBklQxHCRJ\nFcNBklQxHCRJFcNBklQxHCRJlUbhEBF/EBFPR8RTEfHliDgrIi6MiEcjYn9EfCUizix1f76s7y/b\nl7cd5+Ol/NmIuKZZlyRJTXUcDhGxBPh94LLMXAmcAdwEfAa4JzMvAo4At5ZdbgWOlPJ7Sj0i4l1l\nv18B1gB/FhFndNouSVJzTaeV5gHzI2IecDbwCvB+YHvZvg24sSyvLeuU7VdFRJTy+zPzp5n5ArAf\nuLxhuyRJDXQcDpk5BnwWeIlWKBwF9gCvZeZ4qXYQWFKWlwAvl33HS/3z2sun2EeS1AWRmZ3tGHEu\n8LfArwGvAX9Da0TwyTJ1REQsA76WmSsj4ilgTWYeLNu+B1wBfBJ4JDP/qpRvLftsn/SSRMQGYAPA\n4ODgpSMjIx21vZccO3aMBQsWdLsZjdmPN+0dO/rG8qolC99WebtO9108H85fdOLjd/Ia7eUnm5+p\n2bd69eo9mXnZTOo2ebbSB4AXMvMHABHxVeC9wEBEzCujg6XAWKk/BiwDDpZpqIXAP7eVT2jf5ziZ\nuQXYAjA0NJTDw8MNmt8bRkdHsR+9Yzb6cUv7s4huHn5b5e063XfjqnHWDb91nU5fo738ZPMz1V1N\nrjm8BFwZEWeXawdXAc8A3wQ+VOqsBx4oyzvKOmX7N7I1bNkB3FTuZroQWAF8u0G7JEkNdTxyyMxH\nI2I78B1gHHiC1l/1O4H7I+KuUra17LIV+MuI2A8cpnWHEpn5dESM0AqWceC2zPxZp+2SJDXX6JHd\nmXkncOek4ueZ4m6jzPwX4MPTHOdu4O4mbZEkzR6/IS1Jqvif/UizYPlbXPSV+pEjB0lSxXCQJFUM\nB0lSxXCQJFUMB0lSxXCQJFW8lVXSjLXfsntg8/VdbIlONkcOkqSK4SBJqhgOkqSK4SBJqhgOkqSK\n4SBJqhgOkqSK4SBJqhgOkqSK4SBJqhgOkqSK4SBJqhgOkqSK4SBJqhgOkqSK4SBJqhgOkqSK4SBJ\nqhgOkqSK4SBJqhgOkqSK4SBJqjQKh4gYiIjtEfFPEbEvIt4TEYsiYldEPFd+n1vqRkR8LiL2R8R3\nI+KStuOsL/Wfi4j1TTsl6dRavmnnGz+aG5qOHO4Fvp6Z7wTeDewDNgG7M3MFsLusA1wLrCg/G4DP\nA0TEIuBO4ArgcuDOiUCRJHVHx+EQEQuB9wFbATLz/2bma8BaYFuptg24sSyvBb6YLY8AAxFxAXAN\nsCszD2fmEWAXsKbTdkmSmovM7GzHiIuBLcAztEYNe4DbgbHMHCh1AjiSmQMR8SCwOTO/VbbtBu4A\nhoGzMvOuUv4J4PXM/OwUr7mB1qiDwcHBS0dGRjpqey85duwYCxYs6HYzGjtd+rF37Ogby6uWLJyy\nvN10dU7mvovnw/mLTnz8U9G+Jk6Xz9SptHr16j2ZedlM6s5r8DrzgEuA38vMRyPiXt6cQgIgMzMi\nOkufKWTmFlqBxNDQUA4PD8/WobtmdHQU+9E7TtSPW9rm1A/cPDxlebvp6pzMfTeuGmfd8FvXOVXt\na+J0+Uz1qibXHA4CBzPz0bK+nVZYvFqmiyi/D5XtY8Cytv2XlrLpyiVJXdJxOGTm94GXI2KoFF1F\na4ppBzBxx9F64IGyvAP4SLlr6UrgaGa+AjwMXB0R55YL0VeXMklSlzSZVgL4PeBLEXEm8DzwUVqB\nMxIRtwIvAutK3YeA64D9wE9KXTLzcER8Gnis1PtUZh5u2C5JUgONwiEznwSmurhx1RR1E7htmuPc\nB9zXpC2SpNnjN6QlSRXDQZJUMRwkSRXDQZJUMRwkSRXDQZJUMRwkSRXDQZJUMRwkSRXDQZJUMRwk\nSZWmD96T5qT2/wv5wObru9gSqTsMB0knjSHbv5xWkiRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVw\nkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAepWL5pJ3vHjh73PCDpdGU4SJIqhoMkqWI4SJIqhoMkqWI4\nSJIqjcMhIs6IiCci4sGyfmFEPBoR+yPiKxFxZin/+bK+v2xf3naMj5fyZyPimqZtkiQ1Mxsjh9uB\nfW3rnwHuycyLgCPAraX8VuBIKb+n1CMi3gXcBPwKsAb4s4g4YxbaJUnqUKNwiIilwPXAF8p6AO8H\ntpcq24Aby/Lask7ZflWpvxa4PzN/mpkvAPuBy5u0S5LUzLyG+/8p8EfAL5T184DXMnO8rB8ElpTl\nJcDLAJk5HhFHS/0lwCNtx2zfR9Ic0f7lwgObr+9iSzQTkZmd7RhxA3BdZv5ORAwDfwjcAjxSpo6I\niGXA1zJzZUQ8BazJzINl2/eAK4BPln3+qpRvLftsn/SSRMQGYAPA4ODgpSMjIx21vZccO3aMBQsW\ndLsZjc2FfuwdO8ri+fDq68eXr1qy8Lg6Jyrv9r6L58P5i058/G61b3Kd6cyFzxT0Vj9Wr169JzMv\nm0ndJiOH9wIfjIjrgLOAXwTuBQYiYl4ZPSwFxkr9MWAZcDAi5gELgX9uK5/Qvs9xMnMLsAVgaGgo\nh4eHGzS/N4yOjmI/esMtm3aycdU4f7L3+NPiwM3Dx9U5UXm39924apx1w29dp5vtm1xnOnPhMwX9\n24+Orzlk5sczc2lmLqd1QfkbmXkz8E3gQ6XaeuCBsryjrFO2fyNbw5YdwE3lbqYLgRXAtzttlySp\nuabXHKZyB3B/RNwFPAFsLeVbgb+MiP3AYVqBQmY+HREjwDPAOHBbZv7sJLRLkjRDsxIOmTkKjJbl\n55nibqPM/Bfgw9Psfzdw92y0RZLUnN+QliRVDAdJUsVwkCRVDAdJUsVwkCRVTsatrJI0Yz5Wozc5\ncpAkVQwHSVLFcJAkVQwHSVLFC9I67XgBVDoxRw6SpIrhIEmqGA6SpIrhIEmqGA6SpIp3K2nO8q4k\nqXOOHCRJFcNBklQxHCT1pL1jR1m+aedx04M6dQwHSVLFcJAkVQwHSVLFcJAkVQwHSVLFcJAkVQwH\nSVLFcJAkVQwHSVLFB+9pzvCbtNLsceQgSap0HA4RsSwivhkRz0TE0xFxeylfFBG7IuK58vvcUh4R\n8bmI2B8R342IS9qOtb7Ufy4i1jfvlqS5ZOIZS44OT50mI4dxYGNmvgu4ErgtIt4FbAJ2Z+YKYHdZ\nB7gWWFF+NgCfh1aYAHcCVwCXA3dOBIokqTs6DofMfCUzv1OW/w+wD1gCrAW2lWrbgBvL8lrgi9ny\nCDAQERcA1wC7MvNwZh4BdgFrOm2XJKm5yMzmB4lYDvwDsBJ4KTMHSnkARzJzICIeBDZn5rfKtt3A\nHcAwcFZm3lXKPwG8npmfneJ1NtAadTA4OHjpyMhI47Z327Fjx1iwYEG3m9FYL/Rj79jRabetWrJw\nynqTyxfPh1df72zfJq87m/sung/nLzrx8bvVvpnue+jw0eq9mFynH/TCuTFh9erVezLzspnUbXy3\nUkQsAP4W+Fhm/qiVBy2ZmRHRPH3ePN4WYAvA0NBQDg8Pz9ahu2Z0dBT7MTtueYv56AM3D09Zb3L5\nxlXj/Mne40+Lme7b5HVnc9+Nq8ZZN/zWdbrZvpnu+9+/9ED1Xkyu0w964dzoRKO7lSLi39AKhi9l\n5ldL8atluojy+1ApHwOWte2+tJRNVy5J6pImdysFsBXYl5n/rW3TDmDijqP1wANt5R8pdy1dCRzN\nzFeAh4GrI+LcciH66lImSeqSJtNK7wV+E9gbEU+Wsv8KbAZGIuJW4EVgXdn2EHAdsB/4CfBRgMw8\nHBGfBh4r9T6VmYcbtEtzXPvtjAc2X9/FlkhzV8fhUC4sxzSbr5qifgK3TXOs+4D7Om2LJGl2+Q1p\nSVLFZytJ6ltOMZ48jhwkSRXDQZJUMRwkSRXDQZJU8YK0+oKPapZOLUcOkqSK4SBJqhgOkqSK4SBJ\nqnhBWj3Fb7yqU352ZpcjB0lSxXCQJFWcVlJXOAUg9TZHDpKkiuEgSao4raRTxkdgqBucwuyMIwdJ\nUsVwkCRVDAdJUsVrDpp1zvFK/c9wUMfaQ+Av1pzTxZZInfEPmek5rSRJqhgOkqSK00qShFNMkzly\nkCRVDAdJUsVpJb0tPgJDp5vTdbrJcNCUTtcTQlJLz0wrRcSaiHg2IvZHxKZut0eSTmc9MXKIiDOA\n/wH8J+Ag8FhE7MjMZ7rbsrlpuqkhRwjSzM310XVPhANwObA/M58HiIj7gbWA4dDAXP/wSr1iunNt\n+aadbFw1zi2bdvbdOdgr4bAEeLlt/SBwRZfackpMfJg2rhpneIryySZ/4Ga6TVLv6YfRe2Rmt9tA\nRHwIWJOZv1XWfxO4IjN/d1K9DcCGsroSeOqUNvTkeAfww243YhbYj94xF/oA9uNk+HeZOTiTir0y\nchgDlrWtLy1lx8nMLcAWgIh4PDMvOzXNO3nsR2+ZC/2YC30A+9FtvXK30mPAioi4MCLOBG4CdnS5\nTZJ02uqJkUNmjkfE7wIPA2cA92Xm011uliSdtnoiHAAy8yHgobexy5aT1ZZTzH70lrnQj7nQB7Af\nXdUTF6QlSb2lV645SJJ6SM+HQ0ScFRHfjoj/FRFPR8Qfl/ILI+LR8riNr5QL2T0vIs6IiCci4sGy\n3nf9iIgDEbE3Ip6MiMdL2aKI2BURz5Xf53a7nScSEQMRsT0i/iki9kXEe/qtHxExVN6HiZ8fRcTH\n+q0fABHxB+UcfyoivlzO/X48P24vfXg6Ij5Wyvru/ej5cAB+Crw/M98NXAysiYgrgc8A92TmRcAR\n4NYutvHtuB3Y17ber/1YnZkXt92itwnYnZkrgN1lvdfdC3w9M98JvJvW+9JX/cjMZ8v7cDFwKfAT\n4O/os35ExBLg94HLMnMlrRtTbqLPzo+IWAn8Nq2nPrwbuCEiLqLP3g8AMrNvfoCzge/Q+vb0D4F5\npfw9wMPdbt8M2r+U1gfj/cCDQPRpPw4A75hU9ixwQVm+AHi22+08QR8WAi9Qrrv1az8mtf1q4B/7\nsR+8+ZSERbRulHkQuKbfzg/gw8DWtvVPAH/Ub+9HZvbFyGFiKuZJ4BCwC/ge8FpmjpcqB2l9uHrd\nn9L6oPy/sn4e/dmPBP4+IvaUb60DLM7MV8ry94HF3WnajF0I/AD48zLN94WIOIf+60e7m4Avl+W+\n6kdmjgGfBV4CXgGOAnvov/PjKeBXI+K8iDgbuI7WF3z76v2A/phWIjN/lq1h81Jaw7V3drlJb1tE\n3AAcysw93W7LLPiPmXkJcC1wW0S8r31jtv486vXb4OYBlwCfz8z/APyYSUP9PukHAGUu/oPA30ze\n1g/9KHPwa2mF9r8FzgHWdLVRHcjMfbSmwv4e+DrwJPCzSXV6/v2APgmHCZn5GvBNWsPLgYiY+J7G\nlI/b6DHvBT4YEQeA+2lNLd1L//Vj4q88MvMQrfnty4FXI+ICgPL7UPdaOCMHgYOZ+WhZ304rLPqt\nHxOuBb6Tma+W9X7rxweAFzLzB5n5r8BXaZ0z/Xh+bM3MSzPzfbSuk/xv+u/96P1wiIjBiBgoy/Np\n/Z8P+2iFxIdKtfXAA91p4cxk5sczc2lmLqc1/P9GZt5Mn/UjIs6JiF+YWKY1z/0UrcedrC/Ver4f\nmfl94OWIGCpFV9F6RHxf9aPNr/PmlBL0Xz9eAq6MiLMjInjz/eir8wMgIs4vv38J+M/AX9N/70fv\nfwkuIv49sI3W3Qs/B4xk5qci4pdp/QW+CHgC+I3M/Gn3WjpzETEM/GFm3tBv/Sjt/buyOg/468y8\nOyLOA0aAXwJeBNZl5uEuNXNGIuJi4AvAmcDzwEcpnzH6qx/n0PrH9Zcz82gp68f344+BXwPGaZ0L\nv0XrGkPfnB8AEfE/aV1P/Ffgv2Tm7r58P3o9HCRJp17PTytJkk49w0GSVDEcJEkVw0GSVDEcJEkV\nw0GSVDEcJEkVw0GSVPn/wcTWZ/rmITYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7eff9144aeb8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "df['overall_rating'].to_pandas().hist(bins=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensure extracted data is float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for col in df.columns:\n",
    "    df[col] = df[col].astype(np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Pre-processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "response_col = 'overall_rating'\n",
    "key_col = 'map_id'\n",
    "feature_col = set(df.columns) - set([response_col]) - set([key_col])\n",
    "\n",
    "num_col = set()\n",
    "cat_col = set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if storage == 1:\n",
    "    # Create DF with key_col\n",
    "    from pygdf.dataframe import DataFrame\n",
    "    df_src = DataFrame()\n",
    "    df_src.add_column(key_col, df[key_col].astype(np.int32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Distinguish Categorical and Numerical columns by computing unique values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "unique_val = {}\n",
    "for col in feature_col:\n",
    "    try:\n",
    "        val = df[col].unique_k(1000)\n",
    "    except ValueError:\n",
    "        # more than 1000 unique values\n",
    "        num_col.add(col)\n",
    "    else:\n",
    "        # value less than 1000\n",
    "        value = len(val)\n",
    "        if value <= 1:\n",
    "            del df[col]\n",
    "        elif 1 < value < 1000:\n",
    "            cat_col.add(col)\n",
    "        else:\n",
    "            num_col.add(col)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numeric Columns: Fill null values and Normalize data from 0-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for col in num_col:\n",
    "    df[col] = df[col].fillna(df[col].mean())\n",
    "    assert df[col].null_count == 0\n",
    "    std = df[col].std()\n",
    "    # drop near constant columns\n",
    "    if not np.isfinite(std) or std < 1e-4:\n",
    "        del df[col]\n",
    "        print('drop near constant', col)\n",
    "    else:\n",
    "        df[col] = df[col].scale()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Categorical columns: One-hot-encode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for col in cat_col:\n",
    "    df[col] = df[col].fillna(-99)\n",
    "    cats = (df[col].unique_k(501))[1:]  # drop first\n",
    "    df = df.one_hot_encoding(col, prefix=col, cats=cats, dtype=np.float32)\n",
    "    del df[col]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add intercept column and unity weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nrows = len(df)\n",
    "df['intercept'] = np.ones(nrows, dtype=np.float32)\n",
    "df['weights'] = np.ones(nrows, dtype=np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensure response column is not null"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df[response_col] = df[response_col].fillna(df[response_col].mean())\n",
    "for col in df.columns:\n",
    "    df[col] = df[col].astype(np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create 60-30 split: training - testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60% of 183141 is 109884\n",
      "df_train has 109885 rows | df_test has 109885 rows\n"
     ]
    }
   ],
   "source": [
    "FRACTION=0.6\n",
    "\n",
    "n = int(len(df) * FRACTION)\n",
    "print('60% of {} is {}'.format(len(df), n))\n",
    "df_train = df.loc[:n]\n",
    "\n",
    "df_test = df.loc[n:]\n",
    "if storage == 1:\n",
    "    df_src = df_src.loc[n:]\n",
    "        \n",
    "    print('df_train has {} rows | df_test has {} rows'.format(len(df_train), len(df_train)))\n",
    "else:\n",
    "    print('df_train has {} rows | df_test has {} rows'.format(len(df_train), 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make matrices from data frames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_data_mat = df_train.as_gpu_matrix(columns=df.columns[1:-1])\n",
    "train_result_mat = df_train.as_gpu_matrix(columns=[df.columns[0]])\n",
    "train_w_mat = df_train.as_gpu_matrix(columns=[df.columns[-1]])\n",
    "test_data_mat = df_test.as_gpu_matrix(columns=df.columns[1:-1])\n",
    "test_result_mat = df_test.as_gpu_matrix(columns=[df.columns[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(109885, 3053)\n",
      "(109885, 1)\n",
      "(109885, 1)\n",
      "(73257, 3053)\n",
      "(73257, 1)\n"
     ]
    }
   ],
   "source": [
    "print(train_data_mat.shape)\n",
    "print(train_result_mat.shape)\n",
    "print(train_w_mat.shape)\n",
    "print(test_data_mat.shape)\n",
    "print(test_result_mat.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make ctypes pointers to GPU matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_data_mat_ptr address 0x102cca00000\n",
      "train_result_mat_ptr address 0x102cc965c00\n",
      "test_data_mat_ptr address 0x1031ca00000\n",
      "test_result_mat_ptr address 0x10351f2bc00\n"
     ]
    }
   ],
   "source": [
    "train_data_mat_ptr = train_data_mat.device_ctypes_pointer\n",
    "train_result_mat_ptr = train_result_mat.device_ctypes_pointer\n",
    "print('train_data_mat_ptr address', hex(train_data_mat_ptr.value))\n",
    "print('train_result_mat_ptr address', hex(train_result_mat_ptr.value))\n",
    "\n",
    "test_data_mat_ptr = test_data_mat.device_ctypes_pointer\n",
    "test_result_mat_ptr = test_result_mat.device_ctypes_pointer\n",
    "print('test_data_mat_ptr address', hex(test_data_mat_ptr.value))\n",
    "print('test_result_mat_ptr address', hex(test_result_mat_ptr.value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### H2OGPUML: Model training and Prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load H2OGPUML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import h2o4gpu\n",
    "from ctypes import *\n",
    "import subprocess"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "xtrain = train_data_mat.device_ctypes_pointer\n",
    "ytrain = train_result_mat.device_ctypes_pointer\n",
    "xtest = test_data_mat.device_ctypes_pointer\n",
    "ytest = test_result_mat.device_ctypes_pointer\n",
    "wtrain = train_w_mat.device_ctypes_pointer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# params for features, train values, shape\n",
    "n = train_data_mat.shape[1]\n",
    "mTrain = train_data_mat.shape[0]\n",
    "mValid = test_data_mat.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Helper methods to display errors and running the algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_errors(display, enet, givefullpath):\n",
    "    err_best = enet.error_best\n",
    "    alphas_best = enet.alphas_best\n",
    "    lambdas_best = enet.lambdas_best\n",
    "    tols_best = enet.tols_best\n",
    "\n",
    "    if givefullpath == 1:\n",
    "        err_full = enet.error_full\n",
    "        alphas_full = enet.alphas_full\n",
    "        lambdas_full = enet.lambdas_full\n",
    "        tols_full = enet.tols_full\n",
    "\n",
    "    loss = 'RMSE'\n",
    "\n",
    "    if enet.family == 'logistic':\n",
    "        loss = \"LOGLOSS\"\n",
    "\n",
    "    if display == 1:\n",
    "        # Display most important metrics\n",
    "        if givefullpath == 1:\n",
    "            print('Alphas full path: {}'.format(alphas_full))\n",
    "            print('Lambdas full path: {}'.format(lambdas_best))\n",
    "            print('Tols full path: {}'.format(tols_full))\n",
    "            print('RMSE full path: {}'.format(err_full))\n",
    "\n",
    "        print('Alphas: {}'.format(alphas_best))\n",
    "        print('Lambdas: {}'.format(lambdas_best))\n",
    "        print('Tols: {}'.format(tols_best))\n",
    "        print('{}: {}'.format(loss, err_best))\n",
    "\n",
    "    return err_best"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def run_glm(nFolds, nAlphas, nLambdas, xtrain, ytrain, xtest, ytest, wtrain):\n",
    "\n",
    "   # params for features, train values, shape\n",
    "    n = train_data_mat.shape[1]\n",
    "    mTrain = train_data_mat.shape[0]\n",
    "    mValid = test_data_mat.shape[0]\n",
    "\n",
    "    maxNGPUS = int(subprocess.check_output(\"nvidia-smi -L | wc -l\", shell=True))\n",
    "    print(\"Maximum Number of GPUS:\", maxNGPUS)\n",
    "    nGPUs = maxNGPUS  # choose all GPUs\n",
    "\n",
    "    print(\"No. of Features=%d mTrain=%d mValid=%d\" % (n, mTrain, mValid))\n",
    "\n",
    "    # Order of data\n",
    "    fortran = 1\n",
    "    print(\"fortran=%d\" % (fortran))\n",
    "\n",
    "    sourceme = 0\n",
    "    sourceDev = 0\n",
    "    nThreads = None  # default value, algo handles it.\n",
    "    precision = 0    #0: Single precision; 1: Double Precision\n",
    "    # variables\n",
    "    a, b = c_void_p(xtrain.value), c_void_p(ytrain.value)\n",
    "    c, d = c_void_p(xtest.value), c_void_p(ytest.value)\n",
    "    e = c_void_p(wtrain.value)\n",
    "\n",
    "    #print(a, b, c, d, e)\n",
    "    \n",
    "    print(\"Setting up Solver\")\n",
    "\n",
    "    Solver = h2o4gpu.GLM\n",
    "    enet = Solver(n_threads=nThreads, n_gpus=nGPUs, order='c' if fortran else 'r', fit_intercept=fit_intercept, \\\n",
    "                  lambda_min_ratio=lambda_min_ratio, n_lambdas=nLambdas, n_folds=nFolds, n_alphas=nAlphas, \\\n",
    "                  family=family,verbose=5, store_full_path=givefullpath)\n",
    "    \n",
    "    #Family\n",
    "    print('Family: %s'%(enet.family))\n",
    "\n",
    "    print(\"Solving\")\n",
    "\n",
    "    enet.fit_ptr(mTrain, n, mValid, precision, None, a, b, c, d, e, source_dev=sourceDev)\n",
    "\n",
    "    print(\"Done Solving\\n\")\n",
    "\n",
    "    print('Predicting')\n",
    "    pred_val = enet.predict_ptr(c, d)\n",
    "\n",
    "    print('Done Predicting')\n",
    "    print('predicted values:\\n', pred_val)\n",
    "\n",
    "    loss = get_errors(display, enet, givefullpath)\n",
    "\n",
    "    return pred_val, loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Choose Parameters for building the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fit_intercept = True\n",
    "lambda_min_ratio = 1e-9\n",
    "nAlphas = 8\n",
    "nLambdas = 100\n",
    "nFolds = 5\n",
    "\n",
    "givefullpath = 0\n",
    "display = 1 # To print the errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum Number of GPUS: 1\n",
      "No. of Features=3053 mTrain=109885 mValid=73257\n",
      "fortran=1\n",
      "Setting up Solver\n",
      "Using GPU GLM solver with 1 GPUs\n",
      "Family: elasticnet\n",
      "Solving\n",
      "single precision fit\n",
      "Done Solving\n",
      "\n",
      "Predicting\n",
      "single precision fit\n",
      "thecount=586056 count_full_value=0 count_short_value=24472 n=3053 num_all_other=6 m_valid=73257\n",
      "Done Predicting\n",
      "predicted values:\n",
      " [[ 76.91146088  74.35827637  77.09158325 ...,  67.40345764  67.89889526\n",
      "   68.17915344]\n",
      " [ 76.94308472  74.11868286  77.0918045  ...,  67.39995575  67.8575058\n",
      "   68.14860535]\n",
      " [ 76.96173096  73.85163879  76.66847992 ...,  67.401474    67.70975494\n",
      "   68.01103973]\n",
      " ..., \n",
      " [ 77.25533295  73.37854004  75.06256104 ...,  67.37986755  67.87966156\n",
      "   68.2463913 ]\n",
      " [ 76.9280777   73.16997528  74.36225128 ...,  67.41166687  67.919487\n",
      "   68.33453369]\n",
      " [ 78.06202698  72.9460144   79.01708984 ...,  67.01580048  67.16179657\n",
      "   67.47941589]]\n",
      "Alphas: [[ 0.        ]\n",
      " [ 0.14285715]\n",
      " [ 0.2857143 ]\n",
      " [ 0.42857143]\n",
      " [ 0.5714286 ]\n",
      " [ 0.71428573]\n",
      " [ 0.85714287]\n",
      " [ 1.        ]]\n",
      "Lambdas: [[ 479.72692871]\n",
      " [ 460.89440918]\n",
      " [ 460.89440918]\n",
      " [ 479.72692871]\n",
      " [ 502.94448853]\n",
      " [ 591.42974854]\n",
      " [ 729.14221191]\n",
      " [ 148.55839539]]\n",
      "Tols: [[ 0.001]\n",
      " [ 0.001]\n",
      " [ 0.001]\n",
      " [ 0.001]\n",
      " [ 0.001]\n",
      " [ 0.001]\n",
      " [ 0.001]\n",
      " [ 0.001]]\n",
      "RMSE: [[ 3.14682651  3.04578876  3.25641823]\n",
      " [ 3.13043904  3.03060889  3.23493123]\n",
      " [ 3.17223048  3.07075119  3.26786971]\n",
      " [ 3.21457958  3.12087703  3.30278063]\n",
      " [ 3.24773598  3.15929723  3.3297801 ]\n",
      " [ 3.32383013  3.25064373  3.39727592]\n",
      " [ 3.42914653  3.37600517  3.49444366]\n",
      " [ 3.09665656  2.98604131  3.23324823]]\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "#st_h2o = time.time()\n",
    "pred_val, loss = run_glm(nFolds, nAlphas, nLambdas, xtrain, ytrain, xtest, ytest, wtrain)\n",
    "#en_h2o = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Storage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Helper methods to store Predictions in MapD DB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_index(loss):\n",
    "    first = True\n",
    "    prev_val = None\n",
    "\n",
    "    for i in range(len(loss)):\n",
    "        curr_val = loss[i][2]\n",
    "        if first:\n",
    "            prev_val = curr_val\n",
    "            ind = i\n",
    "            first = False\n",
    "        elif curr_val - prev_val < 0:\n",
    "            prev_val = curr_val\n",
    "            ind = i\n",
    "    return ind\n",
    "\n",
    "def insert_results(pred_val, n_table, n_predcol, loss):\n",
    "    ind = get_index(loss)\n",
    "    \n",
    "    # predicted values from dataframe to list\n",
    "    df_pred = pd.DataFrame(pred_val[ind][np.newaxis][0].T)\n",
    "    df_src_test = df_src.to_pandas()\n",
    "    df_src_test.reset_index(inplace=True,drop=True)\n",
    "    df_src_test[n_predcol] = df_pred\n",
    "    \n",
    "    query_pred_drop = 'DROP TABLE IF EXISTS {};'.format(n_table)\n",
    "    query_pred_create = 'CREATE TABLE {}({} BIGINT NOT NULL, {} INT);'.format(n_table, key_col, n_predcol)\n",
    "    \n",
    "    # initialize a cursor to mapd\n",
    "    cur = con.cursor()\n",
    "\n",
    "    cur.execute(query_pred_drop)\n",
    "    cur.execute(query_pred_create)\n",
    "    \n",
    "    cur.close()\n",
    "    \n",
    "    con.load_table('prediction_table',df_src_test.itertuples(index=False))\n",
    "\n",
    "    print(\"Predicted values inserted in MapD\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert records in MapD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted values inserted in MapD\n",
      "\n",
      "Join Query is: SELECT a.overall_rating,b.overall_rating_Pred FROM Player_Attributes a, prediction_table b WHERE a.rowid = b.map_id\n",
      "\n",
      "   overall_rating  overall_rating_Pred\n",
      "0              66                   65\n",
      "1              66                   66\n",
      "2              66                   66\n",
      "3              66                   66\n",
      "4              67                   65\n",
      "5              58                   61\n",
      "6              58                   61\n",
      "7              58                   61\n",
      "8              71                   69\n",
      "9              71                   69\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEKCAYAAAAIO8L1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsnXtcVGX+x9/PDHcQRFG8ErRpFpZauCYqiZptmlhba9u2\nW+3WVuS2bV66LvozsoumbW1JtdVWu+VmbSWa7ZqJoWKulFaSly4iooliIHKHmef3x+E8zAwDDDBc\nxOfta17DOXMuz1w83/N8L5+vkFKi0Wg0Go0rls4egEaj0Wi6JtpAaDQajcYt2kBoNBqNxi3aQGg0\nGo3GLdpAaDQajcYt2kBoNBqNxi3aQGg0Go3GLdpAaDQajcYt2kBoNBqNxi0+nT2AthARESGjo6M7\nexgajUZzWvHZZ58VSin7NLfdaW0goqOjyc7O7uxhaDQazWmFEOKgJ9tpF5NGo9Fo3KINhEaj0Wjc\nog2ERqPRaNyiDYRGo9Fo3KINhEaj0Wjc0m4GQgjxihDimBBit8O6XkKIj4QQ39Q9h9etF0KIZ4QQ\n3wohvhRCXNRe49JoNBqNZ7TnDOJV4Gcu6+4HPpZSDgE+rlsGuAIYUve4DUhrx3FpNBqNxgPazUBI\nKTOBH11WzwReq/v7NeAqh/WvS4NPgZ5CiP7tNTaNRqM5XSkvh/vug4MeVTK0jY6OQURKKX+o+/so\nEFn390DgkMN2+XXrGiCEuE0IkS2EyD5+/Hj7jVSj0Wi6GBkZcMEFsGQJrFvX/ufrtCC1lFICshX7\nvSiljJNSxvXp02yluEaj0Zz2nDwJt90GkyaBxQKbNkFycvuft6MNRIHpOqp7Pla3/jAw2GG7QXXr\nNBqN5owmPR3OPx9efhnuvRe+/BIuvbRjzt3RBiIduKnu75uA1Q7rb6zLZroEOOngitJoNJozjmPH\n4Je/hJkzoXdv2L4dnngCAgM7bgztmea6EtgGnCuEyBdC3AI8DlwmhPgGmFK3DLAO+B74FvgbcGd7\njUuj0Wi6MlLCG28Ys4b33oPUVMjOhri4jh9Lu6m5Simvb+SlyW62lcDs9hqLRqPRnA4cOmTEFj74\nAC65xHArnX9+541HV1JrNBpNJ2O3w/PPQ2yskan0l7/Ali2daxzgNO8HodFoNKc733wDt94KmZkw\nZQq8+CLExHT2qAz0DEKj0Wg6gdpao57hwgvhiy8Md9L69V3HOICeQWg0Gk2H88UXcMst8NlncNVV\n8NxzMGBAZ4+qIXoGodFoNB1EVRWkpBgZSYcOwapV8O67XdM4gJ5BaDQaTYewbZsxa9izB268EZYv\nN+obujJ6BqHRaDTtSFkZ/OlPMG6c8feHH8Jrr3V94wB6BqHRaDTtxoYN8PvfQ24uzJ4Njz0GPXp0\n9qg8R88gNBqNxssUFRnupMsuAz8/I4X12WdPL+MA2kBoNBqNV3nvPaPA7bXX4P77jYylCRM6e1St\nQ7uYNBqNxgsUFMBdd8Hbb8PIkYZcxkWnefNkPYPQaDSaNiAlvP46nHcerF4NixfD//53+hsH0DMI\njUajaTV5eXD77fCf/0B8vFENPWxYZ4/Ke+gZhEaj0bQQu92ofo6Nhc2b4a9/NZ67k3EAbSA0Gs1p\nypKtS8g4kOG0LuNABku2LmnX8+7bZ3R0+8MfjFnD7t3G35ZueDXthm9Jo9GcCYweMJpZ78xSRiLj\nQAaz3pnF6AGj2+V8NTXw+OMwYgTk5MCrrxqupejodjldl0DHIDQazWlJYkwiq65dxax3ZpEcl0xa\ndhqrrl1FYkyi18+1c6dR17BzJ1xzjVHT0K+f10/T5dAzCI1G0+m0xl007NlhvP312yTHJZOamUpy\nXDJvf/02w571XiCgshIeeghGj4YjR+Cdd4zHmWAcQM8gNBpNF8B0F5kzANNdtOraVY3uMylmEmnZ\nafhb/UlJSGHJ1iVU2apIjkv2ypi2bjVmDfv2wW9/C08+Cb16eeXQpw2dMoMQQtwthNgthMgRQvyp\nbl0vIcRHQohv6p7DO2NsGo2m43F0Fy3IWOBkLBrj+eznAaiyVfHqrlepslU5rW8tp04ZBW8TJhgz\niP/+F1555cwzDtAJBkIIMRz4PfBTYARwpRDiHOB+4GMp5RDg47pljUZzhpAYk+jkLmoulhDkGwSA\nQHCo5BAC4bS+Nfz3vzB8uJHCetddRobS1KmtPtxpT2fMIM4Dtkspy6WUtcAnwM+BmcBrddu8BlzV\nCWPTaDSdRMaBDNKy00hJSCEtO61BTMKV0gdLCbAGIJEASCQB1gBKHyxt8bl//BFuvhl+9jMICjJq\nGp5+GkJCWvNOug+dYSB2AxOEEL2FEEHANGAwECml/KFum6NApLudhRC3CSGyhRDZx48f75gRazSa\ndsUx5vBw4sPK3dSUkRCLBJW2Sqd1lbZKxCLRonP/+9+GuN4//2kEpHfuNHo3aDrBQEgp9wBPAOuB\n/wC7AJvLNhLqbgsa7v+ilDJOShnXp0+f9h6uRqPpAHYc2eEUczBjEjuO7Gh0H0sjl6/G1rvyww9G\nyuq118LAgZCdDY88AgEBLR9/d6VTspiklC8DLwMIIR4F8oECIUR/KeUPQoj+wLHOGJtGo+l47h13\nb4N1iTGJTcYh+gT1oaC8wO36ppDSkOK+5x6oqDCK3+bOBR+d09mAzspi6lv3HIURf3gTSAduqtvk\nJmB1Z4xNo9F0PtPemMbybcvV8pKtS7jzgzuZ9sY0ta6gvACLcL6E+Vp83RoNk9xcuPxyI231ggvg\nyy/hvvu0cWiMziqU+7cQ4mtgDTBbSlkMPA5cJoT4BphSt6zRaM5Appw9hXnr5ykjkVucS1p2GtE9\nowEjZuFn9cMu7U771dhrSBqa1OB4Nhs884yRobRtm5GltGkTDB3a3u/k9KazXEwN+itJKU8Akzth\nOBqNposxZ+wcAOatn8f7e99nS94WVSkdERRBWnYawT7BVNuqAQj1C6WkugSA7fnbnY61Zw/ceitk\nZRlZSi+8AFFRHft+Tle01IZGo/EqrZHN8Ev1Y/hzw9Wy9WEr935kxCU2521GInnxsxc5UX5C1UkU\nVRUB9cYh1C+UyKBIjpUb4cuaGqN5z8iRsHev0dRn3TptHFqCNhAajcartEZldWivoeQU5igjIRDY\npA2JZEKU4XAwl1MSUli8eTEAIb4hyjiUVJcwZtAY7AvtfPaZoZ/05z/DVVfB11/Db34DomUZsGc8\nwsgoPT2Ji4uT2dnZnT0MjUbjgmkUWqKyOvy54eQU5mDBgh17o9u5vp40NInV169m5sqZpOes55wv\n/8mBddfQty+sWGEYCI0zQojPpJRxzW6nDYRGo2kPFmQsIDUzFV+LL6MHjGbrLVsBCH40WF3kyx4s\nA1DFbU0ZB8fXLFiQ5r+FxjUsMxOmXXeYsqMDueUWQ1yvZ8/2fpenJ54aCO1i0mg0XsdRNsMu7WTl\nZzHuZaM82YKF0ppSVdBmrgewY2+00M3RONixI5HERsRSUgKzZxtd3voGDmTDBnjpJW0cvIHO/tVo\nNF7FUTYjMSaRxOhELvvHZWTlZ+Gf6k+1vZoQ3xBKa0rVcoA1QMlmuM4g/Cx+VNur3Z7rVM54hg+H\n/Hz405+MSujg4HZ/i2cMzc4ghBCnhBAlLo9DQoj3hBBnd8QgNRpN18S1oA1g8uuTKa0qVTGHSa9P\nwiYNNR3zQl9eU66W/Sx+DTSVHHE1DnbsiPIIePc18tKep0cPI4X1qafgV+kz6bNUS/B4C09cTH8B\n5gMDgUHAPIzK538Br7Tf0DQaTVfHtaBt+bblSCSVtkqntFUTP4sfUD9LaGp24LoPABLE7uuQz+bA\n7uvh0kXE3HcNl1yCEaTen078oHgvvTtNs0FqIcQXUsoRLut2SSlHunutI9FBao2mY1mydQmjB4xW\ns4MlW5ewNW8r6fvTmRA1gS15W5T8NjQddAYYHDqYQyWHPDt5SX/4YAXsuwoG7ICkW6DfV0B9LYRA\nqMC161jBcH/tOLLDrfbTmYQ3g9TlQohZQghL3WMWYM4HT98UKI1G02Jcaxx8LD6s2b+GmJ4xbM7b\nzPC+zrOGpowD4JlxkMDnv4PnvobvLofL5sEtY5VxAFQVtdkTwt1YPanH0DjjyQzibOBpYCzGV/Up\ncA9wGLhYSrmlvQfZGHoGodF0PK41DvGD4knfn65mA+Z6r/BjDKz5GxyYDGdtgqRbofd36mVzxuC4\nbF9Yb5RaU49xJqDrIDQaTYuY9sY0ppw9RekggRFT2PD9BtbdsA4wJDCiekTxm5G/ITUztcExLjv7\nMj76/qO2D8Zuge13wcbFIGwwdT5c9DewNH+9smDBttDGsGeH4SN8OFp2lBMVJ0hJSKGwvJCNBzay\n9w972z7G0xhPDUSzaa5CiD4YPaSjHbeXUv6uLQPUaDRdCzPgDIZY3vJty5m3fh5PTn1SbRPVI4rc\nklweyXyElIQUJyPhutxqjp0Pq1+Gw5fAkLVw5R0Qdtjj3c0ZhY/wUZXZKQkpLN26lEpbJclxyW0f\n4xmCJy6mLGAz8BkOnd+klP9u36E1j55BaDTexTQK46PGsyVvC09OfdJpRpFxIIPJr092cut4jVpf\n2HI/ZP4Z/Evgij/CBSvBA/0k12wo091lBsnN5QBrAOtuWHfGu5m85mIyM5a8NjIvog2ERuM9zKyf\nhZsWsjlvMxOiJvC/w/8jMjiSg/ccBGhxv2ePORxnzBqOXQjD34Qr7obgQo92bSpVNsQ3hMraSmpl\nLYNDB2PFSt6pPGwLbG63P1PwZhbTWiHEtOY302g0pzOjB4zmypVXsiVvi0pZrbZVk1eS5ySH4VWq\nA2H9EnjpU6joBdfPgGtv8Ng4QH2xnSODQwcDUFpTqozDoZJD5Jbkcl7v87z6FroznhiIuzGMREVd\nFfUpIURJew9Mo9F0LDuP7qSipoJA30AmRk8k0DcQgOjQaCWT4VUOXArPfwFZ8+Gil2B2LJy7tlWH\naq7Y7nBJfQwjITqhVec4E2nWQEgpe0gpLVLKQCllaN1yaEcMTqPRdBwvfvYid8Tdwdyxc0nNTGXu\n2LlIJLkluR5VPHtMZSisSYPXNoEUcFMizLgDArx333mo5BACQWRQJFAvApg0NIm3v37ba+fp7jSa\nxSSEGCal3CuEuMjd61LKz9tvWBqNpqNJm57G1W9drZryPL39afWa6cZps5HYNx3WPg+l/WHsk5C4\nAPwq2jjyhpgupYLyAqC+onvt/rVsuHGD18/XXWlqBmGmLixz83iysZ08QQhxjxAiRwixWwixUggR\nIISIEUJsF0J8K4R4Swjh1/yRNBqNN5FIRF3akEBgEfWXiDYZh7IIeOcNWLkWAouMSujL57eLcQC4\neeTNTssPJTykjMRd6+5ql3N2RzzJYgqQUlY2t87jEwoxENgCnC+lrBBCrALWAdOAd6WU/xJCPA98\nIaVsshxTZzFpNK3HL9WPob2Gsnv2bsChaY+wYJd279Q1SGD3L+HDZ6AyDBIegfGPg09NG0ffPAKB\nj8VwktTYa0hJSOHRzY9il3ZVbW1qSe07sU8Vz50Jek3ezGLK8nBdS/ABAoUQPkAQ8AMwCXin7vXX\nAN0oUKNpR1z7QJt4zTicHAgr0+HfKyH8e7j9IpiY2iHGISUhBX+rPzX2GqzCqlxmVosVieTOD+4E\nUEKD5/Y+F9B6Ta40FYPohyHxHSiEGEV9uUooxkW9VUgpDwshngTygApgPUYRXrGUsrZus/y6c2s0\nmnZi9+zdqg+0dZHV6bU2GQe7gM9vhY+Wgs0XLr8HxjwDlqaF+7zJptxNqseE1WK8N4EgwCeAn/3k\nZ6Rlp7F2/1oOlRwiaWgSWflZLMhYoPWaXGhKauNy4GaMHhCOHUFOAQ+29oRCiHBgJhADFANvAz9r\nwf63AbcBREVFtXYYGs0Zh2WRhb5BfTk6/yjgXPTWnOqqx5z4iSGul5sI0Rsh6ffQ63vvHLsFbM7b\nTKBPIGf3PJsfyn4gNTOVlIQUntn+DJkHM1UQe3DoYAaGDsQu7WobbRzqadTFJKV8TUqZCNwspUx0\neCRJKd9twzmnAAeklMellDXAu8A4oGedywkMo+RWfEVK+aKUMk5KGdenj+4cpdF4St+gvhSUF9Bv\nab8GrzXWB9pjbFbImgNpX8IPF8GMW+GmyZ1iHAAmRE2goraCnMIcTlWdIiUhheXblnOy6iTFVcXK\nOBwqOURadhrl1eWkJKSQlp2m5ME1ntVB/FsIMV0Ica8QYoH5aMM584BLhBBBQggBTAa+BjKAa+u2\nuQlY3YZzaDSnLUu2Lmlwkco4kMGSrUs83kcsEohFwmkfM+WzoLyggWRGm2YQBcPh5SxYvwx+8hHM\nPh8uftkjDaWOoMZew6bcTarNqTtiwmN4OPFhVl27ihkrZzDmb2M6cIRdF096Uj8PXAfchfGV/wI4\nq7UnlFJuxwhGfw58VTeGF4H7gDlCiG+B3sDLrT2HRnM605pGN677mNy34T6gnTSUav0g4//ghc+h\nOBquvQ5+eRWEHvH+uVrI5rzN+NQ5JASCzXmbCfENUa/3CerDoZJD+Fp8AThyyhjzzqM7Kaspo0+w\n9k6AZ2muX0opL3R4DgE+lFJO6JghNo5Oc9V0V1rT6MZ1n8Jyz/WMWkz+Tw1xvePD4cJ/GIHo4BPt\nd74WYrqPQnxDKK0pVeujQ6O5sN+FpO9PV21KYyNi+brw60YVbLsjXusHgZFpBEbr0QHACaB/Wwan\n0WiaJjEmkeS45EYDp8OeHcakmEmsmL5CLfsIH6SU3unJ0BjVQbAxFT79E4Qehl9Nh6Hr2u98reRQ\nySEiAiMorKg3klZhJbckl9ySXC7ufzGf/fCZeu4X3E8p2HZ349ASPFVz7QksxXAL5QIr23NQGs2Z\nTsaBDNKy0xoNnE6KmURadprK5zeb4xRVFJGSkNI+g/o+0QhCfzoH4p6HO2O7pHEAow7C0Tj4Wfyw\nSUPiu6d/Tw6ePEhKQgoHTx4kNiKWo2VHlYLt8m3LGzvsGUezMwgppXk78m8hxFogQEp5sn2HpdGc\nuZiuItOtlBid6LQMqJmDYz6/KSXx6q5XvTugijCjpuHz30Ov/XDzpRCd6d1zeJnFmYvV3xYs3Df+\nPh7d/Cg2aeNU9Sk++s1HJMYkUlheSFp2GslxyayYvkI1TAL0TALPZhAKKWUV8FMhhBeazmo0XYfW\nZA6117l3HNnBA+MfYMeRHYDhblp17Sq1DIZMRmZufT4/1GcimcteYW8SPPc17PwdjHsCkkd0eeMA\nzllZdowahwcnPGj0q5Y2ZWhzi3NJGppEbnEuYBiFaUOm8dbut5yO11G/ha5GowZCCDFJCLFfCFEq\nhPinEOICIUQ28DjQpEaSRnO60ZrMofY69+gBo3lsy2NO506MSXTSBjJlMsx8fkdcl1tFaR94eyX8\nazUEH4dbx8Bl94NvqyTYOhzXuo6UhBQe2/IYduz4WHzUZz0/fj5Z+VnMj5+vtp07di7fF3/fKb+F\nrkajWUxCiJ3APcA24Argn8D9UspnO254TaOzmDTepDWZQ5117js/uJO0bOM+zXQteQUJfHkD/Odp\nqA6BhFQY/wRYa5vdtStjSpX7WHx4YsoTPLblsSY/6878LXQE3hDrk1LKTVLKKinl+8DhrmQcNBpv\n45g5lByX3KEXBMdzh/mHsfPoTvWaX6of/Zb2Y9ob9Z1/28U4nBwEb66F9/4JvffD7aPg0sWnvXGA\n+n4WA3sM5MGPH3T6noEG7qPO/C10JZoyED2FED83H4CPy7JG061oLnOoo859tPQoc9fPVdk0vQJ6\nUVBewOdHjB5djuqrZqe0NmEXsOMOeC4HcifCz+6G342HvnvadtwuhDmDOHjyIDZp4+ntTyuF16vf\nurqB+6gzfwtdiaaymD4BZjgsZzosSwwNJY2mW+BJ5lBHnnvGyhnMXT+X9/e+z7HyY0QGRVJQXoB1\nkRU7dnwtvtTYDdnsNs0gCodA+kuQlwBnfwQzboPwXO+8sS5EgE8A1dVGwyO7tDs1RZI4u9k787fQ\n1Wi2kroro2MQGm+xZOsSRg8Y7XQBaK5xTPCjwYyMHMnWW7aqdeNeHseugl2UPVjm8XGnvTGNKWdP\nUWmVw54dRu/A3uwp3ENRZVGD83rFrWSzwrY5sGkR+FTC5XNg5KtdRj+pPQj1C6W0uhQ79f0uUhJS\nKCwvZOOBjaphUGt+C6cbnsYgtIHQaFrJuJfHkZWfRfygeLbesrXBMjS8G3VddrfNzJUzSd+fDhiq\npJvzNqtzesU4HL0QVr8CP1wMw96F6bOhx9G2HbOLY8pqmAT7BjNn7ByWb1tOWU0Zy6YuO6PqHrzZ\nUU6j0bghLCCM6NBosvKz8E/1Jys/i+jQaMICwtQ2Zg3DrHdmsSBjAVP+MYX4QfFOd6dXvHEFpdWl\nahvTOAAqP9+kTcah1g82PgwvZkPJIPjFtXDdNd3COIT6hTb5uuN3AlBWU8am3E2U1ZQhEDz4cX2L\nG9eah+BHgxn38ji1vGTrEoY/N5zgR4Mb3ae7oA2ERtNKppw9hYMlB7EKK9X2aqzCysGSg0w5e4rT\ndo4ZMaP6jSJ9f7qSyLjzgzupslVRWVtJr4BeDXSUvFb0ljcWnt8JmSlwwZuGJHfsv7uFS8nX4us0\nO3DHoZJDBPvWX9B7+PYwmgpZA5FIegb0BNzXPIyMHElWfpYyEq/vep2cwhxiwmIa3ae70FQdRJOZ\nSm1sGuQVtItJ09nEPBVDbkmuWo4OjebAPQectnHNqY8fFE/6/nRVBZ0cl8wXR78gKz9LZdt4japg\n2LgYtt8FYYfgytthyH+9d3wvYRVWpZXUEqJDo50+/8YwXXOxEbGUVZc57RMZFIkNW5M1D6b70Px+\nYiNiKSgvOG3rJNocgxBC/L2J/aSU8netHZy30AZC05mYFw1TUtp8doxB+D7si13a2XDjBhJjEgl8\nJFD1SgacpDKCfIIor228qU2L+W4KrHkRimPgp3+FyQ+Cf2nz+3UwbY2rBFgDnD7TxnCU/rZixUa9\nQeod2JsTFSdISUjh7Zy3AdjzByPNVywSBFgDqLJVIZEIBP5Wf3XOlIQUegb0ZMP3G1h3Q9cUL3Sl\nzTEIKeVvm3h0unHQaDqbXQW7iA6NpqymjAlREyirKSM6NJpdBbvUNr0Ce2HHzl3r7mqwv6NxACiv\nLW/Wl+4RFT3h/ZfhHx+BtQp+Ox6m/bFLGAc/i5/TckpCCr2CerXpmJW2ymblRQaHDnbqC2HD5jSW\nHyt+VG1J957Yy94Te1UdimmAJBI/ix8S6WQclm1bxrz18xq4FrsDTWkxzWnq0ZGD1Gi6IqmJqRws\nOciTU58k87eZPDn1SQ6WHCQ1sT6OUDC/gNiIWHIKc7Ausjrd6RaUFjQ4ZnO+9GbZc5UhrvfFjTD+\nUbhjJJy1tfn9Oogxg+pbecZGxKo2n464GpEJUU33JvO3+nPzyJub3MZdLMdxLBKpgtbBvsEkxyUz\nb/08Ev6e4PSdubr/NuVuoqKmgkDfQEb1G9XkGE5HmgpS92jmodF0G/os7cPMlTOd1s1cOZM+Sxtv\nPbnh+w1O3cfu33A/fYP6suH7DWobsUiQU5jj1o1iyj94hVORsGoVvPUehByF3/8UpjwEvlXeOb6X\n2Jy3mfCAcCKDItn/434AJ9+9uxiMY5qvO+4dd2+LmyS5pg+b55kQNQGb3UZadhrjo8azOW8zFizE\nRsQ6bRsbEYtFWNict5nxUeNZe/1aJ7Xd7kKjldRSykUdORCNpjMxA8czV85k9fWrVS1C0tCkRvdx\n9TebCqt5xXmAe0kMRyPhlYC0xJgt/OcpqAmCyQ9A/JNdVj/J8cK8bOoywAjiB/sGU1ZTpoym4+fi\n7mLuiFnw1hIjYRoDx+O6Lm/J26KaCOUU5jjt/13Rd0gp1es7j+7sNkV0jjSb5iqECBBCzBZCrBBC\nvGI+WntCIcS5QohdDo8SIcSfhBC9hBAfCSG+qXsOb+05NJqWsvr61SQNTSJ9fzphj4Up47D6+tUe\nH2P37N1O7qScwhx8Lb7qdXcziDZRHAX//BDefw36fG24kyY83mHGwbVznbvZkGtMZWL0RJVuuiBj\nAQsyFjDrnVlEh0WrbRxdP9BwBuEuTtOccXC3j2uNiet5An0DmRg9UUlxBFgDkAulikn4W/2Va3He\n+nndshOdJ3UQ/wD6AZdj6DMNAk619oRSyn1SypFSypHAxUA58B5wP/CxlHII8HHdskbTYay+frWq\nuBUIBoYOdHp97EtjiVoepZaXbF3C8m3LVYGUX6ofZdVG4ZU5YzD1kryKXcD22Ya4Xt54uOIP8NsE\n6LPP++dqAteLsqvLzPwsrcKqDGVqZir9QvqRNDSJ/iH9lVrqnhN7CPYNbna2AEacpqXBfHMfU4PJ\nTBAIsAYQPyjeadtg32D6BPVh7ti56j1asBDiHwIYLjFfi6+KTcwZO4cnpz7p5FrsLnhiIM6RUqYA\nZVLK14DpwJhm9vGUycB3UsqDwEzgtbr1rwFXeekcGo1HzFw5U11IJNKp5/OdH9zJp4c/5Vj5MaXs\n6WPxYd76efhYDE/twJCB5JbkIpHeleF2pHAo/D0TPnwWorbA7FgY8xxYOlYyJ8AaQEpCilPxmeka\nsgor8YPi1WdpkzZGDxhNRFCEUqtN35/OD6U/qMwhu7RTbatWbp2mcJXN8ARzH4nEKqyq0VKlrZKs\n/CynbQWCwvJClm1bRkpCCv5Wf+zY+cX5vwCMJkNhAWFsvHGj2mfO2DmnTYprS/DEQJi3QMVCiOFA\nGNDXS+f/JbCy7u9IKeUPdX8fBSK9dA6NplkcYw4nHzipYg9p2WlEPRWl+hZ/eMOHShLjsS2P8eTU\nJ3lsy2MsyFhA3qm89hugzQc23w9pX8Dx8+Gqm+DXV0DP9jmnOwlxxwu3efdcWVuptr9v/H2q4C0r\nP0t9lvGD4snKz2Jor6E8nPgwDyc+DNTLXZTXlCt1WtOt0xTujIOrUXFdHtFvhPrbJm0NMp9M91Fk\nUCSlNaVIJBU1FWzK3US1rRp/qz9vfvWmcomdboVxraVZsT4hxK3Av4ELgFeBECBFSvlCm04shB9w\nBIiVUhZJ6lGXAAAgAElEQVQIIYqllD0dXi+SUjaIQwghbgNuA4iKirr44MGDbRmGRgMYWUzxg+Kd\nYg4zV85k7f612LEzOHQwh08dJqpHFL8Z+Rsn94o7yWjwYjOfH0Ya4npHR8H5b8MVd0GPhimy3sZx\n/KbrJzwgvIHCbIhvCP1C+vFt0bdOwWK50PhMhj07jOKKYk7VnKLswTKmvTGNk5Un2Xl0JxW1FUyI\nmsDWvK0E+QZxz9h7vJKRBGARFpA4vYcdh3dQa6/lgQkPOLmPhvQeotRcLYssSKQ6bnTPaK445wo+\n+u4j9R4ToxOd1F2HPTuMSTGTWDF9hTr/nR/c6aQS25XwilifEMIClEgpi6SUmVLKs6WUfdtqHOq4\nAvhcSmn+0guEEP3rztsfOOZuJynli1LKOCllXJ8+jacgajQt4fj84w0C0gNDByrjcKjkEEE+QeSW\n5PJI5iNOAVqJbBCw9YpxqPGHDY/CizvgVH+Y9XOYNavDjQPUZ/2YxsF0MflafCmtKeXgyYOkJKSw\ndOtS43WfAOWKmxQziYLyAm4acRMA0T0NgUPTOGzO24wQgtKaUh7f8niDz7I5zLE5MiFqAnZpdzIO\nW/K2YLFYeOKyJ1QzINN9NClmEmBc1E03lOnuyi3OJS07jSOlRxptMjQpZlIDl2Radpo67ulKkwZC\nSmkH2it363rq3UsA6cBNdX/fBHiePqLReBnzP3hyXDJ59+SRHJesKnElssFdrutym43DwXHw/Bew\n5QEY8Tr84Tw4/722HbMFuAboXTFnTL5WI/hcY6/h1V2vUmmrJMAawOJJi5Ur7u2v3yY5Lpnns58n\n4e8Jql1qsG+wymqySZsK6j/96dNNnru5ALWf1Y+J0RNVYNzX4svE6IkE+gZSXlNOSkYKq65dxcOJ\nD/PhDR/ib/V3ciXGD4rHLu0E+QYxMXoiAdYAwGg0BO5njCumr1C6TI4uSccZxemIJy6mx4FC4C2g\nzFwvpfyx1ScVIhjIA86WUp6sW9cbWAVEAQeBWc2dQ2sxadoLsUgQ7h/Oj/f/6LSu3akKgQ2PwY4/\nQM8DRoe3n3ROdoyjFIijG8cqrFiE+wwtx30c3U1NzahSElJYnLkYO3aPA9CO2zm6vyZETSDneA7f\nFX3HOeHncH6f89VySkIKO3/YybGyY2z//XZ1rIwDGVz91tWcrDrJ4NDBDO87nClnT6G4spjUzFQm\nx0xmaO+hrP9uPd8VfYcFC1GhUST/NFm5mMzfhvn+B4cOxoqVvFN52Ba0XISwvfFmP4jrgNkYLUc/\nq3u06aospSyTUvY2jUPduhNSyslSyiFSyiltMUAaTVuJjYilqKpIFbs5Fr21G99OhRW7YcedMOZp\nSL6gSxgHcHbj2KSNGntNA1eQ6z6LNy9W2zi6ehxJSUhh8ebF6vWmUljNO3nTOCQNTWLZ1GXKFVRc\nWczA0IGcrDpJSkIKxVXFXBp9qVpOy05jztg5TsYB4O2v31bG4VDJIaJ7RjOq3yjlhvqi4AvO6XWO\nOo4QgtySXF7f9Trg/NswjcOhkkPkluQS1SOK0xndUU7T7XHXQvL2NbcD8MIMI5w27Y1pRPeMJrpn\nNPeOuxfrw1aklI2mrHo1jbU8HP77FHxxE0TsgaRbIGqbd47tIZ7UH7gaAE9ozefkOha5UKrAsbns\n2HXP7AYX/ng4xVXFXDLwErbduo0Zb85g7Tdr6RPUh2Pzj6mZwnWx16nvPeqpKCW5vmL6CuVaBNh4\n40YSYxJZvm0589bPY/qQ6az51RoyDmRw2T8uU24xO3Z8hA+1smGBYlRoFAfv6XqJNF6bQQghgoQQ\nfxZCvFi3PEQIcaU3BqnRdASjB4xm1juzVNA040AGb+W8xb9y/qXWRfeMJi07TVXXhvmFqQuSuwuc\nV4yDBHKugef2wFe/ggmPwO2jOtw4QPN6R9C65kWt+ZzcjcXV539p9KXqb1Mkr3+P/oAhgwHwbdG3\nAPQO6t3occw03XN6neP07Mi+wn0E+gYyoMcAwCiU++g3HzkVRIYHuhd+qKitaOxtnhY0qsXkwN8x\n3EpmueFh4G1gbXsNSqPxJo5tP81A4nvXGQFfc51jIHX3sd0UVxU3CEa2tqmNW071gw+eg70/h/6f\nwa8vh/5feOfY3QzH2I9AkPD3BLbkbWHZ1GWM6jdKfYfHy48ruRRzZpA0NIms/CwWZCwgLTuN9697\n32kmeWz+MTVDeH/v+26P++7ed1l7/Vqn/e5ad5fT7LJvUF9qbbUUVdWnAIf7h3NsvttkzNMGT4LU\n2VLKOCHETinlqLp1X0gpRzS5YwegXUzdD1d3kKvrB2D5tuVNNmdxPcaSrUvwsfiw7pt1fHzgY1IS\nUnhs82P0CuzF7XG3tzjvvk1IYNfN8N/lUBsAExfC2OVg7XqBzK6Go8GeEDWBY2XHmBQziYigCFIz\nU/lJ+E+IDI7kf4f/R62sZXDoYP50yZ9YsWOFClKbRXquJPw9QcVZMn+bCRhaUaYQoON+w58bTk5h\nDrERseyevVstA/hb/KmyV6lndx0GuwLeDFJXCyECMX7aCCF+AnQtDWFNt8HVHeTq+jHv9ppqzuJ6\nDB+LD3PXz+XT/E9JSUjhme3PYJM2jpUfY3Hm4gbB1uakHlpNUTT8Yz2s/jv0/QruGAHjl2rj4CGO\nxmFL3hZ6B/YmLTuNpVlLSUlI4eDJg2TlZynjcKjkEHPXz+Vo6VEVpDZ/E44s37bcSbl1+bblZBzI\nUEFq1/32/7hfGQdAPYOhRzUhagLV9mrC/cPbt7q+A/DEQPwf8B9gsBDiDQwhve6na6vpEji6g9zl\n0M9bP8+pB4Mnx1j0ySKCfYOxWqyAcaEJ8g1SPuTFmYud9vfEH98i7Bb49C4jQyn/EpieDDdPhIhv\nvHueMwRTQTUrPwsfiw+VtZW8uutVau31QeLontHq78kxk1VjIscbB6i/4XBs+jRv/TyuXHmlqpVw\n3a86pdrJKIARKBcIp+MUVxWz9LKl7fthtDMeZTHV1ShcAgjgUyllYXsPzBPOdBdTR5b3Bz8azMjI\nkarX8rQ3prHn2B6OVRyj7EGjPKY5148r7uQt+i7tS3lNOXPGzlFug9g+sWzO26yqeEN8Q5hw1gR1\nHtNHbUo7mMsWYVHFTY54mp/vFY4Pg9UvQ348nLMOrrwDerY82Kupx/yex740lsOnDgNGAN1H+DBt\nyDS+PPYlucW5RPeM5sK+F7LvxD71/yHjQIaTRMa0N6Yx5ewpTjccM96c4bZWwnE/V9wdp6X/HzoS\nb2YxrQGmApuklGu7inHQdGx5/8jIkWTlZzHu5XEA7Dm2h9ySXPoGGrqNnrh+XHFs0gOG9tHx8uOU\n1ZQpJc28k3mk70+nqLJIuX5Ka0rZfNC4y++3tJ86nmutgl3aG7iPUhJSeCTzkfpt6rJQvI7NBz55\nCJ7fBSfOhat/DTdM18ahjUSHRgPGBfvbom8Z1W+Uqj2olbUUlhdysPggE6ImcLD4IJdGX+p0s5QY\nk+h0kV93w7oGs9E1v1rToFbCdT9X3B2nOyi8ehKkvhSjWG46sAP4F7BWSlnZ5I4dwJk+g4B6o2D6\nXNuzvH/cy+PIys9Sss7RodEcLDnI+KjxbMnb0qzrxx1mPrtZ/BQ/KJ5dBbuoqKlQLR9NGsvVjwyK\nJCIootHWnh3OkYsMcb2CERD7L7jijxByvHPHdBrj+p2acQHzBsP8zZu/z/hB8Wy9ZauT+6ilv8vu\njtdmEFLKT6SUdwJnAy8As2hESE/T8ayYvsKpvD+3OLdBZ6vl25Yz7Y1pHh/TXX/m8587n5xjOU7t\nIAeEDuCsnmepvryf5H7i1MN52hvTnMYy7Y1pzFw5U41lydYlDAwdiFVYVQVtrb2WSdGTnIxDuH84\n4QHhKsvEvIs0KSgv6BrGoSYAPnoc/vY/KOsDv5wJv7heG4c2YseuGv0AqsnQJwc/4byI89QNUVhA\nGLERsarXdXdu5NNReDS3rstiuga4AxhNfWMfTSdz5wd3OpX3n6w86dT+0Fuunz2FezhZfdKpa1hW\nfha5xbnqzj59f7pTd64pZ09xGouvxZf0/elKRM1UybRJm5pBfPbDZ2w4sMFJ2qGoqki5mDbnbSa3\nJNftuNvNXeQJuROMXg1b74NRr8Ds82FYeueMpZthob6KOsg3SCmq1tprOXLqiAoez4+fT0F5Aauu\nXaX27Q5uns7EkxjEKmAvMAl4FviJlPKu9h6YpnncKY5m5WcxdtBY5q2f53HWjyvu+jOH+xuVoj4W\nH+4bf5/THd0XR+sLvBwrXM07OHMsa/avIWloEmv2r3FS9fS1+HL3JXfja/HFJm1U1lYqpU8/a30L\ny+359X7hEN8Q1eDFEXeSGO1KZQ9Y+xy8mgl2H7hxMiTdBoEnm99X45bBoYOdlh9KeEh9j5U1hmdb\nILBarCy4dIHKVjuTGvl0FJ7EIC4HNkjprRJS79HdYxDNZSm5e/2sp86ioraCYRHDnBQua+w16k7q\nyjev5HjZcRWIMwvJau213DvuXlWc9srOV6iyVRHqF8qp6lP4W/2ZP24+qZmpnBN+DifKTzhVjkYG\nRXLRgIsaZBcpzX83MskCgRBCBZTN7CLz70ab8QiLUsnsEJVVd+y/Ata+ACUD4ZK/wKQU8CvvnLF0\nExrTe5ocM5nt+duV5Lpj057S6lK3BW2axvFWw6C+wDjgLSHEO0KIRUII3Qq0g2guS2nvH/Y2CEjf\nfcndHC8/7tTgxdGts3zbcj745gNyjuc02lvZLE4zjYPZy7fSVqmyi46UHlHGwVTfLCgvIK/YKAxy\nzCgyx+J4oTfdRxKpjMOjmx9Vr5v/4R33MV1b4KDN34xxaJcZRFlv+Pc/4M114F8Ct8TDz+Zq4+AF\nTHepiZ/Vj5SEFLYe2kppTSkBPgEqSA1GUWRjBW2attOoFpMQYhzwJkab0dfrVl8MbBdC3CCl3Nr+\nwzuzMS/+adlprN2/tk1ZSun70xvVsEnLTlO9lYsri3np85fUfiP6jVDBYgsW1ae3vMa4GJoZI2Y2\nUk5hDtZFVuzYiQyKpKDc6H7mmn20Nc/55/PEliec1DGhYRMeVzyZOXg1aC2BnFmw7q9QGQ6XLoIJ\nj4JPtffOcRrjmMBg4po44DpDcH09wBrAzSNv5vEtj1Njr6HaVm00IqoT1Vs8aTFzxs4hMTqRq966\nCoHgveveIzEmkcToRO1m8jJNifUtA66SUu50WJcuhHgPI5tpTLuOTAMYRsI0DoNDBzsZB3fFOX/7\n7G8M6z2MPsF91J37VcOu4pHMR9SyuX1yXLK6U58zdo5qkGIRFmIjYukV1Evts7dwL0UVRYwdPNbp\nYj9zmBHIdmweYwaLC8oLVDN6E/OCYF4UzGUz+O16gXGkqdfanZL+8EEa7JsJA3bAzMkQubv5/c4g\nXL9Dd1llru4j87dibme6MCfHTCbYN5h136zjUMkhwvzDWHDpAlUtnRiTyC9jf6n+Np9XXbuKHUd2\naAPhJZqaf4e6GAcApJS7gB7tNySNI65ZSqa7CRpmCS3ftpx9J/YxtPdQJ22ZT3I/obiyuEmtmeXb\nlqvlAJ8AcgpzlHHYnLeZ4+XHmTZkmjquyQMbHgDgw28/VOsc/8O7dh1zNAyOy80ZB3ObDkcCn90C\nz30N302FqXPhlrHaOLjB8TsM9w93m1XmGoA2fyuxEbFsvHGjU5MeQOkqnaw6ybc/futUrPbCjBdU\nXweT5graNC2jKQMhhBANRM6FEL2a2U/jJdxlKTnGJFyzhOatn8eMoTNYs3+N0oSZMXQG6fvTmTF0\nhtKImbt+LjNWzlBaMycrTzJ3/VweGP8ADyc+jN3u3i2Tvj9dHdfEjr2Bq2dc1LgG+7peKEL8QpyW\nPZkddPgM4scYeH0DrHkJ+u0yOrzFa+VVE9fOb5Eh9eHJoqoiYiNisS20OWW8OWokCQS2hTZiI2LJ\nKcxhyutT1G/STLVOGprk9rev6RiautA/BawXQlwqhOhR95gIfFj3mqad2Xhgo1PMwWyMvvHARrXN\nnLFzVFHZ+Kjx1NhrnNJaa+w1JA1NUnfyc8bOYfqQ6cT2iVXT8P4hRqMVs1m8412/mQll8tDHDzU7\nbnfVzq6uBk/6Dncadgts+5Mhrnd4NFx5G9w0CXp/19kj61K4foeHSg6ptqAACdEJACr5AZx/G6H+\nhoHZPXs3fYP6YhEW9Zvcd2IfSUOT1M2Gu9++pv1pMs21rnPcvUAsxmT7a2CplHJNxwyvabp7mqsn\nmIVwbZG7gIYyGgHWACptlU4ugO+KvqPS1jKFFdcYRJenIBbSX4bDY2DIWkNcL+xwZ4/Ka7S06ZFZ\n/+KYzmwew8xwM38rJtGh0Vwx9AonCRgzYcH8fZnJDZrOwStprnXifAlSyt5Syoi6v9tsHIQQPevS\nZvcKIfYIIcYKIXoJIT4SQnxT9+y+h18XxFVSApqXt2hOhgKMeoUxf6vPBRj27DBmrpzJkq1L1Otz\n188lIijCyX105ZtNd4R1PbdYJPj8h88RCOXGMf/D27Hjb/UnpzCnxcYBGsYguiy1vrBpAbzwORSd\nDddcD7+a0a2MA+CxcZALJeH+4UYVe1URQT5BgOEqtEkbvhZfTj5wkvCAcKffha/wJbckl50/7FTG\nwSqsFJQX0NO/J9X2anr69yQrP4vznj2vXd6jxnt0VizhaeA/UsphwAhgD3A/8LGUcghGz4n7O2ls\nLcZdsLg5eYvmZCjc1Suc2/tc0venqxTRHYd3ADB20FjA6M0b7BvM8bKmtX9cz23eAUpkg0BwqF8o\nVba294fqNAkMTzgcBy9+BpsWQezbhkzGBf+CTqq/c8Q1qOsJrp+1u8/e9Xt21yTpx/t/VH8H+QWp\nuhSrsKpsohDf+lhSqF8oNbIGgeCrY1+p5ArTKBVXFTM4dDDFVcUtfk+azqHD/9cKIcKABOBlACll\ntZSyGJhJvcbTa8BVHT221uIuWNycq6c5GYp56+exbOoy1ly/RkkJZOVnOfXcPVZ+zKnn7qx3ZrHm\n+oZSxc2d2/EO0DUQXFpd2mB/14uLJxf/TldYdUd1IPx3Kbz0KVSEw/Uz4JpfQ3DnKdq7fpauaaGe\nGIyBoQOdll2TBuIHxVOVUqVEDwWCidETVROlZVOXqW033riRiKAIFTz++MaPCQ8M5+MbPwZgVP9R\ngLNcikRSVlOmkitiI2LV8RyD1DoVtevjUcMgr55QiJHAixjxjBHAZ8DdwGEpZc+6bQRQZC677H8b\ncBtAVFTUxQcPHuyooTeLu762nu4T3TOaV5JeYeGmheoY50UYU/DIkEhSM1MJ9AlkVL9R5BzP4WTV\nSQSCnv49qbJVUV5bTkpCCn/d/lfKasqoTjEu9MOeHUbvwN6EBYQpCYyop6KorK1UchxAAz+yo8SF\nY9qqJ+mopwUHJkL636DoHLj4ebjsPgjo3MB5c2q05nfSmByFqyyJY/zHTHGWSNVwZ9izwyiuKObH\nyh+psdeQkpBCYXmhU8Mp1/7e4Nw8x2z6NKLfCFVTs3zbcmrttVT+uVKdx0f48H3x91TUVjAhagLD\n+w5vl8ZWGs/wNAbRqIEQQjQZ6ZRSLm/q9SYGFgd8CoyTUm4XQjwNlAB3ORoEIUSRlLLJOERXClK3\nJljsuo+ph2Qu+1n98LH4YLVYuXvM3Ty6+VE1XXe9SJhSFebry6YuY87YOQ008s3UWZPGeiyYOF60\nokOjyS3JbWAkOl1muyVUhsJHS+Cz2yH8W0j6PcRs6uxRKZr7LM3vvangv7lN/KB4tuVva/Q3mXEg\ng6vfuhqJ5O4xd/P09qedKpM9JeNAhlNVvrtKZm8lU2i8gzeC1D3qHnFAMjCw7nEHcFEbxpYP5Esp\nTT/IO3XHKxBC9Aeoez5tek401tfWNXDd1D4zhs6gxl6Dj8WHidETCfQNpMpWhc1en0du9lQGOFnp\nrBZqSlVYhZXkuGTlPtqWv434QfFk5WcR9VSUarTSGK657Y7uidySXOWecExnPG2Mw74rjYK3z2+F\n+KWQfGGnGgd3rjnX+hDXjng3j7yZAGuAMg4C4bRNgDWAvHvy1Hc+dtDYJn+TEql+X40JIzaFaRwa\n698Mrfv/oekaNGogpJSLpJSLgEHARVLKuVLKuRh6TFGtPaGU8ihwSAhxbt2qyRjupnTgprp1NwGr\n3ezeJdnw/QanOyJPGpW47mPWK5wVdhapmanMHTuXPkF96BPchz+O+SOpmalYhZXo0GgEgpLqEvyt\n/upib8ocfPSbj4juGe1UG7H1lq1OTYVOVJwgOS65wezBPK4jjn0ZAJWa2JqMpk6jLALeeQNWroHA\nE3DrJTD1XvCr6NRhuVYam2mjYHwXFmEhNTOV3oG9VfJCamYq88fNBwxF2z8n/FltE2ANUAkFYQFh\nxA+K50TFCcD9b3LHkR28f9376vf1xzF/5P3r3mfHkR0ev4cdR3Y4zRgc5S5MWvP/Q9M18ETuex9w\noZSyqm7ZH/hSSnlukzs2fcyRwEuAH/A98FsMY7UKw/gcBGZJKX9s9CB0LReTN3Cdqv/i/F+Qlp1G\nsG8wc8bOYWnWUiVa5ngxAZzyy685/xqn6fzYQWPJys9SRiJpaBIfH/iYspqyBkbC9biur5uFe5ZF\nlhbfbXY4EvjqevjwGagKhYRHYPzj4NM1Um9Nd5JVWBkzcAxZ+Vnq87cKKyF+IfxxzB95Zvsz1Npr\nlavRdOMAzbp2msMT95Cm++G1lqMYSq7/E0L8nxDi/4DttLGjnJRyl5QyTkp5oZTyKillkZTyhJRy\nspRyiJRySnPGobvhbqr+xldvEOATQFlNGZtyNynjYBVW7r7kbrVvuH84VSlVyq0wd/1cNZ03jUP8\noHglWZC+P52ymjLVlMcqrI0Ny6kZUPygeNKy04h6KqrrG4eTA2FlOrz7JvT6Fu4YBRNTO8w4uLrq\nrMKqgsMmDyU8pIrOzAy1kw+cJH5QPDZpUxlktfZaymvKWXjpQvXbuOqtq7j6raubdO00hyfuIc2Z\njUdZTEKIiwDTz5DpTsSvMzidZhDulFeXb1vOhu83sO6GdW6zRW5fczsAewr3qLv4yKBIhkcO5+MD\nH6vtHJvn+D7sS62sVRcjyyILwb7BTDhrQoNGPo4NeprCcVbRWAZNl8Eu4PPfw/qlRoe3yQ/BmGfA\n0vFxEsfPzfw+/FL9nILLKQkpLM5cbPTFWGiMcdob08grzuNA8QHKa8uZHDOZob2Hklucq75D87fh\nKFbnmF3kCc1lKGm6L96cQQAEASVSyqeBfCFETJtGdwbSXDHdvePubTC1f2HGC5wbca6TgmpBeQFb\n8raQkpCigotRPYyQ0MyVM6mVtSQNTVLHGDtoLKU1pSqoPe7l+qDz4s2LGwRBXe98XV1Org1duhQn\nzoHXNhpd3gbugDuHw9i/dKhxMGMF5ueWNDTJaeZQnVKtagtMJd0NN25QxgGM3sr5p/LxsfqQkpDC\njiM7ePOrN5kfP19t4w0lU3e/Oa2GqnGkqX4QAAghFmJkMp0L/B3wBf6J0WlO4yHmzGHe+nm8v/d9\nj1L9HLM/5oydQ9RTURwqOUSVrYpXd72q3Dy5JbmEPRZGSXUJFmFh/Xfr1TG25W8DICs/C/9Uf6rt\n1fU9GaSdxZmLnc5purFM3BXKdbkZhM0Kn/4JMlLBWgVJt8CoV7xWCe2u9sN1nVwo1ezAlKEwmyjN\nXDmT1dcbOReObp2mmty0NbtIo/EGnswgrgaSgDIAKeURdD+IVuGqvNpcHrhr9seFkRcC4CN8OFRy\nCB9Rb99LqkuwYsUu7VTaKpUssr/VX21jXtDs2An3D3ebc+96IezyKaxHL4CXt8FHT8JP/mvIZFzk\nPeMA9RliJo0VC4YFhOFr8VUyFKuvX60q3U08yfrxRnaRRuMNPMli+p+U8qdCiM+llBcJIYKBbVLK\nCztmiI1zOsUgwDvFQq6qq67qnJFBkfz8/J87KWm6YhVWhvUeRk5hjsdFbiG+IaphfJeg1g82P2g8\nAopg2h8MHaV20E9yzBADnD7/9lIl1dlFmvbEmzGIVUKIF4CeQojfAxswUlQ1LcC1WGj6kOkNioUy\nDmQopVZoqLoa9VQUWflZ+Fp81R2so3EwVTNf+vwlp4pbV2zSRk5hjmro0hwC0bWMw6ExhurqJwth\n+L/gD+fB8PYxDoBThpiZEea4zjGu4w10dpGmq9CsgZBSPolR7fxvjDjEAinlM+09sO6Gu2KhQN9A\n3tr9FlB/URg9YLTaxzWw/WOFkflbY69poL4Z6heqjEWNvUYFk5uS2zYbujjiTs21y/i/q4PgP8vh\n5SyjruFX0+DnN0JQ+2dEb71lK6Lunzlj2HrLVuIHxbOrYJdXz+WJG0qj6Qg8cTE9IaW8r7l1ncHp\n5mJypaUaNo4Fa64FbO40lRwzkAKsAVT8uYJ+S/tRUF6gxPmaS1t1zWLqNL6fZIjrFZ8NcStgyv0Q\ncMorh3ZN95ULJT4P+yjpktoFtV45j0bTVfCmi+kyN+uuaPmQNK4kxiSSHJdMamYqyXHJDYyD2TzI\nNA7hAeEkDU0iPCCczXmb8RE+xEbEquUJUROwCAtWYW1wYbdYjK/66PyjAA2MQ2PFciXVJQ1SXzuU\nijBY/Td4/WOw1MLNCXDl7HYzDia1C2pb3H1No+luNGoghBDJQoivgGFCiC8dHgeArzpuiN2XjAMZ\npGWnqXx4Vx/zlLOnMHf9XHXxL6osIn1/OkWVRUyImoBN2vhJr59QXFms5JyvHHIlNmlrcGGPCTNK\nV2aunKnWOdY0NHYh7NQZxN4kQ1xv180w7nFIHgHRjSvPtpTo0Gj1+UcERbDxxo1ONQu1C2obVD9r\nNGcSTc0g3gRmYIjmzXB4XCylvKEDxtataUsgMmloklKATd+fzoyhM5RKZvr+dLXdiH4j1N85hTmE\nPRZG+v501SjGHa4xCHd1EK4zCnfdyNpEaV94+1/wr9UQfAx+PwYuewB8Wy4Q2FR3tdySXB0I1mia\nwPxXRGAAABoCSURBVJMYxCVAjpTyVN1yKHCeg1x3p3E6xyA8kTkwm7EUVRYpF9OAkAEUlBdwfP5x\ngh8Npm9gX87re56SYPB92Be7tDMuapxqRDQgZIDKxQ/1C6W0upRQ/1B6+PdoNP7gmP7q+He7zigk\n8OWv4T9/geoQuPRhGLcErN6NATi+H8cZgpaZ0JwpeDMGkQY43kaW1q3TtAFPZA4eGP8A6fvTnVxM\nOYU5PDD+AQBuGnETuSW5qo3jnR/cSa2s5ZJBlyh5jtziXD7N/xSov7jbsVNcVexWNsOcQbgzDuA+\nJuGVGUTxYHjjA3jvH9B7H9wxEhIebbNxMGcMZrqv+X5iI2IbuI+0zIRG44wnBkJIh2mGlNKOBxId\nmvZnxfQVKgPKsRnQtvxtqt4iNiJW9R0wewY74tp46L7xzslpDyU81GzP6aY60jWLXcD/kmFFDhy8\nFH72R/jdBOjjnVaUtoU21X3N1+KLbaGN2IhYcgpzGP7ccK+cQ6PprnhiIL4XQvxRCOFb97gbo4eD\npp3Z8P0Glk1dplJYzSwmx0Yr5/Q6hwBrgJoNhAWEOdVbfF34NSG+IcSEx5Camcr94+9X+7o2qBGI\nBhk9qZmpPJTwkNt93BXhtYjCIfDqJli3AgZtM8T1Lvlru4jrOY519+zdxEbEsv/H/V4/j0bTnfDE\nQNwBxAOHMdqFjgFua89BaQzMuILpLjKzmEwF2OXbljN3/VynlNXontFO8h0zhs6gtKaUvJN5pCSk\n8PiWx9Vrju4isxjOUd3VbGf52JbH3O7TVBFek9issOVeSPsSjl0AM2+G31wO4bmtO14jmKq21SnV\n6mGye/Zup2WNRtMQj/pBdFVO5yC1J7iquZoGAZwL48wub3d+cCdp2WlqGYzA6+X/vJwae43bALPr\nOtfCOXfCdM11oWuSoxfC6lfgh4th2LswfTb0OOrRrp7oRrnOihxltDUajUGbg9RCiHvrnv8qhHjG\n9eHNwWrc406eY9nUZaowLtAn0MkYrJi+gksGXsLafWvVMXYc2cHjUx7H3+qv7v7D/MI4L+I8dTEV\nCKJDo7Fg4VDJIcL8w+rvvh2UTAOsAW4rtj0yDjX+8HEqvJgNJQNh1jXwy2s8Ng7QvLKs+X5cZ0Ua\njaZ1NOVi2lP3nA185uahaWfW3bDOrdqrWRhXWVvJOb3OcXrt0cmPUmGrUPn8oweM5v4N91Nlq1IX\n0EujL2VIryHqYiqR5JbkYsfO4NDBnKw6qeopzBlEiG8IlbZKlVHlSLOV1nlj4YWdsPnPcMEbhiT3\n+e+2+PNoLlhuvh/TYCXHJbf4HBqNpp5G/8dJKdfUPb/m7tGWkwohcoUQXwkhdgkhsuvW9RJCfCSE\n+KbuObwt5+iOuCrCPjn1yQaKsKaw26x3ZrEgY4FyL5n9jpOGJpG+P530/elqneOF10yZBcNFY6qW\nOqq5bs93LoFx7I/tRFUwrHsaXtkCNUHw68vh6t9CUFGDTd2lyroaHsdgOeC2s11YQJj6+3DJYffj\n0mg0HtFoDEIIsQYan6NLKZMae63ZkwqRC8RJKQsd1i0BfpRSPi6EuB8Ib04QsLvHIFxprq+1Iwsy\nFpCamUqQTxBTzp6iOpqB0RcZCdULjNhCyKMhlNWUNTifBQu2hTbVGQ0adjdrVK/o28tgzYtwMgp+\n+hxMfhD8m5YM7x/Snx9KfwCMRkdVtqpmPhHo6d+T4qpioD5+Mjh0MKP6jSIrP4vj8483ewyN5kzD\n0xhEUwbi0ro/fw70w2gzCnA9UCClvKcNg8uloYHYB0yUUv4ghOgPbJJSntvUcc40A+EprWk2M/y5\n4U4NhMwGQY69lbfnb6egvEDtYxoHp0B2RU/473LY9VuI2AszboWzmm+o49iA52TlSaexhPuHU1RV\npAxAZFAkBeUFTvuM6DfCqUmSY2xGo9E402YD4XCgbNcDuVvXwsEdAIowZigvSClfFEIUSyl71r0u\ngCJz2WXf26hLs42Kirr44MGDrR1Gt8S157HrsjtM15Wf1Y8qW5WaJfhb/KmyG7GLXgG9yC3JVRdl\ncxunGcXXV8O657BW9Mce/zgy4f/At/lZgEmYfxgnq4zCvfCAcIoqixp0sjPXm8/9gvtxtMwIdDeV\nzaXRaOrxptRGsBDibIcDxwDBbRkcMF5KeRGGbPhsIYRT55q6ym23lktK+aKUMk5KGdenT582DqP7\n0ZpmMxu+38D5EeerQLZ5wTeNQ0l1CbkluYT4hlBtr2Zw6GC1jUQSUnUOvPU2rHoX/57F7NgBd9yX\n16RxcI05mMFxUdcWzlSsdTQOZi1IZFCker2gzOhtEeYf5pTNlRyXzMYDG1vxCWo0GhNPDMQ9wCYh\nxCYhxCdABvCntpxUSnm47vkY8B7wU6CgzrVE3fOxtpzjTMUTjSdXfC2+5BTmqKB1ZFCkes1REba0\nppTkuGTy7skzFGElsPNmap/9Ar65Ev6/vfsPs6qq9zj+/ogGggiGROqooEgiJgQIDnSRQE2TZ7R7\nuaX9oiTtSipKXdMyi9K6Jml0A5McjcpExeSXhQqiKSgIiDCAKCIhXAVEwR8Q6Mz3/rHWGQ/TmWFm\nmDl7n5nv63nOM2fvOT8+5zxn5nvWWnuvNfRadn/jFM57PEz7ka3qgHL2QPeAogFsuGoDl/a9dK/x\njfXb11dez8xgW9KthM07N1dujztrHLvLd3P96dfv9fgTz53IC5c1zHQdzjVXtVlydDZwAjAauAL4\nhJk9XN8nlNRGUtvMdeAsoAyYAYyINxtBmGbc5cGCjQso6VZSOZBdTjmdWnfiwAMOrDystc1BbWjZ\nomXlt/QdWw6j1ZQnYPpd/LP9Uo65+jx6fH4mB7So+JdJADPjAq1atKrclxmzGFA0oPLIo4nnTuSY\nQ4+hY+uOe92npFtJ5VnbmSOyMttjiscw7qxxe00/4pxrGLUZg2gNjAGONbOLJZ1AKBKzarxj9Y93\nHKHVAGHSvz+b2Y2SOgD3AccA/wC+YGY1Ljbsg9SNJ3up06c2PFV5wl5FBUyYANdeCxV8wAFn/oCr\nLmvFLQvHsfP9ncDeZ2MPKBrAgo0LahxgzqzxnJEZQ/ABZ+caR0OOQdwF7AGK4/Ym4Ib6BjOzdWbW\nM156mNmNcf82MxtqZieY2Rn7Kg6u8VR3vsX37rmLQYPgiivgpD7baHXFqcy85Wx+OnQsZ3Q5o/L+\n2edSLNi4oLJbKlMcOrXuVHl+xYKNCxhYOrDy9tkDzJlup9sW38aoh0bl8y1wzlG7abuPN7MvSroQ\nwMx2xqOMXBNVdYqPy/uOYc7kftx8Q3/at4XJk+G140rpd9QtleMda7atoaRbCcu3LK/sllq+eTlC\nld/+33n/HTq17kT7g8PBafNHzmdg6UCWbV5W+dyPvfLYv0wfktnvnMuv2nQxLQCGAvPNrLek44F7\nzKxfPgLWxLuYGt/SpTByJCxbBsOHw29+A5065b5tdd1Szrl0acguph8Bs4GjJd0NzAV82a0mbteu\nMM7Qrx+8/jo88ADcf/++i0NN04A45wpLjV1MsSvpBcLZ1KcBAkZnnwHtmp6nngqthhdfhIsugnHj\n4LB9zIyVa+bZzH5vRThXmGrTxbTCzD6Zpzx14l1MDeudd0KrYcIE6NwZfvc7OOOMfd7NOVdgGrKL\naamkUxsgk0uxv/0NevSAiRNh9GhYscKLg3PNXW2OYuoPfCVOsPceoZvJzOyUxgzm8mPbNrjqKvjj\nH6F7d5g/H4qL930/51zTV5sC8dlGT+HyzgymToXLLoM334TrrguXli2TTuacS4tqC4SkVsB/AV2B\nFUCpmX2Qr2Cu8bz2GowaBdOmQZ8+8Mgj0LPnvu/nnGteahqDmAz0JRSHc4Bf5iWRazRmcOedoStp\n9mz4xS/gmWe8ODjncqupi+mkzNFLkkqBRfmJ5BrDK6/AJZfAnDkwaFA4Qqlbt6RTOefSrKYWxPuZ\nK961VLjKy2H8eDj5ZFi4EG67DebN8+LgnNu3mloQPSW9Ha8LODhuZ45iOrT6u7o0WLUqnPD2zDNw\nzjlw++1w9NH7vp9zzkENBcLMWuQziGs4e/bATTfBDTdA27bwpz/Bl74EPsWic64uanOYqysgixeH\nVsPy5XDBBaF76WMfSzqVc64Q1eZMalcAdu2Cq6+G/v3hjTdg+nS45x4vDs65+vMWRBPwxBPwzW/C\n2rVw8cXh8NX27ZNO5ZwrdN6CKGBvvw2XXgqDB0NFBcydC5MmeXFwzjUMLxAF6qGHwuR6kybBmDFh\nzGHIkKRTOeeaksQKhKQWkp6TNCtud5G0UNJaSfdK+khS2dLsjTfgK1+BYcPg0ENhwQL45S+hTZuk\nkznnmpokWxCjgdVZ2zcBt5pZV+AtYGQiqVLKDKZMCdNk3Hcf/OhHYTnQ/v2TTuaca6oSKRCSioBz\ngTvitoAhwNR4k8nA+UlkS6NNm+D88+HCC6FLF1iyBH78Y5951TnXuJJqQfyKsK51RdzuAGzPmtJj\nI3BUEsHSxCzMmXTSSfDoo2Hpz6efhk+mcn0/51xTk/cCIWkYsMXMltTz/pdIWixp8datWxs4XXq8\n/DIMHRom2OvdOwxCf+c70MLPb3fO5UkSLYiBQElcoW4KoWtpPNBeUua8jCJgU647m9kkM+trZn07\nduyYj7x5VV4Ot9wSWglLloT5k+bOha5dk07mnGtu8l4gzOxaMysys87ABcBjZvZlYB4wPN5sBDA9\n39mSVlYGAwaElsLQobByZWhBHOAHIzvnEpCmfz3fA8ZIWksYkyhNOE/e7NkDY8eGrqR168IUGTNm\nQFFR0smcc81ZolNtmNnjwOPx+jqgX5J5krBoUZhcr6wszLg6fjwcfnjSqZxzLl0tiGZl587QlVRc\nDG+9BTNnwt13e3FwzqWHT9aXgHnzwuR669bBt74V1m5o1y7pVM45tzdvQeTRjh1h0HnIkLB4z7x5\n8NvfenFwzqWTF4g8mTkznPBWWgrf/W44r2Hw4KRTOedc9bxANLKtW8MUGSUl0KFDWB/65puhdeuk\nkznnXM28QDQSszDo3L07PPAA/OQnYTnQU09NOplzztWOD1I3gldfDQv5PPRQmG21tDSs3eCcc4XE\nWxANqKIiDDr36BEGoG+9FebP9+LgnCtM3oJoIC+9FNaDfuKJME3GpElw3HFJp3LOufrzFsR++uCD\nMOh8yimwbBnccUeYmtuLg3Ou0HkLYj8sXx6myVi8GM47DyZOhCOPTDqVc841DG9B1MPu3XD99dCn\nD2zYEJYAffBBLw7OuabFWxB19PTTodWwejV89athILpDh6RTOedcw/MWRC299x5ceSUMHAjvvgt/\n/Sv84Q9eHJxzTZe3IGphzpxwhNL69TBqFPz853DooUmncs65xuUtiBps3x66k848Ew46KBzCOmGC\nFwfnXPPgBaIa06aFyfUmT4ZrroHnn4dBg5JO5Zxz+eNdTFVs3gyXXw733w89e4ZZWPv0STqVc87l\nn7cgIrMw6Ny9O0yfDjfeCM8+68XBOdd85b1ASGolaZGk5yWtlDQ27u8iaaGktZLulfSRfGXasAE+\n9zkYMQJOPDGcEf3974dxB+eca66SaEHsBoaYWU+gF3C2pNOAm4Bbzawr8BYwsrGDVFSEQecePeDJ\nJ+HXvw4/u3dv7Gd2zrn0y3uBsODduHlQvBgwBJga908Gzm/MHGvWwOmnw2WXQXExlJWFsYcWLRrz\nWZ1zrnAkMgYhqYWkZcAW4FHgZWC7mX0Qb7IROKqxnv/OO8MAdFkZ3HUXPPwwdO7cWM/mnHOFKZEC\nYWblZtYLKAL6ASfW9r6SLpG0WNLirVu31uv5u3WDYcPCdBlf/zpI9XoY55xr0hI9isnMtgPzgGKg\nvaTMYbdFwKZq7jPJzPqaWd+OHTvW63k//WmYOhU+/vF63d0555qFJI5i6iipfbx+MHAmsJpQKIbH\nm40Apuc7m3POuQ8lcaLcEcBkSS0IBeo+M5slaRUwRdINwHNAaQLZnHPORXkvEGa2HPhUjv3rCOMR\nzjnnUsDPpHbOOZeTFwjnnHM5eYFwzjmXkxcI55xzOXmBcM45l5PMLOkM9SZpK/CPet79cOCNBozT\n2AopbyFlhcLKW0hZobDyFlJW2L+8x5rZPs80LugCsT8kLTazvknnqK1CyltIWaGw8hZSViisvIWU\nFfKT17uYnHPO5eQFwjnnXE7NuUBMSjpAHRVS3kLKCoWVt5CyQmHlLaSskIe8zXYMwjnnXM2acwvC\nOedcDZpFgZDUStIiSc9LWilpbNzfRdJCSWsl3SvpI0lnzYir7j0naVbcTnPW9ZJWSFomaXHc91FJ\nj0p6Kf48LOmcAJLaS5oq6QVJqyUVpzjrJ+J7mrm8LenKFOe9Kv59lUm6J/7dpfJzK2l0zLlS0pVx\nX2reV0l3StoiqSxrX858Cn4d3+Plkno3VI5mUSCA3cAQM+sJ9ALOlnQacBNwq5l1Bd4CRiaYsarR\nhHUyMtKcFeAzZtYr67C7a4C5ZnYCMDdup8F4YLaZnQj0JLzHqcxqZmvie9oL6APsBB4khXklHQVc\nAfQ1s5OBFsAFpPBzK+lk4GLC7NE9gWGSupKu9/X3wNlV9lWX7xzghHi5BLitwVKYWbO6AK2BpUB/\nwkkmB8b9xcDDSeeLWYriB2AIMAtQWrPGPOuBw6vsWwMcEa8fAaxJQc52wCvEsbc0Z82R/Sxgflrz\nEtaQfxX4KGEZgVnAZ9P4uQX+EyjN2v4hcHXa3legM1CWtZ0zH3A7cGGu2+3vpbm0IDJdNsuALcCj\nwMvAdjP7IN5kI+FDnga/InxgK+J2B9KbFcCARyQtkXRJ3NfJzF6L118HOiUTbS9dgK3AXbH77g5J\nbUhn1qouAO6J11OX18w2AeOADcBrwA5gCen83JYB/yapg6TWwOeAo0nh+1pFdfkyxTmjwd7nZlMg\nzKzcQlO9iNC0PDHhSDlJGgZsMbMlSWepg0+bWW9CU/fbkgZl/9LC15o0HC53INAbuM3MPgW8R5Vu\nhBRlrRT77UuA+6v+Li15Y3/4eYQifCTQhn/tIkkFM1tN6Pp6BJgNLAPKq9wmFe9rdfKVr9kUiAwz\n205Y/7oYaC8ps6peEbApsWAfGgiUSFoPTCF0M40nnVmBym+PmNkWQh95P2CzpCMA4s8tySWstBHY\naGYL4/ZUQsFIY9Zs5wBLzWxz3E5j3jOAV8xsq5m9D/yF8FlO5efWzErNrI+ZDSKMjbxIOt/XbNXl\n20RoAWU02PvcLAqEpI6S2sfrBwNnEgYn5wHD481GANOTSfghM7vWzIrMrDOhW+ExM/syKcwKIKmN\npLaZ64S+8jJgBiEnpCSvmb0OvCrpE3HXUGAVKcxaxYV82L0E6cy7AThNUmtJ4sP3Nq2f24/Fn8cA\n/w78mXS+r9mqyzcD+Fo8muk0YEdWV9T+SXIQJo+DPacAzwHLCf+8ro/7jwMWAWsJzfeWSWetknsw\nMCvNWWOu5+NlJfCDuL8DYaD9JWAO8NGks8ZcvYDF8bMwDTgsrVlj3jbANqBd1r5U5gXGAi/Ev7E/\nAi1T/Ll9klDAngeGpu19JXwheA14n9DyHVldPsJBLBMI46orCEeSNUgOP5PaOedcTs2ii8k551zd\neYFwzjmXkxcI55xzOXmBcM45l5MXCOecczl5gXCpJak8zmJaJmlm5lyWej7WekmH59jfTtIf4kyY\nL8fr7fYved3ySHq3mtvU6fXHmWpHZW0fKWlqwyZ3zYkXCJdmuyzMZnoy8Cbw7UZ4jlJgnZl1NbPj\nCZP53bG/D5p19vD+qOvrbw9UFggz+z8zG17D7Z2rkRcIVyieJmsCMkn/LenZOP/92Kz90+KkgSuz\nJg7MKU7x3Af4adbunwB9JR0vaYqkc7Nu/3tJw+PEjzdnPf+34u8HS3pS0gzCSVh1ylPb1y/pEElz\nJS1VWIfjvHib/wGOj62OmyV1zqwnIOnrkv4iaXZcT+AXWa9rpKQXFdZM+Z2k3+xHTteENMS3HOca\nlaQWhKkbSuP2WYS57/sRziKdIWmQmf0duMjM3oxTqjwr6QEz21bNQ58ELDOzyonazKw8zvrbA7gX\n+ALwUJwwbyhwKeGs1h1mdqqklsB8SY/Eh+gNnGxmr8TtuuSp1esH/gl83szejt1Uz8SidE187l7x\nfp2rPFQv4FOE9VHWSPpfwiR1P4y53wEeI5xd7JwXCJdqB8d/1kcR5s56NO4/K16ei9uHEArG34Er\nJH0+7j867q/TP+QsfwPGxyJwNvB3M9sVC9QpkjLdN+3i8+wBFmUVB/YzT3WvX8DP4qy5FfH3tZma\neq6Z7QCQtAo4FjgceMLM3oz77we61TKfa+K8i8ml2a74bfhYwj/FTB+8gJ/H/vlecfygVNJgwqyi\nxRZWD3wOaFXD468Cekmq/DuI13sBq8zsn8DjhIVvvkhoUWSe//Ks5+9iZpkWxHtZj1XXPLV9/V8G\nOgJ94u831/Jxd2ddL8e/ILp98ALhUs/MdhKWs/xOHPx9GLhI0iEQlruMs3O2A94ys52STgRO28fj\nriX8074ua/d1hKm118bte4FvAP9GWDuA+PyXSjooPn+3OJNtVXXKU0POqq+/HWHNkPclfYZQQCB0\nEbWt48M/C5wu6bD42P9Rn4yuafIC4QqCmWVm470wflv/M/C0pBWEdR3aEv6BHyhpNWHA9plaPPRI\noFs8xPVlQvdK9rrJjwCnA3PMbE/cdweh9bE0DgLfTu5v4/XJk1P26wfuJgykrwC+RphBlTi2MT8e\nFntzLR93E/Azwoyr8wnLx+6ob07XtPhsrs41c5IOMbN3YwviQeBOM3sw6Vwued6CcM79OA6GlxHO\nA5mWcB6XEt6CcM45l5O3IJxzzuXkBcI551xOXiCcc87l5AXCOedcTl4gnHPO5eQFwjnnXE7/D+Eg\nFCScg+NsAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7eff99a96978>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if storage == 1:\n",
    "    \n",
    "    n_table = 'prediction_table'\n",
    "    n_predcol = response_col+'_Pred'\n",
    "    \n",
    "    insert_results(pred_val, n_table, n_predcol, loss)\n",
    "    \n",
    "    query_join = '''SELECT a.{},b.{} FROM Player_Attributes a, {} b WHERE a.rowid = b.{}'''.format(response_col,n_predcol,n_table,key_col)\n",
    "    print('Join Query is: {}\\n'.format(query_join))\n",
    "    \n",
    "    df_join = con.select_ipc(query_join)\n",
    "    pprint(df_join.head(10))\n",
    "    \n",
    "    y = df_join[response_col]\n",
    "    ypred = df_join[n_predcol]\n",
    "    \n",
    "    %matplotlib inline\n",
    "    plt.plot(y,ypred,'gx')\n",
    "    plt.plot([30,100],[30,100],'b-')\n",
    "    plt.ylabel('Predicted Overall Rating')\n",
    "    plt.xlabel('Real Overall Rating')\n",
    "    plt.show()\n",
    "    \n",
    "    con.close()    #close the connection\n",
    "else:\n",
    "    con.close()\n",
    "    print('Connection closed without inserting predictions in MapD')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}