chapter_02_linear_algebra/Chapter 2.1-2.5.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 2: Linear Algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A branch of mathematics widely used throughout science and engineering.\n",
    "\n",
    "Essential for understanding and working with machine learning algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1: Scalars, Vectors, Matrices and Tensors\n",
    "\n",
    "- **Scalars**: A single number\n",
    "- **Vectors**: An array of numbers; each number is identified by its index.\n",
    "- **Matrices**: A 2D array of numbers; each number is identified by two indices\n",
    "- **Tensors**: A general, variably-dimensional array of numbers;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalars\n",
    "\n",
    "We'll use NumPy throughout these notebooks.  Numpy defines a set of fundamental scalar types.\n",
    "\n",
    "The default data type in numpy is `float_`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'complex'>\n",
      "<class 'int'>\n",
      "<class 'bool'>\n",
      "<class 'bytes'>\n",
      "<class 'str'>\n",
      "<class 'memoryview'>\n",
      "<class 'numpy.int8'>\n",
      "<class 'numpy.uint8'>\n",
      "<class 'numpy.float16'>\n",
      "<class 'numpy.timedelta64'>\n",
      "<class 'numpy.object_'>\n",
      "<class 'numpy.int16'>\n",
      "<class 'numpy.uint16'>\n",
      "<class 'numpy.float32'>\n",
      "<class 'numpy.complex64'>\n",
      "<class 'numpy.bytes_'>\n",
      "<class 'numpy.int32'>\n",
      "<class 'numpy.uint32'>\n",
      "<class 'numpy.float64'>\n",
      "<class 'numpy.complex128'>\n",
      "<class 'numpy.str_'>\n",
      "<class 'numpy.int64'>\n",
      "<class 'numpy.uint64'>\n",
      "<class 'numpy.float128'>\n",
      "<class 'numpy.complex256'>\n",
      "<class 'numpy.bool_'>\n",
      "<class 'numpy.void'>\n",
      "<class 'numpy.longlong'>\n",
      "<class 'numpy.ulonglong'>\n",
      "<class 'numpy.datetime64'>\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Some scalar numbers in Python\n",
    "\"\"\"\n",
    "x_1 = -0.000498\n",
    "x_2 = 34\n",
    "\n",
    "\"\"\"\n",
    "NumPy defines 24 scalar types.  Note in cases such as bool_ and int_,\n",
    "these are substantially different than the native Python counterparts.\n",
    "\"\"\"\n",
    "\n",
    "for t in np.ScalarType:\n",
    "    print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectors\n",
    "\n",
    "NumPy’s main object is the homogeneous multidimensional array.\n",
    "\n",
    "We can represent a vector simply as a 1-dimensional array:\n",
    "\n",
    "$\\Large \\begin{bmatrix} x_1 \\\\ x_2 \\\\ \\vdots \\\\ x_n \\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Representing a vector of values:\n",
      "\n",
      "[20 30 40 50]\n",
      "---\n",
      "Shape: (4,)\n",
      "Dimensions: 1\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Type of values in matrix: int64\n"
     ]
    }
   ],
   "source": [
    "# Let's represent a vector:\n",
    "v_1 = np.array( [20, 30, 40, 50] )\n",
    "\n",
    "print('Representing a vector of values:\\n')\n",
    "print(v_1)\n",
    "\n",
    "print(\"---\")\n",
    "print(f'Shape: {v_1.shape}')\n",
    "print(f'Dimensions: {v_1.ndim}')\n",
    "print(f'Type: {type(v_1)}')\n",
    "print(f'Type of values in matrix: {v_1.dtype}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrices\n",
    "\n",
    "We can continue to use the same data structure (the `ndarray` type) to build matrices, or 2-dimensional  arrays:\n",
    "\n",
    "$\\Large \\begin{bmatrix} A_{1,1} && A_{1,2} \\\\ A_{2,1} && A_{2,2} \\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Representing a matrix of 1s:\n",
      "\n",
      "[[1 1 1 1 1 1 1 1]\n",
      " [1 1 1 1 1 1 1 1]\n",
      " [1 1 1 1 1 1 1 1]\n",
      " [1 1 1 1 1 1 1 1]\n",
      " [1 1 1 1 1 1 1 1]\n",
      " [1 1 1 1 1 1 1 1]\n",
      " [1 1 1 1 1 1 1 1]\n",
      " [1 1 1 1 1 1 1 1]]\n",
      "---\n",
      "Shape: (8, 8)\n",
      "Dimensions: 2\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Type of values in matrix: int32\n"
     ]
    }
   ],
   "source": [
    "# Let's create a few matrices using NumPy:\n",
    "\n",
    "# An 8x8 matrix of ones of type int32\n",
    "m_1 = np.ones((8, 8), dtype=np.int32)\n",
    "\n",
    "print('Representing a matrix of 1s:\\n')\n",
    "print(m_1)\n",
    "\n",
    "print(\"---\")\n",
    "print(f'Shape: {m_1.shape}')\n",
    "print(f'Dimensions: {m_1.ndim}')\n",
    "print(f'Type: {type(m_1)}')\n",
    "print(f'Type of values in matrix: {m_1.dtype}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Representing a matrix of random float64s:\n",
      "\n",
      "[[0.51182162 0.9504637  0.14415961 0.94864945 0.31183145 0.42332645]\n",
      " [0.82770259 0.40919914 0.54959369 0.02755911 0.75351311 0.53814331]]\n",
      "---\n",
      "Shape: (2, 6)\n",
      "Dimensions: 2\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Type of values in matrix: float64\n"
     ]
    }
   ],
   "source": [
    "# A 2x6 matrix of random `float64s`\n",
    "# we can do this with an instance of the default random number generator\n",
    "rng = np.random.default_rng(1)\n",
    "m_2 = rng.random((2, 6))\n",
    "\n",
    "print('Representing a matrix of random float64s:\\n')\n",
    "print(m_2)\n",
    "\n",
    "print(\"---\")\n",
    "print(f'Shape: {m_2.shape}')\n",
    "print(f'Dimensions: {m_2.ndim}')\n",
    "print(f'Type: {type(m_2)}')\n",
    "print(f'Type of values in matrix: {m_2.dtype}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensors\n",
    "\n",
    "Given that __vectors__ are just first-order __tensors__, and __matrices__ are second-order __tensors__, we can continue to use the `ndarray` type to represent n-dimensional tensors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Representing a tensor:\n",
      "\n",
      "[[[0.32973172 0.7884287  0.30319483]\n",
      "  [0.45349789 0.1340417  0.40311299]\n",
      "  [0.20345524 0.26231334 0.75036467]]\n",
      "\n",
      " [[0.28040876 0.48519097 0.9807372 ]\n",
      "  [0.96165719 0.72478994 0.54122686]\n",
      "  [0.2768912  0.16065201 0.96992541]]\n",
      "\n",
      " [[0.51606859 0.11586561 0.62348976]\n",
      "  [0.77668311 0.6130033  0.9172977 ]\n",
      "  [0.03959288 0.52858926 0.45933588]]]\n",
      "---\n",
      "Shape: (3, 3, 3)\n",
      "Dimensions: 3\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Type of values in tensor: float64\n"
     ]
    }
   ],
   "source": [
    "# Let's make a 3-dimensional tensor!\n",
    "t_1 = rng.random((3, 3, 3))\n",
    "\n",
    "print('Representing a tensor:\\n')\n",
    "print(t_1)\n",
    "\n",
    "print(\"---\")\n",
    "print(f'Shape: {t_1.shape}')\n",
    "print(f'Dimensions: {t_1.ndim}')\n",
    "print(f'Type: {type(t_1)}')\n",
    "print(f'Type of values in tensor: {t_1.dtype}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transpose Operation\n",
    "\n",
    "> The transpose of a matrix is the mirror image of the matrix across a diagonal line, called the __main diagonal__, running down and to the right, starting from its upper left corner.\n",
    "\n",
    "The __transpose__ of $A$ is denoted as $A^\\top$.\n",
    "\n",
    "$$\\huge (A^\\top)_{i,j} = A_{j,i}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice in the illustration below how the transpose operation mirrors the matrix over the __main diagonal__:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_(GitHub currently doesn't render the transposed matrix correctly, try in your own notebook for better results)_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\Large A = \\begin{bmatrix} A_{1,1} && A_{1,2}\\\\ A_{2,1} && A_{2,2} \\\\ A_{3,1} && A_{3,2} \\end{bmatrix} \\Rightarrow A^\\top = \\begin{bmatrix} A_{1,1} && A_{2,1} && A_{3,1}\\\\ A_{1,2} && A_{2,2} && A_{3,2} \\end{bmatrix} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we consider __vectors__ to be special cases of __matrices__ with only a single column, then the __transpose__ of a vector is a matrix with a single row.\n",
    "\n",
    "When writing a vector out in text (such as in a book), it's often practical to represent it as a transpose row, e.g:\n",
    "\n",
    "$$\\large [3.2, 2.1, 9.0, 4.8]^\\top$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tranpose of a __scalar__ is just itself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With NumPy, it's easy to compute the transpose of `ndarray` types:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transpose of a scalar in NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.342 ()\n",
      "23.342 ()\n"
     ]
    }
   ],
   "source": [
    "# Construct a scalar value of type float64\n",
    "s_2 = np.float64(23.342)\n",
    "\n",
    "s_2_transpose = s_2.transpose()\n",
    "\n",
    "print(s_2, s_2.shape)\n",
    "print(s_2_transpose, s_2.shape)\n",
    "\n",
    "# Notice it's the same!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transpose of a vector in NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20 30 40 50] (4,)\n",
      "[20 30 40 50] (4,)\n"
     ]
    }
   ],
   "source": [
    "v_1_transpose = v_1.transpose()\n",
    "\n",
    "print(v_1, v_1.shape)\n",
    "print(v_1_transpose, v_1_transpose.shape)\n",
    "\n",
    "# Notice it's the same, as far as NumPy is concerned!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transpose of a matrix in NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Matrix:\n",
      "[[5 5 7 4 2 2]\n",
      " [0 2 6 1 3 1]] (2, 6)\n",
      "Transposed Matrix:\n",
      "[[5 0]\n",
      " [5 2]\n",
      " [7 6]\n",
      " [4 1]\n",
      " [2 3]\n",
      " [2 1]] (6, 2)\n"
     ]
    }
   ],
   "source": [
    "m_3 = np.random.randint(8, size=(2, 6))\n",
    "m_3_transpose = m_3.transpose()\n",
    "\n",
    "print(\"Original Matrix:\")\n",
    "print(m_3, m_3.shape)\n",
    "\n",
    "print(\"Transposed Matrix:\")\n",
    "print(m_3_transpose, m_3_transpose.shape)\n",
    "\n",
    "# Notice how the shape has changed!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Addition - Multiple Matrices\n",
    "\n",
    "Matrices of the same shape can be added together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_4 = np.random.randint(8, size=(2, 3))\n",
    "m_5 = np.random.randint(8, size=(2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_6 = np.add(m_4, m_5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 7 3]\n",
      " [5 5 6]]\n"
     ]
    }
   ],
   "source": [
    "print(m_4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 5 5]\n",
      " [6 4 3]]\n"
     ]
    }
   ],
   "source": [
    "print(m_5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 9 12  8]\n",
      " [11  9  9]]\n"
     ]
    }
   ],
   "source": [
    "print(m_6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Addition - Adding Scalars\n",
    "\n",
    "Scalars can be added to matrices by adding the scalar to each element of the matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_7 = 10 + m_6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 22 18]\n",
      " [21 19 19]]\n"
     ]
    }
   ],
   "source": [
    "print(m_7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Multiplication - Multiplying Scalars\n",
    "\n",
    "Matrices can be multiplied by scalars by multiplying the scalar against each element of the matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_8 = m_7 * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[190 220 180]\n",
      " [210 190 190]]\n"
     ]
    }
   ],
   "source": [
    "print(m_8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Broadcasting\n",
    "\n",
    "We can allow the addition of a matrix and a vector to produce a new matrix, where the vector is added to each row of the matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 3 7]\n",
      " [5 0 4]\n",
      " [4 5 4]\n",
      " [0 5 0]\n",
      " [2 7 6]]\n"
     ]
    }
   ],
   "source": [
    "m_9 = np.random.randint(8, size=(5, 3))\n",
    "print(m_9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's make an array (vector) to broadcast against the m_9 array (matrix):\n",
    "m_10 = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  5 10]\n",
      " [ 6  2  7]\n",
      " [ 5  7  7]\n",
      " [ 1  7  3]\n",
      " [ 3  9  9]]\n"
     ]
    }
   ],
   "source": [
    "# Now we'll broadcast the addition of m_10 over m_9:\n",
    "m_11 = m_9 + m_10\n",
    "print(m_11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This broadcasting of addition can be written as:\n",
    "\n",
    "$$\\huge C_{i,j} = A_{i,j} + b_j$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In NumPy, arrays may be broadcasted according to a set of rules:\n",
    "\n",
    "> When operating on two arrays, NumPy compares their shapes element-wise. It starts with the trailing dimensions and works its way forward. Two dimensions are compatible when\n",
    "> - they are equal, or\n",
    "> - one of them is 1\n",
    ">\n",
    "> If these conditions are not met, a ValueError: operands could not be broadcast together exception is thrown, indicating that the arrays have incompatible shapes. The size of the resulting array is the size that is not 1 along each axis of the inputs.\n",
    ">\n",
    "> (https://numpy.org/doc/stable/user/basics.broadcasting.html#general-broadcasting-rules\n",
    "\n",
    "See also: (http://www.astroml.org/book_figures/appendix/fig_broadcast_visual.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2: Multiplying Matrices and Vectors\n",
    "\n",
    "Matrix multiplication is one of the most important operations involving matrices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Product\n",
    "\n",
    "For the matrix product:\n",
    "\n",
    "$$\\huge C = AB $$\n",
    "\n",
    "$A$ must have the same number of columns as $B$ has rows.\n",
    "\n",
    "If $A$ has a shape $(m, n)$ and $B$ has a shape $(n, p)$, then $C$ is of shape $(m,p)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *matrix product* operation is defined as:\n",
    "\n",
    "$$\\Large C_{i,j} = \\sum_{k}A_{i,k}B_{k,j}$$\n",
    "\n",
    "In other words, $C$ is the sum of the products between rows of $A$ and columns of $B$.\n",
    "\n",
    "Let's looks at a concrete example using NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8 4]\n",
      " [5 2]]\n"
     ]
    }
   ],
   "source": [
    "# Matrix Multiplication using NumPy:\n",
    "\n",
    "A = np.array([[1, 0, 0],\n",
    "              [0, 1, 1]])\n",
    "\n",
    "B = np.array([[8, 4],\n",
    "              [4, 2],\n",
    "              [1, 0]])\n",
    "\n",
    "C = np.matmul(A, B)\n",
    "\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's get a sense of what this example would look like when written out:\n",
    "\n",
    "$$\n",
    "\\Large \\begin{bmatrix} 1 && 0 && 0 \\\\ 0 && 1 && 1 \\end{bmatrix}\n",
    "\\times\n",
    "\\Large \\begin{bmatrix} 8 && 4 \\\\ 4 && 2 \\\\ 1 && 0 \\end{bmatrix} \n",
    "=\n",
    "\\large \\begin{bmatrix} (1 \\times 8 + 0 \\times 4 + 0 \\times 1) && (1 \\times 4 + 0 \\times 2 + 0 \\times 0) \\\\ \n",
    "(0 \\times 8 + 1 \\times 4 + 1 \\times 1) && (0 \\times 4 + 1 \\times 2 + 1 \\times 0)\\end{bmatrix} \n",
    "=\n",
    "\\Large \\begin{bmatrix} 8 && 4 \\\\ 5 && 2 \\end{bmatrix} \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to make a distinction between the **matrix product**, as shown above, and the **Hadamard product**, which is an **element-wise product**.  The **Hadmard product** is denoted as $A \\odot B$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0 0]\n",
      " [0 2 2]]\n"
     ]
    }
   ],
   "source": [
    "# Hadamard product using NumPy:\n",
    "\n",
    "A = np.array([[1, 0, 0],\n",
    "              [0, 1, 1]])\n",
    "\n",
    "B = np.array([[2, 2, 2],\n",
    "              [2, 2, 2]])\n",
    "\n",
    "C = np.multiply(A, B)\n",
    "\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dot Product\n",
    "\n",
    "The **dot product** of two vectors $x$ and $y$ is the **matrix product** $x^\\top y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8 4]\n",
      " [5 2]]\n",
      "[[8 4]\n",
      " [5 2]]\n"
     ]
    }
   ],
   "source": [
    "# Dot Product using NumPy\n",
    "\n",
    "# For 2-D arrays it is the same as the matrix product:\n",
    "\n",
    "A = np.array([[1, 0, 0],\n",
    "              [0, 1, 1]])\n",
    "\n",
    "B = np.array([[8, 4],\n",
    "              [4, 2],\n",
    "              [1, 0]])\n",
    "\n",
    "C = np.dot(A, B)\n",
    "\n",
    "# Alternative syntax\n",
    "C_alt = A.dot(B)\n",
    "\n",
    "print(C)\n",
    "\n",
    "print(C_alt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other Useful Properties of Matrix Product Operations\n",
    "\n",
    "There are many useful properties of matrix product operations.  Here are a few mentioned in the book:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Distributive:\n",
    "\n",
    "$$\\large A(B+C) = AB + AC$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Demonstration of the Distributive property of Matrix Multiplication using NumPy:\n",
    "\n",
    "A = np.array([[1, 0, 0],\n",
    "              [0, 1, 1]])\n",
    "\n",
    "B = np.array([[8, 4],\n",
    "              [4, 2],\n",
    "              [1, 0]])\n",
    "\n",
    "C = np.array([[8, 4],\n",
    "              [4, 2],\n",
    "              [1, 0]])\n",
    "\n",
    "def assert_distributive(A, B, C):\n",
    "    Y_1 = np.dot(A, B + C)\n",
    "    Y_2 = np.dot(A, B) + np.dot(A, C)\n",
    "    if np.array_equal(Y_1, Y_2):\n",
    "        return True\n",
    "    return False\n",
    "    \n",
    "print(assert_distributive(A, B, C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Associative:\n",
    "\n",
    "$$\\large A(BC) = (AB)C$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Demonstration of the Associative property of Matrix Multiplication in NumPy:\n",
    "\n",
    "A = np.array([[1, 2],\n",
    "              [1, 4],\n",
    "              [1, 8]])\n",
    "\n",
    "B = np.array([[1, 2, 2],\n",
    "              [9, 0, 9]])\n",
    "\n",
    "C = np.array([[16, 14],\n",
    "              [41, 12],\n",
    "              [11, 80]])\n",
    "\n",
    "def assert_associative(A, B, C):\n",
    "    Y_1 = A.dot(B.dot(C))\n",
    "    Y_2 = np.dot(A, B).dot(C)\n",
    "    if np.array_equal(Y_1, Y_2):\n",
    "        return True\n",
    "    return False\n",
    "    \n",
    "print(assert_associative(A, B, C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dot Product of two Vectors  (1-D Tensors) is Commutative\n",
    "\n",
    "$$\\large x^\\top y = y^\\top x$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of A:  (20,)\n",
      "Shape of B:  (20,)\n",
      "A:  [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n",
      "B:  [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n",
      "C_1 and C_2:\n",
      "2470\n",
      "2470\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Demonstration of the commutative property of the dot product using NumPy:\n",
    "\n",
    "# Here we can look at NumPy's arange to return a vector of evenly-spaced values at a given interval\n",
    "\n",
    "A = np.arange(0, 20)\n",
    "B = np.arange(0, 20)\n",
    "\n",
    "def assert_dot_product_vectors_commutative(A, B):\n",
    "    Y_1 = A.dot(B)\n",
    "    Y_2 = B.dot(A)\n",
    "    if np.array_equal(Y_1, Y_2):\n",
    "        return True\n",
    "    return False\n",
    "    \n",
    "print(\"Shape of A: \", A.shape)\n",
    "print(\"Shape of B: \", A.shape)\n",
    "print(\"A: \", A)\n",
    "print(\"B: \", B)\n",
    "\n",
    "print(\"C_1 and C_2:\")\n",
    "C_1 = A.dot(B)\n",
    "C_2 = B.dot(A)\n",
    "print(C_1)\n",
    "print(C_2)\n",
    "\n",
    "print(assert_dot_product_vectors_commutative(A, B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The transpose of the product of two matrices is equivalent to the product of their transposes reversed\n",
    "\n",
    "$$\\large (AB)^\\top = B^\\top A^\\top$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "[[8 5]\n",
      " [4 2]]\n",
      "[[8 5]\n",
      " [4 2]]\n"
     ]
    }
   ],
   "source": [
    "# Demonstration of commutative property of transpose in NumPy:\n",
    "\n",
    "A = np.array([[1, 0, 0],\n",
    "              [0, 1, 1]])\n",
    "\n",
    "B = np.array([[8, 4],\n",
    "              [4, 2],\n",
    "              [1, 0]])\n",
    "\n",
    "def assert_transpose_commutative(A, B):\n",
    "    Y_1 = np.matmul(A, B).T\n",
    "    Y_2 = B.T.dot(A.T)\n",
    "    if np.array_equal(Y_1, Y_2):\n",
    "        return True\n",
    "    return False\n",
    "    \n",
    "print(assert_transpose_commutative(A, B))\n",
    "      \n",
    "Y_1 = A.dot(B).T\n",
    "Y_2 = B.T.dot(A.T)\n",
    "\n",
    "print(Y_1)\n",
    "print(Y_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Matrices to model systems of linear equations\n",
    "\n",
    "One of the reasons linear algebra is so useful to engineering is because **matrices can be used to model systems of linear equations.**\n",
    "\n",
    "Every system of linear equations has several important properties, including the _number of equations_ and the _number of unknowns_.  It's easy to start with an example in two dimensions, because we can visualize it clearly using a 2-dimensional plot.\n",
    "\n",
    "Let's consider a system of: \n",
    "- 2 equations, shown below\n",
    "- 2 unknowns ($x$, $y$).\n",
    "\n",
    "The number of dimensions in our space correspond to the number of unknowns. Each of our equations corresponds to a line in this space.\n",
    "\n",
    "$$\\large \\begin{cases} 2x + 5y = 18 \\\\ -6x – 2y = 10 \\end{cases} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can rewrite these in standard form and plot these equations in 2 dimensions:\n",
    "\n",
    "$$ \\Large y_1 = \\frac{18 - 2x}{5}, \\Large y_2 = \\frac{10 + 6x}{2} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set_style(\"whitegrid\")\n",
    "sns.set_context(\"notebook\", font_scale=1.5, rc={\"lines.linewidth\": 2.5})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.arange(-5, 5, 1) # start, stop, step\n",
    "y_1 = (18 - 2*x)/5\n",
    "y_2 = (10 + 6*x)/-2\n",
    "\n",
    "plt.plot(x, y_1, x, y_2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we can see that there is a single value (x, y) at which both equations cross.  We'll revisit the other two possible scenarios - two equations which never cross (parallel lines), and two equations with overlap entirely.\n",
    "\n",
    "Notice that with linear equations, each can not overlap more than once but less than infinitely many times!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's solve this system of equations using matrices.\n",
    "\n",
    "We'll go back to representing the equations with the following form:\n",
    "\n",
    "$$\\large \\begin{cases} 2x + 5y = 18 \\\\ -6x – 2y = 10 \\end{cases} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's call $x$ and $y$, which we're trying to solve for, $x_1$ and $x_2$, respectively. Now we end up with the following notation:\n",
    "\n",
    "$$\\large \\begin{cases} 2x_1 + 5x_2 = 18 \\\\ -6x_1 – 2x_2 = 10 \\end{cases} $$\n",
    "\n",
    "We will think of the constant numeric values on left sides of our system of equations as the matrix $A$, and the right sides of the equation as the vector $b$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we know how the matrix dot product works - i.e. the product $C$ is the sum of the products between rows of $A$ and columns of $B$, we can represent our system of equations using matrices.\n",
    "\n",
    "We can express our system of linear equations with matrices of the form:\n",
    "\n",
    "$$\\huge Ax = b$$\n",
    "\n",
    "where:\n",
    "- $ A \\in \\mathbb{R}^{m \\times n}$ is a known matrix (the numeric values on the left-hand side)\n",
    "- $ b \\in \\mathbb{R}^{n} $ is a known vector (the numeric values on the right-hand side), and\n",
    "- $ x \\in \\mathbb{R}^{n} $ is a vector of unknown variables to be solved for ($x_1$ and $x_2$)\n",
    "\n",
    "Each element $x_{i}$ of $x$ is one of these unknown variables.\n",
    "\n",
    "Each row of $A$ and each element of $b$ provide another constraint - in this case, our two dimensions.\n",
    "\n",
    "We can now see that the dot product of the matrix $A$ and the unknown vector $x$ will produce a new vector $b$.\n",
    "\n",
    "In the next section, we'll look at one way to solve this system of equations for the unknown values $x_1$ and $x_2$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3: Identity and Inverse Matrices\n",
    "\n",
    "We can use **matrix inversion** to analytically solve this equation for many values of $A$.  **Matrix inversion** can be accomplished using the **identity matrix**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identity Matrix\n",
    "\n",
    "An identity matrix $I_{3}$.  This probably doesn't display correctly on GitHub, but it should render properly in a local Jupyter notebook.\n",
    "\n",
    "$$\\Large \\begin{bmatrix} 1 && 0 && 0 \\\\ 0 && 1 && 0 \\\\ 0 && 0 && 1 \\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> In linear algebra, the identity matrix of size n is the n × n square matrix with ones on the main diagonal and zeros elsewhere. [Wikipedia - Identity Matrix](https://en.wikipedia.org/wiki/Identity_matrix)\n",
    "\n",
    "When a vector is multiplied by an identity matrix, the result is equivalent to the vector. I.e.:\n",
    "\n",
    "$$\\huge \\forall x \\in \\mathbb{R}^{n}, I_{n}x = x$$\n",
    "\n",
    "This is to say that for the identity matrix $I_n \\in \\mathbb{R}^{n \\times n}$, and all vectors $x$ containing real numbers, $I_n$ multiplied by that vector equals that vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# In NumPy, we can easily generate an identity matrix:\n",
    "\n",
    "print(np.identity(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0. 0. 0. 0. 0.]]\n",
      "^ not an identity matrix!\n"
     ]
    }
   ],
   "source": [
    "# Note that under the hood, np.identity calls np.eye, which provides an matrix with zeros on the diagonal,\n",
    "# but with the ability to offset the diagonal and provide matrices of different shapes than the square \n",
    "# identity matrix.  Thus, np.identity is a special case of np.eye\n",
    "\n",
    "print(np.eye(3, 9, 0))\n",
    "print(\"^ not an identity matrix!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use NumPy to see that when we apply the identity matrix to a vector, we get that vector back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 8. 12.  3.]\n"
     ]
    }
   ],
   "source": [
    "A = np.identity(3)\n",
    "x = np.array([8, 12, 3])\n",
    "b = A.dot(x)\n",
    "\n",
    "print(b)\n",
    "\n",
    "# Notice that the result is the same as the input vector x."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a better visual of what we've done here:\n",
    "\n",
    "$$\n",
    "\\large \\begin{bmatrix} 1 && 0 && 0 \\\\ 0 && 1 && 0 \\\\ 0 && 0 && 1 \\end{bmatrix}\n",
    "\\times\n",
    "\\large \\begin{bmatrix} 8 \\\\ 12 \\\\ 3 \\end{bmatrix} \n",
    "=\n",
    "\\large \\begin{bmatrix} 1 \\times 8 + 0 \\times 12 + 0 \\times 3 \\\\ 0 \\times 8 + 1 \\times 12 + 0 \\times 3 \\\\ 0 \\times 8 + 0 \\times 12 + 1 \\times 3 \\end{bmatrix} \n",
    "=\n",
    "\\large \\begin{bmatrix} 8 \\\\ 12 \\\\ 3 \\end{bmatrix} \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inverse Matrix\n",
    "\n",
    "\n",
    "The **matrix inverse** of a matrix $A$ is denoted as $A^{-1}$.  Thus, \n",
    "\n",
    "$$ \\huge A^{-1}A = I_{n} $$\n",
    "\n",
    "I.e. When we multiply a **matrix** by its **inverse**, we get the **identity matrix**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The steps to solve the equation $ Ax=b $ are as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.) $Ax = b$\n",
    "\n",
    "2.) $A^{-1}Ax = A^{-1}b$\n",
    "\n",
    "3.) $I_{n}x = A^{-1}b$\n",
    "\n",
    "4.) $x=A^{-1}b$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All of this depends on the possibility that $A^{-1}$ exists and can be found.  Due to the limits of the precision of representing real numbers digitally, using $A^{-1}$ is generally not the best tool for the job when solving systems of equations using computation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solving a 2-dimensions system of equations\n",
    "\n",
    "Let's use this technique to solve the system of equations from the previous section using NumPy!\n",
    "\n",
    "Recall that we had the following system of equations:\n",
    "\n",
    "\n",
    "$$\\large \\begin{cases} 2x_1 + 5x_2 = 18 \\\\ -6x_1 – 2x_2 = 10 \\end{cases} $$\n",
    "\n",
    "and we want to represent it using the form:\n",
    "\n",
    "$$\\huge Ax = b$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, we build our $A$ matrix and $b$ vector, with $x$ being our unknown:\n",
    "\n",
    "$$ \\large \\begin{bmatrix} 2 && 5 \\\\ -6 && -2 \\end{bmatrix} \\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix} = \\begin{bmatrix} 18 \\\\ 10 \\end{bmatrix} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice what happens when you take the dot product here on the left-hand side: you end up with the same representation we started with!  This should help illustrate why this tensor-based structure is useful as a representation. \n",
    "\n",
    "> Keep in mind that even though we're working in 2-D space for the purposes of practical visualization, this works for arbitrarily large numbers of dimensions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  5]\n",
      " [-6 -2]]\n",
      "[[18]\n",
      " [10]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2, 5],\n",
    "              [-6, -2]])\n",
    "\n",
    "b = np.array([[18],\n",
    "              [10]])\n",
    "\n",
    "print(A)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already know that $x=A^{−1}b$, so let's use NumPy to find and use the inverse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.07692308 -0.19230769]\n",
      " [ 0.23076923  0.07692308]]\n"
     ]
    }
   ],
   "source": [
    "A_inv = np.linalg.inv(A)\n",
    "print (A_inv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and now, simply solve for x using the **dot product**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-3.30769231]\n",
      " [ 4.92307692]]\n"
     ]
    }
   ],
   "source": [
    "x = A_inv.dot(b)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plug in values:\n",
    "\n",
    "$$\\large \\begin{cases} 2 \\times -3.31 + 5 \\times 4.92 \\Rightarrow 17.98 \\approx 18 \\\\ -6 \\times -3.31 – 2 \\times 4.92 \\Rightarrow 10.02 \\approx 10 \\end{cases} $$\n",
    "\n",
    "See how this corresponds to the graph we created earlier, also.  Nice!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why do we care about systems of equations? Two Practical Examples\n",
    "\n",
    "### Example 1: Ticket Pricing Analysis\n",
    "\n",
    "Let's say we sell tickets to a concert.  Tickets for children are 8 dollars and adults are 12 dollars.  We measured attendance at our last event - we had 300 people, and we made $3,100.  How many child and adult tickets did we sell?\n",
    "\n",
    "Our unknowns:\n",
    "- $\\large x_1$ - how many child tickets?\n",
    "- $\\large x_2$ - how many adult tickets?\n",
    "\n",
    "Our knowns:\n",
    "- 8 - the cost of a child ticket\n",
    "- 12 - the cose of an adult ticket\n",
    "- 300 - the number of people in attendance at the show\n",
    "- 3100 - the number of dollars collected (revenue)\n",
    "\n",
    "Our equations:\n",
    "- $\\large 8x_1 + 12x_2 = 3100$\n",
    "- $\\large x_1 + x_2 = 300$\n",
    "\n",
    "Let's start with a graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAEWCAYAAACwtjr+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABqu0lEQVR4nO3dd1QUVxvA4d+yNAUsWEAFG0qRYq8gBBXFlth7QSwYxd5jj733GkvsHUvUREXFgh0rdhELdkWkqNT9/hjZLxtAF2VdwPucs+dkZ2Zn3rmSfXdm7n2vTKFQKBAEQRAEDdLRdgCCIAhC9ieSjSAIgqBxItkIgiAIGieSjSAIgqBxItkIgiAIGqer7QAyg6SkJGJiYtDT00Mmk2k7HEEQhCxBoVAQHx+PkZEROjqfv3YRyQaIiYnhzp072g5DEAQhS7K2tsbExOSz24hkA+jp6QFSg+nr62s5mu8jODgYBwcHbYeRbYn21SzRvpqlbvvGxcVx584d5Xfo54hkA8pbZ/r6+hgYGGg5mu/nRzpXbRDtq1mifTUrPe2rzuMH0UFAEARB0DiRbARBEASNE8lGEARB0DiRbARBEASNE8lGEARB0DjRG+0bvYj8yKEbL6hjZ4Z5bkNthyNkcpGRkbx8+ZL4+Hhth5Kl6erqcvPmTW2HkW3p6ury+PFjChQogKFhxnyviWTzjYbtuErA7VdM+/sWvzW0o01lS1GFQEhVZGQkL168oEiRIuTIkUP8nXyDmJgYjIyMtB1GtqRQKIiMjCQpKYlHjx5hZmZG7ty5v3m/4jbaN3K2yg9AVGwCI/yu0e6Pszx4HaPlqITM6OXLlxQpUoScOXOKRCNkWjKZDF1dXfLmzYuFhQVv3rzJkP2KZPONuruWZJVXJQp9uoV2+v4bPOcd54/j90lMEpOgCv8XHx9Pjhw5tB2GIKgtR44cxMbGZsi+RLLJALVszTg4wJUO1YoC8DE+iUn7b9JscSC3n0dpOTohMxFXNEJWkpF/ryLZZBATQz0mNnFkS49qlMgv3Uu+EvaORgtOMOfQHeISkrQcoSAIgvaIZJPBqpbMx9/9auLjVhIdGcQnKph3+C6NFpzg8uMIbYcnCIKgFSLZaIChnpwR9e3Y1dsZW3Op7PadF9E0WxzIxL03+BCXqOUIBUEQvi+RbDTIySIPf/VxYZCHNfpyHZIUsOJkKPXmHudUyGtthycIgvDdiGSjYXpyHfrULs3+fi5UKJoHgEfh72n3x1mG77hK5EcxuE8QhOxPJJvvpFRBE7b1rMHYxmXIoScHYPP5x3jMPob/jRdajk4Qvl6tWrWYOnUqHTt2xMnJifHjxwPw9u1bRo0aRfXq1XFycqJt27YEBQUpP9epUydat26dYn9eXl506NBB+f7QoUM0a9YMR0dHXFxcmDZtGnFxccr1CxYswNPTk8OHD9O4cWMcHByoV68eu3fvVm7j5+eHjY0Nz58/TxH7yJEjle8/fvzItGnTcHV1xdHRkSZNmnD48OEvtsGXzhUgNjaWSZMmUaNGDcqXL8/QoUPZuHEjZcqUUW7TsWNHxowZw9KlS3Fzc8PR0ZE2bdpw7dq1L8aQ2Ylk8x3JdWR0cS7BwQGuuJSSBoO+iIyl29oL9Nl0idfRGdOfXRC+t3Xr1lGhQgUWLVpE06ZNiY2NxcvLi4CAAAYOHMj8+fPJnTs3Xl5eXL16FYBffvmFy5cv8+TJE+V+Xr9+zblz5/j5558B+Ouvv/D19aV06dIsWrSInj17smXLFn777TeV47948YJJkybRuXNnli9fjoWFBcOGDePBgwdqn4NCocDX15etW7fStWtXFi1ahJ2dHb1798bf3z/Nz6lzrgCDBw9m+/bt+Pj4MGfOHMLDw5k7d26K/e3fv5+AgABGjx7N7Nmzef36Nf369SMpKWv3aBXlarTA0jQn67pWYVtQGBP33iDyYwJ/XXnKybuvGPezPT+XLSzGY/wgLj+OYMHhu0THJmg1DmMDXfrULk05yzxf9XlLS0sGDBigfL9161Zu377Ntm3bcHR0BMDV1ZUWLVowZ84cVq9eTb169fj999/Zt28fPXr0AODvv/9GLpfj6emJQqFg5syZuLu7M23aNOW+zc3N6d27N0FBQVSsWBGA9+/fs2TJEqpVqwZA8eLFcXd359ixYxQvXlytczh16hQnTpxg/vz51KtXTxlzZGQkM2bMoE6dOql+bvfu3V881zt37nDw4EHGjx9PmzZtAHBxcaFhw4ZER0er7C8xMZEVK1ZgbGwMSKV5hg0bxp07d7C1tVXrXDIjkWy0RCaT0aqSJT9ZF2D07mAOXH/B2/fx9Nt8md2XnzKxiQOF84jR5tndqpOhHL71UtthAGBsqMu8NuW/6rN2dnYq70+fPo2ZmRl2dnYkJPw/kbq7u7Ns2TLi4uIwNjamdu3a7N+/X5ls9u3bh7u7O7ly5SIkJITnz5/Tu3dvlX3UrFkTPT09Tp06pUw2ABUqVFD+t7m5OQAfPnxQ+xxOnz6NXC7H1dVV5Xi1atXC39+fsLAwLCwsUv3cl871woULANSuXVu5XldXl0aNGrFkyRKV/dnY2CgTDYCZmRkgJdSsTCQbLSuYy5ClHSryd/BzxuwO5nV0HEduvaTunOMMr29LuypF0dERVznZlbdLCWJiEzLFlY23c4mv/nzOnDlV3kdERPD8+XPs7e1T3f7t27eYmZnxyy+/0KNHD+7fv4+BgQGXL19m4cKFyn0AjB49mtGjR6fYx8uX/0/ScrkcfX195XsdHekJQXpuPUVERJCYmEi5cuVSXf/y5ctUk4065/ru3TsATE1NVdYlJ8V/+2+V5a85l8xIJJtMQCaT0cCxEDWs8jFh7012XAwjOjaBUbuC2XPlKdOaOymrEgjZSznLPKz0qqztMDKciYkJVlZWKre//i1v3rwAODs7ky9fPv755x/09fXJnTs3bm5uyn0AjBgxQuUKBqQH+YUKFVI7nuTb0omJqmPcYmL+XzTXxMQEExMTVq9eneo+SpRIPRmrc67J5/v69WvllQpIiehHIToIZCJ5cuozq1VZ1nhXocinW2jnQsPxnHucpcdCSEjM2r9shB9H5cqVefr0KQULFsTR0VH5Onz4MOvWrUNPTw+QbiU1bNiQo0eP8s8//1C/fn3lOisrK0xNTXny5InKPvLmzcu8efMICQlRO57k21LPnj1TLgsJCVFePSXHHBUVha6ursrxrl69ypIlS9J8jqrOuVarVg2ZTMb+/ftVPnv06FG1zyGrE1c2mZCbdQEODHBlxj+3WHP6IbEJSUz9+xb7rj5jWnMnyhTOpe0QBeGzmjVrxvr16+nSpQs+Pj6YmZkREBDA6tWr8fX1Vfni/uWXX1i3bh2ASi8zuVxO//79GT9+PDo6Ori6uhIREcGCBQuIjIxU6TL8JVWrVsXQ0JDJkyfTr18/YmJimD9/Pnny5FFu89NPP1GhQgV69uxJr169KF68OBcvXmTRokU0atQozflz1DnX4sWL06ZNG2bPnk18fDx2dnb89ddfXLp0SXmbLLsTySaTMjbQZfwvDjQqW5hhO65y/1UM15684+eFJ/n1Jyt8a5XCQFeu7TAFIVVGRkZs2LCBWbNmMXXqVGJiYrC0tGT06NEqY2gAHBwcKFmyJHFxcSoP+QFat26NsbExK1asYOPGjRgbG1O5cmV+/fVXChQooHY8uXLlYsGCBcyaNYvevXtTpEgRfH192bVrl3IbHR0d/vjjD+bNm8fChQt5+/YthQoVomfPnvj4+HzzuY4ZM4b8+fOzbt06IiMjcXNzo127dmzevFnt88jKZAqF4oefdCU2Npbg4GAcHBwwMDDQdjgpfIxPZP7huyz71xw5pQoaM625ExWL5f2qff6726iQ8VJr35s3b6botSV8newyU+eCBQtYsmQJN27c0HYoKv7dvp/7u03Pd2emuX67efMm9vb2KUb4HjhwgCZNmlCuXDnq1avHn3/+maJXxrVr1+jYsSPly5fHxcVFeamaXRjqyRnqacvu3s6UKSTdQrv3MpoWS08x/q/rvI/Tbk8mQRCEL8kUySYkJAQfHx+VPuoAJ0+epG/fvtjY2LB48WKaNGnCtGnTWLVqlXKbhw8f4uXlhYGBAXPnzsXb25vVq1czZcqU730aGudQJDe7fZ0ZUs8GfV0dFApYHfiAunOOc/KuKOwpCELmpdVkk5CQwIYNG2jZsmWqU4/u3LmTokWLMmXKFGrUqMGvv/5K48aN2bhxo3Kb5cuXY2JiwuLFi3Fzc8Pb25sRI0awefNmXrzIfjXH9OQ69HYvxf6+Nan06RZa2NsPdFh5lqHbr/DuQ/a5ohOE7K5Pnz6Z7haapmg12QQFBTFz5ky8vb0ZPHhwivWxsbHkyJFDpbdGnjx5VLorBgYG4u7urjKgy9PTk8TERE6ePKnR+LWpVEFjtvpUZ/zP9uTUlzoKbL0QhsfsYxy4/vwLnxYEQfi+tJpsrKys8Pf3x9fXF7k8Zc+qdu3acf/+fdatW0dUVBSnT5/Gz8+PX375BZBKUTx79izFYCtTU1OMjY0JDQ39LuehLTo6MjrXKM7BAa64Wks9c15GxeKzLojeGy7yKkoU9hQEIXPQarLJnz8/+fLlS3N99erV8fb2ZuLEiVSqVAkvLy+cnJwYMWIEAFFRUQAqdYSSGRkZpShwl11Z5M3Jmi6VmdWyLLlzSAPi9l17Rp3Zx9gRFIbocCgIgrZl6nE2Y8eOxc/PD19fX6pWrcq9e/eYP38+/fr1Y/HixV/8Ek3vYKng4OBvCVfrigOz6+RhxaVITofF8u5DPIO2XWH9iZv4VMxNgZyqV4//nW9DyFj/bV9dXV2V8ijCtxFtqVnJ7RsXF5ch3xWZNtm8ePGCrVu30rt3b/r06QNAlSpVKFq0KF27diUgIIAqVaoAqf/RRUdHK2srqSuzjrNJr9rO8E/wM0bvvs6rqFguPY9j0KFwhtW3pUPVYujoyMQ4Gw1La5xNdhgbkhlkl3E2mdW/21dfX5+yZcumul3yOBt1ZIquz6l5+vQpCoUixYjiypWlooV3797FyMgIMzMzHj58qLLNmzdviImJSbNw3o/A06EQ/gPcaFlRqlIbE5fImN3Xab38NCGvfozbi4IgZB6ZNtkUK1YMuVye4vLt0qVLAMpS387Ozhw9elRlmtgDBw4gl8uVVz4/qtw59ZjRsizrulbBIq9U2PP8g7fUn3cCv1vRxIvCnsJ3lNptb/E88ceRaZONqakpHTp0YPny5SxYsICzZ8+yefNmBg0ahK2tLR4eHgB069aNV69e0aNHD44ePaoc0NmqVSsKFy6s5bPIHGqWLsCB/q541SiOTAZxCUlsuBZNk0WBBD95p+3whB9ASEgIbdu2VVm2Y8eONMvya4Kfnx82NjYpqpQI30emTTYAw4cPZ+DAgezdu5euXbuyYsUKGjZsyPr161XKkK9atYr379/Tt29fVq9eTZcuXRg5cqSWo89cjAx0GfezPdt7VseqgHQv9vrTSH5ZFMiMA7f4GJ/4hT0Iwtc7cOCA8q5EsqVLl6qMmROyt0zTQaBZs2Y0a9ZMZZmOjg7e3t54e3t/9rOVKlVi69atmgwv26hYzJR9fWsycuMJdt9+T0KSgkVHQ/g7+DnTmztRqbjpl3ciCIKQTpn6ykbQDEM9Oe0cTNjt64xDEamw5/1XMbRcdpqxu4OJ0fIUxULW8v79e2bMmEHdunVxcHCgQoUKdO3alVu3bgFSZeN58+YBYGNjw4IFC6hVqxaPHj1i586d2NjYEBYWBsCTJ0/o378/lStXply5cnTt2pV79+4pjxUWFoaNjQ2HDx/G19eX8uXLU6VKFUaPHs2HDx+U2yUlJbF48WJ++uknypYtS69evZRTM//b5s2badasGeXKlcPJyYmmTZty4MAB5Xo/Pz8cHR25ePEiLVu2xNHREXd3d5X6jCD1fp0wYQIuLi6UK1eOVq1acerUKZVttm7dSoMGDXBwcKBWrVosX778i8+skpKSWLp0KXXq1MHBwQFPT0+2bduWYruNGzdSr149nJycaN++PadPn8bGxoYLFy4o/w08PT05fPgwjRs3xsHBgXr16rF79+7PHj8jqZ1sdu3apfyDSE1ISAjLli3LkKCE78O+cG529XJmeH1bDD4V9lxz+iF15xzn+J1X2g5PyCKGDh3Krl278PHxYdWqVYwYMYLbt28zePBgFAoFLVu2pHXr1gBs2bKFli1bsnDhQszNzXFzc2PLli0ULFiQ8PBw2rZty61btxg3bhwzZ84kJiaGdu3a8eTJE5VjTpgwAUtLSxYvXkzXrl3Ztm2byvfPjBkzWLRoES1atGDhwoXkyZOHWbNmqexj7dq1/P7779StW5dly5Yxc+ZMdHV1GTRokEpdxYSEBAYOHEjjxo35448/qFChAtOmTeP06dOANNW0t7c3e/fupVevXixevJhChQrRo0cPZd2zZcuWMWbMGGrWrMnSpUtp2bIl8+fP/+Izq3HjxrFw4UKaNm3K0qVLcXd3Z/To0crJ5gDWrVvH+PHjcXV1ZdGiRZQpU4Z+/fql2NeLFy+YNGkSnTt3Zvny5VhYWDBs2DAePHigxr/yt1P7NtqIESOYMWOGshfYf507d45FixZ9dpIhIfPRlevQ082KumXMGL7jGucehPMk4gOdVp2jeQULRjeyI09O/S/vSPg6YUFwfDrEark7uoExuA4Fi/SNvYqNjeXDhw+MHj0aT09PQBoPFx0dzdSpU3n79i3m5uaYm5sDUK5cOQDMzc3R19fH1NRUuWzNmjW8e/eOrVu3Krd3cXHBw8ODJUuWMHHiROVxXV1dGTZsGCBVGgkMDCQgIID+/fsTGRnJunXr8Pb2xtfXF4CaNWvy8uVLTpw4odxHWFgY3bp1o2fPnsplRYoUoVmzZly8eJH69esD0tVFnz59aN68OQAVKlTg0KFDHD16lOrVq3P8+HGuXLnCsmXL+Omnn5Rt0LJlS86ePatMiu3bt1dWP3FxcSFnzpxMmzaNTp06pdqZKTQ0lK1btzJ06FDlowQXFxcSExOZN28eLVq0wMDAgCVLltCwYUPlc+qaNWsSHR2Nn5+fyv7ev3/PkiVLqFatGgDFixfH3d2dY8eOUbx4cbX+vb9Fmsnm8ePHjBo1SnmZp1AoWLJkSarPRhQKBbdu3UrXzHlC5lKygDGbe1Rjw7lHTPv7FtGxCey4GMaxO6+Y8Is99R0LaTvE7OnMYrjzj7ajkBiYgMWK9H3EwICVK1cC0i/n0NBQHjx4wNGjRwHSNa/U6dOnsbe3J3/+/MrpRnR1dXF2dk5xS+q/gwzNzc2VVyOXL18mPj6e2rVrq2xTv359lWSTPAV1ZGQk9+/f5+HDh5w9ezbVuP893i85SSbftgsKCkJfXx83NzflNrq6uuzcuROA48eP8/HjR2rVqqUyjUqtWrWYPHkyZ86cSfG8GuDMmTMoFArc3d1TfG7NmjVcvXqV/Pnz8+bNmxTn2qRJkxTJ5r/nkZzQ/337UZPSTDaWlpYUK1ZMWTlZJpMRHh6eamByuZySJUsqR/oLWZOOjoyO1YpR27YgI3de4+jtV7yOjuXXDRep72DO+F/sKWhiqO0ws5dqvSAuOnNc2VT79as+euLECSZPnsz9+/cxMjLC1taWnDlzAukbRxMREcHDhw+xt7dPsS6592kyQ0PVv0MdHR3lpIrJz2ZMTVU7u/z3x/CjR48YM2YMp0+fRk9Pj5IlS2Jra5tq3Dly5EjzeBEREZiamiKTydI8LyDNjk4vX7787OeSrxhT+5yurvQV/t9zTU4k/yaXy1Wq4yeX8/rvZJSa8tnbaL///rvyv21tbfntt99o3LixxoMStKtwnhys8qrM7stPGf/Xdd6+j+fv4OecCnnDqIZ2tKhokeb/WEI6WVSEdlu0HcVXe/ToEb1798bDw0P5HEAmk7FhwwaVqwh1GBsbU61atVSnG0mPvHmleZ5ev35N0aJFlcv/3c06KSmJHj16YGBgwPbt27Gzs0NXV5d79+6l+6G5iYkJb9++TbH86tWr6OvrK8tmzZkzB0tLyxTbFSxYMM39Aqxfvz5FcgVpYHvycV+9Un3Gmhm7lKvdQeDWrVsi0fxAZDIZTcoX4dBANxo5SbfQ3n2IZ8j2q3RadY7H4e+1HKGQGQQHBxMbG0vPnj2xtLRU/ghJTjTJv5pTm0Lkv4Vyq1SpQmhoKFZWVjg6OipfW7duZd++fWrHVL58eQwNDfnnH9Xbk8m39gDevn1LaGgorVq1wtHRUXmFcPz4cSB9V2QVK1YkNjaWwMBA5bLExESGDBnC2rVrKVu2LHp6erx8+VLlvBISEpgzZ06KRJGsUqVKgHSl9u/PPXv2jPnz5/PhwwdKlChBoUKF2L9/v8pnjxw5onb830u6xtkkJSVx9uxZXr16lealV5MmTTIiLiGTyG9swMJ2Ffi57HNG7QrmZVQsJ+6+pt7c4wypZ0On6sWR64irnB+Vvb09urq6zJgxAy8vL2JjY/Hz8yMgIAD4//OA5F/pe/fupVy5clhYWJArVy5u3LjBuXPncHJyokuXLuzatQtvb2+8vLzIlSsXu3btYvfu3ema5t3IyIhevXoxd+5cDA0NqVKlCgEBASrJJl++fBQpUoS1a9dSsGBBjI2NOXHiBGvXrgWkh+nqcnd3x8nJiaFDh9K/f38KFy7Mtm3bePHiBV5eXpiamuLt7c2cOXOIjo6mYsWKPH36lDlz5mBiYkLp0qVT3a+trS2NGjXit99+4/Hjx9jZ2XH37l3mzJmDvb29slPB0KFDGThwICNHjqR+/fpcuXIlRdfszEDtZHPr1i18fHx4+fJlmllfJpOJZJNN1bU3p2rJfEzZf5PN5x/zPi6R8X/dYO/VZ0xr7kipgumrsC1kD8WKFWPWrFksXLiQnj17kjt3bsqVK8e6devo2LEjFy5cwMrKijp16uDn58fw4cNp1aoVY8aMoUuXLkycOJGuXbuyZs0aKlSowObNm5k9ezajR48mPj6ekiVLMnv2bBo2bJiuuHx8fMiZMydr1qxh9erVlC9fnmHDhjFu3DjlNosXL2bSpEkMHToUfX19SpUqxZIlS5g8eTJBQUG0a9dOrWPJ5XJWrlzJzJkzmT17Nh8/fsTe3p7Vq1djbW0NwIABAyhQoAAbN25k6dKl5MmTh5o1azJw4MDPVpqfOnUqS5cuZf369bx48YL8+fPTokUL+vbtq9ymQYMGyOVyFixYwO7du7Gzs2PQoEHpStDfg0yh5vWil5cXV65coVevXtjZ2ak8aPq3rFj8MrlMdnaZYkAd3zLFQOC91wz3u8rjcOlXq75ch761S+HjZoWeXIwThrSnGLCzs9NSRNmLmGLg886ePUunTp3YsGGD8nZcevy7fT/3d5ue7061r2wuX75M9+7d6d69ezpC/gG8fQi39kEJVzB30HY034Vzqfwc6O/KrIN3WBUYSlxiEjMP3mHfNankjaNFbm2HKAhCJqP2z9CcOXOSJ08eDYaSRe0bBAdGwFJn+LMR3NwLSdm/qGVOfV1GNyrDjl9rULqgNC33zWeRNFkcyNS/RWFPQRBUqZ1s6tWrx19//SXmn/gv63og+9SMD07AlvYwvzycWggfIrQa2vdQoWhe9vZ1oW+tUujqyEhMUrD0WAj1553g7P032g5PEH5IVatW5fbt2191C01T1L6N5uHhwbFjx2jTpg0eHh6Ympqm6LoIP2BvtCrdobQHnPsDLq6D2HcQ8RAOjoSjk6FcW6jaE/Kn3uMkOzDQlTOwrg31HQsxbMdVroa9I/R1DK2Xn6FDtaIM87TFxFDvyzsSBCHbUjvZJI9+ffr0KVeuXEl1mx+2N1re4lBvEvw0Aq5sgrPL4M1diI+B8yukV6k6UtKxqg2pJOnswK5QLvx+rcGqwFBmHbxDbEIS68884sjNl0xq5oi7TeqD1wRByP7UTjbJ/c+FzzAwlq50KnWFkCNwdincOyStu+cvvfKVhqo+ULattH02oyvXoYerFXXLmDNsx1XOhobz9N1Huqw+T7PyRRjdqAx5jX7cwp4KhUJUXxCyjIx8bKJ2ssmKXZq1RkcHSteRXq/vSlc6lzdKVzpv7sL+wXB4AlToKCWnvMW1HXGGK57fiE3dq7H5/GOm7L9JVGwCfpeecOzOK8b/Yk9Dx0I/3Jeurq4uCQkJKep8CUJmFR8fn2r1h6+hdrLZtWuXWtv9kLfRPid/aWg4E2qNgkvr4dwyiHgkPds5vRBOLwKbBlCtJxSvCdnoC1hHR0a7qkVxty3AqJ3BHL71kjcxcfhuvMTuMk+Z2MQBs1w/TmFPQ0NDoqOjlbW7BCGzi4yMVFZ/+FZqD+q0tbVFJpOleln171+oN2/ezJDAvqfvOqgzKVEqKX9midR77d8K2ktJx7El6OVI/fMZ5FsGdX4NhULBnitPGf/XDcJj4gAwMdRlVEM7WlWyzHZXOam178ePH3n06BEWFhbkyJEj253z9yQGdWqOQqHg3bt3JCQk8PbtW4oWLZrm92J6vjvVTjbnzp1LsSwxMZHXr1+zb98+Hj58yJIlS77LJDwZTWsVBJ4HS891rm2DhI//X57DFCp1kZ795C6ikUN/72ST7E10LL/vvcHuy0+Vy2pY5WNqMyeK5sv53ePRlLTa9927d7x584bY2FgtRJV9xMXFpVnFRPh2cXFxFCxYEFNT089+J2ok2XxJ9+7dyZ8/f6arx6MOrZeriXkDQavh/EqI+v+XMDq6YPezNM+IReUMvcWmrWSTzP/GC0btCuZ5pJRkc+jJGVTXmi7OJbJFYU9tt292J9pXs9Rt3/R8d2ZYH1wPD49MWdY6SzDKB66Dof9VaLEKLD51xkhKgOt+sNID/qgFV7dCQpx2Y80gdcqYcXCgK22rSPONfIhPZOK+mzRfcoo7L6K0HJ0gCBktw5JNaGioytSlwleQ64FDc+h2CLodAcdWoPOp59LTi+DXHeY6QMA0iE59DoysJJehHlOaObKpezWKfbqFdvlxBA3nn2Ce/13iEr7PDIKCIGjeN/dGi4uL4+bNm2zdujXFPNjCN7CoCBZ/QN0J0u21C6vg/WuIfgEBk+HETHBoIXUoKFT2y/vLxKpb5eOffq7M8b/DihP3iU9UMMf/Dn8HP2NacyfKWubRdoiCIHwjtZPN8OHD0+yNBtIkSsOHD8+wwIRPTMyh1kioOQiCd8DZJfD8GiTGwZWN0qtoDSnp2DQEebrmw8s0cujL+a2BHQ0/lby59TyKW8+jaLo4kO41S9K/jjU59DOmv78gCN/fN1cQ0NHRoUCBAhQrVuybArl58yYtWrTg8OHDmJubK5ffvn2b6dOnc/HiRQwNDXFxcWHYsGHkz59fuc21a9eYPn06wcHBGBkZ0axZM/r06ZO9Bs/pGUL59lCuHTw6LXWdvrUXFEnw6JT0ym0pDRKt0AlyZM2xHGUt87DH14UlASEsPHqX+EQFy47f58D150xt7kS1kvm0HaIgCF8hU1QQCAkJwcfHJ8Uzn8ePH9O+fXvs7OyYO3cuERERzJo1i969e7NlyxYAHj58iJeXF+XLl2fu3LmEhIQop18dM2aMxmLWGpkMitWQXhGPPhUAXQMf38G7x3BoDARMBafWUi22grbajjjd9HV16FenNPUdzRm6/SqXH0fw4M172iw/Q7uqRRle35ZcorCnIGQp6brnEh0dzdKlSzl8+DBPnz5FT0+PQoUK4e7uTo8ePTA2Tl+tr4SEBLZs2cKsWbNSvQpZuHAhpqamrFixQtmtzsTEhPHjx/P48WMsLS1Zvnw5JiYmLF68GH19fdzc3DA0NGTixIn4+PhgZmaWrpiylDxFpWc6Pw2Hq1vgzFJ4fRvi30tdqYNWQ0l3qet0KY8sVwDU2syEHb/WYHVgKDMP3uZjfBIbz34q7NnUgdp22fjfVhCyGbW/fd6+fUvLli1ZsWIFADVr1qRKlSokJCSwfPlymjdvTmRkZLoOHhQUxMyZM/H29mbw4MEq6xQKBf7+/rRo0UKl/3atWrU4duwYlpaWAAQGBuLu7q4ywMvT05PExEROnjyZrniyLH0jqOQNvc9Cx51Qut7/190/ChtbwcKKUjKKzVrdiuU6MrrVLMnB/m7UsJJuoT2P/EjXNRfot/kSb6LF4EhByArUTjbz5s3j8ePHzJ07l7///puFCxeyePFi5X8/ffqUBQsWpOvgVlZW+Pv74+vrm6LYW1hYGNHR0ZibmzNmzBgqVapE2bJlGThwIG/fvgXgw4cPPHv2jBIlSqh81tTUFGNjY0JDQ9MVT5Ynk4FVLWi/FfpclG6j6X+qaxR+H/4ZBrPs4O/h6Mc80W6s6VQ0X042dKvKtOaOmBhKF+S7Lz/FY85x9lx5Kib1E4RMTu1kc/jwYdq2bYunp2eKdXXq1KFNmzb4+/un6+D58+cnX77UH/gmJ5Tp06fz7t075s2bx6hRowgMDKRv374AREVJv9JTu31nZGREdHR0uuLJVvJZQf1pMPAGeE6FvJ8SclwUnF2Cw5FOsLE1hByFLPJFLZPJaF25KP4D3fAoI91CC4+Jo++mS3Rfe4Hn7z5+YQ+CIGiL2s9sIiIiKFmyZJrrS5QowZs3GTcNcFycNFLe3NycuXPnKosW5s6dmz59+nDmzJkUVzT/ldpMop8THBz8dcFmdnpVwLkiuV+eo+B9P3K9DkKGQioIeucfPpgU52WJZrwpUgeFbtaowuxTBhxz5WbFpSgiY5Pwv/mSU3eP0LGsCXVK5EAnExS5DAoK0nYI2ZpoX83K6PZVO9kUKVKEM2fO0LZt21TXnzlzhkKFCmVYYMlXKzVr1lSpjuvs7AxIXaIdHR0BqQLsf0VHR6e7NLbWaqN9N1UAX3h5k1d7J1Lg6WFI+ECOqAcUuzqbYndXQ4XOUvfp3BbaDvaLKlWCjh5x/L73BjsvPeF9goJlQZFceavL1GZOFM+vvarAonaXZon21az01kZTh9o//Vu0aMGBAweYOnUq4eHhyuXh4eFMmTKFQ4cO0bRpU3V390WWllLZ+eQrnGSJiYmAdEvFyMgIMzMzHj58qLLNmzdviImJ+eKVzw+roB2Pyg6UbrHVGQe5PiWWD28hcC7MdYKtneHh6Ux/iy2vkT5zWpdjdZfKFM4tXZWduR+O57zjLD8eQkKiKHkjCJmB2snG29ubunXr8ueff+Ls7EzVqlWpWrUqzs7OrFmzhlq1atG9e/cMC8zIyIiKFSty6NAh4uPjlcuTi31WqlQJkK50jh49qpKUDhw4gFwuF7OLfklOU3AZAP2uQMs1ULS6tFyRCDd2wWpPWO4GlzdBQubu9eVuU5ADA1zpUE0q7PkxPonJ+2/RfMkpbj1PXy9JQRAyntq30XR0dJg/fz7Hjx/nyJEjPHnyBIVCQZEiRahVqxZubm4ZHtyAAQPw8vKiZ8+eeHl5ERYWxsyZM/Hw8KBMmTIAdOvWjX379tGjRw86d+7MgwcPmD17Nq1ataJw4cIZHlO2JNcF+ybS6+klaRrr4B1SSZxnV2BXT2mwaCVv6WWSOce3mBjqMbGJI42dCjPc7xqhr2O4EvaORvNP0su9FL3drTDQFSVvBEEb0l1Iq0iRIowcOVI5CPPixYsamzGvUqVK/Pnnn8yePZvevXtjYmJCixYtGDhwoHIbKysrVq1axfTp0+nbty958+alS5cu9OnTRyMxZXuFy0PTpeDxu1T88/xKiHkpvY5NhROzpMrU1XpK22ZCVUvm4+9+NZnrf5c/TtwnIUnB/MN3+edTYc/yRbNmKR9ByMrUnjzt48ePDBkyBH9/f/bs2UPp0qUB6erjn3/+oUmTJkyYMAFd3axXCFLrk6dpgdoPWBNi4fpOqRbbs8uq6yyrQVUfaYK3TFoA9FrYO4buuMrNZ9KtNJkMvJ1LMKiuNTn1NRezeICtWaJ9NUurk6ctWrSII0eO4OPjo9LrbPjw4fTt25e//vqLlStXqrs7IavQNYCybaBHAHgfBPumIPt0K+rxGdjeBeY5wYnZ8D78s7vSBkeL3OzxdWaQhzX6ch0UClh5MhTPuSc4de+1tsMThB+G2slm//79tG/fnv79+6sMojQzM+PXX3+ldevW+Pn5aSRIIROQyaBoVWj5pzSjqMuA/1eWjnwCh8fDbDvY0wde3NBqqP+lJ9ehT+3S7O/nQoWieQB4FP6edivOMnzHVd59iP/8DgRB+GZqJ5vXr19/titx6dKlefbsWYYEJWRyuS2kLtMDbkDj+VBQ6qxBwke4uBaWVIc1jeHWfkhK1Gqo/1aqoAnbetZgbOMy5NCTrs42n39M3TnHOHTjhZajE4TsTe1kU7RoUU6cOJHm+tOnT4veXz8a/ZxQsTP8ego67QGbBsCnAbihx2FzW1hQAU4vlqZAyATkOjK6OJfg4ABXapaW5kR6ERlL97UX8N14kdeisKcgaITayaZly5YcOXKEsWPHcu/ePeLj40lISOD+/ftMnjyZgwcP0qpVK03GKmRWMhmUdIO2m6DvRajWCwxySevePoADI2B2Gdg/FN6EaDXUZJamOVnrXYUZLZzI9amw596rz/CYfYydl8JEYU9ByGBqd8fp1KkT9+/fZ8uWLWzdulVlnUKhoGXLlnh7e2d4gEIWY1oSPKeA+2/SYNCzSyE8BOKi4dwy6VW6rlSR2qqWlKi0RCaT0bKSJW7WBRi9O5gD11/w9n08A7ZcYc/lp0xq6kjhPDm0Fp8gZCfp6vs5btw4OnbsSEBAAE+ePCExMZHChQvj5uaGrW3WmxFS0CADE6jaAyp3g5DDUtfpkMPSursHpVd+G6nrdNk20pw8WlIwlyHLOlZi/7VnjNl9ndfRsRy9/Yq6c44zrL4t7asURUdH+4U9BSErS/dAAysrK6ysrDQRi5Ad6ehAaQ/p9eq2VJ3gyiZpNtHXt2HfQKknW4VOUKWHNPuoljRwLEQNq3xM2HuTHRfDiI5NYPSuYP668pRpzZ0oocXCnoKQ1WWteYKFrK2ADTSaLRUArTsRcn9KLB/fwakFMK8sbOkADwK1VgA0T059ZrUqyxrvKhT5dAvtXGg4nnOPs/SYKOwpCF9LJBvh+8uRF2r0gX6XofV6KOYiLVckwc2/4M8GsKwmXFoP8dqZEM3NugAHBrjiVaM4MhnEJiQx9e9bNFkcyI2norCnIKSXSDaC9ujIwa4xdNkHPiegXAeQfyp58fwa7O4Nc+zhyESI/P5juIwNdBn3sz1bfapTsoB0Cy34SSQ/LzzJrIO3iU3IPGOIBCGzE8lGyBwKOUGTRdIttlqjwORTSaT3r+H4DJjrANu7QtiF7x5a5eKm7O9bk14/WSHXkZGQpGDBkXs0nH+SoIeZr0SPIGRGaieb8+fPq0ya9l/Pnj1jz549GRKU8AMzyg+uQ6DfVWi+EopI8xaRlADB22FFbfijNlzbDonfr8yMoZ6coZ627O7tTJlC0hiiey+jabH0NOP2XCcmNuG7xSIIWZHayaZTp06cOnUqzfUnT55k9OjRGRKUIKCrD44toPth6HYYHFuCzqfOk08uwI6uMNdRuuqJ+X4FNR2K5Ga3rzNDPW3Q15UKe/556gH15h7nxN1X3y0OQchq0uz6/PjxYxYvXqx8r1Ao2LJlC4GBgSm2VSgUnDt3jly5cmkmSuHHZlEJLFaAxwS4sFKaZ+f9G4h6Jj3POTYDnFpKA0XNHTUejp5ch14/laKevTnDd1zl/IO3hL39QMeV52hVyYKRDcpoPAZByGrSTDaWlpa8fPlSmVxkMhnnz5/n/PnzKbbV0dHB1NSUwYMHay5SQchVSHqeU3OwdEvtzFJ4cQ0SY6Wea5c+9Wyr1lOq06aj2Vk5rQoYs6VHddaffci0v28RE5fI1gthHL39ii6OORDTrQjC/312UOe/56extbVlxowZNG7cWONBCcJn6RlC+Q5Qrj08DJSqE9zeL3WdfnhSeuUpKg0SLd8RcuTRWCg6OjI6VS9OLduC/LYzmON3XvEqKpbpp2K5HnWRcT/bU8Dkx5iQTxA+R+1nNocPH6ZOnTqajEUQ0kcmg+Iu0GYD9L0sjd0xzC2ti3gEB0dJc+zsHQiv7mg0FIu8OVnTpTKzWpYldw5pyvR9155RZ/YxtgeJwp6CoHayKVKkCDly5ODIkSOMGTOGbt26cePGDUJDQ9m4cSOxsaI0u6BFeYtJVQkG3ICGsyC/tbQ8/r30nGdRZVjXDO4egiTNVAGQyWQ0r2iB/0A3qltIVzPvPsQzeNsVOq8+T9jb9xo5riBkBWonm/j4eH799Vd69+7Njh07CAwM5N27d9y8eZPff/+d9u3b8+5d5pizRPiBGRhLxT97nYUOO6CUx//XhRyGDS2kxHN2OcRGaySEAiYGDK6el6UdKihvoR2/IxX2XHPqAUlJ4ipH+PGonWyWLFnCsWPH+P333zl8+LDytkDdunUZOXIkt27dYtGiRRoLVBDSRUcHStWBDtvB9wJU7g56nwppvrkHfw+RbrH98xuEh2okBE+HQvgPcKNlRQsA3sclMnbPdVotO03IK80kOkHIrNRONnv27KF58+a0bNkSA4P/P/DU1dWlY8eOtGrVisOHD2skSEH4JvlLQ8OZMOgm1JsMeYpJy2Mj4cwimF8eNrWTZhfN4GcruXPqMaNlWdZ3rYpFXqmw54WHb6k/7wSLjt4jXhT2FH4Qaieb58+f4+DgkOZ6GxsbXr0Sg9qETMwwN1TvDX0vQZtNULzmpxUKuL0P1jSGpS5wcS3Ef8jQQ7uUzs+B/q50cZYKe8YlJDHjwG2aLAok+Im4/Sxkf2onGzMzM+7fv5/m+qtXr1KgQIEMCUoQNEpHDrYNwGsv9AyU5tLRNZTWvQiGPX2kaawP/w7vnmTYYY0MdBnb2J7tPWtQqqAxANefRvLLokCm/3OLj/GisKeQfamdbBo1asSWLVtUStbIPk3pu2HDBnbu3Imnp2fGRygImmTuAD8vkHqx1R4DJoWl5R/C4cQsmOcE27rA43MZdoutYrG87OvrQp9apdDVkZGYpGBxQAgN5p/gwgNR2FPIntRONr1796ZcuXJ07dqVRo0aIZPJGDduHNWqVWPChAnY29vTu3fvrw7k5s2b2Nvb8/z58zS3mTx5MmXKpCwFcu3aNTp27Ej58uVxcXFh9uzZxMd/vyKNQjZglA9qDoL+V6HFKrCoIi1PSoDrfrDSA/6oBVe3QkLcNx/OQFfOoLo27PF1wbGINDbo/qsYWi47zdjdwUSLwp5CNqN2stHX12fVqlVMmjQJR0dHSpYsCYC9vT2jR49mw4YN5MyZ86uCCAkJwcfHh4SEtP8HO3/+PGvXrk2x/OHDh3h5eWFgYMDcuXPx9vZm9erVTJky5atiEX5wcj1waA7dDkH3I+DUGnSkQZo8vQh+3aXpDgKmQfS3P6MsUzgXO3vVYJinLQafCnuuOf2QenOOc+yOeAYqZB+fLVfzXzo6OjRr1oxmzZqluv7JkycUKVJE7f0lJCSwZcsWZs2ahZ6eXprbxcTEMGLECMzMzFJ0Qli+fDkmJiYsXrwYfX193NzcMDQ0ZOLEifj4+GBmZqZ2PIKgokhFaLYcPH6Xin9eWAUxryD6BQRMhhMzwaGFVIutUNmvPoyuXIdff7Kinr0Zw/2ucS40nCcRH+i86hzNKhRhTKMy5Mmpn4EnJgjfn9pXNp+7UkhMTGT58uU0atQoXQcPCgpi5syZeHt7f7aI5/Tp08mfP3+qSS4wMBB3d3f09f//P6OnpyeJiYmcPHkyXfEIQqpMzMH9NxhwHZosAXMnaXliHFzZCMtcYZUnXN8FiV9/+6tkAWM2d6/GxCYOGBtIvwP9Lj6hzuxj7L/2/WcqFYSMpHayWbNmDePGjUux/PLlyzRt2pTZs2djYWGRroNbWVnh7++Pr68vcnnqFXoDAwPZvXs3U6ZMQUdHNdwPHz7w7NkzSpQoobLc1NQUY2NjQkM1M1hP+EHpGkC5duBzHLr8DXY/g+zT3+Sj07CtM8wvByfnIo+L+qpD6OjI6FCtGAcHuOJuI/XufB0dR68NF/FZd4GXkR8z6GQE4ftSO9kMGjSIzZs3M2LECBQKBVFRUYwZM4Z27doRFhbG0KFD2bVrV7oOnj9/fvLly5fm+qioKEaOHEnfvn1TJJTk9QDGxsYp1hkZGREdLUZpCxogk0GxGtB6nTSjqHM/MMwjrXv3GPzH4ujfGv7qDy9vfdUhCufJwSqvysxtXY68OaVbzAeuv6DO7GNsvfBYFPYUshy1n9l0796dPHnyMG7cOF68eMGdO3d4/fo1DRo0YNiwYRp5NjJ58mTMzc3x8vJKdf2X/of775XQlwQHB6dr+6wuKChI2yFkD6a/oONeF9MwfwqG+pEj+iHyxI8QtBqCVhOZvyIvSzbjXcGq/78SUpMlMKt2HlZejiLw8UciPyYwdPtV1h+/Rc9KuTAzStdj12xF/P1qVka3b7r+Ulu2bEmePHkYNGgQiYmJLFu2DDc3twwNKNnRo0fZt28fO3bsICkpSfkCqWOBjo6O8oomJiYmxeejo6MxMTFJ1zEdHBxUSvFkZ0FBQVQUs3tlrKouoBgL9wOIODiVPC/OAgpyvQ4i1+sgyFsCqvpI8/AYpm9W21rOcPD6c0btCuZlVCxXX8Yx6NBbhtSzoXON4sh1ZJo5p0xK/P1qlrrtGxsbq/aP9DSTTWozcgLkyZOHbt26sXjxYtauXYuRkZHKFUblypXVOvCXHDhwgNjY2FQ7Hdjb2+Pr60ufPn0wMzPj4cOHKuvfvHlDTExMqrfeBEGjZDKwciekSi4qFs8D55bDpQ0QFwVvQ+Gf4XBkEpRvL03uls9K7V3XtTenasl8TNl/k83nH/MhPpHf995g79WnTG/hRKmC6ftxJQjfU5rJpmPHjsoKAWkJDAxUVhRQKBTIZDJu3ryZIYH5+vrSvn17lWVbt25lx44dbNmyhYIFCwLg7OzM0aNHGTp0qLJH2oEDB5DL5VSpUiVDYhGEr5LPCupPA/eRcHkDnF0mJZy4KDi7VHpvXU+62inpLiWqL8idQ4+pzZ1oXLYwI/yu8Sj8PRcfRdBg3kn61i6Fj5sVevL03aoThO8hzWSj7UGRFhYWKXq3BQQEAODo6Khc1q1bN/bt20ePHj3o3LkzDx48YPbs2bRq1YrChQt/z5AFIXWGuaDar9KVzN1DcHYJ3A8AFHDnH+lVwFZKOk5tQP/Lg6OdS+Xnn/41mX3wDqsCQ4lLTGLmwTvsvfqMGS3K4miRW+OnJQjpkWayadq0qVo7CA8PJ2/evF+8CtIUKysrVq1axfTp0+nbty958+alS5cu9OnTRyvxCEKadORg4ym9Xt6Urm6ubIGED/DqFuwdAP7joWJnaf6dPJaf3V1OfV1GNSpDQ6dCDN1+lbsvo7n1PIomiwPpXrMk/euUxlAv9SEFgvC9yRTp6EO5fv16li1bxsaNG7G0lP5HGD58OMeOHWPYsGE0adJEU3FqVPJDLtFBQMgoarfv+3BpSoNzf0Bk2P+Xy+Rg1wiq/gpFq33xFltsQiKLjoawJOAe8YnS/9Il8hsxtZkjVUumPbwgqxJ/v5qV3g4C6nx3qn1zd9u2bUycOJFixYqhq/v/C6IGDRpgZ2fHiBEjOHjwoLq7EwQBIKcpuPSHfleg5RooWl1arkiEG7thtScsd4PLmyAhNs3dGOjKGehhzV99XCj76RZa6OsYWi8/w6hd14j6KArTCtqldrJZu3YttWvXZv369RQqVEi53NXVlVWrVuHm5sayZcs0EqQgZHtyXbBvAt7/QI9jULYdyD+VYHp2BXb1hDn2cHQyRL1Icze25rnw6+XMyAZ2GOpJ/3uvP/OIenOOc/TWy+9wIoKQOrWTzePHjz87psbd3f2zk6sJgqCmwuWg6RKpFttPv4HxpwHTMa/g2DQp6fj1gCcXU/24XEdGd9eS/NPPlWolTQF4+u4jXf48z4AtlwmP+fYpEgQhvdRONnnz5uX27dtprg8NDU21bIwgCF/JuCD8NAz6B0PT5VC4vLQ8KR6uboE/3GFlXQj2g8SUt8mK5zdiY7dqTG7qiMmnwp47Lz3BY/Yx/rryVJS8Eb4rtZONh4cHW7ZsYf/+/SnW+fv7s3HjRjw8PDI0OEEQAF19KNsauh8F74Ng31TqQADw+Cxs7wLzykozi75XnelTR0dGu6pFOTjQldq20ti0NzFx9Nl0iR7rgnghCnsK34na5Wr69u3L2bNnGTRoEJMmTcLS0hKZTMbjx4958+YNpUuXpn///hoMVRB+cDIZFK0qvd49gfMrIOhPaQrryCdw+Hc4Nh2cWkm92Mz+P6ttodw5WNG5EnuuPGX8XzcIj4nj0I0XnLn/hpEN7Ghd2VJrwxeEH4PaVzbGxsZs376d0aNH4+DgQHR0NBEREdjY2DB8+HC2bdtGrlzpq/ckCMJXyl0E6oyFgTeg8Xwo+CmxJHyUulIvqQ5rGsOt/ZCUCIBMJuOXckXwH+jGL+WkAc9RHxMY7neN9ivO8ujNe22djfADSFchTj09Pdq1a0e7du00FY8gCOmhl0MaBFqhE4QelwaK3v4bUEjvQ49D3uJQxUeqx2aYG1Mjfea1Kc/PZQszcmcwzyM/cirkDXXnHmNwXRu6OJf44Qp7CpqXZrJ5+vQppqamGBoaKt+rQ5SIEQQtkMmgpJv0Cg+VBoleWgexkfD2ARwYAUcnSZO/VfGB/KWobWdG5RKmTP37FhvPPuJjfBIT991k79VnTG/hhLWZKOwpZJw0k03t2rWZPn06jRs3BqBWrVpq3dPNqEKcgiB8JdMS4DkZ3EdIg0HPLoXwEIiLlqpQn1sOpetC1Z7ksqrF5KaONHYqzHC/qzx8857LjyNoOP8Evu6l+fUnK/R1RWFP4dulmWx69+6NjY2NynvxAFEQshADE6jaAyp3g3v+UgHQkCPSursHpVd+a6jqQ/Wybfmnnytz/O+w4sR94hMVzPG/w9/Bz5jW3Imylnm0eipC1pdmsvH19VV5r05hy7g4MVhMEDIdHR2wriu9Xt2Wpja4sgni38PrO7BvEBz+nRwVOvFbjR40cnJm6Par3Hoexa3nUTRdHEi3miUZUMeaHPqisKfwddS+Pq5duzaHDx9Oc/3evXupWbNmhgQlCIKGFLCBRrOlXmweEyB3UWn5x3dwagHMK4tToC9/NZYxsE5p9OQykhSw/Ph9POcd53TIG+3GL2RZaV7ZhIeHExISonz/5MkTrl27lmr35qSkJA4dOiSubAQhq8iRF5z7QrVecHu/dLXz8CQokuDmX+jd/Iu+5o60qutFn2tWnA97z8M372n7xxnaVS3K8Pq25DLU0/ZZCFlImsnGwMCAQYMG8erVK0Dqo79s2bI0i20qFAoaNGigmSgFQdAMuS6U+Vl6PbsqJZ1r2yAxFp5fw/z5ILbmzM9lu6b0u1eBR/G52Xj2EUduvmRSUwdq25lp+wyELCLNZGNkZMSSJUu4c+cOCoWC3377jVatWlG+fPkU2+ro6GBqakr16tU1GqwgCBpUyAmaLAKP8RC0Gs6vhKhnyN6/pnzoHxzT0+WUcU2mR7hzJbIUXddc4OeyhRnbuAz5jH+MeaCEr/fZQZ329vbY29sD0jibunXrYm1t/V0CEwRBS4zyg+sQqNEPbu6BM0vgyQVkSQk4fzjKboOjXKE0K+Pqsf9KFU7ee83YxmX4uWxh0WNVSJPaFQT+2ztNEIRsTlcfHFtIr7ALUtK5sQuSEijLXebr3+U3RV7WffRg/OZa7L5ciklNHSiUO4e2IxcyITFaSxCEL7OoBC1WQv9rUHMw5JSmmjaXvWWI3lZOG/Sh3r2J9J69jg1nH5KUJKYvEFSJZCMIgvpyFYbao2HADfhlEZg5AmAgi6e1bgB+siFY7WvNnAWzePAyUsvBCpmJSDaCIKSfniGU7wA9T4DXPrBthEImfZ1U07nJoLcT0F1UnjPrx5IQHf6FnQk/ApFsBEH4ejIZFHeBNhuQ9b1MXJXefJBLBTwtZK+pdm8uCTNtebvVF17d0XKwgjapnWw6derE6dOn01x/5MgRGjZsmCFBCYKQBeUthn6DyeQYeosHVSfwUGYBgCGx5L2xDhZVJmltE7hzEJKStBur8N2l2Rvtw4cPvH37Vvn+3LlzeHh4UKxYsRTbJiUlcfz4ccLCwjQTpSAIWYeBMcXr9+Vj7V/Z6reBgjdW85POZQB07h+F+0chXylpqoNybaWCoUK299lk06RJE6KiogCpgsDkyZOZPHlyqtsrFAqcnZ01E6UgCFmOob4erdp4cS2sKd227qdm+A5ayI9jJIuFN/fg7yFwZAKU7whVuktTIwjZVprJxtTUlBkzZnDt2jUUCgWLFi3Cw8NDZdqBZMkVBMRtNEEQ/svRIjdL+rVm2bFK1Dx8laYcobP8AEV1XkmTu51ZBGcWg00DqNYTiteUngUJ2cpnB3W6ubnh5uYGSBUE2rRpQ9myZTUSyM2bN2nRogWHDx/G3Nxcufzvv/9mxYoV3L9/n1y5clGjRg0GDx5Mvnz5lNs8ePCAqVOncuHCBeRyOZ6engwZMgRjY2ONxCoIQvroyXXwrVUaTwdzhm43Z/UjT2rrXKSL/B9qyG8ACri9T3oVtIeqPuDUSpr2WsgW1O4gMGXKFI0lmpCQEHx8fEhISFBZvn//fvr374+9vT0LFiygf//+nDlzBi8vL2WF6Xfv3tG5c2dev37NtGnTGDRoEPv372fQoEEaiVUQhK9XqqAJ23rWYExjBwJ1q9IufhT1YqeyS6cOifJP9dVeXoe/+sLsMuA/Ht490W7QQoZI88qmU6dO6d6ZTCZjzZo1am+fkJDAli1bmDVrFnp6KcuVL1u2DDc3N37//XflspIlS9KqVSuOHz9OnTp12LBhA5GRkezatYu8efMCYGZmRo8ePbhy5YrGEqQgCF9HriPDy7kEte3M+G3nNU7chf7vvRlPC8ZbXKDhx33Io5/Bh3A4ORsC50lVqav+CpZVxC22LCrNZPM9epYFBQUxc+ZMunbtipmZGaNGjVKuUygU1KhRg4oVK6p8pmTJkgA8evQIgMDAQCpXrqxMNAAuLi4YGRlx7NgxkWwEIZOyNM3JWu8qbA8KY8LeG7z9mIu+YbX4PUdtFld6SuUXW5E9PguKRLi+U3oVLg9Vf0WWlLJXrJC5pZlsjhw5ovGDW1lZ4e/vT758+fDz81NZJ5PJGDZsWIrP+Pv7A1CqVCkA7t+/z88//6yyjVwux8LCgtDQUA1FLghCRpDJZLSsZImbdQFG7w7mwPUXvP6goNXJQrjbTGR620QKXF8NwX6QFA9PL8HOHjgamEKMD1TyBuOC2j4NQQ1qV33WhPz586dr+0ePHjFt2jTs7e1xcXEBICoqKtWOAEZGRkRHR6dr/8HBwenaPqsLCgrSdgjZmmjf9OlRRoZjrjysuBhJRGwSR2+/omaIjI5OHWlQqwVmj/6iwIO/0It7i15sOARMIen4TN4WdudFiWZ8yCOmP8lIGf33q3ayUfcZztq1a786mM8JCQmha9eu6OrqMnfuXHR0vty3QZ1t/s3BwQEDgx9jEqigoKAUtyiFjCPa9+tUrAgdPOKYsPcmOy6G8TFBwR8XI7kSbsrU5lPQyzsTgv2IOToLo3d30UmKJ1/YQfKFHYSi1aFqT7BtJM1AKnw1df9+Y2Nj1f6Rrva/SGrPcJKSknj79i2xsbEUKVKE0qVLq7u7dDl79ix9+vQhZ86crFmzhqJFiyrXGRsbExMTk+Iz0dHRFC5cWCPxCIKgOXly6jOrVVl+LleY3/yu8STiA+cehOM57wQD6ljTvWZrbiWUpmKBeDi7FG7+JT3XeXRaeuW2hMrdoEInyGmq7dMRPlE72aT1DCcxMZHDhw8zatQounbtmmGBJdu/fz9Dhw6lRIkSrFixAjMz1TnPS5QowcOHD1PEFBYWRr169TI8HkEQvg836wIcHODKjAO3WXP6AXEJSUz75xb7rj2lSxk9KlaqDsWqQ8RjOL8Cgv6EjxHw7jH4j4WAqVC2tXS1U9BO26fzw/vmqs9yuZy6devSsmVLZs6cmRExKZ04cYLBgwdTvnx5Nm3alCLRADg7O3P27FkiIiKUy06ePMn79++pUaNGhsYjCML3ZWSgy7if7dnmU52SBYwACH4SyVD/N8w8cJuP8YmQxxI8xsPAm9BoLhT4lFgSPkgJaHE1WPsL3P5HFADVogybYqB48eLcunUro3ZHXFwcI0eOxMjIiJ49e3Lv3j0uX76sfL148QKAdu3aoa+vj5eXF4cOHWLbtm0MGTIEV1dXKlSokGHxCIKgPZWKm7K/b016u1sh15GRqICFR+/RcP4Jgh5+mi9HPydU6gK9TkPHXWDtCXwak3M/ADa1hgUVpOmtP4qJ3b63DHmKFhcXx549e1RKyHyrK1euKBOKt7d3ivX9+vWjV69emJqasnbtWiZPnszgwYMxMjLC09OToUOHZlgsgiBon6GenCH1bKnvUIg+684QGpFAyKsYWiw9TefqxRlSzwYjA11p0KeVu/R6EwLnlsOlDRAXBW9D4Z/hcGQSlG8PVXpAPittn9oPQaZQKNSaLDyt3mhxcXGEhoYSGRlJnz596NWrV4YG+D0k96gQvdGEjCLaV7POnr9AUEwe5vrfJS5BujVmkTcHU5o5UrN0gZQf+BgJlzdKHQre/nv8nQys60nPdUr+JKoTfJLe3mjqfHd+U280kJ7ZlCxZkkaNGtGuXTt1dycIgvDVdHVk9PqpFPXszRm+4yrnH7wl7O0HOq48R8uKFoxqWIbcOf9VAsswl1RRukoPuHtQSjr3jwIKuPOP9Cpg96kAaGvplpyQob65N5ogCIK2WBUwZkuP6mw4+5Cpf98iJi6RbUFhBNx5xYRfHPB0MFf9gI4O2HhKr5e3pKRzZbPUmeDVTdjbH/zHQcXOULm71PlAyBAZ1kFAEARBG3R0ZHSsXpwDA1xxs5Zuob2KiqXn+iB6bQjiZdTH1D9Y0BYaz4WBN6DOeGl8DkjdpwPnwbyysLUTPDwN6j1tED5Dq1WfBUEQMopF3pz82aUyOy894fe9N4h4H8/+a88JvPeG0Y3K0LxCEWSpPZPJaQou/aG6L9zaC2eXwaNT0kDRG7ulV6GyUtVph2ag+2M8181o6ar6/ObNG2JjY8mdOzfFihUjKSmJJ0+e8PbtW/LkyYOVlejVIQiC9shkMppVsKBm6QKM23Odfdee8e5DPIO3XWHPladMbuqARd40nsfIdcG+ifR6ellKOsHbITEOnl2BXT3h0Gip+GelrmCSctyfkDa1qz4fOXKE/v37M3XqVH7++WeVumN79+5l1KhRtG/fXnORCoIgqKmAiQGL2legcfBzRu8O5lVULMfvvKLunOMM87SlY7Vi6Oh8pudZ4XLQdIk0WPTCariwEqJfQMwrODYNTsyWrnKq9oQiYjyfOtR+ZjNnzhxat25NkyZNUhS4TO6JNm/evAwPUBAE4Wt5OpjjP8CNlhUtAHgfl8jYPddptew0916qURXeuCD8NAz6B0PT5dJ8OiBNd3B1C/zhDivrQvAOSIzX4JlkfWonm0ePHlG8ePE015ubm/Py5cuMiEkQBCHD5M6px4yWZVnftSoWeXMAcOHhWxrMO8Gio/eIT1SjhI2uvlRnrftR8D4I9s1AJpfWPT4L272lDgUnZkHMGw2eTdaldrIpUaIE+/btIzExMcW62NhYduzYgY2NTYYGJwiCkFFcSufnQH9XujgXRyaDuMQkZhy4zS8LAwl+8k69nchkULQqtFwN/a+By0DI8amydOQTOPw7zCkDu33hxXXNnUwWpHay6dGjBxcvXqRdu3Zs2bKFU6dOceTIEVavXk3jxo0JCQmhT58+moxVEAThmxgZ6DK2sT3be9agVEFp0sUbzyL5ZVEg0/65JRX2VFfuIlBnrNR1uvF8KFhGWp7wES6tgyU14M9GcGsfJKVjv9mU2oM6GzRowMePH5k1axZjx45VdiFUKBQUKVKEhQsX4uzsrLFABUEQMkrFYnnZ19eFRUfusTgghIQkBUsCQjgQ/JxpLZyoXDwd8+Do5ZAGgVboBA9OwJmlcHs/oJDePzgBeYpJ1QsqdATD3Bo7r8wsXYU4mzVrRpMmTQgODubp06fIZDIsLS0pU6aMpuITBEHQCANdOQPr2lDfsRBDt1/l2pN33H8dQ8ulp+lUvRhDPW0xNkjHV6RMBiVcpVd4KJz7Q7rCiY2EiIdwcCQcnQzl2km92PKX0tzJZULpriCgo6ODk5MTnp6e1KtXTyXRhIeHZ2hwgiAImmZXKBc7e9VgRH1bDHSlr8S1px9Sb85xAm5/Zacn0xLgOVm6xVZ/Bph+GoMYHwPn/4CFFWF9C7jn/8NUJ0jXlc2mTZs4ceIE79+/J+lfkxAlJiYSExPDvXv31J6PWhAEIbPQlevg42aFRxkzhvtd41xoOE8iPuC1+jzNKhRhdMMy5DXST/+ODUygag9pmup7/lIttpDD0rp7h6RXfmvpFlvZtmBgnLEnlomonWz++OMPZs2ahb6+PsbGxrx9+xZzc3MiIiL48OEDhoaGdOzYUZOxCoIgaFTJAsZs7l6NjeceMfXvW0THJuB38QnH77zi918cqO9gnnrJmy/R0QHrutLr1W2pOsGVTRD/Hl7fgf2D4fAE6ZlOlR6Qt1jGn5yWqX0bzc/PDzs7O06dOsWWLVtQKBSsXbuWCxcuMGbMGGJjYylbtqwmYxUEQdA4HR0ZHaoV4+AAV9xtpMKer6Pj6LXhIj3XB/EyMo3CnuoqYAONZku32DwmQO6i0vLYd3B6IcwvB5vbw4OT2eoWm9rJ5smTJ/zyyy8YGxtjaWlJ7ty5uXDhAnK5nHbt2tGgQQNRhFMQhGyjcJ4crPKqzNzW5cj7aW6cA9dfUGf2Mbaef4ya806mLUdecO4L/S5D6/VQzEVarkiSCoL+2RCW1oRL6yH+GxNcJqB2stHV1cXIyEj5vlixYty+fVv5vmrVqjx48CBDgxMEQdAmmUxGk/JFODTQjcZlCwMQ+TGBoTuu0nHlOR6Hv//2g+jIwa4xdNkHPiegXAeQf6os/eIa7O4tDRQ9PAEin3378bRE7WRjZWXFpUuXlO9LlCih0hng3bt3xMXFZWx0giAImUB+YwMWtC3PH50qYZZLSgQn772m7pzjrDoZSmJSBt3uKuQETRZJt9hqjQKTQtLy92/gxEyY6wDbu0LYhYw53nekdrJp1qwZfn5+DB48mPfv31OrVi0uXLjAwoUL2b9/P2vWrMHW1laTsQqCIGiVRxkzDg5wo20VaaK1D/GJ/L73Bi2XnuLui6iMO5BRfnAdIpXEab4SilSSliclSNMerKgNf9SCq9sgIWv8yFc72bRt2xYfHx8CAgLQ1dWlbt26/PTTTyxcuJCBAwfy8eNHBg8erMlYBUEQtC53Dj2mNHNiY7eqFDWV5sa5+CiChvNPsuDwXfUKe6pLrgeOLaD7Yeh2GBxbgs6nTsRPgsCvG8x1hGMzIOZ1xh1XA2SKdD7lSkhIQFf3/z2mL1y4QEREBOXLlydfvnwZHuD3EBsbS3BwMA4ODhgY/Biz8AUFBVGxYkVth5FtifbVrMzSvh/iEpl18DarAkNJvpNma27C9BZOOFnk0cxBI59J8+tcWA3v/5Vg5AZSMqrWE8wdv+kQ6rZver47011B4N+JBqBSpUrUqVMnyyYaQRCEr5VDX86oRmXY8WsNrM2kAZm3nkfRZFEgU/6+mb7CnurKVUh6njPgOvyy+P+JJTEWLq+HpS6wuiHc2JOpCoCmO9kIgiAIqsoXzcvePjXpV7s0enIZSQpYduw+9eed4Mx9Dc1vo2cI5dtLPdi89ks92mSfvtIfnoStHWFeOQicDx/eaiaGdBDJRhAEIQPo6+owwMOavX1qUtYyDwChr2Nos/wMI3deI+qjhmbylMmguLM0VqfvZajR5/+Vpd89gkOjYXYZ2DsQXt3RTAxqyDTJ5ubNm9jb2/P8+XOV5SdPnqR58+aULVuWWrVqsWrVqhSfvXbtGh07dqR8+fK4uLgwe/Zs4uPFFK2CIHx/NuYm+P1ag1EN7TDUk75iN5x9RN05xzl6S8OzGectBnUnwsCb0HA25P80oWX8e+k5z6LKsK4p3DkISRnYkUENmSLZhISE4OPjQ0JCgsryixcv0rNnT0qWLMmCBQto3Lgx06dPZ+XKlcptHj58iJeXFwYGBsydOxdvb29Wr17NlClTvvdpCIIgACDXkdGtZkkO9Heleknpefazdx/p8ud5+m++RHiMhrsr6xtB5a7Q+yx08IPSdf+/LuQIbGwpJZ6zyyE2A7tsf4ZWk01CQgIbNmygZcuWxMbGplg/f/58ypQpw4wZM3B1dWXAgAF07dqVpUuXKgeQLl++HBMTExYvXoybmxve3t6MGDGCzZs38+LFi+99SoIgCErF8hmxsXtVpjRzxOTT3Di7Lj/FY/Yx/rry9NtL3nyJTAalakP7beAbJBX51P9UWfrNPfh7iHSL7ULKO0YZTavJJigoiJkzZ+Lt7Z1ijE5sbCwXLlygbt26Ksvr1atHZGQkFy9eBCAwMBB3d3f09f9f/tvT05PExEROnjyp+ZMQBEH4DJlMRtsqRTk00I06dgUBeBMTR59Nl+i+Nojn775T3bP8paDBDKk6Qb0pkLe4tDw2Eg6N0/jhtZpsrKys8Pf3x9fXF7lcrrLu8ePHxMfHU6JECZXlxYpJpbdDQ0P58OEDz549S7GNqakpxsbGhIaGavYEBEEQ1GSe25A/OlViftvymH6aG8f/5gs8Zh9j07lHmr/KSWaYG6r3gj4Xoc0mcGoD9SZq/LDpmjwto+XPnz/NdVFR0n1EY2PVyYSSi4FGR0enuU3ydtHR0emK50eb+C0oKEjbIWRron01K6u2bxFgVu08rL4cyfFHH4mKTWCE3zU2nLjNr5VyYW78Pb+WzaBYD1AA/2nPjG5frSabz/lSltfR0VFrm/QQFQSEjCLaV7OyQ/u614Ajt14wcmcwz959JPhVHIP8wxlc14YuziWQ63zFJG0ZJL0VBNSRKXqjpcbExASAmJgYleXJVysmJibKK5r/bpO8XfI+BEEQMqNatmYcHOBKu6rSBGof45OYuO8mzZac4vbz79NL7HvJtMmmaNGiyOVyHj16pLI8+X2JEiUwMjLCzMyMhw8fqmzz5s0bYmJiUjzLEQRByGxMDPWY3NSRzT2qUTyfVNjzyuMIGi04wVz/O8QlfN/xMJqSaZONgYEBlSpV4uDBgyq3yw4cOICJiQkODg4AODs7c/ToUZW5dA4cOIBcLqdKlSrfPW5BEISvUa1kPv7u50oP15LoyCA+UcFc/7s0XnCSK48jtB3eN8u0yQbg119/5eLFiwwYMIBjx44xd+5cVq5ciY+PDzly5ACgW7duvHr1ih49enD06FHlgM5WrVpRuHBhLZ+BIAiC+nLoy/mtgR07ezljay49Brj9IoqmiwOZtO8GH+IyT2HN9MrUyaZ69eosWLCAkJAQevfuzV9//cXQoUPp3r27chsrKytWrVrF+/fv6du3L6tXr6ZLly6MHDlSi5ELgiB8vbKWedjj68JAD2tlYc8/ToRSb+5xToVk7nlr0pLu+WyyIzGfjZDRRPtq1o/UvndeRDFsx1UuPYpQLmtbpSgjGtiSy1BPI8fMFPPZCIIgCN+PtZkJ23vWYEyjMuTQkwa/bzr3CI/Zx/C/kXVKcolkIwiCkMnJdWR4u5Tg4ABXXEpJg+FfRMbSbe0F+my6xJvolLUlMxuRbARBELIIS9OcrOtahenNnTAxlMbk/3XlKXVmH2P35Sffr+TNVxDJRhAEIQuRyWS0qmyJ/0A3PMqYAfD2fTz9Nl+m65oLPHv3QcsRpk4kG0EQhCzILJchyztWZFG7CuQ3lgp7Hrn1Eo/Zx9lw9iFJSZnrKkckG0EQhCxKJpPR0KkQhwa40bR8EQCiYxMYuTOYtn+cIfR1ylJe2iKSjSAIQhaX10ifOa3LsbpLZQrnNgTgbGg4nnOPs/x4CAmJ2i95I5KNIAhCNuFuU5CDA93oVF2a9ys2IYnJ+2/RbMkpbj6L1GpsItkIgiBkI8YGuvz+iwNbfapTMr80/9fVsHc0XnCS2QdvE5ugnZI3ItkIgiBkQ1VKmLK/X01+/ckKuY6MhCQF84/co9H8k1x89Pa7xyOSjSAIQjZlqCdnmKctu3o5Y1coFwB3X0bTfMkpJuy9wfu4hO8Wi0g2giAI2ZyjRW72+DozpJ4N+nIdFApYeVIq7Bl47/sU9hTJRhAE4QegJ9eht3sp9verScVieQF4HP6B9ivOMufQHY0fXyQbQRCEH0ipgsZs86nOuMZlyKkvFfb889QDjZe60dXo3gVBEIRMR0dHhpdzCWrbmbH+zEPKF82DTCbT6DFFshEEQfhBWZrmZEQDu+9yLHEbTRAEQdA4kWwEQRAEjRPJRhAEQdA4kWwEQRAEjRPJRhAEQdA4kWwEQRAEjRNdn0E5mCkuLk7LkXxfsbGx2g4hWxPtq1mifTVLnfZN/s5UZ0CoTKHpYaNZQFRUFHfuaL5cgyAIQnZkbW2NiYnJZ7cRyQZISkoiJiYGPT09jY+iFQRByC4UCgXx8fEYGRmho/P5pzIi2QiCIAgaJzoICIIgCBonko0gCIKgcSLZCIIgCBonko0gCIKgcSLZCIIgCBonko0gCIKgcSLZCIIgCBonkk02dPPmTezt7Xn+/Hma20yePJkyZcqkWH7t2jU6duxI+fLlcXFxYfbs2cTHx2sy3Cwnrfa9ffs2Xbt2pXz58lSvXp0hQ4bw+vVrlW1E+35ZWu174MABmjRpQrly5ahXrx5//vknSUlJKtuI9k1dUlISmzZtonHjxpQvX546deowZcoUoqOjlduo03YPHjygZ8+eVKpUiapVqzJ27FiVfXyWQshW7t27p6hZs6bC2tpa8ezZs1S3OXfunMLGxkZhZ2ensvzBgweKChUqKLp27aoICAhQrFy5UuHg4KAYP3789wg9S0irfR89eqSoWLGiokOHDoqAgADFrl27FDVr1lS0atVKuY1o3y9Lq31PnDihsLa2VgwdOlQRGBioWLx4scLW1lbxxx9/KLcR7Zu2ZcuWKezs7BQzZ85UBAYGKtavX6+oUqWKwtvbW6FQqNd2ERERCldXV0Xz5s0V/v7+ii1btigqVaqk6NGjh1oxiGSTTcTHxyvWr1+vKF++vKJKlSppJpvo6GhF7dq1Fa6urimSzW+//aZwc3NTxMbGKpdt2LBBYWdnp3j+/LnGzyEz+1L7Dh06VOHh4aH4+PGjctnhw4cVrq6uikePHikUCtG+n/Ol9h04cKCiTp06isTEROWyIUOGKNzd3ZXvRfumLikpSVG5cmXFuHHjVJbv27dPYW1trbhx44Zabbdo0SJFuXLlFOHh4cptAgICFNbW1orLly9/MQ5xGy2bCAoKYubMmXh7ezN48OA0t5s+fTr58+enWbNmKdYFBgbi7u6Ovr6+cpmnpyeJiYmcPHlSI3FnFZ9rX4VCgb+/Py1atMDAwEC5vFatWhw7dgxLS0tAtO/nfOnvNzY2lhw5cqjU38qTJw8RERHK96J9UxcTE8PPP/9Mo0aNVJaXLFkSgEePHqnVdoGBgVSuXJm8efMqt3FxccHIyIhjx459MQ6RbLIJKysr/P398fX1RS6Xp7pNYGAgu3fvZsqUKSmK5n348IFnz55RokQJleWmpqYYGxsTGhqqsdizgs+1b1hYGNHR0ZibmzNmzBgqVapE2bJlGThwIG/fvgVE+37Jl/5+27Vrx/3791m3bh1RUVGcPn0aPz8/fvnlF0C07+cYGxszatQoKlasqLLc398fkNpenba7f/9+im3kcjkWFhZqta9INtlE/vz5yZcvX5rro6KiGDlyJH379k3xB5O8HqQ/zP8yMjJS/yFgNvW59k1OKNOnT+fdu3fMmzePUaNGERgYSN++fQHRvl/ypb/f6tWr4+3tzcSJE6lUqRJeXl44OTkxYsQIQLRvel25coXly5dTp04dcuXKBXy57aKior6pfcXkaT+IyZMnY25ujpeXV6rrFV8o/v2l8uE/suQJpMzNzZk7d65ymorcuXPTp08fzpw5k2qC/zfRvp83duxY/Pz88PX1pWrVqty7d4/58+fTr18/Fi9eLP5+0yEoKIiePXtiYWHBxIkTvzhppDptp842Itn8AI4ePcq+ffvYsWMHSUlJyhdAQkICOjo6yl8sMTExKT4fHR39xYmRfmTJbVezZk2V+ZCcnZ0BqUu0o6MjINr3a7x48YKtW7fSu3dv+vTpA0CVKlUoWrQoXbt2JSAggCpVqgCifb9k//79DB8+nOLFi7NixQry5s2rbLMvtZ2xsXGa2xQuXPiLxxbp/gdw4MABYmNjadSoEfb29tjb27N48WISExOxt7dn0aJFGBkZYWZmxsOHD1U+++bNG2JiYr74y/xHZmlpiUwmS/ELMTExEQCZTCba9xs8ffoUhUJBhQoVVJZXrlwZgLt374r2VcPq1asZOHAg5cqVY8OGDRQsWBBA7bYrUaJEim0SExMJCwtTq31FsvkB+Pr6sn37dpVXq1atkMvlyv8G6Zf40aNHVb40Dxw4gFwuV/5yFFIyMjKiYsWKHDp0SGUQ3JEjRwCoVKkSINr3axUrVgy5XE5QUJDK8kuXLgFgYWEBiPb9nG3btjF16lTq16/PihUrUlzpqdN2zs7OnD17VqUH4MmTJ3n//j01atT4YgziNtoPwMLCQvk/ZLKAgAAA5e0dgG7durFv3z569OhB586defDgAbNnz6ZVq1ZqXSb/yAYMGICXlxc9e/bEy8uLsLAwZs6ciYeHh7JSg2jfr2NqakqHDh1Yvnw5MpmMKlWqEBoayoIFC7C1tcXDwwMQ7ZuWN2/eMGnSJIoUKUL79u25ceOGyvqiRYuq1Xbt2rVj/fr1eHl50bt3byIiIpgxYwaurq4prjpTlQFjhoRMZseOHZ+tIKBQKBTz589PMahToVAozp8/r2jZsqXCwcFBUbNmTcWsWbMUcXFxmgw3y0mrfc+fP69o27atwtHRUVGjRg3F5MmTVQZ5Jm8j2vfzUmvfxMRExcqVKxV169ZV2NvbK2rXrq2YNGmSIjIyUuWzon1T2rlzp8La2jrN165duxQKhXptd/v2bUXnzp0VTk5OiurVqytGjx6tiIqKUisOmULxhW4cgiAIgvCNxDMbQRAEQeNEshEEQRA0TiQbQRAEQeNEshEEQRA0TiQbQRAEQeNEshEEQRA0TiQbIcurVasWHTt2/OJ2HTt2pFatWmm+V/dzaYmOjiY8PFz5fsGCBdjY2BAWFvbFzybz8/PDxsaGs2fPqv2ZL3n8+HGG7UtbssM5/OhEshF+GD179uS3337TyL6Dg4OpX78+d+/eVS7z8PBg+vTpmJqaauSY6ujatSuLFi3S2vEzwpgxYzT27yZ8P6JcjfDDSK7CrAl37tzh5cuXKstsbW2xtbXV2DHVcfLkSZo2barVGL7VyZMnKVKkiLbDEL6RuLIRBEEQNE4kGyHTu3LlCt27d6dSpUpUrVqVHj16cPv27RTb7dmzh4YNG+Lg4EC9evXYtGmTynp1nr2cOnWKNm3aUK5cOerUqcO2bdu+GN+CBQuUM0Z26tRJeYzUntlER0czefJkfvrpJ8qWLUvjxo2/eIw//vgDGxsbJk2apFwWGxvLnDlzqFWrFg4ODtSuXZt58+Ypq/aGhYVhY2MDwM6dO7/4HEihULB27VoaNWqEk5MTtWrVYubMmXz48EG5TWJiIitWrKBevXo4ODjg4uLC2LFjVZ5TnT17FhsbG/z8/FT2/9/lye8DAwMZP3481atXp2zZsnTu3Jlbt24pP2djY8OTJ084d+5cqvsVsg5xG03I1C5cuICXlxcFCxakW7duGBoasnbtWjp16sSOHTuU1ayvXbvGnTt36NChA6ampmzevJlx48ZRoEAB6tSpo9axTp06Rffu3SlevDj9+/cnPDycSZMmIZPJyJs3b5qf8/Dw4NWrV2zZsoWePXuqVNL+t7i4ONq3b8/du3dp1aoVtra2HDt2jFGjRvHhwwc6deqU4jPbtm1j5syZtG7dmpEjRwLSl76Pjw8XL16kVatWWFlZERwczNKlS7l58yZLlizB1NSU6dOnM3ToUCpVqqTcLi3jx49n06ZNuLu707ZtW0JDQ1m1ahUPHjxg4cKFgFTZ+sCBA9StW5dOnToRGhrKpk2bOHPmDNu2bVNOL5weo0aNomDBgvTq1Yt3796xYsUKunfvztGjR9HV1WX69OlMmTKFvHnz0rNnT/WqCwuZU8bWFxWEjNWiRQuFs7OzIjw8XLns/v37CltbW8W0adMUCoVC4e7urrCxsVEEBwcrtwkLC1PY2NgohgwZolzWoUMHhbu7e5rvmzZtqnBzc1OpYnv69GmFtbW1ynapSa5UfObMGeWy+fPnK6ytrRWPHz9WKBQKxYYNGxTW1taKPXv2KLdJSkpStGvXTuHs7KxITExU2c/BgwcVdnZ2iiFDhiiSkpJSHOv48eMqMWzevFlhbW2tOHTokHKZtbW1YtiwYZ+N/e7duwobGxvFqFGjVJbPnj1bYW1trbh7967i2LFjCmtra8XEiRNVttm/f7/C2tpa+W9x5swZhbW1tWLHjh0q2/13efL75s2bKxISEpTbLVu2TGFtba04efKkcpm7u7uiQ4cOnz0HIfMTt9GETOvNmzdcvXqVxo0bq1xZlChRgh07dtC9e3flsuLFi2Nvb698X6RIEUxNTXn9+rXax7p+/ToNGzZUTvMMUK1aNeXtqG8VEBCAqakpjRo1Ui6TyWRMnz6dDRs2qEwpfebMGQYOHEiVKlWYMmWKyrqDBw9iamqKvb094eHhypebmxtyuVw5V1F64lIoFCm6j3ft2pU9e/ZQtGhR5URwPj4+KtvUr1+fEiVKcPjw4XQdM1ndunWRy+XK93Z2dgC8evXqq/YnZF7iNpqQaT158gSQZmr8r+QJyZLly5cvxTaGhoYqM2eqc6yiRYumWFeyZEmuXr2q1n6+dIyiRYuqJA4g1Z5WixcvRkdHhzt37hAdHU3u3LmV6x49ekR4eDjVq1dP9TjPnj1Ld1wgJex/y5Url/LWWFhYGLly5SJ//vwpPm9lZcXx48fTdcxk/+0Wrq+vD0BSUtJX7U/IvESyETKt5C+c/345p0ZH59su0pOP8fHjxzTj+FaJiYlqnQtA9erV6dy5Mz179mTmzJlMmDBBZT/Fixdn7NixqX42vc9OEhMTv7iN4jPTXiUlJaGnp/fZz6fVht/67yZkHeJfWsi0ChUqBEi/5P9rxowZLF++PMOOVaRIEWQyGQ8fPkyxLj0VAD6ncOHCqY6EP3bsGMOGDVO55ffrr7/i7u5OgwYN2LZtGxcvXlSus7CwICIigmrVqlGjRg3lq3LlykRERJAzZ850xwUpR+m/ePGC/v37c+HCBYoUKUJkZGSqtyVDQ0OV/1bJt8T+PZc9iNtigkg2QiZmZmaGra0t+/btIzo6Wrn88ePHrF27Vu3nMeowNTWlcuXK7NmzR2W/ly5d4vr161/8fPIv9M9dBbm6uvL69WsOHTqksnzNmjUEBASk2uNt+PDh5MiRg7FjxypvCdaqVYuIiIgUXbs3b97MgAEDOH36tEpcX7oyc3NzA0ixPz8/P/7++2+MjY2V3bmXLVumso2/vz+hoaH89NNPAMrbbDdv3lTZbv/+/Z+N4XPUOQch8xO30YRMbcSIEXTr1o3mzZvTsmVLdHR0WL9+Pbly5VLpIJARhg0bRvv27WnVqhXt27fnw4cP/Pnnn5/t9pws+dnDpk2beP36NY0bN06xTZs2bdixYwcDBgygffv2lChRgoCAAAIDA5k8ebLKg/JkZmZm+Pr6Mn36dFavXk2PHj1o2bIlO3fuZMKECVy/fh0nJyfu3LnDli1bsLe3p1mzZipxnTt3jq1bt+Li4qK8ivk3Ozs7WrZsybp163j58iXVq1fn3r17bN68mSZNmmBra4uNjQ21a9dm7dq1vHjxgqpVq/LgwQM2bdqEpaWlsuNAckeNrVu3kjNnTooXL86hQ4e+qbaZqakpt27dYuPGjVSpUoVSpUp99b4E7RFXNkKmVq1aNdasWYO5uTmLFi1i+fLl2Nvbs2nTJgoUKJChx3JwcGDdunVYWlqycOFCtm3bhq+vLy4uLl/8bPXq1alfvz7Hjh1jwoQJxMbGptjG0NCQdevW0aJFC/bt28eUKVN4+fIlc+fOpXnz5mnuu3PnzpQuXZpFixbx+PFj9PX1+fPPP+nSpQtnzpxh4sSJBAQE0LZtW1auXEmOHDmUnx08eDAJCQlMmDCBc+fOpXmM33//nSFDhnD79m0mTZrEiRMn6N27t/JZkUwmY968efTr149bt24xZcoUDh48SOvWrdm+fbvKc6L58+dTu3ZtNm/ezMyZM8mXLx9Lliz5YhumpU+fPuTOnZvJkyenuCoUsg6Z4nNP/gRBEAQhA4grG0EQBEHjRLIRBEEQNE4kG0EQBEHjRLIRBEEQNE4kG0EQBEHjRLIRBEEQNE4kG0EQBEHjRLIRBEEQNE4kG0EQBEHjRLIRBEEQNO5/L+BOo4MOWjcAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# we'll put x_1 (child) on the y axis, and x_2 (adult) on the x-axis\n",
    "\n",
    "x = np.arange(130, 200, 1) # start, stop, step\n",
    "y_1 = (3100 - 12*x)/8\n",
    "y_2 = (300 - x)\n",
    "\n",
    "plt.plot(x, y_1, x, y_2)\n",
    "plt.xlabel(\"child ticket count\")\n",
    "plt.ylabel(\"adult ticket count\")\n",
    "plt.legend(['revenue eqn', 'attendance eqn'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The point at which these two lines intersect is the only point at which the collected revenue and the attendance match what we observed.  At this point, we can now observe the necessary number of adult and child tickets that must have been sold.\n",
    "\n",
    "From the graph, we estimate that the number of child and adult tickets that solve both equations are about 125 and 175 tickets, respectively.\n",
    "\n",
    "Let's solve the system of equations using linear algebra.\n",
    "\n",
    "$$\\Large \\begin{cases} 8x_1 + 12x_2 = 3100 \\\\ x_1 + x_2 = 300 \\end{cases} $$\n",
    "\n",
    "\n",
    "$$ \\Large \\begin{bmatrix} 8 && 12 \\\\ 1 && 1 \\end{bmatrix} \\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix} = \\begin{bmatrix} 3100 \\\\ 300 \\end{bmatrix} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[125.]\n",
      " [175.]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[8, 12],\n",
    "              [1, 1]])\n",
    "\n",
    "A_inv = np.linalg.inv(A)\n",
    "\n",
    "b = np.array([[3100],\n",
    "              [300]])\n",
    "\n",
    "x = A_inv.dot(b)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Children Tickets: 125\n",
      "Adult Tickets: 175\n",
      "----\n",
      "Children Tickets: 65\n",
      "Adult Tickets: 215\n"
     ]
    }
   ],
   "source": [
    "# Now let's take a quick look at moving this logic into a Python function:\n",
    "\n",
    "import math\n",
    "\n",
    "def print_ticket_sales(revenue, attendance, child_price, adult_price):\n",
    "    A = np.array([[child_price, adult_price], [1, 1]])\n",
    "    A_inv = np.linalg.inv(A)\n",
    "    b = np.array([[revenue], [attendance]])\n",
    "    x = A_inv.dot(b)\n",
    "    print(\"Children Tickets:\", math.ceil(x[0][0]))\n",
    "    print(\"Adult Tickets:\", math.ceil(x[1][0]))\n",
    "\n",
    "print_ticket_sales(3100, 300, 8, 12)\n",
    "\n",
    "# We can also experiment with other numbers here to see how it affects the outcome.\n",
    "print(\"----\")\n",
    "print_ticket_sales(3100, 280, 8, 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2: Break-even analysis\n",
    "\n",
    "Let's say we own a company that provides cloud hosting.  We want to determine when we expect to be profitable.\n",
    "\n",
    "We have two equations - a cost equation and a revenue equation. The cost of running business includes a significant amount of cash for computers and servers, and increasaes linearly with the number of servers purchased. Let's assume that our cost and our revenue are a function of how many servers we manage.\n",
    "\n",
    "Our unknowns:\n",
    "- $\\large x_1$ - how many servers do we need to provision to break even on our investment?\n",
    "- $\\large x_2$ - what is the break even dollar amount?\n",
    "\n",
    "Solving for these unknowns where these values are the same for the _cost equation_ and the _revenue equation_ will provide us with our _break even__ point.\n",
    "\n",
    "Our knowns:\n",
    "- 15 - the cost per server, including all overhead\n",
    "- 99 - the revenue we generate per server we own\n",
    "\n",
    "Our equations:\n",
    "- $\\large cost: x_2 = 5000 + 16x_1$\n",
    "- $\\large revenue: x_2 = 40x_1$\n",
    "\n",
    "Let's start with a graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# we'll put x_2 (dollars) on the y axis, and x_1 (servers) on the x-axis\n",
    "\n",
    "x = np.arange(0, 400, 1) # start, stop, step\n",
    "cost = (5000 + 16*x)\n",
    "revenue = (40*x)\n",
    "\n",
    "plt.plot(x, cost, x, revenue)\n",
    "plt.legend(['cost', 'revenue'])\n",
    "plt.xlabel(\"servers\")\n",
    "plt.ylabel(\"dollars\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And again, solving using linear algebra:\n",
    "\n",
    "$$\\Large \\begin{cases} -16x_1 + x_2 = 5000 \\\\ -40x_1 + x_2 = 0 \\end{cases} $$\n",
    "\n",
    "\n",
    "$$ \\Large \\begin{bmatrix} -16 && 1 \\\\ -40 && 1 \\end{bmatrix} \\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix} = \\begin{bmatrix} 5000 \\\\ 0 \\end{bmatrix} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "209 servers and $ 8334 invested at break-even.\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[-16, 1],\n",
    "              [-40, 1]])\n",
    "\n",
    "A_inv = np.linalg.inv(A)\n",
    "\n",
    "b = np.array([[5000],\n",
    "              [0]])\n",
    "\n",
    "x = A_inv.dot(b)\n",
    "\n",
    "print(f'{math.ceil(x[0][0])} servers and $ {math.ceil(x[1][0])} invested at break-even.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4: Linear Dependence and Span\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> For $A^{-1}$ to exist, $Ax = b$ must have exactly one solution for every value of $b$. \n",
    "\n",
    "It's also possible for the system of equations to have **zero solutions** or an **infinite number of solutions** for some values of $b$.\n",
    "\n",
    "However, **it is not possible to have more than one but less than an infinite number of solutions for a particular $b$.**  This is because we're working with linear systems, for which there are three general states:\n",
    "\n",
    "- Zero solutions (e.g. in 2D, parallel lines)\n",
    "- One solution (e.g. in 2D, lines that cross at a single point)\n",
    "- Infinitely man solutions (e.g. in 2D, lines that overlap)\n",
    "\n",
    "This is easier to understand using a visual.  We'll use NumPy and matplotlib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x432 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.arange(0, 20, 1) # start, stop, step\n",
    "\n",
    "y_1 = (2*x + 4)\n",
    "y_2 = (2*x - 3)\n",
    "\n",
    "y_3 = (-3.4*x)\n",
    "y_4 = (0.2*x - 32)\n",
    "\n",
    "y_5 = (0.8*x)\n",
    "y_6 = (0.8*x)\n",
    "\n",
    "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18,6))\n",
    "\n",
    "# ax.set_title('3 classes of linear equation relationships')\n",
    "\n",
    "ax1.plot(y_1, linestyle=':', linewidth=8)\n",
    "ax1.plot(y_2, linewidth=8)\n",
    "ax1.set_title('No Solutions')\n",
    "\n",
    "ax2.plot(y_3, linestyle=':',linewidth=8)\n",
    "ax2.plot(y_4, linewidth=8)\n",
    "ax2.set_title('One Solution')\n",
    "\n",
    "ax3.plot(y_5, linestyle=':', linewidth=8)\n",
    "ax3.plot(y_6, linewidth=4)\n",
    "ax3.set_title('Infinite Solutions')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Span\n",
    "\n",
    "> The **span** of a set of vectors is the set of all points obtainable by **linear combination** of the original vectors.\n",
    "\n",
    "The **linear combination** of a set of 2 vectors is effectively their *weighted sum*.  \n",
    "\n",
    "To visualize this, we can take the so-called \"column picture\" of our equation $Ax = b$:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a set of two vectors $x_1$ and $x_2$:\n",
    "\n",
    "$$\\Large x_1 = \\begin{bmatrix} 0.56 \\\\ 0.59 \\end{bmatrix} $$\n",
    "\n",
    "$$\\Large x_2 = \\begin{bmatrix} 0.86 \\\\ 0.88 \\end{bmatrix} $$\n",
    "\n",
    "The **linear combination** of these two numbers is the sum of each multiplied some scalar weight, i.e:\n",
    "\n",
    "$$\\Large a \\begin{bmatrix} 0.86 \\\\ 0.88 \\end{bmatrix} + b \\begin{bmatrix} 0.86 \\\\ 0.88 \\end{bmatrix} $$\n",
    "\n",
    "Notice that the sum of two vectors just gives us some point on a plane. Think of the **span** as **all the vectors that you can get to in this space by linear combination of these vectors for any possible combination of weights**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Determining whether $Ax=b$ has a solution thus amounts to testing whether $b$ is in the span of the columns of $A$.\n",
    "\n",
    "This particular span is known as the **column space**, or the **range**, of $A$.\n",
    "\n",
    "Think of the **column space** as **the span of the column vectors in a given matrix**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linear Dependence \n",
    "\n",
    "> A set of vectors is **linearly independent** if no vector in the set is a linear combination of the other vectors.\n",
    "\n",
    "If two vectors are identical, or each of the values in one vector is an equal factor of all values in the other (i.e. one is a \"scaled\" version of the other, than the two vectors are not linearly dependent.  They describe the same behavior. They fall on the same line.\n",
    "\n",
    "For a matrix to have an **inverse**, it must have exactly the same number of linearly independent rows as it has columns.  If it has less, we may be under-constrained and have infinitely many solutions.  If we have more, we are overconstrained and will have no unique solution.\n",
    "\n",
    "> Another way of looking at this is to say that to solve a linear system of $n$ unknowns using matrix inversion, we must have precisely $m$ linearly independent equations, where $m$ and $n$ are equal - that is, we have a **square matrix**.\n",
    "\n",
    "A **singular matrix** is a **square matrix** where all of the columns are **linearly dependent**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Norms\n",
    "\n",
    "In machine learning, we use __norms__ to measure the size of vectors.  They are always non-negative values, but may be 0 if the vector is a zero vector.\n",
    "\n",
    "Norms are typically denoted by two horizontal bars, i.e. $‖x‖$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When solving a system of linear equations, i.e. $Ax = b$, the exact solution, if it exists, and any approximations of a solution, are vectors.  The __error__ is a vector, too.  Norms help us assess the magnitude of an error by helping us quanitify the size of a vector."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\large \\left\\Vert x \\right\\Vert_{p}=\\left( \\sum_{k} \\left\\vert x_{i} \\right\\vert^{p} \\right) ^{1/p} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Euclidean Norm ($L^2$)\n",
    "\n",
    "Very common in machine learning; just the Euclidean distance to a point $x$ from the origin.\n",
    "\n",
    "For example, for the vector:\n",
    "\n",
    "$$ \\large x = \\begin{bmatrix} 2.4 \\\\ 4.9 \\end{bmatrix} $$\n",
    "\n",
    "The $L^2$ norm is calculated:\n",
    "\n",
    "$$ \\large \\left\\Vert x \\right\\Vert_2 = \\left( 2.4^2 + 4.9^2 \\right)^{1/2} $$\n",
    "\n",
    "$$ \\large = \\sqrt{ 5.76 + 24.01 } $$\n",
    "\n",
    "$$ \\large \\approx 5.46 $$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.456189146281496\n"
     ]
    }
   ],
   "source": [
    "# Using numPy, the L2 norm can be easily calculated:\n",
    "\n",
    "x = np.array([[2.4],[4.9]])\n",
    "\n",
    "x_norm = np.linalg.norm(x)\n",
    "\n",
    "print(x_norm)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}