practice/04-Monte-Carlo-Methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **前言：** 刚刚读完 Sutton 的《强化学习（第二版）》第5章：蒙特卡洛方法。在本文中用尽量简单直白的语言复述本章的思想，各个知识点之间的关系。\n",
    "\n",
    "笔者阅读的是中文书籍，提到的具体公式笔者将给出其所在的英文版本的页码，英文书籍原文见 Sutton 本人官网：\n",
    "[http://incompleteideas.net/book/the-book.html](http://incompleteideas.net/book/the-book.html)。\n",
    "\n",
    "本章目录：\n",
    "5.1 蒙特卡洛预测\n",
    "5.2 动作价值的蒙特卡洛估计\n",
    "5.3 蒙特卡洛控制\n",
    "5.4 没有试探性出发假设的蒙特卡洛控制\n",
    "5.5 基于重要度采样的离轨策略\n",
    "5.6 增量式实现\n",
    "5.7 离轨策略蒙特卡洛控制\n",
    "5.8 折扣敏感的重要度采样\n",
    "5.9 每次决策型重要度采样\n",
    "5.10 本章小结\n",
    "\n",
    "****\n",
    "\n",
    "### 各小节间结构关系\n",
    "\n",
    "首先，本章介绍中指出蒙特卡洛的优点与特殊性，即：\n",
    "- 无需拥有完备的关于环境的信息，蒙特卡洛方法从真实或模拟的环境中交互采样即可；\n",
    "- 蒙特卡洛是基于每一幕进行改进的，而非每一步（而非每一次动作）进行改进（be incremental in an episode-by-episode sense, but not in\n",
    "a step-by-step (online) sense）；\n",
    "- 蒙特卡洛方法在马尔科夫性不成立时性能损失较小，因为不需要用后继状态的估计值来更新当前的估值。\n",
    "\n",
    "基于上述特点，在已知环境中的很多幕的序列的情况下，“5.1 蒙特卡洛预测”提出了两种蒙特卡洛预测方法：\n",
    "- 首次访问型MC预测算法（first-visit MC method）；\n",
    "- 每次访问型MC预测算法（every-visit MC method）。\n",
    "\n",
    "![](images/04-01.png)\n",
    "\n",
    "“5.2 动作价值的蒙特卡洛估计”则告诉读者：在实际环境中，很难保证所有“状态-动作”都出现过一遍，因此可能有采样不足的问题。因此，我们可以通过设置每个“状态-动作”的第一次采样的概率都不为0，来进行 **试探性出发** 。或者使用别的思想。接下来的讨论中， **我们先保留试探性出发的假设** 。\n",
    "\n",
    "基于广义策略迭代（GPI）的思想，“5.3 蒙特卡洛控制”讨论了使用贪心更新策略下，蒙特卡洛算法的向最优策略的收敛性（数学上可以证明，见P97-98），并且，给出了 **基于试探性出发的蒙特卡洛（蒙特卡洛 ES）** 算法框架。\n",
    "\n",
    "值得注意的是，为了保证蒙特卡洛算法收敛，我们做了两个假设：\n",
    "1. 试探性出发；\n",
    "2. 在进行策略评估时有无限多幕的样本序列进行试探。\n",
    "\n",
    "为了在应用中消除两个假设的影响，我们需要设计算法。 **基于试探性出发的蒙特卡洛（蒙特卡洛 ES）采用了GPI的思想，即不再要求在策略改进前就完成策略评估，这可以有效消除假设2的影响。**\n",
    "\n",
    "**“5.4 没有试探性出发假设的蒙特卡洛控制”以后的内容则是讨论如何消除假设1的影响。**\n",
    "\n",
    "为了消除假设1（“试探性出发”）的影响，我们采用：\n",
    "- 同轨策略（on-policy）；\n",
    "- 离轨策略（off-policy）。\n",
    "\n",
    "在通过策略中，我们观测到的“状态、动作、回报”序列是遵从我们的策略的，在我看来，可以理解为： **我们一边观测我们的系统，一边改进它；但是并非在线改进，而是以幕为单位进行改进，即遵循：“由策略生成序列-由序列更新动作期望-由期望更新最优动作-进而更新策略”** 。其算法框图见书P101：\n",
    "\n",
    "![](images/04-02.png)\n",
    "\n",
    "但是，注意到“由策略生成序列”这个步骤。在很多情况下，我们得到的序列并非是我们完全可控的，即 **我们无法由我们自己的策略生产序列** 。这就需要一种 **能够使用与自己策略无关的序列，来更新自己策略的方法了，即离轨策略。**\n",
    "\n",
    "离轨策略相对复杂，书上分为几个小节对其进行分步讲解：\n",
    "- “5.5 基于重要度采样的离轨策略”本节中主要讨论了评估离轨序列价值所要用到的概念：重要度采样比，并且提出了“普通重要度采样”与“加权重要度采样”，告诉读者“加权重要度采样”的估计方差为1，而非“普通重要度采样”的无穷，但是“加权重要度采样”是有偏的，但是偏差会收敛到0。 **其中，我还对重要度采样比有一点心得，见[1]** ；\n",
    "- “5.6 增量式实现”则对价值更新公式做了一个很简单的推导[2]；\n",
    "- 现在有了 **能够估计离轨策略价值** 的前提，可以开始讨论如何对策略进行更新了，“5.7 离轨策略蒙特卡洛控制”给出了 **离轨策略MC控制算法** ，并附有算法框图。\n",
    "- “5.8 折扣敏感的重要度采样”讨论了：如果考虑（回报中的）折扣，那么在离轨策略中，如何考虑回报、更新价值。这减小了方差，更利于收敛，即 **折扣敏感的重要度采样** ；\n",
    "- “5.9 每次决策型重要度采样”讨论了：不考虑折扣，也可减小方差。使用 **每次决策型重要度采样** 来进行无偏估计即可。\n",
    "\n",
    "书上给出了2个例子：\n",
    "1. 二十一点游戏，用于说明蒙特卡洛的基本思想；\n",
    "2. 单状态MDP，用于说明普通重要度采样的方差不收敛性。我对于证明$\\pi (\\text{left} | s) = 1$策略下的期望有一点心得，见[3]。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 补充知识点与心得\n",
    "\n",
    "#### [1] 重要度采样比心得\n",
    "\n",
    "重要度采样比定义为：在目标策略和行动策略轨迹下的相对概率。经过推导，即\n",
    "\n",
    "$$\\rho_{t:T-1} = \\prod_{k=t}^{T-1} \\frac{\\pi (A_k | S_k)}{b(A_k | S_k)}$$\n",
    "\n",
    "为什么这么定义这个参数，或者说，长成这样的公式有什么用？\n",
    "\n",
    "我们来看其使用场景，普通重要度采样：\n",
    "\n",
    "$$V(s) = \\frac{\\sum_{t \\in \\tau(s)} \\rho_{t:T(t)-1} G_t}{|\\tau(s)|}$$\n",
    "\n",
    "加权重要度采样：\n",
    "\n",
    "$$V(s) = \\frac{\\sum_{t \\in \\tau(s)} \\rho_{t:T(t)-1} G_t}{\\sum_{t \\in \\tau(s)} \\rho_{t:T(t)-1}}$$\n",
    "\n",
    "其中，二者的期望分别接近$v_{\\pi}(s)$与$v_{b}(s)$，而这个 **重要度采样比** 在其中的作用为：当观测值贴近策略$\\pi$时，此时取得的**G**更加重要，影响更大，因此其系数 **重要度采样比** 增大。\n",
    "\n",
    "#### [2] 增量式实现更新公式简单推导\n",
    "\n",
    "把下式转换为增量式：\n",
    "\n",
    "$$V_n = \\frac{\\sum^{n-1}_{k=1}W_k G_k}{\\sum^{n-1}_{k=1}W_k}, \\quad n \\ge 2$$\n",
    "\n",
    "书上没有给出，因为太简单了，我在这里证明一下。\n",
    "\n",
    "$$\\begin{aligned}\n",
    "V_{n+1} & = \\frac{\\sum^{n}_{k=1}W_k G_k}{\\sum^{n}_{k=1}W_k}, \\quad n \\ge 2 \\\\\n",
    "& = \\frac{1}{\\sum^{n}_{k=1}W_k} (W_n G_n + V_n \\sum^{n-1}_{k=1} W_k) \\\\\n",
    "& = \\frac{1}{\\sum^{n}_{k=1}W_k} (W_n G_n + V_n (\\sum^{n}_{k=1}W_k - W_n)) \\\\\n",
    "& = V_n + \\frac{1}{\\sum^{n}_{k=1}W_k} (W_n G_n - W_n V_n)\n",
    "\\end{aligned}$$\n",
    "\n",
    "即答案：\n",
    "\n",
    "$$V_{n+1} = V_n + \\frac{W_n}{C_n}[G_n - V_n]$$\n",
    "\n",
    "$$其中，C_{n+1} = C_n + W_{n+1}$$\n",
    "\n",
    "#### [2] 单状态MDP中，$\\pi (\\text{left} | s) = 1$策略下的期望\n",
    "\n",
    "![](images/04-03.png)\n",
    "\n",
    "期望 E 为：\n",
    "\n",
    "$$\\begin{aligned}\n",
    "E & = 1 \\times E(left) + 0 \\times E(right) \\\\\n",
    "& = 1 \\times E(left) \\\\\n",
    "& = 0.1 \\times 1 + 0.9 \\times E\n",
    "\\end{aligned}$$\n",
    "\n",
    "解得 E = 1 。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 两个实例\n",
    "\n",
    "代码来自 Zhang ：\n",
    "[ShangtongZhang/reinforcement-learning-an-introduction/chapter05](https://github.com/ShangtongZhang/reinforcement-learning-an-introduction/tree/master/chapter05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 5.1: Blackjack\n",
    "\n",
    "The object of the popular casino card game of blackjack is to obtain cards the sum of whose numerical values is as great as possible without exceeding 21. All face cards count as 10, and an ace can count either as 1 or as 11. We consider the version in which each player competes independently against the dealer. The game begins with two cards dealt to both dealer and player. One of the dealer’s cards is face up and the other is face down. If the player has 21 immediately (an ace and a 10-card), it is called a natural. He then wins unless the dealer also has a natural, in which case the game is a draw. If the player does not have a natural, then he can request additional cards, one by one (hits), until he either stops (sticks) or exceeds 21 (goes bust ). If he goes bust, he loses; if he sticks, then it becomes the dealer’s turn. The dealer hits or sticks\n",
    "according to a fixed strategy without choice: he sticks on any sum of 17 or greater, and hits otherwise. If the dealer goes bust, then the player wins; otherwise, the outcome—win, lose, or draw—is determined by whose final sum is closer to 21.\n",
    "\n",
    "Playing blackjack is naturally formulated as an episodic finite MDP. Each game of blackjack is an episode. Rewards of +1, −1, and 0 are given for winning, losing, and drawing, respectively. All rewards within a game are zero, and we do not discount ($\\gamma = 1$); therefore these terminal rewards are also the returns. The player’s actions are to hit or to stick. The states depend on the player’s cards and the dealer’s showing card. We assume that cards are dealt from an infinite deck (i.e., with replacement) so that there is no advantage to keeping track of the cards already dealt. If the player holds an ace that he could count as 11 without going bust, then the ace is said to be usable. In this case it is always counted as 11 because counting it as 1 would make the sum 11 or less, in which case there is no decision to be made because, obviously, the player should always hit. Thus, the player makes decisions on the basis of three variables: his current sum (12–21), the dealer’s one showing card (ace–10), and whether or not he holds a usable ace. This makes for a total of 200 states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-18T04:28:33.148403Z",
     "start_time": "2020-01-18T04:28:33.115489Z"
    }
   },
   "outputs": [],
   "source": [
    "#######################################################################\n",
    "# Copyright (C)                                                       #\n",
    "# 2016-2018 Shangtong Zhang(zhangshangtong.cpp@gmail.com)             #\n",
    "# 2016 Kenta Shimada(hyperkentakun@gmail.com)                         #\n",
    "# 2017 Nicky van Foreest(vanforeest@gmail.com)                        #\n",
    "# Permission given to modify the code as long as you keep this        #\n",
    "# declaration at the top                                              #\n",
    "#######################################################################\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from tqdm import tqdm\n",
    "\n",
    "# actions: hit or stand\n",
    "ACTION_HIT = 0\n",
    "ACTION_STAND = 1  #  \"strike\" in the book\n",
    "ACTIONS = [ACTION_HIT, ACTION_STAND]\n",
    "\n",
    "# policy for player\n",
    "POLICY_PLAYER = np.zeros(22, dtype=np.int)\n",
    "for i in range(12, 20):\n",
    "    POLICY_PLAYER[i] = ACTION_HIT\n",
    "POLICY_PLAYER[20] = ACTION_STAND\n",
    "POLICY_PLAYER[21] = ACTION_STAND\n",
    "'''\n",
    "POLICY_PLAYER 是全局变量，是 同轨控制 或 ES 试探性出发中的当前 $\\pi$\n",
    "问题：figure_5_2() 中好像没有对 POLICY_PLAYER 进行初始化？\n",
    "'''\n",
    "\n",
    "# function form of target policy of player\n",
    "def target_policy_player(usable_ace_player, player_sum, dealer_card):\n",
    "    return POLICY_PLAYER[player_sum]\n",
    "\n",
    "# function form of behavior policy of player\n",
    "'''\n",
    "应该是离轨的 b 策略（即我们能观测到的，但不可控的策略）\n",
    "'''\n",
    "def behavior_policy_player(usable_ace_player, player_sum, dealer_card):\n",
    "    if np.random.binomial(1, 0.5) == 1:\n",
    "        return ACTION_STAND\n",
    "    return ACTION_HIT\n",
    "\n",
    "# policy for dealer\n",
    "POLICY_DEALER = np.zeros(22)\n",
    "for i in range(12, 17):\n",
    "    POLICY_DEALER[i] = ACTION_HIT\n",
    "for i in range(17, 22):\n",
    "    POLICY_DEALER[i] = ACTION_STAND\n",
    "\n",
    "# get a new card\n",
    "def get_card():\n",
    "    card = np.random.randint(1, 14)\n",
    "    card = min(card, 10)\n",
    "    return card\n",
    "\n",
    "# get the value of a card (11 for ace).\n",
    "def card_value(card_id):\n",
    "    return 11 if card_id == 1 else card_id\n",
    "\n",
    "# play a game\n",
    "# @policy_player: specify policy for player\n",
    "# @initial_state: [whether player has a usable Ace, sum of player's cards, one card of dealer]\n",
    "# @initial_action: the initial action\n",
    "def play(policy_player, initial_state=None, initial_action=None):\n",
    "    # player status\n",
    "\n",
    "    # sum of player\n",
    "    player_sum = 0\n",
    "\n",
    "    # trajectory of player\n",
    "    player_trajectory = []\n",
    "\n",
    "    # whether player uses Ace as 11\n",
    "    usable_ace_player = False\n",
    "\n",
    "    # dealer status\n",
    "    dealer_card1 = 0\n",
    "    dealer_card2 = 0\n",
    "    usable_ace_dealer = False\n",
    "\n",
    "    if initial_state is None:\n",
    "        # generate a random initial state\n",
    "\n",
    "        while player_sum < 12:\n",
    "            # if sum of player is less than 12, always hit\n",
    "            card = get_card()\n",
    "            player_sum += card_value(card)\n",
    "\n",
    "            # If the player's sum is larger than 21, he may hold one or two aces.\n",
    "            if player_sum > 21:\n",
    "                assert player_sum == 22\n",
    "                # last card must be ace\n",
    "                player_sum -= 10\n",
    "            else:\n",
    "                usable_ace_player |= (1 == card)\n",
    "                '''\n",
    "                1 == 1: True 有可用的 A ，且在 1 与 11 中选择值\n",
    "                1 == others : 没有可用 A\n",
    "                '''\n",
    "\n",
    "        # initialize cards of dealer, suppose dealer will show the first card he gets\n",
    "        dealer_card1 = get_card()\n",
    "        dealer_card2 = get_card()\n",
    "\n",
    "    else:\n",
    "        # use specified initial state\n",
    "        usable_ace_player, player_sum, dealer_card1 = initial_state\n",
    "        dealer_card2 = get_card()\n",
    "\n",
    "    # initial state of the game\n",
    "    state = [usable_ace_player, player_sum, dealer_card1]\n",
    "\n",
    "    # initialize dealer's sum\n",
    "    dealer_sum = card_value(dealer_card1) + card_value(dealer_card2)\n",
    "    usable_ace_dealer = 1 in (dealer_card1, dealer_card2)\n",
    "    # if the dealer's sum is larger than 21, he must hold two aces.\n",
    "    if dealer_sum > 21:\n",
    "        assert dealer_sum == 22\n",
    "        # use one Ace as 1 rather than 11\n",
    "        dealer_sum -= 10\n",
    "    assert dealer_sum <= 21\n",
    "    assert player_sum <= 21\n",
    "\n",
    "    # game starts!\n",
    "\n",
    "    # player's turn\n",
    "    while True:\n",
    "        if initial_action is not None:\n",
    "            action = initial_action\n",
    "            initial_action = None\n",
    "        else:\n",
    "            # get action based on current sum\n",
    "            action = policy_player(usable_ace_player, player_sum, dealer_card1)\n",
    "\n",
    "        # track player's trajectory for importance sampling\n",
    "        player_trajectory.append([(usable_ace_player, player_sum, dealer_card1), action])\n",
    "\n",
    "        if action == ACTION_STAND:\n",
    "            break\n",
    "        # if hit, get new card\n",
    "        card = get_card()\n",
    "        # Keep track of the ace count. the usable_ace_player flag is insufficient alone as it cannot\n",
    "        # distinguish between having one ace or two.\n",
    "        ace_count = int(usable_ace_player)\n",
    "        if card == 1:\n",
    "            ace_count += 1\n",
    "        player_sum += card_value(card)\n",
    "        # If the player has a usable ace, use it as 1 to avoid busting and continue.\n",
    "        while player_sum > 21 and ace_count:\n",
    "            player_sum -= 10\n",
    "            ace_count -= 1\n",
    "        # player busts\n",
    "        if player_sum > 21:\n",
    "            return state, -1, player_trajectory\n",
    "        assert player_sum <= 21\n",
    "        usable_ace_player = (ace_count == 1)\n",
    "\n",
    "    # dealer's turn\n",
    "    while True:\n",
    "        # get action based on current sum\n",
    "        action = POLICY_DEALER[dealer_sum]\n",
    "        if action == ACTION_STAND:\n",
    "            break\n",
    "        # if hit, get a new card\n",
    "        new_card = get_card()\n",
    "        ace_count = int(usable_ace_dealer)\n",
    "        if new_card == 1:\n",
    "            ace_count += 1\n",
    "        dealer_sum += card_value(new_card)\n",
    "        # If the dealer has a usable ace, use it as 1 to avoid busting and continue.\n",
    "        while dealer_sum > 21 and ace_count:\n",
    "            dealer_sum -= 10\n",
    "            ace_count -= 1\n",
    "        # dealer busts\n",
    "        if dealer_sum > 21:\n",
    "            return state, 1, player_trajectory\n",
    "        usable_ace_dealer = (ace_count == 1)\n",
    "\n",
    "    # compare the sum between player and dealer\n",
    "    assert player_sum <= 21 and dealer_sum <= 21\n",
    "    if player_sum > dealer_sum:\n",
    "        return state, 1, player_trajectory\n",
    "    elif player_sum == dealer_sum:\n",
    "        return state, 0, player_trajectory\n",
    "    else:\n",
    "        return state, -1, player_trajectory\n",
    "\n",
    "# Monte Carlo Sample with On-Policy\n",
    "def monte_carlo_on_policy(episodes):\n",
    "    states_usable_ace = np.zeros((10, 10))\n",
    "    # initialze counts to 1 to avoid 0 being divided\n",
    "    states_usable_ace_count = np.ones((10, 10))\n",
    "    states_no_usable_ace = np.zeros((10, 10))\n",
    "    # initialze counts to 1 to avoid 0 being divided\n",
    "    states_no_usable_ace_count = np.ones((10, 10))\n",
    "    for i in tqdm(range(0, episodes)):\n",
    "        _, reward, player_trajectory = play(target_policy_player)\n",
    "        for (usable_ace, player_sum, dealer_card), _ in player_trajectory:\n",
    "            player_sum -= 12\n",
    "            dealer_card -= 1\n",
    "            '''\n",
    "            palyer_sum 的值大于等于 12\n",
    "            减 12 是为了将其哈希映射到 [0, #]\n",
    "            dealer_card 同理\n",
    "            '''\n",
    "            if usable_ace:\n",
    "                states_usable_ace_count[player_sum, dealer_card] += 1\n",
    "                states_usable_ace[player_sum, dealer_card] += reward\n",
    "            else:\n",
    "                states_no_usable_ace_count[player_sum, dealer_card] += 1\n",
    "                states_no_usable_ace[player_sum, dealer_card] += reward\n",
    "    return states_usable_ace / states_usable_ace_count, states_no_usable_ace / states_no_usable_ace_count\n",
    "\n",
    "# Monte Carlo with Exploring Starts\n",
    "def monte_carlo_es(episodes):\n",
    "    '''\n",
    "    书 P99\n",
    "    对策略有控制，即尝试逼近 $\\pi_*$\n",
    "    '''\n",
    "    # (playerSum, dealerCard, usableAce, action)\n",
    "    state_action_values = np.zeros((10, 10, 2, 2))\n",
    "    # initialze counts to 1 to avoid division by 0\n",
    "    state_action_pair_count = np.ones((10, 10, 2, 2))\n",
    "\n",
    "    # behavior policy is greedy\n",
    "    def behavior_policy(usable_ace, player_sum, dealer_card):\n",
    "        usable_ace = int(usable_ace)\n",
    "        player_sum -= 12\n",
    "        dealer_card -= 1\n",
    "        # get argmax of the average returns(s, a)\n",
    "        values_ = state_action_values[player_sum, dealer_card, usable_ace, :] / \\\n",
    "                  state_action_pair_count[player_sum, dealer_card, usable_ace, :]\n",
    "        return np.random.choice([action_ for action_, value_ in enumerate(values_) if value_ == np.max(values_)])\n",
    "\n",
    "    # play for several episodes\n",
    "    for episode in tqdm(range(episodes)):\n",
    "        # for each episode, use a randomly initialized state and action\n",
    "        initial_state = [bool(np.random.choice([0, 1])),\n",
    "                       np.random.choice(range(12, 22)),\n",
    "                       np.random.choice(range(1, 11))]\n",
    "        initial_action = np.random.choice(ACTIONS)\n",
    "        current_policy = behavior_policy if episode else target_policy_player\n",
    "        '''\n",
    "        current_policy 是一个函数指针\n",
    "        第 1 幕，使用 behavior_policy\n",
    "        第 1 幕后，已有学习数据，使用 target_policy_player\n",
    "        '''\n",
    "        _, reward, trajectory = play(current_policy, initial_state, initial_action)\n",
    "        for (usable_ace, player_sum, dealer_card), action in trajectory:\n",
    "            usable_ace = int(usable_ace)\n",
    "            player_sum -= 12\n",
    "            dealer_card -= 1\n",
    "            # update values of state-action pairs\n",
    "            state_action_values[player_sum, dealer_card, usable_ace, action] += reward\n",
    "            state_action_pair_count[player_sum, dealer_card, usable_ace, action] += 1\n",
    "\n",
    "    return state_action_values / state_action_pair_count\n",
    "\n",
    "# Monte Carlo Sample with Off-Policy\n",
    "def monte_carlo_off_policy(episodes):\n",
    "    '''\n",
    "    对二十一点游戏分布进行离轨策略，没有控制：\n",
    "    - 普通重要度采样\n",
    "    - 加权重要度采样\n",
    "    （因为这个问题中，每幕的回报为 0 / 1 ，因此更新公式看起来有些奇怪 \\\n",
    "        且 离轨观测序列 b 策略服从二项分布）\n",
    "    最后比较二者（两个采样率下 价值 的均方误差）\n",
    "    （我对于均方误差的更新公式存疑，需要进行数学推导）\n",
    "    '''\n",
    "    initial_state = [True, 13, 2]\n",
    "\n",
    "    rhos = []\n",
    "    returns = []\n",
    "\n",
    "    for i in range(0, episodes):\n",
    "        _, reward, player_trajectory = play(behavior_policy_player, initial_state=initial_state)\n",
    "\n",
    "        # get the importance ratio\n",
    "        numerator = 1.0\n",
    "        denominator = 1.0\n",
    "        for (usable_ace, player_sum, dealer_card), action in player_trajectory:\n",
    "            if action == target_policy_player(usable_ace, player_sum, dealer_card):\n",
    "                denominator *= 0.5\n",
    "            else:\n",
    "                numerator = 0.0\n",
    "                break\n",
    "        rho = numerator / denominator\n",
    "        rhos.append(rho)\n",
    "        returns.append(reward)\n",
    "\n",
    "    rhos = np.asarray(rhos)\n",
    "    returns = np.asarray(returns)\n",
    "    '''\n",
    "    以后多用 np.asarray() 少用 np.array()\n",
    "    '''\n",
    "    weighted_returns = rhos * returns\n",
    "\n",
    "    weighted_returns = np.add.accumulate(weighted_returns)\n",
    "    rhos = np.add.accumulate(rhos)\n",
    "\n",
    "    ordinary_sampling = weighted_returns / np.arange(1, episodes + 1)\n",
    "\n",
    "    with np.errstate(divide='ignore',invalid='ignore'):\n",
    "        weighted_sampling = np.where(rhos != 0, weighted_returns / rhos, 0)\n",
    "\n",
    "    return ordinary_sampling, weighted_sampling\n",
    "\n",
    "def figure_5_1():\n",
    "    '''\n",
    "    没有试探性出发\n",
    "    使用同轨策略\n",
    "    不仅仅评估价值，有控制\n",
    "    '''\n",
    "    states_usable_ace_1, states_no_usable_ace_1 = monte_carlo_on_policy(10000)\n",
    "    states_usable_ace_2, states_no_usable_ace_2 = monte_carlo_on_policy(500000)\n",
    "\n",
    "    states = [states_usable_ace_1,\n",
    "              states_usable_ace_2,\n",
    "              states_no_usable_ace_1,\n",
    "              states_no_usable_ace_2]\n",
    "\n",
    "    titles = ['Usable Ace, 10000 Episodes',\n",
    "              'Usable Ace, 500000 Episodes',\n",
    "              'No Usable Ace, 10000 Episodes',\n",
    "              'No Usable Ace, 500000 Episodes']\n",
    "\n",
    "    _, axes = plt.subplots(2, 2, figsize=(40, 30))\n",
    "    plt.subplots_adjust(wspace=0.1, hspace=0.2)\n",
    "    axes = axes.flatten()\n",
    "\n",
    "    for state, title, axis in zip(states, titles, axes):\n",
    "        fig = sns.heatmap(np.flipud(state), cmap=\"YlGnBu\", ax=axis, xticklabels=range(1, 11),\n",
    "                          yticklabels=list(reversed(range(12, 22))))\n",
    "        fig.set_ylabel('player sum', fontsize=30)\n",
    "        fig.set_xlabel('dealer showing', fontsize=30)\n",
    "        fig.set_title(title, fontsize=30)\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "def figure_5_2():\n",
    "    state_action_values = monte_carlo_es(500000)\n",
    "\n",
    "    state_value_no_usable_ace = np.max(state_action_values[:, :, 0, :], axis=-1)\n",
    "    state_value_usable_ace = np.max(state_action_values[:, :, 1, :], axis=-1)\n",
    "\n",
    "    # get the optimal policy\n",
    "    action_no_usable_ace = np.argmax(state_action_values[:, :, 0, :], axis=-1)\n",
    "    action_usable_ace = np.argmax(state_action_values[:, :, 1, :], axis=-1)\n",
    "\n",
    "    images = [action_usable_ace,\n",
    "              state_value_usable_ace,\n",
    "              action_no_usable_ace,\n",
    "              state_value_no_usable_ace]\n",
    "\n",
    "    titles = ['Optimal policy with usable Ace',\n",
    "              'Optimal value with usable Ace',\n",
    "              'Optimal policy without usable Ace',\n",
    "              'Optimal value without usable Ace']\n",
    "\n",
    "    _, axes = plt.subplots(2, 2, figsize=(40, 30))\n",
    "    plt.subplots_adjust(wspace=0.1, hspace=0.2)\n",
    "    axes = axes.flatten()\n",
    "\n",
    "    for image, title, axis in zip(images, titles, axes):\n",
    "        fig = sns.heatmap(np.flipud(image), cmap=\"YlGnBu\", ax=axis, xticklabels=range(1, 11),\n",
    "                          yticklabels=list(reversed(range(12, 22))))\n",
    "        fig.set_ylabel('player sum', fontsize=30)\n",
    "        fig.set_xlabel('dealer showing', fontsize=30)\n",
    "        fig.set_title(title, fontsize=30)\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "def figure_5_3():\n",
    "    true_value = -0.27726\n",
    "    episodes = 10000\n",
    "    runs = 100\n",
    "    error_ordinary = np.zeros(episodes)\n",
    "    error_weighted = np.zeros(episodes)\n",
    "    for i in tqdm(range(0, runs)):\n",
    "#     for i in range(runs):\n",
    "        ordinary_sampling_, weighted_sampling_ = monte_carlo_off_policy(episodes)\n",
    "        # get the squared error\n",
    "        error_ordinary += np.power(ordinary_sampling_ - true_value, 2)\n",
    "        error_weighted += np.power(weighted_sampling_ - true_value, 2)\n",
    "    error_ordinary /= runs\n",
    "    error_weighted /= runs\n",
    "\n",
    "    plt.plot(error_ordinary, label='Ordinary Importance Sampling')\n",
    "    plt.plot(error_weighted, label='Weighted Importance Sampling')\n",
    "    plt.xlabel('Episodes (log scale)')\n",
    "    plt.ylabel('Mean square error')\n",
    "    plt.xscale('log')\n",
    "    plt.legend()\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-18T04:28:41.719574Z",
     "start_time": "2020-01-18T04:28:33.508439Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████| 10000/10000 [00:00<00:00, 66402.87it/s]\n",
      "100%|█████████████████████████████| 500000/500000 [00:06<00:00, 71762.11it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAACJ0AAAa8CAYAAAC7xXg6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XmYdFdZL+zf8yZMCQSEBASCCbPMIARBpjCDzKKIjEEkiKBHOYriEYx8CnIO4EEOeoyAYUZARYYwiQSBAxJmSJgCJCRExgRCGBKSrO+PtZveqVR3V73d6erhvq9rXe+u2muvWrWrar9VT6/1rGqtBQAAAAAAAAAA5rFn0R0AAAAAAAAAAGD7MegEAAAAAAAAAIC5GXQCAAAAAAAAAMDcDDoBAAAAAAAAAGBuBp0AAAAAAAAAADA3g04AAAAAAAAAAJibQScAK6iqw6uqDeWoDWhvqa3j1t87YDuoquOWPvuL7stGqaqjRtezwxfdHwAAgIuL2BCwlVTVMaPryKGL7s9GqKojRs/piEX3B4C9Y9AJsNcmvhAeM8dxx/giuTVV1X5VdZYgyIVVd72q+rWqeu4wkOCsvXn/T7R726p6SVV9sap+UFVnVNVHqupPqurAOdu6cVW9oKo+W1VnV9V3q+pTVfWsqjpkzrYOqaq/HI7/7tDeZ4f2bzRnWwdV1dOG53XG8Dy/ODzv28zT1hqP85PBHXOWK2xUHwAAAHYbsaGdR2xouon37JpljnbFhuZra/+qenJVvb+qvlFVP6qqU6rqH6vqnvO0tcbjzPV6j8rNN6oPALCd7LvoDgCwpfxyksuNbt+xqq7VWvvSojq0RTwnyZM3qrGqqiTPTfK7SWq06zJJfirJzyV5UlU9rLX27zO09/tJnpnkEhO7bjyUJ1bVka2118zQ1sOT/N8kl53Ydf2hHFlVf9Ra+6sZ2rpbklcmufLErmsN5Yiqel5r7ffXagsAAADYFGJDm0BsaP7YUFXdIsnrh+PGfmYoD6mqVyV5TGvt3LXaAwA2jkEnAIw9ZuJ2JTkiydM3vytbyj4Tt7+X5NQkN9zL9p6V5PeG7e8neXGSD6X/mH9wkrsnuUqSf62qO7TWPr5SQ1X1m0n+13Dzx0lenuQ96UGGe2Y5WPTyqvpOa+1tq7R1nyQvTX++Lf2H/NuHdu+U5JFJLpnkeVX1vdbai1Zp65ZJ3pBk/+Gudyb5pyRnJ7l1kscO+/57Vf2otfYnK7W1F56W5NMz1v3+Bj7uRbTWDr842wcAAIANJja0tscn+cY62xAbmiM2NGRqeetwTpJ+rl6R5FtJbpLkyCRXSvKwJBcM/dwoL0iy5sCfwZc38HEvorV2RPrnEQC2FINOAEiSVNU10388Jslb0n/8HZTk0VV1VGvtgoV1bvFOTPJXST6S5MNJPp9+rt49b0PDrIynDDe/m+SOrbVPjqr8XfV1ov80PdBwdFX9fGvtIqlZq+qq6bNikuS8JL/YWvu3UZUXD2mK/yH9//yjq+p6rbUfTWlrvyRHZ3mAzWNaay8dVXlZVb0mybFDW39VVW9qrX19Sls1tLUUVDiqtfZnoyqvrKqXJPmPJAckeWpV/WNr7VOTbe2l97XWjtugtgAAAGBXEBua2Ttaayfv7cFiQ0nmjw397ywPOHlJkseN3o+vrqr/m+S96RlPHlFVr2mtvWWFtub10dbaGzaoLQDYkfYsugMAbBlHZDmd50uSLKXb/Jkkd1lEh7aK1trRrbUnt9Ze2Vr73LQf+XN4epbP8x9PBBWW/Fn6jI0kOSzJL67Q1lOS7Dds/9VEUGGp78cked1w8xrps0imeVySqw3br5sIKiy19c70wTdJD3qslPr0/ulpYJPkP5M8Y0pbn0jy1OHmnpgxBQAAAIt2RMSGNoPYUGaPDVXVzZI8cLj5lSRPnBwA1Vr7SpInjO46aoV+AQAXA4NOgC2pqvapqkdW1Zuq6tSq+lFV/XDY/mhVHV1VvzSMwJ92/M9W1R9U1Rur6ktV9YOqOqeq/quq3lZVv1VVl96Lft1keOwvDv35ZlX9W1X92vqf9YUe50ZV9byq+nhVnTH0/avD83l4VW3o9XuYffDo4eaZSd6cnopzyWRq1bXa27eqHlVVr6uqk6vq+8NzOLWq3lJVv1tVk2u5TraxqedgM1TV5ZLce7h5VpJjptUbBrW8YHTXr05pq5L8ytIhE/Un/fVqbU25//mrtPWC4fGS5CEztPWCVQbpHJN+HpLkvlW1/wr1NlVVtaEcN9w+qKqeUVWfqqrvVtVZVfWRqvqjqrrMGm0dt9TeKnUuPVyT3jlco86pqrOHz86Hqur5VXXvqppcl3ncxr5V9RtVdWxVnT608e2q+nBV/fkw82mW515V9YiqeldVfWu4zn2xqv6uqm40SxsT7V12+Ly/c9SvM6rq+OGcHjRDG9etqucO5/w7VfXj4bl9rqreUVVP2Zu+AQAAW5vYkNiQ2JDY0JS2jp6WpWXw1iQnDdu3qqprr1BvUw3v/1ZVJw+39x9iGR8e3tffr6pPV9VfVNUV12jrmFqOWx26Qp11XTuHNqqqHlJVr6+qrwxtfKeqPjl8Jq87x/O/79CXrw3tnFxVr6yq287axqitS1bVY4drwKkT/XruSudkoo2rVY9JfWA4/z+uqjOr6gtV9Z6q+tOqOmzevgHseq01RVGUvSrpsx/aUI6Z47hjRscdMWX/gekj+dsM5YFTjn/UjMeelOQGq/Tz8FHdo9LXAv3RKu29OcmlV2lvqd5xq9TZN/1H3flr9P0/k/z0Br6Wdx21/bej+08c7vtBksvP2NathnO71vl/91Y6B3txzsbvj5ne/0nuOzrmTWvUPWhU95tT9t94tP9Ta7S1Jz1daxvO6+Um9h+Qvt5tS/KdJHvWaO/To8e+4ZT93xrtP3CNtt48qvuL63g9jhu1c/g6X9uffFaT3CLJaau8D7+Q5Jqz9GuF/dce2pjlmnXzFdq4XpLPrnHs2Uketcbz3i99neaV2vhhkkekXw/XPNfpQbSvr9Gvs5Lcf5U2fiPJOTOcm4+v5zVXFEVRFEVRFGXvSsSGJovYUD9mx8WGJt6zh66jHbGhi9ZdNTaUvtT10v5brtHW/xnV/a0Ner2PWOd75+ShnZOTHDL6TE0rX0tyq719H2ad186hjask+X9rHHtukj9a43nvM9HfyXJ+eqaeI2Y51+nXlS+t0a9zkjx+lTbuk+R7M5yb76znNVcURdmNZd8AbD1/n542Muk/UF+d5PPpf/A8IMn1k9wxyc+vcPx+6V8OP5K+Lujn0mdoHJD+xf5X0/9Ie+0kb62qm7fWvrNGnw5L8sfD9tJ6o+cP9z82fX3S+yR5RZJfnv2pLhtmJ7w2yYOGu76Z/tw/luT7o77fKn1N3XdV1WGttR/szeNNGM9WefnE9jOTXCbJQ5P83RrP4fZJ3jHUT5Ivpj+nz6R/6b9a+ut2nyynER0fv8hzsBluPNr+yGoVW2vfrKpT0p/zgVV15dbaN/ayrQuq6mPp6zLvSXKDLKdoTZIbZvn1+Hhbe43mDydZyixx4/Qfy0mSqvrpJFcabp7SWvvWDG3dZ9TWsWvU30yXT/LPSa6e/r5+Q5Iz0q9Bj01PL3yd9PfhzVtrZ63U0DTD+/11QxtJ8vEkr0//Af3jJD+V/lrdOcnNV2jj4CTvSw9EJf2aeczw70+lp7O9d/o16piqOr+19soVuvTaJPcYtr+X5MXpr88l0t87j0i//r1zhuf24CT/mB5gOD89gPSu9ODJ5Ybn9KvD9r9U1d1ba/8+0cYt0q85e9LXpf6n9GvvN4Y+XTV9UNA9AgAA7DRiQ53Y0NaMDf19VV0//Y/zP0xyepL3J3l5a+0/1jhWbGh6W1NjQ0M2mxsMN89L8okZ2lpy4xVrLcYl0uNAN0gfMPXq9DjJIelZhm6Y/p56x3BN+spePMa6rp1DJp7/SL8+Jsl/pV/vTki/rt49PbvOJZI8q6r2tNaeuUJf/jrL2ZPOTfLS9BjWBemf3ccmeXZ6vG1VQ1aUf8vyUlLvSs9sc2qSSye5bfpgw/2S/N+qOqf1ZaXGbVw9fcmwyw53vSU9xnV6+mfiykluNjzHy6/VJwAmLHrUi6Io27fkYpjNkv7lbmkWw/FJ9l+lnUOSHDLl/htl9cwDe9LXG13qw5+uUO/wXHiE81lJbjOl3nWTfHVU78ErtLe0/7gV9v+3UZ1/SXLACvX+YlTvLzfgdTwgfbZKS3LSxL5rZHmWwwfXaOfy6V/Sl/r27CT7rlB3vyT33CrnYC/P2/j9MdP7P/1H2syzJJK8Z1T/9hP7nj7ad9QMbb10VP8RE/seNc9zSV9XeKn+n0zsu+Na7/WJ+o8Z1X/ROl6P40btHL7O13ZydsMTp9S5bJJ3j+q8YK1+Tdl3q9Hxb0qyzyp9umGSK025/62jNl6X5FJT6hyR5evqWUmuOqXOI0btnJIp19Akt0vPmDI+Nxc51+nXjaXZU19LctgKz+mw9NlTLT1IcImJ/ePZSQ9Z5dzsk+QX1vOaK4qiKIqiKIqydyViQ0v1xIbazo4NZfWMDePy5iRXXKUdsaGLtrVibCh9ws/SvpNnaOvOo/r/tkGv95qv0xptnTzxHnl2kpqoc4kkrxzVmZoFJ6tkOsnGXDv/dtT+ezMlu1H65J8fDnV+nORmU+rcIcvXjTMzJUNN+gCY/5o4Nxc51+kTlr4y7D87yb1XeE7XSY9pLdU7cGL/+Jr/lFXOTSW5w3pec0VRlN1Ytt2ah8COd63kJ9emV7XWvr9SxdbaKa21U6bcf0Jr7curHHdBa+056aO2k54adRZ/0Fr74JT2vpA+MnvJ78/Y3k9UX0N4abbMZ5P8alsha0Jr7X+kf+lPkifUXqw/POGhWZ59Mp7Jktbaqel/NE+Sn6+qG67SzhPTMw8kyatba3/YWjtvWsXW2g9aa28f37fgc7BZrjDaXmuWR5J8e4Vjd0tbe+vdo/VtVyvHzNDWa1prL5y8s7V2dvpnZ+k9+tiqmrf/1xltv6S1dv5KFVtrJ7bWxucqVXXTJPcabp6cvnzOOVOOPSY9aJD0H+pPnPIQ/320/ahp19DW2vuT/OFKfRz5g/SAZZL8Smvt+GmVhvufPNw8OMvrUC9ZOj/fTR9QM1Vr7fzW2v+boV8AAMD2IDYkNpRszdjQ99Izov5Rkoenn7ffT8/ssuQ+Sd5TVQdc9PAkWzcGsxva2lv/MGOc6bgZ2vpA+rI0bXxna+3H6deQk4e77jtk05nHuq6dVXVQljMenZUe0/nulGPfkeRpw8190+NAk/57ljPn/G5r7SKZeFprn0tfVnktj0sf/JYkT2itvXVapdbaSaP+75/kyIkq4zjc36/0YK1770r7AZjOoBNgqxmnwrzRirU2xtIfKa9dVQeuUffMJP+w0s7W2tuynEbyNkMayXncM300epL8dWvt3DXqv2L494Akt5nzsSb9+pR2x1422j5ilXYePvx7QZI/2Yt+LPIcbJbLjrZ/NEP9H462L7cL29oKnrvSjtba17P8PrxMlgeAzGq917tfGm2/oLX2wxVrJv8zfSbH5HGpqmtmefmej7TW3rNKOy9Kz04y1ZAGeela8KEZfqT/Y3p63OSiy+QsnZ/Lpc9sAgAAdgexIbGhZOvFhl6Qnjn0wa21Z7fWXtVa+8fW2nNba/dMz+6xtPTNjbNyPGGrxmB2Q1tbwfMmB5wsaa39KMnfjO560LR6q1jvtfM+SS41bL+0tfa1Ver+TfogrCR5QFXts7Sjqi6VvtRz0j8T064pSZLW2lvSl95azdKgwP9KzwazotaXbj59uLlSnCm5+P9vAdh19l10BwAmnJD+xfBq6ZkDKn3k8Yfa2muJXkhV3S19xsFh6X+wvFz6MgzTXD2rj5Z/7ww/dP89fQmMDI/5ptl7mzuMti9bVQ9co/7VR9s3yPKMk7lU1Q2yvIbn+1trX5xS7Z+SvDA97ekjq+qPJ2epVNUVs/zcP91a+9JedGch52CBpv7A1NaGeFqST89Qb621cb+bNdZETv/c/9awfVj62rCzel96MOQySf60qn4q/Uf9J2c8/taj7XesWCtJa+0rVfXZ9M/Kz1bVAaPZYoeNqr5rjXbOqar3JbnvClVulOSKw/YZM3yOk57y9ApZXqN5yTvTAyx70rPXPDPJG9raa0EDAADbm9iQ2FCyxWJD0zI1TOx/b1X9Unr2lUrymKo6qrX21dUO28guauti84L0z/ZaZolXrNXOeP9hK9aabr3XznniTD8Y4kP3Th8YdMMknxp23yzJJYft41bL7Dt4Vy4aE0qSVNXlk9x0uPlfSe7fn9aqzh7+nRZn+r1h+5+r6llJXtdaO22tBgFYm0EnwJbSWju/qh6f/mP2kukzLX49yXeq6gPpf6R9+2o/9IYvo6/NRUczr2allJdLTpqhjXGdq83x2Ely6Gj7f8557E/NWX/sMaPtl0+r0Fr7XlW9IcnDkvx0+o+JyaDJ+Ef+WqPTV3LoaHszz8FmOnu0fZkVa02v872Jfbuhrb31vtbacRvQzhdXmn0ystef+9baGVX1e+lL3+ybvtTMk6vqG+mz7d6b5K2ttZU+U1cdbX9hhof8fPoP7kr/LC8NOhn3e95r3aRDR9v3ynzZXyY/xy9O8pD0NdSvmR4oObqqTkg/P8clOXZaqlcAAGD7EhtKIjaUbMPYUGvt/VX1jvSMLfsM/75kotpWjcHshrb21kdba2/YgHbOaK2dsUad9cSZ1nvtHMeZPj/DQ34+yxlNrprlQScbGWe6RpZXbPi5JP8yQ3tLLnRNaK29tapelX4dOyjJ85I8r6q+kB5n+o8kb26tfeMiLQGwJsvrAOsxHqU8zyC2cd2LjHRurb05fWT1G5L8eLj7CulfYv8iyYer6lNVtdIfM1+f5aDC95K8KslT0lPxPTh95vyD0pd1WLLSLJclP1hjf5KM18m87Iq1prv8nPXHLrl2lYsa0h4upSc8Nz0Ys5JxGtXHTNk/DsycPWX/LDb9HCzAeFmSK81Qf1xnckmT3dDWol3cn/u01v4uyZ3TZ3UszTq5cpIHpqfiPbGq3l9Vt55y+FKa2PNaa+fM8HDjz+Y4xey43/M+50kb9jkeZhDeM31t4JOHuys9TfGR6df2r1fVC1dZKxsAALh4iQ1dmNhQt5tjQ8eNtq8/Zf9WjcHshrYWbTPiTOu5do5jRavFfpZs9TjTJabc94gkv5GeFWbJdZM8On3y0+lV9aqquuqUYwFYhUwnwHqcNdqeZ43M8Y/QqV/+W2ufSPKgqrpcktsl+YX0tVF/If0L442THFtVj2yt/WQtx6q6Y5K7DTc/keTurbVvTnuMqrrdHH3eb4Y6+4+25/1xPa5/aGvtlDmP3xv3Tp+dkvQf5mfMkJ4wSe5bVQdNnNfxe2HuH0SDRZyDzTaeJXDoDPUPWeHY3dLWol3cn/skSWvtPUneU1VXSk8lfNskd0pPo7on/br3vqq6x0QGl6UZO/tW1SVnSPM8/myOZ/uM+z3vc540buuo1tqfzdDeiobn9Jwkz6mqG6b/f3C7JHdNcnD6WsO/leR2VXXb1toPV2wMAAC4OIgNXZjYULebY0PfHm1Py76yVWMwW7Wt09IHLuyX5OCq2ndyaac52lq0zYoz7dW1MxeOFa0W+1my2XGmY1pr0wa8zWzIaPziJC+uqmsluX36eblL+uCTfZL8WpLbV9VhrbWvr+fxAHYTmU6A9fjaaPvacxw3rrvqF7fW2vdaa29rrT29tXZ4eqq+vxp2V3oKvPFMlLuNtv/HSkGFwSGr7Jt0nTnrnD5H20kyXt/1RnMeu7f29kv6JZI8fOK+r2Z5XdWpa3DOYBHnYLN9erR9q9UqVtVBWX6PfmtKasd52tqT5BbDzQty0TS3J2Y5y8YthvqrGT/euB9prX0tywGWQ6vqwL1tawu4dq0dbVvP5/5CWmvfbq29obX2h62126SvN/6qYfcl0gdfjP3XaPu6MzzEUp2WC1+/x/2e91o36WL7HLfWTmyt/X1r7YjW2jXSAwInD7tvluSxG/l4AADATMSGVq4jNjS/nRAbWivThtjQfG2N+7pv+u//vWprC7hiVV1xjTobGWea99q5t3Gmyb5ulzjTl1prL2ut/WZr7XpJbpnkY8Pua6Rn3gVgRgadAOvx8fTUm0nys8MPoVUNdZZSS56TPuNkZsMfZZ+c5MPDXVfOhb/gXmW0/cVV+nHJJIfP8dC3H45ZzZ1H28fP0XaSvGe0/aA5j53b8GPvvsPN7yb5sxnK/xo1caGgxLAe6YnDzRtX1TX3olubeg4W5Lj0932S3LGqVluL9p6j7bdO2X9C+myPJLlRVR28Slu/kOVZZO9vrV1oTdvW2llJPjjcvHyS26zUUFVdI8kNh5tfaa2dOKXa20fbK66fXVX7pWf2SJIf5sLvga3g8unrxa5mPZ/7VbXWvpqe3nMpiHvLiffMh0bbd1+treF1+9nh5meH13xaO3dZo51Lpc+SWcnHsjy77R5VNcvMmL3SWnt3kieN7rr9xfVYAADAisSGLkxsqNvNsaE7jbanZdo4LmJD47ZmiQ2N27rnlP1LbdXE/revVHeB7jzH/o2OM6117ZwnznSZLMdhzs6FBzF9Isv/L9xpYmDLNCvGolpr38rydeWWw3vvYtFa+2iWlxtLxJkA5mLQCbDXWmvnJHnHcHOfJI+f4bAnZHmN3LcNbeyNk0fb46XCxutErjbD5glJ1gyEjFwx/Y+/U1XVPbI82voDw4j+eRyb5FvD9qOq6uKezfHwLK91+7rW2lEzlKekB5OS5KZVNfnH+FcM/+5JXyN0Xpt9DjZda+3s9OeZ9B/6R0yrN/xIHv8x/R8n6wzpIF+3dEiS317loX9ntbam3P/fVmnrt4fHS1Ze63nc1u+ski3kiCwHPN7SWptlvdjN9uSVdgyB0kcMN3+Y5G0b/eBDytjTRneNr3f/PNr+7aq69CpN/UGWv/f908RjnJzlmRy3qqo7ZGW/nunpgZfaOj/JUmrWyyf541Xa2ggnj7YtGwkAAJtMbGiZ2FCSXR4bqqpfyPKghwsyZdCD2NBFHJG1Y0Pjx3j8KvGPe2c5a8aHW2srDjpboN9baccw0ee3Rnf9y8XUh5NH2+Nr51uyPCDq0VV15VXaeEKWX7c3DPGgJD/5f2HpPX6VJA9bqZGquneWBzCt5KXDv3uSPGuNuut18mhbnAlgHq01RVGUvS7pI34vSE+f+aMkD1yl7gOHOm045rZT6twz/UfN5Vdp5zrp6Slb+nqRlxnte9hwf0vyn0kuNeX4+6X/gbiNyuFT6h0+Uee7SQ6bUu/a6X8UXqr34BX6vbT/uBX2P2lU55Qkt1rj3B+W5H/u5ev28dFj3WmO4548Ou4FE/sun+VUqi3Js5Psu0I7l0lyj0Wegw1474/fH8fMcdwtRp+Z7yS56ZQ6fzpq+0NJaoW2rprk+0O9Hye565Q6R4za+kqSS6/Q1n4Tr9+jp9S52/A4S5+9q6zQViX5yKitp0+pc9PR5/j8JDdZ5+tx3Gqf5znbahPlN6fU2T/Jv630eZjWryn7Hp4+M+wyq/TlNknOG9r44pT9x4768Ookl5xS55HDOW7pWUiuukJfltr5cpJDptS57XD8WtfOg5OcmeVr/e8n2bPKczwoyZ9MfhaSPDfJbdZ4rf7PqC9PW8/rriiKoiiKoijK3pWIDSViQ0v7dmRsKMmj0jM/TI3PjD4HXx/1/R9WqSs21OaLDaUPwFhq60WZiDOkL1F8yqjOfdb5mh8zauuIdbZ18qitluSZk69n+gCHl4/qvGmGfh06sW9d185h/9+M2j8uyQFT2rhr+uC+pffczVb4PCy1c0aSm0+pc930pXjG5+Yi5zo9Bjc+h3+VKfGvUf0D0gdZ3W3i/qenf45Xi1H9wehxXrye111RFGW3lWqtBWA9quqZSZ46uuu49D+Enpr+A+PgJL+YC6cs/f9aa0+f0tYRSf4hPQXfu9ODA19K/yJ7YPoPyYekf9lMkj9vrT1tdPxlknwhydWHu76U5MXDv1cY+nG/ob23Jfmlod6dW2vHTfTl8KEPGZ7PUlrBlyZ5b/qPocOSPDbJZYd9/9xae/Dk8xraW7rgvqf1dTSn1Xlp+g/ZpH+5fVuSd6UHLmo4BzdJ/3J/7fQ/Qs+yNub4MW6R5KPDza+k/0CZ6T+DqvrpoS/7pP9guFobzUiqqtsneWeSpRkHX0yf2fCZ9Nf0p9PP2f2SfHzaedioczB6LyWrnPNZVNUV0v9wPnZIlrNcfDLJmyb2/3tr7d9XaO8vk/zhcPP76T+WP5T+PnpwltOOnp3kDq21j1+kkeW2fjPJ3w43f5zkZempSPdNn+Hxy+nn7bwk92utrZiNo6ruk+Rf01/fluT16elbz0tPD/uo9HWbk+RxrbUXrdLWLZP8R3rAIukz314/PN9bJ/mNLH+O/6K19icrtTWLqjouyylsn5bZ1+39z9baeM3a8Wf14+nXjUPTZyf9S/oP8+ulf+4PGep9Of3H83jJmov0q7VWE/uOSg8ifT/9c3N8+nXznPQUp3dID8guzTz7jdbaiyfaODj987w0O+/z6deok4a+3z/JfUaHPKK19spMUVVvHtU9K/3a+eH01/yO6a//BemDbX5xqHeRa+fQ1j2TvHHU9y+kZ1j5TPr194D04MJthue5T/p7/X2jNk5OP8dfHh7zk0m+keRS6Wvr/kqSmw/Vv53kRq21VdeCBwAALh5iQ2JDo/07LjZUVf87/Y/5p6bHBz6V5Jvpr//B6XGce2Q5+8cJSW7fWvvOKm2KDc0RG6qqQ9KvBUvLZ/1n+iCNb6e/Fx6f5ErDvle21h5xkUbmUFXHZDmz0QuSTI3xTfGpNpFhZRTfOD19UM9hST6QPnno68O+R2c5U9KZ6XGmr6zRr2u2nr12ad8RWce1c2jjcumxoOsNd301yUvSl7jZL33Q0a9mOZvu/2itPXPaiaiqF2Y5c8s56dfN96XHlm6dft3cP8kb0uNfSfKY1toxU9q6efp7eim7yunpGXA+mR7DulySaw7t3jk9dvTI1torRm0cl/4e/lr65/jjw/aeJFdLj6EtZf8IR3PcAAAgAElEQVQ9J8ktW2snTHtuAEyx6FEviqLsjJL+B/nJGSLTyg+T/N4q7TxqhjZa+pfT/50pI5PT/4h5xirHnpkeYDhqdN/hU9o5fLT/qPQBBj9apd23ZIWZAkN7PxklvkqdSp/xv9rjtFnaWuUx/np0/DP34vi3jY7/lSn7fz4XHcE/rfz7xXkOcuFZHHOfp4m2Dp2xL+Ny1Bqv8/OyPKtlWvl6krvM8fk7d5W2zkry0Bnbenj6TIeV2jo3q3yGJ9q6W/oggdU+x8/JKjOF5niNjtuL16hlygy88fsmfVDDaascf1KSa83Sryn7nj5jH89N8oerPMb1knx2jTa+n+RRa5zD/dMDQCu18cPh/XHU6L7DV2nvNunBxVme4/cyMaMpPTAyy7EnJ/m59b6HFEVRFEVRFEVZX4nYUIvY0NL+HRUbGt5ns/SjpS+Fe6UZ2hQbWv4czxQbSs8Qs1ac4ZVZJQvGHK/5MXO85uPyu1PaWvosnJw+wOSENV7zFbP7ZPVMJ+u+dg7tXCV9UMxqbfw4yVPXOIf7pA80WamN89Mzixwxuu+IVdq7fvpguVme44+S3Gvi+H+f8dhvZkoWJkVRFGX1Yk0yYEO01p5TVS9PH6F8lyQ3SF/rNuk/8j+T/sXuxW31megvTx9lfNf0kcc3Sk8Teen0kf1fTh8R/ZLW2sdW6MsHq+pmSZ6SPpr/GukBjVPTf/z/TWvtK1V16zmf4yuq6hPp6fnukj4C+gdDf1/cWnvVPO2t8BgtyZ9X1YvTR/vfNf0L9RXTfxB8K/2Pyx9Icmxr7YPztF9Vl8yF19F8xUp1V/HyLK9P++tZXjt26Tn8Z1VdL33U/QPSfxAemP6l/WvpI9Dfnj6a/yI28BzsN9r+5nxP8eI1PMcnV9XrkhyZnkXiauk/iL6UPsL/b1tr31q5lQu195yqeluS30yfdXX19HP1lSy/50+Zsa1XVtX70mci3Cc9Peme9JkN7xz6NdMo/9bavw3rLz8h/b1wrfTP8unpM12Obq19YJa2FqW19vFhBtjvpM+6OCQ9MPSF9Pf+81trP1ilidX8Rfpn4S7p74GfTf9hf4n04M4X0memvKi1dtIqffx8Vd0k/TP3y0lulj67Z+ma+bYkL2ytnb7Gc/3+kKHkEenL/tws/XN0evqMsue31k4YMrSsabgWXz99Bsz902fUHJT+Hjgr/b3+sfQsJtPWbf659ADvXdIDltdKT9V8Qfpn+pPp2VRe1lr74Sx9AgAALj5iQ2JDo+ew02JD/yt9qZjbpP9WvcrwfC6dvuTSl5P8v/Tfpx9dqZExsaH5Y0OttY9V1U3Ts5r8cnoG1culD2r5YPo1YcUsLltBa+2U4brzpPSsI9dKz8pxcvpr/pzW2hl72fy6r51DH79eVb+QnmH2oVmO55yTfg19Z/r76QtrPNfzkzx6eI//ZnoWkgPSB9a8P315rg8MGVrW1Fr73JA9537pGapum545af/0ONopST6R/v/MG1trZ040cd/0TCZ3HY69Tnr8rKX/H3VCelafF7dVshQBMJ3ldQDYkarq1ek/jFr6DIGZfvTDLOmOAQAAgK1NbIitYLS8zimttUMX2xsAuHjsWbsKAGwvVVXpM46S5LWCCgAAAAC7h9gQAMDmMegEgJ3opkmunOS8JE9bcF8AAAAA2FxiQwAAm8SgEwB2orsO/754rfVFAQAAANhxxIYAADZJtdYW3QcAgC2jqpa+HL2ntXb4IvsCAAAAwPZVVScnOSTJKa21QxfbGwC4eMh0AgAAAAAAAADA3HZFppPrPPBlO/9JbrJvf/qDi+7CjlNlDNhG2/8yV150F3ac3fB/xmb77tknL7oLO05rFyy6CzvO+Recu+guwJr2u/RBi+7CjvPtz/91LboPF4fL/MyvbbkvND/8yqt35LmG7eg69ztmy10jtrszP/fRRXdhx/GbZ+M5pxuvxTndaN6nG+/8889ZdBd2nAvaeYvuwo7js7/xLn3Jn1p0F3akM0/6mx0X2xBDmp2/cgMAAAAAAAAAMDeDTgAAAAAAAAAAmNu+i+4AAAAAbBbLWgIAAACwFjGk2TlTAAAAAAAAAADMzaATAAAAAAAAAADmZnkdAAAAdo0y9wIAAACANYghzc6ZAgAAAAAAAABgbgadAAAAAAAAAAAwN8vrAAAAsGtUbb+5F1V1ryTPT7JPkhe11v5yYv8hSV6S5KAkZyR5RGvttE3vKAAAAMAOsR1jSIviTAEAAMAWVVX7JHlhknsnuWGSX6uqG05Ue06Sl7XWbprkGUmetbm9BAAAAGC3MugEAAAAtq5bJzmptfal1tq5SV6T5AETdW6Y5F3D9run7AcAAACAi4XldQAAANg1tmFq1KsnOXV0+7QkPz9R5xNJHpy+BM+Dklyuqq7UWvv25nQRAAAAYGfZhjGkhXGmAAAAYIGq6siq+vCoHDnePeWQNnH795Pcqao+luROSb6a5LyLqbsAAAAA8BMynQAAAMACtdaOTnL0CrtPS3KN0e2Dk5w+cfzpSX4pSarqskke3Fr77sXQVQAAAAC4EINOAAAA2DWqpiUO2dKOT3LdqrpmegaThyZ52LhCVR2Y5IzW2gVJnprkJZveSwAAAIAdZBvGkBbG8joAAACwRbXWzkvypCRvT/KZJK9trZ1QVc+oqvsP1Q5P8rmq+nySqyT5i4V0FgAAAIBdR6YTAAAA2MJaa8cmOXbivqePtl+f5PWb3S8AAAAAto6quleS5yfZJ8mLWmt/ObH/kPQMuQclOSPJI1prp633cQ06AQAAYBeR8BMAAACAtWyvGFJV7ZPkhUnunuS0JMdX1RtbayeOqj0nyctaay+tqrskeVaSR673sbfXmQIAAAAAAAAAYOzWSU5qrX2ptXZuktckecBEnRsmedew/e4p+/eKQScAAAAAAAAAANvX1ZOcOrp92nDf2CeSPHjYflCSy1XVldb7wJbXAQAAYNeoMvcCAAAAgNVtxRhSVR2Z5MjRXUe31o5e2j3lkDZx+/eT/J+qOiLJfyT5apLz1tsvg04AAAAAAAAAALawYYDJ0SvsPi3JNUa3D05y+sTxpyf5pSSpqssmeXBr7bvr7dfWG54DAAAAAAAAAMCsjk9y3aq6ZlVdMslDk7xxXKGqDqzlFC5PTfKSjXhgmU4AAADYNbZialQAAAAAtpbtFkNqrZ1XVU9K8vYk+yR5SWvthKp6RpIPt9bemOTwJM+qqpa+vM4TN+KxDToBAAAAAAAAANjGWmvHJjl24r6nj7Zfn+T1G/2422t4DgAAAAAAAAAAW4JMJwAAAOwaZe4FAAAAAGsQQ5qdMwUAAAAAAAAAwNxkOgEAAGDXqDL3AgAAAIDViSHNzpkCAAAAAAAAAGBuBp0AAAAAAAAAADA3y+sAAACwa0iNCgAAAMBaxJBm50wBAAAAAAAAADA3g04AAAAAAAAAAJib5XUAAADYNaRGBQAAAGAtYkiz29Znqqreuug+AAAAALC1iSEBAADAxWPLZzqpqp9baVeSm69y3JFJjkySg252RA449M4XQ+8AAAAA2Ao2JIZ0k0fngEMO3/jOAQAAwA615QedJDk+yXvSAwSTrrDSQa21o5McnSTXeeDL2sXTNQAAALaTmvrTEtgh1h9Dut8xYkgAAACIIc1hOww6+UySx7fWvjC5o6pOXUB/AAAAANh6xJAAAABgk+1ZdAdmcFRW7udvb2I/AAAAANi6jooYEgAAAGyqLZ/ppLX2+qr62aq6a5L/bK2dPdr9o0X1CwAAgO2najvMvQD2hhgSAAAAG0UMaXZb/kxV1e8k+df0GSmfrqoHjHY/czG9AgAAAGArEUMCAACAzbflM50keVySW7bWzq6qQ5O8vqoOba09P0kttGcAAAAAbBViSAAAALDJtsOgk32W0qG21k6uqsPTgwaHRMAAAACAOUiNCjuaGBIAAAAbQgxpdtvhTH2tqm6+dGMIHtw3yYFJbrKwXgEAAACwlYghAQAAwCbbDoNOHpXka+M7WmvntdYeleSOi+kSAAAAAFuMGBIAAABssi2/vE5r7bRV9r1/M/sCAADA9iY1KuxcYkgAAABsFDGk2TlTAAAAAAAAAADMzaATAAAAAAAAAADmtuWX1wEAAICNY+4FAAAAAGsRQ5qVMwUAAAAAAAAAwNwMOgEAAAAAAAAAYG6W1wEAAGDXqDL3AgAAAIDViSHNzpkCAAAAAAAAAGBuBp0AAAAAAAAAADA3y+sAAACwa0iNCgAAAMBaxJBm50wBAAAAAAAAADA3mU4AAADYNcrcCwAAAADWIIY0O2cKAAAAAAAAAIC5GXQCAAAAAAAAAMDcLK8DAADArlFl7gUAAAAAqxNDmp0zBQAAAAAAAADA3Aw6AQAAAAAAAABgbpbXAQAAYNeoqkV3AQAAAIAtTgxpdjKdAAAAAAAAAAAwN4NOAAAAAAAAAACYm+V1AAAA2DWqzL0AAAAAYHViSLNzpgAAAAAAAAAAmJtBJwAAAAAAAAAAzM3yOgAAAOwaZe4FAAAAAGsQQ5qdMwUAAAAAAAAAwNwMOgEAAAAAAAAAYG6W1wEAAGDXqDL3AgAAAIDViSHNblcMOrnBE6+56C7sOJ97+vcX3YUdp13hUovuwo7TLr0rLnGb6uzPnbDoLuw4V/m5uy66CztOnXXOoruw8+xTi+7BjtP2u8Siu7DjXHCV/RfdBQB2gJv97rUX3YUd5xPP912SbeC8Cxbdgx2nvnfuoruw8+zrD18b7YKz/J1jo11wgc/+RttnH3872mjn3ef6i+4C7Di+pQAAAAAAAAAAMDdpAAAAANg1pEYFAAAAYC1iSLNzpgAAAAAAAAAAmJtBJwAAAAAAAAAAzM3yOgAAAOwaZe4FAAAAAGsQQ5qdMwUAAAAAAAAAwNwMOgEAAAAAAAAAYG6W1wEAAGD3KHMvAAAAAFiDGNLMnCkAAAAAAAAAAOYm0wkAAAC7RpmlAgAAAMAaxJBm50wBAAAAAAAAADA3g04AAAAAAAAAAJib5XUAAADYNapq0V0AAAAAYIsTQ5qdTCcAAAAAAAAAAMzNoBMAAAAAAAAAAOZmeR0AAAB2jTL3AgAAAIA1iCHNzpkCAAAAAAAAAGBuBp0AAAAAAAAAADA3y+sAAACwa1SZewEAAADA6sSQZudMAQAAAAAAAAAwN4NOAAAAAAAAAACYm+V1AAAA2D2qFt0DAAAAALY6MaSZyXQCAAAAAAAAAMDcDDoBAAAAAAAAAGBultcBAABg9zD1AgAAAIC1iCHNzKkCAAAAAAAAAGBuBp0AAAAAAAAAADA3y+sAAACwe1QtugcAAAAAbHViSDOT6QQAAAAAAAAAgLkZdAIAAAAAAAAAwNwsrwMAAMDuITUqAAAAAGsRQ5qZTCcAAAAAAAAAAMzNoBMAAAAAAAAAAOZmeR0AAAB2D1MvAAAAAFiLGNLMnCoAAAAAAAAAAOa25QedVNXlq+ovq+qzVfXtoXxmuO8Ki+4fAAAAAIsnhgQAAACbb8sPOkny2iRnJjm8tXal1tqVktx5uO91Kx1UVUdW1Yer6sOnvOWNm9RVAAAAtrJWteUKsGHWHUP68pvFkAAAABBDmsd2GHRyaGvt2a21ry3d0Vr7Wmvt2Ul+ZqWDWmtHt9Zu1Vq71SH3uf+mdBQAAACAhVl3DOma9xVDAgAAgHlsh0Enp1TVU6rqKkt3VNVVquoPk5y6wH4BAACw3dQWLMBGEUMCAABgYyw6XrSNYkjbYdDJrya5UpL3VNWZVXVGkuOSXDHJQxbZMQAAAAC2DDEkAAAA2GT7LroDa2mtnVlV/5DknUk+2Fo7e2lfVd0rydsW1jkAAAAAtgQxJAAAANh8Wz7TSVX9TpJ/TfKkJJ+uqgeMdj9zMb0CAABgW9pTW68AG0IMCQAAgA2z6HjRNoohbflMJ0kel+SWrbWzq+rQJK+vqkNba8/Pll65CAAAAIBNJIYEAAAAm2w7DDrZZykdamvt5Ko6PD1ocEgEDAAAAADoxJAAAABgk2355XWSfK2qbr50Ywge3DfJgUlusrBeAQAAsP1Ubb0CbBQxJAAAADbGouNF2yiGtB0GnTwqydfGd7TWzmutPSrJHRfTJQAAAAC2GDEkAAAA2GRbfnmd1tppq+x7/2b2BQAAAICtSQwJAAAANt+WH3QCAAAAG2brZiIFAAAAYKsQQ5rZdlheBwAAAAAAAACALcagEwAAAAAAAAAA5mZ5HQAAAHaPPXKjAgAAALAGMaSZyXQCAAAAAAAAAMDcDDoBAAAAAAAAAGBultcBAABg9yipUQEAAABYgxjSzGQ6AQAAAAAAAABgbgadAAAAAAAAAAAwN8vrAAAAsHvIjAoAAADAWsSQZibTCQAAAAAAAAAAczPoBAAAALawqrpXVX2uqk6qqj9aoc5DqurEqjqhql612X0EAAAAYHeyvA4AAAC7x57tlRu1qvZJ8sIkd09yWpLjq+qNrbUTR3Wum+SpSW7XWjuzqq68mN4CAAAA7BDbLIa0SDKdAAAAwNZ16yQntda+1Fo7N8lrkjxgos7jkrywtXZmkrTWvrHJfQQAAABglzLoBAAAALauqyc5dXT7tOG+sesluV5Vvb+qPlhV99q03gEAAACwq1leBwAAgN1jC2ZGraojkxw5uuvo1trRS7unHNImbu+b5LpJDk9ycJL3VtWNW2vf2ei+AgAAAOwKWzCGtFUZdAIAAAALNAwwOXqF3aclucbo9sFJTp9S54OttR8n+XJVfS59EMrxG91XAAAAABgz6AQAAIBdo9W2m6ZyfJLrVtU1k3w1yUOTPGyizhuS/FqSY6rqwPTldr60qb0EAAAA2EG2YQxpYfYsugMAAADAdK2185I8Kcnbk3wmyWtbaydU1TOq6v5Dtbcn+XZVnZjk3Un+oLX27cX0GAAAAIDdRKYTAAAA2MJaa8cmOXbivqePtluSJw8FAAAAADaNQScAAADsHnukRgUAAABgDWJIM7O8DgAAAAAAAAAAczPoBAAAAAAAAACAuVleBwAAgN1DZlQAAAAA1iKGNDOZTgAAAAAAAAAAmJtBJwAAAAAAAAAAzG1XLK/z2zf83qK7sONc+c3XWHQXdpx//cqlF92FHed2Vz530V3Ycd779bsvugs7zo2ucN6iu7DjXOuA8xfdhR3nJZ/fb9Fd2HH+6KZnL7oLO865Fyy6B2wbJTcqsLJ/uutVFt2FHee7d/j+oruw41x6nysuugs7zjkXnLXoLuw4513wg0V3YcfZf9+rLroLO845F3xn0V2ANV3QxI832iX2iHUyIzGkmcl0AgAAAAAAAADA3Aw6AQAAAAAAAABgbrtieR0AAABIkuyRGhUAAACANYghzUymEwAAAAAAAAAA5mbQCQAAAAAAAAAAc7O8DgAAALuHzKgAAAAArEUMaWYynQAAAAAAAAAAMDeDTgAAAAAAAAAAmJvldQAAANg9Sm5UAAAAANYghjQzmU4AAAAAAAAAAJibQScAAAAAAAAAAMzN8joAAADsHlKjAgAAALAWMaSZyXQCAAAAAAAAAMDcDDoBAAAAAAAAAGBuBp0AAACwe+zZggUAAACArWXR8aK9iCFV1b2q6nNVdVJV/dEKdR5SVSdW1QlV9ap5TslK9t2IRgAAAAAAAAAA2HxVtU+SFya5e5LTkhxfVW9srZ04qnPdJE9NcrvW2plVdeWNeGxzqgAAAAAAAAAAtq9bJzmptfal1tq5SV6T5AETdR6X5IWttTOTpLX2jY14YJlOAAAA2D2qFt0DAAAAALa67RdDunqSU0e3T0vy8xN1rpckVfX+JPskOaq19rb1PrBBJwAAAAAAAAAAW1hVHZnkyNFdR7fWjl7aPeWQNnF73yTXTXJ4koOTvLeqbtxa+856+mXQCQAAALvHtpukAgAAAMCm24IxpGGAydEr7D4tyTVGtw9OcvqUOh9srf04yZer6nPpg1COX0+/9qznYAAAAAAAAAAAFur4JNetqmtW1SWTPDTJGyfqvCHJnZOkqg5MX27nS+t9YINOAAAAAAAAAAC2qdbaeUmelOTtST6T5LWttROq6hlVdf+h2tuTfLuqTkzy7iR/0Fr79nof2/I6AAAA7BptzxbMjQoAAADAlrIdY0ittWOTHDtx39NH2y3Jk4eyYWQ6AQAAAAAAAABgbgadAAAAAAAAAAAwN8vrAAAAsHvU9kuNCgAAAMAmE0OamUwnAAAAAAAAAADMzaATAAAAAAAAAADmZnkdAAAAdg+ZUQEAAABYixjSzGQ6+f/Zu/doW++yPvTfZ+0dwk3DPQfCVQlqOFY6DqIeQSkBCZdCG7GEjFMw3ZKi0nKktkXL4JQ4WtRWW7WpsjVcRDFQ5RIghFICCANlZA8bIwGBgMFcBLkEQrgk2clz/lhzl9XF2nvNd66515zzXZ/PGHO8a873fefvGWvsZK/13c98fgAAAAAAAAAADKbpBAAAAAAAAACAwWyvAwAAwN6xZjYqAAAAANuQIU3NpBMAAAAAAAAAAAbTdAIAAAAAAAAAwGC21wEAAGDvKKNRAQAAANiGDGlqJp0AAAAAAAAAADDY0jedVNVdq+q8qrqyqr5UVZ+tqj+tqh/f5r5zq+pQVR26+PfevkvVAgAAALAI88iQDh583S5VCwAAAOOwCtvr/H6SNyZ5YpJ/lOQuSS5M8uKqelh3//xWN3X3wSQHk+S/X3dx71KtAAAALDOTUWHMdpwhJR+TIQEAACBDGmDpJ50keXB3v6q7r+3uX03ytO7+eJJzkpy54NoAAAAAWA4yJAAAANhlq9B08pWqenSSVNXfT/KFJOnu26O/CAAAAIB1MiQAAADYZauwvc7zkvxOVT0syYeS/JMkqap7Jzl/kYUBAACwYtb8uzOMmAwJAACA+ZAhTW3pm066+4okj9ri9c9W1ZcXUBIAAAAAS0aGBAAAALtvFbbXOZaXLroAAAAAAJaeDAkAAACOg6WfdFJVVxztVJKTd7MWAAAAVpzRqDBaMiQAAADmRoY0taVvOsl6KPDEJDdser2SfGD3ywEAAABgCcmQAAAAYJetQtPJW5Pctbsv33yiqt6z++UAAAAAsIRkSAAAALDLlr7ppLsPHOPc2btZCwAAAKutTUaF0ZIhAQAAMC8ypOmtLboAAAAAAAAAAABWz9JPOgEAAIC5WfMxFQAAAAC2IUOamkknAAAAAAAAAAAMpukEAAAAAAAAAIDBbK8DAADA3lFGowIAAACwDRnS1Ew6AQAAAAAAAABgME0nAAAAAAAAAAAMZnsdAAAA9o41o1EBAAAA2IYMaWomnQAAAAAAAAAAMJimEwAAAAAAAAAABrO9DgAAAHuHj14AAAAAsB0Z0tR8qwAAAAAAAAAAGEzTCQAAAAAAAAAAg9leBwAAgL2jatEVAAAAALDsZEhTM+kEAAAAAAAAAIDBNJ0AAAAAAAAAADCY7XUAAADYO9aMRgUAAABgGzKkqZl0AgAAAAAAAADAYJpOAAAAAAAAAAAYzPY6AAAA7BldRqMCAAAAcGwypOmZdAIAAAAAAAAAwGCaTgAAAAAAAAAAGMz2OgAAAOwdPnoBAAAAwHZkSFPzrQIAAAAAAAAAYDBNJwAAAAAAAAAADGZ7HQAAAPaOtVp0BQAAAAAsOxnS1PZE08lJJ/SiSxidX/3Qtyy6hNF58v2/tugSRufQ505YdAmj8yOn3LzoEkbnK4f90DJvn/maQW7z9s9O+8qiSxid93/G31Hz9oh7Hl50CQCMwNcOf27RJYzOXfbfd9EljM5XDv/NoksYnao9EZPvqltvX3QF43Pr7V9edAmjc+ttMvl5O+yf4+bujvvusOgSRuf2vnXRJcDo+GkaAACAvaM0fAIAAACwDRnS1HwUGAAAAAAAAACAwTSdAAAAAAAAAAAwmO11AAAA2DvWjEYFAAAAYBsypKmZdAIAAAAAAAAAwGCaTgAAAAAAAAAAGMz2OgAAAOwdJqMCAAAAsB0Z0tRMOgEAAAAAAAAAYDBNJwAAAAAAAAAADGZ7HQAAAPaMXjMbFQAAAIBjkyFNz6QTAAAAAAAAAAAG03QCAAAAAAAAAMBgttcBAABg7zAaFQAAAIDtyJCmZtIJAAAAAAAAAACDaToBAAAAAAAAAGAw2+sAAACwd5TRqAAAAABsQ4Y0NZNOAAAAAAAAAAAYTNMJAAAAAAAAAACD2V4HAACAvcNHLwAAAADYjgxpar5VAAAAAAAAAAAMpukEAAAAAAAAAIDBbK8DAADA3lG16AoAAAAAWHYypKmZdAIAAAAAAAAAwGCaTgAAAAAAAAAAGMz2OgAAAOwda0ajAgAAALANGdLUTDoBAAAAAAAAAGAwTScAAAAAAAAAAAxmex0AAAD2DqNRAQAAANiODGlqJp0AAAAAAAAAADCYSScAAADsGV0+pQIAAADAscmQpmfSCQAAAAAAAAAAg2k6AQAAAAAAAABgMNvrAAAAsHf46AUAAAAA25EhTc23CgAAAAAAAACAwTSdAAAAAAAAAAAwmKYTAAAA9o6q5XtsW3KdUVUfraqrqupFW5x/XlX9RVVdXlXvr6rTjsv3DgAAAGCvWHReNEOGtChL33RSVY+sqndX1e9V1QOq6p1V9aWquqyq/u4x7ju3qg5V1aE3/e4lu1kyAAAAzEVV7UtyfpInJTktybO2aCp5bXd/d3c/IskvJ/nVXS4TlsI8MqQLfvvNu1kyAAAArLz9iy5gCv81yf+X5G5JPpDkZ7r7CVV1+uTcD2x1U3cfTHIwST74t2/rXaoVAAAA5ulRSa7q7k8mSVVdmOTpST585ILuvnHD9XdJ4ndg9qodZ0hfO/wB//0AAADAAEs/6STJCd399u7+gyTd3X+Y9S/eleSOiy0NAACAlbJWS/fYOGVh8jh3Q8WnJLlmw/NrJ6/9b6rqp6vqE1mfdPLPj+83EZaWDAkAAID5WILM6JseS2oVJp18vaxcOHAAACAASURBVKp+JMlJSbqq/kF3v6mqfjjJbQuuDQAAAHZk45SFLWyVKHzTJIbuPj/J+VV1dpIXJ3nO/CqElSFDAgAAgF22Ck0nz8v6J7VuT/LEJD9ZVa9Kcl2S5y6wLgAAADjerk3ygA3P75/k+mNcf2GS3zyuFcHykiEBAADALlv6ppPu/vOsBwVHvGDySFWdk/U9egEAAGB7SzyK9CguS3JqVT0k6/9wflaSszdeUFWndvfHJ0+fkuTjgT1IhgQAAMDcrF6GtDBriy5gh1666AIAAADgeOnuw0men+QdST6S5PXdfWVVnVdVT5tc9vyqurKqLk/ywthaB7YiQwIAAIDjYOknnVTVFUc7leTk3awFAAAAdlt3X5zk4k2vvWTD1y/Y9aJgCcmQAAAAYPctfdNJ1kOBJya5YdPrFWNRAQAAGMJkVBgzGRIAAADzIUOa2io0nbw1yV27+/LNJ6rqPbtfDgAAAABLSIYEAAAAu2zpm066+8Axzp29m7UAAAAAsJxkSAAAALD7lr7pBAAAAOal18xGBQAAAODYZEjTW1t0AQAAAAAAAAAArB5NJwAAAAAAAAAADGZ7HQAAAPaOMhoVAAAAgG3IkKZm0gkAAAAAAAAAAINpOgEAAAAAAAAAYDDb6wAAALB3rBmNCgAAAMA2ZEhTM+kEAAAAAAAAAIDBTDoBAABg7/AhFQAAAAC2I0OamkknAAAAAAAAAAAMpukEAAAAAAAAAIDBbK8DAADAnrHmoxcAAAAAbEOGND3fKgAAAAAAAAAABtN0AgAAAAAAAADAYLbXAQAAYM+oWnQFAAAAACw7GdL0TDoBAAAAAAAAAGAwTScAAAAAAAAAAAxmex0AAAD2DKNRAQAAANiODGl6Jp0AAAAAAAAAADCYphMAAAAAAAAAAAbb0fY6VXVykscnOS3J3ZPccYrbursP7GRdAAAAmEWZjQoLIUMCAABglciQpjdT00lV3TPJf0pyVpJ9M7yFwAAAAABg5GRIAAAAMG6Dm06q6luSvC/JdySZpb2nZ7gHAAAAgBUiQwIAAIDxm2XSyc8n+c7J13+T5L8keX+SzyS5eU51AQAAwNyZjAq7SoYEAADASpIhTW+WppMzJ8erk3xfd392fuUAAAAAMBIyJAAAABi5tRnueWDWx5ueLywAAAAA4ChkSAAAADBys0w6uSHJyUk+Nedajpt9s7TWcEzff29TcOft6pv2LbqE0Tnr276+6BJG52M3+nM6b3/2uRMWXcLo/OWX7rDoEkbnLz/rv/15+/5Tbll0CaNzBz/zz91pd1t0BceH0aiwq1YuQ7rT/nstuoTR+ezX/3LRJYzOPn+Xzd3Nh29ddAmjc6JfI+fuK4dvWnQJo3Pzbf6HOm9rvqVzd3v7O2re7nKCv6SYjgxperNEsx+ZHO87z0IAAAAAGBUZEgAAAIzcLE0nFySpJM+Ycy0AAAAAjIcMCQAAAEZulqaTC5NckuTRVfUv51wPAAAAHDe1tnwPGDEZEgAAACtp0XnRKmVIg0vr7tuT/KMkb0vyi1X1lqp6UlXdc+7VAQAAALCSZEgAAAAwfvtnuam7b6qqZyd5Z5InTx6pqilv75nWBQAAAGB1yJAAAABg3Gb6xb2qnpDkdUlOOvLS3CoCAACA42S6f+cG5kWGBAAAwCqSIU1vcNNJVT08yUVJTpy81En+Kslnktw8v9IAAAAAWFUyJAAAABi/WSad/JushwWd5HeSvLS7r59rVQAAAACsOhkSAAAAjNwsTSf/d9bDgrd19z+dcz0AAABw3KwZjQq7SYYEAADASpIhTW9thnvuMzm+YZ6FAAAAADAqMiQAAAAYuVkmnXw6yYOSfG3OtQAAAMBxVT6lArtJhgQAAMBKkiFNb5ZJJ++bHB8+z0IAAAAAGBUZEgAAAIzcLE0nv5HktiTPrapvnXM9AAAAAIyDDAkAAAB2SVWdUVUfraqrqupFW5x/XlX9RVVdXlXvr6rT5rHu4KaT7j6U5IVZ35f3kqq6/zwKAQAAgOOtavkeMFYyJAAAAFbVovOioRlSVe1Lcn6SJyU5LcmztmgqeW13f3d3PyLJLyf51Xl8r/YPvaGqnp3kxiRvSPKjST5eVW9J8sEkn09y+3bv0d2/O3RdAAAAAFaHDAkAAAB2zaOSXNXdn0ySqrowydOTfPjIBd1944br75Kk57Hw4KaTJK/asHgnOTHrwcGPTnl/JxEYAAAAAIzbqyJDAgAAgN1wSpJrNjy/Nsn3bb6oqn4661NJ75DkcfNYeJamkyTZPLzFQGAAAACWXtnPBnabDAkAAICVs4wZUlWdm+TcDS8d7O6DR05vccs3TTLp7vOTnF9VZyd5cZLn7LSuWZpOztnpogAAAACMngwJAAAA5mTSYHLwKKevTfKADc/vn+T6Y7zdhUl+cx51DW466e5Xz2NhAAAAAMZLhgQAAAC75rIkp1bVQ5Jcl+SsJGdvvKCqTu3uj0+ePiXJxzMHs26vAwAAACun1hZdAQAAAADLbtUypO4+XFXPT/KOJPuSvKK7r6yq85Ic6u6Lkjy/qh6f5NYkN2QOW+skmk4AAAAAAAAAAFZad1+c5OJNr71kw9cvOB7rrlh/DgAAAAAAAAAAy2DwpJOqeuBOF+3uv97pewAAAMBQVYuuAPYOGRIAAACrSoY0vVm217k6Se9gzZ5xXQAAAABWx9WRIQEAAMCozfqLu74eAAAAALYjQwIAAIARm6Xp5NVTXLOW5F5JHpnk3ln/ZMqlSa6dYT0AAACYC6NRYVfJkAAAAFhJMqTpDW466e5zpr22qtaSPCvJryf57iQ/392XDV0TAAAAgNUiQwIAAIDxWzueb97dt3f37yd5YpJ7JHlDVd3zeK4JAAAAwGqRIQEAAMBqOq5NJ0d096EkFya5X5J/vhtrAgAAwGZVy/cAvkGGBAAAwDJYdF60ShnSrjSdTLw7SSU5cxfXBAAAAGC1yJAAAABgRexm08lNk+ODdnFNAAAAAFaLDAkAAABWxP5dXOu0ybF3cU0AAAD4X9aWeBQp8L/IkAAAAFgoGdL0dmXSSVU9MMlPZT0s+PhurAkAAADAapEhAQAAwGoZPOlk8sv/NO6Q5H5JHpfkp5PcM+uBweuGrgkAAADAapEhAQAAwPjNsr3O1Zl9vOnlSX59xnsBAABgR8poVNhNV0eGBAAAwAqSIU1v1u11auDj9iSvSfL47r55hzUDAAAAsBpkSAAAADBis0w6efWU192c5ItJPpzknd39NzOsBQAAAHPjUyqwq2RIAAAArCQZ0vQGN5109znHo5Cjqao/S/KGJH/Q3Z8YcN+5Sc5Nkp/7lefnzGefcZwqBAAAAGCzVcyQXv7y83Luuc88ThUCAADA+Mwy6WS33T3J3ZK8u6o+neQPkryuu68/1k3dfTDJwSQ59Lm3zbp/MAAAAACrYccZUvIxGRIAAAAMsLboAqZwQ3f/bHc/MMm/SHJqkj+rqndPPokCAAAAU6m1WroHMDcyJAAAAOZi0XnRKmVIx63ppKoeXlXnVtVPVdUPzuM9u/t93f1TSU5J8ktJfmAe7wsAAADAYsiQAAAAYHUN3l6nqk5O8q8nT1/V3Vdscc1vJXnuptf+OMmZ3X3DwCU/tvmF7r4tySWTBwAAAABLRoYEAAAA4zfLpJOnJvl/sx4IfHLzyap6QZJzk9Smxw8lef3Qxbr7rKOdq6pzhr4fAAAAe1fV8j1gxGRIAAAArKRF50WrlCHN0nRyxuT47u6+aeOJqtqf5OcmT29O8h+TPD/JZVkPDR5XVU+esdatvHSO7wUAAADA/MiQAAAAYOQGb6+T5DuTdJIPbnHucUnuMzn/vO5+dZJU1auSfDTJ/ZKcneTiaRerqm8avXrkVJKTp64aAAAAgN0kQwIAAICRm6Xp5F6T49VbnHvc5Hhjkt8/8mJ3f7WqXpvkXyZ55MD1Tk7yxCSb9/GtJB8Y+F4AAADsYcs8ihRGSIYEAADASpIhTW+WppN7TI5f3eLcD2b9EyqXdvfhTec+OjmeMnC9tya5a3dfvvlEVb1n4HsBAAAAsDtkSAAAADByszSd3DK576SNL1bVHfONT6C8f4v7vjQ5njhkse4+cIxzZw95LwAAAAB2jQwJAAAARm5thnuumxz/7qbXH59vhAFbjSy92+R40wxrAgAAwI5VLd8DRkyGBAAAwEpadF60ShnSLE0nf5r1vXD/n6r69iSpqn1JfnZy/otJDm1x33dNjn89w5oAAAAArBYZEgAAAIzcLE0nr5wc75bksqp6Y5I/T/JDWd+L9/e6+7Yt7nvM5Pz/nKVQAAAAAFaKDAkAAABGbv/QG7r7vVV1QZIDWQ8Nnrbh9PVJfmHzPVX14CTfm/XA4N2zFAoAAAA7tbbEo0hhbGRIAAAArCoZ0vRmmXSSJOcm+ZkkVya5JevjUF+f5NHd/bktrv/pDV+/a8Y1AQAAAFgtMiQAAAAYscGTTpKkuzvJr00e0/iVJP9lcut1s6wJAAAAwGqRIQEAAMC4zdR0MlR3f3o31gEAAIBjKaNRYanJkAAAAFgGMqTpzbq9DgAAAAAAAAAAe5imEwAAAAAAAAAABtuV7XUAAABgGZSPXgAAAACwDRnS9HyrAAAAAAAAAAAYTNMJAAAAAAAAAACD2V4HAACAPaNq0RUAAAAAsOxkSNMz6QQAAAAAAAAAgME0nQAAAAAAAAAAMJjtdQAAANgzymxUAAAAALYhQ5re4KaTqnrF5MvLu/vX51wPAAAAACMgQwIAAIDxm2XSyY8n6SR/Pt9SAAAA4PjyIRXYVT8eGRIAAAArSIY0vbUZ7vn85HjdPAsBAAAAYFRkSAAAADByszSd/NXkeK95FgIAAADAqMiQAAAAYORmaTp5Y5JK8uQ51wIAAADHVdXyPWDEZEgAAACspEXnRauUIc3SdPKbSa5N8pSqOnPO9QAAAAAwDjIkAAAAGLnBTSfd/cUkT8/6frwXVtV/qKoHzb0yAAAAAFaWDAkAAADGb//QG6rq0smXX0xy/yQvTPLCqrou6yHC17Z5i+7u04euCwAAADu1zKNIYWxkSAAAAKwqGdL0BjedJHlskp58feRYSU6ZPI6lNtwDAAAAwHg9NjIkAAAAGLVZmk6S9V/8p3ltKbSIYu4OfMfdF13C6HzXP7160SWMzre+8KRFlwDbevapX190CaPzua/fvOgSRufm25b2x7yVdaf9fkCdtzvt8z0FWFIrlSF9+dZrFl3C6Nzur+i52+cjl3N34r5FVzA+h/23P3df97v53N3tDicsuoTR+fKtty66hNG5835/Tuft8O0yeZi3wU0n3b12PAoBAACA421NVg+7RoYEAADAqpIhTc8v/wAAAAAAAAAADKbpBAAAAAAAAACAwQZvrwMAAACrymhUAAAAALYjQ5rejptOquqUJKcn+a4kd09yQncf2On7AgAAADAeMiQAAAAYn5mbTqrqPkn+c5JnJNl35OUkneTApmv/a5KfSHJNd3/7rGsCAAAAsFpkSAAAADBeMzWdVNWpSd6b5OSshwTb+Y0kz0vy4Kp6bHe/Z5Z1AQAAYCfWqhddAuwpMiQAAABWkQxpemtDb6iqE5K8Ncn/kfWw4DVJnpjk+Ue7p7s/kuQvJk/PGF4mAAAAAKtEhgQAAADjN8ukkwNJTs36CNTndfdvJ0lV3Xmb+96b5LuTfN8MawIAAACwWmRIAAAAMHKzNJ2cOTleeiQsmNKVk+PDZlgTAAAAdmxtms09gHmRIQEAALCSZEjTG7y9TtY/adJJ3jTwvi9MjnefYU0AAAAAVosMCQAAAEZulqaTe0yOnx543yxTVQAAAGBPq6ozquqjVXVVVb1oi/MnVtXrJuc/WFUP3v0qYUsyJAAAABi5WX6J/1KSeyY5aeB9D5ocPz/DmgAAALBjs3zyYpGqal+S85M8Icm1SS6rqou6+8MbLjuQ5IbufmhVnZXkl5I8c/erhW8iQwIAAGAlrVqGtEizfK/+anJ81MD7npT1kaofmmFNAAAA2IseleSq7v5kd9+S5MIkT990zdOTvHry9R8mOb2q7DzMMpAhAQAAwMjN0nTyziSV5Kyquvc0N1TVjyR5zOTpO2ZYEwAAAPaiU5Jcs+H5tZPXtrymuw/nG9MlYNFkSAAAADByszSdvDzJzUm+JckfVdUxR6RW1elJXjt5emOSV8ywJgAAAOzYWvXSParq3Ko6tOFx7oaSt5pY0pueT3MNLIIMCQAAgJW06Lxoq8ey2j/0hu6+pqrOS/Lvkvxgko9V1SuyoYGlqh6d5P9M8g+TPD7rAVgn+RfdfeM8CgcAAIAx6O6DSQ4e5fS1SR6w4fn9k1x/lGuurar9SU5K8oV51wlDyZAAAABg/AY3nSRJd7+squ6T5AVJ7p3kXx05NTm+d8PlRz5xdV53+4QKAAAATO+yJKdW1UOSXJfkrCRnb7rmoiTPSfInSZ6R5NLuXt6Pv7CnyJAAAABg3GZqOkmS7v6ZqnpPkpcm+TvHuPTKJD/X3W+ddS0AAACYh7WtNqJZYt19uKqen+QdSfYleUV3XzmZHnGouy9KckGS11TVVVmfcHLW4iqGbyZDAgAAYNWsWoa0SDM3nSRJd785yZur6u8keUySB2d9jO9NWf8E1nu7+9BOiwQAAIC9qrsvTnLxptdesuHrryf5sd2uC4aQIQEAAMA47ajp5IjuviLJFfN4LwAAADhe1hZdAOxxMiQAAABWgQxper5XAAAAAAAAAAAMNrjppKpeW1WPPQ61AAAAADASMiQAAAAYv1m21zkryTOr6pNJfjvJq7r7b+dbFgAAAMzfWi26AthTZEgAAACsJBnS9GbdXqeSfFuSlyW5pqr+W1U9cX5lAQAAADACMiQAAAAYsVmaTv6vJC9P8uWsBwcnJDkzycVVdXVVvbiqTpljjQAAAACsHhkSAAAAjNzgppPu/p/d/ZNJ7pvkQJIPZD04qCQPTPLSJFdX1Zur6qlVNes0FQAAAJirql66B4yVDAkAAIBVtei8aJUypJl/me/ur3X3K7v70UkenuTXknw+68HBviRPTfLmJH9dVedV1YPmUTAAAAAAq0OGBAAAAOM1l0+QdPdHuvtnkpyS5Owkl05OVZL7Jfk3ST5RVZdU1ZlVtX8e6wIAAACwOmRIAAAAMC5zHVva3bd094Xd/fgkD03ysiR/k/XgYC3JE5L8tyTXVtW/r6oHznN9AAAAOJa1Wr4H7EUyJAAAAJbZovOiVcqQjtteud39V0neneRPj7yUb+zbe58k/zrJx6vqt6rqbserDgAAAACWlwwJAAAAVtfcm06q6r5V9fNVdVWSdyT5B0dOJflIkt9Ics3k+QlJnpvkUFXde961AAAAALCcZEgAAACw+ubSdFLrnlpVb0ryqSS/kOTbsh4K3JLktUl+uLsf3t0vSPLgJE9PcmhyzUOSvGQetQAAAMDRrC3hA/YSGRIAAACrYNF50SplSPt3cnNVPSjJgSTnJLnfkZcnx6uSHEzyyu7+/Mb7uruTvKWq3pbk7Vnfp/dJO6kFAAAAgOUkQwIAAIBxGtx0UlX7sz7u9LlJTs839thNkluTXJTkt7r7Xdu9V3ffXlWvynpg8MChtQAAAACwnGRIAAAAMH6zTDq5Lsm9Jl8fCQo+leS3k1zQ3Z8Z+H5fmBz3zVALAAAATG2tetElwF4iQwIAAGAlyZCmN0vTyb0nx9uSXJzkt5JcMhl3Oovrkrx6yA1Vdc/N41YBAAAAWCoyJAAAABi5tRnuuS7JeUke3N1P7+637yAsSHd/qLvP6e5ztjpfVb9YVfeafP3Iqvpkkg9W1aeq6oeP9r5VdW5VHaqqQ2/83UtmLQ8AAACA2axchvTK33nrrOUBAADAnjTLpJMHdfftc6/k6J7S3S+afP0fkjyzuy+rqocleW2SR251U3cfTHIwSS777NvMvgEAACBrtf01wNysXIb05VvfJUMCAABAhjTA4EknuxwWJMkJVXWkOeZO3X3ZpI6PJTlxl2sBAAAAYAoyJAAAABi/WbbX2W3nJ7m4qh6X5JKq+s9V9UNV9dIkly+4NgAAAACWgwwJAAAAdtks2+t8k6q6R5JTknxrkn3bXd/dfzzte3f3b1TVXyT5ySQPy3rND0vypiS/MFPBAAAA7Emr8MkLGDMZEgAAAKtAhjS9mZtOqupbk7wgyT9O8u0Dbu2h63b3e5K8Z4sazknyyiHvBQAAAMDukSEBAADAeM3UdFJV35nk4iQPSlJzrWiYl0ZgAAAAALCUZEgAAAAwboObTqrqxCRvSfLgyUt/nOQDSV6U9U+gvD7JNVkPEx6b5N6T19+Q5EMzrHfF0U4lOXno+wEAALB3rS3yn7xhj5EhAQAAsKpkSNObZdLJP8n6KNRO8q+6+1eSpKpeNDn/B9190eS1E5L8VJKXJTkjyQXdfcnA9U5O8sQkN2x6vbIeVAAAAACwfGRIAAAAMHKzNJ08bXL82JGw4Gi6+9Ykv1ZVn0zy5iS/V1WP6O5rB6z31iR37e7LN5+oqvcMeB8AAAD2uLXqRZcAe4kMCQAAgJUkQ5re2gz3fE/WP6Hyumnfs7vfkvVf/O+e5CeHLNbdB7r7/Uc5d/aQ9wIAAABg18iQAAAAYORmaTq5x+T4qU2v3zY53vko970t6+NMnzrDmgAAAACsFhkSAAAAjNws2+vcluSEJDduev3LSU5Kct+j3PfFyfEBM6wJAAAAO7ZWi64A9hQZEgAAACtJhjS9WSadfHpyvPum1/96cnzEUe77tsnxTjOsCQAAAMBqkSEBAADAyM3SdPKhyfE7Nr1+WdZHn/79qrrHxhNVdYckByZPr5lhTQAAAABWiwwJAAAARm6WppP3ZT0YeMym1y+cHL8lyf+oqjOq6mFV9aQk7836p1Q6ydtnLRYAAAB2Ym0JHzBiMiQAAABW0qLzolXKkGap7S2T4yOr6kFHXuzudyV5Z9bDhO9J8rYkH0ny1iSPmlx2Q5JfnrlaAAAAAFaFDAkAAABGbv/QG7r7o1X1nCR3njw2+rEkf5Tk9C1uvS7JM7r7usFVAgAAALBSZEgAAAAwfoObTpKku19zlNdvTPKEqnpMkscnOTnJV7O+V+8bu/vrsxYKAAAAO7VWvegSYE+RIQEAALCKZEjTm6npZDvd/b6s79sLAAAAAFuSIQEAAMBqW1t0AQAAAAAAAAAArJ7jMukEAAAAltFaLboCAAAAAJadDGl6Jp0AAAAAAAAAADDYUSedVNWlx2nN7u7Tj9N7AwAAALCLZEgAAACwdx1re53HJuk5r1fH4T0BAABgKkajwnHx2MiQAAAAGBEZ0vSO1XSSrP+CDwAAAADHIkMCAACAPeioTSfdvbabhQAAAACwemRIAAAAsHdtN+kEAAAARsO/jAMAAACwHRnS9HyvAAAAAAAAAAAYTNMJAAAAAAAAAACDzWV7naq6T5LvTXK/JHdNclOS65Nc1t1/O481AAAAYKfWqhddAuxpMiQAAABWgQxpejtqOqmqf5jkZ5N8/zGu+ZMk/7G737STtQAAAABYTTIkAAAAGKeZttepqjtU1euT/GHWw4I6xuMHkvxRVb2+qu4wl6oBAAAAWHoyJAAAABi3WSed/FGSJ2c9EEiSDye5NMlVSb6S5C5JHprk7yV5+OSaH01yxyRPm7VYAAAA2Im12v4aYK5kSAAAAKwcGdL0BjedVNVZSZ6SpLO+5+6B7n7HMa7/kSQXJDklyVOq6pnd/boZ6wUAAABgBciQAAAAYPxm2V7nwOT4lSQ/fKywIEm6+78neWySmyYv/cQMawIAAACwWmRIAAAAMHKzbK/zPVn/hMoF3f2JaW7o7k9U1QVJXpDkETOsuSNXfGHWXYQ4mouv/dKiSxidX3nxXRddwuhcecMsfXUcy5s/fsdFlzA6z/r2WxZdwuh87bCZd/N28p1uX3QJo/PP/vRuiy5hdF72SD+fMh0/IcKuWrkMaV/5nWfebrn9q4suYXS+dIvfeebtjvt60SWMzq23+3M6b/v9IDt313/18KJLGB3/7c/fjbf6czpv97qjv/eZjr96pzfL9+rIv4xfNvC+I9ffeYY1AQAAAFgtMiQAAAAYuVlGgFyf5CFJ9g2878j118+wJgAAAOzYmg/ewW6SIQEAALCSZEjTm2XSyaWT42MG3veYrI9UvXS7CwEAAABYeTIkAAAAGLlZmk5+PcktSZ5dVd87zQ1V9cgkz0ly8+R+AAAAAMZNhgQAAAAjN7jppLs/lOS5SSrJO6vqJ6pqy216qmp/VR1I8s6sf0LlJ7r7yp0UDAAAALOq6qV7wFjJkAAAAFhVi86LVilD2vIX/WOpqpdMvnxnkicneXmSX6yq9yW5KslXk9w5yUOTPDrJPSbXX5zkoRvu/ybdfd7QegAAAABYPjIkAAAAGL/BTSdJ/m3WP3GSDcd7JHnaFtfWhmuePHkci8AAAAAAYBz+bWRIAAAAMGqzNJ0k60HANK8d6/XNlnceDAAAAKOwNu1vqMC8yJAAAABYOTKk6c3SdPL35l4FAAAAAGMjQwIAAICRG9x00t3vPR6FAAAAADAeMiQAAAAYv7VFFwAAAAC7ZW0JHwAAAAAsl0XnRbNkSFV1RlV9tKquqqoXbXH+xKp63eT8B6vqwYO+KUch3wIAAAAAAAAAWFFVtS/J+UmelOS0JM+qqtM2XXYgyQ3d/dAk/ynJL81jbU0nAAAAAAAAAACr61FJruruT3b3LUkuTPL0Tdc8PcmrJ1//YZLTq6p2uvD+nb4BAAAArIq16kWXAAAAAMCSW8EM6ZQk12x4fm2S7zvaNd19uKq+lOSeST63k4VNOgEAAAAAAAAAWGJVdW5VHdrwOHfj6S1u2dw5M801g5l0AgAAAAAAAACwxLr7YJKDRzl9bZIHbHh+/yTXH+Waa6tqf5KTknxhp3VpOgEAAGDPWNvxLrUAAAAAjN0KIHwrTwAAIABJREFUZkiXJTm1qh6S5LokZyU5e9M1FyV5TpI/SfKMJJd2t0knAAAAAAAAAAB7VXcfrqrnJ3lHkn1JXtHdV1bVeUkOdfdFSS5I8pqquirrE07Omsfamk4AAAAAAAAAAFZYd1+c5OJNr71kw9dfT/Jj815X0wkAAAB7xgqORgUAAABgl8mQpre26AIAAAAAAAAAAFg9mk4AAAAAAAAAABjM9joAAADsGfsWXQAAAAAAS0+GND2TTgAAAAAAAAAAGEzTCQAAAAAAAAAAg9leBwAAgD1jrXrRJQAAAACw5GRI0zPpBAAAAAAAAACAwUw6AQAAYM9Yq0VXAAAAAMCykyFNz6QTAAAAAAAAAAAG03QCAAAAAAAAAMBgttcBAABgzzAaFQAAAIDtyJCmZ9IJAAAAAAAAAACDaToBAAAAAAAAAGAw2+sAAACwZ+wzGhUAAACAbciQpmfSCQAAAAAAAAAAg2k6AQAAAAAAAABgMNvrAAAAsGesGY0KAAAAwDZkSNNb+kknVXXGhq9PqqoLquqKqnptVZ18jPvOrf+fvTuPlu6s60T//b2ZIAlDQBPCYMIQEaQRJY0gF0wYRBplsBsaUQwaCGD3VdFupC99sVmrW8NqEL3eBg2DCVdEYpAwCsSQoDQqhHkIEAVCYl4IIvOQQPLcP2q/pjzUOaf2e/Y5u4bPZ629alftp3b9zj7n5Lz1zVO/p+qSqrrkba98494UCwAAAMAohsiQXvqi1+xNsQAAALAiFn7SSZLfnNp/XpL9SX4yybuS/MFmT2qtndVaO7m1dvKP/vt/s8slAgAAADCyHWdIv/CkR+xyiQAAALBalm15nZNba/fo9p9fVaeNWg0AAABLZV+1sUsA9oYMCQAAgIMmQ5rfMkw6ObaqfjVJJblpVVVr7cB3eBk6tQAAAACw+2RIAAAAsMeW4Q33i5LcJMnRSc5J8l1JUlW3SvK+EesCAAAAYHHIkAAAAGCPLXynk9baszd5/DNVddFe1wMAAMDy2ldjVwDsFhkSAAAAQ5EhzW8ZOp1sZWaYAAAAAABTZEgAAACwCxa+00lVfWCzQ0mO28taAAAAAFhMMiQAAADYews/6SSTUOAhSb6w4fFK8o69LwcAAIBldcjYBQC7SYYEAADAIGRI81uGSSevT3J0a+19Gw9U1cV7Xw4AAAAAC0iGBAAAAHts4SedtNZO3+LY4/ayFgAAAAAWkwwJAAAA9t7CTzoBAACAoeyrsSsAAAAAYNHJkOa3b+wCAAAAAAAAAABYPiadAAAAAAAAAADQm+V1AAAAWBv7qo1dAgAAAAALToY0P51OAAAAAAAAAADozaQTAAAAAAAAAAB6s7wOAAAAa+OQGrsCAAAAABadDGl+Op0AAAAAAAAAANCbTicAAACsjX0+pQIAAADANmRI89PpBAAAAAAAAACA3kw6AQAAAAAAAACgN8vrAAAAsDa0RgUAAABgOzKk+el0AgAAAAAAAABAbyadAAAAwJKqqltU1QVVdVl3e8yMMSdU1bur6n1V9eGqesoYtQIAAACweiyvAwAAwNpYwdaoz0hyYWvtzKp6Rnf/1zeM2Z/kR1pr11TV0Uk+VFWvba1dtdfFAgAAACyDFcyQdo1OJwAAALC8HpHknG7/nCSP3DigtXZta+2a7u4RkQUAAAAAMBBBEwAAACyv41pr+5Okuz121qCqul1VfSDJFUmeo8sJAAAAAEOwvA4AAABr45BqY5fwHarqjCRnTD10VmvtrKnjf5HkVjOe+sx5X6O1dkWSu1fVrZOcX1XntdY+e7A1AwAAAKyyRcyQFpVJJwAAADCiboLJWVscf9Bmx6rqs1V1fGttf1Udn+TqbV7rqqr6cJL7JTnvYGsGAAAAgMTyOgAAALDMXpvktG7/tCSv2Tigqm5bVTfu9o9Jct8kH9uzCgEAAABYWTqdAAAAsDZW8JMXZyY5t6pOT/LpJI9Okqo6OclTWmtPTHKXJM+rqpakkjy3tfbBsQoGAAAAWHQrmCHtGpNOAAAAYEm11j6f5IEzHr8kyRO7/QuS3H2PSwMAAABgDZigAwAAAAAAAABAbzqdAAAAsDb21dgVAAAAALDoZEjz0+kEAAAAAAAAAIDe1qLTySNPuGbsElbOJ796yNglrJzHnHv02CWsnN98yDfGLmHl3Pm468YuYeW89ONHjF3Cyrn4Mzcau4SV87L7f2nsElbOz9zha2OXsHIu+5J/nw7tbseMXQHA3vvW9V8du4SV86VrfTxwaIf7GOHgyo/p4K5vLurQKm3sElaOKzq8w/yNYglce52/UTC0tZh0AgAAAInWqAAAAABsT4Y0P3MOAQAAAAAAAADozaQTAAAAAAAAAAB6s7wOAAAAa+OQsnI7AAAAAFuTIc1PpxMAAAAAAAAAAHoz6QQAAAAAAAAAgN4srwMAAMDa2FdjVwAAAADAopMhzU+nEwAAAAAAAAAAetPpBAAAgLXhUyoAAAAAbEeGND+dTgAAAAAAAAAA6M2kEwAAAAAAAAAAerO8DgAAAGtDa1QAAAAAtiNDmp9OJwAAAAAAAAAA9GbSCQAAAAAAAAAAvVleBwAAgLVxiNaoAAAAAGxDhjQ/nU4AAAAAAAAAAOjNpBMAAAAAAAAAAHqzvA4AAABrY1+1sUsAAAAAYMHJkOan0wkAAAAAAAAAAL2ZdAIAAAAAAAAAQG+W1wEAAGBt+OQFAAAAANuRIc3PtQIAAAAAAAAAoDeTTgAAAAAAAAAA6M3yOgAAAKyNfTV2BQAAAAAsOhnS/HQ6AQAAAAAAAACgN5NOAAAAAAAAAADozfI6AAAArI1DtEYFAAAAYBsypPnpdAIAAAAAAAAAQG8mnQAAAAAAAAAA0JvldQAAAFgb+6qNXQIAAAAAC06GND+dTgAAAAAAAAAA6M2kEwAAAAAAAAAAerO8DgAAAGtjX41dAQAAAACLToY0P51OAAAAAAAAAADozaQTAAAAAAAAAAB6s7wOAAAAa0NrVAAAAAC2I0Oa31J2OqmqY8euAQAAAIDFJkMCAACA3bXwk06q6hYbtlsmeWdVHVNVt9jieWdU1SVVdck5L3nzHlYMAADAotq3gBswjCEypLNf/MY9rBgAAIBFNXZetEwZ0jIsr/OPSS7f8NhtkrwnSUtyh1lPaq2dleSsJPn8N1/bdrNAAAAAAEa34wzpS9e+WYYEAAAAPSzyhJgDnp7kY0ke3lq7fWvt9kmu7PZnhgUAAAAArB0ZEgAAAOyxhe900lp7blX9SZLnV9UVSX4jk0+nAAAAQC9VY1cA7BYZEgAAAEORIc1vGTqdpLV2ZWvt0UkuSnJBkiNHLgkAAACABSNDAgAAgL21FJNODmitvS7JqUkelCRV9fPjVgQAAADAopEhAQAAwN5YqkknSdJa+0Zr7UPd3WePWgwAAABLpRZwA3aHDAkAAICDNXZetEwZ0qFjF7CdqvrAZoeSHLeXtQAAAACwmGRIAAAAsPcWftJJJqHAQ5J8YcPjleQde18OAAAAAAtIhgQAAAB7bBkmnbw+ydGttfdtPFBVF+99OQAAACyrWuRepMBOyZAAAAAYhAxpfgs/6aS1dvoWxx63l7UAAAAAsJhkSAAAALD39o1dAAAAAAAAAAAAy2fhO50AAADAUHzyAgAAAIDtyJDm51oBAAAAAAAAANCbSScAAAAAAAAAAPRmeR0AAADWRlUbuwQAAAAAFpwMaX46nQAAAAAAAAAA0JtJJwAAAAAAAAAA9GZ5HQAAANZGjV0AAAAAAAtPhjQ/nU4AAAAAAAAAAOjNpBMAAAAAAAAAAHqzvA4AAABro/RGBQAAAGAbMqT56XQCAAAAAAAAAEBvJp0AAAAAAAAAANCb5XUAAABYGzqjAgAAALAdGdL8dDoBAAAAAAAAAKA3k04AAAAAAAAAAOjN8joAAACsjX16owIAAACwDRnS/HQ6AQAAAAAAAACgN51OAAAAWBs+pAIAAADAdmRI89PpBAAAAAAAAACA3kw6AQAAAAAAAACgN8vrAAAAsDZKb1QAAAAAtiFDmp9OJwAAAAAAAAAA9GbSCQAAAAAAAAAAvVleBwAAgLWhMyoAAAAA25EhzU+nEwAAAAAAAAAAeluLTidnX3bjsUtYOY8/6Rtjl7ByXvDwr49dwsr566sPG7uElfP2D45dwer5tz/x7bFLWDl/9nfmHw/tFX9/+NglrJznvO6QsUtYOW96sn+fArBzh+670dglrJwbHXLt2CWsnG9d7z3P0L58rWs6tGuvH7uC1fOFa32GeGhHHtrGLmHlfPM6/z0d2jfEx4Pzuw/DW4tJJwAAAJBojQoAAADA9mRI8zM1FgAAAAAAAACA3kw6AQAAAAAAAACgN8vrAAAAsDb26Y0KAAAAwDZkSPPT6QQAAAAAAAAAgN5MOgEAAAAAAAAAoDfL6wAAALA2dEYFAAAAYDsypPnpdAIAAAAAAAAAsKKq6hZVdUFVXdbdHjNjzAlV9e6qel9VfbiqnjLPuU06AQAAAAAAAABYXc9IcmFr7aQkF3b3N9qf5Edaa/dI8sNJnlFVt97uxJbXAQAAYG1UtbFLAAAAAGDBrWCG9Igkp3T75yS5OMmvTw9orV07dfeIzNnERKcTAAAAAAAAAIDVdVxrbX+SdLfHzhpUVberqg8kuSLJc1prV213Yp1OAAAAAAAAAAAWWFWdkeSMqYfOaq2dNXX8L5LcasZTnznva7TWrkhy925ZnfOr6rzW2me3eo5JJwAAAKyNGrsAAAAAABbeImZI3QSTs7Y4/qDNjlXVZ6vq+Nba/qo6PsnV27zWVVX14ST3S3LeVmMtrwMAAAAAAAAAsLpem+S0bv+0JK/ZOKCqbltVN+72j0ly3yQf2+7EJp0AAAAAAAAAAKyuM5M8uKouS/Lg7n6q6uSqenE35i5J/raq3p/kbUme21r74HYntrwOAAAAa6MWsTcqAAAAAAtl1TKk1trnkzxwxuOXJHlit39Bkrv3PbdOJwAAAAAAAAAA9KbTCQAAAGvDJy8AAAAA2I4MaX6uFQAAAAAAAAAAvZl0AgAAAAAAAABAb5bXAQAAYG1UjV0BAAAAAItOhjQ/nU4AAAAAAAAAAOjNpBMAAAAAAAAAAHqzvA4AAABrQ2dUAAAAALYjQ5qfTicAAAAAAAAAAPRm0gkAAAAAAAAAAL1ZXgcAAIC1UXqjAgAAALANGdL8dDoBAAAAAAAAAKA3k04AAAAAAAAAAOjN8joAAACsDZ1RAQAAANiODGl+Op0AAAAAAAAAANCbSScAAAAAAAAAAPRmeR0AAADWxj69UQEAAADYhgxpfjqdAAAAAAAAAADQm0knAAAAAAAAAAD0ZnkdAAAA1obOqAAAAABsR4Y0v4XvdFJVt6qqF1bV/6qqW1bVf6uqD1bVuVV1/BbPO6OqLqmqS/7mvDfsZckAAAAA7LEhMqSXvuh1e1kyAAAALL2Fn3SS5OwkH0lyRZKLknwjycOS/FWS39/sSa21s1prJ7fWTr73v3vYXtQJAAAAe6qqblFVF1TVZd3tMZuM+56qektVXVpVH6mqE/e2UtgTZ2eHGdIvPOkn96JOAAAAWBnLMOnkuNba77XWzkxy89bac1prn26t/V6SE8YuDgAAgOVR1RZu26FnJLmwtXZSkgu7+7O8LMn/bK3dJcm9kly90xeGBSRDAgAAYBBj50W7kCHtmmWYdDJd48s2HDtkLwsBAACABfOIJOd0++ckeeTGAVV11ySHttYuSJLW2ldba1/fuxJhz8iQAAAAYI8tw6ST11TV0UnSWvuvBx6sqjsl+dhoVQEAAMD4jmut7U+S7vbYGWO+N8kXq+rPquq9VfU/q8r/gGcVyZAAAABgjx06dgHbaa09a5PH/66q3rDX9QAAALC8auwCZqiqM5KcMfXQWa21s6aO/0WSW8146jPnfIlDk9wvyQ8m+XSSVyZ5QpKXHEy9sKhkSAAAAAxlETOkRbXwk0628ewkfzh2EQAAAHCwugkmZ21x/EGbHauqz1bV8a21/VV1fJKrZwy7Msl7W2uf6J5zfpJ7x6QT1osMCQAAAHbBwk86qaoPbHYoyXF7WQsAAAAsmNcmOS3Jmd3ta2aMeVeSY6rqu1trn0vygCSX7F2JsDdkSAAAALD3Fn7SSSahwEOSfGHD45XkHXtfDgAAAMuqVq836plJzq2q0zNZOufRSVJVJyd5Smvtia2166rqPyW5sKoqybuTvGi0imH3yJAAAAAYxApmSLtmGSadvD7J0a219208UFUX7305AAAAsBhaa59P8sAZj1+S5IlT9y9Icvc9LA3GIEMCAACAPbbwk05aa6dvcexxe1kLAAAAy82HVGB1yZAAAAAYigxpfvvGLgAAAAAAAAAAgOVj0gkAAAAAAAAAAL0t/PI6AAAAMBSfvAAAAABgOzKk+blWAAAAAAAAAAD0ZtIJAAAAAAAAAAC9WV4HAACAtVE1dgUAAAAALDoZ0vx0OgEAAAAAAAAAoDeTTgAAAAAAAAAA6M3yOgAAAKwRvVEBAAAA2I4MaV46nQAAAAAAAAAA0JtJJwAAAAAAAAAA9GZ5HQAAANZGaY0KAAAAwDZkSPPT6QQAAAAAAAAAgN5MOgEAAAAAAAAAoDfL6wAAALA2qnz2AgAAAICtyZDm50oBAAAAAAAAANCbSScAAAAAAAAAAPRmeR0AAADWSI1dAAAAAAALT4Y0L51OAAAAAAAAAADozaQTAAAAAAAAAAB6s7wOAAAAa6O0RgUAAABgGzKk+el0AgAAAAAAAABAbyadAAAAAAAAAADQm+V1AAAAWCNaowIAAACwHRnSvHQ6AQAAAAAAAACgN51OAAAAWBtVPnsBAAAAwNZkSPNbi0knF3/mRmOXsHJc0+F95Owrxy5h5fz9y+85dgkr52vf8nM6tKe9/sixS1g5f/6zXxy7hJXz9HfdbOwSVs6bnvylsUtYOd/4tnaXAOzcNdf5Gz20w/f5Gz20L17rmg7N/04Y3tGHtbFLWDk3OuT6sUtYOf/4Tb/9Q/una/yNGtqtbux3f2jXXOfnFIbmLyoAAAAAAAAAAL2tRacTAAAAmPCJJgAAAAC2I0Oal04nAAAAAAAAAAD0ZtIJAAAAAAAAAAC9WV4HAACAtVFaowIAAACwDRnS/HQ6AQAAAAAAAACgN5NOAAAAAAAAAADozfI6AAAArA2tUQEAAADYjgxpfjqdAAAAAAAAAADQm0knAAAAAAAAAAD0ZnkdAAAA1ojPXgAAAACwHRnSvFwpAAAAAAAAAAB6M+kEAAAAAAAAAIDeLK8DAADA2qiqsUsAAAAAYMHJkOan0wkAAAAAAAAAAL2ZdAIAAAAAAAAAQG+W1wEAAGCNaI0KAAAAwHZkSPPS6QQAAAAAAAAAgN5MOgEAAAAAAAAAoDfL6wAAALA2SmtUAAAAALYhQ5qfTicAAAAAAAAAAPRm0gkAAAAAAAAAAL1ZXgcAAIA14rMXAAAAAGxHhjQvVwoAAAAAAAAAgN5MOgEAAAAAAAAAoDfL6wAAALA2KjV2CQAAAAAsOBnS/HQ6AQAAAAAAAACgN51OAAAAWBtVPqUCAAAAwNZkSPPT6QQAAAAAAAAAgN5MOgEAAAAAAAAAoDfL6wAAALBGtEYFAAAAYDsypHnpdAIAAAAAAAAAQG8mnQAAAAAAAAAA0JvldQAAAFgb5bMXAAAAAGxDhjQ/VwoAAAAAAAAAgN5MOgEAAAAAAAAAoLeFn3RSVTetqt+qqv+vqh634dgLtnjeGVV1SVVdcvkbXrv7hQIAALAEagE3YAhDZEjnvPjNu18oAAAAS2DsvGh5MqSFn3SS5A8zuYKvSvLYqnpVVR3RHbv3Zk9qrZ3VWju5tXbyCQ97+F7UCQAAAMB4dpwhnfbEh+xFnQAAALAylmHSyR1ba89orZ3fWnt4kvckeWtV3XLswgAAAABYGDIkAAAA2GOHjl3AHI6oqn2tteuTpLX2P6rqyiR/meTocUsDAABgmVQtbitSYMdkSAAAAAxChjS/Zeh08rokD5h+oLV2TpJfS3LtKBUBAAAAsGhkSAAAALDHFr7TSWvt6Zs8/qaq+s29rgcAAACAxSNDAgAAgL23DJ1OtvLssQsAAABgmdQCbsAekCEBAADQw9h50fJkSAvf6aSqPrDZoSTH7WUtAAAAACwmGRIAAADsvYWfdJJJKPCQJF/Y8HglecfelwMAAADAApIhAQAAwB5bhkknr09ydGvtfRsPVNXFe18OAAAAy6qWfpVZYAsyJAAAAAYhQ5rfwk86aa2dvsWxx+1lLQAAAAAsJhkSAAAA7D3TcwAAAAAAAAAA6G3hO50AAADAcGrsAgAAAABYeDKkeel0AgAAAAAAAABAbyadAAAAAAAAAADQm+V1AAAAWBulNSoAAAAA25AhzU+nEwAAAAAAAAAAejPpBAAAAAAAAACA3iyvAwAAwNqo0hoVAAAAgK3JkOan0wkAAAAAAAAAAL3pdAIAAMAa8dkLAAAAALYjQ5qXKwUAAAAAAAAAQG8mnQAAAAAAAAAA0JvldQAAAFgblRq7BAAAAAAWnAxpfjqdAAAAAAAAAADQm0knAAAAAAAAAAD0ZnkdAAAA1ojWqAAAAABsR4Y0L51OAAAAAAAAAADozaQTAAAAAAAAAAB6s7wOAAAAa6NKa1QAAAAAtiZDmp9OJwAAAAAAAAAA9GbSCQAAAAAAAAAAvVleBwAAgDXisxcAAAAAbEeGNC9XCgAAAAAAAACA3kw6AQAAAAAAAACgN8vrAAAAsDYqNXYJAAAAACw4GdL8dDoBAAAAAAAAAKC3aq2NXQNTquqM1tpZY9exSlzT4bmmw3NNh+eaDs81HZ5rOjzXdHiu6fBcUwCG4O/J8FzT4bmmw3NNh+eaDs81HZ5rOjzXdHiu6fBcU5aFTieL54yxC1hBrunwXNPhuabDc02H55oOzzUdnms6PNd0eK4pAEPw92R4runwXNPhuabDc02H55oOzzUdnms6PNd0eK4pS8GkEwAAAAAAAAAAejPpBAAAAAAAAACA3kw6WTzW5Rqeazo813R4runwXNPhuabDc02H55oOzzUdnmsKwBD8PRmeazo813R4runwXNPhuabDc02H55oOzzUdnmvKUqjW2tg1AAAAAAAAAACwZHQ6AQAAAAAAAACgN5NOFkRVvbSqrq6qD41dyyqoqttV1UVVdWlVfbiqfnnsmpZdVd2oqt5ZVe/vrumzx65pVVTVIVX13qp6/di1rIKq+lRVfbCq3ldVl4xdzyqoqptX1XlV9dHuv6v3GbumZVdVd+5+Rg9sX66qXxm7rmVWVU/r/j59qKpeUVU3GrumZVdVv9xdzw/7+Tx4s/6dX1W3qKoLquqy7vaYMWsEYLnIkIYlQ9odcqTdIUManhxpeHKkYcmQdoccaXhypJ2TIbHMTDpZHGcn+fGxi1gh307ya621uyS5d5L/UFV3HbmmZXdNkge01n4gyT2S/HhV3XvkmlbFLye5dOwiVsyprbV7tNZOHruQFfG7Sd7UWvu+JD8QP6871lr7WPczeo8k90zy9SSvHrmspVVVt0nyS0lObq3dLckhSR47blXLraruluRJSe6Vye/9T1TVSeNWtbTOznf+O/8ZSS5srZ2U5MLuPgDM6+zIkIYkQ9odcqTdIUPaHXKkYcmRBiRDGp4caXhypMGcHRkSS8qkkwXRWvvLJP80dh2rorW2v7X2nm7/K5n8w/Y241a13NrEV7u7h3VbG7GklVBVt03ysCQvHrsWmKWqbprk/klekiSttWtba18ct6qV88Akf99au3zsQpbcoUluXFWHJjkyyVUj17Ps7pLkb1prX2+tfTvJ25I8auSaltIm/85/RJJzuv1zkjxyT4sCYKnJkIYlQ9odcqThyZBYBnKkXSdDGo4caVhypAHIkFhmJp2w8qrqxCQ/mORvx61k+XUtPN+X5OokF7TWXNOd+50kT09y/diFrJCW5C1V9e6qOmPsYlbAHZJ8Lskfdi18X1xVR41d1Ip5bJJXjF3EMmut/UOS5yb5dJL9Sb7UWnvLuFUtvQ8luX9V3bKqjkzyb5LcbuSaVslxrbX9yeR/dCU5duR6AIDIkIYmRxqcDGl3yJGGJUfaXTKkAciRdoUcaffIkFgKJp2w0qrq6CSvSvIrrbUvj13PsmutXde18bttknt1LdM4SFX1E0mubq29e+xaVsx9W2s/lOShmbRFvv/YBS25Q5P8UJIXttZ+MMnXooXfYKrq8CQPT/KnY9eyzLq1TB+R5PZJbp3kqKr62XGrWm6ttUuTPCfJBUnelOT9mbSeBwBYSTKk4cmRhiND2lVypGHJkXaJDGk4cqThyZEAk05YWVV1WCZhwctba382dj2rpGuJeHGsIb1T903y8Kr6VJI/SfKAqvqjcUtafq21q7rbqzNZ3/Re41a09K5McuXUJ9LOyyQ8YBgPTfKe1tpnxy5kyT0oySdba59rrX0ryZ8l+ZGRa1p6rbWXtNZ+qLV2/0xae142dk0r5LNVdXySdLdXj1wPAKw1GdLukiMNQoa0S+RIg5Mj7R4Z0nDkSLtAjrRrZEgsBZNOWElVVZmsG3lpa+23x65nFVTVd1fVzbv9G2fyD7OPjlvVcmut/ZfW2m1baydm0hrxra01M6p3oKqOqqqbHNhP8mOZtPbjILXWPpPkiqq6c/fQA5N8ZMSSVs1PR1vUIXw6yb2r6sju3wAPTHLpyDUtvao6trv9niQ/FT+rQ3ptktO6/dOSvGbEWgBgrcmQdoccaVgypN0hRxqeHGlXyZCGI0faBXKkXSNDYikcOnYBTFTVK5KckuS7qurKJL/RWnvJuFUttfsmeXySD3ZrxybJ/9Vae+OINS2745OcU1WHZDJh7dzW2utHrgk2Oi7JqyfvFXJokj9urb1p3JJWwv+Z5OVdG89PJPn5ketZCd36pg9O8uSxa1l2rbW22eLpAAAgAElEQVS/rarzkrwnk9ad701y1rhVrYRXVdUtk3wryX9orX1h7IKW0ax/5yc5M8m5VXV6JmHXo8erEIBlI0ManAxpd8iRWAZypN0hRxqYDGlYcqRdI0faIRkSy6xaa2PXAAAAAAAAAADAkrG8DgAAAAAAAAAAvZl0AgAAAAAAAABAbyadAAAAAAAAAADQm0knAAAAAAAAAAD0ZtIJAAAAAAAAAAC9mXQCsEaq6glV1brtCWPXM4+qOnGq5rPHrmcMVXX21DU4cex69sq6ft0AAAAwNhnSclrXLGVdv24AWBQmnQAAAAAAAAAA0JtJJwAAAAAAAAAA9GbSCQCwkFprT2itVbd9aux6AAAAAFg8MiQAGJdJJwAAAAAAAAAA9GbSCQAAAAAAAAAAvZl0ArBCquonqup1VfWZqvpmVX2qql5eVfc5iHMdXlWnV9Vrq+qK7nxfrKoPVNXzqurEOc7xfVX1n7tzfKKqvl5V11TV/qp6U1X9YlXd6GC+1i1e8z5V9cKq+khX7zer6tNV9cqqetg2zz2lqlq3/bfusTtX1e9U1aVV9eXu2BMOoq5Dqurx3ffnwPX8Rrf/nqo6q6p+qqqOnPN8D6mq86vqyu6aXlVVf1pVPzzn86uqHlNV53XXZ/r7+9tVddIWz31xdx2ur6rv3mTM06au5deq6vBNxj1vatydNxw7e+rYiTOeO+v79T3dOT/ave4Xq+od3c/aoXNem0dV1Ruq6rNTv0d/dODaVtUTpl73CfOcEwAAABaJDEmGJEOSIQHAUOb6wwnAYquqQ5K8JMlpGw6d0G2Prar/kuTqOc93cpJzk9x+w6EjkvyrbvuPVfVLrbU/2OQcP5fknE1e4lbd9pAkv1pVP9lau3Se2rao+agkL07y2BmHb9dtj6mqNyT56dbaV+Y4588l+f0kN95hbd+V5I1J/vWMw7ftth9M8qQkj0py/han21dVL0jy1A2PH5/k3yX5qao6o7X2ki3qOS7Jq5NsDJI2fn+f1Vo7c8YpLk5yepJKckqSP50x5pSp/SOT/HCSv9pi3P7W2sc2q3keVfXjSV6R5OYbDt2n2x7Z/axds8nzD0vy8iSP3nBo+vfo15N8fid1AgAAwFhkSDKkyJBkSAAwMJNOAFbD/5MbwoJrM3mj/vYk1ye5VyZv7p6Trd+IJpl8yiPJX2TyJi9JLkzy50muSHKjTN54/Vx3/Per6prW2tkzTnVkkpbk3Un+MsnHknwhyU0zefP175N8b5I7JvnzqrpHa+2Lfb7oqZqP6Gq+d/fQpzN54/jhJNckuVNX852TPCzJ+VX14Nba9Vuc9r5JnpnkukzCmP+d5JvdOT7Ts8QX5Yaw4O+62j6e5BuZXI87J7l/Jm+qt/Pfk/x09/yXdee7SZKfSvLQTLqYvaCq/ndr7aMbn1xVN8nk+/G93UP7k7w0k2t1ZJIHZ/KG+bAkv1VV+1prv7nhNBdN7Z+aDYFBVe3rvp5sGPdXG8bdPMk9ZpzzYNwjyX/OJMT4gyR/ncn3/uQkT0lyVCZf2zOTPGuTc5yVG8KCbyY5uzvPdd15Tk/y3CTn7bBWAAAAGIsMSYYkQ5IhAcCwWms2m81mW+Ityf0yCQZaJm/I7zljzJ0zeWPYprYnzBh3k0zebLckX03y0E1e805JLp8a910zxnx/kttvUfe+JP9pqp7f2GTciVNjzt5kzPOnxrwwyeEzxhyWSZByYNxTZow5ZcM12p/krjv8/hybyRvOluRdSY7aYuwJSU6Y8fjZG+o6J8mhM8b97tSYF2zyGi+cGvNXSW42Y8yPZRJmtCTfSvIDM8Zc1h2/dMaxe069xju624tmjHv41LgnbfN1nzjH9+vyJCfNGHev7utoSf4pyREzxjxw6jyfS3K3TX4WP7XhNb/j98hms9lsNpvNZrPZbLZF3CJDSmRIB8bJkGRINpvNZrMNtu0LAMvu1zKZmZ8kv9Jae/fGAW3ScvKJc5zrSZm0EE2Sp7bW/nzWoNba3yX5+e7uUUnOmDHmw621T272Qq2161trz83kExNJ8vg56vsOVXV8kl/s7l7YWntqa+3aGa/3rUyuwSe6h351jtM/ubX2kYOpa8odkn/+e/vHrbWvbTawtXZ5a+3ybc730UzeXH97xrH/mskb/WTSdvZf6NbOPfB9+3KSR7fWvjSjjrck+b+7u4dm8umPjS7qbr+v+x5MO7W7vTrJC7r9+9R3rr186tT+Rdm5n22tXbbxwdbaO5O8srt7TCYBwkZPm9r/j621D804z6eSPGHnZQIAAMAoZEgypANkSDIkABiMSScAS6xrCfrQ7u7VSf5os7GttTck2W7N2wNv2vdnsi7pplprb01yVXf3x7YtdnPv6G7v2K1b29djkhze7T9vq4FdaHDgjeNJVXXiFsMvT/K6g6hno69P7X//AOd74axAJEnaZI3hS7q7t5/xBv1hmay5myTntNa2avH6giQH1ix+RLfm87SLp/ZP2XDsQBBwUZK3dvtH5DvX/z3wvCu7EGon3ttam7Xe7wFvndq/6/SB7jod+Bnen9nrCydJWmsXJ/nAQdYIAAAAo5AhJZEh/TMZkgwJAIZ06NgFALAjP5Ab3ixf3Fq7bpvxFya5y6wDVXWzJHfv7u5P8vCqmjV02le725nn7M77oCSPzWQ92u/JpP3qxjefB9wmyT9u96Ib3G9q/9iqeuQ244+Z2r9LJq0uZ3l7a631rGWWD2cSrNw6yek1uagvSvLOtvV6wJv5m22O/0N3W0lunn+5dvD0pzPestVJWmtfr6q3ZxJIHZ3Jm+wPTg2Z/lTJqZmsMZwuWPg/DoxprV1VVR/PZP3fUw88r6qOyQ0/bxdv8zXNY97rkvzLn4Fk8nt0WLf/tjm+LxfnhtoBAABgGciQZEgbyZBmkyEBQE8mnQAst1tP7c8zy3+rMbfLDR2wfijJq3vUsfEN2IEA4tz0+wTLTXuMPeDEqf2zez73O+qe8g9bHJtba+26qnpykldlEu78Qrd9sar+Osnbk7x5VkvbTWwXqFwztb/xUyrTLUw/PsdrfTw3fArq+EwFBq21/VNBwAOmnnPP3PB9vGjq9sC4Z3WP/Whu+Hkboi3qTq7L9O/RJ7K9ecYAAADAIpEhyZA2kiHNJkMCgJ4srwOw3I6e2v/6pqNusOlasElutoM6Dpvx2Hm5ISz4SpI/TvL0TNqv/tskj+q2V049Z7NPr2xlJ3UfvsWxb2xxrJfW2usz+YTI+Um+1T1880zejP+PJJdU1Qer6sfnON3BfLLlgJtM7W/1s3DAV6f2bzLj+IE3+nesqgPrOB9oi3pVa+3jG8bdq6qO2jBu+vhO7OS6HDW1v9PfIwAAAFhEMiQZUh8ypNlkSAAwg04nAMtt+g3dkXOMP2qLY9PnOru19vMHV1JSVfdP8qDu7vuTPLi19rlNxt73YF+nc6Dubye5cWvt2zs8365orb0/yaOq6iZJ7pvkR5Lcv7s9LMndkryxqh7fWttyLeQd+MrU/lY/CwdMB1JfmXH84iRP7vZPTfKy/Mu1eKfHJZOv876ZtGU9pXvs8tbaJ+eoZTdNBwA7/T0CAACARSRDkiH1IUOaTYYEADPodAKw3K6a2r/THOO3GjPdCvT7D66cf/agqf1nbhYWdE7Y4WsdqPvQTNpvLrTW2ldaa29qrT2rtXZKJi1Hn98driS/3a1puxv2T+2fNMf46TFXzTh+8dT+qVV1WKbW4j1woLX22SSXTo27ZZJ/NeMcY5n+2u4wx/h5xgAAAMAikSHJkPqQIc0mQwKAGUw6AVhu709ybbf/o3O80XzAZgdaa/+Y5CPd3XtOtbo8GMdN7f/9ZoOq6vDc8GmFg/W2qf1H7fBce6619vnW2q8muaR76NjM92b+YLxzav/BWw2sqhvnhjf/X80Nb/j/WWvtM0k+2t09Ncm/zg2f4HjrhuEXTY370UzCkenHx/T+3NCy9v5Vtd2/j07Z3XIAAABgcDIkGVIfMqTZZEgAMINJJwBLrLV2TZI3dnePS/K4zcZW1UOT3HWbU57T3e5L8ls7KG16TdM7bjHuqUm+ewevkyR/khtCk6dV1a12eL6xfGpqf7eWv3tDkmu6/dOq6tgtxj41yU27/fNba9dtMu7AG/4TkvxCtz+r3emBcScnefjU4xdvV/Rua619M5N2rUly6ySP3mxsVZ2S5O57UBYAAAAMRoaURIbUhwxpBhkSAMxm0gnA8nve1P7vVtU9Ng6oqpOSvGSOc/2vJJd3+z9TVc/vPkkyU1XdtKp+qaoetOHQu6b2n1VVR8x47k8mOXOOmrbUWrsiye91d2+Z5M1VtWkL2Jp4YFU9c6evPY+qekhV/XJV3WyLMXfKDZ8a+Wq2+GTPTnQtal/a3b15knOr6qYbx1XVA5P89+7ut5M8d4vTXjy1f1p3O+uTJxcnaUkOSfIz3WOfbK1dPmPsGH5nav//raq7bRxQVScmOXuP6gEAAIChyZBkSHORIW1JhgQAG+zWLFgA9khr7e1V9YIkv5jkmCR/U1XnJHl7kuuT3CvJ6Zm0rDw/ySO3ONfXquqRmbQbvWmSX0nymKo6N8kHknw5yU2S3L4776lJjkjy+A2nenUm6+Tephv3kap6Sf5/9u47XJKrvBP/91VCJCFEMiCQwGSDiSbaIIJJCyanJQmTDAYvZvE6g8wP2MUGL8ZgrwUIgU2WydkEmWBMMoggksACZIIAkYPi+f1xqnVLrb59u2fuTN+Z+/k8Tz1T3XXq9Onq6pqu977nnOQr6Teqd05y1/TeLK9Ncs+dOwr54yTXS3Lb9B4EJ1bVG5K8L8m3kuyf3ovnuuk35pdL8u4kT9/J113EZdNvRv+yqt6b5MPpx+FnSS6ZPpzofbM2pOhzWms/34Xt+cP043S19CFKT6yqY9KHxb1Q+lzK98taYupTWmsnzKnv+NH65HfF+QIGrbXvVtVn0ufhXbfcqrTW3lVVxyY5Mv1z+ejw+N/Sv0c3Su+Fc1CS45Lce9j1nN3dVgAAANgRYkhJxJCWIYY0gxgSAJyfpBOAvcPvJblIkoek38A/algmzknyv5J8J3MCBknSWvtkVd04ySuSXD/95voJc3Y5Pcl3p+r4eVXdO33Y1osnuXLOf3P+g/TeCjfOTgYMWmtnVtWd03vsPCY9QHDvrN3UzfJfO/OaS5jcUB6Q5A7DMktL8twkT9mVjWmt/biqbpkePLppelDnz2cUPSvJk1trc4fIba2dWlUn5rzD7q4XCHhvesBgo3Kr8qj079G9kxyY5HeGZeKcJE9K8sOsnVs/3p0NBAAAgJ0khiSGtBAxpLnEkABgxPQ6AHuB1trZrbWHpvf8eEt6YOD0JF9Lv/H/9dbaXy1R3xeS3DDJ3dLn6P1ieg+Vs9Nv9E9I8tL0jP7LttbePqOOf0/vFfK89KE+z0i/0fpMkmcmuW5r7a3T++2o1toZrbXHJ7lG+pCrH04/Dmel9wj5z/QAxp8k+dXheO0O/5h+HJ6Y5A1JTkry0/Rj+cMkn0w/RjdsrT2htbbLez201r6d5ObpvVFel+SU9PPlR0k+m96r5lobBQtGxjf+Xx6Gq92oXLIF5uIda62d2Vq7T5J7JXl7zvs9elmSW7TWnp0+BO/Eabu9oQAAALCDxJDEkJYhhjSbGBIAnFe11lbdBgCAPUZV/XPWelZdorUmaAAAAADAeYghAbBdGOkEAGBBVXV4krsMD08QLAAAAABgmhgSANuJpBMAgCRV9ctVdeic7ZdPH0r2gOGpf9gtDQMAAABgyxBDAoDz2m/VDQAA2CJuluTFVfW+JO9Pn0f65+nz7940yX2TXGgo++9Jjl5FIwEAAABYKTEkABiRdAIAsGa/JLcZlvUcn+RerbWzd0uLAAAAANhqxJAAYFCttVW3AQBg5arqoPS5du+Y5PpJLpnkkCRnJPl2kg8neWVr7U0rayQAAAAAKyWGBADnJekEAAAAAAAAAICl7bPqBgAAAAAAAAAAsOeRdAIAAAAAAAAAwNIknQAAAAAAAAAAsDRJJwAAAAAAAAAALE3SCQAAAAAAAAAAS5N0AgAAAAAAAADA0iSdAAAAAAAAAACwNEknAAAAAAAAAAAsTdIJAAAAAAAAAABLk3QCAAAAAAAAAMDSJJ0AAAAAAAAAALA0SScAAAAAAAAAACxN0gkAAAAAAAAAAEuTdAIAAAAAAAAAwNIknQAAAAAAAAAAsDRJJwAAAAAAAAAALE3SCQAAAAAAAAAAS5N0AgAAAAAAAADA0iSdAAAAAAAAAACwNEknAAAAAAAAAAAsTdIJAAAAAAAAAABLk3QCAAAAAAAAAMDSJJ0AAAAAAAAAALA0SScAAAAAAAAAACxN0gkAAAAAAAAAAEuTdAIAAAAAAAAAwNIknQAAAAAAAAAAsDRJJwAAAAAAAAAALE3SCQAAAAAAAAAAS5N0AgAAAAAAAADA0iSdAAAAAAAAAACwNEknAAAAAAAAAAAsTdIJAAAAAAAAAABLk3QCAAAAAAAAAMDSJJ0AAAAAAAAAALA0SScAAAAAAAAAACxN0gkAAAAAAAAAAEuTdAIAAAAAAAAAwNIknQAAAAAAAAAAsDRJJwAAAAAAAAAALE3SCQAAAAAAAAAAS5N0AgAAAAAAAADA0iSdAAAAAAAAAACwNEknAAAAAAAAAAAsTdIJAAAAAAAAAABLk3QCAAAAAAAAAMDSJJ0AAAAAAAAAALA0SScAAAAAAAAAACxN0gkAAAAAAAAAAEuTdAIAAAAAAAAAwNIknQAAAAAAAAAAsDRJJwAAAAAAAAAALE3SCQAAAAAAAAAAS5N0AgAAAAAAAADA0iSdAAAAAAAAAACwNEknAAAAAAAAAAAsTdIJAAAAAAAAAABLk3QCAAAAAAAAAMDSJJ0AAAAAAAAAALA0SScAAAAAAAAAACxN0gkAAAAAAAAAAEuTdAIAAAAAAAAAwNIknQAAAAAAAAAAsDRJJwAAAAAAAAAALE3SCQAAAAAAAAAAS5N0AgAAAAAAAADA0iSdAAAAAAAAAACwNEknAAAAAAAAAAAsTdIJAAAAAAAAAABLk3QCsGJVdXJVtao6eRPqOnaoq1XV4TvdOGDLq6ojR9/7I1fdns1QVYeP3tOxq24PAADAriQ2BGwVVXXE6Bpy1Krbs1lG7+n4VbcFYG8k6QT2YqMfUpPlJgvsc/+t9qNy/B6W2OcIPyS3rqp60ejzOaeqrrTqNm0FVXWJqrp9Vf1JVf1zVX11R87/qTovVVV/XlUfr6rTqupnVfXlqjqmqm66ZF0XrqonVtUHq+rUqvrF0MZXVdUdlqxr/6p6ZFW9u6q+WVWnV9UpVfWmqrpfVdUSddWwz5uHOk4f6nx3VT2iqvZbpm1zXmec3LHM8oTNeH0AAIBliQ2JDW1VYkPnN3XOLrIcuWC9YkNLxoaq6o7De/rq8B5PHd7z71fVhZepa85rLPt5T5bnbMbrA8Bm2pQ/wgB7jGckue2qG8H2NtyY3Wf8VJIjkzxlJQ3aIqrqOkk+tcl13i7Jy5JcemrTlYflyKr669bakxao6/pJjhv2G7visNy3ql6e5GGttTM2qOvwJK9Ncv2pTZcflrskeURV3ae19oMN6rr40K7bTG36pWG5TZLHVNU9Wmtfm1cXAADANiA2xMqJDe0+YkPLxYaq6gJJXpzkAVObLjUsN0/yu1V1z9bapsbxAGBPJukEtpfbVNXtWmvvWnVD2NbuneSiU889tKqOaq3t0Ggee4l9px6fneTz6TfyF1y2sqq6YZLXJ5n0vviXJP+c5CdJbpzk4cO2/1lVv2it/dmcug5L8rYklxme+kiSf0ry3STXSfKoJJdI8t+TnJPkwXPqOnio6xrDU59LckySU5JcZajrCklul+S1VXX71tpZ69R1QJI3JPmN4amvJzk6yUlJDk3y20mumeQGSd5WVTdrrf1ovbYt6b1Jnrtg2U9v0mvO1Fo7Nsmxu/I1AACAvYbYEFuB2NDGXpXklRuU+Y95G8WGdig29JIk9xvWvzfU9ekkl0zyoPTj9stJ3l5VN2mtfX1OXcv4bJJ1j/+UL2/Sa87UWjs+PREMABYm6QS2h58ludCw/r+TCCywSg8b/j0zyauTPDDJYem9Dt69qkZtAT9O8tIkHx+WT7TWflZ9PufDlqloGH706KwFFY5qrf3FqMjLquqYJO9LclCSP66qV7XW1kuOeE7WggrHJHlka+2c4fErqur/JXl/eq+WB1XVK1trb1mnrqdkLajw9iT3aK39YtT2v0u/Rl0/ya2TPDrJ89ep6zFZCyr8R5Lbtda+P6rreenBlTskuVaSP0/yB+vUtayvtdZev0l1AQAA7GpiQ2wlYkMb+/zOxB3Ehs6ta+HYUFXdLWsJJ19L8hvjkVGq6vlJXph+/l42yV/nvCP27IzvijMBsCfbZ9UNAHaLryd53bB+o6q65yobw/ZVVVdOcsvh4dvTb84mHnb+PbaP1tqXW2sPba09t7X2wdbaz3aiut9K78GRJB9O8tQZr3dCkj8eHu6T5MmzKqqq6ya5+/Dwa0l+dxRUmNT1tfSb/Imj1qnr0kkeOzz8aZKHjoMKQ12nJXlIkknPpj+vqulRYDLMxfunk92SPGQcVBjq+sVQ10+Hpx5fVZeY1TYAAIC9nNgQW4LY0G4jNpSlY0PjNj9meiqe4T3/bvoxSJJ7V9W116kLALYVSSewffxZ+tCGSfK0WT/Ul1VV+1XVI6rqrVX1jao6vaq+V1Ufq6qnVdVld/Y1drWqukFV/b+q+nRV/aiqzqyqU6vqxKp6U1U9vqqutM6+B1XVA6vqRVX1iar6wbD/aVX1H1X17Kr65R1o04Wr6n8Nx/G0qvppVX2mqp5eVYfs/Ls+93UuUlVPqKp/GX1+p1XVR6vqqVV1qc16rZEjszY840tba/+RPnxkktyzqi62TGVVdaOqem5VnTCce5Pj/+Hh+N9kg/1XcQx2h/uN1v92ztC0xyaZDCl6l+pzKs+r6+jpQMDI29KHLk16AHPWuX/3JAcM669orZ06q6LW2meSvGd4eJkkt5pR7Dbpc+kmybtba5+dUSbDa0yGo71Akrut0/7dqqqOrao2LIcPzz2wqt5VVd+sql9U1clV9cKqutYGdR05quvIOeWOqKqXVNUXquonVXVGVX1ruL4cN1zPf2mD17pJVR091PHj4fr05aHe6bmT59VzneHa+dXhvX6zqt5ZVdNzJi9a3x2HY/qloV0/G9p1bFX9+gL7H1hVjx2uBd8crgU/GT6Dj1TV31TVnapq/x1pHwAAbBFiQzOU2JDYkNjQto8NVdVVk1xvePil1tpb16nr50leMHrqvrPK7W5VddQoNnTE8Nydq+oNVXXKcF6fUlWvqKqbbVDXEaO6jppTboevnaM6rjnEXD5TVT+sqp8PsaJXV9U9lnj/h1XV31bVSUMdp1bV+6vq0dWTk5ZSVTerqr8f3ssPqseuvlZVr6qq/7bA/vtW1YOH4/D1Yf+fD+v/UT22ds+qutBGdQHsMVprFotlL13SM7xb+nCMSb+JmDx35Dr73H9U5qg5dV8tyedHZWctP0nPMN+s99GW2OeI0X7Hr1PmqPRgy7z30JK8fsa+ByT5xQL7npme/T+vrScPZU9OH0r0xDn1fSvJjebUNf6MD59T7k5Jvr1B23+U5Lc28XysJF8d6v5+kgsMz//h6DUftWBdF07ysgWOf0ty2FY5Bjt43CbnxzLn/3dH7+GSG5R986jsnWds/9ho+w03qOt5o7KPnbH9uNH2e21Q15NGZf9yxvZnjbb/zw3quveo7Kt34rM4clTPsTv5uY6/q1dL73G43nl4epKHL9iuI2ds3yc9ILLI9+U567zGfunD8m60/6uTXHCD9/6YJGfMqeO1wzHZ8FinB5fevUC7Xphk/3Xq+OUkX1rw+FxvZz53i8VisVgsFotldy+j37JiQ7PLHBWxoXltFxvajbGhqXN23e/egnWJDZ237NzYUJLHjbb/7QZ13WhU9iOb9Hkfv5Of91Gjuo5In45ovXP67CRP2ZnzMDtx7RzV8RdJztpg/+OTXGKD93739P9r1qvj/UkOXuRYp19XXrHA+3pzkouuU8clk3xkgTpakrvvzOdusVgsW2lZOsMP2KM9JckD0m+Kj6qql7fWzli2kqo6NMkHspZJflL6De1JSS6ePnzjndJ/pB1bVWe31l62883fPNXn6HzK8PDn6T8m/z3JaUkOTHJo+g3Eb65TxT7pmfHfSPIvST6VfpN6TpIrJLl5krum/6H2eVX1jdba69apa2L/JK9Jcs30YS9fkR5IOCzJQ9PnHb1MkndW1fXa1BCPi6qqeyV5VZJ9028y3pz+R9tvJblo+lyp9xvWX1dVv9lae8861S3jtunzuibJa1prpw/r/5TkGenH9GHpf9ie1/4Dk7w3ya8NT/0i/Q/dH0wPWByU5NpJ7pweAKsZdazqGOxy1UeqmAwT+tXW2nc32OVjSSYZ+tdOcm5PjqraJ/18TPpN4AkL1DUxa3jR8XMf30J1rdoz02+Qv5o+L/IXkhwyPHf79Gv2C6rqO621N+5A/Y9P8ohh/Qfp37lPJPlh+pzuhye5Sfp5v56Xpv//kfTv3EuS/Fv69+dGSR6e/n25T5KLVdUdW2ttupKqum+Svxs99bYkbxjadY2hnoV6sgy9+z6UnjSS9KDsa5J8Mf1a/CvpCTmHDvXuNzwe11HDPlcZnvpkegDsK+mB4YunfwdunbUeTwAAsCcTGxqIDYkNZWvHhu5VfRqsK6WfQ99Nv2d9S5KXtD7ixkxiQ7u8rk+mnzP7JrlWVdWsGMgK/Y/0mNJ30zvhfCo9/nPHJPdK/54dVVXfa609b9nKN+Hamar630n+aHh4dvpINO8Z6rtOkt/O2gg376mqm84656vqFunf/cnItB9M/16fmh7vemiSX0+Pt230vi6Q5F1Jbngb3wkAACAASURBVDo89bXhvX02vUPYVdKnarp6+vfl9cN14Zypql6QtWvTSUMdXxze20HD/rdMj8UB7D1WnfVisVh23ZK1jNnPj5577uj535uxz4a9WdL/SDgp85oMvRKmyhyZ/oNx0iPgspvwPtoS+xyROdnLWcvgPyvJzefUc2CSG894ft/0H+o1Z99fTfLN4XW+nGSfdcqdnPNmOD9zut70H87j3htvWqeuY0dlDp+x/Qrpf2hu6TfRv7ZOPb+W/kfglj7v88wRApb8HMft//Wpbe8abbvmBvX83ajsJ5NccU7Z2yQ5eKscgx08bueeHwuWv+W8c39G+YeNyr9watsVR9tOXqCuW4/Kv2tq2z7pf8SffO/226CuK43qOmnG9q/MO9enyu6XtZ4TZ8773m5Qz5Gj1zx2Jz/X8Xe1pd9YX2RGuXFPm2+uU2bcriNnbP/MsO0HSa42p00HZcZIHulBtkn930pyrRllDpv6TM7Xiy+9V8l3hu3nJHnEjDIXTfK+qWMz81jnvKPD/FlmXGOTXCTJO0bl7ji1fdw76U1J9p1zfK6VDXrXWCwWi8VisVgsW20Z/d4VGzr/drEhsaEtFRuaOmfnLd9Icus59YgNnb/s3NhQelxmUtcRC7zPr47KH7oJn/eGn9MGdR01dY58JsmlZ5S7++gz+Oms7042GOkkO3/tvFnWRkn5SZJbzihzSJKPjtrxVzPK7Jvzjrb11BllDkhPQhkfm5nHOsn/HZX5+yQHzCizf3pHrEm535nafums/b/30SQXnnN8Dss6ozBZLBbLnrjsE2C7eVr6D8ok+dOqusgyO1fVr6bfUCf9hvghba1Xwrlaa8em/zhL+h8Rf3dHGrsLTXq1f7a19m/rFWqt/aK19pEZz5/dWnt7a63N2fdTSf5keHjl9B4uG/lQkj+arre1dmZ6T/2Th6fuUlVXX6C+aX+Q/oflJLlPa+2jswoNzz9xeHho+ugFO2yYj3cyesF/pmedj710tH7knHqumOSRw8PvJblTm9Orp7X2ntbaD6aeXskx2I0OHq1v1JMl6cdx1r6bXddFknNHWPtBa+2snahrqbYNrzWZn3i/9J52O+uho/lt5y4L1PXDJPdvrf1kRtufl35znCS/lOSBO9DWyfXuX1trX1yvUGvtR621T87Y9Iej9Ye11k6cse9XsxaYTpI/qPPPD39k+hCjSe+V9cIZ9fw4Pcnlx+u1M+nzBqcHSpLkmNba09r5e5ZkOKb3Tz/Gydp3euIqo/VjWmtnr/earbUTW2vfW287AADsQcSGOrEhsaFk68WGWvrUHM9MH+3hPunv9+is3dteNn20m/VGkhAbmrJAbGgz3+eOuNWicaaqOnyDus5Kcr/W2qnTG1prr0/y7OHhhdKnQF7WTl07079/k9GH/qC19r4Z+56WPiXSz4anHlNV08f5rumjhiQ9keTJM+o5Iz2pau6oUFV12SSPHR6+u7X2mDZjFLDhOvyI9ISn5Pxxpisn5/7d9eWttZ9mHa21rw7xNIC9gqQT2GaGH5vPGR5eOskTlqzinqP1v21zhnJM8pdZ+wPkPeeUW4XJD9ZDh5veXWX8w3uRIfP+er1gRWvtFznvtBQLTUExMUwjMfmD9Udaa+/fYJdXpd+kJH2Kj53xgCQXHNb/acZ7/OesBbwePOOP1RP3y9rN6d+21r65TCNWfAx2l3Gw8BcLlB9/hy+6h9S1K+pbpX+aFQgYefZofanv/WByvbtqVe0/t+SUIZBx/eHhp1trb1uv7BBImAw1fFiSG04VGbf92VnH8L3+pw2a9uDR+rPmFWytfT9rQwPfchgudeJno/Vf2eA1AQBgryA2dC6xIbGhrRYb+kKSq7fWbtJa+6PW2otba8e11l7YWnt0+sgfk/vb/ZK8oqoOmlHPVo3nbOXY0N4UZ3pHa+2zc7Y/J300jmTn4kxLXzuHmMydh4ffS/Ki9coOCRmvGB5eOOf//i0aZ/pZkudv0LT7po+KMreuob4zs9ZB7KpTSUDiTMC2td/GRYC90F+lZzEfkuRJVfV3Q/bwIm48Wn/nvIKtta9V1efT5/28RlUd1Fr70bx9dqN/Sf9D6iFJ/rWqnpnkLcu2b/hR+dD0YQevkZ7ZfuA6xQ9doMqN5oYdb/+1dUvN9ivp7zdJTququ88rPPhJ+nu65kYFN/Cw0fo/Tm9srf20ql6X5EHpvTXulD5U47RfH62/cQfascpjsAqLjLKxVevazNfbFd6bPiT1Znj3Bts/lt4b56As/71P+vXuvunn8Luq6lnpQ9zOCwxPLHzNH5W57bB+k/TeWZOg3iQJ5dTW2mc2qOfdmd/b5jeGf89IcvUFevddYPTvlZN8bnj8gfRA0QWTPKWqLp4+CsunNqgPAAD2dGJDYkNiQ1ssNrRRAk1r7ftVda/0e+3rJLlE+vf4mfN227wWbpvY0Cpe97PpUwcvYl7HpWSDOFNr7VtV9bkk105ytaq6WGvth/P2mbIz187rZi1Gc/ys0USmvDN9hKekx5lePdo2uf6dkx6nm2ej2NtvjNYvvcB14eKj9WtmbQSqz6ZPf3W5JA8f4mEvSE9wO98IvQB7E0knsA211n44/Bh8ZpKLJfmjJP9rwd0vO1r/0gLlv5j+w6vSp4bYKoGF/5PkLkmulf5j9+VJzq6qT6YP7/ne9Kzwdf8oW1VPGOq5wHplpszqeTB22gIBnpNG65db8HUnDh+t3zFrQ+Eu4uIbF5mtqq6VtYDUv7fW1jtvXpoeWEh6IGJWYGEcnPncjO0bOXy0vtuOwW42nqLlguuWml1mekqTVdZ1oTl1TeqbfCYHTtW/bNt2xNeGIUk3w0nzNrbWWlV9Jcn1khxSVReYNXT1HH+YHpS7XPq8zrdMcnpVfSz9eveeJO8ZempMG1/z152aZ50y430vlrWha+e+3wXLHD78e0CS1y1Q39i53+XW2mlV9fvpQ37vlz4s6hOr6tT03ojvT/K21tqOXG8AAGDLEhtKIjYkNrQHxoZaa7+oqmdkbQSI/5bzJ52IDe36tm12nOm7uyvONCpz7axdl5dJOtmZa+dmxZmStevft+ZNYzNYNM6UJMdu3KzzGMeZzq6qR6eP3HRA+hRZv53kB1X1ofTOT+9orX18ydcA2PJMrwPb19+mZ90myeOqatGb1MlwgWct+EfP8Q/2HR1q8Nws4KpaNFluXO7s6Y3DdAs3TfL0JN8ent43vSf+76X/EfPbVfXUqjpgev+qemCS/5u1oML70+dEfkT6MJ/3GJZHj3Zbb1jQiZ9tsD1ZG2Y0Oe+wj4vYmaFiz3cMljC3J8vIu5P817B+16q65Iwyk+DM2cOQssta1THYncbzFF9igfLjMtNzHG9mXT/J2nC0B88ZJneRupZq23DdmJw7Z+W836OtYJd+91trJ6f3QHle1o7bBZLcIj2o/PYkp1TVE4YeGGPj6/Yix229a/64zcu+31k27bvcWvuHJLdOvwZN/r+5dJK7pw+pemJVfbCqbhwAANi7iA2JDS1DbGjrxIaOH63PGvlTbGjKArGhzXyfq7ar40w7c+3crDhTstburRZnenN6kt3rk0w6eB2cPnrT05N8rKo+XVXLJLwBbHmSTmCbGjKN/7/h4QWTPHnBXSeZ2/vNuuGeYfyjdUezvsc9YBYNTox7jsz84d9a+3Fr7c/Ss6JvkOTx6fMxfnf0Wn+e5I0z/hD71OHfs5LcubV2y9ban7fWXtRae3Vr7fVDdvoHF2xvct7s/fVceLS+Ufb+tHH5o1prtcRy+JKvleTcG7oHjZ56flW1WUt6AOjyQ7n9sza/7tjkXNi3qtYbqnae3X4MVmDcA+DwBcofts6+SXJKzjtP60aBvXXrGoaQ/PLwcN9sPKTwvHZNP3f4BnUdmrXA3pfWmxt7hXb1dz+ttVNba49PT6a4eZInpd/8Tr5Tl04Plv7D1K7j6/aFs7H1rvnjNi/7fmeZ1Hfykt/jaq0dP11Za+1fW2u3Sz8O90ifd/7DWQts3zzJB6rqiAXaDgAAewSxIbEhsaE9Njb0vdH6rNFXxIbOb6PY0MJ1Dcdgcp7+NGuJUlvF7ogz7ei1c7PiTMlauzczznRWkv2XvC4cO11Za+2E1to90pOT7pT+f+2/Zi0J5dpJ3jokLwLsFSSdwPb2oqz90H94VV1lgX3Gc4tedYHykzItybeWaNvYeL9fXnCfcblvr1sq/YantfaJ1trzWmv3T3KZ9D86ToYzvUP6UJVJkqq6cpIrDw9f31p725zqD5uzbdohVXXIBmXGn9E31i012/gG6FeW3HdH3Sl9iMYd8bAZz50yWt+ReXRXcQx2q9bat7IWfDh8nV5BYzcarX9mqq5zsjZU7X7pQ2buUF0znrvRjO2rqmvV5l57h5vzyTXntAV7Es7UWjuztfah1tqzh5vfS6UP8zmp85FVdZ3RLjt6zU/Oe436YdZ6lSzyf81GZSbf5StU1UbDUy+stfa9ITD8h621mya5YvowsUkPeD5rs14LAAC2CLGhiA3tYmJDm2/uKBtiQ7u8rutlLYHlxC3YuWmZuMvOXJeXvnZm8+JM48e/VFUbJZUsGmfaL8nVFmjXQobknLe31p7cWjsifYqg/ztsriR/vcCIPwB7BEknsI211s7MWi+W/bLWQ2Oej4zWf3Newaq6QpJrDA8/31rb0Tl7x6/5GwvuMy734WVebPix/Pqct4fPr4/WLzNa/3Lmu8Myr50+xcOi2z+6ZN2fyFpvkNsv8GN8M4yDAy9J8hcLLJN5fa9bVdefqu/9o/Xf2oH2rOIYrMI7Ruu3X69QVV0oa9+Vn6dn3M+ra93zeUiMGG9/x4xiC9U1GA8x+fZdXNeq3WaD7TfMWg+9Zb/3c7XWzmitvTh9WO2JW4zWF77mD8bn27n7DgGYjw0PL11VGwX2brvB9sm5um+Suy7Qrh3SWvuvJA/NWgDmhlW1yNzOAACwRxAbmk1saFOJDW2+W43WZ40AkogNrbKuVZsbZ6qqX8pawtYXW2s/3KwXXuDaeULWOj4dUVX7b1DlzDjT1ON9khyxQT2LxpmSnjSzSwydnZ6YUYwsiyXfAGx5kk6AVyT51LB+/2ycrf7a0frjNxjG8g+ydp355x1rXpLkjaP1R230Y3TolTP58X96Zt/gLOLk0fp46MjxPJHr9q6pqkMzu0fGPL8/p74LJHns6KnXLVNxa+3sJC8bHl4syZ8s2balDL0o7jI8/HGSx7TWjtpoSfL8UTXTx+9VWRuG8PFVddll2rS7j8EKvWq0/nszhgCeODJryQxvaa3Nmt/01aP1R8/5zt8pa70GPtZamxV0e32SM4b1B1TVpWdVNCQkTG6Qv5XZAY/3JvnOsH679ZIYhte4//DwF0nesE77V+lBVXWpOdufOFp/7bqlds7Jo/Vzr3ettZOT/Mfw8LpVNS9QdaOsfW5fTfLxqSLja9YTs46qukxmD6E89tLR+pN3ZZCwtXZWztuTbtH54wEAYE8hNrS+k0frYkNLEhvafMM5MG7zW9cpKja0VteGsaHW2pfSE5KS5KpVdad16jowySNHT716VrkVu2NVzRsF6PeyNlLL7o4znZ7kLcPDS6affzMNSYsPGB7+NMk7p4osGme6YJLHbNDeV2btvPz9ITFnVzp5tC7OBOwVJJ3ANjf0Pv/T4WGlz784r/ynkkyGDL1ykhfPmr+3qh6c5HeHhz9O8nc70czXJ/nCsH6NJC8cbrDOZ7jRfE36NAhJcuwwpOR0uaOr6trrveAwN+f4BuKE0frnsjZNxN2q6sYz9r9M+g3MovMMT9yiqp4xfSM4tOeFSa40PPXm1toXzrf3xp6RtWE3/7iqnlRV6/5fUFWXqqo/q6pf3YHXelDWPod/bn2u6EW8In3+zCT57+Pzq7X29SQvGB5eIn3uyyuuV1FV3aqqDp56enceg1V5U9YSBW6SPofqeQzv5xnDw3OyTm+21toJ6d/BpE818rzp4zV8Bn8/euqoder6TtauBRdJcux0oKKqLp7kH9OvR0nytCEgNF3XWUmePtktyUuHfcd1HZjei2qSkPC81tp43uOt4uAkr5iVOFFVv5O1G+xvZW2ql4VU1WWr6llVdaU5ZS6UPprHxAlTRZ45Wj+2qq4xtX1yDrwya78t/2rG5/aSrM3t+7CqOnJGPRcZ6pk7ZU5r7cNZC1hfLcmbhuvuTFW1X1XdvaoeO/X8A6vqYfNGL6mqmyaZ9Kz7SmttR+egBwCALUlsaDaxoXNfV2xoN8SGquoqQzvWPV+GuMdrk0za8f2s/70SG8rSsaG/GK3//fR5Nbzn56cfgyQ5rrW2Fadx3i/Jq2Z1cKqquyZ50vDwZznvZ7aQnbx2JslfpZ9vSfLsqrrF1PbJOXBc1j63v2+tTU8l9eas/b9wm6p68tT2DAmKL0py+HrtTc69rkxGAb5EknfUnOnmqrttVf3p1PN3qKr/UVUXm7PvVbI2SthPsvFoWQB7hNp6080Bm6WqJl/wL7TWzvdHwqmyH0xy86mn/2LoXTBd9tD0m5bJD9cvpv94Pyn9j6e/lfPO1fig1trLshOq6npJPpjkQsNTp6Rn7H86/Sb/kPQbqPtl7cfoiUlu0lr7yYz6Jsfms+lZ8Z9Jn2vywukBk/tnbWi7Lya53vjGuKqenbUM6tOTHJM+pOmZSW6Q3gvj4PTe+A8Zyr2ktXbkjLacnD6/7zfS54/8tSQfSr/B/vaw7aFZm2f2+0N7vjajrmOz9sfjKw2jFEyXuUN6D6HJDfuX0v94+7n0m42Dhvd+0/ThNfdN8huttQ9M1zVPVZ2QtZvg27bW3rPEvm9Jcufh4X1aa8eNth2Y5H3pxynpPRReleTf0j/Di6YfqzunDxV5vuOwmcdgdC5l1msto6oenrXg0cTj0nveJGs30hPfb609e526bph+nCbfmXem36z9NMmNkzwia9+Vp7fW/mxOuw5LH4p48kf9D6ff/H8vyXWSPDpr8wm/rLX2oDl1HZx+fk+uSZ9LD5r9V3pvmEcnucKw7fgktx+Ge55V1wFJ3pW1YWC/nuQf0q9FhyZ5eNaGCz0xyc13ZsjQIUnixcPD9yZ57oK7fnNIkhjXdWzWvquvT3L39F4OL0o/Hw9OH85zMqRrS3L31tq4d9+sdj2stXbsaNvhSf5zePjR9GGIP5ceXLtYkqsn+e9JLj+UeX+SW03PR1xVL89a8svPkxyb/jmenT7X8cOzlijyziR3nDWncVXdN+ftbfWW9O/iD4e2PDw9ePO6rA1nut6186AkH0g/B5P+3T1uaNd3kxyYPlfuDdKHYz0kyYtaa48Y1XFUkqekfy/+ZThGX0+/rl86/dy6e9auFY9orb1oui0AALBViQ2JDYkN7RmxoeH8/sTwXib3p19NP7cPHt7r/bMWIzoryV1ba+tO7yI2tHxsqKpemX4NSXps4R/Srw2XSP8eTxLMvpl+bfn6enVtpKqOSL/2JP06tO7xn/LD1tp7x0+M4hvJWpzpO+kJWp9OPwfukOQ+WUvmeXxr7XkbtOt8/wfs7LVzqOMZSf54eHh2+rXuPekxp2unn5uTc+1TSW46K2ltSFh5b9aS2z6Qfi04Nf26eWSSa+W8caZ/ba0dMaOu/dMTKidT8ZyZnjj4vvSOYPsPbbpuetLI5ZK8u7V2u1EdR6bH6M4Y2vXhJF9Jv6ZcMv17fN+sfe+e1lo7X0IYwB6ptWaxWPbSJf2PlC19ztyNyt5yVH6yHDWn/NWSfH7GPuPlp0kesonv5/rpP1TnveZkeWuSQ+bUdc6C9ZyQ5PAZ+x+Y/kN43r7/L/2H9uTxseu05eRh+8npP4Y/O6fObye50Zz3deyo7PnaPSp30/Qs6kWOwY+TXGfJz+oGo/1PSbLPkvvff7T/W2Zsv0h6r6VF2n/FXXkMpsqte8wXfN/HL9ieyXLyBvXdLv0ma739z0nyrAxJqAt8/zY6Xi9LcsACdR2eHpycV9e/JDl4gbounuTdG9T18fXOgyU/nyOX/Hwmy+s3+K5eLb2n0nr7n56e7LBIu46c2nbYEu18T5JLrPMa+6UHKjaq4zVJLrjBcXxs+o37enUclx6cmDyeee0c6rpo+sgoi77Hp07t/+QF9zsjyR/u7DlksVgsFovFYrHs7mX0m1Zs6Px1iQ2JDW2Z2FCS6y3YjpaejHLEgvWKDfVlodhQkgukJ0DMq+ukJNfdkc956rWOWOIzHy+fnFHXUaPtRyR53gaf+VELtut85bKT185RPU9NT56aV8fxWSdWNarnHukjhqxXx/vSE7fOrXNOXQekj3iyUbsmy0um9n/Igvudk+Q5WfK6aLFYLFt5MVcYkCRprb2vqt6etfluNyr/xaq6TnrPiXunZ/heIv0H3n8meXuS57fWvrGJbfxE9fko753eY+bG6T3RL5TkR+k3sB9Mz6b/4AbV/VL6vKC3SXLD9NElDkr/w+K303sWHJfkVW328I2/qKrbpw8V+OD0DOwD0rOeP5zem/6dwygDy7zHrw5Dsj4uPev5yuk3OyenZ6k/q7V22jJ1rvM6/15VV0/P3P+t9CzrS6UHTH6UnoH9ifSeAuvN5zrPeL7dl7fWzlm35GxvGNpxUJI7VNXlxudS6z2U7lNVN08/B2+Vnl1+wfQRE76YPmLDK9qMXj9DHTt9DKpPSzJxxrDfltFae1f1+Wwfk+Ru6efTgek9p96X5OjW2ocWrOsTw7Crj07/Dl41/Q/+pyb59yTHtDm9a6bqOrmqbpKeLHH/9N5HF0/vQfKJ9J4yr26ttQXq+n5V3S79+/Lg9ADIJdN7fX02PSHhxa0PubpVndFau2dVPTD9u3Pt9OPxrfTz79mttRN3pOLhmnLF9F4at04/PldMD86dnt6L6GPp39M3z6nnrCSPrKoXpfc2uVX6KCL7DO38YPpx3rDXWmvt76rq/ek9Am+b3kvk++k9b45prb1i0Wtn61Pd3L+qnpl+Y3+r4f1dLL132DfTz4P3JXlDa+0rU1U8PX1u99ukB9ivMbRn//SA4pfSe6a8sLV20iJtAgCAPZXYkNhQxIZWGRv6XPp372bpyTCHpcc3Dk4fJeHU9Pv3N6VP63LGIpWKDS0XG2qtnZ7kAVX1kiS/nf5ZXDprMYLXpB+zZb8Pu1Vr7XFV9dYkv5N+fbtk+rF9f5K/WfQzX8dOXTtHbXzyMLLM76THh66Qfg39Tvo19OWttddu1JjW2uuGc/xJ6aMbXT798/pCkn9Kj+mcVeedsWy9us5I8viq+pv0UXJunf6dufjo/X0ufUSVN7fWPj1VxT8m+eTwfm6Vfl5fNv07N/m/8QPp35VPbNgggD2I6XUAYAcNQ7FObqaf21r7H6tsD3uORYY7BgAAALY2sSG2gqnpdW7dWjt+da0BYDvaZ9UNAIA92GTOzh8nedoqGwIAAADAbic2BABse5JOAGDHTQILf91a+85KWwIAAADA7iY2BABse5JOAGAHVNUl0uer/k6SZ6+4OQAAAADsRmJDAADdfqtuAADsiVpr34vkTQAAAIBtSWwIAKDzgwgAAAAAAAAAgKVVa23VbdjlrnrrF+z9b3I3+6+vHL/qJux1Wjtn1U3Y6+y7zwGrbsJeZ5999l91E4AVOOecM1fdhL3OOe2sVTdhr3PgARdfdRP2Oqd96Xm16jbsChe84gO23P3hz7/2ir3yWMOe6Kq/+aItd43Y0333Pz++6ibsdVrEkDabuNzmc0x3Bcd0s519tnjHZhPvYE9wwP4XXXUT9ko//PLRe11sQwxpcUY6AQAAAAAAAABgaZJOAAAAAAAAAABY2n6rbgAAAADsLlX6XgAAAAAwnxjS4hwpAAAAAAAAAACWJukEAAAAAAAAAIClmV4HAACAbaP0vQAAAABgA2JIi3OkAAAAAAAAAABYmqQTAAAAAAAAAACWZnodAAAAto0qfS8AAAAAmE8MaXGOFAAAAAAAAAAAS5N0AgAAAAAAAADA0kyvAwAAwLZhaFQAAAAANrInxpCq6o5J/ibJvkle2Fr7P1PbD0tyTJJLJTktyYNaa6fs7OvueUcKAAAAAAAAAIAkSVXtm+T5Se6U5FpJHlBV15oq9qwkL22t/WqSpyb535vx2pJOAAAAAAAAAAD2XDdOclJr7SuttTOSvDLJ3abKXCvJu4f1987YvkNMrwMAAMC2UVWrbgIAAAAAW9weGEO6fJKvjx6fkuQmU2VOSHKv9Cl47pHkolV1idba93bmhY10AgAAAAAAAACwhVXVo6rqY6PlUePNM3ZpU4+flORWVfWJJLdK8l9JztrZdhnpBAAAgG1E3wsAAAAANrL1YkittaOTHL3O5lOSXGH0+NAk35ja/xtJ7pkkVXWRJPdqrf1wZ9u19Y4UAAAAAAAAAACL+miSq1bVlarqgCT3T/LGcYGqumRVTXJE/jjJMZvxwpJOAAAAAAAAAAD2UK21s5I8Lsk7knwuyatba5+tqqdW1W8NxY5I8oWq+mKSyyR5+ma8tul1AAAA2DbWOnMAAAAAwGx7YgyptfbWJG+deu7Jo/Xjkhy32a+75x0pAAAAAAAAAABWTtIJAAAAAAAAAABLM70OAAAA28aeODQqAAAAALuXGNLiHCkAAAAAAAAAAJYm6QQAAAAAAAAAgKWZXgcAAIBto/S9AAAAAGADYkiLc6QAAAAAAAAAAFiapBMAAAAAAAAAAJZmeh0AAAC2jSp9LwAAAACYTwxpcY4UAAAAAAAAAABLk3QCAAAAAAAAAMDSTK8DAADAtmFoVAAAAAA2Ioa0OEcKAAAAAAAAAIClSToBAAAAAAAAAGBpptcBAABg2zA0KgAAAAAbEUNa3B59pKrqbatuAwAAAABbmxgSAAAA7BpbfqSTqrrBepuSXG/Ofo9K8qgkudTVHpSLXe6Wu6B1AAAAAGwFmxJDusaDc7FDb7ULWgcAAAB7py2fdJLko0n+NT1AMO3gK15EdQAAIABJREFU9XZqrR2d5OgkueqtX9B2TdMAAADYk9TMW0tgL7HzMaTffJEYEgAAAGJIS9gTkk4+l+TRrbUvTW+oqq+voD0AAAAAbD1iSAAAALCb7bPqBizgqKzfzsfvxnYAAAAAsHUdFTEkAAAA2K22/EgnrbXjquoaVXXbJB9urf1ktPkXq2oXAAAAe56qPaHvBbAjxJAAAADYLGJIi9vyR6qqfi/JG9J7pHymqu422vyM1bQKAAAAgK1EDAkAAAB2vy0/0kmSRya5YWvtJ1V1eJLjqurw1trfJKmVtgwAAIA9il4qsFcTQwIAAGBTiCEtbk9IOtl3Mhxqa+3kqjoiPWhwWAQMAAAAAOjEkAAAAGA32xPSc75VVdebPBiCB3dJcskk11lZqwAAAADYSsSQAAAAYDfbE0Y6eUiSs8ZPtNbOSvKQqvqH1TQJAACAPZGhUWGvJoYEAADAphBDWtyWTzpprZ0yZ9sHd2dbAAAAANiaxJAAAABg95OeAwAAAAAAAADA0rb8SCcAAACwefS9AAAAAGAjYkiLcqQAAAAAAAAAAFiapBMAAADYwqrqjlX1hao6qar+aMb2K1bVe6vqE1X1qaq68yraCQAAAMD2Y3odAAAAto2qPavvRVXtm+T5SX4zySlJPlpVb2ytnTgq9mdJXt1a+/uqulaStyY5fLc3FgAAAGAvsafFkFbJkQIAAICt68ZJTmqtfaW1dkaSVya521SZluSgYf1iSb6xG9sHAAAAwDZmpBMAAADYui6f5Oujx6ckuclUmaOSvLOqHp/kwklut3uaBgAAAMB2J+kEAACAbWMrDo1aVY9K8qjRU0e31o6ebJ6xS5t6/IAkx7bWnl1VN0vyj1V17dbaObuguQAAAAB7va0YQ9qqJJ0AAADACg0JJkevs/mUJFcYPT40558+5+FJ7jjU9aGqOjDJJZOcuslNBQAAAIDzkJ4DAAAAW9dHk1y1qq5UVQckuX+SN06V+VqS2yZJVV0zyYFJvrNbWwkAAADAtmSkEwAAALaN2sP6XrTWzqqqxyV5R5J9kxzTWvtsVT01ycdaa29M8j+TvKCqfj996p0jW2vTU/AAAAAAsKA9LYa0SpJOAAAAYAtrrb01yVunnnvyaP3EJLfY3e0CAAAAAOk5AAAAAAAAAAAszUgnAAAAbBtV+l4AAAAAMJ8Y0uIcKQAAAAAAAAAAlibpBAAAAAAAAACApZleBwAAgG2jqlbdBAAAAAC2ODGkxRnpBAAAAAAAAACApUk6AQAAAAAAAABgaabXAQAAYNuo0vcCAAAAgPnEkBbnSAEAAAAAAAAAsDRJJwAAAAAAAAAALM30OgAAAGwbpe8FAAAAABsQQ1qcIwUAAAAAAAAAwNKMdAIAAMC2UaXvBQAAAADziSEtblsknVzs0ddYdRP2Omf/5Y9X3YS9zn4HHLjqJux9qlbdgr3O6T/7/qqbsNc54JBLrboJe52zfuA83WxnnPnTVTdhr3PBAw9ZdRP2Ou06l111EwDYCxz021dbdRP2PsesugF7obPOWXUL9j5CSJuvrboBe5/66ZmrbsJe5/TTf7DqJux1zmlnrboJe5399vW3o013y6uvugWw15GeAwAAAAAAAADA0rbFSCcAAACQGBoVAAAAgI2JIS3OkQIAAAAAAAAAYGmSTgAAAAAAAAAAWJrpdQAAANg2St8LAAAAADYghrQ4RwoAAAAAAAAAgKVJOgEAAAAAAAAAYGmm1wEAAGD7KH0vAAAAANiAGNLCHCkAAAAAAAAAAJYm6QQAAAAAAAAAgKWZXgcAAIBtowyNCgAAAMAGxJAW50gBAAAAAAAAALA0SScAAAAAAAAAACzN9DoAAABsG1W16iYAAAAAsMWJIS3OSCcAAAAAAAAAACxN0gkAAAAAAAAAAEszvQ4AAADbRul7AQAAAMAGxJAW50gBAAAAAAAAALA0SScAAAAAAAAAACzN9DoAAABsG1X6XgAAAAAwnxjS4hwpAAAAAAAAAACWJukEAAAAAAAAAIClmV4HAACA7aNq1S0AAAAAYKsTQ1qYkU4AAAAAAAAAAFiakU4AAADYPnS9AAAAAGAjYkgLc6gAAAAAAAAAAFiapBMAAAAAAAAAAJZmeh0AAAC2j6pVtwAAAACArU4MaWFGOgEAAAAAAAAAYGmSTgAAAAAAAAAAWJrpdQD+f/buPWryu64T/PvzdIfgigRJQkYCJAwm64DOGc9k8eyKmuUiQRniZlACZ1fNZNODY1ZWRjE6HvYQz4yXuTheMjItl7COGNBBiRjgsEAQZeCkd0QkcJBMCKaDOAyEQFYhl/7sH081PKfp7qd+9VRX1a/q9TqnTlX9LvX7pE6nu593f36fLwAAm8NoVAAAAAB2I0OamkknAAAAAAAAAAAMpukEAAAAAAAAAIDBLK8DAADA5nDrBQAAAAC7kSFNzVcFAAAAAAAAAMBgmk4AAAAAAAAAABhs5ZfXqaozkvxkku9JcvZk839N8sYkP9fdn11WbQAAAIxLVy27BOAUkSEBAAAwLzKk6Y1h0snrk9yd5OLuPrO7z0zyP0+2/faJTqqqA1V1qKoOfertNy6oVAAAAACWZM8Z0n+TIQEAAMAgY2g6Ob+7f767P3l0Q3d/srt/PsnjTnRSdx/s7ou6+6Kzn/achRQKAAAAwNLsOUM6S4YEAAAAg4yh6eTjVfWSqjrn6IaqOqeqfiLJnUusCwAAgLGpFXwA8yJDAgAAYD6WnReNKEMaQ9PJ85KcmeRdVXV3VX0myc1JHpnk+5ZZGAAAAAArQ4YEAAAAC7Z/2QXsprvvrqpXJ3lbkvd2971H91XVJUnesrTiAAAAAFgJMiQAAABYvJWfdFJVP5LkjUmuTvLBqrp0x+5/sZyqAAAAGKWtWr0HMBcyJAAAAOZm2XnRiDKklZ90kuSqJH+/u++tqvOT/E5Vnd/dv5SVXrkIAAAAgAWSIQEAAMCCjaHpZN/RcajdfUdVXZzt0OC8CAwAAAAA2CZDAgAAgAVb+eV1knyyqv7e0TeT8ODZSc5K8k1LqwoAAIDxqVq9BzAvMiQAAADmY9l50YgypDE0nXx/kk/u3NDdD3T39yf59uWUBAAAAMCKkSEBAADAgq388jrdffgk+/54kbUAAAAAsJpkSAAAALB4K990AgAAAHOzupNIAQAAAFgVMqSpjWF5HQAAAAAAAAAAVoymEwAAAAAAAAAABrO8DgAAAJtjy2xUAAAAAHYhQ5qaSScAAAAAAAAAAAxm0gkAAACbo9ylAgAAAMAuZEhTM+kEAAAAAAAAAIDBNJ0AAAAAAAAAADCY5XUAAADYHCajAgAAALAbGdLUTDoBAAAAAAAAAGAwTScAAAAAAAAAAAxmeR0AAAA2x5bZqAAAAADsQoY0NZNOAAAAAAAAAAAYTNMJAAAAAAAAAACDWV4HAACAzWEyKgAAAAC7kSFNzaQTAAAAAAAAAAAG03QCAAAAAAAAAMBgltcBAABgY3SZjQoAAADAycmQpmfSCQAAAAAAAAAAg2k6AQAAAAAAAAAYsaq6pKo+UlW3VdU1Jzjm+6rqQ1V1a1W9dh7XtbwOAAAAm2PLaFQAAAAAdjGyDKmq9iW5LskzkhxOcktV3djdH9pxzAVJfjLJt3b33VX1qHlc26QTAAAAAAAAAIDxenKS27r79u6+L8kNSS495pirklzX3XcnSXf/13lcWNMJAAAAAAAAAMB4nZvkzh3vD0+27XRhkgur6o+r6r1Vdck8Lmx5HQAAADbHuCajAgAAALAMK5ghVdWBJAd2bDrY3QeP7j7OKX3M+/1JLkhycZLHJHl3VX1jd392L3VpOgEAAAAAAAAAWGGTBpODJ9h9OMljd7x/TJJPHOeY93b3/Uk+VlUfyXYTyi17qWsjmk7+n8vuXXYJa+fz/+CCZZewds48/ZHLLmHtdB5cdglr54sP3rPsEtbOf7f/rGWXsHa+8OCeGnI5jiN9/7JLWDv76vRll7B29m89dNklALAG/t/nn7PsEtbOA897+LJLgF0dyQPLLmHtbG3GPz0AnHL+jJo/uRxr7JYkF1TV45PcleTyJC845pjfS/L8JNdX1VnZXm7n9r1e2N/8AAAA2By1grNRAQAAAFgtI8uQuvuBqro6yVuT7Evyqu6+taquTXKou2+c7PvOqvpQkgeT/Hh3f3qv19Z0AgAAAAAAAAAwYt19U5Kbjtn20h2vO8mLJ4+52ZrnhwEAAAAAAAAAsBlMOgEAAGBzbI1rNCoAAAAASyBDmppJJwAAAAAAAAAADGbSCQAAAJvDTSoAAAAA7EaGNDWTTgAAAAAAAAAAGEzTCQAAAAAAAAAAg1leBwAAgM1RZqMCAAAAsAsZ0tRMOgEAAAAAAAAAYDBNJwAAAAAAAAAADGZ5HQAAADaH0agAAAAA7EaGNDWTTgAAAAAAAAAAGEzTCQAAAAAAAAAAg1leBwAAgM3h1gsAAAAAdiNDmpqvCgAAAAAAAACAwTSdAAAAAAAAAAAwmOV1AAAA2BxVy64AAAAAgFUnQ5qaSScAAAAAAAAAAAym6QQAAAAAAAAAgMEsrwMAAMDmMBkVAAAAgN3IkKZm0gkAAAAAAAAAAINpOgEAAAAAAAAAYDDL6wAAALAxestsVAAAAABOToY0PZNOAAAAAAAAAAAYTNMJAAAAAAAAAACDWV4HAACAzVFGowIAAACwCxnS1Ew6AQAAAAAAAABgME0nAAAAAAAAAAAMZnkdAAAANofJqAAAAADsRoY0NZNOAAAAAAAAAAAYTNMJAAAAAAAAAACDWV4HAACAzbFlNioAAAAAu5AhTc2kEwAAAAAAAAAABjPpBAAAgM1R7lIBAAAAYBcypKmZdAIAAAAAAAAAwGCaTgAAAAAAAAAAGGzlm06q6mFVdW1V3VpV91TVp6rqvVX1g7ucd6CqDlXVoetf8eYFVQsAAMBKqxV8AHMxjwzp4MHXLahaAAAAVtqy86IRZUj7l13AFH4zye8meWaS70vy1UluSPLTVXVhd//U8U7q7oNJDibJZ+97cy+oVgAAAACWY88ZUvLnMiQAAAAYYOUnnSQ5v7uv7+7D3f1vkjynuz+a5Iokly25NgAAAABWgwwJAAAAFmwMk07+v6p6Snf/UVX9gySfSZLuPlJVKzxEBgAAgJWz5cdIWGMyJAAAAOZDhjS1MTSdvDDJK6rqwiQfTPKPkqSqzk5y3TILAwAAAGBlyJAAAABgwVa+6aS7P5DkycfZ/qmq+vwSSgIAAABgxciQAAAAYPFWvulkFy9L8uplFwEAAMBIGI0Km0qGBAAAwPRkSFNb+aaTqvrAiXYlOWeRtQAAAACwmmRIAAAAsHgr33SS7VDgmUnuPmZ7JXnP4ssBAAAAYAXJkAAAAGDBxtB08qYkD+vu9x+7o6puXnw5AAAAjFWbjArrTIYEAADAXMiQprfyTSfdfeVJ9r1gkbUAAAAAsJpkSAAAALB4W8suAAAAAAAAAACA8Vn5SScAAAAwN1tmowIAAACwCxnS1Ew6AQAAAAAAAABgME0nAAAAAAAAAAAMZnkdAAAANkcZjQoAAADALmRIUzPpBAAAAAAAAACAwTSdAAAAAAAAAAAwmOV1AAAA2BxbRqMCAAAAsAsZ0tRMOgEAAAAAAAAAYDBNJwAAAAAAAAAADGZ5HQAAADaHWy8AAAAA2I0MaWq+KgAAAAAAAAAABtN0AgAAAAAAAADAYJbXAQAAYHNULbsCAAAAAFadDGlqJp0AAAAAAAAAADCYSScAAABsji13qQAAAACwCxnS1Ew6AQAAAAAAAABgME0nAAAAAAAAAAAMZnkdAAAANkaX0agAAAAAnJwMaXomnQAAAMAKq6pLquojVXVbVV1zkuOeW1VdVRctsj4AAAAANpemEwAAAFhRVbUvyXVJnpXkiUmeX1VPPM5xX5PkR5K8b7EVAgAAALDJNJ0AAACwObZW8HFyT05yW3ff3t33JbkhyaXHOe5nkvxCki9M/V0AAAAAcHzLzouGZ0hLs8KlAQAAwPqrqgNVdWjH48CO3ecmuXPH+8OTbTvP/+Ykj+3uNy2gXAAAAAD4kv3LLgAAAAA2WXcfTHLwBLvreKd8aWfVVpJfTPKD868MAAAAAE5O0wkAAACbY+t4PRwr7XCSx+54/5gkn9jx/muSfGOSm6sqSf5Wkhur6jndfWhhVQIAAACsk/FlSEuzEU0nX7XvrGWXsHa26rPLLmHt3H/k3mWXsHZO33fGsktYO6fve/iyS1g7n7v/U8suYe189f5HLLuENdS7H8Ig3Q8uu4S182Dfv+wS4FS5JckFVfX4JHcluTzJC47u7O57knzph96qujnJj2k4gdkc8efJ3HWOLLuEtXOkH1h2CWvIzzzzdsS/0cxdt99PYRP5++n81da+ZZewlvb5s3+jbS27AAAAAOD4uvuBJFcneWuSDyd5fXffWlXXVtVzllsdAAAAAJtuIyadAAAAQJKkxnfrTXfflOSmY7a99ATHXryImgAAAADW2ggzpGUx6QQAAAAAAAAAgME0nQAAAAAAAAAAMJjldQAAANgcW0ajAgAAALALGdLUTDoBAAAAAAAAAGAwTScAAAAAAAAAAAxmeR0AAAA2h8moAAAAAOxGhjQ1k04AAAAAAAAAABhM0wkAAAAAAAAAAINZXgcAAICN0VtmowIAAABwcjKk6Zl0AgAAAAAAAADAYJpOAAAAAAAAAAAYzPI6AAAAbA6jUQEAAADYjQxpaiadAAAAAAAAAAAwmEknAAAAbI5ylwoAAAAAu5AhTc2kEwAAAAAAAAAABtN0AgAAAAAAAADAYJbXAQAAYHO49QIAAACA3ciQpuarAgAAAAAAAABgME0nAAAAAAAAAAAMZnkdAAAANkfVsisAAAAAYNXJkKZm0gkAAAAAAAAAAINpOgEAAAAAAAAAYDDL6wAAALA5toxGBQAAAGAXMqSpmXQCAAAAAAAAAMBgmk4AAAAAAAAAABjM8joAAABsDqNRAQAAANiNDGlqJp0AAAAAAAAAADCYphMAAAAAAAAAAAazvA4AAAAbo8toVAAAAABOToY0PZNOAAAAAAAAAAAYTNMJAAAAAAAAAACDWV4HAACAzeHWCwAAAAB2I0Oamq8KAAAAAAAAAIDBNJ0AAAAAAAAAADCY5XUAAADYHFXLrgAAAACAVSdDmtrKTzqpqouq6p1V9R+q6rFV9baquqeqbqmqbz7JeQeq6lBVHXrFr//uIksGAAAAYMHmkSEdPPjbiywZAAAARm8Mk07+XZL/K8kjkrwnyY929zOq6mmTff/j8U7q7oNJDibJFx+8pRdUKwAAAADLsecM6UjfKkMCAACAAVZ+0kmS07r7zd39W0m6u38n2y/enuShyy0NAACAUdmq1XsA8yJDAgAAYD6WnReNKEMaQ9PJF6rqO6vqe5N0VX1PklTVdyR5cLmlAQAAALAiZEgAAACwYGNYXueFSX4hyZEkz0zyQ1V1fZK7kly1xLoAAAAAWB0yJAAAAFiwlW866e4/zXZQcNSLJo9U1RXZXqMXAAAAdrfCo0iBvZEhAQAAMDcypKmNYXmdk3nZsgsAAAAAYOXJkAAAAOAUWPlJJ1X1gRPtSnLOImsBAABg5NykAmtLhgQAAMDcyJCmtvJNJ9kOBZ6Z5O5jtleMRQUAAABgmwwJAAAAFmwMTSdvSvKw7n7/sTuq6ubFlwMAAADACpIhAQAAwIKtfNNJd195kn0vWGQtAAAAjFtvmY0K60qGBAAAwLzIkKa3tewCAAAAAAAAAACYXVVdUlUfqarbquqa4+x/YVX9WVW9v6r+qKqeOI/rajoBAAAAAAAAABipqtqX5Lokz0ryxCTPP05TyWu7+5u6++8l+YUk/2Ye11755XUAAABgbspoVAAAAAB2Mb4M6clJbuvu25Okqm5IcmmSDx09oLs/t+P4r07S87iwphMAAAAAAAAAgPE6N8mdO94fTvItxx5UVT+c5MVJHpLkqfO4sOV1AAAAAAAAAABWWFUdqKpDOx4Hdu4+zilfMcmku6/r7ick+YkkPz2Pukw6AQAAYHNsjW40KgAAAACLtoIZUncfTHLwBLsPJ3nsjvePSfKJk3zcDUl+bR51mXQCAAAAAAAAADBetyS5oKoeX1UPSXJ5kht3HlBVF+x4+91JPjqPC5t0AgAAAAAAAAAwUt39QFVdneStSfYleVV331pV1yY51N03Jrm6qp6e5P4kdyf5gXlcW9MJAAAAm2P1JqMCAAAAsGpGmCF1901Jbjpm20t3vH7Rqbiu5XUAAAAAAAAAABhM0wkAAAAAAAAAAINZXgcAAICNseXWCwAAAAB2IUOanq8KAAAAAAAAAIDBNJ0AAAAAAAAAADCY5XUAAADYGFXLrgAAAACAVSdDmp5JJwAAAAAAAAAADKbpBAAAAAAAAACAwSyvAwAAwMYwGhUAAACA3ciQpmfSCQAAAAAAAAAAg+1p0klVnZPk6UmemORrkzx0itO6u6/cy3UBAAAAGA8ZEgAAAKynmZpOqurMJL+Y5PIk+2b4CIEBAAAAC1dmo8JCyZAAAAAYIxnS9AY3nVTV1yR5d5L/Psks33TPcA4AAAAAIyJDAgAAgPU3y6STn0ryDZPXf5nkV5P8UZK/SvLFOdUFAAAAc+cmFVgoGRIAAACjJEOa3ixNJ5dNnu9I8i3d/an5lQMAAADAmpAhAQAAwJrbmuGcx2V7vOl1wgIAAAAATkCGBAAAAGtulkkndyc5J8nH51wLAAAAnFJGo8JCyZAAAAAYJRnS9GZpOvlwtgODr5tzLadM54Fll7B2aqYhOZzMEb9O5+5I37/sEtbO5++/Z9klrJ2HbPlby7z95V/7dTpvZzykl13C2nngiP/35+2rT/uqZZcAwFcaYYbk7z3z5mfz+es8uOwSYFfdR5Zdwtrxnc6fP/dPBb9O582v0/nz91OYv1k6B16ZpJI8d861AAAAALA+ZEgAAACw5mZpOrkhyVuSPKWqfnzO9QAAAMApU1ur94A1JkMCAABglJadF40pQxpcWm/PcPu+JH+Q5Oeq6ver6llVdebcqwMAAABglGRIAAAAsP72z3JSd99bVd+f5G1JvmvySNVUa9N3d890XQAAAADGQ4YEAAAA622mH9yr6hlJXpfkjKOb5lYRAAAAnCLT/Ts3MC8yJAAAAMZIhjS9wU0nVfWkJDcmOX2yqZN8LMlfJfni/EoDAAAAYKxkSAAAALD+Zpl08s+yHRZ0klckeVl3f2KuVQEAAAAwdjIkAAAAWHOzNJ38T9kOC/6gu//xnOsBAACAU2bLaFRYJBkSAAAAoyRDmt7WDOc8avL8hnkWAgAAAMBakSEBAADAmpul6eSTk+e/mWchAAAAAKwVGRIAAACsuVmW13l3kvOSPGnOtQAAAMApVUajwiLJkAAAABglGdL0Zpl08itJHkxyVVU9fM71AAAAALAeZEgAAACw5gY3nXT3oSQvzva6vG+pqsfMvSoAAAAARk2GBAAAAOtv8PI6VfX9ST6X5A1J/mGSj1bV7yd5X5JPJzmy22d09/899LoAAACwV0ajwuLIkAAAABgrGdL0BjedJLk+SU9ed5LTsx0c/MMpz+8kAgMAAACA9XZ9ZEgAAACw1mZpOkmSY/t69PkAAAAAcCwZEgAAAKyxWZpOrph7FQAAALAAZTYqLJIMCQAAgFGSIU1vcNNJd7/mVBQCAAAAwPqQIQEAAMD621p2AQAAAAAAAAAAjM8sy+sAAADAKJVbLwAAAADYhQxper4qAAAAAAAAAAAGGzzppKoet9eLdvdf7PUzAAAAAFhdMiQAAABYf7Msr3NHkt7DNXvG6wIAAMCeVC27Atgod0SGBAAAwAjJkKY36w/uvmIAAAAAdiNDAgAAgDU2S9PJa6Y4ZivJWUkuSnJ2tu9MeUeSwzNcDwAAAObCXSqwUDIkAAAARkmGNL3BTSfdfcW0x1bVVpLnJ/nlJN+U5Ke6+5ah1wQAAABgXGRIAAAAsP62TuWHd/eR7v7NJM9M8sgkb6iqM0/lNQEAAAAYFxkSAAAAjNMpbTo5qrsPJbkhyaOT/MgirgkAAADHqlq9B/BlMiQAAABWwbLzojFlSAtpOpl4Z5JKctkCrwkAAADAuMiQAAAAYCQW2XRy7+T5vAVeEwAAAIBxkSEBAADASOxf4LWeOHnuBV4TAAAAvmRrhUeRAl8iQwIAAGCpZEjTW8ikk6p6XJJ/ku2w4KOLuCYAAAAA4yJDAgAAgHEZPOlk8sP/NB6S5NFJnprkh5Ocme3A4HVDrwkAAADAuMiQAAAAYP3NsrzOHZl9vOn7k/zyjOcCAADAnpTRqLBId0SGBAAAwAjJkKY36/I6NfBxJMlvJHl6d39xjzUDAAAAMA4yJAAAAFhjs0w6ec2Ux30xyWeTfCjJ27r7L2e4FgAAAADjJEMCAACANTe46aS7rzgVhZxIVf3nJG9I8lvd/V8GnHcgyYEk+dVfe0muvOp7TlGFAAAAjIXRqLA4Y8yQfu3lL81VB773FFUIAADAWMiQpjfLpJNF+9okj0jyzqr6ZJLfSvK67v7EyU7q7oNJDibJFx78T7OuHwwAAADAOOw5Q3qwPyhDAgAAgAG2ll3AFO7u7h/r7scl+adJLkjyn6vqnZM7UQAAAABAhgQAAAALdsomnVTVk5J86+Qaf9rdf7zXz+zudyd5d1X9H0mekeR5mdyJAgAAALupLbNRYdXIkAAAAFg1MqTpDW46qapzkvzE5O313f2B4xzz8iRXHbPtD5Nc1t13D7zknx+7obsfTPKWyQMAAACAFSNDAgAAgPU3y/I6z07yf2Y7ELj92J1V9aIkB5LUMY9vT/L6oRfr7stPtK+qrhj6eQAAAAAshAwJAAAA1twsTSeXTJ7f2d337txRVfuT/OTk7ReT/KskVye5JduhwVOr6rtmrPV4XjbHzwIAAGDNVa16xwDWAAAgAElEQVTeA9aYDAkAAIBRWnZeNKYMafDyOkm+IUkned9x9j01yaMm+1/Y3a9Jkqq6PslHkjw6yQuS3DTtxarqK0avHt2V5JypqwYAAABgkWRIAAAAsOZmaTo5a/J8x3H2PXXy/Lkkv3l0Y3f/dVW9NsmPJ7lo4PXOSfLMJMeu41tJ3jPwswAAAABYDBkSAAAArLlZmk4eOXn+6+Ps+9Zs36Hyju5+4Jh9H5k8nzvwem9K8rDufv+xO6rq5oGfBQAAwAZb5VGksIZkSAAAAIySDGl6szSd3Dc574ydG6vqofnyHSh/dJzz7pk8nz7kYt195Un2vWDIZwEAAACwMDIkAAAAWHNbM5xz1+T5m4/Z/vR8OQw43sjSR0ye753hmgAAAACMiwwJAAAA1twsTSfvzfZauP9rVT0hSapqX5Ifm+z/bJJDxznv70ye/2KGawIAAMCeVa3eA9aYDAkAAIBRWnZeNKYMaZamk1dPnh+R5Jaq+t0kf5rk27O9Fu9/6O4Hj3Pet032/8kshQIAAAAwKjIkAAAAWHP7h57Q3e+qqlcmuTLbocFzduz+RJKfOfacqjo/yf+Q7cDgnbMUCgAAAHu1tcJ3hcC6kSEBAAAwVjKk6c0y6SRJDiT50SS3Jrkv2+NQX5/kKd39345z/A/veP32Ga8JAAAAwLjIkAAAAGCNDZ50kiTd3Ul+afKYxr9O8quTU++a5ZoAAAAAjIsMCQAAANbbTE0nQ3X3JxdxHQAAADiZMhoVVpoMCQAAgFUgQ5rerMvrAAAAAAAAAACwwTSdAAAAAAAAAAAw2EKW1wEAAIBVUG69AAAAAGAXMqTp+aoAAAAAAAAAABhM0wkAAAAAAAAAAINZXgcAAICNUbXsCgAAAABYdTKk6Zl0AgAAAAAAAADAYJpOAAAAAAAAAAAYzPI6AAAAbIwyGxUAAACAXciQpje46aSqXjV5+f7u/uU51wMAAADAGpAhAQAAwPqbZdLJDybpJH8631IAAAAAWCM/GBkSAAAArLVZmk4+neSRSe6acy0AAABwSpmMCgslQwIAAGCUZEjT25rhnI9Nns+aZyEAAAAArBUZEgAAAKy5WZpOfjdJJfmuOdcCAAAAwPqQIQEAAMCam6Xp5NeSHE7y3VV12ZzrAQAAgFOmavUesMZkSAAAAIzSsvOiMWVIg5tOuvuzSS7N9nq8N1TVv6yq8+ZeGQAAAACjJUMCAACA9bd/6AlV9Y7Jy88meUySFyd5cVXdle0Q4W92+Yju7qcNvS4AAAAA4yFDAgAAgPU3uOkkycVJevL66HMlOXfyOJnacQ4AAAAs1CqPIoU1dHFkSAAAAIyQDGl6szSdJNs/+E+zDQAAAIDNJUMCAACANTa46aS7t05FIafSPfd9atklrJ3P3y8fmreHjO7/rNV3xkP+etklrB2/TufvCw8uu4L187DT3BA7b6dtnbbsEtbO2Q99wrJLWDv33n942SUAcIwxZkhH+v5ll7B2jvQDyy5h7bQhQHPX8cM5q6/9fjp3fj+dv62a9V53TqTbn1Hz1uU7hXnzuz8AAAAbY0v/PAAAAAC7kCFNb3R3nAAAAAAAAAAAsHyaTgAAAAAAAAAAGGzPy+tU1blJnpbk7yT52iSndfeVe/1cAAAAmDejUWF5ZEgAAACMhQxpejM3nVTVo5L82yTPTbLv6OYkneTKY479d0n+9yR3dvcTZr0mAAAAAOMiQwIAAID1NVPTSVVdkORdSc7Jdkiwm19J8sIk51fVxd198yzXBQAAgL3Yql52CbBRZEgAAACMkQxpeltDT6iq05K8KcnfynZY8BtJnpnk6hOd090fTvJnk7eXDC8TAAAAgDGRIQEAAMD6G9x0ku2xpxdkewTqP+7uH+jutyW5a5fz3pXtgOFbZrgmAAAAbKSquqSqPlJVt1XVNcfZf3pVvW6y/31Vdf7iq4TjkiEBAADAmptleZ3LJs/v6O5fH3DerZPnC2e4JgAAAOzZ1jSLe6yQqtqX5Lokz0hyOMktVXVjd39ox2FXJrm7u7++qi5P8vNJnrf4auEryJAAAAAYpbFlSMs0y6STb8r2HSq/N/C8z0yev3aGawIAAMAmenKS27r79u6+L8kNSS495phLk7xm8vp3kjytqkQjrAIZEgAAAKy5WZpOHjl5/uTA82aZqgIAAACb7Nwkd+54f3iy7bjHdPcDSe5JcuZCqoOTkyEBAADAmpvlh/ij4dUZA887b/L86RmuCQAAAHs2y50Xp1pVHUhyYMemg9198Oju45zSx37EFMfAMsiQAAAAGKVVzJBW1Szf1ccmz08eeN6zsh16fXCGawIAAMBa6u6D3X3RjsfBHbsPJ3nsjvePSfKJYz7iS8dU1f5s/wP/ZwLLJ0MCAACANTdL08nbsn0X1eVVdfY0J1TVdyb5tsnbt85wTQAAANhEtyS5oKoeX1UPSXJ5khuPOebGJD8wef3cJO/obpNOWAUyJAAAAFhzszSd/PskX0zyNUn+Y1WddERqVT0tyWsnbz+X5FUzXBMAAAD2bKt65R4n090PJLk62//4/uEkr+/uW6vq2qp6zuSwVyY5s6puS/LiJNecwq8QhpAhAQAAMErLzouGZkjLtH/oCd19Z1Vdm+SfJ/nWJH9eVa/KjgaWqnpKkm9M8r8keXq272rpJP+0uz83j8IBAABgE3T3TUluOmbbS3e8/kKS7110XbAbGRIAAACsv8FNJ0nS3T9bVY9K8qIkZyd5ydFdk+d37Ti8Js/Xdrc7VAAAAAA2hAwJAAAA1ttMTSdJ0t0/WlU3J3lZkr97kkNvTfKT3f2mWa8FAAAA87BVux8DzJcMCQAAgLGRIU1v5qaTJOnuNyZ5Y1X93STfluT8JGckuTfJXUne1d2H9lokAAAAAOMlQwIAAID1tKemk6O6+wNJPjCPzwIAAABgPcmQAAAAYL3MpekEAAAAxmBr2QUAAAAAsPJkSNMb/F1V1Wur6uJTUAsAAAAAa0KGBAAAAOtvlgady5O8vao+WlUvqapHzbsoAAAAAEZPhgQAAABrbtapMJXkbyf52SR3VtVvV9Uz51cWAAAAzN9Wrd4D1pwMCQAAgNFZdl40pgxplqaTv5/k3yf5fLaDg9OSXJbkpqq6o6p+uqrOnWONAAAAAIyPDAkAAADW3OCmk+7+k+7+oSRfl+TKJO/JdnBQSR6X5GVJ7qiqN1bVs6tq1mkqAAAAAIyUDAkAAADW38w/zHf333T3q7v7KUmelOSXknw628HBviTPTvLGJH9RVddW1XnzKBgAAABmVdUr94B1J0MCAABgbJadF40pQ5rLHSTd/eHu/tEk5yZ5QZJ3THZVkkcn+WdJ/ktVvaWqLquq/fO4LgAAAADjIUMCAACA9TLXsaXdfV9339DdT0/y9Ul+NslfZjs42EryjCS/neRwVf2LqnrcPK8PAAAAwOqTIQEAAMB8VdUlVfWRqrqtqq45zv7Tq+p1k/3vq6rz53HdU7ZWbnd/LMk7k7z36KZ8ed3eRyX5iSQfraqXV9UjTlUdAAAAcNRWrd4DNp0MCQAAgFWz7LxoaIZUVfuSXJfkWUmemOT5VfXEYw67Msnd3f31SX4xyc/P5buax4fsVFVfV1U/VVW3JXlrku85uivJh5P8SpI7J+9PS3JVkkNVdfa8awEAAABgNcmQAAAAYG6enOS27r69u+9LckOSS4855tIkr5m8/p0kT6uqPd8SNZemk9r27Kr6vSQfT/IzSf52tkOB+5K8Nsl3dPeTuvtFSc7P9n/Qockxj0/y0nnUAgAAAMBqkiEBAADAKXFutm/cOOrwZNtxj+nuB5Lck+TMvV54/15Orqrzsj2C5Yokjz66efJ8W5KDSV7d3Z/eeV53d5Lfr6o/SPLmbK/T+6y91AIAAAC7OWVrzAInJUMCAABgTFYxQ6qqA0kO7Nh0sLsPHt19nFP62I+Y4pjBBjedVNX+bI87vSrJ0/LlNXaT5P4kNyZ5eXe/fbfP6u4jVXV9tgODxw2tBQAAAIDVJEMCAACA+Zk0mBw8we7DSR674/1jknziBMccnvzMfkaSz+y1rlkmndyV5KzJ66NBwceT/HqSV3b3Xw38vKP/EftmqAUAAACmtlV7vnkDmJ4MCQAAgFEaYYZ0S5ILqurx2f55/PIkLzjmmBuT/ECS/5TkuUneMZkwuiezNJ2cPXl+MMlNSV6e5C17KOauJK8ZckJVnXnsuFUAAAAAVooMCQAAABagux+oqquTvDXbN2u8qrtvraprkxzq7huTvDLJb1TVbdm+sePyeVx7lqWI7kpybZLzu/vS7n7zXrpfuvuD3X1Fd19xvP1V9XNVddbk9UVVdXuS91XVx6vqO070uVV1oKoOVdWh33jlW2ctDwAAAIDZjC5DesXB/zhreQAAALBU3X1Td1/Y3U/o7n8+2fbSScNJuvsL3f293f313f3k7r59HtedZdLJed19ZB4Xn9J3d/c1k9f/MsnzuvuWqrowyWuTXHS8k3auZ/RXf3Pj6GbfAAAAMH9btfsxwNyMLkO6/8ifyJAAAACQIQ0weNLJgsOCJDmtqo42x3xVd98yqePPk5y+4FoAAAAAmIIMCQAAANbfLMvrLNp1SW6qqqcmeUtV/duq+vaqelmS9y+5NgAAAABWgwwJAAAAFmyW5XW+QlU9Msm5SR6eZN9ux3f3H0772d39K1X1Z0l+KMmF2a75wiS/l+RnZioYAACAjTSGOy9gncmQAAAAGAMZ0vRmbjqpqocneVGS/y3JEwac2kOv2903J7n5ODVckeTVQz4LAAAAgMWRIQEAAMD6mqnppKq+IclNSc5LUnOtaJiXRWAAAAAAsJJkSAAAALDeBjedVNXpSX4/yfmTTX+Y5D1Jrsn2HSivT3JntsOEi5OcPdn+hiQfnOF6HzjRriTnDP08AAAANtfWMv/JGzaMDAkAAICxkiFNb5ZJJ/8o26NQO8lLuvtfJ0lVXTPZ/1vdfeNk22lJ/kmSn01ySZJXdvdbBl7vnP+fvfsPtvSu6wP+/tzdJBA2YELNDwEFC1qshaCRQSkIBARBAmppLe00tolbazvVVivp0HGknWpUtOq0tS5EE7VVKCAJQZEQCNJBKwtECEQatfLDLIkiFJJAstn99o97MrNzuXvP89x97nnOec7rNXPnnHue55zz2e/cvffuez/P55vkuUk+veXxymZQAQAAAMDykSEBAADAxO2m6eSS2e3/eSAsOJnW2tEkP1dVf5rk2iS/VlUXttY+0eP9rk9yoLV289YDVXVTj9cBAAAAYHFkSAAAADBxu2k6eWI2r1B5zUmOb2x9oLX2pqq6PskLkvyzJC/v+mattct2OPbSrq8DAAAAG9XGLgHWiQwJAACAlSRD6u6L/nHfwTmz249uefzY7PbMkzzvzdkcZ/ptu3hPAAAAAFaLDAkAAAAmbjdNJw8EA5/d8vjnZrcXnOR5n5ndPmoX7wkAAADAapEhAQAAwMTtZnudTyZ5dJKztzz+sSR/K8mFJ3neV85uH7yL9wQAAIBTtlFjVwBrRYYEAADASpIhdbebSSe3zG6/esvj78nm6NMXVtU5Jx6oqtOTPLCv7sd38Z4AAAAArBYZEgAAAEzcbppO3pXNYOBpWx7/jdntWUneVlXPq6qvqqpvTfLObF6l0pL89m6LBQAAAGBlyJAAAABg4nazvc6bkvxkkouq6itaax9NktbajVV1Q5LnJHlikjdv89xPz54LAAAAC7ebKy+AXZMhAQAAsJJkSN31bjpprX2kqi5Ncubs40QvSfL6JBdv89Q/T/J3Wmt/3rtKAAAAAFaKDAkAAACmbzeTTtJa+9WTPP7ZJM+pqqcleXaS85Lck829en+ztfaF3RYKAAAAwGqRIQEAAMC07arpZJ7W2ruyuW8vAAAALI2NamOXAJxAhgQAAMAykiF1ZysiAAAAAAAAAAB603QCAAAAAAAAAEBve7K9DgAAACyjjRq7AgAAAACWnQypu5M2nVTV2/foPVtr7eI9em0AAAAAFkiGBAAAAOtrp0knz0jSBn6/2oPXBAAAgE5cpQJ74hmRIQEAADAhMqTu5m2vYykBAAAAmEeGBAAAAGvopE0nrbWNRRYCAAAAwOqRIQEAAMD6mjfpBAAAACbD/4wDAAAAMI8MqTtrBQAAAAAAAABAb5pOAAAAAAAAAADobZDtdarq3CTfkOTLkhxIcleS25O8p7V25xDvAQAAAKdqo9rYJcBakyEBAACwCmRI3Z1S00lVfXuSH0rylB3O+b0kr2ytvfFU3gsAAACA1SRDAgAAgGna1fY6VXV6Vb02yeuyGRbUDh/fmOT1VfXaqjp9kKoBAAAAWHoyJAAAAJi23U46eX2S52czEEiSDyd5e5I/TnJ3kockeWySZyb5m7NzvjPJg5JcsttiAQAA4FRs1PxzgEHJkAAAAFg5MqTuejedVNV3JXlBkpbNPXcva639zg7nf0uSq5I8IskLqurvtdZes8t6AQAAAFgBMiQAAACYvt1sr3PZ7PbuJN+8U1iQJK21tyZ5RpK7Zg9dvov3BAAAAGC1yJAAAABg4nbTdPLEbF6hclVr7U+6PGF23lXZHKV64S7eEwAAAE7ZxhJ+wITJkAAAAFhJY+dFq5Qh9d5eJ8mB2e17ej7vgfPP3MV7npL99lsa3IHT2tglTM7pNgYb3PF2dOwSJufu+32dDu2cMx46dgmTc/vdnxu7hMlpp90/dgmTc9fRj4xdwuR8yelnjV0CAF9s5TKkluOLfsvJO9buG7uEyTnW7h27hMnZv/GgsUsARnC8yTuGZk2HV7XM/828mo63Y2OXAJOzm+9Ut89u9/V83gPn377jWQAAAABMgQwJAAAAJm43TSdvn90+refznpbNkapvn3ciAAAA7IWNWr4PmDAZEgAAACtp7LxolTKk3TSd/HyS+5L8o6r6hi5PqKqLklya5N7Z8wEAAACYNhkSAAAATFzvppPW2i1JvidJJbmhqi6vqv3bnVtV+6vqsiQ3ZPMKlctbax86lYIBAAAAWH4yJAAAAJi+bf+hv5Oq+pHZ3RuSPD/JLya5sqreleSPk9yT5Mwkj03yt5OcMzv/t5I89oTnf5HW2r/vWw8AAAB0VdXGLgHWhgwJAACAVSVD6q5300mSH83mFSc54facJJdsc26dcM7zZx87ERgAAAAATMOPRoYEAAAAk7abppNkMwjo8thOj2+lVQgAAABgWmRIAAAAMGG7aTp55uBVAAAAwAJsdP0vbWAIMiQAAABWkgypu95NJ621d+5FIQAAAABMhwwJAAAApm9j7AIAAAAAAAAAAFg9u9leBwAAAFaSKy8AAAAAmEeG1J21AgAAAAAAAACgN00nAAAAAAAAAAD0ZnsdAAAA1sZGtbFLAAAAAGDJyZC6M+kEAAAAAAAAAIDeTDoBAABgbWzU2BUAAAAAsOxkSN2ZdAIAAAAAAAAAQG+aTgAAAAAAAAAA6M32OgAAAKwNo1EBAAAAmEeG1J1JJwAAAAAAAAAA9KbpBAAAAAAAAACA3myvAwAAwNrYN3YBAAAAACw9GVJ3Jp0AAAAAAAAAANCbphMAAAAAAAAAAHqzvQ4AAABrY6Pa2CUAAAAAsORkSN2ZdAIAAAAAAAAAQG+aTgAAAAAAAAAA6M32OgAAAKyNjRq7AgAAAACWnQypO5NOAAAAAAAAAADoTdMJAAAAAAAAAAC92V4HAACAtWE0KgAAAADzyJC6M+kEAAAAAAAAAIDeNJ0AAAAAAAAAANCb7XUAAABYG/uMRgUAAABgDhlSdyadAAAAAAAAAADQm6YTAAAAAAAAAAB6W/qmk6p63gn3H1ZVV1XVB6rqf1TVeTs872BVHa6qw9dc9TuLKRYAAICltlHL9wEMY4gM6dWH3rCYYgEAAFhqY+dFq5Qh7R+7gA5+LMlbZvd/OsmRJC9M8h1JfjHJi7d7UmvtUJJDSfKpL1zX9r5MAAAAAEZ0yhnSfcffK0MCAACAHlah6eREF7XWLpzd/09Vdemo1QAAAACwjGRIAAAAsACr0HRyblX96ySV5KFVVa21B646WfrtgQAAAFgeG2WIAUyYDAkAAIBByJC6W4V/cL8qyVlJDiS5JslfS5KqOj/JzSPWBQAAAMDykCEBAADAgi39pJPW2itO8vgnq+odi64HAACA1bVRY1cA7BUZEgAAAEORIXW3CpNOdrJtmAAAAAAAJ5AhAQAAwB5Y+kknVfWBkx1Kct4iawEAAABgOcmQAAAAYPGWvukkm6HAc5N8esvjleTdiy8HAACAVbVv7AKAvSRDAgAAYBAypO5Woenk+iQHWms3bz1QVTctvhwAAAAAlpAMCQAAABZs6ZtOWmuX7XDspYusBQAAAIDlJEMCAACAxVv6phMAAAAYykaNXQEAAAAAy06G1N3G2AUAAAAAAAAAALB6NJ0AAAAAAAAAANCb7XUAAABYGxvVxi4BAAAAgCUnQ+rOpBMAAAAAAAAAAHrTdAIAAAAAAAAAQG+21wEAAGBt7KuxKwAAAABg2cmQujPpBAAAAAAAAACA3jSdAAAAAAAAAADQm+11AAAAWBsbRqMCAAAAMIcMqTuTTgAAAAAAAAAA6E3TCQAAAAAAAAAAvdleBwAAgLVhNCoAAAAA88iQujPpBAAAAAAAAACA3jSdAAAAAAAAAADQm+11AAAAWBtGowIAAAAwjwypO5NOAAAAAAAAAADoTdMJAAAAAAAAAAC92V4HAACAtbGv2tglAAAAALDkZEjdmXQCAAAAAAAAAEBvmk4AAAAAAAAAAOjN9joAAACsDVdeAAAAADCPDKk7awUAAAAAAAAAQG8mnQAAALA2NmrsCgAAAABYdjKk7kw6AQAAAAAAAACgN00nAAAAAAAAAAD0thbb69zfxq5geg7sf+jYJUzO/e2esUuAuR5+xlljlzA5n7nvM2OXMDkfv3vf2CVMzuePmSM4tMecdWzsEibnzP2fHbsEVoTRqMBOjh2/d+wSJudY+8LYJUxOy/GxS5ic+4/7Oh1ai3/zDK1cQzy4Y+3o2CVMzkbJ5YbWmu+nQzsev/PTjQypO7+lAAAAAAAAAADQm6YTAAAAAAAAAAB6W4vtdQAAACBJ9pX9VwEAAADYmQypO5NOAAAAAAAAAADoTdMJAAAAAAAAAAC92V4HAACAtbFRY1cAAAAAwLKTIXVn0gkAAAAAAAAAAL1pOgEAAAAAAAAAoDfb6wAAALA2jEYFAAAAYB4ZUncmnQAAAAAAAAAA0JumEwAAAAAAAACAiaqqc6rqhqq6bXZ79jbnfEVVvbeqbq6qD1XV93Z5bdvrAAAAsDaMRgUAAABgnglmSFckubG1dmVVXTH7/GVbzjmS5Jtaa/dW1YEkt1TVda2123d6YZNOAAAAAAAAAACm60VJrpndvybJi7ee0Fq7r7V27+zTM9Kxn0TTCQAAAAAAAADAEquqg1V1+ISPgz2efl5r7UiSzG7PPcl7PKqqPpDk40l+Yt6Uk8T2OgAAAKyRfdMbjQoAAADAwJYxQ2qtHUpy6GTHq+ptSc7f5tDLe7zHx5M8oaq+LMkbq+p1rbU7dnqOphMAAAAAAAAAgBXWWnv2yY5V1R1VdUFr7UhVXZDkzjmvdXtVfSjJ05K8bqdzba8DAAAAAAAAADBd1yW5dHb/0iTXbj2hqh5ZVQ+e3T87yVOTfGTeC5t0AgAAwNrYqDZ2CQAAAAAsuQlmSFcmeW1VXZbkY0lekiRVdVGS722tXZ7k8Ul+uqpakkryytbaB+e9sKYTAAAAAAAAAICJaq19KsnF2zx+OMnls/s3JHlC39e2vQ4AAAAAAAAAAL2ZdAIAAMDacOUFAAAAAPPIkLqzVgAAAAAAAAAA9KbpBAAAAAAAAACA3myvAwAAwNrYqLErGFZVnZPkNUkeneTPkvzd1tqnT3LuQ5PcmuQ3W2v/YlE1AgAAAKyaqWVIe8mkEwAAAFhdVyS5sbX2uCQ3zj4/mf+Q5J0LqQoAAACAtWDSCQAAAGtj3/SuUnlRkmfM7l+T5KYkL9t6UlV9fZLzkrwlyUULqg0AAABgJU0wQ9ozJp0AAADA6jqvtXYkSWa35249oao2kvx0kn+z4NoAAAAAmDiTTgAAAGBEVXUwycETHjrUWjt0wvG3JTl/m6e+vONbfF+S32qtfbzKZToAAAAADEfTCQAAAGtjo9rYJXyRWYPJoR2OP/tkx6rqjqq6oLV2pKouSHLnNqd9Y5KnVdX3JTmQ5PSququ1dsWp1g4AAAAwRcuYIS0rTScAAACwuq5LcmmSK2e31249obX2Dx64X1XfneQiDScAAAAADGFj7AIAAACAXbsyyXOq6rYkz5l9nqq6qKpePWplAAAAAEyeSScAAACsjY0au4JhtdY+leTibR4/nOTybR6/OsnVe14YAAAAwAqbWoa0l0w6AQAAAAAAAACgN00nAAAAAAAAAAD0ZnsdAAAA1obRqAAAAADMI0PqbiUnnVTVuWPXAAAAAMBykyEBAADA3lr6ppOqOmfLx8OT/EFVnV1V5+zwvINVdbiqDv/qVb+zwIoBAAAAWLQhMqSrXnXtAisGAACA1bcK2+v8ZZKPbnnsEUnel6Ql+crtntRaO5TkUJLc8fnr2l4WCAAAwGpY+isvgFNxyhnS5+9/twwJAAAAGVIPq7BWP5zkI0kuaa09prX2mCSfmN3fNiwAAAAAYO3IkAAAAGDBlr7ppLX2yiSXJ/mRqvqZqjorm1enAAAAAEASGRIAAACMYRW210lr7RNJXlJVL0xyQ5IzRy4JAACAFVQ1dgXAXpIhAQAAMAQZUndLP+nkRK21NyV5ZpJnJ0lV/eNxKwIAAABg2ciQAAAAYDFWqukkSVprn2+t3TL79BWjFgMAAADAUpIhAQAAwN5b+u11quoDJzuU5LxF1gIAAMBqMxkVpkuGBAAAwFBkSN0tfdNJNkOB5yb59JbHK1KxMxkAACAASURBVMm7F18OAAAAAEtIhgQAAAALtgpNJ9cnOdBau3nrgaq6afHlAAAAALCEZEgAAACwYEvfdNJau2yHYy9dZC0AAACstjIbFSZLhgQAAMBQZEjdbYxdAAAAAAAAAAAAq0fTCQAAAAAAAAAAvS399joAAAAwFFdeAAAAADCPDKk7awUAAAAAAAAAQG8mnQAAALA2qtrYJQAAAACw5GRI3Zl0AgAAAAAAAABAb5pOAAAAAAAAAADozfY6AAAArI0auwAAAAAAlp4MqTuTTgAAAAAAAAAA6E3TCQAAAAAAAAAAvdleBwAAgLVRZqMCAAAAMIcMqTuTTgAAAAAAAAAA6E3TCQAAAAAAAAAAvdleBwAAgLVhMioAAAAA88iQujPpBAAAAAAAAACA3jSdAAAAAAAAAADQm+11AAAAWBsbZqMCAAAAMIcMqTuTTgAAAAAAAAAA6E3TCQAAAAAAAAAAvdleBwAAgLVhMioAAAAA88iQujPpBAAAAAAAAACA3jSdAAAAAAAAAADQm+11AAAAWBtlNioAAAAAc8iQujPpBAAAAAAAAACA3jSdAAAAAAAAAADQm+11AAAAWBsmowIAAAAwjwypu7VoOjnefEkM7a77Pzt2CZPj63R4dx21pkM7/8wvjF3C5Pg6Hd55Dz4+dgmTc8a+NnYJk/Ow063p8Hw/BeDUHc/RsUuYnBa/9wzteDs2dgkTZE2H5+/+0DZqLf47Z6GONV+nQzt6/P6xS5ic0+xZMbhjuW/sEmByfKsCAAAAAAAAAKA3rbEAAACsDTNxAAAAAJhHhtSdSScAAAAAAAAAAPSm6QQAAAAAAAAAgN5srwMAAMDa2DAbFQAAAIA5ZEjdmXQCAAAAAAAAAEBvJp0AAACwNlykAgAAAMA8MqTuTDoBAAAAAAAAAKA3TScAAAAAAAAAAPRmex0AAADWRlUbuwQAAAAAlpwMqTuTTgAAAAAAAAAA6E3TCQAAAAAAAAAAvdleBwAAgLVRYxcAAAAAwNKTIXVn0gkAAAAAAAAAAL1pOgEAAAAAAAAAoDfb6wAAALA2ymxUAAAAAOaQIXVn0gkAAAAAAAAAAL1pOgEAAAAAAAAAoDfb6wAAALA2XHkBAAAAwDwypO6sFQAAAAAAAAAAvWk6AQAAAAAAAACgN9vrAAAAsDaqxq4AAAAAgGUnQ+rOpBMAAAAAAAAAAHrTdAIAAAAAAAAAQG+21wEAAGBtmIwKAAAAwDwypO5MOgEAAAAAAAAAoDdNJwAAAAAAAAAA9GZ7HQAAANZGmY0KAAAAwBwypO5MOgEAAAAAAAAAoDdNJwAAAAAAAAAA9GZ7HQAAANaGyagAAAAAzCND6s6kEwAAAAAAAAAAejPpBAAAgLWx4TIVAAAAAOaQIXVn0gkAAAAAAAAAAL1pOgEAAAAAAAAAoDfb6wAAALA2TEYFAAAAYB4ZUndLP+mkqs6vql+oqv9SVQ+vqh+tqg9W1Wur6oKx6wMAAABgfDIkAAAAWLylbzpJcnWSDyf5eJJ3JPl8khckeVeS/3ayJ1XVwao6XFWHf+2X3rKIOgEAAAAYz9U5xQzpl171pkXUCQAAAJNRrbWxa9hRVb2/tfak2f2Ptda+/IRjN7fWLpz3GkfuedNy/yFXUJUlHdrxZkjT0O46ak2Hdv6ZZ4xdwuR88p57xy5hco4eH7uC6Tljn5/7Q3vY6dZ0aPvKz/2hnXPGCye5qJ/8/HVL9xfw/AdfMsm1hkUbIkO6+/53Lt33iFV39Pg9Y5cwOcfb/WOXAB34djq0jdo/dgmTc/S476dDO+6v/uBOW4XxAStmX50+dgmT9LDTnze5bEOG1N0qfKs6scZf2XJs3yILAQAAAGBpyZAAAABgwVah6eTaqjqQJK21f/fAg1X12CQfGa0qAAAAAJaJDAkAAAAWbOnnsbXWfuQkj/9xVb150fUAAACwupZyBikwCBkSAAAAQ5EhdbcKk0528oqxCwAAAABg6cmQAAAAYA8s/aSTqvrAyQ4lOW+RtQAAAACwnGRIAAAAsHhL33SSzVDguUk+veXxSvLuxZcDAADAqiqzUWHKZEgAAAAMQobU3So0nVyf5EBr7eatB6rqpsWXAwAAAMASkiEBAADAgi1900lr7bIdjr10kbUAAAAAsJxkSAAAALB4S990AgAAAEMxGRUAAACAeWRI3W2MXQAAAAAAAAAAAKtH0wkAAAAAAAAAAL3ZXgcAAIC14coLAAAAAOaRIXVnrQAAAAAAAAAA6E3TCQAAAAAAAAAAvdleBwAAgLVRNXYFAAAAACw7GVJ3Jp0AAAAAAAAAANCbphMAAAAAAAAAAHqzvQ4AAABrxGxUAAAAAOaRIXVl0gkAAAAAAAAAAL1pOgEAAAAAAAAAoDfb6wAAALA2ymhUAAAAAOaQIXVn0gkAAAAAAAAAAL2ZdAIAAMDaqHLtBQAAAAA7kyF1Z6UAAAAAAAAAAOhN0wkAAAAAAAAAAL3ZXgcAAIA1UmMXAAAAAMDSkyF1ZdIJAAAAAAAAAMBEVdU5VXVDVd02uz37JOd9eVW9tapuraoPV9Wj5722phMAAAAAAAAAgOm6IsmNrbXHJblx9vl2fiXJT7XWHp/kyUnunPfCttcBAABgbZTRqAAAAADMMcEM6UVJnjG7f02Sm5K87MQTquprkuxvrd2QJK21u7q8sEknAAAAAAAAAADTdV5r7UiSzG7P3eacr0rymap6Q1W9v6p+qqr2zXthk04AAAAAAAAAAJZYVR1McvCEhw611g6dcPxtSc7f5qkv7/gW+5M8LcmTknwsyWuSfHeSq+Y9CQAAANbE5EajAgAAADC45cuQZg0mh3Y4/uyTHauqO6rqgtbakaq6IMmd25z2iSTvb6396ew5b0zylMxpOrG9DgAAAAAAAADAdF2X5NLZ/UuTXLvNOe9JcnZVfens82cl+fC8F9Z0AgAAAAAAAAAwXVcmeU5V3ZbkObPPU1UXVdWrk6S1dizJDyW5sao+mM1xL6+a98Jrsb3OQ0578NglTM7dRz8/dgmT84VjY1cwPY98yNljlzA5f/mFvxq7hMk5cNrYFUzPX3xh+Uberbp779OnPLR7j7WxS5ics06zpkM754yxK9gbVb6nASd3vN0/dgmTc/T40bFLmJz7j/s3z9BO3/C75NCOWtLBHW8C5KFt+HY6uKN+Rg2uxTfUoZ2x4Xd+uplahtRa+1SSi7d5/HCSy0/4/IYkT+jz2tNaKQAAAAAAAAAAFkLTCQAAAAAAAAAAva3F9joAAACwybhnAAAAAOaRIXVl0gkAAAAAAAAAAL1pOgEAAAAAAAAAoDfb6wAAALA2ymhUAAAAAOaQIXVn0gkAAAAAAAAAAL1pOgEAAAAAAAAAoDfb6wAAALA2jEYFAAAAYB4ZUncmnQAAAAAAAAAA0JumEwAAAAAAAAAAerO9DgAAAGvEtRcAAAAAzCND6spKAQAAAAAAAADQm0knAAAArI2qGrsEAAAAAJacDKk7k04AAAAAAAAAAOhN0wkAAAAAAAAAAL3ZXgcAAIA1YjQqAAAAAPPIkLoy6QQAAAAAAAAAgN40nQAAAAAAAAAA0JvtdQAAAFgbZTQqAAAAAHPIkLoz6QQAAAAAAAAAgN40nQAAAAAAAAAA0JvtdQAAAFgjrr0AAAAAYB4ZUldWCgAAAAAAAACA3jSdAAAAAAAAAADQm+11AAAAWBuVGrsEAAAAAJacDKk7k04AAAAAAAAAAOhN0wkAAAAAAAAAAL3ZXgcAAIC1UWU0KgAAAAA7kyF1Z9IJAAAAAAAAAAC9aToBAAAAAAAAAKA32+sAAACwRoxGBQAAAGAeGVJXJp0AAAAAAAAAANCbphMAAAAAAAAAAHqzvQ4AAABro1x7AQAAAMAcMqTurBQAAAAAAAAAAL1pOgEAAAAAAAAAoLelbzqpqodW1Y9X1a9W1Uu3HPuvOzzvYFUdrqrDv/zqN+99oQAAAKyAWsIPYAjDZEjX732hAAAArICx86LVyZD2j11AB7+c5LYkr0/yT6rqO5O8tLV2b5KnnOxJrbVDSQ4lyWePvq0tolAAAAAARnPKGdLnjt4oQwIAAIAeln7SSZK/3lq7orX2xtbaJUnel+TtVfXwsQsDAACAMVXVOVV1Q1XdNrs9+yTn/WRVfaiqbq2qn6+q5b08BnZPhgQAAAALtgqTTs6oqo3W2vEkaa39x6r6RJLfTXJg3NIAAABYJRPstbgiyY2ttSur6orZ5y878YSq+qYkT03yhNlD/yvJNye5aYF1wiLIkAAAABjEBDOkPbMKk07elORZJz7QWrsmyQ8muW+UigAAAGA5vCjJNbP71yR58TbntCQPSnJ6kjOSnJbkjoVUB4slQwIAAIAFW/pJJ621Hz7J42+pqh9bdD0AAACsssldpXJea+1IkrTWjlTVuVtPaK39XlW9I8mRbC7Af26t3brgOmHPyZAAAAAYzuQypD2zCpNOdvKKsQsAAACAU1FVB6vq8AkfB7ccf1tV3bLNx4s6vv5jkzw+ySOTPCLJs6rq6cP/SWCpyZAAAABgDyz9pJOq+sDJDiU5b5G1AAAAwNBaa4eSHNrh+LNPdqyq7qiqC2ZTTi5Icuc2p317kt9vrd01e85vJ3lKkt89tcphuciQAAAAYPGWvukkm6HAc5N8esvjleTdiy8HAACAVVUrP/Dzi1yX5NIkV85ur93mnI8l+Z6q+vFs/lv6m5P87MIqhMWRIQEAADCICWZIe2YVmk6uT3KgtXbz1gNVddPiywEAAIClcWWS11bVZdlsLnlJklTVRUm+t7V2eZLXJXlWkg8maUne0lp700j1wl6SIQEAAMCCLX3TSWvtsh2OvXSRtQAAAMAyaa19KsnF2zx+OMnls/vHkvzTBZcGCydDAgAAgMVb+qYTAAAAGE6NXQAAAAAAS0+G1JWNiAAAAAAAAAAA6E3TCQAAAAAAAAAAvdleBwAAgLVRRqMCAAAAMIcMqTuTTgAAAAAAAAAA6E3TCQAAAAAAAAAAvdleBwAAgLVRZTQqAAAAADuTIXVn0gkAAAAAAAAAAL1pOgEAAAAAAAAAoDfb6wAAALBGXHsBAAAAwDwypK6sFAAAAAAAAAAAvWk6AQAAAAAAAACgN9vrAAAAsDYqNXYJAAAAACw5GVJ3Jp0AAAAAAAAAANCbphMAAAAAAAAAAHqzvQ4AAABrxGhUAAAAAOaRIXVl0gkAAAAAAAAAAL1pOgEAAAAAAAAAoDfb6wAAALA2qoxGBQAAAGBnMqTuTDoBAAAAAAAAAKA3TScAAAAAAAAAAPRmex0AAADWiGsvAAAAAJhHhtSVlQIAAAAAAAAAoDeTTgAAAFgblRq7BAAAAACWnAypO5NOAAAAAAAAAADoTdMJAAAAAAAAAAC9VWtt7Bo4QVUdbK0dGruOKbGmw7Omw7Omw7Omw7Omw7Omw7Omw7Omw7OmAAzBz5PhWdPhWdPhWdPhWdPhWdPhWdPhWdPhWdPhWVNWhUkny+fg2AVMkDUdnjUdnjUdnjUdnjUdnjUdnjUdnjUdnjUFYAh+ngzPmg7Pmg7Pmg7Pmg7Pmg7Pmg7Pmg7Pmg7PmrISNJ0AAAAAAAAAANCbphMAAAAAAAAAAHrTdLJ87Ms1PGs6PGs6PGs6PGs6PGs6PGs6PGs6PGs6PGsKwBD8PBmeNR2eNR2eNR2eNR2eNR2eNR2eNR2eNR2eNWUlVGtt7BoAAAAAAAAAAFgxJp0AAAAAAAAAANCbppMlUVW/VFV3VtUtY9cyBVX1qKp6R1XdWlUfqqrvH7umVVdVD6qqP6iqP5yt6SvGrmkqqmpfVb2/qq4fu5YpqKo/q6oPVtXNVXV47HqmoKq+pKpeV1V/NPu++o1j17TqquqrZ1+jD3x8tqp+YOy6VllV/avZz6dbqurXq+pBY9e06qrq+2fr+SFfn7u33e/5VXVOVd1QVbfNbs8es0YAVosMaVgypL0hR9obMqThyZGGJ0calgxpb8iRhidHOnUyJFaZppPlcXWS541dxITcn+QHW2uPT/KUJP+8qr5m5JpW3b1JntVae2KSC5M8r6qeMnJNU/H9SW4du4iJeWZr7cLW2kVjFzIRP5fkLa21v5HkifH1espaax+ZfY1emOTrk9yT5DdHLmtlVdUjkvzLJBe11r42yb4k3zVuVautqr42yfckeXI2/95/W1U9btyqVtbV+eLf869IcmNr7XFJbpx9DgBdXR0Z0pBkSHtDjrQ3ZEh7Q440LDnSgGRIw5MjDU+ONJirI0NiRWk6WRKttd9N8ldj1zEVrbUjrbX3ze5/Lpu/2D5i3KpWW9t01+zT02YfbcSSJqGqHpnkBUlePXYtsJ2qemiSpye5Kklaa/e11j4zblWTc3GSP2mtfXTsQlbc/iQPrqr9Sc5McvvI9ay6xyf5/dbaPa21+5O8M8m3j1zTSjrJ7/kvSnLN7P41SV680KIAWGkypGHJkPaGHGl4MiRWgRxpz8mQhiNHGpYcaQAyJFaZphMmr6oeneRJSf73uJWsvtkIz5uT3JnkhtaaNT11P5vkh5McH7uQCWlJ3lpV762qg2MXMwFfmeQvkvzybITvq6vqIWMXNTHfleTXxy5ilbXW/jzJK5N8LMmRJP+vtfbWcataebckeXpVPbyqzkzy/CSPGrmmKTmvtXYk2fyPriTnjlwPABAZ0tDkSIOTIe0NOdKw5Eh7S4Y0ADnSnpAj7R0ZEitB0wmTVlUHkrw+yQ+01j47dj2rrrV2bDbG75FJnjwbmcYuVdW3JbmztfbesWuZmKe21r4uybdmcyzy08cuaMXtT/J1SX6htfakJHfHCL/BVNXpSS5J8j/HrmWVzfYyfVGSxyT5siQPqap/OG5Vq621dmuSn0hyQ5K3JPnDbI6eBwCYJBnS8ORIw5Eh7Sk50rDkSHtEhjQcOdLw5EiAphMmq6pOy2ZY8N9ba28Yu54pmY1EvCn2kD5VT01ySVX9WZLfSPKsqvq1cUtafa2122e3d2Zzf9Mnj1vRyvtEkk+ccEXa67IZHjCMb03yvtbaHWMXsuKeneT/ttb+orV2NMkbknzTyDWtvNbaVa21r2utPT2boz1vG7umCbmjqi5IktntnSPXAwBrTYa0t+RIg5Ah7RE50uDkSHtHhjQcOdIekCPtGRkSK0HTCZNUVZXNfSNvba39zNj1TEFVfWlVfcns/oOz+YvZH41b1Wprrf3b1tojW2uPzuZoxLe31nRUn4KqekhVnfXA/STfks3RfuxSa+2TST5eVV89e+jiJB8esaSp+fsxFnUIH0vylKo6c/Y7wMVJbh25ppVXVefObr88yXfE1+qQrkty6ez+pUmuHbEWAFhrMqS9IUcalgxpb8iRhidH2lMypOHIkfaAHGnPyJBYCfvHLoBNVf+/vXuNmqsqDzj+fyAJChKgIAheCAKieAELoohiIiDiFRBQa4EoFcSqReplKRX7Qau24q0WFMUGK14QC1ZBdAmJggjeUbmICkSRAKIi9wDJ0w97D+/J5My8M+8kmbzw/62117vPnOfss+fMzEr2s87ZO74AzAU2i4jrgHdn5inj7dW0tgdwKPCLunYswDsz85wx9mm62xI4NSLWpdywdnpmfn3MfZK6bQGcWcYKzAA+n5nnjrdLDwhvBE6r03heDbx6zP15QKjrm+4DHDXuvkx3mXlJRJwB/IQydedPgZPH26sHhK9ExKbAvcA/ZuZfxt2h6ajt//nA+4HTI+IISrLr4PH1UJI03ZhDWuXMIa0e5pE0HZhHWj3MI61i5pBWLfNIq415pBGZQ9J0Fpk57j5IkiRJkiRJkiRJkiRpmnF5HUmSJEmSJEmSJEmSJA3Nm04kSZIkSZIkSZIkSZI0NG86kSRJkiRJkiRJkiRJ0tC86USSJEmSJEmSJEmSJElD86YTSZIkSZIkSZIkSZIkDc2bTiTpQSQi5kdE1jJ/3P0ZRETMafR5wbj7Mw4RsaBxDeaMuz9ryoP1fUuSJEmSNG7mkKanB2su5cH6viVJWlt404kkSZIkSZIkSZIkSZKG5k0nkiRJkiRJkiRJkiRJGpo3nUiSpLVSZs7PzKjl2nH3R5IkSZIkSWsfc0iSJI2XN51IkiRJkiRJkiRJkiRpaN50IkmSJEmSJEmSJEmSpKF504kkPYBExIsi4msRcUNE3B0R10bEaRGx+xTamhURR0TE/0XE72t7t0TEzyPihIiYM0Abj4+It9Y2ro6IOyNiaUQsiYhzI+L1EfGQqbzXPufcPSJOiojLa3/vjojfRcSXIuKFkxw7NyKyln+tr+0QER+JiCsi4ta6b/4U+rVuRBxaP5/O9byr1n8SESdHxIERsf6A7e0bEWdFxHX1ml4fEV+OiKcPeHxExCERcUa9Ps3P90MRsX2fYz9dr8PyiHh4j5g3N67lHRExq0fcCY24Hbr2LWjsm9NybNvn9Zja5pX1vLdExEX1uzZjwGtzQEScHRE3Nn5Hn+tc24iY3zjv/EHalCRJkiRpbWIOyRySOSRzSJIkrSoD/cMpSVq7RcS6wCnA4V27tq7lFRHxDuCmAdvbFTgd2KZr13rAk2t5Q0S8KTM/2aONw4BTe5ziEbXsCxwbES/OzCsG6VufPm8AfBp4RcvuR9dySEScDbwyM28boM3DgE8ADx2xb5sB5wBPa9n9qFqeCrwWOAA4q09z60TEicDRXa9vCRwEHBgRR2bmKX36swVwJtCdSOr+fI/PzPe3NLEIOAIIYC7w5ZaYuY36+sDTgQv6xC3JzF/16vMgIuL5wBeAjbt27V7L/vW7trTH8TOB04CDu3Y1f0dvB/40Sj8lSZIkSRoXc0jmkDCHZA5JkqRVzJtOJOmB4WNMJAvuoQzULwSWA7tRBncfoP9AFChPeQDfpgzyAM4DvgH8HngIZeB1WN3/iYhYmpkLWppaH0jgx8B3gV8BfwFmUwZfLwceB2wLfCMids7MW4Z5040+r1f7/Iz60u8oA8fLgKXAdrXPOwAvBM6KiH0yc3mfZvcAjgOWUZIx3wPurm3cMGQXP8VEsuA3tW9XAXdRrscOwJ6UQfVk3gO8sh7/2drehsCBwH6UWcxOjIjvZeaV3QdHxIaUz+Nx9aUlwGco12p9YB/KgHkm8L6IWCcz/62rmYWN+jy6EgYRsU59P3TFXdAVtzGwc0ubU7Ez8FZKEuOTwPcpn/2uwOuADSjv7Tjg+B5tnMxEsuBuYEFtZ1lt5wjgg8AZI/ZVkiRJkqRxMYdkDskckjkkSZJWrcy0WCwWyzQuwLMpiYGkDMh3aYnZgTIwzEaZ3xK3IWWwncDtwH49zrkdsLgRt1lLzBOBbfr0ex3gLY3+vLtH3JxGzIIeMR9uxJwEzGqJmUlJpHTiXtcSM7frGi0Bdhzx89mcMuBM4IfABn1itwa2bnl9QVe/TgVmtMR9tBFzYo9znNSIuQDYqCXmeZRkRgL3Aju1xPy67r+iZd8ujXNcVP8ubIl7SSPutZO87zkDfF6Lge1b4nar7yOBPwPrtcTs1Wjnj8CTenwXr+0650q/I4vFYrFYLBaLxWKxWNbGgjkkMIfUiTOHZA7JYrFYLJZVVtZBkjTd/TPlznyAYzLzx90BWaac/IcB2notZQpRgKMz8xttQZn5G+DVdXMD4MiWmMsy85peJ8rM5Zn5QcoTEwCHDtC/lUTElsDr6+Z5mXl0Zt7Tcr57Kdfg6vrSsQM0f1RmXj6VfjU8Fu7/9/bzmXlHr8DMXJyZiydp70rK4Pq+ln3/QhnoQ5l2dgV17dzO53YrcHBm/rWlH98C3lU3Z1Ce/ui2sP59fP0MmubVvzcBJ9b67rHy2svzGvWFjO7vM/PX3S9m5g+AL9XNTSgJhG5vbtTfkJm/bGnnWmD+6N2UJEmSJGkszCGZQ+owh2QOSZKkVcabTiRpGqtTgu5XN28CPtcrNjPPBiZb87YzaF9CWZe0p8w8H7i+bj5v0s72dlH9u21dt3ZYhwCzav2EfoE1adAZOG4fEXP6hC8GvjaF/nS7s1F/4ipo76S2hAhAljWGf1Q3t2kZoL+QsuYuwKmZ2W+K1xOBzprFL61rPjctatTndu3rJAIWAufX+nqsvP5v57jrahJqFD/NzLb1fjvOb9R3bO6o16nzHV5C+/rCAGTmIuDnU+yjJEmSJEljYQ4JMId0P3NI5pAkSVqVZoy7A5KkkezExGB5UWYumyT+POAJbTsiYiPgKXVzCfCSiGgLbbq9/m1ts7a7N/AKynq0j6FMv9o9+Ox4JHDzZCft8uxGffOI2H+S+E0a9SdQprpsc2Fm5pB9aXMZJbGyFXBElIv6KeAH2X894F4unmT/H+rfADZmxbWDm09nfKtfI5l5Z0RcSElIPYwyyP5FI6T5VMk8yhrD1MTCszoxmXl9RFxFWf93Xue4iNiEie/bokne0yAGvS6w4ncAyu9oZq1/Z4DPZRETfZckSZIkaTowh2QOqZs5pHbmkCRJGpI3nUjS9LZVoz7IXf79Yh7NxAxYfwucOUQ/ugdgnQTE6Qz3BMvsIWI75jTqC4Y8dqV+N/yhz76BZeayiDgK+AolufOaWm6JiO8DFwLfbJvStofJEipLG/Xup1SaU5heNcC5rmLiKagtaSQMMnNJIxHw3MYxuzDxOS5s/O3EHV9few4T37dVMS3qKNel+Tu6mskNEiNJkiRJ0trEHJI5pG7mkNqZQ5IkaUguryNJ09vDGvU7e0ZN6LkWLLDRCP2Y2fLaGUwkC24DPg+8jTL96suAA2r5UuOYXk+v9DNKv2f12XdXn31DycyvU54QOQu4t768MWUw/l7gRxHxi4h4/gDNTeXJlo4NG/V+34WO2xv1DVv2dwb620ZEZx3nzrSo12fmVV1xu0XEBl1xzf2jGOW6bNCoj/o7kiRJkiRpbWQOyRzSMMwhtTOHJElSC2c6kaTprTmgW3+A+A367Gu2tSAzXz21LkFE7AnsPVJI0QAABy9JREFUXTcvBfbJzD/2iN1jquepOv2+D3hoZt43YnurRWZeChwQERsCewDPBPasf2cCTwLOiYhDM7PvWsgjuK1R7/dd6GgmpG5r2b8IOKrW5wGfZcW1eJtxUN7nHpRpWefW1xZn5jUD9GV1aiYARv0dSZIkSZK0NjKHZA5pGOaQ2plDkiSphTOdSNL0dn2jvt0A8f1imlOBPnFq3bnf3o36cb2SBdXWI56r0+8ZlOk312qZeVtmnpuZx2fmXMqUox+uuwP4UF3TdnVY0qhvP0B8M+b6lv2LGvV5ETGTxlq8nR2ZeSNwRSNuU+DJLW2MS/O9PXaA+EFiJEmSJElam5hDMoc0DHNI7cwhSZLUwptOJGl6uxS4p9afM8BA87m9dmTmzcDldXOXxlSXU7FFo/7bXkERMYuJpxWm6juN+gEjtrXGZeafMvNY4Ef1pc0ZbDA/FT9o1PfpFxgRD2Vi8H87EwP++2XmDcCVdXMe8DQmnuA4vyt8YSPuOZTkSPP1cbqUiSlr94yIyf5/NHf1dkeSJEmSpFXOHJI5pGGYQ2pnDkmSpBbedCJJ01hmLgXOqZtbAH/XKzYi9gN2nKTJU+vfdYD3jdC15pqm2/aJOxp4+AjnAfgiE0mTN0fEI0Zsb1yubdRX1/J3ZwNLa/3wiNi8T+zRwOxaPyszl/WI6wz4twZeU+tt05124nYFXtJ4fdFknV7dMvNuynStAFsBB/eKjYi5wFPWQLckSZIkSVplzCEB5pCGYQ6phTkkSZLaedOJJE1/JzTqH42InbsDImJ74JQB2vovYHGtvyoiPlyfJGkVEbMj4k0RsXfXrh826sdHxHotx74YeP8AfeorM38P/Gfd3BT4ZkT0nAI2ir0i4rhRzz2IiNg3Iv4pIjbqE7MdE0+N3E6fJ3tGUaeo/Uzd3Bg4PSJmd8dFxF7Ae+rmfcAH+zS7qFE/vP5te/JkEZDAusCr6mvXZObilthx+Eij/vGIeFJ3QETMARasof5IkiRJkrSqmUMyhzQQc0h9mUOSJKnL6roLVpK0hmTmhRFxIvB6YBPg4og4FbgQWA7sBhxBmbLyLGD/Pm3dERH7U6YbnQ0cAxwSEacDPwduBTYEtqntzgPWAw7taupMyjq5j6xxl0fEKcDVlIHqC4AXU55m+V/gwNGuAu8Adgb2ojxBcHlEfBX4LnADMJPyFM9OlIH5VsB5wHtHPO8gtqQMRv89IhYCl1Cuw53AZpTpRA9hYkrRj2TmXauxP2+nXKfHUaYovTwiPkOZFnd9ylrKL2fixtR3Z+alfdpb1Kh3/l+xUsIgM2+OiF9S1uHtGTcumfntiFgAzKd8Lj+s2xdRfke7Up7CmQ2cARxUD12+pvsqSZIkSdJUmEMCzCENwxxSC3NIkiStzJtOJOmB4U3Aw4DDKAP4I2vpWA68DfgjfRIGAJn5s4jYDfgC8FTK4PqYPocsBW7uauOuiDiIMm3rJsBjWXlwfgvlaYXdGDFhkJn3RsQLKE/sHE1JEBzExKCuzR9GOecQOgPKWcC+tbRJ4GPAu1dnZzLztojYk5I8egYlqfOultD7gOMzs+8UuZl5U0RczorT7vZKBCykJAwmixuXIym/o4OAhwCvq6VjOfAW4K9MfLduW5MdlCRJkiRpROaQzCENxBxSX+aQJElqcHkdSXoAyMxlmXk45cmPsymJgaXA7ygD/2dl5n8M0d6vgF2Al1LW6L2K8oTKMspA/1Lgs5Q7+rfMzHNb2riY8lTIxylTfd5DGWj9EvgAsFNmntN93FRl5j2Z+Ubg8ZQpVy+hXIf7KE+EXENJYLwTeEq9XmvC/1Cuw7HAV4HfAHdQruVfgZ9RrtEumXlMZq72px4y80bgmZSnUc4ErqN8X24FLqM8VbPjZMmChubA/7d1utrJ4mAtWIu3KTPvzcyDgZcB57Li7+g0YI/MPIEyBW/Hn9d4RyVJkiRJmiJzSOaQhmEOqZ05JEmSVhSZOe4+SJIkTRsR8RUmnqzaNDNNGkiSJEmSJGkF5pAkSQ8WznQiSZI0oIiYA7yobl5qskCSJEmSJEndzCFJkh5MvOlEkiQJiIhtI+JRffY/kjKV7Kz60ifXSMckSZIkSZK01jCHJEnSimaMuwOSJElrid2B/46I7wIXUNaRvouy/u4zgEOA9WvsxcDJ4+ikJEmSJEmSxsockiRJDd50IkmSNGEG8NxaelkEvCwzl62RHkmSJEmSJGltYw5JkqQqMnPcfZAkSRq7iJhNWWv3+cBTgc2AvwHuAW4ELgG+mJlfG1snJUmSJEmSNFbmkCRJWpE3nUiSJEmSJEmSJEmSJGlo64y7A5IkSZIkSZIkSZIkSZp+vOlEkiRJkiRJkiRJkiRJQ/OmE0mSJEmSJEmSJEmSJA3Nm04kSZIkSZIkSZIkSZI0NG86kSRJkiRJkiRJkiRJ0tC86USSJEmSJEmSJEmSJElD+39VgzCBePyccwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 2880x2160 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure_5_1()\n",
    "# 没有试探性出发\n",
    "# 使用同轨策略\n",
    "# 不仅仅评估价值，有控制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-18T04:29:04.074682Z",
     "start_time": "2020-01-18T04:28:41.734499Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████| 500000/500000 [00:21<00:00, 23505.03it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2880x2160 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure_5_2()\n",
    "# 试探性出发\n",
    "# 书 P99\n",
    "# 对策略有控制，即尝试逼近 $\\pi_*$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-18T04:29:19.034523Z",
     "start_time": "2020-01-18T04:29:04.076674Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████| 100/100 [00:14<00:00,  7.16it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure_5_3()\n",
    "# 对二十一点游戏分布进行离轨策略，没有控制：\n",
    "#     - 普通重要度采样\n",
    "#     - 加权重要度采样\n",
    "# （因为这个问题中，每幕的回报为 0 / 1 ，因此更新公式看起来有些奇怪 \\\n",
    "#     且 离轨观测序列 b 策略服从二项分布）\n",
    "# 最后比较二者（两个采样率下 价值 的均方误差）\n",
    "# （我对于均方误差的更新公式存疑，需要进行数学推导）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 5.5: Infinite Variance\n",
    "\n",
    "The estimates of ordinary importance sampling will typically have infinite variance, and thus unsatisfactory convergence properties, whenever the scaled returns have infinite variance—and this can easily happen in o↵-policy learning when trajectories contain loops. A simple example is shown inset in Figure 5.4. There is only one nonterminal state s and two actions, right and left. The right action causes a deterministic transition to termination, whereas the left action transitions, with probability 0.9, back to s or, with probability 0.1, on to termination. The rewards are +1 on the latter transition and otherwise zero. Consider the target policy that always selects left. All episodes under this policy consist of some number (possibly zero) of transitions back to s followed by termination with a reward and return of +1. Thus the value of s under the target policy is 1 ($\\gamma = 1$). Suppose we are estimating this value from o↵-policy data using the behavior policy that selects right and left with equal probability.\n",
    "\n",
    "![](images/04-03.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-18T04:45:52.184311Z",
     "start_time": "2020-01-18T04:45:52.173302Z"
    }
   },
   "outputs": [],
   "source": [
    "#######################################################################\n",
    "# Copyright (C)                                                       #\n",
    "# 2016-2018 Shangtong Zhang(zhangshangtong.cpp@gmail.com)             #\n",
    "# 2016 Kenta Shimada(hyperkentakun@gmail.com)                         #\n",
    "# Permission given to modify the code as long as you keep this        #\n",
    "# declaration at the top                                              #\n",
    "#######################################################################\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "ACTION_BACK = 0\n",
    "ACTION_END = 1\n",
    "\n",
    "# behavior policy\n",
    "def behavior_policy():\n",
    "    return np.random.binomial(1, 0.5)\n",
    "\n",
    "# target policy\n",
    "def target_policy():\n",
    "    return ACTION_BACK\n",
    "\n",
    "# one turn\n",
    "def play():\n",
    "    # track the action for importance ratio\n",
    "    trajectory = []\n",
    "    while True:\n",
    "        action = behavior_policy()\n",
    "        trajectory.append(action)\n",
    "        if action == ACTION_END:\n",
    "            return 0, trajectory\n",
    "        if np.random.binomial(1, 0.9) == 0:\n",
    "            return 1, trajectory\n",
    "\n",
    "def figure_5_4():\n",
    "    runs = 10\n",
    "    episodes = 100000\n",
    "    for run in range(runs):\n",
    "        rewards = []\n",
    "        for episode in range(0, episodes):\n",
    "            reward, trajectory = play()\n",
    "            if trajectory[-1] == ACTION_END:\n",
    "                rho = 0\n",
    "            else:\n",
    "                rho = 1.0 / pow(0.5, len(trajectory))\n",
    "            rewards.append(rho * reward)\n",
    "        rewards = np.add.accumulate(rewards)\n",
    "        estimations = np.asarray(rewards) / np.arange(1, episodes + 1)\n",
    "        plt.plot(estimations)\n",
    "    plt.xlabel('Episodes (log scale)')\n",
    "    plt.ylabel('Ordinary Importance Sampling')\n",
    "    plt.xscale('log')\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-18T04:46:16.388243Z",
     "start_time": "2020-01-18T04:46:10.851909Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure_5_4()\n",
    "# 基于普通重要度采样的“首次访问型”MC算法的10次独立运行结果，\n",
    "# 预测值不收敛到正确的1\n",
    "# 存疑：这个应该不是“首次访问型”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}