01_00_Intro_DataScience_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](http://jrjohansson.github.io/) (robert@riken.jp).\n",
    "\n",
    "Traducido/Adaptado por [G.F. Rubilar](http://google.com/+GuillermoRubilar).\n",
    "\n",
    "La última versión de estos [Notebooks](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) está disponible en [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\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": {},
   "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 listas\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": {},
   "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": {},
   "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": {},
   "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": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "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": {},
   "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": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "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 matrices, 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": {},
   "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": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for long() with base 10: 'hola'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-fc4abc9a80ec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hola\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;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": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.+0.j,  2.+0.j],\n",
       "       [ 3.+0.j,  4.+0.j]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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. Algunas de los más comunes son:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# crea un arreglo con valores en un rango\n",
    "\n",
    "x = arange(0,10,1) # argumentos: desde, hasta (no se incluye!), paso\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -1.00000000e+00,  -9.00000000e-01,  -8.00000000e-01,\n",
       "        -7.00000000e-01,  -6.00000000e-01,  -5.00000000e-01,\n",
       "        -4.00000000e-01,  -3.00000000e-01,  -2.00000000e-01,\n",
       "        -1.00000000e-01,  -2.22044605e-16,   1.00000000e-01,\n",
       "         2.00000000e-01,   3.00000000e-01,   4.00000000e-01,\n",
       "         5.00000000e-01,   6.00000000e-01,   7.00000000e-01,\n",
       "         8.00000000e-01,   9.00000000e-01])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(-1,1,0.1)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### linspace y logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.        ,   0.41666667,   0.83333333,   1.25      ,\n",
       "         1.66666667,   2.08333333,   2.5       ,   2.91666667,\n",
       "         3.33333333,   3.75      ,   4.16666667,   4.58333333,\n",
       "         5.        ,   5.41666667,   5.83333333,   6.25      ,\n",
       "         6.66666667,   7.08333333,   7.5       ,   7.91666667,\n",
       "         8.33333333,   8.75      ,   9.16666667,   9.58333333,  10.        ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.00000000e+00,   2.71828183e+00,   7.38905610e+00,\n",
       "         2.00855369e+01,   5.45981500e+01,   1.48413159e+02,\n",
       "         4.03428793e+02,   1.09663316e+03,   2.98095799e+03,\n",
       "         8.10308393e+03,   2.20264658e+04])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = mgrid[0:5, 0:5] # similar a meshgrid en MATLAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [1, 1, 1, 1, 1],\n",
       "       [2, 2, 2, 2, 2],\n",
       "       [3, 3, 3, 3, 3],\n",
       "       [4, 4, 4, 4, 4]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Datos aleatorios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.24505667,  0.73920374,  0.43203417,  0.20683999,  0.6392161 ,\n",
       "        0.04194899,  0.13378878,  0.52801467,  0.69030967,  0.52480182])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# números aleatorios con distribución de probabilidad uniforme en [0,1]\n",
    "random.rand(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.98227309,  0.461191  ,  0.72575093],\n",
       "       [-0.60268008, -2.27446301, -0.12867387],\n",
       "       [ 0.19399359,  1.51916762,  1.15105401]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# números aleatorios con distribución normal (gaussiana de media 0 y varianza 1).\n",
    "random.randn(3,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# una matriz diagonal\n",
    "diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "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": 24,
     "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": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.]])"
      ]
     },
     "execution_count": 26,
     "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": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = genfromtxt('stockholm_td_adj.dat')  # asigna los datos desde el archivo 'stockholm_td_adj.dat' al arreglo data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ¿qué hace esta línea?. La respuesta en la clase 04\n",
    "%matplotlib inline\n",
    "from matplotlib.pyplot import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABIgAAAGHCAYAAADbQmmxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAAPYQAAD2EBqD+naQAAIABJREFUeJzsnXe4HVXV/787NAEFREABX5qoFPWnIv1VFJQu5bUgRUBF\nEAHpTUB6kRYEpIlEinRCCBAJJfTQO6EEQgs1QGiBAEnu/v0xZ3v3nbNmZu02Myd3fZ7nPufcObvN\nnj27rL32WkprDUEQBEEQBEEQBEEQBGHwMqTpAgiCIAiCIAiCIAiCIAjNIgIiQRAEQRAEQRAEQRCE\nQY4IiARBEARBEARBEARBEAY5IiASBEEQBEEQBEEQBEEY5IiASBAEQRAEQRAEQRAEYZAjAiJBEARB\nEARBEARBEIRBjgiIBEEQBEEQBEEQBEEQBjkiIBIEQRAEQRAEQRAEQRjkiIBIEARBEARBEARBEARh\nkCMCIkEQBEEQBGGmQCn1L6XU802XQxAEQRB6EREQCYIgCEIPoZRaVSl1sFJqnqbL0jaUUpsrpXZt\nuhxtRyk1TCnVV/D3kWNa6ymlDk5VVg90508QBEEQBEdmbboAgiAIgiA4sRqAvwAYBuD9hsvSNrYA\nsDyAvzVdkB7gYwC/A6By12c4prM+gD8CODRGoQRBEARBaA4REAmCIAhCb5Ff0M+0KKXm1FpPlXIk\nYbrW+qII6Qya9igIgiAIMztyxEwQBEEQeoTOUZ5jO/++0DkSNEMptZgVZiul1P1KqY+UUm8rpS5S\nSn05l84tSqlHlVLf7Hz/UCn1jFLqZ53f11BK3d1J4yml1Fq5+Id08v66UupSpdR7Sqm3lFInKaXm\nIMrtUqbvKqVuU0p9CODIzm8bK6WuUUq9opT6WCn1rFLqQKXUECv+zQA2ALC4dVzquc5v23b+XyyX\n5xqd6z+IVY5OuKWVUlcopV5TSk1VSk3s3PPnyp8woJRaWSl1nVLq3c5zuUUptVpB/X+lY3PnnU74\nc5RSn6nKg4tSatbOccbxnft4Syl1u2kPSqlhyLSHYNX5DCv+XEqpE5RSL3Xq6yml1J4FeW2llLqn\nc8+TlVK3KqV+nAvzR6XU4520XlFKnaqUmrfiHkx72KMTf4JSaopSarRSatFOmIM6z+gjpdQIpdR8\nRDrOeQuCIAhCryEaRIIgCILQO1wB4GsAfgVgVwBvd66/CQBKqQMAHAbgYgD/ALAggD8BuFUp9R2t\ntTmSpgHMD+DqTthLAewI4CKl1FYATgJwGoB/A9gHwGVKqf/RWn9oxUcn3vMA9gOwSiev+QBsawrs\nWKYFAIzqhD0PwBud37YB8AGAEwBMAbBmJ83PAdi3E+YIAPMCWBTAbsg0W6ZYaRfZpclfDyqHUmo2\nANcDmA3AyQBe75Rpw07dfFBQDiil1uzkez+AQwD0AfgNgDFKqf/VWt+fK/OlAJ5DVv/fBbBdp6z7\nF+WRy+8LxOVPtdamjId20j4LwH0A5gHwvU5eNwE4A8AiAH4MYEt0axNdDWANAP8E8DCAdQAcp5Ra\nRGv9X0GRygSfBwO4E8BBAD4FsDKy+r2xE+YQZEcrr0fWNr+OTDj1PaXU6lrrqqNxW6H/mcyP7Hld\nppQa0ynjMQCWRtY2j0dWl6Z8oXkLgiAIQm+gtZY/+ZM/+ZM/+ZO/HvkDsCcyOzGL5a4vBmAagH1z\n15dDtuDez7p2cyeNX1rXvoZMIDENwIrW9Z90rm9tXTu4c214Lq9TO+l+I6BM2xH3PAdx7XRkwpbZ\nrGtXA3iOCLtNQZ2t0bn+g1jlAPD/OnWzqcezfRrAtfk8AUwAcB1R/2flwl4BYBIjn2Gd+NTfKCvc\nQwBGVqR1CoAZxPWNO+ntl7t+CYDpAJbs/P+Vzv+XleSxADKbSaNy1//YeVbb5O7tOev/xTvleB3A\nZ63rR3auPwhgiHX93wCmWs+Tnbf8yZ/8yZ/8yV+v/8kRM0EQBEGYOfgZMg2Oy5RSXzB/ACYBeAbA\nj3Lhp2itLzX/aK3HA3gXwJNa6/uscPd0PpfKxdcA/p67dkqnDOt7lukTAP/K35jW+hPzXSn12U4a\ndwCYC8Ay+fARCCnHe53PdZVSc3IzVEp9G8BXkWlx2XX1OWTaOj/IRdEAzsxdux3AF5RSn2VkORXA\nWsi0f+y//aww7wJYXim1NPc+LNZDJvg5JXf9RGQmDtbr/L8psjZyWElaP0am/XNS7vo/kAnnNmCU\n51Kt9RTrf9Ouz9da9+Wuz45M6ytW3oIgCILQE8gRM0EQBEGYOVga2cL7WeI3jUxjx+ZlItx7ACYO\niKj1+0opAPg8ET6f17PItDIW9yzTK1rr6fmASqnlkGl8/AjZMSc7jRR2YLzLobV+QSl1AoA9AGyl\nlLodwEgAF+j+43QUX+18nlfwe59Sal6t9XvWtZdyYd7pfH4e/cfripihtb65IsxfAIwAMF4p9TiA\n/yC7j8cq4gFZG3hV9x9LNDxp/Q5kgsc+63pRWgAw3r6otZ6mMjtTi3dH6WJi7n9Tj/n3wFz/PIAX\nIuUtCIIgCD2BCIgEQRAEYeZgCLKF9rqdzzx5gUGR3ZSi6z7eqlzL1OUprGMI+DZk2iwHIrO58zGA\nFZDZjeFoQxfZH5ql4HpQObTWeyul/oXsmNXayOze7KeUWkVr/WpBnib+ngAeKQjDfYZRPItprW9X\nSn0F/fexHYA9lFI7aK3PqYheVIb8s+CUNcb9+LZ38dImCIIgDBpEQCQIgiAIvUWRsGMCssXsC1pr\nSmMnBV8F8KL1v9EYeiFimX6ITJtjY631neZiR3CRp6hujGbNfBiodbNEonJAaz0OwDgARymlVgEw\nFsAfkGnlUEzofH6gtR7jUK6kaK3fBXAugHOVUnMhO8Z2CAAjICqq8xcArKmUmjunRbSc9TuQaZcN\n6Vx/tCQtIDMObb4bg+BLAriBcy+eNJm3IAiCINSK2CASBEEQhN7CLLbzrriHI9PSOZiKpJSaP3I5\nFICdctf+hExgcF3EMs3o5GW7tJ8dHffqOT4EfeTMCKpsd/ZDAGzPyN+pHEqpzyml8ppJ45DVwxwl\n6T/QKedeSqm58z8qpRZwKGsU8s9Ha/0RMoGOfR8fdsLaR+6AzBvbrAB2zl3fHVldmDYyAlmb+Yvq\nnGUkuBGZsfM/5a5vh+yo3zVV9xJAk3kLgiAIQq2IBpEgCIIg9BYPIBNUHKWUuhjZ4nWk1vo5pdSB\nnetLIlt4f4DMxssmyAwanxi5LEsqpa5CtthfFZkr8f/aqIlUprHINIDOU0qd3Lm2FWjNlQcA/LJj\nA+g+ZIa4r9FaP6GUugvAMR3Dz5MB/ApuG2XccqwJ4FSl1GXI7NbMCmBrZAabryhKXGutlVLbIROs\njFNKDQPwCjJjyT9CZhtnY4fyVjGrUmrLgt+Ga62nAnhCKXULsnqdDGBFAD9HdmTOYNrjKUqp0chs\nG12itR7ZcSF/pFJqKfS7uf8pgKFa6+c79z1BKXUksmN7tyulhiMzEr4iMltQB2it31JKHY1MiHQd\nMptOywDYEcC9yDyPxeS/gqoG8hYEQRCExhABkSAIgiD0EFrr+ztClz8gW3APQXbU5SWt9V+VUk8j\n09IwR5kmIhPgjMwnRSXvcF0D2AzA4QCORiYAORnAPrnyBpVJaz1ZKbUBgBM6eb0D4HwAYwCMzgU/\nDZmb+W0B7Ibs+JvR8NgSmUBqX2R2hM4GcAvoI0Ih5Xikc28bIhPufNS5tq7W+l4iLzuPW5VSqwI4\nCJl21ucAvIbMs1beY1koc6DYIPbtyI7i/Q3ARgB+0gn/IoA/AzjeCjsc2XP/FbI6Vshc2aMT9zBk\n7WQbZEe09tJaD7Uz01of3DH4vAuAI5DV2aN2+bTWhyqlJiHTSDoRmcDqDAAHaK3zdoSotlrUrikG\nXHfMWxAEQRB6FqV10dgoCIIgCILQjVLqYGTCngW11pObLo8gCIIgCIIQjtggEgRBEARBEARBEARB\nGOSIgEgQBEEQBEEQBEEQBGGQIwIiQRAEQRAEQRAEQRCEQY7YIBIEQRAEQRAEQRAEQRjkiAYRAKXU\nXEqp7yql5mq6LIIgCIIgCIIgCIIgCLHgyjzEzX3GtwHcCWBLpdRTTRdGEARBEARBEARBEAQhEssA\n+DeA1QGMLQokAqKMJTqf/26yEIIgCIIgCIIgCIIgCIlYAiIgquQFALjggguw7LLLNlwUQRDqZPfd\nd8fQoUObLoYgCA0g778gDF7k/RcAYNgw4NRTgeOPB370o6ZLI9TFYHz/n3zySWy11VZAR/ZRhAiI\nMj4GgGWXXRbf/e53my6LIAg1Mu+888p7LwiDFHn/BWHwIu+/AADXX599fuUrgDSHwcMgf/8/LvtR\njFQLgiAIgiAIgiAIgiAMckRAJAiCIAiCIAiCIAgtZMstgXXWaboUwmBBBESDiOnTgR//GHjyyaZL\nIgiCIAiCIAiCIFRx4YX9R+FmVl5/vekSCAYREA0iXnkFuOkm4LDDmi6JILSHzTffvOkiCILQEPL+\nC8LgRd5/AQCUaroEwvjxwMILA5dcUl+e8v4XIwKiQYTWTZdAENqHDBCCMHiR918Q2suUKdni/dJL\n06Qv778gtINXX80+H3qovjzl/S9GBESDkIsvbroEgtDbPPaYCFwFQRCE+njnHWDixKZLUS9vv519\nXnFFebiPPwYWWAC4++70ZRIEIT6ixdUuREAkCDMBU6eKwKIuHn8c+Na3gH/9q+mSCIIgCIOFZZcF\nFlus6VK0k1deyYRJp5zSdEkEQQhB1jJhPPQQcMAB4emIgGgQIS/dzMtccwFHHdV0Kepl4sRmtOHe\nfDP7fPbZ+vNuG2+8AZx3XtOlEARBmPl5442mS9B+ZJ4rCL3JsGHZ5zvvNFuOXmf99eOsB0VAJAgz\nCddc03QJ6mXttYEmjg/LBLSfLbcEttmm6VIIQhpGjcrU3j/6qOmSCEJv8MorwBNP1J9vrxxPeeAB\nYPLkpkshFCHzu+a48cbsUwRE7UAEREKjTJqUnR0X/BmsA1rTk6xemZCm5L33mi6BIKTD7GgaOyiC\nIJTz5S8Dyy/vF1frcBtLbR+Xv/c9YJ11mi6F0HamTRt8Lt9n9rXM9OnAaqsBjzzSdEl4iIBoENHG\nl++LXwQ23bTpUgi9SBvbsyAIMw+33ZZ93nprs+UQhMHAKadkNpYmTfJPoxfmBU1oWAm9xQ47ZC7f\nBxPm3W27kNeXN94A7roLOOKIpkvCQwRELeall7IX5ZZbmi5JxpQp1Z4kfLjuuvhpDiZ6YUI0MyH1\nLQiDA7NQfeaZZsshCIOB++7LPkUzVRjs3HRT0yUYyMiRcvQrlF5bO4iAqMU8/XT2OWZMs+Uw7LEH\n8POfA2+91XRJ6mP8eGCWWcQ4ZBvptc52ZkaehSAIRWy+ObDLLk2XQugVZvbxZGa/vzbxzDPABx80\nXYreZ+ONxd5kKL2mISUCIgZTpgB9ffXnaxpRrMEkNB3jvWnGjPCy9ArDh2fP/u67my5JMYN1stHU\nfTfZuU+aBGyxBfDJJ82VQRAEwYWLLwZOPbWZvM84Azj//GbyFtzolYWT0Dt87WvAeutVh5O2V83M\nslH+4YfxtaE++KB6TSICopmQz30O2Hvv+vONLSAKpS3lqBPzDJoQEArlpGiPw4dX2wdo8j0YOhS4\n6CLgzjubKwOFT5309QEnnihG6gWhF7j66t4xrmmz447A1lv7xZ08GTjttLjlEfyoGmOKFl3jxwOX\nXRa/PELvcM89TZegt6l7zptagPLZzwLzzx8vvWnTgHnmAf76V7/4Z5/dTuGbCIiYjBzpF+/ww4Eh\nM1kt94r0Mwbm2XE6yDFjmnGHPBgFd0Ca+/7Zz/geWAbTexDKdtsBSy458NqYMcCeewInndRMmQRB\n4LPRRsC3v910KerlT38CdtopzGiyUC/PPTfw/+98B/jlL5spi9AOZK4Wh9T1aDbie+15TZ+efY4e\n7R53xgzg978Hfv3reOWJVX8zmegiHb6L0cMO6457+OHAvvtWx42tvdKWo2pVvP12e4wUcrW4PvwQ\nWGstYNdd05dJyGhKMOaS73rrAVdeGT/vtg2gVXXyz38CL7ww8Nq0admnHJcT2s5gFcIPdqZMaboE\ng4uycY075uW1RZrYtBMEYfDhc8TMXPvww/rKwUUERA3wl78Axx7bdCmap6gRL7AAsPji8fIZOtTf\nrShXQGQkyC+95JdPCLJ4aS/XXQdsu61f3L4+4M9/po3C95qASBBi8s47wH77DS57eDEYMQK49tqm\nS9E7tFUg3wu8/XbTJRAEIQaDdX53yy3AhRdWhysaH84/H7jttv7/y8aTNo4xIiBKTMhDL5I2nnfe\nzLHrXrazE1ODaI89gDXX9IvbSzaI2tjBpGRmH7SefBI4+uhsIWyYGe/5kEOaLoHQaxx+eHbe//77\nmy5Jb7HppsCGGzZdit6hV/vbCROAm2/2j7/00uGbdCHaV71a71wG21zNhUsvjX+CwKW+e6Htvfhi\nM/kOtnb7ox8BW27ZfV2pgfNyow2fbztbbw2ssUa68hUhR8wGEfbDfuSRzNXgkUe6pxOr44vV+Kh0\nnn8+Ttp5fO/dlNF3wLr33vS73L0woKVgsNy3fZ9m0t82AfFgeRZCOzDtTdqdEIt7783G+/ff7/4t\nv0nXZq+mQCbg8d0UAzIBU6g2tM88cbAsQGP2W8cfD3zjG/HSa5IPPwQ22wz4wx/ipGeElJ9+Gie9\ntvDMM/XmV9c4W6RhM3Ei8Oqr9ZSBy7nn9n8/++zs09YWKqNX+jkRECUmdkMwC8O22OgJgaqbtnXk\nTz6ZfW6/vXvcl18GVl7Z37K9UE7TWl2+7/aGG2ZeFLjp24Pzffdln5Mn++WdirYs1EeMAA48sOlS\nCKmpe4LVlvYtpOO887JPe/FFPfcRI4BVVwVuvNEvn7b13W0i5D3rlUVXbPbeGxg3rulSxMHM6WK9\nI6+8Ehb/o4+AqVPjlEWopkhAtNhiwKKL8uLX1b/aZeTaOaP6t6eeyj4565kbbgB2352XVwxEQMTE\nd+AKEXhQeTY5UY2ddy9Muv/xD144anJidi9SS/t7oR5nJkLr+9prww3SDdbJcBWbbuqnXSn0Jr3W\n92kNnHhiZkNJ6B3s/vbll7PP1193T+eOO4AvfKFbA2nChIE70imoIw+BR4rx++mn46dZN7EN9s4+\nOz8s9Uzmmw9YaKE4ZYmJbJDQ7LRT1r9+/HH6vOxnMMssvDiUAGyffbJPjs22tdeu1+uvCIh6AMri\nuU8H0fRLPnr0QGk8VZ7LLquvPDFpum6BwSc0aEOdN0XbnrXPsxjMz8+Xl14CHnyw6VKU88QT6Rcr\nXOcBRbz8cr82Xp289BKw55717gIKPCgXy1T7Cml7RtMj7zTjhz/0d2bAZc010+dhE3LEbGYfG1J4\nVltllfhp+rDPPv7zk9tvzz7vvDNOWVwERBTTprXTk2FT8782zTt32AH4/OcHXjv99OwzpYBo+PDs\n036HuQKiXkMEREza9GIAzZQnJM/Jk4F11wX22qs8nFHzFvjM7JMpINv9zNty6pX79n1vYrj8rYte\neRa9zuKLAyus0HQpyll+eWCZZeKl19cHPPvswGum/ZsJoSvLLgustBI/vG/7Xmst4OKL+/83fVjb\nbIgJ/VR5mInR9+bHspBF6NixwNe/3u9J1cZeKLVxoVtE28a3XiCmm+wQjjvOP26ovc7x4wf21T4L\n916Yy8ys74eLAsRZZwHvvlueTgouuCD7tPMO0SAy+GoVv/lm97G6117LPkPnGSIgYtKWTqNXj5iZ\no3a2obG21GlboCZ4M3O+XKZMyYxuHnrowOtGgm88CISSyqZRm+yFTZ8u750wkLa//8cdB3z1q8Bb\nb3X/ZiZrrrgulk87zS+fMWOA3/2u+3peS2WjjYDddvPLQ4hDkdfYqvAumHZ32GHucYs4/PBsYfzB\nB92//frX/d/NIqLX+n/uYnhmXTRzacP9h7atkHt4/PFMUPrHP8ZJz5Vjjum3WTqz4fJcZ8wIn5O3\noS274CqIpO7vzTf98l5ooexYHUWoDS4RELWYMmljLx4xA6onX6nKyEl3xoxMKu2zixHaoV13HTDb\nbMALL7jHDamzV17J8r36av80UmOEiw88QP9+/fVx8nH1oFfXIEY937339ktrttnCdviKkCNmvUkv\nvP8PP5x92jvkdU8gY9kMotr8pElZ/f/tb3HyEPwoExDZ1266Kft87jn3PIxGj7FjVMaDDwJ33eWe\nh80dd3RfmzgxLM2UtM3uZi/RhkV1qJbakIAVqdGaOOOM/ms+bce3HvffH1hvPb+4rrTliNnzz2c2\nNW1mnTX8aF/oO5+yz6DS5rbbuvu3oUPD4ouAqMWENKZPP81e5lGj4pYpJm0b+C+8MDvXGmIHybfj\nvuWW7NNVSAGE1eOLLw7MPwazzAJcdFG89EydFmn4tGFilBLq/kJcEF9xhX9cYebCtKOY738d9Po7\n3+vlnxnhzreMnZQJE9zzcHnuK6wArLZadThXLae65l2cex07ltZgpI6OtG2+2Dba0KcUleHxx7Pf\n7BMEb77ZrXFDLbQnT87ipyaGpncbnkEKit69FVbIvPK2AVsDp24BUWzuvDNrS++/H5bOlVeGxRcB\nUU1cdZV/XB8NItPZ+dpoKCOWtkCZAcgmMEeWQtxaNqliG3IG3Ve9kaKvDzj2WF7YDz7gG2wsqptY\nbYbySvPQQ8BPfzrwudY1UTWDw6RJcdNN8Y7ZdfLRR/RxB6E+3n0X+NGP6GNZFPm+Y9IkWZDFwu7f\nYizYY/cHQkaZxrb9jEIMKacew/Jw2ptLe3IJW3VPEycCq68OHHVU929rrsnPx2DcRTdBX1/cOZQP\nbRBOFJXBaKjajgG+9S1gueWq46+xBvDNb/qVx+Udje39dOrUsAV+yCZgKvLPp0yz1q776dN5XrpC\nnDD1ghc/6v6oezW2eM0Gvi+hfYIIiJhwOpr77gMuv5z+bZNN/PP2afiXXJJ92sY9Qyf8sb2+1Lm7\n1YbBMxWmzh55xD+N889vZlE/zzzAV74SlkasZ3vOOd3X9tgDuOaaetxm5tlpp+zTVuH95S/90zPt\nJMVunP3eLrFE9lxd4ghxueaaTCvIjANFmGdw5pn9195+G/jiF9NsLrSZl14CTj21nrx8+6wrr8ye\nTZOL4Zkdrhczc/TRN+1YuKZp39Pdd2ft6dZbq+OZthdrIWbmG7bWtCkbtWlkNLeKmGuuOOXy4Ygj\nMlsgTdpza8Mct6gM1HtEbcjde2/3tTq0h2xizUu++U1g3nnjpJWnDc+6Crsed9wRWGABfhyf+5tj\nDjrvGNjCuhhHzLj3F1Ph4KmngGHD3OKLgCjHl74EbLyxX9yVVgJ+8Yt4ZTFq/9Qkv6qBGVfIoUaq\nbMwZ3160N9J0/lWEdIxFjB5drTab1/woY4450gxM1ETBhVhGoLltpCjcvff62ZAqgrK5xJ1wfPhh\n9qxsgbUpd2pvJ03vpOZ58kngsceaLoU7Cy+cTTxCXCL7vK/meEeo/RMfpk5tzh7S4osDu+ySNo/Q\ncciM6zHtyCgFnHBCvPTq4qmngEcfjZde2YYVpUFqXNa7kFp70xUj7KkSOGoN/P732XeO/SQXqurE\n/F41T1hkkTjl8eHmm7PPUC9cIbRBaFAlIKoq48EHx8+7Tux30ecIqmHkyPLfY97rqFHVtqNCxy2u\nqZOQfFJq+b/xRvnvIUL6lGtTu1yrrAL89rdu8UVAlOONN6pfzrr4z3+6r3EbU5XdlhB8GvQ//lGc\nTqgGic366wMnn+wX1+wIhizIqPrO19eFF3a7WDa7aDGNj6+7LrDNNn5xKYyx6FjEWuTEOnLhqtGW\nf1YrrwwsuWScsoRiPNZcemn/tV4/l+3Lcstl6uw+UO9qKNtsAxx4YHW411/P6nXPPd3ziDXRqpt9\n9sk8elUtBtuwGAiB6ymrLs46K15aY8cCiy5Kjxc+QpUill0W+H//L1563EVsyPMKMcJbRdXROOoa\n97jc2LG8IyJFnHhi9l5T5Yj1Ljf5HhnNF1vTeNq0eo+9tMXNfRl199tt6FvzvP569dHv4cPrKcvU\nqcAGGwz0/KZ1cT+dd6deBtXP9Cp2+WPIB5rwzOizrhUBkSfXX+/v+jYEalCdPBnYfvuBEzIzEWnC\ndorW3UdyDjmEDpcn9IX4z3+AXXf1i2u8H9jH8riYjvPGG6vD7rhj93G9EMPYZWqDLhpk3PYRa5fM\ndRAsyrfuCabJj6OW75p2rHSoib/L4uzTT92ecy9qFXL4wx+ydzVUy83mvPPc7B3Yhj1dCXk3mpjU\nmXquEkY3OeGkxjeXuCGMHx8Wv450jzsua7OUQOFf/+r//vjjwAEHDPx9ypRMU8WezH70UXatrgUw\nJbzjzKNCjiGHtOfRo93C+wiIijQMpk0rPlZl39Oee3ZrBnI3ZOoYJ7TOjpP7eKYD+tur0bIHMq9W\nyyzTzPH0pvB5VqEu0bnE0jTntvkiFl4YWHDB8jBVbtNjjX9mQ9tut2efDXzjGwO1Cs1zzRsVT0Xo\n/bV9blnXEbPQ9b8IiDxZZ51+GyGp4Gr/DB2aaejYC1bTAEO0YYqoamhHHgnMOSf9W5UL2Ta82D6T\nBJfJa+zFTd3G2Tj2Lzj36Oo5qcidfaxdWa7A0oRzKX/d7Zoq96ab8uPPMUdm5LjNXHNN3IXtiy92\ne3gzdjIOOihePnXQqxpE1IK1DWOCzeGHF49vXKqMVBZhawT2Optu2m2g+NxzswWK7X3lkkuyaxde\nWG/5ilh22e5rb7yRtYkqm191wxW4VG0kFb2DX/gCsPTS7uWyaYN2wUcfZfPoHXaIl+ZDD2WfTR47\n8+WOO2h7QL6U9eGUS3QfI+VVxBLUzT03sPzycdJqGuq5mPWEreU0dmyctH24447m8uYScsSsLoxQ\n0+UIvwiImLRlkuqqQQDEPzNeVYYy13ptnvgbqlzNf/KJX6fFIfZkyVddfq65gL/9zT/fOp9tSg0i\n7n0YGwQ2ttHvlBpEV12V1QG1ExfyvlUZBa0qVxUnncQPO35895HEn/7Uf6L24INZndmaQT/8IfDz\nn9P3cvaTiPb4AAAgAElEQVTZ/d832yzNBLaIMWP84/aaBhFXo8Fl1/mFF9zsQYSMbz5pF+X3+utx\nj2RRPPNM/DTLjg61QRhguPnmgZtwXBtElKDd9CP5TYOHHw47mhUKd5PR14PTBx8Ue9qhnrVty6OO\nI31N0qvlBoDvfz87Mm8zbly4Ji33/V9ooeowY8ZUH2PyeQZV9mamTSvemOrV45LUhoXdd1D2MKvw\nOWJG9Qn33++eX2y4dtJ6AZd5vQiIWoTLcaCqBmlrVVTtYFx9NbDllvy8q17EXh4YOeyzTzaAGmOu\nADDrrN3hzLGz1EZ7U9T31KnAYYfFT7cJttmGt6gLMVJ9/vnd12yvcinfiX33zT7tHR9qoZ3CHpnB\n5/5cBB9f/zqw2GLd1329xqywQvZpG682BsYp2282l15KCwRTUWVAkqJXNYgoqLHuxBPpsDNmdC9i\nllzSTcuhjveEo/W4zDKZqn9ZOmVw5hPXXUdf33prYMQI+reQ+vERWKdoj/femwl5bduIIQKLojJ+\n5zvNamJSNkPssoYIO6ug6sQW6PeCgOjWW7ONCC6UsfdeWjyW8Y1vZONwGUXPypxk4NbFxReX/37L\nLcBaawEXXMBLz4UQjS/ftvrxx26C5JSCqBRavO+84x83pfmCWGN9qo399dbjx6Hm06FC054TECml\n9ldK3auUel8p9YZS6kql1NdyYeZQSv1dKfWWUuoDpdTlSimGTLos3/LfQ1+gRx4Bvvzl7NhEWZ7U\n8RZjr8FWoXRpGP/3f/Wpbzd1nOzNN+O5IDVH0OxdbONi1TZoa9yT5y34l7WlWEaqY9RtSBp1Toqq\n8jrvvKyNVxFiE4sKV5exe6MSbFTa7fLUJSCamUgp0LX7oDqeRywNor6+zI5cLDsOLrj0Q/vvn9l4\nqCs/XzjjYFldVz3XUaOy+YTdJ1AUHRc+//ziI6lNGNiMnZ4RnFD2vXxtEOXjGjgeFF2Mv4biIyCy\n43zyCS8OVRcxtal++MOBNq1c3ttx42jhYJ7ttx84J6/C1jStoqq8d9/dPS+/8sp6NyfyvP++X7yj\nj45bDtOOqjSa2rbZUaSx+eMfD3QDX1Vun77w4YcHvi9VaYcKiEycadPC7Mf5nJrhxrHb5YgRxWYj\nmjrZ4WJ/kjJ8TuXjcvql5wREAL4P4BQAKwP4MYDZAFyvlLKtApwEYAMAPwPwAwCLAMhZl3AjdUfz\n7W9nn/ZuBZWncQNpGzk2O3324OTSoCnByR//WO2ysggzKa1aANVtkJBjQNoFu6zGYHnoue0mvTzE\nrPs6B+aUnmG4u5zU77ZWWcojZtzypHwmbZuIcan7GIytnRRLQPTWW92aILEFxPfcAxx6aPaXkrIj\nZpznctxx4WVom6ZdFRMmdNuI2GCD7DO1nURXuLaX6upPYm38taH/49qbDC0rV2uDW7dVC7ui8t56\nK/Cb3/DKkmfllTPhT56pUwf+T93D1KnA5Zf75Wvz0kvlv6+6ardm///9X73Hm11JIdjoJarub911\n6et33lkcx+d9XXHFbq3Z73yH977EcnBk4rhslNqnMlzz9imjXe+bbuqv7clt12at7qJRxZ2PcO/f\n5Vh5zwmItNbra63P11o/qbV+DMC2ABYDsAIAKKXmAfBbALtrrW/VWj8E4DcAVldKRXZYbJernjQp\nz0mmAdmqkfai2adsp5/uVi6KvOZMPi538R2LWM+IKi8lZGty0hgjb04n9uST6b10VN3LHHP0f3/3\n3WobUr75lFElaKhKe+pUnvFvV+0W0SDqJ0RDjMJnV6zK5okPm2xSrIocawFsBOCpd6/LBEQp+lNq\nR9xXS2rFFfs9YabGfq5LLw2svjod7q67ytNpUmjctvGxTGDRBgFQFfvswwtX5SGQwr7/ued2jx+b\nhx8Oi5/vu81xzLKFuuGAA4Bf/KLY9hKXoiOcqfjVr4C99643z14k5XqEq33nylNPDRRu3n+/m909\nSnBvv/OU7TAuKezcVVG3YN9VQFRl5yqvvQ30m0BwIXQe1XMCIoL5AGgARkl3BQCzArjJBNBaPw3g\nJQCr+mbS5skORd0aBBRVtjPaVmcGHxeELi9iyAA0dmy3a2AqH2OpPvXRyOWWy7TN8lD5XnstcPzx\n7nlXhfuadcB0pZWApZbipeuaTxmUFpPLDsy229LecfKUvVO2h6MUR8ymTCm+j5jv8owZabwvxuaz\nnw2Lz30e669f/jtla8bHqGQe+x02R2BcnovPM6xbo4vyAPmDH/ildf/9wI478sL2mhtf+ygHdy4U\nco9NaBBxhUFtnbdQRwwouIKkIjbckBeOsykC+M1RqL7FDmfb/+NQtXC3F9uTJmWfVYI2s2lY5CTG\ntrPjY2fOlUsuGTj/8qVMOFf3u2GbeaBsB9VVHtN+UoxV1D0MHTrw/2WXBX772zhpmw1f+9hriCex\nvFYeh7pMkXDnYFXP1VXw53J/5ndjsqQqXEx6WkCklFLIjpPdobV+onP5SwA+1Vrn9wbf6PzmhNlN\ndNktqLuTpCZkKSfVIQv7Kjf3NlVS1jxV9ha4VNmw4ArffNpB1XNba61u18BUPpts4p63L3a9F93z\nDTdkE8vUO1ghuxWx2rVP2lxPDWUaHOee212eWAKiDz4APvc54Mwz6d9j9nmzzppml5r73OrSaOQu\n6Ix9MxdOPTX7zN/L+ecPFCi59mUudePiaSxfnlRHXzlwNPkGGz4LWG6faC+0zeLEtg2R4vlzVfwp\noVFZeXrhCM2jj4bFj3WPq67and7jj/unZz+XLbbwj2tjFsm77dYdtqoeTD9yyCHl4S64IBtbXee7\nTRFioy9W2zHzJXuzNKU2SFXaZoyOJVyuCmd7t3zwwezTNjtSxmuvdV+z7/n667PPorleHcQ63hYr\nXBW77BInHQqu0XTu/NZlHdDTAiIApwFYDsDmjLAKmaZRIbvvvjuAjQBshI02yv7OPfciVkFSTGhd\nG7ktqW2DgKiKP/2pPD2zU8PlySf5Ye+6K9tRsZllluzzS0wxou8zD6m/tu5eVrH22v5xfQZdF+Nu\nhirPGYYqd/IUTQmNY/VLRlB+003l4QQ+v/sdLxx1Lt+XrbceKDzmLnZ92s5ss5X/Pn16t124Mi2O\nXlh8V3Hyyf5xbUFK3XVRtEH2ySfdQuuyY4L25NQ4e7CP5Zlj6S5juQ/GtgulGeXTlzd5VK+O9OqK\nQ2n++Cz2QurMti9UduwwdFPIvAvGbITrfLeM3/420+4uy7cJYvVbxxwTJx0uEyeW/15Wp/Z8MdZ7\nZNej8cjKPVL2i1/w0g5tJ7GO58bue2wBZ1PzchfMaRBfLrroImy0USbXADbClCkbdWQd1fSsgEgp\ndSqA9QH8UGttLwdfBzB7xxaRzULItIgKGTp0KICRAEZi5Mjsb5NNOLKngXAbQazzqCYde/FGdcSn\nnBInPy5VEynK0J/9u30Pb71VvYvpMvistlp2JtvGSGptTYyyfGIe38mnXYSrcKIOF7JNLNxslVfq\nHjieY1yw39VeOP5EkfJZ94LgMnUZXc+I225JTzgB2HNPv3RdvSJWeaKh6smMLS4G4fN5v/12polm\nOOAA4Cc/GThuXXZZ9mkb8zb4CH3rguvdh7JRxG2Xtt2Uujeh7rmHjrPvvpnRXNs7VVmalK0+u2+l\nju2YvFO8v/burCmHrcXiushJMRZSthxD8vb1RJUKnzlK/ohNUTgf/vnP/u9Gy5NapPk4rrDJlzdm\n+x42LBOyUhpZvSTMDKVoPZGnav6++OK8/GK9/1X16KOda7DHYIrYRqqboCzv8eN54Wxire98Tvtw\n5QRFwr7NN98cI0dmcg1gJKZPH9mRdVTTkwKijnBoYwA/0lrnfQE8AGA6gLWs8F9DZsi61GQj100c\nhc/LlFKST5U7lspg7BffLqvZVcyz4IKZGm4ZKb1Z2ZgOtkr1r6ieXBd0NlSbcdlhO/TQgSqmMXbd\nUmtSUeFsQ7LU71VCPle22648v1ANotgLC2phw+1vfFTdqfszqs9tIeURs1GjgCWXdPNiaE/y9toL\nOPFEOlzstmFPkMqw8/WZkObre4EFgCWW6P/faOzZDhGMAMHuo0w5Vq2wIGhPpOqenC6ySPo8Qu8p\nZL5RlLfRLKImsVS7pcbMKk014448tWDeODeostNSd9uiXMOHlKHKuL7Lxl0ZKeupqoyueacoa5km\nHRUuBT5eHYtsJvU6Zc/B7r9iryNs25CxBC3PPutfHm57tL3shdg0rEuDqGjtGCPtww5zT7ssPx8b\nRE3QcwIipdRpALYEsAWAD5VSX+z8fQYAOraH/gngRKXUD5VSKwAYBuBOrXXp9L1KskoRcpSjamBY\nckn/dHwGHUpDhzKAmr8/pYq96NRJXQIis/NfpcVS1A5cXBzGZNKk7Dw8ZVS6zVD1aD/rz3+++/cq\nDaKXXsrsInGxtT2od6LKI0ndnbxZuPkIiGIdaTKqz20m1uTc2JtYeeU46cXCvj/7OE2Z58EQjcQq\nbMOX5h2m2qWtScJ9d845p/976iNKeXw82hnq6hso4WWIkB5wbw9cewpVeYXa0aHSNMQ6qkRpS8Ui\n5eZi1RGU2NSh5VyFS32GvjNFv7dF+4ZrG4+iSWFYrPqLXcattur/HqvthEAJ2u17NmOvixc0iqoj\nxq5xq7DtjsWu57vvdi9PLEL6+lBHKj0nIALwBwDzALgFwKvW3y+tMLsDuAbA5Va4n1UlTAkYfDqL\nWC/3ppvywsWaLNiTdwPlMpy6v+uu44VzEWa51r3Ps/Jx+WqwJ7s+WiWxcM0n9uSyLo8DNva7Si06\nqoSFK67oZhepStBSZbix7h3NVVbpTsdHcM09YsFNm/IaVQV3oVVlXLgJ1fojj8yOs4YQa8JqG9/3\nTfOJJ/q/T5tW7hiAu1io8j7D3bixxy/XZx0iuPBh2LCw+NSEtWosC5mwU0yeDFx5ZXW4KhV5blu0\nN2RieOkD6P6RumYvqrhjfcgxkCrqsgU3dmz22eQ8uG35UVoAZRSFM+9eSqFJ2+y21V0enzZha6fH\npg1HtWzBT8iJBNu7KhXHbEjYv13EM+k7gP3267525JHlccruwWdOHOsZ+KQTMka7mj3I03MCIq31\nEK31LMTfeVaYT7TWu2itF9Baf05r/QutdaUJOGpRecEFVeUZ+Jn/XkZdnSW3PFw3kSG2IFIO4lVC\nAWqhae+qu2I8BQHNCojKaGp3LmbbriojNVhU5R9iENI+OhUywNg7dfndGkqFPhSfgebCC7PPokmx\nqcfzz+eld8017mU49FBeuOHDu6/dckv/95T9clHaBx6YGcQPIcTWRcox5qCDgO9+N/OsWCYE0Br4\n9a+LyzZyZHk+XBss+TxT0+QC+Oyzu3+va2FjvnPtvNmCO0qwc9ttdD55jH2qqnChUPfKdSGdYryl\n4lDa3qH9DIXRNExZ37HqLKSMLnGNt6iqcptNo6K08+NxymNuMeNwF98+vzeFfc+UQIJLmWZuE1TV\nt7G3ZWtkcjfabDuBlIOXNdfsvsb1hlnVBg88kJdOFdw5cSxhv8nPCN5T4+N91KbnBEQpoRrl/vu7\np8NtdD676RRcTZ0quAKiqjP6ZXFTUnXPW2/dfY1rfI7C3sWNJSBqw05dXV4uuPdadSbePuPNSdu2\nb5L3ZJeHEgDbcUImS7bXwTwv5S2reRJ6XKLIexEAjB7dX84iA8t59trLvQwhbscpl672JK5JN/dt\nIOQ4mTnGNWZMv9thG+ORaMoUeqOljnrm9mUuZWlD+6A2Q6o2SA4/PE7erlq3drmoY262gJDbR8Vy\n8FF1xMxoLdnetbh9fsq+xRgfto8DpxAQ9pIwINbRwCooWyezzpouv9hccUX5700KA2NT9T5S4UKo\n2jz3EXaGlK1KM9a0ZcrOmQvjxvHCteFUhc+Jh1hmF1JuUqZ4t0RAZEFNcqugFpDGbWUV1PEtKm1u\nGWy4VtJtKTBXQGRfK3txQjsDU26uzZ4qN+Ux3UXnaevOCDXQFE3Izffrr4+TXyyMS2IXytq8rT0U\nuutat4qqK1VH4yjKFk32b3UZoY5lFNX8bi8u65qwltl1aNLtMEWsSewzz2SfdU12KPfUKY7i1PEu\nVxkm9hE+UJ7hfNqe2XW+6iq6bK7l8iGFvUHTXqvmPHVpqpTFOfjg7NNH4O4DVQbuorCKKhfiPv2R\nj6MFA/e4qd2uy45BF7Wd/H2FaLO7sNlm7nGKBAg/+xmw3HL8dEL6gp13Lv+dMpHRNuoYO1IebS0i\nxAYfRWg9xT5iFgtufnb/1eT8UAREFjff7B/XfvCxXlDuIBfSyG2hCndgtPPbdlu3/Ch7EmZiVoS9\ne1cGpUlSF00eMSvLx3ZPzDXK7LpDTNkhefBB4M9/Lo/H9UoT29hnTC0t18krZeCaIoW71Bjtkas9\nFZNUHt6KMMfqYqZZ9vu//lUe19y/zySsqO7M8YdYx9OoXfWiY4kcqjT7KB5+uDvvlIaCU7b/KqcP\nsbRTqHugNlrscEbAWnWstKx+irQnuXVKaQaGYjaQQgREKYRhPvWYEsp2WMj8hzu/q4K7cWlj6s+O\n6+K8gkOVgMjUp/3OV2nIcY+OxNK0K/IQNXz4QIcAKfvEv/+9/HefjURDrBMXseD2N9TztTWk27Bx\nbZfBftffeqv/uGYeyqatb5477QQcdVT//3V5O6XaR5Wwx5THDmeuVWnSH3ssv2xcREBk4bMrRTWw\nWBK/qgU2F640latBZFOmBUXFpSbsRfV17bXZZ13nNUOI1dGk7LC4x4B8oLwGHX10eRzuRGyWWdzL\nE5uiNuq6U0HZyamL2G0rRVvlLuiphZGPkIaaGJp+xwVu3lS4KgPnBrtubOODXHfKNqNHu8fJY8el\nbC9UCYjKJuV1u1p2qYc6BJbUpokdLqVDjc03L48TwxNN0YKTm3aRXTKtwz1S+fQjKcdt7hhTN22z\noelDiLvw0Psvu6+qI+b/+7+8PIrm5642GGM9g7YYqe7ry2wNhdiiPOII/7ixqBon6+ofuGtnI9i8\n5x5gwQWBlVaiw3HnREXY933aacABB/T/b8+dUvbl3A1wmzKj4Wec0X/NzAXtzXx7gywWIiCyCFFb\nbrPaGnfC5HPELOXkZfz4OOnUQVs1iGyo9u3Tbqlw666bfaY4xudTj2YiwrUxVEWRJyXX9t9k35DC\nHktsKGEwtVjmGsW2KRPS1MVpp3Vf8zFCTRk4p45qVKVtq+2bNEPeN5sm65nKO9Zueh341J3P/MVn\nM6tq5/zOO93TNIRurq28MjD33GFpVPXbZWVMYaS6DUdQuUIzWws/ZD5hYxsnD0mnLI5PXB+7LWUa\nRC5wta6K0i7zDBlr06ANFC3SzzgD+Otfgb339k/b54h9SBtNQaw5EXfsMfkYL7upcN24tYk1T6ha\nb1GYvr6qjMb5in3MOwUiILKItTAyDznGThuHJZbovmbfS1k5qhpiiBvEc8/lhSvCTETbNuhQxBIG\npFycU0cWq3aly7DjmvPzZbZWfAl5/qGqqlVwByJXt8wpjpgV9QPTphWr+pZNIFK8l5QRW0q1tm19\nArc8PscXuG2hSCuDwpTXXmjkbWAYWzMu6dkYLY+i8qc4JlRWHkrrzOeYQJXtQFf+8If+79z+pEnj\n6lXzGrNwLruXorKGClDuu8/Nk1As+2Zc7HSqbO/k4zTZ59m2vMwCijL2aox6u1A17zDajlXULdjY\nYouwfEI2bkNx7Suq+p5U+YZia44Ypk/Pjh2F0gZnBVW0YZ40Zkz/9zZsmi+1VHc4exMy5WmQqnee\n+t3YNLY1yKkTGykQAZGFjw0iavA23086iZfGOee452tDLapiG3YtulZmQDrEphPgd3SiKagyrrBC\nWDrTpw+s36KJb2z1X5/0jKpjjLJMnJhpJFH2ASgoNVWubZXQ8nIXdFUG1Oug6PjWQQdldWiMPDY5\n8aGEEtzycM93+6RdBZW28TRU9DsFdzFACVeo+0/pFdEOR6mEVx2TiG3Ysoprrum+9te/uqdTZqvG\nh1Gj+r9z1cSpRbWPpkksjZYmj6DEtjNF3YvdVmPdK1fTqg2aeKef3n9tjz2yz6pxlFtu+8hHCNz8\nqGfpU8dcAfell5Zr51e1+RCPppxNv803H7iGoATpVfZ/DJQA1H6+5lRAXVDrE3scqFvY5TO2hrz/\nt91W/nsdXpOrvD3XrSE555z93817aR/VilUeyk6Ynbax3VqlzEG9j9RcJgUiIIoE9UJzd3RjubSu\nC/tlclXHiznZefll/sCVGuq+ll7aPR37TPzOOwPzz9//P2UMuihvH0J2lWKW5aSTsl1Do8Jblebs\ns4fnWYSPxN8QMsjH1mYsw+yelL3LdWkQUWlyVXW5wm47nG3EPQQqbx/1da4nm3/8o/talbF/m9hH\nwnyO/KWEuheqbkNskKTACGmr2jf1/P7v/9zzq3rmZhHs05f5tCcfOwqx+yHuMYCqOFzvq1VQxw6a\npK3z1ar6Mf1j1aKZy3vv8cMa7W2f9+iCC/j55CkSENn9x8UXAzvs0P//6qv3fzdONWytSUqwT80d\nzAa5fZztkENKixsdqo433bT/e4jdljqEKz7Y5aryWGfKE+oVsm7tvVhpmr6Ve+LGhYUX7r5ml4sa\n6ymliib7fREQBVLXwsmVWJ0XdWTIVjeedVa3PIy6XAx+9atq15epKduBOu44Xlx7d+nXv+7/XmYs\nN6UaZJPpXX01cOKJbmma3+2OnerkKe9sVWlXqczbuyNlaVPlcTkK4QtnsONqQbn85ouPls/99/PK\nQwkInn6aVy4ffNSAufdPhbOPKpXFLYrv+jxj7XL68J3vlP/uOslrw5gNlNsGsaGeq63Kz6Xqvl98\n0a0MLmlT+GgD1T2GcY/O7bZbWD6ccKk1U8u0imNpEMWCys8en9dYo76y5DFle+KJ7mtl4YF+r8gp\nvWYVvcuUYIvSaDCnIKraQRvsadmY8b9ubdYqqLGVMqgd2gdztdhCsDV2mtxopH4rc67hC9c2GVXn\nP/1pdxnEzf1MAPVCV7mpD1FvTQFVjiqPJnXYkSiqn7IFtikXZaTO1Y17GVdckX1SZbzyyvK4Jo5t\nnZ76vej/quuulA0S77/f/72sAwwtC2W3ipvmsGH93yltK2rxNWJE9unbCZfFs3+jVEJ33LH7WpMC\nO/P8fYxvxsLn/s3C2K5vaqFpdkbr6m/LFtdFcBefTe66UfhoS4bwP/9T/jv3uJ3LPeeP0aV4BmUb\nHlUaRD5U3QO1cKLGZW67LbvmS+wJtI+AiLoWa/FRpkEUsw2WpU/9Zs+jqN/tI7ZNYdt8owQblAAk\nBSZ9W2O1bHFO2d2jHBxUwd2EKnofue8WNd62wXFBVX6mDYcaHA+Jw3XskuIIMaVB40NZ2WwBUcrj\nydw07d/Gjev+PeWalnsiwX4eK66YrjxViIAokLLJUtWOnlExa4K2CacoqmziGMO/1O9Gy4kyKBpT\n6yjEHoWJU2XYuS6pe9kg8dhj/d9vv724DKHlMgK3ovKYiZOt3s0VbFCTGJOOb7m5AxGljm5r4uXj\n1HnELJ83pYLfhh3iIqi+zBZoGqoE9jHKAPTv+HLxedbc3eS61ODnmy9uelVUpWnu277/0AVLrKMp\nZZgjHVXUJSAqC2eXgdK0rLt/8LF5SNnOCtEgqiLWojIFrvnYRpqpuGedFVYeg611U4ZPPa2zjnsc\nH0zZbI37srHZ3uzizhMpipxPcO1NUmOrmfNWjXNUH9Xk5hNFyPFNH29Xdj6mv1p22fJwIe9/1THI\nWPPNuvvElGlS8/JY+Diuoo6qlRFTG04ERA5wNU+4jeB3v8s+69q94F6LqWETAleIRf1++eXZ52yz\ndf/ma3eEyofrlrAsvaLwRuOF0jCKNYD4xD3oIP/8fLDLaBb5tgF4rpDGCIjq8gBkL+JDFmIu5I9M\ncQyh5vNs0kh1SD35vBMpFtohbr4pqDKGeueLLfCrWxhQJSAz/X9qDYumCLUZYfAx7E7x8sv+cUMx\n+ey7r3tco+VbpQ1jE8s7LXeBWddmHteensHWcqEWmrHKy9WwCBHs1dVWZ5mlO0/uMaGY3hNNnua9\ndTmKbEwAmI3CqvBNYpeHKu+uu3aH4xLaBxtbXly7gymIpUHErT+qj0mxcef6rtv3H3qUs45+pux5\nnXde9zWq7XMQAZEDZQaRqcVJkwutEC9mXO9rdWHcJRdB3cNVV2WflIAohbaIzV13+aWfx2hB/PGP\n2WfRJDZWp2PSodzvNqEuTO1yhXTelAaREcL53gtVL2YQtAdDs9vGXZD59h15LyGc+jK2csrybGIX\n2+yYVhmpNloXdt3+8pe8/OqwAwWkFRB+//vFv736Kj8f193UJhcDVXlz7fFwtRN8yuCz40+lTW0k\nNTm38DnqkidF+W2vMa5t89RT+79X2SWj0qY2H66+ujyu6XtCBBuLL14e1wXuwmbuucPTS0FVfmXa\nFHVt0toaRMss4xY3hUH9tdfOPqsERG3WIC7D3qyh7EXOM49/2mU2Qouwjzm6rtFSbHrVsVa10zYb\nNzY/+1n8PM192fM77qZaSps/scbwsjZBzZcpT+ccREDkAGXPpq0dJ9eAIPVb2wy2VWG7Cc5DGdGO\nKSCiOqJUO4P2BCe2UMjGVh12HUBSq4uWqUZXXaNsEIRC1YsR5H3rW8W/2diCq9D684nva6g59bMu\nM/JMaYbZA7sREFS1CWq3xYcQgS3Vhm68sf97lS2Psp3M/fZzK0vbMVoLPpNlasFu4KTnOqGLZTvA\nGIC1iaVBxD0OadePMZZqX6PaaN1CZbu/+Ne/3NJwmfNQ93Xkkdmni4cvbv2YeScVfoUV+PmFlMf+\nzdaCMVDjWt3GVUMW0HVpZ9nz0bnm4pUnxSLepEUdsSwqRz4udc0Ob+bBbVgPAfRmWdkcnOswwAX7\nPeHanqqDorbFdRoQojVTdAwyBvaRxrPP5sUJPUFD1ZnZxLTrwpiYqTrREGM+6YsIiBygbJ0YV/a2\ni4oz/9oAACAASURBVGHXB9pEB2ryHDu2/ry5cDudMk9S1GQmJqYctjeRVDvwdnjKmHMKjDvtyy7j\nhfdty2WuXKsERFxB25Zb+pWtDKozNhOjRRflhbe9UzQhIKozvSpCDDG2WaPFFUrt3OUYQBXUbjRV\nj2UChLy2WhEx68ZM2u12wlWfvuWWeOXg8MIL/nGrBJuxBES2zbcQKEFrk+9jkeZcDCgNYfOsqwRN\nVYJk6tr++/PSCyVEwEK19bqfP1ejw8zZ68TUhd1nhiyqy3Bx3W7WMi4aRNzx9tFH+eWIzUUXdV8r\nExBRVHmwTcHRR2efdSkeVAkfKYPN1PvTNu901H1x2+0++8TJ24YS8htBVMizTq1JLAIiD3bfvf/7\nhhtmn/YZ/DrU9qrgqi277Hi1laOOKv4t5m5RbMFPSIdvS91jdc5UB2pUE6lJR8wBizIAyzWkWIYd\n98EHB6Zrw7VzwMHsIHB333zsEqSAu1vkqsXhC7cuygb+unaLuf2tzTe+kX3ai0oTzscDmgtlNmNs\nY7/rruuWRl3YfR4lqEq5K2loYgFhMH1ZXcTujzjphYyjlAMQSgPcNS+AFkhyxyp7nDFhDzuMl29d\n/a1PnkaQbM8n6xYQHXEEL9xOO6UtRxl/+Uv/d9OH+WjxlP0W01ZRWd5VXvqaXP9Q81VXAVFquPWz\n0UbFv4Vu8Jv7L9pwoK6bNS+VTlso68u480RfyjSC7HlLjPUNRcz0REDkgHmg9q5qmWptiA0CDmX2\nM6oafNnxjbbgqiZOkXqHLWRSVeVhII/9TO2z1WUTX5sll+y+VlXWKiOGrukVUSagCaljbjhfIVuZ\nACJEQMQhhhtlO/wJJ/DSeOghv7w4UDvwZa627e9tm6RUYdrCIYd0/xZqKLGKMnez9ln9Mls+TSwA\nyna068rbkNLbCQduvx9CyKQ6dRs2UMcyjCFdG9fx1gfbDhKF6WNtbJtOTWqfh6RlNhfseWVZelxv\nfXVBmSKICSUEMu/PJZd0/0bZ04qpVZAPUyTsp8YJE/fww8vzoI5oLbhgddliQNUVdS+PPFIcnqsh\n6wv3qF6Zd8bQMcjk88479O/UvJwyodG2uZcpz957d1+jxqUUxwkpKAEq1Q64YztV7z7e9YoQAZEH\nZoFkEzJh9X25ytSoqwaJJnd/Q0jREXEnslTelBCQW0ZjINVH2DFuXP/3ESN48X3sMbkuQnyfD1d7\nJRW+5XY17EyFt3dpXDSIYizA1lqr/zu16+5K6PtJTaRtgTwlnDLfm1RzjtUv+aTjMyGo0yB5ij67\niWedr7Oi94+6Ttk/C72HOiblIcdgzHGJFHnbXHghL1wdAs277oqn8eryWwxCBBCuY9H117uFT01q\nwQVlBuHb3y4ObwsnyrzuxmoT1FEiADj55OyTmp/ZYzXVJh54oDxO3VD9bZlA1zYbkQLX/ijFsaOq\nMcgI0KrK0VYBkT02GOH1ttt2h19jjXh5lwn+bA3LsmPituDPtb7LhLquiIDIAVPJlFFXe0fEdeKX\n4uWqahC2145ewnWA4dRtiNtaruHykHxj4XMMxqjTc4/qpD6+43pkKPVxv7LyfP7zvDTsgYI6aueT\nNxdqd6pJg+RVGJeoXA2iJiYzMVTZXcKXLSBS0Aa1/DqEWPlr+f8pbRCAttFA2UdxNUhaVZ4UhIxR\nZhPDd3Ia+/7q0nhzdfJB2cloQsMmtoCoDYvGNpQBoN+jZZctDm/XsbGdlvoYDIVZ69x/f/dvTYyt\nIfO5sjYa08RACK7PmDMHHD++2JZgVX02Oe8PgSqPacuUWRUfBzaUE5qivMsYPbr8dyq9G25wy4OT\nJoUIiApwHeR32aX/u2sD8e34QxZyMdXQYkC5VqfYeuvsc7XV/PPynWjHXoCWuZWOOWBxPdUYqPJw\nO1DOvVPqnFx1W9e8uVo8vgPcZz5T/FuVdwIKatetLrgGwOva5XZ9t5qcpNh5U+9bXVql3H60bMeM\nK0huor4pbbFU5cjbGMp76nLpV6ky7rWXW/gmSKEN09cX1wYRl1iGvSmqvM64amdSdkdCF2ZzzDHw\n//wcN6S+qcV3mXAx5rMtOx7CtROWetHrKmhdeunuayHzG58wRemXad0MG8ZLw7duuQ4JqPQpLSgT\nzrYrW0ZMTXfXdZ+vw50JE+jnAlS3y7I646bTlrGMu2HLZbbZwuIXaai5CKt83y1K4EshAqICbM9C\nMaGOhXFfoDKbQ66UufJrwrYEdwB9//3ss8xzmU3MwSkkLTNBtAfXok4boCezvuU2xhtDyk8Zw/Mt\nD/UOlHW2dj5mgtCUUC/PQgsVp+UzeXNR1Y89qXXdLUr9bpWFs72UmL4jRBMwJpTgwGg+VVFWNk6/\nzDVePN98fmUA6L7X9Mt14aJp50t+E4W7OKCeE9U2yxa2bdmlNeWmvJRx43Kv+xKi+ZIC12dHCZdS\naDTkj5jnnwO3Hn/+8+5rTS4Cy0wtuG6OpcK1Tcw+e7qyuEC9q+Y4ml1+s+AcOjRteUIENGV297g2\naI47zi9vV+FeyPyWClNkKqIq/rHH8uLU9f6HCHxXWSVuWYruWevu9TU19gwfTsd32Uw46yx+WBtu\nvygCIge4C6gy49QhhmWfecYvHgVXMtw22lZGbnnMuVdbQ4RyZW3w3S2gMPamJkwoD9dk3VKeEajB\n8qCD6ikPlxiDpR2+TKvMtzzcI0gmrt3PGWOvMctYRH7QKutvbSFFDI2WUI3KKg2iMk8kNmVGM2PW\nd9liucodvBnf7DTKXEy3rc/2JbY2Tapd13zcjz/2T88IrCk35r6ELn44/UTdVGkQce+ZsvkRI12A\ndlJRldazz3ZfW3317mtUWy5r33U9sza0DSCdNmzqvrVsw8r+rcyhTMyxLPbx97K5DHUtpu3WsnuJ\nbSO2qD6qDHFT5aA0XOoa4/fckxeuaW3y/BHhVP1Qke2wKrj1IwKiArgPlNq9KLPu35aBsS0DpytN\n7ghxB5HLL+++Rk38XBfaKZ5Z7I7UV4BTpv5fVe9lAgLKO0Nq1+dm98AnTZfddW761CS/LD07XaMZ\nUseE9ZprqtNKpdF0wQW8cEVQAjQbyqYI1Q433TSsHCETaNNvVe3S1q0tVAU1YY1hdDLmIibGApFb\nnryH0unT/TVSXL1L2tx7Lx1O67AjZvn2GWP8DO3/H3usPC3us+ZqAHLSzbPUUv3fH32UlxbXJbxr\n/dXl4Y7bH9qe5FJQpr1CQdlJiTlP5NZL2XzE9Z5iwC236XtsyoT0qcvtqk1O9bux52D33efe3wC0\nhkuTDkIoUj1Pu98qykOp+gRU3LlGPpwIiBLA7ZyqdmrypBAQmGNFRem7dlhtwdVGC1cF0zctqmO8\n+uriuHYdu3aqnPBvv12cdxUhmi+G//zHLQ3ffLjYLrvLsG0Jfec7/vkBwKGHuoWnhF2+CyjqmqtQ\ntep4Y4ydTyoep32nEhDF9CiV6n3z7Z+5xpCpfotijz2Kf0stPKI0cKnjAV/8YvZJTWa59gUpwYYv\nrosp33eBQil/jdTtt3cLX+XmHQifPOffg+ef94tnE3NCTz07SovT5GkfPzWCgRSbGHb8Bx7oziOk\nD3RdaPoKiKg6CPHma+B6wvOFKvdf/1ocnttnNyHYMFDPkDo9EbMtc+2IUUeRXAVEqfuEMrhHDEPW\nN5TZiDwxBIlNaPPEMJpPbfTbtoaL0DruPS+xRPFvvhuC3PYoAiIHYghQmhDCUBoEqbUoymhqB3qR\nRbJPzn1SdRYyiBjva5SAiJvuSSdV5/Pww7zyGO680y18DLjGm8vOY8fevbLzX355OkyVOq7hn//M\nPqlBitq5tYlpBNEQ473mamxx8V2MUHmaeua+RykMgdv5LLxweHrc+skL/6gJOiVUCRmHTF9G1S31\njsQcV37/++5rZWMZ1R+G7M5z4I6tqSbV+fyV6l5Y5bWMinA9ernxxtVhuBNobh2MHBkeLuYOOFVu\n7rGMI4/MPstsRPpi32Ps+Z85YmSnYY6qxny3bNtzBsoTpytNaEC4CtVirh3KjjLauGoQUaTuW0Og\nNI1S4KoEQAmIuIaFufnHdBTQhBCojOOP777mWkbqNIQtzC9KL1RAlI8bw6Olb/8mAqISqOMpocQc\nmLkLor339ks/Fb6GtXyw62Ottfjx3nuvPC1ungZqkeb60uZtUAHdnnVcOeaY7mvcdt/koNCEoVPK\n00VZvN12675WZpgcAI4+urocnLyroNqjOW9e1a/E0CDKv18h75a5xm0TeYPRMRZjdrnKDEDbuE52\nKQ0f40rc4OOutZegBFBlGm+UUVHfthZbQ831PfJ936l2xjWE6eqphXu0g0Ps8eU3v6knL66AqAzK\nG2Fom7DDxhYQlcWlDOT65vXii7xw886bfcbQgIjBD37AC3f++cW/xTxp8Otf89Iqq5eQY4Ix+7Ii\nA8wuPPccL1zqvszcX96gPABstplf3nmWWYYfNoYGdkyhHjctSgOvzvVKzLzKvJ1y887LAESDKBCl\n/M/tN2mcj7szQJWDEhaU0bZzp1xidvKuE397UHWtP+qZUUKjPDfdxEvflNvsYqaC+w6UaRDZ17ge\n7cryTzF42HYpyuCorVJwFwzU/VICojFjuq9Rx2WNcfWQBQvnyMt99/HSN++Ur1bZtGnh/bLPETNX\nqGMqeeFIyCLCtQ5Sq+VzienxsYzYC+i6NIhSLfxD0vTdvZ4xI/xdpTZ/Ys5lqLSouVVo3ZY5Q6Gw\nNSepOgzRrKxrLsjtc8wCO8QmWxOaL662kFL3t2VCoLZoEBlhYEg5Umhu27i+H9x5nE/dfv3rYeVw\nDdfEnIDa5I6x3qpyRlB03WXMyod18WrGhftMREBUM6kFRDfe2H3t6ad5cYvc7hVRpyaQL/aLYBYS\nbdkZrstQI3WkIkWnQ8EVWFJ1Zo75cZ9PrIVQkcHiVO9uTPsHMerK/u1rX+u+tv/+YeUBeAIirj2r\nUEOTMZ6rrfkVY0LEHsBzI3idQnvf++Tu1qbCd9LraxAScPdeGtK/UQIizphHkaI9hajg//3v4fnH\nsE9RxogR3dcoDaKvftUt3XwZJ0xwK3deczIPt7+lbHhRfbBt1y8lMTS2uO2cM2966KHuazHeN982\nGqJVGkNARBFzrOYKd1zzjDnfc+27Ywr1i/pbzv0tuigvzzZ4LLShvK/FGMu4Gxu+422M8nDyEgFR\nIDF2WLlwHxa1w5+Hq4Jbdi/UZJaiasLhkncdnci554bFp56T62KHEhDl0w3ZzeDW4623dl9z7cQ4\n4TlGS4s4++zsM8ZuQCqa2B1Jnfdii/V/NzaqfAVPMXaguHledpl/ujHhekSLUba8oC2kH02lQZS/\nFuNIgE2MvoCThu0FysB9hnkPfVVxU/dvXE2FGOWIqbHrO+eoSjdmP0E5iqDgaj4UQZWZmjsULQ7z\n17kbVpRnM7OZY/chZh5JzUl965vrfc30MbHdolPzpjzHHuufvmsfTLW1mHNprpv7MnzLQ6Ufcm8p\n5rdcYmhbhcy3OBrO1PXPfra4PDZl97f66rw0UhNDg8gm1dzSJd2YYyuFCIhK4OwgcuJVpUGFp3Zp\nJkyozvvUU6vDVEEZprzrrvB0y+AKtlzJ1+2nn/oPMtRzuvZav7SA4g6ryOhi6sVu6qNlZbgKDZuw\nQdQ2L38hC52ycPaukRHwxRYQ+e5yUNfMRJI6EtyEIJGziADKjyD6ahCFLERiTKBj7l6FhPvyl93C\n33ZbdT6UgIiCqltXARFFTA0irmZnjPL4xuMKNmLkn3oxSHnac4XTt95wQ/f8gdIgodpoqr6SOgrn\nW9+umgFtsUEUA6rO/vKXeGlRmOPkFFwBke/7tuOO3de4XsxiELNPoNIyG6A2xsGJb95FTgXsTZmi\ntk7lyX0vysKtsw4vjTyUM6OQeUuM8db2bOYizGtaucQ3ngiIElDmRpfbUFJ7+irraKkyrrZavLyp\n9LmualPkTUGpW8dWyzcedrgDaGoBhetRpxi7uTGJqZZLwfViVhep7jfmAspl8M6H5S4sQif3SoVp\nuuWhbCe5wn0Gvu7LKdomAOUIbQC6XpZbzi2vP/yh+xpHkzbkHQxtt1Tezz/vb4MoxoKoFzzjUItq\n32fB9TBDaXq4HvPOl7HoKEP+veFuvsQ48s7Vfvbta6jndM45fmnZpN5846b/2mtuaXDabSqBKPek\ngS+U18GQMYrygFdG3kMoEHceVGYbNHZ75Kwn6pxPcojtLIe7cWfgevqk+mDuRmlTiJHqBHA7J8rm\ni0saRY0p/1BTHSdIvVCg0v/KV9LmWZY3Vd9/+xsvHEXZxC+fP8fIdFFcihBDk67Pnbuj7ptPWThK\noMjp9Fx2T/JQAqKm7amkwFdbiLoWUt+Uhg1V39zB7otfpK8rlU6DMTUxF+SucG25cCZLlICOuwCh\n2skOOxSHp/KnhJH5+4tt3N51Qc7Jq2jREVOzyxVOurGPHRqoOj799O5rvvfOPdJF8dOfuuXFmZO8\n8AIvrVQCIuo9puqDWnxzmDGju7+fNKk4/OjRvHQ5z+zNN9NvlJStHbhpcBbWdS5YfQVUsY+YuWI2\ncGOQSkONO97a11y0upswRO5KXXkXzWM4AiIXXNq4q21DA1eQLwKiAooeUqhmT10elNoMdb8LLVRP\nXiHCiRjPKS+VdmlPnF2AffZxL1NZ+m2FUpvnlP/DD+PuqB12mF+8GIQsTlLs+FBxXdLivJvUUY2y\nhY2dfy8cI3Bh+vRuTdCQ/q3J+gnZrb344rhlKco/hmDbJobmWx6teTvDMZ5/zMUy1Ze9+mp4vmVH\nZGx6oW/Imxig6oF7lC3EBpErVDl33bX7Wl5I++ab3WH6+oBDD41TLhtOmwrRmIkxt+LOW/79b794\nbSOGgOhLX4pTllBiHG/iCAM4z/qOO+g8qT4wxhGzqnsv2rijeOQRWrOsDigvsk3ju0HNPbEjAiIH\npk8PP4rA3fHlCChCpOmzzeYfNxTqWETbjjekKg9l4PGJJ3hxYw7qlLHHJkk1gaLCcAZR7nve5EQr\nlVHmTTbxT9dXQJTqqM7MLCC67DJ/NXHKw1CMtnPFFX7x6uz/Tz65+xrn3rmbBtdfzytHqAZRUZk5\n5YyxaIwpZKTibbEFL88yYhsp5pCqn6EWdtRz5dxz2wTEQLfmC3Usr6+P/365EFOIkkogE9Nj0Xvv\nhZeHi2+5qfYYw5FCCByPcFTdPvigWz6Ura2QY2J2OFM+Ttw65m/GVAV1hDbP1KndpyTqmoPnTxCk\n0iAKvZ+Y9SECIgemT08zkQ050uEL1zq9K5wy1iEg+t3v6PI0+eIWkfrcPoXredwqXGx+cG0iuN4v\n98wyRf7Zcj3RNMn06bw2SR15LItH1SMVnnMshHvEbNw4/8kuVxsq5Lhb3XDuM0SD7Atf8I9bRszd\n61TPhTIO6ltOKszw4e5l8mHUKF64VPVN9c+U/UXOGEy9m9RxacoQfQx6QUCUf9+17t7IoDSDiu6t\nLg2iPNzjZVQ9pugTpk+P+8wuuaT7Wl0bYID/PDHE4UoZvvceQ0AU+13k2A2jtBZ/9Su3fLiajxSU\n5l3+GVBHGbn9MkWMeh42jBcuX84ym78xyfeP48Zlc2CO4kbb5pjc90gERA7UpYJbR2NqssHW4Ykg\nv1BxhdPJxqCpziR2HlwtKJe8XScDp5zCyzv1bmEq8qq13PsYO7b72pgxbnlT6VL2s/LhuBOHM8/0\nLwe3XzYLrLoWHiH4ttGmNTGp588Z30LKPccc/nENnPqOXbdzzhkWn9qppjRIpkzxF3bFDF8WT2ve\noogrFDc0oUF0//3x0rLh2A0KOQbJ3ahypW19a553301vayWVgChEqyTPzju7l8kXTpmo9ti0BpFv\netR6IgbU2Ep5Qc6Hu+KKuBpE5v2hNla5afjW0YYb+sVzheojJkzovj7nnO3v80RAFAhVgb4uJWPl\n37a8KcOevpRZ9Pfh44+LhQH5++vr46mOpnrpU2uLUVBHqFK1uSLXmzZt61DbVh6g2xgvd/Ftu603\nuO5oUelSgt4mtEPmnpsXztjn2G677t+aFqz4EtMTSYxjx77aC59+6p8np39xhXskoC4Nqddf59Ut\nNeadeaa/Fk8ZMd9hrXnaQamcAsTUNKhLEyOk/pWi50GhhAixYy5YXZgxI6zcvp7EXOHWx+ab+6Vf\nZPOLa9eqiLyGh9Y8GyjUnLxpAVHboPqEW27pvhbTa2BZOULaylFHueVlKLKpFJsipxwHHdR9LfXm\nUhkxNxJFQFRCis4lZCevyUZHceqp1WFCtBxC4XZu11/PszmTarBpYpeTMo4daoC9iBNPHPh/0+22\nCYFcKFyjchQrrBCeP1U/Md2AF01i8otGSg2Za6Q6JAyQztMSl5gLRCpuDE2cPEUehvLHh0K8Rqbg\nkUf8247rrisHrjv1EAGKa337jlshdZY31BwL37bW5MQ/VBMvH586GuVKSH8bU9jtAldABND1yzlS\nWufmYr4f5+ZdJKQPPdaZFxrceiuw4ophaXJpQoOo6fntXXf5xYux2fHII92/zTUXL41QQWRqiuaZ\nF13UfS1fb3ffHb88RYiAqAZiPNAFF/SP+/TT/d+XWSa8LC5QBtJ8aUKjwEAN/NR51U8+oe2u5IVG\nbRcitBXKTgKHOuu7SdVxDrfdRk+gUxwd4ZLfqaLyovL+9FP+ZCR/jI3a5Sy7v5j9z+9/z0srBlR5\nfDXxmnyPHn2UbhP5e6Emh1yX3THgtFtqIkiRwogul2OP5fUTMY42x+wzXYRlLvneeKN/mk32rVzy\nz5Gr+da2He2Y8VyhNHEB/oZZXdrn+TQmTeK/N089FS9fV/Jt7eOP/TdbXI9BNvF+xrbvWcall3Zf\n4/Zl+edijEXbcNuXGc+pTcM6TIrUQZGAKObcIQacNr/44ry0ZpJHF58dd6SNJFIUPRCuHRuqgVEa\nLTF3kMtsxoQY/eKUceGFu6/lLcTHgHqhKU2lIUOAK6/svh5y7MGFJjTD6ho4ueqtddliKhKq5K9x\nXVo2ufiu05YON11On7nZZt3XitpI6CLNV0BEnaUPmWS7QpX78cd58XyP/qZYxBSpZVPX8tdTaTRS\nUONWvk1SdrJC6ixUKFKUd94JBFfTpElhR4iGZBlcuxYhgtWYR+1d0Lq7v7344u5yX3ZZdxkpY9ap\n4MwJKcFWXcLuvj76XbzhBl58TplSHN8rEkxR9X3ooeH5+5Ivp4st13y97bKLW95N9Gnbb19fXpTh\n+jzcOrjgAv+4RhDf9AZVLFw2MTj33DaB/Pzz89ISAVEJzz7LC+dioJeiagJnfs+HCznyUHZvvi80\npYpKpbXYYt3XUqjghRoejCmQKyJEJXzSJP+Op64Oi+udrOmBJZ8X992vq4xFnsXqaKMu6a61VnW8\nESP806cINQBJCQO4HvGKjlDVAVVn114L7LprddzDD49fHqC7TJTKeRsnjE1okLgKiLjvel5A9OGH\nvLgxNYfL8qLy/ulPmx1fOc+f6hOUCvOeGQqlVZgv9333dZcx1fjPEUZSYagNQur9SNFGizSIqHab\nv8bVaEkhfNe6W7DKOfZdNyedNPD/EAFR6DqBo+1VRhvHLhvuBmhR3Hw/4Xq/vvVTNI9qqr4ffrj7\nmosGUf5anVpUMe3piYCoAJcH6tLhUQN63u1n0UueZ6+9+Pm6YO/crrsuP95rr3Vfa7JDdTlbTlHX\n4puTN0XIEYw6Jdq+eblMdlw0RShNHN9nm0rLLK89UbSj0TYBETde/nrR+XNOvvfeyy8PVyuF26e/\n+CI/bxe49Z1/t266idcmr7vOvUw+uBiQbFN/q3X4YqKKuhbp+QUaFQYYeKw9NfljeNzNLlfNF24d\nU5PqAw8c+D81v6kT3/dj+vTuekilQUSlyRGif/ppdxlvvz1Omaqgnn2RN6b8+BHSvkLROjvCm7/W\nVD9aZKsov75JURdF5O897/lx443D0msbXAHRq692X/vww3DD9VyN4TxFa5mrrvJLLxTqPlw0iHzC\nxIJjT5cr3xABUQGpJm9/+lP3tdNOK49TpEH0+utpOlvfgbltmiFF+fjuKtY1geaqN7Z9sAolZHHp\nwnHH0dpZHKidhhhQqsP5Mv71r93xUr1vMQ0fUqQ6o53Pnxr4J0/mCaw4bqZjEfPd5nqITLHLTQnp\ni4SB+YVEnVDP9je/qY4XcwOi6bxcNWF8jwBqDRxyyMBrXAERV7PT4DvWz5gBHHPMwGuTJ3fHS+W+\nmsJ3TlokIEoB1c7yXrWoMJRQO1//qaDmVlRfNPvswG9/65fHrLP6xSuDKncqQRQHSlsU6DacXzRm\ncmwaulIlLKMEEEU88UTccXmrreKlZeBuyFHtm7Jf59qehg6tDsOdo2rdLdCLzWc+Q193uW/KS1/+\nfurckKfWBXlEQBSBFMZ077/fPz2qs0u9q+Vyb0Vur+sQZHDrrCxsVbitt3Yrky/UZPm554Cvf33g\ntZB6rUvYVVfH6FIX+bDjxnWHOfnksPKEQO2maN1dl+++W5+QcLfd4qZXV7k5A/3JJwPnnjvwGmX8\nkWL99d3LxIFTP9SCleKll8LK4kJ+550SBi2wQPc1rYE77xx4rW0eojjxXAhdzIXkTWmQ/P3vbmlw\nhKPUoorqy5om/yyouqUWP8ccU19fxvXylb9OHYOq0wYRh76+7vujyp2izEVaD5w+gVue/LFPH3w1\nFW65pdk5eF6IWtTvTZzIT9O3TCHpUcJgV6PZNrPP7h8XoIU8Re2W64kuv4ZzrS+OBhHHvm4ZMdvy\nt75FX+du/FFahdQzaJuhbm4dtqzY7UGpNJMYn05+/PisM2hSG4cDd9KRosyPPcYLF6JV9Prr/PK4\nkC8TtZPb1xfeecfExZB5241upxBihhguffFFesGSP/JA0bY+ok39E8DfqeJO/FLZH8lP6FzqsU12\nybiaZ3Uel6RoMm8uIUIr6v7ymmUptOGKNiJibtzEgPP8KQ+KKSi6vw024IXLM2NG93HtVGMyqqfe\nMwAAIABJREFUR+jJffaUFm+KZ1+knZ3fiQ/Jm3LMwGW77ej8te5ebFP3ct99/nmnoMkjZi7vDAeO\nZ9EiQtvyOefQaVLp5jduitZqoRpERVpkVTQ13hblOxhPbFCIgKiAIUPSTFh800zlhWCuueKlVXTE\nrI4Xa/Ro+jqVd15Dh1u+kN2CIqg6K1IdbtMiJqQuUhwlcXmv6hCihCy2lOpuA9zzz70iIGpyMcgh\nxbvuQn7yp3Xx0awquHayQnc0i+A+Q6qNc87Tx6AJDaLQeUPou5Ff3Dz0UFh6XOqYExhhOuedoTbf\nqPJRBnIpWzWhUB5VAWDBBQf+z+1b65qDATzBE1WWUaN46dfVL2vdfXycs6AuIuQoYlG/XLSIjT1P\nDOkLKTtudY7p3HlUnlNOoa/ny77qqv73Eyqkpfq2IvMg+floyJgM9Hst48Cx5dfUvLUojxDnI9Q7\n2DaNWdEgCiTEu1RoWCrMWWfx04opoQ/duaZ2KlO8+NQAXDSgU6qsFHUNZJzOxKUDrcPtLtcYnVLd\nC48dd+TFdSEfv2zHrskJNIcQF9S9IiBqU3wqTCrbQr5oTR+F5IxT1NhBwbG5k4qihU3bnkOekPbp\nOk7fdpt/XtQYU9cEPHafVBV3wQX7bUscdFB1epTBVi433+wXr4zYHn2KxuUUz99XyDxyJC+cr5C8\njLqEvKF5cI5Btk3zgRqzuOUuChsCN71XXqGv58vJPblA4attY3jjje5rO+8cd35b9Fxc5goc8wQh\nwtcUUEL6kHX+HHP4xw2F8vw40wqIlFLfV0qNVEq9opTqU0ptRIQ5TCn1qlLqI6XUDUqppf3y4oW7\n9VZ+mr4P/803+S9+3rNBivJQFC1sn3wyXh5FFA2MnAlc0XOua2DNC6w++aQ7b+r+9tyTTi+1YTfA\n7Yxu3hXrmDHxbSDl6+uSS2hBWdFipe0ComuvpcO2SasslKYMbJYJiJZaCphvvrhl8qGO55rCkCoF\ndS+nn04vgOq474MOivseLc2cbQwZwl/wak27Ai8KW0WdxzzytqVSP1fXhYXWvMV3WfyYhGhdUguR\nOne0ffvbttEmQYvJd7HF6Ov5a22qX65wuMiwblMbTCHvIJcHHgiLz9UgcyEf97XXwoRgIdSxLitK\ny2V9Q13La6DVJeyiNCxDFAacBERKqSFKqR8ppf6ilPqnUuoipdTJSqnfKKX+x78YTswN4GEAOwHo\nejxKqX0B7AxgBwArAfgQwGillNPehotRORd1uzoGUJf4Vep/rmXJn3XXmm9cMQSqsxw1qtudrkv+\ndQy0SnVP/KnjhFTHf889zUnZfd1ZGmJ7/6LypnaBinZOYz/rkOdClbFIdTgfjhIOtlGDiLoe25OZ\n1jxhaVl7oPqvJiiqx5hlK8ojxM4ClW5RnTal2XfWWf4CIkrbI38UqIhnnuGFKyJEiOHrgcwVapOm\njsWXa1ptErSHzE+KNPEo72/cfCZM4IUDeN7oihYsvSjYqMOLnck375Kdq4nT10drmzQFVe6bbgrT\nnC4iRPCbp665IxdqDv7KK/S8N2Tz5957u6/FnhM1pUFU9Owo25JjxvDTPf98v/IAYfddZLicc42C\nJSBSSs2plDoQwEQAowCsB2A+ADMALA3gUADPK6VGKaVW4WXth9b6Oq31X7TWIwBQVbkrgMO11ldr\nrR8HsDWARQBs4pJPqiNm3DPrIZ1lUwsapboNOdc1yS+yXxFTmp4CarH01lvdE/g6d3w5uBwx43RQ\nsScCRWmm8rS3/vrAppuW502RF6gCYe/vU0/5x02BS73G1nzTutuwN1UeyuC6Hc48j7YtGqmjMQsv\nHD/v0COreXXtkSN5ixvK7loKQvL42tfqyTv2OFqXwWWA3myj7oXbd1XVg8/xqZCFZBsEyAaqnfT1\nAcOHD7xWVGZqBzrv4bEMygNnngcfpK+3SUDEnU/ccw8dn3tkjoOLQLXoGvd4auwjvVwhVirymxtN\naSSlwEXLZf756eu+12JTtHZ47rm05SlKi+oHr7uOl+Ybb9SjFBGykcA9Gs3VIBoP4FsAfg9gHq31\nqlrrn2mtt9Jar6+1XgzAVwDcDuBipdTvmelGRSm1JIAvAfiv1Rut9fsA7gGwqktaL75IX29ywpq/\n/thj6cvjOlHKh3/yyXp256gJT6hXtaYGA6W6tSnaNDABbhpETzyRtixleXPCxqhb3zSKNIN8802x\nC5eCOiYn3LhFx/cMbRAQURx/fPe1EO+bqe4vf8S0SOP21FMH/v/aa/UJ+NukQRIKVfbLL6+/HAau\n983tt4+Tn4+AKOT5x17wcucj3MU3JTQqqqNNnLZR40JpObz0Uv3lAOh6pDYSioTYMctt0s8vllMY\nqXbRFqPyjhnONWwd6XHNFtQBt99JsUnPnWNwtY+p8n3yCXDYYfwyxSSkvo4/vjv+hReGlScEuyxL\nLZV9XnopLy5XQLS21vqXWutRWmvSB5HW+kWt9dEAvgrAQRkrKl8CoAHkFSrf6PzmBPclqEs62PZJ\nK1VfoWr0IXzyCa8TbdIGkVLAPPNUhyu6jzYJBKh8XexzUVAaNty8XcK51tnKK3dfi7WTXIf6bgpc\nhIbciQPnyEIR3PsuK/fzz/d7AWtag4hj2yaFQCV2eyzqE/LHgc84IyyfEI3bJjU2qzTa7GvUdUpL\nOVQQ7YvWtIAo5bvkIyD6978H/k/FX2ghOq7L0QMORWXPL065c8S+PuCznx14reidrhKWp4QSEK29\ndnH45ZdPVxaqHo84gg6Xd8ISm7Fjs8/jjuvOO8+WW3Zfc3nfuNp+XLht9IMP6pnLughVKFzsu6bG\nRdsrfz+nnx63LEWE1PdJJ8UtCzdfoH1r/1jhlljCrSwsAZHWmm1mWGs9TWsdIIdOggK67RV1szuA\njf77d/LJGwGIbBiDQeoJVBkhqtb33999jXsmMhQqzQMO4HVQRfVd1zPIT3SGDOnuoKZPb7+AMMXO\nNXUWmJt3EZTasasgKm8MlKPJw8VFC6SpNkHZLqPcqY8YQcffbz9ePiE2HkIGWq0zDRag35Bw0wKi\nuebihQvJo0liG4YNERC6aD2ecIJfvi64pPmTn8RP05dPPy0+1puH6vOo/r9KOyOGhy4qfpEdj1Ab\nXZy8AeDMM6vDad19nOi997rr1qWOmjxCV3bs+Atf6P8+eXL377H7jiLBLbUbH/PdojyBFeVx4420\nBlGIgKgO7r2XnlM0pUHkkm9TnjZdNjHyYT/9tF1KCFS+VfZxfcjP8x9+mLYjmKLPS3E/HEaPvghG\npvHoo0a+sTsrLttItVLqqx2j1F36DkqpeZVSFyqlluKml4jXkQmDvpi7vhC6tYoIhgIY+d+/V18d\nCWDzylgpXqq77uKF4060uITcy8EHd8fff3//9FygNJU++KC7Y6Tqpo4jUEVQZ12pydvhh9dTHi7c\ndsJ1X1qXJF9r4He/6772q1/x4huoRU8dBoPz3HILP62f/xz45je9izQArr2QIvs11BHe2P3o2Wfz\nwhXlSxncB4BVklrZo0mxaVDXAjH2Qo3rVYXqex56qPsapXHj4k57r734YX0ZPpy38FttNb5QvQ4o\nW0cubZkSOp93XnkcVwERd6HUtLdTDloDd9wx8BolNHB5p+vSaHWtR1sQRrWT0A0Cbtw55+SFDYG6\nv1BtGAoXAdFyy/nlbTZe8rTJfqKL8IVyKlMHLjaIuPfz7ru8cHX0Cdy1gwvUEcqrr/ZPrwiqjNz2\nHXvNs846m8PINL79bSPfGMqK6+LFbG8AEzs2fQagtX4PmQHrvR3Si47W+nlkQqK1zLWOQGtlAGPj\n5MG7FppH3m6DSz5NerbKl5EaDFJMqPLGsQ0cjagmhS+jRvHqY6xD6+UaJIxNyLvx5z/Hz5vik0+A\np5/uvk5dK8sn/47dfXfxTl8ZlMryLLPw72fDDenyUWhNC7bawmabdV8L6SseeYQXjtJSWmSR7iMF\nTWsQLbkkfb3s/zLyi/cQLbxUUGXaeWdeXMqTyHe/G1YeDqHjLxX/8ce7r1F1kz9KVBaWS11xuUKZ\nqjRfecXNsyzFscfywzYluG06zTYR+3gStTiltOH7+uhFdewjqpdd1n2N6y0xlYBo220HalJz538u\nm8ZNvVt33slP8+67/criAqV9kuIYdJEH5TyUwJIi5PmNGsUPG5JPiBkDF0LmBRMndl+ro093cX73\nAwC/Lvn9UgDJTTEppeZG5jnNVPdSSqn/B2Cy1noigJMAHKiUehbACwAOB/AygKti5F+XWl5TNhBC\nFhwzZsQ/JhCKi5Sdcy0FefsQ1CKe6/0OCLf740vILsDLL/PyKFLz5z6ro4/mxa1yC5pXS333Xf7u\niw3l0YU6YsiFuhejCaN1POFx6PtChZ177rA0OXG56f3v/2ae6ai4ecFTHX11kXAvP4kK0TQqOs5B\ntRnqSGZR+6fiu/RnebgC8KuijPjuhI4blHAiVBMzhND2HVJG34W/y4YKlV7eJpFr/DoI6W9DjuEt\nswx9/eCD/dIzhNRjkWc0XygvZNSCNcWz53rzDBnLiwRB3OOgQDYHqtooCK2fNglfm9QgpAz4h9gg\nKrrGTbNIC8wXqixF5gViP8M994ybRxGUVjL3aCzlzY07Dwq5F5f95MUBEKf1/stbAP7Hvyhsvgfg\nIQAPANAATgDwIIBDAUBrfSyAUwCcicx72ZwA1tNaM2WezaM1PcGpQ4gRMhmkNIgo6twh6wUBUR6X\ngahtLnZTQx3Jc8mbOn5Bxf3+98vziVXv3J0YLosu2n1t985x4yY0iFzach2TwYcf9o9rruV38/I2\naFJQVDd5uxgffUTvNnOEl/vuyy8P9VyLtPCosm+8MS+fpjRfQsbBUDseRbu4nGNCKYSVsRd5IULM\nGOXJw62zuhaI3PRCnrXLOGDPoZZfnnbQAKTxOFSkGZ6HElSEPJcpU/zjhubNPYpSlEeVQHallYDf\n/IaO69Iu8l40Q8d0rjCYm6bLhqVvHnVB2ckpupf8HFDr9m3c52myLJRm4Gyzxc/nBz/ovkatZyhh\nEAWl+VTVD7rO/12Cv4fMlX0RSwPoOn4WG631rVrrIVrrWXJ/v7XCHKK1XkRrPZfWeh2t9bOx8qd2\nPlM0bkqjookFeFGeN9zQfa2vL2zSkmLHl2ODqIg66rtI6JO3LfOZz6QviwvcgTu0vlPYIOJc+973\nytP5xjd4+VVBHYO66ir/tld2Hr4XBUSx7alxNVcobauiZxLiGtgFTpsoWthcfHHcslBwFywx0mxz\n3A02iJ+P72LQNR8K7pjO9b4WWp6QRSO165pCGzKE0DbBCTt2LD++bRR83Djg3HOBm2/m510HIUfM\nZiZBAoWL9libNhxDobxg2QvosjlciufKdYRCESooa9MGOIXLkXXKSQH3XppaT7jwwx/ywlF9FNWm\n7fK4vt8uy4XbAOxS8vufADTkTLU+ttsufR6XXBIWP6STL9LQyEMtbIsk1VQ4CsoLGgVVxiKjor2o\nQTRkCHDddQOvzTYbvzxVRjxjUMckNjQf7sTviiu6r1UJNmIJWqi2fNdd6bTs2jIBpO6vDm9ALvXK\nFZbXUacptC647wd1f3W1o14TEH3uc2k8AfX10Z6o6oCqC8o4PrUAotqt1t27n/PPzy/PsGHd1154\ngRf33nu7r3HfjXnn5eURCpV3qIen/Ht9yCFOReoixN13CqFh7I0P7rxxiy3i5gvQ9eBihPuAA8rD\nDRmSXXvgAX6avsTWPgToclOMGdN9za7HFVek7foV5VsEN+ypp/LTzBNqwDtECEpp2FBQR8K4dXPO\nObxwQNhmF3fM/M9//PNwIUSwRcV95ZXua/amaEoNoqMBrKeUulwptVLHc9m8SqmVlVJXAFinE2am\nhhJixF4sn3suP37sXff8wOiyKNKankTFrh9qsHy2QEeM2wlSnXcdAqK2uzN3gSpj0USy7buueTf2\nrnC14YomgykWfzE1iEL7IirsQf+fvW+P33Qo/7/ms87HnFsWu1as41obdmmd7Tqfz+t8Fjmfz+RQ\nyCElQoocS4QSKQkhRX2FSr4hXz8UpUKE+f3x7Lw+85n7mnuumeuauedZ3q/X5/U8n3lm5pp77jle\nx5Np+aiIUaueZ560+gAA/pmgN7vIIk0H423IcdDG1kwOQx3D/PPT8nHpSOMHP0grl4tp42PccTSI\nqH2L0cbWN2xt+fDDJp3HHmvmw3wxAODOuTEfLdR9/mgkjArGpMf6xud7p8Reduut8nV2NbdyRH2i\n+s7BmJjYnL38cn6bUoG1++yzm2m+IAyYQ1sbSvXmyz33xLctJ1yTNQC8L6jtxsq60VMl5gC1Do4A\nLPRObVBNj6lrwkEH0ehyNKm559IYh9a5sPTSg985eysVVBq2RnM2BpHW+gkA2BZ6zqofBoA3pv39\nAgAmAcD2WmthV3H9AenLaZfMAKoGke8gPNNM4bJa4xeRHJOKmpfqdK3EQhRzyK/FmbkvLQaYY0gO\nAw3jplPb6DMxM+VD7cIOO9i7wtLee4+3YWJS8jff7PVvzvHCjTrBkUBR4XOG7ka3ipmDKQ5SY7VM\nuBpEGDBNDAzUOZgjXCwHnP6KCXNvI8b57wor0Oulztsc85tTJ3ae+OIX6eUxMxFpUCOWmfc6ejSe\nbuOJJ5ppTz7pr9MGdjbCfIiVOidKMz2xfgDgPQ9Vwk49d/oYllRIv5tXX22mXUiLVN1ArIPyLs1t\npOu8+ebB70aTigo3mEwbqPX+5Cf0Ol3EBC4o4YOIuk5g+XbaiUebGtk0J8yZPcfckiqb08QMtNZ3\nQs9Z9bYAcBwAHA8A2wDASK01cr37aIA6yXMsltKgSiR9GzKV0RITZcRFzIHVPRBQfZDMOiv+7M8+\nS6ddAl/4Qjd0cxwGqKHmMWC099+fls+Hv/3N/1tooaVqU+XoR0zadN55vU9Meh+CL5qEC2xuKMU7\nBFE3NEwNGnvWY47By1P63JcnFPEOQ+zh1McgwtLc6Gs+SF/8MI0kLmOLU7YGqaIPG28MsMQS9Oeb\nc06AKVOa6dT9mgpMys0xO7zvvmabcmlHpgLT2G6rz/0N65/x45tpL7/cTPvjH5tp2BpFleL7IL3P\nlAoNTQX1+VZZJX9bqPAJCajPkvr+DIOoFnPzWFCfGzu/2WWNJhWVhs+MFcvbdna0cdhhtHwYfKZW\nVGZQjFYSBRxhbg6zbAzSAhT7WYwZMBYkhFI+FinPstRScfmj5dRa63e01rdqrc/TWp+rtb5Na13Z\ndlEn+pFBdP/9+GHAxyDCHHRih1iK+ie1jW1wGUS+6A0uXClhCm0KuPU9/LBMOyTAfRZpvwZcjSvM\nv4C0lNMHDh3MXwVnY6RKd7A2K0UPx8kBZnaKmaf48JnPDP3fN56w9BRtr9gyMQwizKyL4yCTihz7\nU5fatCl4802AZ54J50uR4ruRVXKsJ9jaQTU79J0J+u0dArS32Y0yQ52X2Jy/9tq4doVo+ICt/6la\ncgD8kPYYqM+DaQZTgc3NmHDhVISeZa+9etHEpOqLKRsrnEil40srVScW+csuq3WPSYJFNqVGO/Uh\nh2+qVPiCnmD3rRJafAAAI0em08Hg83/n4pvfbK9npZV6nyGGFfY7FqQhBG4EzVhss01c/qhjqlJq\nglJqQ6X6lffcLUotltKRfzCtIB8NTBWWSocaGYPDIKI6XIulI4laDtTLLef/LcdhAHMWTQXHxtqH\nNs2Z0Bzj+pbi9KX0gZeqdWdH0Fprrd6nbZdtg/p8VMkSd+xRfBD5LrspjM3YNfqpp/DIkVRp1ZFH\nNtNyzGHp+mpZC2PwrW+F9xnDIKI+H+bL54MPmszXHOrtHOYy5sw6x+mx1IkUY6pQ+xEzE0u5VMTS\n9eXdeut02jHnKGlQNR+o/XPWWeltScVLL/WEe1Tn45IMov/8pzeOS6z/XEhrn9ppV13V+xw3Lp2G\nj47RIFp2WV7dErjxxrpMzACawg6qaxMfQtpiBiEH52ee2fv85Cfb81F9noVAfW6s7hiTR4NsJmZK\nqRMA4MsAcAAARChRfQyDUouvOwgmT8bz/f3vzTSOOrnW9ChmHMYWV3JGpYHRwRxkchDjHLv05r34\n4r3PmPDFVEirUWP5sMN8zHhok7CWDhcfA+lxQj1c2OaOhkHk22ipbfRFGXHBVR2mtEdyzLdJcTFG\n+fHH41pSPp9Kse1pA7YuY23x7Qk5/CzUjpDDziee6Plsor4DzF/RMcc0tftyzAOsTmrEURvmUlCz\nppmRIGP1Lb00wN13p9PmCEAwcBlETz9NK1uK+YadRzmg+kTDTGPdC2wsQu/GOFqm+q/jzOsHHxz6\n/y9/CXDbbfTyXTKNpM+EnH5M0dis5ZxI7QtpDaLvfhfP59Lxmf5TITVGqQJJqTWRI8y9+GKZNrQh\nZvgeAAD7A8B2ALCZUmq+PE2aftHFQrvYYgCf+hTu3yUl+o4B1VO+D9S+wJgTMXT222/o/zH+QrA2\ncsPDuijhmDcGdt+agwXmxDOH9Enaoz937GCXPENHaoMYMQKn8bWvydQvgRIaMrUhxsSMClu7cq65\n/Pkw0zjfQaKExg/2Ln2RNjGkOPE2qOWALY1YM5n112++G8yZfYxwAfM3hOXDzC0w6aWP9mWX9T5D\nawLmGLgmLd7VVqPnLYGYMVSDZsgSS7T/ftRRsvSoZkLU4BExkNZ8oZrQYPBFO6thTKSghOZjDN02\nU3Z7fcb8jcXQoSKHNj0F2Prui0zr0uZEQAOQf+bQ2kpVmgihtIlZTifVLwLAKgAwFgD+AwAM9sJH\nE9jgjIlOkTLg55yzl8cXopVSHzaoME0a6uR77TX6s2CHxpiFf8EFwzQwcC+DHOSgS9V8slUeTTsw\nbQEMXZqTUM2gpPrWZzplQF2IH3kET+dGUXGRItGad950elQn3hMmtOfjmGDEwB0XPomb1MF/scXi\nyvp8jUlfRKigmphw5xtX9bwrSGvD+vJRGUQYbJNQA8y3zJVX0uoLnVtMn9TMPDZti2EQl56DZl2O\nidzTxVnGfc+Yf0obnDDgHGDM9y41F7lrgjQdDGefTauPenb0gTPfpN/hFVfg6Zjmm2Ew2EKha66h\n0YlxckwFlYHCWZuxsj4N5xLrUT/QyLnOfOITzbScDKK9oBe97FIA2FFr3aEVcn8CG0wx4d5TBmOs\nqizVxAzjDPuk3KbOOefsfe6wg7zqaCjvBRfElaWqX8eAe5DklMfC7mKw1ZHN5aMriURMndSoeNQF\nOTQHKT5rUpHzAhViENkHOgl1Y18dVAbD739Py1dCk0a6TgqNhReOq5ML6qFR+nAZas/nPidfdz/B\nt/5zNIgwYCbPN91EK5sDVD8LUmNvttn8v33jGzQH5D5I7ZkpWnXSpiNUmjbTJyXyJxUcjfYcTqqx\nCIrS59suz1snnkjLd8ghg9/32UemPZz+KcUoNT5xQj5ZqUJxLjBfSNL9E7NOlGDA5nzXZg2m3qt8\noK49dr4237A2JKwQyFuN1vqPWuvJWutVtdZ38Ul/9OCbkK4U3adVQB3w9kR97TWA66+nlfPRoE58\n21zq6KOb3xdYoJ1OTgaRCW8aszBhDgRLIMfGRn2HtgNIY49LbU9MG7GQ6Jxn5DJ+qJAODYqhxMbm\nA+ZjIwWh8caJWJcDlD7vQqtwmWXaf+9Ky5EqSJCScq+9dns+LJBCP4Cr0crRIJJGDtqYhnVO2rPO\n6q/vjjtwDavSfZ7CsOlqXBhfOyGsv748bapJD1UIEYOYgCuTJgFMnRpPI6cZ3Pnn0/LZwOaqzVA1\ncysGNWjs5USOsz4WddZovIecZlODDGGg+hB7+GGA559Pp0OFTwtcAmYNdl2YxILq8mSddZq0Qyit\nQfQxmMAG7HPPhT2mx9ZpD4KXX6YfsgDoB/8QMPMUu55SqqOuensMqNEtSphbcDcNqtTRptOmQRQq\nG8IZZzTTOIt3KHylQaiNN97Y/vt66/U+c0pDc6iOm7QYDaG236WYuVL9WEqdWIrOrbcC3HUX7oPs\nyScHv888c7hNkuCswTk0iAydueduz/fnP8vT5oDaj9R2+6TKbp/HaBB1NXb6wcQsZi/CtK4wSPU3\nZhoYAmdv5Zh52s/c9t7fekt+z6xp7wjRt89nNbQ7ZEKPIaT5suiiaW1JRYnIXSGsuWZZegAAs8zS\nTMOeGzPfv/fedLqvvELLN2VKOg0uQusgdW+S2sNSXChQ13KJSGuka6NSakdqhUqpRZVSa8Q1Y/oD\nNfLThAl1qUxKmQ6kXPxymC0YFeeUetqiWNl4++1mGqY6eP/9tPq4ZgIYbr45nrZRk8XCa2O25Zgj\nRS6oz/zYYzL1zTFH7/OSS/DfqeE0MellqYtRyrvG0qTUjduiybz2WnzdVOlsCLYPD4r514svyl9i\nxo9vptm+DkKMXen2tDnctFHq8E1l8McIQWrCQw/R8u26K+7sm6NBVJpRY+j5/GmVhpQDdKr/OyxC\nTsqcKVXG4Npr08tSkWNM1KZpgrktMBGd7LlI1YYsxeygXkhDjMSQsAODtCC5X6NixoDaZz//+dD/\nuW4TagsogT1zSmh4DFJ7p++e0QaOICaW2U99pZ9VSj2jlDpGKdVwd6yUmlsptbFS6noAeBwAPvIR\nzjApT9eSChdYeE/swvbyy/F1h7y8l9q899zT3x4pOhgz6PTTm2mYtgAV3AWJKuXENlDsALzHHs20\nyZOjmkQC9g6oDrcxUCUIvtDcHI20UvP/Rz9KL4s5KU+B3T9tdtop0SuwsZfS1r324pWXQMhksbSm\nGhal8Ze/pJXFtO/sfCaEeAyMynuoH2rWSmlDTLuPPbaZ5h7KqYzyHOBqC0ojFKX1hBOaaVgbv/pV\nmfZstlkzLeXCWvPew6HLMd/GzFuk9i8pfP7zeLrLIMJMhHzlOKCWp/rEyTH/OQyiFOGTNGqZq6Fz\n6/zzh03Exo1r/934mK0FORnpUlHMUkz6qG2UYNiRqtBarwkAxwLABgDwlFLqn0qpZ5Wx1ISGAAAg\nAElEQVRSTyqlXgKA1wHgG9CLdLac1vp2ftP6G1jkj1ILOhUbbNBMs53KGey6a3zdoQlUWv0z50KN\ncaU5nGpMO6fUAY9KB7v0cxx4xgBjvlEhdYixnZlKv5tSl7zbbmum2cwliefKMW5ffFGmnrZ3nUOL\nLwUpGkRUXwCYY3esvo03bqalmJ0usgitjA3jnJrrYyiFtoGU5DuHr5MU0+Fc4Jis5gBmxmxj9tmb\naZhz/ZEjZdoj5aOrlkunNF1fxCMKjjuOR1uybEydOQVOq64qX2cb+oFJX5uQPodVCCb4D50JMM14\nF6GAGbFm3ssvH5c/FiFBcmwAJxscBpEtKEsREHCYWFlMzHoV69u11hsAwEIAsBsAfAUArgOA0wBg\nNQBYWGt9nNa6Ar5t98gRnUzaLAsri4UaTbFBT9EgyuloGGuPMSfi0tkRMcBMmZyYCnpsW7johw2U\n6vOJWp8N6tzpUp2Ws7HZuPXWZloODaISKMV859ChmqLYSGEQmRC7IXAcRWJaRRi474UbJtmAMx5H\njQKYay58nY9ByOF4CjjrkPRaHzJtLb23hM4tbWcUu61Sa/1TTzXTUrQcUoJn1MAgytkG7F1L0ZOa\ntz5/I64GERWh51tssfTydnvs7/O12Ibk0CDB2siJMFx6HlDp2c6KuW285ZZm2mGH8eoECI9R22Qf\ng206D0A3Z08Fpp1j3/kwB9ElfBDtu+/g95R3Tb0nS2g5RW99Wuu/aa1v01pfrLX+gtb6Sq31r7XW\nHwHrTh58g+F2or6VNIMoJ1JMI0Iq4QYvvBDfHuyQF7poU0MQUn3v1CbRSsHmm+ere8SIZhqHkYiB\nyyDKIfGJxUILxZehttse823PFXpmc2DHpFk5kPIO7DUhJcJKLH71q/gytY7HlGh3bQxwHzjSMhvc\nS/748T0aObSAOKhhrzc46qj230v7/wj5/KOOCak+xoJeYFp8IUibTkycGF9fCt2c719KO2u11Wh1\np8Dn2D8XgyhUZ8r7wPrHgBqRKQbYM3J8XdZyjnZhr0U5oydz9kHuPAgJ5KWBCeRyaoOmlJ3uGEQf\nIx4HHdT7rHVxsiHFcEoxMaNqhoTUJTHJCbYwhhZLKWe4Bhw/Gh9+KD9+UhiOmN8GKWAq5lIX4DHT\nPKd1GcVA6qApPQ7sqBJUpmgIxsH7gQfK1BcCV6twxhl768GoUe319YOJWU2wffGljH8zX7m+mKQO\ndHvvTStT23vhRKKiorZnDpksUTWIcjLhuKaTBiHpvQFmVpcDJmJVaL+lBlQIAXtHKQyQtddObwMm\n4ApB63gG0TnnDJY1WGWVZr4cEUJToi7F0kspU0qjNRfsd/WDH+Sj06VWOFaeGya+Deuu2/57V8IV\nrrCKekbH6HzMIKoQZqByFyeMcy4tlZFiEEldbDDam27aXqZUCOY2SEm0DEpJX319t8kmYSd1IYwd\nyytvkNIX5rIQspNOOVR9/eu0NkgdTmz/RxyY9uy882DaddfJ1G20RbjjltpnXDqHHtqrA7sgprSH\nGu0uhJDWTYn1Xwo5I0mGwD2UGUl/bRcMLFoihh/+MG87AMJ9U1sEodIhjTFIjacll6Tlsx3z54SZ\nb9ttN5iGmSfNNVe+Nki5IqDWM2FCPD1Tf8wY++QnB8sZpKxvpvyGGw6mmYijmKsJgHatvJxM+hCd\nNs2mUNnakIOZv9tuvc8ULV4D7vvDLD+wwAsh33EcjGmE2BoK6vg488xmWsr9KCVynGG+hyAx3z5m\nEAnCt9mZFxXrxMsFdsj7n//x00vBk0/K1JdDvZUKKoOoNj8pNdhHY30388w9E5wFFuD12dJLx5cJ\ntfGII2j1GE0GLoPI+ESxzUK/9CVaG6SAbRApzDcjifA9M2c8mgNrqUsh9zJg3qtJu/BCvAzVHPjI\nI5tpKc61Qwd/LFomB6XNQEIwGhbc/aQmUywb11zTdQvKofT+FnK82iZhzeGDSAqf+lQzLeRI3cyP\nUs+CzTdbU7UEvRSst14zTcrM9a678DKx88LQsU2R1lijmQ9zBzB2bM+X2nrrDY4J+5J61VW9z3/8\nI65NAHnmdw0m/TlhniVkXRHCuee2/77qqgAzzSSnSZuS99FHm2nYepTDVNHgu99t/53a95/+dDNt\n6tT49qy8cu9z/Hh6GYw5heFjDaLK4Ot8k37ZZfI0zcJgc0alD8NSDCJbPVVqkcekUlQGUemDH9cH\nUcwiQq2TkmakDwD1MdVSQme3gfp89uWj9IEFa2PIdABr40039T5TnCeHntnMLSknwyGk2O23MY19\nUQipTmUx05EUyVitjI0Qhg+XrS/UDyGtUq7vhVwaRI8/Lltfl+jy4haijUlq2+a/Hdq7NgaR7eTU\ngOpHKMd6gvmeol5OpHyCSDESMOabFIPIh1gNIpPXdvKLaZBhZmfGkbS9ltm0jZsHez/lBL2J+Z1a\nJsX/nUFpLcaUsZPST3PP3UxzhYY5TMS4ebs832C0OcwpzjoRo9lFDVLzsQ+iDDDqmzZmmolWNsQg\nynGAMgu+8XPU1o5USDGIjj568HtpDSIMORenHE4HJ03qfUodWDF6F1/cTDOLZi2XVftgJH14T9nY\n/vd/ZdsQQ9uA0w9U5/AxoPYjJ/y4jQMOiC+TsoGm+G3ggNqPUqYjUnOceiEvhVKSU4OczJJPfEKm\nniee6H1Km6z6gO3LOU2MbFDXzFr2uDbYc32zzQDWWYe+buV4PkxwRTXVWmIJmTZgDHmpM2Zuxmcs\ng4jqBgLLNzDQY37+9Kf4mDBrwpVX0tuTE1I+EQ3uvVe2Pi6M2RWXQYS9f3ttbasz5KunjQY3b5eC\neyqD6BvfoJVNQc51WaIfk6pQSo1QSn1WKfUFpdQF9h+/Sd0Ci2aTEjUI48Dn2GikfH1wMP/8zTRs\nwNtSZamLFtU5YT+opbZd8uz2S12qMTz7bDPNVoOu4aL1618Pfu+KQZQCKX8qWBtDKuE5HURyEIoe\nRm1DilQxJ4NICtTxyPEtYEPq+TDNgNJrh3T5LvYQTDMwZE5AxVe/2vvMKXCwgTG2TjxRhraUEGuj\njWTqLoVhwwBmmYW+bkntQTY4l0GpvsX2EamL9oILppcN4cMPe+cZbj9QGa0DAwD33DNI26S5+M1v\nBr9LaRBRsdZag9+NT8TFF5epuzaYe6LdxynmfaG59dRT/vdI1UiJ2Sc447lLBhEGzEpBat1KMf3l\naCpl1yBSSq0HAH8AgAMB4EgAWAcA9gSAvQBA2OCjPJZaqpmGaVWEYDMpcjKIMOm/tEZAaFBh4Qu5\nPiMMUtRWqaHYS2sQhZ6lzY+MXfbWW9Pa5OKGG+LL1MAgyhlhJqdqrFTI9x12aKbZWlUY2uZbl8zT\nUD+WnqO1MYioBwc7Xw3McGrfLrxwen3c9pQoy8XZZzfTpH00SEtDfdhjDxk6KbSp8wi7iOZ+/6NH\n485afXCf1ZhAtsEIlTDfGVxgka1SosZyEBI0cHDJJbR8KePk0kt7n5hgLga2o+m29thp1AiRVEjt\nO0ZTHgDg5Zd7n2++KVN3rbDfATXwgA3MQbpd53e+EyfksJ3LY/WFQL3/UM8JORiENZgOG4fkXA1C\nDF1pEJ0DAOdrrVcAgP8AwDYAsCgA3A8A3+E3qVtgoSoxBggG+yVj36UWUFuD5Fe/av5+yy0ydKiw\nF3QD6uYUQkqfbbIJrZ6cC0TOS9oCC8jUY/sWooB7kJDyS2Ls5AG6u7x1eWncffdmWkgKJM0gMlJI\nLnLMQarj8n5gEFHHWW0MIgw5NQhSaGPYeGN/edtvB+b7zkbKO6Bq4kqj1AVRSsstBfYzGn9VtWgG\ncUyMqOPM+L9cccXmb9x+wMJyY87zc/Y35oNOSoOIev5PwfPP9z5tregUcPYJKSFNisAxhO9/v/eZ\nolVTGilCYQwpZZZfvr09pk7jksSXzwALKFPKxKzLcwIVnHdtlz31VH99PuT2iWYj5Xi+DACY2Bvv\nA8CsWut/A8ApABAhB6kTnMFZikE0yyzNtC6jbqTY8kuZmFEjcVG511J9J6Utg/1eerFUqsd0/NGP\nykviQ05cOe8Lc2xbWmOlVN0pDKK28XjKKYPfd9klvj3UfG+/TavHhokMkUK71LpFBdX5tj0P/u//\nZGhzQO1bKR8kIVDXCayNhx8++D0n8426HklHfulSgyDHmjh5cjudRRbprREpl+ociGUQ2Xjkkbiy\nOZ4Fo4/5BMp58cPWyRS3Cxxn1xwzxxwaMqG1Q1qDyA7sEIqq1wa7v42wN6eGmAHXj58U00AKhxwy\n+P2NN3pzZOTIdNoxbcSE2NS+oJq8cSGt5cShy2UQ2T6I2/JR/SkbpGwXbwGAmf7/DwBGW78hMrD+\nB/fgI80gKm2W8Yc/xNMLTb6cFy0q0whzzhmKBkWFlDTBxn/+46+7FErTxlRdbXCjE1HS+gGhfsgp\nycI2dKlDR4zpRSyoh4FQGQw/+Ul8ezBQHQjb7Q6F925Dzj0KS/v859Pr47aHitGjmxpEOdYJbA5j\nWjcYbc6FrDYtLm7dmMbHoYcOfk+NGpULse2xx8mrr/Y+Oestl2nEYb7mRE5m7mqrNdNSnq+079Cc\nQlGbSU3dtzC/ZLYA3JjlhzQ2+x32e5F6H6NHN9OWXTa9vpjxjVmVUJHisiQFWD93pX3NfT6M8YM9\nX2xQiJSh+AgArDHt+w8B4EtKqRMB4BvTfpvuwNUG4TCIMK52iPmQEk6Zg5SLdmhjNLbyKX1G1SC6\nAHGpHkMPW4ANUhhEod/33jvcptyojYHSFSc/h4YYFSmHvIce8v/GbVdprbKcdeZgtHFA1QzhHCrt\nA3np6GulpIWc/jF9ojVd6p7SjxgzqEsJNBWnnSZb3wYbxJcJ+aXbZpuheX391YXQgKNBJAGlcN+b\npWjnwtNP56sbW5exZznrLHnanDUaMzGT2vOWWy6+PVjd6603+P1nP+t9lvBBxB2L2LO8/no8bSmm\nofRZdnozMZM+t0rNyxCogk0Jk+6UY9MRAPDotO+nAsBPAGAHAHgeACq4wvKQ47LDYRBhnEFOGzFb\nVS5SJnmoL0zoVCnNByyN2xeYFKkEMBPD2mCbZRjkkJZJbxw5paFdmpi1mep16bOG2t+rrEKvU/pw\n0g+g+l3CcPzxg9+lfD1I+zrpUoPIlL/lFr6vEAC/FA870GFmZ1RQHRJz+2biRF55F8YvQypsH3UG\n9jM++CDAM8/kFQbEgKvRxL24TZxY17q32WYy9bz2mkw9mN8WDFgfPhIQmT/6aPvvVGB7OKaJcc45\ng9+pzO4nn4xvD9XMGwPWnjXWaKZJw3cO+spX0uv8/e9p+Uo54S5lViW9nqS4GsgJDoMI0/blmpjl\n0gyMqkIpNQwARgDAiwAAWuu3tNYHaK1X1Fpvo7V+gd+kbiE1sG0/ECbKw4MPytTNgc2dlwI2EP/8\n5/Yyocl0+eW9z5Tw3VQTMwwxXNfrrx/6/5gxg99zMhCkzOBSQG3jqFHNtClTZNsCwJuvXfZjP6Am\nZ8cxklis3dh4xPK9+2583VLA/PEsthit7LzzptPNcTk8+WRZOtw2UjWxMJOHlMPyTTf5f9tiCzwd\n20cxYQC1PT/6kb8NIboxkB4/WH1f+AK9/O23t//+zDN45K0YSO5lL74Y14fSUey49Ukz2mqILmTj\nk59sptW0N/qA9bcdsttcukPvZd99afRsZhdmOswxRS+laYqBGkErh/CdA+o8omqudslEll7zAHjr\n1t//3kzjaPvmCHMvoUgQtRRrrT8AgHsAYB4+6ekbDz88+P3FF3ufJmKBD9SFiONIL8fmi2k5mfB9\nPhiGTShCxAcfxLen1ESNrbsfDhUYQur7mGox9qxSUcxsUN8XZrYwbpxsW0LIab7DqbtLEzMMWOhz\nrros5uQSa/cbb7TXk3MOY+0x7Q6NVSnmS+j5sAh6GKi+c0pgoYXoWgA774ynu20PXVhSTEs4/YPt\nwSnRV1NQ4r1y9w5p5mSss88QYrRdMA00zvPNOCPv3MPRus15BssJ3wW6lNN9Fyn70hVX9D5z9Dd2\noccYbVSkmJ1KgSpcpu4xpUBdt6jmkkrhkTY5oK4JnPPfCSfg6Xvs0UzD5tGiizbTnnmGRnuttZpp\nXO2s2k3MfgcAHS2D+ZFDyhmSSht86UvpdLpkEGHSglA/3nln73OZZZq/2Q7uQhpEGB2qDyIMnEll\nt+W555q/X311e/l+ZSBhjqQ57yAG1PGMXWxTou/F5gMY3IBzOqTscuxwDvmlLghS0uuc/dw2HkN0\npS7ppRlgJcr6QtdjoK7/e+6Z1hYAvqo+lnbeeTw6JdClvwkqSjAxMHMZjonJb35Dz4vN76OPLjM3\n+0GDSHqPxsyzFlpIloYPtfkvS9lbjICkK3cOAHi7TzqpfDsM5p6blg97r5/9bDMthkF033002hg4\n45EzRkeOxBljVGEXpp1Nbc/FF9PycRlE3Dp9SFmKTwKA85VSmyqlhiul5rL/+E3qFlLS+X//e/D7\nJZfQymDq7Rg4Lz7H5psygW65xd8eu6yP+2tA1abCbKKxNmIS5P32a2+Dga019Ze/NH83Dvf6DSEN\nIsxkolR0DupcwMYEh0GUAs7mGsLBB6eX7ZJxVwrU9nTJIGo7GIXmE/X5ME2kGA0i6YtkicOOUvTy\nvn52y195ZTMP9TAYAyrDinOIpY4dX1AGzrvBwiFjyDHvOIwNLC0l4mBsWzC89BI9r+v/Ytgwvqm1\ndD9Kw2d+Ow9iB/Hee7Q6fevEO+8M/T9kNWDj29+m5ZM2/6ltr7afz/Rnl23ErBgwrZJSOPdcWr4R\nI5ppmNmRhKZJKkrM/4EBgG99Kz9tbF7abkdy0sHQFYPohwAwFgBuB4CXAODv0/7+Me3zIwv7hbzy\nyuB3qgYRFZzwfNJt8UFKquRuuC6o/oaovhwWXLCZZhxmh2DC0LvfqcCehdruUuAwZLo85HdZ1uQN\nmV1iB/V99qHRxg4DVHTJIMJMdbhjh/NeQ4elnIxPbJ2R1iDCxhhXo4WTrwRytAVzhMx1Co2ZKJTo\nb2pZ39zg7Alrr02rLzT+7fOWNKiMDapJH7YPlPID5TJLTLnpeb5OnYqnhzS624AxDZQKmyibfBgw\nM2gqSkVQ4oDTxi7HJ7bnY8zgUm2kMnSofnuo9Q0MdPceuGMHO2dS/Tv66nSBtRFzSE2tjyP09dUZ\ni5SlYR3rb13rz/w/3cHX0a7PIF8+7BAUQ8cFtqBTD6eYZkuXwJ4FC8UZA85igql/U53PxZgy9BNy\n+oHCcMop9LzSvhO6PIhgTJ7jjpOn4/qw6JJxN3IkrSyXQUT1YbD11u2/59Qg+t3vmmmYBlFIC4iD\nJ57w/2Y7OE0BVbBx6608Oi5ee01egygHQ+bQQ5tpnPVNei3jXiRzzp0112z/ncNoo45bKg0s9DX3\nXaWWl2AQldgzqWY1McCY5UstRSuLrRP9YELZryjBxNIaF9JgPjZ32imdziGHpJcFkBcaUBlJ3HH7\nr3+ll82hQYwJZGpy8xGj2ZlrnYmedlrr+9v++E3qFjGdSg29zHGwhoX8xBYxqo0uJ9oNAMDYsbR8\nHGYXd2Bjl04MGB2MmbfssrT6fJIqKjiHTkzTRAp2RCLqQnTAAc006uJ71FG0fAD0g4O0iVnKGKU6\ntkuhHbOxuc998814vhI249QLGRe+yFEuzj+//fff/rb3mcMhJXU8UscyBs67mmeeMiZmHMkehjvu\n4DGIOBoyAE3pJcYgwPL5aFPnjPRa5stHLZ8iaDDIEcWIozn1hz/I06VGi5KEGTclLuCccXbZZbJt\n4YK6TmBnUV9fd+WCwPdeqOfeEsjBVHPfw9VX43MQ85NK1brBGJs1MSEA4hhE7nuIWbN++lO8ztQ0\nKnKMnRJM3q6EBjaitwWl1Jptf/wmdYvauPuYc63TT0+vj2s7u8givPIucnA+qRpb0ohpt5RPFIOJ\nE+m0OeCo2+ewncU2bypKMYhMXsNciAHVdIzDIPrf/6WXTaXhg3RUDC5C7f7e92j5pGmnmJiFtKHa\nyqa0IVSnL0JYan0+cEw1fNGyXPoxfeFqpd5xB70sh/FHRSkGEUfrgurfx4cUk28D6mWQIxQbGCjj\nC8R1kFxSg4hDoyZNOgC66f+ECc0037P84hfNNEzjf6ONmmnYekRlquboH+mzXo42Un2+cnDmmc00\n6rP4zvTSfYY5TacKqzE/XrXBp0HErdNFKd9Atfsg+hnyd5/1N93B90LchZ57gKKC6nU+R1tKc05D\nPj84B8cSi4YP113XTONoEJWSSoT86LQBayPG4Inpx5refw5QbZg5DKJjj6XXSdWcofYt1QF8DEpc\ndjjq0jG0MRMzzNQLK7v++rR8pfw7jRrFo80Btd2c8OXYs2y5ZXp9AHQmNhbtswRjIwalAhdgwMLI\nczSIOMihNb3wwrR87viukUGUQ6t0xx3T24PBdS9h6qPUieXZcEM8HdP4p4aLpwpffG2WXps559tS\nkU0nTUqvT3pelzqfHnggLR/mg8j3Xjht5+zBGEr5TuLQoJ7zfcjFNEqZdvM4fwsCwIYA8BgATE6o\nryrkmND9sEisuCItH+dQlbLxh1S5r7iC1h4OcjDfXD8wMXV2ydh44QXZ+rpUty3lnLEEky/mWdz2\nxGxO0nOBevnijhPpg2iOyy7WRmPSa/vGwEywOO/FZ/JELS9dlrvmccpT93CquVRMuzkXqLvvptNJ\nRSkNohzgvH9sjeJoUvvGJ5ZO1XKgnid8balJWEI9J37zm7w6OZA2vx4+XP5sRQWVQXT00Xg+qtsJ\nrM/mm49WttT45JjVcYIHYeCut9JnMOz5fOsg9txUxYZtt6XVR0WMBhGHDoe5eOqp9LxuGwcG6GeH\n2OdL8UH0pvP3N631jwHgWAAgBuD7aKGrzRdzpOZrC5XRUkLrxk4LDWhqmFwq7dpANZcrxWiR3vCk\nQ7b6wPFBxFETLoWY9lA1H6l0OBJf7GIjsbGlgtoXVJ9vPlDDkq+1Vs+cYeml2+srMR65mkacccId\noxiWWCK9LKaxg/XPsGG8d1PCxIwK7oWFegiubW3FtCY5frJ8+8699zbTl1wynU5MW2qSsFPXCSpj\nohSoa96bb+L5/vpX+TalYsKEZtuxCL8AADfdJEu7hOnXwguXuct0GblN+vn2249X57rEEFYcCxkM\npYR5VAf3GDCXHL71xB1TkybxzjJtkJShvwoAgWNs/eAcRHNMaGnJl68+qqMyDjD/R11GkiqxQcQA\n20yonuy7DFXK4c6XYhBhoM437DIQ43A6hwYap2xXWiAYMLMjzL9DKTMoKjA/NzH+3TbZhJ53nnkA\nzjuvPU8/aKl22caHHmqmUU01OOBKL7F1HZsf660X1y4bXO06zNwSq9N3wUzFiSfyylOf2+eXKrU+\nLN/ddwM8+yytvCTa2oxFb5WW7mPATExq80FENcvBEHPO74pxN9dcdK1JaQfymNuBHGZH0uMW60eO\nPzyu+RZn7GB9E7N+lxDyUdflb3+b3hcrr5zeHipi+uZHPwrnUwoPCsTVxAZIc1K9ovM3Vim1IQB8\nDQAS3LDWjy4lWqWYGNKLDpYP8xdTW6hxDnIwabADGYYSDi4BeNz4HAwiabMsKu0//jGdLgDAlVc2\n06SlTZiDTC6oYxxj/FCBbdI5GETSDItcTDpJQQSn3fffX9faPNlj0I618Z13mmmhiHV2fXfeGc7H\niS4XUx4zBx85kk7HBdZfRxwBcNZZzXzUw+2118q2BwM3DDAHEodvGy+/TKcjCVM/Rkdae5n6LKuv\n3kzjnhOl+xHrmxKagj5IX75jhMvSjAgMHO0MDDnmFVYntkdRI0n7xgSViZHjvbh1xow7aeEy5tQd\nM4P85z/pdKgWKaXOQZg2ndsXSuW7R6csS78BgCemfZrvPwSAmQFgb36TukUMdw+TSlLr5OSjQvoQ\nAwAwfnw67S61RTCUYIrFAOufbbah0anp4uYDlUFUCqXMN7DyJbQXfJsdleHAma9Up6kYSkifAHjm\nGyXHsu/ymIJPf5pXvsR8pa5vZ5+Nl6fOa4zBIL2OrrsuHt5XGtR2U9//qFHNOj/1KTptqm8RDnLs\neb/5DY0OlkaNOEkdn9JaExjaGEQcYL5cqBdjbF5SNeRifHmUAMe0vRQGBprarzFt5FzypfGZz9Dy\nxWh2UoHVh/VjjL+wCy5opq2wQnp7qOC+K6y8tHAZW2+xvVYpgP/5n3TaGDgmxhi69FXVhhQG0SgA\nWGLa5ygAWBwAZtNar661/j2/Sd0iplN9IUNTgQ2SceN4dbrgqi0ecohcWwD8IV+p6IrB8MUvdkPX\nhxhpKoYY8xgXnAPC6NHp9cXmlSybA1/9anpZLNyoj0lDfe7TTqOVLcHQyTHPuzxAYdh/f9n6qAfW\nUuapHGAhf31MCGr0Hio4e3CM+QX1MomZLVDf4c9+Rss3bFizzgMOoI9RjlCllEAGK/+739HyYWkc\nZ68+cJ6RYhIi4YOIevHjCEW4LhAoz8cxBwIAOOooGt1S758KbK5jWgk52sLxIYoB8xe2yirNtBx7\nXo4oZphvmZjy0pDUZubQjaGtFMDTT9NpUZiM0qZoHE2snOe3lKrXAoBXtNYvTPv7i9b6P0qpmZRS\nu0k3sGa4B1GXYWTAmUTUMN7UCRTDINp5Z3p5yfYstxyNBhec94JJ93Jw3amgRqHzgRoRxO2zffel\n08CeD3NwmMPEjKMNw5XkUucCx48IdoE+7jhaWV8fYgerEgcCjEbM+K5JyyUGGLO0BGpjlGKXwbnn\nbqb53vN226XTxvoCcyDJqY9bHoscI601hUU2VApgjz1odDig9pnPxLAEOJdBpeQl0Bi23prWFvvT\n4DOfac6vXXelCwM4c4YDjCG75Za0sl/+Mo82FkiAOkZzCJepwM43m2+Om7Jg4AgIt9+eVpYKrC1Y\nQIkcoc+xu1ptDHBqPs65OqZ8ibNH7Lum5C11ZsJM413EvINYZlIKg+hqAECOa5bysOYAACAASURB\nVDDntN/6GpyBhHGvuSjhSM2XzjkEYdJd7Fn+859mGlVVO6Y9nLK1XaAwcFX6U8fuUkvxDgjYxY/b\n31ttRctHXSwxMz8fSpiOYcCexSd1dfs3ZoPpyrwxZk0ogX4wjc2BEsw3joBg553p87qEyXMp33Cl\nGLclfIFQn4WrXY05YZYOX+4D1RSGA2lz0mOOoeUD4DFbOH2LRe6dOJFWniqMbYPbF5hgo6s91AfM\n3Gq11QDef7+ZzwW1b0vCFVpef30zT451+dRTAXZzVCQ4zJccTCwqYsYo1V+VtBkVlcajjzbz/vCH\n6W3hIqZvf4t4dXafMaZfF1+cnhcgjUGkAABr0ggAQAI4Tr8oYXvLsdukDsSvfKWMPS6G995rpmGH\n0H32wct36cPGRSkpEEaHat/PBUfFtFQbb765mUa9DLr5ZpgB3wB3372ZdvbZAJdf3kz/ylfS20NF\nzIGHox7LuXyXQolDFff5OAcojtp5CeywAz0vhwnp066ZMoVOPzdyaENi4KiZU7WKpaWwPpQIcw2A\nM1B23JFW9tBDm2nUZ8bmry+0M6cfKfPgjTcGadn473+bed96C2DMmGY6pvmImTxzQO2HGFO0HPsE\n5fIWY+ZbQoiJjTOl8LvHEUcM/T+GibHppjhtSSjV9H+FCQxzvPvZZ4+LThpCjkhrVMQoEhx+OK3O\nEs+CMUDef7/Z7vXX99dRC8PT1w4OgygW5GOFUuoJpdTj0GMO/UQp9bj191sAeAAA7s3V0FgopQ5S\nSv1ZKfWOUuoRpRRiMEED1zaZyuShqnpzLpdYvllnLbMRYf2AbYyYnwOfg0wOSjD4sJCdNQJ7RsyX\nh9tnmFNPHzAVbAycMbbhhvRDIkbHHaO+thx8cDNt5MjmM44YAfDvf9Paw0EMgwhTw6f6JsH6Awu7\njTkpLQXpDZ7q36sUg3iXXWj5qM4wpX1i3HYbvT5pKMXfryVRyr8TdnGnIkfEIs5cwBgoXB97VFA1\nabG90b08+zDDDLggAkOpy4pL5513APZ2Qs784x+4nx1ps0PsmbExGsNcTu3Hww5LK9eGHBpEOZzc\numHtfYwkatuxObzZZrSyMXD7AqObY12uTTOMCm4bqUx1aaEoVtZnXl77e6C278gjm2lcM782xEyT\n2wDg+9DTILp72nfzdyMA7A8AxKNrXiildgCALwHAqQAwDgB+CwB3K6WC7iuxF7XGGrS8VI6fDxI2\ng5T2YPmoEm3ORMN8J1CdeD76aDrdLkE9NAIArLkmLV9Xh0aAJgPk3Xd5Wm5Uur6Q7V05Q6aaXyqF\n2xFLv0Oq1P3445tt15ru2BdrN3ZBwEwHuwTHvw82JkqZDmGgjh3qwU1ay+Xdd+n1UVHqUtWliRln\nLYuJjOMCW8u0pp1vllyyjGR4gw145Uu8a2pYeACafxetu9OGU6qpaapU3L7XFVwGsVI0IY3EGKGc\nhbA6X389jo4kfOd/18QMQH4eSWvDxvhIjQkgQK2To3XZFbj3RKpwwqclKQkJbVjpNq20klxdkyfT\nNYiKMoi01qdrrU8HgD0B4GTz/7S/c7TWN2itEYOhTnA4AFyutb5mWmS1AwDgbQDYK1SQutl98Yvy\nDKISkJawxNDBLqGnn95Mo4Y0xBDji0daGorle+QRenswZ3ocYH02aVIz7Y476HW60c5uvRU/SHCA\n9SPV4TKXDsfMD1MJzjG3MFAdJC64YDM9Zn3C6hw7ll4+N1ZfHU/3RXSjACt74onp9ZWC7zLnqoTH\nvH/pULXSPru0LhNi3UfbBcVRcFv5EvCtT64vKCwfNwpRCY2kGFDpYFpqMW10L0u+c1mbKURpcM2g\nSuGyy4b+rxTuyoCC2Gdz5zC2N2L9eOONPPo5/LtQfBCVOt/EgNIXAwO4byIuJBlESuXZE1yrBiza\nYYwrAewZMcfn55xDq5OKGMa0NOMupvySSzbLbrxxM80VgvvmlhvgoAoG0SBR/S2tNeJauA4opWYE\ngPEA8BOTprXW0DN/Q2L9uOVpdFZeWX7x5hyWOGm+dGlTNgxUzYdJkwCmTg3n80WSi8HIkeE81L7F\nwuYC5FEJdoExfr7/fR4dN02aOeSjmwMYHffCivliaKsPYxC5aRiTrmvUFHWCQ0PaiS4ALiHDNDao\n7V53XV57uJBm8nAgbTqsNcDw4enlqe+QKvmWllLngI+R6B5iTXpqWpeghHyPAcfkTSmAbbdtpuUA\nNaIfhX5tTDoMWjf3cKVoGq0S45gSgprzfHvumV7WB99zH3tsM819vj/9Ca+zJqE4hoEB+UiC1PEj\nrdmLmR21wfWTxL0nYmmYaxTMByn1GU8+mZZP4n6ae53DtIAAcFcNGGNrhRWGpmHnOZcplYpoBpFS\naphS6iil1C+VUq8opd6w/2SaxcL8ADAMAF510l8FgKC80t24fYjhnHNDBkqi1GGOekin0p4yBd8c\nqaE4Y2hTpL7Yu8IWRQzcSwP1GbEFh7IIdQ2u1AUDdW5R36EPrqQSc+J4/PHd9jmFto+JwWn3gQem\nl+0SblQUAL8GGQVYpB2Acodqqp8tDFgbzz6bVpbDvM8xXzj9ncPhfleXqhizDAycvbDUOhgbvSUF\nMedBl2GVSzunNrN1CiYGxbjtwJ4l1SSYyyDCMMccaW0BALg6U5xo7DkppkM+DZIS4Jgs5fJBRAlL\nLn03MvcJSW1cLtOICqrPNyziZExbpDWIOMAc+Mc413eBrTmLLdaRBhH0/PocAQA3QS/c/QUA8D0A\n+BAATuM3KRsU4NHXLBwO55yzOQDYfzf4Kyyg/hlT316OAR31EuNjdnE0iDiOXUtoLsXmTa3Pd1ip\nSRODKy3oV2DPwtm8BwYA/vKXZhpWtsRl0EfDbTuWz2fSx3n/NTkPjsHmmzfTuHODuu7lwCpOuAaM\naewD1kbqhYdzMcKQYy3qan278spu6ALwGES+/qKGcadeELjAxh7nUI6BM3ZyXVhT1xSMSfP887Rn\n3GijNJoGFA1uH+aeG78Mpr6bHAyiM8+Up89ZWzEhFvcsW2IdxbRKMLoYkzRHCHmlAJ5+OtweKmIj\nxpa4j1LfNZUGVVgufZehahCNGsVrDwCtLzCNn4kT0zU7tba1Jm8Aw8/YfHPD16CFnkvZlqYCwL5a\n6y8BwPsAcIPWeh8AOAMAPK5ki+JvAPABALjyygWhqVXk4EK4/fbbAcD+84h7gT7oOI5vpYEdinxS\nAMyXQ45FNdUkwFW16xdwD6bUd0BVM+QyiKRD2lJxwAF1qTIr1dTOkFYx58LnkJZTnooc72rLLeXr\nTAWVIdc1k9U9MJfyQVQC/WAGM348wLhxQ9OWWKK5D151VTqNGHAYm76LVomLbQ7k0F7Nnc8H37x+\n4IFwWYzJ45v7kgyZGGDPx2EQlXBkDpAnIh+nTiyAQ4wmDpbXjYCWAz6Bk/set9mmmWdgQH7t8Z31\nUh3sx449ybHapaBdmsZaa6U/j7tPpwAbZ5QzF2bijcHHIBp0g7ATGH7G7bffDhMm3A4AF5LqTjnu\nfxIAnpz2/d/Q0yICALgTADZBSxSE1vq/APBrAFjPpCml1LT/fyFJi3rwpzoalI5YhqVh0uK77sLz\nciL/xMDd3KgbteuM0JfPhxJ+gHyaJiUYGzHhizFcSFtDWBI/DjBb7l/+Es+L9XdM1BkXvn50D0Y+\n6VxXTAKu5MwtG+MTgTrmMQeHPrgSqK6ZLxhqMzHm0MnhAyMVXMk1x/8RRofqrH3BBQFuQBST3f1/\nnXXi25UCbkS+Ukx6qvl/V/CNvcsvTy+bA6nzpqt9PhaSGi0338xrC4DMJTMntt++mYadUXxnWSzd\n9d3o+r3pGgMD9MitVPjGXaoQi7pXmzySCgYxliZY3gMOwMunwo2e7APWljnmAPjXv+i0umJuY+3I\noTQSY4qYQv4lADCyrucAYPK076sAQIYAt0m4AAD2U0rtppQaAwCXAcBsAPBNSSLuQNplFzwfx2mm\nNDDfAO+8U06qJVkf159OifDsGLgH8lLvADuQd3kBX2utof9jqsMmXKzt0Pyhh/D6cvhEcccU1azK\nt3ZwQNUMo2q+YGk5NrAYBlFX6u39Cq2b79t3UMbGrhvZar/9ZNolhRhmBSbZo44dTLpHDbigVLNv\nuXsCBzEmhl3izTe7bkE7sLGzzDIA++wzNG2bbZrjFHv/Ev5dUs91mOlfrMlLV8CeOdXv4/PPs5oC\nAACbbTb0/9r2pxjLB4oTboDmOagrLXMfcqx5vrNI6nzA6sPORiaf5LjCouJi0BofA9JMUaq2F/Vc\nzsF889U3h11IrcEpx/tbYVA75xIA+LxS6lkAuAYAviHTLB601jcDwJHQM3t7AgBWBIApWuu/StHA\nBsieewLcdJMUBT5WXLGZ5ou+0tWAx+hiHE7qJlZKg4iDUhpEGGLUqGu6fMe2xY7gtsgi8u3xwdUg\n+t73ut1MMAfCbnvGjWuOixzmUtQxHxMOtabxiGHEiGZazrCkFLh0sIhsAAAbbhiu67TT2M2pCtT3\nygk/TqVRajxcdBE9bwkGsQ9PPJFW7ogj6Hk56wnWF3PP3UzHgmBgdLnRDjkSaOwCTa3rrrvSaOZE\nvwZI6Gp/ozrh92kQuZFaa7tQ5wpxL8kYo5bNsU9whIZdwtc+Shsx5Qms3H8EYrhT72GLLhrOg6VJ\nMcRSwtwfp7U+e9r3mwBgEgB8DQC21Vp7XJuWh9b6Uq31SK31rFrriVrrX0nTwDbM1VaTpkIDNkgw\ntU6fqp7PjpGSTxoxEg0OOJPIF4mIgmHDupey2ahpgW8DRaJl8M9/5m0Lhg8/bGpjLL44jamS6x1Q\n5jA1FDJWNuYCQpXaUTUxfPRLmWqdccbQNCzCzDHH0OuszcTsd79rpnGj/HUFaUZWCUefpcCJyFay\n3a4mBhWlmFhU8wsAmibG0Ufz2uOT7q+8clp9XH9TLi69NC6/G/ktBpg2ZKmxm3tddzWrU+D2xYIL\n4ucWd/33jQlXI84nmC4F1+9nDqHhLLPQBd4Y3LOjUgDrrYfntZHDxIx696vJOgYA1xSkzvM11mjm\nl1jvOC4GllkmXC62PTH5o4aUUmpGpdQ3lFKjTJrW+hGt9QVa6zvayk6P6OpQl8N2tksTM44KJkej\nwQe3PdjhgnNYqU2DiOp80pdWAphpDBWcMdZWJwZXaw+T4pbsVyotahhoDoOIG4bVNdXoWirsRlHx\nRUtxEbPe5oA732M0mlzmXb8wl088kZaPaopSUySYUui6PTvvTMvnXqpKme/FMIgo+V57jdceHyjM\nEkyQKD3X20yJMf+XhzuBd6ja8L52d8Xslu5HzAlzDrz/flPblGqKdNJJ8u3B4BO+5rgnuJh/frxe\nalS/Y49tprn93eY3swvhPUe4mAM+s3EKbSoTueT5beGFw3liBOcAAIcdRqcfxSCa5gAaUZD9GAYl\nBo50uOgPP2y22w3XGAtp05MuTcw4Ucew9pRy/o0Be+a336aX7/JCiB1Garqgao1LgUppEHHsvn1m\nRi5KmJj54Jqe7bILTp8avY8DDkO964s2FVQNy1VWydsOH2LmEXUNpzJKqfkw1GZiFtOeLtdbqnZ2\nV2ZwMQIrSj5uf3MEf5hWGfUMRtVoiX02dw4PhnFOq3fixDj6uYGtUZRnwRwC5wAWmWzGGWlt5Ebu\npULaGfZZZ/HroPTPUks1GdlYuVKaWNS9p6bztw+x8zz0TDmUEHz1UhiwsWfMNdeka/OnbJ3fB4CK\nggvLY8KEcB5MM4CLrjYsjBm01FJlTMy49bmbVkx90ow2H21XwjNyZHeXROzSh2nYdB0+fIcdhv6v\nFL6ocZiL0ug6zPl88w39f7bZmrSolw7fs4wfP/T/kgcEVzrke5aRI/O3xffcbpQv6f7hRN4yoPqb\noq5RlP0yB7o8nC62WHpZarulgyjkQNcXBCwCk4sYDSJphgzVxMzXxgUWSG+PNKjnU6r5DsdM34B6\n0UkVysQyNjAtN6oQE3N875bFggKkOuCmtMkGZvrdpTYsxhjbay/Zs3Wpczp2ZsllOiTpNDuGbhca\nTgA9rasY2tImZrmBtaczH0QA8CwAnKKU+q5S6nil1CH2n0yzugVFAhJjx00dUNKaKhg4l9jVVpOf\nHFrTLnS+iYqFFacixtdJKnwbaJcOsjFgPhFyLI5U80jsEsvpM+zwxUGMOQGlHyXmlVuHz8khhZYv\nzymnDP0/Zr6VOiB0qaHjXqJi5j6l3TkcJE6ejOejHDK6PCzVdlCjAosQhaE2TTOMIdv1fOOsZdLA\n9kwqbd86StGGNBfl++5r/ib57DPMIFtfm4COevaIcUBuwxWmAODv4P334+qlrPcxF22XcfjpT8e1\nhwrKe508GX+WrtZh3zrapb8pzpnZHZOx9wbJZ4xxUp2KRx/l10E5bwGkK3OY+mxfS7k0iHLUxfVP\nltJtewPAPwBgPADsBwCHW38R1m31gjIA5p67fw+oGCiL0RVX5KH93e+mlVOqfinr3/6Gp3d1qJ59\ndjy9lEopxyEqBp+auQ2l5J3pYf3gO7BQLg251hKMNocWRQ3ahxx+oGpbg10/STGg9M9f/pJePwB+\noV9oofT21MbEwHD++d3Sd80CMOFSSSHCVls108aMCZfDtNdKMogoc32HHeihuKURs65LttFoVrp7\nYVehxV99FTdHigFVez11L73uOhpNKu6+m19HKUESFS6t4cPb/UbVAixyaD9gl12G/r/tts08bSZ0\nkmOD4hw7BpiWG9WtQQx8c4jbN/aYkqhPUosr5/6WEsVsVMtfx77qZcC5LFMHzpVX0tuTiphNliqJ\nk96glKIdZHx0XQYRlu+LX4xrk+SB991367vEusAO+V0z3jBJFeagj6piXgJdm5hRIH2ZKxnmmoqu\nVJmx9FTpYS74NPGww6ibz8dcpoAbkQkDtW+7uigbUJzhlmQaY34sKPMYczJf294211zNNnVpYkYF\ndR3FHNn61nTMxNgHznO79N99t8ck4uC999JoA9AFvJIwTPbPfCa9ji614aiaTwcfPDTNp2leG6iO\noruEuwZsuGEzD3YGNmd1yfeAaapx1rdcZlDYeevGG8O0Y+rEfo9xcJ9bgNI2d++/n1d38vFeKTWT\nUmpppVQh92PlUEIi1hWX27ehYoNs993zt4cLig+iNs//0rjwwqH/+w7+NUnefe0peWlxgbUnxvu+\nja4PMF1qEEnjT38a+n+XEk2A9DD30mHPfYhhJJVaEzA6yy4bzsdp3/LLp5eNwW670cbklCn522Lg\n9htVcsrpb5/mKoaYOUzRSMTGUkm47aEyX448kk9X2sQsNd/IkbR8BpLruMRa9t//4vWmIvcebMpi\nfnE4gVRywI20SsXAQNN8q18sKc4+O62cxJ5M6R9OKPSf/5xOpwRuuqmZhpkn5zjvzDMPwAorpJW9\n4IJm2q239j7ttiqVRzCd+v6w84RU30YziJRSsymlrgKAtwHgKQBYbFr6JUqp42Sa1S2onesLYVwT\nKH52fAwiSkSmksDei8sgwnzcmHLSfmgwUDbfT3yiPxhEpUDVTJAce5izx1woxSAqwXjiHHaxEKRd\ngRv6mnpR80l3nnqKRz8VMXO9pjUKg1JNtXyqj7NcoDjoLaF1F6u+z5EMu2UlnOb6aLmgmGpJM19i\nQA2E4QZlsPGb3wx+p74nI9zLfV7DLmMS5wlpU3QXOTThc9Tro8MBpkGYat42enR9dx4MlP1+iy34\ndLroi8ceK0+zDVThSw4NomWWoQkxMCy1VLNOTJNxr73i2oghNjS9AfYcscKAGKRsiecAwFgAWBsA\nbJeZ9wJAyzbXP5D0x9IlU8VnTuCGWadKvrp8FqomzrXXlmkPBuoF/QtfiOvHWBO5WFAO3qXhtokT\nuhx7Pm4Eu5j+oVw8cs2rH/946P+rrsqrj+M7w43wJYHUfuOO7xjTjc02a6a7DhoHBsrNOcxUCIN7\ngCsR1dKAGkmUYtKRGj46BW6UP4C6HLv6IB3Zpku4a3tJM1i3P9Zcs/d5773t5VZayf/bggv66wdI\nv2z40HbhcOljUdaU4l/+qOe41DWpy3FL1SrFwBEsbL65/7dSYehrBhYR0WbOUlC7w/4S8Jlvuu3L\n5caCqmmeijXWiMvfpYmZDVtoRNZsTWjPlgBwsNb6QQCwm/EUAIzGi/QXJF9o1xtRV6ZDpZ57/fWH\n/o9Jnszm18W7wGjOPjvAppsOTdtuO38dWCQNLoPDhlLNaAAlNzoKLUzqRUWO984xy+DWF4MXXhj6\nv3Qkwpi6fIdQyeiNMYwbDmLoHHigXH3mwskB1d8RxS9ZrnH7i180066/PlwOaw8mPS65F2B+8ro4\nNJaqt2u/ZJdfPvT/kpEWfetRinkFVja2fXb+m2+m5YuJ0PvSS3hd3PE9blwzjcoIS9WG4aCtPkmB\n8yuv0OoysLV2b7vNn4/DIK6FMWEgeb+J7W8MpfonJ52TT8aZwVS4a7IUqM/82c+m1Yn5gZJASWGb\nQYoJdcpWvgAAvIakzw5DGUZ9C2kNoi7hSliloyz4QNVU4F7oKOrsMQ7FuKD2b0w0CMxcQNLpnlLN\nS1SMDwsusAtrbifZJeclReW163UCg7QjTy76oc9cSB+gYy5vXLhrGVWLb+GF+bSxPnPNd33zqEuf\nH5LamLmYSLn7p8t5qXVTQ87WwAmVpZiIt0Vd7YIRIRH62s4X69Tb9acpwSDC2l2z2Vlb2d/+Nr1e\nF++8k17WtDFHNNGaQHGrQUVsX+XWaJaY6ynv/4wzeO95662badT62hgbmG8pbA1ODbCB+QpuO5vc\ncgutXiwiqKQWr5RWaQqD6FcAYAfbM2T3AYCHE+qrDqWYKLmhFH2xlG53ictlTX2dE12o//7hD+Vo\nYRGUJPFR0SCiSs6ozEmKmY8E+nG95bx/3/PWpp6+zTZD/zcOG21It/mii/y/STI2So4biolZvzJp\numa+Uejvuiutfq1pF4k55/T/Rn2vMWPZ/q3NKX9oLubaB10B3IgRec4skyc30/rBNPK++5q0U/2X\nYmtwGySF3ZLlcmKttQB+8IOhabkZNzWg9Ls46SR6Xs598PTT/b9NmtRMk9xbqWV33rn3OXx48zds\nDF16aXqbKMBoxiglGKQwiE4AgLOVUl8DgBkA4FCl1I8BYE8AODGhvukaXS+gmCYGRb1NUk1TApz2\ndH2ITcUyyzTTTDhVSUhKvaXoU/yf9Auw5xs1qgwdDBwHzS6NNmk6Ff3IIKKCqkGUU/pHoYOlu9Ef\nOeHiqc8Xq8Ze2/vH3o/rs4C6l9W45lHOCV36/MHAaY85+FPhY/ykjNMuzBBigfXtJz7Ru6RLgyoV\n/8tfmmm5+62t/hdfDOc/55xumbocBlFtYxJALiBNqShmVEhrC3LQL3t17BgNMeTb6sIYRBhym71j\n4yR2LwNIYBBN8z20EvSYQ08CwGQAeBUAJmqtfx3fhPogyXXv2h6fcsh4771yWg5dIPaQ1oUPKowm\n5juplDZMbhOvEFLpY4yXrsctRt9ETGjLI4HckRaff16urljMM0/6s1AdNXMxMNDNuuNDDGOydtMo\nDF0LDbA27rhjGdqlaRg6NWm+cdqCaQ+NHBmmacM1rfedPbA6Pvc5vM7Q/i9hTiA5XrpmGryGOMDo\nQgBqNDCxyIourVwa99Tx0i/amKkopUFUmxCdA2zti+mP1HDzLmKfi9sPofW0rX6OeX3q+Yb6vCnR\nRZPYF1rr57TW+2qtV9VaL6u13kVr/WRKXTUCe1GHHZZW1/Dh3S4aFMei77zT/SJPVQNPgXm2mh2D\nxobNzv2+OH0loV7u0qe2J4eGFUDTOXCqRMJXNtf7rE0TEEPqpX7MmHSa3DD3VMTOaxuYCjd3Ddt7\n7/SyJcYSZ16l1NEVatMOctX4bee2sehyLeMI5DCmceyz3HknrTymaeQyiLAx0mZihtGVZphSTONy\nvX/sgkOdR+7FDfMB0obQXoM9c5vvS1fTYI452iPZpQLzX4kh9Z3NO2+3662r5SqNUuv0UUfx6wi9\nh9gIzzm0AFPAHV8chnWp+5Y0QgL2M86g1ZO0nSqlhimltlVKnayUOkkptY1SaroJlIgtCjvskFZX\nW+QAaVDt2mebrZmvaw2iY4+Np01tTy6mAQWcAxqVsZXqgK0NnI1xt926pZ8Du+wy9P+YudBlmHvu\nxpgTxjl5be9aEtQLKxbm/rjj+PTdSxX1vX7xi/UdiiQZrSWfzaWFRWiiguoo3NDcd9/mb9g5Ydtt\nAQ46aDDN9T9VAygSUOp8O+CAZhqVIdM2dlz/RDHjzGVaYJcTrL62NlKFNXa+tja7fYRpCeSaW5iz\ncere4UZ9bfMjhSE0rmKf+brrhv4/dWoeJ9xUwWvqOzv++LRyUthkk3AegPQzxv/9X1o5G1jfutGX\np0zJQ8eG0Qgqdd7i0LGjKkswiCTLUrXyJGhJwq5/3XVpZaIZREqp5QDgjwDwLQDYCgC2nvb9WaXU\n8rH11QjsZWMOWymDhxMaUAIuMwigKdnQWpZBdMoptHw2cpri5Y5+YSC9EFFDWqc4HwvR5sBlpqRA\n0rwlhy+HmE0idW595zv8NqVeoqkbCAcS447CNMhFm0pHUjr/r3/F0U81pcMuY6nPIQWKs2cMJd71\n+efT6S+3HG3cYv3oM0PyATMToMC3H3/wwdD/29aXPfdMo+0DxuxI1SqkjgksPHLMWcUngZbUxDn1\nVFrZtnl54YU0Wi4wTZzaGMtUlNKGVKp5Js11/qVqylKi92GYeeb+eN9dMogwpLpQ6Gd/jTH0f/GL\nMnSodYX6Hfvd3L1rtlwJIWVZuhIAngKAEVrrlbXWKwPAogDwPwDwdcnGdQXpF1qKY4sNFFdS4rss\n55hUknmVql/TgBOdCOsHc2jDJIh2Wg5zGc54kHhPtb/rLk1rStTrc6LHMT3JAff59tmnG7pt+Sim\nA9T6rr6ali8WoQusdP0+xNDtWoMIE77kNJWOQcrzUcq4F1ml/IIMqTWtZ6biwwAAIABJREFUbf64\nNDbYIJ1O2yG/jWYbpJngWH1YpFrsnHDPPX4aqYJMiedLdd8AUO6c4PoMdBG7FmG/bbnl0P8vvjjc\nrhTstVczDYskW5uwhQNJ/3W1ItR+6ecL9SlV29UOfnHwwc3fY9vt5o89s4bW2xjaMTjnHDw9pAWK\nacNKIYVBtBIAHK+1/rtJmPb9RABgKE/Xg+23Ty/b5SKDTVgKp7omSWwMOJN3+Uhdt1lmictvI3Vz\nalsYJBlEtb1XgPQoZl1qEPnqxC5VlLJYu0ePDreN0qZUxNKXBOVZUjUmckGp5iUTs+3nMDu6BNUE\nJxfTuMt9Czt4jhhBK4s5rnVRmklO6SfXVAcgn4NdAyyUsdGMS9Ug5CBFg6gGvPee/7dQO6+4Iq0c\nBRgTjopSc+Saa9p/l2AQuVqb660XblcKFl88T739DsxKJBacsx0Fbe4kbDpt57SNNmqmuSZvbn0Y\n2nxsAQBcfnl7fWYc2sxXTHOdu8YsuWR6f3PeXSzNVVfFrV1eeKGZZgsFsHcttS6mMIj+CACYV5cF\nAeBPvObUAexAQkWsbXNOSGvd5DjsUEMnS9M+4QRavieeoNOX1sQK0TJI9Y/VBs64qUGDyDbF6Nrm\nWnJMtJlvUg8nqe2pTcuJW7YrcJxr5wJlnGB5sANN7dp/ADLjBnP0mOoTpV8ZhBhi233ooe2/t/kG\nStV84/Qtx8RsueV6n+4lve39c7TBbEEYNUQ2xpj49KfDddSCHPtbyrm+zcQsln4XoEa8rK3dGCjj\nNibCJ0CTARKD1HnU5k7Cfg8YI9/8PnZs87fTTotvSyjghcvMch2mG8GCLSx59934drjAxmNKBC9f\nXZx8IayxRjPNdrBv6Gy4YXs9XTKIjgeAL09zUj1i2t+2AHARAByrlJrL/Mk0sV5gg8KVKta4eEoe\nRvfYg9UUln8gaoQGDox6e5eXanuyYwfjVP8BBs8+yysfg1RTk9gFL3cY85j3WspJde5LpvRaVuPa\nSEVM21MlTrVpo2LIpS2USlupchHqqMEBVlstbzvaQHk/0gxak0ZlpKRoJXKYJwC4ZjVVQy3FxMw9\n2LuajhIXESwUs22eR9VowRyb17pW59AOToGEBlEOcIRGSyyRTqM25NiTOPPkC1+QbQsAwHnnDX6n\nvjuDlHcYy3ShMFklzrAYnVQGEXUPaxtfMWNvs83w9COOGPp/qE9CQZ+oSGEQ3QkAywLAzQDwwrS/\nmwFgeQC4AwD+DgD/mPb5MToG9aKdqqovdSlNWcCNOr+EaigAn9ECkH74js2HMY1S8dRT6e3BILEZ\npy7oGHJoNKVcErh5pMBhduY4aEk6Xiwt8ZEC1re5mIYYarloxcC393Cd9ksjd3vaNJ6pGroAAD//\neTxtac0XLkJmDwaXXdZMy2GeTDW/s6P2GBgGpE0P8zdEBWdtNCb2rql9iXfcdhaQ3I+kHQC3nctq\nOxNwfAvWvk8A5Dm3UIUjWL5FF5Vvj13ndts1fzdM8dreV2iNpL47sw9i/tRyC/ilxpevntgzhFRw\nrJTQ9OvIkP7ooEuJKtX/jeSG1UZz7FiA3/6WVk8KbQ44foYAeMyy2MNEbs2Qrk3Mhg/n0bb7M8f8\nk4460g8MImmY98LRVsHSOD4tpNEvDCv3HQwMNDVxajSD6lKzsxZaJ5/s/23ffQEOPHBoms+3Xcq+\n3Aap56aaRgHQJeerrJLenpjn2mknWj4sauDaazfT9tuPVp+0RsvSS/c+Kdp5Xa8JPkye3O6ou5SG\nrO+8naPfqHSoEXM/Rjty7PfXXksLfmDXWcMcpLbB3o847V5kkfSyq6/e/nvKGdUwtmPuH9TodqV4\nCtHXHK31/dS/HA2uCZTB/Ne/5m+HASaBzm2THztQt9kmjU4sQhO+DalSQ+koZhgM4wTLn3rAl95M\nutQyMfnsg2CO9rgmAlxQmXQLYd7fCqFtPUnxqyPxXjANIleL4Nxz+XRcUCN0xBwYazIx22EHgE03\nLU83RlVb2jSKA+5YzqWxiV3o2xhKsSgxRmMYRFRgjuLbNIgefjiNpmsSnhKlz6ZHNZ8sZfLU9UV0\n/Phmmu+iuE5AtB37LLZUvxRzJxaUCJpcWtx2brEFLZ8b5S0G3PVZWugU055PfYqWz34PbXeYUkIr\nqXM3dc3jmJb7XFJwhOff+15cfh89KaTUnSQHV0rNopRaVSm1qVJqc/svpb7pGW+80S19CrNDWoMo\n5SAird4bihIjMRFPOolfRyzaJKQrrphWZwkNohI20Xa5xx+Xqd/nALyUtJFLt9QB/rHH4svkMEXB\nxl4O6WhMm6lziRLZCsNZZ6WVs+FqxM00U1PTJFaDdIUV4svGYIYZ6jPV6MKJbyzN3L77UpghbVhs\nsTCtWMSW45p0p7Qztoz9XksxiEqgrW1TpzbTqBdqLpZdtv33WA2iHMAEsl2dXbi46ab0srZmhnEU\nHwOOG4ta5hZnzWtLiykfAtZGKuOHGvWZ2x7Mby62J6REC6xlrBhEb3VKqQ0B4EUAeAQAbgeA26y/\nW0VbNx0Ae+Ennli+HW0YGJDVIJI4GGKaEjH1toV09dXVVj9m0+lGA/D1IVdryo5IIH34tusMpWGg\n2sb+/vdx9N3nw6IytEHKxIzqiJYL6juQkKbnuFR1Faq4tg3VBdVsVammVgP12WL8zPjg+vmQ0GjJ\nzSyZbTZaNLBckHw+6iG4lC+Nmuo96ih5GhwT4dJrDpVeiDFSq5bL1lun04ihX1o67xtjY8bUv2/V\nCI4vN3vdlPK1xsmXA1QTs1JtlGIQYdhqq7h6Y3ya2m3A5jAWaSx3nxofYdQ50GUUs0sA4DsAMFxr\nPeD8FYof0t/o+hCLqWqWksSG6lhmmd7n0Ufz6GBSghDttt/vJxpMYtpZK69MK+uDLSUrdcijLkRX\nXNFMc8fcLLPwnU63SQcwUNVtS0CS+VorSvQnh5EpVS4Wm24aR6uriFeS/WHMqu3wrBLA5oPrjJM6\nRrC03Xfvfab4ouP2X6nIa9IocRHJ0TfYwZ/KfM/pn2+++dLrttFPJmaYmVgO5NxPY/p7/vllmPq1\noB+YXfa750RODqEfGElUcNtotLY22ECGzsYbx5cxCPknsscHFg0yhDaBg8S6c+SRAF/7Gh7MICdS\nGEQLAcAFWutXpRszvQJzABqyh5aAUvjgPOaYof9L+ylKOYiY6Bz77EOjEaozZK8ce4BqU3Nvg4Qz\nY+yAzFm8XXMvrC4qQwfbbLtkbBjaUgf6Uih5sKidqRIDqi+grjAwkD7+apFGtqW1IcVfVmxfUZgH\nVAZxqmN8CXB8y3S5vrVpTnTFNK4RVM3fVVdtlkl5RmxdrEGrIAW1ti30LtvandvMsyRqfT82SjHk\nJIVYHNo5/LbFAgsYE0Jb2+68k9ceKlJcdUgFrfE9/yyzABxwQB4LkjakPNZ3AWBt4Xb0JTgXrVKh\neLEw910uYj4ssgjAM88AHHaYTH0pzxM7yTFtIQySTqol3tN3vhOukzo+c40b7gIoHWWMAl+o2BLM\nYID8Y+iII/zvJaVOiU0OC+fqouu1jYJazXy+9CWZdtQK++KQSzOE8g66NDGTBoexkUpLAjkDeuRa\nm33npW23jau75jUydsynBguJ7YMUTYMYYHWuu64//0svpdfbJVLaY9ZL6thIFfAa2G3Eogv2Azjj\nOwVzzNETRse4VKGuUTnvsGec0ayTszeU2rNzCEtTrlEHA8DWSqlvKqWOVEodYv9JN3B6RNcmZi6U\nSjcxkzTfGTNm8GKfe1JJtBtjvkm2pw2cMUTxF0PdBGNV9THkDkMvUT9Whxv54DOfwctiIYxdUN9n\nlxdEW7otCc5YruWwy3WMWhvT3tBOcbTYJWJNzGrpdw5DuzamUYm9jPuOalk32kBhtMWYcfaD/6rL\nLx/8HhvYIoTSDCJ7TrsM4NR+a9uDOWG+u4AJYhB6Lxtu6P8tx5hedNH23y+6yP9bDXu2rx0PPuj/\njYtTTmmmzTADwHPPAUyaNJi2/PLNfF2s/y7scWRbT5ixZ+j5Ap60WVzkduxtkMNqIuVYshMATAaA\nbQDgcwBwuPUnpP8x/aAWlcM2DBsmyyDqCquswiufSwpEqbckg4hSlx2BKLZsDWOCwyD6xjdo+Vw/\nVzUyOqTHSY53m1NyzykXgzZHujYuvhhPL606nILYfqz5Et7W3120m2NixkXN78kHrpZSrEZP6PJF\nhTSTIiZ/Dg0i6bGDRQbLqfmw885p5Sj5a52rtcx3atj6vfdupplnsKOTSeGBB9LLlrQEiK3T+Aak\n7nk52vjkk/J1Ylh/fZl6bOZWG7BoirWd5ZKsahLonAUApwLA3FrrkVrrUdafMM+/btSyqbaBouVC\nZWJIIIemRMri1lamBp8hubQ1pIE51XSjMYWQe7OMfZ/jxjXTJBd76gYde3nNfTiRdu7YFu1qzBhe\nnSFIj7m2+uw2rbSSTJ22lNNE8koJ35sDO+7YTMulxeeC469N4oKY+pw+81Sp+tsQGyHShsTFgvNM\nxx2XVk5C8zUGKWcLaVO90iZmI0fGl8m5TmCavCEHulQ6oXlQg5ZEKVx3HS2feT5M+wTLZ8P0fQ4G\nEaaV12/vAou6bFCzuZRUPx94oAxd6rrd5uOKe5dtg+3LLMcYTWEQzQQAN2mtM0zN/sKee4bzYFL3\n2BeZElXFgLqA1mBiFgJ2cffR42zInAXU1byR1rrAnDBjMJI4zEeLpEYTprVFvezkgIl+Zz8jJwKa\nQW3SACok2z0wQDOXawN146aOoVoObhSzTQqoUYxsZt388/c+OY5Pff1oMw9iGZC5fXRgmHnmuPw5\n1LJT4JqrArSrrdv5ue3mzOmuTfRGjUorh+0Jsf14/PFptNvQlZZejnfW5i+HgtQ2+fwnhrQBYunZ\nZ+tS86AfNIh8Zjgutt6695niO6VNuBQDzt2KA8m9Zqedep/2e8XcHbT1mZ1m1kYsny/wROlzWFfn\nPh9dqShmseNC6tzpQwqD6FsAsIN0Q/oRPp8jUjCX/AsvTK+DwpyiahBJb06xi3PoIMtddCXMPMxl\nLRbSl5Onnup9XnVVOG+NDJFU+sY5p+0YGvOjUgtjwSC2PZiGWQn15llnjb+E2zCHwhBym1BKA9Oa\nScG11w5+p2olteXnPvvkyc20nIdq7rpTMlx87nG11FJ+mldfPZjW9VrtQkLQEkKpIAZtdKhmpVyU\n0PyR1IbnaD6laB25WGYZXvmll6blCwlfue+mtjOKNMaOpeVr6weuBtFZZ8WXKa2JF4K0xmbb2sjR\nNpUE9ZnPO4+Wjxp8xc531120dsW8H6m9XGocpjCIhgHAMUqp+5VSlyilLrD/ZJpVD7baSr5O6svj\nhoulaq8MDHRjYvbpT/vzxaoIAqRNLtu+OYeJGZX5RnV4HSs5oWjPYO3DVK8x/wC1wTzLlCmy9Xah\nWtu2Ud9/vyytmHJSFyNu1EAM5j3Z477EBbqNMUHRhjLPRtUgwsrakJqrWN1vvdVNlEDqhYICbG+l\name6+VPRxmjzmXPWxgz6qKDWi19Mu3JqtEhdHDEHwY88IlN36PnN79SIVzEmZh/DD04/cRlE1HEr\nLXyTHBsXXNCsM1a4xAWHKZtDi1f6GbH+pLoBueQSgBNOoOWltjv2rJKKlGPeCgDwBAB8CADLA8A4\n6y/Cw0J/QEIi6V4QOKr6MZhppmZkAyqnNDWPFFLMlKgHABubbz743RzKJRcXKpNul12G/t+FA0Qb\nsWZZtaHEWM2t5dJ2CafS/sQn0tqTCw8/PPi9zYSGC+n3zxEUYG059dSh/w8fTitHpXPyyellQ3lC\nAgWz50gf0nzzQWqM52K++PpKKvIJFe4e4+KII+LrlNAgSXl/XWpnpGjIYGe500+PK2vDaNrY5xcO\nUvvD0F9jDbk63fJSjOHQnDKmUVQmfb86qZ4eYPohhw8iDrMvx/sJ3YWM2VeINlW4nBKRdfvt48tg\n6MqHZIgO5y4+fDhdU602AVA0g0hrvU7LH9PqePqDUnIhLmOx0EK0QwhnUNY0oFN8XtgO6TbdtFkP\nF9R2UH0pxHKOKflyaQOst156Wa4WF2eOYRLELjSIYhkomEZCzDv41a/i6KXg3Xdp+WK1LCnl7RCr\nseNjzjnj8ofg7gmpznZ96ELDx+DMM5tpr72Wj17IySkGSQfT3LJcUGnvumv77ynCMI65qQFmxpgb\nVCfVUuYkWN6QEKatfmNuHxPmPodpjKE/PTAuDGOIagbN0SDqsr9Kmf7dckt8GSrMWeeDDwbTLrss\nHz0qcrxXqeATEyf2Ptv2iwkTAO67r/e9a+3EWHDakGJiluOZpc4RUqb2ycdIpdSSSqkpSqlZp/1f\nwRCRR5dSAAna1ANcKq0awgRzOP7YhK+B6VUioooBtgFh9FdfPY7OvfemtUcCnDqxiATSF0oXWHs3\n2SSuDuyijJlx+vpm/Pj2+mP7FDtoS7/rGKeJhgFcI3JqU3Hge19t79HsOXaeG2/sff7oRzLtikGs\nlkuOg2YNWHnlZtqxx/LqbDMFp/bj7LPz2pACrG2x7y6HFlNXjIbp8/SeBs7ZMaUeG26QE4k6u0KK\nufRFF9Hymb63g6S4kU/vuCMs9Ar1t4EdIKdfGX/Gp13bOjdxYnsEtBxIMTHrUqOrBhhft5jmJgDA\n2mvL0IlmECml5lNK/QQA/ggAPwQAoxx/lVLqSzLNmr6RsgFJgWNiJjF5c0zYgw7qffomSyyoz4lF\nnnGRa4GSHBvYRR7TmNh5ZzmaudFvGwPWXqoUwGzomCryhhumt4mLLt5BG8OaM2cOOyy9LAbMcXoq\nSq23EnVhDmD32GPw+xZb8GmkoibmTqgt9u+hvG1ahPvsQ68Hg4QGUQqDiDsWY6O/1CbEqAW1Xpap\n4Mx5W3sFwz33xNc5dergd07/tWmkp9RbSmA5YkRc2S22ANhvP/y3TTcNC71CgYaMudX668e1K4Tc\nc4OifWgjtwCUCmkGUZdOn1NoU8sYweheew2m2W3ENGRTniFFg+hCAPgvACwGAG9b6TcBQIfXkTqB\nhdysbePUOp1BFLuw2HSk+sEseCGHc4ccQquPOkldhpRPikSpj+qkOgew8NgpKsU1QXqO1XR5BBj6\nfM8800yjlo0BJ4R4LCTfn8S7ozCDYxAy9wnBpzlVE6jamV//+uB3bC0KITRWqNL90nO8jZ5kaNw2\nZ9ihvqOGrLbRpXkjFaGIqBRwLw2lNYhyMHNKM4hifatdf308DWq7Q2HuTSTZGKSsfxhKRdgrgdBa\nbXyY5RhvTz8dV3fNGkTm9zbBY477WQi2kEIKsXt5rHNoH7h9Nj04qZ4MAMdqrV9y0p8FAEG5aB3g\nvgBX7VGiTmlIhy3uSqoUqnu99QAuvDBcj7Tp0HvvxdPcaaf2fF1cvmsbt21IuTS2wb70GLOKWrQz\nYlW5U2hNnIibqLSBM4+4TtKlGQDSY59b3w03NOvCVLUlL+u55j/XvK4GibhU32yzjUw9NjjPai5f\n11wj0xYbUo5NMYQiX3HWhzbzRB+4EWklkPNchjkLtuuUMu+Njc5oTDFyQ+q8se++7WVMWmjNbNs/\na9OGsMGJvplDW8T0Y23Ok6VpS2hZU/HtbwN89auD/xvfSDFIeR8pJo9uPTE+iGo4l3DrTjk+zg5D\nNYcM5gUAogvS/kGXqsWlFhtqNA1qxIAaGAm+NlAYLKmTFJP+KAXw3/+Gy7o0QxIg6qKKPefcc9PK\n+rD//rzyFHAXSukxaKtyxjgGxVCD365YXHppWXrXXZdWjspArb2/Q7APOyZqGOYI+vzzafX5+qM2\nxlgK2sJWp/g/wNAWIcamMXp0O70uBShtF9IYR9LUfrzpJnqdsVhttXx1pzAdVl65F+rYPmuV1iCy\nYe9nnHqwcrfdRsuXUjcH1Gh51PF78MF02tQ6bcYOh7kvrcVXysQsJYJWaUiMSwkNRkmU1J6dOhXg\ns5/ltSPlHVB9olLphdpQiqlKxRtvxJdJWUYeAIDdrP+1UmoAAI4BgPsS6qsaOQ5ssYu3lPobAH64\nwZzyclADt51Td+okxZy7zThjGoMolI/jpZ67OUm/NyzENxfSbbTNF7tkGneFlIt0aFNte2aujx6p\n/jT+W3K/H079K67Y+/zjH5v15XI4SWlvqUNnqC22I9O2MrnU0m2ss4583TH+iqRotqHtfVDNvEPA\nfFlxQX1+szbFahCddZb8WYsCzM2BYSrnwHPP9T5r2ycxs9zQO992W/9vRx45+D2HQILzrP1g5klF\n7WcjG5ttRsuXe25M71YCKUoWtbmJwFBK45GKlGXkGADYTyl1FwDMBADnAsDvAGBNAGDGxKgPOUKw\nSpt0UTFsGK6ayjlA1jTppA7VPvOuFMw+ex6pSKmFPGeoUmNOceih+WjkBOYUOhWx71PCRIJLL6VM\nlxu2zeSbMIFWBmMu1ARJZ9chcNacKVPk2iGBtvkT0t7MefmqVWgSU2eb8GLddWXohvwNhhC7fqZI\nkFPaEJvP/W3bbZuRKzGtSqo2OKdtMY7UJehJwabx7W8PfneDdNjrgMT+7QJbZ8zdIVS+jRGZuw8l\n3nXIR19p7UvqM4UEMrvt1v57Tejinmr383HH+a0dqO8/9N7M3SxlzOYYb5tv3n0bbEQfdbTWvwOA\npQDgQQD4PvRMzr4HAOO01s/JNq97GOmsJKhOuWL9zaRKMaiXDOxQEbtQl2JscOhIRixQyr9p2Grw\npUPsUmH7nUnxveDCLrvnnr1P7EKR28TM1B8K89x2MbjiinY185iIHLVLbmpTiQ4B60/7XdumPm2o\niQGeA8akIff4W2mlvPXHAttbzXef+rsEqHt0FxpEBrafvhQ1+iWXjKMXAymBncR4z8Egotbpe6ff\n+Q7AY4/hee26QxG4qGhrL0VzWpIeBTvsEM5jm3nZgRlSzZ5TgT2rOTOFwGWglgS2BqcI3/qBCfnL\nX6aXDfnQwdrNWS990eFywn6H55wD8I9/yNXNcSuScgfHyoTMXGu7B6SEuV8MAP6ptT5La7291npj\nrfVJWuv/N+23j2EBe+GYyi8GE/4VG7y2eqtB6gIpfaDrikFk1x0KnVtqIrZJmzkSti5UiCU24Bgn\nbyWw3HLtv7cxQOefv53Zu+iieDrmH6NkX8TQMtLofoiaBdDOVE85NJeKFhEKt+uDb05S5+q//93+\nu++5Kf2BhRKX6sfLL2+v85xz4uvE+swIC5ZYor2sEbJIMXakmT4A9L53NVBi6XEO4gY+rdurr/aX\n4Zhdc/HlL8eXoTILsXyGwZPqzF+KQWQQEhTWsNcD9Jg8b701+H9OpgLX1yN2xjN3B45JW8q7KC0o\nyeHfhYPcQvoQ3n4b4JVX4stR14dVVgHYZReAY44ZTIsNHnHRRQDf+15cmdyQfm8x95fSFjc5xl7K\nNfPPANDQiVBKzTftt48hhDZ1RaoE3AZ3k67dxMwG15EwFSFGTaxE8OWXAf7f/wvn50Z5oqLfTB5K\n1M1VvcUYxLUcoF3kjPyFhY63o1vUgFLrmy2pljRdpNLdcstw3tgxmtPfih3tBmvXccfR6gk9E3ZI\nxspst50MvRzrgGHuhvaqWtTsAfzMnrZniNkTpc27UvZjTt8ZBk9MHXZeqsPm0BzG6Bs/LNyxIeEn\nyR3Tw4bhjGsMdkSxFBx+uP83ylyT0tQuDWntvFrPRiUx66zhNQbrM2rfzTQTwLXX8gSBhx4KsNVW\n6eUB5M5bXYW5LwWsHTFO86lIYRApAMC6aQ4A+A+vOQHCSp2glHpIKfWWUgr1ya2UWlQp9YNpeV5R\nSp07zYl230FCEicJDk3jVLLUYu+T3piDp1Q7QlLLWE2f4cPxi7NBlwuUtIlZWz1bbJFOgwKJsewD\nFs0uhFQfBpMmxdNKQY55a/t3MOCa91AvPrEoeUhtuxjNOWcemikChxBy+O+Thv1eY33QUH/3/dam\nSSxpYnbJJQC33orviTn2kxJzJQeN0j6IqMDopPgysZ+P6vePOj7sc45tlm6Q0lff/S7AD34QXy6G\nLvZ8yy/f+6Sac/nocLW8c425UhpEtVymJdAP5mvStGtmzJVuW4rPq5Q22oLCWFAjW8eAvIQppS5Q\nSl0APebQ583/0/4uBoCbAOA38k0cghkB4GYA+JqnjQMA8EMAmAEAJgDA7gCwBwCckbldHwlgk4Rj\nLtPFArTvvgAnnjjI6c4d0SuXuV3NizcVPhMsAJpGQxtGjYovI62VJXWoeOCBwe8S751rLiLlDNuV\nTp90Eq1eH7QeNC21aY8fz6u3JrjrbclDeOzYMxHgaoR5lqWWGkzD+tJc8lLmwRprtP/+0EMAX/ta\nfs3cOeeU1RALPVcps0wXqdo0Bm3vIVc0QBfUZzjiCJ7fwljzEUqdbWkG1Ch+AD2fKxtvTK8bQwqD\naPToXrrvwmUYSJx2tcEIxzhnx7bfbUZxW5Q2LqhmjF1oVXJQ67m9NrO8FJRuo9nLqG5fcrevlGUI\nFTE87nHT/hQArGD9Pw4AxgDAb6HHjMkGrfXpWuuLAeBJT5Yp09oyVWv9pNb6bgA4GQAOUkqJdf3+\n+0vV1I7TT4/Ln3uhxSZHmxqtJO02rLpq74/yXmadFeDMMwcPSIsvDvCnPwH89a952tZ2waBKr230\nwyLvwufnJ+T/h4Nx49p/p6qv17Dp2v5pDD33Mwal1q/Yy4PkGmHXZUty33yz90dFV5ddH0K+cGqF\n9Dyhvo8VVmj/HZPyU7UcQ0Ebxo5tp73ssgAHHOCnTYWh+eMfx5cNAWtPDi09anjftvmY0nfUi8Fi\n07xrjhzJo2ejlCDNjNMcZjuYbw4DzF/HRRfJ0OsKr78O8OijtLxtbaX4pgytTW1om6P2XKM63k5Z\nv6kMImycdHnuCjGPczrhlwZnzveblQqG0B3r5JN7nyHNnZT9pp8cxftAZhBprdfRWq8DAN8CgI3M\n/9P+pmit99daP5uvqSRMAIAntdZ/s9LuBoC5ASDpOoodyGOkL5z+GevDAAAgAElEQVQNzUR+oYaG\nlfLE7gNmTkWtM+diM/vsvU3bPrzFYPRo+gHVRchfSJuz7BxhYKXBsWsGAPj1r9MvLpgJkhQ+97l8\ndacg1KdUkwCDNp8opUKjx65HIcfyMfD151xzpZkAlkTbWHAvWF1dmLq+qNnwteWJJwDuu49eD8Z0\nxda8tktxCKF+M2YtPs1WzP+ZaQc3+ibVaXaOd+8+79FHx9eRokH0/PMA99zT++5qq8TQkxoLOfrW\nXFRyhq222435IDL906UjcQyx723eeenO91OFIRhDz1fexwBfZRV/WRtUBmkMTJ++/7583TWAYwYk\nHVzGpylf0/4cA07fpjyzeR/Us2rMeoFFMbbLx5iw+pD7PaeEud9Ta/3PHI0RwCcB4FUn7VXrt2jk\ndLRJRcjnCRVcJkSK2Y5BCnOhHxBiFmLR5jiogZEU04aVV06fQ8ssk1aOgpwH1ZQxvuqq7b+7/kOw\n+WS/l9qZIDbMYfaww4amn3Za8aY00IUGkW9+KdWUStVsYlYKvnattJI/NLCEpBrTIOLC+G3yOdLd\nay9ZevbzmeexLzEpTAyJceJ7TmlfIMOHA2ywQa9eTOMrp8ZjKQ2inXfufW6/Pa8eDNjFyfggwtrN\nNemPRY5ogLkhoUFUA6iaNhytyY86fvazwe/S63IXY43r5NqgxPjg9o9hpKeg1Pjv3HmzUuocpdSH\nLX8fKKWWCtcUxMdLSkaMGUPLl0PNuWZQOeK1bnilpJxU5DjkGtjPRfU5keK8DgPVX0sNGntUYG39\n05+aaSastjtX1l47nXZq2HgXNfTj9IQca4dUnW1mpxiNFAZRrNm4CyOQyBHtpQQztBZnrxttJNMO\ng5rPMobRkCIUufdeGqOeKoE3+2otWqxSkHz/FA2ifgBHsF3bs0v5XaSC6n7BmL5SUFufYqCuUdLa\nu134weqHs2UNLpHOB4CrA3n+l1jXKwDgKleawH2uZhGCw2HzzYeK6m+4YSfYaaediOTrRs4FYnqw\nt8wBW1JNVeGvFW1S9+WWA3jqqfxtmDoV4Oab5erzmWXccQfAhAl0O3obPme3EhoHbt0x4+aFF/j0\nY4CNk6efbqZddFFTe4iLm2+WMVnrQoOoHw5y0yMOOqj3GTKrpaqbY79zwgjH0OHUE/LB0SWk9lBp\nc6tNN5Wph2vSLY3x49ud/Le18aMmDHSR+sxtGkQfFXTpg6gGLCWhEjEdQ3o9SfEBy22D9Bj213cD\nANwAn/3soEuUN4mOODtnEGmtXweA14WqexgATlBKzW/5IZoMAG8CAHI1cXEh3H57Tz925MjehaoU\nb0j6glQD9tsP4Otf732v4bBTG0p7rN9wQ9n67PZvvHEZBpE0hg/H0//+997nN78JcHWIfe1Bl44U\nMZSKxNMGzCRzppnwAxFnrfCZ6Li4/PJyTrup8L3H0DOtttqgA9V+DV9OBffyiTFDsDDwqY5mqXWk\nIqdEM8WXDxcS5g8lxqfrVNygLSKnD6XmU046OU3wqHUOG+YX5NTSxzHrsatBdMghAF/+chw9aZTW\nxOpyr8nJIC/l2qBNsGFjwoR87akBNZ1ZXEiMKdrz7QQAO8Fllw2esx9//HEYTwjv21c8aqXUokqp\nsQCwOAAMU0qNnfZnZMX3QI8RdK1SakWl1BQA+DwAfEVr/V+pdlAdwMUgVuU2ZeBjZXL4+TB0Lr98\n+uf0h9D2nmypY4koZlISKUyCPr2955hIVy66OpDnaANm+sZ51xtsMPi9hs174YWbaTYjravoWzb2\n2KP3iTkUtduXI7qUD129u09O8yQodbANmTG2RaHcffdmWg7Tr9DvJTSIbMSYNUjDSEBNeGIbOcak\nzdDWGuDYY/HfpFCbSbcU3GeQfKa77kovW4vJow13Htq+fCTplDLzS4HPd1ztCL0f+/zDqYcakCBU\nD4VhZc4fNaG03yqpdbnf7kl9xSACgDMA4HEAOBUA5pj2/XEAGA8AoLX+EAA2BYAPAOAXAHANAHxz\nWv4otL38XXeNra0OYM+UQ3reb5OAA07kOHtxju2zLiRjxlcMhi4vDTnQjxE47HclNQfPOgvgr3/l\nt8egH9TmbW1O4xdJar5RHLa7tKgmB9g7Nw5jJZB7zaGYX622Wu+TO47Ms5x4YnpZTsQVSXA0AzEn\n1SGps63tN+ec/rqxsj5fa9SxNffcAK++CnD44el1xKBU5C+D0aP9+al+Hl2MHNn7tCOuSmkvl/aJ\nh9HDIg1T6ZbW8qXgU5/qfbYxIG+9Na1uG7nWc4l6+8XELBTF2AVVgyj0/HfeOajl/jGakPYZRTUr\njwGnrv337wm3Vl9drDko+uC4PohpEdSGIX8/t/L8RWu9qdZ6Dq31QlrrY6cxjsTQDyrj++wjW58U\npgdpmBT6jQPdFkHJ+O+oGT5zMgzUAzT1fcw/P512DL3cURaHDYtv+4EH5mlLF5A2y1t++XAe9x1P\nmdL7TDkM9ItvuGeeAXjyyXC+b38b4Ne/HprG2VNCjKbNN+99YtpCGCjvl4KYdZ7jzB2jGcN8i/WV\n4YuuGPO8Cy5Yl6YNZppIgZnXtrbE5z/fzMd9rqOOAnjwwaHMJ6V6voWko6zayCGwkDb/ydmu1Pd2\nwQU9U2HMpNjUaaId5sZzz8WXKa11awKXUB07u9hhB4Attkgr6wZNiWUY+bDvvu2/zzyzjMZwW98a\ns9kaNYgwpMw3c85PifrLXZcnTkwvu/DCAPfdJ+Nnsw19xSD6GHSEFunUBdGGTzpNtUv/KDCLcknY\nUjbhFEea1PbXqhlit98OCRqC0VTgzBP7Hd1+e3o9GIYNA7j++qH+kWqZT4YpETo0Sx2mOKBqAEr0\nbZu2RRtMNBhMS8/X/txjwa3/zDN59Y0ZQ2PGzTFHc9/J+ayG4TN1Ki3/Ags0GVg1gxrFrBaJfRu6\nWv9S6Rrmmj2vZ5zRbz6Z+g6GDcNN8n71K4Dzz0+r82Pkw8wzA6y6an46lHGLaWdJO1DmCkrHj+/9\nnyqEu/FGgNtuo9Oz4bY9ZHZKfVaqKZqNkAPl2H6eY45enWutFd+WfsEii/T8jFLXQcl9cMSInvlo\nbiGvQUrbK73WffSQI7pJbjz2GD1vLZfX0mgL9Vlag8jnYLMNmI8WCay0Up56pSBtRmJ8p3Bhj5md\ndurGVt/2w4GhzW+LnZZb+pGKXGtVyVC5uZ1Up9Zv15FqMpMb2HMuumh8aPSce16O94sxiFIuGhz/\niHfcEV+WQ7cG+Pzz9BNTLtbUPvXZMEFUrRpEOVCCzrzztv/eZtLHRa1zOGWcnHsuLV/p6LLTG9qE\nNxSFhN13Dwvvcvkg+sMf0l04lMDHDCIhUKPm+CDtYDQ0oCXCN9eqNVIT2i7L9uU+12HQlmhwDu6h\ntFg88AC/jhLoF1t4FznbZa9VtuNkoyVl/Jp9yDTsreGw2EWYe+MzRBo19KcNzJwmBRzVcgy+uZPq\nt6VmU+IcGkQmbykt167BnVduP9XsPNiHUiZ/WJ1t+0yX+zdGu5S2gI2zzwbYa69muq9vJk1qptV6\nzqkFMf3rAvNLJDV3jjlGvs4ceP11gNdeo+e37zVXXNE7Mx18MK1sismclFat62NuYEAush3Wnksv\nHfye8v4/vuJ7ENuZPl8P1HqMPboUsMFSwwLxUTMxa4Pt7Jy62MQ6zQ0x8e67j1YPBs6hIdW8qIQp\nnlR5ST9ghhHTtplIaHgceGCcZs/ZZw9+32yzHl0TdeW999La0DW6PgzfcAPAT39KyxvT1uOPT2sP\nBom1m3owCvmWoLbFjgbE0V6rgWnsa8PUqXG+1kJOqvsZyy4LsPHG+elIv++vfx3gxz/OGxK7BKTP\ntD5IRyeKgREMh+ox+bjjMaW9xx8PcNVVzfQY/3RcAbgB1Vdlv6xBZuxhTvNLA5sHOSJu58C888b5\ne7QZRLPOCvDnPwOMHTuYZgLqYOZxnMADnLXmgQd663pJcOftxwwiIXAPCbELYsogHzEivgwV/bKg\n1wSbeUM91H/1q+2/x9oucxycdn2Rzom2Z6OOddvRILevjjgC4Jxz5BzS+nDppQD//vf/b+/Ow+eo\n6j2Pf74QAgECAcIvCRHUSIJAWBK2sAUBBVREWZTFa0S5LveyCFy4KoJsxgVllXGUQRRFcEEZM4gT\nNW4ji3DFBREVURTEBEl8goMsAmf+qK5JpdNLddWpOrW8X8+Tp/Prrq761nKqqk+d8z3ppx/1PFS1\n88Soo1iUYdIkaf/9/c934cJ83y9jdJpehiXs9K0ODzH6nU+uu0565JF88+z1UCFv69MDDsgWU9bl\nSdK990rf+Ebxy82re19OnJh+GGuf7r5b+upX/c1vUB6drOWqakmq4x/gw9YnznFTlfPJ1Vf3Lxvd\nMV5zjb8ftkcc4Wc+oe49+40y6Hu/+ppfVY4334a15n3JS6JjJJnKIvTvlX328T/oSVIRuQOpICrY\nqDvollvSTTfsh1mv5b74xenmXUTemfjgnT591Xtpc1Akm8nV1bATddph4oflnLn5Zunxx9PNK6uq\nXXTSds/01cUuaYcdRp9nFhMmSO95T/punWXto9AX3UGyjEzRrQrHetptXOa+6Jc3pZ941J0sMX7h\nC6N/pwghuhuWKW0Xszjnw+LFvefTK7F7Gd3R65akumrmzPH3A14qr6J10DmlKsPcb7tt9JpsxZh3\nnr3+TuuEE9J3ZXzLW4rNO1QH8XGSbPU/TNpul0XkwWrKOamforrhD5NmX+VpoZTHqHng0qCCyBNf\nBXLURJhFyDJsa9qa0eSoUJdcku473UNJVkmo5s39RhYYPz77aEknnJA9nrL02ma+Ekln2R/JHDy+\n551HVStuytwOv/uddP/9g6dJbqde57AqbcfubTc21j+PT9FJqkeV9ZwkSc8+O/jztHGdd172GNqg\nVxezXtt2002j42vYUNtll52m/yiqsrL29ag5iIYpa5j7qVOlO++U3ve+0eedpwKsLMl7sEGtO3yV\n0VDrnTfZetnnqLwDDlTV0UeXu7xRBg744x+lBx4oNp6yUEHkybADZ5T+vmXwfYJN+5Q3eULy9cO+\njdK2OBpF2sqOsvQ6RovMrVXFlhpZ1SHGYfLu1803H/7ENrmdBp2js8Tiu4x279Nly3onxyxDd36t\nLF31yr45TY52kiU/SpnxhkhS3avlj694hm27447LN/80yyjLueeONv0xxxQTRxnSbvNhx8+SJcMr\n8/str6rXuu64dtste6L7WBWO8V6tAZMpEgalS0hbSVGF9Uw+1MhyjFX1uEyqQ4y9VOH46GdsrJot\n7hjmvoLiA7kKB0yRJ+JhXZ+qXKDL0KT1r9q6FJGXp9fJNG3z4qo83aqSAw8MHUFvvX4gV00V47rs\nsvzbzleF7KjLnj5det3rRvtOmjjq7iMfiRLaJrt+5zn2Rvnue95T31EPu5c7e3b67z7/vPTud6eb\ntorH36Cug6PsjwMOSNf9qleOxTzbJe6GfPbZ2b7va+S/QQZtx+7PfCQ2H7bfrrpq9O/kkZx3nMup\nDNtsMziWXn8nJdNppJm+CG3qdlakJmy7tClmkqgg6mPUA6IKB1CvE5IknX/+mu/luXhl6f+Z5eCM\nVWHb5lWHdRg1gVrR6zRo/smuNZ/9bP/pel3k+/04HFaBmjd/wCiydPOsmuQ5JjnqRJWkPQ8+91zv\n9088UfroR1d/769/7T3vkDmC6jb/Io0Se6/RzkY9DxRZeZZXcjmTJ0ejEubNF5R2pKIks+zHVNp4\np07NNv9hZs5c/e9R1qOoacvWq3KviGO413XEx4ASRQ7g4tOw9XnssWjI8CJNnx61kktWbObZ16Oc\nb5IpKoqW/J2z997SrFlrPiSsYqWtlK1Fb9NVNZG4L+QgqrAids6o3v/+6MludzwnneR3OXfcId11\nV/rpf/jDaHQVVNsoCfikbBfHd71r9O8kzZkTvb761ave69dV8cc/joaW7JYmH0r8JC5U19DTT8/3\n/SrcuPR6elW1i2ovabs2StKVV0pnnLH6e5MnD/4ORjPsmCnyxm+77db8/GtfG21+RR4HyW5zRYiv\nCcNaCMde+9reg08UWe7f8pbodVgldBHDxt9225oDi+yyi//lSNU+n+Rt/VXUsovY50llJ67vPsa7\nK2MnTYpyhBXtvPOkD3/Yz7yq+PDoBz+IRm+LTZok/eY3/R+OV/W+Jln5VqfumUXwsa5t2l4SFUR9\nVbXADzJ+/OjDnGcxZYq06679P+/edvvu62dEIRSrjGP+ne/Md5Ldaqvo+3FF0SC77756q6hR1m+r\nraSPf3z1ROplXhyyLCu5fiFaIHTrtb3TjlxYlmT8g7od+SgbWecROv/B3Ln+5lXH62osHnq8iFE+\nB1myJHpdsGDVe/H+7VWBNYphx8mhh0bTrL9+uvklRxwtY2h7KbqmSGEG+NhzzzV/kMc/IvO0mm6C\nssp6r2N43rzoNR6GvmhlrWsyh5Fz0tvfXs5yh8mbi2r77bPNryjz5+cbWEEKvw5pYqhCjFmE7KpX\nVUXESAWRJ/12TtVH8khOH5+k88bctlpWFMP3cTTq/E46KXpy1G1YGSsykXZaVbig9cpRs/PO/pdz\n2WXZh0JPxnjxxf2nq0I3oWExhHyKn0VVR7TpN79TTpFWruzd7cy3ZAyzZkWvvSqDqlDOk5ItjZIV\nrpdfnm1+abr+xIMr5O0ah+I8+aS/eT32mPTEE6v+7lVeyyij/cRlwNfxWMSAJINkOaf4SlbedG1v\nxeNL2Q9p6qCI4yhnTn2EkuVHalLcsiLZBDfuqpP3ptP3jVrVboKT0hbKotZhyhR/82p7v+Urrggd\nwSqvf33oCPw67bTRv5P2OMvbbTGWtjtC1vxQRd8IFlVB5DN3S7I7QdVHDexukWIWpiXsC14g3X23\ntOOO/ub52tdKX/96eZWYWVoOPvBA7wr6UZc9qk03lVas8DMvRHx2e+ru7pjngUzeLmK9vn/xxdLx\nx/vrOnXYYX7mU6S02y+u7B42Ym4TcjCGVKfR4rIouutot3g7ta0yj2cunvQ7cMrOvTGohjr52RVX\nSDfeWEx/5fXW8z/Puiuin/V3vjNaLqi2G1YG3/GOcuJII2/XkV7rWsQxuOee/T876KBV/4+751RN\nr/N2clS8vfeOXpPbs6rdZYuqILruuqgywYexMT/zSRr12jpsqOm81+ott4xe4wqmLA9Mum+A58xZ\n/b14nllj9flgoSgzZqS7P0l70572/Pfv/55uOqwy7Mdnka27qvajLa788HXPX9cf8b3E185hebqK\n6Dq3xRZR2gGfqnbsoRhUECGXqp3Eh8Wz4YbSkUcWs+zu/sSQbr/d/zwPPHDVj5EyFXGsZ+2CUEVV\naEbca3nDfhhnMSgXWbKCqKp6bae4UkhalcsiqWrn+lhRFUSbbDL8KXaR3RJ85lG4/HJp8eL006fR\n3QVkbCw6rg49NPp71G1z6aXSzTcPnubgg6WzzpJOPnm0eceqegznMWydyn7qjFWK3PY+rq0+WxDN\nmBG99hpBtco+97lwy+7eh0Xcq/z5z9HAJUXwdS2LW1gVoUktiJBOrzQPo6CCyJNRmkLnkfbJX5aL\npq9hvMtKTlm2PE8fZs/2F0dRQl4smnShCvWUIUSSavRX9j646KJV/8/SMvSTn/QXS1Wdcorfm/Dl\ny6V77/U3P0k69dTh1+Jx46SFC/PnWmnjeSIe9axobdy2/XRXEPksg70qxtN2HStiH+2xh/SnP0mH\nHOJ/3kXaf//s3217eoJe0lbIJEfhrXrO2ioY1j2xHx/rWsb+efvbVx9BLyQqiPoY9WDaa69i4uj2\nvvcN/jxPIfj0p7N/tw0uuCB0BPAhxI17HS/EedXhB1Le0eKqZN686MfSt76VrfVWEV0s0yQZzivr\nDaMPm24atcatG9/HcPzwpKplI2nYzXcd1iGkhQvTTdevi9kdd0hf/rK/eAa1Nik6R2S/iqgQLbt9\nybItRh3xq3sZg5bZ1PL48MNRa9Eiul330pQWRJtsku17ee5Hy9xOn/qUv4cYufMJ+wkDVREXgiyF\nIb7RrdpJo2rxtB37A2nkHc2tjOOsyAoiXxVk8Ygd8+cPn9ZMesUrmlVGh23Hgw8uJ44mqkMl7jBV\nXQffZfDww/3OL6vuJNHS8H2QbEG0xx5+kxD3ymcz6jk67zHUhPNtnm1w3XX+4miKXtsz+d706VFr\n0WHfyesNb4hem5D4+ytfkW67Ldzy83bZKlve44lRzEpSh4Opl09+UnrnO8PGUNUbwFF9+cvS3/8e\nOorm6nXj6tPJJ0sPPljdLpR1PceElOXc0isvUZZ5n3++dO65w+czbVo0rPP666dbbgj9jr1Fi/y2\nFuilqAS4Pq87ixdLv/ylv/nl1cRzRRPXKfaPf6zeFSWktOUieT0uMgdRk/d7CFm2Z95BNVCcL35R\n+sxnqn3/kNZRR4VZbh3OMcPOy1nuZ6ggapi0o5ilRWLHVXr9EBml0FVp6PJly7Intd1772go19e9\nzl88eU/ADz1U/AVw002jC20dVKFSddq00BEMl6ULgq8uTTvvnH7aqt/c9etmNWdO9C+Psm/Oilje\nQQdVM2l7Fc4TefnuRhTPL2+Xe5/bdsIEf/MqQq9tm7xfKitH56h8jTJc9DlqrbWKG4QgFl/Xyujy\n1L29Rikre+0lLVjgN56sRi3jIXJimfW/f6hDxUcVHHCA9O1vh28sUTYqiDwZVrB9FcQihwvthRPI\nKvEFtAnD4Oa5CYiHNj/pJD+x+DBKrpOij+km/OjyYb31QkfgT/KYSTvCSlnXhCrYZ5/o9fjjg4aB\nFsrzAGzQ/LpHp0N2RxxR7vLSVuLnvVbn+f6ZZ0of/Wi6aX/3O2np0uzLSmPKFOmmm8qpyM6z3W69\n1V8cvpCku9nOPDManbBKD/nTyDtwDRVEfZRRkD/wAenss0f7zrAnHj7iPvDA/PNooriAbbRR+cv+\n0Y+iVj9FGnTsJEfkmDrVfyVImRdOKnAQS3ssJFvIpL2pT7vs447zM7+Q4vI7yvDEVb2pjis240qv\nJqvzebyoZcct+8pIsN4Uw7Z92cfF1VdHeXHSJk8O0YJolFFxX/zi6F/RfLYKj8UPFJto0PkzS1Lo\nshMpU2GVztprr8rlVCfkIKqxLM1ui06QumxZtiGSUay99w637MceK36knqZfqMpev7Tlv0qtwPrZ\nbbfi5p3lPJn2/Jh23ttvP3oMbVJ2s/wJE6S//KW80WVCiLdp0ZXlJ5wgHXposcvw7aijpEceqUcX\n2RDq8IBl2rToqf8wIVsQtcGKFem6Rzb9/q+qZs4MHQHKkqWMUUHkSVkXiqKXU8Wb4jpcPJowQkC/\n7Vx08mf4l/Y8scEGxcaRR3w87rtv2DiKEvK8duSR0tNPh1v+KNJupz328LfMqVP9zauKyjr2rr66\nnOX45qNyqA73LYhk3VfxkNu03uit35DkTclt6nsfll3heOml5S4PYZxwwmitu2NUEPXhq+D7SoLX\nrd9TZ9/LacNFrJctt5SefHL199q6LZqi6fsvy/qVfUOSdx8sWiQddpifWKTB6/+mN+Wbd3fXsX7L\nCvEU+sYb/c4vrlAponty2mOGlq/t5DtJtS9NbV0yaCCUfqq6LfLG9bnPSd/6VrbvNv1+pJd4nbtz\nqVb1+BjGd5LqsjUpT2TZ6lTJOUp31iQqiPqo+glr9uze78f5cZKf+07i2AZ/+EPoCNrl8MOlE0+U\ndt111XujjPKURpyPoF/ZaZKq5nfJy3dron7n+WeeyXcD8Mwzw5/Y1G3bD7L55lGLpFFGePPVhadJ\n27EsdX/y3QvHQTmqsK+rYvLkZuSQK9so19Y6lOthMa6/vvSPfwzPI0XZqo+4knP69LBxFIkKooLF\nBf5DH5Je+crVPzvsMP85QKZMkX79a/qW5lWn2mFfQl6I4ycZyS5PvvfB2Fi4slHGhb8NzdzLined\ndYr/ftMq7kepHJKkuXP9LJeb6uyakKSa/Y+8mnIOrouyR2MOIXlM7buvtHhxsfnY8t6zYJUFC6St\nt043bR2O5azntxqsWhi+LxjJUaBiW27pdxmxbbZZ/aCN12XddYtZXlv0uhFt0s1pyHUp6watu2xU\nzf33Sz/7Wf75NOm4LFKZ26nfMc6+Gozt418TfxA3cZ3q4sgjB39e1X2z117Rq8/8ZWlVdZsUKT6X\nV/kebBTxsOe9ctYlr1tpr2Ennpg9liyDHqG3a6+VzjkndBSjKeI+iRZECSefHDqCYkyeLF18cf6c\nGugvz8U+7haI5kp7fKR9atFLsvVVk35UF7kuZW6n7mW18QdCUtvXvwp8Hf8h92VVz3XdLcabrK7r\nuv321T1+muj556PX7gqiul4LDj10tONn2HqecUb0D/VR5fPHS18avW67bbbvU0FUsGEnhLPOknbc\nMd/81l9/+PdOPz39MqqmKhePouJo+vrVLYa8Ql0wNtwwuvF6/vn027HsWPPeTDUxd0oVYmizRYuk\n7343dBTlasJ5tluV1mnFilU575qG8xWy6ldB1PRjqunrVwfxg/hheaCaZM89pb/+NWokkgUVRH2M\nerOR9QSwcGG66c45R7rwwt6fvetd2ZaN/KZMiW4G86jSjS3qbfJk6dFHQ0dRH9y44TWvif61ka/j\nP2Q5irvOD2uJW+Z1tt/w3k3FPczo2rjN+lUQtUUb93lVvOQl0u23S7vt5ne+Vd+nWSuHJHIQ1Uae\nridN8pKXhI5gdd/+dv55VP0EU6Y2/mA/80x/8zr44Oi1V5/4EH7yE+nHPw4dRX9VON7aWv6HrXfc\nPBr+xdu+CUmqd9hB+sxnhueMaGs5a4u6dXNr4/HYpgqi5P6twn0GpHnz/A9+0+R9SwuimmnywVhH\nPoY4rMqNQsg4+i17s82k5cvLjaVsO+3kb15HHSV9/vP5nhr41D1SVd7zV1XKyqguvVTaf//en3FO\n72327GjUwaz959FfXctRL2bS8ccPn27RIulrXys8nMar4skAzjUAABSSSURBVLHz3HPVjAuri0er\n3WWXsHGEwjGKomy+uf95UkHkSb+b/DJqyos86SxdWty8swh5gp07V5oxQ3rrW/3N84AD8o1c0DTd\n+/eBB6Snnw4TS1a9zgVlHbdNvAEpsgLlVa8qbt5Jp5665ntN3Fc+bbdd9HrccYOni48Ptmd6cQvD\nZGL7pps1S3rPe0JHUX9Zzsdp8mTm0YYWKU0wcWJ0T/fCF4aOpFznnx/9liq6HKC9ZszwP08qiBKK\nGOpywgT/8+xW5I3xT39a3Lyz2HDDcMuOL24+LVnid35Ns/HGoSMoXptakIzS9a2MJNVTpvidH9JL\nuy+p+PHvP/4j6po1e3boSNAGtAJcU1vPa0X8kK26vfaS7rkndBRous03j5JS+0K9e0LyIubj5D1+\nfP55YHWLFoWOoLnaesPSZmXv86aO7IPiVHVEvjobN6681nMAAKBeaEHkic+b03POkXbfvff8y3iq\nXta8s9hyy9AR1M9VV0V99FGOKpSZJvxYjkcCauMTx1CeempVItG6qEJ5Q4R90U7s99GxzQBUGRVE\nfZx3nnTSSfnmkfUCcMEFo03fhB+DKM7b3hY6guGadLPUqzwOKqM+y++o27HK545Zs6S77lo90XWT\njpNYlfZBPGR4FaTdLuQgqp+ZM0NHgKyqdL6qM85X6XC8Aen4PqfQxayPo48erS9frx3DiS2fbbYJ\nHQGAkHbdtbkJSNv+A6Ht699W3/ym9P3vh44CPsVl+ZhjwsZRJ/w+QB3ddpt0772ho6iONCNo1lVD\nb73Lc9NNoSNorhe9KP88QozSQuJpdOPHMEJae+3QEQCRQw6RttgidBQAqmL+/NARIK0991w1wmjb\nOSddeGHoKIpDBVFOO+8cvRY9tHU8r5BDaNfNihXSI4+Uv9wDDih/mT5wHDVHU59ONvEYLXpfrVgh\nLV9e7DKKkHa7rLNO9Nq2oZOrpKnnG6xp883XfG+99aJXckSm18RrWVZXXCE9/HDoKIB6u+Yav4NP\nkIMop6af5KuwflljiJPcluGss8pbVpNV4XirM7Zf/RS9z8o8DxZh2PbZaCPpe9+T5s0rJx70x/mn\n+V7/+igFQ9K0aVHL6X32CRMT6m2ddaTp0/t/hnQ23lhauTJ0FAjl1a+O/vlCBVFNhHpCx5PB4dhG\nSBp0PBx55GjTo/nY/72Nsl1e9rLCwgCQ0K8SsK4tp1FtL3956AiyCVFZftdd0s9/Xv5y0UxUEHmS\nvJlda63ihgqu8jD3ixZJ999fXCx1MzYWOoLRhHz6W+cnz1/5irRsWego2qHOx0m3Jq1LkdhO1cc+\napdzz5X23z90FPVGmRnsySelcePqN0jFhRdK55wTZtkzZzJCJPyhgqgAS5eWWzlQlQqi17ymuDjq\n5sEHpYkTQ0dRP3W8aTrqqOHTDMoh5lOclH3SpGKXAwBop/POCx1B/dXxXqdMcV6rupkwIXQEgB9U\nEBWgVxI/jK7OXS/qnDB1t93CLbuNN00+j/P99pNuuCFdpRVQZXU+/7cN+woAgOaoVeM9M3uhmV1t\nZr83s3+Y2f1mdp6ZrdM13Y5m9kMze9LM/mhmZxYdGzdIxemuNLjjDun668PE0mTxdu6XLBDp+BxF\nYFRm0jHHRE2z0+C8haprY6UxAABAKLWqIJL0Ukkm6W2StpN0mqR3SloYT2BmEyUtlvQHSXMlnSnp\nPDP71yICqsLNaxViKNMee0jHHhs6iuahssCPL3xBevTR4dNdcknxsQAAgGpp2317W7zxjVEr/Fe8\nInQkQD61qiByzi12zp3gnFvinHvQOXezpI9JOiIx2b9IWkfSCc65+5xzX5Z0haTTA4Rce8uXh44A\nbdCkm6Xx49N1M61rH3ugDIcfHr3Onh02DgAA0pg6VbrzTvJAov5qVUHUxyRJKxJ/z5P0Q+fcs4n3\nFkvaxsw2LiqIokcX22GH6HXOHH/zTGPJknKXh3BCVtLErZeaVFGUtNFG0evBB4eNI8bTrfCaeqz7\nsuuu0XlhypTQkQCAX5z/AVRZrZNUm9nWkk7S6q2Dpkr6fdekyxKfrSwill7dc3x22Zk7Nxr2sVer\ngyIvNGutJT33XHHzB6TmVxBNnBiV33XXDR1J5KyzpG9/O3QUkOjaifq77jrp058OHQVQH0291wHQ\nDJVoQWRmHzKz5wf8e87MZnV9Z7qkb0r6knPummGL6Lx6vxUv8yQfokvKxoW1uRpuiy2i17UqcZS2\nBz9Yi7Heer3PFyG295w50mabSW9+c/nLBtAs22wjXXRR6CgAAIAPVWlB9DFJnxkyzf9vFWRmW0j6\nrqQfOefe0TXdUkndjdLHOq/LNMBpp52mjbtqRI499lgdmzEjclmVR2lHLMri3/5NWrhw+HRF+PjH\npde/XtpggzDLbxueaJUr5PbeeGPpscfCLR+rUO4AAADg0w033KAbbrhhtfdWrkzXkaoSFUTOueWS\nUqVD7rQc+q6kuyS9tcckt0v6gJmt7ZyLO0cdJOk3zrmBW+XSSy/V3Llz0weeELLVxbveVdy841Y8\nvu277/BpNtww7JDhKA+tltBWbTv2d9xR+sUvQkcBAADQXL0audx9993aZZddhn63EhVEaZnZNEnf\nl/SgpP+UNGadx6/Oubh10PWS3i/pGjP7iKQdJJ0iqZBqlEFPf3faqYglrmnChHKW48vf/la/mNsk\n6w/W00+Xdt8937JDtKa49FLpn/8sf7mxoisIrr1W+vWvi13GKMaNk559dvh0TUfLIQBoJ87/AKqs\nVhVEiloCzej8e6jzninKLbS2JDnnHjezgyVdKem/JD0m6TznXKkpFH/+c2mrrcpcYn0w/GM15b1h\nufji7N8NmaT61FPLX6ZU3rouWFDOctJ66CHp8cezfbdJN9VxTjm60AJAuzTpWgageWpVQeScu1bS\ntSmmu0fSfsVH1N+OO4ZcOpBdiC4vbetmk9S2dZ86NfqXRYhE/Uk+E+bPny9ddRWJwgEAAFAdtaog\nqrK2/chD84yNSe99r3TiieFiaNNTtQULpPvukzLmwEcAs2YNnyYtM+ltb/M3v7q48Ubpi18MHQUA\nhNOmex0A9UMFUU6c5NEUZtIHPxg6ivaYMEG67LLQUQDlmjlTOuec0FEAAACgFyqIMBAVYCgDLfCQ\n1tprSyefHGbZJNcHAOQ1jl9fACqMU1ROEydGr/Pnh42jKPxwR5mokMQwoUZAu+oq6ZBDwiwbANAc\ne+8dvc6ZEzYOAOiFCqKcNtpIWr5c2mSTcDEU+aOaCiKUgeMMVdfGfEEAAP/iAQ/WXz9sHADQCxVE\nHmy6aegIgHpbe+3odbPNwsYBAABQJFpLA6gyKogwEBcxlGHSpGhko1e+MnQkAAAAGMVRR4WOAIAv\nVBABqISjjw4dAdK69lppxozQUQAAUD9N61bftPUB2o4KIgDASBYsCB0BAAD1Rit9AFW0VugAUG3j\nx4eOAAAAAAAAFI0KIgwU9yneb7+wcQAAAAB1F7ccOuSQsHEAQC90McNA8ehS66wTNg4AAACg7tZa\nS3r8cWnDDUNHAgBrooKoAYrsw0ziOQAAAMCfiRNDRwAAvdHFDKmQSA8AAAAAgOaiggip0JIIAAAA\nAIDmooIIA9FyCAAAAACA5qOCCAPRcggAAAAAgOajggip0JIIAAAAAIDmooIIAAAAAACg5aggAgAA\nAODVJpuEjgAAMKpxoQNAfkV2/yIHEQAAAEbxwx9KL3pR6CgAAKOigggA0Fpf/ao0ZUroKACgWfbd\nN3QEAHqZPj10BKg6KohGMDYmPfpo6ChWmTVL+u1vi10GyakBNNkRR4SOAAAAoHgrV0rj+PWPIchB\nNIJ77pHuvTf797feWjr7bH/x3Hab9Itf+Jsf0EY33HBD6BAABEL5B9qL8o+22Wgjaf31Q0dRDZT/\n/qggGsHYmLTddtm/f//90oUX+otns82kHXbwN79eyEGEpuMCAbQX5R9oL8o/0F6U//6oIEIqdDUD\nAAAAAKC5qCACAAAAAABoOSqIAAAAAAAAWo485pH1JOm+++4LHUflPP109DpzpnT33WFjAYqwcuVK\n3c3BDbQS5R9oL8o/0F5tLP+Juo71Bk1njizEMrPjJH0hdBwAAAAAAAAFeaNz7vp+H1JBJMnMNpN0\nsKQHJT0VNhoAAAAAAABv1pP0IkmLnXPL+01EBREAAAAAAEDLkaQaAAAAAACg5aggAgAAAAAAaDkq\niAAAAAAAAFqOCiIAAAAAAICWo4IIQK2Z2b5mtsjM/mxmz5vZYV2fb2BmV5rZQ2b2DzO718ze0TXN\n9zvfjf89Z2af6JpmSzP7hpk9YWZLzewiM+McCgSUovyPmdlnO58/YWa3mNnWXdOsa2b/zcweM7O/\nm9mNZjbWNQ3lH6gYT+Wf6z9QM2b2XjO708weN7NlZnaTmc3qmsbLtd3MXmZmPzGzp8zst2b25jLW\nMSRObgDqbgNJP5N0oqRewzJeKukgScdJeqmkyyRdaWaHJqZxkq6SNEXSVEnTJP1n/GHnYnGLpHGS\n5kl6s6TjJV3gd1UAjGhY+f+6oiFdXyNpZ0l/kvQdM5uQmOYySa+WdKSk+ZK2kPTV+EPKP1BZPso/\n13+gfvaV9HFJe0h6uaR1JH3L97XdzF4k6WZJSyTtJOlySVeb2SsKWauKYJh7AI1hZs9Lep1zblHi\nvXskfdE5tzDx3n9JusU59/7O39+T9FPn3Ol95vtKSYskTXPOPdZ57x2SPixpc+fcs0WtE4B0usu/\nmc2U9BtJ2znnft15zyQtlfRe59w1ZraRpL9KOsY5d1Nnmm0k3SdpnnPuTso/UH1Zyn/nPa7/QM2Z\n2WRJj0qa75z7ka9ru5l9RNIrnXM7JpZ1g6SNnXOvKnMdy0QLIgBNd5ukw8xsC0kys/0lzZS0uGu6\nN5rZX83sHjP7YNdTiHmS7okvIB2LJW0safsCYweQ3bqKWgc8Hb/hoqdiT0vap/PWroqeHi5JTPMb\nRS0N9uy8RfkH6idN+Y9x/QfqbZKi8r6i8/cu8nNtnyfpO13LWpyYRyNRQQSg6U5W9MTgYTN7RlFz\n0hOdc7cmpvmCpH+R9DJJH5T0JkmfT3w+VdKyrvkuS3wGoHp+rehm8ENmNsnMxpvZuyW9QFE3Einq\nVvKMc+7xru8u06qyTfkH6idN+Ze4/gO11mkZeJmkHznnftV5e6r8XNv7TbORma2bN/aqGhc6AAAo\n2CmK+igfquhmcb6kT5jZI86570qSc+7qxPT3mtlSSUvM7MXOuT8MmT/9dIEK6jQPP0LSpxU9VXxW\n0ZPAW1J83ZSubFP+gQpKW/65/gO19wlJ22nNloG9+Li2W4ppao0WRAAay8zWk7RQ0mnOuVucc790\nzn1C0pcknTHgqz/uvMajnSxV1NIgKf67+8kCgIpwzv3UOTdXUZPxaZ2cAZMlxT/8lkoa38lXkDSm\nVWWb8g/UUIry3wvXf6AmzOxKSa+S9DLn3COJj/Je25cOmGZM0uPOuWfyxF5lVBABaLJ1Ov+6a/mf\n0+Dz35zOd/7S+ft2STt0kuDFDpK0UtKvBKDSnHN/d84t7ySu3VXS/+x89BNFLQsOjKftDJW7laL8\nZRLlH6i1AeW/F67/QA10KodeK2l/59yfuj7Oe22/LzHNgVrdQZ33G4suZgBqzcw2UPSkL27yOcPM\ndpK0wjn3kJn9QNJHzewpSX9UlGdggaRTO9+fIek4Rc3OlysaxvISST9wzv2yM89vKboR/Hwnh8E0\nSRdKutI598/i1xJALynK/1GKRjL5k6QdFeUp+JpzbokkOeceN7NPS7rEzP4m6e+SrpB0q3Purs48\nKf9ABeUt/1z/gXoys09IOlbSYZKeMLO4lc9K59xTHq/tn5R0Umc0s2sUVRYdpajVUmMxzD2AWjOz\n/SR9T2u2ErrWOfdWMxuT9CFFNf6bKqok+pRz7vLO918g6TpFIxZsIOkhSV+TtNA5938Ty9lS0n9X\nVMH0hKTPKhoq9/nCVg7AQCnK/8mSzlTUJPwvkq6V9IHk0NSdRJMfU3Szua6k/60okf2jiWko/0DF\n5C3/XP+BejKz59U7B9BbnHOf60zj5dreOc9coijP0cOSLnDOJRPZNw4VRAAAAAAAAC1HDiIAAAAA\nAICWo4IIAAAAAACg5aggAgAAAAAAaDkqiAAAAAAAAFqOCiIAAAAAAICWo4IIAAAAAACg5aggAgAA\nAAAAaDkqiAAAAAAAAFqOCiIAAICSmNk1ZvaQme1vZv/DzOaHjgkAAECSxoUOAAAAoA3MbG1JO0k6\nWtLHJD0l6bagQQEAAHSYcy50DAAAAAAAAAiILmYAAAAemNnBZvZ/zOxvZvaYmf0vM5vR+eyFZva8\nmR1uZt81syfM7GdmNq9rHkea2S/N7Ckz+4OZnR5mbQAAQNtQQQQAAODHBpIulrSLpAMkPSfppq5p\nPiDpIkVdzX4r6XozW0uSzGwXSV+SdL2k2ZLOlXShmS0oJXoAANBqdDEDAAAogJltLmmZosqeJyT9\nQdJbnXOf7Xy+raRfStrWOfdbM7tO0mTn3CGJeXxE0qucczuUHT8AAGgXWhABAAB4YGZbm9n1ZvaA\nma2U9HtJTtJWicnuSfz/L5JM0ljn720l3do121slzTQzKyhsAAAASYxiBgAA4MvNiloJ/aukRySt\nraiF0PjENP9M/D9uxh0/sLPEe0q8BwAAUDgqiAAAAHIys00lzZJ0gnPu1s57+4w4m19J6v7O3pJ+\n68gJAAAACkYFEQAAQH5/k7Rc0tvNbKmkF0r6kNZsETTIxZLuNLOzFSWr3kvSiZLe6TlWAACANZCD\nCAAAIKdOC5+jFY1gdo+iyp4z4o+7Xlf7amIeP5X0hs587pF0nqSznXOfLyZqAACAVRjFDAAAAAAA\noOVoQQQAAAAAANByVBABAAAAAAC0HBVEAAAAAAAALUcFEQAAAAAAQMtRQQQAAAAAANByVBABAAAA\nAAC0HBVEAAAAAAAALUcFEQAAAAAAQMtRQQQAAAAAANByVBABAAAAAAC0HBVEAAAAAAAALUcFEQAA\nAAAAQMv9P71vzxxUMo27AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2ba5972e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(14,4))\n",
    "plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
    "axis('tight')\n",
    "title('temperaturas en Estocolmo')\n",
    "xlabel(u'año')\n",
    "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": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.44373475,  0.09421772,  0.22699008],\n",
       "       [ 0.56588745,  0.33473943,  0.57484992],\n",
       "       [ 0.36831004,  0.77844943,  0.47212619]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = random.rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "savetxt(\"matriz-aleatoria.csv\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "savetxt(\"matriz-aleatoria.csv\", M, fmt='%.5f') # fmt especifica el formato (5 decimales)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### El formato de archivo nativo de Numpy\n",
    "\n",
    "Este formato 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": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "save(\"matriz-aleatoria.npy\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.44373475,  0.09421772,  0.22699008],\n",
       "       [ 0.56588745,  0.33473943,  0.57484992],\n",
       "       [ 0.36831004,  0.77844943,  0.47212619]])"
      ]
     },
     "execution_count": 35,
     "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": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.itemsize # los bits de cada elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.nbytes # número de bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 38,
     "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, tal como con las listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 39,
     "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": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.33473943047565435"
      ]
     },
     "execution_count": 40,
     "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 un arreglo multidimensional `Numpy` entrega la fila completa (o, en general, al arreglo de dimensión N-1 correspondiente) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.44373475,  0.09421772,  0.22699008],\n",
       "       [ 0.56588745,  0.33473943,  0.57484992],\n",
       "       [ 0.36831004,  0.77844943,  0.47212619]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.56588745,  0.33473943,  0.57484992])"
      ]
     },
     "execution_count": 42,
     "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": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.56588745,  0.33473943,  0.57484992])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # fila 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.09421772,  0.33473943,  0.77844943])"
      ]
     },
     "execution_count": 44,
     "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": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[0,0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.09421772,  0.22699008],\n",
       "       [ 0.56588745,  0.33473943,  0.57484992],\n",
       "       [ 0.36831004,  0.77844943,  0.47212619]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# también funciona para filas y columnas completas\n",
    "M[1,:] = 0\n",
    "M[:,2] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.09421772, -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.36831004,  0.77844943, -1.        ]])"
      ]
     },
     "execution_count": 48,
     "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]` que extrae una parte de un arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([1,2,3,4,5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 50,
     "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": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 51,
     "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": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # desde, hasta y paso asumen los valores por defecto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 53,
     "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": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # primeros tres elementos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 55,
     "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": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # el último elemento del arreglo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 58,
     "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": 59,
   "metadata": {},
   "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": 59,
     "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": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# un bloque parte del arreglo original\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 61,
     "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 un arreglo o una lista es usado en lugar de un índice: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices_fila = [1, 2, 3]\n",
    "A[indices_fila]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 22, 34])"
      ]
     },
     "execution_count": 63,
     "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": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = arange(5)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masc_fila = array([True, False, True, False, False])\n",
    "B[masc_fila]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 66,
     "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": 67,
   "metadata": {},
   "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": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(0, 10, 0.5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "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": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masc = (5 < x) * (x < 7.5) # * Entre 2 booleanos actúa como AND, entregando 0 (False) y 1 (True)\n",
    "\n",
    "masc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.5,  6. ,  6.5,  7. ])"
      ]
     },
     "execution_count": 69,
     "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": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14]),)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = where(masc)\n",
    "\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.5,  6. ,  6.5,  7. ])"
      ]
     },
     "execution_count": 71,
     "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": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 73,
     "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": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 = arange(-3,3)\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices_fila = [1, 3, 5]\n",
    "v2[indices_fila] # indexado fancy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 76,
     "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": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 77,
     "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": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 2, 7, 4])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cuales = [1, 0, 1, 0]\n",
    "posibilidades = [[1,2,3,4], [5,6,7,8]]\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": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = arange(0,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   3,   6,   9,  12],\n",
       "       [ 30,  33,  36,  39,  42],\n",
       "       [ 60,  63,  66,  69,  72],\n",
       "       [ 90,  93,  96,  99, 102],\n",
       "       [120, 123, 126, 129, 132]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3*A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "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": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A+2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones elemento a elemento entre arreglos\n",
    "\n",
    "Cuando sumamos, sustraemos, multiplicamos y dividimos dos arreglos, el comportamiento por defecto es operar *elemento a elemento*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "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": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # multiplicación elemento a elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "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": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A**2 # mismo resultado que A*A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 86,
     "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": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "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": 88,
     "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": 89,
   "metadata": {},
   "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": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 91,
     "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": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = matrix(A)\n",
    "v = matrix(v1).T # aplica la traspuesta, convirtiéndolo en vector columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "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": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M*M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [130],\n",
       "        [230],\n",
       "        [330],\n",
       "        [430]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M*v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# producto interior\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [131],\n",
       "        [232],\n",
       "        [333],\n",
       "        [434]])"
      ]
     },
     "execution_count": 97,
     "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": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (6, 1))"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M), shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-100-995fb48ad0cc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/opt/anaconda/lib/python2.7/site-packages/numpy/matrixlib/defmatrix.pyc\u001b[0m in \u001b[0;36m__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    341\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m             \u001b[0;31m# This promotes 1-D vectors to row vectors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 343\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0masmatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    344\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misscalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'__rmul__'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;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": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.+1.j,  0.+2.j],\n",
       "        [ 0.+3.j,  0.+4.j]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-2.j],\n",
       "        [ 0.-3.j,  0.-4.j]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hermítico conjugado: transpuesta + conjugado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-3.j],\n",
       "        [ 0.-2.j,  0.-4.j]])"
      ]
     },
     "execution_count": 103,
     "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": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.,  0.],\n",
       "        [ 0.,  0.]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "real(C) # lo mismo que: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 105,
     "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": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.78539816,  1.10714872],\n",
       "       [ 1.24904577,  1.32581766]])"
      ]
     },
     "execution_count": 106,
     "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": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 107,
     "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": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.+2.j ,  0.-1.j ],\n",
       "        [ 0.-1.5j,  0.+0.5j]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.inv(C) # equivalente a C.I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[  1.00000000e+00+0.j,   0.00000000e+00+0.j],\n",
       "        [  1.11022302e-16+0.j,   1.00000000e+00+0.j]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.I * C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determinante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0000000000000004+0j)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.49999999999999967+0j)"
      ]
     },
     "execution_count": 111,
     "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": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 112,
     "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": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.1971096847515854"
      ]
     },
     "execution_count": 113,
     "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": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.2822716213405734, 68.596023209663414)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "std(data[:,3]), var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `min` y `max`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.800000000000001"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# valor mínimo del promedio diario de temperatura. Lo mismo que data[:,3].min()\n",
    "min(data[:,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.300000000000001"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# valor máximo del promedio diario de temperatura. Lo mismo que data[:,3].max()\n",
    "max(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `sum`, `prod` y `trace`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = arange(1,11)**2\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "385"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# suma todos los elementos\n",
    "sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13168189440000"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiplica todos los elementos\n",
    "prod(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   5,  14,  30,  55,  91, 140, 204, 285, 385])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# suma acumulativa\n",
    "cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([             1,              4,             36,            576,\n",
       "                14400,         518400,       25401600,     1625702400,\n",
       "         131681894400, 13168189440000])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# producto acumulativo\n",
    "cumprod(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 122,
     "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": "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": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.,\n",
       "        12.])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique(data[:,1]) # la columna mes asume valores entre 1 y 12, `unique` lista los valores distintos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "masc_feb = (data[:,1] == 2) # los paréntesis () son opcionales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.2121095707365961"
      ]
     },
     "execution_count": 125,
     "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": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhwAAAF5CAYAAADUL/MIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIUmSamfhkCRJtbNwSJKk2lk4JElS7f4/rYbSsvjbl/QAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2ba27ed6d0>"
      ]
     },
     "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",
    "bar(meses, media_mensual)\n",
    "xlabel(\"Mes\")\n",
    "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": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.69848249,  0.95112965,  0.95984403],\n",
       "       [ 0.34837068,  0.5614132 ,  0.69146514],\n",
       "       [ 0.11750508,  0.45918034,  0.97143975]])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = random.rand(3,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.97143975235812652"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# máximo global\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.69848249,  0.95112965,  0.97143975])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# máximo en cada columna\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.95984403,  0.69146514,  0.97143975])"
      ]
     },
     "execution_count": 130,
     "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 (opcional) `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, incluso con arreglos grandes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "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": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "n, m = A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "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": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1,n*m)) # convierte el arreglo a uno de dimensiones (1,n*m)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "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": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modifica el arreglo\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "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": 135,
     "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": 136,
   "metadata": {},
   "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": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "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": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "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": 138,
     "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": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# crea una matriz con el vector v como su columna\n",
    "v[:, newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matriz columna\n",
    "v[:,newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matriz fila\n",
    "v[newaxis,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 144,
     "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 funciones `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": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = array([[1, 2], [3, 4]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repite cada elemento 3 veces\n",
    "repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 147,
     "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": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `hstack` y `vstack`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hstack((a,b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy y \"deep copy\"\n",
    "\n",
    "Para alcanzar un alto desempeñ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": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[1, 2], [3, 4]])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ahora B apunta al mismo arreglo que A\n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cambiar B afecta a A\n",
    "B[0,0] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 156,
     "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 profunda\" (\"deep copy\") usando la función `copy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 158,
     "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": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 159,
     "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 casos el bucle Python `for` es la forma más conveniente para iterar sobre un arreglo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "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": 161,
   "metadata": {},
   "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 valores, es conveniendo usar la función `enumerate` para obtener tanto el elemento como su índice en el bucle `for`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "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": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 163,
     "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 de que las funciones que escribamos funcionen con argumentos vectoriales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "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": 165,
   "metadata": {},
   "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[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-165-6658efdd2f22>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mTheta\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-164-d6359217b50a>\u001b[0m in \u001b[0;36mTheta\u001b[0;34m(x)\u001b[0m\n\u001b[1;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[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \"\"\"\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;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. Para obtener una *versión 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": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "Theta_vec = vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 167,
     "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, para mejorar el rendimiento):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "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": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 170,
     "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": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "al menos un elemento de M es mayor que 5\n"
     ]
    }
   ],
   "source": [
    "if any(M > 5): # equivalente a (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": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no todos los elementos de M son mayores que 5\n"
     ]
    }
   ],
   "source": [
    "if all(M > 5): # equivalente a (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 arreglo no puede ser cambiado luego de que es creado. Sin embargo, 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": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.,   4.],\n",
       "       [  9.,  16.]])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.+0.j,   4.+0.j],\n",
       "       [  9.+0.j,  16.+0.j]])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(complex)\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 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}