notebooks/0a - Python Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics \n",
    "\n",
    "Why would you want to use Python over Matlab?\n",
    "1. Python is free!\n",
    "2. Python is a general purpose programming langage\n",
    "3. Python has a wealth of useful third party open source libaries\n",
    "4. Python can replicate all the behavior of MATLAB using Numpy, Scipy, and Matplotlib\n",
    "5. It's easy to add third party open source libraries\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Big Differences between Matlab and Python\n",
    "\n",
    "- No need to use semicolon at the end of lines of code \n",
    "- To print things use the function print() instead of not using a semicolon\n",
    "- In python blocks of code are designed by indentation and they start with a colon\n",
    "- Function use the def keyword for a function, and return values with return\n",
    "- In Python array indices start at 0, instead of 1 for Matlab."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Varibles\n",
    "\n",
    "In python is easy to define a variable. Let's try it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "one = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There you go! You just assigned '1' to the variable called one.\n",
    "\n",
    "Python supports a number of data types that you can use. These include\n",
    "int, float, strings, boolearns, etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5                  # A number (int)\n",
    "b = 5.0                # A number (float)\n",
    "c = [1,2,3]            # A list\n",
    "d = 'This is a string' # A string\n",
    "e = True               # Boolean (True)\n",
    "f = False              # Boolean (False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If/Else Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a true statement\n",
      "It's off!\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# If\n",
    "if True:\n",
    "    print('This is a true statement')\n",
    "\n",
    "# Else If\n",
    "isOn = False\n",
    "if isOn:\n",
    "    print(\"It's on!\")\n",
    "else:\n",
    "    print(\"It's off!\")\n",
    "    \n",
    "# If + Else If + Else\n",
    "a = '1'\n",
    "if a == 1:\n",
    "    print('1')\n",
    "elif a == 2:\n",
    "    print('2')\n",
    "else:\n",
    "    print('3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for _ in [1,2,3]:\n",
    "    print(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for _ in range(10):\n",
    "    print(_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[[1, 2], [3, 4]]\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "list = []\n",
    "\n",
    "for _ in range(10):\n",
    "    list.append(_)\n",
    "    \n",
    "print(list)\n",
    "\n",
    "# Multi-dimensional List\n",
    "mlist = [[1,2],[3,4]]\n",
    "print(mlist)\n",
    "\n",
    "# Access element in list\n",
    "print(mlist[0][0])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "list = [_ for _ in range(10)]\n",
    "print(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "list = [[i for i in range(10)] for j in range(10)]\n",
    "print(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "Dictionaries are simply a collection of key/value pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id 10\n",
      "name Jane\n",
      "age 26\n"
     ]
    }
   ],
   "source": [
    "dict = { \n",
    "         \"id\": 10, \n",
    "         \"name\" : \"Jane\",\n",
    "         \"age\" : 26\n",
    "       }\n",
    "\n",
    "for key in dict:\n",
    "    print(key, dict[key])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add a new item to the dictionaries simply do the following"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id 10\n",
      "name Jane\n",
      "age 26\n",
      "1 1\n"
     ]
    }
   ],
   "source": [
    "dict[1] = 1\n",
    "\n",
    "for key in dict:\n",
    "    print(key, dict[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are useful for speeding up computation by using them as a Look Up Table (LUT). Takes take the example of computing sum(sin(N) * sin(N)) to see how we can use dictionaries to speed computation. This is also known as a form of dynamic programming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result with Dict 5000000.034065164  Computed in:  1.57185697555542\n",
      "Result with Sin 5000000.034065164  Computed in:  2.3720405101776123\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import time\n",
    "\n",
    "N = 10000000\n",
    "\n",
    "# Create dictionary of values for sin(N)\n",
    "compute = {}\n",
    "for _ in range(N):\n",
    "    compute[_] = math.sin(_)\n",
    "\n",
    "# Compute sin(N) * sin(N) using LUT\n",
    "start_time = time.time()\n",
    "result = 0\n",
    "for _ in range(N):\n",
    "    result += compute[_] * compute[_]\n",
    "time_elapsed = time.time() - start_time\n",
    "    \n",
    "# Compute sin(N) * sin(N)\n",
    "start_time = time.time()    \n",
    "result2 = 0;\n",
    "for _ in range(N):\n",
    "    result2 += math.sin(_) * math.sin(_)\n",
    "time_elapsed2 = time.time() - start_time\n",
    "\n",
    "print(\"Result with Dict\", result, \" Computed in: \", time_elapsed);\n",
    "print(\"Result with Sin\", result2, \" Computed in: \", time_elapsed2); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions and Classes\n",
    "\n",
    "Functions and Classes are useful for organizing and structuring code. They are used to make go portable, reusable, and clean."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python we define function with the 'def' keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def add_and_print(arg0, arg1):\n",
    "    print(arg0 + arg1)\n",
    "\n",
    "add_and_print(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "def add_and_print(arg0 = 0, arg1 = 10):\n",
    "    print(arg0 + arg1)\n",
    "\n",
    "add_and_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793 100 100 1 2 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "def SSFP(alpha = math.pi, T1 = 100, T2=100, TE=0.5, TR=1, dpi=math.pi):\n",
    "    print(alpha, T1, T2, TE, TR, dpi)\n",
    "    \n",
    "SSFP(math.pi, TR = 2, TE=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make a simple class to orgainize our computation code we need earlier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Compute:\n",
    "    def __init__(self, N = 10):\n",
    "        self.N = N\n",
    "        self.n2, self.two_n = self.compute()\n",
    "        self._print()\n",
    "        \n",
    "    def compute(self):\n",
    "        return self.N * self.N, 2 * self.N\n",
    "    \n",
    "    def _print(self):\n",
    "        print(\"Test\", self.N, self.n2, self.two_n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test 5 25 10\n"
     ]
    }
   ],
   "source": [
    "c = Compute(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 10\n"
     ]
    }
   ],
   "source": [
    "n2, two_n = c.compute()\n",
    "print(n2, two_n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the numpy library\n",
    "import numpy\n",
    "\n",
    "# import a single export of numpy\n",
    "from numpy import linspace\n",
    "\n",
    "# import all the exports of numpy \n",
    "from numpy import *\n",
    "\n",
    "\n",
    "# import numpy with the alias np\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy/Matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd3hU55X48e8ZVSRAQr0jAaJIgADLYIwrptsGlzi248QlxVviTX7JbhI72U12nc3G2d2UTTZO4rg7iWuMwRgMAuOGwSCbJokOAnUJCRXUpXl/f2jklbEESFPulPN5nnk0c+feuUcwmjP3vE2MMSillApcNqsDUEopZS1NBEopFeA0ESilVIDTRKCUUgFOE4FSSgW4YKsDGIm4uDiTmZlpdRhKKeVTPvroo9PGmPhzt/tkIsjMzKSwsNDqMJRSyqeIyMnBtmtpSCmlApwmAqWUCnCaCJRSKsBpIlBKqQCniUAppQKcSxKBiDwpIrUiUjTE8yIivxaRoyKyT0TmDHjuHhE54rjd44p4lFJKXTxXXRE8DSw7z/PLgWzH7X7gdwAiEgP8CJgHzAV+JCLjXBSTUkqpi+CScQTGmHdFJPM8u6wCnjV9c17vEJFoEUkGrgEKjDENACJSQF9Ced4VcfkDYwz7K5ooqWymx27o6bUzOjyEqyfHEz8mzOrwlHKrQ9UtnDjdSkNrFw2tnSRFjWJeVgxp40YhIlaH5zc8NaAsFSgb8LjcsW2o7Z8hIvfTdzVBRkaGe6L0ImUNbby4q4zX91Vysr7tM8+LwJyMcVw/I5m7LssgLDjIgiiVcr32rl7W7q3gTztOsb+iadB9UqLCWTkrlb+/diJjw0M8HKH/8VQiGCx1m/Ns/+xGYx4DHgPIz8/329V07HbDs9tL+dmbh+js6WXBpDi+fs0k5k+MJTwkiGCbUNnUzuaSWjaVVPPwuhL+/OFJHrl1JpdmxlgdvlJO2XKghu+8so+G1i6yE0bzbytzuWT8OOJGhxEdEUJpfSs7TzTw3pHT/OHdY7xcWMY/LpnC7ZemE2TTK4SR8lQiKAfSBzxOAyod2685Z/vbHorJ65Q1tPFPL+/lwxMNXD05nv+4ZQap0aM+s9+4yFByU6L45qJsth6q5Z9XF3Hb77dz17wMfnhjjl4dKJ/T2dPLIxsO8tS2UnKSx/LoXXOYlxXzmfLP1KSxTE0ay93zM9lf3sSP15Xw/dX7efXjcv54dz7jIkMt+g18m7hqqUpHG8E6Y8z0QZ67HngAWEFfw/CvjTFzHY3FHwH9vYg+Bi7pbzMYSn5+vvG3uYYOVjdz1x8/pKvHzr/ckMNt+WkXXQNt7ezhFwWHeeL9E1yZHcdjX8pnVKgmA+UbTp/t5N6ndlJU0cy9l2fy0IqpF/1lxhjD6t0VPPjqftLGjeKZ++aSHhPh5oh9l4h8ZIzJ/8x2VyQCEXmevm/2cUANfT2BQgCMMb+Xvk+0/6WvIbgNuM8YU+g49svA9x0v9RNjzFMXOp+/JYKSyma++MSHhAQJz3/tMibEjx7R67xUWMaDf91H/vgYnrg3nzFaO1VerrGtizse20FpfSu/vmM2S3KTRvQ6u0ob+OozhYQE2Xj6vkuZnhrl4kj9g1sTgaf5UyIoqmjii098yKiQIJ7/2mVkxkU69Xqv763kWy/uITdlLH/66jxNBsprne3s4a7HP+RAZTNP3JvPldmfmR15WI7UtHDPkztp6+7ltb9f4PTfkj8aKhHoyGIL1TR3cO9TO4kMDebF++e75I17Y14Kv//iJRRVNvOPL+3Fbve9RK/8X0d3L195ehdFFU389q45TicBgOzEMTx//2UAfPXZQpo7up1+zUChicAi3b12vv7nj2nr6uWZL19KRqzr6pqLchL5/oppbCqp4dG3j7rsdZVylZ+8cYAPTzTwi8/nsTgn0WWvOz42kt/ddQmlp1t54C+76em1u+y1/ZkmAov8dP1BCk+e4We3zmRSwhiXv/6XF2SyalYKPy84zNZDtS5/faVGasP+Kp7bcZKvXZnFqlmDDhtyyvyJsfz4pum8e7iO/1h/0OWv7480EVhg3b5Kntx2gnsvz+TGvBS3nENEeOSWmUxNGss3n99NWcNnB6Up5WllDW1896/7yEuP5jtLp7rtPHfOzeCe+eN5ctsJ3jtS57bz+AtNBB5W09zBQ3/dz5yMaL6/YppbzzUqNIg/fPESeu2G76/ejy92DFD+o7vXzjde2A0GfnPHbEKD3fvx89CKaUyIj+R7r+yjRdsLzksTgYf969piunrt/OLzs9z+hwCQERvBd5dN5b0jp1m9u8Lt51NqKH987zi7TzXy01tnuLRNbCjhIUH89215VDd38B/rD7j9fL5ME4EHFZTUsKGomm9cl+3Rrm1fumw8czKieXhdCafPdnrsvEr1Kz/Txq+3HGFpbiI3zHRPOXQwczLG8bUrJ/D8zjLePawloqFoIvCQs509/HBNEVMSx3D/VRM8em6bTfjZrTNp6+zl4ddLPHpupQD+7fUSBOGHN+Z6/NzfWjyZifGRPPTqftq7ej1+fl+gicBD/nvjIaqbO/jprTMICfL8P3t24hi+fu0k1u6t5B39ZqQ8aMuBGgpKavjmouxB585yt/CQIH56y0wqGtt5/L3jHj+/L9BE4AFHalp4dnspd83LYE6Gdevu/N01ExkfG8FP1x+gVweaKQ9o7+rlR2uLyU4YzZcXZFkWx9ysGJblJvG7d45R29xhWRzeShOBB/zXxkNEhAbz7cVTLI0jNNjGd5ZO4WB1C69+XG5pLCowPLntBOVn2nl41XSPdI44nweXT6W7187PNx22NA5vpInAzT46eYZNJTX8zVUTiPGCKXKvn5FMXloUvyg4TEe31kuV+zS1d/OHd46xaFoC8yfGWh0OmXGR3DM/k5c+KqOkstnqcLyKJgI3Msbwsw0HiRsdxleutO6yeCAR4aEV06hq6uCpbaVWh6P82B/fPU5zR4/lV8ID/cPCbKJGhfCT9SU6rmYATQRutPVQLTtLG/jmdZOICPXUGkAXdtmEWBZOTeDRt49yprXL6nCUHzp9tpMnt53gxrwUclLGWh3OJ6IiQviHhdlsO1rPjuPnXfYkoGgicBO73fCfbx4iMzaCO+Z63xrLDy6fytnOHh7TXhTKDR7deozOHjvfWpRtdSifcde8DOJGh/Gbt45YHYrX0ETgJptKajhY3cK3Fk+2pLvohUxOHMOKGck8t/0kTe06/F65TmVjO3/acZLPzUkb8SJL7hQeEsTfXj2BD47VU1iqVwXgokQgIstE5JCIHBWRBwd5/pcissdxOywijQOe6x3w3FpXxGM1Ywy/e+cYGTERXD8j2epwhvT310zkbGcPz20vtToU5Ucee/c4BsM3vPBqoN8X5mUQExnKr9/SadrBBYlARIKA3wLLgRzgThHJGbiPMeZbxphZxphZwG+AVwc83d7/nDFmpbPxeIPtx+rZW9bI31w9gWAvvBrol5sSxbVT4nlyWyltXT1Wh6P8QENrFy/sOsVNs1ItGTx2sSJCg/nqlVm8e7iOPWWNFz7Az7niU2oucNQYc9wY0wW8AKw6z/53As+74Lxe69G3jxE/Joxb56RZHcoFPbBwUt8f784yq0NRfuC57Sfp6LZ7fBqVkbh7fiZRo0L4X20rcEkiSAUGfoqUO7Z9hoiMB7KAtwZsDheRQhHZISI3DXUSEbnfsV9hXZ33TpGwr7yR94+e5itXZBEeEmR1OBd0yfgY5mXF8Ni7x+nq0dWc1Mi1d/XyzPZSFk1LIDvR9YstudrosGC+vCCLzQdqOVTdYnU4lnJFIpBBtg3VQfcO4BVjzMCRTBmOxZS/APxKRCYOdqAx5jFjTL4xJj8+3vn1Td3ld28fY0x4MHfN876eQkP5+rWTqG7uYPVuHW2sRu6Vj8poaO3i/qsG/RP2SnfPH09YsI2ntp2wOhRLuSIRlAPpAx6nAZVD7HsH55SFjDGVjp/HgbeB2S6IyRKlp1t5s7iau+ePZ0x4iNXhXLQrs+OYljyWp7aV6iAbNSI9vXb++N4JZmdEc2mmdfNpDde4yFBumZPG6t0VNATwmBpXJIJdQLaIZIlIKH0f9p/p/SMiU4BxwPYB28aJSJjjfhywAPDZeZKf3X6SIBHumZ9pdSjDIiLcd3kmB6tbdJCNGpE3i6s51dDG31w1EZHBigTe68sLMunssfP8zlNWh2IZpxOBMaYHeADYCBwAXjLGFIvIwyIysBfQncAL5tNfOacBhSKyF9gKPGKM8clE0NrZw8uFZSyfkUzC2HCrwxm2lbNSGBcRwjMflFodivJBz3xQyvjYCBbnJFodyrBlJ47hyuw4nt1eGrDtZC6Z98AYsx5Yf862H57z+F8HOe4DYIYrYrDa6t0VtHT2cO/l460OZUTCQ4K4Y24Gf3jnGOVn2kgb5/6lBJV/OFDVzK7SM/xgxTSCbL51NdDvywuyuO/pXWwoqmLVrEH7uvg17+3k7kOMMTy7vZTpqWMtXW/AWV+8rC+JPbfjpMWRKF/y3I6ThAXbuC3f+7tLD+XqyfFMiIvkifdPBGQ7mSYCF9h+vJ7DNWe5e36mz9VHB0qNHsXS3CRe3FWmS/qpi9Lc0c1ruytYmZdCdIT106yPlM0m3Lcgk33lTewOwAFmmghc4JkPShkXEcLKPM8tyu0u91yeSWNbN2v2VFgdivIBr35UTltXL3f7WAeJwdw0O5WI0CBeCMBGY00ETqpsbKegpIbbL83wiQFkFzIvK4YpiWP4SwD+MajhMcbw3I6T5KVHMyMtyupwnDYmvO/L3Ot7q2juCKyJGDUROOnlwnLsBp8aQHY+IsIdc9PZV95EcWWT1eEoL7b9WD3H6lq5+zLf7CAxmDvnZtDe3cuaPUMNhfJPmgicYLcbXios44pJcaTH+E8vm5tnpxIabOPFXTr/kBran3eeIjoihOtneu8Mu8M1My2KnOSx/OXDUwHVaKyJwAnbjp2morGd2y9Nv/DOPiQ6IpTl05NYvbtC1zVWgzrT2kVBcQ03z071i5JoPxHhznkZHKhqZl954FwRayJwwgu7yoiOCGFJru8NormQ2y9Np6Wjhw1FVVaHorzQmj0VdPXaue0S//oSBLBqVgqjQoICaqSxJoIRahjwjSgs2H++EfW7LCuW8bERPK/TU6tBvFRYzozUKK9aj9hVxjoajdfuraQlQBqNNRGM0Ordfd+I/K0s1M9mE26/NJ2dJxo4XnfW6nCUFymqaKKkqpnP+/AAsgu5Y246bV29rNsXGFfEmghGwBjDS7vKyEuPZmqS/30j6ve5OWkE2UQbjdWnvFxYRmiwjZV5/jsVw6z0aCbER/Lqx4ExNbsmghHYW97EoZoWbs/3z6uBfgljw7l2Sjyv7amg1x44PSjU0Dq6e3ltTyXLcpOIivCdqdaHS0S4dU4au0rPcLK+1epw3E4TwQis/ricsGAbN+T5T7e5odw8O42a5k4+OHba6lCUFygoqaGpvZvP+/mXIOjrRi0Cr37s/6PsNREMU3evndf3VbEoJ5GxPrT4zEhdNy2BMeHBAfHHoC7slY/KSY0exeUTY60Oxe1SHL/nq7vLsfv5FbEmgmF651AdDa1d3DLbf+ujA4WHBHHDzGTeLKqmtbPH6nCUhepaOnnvSB03zU7B5qPTTQ/XrXPSKGtop/DkGatDcSuXJAIRWSYih0TkqIg8OMjz94pInYjscdy+OuC5e0TkiON2jyvicafVuyuIjQzlqsneu26yq90yJ4327l7eLKq2OhRloXX7KrEbuCmA5utfNj2JiNAg/vqRfzcaO50IRCQI+C2wHMgB7hSRnEF2fdEYM8txe9xxbAzwI2AeMBf4kYh47YT+Te3dFByo4ca8FEKCAudiKn/8ONJjRrF6t5aHAtlruyvITRlLduIYq0PxmIjQYJZPT+aN/VV+PcreFZ9mc4Gjxpjjxpgu4AVg1UUeuxQoMMY0GGPOAAXAMhfE5BYb9lfR1WPn5gApC/UTEW6enca2Y6epbuqwOhxlgeN1Z9lb3hRw732AWy9J5WxnD5tKaqwOxW1ckQhSgYEdzcsd2851q4jsE5FXRKS/y8HFHusVXt1dwYS4SGb6wZS7w3Xz7FSMgdd0nYKA9NqeSkTgRj9Yc2O4LsuKJWlsOGv9eEZSVySCwVqNzm1ifx3INMbMBDYDzwzj2L4dRe4XkUIRKayrqxtxsCNVfqaNnScaHF3KAqOhbKCsuEhmZ0TzmpaHAo4xhtd2V7BgYhyJY8OtDsfjbDbhhpnJvHO4lsa2LqvDcQtXJIJyYGCn4jTgU6nTGFNvjOl0PPwjcMnFHjvgNR4zxuQbY/Lj4z3fUPv63r6h5jcF4KVxv1V5KRysbuFITYvVoSgP2l3WyKmGtoB+76+clUJ3r/HbDhOuSAS7gGwRyRKRUOAOYO3AHURk4MirlcABx/2NwBIRGedoJF7i2OZ1Xt9byeyMaL9ad2C4VsxMxibweoDMv6L6vLa7grBgG0v9cJbdizUjNYqsuEjW7vXP8pDTicAY0wM8QN8H+AHgJWNMsYg8LCIrHbt9Q0SKRWQv8A3gXsexDcCP6Usmu4CHHdu8ytHas5RUNXPjzMCrjw6UMCacyybEsm5vZUAt2hHIenrtrN9fxaJpiYwJgAGUQxERbsxLYfvxemqb/a/DhEv6QBpj1htjJhtjJhpjfuLY9kNjzFrH/YeMMbnGmDxjzLXGmIMDjn3SGDPJcXvKFfG42rp9fQ1l/rQS00jdmJfC8dOtFFc2Wx2K8oAPTzRw+mwXNwbAdCoXsjIvBWPwyxlJA6cz/AgZY3h9byVzM2MCsqHsXMtykwi2Ca/76SWy+rR1+yqJDA3imikJVodiuUkJo8lJHssaP3zvayK4gIPVLRyraw3IbnODGRcZypXZcazbV+X3868Euu5eOxuKqlmUk+hXy1E6Y+WsFPaWNfrdjKSaCC7g9b2VBNmE5dOTrA7Fa6yclUJFYzu7y/x7/pVAt+3oaRrburkhwNvGBur/Quhv5SFNBOdhjGHdviounxhL7Ogwq8PxGoumJRIWbPukS63yT+v2VTEmPJirJsdZHYrXSI0exeyMaN7QRBA49pU3caqhTctC5xgTHsK1UxJ4Y3+VLljjpzp7etlYXM2SnCS/XJPbGdfPSKakqpnS0/5THtJEcB5v7K8iJEhYmqNloXOtmJlMXUsnH/n59LyB6r3Dp2np6AmIxZeGa/mMvn+TN/b7z1WBJoIhGGNYv7+KKybF+fWSfCO1cGoCYcE21vvRH4P6P2/sryJqVAgLJmpZ6Fyp0aOYlR7tV+99TQRDKKpopvxM+yfZX33a6LBgrp4cz4Yi7T3kbzp7etlcUsPS3ERCg/UjYjDXz0imuLLZb3oP6f/yENYXVRFsE5bkBO6w+gu5fmYyNc2d2nvIz2w7epqWzh79EnQey2f0lYv9pTykiWAQxhg27K9i/sRYoiNCrQ7Hay2cmkBokI039vnnRFyBav3+asaEB2tZ6DzSxkWQ50flIU0EgzhQ1UJpfRsr9BvReY0JD+GqyXFaHvIj3b12CkpqWDxNy0IXcv2MJIoqmjlV32Z1KE7T/+lBbCiqwiZoWegirJiRTFVTB3vLG60ORbnA9mP1NLV3s0wHUF7Q8un+03tIE8E5jDG8sb+KyyboILKLcd20REKCxG8ukQPdhqJqIkODuGqy59f88DXpMRHMTItiY7Hvl0Y1EZzjcM1Zjte1akPZRYoaFcKV2fGs31+tU1P7uF67YVNxNddOTdC5hS7S0twk9pQ1UtXUbnUoTtFEcI4NRVWIENCLcAzXstwkKhrbdWpqH7fzRAP1rV3aNjYM/SW0jT6+cpkmgnO8WVRN/vhxJIzRKacv1qKcRGyCX1wiB7INRVWEh9i4ZoqWhS7WxPjRZCeM5k0ff++7JBGIyDIROSQiR0XkwUGe/7aIlIjIPhHZIiLjBzzXKyJ7HLe15x7rSSfrWzlY3cLSXG0oG46YyFDmZsX47XqugcBuN2wsrubqyfFEhAZbHY5PWTY9qe9q6mznhXf2Uk4nAhEJAn4LLAdygDtFJOec3XYD+caYmcArwH8OeK7dGDPLcVuJhfq/0WoiGL5luUkcqT3LsbqzVoeiRmBPeSM1zZ3aW2gEluYmYTew+UCN1aGMmCuuCOYCR40xx40xXcALwKqBOxhjthpj+jvb7gDSXHBel9tYXENO8tiAXqB+pJY4kqeWh3zTxuJqgm3CwinaNjZcuSljSY8Z5dNXxK5IBKlA2YDH5Y5tQ/kKsGHA43ARKRSRHSJy01AHicj9jv0K6+rqnIt4ELXNHXx86ox+IxqhlOhR5KVFsbHYd78VBSpjDJuKa5g/MVYnWBwBEWFZbhLbjtbT3NFtdTgj4opEIINsG7QfoYh8EcgH/mvA5gxjTD7wBeBXIjJxsGONMY8ZY/KNMfnx8a5vzNpUUoMxWhZyxtLpSez1g650geZI7VlOnG795KpODd+y6Ul09drZerDW6lBGxBWJoBxIH/A4DfjM6s4isgj4AbDSGPNJq4oxptLx8zjwNjDbBTEN28biarLiIpmcONqK0/uF/iS6Sa8KfEp/10cdST9ys9PHET8mzGdLo65IBLuAbBHJEpFQ4A7gU71/RGQ28Af6kkDtgO3jRCTMcT8OWACUuCCmYWlq72b7sXqW5CYiMtgFjroYn3Sl8+FaaSDaWFLN7IxoEsdql+mRstmExTmJvH2ojo7uXqvDGTanE4Expgd4ANgIHABeMsYUi8jDItLfC+i/gNHAy+d0E50GFIrIXmAr8IgxxuOJ4K2DNfTYjZaFXGBpbhIfnqinobXL6lDURSg/00ZRRbO+911gSU4ibV29fHDstNWhDJtLOgwbY9YD68/Z9sMB9xcNcdwHwAxXxOCMTcU1JIwJY1ZatNWh+LyluUn879ajvHWwls9d4pWdw9QA/WU8TQTOu3xiHGPCgtlUXMPCqb5VZgv4kcUd3b28c7iOJbmJ2GxaFnLW9NSxJEeFs8lHa6WBZmNxNZMTR5MVF2l1KD4vNNjGNVMT2Hyghl4fm5Y94BPBB8dO09bVy2JdoN4lRPpqpe8eqaO9y/dqpYGkobWLXaUNLNH3vsssyUnk9Nkudp/yrVX7Aj4RbCquYUxYMPMnxFodit9YkpNER7ed9464fryHcp0tB2qwa5dpl7pmSjyhQTY2lfhWz7mATgS9dsPmAzVcMzVBV2NyoXkTYhgTHkyBj/0xBJqCkhqSo8KZnjrW6lD8xpjwEC6fFMvGYt+alj2gP/12nzrD6bNd2n/axUKCbFznqJX29NqtDkcNor2rl3eP1LE4R7tMu9qSnCRO1rdxuMZ35t0K6ERQUFJDSJDotLtusCQ3iTNt3Xx00rdqpYHi/aOn6ei2s1i/BLncopwExMemZQ/YRGBM37S78yfGMSZc51dxtasmxxMa7Hu10kCxqbiaMeHBzMvStjFXSxgTzuz0aJ8qjQZsIjhae5bS+jYtC7nJ6LBgrpgU53O10kDQazdsOVjLtVO0bcxdFucksb+iyWfm3QrYd0H/N1W9NHafxTmJlJ9p52B1i9WhqAE+OnmGhtYuluhyrG7T/7my2UeuCgI6EeSl6/wq7nTdtL5aqS9dIgeCgpJqQoKEqydr25i7TEoYzYS4SJ8pjQZkIqhp7mBvWaOWhdwsYUw4s3ysVurvjDFsKqnpmw5B28bcanFOIjuO+8YaBQGZCPqXlNOykPstzkn0qVqpvztSe5aT9W363veAxTmJdPca3jnk/QMrAzIRFJTUMD42guwEXXvA3Zb4WK3U3xVo25jHzM4YR2xkqE9cEQdcIjjb2cMHR+tZPE0H0njCxPi+Cc18pVbq7zaV1JCXFqVtYx4QZBOum5bA1kO1dHv5wMqASwTvHq6jq1cH0nhK/yR0vlIr9Wf9bWP63vecxTlJtHT08OHxBqtDOa+ASwQFJTWMiwjhkvHjrA4lYPhSrdSf/V/bmE4y5ylXTIojPMRGQYl3jzJ2SSIQkWUickhEjorIg4M8HyYiLzqe/1BEMgc895Bj+yERWeqKeIbS3WvnrYO1XDs1geCggMuBlpnjQ7VSf7a5pIaMmAhdl9uDRoUGcWV2PAUlNV49sNLpT0MRCQJ+CywHcoA7RSTnnN2+ApwxxkwCfgn8zHFsDn1rHOcCy4BHHa/nFrtKG2hq79Zuox4WZBMWTvWNWqm/au3sYduxep1kzgKLpyVS2dRBcWWz1aEMyRVfi+cCR40xx40xXcALwKpz9lkFPOO4/wpwnfS9G1cBLxhjOo0xJ4Cjjtdzi4KSGkKDbVyZrQNpPG1xTqJP1Er91buH6+jqsbNomn4J8rSFPjCw0hWJIBUoG/C43LFt0H0ci903AbEXeSwAInK/iBSKSGFd3chqzR3ddq6bmkBkmEuWalbDcGV2POEhtk/q1MqzCkpqiI4I4dJMbRvztLjRYVySMc7vE8Fg15nnFsOG2udiju3baMxjxph8Y0x+fPzIvtH/9JYZPHrXnBEdq5wzKjSIKyZ5f63UH/X02nnrUC0Lp2jbmFUW5yRSUtVMRaN3Dqx0xbuiHEgf8DgNqBxqHxEJBqKAhos81qW0PmqdxTkJVDS2U1LlvbVSf7Sr9AyNbd3abdRC3j4JnSsSwS4gW0SyRCSUvsbftefssxa4x3H/c8Bbpu9r4VrgDkevoiwgG9jpgpiUF1o4NdHra6X+qL9t7CqdZM4yE+JHMzE+0mvf+04nAkfN/wFgI3AAeMkYUywiD4vISsduTwCxInIU+DbwoOPYYuAloAR4E/i6MabX2ZiUd4ofE8YcL6+V+htjDAUHqlkwMVbbxiy2OCeJHcfraWr3voGVLikYGmPWG2MmG2MmGmN+4tj2Q2PMWsf9DmPMbcaYScaYucaY4wOO/YnjuCnGmA2uiEd5r8U5iRRXem+t1N8cqmmhrKFdB5F5gcU5ifTYDW8fqrU6lM/QliPlUd5eK/U3BcV9/86LpiVYHImanR5N3Ogwr7wi1kSgPGpi/GgmeHGt1N8UHKhhVno0CTrJnOVsNmHRtATeOdQ3psObaCJQHtc/CZ031kr9SXVTB/vKm7S3kBdZnJNIS2cPO4KM8qYAABcoSURBVI7XWx3Kp2giUB63xItrpf6kwDF4T6dU8R4LJsURERrEJi+bhE4TgfK4WenjiBsdpmsUuFlBSQ2ZsRFM0gWYvEZ4SBBXZcezuaTWqwZWaiJQHhc0oFba2aO9hd2hpaOb7cdO6yRzXmhJbiLVzR3sr2iyOpRPaCJQlliSm8jZzh62H/OuWqm/eOdwHd29RruNeqGFUxMIsgmbir3nilgTgbLE5RP7aqXae8g9NhbXEBsZqgsweaHoiFAuzfSugZWaCJQlwkOCuHpy3yR0drv31Er9QWdPL1sP1rJoWiJBNi0LeaMlOUkcqmnhZH2r1aEAmgiUhZbkJlLb0sne8karQ/ErO443cLazhyW52lvIW/V36fWWqwJNBMoy107pq5V6yx+Dv9hUXE1EaBALJsVZHYoaQnpMBFOTxnhNO4EmAmWZ6IhQ5mXFaDdSF7LbDQUlNVw9OZ7wELet+qpcYEluEoUnGzh9ttPqUDQRKGstzknkaO1ZjtedtToUv7C3vJHalk4tC/mApbmJ2A1s8YJV+zQRKEstye3r3rjRSy6Rfd2mkhqCbMLCKZoIvF1O8ljSxo3yive+JgJlqdToUcxIjWJjsXcNufdVm4qruWxCDFERIVaHoi5ARFiam8T7R05ztrPH0lg0ESjLLc1NZE9ZI9VNHVaH4tOO1Z3lWF0rS3QQmc9YkpNIV6/d8nm3nEoEIhIjIgUicsTx8zOjV0RklohsF5FiEdknIrcPeO5pETkhInsct1nOxKN801JHeajAyybi8jX9V1U626jvyM+MITYy1PLykLNXBA8CW4wx2cAWx+NztQF3G2NygWXAr0QkesDz3zHGzHLc9jgZj/JBkxL61iiw+o/B120sqiYvLYqU6FFWh6IuUt+8W4lsPVhr6bxbziaCVcAzjvvPADedu4Mx5rAx5ojjfiVQC+gq2uoT/bXSHcfraWrTNQpGoqKxnb3lTSydrmUhX7N0uvXzbjmbCBKNMVUAjp/nXQ9PROYCocCxAZt/4igZ/VJEws5z7P0iUigihXV1dU6GrbzN0twkeuyGLQf1qmAkNjnKQstyNRH4mssnxhEZGmTpFfEFE4GIbBaRokFuq4ZzIhFJBp4D7jPG9K/T9hAwFbgUiAG+N9TxxpjHjDH5xpj8+Hi9oPA3M1OjSBobzptF2k4wEm8WVTM5cTQT4nXtAV8THhLENVMSKCipodeiebcumAiMMYuMMdMHua0Bahwf8P0f9IM2fYvIWOAN4J+NMTsGvHaV6dMJPAXMdcUvpXyPzSYszU3k3SN1tHfpGgXDUX+2k12lDXo14MOWTk/i9NlOPjp5xpLzO1saWgvc47h/D7Dm3B1EJBRYDTxrjHn5nOf6k4jQ175Q5GQ8yoctzU2io9vOO4d1Ccvh2HygBrtB2wd82MKpCYQG29hQVGXJ+Z1NBI8Ai0XkCLDY8RgRyReRxx37fB64Crh3kG6ifxaR/cB+IA74dyfjUT5sblYM4yJC2KDloWF5s6ia9JhR5CSPtToUNUKjw4K5KjuejUXVlixhGezMwcaYeuC6QbYXAl913P8T8Kchjl/ozPmVfwkOsrE0N4l1+6ro7OklLFgnTbuQ5o5uth2t5+7543VJSh+3fHoSmw/UsLe8iVnp0Rc+wIV0ZLHyKsumJ3G2s4f3j5y2OhSfsPVgLV29dpZpWcjnLZqWSLBN2LDf8+UhTQTKq1w+MY6x4cGs36/loYuxfn8ViWPDmJOhS1L6uqiIEC6fFMcGC8pDmgiUVwkNtrEoJ5GCkmq6euwXPiCAtXb28PahOpZPT8amS1L6heXTkzjV0EZJVbNHz6uJQHmdFdOTae7oYftx60Za+oK3DtbS2WNnuZaF/MaSnERsgsfH02giUF7niuw4RocFW1Ir9SXr91cRPyaM/MwYq0NRLhI7Oox5WbEe7zmniUB5nfCQIBZOTWBjcTU9vVoeGkxbVw9bD9WyfHoSQVoW8isrZiRxtPYsh2taPHZOTQTKK62YkcSZtm52HG+wOhSvtPVgHR3ddlbMSLY6FOViS6cnYRNYt89zV8SaCJRXunpyAhGhQbyh5aFBrd9fRdzoMC7VspDfSRgTzrysWNbtq/RY7yFNBMorjQoNYtG0RDYUVdGt5aFPae/q5a2DtSybnqhlIT91Q14yx+taOVjtmfKQJgLltW6YmUxjWzfbjurgsoG2HqqlvbtXy0J+bFluX9vPun2VHjmfJgLlta6eEs+YsGCP1kp9wbp9lcQ5epco/xQ7OozLJ8aybl+VR8pDmgiU1woLDmJxbiIbi6stXcbPm7R0dLPlQC03zEzWspCfu35GMifr2yiudP/gMk0EyqvdmJdCS0cP7x7W8hBAQUkNnT12bsxLsToU5WZLc5MItgmve6A8pIlAebUrJsURHRHisVqpt3t9byWp0aOYk+HZ2SmV542LDGXBpDje8EB5SBOB8mohQTaW5SaxuaQm4FcuO9PaxXtHTnNjXopOOR0gbpiZTPmZdnaXNbr1PE4lAhGJEZECETni+DnoFIgi0jtgUZq1A7ZniciHjuNfdKxmptSn3JiXQmtXL1sPBfbKZeuLquixG27M095CgWLp9CTCgm2s2V3h1vM4e0XwILDFGJMNbHE8Hky7MWaW47ZywPafAb90HH8G+IqT8Sg/NC8rhrjRYazZ494/Bm/3+t5KJsZH6kpkAWRseAiLpiWybp97x9M4mwhWAc847j9D37rDF8WxTvFC4JWRHK8CR3CQjZV5KWw9WEdjW5fV4ViiuqmDD080sDIvVctCAWbVrBTqW7t4343jaZxNBInGmCoAx8+EIfYLF5FCEdkhIv0f9rFAozGmx/G4HEh1Mh7lp26Zk0pXrz1gF6zpm24ALQsFoGumJBA1KsSt5aELrlksIpuBwSY8/8EwzpNhjKkUkQnAW44F6wfrHDtk07iI3A/cD5CRkTGMUyt/kJsylkkJo3ltdwVfmBd4//+vflxBXloUE+JHWx2K8rDQYBsrZiSzZk8FbV09RIQ6tdT8oC54RWCMWWSMmT7IbQ1QIyLJAI6fg7bmGWMqHT+PA28Ds4HTQLSI9P9WacCQfQSNMY8ZY/KNMfnx8fHD+BWVPxARbp6dys7SBsoa2qwOx6MOVDVTUtXMLXPSrA5FWeSmWSm0dfVSUFLjltd3tjS0FrjHcf8eYM25O4jIOBEJc9yPAxYAJaavY+xW4HPnO16pfqtm9Q2iCrRG49W7Kwi2iQ4iC2CXZsaQEhXOa24qDzmbCB4BFovIEWCx4zEiki8ijzv2mQYUishe+j74HzHGlDie+x7wbRE5Sl+bwRNOxqP8WNq4COZmxbB6d4XHF/e2Sk+vndW7K7h2agIxkdq7OlDZbMLKWam8e+Q09Wc7Xf76ThWbjDH1wHWDbC8Evuq4/wEwY4jjjwNznYlBBZabZ6fy0Kv7KapoZkZalNXhuN22Y/XUtXRy6xztRxHobp6dSkVjO21dvbh6ukEdWax8yooZyYQG2/jrx+VWh+IRr35cTtSoEK6dOlSHPBUopiSN4Td3ziY9JsLlr62JQPmUqFEhLMlJ5LU9FX4/I2lLRzcbi6u5MS+ZsOAgq8NRfkwTgfI5t1+aTmNbt9t6UHiLDUXVdHTbtbeQcjtNBMrnLJgYR2r0KF7cVWZ1KG710q4yJsRFMjtdZxpV7qWJQPkcm0343CVpvH/0NOVn/HNMweGaFgpPnuGOuek6pYRyO00Eyifdlt9XLnnlI/9sNH5hZxkhQcKtWhZSHqCJQPmktHERXDEpjpcLy7Hb/WtMQUd3L6/uLmdJThKxo8OsDkcFAE0Eymd9Pj+disZ2PjhWb3UoLrWxuJrGtm7umJtudSgqQGgiUD5rcU4i0REhPL/zlNWhuNQLO8tIjxnFgolxVoeiAoQmAuWzwkOCuO2SNDYWV1PT3GF1OC5RerqV7cfruT0/HZtNG4mVZ2giUD7ti5eNp9cY/vKhf1wVPL/rFEE24bZ8LQspz9FEoHza+NhIrpkcz192nqKrx31L+XlCe1cvL+4qY/G0RBLHhlsdjgogmgiUz7t7fiZ1LZ1sLPbt1cte21NBY1s39y3ItDoUFWA0ESifd/XkeDJiInhu+0mrQxkxYwxPbTvBtOSxzM2KsTocFWA0ESifZ7MJX7psPDtLGzhQNdgKqN5v+7F6Dtec5b4FmTqSWHmcJgLlF27LTyMs2Maz20utDmVEntxWSmxkKCt1FTJlAacSgYjEiEiBiBxx/Bw3yD7XisieAbcOEbnJ8dzTInJiwHOznIlHBa7oiFBumZPGXz+uoLbFt7qSnqpvY8vBGr4wL4PwEJ1uWnmes1cEDwJbjDHZwBbH408xxmw1xswyxswCFgJtwKYBu3yn/3ljzB4n41EB7G+umkBPr52ntpVaHcqwPP1BKUEifPGy8VaHogKUs4lgFfCM4/4zwE0X2P9zwAZjjH9OGakslRkXyfLpyfxpx0laOrqtDueiNLR28cKuU9yYl6JdRpVlnE0EicaYKgDHzwutp3cH8Pw5234iIvtE5JciMuQMWyJyv4gUikhhXV2dc1Erv/W3V0+kpaPHZwaYPbXtBG1dvfz9NROtDkUFsAsmAhHZLCJFg9xWDedEIpJM3yL2GwdsfgiYClwKxADfG+p4Y8xjxph8Y0x+fHz8cE6tAsiMtCgWTIrlifdPeP1Sls0d3Tz9QSnLpyeRnTjG6nBUALtgIjDGLDLGTB/ktgaocXzA93/Q157npT4PrDbGfHLNboypMn06gaeAuc79OkrB3109idqWTlZ/XGF1KOf13PaTtHT08PVrJ1kdigpwzpaG1gL3OO7fA6w5z753ck5ZaEASEfraF4qcjEcpFkyKZUZqFI++fYzuXu+cdqKtq4fH3zvOtVPimZ4aZXU4KsA5mwgeARaLyBFgseMxIpIvIo/37yQimUA68M45x/9ZRPYD+4E44N+djEcpRIRvLc7mVEOb165r/JcPT3GmrZsHFmZbHYpSBDtzsDGmHrhukO2FwFcHPC4FUgfZb6Ez51dqKNdOSeDSzHH8essRbp2TxqhQ7+mf39LRze/fOcblE2O5ZPxnht4o5XE6slj5JRHhu8umUtvSydMflFodzqf84Z3jnD7bxfeWTbU6FKUATQTKj12aGcO1U+L5/TvHaGr3jnEFVU3tPP7+cVbmpZCXHm11OEoBmgiUn/vO0qk0tXfzh3eOWR0KAD/fdBi7Hb6zdIrVoSj1CU0Eyq/lpIzlplkpPP7+CUpPt1oaS0llM3/9uJx7F2SSHhNhaSxKDaSJQPm9h1ZMIzTIxr+sKcIYY0kMxhj+/Y0SokaF8PVrdNyA8i6aCJTfSxwbzj8tmcx7R06zbl+VJTG8/FE5Hxyr5x8XTyYqIsSSGJQaiiYCFRC+ND+TGalRPLyuxOMNxzXNHfx4XQlzs2K4a57OMKq8jyYCFRCCbMJ/3DyD+rOd/PfGQx47rzGGH6wuoqvHzs9unYnNpquPKe+jiUAFjBlpUdx7eRbP7TjJlgM1Hjnn6/uq2Hyghn9aMoWsuEiPnFOp4dJEoALKd5dNISd5LN9+aS/lZ9y7LMap+jZ+uKaIvPRovnxFllvPpZQzNBGogBIeEsSjd83Bbjc88JfddPW4Z1K61s4evvZsIcbA/9w+iyAtCSkvpolABZzMuEj+83Mz2VPWyE83HHD569vthm+/tIcjtS387xdmk6klIeXlNBGogLR8RjL3LcjkqW2lPPr2UZe+9q/fOsLG4hq+v2IaV2brIkrK+zk1+6hSvuyfr8+hobWL/3zzECE2G1+7aoJTr2eM4bdbj/KrzUe4ZU4qX9F2AeUjNBGogBVkE35+Wx49dsNP1h/AZpMRf3jb7YZ/f+MAT247wS2zU/nZrTPpW29JKe+niUAFtOAgG7+6fRZ2u+HH60ooqmji31blMjb84kf/tnR08y+vFfHankq+vCCLf75+mo4XUD7FqTYCEblNRIpFxC4i+efZb5mIHBKRoyLy4IDtWSLyoYgcEZEXRSTUmXiUGomQIBu/uXM231o0mbV7K1n+q/fYfqz+gscZY1izp4KFP3+HNXsr+c7SKfzLDZoElO8RZybhEpFpgB34A/BPjpXJzt0nCDhM31KW5cAu4E5jTImIvAS8aox5QUR+D+w1xvzuQufNz883hYWfOZVSTtt96gzfenEPpfVt5KVHc9sladyYl0LUqP+7QjhV38Y7R+pYu6eCXaVnmJkWxY9XTdf1BZTXE5GPjDGf+dLuVCIY8OJvM3QimA/8qzFmqePxQ46nHgHqgCRjTM+5+52PJgLlTq2dPTy/8xQvF5ZzqKYFERgdGkxkWDAiUNXUAUDauFH87dUTuXNuho4TUD5hqETgiTaCVGDgCuLlwDwgFmg0xvQM2P6ZdY37icj9wP0AGRkZ7olUKSAyLJivXjmBr1yRRVFFM5sP1NDc0U1rZw9dPXby0qO5enI8WXGR2iCs/MIFE4GIbAaSBnnqB8aYNRdxjsH+Usx5tg/KGPMY8Bj0XRFcxHmVcoqIMCMtihlpUVaHopRbXTARGGMWOXmOciB9wOM0oBI4DUSLSLDjqqB/u1JKKQ/yxMjiXUC2o4dQKHAHsNb0NU5sBT7n2O8e4GKuMJRSSrmQs91HbxaRcmA+8IaIbHRsTxGR9QCOb/sPABuBA8BLxphix0t8D/i2iBylr83gCWfiUUopNXwu6TXkadprSCmlhm+oXkM66ZxSSgU4TQRKKRXgNBEopVSA00SglFIBzicbi0WkDjg5wsPj6BvDEEj0dw4M+jv7P2d/3/HGmM+sluSTicAZIlI4WKu5P9PfOTDo7+z/3PX7amlIKaUCnCYCpZQKcIGYCB6zOgAL6O8cGPR39n9u+X0Dro1AKaXUpwXiFYFSSqkBNBEopVSAC6hEICLLROSQiBwVkQetjsedRCRdRLaKyAERKRaRb1odk6eISJCI7BaRdVbH4gkiEi0ir4jIQcf/93yrY3I3EfmW431dJCLPi0i41TG5mog8KSK1IlI0YFuMiBSIyBHHz3GuOFfAJAIRCQJ+CywHcoA7RSTH2qjcqgf4R2PMNOAy4Ot+/vsO9E36pjwPFP8DvGmMmQrk4ee/u4ikAt8A8o0x04Eg+tY58TdPA8vO2fYgsMUYkw1scTx2WsAkAmAucNQYc9wY0wW8AKyyOCa3McZUGWM+dtxvoe/DYcg1of2FiKQB1wOPWx2LJ4jIWOAqHGt5GGO6jDGN1kblEcHAKBEJBiLww9UNjTHvAg3nbF4FPOO4/wxwkyvOFUiJIBUoG/C4nAD4YAQQkUxgNvChtZF4xK+A7wJ2qwPxkAlAHfCUoxz2uIhEWh2UOxljKoD/Bk4BVUCTMWaTtVF5TKIxpgr6vuwBCa540UBKBDLINr/vOysio4G/Av/PGNNsdTzuJCI3ALXGmI+sjsWDgoE5wO+MMbOBVlxULvBWjrr4KiALSAEiReSL1kbl2wIpEZQD6QMep+GHl5MDiUgIfUngz8aYV62OxwMWACtFpJS+0t9CEfmTtSG5XTlQbozpv9p7hb7E4M8WASeMMXXGmG7gVeByi2PylBoRSQZw/Kx1xYsGUiLYBWSLSJaIhNLXuLTW4pjcRkSEvrrxAWPML6yOxxOMMQ8ZY9KMMZn0/f++ZYzx62+KxphqoExEpjg2XQeUWBiSJ5wCLhORCMf7/Dr8vIF8gLXAPY779wBrXPGiwa54EV9gjOkRkQeAjfT1MnjSGFNscVjutAD4ErBfRPY4tn3fGLPewpiUe/wD8GfHF5zjwH0Wx+NWxpgPReQV4GP6esftxg+nmhCR54FrgDgRKQd+BDwCvCQiX6EvId7mknPpFBNKKRXYAqk0pJRSahCaCJRSKsBpIlBKqQCniUAppQKcJgKllApwmgiUUirAaSJQSqkA9/8B6DWfSZYNk14AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.linspace(0, 10, 100)\n",
    "y = np.sin(x)\n",
    "\n",
    "%matplotlib inline\n",
    "plt.plot(x,y)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "M = 128; N = 128\n",
    "x = np.zeros((M, N))\n",
    "\n",
    "plt.imshow(x)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = np.linspace(0, 10, N)\n",
    "x = np.reshape(_, (N, 1))\n",
    "x = x * x.T\n",
    "plt.imshow(x)\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "(10,)\n"
     ]
    }
   ],
   "source": [
    "list = range(10)\n",
    "print(len(list))\n",
    "\n",
    "npList = np.array(list)\n",
    "print(npList)\n",
    "print(npList.shape)"
   ]
  },
  {
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}