From b13e34cc51af34a799445ede43c79f184d0c409f Mon Sep 17 00:00:00 2001 From: Hongru Date: Sat, 28 Feb 2026 15:27:59 +0800 Subject: [PATCH] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Notebooks/C5.ipynb | 13 +- Notebooks/C6.ipynb | 11 ++ Notebooks/C7.ipynb | 54 ++++-- Notebooks/C8.ipynb | 417 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 482 insertions(+), 13 deletions(-) create mode 100644 Notebooks/C8.ipynb diff --git a/Notebooks/C5.ipynb b/Notebooks/C5.ipynb index 33954d5..c73cd4d 100644 --- a/Notebooks/C5.ipynb +++ b/Notebooks/C5.ipynb @@ -157,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "142b7542", "metadata": {}, "outputs": [ @@ -170,6 +170,17 @@ }, "metadata": {}, "output_type": "display_data" + }, + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m在当前单元格或上一个单元格中执行代码时 Kernel 崩溃。\n", + "\u001b[1;31m请查看单元格中的代码，以确定故障的可能原因。\n", + "\u001b[1;31m单击此处了解详细信息。\n", + "\u001b[1;31m有关更多详细信息，请查看 Jupyter log。" + ] } ], "source": [ diff --git a/Notebooks/C6.ipynb b/Notebooks/C6.ipynb index c4406c2..37da968 100644 --- a/Notebooks/C6.ipynb +++ b/Notebooks/C6.ipynb @@ -174,6 +174,17 @@ "text": [ "结论：离真值越远，SGD下降得越快；靠近真值时，SGD 会有一定的波动，而 MBGD (使用更多样本) 波动更小 [cite: 7129-7134]。\n" ] + }, + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m在当前单元格或上一个单元格中执行代码时 Kernel 崩溃。\n", + "\u001b[1;31m请查看单元格中的代码，以确定故障的可能原因。\n", + "\u001b[1;31m单击此处了解详细信息。\n", + "\u001b[1;31m有关更多详细信息，请查看 Jupyter log。" + ] } ], "source": [ diff --git a/Notebooks/C7.ipynb b/Notebooks/C7.ipynb index c3d6b72..1929ad9 100644 --- a/Notebooks/C7.ipynb +++ b/Notebooks/C7.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "id": "e46747a5", "metadata": {}, "outputs": [ @@ -40,19 +40,49 @@ " -> 所以我的 TD 目标是 0.0 + 1.0 * 0.000 = 0.000。\n", " -> 我把状态 3 的价值从 0.000 更新为了 0.000。\n", "\n", - "[第 2 步] 在状态 4 决定 向右，进入了状态 5。拿到真实奖励 0.0。\n", - " -> 我猜状态 5 的价值是 0.000。\n", + "[第 2 步] 在状态 4 决定 向左，进入了状态 3。拿到真实奖励 0.0。\n", + " -> 我猜状态 3 的价值是 0.000。\n", " -> 所以我的 TD 目标是 0.0 + 1.0 * 0.000 = 0.000。\n", " -> 我把状态 4 的价值从 0.000 更新为了 0.000。\n", "\n", - "[第 3 步] 在状态 5 决定 向右，进入了状态 6。拿到真实奖励 1.0。\n", - " -> 我猜状态 6 的价值是 0.000。\n", - " -> 所以我的 TD 目标是 1.0 + 1.0 * 0.000 = 1.000。\n", - " -> 我把状态 5 的价值从 0.000 更新为了 0.100。\n", + "[第 3 步] 在状态 3 决定 向左，进入了状态 2。拿到真实奖励 0.0。\n", + " -> 我猜状态 2 的价值是 0.000。\n", + " -> 所以我的 TD 目标是 0.0 + 1.0 * 0.000 = 0.000。\n", + " -> 我把状态 3 的价值从 0.000 更新为了 0.000。\n", "\n", - "游戏结束！最终到达终点 6。\n", + "[第 4 步] 在状态 2 决定 向右，进入了状态 3。拿到真实奖励 0.0。\n", + " -> 我猜状态 3 的价值是 0.000。\n", + " -> 所以我的 TD 目标是 0.0 + 1.0 * 0.000 = 0.000。\n", + " -> 我把状态 2 的价值从 0.000 更新为了 0.000。\n", "\n", - "跑完这 1 局后的最新状态 V 表 (状态1到5): [0. 0. 0. 0. 0.1]\n", + "[第 5 步] 在状态 3 决定 向右，进入了状态 4。拿到真实奖励 0.0。\n", + " -> 我猜状态 4 的价值是 0.000。\n", + " -> 所以我的 TD 目标是 0.0 + 1.0 * 0.000 = 0.000。\n", + " -> 我把状态 3 的价值从 0.000 更新为了 0.000。\n", + "\n", + "[第 6 步] 在状态 4 决定 向左，进入了状态 3。拿到真实奖励 0.0。\n", + " -> 我猜状态 3 的价值是 0.000。\n", + " -> 所以我的 TD 目标是 0.0 + 1.0 * 0.000 = 0.000。\n", + " -> 我把状态 4 的价值从 0.000 更新为了 0.000。\n", + "\n", + "[第 7 步] 在状态 3 决定 向左，进入了状态 2。拿到真实奖励 0.0。\n", + " -> 我猜状态 2 的价值是 0.000。\n", + " -> 所以我的 TD 目标是 0.0 + 1.0 * 0.000 = 0.000。\n", + " -> 我把状态 3 的价值从 0.000 更新为了 0.000。\n", + "\n", + "[第 8 步] 在状态 2 决定 向左，进入了状态 1。拿到真实奖励 0.0。\n", + " -> 我猜状态 1 的价值是 0.000。\n", + " -> 所以我的 TD 目标是 0.0 + 1.0 * 0.000 = 0.000。\n", + " -> 我把状态 2 的价值从 0.000 更新为了 0.000。\n", + "\n", + "[第 9 步] 在状态 1 决定 向左，进入了状态 0。拿到真实奖励 0.0。\n", + " -> 我猜状态 0 的价值是 0.000。\n", + " -> 所以我的 TD 目标是 0.0 + 1.0 * 0.000 = 0.000。\n", + " -> 我把状态 1 的价值从 0.000 更新为了 0.000。\n", + "\n", + "游戏结束！最终到达终点 0。\n", + "\n", + "跑完这 1 局后的最新状态 V 表 (状态1到5): [0. 0. 0. 0. 0.]\n", "仔细看：相比于 MC 要等游戏结束，TD 在游戏过程中就已经把前面的状态价值更新了！\n" ] } @@ -121,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "6057ac63", "metadata": {}, "outputs": [ @@ -130,7 +160,7 @@ "output_type": "stream", "text": [ "=== TD(0) 经过 500 局学习后的最终估值 ===\n", - "状态 1-5 学习到的 V 值: [0.123 0.311 0.416 0.688 0.864]\n", + "状态 1-5 学习到的 V 值: [0.153 0.291 0.513 0.666 0.919]\n", "真实的理论 V 值 : [0.167, 0.333, 0.5 , 0.667, 0.833]\n", "结论：TD(0) 完美地学会了评估这个策略的真实价值！\n" ] @@ -195,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "c632f093", "metadata": {}, "outputs": [ diff --git a/Notebooks/C8.ipynb b/Notebooks/C8.ipynb new file mode 100644 index 0000000..14a5049 --- /dev/null +++ b/Notebooks/C8.ipynb @@ -0,0 +1,417 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "255e09c4", + "metadata": {}, + "source": [ + "# 第 8 章：价值函数近似 (Value Function Methods)\n", + "\n", + "## 1. 为什么抛弃表格，拥抱函数？\n", + "* **存储高效**：不需要存成千上万个状态的值，只需要存函数的几个参数 $w$。\n", + "* **泛化能力 (Generalization)**：在表格法中，没见过的状态价值永远是初始值；而在函数法中，更新一个状态的参数 $w$，也会同时改善对周围相似状态的预测。\n", + "\n", + "## 2. 线性函数近似 (Linear Function Approximation)\n", + "最简单的函数就是线性函数： $\\hat{v}(s, w) = \\phi^T(s) w$。\n", + "* **$\\phi(s)$**：状态的**特征向量 (Feature Vector)**。比如在网格中，如果状态坐标是 $(x, y)$，特征向量可以是简单的 $[1, x, y]^T$（代表一个平面），也可以是多项式如 $[1, x, y, x^2, y^2, xy]^T$（代表一个曲面）。\n", + "* **TD-Linear 算法**：我们不再直接更新 $V(s)$，而是通过梯度下降更新参数 $w$：\n", + " $$w_{t+1} = w_t + \\alpha [r_{t+1} + \\gamma \\phi^T(s_{t+1})w_t - \\phi^T(s_t)w_t] \\phi(s_t)$$" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a3119ab2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 体验 TD-Linear 的一次更新过程 ---\n", + "提取的当前特征 phi_t: [ 1. -0.5 -0.5]\n", + "TD 误差: -1.0\n", + "更新后的权重 w: [-0.01 0.005 0.005]\n", + "结论：我们没有单独记录状态 (1,1) 的价值，而是更新了统管全局的参数 w！这就是函数近似的精髓。\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# --- 1. 定义特征提取器 (Feature Extractor) ---\n", + "def get_features(state_x, state_y):\n", + " # 按照书中 8.2.4 的建议，将 x 和 y 归一化到 [-1, 1] 区间\n", + " # 假设网格是 5x5 (x, y 在 0 到 4 之间)\n", + " norm_x = (state_x - 2.0) / 2.0\n", + " norm_y = (state_y - 2.0) / 2.0\n", + " \n", + " # 提取简单的 3D 特征向量: [1, x, y]^T\n", + " return np.array([1.0, norm_x, norm_y])\n", + "\n", + "# --- 2. TD-Linear 参数初始化 ---\n", + "# 权重向量 w 初始设为 0 (对应特征维度 3)\n", + "w = np.zeros(3)\n", + "alpha = 0.01\n", + "gamma = 0.9\n", + "\n", + "print(\"--- 体验 TD-Linear 的一次更新过程 ---\")\n", + "# 假设智能体走了一步：从 (1, 1) 走到 (2, 1)，获得奖励 -1\n", + "s_t_x, s_t_y = 1, 1\n", + "s_next_x, s_next_y = 2, 1\n", + "reward = -1.0\n", + "\n", + "# 1. 计算当前状态和下一个状态的特征\n", + "phi_t = get_features(s_t_x, s_t_y)\n", + "phi_next = get_features(s_next_x, s_next_y)\n", + "\n", + "# 2. 用当前权重 w 计算预测价值 v = w^T * phi\n", + "v_t = np.dot(w, phi_t)\n", + "v_next = np.dot(w, phi_next)\n", + "\n", + "# 3. 计算 TD 误差 (TD Error)\n", + "td_target = reward + gamma * v_next\n", + "td_error = td_target - v_t\n", + "\n", + "# 4. 更新权重 w\n", + "w = w + alpha * td_error * phi_t\n", + "\n", + "print(f\"提取的当前特征 phi_t: {phi_t}\")\n", + "print(f\"TD 误差: {td_error}\")\n", + "print(f\"更新后的权重 w: {w}\")\n", + "print(\"结论：我们没有单独记录状态 (1,1) 的价值，而是更新了统管全局的参数 w！这就是函数近似的精髓。\")" + ] + }, + { + "cell_type": "markdown", + "id": "5bf7d1dd", + "metadata": {}, + "source": [ + "## 3. 深度 Q 网络 (Deep Q-Learning, DQN)\n", + "当特征极度复杂（比如游戏画面的像素）时，人工设计 $\\phi(s)$ 根本行不通。于是我们让**神经网络**来代替线性特征，直接输入状态，输出 Q 值。\n", + "\n", + "但把神经网络和 TD 算法结合极容易崩溃。DQN 提出了两个伟大的技巧来稳定训练：\n", + "\n", + "1. **经验回放 (Experience Replay)** ：\n", + " * 智能体边走边把经历 $(s, a, r, s')$ 存入一个“回放缓冲区 (Replay Buffer)”。\n", + " * 每次训练时，从缓冲区**随机打乱抽取**一个小批量 (Mini-batch) 数据。\n", + " * **为什么？** 因为神经网络最怕输入“高度相关”的连续数据。随机抽样打破了数据的时间相关性，满足了数据独立同分布的假设，同时也让数据得到了高效复用。\n", + "\n", + "2. **目标网络 (Target Network)**：\n", + " * 建立两个一模一样的网络：**主网络 (Main Network)** 和 **目标网络 (Target Network)**。\n", + " * 计算 TD 目标 $y_T = R + \\gamma \\max_a \\hat{q}(S', a, w_T)$ 时，用的是被冻结的**目标网络**参数 $w_T$。\n", + " * **为什么？** 如果用同一个网络，你在追逐目标的同时，目标也在狂奔（因为参数更新了）。固定目标网络一段时间，能让算法有稳定的方向，不易崩溃。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "628f60f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAIhCAYAAAB5deq6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAA+DRJREFUeJzs3Xdc1PUfwPHXsTeKKIiA4N57m6lpSm7NUWku3FqucpWCO7UMG5aDYeasHGmK4s7ULMuVhokoDlBxgMo6uO/vj/txeixBOQ/w/Xw87lH3+a73fb53eO/7fr6ft0pRFAUhhBBCCCGEENkyMXYAQgghhBBCCFHQSeIkhBBCCCGEEE8hiZMQQgghhBBCPIUkTkIIIYQQQgjxFJI4CSGEEEIIIcRTSOIkhBBCCCGEEE8hiZMQQgghhBBCPIUkTkIIIYQQQgjxFJI4CSGEEEIIIcRTSOIkRAGiUqly9Thw4ACXL1/WazM3N6dEiRI0bNiQ8ePH888//+T6uOn7+vTTT3Ncz8vLi4EDBz7nqyxY/P39UalUxMbGGjuUPDPm+Xj06BELFiygdu3aODg4YG9vT/ny5enduzcHDx7UrXfu3Dn8/f25fPnyMx/ryJEj+Pv7c//+/ecP/P/Gjx+PSqXi33//zXadjz76CJVKxV9//ZXr/RbFz0irVq1o1aqV7nlCQgL+/v4cOHAg07rG/jxdvXqVUaNGUalSJaytrXFycqJmzZoMHTqUq1ev6tbbsWMH/v7+BosjY5/lxcCBA7Gzs3vqejmdh6y8zH/nhcgvZsYOQAjx2NGjR/Wez549m/3797Nv3z699mrVqnH37l0A3nvvPd555x00Gg3379/n77//JigoiC+//JL58+fz4Ycf5lt8mzdvxsHBId/2J56Psc5HWloa7dq148yZM3z44Yc0atQIgP/++49t27bx66+/0rJlS0CbOM2cOZNWrVrh5eX1TMc7cuQIM2fOZODAgRQrVixfXoOvry8BAQEEBQWxcOHCTMs1Gg3fffcdderUoV69evlyzMJq6dKles8TEhKYOXMmwDMnB4Zw7do16tWrR7FixZg4cSKVK1cmLi6Oc+fOsXHjRi5duoSHhwegTZy+/vprgyVPGfvMEAx1HuTvvBDZk8RJiAKkSZMmes9LliyJiYlJpnZAlzh5enrqLe/QoQMTJkygR48eTJo0iRo1avDGG2/kS3x169bNl/0YilqtRqVSYWZW+P60paWlkZqaiqWlZa63Mdb5OHToEEeOHCEoKIhBgwbp2tu3b8+YMWPQaDRGiSsvatSoQaNGjVi9ejXz5s3L9J7ZvXs3165dY/LkyUaKsOCoVq2asUPIlRUrVhAbG8vx48fx9vbWtXfr1o1p06Y98/tSURSSkpKwtrbO9TaFpc+yUtD/zgthTDJUT4giyNramsDAQMzNzVm0aFG+7TfjEI4DBw6gUqlYt24dH330EW5ubjg4ONC2bVvCw8Mzbb9nzx7atGmDg4MDNjY2NG/enL179+qtc/HiRQYNGkTFihWxsbGhTJkydO7cmTNnzuitl37s1atXM3HiRMqUKYOlpSUXL17Mt9f7pD///JMuXbrg5OSElZUVdevWZePGjXrr3L59m1GjRlGtWjXs7OwoVaoUr732Gr/++qveeulDZhYuXMicOXPw9vbG0tKS/fv364Y6/fPPP7z99ts4Ojri4uLC4MGDiYuL09vP85wPRVGYN28eZcuWxcrKigYNGhAWFparIUZ37twBoHTp0lkuNzHR/tMSEhJCr169AGjdurVuWGlISAgAYWFhdO3aFXd3d6ysrKhQoQLDhw/XG+bl7++vu2rq7e2tN1w13YYNG2jatCm2trbY2dnRvn17/v777xxfA2ivOsXExLBz585My4KDg7G0tKRv374kJSUxceJE6tSpg6OjI05OTjRt2pStW7c+9RghISGoVKpMQxXTz1XGYVa5+Yzcvn2bYcOG4eHhgaWlJSVLlqR58+bs2bMn2zj++ecfVCoVP/zwg67txIkTqFQqqlevrrduly5dqF+/vu75k++Jy5cvU7JkSQBmzpypOx8Zh3bdvHnzqe/frOTmPZGdO3fuYGJiQqlSpbJcnv6+HDhwIF9//TWgPzw6/RypVCrGjBnDt99+S9WqVbG0tGTVqlW619y4cWOcnJxwcHCgXr16BAYGoiiK3rGy+hxdu3aNnj17Ym9vT7Fixejbty9//PGH3mfiSRcvXqRDhw7Y2dnh4eHBxIkTSU5OBnJ/Hp7Fi/g7L0RhJYmTEEWUm5sb9evX58iRI6Smphr0WNOmTePKlSusXLmS5cuX899//9G5c2fS0tJ063z//fe0a9cOBwcHVq1axcaNG3FycqJ9+/Z6/6jeuHGDEiVK8MknnxAaGsrXX3+NmZkZjRs3zvIf6alTpxIVFcW3337Ltm3bKFWqlC4xya9x+vv376d58+bcv3+fb7/9lq1bt1KnTh369Omj94Un/Sqgn58fv/zyC8HBwZQrV45WrVpleR/CF198wb59+/j000/ZuXMnVapU0S178803qVSpEj/99BNTpkxh7dq1jB8/Plfx5uZ8fPTRR3z00Uf4+PiwdetWRowYwZAhQ7hw4cJT99+gQQPMzc0ZO3Ysa9asITo6Osv1OnbsyLx58wD4+uuvOXr0KEePHqVjx44ARERE0LRpU7755ht2797NjBkz+P3333nllVdQq9UADBkyhPfeew+ATZs26faRPnxu3rx5vP3221SrVo2NGzeyevVqHjx4QIsWLTh37lyOr+Ptt9/GxsaGoKAgvfZ79+6xdetWunfvTvHixUlOTubu3bt88MEHbNmyhXXr1vHKK6/Qo0cPvvvuu6f2V27l9jPy7rvvsmXLFmbMmMHu3btZuXIlbdu21SW0WalevTqlS5fWS6727NmDtbU1586d48aNGwCkpqZy8OBB2rZtm+V+SpcuTWhoKKBNPNPPx/Tp0/XWe9b3b27eE9lp2rQpGo2GHj16sGvXLuLj47Ncb/r06fTs2RNAF//Ro0f1fgjYsmUL33zzDTNmzGDXrl20aNEC0CYsw4cPZ+PGjWzatIkePXrw3nvvMXv27Bxje/ToEa1bt2b//v0sWLCAjRs34uLiQp8+fbJcX61W06VLF9q0acPWrVsZPHgwn3/+OQsWLAByfx7yU37+nRei0FKEEAXWgAEDFFtb2yyXRUZGKoCyaNGibLfv06ePAig3b97M8Ti52ZeiKErZsmWVAQMG6J7v379fAZQOHTrorbdx40YFUI4ePaooiqI8evRIcXJyUjp37qy3XlpamlK7dm2lUaNG2R4zNTVVSUlJUSpWrKiMHz8+07FfffXVTNtcvnxZMTU1VQYPHpzj61EURfHz81MA5fbt29muU6VKFaVu3bqKWq3Wa+/UqZNSunRpJS0tLdvY1Wq10qZNG6V79+669vT+Ll++vJKSkpJlPAsXLtRrHzVqlGJlZaVoNBpd27Oej7t37yqWlpZKnz599NY7evSoAigtW7bMti/SBQYGKnZ2dgqgAErp0qWV/v37K4cOHdJb74cfflAAZf/+/TnuT6PRKGq1Wrly5YoCKFu3btUtW7RokQIokZGRettERUUpZmZmynvvvafX/uDBA8XV1VXp3bv3U1/HgAEDFHNzc73PyJdffqkASlhYWJbbpJ9XX19fpW7dunrLMp6T4ODgLGNPP1fp/ZKXz4idnZ0ybty4p762jPr166eUK1dO97xt27bK0KFDleLFiyurVq1SFEVRfvvtNwVQdu/erVuvZcuWeu+J27dvK4Di5+eX6Rh5ef8+TU7viezWHz58uGJiYqIAikqlUqpWraqMHz8+U/+PHj1aye4rEKA4Ojoqd+/ezfF4aWlpilqtVmbNmqWUKFFC77Vl7LOvv/5aAZSdO3fq7WP48OEKoAQHB+vaBgwYoADKxo0b9dbt0KGDUrlyZd3znM5DVgry33khCgu54iREEaZkGD6Smpqq98i4/Fl16dJF73mtWrUAuHLlCqC9uf/u3bsMGDBA7/gajQYfHx/++OMPHj16pItx3rx5VKtWDQsLC8zMzLCwsOC///7j/PnzmY795ptvZmorW7YsqampBAYGPvdru3jxIv/++y99+/bVxZf+6NChA9HR0XpXwr799lvq1auHlZUVZmZmmJubs3fv3ixj79KlC+bm5lkeN6s+TUpK4tatW0+N+Wnn49ixYyQnJ9O7d2+99Zo0aZLrCRwGDx7MtWvXWLt2Le+//z4eHh58//33tGzZMtfDQ2/dusWIESPw8PDQ9VXZsmUBsuyvjHbt2kVqair9+/fXOy9WVla0bNkyV7ON+fr6olarWb16ta4tODiYsmXL0qZNG13bDz/8QPPmzbGzs9PFGhgYmKs4cyMvn5FGjRoREhLCnDlzOHbs2FOvxKRr06YNly5dIjIykqSkJA4fPoyPjw+tW7cmLCwM0F6FsrS05JVXXnmu1/Os79/neU+oVCq+/fZbLl26xNKlSxk0aBBqtZrPP/+c6tWr6832+DSvvfYaxYsXz9S+b98+2rZti6OjI6amppibmzNjxgzu3LmT42s7ePAg9vb2+Pj46LW//fbb2b6Wzp0767XVqlVL9xk2hvz8Oy9EYVX47qAWQuTalStXsLS0xMnJCSDTl/Tg4OB8Gc5WokQJvefpExwkJiYC2vsdAN3wmKzcvXsXW1tbJkyYwNdff83kyZNp2bIlxYsXx8TEhCFDhuj296Ts7rPJL+mxf/DBB3zwwQdZrpN+/8XixYuZOHEiI0aMYPbs2Tg7O2Nqasr06dOz/NKXU+xP69OcPG3b9CFdLi4umbbNqi07jo6OvP3227ovf//88w9t27blo48+YujQoTnOgKfRaGjXrh03btxg+vTp1KxZE1tbWzQaDU2aNMnV60w/Nw0bNsxyefo9LTlp0aIFlSpVIjg4mIkTJ3L69Gn++usv3b1moB0i2Lt3b3r16sWHH36Iq6srZmZmfPPNN5mG+T2rvHxGNmzYwJw5c1i5ciXTp0/Hzs6O7t27s3DhQlxdXbPdPn343Z49e/D29katVvPaa69x8+ZN3VCzPXv20Lx58zxNhJCVZ3n/5sd7ArQ/nIwcOVL3fOPGjbz99tt8+OGHHD9+PFf7yOqzefz4cdq1a0erVq1YsWIF7u7uWFhYsGXLFubOnZtjfHfu3MnT583GxgYrKyu9NktLS5KSknIVvyHk5995IQorSZyEKKKuX7/OiRMnaNmypW7GsD/++ENvnSdnnjIkZ2dnAL788sssZwiEx18gvv/+e/r376+7NyZdbGxsll/E07/cGkp67FOnTqVHjx5ZrlO5cmVAG3urVq345ptv9JY/ePAgy+0MHXt20r8ApX/ReVJMTMwzTxtevXp13nrrLQICArhw4YJumvKsnD17llOnThESEsKAAQN07XmZ3CP93Pz444+6qxLPYvDgwUyZMoXjx4+zdu1aTExM9H5Q+P777/H29mbDhg165yz9Rv2cpH/5zbhuxskO8vIZcXZ2JiAggICAAKKiovj555+ZMmUKt27d0t33khV3d3cqVarEnj178PLyokGDBhQrVow2bdowatQofv/9d44dO6ab4vpFy4/3RFZ69+7N/PnzOXv2bK63yeqzuX79eszNzdm+fbteUrNly5an7q9EiRJZJm0xMTG5jqmgy8t7WIjCShInIYqgxMREhgwZQmpqKpMmTdK1N2jQwCjxNG/enGLFinHu3DnGjBmT47oqlSrTlNy//PIL169fp0KFCoYMM0uVK1emYsWKnDp1KlMyl1FWsZ8+fZqjR4/q6scUBI0bN8bS0pINGzboJYPHjh3jypUrT02c7ty5g729PRYWFpmWpReUdXNzA7K/0pD+xTRjfy1btizTPrPbR/v27TEzMyMiIiLLIZu5NWDAAD7++GOWLVvGzz//TJs2bfQSMZVKhYWFhd6X6ZiYmFzNqpfel6dPn9Yl2AA///yz3np5+Yw8ydPTkzFjxrB3715+++23p67ftm1bNm7ciIeHh26SjkqVKuHp6cmMGTNQq9XZTgyRLi9XP/MiL++JrERHR2d5pejhw4dcvXpV95588hiJiYm5vrqWXurA1NRU15aYmKg3zDM7LVu2ZOPGjezcuVOvPMT69etzdeysGOo8PKtnfQ8LUZhI4iREIRcVFcWxY8fQaDTExcXpCuBeuXKFzz77jHbt2uV6X2fOnOHHH3/M1N6wYcPn+kXfzs6OL7/8kgEDBnD37l169uxJqVKluH37NqdOneL27du6qzSdOnUiJCSEKlWqUKtWLU6cOMGiRYtwd3fP9fGuXLlC+fLlGTBgQK7vc9q2bRv29vaZ2nv27MmyZct44403aN++PQMHDqRMmTLcvXuX8+fP89dff+mmeO7UqROzZ8/Gz8+Pli1bEh4ezqxZs/D29jb4zIZ54eTkxIQJE5g/fz7Fixene/fuXLt2jZkzZ1K6dOmnDnHbv38/Y8eOpW/fvjRr1owSJUpw69Yt1q1bR2hoKP3799edrxo1agCwfPly7O3tsbKywtvbmypVqlC+fHmmTJmCoig4OTmxbds23b02T6pZsyYAS5YsYcCAAZibm1O5cmW8vLyYNWsWH330EZcuXcLHx4fixYtz8+ZNjh8/jq2tba6unri6utKhQweCg4NRFAVfX1+95Z06dWLTpk2MGjWKnj17cvXqVWbPnk3p0qX577//ctx3w4YNqVy5Mh988AGpqakUL16czZs3c/jwYb31cvsZiYuLo3Xr1rzzzjtUqVIFe3t7/vjjD0JDQ7O9IvqkNm3asHTpUmJjYwkICNBrDw4Opnjx4npTkWfF3t6esmXLsnXrVtq0aYOTkxPOzs7PfKUyXV7eE1mZO3cuv/32G3369KFOnTpYW1sTGRnJV199xZ07d/TuvUt/Ty1YsIA33ngDU1NTatWqleWPAek6duzI4sWLeeeddxg2bBh37tzh008/zVXttQEDBvD555/Tr18/5syZQ4UKFdi5cye7du0CcjesNKNnPQ8F4e+8EIWWUaemEELkKDez6qU/TE1NleLFiyv169dXxo0bp/zzzz+5Pk7GfWV8pM/4lN1sSz/88EOW+3typihFUZSDBw8qHTt2VJycnBRzc3OlTJkySseOHfW2v3fvnuLr66uUKlVKsbGxUV555RXl119/zTRLVXbHfvL4T8aanfRZwLJ7pDt16pTSu3dvpVSpUoq5ubni6uqqvPbaa8q3336rWyc5OVn54IMPlDJlyihWVlZKvXr1lC1btigDBgxQypYtmym+rGa3ym6Wv6xmZ3ue86HRaJQ5c+Yo7u7uioWFhVKrVi1l+/btSu3atfVmAMzK1atXlY8//lhp3ry54urqqpiZmSn29vZK48aNlS+//FJJTU3VWz8gIEDx9vZWTE1N9eI4d+6c8vrrryv29vZK8eLFlV69eilRUVFZzhQ2depUxc3NTTdj2pOz9G3ZskVp3bq14uDgoFhaWiply5ZVevbsqezZsyfH1/GkrVu3KoDi5OSkJCUlZVr+ySefKF5eXoqlpaVStWpVZcWKFbpz9aSM50RRFOXChQtKu3btFAcHB6VkyZLKe++9p/zyyy9Zzjb4tM9IUlKSMmLECKVWrVqKg4ODYm1trVSuXFnx8/NTHj169NTXee/ePcXExESxtbXVm9FxzZo1CqD06NEj0zYZP3uKoih79uxR6tatq1haWup91vLy/s1KXt4TGR07dkwZPXq0Urt2bcXJyUkxNTVVSpYsqfj4+Cg7duzQWzc5OVkZMmSIUrJkSUWlUunFBiijR4/O8hhBQUFK5cqVFUtLS6VcuXLK/PnzlcDAwEyvLas+i4qKUnr06KHY2dkp9vb2yptvvqns2LEj04yB2f3dz+r9lt15yEpB+jsvRGGlUpR8mlZLCCFEoRYZGUmVKlXw8/Nj2rRpxg5HiCJv3rx5fPzxx0RFReXpqroQwjhkqJ4QQryETp06xbp162jWrBkODg6Eh4ezcOFCHBwcMg1VE0I8v6+++grQDklUq9Xs27ePL774gn79+knSJEQhIYmTEEK8hGxtbfnzzz8JDAzk/v37ODo60qpVK+bOnSszXwlhADY2Nnz++edcvnyZ5ORkPD09mTx5Mh9//LGxQxNC5JIM1RNCCCGEEEKIp8j7NC5CCCGEEEII8ZKRxEkIIYQQQgghnkISJyGEEEIIIYR4ipducgiNRsONGzewt7fXqwIvhBBCCCGEeLkoisKDBw9wc3N7ajHqly5xunHjBh4eHsYOQwghhBBCCFFAXL169amlAV66xMne3h7Qdo6Dg4ORowG1Ws3u3btp164d5ubmxg6nyJH+NSzpX8OS/jUs6V/Dkv41LOlfw5L+NayC1L/x8fF4eHjocoScvHSJU/rwPAcHhwKTONnY2ODg4GD0N05RJP1rWNK/hiX9a1jSv4Yl/WtY0r+GJf1rWAWxf3NzC49MDiGEEEIIIYQQTyGJkxBCCCGEEEI8hSROQgghhBBCCPEUL909TrmhKAqpqamkpaUZ/FhqtRozMzOSkpJeyPFeNtK/hlXQ+tfc3BxTU1NjhyGEEEKIIkgSpwxSUlKIjo4mISHhhRxPURRcXV25evWq1JUyAOlfwypo/atSqXB3d8fOzs7YoQghhBCiiJHE6QkajYbIyEhMTU1xc3PDwsLC4F8GNRoNDx8+xM7O7qlFt0TeSf8aVkHqX0VRuH37NteuXaNixYpy5UkIIYQQ+UoSpyekpKSg0Wjw8PDAxsbmhRxTo9GQkpKClZWV0b94FkXSv4ZV0Pq3ZMmSXL58GbVaLYmTEEIIIfKV8b/pFEAF4QugECLvCsJwQSGEEEIUTZIhCCGEEEIIIcRTSOIkhBBCCCGEEE8hiZOhpKXBgQOwbp32vwVgqubColWrVowbN87YYQghhBBCCKEjiZMhbNoEXl7QujW88472v15e2nYDUKlUOT4GDhxokONm1LlzZ9q2bZvlsqNHj6JSqfjrr79eSCxCCCGEEELkJ5lVL79t2gQ9e4Ki6Ldfv65t//FH6NEjXw8ZHR2t+/8NGzYwY8YMwsPDdW3W1tZ666vVaszNzfM1BgBfX1969OjBlStXKFu2rN6yoKAg6tSpQ7169fL9uEIIIYQQQhiaXHHKT2lpMHZs5qQJHreNG5fvw/ZcXV11D0dHR1Qqle55UlISxYoVY+PGjbRq1QorKyu+//57/P39qVOnjt5+AgIC8PLy0msLDg6matWqWFlZUaVKFZYuXZptHJ06daJUqVKEhITotSckJLBhwwZ8fX25c+cOb7/9Nu7u7tjY2FCzZk3WrVuX4+tTqVRs2bJFr61YsWJ6x7l+/Tp9+vShePHilChRgq5du3L58mXd8gMHDtCoUSNsbW0pVqwYzZs358qVKzkeVwghhBBCiHRyxSk3GjSAmJinr5ecDLGx2S9XFLh6FVxdwdISABXgoChZT6Ps6gp//vlsMWcwefJkPvvsM4KDg7G0tGT58uVP3WbFihX4+fnx1VdfUbduXf7++2+GDh2Kra0tAwYMyLS+mZkZ/fv3JyQkhBkzZuhe0w8//EBKSgp9+/YlISGB+vXrM3nyZBwcHPjll1949913KVeuHI0bN36m15aQkEDr1q1p0aIFhw4dwszMjDlz5uDj48PJkydJTU2lR48eDB06lHXr1pGSksLx48dl6mohhBBCCJFrkjjlRkyMdqhdfnkiuVL9/2Fo48aNo0cehwjOnj2bzz77TLedt7c3586dY9myZVkmTgCDBw9m0aJFHDhwgNatWwPaYXo9evSgePHiFC9enA8++EC3/nvvvUdoaCg//PDDMydO69evx8TEhJUrV+qSoeDgYIoVK8aBAweoXLkycXFxdOrUifLlywNQtWrVZzqWEEIIIYR4OUnilBuurrlb72lXnNI5O+uuOCmA8v8rTpkSqNweNxcaNGiQp/Vv377N1atX8fX1ZejQobr21NRUHB0ds92uSpUqNGvWjKCgIFq3bk1ERAS//voru3fvBiAtLY1PPvmEDRs2cP36dZKTk0lOTsbW1vbZXhhw4sQJLl68iL29vV57UlISERERNGnShAEDBtC+fXtef/112rZtS+/evSlduvQzH1MIIYQQQjybBykPjB3CM5HEKTdyO1wuLU07e97161nf56RSgbs7REaCqSkAikZDfHw8Dg4OqEwMd8tZxsTExMQEJUOMarVa9/8ajQbQDtfLeCXI9P+xZ8fX15cxY8bw9ddfExwcTNmyZWnTpg0An332GZ9//jkBAQHUrFkTW1tbxo0bR0pKSrb7U6lUT421fv36rFmzJtO2JUqUALRXvcaOHUtoaCgbNmzg448/JiwsjCZNmuT4WoQQQgghRP64cO8CgWcC2Re1j7G2Y40dTp5J4pSfTE1hyRLt7HkqlX7ylH4/TUCALmkyppIlSxITE6O72gVw8uRJ3XIXFxfKlCnDpUuX6Nu3b5723bt3b8aOHcvatWtZtWoVQ4cO1R3j119/pWvXrvTr1w/QJj3//fdfjkPnSpYsqTdz4H///UdCQoLueb169diwYQOlSpXCwcFBb1vN/xNTgLp161K3bl2mTp1K06ZNWbt2rSROQgghhBAG9tfNvwg8G8iha4d0bf+q/zViRM9GZtXLbz16aKccL1NGv93d3SBTkT+rVq1acfv2bRYuXEhERARff/01O3fu1FvH39+f+fPns2TJEi5cuMCZM2cIDg5m8eLFOe7bzs6OPn36MG3aNG7cuKFXR6pChQqEhYVx5MgRzp8/z/Dhw4l5ysQbr732Gl999RV//fUXf/75JyNGjNCbTr1v3744OzvTtWtXfv31VyIjIzl48CBjx47l2rVrXLlyhWnTpnH06FGuXLnC7t27uXDhgtznJIQQQghhYH/E/MGA0AEcunYIE5UJ7b3as9ZnLQ0tGxo7tDyTxMkQevSAy5dh/35Yu1b738jIApM0gXZyhKVLl/L1119Tu3Ztjh8/rjdpA8CQIUNYuXIlISEh1KxZk5YtWxISEoK3t/dT9+/r68u9e/do27Ytnp6euvbp06dTr1492rdvT6tWrXB1daVbt2457uuzzz7Dw8ODV199lXfeeYcPPvgAGxsb3XIbGxsOHTqEp6cnPXr0oGrVqgwePJjExEQcHBywtrbm33//5c0336RSpUoMGzaMMWPGMHz48Lx1mhBCCCGEyFGqJpWI+xG65/Vd6lPVqSpvVnyTn7v9zKctP6WKUxUjRvjsVErGm0eKuPj4eBwdHYmLi8s0rCspKYnIyEi8vb2xsrJ6IfFonrjHycSA9zi9rKR/Daug9a8xPsOGpFar2bFjBx06dDBI0eqXnfSvYUn/Gpb0r2FJ/+ZdUmoSWy9uJfifYBJTEwl9MxRrM2tAm0yZmTy+Q6gg9W9OuUFGco+TEEIIIYQQ4pk8SHnAhvANfH/ue+4k3QGguGVxLt2/RHXn6gB6SVNhZvSfiJcuXar7dbh+/fr8+uuvOa7/9ddfU7VqVaytralcuTLffffdC4pUCCGEEEIIAXA36S4BJwJo92M7lvy1hDtJdyhtW5opjaawq+cuXdJUlBg1/duwYQPjxo1j6dKlNG/enGXLlvHGG29w7tw5vfti0n3zzTdMnTqVFStW0LBhQ44fP87QoUMpXrw4nTt3NsIrEEIIIYQQ4uVzN/EugWcDASjvWJ7BNQfzhvcbmJsU3aGNRk2cFi9ejK+vL0OGDAEgICCAXbt28c033zB//vxM669evZrhw4fTp08fAMqVK8exY8dYsGCBJE5CCCGEEEIYSPjdcE7dPkXvyr0BqFC8AkNrDqWGcw1aebTCRGX0gWwGZ7TEKSUlhRMnTjBlyhS99nbt2nHkyJEst0lOTs50w7e1tTXHjx9HrVZneXNZcnIyycnJuufpNX3UarVeEdX0NkVR0Gg0ugKwhpY+N0f6cUX+kv41rILWvxqNBkVRUKvVTy3UXBik/43K+LdK5A/pX8OS/jUs6V/Dkv597O9bfxN8LpjDNw5jpjKjsUtj3GzdABhZcyQAaalppJGW630WpP7NSwxGS5xiY2NJS0vDxcVFr93FxSXbuj7t27dn5cqVdOvWjXr16nHixAmCgoJQq9XExsZSunTpTNvMnz+fmTNnZmrfvXu33pTWAGZmZri6uvLw4UNSUlKe49Xl3YMHD17o8V420r+GVVD6NyUlhcTERA4dOkRqaqqxw8k3YWFhxg6hSJP+NSzpX8OS/jWsl7V/FUXhQuoFDiYdJCotCgAVKqqYVWHfvn04mTrly3EKQv8mJCTkel2jT3GhUqn0niuKkqkt3fTp04mJiaFJkyYoioKLiwsDBw5k4cKF2f66PHXqVCZMmKB7Hh8fj4eHB+3atctyOvKrV69iZ2f3wqYyVhSFBw8eYG9vn+3rFs9O+tewClr/JiUlYW1tzauvvlpkpiMPCwvj9ddfN/p0rUWR9K9hSf8alvSvYb3M/Xvx/kU+OvIR/z36DwBzE3M6eXdiQNUBeDpknoPgWRSk/k0fjZYbRkucnJ2dMTU1zXR16datW5muQqWztrYmKCiIZcuWcfPmTUqXLs3y5cuxt7fH2dk5y20sLS2xtLTM1G5ubp7pRKWlpaFSqTAxMXlhNWnShzelH1fkL+lfwypo/WtiYoJKpcry812YFbXXU9BI/xqW9K9hSf8a1svYv2Ucy3Dj0Q1szGzoXbk371Z7l1I2pQxyrILQv3k5vtESJwsLC+rXr09YWBjdu3fXtYeFhdG1a9cctzU3N8fd3R2A9evX06lTpwLxpU0IIYQQQojCIr0G0+nbp1nSegkqlQoHCwcCWgdQ1akqjpaOxg6xQDFqtjFhwgRWrlxJUFAQ58+fZ/z48URFRTFixAhAO8yuf//+uvUvXLjA999/z3///cfx48d56623OHv2LPPmzTPWSyjSQkJCKFasmLHDyJMXEfPly5dRqVScPHnSoMcRQgghhDCE2MRYvRpM+6/u58TNE7rlTUo3kaQpC0ZNnPr06UNAQACzZs2iTp06HDp0iB07dlC2bFkAoqOjiYqK0q2flpbGZ599Ru3atXn99ddJSkriyJEjeHl5GekVFBwDBw5EpVJlevj4+ORqey8vLwICAvTa+vTpw4ULFwwQrb4XlaDdvHkTc3Nzvv/++yyXDx8+nFq1ahk8jvy2d+9e3n77bby9vXF2dqZWrVpMnjyZ69evP3Xb9CQwq8exY8eeK66xY8dSv359LC0tqVOnTpbrnDlzhpYtW2JtbU2ZMmWYNWuWbqY+IYQQQuSvqw+uMufYHNr/2J7As4E8VD+kvGN55r0yj9qlahs7vALP6JNDjBo1ilGjRmW5LCQkRO951apV+fvvv19AVIWTj48PwcHBem1Z3d+VW9bW1lhbWz9vWAWGi4sLHTt2JDg4mH79+uktS0xMZP369cyaNctI0eVdYmIigwcP5sCBA4wcOZIhQ4bg6urKtWvX2LRpE7Vq1SI4OJguXbo8dV979uyhenX9Ct8lSpR4rvgURWHw4MH8/vvvnD59OtPy+Ph4Xn/9dVq3bs0ff/zBhQsXGDhwILa2tkycOPG5ji2EEEIIfadvn+bdne+iUbT3J9cqWYshNYbQ0qPlS1GDKT9IL+VSQkpqto8kddpzrZuYkpZpvWdhaWmJq6ur3qN48eK65f7+/nh6emJpaYmbmxvvv/8+AK1ateLKlSuMHz9ed7UBMl8J8vf3p06dOgQFBeHp6YmdnR0jR44kLS2NhQsX4urqSqlSpZg7d65eXIsXL6ZmzZrY2tri4eHBqFGjePjwIQAHDhxg0KBBxMXF6Y7t7+8PaKeWnjRpEmXKlMHW1pbGjRtz4MABvX2HhITg6emJjY0N3bt3586dOzn2ka+vL/v37+fy5ct67T/++CNJSUn069eP0NBQXnnlFYoVK0aJEiXo1KkTERER2e4zqytmW7ZsyTTL3LZt26hfvz5WVlaUK1eOmTNn6k2Znd35yc6gQYOIj4/nwoULzJgxgzZt2lC9enXat2/PsmXLCA0NZfjw4Zw6dSrH/YA2Scr43km/WTL9vC9btgwPDw9sbGzo1asX9+/fz3GfX3zxBaNHj6ZcuXJZLl+zZg1JSUmEhIRQo0YNevTowbRp01i8eLFcdRJCCCHyQWxirO7/q5eojqe9J83dmhPUPojv3/ie1p6tJWnKA6NfcSosqs3Yle2y1pVLEjyoke55/dl7SFRnXQSssbcTG4Y31T1/deEB7iZkLrx1+ZOOzxFtZj/++COff/4569evp3r16sTExOi+UG/atInatWszbNgwhg4dmuN+IiIi2LlzJ6GhoURERNCzZ08iIyOpVKkSBw8e5MiRIwwePJg2bdrQpEkTQDvT2RdffIGXlxeRkZGMGjWKSZMmsXTpUpo1a0ZAQAAzZswgPDwcADs7O0CbGFy+fJn169fj5ubG5s2b8fHx4cyZM1SsWJHff/+dwYMHM2/ePHr06EFoaCh+fn45xt+hQwdcXV0JCQnRJWgAQUFBdOvWjRIlSvDo0SMmTJhAzZo1efToETNmzKB79+6cPHnymSch2bVrF/369eOLL76gRYsWREREMGzYMAD8/PxyPD9ZCQsL488//+TUqVPY2Ngwd+5cAgMDAfjwww8JCAggLCyMOXPmMHnyZEJDQ58p7nQXL15k48aNbNu2jfj4eHx9fRk9ejSrV69+5n0ePXqUli1b6l0Vbd++PVOnTuXy5ct4e3s/V8xCCCHEy0hRFA5dO0Tg2UCuPrhK6JuhWJpaYmpiyrqO67CzsDN2iIWWJE5FyPbt23VJR7rJkyczffp0oqKicHV1pW3btpibm+Pp6UmjRtpkz8nJCVNTU+zt7XF1dc3xGBqNhqCgIOzt7alWrRqtW7cmPDycHTt2YGJiQuXKlVmwYAEHDhzQJU7jxo3Tbe/t7c3s2bMZOXIkS5cuxcLCAkdHR1Qqld6xIyIiWLduHdeuXcPNTVud+oMPPiA0NJTg4GDmzZvHkiVLaN++PVOmTAGgUqVKHDlyJMckwdTUlP79+xMSEoKfnx8qlYrIyEgOHjyo2+7NN9/U2yYwMJBSpUpx7tw5atSokWP/ZGfu3LlMmTKFAQMGAFCuXDlmz57NpEmT8PPzy/H8ZGXVqlWMGzcOW1tb1qxZw5IlS1i+fDnu7u5Mnz6diIgINBoN/fr1Y9SoUTx69AhbW9ts99esWbNMSWFcXJyuPlpSUhKrVq3SzWb55Zdf0rFjRxYtWpSpkHRuxcTEZLo/Mb0UQUxMjCROQgghRB6kalIJvRxK0Nkg/rv3uAbTmdtnaODaAECSpuckiVMunZvVPttlJhmGZJ2Y3jbX6x6a1IoH8Q+wd7B/7inVW7duzTfffKPX5uSkrezcq1cvAgICKFeuHD4+PnTo0IHOnTtjZpa3t4CXlxf29va65y4uLpiamurF7uLiwq1bt3TP9+/fz7x58zh37hzx8fGkpqaSlJSU45f5v/76C0VRqFSpkl57cnKy7t6b8+fP601lD9C0adOnXl3x9fVlwYIF7Nu3jzZt2hAUFIS7uztt22rPW0REBNOnT+fYsWPExsbqahVFRUU9c+J04sQJ/vjjD71hjGlpaSQlJZGQkJDn83P69GldYeetW7cyduxYunXrBsCKFSvw8PAAtMM3HR0diY+PzzFx2rBhA1WrVtVre7KotKenpy5pAm0/azQawsPDqVu3bt464wlZFcDOql0IIYQQWUtKTWLLxS2E/BPC9YfaiaFszGzoU7kP/ar1M1gNppeRJE65ZGOR+67K67qpFqbYWJg9d+Jka2tLhQoVslzm4eFBeHg4YWFh7Nmzh1GjRrFo0SIOHjyYp8JfGddNLzaasS092bhy5QodOnRgxIgRzJ49GycnJw4fPoyvry9qdeYhiuk0Gg2mpqacOHFC7ws8PB7K96z3wVSsWJEWLVoQHBxM69atWbVqFYMGDdL1f+fOnfHw8GDFihW4ubmh0WioUaMGKSkpWe7PxMQkUywZX5tGo2HmzJn06NEj0/ZWVlZ5Pj+pqalYWVkB2nvBnkyKnrzqeOPGDVJSUihZsmSOfeLh4ZHteycr6YnN8yQ4rq6uWRbABrItgi2EEEIIfVfirzD3d+0Ps8Uti9OvWj/6VO4j04kbgCROLxFra2u6dOlCly5dGD16NFWqVOHMmTPUq1cPCwsL0tKyvi/refz555+kpqby2Wef6RKTjRs36q2T1bHr1q1LWloat27dokWLFlnuu1q1apmmzM7tFNq+vr6MHDmSrl27cu3aNQYNGgTAnTt3OH/+PMuWLdMd9/Dhwznuq2TJkjx48EDvClrGGk/16tUjPDw8x+Qkp/OTUYUKFTh9+jTVqlXj1VdfZcWKFfTo0QNXV1dmz54NaKdf9/PzY8yYMXm+sphRVFQUN27c0A2bPHr0KCYmJpmuCOZF06ZNmTZtGikpKVhYWACwe/du3NzcpMSAEEIIkY3YxFj+vvU3r5d9HYDKTpXpWaknFYtVpHvF7libFZ0ZkQsamUajCElOTiYmJkbvERurnU0lJCSEwMBAzp49y6VLl1i9ejXW1ta6mlleXl4cOnSI69ev67bJD+XLlyc1NZUvv/xSd9xvv/1Wbx0vLy8ePnzI3r17iY2NJSEhgUqVKtG3b1/69+/Ppk2biIyM5I8//mDBggXs2LEDgPfff5/Q0FAWLlzIhQsX+Oqrr3I9CUKvXr0wNzdn+PDhtGnTRvdFvXjx4pQoUYLly5dz8eJF9u3bpxsSl53GjRtjY2PDtGnTuHjxImvXrs00lf6MGTP47rvv8Pf3559//uH8+fNs2LCBjz/+GHj6+cmoe/fufPXVVwCMHj2aatWq4eXlhZ2dHQkJCbi5ueHj40PDhg2ZOXPmU/vjzp07md47SUlJuuVWVlYMGDCAU6dO8euvv/L+++/Tu3fvHO+Ju3jxIidPniQmJobExEROnjzJyZMndVfu3nnnHSwtLRk4cCBnz55l8+bNzJs3jwkTJshQPSGEECKDqw+uMvvobNr/2J5JhyZx89FN3TK/pn68U/UdSZoMTXnJxMXFKYASFxeXaVliYqJy7tw5JTEx8YXFk5aWpty7d09JS0t7rv0MGDBAATI9KleurCiKomzevFlp3Lix4uDgoNja2ipNmjRR9uzZo9v+6NGjSq1atRRLS0sl/W0RHBysODo66tbx8/NTateunem4Xbt21Wtr2bKlMnbsWN3zxYsXK6VLl1asra2V9u3bK999950CKPfu3dOtM2LECKVEiRIKoPj5+SmKoigpKSnKjBkzFC8vL8Xc3FxxdXVVunfvrpw+fVq3XWBgoOLu7q5YW1srnTt3Vj799FO9mHPq32HDhimAsnbtWr32sLAwpWrVqoqlpaVSq1Yt5cCBAwqgbN68WVEURYmMjFQA5e+//9Zts3nzZqVChQqKlZWV0qlTJ2X58uVKxo9XaGio0qxZM8Xa2lpxcHBQGjVqpCxfvly3fU7nJyO1Wq3Url1bmTJliq7t/v37uj6Njo5WUlNTs90+Xfpryeqxbt06RVEen/elS5cqbm5uipWVldKjRw/l7t27OfZvy5Yts9xvZGSkbp3Tp08rLVq0UCwtLRVXV1fF399f0Wg0T407O8b4DBtSSkqKsmXLFiUlJcXYoRRJ0r+GJf1rWNK/hlWQ+vffO/8qHx78UKm1qpZSI6SGUiOkhtL3l75K+N1wY4f2zApS/+aUG2SkUpSXq2BKfHw8jo6OxMXF4eDgoLcsKSmJyMhIvL29dfePGJpGoyE+Ph4HB4fnvsdJZFaU+zcqKgofHx/c3d2ZPHkyzZs3x8rKiujoaFavXs2PP/7I4cOHdcPgnpW/vz9btmzJNPwQCl7/GuMzbEhqtZodO3bQoUOHPN2LKHJH+tewpH8NS/rXsApC/159cJX5v8/n1+u/6tqal2nOkBpDqO9Sv1CPzigI/Zsup9wgI7nHSYhCytPTk+PHj/PZZ5/h6+vLlStXsLCwwMzMjE6dOhEcHPzcSZMQQgghjMPe3J4/b/6JicqEdmXb4VvTlypOVYwd1ktNEichCjE7Ozv8/Pzw8/Pj7t27JCQk4OLiYvRfb4QQQgiRe+k1mP6M+RP/Zv4AFLMqxuzms6nqVBVPB0/jBigASZyEKDKcnJx0dbvyk7+/P/7+/vm+XyGEEOJll1UNpm4VulGnVB0A2ntlX0dUvHiSOAkhhBBCCPECxafEszF8I6vPreZu0l0AnKyc6Fu1L96O3kaOTmRHEichhBBCCCFekPC74QwMHchD9UMA3GzdGFB9gNRgKgQkcRJCCCGEEMKAklKTsDLTzvZavlh5HC0dcbV1ZXCNwfh4+2BuIvcmFwaSOAkhhBBCCGEA4XfDCTwTyKnbp9jefTvmpuaYmZgR3D4YF1sXTFTGL+Uhck8SJyGEEEIIIfLRiZsnCDwTqFeD6Vj0MVq4twCgtF1pY4UmnoMkTkIIIYQQQjwnRVE4dO0QgWcD+fvW3wCYqExoX7Y9g2sOlhpMRYBcHxTZCgkJoVixYsYOI09eRMyXL19GpVJx8uRJgx5HCCGEEIVH+L1wxuwbw9+3/sbcxJxelXqxrds2FrZcKElTESGJUxExcOBAVCpVpoePj0+utvfy8iIgIECvrU+fPly4cMEA0ep7UQnazZs3MTc35/vvv89y+fDhw6lVq5bB48hve/fu5e2338bb2xtnZ2dq1arF5MmTuX79+lO3TU8Cs3ocO3bsueLKap/ffvut3jpnzpyhZcuWWFtbU6ZMGWbNmoWiKM91XCGEEOJFSEpN4o+YP3TPqzhVoY1nGwbVGMSuN3cxo+kMKVxbxMhQvSLEx8eH4OBgvTZLS8tn3p+1tTXW1kVnWkwXFxc6duxIcHAw/fr101uWmJjI+vXrmTVrlpGiy7vExEQGDx7MgQMHGDlyJEOGDMHV1ZVr166xadMmatWqRXBwMF26dHnqvvbs2UP16tX12kqUKPHcMQYHB+sl746Ojrr/j4+P5/XXX6d169b88ccfXLhwgYEDB2Jra8vEiROf+9hCCCGEITxZg+lhykN29dyFs7UzAJ+3+hyVSmXkCIWhyBWn3Ep5lP1DnZSHdRMzr6tOyLzeM7C0tMTV1VXvUbx4cd1yf39/PD09sbS0xM3Njffffx+AVq1aceXKFcaPH6+7MgCZrwT5+/tTp04dgoKC8PT0xM7OjpEjR5KWlsbChQtxdXWlVKlSzJ07Vy+uxYsXU7NmTWxtbfHw8GDUqFE8fKitXXDgwAEGDRpEXFyc7tj+/v7arklJYdKkSZQpUwZbW1saN27MgQMH9PYdEhKCp6cnNjY2dO/enTt37uTYR76+vuzfv5/Lly/rtf/4448kJSXRr18/QkNDeeWVVyhWrBglSpSgU6dOREREZLvPrK6YbdmyJdMfzm3btlG/fn2srKwoV64cM2fOJDU1Va9/szo/2Rk0aBDx8fFcuHCBGTNm0KZNG6pXr0779u1ZtmwZoaGhDB8+nFOnTuW4H9AmSRnfO+bm5rq46tSpw7Jly/Dw8MDGxoZevXpx//79p+63WLFievt8MhFfs2YNSUlJhISEUKNGDXr06MG0adNYvHixXHUSQghR4MQmxrL4xGLa/diOJX8t4W7SXZytnbn24JpuHUmaija54pRb89yyX1axHfT94fHzRRW0yVBWyr4Cg37RPVV9UZtiCVl82fePe8ZAs/bjjz/y+eefs379eqpXr05MTIzuC/WmTZuoXbs2w4YNY+jQoTnuJyIigp07dxIaGkpERAQ9e/YkMjKSSpUqcfDgQY4cOcLgwYNp06YNTZo0AcDExIQvvvgCLy8vIiMjGTVqFJMmTWLp0qU0a9aMgIAAZsyYQXh4OAB2dnaANjG4fPky69evx83Njc2bN+Pj48OZM2eoWLEiv//+O4MHD2bevHn06NGD0NBQ/Pz8coy/Q4cOuLq6EhISokvQAIKCgujWrRslSpTg0aNHTJgwgZo1a/Lo0SNmzJhB9+7dOXnyJCYmz/Zbw65du+jXrx9ffPEFLVq0ICIigmHDhgHg5+eX4/nJSlhYGH/++SenTp3CxsaGuXPnEhgYCMCHH35IQEAAYWFhzJkzh8mTJxMaGvpMcae7ePEiGzduZNu2bcTHx+Pr68vo0aNZvXp1jtuNGTOGIUOG4O3tja+vL8OGDdP14dGjR2nZsqXeVdH27dszdepULl++jLe3VE4XQghhfLGJsSw9uZStF7eSokkBoEKxClKD6SUkiVMRsn37dl3SkW7y5MlMnz6dqKgoXF1dadu2Lebm5nh6etKoUSMAnJycMDU1xd7eHldX1xyPodFoCAoKwt7enmrVqtG6dWvCw8PZsWMHJiYmVK5cmQULFnDgwAFd4jRu3Djd9t7e3syePZuRI0eydOlSLCwscHR0RKVS6R07IiKCdevWce3aNdzctEnrBx98QGhoKMHBwcybN48lS5bQvn17pkyZAkClSpU4cuRIjkmCqakp/fv3JyQkBD8/P1QqFZGRkRw8eFC33Ztvvqm3TWBgIKVKleLcuXPUqFEjx/7Jzty5c5kyZQoDBgwAoFy5csyePZtJkybh5+eX4/nJyqpVqxg3bhy2trasWbOGJUuWsHz5ctzd3Zk+fToRERFoNBr69evHqFGjePToEba2ttnur1mzZpmSwri4OExNTQFISkpi1apVuLu7A/Dll1/SsWNHFi1ahI2NTZb7nD17Nm3atMHa2pq9e/cyceJEYmNj+fjjjwGIiYnBy8tLbxsXFxfdMkmchBBCFBTpSVPtkrUZUnMIr7q/KjWYXkKSOOXWtBvZL1OZ6j//8GIO6+p/yJT3TxH34AEO9vbPfDUjXevWrfnmm2/02pycnADo1asXAQEBlCtXDh8fHzp06EDnzp0xM8vbW8DLywt7e3vdcxcXF0xNTfVid3Fx4datW7rn+/fvZ968eZw7d474+HhSU1NJSkrK8cv8X3/9haIoVKpUSa89OTlZd+/N+fPn6d69u97ypk2bPvXqiq+vLwsWLGDfvn20adOGoKAg3N3dadu2LaBN2qZPn86xY8eIjY1Fo9EAEBUV9cyJ04kTJ/jjjz/0hjGmpaWRlJREQkJCns/P6dOnmTBhAgBbt25l7NixdOvWDYAVK1bg4eEBaIdvOjo6Eh8fn2PitGHDBqpWrarXlp40AXh6euqSJtD2s0ajITw8nLp162a5z/QECaBOnToAzJo1S68945CG9CF6MtRBCCGEMSiKwombJzh87TDeaH/Ac7Z2ZnKjyZRzLEd9l/ryb9RLTBKn3LLI/kvnc69rnqb973MmTra2tlSoUCHLZR4eHoSHhxMWFsaePXsYNWoUixYt4uDBg7p7WXIj47oqlSrLtvRk48qVK3To0IERI0Ywe/ZsnJycOHz4ML6+vqjV6myPo9FoMDU15cSJE3pf4OHxUL5nvQ+mYsWKtGjRguDgYFq3bs2qVasYNGiQLvnr3LkzHh4erFixAjc3NzQaDTVq1CAlJSXL/ZmYmGSKJeNr02g0zJw5kx49emTa3srKKs/nJzU1FSsrK0B7L9iTSdGTVx1v3LhBSkoKJUuWzLFPPDw8sn3vZCX9H428/OPRpEkT4uPjuXnzJi4uLri6uhITE6O3TnrCnX7lSQghhHgRNIpGW4PpTCAnb58EYITdCN3y3pV7GykyUZBI4vQSsba2pkuXLnTp0oXRo0dTpUoVzpw5Q7169bCwsCAtLS3fj/nnn3+SmprKZ599pktMNm7cqLdOVseuW7cuaWlp3Lp1ixYtWmS572rVqmWaMju3U2j7+voycuRIunbtyrVr1xg0aBAAd+7c4fz58yxbtkx33MOHD+e4r5IlS/LgwQO9K2gZazzVq1eP8PDwHJOTnM5PRhUqVOD06dNUq1aNV199lRUrVtCjRw9cXV2ZPXs2oJ1+3c/PjzFjxuT5ymJGUVFR3LhxQzds8ujRo5iYmGS6IpiTv//+GysrK91EGk2bNmXatGmkpKRgYWEBwO7du3Fzc8s0hE8IIYQwBLVGTWhkKEFng7h4XztiyNzEnC7lumB3y+4pW4tnkpaG6uBByhw6hMrWFlq3hgw/khdUkjgVIcnJyZl+wTczM8PZ2ZmQkBDS0tJo3LgxNjY2rF69Gmtra8qWLQtoh+AdOnSIt956C0tLS5ydnfMlpvLly5OamsqXX35J586d+e233zLV8vHy8uLhw4fs3buX2rVrY2NjQ6VKlejbty/9+/fns88+o27dusTGxrJv3z5q1qxJhw4deP/992nWrBkLFy6kW7du7N69O9eTIPTq1Yv333+f4cOH06ZNG90X9eLFi1OiRAmWL19O6dKliYqK0t1DlZ30Pp02bRrvvfcex48fJyQkRG+dGTNm0KlTJzw8POjVqxcmJiacPn2aM2fOMGfOnKeen4y6d+/OV199xVtvvcXo0aM5evQoXl5emJmZ4evri5ubGz4+PowZM0ZvEozs3LlzJ9N7p1ixYrqrWlZWVgwYMIBPP/2U+Ph43n//fXr37o2rqyvx8fGZ9rdt2zZiYmJo2rQp1tbW7N+/n48++ohhw4bpJoN45513mDlzJgMHDmTatGn8999/zJs3jxkzZsgwCCGEEAYXGRfJyD0juf5QW/fQ1tyW3pV7827VdylmXowdO3YYOcIiaNMmGDsWs2vXaACweDG4u8OSJZDFqJwCR3nJxMXFKYASFxeXaVliYqJy7tw5JTEx8YXFk5aWpty7d09JS0t7rv0MGDBAATI9KleurCiKomzevFlp3Lix4uDgoNja2ipNmjRR9uzZo9v+6NGjSq1atRRLS0sl/W0RHBysODo66tbx8/NTateunem4Xbt21Wtr2bKlMnbsWN3zxYsXK6VLl1asra2V9u3bK999950CKPfu3dOtM2LECKVEiRIKoPj5+SmKoigpKSnKjBkzFC8vL8Xc3FxxdXVVunfvrpw+fVq3XWBgoOLu7q5YW1srnTt3Vj799FO9mHPq32HDhimAsnbtWr32sLAwpWrVqoqlpaVSq1Yt5cCBAwqgbN68WVEURYmMjFQA5e+//9Zts3nzZqVChQqKlZWV0qlTJ2X58uVKxo9XaGio0qxZM8Xa2lpxcHBQGjVqpCxfvly3fU7nJyO1Wq3Url1bmTJliq7t/v37uj6Njo5WUlNTs90+Xfpryeqxbt06RVEen/elS5cqbm5uipWVldKjRw/l7t272fbvzp07lTp16ih2dnaKjY2NUqNGDSUgIEBRq9V6650+fVpp0aKFYmlpqbi6uir+/v6KRqN5atzZMcZn2JBSUlKULVu2KCkpKcYOpUiS/jUs6V/Dkv59Nmmax/9epaSmKG1/aKu8uv5VZfmp5Upc8uPvhtK/BvDTT4qiUikK6D9UKu3jp5+MElZOuUFGKkV5uQqmxMfH4+joSFxcHA4ODnrLkpKSiIyMxNvbW/dLu6FpNBri4+NxcHB47skhRGZFuX+joqLw8fHB3d2dyZMn07x5c6ysrIiOjmb16tX8+OOPHD58WDcM7ln5+/uzZcuWTMMPoeD1rzE+w4akVqvZsWMHHTp0yNO9iCJ3pH8NS/rXsKR/8yY2MZbV51Zz+Pph1ndar5tCPPxuOJ4OnlibWeutL/2bz9LSwMsLrl3LerlKpb3yFBn5woft5ZQbZGT8bzpCiGfi6enJ8ePHad68Ob6+vlhbW2NpaUmFChU4ceIEwcHBz500CSGEEIXZ1firzDo6i/Y/tifobBAX7l3g4NWDuuWVnSpnSpqEAfz6a/ZJE2ivPV29ql2vAJN7nIQoxOzs7PDz88PPz4+7d++SkJCAi4uL/DomhBDipRZ+N5zAM4HsurILjaKd6bdOyToMqTmEFu5ZTzolDOTRI1i6NHfrRkcbNpbnJImTEEWEk5OTrm5XfvL398/VBBNCCCFEQRBxP4Ke23rqnrco0wLfmr7UK1VPJh96kVJSYPlymDMHbt7M3TalSxs2puckiZMQQgghhCi0NIqGyLhIyhcrD0D5YuVp7NoYJ2snfGv4UtmpspEjfMmkpcG6dTBjhvaepdxIv8cpmxI0BYUkTkIIIYQQotB5sgbTtQfX2N1zN8WtigPw7evfYmYiX3NfKEWB7dth2jQ4e1Z/Wc+e2qRo3LjH66ZLvwoYEFDg6znJO0oIIYQQQhQaiamJbLm4hVX/rNKrwXT+znmalWkGIEnTi3boEEyZAkeP6re//jrMmwcNGmifu7vD2LH6E0W4u2uTpkJQx0neVUIIIYQQosB7mPKQtf+uZc35NdxNuguAk5UT/ar2o0+VPjhY5DyVtDCAkye1V5h27tRvb9QI5s+H117Tb+/RA7p2JXX/fk7u3EmdN97ArHXrAn+lKZ0kTkIIIYQQosBLSE3g21PfotaocbN1Y2CNgXSv0B0rs8Jft6/Q+e8/7T1M69frt1etCnPnQrduj4fgZWRqitKyJdcfPaJ2y5aFJmkCSZyEEEIIIUQBdDX+KoeuH6Jv1b4AlLIpxcjaIyltV5r2Xu11RWzFC3TjBsyaBStXaieBSOfpCTNnwrvvFqpEKK+kAK7IVkhICMWKFTN2GHnyImK+fPkyKpWKkydPGvQ4QgghxMso/G44kw5OotOWTnxy/BP+vfuvbtnQWkPpVK6TJE0v2t27MHkylC8Py5Y9TpqcnbX3J124AAMHFumkCSRxKjIGDhyISqXK9PDx8cnV9l5eXgQEBOi19enThwsXLhggWn0vKkG7efMm5ubmfP/991kuHz58OLVq1TJ4HPlt7969vP3223h7e+Ps7EytWrWYPHky169ff+q26UlgVo9jx449V1xjx46lfv36WFpaUqdOnSzX2bhxI3Xq1MHGxoayZcuyaNGiTOt8/fXXVK1aFWtraypXrsx33333XHEJIYQoeBRF4cTNE4zcM5Ke23qy8/JONIqGFmVaYKKSr6tG8+iRdnKHcuVg4UJIStK229trrzBduqSd7MHS0rhxviAyVK8I8fHxITg4WK/N8jneyNbW1lhbWz9vWAWGi4sLHTt2JDg4mH79+uktS0xMZP369cyaNctI0eVdYmIigwcP5sCBA4wcOZIhQ4bg6urKtWvX2LRpE7Vq1SI4OJguXbo8dV979uyhevXqem0lSpR4rvgURWHw4MH8/vvvnD59OtPynTt30rdvX7788kvatWvH+fPnGTJkCNbW1owZMwaAb775hqlTp7JixQoaNmzI8ePHGTp0KMWLF6dz587PFZ8QQoiC4cbDG0w+NJmTt08CYKIyob1Xe6nBZEwpKbBiBcyerV+81tISRo2CqVOhZEnjxWckksLnUoI6IdtHclpyrtdNSk3KtG5iamKm9Z6FpaUlrq6ueo/ixYvrlvv7++Pp6YmlpSVubm68//77ALRq1YorV64wfvx43dUGyHwlyN/fnzp16hAUFISnpyd2dnaMHDmStLQ0Fi5ciKurK6VKlWLu3Ll6cS1evJiaNWtia2uLh4cHo0aN4uHDhwAcOHCAQYMGERcXpzu2v78/ACkpKUyaNIkyZcpga2tL48aNOXDggN6+Q0JC8PT0xMbGhu7du3Pnzp0c+8jX15f9+/dz+fJlvfYff/yRpKQk+vXrR2hoKK+88grFihWjRIkSdOrUiYiIiGz3mdUVsy1btmSqTr5t2zbq16+PlZUV5cqVY+bMmaSmpur1b1bnJzuDBg0iPj6eCxcuMGPGDNq0aUP16tVp3749y5YtIzQ0lOHDh3Pq1Kkc9wPaJCnje8fc3FwXV506dVi2bBkeHh7Y2NjQq1cv7t+/n+M+v/jiC0aPHk25cuWyXL569Wq6devGiBEjKFeuHB07dmTy5MksWLAA5f/1HVavXs3w4cPp06cP5cqV46233sLX15cFCxY89TUJIYQoHJytnbn+8DoWJhb0rtSb7d22s/DVhZI0GUNaGnz/PVSpAmPGPE6aTExg8GDtkLzFi1/KpAnkilOuNV7bONtlLcq0YGnbpbrnrTa2IjE1Mct1G7g0INjn8VWhDps7cC/5Xqb1zgw48xzRZvbjjz/y+eefs379eqpXr05MTIzuC/WmTZuoXbs2w4YNY+jQoTnuJyIigp07dxIaGkpERAQ9e/YkMjKSSpUqcfDgQY4cOcLgwYNp06YNTZo0AcDExIQvvvgCLy8vIiMjGTVqFJMmTWLp0qU0a9aMgIAAZsyYQXh4OAB2dnaANjG4fPky69evx83Njc2bN+Pj48OZM2eoWLEiv//+O4MHD2bevHn06NGD0NBQ/Pz8coy/Q4cOuLq6EhISokvQAIKCgujWrRslSpTg0aNHTJgwgZo1a/Lo0SNmzJhB9+7dOXnyJCYmz/Zbw65du+jXrx9ffPEFLVq0ICIigmHDhgHg5+eX4/nJSlhYGH/++SenTp3CxsaGuXPnEhgYCMCHH35IQEAAYWFhzJkzh8mTJxMaGvpMcae7ePEiGzduZNu2bcTHx+Pr68vo0aNZvXr1M+8zOTkZGxsbvTZra2uuXbvGlStX8PLyIjk5GSsrq0zrHD9+HLVarUvuhBBCFA7pNZj2Re3j27bfYmpiioWpBQtfXUhZh7KUtHk5v5AbnaLAL79opxY/k+E76Jtvaq88Va1qnNgKEEmcipDt27frko50kydPZvr06URFReHq6krbtm0xNzfH09OTRo0aAeDk5ISpqSn29va4urrmeAyNRkNQUBD29vZUq1aN1q1bEx4ezo4dOzAxMaFy5cosWLCAAwcO6BKncelVogFvb29mz57NyJEjWbp0KRYWFjg6OqJSqfSOHRERwbp167h27Rpubm4AfPDBB4SGhhIcHMy8efNYsmQJ7du3Z8qUKQBUqlSJI0eO5JgkmJqa0r9/f0JCQvDz80OlUhEZGcnBgwd127355pt62wQGBlKqVCnOnTtHjRo1cuyf7MydO5cpU6YwYMAAAMqVK8fs2bOZNGkSfn5+OZ6frKxatYpx48Zha2vLmjVrWLJkCcuXL8fd3Z3p06cTERGBRqOhX79+jBo1ikePHmFra5vt/po1a5YpKYyLi8P0/zd5JiUlsWrVKtzd3QH48ssv6dixI4sWLcqU/ORW+/btGT9+PAMHDqR169ZcvHhRd59ddHQ0Xl5etG/fnpUrV9KtWzfq1avHiRMnCAoKQq1WExsbS+nSpZ/p2EIIIV6s+JR41v+7Xq8G096ovbTzagdAA9cGxgzv5XbokHbo3ZEj+u1t22rvb2rY0DhxFUBGT5yWLl3KokWLiI6Opnr16gQEBNCiRYts11+zZg0LFy7kv//+w9HRER8fHz799NPnvh/jaX5/5/dsl5ma6M8gcqD3gWzXzXiD447uO3jw4AH29vbPfDUjXevWrfnmm2/02pycnADo1asXAQEBlCtXDh8fHzp06EDnzp0xM8vbW8DLywt7e3vdcxcXF0xNTfVid3Fx4datW7rn+/fvZ968eZw7d474+HhSU1NJSkrK8cv8X3/9haIoVKpUSa89OTlZd67Pnz9P9+7d9ZY3bdr0qVdX0od67du3jzZt2hAUFIS7uztt27YFtEnb9OnTOXbsGLGxsWg0GgCioqKeOXE6ceIEf/zxh94wxrS0NJKSkkhISMjz+Tl9+jQTJkwAYOvWrYwdO5Zu3boBsGLFCjw8PADt8E1HR0fi4+NzTJw2bNhA1Qy/JJk+MTOOp6enLmkCbT9rNBrCw8OpW7du3jrj/4YOHUpERASdOnVCrVbj4ODA2LFj8ff31x17+vTpxMTE0KRJExRFwcXFhYEDB7Jw4UK9+IQQQhRMtxNus/rcajZe2Mgj9SMAytiVYWD1gbzq/qqRo3vJZVe8tmFDbfHaNm2MElZBZtTEacOGDYwbN46lS5fSvHlzli1bxhtvvMG5c+fw9PTMtP7hw4fp378/n3/+OZ07d+b69euMGDGCIUOGsHnzZoPGamOe+1/V87puqlkqNuY2z5042draUqFChSyXeXh4EB4eTlhYGHv27GHUqFEsWrSIgwcP5mm4U8Z1VSpVlm3pycaVK1fo0KEDI0aMYPbs2Tg5OXH48GF8fX1Rq9XZHkej0WBqasqJEycyfUFOv6qWfh9MXlWsWJEWLVoQHBxM69atWbVqFYMGDdL1f+fOnfHw8GDFihW4ubmh0WioUaMGKSkpWe7PxMQkUywZX5tGo2HmzJn06NEj0/ZWVlZ5Pj+pqam6IWwpKSl6SdGTVx1v3LhBSkoKJZ8yFtnDwyPb905W0u/fyngfV16oVCoWLFjAvHnziImJoWTJkuzduxfQJuigHZYXFBTEsmXLuHnzJqVLl2b58uXY29vj7Oz8zMcWQghheFHxUXTb2g21RvtvYoViFfCt6YuPlw9mJkb/7f7ldfEiTJ/+bMVrX3JGfdcuXrwYX19fhgwZAkBAQAC7du3im2++Yf78+ZnWP3bsGF5eXrqb5r29vRk+fDgLFy58oXEXVtbW1nTp0oUuXbowevRoqlSpwpkzZ6hXrx4WFhakPVnILJ/8+eefpKam8tlnn+kSk40bN+qtk9Wx69atS1paGrdu3cr2CmS1atUyTZmd2ym0fX19GTlyJF27duXatWsMGjQIgDt37nD+/HmWLVumO+7hw4dz3FfJkiV58OCB3hW0jDWe6tWrR3h4eI7JSU7nJ6MKFSpw+vRpqlWrxquvvsqKFSvo0aMHrq6uzJ49G9BOv+7n58eYMWPyfGUxo6ioKG7cuKEbNnn06FFMTEwyXRF8FqamppQpUwaAdevW0bRpU0qVKqW3jrm5ue6K1/r16+nUqdNz/9AghBAi/8UmxuJsrf1hy8Peg2olqqFCxZCaQ2jhLlOLG1V68drAQHhicio8PB4Xr33O7wtFndF6JyUlhRMnTujuT0nXrl07jmQcY/l/zZo146OPPmLHjh288cYb3Lp1ix9//JGOHTtme5zk5GSSkx/PehcfHw9orwhkvCqgVqtRFAWNRqO7YmJo6Vcq0o/7PPtJSkrixo0beu1mZmY4OzsTEhJCWloajRs3xsbGhu+++w5ra2s8PDzQaDSULVuWgwcP0rt3bywtLXF2dtbFk/7f9FifjFNRlCxjT2/z9vYmNTWVL774gk6dOvHbb7/x7bff6vaj0Wjw9PTk4cOHhIWFUbt2bWxsbKhQoQLvvPMO/fv3Z9GiRdStW5fY2Fj2799PjRo16NChA2PGjOGVV15hwYIFdO3albCwMN0wvYwxZ4zxzTff5P3332f48OG89tpreHp6otFocHR0pESJEixbtgwXFxeioqKYNm2aXrxP9otGo6Fhw4bY2NgwdepUxowZw/HjxwkJCdGL4+OPP6ZLly64u7vTs2dPTExMOH36NGfPnmX27NlPPT8Zde3ala+++orevXszcuRIjhw5gpeXF2ZmZgwePBg3Nzd8fHwYPXo0fn5+2b630ttv376d6b1TrFgxrKysUBQFKysr3bmIj4/n/fffp1evXri4uPDgwYMs3wMXL17k4cOHREdHk5iYyF9//QVoE14LCwtiY2P58ccfadWqFUlJSYSEhPDDDz+wf/9+3b4uXLjA8ePHady4Mffu3ePzzz/n7NmzBAcHZ/maNBoNiqKgVquLxFC+9L9ROV2dFc9O+tewpH8NqyD1r6Io/HXrL4LPBXPy9kl+6foLjpaOAHzR8gvsLbRD/NNS00gj/3+kNYSC1L/P7d49TBYtwuTrr1ElPp68THF2RjNlCpphw8DKSjtBxAt6vQWpf/MSg9ESp9jYWNLS0nBxcdFrd3FxISYmJsttmjVrxpo1a+jTpw9JSUmkpqbSpUsXvvzyy2yPM3/+fGbOnJmpfffu3ZluajczM8PV1ZWHDx9mOyzLUB48ePBc26vVanbt2qX75T5dxYoVOX78OJaWlgQEBDBx4kQ0Gg3VqlVj3bp1mJubEx8fz6RJkxg/fjwVK1YkOTmZe/fukZSUhKIoumQzOTmZtLQ03fP046ampuq1paamkpKSQnx8POXKlWPu3LksWLCAadOm0axZMz7++GNGjhzJgwcPMDExoUaNGgwaNIi33nqLu3fvMnnyZKZMmUJAQACffvopEydOJDo6GicnJxo2bEiLFi2Ij4+nWrVqfPHFF7pz3LJlSyZOnKj7cv+0/u3evTurVq3irbfe0lt/5cqVTJkyhVq1alGhQgUWLFhAp06dSExMJD4+XjeV+qNHj4iPj8fMzIxly5YxY8YMVqxYQcuWLZk0aRLjxo3T7bdp06asX7+ehQsXsmjRIszMzKhUqRLvvvsu8fHxTz0/GXXt2lW3vp+fHytXruSzzz4DwNHRkfHjx+Ps7IypqSmPHj3K9n2T/lratWuXadnKlSt58803SU5OxtvbmzfeeIOOHTty7949Xn/9dT755BNdv2bVv4MHD+a3337TPa9fvz4Ap06dwtPTkwcPHhASEsKkSZNQFIWGDRuybds2qlSponvNcXFxfPrpp1y8eBEzMzNatGhBaGgoTk5OWfZLSkoKiYmJHDp0SG+q98IuLCzM2CEUadK/hiX9a1jG7F+NoiE8NZxDSYe4mnYVABUqlu9cTnWL6k/ZunAozO9f06Qkym3fTsVNmzBNeFzqJtXKiovduhHRtSup1tawb5/RYiwI/ZuQkPsyQCrlWW8UeU43btygTJkyHDlyhKZNm+ra586dy+rVq/n3338zbXPu3Dnatm3L+PHjad++PdHR0Xz44Yc0bNhQNxVzRlldcfLw8CA2NhYHBwe9dZOSkrh69SpeXl6ZpkA2FEVRdJNDPM/9IiJrRbl/o6Ki6NChA2XKlGHSpEk0b94cKysroqOj+f777/npp584dOgQFhYWz3WcmTNnsnXrVt0VoycVtP5NSkri8uXLeHh4vLDPsCGp1WrCwsJ4/fXXZep1A5D+NSzpX8MyZv+qNWp2XdnFqnOriIjT1jm0MLGgS7kuvFv1XTzsPV5oPIZQqN+/KSmYBAVhMncuqieK1yoWFmhGjkQzaZLR6zAVpP6Nj4/H2dmZuLi4TLlBRka74pT+a3jGq0u3bt3KdBUq3fz582nevDkffvghALVq1cLW1pYWLVowZ86cLKcmtrS0xNLSMlO7ubl5phOVlpaGSqXCxMTkhd0/kT7cKP24In8V5f718vLi+PHjfPbZZwwdOpQrV65gYWGBmZkZnTp1Ijg4OF+Sh/SEKKv+K2j9a2JiopuwxNh/iPNTUXs9BY30r2FJ/xqWMfo39mEss47NIlVJxdbclj6V+/ButXd19zYVJYXq/avRwLp1MGMGXLr0uN3EBAYOROXnh6mnJwVpIHtB6N+8HN9oiZOFhQX169cnLCxMb0rpsLAwunbtmuU2CQkJmW5yT7+PwUgXzoQwKjs7O/z8/PDz8+Pu3bskJCTg4uJi9D9CQgghio74lHiOXD+Cj7cPAKXtStO3al+KWRWjd+XeOFjk/Cu9MDApXvvCGHXqjAkTJvDuu+/SoEEDmjZtyvLly4mKimLEiBEATJ06levXr/Pdd98B2mmihw4dyjfffKMbqjdu3DgaNWqkm+1LiJeVk5OTrm5XfvL398ff3z/f9yuEEKJgy1iDqXyx8lQsXhGADxp+YOToBAC//qotXvvEPcWAFK81EKMmTn369OHOnTvMmjWL6OhoatSowY4dOyhbtiwA0dHRREVF6dYfOHAgDx484KuvvmLixIkUK1aM1157jQULFhjrJQghhBBCFClR8VEE/xPM1otbdTWYKhavyEP1QyNHJnROnoSPPoIdO/TbGzTQFq9t29YoYRV1Rp+sfdSoUYwaNSrLZelTOj/pvffe47333jNoTDLsT4jCST67Qgjx7GITY1lwfAG7r+xGo2jvYa1bqq62BlOZFgViEqCX3sWL2nuY1q3Tb69SRVu8tnt3KV5rQEZPnAqS9PtCEhISsLa2NnI0Qoi8Si8jUBRqOAkhxItmZ27H8ZjjaBQNr7q/im8NX+q5ZC7CLozgxg3tvUorV0rxWiOSHn6CqakpxYoV49atWwDY2NgY/NcVjUZDSkoKSUlJBWJWsqJG+tewClL/ajQabt++jY2NTaZJZIQQQujTKBoOXj3I7iu7mfvKXExUJliZWeHf1B83OzcqO1U2dogC4N49WLAAvvgCnihei7OzdqjeiBHa4rXihZBvFxm4uroC6JInQ1MUhcTERKytreUSuAFI/xpWQetfExMTPD09C0QsQghREKk1akIjQwk6G8TF+xcBaFu2LW082wDQ2rO1McMT6R490iZLCxfC/fuP2+3s4IMPYPx4eErNIZH/JHHKQKVSUbp0aUqVKoVarTb48dRqNYcOHeLVV1+VKaQNQPrXsApa/1pYWBj9ypcQQhREiamJbP5vM6v+WcWNRzcAdDWYapesbeTohE5KinY43uzZ8GStUwsLGDVKO+W4kYvXvswkccqGqanpC7lPwtTUlNTUVKysrArEF8+iRvrXsKR/hRCi4It+GM1bv7zF3aS7ADhZOfFutXelBlNBotHA+vUwfXrm4rUDBoCfH/x/1mlhPJI4CSGEEEIUMclpyViaWgLgautKadvSWJtZM7D6QLpV6IaVmdwXUyAoinZK8WnT4PRp/WU9esCcOVK8tgCRxEkIIYQQoohIr8G0L2of27tvx97CHpVKRUDrAJytnTEzka9+BcbhwzBlSubitW3aaIvXNmpknLhEtuTTI4QQQghRyJ2/c56gs0F6NZj2Re2ja4WugPaqkyggTp3SXmGS4rWFjiROQgghhBCFkKIonLh5gpB/Q/jt+uOrFlKDqYCKiNAWr127Vr+9ShXtkLwePaR4bQEniZMQQgghRCEUr8Tjt88PjaLBRGWCj5cPg2sMlhpMBU10tHaWvBUrMhev9feH/v2leG0hIWdJCCGEEKIQUGvU/H3zbxqV1t774mjiSGfvzliZWzGg+gA87D2MHKHQc++etg7TkiX6xWtLlNAWrx05UorXFjKSOAkhhBBCFGBP1mCKfhTN1m5bcbdxB2BG4xlYWFgYOUKhJyFBW7x2wYLMxWsnToQJE6R4bSEliZMQQgghRAEUlxzH+n/Xs+b8Gu4l3wO0NZiuPriqS5xUck9MwaFWPy5eGx39uF2K1xYZkjgJIYQQQhQg8SnxrDi9go3hG0lITQCgjF0ZBlUfRNcKXbEys0KtVhs5SqGTXrx2xgztBBDppHhtkSOJkxBCCCFEAWKmMmPzxc0kpCZQsXhFfGv40t6rvdRgKmjSi9d+9JF2ivEnde+unSmvWjXjxCYMQj6BQgghhBBGdP7OeX659AsTG0xEpVJhY27DpIaTKGZZjBZlWshwvILo8GGYOlX73ye99pq2eG3jxsaJSxiUJE5CCCGEEC+Yoij8efNPAs8E8tsNbQ2mRqUb8ar7qwB0Kd/FmOGJ7Jw+rb1X6Zdf9Nvr14dPPpHitUWcJE5CCCGEEC+IRtFw8OpBVp5dyenbpwF0NZjc7d2NHJ3IVnrx2nXrtEP00lWuDHPnSvHal4QkTkIIIYQQL0BsYixDdw/l4v2LAFiYWNC9YnepwVSQRUdrryRlLF7r7q4tXjtggBSvfYnImRZCCCGEMBBFUXT3KJWwKoGpyhQ7czv6VO5Dv2r9cLZ2NnKEIkv37lF19WrM3n47c/HaadO004tL8dqXjiROQgghhBD5LL0G0/ZL29nQaQM25jaoVCoWvLqAUjalsLewN3aIIisJCfDll5h98gmVMhavnTBBW8BWite+tCRxEkIIIYTIJ7cSbrH63Gq9GkzbIrbRp0ofAMoXK2/M8ER21GoIDIRZsyA6mvS7lRQLC1QjR2qvMpUqZdQQhfFJ4iSEEEII8ZyuxF8h+GwwP0f8jFqjLU5bqXglfGv40s6rnZGjE9nSaGDDBpg+Xa94rWJiwtVWrSi9bBnmFSoYMUBRkEjiJIQQQgjxHGITY+m2pRupinbygHql6uFb01dqMBVkigI7d2qvJGVRvDbVz4+/L1+mdNmyxolPFEiSOAkhhBBC5IGiKFyKu6Qbduds7cxrnq+RlJaEbw1f6rnUM3KEIke//aYtXvvrr/rtrVvD/Pna4rVqNVy+bJTwRMEliZMQQgghRC5oFA0Hrh4g8EwgZ++cZXu37Xg4aKcR/+TVTzA3MTdugCJnp0/DRx/B9u367fXraxOmtm2lFpPIkSROQgghhBA5UGvU7IzcSdCZICLitPfBWJhYcCb2jC5xkqSpALt0SVu8du1a/eK1lSppi9e++aYkTCJXJHESQgghhMhCUmoSP/33E6v+WUX0o2gA7MzteKvKW/St2ldqMBV00dEwZw4sXy7Fa0W+kHeLEEIIIUQWUjWpfP331zxQP6CEVQnerfYuvSv3lhpMBd39+7BwISxZoq3LlE6K14rnJImTEEIIIQTaGkw7I3fSv1p/VCoVdhZ2jK47GnMTc7qU74KVmXzZLtD+X7yWBQvg3r3H7ba22sK1UrxWPCdJnIQQQgjxUstYg6li8Yo0c2sGQN+qfY0cnXgqtRqCgmDmTO3wvHQWFiDFa0U+ksRJCCGEEC+l83fOE3g2kLArYWgUDaCtwWRjZmPkyESupBevnTEDLl583G5iAu++q72PycvLWNGJIkgSJyGEEEK8VO4n3WfKr1P47cZvuraW7i3xrelL3VJ1jRiZyBVFgdBQbS2mjMVru3XTTghRvbpRQhNFmyROQgghhHipOFg6EPMoBlOVKT7ePgyuMZhKxSsZOyyRG9kVr23VSluLqUkTo4QlXg6SOAkhhBCiyFJr1Oy4tIMtF7ewtO1SrM2sMVGZMLP5TEpYlcDd3t3YIYrcyKl47bx58PrrUotJGJwkTkIIIYQochJTE9n03yZC/gkh5lEMAFsvbuWtKm8BULtkbWOGJ3Lr0iXw84M1a6R4rTA6SZyEEEIIUWTEJcex7t91rD2/lnvJ2imp02swdSzX0cjRiVyLiXlcvFatftxepox20oeBA6V4rXjh5B0nhBBCiCLhftJ9fDb58Ej9CIAydmUYXGOw1GAqTO7fh0WLICBAv3itk9Pj4rXW1saKTrzkJHESQgghRKF1N+kuTlZOABSzKkYj10Zcf3gd3xq+tPNqh5mJfNUpFBIS4Kuv4JNPMhevnTBBW7zW0dF48QmBJE5CCCGEKITO3TlH4JlA9l/dz/bu23GzcwNgzitzsDe3RyX3vRQO6cVrZ82CGzcet5ubPy5e6+JivPiEeIIkTkIIIYQoFBRF4Y+YPwg8G8iRG0d07YevH6Z35d4AOFg4GCs8kRcaDWzcCNOn6xevVamgf38pXisKJEmchBBCCFGgaRQN+6/uJ+hMEKdjTwNIDabCKr147bRpcPKk/jIpXisKOEmchBBCCFGgPVQ/5KPDH/FI/QhLU0u6V+jOgOoDpAZTYXPkiLZ47aFD+u1SvFYUEpI4CSGEEKJASUxNZF/UPjp4d0ClUuFg4cCg6oNISkuib9W+OFs7GztEkRdnzmiL127bpt9er542YZLitaKQkMRJCCGEEAVCxhpMpWxK0dC1IQDDaw83cnQiz3IqXjtnjrZ4rYmJ8eITIo+M/m5dunQp3t7eWFlZUb9+fX799dds1x04cCAqlSrTo7qMhRVCCCEKrZuPbvLpH5/S7sd2fH3ya+4l38Pdzp3E1ERjhyaexc2b8N57UKUKfP/946SpTBlYsQL++Qd69ZKkSRQ6Rr3itGHDBsaNG8fSpUtp3rw5y5Yt44033uDcuXN4enpmWn/JkiV88sknuuepqanUrl2bXr16vciwhRBCCJEPHqY8ZNGfi/g54mdSNakAVC5eGd+avrxe9nWpwVTY3L8Pn34Kn3+euXjt1KkwerQUrxWFmlH/Ii1evBhfX1+GDBkCQEBAALt27eKbb75h/vz5mdZ3dHTE8YniZ1u2bOHevXsMGjTohcUshBBCiPxhbWbNiZsnSNWkUq9UPYbUHMIrZV6RGkyFTWKitnjt/PmZi9eOHw8ffCDFa0WRYLTEKSUlhRMnTjBlyhS99nbt2nHkyJFsttIXGBhI27ZtKVu2bLbrJCcnk5ycrHseHx8PgFqtRq1WP0Pk+Ss9hoIQS1Ek/WtY0r+GJf1rWNK/hpWxfxVF4c9bf7Lp4ib8m/hjaWoJwKT6k7A2s6ZOyTqAdjSJeLoC8f5Vq1GtWoXpnDmoniheq5iboxk2DM2UKY+L1xayz1mB6N8irCD1b15iUCnKk3frvTg3btygTJky/PbbbzRr1kzXPm/ePFatWkV4eHiO20dHR+Ph4cHatWvp3bt3tuv5+/szc+bMTO1r167Fxsbm2V+AEEIIIZ5Ko2j4V/0vh5IPcS3tGgBdrbvS0LKhkSMTz0yjwe3IEaquWYNddLSuWVGpuNqqFf++9RaJ6QmTEAVcQkIC77zzDnFxcTg45FxA2+iDhzNejlcUJVeX6ENCQihWrBjdunXLcb2pU6cyYcIE3fP4+Hg8PDxo167dUzvnRVCr1YSFhfH6669jbm5u7HCKHOlfw5L+NSzpX8OS/jWshOQEFu9YzF9mf3E54TIAlqaWdC3Xlf5V++Nm52bcAAs5o7x/FQXV7t2Y+vujylC8VtO5M2kzZ1K6Rg1Kv5hoDEr+PhhWQerf9NFouWG0xMnZ2RlTU1NiYmL02m/duoXLU36lUBSFoKAg3n33XSwsLHJc19LSEktLy0zt5ubmRj9RTypo8RQ10r+GJf1rWNK/hiX9m/8epDyg586exCRq/423N7fnrSpv8U7Vd6QGUz57Ye/fo0e1EzwcPKjf3rIlzJ+PSdOmxp+q2QDk74NhFYT+zcvxjfYet7CwoH79+oSFhem1h4WF6Q3dy8rBgwe5ePEivr6+hgxRCCGEELmUkpai+397C3sqFKuAncqO9+u8z66eu3i/3vuSNBVGZ89C167QrJl+0lS3LoSGwv790LSp8eIT4gUy6lC9CRMm8O6779KgQQOaNm3K8uXLiYqKYsSIEYB2mN3169f57rvv9LYLDAykcePG1KhRwxhhCyGEEOL/bj66yepzq9kSsYWfOv+Ei6121MjHjT7m6P6jdK3W1ei/KItnEBmpLV77ZB0mgIoVtcVre/aUOkzipWPUxKlPnz7cuXOHWbNmER0dTY0aNdixY4dulrzo6GiioqL0tomLi+Onn35iyZIlxghZCCGEEMDluMuE/BPCzxE/o9ZoZ6Xafmk7vjW1o0FK2ZTCXCUJU6Fz86Y2MVq2TH8mPDc38PeHgQNBEmHxkjL65BCjRo1i1KhRWS4LCQnJ1Obo6EjCk0XVhBBCCPHC/HPnHwLPBLLnyh4UtFci6rvUx7eGL6+UecXI0YlnFhcHixZBQAA8evS4XYrXCqFj9MRJCCGEEIXDw5SHDAodRGJqIgCt3FvhW9OXOqXqGDcw8ezSi9d+8gncvfu43cYGJkyQ4rVCPEESJyGEEEJkSaNo+DPmTxqVbgSAnYUdfSr3ITYxlsE1BlOxeEUjRyieWWoqBAfDzJlw/frjdnNzGDECPvrocfFaIQQgiZMQQgghMlCnqfkl8heCzgYRGRfJd298R91SdQGYUH9CruotigJKo4Eff4SPP4b//nvcrlJBv37aRMrb23jxCVGASeIkhBBCCAAS1Als+m8Tq86tIubR4xpM1x9e1yVOkjQVUooCu3dr71f6+2/9ZV26wNy5ILMVC5EjSZyEEEKIl1xSahLB/wSz9vxa7iffB8DZ2pl3q71L70q9sbOwM26A4vk8pXit1GESInckcRJCCCFecmYmZmy9uJX7yfdxt3NnUI1BdK3QFUtTS2OHJp7H2bPae5V+/lm/vW5dbcLUrp12iJ4QIlckcRJCCCFeMpfjLvPDhR8YV28c5qbmmJmYMbHBRFI1qbxe9nXMTOTrQaF2+bK2eO3q1ZmL186eDb16SfFaIZ6B/GUUQgghXhIZazBVKFaB7hW7A/B62deNHJ3ItbQ0VAcPUubQIVS2ttC6NZiaaovXzp0L334rxWuFMABJnIQQQogiTFEU/oj5g5VnVnI0+qiuvZV7Kyo5VTJiZOKZbNoEY8didu0aDQAWL9YmRs2awc6d+sVrixfX3ts0ZowUrxUiH0jiJIQQQhRRCeoEhu4eyunY0wCYqkx5w/sNqcFUWG3aBD176g+/A7hxQzvFeDobGxg/Xlu8tlixFxqiEEWZJE5CCCFEEaIoim7KcBtzG2zMbbA0taR7he4MrDGQMnZljByheCZpaTB2bOakKaNRo2D6dHB1fTFxCfESkcRJCCGEKALSazCtD19PiE8IztbOAHzU+CPsLewpYV3CyBGK5/Lrr3Dt2tPX69VLkiYhDEQSJyGEEKIQi0uOY+2/a/VqMG0M38ioOqMA8HL0Ml5wIn8oCoSG5m7d6GjDxiLES0wSJyGEEKIQinkUw+pzq/nhwg8kpiYC6NVgEkXEsWPaCR4OHMjd+qVLGzQcIV5mkjgJIYQQhUxiaiLdt3bnofohAJWLV8a3pq/UYCpK/vlHW7x269bcra9Sgbs7tGhh2LiEeInJX1chhBCiELgUd4lyjuUAsDazpmO5jly8fxHfGr68UuYV3YQQopDLrnhthQrQpQt8/rn2+ZPL0s99QIC2npMQwiAkcRJCCCEKKEVR+D3mdwLPBHIs+hhrO6ylZsmaAExuOBlzUylmWmTcuqUtXvvNN5mL1/r5waBB2uK1zZtrZ9d7cqIId3dt0tSjxwsPW4iXiSROQgghRAGjUTTsi9pH4JlAzt45C2hrMJ2OPa1LnCRpKiLi4uCzz7SFbHNTvLZHD+jaldT9+zm5cyd13ngDs9at5UqTEC+AJE5CCCFEAaHWqNkesZ2gs0Fcjr8MgKWpJT0q9mBA9QFSg6koSUyEpUth3jy4e/dxu40NjBsHH36YffFaU1OUli25/ugRtVu2lKRJiBdEEichhBCioFBg6amlxDyKwd7cnreqvEXfqn2lBlNRkpoKISHg7w/Xrz9uNzeHYcPg44+lDpMQBZQkTkIIIYSRxCXHsfm/zfSt1hdzE3PMTc0ZXWc095Lu0atSL+ws7IwdosgvGg389JM2Mbpw4XG7SgV9+8LMmVCunPHiE0I8lSROQgghxAuWsQaTs40zncp1AqBbhW7GDU7kL0WBsDCYNg1OnNBf1rmzdkKImjWNE5sQIk8kcRJCCCFekMi4SILPBrPt0jZSNakAVHGqQnHL4kaOTBjE779rJ3jYv1+/vUUL+OQTaNbMOHEJIZ6JJE5CCCGEgSWlJjHt8DT2XNmDgrb+TgOXBgypOYRmbs2kBlNR888/2iF5W7bot9epo50Mwsfnce0lIUShIYmTEEIIYWBWZlbcTbqLgkIrj1b41vClTqk6xg5L5LfLl7WTPqxerb2nKV2FCjB7NvTuDSYmxopOCPGcJHESQggh8lF6Dabvz3/P560+p7iVdhjelEZTMFOZUaF4BSNHKPJddsVrS5fWFq8dPFg7a54QolCTxEkIIYTIB+o0Ndsv6ddgWvvvWkbXGQ1o72USRUxOxWunTNEWr7WxMV58Qoh8JYmTEEII8RwS1An89N9PrPpnFTcTbgLoajC9VfktI0cnDCIpCb7+GubPhzt3HrfnpnitEKLQksRJCCGEeEbJacl03tyZW4m3AHC2dqZ/tf5Sg6moSk2FVau09zFdu/a43cwMhg+X4rVCFHGSOAkhhBB5cD/pPsWsigFgaWpJC/cWHI85zqAag+hSvguWppbGDVDkP0V5XLw2PPxxuxSvFeKlIomTEEIIkQvpNZi2X9rOmg5rqFqiKgAfNPgAazNrTE1MjRyhyHeKAnv2aGsxZSxe26mTdkKIWrWME5sQ4oV75sQpJSWFyMhIypcvj5mZ5F9CCCGKpn9i/yHwbKBeDaYDVw/oEicZkldE5VS8dv58aN7cOHEJIYwmzxlPQkIC7733HqtWrQLgwoULlCtXjvfffx83NzemTJmS70EKIYQQL5KiKPwe8zuBZwI5Fn1M1y41mF4C587BRx9lLl5bu7Y2YZLitUK8tPJchW3q1KmcOnWKAwcOYGVlpWtv27YtGzZsyNfghBBCCGNQa9RM+3Uax6KPYaoypUv5LmzuspkvX/tSkqai6soVGDQIatbUT5rKl4e1a+Gvv+CNNyRpEuIllucrTlu2bGHDhg00adIE1RN/PKpVq0ZERES+BieEEEK8COo0NWFXwmjv1R5TE1MsTC0YUnMIV+KvMKD6ANzs3IwdojCUW7dg3jxt8dqUlMftpUvDjBng6yvFa4UQwDMkTrdv36ZUqVKZ2h89eqSXSAkhhBAFXYqSwpp/1/D9v99zM+EmJiYm+Hj5APBO1XeMHJ0wqPj4x8VrHz583F6smLZ47XvvSfFaIYSePCdODRs25JdffuG9994D0CVLK1asoGnTpvkbnRBCCGEA95Pu8/257/ku/jsS/0oEtDWYUjWpRo5MGFxSEixdqr3K9GTxWmvrx8Vrixc3WnhCiIIrz4nT/Pnz8fHx4dy5c6SmprJkyRL++ecfjh49ysGDBw0RoxBCCJEv1GlqPv/rc3688COJqdqEycPOg8E1B9O5fGepwVSU5VS8dtgwbY2m0qWNFp4QouDL8+QQzZo147fffiMhIYHy5cuze/duXFxcOHr0KPXr1zdEjEIIIUS+MDMx4/Tt0ySmJlK5eGX62PRhU6dN9KzUU5Kmoiq9eG2NGjBkyOOkKb147b//wtdfS9IkhHiqZyrAVLNmTd105EIIIURBdTb2LN+d+46PGn+Eo6UjKpWKCfUnkJiaSMOSDdm5c6cUri3K0ovX/vmnfrsUrxVCPIM8J06mpqZER0dnmiDizp07lCpVirS0tHwLTgghhMir9BpMK8+s5Pfo3wEo71ie4bWHA1DPpR4AarXaaDEKAzt+XJsw7dun3/7KK9paTK+8Ypy4hBCFWp4TJ0VRsmxPTk7GwsLiuQMSQgghnoVG0bAvah+BZwI5e+csAKYqUzqW60jbsm2NHJ14Ic6d096rtHmzfnutWtqESeowCSGeQ64Tpy+++ALQzqK3cuVK7OzsdMvS0tI4dOgQVapUyf8IhRBCiKdQa9T02d6H/+79B4CVqRU9KvaQGkwviytXtJM+fPcdaDSP28uXh9mzoU8fMMnzbd1CCKEn14nT559/DmivOH377beYmj4eE25hYYGXlxfffvtt/kcohBBCZCElLQULU+1IB3MTc6o6VSXmUQxvV3mbvlX74mTlZOQIhcHdvq2dVnzpUv3ita6u4OcnxWuFKGjS1HBxLyaXDqBSGhk7mjzLdeIUGRkJQOvWrdm0aRPFpcaBEEIII7ifdJ91/65j3b/rCGwfSMXiFQEYX388UxtNxc7C7il7EIVefLy2cO1nn0nxWiEKMo0GHsaAwxNX/n8agmnKA4pVcjZeXM8oz9et9+/fn69J09KlS/H29sbKyor69evz66+/5rh+cnIyH330EWXLlsXS0pLy5csTFBSUb/EIIYQomGIexbDwj4W0+6kdS08t5V7yPTZffHwvi7O1syRNRV1SEnz+OZQrBzNnPk6arK21CdOlSzB5siRNQhjTg5twch38NBQ+qwTBHR4vMzWH2m+RVncAqSaF73P6TNORX7t2jZ9//pmoqChSnrw0DixevDjX+9mwYQPjxo1j6dKlNG/enGXLlvHGG29w7tw5PD09s9ymd+/e3Lx5k8DAQCpUqMCtW7dITZVK70IIUVRdirtE8Nlgtl/aTqpG+/e+qlNVBtcczOuerxs5OvFCpKZq71/y94erVx+3m5nB0KEwfbrUYRLCmK4eh/PbIGIf3Dyrv0ydCA9vgd3/Z+Tu+CkatZoHO3a8+DifU54Tp71799KlSxe8vb0JDw+nRo0aXL58GUVRqFevXp72tXjxYnx9fRkyZAgAAQEB7Nq1i2+++Yb58+dnWj80NJSDBw9y6dIlnJy0Y9e9vLzy+hKEEEIUEmqNGt9dvsQmxgLQ0LUhvjV8aebWDJXMjlb0KQps2qSdKe/ffx+3q1Tw9tswa5Z2AgghxIujKBD7Hzh5a68gAZxaB38+MQKsdB2o0AbKvwbujcCsaMy8nefEaerUqUycOJFZs2Zhb2/PTz/9RKlSpejbty8+Pj653k9KSgonTpxgypQpeu3t2rXjyJEjWW7z888/06BBAxYuXMjq1auxtbWlS5cuzJ49G2tr6yy3SU5OJjk5Wfc8Pj4e0NbvKAg1PNJjKAixFEXSv4Yl/WtYL2P/KorCX7f+om6pupiotKPJ3670NmfunGFgtYHUctYWLM2PkQYvY/++SM/bv6q9ezGZPh2TDMVrNR06kDZzJtSunX6g54qzsJL3r2FJ/2aQeB/V5YOYXNqP6tJ+VPHXSe2/HcWjCQCqih0wSUlAU641ildLsH3i/iWFTJ/TgtS/eYlBpWRXmCkb9vb2nDx5kvLly1O8eHEOHz5M9erVOXXqFF27duXy5cu52s+NGzcoU6YMv/32G82aNdO1z5s3j1WrVhEeHp5pGx8fHw4cOEDbtm2ZMWMGsbGxjBo1itdeey3b+5z8/f2ZOXNmpva1a9diI2OghRCiQNAoGs6rz3Mo+RDX067zjs07VLOoBmiTKbm69PIo9t9/VFu9mpKnT+u136lalXPvvsvdatWMFJkQLxfrlFg87xyiVPwZiidcQsXjlCFNZc5pj/5ElWhpxAjzR0JCAu+88w5xcXE4ODjkuG6erzjZ2trqruC4ubkRERFB9erVAYiNjc1zsBn/MczpH0iNRoNKpWLNmjU4OjoC2uF+PXv25Ouvv87yqtPUqVOZMGGC7nl8fDweHh60a9fuqZ3zIqjVasLCwnj99dcxlylT8530r2FJ/xrWy9C/6jQ1v1z+he/Of8flhMuAtgZTmapl6FC5Q84bP++xX4L+NaY89+/585j6+WGyZYtes1KzJmlz5uDg40MTSaB15P1rWC9l/96PAiUNinsDoLp+ArOQx9+hFefK2itK5VqjeDalhrkNNZ7xUAWpf9NHo+VGnhOnJk2a8Ntvv1GtWjU6duzIxIkTOXPmDJs2baJJkya53o+zszOmpqbExMTotd+6dQsXF5cstyldujRlypTRJU0AVatWRVEUrl27RsWKFTNtY2lpiaWlZaZ2c3Nzo5+oJxW0eIoa6V/Dkv41rKLYv6maVNaeX8uqc6u4lXALAHsLe6PUYCqK/VuQPLV/o6K0kz6sWqVfvLZcOZg9G9Vbb2EmxWuzJe9fwyrS/Zv8EC4fhoi9cHEv3I2Auu9C16+0yz0bQu13oGwzKN8alaM7pjnvMc8KQv/m5fh5TpwWL17Mw/9P/+nv78/Dhw/ZsGEDFSpU0BXJzQ0LCwvq169PWFgY3bt317WHhYXRtWvXLLdp3rw5P/zwAw8fPsTOTjvl7IULFzAxMcHd3T2vL0UIIYSRmKpM+SXyF24l3KKkdUn6V+tPr8q9sDW3NXZo4kXJqXjtjBna4rUWReOGciEKDI0GfgvQzn4XdQw0T9zfozKFlCfqopmYQvdv8uWwsQ+TuRDzgAs3HxB+8yGu9hZ45cueX6w8J07lypXT/b+NjQ1Lly595oNPmDCBd999lwYNGtC0aVOWL19OVFQUI0aMALTD7K5fv853330HwDvvvMPs2bMZNGgQM2fOJDY2lg8//JDBgwdnOzmEEEII44t5FMPa82sZWmso9hb2qFQqxtYdy41HN+hSvgsWpvIF+aWRU/HayZO1xWttJYEWIl88uAm3zkH51trnJibaGfBiL2ifFyv7ePY771fByjH7feWBoijM3n6e89HxXLj5gDuP9MsXVXezZ1jZfDnUC/VMdZzSPXz4EM2Tl9UhT/cN9enThzt37jBr1iyio6OpUaMGO3bsoGxZbU9GR0cTFRWlW9/Ozo6wsDDee+89GjRoQIkSJejduzdz5sx5npchhBDCQDLWYHK0dMS3pi8Azco0e8rWokhJSoJvv4W5c+HJe6KtrWHsWJg0CYoXN158QhQF6iS4ekw79C69ppK5DUy+DGb/v3Wl2XuQmqxNlpzKaaf3z6PElDT+u/WACzcfaq8ixTzA2tyUb9+tD2jnMNgffovI2Ef/fw6eTjZUcrGnsos9lV1s0Vw5kV+v+oXJc+IUGRnJmDFjOHDgAElJSbr29Ekd0tLS8rS/UaNGMWrUqCyXhYSEZGqrUqUKYWFheTqGEEKIF+ts7FkCzwSyN2ovyv9nYmrk2ohaJWsZOTLxwqWmwvffg5+fFK8VwlDOb4MTq7T3LKUm6i9zrgQPoqG4l/Z5vf653m2aRsHU5HFiNW3zGX67GEvU3QQyzsttb2mmN8nbqFbaGmuVXe2pUMoOG4vHaYdarWbHldy/vIIiz4lT3759AQgKCsLFxUWmiBVCCKGTpklj9N7R/HbjN13bax6vMbjmYGqXrG3EyMQLpyiUPnoUs8mTIWOJkfTitRUqGCc2IQqzxHtw6QB4twSb/0+kc+ciXPz/hQU7V+3VpAptoFwr/ZpK2UjTKFy584gLN7VXkcJvPuBCzAMeJKVybFob3Xo37idy5U4CAE62FtqrR672VHSxo7KLPYry+AJWrwYe+fiiC4Y8J06nT5/mxIkTVK5c2RDxCCGEKGSe/IXR1MQUR0tHzFRmdCjXgcE1BlO+WHkjRyheuL17MZ0yhUYZitfSoYN2qF6dOkYJS4hCKS0Vrv+pHXp3cS/c+AsUDfRYAbV6a9ep0kk7uUOFNlCqWrbD7xRFISY+idKOj+cGmLrpDJv+ukZyqibLbWIfJuNspx3mN7p1BYa1KEclV3td28skz4lTw4YNuXr1qiROQgjxklOnqdl2aRsh/4SwpPUSvB21tT/G1hvL2HpjcbNzM3KE4oX74w+YOhX27kVvAvHmzWH+fGjRwliRCVH4xF6EPX4QeQiSM9QaKlkFeCI5cq6offyfoijcfpjMhZiH/7+K9IDwmw/47+ZDHiancsa/HfZW2mm4Lc1MSE7VYGVuQsVS9tr7kFztqPj/+5FK2D6evKeh14srFVEQ5TlxWrlyJSNGjOD69evUqFEj09zntWrJ+HUhhCjKEtQJ/HDhB747952uBtOa82v4uMnHAJIwvYz+/Rc+/hh++kmvOc7LC9uAAMy6dHmmG9CFeGkkP4TLv4K5tXZ4HYClHfy7Xfv/1sWhXGvtELzyr4FjGd2mcQlqLtx6QC13RyzNtJWWZm0/R/Bvl7M8lJmJiit3EqhRRjuDnu8r3gxs5oWHk43e/UwiszwnTrdv3yYiIoJBgwbp2lQq1TNPDiGEEKJwuJd0j7X/rmXt+bXEp2h//XyyBpN4CUVFwcyZEBKSqXhtqp8fB+zt6dChgyRNQmSk0UDMaW3x2Yj9j2sqlWv9OHGyd4WOn4FbXShdh4RURTuL3X8PuBBzTnsf0s0H3IxPBmD7e6/okiFPJxtUKvAqYUul/99/VPH/9yN5lbDFwuzxNWEPJ5sX/eoLrTwnToMHD6Zu3bqsW7dOJocQQoiXRJomjT7b+xD9KBoAT3tPBtcYTOfynaUG08vo9m3t0LulSyE5+XG7q6t2lrwhQ1BUKtixw3gxClFQ/fwe/LsDEmL124uVhVJVSU5NI+KWdqKGZlX6UcreCoDvjkbwyc5/s9xlmWLWxCU+Lmbbu4EHbzX0xNrC1GAv42WU58TpypUr/Pzzz1SQmXCEEKJIuxJ/BU97T1QqFaYmpnSv0J39V/fjW9OXtp5tMTWRf5BfOg8ePC5e++DB43ZHR23x2vfff1y8Vq3Oeh9CvCzUSRB1VHtlqfnYx+1x17VJk4UdyR6v8J99I/4wrcMf8cUI/+cBlw/tIk2jnet7ad96dKipna6/kosdznaWVHa109VDquiindHOwUr/1hlby+cq1Sqykedefe211zh16pQkTkIIUUSdjT3LyjMr2Re1j6/afMWr7q8CMKTmEEbUHiEjDV5G2RWvtbJ6XLzW6eW+aVwIFAVuh2tnv4vYC5d/09VUuuHRiXMP7bhw6wE+1UZRrsUEcG/EvvN3GLnmLyAJiNHtysHKjMqu9lg+MaSudeVS/Plx2xf8osST8pw4de7cmfHjx3PmzBlq1qyZaXKILl265FtwQgghXgxFUTgWfYzAM4H8HvO7rv307dO6xMnc1Dy7zUVRlZoKq1eDv7/2fqZ0ZmYwZIh2WJ6bTAYiBH+vgf1zIf66XvNdEycOptVk8TcHuaq4aBt9KjOqvvYCRJXSDtR2d/z/THbaGe0qudjj4mCZ6Ucq+dHK+PKcOI0YMQKAWbNmZVomk0MIIUTholE07I3aS+CZQP658w+A1GAS2l/Ot2yBjz6C8+f1l0nxWvEy+39NpcTzu7lQsh2nk10Jv/mANy0SqRt/HUwteej6v/buOzyqMn3j+HfSeyghBQiEhCSUBERQKSICgmJZV+woooCLXZe1gIqCuuKqq7jr2n6LYNdVsONqlA66KoL0EAidFHp6Mpk5vz9OMpMhQBLIZFLuz3VxLfOeM5M3r2chD+c9z302s3Z0Yqm9F1uMjoAFP28vurULNsNiI0MdH9clIpjP7zrXc9+P1EmdCye7/fjhWCIi0vRYsPDa76+x5fAWArwDuDLpSm7qcZNairdkCxeaWUw//+w6rvBaaakO76BwYxq7fvmSzkd/IcgoIhD41rqbV2x/BMC7T3f63DgPOg/C1+LH3g/XMCoqlHsrMpE6tw3G19vrpF9GGj89OSYi0oIUWYuYnzGf0YmjCfINwmKxcMcZd7Dp4CZu6H4DrQNae3qK4im//moWTN9/7zqu8FppAUqsNrbmFpCRm096dgGbs47SMT+XP7x6NhzKJBjoXnHuYSOE5fYUcoKTGd4+kqToUPrHt4Wu7QDwB169sa+nvhVxo1oVTv/4xz/405/+REBAAP/4xz9Oeu4999xTLxMTEZH6c2wGk92wc1PPmwAY3mk4wzsN9/AMxWNOEF5Laio8/TRccolymKTZqMwdBSgrt3PPB6vJyD5K8OENnGtZRz6BvGMbCUC30HZgyQEvH+h4NivpRWHsECISz2ZoTCsuU+e6FqdW/8VffPFFbrjhBgICAnjxxRdPeJ7FYlHhJCLSiGQVZPH2xreZlzGP4oruTp3DOhMZHOnhmYnH7d5thtfOmeMaXtulCzz5JFx3HXir5bw0TXa7we7DRWZgbE4+6dlmWGzH1oH8e9xZkJ+N37aF/DHzPc6y/05bP7O9/j7vDpB6Kwntgji6fR22c+fhE90TAsIY6OHvSTyvVoXT9u3bj/t7ERFpnOyGnekrp/Plti8pN8oB6N6muzKYxGwnPnMm/OtfruG1UVHw2GNmtzw/hRpL02AYBnnF5YQHObt+jp39P37dcZhia/WGZUeKrPDeNZDxLQAXAVjA7huMJf482icM58l+PbDabCw4sA6jQz/wVUdRMdX5HuMTTzzB/fffT1BQkMt4cXExzz33HI899li9TU5ERE6Nl8WLAmsB5UY5Z0efzYSUCQxoP0DtbFuy/Hx48UV4/vmaw2tFGqGDBaWk5+STkVNAek4+W7LzSc/Jp02wH0seGOo4r8Rqo9haTnefLK4I3Ux/n3RW9vk7iTGtSIoKhRVfABZofwYkDIOE4Xh1PAt8qvyDgbpEy3HUuXCaMWMGt912W7XCqaioiBkzZqhwEhFpYIZh8GPWj8xZP4fH+j9GbFgsAHf1uYtxPcfRu11vD89QPKq01Bleu3+/c1zhtdJI5ZVY2XWwiJQO4Y6xsbP/x7KMA8c9v8Rqo8RqI8B6FDIX80bYfwmNWIpPQRaYO5TplXgUYpPNF+c9AMOmQXCEu78VaWbqXDhVfaiuqt9//502+oNXRKTB2Ow2M4Np/Ww2HtwIwNwNc5k2YBoA8eHxnpyeeJrNZobXPv64a3itt7czvLZDB8/NT1q84jKzk92WHPP5o8q7SPuOluDjZWHjExfh52O28I4KCwCgU5ugirDYEEdYbHy7YPzXvAVfTQYMHL1BfQKg80BIGA7hsc4vHN6xQb9PaT5qXTi1bt0ai8WCxWIhKSnJpXiy2WwUFBQ4wnFFRMR9ymxlfJX5FXPWz2FH3g4ARwbTuB7jPDs58bzK8NpHH4WNG12PXXedGV6bmOiRqUnLZLXZ2X6gkPTsfC5OjcHby/wZ8qF5a/ni933HfU9EiD+5+SV0bG3ucJoyqhsz/tCT4KI9sPUH2LYQuoyDGLMDHpE9AQPadYeuw80teJ0Hgm9gQ3yL0kLUunCaNWsWhmEwfvx4ZsyYQXi48/apn58fcXFxDBgwwC2TFBERk2EYXPvVtWw9shWAML8wru92vTKYxHSi8NpRo8yten36eGZe0mJkHy1h7Z4jFXeQCtiSnU/mgQKsNgOA1A7hxEWYz9IlRYXQOsiX5OhQkqNCSYwKJTk6lKTIUGezh9IC2LGMiMpi6dA25xcLbgdJFYVTh74weROEKbxb3KfWhdO4cea/Ynbp0oVBgwbh46Pe9SIiDeFo6VHa+rR13PUfGjuUvNI8bup5E1clXUWwrx7ob/F+/RUefhjS0lzHBw40O+idd55n5iXNkmEYZB0tqWjUkM+VZ3akbYg/AO//byf/WLi12ntC/H1IigqhsKzcMXbbkATuHNr1xE1r8nPgxZ5gtzrHKjKV6DoMki5yjnv7qGgSt6tz9RMaGsqmTZtITU0F4PPPP2fOnDn06NGD6dOn46cWpiIi9SK7MJuvi77mqc+e4qWhLzGwg5kiMjF1Irf1vg0/b/152+Klp5tb8j75xHU8JcUMr730UoXXymnbfqCQJem55h2kiueQ8kudBVBydBhDktoB0KN9OCkdwsznkCqeQUqKDqV9eEC1AsnH23x+ibwsyFxkbsHzCYA//sscD42CVp3AsJnPKXUdDnGDISCsQb5vkWPVuXCaNGkSU6ZMITU1lczMTK699lpGjx7Nxx9/TFFREbNmzXLDNEVEWo7MI5m8uf5Nvs782pHB9MOuHxyFU5Bv0MneLi1BZXjt3LmubZO7dDGfYbr+eoXXSp0cLbaSkZPvCIy9ul9HerY3H8tYtfMw0790fV7Ox8tCfLtgkqJCCQ1w/jh5UUo0F6VEn/yLWUtg18qKZ5UWQe4G5zG/ELj0RWdr8Ft/gEBtQ5bGoc6F05YtWzjjjDMA+PjjjxkyZAjvv/8+K1as4LrrrlPhJCJyitbtX8fs9bNZuGshBubzAPE+8dw/+H7OjT3Xw7OTRuFk4bXTpsGttyq8Vmpl2/4CPvplN+nZZke7rKMlLsfj2wU7CqfUDuGM7BFlPn9UcRepS0Swo+NdjQzD9c7nB9dC5uIqJ1RmKlU0daga0K2iSRqRU2pHbrfbAfj++++59NJLAYiNjeXAgeP31xcRkZMzDINpK6ax7aj54PPwTsO5qdtN7P55N/1j+iu4tqU7UXhtWJgZXnvvvQqvFRdl5XYyDxSQnu0MjB3dpwOjUmMAOFxYxhtLM13e0z48gKSKRg2VRRNAcnQob9zUr24TKDpkFkfbfoDMJfCnJRDc1jwWdy7sT68olIZC/FDnMZFGrM6FU79+/Xjqqae44IILWLJkCa+++ioA27dvJyoqqt4nKCLSHNnsNhbuXsi5Hc4l0CcQi8XCrb1u5cd9PzI+ZTzxreKxWq3sZrenpyqeVFoKr78OTz1VPbz2nnvMokkZilJh96EinvnvZrZk57P9QCHldsPleGzrIEfhlBQdys0D4yruIoWQGBVKWIDvqX9xmxX2/Gp2vtv2A+z9Dajy9bcvhpQrzd8PvAcG36/n76TJqXPhNGvWLG644QY+++wzHnnkEbp27QrAJ598wsCBA+t9giIizUmZrYwvt33JnA1z2Jm3k6lnT2VM9zEAXBJ/CZfEX+LhGUqjYLPBu++a4bU7dzrHFV7bYhmGwd4jxWab7+wCNmcdZdVWb7YFbGPyhd0ACPD15uu1WY73hAb4mA0aKu4i9YtzbnsLC/Bl+h96nt6k7Dbntrq1H8Hnd7oej+xhbr2rzFSq5ON/el9XxEPqXDj16tWLdevWVRt/7rnn8NaDqCIix1VoLeSTLZ/w9oa3yS3OBcwMJgOjhndKi2IY8Pnn8MgjCq9toQzDoLTcToCv+TPV0SIrN8/9mYycAgqqdLIzWVi376jjVUSIH49f1oMuEcEkR4cSHVa9k91pKc2H7csq7iothLMmwoA7zGPxQyGwjbn1rrJYUntwaWZqXTj9/PPP9O3b11EcGYbh8n9Gi8XCp59+yjXXXFP/sxQRaaIMw+DV31/lvU3vkVeWB0BkYKQymKS6RYvM8Nr//c91/KKLzNbiCq9tdo4WWUnPMZszmHeSzP8dkNCWV27oC0BYoA9bsvMpLLPh620hoZ25ra5rRBB5e9K58ZLujs+zWCzcMqhL/U3QboesNc5Caff/wF6leMtc5CycwjvAA9vAq5YNI0SaoFoXTgMGDCArK4vIyEgAwsPDWbNmDfHx8QAcOXKE66+/XoWTiEgVFouFzYc2k1eWR+ewzoxPGc+l8Zcqg0mcVq0yw2u/+851fMAAs4PekCGemZfUm8LScg4VlhHbxowSMAyDIc8tZtehouOevyWnwPF7i8XCa2P7Eh0WQFxEML4V2UdWq5UFCzbTsXVg/U7WWgy+FZ9ZXgJvXgS2Kh0cW3cx85QShpmZSlWpaJJmrtaFk2EYJ319ojERkZYk80gmczbM4fbet9M+xNymcscZd3Bp/KUM7zQcby9taZYK6enms0off+w6rvDaJqu03Ma23EIycp13j9Jz8tl9qJgeMWEsuNcsNCwWCyH+5o9gHVoFVmnzHUJSVChdI0NcPndwYjv3TfrYTCWLF9y+3DzmFwRJI807T10rtt+1iXffXEQauTo/43QyapcrIi3VsRlMQT5BTD1nKgDd2nSjW5tuHp6hNBp79pjhtXPmuIbXxsXBk08qvLYJKLfZ2XGwiNy8EgZ2jXCMX/bP5S53i6rKK7G6PObw6o1n0ibYj9DT6WR3qvZvga1pZrG0c4V5Z6mSxctsJR5U0a3x2ncbfn4ijVS9Fk4iIi2JYRj8mPUjb657k/9lO59LGd5pOJfGX+rBmUmjdPCgufXu5Zerh9c++ij86U8Kr22E9h0pZlNWnvksUnY+6TkFbMstoMxmJ9jPm/UzLnQUQwntQsg+WuK4g1Q1MLZNsOt/285tG/D5xqJDENDKuZVu2fNmF7xKoTGumUpBanEvcjx1Kpw2btxIdnY2YP7AsHnzZgoKzH9ZUfitiLQkhmEw8buJ/Jz9MwA+Fh8uib/EkcEk4lBQ4AyvzctzjoeFwYMPmuG1ISEnfr+4nWEY5OaXkl6Rf3TTgM6OYmjaZ+v5YXNutfcE+nrTNTKEvOJywoPMu0Z/v6Y3gb7ent+B48hU+sFs6rD3N5i0FGJ6mceTR0HhfrNY6joc2nXTtlCRWqhT4TR8+HCX55guvdT8F1WLxVKty56ISHNjtVnx8fLBYrFgsVjo2bYn6w6s48rEKxnXcxzRwdGenqI0JpXhtX/9K+RW+cE7IADuvtsMr23b1nPza8E2ZeXx645DFXeRCkjPyedosdVx/OLUGNqFmllDPTuEs/dIscvdo+SoUDq2DsTLy/XnniA/D27kKciFTV+YzyltXwqlea7H965yFk49rzB/iUid1Pr/4du3b3fnPEREGq2qGUzPnPcMZ0WfBcCE1AncknILrQNa1/AJ0qLYbPDee/DYY9XDaydMMMcVXut2BaXlZpvv7Hy25BRw34hEwiqeJ/r41z28ucL15xovC8RFBJMcFUqJ1fns2eQRSUwekdSgc6+V0nz8rFWKo9xN8PVfnK+VqSRS72pdOHXu3Nmd8xARaXQOlxzmvU3v8cHmDxwZTB9v+dhROIX7h3tyetLYGAZ88YUZXrthg+uxa681w2uTGuEP4M3E6l2H+XZDjiMPae+RYpfjl/SKpm9n89mdvp1bs/NgIUnRzk52Ce1CHKGzjdIxmUo+u/9HUtthwHXm8U79If58iDvXLJRizgB18RSpV2oOISJyjKyCLN7a+BbztsyjxGZ2m6qawSRSzeLFZnjtTz+5jl90kblV78wzPTKt5sRqs7PjQGFFYGwBW7LzmTwyiaSoUADW7jnKa0u2ubwnMtTfscUuPNDZnOGSXjFc0iumQed/Suw2+P1Ds1jKXARFBx2HLEBISbbzXB9/uOnzhp+jSAuiwklEpArDMLjjhzvYemQrAN3bdGdi6kRlMMnxKbzWrX7bdZi5K3awJSefbfsLsNpc8yJH9IhyFE59O7dmbP/O5l2kSPMuUuvgJtal0FoCh7ZBVE/ztcULFv0V8vaar/1CIX4IJAzF2vk8fvpxExd7brYiLY4KJxFp8dbtX0dSmyT8vf2xWCzc2P1Gvtn+DeNTxzMgZoAa30h1Jwuv/etf4bLL1KWsBoZhkJ1XQnp2Phk5BRV3kvK5c2hXLuxpNlrJK7byxe/7HO8J9vMmsaI5Q1J0KGd0auU4ltIhnJQOTWz7rGHA/s3mHaXKTCXfQHhgm7nNzmKBsyaCtcjcftfxLPCuyH2yWoFNHp2+SEujwklEWiTDMPhx34/MXj+bn7N/Zlr/aVyTfA0AoxNHc2XSlR6eoTRKe/aYzyq9+Wb18NonnoAxYxReexw2u4F3RQe6jfvyeOzz9aTn5JNfUl7t3A17jzoKp5QO4Tx0UTeSo0NIjAylQ6vqneyapMzFsO5jswNe5d2kSoGt4egeaF3xbPngyQ0+PRE5vlMqnMrLy1m8eDHbtm1jzJgxhIaGsm/fPsLCwghRFoWINGI2u43vd33P7HWz2XTI/NdaH4sPOUU5jnN0h0mqOXgQnnkG/vlP1/DayEjzztOtt4K/v+fm10jklVjJqHgGadO+o/y40Ysn1i5m/LlduHNoVwCC/Lz5dedhALy9LHSp6GRntvoOoXdsK8fnRYT4c/v5CZ74VuqPzQp7foHoXuBf8TPSjuWw+l3z9z4B0HmQeUdJmUoijVqdC6edO3dy0UUXsWvXLkpLSxkxYgShoaE8++yzlJSU8Nprr7ljniIip8UwDOZnzGfOhjnszDNbRAf6BCqDSU6uoABmzYLnnlN4bRXFZTaKysppG2IWi3sOF3HNaz+y72jJMWd6AWVszs53jMS2CeKl684gKSqU+HbB+Ps0wzt0hzIrtt8tNDOVyvLhuveh2yXm8W6XgLXYLJY6DzS354lIo1fnwunee++lX79+/P7777StEtx3xRVXMHHixHqdnIhIfbFYLHy/63t25u0kzC+MG7rfwPXdrlcGkxxfaSm88QY89VT18Nq77oIpU1pEeG1ZuZ3tFZ3sMirafG/JyWfnoSKuOrMjz13dG4DI0ABy8807cdFhASRFh5LYLoji7EyuvGAg3dq3cnymt5eFy89ohjlWh3fAyn+azyodPib7MrANFB1yvm7fx/wlIk1KnQun5cuXs2LFCvz8XDvVdO7cmb17957gXSIiDetQySHe3/Q+VyddTVRwFAC39b6NATEDuCrpKoJ8gzw8Q/Eomw3LkiV0WLoUS3AwDB1qPptUGV77+OOwY4fzfG9vGD/eDK/t2NFj03YXm91g16Eiists9GgfBkCJ1Uav6d9RZrMf9z1ZVe4u+fl4Mf+OgXRuE0x4kNm8wGq1smDBNnp1DMfXt5k9Ul2ZqWTxgvZnmGOGHX75t/l7Lx+IPccZPhtzBnh5eWiyIlJf6vwnmd1ux1b1gdgKe/bsITQ0tM4TeOWVV3juuefIysqiZ8+ezJo1i8GDBx/33MWLFzN06NBq45s2baJbt251/toi0vwcm8FUXF7MA2c9AEDvdr3p3a63h2coHjd/Ptx7Lz579tAP4IUXzGLohhvgq6+qh9decw08+WSzCa/dd6TY7GCXne/oZJeRU0BpuZ2z49rwn9sGABDg6010eACHCstIigpx5CFV/ooIcf0H1F4dW3ngu2lAeVkV4bM/mE0dig9Bt0vhuvfM423iYfD90KGvGUIbEObZ+YpIvatz4TRixAhmzZrFG2+8AZjbXwoKCnj88ce5+OK6pQl89NFH3HfffbzyyisMGjSI119/nVGjRrFx40Y6dep0wvelp6cTFub8A6ldu3Z1/TZEpJnZdmQbb65/kwWZCyg3zE5dPdr2oF9UPw/PTBqV+fPhqqvMNtBV7dkDf/ub69iFF8LTTzfJ8FrDMDhQUEZGTj55JVYuSnGGvY5+ZSXZecc+iwT+Pl74+rg2Jfj8zkG0CvJtuQ1TDAO+nw4Z30HuRtdjfqHgf8w/GA+f1mBTE5GGV+fC6cUXX2To0KH06NGDkpISxowZQ0ZGBhEREXzwwQd1+qwXXniBCRMmOJ6NmjVrFt9++y2vvvoqM2fOPOH7IiMjadWqVV2nLiLN1NRlU/kq8yvH63NizmFCygT6x/RvuT/wSXU2m9nM4dii6VjnnGN20Dv//AaZVn34ffcR1u87WuUuUgGHCssAiAz1dymcerQPIyzQh6SKPKTEqFCSo0Pp1CbI0TK8UpMLkD0dlZlK2euglxlNgMUCu36qKJos5nNJXYdDwnDo2M+ZqSQiLUKdC6f27duzZs0aPvjgA3777TfsdjsTJkzghhtuIDCw9l1hysrKWLVqFVOmTHEZHzlyJCtXrjzpe/v06UNJSQk9evTg0UcfPe72vUqlpaWUVmkdm1fRFclqtWK1Wms9X3epnENjmEtzpPV1L0+tr2EYLgVRmG8YFiwMjR3Kzd1vJiUiBTCjE5oyXb/1y7JkCT579tR4XvmTT2IMGlQRMNp4FJWVszW3kIzcArKOlnDXUGeb7r9+vZGfdxx2Od9igU6tg0iKCqGwuBQ/H/MZm9fG9D7uPyjYbeXYq+/EP2VN4votOoRl+2K8Mhdj2b4IS34WhsWL8rihENgKAEv/u6DfBIy4IRDUxvleO2D33PfWJNa3CdP6uldjWt+6zMFiGDX905t77Nu3jw4dOrBixQoGDhzoGH/66ad56623SE9Pr/ae9PR0li5dSt++fSktLeWdd97htddeY/HixZx33nnH/TrTp09nxowZ1cbff/99goL0cLhIU2I37Gy0bmRp6VIuCbyEzj5mQGS+PZ9io5hI70gPz1Aas7ivv6b3//1fjef9Onkye0/wd0pD2nzEwtY8C1lFkFVk4VApGDgLnmfPLse/opP3N7u92FkAMUEQE2QQE2gQFQh+zbDTd31of/gnuub+l1ZF27Hg/DHIZvHlQEg31nUcS2GAIgpEWoKioiLGjBnD0aNHXR4FOp4633F6++23T3r8pptuqtPnHfuvXsf+S3JVycnJJCcnO14PGDCA3bt38/zzz5+wcJo6dSqTJztTt/Py8oiNjWXkyJE1Lk5DsFqtpKWlMWLECHx9dcu/vml93auh1rfMVsbX27/mrU1vsatoFwCZrTO5ffDtbvuajYGu33py8CBezz2H19y5tTr9jFGj6D1kiHvnBJTb7Ow6VMyW3AIycgvYmlvAs1em4l9xZ2j5ZxtI2+TarbZtsB9JUSEkRoYw5Px42lRspavbE8YNo9Fcv4e345W5CHvXERAeC4Bl9UF8drwCgBHZA3uX8zHih2HEnkMb30Dc/1//9DWa9W2mtL7u1ZjWN69qRl8NTinHqSqr1UpRURF+fn4EBQXVunCKiIjA29ub7Oxsl/Hc3FyioqJqPZ/+/fvz7rvvnvC4v78//sdJc/f19fX4f6iqGtt8mhutr3u5a30LrYV8nP4xb298m/3F+wFcMphayn9TXb+n6EThtSdisUDHjvhUtiZ3g+835vD1uizSs/PZur+AsnLXVt93D0+ie4z5j3rnJ0fh6+NNUmQISdGVneyq/33W2DX49VuSBzuWVQTQOjOVvEc9C+dMMs/pfjH4BUD8UCxhMTTlG3P688G9tL7u1RjWty5fv86F0+HDh6uNZWRkcPvtt/PAAw/U+nP8/Pzo27cvaWlpXHHFFY7xtLQ0Lr/88lp/zurVq4mJian5RBFpcsZ/O56NB81OVpFBkYzrMU4ZTFKzsjIzvPbJJ13Da/39zU55X35pvq66U71yp8OsWadcNBmGwf78UkdzhspGDbOuPYO4iGAA0nPy+XS18y5SgK9XlRbfIY47SACX9Irhkl76+63WDmXCZ3fCnp/BXuX5Ri8fiO0PIVW28oZGwxljGn6OItKk1UsiXWJiIs888ww33ngjmzdvrvX7Jk+ezNixY+nXrx8DBgzgjTfeYNeuXdx2222Auc1u7969ju2Bs2bNIi4ujp49e1JWVsa7777LvHnzmDdvXn18GyLiYVkFWUQERuBb0alqdNfRFFmLGJ8ynkviL8HPuwV1+JK6s9ng/ffNkNqThddW5DhRtVFEx45m0TR6dK2+VNVt5T9syuH1pZlsycnnSFH1h4w3Z+c7CqfzEs34jMRIMxcptnUQXl7q/FhnefvMLCXfAEi50hwLjoQ9v5hFU5t4s/NdwjDoMrh623ARkVNQb1He3t7e7Nu3r07vufbaazl48CBPPPEEWVlZpKSksGDBAjp3Nh/4zsrKYteuXY7zy8rKuP/++9m7dy+BgYH07NmTr7/+us75USLSuFTNYHpswGNckWjehR6dNJqrkq7C26spb6QRtzMM8y7Sww/XLrx29Gi4/HLKFy1izTffcMaoUSfcnldYWk5GboFLWGx6dj5/u6oXQ5PNOxglVjs/bz8EgJcF4toGm3eQos123307t3Z8XmrHcFI7htf/GjR31mLYubIigHahM1MpprezcPIPgavnQlRPaNPFY1MVkearzoXTF1984fLaMAyysrJ4+eWXGTRoUJ0ncMcdd3DHHXcc99jcYx7kffDBB3nwwQfr/DVEpHFau38ts9fNZuHuhc6xA2sdhZOvl/aVSw2WLIGpU+HHH13HR440w2v79j3++7y9MYYMYW9hIb2HDKHUAFtZOUF+5l+LK7ce4KH5a9l9qPi4b9+Sne8onM6Ka82L1/YmMTKUrpEhBPiq0K9X826FTV9AedXQXgt0OBO6XmAWzpVbLbtf6pEpikjLUOfC6Y9//KPLa4vFQrt27Rg2bBh///vf62teItKMrdy7kn+v/ze/ZP8CgAULwzsNZ0LqBEcGk8hJrV5t3mH6739dx885B2bOhBPk+5Xb7Ow4WMSWnHw27TvCsnQvXspYwc5DRUy7pDs3DzLvVIQF+jqKpnah/iRXPIeUHB1CYsXvK0WGBXBFn47u+T5bksKDkLkIdv8Mo/7mLIYwzKIptD10HWZuwYs/3zVTSUSkAdS5cLLb7TWfJCJyEnM2zOGX7F/wsfhwacKl3JJyC/Hh8Z6eljQFGRkwbRp89JHreI8e5h2mP/wBLBbsdoO9R4rx8rLQoZUZzr5h31Gu+NdKymxV/x7zAgoB2HGwyDGaGBXCh3/qT1JUqEvDBqlHNqtZJG1bCNt+gH1roDJTqe84c8sdwOD7zV/tkqsUUyIiDa/ennESETmeMlsZX277kiGxQ4gIjADgT73+RNdWXRnXcxzRwQqZlFrYuxeeeAJmzzabQFQwOncmd9qTpA8ayZb9hWyZt5b0nAIycvIpKrNx88A4pv/B/AG8U5sgymx2gvy8SYwMoWtkMOUHd3P5+WfRs0NrIkOdrb79fbzpH9+2wb/NFmP1u/DNFCjLdx2PSoGEoeAX7ByL7NawcxMROYFaFU5VA2Rr8sILL5zyZESk+Tg2g2lC/gTu63sfAGdFn8VZ0Wd5doLSNBw6BM88A//8J4fxJb19d3xt5fS1HoRp0zh0w82c8+xSyPi12lv9vL0osTqLrNAAX5Y/NJT24YF4eVmwWq0sWLCLwV0jPJ4j0lz52IqxpC+AnUsh9Wro1N88EBpjFk1BbSF+KHSt6IAXqn9IEZHGq1aF0+rVq2v1YRbdQhdp8Q6VHOK9Te/xweYPyK/41+TIoEjah7T38MykqbDbDdZsySLjg89J/2UDW8KiSZ/wBvtDzGdahnofZc6UyyA0lLZAVJg/If4+JFeExCZHhZIYFUpc2yB8vL1cPrtja2WAuZXdBllrYOtCvLd+z6jdv+C1tqJ49QlwFk6dB8GfFkN0b/DyOtGniYg0KrUqnBYtWuTueYhIM/DCqhf4YNMHlNjM7ldxYXHKYJITKrHa2JpbQEZuPoYBo8/sCGVlWF5/g3Hbo8j36wS9Orm8Jzbcn6ikFAh1NmdY8dCwagWSeMDRvfDauVBc0Zq9Ytho3QVL1wsgeZTzXN8AaN+n4ecoInIa9IyTiNSbImsRJbYSerTtwcTUiQyLHaYMJnH4bkM26/flsSXbzEPacbAQe0UvgPiIIEZvXAyPPYZl+3YG/vFhivwCSD6wi6TunUi6+RoSUxMI9q/+15aKpgZmLYadK8wAWh9/GP6YOR7WHrz9wC8U4odgixvCwl0Wzr/iZm2FFJFm4ZQKp19++YWPP/6YXbt2UVZW5nJs/vz59TIxEWncft//O/9e+2+6lTsf3J6QMoHhnYbTP6a/tu62QHa7we7DRWzJKWBLTj55JVamjuruOP6PhRms35vn8p5Wgb4k+5bR/Zc0jP/MpPKqef2zp+Hqq+GVJyE5uQG/C6nGMCB3k9n5busPZhCtrdQ8FtQWhj5qbrezWOCWBdCqE3j7YrdaKcpZ4Nm5i4jUozoXTh9++CE33XQTI0eOJC0tjZEjR5KRkUF2djZXXHGFO+YoIo2EYRis3LeS2etnOzKYcn1z+RN/AiAmJIaYkBhPTlEa2LxVe/gx8yBbcvLJyCmguEozBj9vL+4fmYxvxR2hC3tEk9I+nKSKHKSkHetp9/jDWOoaXisN672rYOv3rmNhHcxmDgnDwLDj2JjXNqHBpyci0lDqXDg9/fTTvPjii9x5552Ehoby0ksv0aVLFyZNmkRMjH5gEmmObHYb3+/6ntnrZrPp0CYAfCw+XNzlYrrs7+Lh2Yk7HSwoJb2iKErPyWfHgULenXAOXl7mvaGF6bl8vTbLcb6fjxeJkSFmYGx0KOU2A9+K3Zp3D080f7N6NdxzR/Xw2rPPNsNrhw1riG9NqqqaqbR9CYz9DPxDzGPRqbBjBcQNMsNnuw6HiCRlKolIi1Pnwmnbtm1ccsklAPj7+1NYWIjFYuHPf/4zw4YNY8aMGfU+SRHxrEnfT+J/Wf8DINAnkCsTr2Rcz3G09WvLggXaitPcfPjzLr74fR9bcvI5UFBW7fjeI8XEtjG7012aGmMWSVEhJEWF0rltMN5eJ/iB+mThtX/9K1x+uX4Yb0iHMs2td9sWwvZlrplKO1dA0oXm7wfdC0OmmA0dRERasDoXTm3atCE/3/zDtUOHDqxfv57U1FSOHDlCUVFRDe8Wkaag0FqIv7c/Pl7mHxFDY4ey+dBmbuh2A9d3u55WAa0AsFqtHpylnIriMrOTnXkXKZ/0nHy2ZOfz2Z2DiAwzfzDefbiIldsOAmYdE9s6yGzzHW0WR+FBzgf9R6XGMOq4X6mKffvM8Np//9slvJZOnczxG28EbzURaVC/vQ1f3O06FtTWuf2uQz/neGDrhp2biEgjVefCafDgwaSlpZGamso111zDvffey8KFC0lLS2P48OHumKOINJCqGUxTz57KZQmXAXBl4pVc0fUKgnyVgdNUlJXb8bI4O87955fdvLJ4KzsPFWEY1c/fklPgKJxGpcQQ1zaY5OhQukaGEOR3ig1YDx2Cv/0N/vEPKClxjrdrB48+CpMmgb//qX221KxKphLbfoA+N5q/ADoNAC8fiO0PXSuKJWUqiYicVK3/NlyzZg1nnHEGL7/8MiUVfwFOnToVX19fli9fzujRo5k2bZrbJioi7rOvYB9vbXiL+RnzHRlM3+/83lE4Bfhoi05jZbMb7DpURHp2lTtIOflk7i/kgz/156y4No5zdxw0dwW0DvIlOTrU8RxSUlQoPduHOc5L6RBOSofwU59UYSG89BI8+ywcPeocDw2FBx6A++5zyWGSenR0r7n1bttCyFwExYedx0IinYVT267w0A7w138HEZHaqnXhdOaZZ9KnTx8mTpzImDFjAPDy8uLBBx/kwQcfdNsERcR9th7eypwNc1iQuYByoxyAnm17MjF1IkNjh3p4dlKVYRjsO1pCiL8P4YHmVrkvf9/H/R//Tmm5/bjv2ZKT7yiczk9ux3sTzyEpKpSIED/3tIsvK4P/+z948knIyXGO+/vDnXfC1KkQEVH/X7clMwznc2ElR2FWSkWXuwr+YdDlPPOOUtcqu0IsFhVNIiJ1VOvCacWKFbz55ptMmTKFv/zlL4wePZoJEyYwdKh+uBJpqp7++WlHW/FzYs5hYupEzok+RxlMHmQYBgcKytiSk8/GfUdYuM2LuW/8j4zcQgpKy3nuql5c3S8WgMhQf0rL7fj7eJFY0ZwhubLVd3Qo7cOddwojwwIcW/Hqnc0GH3wAjz0G27c7x7284JZb4PHHITbWPV+7pTk2U8mww7gvzGMB4dDxLHOLXmWh1KEveCt8VkSkPtS6cBowYAADBgzgH//4B//5z3+YM2cOF1xwAXFxcYwfP55x48bRsWNHd85VRE5DZQZTj7Y9aB1gPuw9IWUC4X7hTEidQEpEiodn2PIcLbKyJTefdiH+xEUEA7Bi60FunP2/Kmd5AeZ2Nx8vi0uXu96xrVh0//l0ahN04k527mQY8NVX8MgjsG6d67GrrjLvPHXrdvz3Su0VHjS33VVuwct3tn/H4m3eaQqo2Fp589cqlERE3KTOT/wGBgYybtw4xo0bx7Zt25gzZw6vv/4606dPZ8SIEWpNLNLI2Ow20namMXv9bDYf2sykXpO4q89dAAzqMIhBHQZ5eIbNX1m5nU1ZeWypeP4oPaeALdn5ZOeZz5PdNbQr91+YDEBiVAgWC3RuE0RiZAiWvGwuHnQG3du3oktEMH4+zof3A3y96VJRcDW4pUvNrXcrV7qOjxhhhtf263f890nNbFbX4ufLe2DzV87XPoGumUr+zufTVDSJiLjPKbZKMiUkJDBlyhRiY2N5+OGH+fbbb+trXiJymspsZXy+7XPmrJ/D7vzdgJnB5G1R22d3KS23kbm/kC05+bQL9Wdggvk8T/bREi7/14rjvqd9eAC+3s5iKDLUn40zLiLQzxur1cqCBQu4ODUaX99G8gPxmjXw8MPwzTeu4wqvPT0HtznvKG1fCpOWQtsE81jX4XB4ByQMNYulTgOUqSQi4gGnXDgtWbKEN998k3nz5uHt7c0111zDhAkT6nNuInKK3tv0HrPXzWZ/8X4Awv3Dq2UwyekpK7ezcHMO6dkFFXeR8tl+oBCb3ez1fWmvGEfh1LF1ILFtAqvkIZmBsYlRoYQFuBZEFouFQL9GWNxu3WqG1374oet49+5meO0f/6jw2roozYfMJeazStsWmoVRVduXOAunvrdAv/ENPkUREXFVp8Jp9+7dzJ07l7lz57J9+3YGDhzIP//5T6655hqCgz20XUREqsk4nMH+4v1EBUUxruc4rky8UhlMp8BuN9h7pLhii10B4YG+jDmnE2DWCHd/sBqrzTUUKTTAh+SKJg2VvLwsLHuwid6JqQyvnT0bysud4506wYwZMHaswmtrw26D8hLwq/i7cvsy+OgG53EvX+jU33lXKbqX85gKUhGRRqHWhdOIESNYtGgR7dq146abbmL8+PEkJye7c24iUguVGUxXJF5Btzbmg/jjU8bTu11vLo2/FF8981Anc1dsZ1OWeQcpIyefwjKb41hqh3BH4eTr7cVFKTH4+3iRHBVKYlQIydGhRIcFNI+uhJXhtf/8JxQXO8cjIszw2ttuU3htTY7NVOo3AYZX5B3GnQvtulW0Ch9uPrOk9uAiIo1arQunwMBA5s2bx6WXXoq3/nVRxOO2Ht7Km+vfZMH2BdgMG4dKDvHckOcA6BTWiU5hnTw8w8bpSFEZ6dn5bMk1GzRYLPDE5c6Ogm/9uJPtBwodr329LSS0M1t9px4TCvvP6/s02LwbzMnCa++/H/78Z4XXnojdZhZIWyuKpf2bXI/vrtItMSAM7vwfIiLSdNS6cPriiy/cOQ8RqaXf9//Ov9f9m8W7FzvG+sf056qkqzw2p8buX4u28lPmQdKz88nNL3U5Fhrgw4w/9HTcJbr2rFiKymwkRYWQHBVKXESwS/OGZkvhtXVnGFCQA6HRzrF5E6H4sPl7ixe0P9Ns7pAwDDqo06CISFN2Wl31RKRhPbj0Qb7ZbnYzs2Dhgs4XMD5lfIvOYCqx2ti2v4CMnALSc/LZkp3PgYJSPr/rXMc5v+w4xLKMA47XHVoFVjRoMJs02OwGPt5m4XTbkIQG/x48ym43w2unTVN4bW0UHoDMxWb47LaF4OUNf95gPofk5Q29roOyArNY6jIEgtp4esYiIlJPVDiJNGI2u/l8jbeXuT22R5sepO1M47L4y7gl5Ra6hHfx5PQalM1uuIS8zvp+C1/8vo8dBwqxG9XPP1hQStsQ8xmcG87pzKiUaBKjQkmMDCE0QM99YRjw9ddma3GF157c3lWw6SuzUMr6HahywfkEQt5eCK8IgB/1jEemKCIi7qfCSaQRqprBdM+Z93BR3EUAXJN8DRd1uYjo4OgaPqHpstsN9hwuNu8eVQbGZueTeaCQ36aNIMTf/GPrSJGVzP3ms0jhgb4kR4WSFB1ScRcplJAA5x9vI3pEeeR7abSWLTO33q04JlvqggvM8NqzzvLMvBoDw4BDmWYh5FPR/GLdJ/DTK85zolLMrXcJw5SpJCLSgqhwEmlECsoK+HjLx7yz8R1HBtMn6Z84Cqcg36Bm01bcMAxy8kppG+LneIbonz9k8MribRRbbcd9z5acfM7s1Bown0Ua1i2S5OhQIkP9m0cnO3dbswYeeQQWLHAdP+ssM7x2+HCPTMvjSvJg60rzjtLWH+DITrjpc4g/3zyefLG5RS9hmNkuPLT5/sOFiIicmAonkUbgYPFB3tv0Hh+mf0h+WT6ASwZTU3eosKKT3TF3kfJKyllwz2B6tA8DINjfh2KrDT9vLxIiQ0iOCiEp2sxESooKpUOrQMdndo8Jo3uMp76jJmbrVnjsMfNZpqpacnht3j68Vr3NuVvm4bNmGxhVinUvXzi41Vk4dRls/hIRkRZNhZNII/DQ0of4X7bZmjguLI7xKeObZAZTfomVjNwC4iOCaRXkB8Ds5dt58quNxz3f28vC7sNFjsLpst7tOS+pHXFtg/BpCZ3s3G3fPvNZpX//u3p47fTpZnitTwv5a+DoXrCVQpt483XhAbyXzKRt5fG2Xc08pYRhZsaSf4inZioiIo1UC/kbU6RxyTicQWRQJOH+Zi7QjT1upMBawMTUiQzrNAwvS+MuGkqsNrbmFrBp3xH+u9OL+e/8xtbcQvYeMYNSX73hTEalmreDukSYWwtj2wQ67hwlR4eSGBlKfLtgAnyduXDtQv1pF6pQ1dN2+LAZXvuPf7Tc8NqyIthZsf1u2w+wf7PZ8W706+bx6FTsva5j7eEAev7hHnzbtbBuiiIiUmcqnEQa0JrcNcxeN5vFexZz5xl3clvv2wAY0nEIQzoOaXTP6VhtdrYfKCQ9O5/uMWF0jTT/FX7R5lxuf++3irO8AGer76gwf4rKnNueBiZEsGHGhQT7648btyssNIulv/3NNbw2JMQMr508uXmH1xoG/PgybP0edv5o3mGqZPGC0rwqry3YLnuZnQsW0LOVwqJFRKRm+klGxM0Mw2DFvhX8e92/WZWzCjAzmHKKnCGjjaFgyiux8uO2g2Tk5JOeU8CW7HwyDxRgtZmtlx+6qJujcEqKDqVVkC+JkSEEFB/kgrN70r19K5KiQhxb9CpVvaMkblJWZm7He/JJyM52jvv5OcNr27Xz3PzcpfAA5Kx3PotkscDvH0FORXv1sA7m1jtlKomISD1Q4STiRmk703hj7RtsPrQZAB8vH/6Q8Adu7nmzRzKYDMMgO6+E9Ox8MnIK6BYTyuBE8wfqPYeKmfTOqmrvCfbzJik6lDbBzuet4iOCWT1tBOXl5SxYsICLz47F17dpPY/VLFSG1z72GGRmOse9vODmm83w2k7N6G5KeRns+bkifPYHM1PJ2x8e2gF+Fd0m+98OJUfNYikiqeU1vRAREbdR4STiRot3L2bzoc0E+gRyddLVjO0xtkEzmApKy5m3ao+ZiZSdT3pOPvklziYB150V6yic4tsFk9ohnMRIs5NdUlSIo5PdsXfEGsMdshbNMMyW4g8/DGvXuh678krzzlP37p6Zmzuk/xdWzYUdy6CswPVYRBLk7YOIrubrPjc0+PRERKRlUOEkUk8qM5gGdxhM19bmD3ETUibQMbQj1ydfT6uAVm75unklVjJy8tmSU0B6dj5dIoIZNzDOcfzxLza4nO/tZSE+Ipik6FD6dm7tGA/w9ebLu891yxylHjX38NqSo7B9qRksGxxhjh3aBlu+MX8fFOHcfhc/FEIVbiwiIg1DhZPIaTo2g2nL4S3MHDwTgPhW8dze6vZ6/XrlNjvPfZvuuIu072iJy/H+8W0chVOIvw/X9oulXai/4y5Sl4hg/H303FGT8/vv5h2mY8Nr+/Uzw2svuMAz8zpddhvsW2Nuvdv6A+z5xcxUuvxf0OdG85zkUVBeahZLUanmVkQREZEGpsJJ5BTtLdjL3PVz+XTrp5RWdO/qEt6Fge0HntbnlpVXdLLLyTcbNWTn0ybYj2eu7AWAj7cX81fvZX++s2NYTHiAo813746tXD7vb1f1Oq35iGcFZ2XhPXYsfPSR64Fu3czw2iuuaJrP8RzeAd9Ph8zFUHzY9VjbrmYXvEpt4mHw5AacnIiISHUqnEROwbO/PMv7m97HZphtt1PapjAxdSJDOw2tdQaTYRguzwpNnb+OVTsPkbm/kHK74XJuTHiAy+u7hnbF19uLpKgQEqNCCQ9UY4ZmZ98+vGbMYNjs2XjZnO3diY2FGTOaVnhtWRHsXAFe3uY2OwD/MNjwGWCAfzjEn+cMoG3d2ZOzFREROa4m8reuiOdVLXRa+7fGZtjoH9OfiakTOTv67BM2TDAMg31HS9iSnc+WHLNBw5acfMptBv+97zzHeVtzzeeUAEL9fSq21oWSHGU2a6j69as+wyTNzOHD8Oyz8NJLeB8bXvvII2Z4bUDAid/fGBgG5Gxwbr/b9SPYyqDzIGfhFNQGLnne3HrXoS94668jERFp3PQ3lchJGIbB8r3Lmb1+NmN7jGV4p+EAXNvtWga0H0BKRIrLuUeKrLQOduYYPfTJWhasyyK/tLzaZ1ssUFxmI9DPfN7onuGJlNsNkqNCiQkPUOe6lqaoyBlee+SIY7g8IADLAw/gff/9EBbmufnV1tf3w6YvoCDHdTysI7TrZhZVldf2WRMbfn4iIiKnSIWTyHGU28tJ25nG7HWzST+cDpiFUWXhZJQHUlzQnve27XS0+d6SU0BesZWNT1yEn4+5Xc9mGOSXluPjZSGhnXnnKLlie11yVCj+Ps5tfZVtwaWFsVrN8NonnqgWXmu77TbS+vblguuvx7ux5WRVZirt+RXOvc85nrfXLJp8gyDuXPMOU8JwiEhsms9iiYiIVFDhJFJFqa2Uz7d+ztwNc9mdvxsAf+9Arkm6mnE9bwLg4U/X8f7/dh33/RYL7D5cREK7EABuPz+BP50XT1zbYEcxJQKY4bUffgjTplUPrx03Dh5/HHv79pQd20XPUwwDDmVWhM8udM1U6vlHaB1n/n7QfXDOJLOduI+/hyYrIiJS/1Q4iQCl5TYy9xcy7cc/k57/MwAWezAlBweQf2gg1426hKjgIABiwsznSzq0CjRDYqNDSYo0O9oltAtxbL0DHAWUiMPJwmtHj4annnKG11qtDT+/41n7MSx8Eo7sdB2vzFSyVdmK2umchp2biIhIA1HhJC1Kuc3OzkNFbMnOZ2BCBOWWPAJ8Anh14R5eXrQVn9BE/KPSKTs4GOuRs8HwIyLEn9z8Ejq1NQunmwbEMW5QHGEBjWzrlDR+y5eb4bXLl7uODx9uhteefbZn5lWpaqZS8sUQXfEMn4+/WTR5+UKn/s4AWmUqiYhIC+LxwumVV17hueeeIysri549ezJr1iwGDx5c4/tWrFjBkCFDSElJYc2aNe6fqDQ5BwtK+XXHQb7fa2HhJ+vIyC1k6/4CysrtWHwPcfGgdP534L/c3vt2kqJHERbgQ1Lbc0lscyHde7YmKcrsatemSrMHgPAgFUxSR7//bnbE+/pr1/HGEF57dI+59W7bQtdMJbvNWTjFnw/Xf2Q+s+Svu6giItIyebRw+uijj7jvvvt45ZVXGDRoEK+//jqjRo1i48aNdOrU6YTvO3r0KDfddBPDhw8nJyfnhOdJ82cYBvvzSx3NGYYktaNrpPmD3cLNuTzwyVrAG3ZlAeDln01w1FK8QtewNMcOwJrcNcwaOp7LesWok53Ur23b4LHH4IMPzC16lbp1M7fkjR7tuYYJR3bDu1fCgXTXcf9wiB8CMb2dYwFhkHxRw85PRESkkfFo4fTCCy8wYcIEJk40W9LOmjWLb7/9lldffZWZM2ee8H2TJk1izJgxeHt789lnnzXQbKUxyMkr4buNOVU62eVzpMj5HIjf5T0dhVP3mDCSo0IILs+jew+DrdYv2Xj0J8e5A2IGMDF1ImdFn6WCSepXVhY8+ST83/9BeZXnf2JjYfp0uOmmhguvrZqp5O0H/W83x0NjoCAbLF7QoZ9z+137M5WpJCIichwe+9uxrKyMVatWMWXKFJfxkSNHsnLlyhO+b86cOWzbto13332Xp556qsavU1paSmlpqeN1Xl4eAFarFWsjePC6cg6NYS6NRUFpOVtzC8jILSQjt4DBXdsyODECgMzcPKZ9tt7lfC8LdG4TRGJUCJGhfo61TI4M4tNJZ5GWlsayoGVs3PUTFiwMjx3OzT1vpkebHgCUl1fPWJLa0fV7jMOH8Xr+ebxefhlLlfBao21b7FOmYJ80yQyvNYxaNX445fUt3I9l+xK8MhdhyVyEpTDXnEd4LOVnTnDc5bJc+yFG20QIbOV8r90Ae8v476nr1720vu6l9XUvra97Nab1rcscPFY4HThwAJvNRlRUlMt4VFQU2VWzTKrIyMhgypQpLFu2DJ9a/mvtzJkzmTFjRrXx7777jqCgoLpP3E3S0tI8PQWPySuDJVleZBVDVpGFQ6Wud3+2b99Ofoa5ra6oHHq08iImCGKCDGKCDCIDwM87D8ijZNs+vtxqY4N1A+292xPhbRZciYcTOeB3gMH+g4nIj2DHTzvYwY4G/k6br5Z8/QJ4l5YS/9VXdJ0/H+/CQsd4eUAAWy+/nG2XX055UBAsXHhKn1+X9e23/Z90OPKLy1i5lx8HQrqzPySV7Qu+wrB4Vzm6/5Tm1Jy09OvX3bS+7qX1dS+tr3s1hvUtKiqq9bke349x7BYpwzCOu23KZrMxZswYZsyYQVJSUq0/f+rUqUyePNnxOi8vj9jYWEaOHElYWNipT7yeWK1W0tLSGDFiBL6NLeCynpTb7Ow4WERGbgEZuQVsySmgX1xrbh7QGYD9+aVMe3aJy3vahfiRGBVCUmQIgxMjOK/ijhPAVSf4OqW2Ur7M/JK3N73NnqI9XB5/Odf3vZ60tDTGXjSW8b7j3fUttlgt4fo9KasVrzffxOvpp7FkZTmGDT8/7LfdhvHQQyS0a0fCKX/8CdbXMOBwJl7bFmHZtQLbH183t+EBXt8uhV9/wYhMwZ4wFCN+KEbHc2jr409boNupf7fNTou/ft1M6+teWl/30vq6V2Na38rdaLXhscIpIiICb2/vaneXcnNzq92FAsjPz+fXX39l9erV3HXXXQDY7XYMw8DHx4fvvvuOYcOGVXufv78//v7VQxh9fX09/h+qqsY2n9NVWFrOw5+uIz07n8z9hZTZ7C7HbQbcel5XAGJa+zDh3C7EtQ0i8QSd7E6moKyA/2z5D+9sfIcDxQcAaOXfirhWcY41bW7r29i0uPWtDK997DGzAUSlivBay+OP4925M94n/oQ68fX1xbe8ELYvreiA9wMccYYwe2VNgi4V3UgHT4YhD2IJjaq3r9/ctbjrt4Fpfd1L6+teWl/3agzrW5ev77HCyc/Pj759+5KWlsYVV1zhGE9LS+Pyyy+vdn5YWBjr1q1zGXvllVdYuHAhn3zyCV26dHH7nMVkGAY5eWYnu4ycfNKzzSYNiVGhPH+12Ykr0Neb7zfmUFhmAyDIz5vEqFCSo0JIigqld2wrx+dZLBamXdrjlOYyZ/0c/m/t/5FvzQcgKiiKm3vezOjE0QT5BjWKvbPSjBgGfPONGV77+++ux664wuyU1+PUruWTsfz+AXx9Hxg252BlplLX4dCmyp9/4R3q/euLiIiIh7fqTZ48mbFjx9KvXz8GDBjAG2+8wa5du7jtttsAc5vd3r17efvtt/Hy8iIlJcXl/ZGRkQQEBFQbl/pTXGYj0M/8d2vDMLhx9v9Yt+coeSXVGypUFkkAXl4Wpv+hJ62D/EiODqVDq0C8vOq/c11JeQn51nziw+MZnzKei7tcjK+3/mVI3OBE4bVDh5pZTOecc/pf4+ge2PqDeVep1zWQMBIAI7K7WTS1TTQLpYRhZqaSX/Dpf00RERGpFY8WTtdeey0HDx7kiSeeICsri5SUFBYsWEDnzuazL1lZWezatauGT5H6kF9iZUtOgXkHqaLNd3p2AVFh/nx9j7kFyGKxcKjQSl5JOd5eFuLaBpEcHeoIik2ODnX5zKv7xdbrHDMOZ/Dm+je5uMvFDO5ozun6bteT1DqJoZ2G4mXxqtevJwLA2rXmHaZjw2v79nWG155qO/uyIti5wlksVc1U8g1yFE5E94L71kGrE+fbiYiIiHt5vDnEHXfcwR133HHcY3Pnzj3pe6dPn8706dPrf1LNWInVxt4jxSS0C3GMjfm/n1i57eBxzy8otWKzG3hX3C168vKeBPn5EN8umADfhnmCYk3uGmavm83iPYsB2Fuw11E4tQpoxfDOwxtkHtLCZGaazzC9/75reG1yMvz1r6cfXlt8GJ5PBpszLsElU6lq4KzFS0WTiIiIh3m8cBL3sNrsbD9QyJac/CphsQXsPFhIkJ8P66aPdHQvDA80t7ZFhfmbd46iQkmquJOUGBniKJoA+sW1aZD5G4bB8r3Lmb1+NqtyVgFgwcIFnS9gQuqEBpmDtFBZWeazSm+84Rpe27GjGV47blzdwmsL9kPmIvOOEsAVr5n/G9ga2iZAab4zfLbLeeZ4JT2jJyIi0miocGribHaD3YeK2La/gOHdnd0Ib393Fd9vyj3ue3y8LRwsLCMixOw2+OilPZg5OpVWQbXvZOduU5dP5etMc2uUj5cPf0j4A7f0vIW48DjPTkyaryNH4NlnYdYsqBJeS9u25la9O+4ww2trUl4Gu38yC6WtP0D2WucxnwC49EXwDTRf3/y1WSidzp0rERERaRAqnJqQ3PwSNuzLq+hkV8CWnHwycvMpsZqtvn999AJHMdQ1MpQftx0kKbriDlLlr+gQ2oX4u2RldWgV6JHvp6rSiu1K/t7m/Id0HMLCXQu5JukaxvYYS1Rw9Rb1IvWiqAj++U945hmzeKoUHAx/+Yv5qy6Zb/8ZC1v+6zoWnWreVUoYbnbDqxTUMHdwRURE5PSpcGqEDhSUsqWixfdV/WIJ8Tf/M72yaBtzV+6odr6fjxeJkSEcKXLeRbrvgkQeuij5uGHCjUnVDKabe97MuJ7jABjReQQD2w8k3D/cwzOUZstqhdmz4YknzO15lfz84PbbzbtMkZHHf2/xkYpMpYqmDhPSIDTaPNZ5EOxdVVEoDYP4oRCqwl9ERKSpU+HkYTsOFrIyx8KvX29ma675TNLBwjLH8dSOrejb2XzmoUf7MBIjQ465ixRC57bBLs8hAQ3WuOFUHSw+yHub3uPDzR86Mpi+2/mdo3Dy8fJR0STuYbfDRx/BtGnVw2tvusl8jqmis6fzPTbY+5szfHbPr66ZStsWwhljzN+f/ScYcJf5eSIiItJsqHDysKUZB/ko0xsynW3XLRbo1CaIpKhQfKoURNf0i+Waem7x3dD2Fuxl7vq5fLr1U8f2vC7hXRifMp5Lulzi4dlJs1bX8Fq73Vn8bPgU5h3TlCQiybn9Lm6Qc9y3Fs9BiYiISJOjwsnDUtuH0b2VnYE9u9C9fSuSo0LpGhniCJ1tbl5c9SLf7vgWgNSIVCakTmBorDKYxM1WrDDDa5ctcx2vGl5bVgQZaRWZSj+Yd5DO/bN5XpchZhOHLuc5t+CpPbiIiEiLosLJw/p0asVt3e1cfFEyvr6+Nb+hiVmTu4bIoEjah7QH4JaUW8grzWNi6kTOij6r0T+DJU3c2rXwyCPw1Veu4337wtNPQ68Yc5vdW3+FXT+CzblNlm0LnYVTSDt4IFPb70RERFowFU5S7wzDYNneZcxeN5vfcn/j6qSreWzAYwD0bNuTN0a+4eEZSrN3ovDabonw5NNw5ZVmkfS3OLAWOY+Hx7pmKlWloklERKRFU+Ek9abcXs53O75j9vrZbDm8BTCbPHhbvDEMQ3eXxP2ODa/1Ajp7wxmtoV87CA+Bq64yz/Xxh6QLoazQfE6p63Bo21WZSiIiInJcKpykXny57UteWfMKewr2ABDoE6gMJmk4leG1L70E/sVwpg8kBEKcL/gBlIF1LxwA8rOdrcOvnuuxKYuIiEjTosJJ6sX2o9vZU7CHVv6tuKH7DVzf7Xq1Exf3KyqCfz4Pz74Ih46YY8MD4Ew/5znB7Zzd7+LPV6aSiIiInBIVTlJnlRlM/WP6c3bM2QDc0P0G2ga25YquVxDkG+ThGUqzZrfBrp/hk7+bHfAibRBQaB7z9TW333Uoge4XmQVTVIqeTxIREZHTpsJJau3YDKbf9//uKJzaBrblhu43eHiG0mwVHoTNX5mFUnoa2CsaOkQDWCDWF0ZcZ4bXxsV5bp4iIiLSbKlwkhplHM5g9vrZ/Hf7f7EZNgB6RfTihu43qOmDuEdZoZmrFNLOfH0gHb68x3m82IDMcvNXwjCY/Xfo2dMzcxUREZEWQYWTnNSzvzzLOxvfcbwe2H4gE1Mn0i+qnwomqT+GATnrK8JnF5qZSn3GwqUvmOG1D0+BTuWwuxy22WCvDYacD/+aCf37e3r2IiIi0gKocBIXhmFgM2z4eJmXRvc23bFgYUTnEUxInUCPtj08PENpNux2WPexWShtWwiFua7Hd6yCyy6rHl575pkweyaMGKHW4SIiItJgVDgJ4JrBdFXSVVzf7XoALupyEb3a9aJzWGcPz1CavPJSOLgVoiq21Hl5weKZcHi7+do3COIGQ6veMO9XeOJz1/DapCQzo+nKK9XsQURERBqcCqcWrtRWyudbP2fO+jmODKb/pP+H65Kvw2Kx4Ovlq6JJTo1hmIXStoXmFrwdy8HiBQ9tB29f85x+t0DxYfM5Jb84mPksvDEDrFbn53ToYDZ9uPlm8NEfWSIiIuIZ+imkhcovy+c/6f/hnY3vcLDkIACt/VtzQ/cbuK7bdXp+SU7djuXmFrytC+HoLtdjwZFweCdEdDVfD7rXDK997jmYNcvMZarUpg08/DDccQcEBjbU7EVERESOS4VTC/XkT0/yzfZvAIgJjmFcz3HKYJK6s9toXbgVSvPBt405tnMlrJpr/t7bDzoNMO8odR1uZipVFuVFRfDyy/DMM3D4sPMzg4Nh8mT4y18gXCHKIiIi0jiocGoh9uTvIcAngIjACMAMrE0/lM6E1AmM6jIKXy9fD89Qmowju2Gb2f3OJ3Mx55UcpTyzM/S6yjyefDEUHYSE4RA3CPyCXd9vtcKbb8ITT8C+fc5xX1+4/XbzLlNUVMN9PyIiIiK1oMKpmdtyeAtvrn+T/27/L9ckX8PD5zwMQO92vfns8s+0JU9q58hu+PFl81mlgxmOYQtQ5h2Ed9FB57nRKTDqb9U/w26H//wHpk2DrVud4xYLjB0LM2YovFZEREQaLRVOzdTq3NXMXjebJXuWOMZyCnNcAmtVNMlx2e1mppK9HDqcaY5ZLPC/1yp+7wUd+kHX4ZTHDeG/a7IY1fcyvE/0eYYB//2veSdpzRrXY5dfbnbKS0lx0zcjIiIiUj9UODUzK/et5PXfX+e33N8AsGBhZNxIxqeMVwaTnFhBLmxbVLEFb5GZqZQ4Em742Dwe3hHOewCiU6HLEAhsBYBhtWL8vuDEn7tyJUydCkuXuo4PGWI+26TwWhEREWkiVDg1Mz/t+4nfcn/D18uXPyT8gVtSblE7cTmxRU9D+gLIXuc67hsMfiGuY8MedX1ts2FZsoQOS5diCQ6GoUPBu+K+07p18Mgj8OWXru8580x4+mkYOVLhtSIiItKkqHBqwiozmJJaJ3FG5BkAjO0xFgODsT3GEhkU6dkJSuNRmam0bzX0usY5vnOls2iK7mV2vksYDrFng4//iT9v/ny491589uyhH8ALL0DHjuZ2vJUr4b33XMNrExPNLXlXXaXwWhEREWmSVDg1QcdmMA1qP4jXRpjPn7QLasdf+v3FwzOURqH4MGxfajZ02LbImakUPxRC2pm/H3g3nHmT61hN5s83C6CqhRHAnj1m5lJVHTrA44+b4bW+6twoIiIiTZcKpybkQPEB3t34Lh+lf0SBtQCA6OBoBncc7NL0QVq4TV/Cin/A3l/BsDvHKzOVig85i6SkC+v22TYb3Htv9aLpWK1bm3ef7rxT4bUiIiLSLKhwaiL+ve7fvLrmVcrsZQDEh8crg0ngyC7YthC6nAdt4s2x0gLY87P5+4gkc+td1+HQeWD1TKW6WrbMvLNUk7ffhksvPb2vJSIiItKIqHBqxKreRWrt35oyexm9InoxIXUC58eej5dFz4q0OGWFsGO5WSxVzVQa8SQMusf8feIIuOwfkDAMWsXW79ffvbt25+Xn1+/XFREREfEwFU6N0G85vzF7/WyGxg7lqqSrALgs4TI6hXWiX1Q/bclriY7shs/vgF0/ga3MOW7xgo5nQWi0cyw4AvqOq9+vb7fDxx/DlCm1Oz8mpn6/voiIiIiHqXBqJAzDYOmepcxeN9uRwbQrbxdXJl6JxWLBz9uPs6LP8vAspUFUZipZvKDX1eZYcDvY/bNZNIV3gq7DzC14Xc5zZCq5hWHAt9+azyutXl3z+RaL2V1v8GD3zUlERETEA1Q4eVi5vZzfy37nrW/eIuOIue2qagaT7i61AOWl5p2kbQvNANrK9uDtujsLJ98AuHI2tOsGbRMaJgPpxx/N8NolS1zHe/SAjRvNOVRtElE5p1mznHlOIiIiIs2ECicP++vPf+Xzos+hCIJ8grgm+RplMLUkn98F6+eBtch1PLoXdL0A7DbwqihCujdQs4X1683w2i++cB3v0wdmzjTDaz/91OyuV7VRRMeOZtE0enTDzFNERESkAalw8rDL4i8jbXsaN6fezJgeYwj3D/f0lMQdig9D5hIzcPaiZ5whsIbdLJpCosxmDgnD6papVJ+2bzczl959t+bw2tGj4fLLKV+0iDXffMMZo0bhM3So7jSJiIhIs6XCycPOjDyTB8Ie4PKUy/FVQGjzYSuHfb9VhM/+AHtXOTOVel8HHc40fz/oXuh/O0SlNMz2u+PJyTELo9dfB6vVOd6+PUyffuLwWm9vjCFD2FtYSO8hQ1Q0iYiISLOmwqkR8LWoYGpW1n4MC/4CJUddxyOSzTtKAVXuKrZLbti5VXX0KDz3nLm9rrDQOd66tfls0113KbxWREREpIIKJ5FTVZmptPUH6H4ZdKnoJBcWYxZNAa0g/nwzfDZ+aP1nKp2q4mJ4+WV45hk4dMg5HhQEf/4z3H8/tGrlsemJiIiINEYqnERqy26HnPXm1rutP5id8OyVW9sMZ+HU8WyY+AO07+Ns7NAYlJfDnDkwYwbs3esc9/WFSZPMhhDR0Sd+v4iIiEgLpsJJpDYKD8ArA6Aw13W8VSczTyn5YueYjx907New8zsZux0++QQefRQyMpzjFgvceKNZSHXp4rn5iYiIiDQBKpxEqqqaqQQwYob5v0FtzSwl32DzzlLCcHMLXpt4zzV1qIlhwHffmc8rHRte+4c/mA0hUlM9MzcRERGRJkaFk7RshgEHMpzhszuWOzOV/MNh2DTw9jGLo7GfQXiseUepsTtReO1555lZTAMHemZeIiIiIk2UCidp2T66ETZ/5TpWNVOpsoU4QNuEhp3bqThZeO3TT8OFFzbeO2QiIiIijZgKJ2n2LIYNy56fYcdSyFwEY/4Dga3Mg1EpkJEGnQeY2+8ShkFUz6ZXXOzYYYbXvvNO9fDaJ5+Eq692hteKiIiISJ15/CepV155hS5duhAQEEDfvn1ZtmzZCc9dvnw5gwYNom3btgQGBtKtWzdefPHFBpytNBlHdsGvc/CedwsXrbsTn7cuhiXPwO7/wfalzvP63w4P7YCbPodB90C0B4NoT0VODtxzDyQlwdtvO4um9u3NQNsNG+Daa1U0iYiIiJwmj95x+uijj7jvvvt45ZVXGDRoEK+//jqjRo1i48aNdOrUqdr5wcHB3HXXXfTq1Yvg4GCWL1/OpEmTCA4O5k9/+pMHvgNplNb+B+bfCpj/MuAHGAGtsCQMNe8odervPLfyzlNTc/QoPP88vPiiwmtFREREGoBHC6cXXniBCRMmMHHiRABmzZrFt99+y6uvvsrMmTOrnd+nTx/69OnjeB0XF8f8+fNZtmyZCqeWxm6HnHVmU4etP0DqVdD3ZvNY7Dlg8YaOZ2HrMoQV2QEMuPIOfP0DPDrlelFcDP/6l9ngQeG1IiIiIg3GY4VTWVkZq1atYsqUKS7jI0eOZOXKlbX6jNWrV7Ny5UqeeuqpE55TWlpKaWmp43VeXh4AVqsVq9V6orc1mMo5NIa5NHoFOVi2L8ErcyGW7UuwFO53HLL7BmHrdYP5IqQ9/GUr+IditVo5nJaG1WaHprzG5eVY3noL76eewlIlvNbw9cU+cSL2qVOd4bUN+H3q+nUvra97aX3dS+vrXlpf99L6uldjWt+6zMFiGFWfJG84+/bto0OHDqxYsYKBVVojP/3007z11lukp6ef8L0dO3Zk//79lJeXM336dKZNm3bCc6dPn86MGTOqjb///vsEBQWd3jch7mUYjueNvO2ljFp7O95GueNwuZc/B0K6kxuWSm5YLwr9ozw1U/ex22n/4490f+89QvbtcwwbFgt7zjuPzddfT1FlwSQiIiIidVJUVMSYMWM4evQoYWFhJz3X4131LMc8iG8YRrWxYy1btoyCggJ++uknpkyZQteuXbn++uuPe+7UqVOZPHmy43VeXh6xsbGMHDmyxsVpCFarlbS0NEaMGIGvr6+np+NZhgEHM/DKXIQlcxFYi7CNdbbVthyZi1Gajz1+KEb8UIyOZ9PW24+2QPcTfGSTXV/DwJKWhve0aViOCa+1X3IJtieeIDo1FU+XTE12fZsIra97aX3dS+vrXlpf99L6uldjWt/K3Wi14bHCKSIiAm9vb7Kzs13Gc3NziYo6+Z2DLl26AJCamkpOTg7Tp08/YeHk7++Pv79/tXFfX1+P/4eqqrHNp8EUH4bMxRXPKi2EvD1VDlrwKsuD4Lbmy7GfgY8f3qfwZZrU+v70k9ngYfFi1/GK8FqvgQM93w7zGE1qfZsgra97aX3dS+vrXlpf99L6uldjWN+6fH2PFU5+fn707duXtLQ0rrjiCsd4Wloal19+ea0/xzAMl2eYpJGzlYOXt7Pl99d/gfXznMe9/Z2ZSl2HQ1Ab5zEfv4ada0PbsMEMr/38c9fxM84wm0EovFZERETEYzy6VW/y5MmMHTuWfv36MWDAAN544w127drFbbfdBpjb7Pbu3cvbb78NwL/+9S86depEt27dADPX6fnnn+fuu+/22PcgtXBkl9n5btsPkLkUJnwHkeZ/QxKGQc4G838ThkPngeDXwp49O1F4bdeuZnjtNdcoh0lERETEwzxaOF177bUcPHiQJ554gqysLFJSUliwYAGdO3cGICsri127djnOt9vtTJ06le3bt+Pj40NCQgLPPPMMkyZN8tS3IMdTVgg7ljuLpYNbXY9nLnYWTmfcAH1ubPApNgo5OfDXv8Jrr7l2wmvf3iykbrkFtD1AREREpFHweHOIO+64gzvuuOO4x+bOnevy+u6779bdpcbIbofyYvALNl/v/BHev8Z5vCJTia7DzTtL7ftUOdYCt56dLLx2yhQzvFYdH0VEREQaFY8XTtJE5eeYDR22/QDbFsEZY2Dkk+axzgMhIgk6DzKLpbjBENjKo9NtFIqL4ZVX4Omnq4fX3ncfPPCAwmtFREREGikVTlI7djvsWFqx/W4h5Kx3Pb7rR+fv/YLgrl8adn6NWXk5zJ0L06dDlfBafHxg0iR49FFneK2IiIiINEoqnOT4DAMKciG0ojW8xQLzboXCXOc5Mb2d3e86nu2ZeTZmdjvMm2cWRlu2OMctFrjhBpgxA+LjPTc/EREREak1FU7idGymkq0M/pJudnSzWKDXNVB0qKID3lAIjvD0jBsnw4C0NHj4YVi1yvXYZZeZDSFSUz0zNxERERE5JSqcWrqstbD5K7NY2rsKDLvzmLc/HNkBbSruilz4V49MsUn53//M8NpFi1zHBw82s5gGDfLMvERERETktKhwammO7ILgSPANMF+v/wRWvOQ83q6buf0uYVjLzFQ6VRs2mFvyPvvMdfyMM8xmEBdd1DI7CIqIiIg0EyqcmrvSAjNTqbID3sGtcMMnkDjCPJ58sVlMJQw3t9+Fd/TsfJuaHTvMpg/vvGM+01QpIQGeekrhtSIiIiLNhAqn5ig/G9a8bxZLu34Ce5VwVYs3HMhwFk6d+pu/pG5yc81nlV591TW8NibGDK8dP17htSIiIiLNiAqn5iA/B8oKoG2C+brkKPwww3m8VWdn+GyX8yAg3DPzbA6OHoW//x1eeME1vLZVK/PZJoXXioiIiDRLKpyaImsJ7P7JNVOp5xVw9VzzeEQSnHEDtO9jFktt4vV8zekqKYF//cts8HDwoHM8KAjuvdcMr23d2nPzExERERG3UuHUVBgG/PwGZKSZzyyVF1c5aDHvMjleWuCPrzT4FJul8nJ46y3zOaY9e5zjPj7wpz+ZDSFiYjw2PRERERFpGCqcGqviw2ar8Pgh5muLBX7/EPb9Zr4OiTbvJnUdDvHnK1OpvhmGM7w2Pd05brHAmDFmeG1CgufmJyIiIiINSoVTY2Evh12rKsJnfzALJIsXPLgdAsLMc87+ExTuN4ulyB7afucOhgHff28+r3RseO2ll5oNIXr18szcRERERMRjVDh5mGXbQs7KfAmfF+6E0nzXgxFJkLfXWTidcX3DT7AlOVF47bnnwjPPKLxWREREpAVT4eRhlsM7aH+04s5GYGuIH2puwUsYBuEdPDu5lmLjRnjkkerhtb17m+G1o0bp7p6IiIhIC6fCycPsiSPYsvZKEi+ahE9sP/Dy9vSUWo6dO82mD2+/XT289skn4dprFV4rIiIiIoAKJ88Lj2VL9OV0bX+miqaGkptr3kl69VUoK3OOx8TAY4/BhAkKrxURERERFyqcpOXIy3OG1xYUOMdbtYIpU+DuuxVeKyIiIiLHpcJJmj2vsjK8Zs2Cv/3NNbw2MBDuu0/htSIiIiJSIxVO0nyVl2OZM4cLHn4Y76oFk8JrRURERKSOVDhJ81MlvNYnPd15kSu8VkREREROkQonaV4qw2t//dVl2H7xxXg9/bTZYlxEREREpI5UOEnz8PPPZsG0cKHLsH3QIFZccgn9778fL3XKExEREZFTpJAaado2boTRo+Gcc1yLpl694OuvsS1cyKEePTw3PxERERFpFlQ4SdO0cyfccgukpsKnnzrH4+Ph/fdh9Wq4+GLzuSYRERERkdOkrXrStJwovDY62hle6+fnufmJiIiISLOkwkmahrw8M7j273+vHl770ENmeG1wsMemJyIiIiLNmwonadxKSsy7S3/9a/Xw2nvvhQcfVHitiIiIiLidCidpnMrL4e23Yfp02L3bOe7jA7feCtOmKbxWRERERBqMCidpXAwD5s+HRx+FzZtdj40ZA088ofBaEREREWlwKpyk8fj+e3j4YfjlF9fxSy4xt+opvFZEREREPESFk3jeL7+Y4bU//OA6PmgQPPMMnHuuZ+YlIiIiIlJBOU7iOZs2wZVXwtlnuxZNvXrBV1/BsmUqmkRERESkUVDhJA1v1y4YPx5SUsznmSrFx8N775nhtZdcovBaEREREWk0tFVPGs7+/WZ47SuvKLxWRERERJoUFU7ifgqvFREREZEmToWTuE9JCbz2mtkR78AB57jCa0VERESkiVHhJPXvZOG1Eyea4bXt23tseiIiIiIidaXCSeqPYcCnn8Ijj1QPr73+ejO8tmtXz8xNREREROQ0qHCS+vHDD2YW07HhtRdfbG7VO+MMj0xLRERERKQ+qHCS03Oy8NqZM2HwYM/MS0RERESkHinHSU7N5s1w1VXVw2tTU53htSqaRERERKSZUOEkdbNrl5m31LMnzJvnHI+Ph3ffhTVrFF4rIiIiIs2OtupJ7ezfb269+9e/qofXTptmdstTeK2IiIiINFMqnOTk8vPN8Nrnn3cNrw0PN8Nr77lH4bUiIiIi0ux5fKveK6+8QpcuXQgICKBv374sW7bshOfOnz+fESNG0K5dO8LCwhgwYADffvttA862BSkpgVmzzC1406c7i6aAALNgysw0m0KoaBIRERGRFsCjhdNHH33EfffdxyOPPMLq1asZPHgwo0aNYteuXcc9f+nSpYwYMYIFCxawatUqhg4dymWXXcbq1asbeObNWHk5zJkDycnw5z/DgQPmuLc33HYbbNsGzzwDbdp4dp4iIiIiIg3Io1v1XnjhBSZMmMDEiRMBmDVrFt9++y2vvvoqM2fOrHb+rFmzXF4//fTTfP7553z55Zf06dOnIabcfFWG1z76KGza5HpM4bUiIiIi0sJ5rHAqKytj1apVTJkyxWV85MiRrFy5slafYbfbyc/Pp81J7n6UlpZSWlrqeJ2XlweA1WrFarWewszrV+UcPDkXy6JFeD36KF7HhNfaR43CNmOGM7y2EaxXXTWG9W3OtL7upfV1L62ve2l93Uvr615aX/dqTOtblzlYDMMw3DiXE9q3bx8dOnRgxYoVDBw40DH+9NNP89Zbb5Genl7jZzz33HM888wzbNq0icjIyOOeM336dGbMmFFt/P333ycoKOjUv4FmoFVGBt3ffZfI3393GT/YrRubxo7lYM+eHpqZiIiIiIj7FRUVMWbMGI4ePUpYWNhJz/V4Vz3LMXk/hmFUGzueDz74gOnTp/P555+fsGgCmDp1KpMnT3a8zsvLIzY2lpEjR9a4OA3BarWSlpbGiBEj8PX1bZgvunkz3o8/jtenn7oMGykp2J58krCLL+acZpLD5JH1bUG0vu6l9XUvra97aX3dS+vrXlpf92pM61u5G602PFY4RURE4O3tTXZ2tst4bm4uUVFRJ33vRx99xIQJE/j444+54IILTnquv78//v7+1cZ9fX09/h+qqgaZz+7dMGOG2fzBbneOd+kCTz6J5brr8PH2du8cPKSx/fdubrS+7qX1dS+tr3tpfd1L6+teWl/3agzrW5ev77Guen5+fvTt25e0tDSX8bS0NJete8f64IMPuPnmm3n//fe55JJL3D3N5uHAAfjLXyAxEWbPdhZNUVHw8suweTPccIPZOU9ERERERKrx6Fa9yZMnM3bsWPr168eAAQN444032LVrF7fddhtgbrPbu3cvb7/9NmAWTTfddBMvvfQS/fv3d9ytCgwMJDw83GPfR6OVnw8vvmiG1+bnO8fDw+HBB+Hee5XDJCIiIiJSCx4tnK699loOHjzIE088QVZWFikpKSxYsIDOnTsDkJWV5ZLp9Prrr1NeXs6dd97JnXfe6RgfN24cc+fObejpN16lpfDaa/DXv8L+/c7xgAC45x4zwFY5TCIiIiIitebx5hB33HEHd9xxx3GPHVsMLV682P0TaspsNnjnHXj8cagaIuztDRMnwrRp0KGD5+YnIiIiItJEebxwknpgGPDZZ2Z47caNrseuu84Mr01M9MjURERERESaAxVOTd3ChTB1Kvz8s+v4qFHmVr0+fTwzLxERERGRZkSFU1P166/w8MNwTFdCBg6EmTPhvPM8My8RERERkWbIY+3I5RRt3gxXXw1nneVaNKWkwBdfwPLlKppEREREROqZ7jg1FScKr42LgyefhOuvVw6TiIiIiIibqHBq7A4cMLfe/etfZpvxSlFRZpe8W28FPz/PzU9EREREpAVQ4dRYnSi8NizMzGFSeK2IiIiISINR4eRJNhuWJUvosHQpluBgGDoUysvh9dfhqacUXisiIiIi0kiocPKU+fPh3nvx2bOHfgAvvACtW4OPj2vBpPBaERERERGPU+HkCfPnw1VXmcG1VR0+7Pr62mvNxg8KrxURERER8SgVTg3NZjOfTzq2aKoqIACWLYN+/RpuXiIiIiIickLKcWpoy5bBnj0nP6ekBAoKGmY+IiIiIiJSIxVODS0rq37PExERERERt1Ph1NBiYur3PBERERERcTsVTg1t8GDo2BEsluMft1ggNtY8T0REREREGgUVTg3N2xteesn8/bHFU+XrWbPM80REREREpFFQ4eQJo0fDJ59Uz2Xq2NEcHz3aM/MSEREREZHjUjtyTxk9Gi6/nPJFi1jzzTecMWoUPkOH6k6TiIiIiEgjpMLJk7y9MYYMYW9hIb2HDFHRJCIiIiLSSGmrnoiIiIiISA1UOImIiIiIiNRAhZOIiIiIiEgNVDiJiIiIiIjUQIWTiIiIiIhIDVQ4iYiIiIiI1ECFk4iIiIiISA1UOImIiIiIiNRAhZOIiIiIiEgNVDiJiIiIiIjUQIWTiIiIiIhIDVQ4iYiIiIiI1ECFk4iIiIiISA18PD2BhmYYBgB5eXkenonJarVSVFREXl4evr6+np5Os6P1dS+tr3tpfd1L6+teWl/30vq6l9bXvRrT+lbWBJU1wsm0uMIpPz8fgNjYWA/PREREREREGoP8/HzCw8NPeo7FqE151YzY7Xb27dtHaGgoFovF09MhLy+P2NhYdu/eTVhYmKen0+xofd1L6+teWl/30vq6l9bXvbS+7qX1da/GtL6GYZCfn0/79u3x8jr5U0wt7o6Tl5cXHTt29PQ0qgkLC/P4hdOcaX3dS+vrXlpf99L6upfW1720vu6l9XWvxrK+Nd1pqqTmECIiIiIiIjVQ4SQiIiIiIlIDFU4e5u/vz+OPP46/v7+np9IsaX3dS+vrXlpf99L6upfW1720vu6l9XWvprq+La45hIiIiIiISF3pjpOIiIiIiEgNVDiJiIiIiIjUQIWTiIiIiIhIDVQ4iYiIiIiI1ECFkxstXbqUyy67jPbt22OxWPjss89qfM+SJUvo27cvAQEBxMfH89prr7l/ok1UXdd38eLFWCyWar82b97cMBNuYmbOnMlZZ51FaGgokZGR/PGPfyQ9Pb3G9+karp1TWV9dw7X36quv0qtXL0e44oABA/jmm29O+h5du7VX1/XVtXt6Zs6cicVi4b777jvpebqGT01t1lfXcO1Nnz692jpFR0ef9D1N5dpV4eRGhYWF9O7dm5dffrlW52/fvp2LL76YwYMHs3r1ah5++GHuuece5s2b5+aZNk11Xd9K6enpZGVlOX4lJia6aYZN25IlS7jzzjv56aefSEtLo7y8nJEjR1JYWHjC9+garr1TWd9KuoZr1rFjR5555hl+/fVXfv31V4YNG8bll1/Ohg0bjnu+rt26qev6VtK1W3e//PILb7zxBr169TrpebqGT01t17eSruHa6dmzp8s6rVu37oTnNqlr15AGARiffvrpSc958MEHjW7durmMTZo0yejfv78bZ9Y81GZ9Fy1aZADG4cOHG2ROzU1ubq4BGEuWLDnhObqGT11t1lfX8Olp3bq18e9///u4x3Ttnr6Tra+u3VOTn59vJCYmGmlpacaQIUOMe++994Tn6hquu7qsr67h2nv88ceN3r171/r8pnTt6o5TI/Ljjz8ycuRIl7ELL7yQX3/9FavV6qFZNT99+vQhJiaG4cOHs2jRIk9Pp8k4evQoAG3atDnhObqGT11t1reSruG6sdlsfPjhhxQWFjJgwIDjnqNr99TVZn0r6dqtmzvvvJNLLrmECy64oMZzdQ3XXV3Wt5Ku4drJyMigffv2dOnSheuuu47MzMwTntuUrl0fT09AnLKzs4mKinIZi4qKory8nAMHDhATE+OhmTUPMTExvPHGG/Tt25fS0lLeeecdhg8fzuLFiznvvPM8Pb1GzTAMJk+ezLnnnktKSsoJz9M1fGpqu766hutm3bp1DBgwgJKSEkJCQvj000/p0aPHcc/VtVt3dVlfXbt19+GHH/Lbb7/xyy+/1Op8XcN1U9f11TVce+eccw5vv/02SUlJ5OTk8NRTTzFw4EA2bNhA27Ztq53flK5dFU6NjMVicXltGMZxx6XukpOTSU5OdrweMGAAu3fv5vnnn9cfejW46667WLt2LcuXL6/xXF3DdVfb9dU1XDfJycmsWbOGI0eOMG/ePMaNG8eSJUtO+MO9rt26qcv66tqtm927d3Pvvffy3XffERAQUOv36RqunVNZX13DtTdq1CjH71NTUxkwYAAJCQm89dZbTJ48+bjvaSrXrrbqNSLR0dFkZ2e7jOXm5uLj43PcCl1OX//+/cnIyPD0NBq1u+++my+++IJFixbRsWPHk56ra7ju6rK+x6Nr+MT8/Pzo2rUr/fr1Y+bMmfTu3ZuXXnrpuOfq2q27uqzv8ejaPbFVq1aRm5tL37598fHxwcfHhyVLlvCPf/wDHx8fbDZbtffoGq69U1nf49E1XDvBwcGkpqaecK2a0rWrO06NyIABA/jyyy9dxr777jv69euHr6+vh2bVvK1evbpR3QJuTAzD4O677+bTTz9l8eLFdOnSpcb36BquvVNZ3+PRNVx7hmFQWlp63GO6dk/fydb3eHTtntjw4cOrdSG75ZZb6NatGw899BDe3t7V3qNruPZOZX2PR9dw7ZSWlrJp0yYGDx583ONN6tr1UFOKFiE/P99YvXq1sXr1agMwXnjhBWP16tXGzp07DcMwjClTphhjx451nJ+ZmWkEBQUZf/7zn42NGzcas2fPNnx9fY1PPvnEU99Co1bX9X3xxReNTz/91NiyZYuxfv16Y8qUKQZgzJs3z1PfQqN2++23G+Hh4cbixYuNrKwsx6+ioiLHObqGT92prK+u4dqbOnWqsXTpUmP79u3G2rVrjYcfftjw8vIyvvvuO8MwdO2errqur67d03ds1zddw/WrpvXVNVx7f/nLX4zFixcbmZmZxk8//WRceumlRmhoqLFjxw7DMJr2tavCyY0qW1ce+2vcuHGGYRjGuHHjjCFDhri8Z/HixUafPn0MPz8/Iy4uznj11VcbfuJNRF3X929/+5uRkJBgBAQEGK1btzbOPfdc4+uvv/bM5JuA460tYMyZM8dxjq7hU3cq66truPbGjx9vdO7c2fDz8zPatWtnDB8+3PFDvWHo2j1ddV1fXbun79gf7HUN16+a1lfXcO1de+21RkxMjOHr62u0b9/eGD16tLFhwwbH8aZ87VoMo+LpKxERERERETkuNYcQERERERGpgQonERERERGRGqhwEhERERERqYEKJxERERERkRqocBIREREREamBCicREREREZEaqHASERERERGpgQonERERERGRGqhwEhERERERqYEKJxERaZJyc3OZNGkSnTp1wt/fn+joaC688EJ+/PFHACwWC5999lmdPzcuLo5Zs2bV72RFRKTJ8/H0BERERE7FlVdeidVq5a233iI+Pp6cnBx++OEHDh065OmpiYhIM2QxDMPw9CRERETq4siRI7Ru3ZrFixczZMiQasfj4uLYuXOn43Xnzp3ZsWMH27ZtY/Lkyfz0008UFhbSvXt3Zs6cyQUXXADA+eefz5IlS1w+q/KvyZUrVzJlyhR++eUXIiIiuOKKK5g5cybBwcFu/E5FRKSx0FY9ERFpckJCQggJCeGzzz6jtLS02vFffvkFgDlz5pCVleV4XVBQwMUXX8z333/P6tWrufDCC7nsssvYtWsXAPPnz6djx4488cQTZGVlkZWVBcC6deu48MILGT16NGvXruWjjz5i+fLl3HXXXQ30HYuIiKfpjpOIiDRJ8+bN49Zbb6W4uJgzzzyTIUOGcN1119GrVy/AfMbp008/5Y9//ONJP6dnz57cfvvtjiIoLi6O++67j/vuu89xzk033URgYCCvv/66Y2z58uUMGTKEwsJCAgIC6v37ExGRxkV3nEREpEm68sor2bdvH1988QUXXnghixcv5swzz2Tu3LknfE9hYSEPPvggPXr0oFWrVoSEhLB582bHHacTWbVqFXPnznXc6QoJCeHCCy/Ebrezffv2ev7ORESkMVJzCBERabICAgIYMWIEI0aM4LHHHmPixIk8/vjj3Hzzzcc9/4EHHuDbb7/l+eefp2vXrgQGBnLVVVdRVlZ20q9jt9uZNGkS99xzT7VjnTp1qo9vRUREGjkVTiIi0mz06NHD0YLc19cXm83mcnzZsmXcfPPNXHHFFYD5zNOOHTtczvHz86v2vjPPPJMNGzbQtWtXt81dREQaN23VExGRJufgwYMMGzaMd999l7Vr17J9+3Y+/vhjnn32WS6//HLAfFbphx9+IDs7m8OHDwPQtWtX5s+fz5o1a/j9998ZM2YMdrvd5bPj4uJYunQpe/fu5cCBAwA89NBD/Pjjj9x5552sWbOGjIwMvvjiC+6+++6G/cZFRMRjVDiJiEiTExISwjnnnMOLL77IeeedR0pKCtOmTePWW2/l5ZdfBuDvf/87aWlpxMbG0qdPHwBefPFFWrduzcCBA7nsssu48MILOfPMM10++4knnmDHjh0kJCTQrl07AHr16sWSJUvIyMhg8ODB9OnTh2nTphETE9Ow37iIiHiMuuqJiIiIiIjUQHecREREREREaqDCSUREREREpAYqnERERERERGqgwklERERERKQGKpxERERERERqoMJJRERERESkBiqcREREREREaqDCSUREREREpAYqnERERERERGqgwklERERERKQGKpxERERERERq8P/D5ue7UQ+dJgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "最终学到的参数 w: [0.177 0.888]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# --- 1. 定义环境 ---\n", + "def step(state):\n", + " # 随机向左或向右走\n", + " action = np.random.choice([-1, 1])\n", + " next_state = state + action\n", + " # 到达最右侧(6)奖励为1，其余为0\n", + " reward = 1.0 if next_state == 6 else 0.0\n", + " done = next_state == 0 or next_state == 6\n", + " return next_state, reward, done\n", + "\n", + "# --- 2. 定义特征提取器 (Feature Extractor) ---\n", + "# 对应书中公式：phi(s) = [1, x]^T\n", + "def get_features(state):\n", + " # 将状态归一化到 [0, 1] 之间，这是机器学习的好习惯\n", + " norm_s = state / 6.0\n", + " return np.array([1.0, norm_s])\n", + "\n", + "# --- 3. 运行 TD-Linear 算法 ---\n", + "# 初始化参数 w 为 0 (只有两个参数！不管走廊有多长，都只需要2个参数)\n", + "w = np.zeros(2) \n", + "alpha = 0.1 # 学习率\n", + "gamma = 1.0 # 无折扣\n", + "\n", + "# 记录每个 episode 后的状态价值，用于画图\n", + "history_v = []\n", + "\n", + "num_episodes = 200\n", + "for ep in range(num_episodes):\n", + " state = 3 # 从中间开始\n", + " while True:\n", + " next_state, reward, done = step(state)\n", + " \n", + " # 提取当前状态和下一个状态的特征 phi\n", + " phi_t = get_features(state)\n", + " phi_next = get_features(next_state)\n", + " \n", + " # 计算当前的预测价值 v = w^T * phi \n", + " v_t = np.dot(w, phi_t)\n", + " # 如果游戏结束，下一个状态的价值必定是 0\n", + " v_next = 0.0 if done else np.dot(w, phi_next)\n", + " \n", + " # 计算 TD 误差\n", + " td_target = reward + gamma * v_next\n", + " td_error = td_target - v_t\n", + " \n", + " # 核心：使用 TD-Linear 公式更新参数 w\n", + " # w_{t+1} = w_t + alpha * (TD_target - v_t) * phi(s_t)\n", + " w = w + alpha * td_error * phi_t\n", + " \n", + " state = next_state\n", + " if done:\n", + " break\n", + " \n", + " # 每局结束后，把当前 w 眼中的“所有状态价值”记录下来\n", + " current_estimated_v = [np.dot(w, get_features(s)) for s in range(1, 6)]\n", + " history_v.append(current_estimated_v)\n", + "\n", + "# --- 4. 可视化学习过程 ---\n", + "true_values = [1/6, 2/6, 3/6, 4/6, 5/6]\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(range(1, 6), true_values, 'r-o', linewidth=2, label='True Values')\n", + "\n", + "# 画出第 10, 50, 199 局的拟合结果\n", + "for ep in [10, 50, 199]:\n", + " plt.plot(range(1, 6), history_v[ep], '--', label=f'Estimated Values @ Ep {ep}')\n", + "\n", + "plt.title('TD-Linear: Learning State Values with a Straight Line')\n", + "plt.xlabel('State')\n", + "plt.ylabel('Value Estimate')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "print(f\"最终学到的参数 w: {np.round(w, 3)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0da2810e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "开始训练 DQN，让神经网络去感受陷阱和宝箱...\n", + "训练完成！\n", + "\n", + "--- 揭晓神经网络眼中的 Q 值 ---\n", + "状态 0: Q(向左)= 0.34, Q(向右)= 0.13 => 最优决策: 向左\n", + "状态 1: Q(向左)= 0.32, Q(向右)= -3.04 => 最优决策: 向左\n", + "状态 2: Q(向左)= -2.48, Q(向右)= 8.08 => 最优决策: 向右\n", + "状态 3: Q(向左)= -0.92, Q(向右)= 8.95 => 最优决策: 向右\n", + "状态 4: Q(向左)= 4.09, Q(向右)= 9.81 => 最优决策: 向右\n", + "状态 5: Q(向左)= 9.18, Q(向右)= 10.66 => 最优决策: 向右\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import numpy as np\n", + "import random\n", + "from collections import deque\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# --- 1. 定义非线性环境 ---\n", + "class NonLinearCorridor:\n", + " def __init__(self):\n", + " self.state = 0\n", + " def step(self, action):\n", + " # action: 0向左, 1向右\n", + " move = -1 if action == 0 else 1\n", + " self.state = max(0, min(5, self.state + move))\n", + " \n", + " # 奖励机制：状态 5 是宝箱，状态 2 是陷阱\n", + " if self.state == 5:\n", + " return self.state, 10.0, True\n", + " elif self.state == 2:\n", + " return self.state, -10.0, False\n", + " else:\n", + " return self.state, 0.0, False\n", + " def reset(self):\n", + " self.state = 0\n", + " return self.state\n", + "\n", + "# --- 2. 定义神经网络 Q-Network ---\n", + "# 输入是状态(1维)，隐藏层提取非线性特征，输出是2个动作的Q值\n", + "class QNetwork(nn.Module):\n", + " def __init__(self):\n", + " super(QNetwork, self).__init__()\n", + " # 浅层网络足以解决简单的网格世界问题\n", + " self.fc1 = nn.Linear(1, 16)\n", + " self.relu = nn.ReLU()\n", + " self.fc2 = nn.Linear(16, 2)\n", + "\n", + " def forward(self, x):\n", + " x = self.relu(self.fc1(x))\n", + " return self.fc2(x)\n", + "\n", + "# --- 3. 经验回放缓冲区 (Experience Replay)---\n", + "class ReplayBuffer:\n", + " def __init__(self, capacity=1000):\n", + " self.buffer = deque(maxlen=capacity)\n", + " def add(self, state, action, reward, next_state, done):\n", + " self.buffer.append((state, action, reward, next_state, done))\n", + " def sample(self, batch_size):\n", + " # 均匀随机抽样，打破数据的时间相关性\n", + " return random.sample(self.buffer, batch_size)\n", + " def __len__(self):\n", + " return len(self.buffer)\n", + "\n", + "# --- 4. DQN 核心训练逻辑 ---\n", + "env = NonLinearCorridor()\n", + "\n", + "# 初始化主网络和目标网络，并让它们参数一致\n", + "main_net = QNetwork()\n", + "target_net = QNetwork()\n", + "target_net.load_state_dict(main_net.state_dict())\n", + "\n", + "optimizer = optim.Adam(main_net.parameters(), lr=0.01)\n", + "loss_fn = nn.MSELoss()\n", + "buffer = ReplayBuffer(capacity=2000)\n", + "\n", + "batch_size = 32\n", + "gamma = 0.9\n", + "epsilon = 0.3 # 探索率\n", + "update_target_every = 20 # 每隔 C 步更新一次目标网络\n", + "\n", + "episodes = 300\n", + "loss_history = []\n", + "step_count = 0\n", + "\n", + "print(\"开始训练 DQN，让神经网络去感受陷阱和宝箱...\")\n", + "\n", + "for ep in range(episodes):\n", + " state = env.reset()\n", + " done = False\n", + " \n", + " while not done:\n", + " step_count += 1\n", + " \n", + " # --- 策略：Epsilon-Greedy ---\n", + " if random.random() < epsilon:\n", + " action = random.choice([0, 1])\n", + " else:\n", + " state_tensor = torch.FloatTensor([[state]])\n", + " with torch.no_grad():\n", + " q_values = main_net(state_tensor)\n", + " action = torch.argmax(q_values).item()\n", + " \n", + " next_state, reward, done = env.step(action)\n", + " \n", + " # 存入经验回放池\n", + " buffer.add(state, action, reward, next_state, done)\n", + " state = next_state\n", + " \n", + " # --- 训练阶段 ---\n", + " if len(buffer) >= batch_size:\n", + " # 1. 抽取 Mini-batch\n", + " batch = buffer.sample(batch_size)\n", + " b_s = torch.FloatTensor([[x[0]] for x in batch])\n", + " b_a = torch.LongTensor([[x[1]] for x in batch])\n", + " b_r = torch.FloatTensor([[x[2]] for x in batch])\n", + " b_ns = torch.FloatTensor([[x[3]] for x in batch])\n", + " b_d = torch.FloatTensor([[x[4]] for x in batch])\n", + " \n", + " # 2. 计算当前 Q 值预测: main_net(S)[A]\n", + " q_pred = main_net(b_s).gather(1, b_a)\n", + " \n", + " # 3. 计算目标 Q 值 (使用 Target Network)\n", + " # y_T = R + gamma * max_a Q_target(S', a)\n", + " with torch.no_grad():\n", + " max_q_next = target_net(b_ns).max(1, keepdim=True)[0]\n", + " q_target = b_r + gamma * max_q_next * (1 - b_d)\n", + " \n", + " # 4. 反向传播更新网络\n", + " loss = loss_fn(q_pred, q_target)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " loss_history.append(loss.item())\n", + " \n", + " # 5. 定期同步目标网络\n", + " if step_count % update_target_every == 0:\n", + " target_net.load_state_dict(main_net.state_dict())\n", + "\n", + "print(\"训练完成！\")\n", + "\n", + "# --- 5. 验证神经网络学到了什么 ---\n", + "print(\"\\n--- 揭晓神经网络眼中的 Q 值 ---\")\n", + "states_to_test = torch.FloatTensor([[s] for s in range(6)])\n", + "with torch.no_grad():\n", + " learned_q = main_net(states_to_test).numpy()\n", + "\n", + "for s in range(6):\n", + " q_left, q_right = learned_q[s]\n", + " best_act = \"向左\" if q_left > q_right else \"向右\"\n", + " print(f\"状态 {s}: Q(向左)={q_left:6.2f}, Q(向右)={q_right:6.2f} => 最优决策: {best_act}\")\n", + "\n", + "# 画出 Loss 曲线 (证明它在收敛)\n", + "plt.plot(loss_history)\n", + "plt.title(\"DQN Training Loss\")\n", + "plt.xlabel(\"Training Steps\")\n", + "plt.ylabel(\"Loss (MSE)\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "GymRL", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}