Earthquake Damage Prediction-2 Preparing I&O.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preparing the Input & Output to feed the Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as n\n",
    "import pandas as p\n",
    "import glob\n",
    "import matplotlib.pyplot as m\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# path = os.getcwd()\n",
    "# print (\"The current working directory is %s\" % path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols_1=n.concatenate([n.arange(428,440)],axis=0)\n",
    "cols_2=n.arange(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path=\"D:\\\\DATASET\\\\\"\n",
    "Damaged_Input={}\n",
    "Undamaged_Input={}\n",
    "Damaged_Output={}\n",
    "Undamaged_Output={}\n",
    "\n",
    "in_list_dam=glob.glob(data_path+\"Input\\\\Damaged\\\\\"+\"Joint_*.csv\")\n",
    "in_list_undam=glob.glob(data_path+\"Input\\\\Undamaged\\\\\"+\"Joint_*.csv\")\n",
    "out_list_dam=glob.glob(data_path+\"Output\\\\Damaged\\\\\"+\"Joint_*.csv\")\n",
    "out_list_undam=glob.glob(data_path+\"Output\\\\Undamaged\\\\\"+\"Joint_*.csv\")\n",
    "\n",
    "for list_value in in_list_dam:\n",
    "    Damaged_Input[int(list_value[list_value.rfind('_')+1:-4])-1]=p.DataFrame(p.read_csv(list_value))\n",
    "for list_value in in_list_undam:\n",
    "    Undamaged_Input[int(list_value[list_value.rfind('_')+1:-4])-1]=p.DataFrame(p.read_csv(list_value))\n",
    "\n",
    "for list_value in out_list_dam:\n",
    "    Damaged_Output[int(list_value[list_value.rfind('_')+1:-4])-1]=p.DataFrame(p.read_csv(list_value,header=None))\n",
    "    Damaged_Output[int(list_value[list_value.rfind('_')+1:-4])-1].columns=cols_2\n",
    "for list_value in out_list_undam:\n",
    "    Undamaged_Output[int(list_value[list_value.rfind('_')+1:-4])-1]=p.DataFrame(p.read_csv(list_value,header=None))\n",
    "    Undamaged_Output[int(list_value[list_value.rfind('_')+1:-4])-1].columns=cols_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X={}\n",
    "\n",
    "for key in cols_1:\n",
    "    X[key]=p.DataFrame()\n",
    "    X[key]=p.concat((Damaged_Input[key],Undamaged_Input[key]),axis=0)\n",
    "    X[key].reset_index(drop=True,inplace=True)\n",
    "\n",
    "y={}\n",
    "\n",
    "for key in cols_1:\n",
    "    y[key]=p.Series()\n",
    "    y[key]=p.concat((Damaged_Output[key],Undamaged_Output[key]),axis=0)\n",
    "    y[key].reset_index(drop=True,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train={}\n",
    "y_train={}\n",
    "X_test={}\n",
    "y_test={}\n",
    "\n",
    "for key in cols_1:\n",
    "    X_train[key],X_test[key],y_train[key],y_test[key]=train_test_split(X[key],y[key],test_size=0.20,random_state=70)\n",
    "    X_train[key].reset_index(drop=True,inplace=True)\n",
    "    X_test[key].reset_index(drop=True,inplace=True)\n",
    "    y_train[key].reset_index(drop=True,inplace=True)\n",
    "    y_test[key].reset_index(drop=True,inplace=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key in cols_1:\n",
    "    X_train[key].to_csv((\"D:\\\\DATASET\\\\X & y\\\\Train\\\\X_train\\\\X_train_\"+str(key)+\".csv\"),index=False)\n",
    "    y_train[key].to_csv((\"D:\\\\DATASET\\\\X & y\\Train\\\\y_train\\\\y_train_\"+str(key)+\".csv\"),index=False)\n",
    "    X_test[key].to_csv((\"D:\\\\DATASET\\\\X & y\\\\Test\\\\X_test\\\\X_test_\"+str(key)+\".csv\"),index=False)\n",
    "    y_test[key].to_csv((\"D:\\\\DATASET\\\\X & y\\\\Test\\\\y_test\\\\y_test_\"+str(key)+\".csv\"),index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spectrogram's Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir_path=\"D:\\\\DATASET\\\\Spectrogram_Data\\\\\"\n",
    "\n",
    "for key in cols_1:\n",
    "    name=\"X-Axis\\\\\"+\"Joint_\"+str(key)+\"\\\\Train\\\\Damaged\\\\\"\n",
    "    location=dir_path+name\n",
    "    if not os.path.exists(location):\n",
    "        os.makedirs(location)\n",
    "    name=\"X-Axis\\\\\"+\"Joint_\"+str(key)+\"\\\\Train\\\\Undamaged\\\\\"\n",
    "    location=dir_path+name\n",
    "    if not os.path.exists(location):\n",
    "        os.makedirs(location)\n",
    "    name=\"X-Axis\\\\\"+\"Joint_\"+str(key)+\"\\\\Test\\\\Damaged\\\\\"\n",
    "    location=dir_path+name\n",
    "    if not os.path.exists(location):\n",
    "        os.makedirs(location)\n",
    "    name=\"X-Axis\\\\\"+\"Joint_\"+str(key)+\"\\\\Test\\\\Undamaged\\\\\"\n",
    "    location=dir_path+name\n",
    "    if not os.path.exists(location):\n",
    "        os.makedirs(location)\n",
    "\n",
    "for key in cols_1:\n",
    "    name=\"Y-Axis\\\\\"+\"Joint_\"+str(key)+\"\\\\Train\\\\Damaged\\\\\"\n",
    "    location=dir_path+name\n",
    "    if not os.path.exists(location):\n",
    "        os.makedirs(location)\n",
    "    name=\"Y-Axis\\\\\"+\"Joint_\"+str(key)+\"\\\\Train\\\\Undamaged\\\\\"\n",
    "    location=dir_path+name\n",
    "    if not os.path.exists(location):\n",
    "        os.makedirs(location)\n",
    "    name=\"Y-Axis\\\\\"+\"Joint_\"+str(key)+\"\\\\Test\\\\Damaged\\\\\"\n",
    "    location=dir_path+name\n",
    "    if not os.path.exists(location):\n",
    "        os.makedirs(location)\n",
    "    name=\"Y-Axis\\\\\"+\"Joint_\"+str(key)+\"\\\\Test\\\\Undamaged\\\\\"\n",
    "    location=dir_path+name\n",
    "    if not os.path.exists(location):\n",
    "        os.makedirs(location)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_path_=\"D:\\\\DATASET\\\\X & y\\\\\"\n",
    "fig_path_1=\"D:\\\\DATASET\\\\Spectrogram_Data\\\\X-Axis\\\\\"\n",
    "fig_path_2=\"D:\\\\DATASET\\\\Spectrogram_Data\\\\Y-Axis\\\\\"\n",
    "\n",
    "from multiprocessing import Process\n",
    "\n",
    "def loop_X(split,i):\n",
    "    if split=='Train':\n",
    "        file_list_X=file_path_+\"Train\\\\X_train\\\\\"+\"X_train_\"+str(i)+\".csv\"\n",
    "        data_X=p.DataFrame(p.read_csv(file_list_X))            \n",
    "    else:\n",
    "        file_list_X=file_path_+\"Test\\\\X_test\\\\\"+\"X_test_\"+str(i)+\".csv\"\n",
    "        data_X=p.DataFrame(p.read_csv(file_list_X))        \n",
    "    return(data_X,file_list_X)\n",
    "\n",
    "def loop_Y(split,i):\n",
    "    if split=='Train':\n",
    "        file_list_Y=file_path_+\"Train\\\\y_train\\\\\"+\"y_train_\"+str(i)+\".csv\"\n",
    "        data_Y=p.DataFrame(p.read_csv(file_list_Y))            \n",
    "    else:\n",
    "        file_list_Y=file_path_+\"Test\\\\y_test\\\\\"+\"y_test_\"+str(i)+\".csv\"\n",
    "        data_Y=p.DataFrame(p.read_csv(file_list_Y)) \n",
    "    return(data_Y,file_list_Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in cols_1:\n",
    "    if __name__=='__main__':\n",
    "        Process(target=loop_X,args=('Train',i)).start()\n",
    "        Process(target=loop_Y,args=('Train',i)).start()\n",
    "        data_X,file_list_X=loop_X('Train',i)\n",
    "        data_Y,file_list_Y=loop_Y('Train',i)\n",
    "        for i in range(n.int(data_X.shape[0])):\n",
    "            if data_Y.loc[i][0]==0:\n",
    "                save_loc_X=fig_path_1+\"Joint_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"\\\\Train\\\\Damaged\"\n",
    "                save_loc_Y=fig_path_2+\"Joint_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"\\\\Train\\\\Damaged\"\n",
    "                m.specgram(data_X.loc[i][0:4001],Fs=50)    \n",
    "                m.savefig(save_loc_X+\"\\\\\"+\"Spectrogram_X_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"_\"+str(i)+\".jpeg\")\n",
    "                m.specgram(data_X.loc[i][4001:8002],Fs=50)    \n",
    "                m.savefig(save_loc_Y+\"\\\\\"+\"Spectrogram_Y_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"_\"+str(i)+\".jpeg\")\n",
    "            else:\n",
    "                save_loc_X=fig_path_1+\"Joint_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"\\\\Train\\\\Undamaged\"\n",
    "                save_loc_Y=fig_path_2+\"Joint_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"\\\\Train\\\\Undamaged\"\n",
    "                m.specgram(data_X.loc[i][0:4001],Fs=50)    \n",
    "                m.savefig(save_loc_X+\"\\\\\"+\"Spectrogram_X_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"_\"+str(i)+\".jpeg\")\n",
    "                m.specgram(data_X.loc[i][4001:8002],Fs=50)    \n",
    "                m.savefig(save_loc_Y+\"\\\\\"+\"Spectrogram_Y_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"_\"+str(i)+\".jpeg\")\n",
    "            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztvWmspdl1nvfu7zvTPedOdWu8NTSrJ7ZIU2JTpqmBgqAhtmlBsGxAViwYggwraf+wAAkRECsKEDsWAihAIkc/AiNti5ECKIocibIYwbGoMHRo6QfNURKn5tAsVlfXXHc+8/nOzo97m243u7rep/ueU7ev1gsUqurUrn332d/+9l57rXe9K+WcFQgEAoE3P4qHPYBAIBAIHA5iQw8EAoFjgtjQA4FA4JggNvRAIBA4JogNPRAIBI4JYkMPBAKBY4IHbugppUsppY+klL6QUvpcSulnDj7/xymlF1NKnzn49UOzH24gEAgE7of0IB56Smld0nrO+VMppSVJn5T0NyT9mKS9nPP/MPthBgKBQOBBqD2oQc75hqQbB3/eTSl9QdKFWQ8sEAgEAgwPtND/o8YpXZb0UUnvkPRfSPq7knYkfULSz+WcN1/l/zwj6RlJSs3GX6yfP+39sEnyx1Wf2m1xYmzlhxlSBfueAXINfMHKn2NJSqBrNM1gGMUYjIFEiGA0KU3AOB5oNr2sLZiL5C97Nscj0K+kXPptp2AuyPcj715tAPa8MZlkSb0Ba29iV5t3c84P3DztDT2ltCjp/5P03+WcP5BSOivprvbf3V/Uvlvm771WH83HLub1f/IPrJ+nzYbXTlLtbM9uO63A6pM03fLHUd/ydwXyEhCMT/s7XrEN3i5J5cDfFcj3y6X/grWv+3M8XvTHULXYSd+668/F4JTf97Tpt63tgfUGDvrOC3ZTSdJwzZ+L0ao/DnKwNDf8Max90X9HWrf8vUWS8ic/h9q7+H/yb38y5/zuB7Wz3uiUUl3S70j6jZzzByQp53zrZf/+zyX9/oP7yWoumJPptpM0HvkbU1GwE7cCm82k47fNdbCBgNsKMY3RGCSNl32ztHa3bredLvjjGK3YTZGFV+ux20r/3IyuK6AtsUqnTb/t7qN+W0mqFvyBlAP/EKrAusg1//kNV3xrY+Equ3ZX3/O03Xa06huL+r9+22r2wJ0wpZQk/aqkL+Scf/lln68f+Ncl6W9K+qzzA12XR7Phbx7D2227bdUGd2VJzVvgsAAWRf+SPw6yMZXA6i7hJjZe8sdMLMIMfDnjZX8yGuDGNDjDXtz6jt83OSzaNx7c5iXsPAHm2O8WNpaKEXCPgtevAofQuOO3bW2AdbzgGyaSNFn026fp4QsjOm//eyX9hKQ/Syl95uCzX5D04ymlp7X/+K9I+vuHPrpAIBAI2HBYLn+kVw+p/Gv6w1LKtuU9BG6U5hnfzzXYBce+pNFbhnbbPPCvcgkEJAtwTSX+6PEKcz+R70eie2k8G1/wpD0jF5iEgozjRb/v7Sf9fknQt2rP5mYjSQXw5Q/X/HEUJPAM1n1t4N/GqiYLdo075OYGA64GIlM0EAgEjgkYzeEQ4J6jU0AXbLb8AGoqqCUGKE5DcD6Cfgvg3h0v+ad+8zazPkYn/L6nwCJs3vHHMTwJrCvAXKntQtoRWEaEuUL80YRJVPYIO4i9I4RKWuv634+QDMqh3+/eBf+WXp+BFf0SCA3YxVw39JyTxmPvRy4s+BHGbrdlt601WVB03PeDHCXouuwDNwPiUwM3A7yfEXdHfQts0qf9TZpcrRELBL63aUoI46Rfv+206Teudf2HPW2xyajv+ttIre/3OwKH96TtT3KtD2ikgD0jSSXguBO2jYtwuQQCgcAxwZwtdGk08H5kow6oRbMsiwo44CQLbgrcFwW4LotYjjOct/GKb10lwrMHU1Hu+o3ruzBrFhixgzPgZgPGMV71x4Cor2S9SaqIS4lkgJN1ATCt+/2WI3ZbmTZI34f/AoaFHggEAscEcw+KJvMIIbTFsgTBuik8wwC9MANNGYRZRE8kTUGimiQ1Nnyf3+jEbCx0QqkjtEViWUkswYnEKkggsAZuICTQWeuzuZiC2MoU5OmQADEBih3N8Ba7/PFrh95nWOiBQCBwTDBXC70ospotj73Su+Pn8taWoTwcwMI1f4r6F32/f7k3G3Wu2o7fL1JmlDQGFm8djGNCNDuA0UboglXF5oKk/hMfM7k1IXVPcMsjtwSJJb4t3PIf4M7jRNjGb0p8140dxoqbtPx1P3jqnN+xKZg2d5dLzXSPlEuEW+5ffyvgypGk/qP+YVFu+vfJahG8jWBdF4ALT+lpZBzjZaJnCjY8M6guSQXgJtPDjQT3iMIgcSmRTF/SL8k3kFiWbfcS6Jfw7IGbiGRoNm7u+oOQNL2wbLetmofvIAmXSyAQCBwTHNlM0RZILBqPgZsBFnUgqE6AWwXQRckt39otgCundYc9/sEZEHwm1j+gWhJNEpJMMwEZthJzExHK4KTjN05jQAEE657orEtMTXK0DLI/gf4+cT9N2uC2cm7J71jsWefy8PeisNADgUDgmGD+FroZ1Rr0/ehQ1fO/RmPZV0+UWOr/qY/4Y974NuA3TiDAuAISskoWmM1UB8cEoS0Sq5QkN9FkGuLfJfS7CljoJKNuDGw3WuxjtAqS5EBcg5ibRLcHqVQ22Lpo3vW1DUYroKSWiblu6NNpUr/nCePUQKbotAmCX3BPKm/7m/Sd7wTca3JdRoJNoC288ZFru8CLS8SdqkWy4flNl55nL+72U7Op0kMON+LWKrp2U+T22R8IWMvgmYzAgUxyJIZL/vMg2iySNFnyhb+KcWSKBgKBQOA+mK/LJSdVI+8MaXd8C71e90/yPnDlSLDwATBga/CK74LUVqS0xcJ8dhK/trsg1OsSBEV3HmdzQaxu1C+g3yVABpiQmw0kDiTA4Z/41SIZyMUN7Hq1HitNOOn4z6TeZRx3B2GhBwKBwDHBfC30lFU2vROPaK4Q2uJ0xAKBDZARODrpUy2nwHokvmCiFz7L45wEJEkyFNFZrxqAWkgLIwO/P9GUqYF4yRT0S26PVJOouelvI+SZTP0yB2ogtUxScIRZ6KR9BbJKXcx1Q09JKsw3p7cHan9u+m6UDFw5kjRcB9xy0C+R2iU8dFKfU/DGhw4Lkv0J7stTUsUGyA80NtnpNjhPqmf4TceA9pyX/AdYbPsLLi+xTYwUKCkAt1xgvfVBjsTCbZL3wLZI4n4qx1FTNBAIBAL3wdx56C4y4JZrAVDI2swsrYYgoxOMOUHtEBfEAiJSppKUazOSBwbPD1HkQHBvvAKfByrKMZusUjJidLsitzwxF0254b8jU8ABR2sZTEXjDqiZJ6la9L0FoxX4AhoICz0QCASOCeYeFK2ZFMNq0fddlzXfwqtBK7PfB4U2gAZGRYKGXRD0PQ2khLcYhTORTKQG+H53fUuFqBxOAeW0hDTL5ob/rHsXQYIMUEUcALU+os9CaH2SNAHKmo0d4L9emE25uhop5HxmwW4rQdowLKriYK4bellkLbcHVtsd0K8rJyDtZ6vOCmizARveFLgOShKMhNSO3ACZiURKeM13gzW/7B9Cw5MgNR6IRklCd1simTAFLJDOVf/1HZwGol+wlifJep6A/XEKBNCWvuw/kKIC63gC3xHCSJuBlEa4XAKBQOCYYM6ZolJl8ssTsB77d/30s/qqd0P4Bkgs6aRvaaZt34Kt9YEMLJg35EKBQNV0AIiliXik0FqqAEeaVPSZAmpy/xyoawqCogkuC5KRWweaMkRGr3/G/34t4C4jLiJJKnugalkPdW0hLPRAIBA4Jpiv2mJO6g09y7Tf9ROLWid9alEDqDhK0mTgW9KZUM5AUkhVAjrkBFhLKLtOGgEdDiIvm0DQF2U8Ej83pJEmoMVTB/osJKuU+GCJJhGR+5VY7dbBadS1DbLexmAdN2+BK4Wk/gVfErd1B3oLDMw5KDrViY63+Q56fvCr3fIvZ5MKaoCDykICQcNywz8opid9xk8GHOICyiCQzMtqAdRtvAeqLN0DRYafAoc3dDOQTYzEGJEXjJCO7gLRqD02Gb1LJMDv95uJ+xAYUyXw5YxOMjWxXADZ6B3Gcbf6PPQeA4FAIPBQMF8tF0m1wjtKS8AXR0Jek8MXxPkGgEWBKtP0/TEnQMscnmWRy9YNfxwDcKsYAXfHZMkfQ20baLnA4BepkDMB+jMo/ZOYY6DfwakZZQSLFRLZecLvl9xsCrDsR6tsi1z+5HW77fjCGurbQVjogUAgcEww36CokgYT70fWG77/c3vb93NlYO1Kkky5X0mqgbZVF0z9EvChg8zWAhbZGACLPhPHMZFrBbw+Uq6uTwsvgKkj+jpLV/yOd98CbgmLftvGNlsXFUi+6Z/1+yV+cfI80nQ2OkqStPPt5+22zS2gwWwiLPRAIBA4JnigOZdSuiTpf5N0TvvKzs/mnH8lpbQm6bckXZZ0RdKP5Zw3X7OzvE9ddFCW/vFcbwJd6AV2Kg42/AySiijaLR5++SmJ+Y2J1gkGKFcnUAqPKChmYImRIhuzRPciKQABWFUgOW20DEsTgtsYKYVXB8VlSIyAyA+07rE40xjEeFC8xIRzP59I+rmc86dSSkuSPplS+kNJf1fSh3POv5RS+nlJPy/pH75WR1nJDko2geDWeAwqpsB6iYQaVt70ufMTIqIFIj4TIPqFy/SAuavtgnqX4CCsYPEFu982O+gTcN0RDngGG6+W/TFXGeRTAD0ZSUpA+Atx1td9o4cYMgv3AOECCmgVY//7Na9uoL6tn/+gBjnnGznnTx38eVfSFyRdkPQjkn79oNmvS/obhz66QCAQCNhAQdGU0mVJ75L0MUlnc843pP1NP6V05j7/5xlJz0hS7dSKhqY1PQalnAZ7fhJSAeVzE3AdVO0ZVVYH2Z/lsm/5VwNYXgskLZHEIlK0YuEaUBhcB0FcWGuAKBJmUMBjCtwBRIsnd0AZQ5JMJxZ8JsqMJFEvl0AeGFyC6jvsRljf8d+//mMn/Y6/6jWzv1pKaVHS70j62ZyzrW6bc3425/zunPO7yxVKJQgEAoGAC8vcSSnVtb+Z/0bO+QMHH99KKa0fWOfrkm4/sB9Jhak/0d32g5ElOMkJHVKSBqAEXSJURGDtUn1qG0AFkCI3gYUOEov6l4CiJbAGUw/KIJBSf8ugX1KIAvjbM7gxIStaTFOmDiiRIxB7qIECJb1TfluacDY85e9bRCbAhcNySZJ+VdIXcs6//LJ/+qCkn5T0Swe//96D+soCBSbAhtdaOXyRm28AuAPQJkaEvMCGVwEeOtUvQXUpiVwr4KF3vui717qXQQ7BLjvcSCEKVAcVHN7LX/GHsPltflvKvkDywKBIVgIiYbNSgq5AVSiJuXNmITHtvP3vlfQTkv4spfSZg89+Qfsb+b9MKf2UpKuS/tbhDy8QCAQCLh64oeec/0j3t+V+EP20nGwLvbHiS6JVlX8sDrusjiYB4oAD+lY+4QdaiNoiCTpJLFjGCir4bYnVTdwXE1DuTJIKwHIsAIWTWP67jwLLH9wSSF1TSRqu+euoAuu+IKXtiF4OqOCRADlDkhIR+JwBD/1oZFMEAoFA4A1jvmqLKasBg5IO9nZ8rlcdZoqO+iBTFNC3CJXNDSRLQgHGDLMjcxsEJHv+0spAq4YE7OogoEUq1+//BxDUJmxWoMI5BaQxkmFLLG5JKock8c1fQ1OSbUwSAMF4sYVOXtW9w9dymfOGLpXmN+6blY0kqQDX+9EmKAYpqSTZeHugshCo0kO4yejOBa7hEtykwYFFXgKS7j5ZAt+PJhCD4CWRWCAHFuGWawieHRFLk5TB4UbyL1q3/XdkeIJw1u2mqlrM6CkH/jh659le5CBcLoFAIHBMMHeXS6vhWby7Xf/0KkrfUqmfZC6fEcymdFGsgYxOYBmLBGU60P2169+aEql3OaNAbiLlBmGAimjm1Lf8cYzBDYTUtmtf9+e45yvASoL1Y4GFXoEAMeGhTxZAZvINViZuvOyTLmZBtQwLPRAIBI4J5lvgYpq0awYZyeG10PL93P0BE+1IRPcB6KiQsnkiGY9ElhdapaTQ8JD4YUEgl4x5SlY3nIuSFAcBfRckEAj67a/7z6PWZ6bjBARyCxCQnIJXlQSeiSLi4CwJYEnFCGSt9w6/1N/cN/R+z7uSrK127X4rENyrxizFu9HyN0gizVsRSYE2uN5f9SV8xytsQQ0v+AcWkpcFabOJcOdnlD0oielvA33x+gaoj7s6m9qf6LCSNCESTeCZkAzpTITKQMo92fwlqXnXd9H01zuobwfhcgkEAoFjgrla6JoU0l3Pglw+d8/u9tbOkt12ZaVnt5Wknef8ytzFRb9vwoevAC1sdGo2BSD2Owfn/wrg2IKgbwLyxxUJMEJMSWYpeCQV6DeDm1ux48/xENSOlaTWTf82Nlr2v9/Zj/ttb70HzFsJqJM39uy2kjQ+4btoqtbhXyHDQg8EAoFjgrla6GVzopXHXrvs6Etwa49KUln4lthez/cxS5Iu+D6xCfDPE/2SKclKJDU3m8wSKzf9KFUF/J8JZKBOR/4c14EvmGiMSNKUWMdgXRCNH0JbnC6CZw3lmgfngKolkM+99R1gEEQIdAgSEU+xGg7T2iwDNw9GWOiBQCBwTDDfxCJJpZlwcvWW77teP7Vtt+1SC/26n+CUzvkKkdM9kKQDrO4EaGFaYj7mCqSa17b8pTVZ9Me8+DW/370niCSi31SSWtf85zcCaenkWQto8SDmCpwLooMzAWuu7AKd9ZZvdbfvANbRtv9OS1IaAL2j84uobwdz3dCraaEdMwO0Cbjlw4n/NSqwkUpSQTZpkEm58KI/ZrIhEO51rc5cLpOxnwVHZGCJtGv3EhgzkfCFdTSJgFUGuQHlhr+GMtjESL3bxStsLnZXQUASuJSmJP8CtO2dBpmiIOArSb23+FTEWv/wg/bhcgkEAoFjgrlrudRNqzCDIMe9e/7VJcFAIJGunYJA4PAksPCAtZsBra8EbSVpDAKBmXRNzAoSuyRZvptUVc+38vpAO4RkPBKrlARFe+dhYI+odpI1RyR+7pEyfyAousoK4iDl0EbQFgOBQCBwH8yXtlhMtdL2aIC3NvxS6c22728fAV1oSSrK2ajfTVdBwA6oEdY2/e83aEDrA+izkMSpESkLSCx/EGAcnYY3N1AYubbhP5P63mzKyvWADz3DXYHcFARopwUpEg3GXPoKFposMJu3teGv+0mb+ecdzHVDL1JWu+594U4bBCMBZ51kXUqML05eci36Dz53QdD3LFittGIRqRfRBgFJoPsiUN2odg3o2pxl1WMy4fsDvbT+JdAYuPhKwDoqoTgXcR0Qvn+1AAK5V0F+AghGdl5k8rnVAigkAmqbugiXSyAQCBwTzFfLRVJhRrXOLPkaCoS2+GKX8dAJtY+UJUuAUkfKGtaavoU3HkBOPghoTSZAbZEEqomKIzFXSJENsTJt0+rh203kdlUBOqTEZG4RlRS4XHYe959HcwsUw+gwmjNCFLgIBAKBwP0wVwt9Mi11e8+jGK6awVNJGpNiERBEnyWvD/yOgclUnPTjCRWxBmleA7FiiZIc6BeVcwNl4lo32aswAlrymVilZI6B258k9CDKqaT6DtDMIXWRSZ2DZf9mWoDbYyLXY0lpAmjDQPXRxXwzRceFtm57Urc9UJtvDOp+1kHBCkmakKg8eHHLGkiXHoNACwz6IoDvNyUCT03gylny+61vgwpLkOVCGE25DtLSr/rPunfZ39HrgP2E66sSyV9ysADRPVQ4g5yZi5Ty4zftPO9LlrgIl0sgEAgcE8w3KFpkFaaF3GiAKxTI5hzeYHKYtdO+G4VUuh8DPnwmbhSSqkaPc1L6E9xsSPZuRhQ5Egn0m0pSBrcKgXXRe9S3uosekOUFzNApoAtKjIde2/UX3eQcoOCCAh6900DUbASvKwDdR1f8xp/1moWFHggEAscE880ULadaNYs/7+75pZxWlvwAagVOZ4kVn63X/FvF5Lp/U8jEYgJ+bmTNCyYAAau07IDsOgGrFGRHEsqpJBV9fx2RoGgGmitTUmIPBCPJd5OkKZBVToBinEFQFBUz8bcW1ffYbYXRQw/fnp7rhl4rploz2SvLLZ/Z8eLdVbstSuWXNOr7PNRxARgxJ0lGJ3BfgOzP3IB0BpKZCK7W1TK4Am+DDQEEI6ekBqqkDNgoRRcchOTQBG4iUn90CtMTyJqrSOUksDxJoDOBIRDWiiTV+37nIx0+xz1cLoFAIHBMMF/aYi60N/LoiHVAWVpY8K3d3R1w35IkUBBjDAKBJaijWQF3wMJ1fwz9p6BVSq6TQDKWzHENSGuAFAKcKdq4DQqUnAZVbEbghkUCs8SjRNx2EuKLl3vAZUaopMQrCdJFoFdSo2V/Ldd32fvnICz0QCAQOCaYb6boqNTNa16t0POX7tn9LjT8k25n5JeIkoSsFRLcmxKLEPi6e4/7t5US+MQlqQKFAUjZNZKkM2mDhB6QxIKKNEgar/rPhPjQSYARWdJgjpHPX2zMDVDSrb8GtJHAVNT3/Mb9U8zP3dwGFNzaQwiKppTeL+mHJd3OOb/j4LN/LOk/l3TnoNkv5Jz/9YP6KmpTtdd61sB2gXBUq+5vHnWw6UosC7Xqg/MRBJKKZXBQALcPqQq13zlgHSz5Qe3xnp8V3Lznz9vgNNh0oYBWc9Ofi8EpwLYBB30GDxCxckCFLIlp8I8XZ3MITRZBtnHHf0c6t1lmeX3HN6iKEUx+cPo02vyapPe9yuf/NOf89MGvB27mgUAgEJgtHni05pw/mlK6fFg/sDRpg70uIM52/CgHrXRf3fSDqFMgEJRAgQTkngH9UiCXEhBMSyDjcXAGyNYCql5B6IKS+heACNMeEQ+ZzfMrAEs2QbG70cnZBC8RiMuMBFBBMQxJGq75noXG9tEKiv50SulPU0rvTymduF+jlNIzKaVPpJQ+Ue147pZAIBAIcLzeoOg/k/SL2lf3+EVJ/6Okv/dqDXPOz0p6VpLW3nY6v/30LesHfHz3LfZgOk3f/KjqsEbg4/4p2hv4vuBRD2jKEOsRBDqnxOcvMesf6LMUwLpqbvjPr0+SaWiSFVhGkyV/HEQhksgD13aB3/ia3VSSNLwInvWuv+Zq90ASGaop6r8jxN8usQSn0coRSSzKOd/KOVc556mkfy7pPYc7rEAgEAhQvC4LPaW0nnO+cfDXvylTCyxJqiXPEnrs/F17PFt93899766nx/4SFld9NxGq+QqYKwIa56S0HVGok6R0AjhiATLod1AHVg2wuhOwHCVJQCogA+mG8RmwLgBTagKs+d0mtPOI3ATQ+JkAhnE5ALRMQFyp78H6CQtApmMG8QSHtvibkr5P0qmU0jVJ/0jS96WUnta+y+WKpL/v/LDJtNDG0HM1lODbNoAo1iPnfX67JF3fWLbb1kDNzcYC2BBAiiahIo4hbbEFxjwBh9Bk4G/SZEMgcsaZ8L8lGIQDfGpSX3UPuCRAVmlie5jUBvRJIKJFapUSHno5JBWk4K7bBtnig8OnLToslx9/lY9/9dBHEggEAoE3hDlruSTtDD06YqfuX8NnR9STVhZ9SuQEJKfs7PpuIpfqKTFaZibWoKQhUJ6cklJ4SJbXb5o2/CA1jiYRSVzSlqg4khsWSNKZwsQi8gJWyyCACuispPhKBYqkTBZZ4DIDv2s5oFehByO0XAKBQOCYYL4l6OQfpBPA/2kCH/pmj6kt1oB1TGiLGVAAx6PZOBOnUL+EFMGeDoCtQFQDiRohsDSJFS1JqhOxbr9pbePwqWwSY5wSvXCJrWWkPwOmuAKFqodr/hqqDRhtsXPdl7yoWoe//c51Q885aWRWLDnR8nVSh5X/NYiQlyTtAU2Z6df9sHzrsV27bX/XH8O46x8qtbtw87gEtGuBP4Bwk9HmuOdvNCjbUSy7tXUbZMKe9cdRggAj2UinpAiFpESCs4B5hCpOjWaTKVrvsaBoBRhCFWDEuAiXSyAQCBwTzNflkqQSFK5w0R/7lubGLpPPrQMlx8kp3/pfAjeF/gBklbZ866qC1d0Jn7oE4yg6fgB8vOFr/IwAna6EnPxq1V8X/UeBxQu0XCogd5ShVDIC6RvcFBJYQ5r4e0Bj1x9DfZcFLqc1QFGtDv+ZhIUeCAQCxwRz96EPx96PnADFt1sg+efxc3ce3Ohl2DZplpI0aPtWAvl+KAAHkJeY9VGAcRTgJtZq+beV8YI/xyRrtpqhBZsILRPQC8s+oN8t+M+63IK3lRW/7wL426fgmRTEhw6AreiG/15T69/BnFku2X7RB+AKtX5y225bwCKBt26v2G3boKjDAGRHFuTqCb5egvezDM6VcRdsvCCAWt7z+yWcZwziZdgFgbJzvvtp0gIPEDy7aR1uYiTnAHRdgINl4TbJQAWMmJOMOFDf9dfcePHwt99wuQQCgcAxwVwt9CSpMG9GrZp/DSdukd4YZA+KWd2JcMAr/xreBC4JoqFSTSBt6o5Pn0xrwI1y188NQLcKEoCDbq0MXAczy2Qm4mNgEJSTn7qAtnjCXxflLZDXQXj24FFPoFBZ58qe3bbqsL3IQVjogUAgcEwwVwu9LKY62e5abVebfhLL1gCUiSNHOQQpVj1tgaSXIVAjtFsy37XEglQEmcQ1TgILD4yXxAckKQM/bHMDZAWv+LcmVAxjDZRHpMU+iEVPbrFgjieA2UuKUFCMT/jeguHq4WcFz3VDH1elrm2tWm0bIHNvDESxSOanxNwoXZD63wSbP7kud+/5K7sO3EmSVIFU+jphrgAWSAE26Qq4AhKQFJCktOR/v+4joG/w/cZngT49kUyg2lyLYC0DwTRSo1dAOI7UV6WZoqNlf82Vo8Nnr4XLJRAIBI4J5mqh18tKF1e3rLZfvH7W7vc8oC0OQVapJO3d9TNL22t+daOtm37lpNVzvu5LreNbjtWYBUUL0jcJuJKAHTBqaoD2VrWgtTQrzx1xPwH3YW3Tn4vJCcaPJlmopNAGMTeJJ7W15Y8Bu2eITtkgLPRAIBAI3AfzpS0mqWYmFp1b27H77QGre9BnVKE5Kq5NAAAgAElEQVTGMvMzu6iv+P1ub4GID0DjChADkTQ8e/iZbZKUQHZk3gRUtgt+cRKBfvc7B00JvRDItdZ2QDINKVoBE4vqt/z3b3zWv+URRctJxx9z74w/b6tfZnV009QfR+OORxAhCAs9EAgEjgnmznJ5cdtLpb+w4vvF7+ycer1DeiCWO76Vt9f3GTTEf90CaoRDICkwehRYsJIaV/3vN7oALBtQnICwXOoN/0ZR7bHbymQROEuJjxloh4xXgbQBSbLqstjK5Dy4xcKCETYABXey4Nuxo1W2RRYjMM/58G/ecw+Kuhv13Z4fjBze9ifm0adu2G0l6c6eP44KZGkuLs2mVikBqT8qSaM1v329BcSgar5LgtQ1HQ0AbRFy7DPZmEigc0Zc/wKIc00z5EeT9QmqZKEAKpAdRskaM1Qdzm7aPEC4XAKBQOCYYK4WeqGp2jXvKp7SbKzuesGsUqKKuAjcMxWQzx2P/MdErO4ptfwptc8EkdpF9St3SBILVGYkMrcguIcUIkmCJtE6oVK0QJcog9sYKmM48scwBfHvxjYjApRD//lNogRdIBAIBO6H+Wq5pKylmhdAOW1qvlBQLZcxKNBcgXT3bs/vl2i4N5tgDLssENhc9INfxPqfkCQkYKHnNrB2ieUvKXVAujtYQ8THXPQBbXEBlAQcQjsPrM/Kz6dDt6AEHnUBjO6yD6m6wC8+BcUwXMy5wAUvMOFgOAFC+ECWV2LZn3tgg5yCK6JAQAttS/BmXQPX5R4IXmYQTK4vzqb+qEgATkzYbOmK3+/W28CBBZgrpB7stM3mogYKeEzBsybumWqRuKr8MQzOMu2n9ou+qGANHMguwuUSCAQCxwRztdAnudCdwaLV9l7fD4oSNwophiFJvR2/Pam52Tnhn+SjIQiKlr6lksH1XmJZtrUbvmUzfcSfiwmYC1IAQtDNQKZu6x0g6EvGTLjlIDBLQfjwtR2Q/QkUV1HdVoD6DguWV00gf7zJ8kAchIUeCAQCxwRztdCraaGtoVeMgtiOxC9fBxasJDXavs+dBALbTeALBlmlIxBPyEAvXJIqYD1WQLGvDmiLFaCRIgsWBssToIdmYj2iIt+zUTms3WPrgqgzVp3ZUF+JHhDRQx+tsLmo+8Komjb8wjwu5stDT1ntujebrdLfSF3BL0n62tZJu60ktQBrZDQGEqVg86+DzaMi3HJamQagaM9GyKsEhSWqPRCYBSwQifH9x03Q9xgEDUm2KnjWkxU2F4kElME8JyCYVvYAIwYIaBVjWNVrBswVgnC5BAKBwDHBXC30ZjnRY4v3rLbjGRX+e6H0SuC9hJ2uHxRdP+FL/t7ZBRoxwOomGYFNWIJuuOXPRQKPrwCug5K4zLb9K221xKzS3JpN9QXCb8898PqSoC+sNUtuCsUicGGC0nYZuOIqUM+31ofrovT7bmxEUDQQCAQC98F8C1woq1l4J/TN3prdr6sPI0lNGBQl1nGznE3h5yngyBFZ3hKqLRLFPqLPUpZ+2ynQwCFFHYoBs20mNfDqgOAsCoqC50EoquVdVuxjegZkEIMYAWFGkEDnBMQiicUtSbUu2APGUD/I+fkP/KEpvV/SD0u6nXN+x8Fna5J+S9JlSVck/VjOedP5gZV5KRhU/hVqe+Q/oVMLe3ZbSdrugOxPsAJLsOEVhf8SNIB2+ohkq4pJ/o5BOn8NbOi7XZ/fnk7OaKORpBFwg4GMx9z3D4r6KpBgJi6JVRjQRvK5pF+QRg8SOhPYAqY1tqFPOv7zGy0DxtZnvGbOk/g1Se97xWc/L+nDOecnJX344O+BQCAQeIh44HGSc/5oSunyKz7+EUnfd/DnX5f0byX9Q+cHluYRfaG9ZbWTpK/vzcY9I0mnFn2RsDGQESUZnTvbXnatJJVAe4a4LyRmdQ+6IKt0xc8ULe4ASdxT/rMm+QaSNKkBbRRyEwIBSfT8QK5GCbI5JcgtJ1RZEpsF3RIhr/Eim4taH/D9e4fvcnm9QdGzOecbknTw+5n7NUwpPZNS+kRK6RP9zdkUXA4EAoHAHIKiOednJT0rSWfefjIPp57fqAQWxT1Qrq4Bg6JEnfH5G35t09UV3/I/fd6/rXQHvgXbAnK/Eiv2QXzB47bfdnrSH3N5EzhWLzO/cSaZpSTQCeiFFSkVB4aLszlJc9C2fsdfF+WQJBaBMXShFQ2edfMF/7128Xot9FsppXVJOvj99uENKRAIBAKvB6/XQv+gpJ+U9EsHv/+e85+mOalbeRZkBSwgxBiBVV8LcJyvrfpWN8g+VqsGtDIaQE+b6pcs+IPuQSVHF2UDlPgCKeyMqCcmt0iSve6COMU5UPjkDlA5hBIjU1CakEhCEMbIZAWMAbK7COq7/vcbry/7HT/nNXNoi7+p/QDoqZTSNUn/SPsb+b9MKf2UpKuS/pbzw8a5tOVzF+u+v/3ikn91IbovktSbgOAecOdMQAD1zg4IigIKIJHllaTWgh9kJG1JpmgGB+EEBOASLLySSeYl4KEPiWQsoE6OTgDqJMjQlCSB4hmkJmwBaptWLSCWVoANHXqf6je37ba9J5iulAOH5fLj9/mnHzzksQQCgUDgDWDONUWnWq57yRAToOVC5HP/9MZ5u60knVj0aYCLDd8q/epnL9htWxf8TIghCFxSq5QERcd7QCkPKPCVNWDBgoSe8Qi+CjUwd+QGQrJb+yQwO0NXHHCjZKIy6rNZlesgQxowl2mm6N5f8IkR5eDwy3GGlksgEAgcE8zVQq+nSustz8f0oavfYvf7ttO37LaPnfLUHl9Cf+JbpaQU3qkn/HFs7/lRqinwUZagZJ4kLQCaYwWSkIhfHPUL0vlrQDJBYlIBxTagFxK5ggRkAjYANXQFxhNA4eey5Vvzo5MgBjL2133nBuiXsBckFX1wG4OyAg7mW7EoF9oYe5zx96xftftdAMUwPr3nuzooZsPrkDoL/ks+KP3No7/LKpoT3nqj6b+4wx5wEwFXRwLByJIIaEkak+Ae4EhPgLgaYdokEOcsgKtKkjIoRCGwoZP6qhnsZN11f70t3GEB4mkdHG6jwy8wEy6XQCAQOCaYq4U+mpa60fO4l4Re2CiAZKXdch9NwAF/cWPFbntiyQ+29oYg+7PhW9HDGnAFQBD5XJJVOiUBOCI7DCzu/c6B1U1KuoFx1Ld9az6BuSCBS0lqbIJbxTlQTtHMKpekAtRtJVoukDegaR3c3Fiittfn4XcZCAQCgYeBORe48CmGLr1Rku4NfC0Xmlh0e9dP6rl00k9wurHtZ4nVQcLSEBSqJj5miRX76N/w56225scICKUuF6CQc5/dVhIo/JwIbRFY6OMVv23rlr8uMkhYkqTRo/67ugAS38gtiCSA17sgw/a2f5OWpMlb/HWfizd5ULRIUzsDdLXhk1BJYQma+t8C4lwvbPr1SklRB+JG2QU1UOlyIhv62cfv2m1vvuDLH5PUcRKsa55lLy5h21QbfvC5dhIUEQFMmyHYdEvCsZc0nfgrqQ8KlBQdUH9U/oE8XPW3vb1Hl+y2EhPzSpPgoQcCgUDgPpirhd4qJ3qic8dq+6W9+0qsfxN2R75VeqLFLDGCTsvnMlekxiOIzJw+sWu3Je4ZSapAQQWSvVtf9l0uk7s+J78NMmwphqCAR1r2Lc16w7+BkLyHOqgfS7Nmietu2vP7Lhb9eUtAy6VqAf4+lM+t7fpjniwdPikhLPRAIBA4JphzUDSraVIMz7V8S5Nga8i0QUkQjpRoI9bxcgtYsGNQXHu7bbeVmE96tA5uQsTSPO3HVois8s5N5isteqBINAl0XpoRLRNkc1a7zHIsl4AlDeiFuQfokCTAD5oO1tgWudgFFOrq8H3oc+ah13S17wXAmqU/MY92/DT653bP2m0lxnHfa/ob3hLYpMmhMgKHSnMBEmFB+yFgjZTAHdAALok+EBOrr/pBQ0nKy/4GOQUb74RUhQJsFJJ1CXkDqgb+misAo2k6ANsTODQJD72xy1wug9P+HrBwk605B+FyCQQCgWOC+bpcUlbN5Aav1f3qP1d6vlD8yabfryR1QYELEjQ80fbHsTP0g75kDKQYhiS16r51vNz2rY/+aDYCaMTarcPbCjFi84a/hpB8LqD1EY5qbYvVbxqf8NtmIghHs3fdMQBPzrjNbN76nv/9uhdgaSgDYaEHAoHAMcF8E4uUtVh6PrSz9R27334TKAxOmfVxresnC53r+IFcIsu72fNP8gbQntna9jNsJWn5lG91L9YJhdO3Kza2/DFn4NudUIVBYj0uA8U+MOYEzLFqD2SKrjMpYWRJg3gCuYFkcKsAZYIFQmj74wAFMYoZJBbNXT53x6xAOwB6mEMi4gMjPgsgU5QUlN4ZMelaF92+3+/pNcYk2ur6B8tO4buJ9jZ9ts3qSZ9bPun4Abh+Dz4PwKoglaHIsUK074sO2JnwPgNOFiCDMAXMHHK4EVGscsgO+vYVv6bo8BxjVjkIl0sgEAgcE8zVQpf8WqE3h74U7e2hL4izN2aW2HLDdzOQvkkm5d5t381w+qIvENYAol+SNAGUyPNrvqVCBNNW2z4PfaPrW/4Lbd+al6R+37/iT0eAew10UQSeRwG44sQylsQ0ZrcAxx1oymRwY2rf8ttWLTYXe2/1XbTFOLRcAoFAIHAfzNVCbxQTPbKwYbX9wPPvtPt917lrdttOjQV8ru75nKyzC75Pugb87UtP+tbjeOpbbbtDeFvp+LcVKlPsgljduy/4EsXFGlsXbTAXu3v+DZJYpUjrBFjRCQaIp3vA6q4Dq7QJan8CCm53nWi52E0lSSvP+TfTwYXwoQcCgUDgPph7gYumWa32hy5/3u63O/EtzX7FdCpOL/isiq9snbLbrrR8C+9ix/eL3+r7p/7tEbAcJXWavhU7AVTECyu+VfP8XT+JDFndsNZYj7JiTDQ6YI6Bb54AUTIliSQLAZZLCYqIkJKHlU/A0sIdlnA2XvNvkDWg+2L3eeg9vgaypLGZpvVI09dn+dzkgt32VJNJqnZ7fvGFt57wpIEl6cqO3++9oR8U3Rz41MJTi+w+SfjiL971g0PvuHDdbtu/53+/1pp/aJINQZJ6d0CVrGWwSY9BABVwr6cn/DHUW2yjGd0DOyQIXhKJ6doS0EYCbq3+aWYALn/Jz59Jk8N3S4bLJRAIBI4J5mqh11Ols3Xver1a+vKrNSCftlZjVumNwg+sETy1ettuSyz0xcZs3CISk6P9lvO37LYboCbs6jk/8EwCgSQhS2JWN3HmlDV/LdfP+7dNUrSCavw0TwFJY9A3ocmOgG5Pc0jq0jL3U/ey7/Js7By+yyUs9EAgEDgmmHOR6Kyl0vNrblV+cGEC5NNujPyEJUm6O/ADh48t+n5/Uti6AbThR4C2uAE0YiRWaINo1dza9q0aUqjhDCjHt3mPBYjby0BNctf3Mdc7LNnLRQEsY1IMXJIKEOgkGA/B9rTtr7eWx5yWJK085/vEJWm05r9TU6D74mLuWi4bE/biOPi2zgt22y/211Hff2nt63Zbt3iHJH3u3jm77SkgtTusAMcWXq1Jduv1Ld9Vtbrou9e2gZ7M9dt+YHbtFNO12d3zx7Fywn9+Wzf8eavtACGvRyChGoC4Ubp3QJUsIJVMOOv9M/6B1bvI9qvGts+KqRYOn6UULpdAIBA4JpirhT7Ope3yuNy6a/d7Y+RbYhPgkqDolH6g7PKKf+8jwUtCWzzTYRTOLdD3SWB1j8H3a4IiG+PabOq2Sux2Q4KzJPuzApXuV4FWDal3K0kjwIcnqo9EA4fUKq1A/HvcoQUuSCm80HIJBAKBwH3whiz0lNIVSbuSKkmTnPO7X6t9PVVab3i0xVbyrd0eKFqxWgfV6CVtjoFWN+zbhVu2b7/tbDRUJKk78v27pzu+z/baFlCoA99vadGn040qdnNrgUIi1zf8eVtZ9tcQCeSSW94YJDdJMChK4jZbvik9XQUUwD1gx8K45QT4xZub7Fbo4DBcLt+fc7b8I8NpTV8dnLY6/e4lP939VN0PaG1PQFBG0s2B/zJ2a/4CJBmrRK7g/IKfRv8nG36GrSStAenaPVDAow0kBQg6gJOfSQBOzE1EgnvtBhDcAoHcjTsgnwJ6AhZWfMbPBMgDNy75RsFg02cSmUXTJLHqRpLUuuO/I4PTUVM0EAgEAvfBG7XQs6QPpf2oz/+Sc372lQ1SSs9IekaSls61VZpFtu5MfItirQS0PlCuTpKWav5x/qd3z9tt//KFL9ptN0Z+JmUHjHe9zTi2dwAnvwlcEucX/VvFJ55/i922dXbTbktKDUrSBLj5CK+buMxK4uoY+WOor/oWtyT1N3xLs30SZIAD9wwZcQIaMVOgPSNJgzP+XNR32Jpz8EY39PfmnK+nlM5I+sOU0hdzzh99eYODTf5ZSTr79rXZZCAEAoFA4I1t6Dnn6we/304p/a6k90j66P3aL5ZDfffSV6y+70z87MFO4Vulp2osgUTA5b65DIoom8WyJWkAkoWW676tsjFk8YTbu76F/tQpX6uGFB25OCOr+07XvwVJUgNorjyx7qtw3tz11/0YaJ0013zfbqPBNEbGe/5thdBOkb4OtKRdNPaYEx2VrEvMW+DgdW/oKaWOpCLnvHvw578i6Z+85v9RVmlGGXpT/2Feavgp95/tX7TbSrKlCiSpC2qKbtVApiHYpEmm6Nfu+NriknTxpB+oJvVVCQPjFNCn/9qm//2WIA99uQlS/4EMwhQEUGtEyAvUj6UB4nLB75tw3DNwjYjUYgV7/6TF5mL5y77BuPv44VcseiMW+llJv5tSeqmf/z3n/G8OZVSBQCAQwHjdG3rO+XlJfuFPSZUKdU3Lm4hovaXhZ5XukTQxSWfrfuDw6TW/tunuBBQFAPjC1lm77WKbBb9Otvzg8+dv+1o16yv+HK80AC1sBASbAF1QYjehu3u+O4cEUEkGKrHQSb+S1Gz5LrPR0H8mCyC7dbzpv9dVE9RXhbTFnbf6ZI5yFAUuAoFAIHAfzF1t0ZXF7QJL+l7lB+vuDpl62sbIDxxebAEf8wSUD8v+uUsyHh8/4cce9vv2l8sKSEIiQdHR1B/DEriBLDeYD30CngkJoC6AmwIpCbix5d8S2h02F/2u/64uLvvrognmjVAdwKPTtMZ86ItX/e/XO3/4t/Sw0AOBQOCYYK4WuuRbm+ebvrV7pub7YL/3xJfstpJ0ZXDKbvt8z2+71vATLEjq/wAq5RHc7IJCFMB6PNEEeugj36rpEx86SISSpP748ClnkrQFdNYvrPkJWds1f97ILUGS6qvAkgbfrwl0bYolIJkAdOQpBmf920ptcPg+9Llu6GWaaq3m0c7O1v0NvZ38K6KbqfoSSBB1ofQX1emGf0n89NYlu+36EuTZA5zr+H1//oYfnB2e8JfhABxuJ4Db59qXzthtJenpdz5vt72+5wf4z636c0wojhNQc3O8wLR1xsDNRyonDQHPvtbwD5WqBoLJPbZfTOuEPhnyuYFAIBC4D45sCbqlEtDTgD7Lp/d8LRBJesuCT4m8OfQtMWJ1E0vsQtu/2ZSQnlaBcQzO+EuLlLYjdMF23bc0zz/pZ3NK0mLdvxWOgKW5AhKWrm6csNueBMqMxFVFQaR2J2DeUL/AjO2dZu6ZhXv+TWGycPj2dFjogUAgcEwwVwu90NS2vEkx6Qqo0L+tc91uK0n/bvNJu+0THd/Ku9zxKYOEtkhols2SBQJrIMuCqAYSbXgiKUA0cKg3k9xuSCo9kQk4vezPG7mt3KpYSnq371NwF2dUCg+V+QMyAVAFAdEcG7u+Ne9irht60v6m7uAdrRfsfq9P/KvnKLOv/LbFm3bbK31fO6RR+JvppZYvSEUYMcTVIUl/AuSBL4ICJaTO69kFn9H09b01u20DZFJKUhfkEZxZ9Dfeuz1QIWvBd8/c3vMNJKprQ1xKRBJ3r+u/q82WT0goQMy3NmTvSAHqhHbPHb5rK1wugUAgcEwwVws9S5qaZ8hy4VsfXwbKjJS2OM6+9UGstnHh93t37FtXhDo5Jilzkr715A27LbH+/92Lj9ltv/2cr5ezNfA5zyTwLElF8jMvCa3vwrJ/A/mz5/0SgpfOb9htUXk9Sf1rvovm5LfcstuSmrD9of/uFWP/WZcjZqGPOqCQCKREOggLPRAIBI4J5pwpmlRBq9DB5sS3lh4ByowS80mToOF6y8/yIyXoSIDx9pAFv3ZBQLJR+D7pCyv+XJDncabjz8Xnrq7bbSVpad33M1+74fvyly/7Qfta059jktnagFmzp57wA/x7wJImaplIpRJsQVQPvd719wAYwrIw1w19qqRB9h7SzcrndO9WflrzXVCrVJLOgIzOE3U/VZngxf6q3ZbI8hJOt8TcKDtjfxxfvAqkds/6wda3rvqso0YLVukBbpQ8AO61nn94n1jx5YxLwDqCxA5NwGZKhMpI272Bb2yMQaboaJHNRtUA9WMHkSkaCAQCgftgvloummqp8AIdf7zr87+/te1THL80YFfrevKtBLe8nsSCrcQyJjz0M02m+9KvQOAJjPm7n/R1UQiIkBeR2pWkF14E5ftAFiOhAO71fKt0DQhdTWCAeAtI8yYwF7oNyA7nwe0YmLHgNZUk1fqzK57hICz0QCAQOCaYq4U+yjVdHXkSs4ulH3T6VPey3fa7l75st5Wkj+0+brclVvcEtD3b9Kls/SnI2gNzLEmfuecX2G6CwBrxR8+qOPNSk81Fddp/JnWQTEMybE92fKt0OPFfdUpbXFmZTewogVvF5jU/5lYDVje10EdLhBLJ+nYw1w29kSY2y2QMMjrf1b5ityX8donxugWSDbsT/zp5tuFvHsvyv9/ndpn76TtOX7Hb/tEtn1v+vee+arclQV9SX5XKIBCZ4nt93w12c8MP2r/9gp/FTNCGvgAiKDYGWcHdkW+caAG8fEAPHRTIkiQVBZEViKBoIBAIBO6DuVrow1zT14ZeIQFidbvZp5I0gneotZpPDRuXwHVQ860aEmwtgMwU1XI5A24K/+kjn7TbEvExEqR+98mrdltCDZWkpbr//Mg8k9qmkxlVhfraFgj4SjoN+P4LNaC5AubtHuDko6Ao3CFB0vpMeOhhoQcCgcAxwdzVFl1r80zp+ygLYMHuTlmlbbdknsSUHEl26/d0nrPbfmj3W+2271r26Z6S9O0LV+y2Jbgp/FH3rXbbs3X/ltADAWJi+UvSkDpXTRALtl3zo2okM5nq2pD2bfD9SL8bS75uz8YS0X2h9UfJ3NEUrgdjrhv6YjHQ93S8Is0jAfeF/IDWVuVvpJK0BIKoRJd9u/IXYCv53+9Cw5faXTZzAv7DOPyX8V7lC4pdbPjCUV8bnrbbkgDcrSHLIH687Weh7rRmUyeUuCReHPgupbt9/9lJUgsdQn5b4tZaqPvvSLHoj6HqMidGmqHWuoNwuQQCgcAxwXxdLinbVh7RctmSTwujLpdLdV946ObEt4Le2fIDdmTMxM3QSowI+9WRF9CWWKD6XM13BxDcmfjiY8/3vPyIl0ByDlaBxs9Kzb81kRq229lfQ48u+2teYppAWyP/ZtoERWA6oCJTKkG1KbhDThZ9928G1Y1chIUeCAQCxwRzzxS9MvYsIbf2qCR9eeir9dHgF/G5D6Z+ZuJWArcK4G/fnvj99irAsZJ0qu77godgLkj92Gbh+z/J91ups3gCCYoSXzeRl94ByWlE2vlGj8UTyPd7YQvQQ/3KkkhNsg3qmo4vsP1isOffkKe9w99+w0IPBAKBY4L5lqDLyU7sIVbplYHv/3x72y8gIDE/rKv1Lkl/cO8v2G2f6PiMivWG74++1GC+UmI9fmjX/37fteyn/rtFxiVpr/D9xm/r+OX1JOb335n6a/nu2F9vPVDy8NGO/6wvtX2mlCS1wK3p+0/7FNwVcEsnsaMbq/4tgSacvdj14xp3dhmbyMF85XPTVMulR0Uim8d3LvobAqHTSSyLkQTKnl72a2OeB1TE8zW/LXkRJWkDzN17l30RtNXSDxp2Cv+6TL7f103RuJewVvr5CcR92AAU1faaPxfn6/66IGteYnkgBI/UfDrrZwaP2G2J65BoB0nSVt0/vAcLTFfKQbhcAoFA4Jhgrhb6OJe6bZaAuzr09SSI3goNim6AjM53LPhWN0lCIsqTBB1IW2yUvpvh7Q2/unsFMixKEIA7B6xomnB2CbhcxsBuIgH+v7TgFwZ5EgR9qZVXgrVcgQzi58a+tftkczbKk29vvYjaj1f9d5WQKP6O2S4s9EAgEDgmeEOmX0rpfZJ+RVIp6V/knH/ptdoPpnU91/MskMWa7x8kJ91aw7faJOYXJ1Z3A9wUZmWht4G/VpIahW/RLwFdaAGrjWCQ/Tl+uvV11HcH0OSq7LclluZ5EHtYKQDFEchuSFKZfLtwmP24xqWa//0qsIQGJC4Gbd4B2C/I3uLide8UKaVS0v8s6S9Luibp4ymlD+acP3+//zOc1vS1rudKIdzWp1d8VwfRApGk3/y/v9du+6N/9Y/ttoTHjIps+LdUlM0pSXVwAHSBjuhzQ7/QxotDn5z8eMtnB33kni8QJklPLvl9bwHXAWH8bJS+UNl0wioyEXSBwXFlvGa33ar8nApiIFVg3RN3oESlvMn267nX3ojL5T2SvpJzfj7nPJL0f0j6kTfQXyAQCATeAFLOr++6m1L6UUnvyzn/Zwd//wlJ35Fz/ulXtHtG0jMHf31Kkk9EnR9OSfJq4x0NvJnG+2Yaq/TmGu+baaxSjPeN4C055we6F96Ic/bV7iLfdDrknJ+V9Owb+DkzR0rpEznndz/scbh4M433zTRW6c013jfTWKUY7zzwRlwu1yRdetnfL0piaZiBQCAQODS8kQ3945KeTCk9mlJqSPrbkj54OMMKBAKBAMXrdrnknCcppZ+W9Afapy2+P+f8uUMb2XxxpF1Cr4I30/1Bn9cAAAQ/SURBVHjfTGOV3lzjfTONVYrxzhyvOygaCAQCgaOFyBQNBAKBY4LY0AOBQOCY4M/dhp5Sen9K6XZK6bMv+2wtpfSHKaUvH/wOaqXMDimlSymlj6SUvpBS+lxK6WcOPj+q422llP59SulPDsb73x58/mhK6WMH4/2tgyD6kUBKqUwpfTql9PsHfz/KY72SUvqzlNJnUkqfOPjsqK6F1ZTSb6eUvniwfr/rCI/1qYM5fenXTkrpZ4/qeF8Lf+42dEm/Jul9r/js5yV9OOf8pKQPH/z9KGAi6edyzm+T9J2S/kFK6e06uuMdSvqBnPM7JT0t6X0ppe+U9N9L+qcH492U9FMPcYyvxM9I+sLL/n6UxypJ359zfvpl/OijuhZ+RdK/yTl/i6R3an+Oj+RYc87PHczp05L+oqSepN/VER3vayLn/Oful6TLkj77sr8/J2n94M/rkp572GO8z7h/T/vaOUd+vJLakj4l6Tu0n21XO/j8uyT9wcMe38FYLmr/Rf0BSb+v/WS5IznWg/FckXTqFZ8dubUgaVnS13RAujjKY32Vsf8VSX/8ZhnvK3/9ebTQXw1nc843JOng9zMPeTzfhJTSZUnvkvQxHeHxHrgwPiPptqQ/lPRVSVs555eUva5JuvCwxvcK/E+S/kvpG3XtTurojlXaz8T+UErpkweSGtLRXAuPSboj6X89cGf9i5RSR0dzrK/E35b0mwd/fjOM9z9CbOhvAqSUFiX9jqSfzTn7EnsPATnnKu9fXS9qX8Dtba/WbL6j+maklH5Y0u2c8ydf/vGrNH3oY30Z3ptz/nZJf0377jdfCnS+qEn6dkn/LOf8LkldvQncFQfxkr8u6f982GN5vYgNfR+3UkrrknTw++2HPJ5vIKVU1/5m/hs55w8cfHxkx/sScs5bkv6t9n3/qymll5LYjopExHsl/fWU0hXtK4X+gPYt9qM4VklSzvn6we+3te/jfY+O5lq4JulazvljB3//be1v8EdxrC/HX5P0qZzzS+W2jvp4vwmxoe/jg5J+8uDPP6l9X/VDR0opSfpVSV/IOf/yy/7pqI73dEpp9eDPC5L+E+0Hwz4i6UcPmh2J8eac/6uc88Wc82XtX7P/35zz39ERHKskpZQ6KaWll/6sfV/vZ3UE10LO+aakF1JKTx189IOSPq8jONZX4Mf1H9wt0tEf7zfjYTvx5/1L+w/shqSx9i2Jn9K+7/TDkr588Pvawx7nwVi/R/tX/j+V9JmDXz90hMf7bZI+fTDez0r6bw4+f0zSv5f0Fe1fZ5sPe6yvGPf3Sfr9ozzWg3H9ycGvz0n6rw8+P6pr4WlJnzhYC/9K0omjOtaD8bYl3ZO08rLPjux47/crUv8DgUDgmCBcLoFAIHBMEBt6IBAIHBPEhh4IBALHBLGhBwKBwDFBbOiBQCBwTBAbeiAQCBwTxIYeCAQCxwT/Pz89npyvaYtzAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in cols_1:\n",
    "    if __name__=='__main__':\n",
    "        Process(target=loop_X,args=('Test',i)).start()\n",
    "        Process(target=loop_Y,args=('Test',i)).start()\n",
    "        data_X,file_list_X=loop_X('Test',i)\n",
    "        data_Y,file_list_Y=loop_Y('Test',i)\n",
    "        for i in range(n.int(data_X.shape[0])):\n",
    "            if data_Y.loc[i][0]==0:\n",
    "                save_loc_X=fig_path_1+\"Joint_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"\\\\Test\\\\Damaged\"\n",
    "                save_loc_Y=fig_path_2+\"Joint_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"\\\\Test\\\\Damaged\"\n",
    "                m.specgram(data_X.loc[i][0:4001],Fs=50)    \n",
    "                m.savefig(save_loc_X+\"\\\\\"+\"Spectrogram_X_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"_\"+str(i)+\".jpeg\")\n",
    "                m.specgram(data_X.loc[i][4001:8002],Fs=50)    \n",
    "                m.savefig(save_loc_Y+\"\\\\\"+\"Spectrogram_Y_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"_\"+str(i)+\".jpeg\")\n",
    "            else:\n",
    "                save_loc_X=fig_path_1+\"Joint_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"\\\\Test\\\\Undamaged\"\n",
    "                save_loc_Y=fig_path_2+\"Joint_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"\\\\Test\\\\Undamaged\"\n",
    "                m.specgram(data_X.loc[i][0:4001],Fs=50)\n",
    "                m.savefig(save_loc_X+\"\\\\\"+\"Spectrogram_X_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"_\"+str(i)+\".jpeg\")\n",
    "                m.specgram(data_X.loc[i][4001:8002],Fs=50)    \n",
    "                m.savefig(save_loc_Y+\"\\\\\"+\"Spectrogram_Y_\"+file_list_X[file_list_X.rfind('_')+1:-4]+\"_\"+str(i)+\".jpeg\")\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}