projet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.signal as sp\n",
    "import scipy\n",
    "import math\n",
    "import bitarray\n",
    "import random\n",
    "%matplotlib inline\n",
    "plt.rcParams[\"figure.figsize\"] = (14,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "552\n"
     ]
    }
   ],
   "source": [
    "#message to transmit\n",
    "ba = bitarray.bitarray()\n",
    "file = open('message.txt', 'rb')\n",
    "ba.fromfile(file)\n",
    "data = np.array(ba.tolist()).astype(int)\n",
    "text_size = len(data)\n",
    "print(text_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Encoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n"
     ]
    }
   ],
   "source": [
    "Fs = 22050 #sampling freq. in hz\n",
    "Fc = 441 #frequency of carrier signal\n",
    "baud_rate = Fc #need to be less than Fc\n",
    "modulation_freq_1 = 3000 #modulation frequency in hertz of first sine\n",
    "modulation_freq_2 = 7000 #modulation frequency in hertz of second sine\n",
    "sample_per_bit = int(Fs/baud_rate)\n",
    "start_sequence = [+1, +1, +1, +1, +1, 0, 0, +1, +1, 0, +1, 0, +1]\n",
    "stop_sequence = [0,0,0,0,1,0,0]\n",
    "print(sample_per_bit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2970521541950113\n",
      "572\n"
     ]
    }
   ],
   "source": [
    "#append start/stop sequence to message :\n",
    "data = np.concatenate((start_sequence,data,stop_sequence))\n",
    "data_size = len(data)\n",
    "#transform 0 to -1 in data \n",
    "data_tx = np.ones(len(data))\n",
    "data_tx[data==0] = -1\n",
    "T = (data_size/baud_rate) #length in sec\n",
    "print(T)\n",
    "print(data_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "#upsample data :\n",
    "data_tx = np.repeat(data_tx,sample_per_bit)\n",
    "#modulate carrier with data :\n",
    "tx_signal = np.sqrt(2) * np.sin(np.arange(0, len(data_tx)) * 2 *np.pi * (Fc/Fs)) * data_tx "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<StemContainer object of 3 artists>"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAz4AAAD8CAYAAAC2A3H6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xl8U9edN/7P0W7JmyxbXjC2MRjbGAwBQ9hCbENCQkiTp0n3Nm26pHvn9cyvz0zbmUknnek8nZn2NfNr0yWdNk3SJd0ynSRkIQFMCEsCJizBGzZgsI1t2ZbkRbt0z/OHJMch3nWlK937fb9evLAtofOVse8937N8D+OcgxBCCCGEEELkTCV1AIQQQgghhBASb5T4EEIIIYQQQmSPEh9CCCGEEEKI7FHiQwghhBBCCJE9SnwIIYQQQgghskeJDyGEEEIIIUT2KPEhhBBCCCGEyB4lPoQQQgghhBDZo8SHEEIIIYQQInsaMV6EMfY4gL0AbJzz1dM8Xg/gWQBXIl/6b875d+Z63dzcXF5WViZGiIQQQgghhBAZOn369DDnPG+u54mS+AB4AsCjAJ6a5Tmvc873LuRFy8rK0NzcHEtchBBCCCGEEBljjF2dz/NEWerGOT8CwC7GaxFCCCGEEEKI2BK5x2cLY+wcY+wlxlhNAtslhBBCCCGEKJxYS93m8haAUs75BGNsD4D/AVAx3RMZYw8BeAgASkpKEhQeIYQQQgghRM4SMuPDOR/jnE9EPn4RgJYxljvDc3/OOa/jnNfl5c25R4kQQgghhBBC5pSQxIcxVsAYY5GPN0XaHUlE24QQQgghhBAiVjnrpwHUA8hljPUC+DYALQBwzn8G4H4AX2SMBQF4AHyYc87FaJsQQgghhBBC5iJK4sM5/8gcjz+KcLlrQgghhBBCCEm4RBU3IAng8Yfw/Lnr6HW4J7+m16px15pClOWaJIyMkIU52+PE4Q4bBOGdieFVRZnYVZ0PjTqRxSgJWbxRdwD/c7YPIxO+ya+lGzS4Z90S5GcaJIyMEJJsOgbGsb9lAMGQMPm15dZ03LG6AHqNWsLI5IUl84qzuro6TgeYzq1/1IOnTlzF0yevwekOAADCO6oAzsMf76yy4tPblmHLcgtY9EFCkkgwJODllgE8fvQK3rrmBPDun2MAWJKdhk9tLcMHNy5FVppWokgJmd2loQk8cawbfz7dC08ghKmXXM4BjYphb20hPr19GWqLs6ULlBAiKUHgaOqw4fFjV3CsK7z1/cb7Xl6GHh+/uRQf21yC3HS9RJEmP8bYac553ZzPo8QndXHO8bPXLuP7r3SAc47bVxXg09uXYWOZeTK5sY158Zs3ruI3b16D3eXHpmU5+NnHNyDHpJM4ekLe0WWbwOeeasaVYRdKLUZ8amsZ7t9QjAxDOLkJCRyvtg7i8WNXcPKKHSadGj/44FrcsbpQ4sgJeUdI4Pinfa144ng3dGoV3reuCA9uK0NNUdbkc66OuPDE8W788VQPXP4Q9qwpwA8+sA5pOhrRJURJrjs9eOjXzbjQN4aCTAMe2FqKj2wsgTnSP+Oc4/XOYTx+7AoOdwxBp1HhkffV4COb6KiX6VDiI3OBkICHn72Ap0/2YM+aAnzzzmoszTHO+HxvIIQ/Nffgn15oQ1GWAb96cBOW0fI3kgTeuDyCh55qhk6jwj/fuwa3rcqHWjXzrOSFvlH8/f9cwLleJ/5uTzU+s30ZzWISybl8QXzt6TM42G7DJzaX4ms7K5CXMfPo7Jg3gCeOdeM/DlxEbXE2fvFA3azPJ4TIR8v1UXz6iVNw+UL4zj01uHttEbSzLOPusk3gkedb8HrnML5Yvxz/5/ZKqGa5TyoRJT4yNu4N4Mu/O4MjF4fw5Ybl+P9um/8vwOmrdnzuqdPgnOO/HqhDXVlOnKMlZGZ/OdOLv/nzeZRaTPjVpzbOmrxP5Q2E8L//cBYvXRjAA1tK8fDeVbT3h0jGNubFp588hdbrY/jH99XggS1l8/63r7QM4Gu/P4PcdD2eeHAjVlgz4hcoIURyTe02fOV3byErTYvHH9yIqoLMef27YEjAPzzbgqdPXsPe2kJ8/wNrYdDSTHEUJT4y5fIF8cHHTqB9YBzfvXc1PryIKc/uYRcefOIU+pwePP7JjdheMe1ZsoTE1a9PdOMfnm3B5vIcPPbxOmQZF7ZnRxA4vvdyO35+5DL2rCnAox9ZTyNgJOFsY178r58ch93lx6MfvQk7q/MX/Brnepz4zJOn4A8K+OMXtsy7I0QISS0vnO/HV59+C9WFmXj8UxsXXOSEc47HjlzG915qx+byHDz16Zuh09CgHzD/xIe+WymEc46/feY82vrH8PNPbFhU0gMAZbkm/PcXt2KZxYSvPv3Wu6rAEZIIJ6/Y8cjzrdhZZcVTn755wUkPAKhUDN/aU41v3FmFF98ewE9fuxSHSAmZWSAk4Mu/ewt2lx+/f2jzopIeAFi7NBt/+dI2GLRqfOHXpzHqCYgcKSFEahcHx/H1P53DTSVm/PHzWxZV2ZExhi/cuhw/+MBavHHZjn95sS0OkcobJT4p5FfHurHvfD++vrty0TfYKLNJh59+fD2CIY4v/fYteAMhkaIkZHa2MS++/Lu3sDTHiP/48LqYR6s+v6Mc71tbhB+80oHXO4dEipKQuf3fF9txqtuB7923BmuXxladbWmOET/+2Hr0Ojz4+p/OvauUOyEktY17A/jCr0/DpNfgJx9bD5M+ttNk7ttQjM9sX4Ynjnfj2bN9IkWpDJT4pIhT3eHM/rZV+fjirctFec3yvHR8/4Nrcb53FI883yrKaxIym0BIwFd+dwYT3iB+9vENyDTEXpKaMYbv3bcGK6zp+NrTZ9Dn9IgQKSGze/7cdTx+7Ao+tbUM96xbIsprbizLwbf2VOPV1kGawSREJjjn+PqfzuGq3Y0ff/Qm0c7w+sadVdhYZsY3nnkb7QNjorymElDikwJs4158+bdvodichh98cK2oFax21xTgC7cux9Mnr+GPzT2ivS4h0/neS+042W3H9+5bg8oC8TZxG3Ua/OzjGxAIcXzpN6fhC9IMJomfzsFx/O0z57Gh1Ixv7akW9bUf3FaGvbWF+MErHTjaOSzqaxNCEu+xI5exv2UQ37yzCjeXW0R7Xa1ahR9/dD3SDRp84denMealJbLzQYlPCvi7v1zAmDeAn4o0Qn6jr9++EluXW/DwsxdotJzEzfFLw/jl0Sv45JZS0UbIpyrPS8f3P7AW53pH8eihLtFfnxAgfFbP//7jWRh1avz4o+tF31jMGMO/3leL5Xnp+Os/nsWELyjq6xNCEqd9YAz/vr8Dd60pxGe2LxP99a2ZBvz4o+vR4/DgX16g/T7zQYlPkmvqsOHV1kH81c6VqC6MT6UfjVqFf7u/FgDw3RdoyRsRXyAk4NvPtmBpThq+KfII+VR3rC7APeuK8NiRy7g64opbO0S5fnfyGi70jeHbd9egIEucJSs3Muk1+Lf7a2Eb9+GHBzvj0gYhJL4453j42RZkGDT453tXx+28uU3LcvDg1jL8obkH53qccWlDTijxSWK+YAiPPNeC8lxTXEYKpio2G/Hl+hV48e0BWl5BRPfk8W502ibw8N6auJ878K091dCqGL5D+9aIyOwuP76/vwNbyi3YW1sY17ZuKjHjQ3VL8fjRK+iyjce1LUKI+J47dx0nr9jxN7urYDbp4trWX+2qQG66Hg8/e4EKo8yBEp8k9ovXr6B7xI1/fF9NQuq0f25HOUotRnz7uQvwB4W4t0eUwTbmxX8e6ER9ZR52VVvj3l5+pgF/tasCB9ttONg2GPf2iHL8+/52uHxBPHJPTdxGb6f6mzsqYdSp8e3nWpDMZ+4RQt5twhfEv7zYhjVLsvChjUvj3l6GQYtv7anCud5R2q89B0p8klSf04MfHerEHTUF2LEyLyFtGrRqfPvuVbg05MITx68kpE0if997qR3+oIB/vDsxnUUAeHDbMqywpuOR51upVDsRxbkeJ35/qgef2lqGlfniFeaYjSVdj6/vrsSxrhG8dGEgIW0SQmL3o4OdGBzz4Tv31ECdoIO17123BJvKcvCvL7fD6fYnpM1URIlPkorutfn7vfHbDzGdxqp87Kq24v8/0InBMW9C2ybyc6rbjv8+04eHdpSjLNeUsHa1ahUeeV8Nrtnd+PmRywlrl8iTIHA8/FwLctP1+KtdFQlt+2M3l2JVYSb+eV8r3H4qdEBIsuuyjeOXR6/gQ3VLcVOJOWHtMsbwyD01GPUE8INXLias3VRDiU8SOn3VgRffHsCX6leg2GxMePsP761BQOD4j1fpF4csHucc332hDUVZBnypQZyzpxZi24pc3LWmED853IXhCV/C2yfyse/tfpzrceKbd1YhIw6VNWejVjF8554aXB/14vGjNBNPSLL715c7kKZT42/uqEx429WFmXhgSxl+++ZVXB6aSHj7qYASnyT0o0OdyDHp8Nlb4lvQYCYlFiM+vHEpnnmrl8pbk0V7vXMYZ3uc+EpjBYy62E6pXqy/vn0lfEEBv3idOoxkcQSB49FDnViZn45741CGfT7qynLQWGXFL49egYvKWxOStFqvj+HV1kF8dns5LOl6SWL4SuMK6DQq/LiJDkGeDiU+SeZ8rxOHO4bwme3LJOssAsAXbg2P0P/sMP3ikIXjnONHhzpRmGXAfRuk6SwCwPK8dOytLcKvT3TD4aI1z2Th9rcM4OLgBL7csAKqBK3Vn85XG1fA4Q7gN29clSwGQsjsHm3qRIZeg09tK5Mshtx0PT66qRT/c7YP10bcksWRrCjxSTI/OtSFTIMGD2wplTSOouw03L+hGH9o7qG9PmTB3rhsx6luB75w63LoNfEtXz2XrzSsgMsfwq+O0awPWZhwAt+FZbkm7K0tkjSWm0rMuKUiF//1+mV4/FSwg5Bk0zk4jpcuDOCTW8uQlZbYJbE3+vyt5VCrGH76Gh3mfSNKfJJIW394ivTBbcsSvo58Ol+8dQVCAsdjr9HmcLIwPzrUidx0fULKeM6lsiADu2vy8avj3RjzBqQOh6SQg202tPaP4Uv1yxNWmWk2X2lYgeEJP54+eU3qUAghN3i0qQtpWjU+HedzF+cjP9OAD9UtxZ9P05aFG1Hik0QebepCul6DT2+T/pcGCO/1uWddEX538iptDifzdvqqHccvjeDzO8rjfljpfH21sQLj3iCeOt4tdSgkRXDO8aOmLhSb03DvTdIt15zq5nILNi3LwWNHLsEXpFkfQpLFlWEXnj93HR/fXIqcOB9WOl9fqA9vWfj5a7RlYSpKfJJEl20cL77djwe2lCLLKP1sT9SXG1bQ5nCyID861IUckw4f21widSiTVi/Jos3hZEFe7xzGuR4nvlS/Alp18twqv9ZYgcExH/7U3Ct1KISQiJ80dUGrVklWlGo6S7LTcN/6Yjx9qgc22rIwKXmu5gr3k8OXYNCo8ZkkmCKdaurm8FEPLRMis7vQN5oUxTmmE90c/rs3aZkQmdujTV2SF+eYzrYVFtxUko2fHr6EYEiQOhxCFK/P6cFfzvThI5tKYM0wSB3Ou3ypPrxl4RdUCn8SJT5JYHjCh33n+vGBumLJyh/O5vM7yuHyh/Dn0zTCSGb35PFuGHVqfHyztMU5pnNTiRmbluXgqTe6ERK41OGQJNbWP4aTV+x4cFuZ5MU5bsQYw+d3LEef04OD7TapwyFE8X77xlUInCfVbE9UicWIO1cX4Pcnr1FRlAhKfJLAH071wB8SJK/kNpPVS7KwviQbv3njKgTqMJIZOFx+PHfuOu69aYnkFW1m8sCWUvTYPXjtInUYycyeOnEVeo0KH6yTvjjHdHZVW1GUZcCvT1Bpa0Kk5AuG8IdTPdhZnS/JgfPz8cCWMox5g3juXJ/UoSQFURIfxtjjjDEbY+zCDI8zxtgPGWNdjLHzjLH1YrQrB8GQgN+9eQ1bl1uwwpohdTgzemBLGa4Mu/B617DUoZAk9afTPfAFkzeBB4DdNQWwZujx5HHqMJLpjXoC+J8zfbhnXRGyjcmxSflGGrUKH725BEe7htFlo9PZCZHKi2/3Y8TlT+r73sYyM6oKMvDk8avgnAavwTmP+Q+AHQDWA7gww+N7ALwEgAHYDODN+bzuhg0buOR+8xvOS0s5Zyz89xe/+M7nFkv4TwyPuQuL+RPr9nB3YXHc2njPY4t4HYExfj3Lyg823Be3NhLxPqiN+LQhMMb7s638xR3vj+/7EOE9CozxYUMGD+Yk3/eR2pC+jbH8Iv7Euj3ct2Rp4t7HIt6jwBjvzbTyN+78UFJ+H6mNebzOb37DSWq759GjvOH7TTwUEqQOZVa/eaObl/7tPt7cPSJ1KHEDoJnPI7dgXKTsjzFWBmAf53z1NI89BuAw5/zpyOcdAOo55/2zvWZdXR1vbm4WJb5F+e1vgYceAtzxPfmWI5wRpoJUipUkHv18EDlIpZ/jVIqV3MBoBH7+c+BjH5M6ErIIb/eO4u5Hj+Lbd6/Cg0lyDMlMXL4gNv/LQTRUWfHDj9wkdThxwRg7zTmvm+t5idrjswRAz5TPeyNfS25/93eA241Hdn4Oj+z83OSXp34uxmNMpNdZyGNixRqPNhLxPqiN+Dy2kJ+PVH2P1Ib825DimrzY9yjW75zU70OJbcDtDvczSEp66kS4mM99G4qlDmVOJr0G99cV46UL/RgaV/a5jImqNzvdgNS0U02MsYcAPAQAJSUSnwNyLVz2ttVa/q4vT/08Ho9RG9QGtZG87VMb1IYc26c2Et8GgMl+Bkkt0WI+928oRqZBK3U48/KJzaX41bFu/P7kNXx1Z4XU4UhGlaB2egFMLY9TDOD6dE/knP+cc17HOa/Ly8tLSHAzkjrxIoQQQoh8UT8jJf2xOVrMp0zqUOatPC8dt1Tk4rdvXlP0GWCJSnyeA/BApLrbZgCjc+3vSQrf/W54DS6ZRPVAyFT080CItOh3MIUZjeF+BkkpnHP8/lQPNpXloLIgeavxTufjm0sxMOZFU8eQ1KFIRpSlboyxpwHUA8hljPUC+DYALQBwzn8G4EWEK7t1AXADeFCMduMuuuHwoA3w+oDSUmDPHsCrD39usQBaDRAILvixkFoNdSgEXlICdtdd7zwmYhszPhbD67A9exBy66D2+xE058SljUS8D2pDnDauba6HT62FPhRIzPuIw3t05BXCfP+9sv+/ojZmfozn5CCoUkMjhKR5HzG8R7ZnD4IuHTQBP4ScWa7JMvm/kk0bpaXhpIcKG6Sct645cGXYhS/VL5c6lAVrrLLCYtLhmdO9uG1VvtThSEKUxIdz/pE5HucAvixGWwn3sY8BEyfCH//uG+G/H5vy+WMLf+zaj76G5n9vwlJzGth0/06ENuZ8LIbXEX5yDM3XnPjPp48D3fa4tJGI90FtxP7YPz3ZjJaLNqwvMSfufYj4HrtsE6ivfAIn/24n8MuTkn0fqQ1p2zjxT5/F6f96EyvyTNK9jxjeo/eHr6Pl+hj++NIZ4ExfXNpIlv8rWbVBUtKfT/chTavGnWsKpQ5lwbRqFe5ZtwS/fqMbDpcfZlNynlUWT4la6kameOatXgBAboZe4kgWR6tWIStNi79Eb7BEkYYnfDjcYUNuemr+HAPh38FRTwCH2mxSh0Ik9MzpPqgZUrYTkK7XwKBVTd5bCCHx4Q2EsO/8ddy5ugDp+kTVBxPXfRuWIBDieP78tFvtZY8SHwk881YvstI00KlT99ufl6FHn9ODMU9A6lCIRJ49ex1BgSMvRRN4AMhO0yI/U08dRgUTOMdLF/phSddDxVL3RJy8dD1OdTvgDYSkDoUQ2XqldRDj3mBKlLCeSU1RFqoLM/Hn08q876VuzztFjXkD6HV4UnqUHADMRi0yDBoMTSi7HrySPXO6F7XFWUjTqqUOJSb33rQETR1DCCi4yo2Sjbj8cPtDKX9Nzs3Qg7HwTCwhJD6eOd2LoiwDtpRbpA4lJvetX4LzvaO4ODgudSgJR4lPgg2N+5Cu1yAnRZdURKkYw97aIthdfoQ41RVSGrc/hNb+MdyfwqNeUfevL0ZI4Bie8EsdCpHA0LgPZRYjMgypuWwlSqdWYfuKXAyN088xIfEwOObF651DeP/6YqhUqTs7DIQH/DQqhmcUOOtDiU8CCZzD7vLjrjWFKb2kIur+DUsgcMBOHUbFGRr3QatmuLu2SOpQYlaRn4G1xVk0Uq5AvqAQXrayPvUTeAC4f0Mx/CEBY15agkyI2P5ypg8CB96/fonUocQsN12P+so8/OVMn+LO9KHEJ4HsLj8EDtxfJ4+b7PoSMwwaFS13UxiO8HKaXdX5KbsZ/Eb3byiG2x+C2x+UOhSSQNFk9/0ymLkEgNtXFUDNwgMThBDxcM7xzOlebCg1ozwvXepwRHH/hmLYxn042jUsdSgJRYlPAg2N+6DXqFBXapY6FFEwxpCboce4N4geu1vqcEiCjLr9CApcNqPkAHD32iIwgJYJKQjnHEPjPmQaNFiSnSZ1OKJI06mRk66H3eWHy0dJPCFiebtvFJ22CVnd9xqqrMg2ahVX5IASnwSxjXsx5g0iN10PJoNlblHRDcH7zvdLHAlJlOEJP9Qqhlsr86QORTTZRh2yjVqMuHwQBNqzpgTne0fhCwopX9TgRrnpOggcONhOJdoJEctzZ69Dq2a4KwXP7pmJXqPGXWsKcbDNpqjVDpT4JMhLbw8AACzp8lgaFKXXqGDSq7FPofXglcYbCMHh9sNi0kGbwuXYp2NJ1yMQ4jgVPZSXyNq+89fBgJQvNHOjTIMWWjXDvnN0TSZEDILA8cLb/dhRkYcso1bqcES1t7YInkAIBxV0lp28ei5JbN/560jTqlO+9O90LCY9Wq6P4cqwS+pQSJw1tdsgcMAis84iEC7RzhjNXiqBIHC8cL4fWWlaqFO8OtN0ckw6HL44hHEqckBIzN665kD/qBd718pntidq07Ic5GXoFTV4TYlPAvSPenCq2yG72Z6o6PuiEUb523e+HxoVQ0aavEa9gHCJdrNRh5cu9IMWu8nbmR4Hro96ZXtNzk3Xwx8U8GrroNShEJLy9p3vh06jwq7qfKlDEZ1aFV6+19ShnIESSnwS4IXICLIcR8mB8PkRG8vMNFIucwLnONg+CItJB/mNkYdZTDoMT/gx7lHGDUCpnj8X7siYjfK8JqfrNSjKMtA1mZAYhSLL3Boq85BhkN+AHwDsrS2EPyjgQJsyBkoo8UmAfef7UVOUCYMMl7lF7a0tQsfgODyBkNShkDhxuAPwBgTZjpIDQLZRC5NOjREXVXeTsxcjHRk5LnOLuqu2EK93DiFExToIWbSTV+wYGvdhrwzOrJvJ+hIzCrMM2HdOGQMllPjEmS8o4GyPU9a/NABw55oCqBgwQoeZytbIhA/5mXrZjnoB4eVuu1blY8Tlp+VuMjXmDcAm844MEB6MCoTCh2YTQhYnuj97Z7VV6lDiRhVZ7nakcwijbvmvdqDEJ85GXOGD5PbWym9T3FTWDANuXmaZfL9EXkICh9MdwB4ZlfKcyd7aIoQEjlFa7iZLIxN+2XdkAKC2OAslOUa6JhOySMGQgJcvDGBntRVGnUbqcOJq79rwQMn+1gGpQ4k7SnzibGTCj7VLs7E0xyh1KHG3d20hvAEBbj8td5Mbhzs8AyL3UXIA2LEyF2oWnuEi8sIB2F1+NCqgI8MYw121hRj1BBEMCVKHQ0jKOXF5BCMuvyLue2uLs7A0J00R+wIp8YkjbyAEtz+Eu2U+2xN15+rw+6QOo/yMTPihU6uwviRb6lDiTq9Rw2zSweHywxekJF5OxjwBBAWumGtydKWB3U3L3QhZqH3n+pGu16BeRod1z4QxhrvWFOFY17Dsl8dS4hNH0R8eJSwPAsJnR2SlacL7IzjtkJCLMW8Ao54ALOk6MCbfzeBTWdL1CHHgaOew1KEQEdldfqgYUF8p72VuUasKM2HQqGjvJSELFAwJ2N86gF3VVlkXpppqb20hQgLHKy3yXu5GiU8c2V1+mPRqFGWnSR1KwuSYdPAFBXQMjksdChFJU7sNHPI74X42WQYt1AzYL/MbgJKEhPBG/2yjTjEdGcYYckw6jHmDcNKsDyHzdvKKHU53AHesVsbANQDUFGWi2Jwm+/seJT5x0j/qgcsfQo5Mz4mYSfRcjP0XlFEPXgn2twxAq2ZI18t7T8RUjAHZRh0OtNlof4RMnLnmQFDgikrgAcAceb8H22wSR0JI6tjfMgCDVoVbV8p/mVsUYwy7awpwrGtE1oeZUuITJ6+0hDv+SrvJatUqpOs1sh8xUApvIITDHUOyPehxNjkmHewuP5qvOqQOhYhgf8sAGIDsNPmWY59Oul4DrZrRNZmQeeKc45XWQeyoyEOaThmzw1G7awrgDwk43DEkdShxQ4lPnERHC5SypGKqHJMWrf1j6LG7pQ6FxOho5zDc/pDiEnggfJipTqOiDqNM7G8ZRGaaVtaHls4kx6TDkc4hCLT3kpA5ne8dRf+oF7trCqQOJeE2lJphMelkfd+jxCcOggLHm1fsiuwsAu/Mcsn5F0cp9rcMIMOgQaaMDy2diYox3LIid3L2lqQutz+Ea3a3cq/JRh28AQFOBRxOSEis9rcMQK1isj/razpqFcNtq/JxuGNItlVNKfGJA4fLj5DAFbe/J0qvUaOqIIM6jCmOAzjQNoidVVYopJjbe+yuKUCf0wOXPyh1KCQGdpcfjAFmo/ISeADISNMiK00LBxU4IGROL7cMYHN5DrIV2ofbXVOACV8Qx7tGpA4lLijxiQO724+iLANMCtoMfqPdNQU4ddWOAG0MT1nj3gAc7gDuWK286f6oXavyoWLhwQySuuwuPzaW5kCrVuYtjwHYVZ0Phyt8EDEhZHpdtnFcHnLhDgUuc4vausIi673ayrwLxJHAOUbdAdyu4F8aIJz4cA44aGlFyrK7/NBrVNihoKo2N8ox6bBpWY7sD3STM19QgCcQwu01+VKHIqndNfkI8fAhroSQ6e2PrFS5bZVy+3B6jRoNVVa82jqIkCC/oRJREh/G2B2MsQ7GWBdj7BvTPP4pxtgQY+xs5M9nxWg3GTndAXBAkZvipqouzMDSnDTqMKZFcWL7AAAgAElEQVQwh8uPHSvzYNQpd+YSCP8uewICvAF5rneWu+g1SOnX5B0r86BioGsyIbPY3zKAdUuzUZBlkDoUSe2uyceIy4/mbrvUoYgu5sSHMaYG8GMAdwJYBeAjjLFV0zz1D5zzdZE/v4i13WRld/mhUTFsLDNLHYqkGGPYvaoAY56ALEcM5M7lC8If4orvLAKYnL2lDmNqsrv8MOrUWJpjlDoUSRm06sl9PgJdkwl5jz6nB+d7R+m+B6C+0hqpaiq/vdpizPhsAtDFOb/MOfcD+D2Ae0R43ZTjDwpwuv0wG7XQKHQt+VS7VxeAA3DS0oqUY49sgt5ZpbyqNjdakp0Gk049+T0hqWNo3IcJX1CxhWZulGPSIRDiONvrlDoUQpLOgdZwJ3+3wpfFAuHzv7avyMUrrQPgMiuDL0bvfAmAnimf90a+dqP7GGPnGWN/ZowtFaHdpHOq244Qf+ekbKVbX2KGRsVoY3gKcroDyDBo6Gc5wmzSweULYWjcJ3UoZAEOd9gAANkmZVZzu1H0IOKDbfIbxSUkVgfbbSjPNaE8L13qUJLCbavy0evwoGNwXOpQRCVG4jNdodsb08PnAZRxzmsBHADw5IwvxthDjLFmxljz0FBqnRx7oG0QDECWwk4Gn4laxZBt1MLpCSBI1d1SxsCoF25/CNkKLf07nWgZ5KZ2m8SRkIU43DEErZrBpPB9alFqFUOGQYODbfRzTMhUbn8Qb1weQQOtcpgUXfEht+uFGIlPL4CpMzjFAK5PfQLnfIRzHh0q/S8AG2Z6Mc75zznndZzzury81KkmxTnHwTYbstK0UCn10JNpmI06hASO5qsOqUMh89QUGSU30/KgSUadBjo1wwEaKU8ZgZCAIxeHFHsWx0zMRh3aB8bR63BLHQohSeN41wj8QQGNlPhMsmYaUFucJbv7nhiJzykAFYyxZYwxHYAPA3hu6hMYY4VTPn0fgDYR2k0qXbYJXLO7YaYlFe+SZdSCgZZWpJJD7Tbo1CqkadVSh5JUzEYdXu8cpupuKaK524FxX1Cxh5bOJPr9kNsoLiGxONRhg0mnxsayHKlDSSq7qvNxtscpq2XeMSc+nPMggK8A2I9wQvNHznkLY+w7jLH3RZ72NcZYC2PsHICvAfhUrO0mm1cjHXsaXXw3NWPITNPiAN1kUwLnHMe6hmmZ2zSyTTp4AiGcuCTP06zlpqnDBq06fP0h7zBo1SjPM8luFJeQxeKco6ndhu0VudBpqDDVVDurreBcXsu8Rfkf5py/yDlfyTlfzjn/buRrD3POn4t8/E3OeQ3nfC3nvIFz3i5Gu8nkYJsNq5dkQkfV3N7DbNTiyrCLRspTwJg3CLc/RKPk08g0aGDUqanDmCIOtdtw8zIL1LT0+D12VefjjcsjdNQAIQDaB8bRP+qlZW7TWFWYiaIsg6zue9RLF0EwJOCtaw7srKISiNOJzoI5qBxw0nO6/dBrVDRKPg0VY7ilIheHZDTyJVe+oIAu2wRtVJ7BziorAiGOUTpqgJDJfa0NlXS9uBFjDI3VVlkt86bERwQOTwCch0fRyHvpNSpUFWTA4aabbLJzuAPYutxCBTpmsLM6H/2jXrj8QalDIbNwRgZZaAR3ehtKzZOHmRKidE3t4RU71kyD1KEkpZ3V+bJa5k2JjwicLj/yM/VYvSRT6lCS1m2r8jHuDSJISyuSljcQgo+q2syqscoKxgCni5L4ZOZwB7As14RluSapQ0lKGrUKjVVWOGkwiiic0+3H6asOmu2ZxZZyi6yWeVPiEyPOOZyeAHZW54PRKPmMdkZmw5w0wpi0ojNy9XQDmFFuuh43Lc2mkfIkJnCOMU8A9ZWpcxyCFHZWWxEUOMa9NHtJlOu1i0MQOGhZ7CwMWjVuqcjFwTYbOE/9wWtKfGI05g1C4MCuavqlmU3tkixo1YyWuyUxp9uPNK0KS3OMUoeS1HZW58PlDyFAh/ImpTFPABy0zG0uO1aGE0NK4omSNbXbkGPSYW1xttShJLWd1fkYGPOi5fqY1KHEjBKfGDncfjAGbF2eK3UoSU2lYshO02HU7acOYxKa8AUx7g1SOfZ5iO7loyQ+OTncAagYsGkZnccxm0yDFpkGDSU+RLFCAsdrF4dQvzIPahWt2JlNdJm3HJa7UeITA845nO4AsgxaGOiwxzmZTVqEePhgQZJcjnYOgwN0fs88rMxPh06tomWbSWjympymhV5D1+S5mI06eAMCeuxuqUMhJOHO9jjhcAdQT7PDc8pN12NtcTaaOoakDiVmlPjE4PKwC76gQJ3FecpM04LhndKRJHk0tdugZkCGgX6W58IYQ7ZRi1FPAL6gPMp7ysXFwQn4QwLNXM5T9N5F12SiRE3tNqhVDLdW0H7A+WiotOJ8rxPDEz6pQ4kJJT4xiJ5kSzfZ+VEzhgyDhs5BSTKcczR12JBl1IEm++fHbNRC4MCbl+1Sh0KmODR5TaYEfj4MWjX0GhVdk4kiHWq3YUOJGVl0vZiXxiorOAcOp/isDyU+MWjqsCFNq4JeQ9/G+TIbdeiyTdDSiiTScn0MtnEfdRYXIDp7SR3G5NLUboNRp4ZOTdfk+TIbtThxaQQeP81eEuUYGPWitX+MqrktQE1RJvIy9Ck/Q0x3h0UKcY6TV+w027NAtLQi+TS128AYkJ1Gic98qRhDVpoWh+nnOGmEBI7T1xyUwC9QtlEHX1DAicvDUodCSMJEr91U/XH+VCqGhso8HLk4lNJFqijxWaQxTwCBEKeb7AIZtGosyzXRSHkSOdRhQ21xNrQ0Sr4g2UYtukfc8AZopDwZOD0BhAQOMw1GLUimQQOjTk3XZKIoh9ptKMoyYGV+utShpJTGKivGvUGcvpq6Raqop7NITncAGXoNbQZfhPrKPJy4NAJBBgdhpbpgSMDZHica6LDHBYvO9lJZ6+TgdPthNmqRrtdIHUpKYYxh24pcNLWn9rp9QubLFwzhaNcwGqqsdPD8Am2vyINWzSb3uKciSnwWyeH245aVubQZfBEaq6zwBQWMeajDKDWnJwDOabp/MfQaFSqs6VTWOkk43QHcupIS+MVorLKiz+mhfT5EEU5escPtD9F9bxHS9RpsWpaT0tsVKPFZBLc/hECIo76SfmkWY9OyHBh1ahopTwIOdwC56XqsLsqSOpSUFJ32D9HspaQmfEEEBU4blRepIXIvo8NMiRIcardBp1HRwfOL1FBpxcXBCfQ6UrNIFSU+ixAd4a2n5UGLoteosX1FLpyU+EiKAxh1+9FQmQcVnVq9KA1V1sj3kX6WpRS9JtOMz+IUZBmwqjATTpqFJwpwuGMIW8otSNPRIceLER1gStXlbpT4LILTHYBJp4Y1wyB1KCmrscoKf0igpRUSmvAGEaJlbjHZUGqGmoGSeIk5Insuqcrm4k3OXgo0e0nk68qwC1eGXXTfi0F5rgmlFmPKFkShxGeBRt0BjPuCVM0tRvW0tEJy0e/9tgqa7l8srVqFLKMOTo8fnJa7ScI25oXbH6JrcowaqsKzZTTrQ+Qs2lmnxGfxGGNoqLTi+KWRlKxqSuVvFui1znDlGxpZjE1BlgFGnZpGyiXkdAeQadAgkyoTxiTbqIXd5UfL9TGsXkJ7pRItusmWrsmxWbfUDI2KUbEOImtN7TassKZjaY5R6lBS2v0birGqKFPqMBaFZnwW6HC7DRoVo5KpIsg2ajHuC9L+CAn0OT3wBELUWRRB9ODXVJ32T3VN7UPQqRmMtF4/JmpV+FBepztAy92ILLl8Qbx5ZYRme0SwekkWPli3FAZt6l13KfFZAEHgOHxxiJZUiCR60OCRTjo/ItGimxLpZzl2WrUKJr06pct7pip/UMDRrmFK4EViNmoRFDjO9zqlDoUQ0R3tGo5U5KUiKEpGic8CnO8bhd3lnxzhJbFJ12ugUaX2QVipqqndBr1GhbQUHK1JRtlpOpztcWJkwid1KIpyqtuOCdpzKZqsSAJJ12QiR03tNmToNdhYliN1KERClPgsQFO7DSr2zs2BxC4rTYvDF2nGJ5EEznHs0jB1FkVkNmrBOfAa/SwnVPQ8jiwajBJFdBn3IZq9JDLDOUdThw23rMyFVk1dXyWj//0FaOqw4aaS8AZQIg5zZGP4hC8odSiKMeYNwhsQaHmQiEx6DXLT9bTPJ8Ga2m3YXG6BitE1WSxmoxYX+sYQCAlSh0KIaFquj2FwzDd5WC9RLkp85ikQEnC+dxQNtDZUVFlGHVQMVEkogZxuP9K0amQaqECHmBoq83Dk4hBoW3hieAMhXB52oZGuyaKKDohQxU0iJ4cjs5i30vVC8Sjxmafo2QYNVA1EVBoVw4ZSMxx0k00YpzuAbStolFxsjVVWjHmDmPDS7GUiRK/JjVX5EkciL0adGoVZBjpjjcjKoXYbaouz6OB5Ik7iwxi7gzHWwRjrYox9Y5rH9YyxP0Qef5MxViZGu4nkdAdgzdBjVWFq1i1PZvWVVrj9IVpakQCeQAi+oDB5gCwRz7aKXGhUjDqMCeJ0+1GeZ0KJhc7jEFt9pRWjngDoTF4iB3aXH2d6nLTMjQAQIfFhjKkB/BjAnQBWAfgIY2zVDU/7DAAH53wFgP8A8K+xtptIHMCo24+GSisYjZKLLlpTn5ZWxF90SSHNXIov06DFxrIc+jlOAIFzjHmCaKSOTFw0VlkhcGDcSz/LJPW9dtEGzkHn9xAA4sz4bALQxTm/zDn3A/g9gHtueM49AJ6MfPxnADtZCmUQE94AQhxoqKK1ofFQVZABnZpGyhPB4Q4gTavGkuw0qUORpcYqKzyBEPxBmr2Mp1FPABzUkYmXbSssYAAtQSaycKh9CLnpOqxZkiV1KCQJMB7jXDZj7H4Ad3DOPxv5/BMAbuacf2XKcy5EntMb+fxS5DnDs712XV0db25ujik+Mfzwf30R+bZrqCvLgUbF0No/BgBYVZj5ro8BiPKYWK+TSm2cvuZAICRgU5kFKpa67yOZ2wgKHM3ddug0KqwvMafs+5C6/dme6wmEcK7HCYNWjXVLs1P2fSR7G4u9XiTb+0im9m/8vPmqAwLn2BQ58yRV30cyt3F5yAWXP4iaokyoGEP3iAsAUGYxAcC7Po/HY4loQ+r2OYCTV+wwaFVYW5ydsu8jGdtwFi3DPb/4PpIFY+w057xurueJUdZpupmbG7Op+Twn/ETGHgLwEACUlJTEFplI9Fo19Fr1ZBlro+6dQx+nfizWY0psI12vgcPlx7g3gKw0bcq+j2RuYzSyGTw9Us0tVd+H1O3P9lyDVg21ik1e3FL1fSRzGxxASOAwaNSIniyQiu8j2dqf7rljngC8wRAMGnVKv49kbWPU44cvKGDUE4DZqIPbH3rXc6d+Ho/HEtGG1O1PeIOYOsCfqu8jGduwu1LzwG4xZny2APhHzvnuyOffBADO+f+d8pz9keecYIxpAAwAyONzNJ4sMz5A+PCrFFqdl3Lc/iDWfedVfGJzKf5h741bxIgYvv6nc3i1dRCn/34XNHSAW9x8+9kL+ENzD84+fDsMWvXc/4AsSOv1Mez54ev4t/tq8cGNS6UOR7aujrhw678fxrfvXoUHty2TOhxZqnn4Zbj8IXx8cwn++d41+NBjJwAAf/j8FgB41+fxeCwRbUjd/r++3I6fHr6EulIz/vzFrSn7PpK9jWQw3xkfMXo/pwBUMMaWMcZ0AD4M4LkbnvMcgE9GPr4fwKG5kp5kQ0lPfBl1Gmwut6CJDoCMC0HgONxhw46VeZT0xFlDlRXegIATl0ekDkWWmiLncdTTnsu4KrWYUJ5nokN548Q25oUrMoLe1D6EFOsSpYymdhsyDBqo6eB5EhFzD4hzHgTwFQD7AbQB+CPnvIUx9h3G2PsiT/slAAtjrAvAXwN4T8lrQhor83B52IXuYZfUocjO232jGJ7wo5E6i3G3udyCNK2akvg4OdRuw5oldB5HIjRWWvHmZTtcPjqbSmyHLw4BAPIz9OhzetBpm5A4Ivnpc3rQPjAOs1ErdSgkiYgy9Ms5f5FzvpJzvpxz/t3I1x7mnD8X+djLOf8A53wF53wT5/yyGO0SeYkeRBgd0SXiaeqwgTHg1pVUBSveDFo1tq2w4FC7jUZxReZw+XHmmoPKsSdIY5UV/pCA45do9lJshzts0KoZiiIVNmmgRHyHI32JbKNO4khIMqE1LyRplFiMWE5LK+Kiqd2Gm5ZmI8dEN4BEaKiyotfhwaUhGsUV05HOIQh0HkfC1JXlIF2voWuyyAIhAa9fHEa2UQedRoXqwkwa8IuDpnYbis1pSKO9lmQKSnxIUmmgpRWiGxr34VzvKJ1anUD1ke81dRjFdajdBotJh1o6jyMhdBoVtq/IxeEOmr0U0+mrDoz7gshOCy/BaqjMQ3O3AyGBvsdiETjHsa4RGiQh70GJD0kq0aUVx7pmPeKJLEB0up+WByXOkuw0VBVkUOIjopDA8drFIdxamQcVbVROmMYqK/pHvWjrH5c6FNloag8vc8uKJj5VVgQFPnnkAIndmDcITyBEA37kPSjxIUklurSCpv3F09RhQ36mHjVFmVKHoigNVVY0dzsw5qXOjBjOXHPA6Q7QCG6CRavn0TVZPE0dNmwsy5msNHbT0mxkGjRwuv0SRyYfTrcfBq0KW5ZbpA6FJBlKfEhS0WlUuKUil8p7iiS6lryh0kol2ROsMTKKe7STZi/F0NRhg1rFcEsFVSZMJGuGAWuWZNHme5H0Oty4ODjxrpkIjVqFHSvz4KQZH9E43QFsXZ5LZ6mR96DEhySdhiorBsZoaYUYmrvDa8lpmVvi3bQ0G1lpWlruJpJD7UOoKzVPLg8iidNQZcVb1xxwuGhGIlaHO8JlrG+8JjdWWREIcbj8tL81Vp5ACL6gQPc9Mi1KfEjSqa+kpRViaYqUTN22IlfqUBQnOop7uMMGgTYtx6R/1IO2/jHqyEikoTIPAg9X1SOxOdxhw9KcNCzPM73r6ztWhu97TjfN+sQq+j1sqKTZYfJelPiQpBNdWkEj5bE71G7DzcssSNdrpA5FkRqr8jA84cfbfaNSh5LSmtrDHW7a3yONtcXZsJh0dE2OkTcQwrGukWmXHuem62HSq2mfjwicbj/StCoUm41Sh0KSECU+JCk1VFlxhpZWxKTH7kaXbYJGySV060orGKPZy1g1ddiwJDsNFdZ0qUNRJJWK4dbKPLx2cYhKLsfgzSv2WSuNZafpMOELwU73vUUb9wYw5g3SoaVkRpT4kKTUWGWlpRUxina2aZRcOjkmHW5amk0bw2PgC4ZwrGsYjVVUoENKjVVWON0BnO1xSB1Kympqt0GvUWFz+fSVxszG8P61IxfpvrdY0WIy0e8lITeixIckpdolWbS0IkaH2m0osxixLNc095NJ3DRUWnGudxRD4z6pQ0lJb162w+0PoaGK1utL6ZaKPKhVjK7JMTjcYcOW5Rak6aavNGbSa6BRMZohjsGhdhvUDEg3UOJDpkeJD0lKtLQiNh5/CCcujdAytyQQ/T84TJ2ZRTkUGSXfUk4FOqSUlabFhlIzDrXTbMRiXBl2oXvEPecMfLZRS/e9RRIEjqaOIWQZdaC5YTITSnxI0oourThzjZZWLNTxS8PwBQVa5pYEaooykZ+pp1HcReCco6nDhq2zjJKTxGmssqKtfwz9ox6pQ0k50Zmy+pVzJT46WlK4SBeuj2J4wkfL3MisKPEhSSu6tII6jAvX1GGDUafGpmU5UoeieIwxNFRa8frFYQRCgtThpJQrwy5cnccoOUmMxsnZS5r1WajDHTYszzOhxDJ7pbHsNG34vkczawvW1D4ExsLfQ0JmQokPSVpZaVrU0dKKBeOco6l9CNtX5EKvoVHyZNBQZcW4L4jmbhrFXYjJUfIZqmCRxKqwpmNJdhrt81kgly+INy/bZ6zmNpVaxbChxEwDfotwqMOGtcXZ0Kipa0tmRj8dJKk10NKKBbs4OIE+p4f29ySRbStyoVXT7OVCNXXYUGFNx9IcOo8jGTDG0FCVh2Ndw/AFQ1KHkzKOXxqBPyTM+5pcX5WHlutjNEO8AIGQgPO9znkll0TZKPEhSS26tIKm/ecvOhpLN4Dkka7X4OZlFhopX4AJXxAnr9hpmVuSaayywu0P4c3LdqlDSRlNHTaYdGpsLJvf0uPoz7zTHYhnWLLi9ATAOR3fQOZGiQ9JarS0YuGa2m1YVZiJgiyD1KGQKRqqrOiyTaDH7pY6lJRwtHMIgRCnmcsks6U8F3qNiq7J8xReemzD9opc6DTz63JV5megMMsAh5sOMp0vpzuAvAw9aooypQ6FJDlKfEhSY4yhscpKSyvmadQdwOlrDhr1SkKTs5e03G1emtqHkGHQYEOpWepQyBRpOjW2LrdQefZ56hgcR/+od0Ez8Iwx1FdaMRqZxSCz4wBG3X40VOZBpaJC1mR2lPiQpNdYZYUnQEsr5uNIZ/j8BzrsMfksyzVhWa6JRsrnIXwehw07KvKgpY3KSaexyoruETcuD01IHUrSiy7TXmiBjobKPAgcGPfScre5jHsDCHFa3k3mh+4oJOltLrfQ0op5Otg2iByTDuuW0ih5MqqvzMOJSyPw+Gn2cjYXro/CNu7DzmrqyCSjaCeerslzO9g2iJqihS893l6RCwbAQft85uR0B8AA3LKSBvzI3CjxIUkvurSiqcMGTvP+MwqGBDR1DKGh0go1TfcnpcYqK3xBAccvDUsdSlI70DoIFaMR3GS1NMeICms6Lducw8iED6evObCzOn/B/9ao0yAzTQuH20/3vTk4XH5kpmmQrtdIHQpJAZT4kJTQWGXF1RE3Lg+7pA4laTVfdWDUE8AuGiVPWpuW5cCoU9NI+RwOtNmwodQMs0kndShkBo1VVpy8YseELyh1KEmrqWMInGPR12SzUQtfUMAlWlI4o0tDE/AGBZiNdK0g80OJD0kJDZNlranDOJODbYPQqVU03Z/E9Bo1tq/IxeGOIRrFncF1pwet/WOLGiUnidNQZUUgxHG0k2YvZ3KwbRD5mXqsLspa1L+PduYPtNF9byYH2wYBANmU+JB5osSHpIRisxEr82lpxWwOttmwebmFpvuTXGOVFX1ODy4O0ijudA5GBjd2UeKT1DaUmpFh0NBg1Ax8wRCOXBxCY1X+oiuN6TQqGHXqyc49ea8DbTakadXQz7NUOCH0k0JSRkMlLa2YyaWhCVwedtEytxRAG8Nnd6B1EGUWI5bnmaQOhcxCq1ZhR0Ue7b2cwRuX7XD5QzFfk81GHU5fdSAo0Pf4RkGBo7nbDrNJK3UoJIXElPgwxnIYY68yxjojf09bSooxFmKMnY38eS6WNolyvbO0YkjqUJJOdESQzu9JfgVZBqwqzKSR8mm4fEGcuDSCndX5YIwKdCS7hiorbOM+tFwfkzqUpHOwbRAGrQrbVuTG9DpmoxYCB5x0mOl7ON1+CBy0v4csSKwzPt8AcJBzXgHgYOTz6Xg45+sif94XY5tEod5ZWkGJz40OtNlQVZCBYrNR6lDIPDRWWXH6mgOjVKr2XV7vHIY/JFAZ6xRRX5kHxmjv5Y045zjYZsP2FXkwaNUxvZZJr4E1Qw8HJT7v4XAHkJehp+XdZEFiTXzuAfBk5OMnAdwb4+sRMiOtWoUdK2lpxY0cLj+au+24bRXtiUgVDVVWhASOIzR7+S4H2gaRadBgY1mO1KGQechN16O2OBuHaO/lu7T1j6PP6RFt6fHO6nw43QG6703BI7NgjVTynixQrIlPPue8HwAif8/0E2hgjDUzxt5gjFFyRBatsZKWVtzo8EUbBA6qgpVC1i3NhtmopZHyKUICR1O7DfWVVmjVtP00VTRWWnG2x4mRCZ/UoSSNyaXHIiU+u6qtEDgw5qX9rVFj3gAEDuyiAT+yQHPeXRhjBxhjF6b5c88C2inhnNcB+CiA/2SMLZ+lvYciSVLz0BCNhpJ3uzWytII2hr/jQJsNeRl61C5ZXMlUknhqFcOtK/Nw+OIQQrRpGQDCnWeXn5a5pZiGqjxwDrx2ke7XUQfabVi7NBvWDIMor7dtRS4YAy13m8Lh9oMB2B7jHiqiPHMmPpzzXZzz1dP8eRbAIGOsEAAif0/bG+WcX4/8fRnAYQA3zdLezznndZzzurw8Oo+EvFt0aQWV9wzzBwUc6RhCY6V10SVTiTQaqqywu/w42+OQOpSkcKBtEGoVQ/1KSnxSyeqiLORl6HGQzpoBANjGvDjX48QuEQvNGLRqZKVp4XDRcjcgvIfK4Q4gK02LNF1se6iI8sS6nuA5AJ+MfPxJAM/e+ATGmJkxpo98nAtgG4DWGNslCnb7qnyc6x3FwKhX6lAkd/zSMMZ9QdxeQ9P9qSa8pIvhlRZK4gFgf8sANpfnIMtIpWlTiUrFsKs6H4c7bPAGQlKHI7lXWsO/z7fXFIj6ujlGHfwhgZZ5A2jtH4M/KMBsompuZOFiTXy+B+A2xlgngNsin4MxVscY+0XkOdUAmhlj5wA0Afge55wSH7JouyM3lFdaBySORHr7WwZh0qljLplKEi8rTYsty3Oxv2VA8aO4XbZxXB5yTf5uk9SyuyYfLn8Ixy8NSx2K5Pa3DKDMEj5wW0zRTv7+Frrv7Y8MFplpkIQsQkyJD+d8hHO+k3NeEfnbHvl6M+f8s5GPj3PO13DO10b+/qUYgRPlWmFNx/I8k+JvACGB49XWAdRXWWMumUqksbsmH90jblwcnJA6FEm9fCH8u3z7Kkp8UtHW5bnI0Guw/4KyZy9H3QGcuDSC3asLRD+HSqNiyDBoJn9XlGz/hQFkGDRUBIUsCv3UkJS0u6YAb1y2K/pQt7euOTA84adR8hR226p8MEajuPtbBrFuaTYKssTZDE4SS6dRoaHKilfbBhVdrONQxyCCAo/bNTnHpEOnbQKXh5Q7UNI97ELH4Dhy6NBSskiU+JCUtLumACGB44CCN9TuvzAAnVqFhkoqApKqrBkGrF5FuaYAACAASURBVC8xK3oUt8/pwdt9o5TAp7jdNQWwu/w41W2XOhTJ7L8wCGuGHuuKs+Py+tHO/n4F7wuMDhLR/h6yWJT4kJRUW5yFwiyDYkfKOefY3zqArSssyDDQOudUdkdNAVr7x9Bjd0sdiiReifwO76YCHSmtvjIPOo1KsddkbyCE1y4O4faa/LhV2NRpVFizJEux32MgnPjUFGVCr6HuK1kc+skhKYkxht01BThycQhuv/IOdWvrH0eP3UOj5DIQ/T9Uamdmf8sAKqzpKM8TdzM4SSyTXoMdFbl4pWVQkcU6jlwcgicQivs1+Y7VBTjb44Q/JMS1nWQUCAl465qT7nskJpT4kJR1e00+fEEBRxR4cN7+lgEwBuyqplHyVFdiMaKqIEORZa3tLj9OXrFTR0Ymbq8pQJ/To8iSy/tbBpFp0GBzuSWu7URnRh0u5e1vtUfeM10vSCwo8SEpa1NZDsxGrSLXO+9vGUBdqRl5GXqpQyEi2F1TgFNX7Rie8EkdSkIdaBuEwKkjIxe7qvOhUmCxjmBIwMH2Qeyszo97pbEV1gyU55kmkwAlcbj9cSkVTpSFEh+SsjRqFXZW5+Ng2yACCpr2vzriQvvAOHUWZWR3TQE4Bw60KiuJf6VlAEuy07B6SabUoRAR5Jh02LQsR3GJz8krdjjdgYTtU9tdU4AxbxBBBVXQCwkco54gdteIXyqcKAslPiSl3RG5AZy4NCJ1KAmzf3IzOCU+clFdmIGSHCNeVlCHccIXxJHOYdxek08dGRm5o6YAFweVVXL55ZYBGLQq7FiZmAqbd0Su/Uo6zsERea+7V9N9j8SGEh+S0rZX5CJdr8EL5/ulDiVhXjjfj9VLMrE0xyh1KEQkjDHcuboARzuHFdOZOdg2CH9QwJ2rC6UOhYjojsj/p1KuySGB46ULA6hfaYVRp0lIm7XFWdCpVRiZUMa1AgBGXH5o1SxupcKJclDiQ1KaQavGbavy8XLLAPxB+S93uzbixrneUdxdWyR1KERke2uLEBS4YpYJPX+uHwWZBtSVmqUOhYioIMuAjWVm7FNI4vPmlREMjfuwd23iEnjGGCzpOox6Ahh1BxLWrlSi79Ni0setVDhRDkp8SMrbW1uIUU8Ax7qGpQ4l7va9fR0AcFctjZLLzeolmSi1GBXRYRz1BHDk4hDuqi2kjowM7a0tQsfgOC4OjksdStztO9+PNK0ajVXWhLZrMenAoYxCEq+0DIADsKTToaUkdpT4kJR3S0UeMg0aPH/+utShxN2+c/24qSQbxWZa5iY3jDHsrS3E8UsjGJF5dbdXWwfhDwnYSwm8LN25pgAqBuw7J+9rcjAk4OULA9hZnbhlblEmvQZ6jUoZ973z/dBpVEjXJ/Z7TOSJEh+S8nQaFXbXFODVlkF4AyGpw4mby0MTaO0fw15a5iZbe2uLJvcMyNm+89dRbE7DuqW0Xl+OrBkG3LzMgn3n+2V9mOnxSyOwu/ySXZMtJh2OXxpBUMZVTYMCx7GuYVhMNNtDxEGJD5GFvWuLMO4Lyvow033n+8EYcNcaGiWXq6qCDCzPM2GfjEdxHS4/jnYO467aQqrmJmN71xbi8rALrf3yPcx03/nrSNdrUF+ZmGpuN7Kk6xESOEZkfKaP3eVHUOC0zI2IhhIfIgtbl1tgNmplvT9i3/nr2Fiag4Isg9ShkDgJL3crwptX7LCNeaUOJy72twwgKHAq0CFzd64uhFrFZHtN9gfDy9xuW5UPg1YtSQxGnRrleSZZJz4jEz6UWYwwJXgpIZEvSnyILGjVKtyxuhAH2gbh8ctvudvFwXFcHJxIaOUgIo271xaCc+DFt+XZYdx3vh9lFiNqiujQUjnLMemwdbkF+85fl+Vyt6NdQxjzBiXfp7a3tgjj3qAsD/EOhITI95gGSYh4KPEhsnF3bSHc/hCaOmxShyK6feeuQ8VAZ54owAprBqoKMmQ5Uj484cPxS8PYW1tEy9wU4O7aIvTYPTjfOyp1KKLbd64fmQYNbqmQZplb1N2RxEuOsz72yHuiAT8iJkp8iGzcXG5BbrpedvsjOOfYd74fm8styMvQSx0OSYC9tYVovurAdadH6lBE9dKFAQicOjJKsbumAFo1k9012RsI4ZXWQeyuKYBOI203qiI/A2latSwPMx1x+WHQqlCZnyF1KERGKPEhsqFWMdy1pgAH22wY88rnULe3+0ZxediFu9fSdL9SRP+vn5NZOeBnz/ShwppOHRmFyDJqsaMiD8+du46QIJ/lbofabZjwBZPmmmxJ12HCF0SP3S11KKLpc3ow7g0i16Sn2WEiKkp8iKy8f30xfEEBL8homdAzp3uh06iwh6q5KUapxYQNpWY8c7pXNvsjuoddaL7qwPvXF/+/9u48PMrqXuD495edrCyBQAjZTNiCQgiySAFFBbUWZHGhoFRvixbRttbb2uu9dWtvV+2tWrVqaUVBRZCCgFhEXECCkLBDgBiSkIQQICQQAllmzv1jBouYkEBm5p2Z/D7Pw5PMO2/m/DjPyck579m0IdOOTB6cwOETdX51wPTinBLiokMZmRZrdSgAxEY6ZgK8m1tqcSSusyS3BIBYneWgXEw7PsqvXJEQQ3q3SBbllFgdikvUNdpYuq2M8RndiekQbHU4yoOmZiWwv6LGb9ZHLM4tIUBgUmZPq0NRHnRtv27EdAhmca5/1MlHTtbx8b4jTMpMIDDAOzrwoUEBRIcFsTjXPx6UGGNYnFtKVJjjkFalXElLlPIrIsKUrARyio5z4Ogpq8Nps7V5FVTVNjBlsDYW25tvX9GD0KAAv2gw2u2Gd3NL+VZ6V92OvZ0JCw7kOwN7sGpnuV9MQV66tRSb3TA1y7vq5K5RoRRX1rKp8LjVobRZbrHj73fXSB3tUa6nHR/ldyZl9iRA4F0/aDAuyimlW1So5TsHKc+LDgtmfEZ3lm0ro67Rt7dozz5wjNKq09qBb6emZvWirtHOSh+fgmyMYVFOCQN7dSStm3etU+scEUJESCCL/WC2w6KcUjoEB9JZDy1VbqAdH+V34qLDGJXelXdzS7H78ILaozV1fLy3gkmZPb1mSoXyrClZCVTVNvDRHt/eon1RTglRoUGMz+hudSjKAgMTYrisa4TPj17uKjtBXvlJpnphBz5AhBsv78GKHYew+/B0N7sxLN9Wxo0DuhOoawGVG2jHR/mlKVkJlFadJrvgmNWhXLKlW8totBumZCVYHYqyyLfSYomLDvXpBuOpukZW7Szn5oE9LDvhXlnr7BTkTYXHKfThKciLc0sICQzwmt3czjdlcAI1dY1fnX/ji47XNnCyrlH/7im30Y6P8kvj+scRFRbk05scLMop4YqEGHrr1r/tVmCAMCkzgbV7j3DkZJ3V4VySlTsOUVtvY8pgbci0Z5MzE3x6CnJ9o52lW8u4rn83OoZ75xSsYSmdSejUgaM1vllXgGPziPiYMEakdrE6FOWn2tTxEZFbRWSXiNhFZMgF7rtBRPaKSL6IPNKWNJVqjbDgQG6+Ip73d5ZTU9dodTgXbXfZCfYcOqGNRcXUrJ7Y7IalW31zq9rFuSUkdwknK6mT1aEoC3WPCWNkWiyLfXQK8sd7K6g8Ve/VdXJAgDB5cALVpxupt9mtDueiNdjsVJ9uYPLgBAJ0erdyk7aO+OwEJgOfNneDiAQCfwFuBPoD00SkfxvTVapFU7N6crrB5pMLahfllBAcKEzw0ikVynPSukUxMCGGRT54ps/BylqyCyr17B4FOLZo99UpyItySoiNDGF0bxdtNDN/PmzMhk8+geRkmD27+dexsfD5+la99/03/8Cg0jxC1n124Z9rQxouea+JewM3bGBY8Q5+9P3r3ZaGJ/4f7S6N+fNd8zvhIW3q+Bhj9hhj9rZw21Ag3xhTYIypB94CJrYlXaVaY3BiJ9K7RfLGxiKrQ7kop+ttLMo5yLiM7nSK8M4pFcqzbr8ykbzyk+QU+dZWtW9sLCJAHA1epcZndKdjeLDP1cllVaf5cM9hpmQlEBzoghUC8+fDrFlwxjklragIXnyx+dfHjkFDY6vei/77q4TaGlr+uTak4ZL3mrg3wOa4N7jkoNvS8MT/o92lMWuWT3V+PLHGpydw8JzXJc5rSrmViHDniCS2l1Sz9WCV1eG02tKtpZw408hdw5OsDkV5iVsy44kKC2LeBt9pMJ5psLFw00Gu7x9HfMcOVoejvEBYcCC3DenFB7sOU159xupwWm3BxmIMMGOYi+rkRx+F2lrXfJZSVqutdZRpHxHU0g0i8iHQ1B6kjxpjlrYijabmNzQ7X0NEZgGzABITE1vx8Uo1b1JmT373fh7zNhQyqNcgq8NpkTGGeRuK6Ns9iqEpna0OR3mJ8JAgpmYl8EZ2ERUn+9EtyvsPAV2+/RDHaxuYOSLZ6lCUF5kxLIlXPitgwRfFPHR9b6vDaVFdo423NhVzbd9u9Ooc7poPLS4GoH9FwdcuX+i1O97zRBpWp69peCaNs2XaF4gr5oyLyMfAw8aYzU28NwJ43Bgz3vn6FwDGmN+09LlDhgwxmzd/4yOVuii/XLqTt744yIZfjKWLl58EvbmwkqkvbeDXkwYw3VVPF5VfKDhSw9inP+Gh63vz4LXpVofTognPr6O23sbqn4zW9T3qa+75xya2l1Tz+SNjCQny7s1l/7mllB+/vZXX7hnKGFet70lOdkwRUspfJCVBYaGlIYhIjjGm2Y3WzvJEjbMJSBeRFBEJAe4AlnkgXaUAuHN4EvU2O29vPtjyzRabt6GIqLAgbhmks0HV16V2jWRUeiwLNhbT6OU7Nm09WMX2kmruGpGknR71DXeOSOJoTR2rdpVbHUqL5m0oJCU2glFpsa770F//GsJdNHqklNXCwx1l2ke0dTvrSSJSAowAVojIB87r8SKyEsAY0wjMAT4A9gALjTG72ha2Uq2XHhfFiNQuzM8uxubF26hWnDzD+zsPMTUrgYjQFmehqnborhHJlJ84w+rdh60O5YLmbSgkIiSQSZnagVffNCa9K0ldwnl9Q6HVoVzQztJqcourmDE8ybXbK0+fDi+/7HhKLuL4+sMfNv+6SxfHv4t8ryYyhuMdojFuTOOS33O+ticmYkc4GRnttjQ88f9o12m8/LKjTPuINrWujDFLgCVNXC8Dbjrn9UpgZVvSUqotZl6VxH1v5LJmz2HGZTS1ZM16b31xkAab4U7d1EA1Y2zfbvTs2IHXNhRy4+U9rA6nScdq6li+7RC3X9mLqLBgq8NRXiggQLhzeBK/WrGH3WUn6B8fbXVITZq3oZAOwYHu2ZVw+nS3Nxb3FlUy5UXvnjq98ItiHnl3BwvvHaHrWpVHePfkWqVc5Lp+cfSICeP1bO+cV91gs7NgYzGj0mNJ7RppdTjKSwUGCDOGJ5FdUMm+wyetDqdJb28+SL3Nzl0jvLOhpbzDrVm9CAsO4PXsQqtDaVJVbT1Lt5ZxS2ZPYjr4Zgd+cGIn+veI5vUNRV55Bti5m/lcmawHHCvP0I6PaheCAgOYPiyRz/YfZXfZCavD+YYV2w9RfuKM7oClWnT7lb0IDQrg1c8KWr7Zw+oabcz7vIirLutCelyU1eEoLxYTHswtg3rybm4pR07WWR3ON7yRXURdo2934EWEmVclkVd+knX5R60O5xs2fHmM3YdOMPOqZF0LqDxGOz6q3bhzeDKRoUH8ZW2+1aF8jd1ueH5tPn3iohjbt5vV4Sgv1zkihGlDE3k3t5SDld51Fsg7m0soP3GG2VenWR2K8gH3jrmMBpvd6zrxp+oa+du6A4zt241+PbxzGl5r3ZLZkx4xYTy3xrv+7gE8+9F+4qJDdS2g8ijt+Kh2IyY8mJlXJbFy5yHyK7xnmtD7O8vJr6hhztg01y6gVX7r3jGpiMBLn3xpdShfabDZefHjL8lM7MjItC5Wh6N8QEpsBN8ZGM/r2UVUnqq3OpyvvJFdxPHaBuaM9f0OfGhQIPeOTuWLwkqyC45ZHc5XNhVWkl1Qyb2jLyMsONDqcFQ7oh0f1a7cMzKFsKBAnv/IO55+2e2G5z7aT2rXCG7y0sXqyvv0iOnA1KxejhGW6jNWhwPAktxSSqtO88DYNJ22olrt/mvSqK23MXfdAatDAeB0vY1XPivgW2mxDE70j3UndwxNJDYylOc+2m91KF95ds1+YiMdo9dKeZJ2fFS70iUylBnDE1m2rYzCo6esDoc1eRXklZ/k/qvTCNTRHnURZl99GTZj+Oun1o/6NNrsvPBxPgN6RnNNH52uqVqvd1wUNw7ozmufF1J9usHqcHhrUzFHa+p5wA9Ge84KCw5k1ugU1ucfI6fouNXhsPVgFZ/tP8r3R6XSIURHe5RnacdHtTs/GJ1KcGAAL3xs7aiPMY7RnsTO4UwcFG9pLMr39OoczqTMnizYWGz54vDl2w9ReKyWOdek62iPumhzxqZxsq6R1z4vtDSOukYbf/2kgKEpnRmW6l/TNacPS6JTeDDPe8Goz3Nr9tMxPJgZenSDsoB2fFS70y0qzCsWh3+y7wjbS6qZffVlBAXqr6K6ePdfk2b54vBzN+cY1z/OsjiU78qIj+G6ft2Yu/4ANXWNlsVxdnOOB8emWxaDu0SEBvH9Uams3XuEHSXVlsWxs7SaNXkV/MfIFCL1oG5lAW1tqXbp3jGpBIhYNufZbjf86cP99OzYgcmD3XA4nmoXzl0cfviENWt9lm0r0805VJs9MDadqtoGy9b6nK638cLafL/enOOuEUlEhwXxzOq9lsXwp9X7iAoLYubIZMtiUO2bdnxUu9QjpgPfG5nMOzklbD1Y5fH0F+WUsO1gFQ9d35uQIP01VJfuoet702gz/GblHo+nXVPXyG/e38PlPWN0cw7VJgN7deSmy7vzwsf5lBz3/Ej8ix/nU1Z9hkdu6Ou30zWjwoJ5YGw6a/ceYc2ewx5Pf21eBWvyKrj/mjSiw3zzUFjl+7TFpdqtB69Np2tkKL9cuhOb3XOnWlfXNvDbVXkMSerE5MF6foFqm6QuEdw7JpV/bi1jo4e3q312zX4On6jjyYkZujmHarNHv90fQfjVcs924ouOneKlTwuYOCje79b2nO97I5NJ6xbJE+/t5kyDzWPpnmmw8fh7u7isawT3jEzxWLpKnU87PqrdigwN4tFv92N7STULNx/0WLrPrN5LVW09T0zM8Nsni8qzZl+dRs+OHXhs2S4abXaPpJlfcZK56w5w+5BeZPrJtr/KWj07dmDO2DRW7Srn031HPJbuk+/tJjhA+K+b+nksTasEBwbwxIQMiitreflTz60NfPWzAoqO1fL4hAyd5aAspaVPtWsTBsYzNKUzv1+VR1Wt+w/Q21VWzevZRcwYnkRGfIzb01PtQ4eQQP7n5n7klZ/k9ewit6dnjOGxZbsIDwnkZzf0cXt6qv34/qgUkruE8/h7u6hvdH8nfs2ew6zJq+BH16UTFx3m9vS8wci0WL59eQ/+sjbfIxv8lByv5fm1+dw4oDuj0ru6PT2lLkQ7PqpdExGemJDBiTON/OED9y74NMbw2NJddAwP4afXa2NRudb4jO6MSo/lmX/tc/v21it3lLM+/xgPj+9Dl8hQt6al2pfQoEAem5BBwZFT/M3NGx2cabDxxHu7SesWyd3tbPrVo9/uR4AITy3f7fa0zk5d/O+b+7s9LaVaoh0f1e716xHNncOTWPBFMdluXCPxRnYRm4uO8/Mb+hATrgs7lWuJCI9PyOBMo41fLt2JMe5Zt3a0po4nl++iX49ovqunris3uKZPN67rF8eza/aTX1HjtnT+tHofxZW1PDEhg+B2dqRAvHNa4b92H2bF9kNuS2fVzkOs2lXOnGsc03GVslr7+k1XqhkPj+9DSmwEcxZsccu2wFuKj/Pk8t2M6d2VW7N6ufzzlQK4rGskD4/rw/s7y93ytLzRZufBN7dQVdvAH6ZeoedPKbd56pYMwkMCue+NHE654WyfVTvL+eunBXx3WCIj02Jd/vm+4AejUhnUqyM/W7TNLR3ML4/U8PA72xmYEMMPRqe6/POVuhT6V0spHBsdvDQji9r6Ru6fn0uDCxeIH6upY/b8XOKiw/jzHYP0rBPlVrNGpzI+I47fvJ/n8l3enl69j8+/PMZTtwxgQE9do6bcp0dMB56blknBkRp+tni7S0cwC47U8PA72xiYEMNj32m/069CggJ4ccZgwoJd38GsrW/kh2/kEBwovDAji9CgQJd9tlJtoR0fpZx6x0XxuylXsLnoOP/rojNRbHbDg29t4dipel6akUXH8BCXfK5SzRER/njrQJI6hzPnzS1UuGgE84Nd5bz48ZdMG5rIbUN01FK531Vpsfzn+L6s2H7IZSOYtfWN3KcN8q+4o4NpjOGRxTvIr6jhuWmDdYqb8ira8VHqHN8ZGM89I1P4+/pClmwpadNnGWP4/Qd5rM8/xq8m6hNy5TlRYcG8dGcWNWcamT0/t83ndeRX1PDwwm1c0c6fkCvPu2/Mv0cwP//yaJs+y243/HzxDvZX1PDstExtkDud28F85bO2b3H9t3UHWLatjJ+O68O30tvnNELlvbTjo9R5fnFTX4amdOanC7cxb0PhJX2GzW54fNku/vqJYw75bVfqE3LlWb3jovj9VMcI5vRXN1J56tK2a99cWMmtL31OSFAAL0x3TItRylNEhD/cOpDkLuHc/fdNvL/j0hbin663MXt+Lu9tK+M/x/fRbZXPc9+YVG4c0J3/XZnHM6v3XdLIjzGGP3+4n1+t2MO4/nH8cMxlbohUqbbRjo9S5wkODOAfd1/J2L5x/HLpLp5avhubvfV/BE7VNTJr3mZe21DErNGp/GriADdGq1TzvjMwnr98dzA7SquZ/MJ6Dhw9dVE/v3x7Gd99dSMdw0NY/MOrSOgU7qZIlWpedFgwC+8dQf/4aGYvyOXVzwouqmF+tKaOaa9k88Hucv7n5v7MvjrNjdH6JhHhz3dkcmtWAs+u2c9PF267qHOU6hvtPPzOdv704T6mDE7g+e8O1vWsyiuJu7Y8dYUhQ4aYzZs3Wx2GaqdsdsNTy3fzj88LGZ8Rx68nXU5sC2eWHDh6igfezGV32QmemJDBnSOSPROsUheQU1TJD+blYIzh/+7IZHR6LCLNN0rONNh45dMCnl69jyFJnXjlriF0itD1acpaZxps/OTtrby/s5wZwxP5+Q19iQq78NEA20uquH9BLkdO1vF/t2dyw4DuHorWNxljeP6jfJ5evY/hqZ155rZBxLcwJfBQ9WkeensbGwqO8ZPrevPgtWkXrF+UcgcRyTHGDGnxPu34KHVhc9cd4KkVuwkODOCWQfHcPTKFfj2iv3rfGMOGgmPMXVfImrzDdAgO5LlpmVzbL87CqJX6usKjp7j7H5s4cPQUGfHR3DMyhZsH9vja4u6Kk2eYn13M/I1FHK2p5+YrevDHWwfq9DblNex2w29X5fHypwVEhgZx25BefO+qZBK7/Hs00mY3rNlzmLnrD5BdUElsZAiv3DWEzMROFkbuW/65pZSfLdqOzRhuHNCde76VwuDz8m9L8XHmri9k5Y5DBAj8dvIVTMlKsChi1d5px0cpF8qvOMnf1xeyOLeEMw12UmIjCHIO49fW2yitOk3niBCmD0tkxvAk4qLDLI5YqW86XW9jyZZS5q4/QH5FDZ3Cg78axTRA8bFa6m12xvbtxj0jUxiZ1kWf3CqvtO1gFXPXH2DF9kPYjCE1NoIAZ1mtPt1Axck64mPCmHlVMndcmaiHRl+Cg5W1zNtQyFtfHORkXSO9OncgzPmgpK7RTnFlLVGhQdx+ZS9mXpVMr846FVZZRzs+SrlBVW09b206yPaSqq+uiQhj0rsyYVC8PhlXPsEYw7r8oyzZUvq1Hd96xHRg+rBEUrtGWhidUq1XXn2GBRuLyD/y7wM4gwICuGFAd8b1j9NDdl2gpq6RxTklfHGgEoOjzSgIVyZ3YuqQXkSGBlkcoVLa8VFKKaWUUkq1A63t+LTpUYiI3Coiu0TELiLNJiYihSKyQ0S2ioj2ZJRSSimllFIe1dbxyZ3AZOCvrbj3GmNM204fU0oppZRSSqlL0KaOjzFmD6CLX5VSSimllFJezVOr/gzwLxHJEZFZHkpTKaWUUkoppYBWjPiIyIdAUyd+PWqMWdrKdEYaY8pEpBuwWkTyjDGfNpPeLGAWQGJiYis/XimllFJKKaWa12LHxxhzXVsTMcaUOb9WiMgSYCjQZMfHGPMy8DI4dnVra9pKKaWUUkop5fapbiISISJRZ78HxuHYFEEppZRSSimlPKKt21lPEpESYASwQkQ+cF6PF5GVztvigHUisg34AlhhjFnVlnSVUkoppZRS6mJ49QGmInIEKLI6DqdYQLfjdi/NY8/QfHY/zWP30zx2P81j99M89gzNZ/ezOo+TjDFdW7rJqzs+3kRENrfmRFh16TSPPUPz2f00j91P89j9NI/dT/PYMzSf3c9X8thT21krpZRSSimllGW046OUUkoppZTye9rxab2XrQ6gHdA89gzNZ/fTPHY/zWP30zx2P81jz9B8dj+fyGNd46OUUkoppZTyezrio5RSSimllPJ72vFpBRG5QUT2iki+iDxidTz+QER6ichaEdkjIrtE5EfO64+LSKmIbHX+u8nqWH2ZiBSKyA5nXm52XussIqtFZL/zayer4/RVItLnnLK6VUROiMiPtRy3nYjMFZEKEdl5zrUmy644POuso7eLyGDrIvcdzeTxH0Qkz5mPS0Sko/N6soicPqdMv2Rd5L6jmTxutn4QkV84y/FeERlvTdS+pZk8fvuc/C0Uka3O61qOL8EF2mw+VyfrVLcWiEggsA+4HigBNgHTjDG7LQ3Mx4lID6CHMSZXRKKAHOAW4DagxhjzR0sD9BMiUggMMcYcPefa74FKY8xvnR35TsaYn1sVo79w1hWlwDDgbrQct4mIjAZqgHnGmAHOke8iAgAABBhJREFUa02WXWfD8QHgJhz5/2djzDCrYvcVzeTxOOAjY0yjiPwOwJnHycDys/ep1mkmjx+nifpBRPoDbwJDgXjgQ6C3Mcbm0aB9TFN5fN77TwPVxpgntRxfmgu02b6Hj9XJOuLTsqFAvjGmwBhTD7wFTLQ4Jp9njDlkjMl1fn8S2AP0tDaqdmMi8Jrz+9dwVF6q7a4FvjTGeMuhyz7NGPMpUHne5ebK7kQcjR5jjMkGOjr/UKsLaCqPjTH/MsY0Ol9mAwkeD8yPNFOOmzMReMsYU2eMOQDk42iDqAu4UB6LiOB4oPqmR4PyMxdos/lcnawdn5b1BA6e87oEbaC7lPMJTCaw0XlpjnNodK5Ow2ozA/xLRHJEZJbzWpwx5hA4KjOgm2XR+Zc7+PofVy3Hrtdc2dV62j3uAd4/53WKiGwRkU9EZJRVQfmJpuoHLceuNwo4bIzZf841LcdtcF6bzefqZO34tEyauKbzA11ERCKBxcCPjTEngBeBy4BBwCHgaQvD8wcjjTGDgRuB+51TApSLiUgIMAF4x3lJy7FnaT3tYiLyKNAIzHdeOgQkGmMygYeABSISbVV8Pq65+kHLsetN4+sPpLQct0ETbbZmb23imleUZe34tKwE6HXO6wSgzKJY/IqIBOP4BZpvjHkXwBhz2BhjM8bYgVfQYf42McaUOb9WAEtw5Ofhs0POzq8V1kXoN24Eco0xh0HLsRs1V3a1nnYhEZkJ3AxMN86FwM7pV8ec3+cAXwK9rYvSd12gftBy7EIiEgRMBt4+e03L8aVrqs2GD9bJ2vFp2SYgXURSnE917wCWWRyTz3POu/0bsMcY88w518+dAzoJ2Hn+z6rWEZEI5yJERCQCGIcjP5cBM523zQSWWhOhX/naU0Utx27TXNldBtzl3EloOI6FzIesCNDXicgNwM+BCcaY2nOud3Vu4IGIpALpQIE1Ufq2C9QPy4A7RCRURFJw5PEXno7Pj1wH5BljSs5e0HJ8aZprs+GDdXKQ1QF4O+fONnOAD4BAYK4xZpfFYfmDkcCdwI6z20wC/wVME5FBOIZEC4F7rQnPL8QBSxz1FUHAAmPMKhHZBCwUkf8AioFbLYzR54lIOI5dH88tq7/Xctw2IvImcDUQKyIlwGPAb2m67K7EsXtQPlCLY1c91YJm8vgXQCiw2ll3ZBtj7gNGA0+KSCNgA+4zxrR20X671UweX91U/WCM2SUiC4HdOKYZ3q87urWsqTw2xvyNb667BC3Hl6q5NpvP1cm6nbVSSimllFLK7+lUN6WUUkoppZTf046PUkoppZRSyu9px0cppZRSSinl97Tjo5RSSimllPJ72vFRSimllFJK+T3t+CillFJKKaX8nnZ8lFJKKaWUUn5POz5KKaWUUkopv/f/OSwUunXOp6YAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot first samples of tx_signal\n",
    "plt.plot(tx_signal[100:300])\n",
    "plt.stem(data_tx[100:300],markerfmt = 'ro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "tx_fft = np.abs(np.fft.fft(tx_signal))\n",
    "N = int(len(tx_fft)/2)\n",
    "#plt.plot(np.linspace(0,1,N) * (Fs/2), tx_fft[0:N]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "#modulate signal on 2 orthogonals carriers\n",
    "carrier_1 = tx_signal * np.cos(np.arange(0,len(tx_signal)) * 2 * np.pi * (modulation_freq_1/Fs))\n",
    "carrier_2 = tx_signal * np.cos(np.arange(0,len(tx_signal)) * 2 * np.pi * (modulation_freq_2/Fs))\n",
    "tx_signal_modulated = carrier_1 + carrier_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "tx_modulated_fft = np.abs(np.fft.fft(tx_signal_modulated))\n",
    "N = int(len(tx_fft)/2)\n",
    "#plt.plot(np.linspace(0,1,N) * (Fs/2), tx_modulated_fft[0:N]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "rx_file = tx_signal_modulated.tofile(\"tx.txt\",sep='\\n',format='%f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python client.py --input_file=tx.txt --output_file=rx.txt --srv_hostname=iscsrv72.epfl.ch --srv_port=80"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Channel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "# channel\n",
    "#frequency cut\n",
    "erase_indice = random.randint(1,4) #band to erase \n",
    "channel_signal = tx_signal_modulated\n",
    "channel_signal_fft = scipy.fftpack.fft(channel_signal)\n",
    "N = len(channel_signal_fft)\n",
    "erase_low_freq = (erase_indice * 2000 - 1000) * N  / (Fs)\n",
    "erase_high_freq = erase_low_freq + (2000 * N / (Fs))\n",
    "channel_signal_fft[int(erase_low_freq):int(erase_high_freq)] = 0\n",
    "channel_signal = scipy.fftpack.ifft(channel_signal_fft)\n",
    "\n",
    "#noise\n",
    "noise_length = 1100\n",
    "noise = noise = np.random.normal(0,0.05,len(tx_signal_modulated)+noise_length)\n",
    "#rx_signal = np.concatenate((np.zeros(noise_length),channel_signal)) + noise\n",
    "#rx_signal = channel_signal + noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plt.plot(rx_signal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "#N = int(len(rx_signal)/2)\n",
    "#rx_fft = np.abs(np.fft.fft(rx_signal))\n",
    "#plt.plot(np.linspace(0,1,N) * (Fs/2), rx_fft[0:N]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_sequence_bis = [+1, +1, +1, +1, +1, -1, -1, +1, +1, -1, +1, -1, +1]\n",
    "training_upsampled = np.repeat(start_sequence_bis,sample_per_bit)\n",
    "training_signal = np.sqrt(2) * np.sin(np.arange(0, len(training_upsampled)) * 2 *np.pi * sample_per_bit) * training_upsampled "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "rx_signal = np.fromfile(\"rx.txt\",sep='\\n',dtype='float')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "#lowpass filter\n",
    "def butter_lowpass(cutoff, fs, order=5):\n",
    "    nyq = 0.5 * fs\n",
    "    normal_cutoff = cutoff / nyq\n",
    "    b, a = sp.butter(order, normal_cutoff, btype='low', analog=False)\n",
    "    return b, a\n",
    "\n",
    "def butter_lowpass_filter(data, cutoff, fs, order=5):\n",
    "    b, a = butter_lowpass(cutoff, fs, order=order)\n",
    "    y = sp.filtfilt(b, a, data)\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "# demodulate both carriers\n",
    "rx_demod_carrier_1 = rx_signal * np.cos(2 * np.pi * (modulation_freq_1/Fs) * np.arange(0,len(rx_signal)))\n",
    "rx_demod_carrier_2 = rx_signal * np.cos(2 * np.pi * (modulation_freq_2/Fs) * np.arange(0,len(rx_signal)))\n",
    "#fft\n",
    "#rx_demod_carrier_1_fft = np.abs(np.fft.fft(rx_demod_carrier_1))\n",
    "#rx_demod_carrier_2_fft = np.abs(np.fft.fft(rx_demod_carrier_2))\n",
    "#N = int(len(rx_demod_carrier_1_fft))\n",
    "#plt.plot(np.linspace(0,1,N) * (Fs/2), rx_demod_carrier_1_fft[0:N]);\n",
    "#plt.figure()\n",
    "#plt.plot(np.linspace(0,1,N) * (Fs/2), rx_demod_carrier_2_fft[0:N]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "#filter both carriers\n",
    "rx_demod_carrier_1 = butter_lowpass_filter(rx_demod_carrier_1,Fc + 100, Fs, 5)\n",
    "rx_demod_carrier_2 = butter_lowpass_filter(rx_demod_carrier_2,Fc + 100, Fs, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "rx_demod_carrier_1_fft = np.abs(np.fft.fft(rx_demod_carrier_1))\n",
    "rx_demod_carrier_2_fft = np.abs(np.fft.fft(rx_demod_carrier_2))\n",
    "N = int(len(rx_demod_carrier_1_fft))\n",
    "#plt.plot(np.linspace(0,1,N) * (Fs/2), rx_demod_carrier_1_fft[0:N]);\n",
    "#plt.figure()\n",
    "#plt.plot(np.linspace(0,1,N) * (Fs/2), rx_demod_carrier_2_fft[0:N]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "#choose unaltered carrier\n",
    "if rx_demod_carrier_1_fft.sum() > rx_demod_carrier_2_fft.sum() :\n",
    "    rx_signal_demod = rx_demod_carrier_1\n",
    "else :\n",
    "    rx_signal_demod = rx_demod_carrier_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7338\n",
      "6264\n"
     ]
    }
   ],
   "source": [
    "#samplinf offset synchronization\n",
    "init = int(np.argwhere(rx_signal_demod>0.2)[0]) \n",
    "print(init)\n",
    "corr = sp.correlate(rx_signal_demod[0:init + 1000],training_signal,mode='valid')\n",
    "shift = np.argmax(corr)\n",
    "print(shift) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "rx_signal_demod_shifted = rx_signal_demod[shift: (shift + data_size * sample_per_bit)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28649"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#computer the inner product with the base signal to determine bit sent\n",
    "pulse = np.sqrt(2) * np.sin(np.arange(0, sample_per_bit) * 2 *np.pi * sample_per_bit)\n",
    "signal_correlated = np.correlate(rx_signal_demod_shifted,pulse, mode='full')\n",
    "len(signal_correlated)\n",
    "#plt.plot(rx_signal_demod_shifted[0:3000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "matched_filter_output = signal_correlated[np.arange(1,data_size + 1) * sample_per_bit]\n",
    "if matched_filter_output[0] > 0 :\n",
    "    pass\n",
    "else : \n",
    "    window_offset = - int(sample_per_bit/2)\n",
    "    matched_filter_output = signal_correlated[np.arange(1,data_size + 1) * sample_per_bit + window_offset]\n",
    "received_data = np.zeros(data_size, int)\n",
    "received_data [matched_filter_output>0] = 1\n",
    "#print(data[0:20])\n",
    "#print(received_data[0:20])\n",
    "#print(data_size * sample_per_bit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "#compute number of errors\n",
    "err = abs(received_data - data).sum()\n",
    "print(err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "565\n"
     ]
    }
   ],
   "source": [
    "def find_subsequence(seq, subseq):\n",
    "    target = np.dot(subseq, subseq)\n",
    "    candidates = np.where(np.correlate(seq,\n",
    "                                       subseq, mode='valid') == target)[0]\n",
    "    # some of the candidates entries may be false positives, double check\n",
    "    check = candidates[:, np.newaxis] + np.arange(len(subseq))\n",
    "    mask = np.all((np.take(seq, check) == subseq), axis=-1)\n",
    "    return candidates[mask]\n",
    "stop_index = find_subsequence(received_data,stop_sequence)\n",
    "stop_index = stop_index[len(stop_index) - 1]\n",
    "print(stop_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fewkfh wafh ifew fahw  fje fa ff wfew !!! Wehaf lf fewjfi ewfj ;)) :)'"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#decode data\n",
    "decode = received_data[len(start_sequence):stop_index]\n",
    "message = np.packbits(decode)\n",
    "message = str(message.tobytes(),\"utf-8\",\"ignore\")\n",
    "message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzUAAACgCAYAAAA1r0KBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAHTBJREFUeJzt3Xm4XXV97/H3JyMQhlhBJAmTBKPIBRVFvIKkttdZ0UetUBQp2GitFb3VVkVaHLjV1mq1WtoICCIXUewQlas4RUAljAJFxaaMgYgIYUqYknzvH2sd2RyTnCE72dlnv1/Ps5+95vVd+3yzsr/791trpaqQJEmSpH41qdcBSJIkSdLGsKiRJEmS1NcsaiRJkiT1NYsaSZIkSX3NokaSJElSX7OokSRJktTXLGokaYJK8s9JTmiH5ydZ1uuYJEnaFCxqJE14SW5M8vu9jmNTSHJ0kjVJ7u94fQagqt5aVR9ez3pd/0zabT4wLJZZ3dxHv0hSSVa2n8GtST6RZHKv45KkiWpKrwOQJG20H1fVwZtrZ0kCpKrWrmP2K6rqOyOsP6WqVm+a6LYo+1fV0iRzgR8APwM+1+OYJGlCsqVG0kBL8sdJlia5K8mioZaFJB9M8o/t8NT2V/e/bce3TvJgkscl2aP9VX5BktuSLE/y5x3bPzDJj5Pc3c77TJJp7bwk+WSSXyW5J8nVSfZt5700yU+T3Nf+0v/ucRzb6Uk+so7pZwK7AV9rWxL+op1+UJIftbFelWR+xzqLk5yU5IfAKuBJY4hj6DM6NsnNwPdGsb89k/ygPf5vt5/bF9t5v9WVrrPlKcmkJO9N8t9J7kzy5SS/MyyWNyW5OcmvkxzfsZ3JSd7frntfksuT7Jrks0n+ftg+v5bknSMdf1UtBX4IPL1j3R2SnNrmxK1JPjLUkpNkbnvs97TxndOxXiV5R5Lr23l/l2RSx3F/IMlNbU59IckOozzuA5NcluTeJLcn+UTHvPX+nSRpS2FRI2lgJXkB8DfAHwC7ADcBX2pn/wCY3w4/G/glcGg7/lzguqpa0bG53wX2Bl4IvDePdu1aA7wL2LFd7/eAt7XzXgg8H3gyMBN4PXBnO+9U4C1VtR2wL20h0A1V9UbgZppWlW2r6m+TzAa+AXwE+B3g3cBXk+zUseobgQXAdjSf1VgdCjwVeNEo9vd/gctpPrcPA28aw37eAbyq3d8sYAXw2WHLHAzMo/l7/FWSp7bT/zdwBPBSYHvgGJoi7gzgiI4CYsd23bNHCibJU4BDgKUdk88AVgNzgWfQ5MKb23kfBs4HHgfMAf5x2CZfDTwLeCZwWBsjwNHt63dpis5tgc+M8rg/BXyqqrYH9gK+3MY+mryQpJ6zqJE0yI4ETquqK6rqIeB9wHOT7AH8GNg7yeNpCo9TgdlJtqX5svyDYdv6YFWtrKprgM/TfDGmqi6vqouranVV3Qj8C48WR4/QFAhPoenO9bOqWt4xb58k21fViqq6YgPHcVD7K/rQ66BxfBZvAM6rqvOqam1VfRu4jObL/ZDTq+ra9lgeWc92/r0jjn8fNu/E9jN6YEP7S7IbTSF5QlU9VFUXAF8bw7G8BTi+qpa1f9cTgdcm6exy/cGqeqCqrgKuAvZvp78Z+EBVXVeNq6rqzqq6BLiHphgAOBxYXFW3byCOK5KspOl2thj4J4AkOwMvAd7Zfh6/Aj7ZbhOav/3uwKyqerCqLhq23Y9V1V1VdTPwD7S5RpPPn6iq66vqfpp8PnyUx/0IMDfJjlV1f1Vd3E4fTV5IUs9Z1EgaZLPoaHFovwjeCcxuv3hfRlOAPJ+miPkR8DzWXdTc0jF8U7ttkjw5ydeT/DLJvcD/oWl9oKq+R/NL+meB25MsTLJ9u43X0HxxvKntivTcDRzHxVU1s+N18QaWXZ/dgdd1Fkc0v+rvsp5jXJ9XdcTxqmHzOtff0P5mASuqamXH8mNpGdod+LeO7f6MpsVs545lftkxvIqmVQNgV+C/17PdM2i+5NO+nzlCHM9st/t64DnAjI74pgLLO2L8F+AJ7fy/AAJckuTaJMc8drPrzjWG5XM7PIXRHfexNC2GP09yaZKXd8Q6Ul5IUs9Z1EgaZLfRfGkDIMkM4PHAre2kHwAvoOkedGk7/iLgQOCCYdvatWN4t3bbACcDPwf2brv2vJ/mCysAVfXpqjoAeBrNl8r3tNMvrarDaL7o/jttd6AuqmHjtwBnDiuOZlTVRzewzsbsc0P7Ww48rv17DNmtY3glsM3QSHstSmd3qFuAlwzb9lZVdSsju4Wm+9W6fBE4LMn+NN3ohrdE/Za2tefLNC1/f9Wxj4eAHTvi276qntau88uq+uOqmkXT6vRPaW42MGR9ufaYfG7nrQY21Jo0FOd/VdURNPn2MeDc9vMfTV5IUs9Z1EgaFFOTbNXxmkJz3cYfJXl6kuk0rShL2m5i0BQxRwE/raqHaboQvRm4oaruGLb9E5Jsk+RpwB8BQxd3bwfcC9zfXlvxJ0MrJHl2kuckmUrzRf1BYE2SaUmOTLJD283rXpqWhm66ncde7P9F4BVJXpTmYvmt0lyQP6fL+x1xf1V1E00r2Qfbz+Jg4BUd6/4C2CrJy9rP7gPA9I75/wyclGR3gCQ7JTlslHGdAnw4yd5p7Nd2QaSqltEUt2cCX21b80bro8CCJE9suxieD/x9ku3TXOC/V5JD23hf1/G5r6ApBjv//u9Jc5OKXYHjeDTXzgbeleYmC9vS5PM5o7nTXJI3JNmpvaPd3e3kNWz+vJCkcbGokTQozgMe6HidWFXfBU4AvkrTOrAXj17XAE13s615tFXmpzSFx/BWGmgKoKXAd4GPV9X57fR3A38I3EdzO99zOtbZvp22gqar0J3Ax9t5bwRubLusvZVHuz11y98AH2i7FL27qm6huej8/cAdNL/Qv4dN9P/EKPb3hzRdtu4C/hr4Qse699DcbOEUmla1lUDn3dA+BSwCzk9yH3Bxu63R+ARNq9j5NMXkqTQ5MOQM4H8wctezx2ivtfoBbUscTbE8jSanVgDn8miXrmcDS5Lc3x7HcVV1Q8fm/oPmJgo/obmI/9R2+mltXBcAN9Dk6p+NMsQXA9e2+/wUcHh7Pc9mzQtJGq9UbWxvAkkaXO1NBW4Apo7mF3GNT5ITgblV1e3ibqxxPJ+m9WKPWvdzejb1/oumK+PSEReWpAHiLy2SJI1C29XtOOCUXhQ0kqT1s6iRJGkE7fNc7qbpIvYPPQ5HkjSM3c8kSZIk9TVbaiRJkiT1NYsaSZIkSX1tSq92PHPmzJo7d+7IC3bZddddB8C8efM2+7618VauXMmMGTNGXlDqYN5orMwZjYd5o/Ewbzbs8ssv/3VV7TTSciMWNUlOA14O/Kqq9l3H/NDc0/6lwCrg6Kq6YqTt7rzzzlx22WUjLdZ18+fPB2Dx4sWbfd/aeIsXL/7N31AaLfNGY2XOaDzMG42HebNhSW4azXKj6X52Os1DudbnJcDe7WsBcPJodixJkiRJ3TBiS01VXdA+XG59DgO+UM1t1C5OMjPJLlW1fEPbXblyCuedN6ZYf8ukSc1r8uRHh6dNgyc+EebMgalTN277kiRJkrZ83bimZjZwS8f4snbabxU1SRbQtOYAB/Cyl3Vh7+ux9darOfjgX3PssTew884P/Wb63XffDdj9rF/df//9/u00ZuaNxsqc0XiYNxoP86Y7ulHUZB3T1vnwm6paCCwE2H33feorXxn/Tqua19q1j77WrIGHHoLbboMlS6bwxS8+kWuueSIXXQR77dWsN3PmTAD7LvYp+51qPMwbjZU5o/EwbzQe5k13dKOoWQbs2jE+B7htpJW22moNBx7Yhb2vxzHHwHHHwfOeB0cfDRdcAFlX+SVJkiSpr3XjOTWLgKPSOAi4Z6TraTaXffaBj34ULroIvvOdXkcjSZIkaVMYsahJcjbwY2BekmVJjk3y1iRvbRc5D7geWAp8DnjbJot2HI4+GnbcEU47rdeRSJIkSdoURnP3syNGmF/An3Ytoi6bPh1e8xo480x48MFeRyNJkiSp27rR/WyL97KXwapVsGRJryORJEmS1G0DUdQcckhzkwDvlidJkiRNPANR1MycCfvua0uNJEmSNBENRFEDsP/+cPXVvY5CkiRJUrcNVFFz663wyCO9jkSSJElSNw1MUbPffs37ypW9jUOSJElSdw1MUfPUpzbvq1b1Ng5JkiRJ3TUwRc3s2TBtms+qkSRJkiaagSlqJk2CPfeEBx7odSSSJEmSumlgihqAvfayqJEkSZImmoEraux+JkmSJE0sA1fUrFnjbZ0lSZKkiWSgippdd23eH3qot3FIkiRJ6p6BKmrmzGneLWokSZKkiWOgiprZs5t3ixpJkiRp4hioombnnZt3ixpJkiRp4hioombKlOYBnA8/3OtIJEmSJHXLQBU1ANOn21IjSZIkTSQDVdScddZZrFx5MStW/IA99tiDs846q9chSZIkSdpIA1PUnHXWWSxYsIC1a5tmmptuuokFCxZY2EiSJEl9bmCKmuOPP55Vq1Y9ZtqqVas4/vjjexSRJEmSpG4YmKLm5ptvHtN0SZIkSf1hYIqa3XbbbUzTJUmSJPWHgSlqTjrpJLbZZpvHTNtmm2046aSTehSRJEmSpG4YmKLmyCOPZOHChUyfPh2AmTN3Z+HChRx55JE9jkySJEnSxhiYogaawuaggw5i0qRDOeaYGy1oJEmSpAlgoIqaIdOmwW239ToKSZIkSd0wkEXN9OmwfHmvo5AkSZLUDQNZ1NhSI0mSJE0cA1nUTJ9uUSNJkiRNFANZ1EybBitXwn339ToSSZIkSRtrYIsasLVGkiRJmggGsqhpH1VjUSNJkiRNAANZ1NhSI0mSJE0cA1nUDLXUeFtnSZIkqf8NZFEzeTLMmGFLjSRJkjQRjKqoSfLiJNclWZrkveuYf3SSO5L8pH29ufuhdtesWRY1kiRJ0kQwZaQFkkwGPgv8L2AZcGmSRVX102GLnlNVb98EMW4Su+xi9zNJkiRpIhhNS82BwNKqur6qHga+BBy2acPa9GypkSRJkiaGEVtqgNnALR3jy4DnrGO51yR5PvAL4F1VdcvwBZIsABYA7LTTTixevHjMAW+su+++G4AnPOEWli2bxfe/fyHJZg9D43T//ff3JG/U38wbjZU5o/EwbzQe5k13jKaoWddX/ho2/jXg7Kp6KMlbgTOAF/zWSlULgYUA8+bNq/nz548t2i6YOXMmAAceuCtf+QoccMB8tt9+s4ehcVq8eDG9yBv1N/NGY2XOaDzMG42HedMdo+l+tgzYtWN8DvCYjltVdWdVPdSOfg44oDvhbTqzZjXvdkGTJEmS+ttoippLgb2T7JlkGnA4sKhzgSS7dIy+EvhZ90LcNCxqJEmSpIlhxO5nVbU6yduBbwGTgdOq6tokHwIuq6pFwDuSvBJYDdwFHL0JY+4KixpJkiRpYhjNNTVU1XnAecOm/VXH8PuA93U3tE1rl7Ztyds6S5IkSf1tVA/fnIi22w623daWGkmSJKnfDWxRAz6rRpIkSZoIBrqo2WUXu59JkiRJ/W6gixpbaiRJkqT+Z1FzG9TwR4lKkiRJ6hsDXdTssgs88ADce2+vI5EkSZI0XgNd1PisGkmSJKn/WdQAt97a2zgkSZIkjd9AFzW7796833hjT8OQJEmStBEGuqjZdVeYOhWWLu11JJIkSZLGa6CLmsmT4UlPsqiRJEmS+tlAFzUAc+da1EiSJEn9zKKmLWp8Vo0kSZLUnyxq5sLKlXD77b2ORJIkSdJ4WNTMbd7tgiZJkiT1J4uatqj5xS96G4ckSZKk8Rn4ombPPWGbbeCaa3odiSRJkqTxGPiiZvJk2HdfuOqqXkciSZIkaTwGvqgB2H9/uPpq74AmSZIk9SOLGmC//eDOO+G223odiSRJkqSxsqihKWrALmiSJElSP7KoAZ7xDJg0CZYs6XUkkiRJksbKogbYbjt4+tPhoot6HYkkSZKksbKoaR18MFx8MTzySK8jkSRJkjQWFjWtgw+GVavgyit7HYkkSZKksbCoaR16KCTwzW/2OhJJkiRJY2FR03rCE+Cgg2DRol5HIkmSJGksLGo6vPKVcPnlsGxZryORJEmSNFoWNR1e/erm/eyzexuHJEmSpNGzqOkwb15zw4CFC2Ht2l5HI0mSJGk0LGqGectbYOlS+Na3eh2JJEmSpNGwqBnmda+D3XeHE06Aql5HI0mSJGkkFjXDTJ8OJ57Y3DDg85/vdTSSJEmSRmJRsw5HHdU8t+ad72y6okmSJEnaclnUrMOkSXD66TB1KrzoRXDrrb2OSJIkSdL6WNSsxx57wHnnwe23w4EHwgUX9DoiSZIkSesyqqImyYuTXJdkaZL3rmP+9CTntPOXJNmj24H2wnOeAz/6UXOdzaGHwhFHwCWX9DoqSZIkSZ1GLGqSTAY+C7wE2Ac4Isk+wxY7FlhRVXOBTwIf63agvbLffnDNNfD+98PXv94UOnvtBW97W3MjgUsvhbvu8k5pkiRJUq9MGcUyBwJLq+p6gCRfAg4DftqxzGHAie3wucBnkqRqYnzVnzEDTjoJ/vIv4eyz4RvfgC98AU4++dFlpk+HJz4RdtwRtt22WWfofdo0mDwZpkxpXkPDQ++TJkHSbGfovXN4NPPGMq2fLV06hyuu6HUU6jfmjcbKnNF4mDdbti31u9DSpXO48speR9H/RlPUzAZu6RhfBjxnfctU1eok9wCPB37duVCSBcACgJ122onFixePL+qNcPfddwOMe9/z5jWv446D5cu35vrrZ3D77Vtx553TuOuuadx771RWrJjM8uWTeeCByTz44CRWr57EmjVhzZqwdi3tezNetYX+C9tize11AOpL5o3GypzReJg3Gg/zphtGU9Ss61v38BaY0SxDVS0EFgLMmzev5s+fP4rdd9fMmTMB6MW+12Xt2uYFj+3CNjQ8/H1jp/W7Cy+8kEMOOaTXYajPmDcaK3NG42HebLm25O9C5s2GtV/dRzSaomYZsGvH+BzgtvUssyzJFGAH4K7RhTDYJk1qXhqdGTPWsP32vY5C/ca80ViZMxoP80bjse22a9hhh15H0f9G83X6UmDvJHsmmQYcDiwatswi4E3t8GuB702U62kkSZIkbdlGbKlpr5F5O/AtYDJwWlVdm+RDwGVVtQg4FTgzyVKaFprDN2XQkiRJkjQkvWpQSXIfcF1Pdq5+tiPDbkAhjYJ5o7EyZzQe5o3Gw7zZsN2raqeRFhrNNTWbynVV9awe7l99KMll5o3GyrzRWJkzGg/zRuNh3nSHl6hLkiRJ6msWNZIkSZL6Wi+LmoU93Lf6l3mj8TBvNFbmjMbDvNF4mDdd0LMbBUiSJElSN9j9TJIkSVJf60lRk+TFSa5LsjTJe3sRg7YMSXZN8v0kP0tybZLj2um/k+TbSf6rfX9cOz1JPt3mztVJntmxrTe1y/9Xkjetb5+aGJJMTnJlkq+343smWdL+/c9pHxZMkunt+NJ2/h4d23hfO/26JC/qzZFoc0kyM8m5SX7ennOe67lGI0nyrvb/p/9McnaSrTzfaLgkpyX5VZL/7JjWtfNLkgOSXNOu8+kk2bxHuOXb7EVNksnAZ4GXAPsARyTZZ3PHoS3GauDPq+qpwEHAn7b58F7gu1W1N/DddhyavNm7fS0ATobmxAH8NfAc4EDgr4dOHpqwjgN+1jH+MeCTbc6sAI5tpx8LrKiqucAn2+Vo8+xw4GnAi4F/as9Pmrg+BXyzqp4C7E+TP55rtF5JZgPvAJ5VVfvSPIT8cDzf6LedTvO37dTN88vJ7bJD6w3f18DrRUvNgcDSqrq+qh4GvgQc1oM4tAWoquVVdUU7fB/Nl4zZNDlxRrvYGcCr2uHDgC9U42JgZpJdgBcB366qu6pqBfBt/Ac/YSWZA7wMOKUdD/AC4Nx2keE5M5RL5wK/1y5/GPClqnqoqm4AltKcnzQBJdkeeD5wKkBVPVxVd+O5RiObAmydZAqwDbAczzcapqouAO4aNrkr55d23vZV9eNqLob/Qse21OpFUTMbuKVjfFk7TQOubaZ/BrAE2LmqlkNT+ABPaBdbX/6YV4PlH4C/ANa2448H7q6q1e1459//N7nRzr+nXd6cGSxPAu4APt92WzwlyQw812gDqupW4OPAzTTFzD3A5Xi+0eh06/wyux0ePl0delHUrKsPoLdgG3BJtgW+Cryzqu7d0KLrmFYbmK4JJsnLgV9V1eWdk9exaI0wz5wZLFOAZwInV9UzgJU82hVkXcwb0Xb9OQzYE5gFzKDpOjSc5xuNxVjzxPwZhV4UNcuAXTvG5wC39SAObSGSTKUpaM6qqn9tJ9/eNrfSvv+qnb6+/DGvBsfzgFcmuZGm++oLaFpuZrbdQ+Cxf//f5EY7fweaLgLmzGBZBiyrqiXt+Lk0RY7nGm3I7wM3VNUdVfUI8K/A/8TzjUanW+eXZe3w8Onq0Iui5lJg7/bOIdNoLpxb1IM4tAVo+xqfCvysqj7RMWsRMHTXjzcB/9Ex/aj2ziEHAfe0TbrfAl6Y5HHtL2svbKdpgqmq91XVnKrag+b88b2qOhL4PvDadrHhOTOUS69tl692+uHt3Yr2pLnw8pLNdBjazKrql8AtSea1k34P+Cmea7RhNwMHJdmm/f9qKG8832g0unJ+aefdl+SgNg+P6tiWWlNGXqS7qmp1krfT/OEmA6dV1bWbOw5tMZ4HvBG4JslP2mnvBz4KfDnJsTT/qbyunXce8FKaiyxXAX8EUFV3JfkwTdEM8KGqGn7Bnia2vwS+lOQjwJW0F4S372cmWUrzi+nhAFV1bZIv03xBWQ38aVWt2fxhazP6M+Cs9ge162nOH5PwXKP1qKolSc4FrqA5T1xJ8/T3b+D5Rh2SnA3MB3ZMsozmLmbd/C7zJzR3WNsa+H/tSx3S/IAgSZIkSf2pJw/flCRJkqRusaiRJEmS1NcsaiRJkiT1NYsaSZIkSX3NokaSJElSX7OokaQBlWRNkp90vPbodUzdkuToJHckOaUdn5/k68OWOT3Ja9e9BUjyd0l+meTdmzpeSdLG2ezPqZEkbTEeqKqnr29mkilVtXpzBtRl51TV28e7clW9J8nKbgYkSdo0bKmRJP1G28LxlSRfA85vp70nyaVJrk7ywY5lj09yXZLvJDl7qEUjyeIkz2qHd0xyYzs8uW39GNrWW9rp89t1zk3y8yRntU/NJsmzk/woyVVJLkmyXZILkzy9I44fJtlvI475WR2tVdck8QFuktRnbKmRpMG1dZKftMM3VNWr2+HnAvu1T7d+IbA3cCAQYFGS5wMraZ6W/gya/0uuAC4fYX/HAvdU1bOTTAd+mOT8dt4zgKcBtwE/BJ6X5BLgHOD1VXVpku2BB4BTgKOBdyZ5MjC9qq4exfEe0nG8ALsBX6+qy4CnQ9PlDPjmKLYlSdqCWNRI0uBaX/ezb1fVXe3wC9vXle34tjRFznbAv1XVKoAki0axvxcC+3Vcx7JDu62HgUuqalm7rZ8AewD3AMur6lKAqrq3nf8V4IQk7wGOAU4f5fFeWFUvHxpJ8pj1kvwB8Mw2TklSH7GokSQN13kdSYC/qap/6VwgyTuB9XXTWs2j3Zu3GratP6uqbw3b1nzgoY5Ja2j+f8q69lFVq5J8GzgM+APgWSMcz4iSPA34IPD8qlqzsduTJG1eXlMjSdqQbwHHJNkWIMnsJE8ALgBenWTrJNsBr+hY50bggHb4tcO29SdJprbbenKSGRvY98+BWUme3S6/XZKhH+NOAT4NXNrRqjQuSXYAvgQcVVV3bMy2JEm9YUuNJGm9qur8JE8Fftxeu38/8IaquiLJOcBPgJuACztW+zjw5SRvBL7XMf0Umm5lV7Q3ArgDeNUG9v1wktcD/5hka5rraX4fuL+qLk9yL/D5Lhzmq4Ddgc+1x8iG7gonSdrypMqbvEiSNk6SE2mKjY9vpv3NAhYDT6mqteuYfzTwrI25pXO7nRPZjMclSRofu59JkvpKkqOAJcDx6ypoWg8ALxl6+OY49/N3wBt47DVGkqQtkC01kiRJkvqaLTWSJEmS+ppFjSRJkqS+ZlEjSZIkqa9Z1EiSJEnqaxY1kiRJkvqaRY0kSZKkvvb/ARQwQP1SI4w0AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Filter requirements.\n",
    "order = 10\n",
    "fs = Fs   # sample rate, Hz\n",
    "cutoff = Fc  # desired cutoff frequency of the filter, Hz\n",
    "\n",
    "# Get the filter coefficients so we can check its frequency response.\n",
    "b, a = butter_lowpass(cutoff, fs, order)\n",
    "\n",
    "# Plot the frequency response.\n",
    "w, h = sp.freqz(b, a, worN=8000)\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(0.5*fs*w/np.pi, np.abs(h), 'b')\n",
    "plt.plot(cutoff, 0.5*np.sqrt(2), 'ko')\n",
    "plt.axvline(cutoff, color='k')\n",
    "plt.xlim(0, 0.5*fs)\n",
    "plt.title(\"Lowpass Filter Frequency Response\")\n",
    "plt.xlabel('Frequency [Hz]')\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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
}