Lecture-2-Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy -  arreglos de datos multidimensionales\n",
    "\n",
    "Versión original en inglés de J.R. Johansson (robert@riken.jp) http://jrjohansson.github.io/.\n",
    "\n",
    "Traducido/Adaptado por [G.F. Rubilar](http://google.com/+GuillermoRubilar).\n",
    "\n",
    "La última versión de estos [notebooks de IPython](http://ipython.org/notebook.html) está disponible en [http://github.com/gfrubi/clases-python-cientifico](http://github.com/gfrubi/clases-python-cientifico).\n",
    "\n",
    "La última versión del original (en inglés) de estos [notebooks de IPython](http://ipython.org/notebook.html) está disponible en [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n",
    "\n",
    "Los otros notebooks de esta serie están listados en [http://jrjohansson.github.com](http://jrjohansson.github.com)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introducción\n",
    "\n",
    "El paquete (módulo) `numpy` es usado en casi todos los cálculos numéricos usando Python. Es un paquete que provee a Python de estructuras de datos vectoriales, matriciales, y de rango mayor, de alto rendimiento. Está implementado en C y Fortran, de modo que cuando los cálculos son vectorizados (formulados con vectores y matrices), el rendimiento es muy bueno. \n",
    "\n",
    "Para usar `numpy` necesitamos importar el módulo usando, por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el paquete `numpy` la terminología usada para vectores, matrices y conjuntos de datos de dimensión mayor es la de un  *arreglo*. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creando arreglos de `numpy`\n",
    "\n",
    "Existen varias formas para inicializar nuevos arreglos de numpy, por ejemplo desde\n",
    "\n",
    "* Listas o tuplas Python\n",
    "* Usando funciones dedicadas a generar arreglos numpy, como `arange`, `linspace`, etc.\n",
    "* Leyendo datos desde archivos\n",
    "\n",
    "### Desde lista\n",
    "\n",
    "Por ejemplo, para crear nuevos arreglos de matrices y vectores desde listas Python podemos usar la función `numpy.array`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# un vector: el argumento de la función array es una lista de Python\n",
    "v = array([1,2,3,4])\n",
    "\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# una matriz: el argumento de la función array es una lista anidada de Python\n",
    "M = array([[1, 2], [3, 4]])\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los objetos `v` y `M` son ambos del tipo `ndarray` que provee el módulo `numpy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v), type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La diferencia entre los arreglos `v` y `M` es sólo su forma. Podemos obtener información de la forma de un arreglo usando la propiedad `ndarray.shape`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El número de elementos de un arreglo puede obtenerse usando la propiedad `ndarray.size`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equivalentemente, podemos usar las funciones `numpy.shape` y `numpy.size`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hasta el momento el arreglo `numpy.ndarray` luce como una lista Python (anidada). Entonces, ¿por qué simplemente no usar listas para hacer cálculos en lugar de crear un tipo nuevo de arreglo? \n",
    "\n",
    "Existen varias razones:\n",
    "\n",
    "* Las listas Python son muy generales. Ellas pueden contener cualquier tipo de objeto. Sus tipos son asignados dinámicamente. Ellas no permiten usar funciones matemáticas tales como la multiplicación de matricies, el producto escalar, etc. El implementar tales funciones para las listas Python no sería muy eficiente debido a la asignación dinámica de su tipo.\n",
    "* Los arreglos Numpy tienen tipo **estático** y **homogéneo**. El tipo de elementos es determinado cuando se crea el arreglo.\n",
    "* Los arreglos Numpy son eficientes en el uso de memoria.\n",
    "* Debido a su tipo estático, se pueden desarrollar implementaciones rápidas de funciones matemáticas tales como la multiplicación y la suma de arreglos `numpy` usando lenguajes compilados (se usan C y Fortran).\n",
    "\n",
    "Usando la propiedad `dtype` (tipo de dato) de un `ndarray`, podemos ver qué tipo de dato contiene un arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se obtiene un error si intentamos asignar un valor de un tipo equivocado a un elemento de un arreglo numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for long() with base 10: 'hola'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-fc4abc9a80ec>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mM\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"hola\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for long() with base 10: 'hola'"
     ]
    }
   ],
   "source": [
    "M[0,0] = \"hola\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si lo deseamos, podemos definir explícitamente el tipo de datos de un arreglo cuando lo creamos, usando el argumento `dtype`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M = array([[1, 2], [3, 4]], dtype=complex)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunos tipos comunes que pueden ser usados con `dtype` son: `int`, `float`, `complex`, `bool`, `object`, etc.\n",
    "\n",
    "Podemos también definir explícitamente el número de bit de los tipos de datos, por ejemplo: `int64`, `int16`, `float64`, `complex64`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Usando funciones que generan arreglos\n",
    "\n",
    "En el caso de arreglos más grandes no es práctico inicializar los datos manualmente, usando listas Python explícitas. En su lugar, podemos usar una de las muchas funciones en `numpy` que generan arreglos de diferentes formas. Algunos de los más comunes son:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# crea un arreglo con valores en un rango\n",
    "\n",
    "x = arange(0, 10, 1) # argumentos: desde, hasta, paso\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = arange(-1, 1, 0.1)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### linspace y logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# usando linspace, ambos puntos finales SON incluidos. Formato: (desde, hasta, número de elementos)\n",
    "linspace(0, 10, 25) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# logspace también incluye el punto final. Por defecto base=10\n",
    "logspace(0, 10, 11, base=e) # produce e elevado a cada valor en linspace(0, 10, 11), e.d.[e**0, e**1,...,e**10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mgrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x, y = mgrid[0:5, 0:5] # similar a meshgrid en MATLAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-401b30e3b8b5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-009520053b00>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Datos aleatorios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.5421664 ,  0.80497731,  0.36429653,  0.322732  ,  0.2163551 ],\n",
       "       [ 0.2231955 ,  0.20464872,  0.76387013,  0.77729324,  0.2003914 ]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# números aleatorios uniformes en [0,1]\n",
    "random.rand(2,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.76909571,  1.17096506,  0.63397322, -0.29870071,  0.09362062],\n",
       "       [-0.7230359 ,  0.4208798 ,  0.37588416, -0.19797453,  0.00318319]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# números aleatorios con distribución estándar normal (distribución gaussiana de media 0 y varianza 1).\n",
    "random.randn(2,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# una matriz diagonal\n",
    "diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 0],\n",
       "       [0, 0, 2, 0],\n",
       "       [0, 0, 0, 3],\n",
       "       [0, 0, 0, 0]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonal desplazada desde la diagonal principal\n",
    "diag([1,2,3], k=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ceros y unos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones((3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entrada/Salida desde/hasta archivos\n",
    "\n",
    "\n",
    "### Valores separados por coma (Comma-separated values, CSV)\n",
    "\n",
    "Un formato muy común para archivos de datos es el de valores separados por comas, o formatos relacionados, como por ejemplo TSV (tab-separated values, valores separados por tabs). Para leer datos desde tales archivos a un arreglo Numpy podemos usar la función `numpy.genfromtxt`. Por ejemplo, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n",
      "1800  1  4   -19.3   -19.3   -19.3 1\r\n",
      "1800  1  5   -16.8   -16.8   -16.8 1\r\n",
      "1800  1  6   -11.4   -11.4   -11.4 1\r\n",
      "1800  1  7    -7.6    -7.6    -7.6 1\r\n",
      "1800  1  8    -7.1    -7.1    -7.1 1\r\n",
      "1800  1  9   -10.1   -10.1   -10.1 1\r\n",
      "1800  1 10    -9.5    -9.5    -9.5 1\r\n"
     ]
    }
   ],
   "source": [
    "!head stockholm_td_adj.dat # despliega las primeras líneas del archivo stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data = genfromtxt('stockholm_td_adj.dat')  # asigna los datos del archivo al arreglo data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# ¿qué hace esta línea?. La respuesta en la clase 4\n",
    "%matplotlib inline\n",
    "from matplotlib.pyplot import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAz0AAAEVCAYAAADKCIsHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsXXn8bVPZ/56fMaVIA6EumVKRDAlxK5JE5hKhMtVLRKKU\nLso8VPSa3qhMFRkqhQxX5pChQSRDXIprnu903j/2WZ+z9nPWetbzrGGf87t3fz+f3+d39t5rr7X2\n2muv9cwP0KJFixYtWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYt\nWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYtWrQY\nUVwO4I3D7oQCpwF4/7A7EYlZAO4CcDv5e3vgvlLv6CcA9i1Qb4sWLVq0aNGiRYsWI4VZABYZdicU\neADAqsPuRCRmIY55KfWOzgCwT4F6W7Ro0WKOxNiwO9CiRYsWLZw4o/f/KgCL9/4uAHArgDsBfKN3\nfQKA+1FpWf4K4B4AmwD4LYD7APwcQKdX7hEAP0alwbgDwDpWewcCuK137UIAi/XOTwbwKwB/A/A/\nANYEcA2AmwA8BOD/euW+B+BtAM4CsEbvvi2t+icD2KL3+1UAvwDwD1RM0hd69f0ZwIMAdu+VWxSV\nJuW23t8hnrF6F4DLemNzO4DP985PBHA9gJ/16v5b75wPHc/51wE4r1f3bQBO7ZW139ESAN4N4GpU\n7+cOAJ+z6vgCqvdzJ4Are+UBYFcAf+mVvwzAso72XwFwGCpN1IMAtgbwSwB39+paoFfuQwBu7LVx\nC4ANmWdt0aJFixYtWrRo0WIkYGsfrgLwyd7v+XvHW6NiZmZZ1/4XFRP0OgDzAZiCilEx5bbvlduw\nd21uADsAOBfAXL1ruwK4pPf7alQMlcE5ANbt/X4dgMcBrNI7fgB987ar0Wdy6PEsANv1fr8WwA0A\nFu4drwngud7vbwM4qfd7gV4fF0Qdc6NiZkwf3tA7/gAqBmc6gJV61/ZBxXy54DJv+1Xv2ucA/L73\newwV07O0dd8be/34F4DNeucXA/Bw73lWRjVOi/eu7dV7ro8A+Cf6mqIde30H6pqeWQD26P3+OoBn\ne/V3UDF62/bq+A+A1XvlVgTwBKr33qJFixZzPOYedgdatGjRokUQrwWwHirG4FDr3MqoJPrTUWl2\ngIrwvh7AC73jR1ER5f9BxUyc1Tt/GYCZqBiCT6Iilm/tXZsLwGus9q+1fu8IYGNUmqZ3oWJGXhfx\nTKbOF3vtbwJgGQDv6z0bUDEav0PlV3MFgAMAPE/qWQ4VA3K6dW7+Xj33oNJG3dU7fzuAnZg+TQTw\nlKev30PFuP0BwPdRMZa0H/MBuKh3/BgqpunjqJiUS1ExmQDwg97/o1Bp4p7sHf+0d22Cow+GAbsf\nlWbosd7xA6je7wdQafZu6Z3/O6p5MBGVf1CLFi1azNFomZ4WLVq0GH0YDcwHUZk6AcCbALwM4M0A\nppHyMzz1zCTHY71zYwCOAHBK7/y8qPupvGD9vg4V83ApKhOrNeA2C+uibkI9L7lu6lwClUnWyaiY\ni/PR11rdCmApAOuj0or8CZUm5UarnrkAPIO+pgeozOKeQaVleZn0yWfCxuFBVAzZxF4/rgCwJ/qM\nCOA2F58LwDwYfB/zAXhHry+0P53ePRSvWr+nO667nmsutPt8ixYtWgBofXpatGjRYpQxExWz8Bwq\nnxcTzesNqBiETR33cET9wqi0NEClWZmGSgtyGYBd0Dcdm4RK60DrXBiVD84BqDQaS6BiBgxTNgN9\n5uYJAKv1fr8TfRMzitVQmX59D5UWZZPeecOIfRvAxQD2RmX6RX1e7kHFCBpzuSVR+bSsAj18Y/cl\nVOZml6N69stQ+e8A/Xd0D6rx3Lx3/m2ozPkuR6UhWh8VM2bqO7pXz6dRMbBA5Ys0FZXGRsOcdVHN\nj+XRN297Nyofn8mKelq0aNFitkUrAWrRokWL0cUFqDQrmwL4LIATUTEp86LyrTkXlSlU17qnS45t\nTEdFZH8PlQZk817Z/0Plb3JT7/ghVGZsdp0A8DSAw1EFBXgUlQnV71AxPlejYoR+AeCLAL6LinHa\nGFXAgmsc9QEV4f95VEzD46gYnMdQMUrH9+r4CypNxx29Z7YxDcCnUJmFfR2VluTbqLRBEx1j4Rsb\n9J6BasO+0evDer3nfRHV+BgTNfsdbQbgh6iYxrkBHGw9936otGNANXZfQGVyeDwq/6yx3vN/EoPv\nUPJ+n0Tl43UCKpPDWahM+e5jnrdFixYtWrRo0aJFi9kKE1A39WrRokWLFi3mGLTmbS1atGgx54DT\ncrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFixYtWrRo0aJFi+YQk6+g\ncay33nrda665JlywRYsWLVq0aNGiRYsWcyquQRW5cwDjgukB0O12W//bFrMnJk2ahEmTJg27Gy1a\nFEE7v1vM7mjnePM48kjggAOAljQsj/E2vzudDuDhb9robS1atGjRokWLFi1aBPByG/R/XKNlejLi\nn/8cdg9atGjRokWLFi1a5Ma0acACCwy7Fy1S0DI9GbHccsDf/z7sXrQYb5g4ceKwu9CiRTG087vF\n7I52js8ZmDlz2D0I46KLgHXWyVvn7DS/W6YnM1rVZwstZqcFpUULinZ+txhldDqVBN+FqVNlPiPt\nHG8xKrj4YuD66/PWOTvN75bpyYzvf3/YPWgxO2LTTYE//3nYvWjRokULP264Adhmm2H3Qg+fBP/N\nbwbOP7/ZvrRokYLOeAlPlgGPPlr9adAyPZkxZcqwezB7odPRT+ph4oYbgHvvzV/vb35T/Y1X/O53\nwH//O+xetBgl+KTrLcYvfvEL4Lzzht2LvHj88WH3oEULOc44Y9g9aA7vfjew8sq6e1qmJzPmJC67\nKTz22LB7IMfaawObb16m7vEcmnPjjYFDDhl2L1qMCiZPBuabb9i9aDG7YM89gfvvL1N303v61KnA\nTjs122aLFk3iwQfz1PPMM8BTT+nuaZmecYhFFwUeemjYvWgO443YbxnfFi14/OUvw+5BixIY1tp3\n4onABRfIyq68MnDLLWX7k4Lrrwd++tNh96KFwVFHAXvtVf0eb7TIqGKppfJZ8GjfScv0EBx5JLDk\nkuXbuegi4NZb4+7973+bjxL34outOYoULdPTogWP8aS9TcW0acBLLw27Fy0M7roLuPrq+rlRWrNb\nwnq0cOyxwA9/WL6dSZOAGTPKtzMqmD59OO22TA/B5MnAI4+Ub2fzzYHPf758O7nw5jcDO+wwnLZH\naUOSYDz199FHgSeeGHYvWsxpGJuDdp5ttgGWWCJ/vd1uRcC3qFCKWWh6PW+Znj7WXBN49ln3tWGM\nU8m5cPDBc5ZP+LDopHG79Xz2s8CBB8rKdrvArFmysuOFYG26ny+/DNx9d7Ntzmm4/HLgueeabXOZ\nZYAPfrCZtnxzdtas+gZ25ZXA008306cWw8F4Z3qeegq44gpZ2b/+tcx8vusuuRNvt9tMFLLxsn/G\nEsy/+11l9dCiGdx8cz7/jxyYkxjSF1+svue//U1/75Qp8rVg6tRK2dAUxu3Wc+658igVu+0GTJjQ\nP25CkyPBeNkgQnjgAeCb3xx2L8Y/NtwwLuT5Sy/pnfkMXn55+FHVXvta4Fvf6h+vvz5w6KHD60+L\nFiGstx6wwQbD7YPG3Pi554Ctty7Xl/EObi/+/e/7vzfeGPjxj8v2ZU4irMcDZhc6TYvnn6/+x7hS\n/Pvf8rLf+Abw4Q/r24jFuGV6APnicOONwMMP94+XXNJP6I23Cf7AA8Dyy8fde+21eRbYc84BDj88\nvR4fxtsmkDKHYu7dbjtgkUXk5a+9Vt9GSbzySpuDaLzguuvkWnMOo6rpkX4bf/2rvM5RWL9yvLNR\nx8kny8uad0L/u0BTBYw3GmG8Y5TGu3RfxtOz3nqr3FfxqacGNUam/qbXxxHdesrDJyWjL+DMM0fT\n6Xbq1Or/mWfG54VZd934YAo2RmFTn10Qs+g98IC8bLdbvXcbL7ygbzMGmmc7/vhy/WgRjw99CLjq\nqvR6RmlzN3j11cFvYzzjlVf6jtGjsEbPnAkcc4y8/PLLV5GzpCgVspqi9Fim1D9tWjWPRwl/+Utl\nFjheYa9V5t3MbrmoXAit0auvDhx9dP946aWBH/yg+k0js+28M/Ce9+TtXyzGNdMjXRxSNtgddtBF\n7tC0ldIv8+zf+U58HYBOAih1mt1nn0oiPKeiFEEnne+33eYPaS6RbJZCExGsWr+z8sgRYWgUNT0x\ntuvDROgbXnRRYMcd3WWvuQb42tfy94lb+6ZMAfbbT17XvfdW/n0lMQrMIMXtt8ffu+GGwCqr5OtL\nDuy0U2UWmBvDfHc331ym3hK0wwUXAEccob9PskbbDPYDD/QFYlttVS/38sv+Ov7zH76N++7LG+lt\nBLceOaST3pUTwje5mvyQUib4k08Ovw8GdMyOPx445ZT0escrmjZvo1httboPmw3X/F5oofQ2JTj9\n9LL1z5oFrLji+CNexxtyrJEp8/yOO3Q241KUCp4xLOLs2WeBO+909+FHP6pC8Urw5S9XdvcGjzwS\nZ45KiajYekpglJiflGiat9wyeoKf++5rpp1Op9Julm4DGK35EsKBB9a/XxvdbvVMLqak9LOa+i+5\nhC+37LJ5LT/GNdMz3iHd+M85ZzC6xeOPN9sHDuNpAWhRYXZ8Z//4R/V/lPNJ/fSnzWtBp07NG2hE\nqrE7//wqIqELWmLX9sFcZRVgk01098+pyEG4nHRSlfzTYKutgFVXld37/PP9aGd0r9HUkxspGu/S\na2fKO2sqstzqq1e+pBI0GZGU0yjkwOywb3Y6ff83497gMnGP0cb7BEeXXuruhxS+sOXAHJacdBQn\nYAn15HbbAbvsUj83//z528mJUbTZL4E99wTOPrt+LiXEZsyc1ki3hmne1hRG+dl22gn4yleabfOy\ny+IDjRx11KBpBDVd8GHrravUAi5ceKG8Dw8/XJlq2Zg5s//7l78Mm0hIMGyzVC00/U3tg00UceaN\ntE8rrwyss0712xBR555b/ZcQwz6meZgovbeZdzXKwSduvbWM6eFHPzpoJZJjvKdNy6tVHOU9hsJl\n6n7HHdX/z3zGf1/MuBumO3dkS/MtXH01sOWWaXW1TE9CnTNmDNoaNvUxLL542fpfegn4yU/K1N3p\n5DdPue22+MXx1VfjN5gTTxz0+Xrmmbi6gDjThHvukZd1MT3S/m65JbDHHvK2msYo+onkRKcTH7Qk\nFvvv7zeNkCDHeuiSXtv1fvrTo+fH0AQ0Y0vXt5T3Qu895ZQ6E2rjgQf6GljzfRqt0SiYYY2iEMj0\npQkfyBTY2tdXXskzhlddBey+e3o9FKedFq9VdNEVTTCkJ53UH9NOJ56+4bRfuROT52AsXUJcMw4/\n/3nlo5SCcU0mlJC4aD7cj3wEWGut+LZSgh7kenZfPZdcAnz+83nacCF35uEUP47559dFCSoJs5hO\nnZrGPPmQsjFdcEFfSjuKGI/21hQh+3dNpD6DYWpdc7wLSR2c+UPOdsYrcj4brWv33WW57wzT0/Q4\n//vfg3uZJrw1RVPfk50faNTxmtcAP/tZ9fsPf/BrlqdOrYQUOeAymfIhxezN1iI3ZdoIVL50pUy1\nzXOYXDyu55Lspynj4fuOXvOaeooZoE8X5TBfHNdMjw/dbmXSQSEhIl3hHn0v59prB0M+axbEUZDk\nlPLpCdWraVfD2ccmjuO0JZ/9bOX4WxLG1MOMy7LLAmuvnb8dQ1THLlaxSVBtXHopsOaa9XPDdo5v\nEr5nveOO6r1zMA6dN90Un59rWLjyyrQoPLZgg46h793fcYc/qAdFKYJmmMyUj3DJqemx2+H6EGJ6\ntt++7jtEsfrqFUGtxaWXDlotGEsD05emfGEMJk4ELrqILzPemHATMnz77f0+hDffXJmj5sAf/xh3\n3+OPA/POKy8fQ9+UxiqrVKZeJSExs/RFhUsdH2r6avpw5pn8fZddFv5uxg3TM22afCD//nfg4x8f\nZCp8Kngb11yj75sNzUKlMUuiWHll/T2vvlomJ0vomZ97Lo3YMfb/991XqXw5nHWW+3ynE08knntu\n+chjZm6aOf7MM7z09BvfiJMCvfe91X/JPL3xxjKL+yWXlAn5SQm8226rgoBI8Mor8d/GSy/5JVBH\nH131S8IsSoQgRphzzTVlTN1eeaWK9pML5l3ceSew/vrAxRfH12GbPWgSU/vCt4ew4opV+P0YPP10\nHhOYf/8b+P733ddSiOKUvYcjAiXrha/fZ58N/N//ua/deWclYJQKwOzophJJtW+MXcixJl5zDfCr\nX6XXM0ow45IryFIpPPSQnB6h+WYMYr69Z58FDjmELyO16LnjjjgBgIFGCCJZx6RCKClofRLaHajo\n/pC1xLhhelyT1B7Ye+7pEy1f+lL1n3Pwjnkp06aFM3GXkgBQsxaNpMJgm22AxRaTlfUxD1LY4/CG\nNwB77VX9NippyTgZkxVjE37ssZXK1wXJIpRCJMYSTlJI+m9vJkccEWfqpCHEmgo1CuT5bmgde+wh\njzC0+ebAggvGtbvSSpWpqws33FD9t5Pz+d61ZiMtJQX++9+Bww7LV5/ppwnuQeefZDOTPKuPYdRo\n02k7d99d+QLE4I1v7Dtkm3lphBQPPFCPcnT77f226R5z2mnAV78a1wcb9Nly5FqywX2/VCDArUG+\nd/31r1f/jQM2hxtuAN70pnCdNqREFQetP4N5B889V60hBuNNw6NBzDp/wgnp9dtj6iqzxhp1HyUD\nGo0s5d1cdVU9r+LWW1chxm1Q+pIbr5x+RalMD9WkSt4zLZNr3ofWtnHD9IQGZIUV+onPfCY8qYN6\n4ol9Sbmv3hzE27e/DXzqU/VzOTapf/xjUJrt66/GwU2iBTHvhBICHDTBDqhD6qxZeTYyAy4v0p/+\nlK8dblyMHXoO51vfvbEauVtuGY7K/9JL+3OVSpup0MOeE91uXVVO7cM14/Cvf/mFIbYjagijQOzk\nDgYRWoON5H6ttfrZvEN1+M65oNFauTb3FM24kRLT73Xppet+De9/P3DFFdXv006r7zHcc6ZEb6OM\nyOqrh7XoHHJoegB/AmxzjzF72W8/f+QpTQ67mG/O94yrrhqXP++hh9y5BJteD+66q5/XKQZ0XFId\nzg00ggczZkcd5RdEucb1llvca7jvXefY684/HzjvvOq3YbiMJl+yb5RmejRRBKlGTLKPSExiJWUp\nQjkixw3TI4HZoB57rPqfe9HwbYD2ebvNWO3AOecAv/513L25wE2yV16pbzjU6QwYlLCacdEQVbSs\n5H0ak7BPfxp4z3vkbTWBRx8Nm6TZ4+573hyJX311zzuvjlA3kEhgc0Tl+de/6pnkN9oI+O53q9/U\nZ4D2acUV+4FHpk4Fdtih+m/DMErzzpsn0Z2GmBkFpmeuueLvffBBYO+96+dCYYnN2nHjjeE1T/Jt\nzJxZD2nq8tGMhWs95wQr3MZNJchmXUiJBvryy8C227qv0Xros9x6K/Db3/aPt9/ev9+5+uTyofXd\n969/hcv6YObTT38K/OIXfFmT204yhrm+PZtADO3/PvPlBRbI0xctVl4ZeN/7+sdbbqkTttL5LnEV\nuOsu4KCD5G1Icf75dZ8XyfstHQLedY9ZP0ywBI2gvmRwklTEMIV2H0KBUVzrutG0/uY3/L1NMz3z\nADgTwB8B3AxgEwDLALiud+5/AYiHKzSwUjvDuebiiVHjoCeR/tovY8IEv+SKQ5MSc1/YUK4PDz9c\n33BcDvdGgpGCuefW32M2xRtu6JvFjQoWXxw4+OD0esxzpcwTblExQgMNmiLYzztPnkme4p57BrVy\nN95YP7aJWI2m0Ecgms0st6aHlr3zTr/fkGaeaJme7bevCFCg8lHQaGuAKhhMqIxGs/nCCzoJc6dT\n1/5xmDBh8H1KGGONFoSueRqi58EHq5Curra1UuGzz/b7/bj2NI2Az5fAkAOdAxLhmcmHpRnDp54K\n+/eYMZ0xoz5/7WtANV+4nG0mSTHtw8SJ7vMGt97aj7r18suDa1guXHCBTtMpWS/pN3DyycChh+r6\npanfBTqu1AdpyhTgrW91lzXHEiuUWbMGk8pT+NYebs6aoBtNmbd973vV/ylTmkuZ8PGP89ddfmNU\ns+5D00zPdgCeALAugI8D+BGAYwF8s3euA+BT3rszwnwc665bTR4TbtEFQ+BLoo4YKY1ZlIzG49RT\ngYUWkvWNk4SlEJeuBWH77dPref/75fcablyyOGk0PfTaqCZ2Czl5atTCKUwP58gcEyChKWnqPPMM\nnjMaAg1xLBm7FGdvA5fWzO7f4Yfn0Si9732VXxIHsyZx0Jq3nX12lXBVCk4QZV974QVeyhyrLTv2\n2L5gxJjlXnWV7F6g/23EMKgSTdUwE6SmtC1Zk3J8/6YOl/8FhdGyatpdZJGwD5V5xgsvrOgHDubb\nfuwxuYbe1O8rv/rqfe3ICSfI02ZMm5Yn5K8PEq0QnR8pmmUXYvYh6vd5yinhffrvf3ef73T6grWb\nbgI+/GG+HjpmZr5wz2EiyabQONR9gavrn/+s/n/4w/5gUCFztI026v829K3Epyd1nXWhaabnPABG\nmTkGYDqA96PS8gDA7wGsn6sxCfdsJDU09LQLmo/a2GibyXTQQXlzSeT2VyoNah/qm5h//av/GSVS\nBlMvl6H95puBL36Rr8dllqTFK68Aq61WP8dJ/oC03E0+bLDBoPbGda8JjJAjLHUpuAJ4hMbUBQmR\nFpvMjmuP4pvf7EvONQSJ63sPhXCVrF8pPj2SNejII+vHvnFZcMF+UlQN0xDC177Wj3pkJORG223m\nFld3TLZ4lxZE2v8U7V9sPSn3lEJugUZMvRQu8y3athE0nHBC2LyX9uH66/1ljdWJxvdw882Bd75T\nXh7QBTSKYZpzMz3GoV5DH1Ghk6158t1n+2598IN1gZKhU+i7cY0PXZOp364LOXx6abh0F9MT8gPk\nQPcR+z0bk2YJ02MEU2YsN97YX1Y6Hk0zPS8CeAHAgqgYoG+RPrwA4A2xladEHIsJy+c673uREsmU\nBL4+SLJb55Bcu5BTOvne9wKXX179ps8aUhUDsnCZZ53FB184+uh6NJ1YPPFEFTbZhmGGKWI2dem4\nX3HFIFPvascw5R/7mKxeDm96Uz9ymUHsPOl0+tItySZZWqodAwnBfsAB9ePHHstrulKa6eHg87Pi\nYCSMuQh/H8y7WXTRcFlNcBVujtFIX8YcWBPRiBJVXK6ZUWJgYpDC9Oyxh7x+H2z6wNR/xhnheg2j\nE/IzAPoaAiogHBvz7++aft91l9502Zdvx4UY5/NcqQvMOPgEYPba6ptLGtM44wv66KOVRse1Lpx9\ndvXfmHNyPj3DFkpImB7Nnkn9MyX7n+u8GVfDVL7+9eG2R828DQCWBHAVgJ8BOBeAPdwLAnCmED3s\nsEkAJmHSpEmY3KN+Q4wE9/BUayBhejgzFJ/EJfdmY+K803p96lYpZs0Cdtxx8Lyr/ylOahKCXaLi\n9dWfAyY8qhZUEmKeURJP3yRVjQn1aKCR9HKSkpgIRBRPPpk3F48hXGiIz1SUYH4efbQ/lmZOSN4N\nZQh22cVvuqKZ7+YZfTb3Bx3U9y/QSF4pkZ1b08DdmyNCJ12TJPf6mMJbbw37gnD1G78o6qDL3UMJ\n6TXWGCxjBBmlmR6jleD8dVL6YEwQc3+vueelHSob6FsMbLppuD6f6WS3O7i/S8dhrrn6msaQc3gq\naL9vv32wDO33TTe5743FD38YLmPaSgmoYeAy7adrvwm0w/XFd57bp0szPXQsuTkXMomX9JVjvEIM\n9eTJk3HuuZMATMITT0xi22ma6XkrgMsBfB3AT3rnbgewXu/3RuibutWw4YaTYJieicbTLwCOUz31\n1Po1CadrpCSuzc04e4XqSEXIDO/Tnx6UGEvw0kt1vyazieXqv9Te0nWPD3/+sy4Ph4GrDzk2U98i\napKrcnCZ04V8MGKi2xm4VNUpwSc4nzgfYrKg03wAsTDO7pL3/uKLg8QMh8UXB668sn6Ok3TFbHwx\nsDU973hHXyt66KHAhz5U/fYxPS6CSeIjZOB7hjXXHCwTyoUmqVcD824kz/OMUyRXjSH1BYlZUzTJ\nUCXPbgjeFA2YBEaDLdF+ULi0D76UCaPgq6kJDmGEoRKBAKfl8xF9hhnksM464TKhvsXAFdXVMDkU\nqe81pp9U8J0acczA+AzGaI64euk1akmRgvnmGzxHE6lyz6MJ0OTb17hAGIbW8ZWZOHEiPvOZSQAm\n4YUXJrHtN830fBOV+dpBAK7u/X0LwMEAbgAwN4DzXTfGZJ/liAt6TfPRuTY389JpnHs7bCKHD36w\nys8TQogQ+uUvB+3mU8CpZDUw40BzqrggXXxWXbVK0gnESb5t5CCeKBMyZQpf/pRT+oSWMc2U9MMw\n3fQ5NJmwXVG2aDZ0zaIaswDbEjDDJGgIaQrNvDSaNQqX9njq1EpzZTN2IYbNRxy74LPdNwlNXSYb\nqfP13/92M+m+b+9vfxs8R6Pocd+tz8duySX7v80zSULd+hAjUTT9pj5ELlBCztxbykH8qKP812IE\nSJxEltYXY/LNfYO+cXVF2fQF5cjN9EgFC8MwD5S0ya0zRmvYlIaHanZc7+qSS9x1pObU02h8zTXj\nH5JSr+sbpCaBEu0nDaYgiZpHTee5+g2M4IsKtyQa/pgULK736vuGXefN+Brayk7yTTGqPj17AXgb\ngA9bf3cBmAhgLQA7A3B2PcbWXLNQuQY8JooVTdIkzdJ8000yu98Sqk0b1MSGaycmMINGui95xpx5\nOFJBF8DDD+fL7757PTeGFKFgEBK4zGjoeMckK7TnD+2fMUkygRJsc1EjEU1JBrnccvH3GnBJeW3z\nz9e9Tjf3OE1PSLOhJQjuvbdKbkwZONOukXC65o+PUXeVpZsg972GTL9cMBLTVLNNikmT6mXNs8Vo\njU0dEqE2CHwtAAAgAElEQVTcMAhn2rYm+aSkvzmeyVWHz/809xiW1oBJYNaRmHo5uihH0mzJ+BiG\nn9JQrnUrp6WHgTahto9xiRl/1z1UAHLOOdV/Y0Ls6gvd9xZZpPqfkiwWGPSt+dznqv92cmS7H7nh\nYrhNW5QZlJi3ce/a0BchjJvkpDYnKo3zzznu0nwGrpcusQ/13WuQKsGQtpVrIaZ24a72jGRuiy3y\ntElRmrFzoYRvB2fSZyJtfec78fXTeuef319WogWiKvYYGOdNG8aUzJjAmE2gyfcrlcRr+kR9/DhN\nckqb2nG6+OJqs5swoX6/+W/CjrrmpdHISiSa9BwX8TBGQi8JZJDTrCXGX4zbhOn4SCSzGmie3RAf\nv/pV3j74/FxfeilN++Vbi0qtGZyww9durr5IknP69qcYYXBs0nQffOOgYXpSxve55/L4ZuWyAPEJ\nYkwwHkAe+v6ww9L6RJkOo43TBExJgatesxdssEH9POczL6HPpALkccP0GOkcIM8S7FOluuD6QGOS\nqBkYhkDC9GiyHvsigaROWtMHSUZw8+EYSXLTkbBsGPOPVPO2J55olgg3kegMYcdBSgBw70Ezx1Jg\n98lIziUazNKgkjSJ5MgH84wuXy2TyJibS3RxDzEE2nlpynNMGZCeU4XmLTvzzPA9MdA8v0Q7ab4F\n81+yfvmIlAsukAf+MHNjGNhyyzL1+va3k08ejJAZ8l3LhRhtQoxPooaR556Rpghwlb3ssvpxinZi\nww3DZUzUSGOZcfHF+gA6rrlhmDRqtpnC9HQ6eYVMmnttGtGY8EoE01QQ5bvHlaajBJ1ia19iLJxC\n9dr7rzlHffm4PJh07rmsLEbVvC0LpP4DqeZtOSAhNjXRsnwq61RVts8Ui1uM6ISW5Hcx2giJT0/p\nhcz2M/jtb91O8i5nzBzQSO58dtsuxldKxDfB4B14IN9WU+YzrnrM+O+2m74u4wvjWjNMHheO4aDE\nb+gZczGNmrFMCWqhaVtCCGgksRKpuYExRZb4snz5y+72Zs7sm+GF8POf55eySyFZF2II6Lnndp+f\nNUtu5TAK+3QIdh9NH2KS53JlufE364qR3FOmx0T/k0CSuoKuUS6fPgMf4c75aNCATJJAUkBlCkxN\n5Ll1wSUwzGneZhPfVEhO6RjXWheiD6XmujERXV3l3vhG4Ctfkd2jgZ1uxDffXWNB36MZb+oDZZcN\nYVwyPdLkiaOwmOY2bzOgz0ZtN7WQEvcuEx5jOiVJ8GpyYaQSsyn3m4+NZtN+/PHBeqU+WS7YH7d0\nflFH/m5XzjRwZUP35oLLz0vD9NBzOSPU2DBzwOf3wsH0ifu2KSHM1RuaG1On9hPHSuqj8G2w3CZP\nzX1SbfFLSflLrK8u23sz/hLCzvc+u904vyEbq60W5x8VkijHwlefSbJowPm/adYt19heeqnsXhc4\nYl7TBwqTcNhA8nwSYZ+ZP2beGyHZ0UeH69dAY/5krlEago7T9On9eqlQxWWaRNfQ//ynyuPniirm\n65/EkiI3aF+MwMEl0AyZervOUyF5TOQ07v3SvaYU6NrtEsyYflGzXJeQf7ZleppSY2rvX3bZ9DpS\nzB+assm0j03CNPMBSdSiXD81OSpyqKjpgtjtyhzpH31UZ6++wAI6Vb2Nf/zDfy8ND9vtNmtq+Mtf\nDkZ80wgPJGWNtigVdAx9xKfkPZlNh+t/zoAd3a4/6Z4mmAI1cdKYt2nmlcssWDKuMebEu+6qv4eC\nPptr8/URxzNnDj6bT3OfY42+7ba04Ccp+6crPLKvvn/9q37txhvzrOeuci4mVQppwm67XUlkRipg\n4PwVTN00CBKHE0+s/mvCZ1NMm+YXdmqEffvvX/0P5QqcPt3vg+SiHai57GKLVf9da7dEkxwq6woa\nQMv6khPbe68v0FCukNjHH6+vR9NOTlpSYilk4NL0aFJUzLZMjwYcwS6BJuFnjkzmrnC9Pkmm9Flu\nvjkuyprB+SSAeLfrD/kqMeWj6sof/hD4wheq30aCI5F4pb5bF669NtwOUOVh2Xtveb0f/ai8LDUX\nmTrV/2w0WkkpJtGH3XarEmjakJop+EA3hhwJ5FxwJc4DZH01uVTos9r3anJlSYQdvvmu+eao9Jkj\nCFLmC22Hq8/uA41iZyLJcX1J0cRqYNYr+mycCc9gAr3BsinjrGESNUyPEejQ/nORmFywr4UY7Jwa\nap/gykVYm/pWWincrilr0gto+mWuuxgmc22rrfg6XO3EmIIbfO97wNvfXv2mQhWax9DXPjCo1ePg\no5M02mEKl6YnZjyoD5oLGiFcDvqlKXNOKqDIhf/+d/AZfM/kihwaSvsRgzmK6dFy2r5oPinSdE7i\n48Lll7vPSz+aNdeU2bn77t9vv8FzNEJXKHGUDSMp2Xnn6v9JJ/U1FoawkBBeJYh4SY6Yffet/kui\noRmJrGa+0CRhs2bx0iV6LFWTl9IMpjr35ugXrUNDHGqcYnM5Mt98s7weTb0hlNL0uOAbK9c3F2Na\nUxo58oq5JNQ0RYCB5Jk5zTo1DTLjL5mzp50m75NYujqmM+HxQdJ/X6JwTiCz6qr18668UiecUP03\nFg4cfOutKw8YLeuK2OUryyURD81L24SVajJ9zAkXoTE3Yq0jpNdi+kCTTmvaSg0cEwNfm9wam5I2\ngmKnneQmyHZ0uxjMtpqeFPW8dmL5yn/xi4PnfJPLLLRLLVX9d5lJXHyxvw85bNapuYZr86UhvH33\ndruDkmmzQGo0Yy4TEmNL6rOfp/3IDUmIzeOOq/67pCG++SYJ9+s73+32TRlCoO1Pm9a8BElDGJVa\n6KnELsXmHwh/2zZKJQL0bVKSMYzZ+GnwBE0dLoLJ10+qKXSh1DrgM0PREpA+BlEyF3z9dxEAmndO\nCRefpsde82hEw5yMb4gwzanpiQk+ExKUdLuDEdQMjjkmb/99WmjAH2AkdT2nwlj6DUv2ZBdsxlwj\nlAN0tA+93wgTNOZt3LiH7pUgl3lbyv1NCYkMpk9vrg+zLdMD1D/wXAOYWk8oegbnHCbRGvjqDbUP\nDAYYSIkgxBEEmrCf5h47G7eR+mr8IXJCoyZ3BdNIJa5NH2j7vj64kkPaZZ9/3i+Z0izAGhNLDdNT\nivGiRM+MGWlEiab/OaVkEqSMITcHOIlm7rak0LwbDcGUwvRw4y+ZC756XRH7qMDM9+zTp/v9imh/\nXXm1fMyVJBKW71rI/Dsn0xATLELyHfnK7Lef3Lwtlc6gYX4NYnLM2L5Q9N3S+n7843DfKLbfflCT\nq4ky5mMyXb4yvn071ZpASg+kCtRz1CuZ98aPuak8PS66N1dblG6WmuWNO6aHDhjnVFhK06MhTCWT\ni9sQfPVSs4hOxx89jZrpafwkJGNo+i/NiCttUyPhzfEhpRJmvuAGNCdBrj7cdFP9mAYVAGQmeyH4\n/CY0kdpiEVPf739fP/7Tn3RElbQs59NDoXkPlLDh5kQppodC822n5FBwwfhQaAiY9743XK9JxEoZ\nJE1fXcmFzbi6BCNSYZWrD8bR2vR73nnd906eDHz3u+76aJRPW8JPfaio+ZxLOCddo0PaHOmY77BD\nuEyM34iEadFEAqP12d+pNGCBCRDA1WtA87n87W/htYEzVfONoWbNmDAh/l6gn8w6hE7HH5J9jz0G\nz9H9zGXKCOj8U7td//O9+c3Vf24P8L0rzfruMkuNMW8rjVxtxVpBjTumxzW5NRGMfNC8CDOJJfdL\ncjjEENs//OFgHdScwqfm9+XkkcD1nFxSKR84ky9j2pGD6bn/frlPh6sO6lytvR9wO3b7oDENorj7\n7kFCQ5N/yQdNsjINYdrUQptiJsFBsylq8gG5/PhoveZbdxGi0rwxGumwSyPggwn0YCPFIVVq3mlD\n43dhfDU4+L6Bp59Oy5Hhu9dFIFFpOyUq7Tp96yOVvNr+ZLfdVr/2rW+56widcyGXpsfkebNRSotI\nJeecsDDUf9u8kAqLfPcusoi+HYOHHgIuukhWFsgTaYwiZX3XaOu6Xb9g0SUIPuaY+rHP0uYXv3C3\npQX109VA057LP1AaZVbTjo9JlCLXvh87R8cd0+OaiD7Va7dbl5rmkpgut5y8LP2gXH2gUjkJ6MRx\nMYM+gl0TGnMYEgAq6Tb+UHY5ab/uvFNu422cQm34wqFyMeVd56X9jTFT8JXrdvvS5hCTyAXYkCY8\nddXrO8ed15YJQRtwIFbTA7jDnmohkcIZrd4KKwxeczlLS9oB9IFWXEiNuKOZL9J35QtKAwya9qRY\nBMyYwUfUkhKXLlMyX1kXYSed864gKb51uNv1B1VxQaPpkcL1XL5gEBIYgamrXjv3jdR8zQdTvyvE\neYq5FQdXlDkp5por/l4D1zuXCgg4QaWLIdKsObQtX3RbakWkMZO2keLbp4GLGaEaQK596ZqRatHT\nJE3pwrhjelwhWn1qw263PnG16nWpyVqnExfv34CTakgXiRSTNU35XBNWQhBIskDHtOPKN+HrQw5o\nNjkTQtQuqyHCaVnf5kXLcU6crvZ9i6lr4fQxTXRjmzZt8H4fg/7kk2UWT00EGdezaohCH1xMT1P5\nl3wCmCbzP/n8UbhwvyFss43/Gn22FJNBe3/6wx/q15ZYYrC8jyCiz3XXXf53QM2uNO/KVdb4ZroI\nVhcjJIFG06Pdp+nep3n+L3/Zf4064afAjp6XUpfmXuk4SPZibZ2+enOUpd/Vgw8CP/2p/H4pKNPm\nYlhjoEmsqVmLXOa0rnOu9rpd4Mgj5W354LKCouBcUjRWJfZc1KRlGXdMz0MPDb4wX0baWbMG7Z59\nk0uTZ2fYnCogM98ooaLO9eyuiU8ZWp/9tosR8PVrp50Gr3G2zE1sSFw5atKQsnF0Ov1FMxRkQhtO\nc/nl5WV95mU0B9Szz8pNJTWZ1DWMoy8JqAulAjHQd5FD6ipph4NmM0qFTwi0ySb14xkz3BoRLeg4\nmCzpMeAYVNd7/OMf/fXYcJnR+fIBaQQCrn3PfFsSQZodiCbUDjeHbDMcru8Sk9IYc0NpHdL7Kbg8\nScOmJ1xj6guYMOy+ApUm2+6HJoElEP8MIW2lPWduucUdjASoQoVLmfzUPUbj00PNW6Ww+7j66oPX\n6fOZvIwuSBL/uqDRPo07pufQQwfP+ewWu90608Op5111SKOIlZC+AOnhqjfaKO1+gxKaHtd4+3yz\n6JhpHNOffz6+z//8Zx7JFj1///26jVnDTPk2b5d0SYpc+WhC6HTk5lUaRkYDbgwpKBGn6Q/nK0bN\n0zqdtGhkPuK1FNOT+l58/aJzY/LkNH89A6pNTAn+wbXjEthJ34Gr3DLLuNv8z3/k70DLUNN+rLWW\nv6zdh7Ex4MIL69cXW6x/7cwz++e59WbppWX9dMGnQXS1SQlArXkbzRVk6ndpyDWMu+bbkiQu1tbZ\n6biT7PrqjV0LQsyFLRiRJHeW1s0JUzmmh56/9Vb/2qQJgKMZvxQGqduVC/65MVp44cHy9jwMPQ+n\nkaew1yJVSgV50fGHF18cXNR9+WhoxCdzvwuuF+dzVgu9ZG5h2m47/l5tW9pyqffOnCmXyGs+fEmy\n1Rx4/HH5x3Tddf5noJLXqVPl6uxuV07waqPN2OD8nnzJCl1w5ZySzplOB5h7blnZbndQU+RDqlmC\n795Jk+Lr5PzqaCACLrGjBJr350OnwxONNlL6qnVgliImd0tMu7mY8W63bsbT6QyuRT6mRzNfpN+b\nrw8cKMFI1zFjCjPPPPI0FClje801/mvUJ+SRR+Il38Cgn5V5PleEzVI+tpqkzFI8+aRcqq6JEJYi\nOM5pesvttRpNj0Z7k6usaxyMYAGo51F8/esH6+VMs+12uUAGrv7RoFscuG+UQ8v09HDaafXBGBsr\nZyqy6KKycvTlcE7iUic0LUrZ2lLMmCGXmj7wgF/SQDVAGvO20LVQ5D8fUfDGN9aPQzalriSALrie\nSyOxo/f7pD8f+1j9mHMG1kTnc2kESjA9gFxCqmF6NIxjCrg6afAMzYI+ffpged/80RKw0iiZ9Nk0\n0TWljJUWGiloaFw402LtXPGZ5nQ6wEkn8X0ybWnz59iYay65SWcKcWmb2hqsvXb1f/vt5dYEkufS\nmuoCg9/crFl14UOoXZ+ZIr1fMz9c343UnLAUttuuzHooXbMMKEOtgZRxyMlM2XQe3Y9mzfLTPq51\ny2VCBrj7+9rX9n/becNWXLFertuVJWcFKm2MT0jhGlufqWQqYufhuGR6pA/7jnfUjzudeBUedy0k\nHbBBmZycH5Z0Y9e0+eyz8eZtmrLTp/sJbyoJcxH3mnxNNkIE2RZbuM8vsAB/H4Udtrrb9b8Dyjxr\nHPTouHDv+ZJLBu8tBU3dMYkFc8LlaFxibJ5+2q9JpoE2NBL2f/xjsL+ahIY++HKA5cbYWJoDdg6E\n6uXW+1mzgB/8QN6WT2pKx+DUU/3z0hV8Qjo2Y2Py4Bu5mR4zjo88kpfpsYm72Dnyy1/qnpcSjPRe\nE8VVown89rcHz7kijDYJbfJl+l6lPibcviwNwyzpU45ykrI2E0fXY45uc6010jxUHONIy/7jH7wJ\nM2e+GXr2Ur6vNmZ7TY8mFKNL9R9zH4fTT/eXpy/j+9+X1/uXv9TvDxGE3EKRi5BrSksUqpfWfeCB\n6fW6TBTnmcffB3rMfdyxZn5bby27z9xrE8zcJiONNtgkxsbcG70LGuKBvlcuyaCrzlzz2I6k8+qr\nwGqr5ak3FrmdtbXlXOh0/BGHcrZTsl5fYB1Ax9DZZc88s55Tx5QBKsdoGwstpNOuloLdh7GxwfWR\n+tu6fnN1SspTSH3THnhAbq4EDD4bHdfLLpPVw0GjMe125VYt3D7hKms/Q0zkWRd+97v682nGO+cc\njqWTrrvOP1+23ZZvh4volzLfn39ePod/9Su+Lsqo2RrH0LcbKzQPwa5Lk2phXDI9IVWyD488olsI\nfKDRJzgbRxqSlGokuA+WxoVPmTD2IrH00vHMSylCQ7NwXXVVPubLvubaVDQBBzimJ4Vg1EhKbElc\npyMPZV6K+Hn1Vfmza0ybNEzPvPPWy4YSzsaaZ4X6w20cHOaaq0yo2BJhXoFBk1ZtCOVTT5WVHUWm\nJ3SvtO777x8sKzUVXmop+ZqhCQww33zx64SL6bHfs/2s2vD50jE977zBYAo+aIMI2X147jn/OFEC\nN/SepAyGC64cXqmggYG4OekaA9+4nHee7vluuEFelqKEwPfqq/1laZ5BCo7poSksuH7QsZ0508/0\naKyVgMGkxpL+GMRqerjcahTSPQMYp0yPDc0EPuusMpqev/5VvhloQmNTpJoX+OpJTT45DJRgelLb\nz8H0pNz7+OP1sqnR/3LARbz58LvfyevVjCc1RdR+R7vvriufGyEHWhsaZlCbl6EJ7XCpPCAaUNNP\nCo2DdklwxI+0T8suKy+73nqycgaUYKfroy8PDudj5JLES/fU226TE2C03E038eUpIyAVlp18srxe\nDXKZ8udEaOw1/jSxUn56b6ictGxKoBTN+NNw1zaoVYqG7tEKa2LCwmuhSR+haXfcMz0hUO6W0/Ro\nQuvRNjTlbU1VKXUfVy+VLJxyirxeCo5h0o7LeEa3K2d6XBHOXOW4cy7QCHK+SIVNQkOAlSJ46XzX\nMsFSU0BNgmANNGOYK4GeC018yyXNrWY35BDmLLywvGyKxvGQQ3izP7usxhdBI3DUJAadMaNeb8j8\nR8pM0fZDTt6ab87WuozivvuFL/DjpDEntBESUlBwUe3onJWC00qkaELotXvu8ZenQYB+85t8zAlt\n02eKmEK/UMRGcgth3DM93IJ34431426XV8faBHwuTQLF2FhdYjYMKejcc9ev//a38fVq8r9wnPu5\n58rrcfUjtmxI4lGCEL/0Ur9teepmFTLXGwakmkTNWEtzaAHAxz9eP9YSGjRvjq9sMcmUwrnflQtG\nCo3GVwPts/oS36bUC9SDgoQk9xrEMmrGuT22XlvCbY8FDRrAjdPb3qbTxMY+KxcdEpCbfNG+aqN8\nSZ912jTds2qYnti9KzSGtA9Sh39tgl+pAImO3+WX69btEtCMP+e24ILUlAyoB2fSzHdOuDr//PVj\nagLI9Umr6aG+w9J7NXM/ZN5Gv20pxj3To11ApHajWkmyFBrzNjqJNSpfblJTNSh1kA3VKw0r/Mgj\n9QXVl6EY0BGMtE8h2KFHqY9VTpOdEBFjcMcdg87HBieeyLeVM/RuU7j88vx1PvigTkJtg7vPdq7W\nQjPeHCNFEcq7Ypsxbr45cMYZ8rpthAIINCU9Xn99WTltf2xfrhRzlFxmxjRMMkXo+fbZx12WCrVC\nQh/pOB5xhKycC6EIcfa6Rs1yUyTJtn9QpwP8+tf+sprQ/KE++OYIDaoSmkv2uLhy/HCQ5tN58UVd\nQt6UdYAjZOlYuBJd5uhD0+h2B5/NzsGl0fRw36sJAW8wY0ad3uTecYiuoNdtmirEALXR24YMXzQu\nCs1HRQMOcKBMj33fuuvWry27bLzKlyu70krx3He3K082dffdwC67yMpq8yeFzPds2GrqkKkSrTdk\nvmfDl3PDVdYHl4OmRqIRW3a8IcW8jcOCC5bT8to44AB52VAOsFybSs75YhOb2vGU5llJmb/S3FcS\naPrElaWS+dD7sCXRdl3zz68TlMSOaSj5Zex3lJPpufba+jFnpqa1NuD64Ht3dP/nUi3QerUBQaR4\n5ZV6COIQpO+Vata0Vi0p/s8+hEzhaB+pkJSDPeb2+kK/kx/9qF5Ww/S4+mhw0EF17S81b7MFrVRj\npNX02N+ozUy51oRRozNme6aHfnRSdazmRWlsDzUfspaYkS4wyyxTvx7KBUPrlY7TzJlyE6ucTA+9\n5nOYDdUDAF/+sqwN7aIRq0nUtBPa+OxFsJRpWYpUPOSgKh1DTVZr7QJtZ7kusUkD4ShMo6LRs2FL\n9rXEr7R8ymY6CkE+pKG5ffC99+OOq8/5kPmMPY6lmEFNWdrf0Ppnn/Np0AH9dxJr2swx7tSs+YQT\n5PVq+qDBZpvJQ3lr2tGOt22+99e/5l2nDf7yl/oxjbpGYScIDsGEJQfqJtQ0shhNbqzV9HDl77yz\n/5tb4/baSx8C3YZvr7viivC9UmjMrTVzTZH/fDSx777ysjkXkNgXqYn8oyHW6HVa1lZ177orsMMO\nfF1cG9LFiDpVcxMz5CjKtRMCt2nSYztscrfrJ/Bd7b/2tfLypTYzTVk7YaoGmm9OE4aUkya5ykqf\n9bDDKg2OAcecaIlh2x+ulGZN881pYUuaNYRPaEOyNep0TDlmtgkiD8jrvxTLdKb63PmETw89JJck\n03tDYczt7znnHmmXpe+G29fot0HnFg0LX0pAQPc5XzuTJ4c1ZDY0+Whiv4f774+vh443xzSHEpte\ncEH/91NPlYmGSuvkmGRaPtSm1LwdkAuOtZpNWwBP5yHHuISezZdY2HXtoYf6v9deO17bFzK5jNWC\njntND2dSRBEiHmIDGWggNd2QHFNwH2jKJs8tDFy9GgJSk6MFiGd6QvjOd/q/Ne+KnkvJI8DVm1PT\nE2sWdeut8rKnnx7Xhgt2SOvDDpPfd9VV9Yh53Lj88Y/5BBoahNrUBAzR1GuHrdZEQbrySv66PRbU\nZzDkYN2EOYRmDocQu6lzZlwSTJni74NU00MRElL8+MfyujTt2v3fc0//tW5XlzPEZuRLJeMF6s86\nNsYT+LGmZNr+h/LDSNoMXacmgeef3/+tCRxhyhvcfnuZdYAGMCkl3NbQblpNzyc+4S9vB+/iXClC\n7VBmVsOY2Uw0NS0PBeOwUSqa67hneijoRmI7jAH84Nic+ihqekIIScSk7VLYKmB6H438UspUIgUl\nFk+XvbL9vlIcpVMQy/SsskpcGznxla/w121tpTbikI1S0t6STI+GUNLUG0uYau7bYAN5n6hgSiP1\nD8F+P//7v7p7S0DjLxACHRd73EIS8/POc9fjgk3Q2A7MqZDug91uXUB2yy3yefDww2kmaxyoRkYT\nqCRXH+zrTz+dj2CnkJoQuoLySNs96aQy2u1QpFqOTqLXaHQ3TZ9sixCNRuvcc+V+6UC8y8Z++/H9\nsEEDFdExs49tQU0I9FulVjTRiZLjbhtd0OgsttkUp+nZaKP6sZZJkEZ92mQTf73U6VIrCSzF9HCT\nmOujJsCDFnbIxxA05m1S7Lrr4LlS46/RmMVKJ0PO8k1oP0oJGihCvjfDYNy5Z+Pym4TuDY3Z5Mny\nsrGbF1eP5hpFE1GBXLAjF2lh9/mYY9L74gKN2hQaJzvaX+h7tTVkXDROIH6P4a7RcldcEa9NSOkT\nhT3GoVDHsYKGkP+JjV13Lcf0cPlr7PGV5jfzwR6ne+/t/1511Wa0wQDfDmeeGtrv7TVdo+k5/fTK\njF5Sfp556lp2zl0ihaHjXBOoMPj66/1lKeg+rQ1w4q1XXnR8gDO3eugh4Gc/c1/7/e/rx3QQQ2p/\nLoyz3aeFFuLr4fqgKU/vzSWF1pimlCQYf/ADeVmNXbQUZ545eI57X9wHG0pqafc/NA9jCQ07YW5O\n5Arv60LsxifNXwGEGc4ShB3FZZfFj2OIwIo16dVKcaWgQhWtiWnOfuS+BgDHHiu/N3ZuXX89L5iy\n8eST5cZRM04apoeu55p2NCHDtflTDD72sfo1zhoiBLsPIUED3adLMT0c6PdKfaqkmGuu+rPbfiIf\n/CDPUKX4kVJwAlP6rBqtim12yfkZ2c9t6rX9Uynsduedt07XLr443ydfPa5jaVlq3pYiqKLt0KAU\nUsx2TA+FveBcfbU8a7pWUs9NClsyqJ1MGm6W+0C1QRF8ZQ86SF6WtllKyqZhGmiI0NgF/qGHBh2/\nOebwne/012VHfQmBSmDoAq9hXuxxCUWp0cxDO4JMCtNDny0Xcbb//vKy1LGbEpD282mit9FxCWUq\njx3HkLY4NjIgddrNyfxx1//5z7g2tTj7bP81TbvUt0OaOwVI0/Dax1wy3s02i5eYavtkIzaiomt+\naNsmbawAACAASURBVOaw/R1RgpJrN3TNPqbmX/Z6yNU7YYKuDxxC31Ho3tiydJ0KaQN9ddEgSPQ3\nZ6YWSj7tazN0HNpbNd8RF2jEDvdP1wDKRHBBMeh+9MY31o+5/trHH/iAPqy2XU/sPKRziX6vGrNc\nG7Md00NfgK3eC0UPsVFK8h0r5ZHUxS3+VK0Yu7BdeCHPxNk48shyC699/Rvf4O+1x+W73+XLaqQS\nlCi3y3/ta/VrCyzgL5vCzNJAAZrw6Ztu2v+tMfkK9TcUalqK007jr8fOrVDULLtemk+HOsBLtRJc\nG65jCq5uTnNFI/TRZ4/VWlDm22ZGUsG1a/e/pHnb5z7nv6aZd6F0ABxizaDoMSV2csGOtuVCLqaH\nrn8hQpur1y6roQdShJ7Ssg8+OOgL5Cu7zDKD57i1SRqpUxt8gFrWUH+TlDD+vn1v1qx8FhsaOoMK\nOTm/3dD85rRCdP/kgiJx7dAxosltbTqOMqchQYO0D7Nm1a+nJP9ONZc0mO2YHo1qk4NNELoQS9hp\nFstZs+qSZs3CS6/ZUT1C7VLYZZ9/fpDJ8JW9//54wpR+SDR8obTeHXfUMTJ21vYLL+TL2h9ht1uv\n287BscsuundFwZlEcqEkNRtDKE+S3ceQBibWeZJrM7WuWFBJGu3DWWf1f1PGVoMUpofTdNKNmTPJ\n4PKjAHwfc2lx6QbLldUSVLGE0oMPyuvREFEh+MouuaTu3hShCoWGaYg1D+PKpkiOgfhQ3hQ0glyO\n9woM+ov5+ugyp6fzVGMaZ6BleiZNqh/bvjeA7huV7pHdbj6z19AcoFH5pO2E6uXm4c4714/XXrt+\nTMdcCmoORiPZ2eAYF64sPabf64c+FO6n3S7XDleWw7CYng8AuLr3exkA1wH4I4D/BZDEw9sqr5yg\nA/7979eP6cdug/tAObvEmTPrISBDfZJeAwZj83NIWdBj/WloKEyqspb2iWYnD222tkTs5JP5umk0\nEbuuNdbo/3ZpLDREyXzz9X9zTI7ruhQaYo3O9VzEMMBHpkkx0QzBtsPn6qUJJU1y0k6H9+sL1RuS\n2HEEJlevxgcvRZqdk+mR3lsqGSwFHcNcBG4Ivm/ZVWcpgUBK0AbOp5PbJ7h6qHDJdcy1I20zdJ2G\nkNcQhSkaPO58agh0oPqmUuYS9ZlO0cj43mu3m+/b15j/0jZDGg4OHNMTyh3EmbTZfVhkEb4ejaBB\nY95G39vPf94/1rw3qtlJERzbGAbT83UApwEwpNxxAL4JYF1UDM+nUirPmR+FQy5ND7cxTJzI38t9\noKGyuUIq03qprT/dsKQIaVmkmHtufjFKWeA57cgb3sC3o/lgqePiJz8JvP3t1W9uwQkl98oFzvdA\nuzm95jX936Og6aGgPmEGqcRCCkORYk6oYXo45DI3CWWoT2kz1/xJYdo0SGF6YgmCEDR1HXGEvB6u\nXjviKZUcv/AC75tTiunRtJPyHWnutXPMAbr+L798v/1cmjQgjTnx0Q4h87acQglOyMLNYQ0DmtO5\n3z5OichKx1szpraJJqUHc6aL0DCZNobB9NwHYAv0NTrvR6XlAYDfA1g/pXJNDHMNNJHIqGQw1tzH\ndmhzgWN6QvaPuSQldBJTlakmy7uNW26pH8duQIsuWl+ANM7BoQ80Vrq94II6ouRTn+pvSgDwtrcB\nK61U/eY0PwceKO9fCLEbITfP1ltP105Jpie1bhexoIkSl7LxaeY0hYbpyWU6zI01DeNMy9rPShNT\na4IEUFDTIK4PFDTYheZerqzvvZZkemiksVLaNA3TYwsyablLL5XXQ5HC9KQICHL00VUHfXcxe+b0\n6XwI4hBSmB7puFDaIAUpTA83viFtjV0XXcdyIZTWQyosC2l6uDHUpBZJgSa5/TCYngsA2CyE/Zm8\nAIDIyHVIWaS5l6eJkU8dxmKzf999d/1YY35CI8bQccm1GNF6OEZAwyRQczaayVe6qVPJoMYuN4Tj\njpPXw6mLQ/d2On3HVfM8Ziw15m0pDEWstJJbWKk2DOC1U5yWjjqM+0LT+2AnMc5lFpLTUboUNNrh\nU07x15NTgscRDPY6fPHF9WucjXoImtC6tOw55/R/X3JJfB8ofEyzhOmxA/ho5hJNglsqkW/s/Kbr\nOUXOCKG20DHEkHLrLhUWcMIQqabn3nvzpi+w+x8KUKFpM3b+cNFO77gjHzMeGiN7XKj5Mjf+lHHk\non5ykSK1sIXMIaG5VIgVYuA0excNEKZJ4svVS1POcAhYoTcCe7lYEIDHgGSS9Xti728QKcQCxy2m\nSGf22stfT06TGE7d97vfyevVmIBpmJ5Q1KzFFuszOyH1sHTcQptkyvhzm2Lo3dh5fiQMhxlX8zxm\n3KkGkvqc5ELsOP3oR/F1atqki2lO4lOCsbE0x2juWoomh5o4aL4jei1X3q3Qe73oIv81biw082nt\ntesRLTXE2SOP+K/97W/yekLQJPJrCm96E/Dvf6fXIw3jTKFlemJ9EULQ3Ev7G9oHuXtthDQesSHP\nc0ZF5L4rSm/ZfaCm43QcNBEJ6Vzj6uWO3/KW+rU//7l+zI0b1QbbArGU9Z2C06zErv1TpqRpwm1Q\noQr1jdfAbneeeSZj+vTJovtGIXrb7QCMoctG6Ju6EUyy/iZ6K0shYrmwqymRjGJNDSg0Hyi9xi0w\nq69ev0bzxuSSrB1/PH/dlvzbvh0uaDZJjVbFRujZ7KhqtN7NNqsf2wEpQtHPXMeGyTHXTN9y2Z1L\n7rUDKsTWa5tghO676iq+He5+qhnkEMrXYcM3J1yaHs23Qd+jJtdELoTG99RT/fdS7bYm95SG8ZI6\nvAO8RH2VVcL9kvaBc0pOYTJ9eOyxQQ0qd28oBxcHyuDZ/jUUmnWACuGk61jI1Cb0zdn30no0ptga\neoBKs+0IoSFw9dIoXxSaIEJ2OzRAjwaahJGcFQANhU3HYZ11/PdSwR/N6fO61/V/awRVVLOsYVZs\nwTdFTqYnli4N1RPS9sQiNqDW7rvXr42NTUSdR/BDoul5LyouYxEA/wVwJQAmVpkY5hH2RRXYYF4A\nfwfAxCsTVJpA2HEfYUqizdisxCFwm7HmY6ZmRlzSTQrNOGgWU0qwxCazo8elmASq8aISds48UkMY\nPftsXfOTSyqn0TalwF7gQ23SjY97Vo30lIJKsTRMkEHuQAYaaTrXbsjMzzahTdFCU98KGiKfQ4oW\n3cYXvlA/puu5zRTldB7W+BLlMhejmkxuDLlEjiHk0u5RxEYaC2l6XOVtcHskZ1obYny5KHcaopbm\nv+LmachnMDYX3JVX8mVzgY6LLRALhQTntDehb3u++fqaltC42Nqcb36zfi0Xs5JTs5ZLC0rnIRdF\nOAW//GX8vbH7LafpeReASwB8B8DCAKagMj87HMCvAbw7rkkAwIMA1ur9/icqpmotADujzwxFIcW8\n5+CDU1qWgb4oTTJJeu+3v+2/rjH1yGlmpImqwoVepEgJxcw9q2aRoOpsGyeeyPcjxSnWZjg+8pFB\nczcbXCAPzXt0Ea257fu1ixZXniYR1YA+F5XoSetIYXp+/OP6cShcuhSaUO8pTI8GKURrSp/syHua\nerjQ9BTUjCXlWTXIKS22UUJTBcRH0TzuOF54FpJm28d0jdNInWn/7XxdoT5xuOKK+jE3Lu96F1+X\nb99z9Scn4W2De3ba5nXX+cvS5KpUs2wjZc5q5nCub67Ut0uheVbjh24ix5baCzSw+3DyyXUNaijP\noA2O6fk0gM8C2ArAIai0MUcB2BLATr3rsxU4W22NJFZD+FMJqabOY4/1173HHvL6cvoiaBa5ffbx\n12WroIFB289YyWAKA0f9RmxQUyyNKvnQQ/mytnmb0WiYUJBUK/G1r/nb4TSZtM2QaRkH6SafyvTY\nx1QypYFGEu57NhfTo5kDNJcT519Iv22uXkkiS4OQSUkuSAlelzllSp9izVw1duc0gpaNzTevBxig\nSPnGNEEzSkGjFUrJKaMRbNJ6bY089R3TRFscBSYz5D9mzwm6B9LUHqW+dU57pjGZsvfeLbbgy9Jn\nocmb7XUl13qSUleuqJghUH8fiXWEeX+jxvQAdSGFZgw5pmcSADsmkm0K9xSAg+TNzH5IIbJs5Iw2\nw0mbKN7xDv81TuKSArpIcB8dLctpWUJMph11JcVMkW6KnHRBQ/BS0whXWRr23BDFVLLMMbCcLXlo\nbk2d6icKNMSOzaSF2qTzkCMINKp7Co3/j8anRwPqT8jVpTE/0czvb3xD3gcKjfCD5uCK1RBst538\nPnqvhrik5r6cUy+HCy/kvxWNhpGOby5mioISjBw0jEAK06MpS4U373lPnnqb0oJy65jG74/WS03u\nSz0P58ersfS4/PL+b61lCj22rQJCwj4OubRjKabZKXN2773LtFMKOZLvAjzTswSAG1CZtgGVZudm\nAIvHNTW+keulhz4U3wcgIV40xFu3C7z1rdVvk1XegCaUyvXsoXrsZ9SE4+QWuW63HnBA0yd6jeY+\nmn9+vo82NMQDTYBpm7MZ+OZDrPlJ6N185CP+a3bIXoAnfigjk+K7wvVZI0XUEOw+pDI9FJq6Jk/2\nX0sxSdT0gQspT0EljjHmJ5/4BLDuunyfNAFlOGaEluU0vqF7OWjCt1JBiTZU/QoryNqh5lYc1lxT\nXjZFSq4RstC9LBa0f9RKoRRGgbkqBdqHKVPi7gtdp8e3396nfei1TTeV9QEIByQaBkqFmM8pnI8F\nFZbFzlmO6TkFlTmb4cfPBnAMgIRYMOMXuVSZ227LX/c5jKX6DFB0u/2wj3SzLSXhpWV//Wt5O6G6\nuHJ22VBUOBv0WahWhXtWDUNEcdhh9WPK9HS7fqK+VJ4ejnigi/+f/iRrp9sddFjloOk/zduTCzRs\nqYHk+9RIwjWBAKipCodRkGZLx+HVV/2hjSUhwilscx/Neq7JyUKRKzwxBZeUWALOlNuGZn2nfhcc\naH9tSX4IKaG8uTHWrBma96rRaNh485ur/r797XH32wgxOcNgemLb5ELaA+HxOuOMPs2TssaFwmoP\nAyl7fGy9TYEKg2PNAjmm53UA6PQ6D4AiQvrsA+6lU0Ym9FHGtFPCiVxaJ6dB0myK1AFV4yAcateH\nG26ol7XteWmEtZzIbStMMzj7mJ7YRS+UOZm7l77z00/3l+VMC0LgCNWUMKsUHEG48MLu8y5Nz7nn\n1o+55J4UdIG3ocl6nuL7kZKZnSMgNWYK1J/GzIEYzdrnPy9rk0KjFaJYYYUq/1huaLLDU7z6qnwe\nlCJ2aH+ptYHmXhuh/sbmGEoxQYoJjAJUa/xLLw0mxYyty6DTGRxDmmLBBvX1y4VSc2tYWolRYAy4\nPuSIWPmpT4XLatwsNKAWDbFpHTimxzd1CinQxi+omYXGLpSiFKfuqku6OPziF/nazQVuE7KdwK++\nuj5uGmfmYUlGXPdKM1A3ZQ5hgzoWc0yyTTBq+6oxb0uBJteEwSKLDG4qNK9NLlMbCk3kGpocjkMo\nozcHagpqQ6NloY7QpqxEs6bROnN1UVMy7XsskXMpJefGww/L2yn1zaUQYL57TaQpDlyAEA6cQ34I\noSSiHGbMyCPw/OIX+7+73cHv873vHcx9YpDy7BxKrd9UKMFF5dtzz/h2cln/pKDpNiV0SFMhz2PB\nPcKfAHyFnNsTgEKJPfuATi4j/Zh77rSgBjfdJCs3Y0aaBomCag84cDkI6Lj4zH9ywzaNW3nl+jVq\nZsExPaUYm9wMqtRcLlYK+ra3xdcbG8lIO0YpDvCl8da3hgnEXP21c+sAOqaHi+BHEQrDHguNpocm\nsbTN23J+u1xdnM9UTmieRxO4g9ar0VqUMntKyf/j6xPnu5mKlFQYGrjM0Er4adBgHJwQNOQ7F4tS\n6/eXv1w/LpXo2SeQaRKatT/lWzYa0lI+Q02CI3u/BWBFAI8C+DOA+3vHDbnwjTbMhJ8xQ864SMCF\noTzwwHztcItciumHRNqWG0svXT/mwi1rND0pJlM5CbJrr5Xbm+fy6dEQhZQwlUI7RhoJtQY5FnKX\n5qEpzZRUeBHTB585Xwp+8pP4ezWaHg6jIKWlSCGsNQTNRhvJy6aMywYb+K+V0PQ8/LDOv02DFD+i\nFMyapfu+pXCtTb51MBQaO1cfcoFGKS1FqIfm8KqrlmnXBpf0nCKHAKPEXAT6/uVNgHuEVwDsDmAC\ngI0BLA/gSwAU0exHG7/5jbws94Fedll6Xww40yBNRKoQnn/evxhobDJHgVjQJKTLSYhy90psX11Y\naKHBen/yk0Ethw9cOa6/VBpGCTBOOqzRHlBotES0/7nCxtN6NcEuDCZPBj760fo5SiyUkpprpH3a\n+d7pDAbwSIUkRLsPZgwvuCBsmsKZMo3CukVx1FHyshpND/XfkUbJCtUbAqedTslzw/WpVLqFpuCK\nyleCaHdpW5uW4tP3KNHUuXJ3heotBdoOXW8WWQSYd155fUstpe/D1lvXjzmz4hxrXu45MmFC9X+1\n1fLWy4Fjej4L4FgA7wbwGIBC7mzDgyY8IcV4V/P9/veDkZFyIEUqVMpe3K7Xdph94ok0e+sS5m3P\nPJMm8eW0IRrNFQ1DzSFWI9btDkaqC5W3ccIJce2GsP76/mvzzFOmzRRw84VmLtcSBE89Vf6ZSzEg\nXOJn6tA+ikwQByqk4N5rSvLDUTT/TQlkMOr4wQ/qx6WYkVFgeihoQnIXJJqGUuZsIWgiELqw3HJ5\n+uFDLiFhThj/SG3OtRRwU2gPAN9DlaR0joAmn8soRB5JAY0sFQuqAdCoW0uBboo77ugv+/Wvx7dT\nag6UipajMWvR5AyJTdbY7cpD5wLNSfA4zYm59trX6ust1X+Nz0mMhH2UNksuSTEF96xN+emUAl23\nuLmVEp546tT6sSbfGL03tg8UMXN4nXX4XGOjipkzy5gUuQSDTTM9vnD04wV0HlKB4+WXDyY25qDR\n2A8Lud7RSitV/808zBGhUAruc7oJwKEAftlQX4aONdbwX+Oc+XPi3nubaSeWUKWww8ACaR9FrkWX\nLuiLL+7Pj8RFdmlRFvfdpytfimlwOQ+HysZot0ZhU48J2ZvidM7h7W+vTAlfVhhMa6Spmn6nmGiO\nAkppVWi4ZY0pN2feliN8rgaLLz6aWtoQSjEjo8D0fOc7g30IIYYB1JiYSbDIItX/n/88b73jgenh\nBA4aQeDGG1f/zTxscu5xU2gfAP+DKinpbIG99uKvcxvqV0gcu1IvaU4mwnMRhU1p5UaBiB0W3vCG\n9Dq0gQlyjvdaa8XdN6ww5rmQS9iRA2YN/epXy9SvSR1QKkhGUxhFky9Oyt202dy2247G96fF7Mz0\nUIRyxQFxfczN7JbSSqQIXppimLjxj3k3dt61psA1dTKA93iuvQ/AqZ5rI4X3v7/6v/feeTIbt+CR\nsnCWZHpKLOi5N9EFFqj+n39+3no1kDiKApWpSIpPnMGwwufaUZ7o3OAyy2++eXybo0B0PfCA/p6S\nprzdbjnzORram8Mo5iLTgJPANmUWSsF92ykO+n/4g//aSSe5z7/0UrrPxTAg2bve+lZ9vXRO7LPP\noD/RKCLGtDG373IpAl2TOJpCk/g6BRwDudtu8nrMnB41Tc+BqDQ9twA4C1VQgx8DuBXAbr3rIw87\nxKnGHllab4t8yDXxXe9mPDA9JpLJMPHpT8vKXXgh8Mc/pren0TyU+uauuKJ+zEUvTDE/bdeMOsw3\nWWpcNOu9xldolGCIEG4MmzLNpjACRxdS3rnEtJSmMfjtb+PbGyZKhaxOiZ43TGhMYUuBvo83valM\nvRo0penhBChvfnP9+B3v8JctvfZz4Ib5SVQhqj8K4GeomJ1zAKzXO58xgHI5mKzinU6exX+xxdLr\naFEWP/pR/Xi8mLeNgk2vxiQo12IvxXhnGoYlcR9VGE3PeH+vw4TxVxiluWWIn6WXBvbf311m1qz0\n9/761/uvrbde/bhJ85mcKGWl8PTT4TJf/GL+dmcH0LmkeT9cPpphmxdKwK0zdFy4b25UmR6D5wBc\nDuBcAFcCSEjZODykJrMzMHbKmqgccxJSxniVVeLuCzlnjxfztlFY9DTR1JrGeJVOGpRc4EtlTS8J\nsylyG2luJ+Rh4S1vKVOvIaKaYnoWXhh497v5MiaAATffc5jwcrk96Fo6XpmeM87gc/cBg1otCTgT\nXoP3+Jwb5nDQuUQ1HBw487CUOdoU7cB905pvjpYdFfO22QqdTp6NYcEFq/9/+Ut6XcPABz5Qtv4U\nwm7llYEDDtDfJ7lnFBiKEEZB06MBfdeHH95sey40Zdscg/Gq0cgRtMKFOUnTs9NOZerde+/qf1MC\ngUUWqcI/c7CJnZLrLrde0naff75cP0riZz8Llyk1xuNhzxwGKDF/2mnye3MHAshxrwYcDZ3C9DSJ\nccX0xDjsGeTS9IyC30UKYrLNazCKC+WOOwJnnpm/3vHiIFkK9HuSBkEoiRVWaKadmHk+Xon7UqF+\n99yz+j9ex0WDUuuiCX7S7QJLLlmmDRuSvDHm+qGHlu2LZkw1ecdaVBjFvXwUQBloSVJVA05zPd41\nPTHmbb5jDttvLy/rgmSYlwXwTQAHoUpUOjRZauqkyLG5lt6g3/e+svWXxrPPxt97xBHAOefk68t4\nw3hjeqij8py0Sc5JTE8pLL74nKPpKfVtG9+VpszbXnghPPfNs778sv47WXxxeVlN3eNtbR0FtGPm\nBg2moJmHXKJ0Ws+WW8rrbQoan55S9EBqyHDJtD4HQBfAOgAmABiaojjF/CeXeVvpDTpGWv7JT8rL\nchNxv/30bVOkhH597rm45Ik+cE6Do4jxtsm8853D7sEgRpnxGiVncw24NW/llePr7XSA6dPzRAGc\nU2HWjGeeaSbX0PTpcqYnBhpNrUaSnGttbSrBqS+ZtguaNS+UqzC23qYwCj5+mrn00Y/WjznfS1qv\nhq5rinbQaHo4NMUgOdsWlHkBwOEApgDYCUBDBiSDSHmxRx4JnHdeeh+4l66RUvkQQxhdfbW87DLL\n+K/F2u5rMvG28IN++AstNJx+SDFMZ8TxBOPoeu21g9eWWKLZvuQGjaD1trflrT8mYIwmwuZRR+nr\nL43jjtPfc+SR+fvhwjPPhMPM00TepaDxj8hFFC67rLzs//wPf50L6S1NHQDo1t1ddpGXHUUhXA4a\nKxVU+M6N0/LL1481gljN+I+iT4/m++TKHntsuF8aSIZ1FoDFALwOwGsBZN7W5BiFj7BU5msT/ldS\nx8SJ9eNcC2RsHiPtB6exgZ2ToRnXYSTepXO11MKrMfkcBdtmCk46nEv7U/K5uUhPtN3NNpPXW6rP\nKRLHUtA8a6myuZ71kkv463YUTq0vTS5Cj17LFSRGM96hNj/8Yf99lFgeBjQ+GhrERmkFdO+xlP/y\nIovUj7k5oQmd3unUn28UhYjD8OlJNWejkEzjQwBshipB6f0AFHqFvCgV3WqppeRluSg5KUyPJhoc\njbGvGReuj3/6U/14ueVkdWozCTdlwz+KiwaHFM1JE07MIbRRhNwYBWFNCjSaZA3mJKanFDRjmJt4\n8MHej04/XX7fAQeUY/imT5eX5bDPPnnqAfz9d9EYRx/tr6fUfkq/jVztpNBxmu+1VMTE9763fszN\nQ0pbcmXHxurvvtS3kAKNT48GTYa3lnRzDQAnAbgYwFsB7JvWZDxKbVCaQeSktimLgiRnhUHKJNBw\n6htuKK9Xg/HuuDwKmipq26yZA9tsk7cvBqW+T818GUVNTxOE9TXXlG/DBToOo/Cucq2HOTEKjHtT\nIfFNWgcJ7BwznU45Qi+XCTYlYg85JL4uzdzjxlQTjltj+llqzqbMQ01C7E02kZeVhAY3oCZqucy4\nUjRrOd+V/a1QKwtuzqbsiZoxTF2zJcP6CQANyYh4lCIeNPVyPjE5NlAJ05PiBMYlMqOL0Uc+Iq9X\ng/HO9ORIrOcCHX/uvZpQtTHIlXSuKfO2Uot/KMliLmy+eZl6P/vZMvWaUNIGGj/GUt/2wguXqbep\n/DZ0Xd9oozz1jqKmR9OnLbao35eL6dH49Hz1q/XjRReV94HCFoqG1q1cAoJ//lNej8anpJTPZimN\nAIVGaKvxrdT4RZXyc6HISRtzdWk0Pbny9OSm+yXVvQnAowBuBnAjgBvydkGOUWB6ND49mg/J3BvK\nvgykjQMn5U/56DSb+CialHDMrI3VViuX4DVlgdSAc6BNQan3qjE/1aAp5luTMZ3663Ewme9zQ8N8\nl+oDBTW95aD5Nt71Ln1fYkDn2kor5ak3p49JLsRq2sbGhuPPpAm+ETL51pjR5Vp/1lwzTz0UuSXs\nBvRdaCLijYK/GxUeaNrhhJUp9WrKhjRgdl2aOZBCP5aidVyQvOpPAlgdwDYAPgNAEUwxL8Yb06NR\nxWpAJ0FKbhyuXg002oMJE+LbKQUp06aVRpZCirYvV9jVpqK3lWJ6mgKXVJmuGRrzk1JELH2PnL9h\nyjvX3KsJj65Zz5vKi6bRipZixjWanne8o36s0SrGzolOJ58/lmZtmjKlfvyWt8S1qYXmPf/5z/5r\npQQPH/pQ/Vjq4xsCXbc23lh+ryYIwigED6Hggis0Zd6mCftN682Vp6cUgySBZFh3In9MeqWyaGqT\n56BhemjkjlygkytXfoYUQlqzKaZErNKE1eb6/4lP1I+pcyJXZ1NmXFw7o5AYlM73UfC5a2ocNBuH\nxoeKfhscQTMKPjEp0uBRkNqmQKMlontBLqZHMy4aDS/da3fe2V92663rx5rxt581tLbSENC5pMP0\nWTWmwxwRS/tA54tGav6b3/jLlprvNDx3jpQfwOB477GH/N5SIatTGIxc4/+5z/Ht5EKKzyP3rCGm\nzX6+lPX8gx+U3+usT1DmvwD+A+BxAEsAeAdfvBxKJffTvICmbMA5jILvBIVmMaLvkTP1oBJeKXMS\nwtpr14+lhIZ27FNU91xbHBEyu2EUmB5qAqPdJH0Cm1B/NY6vudCUA21TmzrVWsT2gQp2fvhDAY4B\n1AAAIABJREFU+b3UJynXs2vq2WEHedn7768fc3PC5KGK6RNlejhst118OxyoBkzDdHIBEmj/Jk2K\nb4dDyjqw2mrysrlCQH/84/VjjQZpFGgf2geNDxj3zqk7RKn1PeRj+txz/mvf+pb/Gh2XtdaqH9uC\nwhTBjsanygXJsJ4M4BRUEdx2ATC09FCjwPlqQlY3JXXm2vnxj+X1NCUhpUwP51BOxzSXil2jtqX3\nad7riivG90lTttRc00g9NX2gmrZc9Zbyi0q1b5cKSzR23ZrvVRMIgNar+T5HAbk3SYMUQYNmXuYa\n04MPrh+nrO9cfykzpfmu7OS2Y2M6J2quHRrtjKs3VgAW6gMFZRpytZPyXrfcMv7eWGjW/qYwCsKb\nlD1doxDQWOXQ5NOrruovS69x5rSl/LgkkHwuywNYrvc3EcAQ0iBWGAXzGc7cZBSjWXH+BKF6uf5T\nYj5FZcot/muska8dGyuvLC9r44EH8jkuUmgWPY1mjc5Zzb1ctB86Zh/7mLxeTVhbDXFQigiPZZJD\noP2dbz6+Xek1ivXXrx9zkRnpRseB5ujSjL8vOWMqqPSdjikHTVLIlGho3LvTzC2N43yp/CiawBcU\n9loUEihpfB40mlkukAGdS1z/Qn6to0APpCBX/zX91Zg0piBFAKZJYaExadSg1L5H8/9x+zbnCwfU\nn0/zLQ8jepvR9JwCYH/M4Xl6qPTMBt2sQpMgFi++WD/OFTudMgJcNm2NTwOFZlPfkXiQ5Vr01l1X\nXvY73+n//u9/dX3QRAbSMD1vV4geKNGnuZeartigc0uTC0NjKpHyzrnAAKXMZTVI2ay4caG+b9Tv\ngmNmaXQfbpzod6RhMEplTD/zTHk7dAw//3l5WTtqVmg9jBXWcKZ5AB+uOKfPXRMmppTpoY70NMJm\nLj8vDfPKmTKlaBRD95bS9GiEiprx5vYCjXCVWnakPOvxx/uvjYIJNX22UmH6NdhWEbYs1idcI5gP\nYbPNwmUkU+g4AB/u/W0EQCGjzYtRCHWsIey++EV5WQ3x89hj8fdyoMRwKRWkJtIbJapyPavGXCkl\nwMNPfiIvyzEYFLQPX/qS/N5cZhUp6vimynJaCzoONF8HV29TZl2xEjBKLG+wQf1YI7HmHPYp0bTI\nIv6yFKWIB00ukhTtvF2WSkS5sqF27D5RH8b9968fc3OAPltTIau5VA2cpHjKlPq4LLRQ/TrVWOea\nP1RAkGt9DJkR2e2kRHpNyTcmTdUQgsZnLbSf2t9STuuZnXbyXxsFpodCk76gFIOUYoYuHaecdP3X\nviZoj7n2SQCHAzgBwGG930cCSMhBzPbjZFQ5gK4G4AxQOgpMjwZNRZvLZR9O6+E2qJQPf++968ea\nPj7yiLysJuhErlCMFJzqm9qS06ANmo1DY5bDgTIJXB/ou9CMC9U8cEiZaxqmR+OUnML02ONG66UM\nB8dEpBAWGmaWRhXi2hkFDMPPaMYMXXl7jL/3vfo1e9+g74JqPzR7DI0gl8u8kPaR03px3+PJJ9fr\nCu1HuQhVKmnONX8mTOCv2+2E3iPXfxoYQINcY0iJY85XKGU/TUEp/04OpTT5FFRb2VT+NBshzb3v\neZ5+mn/WT31K3gfJmHFb1p0A7gHwSu//PQD+iipXT25sBmBeAGsBOADAsa5C3MKw114FeuWAxpSs\nFEFACcZSjnRc0rMUKb9GgkHB+chcd139mCNENERsyrNyeP55/nopLQsHar7J1XvxxfF9KLUoU3OI\nfRljXPrONZrNlM2Mm8PUV+6UU/xluTlAI/CUypY9J8Mep5dflpd1Hduw303oPo2mhxJGGs0yh5wE\nI/fsKe1y48QFGEihK0LvTsP02GW32qp+TZPGIYRcPicc45sitC0VBKEpTU8pnx5NO6UQ2/9XXuH3\nXo3JtITm5oo8DOAnAFYE8NPe7zNRhbDOjbUBXNr7fTMAZyBFblDpQsBBkwBQ04emAhnQfAsaRkxj\nxsX5o2iejZr5pSwwthqXfijUPI/T9NB6OU2JRjKlIZzvuqt+TH0phrFwUYKce1aqHUth8rlx04wD\nVfNz9VJiQbNRp0BTl0bbao9TaC3K9TyjqOmhoM+asv77EAooQE21OGjCOOdK5hmCJgolh9C3TDU9\nXDLKJqTzG24YX69GsKYJBkGv5Xo3TSE0D7lxovu0JoUFN6a56nGBanJLICWoSi5o9pjtt68f5xLC\npTI9BgcDeALAcwBmALhQ3gUxXt+r32AmHH3TRMLikJLgigtOkML00Hs5XxCuXmrP3lSyQO7elPdG\npXC2Nidk7qBhejitVimmh0JjW64RANAAFRw0zxqyude0o4nmlgv0W9GYiXz723n74gP37XCmQqH3\nGJtAkqIUM6WBNlFvbMLXlGejc82ui/vuQ2saJZY165gGGmmrBjSXx9139393OoPRu2zYY7Prrnw7\ntllganJDXx8014D6ew4RrbECsJCTeC7GMYUw5cyiQsKC/faT94G7Xmp+U5QSZK6zTpl6OWjM8en1\nXFpmilxMz6YAlgRwFoAVUJm45cZzqAdIGANA5MiT8Ja3TAIwCcDkgQrogGs4dy4ii4Zg32cfvk8c\naDs0G7K0Xip9T4ke1lTZ2IUgRNhp7ex90BB2mrxIKdCM/9JLy8tqzKA02tXDDpOXpchlThAKxcyZ\nmNA+0BDQsQhJg7mgH9zaRJ+Fe69cxDJXn0YBtlaO5omhTuGlQp5z/idcWXr8yU/Wr3360/77zjqr\nfkznh+1LkdPyIGUOcD5K1AnfZnpc5W3YczikkXnf+/q/V1iBL5vyrPYak9O8TYP/+7/+71DizFz7\nOPXT5UDXIk5QGEqoa/vMNqV1HkXt9jD6FAonbs9v6r/M4Re/4OulqPxeJwOYhFNPnYSKR/BDMlSP\nofLreT2A+wAEgmhG4XoAxlpzTQB3DRaZhGOOmYTqgSYGK+QkHHQQ7QUxBauvzrez0kr+e1Pscu3J\nRZke2icOpTKxN0U00T5dfrm8rKZe7l5JyMQcoH3417/81w4/PL5eanJnQ0NUbbSRvA8UKap7+3ug\n0iXq/5PLVEWD0DfH9Yma49khWUPRlHJ9vzk3W/s9H3QQX/ZnP+v/pmseHZcm1h8tQ8ExTHb0KnqN\npiug+4bNRIS+z1zjojFZC2GLLeT3cWP4hS/Uj+25FeqvPZ+079XWWIe+DXs92nzz+jXa7pQp8j7Z\nAVlS/GcpuHZpYspclhOa9VEzX7gIgwAf1S5XgvSSsOe7huHQQLOnvOY18m+JBlwJ3VetgRMBTMLu\nu09CDqbnEQBfBPACgCMAlFBMXYiKsboeVRADJnisG3Rg9tyzfswxFaUW/2GYemgillGk9DeXmj8E\njaPrak7PMNm9vjZD97qumdClIWmkxv+KA+1DSNrH3fvNb/rLanwjaL2cJtOWdAN89DANNH5cJWH3\nQ8M00NDRdPO1tbo0AAK3QaV8nznN22ytRYgoiR3DmPKuNjXXUsrTXGn0PioQ4NYYei/VMNnYbLO6\nrwiXO0hjmprCyGjq4voUys9VKqS/jQkT6hpJauJVai/mkGL2T8HlwStFF2nmC6UPKWztExUgNRX6\nPQW24GSPPcq0EVr7Y99zylqay7zt6wCu6P1/FEAg+nwUugC+hCqgwdoA7k2tkEqon322/1szqC+9\nFN+HpkIz2vU2pVU5JGPg8mHkjSml6eHup/eFzK1ifXpS5hnHKFJo8lBRcL5nVNJDGaTPKOJHcs79\nIZxxRv83NVvk6tIQD3QD5eoN+UzZZoyh0OMa4YEGVJutMa20/aRKmdoCVbSgHHXlMm/j7r2X7ISh\ndjQOwZzlQafjn4u0npDkW6Opteuea6486xw1Z3v8cb68TfBq3mu3y79X+5g6cg9DQEpx/PG6sP2c\nC8GTT8rryaWB1PiUbropb+ZoP9vb386nntBgGNHbmmIyc9Jb9pqRIqB2lhHU82sAD6Hyu/khgL/L\nu5AXmgg4uUCze2tQarJxuTtSpFgaCSi1xdaY4XAI5Y6w+5+TqSzJTPmYHnqscabMGTTDRijWvo0U\nDRjXBy6JHFBP0EidKSnsuafdTLfZpv+bM9egCIUit5FzztoMK8fk0Os51ymaU8FuN6RxtImQFCl/\nCKHw0jEopelJEbiE5ntoL8gVCjkUZIC2a7Dbbnna10SkBIBjjpHXbSfnDX1z9jEX2MJ1LL225Zbx\nzHiIOaV1bbqpvyxHh+RicmhdnDm7q90DD/SXtZ9tbCwtVHau9dWuhwZvaaL9UL251uxOp26qre3/\nn/7EX5eQuU8B2AvARgA2BPAxXRfygXPc1bwAagJG7WltaEyDmjJv41T3pZJhUdMazbNRcwgOnNlT\nqN1haXrssKoc00NBpfwaqbi0jVFBqH/2vA1J7GwfvAkT+LKcCV7KHOC+M5ojh0OKT48GsZoGgH9W\nTqJL6w4Rk8MwhxgWpOM/NgZ89KP52wxhbMy/32rHzzZbdN3rk+pqBDBcn6gQZaml+Lo02e05bYdG\nu5pqTWDwWWKHoyFEtW1K/TS/8Q15nR/4QHzgEduky4XYMR6VwAW20J8LcAPEv1dtolvbdz5Eb0np\nsU5Hp+CwBfCdTtjsXsr0vA/ANqgSk24r7045UAKROtJxoExPCrHJgXvJ11wTXy/3EWo+BgpNxDuK\nFF8iW3OlIQJDWqEUpsfuU05p2bbW15OSryAFXLshJsJGro0aaEYdr3W45jYOrq5tFSskfRfc/Dnx\nRHm9FCEpdCxC+WlyEa457+PKc/uIZn5QYVnseC+1VN20ppQ2myKX38KRRwI779w/dpkJ2UEH6Jhy\nfZauGTRQUYjpoX2QpiGg/eXmy/vfXz/WmLmG+mBDmwQ6l1AxZHHiq2exxXizyxRo1kDbn23BBeO/\nu5x7uN2H3Xfny9qaqlDf7TQsnHkjxdgYcMMNsnb23VeeT1Izz97whrrGTmJKK1mKdwJwOIDzARyE\nKqjB0EFtYjUmVJoXW2qT0agnqZkBR4DZ6nYX7LJvfWudo9bkL6B9mDZNfi+FLVnTEAc01G6K5J5C\nY1Nqm1iFND32ex8W08NpCks5aeZkkGLrob422vkS0kL62nHVZUDHm1sXQsSatE0gn08PDQ9NYa/T\nOaXOGiaZ+47ovvGRj9SPpXsF7cP559ePqY+VdPyXWy5eapuSC4MS8LFr0bzz1uuhIbeBPuO8227x\nz6opqzX7k9ZNfXo4k9J1162/Hy7/H0XIb8tuJxTy2UYoxYNmjG2mh/Y3RPyGaJjYPmnuta03UtJQ\ndLvARRfVjw3sSIUSaJ7VXrdCdMbBB8e10enI6aS3vEVet6YPe+9df75QOHpAxvTsCeAkAN8FsDUq\nv55xDQ2DlAL68o491n+NAw2DnItgPPhg4NZb89QVIn44aAgwbiPWENY5ifDTT+evm7rphhQy99FE\nn0sxU8iFYbXLwe4TF4kudG8uIpAKFkoRdty988+f51mA8CajSdbblKbHRqkkeTbR5IKGAIh9Ptsn\nzdUmJ40fG9O9O8osGtC5RX1BgX7AkG5XtxdI5y1lRjTodPJF+6PHNEqljVyaHo2fzrnn6saJGxca\n9ltqCtftjkZeLRsLL5y2Rvp8TLShr1MEDxw0YeIpNGMqpcc6nbAg2b5mB6aRrJeSz/kzqPx4ngFw\nHKo8OnMMUjZUuih84AN56s1FsHc6dS2L5qOioVS5xTXkBG47poc2GJrB20ZoXDQJMjVRv0ImBEaC\nRvtDiRKKr3zFf20UEkamEOzD6L823w/H9GjMtmxQf4EUk9KUMcxl3qYZB415YcoGGmo3l1Ygl6Ah\ntKmXYgYfesh/bemlB8Oec/WefbasTxwBNmtWve7VVuOfQTr/O53BshtvLLv3ssvk7YQCu9Aw7CXe\na8o85KIauurm2qJMj0ZbJgX1FdauGcMQ0sVGb9t//3yMMAfNvpAzryPV3NvCwdAaQHOXhSDpdgeA\nLRMKfBrNoNQmQ9GE1CFUV66PlTodp+RX0PQhFAaZZrHmTEpyEcuaBTKVADMEgZaAyTmfciCUxDdl\nMx5GAkkt02YTBbYAI9SODfqcdOOgRGEpDZ5mwyqV3I6iKSKkRDvauRWr6ckphLMDFdBIVksuWYXq\nNciZgNSHkHmYq7wErr7Z4eg5PPxwvH8K7X8praKvfQPOKbyUoIGat5XQbEpMmXIgZW5LA/S8+911\n33K6v2yyCfBVK3slDSyVgtj1JfSuYn3lteOtztMmKHMugD8CeCeA3wO4iC/eDHJuXKUILm4jHJaU\n3A6VucQSun7YJmylCJT55uMTh3EBE0pJcnLVozWzaEKyownFaSe/1LYTQuyzrrwyf93uYwrh1unU\nQ1HHSqBDRCwniEhZM7jrobL0vZdCKY0GhSY0PNdOE0xaroTFQL2/P/95fS+g/gWltAkcqHlbCIcf\n3v+tJdilDEhO4WqulBs5mRN6X653a7/HsTHde5XmitP2Nfb77XTiXSKkbfzhD/W1f5116tfHxoBv\nfat/rJlLKQGfUvClL8nLxq43MXNWMhVPALArgH0B7A9AEcW+HEZFKmjbPWvMKEoRjCGCi8vxE+qT\nbYNaavx32YW/3hTTo3GULiHFon0oBY3dfkgzOAxCKZaABfJKtWLrTUGsqUS3qwvF3xRihUJaSV/I\nYduHnPNb6rsyNhafYJerd775wu1q4KtLaymhWcOlSYDnmit+DHOGK9bU1VQSSw007ybWd3FsbDCx\nfC6kMD00FLgUsVFJaQCKpZaKF3pxqV5o2ZzrLl3jSmnYSzA9ywE4AsAhAL4FIBANvRnklMCkoAkT\nJNfHetBB/WObEeAmYogp455l+eX5e3MhRMTaz5ozL1IT9za5WWki4EhBfbOGpa20ETJxsNul5gUa\n9XunM/x8DTnnzz779H+Pgn8Y0Nz38dhj+escRS1zKZ+vUu9p1qx8QQNspHy3nY5uHFPCLe+xR/y9\nBinaD61wTzPm0negiWIHpAknNfu2JqqpbZpmW8doBBj0GiesTkWKBVIJ2sf1ns48M0/dgIzp+RmA\n0wCsBeCnAH6ia6IMOh0+I3DOdqTQOupyIWhD7U6a1P8dmyNHIyXX+P+kgnv2lLwfsR9eTgJGU9eG\nG+rqtiHNpj4sqWFsIAAKGrqewvZDohvvBhvo2pJu3CEti7RsqF5t9B+7HjuowygyPSHppP0uQmGl\nU57vz3/u/+Ycp0sRm/RaLm2BC3buuNDzHH10/Vij6WlaI5wqZfbtry4Tub32im/HHisuGir3LMss\nM3id8z+k9aasRzYoM2LPWzonbGGUEa66mIwDDpD3bZiw+25HIQPqzz5rVl9bmdOMFXDnw5KgFD2Q\nkgqj0+HN+eiaGLJikCyhLwL4LYCnAVwiKN8Y7BDQHHI6fVHYm7NW67P66u5rtL+uiWifkzpa0npC\n0XFs0MhXuT4O21nW1MvVzSXlGpa0NddGQdFEuF8tYu3SO53BzMk2JkyIr5dDymKrGX8pnnkmX13S\nvEEUTTI59vvRCIW22sr/7lZbrc40h6In2u2uvz5flsLWcNPoWyFwASCk3+sWW9T7TxmvnLD7FMqt\nYidv5ODyGfzQh/zlt9rK36dYdDpyIZDrXkq4GrgSgedah2mURymoILXT4fPvUcHns8/6y8bur6+8\nImd0zW87oquBa07a94aieKVoeqTQ7DclTOgNYrWGpTQ9msipKQIkIPwOJEzPfQD+B5WZ2+cAvADg\n/b2/oaHbDUsDfchpahOrduTU5ksuqXvxmugyXB+4cZh77vrGkSuJ5RVXDPaJAyehDi1qJQIDaJLM\nNsWYaNrROmjaRIl2geTa2ndfXT+aQAlzthtvrB+XYpg1dc0/fxkGj2szdH1szL/GnHhi/CZaKuJT\np1Mfw05Hzshz40IDdey8s7xP2vVOSoSFhHA2XAJHru5QhMgYLLOMTitKx0HKgLh8kjSJ0Ln39ZnP\n9H/bpqkU2jVCwwzGMg3f/76+X66xoOf+v71zD7drOvf/d292JJGEqoM0LkFIItEIISmJpKREIghF\nSBF3qdNS2hKK0NLSluJI0epp3doqPb/SVl2TihJ1O6eC1rXqaV2qmoYfdes+f8w1zpprrHF5x21e\n1n4/z7OftfZcc44x5phjjjHe8b7jffv1a9ecmAgReqjvks0MKz+mmMobMic9/3z/BVOqK3f5Ohu2\n+7F5Q9Xl5aPFpQzrawCYAGAhgF0AvI4sYKnBx1Z6QnyEl2XSI69oUBu2rA2RhT3fjbkyphXTffdt\nXeWPVYfySlNIurGulSdbqczbUrZDatp5D0gx03Wl7P0yQLzVNtt5RXjls01m8mkNGBDmEMJEfmB3\n9Z6nu99NNwV23dV+XtHsvHPr/6ZyTZ3ql0fMvsj0PPLv4777tvaJoZrCoUPN5VLxu9+Z0zTVS0gw\n8g8+oNe5ahJ77bX0vEz1mtfqmoRp1TuUQqPhwvvvp0n78svjp6nCZa4m9wFAc4HmzTdbn53JW+FG\nATvnXU3H889G9uJIvY6CqQ4HDmxfmMhvXzHllcJl9XwAJwI4Nfd3eOOvNEJe5irYsNtW0vK/y/a9\n8uqfbYVDBEAM6Xhc9peosAUoFTz1FH2V0Wa76fvcN9ooziptWbi4xnY1+/AV2lIJAi6EPqsUzzpV\n+3Ed+FLVv2+ME8A8mPmakaTCZUHjox8Fxo+nnVtk/5Kvp3zdn3FG6x4B1306Mpdeqs9fJ/iW1c/a\nTLPyhNYLNW2XuYNrH/0Ng29e33txidMjoGh65HlRbBMxQf/+YX1IftGa2r5d782XceNaF7xM+eSd\nZ4lzY2p7xO8izauvtpeJ8rsM1ZHBowB+1fi71S2LNLhUuC0goC0fKjEjjrtgm1gccID+t5COzAWq\nNzE5KrdMvo7zEwfAvlLs0nFRV5Jd6y9V5yW3rRSre6r6o65Y21bLqig8+uLrYMBGzDoKScvl3c9v\nAreZXBShkT/jjPhpAup3TtfefUwyfDC9bytXmscj054d6l5aHTqBPC/0yPun1l/fnGaKyZdrOqrr\nZK+nMfI1oaoHl7rRPRtVm6WOi/K1dRsHurv1+7pkXJ7hv/6VZkHGpQ5/8AP6AplK6EkJdftKCqFn\nJIDNAIxv/JW6l0fgMnA88UT7tbEIiaFAHRR7e81BJPPmbUV1GjHNLPIIrVSMtGIRS+gJKd9uu6VJ\nu0jtRyphoCh09ypvzM47bLBh2pj+ta/R03ElZAHG5fy80GPaUK1KN8X7rHKJGyNopIsJTEifEWty\n/8ADrf/LgqypHx42rF2AjT0eyM+EGkw0BnmtlsrxxW23qa9T1XesPWS+8V6AOMGFVQsdpnLkTQpd\n3o2icF14cBm7qIsfqYSeVHGoVGb/1Dr8yEfC+seYLvQpt/xbAIm2f4bh29Gec07r/yENL2Tjl8uK\nkslldH7ilLJzSaWp0uWhIiQuEvVaeeOladO06wSGer68WdWkrdPlFZuQCVhXV1NdXVd09xuyZ+Cs\ns/S/+XpwAtIufvgKPa5mCuusQ8vDxalBUcRcDEnxLGUHLD09mVc8Fap+c8gQ/7xjas4puJp65vfP\nuHh+dTErdsV3wtjVBRx+uN+18m++/b9K6LGZy6vuVxUDSQ6AKQf1tJUrNi5p5q1aytJwhY7pVAYP\njqNhPeyw9jKkEHr+gUzweanx9xe3LNLh21BctAm2PPIDs+tGXZcy6K6dMAFYvDhNvjL5TW62id6c\nOa3/6yR11UvnOyiGmLflf9t779bfTGY5r7yi/y0El4H6M5JLkaLM21zbVarN8rHwfU/22KP9mMkE\nKF+Ppgl7zJg+sc5duNAtOnl+QcYmxMnl0HnGlOvFJvSUtV/Mpz2pNr6HCNU6ZNORrq5WT2Mmc6RH\nH23f8xhb0xNzMhganLQoJysmE3Bfz3o9PfHKH8uaYO216QsaeQ46qP1YftHZVRuVCmp/4xKMt8j7\nmDePdl6+TL6OWXTpAep9mzG8BlOqfFcA6wAY2viLoCyNQ1kmPaa0vvc9/bny4Gwyb5P/15X5kkta\nJ8gpV9H226/5XfYoJyObkRRlBuaL7wTTFhtA5uab3c4XpHquIaZNtmup7bIoUpnybbZZWLo67rsv\nTbpyW99lF7frL7qIfm4+eKwtYN7f/+5WDoFN6DHFywH0Jkgu+zFcVsJN56l+M3k7K4PHH7fvsTEh\n36MwXQvRlHR16ePehUJ9rqHC9eTJ6uNTp7oJPfn2IoJfUkml/ciXf8017e8GtS5t737RXkEpDhhs\nx23oNLKmdG+/nZ6+ySV6nnyfR2k3VKWA+OzubnduEON5UpJ4CoDFT1bxxJzoxRpUenvNrgZDzNtU\n9/vWW5mdvK1DLEOFKjtXSKF5AIAZM5rfbYILVdOTiq4u4I03/K6VA+HlV2q7utonrtR6DL1vUz55\ne/gqCD1Au+dDF3T3sM8+/mmaWLrUfs5NN6mPu9S3S9DNsWPdVmldykFdKFGtZpuw7WlYuJCWjwl5\nYhdzkcL33UnVp734YvuxkEWtI4/MPvPjnOvkF1AHC1Wx3Xb0NEM04a7oFhK3397NC6Jt75wO0+Kq\njxmRQDVRTdU25TJWIRSCaU+P6LuodXvHHc1YQC4mpro5rs8zFRrhvAZa3jKSihjaPEqT2AnA8wBe\nRoXM24YNi6fpyVdkEUH6BC5eTFTnipV0qjOFEDvsUHTPylXNLd9f3mQqllceF1JNYOTzZNMH2RQl\nH2OpKAEjZj6+QX5docY/cNn8q6qHGG2Non3UmQyGtkvdqrPvhComsc3bihbITc/VplVINQk3pRtq\n1uqTt89CHfV+Vc4JXNAJZKF7ekwCR940NGV7dRHWqfU9ezbN050tf9u5roJZKq2WjE5g3WUX+3xT\nHvenT29qplescC+fDcozFZrzPfds3q88rtq0UYCbubvIx2WBTgdF6BkBoAeZtqcy5m1DhqQxb+vq\nAj7/eb90AbeBhnru7ru7DUp1QmVbnqpT13kAcg3QWQeKmMjZ8sjb39rOzWvsUuLrjjYPnoQvAAAg\nAElEQVRlGVKsRrqk2dvbXiaV/Tzgbi5TBLZ4Xb7IXvkAYMcd1ee6CCemVXtVOscdpz/fF5d+liL0\nxJps+mh4BIcc4n6NDVmDB7THUBGk1F6ECmrUfHTIeylOPZX+zFUx+mzX1nVOo3KzrLuXsWPbzbdk\nTMK/SwBTW30LJxGUehdpmcb3yy5rv05OWxcTytS/nHKKvXw2KEPjWADLAKwA8HkAe4ZnG87AgWmE\nntGjW2M5xFppcvG+JQ9IH/4wXehJNUi6EtJp6e71kUfa40fkJ3e2PHUrwpMnF9PJuu6doJLfa+UD\n1RbetY7yEbNt71EVzN9ilaG3Vz85VkGNAaEq34gR+vNTaHZTbKoXUOtfnoDZ6k9eHVR5gVJx5ZXt\nx3R9SMrFmrw3sZjIHtx0uLz3c+faz4lp+pe/zrbP1JcDD2z9X5fPaquF7e9zGeNTYGrDq6/e+tvU\nqfqV+j1LmiGqyl60eZvKWUveg2Ue1XslCzI+z9pnLiPyofTvlEUP1UKUXC45L0q/oNoXn8K87RIA\nRwD4K4AfAjjbLYs07LprGqFn883TTBZUKwAmN9QuyA1MHuRTDDI2fIUIU8c7frz5RTHlOWlSGm2Z\nS/3tsUea+g6diN57r991tnsJ2eycAtWqbZ78Rvv8vYkguC7PzsUMLKRNyHF+8jFEfDwkVQldvahW\n2k0aKDkdsXfo2GOzzxjaeRfth4tZc0jbsOUju/sNQVyv04JQrlXt6Smbri7ghBNo5w4b5rb67lIG\nWejJOwiJhSkwuGpc1p0rx7RR9bu6a0WbNLVd04JSzPeHAsVKxMWRgexZ2BQk2CW/mGZ/JgH83HP1\n14m9e7Z8Us9XqXLw043PPwNYFZ5tOK4ra/nG6SL92/LIb4pUmYmYoDo9sN2r7N7Y14kA0DQRcPFc\npIJqwytQrTq6DiCmPGyuDk2dZaw4IL420T64tHEXoUlul7agqYIXXqCnmxJTnecnziHliREMUAVl\nYp0fJKlBUkPNlarAiSf6XyvaxCc/ST9XRtV/+Ag9tnRjUYRmm2oKqPrNVTPsW09y3A9bPoC+7lxi\n9lHzArJ9HyFjOpW773abiOoWVVzalrynhRJOxOXeYwa1VKEyt5I1ybr6UC0QyGW68EK/crniUxem\ncUP126RJrWNjjPr30bBTpkavAzgOwJoADgKw0rlkFSDvltRFkrS9wHvt1Xquzl7bpfN0OVdFyIAm\n1PNnB+rzXMsgBLf8vev2FeShanpsdv8m7d7++9vLQYHycsaI4G3qCL74xdb/Q80QTz2VptFx8T7k\niuv+FV+o19rMbKgLAinrzEYZQk/ReYp6X2ut7PMLX/BPy6XPlp+r6jyTR1GV1UBKXOz881A2M+vS\nsbUFlUBV9j6QVI6Cjj++1Wwu1Xti0vSo9lDr9sjKz8GkmZE11SLey+zZwMc/rr7GtBgqC2Lz5+vP\nTYUcs0bVj194Ic1rsFhw9dHU5C1+3nnHfK4L8sKnSzq+WhwxxsvnuJiR/19ahHOOALApgNcATABw\npPn04qjCipmMTivg2iHLk3mX8st5xQgcpWLnnenn+ry0rs/MZC64aJE9vbxHtDypND0q5EEgVroC\nig/+2bPD84pVZxSEmRKFVBMj6r4cFTECroVy6qnZp0tdpiakzxNQPASJ/jHvAVGHTgPe3U1fMBNC\nlgqKBuOoo/TX+5LC9Nc1r/w4V/ReDDmYNoWi6qV//3Z37ikwLZbtsov/HMqkcRZ1KLuN33nnTPOk\n4oor1McHDWofu0z7XWNpGmyIvtUn71gamL/+NX4+Pun5LqDoGDMmjabnswBOATATwMkAAtbDysO3\nkbkOvKmEK5fyU73NANkKjsq7CgVTwCvXVWqVoEO5Z50ZmmyH3a+fXqgJIUTVHquthNrwCkSdUSdA\npvP+4z/Cy5OCFA42gGbsBAqyOarObWlqV8F5Tj89+xTmPkU/r1DPW0cc4X+ty70Kra8sHLq826b+\nmFIWqkOUomKh6I7FwGU/RAg33qg+nr+vsjwXxjLlo6Dbi+izaJlH15eJ4y6uiFVWIUD2XsnHdI4l\nitQKUjSeuoVeSr0vWJB9CjP10PeTau7uOlczXe+bhg8moedIAPcjE3Lub/w9AKAg57J2qA23CrEl\nXAh9+K4aMBfPcnlMq3EUE55DD6Vdu/fe+nx0nZpq9dz3PmNBWUmOgW+H7qpxkAeuPPKkMOUgE7Ig\noMM1CJrLOyu3g5dfpl9rw3cgkgfdooWe0JV9lwUNl30LunPyngmB1ujhtvSuvtqejwlTf5intxdY\ne231bzrTJJmJE2ne4yh1N3x49ik/axETSrUnlvq+hrZXXfvLpyvOSeXB0NYuL7ig+X+K/nSPPfRj\ngM/eCYFqT1Iq5HrRmRoXGZIgJb29wOLF2XfhhZWygCwvtOV/d3GeEGLeFipI+2Iaaq5FtofnBgBz\nG9/3B+CpF4hPEeZtLtftsUe6fTouhJjSxbpONm9SmTuNHt2eVr5zpZRLrFDbytbbq+/QKZqSGLEZ\n5JUoVw0NZWAW+aQyD7F1WiqXnbpzXRg3jlYmE75lEINJ7PdVuMLVmR7ENgVwwcfk7uKL/fNbb700\n9xL7mbn07zpM5m2f+ET2KbQ51JVrHTrzPmrcl+XL3bwAmupblEXum/J7NOTyxqhvE7b2oeqvY3ld\nrRozZpjH3pA6tzkoSDWXi7VQ5QJFwKPm7bOXW6QtWxRQy5NyPDXtTZOFNioxzdveAfBHAEcDeKHx\n/U+N47Uj9cQI0K+q+eBbjmnT3K9JIXzJXk1Udq0xMK1MxeSOO9THKW4n88jl2n331v9Ntttnnkkr\nQ4yoxS64miHGhtp+J0ygrzjmJ2aHH+5eJgo6AVFHLEGW4jLZx3kHZSP3f/6n+niRe8AEPuaDunNc\nNYO6cgiBSCfcuGoZqGVwiY6uig1ly+fJJ4E777SnLU+6i3LgYyuP/B2gbUQH6Fo1qgYyVV+aH7dC\n6lLVD8jjnM/zpVCWyVSefOgDGyIot07YdKkfMbaJNO66K3vvQlG5INdhW7DOL17K58yb5142Hwre\nLhiXFJ2cbCZRhcmaSzkmTvQriyBWncovvsq0Szewy9dSzTnyvPWW+zU+qOprlYNT9+OPb/0/HxhX\n5qyzaGnOmaOf3MuTs5BJRZHq6ZAVu698Jfvs7qYLPWUMljJyfVO8dsUqt8vk+tpr6XmncuetI1Yb\nFaa4VKEnVHv+pS+FpQO47TF1caDi8wxHjdIvxpg03lTT9KI12y+/DHzve7Q0QoNSpxIQXMtQFU1s\nWX3zq6/SxnabGfuCBc05jewMSq6P/v3pwV5lTc+GGza9wdoE6iIsoeTzZdNDHy2jT/uptdBDReVZ\nR4e8KlNGR6PqYFwaV9muOylleOcd/Wqy0HaISZ6wBXdB2LlSyyMTon42xaSxbdh2WXEVApPKBObR\nR9XXmO6L4sHI1ybXl89+1n5OUe+Gz/3Gcp4hNAA33xwnvZiIFbrYgm0MExCXfYeUFfmizJdj7RtJ\n8Y5SJyVU19oml/cf/rD6uFy3PkLPiBFZkHMTOnPk9dc339/y5e7lsT0r3QZ+KqedFpa/zTSbmo7q\n+lgLwNR0fN7Nf/s3mmmjLe3Fi+lzmtVWA265hXauIPY7T9VAupbBZTHAVIaY5m2pmAPgutz/kwAs\nB3AvAI0Bj5oUmpLQBhOjTCoVZ8qJ3W67NW28xSpeaDR32/X9+tnvSdaCpMbn2VPqetNNm99tqm+X\nlRdhCx/rPRCDuOu7QvXo5sNFF9HTffjh1v/F6nXeDEUOHKcjlUCXX9nzGXhVQXx1yPcgVhdNGruQ\n+w5Zbe/qcq+P/fbL9hGtvrq+3KrJhWoltrc3zC2wy8KaKm8doZqeslixwqy1ziPqPaS8Pm3v6af1\nznRCePBBYIcdmv/7LNrlEW3gmGNa/3dF1tCp3NPH6Pdiz1V84j1RqII2XxCqcQGadenzLpjytcWd\ns11PxbTX0cTf/uZ2ftFCz8UAzgOQr6JvI3OSMBnARADbUBNL4dnluOP8rwX8zIVUq/8xB7tNNgFO\nPll//pgxzT0rRx+d2YGKDbUmTGV02UQnI8qvc+VLLQOVP/4x+5wxo31PlOylSYZiLvXVr6qPFx2L\nIp/nc8/5XW+LfO+lbjbUgy4oWR7xmywQiEnC/PlNZwFUO3zVXrEYG5l9TV1iuO7VrZqr8HmvQmIV\nAfp70UW6v/FGuyZQdR9f/7o5P5ey5fNx1VRRnEXEnpgdfHDc9ARyOceMcQ+iGlvgPjJyREFq+SZM\naD33y18GXn89PN+89i+GQCuHFbCVIcXCMeU+5MUIioBg2yNoyjdGgHBqXinyUc2bfLQ1gnPOcb9G\nIO/vMl27zTbu6QPu43HR067fAFiAptAzBMAaAJ5v/H8bAKJfGTouL2x+Vb4oZM9gOtMkKvJL1q8f\n8I1v0K7t7o7/0lPIlzlGJ6HSlun405+yz5/8BFiypPU33erDf/+3PV2BTnhz6ZxUyDa8lHTEcVU7\npwwmefe1sfZLUBDOBD7/+fbfVBur83R3N98xajnyq9QubUlGvpa6L0t1bWhZdNeYNHU2r0v5NCj7\nL0z1/8EH9HNldGahqomvLsAoBZ2g4uPIQJjT9fYC557rXyaZ3l7gF7/IzFzlMhTlNp+CbPoZojHe\naaf2Y6q+u0hBTNDT4+60xFSGUI2iqANZMHAxb8sjm2K6jEexEfnIjhNM51KPu55TNMJax0UzZppD\nCHQCJKUOhEe2UHR59fa6v9OphJ4jATwm/W2HzP11niEA8lvD3gBAVnLpBvyYattQtZ8JXflffDHs\npaKuZleRqnUmKQQwEz4aMhfX1yH20LqNhxRcn+vuu7dOTv/937PPDTawpy0muiFtSTVhGj/ePR1T\nnbq4y9Xhs4HepU1/7nP0c0ORhR6By3Pca6/W/086SX+uz7utW1UMMSnp7QXGjjWfQ2HMmOb3mTP9\n7N0pqDSGKlNXG/Pn288ZMgT4+Mfbj8v5UF2su46NVRuPUmJqLybBS9ZeuwgNIY4MVNeKY6m1Ky6L\nBy71EdLexHuiWqjyFWh9qfJ7k8pR6FWNPxurAOSHkSEAVqpPXYRFi8T3aY0/NbK3rzLMiGQo5jl5\n5E7cpRHJHkHqQJEvnRCKhw4FXnopbr6uZZE30obupbLlGeK97ZOftOcVyxvPLbf4D1xXXAFcpel9\nqHtiVGUSkz3TYJsauVwuG94pE4IYg68JF02PD6HeK33p7s4mG7fd1jxW9ERDFvhUhJgdC2bPDk9D\nRb5dCuGkpwe4++72c1V1lyKuVRUmbyqBY8oU4Lrr1Ofb8A3zENO8rQr1qiP2wlGKdumbj+C99+j5\nyum6BJotzjvfUgBLczKCnrLFgVUA3gWwGTKTt90A3KM+dREWLVoEYBF0Ao+QcFWdRFEvmXjI+Y2M\n+eNUxowB7ruv+X9sO9kqE6P8psm9EDR0q6tA++QvldcvV9Wsa/ou5/oOevm62XJLszcmaro9PeoJ\nPeVeTau+Nm9NKmQTgNgOVEKcE7igE3ryacYypfEhxARIUFZclyFDgB13dEs/tC3LUO7nq18Ffvc7\nepoqVB4Jxb3suy89HdP922KNvVPLaIF+qN7JT33KPz2VtpxSBuriFqVdi3clRDMTUgZX51AyI0fq\nLX105TJph2LEeCzKM6lYnDKZMerGylDTTD3TIGSERRbJpwyhp7fxJzgOmTe3BwA8AuBBckKNVISX\nLxEQsyibUlUEcpHPT38alnZXV6uN/KuvhqVXdXz39ITY5cbwClPmyqFpwPAxU4jBXXcBTz1FL08M\nYqTtYt8ea7LsMin2uUch+B9wAP0a2XRJlHHBArdYLnlse64EshbCZcJfFLrnMG+e+4pofmKgspv/\n85/9o6rLx8QCz+DB7eYvMd/NqVPp58rlcNlrtVJjD5InZB4gnKDkn2GVFxMpAakp5dcFGHbpDyl1\nLPaGUvaUUPN1Zdgw/2vvvRd47DG3ayjtMcaiVmqElig2JiuDbbdtmriHUobQ82sAeR8yDwD4GIAd\nABCdXLZi894Q6lVIh6qD13lnMqnjbZHMe3uBd9+llWmttehueUOpsorahKj3U0/VnyO/gBQthy0t\nwG0lNASq0JMvf4zAkYMG2dtzCKnaHDUAHNBaZ1deSbuG4olQMHdu9qlaWXW5f+F5UET9trXV3t6m\ne105n8WLm14OXVHto6Dsj7pB3gEamZiTBPHM8shCj2qzvUD1XG3vI2WiKzC9kwcdREtD7i+vuab5\n3dUssre3KVgAmffQL36xPT0d//gHLZ9QQhceYpahq0vfD7h4qtO1+6FDM+ca+bSn59xKxTRvk8ty\nxBHAr35Fv+6//issllVPj36eJDuWUuEzzqnqZdYs4Oc/d0tHR4gpmemZidAYAhehh1ImSn0PHgxc\neqn6N9f3smzztqjobl4M5DHTBNQP1OYqUYVp8i2g2lEOGlT+HqaFC8vNH2jWgejYXFXh4nxbDAlX\nU65YQQfzuKxo6tpGb2/zXlIM7iFmdWUTw9TR5BFRd/8uq+aqtIQZi82ExBY7KiaifKNHZ58rVrQe\nzyMPthSqtBpPLcs666Sz6adMaqh5h6yM25g+3a0d+taXi1BGOVYERe2RUQXnFVri2JoemYEDaR7X\nBPvs455Hni231P/2s5+Fpe1CT4/eJb8rFOFB8K1v0c/dYIPWZxwi9Mht45VXgMcfp6enwtVldSpH\nBoUgD+a6CV2Re3p80LlbFeRXeOqAKhaETRhUrWr73PPEicADDzTTmzXLbsNuykflOSiPSrM3dmxz\nMgeka3siXRd3uSnKYtqXNGIE8MwzTeHxssuAZ5+Nm3+qCaOOKVPaj6lW5WfPNjumsLVz1cCc4vn5\nCBcURJ2YyhxDu+hL7AUIX1NXW/+vg2L65qqBcSEvyBc9vqreGcpiX9nmQ5ttZo+RNm5ceD4yixfT\nzVxV8w2XeovdFnzSk6/58Y/t12y1FfDEE+H7a0IcSYXU3fbb0zWgJ5wA/POfWXsE1GO4LiZfiGOG\niRNbrR5UAaFd68BVqVE7oWfWrCwGgQrTRE/3oGRPb6lw1Qjk6e2tVnwFH2zmPeL59O/f/qwoK4BX\nX519brVVq9BjImT10yRob7JJq9CTClEG1UZ4itDTr5+6bl07nWXLsg7UhFgl/vSnw/MrApP2LD9A\niGeg2u9y881hZVDFJPIhZNIQMtEzBZtLtYhDTfeRR5oDvku6LnXp4uXIlaeeojlBSSn0TJiQ5jnu\nuqvfuCzvHYsh4MSut+9+1x6gWN5rGqMMCxY0v594Yja513HWWcD779PTFnU1aRKwfLmb5UGqfkAO\n+B4rXgwFlaMPgPYcQ+vDxeRO7IEHgOuvbwbwFuj2VG6zDfBgY+e9bZ4h38/cuWpT4CKpnXmbr8tN\nXaO3NcSuLrXaF3BroBRXeibEIOCyN6CK2Fwyq+5v++2BF15Qny8P6iLopmnvivzcYtvC5m3VdefE\nRJV+PohonryQ9s47/qvMeTbckL5ZXUWq+nEpk8uG0tiehnSoJrWU/srGySfTy/DLX9LP9SHlpNzE\n+PH6wMMuXHml3ryC6shA/k5hiy3imZvF2KsR8/ndeWfrXhIVPsFgqeeUjbzfzUWIoHD88ZnGXceZ\nZwLnnOOenxjbdaENVKQSelyctwjqZE0Tm/XWa43zZcK011RuJxMm0M1WixpXayf0qJArXDWB0aks\nxblHH63+vbfXz4uQXAaVKYX8wFRmMwJhMlZ3L24qdaaMaiO3LRCsGATFKpr4vwyBIyTGUix0DhPq\nMOjH4L33gP33bz8e4/7zk1zf9O64Azj33Oy7ixBuy8/UV4l0XbwWvvUW/VyBMO8QQoVqch9Dk1QF\njj4aWLVK/Ztt3FAF+QxBtdARUxCI4V4/Fj7OUmbPpjttKEsT+f777dpwHw2BaQ9hDPILSnLeLuZG\ndX//Y5N6fD700LTpC8R9fOMbNE+LRVI787Y8uhfGxYWv8GwUM39ffvELu8vIKrlxjWFrq0Jo83xc\nV8dSIYesfsqTmZB6+shHgL/8xf163T1WUeiZNIl+LrX8Pg5FbIjBPL9y5dsHqFayTZqHyZNp6a67\nLvDoo+rfXPbKhbSTHXcE7rmn6T2uSFJMoo46qjlZdtF2yNoI+ffbbwfeftueLpXUmphDDtELzEX3\nKzpPTiZczE1FO8ovVvrEt9Glq4M6vtvqe/Ro4MUXaWmZEHta5fx0lgRUZHflocgxsqpEKlNJH2LP\nH3WLV8Jip6urWnNWoEM0PbZGZWpsW21lTjtlQ5X3Yujy6t+/Gi9MDFKt7IgJhuyBjLKirKpb6qQ5\nP7ERtrzyJF6132PmTFr6Pmp6E2W1I1O+Ni1eSNqhaZ55ZtMDoLCBTtWGTfv+dGabKsRemhiE1K3L\nanyKzdux+M532jXIFGzmbeuum86JhMC2GDRgAH3RYfXV7ZPVovoXisemGGXJjwO6vRpAWg+IlPuQ\nzcJ/+EPg5ZfD8x4xIlu8oJjEyuXM1538m80rqildVRmnTcu+b799tidJpq9rlGIKXpQ0YgRbTUWt\nNT0Cm3lb7AYvR/OdOxf40Y/c05k3L/uz5QXEXRFMTRllFHmKCbTLHg3VbyecYDY3lK/9wx/aTRiF\nmd6YMe1t0GQqss02dpt2wNyu66TpCSXlPZ19dvN7mStWtns02WPLGp6iJwCmsos6ddkHYMJ0b/Pn\nh6e/zTaZaaKJb34z+1TFJ9JBWbl/8kl6etT0ZfPFD30I+Pvf46WfijL6Maq21UTI/lHTsRNPbE78\ngWyvZoz9mgBw7LG08+R7+/WvzbGpYvH0083vAweG758ukzLM8WOcWydqremRnRqkGtRTmXHFuMaH\niy9Om77PZNwVOZik2EcQa2P0wIG0QU7ks+WWbrbMpvI9+qhe4Iox8Nqo2wRm1qzMBMmFXXc1/07Z\newbEac8x9vTEMuuU00vVl37mM9nnkCHxXZgDmTeiFHR12RckhNOZCy7IPin7K2ztzfcdce0PR470\ny6cTePhh4LXXsu+qdr/dduF5xHqfZI3jmmsWI2CoCJl39SUNTBWEiLwXvxjEfH5FtYXaCT35hhND\nhWZriL4NVai7fTZcqlxaxnxhfD3gxcDlPkxxNOQXRLa3Npmh+MQg0Jm71U1AqCJiQz8FVce48caZ\nCZILm2/e+r9suqKL1q0rQwgffGA/x5TnrrvqHVfkr5XduJZJ3qRKdh0ta79NZkU65s61u1HXIQQy\nV2TPlKIPOv10+7XjxvmX10ReU0nBt213Qr+07bZm5xIp7nGHHfyuq6IXV9Mm+Q039E+3yODJKanC\nO5JKcI+12FwEtRN6UhFzlaK3t2lz7NMITDbWRdlklp1+by9NPW8z44p1r2PHmvMJhbrHJwSqi1v5\nnlwjHqswPcuQATGUCy/MPmUXrkV23i7xXFTluvNO8+RWXCOeY+oVtX32adXEqry3mfjYx5rff/97\n4Iorsu+2djhjRjO6eVdXa5s76CC7KbHAd0Kp63OofZGvOZIpwKuLiV0MqrRyH/IO5+PGycdiEqpZ\ni9E3hwYIFvViWuDV7V2j1Onll2f9QBkUvT8y1bgTOxCzoA5CjkxHCT0++xhsL12olxEXcyRRzpNO\n0v9WJWxlOu+89mOxBg6RjjxhpJj/xLKrNh2Plb4vMQfokBg8sYldTyIGV4yYLb4IL2fCJt/07Hw0\nx6LOxADusnnYZeO+YOJE4JZb3K8DsgB5eROMkSObz8YWR+LWW/Xexa6/nrZPLgThmEYXiiCVQCCe\nlWzyqzqnL2HS1toQ9RXbzFU+7zvf8dtDJYihBTn//LDrXbzo+pyz1lrhwiElH9X7E1OjVuaCQMz9\nqCkFM1XwchViEbpPxOlRVbh84z4DtQ5KbAJTxQu7bhdMnsPqNHiljOtgsyOWV1fzKx2yJ5OQgSNm\nW4tJlVZcYxLrvmyr77HfM5NntsmTs/sSGg1TeVZbDfjUp9zyFnUmzMSq3DbWXbf8d8r32evM8Iow\nwwb0QbSp17ucVxbCgyKlnPPm+bd1254/GWq9yeVZY43yPV3FXogsI+8YXHBBtcoTE5f9xoIyHN6Y\ngubGonbe22Jvkg9ROcaOd1HFAWfKFGDZMr9r99wTeOihuOWR0QUClevSFFfAx8c/xQXkllvqf6N6\nlzv0UODdd93KZisXE4ZPP3PTTX6BPmOz//6tXp5sVMmc9owzss3mVacoQZqCyJMabT2E3/++ejE5\nfFHtqzVR1mS56Db1ta8Bp57aeqxTBQXAv35Xrmzv78s0bxs6tLOfkwu1E3rKoAoTyLI2ivmY0wg2\n3xy45pp4ZVExYADw5pvtx031FSNwpe15vPWW2Uaf2gGNH9+6+lHGim2VOsvQ+4pdf9S6WWuteCZ0\n117rdn5+g/0NN9CuSdXfhKQ3c2Yxe9+q0N/HRuxdsxHyrvdlz29UYvalM2bEMT0ePZp+rotWynav\nS5f6OSnxoWgHHTH7+yoj9rwJM9A6OHaqqHGOHtVN+rhXPeywOOWx4eIprQ4eMEx24yEsWAAceaTf\ntaqOU2eTff/9wH77+eXjwoABacx0fG3HmVZCvDbWrW5NZk82YvdFMTZe140y+3OxaNUpGpiyGD06\nW4AKxaXvuOgi8++33gpcemlYeYBsH1zIuOIbYHfqVP0evE4iZmDQIqForAcMyO6v6P4lZAyundBj\nwqUidt/d/1qXa4YPB/78Z/e0Zcp6YVKZDMocfDDw3e/Sz7ft5REB1Y47DnjppebvkybF0fSEEsvD\nXYrzq9w5u5hmheArsKZaFCiL2OZt224bpz+sMvn7PeywOHsbfZ/Ddtt1Vn2XteDwxBN++yI6ndde\nA668suxSpCPmWJj3SsnEwac/qMD0L5zUHeE665gHDlv+ri4hq+RSWo49oUJ262iqj+OPp+dtwlbn\nIiDgaqu1x/CRCanvogWEkSP991hVWZihYoqj4YPPhLRos4UlS8I8UYW4KzW1GWnyG7MAABEFSURB\nVF/TlFAXuXXi+98vuwRu9V2XPiKlkxwfqHMQ0z7POiDfZ74/dnG9XxdiLvoUsUm/L3P33bTzaqfp\noTTC2ELQJZeoj8f2fV7mRjcd3/428Pzz8dIryoaXgk9dCnORTTf1TwNoD45JTUe+TkcdIyVTEGUJ\nnTiL+t57b2DFitbfZC1wnmeeMQdTjVFXchrTptEWH1Q89liYCYmpXdZlguxKUfvGYlGl97Mo8vFz\n6sTmm3eGxl1FlYWeMt+Rupq3+VCm501q/XaEpkfg0rDlDbGma1UT9ZUri13xLeuFGTTI7tKZ6oms\nCFLnPW5c9hni4OGNN9z2evkgt+epU+kbVjvVCYKK7m43z1ZUobMq6ILqxqBTJ2+pqJNGuapUtR5S\n9+dVwVT/stBTpb7fVO6zztL/FlO4ruKitg+nnJLFYisTVdvqOKFn9mz9bzZHBqrKCBVY8tfPnRvH\nHW1Rjgzq8GKFUtQ9+uQTEhco38ZdBpWlS+nn2swBY3HVVf7OK6pClQb2FFTJZXVR1K28Mdlww7JL\nQKNKz+jZZ/uOowhTf1dVTc+SJebFKt0e3xUr6E5gJkxIH56jKgwfDsyfX3YpMvLtkWpFVBvzNsoK\nq+sE5JBDgK23zr6HdKJz5vhHIKfSl1bfKcS8h7rHUoqNHFA31T2X6VWsys+xSu9nDPO2M87wC9Jc\nFp3ctmz84AfAq6+WXQo9VXo3BJttBmyySdmlKJ+qanqmTfPrx8aMaff+GkJV6oNKnVzQ//GPdDPu\n2mh6UtgKXn21/rdzzwVOPz37XrTWoG6Dpkt5y4z+HINUpnyxn7moH5/BWI4vlKqu676pty8QYwV7\n8uTsj/HngAOAYcPS5zNwYPWcBKhI3f/3Fc1NTKqq6bERY+z9wheAAw+sRlli8N57fu9AWXF6XOY5\nHSH0pNg8XGanZ7rXKpqblLl5TUdRL1+Znqgo9xgSx2HePP9rBaZ3c+TIdG63i2C33dojt1epfDEY\nOrTsEhRPVSYeeb70Jf1v55zTWW6pq8B66wEPP1xuGarYl5jKFNuzZlHEeN8pjmaq2K/o8A3rUVSb\nHTUqcyPvQ22EHvEQVA1HVLT8KXDZqFwFTAFYy+a88/yDe553XuYtKwZV0PS8/nrx7ovz+ZvqIEZ7\niSH4V3HgjsVtt5VdgvTsu6/+t059trIL/qpT931xLhQ5Dm67bXF5qajKmE9l+vQsbk+d+OY3sz3Z\noXRqX1hVrr8+czLhU+8VXKNXc9pp+t9sjgzqEjCwDuZtW2/tv4lt4UJg3XWjFicKvpOcD30onpaL\nugnP9SWvclsqkyrXi+0Zx7QzZ9o58MA0k5gqt7m6QHkuIdrtKlHH9lI3bc9JJ1Urblgdn3meosov\nm+C7UBtNz+DB+t9sQg+FBQvCNlbHJMZE+qSTgAsvVP9W9xfrK1+JG924CvWx445x0xPBLFOYfqai\nu9tuF17EfoOqr9o99xywalUxefXFOD2h6Orl/feLLUdfpervL5W630fdy+9CX7rXulMboUdw/vnA\nwQfHT3fCBL33hyo4MqiDFqgohIOJMkhV/7HTXXvt8DSq1tbefjte3IQ6D1JrrlmtIL8MjZkzq/dO\n1ZW6aRSYzsY0nojfKO7gp08vfy9ZCHUIGlwb8zbBxhvrY/bstFO8fOoWYNMlvkKqAeO889Kk60Nd\nhJMqUzUtUb5D7eTnsPHGZZeAScFppwHLlpVdis4gbybdqeaeVezjXPrzkADedYNSL5Q9skcfDTzz\nTHh5yuLII6svtNVO6FEhGtyIEfHTLBLRyanM22J2gLNnAy+/HC89Ud6FC7PPKnbWKupSTh111lZ0\nKjGeyfnnA3/7W3g6MdC9I1OmZKuSTDt171eqzNixrf/vsEO7B8VOoYr9u0sQ9vHj484zqkxqp0J1\noV+/4hyAfPrTfgsetTNvC6XKMQjEi5P6JenqAtZfP05ajzxSnb1QfZ2ZM4Ff/jL7rvNk6EMVB99Q\nqjxI9etHc4FaJvfcU3YJmL7IAQcAhx7a/P+BB8orS2rK7odU3Hij2/mx5hlVZ9QovSanE8fPKnDZ\nZX7XdYSmRyZ2Iyuq8+nuzlau6sT48e2mdYMGlVOWPJ1q3jZnDnDIIerf6mBPWwdC+o+y2wdTPtwG\n0tHTA0ycaD6nU+q/ivcxdar/tU8+CXzwQbyy+HDAAWnS3XRTdlRSFzpS6BFcd12cdIqS1Lu66r9y\n9cYbwEYblV0KYPjwskvgBnWAGzUKuPrqtGUBMrXxlCnh6VR1lSvVhKKq9+tLFSdeTN+luxtYvrzs\nUhRDFfuSYcP8rx01qvxA5pttVm7+TPl0hHmbPDCL/6tsyuYLtSPcay/gf/4nbVlUVEHLA2QdbAqq\nNAk0mRUOGJB9+pb3lVf8riuK0OdQxQkFwzAMwzDpKFLoWQvAtQAGA+gH4CQAywFMAvAtAO8DuB3A\nOa4JyxMYivvATmfq1DBVdF/AZ+JcJaHnmGMy4VaF0HT1lfZeFTqtvjvtfoqgSn0Ew8Sk7v3BEUdk\neyaZvkuRysbPAbgDwDQA8wGIbUiXAzgIwGQAEwFsU2CZtFRFYyHDAyoj6O5ujSYdIzaPiroPdIwf\nP/1p3CDADFMEPEYyOrbYAjj77LJLwZRJkULPRQCubHzvAfA2mlqf5xvHbwMQzRFqSOd3zDHA44+H\npxMbnoB2JjHa2MUXA88+G55OTPpae61SXxHKnDm02BJMk/HjOXAmE4dO6ksYpiqkMm87EsCJ0rH5\nAB4GsAGAawCcgMzkbVXunDcABG81i2He1tMDbLVVaEmKY9asppDGpKPKA9GgQe0ayhRCxz33uMVr\nSEFVn0NfE/KYVh55pOwSMEw6uH9zh+usWqQSeq5q/MlsDeCHAE4GsAzAEGTaHsEQACtVCS5atOj/\nvk+bNg3Tpk2LU1IHPvGJwrNsQzfZu/zyYstRdbijSUcMr25M+ZxxBvDlL5ddCoZh6gKPq0wVWbp0\nKZYuXUo6t0hHBlsB+AmA/QE81ji2CsC7yLQ7zwPYDcAi1cV5oUdG570tv98hBkcdFTc9V55/njfh\nxWSNNYDZs92uSaFhWLAg09RVla9/HXj66fT5TJkCvPde+nwAHryBariWZ5jYVFULzPRNuD2mR1aE\nnG3YuFWk0HMesv07lzT+XwlgDoDjAFwHYDVke3oedE1Y571t++2Bd97xLG0FqVvsmarT3Q3cfHPZ\npQAWLy67BGZmzMj+fHARLu66i37u1KnANde4lyclEyZUW3hlGIZhioUX2KpFkULPPprjDwBI5iNI\n1oxwA+x8hg/vzBhNrkycCGy3XdmloOOyaX7vvasn9DzovFxTLtOmZX8MwzAUeP7E1J2OCE7KMHme\nf95+ji91UlV3cuTysiN7dwJbbAEsWVJ2KRiGqQss9DB1pyOFHl7lZ1JRJ6GnCqQaJPfcE7j99vjp\nzpoF7Ldf/HQZhimGTumjx4wpuwQM03l0nNDz1FPAiBFll4LpVDplQK07PT1h3hR1wtjPf+6fJsMw\n5dMp2ojNgoN3xKdT6pbpu3SE0DN6dPP7FlvET19MdHnC27fZaitgt93KLgXDMAzDFE///mWXgGHC\n6AihZ/WOuAum6nDwV3dOOw144YWyS8EwTF+hUxYnq6hVOfZYYMcdyy4Fw/jT58SFkI6kip0Qw1SZ\nBQvKLgHDMAwTg3796uURlGFk2AeSA4MHl10ChmEYhmE6nZ6eskvAMJ0HCz0ENt88+4zlFY7tYhmG\nYRiG0bHhhmxSzTCxYaGHwJAhZZeAYZiYsKkqw3QmnbKnB8ic5zAME48+J/RUYbLTSZ0ywzAMwzAM\nw1SdPif0MAzD8MIDwzAMw/QtWOhhGKbPUQWNL8MwDMMwxdHnhB6e7DAMwzBMZ8JaXIZhdPQ5oYdh\nGIZhmM5k1KiyS8AwTFXpc8FJGYbp20ydCuy1V9mlYBgmNmzJwVSNNdcsuwRMno4QeoYNKyafddct\nJh+GYdKxdGnZJWAYhmH6ApMmAc89V3YpGEHtzdv++U9g2jTauQ89BPz2t/75jBnjdy3DmFjKs3Cm\ng+H2zXQ63MYZE5tuWnYJwuik9l17oWeNNejnbrcdMH58+nxs8EZLJk8ndSgMI8Ptm+l0uI0znUwn\nte/aCz0MwzAMwzAMwzAmOmJPT51YZ53sj2EYhmEYhmGYYqiLodVSAFPLLgTDMAzDMAzDMJXl1wCm\nlV0IhmEYhmEYhmEYhmEYhmEYhmEYhmEYhmEYhmEYhqkJEwEsaXwfBeBeAMsAXIXmfqOjATwI4H4A\nsxrHBgC4CcA9AH4BgMOGMlWF0sYvBvBQ47wlAAaD2zhTD/LtexyyfnoZgO8B6Nc4zn04U1co7Zv7\nb6aO9AC4BlkbfQDAbAAjkM1R7gGwGDwPj8oXAfwOwH2N/38EYEbj+7UA9gSwQeOcHgBDGt/7ATgJ\nwJmNcw8E8K1iiswwTlDaOJANorJPP27jTNWR2/eDACY1vn8ZwIngPpypL5T2DXD/zdST+QAubHz/\nEIA/AfgZgJ0bx74NYB90WB9eZpyeZwDsi6Yk+TaADzf+HwzgXQA7APgNgPcArGpc81EAOwH4VeO6\nXwGYXlipGYYOpY13A9gCwHeQrbAc3jiX2zhTdeT2vSGA5Y3v9yHzuLk9uA9n6gmlfXeB+2+mnvwE\nTaGlG1kfvS0yzQ0A3Iqs3XZUH16m0PNTAO/n/r8UmZr4CQDrIXM5NwTAP3LnvAFgrcbxVdIxhqka\nlDY+EMAlAOYh0wJ9GsDWaG373MaZKiK37+fQXCWcDWBNcB/O1Bdb+x6IrI1z/83Ukf8P4E1kC7A/\nAfAltMoE+b66Y/rwMoUemWsBTAEwGpmd4TeRVfTg3DmDAaxEVtGDpWMMU3VUbfwtZIPmP5F1QHcj\nsx1fhaxTAbiNM/XgcAALAdwJ4BUAr6G1rwa4D2fqi9y+/wbuv5l6sxGyNns1gB8C+FfutyFo76uB\nmvfhVRJ6BiKTFgHgJQBrA/gtskniGsikyNEAViBTtc1snLsHmuo4hqkyqja+JTKziG5kNrOTATwM\nbuNM/dgT2Yr3dGRmnLeB+3Cmc1C1b+6/mbqyPoDbke1d+37j2KPIzDaBZrvlPjwiw9HcJDgdmb3s\nUmSdycaN40chq/SHAMxpHBsA4AZkGwjvRGYqxDBVZDjsbfwkZN5T7kXmJQXgNs7Ug+Fotu89ATyC\nzMPPxWjuheA+nKkrw2Fv39x/M3XkYgB/QdPr4BJke3WWImvz3wX34QzDMAzDMAzDMAzDMAzDMAzD\nMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMEznsVrZBWAY\nhmEYR/4fgI8A2BvAH5BFB2cYhmEYLd1lF4BhGIZhHBiCLOr90wDWAfBiucVhGIZh6gALPQzDMExV\nGQLgxwBuA/AYgAUAbkYm7HwWwDgAGzfOPRlZ1PD7AHyt8JIyDMMwDMMwDMN4MB7AnMb3oci0O0sA\nzG0c+wqAUwBsDWA5mibbNwGYVVwxGYZhmKrDmh6GYRimqrwKYB8A1wD4EoDVG8cfbXy+CKA/gJHI\nhJ4PGseXARhTXDEZhmGYqsNCD8MwDFNVTgJwP4BDANwIoEtz3u8BTESm6ekCsDMyBwcMwzAMA6C5\nasYwDMMwVeMWAJciM3F7HMCbAPoB6M2d0wtgBYAbAPwG2WLeMgA/K7SkDMMwDMMwDMMwDMMwDMMw\nDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMwDMMw\nDMMwDMMwDMMwDMMwDMMwDMMwTHz+F+jpm7MBhtO0AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f4bda269e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = subplots(figsize=(14,4))\n",
    "ax.plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
    "ax.axis('tight')\n",
    "ax.set_title('temperaturas en Estocolmo')\n",
    "ax.set_xlabel(u'año')\n",
    "ax.set_ylabel(u'temperatura (°C)');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando `numpy.savetxt` podemos almacenar un arreglo Numpy a un archivo en formato CSV:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.71917719,  0.25282947,  0.57017201],\n",
       "       [ 0.47082652,  0.30021729,  0.51052492],\n",
       "       [ 0.38195762,  0.97185082,  0.81447527]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = random.rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "savetxt(\"matriz-aleatoria.csv\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.191771928771565348e-01 2.528294684525156377e-01 5.701720121608914171e-01\r\n",
      "4.708265166542224822e-01 3.002172870758357259e-01 5.105249231389386022e-01\r\n",
      "3.819576170911789248e-01 9.718508247167131353e-01 8.144752737532305886e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat matriz-aleatoria.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.71918 0.25283 0.57017\r\n",
      "0.47083 0.30022 0.51052\r\n",
      "0.38196 0.97185 0.81448\r\n"
     ]
    }
   ],
   "source": [
    "savetxt(\"matriz-aleatoria.csv\", M, fmt='%.5f') # fmt especifica el formato\n",
    "\n",
    "!cat matriz-aleatoria.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### El formato de archivo nativo de Numpy\n",
    "\n",
    "Es útil cuando se almacenan arreglos de datos y luego se leen nuevamente con numpy. Use las funciones `numpy.save` y `numpy.load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matriz-aleatoria.npy: data\r\n"
     ]
    }
   ],
   "source": [
    "save(\"matriz-aleatoria.npy\", M)\n",
    "\n",
    "!file matriz-aleatoria.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.71917719,  0.25282947,  0.57017201],\n",
       "       [ 0.47082652,  0.30021729,  0.51052492],\n",
       "       [ 0.38195762,  0.97185082,  0.81447527]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load(\"matriz-aleatoria.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Más propiedades de los arreglos Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.itemsize # los bits de cada elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.nbytes # número de bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.ndim # número de dimensiones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulando arreglos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexando\n",
    "\n",
    "Podemos indexar elementos en un arreglo usando paréntesis cuadrados e índices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# v es un vector, tiene por lo tanto sólo una dimensión, y requiere un índice\n",
    "v[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30021728707583573"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# M es una matriz, es decir un arreglo bidimensional, requiere dos índices\n",
    "M[1,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si omitimos un índice de una arreglo multidimensional Numpy entrega la fila completa (o, en general, al arreglo de dimensión N-1 correspondiente) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.71917719,  0.25282947,  0.57017201],\n",
       "       [ 0.47082652,  0.30021729,  0.51052492],\n",
       "       [ 0.38195762,  0.97185082,  0.81447527]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.47082652,  0.30021729,  0.51052492])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede obtenerse lo mismo usando `:` en el lugar de un índice: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.47082652,  0.30021729,  0.51052492])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # fila 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.25282947,  0.30021729,  0.97185082])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,1] # columna 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos asignar nuevos valores a los elementos de un arreglo usando el indexado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M[0,0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.25282947,  0.57017201],\n",
       "       [ 0.47082652,  0.30021729,  0.51052492],\n",
       "       [ 0.38195762,  0.97185082,  0.81447527]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# también funciona para filas y columnas completas\n",
    "M[1,:] = 0\n",
    "M[:,2] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.25282947, -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.38195762,  0.97185082, -1.        ]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Corte de índices\n",
    "\n",
    "Corte (slicing) de índices es el nombre para la sintaxis `M[desde:hasta:paso]` para extraer una parte de un arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([1,2,3,4,5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los cortes de índices son *mutables*: si se les asigna un nuevo valor el arreglo original es modificado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2,-3]\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos omitir cualquiera de los tres parámetros en  `M[desde:hasta:paso]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # desde, hasta y paso asumen los valores por defecto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::2] # el paso es 2, desde y hasta se asumen desde el comienzo hasta el fin del arreglo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # primeros tres elementos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # elementos desde el índice 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los índices negativos se cuentan desde el fin del arreglo (los índices positivos desde el comienzo):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "A = array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # el último elemento del arreglo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-3:] # los últimos 3 elementos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El corte de índices funciona exactamente del mismo modo para arreglos multidimensionales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# un bloque parte del arreglo original\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# elemento por medio\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexado Fancy\n",
    "\n",
    "Se llama indexado fancy cuando una arreglo o una lista es usado en lugar de un índice: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices_fila = [1, 2, 3]\n",
    "A[indices_fila]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 22, 34])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices_col = [1, 2, -1] # recuerde que el índice -1 corresponde al último elemento\n",
    "A[indices_fila, indices_col]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos también usar máscaras de índices: Si la máscara de índice es un arreglo Numpy con tipo de dato booleano (`bool`), entonces un elemento es seleccionado (True) o no (False) dependiendo del valor de la máscara de índice en la posición de cada elemento: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = array([n for n in range(5)])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masc_fila = array([True, False, True, False, False])\n",
    "B[masc_fila]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lo mismo\n",
    "masc_fila = array([1,0,1,0,0], dtype=bool)\n",
    "B[masc_fila]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta característica es muy útil para seleccionar en forma condicional elementos de un arreglo, usando por ejemplo los operadores de comparación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5,  5. ,\n",
       "        5.5,  6. ,  6.5,  7. ,  7.5,  8. ,  8.5,  9. ,  9.5])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(0, 10, 0.5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True,  True,  True,  True, False, False, False,\n",
       "       False, False], dtype=bool)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masc = (5 < x) * (x < 7.5)\n",
    "\n",
    "masc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.5,  6. ,  6.5,  7. ])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[masc]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones para extraer información desde arreglos y para crear nuevos arreglos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### where\n",
    "\n",
    "Las máscaras de índices pueden ser convertidas en posiciones de índices usando la función `where` (dónde):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14]),)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = where(masc)\n",
    "\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.5,  6. ,  6.5,  7. ])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[indices] # este indexado es equivalente al indexado fancy x[masc]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag\n",
    "\n",
    "Con la función diag podemos extraer la diagonal y las subdiagonales de un arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### take\n",
    "\n",
    "La función `take` es similar al indexado fancy descrito anteriormente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 = arange(-3,3)\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices_fila = [1, 3, 5]\n",
    "v2[indices_fila] # indexado fancy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2.take(indices_fila)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero la función `take` también funciona sobre listas y otros objetos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take([-3, -2, -1,  0,  1,  2], indices_fila)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### choose\n",
    "\n",
    "Construye un arreglo tomando elementos desde varios arreglos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -2,  5, -2])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cuales = [1, 0, 1, 0]\n",
    "posibilidades = [[-2,-2,-2,-2], [5,5,5,5]]\n",
    "\n",
    "choose(cuales, posibilidades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Álgebra lineal\n",
    "\n",
    "El vectorizar el código es la clave para realizar cálculos numéricos eficientes usando Python/Numpy. Esto significa que la mayor parte de un programa debería ser formulado en términos de operaciones con matrices y vectores, como por ejemplo la multiplicación de matrices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones escalar-arreglo\n",
    "\n",
    "Podemos usar los operadores aritméticos usuales para multiplicar, sumar, restar, y dividir arreglos por números (escalares):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v1 = arange(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  2,  4,  6,  8],\n",
       "        [20, 22, 24, 26, 28],\n",
       "        [40, 42, 44, 46, 48],\n",
       "        [60, 62, 64, 66, 68],\n",
       "        [80, 82, 84, 86, 88]]), array([[ 2,  3,  4,  5,  6],\n",
       "        [12, 13, 14, 15, 16],\n",
       "        [22, 23, 24, 25, 26],\n",
       "        [32, 33, 34, 35, 36],\n",
       "        [42, 43, 44, 45, 46]]))"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * 2, A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones elemento a elemento entre arreglos\n",
    "\n",
    "Cuando sumamos, sustraemos, multiplicados y dividimos dos arreglos, el comportamiento por defecto es operar **elemento a elemento**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    4,    9,   16],\n",
       "       [ 100,  121,  144,  169,  196],\n",
       "       [ 400,  441,  484,  529,  576],\n",
       "       [ 900,  961, 1024, 1089, 1156],\n",
       "       [1600, 1681, 1764, 1849, 1936]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # multiplicación elemento a elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si multiplicamos arreglos con formas compatibles, obtenemos una multiplicación elemento a elemento de cada fila:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   4,   9,  16],\n",
       "       [  0,  11,  24,  39,  56],\n",
       "       [  0,  21,  44,  69,  96],\n",
       "       [  0,  31,  64,  99, 136],\n",
       "       [  0,  41,  84, 129, 176]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Álgebra matricial\n",
    "\n",
    "¿Y la multiplicación de matrices? Podemos realizarla de dos formas. Podemos usar la función `dot`, que aplica una multiplicación matriz-matriz, matriz-vector o un producto interno entre vectores a sus dos argumentos: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 300,  310,  320,  330,  340],\n",
       "       [1300, 1360, 1420, 1480, 1540],\n",
       "       [2300, 2410, 2520, 2630, 2740],\n",
       "       [3300, 3460, 3620, 3780, 3940],\n",
       "       [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativamente, podemos transformar el arreglo al tipo `matrix`. Esto cambia el comportamiento de los operadores aritméticos estándar `+, -, *` al de álgebra de matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M = matrix(A)\n",
    "v = matrix(v1).T # aplica la traspuesta, convirtiéndolo en vector columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 300,  310,  320,  330,  340],\n",
       "        [1300, 1360, 1420, 1480, 1540],\n",
       "        [2300, 2410, 2520, 2630, 2740],\n",
       "        [3300, 3460, 3620, 3780, 3940],\n",
       "        [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M*M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [130],\n",
       "        [230],\n",
       "        [330],\n",
       "        [430]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M*v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# productor interior\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [131],\n",
       "        [232],\n",
       "        [333],\n",
       "        [434]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# con objetos matriciales, el álgebra matricial estándar es usada\n",
    "v + M*v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si intentamos sumar, restar, o multiplicar objetos con formas incompatibles, obtendremos un error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v = matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (6, 1))"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M), shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-94-995fb48ad0cc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mM\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m/usr/local/lib/python2.7/dist-packages/numpy/matrixlib/defmatrix.pyc\u001b[0m in \u001b[0;36m__mul__\u001b[1;34m(self, other)\u001b[0m\n\u001b[0;32m    339\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    340\u001b[0m             \u001b[1;31m# This promotes 1-D vectors to row vectors\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 341\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0masmatrix\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    342\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0misscalar\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mor\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'__rmul__'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    343\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mother\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)"
     ]
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vea también las funciones relacionadas: `inner`, `outer`, `cross`, `kron`, `tensordot`. Por ejemplo, introduzca `help(kron)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transformaciones de arreglos/matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes hemos usado `.T` para transponer un vector `v`. Podemos también usar la función `transpose` para conseguir el mismo resultado. \n",
    "\n",
    "Otras funciones matemáticas que transforman objetos matriciales son:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.+1.j,  0.+2.j],\n",
       "        [ 0.+3.j,  0.+4.j]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-2.j],\n",
       "        [ 0.-3.j,  0.-4.j]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hermítico conjugado: transpuesta + conjugado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-3.j],\n",
       "        [ 0.-2.j,  0.-4.j]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos extraer las partes reales e imaginarias de un arreglo con elementos complejos usando `real` y `imag`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.,  0.],\n",
       "        [ 0.,  0.]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "real(C) # lo mismo que: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imag(C) # lo mismo que: C.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos también extraer el módulo y el argumento complejo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.78539816,  1.10714872],\n",
       "       [ 1.24904577,  1.32581766]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "angle(C+1) # Atención usuarios de MATLAB, se usa angle en lugar de arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculos con matrices\n",
    "\n",
    "#### Inversa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.+2.j ,  0.-1.j ],\n",
       "        [ 0.-1.5j,  0.+0.5j]])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.inv(C) # equivalente a C.I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[  1.00000000e+00+0.j,   4.44089210e-16+0.j],\n",
       "        [  0.00000000e+00+0.j,   1.00000000e+00+0.j]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.I * C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determinante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0000000000000004+0j)"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.50000000000000011+0j)"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(C.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculos con datos\n",
    "\n",
    "A menudo es útil almacenar datos en arreglos Numpy. Numpy provee funciones para realizar cálculos estadísticos de los datos en un arreglo. \n",
    "\n",
    "Por ejemplo, calculemos algunas propiedades de los datos de la temperatura de Estocolmo que discutimos anteriormente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recuerde, los datos de la temperatura están almacenados en la variable data\n",
    "shape(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.1971096847515854"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# la temperatura está almacenada en la columna 3\n",
    "mean(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La temperatura diaria promedio en Estocolmo en los últimos 200 años ha sido aproximadamente 6.2 C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Desviación estándar y varianza"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.2822716213405734, 68.596023209663414)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "std(data[:,3]), var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### min and max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.800000000000001"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# valor mínimo del promedio diario de temperatura. Lo mismo que min(data[:,3])\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.300000000000001"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# valor máximo del promedio diario de temperatura. Lo mismo que max(data[:,3])\n",
    "data[:,3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = 1 + arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# suma todos los elementos\n",
    "sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiplica todos los elementos\n",
    "prod(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  6, 10, 15, 21, 28, 36, 45, 55])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# suma acumulativa\n",
    "cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# producto acumulativo\n",
    "cumprod(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lo mismo que: diag(A).sum()\n",
    "trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculos con subconjuntos de un arreglo\n",
    "\n",
    "Podemos calcular usando subconjuntos de los datos de un arreglo usando el indexado, indexado fancy, y los otros métodos para extraer datos desde un arreglo (descrito más arriba).\n",
    "\n",
    "Por ejemplo, consideremos nuevamente los datos de temperatura de Estocolmo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n"
     ]
    }
   ],
   "source": [
    "!head -n 3 stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El formato de los datos es: año, mes, día, temperatura promedio diaria, mínima, máxima, lugar.\n",
    "\n",
    "Si estamos interesados sólo en la temperatura promedio de un mes particular, Febrero por ejemplo, podemos crear una máscara de índice y seleccionar sólo los datos de ese mes usando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.,\n",
       "        12.])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique(data[:,1]) # la columna mes asume valores entre 1 y 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "masc_feb = (data[:,1] == 2) # los paréntesis () son opcionales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.2121095707365961"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# los datos de temperatura están en la columna 3\n",
    "mean(data[masc_feb,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas funciones ponen a nuestra disposición herramientas muy poderosas para procesar datos. Por ejemplo, para extraer las temperaturas promedio mensuales para cada mes del año sólo necesitamos unas pocas líneas de código: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAENCAYAAAAIbA6TAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkiRJkiRJkiRJkiRJkiRJklRn/w+IvphyhHV68gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f4bd9fbeb10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "meses = arange(1,13)\n",
    "media_mensual = [mean(data[data[:,1] == mes, 3]) for mes in meses]\n",
    "\n",
    "fig, ax = subplots()\n",
    "ax.bar(meses, media_mensual)\n",
    "ax.set_xlabel(\"Mes\")\n",
    "ax.set_ylabel(\"Temperatura promedio mensual\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculos con datos multidimensionales\n",
    "\n",
    "Cuando se aplican funciones como `min`, `max`, etc., a arreglos multidimensionales, a veces se desea aplicarlas al arreglo completo, y en otras ocasiones sólo por filas o columnas. Podemos especificar cómo se comportan estas funciones usando el argumento `axis` (eje): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.60959916,  0.51496133,  0.89085195],\n",
       "       [ 0.20147089,  0.64100653,  0.39383738],\n",
       "       [ 0.02230134,  0.77013792,  0.78870679]])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = random.rand(3,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.89085195401675488"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# máximo global\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.60959916,  0.77013792,  0.89085195])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# máximo en cada columna\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.89085195,  0.64100653,  0.78870679])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# máximo en cada fila\n",
    "m.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Muchas otras funciones y métodos de las clases `array` y `matrix` aceptan el argumento (optional) `axis`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cambiando la forma, redimensionando y apilando arreglos\n",
    "\n",
    "La forma de un arreglo Numpy puede ser modificada sin copiar las datos involucrados, lo que hace que esta operación sea rápida, incluyo con arreglos grandes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "n, m = A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "        32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1,n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "        32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modifica el arreglo\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # la variable original es también cambiada. B sólo constituye una forma distinta de ver los mismos datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos también usar la función `flatten` para transformar un arreglo multidimensional a un vector. A diferencia de `reshape` esta función crea una copia de los datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # ahora A no ha cambiado, ya que los datos de B han sido duplicados desde A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Agregando una dimensión adicional: `newaxis`\n",
    "\n",
    "Con `newaxis`, podemos insertar una nueva dimension en un arreglo, por ejemplo, para convertir un vector en la fila o columna de una matriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v = array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# crea una matriz con el vector v como su columna\n",
    "v[:, newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matriz columna\n",
    "v[:,newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matriz fila\n",
    "v[newaxis,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v[newaxis,:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apilando y repitiendo arreglos\n",
    "\n",
    "Podemos crear vectores y matrices más grandes a partir de otras más pequeñas usando las funcionesn `repeat` (repetir), `tile` (teselar, \"embaldosar\"), `vstack` (apilar verticalmente), `hstack` (apilar horizontalmente), y `concatenate` (concatenar):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### tile y repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repite cada elemente 3 veces\n",
    "repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repite la matriz 3 veces\n",
    "tile(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### hstack and vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hstack((a,b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy y \"deep copy\"\n",
    "\n",
    "Para alcarzar un alto deseméño, las asignaciones en Python usualmente no copian los objetos involucrados. Esto es importante cuando se pasan objetos a funciones, para así evitar uso excesivo de memoria copiando cuando no es necesario (término técnico: paso por referencia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[1, 2], [3, 4]])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# ahora B apunta al mismo arreglo que A\n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cambiar B afecta a A\n",
    "B[0,0] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos evitar este comportamiento, para así obtener un nuevo objecto `B` copiado desde `A`, pero totalmente independiente de `A`, necesitamos realizar una \"copia produnfa\" (\"deep copy\") usando la función `copy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "B = copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ahora A no cambia si modificamos B\n",
    "B[0,0] = -5\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterando sobre elementos de un arreglo\n",
    "\n",
    "Generalmente, deseamos evitar iterar sobre los elementos de un arreglo donde sea posible (a cualquier precio!). La razón es que en un lenguaje interpretado como Python (o MATLAB), las iteraciones son realmente lentas comparadas con las operaciones vectorizadas. \n",
    "\n",
    "Sin embargo, algunas veces es ineludible. En tales cases el bucle Python `for` es la forma más conveniente para iterar sobre un arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "v = array([1,2,3,4])\n",
    "\n",
    "for elemento in v:\n",
    "    print elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fila [1 2]\n",
      "1\n",
      "2\n",
      "fila [3 4]\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "M = array([[1,2], [3,4]])\n",
    "\n",
    "for fila in M:\n",
    "    print \"fila\", fila\n",
    "    \n",
    "    for elemento in fila:\n",
    "        print elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando necesitamos iterar sobre cada elemento de un arreglo y modificar sus elementos, es conveniendo usar la función `enumerate` para obtener tanto el elemento como su índice en el bucle `for`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ind_fila 0 fila [1 2]\n",
      "ind_colu 0 elemento 1\n",
      "ind_colu 1 elemento 2\n",
      "ind_fila 1 fila [3 4]\n",
      "ind_colu 0 elemento 3\n",
      "ind_colu 1 elemento 4\n"
     ]
    }
   ],
   "source": [
    "for ind_fila, fila in enumerate(M):\n",
    "    print \"ind_fila\", ind_fila, \"fila\", fila\n",
    "    \n",
    "    for ind_colu, elemento in enumerate(fila):\n",
    "        print \"ind_colu\", ind_colu, \"elemento\", elemento\n",
    "       \n",
    "        # actualiza la matriz: eleva al cuadrado cada elemento\n",
    "        M[ind_fila, ind_colu] = elemento**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cada elemento en M está ahora al cuadrado\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectorizando funciones\n",
    "\n",
    "Como se ha mencionado en varias ocasiones, para obtener un buen rendimiento deberíamos tratar de evitar realizar bucles sobre los elementos de nuestros vectores y matrices, y en su lugar usar algoritmos vectorizados. El primer paso para convertir un algoritmo escalar a uno vectorizado es asegurarnos que las funciones que escribamos funcionen con argumentos vectoriales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "    implementación escalar de la función escalón de Heaviside.\n",
    "    \"\"\"\n",
    "    if x >= 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-175-6658efdd2f22>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mTheta\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-174-d6359217b50a>\u001b[0m in \u001b[0;36mTheta\u001b[1;34m(x)\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mimplementaci\u001b[0m\u001b[0;31mó\u001b[0m\u001b[0mn\u001b[0m \u001b[0mescalar\u001b[0m \u001b[0mde\u001b[0m \u001b[0mla\u001b[0m \u001b[0mfunci\u001b[0m\u001b[0;31mó\u001b[0m\u001b[0mn\u001b[0m \u001b[0mescal\u001b[0m\u001b[0;31mó\u001b[0m\u001b[0mn\u001b[0m \u001b[0mde\u001b[0m \u001b[0mHeaviside\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \"\"\"\n\u001b[1;32m----> 5\u001b[1;33m     \u001b[1;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m>=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, eso no funcionó porque no definimos la función `Theta` de modo que pueda manejar argumentos vectoriales... \n",
    "\n",
    "Para obtener una version vectorizada de Theta podemos usar la función `vectorize` de Numpy. En muchos casos, puede vectorizar automáticamente una función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Theta_vec = vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta_vec(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos también implementar la función de modo que desde el comienzo acepte un argumento vectorial (esto requiere más esfuerzo, pero mejorar el rendimiento):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "    Implementación preparada para vectores de la función escalón de Heaviside.\n",
    "    \"\"\"\n",
    "    return 1 * (x >= 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# y también funciona para escalares!\n",
    "Theta(-1.2), Theta(2.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Usando arreglos en sentencias condicionales\n",
    "\n",
    "Cuando se usan arreglos en sentencias condicionales, por ejemplo en sentencias `if` y otras expresiones booleanas, necesitamos usar `any` o bien `all`, que requiere que todos los elementos de un arreglo se evalúen con `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "al menos un elemento de M es mayor que 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).any():\n",
    "    print \"al menos un elemento de M es mayor que 5\"\n",
    "else:\n",
    "    print \"ningún elemento de M es mayor que 5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no todos los elementos de M son mayores que 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).all():\n",
    "    print \"todos los elementos de M son mayores que 5\"\n",
    "else:\n",
    "    print \"no todos los elementos de M son mayores que 5\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conversión de tipo\n",
    "\n",
    "Como los arreglos de Numpy son *de tipo estático*, el tipo de un arrglo no puede ser cambiado luego de que es creado. Sin embarg, podemos convertir explícitamente un arreglo de un tipo a otro usando las funciones `astype` (ver también las funciones similares `asarray`). Esto crea un nuevo arreglo de un nuevo tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.,   4.],\n",
       "       [  9.,  16.]])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]], dtype=bool)"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lectura adicional\n",
    "\n",
    "* [Numpy](http://numpy.scipy.org)\n",
    "* http://scipy.org/Tentative_NumPy_Tutorial\n",
    "* http://scipy.org/NumPy_for_Matlab_Users - Una guía de Numpy para usuario de MATLAB."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}