{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nwaAZRu1NTiI"
      },
      "source": [
        "# PPO\n",
        "\n",
        "\n",
        "#### This version uses stable baseline PPO using a custom enviroment, synthetic data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "# !pip install yfinance\n",
        "\n",
        "# # install talib in colab\n",
        "# !wget http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz\n",
        "# !tar -xzvf ta-lib-0.4.0-src.tar.gz\n",
        "# %cd ta-lib\n",
        "# !./configure --prefix=/usr\n",
        "# !make\n",
        "# !make install\n",
        "# !pip install Ta-Lib\n",
        "# import talib as ta"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "LNXxxKojNTiL"
      },
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "import gym\n",
        "from gym import spaces\n",
        "from gym.utils import seeding\n",
        "from gym import wrappers\n",
        "\n",
        "from stable_baselines3 import PPO\n",
        "from stable_baselines3.common.env_checker import check_env\n",
        "\n",
        "from tqdm.notebook import tqdm\n",
        "from collections import deque\n",
        "import numpy as np\n",
        "import random\n",
        "from matplotlib import pyplot as plt\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "import joblib\n",
        "\n",
        "import talib as ta\n",
        "import yfinance as yf\n",
        "import pandas as pd\n",
        "\n",
        "import io\n",
        "import base64\n",
        "from IPython.display import HTML, Video\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [],
      "source": [
        "def get_syntetic_data(tf, start_date, end_date, plot=True, add_noise=None):\n",
        "    df = pd.date_range(start=start_date, end=end_date, freq=tf)\n",
        "    df = df.to_frame()\n",
        "\n",
        "    df['v1'] = np.arange(len(df.index))\n",
        "    df[['Open','High','Low','Close','Volume']] = 0.0\n",
        "    df = df.drop([0], axis=1)\n",
        "\n",
        "    # df[\"Close\"]=df[\"v1\"].map(lambda x: np.sin(x)+10 )\n",
        "    df[\"Close\"]=df[\"v1\"].map(lambda x: np.sin(x)+10 + np.sin(x/2) )\n",
        "    if add_noise is not None: # could be 0.5\n",
        "        noise = np.random.normal(0, add_noise, len(df))\n",
        "        df[\"Close\"] += noise\n",
        "\n",
        "    if plot:\n",
        "        plt.figure(figsize=(15,6))\n",
        "        df['Close'].tail(30).plot()\n",
        "\n",
        "    df[\"Open\"]=df[\"Close\"].shift(1)\n",
        "    df = df.dropna()\n",
        "    x = 1.5\n",
        "    df[\"High\"] = np.where( df[\"Close\"] > df['Open'], df[\"Close\"]+x, df[\"Open\"]+x )\n",
        "    df[\"Low\"] = np.where( df[\"Close\"] < df['Open'], df[\"Close\"]-x, df[\"Open\"]-x )\n",
        "    df[\"Volume\"] = 10\n",
        "    return df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "from enum import Enum\n",
        "class Actions(Enum):\n",
        "    Sell = 0\n",
        "    Buy = 1\n",
        "    Do_nothing = 2\n",
        "\n",
        "class CustTradingEnv(gym.Env):\n",
        "\n",
        "    def __init__(self, df, max_steps=0, random_start=True, scaler=None):\n",
        "        self.seed(seed=43)\n",
        "        self.df = df\n",
        "        if scaler is None:\n",
        "            self.scaler = MinMaxScaler()\n",
        "        else:\n",
        "            self.scaler = scaler\n",
        "        self.prices, self.signal_features = self._process_data()\n",
        "\n",
        "        # spaces\n",
        "        self.action_space = spaces.Discrete(3)\n",
        "        self.observation_space = spaces.Box(low=0, high=1999, shape=(9,) , dtype=np.float64)\n",
        "\n",
        "        # episode\n",
        "        self._start_tick = 0\n",
        "        self._end_tick = 0\n",
        "        self._done = None\n",
        "        self._current_tick = None\n",
        "        self._last_trade_tick = None\n",
        "        self._position = None\n",
        "        self._position_history = None\n",
        "        self._total_reward = None\n",
        "        self._total_profit = None\n",
        "        self._first_rendering = None\n",
        "        self.history = None\n",
        "        self._max_steps = max_steps\n",
        "        self._start_episode_tick = None\n",
        "        self._trade_history = None\n",
        "        self._trade_tick_history = None\n",
        "        self._random_start = random_start\n",
        "\n",
        "    def reset(self):\n",
        "        self._done = False\n",
        "        if self._random_start:\n",
        "            self._start_episode_tick = np.random.randint(1,high=len(self.df)- self._max_steps )\n",
        "            self._end_tick = self._start_episode_tick + self._max_steps\n",
        "        else:\n",
        "            self._start_episode_tick = 1\n",
        "            self._end_tick = len(self.df)-1\n",
        "        # self._start_episode_tick = np.random.randint(1,len(self.df)- self._max_steps )\n",
        "        # self._end_tick = self._start_episode_tick + self._max_steps\n",
        "        self._current_tick = self._start_episode_tick\n",
        "        self._last_trade_tick = self._current_tick - 1\n",
        "        self._position = 0\n",
        "        self._position_history = [-1] * (len(self.prices)) \n",
        "        # self._position_history = (self.window_size * [None]) + [self._position]\n",
        "        self._total_reward = 0.\n",
        "        self._total_profit = 0.\n",
        "        self._trade_history = []\n",
        "        self._trade_tick_history = []\n",
        "        self.history = {}\n",
        "        return self._get_observation()\n",
        "\n",
        "\n",
        "    def step(self, action):\n",
        "        self._done = False\n",
        "        self._current_tick += 1\n",
        "\n",
        "        if self._current_tick == self._end_tick:\n",
        "            self._done = True\n",
        "\n",
        "        step_reward = self._calculate_reward(action)\n",
        "        self._total_reward += step_reward\n",
        "\n",
        "        observation = self._get_observation()\n",
        "        info = dict(\n",
        "            total_reward = self._total_reward,\n",
        "            total_profit = self._total_profit,\n",
        "            position = self._position,\n",
        "            action = action\n",
        "        )\n",
        "        self._update_history(info)\n",
        "\n",
        "        return observation, step_reward, self._done, info\n",
        "\n",
        "    def seed(self, seed=None):\n",
        "        self.np_random, seed = seeding.np_random(seed)\n",
        "        return [seed]\n",
        "        \n",
        "    def _get_observation(self):\n",
        "        return np.concatenate( [[self._position], self.signal_features[self._current_tick]] )\n",
        "\n",
        "    # def _get_observation(self):\n",
        "    #     return self.signal_features[self._current_tick]\n",
        "\n",
        "    def _update_history(self, info):\n",
        "        if not self.history:\n",
        "            self.history = {key: [] for key in info.keys()}\n",
        "\n",
        "        for key, value in info.items():\n",
        "            self.history[key].append(value)\n",
        "\n",
        "\n",
        "    def render(self, mode='human'):\n",
        "        window_ticks = np.arange(len(self.prices))\n",
        "        prices = self.prices\n",
        "        # prices = self.prices[self._start_episode_tick:self._end_tick+1]\n",
        "        plt.plot(prices)\n",
        "\n",
        "        open_buy = []\n",
        "        close_buy = []\n",
        "        open_sell = []\n",
        "        close_sell = []\n",
        "        do_nothing = []\n",
        "        penalty = []\n",
        "        action_not_in_table = []\n",
        "\n",
        "        for i, tick in enumerate(window_ticks):\n",
        "            if self._position_history[i] == 1:\n",
        "                open_buy.append(tick)\n",
        "            elif self._position_history[i] == 2 :\n",
        "                close_buy.append(tick)\n",
        "            elif self._position_history[i] == 3 :\n",
        "                open_sell.append(tick)\n",
        "            elif self._position_history[i] == 4 :\n",
        "                close_sell.append(tick)\n",
        "            elif self._position_history[i] == 0 :\n",
        "                do_nothing.append(tick)\n",
        "            elif self._position_history[i] == 5 :\n",
        "                penalty.append(tick)\n",
        "            elif self._position_history[i] == 6 :\n",
        "                action_not_in_table.append(tick)\n",
        "\n",
        "        plt.plot(open_buy, prices[open_buy], 'go', marker=\"^\")\n",
        "        plt.plot(close_buy, prices[close_buy], 'go', marker=\"v\")\n",
        "        plt.plot(open_sell, prices[open_sell], 'ro', marker=\"v\")\n",
        "        plt.plot(close_sell, prices[close_sell], 'ro', marker=\"^\")\n",
        "    \n",
        "        plt.plot(do_nothing, prices[do_nothing], 'oc')\n",
        "        plt.plot(penalty, prices[penalty], 'yo')\n",
        "\n",
        "        plt.plot(action_not_in_table, prices[action_not_in_table], 'ob')\n",
        "\n",
        "        plt.suptitle(\n",
        "            \"Total Reward: %.6f\" % self._total_reward + ' ~ ' +\n",
        "            \"Total Profit: %.6f\" % self._total_profit\n",
        "        )\n",
        "\n",
        "    # the action is taken when the market is off after the session ends and we receive the close price of the day\n",
        "    # this will be the current price \n",
        "    def _calculate_reward(self, action):\n",
        "        step_reward = 0\n",
        "        \n",
        "        if action is None:\n",
        "            self._position_history[self._current_tick-1]=6\n",
        "            return 0\n",
        "\n",
        "        current_price = self.prices[self._current_tick]\n",
        "        last_price = self.prices[self._current_tick - 1]\n",
        "        price_diff = current_price - last_price\n",
        "\n",
        "        penalty = -1 * last_price * 0.01\n",
        "        # OPEN BUY - 1\n",
        "        if action == Actions.Buy.value and self._position == 0:\n",
        "            self._position = 1\n",
        "            step_reward += price_diff\n",
        "            self._last_trade_tick = self._current_tick - 1\n",
        "            self._position_history[self._current_tick-1]=1\n",
        "\n",
        "        # CLOSE BUY - 2\n",
        "        elif action == Actions.Sell.value and self._position > 0:\n",
        "            self._position = 0\n",
        "            step_reward += self.prices[self._current_tick-1] - self.prices[self._last_trade_tick] \n",
        "            self._total_profit += step_reward\n",
        "            self._position_history[self._current_tick-1]=2\n",
        "            self._trade_history.append(step_reward)\n",
        "            self._trade_tick_history.append((self._last_trade_tick, self._current_tick-1, self.prices[self._last_trade_tick], self.prices[self._current_tick-1], step_reward))\n",
        "\n",
        "        elif action == Actions.Buy.value and self._position > 0:\n",
        "            step_reward += penalty\n",
        "            self._position_history[self._current_tick-1]=5\n",
        "        # CLOSE SELL - 4\n",
        "        elif action == Actions.Buy.value and self._position < 0:\n",
        "            self._position = 0\n",
        "            step_reward += -1 * (self.prices[self._current_tick-1] - self.prices[self._last_trade_tick]) \n",
        "            self._total_profit += step_reward\n",
        "            self._position_history[self._current_tick-1]=4\n",
        "            self._trade_history.append(step_reward)\n",
        "            self._trade_tick_history.append((self._last_trade_tick, self._current_tick-1, self.prices[self._last_trade_tick], self.prices[self._current_tick-1], step_reward))\n",
        "\n",
        "        # OPEN SELL - 3\n",
        "        elif action == Actions.Sell.value and self._position == 0:\n",
        "            self._position = -1\n",
        "            step_reward += -1 * price_diff\n",
        "            self._last_trade_tick = self._current_tick - 1\n",
        "            self._position_history[self._current_tick-1]=3\n",
        "\n",
        "        elif action == Actions.Sell.value and self._position < 0:\n",
        "            step_reward += penalty\n",
        "            self._position_history[self._current_tick-1]=5\n",
        "\n",
        "        # DO NOTHING - 0\n",
        "        elif action == Actions.Do_nothing.value and self._position > 0:\n",
        "            step_reward += price_diff\n",
        "            self._position_history[self._current_tick-1]=0\n",
        "        elif action == Actions.Do_nothing.value and self._position < 0:\n",
        "            step_reward += -1 * price_diff\n",
        "            self._position_history[self._current_tick-1]=0\n",
        "        elif action == Actions.Do_nothing.value and self._position == 0:\n",
        "            step_reward += -1 * abs(price_diff)\n",
        "            self._position_history[self._current_tick-1]=0\n",
        "\n",
        "        return step_reward\n",
        "\n",
        "    def get_scaler(self):\n",
        "        return self.scaler\n",
        "\n",
        "    def set_scaler(self, scaler):\n",
        "        self.scaler = scaler\n",
        " \n",
        "    def _process_data(self):\n",
        "        timeperiod = 14\n",
        "        self.df = self.df.copy()\n",
        "        \n",
        "        self.df['mfi_r'] = ta.MFI(self.df['High'], self.df['Low'], self.df['Close'],self.df['Volume'], timeperiod=timeperiod)\n",
        "        _, self.df['stoch_d_r'] = ta.STOCH(self.df['High'], self.df['Low'], self.df['Close'], fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)\n",
        "        self.df['adx_r'] = ta.ADX(self.df['High'], self.df['Low'], self.df['Close'], timeperiod=timeperiod)\n",
        "        self.df['p_di'] = ta.PLUS_DI(self.df['High'], self.df['Low'], self.df['Close'], timeperiod=timeperiod)\n",
        "        self.df['m_di'] = ta.MINUS_DI(self.df['High'], self.df['Low'], self.df['Close'], timeperiod=timeperiod)\n",
        "        self.df['di'] = np.where( self.df['p_di'] > self.df['m_di'], 1, 0)\n",
        "\n",
        "        self.df = self.df.dropna()\n",
        "        # self.df['di_s']=self.df['di']\n",
        "        # self.df['mfi_s']=self.df['mfi_r']\n",
        "        # self.df['stoch_d_s']=self.df['stoch_d_r']\n",
        "        # self.df['adx_s']=self.df['adx_r']\n",
        "\n",
        "        self.df[['di_s','mfi_s','stoch_d_s','adx_s']] = self.scaler.fit_transform(self.df[['di','mfi_r','stoch_d_r','adx_r']])\n",
        "\n",
        "        self.df['s1_di'] = self.df['di_s'].shift(1)\n",
        "        self.df['s1_mfi'] = self.df['mfi_s'].shift(1)\n",
        "        self.df['s1_stoch_d'] = self.df['stoch_d_s'].shift(1)\n",
        "        self.df['s1_adx'] = self.df['adx_s'].shift(1)\n",
        "        self.df = self.df.dropna()\n",
        "\n",
        "\n",
        "        def f1(row):\n",
        "            row['state'] = [row['di_s'], row['mfi_s'], row['stoch_d_s'], row['adx_s'],row['s1_di'], row['s1_mfi'], row['s1_stoch_d'], row['s1_adx']]\n",
        "            return row\n",
        "\n",
        "        self.df = self.df.apply(f1, axis=1 )\n",
        "\n",
        "        prices = self.df.loc[:, 'Close'].to_numpy()\n",
        "        # print(self.df.head(30))\n",
        "\n",
        "        signal_features = np.stack(self.df.loc[:, 'state'].to_numpy())\n",
        "\n",
        "        return prices, signal_features"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3082\n",
            "1933\n"
          ]
        }
      ],
      "source": [
        "# Get data\n",
        "eth_usd = yf.Ticker(\"ETH-USD\")\n",
        "eth = eth_usd.history(period=\"max\")\n",
        "\n",
        "btc_usd = yf.Ticker(\"BTC-USD\")\n",
        "btc = btc_usd.history(period=\"max\")\n",
        "print(len(btc))\n",
        "print(len(eth))\n",
        "\n",
        "btc_train = eth[-3015:-200]\n",
        "# btc_test = eth[-200:]\n",
        "eth_train = eth[-1864:-200]\n",
        "eth_test = eth[-200:]\n",
        "# len(eth_train)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "synthetic_data = get_syntetic_data(tf=\"D\", start_date=\"2015-01-01\", end_date=\"2023-01-01\", add_noise=None)\n",
        "eth_train = synthetic_data[-1864:-200]\n",
        "eth_test = synthetic_data[-200:]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/Users/viewitpro/projetos/anaconda3/envs/aivai/lib/python3.9/site-packages/stable_baselines3/ppo/ppo.py:145: UserWarning: You have specified a mini-batch size of 64, but because the `RolloutBuffer` is of size `n_steps * n_envs = 8`, after every 0 untruncated mini-batches, there will be a truncated mini-batch of size 8\n",
            "We recommend using a `batch_size` that is a factor of `n_steps * n_envs`.\n",
            "Info: (n_steps=8 and n_envs=1)\n",
            "  warnings.warn(\n"
          ]
        }
      ],
      "source": [
        "# create env\n",
        "max_steps = 20  \n",
        "env = CustTradingEnv(df=eth_train, max_steps=max_steps)\n",
        "\n",
        "# check_env(env)\n",
        "\n",
        "model = PPO(\"MlpPolicy\", env, n_steps=8, verbose=0)\n",
        "# model.learn(total_timesteps=1000)\n",
        "model.learn(total_timesteps=20000)\n",
        "model.save(\"./alt/ppo_v3\")\n",
        "\n",
        "env.close()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['./alt/fin_rl_ppo_v3.h5_scaler']"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "joblib.dump(env.get_scaler(),\"./alt/fin_rl_ppo_v3.h5_scaler\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "def evaluate_agent(env, max_steps, n_eval_episodes, model, random=False):\n",
        "  \"\"\"\n",
        "  Evaluate the agent for ``n_eval_episodes`` episodes and returns average reward and std of reward.\n",
        "  :param env: The evaluation environment\n",
        "  :param n_eval_episodes: Number of episode to evaluate the agent\n",
        "  :param model: The PPO model\n",
        "  \"\"\"\n",
        "  episode_positive_perc_trades = []\n",
        "  episode_rewards = []\n",
        "  episode_profits = []\n",
        "  for episode in range(n_eval_episodes):\n",
        "#   for episode in tqdm(range(n_eval_episodes), disable=random):\n",
        "    state = env.reset()\n",
        "    step = 0\n",
        "    done = False\n",
        "    total_rewards_ep = 0\n",
        "    total_profit_ep = 0\n",
        "    \n",
        "    for step in range(max_steps):\n",
        "      # Take the action (index) that have the maximum expected future reward given that state\n",
        "      if random:\n",
        "        action = env.action_space.sample()\n",
        "      else:\n",
        "        action, _states = model.predict(state)\n",
        "        # action = model.play(state)\n",
        "    # print(action)\n",
        "        \n",
        "      new_state, reward, done, info = env.step(action)\n",
        "      total_rewards_ep += reward\n",
        "        \n",
        "      if done:\n",
        "        break\n",
        "      state = new_state\n",
        "\n",
        "    if len(env._trade_history) > 0:\n",
        "        episode_positive_perc_trades.append(np.count_nonzero(np.array(env._trade_history) > 0)/len(env._trade_history))\n",
        "    episode_rewards.append(total_rewards_ep)\n",
        "    episode_profits.append(env.history['total_profit'][-1])\n",
        "    # print(env.history)\n",
        "    # env.render()\n",
        "    # assert 0\n",
        "\n",
        "  mean_reward = np.mean(episode_rewards)\n",
        "  std_reward = np.std(episode_rewards)\n",
        "  mean_profit = np.mean(episode_profits)\n",
        "  std_profit = np.std(episode_profits)\n",
        "  positive_perc_trades = np.mean(episode_positive_perc_trades)\n",
        "\n",
        "  return mean_reward, std_reward, mean_profit, std_profit, positive_perc_trades"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(48.35490014856917,\n",
              " 3.658240349579211,\n",
              " 23.941710677775053,\n",
              " 1.8360763379803176,\n",
              " 0.9463082525265285)"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# trade with random start in the test set \n",
        "max_steps = 60 \n",
        "env_test = CustTradingEnv(df=eth_test, max_steps=max_steps, random_start=True, scaler=env.get_scaler())\n",
        "n_eval_episodes = 1000\n",
        "\n",
        "evaluate_agent(env_test, max_steps, n_eval_episodes, model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_79018/796306373.py:132: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"go\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(open_buy, prices[open_buy], 'go', marker=\"^\")\n",
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_79018/796306373.py:133: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"go\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(close_buy, prices[close_buy], 'go', marker=\"v\")\n",
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_79018/796306373.py:134: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"ro\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(open_sell, prices[open_sell], 'ro', marker=\"v\")\n",
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_79018/796306373.py:135: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"ro\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(close_sell, prices[close_sell], 'ro', marker=\"^\")\n"
          ]
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABMcAAAI1CAYAAADSGZ1/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydeZgcVdX/v9Xr7Esmk32yEggETAKE7SWECIRdEUFxI/gCLuALiKigokgE3BBQEYT3BwgvKMrmhooKSNgkIQSBECAhy2SbTJbZenqv+/uj+t6qnumeqeq61T1T93yeZx5IT0+npnKr6txzvud7NMYYA0EQBEEQBEEQBEEQBEEoSKDSB0AQBEEQBEEQBEEQBEEQlYKSYwRBEARBEARBEARBEISyUHKMIAiCIAiCIAiCIAiCUBZKjhEEQRAEQRAEQRAEQRDKQskxgiAIgiAIgiAIgiAIQlkoOUYQBEEQBEEQBEEQBEEoCyXHCIIgCIIgCIIgCIIgCGWh5BhBEARBEARBEARBEAShLJQcIwiCIAiCIAiCIAiCIJSFkmMEQRCE73j22WehaRqeffbZSh/KiEDTNFx33XWVPgyCwHXXXQdN0yp9GHl0dHTgnHPOQUtLCzRNw6233kr3EIIgCIJQDEqOEQRBEFLQNM3Wl53N5o033ognnnjC82O+77778o4tFAph8uTJuOCCC7Bt2zbP//7RyA033ABN03DwwQcP+l46ncZ3v/tdzJw5E9FoFDNnzsT3vvc9ZDIZ25/f0dGBz3/+85g8eTKqqqowffp0XHjhhXnvmT59etH1NXv27Lz3dnd342tf+xpmz56N6upqTJs2DRdeeCG2bNky6O/+zW9+g0MPPRRVVVVobW3FhRdeiN27dxc8zv/3//4fDjzwQFRVVWH27Nn42c9+Nug9To7TK3iSx87XcGzfvh3XXXcd1qxZ4/lxX3DBBXnH1tDQgHnz5uHmm29GMpmU+nd9+ctfxt/+9jdcc801eOCBB3DKKacUfN9DDz2EW2+91dXf1d7eju9+97s44ogj0NzcjLFjx+L444/HP/7xj2F/9uKLL4amaTjjjDNs/V133303Fi9ejPHjxyMajWLGjBn47Gc/i02bNuW9b+B9cODXgw8+mPf+bdu24WMf+xiamprQ0NCAD3/4w3j//fcLHoOd63kgJ510EjRNw5e+9KVB33NyPRMEQRCEE0KVPgCCIAjCHzzwwAN5f77//vvx97//fdDrBx544LCfdeONN+Kcc87BWWedJfMQi3L99ddjxowZSCQSePnll3Hffffh+eefx5tvvomqqqqyHMNoYOvWrbjxxhtRW1tb8Puf/vSn8bvf/Q7//d//jcMPPxwvv/wyrr32WmzZsgV33XXXsJ/f3t6O//qv/wIAfOELX8DkyZOxfft2vPLKK3nvu/XWW9HX15f32ubNm/Gtb30LS5cuFa/puo6TTjoJa9euxSWXXIL9998f69evxy9+8Qv87W9/w9tvv436+noAwB133IFLLrkEJ5xwAn7yk59g69atuO2227Bq1Sr8+9//zlsHv/zlL/GFL3wBH/3oR3HllVdixYoVuOyyy9Df34+vf/3rjo/TSw488MBB1+A111yDuro6fPOb33T0Wdu3b8d3v/tdTJ8+HfPnz5d4lIWJRqP43//9XwBAV1cXHn30UVx11VVYuXIlfvOb30j7e55++ml8+MMfxlVXXSVe23///RGPxxGJRMRrDz30EN58801cccUVJf9dv//97/GDH/wAZ511FpYtW4ZMJoP7778fJ510Eu655x589rOfLfhzq1atwn333efofvTaa69hxowZ+NCHPoTm5mZs3LgRd999N/70pz/h9ddfx6RJkwAAxx133KA1AgC33HILXn/9dZxwwgnitb6+PixZsgTd3d34xje+gXA4jFtuuQWLFy/GmjVr0NLSIt5r93q28thjj+Gll14q+D0n1zNBEARBOIYRBEEQhAdceumlrNTHTG1tLVu2bFnJf/czzzzDALBnnnlmyPfde++9DABbuXJl3utf//rXGQD28MMPl3wM5aSvr2/I7wNg3/nOd1z/PR//+MfZBz/4QbZ48WI2d+7cvO+98sorDAC79tpr817/yle+wjRNY6+//vqwn3/qqaeyGTNmsN27dzs+tuXLlzMA7IUXXhCvvfDCCwwA+/nPf5733nvuuYcBYI899hhjjLFkMsmamprYcccdx3RdF+/74x//yACwn/70p+K1/v5+1tLSwk4//fS8z/zUpz7Famtr2d69ex0fZ7mZO3cuW7x4seOfW7lyJQPA7r333pL/7u985zu27gvLli1jtbW1ea9ls1l2+OGHMwBs27ZtBX9O13XW39/v6Jg0TWOXXnrpsO87/fTT2bRp0xx99kDefPNN1tnZmfdaIpFgc+bMYVOmTCn4M7qus6OPPpr993//N5s2bdqgteeEVatWMQDspptuGvJ9/f39rL6+np100kl5r//gBz9gANgrr7wiXnv77bdZMBhk11xzTd57nV7P8XicTZ8+nV1//fUMwKB/E7vXM0EQBEGUArVVEgRBEGUjFovhK1/5Ctra2hCNRnHAAQfgxz/+MRhj4j2apiEWi+FXv/qVaOu54IILABiqm0suuQQHHHAAqqur0dLSgnPPPXdQm5BbFi1aBADYsGFD3uvr1q3DOeecgzFjxqCqqgqHH344/vCHP4jvd3V1IRgM4qc//al4bffu3QgEAmhpacn7Pb/4xS9iwoQJ4s8rVqzAueeei6lTpyIajaKtrQ1f/vKXEY/H847hggsuQF1dHTZs2IDTTjsN9fX1+NSnPgUASCaT+PKXv4zW1lbU19fjQx/6ELZu3Vrwd1y3bp2jVqTnnnsOjzzySNG2shUrVgAAzjvvvLzXzzvvPDDG8PDDDw/5+evWrcNf/vIXfPWrX0VLSwsSiQTS6bTt43vooYcwY8YMHHPMMeK1np4eAMD48ePz3jtx4kQAQHV1NQDgzTffRFdXFz7+8Y/ntReeccYZqKury1MpPfPMM9izZw8uueSSvM+89NJLEYvF8Oc//9nxcY4E3n//fZx77rkYM2YMampqcNRRR+X9Ls8++ywWLlwIAPjsZz8rrs377rsPgP3164ZAIIDjjz8eAMQ1P336dJxxxhn429/+hsMPPxzV1dX45S9/aet34u2EjDHcfvvtee2lAz3Hjj/+ePz5z3/G5s2bxfumT58uPmvLli1Yt27dsL/D3LlzMXbs2LzXotEoTjvtNGzduhW9vb2DfuaBBx7Am2++iRtuuMHuqSoKP+aurq4h3/fHP/4Rvb294t7CeeSRR7Bw4UKxFgBgzpw5OOGEE/Db3/5WvFbK9fzDH/4Quq7nKfis2L2eCYIgCKIUKDlGEARBlAXGGD70oQ/hlltuwSmnnIKf/OQnOOCAA/DVr34VV155pXjfAw88gGg0ikWLFuGBBx7AAw88gM9//vMAgJUrV+LFF1/Eeeedh5/+9Kf4whe+gH/+8584/vjj0d/fL+1Y+ca7ublZvPbWW2/hqKOOwttvv42rr74aN998M2pra3HWWWfh8ccfBwA0NTXh4IMPxnPPPSd+7vnnn4emadi7dy/Wrl0rXl+xYoVIwgHA7373O/T39+OLX/wifvazn+Hkk0/Gz372M5x//vmDji+TyeDkk0/GuHHj8OMf/xgf/ehHAQAXXXQRbr31VixduhTf//73EQ6Hcfrppxf8HQ888MCCn12IbDaL//mf/8FFF12EQw45pOB7uA/UwA1qTU0NAODVV18d8u/gnkvjx4/HCSecgOrqalRXV+PUU08dNvn52muv4e2338YnP/nJvNcPP/xw1NbW4tprr8XTTz+Nbdu24V//+he+9rWvYeHChTjxxBOHPHb+2muvvQZd18XfxT/bymGHHYZAICC+7+Q4K01HRweOOeYY/O1vf8Mll1yCG264AYlEAh/60IfE2j7wwANx/fXXAwA+97nPiWvzuOOOA+Bs/bqBJ6yt7XvvvPMOPvGJT+Ckk07Cbbfdhvnz59v6nazthCeddJL4nQrxzW9+E/Pnz8fYsWPF+6yJ4vPPP99Wy3gxdu7ciZqaGnG9cHp7e/H1r38d3/jGN/KS6U7Ys2cPdu3ahVWrVom2TWurZCEefPBBVFdX4+yzzxav6bqO//znP4PWPgAcccQR2LBhg0juOb2et2zZgu9///v4wQ9+UDTJZfd6JgiCIIiSqKhujSAIgvAtA9sqn3jiCQaAfe9738t73znnnMM0TWPr168XrxVrqyzULvXSSy8xAOz+++8Xrzltq/zHP/7BOjs7WXt7O3vkkUdYa2sri0ajrL29Xbz3hBNOYIcccghLJBLiNV3X2THHHMNmz56d93uPHz9e/PnKK69kxx13HBs3bhy74447GGOM7dmzh2maxm677bYhf7ebbrqJaZrGNm/eLF5btmwZA8CuvvrqvPeuWbOGAWCXXHJJ3uuf/OQnC7ZVArDdWvfzn/+cNTY2sl27djHGWMG2ykcffZQBYA888EDe63feeScDwA4++OAh/47LLruMAWAtLS3slFNOYQ8//DD70Y9+xOrq6tisWbNYLBYr+rNf+cpXGAC2du3aQd/705/+xCZOnMgAiK+TTz6Z9fb2ivd0dnYyTdPYhRdemPez69atEz/DW8MuvfRSFgwGCx5Ha2srO++880o6zqHIZDJ5xzuQrq4uR583sK3yiiuuYADYihUrxGu9vb1sxowZbPr06SybzTLGhm6rtLt+nbZVdnZ2ss7OTrZ+/Xp24403Mk3T2Ac+8AHxvmnTpjEA7K9//Wvez9v9nRhjBVv4Ct1DhmqrXLx4cclt5O+99x6rqqpin/nMZwZ976qrrmIzZswQ951S2iqj0ahYxy0tLXltwoXYs2cPi0Qi7GMf+1je652dnQwAu/766wf9zO23384AsHXr1jHGnF/P55xzDjvmmGPEnwv9mzBm73omCIIgiFIg5RhBEARRFp588kkEg0Fcdtllea9/5StfAWMMf/nLX4b9DKuiIJ1OY8+ePdhvv/3Q1NSE1atXl3xsJ554IlpbW9HW1oZzzjkHtbW1+MMf/oApU6YAAPbu3Yunn34aH/vYx9Db24vdu3dj9+7d2LNnD04++WS89957YrrlokWL0NHRgXfeeQeAoRA77rjjsGjRItF6+Pzzz4Mxlqccs/5usVgMu3fvxjHHHAPGWEE10he/+MW8Pz/55JMAMOj8FjMPZ4zZmhy6Z88efPvb38a1116L1tbWou877bTTMG3aNFx11VV47LHHsHnzZvz2t7/FN7/5TYRCoWHb67hx/YQJE/DnP/8ZH/vYx3DVVVfh7rvvxoYNG/DQQw8V/Dld1/Gb3/wGCxYsKKjcaW1txYIFC3DDDTfgiSeewHXXXYcVK1bkGZ+PHTsWH/vYx/CrX/0KN998M95//32sWLECH//4xxEOhwFAHP9Ak3YrVVVVRX/P4Y6zEOvXr8d5552H+vp61NfXY8KECbjwwgvxxBNPYOPGjXjttdfwla98BZ/73OdsfV4xnnzySRxxxBE49thjxWt1dXX43Oc+h02bNuUpHovhdP3aIRaLobW1Fa2trdhvv/3wjW98A0cffbRQfnFmzJiBk08+Wfrv5IRnn302r23aLv39/Tj33HNRXV2N73//+3nfe/fdd3HbbbfhRz/6EaLRaMnH9pe//AVPPvkkbr75ZkydOhWxWGzI9z/yyCNIpVKDWir52i50LHxQAH+Pk+v5mWeewaOPPmprEqid65kgCIIgSoGmVRIEQRBlYfPmzZg0adKgaWI8UbB58+ZhPyMej+Omm27Cvffei23btuVtRru7u0s+tttvvx37778/uru7cc899+C5557L2wCuX78ejDFce+21uPbaawt+xq5duzB58mSR8FqxYgWmTJmC1157Dd/73vfQ2tqKH//4x+J7DQ0NmDdvnvj5LVu24Nvf/jb+8Ic/YN++fXmfPfB3C4VCInHH2bx5MwKBAGbNmpX3+gEHHODwbOTzrW99C2PGjMH//M//DPm+qqoqsQnmbZ7RaBQ//OEPccMNN6Curm7In+fJlY997GMIBMza3bnnnovPfOYzePHFF3HRRRcN+rl//etf2LZtG7785S8P+t7777+PJUuW4P777xfH9OEPfxjTp0/HBRdcgL/85S849dRTARgTKOPxOK666irhefTpT38as2bNwmOPPSaOv7q6GqlUquDvkEgkiraEDXWcxbj44otRV1eHu+++G7W1tVi5ciX+8Ic/4J577hHvmT9/Pn72s5/Z/sxCbN68GUceeeSg163X5sEHHzzkZzhZv3apqqrCH//4RwDGWpoxY8agdQ8YybGByPidvCabzeK8887D2rVr8Ze//EVMj+RcfvnlOOaYY8TaLZUlS5YAAE499VR8+MMfxsEHH4y6ujp86UtfKvj+Bx98EGPGjBHXBoevbd6GbCWRSOS9x+71nMlkcNlll+Ezn/lMno9ZIZxczwRBEAThFEqOEQRBEKOG//mf/8G9996LK664AkcffTQaGxuhaRrOO+884QlVCkcccYTw0TnrrLNw7LHH4pOf/CTeeecd1NXVic++6qqrBilUOPvttx8AYNKkSZgxYwaee+45TJ8+HYwxHH300WhtbcXll1+OzZs3Y8WKFTjmmGPEpjGbzeKkk07C3r178fWvfx1z5sxBbW0ttm3bhgsuuGDQ7xaNRvM2nF7x3nvv4a677sKtt96K7du3i9e5ufamTZvQ0NCAMWPGADDMxt98802sXbsW+/btw0EHHYTq6mp8+ctfxuLFi4f8u3hiYKDZdjAYREtLy6CEC+fBBx9EIBDAJz7xiUHfu++++5BIJHDGGWfkvf6hD30IAPDCCy+IzXRjYyN+//vfY8uWLdi0aROmTZuGadOm4ZhjjkFrayuampoAGObf2WwWu3btwrhx48RnplIp7NmzZ1CCw85xFuP222/HQQcdJP581lln4YYbbsDWrVuxceNGjB8/Hvvvv7/tz/MKp+vXLsFg0JaP1Gg1Yr/44ovxpz/9CQ8++CA++MEP5n3v6aefxl//+lc89thjeR5dmUwG8XgcmzZtwpgxY9DQ0ODo75w1axYWLFiABx98sGBybMuWLVixYgU+97nPCdUkZ8yYMYhGo9ixY8egn+Ov8fVv93q+//778c477+CXv/zlIC+y3t5ebNq0CePGjUNNTY2j65kgCIIgnELJMYIgCKIsTJs2Df/4xz/Q29ubpx7jE96mTZsmXrNODLTyyCOPYNmyZbj55pvFa4lEYtjJa04IBoO46aabsGTJEvz85z/H1VdfjZkzZwIAwuGwrc36okWL8Nxzz2HGjBmYP38+6uvrMW/ePDQ2NuKvf/0rVq9eje9+97vi/W+88Qbeffdd/OpXv8ozMP/73/9u+7inTZsGXdexYcOGPLUYb+8shW3btkHXdVx22WWD2jUBQ7Fz+eWX57VDaZqGuXPnij8/+eST0HV92PN22GGHib/TSiqVwu7duwu2dCaTSTz66KM4/vjjCyalOjo6wBhDNpvNe51PzctkMoN+ZurUqZg6dSoAY6Lfq6++mqfcmT9/PgBg1apVOO2008Trq1atgq7r4vtOjrMY1sSYlSlTphRUUJXKtGnTCq6TgddmsetSxvqVjd3fyQnFfv9S+OpXv4p7770Xt956a8GEKZ8kazXE52zbtg0zZszALbfcUrRteiji8XhB9RcA/PrXvwZjbFBLJWBMCz3kkEOwatWqQd/797//jZkzZ4p7u93recuWLUin0/iv//qvQZ95//334/7778fjjz+Os846q6TrmSAIgiDsQp5jBEEQRFk47bTTkM1m8fOf/zzv9VtuuQWapuVV/GtrawsmvILB4CBfn5/97GeDNktuOf7443HEEUfg1ltvRSKRwLhx43D88cfjl7/8ZUHVRGdnZ96fFy1ahE2bNuHhhx8WbZaBQADHHHMMfvKTnyCdTuf5jQWDQQDI+90YY7jttttsHzM/fz/96U/zXi/m47Nu3TqxAS/GwQcfjMcff3zQ19y5czF16lQ8/vjjuPDCC4v+fDwex7XXXouJEyfmJQD6+/uxbt067N69W7x2/PHHY9y4cXjwwQdFixZgqL+4MmkgTz75JLq6ugpu5AFg//33B2MMv/3tb/Ne//Wvfw0AWLBgwZC//zXXXINMJpPXCvnBD34QY8aMwR133JH33jvuuAM1NTUFp4MOd5yV5rTTTsMrr7yCl156SbwWi8Vw1113Yfr06SJJV1tbCwCDrk0Z61c2dn8nJ9TW1hZtEd2yZYtIvA3Hj370I/z4xz/GN77xDVx++eUF3/PBD36w4LXX2tqKww8/HI8//jjOPPNM8f4NGzaISZ6AkSgqpLZ85ZVX8MYbbxScOAkADz30EKZOnZrn1WblnHPOwcqVK/MSZO+88w6efvppnHvuueI1u9fzeeedV/D3BIx/w8cff1y0x7q9ngmCIAhiKEg5RhAEQZSFM888E0uWLME3v/lNbNq0CfPmzcNTTz2F3//+97jiiivyvLIOO+ww/OMf/8BPfvIT0aZ45JFH4owzzsADDzyAxsZGHHTQQXjppZfwj3/8Ay0tLdKP96tf/SrOPfdc3HffffjCF76A22+/HcceeywOOeQQXHzxxZg5cyY6Ojrw0ksvYevWrXj99dfFz/LE1zvvvIMbb7xRvH7cccfhL3/5C6LRaJ6/zpw5czBr1ixcddVV2LZtGxoaGvDoo48WbSUsxPz58/GJT3wCv/jFL9Dd3Y1jjjkG//znP7F+/fqC7z/wwAOxePHiIU35x44di7POOmvQ6zzhNvB7H/vYxzBp0iQcdNBB6OnpwT333IP3338ff/7zn/PUgq+88gqWLFmC73znO7juuusAGK2iP/rRj7Bs2TIcd9xx+MxnPoMtW7bgtttuw6JFiwoqaB588EFEo9GinkwXXHABfvzjH+Pzn/88XnvtNcydOxerV6/G//7v/2Lu3Ln4yEc+It77/e9/H2+++SaOPPJIhEIhPPHEE3jqqafwve99L+/fqrq6GsuXL8ell16Kc889FyeffDJWrFiB//u//8MNN9wgWkydHGelufrqq/HrX/8ap556Ki677DKMGTMGv/rVr7Bx40Y8+uijooV31qxZaGpqwp133on6+nrU1tbiyCOPlLJ+K/U7OeGwww7Dww8/jCuvvBILFy5EXV2dSFCdf/75+Ne//jWsKf/jjz+Or33ta5g9ezYOPPBA/N///V/e90866SSMHz8+T8Fo5YorrsD48eMHXXsnnHACAIjWxL6+PrS1teHjH/845s6di9raWrzxxhu499570djYWNA78c0338R//vMfXH311UVVcpdccgnuvvtunH766bjqqqsQDofxk5/8BOPHj8dXvvIV8T671/OcOXMwZ86cgn/XjBkz8n5PJ9czQRAEQTimvMMxCYIgCFW49NJL2cDHTG9vL/vyl7/MJk2axMLhMJs9ezb70Y9+xHRdz3vfunXr2HHHHceqq6sZALZs2TLGGGP79u1jn/3sZ9nYsWNZXV0dO/nkk9m6devYtGnTxHsYY+yZZ55hANgzzzwz5DHee++9DABbuXLloO9ls1k2a9YsNmvWLJbJZBhjjG3YsIGdf/75bMKECSwcDrPJkyezM844gz3yyCODfn7cuHEMAOvo6BCvPf/88wwAW7Ro0aD3r127lp144omsrq6OjR07ll188cXs9ddfZwDYvffeK963bNkyVltbW/D3icfj7LLLLmMtLS2straWnXnmmay9vZ0BYN/5znfy3guALV68eMjzU4zFixezuXPnDnr9Bz/4AZszZw6rqqpizc3N7EMf+hB77bXXBr2P//sMPCbGGPv1r3/N5s2bx6LRKBs/fjz70pe+xHp6ega9r7u7m1VVVbGzzz57yGPdunUr++///m82Y8YMFolE2MSJE9nFF1/MOjs78973pz/9iR1xxBGsvr6e1dTUsKOOOor99re/Lfq5d911FzvggANYJBJhs2bNYrfccsugdezkOMvJ3LlzB/3bb9iwgZ1zzjmsqamJVVVVsSOOOIL96U9/GvSzv//979lBBx3EQqFQ3tq0u36/853vDLovFGKodW5l2rRp7PTTTy/4Pbu/EwB26aWX5r1W6B7S19fHPvnJT7KmpiYGgE2bNk18b/HixbZ+L/77F/sa7p5V7PedNm1a3vEkk0l2+eWXsw984AOsoaGBhcNhNm3aNHbhhReyjRs3Fvzsq6++mgFg//nPf4Y8hvb2dnbOOeewhoYGVldXx8444wz23nvvFXyv3et5IIX+TRizfz0TBEEQhFM0xkqYO00QBEEQBEEQBEEQBEEQPoA8xwiCIAiCIAiCIAiCIAhloeQYQRAEQRAEQRAEQRAEoSyUHCMIgiAIgiAIgiAIgiCUhZJjBEEQBEEQBEEQBEEQhLJQcowgCIIgCIIgCIIgCIJQFkqOEQRBEARBEARBEARBEMpCyTGCIAiCIAiCIAiCIAhCWSg5RhAEQRAEQRAEQRAEQSgLJccIgiAIgiAIgiAIgiAIZaHkGEEQBEEQBEEQBEEQBKEslBwjCIIgCIIgCIIgCIIglIWSYwRBEARBEARBEARBEISyUHKMIAiCIAiCIAiCIAiCUBZKjhEEQRAEQRAEQRAEQRDKQskxgiAIgiAIgiAIgiAIQlkoOUYQBEEQBEEQBEEQBEEoCyXHCIIgCIIgCIIgCIIgCGWh5BhBEARBEARBEARBEAShLJQcIwiCIAiCIAiCIAiCIJSFkmMEQRAEQRAEQRAEQRCEslByjCAIgiAIgiAIgiAIglAWSo4RBEEQBEEQBEEQBEEQykLJMYIgCIIgCIIgCIIgCEJZKDlGEARBEARBEARBEARBKAslxwiCIAiCIAiCIAiCIAhloeQYQRAEQRAEQRAEQRAEoSyUHCMIgiAIgiAIgiAIgiCUhZJjBEEQBEEQBEEQBEEQhLJQcowgCIIgCIIgCIIgCIJQFkqOEQRBEARBEARBEARBEMpCyTGCIAiCIAiCIAiCIAhCWSg5RhAEQRAEQRAEQRAEQSgLJccIgiAIgiAIgiAIgiAIZaHkGEEQBEEQBEEQBEEQBKEslBwjCIIgCIIgCIIgCIIglIWSYwRBEARBEARBEARBEISyUHKMIAiCIAiCIAiCIAiCUBZKjhEEQRAEQRAEQRAEQRDKQskxgiAIgiAIgiAIgiAIQlkoOUYQBEEQBEEQBEEQBEEoCyXHCIIgCIIgCIIgCIIgCGWh5BhBEARBEARBEARBEAShLJQcIwiCIAiCIAiCIAiCIJQlVOkDkIWu69i+fTvq6+uhaVqlD4cgCIIgCIIgCIIgCIKoEIwx9Pb2YtKkSQgEhtaG+SY5tn37drS1tVX6MAiCIAiCIAiCIAiCIIgRQnt7O6ZMmTLke3yTHKuvrwdg/NINDQ0VPhqCIAiCIAiCIAiCIAiiUvT09KCtrU3ki4bCN8kx3krZ0NBAyTGCIAiCIAiCIAiCIAjClvUWGfITBEEQBEEQBEEQBEEQykLJMYIgCIIgCIIgCIIgCEJZKDlGEARBEARBEARBEARBKAslxwiCIAiCIAiCIAiCIAhloeQYQRAEQRAEQRAEQRAEoSyUHCMIgiAIgiAIgiAIgiCUhZJjBEEQBEEQBEEQBEEQhLJQcowgCIIgCIIgCIIgCIJQFkqOEQRBEARBEARBEARBEMpCyTGCIAiCIAiCIAiCIAhCWSg5RhAEQRAEQRAEQRAEQSgLJccIgiAIgiAIgiAIgiAIZaHkGEEQBEEQBEEQBEEQBKEsoUofAEEQo5j2dqCzs/j3x40Dpkwp3/EQBEEQBEEQBEEQhEMoOUYQRGkkk8DChUBHR/H3TJgAbNoERKNlOyyCIAiCIAiCIAiCcAIlxwiCKI1IBJg61VCO6frg7wcCQFub8T6CcAupFAmCIAiCIAiC8AhKjhEEURqaBixfDpxySuHv67rxfU0r73ER/oNUigRBEARBEARBeAgZ8itAfyqDRDpb6cMg/MjSpUbSIhjMfz0YNF5furQyx0X4C65SDBR5ZJFKkSAIQlmef283Ln1wNXb3JSt9KARBEMQohpRjPieV0XHCzf9CNBTA0185HoEAqXgIiRRTj2WzpBoj5EEqRfdQWypRZhhj+PnT6zF3cgM+OGd8pQ+H8DF3rXgfz73biaNmteAzR02r9OEQPuYfazvQNqYGB0yor/ShEAThAZQc8znbu+LY0Z0AAHTF0xhTS8oKQjI59Vj21VcR1HVkAwEEDzuMVGOEXLhKcfVqI/nKCQaBQw+l9TYU1JZKVIDXt3bj5r+/iynN1ZQcIzxlV48R53bk4l2C8IJNu2O46P5VmDG2Fs9cdXylD4cgCA+g5JjP2WEJFHb3JSk5Rsgnp+oJ5lQ9QVLxEF5AKsXSoeEZtmnvbkdnf3GF3bjacZjSQAo7O2zeEwMA7OpJgjEGja5RwiN296UAADt7KDlGeMe2rjgAYOPuGBLpLKrCwWF+giCI0QYlx3zOzp64+P/dvUnsP55kwIQHLF2Kd9oOwAHt72Dt5ANwEKl4CC9YuhTJBYciuGYNQkwHCwahkWpseKgt1RbJTBIL716Ijlhxhd2EugnYdPkmREOksBsOvpFMZXX0JjNoqApX+IgIP5LVGfbGDK+xDkqOER7S1Z8W/79lbz/tqQjCh5Ahv8/Z3mUGCp1kVEp4habhthM+i/da2vD9RZ9BllX6gAhfomnYduU3EGKG+kkj1Zh9aHjGsESCEUxtnIpAkdAogADaGtoQCZLCzg7bu8zi3J6csocgZLOvPwU9F3NQcozwkn395n1s857+Ch4J4XfWtHfhm4+/ge54evg3E1Kh5JjP2Wlpq6TglPAKXWf464SDcdJFd+C5afOxhxKxhEdsXbgIr0+YDQDYMftgSurYhavHsgMmF1OCUaBpGpYvWQ4dBVpPAejQsXzJcmoPtMm2fWZyjCt7CEI21gmVHT20zgjvsCYqeNs44Yz/XfE+lt3zChLp7PBvVpg7nl2PB/+9Bb9d2V7pQ1EOaqv0OQM9xwjCC7riaVG5BYDt3QmMa6iq3AGNJmiKoCO6Ehn8cvEyXPePX+LPH/kirqBEhX2WLkX2sMPBVq9GiOnQAwEEaHhGHktnLcXCSQuxesdqZJkZvAe1IA6deCiWzqJzZZdtFuXYbirOER6xu9dcW93xNHlBEZ6xL0bKMTfoOsNt/3wPvYkMVm/Zh2Nmja30IY1Y9sWMROxr7fsqfCTqQckxn5PnOUbJMcIjBirFdnbHgbamyhzMaIKmCDqmO57GC9Pn46SL7sD+4+twRaUPaDShadh4+dex3/nnAgAC5DU2CK4eO+XBfH+2LMuSaswBjLE85Rgp1wmvGBjb7uxOYPrY2godDeFnuqzKsb2UHHPK+7v70JvIAAC6+6ldcCh6Esb5WbOlq7IHoiDUVulzdnRZlWMUnBLesCeWv7asXnfEEPApgoEit2KaIjiIbovnx6bd/cjqZHDnhH/PPly0pW6ZeRCpxgrA1WMaD5FYAIdNPJxUYw7ojqcRS5nKO2qrJLxiYHKMfMcIr+jK8xyjtkqnvGZJ9HSRl9aQ8CTi9u4E3dPKDCXHfEwinc1LWpAPFOEVA1UBNE7dJtwHSi/scURTBAdj9fxIZXVs3UfVWye8vbMXP1y8DO+1tOE3H/kira0CcPUY495jmo5PzvkqqcYcsNWiGgOoOEd4x8BhUxR/EF5hnVa5bV8c6WyR2I0oyGvtXeL/u0g5NiQ9llj3NVKPlRVKjvmYXQOMSSk4JbxioCrA6nVHDENuiiAL0BRBOwwMqN7vpOqtE9Zu7xFtqS/MWFDpwxmxLJ21FM2hOQCAiD4bmf5DKnxEowur3xgwWF1MELKweo4Bg2NfgpCFVe2U0VneRF5ieNbkKcfomVAMXWfoS2XEn9dYkoqE91ByzMfs6DZu2tGQ8c/c2ZcEY9SCRMiHJ16basIAgB0UMNgnpx7TdJoiaIeBY603dPZV6EhGH7rOsG5nr/iztUWVyEfTNMyMXIyw3oam9DK8/P7eSh/SqIL7jQVyty9qqyS8grdVNufiD1KOOSeRzuL/Pb8R63f1Dv9mheFtlaHcjY1M+e3Tn8pg3c4e8WfyHCtObzID63Z9DZnylxVKjvkYrt45cGIDACCV0dGXzAz1IwRREntzqoCDJzUCIOWYU3YdfRz+M3E2MppxS2akGisKr9xOb6kBALy/m5Rjdtm8tx/9Fh+ofRScDkkkMw+TknegWp+P/2ztpuenA7iiYv/x9QDIkH843u/sw/uU6C8Jnhybm4s/KDnmnFv+/i6W/2ktvv+XdZU+lBELY0wo1+dMNO5r5Dtmnze2dudNtae2yuL0DCgC/2drN/nrlhFKjvkYnqCYObYWtRGjZYtaKwkv2JNTBcydbCRiO3oSdCN3wO9e3YYfH/tphJjhX6GRaqwoPGg4dGozANCG0gFv7zCqtpObqgEY05DoOi0ON8SNhALI6AwrN5F6zC68rfIDU4yEBcUexUlndXzkFy/i5Fufw8vv76n04Yw6RHIsF3/souSYI97v7MM9L2wEAOzqJYVnMfqSGWRyz8t5U5oAkHLMCdxvLBI0Ug/UVlkcHnu01EZQGwmiP5XFux2k6iwXlBzzMTtzbZUTm6owtj4KYPBUH8IkqzOkMmSuWQpcFXDghAYENMOLgQZA2EPXGX79yhY8N+NQMUUwueBQUo0VgVcbF0xtAkCeY05Yu91Ijh01swUAwNjgCiVhYPX8WLTfWADAyxsocWEXnhw7JLeJ3Nefgk6J2IJ0x9PojqeRzjJ8/oFXsX4XJfztoutMxB+kHCuN5X9ai3TWuDbpeVAcHntUhQM4YEJOObaXkmN24X5jR84cA4CUY0PRkzDOTWNNGPPamgCQ71g5oeSYj9meU45NaKzG2LpccoyqQkX53P2rcMh1f8OXH16Df7+/h/zZHMDNlsfVRzG+oQqAuf6IoXnuvU5s3RdHQ3UYv1j633ivpQ07vvZtUo0VgXuOLcgpx3b1JtGboCDLDlw5Nq+tEXXREAAjaUEMpi9len4snTseAPASqXpswz3HPjDZSFhkdTbIL5AwiFnadbvjaVxw7yvopFjNFt3xtFDzzJ3Elevkr2uXp9d14Jl3OsWf6RotDk/mNFVHMK2lFgC1VTrhtZxv1vEHjANAa20ouHKsviqM+Tw5RhMrywYlx3zMzlxyYmJDFcbWRQAAu2liVFFWbtqLZEbH469tw8fvehkn/ORfuPu590kBZQN+jsbURTCh0UiOceUiMTQP/XsLAODsQ6dg/QeOwkkX3YHtC/+rwkc1Mkmks4inDc+stjE1Ium/kXzHbLE2lxw7cGKDGJ7RRQFqQURLZTCAxfsbwfyb27opoLdBPJUVBZPpLbVoqDISsXvIlL8g3MuuoSqEaS012LovjovuX4V4KjvMTxK8G6KhKoQpzUa7eCqjkyrFBslMFtf/cS0A4Kz5kwAAPYkMJRaLwNsAm2rCmDbG8DzdsrefFLE22NEdR0dPEsGAhkWzDSU2XaPF4QrOhqqQSI69Rqb8ZYOSYz5mh1COVaGFlGNDwhgTRtWnf2AiaiJBvN8Zww1Pvo2jbvonLv/Na0LmSuSTyepig91SG8WkRiNAJVP+4dnZncA/1+0CAHzqyKlorDYSFj1xMv4uBA8YAhpQHw1hZqtRvaXWyuHZF0uJa3LOhHozOUbKsYJwNWJ9VQgTGqswc2wtdAa8spF8x4aDt1TWRUNoqA6JJDaZ8hemj/vL1EVx7wUL0VQTxuvtXbj8N6+RJ+AwdOaSY2Pro4iGghhTaxSCO3op/hiOe57fhE17+tFaH8U3Tz8IgKHw7KekbEGEcqwmjMnN1QgGNCTSOvm02eC1nOppzoR6UUCPp7NIpGmtFYLHHw1VYczPWYi8t6uPuiTKBCXHfEoqo4uK2qQmS1slqaAKkszoQpr//bMPwSvfPBE3nX0I5k1pRDrL8Ps12/HPtzsqfJQjk339adF+1FwTFg8+So4Nz8Mr25HVGY6YPgazx9dbkmP0ACwEV+00VIcRCGiYJZJj5NEzHLylcuqYGtRXhdFcY2wi98VorRXCbGswVE9HzzJ82l7csLtixzRa4MmxyU3V0DQNLTnl+h5SrhcklvO2q4uGMLO1Dv97/uGIhAJ4am0HvvfntRU+upENH/TAY9xxOX/dnRR/DElHTwI/e/o9AMA1p87B2LoIwkHDyoEKwYXhhaSm6gjCwYAYbEOtlcPD/bLmtzWhPhpCMJBbaxTrFqQnF380VIcwrr4Kk5uqwZgx8ZPwHkqO+ZSOnCFpJBRAc00YrbytkpJjBbF6ftREQqiLhvCJI6bi9186FqfMnQCANpHF2Jvb8DTXhBEKBjCRkmO2yOoMD680Wio/eeRUAEbSByAvhmJwhWJT7jzNHFsHANhAyrFhMVsqDSPhplxyjNoqC2Mqx4y1xpNjL5Ep/7Bwv7FJTcazgKt5yKKgMH1JQz1RGzWmih8+fQxuPnceAODeFzbhnuc3VuzYRjq8G6I1lxzjxbkOMuUfku//ZR36U1kcOrUJZ82fDE3T0FBFyvWh4Mqx5lrjPE1rMVoraWLl8Ly2xWgJXDC1GZqmiUIwxR+FGRh/cPXYa2TKXxYoOeZTeGJiYmMVNE2jtoZh4DLy6nBQVDQ4/EHIlQREPnzDw1t3J/K2yi7yHBuKZ9/Zhe3dCTTXhHHKwUYCVijHqHJbkO5ccMrPE2+r3EDKsWHhybGDJhoG6TzBSG2VhRmoHOMTPtft7BUFAaIw27qMzeLknAcUfzaQcqwwvDjHh2QAwJnzJuHqU+cAAJb/eS227qMNeCF4wZf76o6v58kxSsQWY9WmvXj8tW3QNOC6D81FIBfzNlD8MST7RPxhrDWRHNtLxbmhSGd1vLHNUDxx/ywz/qC1VgieoOZ+nQu47xiZ8pcFSo75lB05M/QJucmBLdRWOSTcELfWEpxyeOaeer0Lwzc8XB1AbZWFae9ux+odq8XXbc89haS2HkfP6cHa3a9ja89WUbkl5VhheJWxMad6mtlqKMc27YmRKe4wvL2jF4CpHGvOeY7RtMrCDEyOja2L4oDxxrl7maZWDsn2LuPeP7nJ2DyOFcoxWmuFiBWJPz5/3EzMaq0FY8Cm3ZQcK8SeAW2V4/lAIFKOFSSrM1z3x7cAAB8/vA0fmNIkvsc34t2UsCgIN+Tnz85pY/jESro2h+Kdnb1IpHU0VIUwc6xxzhrJ83RIepMDlGN8YmV7Fw3MKAODMwGEL+B+C5NyPfFiWiUFpwUxg9PgoO/V5wJWUo4VZs+Ayi1vpenoSUDXmahKqkwyk8TCuxeiIzbAt64KuONt42tC3QRce9jTAMiHoRg8aciVY23N1QgHDVPc7d1xTGmuqeThjVhSGR3rdxnJsYMmNQAwE4xUuS2MdZQ65+hZLXinoxcvbdiD0w6ZWKlDG/HwtkquHBNtlTStsiDFinOapuW8AWNUnCvCboshP2AWhHdRcqwgf3h9G97c1oP6qhCuOvmAvO+RcmxorIb8ALVV2oW3As5raxL7gSZqqxwSoRyrNp4JB09uRCigYXdfEtu6KNb1GlKO+RTrpErADBz6khmaDlIAEZxGBueLecDAM/lEPnsHKMda66IIaEBGZ6RUzBEJRjC1cSoCRW65AQTQ1tCGlhqjqkbKscJ0C0Nc45oMBQOYmhupThMri7N+Vx/SWYaGqpAwEW6uobaGobBOq+Tw1sqXSDk2JFZDfsDSVknFuYIUaqvk8PVHxbnCmG2VOeVYQ86Qn5JjBflPztD73MPaxDnjNNBAoCERhvw1vK3SiNc27YmRmmcI1uRaARdMbRav8XNIKsXCiPgjalyTVeEgDpxoFDbXkO+Y51ByzKfwtkpujl4fDSESNP65KWExGO45RsGpc3bnkmMttUagFQoGML6BWiutaJqG5UuWQ4de8Ps6dCxfslxIzSk5VpiByjEAmJVrraSJlcUxzfgboGlG5bZZGPJTwqIQQjkWtSbHxkDTjGQjKVMKk8nqIjExhXuO1dK0yqEQhvwFinNcuUhqnsKY0ypznmO52GNnN8W5hejPrbUxteFB3xOG/BTrFkQox3LxBy/M9SYyVGQagtfac2b8udZAABZDfnomFMKcVmlep/PJd6xsUHLMp/C2Si4xN0z5qbWyGFw5VlOorbKKqmlDsTe3nlpy6wuw+o6RKT9n6aylWDhpIQJa/hoLakEsnLQQS2cttbQ1UHBaCDGtssYMGLjv2Pu7STlWjLctyTEOT8TSFN7CDJwWBRjV7oNy55DUY4XZ2ZNAVmcIBzUxQdBUjlHCohBD2jpQca4ojDF0DlKOGbHHnlgS6WzhYpTK9Oc6R2oKdkkYr1GsWxgz/jBi3epIUCgVN++l1spCdPenhap/viU51kTK9SEppFy3+o4R3kLJMZ+yY4DnGGC2VvLR14RJMUNcgILT4eA+Mlw5BpiKRVKOmQj1GMtva86yLJYvWZ43Sp2UY4Xh58VaTeMTK6mtsjhrt+cmVU4yk2NCOUaGuAUZaMgPAGhvx9msA3N3rsfmvz8PrF6d/7V1a4WOduTA/cYmNlYLfxleOOmKp5GhhMUghm6rpGnZxehNZpDKGOupNRffttRGEApoYAzopFh3EP1DJGIbSKVYFF1n4lnZbCnO8dbKzXso/ijEmq1dAIDpLTVorjUL6OQ5NjSm55i51hZMbQIAvLmtmxL/HkOG/D4kldFFNY0reACzskZtlYMRbZUF2xpy1TQKTgsycFolYGyMAEqODWTprKWYWncItvS+BWg6gloQh048FEtnLQVgSs2pcluYgW0NADBLJMeorbIQjDG8vTOXHLMox/g5jKWySGV0REJUK7MyyJA/mQQWLsSFHR24sNgPTZgAbNoERKPF3uF7BvqNAUYiVtMAxoB9/WmRyCAMem0V5+iZMBBe6K2LhlAVNpI9gYCGcfVRbO9OoKMnkVcgJoBYKtclMYS/LhXnBtObzIAPxG60JsfG1OCVjXvJlL8IhfzGAPIcG4pEOotULvllLc7NGFuLxuowuuNprNvRi0OmNFbqEH2P42j4ueeew5lnnolJkyZB0zQ88cQTed9/7LHHsHTpUrS0tEDTNKxZs2bYz7zvvvugaVreV1VV1bA/RxRmV28CjAGRYABjasyEBfl+FKfYtCjArKZRcFqYPQM8PwBSjhVD0zQsnXIZoBkPPqtqDDCDrmRGp8EZBegp4Dk2c6zRVrm9O4H+FCWwB7KzJ4Gu/jRCAQ37jasTrzdUh5FbduT7UYCegW0NkQgwdSpYoEjYFAgAbW3G+xRm4KRKAAgGNKFUpImVgxHKsapC8Qcp14sx0G+MM77RnJhN5MMLwTWRwcoxszhHa20gPIlTEwkiGjLPHU2sHBruN2ZtqQTIc2woeOyhafmCDU3TMI/7juXOK+ENjpNjsVgM8+bNw+233170+8ceeyx+8IMfOPrchoYG7NixQ3xt3rzZ6aERObjf2PjGqGhrAMy2SpKaD8aO50cyowsJP2GQzuqiylhIObaTPMcGMbn6KET02QAgvMY4dZGQSFiQemwwAz0/AKC5NiLaHDaS79ggeEvlrNY6oa4AjIQFD1CpejuYQW2VmgYsXw5NL/IM0HVg+XKIC1hRtncPVo4BZnFuL3meDsJWWyVNyx7EwEmVnAnClJ+SYwPha62gckx0SdBaG8i+AZOyOdRWWRzGmPDHGpQcI8+xovDYoy4aytvDAxbfMTLl9xTHbZWnnnoqTj311KLf/8xnPgMA2LRpk6PP1TQNEyZMsP3+ZDKJZNJM8vT09Dj6+/zM9lxAMLEhPziltsriDKUcswasvYm0MBcmgH05FWJAy09Y8Hbe7V0UnA4kkdbRlF4Grele3HjCjUI1BhgtIQ1Vhmy6J5HGuAZS0HIYYwWnVQKGKf+rm/dhQ2cMcyeR1NyKacZfP+h7TdVhdPWnsY8C1EEUMuTH0qXAwoXQX30VAWuSLBgEDj3U+L7ibC2gHAPM4sluUq4PYuhplaQcK0ax5Bg35e+gQvAg4jnlWEHPsWryHCsGL8w11uSrFIVyjAz5B7FpTz+6+tOIhAJ5w4AAM8lIhbnB8MJ4Q1V40Pe47xiZ8nvLiDEZ6evrw7Rp09DW1oYPf/jDeOutt4Z8/0033YTGxkbx1dbWVqYjHflwtc7EpvyNtTmtkgKGgfDx1oWSY6FgALU5CToFqPnwFt3mmgiClgrHREtbg86NGggAhsdTtT4fNxzzd5w488RB3+cTo8j3I5++ZAbZ3FqyTqsEgJljyXesGGt3DDbj5/CE9j4y5c+DMSYKJg3WVreceiwwUD2WzZJqLAf3HJvSVLg4RxMrB0OG/KXBPcfG1g9oq+TJMVKODSKWGmJaZRW1VRajkBk/AEwbY8Qenb1JcR0TBmtyrX8HT2oY5GnKY4/eZIbM5QfA7/UN1YOTY/OnNAEwprPTMCXvGBHJsQMOOAD33HMPfv/73+P//u//oOs6jjnmGGwdYvLTNddcg+7ubvHV3t5exiMe2XCfJ6sZP2ANTumCGgg3Ka0t4MMAmAEqVdTy4WupZYDnx7j6KAIakNEZJWMHEB9mrZHvR2F4sjASCuS1BwKGcgygiZWFeHtHLwAMqtwCZpKRqrf59Keywny5fmD1dulS9Bw8HxktFz4Fg8DChaQag5FU3N5VWDnGnxF7STmWR1ZniKeLq3nIkL84ncJzbKByzPhzRy8lxwbCfTkLK8fMtUZFzXzEMKABybHGmrB4bQupx/J4rYgZP5BfdCILkXwG+Z1aaK6NYHpOrUjqMe8YEcmxo48+Gueffz7mz5+PxYsX47HHHkNrayt++ctfFv2ZaDSKhoaGvC/CYKdoqyycHKNkxWCGaqsEqLWhGNxcuaU2PzgNBQMYV0+m/IWI5VSK1cMkx0g5lk+hSZUcMbFyNynH2rvbsXrHaqzesRovbH4F7+x9HUltPVKBDVi9YzW29phFp2ZSjhWE3+dDAQ1V4QFhkqZh51XfRIjlqt2kGhPsiaWQSBvnZWBxTrRVUnEuj5hliMhQ0yppWvZgyHPMGamMjnTWSHrVhIsrx3QG9NFwmzzM5NjggSvkO1aYYn5jgLFH4Pe2Lop18xDKsQJtlYDFd4ySY57h2HOsHITDYSxYsADr16+v9KGMSrYL5djAtga+EUojndURDo6I3OiIgLdVFmprAKh6WwyuHBtTNzhgmNhUhZ09CezoTmAedT0L+tPF/WUAS2sDrbU8Ck2q5HDl2MbOGBhjeT5uKpHMJLHw7oXoiHWYL+b2jSf+n/HfCXUTsOnyTYiGoqLiTcFpPr2Wym2htaQvPQmvT5iNeTvfI9WYBT6pclx9NG+iGwDh1UltlfnwVqxQQEM0NDgm48rFVEZHMpMddF5VpqjnWC4xu6uH1poV6zTnQsW5qnAQ0VAAyYyOnni66OZcRYoZ8gPAtDE1eL29iyZWWshkdTEMqFByDDBUeL2JDJnyD8D0HCu8R5iVi3dpGq93jMjsSDabxRtvvIGJEydW+lBGJdxzbNIAz7Hmmgi4LRS1NuQzvHKMJyyommaFK8fG1hZIjjVy5RhNrLTSL6ZFDaMco4AhD3NS5eDgdOqYGgQDGmKpLDoU3hBFghFMbZyKQJFHewABtDW0IRI0rtemauO/5F2RD7/P1xUJTuuqwvjh4mVY39IG3HgjqcZybCvSUgmYzwiKPfKJWWKPQonY/IFAFH9Y4cmx1iKeY73JDPlAWejP+Y1FgoFBHlCcBrJ1KAhX8jcXUI5NJ1P+QcSSWWRyrbnjiwyW4vFHd5yeCVZ4YbyQ5xhAnUzlwHFyrK+vD2vWrMGaNWsAABs3bsSaNWuwZcsWAMDevXuxZs0arF27FgDwzjvvYM2aNdi5c6f4jPPPPx/XXHON+PP111+Pp556Cu+//z5Wr16NT3/609i8eTMuuugiN7+bkqSzOnblTEoHtjUEAhrG1FJrZSGG9xyjm1Eh+EZnTO3gCZ4TctNSqbUhHx6g1hRJxDZQW2VBik2qBAwfsqljjABVZVN+TdOwfMly6ChscKtDx/Ily8UmvLnWOJf7YrTWrAjlWLRIcBoN44Xp83HiRXcgdfwHy3loIxquHJvcNDg5xtsq91ByLI++YVTrwYBGA4GKsLu3sOdYXTQkzudOUlcIuHKspoDfGKdBtPHSM8EKV441FirOUVvlIPrTpiK2WCJWKNepEJwHv88X8hwDjOIcYIo6CPk4To6tWrUKCxYswIIFCwAAV155JRYsWIBvf/vbAIA//OEPWLBgAU4//XQAwHnnnYcFCxbgzjvvFJ+xZcsW7NixQ/x53759uPjii3HggQfitNNOQ09PD1588UUcdNBBrn45FensTYIx44Y0tkDCwpxYSQGqldgwyjGesKC2ynx2FzHkB0zl4nZKjuUhAtThDPlpreXBA6jG6sFrDTAnVm7YrXaAunTWUiyctBBBLX99BbUgFk5aiKWzzBZAvta6qHKbx3DBqdXMmpQpJkMpx1rI87QgfYniBukcc2IlPRM4sWRGDDIYmBwDgHHclJ+SYwLud1rM0gGwKsdorVkZyvNUKMeorVLAi8DFvHUBS/xBybE8zLbKwsU5nvjvo2KJZzj2HDv++OPBWPEpJhdccAEuuOCCIT/j2WefzfvzLbfcgltuucXpoRAF4C1s4xuqEAgMlui31kexbmevGIFN5JuUkiG/M7hyrKVAWyVXLu6ktso8hHKsSNBAyrHC8AROIeUYAMxsrcU/16mtHANM9dgpD56S93qWZfNUY4DZIkLBaT5mcqzwWgsFA6gOBxFPZ9GbyKC5wP1PRXhybEoB5RgvzPUmMkhl9KJqAtXg1f9iyjHAiD929lD8YYUnWavDwYJx24SGKrzfGaPkmIXYMIU5wNyQU/yRD7ceKHSvn5pLjm3vitO9LUd8mDgXAHmeFmG44hx/nZRj3kFXsM/gkwEH+o1xaGLlYKyV/2JtlcIknW7ieXBz5ZYClduJuYEQ27soOOVkdYZkxmh5qylqyJ9rayDPjzx6hvAcAwxT/v/atAYXff4M4B//KOehjTi4egzMeMQHCqjGAEqOFYMrdIoZ4gKWgkmSzh1HtFUWUI41VIURzBXsyHfMZDjVOkDFuUIIM/76wolp7nOksgflQPjgqSGTY9Xkr1sI4XlaoDjXWhdFTSQInQFb95F6DLAWgYvf14TnGHme5jGc5xgvpNDzwDsoOeYzdhaZVMlpId+PQfDsezQUQKjIBE8KTguzR3iOFTfk7+hJQNeLq01VwjotalhDfkrE5mGOUi+SHGupwdf+9StM3rEJ+MY3gCEUzn5H0zRcf/z1gGYkYvUCqjHAPJf7KDjNY7jKLWCa9VNrgwlXjk0qoBwzPE95/EEJCw5X8wytHKO2yoF0FvEb4/DkGHmempjKseJrrbGaF+dorXF0nYl4rKmAIb+macLzlForDXjLc3WYlGNOGd5zjJRjXkPJMZ/BVToTG4sox+pzyjFqqxTwCsdwbQ0AqQSsJDNZcRMfW8BzbFx9FAENyOgMu2kzBMBcawHNSMYWgtoqCzOUIT8AHPCflzFv53vGH1auBJ56qlyHNiJZPO1ERPTZAIAFEw4bpBoDzOA0mdFFGwRhMeQv0lYJAPVRClCt9CUz4hotZMgPWIpz5HkqGG5SNkDFuUII5ViR5NgE8hwbBL/HD+VvJ7okKBEr6EmkRa2tWPwxTfiOqe15yonbaOElz7HCDOc5Zo09hrK5IkqHkmM+Y2ePUbmdUGR0Lg8kOqmtUmArOI3yyi0Fpxw+4S4Y0ArexEPBAMbVG+twB7VWAjCTY7WR0CAVD4cM+QtjGvIXCBgYQ+ON30VGMx5pLBgErr1WafVYMqOjKb0MYb0NN33wxoLrrS4aQijX6kam/CaOlGOUHANgtlQ2VIWKJhX54BZSjpnEbHmOUfwxkOGSY2ZbJcUenJiNVjfTkJ/WGofHHrWRYFE/sel8YuVeUo4B9gz5uQqPlGP52FWOZXWGRLrwZHLCHZQc8xnDeY6J4JQqtwIenNrxYaDg1IQHp2NqIwWHPwCmKf8Oam0AYK61oQKGBstGKEvtqIIhlWNPPQVt1SqEmBEoaNms8uqx/lQW1fp8TM/8EifPHqwaA4x2ENFaGaMAldMzjCE/QL4fA9nWZWwKJzfXFH1PS26CNsUfJmKC4JBqHr7W6Brl8PijtYBqHQDGN5Ln2ED6RSGYlGNO4LYDhVoqOVNpYmUeIjlmo62SPMdMsjpDb+46LeY5Vh0Ogm+5qJvJGyg55jOG8xxrJUP+Qdir3FJwOpChJlVyeJJ2B02sBGBRjg2x1qzJH/IzMinq+cGYoRILDgjCFFeP8bVWFR76MW9WbylA5fQleVvlEMqxnJqYlGMGwoy/SEslYFWO0VrjUFtlaezmnmP1QyvHdvWS5yknJhIWQynHjO+RrYNJ1zDDgACLcozaKgHYnFZZTZ5jA7HGE8XiD03TxH6V9gjeQMkxH5HJ6kJCXtRzLJcc2xNLUcCQI2YjYcFvUjTBx4S3xrQUqdwCwIQGY6NEprgG3JB/qGpaJBQQ36cA1SCd1UXQMEg59tRThkosO8AzS3H1WCI9fAsNYAlQyfdDYKetkgom+WzLtc5PKTCpkmN6jlFxjuOorZJUAgJe4OVqxIGMq49C04B0lmEvKVMAmPGHLeUYxR6Crtz6aR5KOZYz5G/fGyfFP6xtlUMUgrlyLJ6m/WgOft1FQwFEQ8Wv0zryPPUUSo75iM6+JHQGhAJaUR8GPi0qqzPK1ueI2ZCa8+A0ldHFplN1eGtMseAUMJO02yk5BsCqHCu+1gCzekutDQbWQL3BmrDgqrFAkUdZIKCseqzfRuUWMJVjNLHSpNdGW2U9TavMg0+qHFo5Zjwr9pJyTCCUY0NsIkk5NhjTc6xwwiIcDIjYhHzHDPpteI41koXIIITf6RDKMT6hN5XV6VkKoD9t35CfMVpvHDuxB0DTsr2GkmM+gvs6jW+oQrCIB1QkFBA3JKreGtgJTq1VXbqJG/DWmDFDtFVObOLj1KmtErAXnAJm0EDKMQN+HuqjIYSClsdWKgVs2QLoRUxJdR1obzfepxhcJVA1hEoRsIxTJ+WYwJxWOfwzoZcqtwCAbfsMr51JQyXHcs+K3eQ5JrDXVsl9oGitcfgaKtZWCQDjaWJlHraUY9WkHBsIfzY2D5EcCwY01OYSQTF6Jthqq4yGguL7ZOtgwAvivEBeDIo/vGXos0+MKky/scItlZyxdRF0x9Po7Eti9vj6chzaiMYMGIpfDsGA0ePdl8ygN5FG6xABmSrs5cHpEG2VE8mQP49+G+OtAbO1gZJjBlzlOqhyG40arZOdnQCAO59djz/+Zwc+fngbzj9muvGeceOM9ymG2VY59FprFskxCk4BgDHmbFolJSwAWJRjQ7VV0rTKQfCNNLXw2ieRzoqkYrEuCcCY2v7W9h7s7Kb1BpjDH4acVlllbrqzOitaaFcJ/mxsqi4e6wLGMyGWylIBHWZybKjhU4Bh69CfyqKrP41pLeU4spGNfeVYzvOU1ponUHLMR2zPBafDJ8ei2NAZo+ptDh4wDOX5ARgBqpEco5sRYG5wxgzZVmlslDp6DFPcYlMtVcGpcoyqtwZDTqpsazO+APR21uCtXbV4f+p04NC5ZTzCkYedUeqAxZCflGMAgERaRybnf2JnWiV5fhh2A7t6jefBkG2VuWfFXoo9BOa0SmqrtAtvqYwEA/lt9gMY18AnVlJxDrBXnLPe8/oSmSFbCVXBjiE/wK/hJD0TAPTz4twwyvXGmgi2dyfI5icHj/mHuq8BRhcFQPGHV1BbpY/gyrGJDcMkx3Kqp929VE0DzJtLzXA+UFXkxWCFt1UOZcjfWh9FIGeKu5vUAmKU+nBqHmqrzKe7315wShMETeyMUgfMc7qPkmMATHVOQINokymE8ByjtYYd3XEwZpgID6Uk5s+KWCorlAWq0ycM+Yc3SSflmMFui2pd04oX3CZQciwPUzlGA4GcsE/EH0Mrx3jCgtoqnSnHAFKuc/g9vmE45RglxzyFkmM+YgefVDlE5RYAxtZSa4MVO9OiAGptGIhpyF88YAgHAxhbH0ViTAD3tO/As/v2IaugOTpHKMeGNeTnHjO01oBhlGMW+AaTpOZO2iq5coyCU8D0daqLhobcePNELBVLgG37TDP+oc9ZCJGcZyDFH0YLb8yW55jxvURaRzpbxF9RIXhhdyi/MYA8xwYSTw+vUgRoINBAukVbpU2TdEpYmJPZh5uWXUOFYCs8/hjWc4zUxJ5CyTEfIZRjNtoqAWB3L22GAKOKDQxtyA+YASoFDAZ7hXKseID6WGcn3lgYQscR1bhm12Ysef11TH/5ZTyW84hSDb7WasLDBacUMFgR06JseH4AFJwC9kapA5bKLa01AFYz/qE3QtTqZsKnEQ9lxg8AmqYJ9RhNrASSGbOFd6iEBQ0EysecVDlMciwXC+/soUQsYBaC7SrXydbBgCvHmmuHaauMUPzBEYb8NBDIEXbjD1M5RufNCyg55iN22PUc422VNK0SACyV26Fv4vXUVimwGuIWm1b5WGcnznnrLSQGxPzbkkmc89ZbSibI4jamRQGm30B3nNYa4EQ5Rm2VHPttlaQcs2LHjB+g4NQKf4YOV+0GLKb85DuW1341VHEuFDRb3Ui5bk2ODV0sobbKfPptFoIbqki5boU/G20X52iPYPHXHS4RS56nVnpyMf+wnmO01jyFkmM+IaszdOSk5raVY5QcAwBbbQ2AVTlGNyPuNxYOagVv4lnGcPn69WAAMKDLhjdVXrF+vXItljGbPgxUuc2Hj/ke3hA311ZJyTH7bZW1ZuWWKXY9FoInx4bz/KBWNxPerlU1TCIWMAe4UPxhekBVh4PDTgUkpaKJ6Tk2XFulEQvvjaWQzKjtcccYQ8zutGwRf9Bay2R1EfM3D+t5Sp5jHPsDgbhynYolANCbdKoco7XmBZQc8wm7+5Ji7PK4+qGTY7xyS9MqDWIpu8kxMsXl7BV+Y9GCHjMrurqwNVl888MAtCeTWNHV5dERjkziNiu3ZMifT49N5Vg9V47RBtLi+TGcIa7xPMjojAItWNsahr5Grc8L1TdDcZsqRcD0PKW2SnNjM1zsAZCtg5VOm22VzTVh4XG3S/HWykRaB6991AznOUZrTWAthg+vXM8lsBV/HgDW4pw9W4duUo4BsCjHyHOsolByzCfsyHl+tNZFh61AtlqUY6QUMKu39g356WbEJ08Wa6nckbK38bH7Pr8Qs5mwIEP+fLjk3q4hrurJCsB+W2V1JIhoyAgFqLXBfltlOBhAVTiQ9zOqwjdCdpJjoq2SkmPieTDUpEoO2TqY2DXk1zQN43Km/Lt61W6t5MUSYPjrlDxPTXhLZX00hFBw6C0zT3JTcc5+W6WpHKO1BtC0ypECJcd8AldWDNd2BJjVtmRGpwsL5s3FrtSclGMW5VgRz4+JkaG9GZy+zy84VY5RW6VBl03lmGirTGWUT/zbbasEyBTXCq/6D9fWAJDHHYe3VQ6X9AeordIK30Q7UY5Rcsy+5xhg+o7t7FZ7vVmLJcMV0IXnGMUfwoy/aRgzfsC8RmMpta9RXWe2nwmm5xgVSwBTqWh3IJDqsYdXUHLMJzgJTqsjQdTm3qd6a2U6qyOVMfxihlOONVBwKtiTU461FFGOLWpqwpRodKDdmEAD0BaNYlFTkyfHN1JxrByLU5IHsBjyD5P8522VjJmbAVWx6/kBAM05U/59FKCK4kfdMMoxgBIWHJ70t+M5RtMqTfjGZrjYAzATFlScM+PW1mHaKgFzYqXqpvwxm8OAAEtxTvH7GgB0c7/TYcz4AUtbpeLnLWHx9xt+IBCpFK0I5dhwbZVkIeIplBzzCU7aGgCgJRdU7FG8etufNG/iw/XGk+eHCW+JaSkSnAY1Dbfttx+AQX784s+37rcfggX8yvyMUI4NE6Dy4DSV1ZFIq232zRgTfhTDKceqwgFRFVe9oma3rRIwA1RKjtlvq7S+R/WJlXEH8cdYmlYpiDlIjtF0MoNURhcb6eE8xwBgfD0lxwDTPmS4OBcwN+akHAP2xex35dSSIT+A/MKk3eQYDQQyYl3uOTasIX8V+dt5CSXHfILT5NhYYcqvdnKsL1dNiwQDiISGvhzI88OEb2yKeY4BwNmtrXhk7lyMD+Xf5KdEo3hk7lyc3drq6TGORESAGh7G7Dtitj6oXlFLpHWkctMAm2qGrt5qmiZUsapfp3YNcQGzKq76WgOshvx22ipJKQBY4g8HbZWqF+aA0gz5Vd8McdV6KKANWywBzAmDqhc1+21OqgQsbZWKnzPAtHQYLvYADF8ygApzppI4gMAwLbzWgUAxxdX+yYwZ6zYMU5zjsUcqoys/idcLKDnmE8TNyMaDDzArbp2KV29jSftSc2qhMeEtMcN5fpzd2orVhxyK8a/E0fp6Ak/Pm4eNRx2lZGLM6sNQM8x60zSNJkbl4CO+gwEz8TUUPKlB1VsHbZU5PxVeJVcZfn8fLjgFyBSX40Q5xlvx98RSyisFeLHEXnKM2ioBYHev6Xc63MYbMM+t6nGbXYN0IN/WQXW4F9Zww4AAq3JM7WSFudaGv69VhU1hguq+YzzW17ThfYnr8qZlq73evICSYz4hnmu9sq0cy0354VN/VCXmqHJrBqeqB/W86s9VAEPRWB1G1V4dNTuyOLK2XrlWSg7fQAL2AtRGmhgFwPz9m6rD0GysHUpYGDhpqxSmuHG1g1PAWVtlHbW6ATCLc3YSsdxzLJnRlVcKOJtWyYslaq8104x/+NgDMJ8HVCyxH+ty5ZjqsQdgDqlpttFWKVrdFE9g87VmJ/bQNE0kHlUfCCRaKqOhYRP/wYAm9hGqxx9eQMkxn8A33ny0/HCMFdVb1ZNj9qYHAqaSIJ1lSGbU9oEyPceGl5pXh4Pg93mVb+J8I6RpQFXISfVW7YChy6bfGIerQFVXCjiZVtlM0yoFTtoqqY3GwElxriYSEu9TvbXSWVsl2ToAQKfT5FgVqXkAq+eYE0N+eh6ISdk22ipFIjaVVbqAHncQewBkys9xEnsAFlsHxT1PvYCSYz7BseeYUI6prRToc9BWWRsJgQtXVA8auOdYsWmVVgwfKNpEcnVFTThoqx2ElGMGdidVcuqorRKMMUceMzSt0qQU5ZjqCQsnnmOAWVTZo/jEylIM+VVXpThVjom2SoWfB4BFOebAkL8/lUU6q3YhmLf62VKO5dZaVmdKD1KKO2jhBUzfMdWLc1wV3GCzEEzKde+g5JhPiDtooQHMwEJ1Q34nbZWBgEYGzDCCLF4ZKjatciDiJq5wgMort9U2glPAfEAqnxxzqBwjNY/RsqbnCtd2fCgbSTkmMJNjdjZDpOYBnMcf5rRsSo4BDg35FV9rvKA7tn74whxgtqyqXCwBrPHH8NeoNVmr+nrjz0Q70yprIkFRQFdZzePE7xSwxB+K2zqYyjF7ewSKdb2DkmM+QbRV2q3c1tK0SsCsptmp3AKWKT4KJyz4hiYaCtgySAfM4F/lm3g8bV+lCFjXmrrnDMj3HLMDP78qr7WE1d/ORsKCK8dUN8RNpLNiWpSdALVeJP3VfR4AVlsHZ/EHtVU694Ei5ZixZlpte44Z503l5wHgzHMsFAyImFjlWBcw1dR2plVqmoa6CLXxOi2WkOeYAY/1G+y2VZLowDMoOeYTnEyLAsy2StUrt31J+1NVAKreAuakypbaiC2DdMBqiqtuwCAqtzavUWqrNODVRDvBKUCbIcCs3EaCAYSCwz/mm0TlVu21xu/rmgaxyRmKegpOAVjiD4fFOdXbKvtEWyVNy7aL87ZKKpYAzqZVAqBp2Tm4ct1ucY5a3WCxdLC3ryLPMQNe+LAzKRsAdTJ5CCXHfEKixLbK3mQmT2WgGjEHwSlAASpgDnGw21IJWCcIqvvw48GpncotYPp+KB+c5gIm8mGwD19rdge0WIPTrK6ukTAPTusiw0+LAiz3NYXXWlZnSGWcTcumtkoDXjDhCf2h4G2+/aksMgr7QDlNjtXnzm0qo4t1qiIi/iBbB9uks7rwqrNbnKMuCaDfYbGkiZTrAMxY33asS4Vgz7B3lyRGPImMs5tRQ1UIkWAAqayO3X1JTGmu8fLwRiwxB1JzwDoxSq2Aob27HZ39nQCAldt2IqmtBws3Y/UOY92Mqx2HKQ1Tiv68Wb1VNxHrxCAdIOUYp8tp5ZaUApZJlTYrtzlDXMaMNppmG4M2/IhQ8jit3NJaA+AgOUbTsgE4GwhkbfPtS2Zsb9b9hmiztzmgxXpuY8kMIiE1zxsvBNfYtXWoJlsHa+xl1/O0jpJjjg35G6mtEoCzYUDW96lcnPMKSo75hHjKmeeHpmkYUxvBzp4E9sZS6ibHHHh+AKbcVSXlWDKTxMK7F6Ij1mG+WAX8uQP4813GHyfUTcCmyzchGipczRUVDoXO20CctjVQcsxATKukapptnK61SM4/MJbKokvh5JjT4JRUimZLJWD4UNqBT6vcq3hbpZNpleFgAFXhABJpHb0JdZNjfAqg3UJwKBhANBRAMqOjL5lR9t7mvK0ylxxTrBBshSdrGqpCCNpQEgNWCxF1nwlODfnJ1sGA+/vZ9hyjRKxnUFulT4innbU1AJR1Bsy2BrvG8ioqxyLBCKY2TkWgyO0igADaGtoQCRYPOmlilHMfBhr+YOBUKUAJC3Ot2S2WAGZrwz6FWxvMaVF2J6NSIjZuaeG104oKmG2VuxVuq9R15rjVnif+VU5YOB3+AJA3IGB2SdiOP7itg8LxB2/zc5JQJTWxeY3WhJ0p17tJOQbAeXFOJbFGuaDkmE9IOOzxBmjSBeBsWhRg3rR6FLoZaZqG5UuWQ0dhvw4dOpYvWT6kOT+ttdKVYyoHp0ApyjFqqzTbKp0kx3JKRYUD1J4Sg1OVfaCcDgMCaFolYCYrACfTstXeDJXibweY8Z3Kxbm4U88xUo45tnQALJ5jil6jgPO2SlM5pm6xBCjFc4y8nL2CkmM+wenoXIAkmYCpsLAbnNYrGjAsnbUUCyctRFDLX19BLYiFkxZi6aylQ/48mZSW0NbAk2MKB1mAJUC1qxzLqStU3gg5bWsAgGZSjlkqt86CU0DdSbylxB7WtkrG1BwAwddLMKDZbkdVfSBQMuPc3w6gWBewKMfIc8w2/FnY6KCFmV+jascfxu9uN/4gzzGDkj3HFF5rXkHJMZ9gSs3t/5PyCpLKN3FuEF/jUDmmWnDK1WNZlr8BzLLssKoxgHwYAOdtlTxg6EtmlFWl6DpzXE3jBswqtzX0l5Cw4MnHfQoHqGZbpb1rNBIKiMRGr6LVWxF7OEjEjskpxzI6Uzb5L1TrkeCwz0+OirYOVngiFrDvbwdQcQ4A+pNOlWPG+1T2POW/e7PNwhxAiVjAefzBY49kRs8b8KIaJXuOKfoM9RJKjvmEUnwYzFY3dW9GpiGuXc8xnhxTL2Dg6jF+2wjYVI0BFDAAZnBq3xDXDGJVS8ZyehMZcGGJ3bbKehr+4LKtkpRjdpNj1veqem8rpa0yGgoiEjSeI6qeNydm/BxVi3OcRK6lMhqy728HUHEOsHqOObR1UDDW5XDlWEltlQqvNadtlXVRc+CByuoxx55j5G/nGZQc8wGl+jBQv7Kp5rE/rZJXbtW7GXH1GHLeY7pN1RhAAQNgaau0udZCwYAYFKFq9ZZ7UFSHg4iGbAZaucAins4iq6vZsmW2VdrfeJttlWquNcAsetit3AJUvU2UoFIEzOtU1YSF00nZgNrFOcD5VHaO2EQqeo1mdSamfDq2dVA09gCslg4ODPlpIJBjWwdN08zWSkV9x7I6E0ku255jtNY8g5JjPsAqQ3VkyC+qaeoqx8zWBmcTfFQNspbOWopa7QAAwNyxC2ypxgCgXvENJGCp3DoI7HnAoGpyzOmkSsBsqwTUTcaW0lZpBqdqrjWgNOWYmBil6FqLlzAMCLC0Pyv6TOgtKTmmbnEOsAyecpgcq1U81o1b9ghOC8Gqtj0D5rPQSfwhJrOn1D1vYlqlg+Jck+K+Y9ZY1bbnGE3L9gxKjvkA64Ovyqa6AjAfkqoGWpmsLqpp9qdVqu35oWkaJuKzCOtt+MqR19n2SqFpUZZpUTZbeAGrKb+a640HSnZbKoH8li1V11spbZVcOdZFbZXOkmOKJ/5LsXQAaHAG/71LaeFVNWFRylR2wGKSrmjCoj+31gKafa82XghWWzlmPAubnSjHomonsAHnbZUA0FijdnKMX2fRUMBxl0R/St0uCa+g5JgP4Dci5z4MuQqHqsFpylpNc+o5llF2ylYkMw+TknfggzNOsP0zdYr78gDmenPS6tZAyjEAzpJjAK03p9OiAKC5lhvyq5wcyxnyR50oBdTeDJUyrRKg+CPmULUOmMU5Ve9rPBHrxIwfMM+xqtcojz1qIyHbBc0GRSezWxHFuRKU66peo0Bp8UeTiHXVjD+cTsoGqEvCSyg55gP4eGun1bQ61atpud87HNRsZ+r5jSujszzFniowxkoyYLYa8quaVBT+dg6uUxGgKjpOvavE5JjqLVultVVy5Zi6myG+XuocqHkaRCJWzfPmttVN1XZUPgiJPMfsw5X+pbbwqp6IrSlBtZ5I62KPoRrCc8xB/FGvuCIWsLZVOhkIpHb8YU5lt/88iIaCiITUHmzjFZQc8wHxlHMzfoCqaSJgcFC5rY0EwcV5Kp63dJaBq3ejDtYb3wDozAxwVUMY8jtYb6p7jvWU4PkBUMtWaW2Varc1AGaiphTPMdXbKh0X5xRvtXc6KRswE7Eqxh6ApYXXgX0IYGmrVHStlRJ71EdD4CIzZYtzpbRVKv48SGd1pLPGJqEm7DzWVdXztBTlGEB+zl5ByTEfUIqSB6BpUbxy62SUuqZplslH6t3ErWo5J+utJhwUgVavogqLfpGMJUN+u/Dg1KlyrF7x6ahOp0UBZuW2L5kR049Vw820SlUVULw4V+oEQVWDejEMqCRDfjWfB4kS7msAqRS5at1J7BEIaOI5qmJrZSqji3bUUgYC9aXU7JLot9jVVEXspxiaFC/O8UJwg4PCHGC1EFHzvHkFJcd8QOmGuIpvIEVw6uy8mSbp6p23ZG6tBTSjHdUugYAmlIoqToxijKGfq3kctTaoG5wC1mmV9iu3gCVAVfAaBUqfVskT2ComY9OWAS2kHLNPycU5Hn8oausQKyk5prZyLJFxt9ZULQT3WzzHnCBiXQWfB1057ytNc1Ys4W2VjOUnilSBe1AGA5oYjGQH1T3HzLZKp10Saj8TvIKSYz4gXmI1TfXkWF8JbZWA2uPUrRshu8auHJUD1ERaBy8iUlulfXgV0XHAoLhxdaKEUerBgCY2ASpOrLTez52oiVVXKZoTBB2apCuuHONer47WmsKxB2AZPhV2ttZUj3VL8RwDrKb86p0366RsJ4POqsIBYb2iYqwrVIoO9wiqe47xe7pj5Zji9zavoOSYD0gI5VhpAUNMUZP0UoJTQG1TXK6scKpSBNQ2Se+3qCOcVL1NQ3711hpgUY6VWE1TNWAopa0SMKZyJcYE8HDnLjy7bx+yCj0X+P28JhJEyEHFW/XJqKVOq1TdB8qNIX9fMoOsrs61yRGG/CUOf1B1rZWuHDPer2JxjidpnPiNAQOsVxRcb25iD0Dd5JjZVunQQkRx5bpXOLtTEiOSUtsarCbp8XTWsYJqtGMGp06rablWNwVNSktt4QXUVo7xgKEqHEDQQRWyUeG2BsAMyp16jtUpPk69lLbKxzo7sXK+hkS4Gtfubgd2t2NKNIrb9tsPZ7e2enWoIwbTENdp5VZddQVgNeR3dt5qFU9gl2LIb12bfcmM4/viaIcsREqDF4KdJixULs6V6ncKGOutJ5FRMmFRyjAgwNpWqd5aA9zEH2rf27zCsXLsueeew5lnnolJkyZB0zQ88cQTed9/7LHHsHTpUrS0tEDTNKxZs8bW5/7ud7/DnDlzUFVVhUMOOQRPPvmk00NTlniqtIChJmKapKt4YfWX4PkBqG2KW6pKEVBbYVFq5ZZX01TdeHe7nFap4loDnAeoj3V24py33kJiwPLclkzinLfewmOdnbIPccTBPT8cT4sSlVv1ngeABM8xRa9RvnF2En9EQ0FEQsazV+X4o9S1lkjryGTVGzYSF/GHQzWP8NdVb62VWpgD1B52ZirHnMW6ZlulepYOgAvPMcV9KL3C8Q43Foth3rx5uP3224t+/9hjj8UPfvAD25/54osv4hOf+AQuvPBCvPbaazjrrLNw1lln4c0333R6eEpSanCqaRrqIupKMoUhrmPPMXVvRqZKoIS2yoi6myG3lVuVqmnt3e1YvWM1Vu9YjZ39byOprUd771vita09W4f9DJVN0hljjqaTZRnD5evXgwHAAFEjb9y6Yv1637dYUuW2NEr1HFP9vPUJ5ZjD+ENhA+ZEifGHNQGp4kAg/jvXOFxrpiG/umvNqQIKUHs6Kk+Olaoci6WySk7LdqtcV/U56hWO++hOPfVUnHrqqUW//5nPfAYAsGnTJtufedttt+GUU07BV7/6VQDA8uXL8fe//x0///nPceeddzo9ROUoNWAAjE1kbzKjZMBQiucHoLbnGJ9WWRUqba0BalbT4qUqxyxSc8aY4yEIo41kJomFdy9ER6zDeCFkfJ3xW/M9E+omYNPlmxANRYt+jsptlcmMDm5HVGXjmbCiqwtbk8mi32cA2pNJrOjqwvHNzZKOcuRhBqfk+eGEUpXrpg+UerEH4M7zdE8spWRyjBfnoiFnidhIKIBIKIBURkdvMi0U2arAiyVOlWOmIb96sS5ZiJRGPG2/MGfFqpjqjqfRWl88vvMjQjlG8ceIYEQY8r/00ks48cQT8147+eST8dJLLxX9mWQyiZ6enrwvVSlVag5YKxzqPfz6RXBaWsCgcnBaUiJWYaUAD5IcK8dyhrhZnSkxFjwSjGBq41QEijyaAgigraENkeDQJrkqV9P48wAwJkYNx46UvTYGu+8brfSKtsrSlGOxVFZJk3RqqyyNGNk6OMZVIVjhZGxMqHlKM+RX0XPMHD7lfJtcTxYijpOKxrRsPgDC37FGIUotzqn+HPWKEZEc27lzJ8aPH5/32vjx47Fz586iP3PTTTehsbFRfLW1tXl9mCMWNxUOlau3/GbiNGCoV3i8tZtplSrfxPk16nT4Q3U4iHDQUIup0FqpaRqWL1kOHYVl9Tp0LF+yfFgFncptlTw4jQQDtqYuTozYm8Zl932jFRGcOkxW1FmSabGUeuut1ISFeB4oeI0mM1mks0YitXTlunrnLc7jj1KU6wrHH/3JEtU8Cto6cBJCpUgWIk6Il9hWCZi+YyquNzGtsppsHUYCIyI5VgrXXHMNuru7xVd7e3ulD6lixFO58dYl3IzqFZb/xkr1/FC4rbLUFhrAMp1MwaCeJ5+rw87WmqZpypniLp21FAsnLURAy19jQS2IhZMWYumspcN+hsptldbJqHZY1NSEKdHoQLsxgQagLRrFoqYmKcc3UilVORYNBRHJJSFVvLfFS5iMCphJxXhaPcWdtRjptNVN5fgjkSpdOabydFSetC/Zc0zB+xovBJdqVwOo+Two1XMMMAcvdfWrdW9jjJWuHFNYpeglIyI5NmHCBHR0dOS91tHRgQkTJhT9mWg0ioaGhrwvVXHXVmn8jIrGkTGXnmNKBgwZvtZKmFYp2o/UO2/C88OhcgywVG8VCRiEeozlq1mzLGtLNQaYbZUqJv1NI2F797WgpuG2/fYr+D1+pm/dbz8Efe53x4NLp8EpoO7EKMZYyW2V1nuhaoE9vy9Vhe2pO60orVzPlB7r8oKJis8Et9MqexVU8sTd+OsqLDoQ0yodFoIBc72plhxLZnSkclN0GxwW5+oVFh14yYhIjh199NH45z//mffa3//+dxx99NEVOqLRRanBKaD2JjJWYsJCac8PF8qxOoWnbLmppjVUq9fasHTWUuzfPB9gxiPKiWoMsCQrFLyvlbLWzm5txSNz56I1kB+YTYlG8cjcuTi7tVXqMY5EekqcFmX9mT7FvDtTWWfDH6xYFXeqxR+lTqoEFG+rzN3boi6KcypuIl17jikY64rhUy7Wmorxh5spnyI5plCsC5jXl6Y5H9pFyjFvcPxk7uvrw/r168WfN27ciDVr1mDMmDGYOnUq9u7diy1btmD79u0AgHfeeQeAoQ7jSrDzzz8fkydPxk033QQAuPzyy7F48WLcfPPNOP300/Gb3/wGq1atwl133eX6F1QBdwFDrv1IxYChREPcBoWD00RuxLKb4Q+qbYQAa8LC+WZIxdYGTdPwyTlfxXUvfQqAM9UYANTlznMqoyOV0RFxON1sNMNVik4T2Ge3tmJSXwBn/e4VjGmpwi/Ono9FTU2+V4xxSm1rANRN/CdSpjdgqcr1VL+uXGBfauwBKF6cc6EcU7mtsj9ZWiFYTKuMZ5SYlm1FrDU3LbyKPQ8AM/4oyeZH0Yn2PXHT7zQQcHaNmbGHes8DL3G8Y1i1ahUWLFiABQsWAACuvPJKLFiwAN/+9rcBAH/4wx+wYMECnH766QCA8847DwsWLMCdd94pPmPLli3YsWOH+PMxxxyDhx56CHfddRfmzZuHRx55BE888QQOPvhgV7+cKrhRjqkcMPTxtsoSDfn7kkbAoBJmItbNg0+94Q88YHBTTVNJOQYABzYfi4g+GwAcqcaA/E2AaoGWm8ptQzSMqr06anZkcHxzszKJMaB0zzFAXVNcHnuEAhrCDtsDAXWr3vz3dRp7AGoX57i/binKdVU33oBVOeZ0WrYRe6SyOpKZwkNy/Irw1y2hrVKsNSUtREqPP1R9jpqxR+mWDiruR73E8ZP5+OOPH/If4IILLsAFF1ww5Gc8++yzg14799xzce655zo9HAIux1srHDDwhIXT1gYuNc/qDP2pbEnV39GKO387NR98gDvlWKOi49STGR1N6WVI1f0/3HjCjY6q1qFgAFXhABJpQ5XSXOvvSYtW+l2YVqs8gr5XRlulYgkLoRIo4XkAWKa6KXbe5LRVqvU8AFzGHwpPEDSLc87WW20kiGBAQ1Zn6I6nS0pKjla4IT+18DrDzbRKbvOj2jXKu0J4MtoJ9blzpjOjWFXKHoMYjDq9Jj7GneeYmgGDnktsAUCNQ6l5ddgIGAD1qrdxVz4MKk8QlGDIr1hyLJHWUa3Px7KZj+LEmSc6/nlVA63+EqcHAubzIJHWkc6qpRTgyYYGF22Vqq018TwoYSMEqKvmEZOyS0rE8rZKtc4Z4K4QrGpxLpXRkc4agganSkVN04RSUbXiHLXwloZZnHN+b6tV1ObHjWq9KhwQ+1HVzpuXUHLMB8QlmKSrdhO3yp2dVm81TVO2eivGW7sY/qCi/Je3kpZy3hqF55hqa630+xqgrgrKTeXWqoJVLWHhRjmm6rRKN0oeQN1NZF+Jk7IBde9r6ayOTG76g6tWN8XOG38eAKUlFRsUjT9oX1Ua/S6eCare27jnWCmFOU3TlB4A4RWUHPMBVE1zDq9uBAMaoiWYdfObuGoBg5uEBa8KZXWmrH9FKZshEZwqWrktNTmmahVSKIlLqNxGQgExvEClZ0Imq4tnQim+H6qqebgHFCXHnCGUYyUoiZVda2kzyVMVcR6zKbvWcoXgSDBQ0mAaqym/SvAY1U1yTEV/3bgLf11RQFfs3maq1ktriVS5jdcrKDnmA9ypedSspvEAqSYSLGkCD+/zVmmCIOAyOWbZrKsaoJbqC5gYE8AboQSe3bcPWUVUd27MlwF1q7du2ioBY2ISoNZ5s/6upfhAmWtNrQS267ZKReMPMa2yhAS26oU5TTMSPU5R93mQi3VLSMQCpseuquutpH2VRQGl62rEa5y4BA9s1RRQ/NoqxXMMUFdx5yWUHBvlZLI6UlkZyTG1Khxm5ba0TH29om00bjzHAgENtRFF1TxcOeZwM/RYZycu7H4fHUdU45XJWSx5/XVMf/llPNbZ6cVhjihM5VhpjylVPcfcVG4BS2Cv0DXK7+PRUGnqClWDU9PvtLRrtFbRdhAxrdJlW6VKG++ERaVYSkFT1eQYj+1rSiyWmMoxtZJj7vx1LfYEik2sdGfIr2aRyY2lA2CeN9X2o15CybFRTsLSnuamrVI17yw3wSlgbW1Q67y59ZipU3QTGSshYfFYZyfOeestdGbzz9W2ZBLnvPWW7xNkrtea8m2V7hR3KiUselyMUgfUDU4TLlWKqirX3RTneLKCMbU23m4M0gEz1lOtEGwOniot1lV3IFDpXRLRUAChnEm6sustTFOf7cITz6V4jgHq7qu8hJJjoxyr2aYb76xYKquUSXq/C0NcwJSaK7cZSrtrdVPV96PfYTUtyxguX78eha5I/toV69f7usXSrSG/qgGD27bKWgUTFvw+7trzQ6FzBshLxKq2GXJjyB8NBRAOqjct241BOqDuNSomZZd4jTbWqGchwhhzFetqmmaJP9RJKjLGXD0TVE1gy1KO9Skm1vASSo6NcqzqilKk5vxmlNXNh4EKxFwGDA2qK8dcboZU2ngzxizJMXsPvxVdXdiaTBb/TADtySRWdHVJOMKRiRmcUlulE9y0NQAWzzGFNkOug1NFK95xaQlstTZDwnOsBB8oY1q2eqb8btrcAHUTsTGHscdAeMFApbZK68CoUtcbt9BQ6d6WSOvg9Vo3bZWprI5kRp3zRp5jIw9Kjo1y3AYMNeEgeE5NpQvLfVulmsoxsd5KGKUOqFm9TWV1ZHPeMHZNcXekUlLfNxpxrRyjtsqSfl5FxR2v7pfaVlmveCLW/bRKdTbegFmcK9XztE5BOwxZSuJ4OiuexyrQ7yIRC1imZSu41oDS15uKLYL9ljZvNx7YgFrnzW1xjidiVbLC8BpKjo1y3Aanhkm6epsh3lbp1pBfpWqaITXn08ncGTCruNYA+6a4EyMRqe8bjbhPjuXWmkK+PID7tkoVE9hug1NViyVufQHrFW2j4Rs/Ks7Zx+1asyaHVLq3ceVYdcnKMW7Ir84546r1YEBDuITJqICisW5urUVDAQQCzjuZggFNKM5UOm/8Pl5ysUTBRKzXUHJslON2lDpgBg0qtbrxG2/JrUcKtjWksjp4wbXkapqCbZX9uWs0EgogZDPQWtTUhCnRKIqFFxqAtmgUi5qapBzjSCTu0t+uLneNqhYwxF220ajYfiStrVKxCYJuVYoq+tsBZvzhujinlJonN62yxLUWDQWFV5tK6y3u1kKkWsW15i4RC6hZZOLPg1L3VYCaw21k2dWotNa8hpJjo5w43cRLws20KEDVyq1lMqrbNhqFzlt/CYnYoKbhtv32A4BBCTL+51v32w/BEnwGRwtJ0cJbqseMehVIQKJJukLnbXXHv7A9+kXsSq0q6eetzxGVJgi6NUnnhTnV2kHcxx/qFef4fS1aoqUDoKbnqXvPMfWmVbq1qwHUNEl3W5gD1LR1SLi0q1GxhddrKDk2ynE7Sh1QUykgDPldjrdWsZomR2quThsNl5rXOgwYzm5txSNz52JyNJr3+pRoFI/MnYuzW1ulHeNIxH1bpXGNqrQRAiS0VfLEvyLnjTGGv2y5BelAO57ecVtJU5utEwRVCurdKgXqFbxGdZ2JhAW1VdpHWIi46pJQ694GSPQcUyg5lpCZiE2pF+u6uUZV7C5JZNypYnmsq9J9zWsoOTbKSWTc34z4ZkilinfMxSh1QPHg1EUitl7B8db8uirlGj27tRWbjjoKJ26LYOzrCSyvnYyNRx3l+8QYICFgUPAaBcw2mlITFqqpK57a8BR2xN8CALT3vYGnNjzl+DM0TVOyyCTLB6o/pY5Jer/F7LtU5ZiK07J5rFuqkhhQ794GuFeOWSfhlVI4GI24beEFLIlYhZ4H8bS72ANQz6stbRnYVfKgM1KOSYeSY6OceMqdLw9gmXSh0IUlRqm79hxTMDh1ITXn51slA+a4UI6VttaCmob9WBS1O7KYlgn7upXSimjZKnkyqnptlYwx12oelZI8jDFc+8y10HKhUABBXPvMtSVtAlVT3AHyJqMC6hTneOwR0Ep/lqpYnEtIUKWodG/j9EsqlqSzDMmMPsy7/UFCRltllXqJWLeqdUA9z7G4pVgSLXG9qWiF4TWUHBvlyPQcU+km3iek5qVWbtUzYHbrLwNYTNIVWmsxiUG9KhtvxpjrZKy1rVKVincyYxma4TJhocI1+tSGp7By+0owGJs+HVms3L6yJPUYX28qbbzdPhOsJumqnDdr7KGVWOgwk2MqFedyah43hWAFN5H9KXfFktpICHyZqpKwcOsBBZjtgbTWnKFS/AGYa03TDHuGUqhX7JyVA0qOjXKkTFVRuMLh1hBXZ+pUvBMupwcCaqp5zGlREkxKFQlOU1kdPJ8VdemdldHVqXjHLf4mNSV7talRueWqsaCWf56CWmnqMRXVPHyiLBXn7OPWjB9Q1JA/d28r9XkAKBrrurQQCQQ01EXU2nzLsKtRMRErw5C/XjF1ZzL3DI2GAiUXS1RUxHoNJcdGOWRSWho8OCq1wlEVDiAUMG5kqgSoMhKxtYpthACzhbTGzWZIsUBLxmRUa3JIlWuUK4kjwQBCJQ7NMI2E/X3OuGosy/JbvLOsNPWYeY0qpOZx2VYJqBd/uFWtA6omYiUUghVL8gDmfVyGmkcVpSK3q3FlyK9YQRMwRQfuukvUukbdDp4CzHOWyupIZtSxrPESSo6NcuIyLiwFExZuA1RN05QLUKX4MCiiSrEiPD9cDTJQSynA11pAg2i7ckogoCl3bzODU/deKX0J/7ajctVYoEgIFEDAsXpMxQEQMoa0qHaNuh0GBJjPAxWnZbvyPFV5WraEZKwqiR45sa6CXRIu/U4Biz2BIudNdOS4SMRau1JUuUa9hpJjo5y4xISFKjcjQE5rAx9xrUw1TWYi1ueqFCvCh6HEUeqAehtvazWtVKk5oN69TUZbAz9nfm5HTWVT2NK9BToK/346dLT3tCOVTdn+TNXWGiD3maBKUM+VhXUungeqFeYAshApFf67ykhg9yiy3kRbpatzZnqeqoLbSdmAeoo7GS28wYAmBn6pFH94SekRNDEiSEio3KpWTdN1JsapU2uDfaR4jlmCU8aYq8THaEGKSaliLVsy1hoA1CpWvZVRuc2rQiYzrv8NRiLRUBQrL16Jzv5OAMDHf/ki+pJZ3Pnpw9A2pgYAMK52HKKhqO3PVC2oB9xPqwTU8+bhcZarwpxibW6A+UxwN9hGrecBIEs5ppiaR0J7II89VGkXByzTKukatY3wUizRjJ9TVxVCLJVVZj/qNZQcG+XICE5Va2uIp7PC7LvWTfU2qlZrgwzPDx6g8bHgftx4D8QcpS7BkF+Ra1SGSgCwTEdVJGDga83NdRXIVSFjqSz6EhmMrbOfIBpNtDW2oa2xDQCgZToQZToOm3QopjTXlPR5qvkCZnWGlIQJgqqpeWJSPMfMZIUqRSYef7jygVKsZYsxJp4JtVLUPGrEunwyqpuOnHollWPy2ipVSSrK8BwDjH18B5LK3Nu8htoqRznU1uAc/rAKaO6Ceq4cU0ZqLsPzw5IgUiVoiEkIGBoUUymKjZCLtQaol7CQEZwCaiVjdUuSR8ZzVLWgHiCTdCfImVZp/KzOTLWG35EzfCqnSlHkOZrM6NBzhWA3A4FUiz9ktvD2p7LI6v707hyIqRxzb+tAiVhnqFYI9hpKjo1yZN7ElQlOucw8EnJVcTVN0hW5iUtYa8GAJjbuqqy3uGW9lYqoeCvy4BOJWBcqAUDdtko3G0hArcEZVl81N8kx1YZmxC3JMTctIWb8oUaSR8a0yupwEEHVpmVn+DPBvb+uKp6n1gKkDM8xVZ6jCVGcc5+IBdRZb9yuxt3wKTXXmlvlmGqFYK+h5NgoJ56W0Nag2AaSBwxuDNIBFT3H5NzEVfOYEYa4MkapK3LOTM8xl9U0xdpo+iV4UAJmFVIFdadVAeVq461Y61HcMhk1ECi9yFSrmJ+iDOVY/rRsNc5bQoqfkVqxh/V5EHRxjZrTUdU4b3EJnqfRUBCRoPE8UaWoKcWQX9j8qFEsSUoqBKumXPcaSo6NcmQEDLUWzzEno+tHKzIqt4B6prgyWngBs8KhysMvLoY/uA8YUhkdyYz/z1tSwgQfwJL4VyY4ldRWqVDBhCtSwkENoaAbjxm1Nt4yPCgB9Z4H/Pd04wEFKGjrIMHfrlY1CxEJyQpAvaSiDAsRwIz5VCgyAWYytkqGv10yA12BdlQZg0YANQcCeQklx0Y5Mj3HMjrLazHxKzIqtwDQUK1WG428CYJqKgWqw+59GAA1Hn5CleK2mqaYRN9sq3R3b1OpCil9rSlwfQIWDyhJzwNVnqOyinPCuFqV4pyECYL1ig1/EJOyXXZJ1ClWCJY3EEid5yhgmZYtYT8KqNGOGpeUiFVtor3XUHJslCNlgqBlI6XCJjImwQMKUK+t0lxrsm7iaigFhOeYiwA1mJsgCKhxjcqb4ENtlaWgkscdT/q78ZcB1EooApagXlLFW5WEhazinErxB2NMSiFYdEmkskqoUvqTcmLdBsUS/9IsRCJqnTdTuV76eouGAgjlWoBViNuEv53L4ly9Yteo11BybJQjo60yYNl4qxCgmqPU3d6M1KrcJmV7jilyE5cxrRKwVm/9f954C43baZXqtVXKaaNRSWEhjL5dT4syVYoq2BPIaqtUqYUX8MLWwf/nLX9ohntDfkANVYq8tkpVuyRcTstW6DkKWKdVlr7eNE1TSoUtqyNHteKc11BybJQjK0BVqbUhJik4FZ4fcf+fM0DmJDx1ErGAnGoaoJbvh+y2BhU2QoC8a1SlKZ/ypkUZG0jGzE2Cn0nIaquMqLWB5NcUvzeVSoNCxbm8oRmuTNJNVYoKHnf9KbmxrgrPA0Cmcl2thIU8z1N1zpv04pwCe/hyQMmxUUw6qyOTk4bLurBUCFCFIa7rgEGd4BSwtB9J8uZR4cGXzupIZY3z5l7No071VtbwB9Uq3rLbKlU4b0lJKoGqsLnxVuG8SSuWKLbxlt1W2aNA/MFjj3BQQ9jF0AxN05TyPOWxrjTvLAXWGiAv/rAOO/M7GYmxbp1C3SWyE7GqPEe9hpJjo5i4pGoaoNaFxVUksqZFqbARAiwGzK5VKeoEDFYFiVvlmFm99X+AKithoZICCpBYuVWoWJKQNEo9rx1EgWtUXgJbndgD8KI45//zFpd0jQJqeZ6afqfylGMqtIyLVjfygbJNv2U/6naPoFI7Ko91XU99VqzI5DWUHBvF8LYGTTPk4m4QxpEKXFjyPD9yptUpRUYOc/mvy7VWr1RyzPgdQwENEZfnTcVqmuuAIaeAUmGtAfLUPPUKJSz4fc3tOQMs7SAKXKOyplXyc9afyiLr8+doKmOqK+rcmqRXq7fW3A5/ANR6jsryHOPPUV2RlvGkLHsCvq9SwNaBX6PBgIaIC3UnoFhbpbRpleoMUSoHlBwbxSQsGWdN01x9lqkU8P+DT3ZbA2NqPPxkDH8ALP52Cjz4+iUpeQBVAwZJLVuKBAz9kvztVLpGZbWLA2qpoGQlsK1FKr97A1qT9LIGAvXE/a9SlOXLA6ilJu6XpBxTtWWcfKDsY7V0cLsfVWlol2wFtgoxWzmg5NgoRpYZP2AN6v0faMlqa6gKB0WFRIWAgU8QlHUTV0HN0y9prQFqttFEXW+8cxuhlBrtILLVPH0KeMwIVYqEjbdKbTSyVIrRUADhIDdJ9/d54wmZaCiAkEt1RYNCzwNZwx8AoK5KHTUx/x3dFudUahnPWL2c3frrKlQskWW7AqjVIsiLTG6LcyrFHuWAkmOjGFkZZ0AtHwZZAQNg9R3zd8AAeLHx9v9NnLdVSmnZUujhZ3p+uG3hVWuCoLS2SoWUxKYqhdSdToin5BRL8kzSfX5v48o4t6p1QDFD/ozMQrB6yjGZyvUen1+jvAgMyJjMrk4hOJ6Wt69SKamYkOSvy89ZPJ1FJqsP825iOCg5NoqRmalXJTgFPApQ4/4+b4wxEaBGXZukq/PgE20NLtvcAMV8oCQlearCAQRz7SAqnDdZmyGVrlFZwSlgqlJUeI7yRCxthuzDk801LlsqAbUGAvFErFslMaCWv26/8ByTp1z3+70tbimiufVyrlPoGpU1KRtQa1q2rOJcnj2BAkVNr6Hk2ChGlucHYFbTVKhwxCQZ8gPWVjd/V2+TGR28K03WWHC/+8sA5u8oU2quRMAgcYIgn0qrwmYoztebxAmCfh82kpQ4CU/Fa1SurYO/z5vMc9ZQnfMc83nsAUi2EFFoEp7pOSbh3qbIsBGzzS0gzTtLhVhXqkpRoWvUnMzu7rxFQgGRzO31eetzOaDk2CjGE88xBW7iwnNMSjVNjYCB38ABeZ5jfq9AAlblmLyAwe+JWMCq5pGRsFCj4s0Yk6bm4fc1IH9Eux+RNfwBsKo7/X+NypwgWKtI+5HUtValTgJb1kQ3QJ1ELGC1EJEX6/r93paUOL24XqFYNy5pGBCgaJeE5GcC4Q5Kjo1ivAhOVbiJm8oxCdVbRZRjfNMdCmgISxrTrIL0t19icKpSUC9zOpkq5y2Z0cH3yDJM0vl0Mr8/E8TUZ2oPdIQ3A4H8/UyQmfTnsYcK07JJpVgaMm0dVGkRNP1OJe6rfH5fAyxtleSv6whZk1EBtYQHXkPJsVGMGZzKm7Ll98otY8wjU1x/nzeZFW8eMKSyuqjS+ZV+ib48KlWF5K43NdoqrV4pbjeReSbpPlcKCC9Fl/4ygDobSMCj5JjPi0wy72vRUECZadmyPCgBxQrBZOvgGE+SFT5/hgJWfzt516jfB9swxqQ+E0T84fPzVg4oOTaK8SJh4fcNZCJtqitqpHqO+fu8yZyMam0x9Lt6rD8pMzmmRnsgYFHFSgkY1Dhv/BqNBAMIuVR3ApbJi34/bzLXmiLPUcCasJC31mI+nygrnqMSErGapikzLTsufKDkXaNK+EBxCxEJXRLcJN3v9zapyYrcWkukdd9PEPRG3env+1o6y8R+VIZSkZRj8qDk2CgmLnE6iCrJMWtAVCOxx9vvwanMjVAoGBBr1u9KRWFSKiERq0qyAjDHqcuo3qriXyGzrQGwqon9nbAw15pEdacC16jMpGKtIvc2mRtvQJ1p2XxapdzWZ3/f1wDJ07KViXXlPQ9UmiAoM/5Q5TmasHTORKUoFdVIYJcDSo6NYmSqeeqFD5S/Lyoe0EdDAQQC7ibRAOq0VZoVbzlBvSqbISE1lyiZ9ns7qq4zpCQmLFRrq5RRLAHUqd7KNftWJzilCYLOSUpM+gPmxErfJywy8uKPWkVaeLO6vAEtgDq2DjLbKiOhACKKTBCUOq1SEV9iHntomhxbB1WSiuWAkmOjGJlGwqoox5IZuZVbVQz5kxLXGmBRpfi8tUGmcsxa/fXzw49vIAFZEn01EhYyN0KAOgnspMTEvyq+PIBcH6g6RRLYXinH/L7eEil5ynVVFLH8eQDkK5hKRRXluvRrVJFEj8xplaoUgpOW4Q+a5l6sUaeIV1s5oOTYKMaLym06y3x9MzIl03KWvirBqXzlWG4z5PPzJtOkNBjQlAhQrUG9TJNSVdaarAR2nSJKAZltNGabm7+LJYBcpaIqCWz5G2/jvPX4vDjHlWNkIWIfPik7IE2Vooa/blLivgqwPkf9fY32SzxvqhSCZarWAXVi3XJAybFRjEwDRPVuRpKUY6q0NfDzJmvjrUqAKlFqDqhx3vhaCwc1BCW0PnNVit9btmS3VarSai9atiQEqI38eZDMIMuddn0IY0xqcU6VYonMRCwANFT7v1gCWOwwJK61WCoDxvx7jcYsSh6pqhSfx7oy7WoAc2/ld4+7uORCMB/c5edYV/ZaU8UKoxxQcmwUIwxxJd2MTJN0/97ERSsqtTU4QuaULUCNJA+QH6DKoE6B9ZaQrFLkqhS/S83jEtvcAHUk+jILJrxYAvh7E5nKmlOfZcQfqkwQlK0U4GoevyvHZCZiudqOMbN45UdkqtYBdTzHZHeXqKLmkT0QSAVbB9nFElWu0XJAybFRjMyAAbBsvH2cdebBqYwKJKCO1Fymvx1gPvj8rkrh1bRaUo7ZRgQM0taaGqoU2SpF07ja3+dN5tTFcDAgzn+3j1srEynZvoCKrDXJiX9VplXK3ERWhQPggmQ/P0fFpEoJfmOAOmbfsrtLVFHz9HtUCPbzNSr2o5JFB37fj5YDx/8izz33HM4880xMmjQJmqbhiSeeyPs+Ywzf/va3MXHiRFRXV+PEE0/Ee++9N+RnXnfdddA0Le9rzpw5Tg9NOaQnxxQwjpStgLJm6v3cRiNfzeP/Bx9gXkuyBxn4WZUic1oUoM7wB+ltlYpMEEzIniDI1Tw+TljwazQU0BAOuj9vqvhASW+rVGQgkEwLEU3TlIg/+H1bnnLMWGuxVNbXsa53rW7+3VcBcq9RwLR18HMy1qtELCXH3OM4qonFYpg3bx5uv/32gt//4Q9/iJ/+9Ke488478e9//xu1tbU4+eSTkUgkhvzcuXPnYseOHeLr+eefd3poymFOi5KbdfbzZsiraVGAv2/iccmSadWUAtKrtz6+RmVODwQsZt+KrLVqWZVbBTaQus6QyshNWHDfMT8rx2QX5lRJxCYl+tsB6tk6yI51/fxMEMoxyc8DwN/PhIRlgqAMVFFgy26rrFOgqMkLc7Keozz2UGEgkNc4vmueeuqpOPXUUwt+jzGGW2+9Fd/61rfw4Q9/GABw//33Y/z48XjiiSdw3nnnFT+QUAgTJkxwejhKI7MdBDDbj/zsMSNbJRANBREJBZDK6OhJpNFYEx7+h0YhZjuq5ESsjx98gPzqrQqVIdMgne5rTvCqrdLPay2ZMdsDZSfH/OwDxf2M5LU+8+dBFrrOEJAwiGMk4tVAID+vNcDafkS2Dnbhv5usZEUkFEA0FEAyo6M3kRb3Ob+RlJyIVUW57tXwKT/HH7I9KPn+08+FuXIh1XNs48aN2LlzJ0488UTxWmNjI4488ki89NJLQ/7se++9h0mTJmHmzJn41Kc+hS1btgz5/mQyiZ6enrwv1ZAv/83Jpn0cMCQlnzPA2trg3/MmWymgwsY7qzOx+Zbmw8BVUD6+RqUPzVDgvgaY/nbyR9D797zx4BSQ12rPJwj6OUCV3UJjVaX4eRMp2+xbGeWYR6oUP9/bTNW6vFhXBeW6V22V/r9GZReCVYh15a41q2rdz5N4y4HU5NjOnTsBAOPHj897ffz48eJ7hTjyyCNx33334a9//SvuuOMObNy4EYsWLUJvb2/Rn7npppvQ2Ngovtra2uT8EqMI+QGq/42rZZ8zAGhQwAdKtleKCi28/ZZNnuyJUX5ea3wjJE2lmDtn/Yp4pUjzt1PgGuUqxVBAQ0iCdxZgqnn8nByLp+QmsKOhAEI5tRhthuyjjOeY5NZnFVrGud+prMIcoEaiR7a/rgoqRcYY+qVPy1ZnPyo7OZbRGWI+nsRbDkbEtMpTTz0V5557Lj7wgQ/g5JNPxpNPPomuri789re/Lfoz11xzDbq7u8VXe3t7GY94ZCBbYaGCKa7sJA+gRvVWeiJWeMz49wbOZeYBTd40GhUmRnnVVgn4+94mva1BAZWA7GcooIbvh1BXSFprmqZZngk+Xm+S720qDH/IWnwB5Q+f8u9565c8KRswTfl9HX9InpZdr8C+KpnRwYVKNK3SPrKVxNXhIMJBo8jk5+JcOZCaHOOeYR0dHXmvd3R0OPITa2pqwv7774/169cXfU80GkVDQ0Pel0owxqQrBVQITuOSvbMAM2Do9fGoZtm98aKt0sdrzWqIq2lyPHRUqHjLTmBHQ0FEcqogX9/bJE+r5EbOKiT9ox602fs5ODXb7OU9R9VYb3LNvnmxJJ7OIp3Vh3n36MTa+iy/EOzf4pxQjkkaBgSY8YefPe5EAltSQVMF0UF/Sv41ytsq/f08kOulqGkaGqsjAIDufv9eo+VAanJsxowZmDBhAv75z3+K13p6evDvf/8bRx99tO3P6evrw4YNGzBx4kSZh+cr0lkmWoSkSc0j/r+Jy5ZMA2aA6ufqrVc+DH5OVsg2xAXMBLYKAYPrjXd7O7B6NbB6NQ7fuxFzd65HeuUq8Rq2bpVwtCMH6W2VubWWzOi+3XjHJSf9ATWmVSYkJ2IB6zPBvwmLRErueqtTYFq2NTkmS4FtFpn8e41y5ViNB10Sft4jyB50VqeA2p+vtWgogKCkYSoqiDW86GRqVMDztBw4Lin09fXlKbo2btyINWvWYMyYMZg6dSquuOIKfO9738Ps2bMxY8YMXHvttZg0aRLOOuss8TMnnHACPvKRj+BLX/oSAOCqq67CmWeeiWnTpmH79u34zne+g2AwiE984hPuf0OfEvegmqaWjNWLtkr/3oxk98aroIAyDXHlVW7rFRj+IGWtJZPAwoVATsX8EH/9V5b3TJgAbNoERKOl/z0jCLOtUs56s67bWDKDppqIlM8dSci+rwHWCYL+vUZlJ2IBa/zh4+eo5LbKcDCAmkgQ/aksehJpNNf67xoVav9QQNoUUxUSseJ5IFM5pkCiJynd3y7nneXjWDfhwfNAhXZU/jzwwtaBkmPucHzXXLVqFZYsWSL+fOWVVwIAli1bhvvuuw9f+9rXEIvF8LnPfQ5dXV049thj8de//hVVVVXiZzZs2IDdu3eLP2/duhWf+MQnsGfPHrS2tuLYY4/Fyy+/jNbWVje/m6/hN6NgQBM9xm5RQf5rBqcetFX6OGCIS/bmUSERK5RjHqgr/HzepCQsIhFg6lSgsxPQC6ieAgGgrc14n0+Q3VYZDgZQFQ4gkdbRm/Bnciwp2fMDUCM4la0kBvzf6pbVGdJZuWp/wCjO9aeyvo0/vChoqjAt2wvPMRUms8sfdOb/adkiEetBrOtn6xXZSmJADc/TcuA4OXb88ccPOSJU0zRcf/31uP7664u+Z9OmTXl//s1vfuP0MJTHuhGS7Wfk55t40pNplf5XCiRlK8dy6pZURkcqoyMiqV1iJMGvURql7gwpmyFNA5YvB045pfD3dd34vqR750jAEzVPNIREOuXb9eZFm70KwansRCzg/+mo1vZA2cW5jp6kb9ebFxPGVWjZ4gkL2c8DwN/xh+xWe2GF4eNz5slaEypFf97XAPlKYkCN4lw58N+OVBG8qNzW+bxyC1BbZanEJQeo1oSRXwPUmAgY5Bvi+rmtQdrwh6VLjdbK4IA1Gwwary9d6u7zRxiyp1UC/i+YeBGcNlRzD0r/Pg/4NSpzrdX6vP0oLzkmMRnbwD1PffpM8Cbpb3xWLOXPcwZ40zIu/HV9HOtKtxAZUAj2I3HJlg6AGolY2dMqAUqOyYKSY6MUM2CQOC1KAZNS2VMXAWtyzM83cbnnLZRr2QL8+/BbueNZbI9+Efsyq6R9Jl9rqayet9nyE3FZah6uHssOOE/ZrO9UYwAQT3nQxuvzqrc3hrhmcDqUyn40I7tYApjtR359HiRyG+OIRO8swGrr4M+4LWHxHJOFUpNRPXge+LU4xxiTft5UKAR7qlL06VoDvElgU3JMDpQcG6V4MS2qXkjN/bnpBizmrlLPm7+DU8BrpaL/Hn6MMTz87g+RDrRj5b5fSNsk11oqc348b4DkoD6nHtMDxqNODwR8qRpjjIlr1AvlmF8DVC+KJTw4zegsb3COnxAT3TxQ8/h+rUm2EKj3u3LMw5YtvyYrAG/WW53PvdqSFmUXFYLtIyajenGNprLQdX8WmczEv/yBQJQcc4c8DSRRVjw1xPXpgw/wxmNGdltDe3c7Ovs7i35/XO04TGmYIuXvsoMX1TTACLR296V8GaA+teEpbO59AwDQkXgLT214Cifvd7Lrzw0ENNRFQ+hLZtCXyGBsnT8mLVpJZiSqYnPqsUDOeyzgQ68xwAjqefxIHjP28eI5Wh0OIhTQkNEZuuNpqa0mIwVPlGM+T1iIhKLEcwaYmyG/Fue44k5mzOb3+xrg0STeKp+rO/N8AeWqYhPppG/Pm5eFOcBof+YiBD/B91UyYzZSjsnBf1GbIniSrIiYLVvJTFZqNnuk4EWPt0zlWDKTxMK7F6Ij1lH0PRPqJmDT5ZsQDZUnMWKtpsm8idf6dBoNYwzXPnMtNATAoENDANc+cy2WzloqZXiGSI7JOG/t7cZEx2KMGwdMKV8iFvAggb10KXbP+QDGrvsPNs04CNN9phoDzI034M10VL8mLLx4HmiahsbqMPbEUuiOpzGxsVraZ48UvDBJ9+vzgJP0wN8O8L+tQ8ID5Zgak9nlb7zrfO6vy58HoYCGcFCm4i6I3X3+XW/mgBZ5KYVoKIBwUEM6y9CX9GlyLCNf3UnJMTlQcmyU4kXlNr833p/JMVOV4oUhv/sHXyQYwdTGqeiMdULHYPPOAAJoa2hDJBhx/XfZJd9IWL7Hnd823k9teAort68Uf2bQsXL7SmnqsfqqEHb2SDDFTSaNFsOO4olYTJgAbNoERMunUJOu5tE0vHv5Ndj3ra/hdx/+PL7hM9UYYJ6zSDCAkMyg3ucb76QHSmLAUPPsiaXQE/fnefNqMirgv+cBx4tELGCZlu3TzZAXsa51MipjTNrE95GEF10Sfp+W7YWSGLAkLPr9eY2anmNyi0x10RD29aeNbqZGaR89Ykh4oCZWYVp2OSDPsVGKFwGDtTfe9wGqBz3e/aksMll302g0TcPyJcsLJsYAQIeO5UuWlzWY42stHNSkbrzrfbgZ4qqxoJa/voJaENc+c60U7zFppriRCDB1KhAo8m8aCABtbcb7ygi/RqMSN5GpJR/ESRfdgeenL5D2mSMJLwxxAQVM0j3aDPnd98OLFkG/t7p5ttZ8nsAWvjwSnwe8MKcz+NIX0OpBKTMZ63fPMS88KAGgqcaIofb1p6R+7kjBbKuUq7fx/UCgjAcDgWr8HXuUC1KOjVK8kJoD/u+N93K8NWAE9vxBWCpLZy3FwkkLsXrHamSZGbgFtSAOnXgols4qb1uYFwlFwNJG46NAa6BqjJNlWWnqMWmbSD7NMefHNYgK+XN50bLVnLsmu2QHpyOkLTXuwYAWQKJJ+gg5TwPxSs3j99aGOPdK8cLz1Lexh/yNEGCxdfBgyvid/9qAbfviuP7DcyumrvKiEFwTCULTAMaM9eY3X8BUVgevw3kxfCqZ0ZHK6IhI7CTYF0uhqSZcURWfVwns5lzCosu3yjH5k7IBcwCVX32wvRwIxKdl+1EVWw789URQCK/kv37ujU9ndWRyrtUyb0bhnOIukdbRm3CfHOPqsVMezE9aZFm27KoxwJvJZIDVgNkflVuuGgsgULQlVob3mFRT3Nw0R7Z6NbSs5d8hGAQOPbQiUx292EQ28eBUZrJiBLWlemGIC1gSsSkXa20EnaeBJDzygRJDWjxIjrXv7ccNf34bn1s8E4dObZb++XZIUFulY7zaeItplZJbeBPpLH7413XQGbDsmGnYb1y91M+3fxzynweapqEuEkJvbrBNhX41z+DnDPDGgxIw4o8xITmq8n+s7cBF96/CV08+AJcu2U/KZ5aCVwlsvyvHuHJddvxR7+MhLcagM+/aKjM6Q38qK4pOhDOorXKU4kU1DbC0bPnwZuTVJBrArKi59oHKsXTWUhw64XCAGZeohgAWTlpYdtUYYN1Ayr1dmAoof1TTUtkUtnRvGbIltr2nHamsuwBJamtDTj2WlxgDgGy2YlMdvQgYeHDan8oK30HXjKC2VFG5lZ7AziVi3ay1EXSeBuJVwsJL5dj9L23CX9/aiftf3CT9s+3ihVKxzufTsr0wXwa8m1b5XkefmIDbvjcu9bOd4IWSGLB6nvqjOGeFn7OAZthhyCIY0FCbe8bIXG8vbtgDAHju3SHUxWXAq7bKZpEc80esO5C4R8mxOh8PaUlnmbi/yp6Wza95vyrXywElx0YpcQ8MEAF/y1it1bSo5ABVdvVW0zRc9IGrAc04ZlYBrzFOwqOWLbHWfBKcRkNRrLx4JV793Kt49XOvYknT/8OExK342Ql/E6+tvHil6ymj0k3Sly7Fzv0PQUYzrgkWDBpKnwpNdfQiQK2PhhDIXTrSTHF5W6pexGewjG2pnrdVuglOR9B5GkjcI6UAT1jIKpZYWblpHwBgZ09C+mfbxQvlulASp7LQdffejCMNL3zaAO+mVa7b2SP+f+u+fqmf7YS4VxYiChSCq8JB6TGjF0NaNu2JAQDe29Un7TNLwatEbHMtb6v0t3KsWrrnmITi3ACufHgNzrr9hbwJ35UgkbGKNeRPywYoOeYG0tuNUry6ifu5tcG66ZYdMAjfD4mboZbQQkT02UgF3kNL5MCKqMYA71qPaqJBJMYE8JrWj2f37cOipiYEZf27VMjjqK2xDW2NbQCAKsQQZT04ZNwCHDqxVdrfIV1xp2n4/Ue/gM/fdKnxxwqqxqytzzLvbYGAETDs60+jK57GuIYqOR88QtpSvTbkd/08yJ0nrF5tqBI5FWzfBbxTCngVnMZTWby5rRsAsKsnKfWzHR2Hh22VABBLZcQz1S8kMx5Pq0zI9Zh5Z2ev+P+t+yqoHMvFH7ILmn72uPOqPRAwrtMOJOUmx3YbybG9sRR29yUxtq687fUcr2Jdv7dVeq0ck3WNJtJZPPbaNgDAyxv3YMkB46R8bknHkjtnmmZMGZdJQ3UYu/tSlBxzASnHRimeeY75uJqW9OjBB3gzMWpDZwxN6WUI621oC1xYOUPclPxA67HOTlytb0PHEdX4W3McS15/HdNffhmPDZXQsgv3ODrssOJfCxca7/MQc5S6NypFmdW0v03+AF6fMBsAsPegD1Q8WQF4YYqbC1BjEgPUEdKW6pnnmKz7GlePjaD2XQBIimvUm7ZK2Z5jr2/tEsnjjgopx7I6Qyoj35A/GgoglJN3+rnVzSvlWDrLRAJOBu90jIzkmFfKMT9Oy+Z4VTwHzEKwrD1CJqtjy15TmfiuZd2VGx7rRiU/D7w25O9LZnDabSvw+QdWefL5w+FFsQSwxLqS1tq2LvM+9lKulbdSWAedyd7bkXLMPZQcG6V4FTAoUU2T/OADzOqtTOXYux29qNbnY1LyDsR6D6pYq4nsoP6xzk6c89Zb2MvyN0Dbkkmc89Zb7hNkI8TjyAvTasCbNprNe+P44eJleK+lDX86738qlqzwsvW50QtTfgBYuhTts+aabamB8reletdWKfF5sHQp9MMOF+cpqwUq2r4LeKewEGoeySbpqzbtFf8fS2Ur8py2JrBlrjdN0yzxh/+Ceq+SY7WRkLhdy2zjXZenHKtcW2Ui403cVptrGfejnxFPVkQlqxQBa8JCzlrbui8uEv6A4XVXKbz3HPNGOfa7Ve1Yu6MHf3urA+msvAS5XbyeVikr1m23JGErnhzzyMsZoOSYDCg5NkqJe1Tx9nM1Le7Rgw/wJmFh9V9IZXR09FZGKWAOf3B/3rKM4fL161Eozcdfu2L9emSZi0TgCPE4EkG99IRFLhEr6RrtSaSxJ5bCC9Pn46SL7sCT4+dK+dxS4MFpNCS/9ZkHqNI8x3IkMjq+d+QnEGLGv7eml18N5ZnnhyU5xtxckwCgadj51W+K8xRkOvZefW3FErGAdwGqV8Ep9xvj7KqAeixuSY7JTmCb602Ocmzt9h6xcas0XiViAwFNxG2ykrF7Yyl09prK6oq2VXpcCPZjrJvwaH8AyI91N+ZaKjmVVI7x54HsJA+flr2vP+3+OTqArM5wzwsbxZ+lKuNt4llbpWTlWLvlPvbW9u6KJo+8KpYA3inXVYKSY6OUZC7QGunKsazOpD8MSsXLm5EIGCSdt1gyIwJSLsnevKcy1VuZ521FVxe2DtHOyAC0J5NY0dXl7i/iXlDBAcdcRrN5YcAsOUCtk9xWuWXAulq7vadi1yxvfZZ9XwOApmoeoMoNHv++tgN/mzJPtKXuPrD8balet1VmdTktW+/NP0acp9cnzMbfJn/A9We6YTRNq8zqDKs3G8kxPo2qowK+Y6axfACBgGSzb4kTK/+ztQun/XQFPnrHS3lqt0rhlSoFkO95ys34x9QaBYU9sVTFkkheTWb3cyE44dH+AJA8LRtmcozf0yqqHPNoaAYvzKUyel5xQQZ/X7szb5rsngokx/o9ij9kX6NWBazOgFc27h3i3d7ipS8gKcfcQ8mxUYpXAUOtxMptLJnB4h89g4/e8WJeFbJS8JtR1EMfBlnB6YZOI0AYWxfBwZMbASDPl6GcyPSv2JGy9+C2+76iaBo6vvrNinlBMcZMVYrkibKyfRj4pKgPTGlEKKChJ5HB9u4KqRRT3rU+e9VW+ejqrYCm4cfHG22p/1r25bKroeIetTXUhIPiV5GxGdraZbbv/nDxMvxznQSPQRd41lZZnVPySG6z701mUBcNYUFbMwBgVwXUxF76GdXKmI6a443c4IK3d/Tg5qfecf15bvGqPRCQr+ZZt8NQ7xw2rVn4qVr9espJwqMWwVrJSZ5CMMakWm3YJelhy5YZ68qNP46ZNRYA8O6u3ooV5xIeDc2oiQSF6fo+ycr1//f8xrw/761EcsyzaZVyC8Fbc0nESE7xXMnWynIox7zyuFMBSo6NUrwy5JeZqX97Rw+27otj9ZYunHPni9i8Jzb8D3lIQmJ74EB4cCqrreHdXPVs9rh6TB1TA2CwwqdcyNxATrTp82Xnfe3d7Vi9Y3XBr9+/tQInr4vh9QmzhcdROVVjqawOHt95dY3KCrq5InH2uHrMaq0DALy9vUfKZzvFSx8GXr2VOU59V08Cz71rJHgazzwVJ110B9YccLi0z7eLV9MqAwENdRF5ydit++J4Yfp8fON7v8EL0+fjhfW7K6rq8XpaZX8qK80DhvuNLZjahIlNxrTVSpjy93vkbwcAdRLNvrdbkjn/+/xGvLh+t+vPdIOXm6EG3kYj6ZnAJ1XOmVCPKc1G/FEp3zGvCsF84+2FciyrM/zpP9txxs+exwe++xT++XaH9L9jKLxSrQPyp2Vz5diJB45DQDM29J19lSmme5X41zTNbK2UmLxa096FlZv2IRzUMKu1FkD5lWPWAS01HnmeyurIac/dw06ZOwEA8NL7lUuOeWnzQ8ox91BybJTiuSG/hEy9tdK4eU8/PnrHS2IMfSXwtq1SbnD6Xs53Yf/xdWZyrELKMZmJ2EVNTZgSjaKYrkYD0BaNYlFT05Cfk8wksfDuhTjsrsMKfp31yHF4I/sl/HTJJ4XHUTkn4yVS5obYs7ZKGT5QMMeoT2upwUGTGgAYie1K4OU12uTBxKgn1myDzoBDpzZh4fQxAIA9sQq0unnU1gDI9ebhreJLD5qA8Q1RxNNZ/LtCrQ26pVVU/gTBsPh/Wb4f3G/s8GljML6BJ8cqt9aqPGnZMj5Txlrb3mUkDhurw2AM+MrvXpfuN+gEL9sqZU/LXpeLPw6YUI8pzdUAKuc75pW6k2+8YxI96ZKZLH79yhaccPOz+NJDr+Gt7T1gzEhilJOyWIhIbqucM7FBxLqVaq3k+yovukvM4py8exBXjZ05bxIOmFAPANhb5sSi1dNR9n60TvLwB27If+7hUwAYcW4lPNoAb30BGyg55hpKjo1SvKpwyDRA3JFrzVo0eywOnNiA3X1JnHfXyxWTsnrZ1iA7OOVm/PuNr8e0FiNg2FzhtkoZQX1Q03DbfvsBwKAEGf/zrfvth+AwCaxIMIKpjVMRKHYLYxrqQ+Nx9tcvFh5H5ZyMxxVQAc300pAFD+rTWTk+UFw5Nq2lBgdONAKstRVLjnnnw9AkeWIUYwyPvroNAPDRw6agpc74/N19lTPE9UbNI+/extUnbWOqseSAcQCAp8usquBYrx3Z6y1oMUmXFaC+mvMbWzi9GePqowAqoxzzSskDyJ2OypVj15w6BzPG1mJHdwLf+v2brj+3VMpRnJOhJtZ1Jopz+cqxyrZVjuRJeP2pDO5+7n0c98NncM1jb2DTnn40VocxN1dsKnd7k1fDgACLrYOE85ZIZ0URfXpLLWaPN+KPSpnye3neTFN+OfHB9q44nnxjBwDgwmNnCH/AcrdV8tgjoMkf0FIvUazRl8yIltb5bU2YPc7okvj3xsrsR5Npb1p4AVKOyYCSY6MUz6TmEj0/eHB6yORGPPz5o3DkjDHoS2aw7J5X8Nc3d7j+fKckR5EhLg8O9h9Xh7ZcNa29wsoxWWvt7NZWPDJ3LiZHo3mvT4lG8cjcuTi7tXXYz9A0DcuXLIeOIskhjeGes3+MmePq8cPFy/B+61TgxhvL5gVlDehlT12sjYTEryHjOuWeH9NbanHgxMoqx7yUmjdJ9mF4a3sP3unoRSQUwBmHTDLNqyvQEuJVWyUgN2HBN9hTmmvwwTm55Ng7uyriMWNt56ySHNQDcqu327ri2NYVRzCgYf7UJqEc21UBL8+Eh4lYmQOBtncba22/cXW45ePzEQxo+OPr2/H7Ndtcf3YpJDzcDDVItHVo39eP/lQWkVAA01tqLcqxCscfku9tPFkh4/r88sNrcMOTb6OjJ4nxDVF86/QD8eLVH8RHDzUUKrKHwAyHlypFMS1bQsKifW8/GDOeMWPrIth/vJGweLdCyjEv/RRl2zr86sVNyOoMR89swdxJjRhTa8TT5W6rNFXrIfmxrsTnAd8/NdWEUV8VxtGzWgBUznfMtBChaZUjEUqOjUIYY5bWBm9MSmW2NUxsqkZDVRi/+u8jcPLc8UhldVzy4Gr8+pUtrv8OJ8Q9mkQDyJWa96fMSZWzx5ueY3tjqcqYu3qg5jm7tRWbjjoKi7eEMfb1BG6om4KNRx1lKzHGWTprKRZOWoigln9cGgI4dMLh+MiBp6G5JoIXps/HSRfdAXbCCdKOfzi88gQE8n2g3K63/lRGbLCtybHNe/ulGf47oRxtlbKqaY+u3goAOOnA8WisCWNsnRGcVsIQ1xqgyqZeUmtDIp0Vg1mmNFfjv/Ybi0gwgPa9cTGApJzw4DQU0BAKepcc65HwTOB+Y3MnNaAmEjKTY5VUjnmQiJXleZrVGXbmlOuTmqoxv60Jl33QUBB/64k3K2IuP1qUY+tyfmP7tdYhFAxYinPlP2fprI6sbiTOZSv+W3L36z0SlL5vbDXsQr52ygF47mtLcNGimaiNhqQ/c+ziZfwhczI7b6mcMbYWmqZh/5xy7L1KKcc8TCo213LlmPu10JfM4KHc/umiRTMAAC0VUo71e7iv4qp1o0vCnTcpT4615ZSwR8/MJccq5Ds2mmJdFaHk2CgkmTHNvuUrx+Q9+LhybHLOPLgqHMQvPnUYPnFEG3QGfOf3b5X14vUyU98gcYLP+l3mpMoxtRHUV4WFKqUSvmNeqRSDmoYDA1Wo3ZHF5FRo2FbKgXD1WJblPzQZdNx4wvfyTFCzOpOySbWLl+2BgLwpPrylsqkmLBI84+qjYAx4Z2f51WNJD30YmiW2VaazOv6wZjsA4KOHTQZgBqf7+tPISDJht4uXbZW1wpDfXXDKExJ10RAaq8OojYZw5EzDp+3pdbvcHWQJeH2NNlbLa6tcZfEbA4DxDbytMll21Z2XG29Znqe7+5JIZxmCAU20oF66ZBYWTG1CbyKDKx9eI5Iu5cLL+ENmcc5qxg+gosqxuFXdKbkQzO/Xu/vcXUNZnaEjl/Q/e8EURC3PLi98Lu3gZcuWTB8onhybPtYwk589zmyrrKSaeKTbOvxuVTt6ExnMHFsr7AmEcr1iyjHvYg/A/TOhPSc4aBtj3M+OzCXH3u3ow+4KqP29jD+sbZWVmvw62qHk2Cgkrx3Eo+RYKqO7nrK1I9fWMLGxWrwWDGi48SOHoKEqhFRWR2cZR9Hzm5HskeCAGZzG0+6nk3Ez0v1yPfEAKjqx0qtR6oD7BzpXj/FbWUALYuGkhVg6y/AWqwoHRcJA5pTC4fCyAglYk9juAlQ+QXZaS614javH1u4of/WWX6NeqFIacxuVRFp3PSHxX+90Yk8shbF1URw321A7NtVEEMjld/eWuY2mP20Ejp60VUpKxJotldWi/eKEXGvlP9+uRHLMu40QYBZMpCTHcn5jh09vBgCMqzcKTvF0VtokL7uUw9/OrWqVJ2LH10eFKjAUDOCWj81HTSSIf2/ci/9d8b67g3WI2Ax5aMAsYyAQT45xg+/JueTYvv502dXE/BrVNCAiWd3JPSKTGR2xVOnPg87eJLI6QyigobU+3ypCts+lXbxsD5Tpr8stHWbkkmMzW2sR0Ay1bUVaxnn84UlbpZxEaVZnuPeFTQCAzx47A4Fc0CGKc2VOjnnZZh8MaKiNyLH6GagcG1MbEQWAlyugHvNyj8CTYxmdCWUf4QxKjo1CeKY+FNAQlhww8Mot4K61IZ7KCvnwpKbqvO8Zih7jRl5W5ZiXRsJV5nlzGzS8u4tPqqwXr1VyYqWXBsxuH+hcPYac95jOsli+ZHme90FzjTw5u1283njLMsXdlEu2Ts8NfQBQUd8xLz3H6qMhBHOBpNMAtb27Hat3rBZfd770DyS19Thi/y78Z9cabO3ZimBAs/iOldsUNzdK3VPPMXfXD1eecCUKAHxwzngARvKn3C0AXiewZfl+9CTSWJdTcR4+zUiOVUeC4h5Q7tZKT5+jkjxmuGp9YOwxfWwtvn3GQQCAXzy7wdXf4RQv1xtfCzLU0Xyt8eRYQ1VYrOVtZTbl51OfvfDurImExBre6+J+zb3txjdUiecLh/tclntKqpfxB/cc60u4n5b9fidPjhnxR1U4iOm5Ql0lTPm9LATLSpT+fW0HtuztR1NNGB89dLJ4fUxdhQz5vS4ES0rGivhjjBnrct+xFyvgO+alArs6HBSDwKi1sjQoOTYK8bK6EQ4GxMQRNzcjHjDURoKi0mSlEtM0vJSxhoMB8e/h1veDK8dmW5JjlZxY6aVXm4wJO8dPOxER3fCTWTD+MKEa41Sieut1cqxOUhtvIeXYQZMqlxwTwakH6gpN00xT/rj9tZDMJLHw7oU47K7DxNejWz+NnVVX4I63z8Vhdx2GhXcvRDKTrFhyrDO1EtujX8SrO5+T/tmyErHcs4hPvwOAqS01mNVai6zOsOK9Tlef7xQvg1NAXnJs9eZ9YMx4BozLeY0BEL5jHT3lVVh46TnG22jceo7t6DL9xgZy6sETARixh1sfGyeUx3PM3XlLpLOiYDJnQoN4vVKtlV4W5gBTPbY7Vvo1xNfahMaqQd/jrfy9yYzrjgInxEWSx7sW3ozORExdKtZhQJzZFTTl9/KZYNo6uHse/L/nDcXrJ4+YmucxOsYS5+plbBn33EJEUsHEqlzncN+xlyuQHPNSSaxpGk2sdAklx0YhIlnhQXAKmDejWKr0m9EOixl/oYpfRZJj3PPDg8lkANBQLafC8V5OOTbb0lZZyYmVyYx3rW7Noq2y9OB0V28STellCLM2/OCkmwatN26EWt62Su8S2IBlxLXLgGHT7sHKsYMmGknZdTt6y+/L47UPVAmtDZFgBFMbpyJQ5HEZQABtDW2IBCNoEROjypew0HUdO7V7kQ604+Z/XyfdY8KcGOUukVBIOQYAJxxoqMfK7TvmpS8PIG9a5au5lsrDcqoxDvcd21VGawLAVCl62cLrtlV0WxHlGGBs7vkjQsZ0RztkdYZ0Nmcs72Grm9tE7PpdfcjqDI3VYbG+AGtyrMzKMY8T2DJM+U37kMHJMX4PACpUCPYg1q2JBIV9gBtbh1gyIxL7vK0SQEVN+cvTVln6Wnt7Rw9WbtqHcFDDsmOm539+LpbWGdBVxrXmdZGJF4LdFOcYY4PaKgHgyBkt0DTg/d0xdJRZgZ30WHEnc1q2ilBybBTidTVNhsdMsbYGDk+OldOoNOGhAgowq7dufD/6UxmhsLC2VU7LJcc2V8BzTCRjPahw8GSCG+XYju4EqvX5OLr2Vzhp1kmDvi+UY7FKtFV66znmNjlWSDk2vaUW0VAA8XRWfL9c8AS2V/e2Usap89ZdHYWr5Dp00crLlQjlVI79+b2/IhV4DwCwpuNVPLXhKamfL6+tcnDlFoAwFH72nc6yJmPFNerBfQ2wKMdcKolX5iZVLpw+Ju/18fUVVo552FbpVjk2cBiQlUBAE39PuTYO+T6xXrRVyplWaTXjtxaZ+Iay3MU5r1u2xgqlrwvlWHdxlWIwoInEZVljXQ/VnZpmXj9uCsFcNdZcExYxGmB2TFSirTLpYaLHjENLjw3Wbuft9WOEcpgTDgbEWttbxuKcl232AFAXNT7XjVhjX39a+Apa44/GmjDm5jolXiqzeszLAS1AZQQofoKSY6MQr29G5nQy922VkwpU04DKZLW9vhnJmBi1YZcRMLTURkSLFmC0HwFGRbzck/BEwkLytChATlvlUJVbQE7FziletjUActZaIp3F9lxgb1WOhYIBYVT6dplN+c0EtjePpqYSk/J88ENQy//3DA4YADG2rrzKMcYYvvPMtwEWEMdz7TPXSlWP1UsySTeTYzV5rx8+vRl1VSFsj2bwg3Ub8ey+fciWYcLSaAhOUxkda9q7AAALp+crx8aJtkr/eY7FXKoURfwxTHGuIskxTwz5zWvUTUsV9xvj93+OX5VjMib8DRt/1DovyLglkfGuZQswk7FuCuhctW5VjQHA/rm2yvc6+io4iVd+/MHj0J5EpuQYfmdP8UQsIEcJ6ZSyDZ9ysdZ4Un9cfXTQvYS3VpY9OeZxdwklx9xBybFRiOdtlVXuA1S7yrHKeI55s+xl+H7wahn3XeCMr69CJBRAVmfY3lXuNhrvfKC40mZff7rkoJ6fD+tUVCuyvB6c4PWDzzQpLf134gFDfTSUl4gFrBMru0v+/FLwOmHRVOJa4OqxLMu/J2YHDIAot+fYUxuewmsdrwKaLo5n5faVUtVjZrGk9OdBIp0V49IHKsf+uHcPNi2qQscR1fjmri1Y8vrrmP7yy3is01sPMq+fBzxh4aZ1763t3UikdTTXhDGrdcAzgbdVlls55mH8URuVk+QZ7pkgS9VnF56siIQCYrqcTPhkVJ25U1isE5MqG/Je5wntrV3lVY55XQiWkUww11rh5FipBRk3eN0lISNhsXG34Sk2fUBybMbYWgQDGnqTGZEMKgeZrI5M7p7jRVKxUUKLrbmvKrzWZBSbneKlShGwDIBwUZxrz1k6tI2pGfQ9bsr/UpknVno5/AGQ53mqKpQcG4WYbQ0eBfVi8lHpFxWXmhcLGCqTHCuPcszNzehd4TeWX7kNBDS05TaV5ZxYqevMW8+xXLIiq7OS18LOYSq3lTXkH7ltldx4edrYmkE+bebEyjIrxzxOKjZxFaEDQ37O0llLMatxXp5Ky6oaA8xkrxslgl0YY7j2mWsRKKBmk6keM9vsS7+vccVJXTSUt0l4rLMT57z1FmLB/GPdlkzinLfe8jRB5vXzQMYzzuo3NvAaHVdfGeWYl22V9ZbhPf3p0pKx8VRWbA4nFynO8WRSuTYOZguvN8+DaCggppO5SVi8I5JjA5RjYyqjHPNy+AMAjBX3azdtlTz+KLzWKhJ/ZLyNP0w1cenXz0auHGvJT45FQ0GhZC+nKT9PYAPerLeQpe2x1ELtzu6hk/4ylJBOEV0SnqkU3dv8cKuatubB523h9DEIBjRs2dsvvCrLQbkGApFyrDQoOTYK8dpzjLcGdfaWHjBsE54fw1RufZQca5DQ6rY+FwzsP0A5Bpi+UJv3ls8HKmkNGDw4b5FQQDz8Sn2g89bAiUXWWnMJJuxu8drPSEbAUMhvjGMmx8o7sdLrahpfC90lrAVN03By2+V5Ki2ragwwPfTceNjY5akNT2Hl9pXQC6jZZKrHZCRirWb8/HxlGcPl69ejUAqPv3bF+vWetVh6PfyBJ2DcBKfcb+zwAX5jgKkc6yi3Ib+H8Uc0FEAwp6wq9d62wzopu3rwpGyg/PGH17GHpmlivZUaf+yLpbArF/MNTI7xOK6rP+3a18wJ/Br1auPt1iMyndXFOZtYRM3DCzJ+KgTXSYh1uefYjNbB8UclTPm5IhYw7kNe4LbFdvswooOWiijHvCueA3Lij6GUY/VVYRw8uRFAeVsrPR8+RckxV1BybBTitYy1td7dFCzGWN60ykJUtq3S282Qm+BRKMfG1w/63tTcjb2cyrF8I2GPAlSXD3RRuW0o5jlWSeWYt54fboJTPtzB6jfGmZObWLmjO+HKQNYpnlfTXK6FRu0wRPTZADBINQZYlQjenjOhGhtigqYs9ZiMRGwhM/4VXV3YmiyeRGQA2pNJrOjqKvnvHQqvzb75M643UVrLOGMMqzYZyrGBfmMAhCFzR0+yrN48Zvwh/7xZzb5L3QzxNrdJRSZlA2bLa7k9x7y6rwEW5XqJ8QdvqZzSXC3+DczPDoskT1nVFSlvY90xuWLG7hKLGbt6k2AMCAc1jK2NFnxPRdoqPY51ZcQfG3cbybHpBYpzlTDlF4W5UKDofcMtpdo6cESsO4LaKuMeF4JlJGILTaq0UgnfsaTHamK3e+zX27vwenuXa6/Z0Qolx0YhcY/9BMbVu1OOdfWnxQ1zZLZVeis1L/Um3p/KiE3k7HGDlWMiOVbGiZX83zESNCv6sjEf6KWtNyE1H6ZyW4ng1OtqWq+rtsriyrGGqjDacq005VSPeR3Uu92odPQk0ZRehkm1++HGE24cFESXy3MslU1hS/eWISdotve0I5V1fxzcByqWypbsA1XIjH9Hyt6x2X2fU5IeB/V86IzOgL4SfKA27o5hTyyFSCggKttWeBErldFd+Zo5xev4w31ybGi/U6AShvze+tsB7idWvlPEjJ9jTqwsX3JMtAd6tIFscdmGtiO31sY3VBX1kqtEW6XXiX+312h3f1okcAYa8gNm50Q52yqTGW8TsYCpXC9lLcRTWRG3jKS2Si+LJYDVh9K9rQNvDx8I9x17+f09ZSs0ed7J5PIZd8Of38aHb38Bz6zbJfOwRg2FNefEiMbrtkpTOVZasoJPimqpjRS98CuaHPN4gk9viTfxDbtiYMw4b9wo1kollWNetbkBZvW2lAd6MpPF7lwiYtKwhvyV8GHwKDiV4PlhKscGB6cAcOCEBrTvjWPtjh4cs9/Ykv8eJyQ9vrfxtVBqcmx7dwLV+nzce+YLWDJz3KDv8+u2L5lBIp31LPCJhqJYefFKdPZ34pWNe/DdP67F/uPrcMvHF4j3jKsdh2iosJrBCVYVSSyVEfc5J1jbKjkTI5Fib8/j/7P35+GVXNW9P/ytOpOmI6nVavWobvfg2eCxPYZgQ6dNLpfrYAi5hN+FkDBekoshvzjXJE24mOAECDgQgt9AeHEgyQ3BDC8hwbIBGwgGyzZt8Nzd7kHdUnerB41nrqr3jzp7Vx3pDDXs2ken9vo8Tz9g6Ug6Ku2qvfZa3/VdXl/nl6iD065UAumkjlLFxGyuzJXFXnms6jd26aaBum1lXakEBntSmMmVcWK+gIEe/3+XIEQdfwx0p3BsJh9YsXrMR3JMVlJRhnKMqeGCFueeP1Hfb4yxaVU3fnlslt/LMihErBxjFiJnF0swTcv3sATW5tYo9gDcPpdyYl3TtFCqRN0lEW4g0MFqYW4km+HJDzesrXL/SXtiZVRKLjf5UrQTPgF3/OH/2cZUYz3pBL/+S2FtwkELzUGIvEsi5ARj07Rw7CzzHKuvHLtqyyokdQ3HZvKYOJPH5jrdFKIpRHyPhj1jH2sx/CHukHKsA4laXbGmavQbVDk2NdN83DDQpuRYxA+jsMqxfdWWyh11VGMAsGW1oxyTVd2I+iAEuNoqA6htTszaazST1HkQuhQWkORKBq8ORo0sf7ugrW6liskPOfXaKgHgog3yTfmjVneGMeQHnAC10WGovyvJjbGjbm0YHRjFFeuvwKa+i5GxdmBd90W4Yv0V/N+m/k1Cfo7b7DuoUqBeW+XLBgexKZNBo2OPBmA0k8HLBgcD/cxWyFDzhJmK+PMjzIx/ud8YY20bTPmjtnUY6Q9n68CVYw1U60D4qrpfoo7ZACCbCeej1mhSJYPduzJN+aOOP5jSpmJage7R4y3a3IBwCZEgRO0TC4RXjh1iLZV1VGOAXbBL6hoWihWegIyaqIcYAE78EaSt0j3krFGykBeaJU3LBqJ/toXtkjg5X0TJMJHQtYadTL2ZJC7eIHdCe9STeMOcsQ3T4jFFs3N8nKHkWAcS9U014lKOBUnCTLaYHgg4N26hbEpJWJQNE0a1JSiq68YUFXMBExYvcDP+RpVbO4kxX6xIaxGUEdQPhfBpYmutmb9MtisJVhAOYsQeBJaIjS44dTw/gtyjx2byMC37/TGl6FLaYcofteeYOzj1e91q2hoaHIY0TXOZ8ssJUKNuc6vxgQr4bKvXVpnQNPz1jh32z1j6M6v/e/eOHUhEpBpwDkPRPdvCBKhM2Xn+uvrFEsBJJJ2Yk6cU4D5QEV03J+EXsDg3u/KKc3I9x/zfo6Zp4YVqcqxRWyW7d6Uqx5ghf0TXLZ10JgieCvC8Zv52jdrcAHBFp7yYLXqf2DBrDXD8xrY1SI6lkzpvt5TlOybjHg2nHGv9XGuHIX/kbfYhp2UzM/71A11IJhqnPFiiXIaa2LKsyAvBYYbOTM8XUTEtJHSNT8VWDUqOdSBRm5SG9TKZ9KAcy3Ylwc48MgJUd8AQVYsgV44F/H3YZJ5z60yqBOy/N0tcymqtjDoRC4Tb0JmSZ10DM34A0HUttBGqXwqSAoaKadVUir3i+I31NEwqXlRNju07Oc/bNKKGJ2Mjam1g66BUMfnP8sqkawpetk4rCIMFWacktTZEnYgF3L4f/veDQtnghtdL2xpuXbMGX7v4YmzM1CZoN2Uy+NrFF+PWNWsCvmNv7wuI7uANOArPYPtoc5UiAB64ylKOWZYVuZpnrSjlWJP4o78ruKIvCFF7ZwGOGi6Icv3YTB6LJQOphFbXAwqIp3IMcFrhg0wYnvJQCJZtyM+uWSqhReYT21e9f4IWSw62UI4B8idWRp3kAVyeY4sBlGMzrWNdNg3zbK4kzzurEu09Glal2MqMn5GVuCeUDBPMvjWq+MNdAPK7FiZd56qoniErHUqOdSBRqyu6Uk5P+/SC/wB10kOvsq5r/IApY5w6OwhrWnQ+UGGraftO2sqxc0fqV24Bp7XysOTkWJRS8zATdqZamPEzBkMYoQYhaol+TyrBk8tBDkOHTznJsUawqWXzAxo+feAIHjp7FkaEAZdlWc51i8rcNZ1AsrrZ+22tdAY/NFYpAi7fD0nKsah9eYBwASo7TGczSe6L5ObWNWtw6Npr8VerNmP4yQKuO6jj4LXXRpoYA1xDMyQox/zucaZpOX5GTZI8PJEkKTnmDuq7ImurDK4csyyLe6VsbJYci2NbZYhplaylcvuaPqQaqCsc5Zj85FiU8UcYU353q1sjZLdVRu2tC7gtRILdP6w41ygRCzhFYlmm/I7tSpRtlcH9bydd8Ucj2FouG1aoYU1+cJKK0Z6rgiZi2QCR0QZm/Et/TtDzmx/chdmolWNlwyloeYWd4Zs91+IOJcc6EBnVNG7KHyBAdappzR9GTG4uUzkW5Zjm/hDTovIlg8t/GynHAGB0iE2MkpMcizoRC4SbsMP97VqstXYFqFHdo7quhUpYHGphxg8A3zh1Ci/+SgYnru7GH00dwk1PPolzfvpTfH16OtibbkHJMMFyb1G2CPIA1Wf11mvAwEyeT8tSjkk4QIYJUFkb1sZVjZOKCU3DywYG0TtlIH3KiKyV0o2M6xY0CXN6sYRSxYSmAeuarLe11URS0OE5fimUovcz4r9TgITfmcUSitXrtnag8TCKMC0nQZBzjwZXjj1XbZ1nrfT1YMqx2XxZmuIu6gEtgFPMCJMca5bAZoW5xZIhRYHNE7ERFkuyIWIPy7JwcLp1cky2ckxGl0SYgUDHud9p4/2gK5VAT/XvLqs4V4zcQiTctGx2rmqlHHOUt9E/29hzTdOAdJNWzzD0uAvBPtebF9/wuEPJsQ4k6tG5gNOuMR1Aau6lrRKQ6/shZVpUNTgtVkzfQdCB6QVYlp0oGq4zqZKxZcgOJg5XK29RI6PizTyagkzY4W2VLRIWq0IYoQYhaq8UwAlQg2zmh3lbZf3g9OvT03j9008jv0Toc6xYxOuffjqSBJn74B1l1TuoKf+Uh8lkgEuJIMtzTMKzTYRybFOr4DTE4T4IMhQWQQ352XNtJJtpqOQBHOWYrLZKttaSutb0fYVhbQgfNRZ7rOnL1J3wyeCTHYuVQAcuv8iJP4LvB8+1mFQJ2K3VrJB19Iwc9RgvBEeY6AnaVlmqmLxdvFnBpL8rxVXeQQfB+EGG2q4vRLHk9GIJ88UKNM2ZwF6P86pF4n0nF6Tco0UJ92iYDgYWf7SKdcMUm4MQdTtq75Jp2X7hbZVN1hoQfqCaH9z2IVGJNTRNC3zGnvQwaCTuUHKsA4naEBdwTYzyGaAapoXjfMpFi1a3bvshLic5Fv2Y5j7XeGW/Aeq/PvXvmMy8G/0DzzZ93ebV9sFclueYDJXiUJ/TVum3N96p3LZqqwwuZw/CSg9QD3Pl2PKAwbAsvHf/fljAMqd09te5bf9+4S2WrKVS18CnI0bBqoAGyV4TsWw9BzF4DoKMBHYYzzFWuXVPqqyHOziV4Zci47oFDk49+GYB4VoQgyBjP2DKsemFIh+i4xXWUtms9QhwErGWJeswJMOQP7ga7vnjrZNjgNt3TJatQ7XIFGHcNhywmHFirgDLss3jWUKiHrruOqRKKM4VpbRVBi9ksEmVGwa6m94PW1b3IpXQkCsZ/L6OEhlFJuYJNhNgIJAXlSIg35Q/6sE2Yadls+Jc67ZKecox7tMWYdIfEBB/tCgExxlKjnUgMh7ia/qCmeKenC/A8DjlQmbAIONhlNA19Fa/v5+gwbIs/P0vP4qyPoEXCn/XdNPcXFWOHTktJzgtSvT8KBuW783P8fxo1VbZnolRUR4ig464rhgmT1hsqdPW8KOZGRwtNj5sWwAmikX8aGbG189thfuaRVVNA4CB7mCtDV4TscMhlJBBkJGwCNdWyZRj3pJjJcMMNGTCL1H7AgJOEsZvcHrMo/raaassSEkocpVAlEqe3jQ0zS60+W1NZgnsjS3u0a5UgnuPymgRlJGI7Q+ofChWDG6Q3mhSJUO2KX/Uw6cAt9LG31pzt9m32q+4Kb+MQrCEKbxcSVzyr7x88VTrlkoASCV0bBtm6rHoWytl3KMsDi0ZJnIl7z5QuVKF7yFelWPS4o+IPcfCTMsuGybfE1q2VUpVjkU/oAUIbuvgNREbZyg51oHIOAwx5di0Ty8T1tbgZcqFc+PKexhFZcbPCFJRGzswhmOLTwEApvJPY+zAWMPXMhn61FwBxYo/k8UgyAhOa3wSfFS7CmWDv76VD5TjMyXJh0GKAXOwiVFTswWUDQvppI71dSYfTZW8XSOvr/OKjKQ/EKKtcsZbIjaMh00QZCVibzi0F29866uABx/09bVe2yp700mwLUNOwiL69RbU22rSg6k84BSxyoYlpWU8X7afNVGutWRC59YCfpXrfire7bF1iN7fzu+9c/h0DoZpIZtJNp2EB8g35ZdxiGRtlX6Vvl7M+Bky4w8Zg0ZYIcOy/Le6HeKTKpvvB4BcU34Z92h3KoF0dS376WJg56q+TJIXXBox1Ms8T6Nfa6ZrWnqk8UdXsELw5EwepmWf+5iPdiNktlXKmIwKhFeOkSE/0VHImE7GVF9+jX69TKpkyA1Oo09WAP4nRlmWhT0/2AN2K+paAnt+sKehCmC4L42edAKWJSdAZVXIKNsaAMeo1M+GzqYHdqcSfC21+v4yDpCGaaFkRL/e+gJ6zLBJUZuHeqDXSWCvTzduEQnyOq/IukeDqgiZD0OrZ5vjYSN5OlmEQX1vOoHbH74XwxMvAh/4AOBDpXTMY1ule8iEVN+PSBMW9u8TvK2h+Vpzt3TJ8B3Ll6I/CAGuKZw+lete/U4Buab8fBKelAmC/u4d1iI5OtTTUgElv61ShudYsDY0rx6UgLsgIyGBXT0fZCJ8roVpdTvIlWONB08xmCn/CxJM+WUU5zRNCxR/HPeRiJU5Ldut8I5WqRisEMwmVW5qMgyIIbetMnpPYiDYHlcoG7xQ0Ko4F2coOdaByJxW6Vc55nVSJRC/yi3gf8T12IExjE+OA7AflqZlYHxyvKF6TNM0rh6T4TvGD0MR98YH2dDdppGtNj4nIJFRuXUUfZFWbwP6QB1q4jcGAC8bHMSmTGap3RhHAzCayeBlg4O+fm4ruLoz4nt0MMDk0oVihR8613k05D+1UJTT6iYhqD//F4/g0uP77P8YHwfGGqtb3eRLTqDVqq0BCOeb5BcpJulczeO/4g14S/KMZOWZ8vO1FvF+sDYbzEvtmI/rFrTlJAgyBwLlSgYqhve2ZPcBshXsHp6Q1VYpIdYdDmjIP+XDtFrmtGwZbZWapgX2HXOSYx6UYyN2Au3AdPQDqGT4EgPuQq3/WLdVSyXgbquUG+tG2iURMNZ1J/5b/gwubJDpQRltrBvkjM0SsV0pnSf1VYSSYx2IDIUFC7j9K8f8V25lBKeyWrb8HIaYakzXat9TooV6jCfHJPiO8UAr4oAhyIbutLn5aGuQnByLso03qOfY4VPNJ1UmNA1/vWMHgGV+/Py/796xAwnBvmAy2gMB98QoPwGDHZxmu5L8ujeCJXqLFROLPnxFghL5wduycPXffwoVrbqWEwlgzx5P6rFjM/YzKptJchVVM5xx6tEGqO52kJVoyO/Vcwxw+45F7zHjJCuiDR2dQQN+lWPe2lGB+BXnagcCeb9//Bwg22XIH+20bEdV7iepyC1EfBSCZXieylJgB1H5mqbFhwF5UY6xIv2shLityFWKURfn/McfLNb1olKUOa2S7QfphN7SRicMfPiUz1iXeet6Kcz1u5RjURc1ZUzKBoLtcU6HRGu1XZyh5FiHYVmWHEN+tinlyzWH/VYEaauUoRKQMcEH8Oc5xlRjplV7fY0W6jGZyjGnhTfaR0WQDZ1NRfWiUlzVKy845QFDUq/btiiKoJ5jrZRjAHDrmjX42sUXY2Om1qdhUyaDr118MW5ds8bnu22NDHUF4JqS62MtTPoITnvSSZ7gk9HakI/aY2ZsDKuf/QWSVvXgaBie1WNMYbLRQ1sDIM/3Q1Y7SBBD/mLFwKmqisVbcoz5c0WvHCtImJQNOL+TH+VYqWJiunrdvKh5BgJ6dAVBxrMtldD538Vfcsy7cmxj9TXzhUrkSUVZse5gjz0AAgDO+EjCMOVYq9Zn+2dINOSXlMD22yUBACfmC8iXDSR0zdN665PpAyUp/giiIjw+512lKHNapSwFVG9AQ34/qli2nsuGFflAIOZJHHVHDnvu+HlW+0nExhlKjnUY7ps2yhtroDvFjSNP+ZCb+/FhaIfnWNQPI68BA1eNNbgFdegN1WNbqkmNwzKVYxEHDKsDTNjxYxrJA5K8jKoQk+dH+3j1EzhOzE7giakn8MTUE/jlyZ+jqO1HUTvAP3Z07uiyr7l1zRocuvZa7NyvYfjJAu5efQ4OXnttJIkxQI4HFBDMkN9PCw3gqMdOSZgYFakHpWUBe/bASiz53h7VY17N+Bn9Pj0bg1LTDhLhfTrAppNVTM9FJndbwyoPbQ1r+4O1IAaBK8eibqtkajgfCb8TcwVYll2UYPtJM9hak+t5GvV0Mv/3j597tCed5Nc2avVYbQI7uuuW0DUM9fhPKBz3OCkbkNxWKSnJ0xeg1Y21VI6u6kYq0fpvGlQdHwRZah5nOIP/4pyXWFdmW6WshGKQtQa4lGMeVLG96SRPkkcef0iYlA0Esw7wI3CJM77/Mj/84Q/xmte8Bhs2bICmafjmN79Z83nLsvDBD34Q69evR3d3N3bt2oV9+/a1/L6f/exncc4556CrqwvXXHMNHn30Ub9vTQnyJTlBvaZpfBKWn3YNnrBYcYb8sj3Hmj/ES0YJR2aPwET9CoUJExNzEygZrg1uYgJ44glcOLUfFx/fj8wv9gJPPOH8O7o8wREWWVNVgkzYmfIRnLKEiGFakXsKyDARBrz7MBQrRez8/E5c+XdX4sq/uxKP5t6B41234e337+If2/n5nShWlt/nCU3DOZU0eqcM7LAywlsp3cgLTv23NfgJTgG5pvyRBlpjY8D4ODRjSWLHo3rsqEczfka/JFNcds2Suoakh0NaUPrcEzg97nNu3ywvarugLYhBcNoqW7fIhoH7qPkw5D/maqn0ct3aE3/IUa77S475u0ed1spofcdk+RkBrgnDHp/XhbLBYxUvh8jBgENggiBvrflX8zh+Y/UtHZb9jIxTXIh6OjtPYEcct63i8Uc0idjVPJaWUJiTLDrwnRyrKse8tFXKHAjEz1Ursq3S+1qLM74jnMXFRVx66aX43d/9Xdx6663LPv+xj30Mn/70p3Hvvfdi69at2LNnD26++WY888wz6Oqqv4n8y7/8C97//vfjnnvuwTXXXIO7774bN998M55//nmMjIz4/61ijLvHO8qgHrBbK4/N5D2b8tcEDH58GHwoOIIia+qi18NdJpnB+NvHMZ2bxl/8+7P40f5TeNvLtuK1l2/irxnpHUEmWW1rKxaBnTuBEydwFYDvsBd90vVN160DDh0ClrTChUGWf0UQKThPjnkITjPJBHrSCeRKBmZypZbTLcMgrXLrMThNJ9LYPLAZ04vTdZOxOnSM9o8inaivtnD8HuSoeaIOTlnldjZnqwi9HKT9DBoBnPXs1+Q5CJElsKuqMeg6YNZJ4uu6/fndu4EG19BPyxYgr61S1nNN123j6tl8GbP5Mk9kNYMlYr1OinISSfLWWtRt9o5yzH9hzmvFm/uD5iWoUiQpsP3ePwvFCi8SbPScHOvBk0dnI0+OsVg3ldA8qYzCYCcUFjx3SbjVnV5iiUGJ07LlTWb37w95qJocO8djcszto7dYNCKN37kKKmLFfxAVoddJ2YBjIVIom8iVKuhJR1fIkFXQZCrfsz7OB/YwIPt+Hh3yXpybL1SkxR+yplWScsw/vp8Cv/7rv46PfOQjeO1rX7vsc5Zl4e6778af/umf4pZbbsFLX/pS/MM//AMmJyeXKczcfPKTn8Tb3/52vPWtb8VFF12Ee+65Bz09PfjiF7/Y8GuKxSLm5uZq/qlAXpICCvBvys+SFd2phKcpF+zGLZQlVoUkBadeAu7RgVFcsf4KFPJbkLF24Fe2XI0r1l/B/23qdxJlSKeBzZvtA2k9dB0YHbVfJxAZ06KAgIb8s97bKgH3lKCokzxyph7xg1CLapqmabjzpjubqhTvvOnOhkkiWQmLvLRpUdVqtGEi59Ewf8rHKHXAlRyT6vsh+LqVSsCRI/UTY4D98YkJ+3UN8NtWKWtapSwlMeDf24oHpx4TsUFaEIMia2jGSNVz7NRC0bNJut/rJndapZxnW7/PhMWx6v050J3iX9uKTdWD5kTEnqeyrhkADPlUjvFkxYA3leIgW2tS2yojtnUI0PJ4iJvxe0uOJXQNPWnmoydrT4g4YeFTue5nUjZg/13S1WRy1Mp1WQXNTXxKrvdnDlPEZjNJz8Vw5/wWj7bKIL7eUy5DfpUR+pc5ePAgjh8/jl27dvGPDQwM4JprrsEjjzxS92tKpRIef/zxmq/RdR27du1q+DUAcNddd2FgYID/Gx0dFfeLrGDyUfrLLIGZ8k97DLqnXC2VXs2X2cuiDlClt1X6UNmwILOp9FfTgDvvbH5QvfPOhgqOoMi6bn6D03zJ4C0KXtU8gwHk7EGQFTA4EvDWa2339t3YuWEndCyfjLpzw07s3r7bw8+R044a9VrrTiV48OjVIJl7KXoMGKS2VUZlyJ/J2K2Tjz8OPP447vw/X8ar33I3vvOlf+Mfw/h4U6XqMb9tld2y11r0+yj7nbzucX6sCQDHvH56vgjTjNZPUVaxZHVvBgldg2l5TzD7mfAJtMuQX0784fUw5Lel0n5tT/VrI1aOleTsowAwzIsZ/pRjXu9Rt+dp1OQlqXmCGPIfPl1VjjWYlF0PWfEH87iL+mzlVznmZ1I2YBdDZfmOyVLbMc8w1ibpBZZI2zTU43nqojzluqRErKsA5NVr2bEQoeSYMI4fPw4AWLt2bc3H165dyz+3lFOnTsEwDF9fAwB33HEHZmdn+b+JiYmQ774zkFW5BYCRrL3xT3uUmh/zMUYdqLacZORk6mUZR/qt3LrbGlpKf3fvtlsr65lj79xpf14wstab37ZKVt3oTSe45LoVskxxZQUMfnwYHPXY8smozVRj9s/x3z4RBFmtR5qmOdVbD+vNsiye+F/nUTk23OfvsBUUw7RQMiKcVjk6ClxxBXDFFTAvvxxPr9uBX6zZxj+GTZsafqnd1mBfXy+eH4DbMykebZWA/9aGSZ+J2OG+DDQNqJiWr2l7QZCVsEjojuepVy81322VASaJBqW4Qlvd/LY9u18btSG/zC4JVszwHn/4O0Cy/SZXMmLTJeHV1oFhmhYfIuUrORbQb8ovsloEV/lUjvmZlM3gybHIC8FyEopsCNnkbN7z/eP4jXm/btI8TyWpYlnsUTacyb/NmCuU+X1GbZUdSiaTQX9/f80/FZCV5AGc1gavvh9+W48AJ2iIOkAtRqWuWIL/4NQOFgZ7UvxrG8LUY/XMsSNQjQHyAi22mefLRs3QiUawtbZuwJtKEXApx3xMCQqCvGlR9u+zUKh4qgrt3r4ba9IXAZb92PeiGgPcSbh43KOAE6B6ee7MFSpYrK5JrwHqUK8/JWRQZJpWj/pUjBybcdoamHqqFVnJ0yqltlV69Laa9FlkSiV0bsIctSm/LOUY4CjivE7h9NsOEqTlJAjuBHbkxbluf2oeRznmLXkNOIfNY2fzkU5+Lkpca3y6sNe2Sh+TsgH7GcgGc8xGbOvAkgdR+wL6jXVPzBdQrJhI6pqvgzf7OX6M/4MgKxnr+M/5KwR7LcwBzno+E3H8IUuluLo3jZ50ApbltIK3gnfkeJhUyZClHOPPtojv0Z50Asnqg8dLrMuea4M9qUi96joBoX+ZdevWAQBOnDhR8/ETJ07wzy1leHgYiUTC19eojNS2ymo1zatyLEivsqyJUfKnVXr7ffxMUwHA1WNm1XvM1PXIVGOA3FHN3CfBg9rGb5sbIE85VqjISsQmccOhvfiPv3sXyvc3nxoI2IqpTcnfATT7/XlRjQHBx2j7xTGWjz5hMdjN1kLr+5S10Az2pDw/d3lbpaS2BgDIRKxU9KsYmagGsRtXefPlAfwrb4MiSyUA+FMoWZblUkB5f7at9VnICopU5bqPKZyWZfFDk9frxhJJc3lvxYWg1Cawo71H+31OqwyiHNs4aMcq88VKpMMMZCZi+YQ/z7GuP+WYrmvSTPllPdu8TstmHDrltPD6GSaWzfi3KgmCrKImK8zNFyqe/BSdWNd7ckxWW6WT5Ile7b+5muQ67NHrkD3b/CjHspKnZUvpkvBxxp4KoFKMK0J36q1bt2LdunX43ve+xz82NzeHn/3sZ7juuuvqfk06ncaVV15Z8zWmaeJ73/tew69RGVkHb8C/cuxYgBtLWnJM8rQor21BrLrhOTitqsf0qveYHpHXGENWUtGvT8KUz8ot4F/OHpSipGvWk9Jx+8P34tzTE9D+5E/s6YJNME0LC7MXI22eCwCeVGOARB8GSfco4M9/btLnpEpA3rRKdn9mkjp0PZpnAMOL19DE7ASemHoCT0w9gR8fHkdR24+uniP8Y0fnjjb9GUF8bIIgc635USjN5st8SISfZ9taH4mkMOQlHYYAd8Kv9e8URN3J/i4lw+QK6SioSY5J84Hy21bpXV3RnU7wtnE/Btl+kTXRDXCUNl6LGX59AQHHlF+arYO0yajentXMb2yLj5ZKwFWcizD+sCxLWpeE2xzeiwfdVAAPqCFJA4FkFjQ3c98xr8W54MqxqG0d+HWTUJzjZ2wP5x4/U1Hjjm/d3MLCAvbv38//++DBg9i7dy+GhoawefNm3HbbbfjIRz6Cc889F1u3bsWePXuwYcMG/MZv/Ab/mle+8pV47Wtfi9///d8HALz//e/HW97yFlx11VW4+uqrcffdd2NxcRFvfetbw/+GMaNQkhfUM0P+Uwu20W+rw9dUgIq3nxs3DDzQijw4rQbcFROFstHy7xTkAY7du3Hy/Jdg5Plf4sj2i7E5ItWYaVqOSamE9TbUm8bxuYKnDX2St1V6X2t+5exByUu6R7UHHsClx/cBAFJPPA6MjQE339zw9VNzBZQqFobxFvSP/CM++sqPelL0yDfkl5cc81NN85OsGHZ52Hh5dgalIDFZsbGawD+9WMJisYLeJebAxUoROz+/EycWXSrwLuBbU8C3/s7+z3V963DovYeQSdY38Zc3rZIdhKIP6v1MRWS+ncN9aV/3AZss7bUFMSiynm2A43nqZVo2S1YM9aY93wt91VY307KVVlHdQ6ygmZaQwParvAxiyA/YMd6phRKmZgu4ZOOAvzfpEbnKMX9t8Mfn/BeC2Z4TtSm/k1RcWdMqD3G/MR+xLhzPMT9TMf3C4lwg+j0hmdDR35XEXKGCmVyJxwqNmJpzLES84nj4Rlyck1hkYr5jzLeuFY7wwE9yTJZyXc49CviLP4Ko1uOK77/MY489hssvvxyXX345ADuxdfnll+ODH/wgAOD222/HH/zBH+Ad73gHdu7ciYWFBXz3u99FV5dzYx84cACnTp3i//1bv/Vb+MQnPoEPfvCDuOyyy7B3715897vfXWbST8g1KXUb/bZKKLjbQfxU0xzlWDwm4bmnyXh5wAYxjYSm4cn/+cfYt3oU973u3ZGpxmoDBnnVWy8+Ccf5KHUfyrFeVrmNgSrFsoA9e2Bo9nq2Eglgz56m6rGD03bl9vxVN+DZ9zyDXdt2NXytG2lSc4km6azF1osh/9RsAJVida1VTCtS/6x8SY6xK2A/q9nwC5bEcZNOpLF5YDP0BmGFDh2j/aNIJ9INfwZrdVsoyml1k6FK8Rec+m8XB1wtiPNRK8fkFUscz7HWv5NfM37AViv7+dsExWlziz5m8+PZ5x4GtNFncozFbVHuCe0w5F8oVmqUfnXfl2tStp+ExaAsWwdJSUW/hvxBlWNZnz8nCDK9OwFgVa/3FlsuOvClHPM3YCIoPP6QcM2YcuyIB+XYbL7M1V9+Ev/SPE/boFz3Vwim5JjvXefGG2+EZVnL/n3pS18CYAccH/7wh3H8+HEUCgU8+OCDOO+882q+x6FDh/ChD32o5mO///u/j8OHD6NYLOJnP/sZrrnmmsC/VJxhLRfdqejN8lIJHUPVDb1V9TZIWwPg7+AQBllS84RrAqeXwPGoa9ywHxZfdiN+7W2fw2PnXun/TXokLzlg8NVWOeu/msZ8pqJWjklJ8oyNAePjSFj2z9IMAxgftz/egIPV4HRr0OA0as8xmSbpPqr4QfztMskEv25RtjYUKvKUY4CjcK3nO+ZMRK3fombCbOlxx5QvpgW+n0SBrGlRgKut0sN+4NfomyHdc0zCenM8x7wrx/wG9TJsHWQqYv0oH5hHm530bjEMaAm9VbPmxSjVPBKVY/1dSaQS9nOpVfwxGWBSNuBuq4xHkcmvSpErx4b9xbpZCcp1ds2SuoaUDz+0oAz6Ks75j3VltVXy+ENGcqwatx7xoBw7eMqOdddkM8sU7s3ol5D0B1butOxjAYpMcaVjp1WqCjtA9kg6DLHWyukWyTEWnK7yYVoNyPMckzVKHfDu+2FZljNRxYf0F5Djw8CC+nRCRyLidhDA34YeRP7L2xoiDk4jT/JUVWNILFnLLdRjh6oBw9bhYMkxWRN8ZCQs/BjyB1GOAU5rZZQTK2W2uQFuU/76vmO7t+/Gzg07kdBq34/XyaiZpM4PqVG2VjpJHgltDdX7x4s6ejLAUBsAWMtbECNWjpXkHYb8/E6szd7rhE+GjImVMg9CfqZVHuWWDv5VAjJa3WQOn9I0zWXK3/x5zdUVg94HjQCQb8gvYYgSYMc7rYzlLcsK7jkmoTgnq3jOWOUxFp0vlPnv7Sdhwbswok6OtcFz7MiZXEtV+Qsn5gEA5470+foZ0qdVrjDP0yCF4LhCybEOQ2blFnCSY62UY1MBTKsB+dMqZTyMvFZvz+bKXB3h1/NDbsAg5zHBfBJaVdMWixUumfZnyC9LORZxoFVVjcFYoqxpoR5j1bRzfCbHWBCcKxkwzChb3aotWxKebU5w6mX4g//KLSDHlF9WuzijlSk/U48ZVu3a9DoZVdM0KRMreVuDTOWYj7ZKv0ke2Yb8Mg6RTA13aqGEcovDd5C2SsDfJNGgyBrQArg9+1rfO9yMf9BfYQ6QVJyrsGEjcmJdVpw71cKnKWixxPG5lBV/RGwh4lLNtTIwn14oIlcyoGsBYt2MhP1A8j7qNRZlyYqB7hR60t4VULwLI8LCHCBXObZxsBu6Zu9B0y1iqv0nFwAA563N+voZ/bKGT8nskvB4xjZNK/CzLY5QcqzDkK0UGPFYvT0W0CtFRuUWkPsw8jrFh6nGRrIZ33/PPp9jtIMge62t8qgcYwFDXybJDwOevn81IMmVDBQr0bVsFaP05WGqMb3BOtb1huoxphzb5jc55gqCZRyGVlJbpWVZjprHZ+LfOWxFqByTmPQHnINNs4lRu7fvxoWrLwcs++/oVTXGkDGxUuZgG3/JsYDKsX5H4R1lAlvmtMpVPWmuIvSqXF+J8YfMhCI73NkTOJvvcUHN+AHnHo2yrZL5GckqBPOJla2UY7P+B7QA3tVCYagYJirV+z/qPSGV0LGumpR/cXqh6WuZifqGwW7fyU7H1iEerc+Ae1p2898paJs9s8OZL1YijXXZGUGGd2c6qXPxRauJlVw5ttavckxOW6XMPcFrcuzUYhFlw4KuOcU2laHkWIch+zDkta1yKmDlVppyrLLy2ioDTaqsIqNyW5TsZ+R1wk7Q6ka2y55OBkQboEaquCuVgCNHALOBksI0gYkJ+3UuKobJjUz9KscyyQTSVTPp+QgDVB5oSVAKrPJojjybL3NFm2/lGJtYGWH1VnZQ30o5Btjqr1dveS+g2dfNq2qMwdUvUSbH2jCtcr5YaZm4CprkWd2X4ZMXo1IqGqaFksTpxbqu8eJcK0Vc0EEGrA0xyoFAMtsqe9NJPp+nVfzBlWMBkmO9PicVBiEvsc0ecE8YjqhLQoJyvSB5iNKF621lzrNTc01fd5hPqvQXewCuFt4IY135bZXe4o/jAROxA90pboVydjH6fVTWedTrxMp9J+xk7bkj/pRj7rNbtAOB5HuetioEsw6JkWyXFN+9lQ5dgQ7DSY7J+dONeGyrDFu5jTI5VjZMfiiR8TDyergLNKmyCgsYFiNsdZM5CQ/wPmGHV259rjVd11y+Hx2asMhk7NbJxx8HHn8c1mOP4Q3v+Axe/Za7cfC7D9sfHx+3X+fi6Nk8KqaFTNKp9vohK0GpKDPR4/afaxYEsUP36t607/c1zJQIEY5Tlx2cMn+ieob8bpLly5E2zwUAX6oxwO2bJEOlKEPN46hbm1Wky4bJk0B+i0wJXeOHey8G9kFwK5FkF+eaxR8Vw8TxuWDtqFKnVUpKKLLCWcv4gyvHVmhxTqIvIOBug29hyD8T7B6VYcifdw0xyUiYjnrRhn4AwDNT801f5/iN+V9rMmKPosRiCeCoCFvFoZMhYl32M6KMP2QnFb1MrFwsVrixvH/PMWfKOIutRGNZltQuCa97XFBrgrhCybEOg21+fvrPw+DZkD9EhQOINjh1T13MSGyrbOXDcFSAcgwAFkvRBA08qJekHPNqyM8NcQMkebicPdJqWsQBw+gocMUVwBVXQLvySpiXXYGn1+3AL9Zutz++adOyL+GTKod7oQcYriDDqJRVvWUoFZkhf8W0mk5FZCoBv6oxwPthKwyyg1OWfDibKzc9rLxwYgGD5bdgU9+5+OgrP+rLuDqbYcWF6BOxstpBWDKp2T53Yq4A0wJSCQ3DvZmGr2sEa4WIypS/Zh+VcPAG3FM4G/9OJ6utpElXgtArfiaJBsXxt5Nzzbx69nHlWABDfhkTjGV3SQxVixmnWjyvHTWPv+vmqIWijz0ySd3XMzcoF65nybHmyrFDIZRjLGEhY/iUrLXmdTjDcaZSDBDr+pn+HhTZ121zNbnabGLlvqrf2HBfhlu1eKU3neDdJVHtCSXD5K4nMuIPr2fsoInYuELJsQ6D+0BJSliMeG2rrD7Eg06LypcN3rIhGvYA1zQ5Qb3XccATZ5lyzH9yzD3VLaqgwWlrkFu5nS9Umq4F3tYQoMLhVc4ehrzENhoAOLdqOsqk5PVgfmNBglPANQAiorVmulq2ZKy37nSCPwuaDYCYDHgQAoChPmYoHh9D/mxXiieYG6nHLMvCC8fn0W1ehgfe9Bh2bdvl82dUiwsyJghKerZ5CVCnXGstSAKbJZKiUo7lXZPJgry/IDiDBhr/Tu4Ett+pyjIM+WW2VQLePPvmC2WepPEbswFOcS5KzzGZCWwAPCHdSmkzGdKQfyZCQ37ZVhgsOfb88bmmHQxhlGNSJqOu0LbKoF0SgOTkmCR1pxfl2L6q39h5Pv3GANsSImrfMbcibSVNq2TKsSD7QRyh5FiHIbuaNsKq0U0qt6ZpOdU0nzeW21A9qgC16OrvllFN86qyOXomuCGupmmRm/LLnoxa45PQJGgIaogLuOXsEqaTSTp4syCAmZDWI+ikSoaj5okoYHCZxso2xW2asAghNR/2qIQMg+z9AHCeV0fP1PcdOzaTx3yxgqSuYduw/wDVKS5IUApIfLYBzacIhm1rGIl4YqVslQDgbQpn0GFAgBzluuwEdr+HiZWs7WiwJ+VrqA1DpueYrPXmxZB/oVjhzyW/sS7bbwrl1sMSgiLTywiwi23dqQQKZROHqgmwpViWFSr+YHFuqWJGZi7Prpusyah+Dfk3BFKuV5O9kXqeyr1uW4bs9XO4WXLsJPMb8x97AN47f4LCzge6Bi5wiJIBV5zbzEKEJlXWQsmxDkN2gMraKhdLRsMq4akF15SLrL+2hoSu8QlLUQWo7VBXAM0rD6Zp8baGIG2VgEvNE3FyTFagVeOT0GRDD2qIC0Cq55isgzcbV82CgnocDDipkhH9WpNrJAx4G6cetIUGcBnyR1m5lTxRFgA2DTJT/voB6vPH7STt9jV9fJCDH6RMq6zIPUQ6xu+Nf6djAX07GWs9TpYOSjsSsUy5fqKJcp1NLgtygOyXMK2yKFmV4nj2Nf6dWGI7SGEOkOM5JluB7eV5zYol2a5kjbWFF/oySV78i6q1MtJhQHVI6BrOX2fHH89M1m+tnMmVeUJxc0gLkajWm+yYjbX7zeRKDRMWlmXxQnAQWwemHIsy1pU5vRhw1s/0fLHGX8/NPj6p0p8ZPyPrsS09KG6VogyxBisAlQ2rxhphKWGKTHGEkmMdRl6yjLUvk0RP9cHXqLWSBfVr+7uQDDDlYsCDgiMMstsaWEDfbKLKyfkiSoaJhK4FztT3pqMNULnZt6SND/AmBWcBQxCFhTNOPT4+UGxc9aHTiw0r0qyqG1g5FrHnGHvf6YTuuzUqKAMeDJKDttAAjhLhbK6EihFVy7j8e9Qx5a+vHHuumhxjhya/OANNIlSOSU4qelEohW1riLqtMifZ0gFw+ag1UY49OTEDwGnx8oPXlpMwyN4PvBzuWGKbJbr9/wwZJumSlWO9zHOs2DBhwdrsNwQolmia5pjyR9RaKXt6MeCY8jeaWMlij3X9XYHeV0LX0Ft95kRWnJPsC8ji0LLR2PN0rlDhz9xAtg4SlOuy19tAT4o/sxu1Vr5wQoxyLOq2SlnXrDed4DG1py6JAGstjlByrMNgD8vulBxDfsBlyt/AO4d5ZwVN8kQdoMqcTAYAV21ZBcA+JJ5ueM3sB/v6gWAJRSD6AFV2FRJwb+j1r5u7rWFdKOWYDD8jSerOvgwGe1KwLGB/HfVYsWLgWPUePWc44GEoYqWA4y8jb60NekiUhmvhTUPTAMuKbr3JPngDznS7iRbKsaDJsX4pyjHJrW4ejN8nQ1ZuvQ7PCUo7lGOt2ioty8Jjh88CAK46Z8j393cM+aNs4W2P51iztcbN+EMqx3JRTsuWPa2yWswoVsyGCYvjIQa0ANEPBJK91gAnKd0oOcaKxEH8xhh9URfnJBdLulMJrqpu5HnKOiRW9aQCFb/Yej4TUVulaVooVuROywaa+465J1WeF1A51i+pECwrEatpWsviXKli8vM9Tau0oeRYh8Ee4jKVAkwJdbJBRXr84BkAwEs3DQb6/lH7frgn+MhgdV8G51cfzD+rXpulsFaQIGb8jKhbG9pRhWQ+CY2UY2HaGoDoDflrxjRLCuo1TcN5I6y1crnv2MSZHEzLXi9rfE5zY0RtUtqOJE+r6WHutoYgCYuErvGfEdU4ddkt44DLc6yBcowlxy4IqRyT4TkmrdXNg/E7U44FLTKxBFxk6opSO5Jj9vPqbK5c12/oxVOLOLNYQjqp45KN/pVj/a4CU3TqzvZ4jjVTjIRNjvVKnJYty8+oJ53ka7tRUdNJYAdNjtn7wWxEyrF2FDQvWl9tq2yhHAs6DAhwYt3IEhYSJ2UDdszmdDHU3xOclspg92jUhvzFitsKQ956Y8mxw3U87vbzSZVp35MqGVy5HrnNj7x9lJ+xG6y1E3MFWJZ9Rh4KeN3iBiXHOoz2+H409zL5yYFTAIDrtq8O9P2jTo7l2+DLw64FuzZLmTjD/MaCS1j72CEycuXYymmrnArR1gBEb8jvHtMs87qdy035lyvHDp6qjlEf7gnscRD1xCin4i1vSxrg08Pqr4UziyU+QXNtgFHqgNOqE1X1tj2G/MxzbHlyrFQxcWDaXoNhlWNSplVKWm9e1NFh2ypZm33UXikyC3MD3SmusKiniHv8kK0au2zTYKAkCksoAtGpx2T727Ek4SMHTjd8zdEZNgwoWHFOyrTsNhSCuSl/CzVPkDY3AC0TImFpx8H7/HX90DS7nbteUpErxwKq1gEn1o3eX1de/NHK83SKJWIDFktadWGExe1fJevZBgCbVzdWjjlm/MFiD0CCcqy6H8iawgs4+1yjM7a7MCfDB60ToORYB1E2TFSqEnaZh6Fm7Ron5go4ML0ITQOu3RouORZZwNAG6S9LjjUKUFlL0spWjsm/bq18EqZCtzVEa1JaKLmqaRIDBm7KX2di5cFTdsAQpnLLW3gjnuAjc621DE6ridjhvkwgY3nAOWydiqp624Y2GqY2mc2Xl7VuvXhqARXTQjaTDJzkkTmtUpYqpVVwOl8o8+SM3yl4DHaPNhqcE5Z2JGI1TXNM+eso18cP2crsq85ZFej7pxI69zOKi1LgV85dg1RCw8FTi3hxuv6QFq4cC1ickzMtW/6zjZnyNxoIFKbNHgAGuqO1dXAmZcu7Zn2ZJLZU1TzPTi2PP0QoxxyFZ7QFdJkJC2diZYtEbECVYqsujLBwn9ikDl2STyzQvK2Sxb9sgnsQou6ScIbqSbQQaZUcmw03DCiOUHKsg6jJ1Etq2QKc5NjJOskxlvy5ZMMAV2L4pdXBISztaD26dutqaBpwYHqxrpkwb6sMOKkScB2GIm5rkHndWvkkPHTo+5jMvBul5N5A339Vb9SJWPuaJXRNyphmhhflWNBJlUD0bQ3tUCkOtpCa8zHqITwYnMNWfHygejNJnsQ+tkQ9xloqz1uXDVyB9OKZFAbLcnmlSFKltFJHs0P3QHcqULs44LS65ctGJC2C7VDyAM1N+R2/sWDJMSB+8UdfJolrqoXK7z93ctnn5wtlvv8FVY4BznqLIjlmmBZKhvzi3DArzjV4Xk+FmF4MuHwuIzPklz+gBWjuOybEc0xWW+UKsnUIu9Z4rJsvR+IL2I7YAwBPxB6pM/DshWpybEdAvzFA3vCptrRVNlSOhVtrcYSSYx0E8/zQNXuqmyyaKcdY2+D1AVsqgejbKmWPUgfslq2LqgHDIy8uV4+xym2otsqoA4Y2bH7N2ioty8I3X/wEyvoE/nP6bxpOlGqG23PMjCBgcMvzZcqTmXJs4mxu2YjrQ6fCTaoEoh/+IHuIAeClchtOJQA4bZWNlAhhaUdSEXDUYxNLqrfPhfQbA5zKba4UTZKn1itFbnKsUevesZnwldvejPO7NDIUD0M79gPAPYWzNjl2aqGIg9Vn25Wb/ZvxMwY8DEsIQzvUnTddMAKgfnKMrbVVPcETsUC0ynX31OX2DARa/rwuG6bTfhSwYMLbKiMy5G+H5xgAHusuTY7NFco8ltuykj3H2lGca6lcD+dByWJdeyCQ+PjDsauRu9aYoODo2fyypB9rqzwv4KRKIPpp2e1MjjVSRzuWDmTGz6DkWAfBJlX2pJNSD94jzZRj1cRPUL8xQIYhv/zgFACu22Zfk58uSY6VDZNvfGHaKqOs3AJOoCVTat7MJ2HswBiOF54GAEws/BJjB8Z8f3+WEDGtaAKtdiUrhvsyGOpN151YeVBIckyO1FzutMpqorSFmidMNY21NkQ1Tr0d6k6gsSl/WDN+wEnEAtE829zJY1keM6181EQEp5lkghfNIrlubXq2Mc/TE0vij8eqfmPnr80GVq0D3oYlhKEdCYtXVpNjjx48s+yZffQMM+MPHnsA0RZM2uVnxJS+p+oox360bxq5koHVvWne2uWXAb7nRLsfyGoXZzDl2FJTfqbuGe7LhEvERl6ck3+PejfkD7YnpBI6P1tF0VrJBqTILpZsGOxGUtdQMkwcdxVMFosVHo+cK0Q5FvV5VKK/rkflelBLhzhCybEOot3B6fQSQ/6JMzlMnMkjqWvYGWCMOsOLWXEY2nWAbOQ7NjVTgFmdDMJUeUHI8spt1L3x7Z9WaVkW/vT7fwr2yNK1BPb8YI9v9VgmmUBPteUgimpauxKxAHDuCGutdHw/8iWDBxAi2iojC07bEGixRGmjtsqwlVvAZfAcUVslv0clt9E0MuVnybHz1/mfHMhIJXS+DubyEahSqmstqWtISlJgs+RNK0PcsJ4fTD0Whe9YvtSeli3WVrlUOfZY1W/syhAtlYDMtkp51+2c4V5sG+5FxbTwo321Q4GOnmVm/OHWWpR7gluVItPPaLivsXL9vsePAQD+22UbkAr43IjekL898ceFG+zn/f6TCzVTZR2/sbCJ2Kohf4zUPM08Ty3LchnyhynORadcZ/uB7LWW0DX+7HK3VrJBQMN96VATF6W1VUpMYLduqyTPsaVQcqyDcKZFyf2zsQTO6cVSTZsLS/pcOjpYM9rbL5FPq2xTNe3qrUNI6BoOnc7xhw/gmPFvXNUdSgEYdTXtyOLPMJl5N54585+RfP96sE1tqU/C2IExPDb1GAB7/ZmWgfHJ8UDqsVZG7GFoVyIWcForXzjpJMdYcDrYk+JKqSA4PlDRTiZrR3A6ky/XTbKy4DRMNW24xfSzsLSjHRVwK8ec4HSuUOYtW+eHqNwC0fqOteMA6S4A1Vtrojw/otwT2uUxw9oql9o6ML+xnSGTY87fJtrEv+xD5CsatFZyM/6QybHeCNsq3V0SMnGKGbXP69lcGQ88ewIA8LorNgX+/oPdzX2mwtKOIhNgT1Qc6E6hYlo1ynXHbyx4YQ5wCsFRq3naUZyrN5xhNl/mz9ugyjGg9fT3MLQjocjYXF1PR84s8o8xv90dIVoqAXdbZbRrTWZHjufkWIi1FjcoOdZBMM8x2RvfUG8aCV2DZdUe8kT4jQHy2iplV7yzXSlcsnEAQK16jJvxh2xriNKHwbIsPL14D8r6BL701EcD+XsFgVVWLcv2BWPvZc8P9kBb8rhKBFSPDUZYvW2XuhNwJvTsc5nys5bKrSFUYwCQzdjXrFQxayrDomA+UO2Qmhumhfk6yQQ+wSdUcBqdIb9lWa6Cidz1xp5dEy7l2AtV1dj6ga5QbW5AtBMr25HAZq17FdOqe1ARMfwBAHrT0ftAyY4/eFulSzmWLxl46tgsAOCqLcFV6wDQ321fs8htHSQnsFly7KHnT9b4azrJsZXfVik/1q3fVvlvv5xEqWLi/LVZXLwhuCo2ckP+NvlAaZqGC9fbBZFnJp3WSu53GlI5FnUhON8GWwe3/+1SWJvbUG86VCzpJMfExx/t8rcDgM1Vr2b3xMp9J9mkynCFuYHuqIc/yH+2NVNHLxQroSdlxxFKjnUQ7QoYErrG5bmsemtZFn5yILzfGCAhOVaRL2NlMN8xtyk/U46FMeMHnIAhimmVYwfGMGc8DwB47szeQAqtICTr+CSMHRjD+OQ4LNSacxsB1WNRKsfaMfyBwXwWWGsb4EqOhazc9rl8oBaL0Zl9y7xuXakED+yWGiSbpoWD849gMvNu7J97JPDPGOxNoTCk40BvBQ+dPQtDYJK5bFhcXdkuQ363cuw53lIZLjgFolaOyVcS96QT2L7Gvgc/8p1nl32eJWI3hgxO+QTjKFvdpLdVMkN+54C3d2IGFdPC2v5MaAVU9MW59hwirzpnCNlMEqcWSvhFNZEIAEdnVn5bZa4a08hO+q9uYMj/9SfslsrXXbkxlNrfrRaKouDYLpUi4J5Y6cQfXDkWsjgXR0N+Nk2yXhwqwtIBcCkhI1SOyT6PAsCWIXs9HXa1VbKi8LmClGMLxUo092gb9oNme9xUtTDX35UM5QsYNyg51kHk2jRKHQBG+pkpv13RODC9iJPzRaSTOq7YLKatIV82UKqIn07Wzla3er5jE2fCm/EDbs8xsQEDU2qF9fcKijtAdd5L/YBUh+77vTWTs4elHfJ8BquYHZvJ88OxiEmVgJ0gZ15tUbQ2tCvQWtXAIHl6oYBTiXtR1ifwiZ9+KNDa//r0NG7a/0ucuLobRy9K4aYnn8Q5P/0pvj49LeS9F1wKPtnPto3Vg/V8ocIDrueFJseiVI7JVylqmoaPvf6l0DXgGz8/hv/fk5P8c4Zp4XhVKRDec6x6iIyRmmek6jk2my/z58Tjh22/savOGQo9nKg/4jaadkyrBIB0UsfLzhsGUNtaKUo51pdxDpGiyfO2SvmDbQC7MMfUdgdPLeLxw2eha8BvXLYx1Pdn1galismfQyJpx7ONUW9ipTjPMTnTsuW2VVZjjzqTSw+ctK9b2Db7uLZVsomVE3WUY2HM+AFnrRmmxc/cImnntMoTc0UeazAmBcUecYOSYx1Eu4JTwGltOFmt3j5Sbam8asuq0Dc5OwgB0VRv2xWcAvb1Seoajs3k+YPcUY6FCxjc0ypFJq6YUkuEv1cQ3Bt6ySjh4MxhAPV/PxMmJuYmUDK8b/7N5OxhaafUfKg3zT2u2EhrUW2VQLRGpe2YjAo4QcPSFtuvP/3vKOn7AACPTz3me+1/fXoar3/6aUyWatfYsWIRr3/6aSEJMtZCo2vgUwpl0ZNO8iQ2U4+JmFTJ6I9wYhRva5B88L5yyxB+/xXnAgD+5Bu/5P5spxaKKBsWErrGJ0MHhVV+I1GOtSn+6O9K8ucpiz/Gq5Mqd24JV5gDoh0IZJgWSkb74o+bzme+Y7Zf1nyhzJ91G0N7jtm/TxQtvO1rq7SfaYZp8WTpN544CgB42blreKI2KL3pBFIJO5kbRWtlOxMW7omVlmUhV6rwCfdM6RMUaSbpbfA8nS9WUHZ5OT/4zAl8/H67a+PSTQOhfsZQhNOy21kI3lJNth6unqlypQoXHYRtq+xOJZCoDgGJS3Fu+0gvNg52Y6FYwa1/+5/Y7/IlJjP++lByrINo12QyAFjTV2uKy9oEw/qNAbYqhW1+USTH2qkc680kcdnoIABHPSZKOcZa3cqGxT2bwsKUWgmtdo0F9fcKwpBLOZZJZvA7O/4J6wp341VrvoTH3/H4sn/jbx9HJun9ULmqp7GcPSyFNiV5GNyUvzqxklVuRSTHomxtaFfFe1VPGjcc2ovLXnUD8OCDKFYM/NPPDuP2B/4EsOz34nftG5aF9+7fXzedyz522/79oVss3cbyYdUzQXBaK/OwLAvPHbcVA+evDe7Jw+CmuBGYpPPW5za02f/BK3bg0tFBzBcq+MOv7oVhWjxJtq6/K/T0zL4ITdKd+EO+nxGfWDlfgGFaeKJqxn9ViCnZjCiTY+yaAe2JP248fwSaBjx1bA4n5gpcNbaqJxW6hSZKNU+7uiTSSZ0n5k8t2Oqx+6otlbdeEU41BthreaBqyn+2jmIoLO30PD13bR+SuobZfBlTswXe8jbYkwrtQRmlShFoX6sb27ZZwvo7v5jCu77yOEqGiV+/ZB3e+fLtoX4GK2CdjSA51q6CJuAIC2ZyZczmy3wIxOrecJMqAfsezUZZnGvDPZpJJvB/33Ettg33YnK2gNff8wger+6hrK0ybAtv3KDkWAfRjoluDKetsgjTtHiiJ6zfGCNK3492BgyAc41+cuAU8iWDm72G9RzrdU1yEhU0MNWYYdXKiYP6ewWB+SScWShhoVjBd/dWkLF24I9e8Spcsf6KZf829fubHjXIPcfi1VYJOMmxfSfmMVco41R16lbYtkoA6OuKLkBtV1vlYHcStz98L/oP7sP0H/whXv6XP8D7vnUvFqznAc3+W/pd+z+amcHRYmMDXAvARLGIH83MhHrv7VQSA8AmV2vD8bkC5goVJHQN20fCr7UolWPt3A9SCR13/9Zl6Ekn8NMXz+ALP3qRV25FBKdcTRyBD2U744+1LlP+F07MY75YQW86IUalGGHsUZMca0Mydk02g5duGgQA/OC5k8JaKgFXwiIK5Vib2ioBYHWfM0Tl0UNncGwmj2wmiZsvXifk+0dpyt+OSbyMTDLBJwU+MzmHw9XCXNhJlYArERvBWqsYJirVFlqZe2lC13hL90yuhG/8/Cj+4J+fQMW0cMtlG/CZN16OdDLcEV1GW2U74o++TJJ3SUycyTl+Y2vD+Y0xopzOXmhTcW50qAdfe/f1uHR0EDO5Mt70hZ/i+8+dwLEZaqusByXHOoj2tlU6yrHnjs/jbK6MnnSCB15hkVG9bVtyzGXKz1qQspkk/52DktA19KbFtTYw1Zje4LEQxN8rCO4JO//62ATmixVsW9OLG88bEfL9mRFq3NoqASc4eOHEAvcbW5PNCDHajLTVrU1B/c4XHsOlx+32yTXP/QLnPvkTLGb+MdRk1KmSt3Xl9XWNaHfS360cY2b824Z7hRjdRzutsn2+PICt4vzgf70IAPCJsefx4DN2y5uI4DRK5Vhb4w9WnJsr4rFDtt/Y5ZtXhVbaAdEW5gpVRXc6qUPX5as7AeCVF7DWypM8/ghrxg+42iojbeGVbxDt9jz9erWl8r+8ZL2w5+yqCKdlO6rY9jzbLnT5jh2qKsfC+o0BTpdEyRA/Lbvg6rqQvZeytfD5H72I93/1SZgW8IarNuGTb7hMyLNtqMGACRG0O9Zl6rEjZ3J4gfmNjYQvlgDR+lDy+KMNif+h3jT++e3X4Mbz16BQNvH2f3gcD79g+1GGnZQdNyg51kG0s5q2JusY8v+k6jd29dYhpAR53UQaoLaxmgYAV2xZhXRCx4m5In64z752m4Z6hLRCiRxxXTJKODJ7BCbqt2gG8fcKAvNJmF4o4ov/eRAA8Ls3bBV2uODKsQjaGtrZsgXUKsdETapkRDmdrC2tz5aFX//qZ1HR7J9paDo+uvdLWLReCDUZdX3am6zf6+sa0c52ccBRnxw9mxdqxg9ImlbZpv0AAH5r5yh+7aK1KBsWvrnXNucXmRyLSrDLZwAAiJ9JREFUwnOsnbYOzPP0xHyB+41ddU54vzEA6O92VAKiCz+FNicrAOAV1eTYj/efwovT9p4gIjkmp61S/nVjyvWjZ3P4918eBwC87kp/6vRmsLbKKJJj7bxHAeDC9fbz/9njYpVj7i4J0QWTvMt0PSP5PmWx6FcfOwrLAv6fazfjL259Kfe8CsuQq61S/LOtvV0SW6rJscOnc9hfVY6dJ1g5FklxrtLePaEnncTn33wVXnfFJhimxbtLNoQc/hA3aG5nB9HOyu0aZsg/X+QtlSL8xhjRVm/b+zDqSiVw+eZB/OzgGfzrYxMAgFEBwSlgH4ZOoCgkQM0kMxh/+zimc9M4ejaHd375cfSmE/jqu67nrxnpHfHl7xUEVrn9/nMnUSibGOxJ4XVXiAtOozTkb3dwel61cjY5W8BTx2YBAOcMh6/cAhEHDO1IKo6NYf0LT/H/TFgmRvcdxKsOaPjujuWBJFNO7t6+u2li+2WDg9iUyeBYsVjXd0wDsCmTwcsGB0O9/Xyb15qjHMuhr6oiYcqBsES71qrFkjYlsAHb1+QvX/dS7J34Iffx3CigcusUS8RP2WKHyHbEH2tdyjHmlbJTgN8Y4MQehmlhsWQIHWffbtU6AFy8oR9r+zM4MVfEv/3CTsQKbauMZFql/T170m1QjlXbKv/v+AQWihWMDnXjKgGDHxirImyrbLea+KL1toH8M5NzfNKiCOUY65JYLBlYKFT4VFERuItMsr07V7m82N72K1vxJ6++UOh7YMmximlhLl8J7f3mpt3Pts11lGM7BCnHnGnZ8RNrALa9wyd+86VYk83gnocPAAg/IC5ukHKsg+CeH22p3DqeYz87aLc1XL99WNj3jzI51s5plQzmO8baj0QEp4DLB0rQIXJ0YBRXrL8C2wZegoy1A0PpC0L5ewVhqNc2Sf/2596JGw7txZuu2Sw0AeAY8sdv4xvoSfF7dazarrV1WEw1jR2GIq2myXq2WRawZw+QqP15FQ34P9+36g5H9aqcTGga/nrHDgB2IswN+++7d+xAImQQ3G6V4midtsrzQ06KYvRHGpy2V3HHGOpN4+Ovfyn/bxHKMWeCsdjrZllWW4tzzJB/78QMjs3kkdA1PugmLN0pZ4KgaFuHdu8HgJ2IZVMr2Z4X1u8UcCViY9bCO1xNKDCV3a2XbxLaEjsYYVtluxP/TDl2+EwOz1eHAolQjgFOwkJ0Mpa1abbjHr20+gz7/Zt2CE+MAfbvxKxXTi829kENAt9H21Sc21xdV88fn+Neih2hHFsBBRPA3hf+969fgL/57ctx160vIc+xJZByrINor3LMPnCXKiZKFRMD3SlhKgEg6rbK9j+Mrt8+jLsf3Mf/W0RwCoArNkQHDOyataOFd6gnhdsfvhfnnp7AH//wXqz9/7xf6PdnUvZ82UChbAhdF3yCTxvbaM5bm8XJ+SKfFrVVsHJM9MEbaENQPzYGjI8v+3DSAq6eBF44/zOYv/H6ZZ/3qpy8dc0afO3ii/He/ftrzPk3ZTK4e8cO3LpmTbj3j5WgHLPX1UKxwqejimurZJ4f0SVi29UO4ubG80fwp6++ED85cFpIsSnL2yrFKsdKhomqZ3V7inNV5RhrFb9ofT9PBIZF02xj7NOLJczmy0IPCcUVkoh9xQUj+L/jE/y/hSjH0rU+UCK8BhntmlYJYNm0OxFTKt0MRqRctyzLVWRqz3pb3ZfBSDaDk/NFbgIvQjkGVJOxc1G0VbYvofjeV56L/+faLUKVcEvJdqVsxZ3gM0K+zS3jTDm2d2IGlmXft6sFXUcVinOM//rSDe1+CyuSlfHXITzRzukgXakEN+QGgGu3DQnriwfkTIxq58Po0tGBmp8/Kko5Vj0gzAve+JzgVH7+fP2jP+Qm6S+d2oe1P/2h0O/f35Xka1d09XYlJGKXTuwRMakSiLaa5kzCk3CPMtWY3uBn6TrO/dQ/4Ip1l4eajHrrmjU4dO21eI8xjOEnC3jjXD8OXnutkMQY4Arq27TWulIJHtSblv0sEuFlBCDSUeorQUns5m0v24Yv/s5OIYmA3oh8AQslx4Ovncoxhii/MUZUxblCG1Upbm7YMYy0yx92oxCVovM7iU7GtrM45z5g7zxnlTDlE2MwIuV6yTDBbKXaud4u2uAUzbOZ5LJkY1B4rCt4T+DFkjasNU3TIk2MAWJ9id2020JkSzXpyoo2546IUY0BaijHiOZQcqyDaLdSgKnHAGcCoyiiCk7b3Q7CyCQTuGqL45Eiqr87qnHqPDkmO6FoWVh1153cJN1KJOxEhkAzUU3TMNjNAlSx1Vs2+aida+28Ja1t5whra4iujUZqa0OpBBw5Apj1B0/ANIGJCft1IUloGi7P9KJ3ysDwoha6ldLNSgiy3Mmw89b2CWsLYcWSKJRjUhOxkolqaAbbQ5O6JmwIjx+WJce2iPEbY/RHNC273QlsRm8miWu22ddsqDctRHWXTOh8n4su/mhHcsxJ5twq0OuUMVg15J8VXZhzJbDb6afo7ijZMixm8BQQ3QCIwgpQ+0dJb0Rq4nybW3jX9GVq/mZLi8Jh4AOBohwQ18Z7lGhNPJ8GMaWdAQPgTIwCgOt3iPMbA6JLjpUNi1cW2jmdDHB8xwAx06KA6Frd8uU2GeKOjUF/7DEkLXsD0QzDbn8baz0l0A9O9VZwcqzU/oTFeWv7kNf3YjLzbvRknxb2XiL1HJM5+SiTsdfU4483/jc+br9OAFG1PjtJ//Zt45tWdfO1lul7Rtj3Zc+1UsXkhxdRrBQ1TxTw5Jjo1qM2F5j6MknunQOIV45FpVxfCQlsxiurUytFDQMColOltLOtkhnJZ5I6/stL1gv//lEZ8rPnmq6Be+i1g5rkmEDVXVTJsfwKiNmixIk/xD7bim0Wa+i6xlsrgeVF4TA4bZVi19pKaH0mvEGeYx1Evo0BA+Aox4b70kIlrICTHBNuiFtxDlbtVgr8yo5hfPz+57FhoEuYX0pfRFWhtgSnbpN0w/X7MPXY7t2AoCqkPbFyUXxbJT94t2+tbV/Th5nUvSjrEzihfQmW9UdCqrdcah7BdDLph8jRUfufBKKa6lZcAQfvjYPdfK397PTfwLLeJmSt9aWT0DT7kTBfqAj9HblSIIaHIZasyJcNGKYlzPqgncOAGGv7u/DiqUVsHupZpiQLy0BESsV2T8p284ado3jh5AJedfE6Yd+zL5PE9LyYadlu2tlWuXW4F3/+2kuwYbCbrwuRDETUVum2XZE9ddHNRa7kmCi/McDdVin6HmXqzvbfo1HgqIlFK8faH+tuHurBvpMLAIBzBU2qBNzTKsWutZXS+ky0Jp5Pg5jSTs8xAFg3YAek125bLXzzjczzo3rNNA01nhvt4NLRQfz1f78Mn/nty4V9z76IeuPZYUhqcMpM0o0lm3gE6jFmiitcObYCWnh/NvkDlHTbs+1M+VmMHRBz3foi8oEqGyYqVXlnHANU5s2zGJlyrH1rbcYc52vt4NwvhK01Xdei85jhbQ3xXWuA2GTsSlhrrDh31RaxqjEA3E9VfPyxMtoqAVsF/tHXvgS/ep4Yz0PAffAWe92cLon21O/fdM0WPuFTNCz2mM2VYQm0i1gpa23rcC/fx0Uqx6JSrq+EmC1KeiNSE68EVexmV/I1krZK0bHHCml9JloTv+gwxuTb/DB60zWb8eqXrsdtu84T/r2jSo4VXf3d7aymMW65bCOuFOiXEnVwKi055sEkXaT32EBPEoUhHQ/mZvHQ2bMwBH3ffJtVKZZlYc8P9kCrPto16Njzgz1CgvBsVGbfrra5dgf2URC1D1S7rpllWfjWwU8Blr3WElpC2FoDnNYG4WqeFRDUR0UmmeAtVSKTsfk2WzoAziTUl58vLrnDiEy5vgLUFVESlZqn3V0SUcLaKkuGyeMsEbR7P2AkdA1Xb7UtRC7dNCjs+/ZFZCES5/0AcE8wjl87KmurHOpNCx1sEJUh/0ppfSZaE88dO6a0O2DYsroXn/3tK7BDcEsl4HhA5UoGSpUGRtkBUCU4jczzQ1blVqJJ+tenp/GF1XM4cXU3vqSdwU1PPolzfvpTfH16OvT3dqq37VlvYwfGMD45Dgv2+7BgYnxyXIiixy01j6LiDcTTFJcF9aKD03YrBcYOjOH5M3sBzX4fhmUIW2tAdBMrV8LQjCjpi+AwxA/ebUxW3PHrF+Jf33UdXhPB6PmokmMrofU5SpxnWzQtW+1oq4ya7lSCdzHMCFxvTrt4+/fQz/725Xjw/b/KE9oi6I9oIFDck2ORTTBeAfvoSzcNAACu2Dwo9Ps6sW50idiVINYgGkOeYx1EnAMG9jACbPWYezJmGFZKNS0qojJglu75wUzSmyWoRkZCm6R/fXoar3/6aSZ24RwrFvH6p5/G1y6+GLeuCa5MaKdEn6nGEloChuUcVpiiZ/f23aE2ZHYQMkwLhbIpLEnvTmDHMWDoTUekrmijIX/Uaw2IzhQ37gmL3kwSZ3Nlod6APPZo4zXrTiew8xyxUyoZkRnyV1ZGq1tURKdct9duHBPYmqZhsCeFk/NFzORK2DgoZkDCSmoPzHalamJ6EURVCG53kSlqohiaYZgWFzG087pduWUI33zPDdgqsH0XcCViixWYpgVdkHdn3NdanKDkWIdQNkyUDVutsRI2P9EkdA3ZriTmCxWhyTGpU/DaQF9EJuk8OJWZiI3YJN2wLLx3/37U0zxZADQAt+3fj1uGh5EIeLBvZxWSqcaW4lb03Lzj5sDfvzedcEzSi+UIkmPxvEeZAqpYMVExTCQFeR+2M8kT9VoDohunvhKMhKMkCuVYIcZtbkB0tg4rofUoSqIozpnV4gsQ3/XmJMdEKsfiffDu4z5QUSnHaD/wStE16KzdZ6vLRgeFf0+W2DUtYLFUEZboXUkJbKI58XwaxJC4+/IA0QSocZ5MBkSz8QHutsr4XLcfzczgaLHY8PMWgIliET+amQn0/Q3T4gls2fcoU/LoDR7pugDvMU3TIvGYKbh8AeOIezKtyPYjrhyTfICUsdaACH0/Yp6MjSJhsRIM+aPE8bcjzzE/RFGcc08Yj2OXBAAMdtum/GKTYzFfaxF1ScS9u4Qp14UOaHF55cXRCqMrpXNPMLGx7sppfSaaQ3+hDoE9wDUtng8jIBrfj7gHDNmIfBjaMq0yYqY8+pV5fd1S3Als2YfIklHCkdkjMFHfs82EiYm5CZSMcJ5t7BApcr2xw1BcVQKphI509Zk9L7D9qF2qFGlrrTsq34/2+gJGTRRtNHE/QEY2LbsS78R/FMU5t0l9XK8b89gVOS2bx7oxvWZMvSPcX7dasOqNafwRxX7AnmuZpC6s5XAloWlajceuKPIxv0fjBLVVdghsBGx3jI38IlGOqRKclgwYpoWEoI0qF8M2mvXptNDXLSVfbl81LZPMYPzt45jONfZsG+kdQSYZrl05GuWYgby+F+P5z+PBF7+AXdt2CfveK4VsJonTlZJQ5Vi72mhkrbVsxG00mZjuCVEYMDvDgOKZUHQKc6RS9EMUPlBO0j+eB2/ASY5F0SXRzqEZUZKNIMkDADnurxvP43AkSuKYt4sD9no7s1gSWpyLe2EuTsTzaRBDcmX7wRYnJc9SomyrjOvDqKZlq1Thyp6wxDFgeNngIDZlMjhWLNb1HdMAbMpk8LLBwUDfn621dJuqaaMDoxgdiM6zDXAHqOLu0VyxgpnUvSiZh/GB730Ar9z6ytgVAHozSZxeLAm9bu30r5Cz1sS3ulmWheIKMBKOkmwUnmNxb6vstq9ZvmxPy04LKm7EPf6IoliSj2HssZRVPaytUpxyLB9zewJnrZVhWZawGCFXjPfZKhIPypjvB0A0tg7Mqy2usUeciOeOHUNUyNRHmxyL53XLJJ3eeLGVofgFDAlNw1/v2AHAToS5Yf99944dIcz44z38AYjGFPeRyR+gpO8DAG7mHjcchYVI5Vi8D95RTKtkiTEgXqpYN6xgEsW0yrg+25ZOyxZFURGTdJFqnjj6nS5lgLdVUiHYKyxZUTasmud4WNh668nEMxkbhZI47msNALIZ8cW5uJ9H40R8V3bMiHtwCkSbHIvrdXObpEfhMRO3A+Sta9bgaxdfjA1LWic3ZTL42sUX49Y1awJ/bxUCBtESfcuy8JVn/hKw7GuW0BJCzNxXGlFUb+O+J0QxrbJmsE1MvTt7o1hrpXi3bLFp2YDgw1Al3ntCNJ5jbZiULRkn8R/FWovndet1KQnFJmOrheCYXjd3O6qouCruk1GBaJRj1FbZOdBfqEMoxDRZ4aY/kuRY1Tgyxg/xSAyYY2jIz7h1zRocuvZarH00j+EnC/j6eRfi4LXXhkqMAWpUhUSblI4dGMOB2V8Amn2fGpYRS/VYb8ZeE0IHGcQ8QI0yOE3qGpKJeIY/TltlBJNRY7rWACdhITL+iLviPwo/o0I5vrEHI4qCZjHmynVd1yJZb45yLJ7XjRVLTMvZ/8IS9wEtgHMeJeWYmsQzOowh+VK8D0IAeY4FpS8jfoJg3FsbkrqONYs6eqcMXJbuC9xK6aYQc88PQKznmGVZ2PODPdCWbENxVI/1CZ60ZVlW7ANUPq1S5ITPmF8zwNVWGUHCIq77ARDRtOyYq3lYYU5kC2/cYw8gmjZ79yCDuBKFxx1PjsXU486tiBO1l6qwH0SrHIvvdYsL8X2KxgwVKrfRJMfi/zDKCq5Cug/ecVYqcsWdoM0v7tOiALFrbezAGMYnx2GhtpoZR/VYH1OOCbpHVfDO6udtleSV4gf2XIukhTemaw1wTPkjiT9iWjBxD38QVcyI46TspTixByVi/cATFiIHAlXbKntjut7cijtRauK8AvtoNoLWZ37dYrofxIlIVvb8/Dxuu+02bNmyBd3d3bj++usxPj7e8PUPPfQQNE1b9u/48eNRvL2OJI4G6UuJtHIb44eR+CSPCRbnxrWaBog3KnU2vvgGDKIM+ZlqTG+wBenQY6UeE+3No4J3Vr9LbSfOK8W+bpk47weCE7FA/NsDgYjij5gfIt0tW/mymIM3tVUGgz/bYnyPio51AWAx5ob8gGPrICr+KKpQLIlEORbv/SBORPI0eNvb3oannnoKX/7yl7FhwwZ85Stfwa5du/DMM89g48aNDb/u+eefR39/P//vkZGRKN5eR0LKsWCo8DASPZ2MVdKAeK830QGqCn4CrJoWNjgtGSUcmT0CE/U9MEyYmJibQMkoIZPMhPpZK4GoErGpRIy9s6przTAt5EoGv4ZhUMEQl7XZi1WOxdvPCHAlx0ROR425cr0nnYCmAZZl7wkiimlOW2V8kxWilTyAItOyBe+jFcNEqarCjqshP2BftxMoCkv0qKCAiqKtsqiAujMuCN998vk87rvvPnzrW9/Cr/7qrwIAPvShD+Hb3/42Pve5z+EjH/lIw68dGRnB4OCg6LcUC7jnWIwz9ZFOq4zxdRNtUsqC00xSR0IP78W1UnECLUE+DBV1gtOwUvNMMoPxt49jOjeNj9//HB56fhpve9lWvPbyTfw1I70jsUiMAVEkYuN96AbsBFZS11AxLcwVymKSYwoEp0wlINIHSoV9VLQhv2FaKBnxvk/ZtOz5QgXzxQpElLOdtsoYJ7BdQ5RM04IuIM5So9VNbMIi51I7xtWQH4hCuR7/82gUbZUqFOfigvDkWKVSgWEY6Orqqvl4d3c3fvzjHzf92ssuuwzFYhGXXHIJPvShD+GGG25o+NpisYhiscj/e25uLtwbX+GopBzLlQyUDRMpAYqIuHt+AE7AsFgSWxWKc1sDIN4Ut6CAIW6/wMmoowOjGB0YRa9mImMN4KLhl+CK9ZtDf9+ViOjgVIU2N03T0N+dwpnFEuYLFawfCP89iwrso9kolGMKmKTz4lxOzGGIqQSAeO8J2WpyTHTLeJwtHfpcif7FUoUfxMNQVEHNkxE72IY91xK6hnRMFdhAlBYiMV5rEXqexnkfjQvCnwbZbBbXXXcd7rzzTkxOTsIwDHzlK1/BI488gqmpqbpfs379etxzzz247777cN9992F0dBQ33ngjnnjiiYY/56677sLAwAD/Nzo6KvpXWVGocFOx6WSAuOqt48MQ341P9ASffMyn9zB6BSvuVGir7ItAap5TwE8xquA0zvsB4FYKiNoP4q3kARzlWK5kwDDFeLWpMOWzn7dVil1rQLwPkaL3UbYfxPnZlknaqlhAXGulCs820fEHS+ja7cEqdEmIjXXjrO7sj0Q5Fn9fwLgQycr+8pe/DMuysHHjRmQyGXz605/GG9/4Ruh6/R93/vnn453vfCeuvPJKXH/99fjiF7+I66+/Hp/61Kca/ow77rgDs7Oz/N/ExEQUv8qKgQcMMT5AJnSNTz8SnRyLdcAgeOPLKaCAAlyKO1EBgwItW6I8x9wwQ9zeGCdj+wQq7gCXSkCRe1RU9VaF1qPeJaoUEagwrVK0rQO7ZumkLqRtbqXCExaC4484rzVN01x7gihbh/gnLERbYeRKanVJiFZ3xjnpH4XnmApFprgQyVN0+/btePjhh7GwsICJiQk8+uijKJfL2LZtm+fvcfXVV2P//v0NP5/JZNDf31/zL86oYIgLONVbcckxdapposaC58usmhbfZAXgKCzESfQVWGssOC3ZXikiyBXjrxyLapR67PeDLtFqnvhXbjNJHakEU6WEf7YZpsVNq+O83gaEK8fiP70YEO95qsK0SsApBomydchzr9j4XjfhnmMKFOYA8cU5PvwhxvcoLwQLjHUdm5947wlxINK/UG9vL9avX4+zZ8/i/vvvxy233OL5a/fu3Yv169dH+O46i7wC1TRAfPWWq3li/DCKSjkW97XWJ9i/wlGOxXetseDUssSpUnIqjFJPiw3qVUj6A+IPQyp4UGqaJrTVreAyrY5zcqy/m1TrQeCJf8H7QZzXGuA828jWwTuir9miAh05QAS2DqX4F5ncse6CoGebCvdoXIjkNHL//ffDsiycf/752L9/P/7oj/4IF1xwAd761rcCsFsijx07hn/4h38AANx9993YunUrLr74YhQKBXzhC1/A97//fYyNjUXx9joSFTzHgAgCBgUSPaI9x5SRmkcUnMb5HmWqlLJhYaEoxkiYtYz3xni9iW7hVUWen41IORbnBDZg7wkzubKQw1DelRzLxLjIJNqQX5UEdlTxR5xjNiC6adlxfraxgqaoFt68Ksox0erOSvxj3a5UAumEjpJhYr5Q4Sr2MBQrauwJcSCSJ8Ls7CzuuOMOHD16FENDQ3jd616HP//zP0cqZS+uqakpHDlyhL++VCrhD//wD3Hs2DH09PTgpS99KR588EHcdNNNUby9jkSdw5Bg+a8CDyPRkum8KskxwW2VKlSFNE1DXyaJs7mysAmCiyoox6q/W75sm6QnQnoQqdZWKUw5poAvICBWTZx3eVDG2TuLWTrMF+02mrC/qyq+gOJbttSIP3oFTss2FWl9jsqQX5VErDAPSoV8iU8vlqqm/N2hv58KBfS4EMlp5A1veAPe8IY3NPz8l770pZr/vv3223H77bdH8VZigzJqnqgmCMa4jSYr2GzTaWuIb7ICiKCtshz/yi1gq3lYciwsZcPkQX2clWPM3w6w19tAd7gqpCoHb9HTKouKeHeKNGBWJaBniVjLshNkYe9RVRKxWeHTKhWJPwR6xbK1BsR7vYlW27Eik3t/jiMiE7GAIzqI/Z7QncLpxZKwgUCqKNfjAP2FOoSCAtOiALGTjyzLUuJh5K7cWlZ448i8MpVbUo4FwWmjCR+gsoMQEO8BEJmkLdEHxCQsVPGgFD2tUoX9AHAOQyIS2KqoFLtSCd42OifAd0yVtspewcU5ZZ5tAtWdbK0B8V5v/aI9x4qKJGIz4hKxgGNXE+e1BogvzqmyJ8SBeEeIMSKviEkpV/MIUaVYYENG4mwcyTa+smHxnvYw5Evxnx4IANnqWhM+3jrGaw0Q2/rMnmtJXUM6xn5GgNhkLFMKxHkyGeBqdRM2iVeNe7RPoMcdb6GJ+X4AOB53QpKKihwgRRY0AZWKc+LUPCz2SCW00C37KxnhhWDmdxpz5ZjoadnKqGIFtvFalsWfbZmYF+fiAP2FOgRVgnrn4C1aah7fpe42ExVx8M4pEtTzZIWgKmRekaqQyIBhUZFELCDWmydfiv8odcBRCoibVhn/KVsA0JcWt9ZyiiQrALGJfxUmZQPirTDYgJb4F4IFxrqKnA9EF4IXFVEpRuVLHOdzFeAU0EUU59zrNe73aRyI98qOEXlV2ioFVjhYwKBr4C1NcUTXNe7XJCJAVcaQnwUMJTFVSO4DFfPDEFNXiFhruSLz/Ih3WwPgJLGFqHkUaXUTP62ymsCO+T0qVJWiiGodEJ2wUKtYIuLgbZoWv25xj3VFTmZXpXjem05CqwrjRBRMcspMq4zGQiTuewK3dRCw1tg1A+J/3eJAvJ8IMcFQZBIN4PIzElG5LTnBqabFV2oO2ImexZIhVDkW9+QYqwpZlv07h03QKOMLKNBzTCXlmMjDkCqG/CKmVU7MTmA6Nw0AmMo9g6I2i2OLSTwxZX9spHcEm/o3hX+zKwihbZWKHLwB97NN3GEo7veoyKS/W+0f9z1BbFulGsOAdF1DXzqJ+WIFC8UK1mQzob5fTpH4wz18yrKs0OchdRL/4trs2dksndSRirFYIy5QcqwDyJfVCRiimOAT9wc4YAf1J1AU2kbTHfNqWldKh64BpmUH9mGTY6ocIkV6zOS450e81xrgPgyRcswrYVt4i5Uidn5+J04snnA+2AW87yEAD9n/ua5vHQ699xAyyXAHrZWESKWAKmsNEKuCKtJ+4Bv3gJY4TxgHxKoUiwrdo31d1eSYQOVYnIcBAY6FiGHa7ahhnkmGaaFkqCHWcJRjAgrB1SR4nwKxbhyg9GUHkHcFDJmYt4OIneCjRpsbAPQJbHVTxZBf0zSxSkXeshXv6yZSAZVTqGVLZHJMFe8sd7LCMP23PqcTaWwe2Ay9QaijQ8do/yjSiXSo97nScCsFwqLK9EDAlegRoRyrKKKuEDhEye1lpMfYWB4Q6wOlWiEYEDUtWw1DfpG+xO72wLivN2cgkDjlWNzXWlyIf9YgBrj7u1VoDwTEBFqqSH8BsUnFnEqHIUFmwpZlOQFqOt6P1azA1iOVPMeyGfGtbnFPKrK2BiDYPappGu686U6YqG/ebMLEnTfdGbt9VeSwEVX8ZQDXPiq0rTLe142ttXzZCJTAduNMqoz/fiDSX5cNaIl7YQ5wqYlFxroxv0dF+hK7k2OxF2t0RZCIVeDZFgfivbJjgipm/IBgzzFF1BWA2OvGA1QVrpsgb55ixQTz9I/7YYgb8gtYayp5jon0mGGTUeMe1KeTOvfRCdrasHv7buzcsBMJrfZaJbQEdm7Yid3bd4d+nysNFtSz+ysMqrSLA6InyqrhOcauGRD+uqmSrACi8bfLxHytAWK7JFQqzolSrrP9IJOMv7pT5LTsRa4ci/9aiwPxf5LGgLxKAYMrOA07QdCpeMd/mfcKrHir1EbTKyipWCy7xjTHvHortq1BjWlRQDQeMyokLMJOrGTqMcOqTUoalhFL1Rjg3E9i9gM1pgcCTjuq0LbKmO8HmWSCTwMPnxyzv16NtSZwMmpFnTOC0C6JskLrTVDiX5VpsoDbkD/8PbqgUCI2DsQ/axADVGpzWzpBMAwqVbwdbx5xCQsV1Dx9glrdWHCa0DWkEvE7bLsR2dbArnuPAj4MQttouJo4/lu4iOrt7u27cdWGqwDLvl5xVo0BghVQCrVV9gncR1VpqwTE2WEUyurFHoWyiYpRv+3bK45KUZ3rJqQ4V1SvOBc61uVezvFfa2EHArlhif8+BWLdOBD/yDoGqOT50ZXSkahKdcMG9kWFPMfE+leoMa0ScFdvQ0rNWXCa1GOpRHEj0rRapURsbxRtNEoEqOHVPJqmYc/L/g+g2XtCnFVjgLjnGqBW/BHJQCAllOtipqPmFEryuBUkYeO2Ih/+EP+1FoXnmBLxR1qUckwhsYaA2IPBrrsKfopxIP5P0higUuW2ZoJg2CpkRZ3gVFTComKYfEyzEp5jgg5DKk2L6hfp+VFSJ2AQ5W8HKNb63JVAYUjHv8+dwUNnz8II2G5/7YZXIG2eCwC4av1VsVWNAc7BO1cSYJLOEhYKrDWRk3jVKs6J8aFUKVmRTupIVw3N50MqFUml6B/DtFwDIBS6bgI9x+JO2GnZbljc10dtlR1B/Fd3DFApOAUEJiwUkv+K8q/IuSbRqHDwFtcOotJByL5m+bIRuh1kkXuOqXDd7N9RhEl6QRFD/q9PT+Nb5xRx4upu3F04gZuefBLn/PSn+Pr0tO/vlSsZGCy/BWlrFHftuiu2qjGgNgAPu95UKs4JNUlXqDgnasqnSm2VgHuCcTjlmErqTmFqf1esq0RxTlBbpUqFuax72EjIZ9si9xyL/3WLA/HftWNAXiFjeUBc9ZYdIFWYVpkVVRWqbny6pkZlSHhbpQL3qNDpZNxzTIXgVIzizjAtru6MczL269PTeP3TT2NRr63YHisW8fqnn/adIFsoVtBtXoZLU1/Erm27RL7VFUcmqSNZtScIfRhS6eAtsGVLSTVP2OKcQm2VgLjrlldoMrsoHyimWtc0ReI2UQlsRQaNALZtBTsHBR0IxFiktsqOIv5PhBig0rRKQJwKSslqWsiNL8/bGpKxVlYwqK3SP6mEzoPJsAHqokLTKkX58hTc6s6YrjfDsvDe/fthAcCSxxBLld22f7+vFkuV2ho0TRPWxltQaPhDVlACG1BLTcynZYdUQKnUVgk4+15oC5GySp5jYu5RZsbfk0ooEeuKukcLCinHAHG+Y4sldeKPOBD/J2kMcCaTqXFTifLPyitliCum4q3SZFTAFTCEXGtFhVQCgKOCElW9VWtapbjkWFzVnT+amcHRYrHh5y0AE8UifjQz4/l7suBUlVHqog7eSk3C6xLXMp5X0dZBWFulGveok8AW01ap0loTFeuqoFoHHMWdqMnsKpyrAPe07HBijQXeVqnGeut01FjdHY5KbQ2ASM8xdSq3wvwEyvbXq7LWeMAQ0pdHFQ8oRr+gNl4eoCpw3fg9WjJghjB3dRvi6no8K95TpZLQ1wHu4DT+aw1wH4bCHbxVij/ca0NYwkKBQ2RWWFulvZ+oELMB7umoYbskqvGHAkVNcS28rM0t/tcMcHxdxVmIqHHdhLXxcuW6Gtet04n/rh0DHANENf5cojzHiioGp6GVPGq2NYRuR1VorQFudWfIAFWhalqvIJN0FQ5C69Npoa8D1GqrBNxtNILsCWK83hiZZELYBEG1plUKLpYosNYAl+JfkOJOhfgjK+ia5UpqqRR7SXQQCN5WGXI/WCDPsY4i/k/SGKCSdxZAPlBBcKtSwowcVq2tUtR464JChriAuAEQiwpVb90m6WGumwotNC8bHMSmTGap3RhHAzCayeBlg4OevydLgKuSHOsT5DGjmudpvwClgCpDMxjC/IwUm1ZJbZX+cXuOWT48J5eimnJM2NAuxc6j/d32dZvLi4l1VSgExwFKjnUAecX8jET5Z/EKhwIBg3uCYBhVSl6xyq3oFl5VAgZ23eZCHCAty+LJWBUCBlEm6XkFlDwJTcNf79hR93MsYXb3jh1I+DBSZve4CmsNcPtABa94W5al3GFIxJ5QrDjJDpXUPGHWGqDetEphbZUqFYKre2jFtFCsBPcFVFWlKMrzVIXnGuAMaQnbJcES4KoU5zodNVZ3h6Oa/Fe0uWtGgYd4JplAOmH/nmGuG1eOpWit+UG1tkoRE6OKFZOrHJUJUNPhFRYFl+dYnLl1zRp87eKLsTaZqvn4pkwGX7v4Yty6Zo2v76daW6VbTRyUkmGCCZG7FLlH+wRYFLBiCaBWcY7aKv1BrW7+sadL2v8/jLpTpUnZgMhCsFrFElGeY4tFtZSKnY4aT4UOR6VR6oA4+a9qD/G+riTOLJZCXTfVpOZcyVM1SQ9qcF5UqK0BcAdawatpedehXZXEvwhvwLxCrc+3rlmDy7UeXPfFHyLRk8A/vmknXjY46EsxxlCtrUGEn1Gh5CR5lNlHBSjXWeyRjvHQDDfUVhkM0a3PKhTndF1DXzqJ+WIF84Uy1mQzgb5PXrVYV3ByTIVELOAUgsN0SVQMk6scVSnOdTrxf5LGANU8P/oy4VUpAJBXqJoGOJO2Qh2GFA1OgbAm6eokLAAxvjzsemeSOhIKHCABMUqBQkWtFt7B7hS6zphIHS3jhv6BQIkxQL1R6mwqlogW3qSuIZVQI1wUEX9wJXHM1Z0MEcUSQL22SkelGHL4g0JtlYCYAjprc+tRZHqg29IhjFebajY/WQHDp9yegqrEH52OGjt3h6Paw4hPwgtZ4Siqdt2qQX2Yw5BqwanbJD2MKa6q96iIFl6VggUhyTHF7lG3n2KY9ea0Vap13YT42ymy1gD3wTv4YUg9dYUgewJFLUTCG/KrVQgWEX/ky2qtNRZ7lI1wXm2q+euKaKtkheB0QufTkImVDf2VOgDVAlRRVUj1jCPDH7xV8/zQNM2VsAhzGLIDhrj7QDFYIjaM1FxFD4asAFNc1faDVELnv2uYAFU1Q34Rg214u5ZC96gIH0rlkhWCWrbyiirXww+fUmtPEHHdVIs/3N5qIuIPVZ5tTltlGOVYda0pUpiLA2qc5Doc1appoqqQrP1IlYe4kGqaYskxQIzvh2ptlSLUFTnFDHEBp/U5lHJMoUEjDLbeRASoqiTH+gQmYlXaD5y1FmLYiGKFuVpVSvB9lHmeKpPkEbCPlg0TlerUDFXWG0tYhCmWqBbrJnSN/65hlIpFxTyw+7vDK8d4YU6hWLfTUWN1dzh5xR5G7ipkmN74gqIm6WGqaTm+1tR5iItQCuRVW2sCpOY5hYzlGdzPiJRjvhDS2qDotEoRiViV1pqIyYsFxTyg3PdU0H3UNC2nZUuRPUFEWyW7RwGF1psAr7ZFbsivxn4AuNXEIQYpKRbr9vNEbHjPMVVijzigRralw8kr6jETpjfesiwnOaZKUlGIckwtqTkgpnpbVKyNpl/AATLHpweqcc0AMSbpqnl+AG6lQPB7lBvyK3IYEpEcU82DEnDZE1BbpWfcqpSg663gUpypEn+IbOEF1LF1IAuRYGSFJGOrzzZFrptIzzFqq+wc1HiSdjCm6SSIVDkMuQ8vQTe/kmGiqjRXJkAV4dWmYsAgpK2yolYbTV8mhRsO7cX/9+O/Azz4YKDvwadFKZKsAFyG/AImyqryXAPEBKjsuahK9VbEWlNRpShEOabgPcqV6wHXG4s9AHVUKeweLRlm4HZUt7euFnCSb6chpEtCMbsaAEL8dVVTjrHCXK5koGIEE2uoplqPA2qc5DoYdzVNFal5QtfQy6qQAQMtdzVNlYe4iCSPkoehTHiJvmrtR9lMArc/fC+2TR8BPvABIED7M1eOKfJcA8QcvPMKtqOGbW2oGCbfE9zTL+NMVsC0yoKCa421PocaZMAPkOqE2GE97pwOCR26rlaSBwiu5lExESvCc0zFQrDjeUr+ul7JdoUXayyS51jHoc7O3aGoWE0Dwh8imWmkrgGphFqBloiDt0rVNB7Ul8InFTOKBKgDP/4BLj2+z/6P8XFgbMz39+DKMYWqac5aC+9npEoLDRBeOea+t1Vp4+11PddMM5h3JxVLgsGKeqokYoHwMZsz/EGda1bTjhqyEKzk+SBUckxFWwc7qRjO1kGtLolUQue/a9j4g9oqOwc1VncHo2I1DQgv0Xd7figjNRdgUuqYpKvzaOgNudYA93pT4LpZFno+/CFUNPt3tRIJYM8e3+qxXFlB5ZiIVjcF1Tw8ORaycptKaMgocoisUaUETMbmlVSlhC8ysb2EKR5VIGxxjsceCq01ILxJumqWDoAYzzFWnOtOqZOMZZ6nQeOPimGibNhxnkr3KXuOz+aD3aPUVtl5qPM07VBUa9di9HWFm+qm2rQoQKxJqVIBg4j2I5Xu07ExaI89hqRlJwQ1wwikHsux4FQhpUCvgHu0oJgHJRDekJ+3NSgUnGaSOpLVglrQlq28gsUSEf52bJ1mVVKOhSwyqZj0B8KbpKvYVily+JRSyrGQif+Ca0CaSust7J6woGD80emoE/F0KCq2NQDuRE/AapqC161PQFCv5LRK7sNABswtsSxbJZZY8nsGUI8tqug5JiI5puIEweqzbS5scKpQIlbTtNAGzEruo9VrlisZMAK2o7I9WMXkWGDPsbJ6sQcQflq2atPsAfd+EOyaWZaFnGLeWUD44hzbDwDVbB3EFOdIOdY5qLO6OxS+8Sn0AAfCtx+x65ZRSGoe9uDtDhhUClCZD0PQ62aYFpeaxz5AHRuzVWLGkip3APVYTmXPMRqa4YuwBszseqsWnIYd0qLiWusTYMDMkrhsb1GBsKqUnIJJHsBJ2Ae2EKkoZOlQJWysWyibvI6nUsEkGzaB7bL5UcWuBhDnearSuarTUedp2qGoGJwCLhVU0EBLySRPuI2vWHECBrWqaWENcV0TZeN8nzLVmN5g29B1X+oxFZVjjkl6JbBJeqGsXuLfCU6DVW6dtgZ11hogrsikUnEuk0wgnbDvraCHb2qr9E9e0QOkY+tAbZVeCesL6PZgjHXMtgTH3y7oGUHN82jYadkq2jp0OupE1x2KsgFDyKB+rmqcqJQhritgsHyaowO1k1FVmhgVNtDKqyI1L5WAI0cA06z/edMEJibs13lAxcmobK1ZlpPA94uKBZPQlVtFg1NREwRVWmtAeE8jFdsqe0O3VaoZ64a1ECkqeI8yReZ8IVism3cNf1Bp0Fnoe7TkDDpTCVHxh2rK9U6G/lIrHBWnRQHhExYqBqfswVs2LBQrpu81w9ZaOqkjoVDAEHa8dcF13WIdaGUyduvk9DQA4K/Gnsf3nzuJt95wDl5/5aj9mpER+3UeUFFqnqneW4ZpYbFYCRQsscmoKqk7Q1duS2oGp6I8ZlQ6eAP2OjmzWAqcsGCTB7MKFefCxmzKtlWGVXcqeEbo77avmWFayJUM30WPRQXN+IHwbZUFRZVj4adlqxfrdjpqRYodiLKV27DKsYJ6yjG3d8JCseI/OVYNGFRbayxACrrx8WSFCtdtdNT+B2D+aAZPzxzCi6PbgSsu8P2tcgoGqJqmoTedwFyhgoViBWsDfA/eRpNU57plQyp5VJ0WFdpjRkHTaiB8iyD7un4Fi3OBVYoKFksAt7ozaFulep5j3akEUgkNZcPCbL7s+7meU3Qyaq+g1ueMCrGuC3aOZB1JflG1ONfJqPM07VBUHW8d1nPMUY6pkxzTdS1UUjGnaHCaFaQcUyk4BYCB7mrAENiHQb22SsB5JoVVCqi0J7BrthhwguBCQc3gtDfkJF4VJ+EB4dpoLMvi602l+CO051hZzf2gL2RbpYqeY5qmhYo/2DAglcz4AZe/XSmsklitWJdsHdRDrRXegajc1gAI8BzrVuthFKZ6q241zf59cwEP3ioGpwDQz4LTfNA2GmbIr9Y9ytZbkGRs2TD5GlVJOeZOagXZE1T1/AjbVplXSRXrIkyLYKFsolK9R1W0dQhaZGL7gWr7aGjFnarxRzXxPJsLkBxjXRKKxbqhB7QoutZYkSNoIXhB0fijk6Hk2ApH1YSFOM8xdSq3QDilgOptDUCwippSbZUuWMtQkIDBNC1HKaBQWyXgUlgEuUddJv5daXW273RS58Mugqw31rKkWuU2tMeMgipFINwhkvniJXRNqb009PCHqtm3StcMcCfHQrZVKlQsAVzFuRBdEqoV5pwEdrC1VlQ01g2jHDNMi9+jqj3bOhl1ousORV3PsWrrUcBAy/EcU2zzC9GyxdsqU2pds0zS9q8Agl03do8q58PQHdyHoVAxwIZMqRYwhJkYxZIVugakE2pt39kuZ0KZXxzlmJprLbBSoKRo/BHC1mHO1cKraTEe0LKE8KoU++tU2w+cyajhplWqZuvA4o/ZAPGHqqIDth+UDBPFiv8EmerKsSADgdwFd9WKc52MWk/TDkT1tsqwhriqKceyodoq1ZSaA+FaGxyDdLUep7ytIUBwyiqXmqZexTtM+1HBNUpdpYM34BQ6wgSoqgWnodU8ih6GeHEuhHJMpZZKwLXWShVYln97AlWnVYZtq+QTBBWL2wZCJceYpYNa18z9+wZRj6lqIRJGOcbivKSucfU7sfKhv9QKR1VDfqetMlg1TWXPsRsO7cWNt94IPPigr68tlNVsqwTCefOoGjAMhGprqKoEUgnoulpJHhFtlaoVS4BwAaqq0ypF+RlR/OGdeUWHP7Df17KcRJcflLV1CNnqxodmKFZk4rYOoZRjat2jyYTOY4cgxbm8oirFMMMfnMFT6hU0Oxm1VngHom7l1t60CmUTZcP0/fXOKHW1lGN9mQRuf/heDB7aD3zgA4CPCq6qUnMgXEtIoaKmDwNLPAcJTnnAoNgBEhDTVqnafgC4WhsCJCxUNeQPo1I0TAslRZ9tYZTrqsYe3akEWJ0jkOeposW5vhCKWMDxHMsomrAIpFxXVDkGOPFHkGebqv66rFgS5DyqauzR6aj1NO1AVJ0W5a7wBwnsHc8xtQLUS595FJce32f/x/g4MDbm+WtzivrLAM7mF6zVTc1qGvP8KFZMnrTxiqptDYBLlRLC3061tQaEbW1Q05C/N4RK0X1Pq7YnhBkIpGpbpaZpoZKK1FYZrB2VtVWqdt3CqHlUVSkCrlg30PApNdeaO7Hl99m2qKhqvdNRL8LuMPKs/Uixh7h7Opnfh1HFMHmgpVSAaln4tX/+DCpa9bZOJIA9ezyrx1St3AJiDpHKBQzpJJhK3O89yoc/KNbWALhbeIN7fqio7hTRVqmaIX8Y5Zh7MqpqXikilGNKxR5VwrTx5hXdE9g1My1HmeMHVdU8YQYCqa1cDz7RXtX4I5nQ+bnIr8JTVUuHTieSiGd+fh633XYbtmzZgu7ublx//fUYHx9v+jUPPfQQrrjiCmQyGezYsQNf+tKXonhrHQdXCij2MAKCV2/dAa1SAerYGNa98BSSVjXAMgxf6jHHkF+ha1YllEm6opVbXdf4AAi/rQ05RZP+gKC2SsX8ZQCnrdKvUsCyLGWrt2HaxfMuRaxyvoBClGNqqdYB57qFScaqtifYXkT2/w/SMq5qcS5MW6Wqk1EBoDcdXrmuWrEECF6cY4XgXsUKc51OJCv8bW97Gx544AF8+ctfxi9/+Uvs3r0bu3btwrFjx+q+/uDBg3j1q1+Nm266CXv37sVtt92Gt73tbbj//vujeHsdhaqj1IHgVUj28OpJJ5BMKPIQtyxgzx6Y+pJ14kM9llNYah7uEOlMEFSN/oCtDSpXbsNMlOUqAQXv0aDBabFiomLazz/VkmM8EVsyYJr+WracAS1qXTMAyIaYVjlHyrGAbZXV4pxi+6imaehLBzflLyjaas8sU+bywdvslXy2hbEQUVQ5BgQvznHlmIJrrZMR/tfK5/O477778K1vfQu/+qu/CgD40Ic+hG9/+9v43Oc+h4985CPLvuaee+7B1q1b8Vd/9VcAgAsvvBA//vGP8alPfQo333yz6LfYUagqmQZc1VufgZaSfmNjY8D4+PJst1s91uJeUtmHwW8idmJ2AtO5aQDAobl9KGrHMV0s4YmpHABgpHcEm/o3RfNmVxAD3SkcPZv33dqgsudYmMmoTuVWvevGDfl97gfu66xagOpO0OTKhi9TYJUno4ZRjrGvUVM5Vk0q+rxupmkpnfjv60pivlgJlIxVdTpqKOWYwrFuuPijWghWMv4IlvgnQ/7ORPhfq1KpwDAMdHV11Xy8u7sbP/7xj+t+zSOPPIJdu3bVfOzmm2/Gbbfd1vDnFItFFItF/t9zc3PB3/QKRtVR6oCrCunzIT6nmiFuVTUGXQfMOp4Vum5/fvduoMkoYZUN+f0EDMVKETs/vxMnFk84H+wCPvmk/Q8A1vWtw6H3HkImmYni7a4YePXWb8CgqL8MIMaXR8X9IBtwqhsLTnvSCSQUaw/MJHUkdA2GaWGhUPGXHFN00AhQe4+apuWrrVRVQ37A8fRb8HmPMmsCQO2Ehd+2yrJh8n1ksCct/H2tZMIY8i8qbOsQJv5QWTnmKBV9xh8s1qW2yo5CeNSTzWZx3XXX4c4778Tk5CQMw8BXvvIVPPLII5iamqr7NcePH8fatWtrPrZ27VrMzc0hn8/X/Zq77roLAwMD/N/o6KjoX2VFoKrUHAD6ArY2MJk1a/mKPaUScORI/cQYYH98YsJ+XRPyKrfR+FAKpBNpbB7YDL3B41OHjtH+UaQT8Q9W+7vt6+ZfOaauD4MIf7tuBRMW/QErtyob4ronCPo9DOUUPgi5E1sLPqe6kSF/gLVWcpJjKqpSnD3BX1ule9/tV2y9sdgjVzJQNvwNMnDiD7WuGRAy/lC0hRcIrxxTca11MpGs8C9/+cuwLAsbN25EJpPBpz/9abzxjW+Erov7cXfccQdmZ2f5v4mJCWHfe6WgutTcSVj4O3grV7nNZOzWyccfx/RD/4lXv+Vu3PLWv4b12GPA44/b/8bH7dc1wVGlqLfx+TFJ1zQNd950J0zUD8hMmLjzpjuhNVHpxYX+gD4MuSIb/qDecy3UtCiu5lHvujltlcH87VRtawiasCgorCTOJHWkEvbz229xjh2elLJ1qMLUPDM5f/eoysMfgOCxLmspzGaS6vjrVnG3LQcdCKTis02Eckzt+CNgW6WCooNOJpK/1vbt2/Hwww9jcXERc3NzWL9+PX7rt34L27Ztq/v6devW4cSJEzUfO3HiBPr7+9Hd3V33azKZDDItDvudTrHiHL6Vfoj79hxTMDgdHQVGR9FXMvD0f5wFACxecqmvA6ETMKj3EPdrJLx7+27s3LATT0w9AcNyqr0JLYEr1l+B3dt3R/I+Vxr9AX0/mNRcNQ8ooHaim2VZvpKohYq6HpThK7fqXTMguFIgr/BBiCnuzubKAQYC2c/CPlWKcy5Ya9+Mz/1AZdU6EHyCILvOynRJuEhUp2XPFyuYy5cx3Of9PJgrqqsccyxE/A9/UHlP6A9o66Cycr2TibTU0Nvbi/Xr1+Ps2bO4//77ccstt9R93XXXXYfvfe97NR974IEHcN1110X59lY87EEEqPkwYsGlX88x5ZRjLrpSOtLVMcszueZtlEtR2aSUJyw8ttAw9Zg7MQYAhmUooxoDgk+MypHnB0yr9hnvBXaPZhTcD8Ia8quYiAWcpKDf66ayIT/gij8CKsdUjD9WseSYz9hDZb9TwD0Awt9+wIpSgz3qJceAYMU5y7J4y7jK8YdfX0BA7QFxQYtzKluIdDKRJMfuv/9+fPe738XBgwfxwAMP4KabbsIFF1yAt771rQDslsg3v/nN/PXvete78OKLL+L222/Hc889h7/927/FV7/6Vbzvfe+L4u11DCw4TVdNdVUjsHJMNc8xF5qmYTBgawMFDP7WGlOPsceoriWwc8NOZVRjADDAPMcCtrqpWE3rTiXAHud+n20qJyzcvoCGaXn+OtWnRbEJgr6VYwoPfwBcnqe+i3PqTqtkSZqgbZXqrrWAbZXV6zygYKwLuE35vd+jxYrJ9w8lY12uXPevHCNbB/9DM0g51plEkhybnZ3Fe97zHlxwwQV485vfjF/5lV/B/fffj1TKXlxTU1M4cuQIf/3WrVvxne98Bw888AAuvfRS/NVf/RW+8IUv4Oabb47i7XUMeYXVFYA/k3Q3KivHACdA9e/DoG6AGsSHganHUPUeMxVTjQFOAtqvIX++rO6zTdO0wOPU+bQohQ1xAX/XTfXgtC+gx11B4UQsYPs4Af4S2IWygVLVHFzF+IPFHmf9qtYV3g+A4IVgUo7Z181PrJt3DX9QsY03aOwBuAcCqXefkiG/WkTy13rDG96AN7zhDQ0//6UvfWnZx2688Ub8/Oc/j+LtdCz5kroSViC4cSRTsSjlOeZisJu1NngPGAzTQqnqZ6RiwBB0rb3inF1Im+eipO/D5WuvVEo1BrgN+f0GDGp7zPRlkpgvVHxXb1U2xM0kE0gndZQqJuYLZc9qCZVVioDLz4g8x3zRF8AknR2cNE1NA2anrTJYYY7Wmr/9YIaUYwD8JceYdUZG9Y4cn/tBxTBRNmzFnYrTKh0LkYCT2RXcDzoZ9VZ4B6FyCw3g3ySdobLnBwAMsNaGvPfqrdv7SMXqLVtrhbKJio+x4HOFCgbLb0HKHMVdr/yoUqoxwFGOzQecFtWr4FoDXM82nxJ9lacXA25TXO97AjsM9Snq+eEeAOEHXpxTdK0FiT+4GX86qeTURd5WmS/Dsry3PqvsdwqEaKvMs+RYWvh76gSCJCxorQXbDwquAXEqJrGDKscWFB8I1KlQcmwFQ5XbkMoxRatpQTzHWLJC0+yKmmq4VSV+1Dwz+TK6zctwvvZ53HyuWqoxIFhbA+BSjqmq5uEBqk9D/uqekEmquScEMeVf4J5jau4HQZUCqhfnghyGVC/MMeWYYVq+BinlFfY7BYLfo6wAqrpyzE9ybLGktmqdD2gJ6EGp6hkhG7hLQm3P005FvRXeQahuUpplhrgBlWP9igaoQTzH8q5pUaqpnwB76AWb8ulHzcOmcqnq+eEY4vpTCqiuHMsGVvMovicEGKfO9g9VK7dBD96qe44FKc6x16poxg/YhVx2cJ71VZxTvBCcCdZWOae455g7/vCKypOyAedcVaqY3ErFC9zSIanmGSFI7GGaFn+2qZqM7VQoObaCoeA0oHIsr7jnWIBx6jnFpeaAY8DsSzlWPQCwirlqsHusbFi85c8LfL0pWk1j/hN+q7fMELdLwcotECzRo3rltjeg2TdLxHYpuicEMeRXfRgQ4OyFfkz5lW91Y7Guz6nPqnuO9QfwHMspr1p37jE/xTnH71TN2IPFukUfScWcy65G1fijU1FzlXcIKk8PBGoPQqbpTZViWZbSo9QBJ1Dy11ap9loD3FN8/CjH1A5Oe9IJbmrrtXpbMUwU2fAHRRP/vUF9PxS/T1nSwU9rg+rTKrlKsURtlX4IkoidU7ytEnBPrPShXC+rra4Iqu7k0yoVjT+ctkrv140lLFSNPZIJnSe4/Kw37neq6HXrcz3TvarHWHyna+omFTsV+mutYFQPTt0BptfAPl82UKkm0pgfkmq4TXG9wiu3KTWvGRCsteEsb6tUUzmmaRpvX/bq++GupvUo2uqW7Qqm5mGmuOruCcxzzP90MlUrt3xapV/lmOLxRx9baz4OkKww16doYQ5wxR++lOv2dVO9rdKvByWL8VT11w3ieZojg3RnvfkomKjugZ3QNX7dvBbn3IU5FVtROxlKjq1gVG+rzCR1JKuqFK8VDhacJnRN2es2WJ1c5M/zw75uqipSAFdyzMchkgVlqxT1/AD8tzawtoakriGdUHMLYoG5b5N0xb15gpikswOnqsqxoPYEPP5Iq3mPOvuB932U2iqdtko/ynU2GVX5tkqfXRKz5DkGwGdyjKuv1b1Hg8S6BcWTY4B/3zEW6/YqvNY6FTWjng5BdfNlTdNcXgzeHuKO35i6mXpHOebD80PxaVGAO0D1Hmhx5ZiilVvANU7dq9TcZYir6j3KJif6aau0LEv56m0Q5Zjqo9QDT6tUPBHbT9MqA+Eox/y0Vaptku5WtXpV8xTKjveRqsr1MIb8qg4DAtwWIkGUY+qmDfwW51SPPToZdVd5B6D6QQhwggavrQ1zivuNAcE8x1Q3xAXcAYN/Q35Vg1PAv+8HW2uqKnkAoC+AcqzoMoFVNUANkrBQ3ZA/aMsWtVX6P0CypK2qw4AAZy/0Y8iv+rRKd5eE1/uUqaUSuqZsoocX5vJlz4o7mh4YLDnmKInVXGuA/+Kc6rFHJ0N/sRUMTRD0L/9lFSRV/cYAp3JbrJgolA1PAafqwSkQTGruJMfUPQyxe82zcqyotkoA8BecTsxOYDo3jflCGUVtPwDg2VNrkay2pI70jmBT/6bo3uwKwm/l1j1KXdVkbNaV5CkbJlIeW5lVPwwF2Q9IOeZYDPjxHFO9OMe6JGZy5apyvavl17DOgMHulLIKbGbpYFq24s5LUZzOVe7J7D6UY+yMkFT4uvkcCOR0Sai7H3Qq9BdbwajuOQbUBvZe4MFpRt1kRV8miYSuwTAtzOTKWDfQev1QW6Wj5vFjUsoC1FUKK8fc1VsvUOXWe6tbsVLEzs/vxInFE/YHqmema/7eec26vnU49N5DyCQzUbzVFYXvyq3rXla1ejvYk4au2QfIs7kSRrKtD96Ay9ZB0fiDK8dKtg+UrrdOQFByzPE89TUQiOIP9Kbt5JjXxP+s4pOyAbuYm07qKFVMzObLHpNj1YSFwq1uQbokzig+fApwxx8ek2OK+512Mmr2ZnQIPFOvcMDgWzmWJ+WYpmncA8ur71iOKhzcB8pPyxZTjg0orRxjvh9+q2n0XGtVuU0n0tg8sBl6g61ah47R/lGkE2oErH6VYyw4TegaMkk1w52ErmGo114fpxe87QdufztVk2OswGZZtRN2m8EN+RUuzjEV9VlfA4FIuc6ebV7bKlnyUeXYA/Bvyr/IJ7Oru9b8ejkDwJnq3jHcp0asUQ+/hvxOW6W6a61TUTNa7BBUD04BZyS6b+WYwp4fgBMwefUdyyk+/AFwAgY/UnPeVqlw9Zb5QHmdjpqjapprrTU/CGmahjtvuhMmzLqfN2HizpvuVKatxm/llg3X6FN8lLrf5FjJMMEsfFQtznWldCTYtGyP642UY8CqXjYtO0hbpbrXzVHzeNtHWTJIZeUY4MQfXj1Pc8zWQeX4gxXnfHRJnF6072e2l6iI0yXh15Bf3bXWqVBybAVDyTH/k7bmyBAXgJOs8Zocy1M1zbdJetkw+WuVbqv0OTEqR8oxHix5qUDu3r4bOzfshK7VXq+ElsDODTuxe/vuSN7jSsTx/PC21ljbiKotlYzVvXbL7enFoqfXF0pOMlbV+EPTNGcgkMf1xgYHqVycY7GHH+UYtVW6hk/5bKtUuTAH+FeOkeeY/7UGOMmx1X3xt29ohF/lGJ+Mqnj80YlQcmwFo7pJKRDEc6xc83WqwnwBZj23VZJyjLVVelUJsMSjpjkJIhXxO06dtTX0KqwScCq3Biyr+ZQtrh6zalVmhmUopRoDavcDL9PJFmmUOgBgdZ8/5RhLVqQSmmcD/zjCD0MUf3iGxR5zhTIMzxME7euraiIW8K9cJ+WYjd/4I0fxB0/W+OmSOL1gF1ZWK9xW6XdaNivOqbzWOhV1o54OgAWoKvsw+K1wMLmryskKIIByrExtDb0+lWMs8djfleLtNyriV2rOD0JKJ2Lt+8wwLRTK9Vsm3ezevhs7Bi8FLHvLVlE1BjhrzbK8tYRQW4PNatZW6VE5RrGHjR/P07Jh8ntZ5eQYS1ZYlrchLabrGaj0npD2VwhmfrIDCqvWAZdy3bNyjOIPPnzKR3LsDFOOKdxWyW0dPLY+U3Guc6Hk2AomT2oe322VVLm14Z5jHgMGZ62p+0jwq1LkfmOKG+Ky4ReelWPcc0zd51pPOgEm+PKy3jRNw6s33wZo9iFSRdUYAGSSOlIJ+3f2UjBxDHHV3g9YKww74LRC9UmVDD97gns9qrze0kmd//5nPfiOFSqOIlblLok+nyrF2WoxipRjwdoqVVbz8OFTHteaZVlcdUxtld7FGtRW2bmoexLuAArkOeaaquJt42MT88hzrDpO3bMhP2trUPch7ldqfpY8PwA495r34JQmo2qaxpUCXtfbSPpqpM1zAUBJ1RhgXzc/pvy8cqvwWgOcVphTPtsqVS7MAf6UY6ww15NOIKlwKyrgFIy8FOdYsgIAupLqrjevE4wZM9XEI8UffpVj9Gzr9akcWyhWUDLswhwpx/y0VVJyrFNRewdf4ZAhP5ANqBzrV1w5xoJTv55jSlduM/4qtzw4pbYGAHZw2so/C3BXbtVda4B7Opm39XZqsYTB8luwrmc7PvrKjyqnGmP4McVdoMmoAFxtlQseDfkp9gDgTMv2sifQpEoHnhzzoBxjKsWulA5dYXsCP4lYwEkGkXIsWHFOZeW63y4JphrrTSeUbrVnXRJeDfkX+UAgda9Zp0LJsRWKZVmO74fCrW59PmWs5Dlm4wSnfj3H1H2Is+C0VDFRqrT2gaK2ShsWnJqWY7bfDJ6IVTxh4dfj7tRCCd3mZfj0TT/Arm27onxrKxo/rQ1OW6W6zzXAf1tlrkSeY4C/hMUct3RQez8AnOnNZxdbxx9UBLbhXRLF1nso4KjyKP5ghvyt79FSxUTZsAt4PdQl4Vk5xiZVDilsxg84z3av/rqkXO9c1M26rHCKFRNMhKFy+xF5jgVjwKchP0nNa9UlXoIGZoi7SnHlWCapI11tI/LS2sCurcqJWAC44dBePPCFdyP9g+97ev2peVv1M5xV1/MDALIZ79PJqK3BxlGO+WyrVDxh4UelSMoxBx5/+GirVDnOBdyxrreYjcV2qivHmJrHi3Is7yreKR3r+hz+wCdV9ioee1Sf7SXD5OrqZiyS51jHQsmxFUq+xodB3T+TH/lvxTC5ckV5z7Fqwsar1DxPASpSCR1dKfte87LezlJwCsD2gfJjyk+GuAAsC2/5t7/DuacnsPVTfw54aEc9VQ1Q1yhsiAsEU46pHpyyQ818sYJipXVQX6BiCQB/tg5Ockzt/QBwCkZ+2ipVX2t+CsGmafG9dkBx5Vi/j7bKXNm+tqmEhjSdq1Aom6gYrbskaFKlTV86yQcpeYs/yNahU1H36bDCYZXbdEJX2tyVTVVZKFRa+hm5g4o+xau3g93ePT/cLbyqq3n8BKiz1eTYKsWDU8BtiushYCiRcgxjY9h+6FkAwKqnnwTGxpq+3DQt3tqwmlobAHgMTkuk5gFsdUWy6ufkpbWSlGM2fiYIkmrdYZUPW4d8mQ0DorUGOAfqZswXKryeonpxzo8hP7u2KheBgaVdEq3XG8UeNrruDFJqpSa2LMulHFP72daJqJt1WeFwv7GU2n8iFjBUTAvFFj5Q7GDek04gpXBCEXB8KBZLRkv/rJJhwjDtSIuqt96TY6ytUnVDfgDI+qjeMqWAstU0ywL27IGp288oU9eBPXuaqsdm8mV+j1Jrg/9WN6VVirDVnexg46W10ok/aD8AvE6rZJOy1V5rADDAPMc8FOfI0sGGDwTysNbYPtudSiCj8IRPwJ8hf54GTwGwuyQyVeXcvIc2XrZnDCkeewDelev5ssFDOtXjj05E7QzCCoak5jY9qYRnGescVW452a4Uv26tgoYaHwbFD0N+Jggys2HV2xoA50BInmMeGBsDxsehm3bSWjdNYHy8qXqMeX4MdKeUbgcBnLVGbZX+YAebUx4mVjrxh9przY+tA3sNtVX6VI5RwgKAP88xVphTXTUGOPFXsdLaB4pU6w59Ge9KxdOLVb9TxZVjgHflOtsPNI3WWyeiduSzgnHa3NQO6t0y1lYBKkuOqe43BgAJXePXoVVyjFVuUwlNecWdH6UAu66qG/ID7olRraXmOZWVY1XVGBJLgqVEoql6bHqBglNGnw/lmDNKXcG1tgS2dry0VRaorRJAra1DK3hbJa01x3MsTy28XmHPKC8+ULM0qZLj9oFqFX8or1p30ecj8c/2jCHFPccAePbX5X5j6SQ0tkCJjkHtk/AKJk+j1Dn8Id4iQKVpUbWwwGm2RYDK2xporbmqaV4M+attlVS95aa4rTzHSoaJisotvFXVGIwl1VrDaKoeO1VtaxhW3IwfcCq3ftQ85Pnhb2IlJSxs/Bwg56rxh+p+p4Cj5mHq6mZQW6WNHx8opsjrp9gDuqsQ3Cr+YMox1Z9rgL+JlSz+WE3xh0s51io5RirFToaSYysUJzilPxH3YmghN2ctXRQw2Dim/N6qaaqrFAHvh6FixeBBPSnHXKa4LQKGnCvo71EtQGWqMb3BM72J99ip+apyLEvBKSt+zPkw5CflmKutctF7W2WX4oE9WzdepvDStEqHVT6mZVNbpU06qfOW+VaxLleOUawLwFHzeO2SIOWYE+t6scI4U90zVJ9WCXj3HGPJMYo9OhPKvKxQeFuD4gED4F05NkfBaQ0DfJx6q4CBKhwMr6a4LAjTNVIqAt6DU5asyCQVnMJbKgFHjgBmg5YZ0wQmJuzXLYH5RK2hyq2/aZXkOcZhhvxnSDnmmX5XsaTVtGyaVunAkjYLxUrLgUC01hyyHn2gqK2yFm7r0Co5Vt0P6FwFrO3vAgCcmCs0fZ1lWVxtrPq0SsB7cc6ZVEn7QSdCf7UVSp5a3TheJwjOc88xWtaASznWKmCgRCzHa1slSzgOdKeg6+Qn4HWcutKeH5mM3To5PQ3AVh/e+rc/AQD837dfh2x3EhgZsV+3hFPkOcbxOq2yWDFQNuyEhpLrbQls7ZwmzzHPsMKcZdmqk2briGwdHPq77YFAlmX7jo1kuxq+lhXnukm5jr6uJE4vllqa8rPkGBny23j1PGWxbi/Fulg/YN+TU7PNk2Nz+Qq3wiDPMe9tlQvMc4wsHToS2o1WKDnyHON4TY4xvwFSjtlwz7EW49QL1NbA8brWWHJskFoqAbg8x1r5MKi+1kZH7X8AMgAmv3sWZ3NlTG6/EOevyzb8MvIcc/A6rdKtvqDDkNNWedrDtEqKP2y6UwnoGmBa9p7QPDlGA4EYCV3DQHcKM7kyZnPlpsmxfMlWlim7J7hgPlCtnm0zzO+U4g8A8D58qkgWIgyWHDveIjnGJlVmM0lkknSPem2rZCrFXlprHYlifS2dgzOtkh5GXlvdeHDaTQ8jwIdyjA5CnF6PyTFmxk+VW5sBj4b8OTIprYG1Nhxv0drgKMcoOeY25G/W6sbUn10pBVt467Dah3Ls5DytNwDQNM1H/EHKMTcs/jjbyvO0TCbpDKZU9NpWSf66Nl7bKhfJQoTDkmOTs/mmr2P7xRCp1gE4idjWyjFqq+xkKGJcoVBbg4NXk/Q57vlBAQPgw3OMErEcr2tttnpNV5HnBwBHzeNdOUYBA+Dd94MM+R1Y8sEwLZ7Yr8cCGeLWMMyVY82TY5Zl4dhZ+8C0cVV35O9rpeNlOmrFMPlapPjDZpDHH83XW56mVXIc5XrzfZQr1yk5BsBJErZSjtHwB4f1A/azvaVyjPmNUUslAJfnWKvJqEWFLURiACXHVig0LcqBmZS2MuRnlVvyHLPxqhzL82oaXbe+TBI3HNqLOz/wW8CDDzZ83Vlqa6ih36shLjcppecaAKxjybEmAaplWa62Slpv3akEElWfv2ZqHpoWVQur/OfLBr8P6zGTK3PlOlMXqEyfh/jDnTgj5ZgNs3VoPRCIEhYMvwOBSLluM+AxOUbFOQf2bD85X0TFaDw0g7VVsrZ81eHKsRYJbG7IT8+1joSSYysUmuDj4Fc5Rp4fNl49x3JUueX0pRO4/eF7MXr8EPCBD9iOwnWYoWlRNTgBQwWm2bjVLUfBaQ1r++2A88R84+TYXKGCUjV4Vb3NDbBb3byY8s9TW0MNvekEMkk75GumHjs2Y6vGhvsy1GoPJ/5outYKTgtvilp4AQCrqoWjs62UYxTrcvy2VVL8YdPvUc2Tp7ZKznBfBkldg2FamG7iQ3mGCnM1ePUco0nZnQ3t4iuUhK6hN50gMz8AfRnW4+1ROUaeYwBclVuvUnMKTrH+Zz/Epcf32f8xPg6MjdV9ndPWQAED4NxzluUkJerBAwYKTgEAa7kpbuPglPmNZTNJSlZU8TJOnYLTWjRN48nVZr5jR6mlsgZ+GGryXHP8xihZwfAbf1BxzntbJSnHavHaVsmSjj20J0DXNW7r0GxiJfcco7ZKAO5pld6SY6Rc70woObZC+fAtl+DpD78Kb//Vbe1+K23HUY413/hYSxcFqDYD3R49x6itwcayMPqpu1DRqo/FRALYs6euesyZFkVrDQAyyQS6UvZ1a9Za6agUKWAAgLXZ1p5j5De2nGymtSkuBafLYQecZhMrmXJs0yAlxwBvbZVsHWZprXEGu715jpGa2MHLtOxSxfG3o+KczYDHadncX5eKTACADYPV5NhM6+TYalKtA0CNar3ZQKAF8hzraCg5Rqx4sh4CBsuyXJ5jlLAAnMTNXKEMo0mrG29rUD04HRtD194nkLSq/guG0VA9xpVjlBzjsPuuWYBKPgy1rBvwkByjtoZleGltoOB0OV4mVpIZfy1ZD7YONKlyOat6vXmOUVulg5Mca9xWydRRmkbrjeFVOcanZZPnKQBgXdWUf6rJxMrTfFI2xR+Ac8+VDQvFSmOvNvLX7WwoOUaseLhyrMlBKF82UKkmgChgsGHVNMtqrrCgCT6wL9KePbASS65BA/UYGfIvxzHlb3yf5qitoQbW1nBqobEp7ikenFLlluGltcFRjin8XFvCag8TK4/N5AAAG0k5BsCbmoeZM5Nq3WHQq+cYxR8cR6XYOF6bzdvXs78rBb06mER1vBryk0qxFmbK36yt8gy1VdbQm06C3XZNC8HcQoTWWidCyTFixeMpOK0ekhK6RkFWlVRC59euWfWWVTiUrtyOjQHj49CMJRXbBuoxFoStIuUYh5niNgtQWXBKyjGb1b1pJHUNpuUoxJZCybHl9HswSafgdDlcOdakrXKy2mKzgZJjALx5npJybDl8WnaT2MM0LZdynfYEL8OnyG9sOUy1vtByIBAp192s556nrZXrq2laJQDbq42dq5oVghfI87SjoeQYseLxMt7a8RtLQtOomsZgAVQzU1zlp1VWVWPQGzwOdX2ZeowM+ZfT78H3gwWnpByz0XUNI1UvseMNWispObYcb22VFJwuZXW1+n+mWVtl1XOMlGM2fqZVUnLMgU2rbJYcK1ScYpTSxbkqXmJdsnRYTm2XRBPleomU625YcmyyQVulaVpc+bma2io5jnK9WXGO2TrQc60ToeQYseJhAWexYqLUoMd7jvzG6sInRjVpbWCVW2UVd6UScOQIYDbwDzBNYGLCfh2AQtng12ywl9Ybg3uONUnELpJybBkj/c2rt9PzVc+xLAWnDG/BKRnyL4WZKp9qkBzLlSo8cUaeYzZePE9ZQYDaKh1Y7NGsrZK1VAKUHAMcg/SJM7mGZt+kHFtOOqnz9dOoOGeYjkcUGfLbrK96jjWKPWbzjl/xKrIQ4XgpznF/XYo/OhL6qxErHvfDZbFYQTq5/CHtBKe0pN2wANVLq5uyyrFMxm6dnJ4GAHz7yUnc8/ABXLttNfb814vs14yM2K+Dcy0TukbTyVw4E6OaeY5VlWOqrrU6rKsmx07Ok3LMK2TIH4zVLaZVTlZVY9lMkg7fVbIePE9JObYcFnsUKyYKZQNddRISLPboSunknwVg81AvErqGxZKBk/NF7knphinH6P6spb87iXzZwGy+jNE6n2eqdYAM+RnrXQOBKoaJZKJWL8MGt/R3JZFOkpaG0d/C89SyLCrOdTj0VyNWPKmEjq6UjkLZxEKxglV1jCFpUmV9nHHqXgz5FX4cjI7a/wBkezfh6ec1VLJZ4Iorlr2UVcIHulPUwuuiv5v5MLRWjim91pawroXvByXHlpPtap2I5cEpJSw4rDWmUVvlUZpUuQwvPlBOcoziD0ZfJomkrqFSbc1iKhU3NKmylnRSx+iqbhw6ncOB6YW6yTFSjtVnoDuFE3PFhoVglohN6BrSCUr0AHZMwe7R6YXisnv0NMUedcm2aLUvlE0w6zsqznUm9FcjOoK+TAqFcrFhpt7tOUY4DPTUN8WdmJ3AdM5WSp0qPouiVsHB2X6YyV4AwEjvCDb1b5L7ZlcIW1bb1+DwmUVYlrUsAUaeH/XhbZVNJ6PSeOuljPQ39hyzLIsnx9ZQgMppFZwCTlsDTat0YG2VpxdKdZ9tzG+MzPgdvPhAzZNyfRmapmGwJ4VTCyWcXSzXT45RsWQZ29b04dDpHF6cXsT124eXfZ4lfyj+qKWVrUPONRWVipo2uq5hbX8Xjs3kMTlTWHaP0qTK+rRSri+6VYqU+O9IaEciOoJsVxKnFooNq7dcOUbVtBr4xKi8oxQoVorY+fmdOLF4wnlhF3Drfc5/rutbh0PvPYRMUr0D+cbBbiR0DYWyWbe1gfm3DdJaq4Eb8pNyzBe8rXJueavbYslAoWz7pJDnmIOntsoCTatcCmurLBkm5ouVZUrrSTLjX0bWh3Ksn5JjNQz2pHFqoVQTf7hhiX9KKjpsX9OL7z8HHJheqPt5Uo7Vh12PRsqxRbJ0qMuGQTs5Vk+5zrwpyYy/llbDp9xrjdrFOxPSlhIdQR83xa3/MCLPsfpwzzGXciydSGPzwGboDW5/HTpG+0eRTqi5IaaTOjfGPXRqcdnnmXKMDEprcSq3rT3HKGHhwJKv9ZRjp+btw2N3KkEJRRfckL/BfgDQtMp6dKUSfBjGmYXlCYtj1Fa5jL6MvdYWipWGJuksEcteS9jw4lwDW4dnp+YAAOevy0p7TyudbWv6AAAvTi+PPQB3cY7iDzcDLRIWrIWXYo9a1lXVYlN1JlayPWKoV70ieTNaFeco9uh8KDlGdAStWhtYWwN5jtXCPcdc1TRN03DnTXfCRP3pjCZM3HnTnUpLz8/hrZW5ZZ9j13KA2hpq4J5jDYJT07SQKys+/KEOLDl2ol5yjHl+kGqsBk/TosgQty68tXJxuVLxGCnHlsE8xwzT4gfspVBbZX0Ge5p7nj47NQ8AuGh9v7T3tNLZNmzHHi+eaq4coy6JWvo9Ksco9qiFmfJP1VGOsT1imJRjNWRbWIgsFmkqe6cjPDlmGAb27NmDrVu3oru7G9u3b8edd97ZsOIGAA899BA0TVv27/jx46LfHtGhtDLFZWoVCk5rcTzHalUCu7fvxs4NO5HQah/eCS2BnRt2Yvf23dLe40pk81APAODw6eXV27NUua3LQIu2ykLFgMVNSiloYDBD/vlCpWaiFkBm/I1wJ8fqxRamafEWXqre1sL8Y06RcswTPakEWJ2o0cRKmlZZn1XV+ONsrn5bJVOOXUjJMQ5Tjh09m0ehTjJ2hjzH6uLYOtS/R5m/HSnHalnfZCDQafIcq4tXzzGKPToX4cmxv/zLv8TnPvc5/M3f/A2effZZ/OVf/iU+9rGP4TOf+UzLr33++ecxNTXF/42MjIh+e0SHwh5G9VpBAJdyjKppNTieY7UJC6YeM6za4MuwDOVVY4BLOXZ6uXJslrdV0lpz099igiAzxNU0oCtJyTFGXybJK4xLA9Tp6vOOkmO1sMqtYVrck81NznWoJOVYLcMNJlaWDZO39m4i5RhH1zVHuV6nOGeaFhZKNK2yHoMNinMAkCtVcLBafKLkmMNwXxrZriQsq3n8QcmxWpjfX0PlWIlU6/VgybHJOm2VbFrlaoo/auC2Di08xyg51rkIT4795Cc/wS233IJXv/rVOOecc/D6178eu3fvxqOPPtrya0dGRrBu3Tr+T9ep65OwOX+t7Unx1ORs3c/PkSFuXVhbw2ydtobd23djtO8lgGXfZ6Qac9i8minHlgenXDlGwWkNLDG9UKygYtRJWFSl5j0pMildytoB1lpZ2+rGPMcoOVZLbzoBtoTqBagsONU1oCtFcYSb1b1sYmXtWjs+W4BpAemETuttCVnmeVon8b9QqnBFLCnHamnWVvnc8XlYFrAmm8GaLK03hqZpLt+x2tZKy7LIkL8BrQz5aVJ2fdiEynrKMVZAWU3KsRpaKse4ty6ttU5FeNR4/fXX43vf+x5eeOEFAMCTTz6JH//4x/j1X//1ll972WWXYf369fi1X/s1/Od//mfT1xaLRczNzdX8I+LL5ZtXAQB+fmSmbhsNeY7Vh1du8+Vl103TNFzQ/TZAsxMZpBpzYMqxQ6cXl123GV65pYDBjftgWC9oYFLzHqqmLWNttr7vGGurXEOeHzVomqPmqadUdBvi0vOslqG++m2VbFLl+sEuSl4voZmtA3vWpRM6ulJ0GHLDhtacrZMce2aSWiobsZ37jtXaOiyWDFRMOx4hW4daWhnyc+VYiuIPN+sHnNhjaVHz9AJNq6xHP1eONUqOkaVDpyM8Ofa///f/xn//7/8dF1xwAVKpFC6//HLcdttteNOb3tTwa9avX4977rkH9913H+677z6Mjo7ixhtvxBNPPNHwa+666y4MDAzwf6Ojo6J/FWIF8ZKNA0joGk7OF+saRzqeY5Qcc8MCBsO0lgX2lmXh5PT5SJvnAgCpxlwwz7H5QmVZ1XuWPD/qkkrofEx6vQCV+WnRKPXlrBuonxxjwekwKSuW0ay1gcz4G8NUAEvbKsmMvzHsMHRqYfkQAzLjbwyflp1f3lbJ/MbIjH8520ds5diBk7XKMRZ72IlYUsS6aWXIzydlk3KshuG+DJK6BtMCpl3PN8O0cCZHnmP1YB1KjQ35Kf7odIQ/Xb/61a/iH//xH/FP//RPeOKJJ3DvvffiE5/4BO69996GX3P++efjne98J6688kpcf/31+OIXv4jrr78en/rUpxp+zR133IHZ2Vn+b2JiQvSvQqwgutMJXFAd9713YmbZ5x3PMXoYuelKJXgQtTTJc/h0DjP5CtaYv4MLVl+Ij77yo6SyqNKdTmBtv52QWDqxkrVVriLl2DK471gdU1xWTeshQ9xlsImVxxsox6jNbTnNWhtolHpjhhtMq+Rm/JQcW8YlGwcAAOOHziz7HJnxN2aQG/IvP0Q6ZvxZqe+pE2ATKw8sUY4x77aBnhTFaksYaGHInyPPsbrousbjj8kZJ/6YyZV4u/gQxbo1ZF3KsXqdTAtkyN/xCE+O/dEf/RFXj73kJS/B//gf/wPve9/7cNddd/n6PldffTX279/f8POZTAb9/f01/4h4c9noIIDlybGKYXLJNCnHlsPk90srauw67lz/cjz7+89g17Zdst/aimbLEDPlXxqgkudHI5q1NuRKNN66ESwR26itkpJjy2nW2sASsVS5XQ5TAZxeaKAco0mVy7h222oAwCMHTi/7nKMco/1gKSz2WGrIb5oWnjs+DwC4eAPF7ktxe465D9/kN9aYfte07HoJi0WaVtmQDYPLJ1aySZWDPSkkE6RSdMMKIYZpIV9noix5jnU+wld8LpdbZqSfSCRgmssNmpuxd+9erF+/XuRbIzoclhz7+ZGzNR93twtS9XY5zsSo2oQFu47suhK1bKljyp8vGShW7GcZtVUuhyk35+q0NuTIc6wh6/obGPLzaZVUuV2KoxxbvtYWivbHKDm2HOYfc5raKj1z7bYhaBpwYHpxWQKblGONWdXrxB7uhMXhMznkSgYySZ37exIOW1b3QNPsteX2BuSTKik5tgyWMCwZZt0JxnmydWjIuqop/5RrYiX3G6OWymX0pBNIVH056xXncuQ51vEIT4695jWvwZ//+Z/jO9/5Dg4dOoRvfOMb+OQnP4nXvva1/DV33HEH3vzmN/P/vvvuu/Gtb30L+/fvx1NPPYXbbrsN3//+9/Ge97xH9NsjOhhmyv/LY7Mou4wjmYy6O5VAiiocy2BBw8wS3w+mHGPXlaiFJccOuZRj7BomdY0O3nVgap56vh/ZHz+MB77wblz5wmOy39aKZ6R/eeW2UDZ44p88x5bTvK2SBad0EFoKUyGeWSzBNJ2EBbVVNmawJ80VTj99sVY9xgZC0H6wHGY9UFniecrM+M9flyVVSh26Uglsqio43RMrSTnWmF5XwqKecp0px8jWYTnMlH+qRjlmF+rYdGPCwT0QqH5xjtoqOx3hu9JnPvMZvP71r8f//J//ExdeeCH+3//3/8U73/lO3Hnnnfw1U1NTOHLkCP/vUqmEP/zDP8RLXvISvPzlL8eTTz6JBx98EK985StFvz2ig9k23ItsVxKFsonnq5J8wNkIyW+sPjw55lKOFcoGnql6flxOyrG6bKlWtI+4lGNnFx0zfvL8WE5/o7ZKy8Klf/uXOPf0BF77tb8F6rQ9qAwz5D85X+AJi+l5OzhNJ3VkKchahhdDfgpOl8MSFoZp8cO2ZVnUVtmC66qtlT/ZX5scWyjQMKBGdKUSyCSXe56SGX9rtg1XWytPuYtz1eQYqdaXoWkaN0qvV5xjqqg+Unguw0mOOcoxNrCFJlXWJ8tN+RtPZqfiXOciPDmWzWZx99134/Dhw8jn8zhw4AA+8pGPIJ12brAvfelLeOihh/h/33777di/fz/y+TxOnz6NH/zgB7jppptEvzWiw9F1zWmtdPmOzZHnR1OciVFOwPD05BzKhoXVvWleoSRq4W2VLkN+phwbJIPSuvApPktNccfGMPL8LwEAmw88DYyNyX5rK5o1VTVP2bD4wAfmN7amL0OJ2Do0DU5pWlRD0kmd36estfL0YgnFiglNA9YP0H5Qj+u3DwMAHlmiHKNplc1hydh6ybELKTnWkG1r7OIcKce8M+DyHXPz7NQcnjo2h6Su4dptQ+14ayuaesox1s5Lkyrr48XzlPztOhfSMxMdBVM57T0ywz/GHk79FJzWZbBnuSmu01I5SAfvBjBD/un5Ij9sk+dHc+oa8lsWsGcPzKoXpanrwJ49pB5zkU7q3FeMTawkv7HmZLtSuOHQXrzrf74GePDBms9RW0NzVrOJldUELGupHMlmkE5SWFiPnVuHkNA1HDmTw9GzTsGE4o/mOBMrnfiDqdYvIjP+hmyvmvIfmHYpx3j8QXtCPZhyfaly7J8ftTuVdl+8FiPZLunva6XDCiJuW4czrK2ShgHVhRfn6qgUqTjX+VAURHQUl20eBAD8fMIx5WcPJ1KO1adeWyWZ8bdmoCfFA/sjVfUYG0lPyrH69Ner3I6NAePj0KtDWXTTBMbHST22BDZO/WTVlJ8mVTYnm0ng9ofvxbpjB4EPfKAm2UrBaXOYyTJTjpEZf2v6Mkm8dNMAgNqplTStsjl8IFB1Tzi7WOIKlQvWZdv2vlY69ZRjc1w5Rs+1egzUSY7lShV844ljAIA3Xr25Le9rpcOUYyfmCqhU/ZxPU3GuKdmmyjEqznU6lBwjOopLNw0CAF6cXuQqHl65JTVPXZYGpwCZ8XuF+Y4drpryO22VtNbqwaTmvNWNq8aWeC8kEqQeWwJLjnHl2Dwlx5qx7ef/iUuP77P/Y0my1WlrIM+PeiydWMmUYxsoOdYU5jtWmxyjaZXNWLVEuc5aKkeHuimh2ASmHJs4m0epOiGbbB2aw+MPV6z7b09OYb5YweahHtxQbY0mahnuyyCpazAtYLpalGN7A7VV1qe/6bRs8hzrdCg5RnQUq/sy3Atq79EZAG7PMQpO68Ek+CyZOD1fxNGzeWgaeCWcqM+WoarvWNWUf4baKpvChmLwyi1XjRm1LzQMUo8tYe2SiZVcOZal4HQZloVLPvcJVDQ7hLGWJFuprbI5Q71L2irJjN8Tbt8xq7rW5smQvym8OFfdO58hM35PjGQz6E0nYJgWjpyxi3PkOdYcp63SUfP8Y7Wl8o1Xb4auk4VIPXRd4/HH5Iwdf7C9gaZV1qfRtGzLspArsWnZFH90KpQcIzqOy5b4jjmeHxQw1MNRjtmVIKYa27GmjwL6FpxTTcQe4skx+xquompaXWoqt0w11sjTjrzHaljbbwehJ+eXeo5RcLqMsTH0P7UXSctWVGhLkq3UVtkc1irDWmdYcmwTKceacuWWVUgndEzNFvieQMW55jCV01muHLMnjZMZf3M0TcO2Jb5jLMFI0yrrs9Tz9OnJWTw5MYNUQsNvXrWpnW9txbNhsLY4R9Mqm9NoWnaxYqJSnThOybHOhZJjRMfBTfmrvmOO5xg9iOqx1HOMXbfLq/5tRGM2V9sqWeWWB6dUua1Lvzs4LZVgHDoMvVHyyzSBiQmgVKr/ecVYt0Q5Nk2eY/WpJl2RqG1ZMHQd1p/+KWBZXDnWR3tCXZjn2JklbZWkHGtOdzrBfU9ZayW1VTZnFSnHAuP4jpFyzAtLleuOEf862kdbsK5qyj81m0fFMLm/7moqBNeFrbUnjszgl0dnuZKYFeYAoCdFbZWdCu3mRMdxWdUna+/EDCzLIs+xFrg9xyzL4sqxy0bJb6wVXDl2qratchV5ftTFGaVeATIZ7PmTL+LJn+/HpZsG8eevvWT5ZNSRESBDQSsArOWmuGTI35Rqq+5SEqYJPPYYMDaGxZK9DqlyW5+h6po6tbStcrCnbe+pU7h++2o8evAMfnLgFH77ms1kyN8CZuswkyuhVDGx/yQpx7yybdhWjr04vQDDdGJdsnWoj9uQf7FYwTd/PgkAeBMZ8beEmfJPzRZ4YkzTyN+uEcwT8JfHZvGav/kxLliXxRuuGsVV59jnqq6UjmSC9EedCkWORMdx4fos0gkdZ3NlHD6d4xJqGqVeH7a5lSomFksGnpyYBUCTKr2wuZocm5rNo1gxyJC/ERMTwPQ0BvMVXHx8PwDg8W+k8OTP9yOha/i9W6+BdsUFbX6TK5u1WWdiFOAY8q8hzzEHphrTdVt5uAQTGs6873ZMveG/YzLzOfxi+m9wxeb/1oY3urIZdk2rXChWuNKCtdYQjblu22rcjX346YunYZqOSpGUY/Vhe+XZXBn7Ty6gbFjIdiWxiVSKLdk+YivHDkwv1JjMUyG4Pm5bh28/OYmFYgXnrO7BddtXt/mdrXyc5Fgepxft2GOoJ40E+bTV5ZUXrsU/vf0a/N9HJ/Ddp4/juePz+PC/PQNW/yVLh86G/npEx5FJJnDxxn78/MgM9k7MkOdYC3rTCSR1DRXTwuOHz2KhWEFPOoHz1va1+62teNb0ZdCTTiBXMnD0bJ5X1KitwUWxCOzcCZw4gSyA77CP3+v6//+xDjh0iFRiTVhXDU5ZwoJN/CTlmItSCThypG5iDAB0WDCPHMGJ8t+jnJ7A3eMfxluueM1yxaLirK6uqTOLJd5S2d+VJPWTBy7bPIiulI5TCyU8eXQGVXsZSo41gBXnZvNlPqnywvX9dE96gCvHTi3yaeN9mSRSpEipi1s59k8uI35aa61xK8fOLNCkSi9cv30Y128fxmyujG89eQxffWwCTx2zn3F0RuhsaDcnOpLLRgfx8yMz+PmRs2SI2wJN0zDYk8KphRIeev4kAOAlGwdI8usBTdOweagHzx2fx+HTi3ziJxnyu0ingc2bgenpukkLS9ehjY7aryMasqonhXRCR8kw+SEyldAoyHKTydgtldPTyz5lWRb+5gf78feHHsVC+pMAgCdPPI6xA2O4ecfNst/pioYdes7mSjhyxm4Z37iKWiq9kEkmcNWWIfx4/ymMPXMCAJDQNXSTv0xdVnHlWIk/18hvzBtbh23l2EyujEOnbN8x2g8aw67Ni9OLKBkm0gkdr7+SjPi9sJ55js0UcIrM+H0x0JPCm687B2++7hw8PTmLf//lFHaeM9Tut0WEgLIJREfCJ1a6lWMUNDRkoJslx+xD5WVkxu+Zc1b34rnj83h2ah4lw07+kOeHC00D7rwTeNWr6n/aNO3PU/W2KZqmYaQ/g6Nn83j6mN36vLo3Q1XvpYyO2v+WoAF416WX4f98/P8ARR3QTCS0BPb8YA92b99N19HFqp4UNM3uUn2qutY20qRKz1y3fbWdHHv6OAC7MEfrqz5u5dhTk/Zau3B9tp1vqWPoTiewcbAbx2by+PkRe5ASJccaw84ALE67+ZJ1XCVLNIcpx07OF3Cyau2wupeunV8u3jCAizcMtPttECEh6QjRkVxRNeV/ZmqO+6WQcqwxLEA9WK0+Xk5m/J7ZUvUde7I6yCCd0NGTJpVADbt3262VSyYIWomE/fHdu9v0xjoLNrHyqUlbYTFMfmO++P6hB3G69Cyg2YcjwzIwPjmOsQNjbX5nK4tkQudDRX5ZTY6RB5R3rq96GB2oThGk2KMxLJljWcDPj8wAAC5aT4dHr7CJlU9Urx35nTZmaeLwt8mI3zPDfRkkdQ2mBTx33B6aQcoxQlUoOUZ0JJtWdWN1bxplw4JRNf0gz7HGLFU6XU7KMc9sWW0Hp08enQFgS6hJJbAEph4zjNoPGwapxnywliXHXMoxwhuWZWHPD/YgodUmaJl6jI1aJ2xYa+Uvqs81Uo555yUbB2oMl7MZij0akU7q/FoVKyYSuoZzye/UM9uqrZVsyjgpxxrjTlJvW9OLa7dRa5tXdF1bFn+Q5xihKpQcIzoSTdNqEjwJXSM1TxMGXNXGDQNdfBMkWsOUYyfm7Ak+q6hyW5+qesxi6jFSjfmG3Zf7Ty4AIDN+P4wdGMP45DgMqzZBS+qx+qyuHnxOVc2XN1ByzDPJhI6rtzoHb1KONced0Nm+phdd5M/mmW1r7EQim4pKyrHGpBI6eqvngN8mI37fsGnF+6rxB7WkEqpCyTGiY2G+YwB5frRisDuNvL4Xk5l3Y3j4+Xa/nY6CJccYg91UTatLVT2mMfUYqcZ8s7bfDkYrVTUstVV6g6nG9AYhjQ6d1GNLWJp43Uhtlb64bttq/v9pymdzVvU61+dCMuP3xfY1tSo78tZtzqtfuh7nr82SEX8A1lVN+Vk3zmpSjhGKQuUuomO5zOWbRZXb5gx0JzGTuhdlfQK/mL8HlvVuSiZ6ZP1AN1IJDWXDDhgGqHLbGOY9Nj5OqrEArBuoVXSuocqtJ0pGCUdmj8DE8mmpAGDCxMTcBEpGCZkkXVNgecsMtVX647rtTnKsn+KPpjB/O4CSY35hnmMMKs4152Ovv7Tdb6FjWb8k/qDkGKEqtKMTHctLRwf4xC3yG2vO0fwjKOn7AACH53+JsQNjuHnHzW1+V51BQtcwOtSDF6vmy9RW2QRNAz76UeB//S/7fykB64uRbG1wSm2V3sgkMxh/+zimc9MNXzPSO0KJMRdus+VMUscwmS/74qL1/RjoTmE2X6biXAvcbZUXUXLMF+v6u9CdSiBfthXZ5DlGRMWy5BjtCYSi0I5OdCz9XSnsWNOHfScXKDhtgmVZ+OaLnwIsHdBMblC9e/tuUo95ZIsrOTbYQwFDU3btAp55pt3voiNZqhyj5Jh3RgdGMTow2u630TG4/WQ2DnbTXuATXddw7bYh3P/0CWp1awEpx4Kj6xq2DvfimSl7gjF5jhFRsVw5RvEHoSbkOUZ0NMx3jJRjjRk7MIb9M08Cmt1yRAbV/mETKwEKTonoYJ5jDPIcI6LC3TJDfmPBePeNO/DKC0Zwy2Ub2v1WVjRMbb0mm8GaLB24/eJurSTlGBEV6wecfSCha7TWCGWh5BjR0bzywhEAwAXrsm1+JysTZlSd0GqnQzH1GBlUe2PL6h4+0ODo4qPtfjtETOlJJ2tUsKQcI6LCnRzbMEDJsSBcNjqIv/+dndgxQvFHM5i/HbVUBmOby5SfEhZEVLiVY6t60tB1UhMTakLJMaKjufnidfjR7Tfhtl3ntfutrEjGDoxhfHIchmXUfJzUY/7YMtTDBxp8bf/HKKlIRMa6/i6eiH38+A/b/XaImFLTVknKMSJC/stL1+PWyzfif71yR7vfSkeynZRjhASG+zJIVhNiZMZPqAwlx4iORtNss3SqcCyHqcb0Bre5Dp3UYx45nHMGGuybeZKSikRkjGQzPBG75wd/QvcnEQk1bZU0qZKIkJFsFz75W5fhyi1D7X4rHcl2l3KMbB2IqNB1DWv7bfUYmfETKkPJMYKIKSWjhCOzR2DCrPt5EyYm5iZQMkqS31lnYVkWPvv4n9sDDQDo1JJKREgh8XOeiCV1JxEVA90pJKpFJVKOEcTKZfuaPqzqSWHjYDf6MjR8ioiODYMsOUaWDoS60FOWIGJKJpnB+NvHMZ2bbviakd4RZJK0CTZj7MAYHp96DKiKE01XS+rNO25u75sjYoVlWXj0zN/SZFkicnRdwyUbB7D/xDx5dhLECqY7ncCD7385ErpG+wARKesGugGcpbZKQmkoOUYQMWZ0YBSjA6Ptfhsdi3uggdu3jZIWRBSMHRjD0cWneCLWoEQsESH/8o5rkS8ZGOyhgxBBrGRIyUPI4PLRQXz7yUlcvIGGZxDqQm2VBEEQDaCBBoQsaLIsIZuuVAKrSCFAEARBAHjrDefgJ//7FfjNq6ioTqgLJccIgiDqQAMNCJlQIpYgCIIgiHahaRo20IAWQnEoOUYQBFEHGmhAyIISsQRBEARBEATRXshzjCAIog400ICQhZ9ELK03giAIgiAIghAPJccIgiAaQAMNCBlQIpYgCIIgCIIg2gslxwiCIAiizVAiliAIgiAIgiDaB3mOEQRBEARBEARBEARBEMpCyTGCIAiCIAiCIAiCIAhCWSg5RhAEQRAEQRAEQRAEQSgLJccIgiAIgiAIgiAIgiAIZaHkGEEQBEEQBEEQBEEQBKEslBwjCIIgCIIgCIIgCIIglIWSYwRBEARBEARBEARBEISyUHKMIAiCIAiCIAiCIAiCUBZKjhEEQRAEQRAEQRAEQRDKQskxgiAIgiAIgiAIgiAIQlkoOUYQBEEQBEEQBEEQBEEoCyXHCIIgCIIgCIIgCIIgCGWh5BhBEARBEARBEARBEAShLMl2vwFRWJYFAJibm2vzOyEIgiAIgiAIgiAIgiDaCcsPsXxRM2KTHJufnwcAjI6OtvmdEARBEARBEARBEARBECuB+fl5DAwMNH2NZnlJoXUApmlicnIS2WwWmqa1++2EZm5uDqOjo5iYmEB/f3+73w4RY2itETKgdUbIgtYaIQNaZ4QsaK0RMqB1RshC9lqzLAvz8/PYsGEDdL25q1hslGO6rmPTpk3tfhvC6e/vpwcUIQVaa4QMaJ0RsqC1RsiA1hkhC1prhAxonRGykLnWWinGGGTITxAEQRAEQRAEQRAEQSgLJccIgiAIgiAIgiAIgiAIZaHk2Aolk8ngz/7sz5DJZNr9VoiYQ2uNkAGtM0IWtNYIGdA6I2RBa42QAa0zQhYrea3FxpCfIAiCIAiCIAiCIAiCIPxCyjGCIAiCIAiCIAiCIAhCWSg5RhAEQRAEQRAEQRAEQSgLJccIgiAIgiAIgiAIgiAIZaHkGEEQBEEQBEEQBEEQBKEslBwjCIIgCIIgCIIgCIIglIWSYyuUz372szjnnHPQ1dWFa665Bo8++mi73xLRwdx1113YuXMnstksRkZG8Bu/8Rt4/vnna15z4403QtO0mn/vete72vSOiU7lQx/60LJ1dMEFF/DPFwoFvOc978Hq1avR19eH173udThx4kQb3zHRiZxzzjnL1pmmaXjPe94DgJ5nRHB++MMf4jWveQ02bNgATdPwzW9+s+bzlmXhgx/8INavX4/u7m7s2rUL+/btq3nNmTNn8KY3vQn9/f0YHBzE7/3e72FhYUHib0GsdJqts3K5jD/+4z/GS17yEvT29mLDhg1485vfjMnJyZrvUe85+Bd/8ReSfxNipdPqmfY7v/M7y9bRq171qprX0DONaEWrdVYvZtM0DR//+Mf5a1bCM42SYyuQf/mXf8H73/9+/Nmf/RmeeOIJXHrppbj55ptx8uTJdr81okN5+OGH8Z73vAc//elP8cADD6BcLmP37t1YXFysed3b3/52TE1N8X8f+9jH2vSOiU7m4osvrllHP/7xj/nn3ve+9+Hb3/42/vVf/xUPP/wwJicnceutt7bx3RKdyPj4eM0ae+CBBwAAv/mbv8lfQ88zIgiLi4u49NJL8dnPfrbu5z/2sY/h05/+NO655x787Gc/Q29vL26++WYUCgX+mje96U14+umn8cADD+Df/u3f8MMf/hDveMc7ZP0KRAfQbJ3lcjk88cQT2LNnD5544gl8/etfx/PPP4//9t/+27LXfvjDH655zv3BH/yBjLdPdBCtnmkA8KpXvapmHf3zP/9zzefpmUa0otU6c6+vqakpfPGLX4SmaXjd615X87q2P9MsYsVx9dVXW+95z3v4fxuGYW3YsMG666672viuiDhx8uRJC4D18MMP84+9/OUvt9773ve2700RseDP/uzPrEsvvbTu52ZmZqxUKmX967/+K//Ys88+awGwHnnkEUnvkIgj733ve63t27dbpmlalkXPM0IMAKxvfOMb/L9N07TWrVtnffzjH+cfm5mZsTKZjPXP//zPlmVZ1jPPPGMBsMbHx/lr/uM//sPSNM06duyYtPdOdA5L11k9Hn30UQuAdfjwYf6xLVu2WJ/61KeifXNErKi31t7ylrdYt9xyS8OvoWca4Rcvz7RbbrnFesUrXlHzsZXwTCPl2AqjVCrh8ccfx65du/jHdF3Hrl278Mgjj7TxnRFxYnZ2FgAwNDRU8/F//Md/xPDwMC655BLccccdyOVy7Xh7RIezb98+bNiwAdu2bcOb3vQmHDlyBADw+OOPo1wu1zzfLrjgAmzevJmeb0RgSqUSvvKVr+B3f/d3oWka/zg9zwjRHDx4EMePH695hg0MDOCaa67hz7BHHnkEg4ODuOqqq/hrdu3aBV3X8bOf/Uz6eybiwezsLDRNw+DgYM3H/+Iv/gKrV6/G5Zdfjo9//OOoVCrteYNER/PQQw9hZGQE559/Pt797nfj9OnT/HP0TCNEc+LECXznO9/B7/3e7y37XLufaUmpP41oyalTp2AYBtauXVvz8bVr1+K5555r07si4oRpmrjttttwww034JJLLuEf/+3f/m1s2bIFGzZswC9+8Qv88R//MZ5//nl8/etf//+3d38hTfV/HMDfv6abi7bl0XSzcCyt8MIFLVy7SIhBuSLoH+koWFIS5Ioc/aFAQoi6KoIuqgtb3XhRFxV4E6kLgpYXxghvRhumRFsXxiorSdvnufjhfgx79Pf0WGdz7xcI43u+Rz4HDu/z5bOdc1SslvKN0+nEnTt3sG7dOiQSCXR1dWHz5s0YHh5GMpmEVqudtbivrKxEMplUp2DKew8fPkQqlcKhQ4cyY8wz+h1mcupna7SZbclkEhUVFVnbi4qKoCgKc45+yeTkJM6ePQuv1wuj0ZgZP3HiBDZs2ABFUfD8+XOcO3cOiUQCV69eVbFayjdNTU3Ys2cPbDYb4vE4zp8/D4/Hg3A4DI1Gw0yjBXf37l0YDIZZj1XJhUxjc4yowLS3t2N4eDjrOVAAsp4dUF9fD4vFArfbjXg8jpqamj9dJuUpj8eT+Wy32+F0OmG1WnHv3j3o9XoVK6PFqru7Gx6PB1VVVZkx5hkRLQZTU1PYv38/RAQ3btzI2hYIBDKf7XY7tFotjh49isuXL0On0/3pUilPtbS0ZD7X19fDbrejpqYGT58+hdvtVrEyWqxu376NAwcOoKSkJGs8FzKNt1XmmPLycmg0mllvb3v//j3MZrNKVdFi4ff70dvbi1AohFWrVs051+l0AgBisdifKI0WqeXLl2Pt2rWIxWIwm834/v07UqlU1hzmG/2q0dFR9PX14ciRI3POY57RQpjJqbnWaGazedYLlKanp/HhwwfmHP0jM42x0dFRPHnyJOtXYz/jdDoxPT2NN2/e/JkCaVFavXo1ysvLM9dLZhotpGfPniEajc67bgPUyTQ2x3KMVquFw+FAf39/ZiydTqO/vx8ul0vFyiifiQj8fj8ePHiAgYEB2Gy2efeJRCIAAIvF8puro8VsYmIC8XgcFosFDocDxcXFWfkWjUYxNjbGfKNfEgwGUVFRgR07dsw5j3lGC8Fms8FsNmdl2KdPnzA4OJjJMJfLhVQqhaGhocycgYEBpNPpTJOWaD4zjbHXr1+jr68PZWVl8+4TiUSwZMmSWbfAEf0Tb9++xfj4eOZ6yUyjhdTd3Q2Hw4H169fPO1eNTONtlTkoEAjA5/Nh48aNaGhowLVr1/Dlyxe0traqXRrlqfb2dvT09ODRo0cwGAyZZwSYTCbo9XrE43H09PRg+/btKCsrw6tXr9DR0YHGxkbY7XaVq6d8curUKezcuRNWqxXv3r3DhQsXoNFo4PV6YTKZcPjwYQQCASiKAqPRiOPHj8PlcmHTpk1ql055Jp1OIxgMwufzoajof8sZ5hn9GxMTE1m/MBwZGUEkEoGiKKiursbJkydx8eJFrFmzBjabDZ2dnaiqqsKuXbsAAHV1dWhqakJbWxtu3ryJqakp+P1+tLS0ZN36S4VtrvPMYrFg3759ePnyJXp7e/Hjx4/Muk1RFGi1WoTDYQwODmLLli0wGAwIh8Po6OjAwYMHUVpaqtZhUQ6a61xTFAVdXV3Yu3cvzGYz4vE4zpw5g9raWmzbtg0AM43+P/NdO4H/fpl0//59XLlyZdb+OZNpqr4rk/7W9evXpbq6WrRarTQ0NMiLFy/ULonyGICf/gWDQRERGRsbk8bGRlEURXQ6ndTW1srp06fl48eP6hZOeae5uVksFototVpZuXKlNDc3SywWy2z/9u2bHDt2TEpLS2Xp0qWye/duSSQSKlZM+erx48cCQKLRaNY484z+jVAo9NPrpc/nExGRdDotnZ2dUllZKTqdTtxu96xzcHx8XLxeryxbtkyMRqO0trbK58+fVTgaylVznWcjIyN/u24LhUIiIjI0NCROp1NMJpOUlJRIXV2dXLp0SSYnJ9U9MMo5c51rX79+la1bt8qKFSukuLhYrFartLW1STKZzPofzDSaz3zXThGRW7duiV6vl1QqNWv/XMm0/4iI/PYOHBERERERERERUQ7iM8eIiIiIiIiIiKhgsTlGREREREREREQFi80xIiIiIiIiIiIqWGyOERERERERERFRwWJzjIiIiIiIiIiIChabY0REREREREREVLDYHCMiIiIiIiIiooLF5hgRERERERERERUsNseIiIiIiIiIiKhgsTlGREREREREREQFi80xIiIiIiIiIiIqWH8BStjhzM5Ft58AAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 1500x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(15,6))\n",
        "plt.cla()\n",
        "env_test.render()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(141.99621523872207, 0.0, 70.77291800898811, 0.0, 0.9722222222222222)"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# trade sequentially in the test set\n",
        "max_steps = len(eth_test)\n",
        "env_test = CustTradingEnv(df=eth_test, max_steps=max_steps, random_start=False, scaler=env.get_scaler())\n",
        "n_eval_episodes = 1\n",
        "\n",
        "evaluate_agent(env_test, max_steps, n_eval_episodes, model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_79018/796306373.py:132: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"go\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(open_buy, prices[open_buy], 'go', marker=\"^\")\n",
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_79018/796306373.py:133: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"go\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(close_buy, prices[close_buy], 'go', marker=\"v\")\n",
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_79018/796306373.py:134: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"ro\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(open_sell, prices[open_sell], 'ro', marker=\"v\")\n",
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_79018/796306373.py:135: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"ro\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(close_sell, prices[close_sell], 'ro', marker=\"^\")\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(15,6))\n",
        "plt.cla()\n",
        "env_test.render()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [],
      "source": [
        "# load model and scaler from file\n",
        "# max_steps = 20 \n",
        "# scaler_l = joblib.load(\"./alt/fin_rl_ppo_100_v1.h5_scaler\")\n",
        "# env_l = CustTradingEnv(df=eth_test, max_steps=max_steps, scaler=scaler_l, random_start=False)\n",
        "\n",
        "# model_l = PPO.load(\"./alt/ppo_tradeenv-100\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [],
      "source": [
        "# # trade sequentially the loaded model and env\n",
        "# max_steps = len(eth_test)\n",
        "# n_eval_episodes = 1\n",
        "# evaluate_agent(env_l, max_steps, n_eval_episodes, model_l)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [],
      "source": [
        "# plt.figure(figsize=(15,6))\n",
        "# plt.cla()\n",
        "# env_l.render()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [],
      "source": [
        "# This does 1000 episodes with random_starts of date trading for max 20 steps \n",
        "# max_steps = 20 \n",
        "# env_test_rand = CustTradingEnv(df=eth_test, max_steps=max_steps, random_start=True, scaler=env_l.get_scaler())\n",
        "# n_eval_episodes = 1000\n",
        "\n",
        "# evaluate_agent(env_test_rand, max_steps, n_eval_episodes, model_l)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.9.16 ('aivai')",
      "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.9.16"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "e0a9bccbe122e523b955ec22d341fa640296741eab9d9470e0d68ebe33390ade"
      }
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "01a2dbcb714e40148b41c761fcf43147": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "20b0f38ec3234ff28a62a286cd57b933": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "PasswordModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "PasswordModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "PasswordView",
            "continuous_update": true,
            "description": "Token:",
            "description_tooltip": null,
            "disabled": false,
            "layout": "IPY_MODEL_01a2dbcb714e40148b41c761fcf43147",
            "placeholder": "​",
            "style": "IPY_MODEL_90c874e91b304ee1a7ef147767ac00ce",
            "value": ""
          }
        },
        "270cbb5d6e9c4b1e9e2f39c8b3b0c15f": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "VBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "VBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "VBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_a02224a43d8d4af3bd31d326540d25da",
              "IPY_MODEL_20b0f38ec3234ff28a62a286cd57b933",
              "IPY_MODEL_f6c845330d6743c0b35c2c7ad834de77",
              "IPY_MODEL_f1675c09d16a4251b403f9c56255f168",
              "IPY_MODEL_c1a82965ae26479a98e4fdbde1e64ec2"
            ],
            "layout": "IPY_MODEL_3fa248114ac24656ba74923936a94d2d"
          }
        },
        "2dc5fa9aa3334dfcbdee9c238f2ef60b": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "3e753b0212644990b558c68853ff2041": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "3fa248114ac24656ba74923936a94d2d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": "center",
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": "flex",
            "flex": null,
            "flex_flow": "column",
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": "50%"
          }
        },
        "42d140b838b844819bc127afc1b7bc84": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "90c874e91b304ee1a7ef147767ac00ce": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "9d847f9a7d47458d8cd57d9b599e47c6": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a02224a43d8d4af3bd31d326540d25da": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_caef095934ec47bbb8b64eab22049284",
            "placeholder": "​",
            "style": "IPY_MODEL_2dc5fa9aa3334dfcbdee9c238f2ef60b",
            "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
          }
        },
        "a2cfb91cf66447d7899292854bd64a07": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "c1a82965ae26479a98e4fdbde1e64ec2": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9d847f9a7d47458d8cd57d9b599e47c6",
            "placeholder": "​",
            "style": "IPY_MODEL_42d140b838b844819bc127afc1b7bc84",
            "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
          }
        },
        "caef095934ec47bbb8b64eab22049284": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "eaba3f1de4444aabadfea2a3dadb1d80": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "ee4a21bedc504171ad09d205d634b528": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "f1675c09d16a4251b403f9c56255f168": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Login",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_a2cfb91cf66447d7899292854bd64a07",
            "style": "IPY_MODEL_ee4a21bedc504171ad09d205d634b528",
            "tooltip": ""
          }
        },
        "f6c845330d6743c0b35c2c7ad834de77": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "CheckboxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "CheckboxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "CheckboxView",
            "description": "Add token as git credential?",
            "description_tooltip": null,
            "disabled": false,
            "indent": true,
            "layout": "IPY_MODEL_3e753b0212644990b558c68853ff2041",
            "style": "IPY_MODEL_eaba3f1de4444aabadfea2a3dadb1d80",
            "value": true
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}