From 2537436fb78fd930819c3bb580dcde91d55459a1 Mon Sep 17 00:00:00 2001 From: Hongru Date: Sat, 28 Feb 2026 00:18:43 +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 | 302 +++++++++++++++++++++++++++++++++++++++++++++ Notebooks/C6.ipynb | 246 ++++++++++++++++++++++++++++++++++++ Notebooks/C7.ipynb | 281 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 829 insertions(+) create mode 100644 Notebooks/C5.ipynb create mode 100644 Notebooks/C6.ipynb create mode 100644 Notebooks/C7.ipynb diff --git a/Notebooks/C5.ipynb b/Notebooks/C5.ipynb new file mode 100644 index 0000000..33954d5 --- /dev/null +++ b/Notebooks/C5.ipynb @@ -0,0 +1,302 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e0ac366f", + "metadata": {}, + "source": [ + "# 第 5 章:蒙特卡洛方法 (Monte Carlo Methods)\n", + "\n", + "## 1. 什么是蒙特卡洛 (MC)?\n", + "当智能体不知道环境的运作规律(无模型,Model-Free)时,它只能通过与环境真实交互来学习。\n", + "蒙特卡洛方法的核心思想是:**“大数定律”**。既然我算不出某个状态的理论预期价值,那我就从这个状态出发,亲自跑几十次、几百次完整的**回合(Episode)**,然后把实际得到的**回报(Return, $G_t$)取平均值**。跑的次数越多,平均值就越接近真实的价值。\n", + "\n", + "## 2. 核心特征\n", + "* **必须是分步的(Episodic)**:蒙特卡洛必须等一个完整的回合(比如一局游戏)彻底结束后,才能从后往前计算总回报并更新价值。\n", + "* **计算动作价值 $q(s,a)$**:因为没有模型,光知道状态价值 $v(s)$ 没用了(你不知道选哪个动作能进入好状态)。因此,MC 直接估计**动作价值 $q(s,a)$**。\n", + "\n", + "## 3. 探索与利用 ($\\epsilon$-Greedy 策略)\n", + "既然要靠“试错”来积累经验,智能体就绝不能总是死盯着当前看起来最好的动作(利用 Exploitation),它必须保留一定的概率去尝试其他动作(探索 Exploration)。\n", + "**$\\epsilon$-贪心($\\epsilon$-Greedy)策略**:\n", + "* 以 $1 - \\epsilon$ 的概率选择当前 Q 值最大的最佳动作。\n", + "* 以 $\\epsilon$ 的概率在所有动作中**随机盲选**(这就是探索!)。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "11448339", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import random\n", + "from collections import defaultdict\n", + "\n", + "# 1. 简单的 1D 走廊环境 (黑盒)\n", + "# 状态: 0, 1, 2, 3 (3 是目标宝箱)\n", + "# 动作: 0 (向左), 1 (向右)\n", + "def step(state, action):\n", + " if state == 3: # 已经在终点\n", + " return 3, 0, True \n", + " \n", + " if action == 1: # 向右走\n", + " next_state = state + 1\n", + " else: # 向左走\n", + " next_state = max(0, state - 1)\n", + " \n", + " reward = 10 if next_state == 3 else -1\n", + " done = (next_state == 3) # 是否结束回合\n", + " return next_state, reward, done\n", + "\n", + "# 2. 定义 epsilon-greedy 策略\n", + "def epsilon_greedy_policy(state, Q, epsilon, n_actions=2):\n", + " # 以 epsilon 的概率随机探索\n", + " if random.uniform(0, 1) < epsilon:\n", + " return random.choice(range(n_actions))\n", + " # 以 1 - epsilon 的概率贪心利用 (选择 Q 值最大的动作)\n", + " else:\n", + " # 如果 Q 值全是 0,也会默认选第一个,所以用 argmax\n", + " return np.argmax(Q[state])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7ecc277d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== 开始蒙特卡洛控制 (Monte Carlo Control) ===\n", + "完成第 100 个回合训练...\n", + "完成第 200 个回合训练...\n", + "完成第 300 个回合训练...\n", + "完成第 400 个回合训练...\n", + "完成第 500 个回合训练...\n", + "\n", + "--- 训练结束!揭晓学到的 Q 表 ---\n", + "状态 0: 向左 Q=3.44, 向右 Q=5.38 -> 最优动作: 向右\n", + "状态 1: 向左 Q=3.03, 向右 Q=7.49 -> 最优动作: 向右\n", + "状态 2: 向左 Q=5.10, 向右 Q=10.00 -> 最优动作: 向右\n", + "\n", + "结论:即使不知道环境具体规则,智能体仅凭不断试错取平均,也学会了一直向右走才是通关秘籍!\n" + ] + } + ], + "source": [ + "print(\"=== 开始蒙特卡洛控制 (Monte Carlo Control) ===\")\n", + "\n", + "# 初始化 Q 表 (状态数目为4,动作为2)\n", + "# 使用 defaultdict 方便处理没见过的状态\n", + "Q = defaultdict(lambda: np.zeros(2))\n", + "# 用于记录每个 (状态, 动作) 组合被访问了多少次,以及获得的总回报\n", + "returns_sum = defaultdict(float)\n", + "returns_count = defaultdict(float)\n", + "\n", + "num_episodes = 500\n", + "gamma = 0.9\n", + "epsilon = 0.2\n", + "\n", + "for i in range(num_episodes):\n", + " # --- 1. 生成一个完整的回合 (Episode) ---\n", + " episode = []\n", + " state = 0 # 每次都从起点开始\n", + " \n", + " # 智能体开始在黑盒里凭感觉走,直到碰壁或找到宝箱\n", + " while True:\n", + " action = epsilon_greedy_policy(state, Q, epsilon)\n", + " next_state, reward, done = step(state, action)\n", + " \n", + " # 记录下这一步的“经验”: (状态, 动作, 奖励)\n", + " episode.append((state, action, reward))\n", + " state = next_state\n", + " if done:\n", + " break\n", + " \n", + " # --- 2. 回合结束后,从后往前算回报并更新 Q 表 ---\n", + " G = 0.0 # G 代表累计回报 Return\n", + " # 从轨迹的最后一步倒着往前算\n", + " for t in reversed(range(len(episode))):\n", + " state, action, reward = episode[t]\n", + " \n", + " # 计算折扣回报\n", + " G = gamma * G + reward\n", + " \n", + " # First-Visit MC (初次访问蒙特卡洛): \n", + " # 只在回合中首次遇到这个 (状态,动作) 时才更新\n", + " state_action_pairs_before_t = [(x[0], x[1]) for x in episode[:t]]\n", + " if (state, action) not in state_action_pairs_before_t:\n", + " # 记录总回报并计数\n", + " returns_sum[(state, action)] += G\n", + " returns_count[(state, action)] += 1.0\n", + " \n", + " # 平均值法更新 Q 表: Q = sum(G) / count\n", + " Q[state][action] = returns_sum[(state, action)] / returns_count[(state, action)]\n", + "\n", + " # 打印部分训练过程\n", + " if (i + 1) % 100 == 0:\n", + " print(f\"完成第 {i + 1} 个回合训练...\")\n", + "\n", + "print(\"\\n--- 训练结束!揭晓学到的 Q 表 ---\")\n", + "for s in range(3):\n", + " print(f\"状态 {s}: 向左 Q={Q[s][0]:.2f}, 向右 Q={Q[s][1]:.2f} -> 最优动作: {'向右' if np.argmax(Q[s])==1 else '向左'}\")\n", + "\n", + "print(\"\\n结论:即使不知道环境具体规则,智能体仅凭不断试错取平均,也学会了一直向右走才是通关秘籍!\")" + ] + }, + { + "cell_type": "markdown", + "id": "8e92690e", + "metadata": {}, + "source": [ + "加一个小测试,引入$\\epsilon$ 衰减(Epsilon Decay)的机制,并与之前的方法进行对比" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "142b7542", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "from collections import defaultdict\n", + "\n", + "# 1. 简单的 1D 走廊黑盒环境\n", + "def step(state, action):\n", + " if state == 3:\n", + " return 3, 0, True\n", + " if action == 1:\n", + " next_state = state + 1\n", + " else:\n", + " next_state = max(0, state - 1)\n", + " reward = 10 if next_state == 3 else -1\n", + " done = (next_state == 3)\n", + " return next_state, reward, done\n", + "\n", + "# 2. epsilon-greedy 策略\n", + "def epsilon_greedy_policy(state, Q, epsilon, n_actions=2):\n", + " if random.uniform(0, 1) < epsilon:\n", + " return random.choice(range(n_actions))\n", + " else:\n", + " return np.argmax(Q[state])\n", + "\n", + "# 3. 封装好的蒙特卡洛控制算法\n", + "def run_mc_control(num_episodes, gamma, initial_epsilon, decay_epsilon=False):\n", + " Q = defaultdict(lambda: np.zeros(2))\n", + " returns_sum = defaultdict(float)\n", + " returns_count = defaultdict(float)\n", + " episode_returns = [] # 记录每一局的最终回报,用来画图\n", + "\n", + " # 循环执行多次回合\n", + " for i in range(num_episodes):\n", + " \n", + " # --- 【彩蛋核心逻辑:Epsilon 衰减】 ---\n", + " # 如果开启衰减,每一局的 epsilon 都会按照比例减小,但最低不低于 0.01\n", + " if decay_epsilon:\n", + " epsilon = max(0.01, initial_epsilon * (1 - i / num_episodes))\n", + " else:\n", + " epsilon = initial_epsilon\n", + " \n", + " episode = []\n", + " state = 0\n", + " episode_return = 0\n", + " \n", + " # 跑完一个完整的回合\n", + " while True:\n", + " action = epsilon_greedy_policy(state, Q, epsilon)\n", + " next_state, reward, done = step(state, action)\n", + " episode.append((state, action, reward))\n", + " episode_return += reward\n", + " state = next_state\n", + " if done: break\n", + " \n", + " episode_returns.append(episode_return)\n", + " \n", + " # 从最后一步倒算回报并更新 Q 表 (初次访问 MC)\n", + " G = 0.0\n", + " for t in reversed(range(len(episode))):\n", + " s, a, r = episode[t]\n", + " G = gamma * G + r\n", + " \n", + " # 检查是否初次访问\n", + " is_first_visit = True\n", + " for prev_t in range(t):\n", + " if episode[prev_t][0] == s and episode[prev_t][1] == a:\n", + " is_first_visit = False\n", + " break\n", + " \n", + " if is_first_visit:\n", + " returns_sum[(s, a)] += G\n", + " returns_count[(s, a)] += 1.0\n", + " Q[s][a] = returns_sum[(s, a)] / returns_count[(s, a)]\n", + " \n", + " return episode_returns\n", + "\n", + "# --- 4. 运行对比实验并绘图 ---\n", + "num_episodes = 500\n", + "gamma = 0.9\n", + "\n", + "# 实验一:恒定 epsilon = 0.2\n", + "returns_const = run_mc_control(num_episodes, gamma, initial_epsilon=0.2, decay_epsilon=False)\n", + "\n", + "# 实验二:衰减 epsilon (初始值大胆设为 0.5,慢慢降到 0.01)\n", + "returns_decay = run_mc_control(num_episodes, gamma, initial_epsilon=0.5, decay_epsilon=True)\n", + "\n", + "# 计算滑动平均 (平滑曲线,看起来更直观)\n", + "def moving_average(a, n=20):\n", + " ret = np.cumsum(a, dtype=float)\n", + " ret[n:] = ret[n:] - ret[:-n]\n", + " return ret[n - 1:] / n\n", + "\n", + "# 绘图\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(moving_average(returns_const), label='Constant Epsilon (0.2)')\n", + "plt.plot(moving_average(returns_decay), label='Decaying Epsilon (0.5 -> 0.01)')\n", + "plt.title('Monte Carlo Control: Constant vs Decaying Epsilon')\n", + "plt.xlabel('Episodes (Smoothed over 20 episodes)')\n", + "plt.ylabel('Average Return per Episode')\n", + "plt.legend()\n", + "plt.grid(True)\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 +} diff --git a/Notebooks/C6.ipynb b/Notebooks/C6.ipynb new file mode 100644 index 0000000..c4406c2 --- /dev/null +++ b/Notebooks/C6.ipynb @@ -0,0 +1,246 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f2aa1842", + "metadata": {}, + "source": [ + "# 第 6 章:随机近似 (Stochastic Approximation)\n", + "\n", + "在学习 TD 算法之前,我们必须掌握如何“增量式”地更新数据。\n", + "\n", + "## 1. 增量式均值估计 (Incremental Mean Estimation)\n", + "求均值不必等所有数据到齐。如果我们依次收到数据 $x_k$,我们可以通过以下公式不断更新当前的均值估计 $w_{k+1}$:\n", + "$$w_{k+1} = w_k - \\alpha_k (w_k - x_k)$$\n", + "\n", + "## 2. Robbins-Monro (RM) 算法\n", + "当我们想解方程 $g(w) = 0$,但我们不知道 $g(w)$ 的具体表达式,且每次观测到的结果都有随机噪声时(即观测值为 $\\tilde{g}(w_k, \\eta_k) = g(w_k) + \\eta_k$),我们可以使用 RM 算法:\n", + "$$w_{k+1} = w_k - a_k \\tilde{g}(w_k, \\eta_k)$$\n", + "\n", + "**收敛的魔法条件**:\n", + "步长 $a_k$ 必须满足 $\\sum a_k = \\infty$(不能衰减太快,保证能走到终点)且 $\\sum a_k^2 < \\infty$(最终要衰减到 0,保证能收敛),最经典的步长就是 $a_k = 1/k$。\n", + "\n", + "## 3. 随机梯度下降 (SGD)\n", + "大名鼎鼎的 SGD 其实就是 RM 算法的特例\n", + "SGD 用于最小化目标函数 $J(w) = \\mathbb{E}[f(w, X)]$。它无需计算真实的期望梯度,而是直接使用单个样本的随机梯度来更新:\n", + "$$w_{k+1} = w_k - \\alpha_k \\nabla_w f(w_k, x_k)$$" + ] + }, + { + "cell_type": "markdown", + "id": "34f1c8c7", + "metadata": {}, + "source": [ + "增量式均值估计 vs 传统均值估计" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "50d3faaa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 传统方法 (非增量式) ---\n", + "一次性求平均结果: 10.0387\n", + "\n", + "--- 增量式均值估计 (Incremental) ---\n", + "收到 10 个样本后的均值估计: 10.8961\n", + "收到 100 个样本后的均值估计: 9.7923\n", + "收到 1000 个样本后的均值估计: 10.0387\n", + "\n", + "结论:增量式更新完美逼近了真实均值,且不需要保存历史样本!\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# 生成 1000 个随机样本,假设它们是某个状态的奖励\n", + "np.random.seed(42)\n", + "samples = np.random.normal(loc=10.0, scale=2.0, size=1000)\n", + "\n", + "print(\"--- 传统方法 (非增量式) ---\")\n", + "true_mean = np.mean(samples)\n", + "print(f\"一次性求平均结果: {true_mean:.4f}\")\n", + "\n", + "print(\"\\n--- 增量式均值估计 (Incremental) ---\")\n", + "w_k = 0.0 # 初始猜测\n", + "for k, x_k in enumerate(samples, start=1):\n", + " alpha_k = 1 / k # 步长 (对应公式 1/k)\n", + " # 核心公式: 新估计 = 老估计 - 步长 * (老估计 - 新样本)\n", + " w_k = w_k - alpha_k * (w_k - x_k)\n", + " \n", + " if k in [10, 100, 1000]:\n", + " print(f\"收到 {k} 个样本后的均值估计: {w_k:.4f}\")\n", + "\n", + "print(\"\\n结论:增量式更新完美逼近了真实均值,且不需要保存历史样本!\")" + ] + }, + { + "cell_type": "markdown", + "id": "b0ac2d46", + "metadata": {}, + "source": [ + "运行一个 Robbins-Monro (RM) 算法" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c2e13c9c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAr8AAAGMCAYAAADTH8pwAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaxRJREFUeJzt3XlcVFX/B/DPsC8K4oYoqLiviYm7iKSgaGaauVTu+jxmi0pq+itzq0xLBXNrUdE0pRS1xQUq3ErNBU3TzJJEEUJcAEFgGM7vj3lmZJiFmWFW+Lxfr3nBnPnOuefOuTN8OXPuuRIhhAARERERURXgYO0GEBERERFZCpNfIiIiIqoymPwSERERUZXB5JeIiIiIqgwmv0RERERUZTD5JSIiIqIqg8kvEREREVUZTH6JiIiIqMpg8ktEREREVQaTXyIiIiKqMpj8EhEREVGVweSXiIjIhowaNQq+vr7w8vLCE088ge+++87aTSKqVCRCCGHtRhAREZHc77//jubNm8PFxQW//vorwsPDcf36ddSqVcvaTSOqFDjyS0REZEPatm0LFxcXAICTkxOKioqQlpZm5VYRVR5MfquQ2NhYSCQS5c3JyQl+fn4YNWoUrl27ZlSdCxcuhEQiQVZWlsliFe38559/jGqTsUq/PocPH1Z7XAiBZs2aQSKRoE+fPhZtm7msXr0aEokE7dq10/i4tfpC1/Z/+eUXLFy4EA8ePFCLN+R4tJSy77vSt1mzZqnFmfK1Vrwe5tyGrdJ1nFRUXFwc2rZtC3d3d0gkEpw/f97k23jxxRfh5uaGTp064amnnkL79u1Nvo3SDh8+rPU4PXnypFm3DQAPHz7EjBkzUL9+fbi5uSEoKAg7d+402/YM+Wyx5c+VqvBeNgcnazeALG/z5s1o1aoVCgoK8PPPP+O9995DUlIS/vjjD/j4+Fi7eRg0aBBOnDgBPz8/q2y/evXq2Lhxo1qCe+TIEfz999+oXr26VdplDps2bQIg/5r11KlT6Nq1q5VbpErTsfDLL79g0aJFGD9+PGrUqGG9xhlI8b4rrX79+srfLXHcW/u9ZUnmOk7u3LmDMWPGYMCAAVi3bh1cXV3RokULk9WvsH37dmzZsgU//fQTrly5ovJPjDm9//77CAsLUynT9s+xKQ0bNgynT5/GBx98gBYtWuDLL7/E6NGjUVJSghdeeMHk27P3z5aq9F42Bya/VVC7du0QHBwMAOjTpw9kMhkWLFiAvXv3YsKECVZuHVCnTh3UqVPHatsfOXIktm/fjrVr18LLy0tZvnHjRnTv3h05OTlWaVd+fj48PDxMVt+ZM2dw4cIFDBo0CN9//z02btxoU8lvfn6+1Y8FUyr9vtPEEvtqi6+nqY9rc/vzzz8hlUrx0ksvITQ01KzbcnJyQkREBFavXo3mzZtj4MCBZt0eADRv3hzdunUz+3ZK279/PxITE5UJLwCEhYXhxo0bmD17NkaOHAlHR0eTbtMW3wuGsPf2WxunPZDyD/K///6rUn78+HH07dsX1atXh4eHB3r06IHvv/9eYx03b97EsGHD4OXlBW9vb7z00ku4c+eOUbGavs5RfO30+++/Y/To0fD29oavry8mTpyI7Oxslfrv3LmD//znPwgICICrqyvq1KmDnj174ocfftDr9VB8+O7YsUNZlp2djd27d2PixIlan6fP66Xvfijizp07h+HDh8PHxwdNmzY1aFvl2bhxIwDggw8+QI8ePbBz507k5+fr9dx9+/bhiSeegKurK5o0aYKYmBi1r9gNaae2/S17LCxcuBCzZ88GAAQGBmqdpvLvv//q9fr+9ttveP755+Ht7Y2aNWsiKioKxcXFuHr1KgYMGIDq1aujcePGWL58ub4vq9E07au+xzwAfP/99wgKCoKrqysCAwPx0UcflbsNY7ajb99rouu4NuSYLi9W3+PE0HrHjx+PXr16AZD/k1zeFKhZs2ahbt26KmVvvPEGJBKJSv9kZGTA1dUVGzZs0FiPTCbDX3/9pbPt9mzPnj2oVq0ann/+eZXyCRMm4Pbt2zh16pTW5/7++++QSCT4+uuvlWVnz56FRCJB27ZtVWKfeeYZdOrUCYDm91t5x0x5nyvaGPoe0+e9oOm9rM/fvmvXruGFF15A3bp14erqitatW2Pt2rXl7kNlw+SXkJKSAgAqX90dOXIETz31FLKzs7Fx40bs2LED1atXx+DBgxEXF6dWx9ChQ9GsWTPs2rULCxcuxN69e9G/f39IpdIKxZb13HPPoUWLFti9ezfmzp2LL7/8EjNnzlSJGTNmDPbu3Yt33nkHCQkJ+Pzzz9GvXz/cvXtXr9fDy8sLw4cPV04JAOSJsIODA0aOHKnxOYa+XvrsByD/KrBZs2b4+uuvlX8YDd2WJo8ePcKOHTvQuXNntGvXDhMnTkRubq7KHxBtDh48iGHDhqFWrVqIi4vD8uXLsWPHDmzZsqVCr4m2/S1t8uTJeO211wAA8fHxOHHiBE6cOIEnn3xSJU7f13fEiBHo0KEDdu/ejSlTpmDVqlWYOXMmnn32WQwaNAh79uzBU089hTfffBPx8fEqzzV07rdMJkNxcbHKTR/67MuPP/6IIUOGoHr16ti5cyc+/PBDfPXVV9i8ebPe7dNnO/r2fXnK9rMhx4o+sfoeJ4bWO3/+fGWi8P777+PEiRNYt26d1jpr1qyp8k3R/fv38emnn8LLywv37t1Tlq9ZswY1atTA+PHjkZGRgd27dyMvLw/FxcX46quvkJSUZPZRZoVXXnkFTk5O8PLyQv/+/XH8+HGd8UIIteNa202bS5cuoXXr1nByUv0y+oknnlA+rk3btm3h5+enkuD98MMPcHd3x+XLl3H79m0AQHFxMY4cOYJ+/fpprEefY0bfzxVt9Hl+RT7fy/vbd/nyZXTu3BmXLl3CihUr8N1332HQoEF4/fXXsWjRIr33o1IQVGVs3rxZABAnT54UUqlU5ObmioMHD4p69eqJ3r17C6lUqozt1q2bqFu3rsjNzVWWFRcXi3bt2gl/f39RUlIihBBiwYIFAoCYOXOmyra2b98uAIht27Ypy/SNVbQzJSVF7bnLly9Xee60adOEm5ubsj1CCFGtWjUxY8YMo1+f06dPi6SkJAFAXLp0SQghROfOncX48eOFEEK0bdtWhIaGqjzX0NervP1QxL3zzjtq7dR3W7ps3bpVABAbNmwQQgiRm5srqlWrJkJCQjS+JqX7onPnziIgIEAUFhYqy3Jzc0WtWrVE6Y8UQ9qpbX81bf/DDz9UKytbj76v74oVK1TigoKCBAARHx+vLJNKpaJOnTpi2LBhKrGOjo7iqaeeUmtDWYp90HQr/Z4ru6+GHPNdu3YV9evXF48ePVKW5eTkiJo1a6r0SUXfW/r2vTba+tmQY0XfWF3HiSb61qv4bPj666/LrXPdunUCgPL1WrRokWjbtq14/vnnxX//+18hhBD5+fmiVq1aYsmSJUIIIdLT00WvXr2El5eX8Pb2FsHBwWLfvn167UNFnDt3TkyfPl3s2bNHHD16VGzatEm0bt1aODo6ioMHD2p9nuL10OemrS+aN28u+vfvr1Z++/ZtAUC8//77Otv+0ksviSZNmijv9+vXT0yZMkX4+PiILVu2CCGE+PnnnwUAkZCQIIQw7LPFkPeIJoY8X9/jUFP7y/vb179/f+Hv7y+ys7NVyl999VXh5uYm7t27p3M/KhOO/FZB3bp1g7OzM6pXr44BAwbAx8cH+/btU/7XnZeXh1OnTmH48OGoVq2a8nmOjo4YM2YMbt26hatXr6rU+eKLL6rcHzFiBJycnJCUlKS2fUNiy3rmmWdU7j/xxBMoKChAZmamsqxLly6IjY3Fu+++i5MnT6qNKJcdjRAalroODQ1F06ZNsWnTJly8eBGnT5/WOuXBmNdLn/0A5CMFFd2WJhs3boS7uztGjRoFAMqvHI8dO6Zz5Y+8vDycOXMGzz77rHIpJsXzBw8eXOF2lt1fY+n7+j799NMq91u3bg2JRILIyEhlmZOTE5o1a4YbN26oxBYXF+PHH3/Uu01bt27F6dOnVW5lR7qM2Ze8vDycPn0aw4YNg5ubmzJOMVqkL322o0/f66N0PxtyrJjq+C/LXPUqTiDOyclBfn4+Pv74Y8yZMwc1atTA/fv3Aci/vi4oKMC0adMAAPXq1cOxY8eQnZ2NBw8e4PTp02p9U5quVRrK3nStStGxY0dER0fj2WefRUhICCZMmIBffvkFfn5+mDNnjtbnderUSe241nYrfYJnWbqmzZQ3paZv3764fv06UlJSUFBQgOPHj2PAgAEICwtDYmIiAPlosKurq3LaijH0/Vwx9vkVPQ51/e0rKCjAjz/+iKFDh8LDw0Plb+DAgQNRUFBgkVU9bAVPeKuCtm7ditatWyM3NxdxcXH45JNPMHr0aBw4cACA/Ks5IYTGs0gVH15lpxDUq1dP5b6TkxNq1aqlcaqBIbFllV3k3dXVFYD8a3yFuLg4vPvuu/j8888xf/58VKtWDUOHDsXy5ctRUFCAwMBAlTqSkpLUvr6WSCSYMGECVq9ejYKCArRo0QIhISEa22TM66XPfgBQq9OYbZX1119/4ejRo3juuecghFAu6zN8+HBs3rwZmzZtwtKlSzU+V7F9X19ftcdKlxnbTlOduazv61uzZk2V+y4uLvDw8FBJIhXlFT3RsXXr1jpPeNOmvH25f/8+SkpK1N5XgPp7raLb0afv9VG6nw05Vkxx/GtirnoVx1dOTg62b98ODw8PvPDCC7h06RJSUlIghEB0dDSmTJmidizqq2XLlvjss8/0im3YsKFBddeoUQNPP/00NmzYgEePHsHd3V0tplq1aggKCtKrPm3/7Gn7/FdMDSnvtVFMZfjhhx8QGBgIqVSKp556Cv/++y+WLFmifKxnz54a90Ff+n6uGPv8ih6Huv72KaZdffzxx/j44481Pt+WlnIzNya/VVDpP8JhYWGQyWT4/PPPsWvXLuVJKA4ODkhPT1d7rmL+VO3atVXKMzIy0KBBA+X94uJi3L17V+MViQyJNUbt2rURHR2N6OhopKam4ptvvsHcuXORmZmJb775BqdPn1aJb9mypcZ6xo8fj3feeQcbNmzAe++9p3V7xrxe+io74mGKbW3atAlCCOzatQu7du1Se3zLli149913NZ5d7ePjA4lEonZyJCDv14q201LLOVUmij4p/foraCqr6HbK63t9lO5nQ44Vc73XzFkvIE/iVq5ciTfeeANOTk7w9vbGvXv38O233+L69esGzRsty8/PD5MnTzb6+eVRfDOm7b155MgRtaXRtElJSUHjxo3Vytu3b48dO3aguLhYJUG+ePEigPKXWvP390eLFi3www8/oHHjxggODkaNGjXQt29fTJs2DadOncLJkydtfl5rRY9DXX/74uPjlSPIr7zyisbnlx0Yqsw47YGwfPly+Pj44J133kFJSQk8PT3RtWtXxMfHq/xHW1JSgm3btik/aErbvn27yv2vvvoKxcXFGk8IMiS2oho2bIhXX30V4eHhOHfuHFxcXBAcHKxy07Zub4MGDTB79mwMHjwY48aN07oNY14vY1V0WzKZDFu2bEHTpk2RlJSkdnvjjTeQnp6u/BZA0/aDg4Oxd+9eFBUVKcsfPnyI7777zmTt1MXQ0ZbKztPTE126dEF8fDwKCgqU5bm5ufj2229Nuh19+t6YevU9VgyJNeQ4Mdfxqkh+169fj7y8PGWSqpj2sHLlSowaNcrgEVlLuX//Pr777jsEBQWpfRuiYIppD0OHDsXDhw+xe/dulfItW7agfv36ei3B2K9fP/z0009ITExEeHg4APlJ3A0bNsQ777wDqVSq9WQ3BWt/tpjyOCz7t8/DwwNhYWFITk7GE088ofZ3MDg4uEpdPpsjvwQfHx/MmzcPc+bMwZdffomXXnoJS5cuRXh4OMLCwjBr1iy4uLhg3bp1uHTpEnbs2KE2ChAfHw8nJyeEh4fj999/x/z589GhQweMGDFCbXuGxBoqOzsbYWFheOGFF9CqVStUr14dp0+fVp6lbqgPPvhArzhDX6+KqMi2Dhw4gNu3b2PZsmUa/9lo164d1qxZg40bN6rNh1VYvHgxBg0ahP79+2P69OmQyWT48MMPUa1aNZUz2M31miiudBUTE4Nx48bB2dkZLVu2tPjFR5ycnBAaGmrQvF9zWbJkCQYMGIDw8HC88cYbkMlkWLZsGTw9PVX6pKL07XtDGXKs6Btr6HFijuNV8XX9li1bMH/+fOV6xt7e3khNTUVKSgouXLhgcL3m8MILL6Bhw4YIDg5G7dq1ce3aNaxYsQL//vsvYmNjtT6vevXqRk3nKS0yMhLh4eF4+eWXkZOTg2bNmmHHjh04ePAgtm3bptcav3379sW6deuQlZWF6OholfLNmzfDx8dHucyZNtqOGUsy9jjU529fTEwMevXqhZCQELz88sto3LgxcnNz8ddff+Hbb7/FTz/9ZMldtSqO/BIA4LXXXkPDhg2xePFiyGQyhIaG4qeffoKnpyfGjx+PUaNGITs7G998843G5b7i4+Pxxx9/YNiwYXjnnXcwePBgJCQkqJwYY0ysodzc3NC1a1d88cUXePHFFxEZGYnPP/8cb775pt7z4oxh6OtlrW1t3LgRLi4uWi9mUrt2bQwdOhTfffedxq+3AWDAgAHYvXs37t69i5EjRyIqKgpDhw7FkCFDVK6KZK7XpE+fPpg3bx6+/fZb9OrVC507d8bZs2eNrs9YMpkMMpnM4tvVJDw8HHv37kVOTo6yT5577jmd61IbQ9++N5Qhx4q+sYYeJ+Y4XmvUqAGJRAI3NzflMlqKcplMhgEDBiiX87K2J554AocOHcLkyZPRr18/vPXWW2jTpg1++eWXckdMTSE+Ph5jxozBO++8gwEDBuDUqVPYsWOH2gnS2jz11FNwcHCAp6cnunfvrixXtD0sLAwODrpTHlv4bDH2ONTnb1+bNm1w7tw5tGvXDm+//TYiIiIwadIk7Nq1C3379rXULtoEidB0qjsRkQGkUimCgoLQoEEDJCQkWLs5ZEHseyKyN5z2QEQGmzRpEsLDw+Hn54eMjAxs2LABV65cQUxMjLWbRmbGvicie8fkl4gMlpubi1mzZuHOnTtwdnbGk08+if3791vk61GyLvY9Edk7TnsgIiIioiqDJ7wRERERUZXB5JeIiIiIqgwmv0RERERUZfCENz2UlJTg9u3bqF69Oi+/SkRERGSDhBDIzc1F/fr1da7rzORXD7dv30ZAQIC1m0FERERE5bh58yb8/f21Ps5pD3pQXA7zJoBsTbfwcGRnZz++ubtrjgOQ3bOnamzNmlpj7wcFqcYGBGivt2VL1diWLbXHBgSoxnbsqD22Zk3V2J49tce6u6vGhodrjwVUY4cM0R17+/bj2NGjdcf+/ffj2MmTdcf+9tvj2Nde0x178uTj2LlzdcbeTUzEl19+iaysLGQvXqy73u++e1zvhx/qjv3qq8ex69bpjo2NfRwbG6s7dt26x7FffaU79sMPH8d+953u2MWLH8f+9JPu2LlzH8eePKk79rXXHsf+9pvu2MmTH8f+/bfu2NGjkZ2djaysLMRt2qQ7dsgQ1WNYV6yZPiOyO3bkZ4TiZmefEdk//fQ4lp8RdvcZkZ2dLT/mdMXyMwLZAB5Y8DPiJuTKu9w9R371oJjq4PW/mxpnZ8DLq/QTtFfm5KQaq2NYvsTREQ56xsLRUbVeXddCd3AwPtZJxyEjkajGOjtrjwUMj/X0lP9e3mWQq1d/XLchsa6uumOrVdM7ttjTEx55efDy8oKzm5vuej09H9fr7q471sPDuFgPD92x7u7GxSr6RBs3t8ex1arpjnV1NS62nA85uLg8ji0s1CtWKpXCw8ND8/tdoez73pBYE31GqL3v+Rkh/90OPiNUYvkZIf/djj4jAOh+XwD8jPgf4eAAiYU/I8qbosp1fvWQk5MDb29vZN++DS9NB7Kjo+qHV16e9socHFQ/kDTESqVSHDp0CP0jI+Fcenv5+YC27pJIVD+QDIl99AgoKdHe5tIfXobEFhQAMplpYj08Hn8YFBYCxcWmiXV3f/xhUFQESKUmiZU6OmL/oUMYOHAgnIXQXa+b2+MPDqlUXrc2rq6PPzgMiS0u1v2h7uLy+IPDkFiZTN532jg7P04uDIktKZEfa6aIdXJ6nIgIIX9vlBMrlUqx//vvMbBPHzhr+/A15H1v4s8IrbH8jJD/XlgI6aNH8s/R/v3V+9AGPiNU3veGxFahzwjl30JFH9rQZ4ResVX8M0Kl/2rU0BmrogKfETn378O7fn1kZ2drztf+hyO/hvD0LP+/WEWcIXWWJZVC5uam/l97ef9tGxtb3uiAsbHljWYYG+vqWv6oijGxLi7ljwLpG1v6D5kh9So+4E0d6+Sk+79tY2MdHfU/3g2JdXAwT6xEYnisvq9xRd/3pojlZ4Scqyvg4CD/HC2vD631GWFsbFX6jFD8LdTUh7b0GaEvW4i15GdE6f4rL1YbQz8j9HwtOOeXiIiIiKoMjvyaiEwmg1TX11YGkEqlcHJyQkFBAWS6hvvJZtlqHzo6OsLJyYlL9hERUZXF5NcEHj58iFu3bsFU06eFEKhXrx5u3rzJJMVO2XIfenh4wM/PDy76fs1KRERUiTD5rSCZTIZbt27Bw8MDderUMUmiU1JSgocPH6JatWo6F2km22WLfSiEQFFREe7cuYOUlBQ0b97cZtpGRERkKUx+K0gqlUIIgTp16sDdkEncOpSUlKCoqAhubm5MTuyUrfahu7s7nJ2dcePGDWX7iIjI/shkwLFjQHo64OcHhITIzxnUVA7oH2uKOgDgyBEJjh5tAE9PCcLCyl8ZzpKY/JqIrX21TaSNLSXjRET2xhaSzn37gOnTgVu3HrfL3x8YPRrYsUO1vFYt+c+7d8uPNUUdj2OdAARj5Up5bEwMMGyYUS+5yTH5JSIiIqvQlQSWHTkELDt6qak8KwuYOdO6SWetWqr3FW7dAj78UL3ckFhT1KEpNi0NGD4c2LXLNhJgJr9ERESVmK18DW746OXjkUNLj15qK9fE0kmnpjJbJ4R8WeQZM4AhQ6w/BYLJLxERkYUYklyaIunUlGBa72tw1TJbHr3UVk7GEwK4eVN+jPbpY922MPklKuPu3bto3bo1fv31VzRu3NjazTHIrFmzUFRUhNWrV1u7KUR2wZLJqCFfmZsq6dR35NDSX4Pb4+glmUZ6urVbAEBQubKzswUAkZ2drfbYo0ePxOXLl8WjR49Mtj2ZTCbu378vZDKZyeosDYDO27hx48yyXU3GjRun3K6jo6MICAgQU6dOFffu3TP5doYMGaJX7BtvvCEmTpxo9LYuXbokhg4dKgICAgQAsWrVqnKfs2DBAo194eHhoYy5ffu2GD16tGjRooWQSCRi+vTpavX8+++/olq1auL69etat2WOY7ayKSoqEnv37hVFRUXWbkqVU1wsRFKSEF9+Kf9ZXKy9XFdsYqJUREWdFomJUq11fP21EP7+QsjHpOQ3f38hZs/Wv7xWLflNn1jeeONN/t4zF135Wmkc+TWXvDztjzk6ql6vumxsSYm8zNFRfv300kuoaavXgGt7p5f6tysuLg7vvPMOrl69qiwru2SbVCqFs77XhzfCgAEDsHnzZhQXF+Py5cuYOHEiHjx4gB07dphtm9o8evQIGzduxP79+42uIz8/H02aNMGgQYPw9ttv6/WcWbNmYerUqSplffv2RefOnZX3CwsLUadOHbz11ltYtWqVxnrq1q2LiIgIbNiwAcuWLTN6H4iMYVtnsKueaV7R+ZumGAElqsokEvl7UfH+tyrz5d+Vh1Ejv7r+7Rk4UDXWw0N7bGioamzt2prjjLR582bh7e2tvJ+SkiIAiLi4OBEaGipcXV3Fpk2bxIIFC0SHDh1Unrtq1SrRqFEjlbJNmzaJVq1aCVdXV9GyZUuxdu1andvXNCIbFRUlatasqbwvk8nEokWLRIMGDYSLi4vo0KGDOHDggMpzfvvtNxEWFibc3NxEzZo1xZQpU0Rubq4QQvOoapKWfz13794tateurbPN+lCM3jdq1Eivkd+yzp8/LwCIo0ePanw8NDRU48ivEELExsaKgIAArXVz5Ld8lWXk15BR1IrWYcgoqqbR0rL3eeONt8pzk0jkt927zfd5JwRHfqmC3nzzTaxYsQKbN2+Gq6srPv3003Kf89lnn2HBggVYs2YNOnbsiOTkZEyZMgWenp4YN26cXtu9fv06Dh48qDLSHBMTgxUrVuCTTz5Bx44dsWnTJjzzzDP4/fff0bx5c+Tn52PAgAHo1q0bTp8+jczMTEyePBmvvvoqYmNjMWvWLFy5cgU5OTnYvHkzAKBmzZoat3/06FEEBwfr1dbSSkpKTLp+7ueff44WLVogxIh/kbt06YKbN2/ixo0baNSokcnaRLbBHKOo/v7AypVAnTrG16EJ54ASmZ5EIk8py87pDggARo3S71sSbbGmqEPbtzLR0baxzBnAE97M5+FD7Y+VXeMjM1PlbklJCXJycuDl5QUHpzJd9M8/pmlfOWbMmIFhBh6lS5YswYoVK5TPCwwMxOXLl/HJJ5/oTH6/++47VKtWDTKZDAUFBQCAlStXKh//6KOP8Oabb2LUqFEAgGXLliEpKQnR0dFYu3Yttm/fjkePHmHr1q3w/N/0jzVr1mDw4MFYtmwZfH194e7ujsLCQtSrV0/nPvzzzz+oX7++WvlPP/2EZcuW4cKFC2jUqBFGjRqFUaNGwdfXFwcOHMChQ4dMdpJZYWEhtm/fjrlz5xr1/AYNGgCQ7wuTX9tnyFQBfc/cN/RM+lu3gBEjVMsMrYOoqrJ00qlIJIcM0fzZsXSp/idlaoo1RR0AkJRUjAMHziMyMghhYU5WX96sNCa/5mLAHFy12JIS+V8+T0+g7GiiIfVWgKGjn3fu3MHNmzcxadIkTJkyRVleXFwMb29vnc8NCwvD+vXrkZ+fj88//xx//vknXnvtNQBATk4Obt++jZ49e6o8p2fPnrhw4QIA4MqVK+jQoYMy8VU8XlJSgqtXr8LX11fv/Xj06JHGS/5OmTIFS5YsQfv27XH69Gl88cUXmDVrFhwcHNCmTRusWbNG722UJz4+Hrm5uRg7dqxRz1fM2c7PzzdZm8gw5lowX98RU1OMonIklszJ1kcvdZWvWKH+LYk1kk5A85Jhjo6ayw2JNUUdoaECeXlpCA3tYFOJL8Dkl7TwLJNkOzg4QAihUiaVSpW/l5SUAJBPfejatatKnGM5R72npyeaNWsGAFi9ejXCwsKwaNEiLFmyRBlT9vLRQghlWenfyzL0stO1a9fG/fv31crPnj2LGjVqAADat2+PiRMnIicnBzKZDD4+PgZtozyff/45nn766XJHqbW5d+8eAKBOnTqmbFaVpy2hLSs+3nJTBYh00ZZg2tLX4LpGL8uOHAKWHb3UVa6JpZNOMh6TX9JLnTp1kJGRoZJonj9/Xvm4r68vGjRogOvXr+PFF1+s0LYWLFiAyMhIvPzyy6hfvz7q16+P48ePo3fv3sqYX375BV26dAEAtGnTBlu2bEFeXp4yaf/555/h4OCAFi1aAABcXFwgk8nK3XbHjh2xbds2tXJF4lual5eXMbunU0pKCpKSkvDNN98YXcelS5fg7OyMtm3bmrBlVYemy6pqm/saE6P6x/vaNWDhQnnCURqnCpA25kw6dSWYgOW/Bjd09FLTyKGlRy+1lZN9Y/JLeunTpw/u3LmD5cuXY/jw4Th48CAOHDigkgAuXLgQr7/+Ory8vBAZGYnCwkKcOXMG9+/fR1RUlEHbatu2Ld5//32sWbMGs2fPxoIFC9C0aVMEBQVh8+bNOH/+PLZv3w4AePHFF7FgwQKMGzcOCxcuxJ07d/Daa69hzJgxyikPjRs3xqFDh3D16lXUqlUL3t7eGpdv69+/P+bNm4f79+8bPaJbVFSES5cuIS8vD0VFRUhLS8P58+dRrVo15Qj3mjVrsGfPHvz4448qz920aRP8/PwQGRmpsW7FPxwPHz7EnTt3cP78ebi4uKBNmzbKmGPHjiEkJERtybqqzPBpCKqXVdV2rfrnntP+ONknc3+VbshX5qYavQRs42twJpFkM8y76ETlUNkuclGatqXOkpOT1WLXr18vAgIChKenpxg7dqx477331JY62759uwgKChIuLi7Cx8dH9O7dW8THx2vdvraLT2zfvl24uLiI1NRUlaXOnJ2dDV7qTAghMjMzRXh4uKhWrZoAtC91JoQQ3bp1Exs2bND6eHkUr2HZW2ipZesWLFig9trJZDLh7+8v/u///k9r3ZrqLVtPixYtxI4dO7TWYW9LnVX0oge7d+u/BBdv1l0KCVBf8iwgQP/l0rTF6ir/6ivDloMz9GIb+i4pR+oqy5KDVZU1+k/fpc4kQpT9go7KysnJgbe3N7Kzs9W+6i4oKEBKSgoCAwM1nihlDJXVHky4fBbpZ//+/Zg1axYuXbpk9OtvrT78/vvvMXv2bPz2229wKrtSyP+Y45g1lDnmzxqy6gFZhqGjpbrmgBp6WWFNZ5rre9yRbZBKpdi/fz8GDhxo1gstkXlYo/905WulcdoDURkDBw7EtWvXkJaWhoCAAGs3xyB5eXnYvHmz1sTX0vRdrkvTOrNZWfLlt/SdP8u1Yx8z9Ex6U9RhqrPgAdN87a5pvijnbxIRwOSXSKPp06dbuwlGGVF2sVYL0mcZL11rx5ZtuqOjeuJblRly5r6h64BqW3LN0LVETXEWPBGRuTH5JSKD6Duaq4khI7F6LM5RKZnyzH1A/1HUoUNNMxJLRGTrmPyaCKdOk73QdKxW5JK5nFdbPlOe/Q+YZxSVySwRVRVMfitIcQGHoqIiLi1FNk8I4N69fOTmAidPOpvkkrmVPfHVNd3g7t3Hj5eNX7QIaN7c9FMFiIioYpj8VpCTkxM8PDxw584dODs7m+TM/pKSEhQVFaGgoICrPdgpa/ehEEB+PlBUBLi4AB4eQE6OQHp6PrKyMrFjRw1s2uRo8Uvm2iNd0w20nbwXHQ0MG6ZeFxNaIiLrY/JbQRKJBH5+fkhJScGNGzdMUqcQAo8ePYK7u7vBl+cl22DNPszPB+7dU50z6+Agv19UBHzzTQ1s3iy/dHJlT2iNXbHAx0d9mSxAPXEdNkz7CWFERGSbmPyagIuLC5o3b46ioiKT1CeVSnH06FH07t2baxvaKUv2oUwGnD0LZGYCN24Aa9ZoXiVBCCAryxn5+faVmSnWZ1UwZO1YY1cskErVl8nS1T6O5hIR2Q+bSn6PHj2KDz/8EGfPnkV6ejr27NmDZ599Vmv84cOHERYWplZ+5coVtGrVSnl/9+7dmD9/Pv7++280bdoU7733HoYOHWrStjs4OJjsggGOjo4oLi6Gm5sbk187ZY4+rMgqC7ZC20istlhAnuRaeu1YIiKqvGwq+c3Ly0OHDh0wYcIEPPfcc3o/7+rVqypX8qhTp47y9xMnTmDkyJFYsmQJhg4dij179mDEiBE4fvw4unbtatL2E5mLpiud2eMqC9pGYnWtM6tp7izAtWOJiMg4NpX8RkZGIjIy0uDn1a1bFzVq1ND4WHR0NMLDwzFv3jwAwLx583DkyBFER0djx44dFWkukVlouliEpiud2Uriq2terbZlvADD1pklIiIyFZtKfo3VsWNHFBQUoE2bNnj77bdVpkKcOHECM2fOVInv378/oqOjtdZXWFiIwsJC5f2cnBwA8nmcUqnUtI3XQLENS2yLzKNsH8pkwPHjEmVi16uXUM5lLV2elQXMmuWItLTHJ8k5OIj/Jb7mOnFOkVVLdJZJJPJ21KwJ3Lv3uLxBA4EVK2R45hmhcR9LKymR37Tp2VP/WHPie9D+sQ/tH/vQvlmj//Tdll0nv35+fvj000/RqVMnFBYW4osvvkDfvn1x+PBh9O7dGwCQkZEBX19flef5+voiIyNDa71Lly7FokWL1MoTEhLg4eFh2p3QITEx0WLbItORyYDLl2vh/v0GuHjxHHJyXLBpU3vcvft4HehatR4hJOQWjh3zVyl/nHQ+VlJiqqRXe5JbvXoRcnNdlaXVq8tP3ixdVqvWI0yadAlduqT/b//c4ONTgDZt7sLRETh0SB7n5QXk5T2+b8/4HrR/7EP7xz60b5bsv/z8fL3iJMJGL00mkUjKPeFNk8GDB0MikeCbb74BIF+JYcuWLRg9erQyZvv27Zg0aRIKCgo01qFp5DcgIABZWVkqc4vNRSqVIjExEeHh4Tzhzc7s2SNBVJTqyK3ukVVN5aYf4dU2auvvr33UFtA8Wl0V8D1o/9iH9o99aN+s0X85OTmoXbs2srOzdeZrdj3yq0m3bt2wbds25f169eqpjfJmZmaqjQaX5urqCldXV7VyZ2dni74BLb09MoymubmjRmlaZkxTMqstwTXP1AZ/f4mWJb8kcHSUfwz066f+PE1lVQnfg/aPfWj/2If2zZL9p+92Kl3ym5ycDD8/P+X97t27IzExUWXeb0JCAnr06GGN5lEloWn1BUdHzevrWpquy+sCXA2BiIiqNptKfh8+fIi//vpLeT8lJQXnz59HzZo10bBhQ8ybNw9paWnYunUrAPlKDo0bN0bbtm1RVFSEbdu2Yffu3di9e7eyjunTp6N3795YtmwZhgwZgn379uGHH37A8ePHLb5/ZJ/0XX2h9IUYLEHbKgvlLRFGRERUldlU8nvmzBmVlRqioqIAAOPGjUNsbCzS09ORmpqqfLyoqAizZs1CWloa3N3d0bZtW3z//fcYOHCgMqZHjx7YuXMn3n77bcyfPx9NmzZFXFwc1/glvdjSCG/ZK52Vd/UyIiIiUmdTyW+fPn2g6/y72NhYlftz5szBnDlzyq13+PDhGD58eEWbR1VA6VHea9eAhQttY4QX0H6lM4BTGYiIiPRlU8kvkaXY06WCOY2BiIjIdJj8UpVjC5cKDgiQrwyxY4dqO8q7KhoRERFVDJNfqtSscangsnNzdSW0S5dyvi4REZElMfmlSsvSJ6uVnpvr41OMAwfOIzIyCGFhTloTWkdHztclIiKyJCa/VCnFxwPDh5v3ZDVtqy8MGwZIpQJ5eWkIDe3AkVwiIiIbwuSXKg3FFIe0NGDmTMuM8HJuLhERkX1h8kuVgqYpDubC1ReIiIjsF5NfsnvapjiYQnmXCiYiIiL7wuSX7JpMJh/xrWjiy0sFExERVQ1MfsnulF6+7N9/jZvqwEsFExERVU1MfsmuVHRuLy8VTEREVLUx+SW7YYq5vZzGQEREVLUx+SW7UJG5vXXqAKtWAQ0acBoDERFRVcfkl+zCsWOGT3VQTHHYsIEjvURERCTH5JdsVukT2y5fNvz5nOJAREREZTH5JZtk7Iltq1YBvr5cqYGIiIg0Y/JLNseYE9skEvlI72uvMeElIiIi7Zj8kk1QTHFISwNmzjQ88QXkUxyY+BIREZEuTH7J6iq6di/n9hIREZG+mPySVRm7du/bbwNt2nBuLxERERmGyS9ZTUXW7u3bl1diIyIiIsMx+SWrMXbtXn9/+WgvERERkaGY/JJFVWTtXp7YRkRERBXF5Jcshie2ERERkbUx+SWzKT3Ke+0asHCh4fN769SRX7iiQQOe2EZEREQVx+SXzKKio7yKKQ4bNnCkl4iIiEzHwdoNoMpHsXyZsYkvIJ/isGsXE18iIiIyLY78kklVZPkyrt1LRERE5sbkl0zKmOXLFLh2LxEREZkbk18yqfR0w5/DtXuJiIjIUpj8UoWVXtXh338Ney7X7iUiIiJLYvJLFcK1e4mIiMie2NRqD0ePHsXgwYNRv359SCQS7N27V2d8fHw8wsPDUadOHXh5eaF79+44dOiQSkxsbCwkEonaraCgwIx7UjUYuqqDYpR30SLgyy+BpCQgJYWJLxEREVmOTY385uXloUOHDpgwYQKee+65cuOPHj2K8PBwvP/++6hRowY2b96MwYMH49SpU+jYsaMyzsvLC1evXlV5rpubm8nbX5Xos6qDo6M8ToGjvERERGRtNpX8RkZGIjIyUu/46Oholfvvv/8+9u3bh2+//VYl+ZVIJKhXr57e9RYWFqKwsFB5PycnBwAglUohlUr1rsdYim1YYlvGOnJEglu3dB8+Mhnw0Ucy1K0r4OcH9Ool4OgI2PBumYw99CFpx/6zf+xD+8c+tG/W6D99t2VTyW9FlZSUIDc3FzVr1lQpf/jwIRo1agSZTIagoCAsWbJEJTkua+nSpVi0aJFaeUJCAjw8PEzebm0SExMtti1DHT3aAEBwuXG3byejWbM05OUBZWakVAm23IdUPvaf/WMf2j/2oX2zZP/l5+frFScRwpjLEZifRCLBnj178Oyzz+r9nA8//BAffPABrly5grp16wIATp48ib/++gvt27dHTk4OYmJisH//fly4cAHNmzfXWI+mkd+AgABkZWXBy8urQvulD6lUisTERISHh8PZ2dns2zPGkSMShIeX/79TYmIxQkNt8hAzK3voQ9KO/Wf/2If2j31o36zRfzk5Oahduzays7N15muVZuR3x44dWLhwIfbt26dMfAGgW7du6Natm/J+z5498eSTT+Ljjz/G6tWrNdbl6uoKV1dXtXJnZ2eLvgEtvT1DhIXJ5/BqO9lNsXZvWJhTlV7CzJb7kMrH/rN/7EP7xz60b5bsP323Y1OrPRgrLi4OkyZNwldffYV+/frpjHVwcEDnzp1x7do1C7WucnJ0BF55RfNjXLuXiIiIbJXdJ787duzA+PHj8eWXX2LQoEHlxgshcP78efj5+VmgdZWXEMDBg/Lfy06D9vcHdu3iqg5ERERke2xq2sPDhw/x119/Ke+npKTg/PnzqFmzJho2bIh58+YhLS0NW7duBSBPfMeOHYuYmBh069YNGRkZAAB3d3d4e3sDABYtWoRu3bqhefPmyMnJwerVq3H+/HmsXbvW8jto50pfyS01FThyBHB1BX7/HfjnH3m5n5/8MsUc8SUiIiJbZFPJ75kzZxAWFqa8HxUVBQAYN24cYmNjkZ6ejtTUVOXjn3zyCYqLi/HKK6/glVLfwSviAeDBgwf4z3/+g4yMDHh7e6Njx444evQounTpYpmdqiS0Xcmtf3+gcWP5jYiIiMjW2VTy26dPH+hafEKR0CocPny43DpXrVqFVatWVbBlVZviSm6auubbb+WPc4oDERER2QO7n/NL5qXPldxmzFC9khsRERGRrWLySzodO6Z9OTNAnhTfvCmPIyIiIrJ1TH5Jp/R008YRERERWROTX9JJ3xXhuHIcERER2QMmv6RTSIh83V5tJBIgIEAeR0RERGTrmPySTo6OwNKlmh/jldyIiIjI3pgk+d28ebMpqiEbIpMBhw8DO3YAu3fLy8omuLySGxEREdkbk6zzGx8fj8aNGysvUPHo0SNMnjwZ27dvN0X1ZGHaLmgxbx7Qty+v5EZERET2yyTJ77Zt2xAZGYlNmzbB0dERo0ePxn//+19TVE0WpuuCFu+9B3TsCIwebfl2EREREZlChZLfqKgoBAUFISgoCJs2bcILL7wAIQQ2bdqEjh07mqqNZCH6XtBiyBCO+BIREZF9qtCc39DQUNy4cQNLlizB888/jxs3bqB+/fpISEjA999/b6o2koXwghZERERU2Rk18nv16lW0bNkSQ4YMwZAhQ5Tljx49wqVLl/Dbb7/hhx9+wKBBg0zWUDI/XtCCiIiIKjujkt8nnngCffv2xYwZMxAREaEsd3d3R+fOndG5c2eTNZAshxe0ICIiosrOqGkPKSkp6NKlCyZMmIDWrVtj/fr1yM/PN3XbyMJ4QQsiIiKq7IxKfuvXr4+FCxfixo0bWLRoEeLi4uDv7485c+bgxo0bpm4jWYijI7BqlebHeEELIiIiqgyMSn4fPXqE27dv4+rVq6hfvz6ioqIwefJkrF+/Hs2bNzd1G8mCnJ3lPxXJrgIvaEFERESVgVFzfj09PeHl5YU6deqgevXq8PLygpeXF4YMGQIvLy9Tt5EsaPVq+c9Zs4CBA3lBCyIiIqpcjEp+n3/+eSQkJGDAgAGYPn06mjVrZup2kRX8/jvw00+AgwPw6qtAw4bWbhERERGRaRk17SEuLg4XL16Ep6cnunXrhmeeeQZJSUmmbhtZ2Mcfy38++ywTXyIiIqqcjL7Ihb+/Pz744AOkpqYiMjISL7/8Mjp06IDNmzebsn1kZjIZcPgw8PnnQGysvOz1163ZIiIiIiLzMWraQ0xMDHJzc/Hw4UPlz1atWuGnn37C5MmTMWHCBFO3k8wgPl5+OePSV3VzdgaysqzXJiIiIiJzMir53blzJ2rUqAEfHx/UqFED/v7+aNeuHZ5++mn4+PiYuo1kBvHxwPDh8ksWlyaVAs8/z5UdiIiIqHIyKvk9ceKEqdtBFiSTyUd8yya+pc2YAQwZwhUeiIiIqHIxes4v2a9jx1SnOpQlBHDzpjyOiIiIqDJh8lsFpaebNo6IiIjIXjD5rYL8/EwbR0RERGQvmPxWQSEh8ssVl72EsYJEAgQEyOOIiIiIKhOjkt/U1FQIDWdLCSGQmppa4UaReTk6AjExmh9TJMTR0TzZjYiIiCofo5LfwMBA3LlzR6383r17CAwMrHCjyPyGDQMWL1Yv9/fnMmdERERUeRm11JkQAhIN35k/fPgQbm5uFW4UWUZenvxn377ApEnyOb4hIRzxJSIiosrLoOQ3KioKACCRSDB//nx4eHgoH5PJZDh16hSCgoJM2kAynwMH5D8nTABGj7ZuW4iIiIgswaBpD8nJyUhOToYQAhcvXlTeT05Oxh9//IEOHTogNjbW6MYcPXoUgwcPRv369SGRSLB3795yn3PkyBF06tQJbm5uaNKkCTZs2KAWs3v3brRp0waurq5o06YN9uzZY3QbK4u0NODCBfkc3/79rd0aIiIiIsswaOQ3KSkJADBhwgTExMTAy8vLpI3Jy8tDhw4dMGHCBDz33HPlxqekpGDgwIGYMmUKtm3bhp9//hnTpk1DnTp1lM8/ceIERo4ciSVLlmDo0KHYs2cPRowYgePHj6Nr164mbb89OXhQ/rNLF6B2beu2hYiIiMhSjJrzu3nzZlO3AwAQGRmJyMhIveM3bNiAhg0bIjo6GgDQunVrnDlzBh999JEy+Y2OjkZ4eDjmzZsHAJg3bx6OHDmC6Oho7Nixw+T7YC/275f/NODlJiIiIrJ7RiW/APDgwQNs3LgRV65cgUQiQevWrTFp0iR4e3ubsn06nThxAhERESpl/fv3x8aNGyGVSuHs7IwTJ05g5syZajGKhFmTwsJCFBYWKu/n5OQAAKRSKaRSqel2QAvFNsy1LakUSEx0AiBBREQxpFL1ZeuoYszdh2Re7D/7xz60f+xD+2aN/tN3W0Ylv2fOnEH//v3h7u6OLl26QAiBVatW4f3330dCQgKefPJJY6o1WEZGBnx9fVXKfH19UVxcjKysLPj5+WmNycjI0Frv0qVLsWjRIrXyhIQElZP8zC0xMdEs9V68WAu5ub3g7V2IjIyDylFgMj1z9SFZBvvP/rEP7R/70L5Zsv/y8/P1ijMq+Z05cyaeeeYZfPbZZ3BykldRXFyMyZMnY8aMGTh69Kgx1Rql7JJriotvlC7XFKNpqTaFefPmKVe2AOQjvwEBAYiIiDD5PGdNpFIpEhMTER4eDmdnZ5PXf+yY/DzHp592xtNPDzR5/WT+PiTzYv/ZP/ah/WMf2jdr9J/im/ryGD3yWzrxBQAnJyfMmTMHwcHBxlRplHr16qmN4GZmZsLJyQm1atXSGVN2NLg0V1dXuLq6qpU7Oztb9A1oru0dOiT/OWiQA5ydeYVrc7L0MUOmxf6zf+xD+8c+tG+W7D99t2NU5uPl5aXxMsY3b95E9erVjanSKN27d1cbTk9ISEBwcLDyBdAW06NHD4u105bcvAlcugQ4OABlpksTERERVXpGjfyOHDkSkyZNwkcffYQePXpAIpHg+PHjmD17NkZX4GoJDx8+xF9//aW8n5KSgvPnz6NmzZpo2LAh5s2bh7S0NGzduhUAMHXqVKxZswZRUVGYMmUKTpw4gY0bN6qs4jB9+nT07t0by5Ytw5AhQ7Bv3z788MMPOH78uNHttEcyGXDsGLBtm/x+ly7A/wbHiYiIiKoMo5Lfjz76CBKJBGPHjkVxcTGEEHBxccHLL7+MDz74wOjGnDlzBmFhYcr7inm348aNQ2xsLNLT01VGnAMDA7F//37MnDkTa9euRf369bF69WqVNYJ79OiBnTt34u2338b8+fPRtGlTxMXFVak1fuPjgenTgVu3HpddviwvHzbMeu0iIiIisjSjkl8XFxfExMRg6dKl+PvvvyGEQLNmzSq8EkKfPn2UJ6xpounqcaGhoTh37pzOeocPH47hw4dXqG32Kj4eGD4cKPuy5uTIy3ftYgJMREREVYfJ1vlt06YNJk6caNF1fkk3mUw+4qvj/wnMmAEMGQI4OlqsWURERERWY9QJb2fOnEHTpk2xatUq3Lt3D1lZWVi5ciWaNm1a7igsWc6xY6pTHcoSQn4C3LFjlmsTERERkTXZ/Tq/pF16umnjiIiIiOydXa/zS7r5+Zk2joiIiMje2fU6v6RbSAjg7w9ou5idRAIEBMjjiIiIiKoCo5JfxTq/cXFxuHnzJm7duoWdO3di8uTJFVrnl0zL0RGIidF8wpsiIY6O5sluREREVHWYZJ1fQH5JuYqu80umN2SIfFpD2Xm9/v7yxJfLnBEREVFVYlPr/JLp7dsnT3y9vYEvvwSys+XJcEgIR3yJiIio6jE4+ZVKpYiIiMAnn3yCFi1aoH379uZoF5mAEMCyZfLfX3sNGDjQuu0hIiIisjaDk19nZ2dcunQJEm1nUZHVyWTytXt/+AH49VfA1VWe/BIRERFVdUad8DZ27Fhs3LjR1G0hE4iPBxo3BsLCgPfek5c5OQHHj1u1WUREREQ2wag5v0VFRfj888+RmJiI4OBgeHp6qjy+cuVKkzSODBMfDwwfrr66Q36+vHzXLp7gRkRERFWbUcnvpUuX8OSTTwIA/vzzT5XHOB3COmQyYPp0zcuaCSFf2mzGDPnqDzzRjYiIiKoqo5LfpKQkU7eDKujYMeDWLe2PCwHcvCmP69PHYs0iIiIisilGzfkl21N2Hd+KxhERERFVRkx+Kwk/P9PGEREREVVGTH4riZAQ+VXbtE25lkiAgAB5HBEREVFVxeS3knB0BGJiND+mSIijo3myGxEREVVtTH4rkWHDHl/RrTR/fy5zRkRERAQYsNpDVFSU3pVynV/rqV5d/jM4GIiKks/xDQnhiC8RERERYEDym5ycrHL/7NmzkMlkaNmyJQD5er+Ojo7o1KmTaVtIBjlzRv4zIgIYPdq6bSEiIiKyNXonv6XX9l25ciWqV6+OLVu2wMfHBwBw//59TJgwASE8o8qqFMlvcLB120FERERki4ya87tixQosXbpUmfgCgI+PD959912sWLHCZI0jwzx6BFy6JP+dyS8RERGROqOS35ycHPz7779q5ZmZmcjNza1wo8g4Fy7IL3Nct678JDciIiIiUmVU8jt06FBMmDABu3btwq1bt3Dr1i3s2rULkyZNwjAuKWA1p0/Lf3burH29XyIiIqKqTO85v6Vt2LABs2bNwksvvQSpVCqvyMkJkyZNwocffmjSBpL+ON+XiIiISDejkl8PDw+sW7cOH374If7++28IIdCsWTN4enqaun1kACa/RERERLoZlfwqeHp64oknnjBVW6gCHj4ErlyR/87V5oiIiIg0M/oKb8eOHcNLL72E7t27Iy0tDQDwxRdf4Pjx4yZrHOkvORkQAmjQQH5hCyIiIiJSZ1Tyu3v3bvTv3x/u7u5ITk5GYWEhACA3Nxfvv/++SRtI+lFMeejc2brtICIiIrJlRiW/7777LjZs2IDPPvsMzs7OyvIePXrg3LlzJmsc6U+x0gPn+xIRERFpZ1Tye/XqVfTu3Vut3MvLCw8ePKhom8gIPNmNiIiIqHxGJb9+fn7466+/1MqPHz+OJk2aVKhB69atQ2BgINzc3NCpUyccO3ZMa+z48eMhkUjUbm3btlXGxMbGaowpKCioUDttyYMHwLVr8t95shsRERGRdkYlv//9738xffp0nDp1ChKJBLdv38b27dsxa9YsTJs2zejGxMXFYcaMGXjrrbeQnJyMkJAQREZGIjU1VWN8TEwM0tPTlbebN2+iZs2aeP7551XivLy8VOLS09Ph5uZmdDttjWKmSePGQO3aVm0KERERkU0zaqmzOXPmIDs7G2FhYSgoKEDv3r3h6uqKWbNm4dVXXzW6MStXrsSkSZMwefJkAEB0dDQOHTqE9evXY+nSpWrx3t7e8Pb2Vt7fu3cv7t+/jwkTJqjESSQS1KtXz+h22Tqe7EZERESkH6OS39TUVCxZsgRvvfUWLl++jJKSErRp0waenp5ITU1Fw4YNDa6zqKgIZ8+exdy5c1XKIyIi8Msvv+hVx8aNG9GvXz80atRIpfzhw4do1KgRZDIZgoKCsGTJEnTs2FFrPYWFhcoVLAAgJycHACCVSpVXtDMnxTb03dapU44AHNCxowxSaYkZW0b6MrQPybaw/+wf+9D+sQ/tmzX6T99tGZX8BgYGIj09HXXr1kVwqTOs7t69i8DAQMhkMoPrzMrKgkwmg6+vr0q5r68vMjIyyn1+eno6Dhw4gC+//FKlvFWrVoiNjUX79u2Rk5ODmJgY9OzZExcuXEDz5s011rV06VIsWrRIrTwhIQEeHh4G7FXFJCYm6hV3/Hg/AJ4oLj6J/fuzzNsoMoi+fUi2if1n/9iH9o99aN8s2X/5+fl6xRmV/AohNJY/fPiwwnNpJRKJ2rbKlmkSGxuLGjVq4Nlnn1Up79atG7p166a837NnTzz55JP4+OOPsXr1ao11zZs3D1FRUcr7OTk5CAgIQEREBLy8vAzYG+NIpVIkJiYiPDxcZSm5smQy4PvvJcjMlHfjlCldUKuW2ZtHetC3D8k2sf/sH/vQ/rEP7Zs1+k/xTX15DEp+FQmhRCLBO++8ozIKKpPJcOrUKQQFBRlSpVLt2rXh6OioNsqbmZmpNhpclhACmzZtwpgxY+Di4qIz1sHBAZ07d8Y1xfIIGri6usLV1VWt3NnZ2aJvQF3bi48Hpk8Hbt16XNa5szNiYoBhwyzUQCqXpY8ZMi32n/1jH9o/9qF9s2T/6bsdg5Lf5ORkAPJk8+LFiyqJpouLCzp06IBZs2YZUqXK8zt16oTExEQMHTpUWZ6YmIghQ4bofO6RI0fw119/YdKkSeVuRwiB8+fPo3379ka10xbExwPDh8svZ1xaWpq8fNcuJsBEREREmhiU/CYlJQEAJkyYgJiYGJNPAYiKisKYMWMQHByM7t2749NPP0VqaiqmTp0KQD4dIS0tDVu3blV53saNG9G1a1e0a9dOrc5FixahW7duaN68OXJycrB69WqcP38ea9euNWnbLUUmk4/4app5IgQgkQAzZgBDhgCOjhZvHhEREZFNM2rO7+bNm03dDgDAyJEjcffuXSxevBjp6elo164d9u/fr1y9IT09XW3N3+zsbOzevRsxMTEa63zw4AH+85//ICMjA97e3ujYsSOOHj2KLl26mGUfzO3YMdWpDmUJAdy8KY/r08dizSIiIiKyC0YlvwqXL19GamoqioqKVMqfeeYZo+ucNm2a1gtlxMbGqpV5e3vrPLtv1apVWLVqldHtsTXp6aaNIyIiIqpKjEp+r1+/jqFDh+LixYuQSCTK1R8UqzIYs9QZ6cfPz7RxRERERFWJUZc3nj59OgIDA/Hvv//Cw8MDv//+O44ePYrg4GAcPnzYxE2k0kJCAH9/+dxeTSQSICBAHkdEREREqoxKfk+cOIHFixejTp06cHBwgIODA3r16oWlS5fi9ddfN3UbqRRHR0DL9GZlQhwdzZPdiIiIiDQxKvmVyWSoVq0aAPn6vLdv3wYANGrUCFevXjVd60ijYcPky5l5eqqW+/tzmTMiIiIiXYxKftu1a4fffvsNANC1a1csX74cP//8MxYvXowmTZqYtIGk2bBhgOLK0tOmAUlJQEoKE18iIiIiXYw64e3tt99GXl4eAODdd9/F008/jZCQENSqVQtxcXEmbSBp9/ff8p9jxgClruBMRERERFoYlfz2799f+XuTJk1w+fJl3Lt3Dz4+PsoVH8i88vMfr/fbrJl120JERERkL4xe57egoAC//fYbMjMzUVJSovJYRdb5Jf1cvy7/WaMGUKuWVZtCREREZDeMSn4PHjyIMWPG4O7du2qPSSQSrvNrAX/9Jf/ZrJn2Zc+IiIiISJVRJ7y9+uqrGDFiBNLT01FSUqJyY+JrGdeuyX82b27ddhARERHZE6OS38zMTERFRcHX19fU7SE9lR75JSIiIiL9GJX8Dh8+nFdyszKO/BIREREZzqg5v2vWrMHzzz+PY8eOoX379nB2dlZ5nFd5Mz+O/BIREREZzqjk98svv8ShQ4fg7u6Ow4cPqyxvJpFImPya2aNHwM2b8t+Z/BIRERHpz+iLXCxevBhz586Fg4NRMyeoAhTLnHl7A7VrW7ctRERERPbEqMy1qKgII0eOZOJrJVzmjIiIiMg4RmWv48aN42WMrYgnuxEREREZx6hpDzKZDMuXL8ehQ4fwxBNPqJ3wtnLlSpM0jjTjyW5ERERExjEq+b148SI6duwIALh06ZLKYxJ+D292iuSXI79EREREhjEq+U1KSjJ1O8gAimkPHPklIiIiMgzPWLMzBQVc5oyIiIjIWHqP/EZFRWHJkiXw9PREVFSUzljO+TWf69cBIQAvL6BOHWu3hoiIiMi+6J38JicnQyqVKn/XhnN+zYvLnBEREREZT+/kt/Q83y1btsDf319tnV8hBG4qvpMns+DJbkRERETGM2rOb2BgILKystTK7927h8DAwAo3irTjyW5ERERExjMq+RVCaCx/+PAh3NzcKtQg0o0jv0RERETGM2ipM8WJbhKJBO+88w48PDyUj8lkMpw6dQpBQUEmbSCp4sgvERERkfEMSn4VJ7oJIXDx4kW4uLgoH3NxcUGHDh0wa9Ys07aQlAoLgdRU+e9MfomIiIgMZ1DyqzjpbcKECYiJiYGXl5dZGkWapaTIlzmrXh2oW9farSEiIiKyP0Zd4W3z5s2mbgfpofSUBy5zRkRERGQ4o054e/ToEfLz85X3b9y4gejoaBw6dMhkDSN1PNmNiIiIqGKMSn6HDBmCrVu3AgAePHiArl27YsWKFXj22Wexfv16kzaQHuPJbkREREQVY1Tye+7cOYSEhAAAdu3aBV9fX9y4cQNbt27F6tWrK9SgdevWITAwEG5ubujUqROOHTumNfbw4cOQSCRqtz/++EMlbvfu3WjTpg1cXV3Rpk0b7Nmzp0JttBaO/BIRERFVjFHJb35+PqpXrw4ASEhIwLBhw+Dg4IBu3brhxo0bRjcmLi4OM2bMwFtvvYXk5GSEhIQgMjISqYolDrS4evUq0tPTlbfmpbLDEydOYOTIkRgzZgwuXLiAMWPGYMSIETh16pTR7bQ0mQw4fBg4f15+n9cRISIiIjKOUSe8NWvWDHv37sXQoUNx6NAhzJw5EwCQmZlZoRUgVq5ciUmTJmHy5MkAoJxHvH79eixdulTr8+rWrYsaNWpofCw6Ohrh4eGYN28eAGDevHk4cuQIoqOjsWPHDo3PKSwsRGFhofJ+Tk4OAEAqlUIqlRqzawZRbEMqlWLPHgmiohyRlvb4DLfRowWio2UYOlTzxUbI+kr3Idkf9p/9Yx/aP/ahfbNG/+m7LaOS33feeQcvvPACZs6ciaeeegrdu3cHIB8F7tixozFVoqioCGfPnsXcuXNVyiMiIvDLL7/ofG7Hjh1RUFCANm3a4O2330ZYWJjysRMnTiiTc4X+/fsjOjpaa31Lly7FokWL1MoTEhJULuxhbosXX8KyZZ3VytPTgZEjHfHmm6fRvXu6xdpDhktMTLR2E6gC2H/2j31o/9iH9s2S/Vd6MQZdjEp+hw8fjl69eiE9PR0dOnRQlvft2xfDhg0zpkpkZWVBJpPB19dXpdzX1xcZGRkan+Pn54dPP/0UnTp1QmFhIb744gv07dsXhw8fRu/evQEAGRkZBtUJyEeHFVezA+QjvwEBAYiIiLDI2sZSqRQHDyZi27bg/5WUXddMAolEYPv2zli4sBiOjmZvEhlIKpUiMTER4eHhcHZ2tnZzyEDsP/vHPrR/7EP7Zo3+U3xTXx6Dkt+BAwdix44d8Pb2Rr169bBx40YEBgYqpxw0bdoUISEhuHz5ssENVpCUWcBWCKFWptCyZUu0bNlSeb979+64efMmPvroI2Xya2idAODq6gpXV1e1cmdnZ4t14OXLtZCWpn1KthAS3LoFnDzpjD59LNIkMoIljxkyPfaf/WMf2j/2oX2zZP/pux2DTng7dOiQylzYZcuW4d69e8r7xcXFuHr1qiFVKtWuXRuOjo5qI7KZmZlqI7e6dOvWDdcUa4IBqFevXoXrtIb79930ikvnrAciIiIivRmU/AohdN6vCBcXF3Tq1EltbkhiYiJ69Oihdz3Jycnw8/NT3u/evbtanQkJCQbVaQ0+PgV6xZXaVSIiIiIqh1Fzfs0lKioKY8aMQXBwMLp3745PP/0UqampmDp1KgD5XNy0tDTlBTaio6PRuHFjtG3bFkVFRdi2bRt2796N3bt3K+ucPn06evfujWXLlmHIkCHYt28ffvjhBxw/ftwq+6ivNm3uokEDgdu3JdD0P4ZEAvj7A/9bbpmIiIiI9GBQ8qu4iETZMlMZOXIk7t69i8WLFyM9PR3t2rXD/v370ahRIwBAenq6ypq/RUVFmDVrFtLS0uDu7o62bdvi+++/x8CBA5UxPXr0wM6dO/H2229j/vz5aNq0KeLi4tC1a1eTtdscHB2BlStlGDXKCRIJVBJgxUseHQ2e7EZERERkAIOSXyEExo8frzwZrKCgAFOnToWnpycAqMwHNta0adMwbdo0jY/Fxsaq3J8zZw7mzJlTbp3Dhw/H8OHDK9w2Sxs6VGDXLmD6dODWrcfl/v7yxNfIhTWIiIiIqiyDkt9x48ap3H/ppZfUYsaOHVuxFpGKYcOAIUOAOnWA+/eBzz4DJkzgiC8RERGRMQxKfjdv3myudpAODg5AXp7894gIJr5ERERExjJotQeyjkePgKIi+e81a1q3LURERET2jMmvHVAspezkBPxvejURERERGYHJrx24f1/+s2bNxys9EBEREZHhmPzaAcXIr4+PddtBREREZO+Y/NqB0iO/RERERGQ8Jr92gCO/RERERKbB5NcOcOSXiIiIyDSY/NoBjvwSERERmQaTXzvAkV8iIiIi02Dyawc48ktERERkGkx+7QBHfomIiIhMg8mvHeDILxEREZFpMPm1Axz5JSIiIjINJr92gCO/RERERKbB5NfGlZQADx7If+fILxEREVHFMPm1cdnZgBDy3znyS0RERFQxTH5tnGK+r6cn4OJi3bYQERER2TsmvzaO832JiIiITIfJr43jSg9EREREpsPk18Zx5JeIiIjIdJj82jiO/BIRERGZDpNfG8eRXyIiIiLTYfJr4zjyS0RERGQ6TH5tHEd+iYiIiEyHya+N48gvERERkekw+bVxHPklIiIiMh0mvzaOI79EREREpsPk18Zx5JeIiIjIdJj82jhF8suRXyIiIqKKs7nkd926dQgMDISbmxs6deqEY8eOaY2Nj49HeHg46tSpAy8vL3Tv3h2HDh1SiYmNjYVEIlG7FRQUmHtXKqywEMjPl//OkV8iIiKiirOp5DcuLg4zZszAW2+9heTkZISEhCAyMhKpqaka448ePYrw8HDs378fZ8+eRVhYGAYPHozk5GSVOC8vL6Snp6vc3NzcLLFLFaKY7yuRAN7e1m0LERERUWXgZO0GlLZy5UpMmjQJkydPBgBER0fj0KFDWL9+PZYuXaoWHx0drXL//fffx759+/Dtt9+iY8eOynKJRIJ69eqZte3moEh+fXwAB5v6N4WIiIjIPtlM8ltUVISzZ89i7ty5KuURERH45Zdf9KqjpKQEubm5qFlmguzDhw/RqFEjyGQyBAUFYcmSJSrJcVmFhYUoLCxU3s/JyQEASKVSSKVSfXfJaIpt3LkjA+AMHx8BqbTY7Nsl01H0oSWOFzI99p/9Yx/aP/ahfbNG/+m7LZtJfrOysiCTyeDr66tS7uvri4yMDL3qWLFiBfLy8jBixAhlWatWrRAbG4v27dsjJycHMTEx6NmzJy5cuIDmzZtrrGfp0qVYtGiRWnlCQgI8PDwM2KuKSUo6D6AbHBweYP/+oxbbLplOYmKitZtAFcD+s3/sQ/vHPrRvluy/fMWJUuWwmeRXQSKRqNwXQqiVabJjxw4sXLgQ+/btQ926dZXl3bp1Q7du3ZT3e/bsiSeffBIff/wxVq9erbGuefPmISoqSnk/JycHAQEBiIiIgJeXl6G7ZDCpVIrExEQ0aiQfnW7c2BsDBw40+3bJdBR9GB4eDmdnZ2s3hwzE/rN/7EP7xz60b9boP8U39eWxmeS3du3acHR0VBvlzczMVBsNLisuLg6TJk3C119/jX79+umMdXBwQOfOnXHt2jWtMa6urnB1dVUrd3Z2tugbMDdX3j21ajnA2ZmTfu2RpY8ZMi32n/1jH9o/9qF9s2T/6bsdm8moXFxc0KlTJ7Xh8cTERPTo0UPr83bs2IHx48fjyy+/xKBBg8rdjhAC58+fh5+fX4XbbG68wAURERGRadnMyC8AREVFYcyYMQgODkb37t3x6aefIjU1FVOnTgUgn46QlpaGrVu3ApAnvmPHjkVMTAy6deumHDV2d3eH9//WBlu0aBG6deuG5s2bIycnB6tXr8b58+exdu1a6+ykAR48kP/kBS6IiIiITMOmkt+RI0fi7t27WLx4MdLT09GuXTvs378fjRo1AgCkp6errPn7ySefoLi4GK+88gpeeeUVZfm4ceMQGxsLAHjw4AH+85//ICMjA97e3ujYsSOOHj2KLl26WHTfjHHvnnyuM0d+iYiIiEzDppJfAJg2bRqmTZum8TFFQqtw+PDhcutbtWoVVq1aZYKWWR5HfomIiIhMy2bm/JI6zvklIiIiMi0mvzbs/n35tAeO/BIRERGZBpNfG1b68sZEREREVHFMfm2UEI+TX478EhEREZkGk18bVVDghOJirvZAREREZEpMfm3Uw4fyq5S4ugLu7lZuDBEREVElweTXRuXmypNfHx9AIrFyY4iIiIgqCSa/NiovzwUA5/sSERERmRKTXxtVeuSXiIiIiEyDya+NysuTJ78c+SUiIiIyHSa/Nio3Vz7tgSO/RERERKbD5NdGceSXiIiIyPSY/NoojvwSERERmR6TXxulWOeXI79EREREpsPk10Y9fMiRXyIiIiJTY/JrozjyS0RERGR6TH5tlCL55cgvERERkekw+bVRimkPHPklIiIiMh0mvzaouBjIz+fILxEREZGpMfm1QQ8ePP6dyS8RERGR6TD5tUH378t/Vq8u4ORk3bYQERERVSZMfm3Q/fsSAJzvS0RERGRqTH5tkGLkt0YNqzaDiIiIqNJh8muD7t2T/6xZU1i3IURERESVDJNfG/TggXzaA0d+iYiIiEyLya8Nejzya912EBEREVU2TH5tkGKpsxo1OO2BiIiIyJSY/Nqge/e42gMRERGROTD5tUGK1R58fDjyS0RERGRKTH5t0OPk17rtICIiIqpsmPzaIMVFLpj8EhEREZkWk18bI5MBGRny369fl98nIiIiItOwueR33bp1CAwMhJubGzp16oRjx47pjD9y5Ag6deoENzc3NGnSBBs2bFCL2b17N9q0aQNXV1e0adMGe/bsMVfzKyQ+Hmjc+PEJb9OmOaFxY3k5EREREVWcTSW/cXFxmDFjBt566y0kJycjJCQEkZGRSE1N1RifkpKCgQMHIiQkBMnJyfi///s/vP7669i9e7cy5sSJExg5ciTGjBmDCxcuYMyYMRgxYgROnTplqd3SS3w8MHw4cOuWanlamrycCTARERFRxdlU8rty5UpMmjQJkydPRuvWrREdHY2AgACsX79eY/yGDRvQsGFDREdHo3Xr1pg8eTImTpyIjz76SBkTHR2N8PBwzJs3D61atcK8efPQt29fREdHW2ivyieTAdOnA0LD4g6KshkzOAWCiIiIqKKcrN0AhaKiIpw9exZz585VKY+IiMAvv/yi8TknTpxARESESln//v2xceNGSKVSODs748SJE5g5c6ZajK7kt7CwEIWFhcr7OTk5AACpVAqpVGrIbunlyBEJbt3S3hVCADdvAklJxQgN5fJn9kBxnJjjeCHzY//ZP/ah/WMf2jdr9J++27KZ5DcrKwsymQy+vr4q5b6+vshQnAFWRkZGhsb44uJiZGVlwc/PT2uMtjoBYOnSpVi0aJFaeUJCAjw8PPTdJb0dPdoAQHC5cQcOnEdeXprJt0/mk5iYaO0mUAWw/+wf+9D+sQ/tmyX7Lz8/X684m0l+FSQSicp9IYRaWXnxZcsNrXPevHmIiopS3s/JyUFAQAAiIiLg5eVV/k4YyNNTgpUry4+LjAxCaGgHk2+fTE8qlSIxMRHh4eFwdna2dnPIQOw/+8c+tH/sQ/tmjf5TfFNfHptJfmvXrg1HR0e1EdnMzEy1kVuFevXqaYx3cnJCrVq1dMZoqxMAXF1d4erqqlbu7Oxslg4MCwP8/eUnt2ma9yuRyB8PC3OCo6PJN09mZK5jhiyD/Wf/2If2j31o3yzZf/pux2ZOeHNxcUGnTp3UhscTExPRo0cPjc/p3r27WnxCQgKCg4OVL4C2GG11WoOjIxATI/+97IC04n50NJj4EhEREVWQzSS/ABAVFYXPP/8cmzZtwpUrVzBz5kykpqZi6tSpAOTTEcaOHauMnzp1Km7cuIGoqChcuXIFmzZtwsaNGzFr1ixlzPTp05GQkIBly5bhjz/+wLJly/DDDz9gxowZlt49nYYNA3btAho0UC3395eXDxtmnXYRERERVSY2M+0BAEaOHIm7d+9i8eLFSE9PR7t27bB//340atQIAJCenq6y5m9gYCD279+PmTNnYu3atahfvz5Wr16N5557ThnTo0cP7Ny5E2+//Tbmz5+Ppk2bIi4uDl27drX4/pVn2DBgyBD5qg4HDpxHZGQQpzoQERERmZBNJb8AMG3aNEybNk3jY7GxsWploaGhOHfunM46hw8fjuHDh5uieWbn6AiEhgrk5aUhNLQDE18iIiIiE7KpaQ9ERERERObE5JeIiIiIqgwmv0RERERUZTD5JSIiIqIqg8kvEREREVUZTH6JiIiIqMqwuaXObJH43zWH9b1mdEVJpVLk5+cjJyeHl3S0U+xD+8b+s3/sQ/vHPrRv1ug/RZ6myNu0YfKrh9zcXABAQECAlVtCRERERLrk5ubC29tb6+MSUV56TCgpKcHt27dRvXp1SCQSs28vJycHAQEBuHnzJry8vMy+PTI99qF9Y//ZP/ah/WMf2jdr9J8QArm5uahfvz4cHLTP7OXIrx4cHBzg7+9v8e16eXnxDW/n2If2jf1n/9iH9o99aN8s3X+6RnwVeMIbEREREVUZTH6JiIiIqMpg8muDXF1dsWDBAri6ulq7KWQk9qF9Y//ZP/ah/WMf2jdb7j+e8EZEREREVQZHfomIiIioymDyS0RERERVBpNfIiIiIqoymPwSERERUZXB5NfGrFu3DoGBgXBzc0OnTp1w7NgxazeJtFi6dCk6d+6M6tWro27dunj22Wdx9epVlRghBBYuXIj69evD3d0dffr0we+//26lFpMuS5cuhUQiwYwZM5Rl7D/bl5aWhpdeegm1atWCh4cHgoKCcPbsWeXj7EPbVlxcjLfffhuBgYFwd3dHkyZNsHjxYpSUlChj2Ie25ejRoxg8eDDq168PiUSCvXv3qjyuT38VFhbitddeQ+3ateHp6YlnnnkGt27dstg+MPm1IXFxcZgxYwbeeustJCcnIyQkBJGRkUhNTbV200iDI0eO4JVXXsHJkyeRmJiI4uJiREREIC8vTxmzfPlyrFy5EmvWrMHp06dRr149hIeHIzc314otp7JOnz6NTz/9FE888YRKOfvPtt2/fx89e/aEs7MzDhw4gMuXL2PFihWoUaOGMoZ9aNuWLVuGDRs2YM2aNbhy5QqWL1+ODz/8EB9//LEyhn1oW/Ly8tChQwesWbNG4+P69NeMGTOwZ88e7Ny5E8ePH8fDhw/x9NNPQyaTWWYnBNmMLl26iKlTp6qUtWrVSsydO9dKLSJDZGZmCgDiyJEjQgghSkpKRL169cQHH3ygjCkoKBDe3t5iw4YN1momlZGbmyuaN28uEhMTRWhoqJg+fboQgv1nD958803Rq1cvrY+zD23foEGDxMSJE1XKhg0bJl566SUhBPvQ1gEQe/bsUd7Xp78ePHggnJ2dxc6dO5UxaWlpwsHBQRw8eNAi7ebIr40oKirC2bNnERERoVIeERGBX375xUqtIkNkZ2cDAGrWrAkASElJQUZGhkqfurq6IjQ0lH1qQ1555RUMGjQI/fr1Uyln/9m+b775BsHBwXj++edRt25ddOzYEZ999pnycfah7evVqxd+/PFH/PnnnwCACxcu4Pjx4xg4cCAA9qG90ae/zp49C6lUqhJTv359tGvXzmJ96mSRrVC5srKyIJPJ4Ovrq1Lu6+uLjIwMK7WK9CWEQFRUFHr16oV27doBgLLfNPXpjRs3LN5GUrdz506cO3cOp0+fVnuM/Wf7rl+/jvXr1yMqKgr/93//h19//RWvv/46XF1dMXbsWPahHXjzzTeRnZ2NVq1awdHRETKZDO+99x5Gjx4NgO9De6NPf2VkZMDFxQU+Pj5qMZbKd5j82hiJRKJyXwihVka259VXX8Vvv/2G48ePqz3GPrVNN2/exPTp05GQkAA3Nzetcew/21VSUoLg4GC8//77AICOHTvi999/x/r16zF27FhlHPvQdsXFxWHbtm348ssv0bZtW5w/fx4zZsxA/fr1MW7cOGUc+9C+GNNfluxTTnuwEbVr14ajo6Pafz2ZmZlq/0GRbXnttdfwzTffICkpCf7+/sryevXqAQD71EadPXsWmZmZ6NSpE5ycnODk5IQjR45g9erVcHJyUvYR+892+fn5oU2bNiplrVu3Vp4kzPeg7Zs9ezbmzp2LUaNGoX379hgzZgxmzpyJpUuXAmAf2ht9+qtevXooKirC/fv3tcaYG5NfG+Hi4oJOnTohMTFRpTwxMRE9evSwUqtIFyEEXn31VcTHx+Onn35CYGCgyuOBgYGoV6+eSp8WFRXhyJEj7FMb0LdvX1y8eBHnz59X3oKDg/Hiiy/i/PnzaNKkCfvPxvXs2VNtecE///wTjRo1AsD3oD3Iz8+Hg4NqKuLo6Khc6ox9aF/06a9OnTrB2dlZJSY9PR2XLl2yXJ9a5LQ60svOnTuFs7Oz2Lhxo7h8+bKYMWOG8PT0FP/884+1m0YavPzyy8Lb21scPnxYpKenK2/5+fnKmA8++EB4e3uL+Ph4cfHiRTF69Gjh5+cncnJyrNhy0qb0ag9CsP9s3a+//iqcnJzEe++9J65duya2b98uPDw8xLZt25Qx7EPbNm7cONGgQQPx3XffiZSUFBEfHy9q164t5syZo4xhH9qW3NxckZycLJKTkwUAsXLlSpGcnCxu3LghhNCvv6ZOnSr8/f3FDz/8IM6dOyeeeuop0aFDB1FcXGyRfWDya2PWrl0rGjVqJFxcXMSTTz6pXDaLbA8AjbfNmzcrY0pKSsSCBQtEvXr1hKurq+jdu7e4ePGi9RpNOpVNftl/tu/bb78V7dq1E66urqJVq1bi008/VXmcfWjbcnJyxPTp00XDhg2Fm5ubaNKkiXjrrbdEYWGhMoZ9aFuSkpI0/u0bN26cEEK//nr06JF49dVXRc2aNYW7u7t4+umnRWpqqsX2QSKEEJYZYyYiIiIisi7O+SUiIiKiKoPJLxERERFVGUx+iYiIiKjKYPJLRERERFUGk18iIiIiqjKY/BIRERFRlcHkl4iIiIiqDCa/RERERFRlMPklIrIzjRs3RnR0tFm3ERsbixo1alS4nj59+mDGjBkVrkcXiUSCvXv3mnUbRFR5MPklItJi/PjxePbZZ5X3LZHIlaYtAT19+jT+85//mHXbI0eOxJ9//mnWbRARWYOTtRtARFTVFBUVwcXFxejn16lTx4St0czd3R3u7u5m3w4RkaVx5JeISA/jx4/HkSNHEBMTA4lEAolEgn/++QcAcPnyZQwcOBDVqlWDr68vxowZg6ysLOVz+/Tpg1dffRVRUVGoXbs2wsPDAQArV65E+/bt4enpiYCAAEybNg0PHz4EABw+fBgTJkxAdna2cnsLFy4EoD7tITU1FUOGDEG1atXg5eWFESNG4N9//1U+vnDhQgQFBeGLL75A48aN4e3tjVGjRiE3N1fr/pYdddanjry8PIwdOxbVqlWDn58fVqxYoVZvUVER5syZgwYNGsDT0xNdu3bF4cOHAQAFBQVo27atyqh2SkoKvL298dlnn+nuoFIWL14MX19fnD9/Xu/nEFHVweSXiEgPMTEx6N69O6ZMmYL09HSkp6cjICAA6enpCA0NRVBQEM6cOYODBw/i33//xYgRI1Sev2XLFjg5OeHnn3/GJ598AgBwcHDA6tWrcenSJWzZsgU//fQT5syZAwDo0aMHoqOj4eXlpdzerFmz1NolhMCzzz6Le/fu4ciRI0hMTMTff/+NkSNHqsT9/fff2Lt3L7777jt89913OHLkCD744AODXoPy6pg9ezaSkpKwZ88eJCQk4PDhwzh79qxKHRMmTMDPP/+MnTt34rfffsPzzz+PAQMG4Nq1a3Bzc8P27duxZcsW7N27FzKZDGPGjEFYWBimTJlSbvuEEJg+fTo2btyI48ePIygoyKD9I6IqQhARkUbjxo0TQ4YMUd4PDQ0V06dPV4mZP3++iIiIUCm7efOmACCuXr2qfF5QUFC52/vqq69ErVq1lPc3b94svL291eIaNWokVq1aJYQQIiEhQTg6OorU1FTl47///rsAIH799VchhBALFiwQHh4eIicnRxkze/Zs0bVrV61tKbvt8urIzc0VLi4uYufOncrH7969K9zd3ZWv2V9//SUkEolIS0tT2Vbfvn3FvHnzlPeXL18uateuLV577TVRr149cefOHa3tFEIIAOLrr78WL730kmjVqpW4efOmzngiqto455eIqALOnj2LpKQkVKtWTe2xv//+Gy1atAAABAcHqz2elJSE999/H5cvX0ZOTg6Ki4tRUFCAvLw8eHp66rX9K1euICAgAAEBAcqyNm3aoEaNGrhy5Qo6d+4MQD5Vonr16soYPz8/ZGZmGrSvuur4+++/UVRUhO7duysfr1mzJlq2bKm8f+7cOQghlK+JQmFhIWrVqqW8/8Ybb2Dfvn34+OOPceDAAdSuXbvcts2cOROurq44efKkXvFEVHUx+SUiqoCSkhIMHjwYy5YtU3vMz89P+XvZZPbGjRsYOHAgpk6diiVLlqBmzZo4fvw4Jk2aBKlUqvf2hRCQSCTlljs7O6s8LpFIUFJSovd2yqtDCFHu80tKSuDo6IizZ8/C0dFR5bHS/zxkZmbi6tWrcHR0xLVr1zBgwIBy6w4PD8eOHTtw6NAhvPjii/rsDhFVUUx+iYj05OLiAplMplL25JNPYvfu3WjcuDGcnPT/SD1z5gyKi4uxYsUKODjIT7/46quvyt1eWW3atEFqaipu3rypHP29fPkysrOz0bp1a73bU1HNmjWDs7MzTp48iYYNGwIA7t+/jz///BOhoaEAgI4dO0ImkyEzMxMhISFa65o4cSLatWuHKVOmYNKkSejbty/atGmjc/vPPPMMBg8ejBdeeAGOjo4YNWqU6XaOiCoVnvBGRKSnxo0b49SpU/jnn3+QlZWFkpISvPLKK7h37x5Gjx6NX3/9FdevX0dCQgImTpyoM3Ft2rQpiouL8fHHH+P69ev44osvsGHDBrXtPXz4ED/++COysrKQn5+vVk+/fv3wxBNP4MUXX8S5c+fw66+/YuzYsQgNDdU41cJcqlWrhkmTJmH27Nn48ccfcenSJYwfP16Z2ANAixYt8OKLL2Ls2LGIj49HSkoKTp8+jWXLlmH//v0AgLVr1+LEiRPYunUrXnjhBQwfPhwvvvgiioqKym3D0KFD8cUXX2DChAnYtWuX2faViOwbk18iIj3NmjULjo6OaNOmDerUqYPU1FTUr18fP//8M2QyGfr374927dph+vTp8Pb2Vkn8ygoKCsLKlSuxbNkytGvXDtu3b8fSpUtVYnr06IGpU6di5MiRqFOnDpYvX65Wj+LqZj4+Pujduzf69euHJk2aIC4uzuT7X54PP/wQvXv3xjPPPIN+/fqhV69e6NSpk0rM5s2bMXbsWLzxxhto2bIlnnnmGZw6dQoBAQH4448/MHv2bKxbt045ir127Vo8ePAA8+fP16sNw4cPx5YtWzBmzBjEx8ebfB+JyP5JhD4TtYiIiIiIKgGO/BIRERFRlcHkl4iIiIiqDCa/RERERFRlMPklIiIioiqDyS8RERERVRlMfomIiIioymDyS0RERERVBpNfIiIiIqoymPwSERERUZXB5JeIiIiIqgwmv0RERERUZfw/KOLjT0IRW/IAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# 真实函数 (我们假装不知道它的表达式)\n", + "def g(w):\n", + " return w**3 - 5\n", + "\n", + "# 带噪声的黑盒观测器\n", + "def noisy_observation(w):\n", + " noise = np.random.normal(0, 1) # 标准正态分布噪声\n", + " return g(w) + noise\n", + "\n", + "w_k = 0.0 # 初始猜测 w1 = 0\n", + "w_history = [w_k]\n", + "\n", + "# 迭代 100 次\n", + "for k in range(1, 101):\n", + " a_k = 0.1 / k # 满足 RM 定理的收敛步长,减小初始步长防止发散\n", + " \n", + " # 观测带噪声的输出\n", + " g_tilde = noisy_observation(w_k)\n", + " \n", + " # RM 核心更新公式\n", + " w_k = w_k - a_k * g_tilde\n", + " w_history.append(w_k)\n", + "\n", + "# 绘图展示收敛过程 (类似图 6.3)\n", + "plt.figure(figsize=(8, 4))\n", + "plt.plot(range(101), w_history, marker='o', linestyle='-', color='b')\n", + "plt.axhline(y=5**(1/3), color='r', linestyle='--', label='True Root (~1.71)')\n", + "plt.title('Robbins-Monro Algorithm: Finding root of $w^3 - 5 = 0$ with noise')\n", + "plt.xlabel('Iteration index k')\n", + "plt.ylabel('Estimated root $w_k$')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3cc50d1f", + "metadata": {}, + "source": [ + "BGD, MBGD, 与 SGD 收敛性对比" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c91caa6f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "结论:离真值越远,SGD下降得越快;靠近真值时,SGD 会有一定的波动,而 MBGD (使用更多样本) 波动更小 [cite: 7129-7134]。\n" + ] + } + ], + "source": [ + "# 目标: 寻找二维平面上一堆散点的中心 (均值)\n", + "# 对应优化问题: 最小化均方误差 J(w)\n", + "np.random.seed(0)\n", + "n_samples = 100\n", + "# 在边长 20 的正方形内均匀分布采样,中心(期望)为 [0,0]\n", + "X = np.random.uniform(-10, 10, size=(n_samples, 2)) \n", + "\n", + "# 初始化\n", + "w_init = np.array([20.0, 20.0]) # 故意从很远的地方开始\n", + "w_sgd = w_init.copy()\n", + "w_mbgd_5 = w_init.copy()\n", + "\n", + "dist_sgd = [np.linalg.norm(w_sgd)]\n", + "dist_mbgd_5 = [np.linalg.norm(w_mbgd_5)]\n", + "\n", + "# 模拟前 30 步迭代\n", + "for k in range(1, 31):\n", + " alpha_k = 1 / k\n", + " \n", + " # SGD: 每次随机抽 1 个样本 [cite: 7173]\n", + " idx_sgd = np.random.choice(n_samples, 1)\n", + " grad_sgd = w_sgd - X[idx_sgd[0]] # 梯度: w - x\n", + " w_sgd = w_sgd - alpha_k * grad_sgd\n", + " dist_sgd.append(np.linalg.norm(w_sgd))\n", + " \n", + " # MBGD (m=5): 每次随机抽 5 个样本\n", + " idx_mbgd = np.random.choice(n_samples, 5)\n", + " grad_mbgd = w_mbgd_5 - np.mean(X[idx_mbgd], axis=0) \n", + " w_mbgd_5 = w_mbgd_5 - alpha_k * grad_mbgd\n", + " dist_mbgd_5.append(np.linalg.norm(w_mbgd_5))\n", + "\n", + "plt.figure(figsize=(8, 4))\n", + "plt.plot(dist_sgd, marker='d', label='SGD (m=1)', alpha=0.7)\n", + "plt.plot(dist_mbgd_5, marker='>', label='MBGD (m=5)', alpha=0.7)\n", + "plt.title('Distance to True Mean (0,0) over iterations')\n", + "plt.xlabel('Iteration step')\n", + "plt.ylabel('Distance to mean')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "print(\"结论:离真值越远,SGD下降得越快;靠近真值时,SGD 会有一定的波动,而 MBGD (使用更多样本) 波动更小。\")" + ] + } + ], + "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 +} diff --git a/Notebooks/C7.ipynb b/Notebooks/C7.ipynb new file mode 100644 index 0000000..c3d6b72 --- /dev/null +++ b/Notebooks/C7.ipynb @@ -0,0 +1,281 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b83792ff", + "metadata": {}, + "source": [ + "# 第 7 章:时间差分方法 (Temporal-Difference Methods) - 上篇\n", + "\n", + "## 1. TD(0):走一步,学一步\n", + "在不知道环境模型(无模型)的情况下,我们要评估一个策略的好坏 $V(s)$。\n", + "相比于蒙特卡洛(MC)必须等一个回合结束(比如游戏 Game Over)才能复盘,**TD 算法允许智能体每走一步就更新一次自己的认知**。\n", + "\n", + "## 2. 核心更新公式\n", + "$$V(s_t) \\leftarrow V(s_t) + \\alpha [r_{t+1} + \\gamma V(s_{t+1}) - V(s_t)]$$\n", + "\n", + "我们来拆解这个美妙的公式:\n", + "* **$r_{t+1} + \\gamma V(s_{t+1})$**:这被称为 **TD 目标 (TD Target)**。它用实际走这一步拿到的“真实奖励”,加上对下一个状态的“现有估值”,来作为当前状态的新目标。\n", + "* **$r_{t+1} + \\gamma V(s_{t+1}) - V(s_t)$**:这被称为 **TD 误差 (TD Error)**。它衡量了“我刚刚经历的真实情况与我对未来的预测”加上“我对下一步的预测”,和“我原来对当前步的预测”之间的偏差。\n", + "* **$\\alpha$**:学习率(相当于第六章的步长)。\n", + "\n", + "**核心思想(自举 Bootstrapping)**:用自己对下一步的估计,来更新对当前步的估计。就像是“左脚踩右脚上天”。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e46747a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== TD(0) 算法:边走边学演示 ===\n", + "初始状态 V 表: [0. 0. 0. 0. 0.]\n", + "\n", + "[第 1 步] 在状态 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", + "[第 2 步] 在状态 4 决定 向右,进入了状态 5。拿到真实奖励 0.0。\n", + " -> 我猜状态 5 的价值是 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", + "\n", + "游戏结束!最终到达终点 6。\n", + "\n", + "跑完这 1 局后的最新状态 V 表 (状态1到5): [0. 0. 0. 0. 0.1]\n", + "仔细看:相比于 MC 要等游戏结束,TD 在游戏过程中就已经把前面的状态价值更新了!\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# --- 1. 定义简单的 1D 随机游走环境 ---\n", + "# 状态: 0, 1, 2, 3, 4, 5, 6 (0 和 6 是终点)\n", + "# 开始状态是 3 (正中间)\n", + "# 规则: 每次有 50% 概率向左,50% 概率向右\n", + "# 奖励: 只有走到 6 (右边终点) 时奖励为 1,走到 0 (左边终点) 奖励为 0,其他全是 0。\n", + "def step(state):\n", + " action = np.random.choice([-1, 1]) # -1向左, 1向右\n", + " next_state = state + action\n", + " \n", + " # 判断奖励和是否结束\n", + " reward = 1.0 if next_state == 6 else 0.0\n", + " done = (next_state == 0 or next_state == 6)\n", + " \n", + " return next_state, reward, done\n", + "\n", + "# --- 2. 运行 TD(0) 算法 ---\n", + "print(\"=== TD(0) 算法:边走边学演示 ===\")\n", + "\n", + "# 初始化状态价值 V(s) 全为 0 (终点 0 和 6 的价值始终为 0)\n", + "V_td = np.zeros(7)\n", + "alpha = 0.1 # 学习率\n", + "gamma = 1.0 # 假设无折扣因子,简化理解\n", + "\n", + "# 我们只跑 1 局游戏,仔细看看里面发生了什么!\n", + "state = 3 # 从中间开始\n", + "step_count = 0\n", + "\n", + "print(f\"初始状态 V 表: {np.round(V_td[1:6], 3)}\")\n", + "\n", + "while True:\n", + " step_count += 1\n", + " next_state, reward, done = step(state)\n", + " \n", + " # 【核心!】TD 走完这一步立刻开始算账\n", + " td_target = reward + gamma * V_td[next_state]\n", + " td_error = td_target - V_td[state]\n", + " \n", + " # 记录下更新前的 V 值,方便打印对比\n", + " old_v = V_td[state]\n", + " \n", + " # 更新 V(s)\n", + " V_td[state] = V_td[state] + alpha * td_error\n", + " \n", + " # 打印超级详细的“内心独白”\n", + " action_str = \"向右\" if next_state > state else \"向左\"\n", + " print(f\"\\n[第 {step_count} 步] 在状态 {state} 决定 {action_str},进入了状态 {next_state}。拿到真实奖励 {reward}。\")\n", + " print(f\" -> 我猜状态 {next_state} 的价值是 {V_td[next_state]:.3f}。\")\n", + " print(f\" -> 所以我的 TD 目标是 {reward} + {gamma} * {V_td[next_state]:.3f} = {td_target:.3f}。\")\n", + " print(f\" -> 我把状态 {state} 的价值从 {old_v:.3f} 更新为了 {V_td[state]:.3f}。\")\n", + " \n", + " state = next_state\n", + " if done:\n", + " print(f\"\\n游戏结束!最终到达终点 {state}。\")\n", + " break\n", + "\n", + "print(f\"\\n跑完这 1 局后的最新状态 V 表 (状态1到5): {np.round(V_td[1:6], 3)}\")\n", + "print(\"仔细看:相比于 MC 要等游戏结束,TD 在游戏过程中就已经把前面的状态价值更新了!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6057ac63", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== TD(0) 经过 500 局学习后的最终估值 ===\n", + "状态 1-5 学习到的 V 值: [0.123 0.311 0.416 0.688 0.864]\n", + "真实的理论 V 值 : [0.167, 0.333, 0.5 , 0.667, 0.833]\n", + "结论:TD(0) 完美地学会了评估这个策略的真实价值!\n" + ] + } + ], + "source": [ + "# 重新初始化\n", + "V_td_500 = np.zeros(7)\n", + "# 为了让它在终点附近也能学到正确的平均值,通常设定非终点状态价值初始值为 0.5 会收敛更快\n", + "V_td_500[1:6] = 0.5 \n", + "alpha = 0.1\n", + "gamma = 1.0\n", + "\n", + "for episode in range(500):\n", + " state = 3\n", + " while True:\n", + " next_state, reward, done = step(state)\n", + " # TD(0) 更新\n", + " td_target = reward + gamma * V_td_500[next_state]\n", + " V_td_500[state] = V_td_500[state] + alpha * (td_target - V_td_500[state])\n", + " \n", + " state = next_state\n", + " if done:\n", + " break\n", + "\n", + "print(\"=== TD(0) 经过 500 局学习后的最终估值 ===\")\n", + "print(\"状态 1-5 学习到的 V 值: \", np.round(V_td_500[1:6], 3))\n", + "print(\"真实的理论 V 值 : [0.167, 0.333, 0.5 , 0.667, 0.833]\")\n", + "print(\"结论:TD(0) 完美地学会了评估这个策略的真实价值!\")" + ] + }, + { + "cell_type": "markdown", + "id": "ab8ef2b0", + "metadata": {}, + "source": [ + "## 3. Sarsa:稳扎稳打的“老实人”\n", + "Sarsa 是一个 **同策略(On-policy)**算法。所谓“同策略”,也就是 **“知行合一”**:智能体用来在环境中瞎逛生成数据的策略(行为策略 Behavior Policy),和它在内心中不断更新优化的策略(目标策略 Target Policy)是**同一个策略**。\n", + "\n", + "**为什么叫 Sarsa?**\n", + "因为更新一次 Q 值,刚好需要这 5 个元素连在一起:当前状态 $S_t$、当前动作 $A_t$、得到的奖励 $R_{t+1}$、下一个状态 $S_{t+1}$、以及在下一个状态**实际采取**的动作 $A_{t+1}$ 。连起来就是 S-A-R-S-A。\n", + "\n", + "**核心更新公式:**\n", + "$$Q(S_t, A_t) \\leftarrow Q(S_t, A_t) + \\alpha [R_{t+1} + \\gamma Q(S_{t+1}, A_{t+1}) - Q(S_t, A_t)]$$\n", + "注意看 TD 目标:它是用下一个状态**实际走的那一步**的 $Q(S_{t+1}, A_{t+1})$ 来更新当前的。" + ] + }, + { + "cell_type": "markdown", + "id": "4e6e3d04", + "metadata": {}, + "source": [ + "## 4. Q-learning:开天辟地的“聪明人”\n", + "Q-learning 也是基于时间差分的,但它极其特殊,它是一个**异策略(Off-policy)**算法。\n", + "所谓“异策略”,就是 **“看别人踩坑,自己学经验”**。它用来收集数据的策略(比如带有随机探索的 $\\epsilon$-greedy),和它真正在心里学到的“终极通关秘籍”(绝对贪心策略)是 **分离的**。\n", + "\n", + "**核心更新公式:**\n", + "$$Q(S_t, A_t) \\leftarrow Q(S_t, A_t) + \\alpha [R_{t+1} + \\gamma \\max_a Q(S_{t+1}, a) - Q(S_t, A_t)]$$\n", + "注意看 TD 目标:不管智能体在 $S_{t+1}$ 实际采取了什么动作,它在更新心里那本账的时候,**永远假设下一步会采取最优的动作(即 $\\max_a Q$)** 。\n", + "它直接去求解了第三章的“贝尔曼最优方程(Bellman Optimality Equation)”。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c632f093", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Sarsa 的更新方式 (老实人) ---\n", + "Sarsa 的 TD 目标: 10 + 0.9 * 3.0 (状态1动作0的价值) = 12.7\n", + "\n", + "--- Q-learning 的更新方式 (聪明人) ---\n", + "Q-learning 的 TD 目标: 10 + 0.9 * 5.0 (状态1里动作1的最大价值) = 14.5\n", + "\n", + "核心结论:\n", + "Sarsa 评估的是当前的探索策略,如果当前策略经常犯错跳崖,Sarsa 就会学得非常保守 (宁愿绕远路也不靠近悬崖)。\n", + "Q-learning 默认未来一定会做最优选择,所以它学到的一定是理论上最短的通关路线,哪怕当前还在跌跌撞撞。\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# 假设我们有一个 Q 表 (状态数目为2,动作数目为2)\n", + "Q = np.array([\n", + " [1.0, 2.0], # 状态 0 的动作价值: 动作0价值=1, 动作1价值=2\n", + " [3.0, 5.0] # 状态 1 的动作价值: 动作0价值=3, 动作1价值=5\n", + "])\n", + "\n", + "# 假设智能体经历了这样一步:\n", + "# 当前在 状态0 (S_t = 0),采取了 动作0 (A_t = 0)\n", + "# 得到了奖励 10 (R_{t+1} = 10)\n", + "# 进入了 状态1 (S_{t+1} = 1)\n", + "S_t, A_t, R, S_next = 0, 0, 10, 1\n", + "\n", + "# 因为有探索率 epsilon 的存在,智能体在 状态1 脑子一抽,\n", + "# 没有选价值最高的动作1(价值5),而是“实际”采取了动作0 (A_{t+1} = 0,价值为3)\n", + "A_next = 0 \n", + "\n", + "alpha = 0.1\n", + "gamma = 0.9\n", + "\n", + "print(\"--- Sarsa 的更新方式 (老实人) ---\")\n", + "# Sarsa 说:“我不管别人怎么选,反正我下一步实际手贱选了动作 0,我就得为我实际的行动买单!”\n", + "# Sarsa 使用的是 Q(S_{t+1}, A_{t+1})\n", + "sarsa_target = R + gamma * Q[S_next, A_next] \n", + "print(f\"Sarsa 的 TD 目标: {R} + {gamma} * {Q[S_next, A_next]} (状态1动作0的价值) = {sarsa_target}\")\n", + "\n", + "\n", + "print(\"\\n--- Q-learning 的更新方式 (聪明人) ---\")\n", + "# Q-learning 说:“虽然我这一步瞎选了动作 0,但我心里门儿清,状态 1 里的最优解其实是动作 1!我是要当海贼王的男人,我的认知必须基于最优选择!”\n", + "# Q-learning 使用的是 max_a Q(S_{t+1}, a) \n", + "max_q_next = np.max(Q[S_next]) \n", + "q_learning_target = R + gamma * max_q_next\n", + "print(f\"Q-learning 的 TD 目标: {R} + {gamma} * {max_q_next} (状态1里动作1的最大价值) = {q_learning_target}\")\n", + "\n", + "print(\"\\n核心结论:\")\n", + "print(\"Sarsa 评估的是当前的探索策略,如果当前策略经常犯错跳崖,Sarsa 就会学得非常保守 (宁愿绕远路也不靠近悬崖)。\")\n", + "print(\"Q-learning 默认未来一定会做最优选择,所以它学到的一定是理论上最短的通关路线,哪怕当前还在跌跌撞撞。\")" + ] + } + ], + "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 +}