blackjack1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BlackjackEnv:\n",
    "    def __init__(self):\n",
    "        self.n_decks = 6\n",
    "        self.deck = self.initialize_deck()\n",
    "        self.min_cards_left = int(0.25 * len(self.deck))\n",
    "        self.intermediate_count = 0\n",
    "        self.true_count = 0\n",
    "        self.tc_cap = 3\n",
    "        self.player_hand = []\n",
    "        self.dealer_hand = []\n",
    "        self.done = False\n",
    "\n",
    "    def initialize_deck(self):\n",
    "        self.deck = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10] * 4 * self.n_decks\n",
    "        random.shuffle(self.deck)\n",
    "        return deque(self.deck)\n",
    "\n",
    "    def draw_card(self):\n",
    "        if len(self.deck) <= self.min_cards_left:\n",
    "            self.deck = self.initialize_deck()\n",
    "            self.intermediate_count = 0\n",
    "            self.true_count = 0\n",
    "        card = self.deck.popleft()\n",
    "        self.update_count(card)\n",
    "        return card\n",
    "\n",
    "    def update_count(self, card):\n",
    "        if card in [2, 3, 4, 5, 6]:\n",
    "            self.intermediate_count += 1\n",
    "        elif card in [10, 1]:\n",
    "            self.intermediate_count -= 1\n",
    "        remaining_decks = len(self.deck) / 52\n",
    "        self.true_count = np.clip(\n",
    "            round(self.intermediate_count / remaining_decks), -self.tc_cap, self.tc_cap\n",
    "        )\n",
    "\n",
    "    def has_usable_ace(self, hand=None):\n",
    "        hand = hand or self.player_hand\n",
    "        return int(1 in hand and sum(hand) <= 11)\n",
    "\n",
    "    def calculate_hand(self, hand=None):\n",
    "        hand = hand or self.player_hand\n",
    "        total = sum(hand)\n",
    "        if 1 in hand and total <= 11:\n",
    "            total += 10   # can be done at most once; 2 Aces leads to 22\n",
    "        return total\n",
    "\n",
    "    def reset(self):\n",
    "        if len(self.deck) <= 0.25 * 52 * self.n_decks:\n",
    "            self.deck = self.initialize_deck()\n",
    "            self.intermediate_count = 0\n",
    "            self.true_count = 0\n",
    "\n",
    "        self.original_tc = deepcopy(self.true_count)\n",
    "        self.player_hand = [self.draw_card(), self.draw_card()]\n",
    "        self.dealer_hand = [self.draw_card()]\n",
    "        self.done = False\n",
    "        player_total = self.calculate_hand(self.player_hand)\n",
    "        dealer_visible_card = self.dealer_hand[0]\n",
    "        return player_total, dealer_visible_card, self.has_usable_ace(), self.original_tc\n",
    "\n",
    "    def get_state(self):\n",
    "        player_total = self.calculate_hand(self.player_hand)\n",
    "        dealer_visible_card = self.dealer_hand[0]\n",
    "        return player_total, dealer_visible_card, self.has_usable_ace(), self.true_count\n",
    "\n",
    "    def step(self, action):\n",
    "        if action == 0:   # hit\n",
    "            self.player_hand.append(self.draw_card())\n",
    "            player_total = self.calculate_hand(self.player_hand)\n",
    "            if player_total > 21:\n",
    "                self.done = True\n",
    "                return self.get_state(), -1, self.done   # Bust\n",
    "            return self.get_state(), 0, self.done        # Continue\n",
    "\n",
    "        elif action == 1:   # stand\n",
    "            self.dealer_hand.append(self.draw_card())\n",
    "            dealer_blackjack = self.calculate_hand(self.dealer_hand) == 21 and len(self.dealer_hand) == 2\n",
    "            player_blackjack = self.calculate_hand(self.player_hand) == 21 and len(self.player_hand) == 2\n",
    "\n",
    "            if dealer_blackjack:\n",
    "                if player_blackjack:\n",
    "                    reward = 0    # Tie\n",
    "                else:\n",
    "                    reward = -1   # Dealer blackjack, player loses\n",
    "                self.done = True\n",
    "                return self.get_state(), reward, self.done\n",
    "\n",
    "            if player_blackjack:  # entered here means Dealer no blackjack\n",
    "                reward = 1.5      # Blackjack win\n",
    "                self.done = True\n",
    "                return self.get_state(), reward, self.done\n",
    "\n",
    "            # Dealer turn\n",
    "            while (self.calculate_hand(self.dealer_hand) < 17) or (self.calculate_hand(self.dealer_hand) == 17 and self.has_usable_ace(self.dealer_hand)):\n",
    "                self.dealer_hand.append(self.draw_card())\n",
    "\n",
    "            dealer_total = self.calculate_hand(self.dealer_hand)\n",
    "            player_total = self.calculate_hand(self.player_hand)\n",
    "\n",
    "            if dealer_total > 21 or player_total > dealer_total:\n",
    "                reward = 1  # Win\n",
    "            elif player_total == dealer_total:\n",
    "                reward = 0   # Tie\n",
    "            else:\n",
    "                reward = -1  # Loss\n",
    "\n",
    "            self.done = True\n",
    "            return self.get_state(), reward, self.done\n",
    "\n",
    "        elif action == 2:   # surrender\n",
    "            self.done = True\n",
    "            if len(self.player_hand) == 2:\n",
    "                return self.get_state(), -0.5, self.done   # Lose half the bet\n",
    "            else:\n",
    "                raise ValueError(\"Surrender is only allowed on the first turn.\")\n",
    "\n",
    "        elif action == 3:   # double down\n",
    "            if len(self.player_hand) > 2:\n",
    "                raise ValueError(\"Double down can only be used on the first two cards.\")\n",
    "\n",
    "            self.player_hand.append(self.draw_card())   # must draw exactly one card\n",
    "            player_total = self.calculate_hand(self.player_hand)\n",
    "            self.done = True\n",
    "            if player_total > 21:\n",
    "                return self.get_state(), -2, self.done  # Bust\n",
    "\n",
    "            # Dealer's turn after double down\n",
    "            while (self.calculate_hand(self.dealer_hand) < 17) or (self.calculate_hand(self.dealer_hand) == 17 and self.has_usable_ace(self.dealer_hand)):\n",
    "                self.dealer_hand.append(self.draw_card())\n",
    "\n",
    "            dealer_total = self.calculate_hand(self.dealer_hand)\n",
    "            if dealer_total > 21 or player_total > dealer_total:\n",
    "                reward = 2\n",
    "            elif player_total == dealer_total:\n",
    "                reward = 0\n",
    "            else:\n",
    "                reward = -2\n",
    "\n",
    "            return self.get_state(), reward, self.done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "from matplotlib.patches import Patch\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "from collections import deque\n",
    "from copy import deepcopy\n",
    "from tqdm import tqdm\n",
    "from time import sleep\n",
    "\n",
    "class Agent:\n",
    "    def __init__(self, env, gamma=0.99, max_learning_rate=0.9, max_epsilon=0.9):\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "        self.max_learning_rate = max_learning_rate\n",
    "        self.learning_rate = max_learning_rate\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.epsilon = max_epsilon\n",
    "        self.Q = np.zeros((22, 11, 2, 7, 4))\n",
    "        self.visits = {}\n",
    "        # ignore index 0 for player hand and dealer card, so it is easier to see in code\n",
    "        # {0:hit, 1:stand, 2:surrender, 3:doubledown}\n",
    "\n",
    "    def choose_action(self, state, deterministic=False):\n",
    "        player_total, dealer_card, usable_ace, truecount = state\n",
    "        original_tc = env.original_tc\n",
    "\n",
    "        if deterministic:\n",
    "            q_values = self.Q[player_total, dealer_card, usable_ace, truecount+self.env.tc_cap, :]\n",
    "            action = np.argmax(q_values)\n",
    "            if action == 2 and len(self.env.player_hand) > 2:\n",
    "                action = 1   # stand if cannot surrender\n",
    "            if action == 3 and len(self.env.player_hand) > 2:\n",
    "                action = 0   # hit if cannot doubledown\n",
    "            return action\n",
    "\n",
    "        else:\n",
    "            epsilon = 1 / (\n",
    "                min(self.visits.get((state,0), 1), self.visits.get((state,1), 1))\n",
    "            )**0.5\n",
    "            # explore with probability self.epsilon\n",
    "            if random.uniform(0, 1) < self.epsilon:\n",
    "                if len(self.env.player_hand) == 2:\n",
    "                    return random.choice([0, 1, 2, 3])\n",
    "                else:\n",
    "                    return random.choice([0, 1])\n",
    "            else:\n",
    "                q_values = self.Q[player_total, dealer_card, usable_ace, truecount+self.env.tc_cap, :]\n",
    "                #return np.argmax(q_values)\n",
    "                action = np.argmax(q_values)\n",
    "                if action == 2 and len(self.env.player_hand) > 2:\n",
    "                    action = 1   # stand if cannot surrender\n",
    "                if action == 3 and len(self.env.player_hand) > 2:\n",
    "                    action = 0   # hit if cannot doubledown\n",
    "                return action\n",
    "\n",
    "    def update_q_value(self, state, action, reward, next_state, done):\n",
    "        player_total, dealer_card, usable_ace, truecount = state\n",
    "\n",
    "        if done:\n",
    "            target = reward\n",
    "        else:\n",
    "            next_player_total, next_dealer_card, next_usable_ace, next_truecount = next_state\n",
    "            best_next_action = np.argmax(\n",
    "                self.Q[next_player_total, next_dealer_card, next_usable_ace, next_truecount+self.env.tc_cap, :]\n",
    "            )\n",
    "            target = reward + self.gamma * self.Q[next_player_total, next_dealer_card, next_usable_ace, next_truecount+self.env.tc_cap, best_next_action]\n",
    "\n",
    "        self.visits[(state, action)] = self.visits.get((state, action), 0) + 1\n",
    "        lr = self.max_learning_rate/(self.visits[(state, action)])**0.5\n",
    "\n",
    "        self.Q[player_total, dealer_card, usable_ace, truecount+self.env.tc_cap, action] += lr * (\n",
    "            target\n",
    "            - self.Q[player_total, dealer_card, usable_ace, truecount+self.env.tc_cap, action]\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(agent, training_episodes):\n",
    "    for episode in tqdm(range(training_episodes)):\n",
    "        state = agent.env.reset()\n",
    "        done = False\n",
    "\n",
    "        while not done:\n",
    "            action = agent.choose_action(state)\n",
    "            next_state, reward, done = agent.env.step(action)\n",
    "            agent.update_q_value(state, action, reward, next_state, done)\n",
    "            state = next_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(agent, episodes=1000000):\n",
    "    reward_history = dict((tc,[]) for tc in range(-agent.env.tc_cap, agent.env.tc_cap+1))\n",
    "    \n",
    "    for episode in tqdm(range(episodes)):\n",
    "        state = agent.env.reset()\n",
    "        done = False\n",
    "        player_total, dealer_visible_card, usable_ace, true_count = state\n",
    "        \n",
    "        while not done:\n",
    "            action = agent.choose_action(state, deterministic=True)\n",
    "            next_state, reward, done = agent.env.step(action)\n",
    "            state = next_state\n",
    "\n",
    "        reward_history[true_count].append(reward)\n",
    "    \n",
    "    total_sum = 0\n",
    "    total_count = 0\n",
    "    sleep(2)\n",
    "    for tc, sublist in reward_history.items():\n",
    "        print(\"TC: %s -> %.4f over %d episodes\" % (tc, np.mean(sublist), len(sublist)))\n",
    "        total_sum += sum(sublist)\n",
    "        total_count += len(sublist)\n",
    "    print(total_sum/total_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000000/1000000 [00:20<00:00, 48476.52it/s]\n",
      "100%|██████████| 1000000/1000000 [00:20<00:00, 49613.06it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TC: -3 -> -0.0803 over 117464 episodes\n",
      "TC: -2 -> -0.0468 over 90374 episodes\n",
      "TC: -1 -> -0.0358 over 171013 episodes\n",
      "TC: 0 -> -0.0311 over 257056 episodes\n",
      "TC: 1 -> -0.0297 over 160057 episodes\n",
      "TC: 2 -> -0.0415 over 90012 episodes\n",
      "TC: 3 -> -0.0180 over 114024 episodes\n",
      "-0.0383\n"
     ]
    }
   ],
   "source": [
    "training_episodes = int(1e6)\n",
    "env = BlackjackEnv()\n",
    "agent = Agent(env)\n",
    "train(agent, training_episodes)\n",
    "test(agent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9000000/9000000 [02:46<00:00, 54147.50it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def continue_train(agent, training_episodes):\n",
    "    initial_Q = deepcopy(agent.Q)\n",
    "\n",
    "    for episode in tqdm(range(training_episodes)):\n",
    "        state = agent.env.reset()\n",
    "        done = False\n",
    "\n",
    "        while not done:\n",
    "            action = agent.choose_action(state)\n",
    "            next_state, reward, done = agent.env.step(action)\n",
    "            agent.update_q_value(state, action, reward, next_state, done)\n",
    "            state = next_state\n",
    "    \n",
    "    final_Q = deepcopy(agent.Q)\n",
    "    diff = final_Q - initial_Q\n",
    "    plt.figure(figsize=(8,3))\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.hist(\n",
    "        diff.flatten(), np.arange(-2, 2.1, 0.1), log=True\n",
    "    )\n",
    "    plt.title(\"Difference in Q (mean abs diff %.2f)\" % np.mean(np.abs(diff)))\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.hist(agent.visits.values(), log=True)\n",
    "    plt.title(\"Cummulate visits for each state-action\")\n",
    "    plt.show()\n",
    "\n",
    "continue_train(agent, training_episodes=int(9e6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5000000/5000000 [01:36<00:00, 52083.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TC: -3 -> -0.0451 over 587477 episodes\n",
      "TC: -2 -> -0.0335 over 459157 episodes\n",
      "TC: -1 -> -0.0237 over 855065 episodes\n",
      "TC: 0 -> -0.0256 over 1278180 episodes\n",
      "TC: 1 -> -0.0172 over 817127 episodes\n",
      "TC: 2 -> -0.0135 over 443406 episodes\n",
      "TC: 3 -> 0.0242 over 559588 episodes\n",
      "-0.0202875\n"
     ]
    }
   ],
   "source": [
    "reward_history = dict((tc,[]) for tc in range(-agent.env.tc_cap, agent.env.tc_cap+1))\n",
    "\n",
    "for episode in tqdm(range(5000000)):\n",
    "    state = agent.env.reset()\n",
    "    done = False\n",
    "    player_total, dealer_visible_card, usable_ace, true_count = state\n",
    "    while not done:\n",
    "        action = agent.choose_action(state, deterministic=True)\n",
    "        next_state, reward, done = agent.env.step(action)\n",
    "        state = next_state\n",
    "    if true_count >= 3:\n",
    "        reward_history[true_count].append(10*reward)\n",
    "    else:\n",
    "        reward_history[true_count].append(reward)\n",
    "total_sum = 0\n",
    "total_count = 0\n",
    "sleep(2)\n",
    "for tc, sublist in reward_history.items():\n",
    "    print(\"TC: %s -> %.4f over %d episodes\" % (tc, np.mean(sublist), len(sublist)))\n",
    "    total_sum += sum(sublist)\n",
    "    total_count += len(sublist)\n",
    "print(total_sum/total_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "vmin = np.min(agent.Q[1:, 1:, :, :, :2])\n",
    "vmax = np.max(agent.Q[1:, 1:, :, :, :2])\n",
    "useable_ace = 0\n",
    "\n",
    "policy_cmap = mcolors.ListedColormap(['blue', 'green', 'red', 'purple'])\n",
    "policy_bounds = [0, 1, 2, 3, 4]\n",
    "policy_norm = mcolors.BoundaryNorm(policy_bounds, policy_cmap.N)\n",
    "q_cmap = 'viridis'\n",
    "\n",
    "for tc, tc_index in zip([-3, 0, 3], [0, 3, 6]):\n",
    "    fig, axes = plt.subplots(\n",
    "        1, 3, figsize=(15, 5), gridspec_kw={'width_ratios': [1.2, 1, 1]}\n",
    "    )\n",
    "    fig.suptitle('True Count %d' % tc, fontsize=16)\n",
    "    \n",
    "    # First column for 'Hit' action\n",
    "    im1 = axes[0].imshow(\n",
    "        agent.Q[1:, 1:, useable_ace, tc_index, 0], \n",
    "        cmap=q_cmap, aspect='auto', vmin=vmin, vmax=vmax, origin='lower'\n",
    "    )\n",
    "    axes[0].set_title('Q_hit')\n",
    "    axes[0].set_xlabel('Dealer Card')\n",
    "    axes[0].set_xticks(range(0, 10))\n",
    "    axes[0].set_xticklabels(range(1, 11))\n",
    "    axes[0].set_yticks(range(0, 21))\n",
    "    \n",
    "    # Second column for 'Stand' action\n",
    "    im2 = axes[1].imshow(\n",
    "        agent.Q[1:, 1:, useable_ace, tc_index, 1], \n",
    "        cmap=q_cmap, aspect='auto', vmin=vmin, vmax=vmax, origin='lower'\n",
    "    )\n",
    "    axes[1].set_title('Q_stand')\n",
    "    axes[1].set_xlabel('Dealer Card')\n",
    "    axes[1].set_ylabel('Player Total')\n",
    "    axes[1].set_xticks(range(0, 10))\n",
    "    axes[1].set_xticklabels(range(1, 11))\n",
    "    axes[1].set_yticks(range(0, 21))\n",
    "    axes[1].set_yticklabels(range(1, 22))\n",
    "    \n",
    "    # Third column for policy\n",
    "    im3 = axes[2].imshow(\n",
    "        np.argmax(agent.Q[1:, 1:, useable_ace, tc_index, :], axis=-1), \n",
    "        cmap=policy_cmap, norm=policy_norm, aspect='auto', origin='lower'\n",
    "    )\n",
    "    axes[2].set_title('Policy')\n",
    "    axes[2].set_xlabel('Dealer Card')\n",
    "    axes[2].set_ylabel('Player Total')\n",
    "    axes[2].set_xticks(range(0, 10))\n",
    "    axes[2].set_xticklabels(range(1, 11))\n",
    "    axes[2].set_yticks(range(0, 21))\n",
    "    axes[2].set_yticklabels(range(1, 22))\n",
    "    \n",
    "    cbar = fig.colorbar(\n",
    "        im1, cax=make_axes_locatable(axes[0]).append_axes(\"left\", size=\"4%\", pad=0.5)\n",
    "    )\n",
    "    cbar.ax.yaxis.set_ticks_position('left')\n",
    "    cbar.ax.yaxis.set_label_position('left')\n",
    "\n",
    "    legend_elements = [\n",
    "        Patch(facecolor='blue', edgecolor='w', label='Hit'),\n",
    "        Patch(facecolor='green', edgecolor='w', label='Stand'),\n",
    "        Patch(facecolor='red', edgecolor='w', label='Surrender'),\n",
    "        Patch(facecolor='purple', edgecolor='w', label='Double Down')\n",
    "    ]\n",
    "    axes[2].legend(handles=legend_elements, loc='right', bbox_to_anchor=(1.25, 1))\n",
    "    \n",
    "    # To add white grid lines between cells\n",
    "    for ax in axes:\n",
    "        ax.set_xticks(np.arange(-.5, 10, 1), minor=True)\n",
    "        ax.set_yticks(np.arange(-.5, 21, 1), minor=True)\n",
    "        ax.grid(which='minor', color='white', linestyle='-', linewidth=1)\n",
    "        ax.tick_params(which='minor', bottom=False, left=False)\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5000000/5000000 [01:49<00:00, 45616.89it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAr4AAAG7CAYAAAAlopZbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABqYklEQVR4nO3de1yO9/8H8NfdWaViUQ6RYc6SJH0NITJDzdkcyswwDJk5C9uYMWNjcxbbzPk0ZyKHHEIip5jVNJRzETrdn98fn193bt2lu9Nd3a/n43E/dH2uz3Vdn+vTfet9fe739bkUQggBIiIiIqISzkDXDSAiIiIiKgwMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhIL2gd+B47dgydO3dGxYoVoVAosH379rduExwcjMaNG8PU1BQ1atRAYGBgLppKRERERJR7Wge+iYmJcHJywuLFi3NUPyoqCh9++CFat26N8PBwjB49Gp9++in279+vdWOJiIiIiHJLIYQQud5YocC2bdvg4+OTZZ3x48dj9+7duHz5sqqsd+/eePr0Kfbt25fbQxMRERERacWooA9w6tQpeHp6qpV5eXlh9OjRWW6TlJSEpKQk1bJSqcTjx4/xzjvvQKFQFFRTiYiIKB8JIfDs2TNUrFgRBga8rYh0r8AD39jYWNjZ2amV2dnZISEhAS9fvkSpUqUybTN79mzMmDGjoJtGREREhSAmJgaVK1fWdTOICj7wzY2JEyfC399ftRwfH48qVaogJiYGVlZW+Xqs2daz83V/RcHE+Im52o59IbEfJPZDBvaFxH6Q2A85l5CQAAcHB5QuXbpA9k+krQIPfO3t7REXF6dWFhcXBysrK42jvQBgamoKU1PTTOVWVlb5HviawSxf91cU5LaP2BcS+0FiP2RgX0jsB4n9oD2mKVJRUeAJN+7u7ggKClIrO3jwINzd3Qv60EREREREKloHvs+fP0d4eDjCw8MByOnKwsPDcfv2bQAyTWHAgAGq+kOHDsU///yDr776CtevX8cvv/yCjRs3YsyYMflzBkREREREOaB14Hvu3Dk4OzvD2dkZAODv7w9nZ2dMmzYNAHDv3j1VEAwA1apVw+7du3Hw4EE4OTnhhx9+wIoVK+Dl5ZVPp0BERERE9HZa5/h6eHggu6l/NT2VzcPDAxcuXND2UEXaqKhRSE1KRerLVADAidkncGXjFfVKCqDd9+1Qo0MNGBgZICYkBruG7YIyRQkbRxt0W98NJpYmiPgjAidmnwAA2Na2heccT6z3Xl/Yp5Rr7Aspp/3Qfl571OhQA8pUJV48eoG/Bv+FJ7eelJh+IHpTTj4bjfwawW2Um2rZqrIV/j32LzZ228jPhh5SKpVITk7WdTOomDA2NoahoWGO6hbJWR2Ki829NiPuYlyW6xsPaowKjStgaeOlUKYo0XlZZzQb1Qwn552E63BXnF18FhF/RODzq58j9OdQJD9PhtcCL+weursQzyJ/sC+kt/VDrS614NDcAUuclkCZqkSLyS3QdlZbbO61uUT1A9Gb3vbZCA8MR3hguGp5WMQwRPwRAQAl5rNhaGKI9j+0R3Wv6kh9lYq4i3HY1n9blvUHBA1AhcYVMKfMHADQmwuA5ORkREVFQalU6ropVIzY2NjA3t7+rTdSMvAtQHZOdvjn0D9QpsgP7829N+Ex3QMn552EMkUJY3NjGBgbQGGggFAKNBnaBP8c+AdPo5/qtuEFgH3x/wRgZGoEIzMjJD9PhqmVKRL+SwCAEtMPOfrjricj3znpC450ZlapaSVYlLdA5M5IACXns+H5nScggEXvLQIAWNhZZFm32ZhmeHLrCSo0rqAqKykXANkRQuDevXswNDSEg4MDH3pBbyWEwIsXL3D//n0AQIUKFbKtz8A3Dz5a+xGgAO6G3sWhCYfw4uELtfX3zt+DyxAXhC4KRerLVNTrWQ82jjYAgDM/nYF3oDdchrjg1LxTMLU2RZ3udfB7+991cCZ5x76Q3tYPkX9FwrG1I8bGjkXys2Qk3ElAYKtAACWnH3Lyx11fRr5z0hf6MNIJvP2z8TrnQc649NslKFPlhXJJ+GwYmxvDeZAz5leerypLjEvUWLdc3XKo7VMbOwbuQN0edVXlJeUCIDupqal48eIFKlasCHNzc103h4qJ9Olx79+/j/Lly2eb9sDAN5dWt1yNhJgEGBgZoM03beCzxgfrPlynVic8MBzWVa3hd9QPqS9T8c+hf1C9fXUAwPPY5/ijwx+qut03dseBsQfg2NoRTYY1QVpSGoImBiH+dnyhnldusC+knPRDxSYVUb5+ecyvNB9JCUnw/M4TnZZ0wrb+20pEP+T4j7sejHxrE+ikK6kjnTn5bKQzNjdG/d71saLZClVZSfhslKleBi8fv0SLSS3wrue7SHmZgqPTjyLqcJRaPQMjA3Re3hk7B+2EMk39q/6ScAHwNmlpaQAAExMTHbeEipv0C6WUlJRsA19+h5BLCTH//0c6VYnTC06jSosqGusdnXEUyxovw6rmq/Dg6gPcv3I/U506Xevgya0niLsYhw9+/gA7/HYgbHkYPGZ6FOQp5Bv2hZSTfnAa4ISow1FIik8CBHBxzUU4tnbMVK+49sPrf9wHnx0Mv2N+qNamWqZ6kX9FIjo4GmNjx2LsvbGo1rYajkw7AkD+ca/9UW0MOjVI7Y/76QWnC/t08iSnffE6TSOdJaEvcvp/BADU7VEX96/cx8NrDzWuL66fDQMjA9g42uDB1QdY7roc+77Yh+4busOivPq3AK0CWuHa1mt4eD3z+adfACxrvAznl51Hh4UdVBcAPTb3QNc/usK6inVhnVKB4gMvSFs5fc9wxDcX0kdgkuKTAAD1+9RH7IXYTPUMTQ1hXMoYr56+Qql3SuH9Ce/jyNQjanVMrU3hNsoNv3v9rtq3UAoIpYCJZdG/4mVfSDnthyf/PEHNjjVVuc3vdXoP9y+rXwAU5354/Y970MQg2DeyR/+D/fFLvV+QeD9jtLOkj3wDOe+LdCV1pDOnn410zoOccWGl5lmAivNnI/52PJRpSlUaS2x4LJ5EPUH5BuURFZQx6lu1VVVYV7FG0xFNYWBkAFMrU4yKGoXlrsvV0kNevwD4/OrnWNF0BSo2qQiPmR7Y4bej0M+PqLhg4JsLFnYW6LmlJwwMDQCFDGa2DZA3rHRe3hmROyNx468bMLM2g2+wL4RSQGGgwJmFZ3Bj1w21fbWb0w7B04OR+kpO83P8m+MYfG4w0pLTsHPQzkI/N22xL6Sc9sPZxWdRrk45DL04FMoUJZ7HPseuobvU9lWc+yGnf9zVRr4hR777HeiXaX/F+Y97TvsinTYjncWpL3L62QCAd957B/aN7LGuo+Y0iOL82Xj56CWigqJQ3as6/t77N2wcbVCmWplMv+/AloGqn62rWmNo+FAsrLZQrU5xvgAg7QUGBmL06NF4+vSprptSIjDwzYWnUU+xrPEyjev+GvyX6ufE+4n4pe4v2e7rzaAnbEUYwlaE5b2RhYR9IeW0H9KS0/DXZ39prJeuOPdDTv+4l/SRbyDnfZGupI505vSzAQCPbjzCd1bfZbmv4vzZAGT7u6zsAs85nhBKgV1DduHZ3WeZLgDepjhfAOiLU6dO4f3330eHDh2we3fOb0R1dHTE6NGjMXr0aFVZr1690LFjxwJopX5i4EtE+Sonf9xL+sh3upwGOiV5pJMyPI16irVt1mYqf/MCIF38v/GqOXxfV9wvAPTBypUrMXLkSKxcuRJ3795FxYoVc72vUqVKqWYtoLxj4EtE+Sonf9xL+sh3upwGOiV9pJNInzx//hwbNmzAuXPnEBsbi8DAQEyaNEm1/q+//sLMmTMREREBS0tLtGjRAtu2bYOHhwf+/fdfjBkzBmPGjAEg56jVlOrw66+/Yt68eYiJiUG1atUwZcoU9O/fX7VeoVBg+fLl2L17N/bv349KlSrhhx9+QJcuXQAAT548wYgRI3DgwAE8f/4clStXxqRJkzBw4MDC6SQd4qwORERERPlk48aNqF27NmrVqoV+/fph1apVEEIAAHbv3o2PPvoIHTt2xIULFxAUFISmTZsCALZu3YrKlStj5syZuHfvHu7du6dx/9u2bcOoUaMwduxYXL58GUOGDMHAgQNx5Ij6DeMzZsxAz549cenSJXTs2BF9+/bF48ePAQBTp07F1atXsXfvXly7dg2//vorbG1tC7BXig6O+BIRERHlk5UrV6JfP3mzbocOHRAfH4+jR4/Cw8MD3377LXr37o0ZM2ao6js5OQEAypYtC0NDQ5QuXRr29vZZ7n/evHnw8/PD559/DgDw9/fH6dOnMW/ePLRu3VpVz8/PD3369AEAzJo1Cz/99BNCQ0PRoUMH3L59G87OzmjSpAkAmVusLzjiS0RERJQPIiMjERoaqgo4jYyM0KtXL6xcuRIAEB4ejrZt2+bpGNeuXUPz5s3Vypo3b45r166plTVs2FD1s4WFBaysrFSP9R02bBjWr1+PRo0a4auvvsLJkyfz1KbihIEvERERUT5YuXIlUlNTUbFiRRgZGcHIyAi//vortmzZgvj4+EK9Sc3Y2FhtWaFQQKmUD8f54IMPVPnEd+/eRdu2bfHll18WWtt0iakORESUIwGYrusmFIAAXTeASojU1FSsXbsWP/zwA9q3b6+2zsfHB3/++ScaNmyIoKCgLG8iMzExUT22OSt16tRBSEgIfH19VWUhISGoW7euVu0tV64cfH194evrixYtWmDcuHGYN2+eVvsojvQ+8OV/5K9vNT1/m1EkaN8X7AciItLWrl278OTJEwwaNAjW1uqPju7WrRtWrlyJuXPnom3btqhevTp69+6N1NRU7NmzB+PHjwcgc22PHTuG3r17w9TUVOMNZ+PGjUPPnj3h7OwMT09P/PXXX9i6dSsOHTqU47ZOmzYNLi4uqFevHpKSkrBr1y7UqVMnbx1QTDDVgYiIiCiPVq5cCU9Pz0xBLyAD33PnzqFs2bLYtGkTdu7ciUaNGqFNmzYIDQ1V1Zs5cyaio6NRvXp1lCtXTuNxfHx8sHDhQsybNw/16tXD0qVLsXr1anh4eOS4rSYmJpg4cSIaNmyIli1bwtDQEOvXr9f6nIsjhUifY6MIS0hIgLW1NeLj42FlZZW/O1co8nd/RUFuf6XsC4n9AACYoZjx9krFTIDI3cg3++L/8bMhsR9yTNu/369evUJUVBSqVasGMzOzAmkTlUw5fe/ofaoDEWnGlI/Xt5qev80oEpj+QkT6h6kOlD/8/OSIgbe35vVffQVcuQJcuACcOgW4uspyGxvg8GHg0iVg8eKM+ra2wJEjgBGvzYiIiCh/MPClvKtaFRg8WAa0mjg5AZ9/DjRtCjg7A4sWyRcA9O0rA9yGDYHatYF69WT5/PnAhAlAamrhnEN+iIoCrl+Xwf2FC0DPnpnrNGuWsf7yZWDJEsDERK5zcZHlV64AAwZkbNO6taxHREREecLAN7dyEuQAQP36MrC7elW+PvpIlpeUIEehAFasAEaOBJKSNNcRAjA2Biws5LKNDfDff/LnlBTA3Fzux9QUSE4GvLyAJ0+AM2cK5RTyVa9eMrh3dgY2bsy8/uJFOdrt7Aw0aACULy8vCgAZ6H/xhVwf8P9fQ5uZAdOnA/9/xy8RERHlHr9HzotevWQgk5VSpYAdO2RgGxICGBgAZcvKdelBzvnzQEQEsHZtRpDTpUuhND9f+PvLcwsLy7rOpUvAjz/Ki4XHj2WA3LKlXPf778CaNfIiYPt24M4dYOVKoGPHQml+oXv5MuNnExP5Hkm/qST9IsDMDEifx3H6dGDhQiA+vtCbSkREVNIw8C1IH38MnD4tA0MAUCqBhw/lzyUhyKlXD+jWLSOIzYqjI9C1K1CjBnDvHjB8OLBhA9CiBfDiBdCjR0bd+fOBOXNk3UmTZNk338jguThYu1aOXoeGyoub9N/366pWlRdE1asDu3cDv/wiy2fOBJYulSPj48bJFJF335X7ISIiojxjqkNerF0rA7IVK+TNWG+qW1eObv71lxzRXLMmo97MmTKwO3BAPcjZurVwzyEvWrSQQe3Nm3I0t1kzYNkyYOhQ9XrduslR7Xv35PLq1cD778v0h9e5usqv/nfvBn76SfbLV1/Jn4uDli3l77FxYxnwrlmjud6//wKNGgH29jK9o2tXWX79OtCqFdCkiXzP/PADMGoU0Ls3sHkzsGqVTBMp6nKaBpQuKEimtqRzdJQXjJcvAxMnZpTXri0vGKh4KVs2471w4QIQGSkv/MuUyVz3yy/l/xVXrsj/C9PnQ+VNsESUX0QxEB8fLwCI+Pj4/N+5/KJZ+5eDg/zXyEiI774TYvfuzHUWLhTi9m0hKlaUy7NmCbFpU+Z6BgZCHDokRIUKQvTuLcTmzUKsWiWEjU3u2lbYfZH+OnJECG/vzOUffSTE5ctCWFjI5Z49hbh+Xb2OkZEQhw8LUb68XD5/XogqVeTr3Lnct0kX/QAIYW8vRELC2+v16iXEzp2Zy/39hRgyRIhSpYS4ckUIQ0Mh/PyEmD696PdDVJQQTk45qztmjBDLlgnx5ElG2dy5QvTvLz8X168LYWkpy/ftE8LRMW+/l9zKj/dEUXvpqh/GjtX8nvf0lO/19N/35MlCLFokfx4+XIipU+XPQUFC1Ksnf167Vgg3t+LZD0XtVUC0/fv98uVLcfXqVfHy5csCaxOVTDl973DEN7diYuS/qanAggVy9PNNt2/L0Yi7d+Xy77/LUdE3jR4NbNoEPH0KTJ0qc4ePHZPlxdWMGcCQIfLnbduAnTuBc+eA8HA5ivnxx+r1x42TI+j378vladOAPXvka+rUQm16rpibZ4xOAUCfPnJ0603Vq2eMThkby5sd30zjcHQE2rWTaQ/GxrK+EDJVxtKywE6h0NWtC/j4AN99p16engZkbCzz4pVK+S3CgQNAdLQuWkr5adAgmcf/Jicn4MQJ4PlzubxnD9C/v/y5JNwEm9OR76pV5d+V1+u++65cx29DiPKukALxPClyI77m5kJYW2csjxkjxNGjmes5OAhx9aoQpUvL5S+/FGLXLvU6jo5C7N0rf7ayEiIyUo50DRggxLx5hXvlrusRh6IyipGb41SrJkRYmBAXLwpx6ZIQ27cLUbWqXLd8uRCdO8ufBw8WIiJCiPBwOQq+cKEQpqbq+9qxQ4hatTKWAwLkSNiZM7kf8SzM90NUVEY/rFghhK1t5jpGRkKEhAhRu7bsp9dHfO3t5ehuWJgQn30mvwk5dEh+LnTxfshLXxTlly76wd1diHv35DcYb67z8BDi1i0h7Ozk8rx58phlysj/czdtkp+b6dPl8rFjGaPDxa0fgKxHvt/8PLz+KorfhrwFR3wzrF69WlhbW+u6GSVWTt87Bfduz0dFLvDNaZADCNGvnwx0Ll4UYs8eISpXVt9XUQlyctsXRf3Ffij8fshJGtDXX8s//ED2f+gBITZulKkTbdvKNKA//pApMIXVD7nti7JlhbhwIeMVGSlESooM5N6s++WX8v+JK1eE2Lo148LaxkamAF26JMTixRn1bW1lapGRUfF4T6S/VqwQYs6crNcPGybE2bNCnD4txPjx8pjpAwevv+bPF+LDD4Vo1Ei+PzZuFKJhw+LTD4AcFNGUGpbd52HWLJkCZWoqxI0b8gJg6FCZGpXX9hSQ/Ap886PLC7I7fH19hbe3d6byI0eOCADiyZMn4sWLFyIuLk61LiAgQDg5OWl/MNKIgW9OFfanqSh+YtkX7IeC6oescp2PHRMiOlqODsfECJGWJn9+c3S4a1chZs+WP1+9Kke4PDyECAwsvH7Ir77Q99xWCwv5Xnj9Qj+7l5ubvEfizXJXVyF+/z3jfVS1qhwkCA4uHv0AZD/yXbWqEMnJQoSGynsdpk7N+LajKH4b8hYMfI+I9MD3TQx88xdzfImo8OU017llS5mvWK2anOEjIUH+/Pr0b9bWMh98xoyMfSuVxTfXWV9zW9Olz3seGZl1HXt7+W+pUnLmm++/V19vZCSnO/T3l8sWFjJOKW7viUGD5D0N6VNZvu7ePaBSJfmkS09Pef/I2LFyXWws0KGDnDlm2TI5/eXYsfLBR5s3A3/8AVSpUrjnQjkWGBgIm/+fmScwMBAzZszAxYsXoVAooFAoEBgYqNP26QvOAUNE+cfODtiyBTA0lMHaP/9kPJlw+XJ5k+Nff+VsX3PmyLmtX72Sy998I2+QTE6WgUNx4u4ub2LatSvzuvPn5dP77OyAuDj5GG8rK1m/JD3gZdAg+R543YwZ8ubfpUvl8oED8oZGExPgt98yHm2eLqubYNPXFQcWFnKKP1dXzeuTk4EHD+TPT57IaQw//hiYO1e9XteuwK1b8mLi6lUZKDdpIi8Y/PwK9BQo73r16oXLly9j3759OHToEADA+vVBAyowDHyJKP9ERcnRKE0GD9Zc/u+/mud0fXM+6BUr5Ks4ym6ELzgYmDdPBsVpaXIWFEDe2V+SHvDSvHnmsvRHc6dr2DD7fcyerb68e7d8FSdvG/kuV04GvKmp8gKga9fM35qkfxvi5SWXi/u3ISXErl27YPlG/6dp+swDKFWqFCwtLWFkZAT79G86qFAw8CUVxXRdtyD/CV03gOhtI3wA8Ouv8gUAbm5yusRnz9TrvP6Al2PHZDqEQgEEBgIeHgXVespvbxv5fv99OWqbliZTOw4fBr79Vr1+Sfo2pARp3bo1fk3/HP+/M2fOoF+/fjpqEWnCwJfoDbwAoHyV09zW2Ni357b27i2X03NbheAIX3HztpHvbdsyRv2zUpK+DSlBLCwsUKNGDbWy//77T0etoazofeDLIIeIChRzW4lIAxMTkyxTIajg6H3gS0RUoJjbSkQaODo6IioqCuHh4ahcuTJKly4NU1NTXTerxON0ZkRERESFrFu3bujQoQNat26NcuXK4c8//9R1k/QCR3yJSCOmARFRUSGK+Ic3qzl4PTw8IP6/8X5+fvB7bao5U1NTbN68uRBaR6/jiC8RERER6QUGvkRERESkFxj4EhEREZFeYOBLRERERHqBN7cREVGO8IZHIiruGPgSERFpgRcARMUXUx2IiIiISC8w8CUiIiIivcBUByKit+BX20REJQNHfImIiIhKkOjoaCgUCoSHh+u6KUUOR3yJiIioSFPMUBTq8USA9t+JPHjwANOmTcPu3bsRFxeHMmXKwMnJCdOmTUPz5s2hUCiwbds2+Pj45H+DKccY+BIRERHlUbdu3ZCcnIw1a9bg3XffRVxcHIKCgvDo0SNdN41ew1QHIiIiojx4+vQpjh8/jjlz5qB169aoWrUqmjZtiokTJ6JLly5wdHQEAHz00UdQKBSq5Vu3bsHb2xt2dnawtLSEq6srDh06pLZvR0dHzJo1C5988glKly6NKlWqYNmyZWp1QkND4ezsDDMzMzRp0gQXLlwojNMulhj4EhEREeWBpaUlLC0tsX37diQlJWVaf/bsWQDA6tWrce/ePdXy8+fP0bFjRwQFBeHChQvo0KEDOnfujNu3b6tt/8MPP6gC2s8//xzDhg1DZGSkah+dOnVC3bp1cf78eUyfPh1ffvllAZ9x8cXAl4iIiCgPjIyMEBgYiDVr1sDGxgbNmzfHpEmTcOnSJQBAuXLlAAA2Njawt7dXLTs5OWHIkCGoX78+atasia+//hrVq1fHzp071fbfsWNHfP7556hRowbGjx8PW1tbHDlyBACwbt06KJVKrFy5EvXq1UOnTp0wbty4Qjz74oWBLxEREVEedevWDXfv3sXOnTvRoUMHBAcHo3HjxggMDMxym+fPn+PLL79EnTp1YGNjA0tLS1y7di3TiG/Dhg1VPysUCtjb2+P+/fsAgGvXrqFhw4YwMzNT1XF3d8/fkytBGPgSERER5QMzMzO0a9cOU6dOxcmTJ+Hn54eAgIAs63/55ZfYtm0bZs2ahePHjyM8PBwNGjRAcnKyWj1jY2O1ZYVCAaVSWSDnUNIx8CUiIiIqAHXr1kViYiIAGbympaWprQ8JCYGfnx8++ugjNGjQAPb29oiOjtbqGHXq1MGlS5fw6tUrVdnp06fz3PaSioEvERERUR48evQIbdq0we+//45Lly4hKioKmzZtwvfffw9vb28AcnaGoKAgxMbG4smTJwCAmjVrYuvWrQgPD8fFixfx8ccfaz2S+/HHH0OhUGDw4MG4evUq9uzZg3nz5uX7OZYUDHyJiIiI8sDS0hJubm748ccf0bJlS9SvXx9Tp07F4MGDsWjRIgByZoaDBw/CwcEBzs7OAID58+ejTJky+N///ofOnTvDy8sLjRs31vrYf/31FyIiIuDs7IzJkydjzpw5+X6OJQUfYEFERERFWm6epFaYTE1NMXv2bMyePTvLOp07d0bnzp3VyhwdHXH48GG1suHDh6sta0p9ePNRxM2aNctUJkTR7jNd4YgvEREREekFBr5EREREpBcY+BIRERGRXshV4Lt48WI4OjrCzMwMbm5uCA0Nzbb+ggULUKtWLZQqVQoODg4YM2aM2rQbREREREQFTevAd8OGDfD390dAQADCwsLg5OQELy8v1RNE3rRu3TpMmDABAQEBuHbtGlauXIkNGzZg0qRJeW48EREREVFOaR34zp8/H4MHD8bAgQNRt25dLFmyBObm5li1apXG+idPnkTz5s3x8ccfw9HREe3bt0efPn3eOkpMRERERJSftAp8k5OTcf78eXh6embswMAAnp6eOHXqlMZt/ve//+H8+fOqQPeff/7Bnj170LFjxyyPk5SUhISEBLUXEREREVFeaDWP78OHD5GWlgY7Ozu1cjs7O1y/fl3jNh9//DEePnyI999/H0IIpKamYujQodmmOsyePRszZszQpmlERERERNkq8FkdgoODMWvWLPzyyy8ICwvD1q1bsXv3bnz99ddZbjNx4kTEx8erXjExMQXdTCIiIiIq4bQa8bW1tYWhoSHi4uLUyuPi4mBvb69xm6lTp6J///749NNPAQANGjRAYmIiPvvsM0yePBkGBpljb1NTU5iammrTNCIiIiLKI4VCgW3btsHHx0fXTSkQWo34mpiYwMXFBUFBQaoypVKJoKAguLu7a9zmxYsXmYJbQ0NDAHycHhEREeWAQlG4r1x48OABhg0bhipVqsDU1BT29vbw8vJCSEhIPncG5YVWI74A4O/vD19fXzRp0gRNmzbFggULkJiYiIEDBwIABgwYgEqVKqmeV925c2fMnz8fzs7OcHNzw99//42pU6eic+fOqgCYiIiIqDjr1q0bkpOTsWbNGrz77ruIi4tDUFAQHj16lKv9CSGQlpYGIyP1UC05ORkmJib50eQCUdTbp3WOb69evTBv3jxMmzYNjRo1Qnh4OPbt26e64e327du4d++eqv6UKVMwduxYTJkyBXXr1sWgQYPg5eWFpUuX5t9ZEBEREenI06dPcfz4ccyZMwetW7dG1apV0bRpU0ycOBFdunRBdHQ0FAoFwsPD1bZRKBQIDg4GIO+JUigU2Lt3L1xcXGBqaooTJ07Aw8MDI0aMwOjRo2FrawsvLy8AwOXLl/HBBx/A0tISdnZ26N+/Px4+fKjav4eHB7744gt89dVXKFu2LOzt7TF9+nS1dt+8eRMtW7aEmZkZ6tati4MHD2Y6t5iYGPTs2RM2NjYoW7YsvL29ER0drVrv5+cHHx8ffPvtt6hYsSJq1aqVb/1aEHJ1c9uIESPw77//IikpCWfOnIGbm5tqXXBwMAIDA1XLRkZGCAgIwN9//42XL1/i9u3bWLx4MWxsbPLadiIiIiKds7S0hKWlJbZv346kpKQ87WvChAn47rvvcO3aNTRs2BAAsGbNGpiYmCAkJARLlizB06dP0aZNGzg7O+PcuXPYt28f4uLi0LNnT7V9rVmzBhYWFjhz5gy+//57zJw5UxXcKpVKdO3aFSYmJjhz5gyWLFmC8ePHq22fkpICLy8vlC5dGsePH0dISAgsLS3RoUMHJCcnq+oFBQUhMjISBw8exK5du/J0/gVN61QHIiIiIspgZGSEwMBADB48GEuWLEHjxo3RqlUr9O7dWxW85tTMmTPRrl07tbKaNWvi+++/Vy1/8803cHZ2xqxZs1Rlq1atgoODA27cuIH33nsPANCwYUMEBASo9rFo0SIEBQWhXbt2OHToEK5fv479+/ejYsWKAIBZs2bhgw8+UO1zw4YNUCqVWLFiBRT/n/u8evVq2NjYIDg4GO3btwcAWFhYYMWKFUU6xSFdgU9nRkRERFTSdevWDXfv3sXOnTvRoUMHBAcHo3HjxmrfgudEkyZNMpW5uLioLV+8eBFHjhxRjTRbWlqidu3aAIBbt26p6r0ZdFeoUAH3798HAFy7dg0ODg6qoBdApokKLl68iL///hulS5dWHads2bJ49eqV2nEaNGhQLIJegCO+RERERPnCzMwM7dq1Q7t27TB16lR8+umnCAgIwPHjxwGoz2aVkpKicR8WFhZvLXv+/Dk6d+6MOXPmZKpboUIF1c/GxsZq6xQKBZRKZY7P5/nz53BxccEff/yRaV25cuWybXNRxcCXiIiIqADUrVsX27dvVwWJ9+7dg7OzMwCo3eimrcaNG2PLli1wdHTMNOtDTtWpUwcxMTG4d++eKlg+ffp0puNs2LAB5cuXh5WVVa7bW5Qw1YGIiIgoDx49eoQ2bdrg999/x6VLlxAVFYVNmzbh+++/h7e3N0qVKoVmzZqpblo7evQopkyZkuvjDR8+HI8fP0afPn1w9uxZ3Lp1C/v378fAgQORlpaWo314enrivffeg6+vLy5evIjjx49j8uTJanX69u0LW1tbeHt74/jx44iKikJwcDC++OIL/Pfff7luvy4x8CUiIqKiTYjCfWnJ0tISbm5u+PHHH9GyZUvUr18fU6dOxeDBg7Fo0SIA8uaz1NRUuLi4YPTo0fjmm29y3R0VK1ZESEgI0tLS0L59ezRo0ACjR4+GjY2NxifiamJgYIBt27bh5cuXaNq0KT799FN8++23anXMzc1x7NgxVKlSBV27dkWdOnUwaNAgvHr1qtiOACtEMXh8WkJCAqytrREfH5/vHa2YkbsntBRlIiB3v1L2hcR+kNgPGdgXEvtBYj/knLZ/v1+9eoWoqChUq1YNZmZmBdImKply+t7hiC8RERER6QUGvkRERESkFxj4EhEREZFeYOBLRERERHqBgS8RERER6QUGvkRERESkFxj4EhEREZFeYOBLRERERHqBgS8RERER6QUGvkRERETFiIeHB0aPHp1tHUdHRyxYsKBQ2lOcGOm6AURERETZmaGYUajHCxABWtX38/PDmjVrAABGRkYoW7YsGjZsiD59+sDPzw8GBsVznFGhyHg8t7m5OSpWrIjmzZtj5MiRcHFx0WHLcq94/iaIiIiIipAOHTrg3r17iI6Oxt69e9G6dWuMGjUKnTp1Qmpqqq6bl2urV6/GvXv3cOXKFSxevBjPnz+Hm5sb1q5dq+um5QoDXyIiIqI8MjU1hb29PSpVqoTGjRtj0qRJ2LFjB/bu3YvAwEBVvdu3b8Pb2xuWlpawsrJCz549ERcXp1rv5+cHHx8ftX2PHj0aHh4eamWpqakYMWIErK2tYWtri6lTp0IIkWX7nj59ik8//RTlypWDlZUV2rRpg4sXL771vGxsbGBvbw9HR0e0b98emzdvRt++fTFixAg8efJEVW/Lli2oV68eTE1N4ejoiB9++EG1btGiRahfv75qefv27VAoFFiyZImqzNPTE1OmTAEATJ8+HY0aNcJvv/0GR0dHWFtbo3fv3nj27Nlb2/s2DHyJiIiICkCbNm3g5OSErVu3AgCUSiW8vb3x+PFjHD16FAcPHsQ///yDXr16ab3vNWvWwMjICKGhoVi4cCHmz5+PFStWZFm/R48euH//Pvbu3Yvz58+jcePGaNu2LR4/fqz1sceMGYNnz57h4MGDAIDz58+jZ8+e6N27NyIiIjB9+nRMnTpVFfC3atUKV69exYMHDwAAR48eha2tLYKDgwEAKSkpOHXqlFpwf+vWLWzfvh27du3Crl27cPToUXz33Xdat/VNzPElIiIiKiC1a9fGpUuXAABBQUGIiIhAVFQUHBwcAABr165FvXr1cPbsWbi6uuZ4vw4ODvjxxx+hUChQq1YtRERE4Mcff8TgwYMz1T1x4gRCQ0Nx//59mJqaAgDmzZuH7du3Y/Pmzfjss8+0PicAiI6OBgDMnz8fbdu2xdSpUwEA7733Hq5evYq5c+fCz88P9evXR9myZXH06FF0794dwcHBGDt2LBYuXAgACA0NRUpKCv73v/+pjqFUKhEYGIjSpUsDAPr374+goCB8++23WrX1TRzxJSIiIiogQgjVTWLXrl2Dg4ODKugFgLp168LGxgbXrl3Tar/NmjVTu/nM3d0dN2/eRFpaWqa6Fy9exPPnz/HOO+/A0tJS9YqKisKtW7dydU4A1M6refPmanWaN2+uao9CoUDLli0RHByMp0+f4urVq/j888+RlJSE69ev4+jRo3B1dYW5ublqe0dHR1XQCwAVKlTA/fv3tW7rmzjiS0RERFRArl27hmrVquW4voGBQaZc3ZSUlDy14fnz56hQoYIqteB1NjY2Wu8vPUjX5rw8PDywbNkyHD9+HM7OzrCyslIFw0ePHkWrVq3U6hsbG6stKxQKKJVKrdv6Jo74EhERERWAw4cPIyIiAt26dQMA1KlTBzExMYiJiVHVuXr1Kp4+fYq6desCAMqVK4d79+6p7Sc8PDzTvs+cOaO2fPr0adSsWROGhoaZ6jZu3BixsbEwMjJCjRo11F62trZan9eCBQtgZWUFT09P1XmFhISo1QkJCcF7772nak96nu+mTZtUubweHh44dOgQQkJCMt28V1AY+BIRERHlUVJSEmJjY3Hnzh2EhYVh1qxZ8Pb2RqdOnTBgwAAAcuaCBg0aoG/fvggLC0NoaCgGDBiAVq1aoUmTJgDkDXHnzp3D2rVrcfPmTQQEBODy5cuZjnf79m34+/sjMjISf/75J37++WeMGjVKY9s8PT3h7u4OHx8fHDhwANHR0Th58iQmT56Mc+fOZXteT58+RWxsLP79918cPHgQ3bt3x7p16/Drr7+qRovHjh2LoKAgfP3117hx4wbWrFmDRYsW4csvv1Ttp2HDhihTpgzWrVunFvhu374dSUlJmVIlCgpTHYiIiKhI0/aBErqwb98+VKhQAUZGRihTpgycnJzw008/wdfXV/UAC4VCgR07dmDkyJFo2bIlDAwM0KFDB/z888+q/Xh5eWHq1Kn46quv8OrVK3zyyScYMGAAIiIi1I43YMAAvHz5Ek2bNoWhoSFGjRqV5U1qCoUCe/bsweTJkzFw4EA8ePAA9vb2aNmyJezs7LI9r4EDBwIAzMzMUKlSJbz//vsIDQ1F48aNVXUaN26MjRs3Ytq0afj6669RoUIFzJw5E35+fmptaNGiBXbv3o33338fgAyGraysUKtWLVhYWOS8s/NAIbKb9K2ISEhIgLW1NeLj42FlZZWv+1bMULy9UjEjAnL3K2VfSOwHif2QgX0hsR8k9kPOafv3+9WrV4iKikK1atVgZmZWIG2ikimn7x2mOhARERGRXmDgS0RERER6gYEvEREREekFBr5EREREpBcY+BIREVGRUgzuu6ciJqfvGQa+REREVCSkP+wgOTlZxy2h4ubFixcAMj/x7U2cx5eIiIiKBCMjI5ibm+PBgwcwNjZWzX9LlBUhBF68eIH79+/DxsZG45PrXsfAl4iIiIoEhUKBChUqICoqCv/++6+um0PFiI2NDezt7d9aj4EvERERFRkmJiaoWbMm0x0ox4yNjd860puOgS8REREVKQYGBnxyGxUIJs8QERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+ueDXyA8iQMC7ljcA4PSg07gw5AIuDLmAiGEREAECDco30LjtAKcBuDT0Ei4MuYCwz8LwQY0PAABGBkbY1msbwoeEY0vPLTBUyImYTQ1NcdTvKGzMbArl3IiIiIhKKga+WqpqXRWDGw/GqZhTqrJmK5vBeakznJc6Y3rwdETERSDifkSmbcuYlcHPH/yMdr+1g/NSZ4zcOxKBPoEAAK/qXnj88jEaLW2Ep6+eokONDgCAqa2mYlHoIjx99bQwTi9HokZF4frw66pgv2e9ngCAGmVrIOSTEESOiETop6GoW65ulvv4xPkT3BhxA3+P/BvLOi+DkYF8lopLBRdcGHIBVz6/ggFOA1T1Wzu2xpJOSwr2xIiIiKhEY+CrBQUUWNFlBUbuHYmktCSNdQY5D8LKCys1rjNQGEABBUqblgYA2JjZ4L+E/wAAKcoUmBubAwDMjc2RnJaMBuUboPY7tbHp6qYCOJu86bW5lyrY33hlIwBgaaelWHZ+GWotqoU5IXMQ6B2ocVtHG0d83fprtFjdAjV+rgE7Czt85vIZAGDC+xPwxd4v4LrcFQGtAgAAZkZmmO4xHeMPji+UcyMiIqKSiYGvFvzd/RESE4Kwe2Ea11e2qoxWjq3w+6XfNa5/9PIRhu4eirDPwhA9KhqrvFfBb7sfAODgrYN4lvwM4UPCEZ8Uj8NRhzHfaz5G7RtVUKeTr8qZl0OTik1U577l2hY4WDugepnqmep2r9sdOyN3Ii4xDgCw5NwS9KnfBwCQkiYvAMyMzJCmTAMATPeYjoVnFiI+Kb6QzoaIiIhKIiNdN6C4qFeuHrrV6YaWgS2zrOPXyA+7buzCo5ePNK63MrXCKLdRaLqiKa4/vI5O73XCtl7bUGdxHaQoU/DZX5+p6o5yG4Xt17fDyMAIf3T9A6aGplh8djGORB/J93PLjbUfrYUCCoTeDcWEQxPgYO2Ae8/uIU2kqercjr+NKtZVcOvJLbVtq1hXwb/x/6qWo59Go4p1FQDAzGMzsbTTUlgYW2DcwXFwsnPCuzbvYsKhCYVzYkRERFRiccQ3h1pUbQFHG0fcHHkTUaOi0KxyMyzrvAxDmwxV1RnYaGCWaQ4A0O7ddnj66imuP7wOANh1YxesTK1Q1aaqWr0q1lXQsWZH/HL2F3zd+mssO78Mfjv88PMHPxfMyWmp5eqWcFrihMbLGuPhi4dY47Mm3/Z9/eF1tApshSbLm+CvG3/hh/Y/YNS+Uehdvzc299iMVV1WFakb/bLKd17YYSGiRkVBBAg42TlluX2zys1U214edhlLOi2BiaEJAOY7ExER5TeO+ObQknNLsORcRrBxxPcIFpxegB2ROwAAbaq1gZGBEQ7eOpjlPv558g8a2TeCnYUd4hLj0KxyMxgZGCEmPkat3sIOCzFm/xgICFiYWEBAQCmUsDCxKJiT01JMgmxvqjIVC04vwI0RNxATH4MKpSvAUGGoGvWtYl0Ft+NvZ9r+dvxttRQIRxtHjfVGNxuNTVc34emrp5jacioa/toQ/Z36Y3Sz0ZgePL1gTi4Xem3uhYtxF9XKNl/djO9DvseJT05ku+3F2ItwXe6KVGUqFFBgS88t+Nz1cyw4vUCV73z+3nlEDIvA2otrVfnOXf7sUpCnREREVCIx8M0ng5wHYXX4aggItfIhLkNQsXRFBAQH4ELsBXx7/Fsc9j2MlLQUpCpT0XNzT7Ub5frU74OLcRdx9cFVAMB3J77D8s7LYWJogq+PfV2o56SJubE5jA2MVfm2fer3wYXYC3jw4gHC7oWhX8N+WHNxDbrV6Yb/Ev7LlOYAAFuubsGJT05gevB0xCXGYWiToVh/eb1aHUcbR7R7tx0++OMDWJlawcjASHUBYGliWSjnmhfHbx/PUb2XqS9VP5sYmqCUcSkIId9DzHcmIiLKXwx8c6n1mtZqy3239tVYb+n5pWrLP535CT+d+SnL/f55+U+15bN3z6LR0ka5a2QBsLOwk/MMGxhCAQX+efIPBmyTX8MP2TUEgd6BmNRiEhKSEjBwx0DVdss7L8fOyJ3468ZfiHoahYDgAIR8EgIACP43OFM/LeywEKP3jQYAJCQlYF3EOkQMi8Dz5OfotblX4ZxsDr2Z7/zwxUOttq9qXRU7eu9A9bLVsfvGbvxy9hcAzHcmIiLKbwqRPrxUhCUkJMDa2hrx8fGwsrLK130rZijydX9FgQjI3a+UfSFp0w8OVg6ISYiBkYERvmnzDRqUb4AP132oWh81Kgo+630ypUJoYmFsgd+7/o71l9djw5UNausMFAY40O8A+m/rj1aOrdC9TnckJCXA/4B/juZ4Luh+KC742cjA94TEfpBy+9l4m4L8+02UG7y5jSgP3sx3blGlRa73lZiSiPWX16Nvg8zfHryZ79xrcy8cu30Mo5uNzvXxiIiI9A0DX6JcMjc2h7WptWo5Pd9ZG9XLVFc9tc7YwBgf1f4Il+5fUquTnu+89PxSGBsaF7t8ZyIioqKCOb5EuZRdvvOSTkvwYc0PYW9pj/399uNZ8jPU/LkmAPV85zbV2uALty+QpkyDkYERgqKC8PVR9ZsYi1O+MxERUVHGHF/maqmwLyT2g8R+yMC+kNgPEvsh55jjS0UNUx2IiIiISC8w8CUiIiIivcDAl4jyLKtHN6fza+QHESDgXcs7y3181fwrXPn8Ci4MuYBTg07BtaIrAMDGzAaHBxzGpaGXsLjjYlV9W3NbHPE9oro5kIiI6G34F4OI8oWmRzcD8gEdgxsPxqmYU1lu62TnhM+bfI56v9RDYkoi+jboi0UdF8FthRv6NuiLI9FH8PWxrxE0IAj1ytXDlQdXML/9fEw4NAGpytSCPC3KhahRUUhKTVI9mXD2idnYcX0H1ndfj7rl6uJlykvcT7yPYbuHaXy6IwB8+b8v4evkCwOFASIfRmLgjoGIT4qHjZkNtvbcCltzWxy/fRzD9wwHIC+ENvXYhHa/teN7goiylKsR38WLF8PR0RFmZmZwc3NDaGhotvWfPn2K4cOHo0KFCjA1NcV7772HPXv25KrBRFR8KKDAii4rMHLvSLVHc79JQMDY0BgWJhYA5Cjvfwn/AQBSlPLRzQooYGpoiuS0ZHhV98KTV09w5s6ZQjkP0l6vzb3gvNQZzkudsfHKRgDAsvPLUGtRLTRa2gg7IndgRZcVGrf1fNcTAxsNhPtKd9T7pR7O3zuPb9t+CwCqC6GGSxqitm1t1CtXDwB4IUREOaJ14Lthwwb4+/sjICAAYWFhcHJygpeXF+7fv6+xfnJyMtq1a4fo6Ghs3rwZkZGRWL58OSpVqpTnxhNR0bH2o7W4NPQSVnRZAVtzWwCAv7s/QmJCEHYvLNttL8Vdwo+nf0TUqCjEjInBmGZjMHLvSADA75d+R42yNXBhyAUcijqEO8/uYHKLyZh8eHKBnxPln6S0JOz9e69q+fR/p+Fo46ixrpOdE07cPoHnyc8BAHtu7kH/hv0B8EKIiPJG61SH+fPnY/DgwRg4cCAAYMmSJdi9ezdWrVqFCRMmZKq/atUqPH78GCdPnoSxsTEAwNHRMW+tJqIipeXqlmqPbl7jswZfHfwK3ep0Q8vAlm/d3tHGEV1rd0WNn2rg3vN7GO46HBu6b0CL1S3wIuUFemzqoao732s+5oTMQY2yNTDp/UkAgG+Of4NLcZey2j3pwNqP1kIBBULvhmLCoQl4+OKh2vpRbqOwI3KHxm3P3zuPz10/h52FHeIS49C3YV9YmVqhjFkZ/H7pd6zxWYMLQy5ge+R23Hl2Byu7rETHdR0L47SIqJjTKvBNTk7G+fPnMXHiRFWZgYEBPD09ceqU5vy9nTt3wt3dHcOHD8eOHTtQrlw5fPzxxxg/fjwMDQ01bpOUlISkpIyvRRMSErRpJhEVsjcf3XxjxA20qNoCjjaOuDnyJgDA3tIeyzovQ4XSFbDk3BK17bvV6YaI+xG49/weAGB1+Gos6rgIxgbGSFGmqOq5VnRFefPy2H1zN475HUP/bf2hUCgQ6B0IjzUehXKu9HaaLoQ+XPehav3E9yeiRtkaaLu2rcbtg6ODMe/kPOz6eBfSlGnYdn0bAPn+4oUQEeWFVoHvw4cPkZaWBjs7O7VyOzs7XL9+XeM2//zzDw4fPoy+fftiz549+Pvvv/H5558jJSUFAQEBGreZPXs2ZsyYoU3TiEhHzI3NYWxgjPikeAAZj25ecm6JWoB7xPcIFpxeoHGU758n/2Bgo4GwMLZAYkoiOr3XCZEPI9WCXiMDI8zxnIPeW3oDACxMLCAgIITgo5uLGE0XQunGuo9F1zpd4bnWU3Xzmya/nvsVv577FQDgVskNMfExeJb8TK0OL4SISFsFPquDUqlE+fLlsWzZMhgaGsLFxQV37tzB3Llzswx8J06cCH9/f9VyQkICHBwcCrqpRJQL2T26OTszPGbg7rO7WHp+KbZd3wbXSq4499k5JKUmITElER9v/Vit/rj/jcPaS2txP1HeTzDtyDTs+VjeJDvu4Lj8PzHKlawuhABgTLMx6FO/Dzx/81Stz4q9pT1in8eilFEpzGw9E9+f/F5tPS+EiCg3tAp8bW1tYWhoiLi4OLXyuLg42Nvba9ymQoUKMDY2VktrqFOnDmJjY5GcnAwTE5NM25iamsLU1FSbphGRjkQ9jULjZY3fWq/1mtZqywHB6he+k4ImYVLQpCy3n31ittry7pu7sfvmbi1aWvA0TeOVPqMBIOczXu29Gj7rfbLMb0232ns1/Br5weY7m2I1jVdWF0KVSlfCfK/5uPX4Fo74HgEAJKUmodnKZgDUL4QA4EC/AzBQGMDE0AS/XfoNi0IXqR2HF0JElBtaBb4mJiZwcXFBUFAQfHx8AMgR3aCgIIwYMULjNs2bN8e6deugVCphYCAnkbhx4wYqVKigMeglIirO8jKfcbqPan+kluYBoNjMZ5zdhZBihiLL7d68EGq4pGG2xykOF0JEVPRoPZ2Zv78/li9fjjVr1uDatWsYNmwYEhMTVbM8DBgwQO3mt2HDhuHx48cYNWoUbty4gd27d2PWrFkYPnx4/p0FEVERltP5jAGgvEV5TGoxCf77/dXKOY0XEVHeaZ3j26tXLzx48ADTpk1DbGwsGjVqhH379qlueLt9+7ZqZBcAHBwcsH//fowZMwYNGzZEpUqVMGrUKIwfPz7/zoKIqIjQNI1XTuczBoDlnZfjq4NfqeawTcdpvIiI8i5XN7eNGDEiy9SG4ODgTGXu7u44ffp0bg5FRFRs5HU+40HOg3A7/jaORB/JtI7TeBVPWeV9f1DjA3zT5hsYKAxgZGCEuSfnYu3FtZm2tzC2wJaeW+BS0QVGBkYoM6eMap2jjSPWd1sPSxNL/BHxhyr9o7ZtbczxnAPv9d6Fc5JExUiBz+pARKQv8jqfcWvH1mhZtSU6vddJVXZp2CV4r/dGeGy4qozTeBUvmvK+f+/6OzwCPRBxPwJVravi+ojr2Hpta6aR/hRlCuaEzMHjl48R7Bestm6463AsPrsYf0T8gaufX8XPoT/jefJzLPBagKG7hxb0aREVSwx8iYjyQX7MZ9xvWz+1ZREg0PDXhmpTf3Ear5JBCAEbMxsAgJWpFR69eISk1Mz538lpyTgSfQRVratmWpee921sYAwDhQGUQomhTYbiwD8HEP00uoDPgKh4YuBLRJQP8mM+45zgNF7Fj6a8716be2Frr61ITE5EmVJl0HVD10wzebzNT2d+QqB3IIa4DMG8U/NgbWqN7nW6o/3v7QvoTIiKPwa+RET5IL/mM36dpum/OI1X8aIp77vLn10wpeUUdN3QFcdvH0eTik2ws/dONPi1AR69fJTjfcc+j0WHPzqoljd234ixB8aitWNrDGsyDElpSZgYNBG3428XxKkRFUtaT2dGREREOfNm3neLKi3QyL4RKpauiOO3jwMAzt09h/8S/oNzBedcH6drna649eQWLsZdxM8f/Ay/HX5YHrYcMz1m5st5EJUUDHyJiIgKgLmxOaxNrVXL6XnfMQkxqGBZAbVtawMAqpepjuplqyPyYWSujmNtao1RbqMw4+gM1XGVQgmlUDLvm+gNTHUgIiIqAFnlfd9PvI/Pdn2Gjd03QimUMFAYYMSeEarR4Tfzvi8OvYhy5uVgZWqFmDExOBJ1BAO2Z+SPz2k3B9ODp+NV6isAclq7c4PPITktGYN2Dir8Eycqwhj4EhERFYDs8r7XX16P9ZfXa1z3Zt630xKnbI8zdJf61GUrwlZgRdgKLVpKpD+Y6kBEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXchX4Ll68GI6OjjAzM4ObmxtCQ0NztN369euhUCjg4+OTm8MSEREREeWakbYbbNiwAf7+/liyZAnc3NywYMECeHl5ITIyEuXLl89yu+joaHz55Zdo0aJFnhqc76YLXbcg/wXougFERERERY/WI77z58/H4MGDMXDgQNStWxdLliyBubk5Vq1aleU2aWlp6Nu3L2bMmIF33303Tw0mIiIiIsoNrQLf5ORknD9/Hp6enhk7MDCAp6cnTp06leV2M2fORPny5TFo0KAcHScpKQkJCQlqLyIiIiKivNAq8H348CHS0tJgZ2enVm5nZ4fY2FiN25w4cQIrV67E8uXLc3yc2bNnw9raWvVycHDQpplERERERJkU6KwOz549Q//+/bF8+XLY2trmeLuJEyciPj5e9YqJiSnAVhIRERGRPtDq5jZbW1sYGhoiLi5OrTwuLg729vaZ6t+6dQvR0dHo3LmzqkypVMoDGxkhMjIS1atXz7SdqakpTE1NtWkaEREREVG2tAp8TUxM4OLigqCgINWUZEqlEkFBQRgxYkSm+rVr10ZERIRa2ZQpU/Ds2TMsXLiQKQxFDWe4ICIiohJM6+nM/P394evriyZNmqBp06ZYsGABEhMTMXDgQADAgAEDUKlSJcyePRtmZmaoX7++2vY2NjYAkKmciIiIiKggaR349urVCw8ePMC0adMQGxuLRo0aYd++faob3m7fvg0DAz4QjoiIiIiKFq0DXwAYMWKExtQGAAgODs5228DAwNwckoiIiIgoTzg0S0RERER6gYEvEREREemFXKU6EJVonN2CiIioROKILxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXGPgSERERkV5g4EtEREREeoGBLxERERHpBQa+RERERKQXjHTdACIiKiamC123IP8F6LoBRFSYOOJLRERERHqBI75EpBlH94iIqIThiC8RERER6QUGvkRERESkFxj4EhEREZFeYOBLRERERHqBgS8RERER6QUGvkRERESkFzidGRHR23BqNyKiEoEjvkRERESkFxj4EhEREZFeYOBLRERERHqBgS8RERER6QUGvkRERESkFxj4EhEREZFeYOBLRERERHqBgS8RERER6QUGvkRERESkFxj4EhEREZFe4COLiYiItMFHWBMVWxzxJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfHPBzw8QAvD2lsvlygF79wI3bgAREUCLFpq3a98euHAh43XnDnD+vFxnYwMcPgxcugQsXpyxja0tcOQIYGRUkGdEREREVPIx8NVS1arA4MHAqVMZZd99B5w+Dbz3HjBwILBuneZA9cABwNk54xUWBvzxh1zXt68McBs2BGrXBurVk+Xz5wMTJgCpqQV/bkREREQlWa4C38WLF8PR0RFmZmZwc3NDaGholnWXL1+OFi1aoEyZMihTpgw8PT2zrV+UKRTAihXAyJFAUlJGec+ewJIl8udz54C7d4FWrbLfV4UKQNu2wG+/yeWUFMDcXB7D1BRITga8vIAnT4AzZwrmfIiIiIj0idaB74YNG+Dv74+AgACEhYXByckJXl5euH//vsb6wcHB6NOnD44cOYJTp07BwcEB7du3x507d/Lc+MLm7w+EhMiR2nRlywLGxkBcXEZZdDRQpUr2+/LzA/bsAR48kMu//w7UqCFTIA4dkmkQkyfLV1Gzfz9w8aJs67FjQKNGstzLCzh7Vq47dUqOXmvi6CgvEC5ckKkhGzfKVI/0dadPA5cvAxMnZmxTuzawY0fBnRMRERHpAaGlpk2biuHDh6uW09LSRMWKFcXs2bNztH1qaqooXbq0WLNmTY6PGR8fLwCI+Ph4bZv7VjJb9+2vevWEOHlSCCMjuXzkiBDe3kKULSvEq1fqdTdsEGLgwOz3d/OmEB98kPX6+fOF+PBDIRo1EmLjRvlq2DBnbS3ovrC2zvjZx0eI8HAhbGyEePhQiLp1Zfn77wsREaF5exMTIczMMpYXLJAvQIi5c4Xo318IAwMhrl8XwtJSlu/bJ4SjY87bmJe+0PYYxeHFfsh9P7Av2A/sh9wryL/fRLmh1S1TycnJOH/+PCa+NhRnYGAAT09PnHo96TUbL168QEpKCsqWLZtlnaSkJCS9lkuQkJCgTTMLRIsWcjTy5k25bG8PLFsGBATI/Fs7u4xRX0dH4PbtrPfVqhVgZiZHTjVxdQXKlwd275Yjqv37yxSIwEDAwyP/zim34uMzfra2lv9tVq8OPHoEXL0qy0+ckKPezs5yZPd1yckZPxsYABYWwPPncjk95cPYWK5TKoGhQ2V+dHR0gZ4WERERlXBapTo8fPgQaWlpsLOzUyu3s7NDbGxsjvYxfvx4VKxYEZ6enlnWmT17NqytrVUvBwcHbZpZIJYsASpWBKpVk6/Tp4HPPpPlmzbJ4AwAmjQBKlUCjh7Nel+DBskgVqnMvM7ICJgzR6ZVADIoFELWtbTM99PKtTVrZHD/9dcyML95E3jnHcDdXa7v3BmwspIXAZoYG8uA+OFDoGZNeQEBAD/9BHz0kUyVmDdPBtbduwMLFhTGWWlPU9pH2bLqs3dERsqAvkwZzftwcAB27gSuXweuXAFGjJDlTPsgIiLKZ9oMD9+5c0cAECdPnlQrHzdunGjatOlbt589e7YoU6aMuHjxYrb1Xr16JeLj41WvmJiYAvuqJLdfC6WnOgBClC8vxP79Qty4IcTly0J4eGTUmzFDiCFDMpatrIR4/lyIatU073fiRCH8/DKWP/xQ7vPy5exTI/LjK6vc9MOAAULs3i1/9vAQIjhYiHPnhPj5Z9nmzp2z397YWIglS4QYN07z+o0bhXByEqJtWyE2bxbijz+EqFKl6HyNqSnt4806Y8cKsXNn1vs4d06I7t0zlsuXl//mZ9pHYb0fivort3Td7qLSF7puM/uhaPVDTjDVgYoarVIdbG1tYWhoiLjX7+QCEBcXB3t7+2y3nTdvHr777jscOnQIDbO66+n/mZqawtTUVJumFbrWrTN+vn9f3tilSfpIZrqEhOxHbmfPVl/evVu+iqq1a+Wod9myQHBwRiqGiQkQG5uR+pCVlBRg9Wpg+XJg7lz1dV27ArduyRHVq1eBpk3liPrMmfLmwKJAU9rHmwYNUh+xfV3btnKGkM2bM8rS7xNl2gcREVH+0irVwcTEBC4uLggKClKVKZVKBAUFwT39O24Nvv/+e3z99dfYt28fmjRpkvvWks5ZW8up2NJ5e8vc3sePZd5zuqlT5QM5bt3KvI8qVYBSpeTPCgXQo4d8cMebxxk1CpgxQy6bm8vAr6ilfACZ0z5e5+4uUxx27dK8bd26cmaPP/+Us4Vs3SpTaYDil/ZBRERU1Gn9PDB/f3/4+vqiSZMmaNq0KRYsWIDExEQMHDgQADBgwABUqlQJs/9/6HLOnDmYNm0a1q1bB0dHR1UusKWlJSyLWgRDb2VtLXOaS5WSQeiDB0CnTnLdzJnyJkAjIxmsDRqUsd2MGXJ+46VL5TRn334ryw0MZMD3xRfqx5kzB5g+HXj1Si5/842cAi05WX2/RYGvr/x3wADZ7g8/zFg3aJAcFU9L07ytkRHQpg3QrJkc1R4yRE7v5uoqR8w7dMiou3EjMHas/LZh2DA5UjxxYvY3UhIREdFrcpMf8fPPP4sqVaoIExMT0bRpU3H69GnVulatWglfX1/VctWqVQWATK+AgIAcH68oTGdWnF7si7z1RV6O9+KFnOIOEMLCQoiEBCFq1cq6frduQhw9mrFsbi5EWlrGtHnpr65dhZg9W/589arM9/XwECIwsGj2Q1F95Zau211U+kLXbWY/FK1+yAnm+FJRo/WILwCMGDECI9JvPX9DcHCw2nI0kxGphLK2likY9+7J5dfTPgCgVy+ZnxwZmfU+9u4Fvv9ezhhy9y7QsSNw7Zr6I6rT0z7S88iLctoHERFRUZarwJeIsk/7AGSaw/Llmbd7Pe3jxQt5w9ru3TLfOT4e6N1bvX5xSvsgSrd/v8z7VyqBZ89kOlN4eNblb2rVSl4Yvn7h6O4uPwcuLvLx8SYm8vOxdq1c37q1vOBMn16SiCgTXQ855wRTHQrnKytdt7uo9IWu21wc+2H/fiEuXhTiwgUhjh2TTxzMrlzT65NP5JSAf/8txLJlGekeLi5y+ytX5PR56fVbt5ZT4RV0P/A9kbt+yGqqv5xMAQgI0aqV/L1rWrdpkxAtWsjUoFu3ZJmZmUwben3/RaEfisuroDDVgYoajvgSUZ717JkxtZuPj3xAS6NGWZe/ydFRzorRuLF8AuKOHfIBMb/8AkyYIEcFz58HIiLk6J6ZmRwF79Kl4M+Ncierqf5yMgXg26RP9WdmlnHj6PTpwMKF6vsnInoTA18iyrO8Bjndu8un16VPEb5kCTBpkgx8GeQUX2vWZMx53rHj28vfVL26vOBJS5Pzff/6qyyfOVOmCllYAOPGAU5OwLvvyoskIqLsMPAlonyRlyCnShXg338zlqOjZRnAIKc4y2qqv+ymAEwXFgZUriwf+lOpErBnj3zE+aZN8vHerVrJegYG8qEu/fvL/Pju3eU2/v7A06cFfopEVMxo9QALIqKs+PrKYHXKFBnMvK08p9KDnCZNgL/+An74Qc5y0bu3fOLdqlWAjU2+nUae7N8vZ/K4cAE4diwjrWPhQiAqSo54OzllvX3VqsCRIzJgu3BBfZ2Liyy7ckUGjOlat5Yj5EXZ2rWynWXL5qwckDe+JSTIn+/ckQ95adEic73Ro2Uw/PSpfHBOr16y70ePzueTIKISgYEvEeWr3AQ5t2/LoC+do6PmB3MU9SCnZ08Z2Do7A/Pny5xmQAbo77//9kdNJyTIC4SPP868Lj3X2dU141Ho6bnO48fn40nkg6ye8KhUZv3kxzfZ28uZTgA5bV+nTpkvBhwdgXbt5DcCxsbygTBCcKo/IsoaUx2IKE+yms84PcjJap7j123ZApw4IYO4uDg5HdX69ep10oOcDz4ArKyKZpCTVU7z8eM52/7JEyAkJONr/NcVp1znrKb6s7LKfgrA5ctlrvdffwHdusknFKamyt/1pk0yz/d1CxdmXPQkJADr1skbIJ8/lxdFRERvYuBLRHmSH0FOVJQcxQwJkeuCg+Uo3uuKS5CT0xu3tFWccp1v3wbc3DSvy6ocAAYPzvh58WL5yo63t/ryjBnyRUSUFYUQuZlMpnAlJCTA2toa8fHxsLKyytd9p3+VVpLk9jfKvpDYDxL7IUNu+mLAABmQv37jVlSUnNbt4sXst23VCliwQKZMaPL6DV2tWuXuhi6+JyT2g1RQkUBB/v0myg3m+BIRFYDscprzqqjnOpNkagps2yafPhceLi9WqleX61xdgVOn5OwVV6/KUfysNG0qt4+MBIKC5CPOAXlT5+HDwKVL6qPjtrbyJkkjfqdLlAkDXyKifJDVDV2acprzgjd0FS/LlgG1askZPnbskI9aTi+fNUs+tKV5c+DLL4E6dTJvr1AAf/whL2pq1ZLTui1YINf17SsD3IYNgdq1gXr1ZPn8+TIFJjW1EE6QqJjh9SARUT7IKtcZkNONffihnKlg/345VVfNmnLd67nOpUoBN27IkUJrayAmBvjtN/kwj3TFJdeZgKQkYO/ejOXTp2WAC8iLlfRp+CwsgORkzRdJLi4ygA0OlstLlwLffCPfI+k3PCoUcjk5GfDykjdJnjlTkGdGVHwxx5e5WirsC4n9ILEfMrAvJPaDlNt+WLtWBrejR8ubE3fskPsqVw4YMkRe5Lypa1f5+O4OHTLK4uKAZs3kv2vWyIuo7duB778H9u2TN1U+f65d25jjS/qCI75EREQFbOJEoEYNoG1buTxhgiz780+gWjXg6FHg3Dng2rWc7/PFC6BHj4zl+fPlQ2Jq1Mj4luCbb2QOMBFJDHyJiIgK0NixcuTW0xN4+RJ45x3go4+APn3k+qgomQbRvHnmwPfNh7tYWso0mLt31eu5ugLlywO7d8sbHfv3l6PJgYGAh0dBnh1R8cKb24iIiArImDEywG3XLuNBI0+eAImJGfM9v/OOnN/48uXM258/L29iTA9ehwyR+eBJSRl1jIzkSK+/v1y2sOANj0RZ4YgvERFRAahUSaYf3LolZ18AZMDarJl8vPXcuTJoNTaWMzWcPi3rDBkipywLCJABbL9+8qY2MzM50tu/v/pxxo2T+cP378vladPk7A/p64goA29u480aKuwLif0gsR8ysC8k9oPEfsg53txGRQ1THYiIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gsMfImIiIhILzDwJSIiIiK9wMCXiIiIiPQCA18iIiIi0gu5CnwXL14MR0dHmJmZwc3NDaGhodnW37RpE2rXrg0zMzM0aNAAe/bsyVVjiYiIiIhyS+vAd8OGDfD390dAQADCwsLg5OQELy8v3L9/X2P9kydPok+fPhg0aBAuXLgAHx8f+Pj44PLly3luPBERERFRTimEEEKbDdzc3ODq6opFixYBAJRKJRwcHDBy5EhMmDAhU/1evXohMTERu3btUpU1a9YMjRo1wpIlS3J0zISEBFhbWyM+Ph5WVlbaNPetFIp83V2RoN1vNAP7QmI/SOyHDOwLif0gsR9yriD/fhPlhpE2lZOTk3H+/HlMnDhRVWZgYABPT0+cOnVK4zanTp2Cv7+/WpmXlxe2b9+e5XGSkpKQlJSkWo6PjwcgP0D0duymDOwLif0gsR8ysC8k9oNUUP2Q/ndbyzE2ogKjVeD78OFDpKWlwc7OTq3czs4O169f17hNbGysxvqxsbFZHmf27NmYMWNGpnIHBwdtmqu3rK113YKig30hsR8k9kMG9oXEfpAKuh+ePXsGa3Y2FQFaBb6FZeLEiWqjxEqlEo8fP8Y777wDRTH9jikhIQEODg6IiYnR66972A8S+yED+0JiP0jshwwloS+EEHj27BkqVqyo66YQAdAy8LW1tYWhoSHi4uLUyuPi4mBvb69xG3t7e63qA4CpqSlMTU3VymxsbLRpapFlZWVVbP8Dy0/sB4n9kIF9IbEfJPZDhuLeFxzppaJEq1kdTExM4OLigqCgIFWZUqlEUFAQ3N3dNW7j7u6uVh8ADh48mGV9IiIiIqKCoHWqg7+/P3x9fdGkSRM0bdoUCxYsQGJiIgYOHAgAGDBgACpVqoTZs2cDAEaNGoVWrVrhhx9+wIcffoj169fj3LlzWLZsWf6eCRERERFRNrQOfHv16oUHDx5g2rRpiI2NRaNGjbBv3z7VDWy3b9+GgUHGQPL//vc/rFu3DlOmTMGkSZNQs2ZNbN++HfXr18+/sygGTE1NERAQkCmFQ9+wHyT2Qwb2hcR+kNgPGdgXRPlP63l8iYiIiIiKo1w9spiIiIiIqLhh4EtEREREeoGBLxERERHpBQa+RERERKQXGPgWkunTp6N27dqwsLBAmTJl4OnpiTNnzui6WYUqJSUF48ePR4MGDWBhYYGKFStiwIABuHv3rq6bVui2bt2K9u3bq55GGB4erusm6cTixYvh6OgIMzMzuLm5ITQ0VNdNKnTHjh1D586dUbFiRSgUCmzfvl3XTdKJ2bNnw9XVFaVLl0b58uXh4+ODyMhIXTer0P36669o2LCh6qEV7u7u2Lt3r66bRVRiMPAtJO+99x4WLVqEiIgInDhxAo6Ojmjfvj0ePHig66YVmhcvXiAsLAxTp05FWFgYtm7disjISHTp0kXXTSt0iYmJeP/99zFnzhxdN0VnNmzYAH9/fwQEBCAsLAxOTk7w8vLC/fv3dd20QpWYmAgnJycsXrxY103RqaNHj2L48OE4ffo0Dh48iJSUFLRv3x6JiYm6blqhqly5Mr777jucP38e586dQ5s2beDt7Y0rV67oumlEJQKnM9ORhIQEWFtb49ChQ2jbtq2um6MzZ8+eRdOmTfHvv/+iSpUqum5OoYuOjka1atVw4cIFNGrUSNfNKVRubm5wdXXFokWLAMinQDo4OGDkyJGYMGGCjlunGwqFAtu2bYOPj4+um6JzDx48QPny5XH06FG0bNlS183RqbJly2Lu3LkYNGiQrptCVOxxxFcHkpOTsWzZMlhbW8PJyUnXzdGp+Ph4KBQK2NjY6LopVIiSk5Nx/vx5eHp6qsoMDAzg6emJU6dO6bBlVFTEx8cDkEGfvkpLS8P69euRmJgId3d3XTeHqETQ+sltlHu7du1C79698eLFC1SoUAEHDx6Era2trpulM69evcL48ePRp08fWFlZ6bo5VIgePnyItLQ01RMf09nZ2eH69es6ahUVFUqlEqNHj0bz5s317imfABAREQF3d3e8evUKlpaW2LZtG+rWravrZhGVCBzxLQB//PEHLC0tVa/jx48DAFq3bo3w8HCcPHkSHTp0QM+ePUt0PmNW/QDIG9169uwJIQR+/fVXHbay4GXXD0SU2fDhw3H58mWsX79e103RiVq1aiE8PBxnzpzBsGHD4Ovri6tXr+q6WUQlAkd8C0CXLl3g5uamWq5UqRIAwMLCAjVq1ECNGjXQrFkz1KxZEytXrsTEiRN11dQClVU/pAe9//77Lw4fPlziR3uz6gd9ZmtrC0NDQ8TFxamVx8XFwd7eXketoqJgxIgR2LVrF44dO4bKlSvrujk6YWJigho1agAAXFxccPbsWSxcuBBLly7VccuIij8GvgWgdOnSKF269FvrKZVKJCUlFUKLdENTP6QHvTdv3sSRI0fwzjvv6Kh1hSen7wd9YmJiAhcXFwQFBalu5FIqlQgKCsKIESN02zjSCSEERo4ciW3btiE4OBjVqlXTdZOKjJL+t4KoMDHwLQSJiYn49ttv0aVLF1SoUAEPHz7E4sWLcefOHfTo0UPXzSs0KSkp6N69O8LCwrBr1y6kpaUhNjYWgLyBxcTERMctLDyPHz/G7du3VXMYp89Xam9vrzcjnv7+/vD19UWTJk3QtGlTLFiwAImJiRg4cKCum1aonj9/jr///lu1HBUVhfDwcJQtW1avZjoZPnw41q1bhx07dqB06dKq/xusra1RqlQpHbeu8EycOBEffPABqlSpgmfPnmHdunUIDg7G/v37dd00opJBUIF7+fKl+Oijj0TFihWFiYmJqFChgujSpYsIDQ3VddMKVVRUlACg8XXkyBFdN69QrV69WmM/BAQE6Lpphernn38WVapUESYmJqJp06bi9OnTum5SoTty5IjG94Kvr6+um1aosvq/YfXq1bpuWqH65JNPRNWqVYWJiYkoV66caNu2rThw4ICum0VUYnAeXyIiIiLSC5zVgYiIiIj0AgNfIiIiItILDHyJiIiISC8w8CUiIiIivcDAl4iIiIj0AgNfIiIiItILDHyJiIiISC8w8CUiIiIivcDAl4goG3fv3oWFhQVmzZpVqMddsWIFDA0NERERUajHJSIqyRj4EhUAhUKh1asoE0Jg69at6Nq1KypXrgxTU1OULl0aTk5OGDNmDK5evarrJmYrMDAQCoUCgYGBudp+8uTJMDc3xxdffAEA8PDw0Op3GxwcrNrXjRs3MHLkSNSrVw9WVlYwNTWFg4MDunfvji1btkCpVKrq+vr6omrVqhg3blxeTp+IiF5jpOsGEJVEAQEBmcoWLFiA+Ph4jeuKqsePH6NHjx44fPgwbGxs0K5dO7z77rtITk7GlStX8Msvv+Cnn35CUFAQPDw8dN3cfHfz5k2sXbsWkydPhqWlJQDAz88v07lu374dFy9ehK+vLxwdHdXWpS//8MMPGD9+PJRKJd5//320a9cO5ubmiImJwaFDh7BlyxZ88sknWLlyJQDA2NgYY8aMwRdffIGQkBA0b968oE+XiKjkE0RUKKpWrSqK00cuJSVFtGzZUgAQ/fr1E/Hx8Znq3L17VwwcOFBs375dBy3MmdWrVwsAYvXq1Vpv++WXXwoA4saNG9nW8/X1FQDEkSNHNK5funSpACAcHR3F+fPnM61PSUkRK1asEL6+vmrl9+/fF0ZGRqJfv35at52IiDIrPn+FiYo5TYFvVFSUACB8fX3F1atXhY+PjyhbtqwAIKKiotTWawJAtGrVKlN5QkKCmDZtmqhbt64wMzMT1tbWon379uL48eM5bu+qVasEANGyZUuRlpaWbd1Xr16pLUdERIgePXqIcuXKCRMTE+Ho6ChGjRolHj58mONzEEL2WdWqVdXK0oPMf/75RyxcuFDUqlVLmJiYiCpVqojp06ertTW9rqbX26SlpYly5cqJRo0avbVudoHvkydPhJWVlTAxMRFXrlzJdj9v9qMQQnh6egozMzPx7Nmzt7aDiIiyx1QHoiLg77//RrNmzdCgQQP4+fnh0aNHMDExQXJystb7evz4MVq2bIkrV66gefPmGDp0KBISErBjxw60bt0amzZtgo+Pz1v3k/6V+5QpU2BgkP3tAKampqqfT5w4AS8vLyQnJ6N79+5wdHTEqVOnsHDhQuzatQunT5+Gra2t1uf1pnHjxuHo0aPo1KkTvLy8sH37dkyfPh3Jycn49ttvAQA+Pj54+vQpduzYAW9vbzRq1CjH+4+IiMCDBw/QrVu3PLVz8+bNSEhIwMcff4y6detmW/f1fkzn7u6OQ4cO4eTJk2jfvn2e2kJEpO8Y+BIVASEhIZg2bRpmzJihVh4dHa31vkaOHIkrV65g+fLl+PTTT1Xls2fPRpMmTfDZZ5+hQ4cOMDMzy3IfqampCA0NhZGREVq0aJHjYyuVSvj5+eHFixfYt28fvLy8VOu++uorzJ07F+PHj1cF1XkRFhaGS5cuoUKFCgCAqVOnombNmvj5558REBAAExMTtcDXx8cHfn5+Od5/SEgIAMDFxSVP7UzfT5s2bXK1fZMmTVT7YeBLRJQ3nNWBqAiwt7fH5MmT87yfhw8fYsOGDWjTpo1a0AsA5cuXx7hx4/DgwQMcOnQo2/08evQIKSkpsLW1zTZAflNISAhu3bqFDz74QC3oBYBp06ahbNmyWLduXa5Gst80depUVdALALa2tvD29sazZ88QGRmZ5/3/999/AAA7O7s87Sc2NhYAULly5Vxtn3789PYQEVHuccSXqAhwcnKCiYlJnvdz9uxZpKWlISkpCdOnT8+0/ubNmwCA69evo1OnTnk+3psuXLgAABpneLC0tESTJk1w4MABREZGokGDBnk6lqaR2PTg8unTp3naNyCDfwCwsbHJ877yomzZsgDkRQ0REeUNA1+iIiCvo4rpHj9+DECOvKZ/xa5JYmJitvt55513YGxsjEePHiEpKUlj7qkmCQkJALI+n/QR2vR6eWFlZZWpzMhI/peWlpaW5/2XKlUKAPDq1as87cfe3h4AcOfOnVxt//LlSwCAubl5ntpBRERMdSAqErJ6iEX6TWWpqamZ1sXHx2cqSw8Gx44dCyFnbdH4ettcwkZGRmjatClSUlJw7NixHJ9H+vHj4uI0rk//2v/1oFWhUGg8P0DzORaWcuXKAci4mMit9Pl3g4KCcrV9+vHT20NERLnHwJeoCEv/ml3TaGF6WsHrXF1doVAocOrUqTwfe9CgQQCAWbNmQQiRbd2kpCQAgLOzMwCoPa0sXWJiIs6dO4dSpUqhVq1aqvIyZcpoPL/o6Oh8SVkwNDQEoP0ocHoqRl7zhbt37w4rKyts2bIF169fz7Zuej++Lv34eU0NISIiBr5ERZqVlRVq1aqFEydO4O+//1aVP3v2DBMnTsxU397eHj179sTJkycxd+5cjQHrmTNn8OLFi7ceu3///mjRogWCg4MxcOBAPHv2LFOduLg4DB48GPv27QMgRzerV6+OvXv3ZrqB7ptvvsGjR4/Qp08ftXxmV1dXREdH4+jRo6qy5ORk+Pv7v7WNOZGeIxsTE6PVdi1atICBgQHOnDmTp+Pb2Nhg7ty5SEpKwocffojw8PBMddLS0rBmzRoMHTo007r047dq1SpP7SAiIub4EhV5Y8eOxWeffQZ3d3f06NEDSqUSe/fuhaurq8b6v/zyCyIjI/HVV1/ht99+g7u7O2xsbBATE4Nz587h5s2buHfv3ltzRo2MjLB9+3b06NEDa9aswc6dO9G+fXtUq1YNycnJuHr1KoKDg5GSkoJ+/foBkKkZgYGB8PLyQseOHdGjRw9UrVoVp06dQnBwMKpXr47vvvtO7Tj+/v44cOAAOnbsiD59+sDc3BwHDx6EjY2N2qwNueXu7o5SpUphwYIFePLkiSplYMqUKdluV6ZMGbRq1QonTpzAq1evtJrd4k2fffYZEhISMGHCBDRu3BgtW7aEs7MzSpUqhTt37iAoKAh37tzJNBOHEAJBQUGoU6cO3nvvvVwfn4iI/p+unpxBpG/e9uS27CxevFjUrFlTGBsbiypVqohp06aJ5OTkLJ969uLFC/H9998LFxcXYWFhIUqVKiWqVasmfHx8xNq1a0VKSkqO261UKsXmzZuFj4+PqFixojAxMRHm5uaifv364osvvhBXr17NtM2lS5dE9+7dha2trTA2NhZVq1YVo0aNEg8ePNB4jE2bNokGDRoIExMTYW9vL0aOHCmePXuW7ZPboqKiMu0nICBA4xPUdu/eLVxdXUWpUqVy/OQ2IYTYsGGDACA2bNiQbb23PbI43fXr18WIESNE3bp1haWlpTA2NhaVKlUSPj4+YvPmzUKpVKrVDw4OFgDEggULctReIiLKnkKItyTvERHpqZSUFNSqVQvVq1fHwYMHC/34/fr1w969e3Hr1i2dT6tGRFQSMMeXiCgLxsbGmD17tuqRwYXpxo0bWL9+PaZMmcKgl4gonzDHl4goG7169cLt27dVD7QoLP/99x8CAgIwfPjwQj0uEVFJxlQHIiIiItILTHUgIiIiIr3AwJeIiIiI9AIDXyIiIiLSCwx8iYiIiEgvMPAlIiIiIr3AwJeIiIiI9AIDXyIiIiLSCwx8iYiIiEgvMPAlIiIiIr3wf2bFPNz+Gz/JAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "action_history = {tc: [1, 1, 1, 1] for tc in range(-agent.env.tc_cap, agent.env.tc_cap + 1)}\n",
    "# just initialize all counts to 1 to make code compact and computationally faster\n",
    "\n",
    "for episode in tqdm(range(5000000)):\n",
    "    state = agent.env.reset()\n",
    "    done = False\n",
    "    \n",
    "    while not done:\n",
    "        action = agent.choose_action(state, deterministic=True)\n",
    "        action_history[state[-1]][action] += 1\n",
    "        next_state, reward, done = agent.env.step(action)\n",
    "        state = next_state\n",
    "\n",
    "\n",
    "action_labels = ['Hit', 'Stand', 'Surrender', 'Double Down']\n",
    "action_colors = ['blue', 'green', 'red', 'purple']\n",
    "action_mapping = {0: 'Hit', 1: 'Stand', 2: 'Surrender', 3: 'Double Down'}\n",
    "\n",
    "hit_p, stand_p, surrender_p, double_p = [], [], [], []\n",
    "tc_cap = agent.env.tc_cap\n",
    "true_counts = list(range(-tc_cap, tc_cap + 1))\n",
    "\n",
    "for tc in true_counts:\n",
    "    actions = action_history[tc]\n",
    "    total = sum(actions)\n",
    "    hit_p.append(actions[0] / total)\n",
    "    stand_p.append(actions[1] / total)\n",
    "    surrender_p.append(actions[2] / total)\n",
    "    double_p.append(actions[3] / total)\n",
    "    \n",
    "x = np.arange(len(true_counts))\n",
    "bottom_surrender = np.array(hit_p) + np.array(stand_p)\n",
    "bottom_double = bottom_surrender + np.array(surrender_p)\n",
    "\n",
    "plt.figure()\n",
    "plt.bar(x, hit_p, color=action_colors[0], label=action_labels[0])\n",
    "plt.bar(x, stand_p, bottom=hit_p, color=action_colors[1], label=action_labels[1])\n",
    "plt.bar(x, surrender_p, bottom=bottom_surrender, color=action_colors[2], label=action_labels[2])\n",
    "plt.bar(x, double_p, bottom=bottom_double, color=action_colors[3], label=action_labels[3])\n",
    "plt.xlabel('True Count (TC)', fontsize=14)\n",
    "plt.xticks(x, true_counts)\n",
    "plt.ylim(0, 1)\n",
    "plt.legend(title='Actions', bbox_to_anchor=(1.01, 1), loc='upper left')\n",
    "\n",
    "for i in range(len(true_counts)):\n",
    "    cumulative = 0\n",
    "    for prop in [hit_p[i], stand_p[i], surrender_p[i], double_p[i]]:\n",
    "        if prop > 0:\n",
    "            plt.text(x[i], cumulative + prop / 2, f'{prop*100:.1f}%', ha='center', va='center', color='white', fontsize=8)\n",
    "            cumulative += prop\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [01:56<00:00, 85.55it/s]\n"
     ]
    }
   ],
   "source": [
    "outcome = []\n",
    "max_loss = []\n",
    "\n",
    "for _ in tqdm(range(10000)):\n",
    "    cummulative_r = 0\n",
    "    history = [0]\n",
    "    for _ in range(50):\n",
    "        agent.env.draw_card()\n",
    "\n",
    "    for episode in range(600):\n",
    "        state = agent.env.reset()\n",
    "        done = False\n",
    "        \n",
    "        while not done:\n",
    "            action = agent.choose_action(state, deterministic=True)\n",
    "            next_state, reward, done = agent.env.step(action)\n",
    "            state = next_state\n",
    "        \n",
    "        if true_count >= 3:\n",
    "            cummulative_r += 10*reward\n",
    "        else:\n",
    "            cummulative_r += reward\n",
    "        history.append(cummulative_r)\n",
    "\n",
    "    outcome.append(cummulative_r)\n",
    "    max_loss.append(min(history))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAGwCAYAAACjPMHLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACAtklEQVR4nO3dd3xT1fvA8U/SXTqBTii0rJbSsgWKMq0UZIiggjIFRZGNIiAg4mL4c35VcAEOFEURmWWUJVLZq5RNoYwOoHTTldzfH1dCQwu00DZN+7xfr7wk554kz21q8vTcc56jURRFQQghhBBCAKA1dQBCCCGEEOWJJEdCCCGEEPlIciSEEEIIkY8kR0IIIYQQ+UhyJIQQQgiRjyRHQgghhBD5SHIkhBBCCJGPpakDMDd6vZ7Lly/j6OiIRqMxdThCCCGEKAJFUUhLS8Pb2xut9u5jQ5IcFdPly5fx8fExdRhCCCGEuA8XLlygZs2ad+0jyVExOTo6AuoP18nJycTRCCGEEKIoUlNT8fHxMXyP340kR8V081Kak5OTJEdCCCGEmSnKlBiZkC2EEEIIkY8kR0IIIYQQ+UhyJIQQQgiRj8w5KiU6nY7c3FxThyGKycrKCgsLC1OHIYQQwoQkOSphiqIQHx9PcnKyqUMR98nFxQVPT0+pYyWEEJWUJEcl7GZi5O7ujr29vXzBmhFFUcjMzCQxMREALy8vE0ckhBDCFCQ5KkE6nc6QGFWrVs3U4Yj7YGdnB0BiYiLu7u5yiU0IISohmZBdgm7OMbK3tzdxJOJB3Hz/ZM6YEEJUTpIclQK5lGbe5P0TQojKTS6rCSGEEKJc0OkVdsckkZiWhbujLa38qmKhLfs/WM1m5Gj27Nk89NBDODo64u7uTu/evTlx4oRRn6ysLEaNGkW1atVwcHCgb9++JCQkGPWJjY2le/fu2Nvb4+7uzqRJk8jLyyvLUxFCCCHEbcKj4nhk7mae/eZfxi09yLPf/MsjczcTHhVX5rGYTXK0bds2Ro0axb///svGjRvJzc2lS5cuZGRkGPpMmDCBVatWsWzZMrZt28bly5fp06eP4bhOp6N79+7k5OSwc+dOvv/+exYvXsybb75pilO6K51eIfLMNf46eInIM9fQ6RVThySEEEKUivCoOEb+tJ+4lCyj9viULEb+tL/MEySNoihm+a175coV3N3d2bZtG+3btyclJQU3Nzd+/vlnnnrqKQCOHz9Ow4YNiYyMpE2bNqxbt44ePXpw+fJlPDw8AFiwYAGTJ0/mypUrWFtb3/N1U1NTcXZ2JiUlpcDGs1lZWcTExODn54etre19n1t4VByzVkUb/ZJ4Odsys2cgXYNKb3n5hQsXmDlzJuHh4Vy9ehUvLy969+7Nm2++WeTVd+fOncPPz48DBw7QtGnTUou1NJXU+yiEEOLedHqFR+ZuLpAY3aQBPJ1t2TG58wNdYrvb9/ftzGbk6HYpKSkAVK1aFYB9+/aRm5tLaGiooU9AQAC1atUiMjISgMjISIKDgw2JEUBYWBipqakcPXq00NfJzs4mNTXV6FaaTJU9nz17lpYtW3Lq1Cl++eUXTp8+zYIFC4iIiCAkJISkpKRSeV0hhBCV2+6YpDsmRgAKEJeSxe6YsvseMsvkSK/XM378eB5++GGCgoIAtfiitbU1Li4uRn09PDyIj4839MmfGN08fvNYYWbPno2zs7Ph5uPjU6xYFUUhMyevSLe0rFxmrjxKYUN5N9veWhlNWlZukZ6vOIOCo0aNwtramg0bNtChQwdq1apFt27d2LRpE5cuXWLatGmAupJrxYoVRo91cXFh8eLFAPj5+QHQrFkzNBoNHTt2NPRbuHAhjRo1wsbGBi8vL0aPHm04FhsbyxNPPIGDgwNOTk4888wzRvPF3nrrLZo2bcrChQupVasWDg4OvPLKK+h0OubNm4enpyfu7u689957RrElJyfzwgsv4ObmhpOTE507d+bQoUNF/rkIIYQoXYlpd06M7qdfSTDL1WqjRo0iKiqKHTt2lPprTZ06lYkTJxrup6amFitBupGrI/DN9SUSiwLEp2YR/NaGIvWPfjsMe+t7v8VJSUmsX7+e9957z1AE8SZPT08GDBjAr7/+ypdffnnP59q9ezetWrVi06ZNNGrUyHCpcv78+UycOJE5c+bQrVs3UlJS+OeffwA12b2ZGG3bto28vDxGjRpFv3792Lp1q+G5z5w5w7p16wgPD+fMmTM89dRTnD17lgYNGrBt2zZ27tzJsGHDCA0NpXXr1gA8/fTT2NnZsW7dOpydnfnqq6949NFHOXnypGHUUQghhOm4O9oUsV/ZTXMwu+Ro9OjRrF69mu3bt1OzZk1Du6enJzk5OSQnJxuNHiUkJODp6Wnos3v3bqPnuzk6cbPP7WxsbLCxKdobZ65OnTqFoig0bNiw0OMNGzbk+vXrXLly5Z7P5ebmBkC1atWMfqbvvvsur776KuPGjTO0PfTQQwBERERw5MgRYmJiDInnDz/8QKNGjdizZ4+hn16vZ+HChTg6OhIYGEinTp04ceIEa9euRavV4u/vz9y5c9myZQutW7dmx44d7N69m8TERMN7+H//93+sWLGC33//nREjRtzHT0sIIURJ0esV1h9NuGufm3OOWvmV3R+0ZpMcKYrCmDFj+PPPP9m6davh8s1NLVq0wMrKioiICPr27QvAiRMniI2NJSQkBICQkBDee+89w9YQABs3bsTJyYnAwMBSidvOyoLot8OK1Hd3TBJDF+25Z7/Fzz9UpF8SO6vibX1RWnPzExMTuXz5Mo8++mihx48dO4aPj4/RiFxgYCAuLi4cO3bMkBz5+vri6Oho6OPh4YGFhQVardao7ebeaIcOHSI9Pb3AZPIbN25w5syZEjs/IYQQxZen0zNl+RF+33fR0KYBo6klN6dfz+wZWKb1jswmORo1ahQ///wzf/31F46OjoY5Qs7OztjZ2eHs7Mzw4cOZOHEiVatWxcnJiTFjxhASEkKbNm0A6NKlC4GBgQwaNIh58+YRHx/P9OnTGTVqVKmNDmk0miJd2gJoV98NL2db4lOyCp13dDN7blffrUR/SerVq4dGo+HYsWM8+eSTBY4fO3YMV1dX3Nzc0Gg0BZKoe22zcfuluvtlZWVldF+j0RTaptfrAUhPT8fLy8vo0txNt89NE0IIUXay83SM/eUA648mYKHVMK9vY6rYWBRYqe1ZBiu1C2M2ydH8+fMBjCb4AixatIihQ4cC8PHHH6PVaunbty/Z2dmEhYUZzZOxsLBg9erVjBw5kpCQEKpUqcKQIUN4++23y+o07spCq2Fmz0BG/rS/TLPnatWq8dhjj/Hll18yYcIEo2QmPj6eJUuWMHjwYDQaDW5ubsTF3Voxd+rUKTIzMw33b84x0ul0hjZHR0d8fX2JiIigU6dOBV6/YcOGXLhwgQsXLhhGj6Kjo0lOTn6gEb3mzZsTHx+PpaUlvr6+9/08QgghSk5Gdh4jftzLP6evYW2p5fNnm9GlkToN47FAz3JRIdtskqOiXPKxtbXliy++4Isvvrhjn9q1a7N27dqSDK1EdQ3yYv7A5mWePX/++ee0bduWsLAw3n33Xfz8/Dh69CiTJk2iRo0ahlVgnTt35vPPPyckJASdTsfkyZONRm/c3d2xs7MjPDycmjVrYmtri7OzM2+99RYvv/wy7u7udOvWjbS0NP755x/GjBlDaGgowcHBDBgwgE8++YS8vDxeeeUVOnToQMuWLe/7nEJDQwkJCaF3797MmzePBg0acPnyZdasWcOTTz75QM8thBCi+JIzcxi6aA8HLyRTxdqCb4a0pG3d6objFloNIXWLVlevNJnlUv6KrmuQFzsmd+aXF9vwaf+m/PJiG3ZM7lyqw4r169dn79691KlTh2eeeYa6desyYsQIOnXqRGRkpGFl14cffoiPjw/t2rXjueee47XXXjPsYg9gaWnJZ599xldffYW3tzdPPPEEAEOGDOGTTz7hyy+/pFGjRvTo0YNTp04B6qWwv/76C1dXV9q3b09oaCh16tTh119/faBz0mg0rF27lvbt2/P888/ToEED+vfvz/nz5wuUdBBCCFG6ElOz6PfVvxy8kIyLvRVLXmxjlBiVJ2ZbIdtUyqJCtjAteR+FEKJkxV7LZOB3u4hNysTDyYYfh7emgYfjvR9YgopTIdtsLqsJIYQQwvyciE9j0He7SEzLpnY1e34a3hqfqvb3fqAJSXIkhBBCiFJxIPY6QxftIeVGLgGejvwwrBXuTuV/RF6SIyGEEEKUuH9OX+XFH/aSmaOjWS0XFg19CBf7e2/wXh5IciSEEEKIEhUeFc/YXw6Qo9PTrn51vhrUosg1/8oD84lUCCGEEOXe7/su8vrvh9Ar0C3Ik0/6N8XGsng7NpiaJEdCCCGEKBELd8Tw9upoAJ5pWZP3nwzG0sL8qgZJciSEEEKIB6IoCp9sOsWnEWr9uhce8WNa94ZoNGVf3bokSHIkhBBCiPum1yu8vTqaxTvPAfBalwaM6lTPbBMjkORICCGEEPcpT6fn9T8Os3z/JQDefqIRg0N8TRtUCTC/C4GVhV4HMX/Dkd/V/+p1937MAxg6dCgajYaXX365wLFRo0ah0WgMG/yWlsWLF+Pi4lKqryGEEKJkZOXqGLlkP8v3X8JCq+GTfk0rRGIEMnJUPkWvhPDJkHr5VpuTN3SdC4G9Su1lfXx8WLp0KR9//DF2dnaAupXGzz//TK1atUrtdYUQQpiX9Ow8Xvx+L5Fnr2FtqeXL55oTGlhx9qyUkaPyJnol/DbYODECSI1T26NXltpLN2/eHB8fH5YvX25oW758ObVq1aJZs2ZGfcPDw3nkkUdwcXGhWrVq9OjRgzNnzhiO//DDDzg4OBg2lwV45ZVXCAgIIDMz877ii42N5YknnsDBwQEnJyeeeeYZEhISDMcPHTpEp06dcHR0xMnJiRYtWrB3714Azp8/T8+ePXF1daVKlSo0atSItWvX3lccQghRmV3PyGHAN/8SefYaDjaWfP98qwqVGIEkR6VPUSAno2i3rFRY9zpQ2F7A/7WFT1b7FeX57mNP4WHDhrFo0SLD/YULF/L8888X6JeRkcHEiRPZu3cvERERaLVannzySfR6PQCDBw/m8ccfZ8CAAeTl5bFmzRq+/fZblixZgr198ffU0ev1PPHEEyQlJbFt2zY2btzI2bNn6devn6HPgAEDqFmzJnv27GHfvn1MmTIFKysrQL00mJ2dzfbt2zly5Ahz587FwcGh2HEIIURlFp+SxTNfRXLoYgqu9lb8/GJrQupWM3VYJU4uq5W23Ex437uEnkxRR5Tm+BSt+xuXwbpKsV5h4MCBTJ06lfPnzwPwzz//sHTpUrZu3WrUr2/fvkb3Fy5ciJubG9HR0QQFBQHw1Vdf0bhxY8aOHcvy5ct56623aNGiRbHiuSkiIoIjR44QExODj496/j/88AONGjViz549PPTQQ8TGxjJp0iQCAgIAqF+/vuHxsbGx9O3bl+DgYADq1KlzX3EIIURldf5aBgO+3cXF6zfwdLLlpxdaUc/d0dRhlQoZORJG3Nzc6N69O4sXL2bRokV0796d6tWrF+h36tQpnn32WerUqYOTkxO+vr6AmoTc5Orqynfffcf8+fOpW7cuU6ZMue+4jh07ho+PjyExAggMDMTFxYVjx44BMHHiRF544QVCQ0OZM2eO0WW+sWPH8u677/Lwww8zc+ZMDh8+fN+xCCFEZXM8PpWnFkRy8foNfKvZs+zlkAqbGIGMHJU+K3t1BKcozu+EJU/du9+A36F226K99n0YNmwYo0ePBuCLL74otE/Pnj2pXbs233zzDd7e3uj1eoKCgsjJyTHqt337diwsLIiLiyMjIwNHx9L7n+mtt97iueeeY82aNaxbt46ZM2eydOlSnnzySV544QXCwsJYs2YNGzZsYPbs2Xz44YeMGTOm1OIRQoiKYH/sdZ5ftIeUG7kEeDryw/BWuDvamjqsUiUjR6VNo1EvbRXlVrezuiqNOxXO0oBTDbVfUZ7vPgtwde3alZycHHJzcwkLCytw/Nq1a5w4cYLp06fz6KOP0rBhQ65fv16g386dO5k7dy6rVq3CwcHBkHDdj4YNG3LhwgUuXLhgaIuOjiY5OZnAwEBDW4MGDZgwYQIbNmygT58+RvOnfHx8ePnll1m+fDmvvvoq33zzzX3HI4QQlcHfp64w4JtdpNzIpUVtV359KaTCJ0YgI0fli9ZCXa7/22DUBCn/hOr/Ep2uc9R+pcjCwsJwqcrCouBrubq6Uq1aNb7++mu8vLyIjY0tcMksLS2NQYMGMXbsWLp160bNmjV56KGH6NmzJ089defRMZ1Ox8GDB43abGxsCA0NJTg4mAEDBvDJJ5+Ql5fHK6+8QocOHWjZsiU3btxg0qRJPPXUU/j5+XHx4kX27NljmBs1fvx4unXrRoMGDbh+/TpbtmyhYcOGD/iTEkKIiis8Ko6xvxwkR6enfQM3Fgxsjr115UgbKsdZmpPAXvDMD3eoczSnVOsc5efk5HTHY1qtlqVLlzJ27FiCgoLw9/fns88+o2PHjoY+48aNo0qVKrz//vsABAcH8/777/PSSy8REhJCjRo1Cn3u9PT0AmUD6taty+nTp/nrr78YM2YM7du3R6vV0rVrV/73v/8BahJ37do1Bg8eTEJCAtWrV6dPnz7MmjULUJOuUaNGcfHiRZycnOjatSsff/zxg/yIhBCiwvpt7wWm/HEYvQLdg734uF9TrC0rz8UmjaLcx3rvSiw1NRVnZ2dSUlIKJBBZWVnExMTg5+eHre0DDjvqdeocpPQEcPBQ5xiV8oiRUJXo+yiEEGbm27/P8u4a9epB/4d8eO/JYCy05rtP2k13+/6+nYwclVdaC/BrZ+oohBBCVBKKovDRxpP8b/NpAF5qX4cp3QLMegPZ+yXJkRBCCFHJ6fUKs1Yd5ftItcbdpDB/XulYt1ImRiDJkRBCCFGp5er0vP77Yf48cAmNBt5+IohBbWqbOiyTkuRICCGEqKSycnWM/nk/m44lYqnV8OEzTXiiaeELZioTSY5KgcxxN2/y/gkhKoO0rFxe+H4vu2KSsLHUMn9gczoHVKwNZO+XJEcl6OYmp5mZmdjZ2Zk4GnG/MjMzgVvvpxBCVDRJGTkMXbSbwxdTcLCx5LshLWldp+JtIHu/JDkqQRYWFri4uJCYmAiAvb19pZ3MZo4URSEzM5PExERcXFwKLYAphBDmLi7lBoO+283pxHSqVrHmh2GtCKrhbOqwyhVJjkqYp6cngCFBEubHxcXF8D4KIURFEnM1g4Hf7uJS8g28nG35cXhr6rk7mDqsckeSoxKm0Wjw8vLC3d2d3NxcU4cjisnKykpGjIQQFVL05VQGL9zN1fRs/KpX4cfhrajpen8blFd0khyVEgsLC/mSFUIIUS7sO5/E84v2kJqVR6CXEz8Mb0V1BxtTh1VuSXIkhBBCVGDbTl7hpR/3kpWr5yFfV74d8hDOdrLg5G4kORJCCCEqqLVH4hi39AC5OoUODdxYMLAFdtZyVeNeJDkSQgghKqBf98QydfkR9Ar0aOzFR880xdpSa+qwzIJZ/ZS2b99Oz5498fb2RqPRsGLFCqPjiqLw5ptv4uXlhZ2dHaGhoZw6dcqoT1JSEgMGDMDJyQkXFxeGDx9Oenp6GZ6FEEIIUbq+3n6GyX+oidGzrWrxaf9mkhgVg1n9pDIyMmjSpAlffPFFocfnzZvHZ599xoIFC9i1axdVqlQhLCyMrKwsQ58BAwZw9OhRNm7cyOrVq9m+fTsjRowoq1MQQgghSo2iKHyw/jjvrz0OwMsd6vL+k0FYaKXmXnFoFDPdK0Gj0fDnn3/Su3dvQP2F8Pb25tVXX+W1114DICUlBQ8PDxYvXkz//v05duwYgYGB7Nmzh5YtWwIQHh7O448/zsWLF/H29r7n66ampuLs7ExKSgpOTk6ldn5CCCFEcej1Cm+ujOKnf2MBmNw1gJEd65o4qvKjON/fZjVydDcxMTHEx8cTGhpqaHN2dqZ169ZERkYCEBkZiYuLiyExAggNDUWr1bJr165Cnzc7O5vU1FSjmxBCCFGe5Or0TPjtID/9G4tGA+8/GSyJ0QOoMMlRfHw8AB4expvmeXh4GI7Fx8fj7u5udNzS0pKqVasa+txu9uzZODs7G24+Pj6lEL0QQghxf7Jydbz04z7+OngZS62Gz/o347nWtUwdllmrMMlRaZk6dSopKSmG24ULF0wdkhBCiEpIp1eIPHONvw5eIvLMNXR6hdSsXAYv3M3m44nYWmn5ZkhLeja59xQRcXcVZin/zb2wEhIS8PLyMrQnJCTQtGlTQ5/b9zzLy8sjKSnpjntp2djYYGMjVUSFEEKYTnhUHLNWRROXcmuBkbujDTZWWi4k3cDRxpLvhj5EK7+qJoyy4qgwI0d+fn54enoSERFhaEtNTWXXrl2EhIQAEBISQnJyMvv27TP02bx5M3q9ntatW5d5zEIIIcS9hEfFMfKn/UaJEUBiWjYXkm7gYGPJLyPaSGJUgsxq5Cg9PZ3Tp08b7sfExHDw4EGqVq1KrVq1GD9+PO+++y7169fHz8+PGTNm4O3tbVjR1rBhQ7p27cqLL77IggULyM3NZfTo0fTv379IK9WEEEKIsqTTK8xaFc3dlpXbWVvQ0EtWT5cks0qO9u7dS6dOnQz3J06cCMCQIUNYvHgxr7/+OhkZGYwYMYLk5GQeeeQRwsPDsbW1NTxmyZIljB49mkcffRStVkvfvn357LPPyvxchBBCiHvZHZNUYMTodlfSstkdk0RI3WplFFXFZ7Z1jkxF6hwJIYQoK38dvMS4pQfv2e/T/k15ommN0g/IjFXKOkdCCCFERePuaHvvTsXoJ4rGrC6rCSGEEJVFalYufx26dNc+GsDT2VYmY5cwSY6EEEKIcibiWALT/owiPvXWfCMNGE3Mvrlb2syegbJ3WgmT5EgIIYQoJ66lZzNrVTQrD10GoHY1e+b0aUzKjZwCdY48nW2Z2TOQrkFed3o6cZ8kORJCCCFMTFEUVh66zKxV0SRl5KDVwAvt6jAhtAF21hYAPBboye6YJBLTsnB3VC+lyYhR6ZDkSAghhDChuJQbTP8ziojj6g4OAZ6OzO3bmCY+Lkb9LLQaWa5fRiQ5EkIIIUxAr1f4ZU8ss9ceJz07DysLDWM61+flDnWxtpTF5KYkyZEQQghRxmKuZjDlj8PsikkCoFktF+b2bUwDD0cTRyZAkiMhhBCizOTp9Hy3I4aPNp4kO0+PnZUFk8L8GdLWV+YPlSOSHAkhhBBl4FhcKpP/OMzhiykAPFKvOrP7BONT1d7EkYnbSXIkhBBClKLsPB1fbD7Nl1vPkKdXcLK1ZHqPQJ5uURONRkaLyiNJjoQQQohSsu/8dSb/cZjTiekAhDXy4J0ngnB3ku0+yjNJjoQQQogSlpGdx/9tOMHinedQFKjuYM3bTwTRLchTRovMgCRHQgghRAn6+9QVpi4/wsXrNwDo27wmM3o0xMXe2sSRiaKS5EgIIYQoASmZuby3Nprf9l4EoIaLHe/3CaZDAzcTRyaKS5IjIYQQ4gGFR8Uz468orqRlo9HA4Da1mdQ1AAcb+Zo1R/KuCSGEEPcpMS2Lt1YeZe2ReADquFVhXt/GtPStauLIxIOQ5EgIIYQoJkVR+GP/Jd5ZHU3KjVwstBpe7lCHMZ3rY2tlYerwxAOS5EgIIYQohgtJmbzx5xH+PnUVgEbeTsx7qjGNvJ1NHJkoKZIcCSGEEEWg1yv8EHmOeetPkJmjw9pSy4TQBrzYzg9LC9kotiKR5EgIIYS4h9OJ6Uz54zB7z18HoJVvVWb3Daaum4OJIxOlQZIjIYQQ4g5ydXq+3n6WTzedIkenp4q1BVO6BTCgdW20slFshSXJkRBCCFGIqEspTPr9MMfiUgHo6O/Ge08GU8PFzsSRidImyZEQQgiRT1aujk82neKbv8+i0yu42Fsxs2cgvZvWkK0/KglJjoQQQoj/7I5JYsofhzl7NQOAHo29eKtXI6o72Jg4MlGWJDkSQghR6aVl5TIv/AQ//nseAA8nG955IogujTxNHJkwBUmOhBBCVGpbjicy7c8jXE7JAuDZVj5M6dYQZzsrE0cmTEWSIyGEEJVSUkYO76yO5s8DlwCoVdWeOX2CaVuvuokjE6YmyZEQQohKRVEUVh+O462VR7mWkYNWA8Me9uPVLv7YWcvWH0KSIyGEEJVIfEoW01dEselYAgANPByY27cxzWq5mjgyUZ5IciSEEKLCUxSFpXsu8P6aY6Rl52FloWFUp3q80rEe1pay9YcwJsmREEKICkGnV9gdk0RiWhbujra08quKhVbD+WsZTPnjCJFnrwHQxMeFeX0b4+/paOKIRXklyZEQQgizFx4Vx6xV0cT9t+IMwNPJlkfqVWP1kTiycvXYWml5rYs/zz/sh4Vs/SHuQpIjIYQQZi08Ko6RP+1Hua09PjWL3/erK9Ha1q3G7D7B1K5WpewDFGZHkiMhhBBmS6dXmLUqukBilJ+znRU/DGuFpYXMLRJFU2l/U7744gt8fX2xtbWldevW7N6929QhCSGEKKbdMUlGl9IKk3Ijlz3nrpdRRKIiqJTJ0a+//srEiROZOXMm+/fvp0mTJoSFhZGYmGjq0IQQQhRDYtrdE6Pi9hMCKulltY8++ogXX3yR559/HoAFCxawZs0aFi5cyJQpU4z6Zmdnk52dbbifmpoKQHx8PBkZGYZ2W1tbXF1dycvL48qVKwVe08vLC4CrV6+Sm5trdMzFxQU7OzsyMjIMz3+TtbU11apVQ6/Xk5CQUOB53d3dsbCwICkpyShOAEdHRxwcHLhx4wbJyclGxywtLXFzcwMgLi6uwPNWr14dKysrkpOTuXHjhtGxKlWq4OTkRHZ2NklJSUbHtFotHh4eACQkJKDX642OV61aFRsbG1JTU41+fgB2dna4uLiQm5vL1atXC8R082d45coV8vLyjI7d/Bmmp6eTlpZmdMzGxoaqVaui0+kKTYA9PDzQarVcu3aNnJwco2NOTk5UqVKl0J+hlZUV1aurlXQL+xm6ublhaWnJ9evXycoy/mB2cHDA0dGx0J+hhYUF7u7uQOE/w2rVqmFtbV3oz9De3h5nZ+dCf4YajQZPT3WfqMJ+hq6urtja2hb6M7z5+32nn6GnpycajabQn6GzszP29vZkZmaSkpJidOzm77eiKMTHxxd43pu/34X9DG/+fmdlZXH9uvGoQP7f7/j4eBTF+KLLzd/vlJQUMjMzjY7d/P3Oycnh2rVrRsfy/34nJiai0+mMjt/8/U5LSyM9Pd3omHxGqEryMyLlRi4b9pyimiYDBQ1Jij0AzpobWGL8vK7W6n/lM6LyfkbcHvPdVLrkKCcnh3379jF16lRDm1arJTQ0lMjIyAL9Z8+ezaxZswq0L1q0CFtbW8P94OBg+vTpQ2pqKl9//XWB/jNnzgTgr7/+4uLFi0bHnnzySRo3bszRo0dZt26d0bG6desycOBAcnNzC33e1157jSpVqrB+/XpOnjxpdKxLly6EhIRw9uxZfv/9d6Njnp6evPTSSwB89913BT7kR44cibu7O9u3b+fAgQNGxx5++GFCQ0OJi4vj+++/Nzrm6OjIxIkTAViyZEmBX8YhQ4bg6+vL7t27+eeff4yONWvWjF69enH9+vUC52phYcH06dMBWL58eYH/SZ566ikaNWrEkSNH2LBhg9GxBg0a8Oyzz5KVlVXoz3DKlCnY2Niwbt06zpw5Y3SsW7dutGrVilOnTvHnn38aHatZsybDhw8HKPR5x4wZQ9WqVdmyZQtHjhwxOtahQwc6duzIhQsXWLJkidExV1dXxo4dC8APP/xQ4Mt72LBh+Pj4EBkZyb///mt0rGXLlnTv3p2rV68WiMna2trwe79s2bICX9D9+/fH39+fAwcOsHnzZqNjgYGBPP3002RkZBR6rtOmTcPS0pJVq1Zx/vx5o2M9e/akefPmHD9+nFWrVhkdq127NkOHDkWn0xX6vBMmTMDJyYlNmzYRHR1tdKxz5860a9eO8+fPs3TpUqNjbm5uvPLKK4D6/+rtH8YjRozAy8uLHTt2sHfvXqNjbdq0ISwsjISEBBYuXGh0zN7enkmTJgGwdOnSAknZgAEDqFevHvv27WPbtm1Gx+QzQlUSnxGJV6/x7X/n6g70sgWdouGHrBYAdLCOoZrW+P8bV30joIZ8RlTiz4jbk6e70Si3/0lVwV2+fJkaNWqwc+dOQkJCDO2vv/4627ZtY9euXUb9Cxs58vHx4cSJEzg63qqRIX8VqmTk6Bb5q1AlI0cq+YxQPchnhK2tLXsuZzN37VGSk9T3xre6A23rVuXnXRdIUuxRKDhy9MbjDXm8ZT35jKByf0akpaXh7+9PSkoKTk5OBZ7L6GchyZHqTsnR7VJTU3F2di7SD1cIIUTJiL6cyrtrotl5Rk2KqjvYMCmsAU+18MFCqym0zpGXsy0zewbSNcjLVGGLcqQ439/Fvqy2fft22rZti6Wl8UPz8vLYuXMn7du3L+5Tlqnq1atjYWFR4C+shIQEQ8YshBCifLiSls2HG07w694LKApYW2p54RE/XulUDwebW99DXYO8eCzQs9AK2UIUV7GTo06dOhEXF2cY0rspJSWFTp06FRhmLm+sra1p0aIFERER9O7dGwC9Xk9ERASjR482bXBCCCEAyMrVsfCfGL7ccob0bPXyTvfGXkzpGoBPVftCH2Oh1RBSt1pZhikqqGInR4qioNEUzMSvXbtGlSrmUXl04sSJDBkyhJYtW9KqVSs++eQTMjIyDKvXhBBCmIaiKKw9Es/sdce4eF2dy9S4pjMzegTykG9VE0cnKosiJ0d9+vQB1AlbQ4cOxcbGxnBMp9Nx+PBh2rZtW/IRloJ+/fpx5coV3nzzTeLj42natCnh4eGGSYJCCCHK3uGLybyzOtpQsNHTyZbXu/rTu2kNtHJ5TJShIidHzs7OgJrVOzo6YmdnZzhmbW1NmzZtePHFF0s+wlIyevRouYwmhBDlQHxKFvPWH2f5f/ug2Vppeal9XV7qUAd760pXcUaUA0X+rVu0aBEAvr6+hroZQgghxP26kaPj6+1nWbDtDDdy1fmqfZrVYFJXf7yc7e7xaCFKz30t5c/Ly2Pr1q2cOXOG5557DkdHRy5fvoyTkxMODg6lEWe5IUv5hRDiwej1Cn8dusS88BOGpfctarsyo0cgTX1cTBucqLBKdSn/+fPn6dq1K7GxsWRnZ/PYY4/h6OjI3Llzyc7OZsGCBfcduBBCiIpt3/kk3l59jEMXkgGo4WLH1McD6B7sVehiHyFModjJ0bhx42jZsiWHDh2iWrVbSyaffPJJs5pzJIQQouxcvJ7JnHXHWX1YrRRdxdqCVzrVY/gjfthaWZg4OiGMFTs5+vvvv9m5cyfW1tZG7b6+vly6dKnEAhNCCGH+0rPzmL/1NN/8HUNOnh6NBvq19GFilwa4O9re+wmEMIFiJ0d6vb7QQo8XL1402mtMCCFE5aXTK/yx7yIfbDjBlTR1T7c2daoyo0cgjbydTRydEHdX7OSoS5cufPLJJ4bdcTUaDenp6cycOZPHH3+8xAMUQghhXiLPXOOd1dFEx6mb5NauZs8bjzekS6CHzCsSZqHYq9UuXrxIWFgYiqJw6tQpWrZsyalTp6hevTrbt28vsK1IRSOr1YQQonDnr2Xw/tpjrD+q7l3paGvJ2M71Gdy2NjaWMq9ImFZxvr/veyn/0qVLOXz4MOnp6TRv3pwBAwYYFYasqCQ5EkIIY6lZuXy++TSL/okhV6dgodXwXKtajA+tTzUHm3s/gRBloFSX8gNYWloycODA+wpOCCFExZCn0/PLngt8vPEkSRk5ALRv4Mb07g1p4CFzUIX5uq/k6MSJE/zvf//j2LFjADRs2JDRo0cTEBBQosEJIYQon7afvMK7a6I5mZAOQD13B6Z1b0gn/4o9tUJUDsVOjv744w/69+9Py5YtCQkJAeDff/8lODiYpUuX0rdv3xIPUgghRPlwOjGd99ZEs+XEFQBc7K2YENqA51rXwspCa+LohCgZxZ5zVLduXQYMGMDbb79t1D5z5kx++uknzpw5U6IBljcy50gIURldz8jh04hT/PjveXR6BUuthiFtfRnbuT7O9lamDk9UFHodnN8J6Qng4AG124K2ZCbzl+qEbHt7ew4fPky9evWM2k+dOkWTJk3IzMwsfsRmRJIjIURlkpOn58d/z/NZxClSbuQCENrQgzceD6COW8XeS1OUseiVED4ZUi/fanPyhq5zIbDXAz99qU7I7tixI3///XeB5GjHjh20a9euuE8nhBCiHFIUhYhjiby/9hhnr2YAEODpyIwegTxcr7qJoxMVTvRK+G0wcNt4TWqc2v7MDyWSIBVVkZKjlStXGv7dq1cvJk+ezL59+2jTpg2gzjlatmwZs2bNKp0ohRBClJljcam8uyaaf05fA6C6gzWvdvHnmZY+WGiliKMoYXqdOmJ0e2IE/7VpIHwKBHQvsUts91Kky2pabdEm2Wk0mkK3FqlI5LKaEKKiupqezYcbTvLrnlj0ClhbaBn2iB+jOtXF0VbmFYlSEvM3fN/j3v2GrAa/+79CVeKX1fR6/X0HI4QQonzQ6RV2xySRmJaFu6MtrfyqYqHVkJ2nY9E/5/h882nSs/MAeDzYkyldG1Krmr2JoxYVXmoRN61PTyjdOPK5rzpHQgghzEt4VByzVkUTl5JlaPN0tqVXYy/WHY3nQtINAIJrODOjRyCt/KqaKlRRWSRfgP3fw+5vi9bfwaN048lHkiMhhKjgwqPiGPnT/gIzOuJTsvj67xgAPJxsmBQWQJ9mNdDKvCJRWvQ6OLUR9i2CUxtA+e/KlEZ7698FaNRVa7XbllmYkhwJIUQFptMrzFoVXehU15scbCzZNLGDzCsSpSctHvb/qI4UpVy41e7XHloOA0WB34f915j/t/W/RL3rnDKbjA2SHAkhRIW2OybJ6FJaYdKz84i6lEpI3WplFJWoFPR6iNkKexfBibWgV+ezYecKTQdAi+eher6yQFrLO9Q5mlOmy/hBkiMhhKjQElPvnhgZ+qUVrZ8Q95RxFQ4uUZOi6zG32n3aqKNEgU+AlW3BxwX2Upfrl1KF7OK47+QoMTGRxMTEAivZGjdu/MBBCSGEeHD7Y6/z2eZTRerr7ljIl5UQRaUoEBsJexdC9F+gy1HbbZygSX91lMgj8N7Po7V4oOX6JaXYydG+ffsYMmQIx44d42aJJI1Gg6IolaLOkRBClHeXkm8wd91xVh5SL09oKLy83s1jns62sjpN3J8byXBoqZoUXT1xq927mTpKFNQXrKuYLLz7VezkaNiwYTRo0IDvvvsODw8PNBpZ1SCEEOVBRnYeC7ad4evtZ8nO06PRwNMtatKilitTlh8BCp3qysyegVL5WhSdosCl/WpCFPUH5KllILCyh+Cn1FGiGs1NG+MDKnZydPbsWf74448Ce6sJIYQwDb1e4ff9F/m/9SdITMsGoLVfVWb0CCSohjMAzvZWhdY5mtkzkK5BXiaJW5iZ7DQ4skydSxR/+Fa7eyNo+Tw0fgZsnU0XXwkqdnL06KOPcujQIUmOhBCiHNh19hrvrIkm6lIqALWq2vPG4w0Ja2Q8st81yIvHAj0LrZAtxF3FH1FHiQ7/BjnpapuFDQT1UUeJfFpBBbuKVOzk6Ntvv2XIkCFERUURFBSElZVxXYxevcp2uZ0QQlRG569lMHvtccKPxgPgaGPJmEfrMaStLzaWha/usdBqZLm+KJqcTDj6p1qs8eKeW+3V6qlziZo8C/YVd55asZOjyMhI/vnnH9atW1fgmEzIFkKI0pWalcsXm0+z6J9z5Oj0aDXwbKtaTHisAdUdbEwdnjB3V06ol80O/QxZKWqb1hIa9lSTIt92FW6UqDDFTo7GjBnDwIEDmTFjBh4eZbfPiRBCVGZ5Oj1L91zg440nuZahLpNuV78607sH4u/paOLohFnLy4Zjq9Sk6PyOW+0utdTLZs0GgoO76eIzgWInR9euXWPChAmSGAkhRBn5+9QV3l19jBMJaQDUcavC9O4N6eTvLiuGxf1LOgv7FsOBnyDzmtqm0UKDbuooUd3OoNWaNERTKXZy1KdPH7Zs2ULdunVLIx4hhBD/OXMlnffXHCPieCIAznZWTAitz4A2tbGyqJxfWuIB6XLhZLg6wfrM5lvtjt7QYgg0GwTONUwXXzlR7OSoQYMGTJ06lR07dhAcHFxgQvbYsWNLLDghhKiMkjNz+DTiFD9GnidPr2Cp1TAopDbjHq2Pi721qcMT5ijlIuz7Hg78CGlx/zVqoN6j6ihR/TCwkB3FbtIoN8tcF5Gfn9+dn0yj4ezZsw8cVGHee+891qxZw8GDB7G2tiY5OblAn9jYWEaOHMmWLVtwcHBgyJAhzJ49G0vLW2/41q1bmThxIkePHsXHx4fp06czdOjQIseRmpqKs7MzKSkpODk5lcCZCSGEKlen56d/z/PJplOk3MgF4NEAd97o3pC6bg4mjk6YHb0OTkeoo0Sn1oPy33Zf9tWh+SBoPgSq3vk7vaIpzvd3sdPEmJiYe3cqBTk5OTz99NOEhITw3XffFTiu0+no3r07np6e7Ny5k7i4OAYPHoyVlRXvv/8+oMbevXt3Xn75ZZYsWUJERAQvvPACXl5ehIWFlfUpCSEEAIqisOVEIu+uOcbZKxkA+Hs4MqNHII/Ur27i6ES5odcVbVPWtAQ48APs+wFSYm+1+7ZTR4kCeoCljEDeTbFHjkxt8eLFjB8/vsDI0bp16+jRoweXL182TBZfsGABkydP5sqVK1hbWzN58mTWrFlDVFSU4XH9+/cnOTmZ8PDwIr2+jBwJIUrSifg03l0Tzd+nrgJQrYo1E7s0oF9LHyxlXpG4KXolhE+G1Mu32py8oetcdTd7vR7ObVdHiY6vAX2e2sfWBZoOgBZDwa2BKSIvN0p15GjYsGF3Pb5w4cLiPmWJiIyMJDg42GgVXVhYGCNHjuTo0aM0a9aMyMhIQkNDjR4XFhbG+PHj7/i82dnZZGdnG+6npqaWeOxCiMrnWno2H208yS+7Y9ErYG2h5flHfBnVqR5Otlb3fgJReUSvhN8GU2D74NQ4tb1Jf7iwG5LO3Drm01odJQp8AqzsyjTciqDYydH169eN7ufm5hIVFUVycjKdO3cuscCKKz4+vkB5gZv34+Pj79onNTWVGzduYGdX8Bdo9uzZzJo1q5SiFkJUNtl5Ohb/c47PN58mLVv9675bkCdTuzWkVjV7E0cnyh29Th0xuj0xgltth35R/2vtCE36qbWJPIPKKsIKqdjJ0Z9//lmgTa/XM3LkyGIv758yZQpz5869a59jx44REBBQrOctSVOnTmXixImG+6mpqfj4+JgsHiGEeVIUhfVH43l/7XFikzIBaOTtxJs9AmldR7b0EHdwfqfxpbQ7CRkNHaeCjUzcLwklsm5Pq9UyceJEOnbsyOuvv17kx7366qv3XClWp06dIj2Xp6cnu3fvNmpLSEgwHLv535tt+fs4OTkVOmoEYGNjg42NlOQXQty/qEspvLM6ml0xSQC4Odrwepg/fZvXRCsbv4q7SYsvWj/vZpIYlaASK2pw5swZ8vLyivUYNzc33NzcSuT1Q0JCeO+990hMTMTdXS1zvnHjRpycnAgMDDT0Wbt2rdHjNm7cSEhISInEIIQQ+SWmZvHB+hP8vv8iigI2llpGtK/Dyx3qUsVGasqIu8hOh6jf4Z/PitbfQXatKEnF/r8z/yUmUIeK4+LiWLNmDUOGDCmxwG4XGxtLUlISsbGx6HQ6Dh48CEC9evVwcHCgS5cuBAYGMmjQIObNm0d8fDzTp09n1KhRhpGfl19+mc8//5zXX3+dYcOGsXnzZn777TfWrFlTanELISqfrFwd3/59li+3niEzR92Mu1cTbyZ3C6CGi0yOFXcRH6WuODv8G+SkFeEBGnXVWu22pR5aZVLspfydOnUyuq/VanFzc6Nz584MGzbMqOBiSRo6dCjff/99gfYtW7bQsWNHAM6fP8/IkSPZunUrVapUYciQIcyZM6dAEcgJEyYQHR1NzZo1mTFjhhSBFEKUCEVRWHnoMvPCT3Ap+QYATX1ceLNnIM1ruZo4OlFu5d6AoyvUpOhivukhVetCy+fBrir8Neq/xvxf2f9dkn3mB3U5v7ir4nx/m12dI1OT5EgIUZgDsdd5Z3U0+2OTAfB2tmVytwB6NfGWzWFF4a6chH2L4ODPkJWstmkt1SKNLYeBX3u4+btTaJ2jGtB1jiRGRVSqdY6EEELccjn5BvPCj7PioPqlZW9twcgOdXmhXR3srAupXiwqt7wcOL4K9i6Cc3/faneudWvjV8dC5g8F9oKA7kWrkC0eWLGTo2vXrvHmm2+yZcsWEhMT0ev1RseTkpJKLDghhCivMrLz+GrbGb7++yxZuXo0GujbvCaTwvzxcLI1dXiivEmKgX2L4cBPkKlWQ0ejhQZd1VGiup3vnehoLcCvXamHKu4jORo0aBCnT59m+PDheHh4yHCxEKJS0esVlh+4xAfrj5OQqlbPb+VXlTd7BBJUw9nE0YlyRZcHJ8PVuURnIm61O3pB88Hqzbmm6eITd1Ts5Ojvv/9mx44dNGnSpDTiEUKIcmt3TBLvrI7myKUUAHyq2vFGt4Z0DfKUPxTFLSkXYf8P6i0t7lZ73UfVUaIGXcFCZrWUZ8V+dwICArhx40ZpxCKEECaj0yvsjkkiMS0Ld0dbWvlVxeK/Ao0XkjKZve4Ya4+oBfkcbCwZ07keQx/2xcZS5nwI1G0+zmxWR4lOhoPy35QT++rQbKA6n6hq0YoaC9MrdnL05ZdfMmXKFN58802CgoKwsjLeIFFWcAkhzE14VByzVkUTl5JlaPNytuX1MH+OJ6SxaMc5cnR6tBro36oWEx9rQHUHqZwvgPREOPCjOp8oOfZWu287dRl+QA+wlN8Vc1Ps5MjFxYXU1NQCm8wqioJGo0Gn05VYcEIIUdrCo+IY+dP+Att6xqVkMeG3Q4b7j9SrzvQeDQnwlD8AKz1FgZjt6ijR8dWg/293CFtnaDpA3fjVrYFpYxQPpNjJ0YABA7CysuLnn3+WCdlCCLOm0yvMWhVd6H7nN1loNSwY0JzQQPm8q/Qyk9SaRPsWwbXTt9prtlLnEjXqDVZSAb0iKHZyFBUVxYEDB/D39y+NeIQQoszsjkkyupRWGJ1ewcHWShKjykpR4MIudZTo6ArQqSsUsXaExs+ol848g00aoih5xU6OWrZsyYULFyQ5EkKYvcS0uydGxe0nKpCsFHV/s70LITH6VrtnY3hoOAQ9BTYOpotPlKpiJ0djxoxh3LhxTJo0ieDg4AITshs3blxiwQkhRGmJT8nir4OX790RcHeUoo6VxqX9akIU9QfkZqptlnYQ3Fe9dObd/NaWHqLCKvbealqttuCTaDSVZkK27K0mhHm7npHD/G1n+H7nObLz9HftqwE8nW3ZMbmzYVm/qICy09VkaO9CiDt4q92toXrZrHE/sHMxVXSihJTq3moxMTH3HZgQQphKRnYe3+2I4ZvtZ0nLVlcXPeTrSvv6bny08SRQ6H7nzOwZKIlRRZVwVE2IDv0KOWlqm4U1BPZWR4lqtZFRokqq2MlR7dq1SyMOIYQoFdl5Opb8G8sXW05zLSMHgIZeTrwe5k9Hfzc0Gg31PRwK1DnydLZlZs9AugZ5mSp0UVx63b03Zs29AdF/qUnRhV232qvWUZfgNx0AVaqVbdyi3ClScrRy5Uq6deuGlZUVK1euvGvfXr16lUhgQgjxIPJ0epYfuMSnm05xKVmt6u9bzZ6JXfzpEeyFNt9oUNcgLx4L9LxjhWxhBqJXQvhkSM03j8zJG7rOVXe0v3oK9i6Cg0sgK1k9rrVUd7pvOQx820Mh00ZE5VSkOUdarZb4+Hjc3d0LnXNkeDKZcySEMDFFUQiPiuf/NpzgzJUMADydbBn7aH2eblkTKwv5AqxwolfCb4OhQMUqjdrm1hCuHLvV7FxL3c6j2SBw9CjDQIUplficI71eX+i/hRCivFAUhR2nr/LB+hMcvqhuDOtqb8UrHesxKKQ2tlayB1qFpNepI0aFlvL8r+3KMUCjbvjachjUe7Tg5TYh8pFtgYUQZm9/7HU+CD9B5NlrAFSxtmB4uzq82M4PR1urezxamLXzO40vpd1J3+/U5fhCFMF9JUcRERFERESQmJhYYCRp4cKFJRKYEELcy4n4NP5vwwk2RicAYG2hZWCb2rzSqa5sDFtZJB67dx+g8JElIQpX7ORo1qxZvP3227Rs2RIvLy8pqS+EKHOx1zL5eNNJVhy8hKKAVgNPtajJuNAG1HCRva0qPL0ezmxWV5ydWFu0xzjI3CJRdMVOjhYsWMDixYsZNGhQacQjhBB3lJiaxf82n2bpnlhydepIwOPBnkx8zJ967rKVQ4WXnggHfoJ9iyH5/K12C2vQ5dzhQRp11VrttmURoaggip0c5eTk0Lat/JIJIcpOSmYuC7afYdE/MWTlqpfy29WvzuthAQTXdDZxdKJUKQqc+1sdJTq2GvS5arutMzR5Tq1gfeXEf6vVoNBSnl3nyARsUSzFTo5eeOEFfv75Z2bMmFEa8QghhEFmTh6L/jnHV9vOkJqlVrVuVsuF18MCCKkrhfoqtMwkOPSLmhRdO32rveZD6oqzwN5gba+2ufnDMz/coc7RHLXOkRDFUOzkKCsri6+//ppNmzbRuHHjAhvPfvTRRyUWnBCicsrJ07N0Tyz/23yaK2nZAPh7OPJamD+hDd1lrmNFpShwYbeaEB39E3Tqe4+1AzR+Rq1g7XWHzc0De6kFHe9VIVuIIih2cnT48GGaNm0KQFRUlNEx+cASQjwInV7hr4OX+HjTSS4kqVWtfaraMfGxBvRqUkMqVldUWalw+Fe1gnXi0VvtnsHqKFHw02DjeO/n0VqAX7vSi1NUGsVOjrZs2VIacQghKjFFUdgYncCHG05yIkHdANTN0YaxnevR76FaWFtKVesK6fIBNSE68jvkqtXMsbSDoL5qUlSjuWz8KkxCikAKIUxq5xm1qvWB2GQAnGwtGdmxHkPa1sbeWj6iKpycDIj6Q710dvnArXa3APWyWZN+YOdquviEoIjJUZ8+fVi8eDFOTk706dPnrn2XL19eIoEJISq2wxeT+WD9Cf4+dRUAOysLhj3iy4j2dXG2k6rWFU5CNOxbBIeWQnaq2mZhDYFPqKNEtUJklEiUG0VKjpydnQ3ziZydZdmsEOL+nU5M48MNJ1kXFQ+AlYWG51rVYlTnerg72po4OlGicrMg+i91lOjCv7faXf3UJfhNB0CV6qaLT4g70CiKIjXVi6E4u/oKIW65lHyDTzae5I/9F9Er6iDBk81qMCG0AT5V7U0dnihJV0+ro0QHl8CN62qbxkJdTdZyGPh1AK3MIxNlqzjf33JBXwhRqq6mZ/PFltMs+TeWHJ1awLFLoAevhfnTwKMIK5CEecjLgRNr1FGimO232p1qQouh0GwgOHmZLDwhiqPYydG1a9d488032bJlS6EbzyYlJZVYcEII85Walcu328/y7Y4YMnN0ALStW41JYf40qyUTbiuM6+dh//ew/0fISPyvUQMNwtRRonqhUmtImJ1iJ0eDBg3i9OnTDB8+HA8PD6ltJIQwkpWr44fIc3y59QzJmepWD01qOjMpLIBH6sv8kgpBlwenNqijRKc3Ydiyw8EDmg9Wby61TBqiEA+i2MnR33//zY4dO2jSpElpxCOEMFO5Oj2/7b3AZxGnSEhVKxvXc3fgtS4NCGvkKX9IVQSpl9URov3fQ+qlW+11OqmjRP7dwEJWGgrzV+zkKCAggBs3bpRGLEKIckynV9gdk0RiWhbujra08quKhVaDXq+w6vBlPt54knPXMgGo4WLH+ND69GleU6pamzu9Hs5uUUeJTqwDRb1Eil1VdR5Ri6FQra5JQxSipBU7Ofryyy+ZMmUKb775JkFBQQX2ViuNFVznzp3jnXfeYfPmzcTHx+Pt7c3AgQOZNm0a1tbWhn6HDx9m1KhR7NmzBzc3N8aMGcPrr79u9FzLli1jxowZnDt3jvr16zN37lwef/zxEo9ZiIokPCqOWauiiUvJMrR5OtvSt3kNNh+/wrE4tW5NdQdrRneqx7Ota2FjKfNMzFr6FTj4E+xbDNfP3Wqv/bBarDGwF1jamCo6IUpVsZMjFxcXUlNT6dy5s1G7oihoNBp0Ol2JBXfT8ePH0ev1fPXVV9SrV4+oqChefPFFMjIy+L//+z9AXaLXpUsXQkNDWbBgAUeOHGHYsGG4uLgwYsQIAHbu3Mmzzz7L7Nmz6dGjBz///DO9e/dm//79BAUFlXjcQlQE4VFxjPxpP7fX/IhPyeKLLWcAcLSx5KUOdXj+YT+q2Mgi2HJLr7v7xqyKAuf/UUeJoleCXp0zho0zNH1WTYrcA0wTuxBlqNh1jlq1aoWlpSXjxo0rdEJ2hw4dSjTAO/nggw+YP38+Z8+eBWD+/PlMmzaN+Ph4w2jSlClTWLFiBcePHwegX79+ZGRksHr1asPztGnThqZNm7JgwYIiva7UORKViU6v8MjczUYjRrerYmPBttc6Ud1RRhHKteiVED5ZnTd0k5M3dJ0Lvo+olav3LYKrJ28dr9FSLdbYqA9YSy0qYd5Ktc5RVFQUBw4cwN/f/74DLAkpKSlUrVrVcD8yMpL27dsbXWYLCwtj7ty5XL9+HVdXVyIjI5k4caLR84SFhbFixYo7vk52djbZ2dmG+6mpqSV3EkKUc7tjku6aGAFkZOs4lZguyVF5Fr0SfhsMt4//pV6G3waB1urWKJFVFWj8jJoUecnCG1E5FbtEacuWLblw4UJpxFJkp0+f5n//+x8vvfSSoS0+Ph4PDw+jfjfvx8fH37XPzeOFmT17Ns7Ozoabj49PSZ2GEOXepeTMIvVLTLt7AiVMSK9TR4wKXBjN3ycX3IOg+0fw6nHo+YkkRqJSK3ZyNGbMGMaNG8fixYvZt28fhw8fNroVx5QpU9BoNHe93bwkdtOlS5fo2rUrTz/9NC+++GJxwy+2qVOnkpKSYriZOjEUoiwoisJfBy8xZ+3xe3cG2ROtPDu/0/hS2p10mw0PDQdbmS4gRLEvq/Xr1w+AYcOGGdo0Gs19Tch+9dVXGTp06F371KlTx/Dvy5cv06lTJ9q2bcvXX39t1M/T05OEhASjtpv3PT0979rn5vHC2NjYYGMjlwtE5bE/9jrvrI7mQGwyAFoN6O8w6KBBXbXWyq9q4R2EaeVkwpHfi9Y3PfHefYSoJIqdHMXExJTYi7u5ueHm5lakvpcuXaJTp060aNGCRYsWob1t08KQkBCmTZtGbm6uobzAxo0b8ff3x9XV1dAnIiKC8ePHGx63ceNGQkJCSuaEhDBjl5NvMDf8OH8dVEcZ7K0teKVjXWpVtWfc0oOA8YWZm0sxZvYMlFpG5U3iMdi7SJ1knZ1StMc4eNy7jxCVRLGTo9q1a5dGHHd16dIlOnbsSO3atfm///s/rly5Yjh2c9TnueeeY9asWQwfPpzJkycTFRXFp59+yscff2zoO27cODp06MCHH35I9+7dWbp0KXv37i0wCiVEZZKRncdX287w1fazZOfp0WjgqeY1mRTmj7uTernM2lJbaJ2jmT0D6Rokm4mWC7lZcGylmhTF7rzV7lIbblyH7DQKn3ekUVet1W5bVpEKUe4Veym/KSxevJjnn3++0GP5w89fBLJ69eqMGTOGyZMnG/VftmwZ06dPNxSBnDdvXrGKQMpSflFR6PUKf+y/yAfrT5CYpq7IbO1XlRk9Agmq4Vyg/50qZAsTu3ZGXYJ/YAnc+G/jb40FBDyu1iWq0wmOr/5vtRoUOv73zA9qUUchKrDifH+bRXJUnkhyJCqC3TFJvLM6miOX1Esutara88bjAbIHmrnQ5cKJtWqxxrNbb7U71VC382g2CJxuG9ErtM5RDeg6RxIjUSmUap0jIYT5ir2Wyex1x1gXpZavcLSxZMyj9RjS1le2+zAHybGw73s48KNa5RoADdR/TN34td5jYHGHj/XAXhDQ/e4VsoUQQBGTo88++4wRI0Zga2tLbGwsPj4+8telEGYkLSuXz7ecZtGOc+To9Gg18GyrWkx4rAHVHWQ1Zrmm18Gpjeoo0akNGC6LVXGH5oPVm2sR54JqLcCvXamFKkRFUaTLapaWlly+fBl3d3csLCyIi4vD3d29LOIrd+SymjAnOr3Cr3su8OGGE1zLyAGgXf3qTO8eiL+no4mjE3eVGqeOEO37HlIv3mqv01GdSxTQHSys7vhwIYSxEr+s5u3tzR9//MHjjz+OoihcvHiRrKzCK+LWqlWr+BELIUrcP6ev8s7qaI7HpwFQx60K07s3pJO/u4z8lld6PZzdok6wPr4WlP/qxtlVhWYD1KSoWl3TxihEJVCkkaOvv/6aMWPGkJeXd8c+91ME0hzJyJEo785eSef9tcfYdEwt6udsZ8X40PoMbFMbK4tiF8UXZSHjKhz4SU2Krp+71V6rrbrHWcNeYCVVyIV4EKWyWi0tLY3z58/TuHFjNm3aRLVq1Qrt16RJxd6PR5IjUV6lZObyacQpfog8R55ewVKrYWCb2owPrY+LvfW9n0CULUVRJ0fvXajWJ9Kplz2xcYYm/dWkyL2haWMUogIpldVqjo6OBAUFsWjRIh5++GHZUkOIciJXp2fJv+f5JOIUyZnqzuqPBrjzRveG1HVzMHF0ooAb19XK1XsXwdUTt9q9m6srzoL6gHUV08UnhCj+Uv4hQ4YAsG/fPo4dOwZAYGAgzZs3L9nIhBB3pSgKW09c4d010Zy5kgGAv4cj03s0pF39om3LI8qIosClfeooUdQfkPffnE2rKtD4aXUukXdTk4YohLil2MlRYmIi/fv3Z+vWrbi4uACQnJxMp06dWLp0aZH3ShNC3L+TCWm8szqav09dBaBaFWsmdmlAv5Y+WMq8ovIjOw0O/6bOJYo/cqvdI0i9bBb8DNjK5XkhyptiJ0djxowhLS2No0eP0rChej08OjqaIUOGMHbsWH755ZcSD1IIobqWns3Hm07y865Y9ApYW2h5/mFfRnWuh5OtLOsuN+IOq6NER5ZBTrraZmkLjfqol85qtgRZMShEuVXs7UOcnZ3ZtGkTDz30kFH77t276dKlC8nJySUZX7kjE7KFKWTn6fh+5zn+t/k0aVnqqtGujTyZ+ngAtavJ/JRyIScTji5X5xJd2nurvVp9NSFq0h/sq5ouPiEquVLdPkSv12NlVfAvVCsrK/R6fXGfTghxF4qisP5oArPXHeP8tUwAGnk7MaNHIG3qFL5iVJSxxOPqZbODv0C2ulcdWit1u44Wz4PvIzJKJISZKXZy1LlzZ8aNG8cvv/yCt7c3AJcuXWLChAk8+uijJR6gEJVV1KUU3l0Tzb9n1Z3W3RxtmBTmT9/mNbHQypetSeVlw7FV6qWz8//caneprc4lajoQHGT+pRDmqtjJ0eeff06vXr3w9fXFx8cHgAsXLhAUFMRPP/1U4gEKUdkkpmbxfxtOsGzfRRQFbCy1vNiuDiM71qWKjewVXWr0untvynrtDOxbDAeXQOY1tU1jAf7d1KSoTmfQyoR4IcxdsT9pfXx82L9/P5s2beL48eMANGzYkNDQ0BIPTojKJCtXx3c7Yvhiy2kyc9RK872aeDO5WwA1XOxMHF0FF70SwidD6uVbbU7e0HWumvicWKvOJTq7Jd/xGtB8CDQfpPYVQlQYxZ6QXdnJhGxR0hRFYfXhOOasO86l5BsANPVxYUaPQFrUdjVxdJVA9Er4bTCG3e4NNGqbrTNkpdxqq/+YOsG63mNgISN5QpiLUp2QLYQoOQcvJPPO6mj2nb8OgLezLZO7BdCzsTdamVdU+vQ6dcSoQGLErbasFLB3gxaD1ZEi19plGaEQwgQkORLCBOJSbjAv/AR/HrgEgJ2VBSM71uXFdnWws7a4x6NFiTm/0/hS2p30+QbqdSr9eIQQ5YIkR0KUocycPBZsO8vX28+QlauWvujbvCaTwvzxdJZd18uUXg9nNhet741rpRuLEKJckeRIiDKg1yv8eeAS89YfJyE1G4CHfF2Z0SOQxjVdTBtcZZNxVV1ttm8xJJ0t2mMcPEo1JCFE+VLs5Gj//v1YWVkRHBwMwF9//cWiRYsIDAzkrbfewtrausSDFMIc6PQKu2OSSEzLwt3RllZ+VbHQathzLol3Vkdz+KI6qdenqh1TuzWkW5AnGikOWDYUBWIj1bpE0X+BLkdtt3YE9JCTcYcHatSVaLXbllWkQohyoNjJ0UsvvcSUKVMIDg7m7Nmz9O/fnyeffJJly5aRmZnJJ598UgphClG+hUfFMWtVNHEpWYY2N0cbfFzt2B+bDICDjSWjO9djaFtfbK1kXlGZuJEMh5aqSdHVE7favZupK86C+sLpiP9Wq4HxxOz/EteucwrWOxJCVGj3tbfa/v37qVu3LnPnzmXz5s2sX7+ef/75h/79+3PhwoXSirVckKX84nbhUXGM/Gl/oeudQP2K7d+qFhMfa4Cbo01ZhlY5KQpc2q8mRFF/QJ5aHgErewh+Wi3W6N3M+DGF1jmqoSZGgb3KLnYhRKkp1aX8iqIY9lDbtGkTPXr0ANTikFevXr2PcIUwXzq9wqxV0XdMjACqO9jwbu8g2fKjtGWnwZFlarHG+MO32t0bqQlR42fUmkWFCewFAd3vXSFbCFEpFDs5atmyJe+++y6hoaFs27aN+fPnAxATE4OHh0xaFJXL7pgko0tphbmSns3umCRC6spGsaUi/og6SnT4N8hJV9ssbCCoj7rxq0+rom38qrUAv3alG6sQwiwUOzn6+OOPGThwICtWrGDatGnUq1cPgN9//522bWXSoqhc4v6raH0viWl3T6BEMeVkwtE/Yd8iuLjnVnu1eupcoibPgn1V08UnhDBrxU6OmjRpwpEjRwq0f/DBB1haSmUAUXkcvpjMx5tOFqmvu6PUMCoRV06ol80O/XxrSw+tFTTsqSZFvo8UbZRICCHuotjZTJ06ddizZw/VqhlfIsjKyqJ58+acPVvEuiFCmKkbOTo+2XSSb/4+i15Rv4vvtKxBA3g6q8v6xX3Ky4Zjq9Sk6PyOW+0utdTLZs0GgoO76eITQlQ4xU6Ozp07h06nK9CenZ3NxYsXSyQoIcqrf89eY8ofhzl3LROAJ5p680i96rz+uzoBuJCF4MzsGSiTse9H0lm1UOOBnyDzvwrVGi006KaOEtXtDFqtSUMUQlRMRU6OVq5cafj3+vXrcXa+tepDp9MRERGBn59fyUYnRDmRmpXLnHXH+XlXLACeTra82zuI0EB1EYKjrWWBOkeezrbM7BlI1yAvk8RslnS5cDJcnWCdf2sPR29oMQSaDQLnGqaLTwhRKRS5zpH2v7/QNBoNtz/EysoKX19fPvzwQ8PS/opK6hxVPhHHEpj2ZxTxqWri81zrWkzpFoCTrZVRvztVyBZFkHwB9v+g3tLj/2vUQL1H1VGi+mFgIXMahRD3r1TqHN2sbeTn58eePXuoXr36g0UpRDl3LT2bWauiWXlILQxYu5o9c/o0vuOSfAutRpbrF4dep1an3rsQTq0HRf2MoYqbOkLUYgi4+po0RCFE5VTsP8ViYmJKIw4hyg1FUVh56DKzVkWTlJGDVgMvtqvD+NAG2FlLUcAHlpYAB36Afd9DSr6K+r7t1FGigB5gKXs0CiFMp0jJ0WeffcaIESOwtbXls88+u2vfsWPHlkhgQphCXMoNpv8ZRcTxRAACPB2Z91RjGtd0MW1g5k6vh3Pb1VGi42tAn6e227qoq81aDIXq9U0ZoRBCGBRpzpGfnx979+6lWrVqd510rdFoKvxSfplzVDHp9Qq/7Ill9trjpGfnYWWhYUzn+rzcoS7WlrIi6r5lXIODS9RVZ0lnbrX7tFZHiQKfACs7k4UnhKg8SnzOUf5Laaa6rNarVy8OHjxIYmIirq6uhIaGMnfuXLy9vQ19Dh8+zKhRo9izZw9ubm6MGTOG119/3eh5li1bxowZMzh37hz169dn7ty5PP7442V9OqIcibmawZQ/DrMrJgmAZrVcmNe3MfU9HE0cmZlSFIj9Vx0lil4Buhy13doRmvRX9znzaGTSEIUQ4m7MZvlHp06deOONN/Dy8uLSpUu89tprPPXUU+zcuRNQM8IuXboQGhrKggULOHLkCMOGDcPFxYURI0YAsHPnTp599llmz55Njx49+Pnnn+nduzf79+8nKCjIlKcnTCBPp+e7HTF8tPEk2Xl67KwsmBTmz5C2vrLKrDB63d03Zr2RrO5vtnchXDl2q92rCbQcDkF9wcahzMMWQojiKvJS/pt0Oh2LFy8mIiKCxMREwyq2mzZv3nyHR5aslStX0rt3b7Kzs7GysmL+/PlMmzaN+Ph4rK3VyZxTpkxhxYoVHD9+HIB+/fqRkZHB6tWrDc/Tpk0bmjZtyoIFCwp9nezsbLKzsw33U1NT8fHxkctqZu5YXCqT/zjM4YvqFhSP1KvO7D7B+FS1N3Fk5VT0SgifDKmXb7U5eUPXOeBcU02IjvwBef/tNWdlryZDLYdBjeamiVkIIfIplaX8N40bN47FixfTvXt3goKC0JhgH6OkpCSWLFlC27ZtsbJSa81ERkbSvn17Q2IEEBYWxty5c7l+/Tqurq5ERkYyceJEo+cKCwtjxYoVd3yt2bNnM2vWrFI5D1H2svN0fLH5NF9uPUOeXsHJ1pLpPQJ5ukVNk/wum4XolfDbYIzrf6MmSr8NNm5zD1QTosbPgK0zQghhjoqdHC1dupTffvvNJPN0Jk+ezOeff05mZiZt2rQxGgGKj48vMFncw8PDcMzV1ZX4+HhDW/4+8fHx3MnUqVONEqqbI0fC/Ow7f53JfxzmdGI6AGGNPHjniSDcnWRT2DvS69QRo9sTo9sFPw0PvaBOtJYkUwhh5oq9DMfa2pp69eqVyItPmTIFjUZz19vNS2IAkyZN4sCBA2zYsAELCwsGDx5coFp3SbOxscHJycnoJsxLRnYes1Yd5akFOzmdmE51B2u+HNCcBQNbSGJ0L+d3Gl9Ku5PmQ6BWG0mMhBAVQrFHjl599VU+/fRTPv/88we+DPHqq68ydOjQu/apU6eO4d/Vq1enevXqNGjQgIYNG+Lj48O///5LSEgInp6eJCQkGD325n1PT0/Dfwvrc/O4qHj+PnWFqcuPcPG6Ohemb/OazOjREBd7KTJYJOf+Llq/9IR79xFCCDNR7ORox44dbNmyhXXr1tGoUSPDnJ+bli9fXuTncnNzw83NrbghALe2M7k5WTokJIRp06aRm5triGnjxo34+/vj6upq6BMREcH48eMNz7Nx40ZCQkLuKwZRfqVk5vLummiW7bsIQA0XO97vE0yHBvf3+1apKArEbINtH8D5HUV7jIPHvfsIIYSZKHZy5OLiwpNPPlkasdzRrl272LNnD4888giurq6cOXOGGTNmULduXUNi89xzzzFr1iyGDx/O5MmTiYqK4tNPP+Xjjz82PM+4cePo0KEDH374Id27d2fp0qXs3buXr7/+ukzPR5Su8Kg4Zvx1lCtp2Wg0MCTEl9fC/HGwMZvKFaahKHBqI2z/AC7uVts0lupWHrk3KHzekUZdtVa7bVlGKoQQparYS/lN4ciRI4wbN45Dhw6RkZGBl5cXXbt2Zfr06dSoUcPQL38RyOrVqzNmzBgmT55s9FzLli1j+vTphiKQ8+bNK9bkcqmQXX4lpmUx86+jrItSJ9jXcavCvL6Naelb1cSRlXN6PZxYoyZFcYfUNktbdR7Rw2Ph0v58q9Lyf1z8d1n9mR8gsFdZRiyEEMVWnO9vs0iOyhNJjsofRVH4Y/8l3lkdTcqNXCy0GkZ2qMvozvWwtZKNYu9Ir1MrWG//P0iMVtusqsBDwyBkDDjmu1RWaJ2jGmqdI0mMhBBmoFTqHLm6uhY6AdvZ2ZkGDRrw2muv8dhjjxU/WiEewIWkTN748wh/n7oKQCNvJ+Y91ZhG3lJj5450eXBkGfz9IVw7pbbZOEGrEdDmFahSreBjAntBQPe7V8gWQogKosjJ0SeffFJoe3JyMvv27aNHjx78/vvv9OzZs6RiE+KO9HqFHyLPMW/9CTJzdFhbapkQ2oAX2/lhaSEbxRYqLwcO/Qx/fwTJ59U2WxcIGaUmRnYud3+81gL82pV2lEIIYXJFTo6GDBly1+NNmzZl9uzZkhyJUnc6MY3Jfxxh3/nrALTyrcqcvsHUcZN9uwqVewP2/wj/fAKpl9Q2++rQdrRauNFGNtgVQoj8Smz5To8ePXj33XdL6umEKCBXp+fr7Wf5dNMpcnR6qlhbMOXxhgxoVQutbBRbUE6GuufZzv/dqkPk4AkPj4MWQ8Fa9pETQojClFhylJ2dbbSvmRAl6cjFFF7/4zDH4lIB6OjvxntPBlPDxc7EkZVDWamw+2v490vIvKa2OfvAI+Oh6UCwkqrgQghxNyWWHH333Xc0bdq0pJ5OCACycnV8sukU3/x9Fp1ewdXeijd7BtK7aQ3ZKPZ2mUmwa4F6y0pR21z9oN2r0LifWq9ICCHEPRU5Obp9N/ubUlJS2L9/PydPnmT79u0lFpgQu85eY8ryI8RczQCgR2Mv3urViOoONiaOrJxJvwKRn8OebyFH3VSX6v7Q/jVo1AcspPilEEIUR5E/NQ8cOFBou5OTE4899hjLly/Hz8+vxAITlVdaVi5zw4/z07+xAHg42fDOE0F0aSR74BlJjVPnE+1dCHnq3nF4BKtJUcNeoJVVe0IIcT+KnBxt2bKlNOMQAoAtxxN5488jxKVkAfBsKx+mdGuIs53VPR5ZiSTHwj+fqivQdOregng3g/avg383kMuNQgjxQGS8XZQLSRk5vL3qKCsOqhWYa1W1Z06fYNrWq27iyMqRpLNqjaJDv4A+T23zaQMdJkHdRyUpEkKIEiLJkSgTOr3C7pgkEtOycHe0pZVfVSy0GhRFYfXhON5aeZRrGTloNTDsYT9e7eKPnbVUXwbgygm1mvWRZaDo1Ta/DtB+Evg+IkmREEKUMEmORKkLj4pj1qpow6UyAC9nW8Y+Wp+IY4lsOqbW4Gng4cDcvo1pVsvVVKGWL/FR6maw0X9h2PC1fhc1KfJpZdLQhBCiIpPkSJSq8Kg4Rv60n9t3N45LyWLq8iMAWFloGNWpHq90rIe1pUwi5tJ+dTPYE2tutQX0UCdaezczXVxCCFFJSHIkSo1OrzBrVXSBxCg/KwsNf416hEDvu++QXCnE/quOFJ3e9F+DBho9qSZFHo1MGpoQQlQmkhyJUrM7JsnoUlphcnUKKTdyyyiickhRIGa7mhSd+1tt01hA42fU4o3V65s2PiGEqIQkORKlJjHt7olRcftVKIoCpyNg+zy4sEtt01pB0+fgkQlQVWqGCSGEqUhyJEqNu2PR9vAqar8KQa+Hk+vUkaLL/xVWtbCBFkOg7Vhw8TFtfEIIISQ5EqWneS0X7Ky03MjVF3pcA3g6q8v6KwS9Ds7vhPQEcPCA2m1Ba3HrWPRf6pL8hCi1zcoeWg6DtmPAUap/CyFEeSHJkSgVWbk6Rv984K6JEcDMnoFYaCtAnZ7olRA+GVIv32pz8oYu76tVrP/+EK6eVNutHaHVixAyCqpIkUshhChvJDkSJS49O48Xv99L5NlrWFtqGf6wHysOXjKanO3pbMvMnoF0DfIyYaQlJHol/DYYbl+Xl3oZfh96676tM7R5BVq/BHZSy0kIIcorSY5EibqekcPQRbs5dDEFBxtLvhnckpC61XgtzL/QCtlmT69TR4zuVrBAo4VO06DVCLCVkgVCCFHeSXIkSkx8ShaDvtvFqcR0XO2t+H5YKxrXdAHAQqshpG410wZYGs7vNL6UVhhFDz6tJTESQggzIcmRKBHnrmYw8LtdXLx+A08nW356oRX13B1NHVbpS08o2X5CCCFMTpIj8cCOxaUy6LvdXE3PxreaPT8Ob41PVXtTh1X6rp6GXV8Vra+DR+nGIoQQosRIciQeyL7z13l+0W5Ss/II8HTkh+GtKn7dohvXYds82P016PPu0Vmjrlqr3bZMQhNCCPHgJDkS9+3vU1cY8cM+buTqaFHblYVDHsLZ3srUYZUeXS7sXQhbZ6sJEkD9MKjbGcKn/Ncp/8Ts/yacd51zq96REEKIck+SI3Ff1h2JY+zSA+TqFNrVr85Xg1pgb11Bf50UBU5thA3TbtUqcg+EsPfUxAjU0aHC6hx1nQOBvco+ZiGEEPetgn6bidL0254LTFl+GL0C3YO9+KhfE2wsK+jISOIxWD8NzkSo9+2rqcvymw8Bi3z/+wT2goDud66QLYQQwmxIciSK5du/z/LummMA9Gvpw/t9gitGvaLbZVyFLe/DvsWg6NRNYduMhPavqcUcC6O1AL92ZRqmEEKIkifJkSgSRVH4cMNJPt9yGoAR7eswtVsAGk0FS4zycmD3V7DtA8hOUdsa9oTH3oaqdUwbmxBCiDIhyZG4J71e4a1VR/kh8jwAk8L8eaVj3YqVGCkKHF8DG6bD9Ri1zbMxdJ0Nvo+YNjYhhBBlSpIjcVe5Oj2Tlh1ixcHLaDTw9hNBDGpT29Rhlay4w7D+DTj3t3rfwQMefROaPCtzhoQQohKS5EjcUVaujtE/72fTsUQstRo+fKYJTzStYeqwSk5aAmx+Bw78BChgaQsho+GR8WBTCap7CyGEKJQkR6JQaVm5vPD9XnbFJGFjqWX+wOZ0DqggVZ5zb0DkF7DjY8hJV9uC+kLoW+BSy6ShCSGEMD1JjkQBSRk5DFm4myOXUnCwseS7IS1pXacCbBqrKHB0OWx8C1Ji1bYaLdV5RT6tTBqaEEKI8kNr6gCKKzs7m6ZNm6LRaDh48KDRscOHD9OuXTtsbW3x8fFh3rx5BR6/bNkyAgICsLW1JTg4mLVr15ZR5OYhLuUGTy/YyZFLKVStYs3SEW0qRmJ0cR8sDIPfh6mJkVMN6PMNDN8oiZEQQggjZpccvf7663h7exdoT01NpUuXLtSuXZt9+/bxwQcf8NZbb/H1118b+uzcuZNnn32W4cOHc+DAAXr37k3v3r2Jiooqy1Mot2KuZvDU/EjOXMnAy9mW314KIajGHWr6mIuUS7B8BHzbGS7sAit7tYjj6L3Q+BnQmt3/AkIIIUqZRlEU5d7dyod169YxceJE/vjjDxo1asSBAwdo2rQpAPPnz2fatGnEx8djbW0NwJQpU1ixYgXHjx8HoF+/fmRkZLB69WrDc7Zp04amTZuyYMGCQl8zOzub7Oxsw/3U1FR8fHxISUnBycmplM607EVfTmXwwt1cTc/Gr3oVfhzeipqu9qYO6/7lZMA/n8I/n0HeDbWtyXPw6Ax1Ww8hhBCVSmpqKs7OzkX6/jabP5sTEhJ48cUX+fHHH7G3L/ilHRkZSfv27Q2JEUBYWBgnTpzg+vXrhj6hoaFGjwsLCyMyMvKOrzt79mycnZ0NNx8fnxI6o/Jj77kk+n0dydX0bAK9nFj2coj5JkZ6PRz8Bf7XArbNVROjWiHw4hZ4cr4kRkIIIe7JLJIjRVEYOnQoL7/8Mi1btiy0T3x8PB4exqupbt6Pj4+/a5+bxwszdepUUlJSDLcLFy48yKmUO9tOXmHgd7tIy8rjIV9XfhnRhuoONqYO6/6cj1Qvn614GdLi1JVnT38Pz6+DGs1NHZ0QQggzYdLValOmTGHu3Ll37XPs2DE2bNhAWloaU6dOLaPIbrGxscHGxkyThXtYcziO8b8eIFen0KGBGwsGtsDO2gyLHl4/BxtnQvQK9b61I7R/FVqPBCtbU0YmhBDCDJk0OXr11VcZOnToXfvUqVOHzZs3ExkZWSBJadmyJQMGDOD777/H09OThIQEo+M373t6ehr+W1ifm8crk6W7Y3njzyPoFeje2IuPn2mKtaVZDCTekpUKOz6CyC9Blw0aLTQbBJ2ng4O7qaMTQghhpkyaHLm5ueHm5nbPfp999hnvvvuu4f7ly5cJCwvj119/pXXr1gCEhIQwbdo0cnNzsbKyAmDjxo34+/vj6upq6BMREcH48eMNz7Vx40ZCQkJK8KzKv6+2nWH2OnWS+rOtavFu7yAstGa0T5peBwd+hM3vQsYVtc2vA4S9D55Bpo1NCCGE2TOLIpC1ahlXLXZwcACgbt261KxZE4DnnnuOWbNmMXz4cCZPnkxUVBSffvopH3/8seFx48aNo0OHDnz44Yd0796dpUuXsnfvXqPl/hWZoih8sP4EX249A8DLHeoyuau/eW0ge3abug9awn/lF6rWhS7vgn83MKfzEEIIUW6ZRXJUFM7OzmzYsIFRo0bRokULqlevzptvvsmIESMMfdq2bcvPP//M9OnTeeONN6hfvz4rVqwgKKjijzbo9Qoz/opiyS61MvTkrgGM7FjXxFEVw7UzsGEGnFij3rd1hg5T4KEXwNL67o8VQgghisGs6hyVB8Wpk1Be5Or0vPrbIVYeuoxGA+/2DmJA69qmDqtoblyHbR/A7q9BnwsaC3hoOHScCvZVTR2dEEIIM1Gc7+8KM3IkCncjR8crS/ax5cQVLLUaPu7XlJ5NzKDWjy4P9i2CLe/DjSS1rX4X9RKam79pYxNCCFGhSXJUgaVm5fLC4r3sPpeErZWW+QNb0MnfDFZxndqkziu6ekK97xYAYe9BvdC7P04IIYQoAZIcVVDX0rMZvHA3Ry+n4mhjyXdDH6KVXzm/DJV4HDZMg9Ob1Pt2VaHzNGg+FCzkV1UIIUTZkG+cCuhy8g0GfreLs1cyqFbFmu+HtTL9BrJ6HZzfCekJ4OABtduC9r+CkxnXYOts2LsQFB1oraD1S9B+Eti5mDRsIYQQlY8kRxXM2SvpDPx2F5dTsvB2tuWnF1pTx83BtEFFr4TwyZB6+Vabkzd0eU9t2zYPslPU9oAe8NjbUM2MVtIJIYSoUCQ5qkCiLqUwZOFurmXkUMetCj8Nb423i51pg4peCb8NBm5bFJl6GX5//tZ9j2Do+j74tS/T8IQQQojbSXJUQew5l8SwRXtIy86jkbcT3w9rZfoNZPU6dcTo9sQoP40WenysbvuhNcN93YQQQlQ4khxVAFtOJDLyp31k5epp5VuVb4e2xMnWytRhqXOM8l9KK4yiV6tcS2IkhBCinJDkyMytOnSZCb8eJE+v0MnfjS8HtMDOupwkGukJ9+5TnH5CCCFEGZDkyIz9vCuWaSuOoCjQq4k3Hz7TBCsLranDusXBo2T7CSGEEGVAkiMzNX/rGeaGHwdgQOtavP1EEBbacrbxanr8PTpo1FVrtduWSThCCCFEUUhyZGYURWFu+AkWbDsDwCsd6zIpzB9NedqRXq+Dze/Cjo/yNWownpj9X7xd58h8IyGEEOWKJEdmRKdXmL4iil92xwIwtVsAL3UoZ/WAslLgjxfg1Ab1ftuxUKMFrJ9asM5R1zkQ2Ms0cQohhBB3IMmRmcjJ0zPxt4OsPhyHRgOznwymf6tapg7L2NVT8MuzcO0UWNpCr8+h8dPqsYY971whWwghhChHJDkyAzdydIxcso+tJ65gZaHhk37N6N7Yy9RhGTu5Af4YDtmp4FQD+i8B72a3jmstwK+d6eITQgghikiSo3Iu5UYuwxfvYe/569haaVkwsAUd/d1NHdYtigI7PoaItwEFaoXAMz+AQzmKUQghhCgGSY7KsStp2QxZuJvouFQcbS1ZNPQhWvpWNXVYt+Rkwl+j4Ohy9X6L56HbPLC0Nm1cQgghxAOQ5Kic0OkVdsckkZiWhbujLTVc7RiycDcxVzOo7mDND8NaE+jtZOowb0mOhaXPQfwR0FqqSdFDw00dlRBCCPHAJDkqB8Kj4pi1Kpq4lCxDm1YDegVquNjx0wut8atexYQR3ubcDnUz2cxrYF8d+v0otYqEEEJUGJIcmVh4VBwjf9pfYGtW/X8NozvXLT+JkaLAnm8hfAro88CrCfRbAi4+po5MCCGEKDHlaK+JykenV5i1Kvpue9bzWcRpdPq79SgjedmwaiysfU1NjIKegufDJTESQghR4UhyZEK7Y5KMLqUVJi4li90xSWUU0R2kJcD3PWH/D4AGHnsb+n4L1vamjUsIIYQoBXJZzYQS0+6eGBW3X6m4tB+WDoC0y2DjDE8thPqhpotHCCGEKGWSHJmQu6NtifYrcYd+hZVjQJcN1RtA/1+gej3TxCKEEEKUEbmsZkKt/Kri5WzLnbaM1QBezra08ivj2ka6PFg/Df4coSZGDbrCCxGSGAkhhKgUJDkyIQuthpk9AwEKJEg378/sGYiF9k7pUynITIIlT0Hk5+r9dq+pI0a25ajGkhBCCFGKJDkysa5BXswf2BxPZ+NLZ57Otswf2JyuQWW4h1riMfimM5zdAlb28PRieHQGaOXXRAghROUhc47Kga5BXjwW6GlUIbuVX9WyHTE6vgaWj4CcdHCpBf1/Bs/gsnt9IYQQopyQ5KicsNBqCKlbrexfWK+H7R/A1vfV+77t4OnvoYoJYhFCCCHKAUmOKrPsdFjxMhxbpd5v9RKEvQcWVqaNSwghhDAhSY4qq6QYdePYxGiwsIbuH0HzQaaOSgghhDA5SY4qo7NbYdlQuHEdHDyg30/g08rUUQkhhBDlgiRHlYmiwL/zYcN0UHRQo4WaGDl5mzoyIYQQotyQ5KiyyM2C1RPg0M/q/SbPQY+PwcpE1beFEEKIcspsCtj4+vqi0WiMbnPmzDHqc/jwYdq1a4etrS0+Pj7MmzevwPMsW7aMgIAAbG1tCQ4OZu3atWV1CqaTehkWP64mRhoLCJsNvb+UxEgIIYQohNkkRwBvv/02cXFxhtuYMWMMx1JTU+nSpQu1a9dm3759fPDBB7z11lt8/fXXhj47d+7k2WefZfjw4Rw4cIDevXvTu3dvoqKiTHE6ZePCbvi6I1zaB7YuMPAPCHkFNGVYQ0kIIYQwI2Z1Wc3R0RFPT89Cjy1ZsoScnBwWLlyItbU1jRo14uDBg3z00UeMGDECgE8//ZSuXbsyadIkAN555x02btzI559/zoIFC8rsPMrM/h9hzUTQ5YB7IPRfAlXrmDoqIYQQolwzq5GjOXPmUK1aNZo1a8YHH3xAXl6e4VhkZCTt27fH2tra0BYWFsaJEye4fv26oU9oaKjRc4aFhREZGXnH18zOziY1NdXoVu7pcmHt67BytJoYNewJwzdKYiSEEEIUgdmMHI0dO5bmzZtTtWpVdu7cydSpU4mLi+Ojjz4CID4+Hj8/P6PHeHh4GI65uroSHx9vaMvfJz4+/o6vO3v2bGbNmlXCZ1OKMq7BsiFw7m/1fqdp6uaxsj+aEEIIUSQm/cacMmVKgUnWt9+OHz8OwMSJE+nYsSONGzfm5Zdf5sMPP+R///sf2dnZpRrj1KlTSUlJMdwuXLhQqq/3QOKPwDcd1cTI2gH6LYEOr0tiJIQQQhSDSUeOXn31VYYOHXrXPnXqFH4pqHXr1uTl5XHu3Dn8/f3x9PQkISHBqM/N+zfnKd2pz53mMQHY2NhgY2Nzr1MxvaN/wopXIDcTXP3g2V/AvaGpoxJCCCHMjkmTIzc3N9zc3O7rsQcPHkSr1eLu7g5ASEgI06ZNIzc3FysrdW+wjRs34u/vj6urq6FPREQE48ePNzzPxo0bCQkJebATMSW9Hra8B3//n3q/Tid4aiHYVzVtXEIIIYSZMovrLZGRkXzyySccOnSIs2fPsmTJEiZMmMDAgQMNic9zzz2HtbU1w4cP5+jRo/z66698+umnTJw40fA848aNIzw8nA8//JDjx4/z1ltvsXfvXkaPHm2qU3swWanq/mg3E6OQ0TDgd0mMhBBCiAegURRFMXUQ97J//35eeeUVjh8/TnZ2Nn5+fgwaNIiJEycaXfI6fPgwo0aNYs+ePVSvXp0xY8YwefJko+datmwZ06dP59y5c9SvX5958+bx+OOPFzmW1NRUnJ2dSUlJwcnJqcTOsdiunlYTo6snwMIGev0PmvQzXTxCCCFEOVac72+zSI7Kk3KRHJ3aBL8Pg+wUcPSG/j+p+6QJIYQQolDF+f42m6X8AnXj2H8+hU1vAQr4tIZnfgRHj3s9UgghhBBFJMmRucjJhJVjIOp39X7zwfD4/4GlGaykE0IIIcyIJEfmIPkC/DoA4g6B1hK6zoGHXpD90YQQQohSIMlReXd+J/w2GDKugH01eOYH8H3E1FEJIYQQFZYkR+WFXqcmQukJ4OABtdvCvsWw7nXQ54FnMPT/GVxqmTpSIYQQokKT5Kg8iF4J4ZMh9fKtNit7tdo1QKM+8MQXYG1vmviEEEKISkSSI1OLXqleNuO2igo3E6PgZ6DP1zK/SAghhCgjZlEhu8LS69QRo9sTo/zO/wOKvsxCEkIIISo7SY5M6fxO40tphUm9pPYTQgghRJmQ5MiU0hNKtp8QQgghHpgkR6bkUMTK1kXtJ4QQQogHJsmRKdVuC07ewJ0mW2vAqYbaTwghhBBlQpIjU9JaQNe5/925PUH6737XOWo/IYQQQpQJSY5MLbCXWvXaycu43clbbQ/sZZq4hBBCiEpK6hyVB4G9IKB7wQrZMmIkhBBClDlJjsoLrQX4tTN1FEIIIUSlJ5fVhBBCCCHykeRICCGEECIfSY6EEEIIIfKR5EgIIYQQIh9JjoQQQggh8pHkSAghhBAiH0mOhBBCCCHykeRICCGEECIfSY6EEEIIIfKRCtnFpCgKAKmpqSaORAghhBBFdfN7++b3+N1IclRMaWlpAPj4+Jg4EiGEEEIUV1paGs7Oznfto1GKkkIJA71ez+XLl3F0dESj0ZToc6empuLj48OFCxdwcnIq0ecuDyr6+UHFP0c5P/NX0c9Rzs/8ldY5KopCWloa3t7eaLV3n1UkI0fFpNVqqVmzZqm+hpOTU4X9pYeKf35Q8c9Rzs/8VfRzlPMzf6VxjvcaMbpJJmQLIYQQQuQjyZEQQgghRD6SHJUjNjY2zJw5ExsbG1OHUioq+vlBxT9HOT/zV9HPUc7P/JWHc5QJ2UIIIYQQ+cjIkRBCCCFEPpIcCSGEEELkI8mREEIIIUQ+khwJIYQQQuQjyZEJbN++nZ49e+Lt7Y1Go2HFihVGxxVF4c0338TLyws7OztCQ0M5deqUaYItptmzZ/PQQw/h6OiIu7s7vXv35sSJE0Z9srKyGDVqFNWqVcPBwYG+ffuSkJBgooiLb/78+TRu3NhQoCwkJIR169YZjpv7+d1uzpw5aDQaxo8fb2gz93N866230Gg0RreAgADDcXM/P4BLly4xcOBAqlWrhp2dHcHBwezdu9dw3Jw/Z3x9fQu8fxqNhlGjRgEV4/3T6XTMmDEDPz8/7OzsqFu3Lu+8847RvmDm/B6Cuo3H+PHjqV27NnZ2drRt25Y9e/YYjpv0/BRR5tauXatMmzZNWb58uQIof/75p9HxOXPmKM7OzsqKFSuUQ4cOKb169VL8/PyUGzdumCbgYggLC1MWLVqkREVFKQcPHlQef/xxpVatWkp6erqhz8svv6z4+PgoERERyt69e5U2bdoobdu2NWHUxbNy5UplzZo1ysmTJ5UTJ04ob7zxhmJlZaVERUUpimL+55ff7t27FV9fX6Vx48bKuHHjDO3mfo4zZ85UGjVqpMTFxRluV65cMRw39/NLSkpSateurQwdOlTZtWuXcvbsWWX9+vXK6dOnDX3M+XMmMTHR6L3buHGjAihbtmxRFMX83z9FUZT33ntPqVatmrJ69WolJiZGWbZsmeLg4KB8+umnhj7m/B4qiqI888wzSmBgoLJt2zbl1KlTysyZMxUnJyfl4sWLiqKY9vwkOTKx25MjvV6veHp6Kh988IGhLTk5WbGxsVF++eUXE0T4YBITExVA2bZtm6Io6rlYWVkpy5YtM/Q5duyYAiiRkZGmCvOBubq6Kt9++22FOr+0tDSlfv36ysaNG5UOHToYkqOKcI4zZ85UmjRpUuixinB+kydPVh555JE7Hq9onzPjxo1T6tatq+j1+grx/imKonTv3l0ZNmyYUVufPn2UAQMGKIpi/u9hZmamYmFhoaxevdqovXnz5sq0adNMfn5yWa2ciYmJIT4+ntDQUEObs7MzrVu3JjIy0oSR3Z+UlBQAqlatCsC+ffvIzc01Or+AgABq1aplluen0+lYunQpGRkZhISEVKjzGzVqFN27dzc6F6g47+GpU6fw9vamTp06DBgwgNjYWKBinN/KlStp2bIlTz/9NO7u7jRr1oxvvvnGcLwifc7k5OTw008/MWzYMDQaTYV4/wDatm1LREQEJ0+eBODQoUPs2LGDbt26Aeb/Hubl5aHT6bC1tTVqt7OzY8eOHSY/P9l4tpyJj48HwMPDw6jdw8PDcMxc6PV6xo8fz8MPP0xQUBCgnp+1tTUuLi5Gfc3t/I4cOUJISAhZWVk4ODjw559/EhgYyMGDByvE+S1dupT9+/cbXf+/qSK8h61bt2bx4sX4+/sTFxfHrFmzaNeuHVFRURXi/M6ePcv8+fOZOHEib7zxBnv27GHs2LFYW1szZMiQCvU5s2LFCpKTkxk6dChQMX4/AaZMmUJqaioBAQFYWFig0+l47733GDBgAGD+3xWOjo6EhITwzjvv0LBhQzw8PPjll1+IjIykXr16Jj8/SY5EqRk1ahRRUVHs2LHD1KGUOH9/fw4ePEhKSgq///47Q4YMYdu2baYOq0RcuHCBcePGsXHjxgJ/1VUUN//6BmjcuDGtW7emdu3a/Pbbb9jZ2ZkwspKh1+tp2bIl77//PgDNmjUjKiqKBQsWMGTIEBNHV7K+++47unXrhre3t6lDKVG//fYbS5Ys4eeff6ZRo0YcPHiQ8ePH4+3tXWHewx9//JFhw4ZRo0YNLCwsaN68Oc8++yz79u0zdWiyWq288fT0BCiwsiIhIcFwzByMHj2a1atXs2XLFmrWrGlo9/T0JCcnh+TkZKP+5nZ+1tbW1KtXjxYtWjB79myaNGnCp59+WiHOb9++fSQmJtK8eXMsLS2xtLRk27ZtfPbZZ1haWuLh4WH253g7FxcXGjRowOnTpyvEe+jl5UVgYKBRW8OGDQ2XDivK58z58+fZtGkTL7zwgqGtIrx/AJMmTWLKlCn079+f4OBgBg0axIQJE5g9ezZQMd7DunXrsm3bNtLT07lw4QK7d+8mNzeXOnXqmPz8JDkqZ/z8/PD09CQiIsLQlpqayq5duwgJCTFhZEWjKAqjR4/mzz//ZPPmzfj5+Rkdb9GiBVZWVkbnd+LECWJjY83i/O5Er9eTnZ1dIc7v0Ucf5ciRIxw8eNBwa9myJQMGDDD829zP8Xbp6emcOXMGLy+vCvEePvzwwwVKaJw8eZLatWsD5v85c9OiRYtwd3ene/fuhraK8P4BZGZmotUaf0VbWFig1+uBivMeAlSpUgUvLy+uX7/O+vXreeKJJ0x/fqU+5VsUkJaWphw4cEA5cOCAAigfffSRcuDAAeX8+fOKoqjLF11cXJS//vpLOXz4sPLEE0+YzfLMkSNHKs7OzsrWrVuNltpmZmYa+rz88stKrVq1lM2bNyt79+5VQkJClJCQEBNGXTxTpkxRtm3bpsTExCiHDx9WpkyZomg0GmXDhg2Kopj/+RUm/2o1RTH/c3z11VeVrVu3KjExMco///yjhIaGKtWrV1cSExMVRTH/89u9e7diaWmpvPfee8qpU6eUJUuWKPb29spPP/1k6GPOnzOKoig6nU6pVauWMnny5ALHzP39UxRFGTJkiFKjRg3DUv7ly5cr1atXV15//XVDH3N/D8PDw5V169YpZ8+eVTZs2KA0adJEad26tZKTk6MoimnPT5IjE9iyZYsCFLgNGTJEURR1ieaMGTMUDw8PxcbGRnn00UeVEydOmDboIirsvABl0aJFhj43btxQXnnlFcXV1VWxt7dXnnzySSUuLs50QRfTsGHDlNq1ayvW1taKm5ub8uijjxoSI0Ux//MrzO3JkbmfY79+/RQvLy/F2tpaqVGjhtKvXz+jGkDmfn6KoiirVq1SgoKCFBsbGyUgIED5+uuvjY6b8+eMoijK+vXrFaDQmCvC+5eamqqMGzdOqVWrlmJra6vUqVNHmTZtmpKdnW3oY+7v4a+//qrUqVNHsba2Vjw9PZVRo0YpycnJhuOmPD+NouQrtymEEEIIUcnJnCMhhBBCiHwkORJCCCGEyEeSIyGEEEKIfCQ5EkIIIYTIR5IjIYQQQoh8JDkSQgghhMhHkiMhhBBCiHwkORJCCCGEyEeSIyGEKAVvvfUWTZs2NdwfOnQovXv3Nlk8Qoiik+RICFFuDB06FI1Gg0ajwdramnr16vH222+Tl5dn6tDuSqPRsGLFCqO21157zWjTTCGE+bA0dQBCCJFf165dWbRoEdnZ2axdu5ZRo0ZhZWXF1KlTi/U8Op0OjUZTYGfzsuLg4ICDg4NJXlsI8WBk5EgIUa7Y2Njg6elJ7dq1GTlyJKGhoaxcuZLs7Gxee+01atSoQZUqVWjdujVbt241PG7x4sW4uLiwcuVKAgMDsbGxITY2luzsbCZPnoyPjw82NjbUq1eP7777zvC4qKgounXrhoODAx4eHgwaNIirV68ajnfs2JGxY8fy+uuvU7VqVTw9PXnrrbcMx319fQF48skn0Wg0hvu3X1a7nV6vZ/bs2fj5+WFnZ0eTJk34/fffS+JHKIR4QJIcCSHKNTs7O3Jychg9ejSRkZEsXbqUw4cP8/TTT9O1a1dOnTpl6JuZmcncuXP59ttvOXr0KO7u7gwePJhffvmFzz77jGPHjvHVV18ZRnSSk5Pp3LkzzZo1Y+/evYSHh5OQkMAzzzxjFMP3339PlSpV2LVrF/PmzePtt99m48aNAOzZsweARYsWERcXZ7h/L7Nnz+aHH35gwYIFHD16lAkTJjBw4EC2bdtWEj82IcQDkMtqQohySVEUIiIiWL9+Pc8++yyLFi0iNjYWb29vQJ3TEx4ezqJFi3j//fcByM3N5csvv6RJkyYAnDx5kt9++42NGzcSGhoKQJ06dQyv8fnnn9OsWTPD4wEWLlyIj48PJ0+epEGDBgA0btyYmTNnAlC/fn0+//xzIiIieOyxx3BzcwPAxcUFT0/PIp1bdnY277//Pps2bSIkJMQQ144dO/jqq6/o0KHDff/chBAPTpIjIUS5snr1ahwcHMjNzUWv1/Pcc8/x1FNPsXjxYkOyclN2djbVqlUz3Le2tqZx48aG+wcPHsTCwuKOycahQ4fYsmVLoXODzpw5Y5Qc5efl5UViYuJ9n+Pp06fJzMzkscceM2rPycmhWbNm9/28QoiSIcmREKJc6dSpE/Pnz8fa2hpvb28sLS359ddfsbCwYN++fVhYWBj1z5/Y2NnZodFojO7fTXp6Oj179mTu3LkFjnl5eRn+bWVlZXRMo9Gg1+uLdV63vy7AmjVrqFGjhtExGxub+35eIUTJkORICFGuVKlShXr16hm1NWvWDJ1OR2JiIu3atSvycwUHB6PX69m2bZvhslp+zZs3548//sDX1xdLy/v/OLSyskKn0xW5f/4J43IJTYjyRyZkCyHKvQYNGjBgwAAGDx7M8uXLiYmJYffu3cyePZs1a9bc8XG+vr4MGTKEYcOGsWLFCmJiYti6dSu//fYbAKNGjSIpKYlnn32WPXv2cObMGdavX8/zzz9frGTH19eXiIgI4uPjuX79+j37Ozo68tprrzFhwgS+//57zpw5w/79+/nf//7H999/X+TXFUKUDkmOhBBmYdGiRQwePJhXX30Vf39/evfuzZ49e6hVq9ZdHzd//nyeeuopXnnlFQICAnjxxRfJyMgAwNvbm3/++QedTkeXLl0IDg5m/PjxuLi4FKs+0ocffsjGjRvx8fEp8pyhd955hxkzZjB79mwaNmxI165dWbNmDX5+fkV+XSFE6dAoiqKYOgghhBBCiPJCRo6EEEIIIfKR5EgIIYQQIh9JjoQQQggh8pHkSAghhBAiH0mOhBBCCCHykeRICCGEECIfSY6EEEIIIfKR5EgIIYQQIh9JjoQQQggh8pHkSAghhBAiH0mOhBBCCCHy+X/C1QfHa5/nVAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "percentiles = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n",
    "plt.figure()\n",
    "plt.plot(\n",
    "    percentiles, np.percentile(outcome, percentiles), \n",
    "    marker='o', label='Outcome'\n",
    ")\n",
    "plt.plot(\n",
    "    percentiles, np.percentile(max_loss, percentiles), \n",
    "    marker='o', label='Max Loss'\n",
    ")\n",
    "plt.axhline(y=0, color='gray', linestyle='--', linewidth=1)\n",
    "plt.xlabel('Percentile')\n",
    "plt.ylabel('Units of minimum bet')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}