learn-autograd.ipynb

learn-autograd.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "427371ec-a216-4aa4-a658-1fcf44fdd746",
   "metadata": {},
   "source": [
    "# 自动微分"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08628e8d-d11d-426b-8ea4-4579867247b5",
   "metadata": {},
   "source": [
    "## 引言：为什么需要自动微分？"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39797cf8-5780-41d5-90a6-f99af7496314",
   "metadata": {},
   "source": [
    "对比手动推导、数值微分与符号微分的局限性\n",
    "\n",
    "- 手动推导：易错、耗时\n",
    "- 数值微分（如有限差分）：精度问题、计算成本高\n",
    "- 符号微分（如Mathematica）：表达式膨胀问题\n",
    "\n",
    "自动微分的优势：高效、精确、适合计算机实现"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2b70b3a-3024-498e-ac19-cbc7c997f93d",
   "metadata": {},
   "source": [
    "## 计算图"
   ]
  },
  {
   "attachments": {
    "cbb80587-8b64-478d-83c7-bb967d6262d5.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "e35f46ea-a1ea-4a40-acc8-1c37aa8e2d71",
   "metadata": {},
   "source": [
    "![无标题.png](attachment:cbb80587-8b64-478d-83c7-bb967d6262d5.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b10676bd-f7ba-497c-9756-b0f0478c0c82",
   "metadata": {},
   "source": [
    "## 自动微分的基本方法"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f542d48f-4087-499c-92de-dc12f0c8ea07",
   "metadata": {},
   "source": [
    "自动微分能做的事情：\n",
    "\n",
    "对于 $y \\leftarrow f(x)$\n",
    "对于给定 $x_0$ ，计算 $f'(x)$ 。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c8669e7-1187-4ae5-bbb9-d7661b88e92e",
   "metadata": {},
   "source": [
    "自动微分的对象必须是连续函数\n",
    "\n",
    "不能是差分函数\n",
    "\n",
    "因为我们是在单个点的附近通过梯度传播进行计算的，差分的话，高阶项扔不掉"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82ccbd99-18ac-48f8-bc53-2cbd74912568",
   "metadata": {},
   "source": [
    "有正向模式和反向模式，都是基于链式法则"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cfc520c-d876-4ac5-be6a-18b0cd19017d",
   "metadata": {},
   "source": [
    "### 反向模式"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b0bee13-2c15-4088-8296-cd5deb2f1adf",
   "metadata": {},
   "source": [
    "如果我们固定感兴趣的量为\n",
    "\n",
    "$\\frac{\\partial z}{\\partial ?}$\n",
    "\n",
    "我们能很轻松的计算$z$的直属上游，比如\n",
    "\n",
    "$\\frac{\\partial z}{\\partial y_1}, \\frac{\\partial z}{\\partial y_2}, \\cdots$\n",
    "\n",
    "我们也可以通过这些结果计算二阶上游的梯度，比如\n",
    "\n",
    "$\\frac{\\partial z} {\\partial x_1} = \\frac{\\partial z} {\\partial y_1} \\frac{\\partial y_1} {\\partial x_0} + \\frac{\\partial z} {\\partial y_2} \\frac{\\partial y_2} {\\partial x_0} + \\cdots$\n",
    "\n",
    "对于每个二阶上游 $x_i$ ，都可以这么计算下来\n",
    "\n",
    "有了二阶上游的导数，我们就可以接着往下算了。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5579c3dd-986f-473b-a90a-d8ab75e2970e",
   "metadata": {},
   "source": [
    "通过反向模式的自动微分，我们能以正向计算的复杂度，计算某个scalar对所有可能的上游参数的梯度"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cced4a6d-0784-4c2f-9901-a245042eb667",
   "metadata": {},
   "source": [
    "### 正向模式"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d791e760-9e19-4288-9ba2-07313aa967c9",
   "metadata": {},
   "source": [
    "如果我们固定感兴趣的量为\n",
    "\n",
    "$\\frac{\\partial ?}{\\partial x}$\n",
    "\n",
    "我们能很轻松地计算$x$的直属下游，比如\n",
    "\n",
    "$\\frac{\\partial y_1}{\\partial x}, \\frac{\\partial y_2}{\\partial x}, \\cdots$\n",
    "\n",
    "我们也可以通过这些结果计算二阶下游的梯度，比如\n",
    "\n",
    "$\\frac{\\partial z_1} {\\partial x} = \\frac{\\partial z_1} {\\partial y_1} \\frac{\\partial y_1} {\\partial x} + \\frac{\\partial z_1} {\\partial y_2} \\frac{\\partial y_2} {\\partial x} + \\cdots$\n",
    "\n",
    "对于每个二阶下游 $z_i$ ，都可以这么计算下来\n",
    "\n",
    "有了二阶上下游的导数，我们就可以接着往下算了。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4f707a5-7ee3-472e-b296-b2b4bafe8a82",
   "metadata": {},
   "source": [
    "通过正向模式的自动微分，我们能以正向计算的复杂度，计算所有可能的下游对给某个scalar参数的梯度"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbca55a8-abc9-4866-a663-41b760c8e81f",
   "metadata": {},
   "source": [
    "## 实现们"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c574557-2e26-4f9d-8b1c-93be4a9feaec",
   "metadata": {},
   "source": [
    "pytorch、tensorflow、jax、..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28d2b42e-459b-4165-85ad-d20b76b9766e",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 一个简单的实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1b4e03ee-359c-4d16-a9b9-4441c03e3435",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Leaf:\n",
    "\n",
    "    def __init__(self, value):\n",
    "        self._value = value\n",
    "\n",
    "    def forward(self):\n",
    "        return self._value\n",
    "\n",
    "    def backward(self, grad):\n",
    "        self.grad = grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "696d337e-feae-4634-b82f-059ad49890a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "\n",
    "    def __init__(self, forward, backward, arg1, arg2):\n",
    "        self._forward = forward\n",
    "        self._backward = backward\n",
    "        self._arg1 = arg1\n",
    "        self._arg2 = arg2\n",
    "\n",
    "    def forward(self):\n",
    "        context, result = self._forward(self._arg1.forward(),\n",
    "                                        self._arg2.forward())\n",
    "        self._context = context\n",
    "        return result\n",
    "\n",
    "    def backward(self, grad):\n",
    "        grad1, grad2 = self._backward(self._context, grad)\n",
    "        self._arg1.backward(grad1)\n",
    "        self._arg2.backward(grad2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2064f793-951c-4a68-966e-d0982f9d543a",
   "metadata": {},
   "source": [
    "### 测试一下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f407c5a1-3a24-40a3-8d6f-51ce1c8fc52d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result=6\n",
      "x.grad=3, y.grad=2\n"
     ]
    }
   ],
   "source": [
    "# result = x * y\n",
    "\n",
    "x = Leaf(2)\n",
    "y = Leaf(3)\n",
    "\n",
    "x_times_y = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a * b),\n",
    "    lambda c, g: (g * c[\"b\"], g * c[\"a\"]),\n",
    "    x,\n",
    "    y,\n",
    ")\n",
    "\n",
    "result = x_times_y.forward()\n",
    "print(f\"{result=}\")\n",
    "x_times_y.backward(1)\n",
    "print(f\"{x.grad=}, {y.grad=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "87883c4d-7427-440d-9a76-78872072ff8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result=20\n",
      "x.grad=4, y.grad=4, z.grad=5\n"
     ]
    }
   ],
   "source": [
    "# result = (x + y) * z\n",
    "\n",
    "x = Leaf(2)\n",
    "y = Leaf(3)\n",
    "z = Leaf(4)\n",
    "\n",
    "x_plus_y = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a + b),\n",
    "    lambda c, g: (g, g),\n",
    "    x,\n",
    "    y,\n",
    ")\n",
    "\n",
    "x_plus_y_multiplied_by_z = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a * b),\n",
    "    lambda c, g: (g * c[\"b\"], g * c[\"a\"]),\n",
    "    x_plus_y,\n",
    "    z,\n",
    ")\n",
    "\n",
    "result = x_plus_y_multiplied_by_z.forward()\n",
    "print(f\"{result=}\")\n",
    "x_plus_y_multiplied_by_z.backward(1)\n",
    "print(f\"{x.grad=}, {y.grad=}, {z.grad=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "916a8397-9674-49c1-a343-8ca7e9019c6d",
   "metadata": {},
   "source": [
    "这是一个简单的计算图实现示例，展示了如何使用叶节点和节点来进行前向传播和反向传播。\n",
    "但是，这个实现不支持一个节点有多个输出的情况。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39e11ae5-bbd0-4ad6-9fd8-415ecc333c82",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 支持多输出的版本，需要累加不同下游的梯度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "94cb905f-7a0f-43f0-984f-ff2ba5ebdd65",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Leaf:\n",
    "\n",
    "    def __init__(self, value):\n",
    "        self._value = value\n",
    "        self.temp_grad = None\n",
    "        self.ref_count = 0\n",
    "\n",
    "    def forward(self):\n",
    "        return self._value\n",
    "\n",
    "    def backward(self, grad):\n",
    "        self.grad = grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c46d0716-28df-4270-b31c-07bceff602a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "\n",
    "    def __init__(self, forward, backward, arg1, arg2):\n",
    "        self._forward = forward\n",
    "        self._backward = backward\n",
    "        self._arg1 = arg1\n",
    "        self._arg2 = arg2\n",
    "        self.temp_grad = None\n",
    "        self.ref_count = 0\n",
    "        self._arg1.ref_count += 1\n",
    "        self._arg2.ref_count += 1\n",
    "\n",
    "    def forward(self):\n",
    "        context, result = self._forward(self._arg1.forward(),\n",
    "                                        self._arg2.forward())\n",
    "        self._context = context\n",
    "        return result\n",
    "\n",
    "    def backward(self, grad):\n",
    "        grad1, grad2 = self._backward(self._context, grad)\n",
    "        if self._arg1.temp_grad is None:\n",
    "            self._arg1.temp_grad = grad1\n",
    "        else:\n",
    "            self._arg1.temp_grad += grad1\n",
    "        if self._arg2.temp_grad is None:\n",
    "            self._arg2.temp_grad = grad2\n",
    "        else:\n",
    "            self._arg2.temp_grad += grad2\n",
    "        self._arg1.ref_count -= 1\n",
    "        if self._arg1.ref_count == 0:\n",
    "            self._arg1.backward(self._arg1.temp_grad)\n",
    "            self._arg1.temp_grad = None\n",
    "        self._arg2.ref_count -= 1\n",
    "        if self._arg2.ref_count == 0:\n",
    "            self._arg2.backward(self._arg2.temp_grad)\n",
    "            self._arg2.temp_grad = None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c31d7b73-b359-400e-a93e-e0e77a30e121",
   "metadata": {},
   "source": [
    "### 测试一下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "46938abe-2e6f-4cc4-8306-cf77047faee7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result=10\n",
      "x.grad=7, y.grad=2\n"
     ]
    }
   ],
   "source": [
    "# result = (x + y) * x\n",
    "\n",
    "x = Leaf(2)\n",
    "y = Leaf(3)\n",
    "\n",
    "x_plus_y = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a + b),\n",
    "    lambda c, g: (g, g),\n",
    "    x,\n",
    "    y,\n",
    ")\n",
    "\n",
    "x_plus_y_multiplied_by_x = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a * b),\n",
    "    lambda c, g: (g * c[\"b\"], g * c[\"a\"]),\n",
    "    x_plus_y,\n",
    "    x,\n",
    ")\n",
    "\n",
    "result = x_plus_y_multiplied_by_x.forward()\n",
    "print(f\"{result=}\")\n",
    "x_plus_y_multiplied_by_x.backward(1)\n",
    "print(f\"{x.grad=}, {y.grad=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e20e522-1091-47c8-9603-3edbe066a382",
   "metadata": {},
   "source": [
    "这个实现支持了一个节点有多个输出的情况。\n",
    "这个实现的设计有些不合理，至少temp grad应该在每个节点中管理。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c010badb-0cca-46a2-a59b-862323b38986",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 调整代码重复"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f9c6324b-4367-41d5-b36c-fdc090c18586",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Leaf:\n",
    "\n",
    "    def __init__(self, value):\n",
    "        self._value = value\n",
    "        self.grad = None\n",
    "        self.ref_count = 0\n",
    "\n",
    "    def forward(self):\n",
    "        return self._value\n",
    "\n",
    "    def backward(self, grad):\n",
    "        if self.grad is None:\n",
    "            self.grad = grad\n",
    "        else:\n",
    "            self.grad += grad\n",
    "        self.ref_count -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "aa568882-c9ae-41c6-b97b-4228f5632112",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "\n",
    "    def __init__(self, forward, backward, arg1, arg2):\n",
    "        self._forward = forward\n",
    "        self._backward = backward\n",
    "        self._arg1 = arg1\n",
    "        self._arg2 = arg2\n",
    "        self.grad = None\n",
    "        self.ref_count = 0\n",
    "        self._arg1.ref_count += 1\n",
    "        self._arg2.ref_count += 1\n",
    "\n",
    "    def forward(self):\n",
    "        context, result = self._forward(self._arg1.forward(),\n",
    "                                        self._arg2.forward())\n",
    "        self._context = context\n",
    "        return result\n",
    "\n",
    "    def backward(self, grad):\n",
    "        if self.grad is None:\n",
    "            self.grad = grad\n",
    "        else:\n",
    "            self.grad += grad\n",
    "        self.ref_count -= 1\n",
    "        if self.ref_count == 0:\n",
    "            grad1, grad2 = self._backward(self._context, grad)\n",
    "            self._arg1.backward(grad1)\n",
    "            self._arg2.backward(grad2)\n",
    "\n",
    "    def backward_interface(self):\n",
    "        self.ref_count += 1\n",
    "        self.backward(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed83a692-dcb4-4256-b377-a7830366445d",
   "metadata": {},
   "source": [
    "### 测试一下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "68c8c3d2-c98e-4e22-947f-da6ae97b7161",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result=10\n",
      "x.grad=7, y.grad=2\n"
     ]
    }
   ],
   "source": [
    "# result = (x + y) * x\n",
    "\n",
    "x = Leaf(2)\n",
    "y = Leaf(3)\n",
    "\n",
    "x_plus_y = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a + b),\n",
    "    lambda c, g: (g, g),\n",
    "    x,\n",
    "    y,\n",
    ")\n",
    "\n",
    "x_plus_y_multiplied_by_x = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a * b),\n",
    "    lambda c, g: (g * c[\"b\"], g * c[\"a\"]),\n",
    "    x_plus_y,\n",
    "    x,\n",
    ")\n",
    "\n",
    "result = x_plus_y_multiplied_by_x.forward()\n",
    "print(f\"{result=}\")\n",
    "x_plus_y_multiplied_by_x.backward_interface()\n",
    "print(f\"{x.grad=}, {y.grad=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad5f8678-a9fe-4667-b79d-33a300575a4b",
   "metadata": {},
   "source": [
    "这个实现做了一些改进，但是有一个严重的问题。\n",
    "如果x -> y, 同时 x -> z，但是只对y进行反向传播，那么z的梯度将不会被计算，结果x将一直等待来自z的梯度。\n",
    "我们应在每次backward时，寻找有效子图的ref count。\n",
    "而不是在构造计算图时直接生成ref count。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78f08773-d687-4249-bf5a-8cc787c362b6",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 使用有效子图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3ca5f026-30f0-41b5-a817-6c5971c29729",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Leaf:\n",
    "\n",
    "    def __init__(self, value):\n",
    "        self._value = value\n",
    "        self.grad = None\n",
    "        self.ref_count = 0\n",
    "\n",
    "    def forward(self):\n",
    "        return self._value\n",
    "\n",
    "    def update_grad(self, grad):\n",
    "        if self.grad is None:\n",
    "            self.grad = grad\n",
    "        else:\n",
    "            self.grad += grad\n",
    "        self.ref_count -= 1\n",
    "\n",
    "    def activate_subgraph(self):\n",
    "        self.ref_count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "19b57da8-fe66-446a-88d9-69d63d8fdb6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "\n",
    "    def __init__(self, forward, backward, arg1, arg2):\n",
    "        self._forward = forward\n",
    "        self._backward = backward\n",
    "        self._arg1 = arg1\n",
    "        self._arg2 = arg2\n",
    "        self.grad = None\n",
    "        self.ref_count = 0\n",
    "\n",
    "    def forward(self):\n",
    "        context, result = self._forward(self._arg1.forward(),\n",
    "                                        self._arg2.forward())\n",
    "        self._context = context\n",
    "        return result\n",
    "\n",
    "    def update_grad(self, grad):\n",
    "        if self.grad is None:\n",
    "            self.grad = grad\n",
    "        else:\n",
    "            self.grad += grad\n",
    "        self.ref_count -= 1\n",
    "        if self.ref_count == 0:\n",
    "            grad1, grad2 = self._backward(self._context, grad)\n",
    "            self._arg1.update_grad(grad1)\n",
    "            self._arg2.update_grad(grad2)\n",
    "\n",
    "    def activate_subgraph(self):\n",
    "        self.ref_count += 1\n",
    "        self._arg1.activate_subgraph()\n",
    "        self._arg2.activate_subgraph()\n",
    "\n",
    "    def backward(self):\n",
    "        self.activate_subgraph()\n",
    "        self.update_grad(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de052196-667c-4171-bec5-0cfba4243f15",
   "metadata": {},
   "source": [
    "### 测试一下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3c9ca10c-469d-4a69-8c1a-9809d45e3fc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result=10\n",
      "x.grad=7, y.grad=2\n"
     ]
    }
   ],
   "source": [
    "# result = (x + y) * x\n",
    "\n",
    "x = Leaf(2)\n",
    "y = Leaf(3)\n",
    "\n",
    "x_plus_y = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a + b),\n",
    "    lambda c, g: (g, g),\n",
    "    x,\n",
    "    y,\n",
    ")\n",
    "\n",
    "x_plus_y_multiplied_by_x = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a * b),\n",
    "    lambda c, g: (g * c[\"b\"], g * c[\"a\"]),\n",
    "    x_plus_y,\n",
    "    x,\n",
    ")\n",
    "\n",
    "another_x_plus_y_multiplied_by_x = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a * b),\n",
    "    lambda c, g: (g * c[\"b\"], g * c[\"a\"]),\n",
    "    x_plus_y,\n",
    "    x,\n",
    ")\n",
    "\n",
    "result = x_plus_y_multiplied_by_x.forward()\n",
    "print(f\"{result=}\")\n",
    "x_plus_y_multiplied_by_x.backward()\n",
    "print(f\"{x.grad=}, {y.grad=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d27d8614-5f06-460b-aeb1-7e754184053a",
   "metadata": {},
   "source": [
    "目前只支持binary operator，这是不合理的"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2973836d-a837-438c-8f33-8dd20c541a12",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 支持任意参数的版本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a60753c2-e705-44cc-b58e-6c491c8d1cb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import inspect\n",
    "import itertools\n",
    "\n",
    "\n",
    "class AutoGrad:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "785b6597-d5c9-415a-a703-f0fe3d8251bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Leaf(AutoGrad):\n",
    "\n",
    "    def __init__(self, value):\n",
    "        self._value = value\n",
    "        self.grad = None\n",
    "        self.ref_count = 0\n",
    "\n",
    "    def forward(self):\n",
    "        return self._value\n",
    "\n",
    "    def update_grad(self, grad):\n",
    "        if self.grad is None:\n",
    "            self.grad = grad\n",
    "        else:\n",
    "            self.grad += grad\n",
    "        self.ref_count -= 1\n",
    "\n",
    "    def activate_subgraph(self):\n",
    "        self.ref_count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "875e42d1-2311-40f1-8e6c-3775cff6fd35",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node(AutoGrad):\n",
    "\n",
    "    def __init__(self, forward, backward, *args, **kwargs):\n",
    "        self._forward = forward\n",
    "        self._backward = backward\n",
    "        self._args = args\n",
    "        self._kwargs = kwargs\n",
    "        self.grad = None\n",
    "        self.ref_count = 0\n",
    "\n",
    "    def forward(self):\n",
    "        context, result = self._forward(\n",
    "            *(arg.forward() if isinstance(arg, AutoGrad) else arg\n",
    "              for arg in self._args),\n",
    "            **{\n",
    "                key: arg.forward() if isinstance(arg, AutoGrad) else arg\n",
    "                for key, arg in self._kwargs\n",
    "            },\n",
    "        )\n",
    "        self._context = context\n",
    "        return result\n",
    "\n",
    "    def update_grad(self, grad):\n",
    "        if self.grad is None:\n",
    "            self.grad = grad\n",
    "        else:\n",
    "            self.grad += grad\n",
    "        self.ref_count -= 1\n",
    "        if self.ref_count == 0:\n",
    "            self.invoke_backward()\n",
    "\n",
    "    def invoke_backward(self):\n",
    "        upstream_grad = self._backward(self._context, self.grad)\n",
    "        sig = inspect.signature(self._forward)\n",
    "        bound = sig.bind(*self._args, **self._kwargs)\n",
    "        for name, param in sig.parameters.items():\n",
    "            if name in bound.arguments:\n",
    "                value = bound.arguments[name]\n",
    "                if isinstance(value, AutoGrad):\n",
    "                    value.update_grad(upstream_grad[name])\n",
    "\n",
    "    def activate_subgraph(self):\n",
    "        self.ref_count += 1\n",
    "        for arg in itertools.chain(self._args, self._kwargs.values()):\n",
    "            if isinstance(arg, AutoGrad):\n",
    "                arg.activate_subgraph()\n",
    "\n",
    "    def backward(self):\n",
    "        self.activate_subgraph()\n",
    "        self.update_grad(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83c18835-113f-4c1f-a57c-36aaa3ed19bc",
   "metadata": {},
   "source": [
    "### 测试一下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8f463fce-ca24-4505-a315-d684d7dc5bfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result=-10\n",
      "x.grad=-7, y.grad=-2\n"
     ]
    }
   ],
   "source": [
    "# result =  - (x + y) * x\n",
    "\n",
    "x = Leaf(2)\n",
    "y = Leaf(3)\n",
    "\n",
    "x_plus_y = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a + b),\n",
    "    lambda c, g: {\n",
    "        \"a\": g,\n",
    "        \"b\": g\n",
    "    },\n",
    "    x,\n",
    "    y,\n",
    ")\n",
    "\n",
    "x_plus_y_multiplied_by_x = Node(\n",
    "    lambda a, b: ({\n",
    "        \"a\": a,\n",
    "        \"b\": b\n",
    "    }, a * b),\n",
    "    lambda c, g: {\n",
    "        \"a\": g * c[\"b\"],\n",
    "        \"b\": g * c[\"a\"]\n",
    "    },\n",
    "    x_plus_y,\n",
    "    x,\n",
    ")\n",
    "\n",
    "minus_x_plus_y_multiplied_by_x = Node(\n",
    "    lambda a: ({}, -a),\n",
    "    lambda c, g: {\"a\": -g},\n",
    "    x_plus_y_multiplied_by_x,\n",
    ")\n",
    "\n",
    "result = minus_x_plus_y_multiplied_by_x.forward()\n",
    "print(f\"{result=}\")\n",
    "minus_x_plus_y_multiplied_by_x.backward()\n",
    "print(f\"{x.grad=}, {y.grad=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85a41387-511b-4115-b7c3-6b3d70ce3edb",
   "metadata": {},
   "source": [
    "看起来好多了，但是每次创建node都需要传入lambda函数，封装一下吧"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73e4e926-0b46-4e2f-93ac-80f1805ad7b4",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 将每个op单独封装"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "89e62586-a4bb-4dbc-a701-cd744cf1c2db",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node(AutoGrad):\n",
    "\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        self.args = args\n",
    "        self.kwargs = kwargs\n",
    "        self.grad = None\n",
    "        self.ref_count = 0\n",
    "\n",
    "    def forward(self):\n",
    "        result = self.forward_impl(\n",
    "            *(arg.forward() if isinstance(arg, AutoGrad) else arg\n",
    "              for arg in self.args),\n",
    "            **{\n",
    "                key: arg.forward() if isinstance(arg, AutoGrad) else arg\n",
    "                for key, arg in self.kwargs\n",
    "            },\n",
    "        )\n",
    "        return result\n",
    "\n",
    "    def update_grad(self, grad):\n",
    "        if self.grad is None:\n",
    "            self.grad = grad\n",
    "        else:\n",
    "            self.grad += grad\n",
    "        self.ref_count -= 1\n",
    "        if self.ref_count == 0:\n",
    "            self.backward_wrap()\n",
    "\n",
    "    def backward_wrap(self):\n",
    "        upstream_grad = self.backward_impl(self.grad)\n",
    "        sig = inspect.signature(self.forward_impl)\n",
    "        bound = sig.bind(*self.args, **self.kwargs)\n",
    "        for name, param in sig.parameters.items():\n",
    "            if name in bound.arguments:\n",
    "                value = bound.arguments[name]\n",
    "                if isinstance(value, AutoGrad):\n",
    "                    value.update_grad(upstream_grad[name])\n",
    "\n",
    "    def activate_subgraph(self):\n",
    "        self.ref_count += 1\n",
    "        for arg in itertools.chain(self.args, self.kwargs.values()):\n",
    "            if isinstance(arg, AutoGrad):\n",
    "                arg.activate_subgraph()\n",
    "\n",
    "    def backward(self):\n",
    "        self.activate_subgraph()\n",
    "        self.update_grad(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fce74892-0888-42fb-9e92-39f11338a45d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Plus(Node):\n",
    "\n",
    "    def forward_impl(self, a, b):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "        return a + b\n",
    "\n",
    "    def backward_impl(self, grad):\n",
    "        return {\"a\": grad, \"b\": grad}\n",
    "\n",
    "\n",
    "class Time(Node):\n",
    "\n",
    "    def forward_impl(self, a, b):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "        return a * b\n",
    "\n",
    "    def backward_impl(self, grad):\n",
    "        return {\"a\": grad * self.b, \"b\": grad * self.a}\n",
    "\n",
    "\n",
    "class Neg(Node):\n",
    "\n",
    "    def forward_impl(self, a):\n",
    "        self.a = a\n",
    "        return -a\n",
    "\n",
    "    def backward_impl(self, grad):\n",
    "        return {\"a\": -grad}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8de0e92-38b3-4659-b8b2-267cd13a1557",
   "metadata": {},
   "source": [
    "### 跑跑看"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1335344a-92c6-488e-a59f-7ab063970c1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result=-9\n",
      "x.grad=-7, y.grad=-2\n"
     ]
    }
   ],
   "source": [
    "x = Leaf(2)\n",
    "y = Leaf(3)\n",
    "\n",
    "x_plus_y = Plus(x, y)\n",
    "x_plus_y_multiplied_by_x = Time(x_plus_y, x)\n",
    "minus_x_plus_y_multiplied_by_x = Neg(x_plus_y_multiplied_by_x)\n",
    "minus_x_plus_y_multiplied_by_x_plus_one = Plus(minus_x_plus_y_multiplied_by_x, 1)\n",
    "\n",
    "result = minus_x_plus_y_multiplied_by_x_plus_one.forward()\n",
    "print(f\"{result=}\")\n",
    "minus_x_plus_y_multiplied_by_x_plus_one.backward()\n",
    "print(f\"{x.grad=}, {y.grad=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76ab55b0-7b81-4919-b162-96a6a932eca5",
   "metadata": {},
   "source": [
    "## 实现小结"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03272b44-3f16-4795-aa1c-daadcd39d406",
   "metadata": {},
   "source": [
    "- 构造计算图\n",
    "- 反向传播梯度\n",
    "- 多下游的梯度进行累加\n",
    "- backward时有效子图"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1577d949-e015-42f4-8e68-258faf9e9a92",
   "metadata": {},
   "source": [
    "## 其他话题"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a757fef4-22ae-4d86-bccc-6cf64bf95772",
   "metadata": {},
   "source": [
    "### 高阶导数"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7009aa52-6605-4596-9fb6-1f39ee2c3517",
   "metadata": {},
   "source": [
    "反向传播的同时也捕获计算图即可"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b53eac2e-639c-4311-8b9c-70fcebd58427",
   "metadata": {},
   "source": [
    "### Hessian与Jacobian"
   ]
  },
  {
   "attachments": {
    "3d1dc0ab-3343-43db-b3d4-6a7ef1e1b6f9.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAGjCAYAAADuElsoAAAgAElEQVR4XuydB7QVxba1ywiYEBRQMeDFCOZ4MaOIooIZxACoqCDmgGKOiJgFDGDAiygqZsWcUBTBnBAxJ8SA+BAToP/76v51Xp9N79S7e5/qPnONwQDO6a6umpXmCrVqoX/+V4xECAgBISAEhIAQEAJCoGIEFhKxqhhDFSAEhIAQEAJCQAgIAYuAiJUGghAQAkJACAgBISAEYkJAxComIFWMEBACQkAICAEhIARErDQGhIAQEAJCQAgIASEQEwIiVjEBqWKEgBAQAkJACAgBISBipTEgBISAEBACQkAICIGYEBCxiglIFSMEhIAQEAJCQAgIARErjQEhIASEgBAQAkJACMSEgIhVTECqGCEgBISAEBACQkAIiFhpDAgBISAEhIAQEAJCICYERKxiAlLFCAEhIASEgBAQAkJAxEpjQAgIASEgBISAEBACMSEgYhUTkCpGCAgBISAEhIAQEAIiVhoDQkAICAEhIASEgBCICQERq5iAVDFCQAgIASEgBISAEBCx0hgQAkJACAgBISAEhEBMCIhYxQRktYv5559/SvrkQgstVNJzekgICAEhIASEgBAwptL9VcQqhaPozz//NB07diyp5s8995xZeOGFS3o2bQ/98ssv5pprrjGTJ082SyyxhNlwww1Nnz59TNOmTdPWFNU3YQRGjx5tnnjiCfPjjz+addZZxxx88MFmk002SfirKl4IpBOBL774wlx77bXm/fffN82bNzdbbbWVOfzww81iiy2WzgaVUetHH33UDB48uOgbO+64ozn33HNDnxOxKgqffw/89ttvZskllyypYvPmzTOLLLJISc+m6aEffvjB7LLLLuaYY44xK6ywgnn22WfNddddZxo0aGD/vfHGG6epOaprgggcccQRlnjvueeedqNgnHz44YfmwgsvNGeddVaCX1bRQiB9CEycONGccMIJ5rTTTjN///23eeihh8x//vMfs+6665qXX37ZLLvssulrVBk1HjFihDnyyCOLvtGtWzczZswYEauiSKXkgSCx2mOPPQqSiPPPP99k0R141FFHma+//to8/PDDNRY5Jn/Pnj2tRWLKlCkp6U1VM0kEXnzxRUuoJkyYYDcG5Oeffzb/+te/zKxZs8ykSZPM5ptvnmQVVLYQSBUCm266qdl9993NBRdcUFNvFNhhw4bZ9XXkyJGpak+5lX3ttdcsmcwnt956q917DjjgAHPnnXeKWJULsK/PB4kV2nffvn19rWrZ9WLTe+ONNywZbNSokdlss80WMD/j/15zzTXNJ598Ym666SZrokbmzJljllpqKfvvb7/91qy44oplf9+9wDfQ1qhHVl2pkcHx4EX655VXXjG4xfn3RhttFOoCZnPAXL/tttua8ePH19R8//33N2PHjjWXXHKJOf300ytqEeME0TipCEa9nDACX331lfnoo4/sV5Zffnmz/vrrLzBmWX9dKMW7775r1ltvPfs8ISW4vlZZZRWDm7ASZZ35wpxlvlRSTsJwhRZPvXGLYtWTxaoueiDBb2aRWP3xxx/mnHPOMZhhmcx//fWXYWIvvvji1iTN5hechPvss4954IEHzLhx48yuu+5q0WbQQ6zA56233rIxV1Hk1VdfNccee6x577337IZ9yimnGL4n8QOBRx55xAwYMMDg5m7WrJn5+OOPzffff2+w3qJorLTSSjUVZYzsvffepnv37uaOO+6o+TnKyA033GBOPPFEc+WVV0ZqGEQey+mTTz5plQDGCGWlbbOI1Hi9lBoEvvvuO3Pqqada6z5rIpbaDz74wKy88srmsssuM/vtt19NW5hTa621lo1FZP1bddVV7e94vm3btnY9Zq2OOsaJdcQFj+K7zTbbmIsvvjhVYRsiVqkZ9uVXNGvECg0G0zPtYrPDlYfMnTvXXHHFFZZwdenSxdxzzz21NCwGeXCCT5061b4Lufrpp5/sIlCuQMhcoGaHDh3Mvvvua+PZKG/RRRcttzg9HzMCLMzHH3+8PbQAWaL/GQdYozi4MHPmTOv2w6LpJHec8PN///vfBgIN2aKccoUxu91225lvvvnGBsUzPhl/xFygyUqEgA8IMB8Y66xpBGSjiCD8HOUERRZyc8YZZ9Sqbu6cuf32280hhxyygOW3nDYy1w466CDrSsTbAMHCkvzCCy9EJmrlfD+OZ0Ws4kDR0zKyRqyGDBliTj75ZGtlatOmzQKos4kSTBm2AAQfPu644wxlsWAMHDiw7N5j0my99dbWxYSpF00OXzom69mzZ9sAaEndIYDm3bp1a3tg4dJLL12gIjNmzLBaOKSKsZSPWBNDQVwVcVYEszds2LDsRqEAYPXq16+fady4cc144+dYsSRCwAcEevToYYgzfPPNN0ODziFLkKbHHnusxvIfVu927drZNRELMDGL5QpWMixh//M//2PnHHOU9RYLGnWLagErtx6VPi9iVSmCHr+fJWLFQF199dWt355Nc9q0aQtMMjZMTv5xGoXnlllmmQV6h81yiy22sBsmC0kUa9U777xjJzobLQsBKS1wM3FyLEtxbB4P7YJVO/PMM2sIzPPPP2+23377BZ7fbbfd7CbBQQY2jVzBxcwmgWuDuBG0+XIFaxXjjFjA2267zVpWGR/EbV1//fWh47Pcb+h5IVApAiiFrVq1MvPnz1/AFe7KJrUALvQtt9zSKpRhBMcpEb1797YWrijiTtrxnccff9ySrBYtWpjLL7/cnu5Oi4hYpaWnItQzS8QqGHCOtQhSlDu5GczEzWCxGDVqlM1BFBRSL+y8887WcoBG1aRJkwioGhvkTLAzp2LIjYW4IMtIBeqlWBHAgnjvvfdaCyLxd2HWTeLxcHkwHnDR5Y4lyBlxWJRDMG4UwY2xxhpr2Ffffvtts8EGG9jNK43BuFHar3fSgQBpZ3baaSdbWaz5WP5zhYB2F0dFCpK111671iPMMxQYTsDhDYiauqdTp06WUOGuR/lI64EPEat0jP1ItcwSsQIArAtsVkcffbTVYnKFwcwmysTH9TJ06NCaR37//XdrwkYDQrNi4ofF1BQDmncIpiRPC3mPhg8fXuwV/b7KCEBiIETEi7gDC7lVwAUMeSIuDrdD8KQex8XZHNDSsY464lyuG8Jp8ASsk6S2PiRNrHJX63MxIEAg+lVXXWVJDIc0wqz4hDg4D8Att9xiDj300Jovf/nll5ZUcXiHdTfqfOHkLsoua/WNN95YUo6oGJqfSBEiVonA6kehWSNWDlUGLZshbhpSJay22mrW4sDCgMUKlyAnrzgm735OcDnuHCwVTggkJug9GMBcrOdYhAh6ZxG4+uqrbYC0xF8EcL9BtOk38lO5OClOP+FeQCA9btNgzJBJmvw0LsEhJI1YLIJoyxFcIjfffLNNBUIerHKJWTnf0rNCIA4EWFunT59uIEuEXjgF9vPPP7f/R1BKiE9FSLtAKAR5EHGvO1LFXGPelSO4zPECIMRp4Q5Mq4hYpbXnSqh31ogVxIlYFXJSYTFyQhwLCdiIr1p66aWtJWqvvfYy999/v30E7YqYKLQpjgYTF4VwvJ7jwsVO8XFsmLgCyuV0F4GeCKSMzO0u/sstPCV0jR5JGAGsVrj6HnzwQZu3DGFsYI0ipgqXxV133VWzOUCinnnmGevixVLFhvHpp59aso7lCctXUEvPV30IGCepEEg3443YkP79+9ufkfEfV7ZECPiEwK+//moVCtZXl8OK+uFWx0JF4LiLVXQ3EWBZwpV+3nnn2TGNO5C5hmLL2ujCJAq1k/AM3kNwSXLwCCFVCpZeBBc6+bTSJCJWaeqtMuuaJWLl8g8xWTm+zgbIhGMDJMPtfffdZ11/Lh6GZKAQMFx1+U5fETNAkHsxYZJ37ty54GMcQ3aLQrHy9PtkEaAvSOi53HLLWXLFhoDmDWHCYsl4wZ2MRo3bg3lCvhwsS4yzMGHRb9++fcGKQ8Ig92wW+YTTiIw5JQlNdgyo9NIReP31120aGwhRr1697NzA4sQBIXeqFms/bkLEJZvmOpd8Qep4CLD+FhNIGdauQhL1hGGxbyf5exGrJNGt47KzQqzw72MW5voZgiuJB8jdmCBPmJI59YeQ0A6fPxoXVqkwYSN17qBiXeU0K8ga1jE2anIl4d7hD2VhEZHULQKczITg4t4l701uVn0snSR1xbIEESKxK+MGlx3HyfMJ7kCIWjHBRcxGxabEJoUwxpxlEzJfjuu52Pf0eyFQCQIoF5x+xYqPwuHGrCuTOcLay9/ME4R5RRJQyFM+IQ8VMajFBAJCXjcUG9zzfIOcVRAuhLW1mEJT7Bt18XsRq7pAvUrfzAqxIh8KMS/EUpHWIMx1B9k58MADa5BlA2XBYIDnk3JjXigLyxWWD9w7HNcvt4wqdX29/Iw7Ek7jceuFneZjg8AdR8wV4k4f8e84x8rdd99dkwAUYl8KKauXnaZG1xkC7A8ohCiswZjU3AqddNJJVplFsPASk0isYpzzJRgfy6GSiy66qM5wiePDIlZxoOhpGVkgVlyvQJA5Uui+NndHFc+RNZgAzKhHfvN1J5OfZJG4cuT682vQM9axBKH5klWfgw1hpJcFjz4kGBdhfJGfJ27hFgBiUVq2bGkDgeX6ixthlVcpAmeffXYNgXnqqacMN0iECe50d+iHdAgoMHErlLjgXaA81uG0Xw0mYlXp6PT4/SwQKzQqXCsIGxSXe4ZJ0EKQVBoErqtxQZQEPnft2tXj3q9fVXNZ92k1bgRyjYUJ5BiXLXODv3HxYsGKW1wCUkgb5E0iBHxCANcfaylB68QFcignH/kPnqBNKg1CUIHm0EjaDwKJWPk02mOuS9qJlbvTD1i4YZ2TXvk0JRdbw7P53ECVwkviOjQ2hLqRE0tS9wgErxiiNsTZuWPbubXDlexinHr27GnvI4tbIG8EqWM1zYJbI258VF7dI+Du9KMmnHbl5F+YMLc4EcsF4rgBydLu7hGMsxUcRkIZInkzp2rTbuEVsYpzdHhWVtqJlbuME1hzE34GoWYQc1LwpZdesqdZOOKexMQcNGiQzd+Slcnv2XCNXB2IDPczEjhOjjFOiuZLoeGuzOBjXK7M9UZxS9CyyWlV0npIhIBPCATjpsKC1l1dudqJVCSkViBNCUma4xbWb655wgWY7yaEuL+ZdHkiVkkjXIflp51YcazXZfLlBF4wOD0Ia/C6BfIWuZisuKHn+wTJc/0DMQlxxxnEXd/6Uh7uDHcikzgR+qaY9s1pUdzHSfQhhxpcssRC7uv60j9qp38IYKVy1tpC1nfWU3ICklOKO1LdFU1xtgjFCOs/t2qcfvrpNpY27SJilfYeLFD/tBOroMWqUCZed+9bUhoVEDP5OWLM8WSSPbr8LhkePqlpGif8IFYkcg2e8sttAIkISXuABs6/c1MxxNVgd10O8XjkBkrCehpXXVVO/UQgaLHC0ht2jQ3kgJO1XGRODCOpbpKQoGJE7qtCaRyS+H4SZYpYJYGqJ2WmnVih7XPrOoOU3Cm4+3JlwoQJNgEkqRgIcnfXkMTdBUx+XIAQLLl34ka3svKCcSCHHXaYzUmVK2wepN8ggzQJX0mImJRwqOGee+6xmj5jJQmrWFJ1V7n1AwFniWJskieQOzNzxXkMkjoJ6L7H2r7DDjvY/3733Xeh98CmrVdErNLWY2XUN+3EiqZihSLQkpMpHPsNyosvvmjjV7BU8G+sEUkJ5TtihxWiefPmSX1K5UZAgOBacotBxHFZBJO1EvPUvXt36yIkRg6LUlISdGtg1XRX2ST1PZUrBKIgELTA4xInxikoxCKSgZ10ISisSeZh485VsrqTPPezzz7LhIVXxCrKqEzJO1kgVpwQ4ToFMll369bNnspjkpMBHa2LycidgJtsskmivcI9Wtz9xsZNLIDcO4nCHalwdyyceA2u2+Ak6fjx4+1VR1gcIVRJEx20f3ehMy4Ud79apAbpJSGQIAIoINtss41VTLm5grFKsDr3/JEBnfv/cM2RjiFJIds7dxRC7khjkwULr4hVkiOmjsvOArECQnKukImXOCtSLjRt2tReqoxr54QTTqi5rDNJuHv37m1dTFg+iP2S+IkAAbmcLmKcQMoh3NwpyTU2a6+9duKVdpZNktOSoTrMxZJ4JfQBIVAiAiiJXLmEVYq4Q4LTiSXt2LGjTcOQNMmBgJAaBRf9lVdeWXMfYYnV9/YxEStvu6byimWFWDkk3BUK/F0NixHmcr7D90hUihY3bNgwayKX+I0AfYe4uxyTrK0bl3zLJSrFysq1SklvTEm2S2XXHwQYw24cV3NtdSlSOIBSKP9c2npCxCptPVZGfbNGrMpoesWPcuyXGJkePXoY3IC4H7FCkKHYZV+v+CMqIPUIYEUltou8Wbir+/bta9M4MGawkkmEgBD4PwTmz59vE44+/fTTZsiQIdZdT+A6+Qfff//9zCgiIlYZHvUiVtE6N5gXi4B47n0jSJ48VuTTkggBEGDxJG/Ws88+awHBnUKCQ5IpcrrJxVoJLSEgBP6LAKdkXToFwiuI3yLMg0ueCevIiohYZaUnQ9ohYhWtczmZwkW9TZo0sUSK2KpJkyYZUjvku6sw2pf0VpoRCOb54WDDtttua0g8WiiTdZrbq7oLgUoRIA0J6Ui4KJ0s7ngE8AZgwWrYsGGlxXvzvoiVN10Rf0VErKJjyoQfNWqUDXhmwrMguDvmopeqN7OGwLhx42y+KvKoff/999YFyB2EEiEgBBZEgD1pq622Mly0TEoUPAIcBsqadVfEKsOjX8Sqss7l7kFOdXECsRoBnZXVVm/XFQJYOHEfc7pJpwDrqhf03bQgQEoHrP+4AbFcZfGAh4hVWkZjhHqKWEUATa8IASEgBISAEKgAARGrCsDz/VURK997SPUTAkJACAiBrCEgYpW1Hg20R8Qqw52rpgkBISAEhICXCIhYedkt8VRKxCoeHFWKEBACQkAICIFSERCxKhWpFD4nYpXCTlOVhYAQEAJCINUIiFiluvsKV17EKsOdq6YJgZQj8NFHH5lBgwaZOXPmmFtuuaWkE5XcZ8eNCGS6Hz58uFl88cWLovDqq6/ae+iaN29urxzSCd+ikOmBChEQsaoQQJ9fTyOxYuEbMWKEz7CWVDc2gCweIy6l8eeff77N+yXxAwFybD366KN+VOb/14KNZ+uttzavvPKK/clZZ51lLrzwwoJ15B2uPpk6dap9rpRLe7kzslmzZvZCboSklIcccog3WHBZ+EEHHeRNfVSR/0Pg+uuvt0l/o4iIVRTUUvJOGonVwIEDrVaZduFKk/pKrE455RSbXFXiBwLcIuAIjB81+u91QNtvv7158cUXbZVOPfVUM3jw4KLEirvluFMOwXLVv3//ou+suOKKZsaMGfY5lDauUvFFuAZpt91286U6qkcAARKX7rTTTpEwEbGKBFs6XkojsUoHsqqlEBAClSLw8ccfm0suucT8/PPP9hqgxo0bFy3yvffes4Rq7ty59p1GjRoVfee1114zV1xxhXU13nDDDdaNKBECSSIgYpUkunVctohVHXeAPi8EhIAQEAL1DgERqwx3uYhVhjtXTRMCQkAICAEvERCx8rJb4qmUiFU8OKoUISAEhIAQEAKlIiBiVSpSKXxOxCqFnaYqCwEhIASEQKoRELFKdfcVrryIVYY7V00TAkJACAgBLxEQsfKyW+KplIhVPDi6UsiJgyjBYDy4svjwxwnpKdKaoiK3LRoj8YwRlfJfBNz4Yn7w7yzNlTS3Jd/4FLHK8MwVsYqnczniTYZokgyS+HPNNdc0J510ktljjz3i+UA9K2X+/Pk20zbH5j/55BPb+uWWW87stddeNlFkq1atUoPIn3/+aYYMGWKuvvpq880339h6r7DCCma//fazbWnRokVq2qKK+okASUQvuugiM3bsWFtB0kWQuLJv375m//3397PSeWr1/PPP2xQbTz75pH2iYcOGZscddzQnnnii6dChQ6raUqiyIlaZ6coFGyJiVXnnfv7556Znz55m5MiRZvXVV7c5d0joN3HiRJvI9Ljjjqv8I/WohHnz5pm9997bkMOIzNkdO3Y0s2bNMi+99JI544wzLDkha/vOO+/sPSpcxeI2g6uuuspsvvnmhsSwL7zwgm0LpOuRRx4xm266qfdtUQX9ROD22283Rx11lDnttNOsMrfYYotZ5W7YsGF2TTr66KPtv9Mg5BK7+OKLDTczHHnkkQYPwJtvvmkuv/xyc//999vM+ygjWRARqyz0Yp42ZJlYMSnJwPzDDz+YZZdd1my88caJuJFYAMaPH29Gjx5ds0FOmTLFtGnTxt5T9tNPP5mllloqw6Mo3qadd955Nis7m8MSSyxRq3CISPv27W2/Tpo0yay99trxfjzm0o444giDNZPs4blJJ//nf/7HbLbZZvYevDfeeEOWq5ixrw/FcZfieuutZ68jylU02LiHDh1qFTtuqxgwYIDXkLz88stmu+22M2Sa33DDDWvVlbagiOAVgEhm4YofESuvh2NllcsisYJQQXLQct55550agFZeeWVrLse6FKdsueWWdpM/5phjrMsHYdJwoeuPP/5oN9Vtttkmzk9mtiwsU6ussor59ddf7UKK9poraOGHHnqo6datm7nzzjsTIctxAPzZZ59ZlzBuzeuuu866ZXKF8Xj22Webk08+2Y5XiRAoBwHWMu42xDX+4YcfmgYNGtR6nfWdexARLOvu3+V8oxrPsl7uuuuu1v23xRZbWGt/bizlt99+a1q2bGm4fujTTz+1LsI0i4hVmnuvSN2zSKwOPvhge+/ZZZddZmNysAzw/3PPPddMnjy5pDvHyuly3Do333yzueCCC2pif5g0XGz71VdfGWIGuPNMUhwBFtZddtnFPti9e3fDXVy54qyBLLzff/+9WX755YsXXAdPcJ3KYYcdZr+MiwY3R648++yz9q4xrmrBsoobRyIESkGANWbVVVc1X3/9tbWGosSFXfmz1VZb2fUPV/QJJ5xQStFVfwb3P6QQpZhYSuZ17uEOfsedll988YVdF1gf0iwiVmnuvSJ1P/30022AMNKnTx/Dbd1pFixGuJJwI6200kq1msLkJfbpqaeeMnfddZfp2rVrYk0lPghrxTLLLGMXiVxNMrEPp7xgNgesUcjw4cOtdporEBCsgci9995r9tlnHy9bjVbNnFp66aVtIH7YpodF1bk9Xn31VautS4RAqQiw1j333HPWGnrAAQeEvsYBGlyFKJnEKfkqxx57rPUwEEMVFj8JEcE7gHJMTBl3OqZZaA/7A9Z5Lg4PeleC7Vrofx/8v3PRaW5xPar7L7/8YuOPkDT44Qt1DfE3mMQJDs63iDz88MOmS5cuNv4J8pXUkfcePXrYOCEmP4uAJBoCwSPkzjWAS4NDAghWIKxBvoo79k79ctNG8DPiSrbeemtb/TFjxlj3pkQIlINA2Bhzc4XfcXgCyygEnkBwn9OVuLaEzRUsVm3btrUuz06dOlmy6HNbSulDCBUxmLhBH3vssdBXRKxKQdKzZ3CTOU2akyOcIEmrEADsTleh8bjjusH2YBFxcQb48dGA4pYHHnjAnmrDFXnKKafEXXy9KA/XBa40DgVg+l9jjTXs2EQz53e4NxBilM4888xamBCnRQDsOuusY62WbvHFYkm8G+4EXCjVWpRZMIkFmzBhgpk+fboNuMdSDInC4kbaBYT29urVq1ZbsM6hALChYKVzdf7jjz8sKVt33XVDrXr1YpCokRYBFMkRI0bYjZmxghUE9zKuv6ZNm9rg9g8++MCstdZalpTkjnvGJS7oTTbZpNYBCzZ8QkU49FMtFzVKE2EVjz/+uK0zazVehsGDB9uDLLQHYwChFYRYBAXiRVuwEENYFllkkZpfQyj5/UYbbVTr53U9hP79738bLNV4T/CihImIVV33UoTvZ4lYcbqK0yL8TbAwrrhcYXJxUo+AYvIKHX/88RFQy/8Kp3Rw5+DGStLVGGulPSqMPGBY+9BGIUbEKEEepk6davv08MMPt4oABwUQXL/u3/yfQF7ILHmiKIv4q2uvvdYGvZLP5/fff7fvsdlwuihJFy2xLwceeKAlcxB4YkJat25tTf4oMViI2eg46YTgpsHS6sS5tYnVc4G7bKBsGLSFutMeNhl+npT11aPhoarkIADhIDUB6xmuNIgD6xtEnnCEZ555xs4F1j1SfbCJO2LFWtW7d287tzgwwvPMJcrjMMVtt91mCQrjmE2f95MSd+oPCzQEipOMKBMoQ9SD9hGm4k4Bd+7c2Tz00EO1iBNtIewC8sV8YR1gfUcZI6UJ77Im3HfffXZt8UFErHzohQTqkCViFUai3M/cpkOOKSYeQt4Xt6nFAS2TGhM1G6KzqBBnAxEgIFNSGAGniZLsEALFUfHgyR9+z8YB0XJmc/7GjI6g6aKlswnwzJdffmn/pgz6AC0eQkO/Q7aILezfv38i3cJmRIJGNHAsamxWQQ2an0OIOKmK5QmBcLGRIYxLrFm4B7GwYT2g7VjgsFZB2Kg/bmbIJDFcLjYtkQapUO8QOOecc2xeJxRISEYuWcDCi4UUCzqChZTxhDA+WaOwnBIHiBCLxXzCcoXVl7AJDt+grGI5woKUlJWX+c4YhrxBfJgXTiBdxFEyf5gTSPAwCASRBKJ4CGgjJJK5xbzC2kaICG3BasUcoX3EpSXVlnIGiohVOWil6NksEivcQLhVOK2HFobGj4uFTRRTORsUQiZfElAGBWsXLkJitYjjcYQMjQnLA8HUmNRzJ+Xs2bOttYFcMcHswFgWCMbMzcuSoiFStaq6IFusO5j0g0TEVQLtMxi0imsX0kpeK7RYkogGDy3Q1xA1/iboFdLFqVEkqRQHc+fOtXFTfI94Pja23PHCZsF4cVo37hvagssFVycbDRuDi38MngAj1w9uEMihO+VFpmo2SUn9QADyse+++9rGMr432GCDBY4YCBAAACAASURBVBrOOtauXbuan7t4RIgHaxSEiXHmBKXExSsydrEYcSsAaxvKKOMzCTKCIoqFirFPihKsy7mCNTd4SAWLHMH6kCbmGilL9txzz5rXWHNJ1UKZKCXUn7UbCxiWK04WJ9GWckefiFW5iKXk+SwRK05XkJARrQyNBY2eIHUmKxsQmgoEB1cTQvoFTtU4IZs3ZAvrBrEFmNQhXmzKaEJMYv5Avojfwq2DsPCQIoCJi4sJcUGYLBrECOH3l+RHIJiaoNCJTZf3iZLYNCBgCIsumwuWISeQYUgXli5yREGkOKbNhsLxdHKPodHmCn0PQUbjj5KAlAXdZYcmRgzLVZhQvjuFS5zV3XffbR8jASqEvF+/fjWvMbabNGliNwbyeJG/CGKFqwOLHMQSy5YTNkGy/hN3CGmDrOLmyU1SqjGZPgSwurP28DfrDvFIYeLcx+53kAmsWpB5xg1XRQXdx5Ab1ivWSMYNa50jVvnShVA2pAcLLGtnucJ71IlvQfJuuumm0CIgeu7ELGPYJX3GyoWiFXRxUgBznLm+ww472MB9sKItzB/mJznyfBARKx96IYE6ZIVYEWuCFoaWjybDibzgJsLvcbOgDbHZISQRxaWCkIOKSQq5Ihs2ExdSxiZLoDPxMZjeeQ4yxqaHqyo4icO6h9gFXFKS/Aj89ddfdqPAPQEJAHtIbZhAeJz7lr9x6yFYbCDMQW0X0z9kGoF40J8QXndoIbip0Ee4EiHBDz74oHWFYPHEOlSOkGWf8cK4wVIKqc+nGWNFJX4EwZ13yCGH2PoxvlAEIFJOSBHC1T4IwcpsElgeaAuLc7AtuG+wlLEZYvHCYsbYxvXDJiySX06P+vdsMEWOGzdhtZw2bZq1riP8DbFinDAGsKpi4XXCuGOuvPXWWzY2CbcagsUfRTM3sSiknjnDuMSFjYuNMVauuASnvPf0009bd32YYKFF4UB4hu8yr7DcOTd/sC14G5jLwZPuuDJRfoPzqtz6xv28iFXciHpSXlaIFUHOWD2wMGAaDwtKduZhBz0aG1o+7iPMyGg9nD5zAlEj+JNFiUnJZCaGCgkuJMTtEF8VJmyuLkmkJ13uXTXGjRtndt99d1sv3BvuItmwimLJcb93/ZevQWiyuA5ZTLlfsJDp3xErYjvQcLF6RiFWHFpw6TUIJmYDChM2MlwYuP0gkYyfsDxX7l1nqSvlyDyKBVaAoDUWRYDgfzR5gvYl6UQAKyzKw4wZM2wDIPIuZjS3RQRsO/KEqwylMJ9ghYdwMy6feOKJGhKf73ksW1iCURxREKIQKyz9EDasVcUS5N544401sWD5bjFwdUXxcPnvXnvtNa/v4RSxSuc8LFrrLBArTNvOv14oZYTbaAHF+dn5N4sPG1bw+hQWGKf1YCVB88EahrZE8DDBj5iZJZUjgIbsspIX6j8sNFhqcHPhAiHQNh9Zov9w32KBxCoJmSg1psKRkCgZ84nfwhKK5J7yCyLl4lZwTRTblGgLwbnUpxBZo/zgVUpo86T9QAjwZczjNuTbcglWPm7rogQUPGKfkNxTfrn1OfXUU60LnHGPyw1Laj5xyg3jAmvtkksuWVLzIC7Uw11CX9JL//+hoBW2WPJS59qD/DnLdr5vuSuvuJ8VF6DPY13EqpwRk6Jn006s2EiIrSFAkUBFtJV8GhyLDIsNwt8cVUbQvojRCbqRsIY461XQcoHlg83d58maouFnq+qsjfybgwfOfZfbDuKp3J2LhWKXeA/NHq0Vt2JYktZgUsXc70QlVpSJRRONH8Gq4DLE536DeCqIHwH6HKjg9GI+wZqA+wL3De9htQtKblsgYeBDygp3PRBWAXfCEvckhzMk6UOAfnXXYxUi2SghjCkINfMLN3chIf6QeFI2ehTIUpWQSoiVi3ekXoWSUzN2OZBCqgS8DpyELCS41FGkOAyD0l2sLVircRu6WEjmEy5QvguJLfZ+JaNIxKoS9Dx+N+3ECvcdgxMhkRzm73wTwR3p5VkClwvlZSGIkkB4tB7M7flifjzu2tRUDZxd0CqxSY0aNQqtO5YdtFHce7gDgkKcB7FRxFnhfoWgESuHBNMY8H+CerFiYfEK+1YlxIrFHO0fQsVR97DcUsFs2GEJTgnUpW64FCHxEDWXUgJiHzz1iAWDoGHiZty4h4Dx7aCFAvKGAkLMFYRP4zk106NWRYOZ+jn44FIl5LYGZRCLOmOF8R9M94ILD1c3bjgUSsYjFnvGSNhJaQgc8U1hV0dVQqywJrtcfxCgYMxXsD1YgLEEEyPJ94JzFsUJgoY1ljkCocSdz/gPm1tY1lgjXCwXMWXEI0LaqAuxZSgjxCkSToKyzXxOKi5LxCqd87BordNOrDj5546ZF7pklMWDCcemSnZ2Nq9CmgjB6iw+TFYmVpJaS9FOyvgDzkXLZo91Jswa6IJXiR2i7yC8ToJB6px2IvEr8UWcEKQsDi4EyyTgnUBeiFhYv0YlVtTHfZfYE7TgsPI5Kg6xQ0MmnitYN2L6XLoO6s+BCTY2DkqEkTWSImKdI76wkLgTiFhpndU248Mqk80LxiW506G5DWW8s8Yxxjm9HLx3j3UQhRLFA3cf6z8kwlkwc8vk0AcWZCz4wdxS7ptOgSHOqtgYzK0nOf7cyep8gesQHhQC3P8o0cG0NSgQrAeUg3eBRKesBU6hyiVrpMtB+caV6OIZIVVYwSB5eDQ4eQghAzOX87BYfFolA03EqhL0PH437cQqGJ9T6BJbp8HRFZySCuY8ye2eYlpPITcSZWFVIBaAE26S4giwWUBE0KTDgk3RuFnoeI4+dkk0XcmQDsgHgssDVxkmfDYMCBhj3BEc4o6wfHFgIbccV54jVlHi6Fi02aQYI3w/9yJwXDkE6kMi0ZZpd1Bwc0CmEIgfAe5o41hNc08Z0laUCqyv7u7EMLTZUDhRSFlstMrQXnxM+vwEZJq+D3MFEv+JixlSEUYIsAi7+Cl3LQz5/dwpwOB9lVg2sXpRXvAgRBCbSixWzBHmAtbZMFcg8xbiw9odFrDO/HJWWaxpJA8NhhUEyRruPsa/S6NCGyBtuO5ZU1wMV/Adl66CNCWEiyQhIlZJoOpBmWknVsGjx4VOyLhjvSwSWAyClgQsUpzeYkPFHB3UpLAouGO+dJfLh8IGGoyfYZFgIpKDiUWC02FhpnMPutzLKjhzPxosVhUwZxNAi2RRhagSDB6WEwpNFZIEWWaBJACeODu0WU5CQVTQ0sm+zOJLH+U71g04jljl9n2pwLFJsVmR/wyLKosnLgvSQ6DV416gLmFJHSFJ5JzCbY12TfvR0onFol38H+0cgsgmACYuv09Y/ch/hfWC069o5UFLX6nt0XN+IcAJUsYzxALCw5rGvGEOYW0hPgirLClIwhLTEoNH7BXzCosTaxVuRaxOuNuwlBKz6jKZYwHOJ45Y4V5zqUPKQYuUEIxfUq5weAgiRWwkqRtYR3HpsR6E3bnKmkseOhQulCvmA0ozz7MOkCoF6yx15HAMebqc0kIdIaG8y7VXzEmUHNKXOMw4fYySRphCMJFqOe0r9qyIVTGEUvr7tBOrYAZil98ntyswDzN5mbBYCYLB7QTyYhHArOwuwnSZgJ1WE/SvszmSPI/N2U1ATO745dm80PK4/40NXMSqvEnBxs9GQdyQE2KMcMeySbgj1GGlkraA+/JwWUBIIDb0D4sjiy73j0FkWFxzrUi55VVKrCgPoo5rmtNYTli4IX+QvUIxGxA6XDK4Etk03cXoWCnIWwTJhLSR64pNIZ8wt3FpQzDd6bBi1tbyekxP1xUCWGCITcRFDilBiD2CRDOHCikOnPojUB1LDeOQccrcYi1EUcXthtUVUuFi+5IiVpQLiSNuElLDKVkEBQDSwbx3rr2wOqCwQJogiJAj2sX6zhqCxQ4rOOsyMVr5ctLh7iSxczB/F99ylsFCh1Aq7X8Rq0oR9PT9tBMrNgoWE8gTmheLTVDYaIlZQbtjEXKnytwzECTy/uAewfWCywQSRi4sJBhMzYbHRsWClHuqym1YZHNn42RDd1dOeNr1XlYLHNEiWey4A41FslTXFe8iYVp62M/zAeCIFfFOaPdRhfqwiUG8sQTgGq5WW1AUCKQn3UIwwJnNBWWkECGL2l69V30E6GeCzjnxiYIYdg1UvlrlI9mEQjCHSokrdRYrTuJB+isRTuHRFuKfsMCVOlcKfZO2FCsHax3KC6doUcoQ3kMRwtWI0gbpxENRahqKUnEQsSoVqZQ9l3ZiBdyYtbneBO3kyCOPtG4kJgBEiMBoFhvcf27SBLsIUzOuFeIN0Jow+6IBQrDIXI1VgPgezMxYETjGG1aOK1PEKmUTIKS6jlgVygTteysh9cSvBC9mdtng0fJL2TR9b6PqV/cIOGKFRYjbLtIozBVciMRcuaB2d88iblCs3HgkiD/Ll8onartFrKIi5/l7WSBWQIxFingWTozh7oMcccSYCYH7LjdIONgtBEejtWBZQKOHHEHGOMJOnAH5sQiGJli0WP4fESvPB3yB6jmLl0ssSrZnZwFNExEhxsRd9ZPbXNyhzhqb3p5SzesaATdXSAVCADiKKK583NRpmivgSNoJ3OUc8nDiwkFQ2vGGEBOZBHEUsarrkZzQ97NCrBw8mHDdpMcEHMckLycuRcQqoYGacLEcWCD7c5hGymZRSqLBhKtYcvHE2hCYGya4ssn7IxEClSBAPGrYNV7sJwSx5ztxW8k3k3gXVz3EijgzTv854XASXhAUadzmHAwgTjNuEbGKG1FPyssasaprWEWs6roHKvt+vjitykqt7tuuDWFfjUPRqG5r9LU0IJDmecNp7nwHWspRqqP0k4hVFNRS8I6IVbydJGIVL54qTQgIASGQVQRErDLasyJW8XasI1bEG+y3337xFq7ShIAQEAJCIDMIiFhlpitrN0TEKt6OdcQq7LLceL+k0oSAEBACQiDNCIhYpbn3CtRdxCrejhWxihdPlSYEhIAQyCoCIlYZ7VkRq3g71hErEo+6m9vj/YJKEwJCQAgIgSwgIGKVhV4MaYOIVeUdS8Zgrl6YM2eOPcrOKROuUeC+Ko7vk2RUIgSEgBAQAkIgiICIVUbHg4hV5R07f/58M378eJs/y10Fwb/5Q04h8qFIhIAQEAJCQAiIWNWDMSBiVQ86WU0UAkJACAgB7xCQxcq7LomnQiJW8eCoUoSAEBACQkAIlIOAiFU5aKXoWRGrFHWWqioEhIAQEAKZQUDEKjNdWbshIlYZ7Vg1SwgIASEgBLxGQMTK6+6JXjkRq+jY6U0hIASEgBAQAlERELGKipzn74lYed5Bqp4QEAJCQAhkEgERq0x2qzEiVhntWDVLCAgBISAEvEZAxMrr7oleORGr6NjpTSEgBISAEBACUREQsYqKnOfviVh53kGqnhAQAkJACGQSARGrTHarXIEZ7VY1SwgIASEgBDxHQMTK8w6KWj1ZrKIip/eEgBAQAkJACERHQMQqOnZevyli5XX3qHJCQAgIASGQUQRErDLasSJWGe1YNUsICAEhIAS8RkDEyuvuiV45Eavo2OlNISAEhIAQEAJRERCxioqc5++JWHneQaqeEBACQkAIZBIBEatMdqtOBWa0W9UsISAEhIAQ8BwBESvPOyhq9WSxioqc3hMCQkAICAEhEB0BEavo2Hn9poiV192jygkBISAEhEBGERCxymjHilhltGPVLCEgBISAEPAaARErr7sneuVErKJjpzeFgBAQAkJACERFQMQqKnKevydi5XkHqXpCQAgIASGQSQRErDLZrToVmNFuVbOEgBAQAkLAcwRErDzvoKjVk8UqKnJ6TwgIASEgBIRAdARErKJj5/WbIlZed48qJwSEgBAQAhlFQMQqox0rYpXRjlWzhIAQEAJCwGsERKy87p7olROxio6d3hQCQkAICAEhEBUBEauoyHn+noiV5x2k6gkBISAEhEAmERCxymS36lRgRrtVzRICQkAICAHPERCx8ryDolZPFquoyOk9ISAEhIAQEALRERCxio6d12+KWHndPaqcEBACQkAIZBQBEauMdqyIVUY7Vs0SAkJACAgBrxEQsfK6e6JXTsQqOnZ6UwgIASEgBIRAVARErKIi5/l7Ilaed5CqJwSEgBAQAplEQMQqk92qU4EZ7VY1SwgIASEgBDxHQMTK8w6KWj1ZrKIip/eEgBAQAkJACERHQMQqOnZevyli5XX3qHJCQAgIASGQUQRErDLasSJWGe1YNUsICAEhIAS8RkDEyuvuiV45Eavo2OlNISAEhIAQEAJRERCxioqc5++JWP23g+bOnWsGDx5sXn31VdOoUSOzySabmBNPPNEsvvjinvegqldtBB577DFz5513mh9++MGss8465phjjjGtW7eudjX0PSGQCgR+/PFHM2jQIPP++++bZs2amZ122sn07NkzFXVPupIiVkkjXEfli1gZ89dff5lOnTqZ7bbbzmy++ebm8ccfN0OGDDEbb7yxefLJJ83yyy9fR72jz/qGwA033GDuuOMOc84555gpU6aYiy66yMyZM8fcddddZvfdd/etuqqPEKhTBL755huz2267meOOO840btzY/Oc//zEPP/yw6dq1q1VOFl544TqtX11/XMSqrnsgoe+LWBkzcOBAM336dHPttdeahRZayCJ99tln202TzfKRRx5JCH0VmyYEpk2bZvbaay/z/PPPW80b+eCDD8yGG25orZzvvvuuWW211dLUJNVVCCSKwL777mv23HNP06NHD/udf/75x+yyyy7mqaeeMhdccIFdZ+uziFhltPezTKz+/vtv8/nnn9s/SyyxhNlss83MoosuWqsnmegbbbSReeedd8wtt9xiDj30UPv777//3rRo0cISrZ9//tlqW1GFb/CHshxxi1qW3osfAfrm119/NW+88YaZP3++tVQ2adJkgQ9dfvnl5tRTTzU77LCDee6552p+j7XTWTlxC1YijFmkvmvylWCod5NHgHHKmjlz5kxr0V9//fUXWNuw5LJuMqd4lmcQFNXOnTtbNzqKSSVroltb0zpfRKySH6t18oWsEqtHH33UxkyNHz++Btdll13WnHLKKeaMM86oNZk7duxonn76aevO2X///Ws0q4YNG1o34euvv25jrqIIMVtstsQX4GbExbjBBhtEKUrvJIDA119/beM/br75ZvPHH3/YLyyyyCLWUonbb8UVV6z56u23324OOeQQ06VLF/Pggw/W/Lxv37722eOPP95cffXVkWoJsevTp4954oknrBIwYMAA+3+JEPAJAUgSCuiVV15pPvzww5qqYalF8dhvv/1qfsaYXnvttc3s2bPNxIkTTZs2bezv3nvvPUuymGfEtkYlVqNHj7ZeBdyNu+66qxk2bFiNJdknzArVRcQqLT1VZj2zSKzOO+88O8kuvvhia4Fi8mKN4P9YFvbee29z77331kxoFgs22KAbh/+vssoqBnJFkPJSSy1VJrLGvP3226Zdu3amffv21t247bbbWivY1KlTZZEoG834X3jzzTdtIC2bAWNmhRVWMB999JEl2JdccolZZpllzMsvv2zWWGONmo9/9tlnplWrVrU2A8p49tlnLTk77LDDyq4o2v/2229vtXoUgf79+9vYPv7NmJEIAR8QYJzus88+do5AoiAzs2bNMi+99JI588wzLWGC6PBvJ1itIFise07uv/9+Ww6WYdblKEJ81oEHHmjOOuss07ZtW9O9e3fTrVs3M2bMmCjF1dk7IlZ1Bn2yH84asWJD2mOPPayFaM0111wAvKOPPtpcf/31CywAuQ+ikZ188snWugUhK1cwUW+99dbmlVdesfEEEDzIGgLmSy+9dLlF6vkYEfj999/Nuuuuaw4//PDQOA80bEgxz0CQF1tssdCvE5sHIYeEM+Yg4uUK1i6sXljDVl111ZrxhnWzUtdiuXXR80IgHwIXXnihtVZBoJZccslaj2HZR4FEEeHULKQrn0CCIEAQLGIWyxXI3FprrWU4bUhcI9Yv1lsIFv+PagErtx5xPC9iFQeKHpaRJWLF5Npqq62s2blDhw5W68+dZJiv2SxxC37xxRfWKpErM2bMsCZsJi/aWJSUC1gfCGrG90+MFv8m1gstCxO2pG4RwKIJaYEIoTUzJnKFsQQx5iQTpCdM2CQeeOABG3PFIlmuMGY33XRTg/WMOn333XeGDQyChRVMaRzKRVTPJ4EA+wRj8pdffjGnnXaadZ/nyqhRo2yQ+pZbbmnnTRjBYT3FCotCc9NNN0Wq6ogRI8yRRx5piRSuc5Qa3IpYy6hbmkTEKk29VUZds0SssEIQn4Ksvvrq5uOPP17A5cZGttxyy1myQ8zMQQcdVAstNC82VFx/aFRhQcylwItr6fzzz7cbNpYMSBwxPARsSuoeAY5733PPPbYinPLDFZcrJ5xwgrnmmmsMMXi4kHM3CqyanGwaO3asJfJR5NNPP60hT2xGxPIRl4e1LPegRZTy9Y4QiAMBFIcdd9zRFkUc6t13371AsZyaRRlFUGBRToPy1Vdf2fHN3OMENmQoipC+AasYazdrOEosp3SD8ZBRyq2Ld0Ss6gL1KnwzS8QKuLBCYA4mRgaClCsQK8gOcU64BbESOPnzzz+tZQJShVbExHen+crtCjZqYmSwaJD3SOIXAg899JC54oorbO4yLERhQlwc8SKMBzT14MkjNhbeoxxIPBJlrAwfPtwcddRRdqwxF51i4Bdaqk19R+C3336zhIgxfuONN5qVV155AUiCe8mtt95qevXqVfMMYRDEMkKGjj322MjzhXhY5iNKKooNSZzTLCJWae69AnXPGrEKNpVFgIBLLA1uU+T/aDakUyDHClYLZ4kg6SNaFYuCExYCgolx5ZUqfIMjyFjFsjD5S213Wp9zR7apfzAlBjF29B8SjIvjiDgHIDhJihsCwe3MH4J6yxFOEqK9E8jL6dM0xYeU0049mx0EgvOFVrm1lYMd//rXv2xDUWxPP/30GgKFlYkUCyizCGWwphK/WM6YJ3DeWcJwKxLHmmYRsUpz7xWoexaJFSZpgiwJGmcT5LQXFiTcc5iM0XiY2AS5kwUYue666wxuGVI0BCc6G+cnn3xiGjRoUHQEuBxExFK52JhnnnnG5j0KLkBFC9IDVUEALRxrIq484qw4PYqrArJDSgVOGTmXB4GyuJAZC2jcuVo7iQ4JYj/iiCOK1j24MXGiEFckpwmJOeF3GitFIdQDdYQAwemsrS+++KJVQjkhS8JPXOLMIbfWEQaBosp4hkxtscUWtSxYxBKS/43YwlKIlVtbUYQPOOAA23pOG2Lh5RvKY1VHA0KfDUcgS8QKMzEJHLEAEMs0dOhQmzMKy9HIkSPNfffdZ3/mYgUOPvhgQ8AlG1q+DRFiRXxUscnPQoNbqZCQQ+uyyy7TUPQAgXHjxtkAWCyXV111lT3FBOnm52jajBdO6hErQt/jJuZQAxsEJwHDhGBzTkYVEjYB4lCI/8sn1INvFRtzHsCoKtQTBH766Sd7vx/5ASFELn4UJfbSSy+1KGB9ca458rmhoODmxt0dJqRcIO1NMWF+nnTSSQUf45QhilDaRBartPVYifXNCrFiw0KTwcLAqROy+wZP/PF7Jjka0muvvWbROffcc60VC9cgGlSYsIiw2RYT3sc6hmAFIacRuVsIrkSb4vtsykqzUAzJ5H9Pck/cwJwIJCh9m222qfVRXAzcbfbWW2/ZfiOPFS4IUm+EnYZyL0PS3FU3hVpBIDAaOJuV2wxwIXIDAEL8Sm7gb/Ko6AtCIBwB9giURtx2vXv3ttbaoIUIhZbkx6QkmTRpki0EAoarLywWy30FixYErZhA3r788suaNXvChAl2jWf9dsqHU5aLleXb70WsfOuRmOqTFWJFrimSxUGSOIUXdpoPrYZgcidMfnz/zv2SD9JyLQcQPJJMYgWBlJX7fkxdq2JCEMACxdVGJC4kyaBzKwQfhfTgLuaUKcIzPIsUGivl9jMnmxh/CEloddm3hqxvCDDesSyRUgRyhVU27DRfMB6RNjglI875QlmEWBDLhesd92PaRcQq7T2Yp/5ZIFYctyU2Bs0Ji0K+XCbEsjhXDb554ma4PDdOYfKvt9561nqFS4kgTokfCNA3LGRo1S4NRhgZCi7g1By3IG6QuAUXCmOkZcuWViNPa5xI3LioPH8QIIebG/sc1iAmMEzcPZr8Dss8uQTLVTSKtZqYKmfxJy4Sq3PaRcQq7T2YYWJF9l53d5u7ciSsubgJneuFU13EXMUtWEJwQWL14Hvu7sG4v6PyykeA/naLMS5gXAlhQt/Rh/QluaRw8xK4Hre44HgOUZC2Ie6NKO76qrz6hQA5/XCDE6TOASDu5MtH/oltdSdic6+1iQu1oGJcaJ2P63vVKEfEqhoo18E30m6xwuSM+4/NkEB1YqjyTX5che56mrDkoHHA7zILUxa5slzCvDjKVhnREcAKxUk/Yu+QyZMnW5dgmAQTHXLiiTisuIXxShwVQexRr02Ku04qTwgEEWDcE2OKkJMqmIYm+Bxzi7AH0o0gjOkkbgxw14w1btzYzJw5MxMWXhGrjM65tBMrTMLOKtSvXz976i9MmPzECEB8iGVBC4tyr1uxYcD3OY6fpclfrM1p+D1Ehj7BnUD8FCdF82U2D54SjXqfWTFMZs+eXXO4AksaFlSJEPAJAdzU7sRfbsLPYD2xbHFFGDGJO++8s71mJgnrKy5JXJNJfqPa+ItYVRvxKn0v7cSKC5Vd0jlO4wWD04MQQqS46wohVxWm6ySEtA1szMQikEcriQUmiXpnvUzcehAqJN89kvwuqH1zqomknVGv3iiEaTA9B/FVLtFo1vtB7UsPAuRWc1aqQtZ3wjDcZcqlpByJggCKEXdqclI3312FUcqt63dErOq6BxL6ftqJVdC6QMAkF4CGCSdIiKnhWDBJ7pK4h41N16sw9QAAIABJREFUmTveuOtNgesJDdiIxXIFhksm2KdPHwMhDxNiN9Zcc037K4LcORSRhAwZMsSmdMCNzXUfClxPAmWVWQkCzBNSKyDMn7Akyax5kCpiBMkL556v5Lth75K8F8UI6xi5rzipmAURscpCL4a0Ie3EitQKnMJDXnjhhdAknd9++61Zf/31bZJHLBBJ5Qhi8i+55JI2g7fcO35NGDYASDX9jyZOnrFcCeZCC17JkURLnDWATYmxIstmEiirzEoQIMP64YcfbscmFt+wE9Tch8qtFsSSMrecVbiS74a9S9kuJpLDJOQIzIKIWGWhFzNIrGgSl4Ny1QHuPdx8QSGlAoGVTMzRo0ebAw88MLGexEzNnW9IliZ/YoBVuWCuLyKAnWs4uKg7uAlAqkhWyB8C1sk/lpQViW/h1uCgRaH0IFWGR58TArUQwDqEEsoVXayvXKIcFJRa4p1mzZplrfQor0kJihDJSbk2CqtyVhQREaukRkwdl5t2ixXwEYjMACU7NskcIVK4WHD5EUzOxOcuQEzVSYrT8LiIlJNlSW3MSbYh62W7RIa4+3B1sBmwcRAUy8GG3Xff3ZBINinNG3zZsLBszps3z94TiMYvEQI+IkC2dQ79EJjOFU/8e/HFF7fxoyNGjLDjmANE7o7ApNpwzDHHmGHDhlklmvkpYpUU0io3FgSyQKwAAvI0cOBA88orr1hLgMsnxe3nV1xxhU0ImbSccMIJ5pprrrEB9ATSS/xEgISfxGmQWJbAcYLTGR/EPKEVJ71oMz6J3eK7v/zyi92cJELAVwS4eJwcVVwFBtEi1IG8ViiwWFyTdssFT3STcsHdR+grXuXUSxarctBK0bNZIVYOcncLOv9ng0x6k2TS8w3+5iQg98BhHUO7k/iLAP0VvG6jmtZFZ9nkoAP3niU9Rv3tBdUsTQgE50w111Ysu1xRRqoUQjqSOlBSF30hYlUXqFfhm1kjVlWArOYTWD043UUOIohU06ZNrTbHKa9SLuOtZl31rbpDYPr06fYCcCxUuDGwjA0fPtxce+21NueZRAgIgdoIXHjhhYYrdM4880xrHSP1SaFrqNKKn4hVWnuuSL1FrKJ1LJl/ueONY8ht27a1LkDyI8kNGA3PLL/FmIBQIQT5QsQ5VMEBh7DLwrOMhdomBIohEMzx1qNHD0uoBgwYYLLmBgQHEatioyGlvxexitZxU6ZMMW3atLFuHG5+J48LmydxOwSvS4QACARzm3EilTQLEHBiVgiklwgBIVAbgdtuu81eocP9nKTQQTEhxIO8cuSiy5KIWGWpNwNtEbGK1rHz58+3SerQrrBYQajuvPNOs9tuu0UrUG9lFoFRo0bZfEDk4eEetc6dO4fm0cosAGqYECgDAe5/RfngYAfhFT/99JM9hZhU/sEyqhb7oyJWsUPqR4EiVpX1A0f0OT7P8X1dS1IZlll+m5NVpHVYZpllbKJSiRAQAvkRYE1lbcXii0LCPZ9ZFBGrLPbq/7ZJxCqjHatmCQEhIASEgNcIiFh53T3RKydiFR07vSkEhIAQEAJCICoCIlZRkfP8PRErzztI1RMCQkAICIFMIiBilclulSswo92qZgkBISAEhIDnCIhYed5BUasni1VU5PSeEBACQkAICIHoCIhYRcfO6zdFrLzuHlVOCNRrBEjAe9ddd9m7P48++uiSsOBZ7upcdNFFzaGHHlrSO9w1Onr0aNO8eXOz//77l/SOHhIClSIgYlUpgp6+Hzex2nPPPe21LhI/ECBz8QEHHOBHZapcC64WOvLII6v81fg/d9JJJ9m8PvVR9t13X3PffffZppd6B2f79u3N888/b9+BlHXt2rUgdCSf5MqU9957zz73zDPPmB133NEbuD/88EPDGJD4h8AFF1xg00FEFRGrqMh5/l7cxGrxxRcXsfKoz7lz66yzzvKoRtWrChsS12GkXbi0uVTLS9rbGqw/OYw23nhj8/bbb9sfY7EaNmxYwSbyTqtWrcyXX35pnzvnnHPM+eefX/SdJZdc0vz+++/2uauvvtocf/zx3kD5yiuvmK222sqb+qgi/4fAo48+WlFSaBGrjI6muIkVid1Y3CR+IIA7hMt/66MwDhmPaZfFFlvMLLzwwmlvRqT6P/LII/bSaq6Jwr2Hq66YcAPC6aefbjbaaCPzn//8p6TkklyKDQHDUsW/GzVqVOwzVft9VsZx1QCr4ocqnZsiVlXsrGp+Km5iVc2661tCQAhkHwGIBXdyliPVeqecOulZIZCLgIhVRseEiFVGO1bNEgJCQAgIAa8RELHyunuiV07EKjp2elMICAEhIASEQFQERKyiIuf5eyJWnneQqicEhIAQEAKZREDEKpPdqszrGe1WNUsICAEhIAQ8R0DEyvMOilq9urJYkTuGgFQXZFpucGrU9ibxHm1wJyFpR5rbkgQ+KnNBBIInZzVeNELiQoB11Una16JgW7J6KlbEKq6R71k51SZWTJb777/fDB061Lz44otm/vz5NjnfgQceaJPgkR4gLUIiVI5233DDDWbixImWXG255ZamZ8+epm/fvmlphupZRQR+++03m1uJOTB9+nSz+uqr27FyzDHHVLEW+lTWECAHF2kibrrpJpvolHV0u+22s2Nrv/32S1VzZ86caddUUmVMnTrVkBuRBLknn3yyV4lb4wBVxCoOFD0so5rE6pdffjF77LGHWWONNQwZa1dccUXz8ccfm5tvvtlcfvnlpl27duaxxx4rKe9MXUP53XffmU6dOpltttnGnH322aZJkyaGhJSXXXaZGTVqlNl9993t5kmeE4kQcAgwLtjoIN8fffSR3SzGjRtnM8TfeOONAkoIlI0ACVTJUN+rVy9zwgknWFIFuSKXF1nkS0msWvZHE3rhhRdeMIcddphtR+/eva2y+sYbb9j/v/766yZrCY9FrBIaSHVdbLWIFRNkt912M23btrUkKldGjhxps0vvuuuullz5LPPmzTObb765Ofjgg+3GGBTaedFFF1mrxOGHH241SIn/CDi3A/2H2yEJ99xLL71k9tlnH3P77bebjh07WlD+/PNPq2hw/c7DDz9sFQ+JECgVgZ9//tmuqddff73hOrGg4A044ogjzK233mouueQSS7R8ls8//9wmdX3iiSes5T8o3BnJHY4kjEVxZe3NgohYZaEXQ9pQLWL11FNP2c1k7bXXNs8++6xZaaWVFqjNBhtsYN59911T6TUBSXeVI4FMiqefftpwHUZQIF6074cffrDXcdAuiZ8IYDXCejpmzBjrloZUbb311pYUY1WKU3B/H3vssTZ7OBZPR9769etXcw8e9+FJhECpCJx55plm4MCBplu3bjYsIVchmDFjhmnZsqW1nH/11Vdm+eWXL7Xoqj+HpQoSyHVCV1111QJteeedd2zYCJ6OTz/91DRs2LDqdYz7gyJWcSPqSXnVIlZsVNx5htxzzz2hfn8m1LXXXmv22msv60bzUZzl7fHHH7fVmzBhQug9Xrh77r33XtOnTx+rTUr8QwDtlw3pxBNPNKeeeqq9xgQXClZGYjyI+yPOI67A2U8++cQcddRRdrxA5pxg3cTFIQunf2PE5xqxFq211lo2nAL58ccfzXLLLbdAlbECoeBBVnCp+ShYjJdeemlDDGKDBg3svY25JJH2opTQTkhkFi6XF7HycTTGUKdqEashQ4bYO78w8WKxWmKJJRaoPS5CNrjGjRubn376yds77vr3729jqXDbPPjgg6EbL5s1l7lyCfD777+fiGsphu6vt0V8++231nqKheiQQw6phQML+OjRo+3P6etLL700UZx22WUX8+STT2Zms0gULBVeCwFiq+677z57+IE1Nkw6d+5sXWi4Ch944AEvEWTOEWP76quv5nVb8swWW2xhXnvttcworCJWXg7HyitVLWJFTdFKnPYfTE/gWsElqOedd579L8SqadOmlTcwoRKKtQXLBKd0cBOCcVxWj4SaU++KPeOMM+wCzuW+BMUuu+yytTBw7lxiWKZNm2ZatWqVCEbOvbHxxhubSZMmpepUbCKAqNCyESi0FrHOcqIOZRbLFYHgScQPll3pPC8E73jM3SNo53rrrWemTJli43Uhiz63pRRMRKxKQSmFz1STWDFRPvvsM3P33XfbCU7gLj5zTn+suuqq9mgwLhjkyy+/NKusskotRJlYbuIFiQo/c3mxqkVg+CaWKNx9b731liVOm2yyiQ0WxVyNdvjQQw/Z+rvYnWBj8uVoCebEqlZbUjhsK6oyGLOgQWSQL774wo6/XOEEHyf2iGPhQELcQroO4u++//57q6kTxC4RAuUiwHgmJAGigSsblxqeAVzLSy21lA1uh4wwvkhfkLuuuHU199BGvp+XW79ynmetfO6552wAO+trs2bNrCWLg03EiXH6mj1r++23N88///wCRfvUllLaLWJVCkopfKZaxIpTT5ygg1TtvffeNlVBixYtbPD3HXfcYRcGCBYnpxAsBc6KwMLBSRBOtRAQzmDEv84xYhaSHj162L85qYe7MWnf+wcffGDjcnDfcMSZfDFMeIgUP5s8ebKNo+GUC3E7v/76a81ixsQn5grL3OzZs22gNLE8LIJsrrSF93gfvHRKLJlJhdsZFx+xTcTBhQmLOQcVtt12W8Mx8Li141NOOcVuhhzWaN26dTINVamZRoB1k9hUFFXWJJQ7CAiHMbC0Mm5R9CAsuRYr4pmw2hLWwDs77LCDXT933nlnG+PKvOAZ1jdiAjfddNNEseQ0OLkMUb5Z+1A6sBzfdttttv4Etq+22mq2Drmnx2fNmmXX1GHDhlli2b59extPxtzlPcplH+HngwYNsmEAPoiIlQ+9kEAdqkGsIApMWiwDuPsI1g0KiwAxLePHj7fayDLLLGOJFRoURIQ4AixYBLZDnlgMmERsfGxMWLmYhJAQAjk5cZXU6ReCQJmcTGS+S/6hoFxxxRXWtURwJbLOOusYiBibMgGZLAi0iY2dRZDNlXZRDosZ77EQEhdBkCZ/snD6JYGhW3GRhdwO/I7j3VgksZwyhuO0IGIFI1aEgxyMd8YGwe24OiRCoBQEWPtQUgn2ZpwSqxcUFE9yB6K4Iqwpzor+zTff2GSbkC3WY6xZpALBQsvJVcrmWZ7j52uuuaZ58803Y1cuXH0hP5wKZN0m7QiEwwnrJYeBCKsgVQlCqIXzbrDm77TTTlZZh0BxChJyyPxCYSURNW2BfB500EGWKKIAx60oldJnuc+IWEVBLQXvJE2s0HjQdEieiQbByZRcYeJgsmZzQdAyIFnIueeeayc5/3dpDZjgkBLEBRe7AGB+xoRKQrvCZcNCRMZstDxIUa6QNTh4MgfrmSNZBJiCA4sX2YQRLHYsAgiE8bTTTqvlpuJYMdm5JfEjwLiDBLPoQpg5ULHZZptZyynWUsYhFlT6k77PJVZYGCFgjLVgIlj6GMWAn7t+DtZ+8ODB1s3BKdlFFlnE/orNhDiYsPkRf8tVYtoRIC0NSibhFByg6dKlywJNYnwGCYpzaTPuibviRKEjJ7zM2IOYIFhRISu44rCso9zNmTMnVuXCVRiXHiQPooMFLlhn9wxKJwTPCVZ/LGq403memCusz07OOussc/HFF9v/Ojc7KXDAC6sXVjERq7TPAo/rnzSxcnFTuMo4iRVmfWFz4vQc/n+EeBYWAdx+K6+8so2FIRbLCadgsGIhmLtxo7AJMinZGF9++eVaGx0LAmZmnqU8rGe58VvFuog6EjfFBoj2xuYZZsFg0eJUI+4/BE0MdyFaVZs2bezfwXgejvYTl0VZ5JxhE3dYsLCR/ytsAaDfxo4da7U8SfkIQM4h+owVNHtIEMQdzZ/xhjuXcQVBYqxgbXX9gPUUCyNxIAhKAZrxlVdeabPwQ5AZL+TbwVrAeHOCSxtSzrMupoVnGScEsLuNrfwW6Y36gsBff/1lxyvhD4USKrPeYr1xgpJA6AGKBKQkNxeUS3fDO4xx1k0sSHyP33HKOSjkxWJ9Yp3GtQZZYy6UI1j+sdJiGcMD4VLy5JaBsgyRdAIx4kAJ8wZFBSycksIznOjFuuXcn5TPustcw9uBwu6DyGLlQy8kUIckiRUuMCYNgxkCwNU1YQIZYdAz+BGXVBNNg0XAaR7uXZfKIBiMicuM91hwgie8CCxnE8QShEWM4/VM0gEDBli3ZKnC1RAsHAim83zvEgsAeSQ2gI0TtyRaH6Zn6oKFLSgkoSRXEsGmr7zyit28sYiBHXFWxGg5wcpBrBpxE8QdsOG7d0pth54z1vqJhss4QTMPknbwQdtl03GWRq4t4h36BqLFkW/czoxpNhTi4u666y5L9tm8sLAy1iDixHuwCTAWCCDG0koW6TDhKHxu9mz1lxDIRQBrDcoAwtqRmy7EPU/yWxdLxBrEugL54H0UuK5du9YUzRqNUoq7LJhPDWWUdRn3WVCRZP3h26yjKJms0ax9I0aMKGsMuxxuVATrPcpkmBDQjlULIeyDtZT5CKni/xBMJ7QFKz/KEOl7eAZhTWWfoC2+iIiVLz0Rcz2SJFa4vggmRAptGtQBixYEC/M0E7WQmZaNDutUsTuw3AXPBClzwgthw4N8scmVmmSOiYoZ2uWAwZrBIhQm1B2LE0IsFu6dfBK01LGZB03ZYe+gaWH6hnCxsQfJWMzDIrPFQZiwDDHmIKhhiyybCePQCTEnxMG5cYB1NGhZYpPBKolgkeIwAqQXiwHjGCKFS5AxC8HOJ2RgJ75OIgTyIcAaiSLgLDTOyh32PNZ15yIsdhcl1imUAMY4B4yIL8wnKAqsQbjR3Q0akDiUaFzipBAp5TAGa9kKK6xgCJ/g26TYyXe3Ki5Ld7E91iaXliesjmBCuUghsubDKBOx8qEXEqhDUsSKBQCXGRsZmwtBlEyeMEHDJ7ASgQTlWnWC71Bf8ltBmgh6J3N2PsGChSkYqw/aGi46BDcMp05KTZjHAkCAMRsk30bryUf8uEjXnTLDFE2wZD7BmoW7CMGk7ixixbqZOAGsYpA73FY+xAoUq7MPv2fTgJTj/uMIN0QnDDv6OWgpdHf4ubv+IExcdOuERR4LJmOEscHv6FcWeO40g2xJhEAcCOCicyfjsJxOnDgx7/wnBpTDNEghZZDfE/fplE/iCbFw5RNcgngNmEsEhjtxKWZYX/l9MWH+UQZS7LYN1lHc6sxXDpKEpUdx33NXjjEPcTXmXjlWrF7V/L2IVTXRruK3kiJWEB9OqzirUaETJWhTmJDZmCBiYdcyOEjKWQAw/ZLDBWsBxMolHCWOhlMm/A7Nr5gECRAmZ+oQtiGzcaMhQhSZ+MRT5dPA+CamdFyB5S4AIlbFeiz897jrXCoONgfiRsIEcuQ2FhZldzITdwRkKZjOI5iAkRNaxP8huCE45Yd1q9AYiNYSvVVfEcAlTQ4nxFlSw7BAscVyjiUpeBgoH27uNglOMRNyUOgELF4IvBEodhA2J9SH+zCxLJVy5yWKcffu3e3r3HeIWzFMWO+wjGHZCh4GytcWlyaFeDKIXymKZ/CEMOWGJbBOYsyJWCWBqgdlJkWsiDGCWDHBmTzuyG9ukzFBE1COZgG54kSWE8qApLBBYWFC3GkPXDW484ILAIHgECgCiJ0QM4B1h8BxJ+70SzEtyT1PXJMLdscF5LTA3LbwbQI/mZQEywf9/gSAcrSeoHaOCiMusJ/JhRUluADwDdoWpvmJWJU/cegTNiSnYbvg17CSgpo0BJx+yyeMURQB5hGbiXNXlF9DvSEEiiNAaIGLQ8I95taS3DdZTyAWrMG47FAineA9gNTgdkYZCM4NDtJwY0RQIFGcXHbxf6zpzCPWYGdx53nWU04olnonIRZ9Fx+W72Qj5TL/iAcjXARF2Lkf+R2B8+wtEEJOhtMWXJIo1WHXUaHI8sfFaxGrRdms3ViXWXfZa1zyYMqFSObezFC8p0p7QsSqNJxS91RSxIoB7jL+En/C6Y0wwfVH4k8mLUdqg+SCAY5ZGYEg4dZzd0XlkjWIC4GanLhiMywkxFhRXqHJHHyftrB5ErhcKAs3p8yuueYaG/uF5hZsCxgQi4NgzoeAEYeAWZvYGp53wvFmTrywoLgFIFgf2sqCCRYE+EuKIxBMg8GhBzT5fJosgbgQeITLtnPzAwW/FiRhLOYuvq54jfSEECgfgaD13J04DisFpY5Tq7luuWCQOh4CFFqIFhZalIRcskbMKDFdKLcowPkESy4uSoLjiVEMkp9877AGu7Q4+UIh8HhAPlzOt+DaTn0JN2ENdXMaS7FLT5MbKwbZZC6z/kLSEPYd1nTWWnILEjuGa5+wDKcoE/vq1oPye6zwGyJWcSPqSXlJESuahwYPaWBihrkCyV/SsWNHG2iI5hC8G5AFgEFODAE/JxUDz7icT7lmcMgZwcjEwQSP3ebC7BLRFTrZF9Y1zlJGfd0x++Bzzr24/vrrW20nmFYCDQ/Nx6V7oC2cdnRm8GAwJu3GNcpRZqxeYZu/s1ixKGGKL8XU7clwq7NqoOnSNwjxGi7RYG6FguMOxYB8QYXwdfFVjFG051KTiLK4s3BzV2GheJY6A0wf9hIBxieHI7A45bt4mcziuNVImMmp1+D4xUPgUiJgwcW9zVrormwihYtLZQNxIVUI8YgorIWEk7HUiXjEQopIsIxgzGM+V6A7ABUWfB+MN+NwEWtw8Fo0rHscIEI4tITrEgsZewWCssXpYPYYF8MVJHiQTghYscD/SgaKiFUl6Hn8bpLECm2D02to/ZwywTTL0VhIAxsbk4k8KfzebXpBqDgqy9FgTu+xYTEp0FicGZtAcczRaGWUB8kodFkuv2cxYSFxk6vUriHRKbEKaFm4K5nwmJzR6DCdc7M8FjPa4oJLg2XzDmSKujOhsWDxhxQUaF24MZnELGAQNzS0fBuuI1Yc3ec5EavivYjb2LmDsUhxCXOYuAMPYEoqC05eOsGNixYMaWZzQ9h4IPRuYQ+WyebGN4PH4ZlvuB4oi3hCyBVjGjd4Uu6G4ujoiTQhQHA5ShVpECD2xB1hsUF5xerCGgMZQjFzB3Zc+1Dy+B0EizUT8sE6i6KKtR3FEes545Q1EkIC+SoUJ8iJWRRPrD6lkipXH5RMyAVWePK/cYiJsAss8cxT2sAeAuHDSh8Ud4qcdZMDIsxNysCdyXqMm5O9gTlGID9YBIkmc5AwD9ZtPAh8N3gYAJIFHmDqQlHiHiciVnEj6kl5SRIrpykQJwQ54ltBgWwxAbgzMEwgIGggTC5OaqGJEePEcV40JDZBfPxsbkwgd8Q2rCwCkIlN4M4rFyuQG7BYrEtwBeLmQytjYXLCJkzAJHXIXcjcM5wk412O/yLEIbAAMJHJh8TGz8SmjpTjTNVhdRKxKtZTC/6ek50QVdwe+WJA0NA5pcSiTpweY8UJYwVrKfnMOGzAWGbTYezyXq7GzYKNqxcrq3MPUgYkCkulswqwEeCKgMARt6JA9/L7tj6+gbUGZQ1SDylxwkEdFFis4MGTq0GMGJMc3GDtYZ2BYOH64uAFHgYsr7jTGKucdg27PcCVh7KK4kAqGqzyUQSrMGsj9WEuOcFVyRzk/sJ8yiPuPUgPCiauSvYZyAqJRiGMzFPmobNUhXkzCNZHSYZ8BS1z1AnFHldjmLIcpa2574hYxYGih2UkTaxck9EuCBjGB87gxs1S6n1+vMvECk4uNil3cqOY+wVrE4SFzRLTL8JihJaG1atcYfJz4g+NES2KSVmqtSHstIn7GfUoxfrkiBX5mAhMLeWdctuYxedZaNE+sTZxN2VQsK6SGJE4OAg/C3RwEWYMcuUN2GNdhdRD9J3liwBXl7SRZ9G8If1YIp1AnNC+SVYbtJiRUZqNgbGYe/dkFvtBbYoPAdYx3NwofZxgZWyWkl7ArTn8HVw/3bqau96G1RhrEwoCB4ycpwCiRSgEBK0c4bvMLUiWuy8W70aulSqszHzrJ/PQramF1kiXI4t2uJQTLmm1S8JcTlvKebbOiRUNdRYGQOL/7pJeB5obJO7/Ud4pB5QsPFstYlVXWGFV4LQK2h0amBsbxHehjXAEP23iiFXubfVpa0e160vMBJYhAtchN1g9cSUTm4FmjtWQHGS4QnI1W9YWSDnuQQgQbjxOEEGcGFu4EjiIgcUJKyzBvmjgwU2On6N9o4ljOXPiDmlQDi5BiRDwHQGUZNZTFBSX3Z06M4+w4qbpdCzkEIsbCUqdguzuWSQtC3MWFycu1mAccBx9VKfECoLkTlAVawzmfk5OIHQwLqBiAttmISxm+ShWThp/n2VihRWCAE6sOliVOG2HdodbCCEGBhdOmoQNngWAcU5sFiShXJdmmtobd11ZG3DB4tJzl36jFUNSsWg6jTXsu8TTEVvnEoxCqnCZEMOBi5r4DU6PQuQZV8Eko5SHaxtCx4kt5wrk5+5gRPAqkbjbrfKEQFwIMIeI8WLekK8PtzeKhrMcESNKbFIahDqTdgI3pru2ino7JYgDR+wbhGckkei3TomVOwlBnAqCGT6o8ZHRG7cIgs+YY/sIwWuYSBEC+wDICcwUUyPC0VCX1TUNgyHOOmaZWAVzvoRhhrblgpDjxDSpspzPP6z8Ylnek6pTWsvFnYsrA1cKpJt4lFJdqvmIbJjLuhR8yDcEWcN6Gry/rZR39YwQqDYCwfv9wr5NiEQp6RaqXe+w77nrb7C00S4nKFG4VbEiE5PGoaR88bOVtKNOiRUVD/pRCVaGXTpxV3u4/wddg+5nLv+R+787apr7TiUgpfHdLBMr+sP52cP6Jo0WyuA8CLapVFKQxjGa5To78s+JU05fFUoVkmUc1Lb0IBCMb83CukrsI4YZl4bCtYnQAKxzWLMLHSaqpOfqnFi5ytOp+YhVvs2Fd/IRq/q+IWWdWFUy6PWuEEgSAVy6LKy4DzktmruwJ/ltlS0EhEDdIyBiVfd9kEgNRKwSgVWFCoGiCBAA6aCMAAAgAElEQVSHwslYktaWcvqpaIF6QAgIgVQhIGKVqu4qvbIiVqVjpSeFQFwIkEcIt5+7sokTi8RxBC94jutbKkcICAE/ERCx8rNfKq6ViFXFEKoAIVAWAoMHD7ZJB7nyyQlJZ4m3InmpRAgIgfqBgIhVRvtZxCqjHatmeYkACUrJg0X29eAhG+645Foc0jlIhIAQqB8IeE2sONpJDphCwp1sLl0DzxEAj4ZYzeD1YqcpSh1KpWTFLbUsEatSkdJzQqAyBJ588smCd6lxKpB1SSIEhED9QMBrYhWlC1y6hXKIFTlvSLnP8ctyj0WTT4urMoJ3IUWpN++Qt4tMseXWIex7IlZRe0HvCYHyECBXFckT8wl3apZ6NVJ5X9bTQkAI+IiA18SKrKlcQ1FIMLGT9MtJ+/btbfblUokV1i2sYuSb4V4vUt5DcMoRcm+5rN/lvJf7LNdk0CFxiIhVHCiqDCEgBISAEBAC5SHgNbFyCUKTymOFCw/y1qVLF5uYlEsmuTMsLnJTXlfE+7SIVbx4qjQhIASEgBAQAqUgUK+JFYGlWKq4NgTLFZfgjhw50l6DkXYRsUp7D6r+QkAICAEhkEYE6jWxOvfcc80FF1xg3nnnHXt/UJZExCpLvam2CAEhIASEQFoQqNfEqnPnzvbKiV9//bWigHHuJCIAvlJRjFWlCOp9ISAEhIAQEAJ1i0C9I1bz58+3ViqERH7Eb/Xt29f+n79XWGGFsnpk5syZpmXLluaPP/4o672wh1u0aGG+/vrrWFyRslhV3B0qQAgIASEgBIRA2QjUO2KFZWnChAmGi1JJk9C1a1fTp08fC1y7du1Mw4YNywZReazKhkwvCAEhIASEgBDIJAJ1Tqz+/vtvAzFBdtxxR3s6zwmnAidOnGj/i2Vp4YUXtv8OvkMDSJPghDxWpFvIfSe397i/q1OnTmbEiBGmd+/emetcWawy16VqkBAQAkJACKQAgTolVhCk1q1b2/u1ikmzZs3Md999Zx/DZfbjjz8We8W0atXKfPLJJzWELPjCoEGDzIABA8zkyZMNBC5rImKVtR5Ve4SAEBACQiANCNQpscJSdeCBB9a6ksZZmpwVy4HYpEkTc//999v/7r333oaM50HBopX7Dlfi3HHHHaHJQrt162bGjh1rfvvtN9OgQYM09FVZdRSxKgsuPSwEhIAQEAJCIBYE6pRYuRY4QuTIUe7fjmwFW1zoHZ7j94USi6677rqmUaNG5o033ig5S3ssiFepEBGrKgGtzwgBISAEhIAQCCDgBbGqdo+QXqFx48bmiCOOMDfccEO1P1+V74lYVQVmfUQICAEhIASEQC0E6iWx4lTgNttsY2699VbTq1evTA4JEatMdqsaJQSEgBAQAp4jUC+JFfmr+vXrZ95//33Tpk0bz7soWvVErKLhpreEgBAQAkJACFSCQL0kVuStIqh91qxZoScGKwHUl3dFrHzpCdVDCAgBISAE6hMC9YZYYZ0aN26ctVTR6LXWWsueCsyqiFhltWfVLiEgBISAEPAZgXpDrLbddlvz0ksvmXvuucdmXCcRKT/LqohYZbVn1S4hIASEgBDwGYF6Q6zIsj5t2jTToUMH07RpUzNw4ECf+6XiuolYVQyhChACQkAICAEhUDYC9YZYzZ0714wZM8ZemMzVOVkXEaus97DaJwSEgBAQAj4iUG+IlY/gJ1knEask0VXZQkAICAEhIATCERCxyujIELHKaMeqWUJACAgBIeA1AiJWXndP9MqJWEXHTm8KASEgBISAEIiKgIhVVOQ8f0/EyvMOUvWEgBAQAkIgkwiIWGWyW40Rscpox6pZQkAICAEh4DUCIlZed0/0yolYRcdObwoBISAEhIAQiIqAiFVU5Dx/T8TK8w5S9YSAEBACQiCTCIhYZbJb5QrMaLeqWUJACAgBIeA5AiJWnndQ1OrJYhUVOb0nBISAEBACQiA6AiJW0bHz+k0RK6+7R5UTAkJACAiBjCIgYpXRjhWxymjHqllCQAgIASHgNQIiVl53T/TKiVhFx05vCgEhIASEgBCIioCIVVTkPH9PxMrzDlL1hIAQEAJCIJMIiFhlslt1KjCj3apmCQEhIASEgOcIiFh53kFRqyeLVVTk9J4QEAJCQAgIgegIiFhFx87rN0WsvO4eVU4ICAEhIAQyioCIVUY7VsQqox2rZgkBISAEhIDXCIhYed090SsnYhUdO70pBISAEBACQiAqAiJWUZHz/D0RK887SNUTAkJACAiBTCIgYpXJbtWpwIx2q5olBISAEBACniMgYuV5B0WtnixWUZHTe0JACAgBISAEoiMgYhUdO6/fFLHyuntUOSEgBISAEMgoAiJWGe1YEauMdqyaJQSEgBAQAl4jIGLldfdEr5yIVXTs9KYQEAJCQAgIgagIiFhFRc7z90SsPO8gVU8ICAEhIAQyiYCIVSa7VacCM9qtapYQEAJCQAh4joCIlecdFLV6slhFRU7vCQEhIASEgBCIjoCIVXTsvH5TxMrr7lHlhIAQEAJCIKMIiFhltGNFrDLasWqWEBACQkAIeI2AiJXX3RO9ciJW0bHTm0JACAgBISAEoiIgYhUVOc/fE7HyvINUPSEgBISAEMgkAiJWmexWnQrMaLeqWUJACAgBIeA5AiJWnndQ1OrJYhUVOb0nBISAEBACQiA6AiJW0bHz+k0RK6+7R5UTAkJACAiBjCIgYpXRjhWxymjHqllCQAgIASHgNQIiVl53T/TKiVhFx05vCgEhIASEgBCIioCIVVTkPH9PxMrzDlL1hIAQEAJCIJMIiFhlslt1KjC3W//8809z+eWXm6efftpccsklhoEvEQJhCDzxxBPmuuuuM5tuuqk555xzBJIQEAIFEJg+fbq5+OKLzZdffmluuukm07x583qPl4hVRoeALFa1O3bYsGHmmGOOsT9s3bq1mTZtmllooYUy2vtqVlQEfv75Z9OsWTMzf/58W8QLL7xgtttuu6jF6T0hkHkEunfvbsaMGWPb2aNHD3Pbbbdlvs3FGihiVQyhlP5exKp2x914442mT58+9oerrrqq+fzzz0WsUjq2k6z2nDlzTNOmTc1ff/1lP/PUU0+ZDh06JPnJels2c/DXX3816623Xr3FIAsNh0yNGjXKNgWSdccdd2ShWRW1QcSqIvj8fVnEqnbfzJs3z1xxxRUGN8+ZZ55pdtppJ387TzWrUwSefPJJM3ToULPOOuuYwYMH12ldsvpxXKwXXnihWXjhhc1jjz1mOnbsmNWmZr5dM2bMMJdeeqmZMmWKGT58uFlllVUy3+ZiDRSxKoZQSn8vYhXecf/8848sVSkd09WstsZJcmiD7QYbbGDee+89+5F+/fpZIisRAllBQMQqKz2Z0w4Rq4x2rJolBDKAwEUXXWTOPvts63YdP368adu2bQZapSYIgf8iIGKV0ZEgYpXRjlWzhEBGECDGqkmTJqZx48YZaZGaIQRErDI9BkSsMt29apwQEAJCQAh4ioAsVp52TKXVErGqFEG9LwSEgBAQAkKgfARErMrHLBVviFiloptUSSEgBISAEMgYAiJWGetQ1xwRq4x2rJolBISAEBACXiMgYuV190SvnIjVgtj9/fff9ofkzpEIgUIIkHmdcaLs/P6Mk3fffdfmS1p00UVtvqTFF1/cn8rV85owX5grWlv/OxBErDI6IUSsanfsN998Yw499FB7VyDX2/Tt2zejPa9mVYrAGWecYccIdwU+/vjj2sArBTSG98l9te6665qpU6fa0q688kpz4oknxlCyiqgUAdJlcF3YF198YRMw6x5WEatKx5S374tY1e6aQYMGmQEDBtgfchfcd999J+3K29FbdxXjQtmVVlqppgIPPfSQ6dy5c91VSF+2COQmFcVy1b9/f6HjAQJdunQxDz/8sK3JnnvuaR544AEPalW3VZDFqm7xT+zrIla1oWXiswAgu+66q71GQyIEchHApcGVHBAskle+9NJL1lIiqXsEyNQOoZo7d6659dZbTaNGjeq+UqqBOe2002qufiLxK1eG1XcRscroCBCxWrBjX331VfP222+bXr16yb2T0XEfR7O4++zuu+82e+yxh1l99dXjKFJlCIHMIkDsKpZdYqywWEnkCszsGBCxymzXqmFCQAgIASHgMQKyWHncOZVUTcSqEvT0rhAQAkJACAiBaAiIWEXDzfu3RKy87yJVUAgIASEgBDKIgIhVBjuVJolYZbRj1SwhIATKQoAThcpHVhZkerhCBESsKgTQ19dFrHztGdVLCAiBaiEwdOhQw0m15s2bG/ItLbvsstX6tL5TjxEQscpo54tYZbRj1SwhIARKQgBLVYMGDWx6BmTIkCE2kaVECCSNgIhV0gjXUfkiVnUEvD4rBISAFwhArMie/+abb9r6jBs3znTq1MmLuqkS2UZAxCqj/StitWDH/vbbb2bSpElmu+22U9b1jI77OJrFhvz666+bli1bmhVXXDGOIlVGHSEwe/Zsc/vtt5ull17aHHzwwXVUi+x/loS6XBu22WabZb+xJbRQxKoEkNL4iIhV7V6bPHmy6dChgw3q7927txkxYkQau1V1ThgBMq9vv/32ZsKECfZqGxLKLr/88gl/VcULgfQiwIXYRx99tGHujBw50vTs2TO9jYmp5iJWMQHpWzEiVrV75OKLLzZnnXWW/WHjxo3NzJkzZbXybdB6UJ9vv/3WWqqcjB071uy7774e1ExVEAJ+IsANBY8++qit3G677Vbzbz9rW51aiVhVB+eqf0XEqjbk7777rtlhhx0soTrggAPMnXfeWfU+0QfTgcBOO+1knn32WbPccssZxo3cgenoN9WybhDASnXEEUeYefPmmWHDhlnrVX0XEauMjgARqwU71sVYbb311maxxRbLaM+rWZUi4GKsWrRoYS9klggBIVAYgR9++MF8/PHHpl27doLqfxEQscroMBCxymjHqllCQAgIASHgNQIiVl53T/TKiVhFx05vCgEhIASEgBCIioCIVVTkPH9PxMrzDlL1hIAQEAJCIJMIiFhlslt1V2BGu1XNEgJCQAgIAc8RELHyvIOiVk8Wq6jI6T0hIASEgBAQAtERELGKjp3Xb4pYed09qpwQEAJCQAhkFAERq4x2rIhVRjtWzRICQkAICAGvERCx8rp7oldOxCo6dnpTCAgBISAEhEBUBESsoiLn+XsiVp53kKonBISAEBACmURAxCqT3apTgRntVjVLCAgBISAEPEdAxMrzDopaPVmsoiKn94SAEBACQkAIREdAxCo6dl6/KWLldfeockJACAgBIZBRBESsMtqxIlYZ7Vg1SwgIASEgBLxGQMTK6+6JXjkRq+jY6U0hIASEgBAQAlERELGKipzn74lYed5Bqp4QEAJCQAhkEgERq0x2q04FZrRb1SwhIASEgBDwHAERK887KGr1ZLGKipzeEwJCQAgIASEQHQERq+jYef2miJXX3aPKCQEhIASEQEYRELHKaMeKWGW0Y9UsISAEhIAQ8BoBESuvuyd65USsomOnN4WAEBACQkAIREVAxCoqcp6/J2LleQepekJACAgBIZBJBESsMtmtOhWY0W5Vs4SAEBACQsBzBESsPO+gqNWTxSoqcnpPCAgBISAEhEB0BESsomPn9ZsiVl53jyonBISAEBACGUVAxCqjHStildGOVbOEgBAQAkLAawRErLzunuiVE7GKjp3eFAJCQAgIASEQFQERq6jIef6eiJXnHaTqCQEhIASEQCYRELHKZLfqVGBGu1XNEgJCQAgIAc8RELHyvIOiVk8Wq6jI6T0hIASEgBAQAtERELGKjp3Xb4pYed09qpwQEAJCQAhkFAERq4x2rIhVRjtWzRICQkAICAGvERCx8rp7oldOxCo6dnpTCAgBISAEhEBUBESsoiLn+XsiVp53kKonBISAEBACmURAxCqT3apTgRntVjVLCAgBISAEPEdAxMrzDopaPVmsoiKn94SAEBACQkAIREdAxCo6dl6/KWLldfeockJACAgBIZBRBESsMtqxIlYZ7Vg1SwgIASEgBLxGQMTK6+6JXjkRq+jY6U0hIASEgBAQAlERELGKipzn74lYed5Bqp4QEAJCQAhkEgERq0x2q04FZrRb1SwhIASEgBDwHAERK887KGr1ZLGKipzeEwJCQAgIASEQHQERq+jYef2miJXX3aPKCQEhIASEQEYRELHKaMeKWNXu2H/++cf+YKGFFspoj6tZcSHAWNE4iQtNlSME6h8CIlYZ7XMRq/927OzZs80111xjJk2aZBo0aGA22mgj07dvX9O0adOM9ryaFRWBMWPGmMcee8x8//33Zp111jHdu3c3W2yxRdTi9J4QyDQCn376qRk6dKiZMmWKad68udlmm21Mr169zGKLLZbpdpfSOBGrUlBK4TMiVsb8/PPPplOnTubCCy+0k/7xxx83hx12mMEi8cwzz5hNN900hT2rKieBwLHHHmsaNWpkBg4caD788ENz3HHHmeeee86ceeaZ5qKLLkrikypTCKQWgRdeeMGcddZZ5vbbbzdLLLGEufnmm82AAQPMeuutZyZMmGCWWWaZ1LYtjoqLWMWBoodliFgZw2b59ddfm1tuucU0adLE9tJdd91lDjjgALPGGmuYadOmedhzqlK1EXjjjTfM3nvvbUaNGmW22267Gktn69atzQ8//GDGjx9vtt1222pXS98TAl4igGK67rrrmoMPPtiSKydHHnmkGTFihOnTp4+5/vrrvax7tSolYlUtpKv8nSwTq19++cU89NBD5uOPPzYNGzY0O++8s9lss81qIczkR3v64IMPrMUBywPy119/WcvE33//bT777DPTqlWryD2Dm/H99983bdq0qfcaWmQQE3yRPn7++eetBj137lzrBt5ll13MkksuWeurgwcPNqeddppZc801zUcffVTzOzaO0aNHm3PPPdecd955kWs6b948M3XqVOsiWWuttSKXoxeFQJIIsGZ+/vnn5v777zezZs0yzZo1M126dDGrrbZarc9+++23pmXLlvZnEydONFtuuaX9Nx4BPATMI8Z7JXGK33zzjZk+fbrZYIMNzOKLL55ksxMpW8QqEVjrvtAsEitIESRpyJAhlszMnz/fvPvuu+a3334z7du3t5vgiiuuWAM+LkCsVXfccYdp166d/TmLx/LLL29mzpxZa1Eot8duvPFG069fP1sHyB2aGhuxxA8EnnjiCdO/f3/zxx9/mBYtWphPPvnEsCEst9xy1n2x66671lT0tddeM127drX9d8EFF9T8/KSTTjJXXXWVjcm77rrrIjWMDQYy98UXX9j399prLzN27FizyCKLRCpPLwmBJBDAsn/qqaca5s36669viRVKI+vbiSeeaC699NKa2CnW4X333df89NNP5uGHH7ZzCsHyS3jF0ksvbVB+oxArlBDCNbAeI6uuuqp55JFHbJ3SJCJWaeqtMuqaNWKF9YFNCUIEqYFYMXGxRBCcfs4551hSNXny5FqB6bknvNDIVl99dRsX8OOPP1rrVbny6KOPmj322MP07t3bdOjQwRx++OF2AaJuUcor9/t6vjACBKHjjrjyyittMO3CCy9sLZQvv/yy/Tkbxn333Wfdf07CTgJC1rF43XrrrbaccmXOnDmmbdu29tsPPPCAHS9vvvmmGTlypOnZs2e5xel5IZAIAjNmzLBWJ9ayQYMG1RAl1kfipoif2meffcy9995b6/u5cwblEncg5Tz11FOR6uqUGeYw8/Xaa681HTt2tNawKEQtUiVieEnEKgYQfSwia8Rq+PDh5uijjzavv/662XDDDReAHLLFptmtWzfDpMwnaGWXX3651c5wAZUrECjcOZyIIYBz//33t6fIELS8xo0bl1ukno8RAWKiiI1igaefcwXyu9JK/6+9e4H+rJz+B35iXBYhUsalkEvJrVKhUCq3opSIMiWMilJMLcKgRUgNkQi10pAoIZfQdKEJlWskd1Gi5bLcspLL+v9+r8fvmf+Zz5zP5fv9nvP5nnNm77Va1cz5nPM8+7m9997vvZ97JeubF0s2U5V873vfK7bccstkMQNigPhMRfjwmGOOKRYvXlyst956xfHHH59e4bDA/wsJDbRBAzin9lX/VJHOeXPPOeecwh5sLlcJkLXNNtukdwBBvLQzFd5dBjPj1N6a6R0yc4UcA1jNVKPxfO0a6BOwYvFvuummiVO1cOHCQvydF6IsQE0uoWCBivMPClc1SwL4Wr58+awW6sqVKxPBWSiHu5sX7eqrr06WnUyykPnVgFDx0qVLUyNYzaznQWF945HwcgI+g3LLLbcUO+64Y3H99dcnftYgx2SSHjpozEHgzYEkXCzEwUvm/wGtkNDAfGsAz3STTTZJzdh///2LM844Y40mCV0zICX84CBWARze4SVLliTqxYEHHjirbuEyCsXvsMMOyTvGgN1oo42S53mnnXaa1Tvn60fhsZovzTf83T4BKzF9NaiIGL5w3+DidpDxVNgoeAaOPPLI1TTMrY0IiUfD3T0IzCYdjuyqRozn1SC+Pdv3TfrdeG4yDbC+ZX6aH9/97nfTmA9K3sB5PoXmBucSb5c5JkHCxj4b8W0eL+JdrG8GQsyT2WgzftOUBjKtwftxEnGpBoVBmw1V60USSFmUJWFgnnrqqQmAzUbsodbLVVddVRxxxBGJ29jlos4BrGYzCzrwmz4BK+pGQOeJOuigg1IoZ1AsQoco75HCjp7PwgOBE+XPeQ0yGJqpa9k3kOCvuOKKYtGiRcnrFdIuDahBZexxRnbbbbfKxuUsQH9pbpSzjhwOvFlCHzn8N5tK7NLNha6FHGWPZsOgXdqK1qztGjD/cVTthUjqCxYsWEMlsvPynmt94JRmQYnYY4890l6YDYnZGBDWSA5D9oGDGMCqpyurb8AqD5NDLpc5kO2FiG5TsJgtfkRMGV/nn39++nPP82II38niy8KyEgqaSbaJb6iHRbcsOxZeSHs1ILEBGOfxVHcnJxZknp2Wmy+ZZ8VDxVI2d/KzLHoE9syPmrS35ppMQvOLFT5TED/pd+K50EBdGrC/yZy97rrrkodK9rR5a/5mLxWjxPohogDKK5x88smrbijwDgkbqrHPRL7+9a8X2223XfoJntZWW201k5+37tkAVq0bknoa1DdgBSBJwcVPwZXCC3BgSu3loQCqssWTs0j8hodq3XXXTenBJHsf8KxwaMZ5EnwDz8bvEKOBNAJYZXKlcFEVp6uekYy3zFQDSnAgrsvEk0wAOCkGCzSZD3vvvfeqDCcHiWxSKd1ChCqv8zJlIIQzApQPI+2W2yY07LAxV4Bu8xQ3JNdQ894oNDrT0Yznm9ZAvvaLp8geh89qvfDyn3LKKakEQ94/s0Fpnvt7vCxGSxZ7qjXDGBknjBqJIQThnfEiVO5aqew5A+i6eP1YAKtxo9/Rv+8TsJLJteuuu6YQHEBk4SIDE2ALZwrB0TNkv/32S7WKMh+qagh5urixx8mFF16YCpCOEt9ZtmzZuFfF309BA8CR+mUKGKqxw2Nks8a9Mz+AK0kGeCP+XA00gIi1rIZOlTgkEGpHCTCF5O5gGSYAnrBK8KymMBHiExNpAP8PQAKoABv8JvPTWhDKFiq0V+b6bvZePFXAgeFQJYwQBvA4kfBj7x4lvMe8Yl2TAFZdG7EJ29sXYKUWkEPP4YdUzIIaDKscfvjhyTvBhU0crK5aEO6zYVSJ1OBJwzvc24Q3Q8bZfe5znwTKZAY6UKPY44STsuHHjA/vkINA9mauDp0/6yBAss3gh2UuZOGwyAUJq5qo5tUkVrN5Yj4otpgr+rP2d9555/RaB1aEBBueBPH6iTVgT3WHKo+VEjWM1rIAV5KFZD/nArdCdqIDPFXDBA8Wn3WcWCt5b2W8IsF7r/WY10lXjZAAVuNGv6N/3xdgZaE59IRrFPesut7AwZdd1Ybr4osvTpXY6xSbgBCSb5U5XHV+I941ew3wLAoBG6dhVq5NHEByUBBFPxX/rFvOO++8BOAIYI+rEhIaaJMGbrrppkQ257nNHv6q9mWuoL+TzKGsjZB2nWJdonEwosscrjq/Me13BbCatsan9L0+AKtyGG7UfW0q9G6//fZJs+oDKdjZxOLHJVDHZbbFRac09GvdZ4QrNttsswS8ce8cFlWeoXx5LEI7kfkHLNctxx57bPKYMgZ4r7pqddetl3hfezSAA5g99ry7PFdVIgRo7yWMBRmzdQtvWNnDy0DqugSw6voIDml/14GVQxBp+LLLLks9VGgxF7Ib7LJsLim/pKkyCLwcuagjD1rcC9iehZOr7muRUG35vr9yK1nGeE7uOMPRQ8AdvJC5jl45gHithDcuuOCCOl4Z7wgN1KYB817CjXs0ARq0hmEhajQLNwWQpsogKAaaDZwbb7wx3e3ZdQlg1fUR7Cmwynf66d6woqC56w5TFbeJ9PhMYq9zaMX/c/Vf3ISZlGmosx3xrtU1AIDjMBkfoo6ZdO8qcYAoIktkd5511lm1qxN4YwCwwhWpnZTHV3tD4oWhgSEaUIsqZ7kOKwrqp9YWT5aIgPIjMmibuDEALxI/coMNNigAqz54eANY9XT5dd1jla9RMDwK18n6GyZqnqgIjLScs73qHlbZZLL/bDB0W1VIr+5vxvvGa6DMm1p//fVTGHjYxnziiSemuUTcRcYjWreUCx0Cbrk8R93fifeFBmarAdl+CtgSZUaGFdLFD8w13lwg7pLlugV423333Ve1QyZvHxI8AljVPVNa8r6uAyvpurJLyJlnnlnsu+++lZq95pprVnkoXGXiwtAmBNHZPVosuEsvvbQXi78JPU37nTKXMp/Oxa/q4VRJuWq+9G2ezSY2cIkTOQsQyM8esmnrJb4XGhimARl7+aL6coHcweeFAIUC1QFUGy7zoOrULMPIe2XqjuLR1vnNabwrgNU0tDwP3zjK2kIAACAASURBVOg6sCrH3Ud5Fw499NBU+VeM/uyzz27ksHQo84q5/81Gw/MR0g4NlD1WrtoQ5qgS9Xq23XbbFMoQyp3tHYDjep0vo5UJ6NDqQ1hjXJ/j77ulgeyxwjOUiVc1R3MFdVdE8W4dfPDBjXRSjUKeZsJbpaZWHySAVR9GsaIPXQdWQjobb7xxKlCnFlBVpojDkgdp4cKFqVhdXqB1DymSJ5KzzSbCO3Vrd+7v46WU4SehoKoeler5wn4KzALse+2119w/OuQNuTxIk16xxhofL14rNKDm35577pnoDMouVN0+kQ0EiRhKzDTh3aVsHuZcABTIcmVYHySAVR9GsaIPKtqqbEuaio83rbqctq5SNi9ReXErVGfRy9bj0XLpblNy5ZVXrno/UjLAF9IeDSifwKOoRhXyumtsstishXFZw01XyAe81QbiETvmmGPSXZQhoYG2aYAHXiKOGwWArJxRrZ3msCLMhx12WErC+OY3v7naeqq7L7moby7W2xSAq7vdo95Hv65a4w1UBmbYvYnr/O+D/2+aDYtvzV0D5RvJXQZ7yCGHzP2lU36DRX7AAQek62l4GTbffPO08HkeLrroolQBnTWlinqTgrSp6nvUJWpSy3N7t/IGeHiqrasgbYOWWQpQ8d4qwZDv7Jvbl4b/+uabb06eTdslSxznKyQ00EYNIKbvsssu6ZJyIXTefokXK1asSPf3KbCMWtF0cVvJHbixTZXJmQ/dW/8MfREVe1Hmsw22JYDVfIzOHL/pDrRco6erwIoKTFK1gNSzkvmXs64UBGVVNVGHaFD1mcelurtsxZB2asDFsWqa8RgBVbgjwDhOybASDHX2JPO4fJenrOw5q/M78a7QQB0aYAjwWPFKWTNC5ozHZzzjGakae9NS5nF1+Ywa1JMzyzVsl19+eQCrpifRtN/fF2BV1lt2nE7DXWzROyDLtVyaKpA37bnR9+9Ne57Qp7mSC5Wy9mUHhoQGuqCBckBqmnsrTzJOlb1WVqAIRB8kgFUfRnFIH/oIrKY1XNJ+hY64cV0Iyk0ug8b1JNPwkE2rn/GduWlAwkQuGit7SrFF5PlR5UHm9sX4dWiguxrgEXMbgXI1yungqrp3VUFn9bSmAeqmob0AVtPQ8jx9I4DV7BSv8i93OHE34LJly9LCjzILs9NnX39l85Qa7sJnIplCqFgW6w033FCZadVXXUS/QgOTaIDBka8Cc7mzYssnnHBCuv5JkdC+SACrvoxkRT8CWM1ucNUeUr7BbetKK/BAyArknQjOzOx02sdf2TwBbiR1hWyBLNyUPtXi6eO4RZ/mTwP2UuVIHvawh6V7BxHXt95660aulpq/Xv6XFxwcq/kcgQa/HcBq9spFpFyyZEm6pPQRj3hEyo6RDhwSGihrQDVqNbSEAVnfJ510UsqwCgkNhAbW1ABvLk/Vaaedlv6Sh9dtFn2jVwSw6vHsD2A1t8FFrHQlyRZbbBHVs+emyl7/+j//+U+qyA94u/ojJDQQGhitgWuvvTZ5ddTJ6qMEsOrjqP5fnwJY9Xhwo2uhgdBAaCA00EoNBLBq5bDU06gAVvXoMd4SGggNhAZCA6GBSTUQwGpSTXXwuQBWHRy0aHJoIDQQGggNdFoDAaw6PXyjGx/AqseDG10LDYQGQgOhgVZqIIBVK4elnkYFsKpHj/GW0EBoIDQQGggNTKqBAFaTaqqDzwWw6uCgRZNDA2uJBn7yk58Ub3vb24q///3v6XaDSVLu3Wf39re/vViwYEGq3H3b2952rLYUbj3xxBOLDTbYoHj3u98dGb5jNRYPzFUDAazmqsEW/75OYOUOJ2nlIe3SwMtf/vLi6KOPbk2jXvnKV/au2F9rlDuHhih46wLztoiDxyXqQA9ZunRpukJqlPiNmxB+/OMfp8fe+c53FkccccTI37iDDqByITZZvnx5sWjRoraoYWrtULjWRct9EMVFV6xY0equBLBq9fDMrXF1AitFMgNYzW08mvj14sWLxx4uTXx32DsdkJ/85Cen+cn41gQa2HDDDYtLLrlkgien84iDZ4cddihWrlyZPnjUUUclT9Q4YGUfuvrqq9Njxx13XLqbcZQAVve6170KtymQD37wg8WLX/zi6XSyRV/Zb7/9Uq21Pshmm21WnHvuua3uSgCrVg/P3BpXJ7CaW0vi16GB0EBoYHUN/PznPy/e8pa3FH/605+K008/faLron7wgx+k8OG//vWv9BvV7sfJt771rXQfnVDjKaecksKIIaGBJjUQwKpJ7c7zuwNYzfMAxOdDA6GB0EBoYK3TQACrHg95AKseD250LTQQGggNhAZaqYEAVq0clnoaFcCqHj3GW0IDoYHQQGggNDCpBgJYTaqpDj4XwKqDgxZNDg2EBkIDoYFOayCAVaeHb3TjA1j1eHCja6GB0EBoIDTQSg0EsGrlsNTTqPkAVor9ffvb3y7+/e9/F1tssUVx17vetZ7OzONb/vrXv6ZUZanb+rTeeuvNY2v68WmlO77//e+n+kJ3v/vdi4c//OHFOuus0+nO6ZN58pe//KW4973vXTz4wQ/ufJ86PSDR+NZr4G9/+1txzTXXFOuvv36xySab9KZ4awCr1k+92TdwmsDqt7/9bUqdPu2004qbb745NfpWt7pV8dSnPjXVjlFLpmty3XXXFW9961tTVeh//vOfqfm3vvWtiz322COlbSs8GDIzDQDc5sM73vGO4mc/+9mqH9///vdP1bF33333mb2wBU+bG+9///tTwcprr712VYsAK5W+n/KUp7SgldGE0EB7NKBcxuGHH15cdtllaU9VUV8R6o997GPFYx/72PY0dJYtCWA1S8V14WfTAlZXXXVVsfPOO6dDUfVkIMp1Feecc04CJmrNqLDsoOmKXHHFFelA3GeffVKfeFVUfD7rrLNSIcO73e1uqU/3u9/9utKleW8nUAWU/upXvyqWLVtWPOlJTyr+/Oc/F1/5yleK17zmNcWPfvSjVG9oyZIl897WSRvwj3/8I80Ta02fHve4xyUv3MUXX1y89rWvTeAR6HrJS14y6SvjudBA7zXwpje9KdUiO+aYY1Jfea+dIaID9tWtttqq0zoIYNXp4Rvd+GkAq1tuuaV46EMfWuy7776VV1K4RmGbbbYpHvSgB6WKyZPc7TXfQ3LTTTcVqvu6LqaqsvOll16aqkY/8pGPLBQfZHGFjNfA6173ugRMFXm8/e1vv9oPzKMnPOEJxZVXXllcdNFFxU477TT+hS14wpUqX/7yl4tvfOMbxW1uc5vVWiQszvrW38svvzytg5DQQJs18MMf/rAQfQAMhOYYjnWH6L37nve8Zwr/u6XhTne6U1LJ+973vuKlL31psd122xVf/epX26ymsW0LYDVWRd19YBrASujPFRG3u93t0uFisQwKEAKMnHrqqcWLXvSi1itUSMedd3e4wx2SJWWDGRRcK546rmterZDRGuDF2XjjjdOFu7xTxx577Bo/yHMJwAJW6t7Q6x4jB5CDRyhQNfBXvepVa3xCePMVr3hF8fSnP734zGc+0/o+1a2jeF83NKD6/YEHHpgMG0bwb37zm0Jl/Ec96lHFe97znuLRj350bR1huGYw9YlPfKJ41rOeld5tr3VlEaPLM102WANY1TZd2veiaQCr5z3veQlckC984QuJUzUovD7HH3988kh04cB0YennPve51A1u6cc85jFr9Onggw9OIR7hz09/+tNxYI6Z/ueff36x2267pafcW/aRj3xkjV8gsfJ+EuFCQKzNcvbZZ68C1Yccckjx3ve+d43mmj8scPL73/8+hZRDQgNt0sDvfve7FIbbe++9k4eekUxEGJ75zGcW119/fQEACePXJTiq1juDhAFLeHZdsMzzywAb9ADX9e1pvCeA1TS0PE/fmAawAip4eBwe+FRVAlTlBWvBtN0Scejzru2yyy6F8FWVvOENb0ihT9ksNiZE/ZDhGnAJLm8lLxTy+sKFC9d4mB7vcY97pD8/88wzU3i5zeLA4a3FIeRtMxcGhdX/wAc+MP3xeeed10lyfpvHINo2Nw3IdBaixos1Pwf3McYA77xMVwTzKu/93Frw/3/NUGWwLlq0qFi+fHldr52X9wSwmhe1T+ej0wBWgz2xUEl5gR599NHJMiF/+MMfKg+g6Whkdl+p6tNhhx2WXOREKKjL1tXstDK3X2WdAlo55Ie8/pCHPCS9GBFcOLZLUtUn4fFtt902deMDH/hAsXjx4i51Kdracw187WtfK7bffvvUS+F5YfpBsQ4ZzxIwgJ8mBMcSjYRxxZPVxSzysl4CWDUxS1ryzmkBK5lRvDzcxd/5zncS0JDV8a53vSu5dp///OcnDwS54YYbVls0JiDC5B//+Mdiyy23LNZdd91V2uMRkL7uz3NMflqq5VnTJ+RKdbnUKMIz0CfZjdziODNELZZyu/WJW5uVp+3Z1e3ZX/ziF4m/QD/lP59Wv+b7O9Krla/wb+OLzyFJgOfnggsuWFWaQOkOgLwseCDGQmKBjTcDMpuyA4JnSMr2NLlZxvqSSy5JFrY+GVt9chgdcMABxbnnnptCLETpBYC8LAwNXL3NN988efHKffK+wb7O9/jF9/ulgcwB1KuTTz45kccHJYe87cG4kgsWLKhdCUov8PqiDKCMdF0CWHV9BEe0fxrAymEoxIPIqzbR0572tBTOAUhYPzhVDhbERIKUeMc73jH9t0Uqtd7hw1oByvCbWPZKNbz+9a9PhxRPBoK4g2kawiWOM6N9gJSQIG6MjDbpwUoxIOT/8pe/TFmO6nZlD52Ql0MVRwuo1CfkTJae8KJSDQ94wAMS8DrooIMqSdzT6OO0v0GX+++/f/H5z38+hcOEWHmnjC33/3Oe85wEKnIWpgwhf57FnPAb2URAuLAbTtOGG25YPPvZz04g1Z+bW7h+OaTYZD+BKGELpRWELY888sg0X4VMjK1D6sYbb1yVLfvhD384GRnExquP5vhGG22U1g+wqJ/mlD7pm9/rqz71odhuk+MR7565BgD7V7/61WkPA2wGs3W9MWdB+2+GDWOxTvnoRz+aEj/sDcjrfZAAVn0YxSF9aBpY2ewdkg4Ci2LHHXdcrSW8VKwgqeYmGm8CUjIQ4qCVcbLrrrsmQOYdwoXAmJi+2D6LXe2jvfbaKwEzQOa+971voyMG0D33uc9NHiigcTAbBkBC1gcYCU8DkidQ4KDVJ4cnt7rw4NKlS9N/Z57CypUrkydLn9TFAgbUxOqzqFUFiAIcL3vZyxJALoeK6YB+AAxkb0L36lwRAMVc+PjHP548OLyY9A5MGSd8txe84AWp4KD5hvtG702KkIWaVT/96U+Lo446qjjuuONW85SZC1tvvXUCS0pykHIiBEAm5MEbgLfCa+tQAQjV9znppJMSIBd+Of3001MoRmmHkNBAUxqwR/uHlEP0n/rUp9J+RXiUGM91CeOC8aqWXTaGENuFzNvOxR2lgwBWdc2QFr6nSWCl8KFwljDYoHchq0L4jAdBqIbsueeeyZNFeLFcDcOLk8UB5DAiAIzF9eQnP7m48MIL0585iDIHpwl1A2+AFOut7F0of8vflUN4wj0f+tCH0iM8Ww5HQDELAPbEJz4x/S+gKYtSlqG0ZvLrX/86XX/SV7HByAYEwtV0ApCqiP7GujwXhP3MD+FWwApXibcqC28gr5+kCe8UigOuCAt8WCJFHXo2r9XZYskDf1/60pcqw4+8WLycBMgGMM0dIeY3vvGNaQ5kUE1Pqs8zPBQcpS8gMYcOh/Ff6uhPvGPt1oD5zMPOc8Qbz6i1zwL/wvQMoQzqJSsNZgeKODCanAfKimRAZH4zuBlNDPBBoMSI5YVesWLFqgxgRgWjSYHpaYb0654BAazq1miL3tcUsDJpxMEdaA4/4YqcolvuvufwkfLVJbkCNYDEs8MDVQ7Z8AQBHhagkJoQSD6cAC6Ha1Oirb7B1c1zwitSZTHl4nbaRxycPFw2JIcsDlmZD5ZrM/HI8dI5WG0yNjLP88xUCZAJaACtXRZ9yIRtG3C2fAf7JMQKbJDHP/7xyYIlQKjyDDb4LDZfgERYGUeEp+qzn/3sqnfTXZMhBcR6YT8CVAH/VeIZzxJlSFj7BCj0d+oGZQHYed8Q4M2ZF77whclDZz0Iz+BhCTNmATx5sfTVfHN4AaB3vvOduzxdou1T1gCvOQ+7Oy7dFMDgBfCBIp5g3imZreYkwSfMkQlzUMiagWG92fsYiQxIxjBKBENVmBuVwm9zqBFFAmne3lC+e5Un2JzOhueU1VHb5wJY1abK9r2oKWDlEMt3uuHBDDv8HRJAirAIL4WFh6DLGlFZt3yw0B5eEzewwxQZmcVigvLqeE+TAiDl9H6HnhIRVaJPd7nLXdKhDizZCPy/cKDDDwgoi/9nCZY9G95BF4N9Ehaywdmo6IcFqHJ9Vy03SQ34ZMbf5gmMDqu8j2OBf0b8W3iNCLGZY3SchW6E4YgQmvAgcbejcHOTpS94aBUFBZLNZeM47HuATl4b5jXelfnsOg9csjKfBUDLNeDKCR6MD/W8yt+wHnARFR7Fu3KI4ZvRMd106eqoJtd0vHu0BoAqIMk1Mgy8nB2Yf5XpGtasPZtYyzzH9jC1rxifPLDWQi4twgAwR3mrUDc8Zx7b3wAxhpFneGerBNATMeiyBLDq8uiNaXsTwMqEYdXkkF7ZghlsDu6Mi4r9RjgMyXeYeEZxSAcl97DDZ1ri2ywzhxsBZnjUqsThnXleXOJc46P6xIJjsZXBwrDneXR4H4AGIdSuAythvBw2AKJlA1YJ/StEmLMsx3HpZAyyro0Dz+I0gSdrPBPQedHwQ4b1SbhQKNjh40BCRh8m+qNfkjgA9FF9YgDgHjqosuBkaQ+jJPPUprV+4jvd04CzQRkQ4XR7bVW9PuuyTMVgtNj/zE1zFfeKEaiOGwG2hLz9O6/3snFxxhlnpAQW32YwDRNgL9MnuqfZ/7Y4gFVXR26CdjcFrBwQsklY3KydYTWcWDLi9CSHzIY1W+p9rrTNAmflTEtsBPrCkgIEhTaHeSF4HnjWiHBeriZe1dZyJXEE/kmvhXBo0qnwjtDkNIFDnTqX8Zn5ZqMKfvJsCe0Jh0lmoNdhfbZh8f65T9AmbbOepiCTK3BKAEGeoyqxLoSyjaWMR2G9YaJP+GfCycj9uT5a1fOe5R3gKfVO7ybmbOagDZb/mKZ+4lvd0EBem0on2HurCvbqSblUjrCdrFWcWQajPT0nmHgWz8r9qSQnn+TrwYA4IKyKMtINjc2slQGsZqavTj3dBLBCdHToZ57VsCtq/L1Dhzt40003TVl9o4poCpcJm1nosubG1XjSN2CFVyfH6B0uNgkclmxFTTJgDsEcauJhYYlVHezZ84b/g4/lIBwVdsqXiuLOcKtPWkS0L8AKsT9XUBYmGFa1uXw1DN7eYEiiPIZqpBkrYKzq7kljNDh2OBvmU0588FuWOgt8pmUZJGBkL+WoK2oyt878wA00T4eJsLI5bG2VwVJ+frBPvAi8v/7JNX/8NtcXGqXrSdZDPNNvDfA6CRcDSObSF7/4xaH7XdmTnw1J60fIedD4lWxx6KGHprVmv8sgiuHaZHi+jaMVwKqNo1JTm5oAVg59YSoH3CiPAYDjILXh40uV79vjmVC/R9xeUVGAI/OrWDYAU/lwRGrGO8meAhsCEjQPk7ARIMS17JssJvF5WWG8C5OIYqC5wOeo8E6uDK69DuvyhdO8BLLRhD+BRBtJtvZkC7Lgyn1C7PT/mdxcbmdfgJX6ZsJ/QmE242GFBWXB0Y9NWUirLICGcUduB7jMDd4dMpglqviqMUGqzVwuoTqWssMD0NUWc0X5B14vXlLgf9LUbhwRcxZJ3HeqDgybqrYKyVVlKPKymaPCwwBXuTCqOQzwZUHyNX94iMvzZxBsCaHLpgIUM6dxkrkfz6x9GlDWJhffHVXGAyDimWKw4vKZV1V1rrIGRSdEKXAFZbWuzRLAqsej3wSwMmFwgIAl1bIz2BlUo9R3BwhQJLukLFJ3MzcFn8nhghDMkhp8JxDGugKecikGRF0Hp0MUYLPoeRGy9c6SckAhZ04SRrOBCLvxqgE8VWBH+7O3QngLcbgsGUT4M98FKrnXAS3PlkswAGFI3TxfVeUjsvdBIT6hwK5KDpsaK3OxCrwAN4ADPZgLZU9lufyGsgPSvnFBlB7gkQSIy+Mr6QDgz4VkkeWBf9w57zcngF0Ay+9403jV1BbLZPhxugaGEO1lOXl/FbAyF80Vd7DxwJUJ+76V56nDDVdFVqM2e6cQX7lPwi/C054bJfmKJYem9oWEBqo0YP8WbmdokFEFP8tXTA3uYYPvLoOwqlsT1rbRCGDV4xFvAlhRV85gcvA7/AYt6VzoE8DxbPlANeF4pRyi+eBh3SAvk7LXgkdKKQMHTvmOKoeg1HXlGWRalcnu3g9sIYzLOpkEWPkuLwRvRE71H+yTwqX6JbypMnv5720qiPc2IoemEA3+QeaX+S0wQHhueNtkspXBVnkaZo8V7xuPxaR9aNtUBooBGuOAkD1YAkHfeKsAJOEyHpeyABtABxCFd+f3ngGQeIzUhcq6URMHb8S8yiTxDKCMg/Ah8C4EmEMUOXShjg5wN4kIGwtts+KrQm7Cwyx2c0L/BsOf5oH5ykPKk8ZjRkfCimVysLaoj6bYqfeUsyIH2wm8Ceng8AGqa1vYZZJxi2f+q4FyWRneJ0beME9yLoEiQsEjOiozmzGZs3OFCdWXK8tgONDe7jm8QOuJWFv2UIZ0uQRDF8cugFUXR23CNjcFrHw+ZzGps6Pmjs1cKAZJGe/KgYk7U1VXRxiQ5c8NbQJawP77zW9+cwqvIO/iWfFMyZIDosqcKZ4tB5JvA1fl9HSHuUPI95WFmIkAdQ5bGS0588uGwbMhBAX86V8V/4sXjvdOKAtnRp+AQaGgXEmbh8Pfy2bjgRu2oWVgBUgov9BVYEX3gLcMHyEqoAJItpkD3HhIxoouqnhVNlleSYAXSZvueAF5+2Qy8YTK3kQiB3b9k8OEvg2ACWUIteGKDBbZzKHaUVypqvnD0wg8AU3a4RDQJ/NU6JOHydyryizNXjgeznzrAFAO7OmfdSEVXV94FYQpR/GzGBD0qy3CptO+U3Mm6yuenX8N2G8ZEYy/UfuLPcjdm4wi89LemMUeqxwN7ysyu7pX5r05zTtr7y6HDN0coN5c3sty1IMBxLtrT3V2mPOMZkYuruuoJI751+ToFgSwavsIzaF9TQIrzbIgbOa8EcAOcMWjgC/ln2GAgPXCm+Dg4MHhOua9cjix5r3Pgcj7IxQyjMfCA+FAKof8co2tYReKjlOn8BWSpjaoxQL8OPh4TgbrbpXfBTwBgrwfQnm8WzxOvCpCPkACj4QUfGHSUWCpT8CKjvTdxsqbRK/6x1IFLIz9qDIEQs5I6rxDqjrn+lY8VMYYyHVAALbDMptcbwO0l0N+5qAQMm8RLtRMwatDQjhbf4SQ9cn4qu/mW6Pu9VOiRJgcP9C1Nbm6usPJnwNH5o6wtMzCYWK9mE/WiYPOOqki74+b8/H3a5cGeEEZJTxFPFFVcx+oMS9lPdtTy8+ccMIJq9Zh3md54RlIg5nM1pm5rBadjFfC0AGeGJ7mrDXMoMh/b7+0f/IKzzS5pC0jGcCqLSPRQDuaBlaabAJZPHnhle+YGtelYYfAJIdDTi/PKcD5W7luClAEdPEeAWAzkcE+zSS0Mpc+5TZmYDVJTaOZ9Gs+n6WX/E+eIzMFM4Pt9z4y7j28S0AVkJszM4XshIwlOfAqCkUC9zOR3J/8m7rm/iR9AuSBOGAzH0h+x3vF2BkFVmfSx3i2fxrA47MnmkMMg8EQPGoGoITqwbM86AXNnEChQWFoSUi57IJwdDZUrA8giXdM2C+vPd6vffbZJ0UzADERj1zZnbYzX1BmYVcvHg9g1b91s6pH0wBW86W+TDz278xlMpl5DVhiFjNuE3AiZNglycBK2Qi1YcYBhy71bdptdXgINwoR4h9lAaZkBwp1yDK12ecCsdNu42y+Jzwq3I18r+o/0MjA8ecSJmLOzEara89vFCMWXgduZEJLDLIOhOZy6RthvqqyNcAULir+K+NEghLvKi4gr5UEJEDLe8xNXnzhwkHBMcWLRB2RpUvs4Txc9kB8yK7O4wBWPV5LfQZW4vli9zxX2TrHlfHf3Mo2Dd4svJdhXKa2Db3FCAgIFfGy6AsSPM5N01f6tE0XdbUnZ+EJleX7/bwb5woHSxgP8PZ3Oeu0rm839Z58IFW9n/fBgRQSGhinAckTwnHAD68TygNDFGAC2kcJXqO9SQkGHlP7rf1LwolbOYSwcQNlEyK/VwmPK9CFk5UzZ/O1OACXkGNXJYBVV0dugnb3GVhl17OFWRbXfSCaW8yIv7ma+wTqmvdHkERxD0i21HK4S7LAsMt+573hLW4AHiAQruZVOUMPj85cweVzb98o/lzbuof3IpOySvCtcGhCQgOTaKAczi7TOSb57Vye4ZGSyAJ8la86YwBZj7iV/g5I61rEgV4CWM1ldrT8t2VghYshnj1MbMZddbsO9mkSjlbLhy41ry/9mG9dj+K9lUHsfLdz0u9nsF31fF/W8KS6iOe6qQE8LCUZZIjLoM4iO5gXTJYg0jxvGkpHG0WG76i7YpVLwfXlAeTdq1yv/7uY/8sUDemMBsrAalyjWRCTVp8e9674+9BAaCA0EBoIDQzTQC60yzNVLpGiFA2vq+xsBHrgJN+B2TZtKq8zye0eiPrKAgWwatsIzrI9MwFWSgTMJPttlk2Kn4UGQgOhgdDAWq4BJVR4q5TpKXNglWVRb04tOKUcZLm2VfQBj3ecBLAap6EO/r1MoUkkQNUkWopnQgOhgdBAaKBJDXSFAjFYbmWYTkaVYVknQoFNTqV4d2ggNBAaCA2EBkIDa5MGAlitTaMdcT1tlwAAACpJREFUfQ0NhAZCA6GB0EBooFENBLBqVL3x8tBAaCA0EBoIDYQG1iYN/A/6Pt7WWyaQDgAAAABJRU5ErkJggg=="
    }
   },
   "cell_type": "markdown",
   "id": "001cba5d-3942-4cee-af5d-582151ffd267",
   "metadata": {},
   "source": [
    "![图片.png](attachment:3d1dc0ab-3343-43db-b3d4-6a7ef1e1b6f9.png)"
   ]
  },
  {
   "attachments": {
    "d2c25cc9-e802-41a7-986b-d63b679af33b.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "d2ff3aff-d54a-4510-80dd-f3c535c6ccaf",
   "metadata": {},
   "source": [
    "![图片.png](attachment:d2c25cc9-e802-41a7-986b-d63b679af33b.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c747e008-cbd5-4f21-9b1b-35c093fd6d67",
   "metadata": {},
   "source": [
    "H 用于估计二阶近似，J用于诱导两个空间度量"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b83a529-c12b-4b6e-b434-36c33c66ae9e",
   "metadata": {},
   "source": [
    "困难在量大，无论正向反向，都需要算多次。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a278c84-d683-4831-9534-e93aeaae3161",
   "metadata": {},
   "source": [
    "但是实际场景下，大多数是J、 H作用在某个向量v上"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f9d617b-d35a-4509-b92a-71defa8f66bb",
   "metadata": {},
   "source": [
    "### vJ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31381a05-92e7-4c61-97b6-ac635ccaab07",
   "metadata": {},
   "source": [
    "对于 vJ，构造辅助量进行反向梯度计算"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5fdae78-9ec6-4b58-91ee-9a0fe413935d",
   "metadata": {},
   "source": [
    "$(vJ)_i = \\sum_j v_j J_{ji}\n",
    "        = \\sum_j v_j \\frac{\\partial f_j}{\\partial x_i}\n",
    "        = \\sum_j \\frac{\\partial v_j f_j}{\\partial x_i}\n",
    "        = \\frac{\\partial \\sum_j v_j f_j}{\\partial x_i}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60891391-23b1-48ce-bb42-6430f03f0b73",
   "metadata": {},
   "source": [
    "### Jv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c7c30ee-8a5f-4630-a1be-789f6de514a1",
   "metadata": {},
   "source": [
    "对于Jv，构造辅助量进行正向梯度计算"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "828f8f7c-452e-4c12-90b6-774bceb8f0d9",
   "metadata": {},
   "source": [
    "let $x_j = v_j a + x_j^0$, where $a = 0$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aecd4e0-6015-48fc-bb96-bc9be8b44bae",
   "metadata": {},
   "source": [
    "$(J v)_{i} = \\sum_{j} J_{ij} v_j\n",
    "           = \\sum_{j} \\frac{\\partial f_i}{\\partial x_j} v_j\n",
    "           = \\sum_{j} \\frac{\\partial f_i}{\\partial x_j} \\frac{\\partial x_j}{\\partial a}\n",
    "           = \\frac{\\partial f_i}{\\partial a}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5969d552-9c12-4d8d-be1f-3f27c7151079",
   "metadata": {},
   "source": [
    "### vH"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e285511-5ee3-4850-8cce-0a4e2bc440bb",
   "metadata": {},
   "source": [
    "let $x_j = v_j a + x_j^0$ where a = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c48b4347-fa46-401e-a5a5-ab42c4c43988",
   "metadata": {},
   "source": [
    "$(vH)_i = \\sum_j v_j H_{ji}\n",
    "        = \\sum_j v_j \\frac{\\partial^2 f}{\\partial x_j \\partial x_i}\n",
    "        = \\frac{\\partial^2 f}{\\partial a \\partial x_i}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efd00918-5445-471f-96bb-dc9d75e10e0f",
   "metadata": {},
   "source": [
    "然后使用反向梯度计算两次即可"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62da7e02-7e57-4b99-8f87-a35bc3216e00",
   "metadata": {},
   "source": [
    "## 总结"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1abd11ea-61be-4f29-9bad-d55d04f06de7",
   "metadata": {},
   "source": [
    "- 计算图\n",
    "- 链式法则\n",
    "- 正向反向，计算复杂度不变\n",
    "- 利用矩阵apply省掉计算"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ef6b78c-d978-4d5e-8878-f1a713c097c9",
   "metadata": {},
   "source": [
    "### 结束后的兴趣话题"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f62c1105-693d-44fa-9370-9b9d7ee2b8ab",
   "metadata": {},
   "source": [
    "Wirtinger derivatives for complex\n",
    "\n",
    "See: https://docs.pytorch.org/docs/stable/notes/autograd.html#autograd-for-complex-numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72226ab1-79aa-4d9c-943f-9567d9220e10",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}