machinelearning_notebook/1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy -  多维数据的数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "J.R. Johansson (jrjohansson at gmail.com)\n",
    "\n",
    "最新的[IPython notebook](http://ipython.org/notebook.html)课程可以在[http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures) 找到.\n",
    "\n",
    "其他有关这个课程的参考书在这里标注出[http://jrjohansson.github.io](http://jrjohansson.github.io).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 这一行的作用会在课程4中回答\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 简介"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个`numpy`包(模块)用在几乎所有使用Python的数值计算中。他是一个为Python提供高性能向量，矩阵和高维数据结构的模块。它是用C和Fortran语言实现的，因此当计算向量化数据（用向量和矩阵表示）时，性能非常的好。\n",
    "\n",
    "为了使用`numpy`模块，你先要像下面的例子一样导入这个模块："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 不建议用这种方式导入库\n",
    "from numpy import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在`numpy`模块中，用于向量，矩阵和高维数据集的术语是*数组*。\n",
    "\n",
    "**建议大家使用第二种导入方法** `import numpy as np`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 创建`numpy`数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有很多种方法去初始化新的numpy数组, 例如从\n",
    "\n",
    "* Python列表或元组\n",
    "* 使用专门用来创建numpy arrays的函数，例如 `arange`, `linspace`等\n",
    "* 从文件中读取数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 从列表中"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "例如，为了从Python列表创建新的向量和矩阵我们可以用`numpy.array`函数。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# a vector: the argument to the array function is a Python list\n",
    "v = np.array([1,2,3,4])\n",
    "\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "# 矩阵:数组函数的参数是一个嵌套的Python列表\n",
    "M = np.array([[1, 2], [3, 4], [5, 6]])\n",
    "\n",
    "print(M)\n",
    "print(M.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`v`和`M`两个都是属于`numpy`模块提供的`ndarray`类型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v), type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`v`和`M`之间的区别仅在于他们的形状。我们可以用属性函数`ndarray.shape`得到数组形状的信息。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过属性函数`ndarray.size`我们可以得到数组中元素的个数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样，我们可以用函数`numpy.shape`和`numpy.size`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.size(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "到目前为止`numpy.ndarray`看起来非常像Python列表(或嵌套列表)。为什么不简单地使用Python列表来进行计算，而不是创建一个新的数组类型?\n",
    "\n",
    "下面有几个原因：\n",
    "\n",
    "* Python列表非常普遍。它们可以包含任何类型的对象。它们是动态类型的。它们不支持矩阵和点乘等数学函数。由于动态类型的关系，为Python列表实现这类函数的效率不是很高。\n",
    "* Numpy数组是**静态类型的**和**同构的**。元素的类型是在创建数组时确定的。\n",
    "* Numpy数组是内存高效的。\n",
    "* 由于是静态类型，数学函数的快速实现，比如“numpy”数组的乘法和加法可以用编译语言实现(使用C和Fortran).\n",
    "\n",
    "利用`ndarray`的属性函数`dtype`（数据类型），我们可以看出数组的数据是那种类型。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果我们试图给一个numpy数组中的元素赋一个错误类型的值，我们会得到一个错误:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m-----------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-e1f336250f69>\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\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'hello'"
     ]
    }
   ],
   "source": [
    "M[0,0] = \"hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果我们想的话，我们可以利用`dtype`关键字参数显式地定义我们创建的数组数据类型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 2.+0.j],\n",
       "       [3.+0.j, 4.+0.j]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]], dtype=complex)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "常规可以伴随`dtype`使用的数据类型是：`int`, `float`, `complex`, `bool`, `object`等\n",
    "\n",
    "我们也可以显式地定义数据类型的大小，例如：`int64`, `int16`, `float128`, `complex128`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 使用数组生成函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于较大的数组，使用显式的Python列表人为地初始化数据是不切实际的。除此之外我们可以用`numpy`的很多函数得到不同类型的数组。有一些常用的分别是："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# 创建一个范围\n",
    "\n",
    "x = np.arange(0, 10, 1) # 参数：start, stop, step: \n",
    "y = range(0, 10, 1)\n",
    "print(x)\n",
    "print(list(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.00000000e+00, -9.00000000e-01, -8.00000000e-01, -7.00000000e-01,\n",
       "       -6.00000000e-01, -5.00000000e-01, -4.00000000e-01, -3.00000000e-01,\n",
       "       -2.00000000e-01, -1.00000000e-01, -2.22044605e-16,  1.00000000e-01,\n",
       "        2.00000000e-01,  3.00000000e-01,  4.00000000e-01,  5.00000000e-01,\n",
       "        6.00000000e-01,  7.00000000e-01,  8.00000000e-01,  9.00000000e-01])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(-1, 1, 0.1)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### linspace and logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  2.5,  5. ,  7.5, 10. ])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用linspace两边的端点也被包含进去\n",
    "np.linspace(0, 10, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 3.03773178e+00, 9.22781435e+00, 2.80316249e+01,\n",
       "       8.51525577e+01, 2.58670631e+02, 7.85771994e+02, 2.38696456e+03,\n",
       "       7.25095809e+03, 2.20264658e+04])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(0, 10, 10, base=e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mgrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = np.mgrid[0:5, 0:5] # 和MATLAB中的meshgrid类似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.77849722, 0.80418995, 0.05675561, 0.70158519, 0.25432473],\n",
       "       [0.26593179, 0.68124455, 0.75827058, 0.54821965, 0.65368682],\n",
       "       [0.10501453, 0.61381473, 0.32029867, 0.05271199, 0.14810179],\n",
       "       [0.81571699, 0.311358  , 0.00545839, 0.81465233, 0.55005373],\n",
       "       [0.64861977, 0.50134439, 0.11211157, 0.97227545, 0.52994903]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 均匀随机数在[0,1)区间\n",
    "random.rand(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.09235676, -0.71023602,  0.61363172,  0.49120177,  1.00102961],\n",
       "       [ 0.70097434,  1.98685481, -0.48047899, -0.83134067,  1.17453105],\n",
       "       [ 0.50057823, -0.23609257,  1.08942973,  0.03857935, -2.00169139],\n",
       "       [-0.09077163,  1.08568903,  0.53531071,  0.30819683,  0.40767628],\n",
       "       [-0.24485242, -0.15219474,  0.29362566, -0.37050405,  0.17776159]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 标准正态分布随机数\n",
    "random.randn(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 一个对角矩阵\n",
    "np.diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 从主对角线偏移的对角线\n",
    "np.diag([1,2,3], k=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### zeros and ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 文件 I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 逗号分隔值 (CSV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于数据文件来说一种非常常见的文件格式是逗号分割值（CSV），或者有关的格式例如TSV（制表符分隔的值）。为了从这些文件中读取数据到Numpy数组中，我们可以用`numpy.genfromtxt`函数。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n",
      "1800  1  4   -19.3   -19.3   -19.3 1\r\n",
      "1800  1  5   -16.8   -16.8   -16.8 1\r\n",
      "1800  1  6   -11.4   -11.4   -11.4 1\r\n",
      "1800  1  7    -7.6    -7.6    -7.6 1\r\n",
      "1800  1  8    -7.1    -7.1    -7.1 1\r\n",
      "1800  1  9   -10.1   -10.1   -10.1 1\r\n",
      "1800  1 10    -9.5    -9.5    -9.5 1\r\n"
     ]
    }
   ],
   "source": [
    "!head stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "data = np.genfromtxt('stockholm_td_adj.dat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0UAAAEWCAYAAACpAjzFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAClmElEQVR4nO2dd5jcxPnHv3Pn3nsv54aNO9iY3k01vQXSKCGEQBIIkMQQAiRAMIFAyi8JJdQQaugY0003NsYNjHsvuOPerszvj5V2R7Oa2Vfa2Xb3fp7Hj/d2pdFIGo3m7UJKCYZhGIZhGIZhmLpKWaE7wDAMwzAMwzAMU0hYKGIYhmEYhmEYpk7DQhHDMAzDMAzDMHUaFooYhmEYhmEYhqnTsFDEMAzDMAzDMEydhoUihmEYhmEYhmHqNCwUMQzDMLUaIcQEIcSFhe6HDSHEUiHE6Ki/EdqVQoi+2fWOYRim9sNCEcMwTBGTzYK4kAghbhFCPFHofgCAlPIkKeVjcfYVQhwmhPhUCLFFCLFJCPGJEOIA77eLhBAfu+0twzAMUwjqFboDDMMwDKMjhKgnpawqcB9aAHgNwE8BPAugAYDDAewpZL8YhmEY97CliGEYpkgRQvwHQA8Arwohtgshfu19f5BnvdgshJgphDhK2ed9IcRt3u/bhRCvCiHaCiH+K4TYKoT4XAhRoWwvhRC/EEIsFkJsEELcJYQoU36/RAgxRwjxrRDiTSFET+W3vwohVnjtfiGEONz7/kQANwD4jteHmd73AauXak0SQlR4ffmREGI5gPdsxxcJ7hVCrPOO/6UQYrDhOr4vhLjU+3yREOJjIcTdXptLhBAnGW7BPgAgpXxKSlktpdwlpXxLSjlLCLEvgPsAHOyd42av/ZZCiMeFEOuFEMuEEDdq1/PH3vlsE0J8LYTYP6S/+3r9ukD5ergQYpZnsXpGCNFIa3OhZ8l6RQjRxXAdHhVC/NNzJ9zuWb06CSH+4l2LuUKI/QzXgmEYplbDQhHDMEyRIqX8AYDlAE6VUjaTUv5JCNEVwHgAtwFoA+A6AM8LIdoru54P4AcAugLoA2ASgEe87ecAuFk71JkARgLYH8DpAC4BACHE6UgIN2cBaA/gIwBPKft9DmC41+6TAJ4TQjSSUr4B4I8AnvH6PSzCaR8JYF8AJ2Q4/vEAjkBCcGkJ4DwAG4nHOBDAPADtAPwJwENCCBGy3XwA1UKIx4QQJwkhWvs/SCnnALgcwCTvHFt5P/3d609v71x+COBiABBCnAvgFu+7FgBO0/vsCUlvAvi5lFK91ucBOBFALwBDAVzkbX8MgDu83zsDWAbgacu5nwfgRu/c9yAxNqZ5f/8PwD2WfRmGYWotLBQxDMOUFt8H8LqU8nUpZY2U8m0AUwGcrGzziJRykZRyC4AJABZJKd/x3NGeA6BbA+6UUm6SUi4H8BcAvoXicgB3SCnnePv+EQmLRU8AkFI+IaXcKKWsklL+GUBDAP2zPL9bpJQ7pJS7Mhy/EkBzAAMACG+bb4jHWCalfFBKWQ3gMSSEiY76RlLKrQAOAyABPAhgvWeJSdsWAIQQ5UgIpNdLKbdJKZcC+DMSAioAXArgT1LKz2WChVLKZUoThwN4BcAPpZSvac3/TUq5Wkq5CcCrSAijAPA9AA9LKadJKfcAuB4J61WF4dxflFJ+IaXcDeBFALullI971+IZpI8NhmGYOgELRQzDMKVFTwDneq5zmz23rcOQWNj7rFU+7wr5u5nW5grl8zIAvvtVTwB/VY6zCYBAwgIFIcR1nivYFu/3lkhYHLJB7Yvx+FLK9wD8H4B/AFgnhHhAJGKAKKzxP0gpd3of9Wvi/z5HSnmRlLIbgMFIXJu/GNptB6A+EtfQZxm86wWgO4BFln5dDuBTKeX7tj4D2Kn0t4t6PCnldiSsT10RTtSxwTAMUydgoYhhGKa4kdrfKwD8R0rZSvnXVEo5LotjdFc+9wCwWjnWT7RjNZZSfurFD/0aCXes1p772BYkhJawfgPADgBNlL87hWyj7mc8PgBIKf8mpRwBYCASbnS/inLSUZFSzgXwKBLCkd5XANiAhAWrp/JdDwCrvM8rkHBnNHE5gB5CiHsjdGu1ejwhRFMAbZVjMgzDMARYKGIYhilu1iIRn+LzBIBThRAnCCHKhRCNhBBHCSG6ZXGMXwkhWgshugO4Cgk3KiCRSOB6IcQgIJlE4Fzvt+YAqgCsB1BPCHETEnEyar8r1CQDAGYAOF8IUV8IMRLAORn6ZTy+EOIAIcSBQoj6SAhbuwHUxDl5E0KIAUKIa/1r612fCwB85m2yFkA3IUQDAPBc0J4FcLsQornn5ncNEvcMAP4N4DohxAgvUURfoSSuALANibihI4QQVCH3KQAXCyGGCyEaIuFiONlz3WMYhmGIsFDEMAxT3NwB4EbPhew6KeUKJJIh3ICEQLICCQtJNvP5ywC+QEJoGQ/gIQCQUr4I4E4ATwshtgL4CoCfqe1NAG8gkYxgGRJCier69pz3/0YhxDTv8++QsJR8C+D3SCRnMJLh+C2QiPP51jv+RgB3RTvtjGxDIinDZCHEDiSEoa8AXOv9/h6A2QDWCCE2eN/9HAkhbTGAj5E4x4e983kOwO3ed9sAvIREkookUsrNAI4DcJIQ4tZMHZRSvoPEdX0ewDdIXN/z45wswzBMXUZIGebhwDAMw9QFhBASQD8p5cJC94VhGIZhCgVbihiGYRiGYRiGqdOwUMQwDMMwDMMwTJ2mYEKRFxw8RSSqsc8WQvze+76XEGKyV537GT+AlWEYhnGPlFKw6xzDMAxT1ymkpWgPgGO8SufDAZwohDgIiaDae6WUfZEIoP1R4brIMAzDMAzDMExtp16hDiwTGR62e3/W9/5JAMcA+K73/WMAbgHwL1tb7dq1kxUVFTnpJ8MwDMMwDMMwpc8XX3yxQUrZPuy3gglFACCEKEciDWxfJKqSLwKwWUpZ5W2yEoaq3EKIywBcBgA9evTA1KlTc99hhmEYhmEYhmFKEiHEMtNvBU20IKWsllIOB9ANwCgAAyLs+4CUcqSUcmT79qECH8MwDMMwDMMwTEaKIvucV6xuIoCDAbQSQvgWrG4AVhWqXwzDMAzDMAzD1H4KmX2uvRCilfe5MRIVvOcgIRyd4212IRKV1hmGYRiGYRiGYXJCIWOKOgN4zIsrKgPwrJTyNSHE1wCeFkLcBmA6gIcK2EeGYRiGYRiGYWo5hcw+NwvAfiHfL0YivohhGIZhGIZhGCbnFEVMEcMwDMMwDMMwTKFgoYhhGIZhGIZhmDoNC0UMwzAMwzBMXpm2/Ft8vXprobvBMEkKWryVYRiGYRiGqXuc9c9PAQBLx40pcE8YJgFbihiGYRiGYRiGqdOwUMQwDMMwDMPUWrbtrix0F5gSgIWiOsK3O/ZiypJNhe4GwzAMwzBM3pi0aCOG3PIWPpi/vtBdYYocForqCN/992Scd/+kQneDYRiGYfLOrr3VWLR+e6G7wRSAL5YlFMJTlmwscE9SfLVqCyrGjsfUpaysLiZYKKojzPkmkeFFSlngnjDFzKYde1FTw2OEYZho7NxbhZ17qwrdDSM/e3Iajv3zB9hbVZP22/hZ37DAxOSVjxZsAAC8PWdtgXvCqLBQVMd4b+66QnehZJBSYvysb1BdR4SEDdv3YP9b38Y9b88vdFcYhikxBt70Jgbe9Gahu2Hk44WJRWhNiGLwSk9gYmonxagL3l1ZXegu5IR73p6Pf0xcWOhuxIaFojrG7sp0LRkTziszV+PKJ6fh3x8tLnRXjFSMHY9rnp3hpK0N2/cAAN76eo2T9nLNo58sQcXY8di8c2+hu8LkiPs/WMTuJUwaC9dtx5ad0QLni2VdPG/NNmzfU7wWtdqMgCh0F5L89d0FAIAZyzcXtiOO+du7C3DXm/MK3Y3YsFBUx5A5ejW88/XaWrd4Wb8tISSs3bqnwD2x88K0VU7aKaYXBoWnpqwAAKzZurvAPWFyxR0T5uKc+zgWkgky+p4PMObvH2Xc7uUZqzB3TXEVBz3hLx/ikkc+L3Q3aj2bd+7F/R8sKvqQgWISkO/7YBEG3fRGobtRUFgoKkEe+ngJfvnMjJy0LaXE81+sRGV1NIvSpY9PzdviJWrfmNpNkb/zGCaAlBJVPIdlzcpvd2Xc5qqnZ+DEv2QWnvKFv0CfUssUiMXI9S98iTsmzMXkHGTdlVLipemrnLjAiSLSRY6bMBc79tZOtz4qLBSVILe+9jVenO7GOqDzyszVuPa5mbjv/UU5aT9bvly5Bf1+OwETOTYqZ7gUMuav3Za0uDEMA9zw4pfo+9sJztqTUuLTRRuKXiPO1E2e/XwFXsrResXGtt0JC4yqRHXlKfPRgg24+pkZuPONuVm3tXozezoUEywU5YHj7vkAlz0+NeN2W3ZVYuP2wi4gv92RiM/YUOB+mPjc07BxvYH4rNi0Ew9+mJ84qePv/RCH/+m9nB4jTNO2evOupBZv9eZduK8E3CiY0mbdtt247rmZGceZ7/bpiglfrcF3H5yMJz5bZt2upkbiL+/Mr7sxeMTHf/ueKtzz1rycWPPq4hT06+dn4eocebZExZWL+JZdiXi2dQ5c6zftiP88Vowdj4qx47ErgnVnd2U1KsaOzzhf7K2qwZ/fmhep7doAC0V5YMG67Xjr68xpF0fe9jZG3PYOgMTC9W3CPlHJx6RcUyNzlprV737YQvjZqStw2v99nJPj1iZ+8NBk3P76nEgC+JadlXhx+spYxytEco9Dxr2Hnz7xBQDgsv9MxbgJc7Fs486894OpO4y6/V3874uVeOSTpXk97spvE+M60/ieOG8d/vLOAtz8yux8dKtoyeSudPeb8/C39xbipRmr89MhpuTwMxgWi+tbFCX2Zi9Byd/fW2Dd7snJy/D39xbin++Xbia5OLBQVERUVqcklpP/9hF+TLAuRSUfiqo7JszBwJvejORvO3XpJvzmf7Myaln938M2+/X/ZmHWyi2R+loX8d0K9EvoT/Bhd+AXT0/HL5+ZmbGWR02NxLXPzsSMFZuz7me2TJyXsCb657uX4zjyyh0T5uCdHCh28s3uympc/p8vsGzjDtL2SzbQtss3fn2eYk4FvGDtNizPsfIik2Jwhxf4Xl2TA0uR8xYZCv51/9aRldQfQ+VlRSIVhXDjS19i0qJEsdqaGomJ89aFrq9em7Uaf3knvQzHnhKYL3IBC0VFir+Qy8Sbs9egYux4fLMlc9BpvnjwoyUAUi8XCufdPwnPTF2RsSaQ7zb36KdLrdtJKTFvzTby8esSpitsm9798ZUpycXGHXvx/LSV+NGjxZNdydeg3zkhe/9vhs79HyzGpTlQ7OSb9+auwxuz1+BX/5tF2r5YtMcAsGbLbvz5rXmQMhVN4bsQrdu6OyvXHSpLN+xAxdjx+JDg8nzcvR/iiLsm5rxPNvxXkMjBjYzrwvvpwg14/ot4lnqXVIwdjz+8+nWhuxGb/05e7qSdpKXISWsJNu3Yi3UOM6k+8dlyXPDgZwCAxyctxcWPfI5XZ32TVNr4WXV/9uR0/OWddKtRMc1j+YSFohLnmc8T/umzV9HSjuZznEepeZpyi7P3kOrD+9/Jy3HCXz7EJ17BPiaFjDGh+/eyTAhIKVExdjwOuP2d9LbhuxXkb6RR1xnLNkXTQI+87R089PGSGD1iCsnuymqn7rtPe3PsFGIWq0KtJcIeuZ8/NQ1/f28hvlq1Nfmc+NuN+uO72P/WtzO2+9qs1QHrzbcRBSk/09rLnjvajj1V2FNVvNpnfw4rK6JV4Xf/PRnXPjez0N0AADz8SW7mxI8WrMeXJeLpIZX3oSv2v/VtjPrju6G/vTBtZVap5Vd4mRrXbtmNyUs2kvYZP+sbAEEPJp/Pl25C/xsnRJ4LSgEWikocGdG31ZX5XkqJN75aYw1GjaIVS76wM21HPIPZqxMTyFKiy0tdxCS4hN03/7sykZokw7LK+R4nxZioo14EV4dVm3dhw/Y9uPW14tGKVlbX4I2v1uQlYcTarbvzVnds5bc7nbpbHnfvBxh405vO2juwVxsAQL8OzZy16RLbcNiluL6kFBbR2v/Zk9Nx0l8/BJAQDPe79W288VWEAs/JBWTi/0E3v4mT/pr/NNnUd8cqbwG5dVe04rC0PmRHLhIMVVbX4MKHp2Bmhmcw12nkf/DQFJxaIjHBNdQFS0yWb9yJ79w/Cdt2V0JKiWuenZlVavn3vGy9QtCV1TM9ATXM5fCfExdiT1UNpq/4NnafihUWikocW+KBXPL212tx+RNf4B8Tzam7o1iKfDKdR5w2axNTlmzCI1lq6jYbXva2a091KdlVAP9j6tivX06f7lYRaqDkm7+/uwCXP/EFJs7LfTr64+/9MHLdsd2V1bjp5a+wdXe0xeRhd07EGf/4JO17agwPAOxz4wRc8EDCVWTFptS9q6yuwUvTV0Vy5dVp27QBAGC/Hq1I2+fTSpoJX0khhKp4it4/v3aJv3D+PIPA/Jbn1r10w47kAvLtOan4ssXri1dZ5de1eXWW+0QL2eozpi1zvwid881WfDB/PX6dwT00zGIQxp6qanz3wc+werO7OXT15l2RXctyVag+0XaCXFkT731nPiYv2YS3Zq/FEw5c/tQ4x6ixcrYYSSnjz/vFCgtFJY7tRbd9T1XOqiVv2J7QHthimWocabRXb96FJ72JgdJmJk368o07UTF2PL5aRTPVZ5r3npqyHPv8dkLGeCidtTH8h8+7fxJ+n6VPdyYlV9hZ+BPji9Ps9Sbi3vNj//w+7pgwJ9I+UV969cuLZ7Eah5XeImPj9mguC0f8aSLueWtepH22xNCSPzVlOR6ftAx/f9ee1YjKjj10AXtvVQ0mLU53Cxk3YS6ufmYGjrzrfSd9KjXUOcmFAq1GsRgDwH8mLQ1drL4yMyFQzFq1JXlcP+tVoaFOUcXkPueTiy797qWvAABrvPu4u7IaW7K4Vy9MW4VPF23EIePclWI4ZNx7RtcyCq6N61J7Duav3ZYc83e+MRcVY8dn5Qqo3ubZxHUKhV17qyNbG/3kVeu27lY8k1I9/O/kxLz/f+8Fs9RFXQ8VCywUFSGR3M78DyGT5eCb38Tgm925kYRhm6TnrY2e6CBMy/r9hybjhhe/xJadlSQNY+Lyma/hu3MTGsvnptLqhWS6Hbe8Mht7q2uS2Z0ovDBtJQ7847v4wqD5q6mROXeTEiIx0aUCoDO/cd+fv84qjMTt86L1O3D/B/FqJ/kKgZoMk3CUOboI10NWDf/6bXvwvsGCtHzTTvzNe2FJKTNep7j4L8FiSvLnu+WZ3DlzcS0KNXbC5s5NnutLwlKUfbyfGlu4fONO/O7l2fiJl/o+rC9SSquiREppXTxFvT/VNRLn3T8pNKlD1KmpPJvrZJi/s7VeuKqzo+K7SW3zNP0n//UjDPvDWwAS76nL/5N+f4FEaYc3Z6e7UbpShpqgvhs3bMtdvIv6HAAJy/ovnpoOAPiXV/j+ySmJOkDZvsv9mEYb+lA1He/ed+bHmp8XrtuOUX98NzTG1rc86c9qpqRMxQoLRTlizjdbM2pbpZS49LHP05IBvByjPgJ1qsz0cK7ektAWVTlYLGSyKlDxNePUydbVpOy7C2QKLPWP9tsXv0z7bcvOytAASd/9xJQhr/cNr2cMrHUhNJ3xj0/ww4enkLdfumGndXERJSX6lCWbnCxKJSTenbMWvW94HXO+MQejRolbKRaZaPXmXWkpisOu2Ln3fYqLHsmc8e/CRz5H7xted9Q796z8didO/8cn2L6nKqfuLwDwxldr0PuG17Egg/JGz9r25cotVne8XCxc49K6SX0AQL2yMnLcpo3kPRGpFPdh7zlfgy6lXRh57NOl6HPD66E106Yu3YTeN7xOTnABJOIfpizZFFos1H+nUZNwZCPc9r7hdZwb0f2UQi4Fbv82LVbcpa55dibe8AQfPYb0owUb8JMQgSnXFoLeN7yO657LnAkyjlKWSg1BweCP+943vI6bXs5vbTDTM1cj460blm9KjAlb4qqwSzF9+beRvRQKDQtFOeKkv36E79xvnxQ37diLd+asw/f+PTntewpV1TXOrQkPfJjQ1k/O8CJassFerwYwx674TFq0MVKBWuoLITEnBzeesWJz0ry9k1iheZf28hzwuwn4c9gD7t2CF6anC4HD/vBW5ABJPzPTCxmEShe33heCgw0n/rv55a9wkOaysH1PlfW41zxLy5A0ce46nHf/JDySIbU6lbdmJ8ZRruojXfDAZ/jBQ5MzbvfW7DXJ2hBU9lRV496354fWgzhk3Hs44q6J+GrVFuv4X0qs7UJJixyFf3+0GBVjx1vnoSgaw8PunIiZKzbjYUdZ/2zH9rXcX2ZwT1Gztu3YU4VT/+9j/OzJacbtw+7TgrXb8PSUYGxA1GQkFz0yBefe92mkfcLIZmGtZt2yZbH0v5Owa8mf9+a4VSHxJ35M2+tffmPt0/Tl3ybndt9ab3uHPvEZLUYj2xo0Uz0vgF17q7FuW2KezXbOzqW4nalvfyAmnclHXZvnp6XSk6/8dmfOBDH1mduxpyr5zPqHsyeaSn3+z2fLctK/YsA0boQAzvznp0kvhVKBhaIcMjfECrBw3XYcfMe7WL9tD/6ape/9ciXFsBAC3+7Yi0PHvYevV8dP3Whj9uot+GJZQljyaxHZyGQFuODBz0gFaqMKfgltZnCfM/7xSdK8fdebNM2F/jDvrqzB30MecIpG2/SiCNv30U+WkvqXLfpl9RdLvqbwsUnLkn7mgf0caPD9+JhF67db03rW1Eg88/ly6+LWlWZeSmm8T5MWb8RHC8K1ZLsrq5Nj9LL/fJGsDUHlsU+X4q/vLrCm/x6vLgyLyFX7tvGJODDbI+pKb5OYf6IFmtssl77wuieC26u/6PYLA1M57t4PMfaFoCX5uudmoqq6Bifc+yHe81x67/tgEX7quaN9uXILDrvzvaQl5v156/H50vTzp15e23O7cfueZArewD7azdNjKYBwbfnrXyYEzpqaVJ2wMPx2bK+KReu3o7K6Bs98vjz0nXLmPz9Nzu2+Br9Ly0bG9vTrYHq/6DFFuyurcfTd7+PTRdHKPJz/wCSMuj1+PEw27K6sdmKNX7V5F/k9bJqPoyRKWLZxByn2ZfXmXTjszom4O0fWCPWZO+mvH2HkbYkyFL6l+LkiqB0Vhu1OZeNJY9vTZjUrpfgiForyzEMfL8E3W3bjra/XYBfRYmFizZbdiuYO+HDBeqzavAv/+iCYES5Tqs0wtocUjx3zt49x9r9065f5QXDtWxw22U5b/m2a+wb1sK6yRKlZeaprJK57bibma6b7het0y5r52LsrMy/SVm3elfXaOO7+cW/ryzNW4YEPE2MzqUmWwMcWk/zz01biN89/ifs/MGc5zIa1W3cnXe7+MXEhBvzuDWzOUPV8x54qXPnfaVi/bQ+27KzEgN+9gZtfCbpHVFbXYPysb5L+5Tb8+23TsAoUj0ufiv8IRX0Jz1yxOXKNi8T8k52lZNH67VjhKZN8gd+WXUmHkl2RGlu4Y08VNu3Yi3lrt+E3zycEpnET5mKCl+76L+/Mx8pvd+HzCO5jQMIC5SeRUS+9zX3ux49PxZVPTktqwr9YtinUKhyoV+Z9lz63pVzraqQMVaz4+PEsHy8wL4CFEHjgw8X4zfNf4n+WRSjVIqmfk2k+K9MsRYvX78CSDTsiFy+dqQjm2b4S9T7Z2F1ZjQG/ewN3vpkoWr1g7bZQixyFQzMkTdiyqxLTlieEB9NrdZM2r66w1I078q73cSHBrdt36ctHPUJVCX3nG5kLgatxfJlwbV2zHTfOGDQJumpbutCr7vMsMX67GGChqIDYXhY6T05ejlkrNwe+k0gtOFRBXNcMqS5FvsQ+8rZ3cOV/zS4gUfpmIo52IKyon6mVyuoanPXPT/GjR4OxFFKmYnVmLN8cuQ/ZsGj9dvzvi5XWawsoi8mQk6PIanur7K6Tlz72ecYXWVzivtevenoG/vh64mWSOkdpTTHtC7ybdqS7YoZeu4h9OnTce8maKS967o8btu+x3oNBN7+J8V9+g7+8Mx/rtyeek8cnBd0jZq7YjCufnEZ6efovxLDFZRiuYm2qayT5mCZSwq29T1JK/GPiwuRC6PR/fIJzM7gX54Jj//wBDv/TxMB3Ybf67a/X4l0vhbRa3+fVmcF4z/MfmITj7/0g8B3VVUZA5MTod9JfP8Ipf0+v92IrOLnSS0FfVS2xZVclzv7XJFzx32lp/fOFQgHa4irdZh/OpxaX0zKRcjW0pf29m+gB4Pdn6YYdiXnUclwgka00bNH61JTlqBg73hpfFjUVvBrftmTDjqyC1f1jP+sF6h9374dZvRNsFtWLH5mCs/75aaR3/l4Hgfg7NBf3D+avT3O3lJI+Z0opsXBd5lgk0tiXwDbi/ddjuPXzysTmnZWocTCfZ+L9EAu53/OXLLHwYTGDxUrBhCIhRHchxEQhxNdCiNlCiKu879sIId4WQizw/m9dqD7mhuivwddmrcYNL36J0/4vWMtDytTL5NpnZ2DphsSCY3zapJB+zA3b9yS3+9f7i3BOlhrYMOIIRdZaCdq73G9fjwmokRLTPGFogqXIoC2deLZkOveUz308BIBqy8z8zpx1GbWC+rigChQuLICqFomSmtwmpAgRfOlFcbdUX0b+p+3EVNASblzD/ulZk2xjFUi/Bm98tQZLI1g5dG56+SuMvucDa6KBTDFa/gI7k6Vo9uqtuOvNeQGBxPYCzxSgDyQWyE5iKkVCwfLYp0tRVV2Dyuoa/PjxqfjRY1OTffE31I/22eJNmL82twuRTOgWIDUgXn1WbQUn/a2EAPZ4AsDXq7emXV/f8klNxLN1VyVpXrEJRVICO71n0rYwXxzhWdi0Yy+Ouvt9/Ob5WcYxVC4EKqtrcMRdE/GLp6anLaz9a+Ff7+emrkizfupxY7bF+dtfr8Vx936Il2eswrptu3H03e/j969mDtA3CYq+J0Sm2F6qw4TNou+/g6tqasipzLP1lAGA7z4YjPO88OEpuCJEIbnA8oz+/tXZuOK/CZfVhz5egtH3fOgsNnXoLW+RttPfqW/OpsdaA4m5/B8TF2L0PR9Ykw0BMdcc2i1VlQR5qCWeVwppKaoCcK2UciCAgwBcKYQYCGAsgHellP0AvOv9XSuhTh43vJCe1QwIugts2L43Gcyps3xTcHGsa0LufGNuMijUJXEWz6FxG4ZmUjUzROj3mfrwbUgthjnfbA1daEZJtw2Ev6DfnL0mWRMijA/mr8euvdVk4eTxT4Ma6Uc+WUJy1/Jx5T43ce46jH0+czag1P6qAGOPCcrnhOune7/pZfM90qF0z4XwrR7HvyaXP/EFjvnz+7Hb/K9X+2uOIQMikBC8bPiPnvqc6dNajQTemRPtJf+fz5Zaf1+/bQ+G3vIW/jEx+yBeAYFHP1mKm1+Zjf98tsxYT8d15q9te6rcukSGNLbIG9N7qqrTsuhlbE6Yx3fCApR59N82fk7WbsoSQJOG5QCARvXLjW5XZM8yKXGf54774vRVgbNQlVlCiKQw9paSECiZbtzbs6pGYvH67fjV/2ZljJG1zWe+y/XcNduw1RNk9KQt+qWcOG8dht7yVmick5/1NM0F0kXGT61R/x1cU0O/D7qLeTbYDlkjJaq0gqUfL9iAa56dAQB45JOlyRg43w3P5tqXC0zjgqpY3ltdgy8898U1W3Zbn8xYiiRtF1+JUcvkIQAFFIqklN9IKad5n7cBmAOgK4DTATzmbfYYgDMK0sEcI6X5JUt9h+gV300DdOW3qQdcSlrMShRMD9k0outa3CA8fz99ElbnP5tQFObacNJfP8JRd7+f9j3FDQqwv/R+8p8v0l1rvB2uf+FLXPjwFFz9zHTS/RciPWPT71/9Oq2f1PSzkdDO8eJHPw+tpWBKN/7KzNUB90HS+SKhda0YO94aV0ChYux4VIwdb/w9SnFUyvvlnxOzj4dKxBSlX6iwR0dKiT+9MTfw3Ntws0gK/wwknsG/vBMtqcyGDPfAty6O/9IutFHYXVmddNPcttucCpxivYqCqtHV0x0DbhccO/dWJxvM9LylhCfz/Fkm6NciW2ve7srqZFp6KaXR7apMCNwxwXfPFZryJWgRVouTqt17RCm/UCaAKUvT47l8y+oKT9l43v2Tku6HNuVimBBQMXY87ng9rGi12QK7u7I62Zafrjws46UpTiVOYeZM+Ba8yUs2orw8fFmpz19UC6up/lqwcfug1ofg9x+aHJrd1U+gEqcsStoxIzzBpmekfj26QoH6mC0i1Hp0QdB7Iy+HdEJRxBQJISoA7AdgMoCOUkrf/2sNgI6GfS4TQkwVQkxdv95tmtlcMnlxYhJ7lJiKeP22PUZNm76WMS1uVEuKa22nEJlTR4e98FVUi5eUElXVNagYOx4ne7Eevl+uHsinF1BLfa9YiizyX5QHNZNJOir6fXjKS9f75uy1JM2qgLDG4vjY3FzSs8/RBgd1sjdlaVq/bU8gZa/NYqreS9+C99SU9JS6krrgczw7U6yh9b1Fwobte0gCyBtfrUmrbbXi25QAnKmFeWu34Z/vL8JPn7DHtaXay9yn3ZXVyeKOP39qerKgo59kRHWF2bY7XuKTKLgsDKjOxWHDR3Uti8IPHpocyYKq801YuvwMmFySWjaun4qNCvld9axL1WCxJCEQgnxfs3W3nb92G96dm5jrbC7BZUIEMuip7pl6im61ho06/lcqz5k+L/mnUVUjA8lYNu3YizZNGwAAKto2MfYvUXsrnfs/TC9aLVITZBpjn5+F4+/9EAvXbUelJ4yEZUWl4nJJ8ObsNeT2JhneD7rw+OpMe0p2IPM5RB2BUS3boceMcFDTa4Fq1VUTn+QiI4/NnZD0/giJFS9WCi4UCSGaAXgewNVSysBKQCZWMKFXXEr5gJRypJRyZPv27fPQUzq2BbTvVkUNiJsaoqny0V82JhcvdW6P+n5atXlXxuJ58y2BiZMXb8QBt78TWtjUxE7fp127jrprnb/A1YMZ1etii7uJgu7zft8Hi3DHhHQNH3XhJCyaQAoS0pjqVtUEWlMlK0d/N8JLgGpYUI9do7mlqNfJds38tPXrFMHav+9h3bjvg/QFhqlPNraGZF/U+XbHXjz4kf14QCImcN3W3Rh52zuh/u46lz/xRVptq0079gSsazZ8RUCm+jtROPru9zHE849/debqZEFHn2WKu4mepta1IAoA37k/WtrzTNhe7H6yFltNkjA+WrAhYzV625Xx3yMZi4ArrazaHD4nqBbqnaEWBEUq8thdWWMca6/MXE2O4zP9pLsoTZwbruSpUrJ7CpiFMX0eMbr+yeAiLzBPKX+UlZnPy5SFsEmDeoajBms72bC9QgREMqD90sc+tyq9xs/K3opqYp1B0VlVnX0amJdnBJWsJne8TFlCfVzPPrlIL53tHCmUNqhJUKKw2qKMoIQW/MOBt0S+KKhQJISoj4RA9F8p5Qve12uFEJ293zsDINhOi4tF62kCDzWmyAR14KvHsVkXwmKSjvzTRJyXRZYoX5Dx4xfCILthaH+b5iZVELJNYNnMG+MmzMX9IQtw6rlQF7gmXrGY97drQuLyjTtRMXY8Xp25OpmqV2fGis2BiXmNRUtNncCl4bMAcNtrqfo2tqfAL7Q7e3WqeKl+dHX/JRt2ZBAEMyMESLW+Zq3cEpqNR2fdtj3JRYQvTCxctw1jn58VaaFNnS58X3kqW3dVQUqJqUs3Ge9tJqtFdU2N0SKQixIVlMxVYZksTfh9XLV5F3bvDbbtF4qcv3Y72UrqMtvSjr1V1kVJkPBBsmtvNeatSbyXwuoRpfYW+NJLIb1lV6Xxni7buDPwnMXJJKZbfS7WsoiGtZ1YIGf2iLAKaZZ7GBCKLA+cSYNve0bLY7zv0+Y6pYktuyqtx5uylFZEOs7zaXo/VNdk72Naryy4LDWdo5qYxnppHc8/+rO93KCcnB4hWUOUsgBhzFy5JbnWkrC/v+Ngu74uY8OKgUJmnxMAHgIwR0p5j/LTKwAu9D5fCODlfPctW9Q5IVu3KwnzgPxQq+1gevbV2gbvzjELRXtCYo0yZRnKNM3XK8/8IlBfRHryA5NfOGAWeErJfzUMyrtzo6XGi65Ze3VWQoC64/U5QYFJu05fKYKATbCnXl71fq0IFBpOWfckaMqBhB90cDvf2vrAh4vJRfTUPplc2YQIFvg1JUrYtrsymakr83GDf9/62hw8/fmK0ALPmfa3Lep2V1aT2/S5+815eGXmapxz3yT0uv71wG97q2oCcRb6sXyqaxCqJADc1ytTsc2vNsWBjl/u4OnPV1gX+NRT8YvaxkUdp49PWkaqjwTY5w6qZl21krq4d6Y2qCKCup2tTk+58put17ZTUm99ueVY+k+Uy1RWRp87KdemvExY3atMruMunkZTG9WSbikybadbRtV3VhyLioTM6ZrgyidT1n/VAhklPfZPPHdknTh685oambW72uTFNIG6NlJIS9GhAH4A4BghxAzv38kAxgE4TgixAMBo7++SYrESyPbarOwC9rbsqjS6T6z6NrhYM1fmTn2uVy6SRdbywXRDsgVVQ26br9TA1bAA7jCoL3LXcUIA8JGlCGEYYbERVD9iEwEhQ6YW+Ku37A60rF+lPyjpX62KtxgvGHUM67JI1OxU+v5xq4pTT2PrrnBXOiEEdhDTyupLBb9a+9tfB90WTbEyNVImiwfarn+cIOpte6qMmsqHP1mCP7wWXqzyPcXdqaqmxiio6/3Va/3kCl3Y1i2oKqqCpUWjcBeoKMOUGpNgupf695RnzrZEFgBemG6O/QwmylAUBzGe9c+0BdXHYRlFY/LRgg0k97lvlMLmid9SP+qJWkxuvoE4jbSDZe5DYrPUF+Vl9jgs3yI5WXFXtwkBuhuynlihxqIA+njBBpz8149ix+aZ3rHVNTKZOS8us1cHvRleV5KpmBK6ZH403UlFekvq3KHHPVOhprgHEmsnF8lxbOiePfUNyTNslKpyupDZ5z6WUgop5VAp5XDv3+tSyo1SymOllP2klKOllNHKeRcBD3xI85+0vcB8/u+9hcZJW5+YbD7UPvXLy3CrYZETZxAvXLfdWivFX/zpfBvI/hM88KwVqUlR9SfXz9dkKfKTWRQCPQ4qDDXRwG3j56S9zCjmaGvdHuXzCmIGMiBzxi8f6qI2uChJfVaL623N4AISxswsakgEXPoMAz5tQWp01zEfJy2+wfBs6XE/938QPnfUSOCThYnFZjGmi33LUldDv87UGiDZvlT13U2lDXRMQvqOPVWBczGVQAASWewo/DE081j6XKcvFFVcLj7STt3mimpYoOp1r3ZHLGeQdhzl85xvthq7lCnhj48eD6M+33pqeaMApr29KfaRTBZxX5n6xbJvk2Nw6cadgTGntqAnMNLHnHouen2nsS/MwtffbI3tZmValO/cW42735ofvo/Xn69WbbFaLVULne6aFmeoS82j7wvH5Uek4bPOrr3VqBg7HkfdNTHttyjKrL6/nYALH5li/N1WyysuR+wTHrdfXSNzks2wkBQ80UJdZq3lpeqjF39T/bD1JAKmKfdzJVlD+2YNzdrJGFPO7qoa7IqR4lszZgT43JBcwqahUbn6mRmR++MMgub36LvfT2ZTAtIzRr1o0ej62KxJ6qLO6gan9Ok+fTFueX/rQfYmTNpE9aW0ccdeen0RIrZR7KooHxDdwhWGLjCsNixS1O3CslWltgv+rS569MKSFJo3tAeO+9iyacZVaupFqKMyV1NQ2OpFUQSL+Wu3B85l6tLsF1evGBQMeneuenpG4O9HP1mCirHj0+YO05i0JcOxHdtmdTe9Lz7TEvNk64JXT5sgTAkZ4hJMtJD6XFUtjYoTk9Ljq1VmpVh5mSCv6tXm1UVuuiUqxRtfBZ8Xhwka01BPQ1XSvJfh3ny9eitO+fvHOOtfnxrHxZCuLZOfL340uPgPplZXBVhbBtPg35OXhLuG5SIhjMq1z80AkBB0VeK8/0LrOXr8/tXZsXxN1PeDfiVMAv19HyxKKutqCywU5QCqS406gZo0NvrgDFqNgr/NWhmuTVQ1Sof1a0eyKNnQTcRxHsCAG5fluOqzuHOv2T0gG3bsqUJNjXSSVcZ4bZVftu+pCqR+zXTU7Xuq8Mzny4MaQ8tFp06yap8qq829SNPqES8T5XJW18g0AW/9tj3Y7w9vpSU7cJFO/tFPliY/Z3u3bd3RFySmY6W5EhK3o6IKgYs3pARk3dpkepT0zI4q1HGmP6em3XQFULZFb8sJ8Yw+QW2vRRCI5LITH7XuTNh1vuXVhLVfndt3V5oLP2/YFqX2VrjlxI+7Ct8n9VlP5GB2d6NdwWaaYP7E5GWGLWlcdEhF4G+T9VgIYL0hYUacJEmzV2+NpXi0zvXa4FizZXfy+u9V4kpsrqMqeu1DE6qlyGZ5UZ9pIYCT/5bIqrl4vTkhTu/2zZKf9Zo6pqtnd/eWViHCJ06yEJ0qy3vUJDC7UK6prN0aL8mLqkC1eYOoLpc2JePamK6EhYaFohxDXbfrWp5UA8E/awwvLCCV7ltHNUc/9PESWocsqObStVt2G4vEhfHs1BX4x8SFwYlAXxgqP6nTxd/eDRaAjOKHa2Lb7koMuvlN3P3WvKRPdy7IRn47/p4P8Jvnvwy8fNK8XIhZk+Kgv1CpL/aAK4rhtbWnqgZasiFMnLsO3+6sxMNagL+Ls1LdkEz3RC/eatpOF9JV9LSyRlc9YwtB9No/Jqi3XhdAVKgFf6nH0s/RtN997wetlXpsSlQaRPGDJ/rABLXTqe91l7FsURN92KzCEjLpbvuqUhRZ57B+7azHU09ZVdioU6xfrDTsN9ucYLoP5PIF2na22nOm/QLJGtLqD6X6rnpfvPP1Wtz08myEEWcu+sVT02O9B9T+ZspSdsGDn+HKJ6dhb1VNIGGGnnXUtz7p7b1myUyoslpRWNjuY6AUg+5yaHRNNEOJJ0vbBzSB54EM5RwofGtxC1wew+15s5Z4ynUsUaZyK2HoNb9MuKwll09YKMox1Do56gJfzQKmv2zUhSYlsxuQnkXHtEDT3dZMlhNVe7Zm6+5AYGgmfv2/WbjrzXmBiU93I1RdQmxalPeUTHqmVNOZ8AW8l2esjhUgSjW5W91QLL9t2VmZdKlSM1DpAuFyLbubCTVeKa6gRp2Xg7WJwreprqlJu8e2IpPZQrEI6Jm+1OukZuWxZQRboFVrN1tn9ec7fDv95WhCv6em627LrEW1mFI1nPqL3LTfPE2wUDWeVKFQRU/taxvvVEE/2EbqPOavpWeaoqAuKPTrovdn384tAABn7d816yQtQLAQqDo+ddnmrdnhAfA6jeqHLzOoyrT0xXSce6V8r91r9a+XlYyFVI8PvQ0besZYE89OTdW3Us9+t+aqHrgyQmClF0OaNp5VHaSUSQvjza8EhT7qtdX7YcI2lZh+sin1TM/phu17yYtwU1IRF7ExcfSRtrlYL4Aep+6i7Z5S46uCWYBpx3WhtC4ELBTlGJs5VUUtDqouznW3JvWvVo0bkNpO04wZtntLy4Rl8r3Vs97FQe2Snr5WjZmwZcpThbM3vsquUN2qzbtIBTszYZqAbFYF29yh3gO1aT2GQ71O6iJC747qRhB3ylLP0aYhp8yJe6pqzAlHciAV1cSY3NUX8QTiONtZqVnXlGMFMi9qffhy1ebQ9ly8X9RjubYmUo8LmJMQ2BYH97wdHrxtg6o00gPqbZeaGmOSLeRU7Uitd/VsZCo2pczarbtJbpu6MKtaVG3XzDR243otZPso6MIYeR5QtluoxWpShQmqlv2fitVU3UdXWOj1w/z1AlU4TrPCURVeMZSBZPd0m9VHhn9esmEH7nh9bsZ9bJjCD6K0F0cp0bRBufG3T7V4Heq5NG9UP/I+NijKRCBRf8+HuvYtNlgoyjHqxD/VkEAACErVtsWByd/bRmPLQ6dOuPphTZPYwC4tSMe1oU4eHxoy1AF2H2d1Qndiqo0xe5hcFnX+8Gp4xj/APsmoiTXsBVVTn/dUp176NkujDfX+LNDqLahWC5v/MuVYyzbuTFtsmbLgUS0T1sKNWc7T1HT26cdJfbHToiE31haJaZHMpcBJvZZ6n742ZFLTA+pVbAsqk0uJLQYmEOsA+kI7KCQon4n7u8bm6qi6Ri1eb56nPl6wwZhOXdVM6wVke7ZrkvxsG5+me0ddNPVo0yTwd7bP8FNTVgS/iNGeLUPoFotV1zbGjSi76Bnn3leLsRNjTtV5VN+MLOwo93SZoXgpEEwSQXUppips9L2/MM7NwS1Na4UplvWZiq4sjpOgIRhrZT7fK47uG/hbvT/Uwt8uRBP1GbadrloeI0rx7GKChaI8YkvXrAoGtgJ16vuFqnjRK2mrg3rTjtTDaRPGVOJqmeNMHnurzPsE3N1cLPJi7KMLbQGNinK+m2yFE4kH1rWCJlRXQj24MxAHQLwf+oJKFQRtL1GqVUa/dWo8hUqswn3aPnEWVOo+egptE9SU6Xu19Kmm/WzFelUes2SBU09drx0TzOrkls2aW4ravvritM0rtsdbdTVS0V3a1Oafm7pS+T7Yui39tRo8rO6VR8NbwNLxu5e+Sn7Wx7paKsEWEK16GaYtkrW6PSrDu7dKHdvS3zjJBdRzOah3m2CfHGcJq6IGKal9sLx8X1IW/9RxYXMlVBVUkxwX1UyPr6Ltpy6SbW5SqmJC95ZQj6Wmt6fGFOnu7qpheKMidOjnlCkuKxN6Jkj1vKhjXbWyphcCTrXRsJ7ZBXgNMZGBVUmI6PO+9flTfrKt3YoZForyCPW9adMmmfxhrcclHlifID83xAplSrtpQs0kQ62fY7MAqRq/uL702b5fbe/TbYFK3ObtqPWB9uvRitirFLqLClXjQ8XuNkOzaprG55qYWXSoZCsg2RjQKWhNDWQtU05Y16bFWVyr8wA1488dE4KuJjOJriPakUlb/fmtoJCrXosde1Lnb1PK2LSppphGvT01BkxdDFTXBFMv22ILVE1o3JiqbFEXodOWb06OmQc/WhK0Xlm6t1WJ0bLNnep80aCeeblgey5McyRZuNFORK8zlC13vxWuhNHRx0zwtxS2WMM/KQofdcztsGSHI88Jyob6pd1tcN+2JZ2woZ6+rnSlol7PJcrawJ40IbWPno5efd7VZCF/1RI0qaEKLt6BawKKEqqVK3Vg/f2v9qlF4/qB33QlGqV99V7Z1pa2epMmt8X046Zwkc23ELBQlE+Ik4dNY0pdaFLbU9Gzozz9ebgG9k1inZp0FMsJUfNtc1MY2Dm18MynO5CK7lseaC8wf5kbN8WR6NiKslEnrTgTld0dzWYpUj9HP67uVhlnitWDpVV3RPXFsdGSjS0O//simMlQ7bs6VNNTckcfyJ9b6uWoC/d5ljgVqlWvJoZQrY/bxcozEwzkp7kN65isaPoCwObqmf3r29z3SkUqoKZGtqEXtFTHTMA1yjIp7jZot3VvBlUAs2bzs42ZLFeeLoxw6qUY0bN14DdqLImK7vlnmn9t8XRqvRrb2Cd7ZigH09/lav0zW2kHk6eDjnpPbQ4mQWWQ+Tc1O5xVKFL20a1rZYGxn/pej8/TXRAp2NxUqYKKClWwaKKFPnzngUm0NtQxqLSop6On9mnV5p2k7dSMoUuJ6d2LDRaK8gjVnZguFGXboyDUl0PrJuYED/oLW+VbYgYtFWrAcVymK24lcdw8KrUJUb0n6gLcZg1yEkSvfra09/HCzPUa4h5XjzlQxyo11astVXScPtmy66jX6dbXLDFfxPuz1ZIhzRTIH2fM6dgys0nLQikO24npulX0tK/VhjmM6r6ro+41R1nU27K26cRZt1N7q7ZtKkwdBWr9JmrMgcoPHgoWy1TjQOprlqLJi1PnYhvHcYQiN1bs8Eb26dgs9PsoVBNd7qYus8QRK/fHLhTR++Vz40tfBv5WC95OX745+dkmOL8wzVxEXFWu2Vx7beNCjVVdqHy2Z59LobvtqbGuVOWSnvnWxJ4YBeptWBVPFgWVuh4yJawBgoqoud+k9mlqKcZte07//NZ80nbqdXJR/qUQsFCUR6gPqlUhl6X2PS6qhtN21JWbzQuvc++bZPwtDibtuw1dU/uLp6ZHPq5avNaWInMBsYo82YvE2oYykdKaIx/XqqlU2pijx8wpv9nqN6jYrGFxoLqDuPDVt7lJmRKk2F5sVH702NTkZ91qpArjh/a116pJYrlk6kiIO/uo6XzVRZPVUqR8ti32VY1ulOnRpFSwBQu3aZZSDuUzpogan2d1cyb2V1VS6JYi1S3JvsgzdIHYh55tm2TeKAM2600cTX96HE34SdqEYHWPuAqBAMoF1d9zqjJM/W3Vt+Yizjalgnr6eibUwHbKpbWVzbC5DwaPmzqwrvCKogTxoQo7VAtvnBp+OtQYJVtowetfppSQajxhfS0jp6rEHty1pbE99b1sLS+i9DdOrF4xwEJRHqHOe7YJstKSztdE66b1M2+UgZXK5GnLFqfXBjHhQpxTF5rvzFlr3E41l+vWjGB7tOOqk4yLWCHqREpdRFDTk7s4bsDHW3NncO2qR90ujv+z9VjU60RcaaoLAD1zk3qtdZ95Cqu08R3HEvXYpKWk7ezuG8TjKpvNUDTYtmNd+vjUwG9OBBLlAO/PS81vt2vlAlSaK1pXas0dW2YyKrYrGy8mzfyb+gzrCypqn0zoRZJV1MQ0ce+v6bz0RZ2eXdOEKszrChCTu1JapjsD9iQj5t9MZSRsRkK1f/r+geLE5iZipeSeZnm+1f7aBBD1sEf3b0/qgw3beagWWUrxV4C+hrAdVy1Sb40vt7VPfPeqIRJUwZz6rFdzSm4mE1TfYJtJW11o2xadqvBkc3dTOTxD1XMKVMHPdfCxrXgidXGubmVLBa5up09u6mJwriXboAq5fAPNYBO7kG2wvVSLj09aZtxOVQbpKXbV82rRKHvBnC7syNDP6e1RBTDSZvY2lM+2VMTqsRYSF2vW4yrtPW7R6Ko894V5IafOTfZrSzpUoAVbens1RksVWoB4MSd6/9Q/VYunbeyri2Q1C5yOOkdc/cwM43bUuDbdXVK1VgdqlJFas6NaRGxZUeNkhrS5Rv9Hue5xnz+Ty2rcBC53vpFKTkItpmxDVY5Y1wYxBrjr92vc9ls2ps376hj+7YvmZ0m9kbbxSMV2Fqf87ePkZ2oyCepVt2XsU5PllFuUzLZnTk0+Qy6S7GDtpv5UyYkWmIxQLUUOEi2ofsMfLaDFkejbxRnS1IxM974TvRijjgutjIkbLYscmwuj+rfNHB1sj2qxoUlFlUSzNfWy2FKYqk1s0zR86rWgZ1Sk9cmuJUt9tgogymebNpY8eogBwi7cXuP4a+8gxgOt2GS2plKXIdSaH9RLYcvoNdWSaEKFqvmmVo2/4cVU3Iat8PNjn5oFq2AfSJvhmmdnavspQpFykk6EeaUN23vJ9fKHao23oQrtao03m6eDDbWN/05eHvjtbcVTgdrfV2auTn7euMMsqFEXqy9MSykObGOYfD0tx6WO1S6tGpO2o8Zoqff0L+8ssGxJw3Yt1Fipz6ju1VQLmuUCqvG3trWBbT2gukuqyYbsrrfxEnKpqAJdHE+HYoCFojxCXVDodT1U1IepXwdzwOj2PTRNlm1yi5OlhWqCjZPxRyeO/24cs3/acdUFlDaXv/5lynWNWlvGRUaq3UrsQxzLWNpvxJfeCmWCfFhbqJMtMbRDkdv+dFHqhWBbTKtNuHDpt2nktuxKjQXb7Qm4r1j6ZEsMoaK24SJ+ScXuOkqbO5wkmiCmvo+RxMuKLZufCrX8QKzCngi+E9QaS7bEHwGLkuV81XnQNre7jm/9QBFc4rb8rOIa9JWl9hQV9Rz1eeUJxbJFHWdqAPyJf/kou84hqAi1xzfS2tPdnwYpRdupJRao7yKb5UTFfRg1rUHqu5zsWubAikJ+5ojbUYutPvyJWSGnDn0X65pCwEJRHqFaUV5VNEg6ag2NfZWU1DprttAWJXGCTG3kMd6YTEBLb/O1VrabucL8En1didm574NF2XQNAPCnN8x1MtQ+fbbIrK1S6zK4WKBQm1DTs+uaoUChWEsbeoE6ChPnmbW9quvoOK0eTwBi/1RscRW2Og8PfLg4+dn2QtSL7bqE6spiQw1uVs9Cvy6O39dkbDWG7DFQqc9k4Yk4alwI3DbUBeUqZR5Q3bOs6bQtqGPVnjKd1l5aMhYD6j2wWXZs93v26tSx4rj36dieW6o2XkVN7mI7jziucHHfAY3rp1JAP/6Z2cJJr2eU2m6klgo9sJ0DRZ4K9RnetZfqVeFWaLMp6wLtWX57bw6tXiT1PUy1FH2y0LwOceHSWGhYKCoxxitZRfSgahVbXv1cYtNOuob6rlAnZmuiBWXKsGk5dhI1IONnmYVbKuopTltOcxOiJn2hVrq2oS6U9GBUau0b+jSaasRmlVGPZbNYUM9RvU6N6pWbt7O0oQYZ5/PZVK/Fwb3bkrazoV539bpUalpl6uLFtfXKFrOjoi/CqAUOVfRzLhRq39UsUer9tgWK67VQgm3TXGCpi3DVLc6G2twrFiXhc1PN8W9qnI6L8IZCFaO84r/TIu9js7w0qm++3yq6wlQ9/y+o7yLlRrZpao5t/tSi8FMhZxMltve7ly3xS4HjkjYj989WKoJ6XKo79EfEMhwuEtaUvkjEQlFecTFggosS83ZUc7RrVL/rXEOdgLbuSk0eeuaqOIwe2JG0HTX7nA1JFCxitW35jboAUCdSPe222oStCG8c7K484Z91JigWP9uzqV4L2+KSen+oGalcY3vpURe1qobzqqdnGLejPpt/cRBbqEIVsvRFnWrBcP2cUbXRVBcdHdU6dJuSLa9Xu6ak/bu2Nsd9qAqWDywWG+rr5j+WxBVxoCY8cGE9p8aauU7PPtMiSHZvE37vvrG8h+euiWeNVtcUaup/PWW6evrquHjra3OGWFsmQhXqXXzra1oGVlu8rAp1fFP752J9Rh3StvGjst5xAfNShYWiPGJLG01FrcruelHrAif1FhQa1TcP0WHdW5HaoPr0U2c0m2ZVxVZUMw627gWFJ9qJfGLRIFGL5tqSJKja+HXEInk2NxJVHrHXtEkd1/YcXP9CKlDe5tqqCk+2lxnV8hSnqKYLbOdI1dTaEleoqLU2urRsZG4vj8ob9fT1DHYqcYUTE88rAfA2qFYUavs2a/dsYoyNKkz8/b2F5u3IsSOO3bUtrxs12Ufc5Aoq1BTDroXqHZaA9RE9wl3SbPOemobZRv+OzY1t2pJuqPNMY6JVynVMEdUVjPqupFr3qf0jJ27IY1HkTx0UdqdmWC5mWCjKIzZNCZXTh3dJfrY90IUy9bsWimyncTzRYvOIJTAwl9SL6cevEijkZrnfgRoaxFt/08uzjb+5iDWzZVRSUbv7hMWPXbVE2V7K6tiPG7yusidGEgsbVI2zCwrl4KUmaenexlx8820Hc6JrXMSfxMF1sgLbYlpN925PtEA7FtUdiIrJAqJDtcbHFThV9OyapQo1tq6hppBUBdpdFo+VOHMkNfvcl6s2k7bbvIs2Llwvk6jP8HRLzSYV2/iOM128P98ch+RCoKkFMhELRfnExYKqe+vUAsPWGjWTCBW65cmxUORiEeo4iJM6GVEX5K2amAPg73k75V5kO43/KMJEPhMt2HiHGAiq8vIMWhwWNRMW1arnAnKK+BKt3wDQX3ovTV+V/Hz68K456k3t4n9TaRYlKm6SC9AWq9RMpdShT12gPTVleeaNkF8lYT6fb9fvWxU9Q+zZ+3cL3c72vqG+i6j3h+oeu3ozzTOBnCGtQIt9a2mQGCovmzDmZiyVvlTEQlGJodag6WbxBX/mc7cvWNUSYcN18hEX7jXUJqiZkcjphonHpfrF5zLFtQ71ZeY6yxg1hfarliQW05ZtTn6m3ntb0hLXUOPzv16dfSa63Yq1oIfFYkPFFvSuohZiVev5lALfOijMGQdb/Y842BaawSK8ljaIY1WPJzRhe2epUN00qeTTTfPvE81uhq6JowCzrX1tcSVxFEzUy164lNw06O54Oe6Igush7aJYOFuKmLzz0EcpV7B9OjQ3btenPS3Ilv4QF592m6yZJ25IfRFTFwCu3WFcWLKGE+OwCuVCZCfVJ1uMgPqCzWetBNeWoqUbaUHANm5/PRV4Hyf1uY4tFqfYKcohrUDNJkXFNszUtYtNeKLOA00b1iNtZ8saqVLpOO6OqnhygesyFzaolnUqVIWfiloOQmfCV98Yf1MZ3KUlaTtqYhbX769XZqzKvBHiXb+4PKkUED5in/ZZt+ci5r041w3RYKGoxCAXESOOzR3EReOcb2iB9w8q9ViKBdfCyfNf0CZI1/NDM+LCo10zc+pTsmBF3i5/rnqq6T+fixzX95Fe2NQttSEINhuK/XXtOj25LaGHKggtsGSGpLo12ep3qXy2eFPmjSIcl4mO7U6pxcd14syDWy2Jc1RsLuQqSzfSrKmu4zZXE7Pq3l+g9U/f9s0KclwdFxl3Cw0LRY7JtaRMbZ+a5UfNOnV4v3bG7d6bS4sPman5IecS6pWmWoCowtOarbQJ0vXETE1r3aKR+QUzj5iOlXotqGuXBQ5M86p534XVg8oeoua3kvjMTV5CWxi6FubLiQvX2kpt0GJG4a/vLjD+piZw2WSxfK8jxgq5vrT5TEZS14grb95hK4RtgCrcukhCpVLXZGoXykkmAQtFtRSqS/b/vnAbe5RPHvt0KWk7qr8ydbFaKKhaGDUVrQ41Noz8UnEwF1Mn9HcVwdyWWcu1QYT6jDz6yVK3B3b9nuP3Zp1ip+UZmbosNUf86Y15xu2ocQauhxY1/TUTnTguXicMomV61SlUvcR8ujAWA6xDcAcLRSWGOslc+9xM43ZxtKKuNdO5hirEuAggjEPTPGY+cw05gQKvtJPYaizF4aMF2deNYFLkM74sX8RVAFDdpqm4fnUUajFdDFCL7uaTJg1orts6LsZFc6LbeF2G3U3dkVEoEkJ0EEKcKYS4UghxiRBilBCChSkDuZYrqHEBejpNE8Gin7TtGBqdW9IyLRUjVGFnk+NCl6VMZ0uR0jh8TcyGyNCgWklLiZ8e2SfWfq4NMa6VI3V5kdemqTkmtFC8OJ0WR6vjYt1QW+pD5RIXCm0XNf1qA0bhRghxtBDiTQDjAZwEoDOAgQBuBPClEOL3QogW2RxcCPGwEGKdEOIr5bs2Qoi3hRALvP/DSzbXUVxbc+qyRi7XlLJffKN6NCvXovXZZ0hzbWzq0Lyh2waJZJvIwJYgwwVqmmymbuNayeV6qttrSRLhukB4sVGbFJC8vMgPLtaFjXPo2dK2CAV9EzaLz8kAfiylPEBKeZmU8kYp5XVSytMADAMwHcBxWR7/UQAnat+NBfCulLIfgHe9v0uGXM8BrudL1aWk1NznCkVvontDKRfpzGvRU8ft1S8vjCE72+cn14/fvW/T0tkypUPcIVPKc31ttyLVprMb/yUtJTeTHU6eiRwOvI079mJLgeq/RcW4epBS/kpKGVouWkpZJaV8SUr5fDYHl1J+CEAPDDkdwGPe58cAnJHNMRg7ajCu7T1pcrdoVL/ueVKS6x6V2Mv7tGFdkp/z2XX3WuvCXPfKLH2Scq9QKa3xSMVFUdq6hmvXXmrqZSYzaumBUqe2C7DFwkYHqbBz7aa4dhsta2+hsbnPXSOE+FHI9z8SQlydwz51lFL66oU1AELTngghLhNCTBVCTF2/vngKCuY8JXcOl062rpuKZbZtWhhXpUJCdYsrZW1sPjmwd1un7X28sDAJCrItfldbhZZc07qEXDNcE3fIuHbVLFR9FqY0cR1/Wdd5l1gyhcmMTc3/PQCPh3z/HwCX5KY7QWRilRA67UspH5BSjpRSjmzfPvtqvqUCr5sKD7EcTUm7z+VToLPVVYpDsaRjPbRvNGEv55aiHLdfKGau2FzoLhSMpz8PdebIyN6q2joamFKgtseFMemUytrVJhTVk1Km2cSllHthL4qcLWuFEJ0BwPu/pETgXN93aiHJOMSxQtVF7Tb1nEst0YLa23ymMa+tab0/Wbgx80YKuRaiS2w4MgQ2x/TTr7QkMig2hnZrWegulARdW5VOtlOei+oepfKetwlFZUKINNe1sO8c8wqAC73PFwJ4OcfHYzxK2LCRV1ZvofnGlrI/ddwUrHFw/YIUrqu35olcj5ZdleZinkzdoopq7i4CqOUl6jq92xdffSOG8SkWD45M2ISiuwCMF0IcKYRo7v07CsBrAO52cXAhxFMAJgHoL4RY6cUwjQNwnBBiAYDR3t8lQylrQOJYfUr4dHNOKQtF+eTRT5cWugvFAQ8XJk9kmxSEKT5KqdhzXfQwqevc9ea8QneBhLFUsJTycSHEegB/ADAYiVf2bAA3SSknuDi4lPICw0/HumifiUYh1/ADOjXH3DXbCteBHFBq2ecKxRfLvnXa3qpvdzltL1/waGHyRacWHOjOFA6e6+oeLjLk5QNrPmUp5QQp5ZFSyrZSynbeZycCUW2lkH6To3q1yWr/GTECll0pfNrmuHBlIWBlWGFYs7U0Un/qsPbULUO6ciyKiW+ILsAMkwt4/NU9ykqkeostJfeNQgjjKlsIcYwQ4pTcdIuJRQmvqWrjenB7jvP+u+br1ey7X0hq4SNQUL7i8Wwk2/TxDMMwUSgrkVhfo/scgC8BvCqE2A1gGoD1ABoB6AdgOIB3APwx1x0sNQq5uC9EXRxXlrHaKBSVGovW7yh0F+o0/Ay4ha8nwzBMcVAqCVNsMUUvA3hZCNEPwKEAOgPYCuAJAJdJKUvTcb8WU4g1wNqte5y0UyrpGhkmV/AzwDAMwzCFw2YpAgBIKRcAWJCHvjBZUsoxCSXcdYZxwu7K0khZyjAMwzC1kRIJfWIolLJcMXnJpkJ3gWEYhmGYOkr3NqVTAJfJDSwUOaYQcT0+bG1hGIZhGIaJDq+hGBaKHPPh/MIVUOPnmWEYhmEYJjosFDEZhSIhxD5CiHeFEF95fw8VQtyY+66VJnurCxcXMDNGnSGGYRiGYZi6TqmV0WDcQ7EUPQjgegCVACClnAXg/Fx2qpQp5WQHDMMwDMMwdZFChj8wxQFFKGoipZyifcfiNMMwDMMwDFMrKI3yokwuoQhFG4QQfeCFrAghzgHwTU57xTAMwzAMwzB5Yhu7z9V5MtYpAnAlgAcADBBCrAKwBMD3ctqrEoatrwzDMAzDMKUFr98Yq1AkhCgHcIWUcrQQoimAMinltvx0rTThqvQMwzAMwzAMU1pYhSIpZbUQ4jDv8478dKm0YU0DwzAMUyiE4PcQwzBMHCjuc9OFEK8AeA5AUjCSUr6Qs16VMDX8MmIYhmEKBAtEDMMw8aAIRY0AbARwjPKdBMBCEcMwDMMwDMMwJU9GoUhKeXE+OlJb4DpFDMMwDMMwDFNaZBSKhBCPAOnZA6SUl+SkRyUOi0QMwzB2ygS7GjMJfnx4Lzz40ZJCdyNvDOnaEl+u2lLobjAMEwLFfe415XMjAGcCWJ2b7tQC+EXPMAxjhQUixqdR/fJCdyGvCK4QyjBFC8V97nn1byHEUwA+zlmPShxOyc0wDMMwNEQdkxLq2vkyTClRFmOffgA6uO5IbYFDihiGYRiGRl0TEWau2FzoLjAMY4ASU7QNQaewNQB+k7MelTivzmLPQoZhGIah8L8vVha6CwzDMABo7nPN89GR2sInCzcWugsMwzAMUxJUVtcUugsMwzAACO5zQoh3Kd8xDMMwDMNE4fwDuhe6CwzDMAAsliIhRCMATQC0E0K0Rsr1twWArnnoG8MwDMMwtZj12/cUugsMwzAA7O5zPwFwNYAuAL5ASijaCuD/ctsthmEYhmFqO5yNjWGYYsHoPiel/KuUsheA66SUvaWUvbx/w6SULBQxDMMwDMMUKb3bNS10F5wxpGvLQneBicGoXm0K3YVIZIwpklL+XQgxWAhxnhDih/6/XHdMCHGiEGKeEGKhEGJsro/HMAzDMEx+mfPNVqftdW3V2Gl7pUxZWe2xwjVuULeK/NYWfnhwz0J3IRKURAs3A/i79+9oAH8CcFouOyWEKAfwDwAnARgI4AIhxMBcHpNhGIZhmPyyZVel0/ZaN63vtL1SpnmjjAmGGSanlJWYeyyleOs5AI4FsEZKeTGAYQBybcccBWChlHKxlHIvgKcBnJ7jYzIMwzAMk0dcp+SOU0B9ePdWTvtQLAzq0qLQXXDGlCWbCt2FAI3r123LVS+ia2ZpiUQ0oWiXlLIGQJUQogWAdQBynUOzK4AVyt8roWW8E0JcJoSYKoSYun79+hx3h8mG2jQxMwzDMO4QRbBsKjFlNpm9VVwDKldIxJC+axE92zYhbVdqzxZFKJoqhGgF4EEkstBNAzApl52iIKV8QEo5Uko5sn379oXuDmMhjuaOoXFARetCd4FhmBxx45h9C92F2DSoR1leMHUNF+Pi6P685is09HVdaUlF1tEpErky75BSbpZS3gfgOAAXem50uWQVgtaobt53TAlSapqCUqJji0aBv284eUCBesIw+aUuWKAb1gEXHdfvh6YNo8fR1NZXVDG6eJ0ypHPWbfRp38xBT5hsaN2EFrtXaus/q1AkpZQAXlf+XiqlnJXzXgGfA+gnhOglhGgA4HwAr+ThuHln3861/8XO5A69xkf75g0L1BOGyS+lFsAbhwbltHPs0rJR5o2KiHNGdEt+dn0Xf3JE78j71FZnhsYNii/Rwun7dc28UQZaNi58Mo1i9IDp37F53o7VumkD0nalNk9T7JjThBAH5LwnClLKKgA/A/AmgDkAnpVSzs5nH/JFaQ2XeBTj5FEocp0htRj8811wWYyFjY1ieIkybimxd20shnZrVegu5ISRPXPn9tuwHs06UoxWFNcUY0ZuF32iPvtN61ga72KMc/Jjj+oTFTyFhiIUHQhgkhBikRBilhDiSyFEzq1FUsrXpZT7SCn7SClvz/XxCkUborRdylAf0wGd8qflKBTljt9Sugm7tiwUOzi2eNWW68LukSlqyS21Ql24F99SCLj3vOHG3w7t2y75Wbd2Z0uPNrQA8OMHdUz1wWkPioc4WvoWDtJ4XzCqh/G3cgf3mzpmqnOokS3GdOfFqIAWALq3aYxTh3YpdFdIUISiEwD0AXAMgFMBnOL9zzigGDXYrovfyWJ8UgtEvTK3wcdXj97HaXs6xTg+VXKpcS5G3pu7rtBdyDnFqByhpp91reSqIB63GDl6gDkYvpEi7B3dv4PT45aXiEY6GxqU094jcXRwLgq+2gTTfBaUza07WfGNs3yutKgCd0tPcVsqq8CMT5aUchkSSQ+O8T7vpOzH0CjGitPUuBTXi5cflFjl4zi4uN2H9Gmb/NxEcw9QJyoXC7T6xJdvoWhFDPasLUxfvrnQXYgNdSE3kJhAwbWFwQZ1cTWwQDGixfcWsaPeuo4tHFuFLb/p82UuyWX2vbP2p8XlxHlGXMSA1FgUofmMMWnfPBVrd81xuVUgxmG/Hq2ctpfP+Yd6Fzs0b1RSbv0Zn1ohxM0AfgPgeu+r+gCeyGWn6hL1i1AoonaJakWwTZAqtbWAnooLIfgnR/Yx/qa+b1yMrFy+v0ZVtDH+5tq46Po0msXIcOWCQmnbbAqQhsTF3/49W5G2s71A1cVgPqfO3VXVpO16ty9dy45r9lSmauSM3tdsDXI9pm1zlmqhUueYaTGVDUfsY7aGXXVsv1htUmhEdKuMM39v2rE3+k4aeyz1kVzo2ejnlbrJVY6LBLt4N1KbOExxN7Vx86kD43eGAUCz+JwJ4DQAOwBASrkaQPH5N5Qo+dR2UqHGvVBfZtQFrm27IrxMsaC+zOKyYO325GfqNbPF7+Tysjesn/3bsc55Zhbh+T754wNJ21E1xLbNvtm8W9mu+CYF167HpYx6v1s1CVqtTXfu/AOyrwtvE6o374y+4LfFjhSqXs55I1PX6dRh5liNQmnon56y3PKrg5giYhvq+8H1fHGMxe2TagGiTucdLNbUnx3dN/k511a4OpGchLDNXi81twQAIQSrwhziYgw3crC4VMnnYkNdkOfT5H6Wg7SgKu2a0VxAXEwqK7/dafxt/JffJD9T4yDaWvqey0n2jOHZ3wNq91zLEtRgbtfkM7vQqF4pS55tThjR02zxU6HeK9tmkxZvJG3nmmJPK9vXQeyE63T+Qnkt2fRs6k9HWiwv+3TMvjaNGqNFvaW2e9+5pVkIDljtHQ+florb8NkWV7pCeT/vqjRbVl1YeKnzoFrLzPUzfNuZg5Ofda+Zpy87KPn5glE0Qf/XJ/aP1Y84p/XIRfESSndSUv8X+ZQYG8oj86wQ4n4ArYQQPwbwDoAHc9utuoOLcTVmiNusHq7dUmzT1wM/HJn8XGOzFLnrDoD8umyouLi2i9btIB2X6t5YqEQYw7q3NP6mvvRsrmqFshSNGZp9AcI45PN81RSqzR24C1K1u9TFSz4FFepzS709B/dum3mjCFx1bN/MG+UZEfhMtRKat+vemqaIsA2L04dFV8TY2mvakKbk+s2JbrNGUkd+oaypUpoX+S4ysFLHkyrou17XqPG2Y08K3l81LfwxAzrChDqfX3FU8BkOCFOWiSXOO2FwV/O7d8JVh5Pa6NC8tGqjUaEkWrgbwP8APA9gHwA3SSn/nuuO1RVcvNhPcbxAI2cc0x7GIZYHzYTqmpDPxTk1zsk1Ll5StgDewEKEeCxb8HFu36nmxqm3x4X1oZRwPWptz7o6N+3TKXstPTWejnxP83pT3R7MdYKQcmJWS1sMTC5dwfJ5T10Pi6YxC6CqC/fLLXGg2VKMbqT7dGyGPu3D5wwXax5yE8qG1H2OivEc2BISubGM2X6L/lawXYt6SocP7GX2ArjwkIrIxy0FqMbVLwF8BOBD7zPjiCKcz3DjmHjBeqrJWMUmgKg1C1o3MWdLUyfSMUPyp6Wn1suJMUfH5vB+5qDLOIkWbIVS43SX6rZnQz0Pm2ZRj1UwUYShOLGgZnyk+rRTX44uYhNcPyNDu0VXwsTFtZa5UFlH1WzVeheu0tL7m9yyrx4dPYGAfk/VhXyZ4bMO+Rm2ueoRL/vFh1YkP193gjlrme25yOUt3rGnirRdHKuMPn/HOY8RPVtjmKHwsOtafTbURFZU4fG2MwZn3kjD1rLtsCbBUce1Epd6B3Rhr62S0TbKffzn9/bPaeIRl1Cyz10KYAqAswCcA+AzIcQlue4YUziaxnSVMe1XVW0RipQHy1qTQ3n+XMdV2IQCataXfFosgoJPsMV9lNgCap9sWq44Wsg/njmEtB3V9e93p5iF9G6taYHtNTbfzBLiIqJ2jpq623Z3DyWOfSr0oUTb8NrjzT741HFBxUVSmZ8fk3KPiVPA0hYHSV2fHDMgFRyuL2r0Nlo0CrdmUd1mmiv72+aRkxVPB9tpUD0JTP2OgtpGo3rx4kDjKMCoiTq27q5MHcfWh+hdSOu3LebURuum4ffBhWJw2cYdmTdCvLTocWoJ2s7JNvap87k9tCB3QmaLxsE1nXo91aNmKmQ7uGvLkqm5Rrn7vwKwn5TyIinlhQBGIJGim3FAMVqKqF3atzNNa22bmKjaBnWz5g2zf+mp79cfHdYr8FvTPNWyqBdXY2aZILsoL1XqZGmbcE0vNhsussqpfW/ruCBmsRAnsN21q4ytvcALMI9uTVQtuC2T47ED3BYEpS7Izx5hFlzUhUOc1N3dLMk9qM+66manz71UZXSceUvfQ/2bWr+KKpjq40LtLrXn1GMNtcRFxkmqc8PJ+xK3zN4V1fTutd0rKlKax2R7RciyeT3YmLx4E2k79fz7daBZZeLMdVYXdMt+Q6zW7tSePR0n9qG6MO7fo3Xg71tOGxS63c2nhn9filBmo40Atil/b/O+Y5xQfFIRdVKo56Cqtmlirq9VJVcn2MuONFt2qMxfu834m/pCzKWbSy4E4ngvMPMS4PqTUi9p19XBnVjNivD5odIig3YtDNdxd9asYKo/voNjUQW6PZaaQCN7tjb+pvKDgytI21HRL3trQ0xQq8Y0Ad51UWR6FsbUiejPjj6yzvQsU3r8Uxz3J30RZsrMNkK5v7r7XtyhXx5woYrXhgmbQBfH0kq1bFDdXuPE76RbELO7aDbLk80V0zbMqoiWf3WMH9THnNxEzSZqO1t9XeJz/MBOxn26aQlC4hQQ7qsIdIMsxa2p48d2T9WfqrXrbPJEqU2puilXcCGAyUKIW7xCrp8BmC+EuEYIcU1uu1f7yWd6SipxagDE3c70cO6jLcDVzaiaRRu7LSlD1f5SH/Y4i3N9n8Fdo1ejTrt8hsWGDdv7pbEygeczHXQ+j1VKvDJztdP2bM+m6uKVz2Bu27NEde2N012bkKr79B9sWGC5SPNswvUdyPTu8d1dTtAWfP201NiUU9G3UWMB1Z9aK1bhrq0aBwSjuDOCMIxj29jv2ormIhjXbcoEVelha7kv1SJi+F5P2hHnWVLPwh5vY/7VdiXUxbottlCNCdaPdMKgVFa4bNdhNuWpLtzv25n6nk+d42mWWlQq5NAHy/mqQ9AmfAbjAmmHLQUoq8tFAF5C6g69DGAJEgVcuYirgVGWrB1FD3GA92xLM+naJjeT1lF/N7h+5qgv2JMGmzVAKi7WjOSsf5ZjLVmf8rWmLrwa1LNojZTPBQvLsZxGy8bURXLtmLU3bs++2nxDRZu40VK93kVdmDjYXPqpVoo4d/viQ4NutKP3TbngDdGCxtXxRK1ZpS4w4gxHF0P4aKXgpL6Q0xfk/p9CBBc9ak22Zg3rkeYZ230zPZvfPbAnvn9gT2P/qJgObXMDVIujxoV6u9RrQz3DoKAX/O0SZRzHSVyh6xzpLn1K2zHfFWoiGVsbway15u0OsVjrVItVYAwSBYa4dLQUYjXhuuYVWWFKfOnripJShpKS+/e2f/noZCmSS//VXEOV+l24lpkCjnXNbJnlJRCHfh1o8rxtUnWNizou789frzZIwl6AMNUIdYKkvjjIGXUsm53jYPFCpXPLwtdlcDH2fzuGtsjpQVR6UKF23fYcUNtQLRFUy7Ie56NqXQdrLivqvDV6X3MdEhX1+XE97VPHhRpvo88jpgQKQphdwVo3rU96X1jddYz7BB/9uBm4zj+gR/KzmpWxhUUJRVWiuHDfzXZe0fuQrbvgoM5By0sXS/IHm0IgzrGvOS6V6e+4gebn6gcH9yRtF+wPbQy6dslOcx2N4YnjuoKI2oMrjgqmi1e7S3VT7NWuDglFQoiRQogXhRDThBCz/H/56FwpQ89Glj+piGqJyKdWnRyUb9BURkF1Twu4heXRAqIuoFQXsWuPM6d91VF9/PU79dMc1sOgL0po263btid+ZzziZPGKi+r/7iK2R12gmnzVbeixHtSEFHGumBvtJK2R0QPNSRKo/WijXAtqgc2GWpaxwKJE2zYQvE+d6x0rdgJtx7irujCjxyOk5icR6LtaOqFMCNKx4+jPEsH6wb/joC7c42Smi++2R9vOtSul2lycto8fFBQybE30Vyw7qgUkELsWoQ/qtrZyGOXE7egHpm0WZyykCZVZuyO6nTxstyfsnR9WlLeuuc/9F8AjAM4GcKryj7GQz2rr1JcFNf9+tj3/7oE9An/bFpCmDFL6Lur1tGWdstGmqTJpW/q0yxJvZIJ6zdRYKbULrZrUdyJIq24F1D7Zxs82JfVra8dZ4MjPiGUzcoC5AyFG7W9zB2l/1UQlPdsGrRQUwb+Ndj+o12J499a0DR1ArU1xppJuun9Hs899HIWNbZ/jLVrmg3qn4obSEi0YngVb76j1eExYa+JE1y1ldEVU3ec6t0hZM1T3SylBmmhsRWOpxLUUmQrlupgT8unKpBZHt8cyhX/W033rQfQmXK5loiQZsM2BrvWYVE8UF1ciThuuE+xQ59GwMXLFUX2xdNyYWO2VApSpdL2U8hUp5RIp5TL/X857VoLs2ptaTJNdRRyMJerz4iKzTWC7kO8W3n4SbteErziTqh5o7+I6qcr4QIa5PGrBbZs5N5ET+2RbbCzbuDP5+ULHGb3sLjVuJ1lViDm4tzkLETVV8qF9zW2onDeyW/LzuSO6BX6rrKpJfu7UIuhCQ7p1McfLPp2Irg5K+3HvRyfFNcgWw6G6uNkW+HGeVdsuQfef4AUdEch0F/xNfS7I/chySNuy8tnujzmGIYNQpHwO0w77UO4Jtd6brQ9x58cjDQLZtt201O+5hjosXvnZoco+5kV84Dfl+2GW9OE2qP07cVAq/lYG5o4UUQTbnyl1vXTixOfZFRapz3HHxX3fHxH4++1fHoEXrjgkvR/EDlMvFaW5X2qFmanzKFVwrk1QVsk3CyH+LYS4QAhxlv8v5z0rQQqVMcv1UakPo+oL3a5ZQnNar7ws7aHvqhVSpLj55CLRgtov1Y2iQ4vcxoqYXG0GdY33klLRr3VQGx3ehyiot2GgJRVoHGx9cv0sqRY0m4bc5o4XvNa0C6pmgjrvgGD809ffbE1+1uPzTF20vwCJgnkeXXbVI3W2ZPRS77dNWI5lYcmB4um9ueuSn9WYBtuoDYyeGJ2qrK4x/lZVY/7NdL8zdsE7aQFzzSrqcxpXk5xtXMX5B3Q3HrvahaVI+dxMy/zlIkY00F4MxVswJpS0e1p/dIu0inoJVU8MKrYzsqWtf3fO2ujHshxMPeede81Cka0NvWB0v47Nk3V+ju6fEszjPAm28iemYdy9Tao/urKvSQPVoyTYI9Xdj4WicC4GMBzAiUi5zp2Swz7VClyYE7s4Dux2bYlQC3vp/vgqenptCnpXqYUubZld1IVmnODWC0b1yLxRCAdUpDIRDuqSEoTGnjggsB09NsH8m6lQoZ6mtRexurRqtm9FzY5HxMUz4tpqb82SleVx9UWTin5Y0/2xulA5vhYBP3YHbdvqXFHnJlvQt4mrRpvj9Y7Z1xy/pC741e7pVeh7E5+lYKwHaZcAtsXz3G/MdddM7lS2gpDDu7dKRRQJPR4q9dlWpJOK6dbrpxvXfc7UO9frvbguTup5UpOC2N3nwq1INiHwJ0ekav/pbXe3ZldUn5Hw7IWZvovD1l2VmTfScFHKI+5YV+O5yZnfDBfrHM3jwKSYUIVKa3FZrT+qwORCcVBqUEbJAVLKkVLKC6WUF3v/Lsl5z2oxFx9akfxsL6JlcTchusLFQT2sza9X3e6o/maf8Y6aJYbymOkTwilDaXn6bZmgqDUqTNxx1pDoO2moi6E4wfWAtjjX2y8LX7zoqC9w27WIc52o++j1G0zYrlIuMwXtr2Sq0iG7Nij9s9Wn0OeBv52/X8a29S7EFarV+SjQvuPsR7rFOHAsw3F14gjmav2hEVrx10P6hLt1jejZOtAPNY5mZEWwjWAQtBl1LMSzeJn3sQkMgXgJpQ9tm5ktAOr52p6xHm2ahAp4UU7PJkyoC744C7Qrjza7YMUVstT4N2tGM/LzqHgwEEsMBPbP8LeP7TqriYds5zSQWGNHSpm8d7kIN4lz51RrS8cWDZ0riRta1mRxDqUL7f77Mk66eCmB//xolPH3doa5gC1F4XwqhBiY857UMtSJQC8ASrVSWINnY41VtwNcnVSaaYUPf+bgZaTGbVA1qzahaJNSk6Vd8+AkcJmiKYtDnBdgLo4V0BKq32uvSvUFoS489MkxjvaTuod9sUXTvsfB5vJDDWB2cSwVveYXJZGDq+Db3xrqkKjzVtxhe6SiLMln8hkV9TLpsVsm9PinYwaYLUqBY1l+M1lsqOQzw5MQwUQLJiraNQ3c14N6J6ziruIPVXfWY4n3QKV7mybJ/qfFtMV4fA7s1YaczZBKnNtKdQVTcZEchvru7t8pJTyp83ymvalzWpSEDWG8eMWhgb/7KVZs/b0UUEBbrns/B5bwwD4O12sSQKvGZiXIx785JvR7ForCOQjADCHEPC8d95eckjszQa2g+TdqGyE/JnGxODK99OOuY+rFtIIk0WOKHCQy2LA9lQJa91cmF041UFVN9K3X/m7RKFwzOEpxuYuCMPyhX5frjk+5FKnD56j+wXEQZ2Q1N5yTjs1V7eA+5kQGcRaX6kKhUwuzxSLOwssF+ks+znNHn1e0vw0Ha2nI2hUFtQaWrdq6y6DitLaJo1jvg+ruqF4jekV6M5ssRXNN6M+LmkDAVk8t7hzuv1cy7a66Nrf3ah3tZ7Gy0o8PnDIs5SHQl1hbzoT+jMVZ8P3qhP4BDb56beK+hYNFg6PfLP00AvOj0p6eujqg9LCsV1ROGBQsZq4+M6qy94JR3VHP0+pecbRSJsLRGlu9d3GWP7pVR00SYSpK//51R8X2S1CFSXIb2nmZzpMy70spjfOAgDmjb1xrailDEYpOBNAPwPFIxRNxSu4M7NiTCtaLqyGlpoakDlvb+DZNhLZ9RMw3wk+OSEySoy3+/DVSWjPsxCHQhONnPTDxa6iH0lMvnzY83C3Qlu0JluticpXRURNNqP3TEw3EURTZ4svUxVIm90FTGl89ixsF9bRsQtvQbq0it61zYK+UQGsTBIL70LLZqcR1n4uDPg9Qi1OrdLe6z9EG2uQlmyIfN857XQhzLEWf9tkXKrQlTaByrDJ/2hOERG97ePfWZLdAahHvAzS3Qx9bTJF6XuSadhZUV26qO14gk5owKyHjrh/1EhYU1EK76dnnaJiSZ2yxxOscYFHWqW5dQgiUlwksHTcGVysxfX4GPKrizEQuDRim69mpZSMnc2xbap1F7Vh+xr14iiHbccwNVhKVvbWJjLOMl367O4BjvM87KfvVRQLaFtXiqj9kWbpR6PvlU5gnp/U2pAUFUi5aLUPMuX86eyiA9IfYJlje+51hpD7l0n1HfUldqQlIw7qlkiuYqo3r52uqrZGJOEUl1YWHSUhzwaWH9YqUgSts8XH5kX1ymj3N5rJKfW4rFMH3pMGdjdupmlpdADRq9ZTvmzYILiyo9bviuHDqQsv1JyeShJjSHcc4AIkVm6Knws71/Ki2b0s7rqLORaoQTT0OENTak92piO+NAypaJ63pmcYV1a3P5L5l2l0gKLhUx1ygqfOFatWK52Eh0oQkH2qMpLV1w8XQlRCmGJBEGzRlomFYYI6SFVNHdzsPJmPJPBD85Ex+chJ1Hz3MwEouhSLDiMxmHvn5MYl6bTefOhDXHW9TeKbQr4dvHdMtnCaFUkBnHbPvNew+l44Q4mYAvwFwvfdVfQBP5LJTtQN1Yoq3iHO9iG/novKzAzcXWxOjvAVClJTc6nXSs6yphLlr+e5SLi91ubay/uVx5uxXrglailLo7oHq5R3cNeUOpKcVVRcOLYguhqbFRqP65bGeBXWfsScNsGxJbY92rLjPrWmxoXPCIEtSEILg94tjg3F7V4+mFUpNc58j7RPcyr82cV+Zp+dQ+C4k9sD78LH16MWjSPOPrpBSrR623YOKiNTnTNk0zxvZHVcc1Qe/yFCAV51zbILGDSdHe3bLykTAfSfb5Zm+f9z1nsntjmoVtmG6j+lW4eiWQZui0eRyp9OttS0TXWb0PqjjpUG9MvI9VsdFBTH7o603qmBhVWLHVMj179QcS8eNwcWH9rImZKDyqxNSglWnluEW+OAYiTfYOftcOGcCOA3ADgCQUq4GkJ1zbx1AHY9+8GnodpaHzPb4xRmrNtN38LjR3dbSJm3lc1q8jrdxmIaxLLnYCvrAHkDUpra11EpQM0/5k6BfgyHOZHeq4u+uL4SbKv7rTRqYXpbmY1Kz/ukvR5M1wyYsBpMzmPtEtUTkGvW8qJp5lYq25peoTRGhuhzmOmkApfkTNSuUOs6aZhmInIlsz97XnPrIwGfz5KbHNFAItJaD2xYnIFodto2J98oW90gVxlSOtsTPVdVINKhXhl+fOCBjLFjYs+Af85ShqTHawmApMrrPIbhojmRJ0BsKOVCmeImTh4SPNb1mjCklu+mW2BQCpnklSmwHdYjHq4WWHdZMgxHOUb0eB1mKcZvYGCOmT0KmWcrioJ/l2fuHu4Pr2/njX4hgTNTRlsy/ybZsYRCW/aprpDHuubZCEYr2ysRolQAghMhdWqhahDrQbPECcSegMgdaAK0nod+m5fY3aaEsT52awhRILSLCzt3/Tm9OrYmkY9J46QxR3Nj8uBf/he/6RXDm/l0zb6ShLl5aNbG4RxDbsAk4w7q3Mv52y6mpZJNxAi1te7h2MYmTgMMWA2GTsdRkJLnOBKaOadWSZ0N9Bi9UaunoqeRdJCtIWooijA/b4p+aIj5OKQK1bauiKXLLfvu07dRjd4+gcY8j+JuOS21pd2V1sA3LjqphXL8Ufzt/P8y/7aTQ3zL1qUmDegFrTtyYIlPfM1mKfn5MP3Rv0ziQBVUIYN/OSqYyIfDwRQeE7q+XovAxK8ksVp4Ii1p1TlSHjouETPqxoraZ5gES88Ubxcr3qxP6p61B0q3l5n74iph6ZWW47Ahz7HBc7jpnaPIZUXHpuha3peoaiR6GxBO1Fcos86wQ4n4ArYQQPwbwDoB/57ZbpY+TRbbVzYfWhCn9N0W7EEoM9zl9EUqZR6PMtdSgTXWheeqwLrjmuH0CZmgfcjFGw/cvzVhF2j9OfARgf5GUBa67uk9wO1MhUSGCGuQRPcMtdLqbHYURFa2DwbiRW3DDEf3MmbpM7ocA/QVuijnQsbWnunraguhNqNrsTG5SceYqyi56Io0mDeolM4DpxxzYhSb4ZSukx1kc2AT5ds0akPuknrO+wLddT0rRaOs9zOGDJkTwmfE/+9+UlYmMgqz+HPjvpmaN6pGzjNlcR33F3v5ajapMi859O7fAR78+xqig6t0+8Z4wWXf0DKc+qpBFxTbG+mheAMG40ugDw0XZCBNNHLgYApkKyga58ui+uPc7wwPfCRGMDbNZe+86Zxg+u/5YNKhXllFBMeOm4zDrluOt2+iCpOkZocYOUY4TVx7u2KJRTmN4ixFKooW7AfwPwPMA+gO4SUr5t2wOKoQ4VwgxWwhRI4QYqf12vRBioZcC/IRsjlNIqNaL4wea4wqoxMuBT8OUnjITlIk17GHz3dm+e2AP8sKbHFiqfC4vE/jFsf1CXUNsqaIpbW/dVUmaSPZW1TifcFo3VV/gNKuRin79OhmEattCp70Wu9bfq9/QqUUjY6IJa59om2VoI9WKngEwsJ1yMP1FSoWeApq6mE516ihiYgP9ml16WK/Q9nJJmOBtqhPURnF7tcYjGi6ZLU32acPixy+9e+2Rxhoefn/izL/6Qtrm0ulDndsyHcslUgbH002nDMQFo3rEcnP0UWMyAzFFlgtti3VpVL8cr/38MPzze/sHvo8jYAsA547ojvMP6I4Xf3qo136iv5R7mKmvpnk6LI7Jd6HS3Sptip3AsQzCE3WfKPjpwId2TXhrhF35KHfDFo9JoV6ZICWzARLvOtN7UKdVkwZGN9GomGR2fYzYsr366OEIgfYs9/SQPm2TiaNs3iW1CUqihTullG9LKX8lpbxOSvm2EOLOLI/7FYCzAHyoHWsggPMBDEIiFfg/hRDFEchAwDjo0rZLfaP7J9v287niqD7Gyu661eQnhqKk6e+D8CfwX98bYeyfvT0zJw7uhIGdW+CnR6Wbops2rIcld5yMK4/ui5tPHYTvHdgDU244lt64BdviwOWygbwIEalYqUy1T9RgZ1vrh/QJunr4jDSkw03rkhCBSde0ELH1oUWj+sk4uj7tzQsFam0oJ86hxFui3jtVG+nLcq/87FC8c80RDnpER5XRdW23eZ/gCedqXWxP2Z9+0OM8JVDrJuYiwbY2TT99Z2S6X/7ScWOw5I6TA7Fw1MvgPwN92jezxvc1aVgey31O17vcde4w434UIVu/1ocr1lBh2c5EFIFBPZf2zRvijrOGhCpNosogAiA//GdncFce3LVlmgLM9u419kkING5QjnFnD03W8erQohEeunAk/qEIXfY44nQGeZbSOO5ztgOo9zsXMfPUJgd7wpB1+EXon+lcWhOztsZxw7UdNxdUEBXSuhIyDFu/B1rWHjVSJrNGNimSmOJcQxkZx4V8l+4AGQEp5Rwp5byQn04H8LSUco+UcgmAhQBGZXOsYsc2SZgWyucf0AN/Oif8Jao3Z/IHTc8CE94HFwUcdVo1aYDXrzrcmDXGn8gb1S/H7WcOQQdiFXogg0XEgTtitvsE9kdCiz3lt8dmTIJxtSIU2YW7cI3f6cOjxzjZyLS4+s4BCTe5wV1bGq+TLW4qw9Ej79HPK/x4mFfk0mQNzCTQDu3WKmMRSXohUtp5qH3Vi+ua26YfK15GwPDvM1m+f33iAEy9cXTSIhyVqNp9/dyoCotMm53j1cq69LDesRIt6P1SrWqPXRL+yoviCPXvC0fiyR8fiPu+PyJonY3aUQKuLVG+26UQIpD9Sr3KN47ZN7BPnDGsxgZly7H7dgwoeaxzdMhPmYY11aqsZzazWxBN39PeL9mQK9sldRy0baYrZZQ2LL2L86zrUD1RyjPU8ctEQCAO+d1PoGCLeQ8UKq4jXnRGoUgI8VMhxJcA+gshZin/lgCYlaP+dAWwQvl7pfddWP8uE0JMFUJMXb9+fY66Ex+bdk79a7ilWOQPD64I/V5CBurY2B7TuuYPql5qXRuUzysRRbvr1ziyvsCUibR7G7NboQtBzcV2/ktGaN+ZxqPNxcnFffMXsTecnFhMXW1IM6y/r4ohdXScRad+HtmOC9OaTB/nvkYYCL9v5WXCankB7JpPcz/s+Mkq1IBrPd4yEGOQoUF/4V6vXJCDvoMB8GZLXhdLv8xtB/9uWK8ch/RphxMHdwrck7jY3iNRvY07ZNBs33rGYPzosF44un97Y/prWzZNMnnU+quEPc+ZuhIl5j649jAfw5RltnMruhKSii7UmU4nW0sMVWlCcTnLFXFiU7NFSpn2DFOar66RebWOFQM2S9GTAE4F8Ir3v/9vhJTy+5kaFkK8I4T4KuTf6S46LqV8QEo5Uko5sn17RwUEHWIb+M0UFzdqNXCbdiHOoG2jWYCoi6azR4RbHAr53AjDZx3bNQy4jGXbH0ETRvVAdHr78bTdeoHQMMqE2dfa1rZOUigi9jVKLac4C/yD+7TF0nFjMgb068/jnw1uTV1b5U4w1YlTmymuhYTcPmF8U+ta6diEprjpYX0tvhr8nqUeNvmJHhuW+hwroVxMa59+rFHE8gY0ZGRXpExDsV2zhvjdKQNRr7zMKKi6eN/EaSNXijV/DJkz5dl729yzNJ40uBM5nlkfF76V1xYTo7enF5A24fc+zYJt/CMecRfwwfgq83bZZoKMgkkhQEXvq/G8LKekjrs6bymSUm6RUi6VUl4gpVym/NtEaVhKOVpKOTjk38uW3VYB6K783c37ruSwPWSmvPQ2DlZy8cfxude59YzBwf2IO952xpBQ4aIUtAlRXRoyYZxjiIJFtoXwQo8d+BzshG0hn9xH67fpvpITN5C2yrzdFUf1Sbq+5XJuTn+RhB/NFo/g+lkYarEmq3S1JCZxfc38OSAtZT9S89vPju6b9puJI4kJJH5MiJHMFJ9nQj2VehkVFqkDmtYuNmEhzVJkOdIPDu6JBvXKMHpfs+tk2H1ItZ1qvVH9cjzxowMx+/eJHEajPLddff/01Mnm1tt7Qmym4qz+o6XXO7Odu2qJdOG6FGhbO0nbNYxK1PeJf01MirtMZ97Gcwf7xbH9QrMBhvcx+1nhtIiWdFeeKybhJJOC4oh92ifjrKNYhn3863lGHjwIdEE4an/VOSyREEXbgNAG5TiZLL+lhrtZwA2vADhfCNFQCNELQD8AUwrcp6zRx2Kc7Ga2F4LpN90NQ6W5pg2ivm7Ky0TS/70YBSFTjYbEb8Q2Yhwrzv7p7cXcMdBGqpFTs8i6lfk49t+TQ0MAAzolfPdNacBN7anj69cnDsATlx5oPeYIYhICG9TkDzaiPhbfOzBDymxiO4O6KK5rxJ10y8tQr5aXf89MHNirDX52dN/Q2MabThmIy4/sE8n10BQ3qAesmxau6jW/WKnRZEOv1j563444aXAia9rxEbKnmRZiE687yrwTYW7y5+8BnVpg/m0nobOhcj1gF8DUtsu99L9+0gE/nfNvtRgd/ZT09NIHhlibKG6RvzqhPx73Yqb8NNq24rANyhUByvH7Rsqgtb6bxS3Zx8UcHSao/PN7++OqY/slM3XqZEof7t+vMiGCiS+aNQw8Q00MtcKCwkqUJBvBczn/gO4kK+hF3jOant02eOywcQakErboqHuHKUcev2QUrvdcqM0KPzO+lfWcEd0tW7nBdM+pY1DN4igh0bG55pZLaK9GSuva89Oxx+Dta46kdahEKIhQJIQ4UwixEsDBAMYLId4EACnlbADPAvgawBsArpRSVptbKl5cu6v0bhfdh7pNswZ5C6TRHxwXheKy5dShwUWZy1TEB1uqaAsBDCH48VOtMlFQm4zjJuPqCiXdQSBwx1lD8fRlB8UuAkd1A8y0kCcdy7sCceow2dqzYStMHJcO2gvQnI41+MNvTkxo+/XscDplZQLXndA/Lf5HykRylrEnDYiV3UvnlKFd8MIVhxj7e/GhFbHbXrt1T+DveuVlSaE4s5tM6nfTelW3zFLdfP1TbGQpdhsFyrSnK+r0U9J/Vy0EdHdegSuP7ptMiX/16H2wdNwYq0BHjZ2Ng0R0y4ULS0eoANyqMX553D7Ga0k9dyGAkUrSnkP6tsPofRMChJTBLKZhNfqyZdzZQ7H4jjFp3+vvtrP274al48YEk+2EnKRJkWaaW/7zo5Ti7Luj7IJLHMtjz7ZNsXTcGBxmqXXnioMsawy9ztmEqw7HpOuDpQP0OcykfAgbcZ9dfyxOGtwJJw7upGyXvmWXVo2dKBKLiYIIRVLKF6WU3aSUDaWUHaWUJyi/3S6l7COl7C+lnFCI/rlAHY8uFgejFc2ILXOcMHyficAL2/tDz2STtk+R+JgGXBWV7y/TXG16RCj4lgndKqEXk8smuPn2Mwdn3shA1vdE0NqIImA2blBuneCBcOupr9XUf/Nf8j5/OH0QAODyI+nVxs1CQuL/bARUalFAukUyeh8oaVrjtm0jbqpbE0LQhEaqEibTQsh3YzIV3ozTZhLrxVaFcdcTawzPhAzXs2/7hJJuePfUPJdXPZiDY8mEVOQU35JpC+SP8sz5LpNqghCfe78zHAM6NU+zntqeQXWh3FGxzgb7RO9gZOVnxqZ19+XE/9RaY8Mj1NJRu+67ZieOmfuFzX9+NArvXWu3sBzStx0uOqQCZ3np5lXvHl/pdYBXamPfzi3SLMmqEFRTE6aENd+7Ti0b4V/fH4EmDerFeq5PHhK/TlmhcVNemAmlaYNy7NhbjUP7ZK9VsPncS8NnILcWm6g1SvKN3gWbJcHW3yYNyrFzb9BgKSExpGtLvDg9EfKmmuoFiMkKDP3tYnGTyTWuLJy+EHRuSP2YMMKu/7izh2JI12VpVjl9yx8eXGHM1BiVlFBUeEvn9N8dh7IyEetZOrxvvDnHP1Lc+I2zMtSLcU2Y9jKs71QN/3Un9EfLxvUjxQzEGSqmexpY0BLafePqwzFj+Wary5J9+IQH+GcK7D+wd1t88Kuj0KNNE0xeTAoztnLS4E5YsmGHdRu1S1U1Eh2aN8S6bXvMO2RAQgZHRYwsfzp3njMEv3xmJhpbarpEsTb1aJOwqumZEgHg5CGdcfKQzgCAnx3TF7/+36xQZcjRAzrgtvFzcNrwLpi6lHKvEtltN++sTO97Ll/roQq5xBdjhnbGKzNX5+zQrWOWCIjL4f1oMZS3nDYo+fl/lx+M9+etC8TkhVn09+nYDPPXbsfPj+mLD+cnMjPb5H9/LppxU1j1HXU7UpcBIBlnWIoUW0xRrcI3DcedSEwLsygLtpqazNscHtEUHHY+1PopucZ2ra2/ef9fdEhFQIMGAB/86mi8/ctgwU4pgQ4twh/8bBPUZBNQnK0wKhB0+/GHmu5Oluko3ds0wdJxYzJaiGy0adoAPz+2X04E7EmLN4Z+7wuFMvl34v8LiXEqiX2j3T/T1q2bNgh1TaBcDmpWy/TGw78+P4Mrik+ceEkb+S4p0KxhPfzyuH0iWfd1AeInR/RGu2bpixWS+1xYQLSFAZ1a4PxRPazPCKU5/ToP757ZOtezbdOMtVCo/Ov7I/DG1faiyOpzJRDM4hqHXOg96pWZx81vvViWjob3RhhUy/V5I7tj6bgxaBKSDa5P+2ZYOm5MmhWll1InUCA47qiL2lypjkwxQy4x9b3w6txwKto1xUWH9gp8F3YO/hi0CeYA8ANPkehbGls1aRBaO7Dw6sH8wkJRjoircbdlCOtlKHZqE5Ioeft1ISAOuiWrGDTtOrYFlnq7fL/rYd5LpH3zhuhnCIANb0vE0x5H3yUnhC2w9K8s7/4MbRu+j9dcbPR4kmQ/vI74z40QAov+eDJuOmWgsS1bgHkuFvUf/upoPPlje9IJaj/Ub08YpLjoauO3EbGuR5SzvTZCGnbj8SJeXlfTUrOGievRsF55mnb++pP3xdQb07WutoykfjHbYwaklEtxu6pXqLddI9P1MMmE6YHxyNvDa4vR0rn73GEZCwkDwWvTpGHmMZ45K6HfcPpXlx7eC4v+eHKkotW+jsFV5r3GSpxaJ8X6dMZ+XYNu+MZ5OvgD1V3W1vtD+yYUZz8+POXuno/lQxEuUZK4jtORUobEj/bHoj+e7NzludThq5EriLEZOiMrCP7zEdqjCjzhGofECeiWJF8TUcRzSijU+0GpHxQnSDe9P25WE43qUx/jzHeMHDRdNCKcW5KWIuVSlWdwYYtyG/34p8D+9N0BJKxwh0R0yTX10fdDn3rjaPz9gv3zOqZ9YYKyeM1EpnS1ro2N1xzXH786oT/O3K9rcj5s3ST+QqZN0waYcsOxuP7kfa13oE/7cMWYiq6wsBZe9eZ43cAXdg1n3HQc3rjKbs3JJb3bB5MN2cbaOSO64YEfjrS2pxe0vPiQhBbeNh5N2eHSG0//SggR2ZLqn6OfzOPQvm0xZmjnSG2onDcy3OKrp1WmzgNHEt3AUu2m41ulKto1TboJ+vXkcumuZxI0i8DznzxOwrbKlMk1tV308VgX4Jgih7h+mPRxnPT3t61tZaJOyPPTVkLKlLXDht7tRvXL8Ytj+yWD5fSEC0/9+EC8MnO1dRFQKC1Mtm4kVAtX26YNYrvqmThz/26YOG89+nfKXGdlYOcW+GbLLgDA704ZiN+++FVSQ3ztcfvg6AHR3BlbNq6PLbsq0xdHRNG3d7umWJwhJgAoHu2c6T77p59N3bzmWpafT8cekxwPPzy4Aje9PDvYl/iHio0QiXvhK2F0a1dabGKO+gAEM4zpZLJ0R33MXJ1H4wbluNKrw9TUszBcrLm2qFyvFeANW3TqacnDxuivThiAy5/4wto3eo0h4Ncn9Ee5EDhTiwULu05RLByuoLg8u2rf15jXt6Y3z+8i8tgBHfDAh4txSJ+ENeW/lx6UVXv1y8vwydhjQrMr2iyZpu9ju+kq/O6UgWjRuD5OHNQJDeqV4eUrD01LVBTrvRHzXhVDPLTr7MVp8XNR9i2Wl3aeYEtRHnA2poijOmqa2rDuXXPcPhjgLc51bUK/js1x7fH9i2LyAOharWwFJiC1gDt9eFdL4CKtLX2z04Z1wdJxY0hFVl+/6nBMv+l4r51ES8O8TFA/P7YfKfvdR78+Gi9deSiAYArt8L4Gv9ffhVGydYW2XxxDKRmncEoEbez/XbBf4G/V1VKUJdKWhtaYMZyzrZ5TXPRD3ey5A+rfJ+9DzDkrzm20zY9+ApMxQzvjoQvNmv8o7kX/+t7+ABI1VVzQsF45lo4bE0h3rHPJYb1w+vCU4NHdUhPHX5y3DXHL3K9HKwDp9aVU0oQi45YJQefWMwYns6Xt0zFhjaG4XacfN3+LJxHTEwMA/vHdxP2/8phgcWGnvXcwn504qBMO7N0WS8eNIRdwptC1VeM0D5JCvsvbNmuIP5w+ODnuh3Vv5cSCMdkQN5qkiNf6xwyIZoHLB1HGSBFf2oywpShHmDKQ6Vpkexs0Au+iGHNJkaxHYxGlQKntPP0HXiKlNR8RkgpY1bD591evNF8sC/xMdG/TJJlK3DSJGdc52kn6PtDnZcg2R/VVz5ZRvdpgyhJaVqyz9u+KF6Ylsgg2aVAPM246Lq24sY0DLckkWkRox+ePZw2JvE9UenmuSANCChzmC8o991Pf+wtZHX8hpWpWM72QTxzcCbecOhDnGlyJcoFAUNj1a/WE0a11E9x59hAcM8DsxtUoQxC1ygmDO+GxScuI/Yz+HObSldbUdjby15ihnTFm6Biv/bBjFgeFeo9IaV4Ax+1Sg3LfTTN/J7V8007r78W8cL9Uia+Ki+5SHDvhV9Y9KS1YKMoRvntK+g8uWpfaX4YsdSHfTb1xdFql5ERf3Q79jTv2Om3PRBSFEsXdTcqEsPD2L49ARWhiC194Sl0vfaIvIyZayDRJHdS7DT6LkO6Wegv/eGbIotvfl+g2oR/M1+yp2vAoRMnIROHHh/e2CkXtmzfEovUJdz/dlSQbN6FbTjUnZKBiswLERruBR+7THhOuOpxc8JY6P0R58R7gFReOotjw8WM7rjy6L/ZW1eD7B/XEs1NXYP7a7aHbXzCqBz5asAEDOjWHECIti9MPDuoZuQ9RiKqJ/84BPay/2+5GOy0+pHvr6PXZ4rwO8rl4cuZ8EXJfnLSdRSOnDeuCV2audmodiopr0eWOs4ai78dLcGjEUgHZ9CNTncVidgvrFJKCnUpoTFEWfUm2G2HbIr60GWH3uSLGFFOkM7BzZlcpn3bNGqb5rmcyVcfRBGaakLLFL+aW6eHzqzy3b94w0sKkX8fmdpcwCaQEpNxAiQcD3GgUkzJRWkxROLqWPds+RLk3Ls73CCVboosJfFi3xDM4vEfrrMdDlGtx3/dHAAB6ZwjAvygkpfi+nVukHct05FyM8V7tEtXhj7DUYAvj+Z8ejKcvS8RWNG1YDzeeMhCN6pdbi7yePKQzlo4bE5p4Zum4Mbj1jPgFk4uN35+WnsyDCjUFdNg+ucCkLDEdMmp5CUqb2TT27rVHZizSqeMviAtlKcrGNdFE++YNMfakAUUV2F/M6/Y4HgY+Yc+uzfqXiYN7t8XxAzuS5xVyMpIihYWiHCEQPrFkGpZxFmhxJxp/kJcJ4VwrFVYvwSVq6lrbs+5fG2qcRqbYBEowaqbfkttkGA2utS229vxgcZN7g/6tKWVopj4XzyvRMcmsdbl71Y6qaJP23YmDO2HurSfizQw1XtpELE7oPweDuybc6/Lp9pKJET3bhBZb9F3KwoLIC43rHtnaM5VuILWbzHZGH8e+8iab45oIi6sCgAGdm6fVYZl764l45KIDIrX//RxbCPu0b5aWNa/YsblaFUscsc7cW09MKz5aihlS7zlvGPp1cDNe1FuVTUr3RvXL8cAPRxo8Z8KP6yqFfCFg97kcYZrMXUwqmbLPUQ+hZo45d2Q3/PXdBdl1rABkOtcOzRvh+pMGJCt/G9uJeFwJYJgnSH53lNnVJRu3MN3N0cTBXkzLmfvRXNfCrtkzlx2Md+aszUmQv0q+pspMwkmuKm4nUrVH3Efra9j+n449JrR6ORAtviQTydg6r0sP/GAkXpy+ChVh9WmKjOtO6I9mDevhDOJzwKQT5+30/QN74NA+bfO6+G/aoB4uOawXrnp6RvK7OM8BJcV5ocj3kl4VIqIIFPXLBSqrcz2z29tvVL888v3XXxFzbz0xb27/Js7avxvO2t8el0tFPb+2EZVidRkWihyiTiSqFitQiTvCTFehBeOaBarsJyRXdViy2cc1/qTwkyP7ZNy2pbfgbNvUvlhOJueSCTeHpePGpG2za2918nOrxqnJ6JwR0SY76l2t8NyQyO2GNFzRrqmT4M5sGNa9FWau2OykrUyWDd+SefKQTk79raWk3zfTwqNpiGDahZCR0AX6ZevSqnEy9TRp/wJqZ5s1rIfrTuhfsOPbcDUfZmOI7NY6N2NICFEQa0hDYkFhG+o80cKzfus1e3LBsG4tMXPlltDfrjiqD9Zv24PvZWHFevLSAzGZmGgmjChFtj/5zTH4dmdl7GPF6YcL9EepUf1yUubXYke9ZuN/cRiueWYmjh/YKb99KEErnQ8LRTkkbGBEGSqmYDvqezGTtvykwZ3w4IeL8aPDelm3izMx5TqmiEKUfp86tDMqq2pw2nB70HfS595yF4Z1b4WKtk0xoFNz3HxqwkVxwe0noTzihXTtiZXLF4yLtk8a3MmZUNSQXNDWDanzl5FvnL61n3GtkBTa+eEXx/bDhu17CtyL3DCcGCvoik4tG2Fg5xa4/uQBGbf1C7+WQqC0izlHLXR7RL92uOe8YRm9ClxwZP8ORqGoVZMGuPc7w7Nq/5C+7XBIxKQGV43uh3lrt+GQPu1w34eLyft1aNEoLU65FIiTdr7UGNSlJd78Zf4LLrP7HJNGwJ8zwviwbapqo8N/8f+ivS3aNWuID399NABg1eZdpH2oHD+oE+6YMNdpm2FI6cbNQAiBswmWHMq1PWFQJzSqX443lDiPsKQNmV7qrieWWBmlIi/w4xfbdCmzRem2X5slG/w4liiWolzz48N74bVZ30Tax/eojR2W4+gmXnPcPm4aKhJ8S/zUG0dn5aIaRxCoX16G1686nNY+oscUFQon877qMiZE1q5LnT1FZikGm+/buQUmXncUAPO1LWSa8MhkDODO3MQfTo+ftKSuonodnTgovxYqF7BQlENcTyCm9nS/6CYNEm4FPQsYBxDVKkJh3FlDIgeM5wrbJO0qzjtX65J47pDBnfT4FhfmcpdDhm5NBS49rDf++Hp2Avxfzt8PD364GPv1aI3Zq7dat/31if0xqqINnpqyAkDuYgd+O2YgfjsmWorw4d1b46JDKnDp4XbrMROPdlnGsuVaVikGt+d84vp8R1a0wQtXHJKMNy1VimUcZPNeySwTZX6YaoM7Xb6RUibnqUP7mmv4FSuF93GqpTSuXx7rBfbL0eaq6D76w6wvWCvaNcW/fzgSd587LHoHHJGLSfX8UT1wvKZ5yPfkTcoq56hPLrS1L195aOSUsBQaNwj68x/ppVXuFqMmSi6IYuEqcyDFdm3VGLecNgjlZSLjsa84qi9GKpnkikknX14mcMtpg2Lfx2JZTNV2cn2di2lM5hJqVsUoRdf379E6Y0bYIkyQGMBsKcpvx/0sp1HcoZt7dd6G92hl3S7fbqz54vYzhuCAitbYp1MRZD0swRcCW4pyxKnDuuCet+dH3s8WsErRmtTzKkePHpiqhn7kPu3RPovg0dINmstdv+1ujm6O66R+TpYTv6kL+lx36eG9cMZ+XTOOM1vCAOp1s72Yu7ZqjFWbd9GTHeRgiBTy2AyTDfv3aI1ZK7egTRYFjPOFiwW6qbSAzmu/OAzTln+b9fFKhWJJvf27UweiX8dmOLp/h8wbe3x2/bH4+3sL8esMSVcuGNUjo4dACXiRpjGseys8d/khBe3DgM6JUg492xSHkjQKLBQ5RJ1HystEeJ2iiJPN45eMwtqtu9O+N2USCgvQfOySUZGOWXLkcf5OxXWZZ0vqLc60XTH59Wc6JSEESfC2CWku3sN9OzRLxsft36MVpi3fnH2jDJlsbuF/Lz0QK7/d6awvTHR+O2ZfnD+qO3qUQAp2F9N+B69kQqYaSz3bNkXPtsWbvts1xSESJTJKRs2K2rRhPYw9KXNSEb3OVSnh149zlb7bJVIm0vTv170VBndtWejuRIaFojwTdbIJq/YuZSJDTRimjHXZMKhrC4z/MlrAtskikIt0p/nM1pVPDVoxiEQUuewXx2Z2+aTg4trefOpA/OG1r3Fw77b458SFDnoVHaos27pJQkvdNMeFjkuFQyNmy6qLtG/eECcP6ZSz9Pn1y8swoFOLnLTtGhfzY4fmifflacPsWUfrGmFlAWob9UKSH5UK3Vo3iVSGI98IIUpSIAJYKMoL6uSdzbqPFM+SAx3P0K6tAEQLmjP5THd0lLrT12QO7dYqcr2Kod2yf1htC1/q4j7TvdKP8cvR+2Dyko2ktintRUKY/9zPkW921Ex3YfRu3wyPXlxYyyj1LK49vj96tGmCkwaXXoYenaYNyrFDqc/F5IbyMoF/fm9E6G8vXXko9lbV5LlHhcPFm65N0waYdcvxaJZnxUSxu6TfefZQHHTHu3jhisK6YWWifnlxX8e6xCWH9sLDnywpdDeyhoUih+hruvDH1fwQjxma+/oIJmxTSzHmnN+/R2u8c80R6BOxaODHvzk65xnsqNN01wzFFHUh4arR/QBkb5WJWC0p6+MVigtG9cDnS/MfB0AV7hrVL8cPDq7IbWfyTLHEIuSC135+GKYXcVxJbQ0cN+FqqLVoRIsrqkuYCpOruChlkA1TbjjWSQFfxg3nHdAND3+ypCjXi1EoXfthERNXezEygxvY6cO7AsiNCxplGGej3frX9/ZPtOFwzdS3Q/PIi7BurZugSRZaQb+WUasm2b9IMwX5llJMkZNjOF5QHzMgEZwbdp2beRmKsk2RXErcevqgnCleimek5o7BXVvWOiGWKQy1QXdATVKRKzq0aISWDt7DjBuK3fpJhS1FOcBfy/7h9MH4/auz0aWVG5exy4/sjYsPrUCjPAcIulibd64l+f5/ObofrjiqT17uQa5kIhfNBgQYR3NhPtPUHtGvHe46ZyhOzUEsQRHJsgF+cHBFzhf1teO1mB/Y5TA+LRrXR4N6pavTrQ3PSW1ZBNs4oFcb6+9CFO98byLn6fxL7HrosFCUQ47Ypz3evfaowHe2AZlpMAkh8i4QBY8fZduozoPuycXDn897UAxzSz4nONe3K1Pc17kjuzs+onfcAt+5KDVVXFHqL8JC8NkNx6Kymi9cHMrLRLLG0CF9Sq9AZKnd9WHdWmLmyi3BL2u/TJTRGjbz5uNRXULP8B1nDcnokRSX2mD9BFgoygm2wZHrcRN3QWaPKcotk284Fjsdakx7t2uKxRt2OGsvKq4mh4N7t8X/vliJAyrcTmJxuqcLuU3V4q2l807IC4UUEN655ghjZsp8EDb2G9cvR+ccZMUsdZpzLEtkzhvZDc9OXVnobmRNqa0f/3PpgVixKZguv9TOIReUWjzaBaN65Kztvu2b4aJDKnDhIRU5O0Y+YKEoz1gtRfnrRiQaeKkrW+TIh9hFRrrXfn5YxiripYZfiLdTy8K5HprGZL+OzfPajzgUSnNVyOe4b4fC3BebMubrP5yQx54wtZk7zx6KcWcNLXQ3sqasxN5VLRrVx6AuiaytR/dvj4nz1uPGMQPz2odc1J07Y3gXHNi79CyNxUhZmcAtpw0qdDeyhoUih1CsNDYtsouUxHGxHfmg3m1w45h9ce6I3LgbuUDNiX/N8fvgZ09OR5cCCRNlRWpHjmJFfPTiAwK1KvJxRqW2UDBRl13JwuIManNGOib3PP/Tg7F1dxWAxFjSh1Ndft4Kwf0/GIltuyvRNs9Jap6+7GDsc+MEp7Gnfzl/P3eNMbUCFopyQNQAxGLP7y6EyLpYYLOGCXerigyVw11wytAuOGVo4YrxHVwLNE9H9U9kbpu/dpvztv93+cGYsWJz2ve1ZelcTFkD80UdPGUmT4zoaQ92L0WaNyrdpVeDemV5F4gA1DpPEKY4KciTKYS4C8CpAPYCWATgYinlZu+36wH8CEA1gF9IKd8sRB/j4AtDHVqYJ4y6qjTt26E5Hr5oJA6qBQKDieaN6mHb7irnFg9XrcXJFtSrXVMc1b89fjl6H0e9AEZWtMHIitwvdHihnn/q6vzGFI5SHHM92yaUgyNyFPReG/Fv85n7dStoP5jaTaFyWr4NYLCUciiA+QCuBwAhxEAA5wMYBOBEAP8UQpRMda4G9crwl+8Mx7M/Odi4Tbh7SeL/Qi7i8vFeOWZAx6xqBBU9Rb4Ij5OEo355GR69eBSGhRSGPKp/+9jthlGvPDfTUSkumkqNP545BO2bN0zGHzJMvihF5YevN2tcwGyypUZZmcDMm4/HnWcPKXRXmFpMQd5gUsq3pJRV3p+fAfBF/9MBPC2l3COlXAJgIYBRhehjXM7Yryu6WGryhC3Q/K+iLi4fufgA/OO7+0fah8k9rhfhrt/52fTv9V8cjt+dkgiwdS1r5KJmUCEoZGxgLrGNm7NHdMPnvx1da+LCXHHZEdm5HTO1E185WhddbbOhZeP6OVOeMQxQHDFFlwB4xvvcFQkhyWel910aQojLAFwGAD165C7NoGvClgxxF6lHe3EfLsjV1HxghuJnTGkxsEsLDOzSIidtN21QjvMP6I5zRpS2e0RNLV3ndGjeEGu37inpopn55oaT98UNJ+9b6G7UakrRElwM3iEMw6STM6FICPEOgE4hP/1WSvmyt81vAVQB+G/U9qWUDwB4AABGjhzJU4tHRdvcJzKgMvfWE1GPNcdpNKhXhr1VNeTtXV1B31WjXllxLmqFEBh3dumn262t3HbGEPz48anYL8SVkmEYOr5QxJYihikuciYUSSlH234XQlwE4BQAx8qUv8kqAGre527ed7WGsPS0pwztggc/WuLE8tMopo9yXJef6b87zqipi9uX2s7rvzgMkxZtzPtxf3XiALRsXB+nDy8eN7VXfnYo5q/dnpO2/ZTiLpNE1GWaehkkS1EzzzDFhF+2gWUihikuCpV97kQAvwZwpJRSLZP8CoAnhRD3AOgCoB+AKQXoYl4Z1r0Vlo4bU9A+xJ2cWzdt4LYjJUzPdk3w1aqtKM+wauzboTmpyKbrF2azhvVwzfH9nbXnF5Vt1jB+Ud+h3VphaLdWjnoUpEG9soI8V728tPP9Ixa4ff6nB+P9eetz0SUnNPOEzM4FLCbMMLWBuHHEDMPklkLFFP0fgIYA3vYsJ59JKS+XUs4WQjwL4Gsk3OqulFJWF6iPDBOJRy8ehenLNweKnrqgWDXzN50yEAf1boNRHDcWwNcC9+kQzZV1RM82RV2TZWi3VvjbBfvh2AHuYhkZpi7iJyRhSxHDFBcFEYqklH0tv90O4PY8dodhnNCuWUMcN7Cj83aL9cXZuEE5Th8emgel5DhuYEdUVdPjvGx0atkIANC/Y24SUhSS02pJhkCm9lCs86MNX8/FMUUMU1wUQ/a5OoWv9X/8klFYtmmnfeM8wnNz8ZHMUFTYbtQJHvzhSGdtjejZGi9deSiGdG3prE2GYWoPfmwxz+0MU1ywUJQnzt6/G56fthLHeK4nR+zTvsA9CsK+zcVHPy/u6NA+bQvcEyYqwzlDG8PkhWJ1L7aRyj5X2H4wDBOEhaI80bt9Ir6gmeN4E1ewpaj4GNilBabeOBptOZlFGu2aNcRVo/sVuhsMwzCRKSuSQkVvXH04lm8sHo8Vhik0xblCZ/IOy0TFSbtmDQvdhaJk6o3WjP8MwzBFSyqmqKDdwIBOLTCgU+2LfWSYuBRnFUcm7/Ro06TQXWAYhmGYWk/nVolkLCcNCatvzzBMoWBLUZ6IWxw1X5SXlaBjNsMwDMOUGB2aN8KXtxxftO70DFNX4Scyz5RiUCjDMAzDMO5o3ih+0WuGYXIDu88xDMMwDMMwDFOnYaGIYRiGYRiGYZg6DQtFDMMwDMMwDMPUaVgoYhiGYRimpPBr/50xvGuBe8IwTG2BEy0wDMPE4O5zh+HD+esL3Q2GqZN0btkYS+44GYKzFzGOOX5gR7z19dpCd4MpACwU5YmTh3TG3W/Nx+lErdagLtEKql14cE/MXLklTtcYhonBOSO64ZwR3QrdDYaps7BAxOSC//vu/tixp6rQ3WAKAAtFeaJ3+2ZYOm4Madv3rj0S7Zs3jNT+708fHKdbDMMwDMMwjEeDemVoUK9BobvBFAAWioqQ3u2bFboLDMMwDMMwDFNn4EQLDMMwDMMwDMPUadhSxCS5+dSBOLBX20J3g2EYhmEYhmHyCgtFTJKLD+1V6C4wDMMwDMMwTN5h9zmGYRiGYRiGYeo0LBQxDMMwDMMwDFOnYaGIYRiGYRiGYZg6DQtFDMMwDMMwDMPUaVgoYhiGYRiGYRimTsNCEcMwDMMwDMMwdRoWihiGYRiGYRiGqdOwUMQwDMMwDMMwTJ1GSCkL3YesEUKsB7Cs0P3waAdgQ6E7wTAGeHwyxQqPTaaY4fHJFCs8NqPRU0rZPuyHWiEUFRNCiKlSypGF7gfDhMHjkylWeGwyxQyPT6ZY4bHpDnafYxiGYRiGYRimTsNCEcMwDMMwDMMwdRoWitzzQKE7wDAWeHwyxQqPTaaY4fHJFCs8Nh3BMUUMwzAMwzAMw9Rp2FLEMAzDMAzDMEydhoUihmEYhmEYhmHqNCwUERBCPCyEWCeE+Er5brgQ4jMhxAwhxFQhxCjveyGE+JsQYqEQYpYQYn9lnwuFEAu8fxcW4lyY2kXEsXmUEGKL9/0MIcRNyj4nCiHmeeN2bCHOhal9GMbnMCHEJCHEl0KIV4UQLZTfrvfG4DwhxAnK9zw+GadEGZtCiAohxC5l7rxP2WeEt/1C790vCnE+TO1CCNFdCDFRCPG1EGK2EOIq7/s2Qoi3vXXk20KI1t73vPZ0gZSS/2X4B+AIAPsD+Er57i0AJ3mfTwbwvvJ5AgAB4CAAk73v2wBY7P3f2vvcutDnxv9K+1/EsXkUgNdC2igHsAhAbwANAMwEMLDQ58b/Sv+fYXx+DuBI7/MlAG71Pg/0xl5DAL28MVnO45P/5eJfxLFZoW6ntTPFe9cL791/UqHPjf+V/j8AnQHs731uDmC+N0f+CcBY7/uxAO70PvPa08E/thQRkFJ+CGCT/jUAX8PZEsBq7/PpAB6XCT4D0EoI0RnACQDellJuklJ+C+BtACfmvvdMbSbi2DQxCsBCKeViKeVeAE8jMY4ZJisM43MfAB96n98GcLb3+XQAT0sp90gplwBYiMTY5PHJOCfi2AzFe7e3kFJ+JhMr0McBnOG4q0wdREr5jZRymvd5G4A5ALoiMfc95m32GFLjjdeeDmChKD5XA7hLCLECwN0Arve+7wpghbLdSu870/cM45qrET42AeBgIcRMIcQEIcQg7zsem0w+mY2UUHMugO7eZ547mUJjGpsA0EsIMV0I8YEQ4nDvu65IjEcfHpuMc4QQFQD2AzAZQEcp5TfeT2sAdPQ+8/zpABaK4vNTAL+UUnYH8EsADxW4PwzjYxqb0wD0lFIOA/B3AC8VpntMHecSAFcIIb5Awi1kb4H7wzA+prH5DYAeUsr9AFwD4Ek1Fo5hcoUQohmA5wFcLaXcqv7mWSe5ro5DWCiKz4UAXvA+P4eEiwcArEJQu9TN+870PcO4JnRsSim3Sim3e59fB1BfCNEOPDaZPCKlnCulPF5KOQLAU0jECwE8dzIFxjQ2PZfOjd7nL7zv90FiHHZTmuCxyThDCFEfCYHov1JK/52+1nOL890313nf8/zpABaK4rMawJHe52MALPA+vwLgh14mkIMAbPFMnW8COF4I0drLFnK89x3DuCZ0bAohOvmZkbyMdGUANiIRXNxPCNFLCNEAwPlIjGOGcY4QooP3fxmAGwH4mbxeAXC+EKKhEKIXgH5IBLHz+GTygmlsCiHaCyHKvc+9kRibi713+1YhxEHe3PpDAC8XpPNMrcIbTw8BmCOlvEf56RUkFJ/w/n9Z+Z7XnllSr9AdKAWEEE8hkbmrnRBiJYCbAfwYwF+FEPUA7AZwmbf560hkAVkIYCeAiwFASrlJCHErEi94APiDlFIP8mSYSEQcm+cA+KkQogrALgDne+b3KiHEz5CYKMsBPCylnJ3fM2FqI4bx2UwIcaW3yQsAHgEAKeVsIcSzAL4GUAXgSilltdcOj0/GKVHGJhKZ6v4ghKgEUAPgcuX9fQWARwE0RiL714S8nABT2zkUwA8AfCmEmOF9dwOAcQCeFUL8CMAyAOd5v/Ha0wEisSZiGIZhGIZhGIapm7D7HMMwDMMwDMMwdRoWihiGYRiGYRiGqdOwUMQwDMMwDMMwTJ2GhSKGYRiGYRiGYeo0LBQxDMMwDMMwDFOnYaGIYRiGYRiGYZg6DQtFDMMwTJ3GL8zJMAzD1F1YKGIYhmFKBiHEH4QQVyt/3y6EuEoI8SshxOdCiFlCiN8rv78khPhCCDFbCHGZ8v12IcSfhRAzARyc37NgGIZhig0WihiGYZhS4mEAPwQAIUQZgPMBrAHQD8AoAMMBjBBCHOFtf4mUcgSAkQB+IYRo633fFMBkKeUwKeXHeew/wzAMU4TUK3QHGIZhGIaKlHKpEGKjEGI/AB0BTAdwAIDjvc8A0AwJIelDJAShM73vu3vfbwRQDeD5fPadYRiGKV5YKGIYhmFKjX8DuAhAJyQsR8cCuENKeb+6kRDiKACjARwspdwphHgfQCPv591Syuo89ZdhGIYpcth9jmEYhik1XgRwIhIWoje9f5cIIZoBgBCiqxCiA4CWAL71BKIBAA4qVIcZhmGY4oYtRQzDMExJIaXcK4SYCGCzZ+15SwixL4BJQggA2A7g+wDeAHC5EGIOgHkAPitUnxmGYZjiRkgpC90HhmEYhiHjJViYBuBcKeWCQveHYRiGKX3YfY5hGIYpGYQQAwEsBPAuC0QMwzCMK9hSxDAMwzAMwzBMnYYtRQzDMAzDMAzD1GlYKGIYhmEYhmEYpk7DQhHDMAzDMAzDMHUaFooYhmEYhmEYhqnTsFDEMAzDMAzDMEyd5v8BgT8yOH4j7u4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(14,4))\n",
    "ax.plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
    "ax.axis('tight')\n",
    "ax.set_title('tempeatures in Stockholm')\n",
    "ax.set_xlabel('year')\n",
    "ax.set_ylabel('temperature (C)');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用`numpy.savetxt`我们可以将一个Numpy数组以CSV格式存入:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.14040248, 0.96924573, 0.53434945],\n",
       "       [0.77573698, 0.21286524, 0.68518057],\n",
       "       [0.32862765, 0.70297393, 0.39513101]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.random.rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(\"random-matrix.csv\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.404024772095778806e-01 9.692457261060815066e-01 5.343494544483793351e-01\r\n",
      "7.757369846310477879e-01 2.128652371287943490e-01 6.851805738917894351e-01\r\n",
      "3.286276500132384593e-01 7.029739262669426614e-01 3.951310081778761640e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.14040 0.96925 0.53435\r\n",
      "0.77574 0.21287 0.68518\r\n",
      "0.32863 0.70297 0.39513\r\n"
     ]
    }
   ],
   "source": [
    "np.savetxt(\"random-matrix.csv\", M, fmt='%.5f') # fmt 确定格式\n",
    "\n",
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 numpy 的本地文件格式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当存储和读取numpy数组时非常有用。利用函数`numpy.save`和`numpy.load`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random-matrix.npy: data\r\n"
     ]
    }
   ],
   "source": [
    "np.save(\"random-matrix.npy\", M)\n",
    "\n",
    "!file random-matrix.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.14040248, 0.96924573, 0.53434945],\n",
       "       [0.77573698, 0.21286524, 0.68518057],\n",
       "       [0.32862765, 0.70297393, 0.39513101]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.load(\"random-matrix.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 更多Numpy数组的性质"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4], [5, 6]])\n",
    "\n",
    "print(M.dtype)\n",
    "print(M.itemsize) # 每个元素的字节数\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.nbytes # 字节数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.ndim # 维度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 操作数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 索引"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以用方括号和下标索引元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.array([1, 2, 3, 4, 5])\n",
    "# v 是一个向量，仅仅只有一维，取一个索引\n",
    "v[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n",
      "[3 4]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# M 是一个矩阵或者是一个二维的数组，取两个索引 \n",
    "print(M[1,1])\n",
    "print(M[1][1])\n",
    "print(M[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果我们省略了一个多维数组的索引，它将会返回整行（或者，总的来说，一个 N-1 维的数组）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "相同的事情可以利用`:`而不是索引来实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # 行 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 6])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,1] # 列 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以用索引赋新的值给数组中的元素:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[0,0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 对行和列也同样有用\n",
    "M[1,:] = 0\n",
    "M[:,1] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.96924573, -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.32862765,  0.70297393, -1.        ]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 切片索引"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切片索引是语法`M[lower:upper:step]`的技术名称，用于提取数组的一部分："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([1,2,3,4,5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切片索引是*可变的*: 如果它们被分配了一个新值，那么从其中提取切片的原始数组将被修改：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2,-3] # auto convert type\n",
    "A[1:3] = np.array([-2, -3])  \n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以省略`M[lower:upper:step]`中任意的三个值\n",
    "We can omit any of the three parameters in `M[lower:upper:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # lower, upper, step 都取默认值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::2] # step is 2, lower and upper 代表数组的开始和结束"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # 前3个元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # 从索引3开始的元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "负索引计数从数组的结束(正索引从开始):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # 数组中最后一个元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-3:] # 最后三个元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "索引切片的工作方式与多维数组完全相同:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 原始数组中的一个块\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 步长\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3 花式索引"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fancy索引是一个名称时，一个数组或列表被使用在一个索引:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]]\n",
      "[[ 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]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "row_indices = [1, 2, 3]\n",
    "print(A[row_indices])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 21, 34])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col_indices = [1, 1, -1] # 索引-1 代表最后一个元素\n",
    "A[row_indices, col_indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们也可以使用索引掩码:如果索引掩码是一个数据类型`bool`的Numpy数组，那么一个元素被选择(True)或不(False)取决于索引掩码在每个元素位置的值:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = array([n for n in range(5)])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_mask = array([True, False, True, False, False])\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 相同的事情\n",
    "row_mask = array([1,0,1,0,0], dtype=bool)\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个特性对于有条件地从数组中选择元素非常有用，例如使用比较运算符:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. ,\n",
       "       6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(0, 10, 0.5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "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])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = (5 < x) * (x < 7.5)\n",
    "\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 6. , 6.5, 7. ])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.5, 4. , 4.5, 5. , 5.5])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[(3<x) * (x<6)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 用于从数组中提取数据和创建数组的函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1 where"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "索引掩码可以使用`where`函数转换为位置索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14]),)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(0, 10, 0.5)\n",
    "mask = (5 < x) * (x < 7.5)\n",
    "\n",
    "indices = np.where(mask)\n",
    "\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 6. , 6.5, 7. ])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[indices] # 这个索引等同于花式索引x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2 diag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用diag函数，我们还可以提取一个数组的对角线和亚对角线:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.3 take"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`take` 函数和上面描述的花式索引类似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 = np.arange(-3,3)\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 3, 5]\n",
    "v2[row_indices] # 花式索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2.take(row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是`take`也作用在列表和其他的物体上："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.take([-3, -2, -1,  0,  1,  2], row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.4 choose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过从几个数组中选择元素来构造一个数组:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -2,  5, -2])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "which = [1, 0, 1, 0]\n",
    "choices = [[-2,-2,-2,-2], [5,5,5,5]]\n",
    "\n",
    "np.choose(which, choices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. 线性代数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "向量化代码是使用Python/Numpy编写高效数值计算的关键。这意味着尽可能多的程序应该用矩阵和向量运算来表示，比如矩阵-矩阵乘法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1 Scalar-array 操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以使用常用的算术运算符来对标量数组进行乘、加、减和除运算。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "v1 = np.arange(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  2,  4,  6,  8],\n",
       "        [20, 22, 24, 26, 28],\n",
       "        [40, 42, 44, 46, 48],\n",
       "        [60, 62, 64, 66, 68],\n",
       "        [80, 82, 84, 86, 88]]),\n",
       " 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": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A * 2, A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2 数组间的元素操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当我们对数组进行加法、减法、乘法和除法时，默认的行为是**element-wise**操作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.01114895, 0.05665904, 0.29848178],\n",
       "       [0.05093977, 0.00040534, 0.14069349]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.rand(2, 3)\n",
    "\n",
    "A * A # element-wise 乘法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果我们用兼容的形状进行数组的乘法，我们会得到每一行的对位相乘结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3), (5,))"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (2,3) (5,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-47-1af134c5c5d0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mA\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mv1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,3) (5,) "
     ]
    }
   ],
   "source": [
    "A * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.4 矩阵代数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "那么矩阵的乘法呢?有两种方法。我们可以使用点函数，它对两个参数应用矩阵-矩阵、矩阵-向量或内向量乘法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.903065  , 1.67919746, 2.3622027 , 1.88412044, 1.11105008],\n",
       "       [1.41054459, 1.8120306 , 1.88727633, 1.43014072, 0.86699677],\n",
       "       [1.66542157, 1.50549264, 1.92165524, 1.68084913, 0.96953227],\n",
       "       [2.60415277, 2.45432125, 3.10136235, 2.57384453, 1.3456306 ],\n",
       "       [1.2318307 , 1.12068957, 1.38086198, 1.18571816, 0.5442449 ]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.rand(5, 5)\n",
    "v = np.random.rand(5, 1)\n",
    "\n",
    "np.dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.14498999, 4.21899366, 6.02247961, 7.06795814, 2.91510261])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外，我们可以将数组对象投到`matrix`类型上。这将改变标准算术运算符`+, -, *` 的行为，以使用矩阵代数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = np.matrix(A)\n",
    "v = np.matrix(v1).T # make it a column vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.72376121, 1.02741179, 1.84320475, 1.4644025 , 0.93766737],\n",
       "        [0.93371216, 1.36026092, 1.81889819, 1.83440464, 1.04760436],\n",
       "        [1.09260054, 1.80363181, 2.27237106, 2.28907943, 1.42251772],\n",
       "        [0.53394728, 1.08528537, 1.22967423, 1.23649788, 0.90293134],\n",
       "        [0.71121961, 1.11261141, 1.74864104, 1.46510406, 0.95440664]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[5.346923  ],\n",
       "        [6.32008278],\n",
       "        [7.66667311],\n",
       "        [3.19229347],\n",
       "        [4.84861051]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 內积\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[5.346923  ],\n",
       "        [7.32008278],\n",
       "        [9.66667311],\n",
       "        [6.19229347],\n",
       "        [8.84861051]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 对于矩阵对象，适用标准的矩阵代数\n",
    "v + M*v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果我们尝试用不相配的矩阵形状加，减或者乘我们会得到错误："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = np.matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5, 1))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(M), np.shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[5.346923  ],\n",
       "        [6.32008278],\n",
       "        [7.66667311],\n",
       "        [3.19229347],\n",
       "        [4.84861051]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样了解相关的函数：`inner`, `outer`, `cross`, `kron`, `tensordot`。例如用`help(kron)`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.5 数组/矩阵转换"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样我们也用`.T`对矩阵目标`v`进行转置。我们也可以利用`transpose`函数去实现同样的事情。\n",
    "\n",
    "变换矩阵对象的其他数学函数有:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.45130455 0.64330743 0.28059702 0.37347175]\n",
      " [0.88485087 0.9022088  0.6700072  0.10678579]\n",
      " [0.98276964 0.05115262 0.29053376 0.40809875]]\n",
      "[[0.45130455 0.88485087 0.98276964]\n",
      " [0.64330743 0.9022088  0.05115262]\n",
      " [0.28059702 0.6700072  0.29053376]\n",
      " [0.37347175 0.10678579 0.40809875]]\n"
     ]
    }
   ],
   "source": [
    "A = np.random.rand(3,4)\n",
    "print(A)\n",
    "print(A.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.+1.j, 0.+2.j],\n",
       "        [0.+3.j, 0.+4.j]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = np.matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.-1.j, 0.-2.j],\n",
       "        [0.-3.j, 0.-4.j]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "厄米共轭:转置+共轭"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.-1.j, 0.-3.j],\n",
       "        [0.-2.j, 0.-4.j]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以将复数数组的实部和虚部提取出来并用`real`和`imag`来表示:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0., 0.],\n",
       "        [0., 0.]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.real(C) # same as: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 2.],\n",
       "        [3., 4.]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.imag(C) # same as: C.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者说复数和绝对值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.78539816, 1.10714872],\n",
       "        [1.24904577, 1.32581766]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.angle(C+1) # heads up MATLAB Users, angle is used instead of arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 2.],\n",
       "        [3., 4.]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.6 矩阵计算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 求逆"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.+2.j , 0.-1.j ],\n",
       "        [0.-1.5j, 0.+0.5j]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.inv(C) # equivalent to C.I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "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": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.I * C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 行列式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0000000000000004+0j)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.49999999999999967+0j)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(C.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.7 数据处理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通常将数据集存储在Numpy数组中是非常有用的。Numpy提供了许多函数用于计算数组中数据集的统计。\n",
    "\n",
    "例如，让我们从上面使用的斯德哥尔摩温度数据集计算一些属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "data = np.genfromtxt('stockholm_td_adj.dat')\n",
    "\n",
    "# 提醒一下，温度数据集存储在数据变量中:\n",
    "np.shape(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(77431, 7)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6.197109684751585"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 温度数据在第三列中\n",
    "print(data.shape)\n",
    "np.mean(data[:,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.536617668205844"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.rand(4, 3)\n",
    "np.mean(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在过去的200年里，斯德哥尔摩每天的平均气温大约是6.2 C。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 标准差和方差"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.282271621340573, 68.59602320966341)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(data[:,3]), np.var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 最小值和最大值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.8"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 最低日平均温度\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.3"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 最高日平均温度\n",
    "data[:,3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将所有的元素相加\n",
    "np.sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 全元素积分\n",
    "np.prod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 累计求和\n",
    "np.cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 累计成绩\n",
    "np.cumprod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5460218417057932"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算对角线元素的和，和diag(A).sum()一样\n",
    "np.trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.8 数组子集的计算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以使用索引、花式索引和从数组中提取数据的其他方法(如上所述)来计算数组中的数据子集。\n",
    "\n",
    "例如，让我们回到温度数据集:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1800  1  1    -6.1    -6.1    -6.1 1\r\n",
      "1800  1  2   -15.4   -15.4   -15.4 1\r\n",
      "1800  1  3   -15.0   -15.0   -15.0 1\r\n"
     ]
    }
   ],
   "source": [
    "!head -n 3 stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数据集的格式是：年，月，日，日平均气温，低，高，位置。\n",
    "\n",
    "如果我们对某个特定月份的平均温度感兴趣，比如二月，然后我们可以创建一个索引掩码，使用它来选择当月的数据:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(data[:,1]) # 列的值从1到12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False ... False False False]\n"
     ]
    }
   ],
   "source": [
    "mask_feb = data[:,1] == 2\n",
    "print(mask_feb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3.212109570736596\n",
      "5.090390768766271\n"
     ]
    }
   ],
   "source": [
    "# 温度数据实在第三行\n",
    "print(np.mean(data[mask_feb,3]))\n",
    "print(np.std(data[mask_feb,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有了这些工具，我们就有了非常强大的数据处理能力。例如，提取每年每个月的平均气温只需要几行代码:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "months = np.arange(1,13)\n",
    "monthly_mean = [np.mean(data[data[:,1] == month, 3]) for month in months]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.bar(months, monthly_mean)\n",
    "ax.set_xlabel(\"Month\")\n",
    "ax.set_ylabel(\"Monthly avg. temp.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.9 高维数据的计算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当例如`min`, `max`等函数应用在高维数组上时，有时将计算应用于整个数组是有用的，而且很多时候有时只基于行或列。用`axis`参数我们可以决定这个函数应该怎样表现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.46711096, 0.38705469, 0.62367441],\n",
       "       [0.50990001, 0.88175455, 0.04836426],\n",
       "       [0.31805034, 0.91664942, 0.47970972],\n",
       "       [0.85967069, 0.14985438, 0.17380319]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "m = np.random.rand(4,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.916649423466619"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# global max\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.85967069, 0.91664942, 0.62367441])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each column\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.62367441, 0.88175455, 0.91664942, 0.85967069])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each row\n",
    "m.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "许多其他的在`array` 和`matrix`类中的函数和方法接受同样（可选的）的关键字参数`axis`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. 阵列的重塑、调整大小和堆叠"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy数组的形状可以被确定而无需复制底层数据，这使得即使对于大型数组也能有较快的操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.20200219 0.38766948 0.49383531]\n",
      " [0.88519418 0.96898662 0.39487907]\n",
      " [0.09463889 0.99524018 0.86314414]\n",
      " [0.73508854 0.14591709 0.73610788]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "A = np.random.rand(4, 3)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 3\n"
     ]
    }
   ],
   "source": [
    "n, m = A.shape\n",
    "print(n, m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.20200219, 0.38766948, 0.49383531, 0.88519418, 0.96898662,\n",
       "        0.39487907, 0.09463889, 0.99524018, 0.86314414, 0.73508854,\n",
       "        0.14591709, 0.73610788]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1,n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.20200219]\n",
      " [0.38766948]\n",
      " [0.49383531]\n",
      " [0.88519418]\n",
      " [0.96898662]\n",
      " [0.39487907]\n",
      " [0.09463889]\n",
      " [0.99524018]\n",
      " [0.86314414]\n",
      " [0.73508854]\n",
      " [0.14591709]\n",
      " [0.73610788]]\n",
      "(12, 1)\n"
     ]
    }
   ],
   "source": [
    "B2 = A.reshape((n*m, 1))\n",
    "print(B2)\n",
    "print(B2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5.        , 5.        , 5.        , 5.        , 5.        ,\n",
       "        0.39487907, 0.09463889, 0.99524018, 0.86314414, 0.73508854,\n",
       "        0.14591709, 0.73610788]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modify the array\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5.        , 5.        , 5.        ],\n",
       "       [5.        , 5.        , 0.39487907],\n",
       "       [0.09463889, 0.99524018, 0.86314414],\n",
       "       [0.73508854, 0.14591709, 0.73610788]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # and the original variable is also changed. B is only a different view of the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the function `flatten` to make a higher-dimensional array into a vector. But this function create a copy of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.        , 5.        , 5.        , 5.        , 5.        ,\n",
       "       0.39487907, 0.09463889, 0.99524018, 0.86314414, 0.73508854,\n",
       "       0.14591709, 0.73610788])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12,)\n"
     ]
    }
   ],
   "source": [
    "print(B.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.77426238 0.40929437 0.81432176 0.59972899 0.09676193 0.4449954\n",
      " 0.01480282 0.26308856 0.58481209 0.74216626 0.22289527 0.46716741\n",
      " 0.33195174 0.52399378 0.88372986 0.60158331 0.58945001 0.31668276\n",
      " 0.11818297 0.27049194 0.11884623 0.29952595 0.32792733 0.43436396\n",
      " 0.646646   0.05237262 0.93389673 0.34454685 0.93967772 0.75029801\n",
      " 0.55267409 0.30308383 0.13671956 0.87033557 0.21616756 0.82525033\n",
      " 0.63810353 0.71845323 0.85226858 0.01932045 0.18269591 0.62072905\n",
      " 0.71238228 0.20326271 0.35548277 0.07583335 0.52520661 0.66373958\n",
      " 0.50652788 0.97000506 0.36231248 0.76321265 0.87553314 0.39389339\n",
      " 0.13004269 0.23257985 0.5075587  0.24471816 0.97082036 0.5918958 ]\n"
     ]
    }
   ],
   "source": [
    "T = np.random.rand(3, 4, 5)\n",
    "T2 = T.flatten()\n",
    "print(T2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10.        , 10.        , 10.        , 10.        , 10.        ,\n",
       "        0.39487907,  0.09463889,  0.99524018,  0.86314414,  0.73508854,\n",
       "        0.14591709,  0.73610788])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5.        , 5.        , 5.        ],\n",
       "       [5.        , 5.        , 0.39487907],\n",
       "       [0.09463889, 0.99524018, 0.86314414],\n",
       "       [0.73508854, 0.14591709, 0.73610788]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # 现在A并没有改变，因为B的数值是A的复制，并不指向同样的值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. 添加、删除维度：newaxis、squeeze"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当矩阵乘法的时候，需要两个矩阵的对应的纬度保持一致才可以正确执行，有了`newaxis`，我们可以在数组中插入新的维度，例如将一个向量转换为列或行矩阵："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = np.array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "print(np.shape(v))\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 1)\n"
     ]
    }
   ],
   "source": [
    "v2 = v.reshape(3, 1)\n",
    "print(v2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n",
      "(3, 1)\n"
     ]
    }
   ],
   "source": [
    "# 做一个向量v的列矩阵\n",
    "v2 = v[:, np.newaxis]\n",
    "print(v.shape)\n",
    "print(v2.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 列矩阵\n",
    "v[:,np.newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 行矩阵\n",
    "v[np.newaxis,:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以通过`np.expand_dims`来实现类似的操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 1)\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1,2,3])\n",
    "v3 = np.expand_dims(v, 1)\n",
    "print(v3.shape)\n",
    "print(v3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在某些情况，需要将纬度为1的那个纬度删除掉，可以使用`np.squeeze`实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "[[[1 2 3]\n",
      "  [2 3 4]]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[[1, 2, 3], [2, 3, 4]]])\n",
    "print(arr.shape)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "[[1 2 3]\n",
      " [2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "# 实际上第一个纬度为`1`，我们不需要\n",
    "arr2 = np.squeeze(arr, 0)\n",
    "print(arr2.shape)\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意：只有数组长度在该纬度上为1，那么该纬度才可以被删除；否则会报错。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. 叠加和重复数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "利用函数`repeat`, `tile`, `vstack`, `hstack`, 和`concatenate` 我们可以用较小的向量和矩阵来创建更大的向量和矩阵："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.1 tile and repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 重复每一个元素三次\n",
    "np.repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tile the matrix 3 times \n",
    "np.tile(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 更好的方案\n",
    "np.tile(a, (1, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [1, 2],\n",
       "       [3, 4],\n",
       "       [1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(a, (3, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.2 concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.3 hstack and vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((a,b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. 复制和“深度复制”"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了获得高性能，Python中的赋值通常不复制底层对象。例如，在函数之间传递对象时，这一点非常重要，以避免不必要时大量的内存复制(技术术语:通过引用传递)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 现在B和A指的是同一个数组数据\n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 改变B影响A\n",
    "B[0,0] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果我们想避免这种行为，那么当我们从`A`中复制一个新的完全独立的对象`B`时，我们需要使用函数`copy`来做一个所谓的“深度复制”:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 现在如果我们改变B，A不受影响\n",
    "B[0,0] = -5\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12. 遍历数组元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通常，我们希望尽可能避免遍历数组元素(不惜一切代价)。原因是在像Python(或MATLAB)这样的解释语言中，迭代与向量化操作相比真的很慢。\n",
    "\n",
    "然而，有时迭代是不可避免的。对于这种情况，Python的For循环是最方便的遍历数组的方法:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1,2,3,4])\n",
    "\n",
    "for element in v:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row [1 2]\n",
      "1\n",
      "2\n",
      "row [3 4]\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "M = np.array([[1,2], [3,4]])\n",
    "\n",
    "for row in M:\n",
    "    print(\"row\", row)\n",
    "    \n",
    "    for element in row:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当我们需要去\n",
    "当我们需要遍历一个数组的每个元素并修改它的元素时，使用`enumerate`函数可以方便地在`for`循环中获得元素及其索引:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row_idx 0 row [1 2]\n",
      "col_idx 0 element 1\n",
      "col_idx 1 element 2\n",
      "row_idx 1 row [3 4]\n",
      "col_idx 0 element 3\n",
      "col_idx 1 element 4\n"
     ]
    }
   ],
   "source": [
    "for row_idx, row in enumerate(M):\n",
    "    print(\"row_idx\", row_idx, \"row\", row)\n",
    "    \n",
    "    for col_idx, element in enumerate(row):\n",
    "        print(\"col_idx\", col_idx, \"element\", element)\n",
    "       \n",
    "        # 更新矩阵：对每个元素求平方\n",
    "        M[row_idx, col_idx] = element ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 现在矩阵里的每一个元素都已经求得平方\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13. 向量化功能"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "正如前面多次提到的，为了获得良好的性能，我们应该尽量避免对向量和矩阵中的元素进行循环，而应该使用向量化算法。将标量算法转换为向量化算法的第一步是确保我们编写的函数使用向量输入。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "    Heaviside阶跃函数的标量实现\n",
    "    \"\"\"\n",
    "    if x >= 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "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-123-b49266106206>\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[0mnp\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[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-122-5990c144f91d>\u001b[0m in \u001b[0;36mTheta\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      3\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[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[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[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(np.array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个操作并不可行因为我们没有写`Theta`函数去解决一个向量输入\n",
    "\n",
    "为了得到向量化的版本，我们可以使用Numpy函数`vectorize`。在许多情况下，它可以自动向量化一个函数:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "Theta_vec = np.vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta_vec(np.array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们也可以实现从一开始就接受矢量输入的函数(需要更多的计算，但可能会有更好的性能):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "   Heaviside阶跃函数的矢量感知实现。\n",
    "    \"\"\"\n",
    "    return 1 * (x >= 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(np.array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False  True  True  True  True]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([-3,-2,-1,0,1,2,3])\n",
    "b = a>=0\n",
    "print(b)\n",
    "b*1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 同样适用于标量\n",
    "Theta(-1.2), Theta(2.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 14. 在条件中使用数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当在条件中使用数组时，例如`if`语句和其他布尔表达，一个需要用`any`或者`all`，这让数组任何或者所有元素都等于`True`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]])\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(M > 2).any()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one element in M is larger than 2\n"
     ]
    }
   ],
   "source": [
    "if (M > 2).any():\n",
    "    print(\"at least one element in M is larger than 2\")\n",
    "else:\n",
    "    print(\"no element in M is larger than 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all elements in M are not larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).all():\n",
    "    print(\"all elements in M are larger than 5\")\n",
    "else:\n",
    "    print(\"all elements in M are not larger than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15. 类型转换"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为Numpy数组是*静态类型*，数组的类型一旦创建就不会改变。但是我们可以用`astype`函数（参见类似的“asarray”函数）显式地转换一个数组的类型到其他的类型，这总是创建一个新类型的新数组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10.,  2.],\n",
       "       [ 3.,  4.]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]])"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 进一步的阅读"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [NumPy 简易教程](https://www.runoob.com/numpy/numpy-tutorial.html)\n",
    "* [NumPy 官方用户指南](https://www.numpy.org.cn/user/)\n",
    "* [NumPy 官方参考手册](https://www.numpy.org.cn/reference/)\n",
    "* [NumPy Tutorial](http://scipy.org/Tentative_NumPy_Tutorial)\n",
    "* [一个针对MATLAB使用者的Numpy教程](http://scipy.org/NumPy_for_Matlab_Users)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}