Adaptando Notebook de Markowitz para Risk Parity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bcaae9f6",
   "metadata": {},
   "source": [
    "# Teoria Moderna do Portfólio em Python\n",
    " _Baseado [nesse artigo do Medium](https://medium.com/turing-talks/teoria-moderna-do-portf%C3%B3lio-em-python-e8bad41ebb8b)_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b16ad005",
   "metadata": {},
   "source": [
    "# Risk Parity - Backtesting\n",
    "\n",
    "### Premissas\n",
    "\n",
    "- Capital inicial de R$100.000,00\n",
    "- Rebalanceamento a cada 3 meses de acordo com a estratégia de Risk Parity\n",
    "- Simular investimentos de 01/01/2021 até 01/07-2023\n",
    "- Sem custo de rebalanceamento\n",
    "- A cada rebalanceamento considerar os dados dos últimos 5 anos\n",
    "- Ativos:\n",
    "    - Bancos:  ITUB4.SA, SANB4.SA, BBAS3.SA, BBDC4.SA\n",
    "    - Energia: TRPL4.SA, EGIE3.SA, AESB3.SA\n",
    "    - Saneamento: SAPR11.SA, SBSP3.SA, CSMG3.SA\n",
    "\n",
    "### Algoritmo\n",
    "\n",
    "1. Gerar datas de rebalanceamento\n",
    "1. Para cada data de rebalanceamento\n",
    "    1. Calcular a melhor carteira de acordo com Risk Parity utilizando os dados dos últimos PW anos, armazenando-a\n",
    "    1. Simular retorno da carteira calculada até a próxima data de rebalanceamento, armazenando-a\n",
    "\n",
    "\n",
    "Parâmetros\n",
    "* PW: Past Window, período de tempo no passado que será utilizado para calcular o peso da carteira (ex: 5 anos)\n",
    "* RP: Rebalancing Period, período em que será feito o rebalanceamento (ex: 3 Meses)\n",
    "* Tickers: Ativos que irão compor a carteira\n",
    "* Start_date e End_date\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4164a49f",
   "metadata": {},
   "source": [
    "### Preliminares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2ea2e5c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import turingquant as tq\n",
    "import yfinance as yf\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "37cff1b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "tickers = ['ITUB4.SA', 'SANB4.SA', 'BBAS3.SA', 'BBDC4.SA',\n",
    "'TRPL4.SA', 'EGIE3.SA', 'AESB3.SA', \n",
    "'SAPR11.SA', 'SBSP3.SA', 'CSMG3.SA']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9ef22d29",
   "metadata": {},
   "outputs": [],
   "source": [
    "def matrix_seriation(retornos: pd.DataFrame):\n",
    "    matriz_cov = retornos.cov()\n",
    "    dendograma = sns.clustermap(matriz_cov, method='ward', metric='euclidean')\n",
    "    colunas_seriation = dendograma.dendrogram_col.reordered_ind\n",
    "    colunas_seriation = retornos.columns[colunas_seriation]\n",
    "    return (matriz_cov, colunas_seriation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2168315f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcula_pesos_hrp(matriz_cov, colunas_seriation):\n",
    "    # Inicialização de pesos\n",
    "    pesos = pd.Series(1, index=colunas_seriation)\n",
    "    paridades = [colunas_seriation]\n",
    "\n",
    "    while len(paridades) > 0:\n",
    "        # Instanciação de clusters\n",
    "        paridades = [cluster[inicio:fim] \n",
    "                     for cluster in paridades\n",
    "                      for inicio, fim in ((0, len(cluster) // 2),(len(cluster) // 2, len(cluster)))\n",
    "                        if len(cluster) > 1]\n",
    "\n",
    "        # Iteração entre paridades\n",
    "        for subcluster in range(0, len(paridades), 2):\n",
    "            \n",
    "            cluster_esquerdo = paridades[subcluster]\n",
    "            cluster_direito = paridades[subcluster + 1]\n",
    "            \n",
    "            matriz_cov_esquerda = matriz_cov[cluster_esquerdo].loc[cluster_esquerdo]\n",
    "            inversa_diagonal = 1 / np.diag(matriz_cov_esquerda.values)\n",
    "            pesos_cluster_esquerdo = inversa_diagonal / np.sum(inversa_diagonal)\n",
    "            vol_cluster_esquerdo = np.dot(pesos_cluster_esquerdo, np.dot(matriz_cov_esquerda, pesos_cluster_esquerdo))\n",
    "\n",
    "            matriz_cov_direita = matriz_cov[cluster_direito].loc[cluster_direito]\n",
    "            inversa_diagonal = 1 / np.diag(matriz_cov_direita.values)\n",
    "            pesos_cluster_direito = inversa_diagonal  / np.sum(inversa_diagonal)\n",
    "            vol_cluster_direito = np.dot(pesos_cluster_direito, np.dot(matriz_cov_direita, pesos_cluster_direito))\n",
    "\n",
    "            fator_alocacao = 1 - vol_cluster_esquerdo / (vol_cluster_esquerdo + vol_cluster_direito)\n",
    "\n",
    "            pesos[cluster_esquerdo] *= fator_alocacao\n",
    "            pesos[cluster_direito] *= 1 - fator_alocacao\n",
    "            \n",
    "    return pesos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be6bd1d1",
   "metadata": {},
   "source": [
    "#### Utilitários"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6df48ba2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import pandas as pd\n",
    "from typing import List\n",
    "import yfinance as yf\n",
    "from datetime import datetime, timedelta\n",
    "\n",
    "\n",
    "# Decorador para cronometrar tempo de execução\n",
    "# Não deve ser utilizado em funções recursivas\n",
    "def timer(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        start_time = time.perf_counter()\n",
    "        result = func(*args, **kwargs)\n",
    "        end_time = time.perf_counter()\n",
    "        execution_time = end_time - start_time\n",
    "        print(f\"Function '{func.__name__}' took {execution_time:.6f} seconds to execute.\")\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "class Params:\n",
    "    def __init__(self, tickers: List[str], start_date: str, end_date: str) -> None:\n",
    "        self.df = yf.download(tickers, start=start_date, end=end_date)\n",
    "        self.df.index = pd.to_datetime(self.df.index)\n",
    "        self.tickers : pd.DataFrame = tickers\n",
    "        self.start_date : pd.DataFrame = start_date\n",
    "        self.end_date : pd.DataFrame = end_date\n",
    "        self.adj_close : pd.DataFrame = self.df['Adj Close']\n",
    "        self.close : pd.DataFrame = self.df['Close']\n",
    "        self.high : pd.DataFrame = self.df['High']\n",
    "        self.low : pd.DataFrame = self.df['Low']\n",
    "        self.open : pd.DataFrame = self.df['Open']\n",
    "        self.volume : pd.DataFrame = self.df['Volume']\n",
    "        self.returns_daily = self.adj_close.pct_change().fillna(0)  # Retornos diários\n",
    "        self.returns_monthly = self.adj_close.pct_change(20).fillna(0).resample('BM').last().ffill()  # Retornos mensais"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a240e4ae",
   "metadata": {},
   "source": [
    "#### Backtesting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a83db1bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "\n",
    "class RiskParityBacktesting:\n",
    "    \"\"\"\n",
    "    Classe que implementa backtesting utilizando a estratégia de Markowitz\n",
    "\n",
    "    Parâmetros\n",
    "    ----------\n",
    "\n",
    "    tickers: List[str]\n",
    "        lista de tickers dos ativos que compõem a carteira a ser simulada\n",
    "    start_date: str\n",
    "        string no formato %Y-%m-%d que representa o início do período simulado Ex: '2011-01-23'\n",
    "    end_date: str\n",
    "        string no formato %Y-%m-%d que representa o final do período simulado. Ex: '2021-12-29'\n",
    "    past_window: timedelta\n",
    "        período de tempo no passado que será levado em consideração para calcular os pesos dos\n",
    "        ativos na carteira a cada rebalanceamento. Exemplo: timedelta(days=5 * 365)\n",
    "    rebalancing_period: pd.DateOffset\n",
    "        período do rebalanceamento. Ex: pd.DateOffset(months=3) significa rebalancear a cada 3 meses\n",
    "    num_portfolios: int\n",
    "        quantidade de portfolios aleatórios gerados para simulação de Markowitz. Quanto maior esse número,\n",
    "        mais próximo do portfolio \"ideal\", porém demora mais para processar\n",
    "    risk_free: int\n",
    "        não faço ideia\n",
    "    method: string\n",
    "        pode ser uma das três: 'sharpe_ratio', 'volatility' ou 'return'. Tem algo a ver com como\n",
    "        Markowitz rebalanceia os pesos \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(\n",
    "        self,\n",
    "        tickers: List[str],\n",
    "        start_date: str,\n",
    "        end_date: str,\n",
    "        past_window: timedelta,\n",
    "        rebalancing_period: pd.DateOffset\n",
    "    ):\n",
    "        self.rebalancing_period = rebalancing_period\n",
    "        self.start_date = start_date\n",
    "        self.end_date = end_date\n",
    "        self.tickers = tickers\n",
    "        self.past_window = past_window\n",
    "\n",
    "        self._portfolio = []\n",
    "        self._compute_rebalancing_dates()\n",
    "        self._download_data()\n",
    "\n",
    "    def _compute_rebalancing_dates(self):\n",
    "        \"\"\"\n",
    "        Calcula as datas em que será necessário realizar o balanceamento\n",
    "        \"\"\"\n",
    "        self.rebalancing_dates = pd.date_range(\n",
    "            start=self.start_date, end=self.end_date, freq=self.rebalancing_period\n",
    "        )\n",
    "\n",
    "    def _download_data(self):\n",
    "        \"\"\"\n",
    "        Baixa todos os dados necessários para fazer o backtesting no período escolhido\n",
    "        \"\"\"\n",
    "        start_period = datetime.strptime(self.start_date, \"%Y-%m-%d\") - self.past_window\n",
    "        self.data = Params(\n",
    "            self.tickers, start_date=start_period, end_date=end_date\n",
    "        ).adj_close\n",
    "\n",
    "    def _get_past_data(self, date):\n",
    "        \"\"\"\n",
    "        Pega os dados do passado a partir de date\n",
    "        \"\"\"\n",
    "        return self.data.loc[date - past_window:date]\n",
    " \n",
    "        \n",
    "    def _rebalance_portfolio(self, date):\n",
    "        past_data = self._get_past_data(date)\n",
    "        best_weights = calcula_pesos_hrp(matriz_cov, colunas_seriation) * 100\n",
    "        return best_weights\n",
    "    \n",
    "    def _compute_returns(self, weights, start_date, end_date):\n",
    "        # TODO: Função deve calcular retorno do portfolio (dados disponívels na variável self.data) com os weights\n",
    "        # de start_date até end_date\n",
    "\n",
    "        pass\n",
    "    \n",
    "    def backtest(self):\n",
    "        returns = []\n",
    "        for i, rebal_date in enumerate(self.rebalancing_dates[:-1]):\n",
    "            next_rebal_date = self.rebalancing_dates[i+1]\n",
    "            best_weights = self._rebalance_portfolio(rebal_date)\n",
    "            returns.append(self._compute_returns(best_weights, rebal_date, next_rebal_date))\n",
    "            self._portfolio.append((rebal_date, best_weights))\n",
    "\n",
    "        self.portfolio = pd.concat([pd.DataFrame({'Date': date, 'Ticker': series.index, 'Allocation': series.values}) for date, series in self._portfolio])\n",
    "        return returns\n",
    "\n",
    "\n",
    "    def plot_portfolio_over_time(self):\n",
    "        # obrigado chatgpt\n",
    "\n",
    "        df = self.portfolio\n",
    "        df['Date'] = df['Date'].dt.strftime('%Y-%m-%d')\n",
    "        # Group the DataFrame by 'Date' and 'Ticker' and calculate the cumulative sum of 'Allocation'\n",
    "        df['Cumulative_Allocation'] = df.groupby(['Date', 'Ticker'])['Allocation'].cumsum()\n",
    "\n",
    "        # Pivot the DataFrame to prepare for stacked bar plot\n",
    "        pivot_df = df.pivot(index='Date', columns='Ticker', values='Cumulative_Allocation').fillna(0)\n",
    "\n",
    "        # Create stacked bar plots\n",
    "        pivot_df.plot(kind='bar', stacked=True, figsize=(10, 6))\n",
    "        plt.xlabel('Date')\n",
    "        plt.ylabel('Cumulative Allocation')\n",
    "        plt.title('Portfolio Allocations by Date according to Risk Parity')\n",
    "        plt.legend(title='Ticker', bbox_to_anchor=(1, 1), loc='upper left')\n",
    "        plt.xticks(rotation=90)\n",
    "        plt.grid(axis='y')\n",
    "        plt.show()\n",
    "\n",
    "    def plot_returns(self):\n",
    "        pass\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "de098f25",
   "metadata": {},
   "outputs": [],
   "source": [
    "tickers = ['ITUB4.SA', 'SANB4.SA', 'BBAS3.SA', 'BBDC4.SA', 'TRPL4.SA', 'EGIE3.SA', 'AESB3.SA', 'SAPR11.SA', 'SBSP3.SA', 'CSMG3.SA']\n",
    "start_date = '2021-01-01'\n",
    "end_date = '2023-07-01'\n",
    "past_window = timedelta(days= 5 * 365)  # 5 anos\n",
    "rebalancing_period = pd.DateOffset(months=3)  # 3 meses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c745ea58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[*********************100%***********************]  10 of 10 completed\n"
     ]
    }
   ],
   "source": [
    "backtesting = RiskParityBacktesting(\n",
    "    tickers,\n",
    "    start_date,\n",
    "    end_date,\n",
    "    past_window,\n",
    "    rebalancing_period\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "afefe449",
   "metadata": {},
   "outputs": [],
   "source": [
    "returns = backtesting.backtest()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "2a406fa7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9kAAAJkCAYAAAAFl+L1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACgGElEQVR4nOzdd1QU19sH8O/C0kFAUBcUAUHF3kElCqhg7xVFxW5ssUUsUbGBLWoSW9Sl2LH3GhWiwRoFjfrDrlFADUUUFCnz/uFh3qxL2cVFJH4/5+yJe+eZO89cdjUPd+aORBAEAURERERERET0ybSKOwEiIiIiIiKi/woW2UREREREREQawiKbiIiIiIiISENYZBMRERERERFpCItsIiIiIiIiIg1hkU1ERERERESkISyyiYiIiIiIiDSERTYRERERERGRhrDIJiIiIiIiItIQFtlEJURISAgkEon4kkqlqFChAgYNGoRnz55p9FgBAQHYt29frttOnTqFhg0bwsjICBKJJM+43ISHh0MikSA8PFxs8/f3h0Qi+bSE8/Dzzz9DIpGgZs2aecZIJBL4+/vnm2NxSEtLg7+/f6555HwWHj169NnzKsijR48gkUiwdOnSIj1Ozs8p56Wrq4syZcrA1dUVM2bMwOPHjwvdd2xsLPz9/REVFaW5hP+D7Ozs4OvrK74vzu/OrVu34O/vr/HvxMefM21tbZQpUwYdO3bElStXlOJ9fX1hZ2dXqGPs2rVL7fxyvm85Ly0tLVhYWKBdu3Y4f/682v3lJ7dzy+/fCiKirxmLbKISJjg4GOfPn8fJkycxbNgwbNu2Dc2aNUNqaqrGjpHX/zgJgoBevXpBR0cHBw4cwPnz5+Hm5vZJxxo6dKjG/2cwR1BQEADg5s2buHjxYpEco6ikpaVhzpw5uRYs7du3x/nz52FlZfX5E/vCBAQE4Pz58zhz5gzkcjnc3d0RFBSEatWqYcuWLYXqMzY2FnPmzGGRrab69evj/PnzqF+//mc/9q1btzBnzpwi+8VTzucsPDwcM2fORGRkJNzc3HD37l2FuJkzZ2Lv3r1FkkN+xo4di/Pnz+Ps2bMIDAxEdHQ0PDw8cO3aNY0dI7dzY5FNRJQ7aXEnQETqqVmzJho2bAgA8PDwQFZWFubNm4d9+/ahX79+n9T327dvYWBgkOf22NhYJCYmomvXrmjZsuUnHStHhQoVUKFCBY309W9XrlxBdHQ02rdvj8OHD0Mul8PFxUXjxykOZcqUQZkyZYo7jS9C5cqV0bhxY/F9p06dMGnSJLRq1Qq+vr6oXbs2atWqVYwZllxpaWkwNDRUOb5UqVIKP4v/kn9/zpo1awYzMzMMHDgQmzdvxpw5c8Q4BweHYsmvYsWKYn6urq5wdHREy5YtsXr1aqxfv/6T+s75HBTXuRERlUScySYq4XL+xyrn8th3795h2rRpsLe3h66uLsqXL4/Ro0cjOTlZYT87Ozt06NABe/bsQb169aCvr485c+ZAIpEgNTUVoaGh4iWI7u7u8Pf3F4thPz8/SCQShUsHz507h5YtW8LExASGhoZo2rQpDh8+XGD+uV0unp2djcWLF8PJyQl6enooW7YsBgwYgKdPn6o8LnK5HACwcOFCNG3aFNu3b0daWprK+3/swIEDaNKkCQwNDWFiYgJPT89cZ+D/97//wdvbG+XKlYOenh4qVqyIAQMGID09HQDw8uVLjBo1CtWrV4exsTHKli2LFi1a4OzZs2Ifjx49EovonJ+JRCIRL83N63LxoKAg1KlTB/r6+ihdujS6du2K27dvK8T4+vrC2NgY9+7dQ7t27WBsbAwbGxtMmjRJzDHHmjVrUKdOHRgbG8PExAROTk6YPn26SuOVnZ2NBQsWoGLFitDX10fDhg1x6tQpcfvZs2chkUiwbds2pX03btwIiUSCy5cvq3Ssj5UuXRq//vorMjMzsXz5crH93r17GDRoECpXrgxDQ0OUL18eHTt2xI0bN8SY8PBwNGrUCAAwaNAgcez/fUvBlStX0KlTJ5QuXRr6+vqoV68eduzYoVJuc+bMgYuLC0qXLo1SpUqhfv36kMvlEARBKXbr1q1o0qQJjI2NYWxsjLp164qf6xzHjh1Dy5YtYWpqCkNDQ1SrVg2BgYEKMap8dnO+h1evXkWPHj1gbm4uFlUZGRmYMmUKZDIZDA0N8c033+DSpUtK+eZ2ubg6n7enT5+iR48eMDExgZmZGfr164fLly9DIpEgJCQkzzENCQlBz549AXz4xWPOz+zf+6jy3VBHzi86nz9/rtCe2yXVO3fuhIuLi/gzqlSpEgYPHpxv/ykpKWjdujXKlSuX61gX5ON/F8LCwuDl5QUrKysYGBigWrVqmDp1qtIVUDk/rxs3bsDLywsmJibiL1Q/Pre8/q149OgRpFKp0ucQAH7//XdIJBLs3LlT7XMiIipJWGQTlXD37t0D8GF2UxAEdOnSBUuXLkX//v1x+PBhTJw4EaGhoWjRooXS/9RevXoV33//PcaNG4djx46he/fuOH/+PAwMDMR7+s6fP4/Vq1dj6NCh2LNnD4D/vzQx59LBiIgItGjRAq9evYJcLse2bdtgYmKCjh07IiwsTO1z+vbbb+Hn5wdPT08cOHAA8+bNw7Fjx9C0aVP8888/Be7/9u1bbNu2DY0aNULNmjUxePBgvH79utD/Y7d161Z07twZpUqVwrZt2yCXy5GUlAR3d3ecO3dOjIuOjkajRo1w4cIFzJ07F0ePHkVgYCDS09Px/v17AEBiYiIAYPbs2Th8+DCCg4NRqVIluLu7i8WJlZUVjh07BgAYMmSI+HOYOXNmnjkGBgZiyJAhqFGjBvbs2YOffvoJ169fR5MmTZQuac3IyECnTp3QsmVL7N+/H4MHD8by5cuxaNEiMWb79u0YNWoU3NzcsHfvXuzbtw8TJkxQ+baElStX4tixY1ixYgU2b94MLS0ttG3bVizumjVrhnr16mHVqlW57tuoUSOx2C2MRo0awcrKCr///rvYFhsbCwsLCyxcuBDHjh3DqlWrIJVK4eLigpiYGAAfLnkODg4GAPzwww/i2A8dOhQAcObMGbi6uiI5ORlr167F/v37UbduXfTu3TvfQjDHo0ePMGLECOzYsQN79uxBt27dMHbsWMybN08hbtasWejXrx+sra0REhKCvXv3YuDAgQr3msvlcrRr1w7Z2dlYu3YtDh48iHHjxin8MkrVz26Obt26wdHRETt37sTatWsBAMOGDcPSpUsxYMAA7N+/H927d0e3bt2QlJSk0s9Clc9bamoqPDw8cObMGSxatAg7duxAuXLl0Lt37wL7b9++PQICAgAAq1atEn9m7du3B6Ded0NVDx8+BABUqVIl37jz58+jd+/eqFSpErZv347Dhw9j1qxZyMzMzHOfp0+f4ptvvsHjx49x/vx5ODs7q53fv/9dAIC7d++iXbt2kMvlOHbsGMaPH48dO3agY8eOSvu+f/8enTp1QosWLbB//36FmfqPzy23fyvs7OzQqVMnrF27FllZWQr7rFy5EtbW1ujatava50REVKIIRFQiBAcHCwCECxcuCBkZGcLr16+FQ4cOCWXKlBFMTEyE+Ph44dixYwIAYfHixQr7hoWFCQCEdevWiW22traCtra2EBMTo3QsIyMjYeDAgUrtDx8+FAAIS5YsUWhv3LixULZsWeH169diW2ZmplCzZk2hQoUKQnZ2tiAIgnDmzBkBgHDmzBkxbvbs2cK//yq6ffu2AEAYNWqUwjEuXrwoABCmT59e4Fht3LhRACCsXbtWEARBeP36tWBsbCw0a9ZMKRaAMHv2bPH9xzlmZWUJ1tbWQq1atYSsrCwx7vXr10LZsmWFpk2bim0tWrQQzMzMhBcvXhSYY47MzEwhIyNDaNmypdC1a1ex/eXLl0q55cj5LDx8+FAQBEFISkoSDAwMhHbt2inEPXnyRNDT0xP69u0rtg0cOFAAIOzYsUMhtl27dkLVqlXF92PGjBHMzMxUPo8cOZ8Ra2tr4e3bt2J7SkqKULp0aaFVq1ZK53Ht2jWx7dKlSwIAITQ0NN/j5Pycdu7cmWeMi4uLYGBgkOf2zMxM4f3790LlypWFCRMmiO2XL18WAAjBwcFK+zg5OQn16tUTMjIyFNo7dOggWFlZKXxGCpKVlSVkZGQIc+fOFSwsLMTvyYMHDwRtbW2hX79+ee77+vVroVSpUsI333wj7pdb/6p+dnO+h7NmzVLoI+f7+O/xEQRB2LJliwBA4e+J3L7fqn7eVq1aJQAQjh49qhA3YsSIPH8W/7Zz506lYwuCet+N3OScU1hYmJCRkSGkpaUJf/zxh1C1alWhevXqQlJSkkL8wIEDBVtbW/H90qVLBQBCcnJygcfYuXOncO3aNcHa2lpo1qyZkJCQkG9ugvD/37dFixYJGRkZwrt374Q///xTaNSokQBAOHz4sNI+2dnZQkZGhhARESEAEKKjoxXyByAEBQUp7ffxuQlC3v9W5JzT3r17xbZnz54JUqlUmDNnToHnRURU0nEmm6iEady4MXR0dGBiYoIOHTpAJpPh6NGjKFeuHE6fPg0ACiv+AkDPnj1hZGSkcLkuANSuXbvAmZiCpKam4uLFi+jRoweMjY3Fdm1tbfTv3x9Pnz4VZwlVcebMGQDK5+Ds7Ixq1aopnUNu5HI5DAwM0KdPHwCAsbExevbsibNnz6o9cxUTE4PY2Fj0798fWlr//1emsbExunfvjgsXLiAtLQ1paWmIiIhAr169Crxfeu3atahfvz709fUhlUqho6ODU6dOFfry1fPnz+Pt27dKY2ZjY4MWLVoojZlEIlGawapdu7bCLKmzszOSk5Ph7e2N/fv3q3QFwb9169YN+vr64vucKxt+//13cXbL29sbZcuWVZjN/uWXX1CmTBmVZjALInx0CXZmZiYCAgJQvXp16OrqQiqVQldXF3fv3lVp7O/du4f//e9/4toHmZmZ4qtdu3aIi4sr8LN++vRptGrVCqamptDW1oaOjg5mzZqFhIQEvHjxAgBw8uRJZGVlYfTo0Xn2ExkZiZSUFIwaNSrP1flV/ez+W/fu3RXe53wfP17voVevXpBKVVvWRZXPW0REBExMTNCmTRuFOG9vb5WOkRd1vxt56d27N3R0dGBoaAhXV1ekpKTg8OHDMDMzy3e/nKsxevXqhR07duT7JIjjx4+jWbNmaN68OU6ePInSpUurlBvw4RYeHR0d6Ovro0GDBnjy5Al+/fVXtGvXDgDw4MED9O3bFzKZTPzc5Sxamdtn/+PPgbrc3d1Rp04dhe/22rVrIZFIMHz48E/qm4ioJGCRTVTCbNy4EZcvX8a1a9cQGxuL69evw9XVFQCQkJAAqVSqVORJJBLIZDIkJCQotGtideqkpCQIgpBrX9bW1mJeqsqJzau/gvq6d+8efv/9d7Rv3x6CICA5ORnJycno0aMHgP9fcVxT+WRnZyMpKQlJSUnIysoqcBG3ZcuW4dtvv4WLiwt2796NCxcu4PLly2jTpg3evn2rVm6q5vjxmBkaGioUwACgp6eHd+/eie/79++PoKAgPH78GN27d0fZsmXh4uKCkydPqpSTTCbLte39+/d48+aNeMwRI0Zg69atSE5OxsuXL7Fjxw4MHToUenp6Kh0nP0+ePBE/gwAwceJEzJw5E126dMHBgwdx8eJFXL58GXXq1FFp7HPuv508eTJ0dHQUXqNGjQKAfH8ZcenSJXh5eQEA1q9fjz/++AOXL1/GjBkzAEDM4eXLlwCQ72dJlRhVP7v/9nFsTh8f/zylUiksLCzyPPa/qfJ5S0hIQLly5ZT2za1NHZ/690mORYsW4fLly4iIiMCMGTPw/PlzdOnSRekWnI81b94c+/btQ2ZmJgYMGIAKFSqgZs2aua5FsG/fPrx9+xbffvut2p//7777DpcvX8aff/6J+/fvIy4uTixm37x5g2bNmuHixYuYP38+wsPDcfnyZfH2n48/+4aGhihVqpRax8/NuHHjcOrUKcTExCAjIwPr169Hjx49cv27gYjov4arixOVMNWqVRMX3fmYhYUFMjMz8fLlS4VCWxAExMfHK93jqonnU5ubm0NLSwtxcXFK22JjYwEAlpaWKveX8z/ucXFxSgVEbGxsgX0FBQVBEATs2rUr1+fOhoaGYv78+dDW1lY7n4/FxsZCS0sL5ubm4jN0C1qcbfPmzXB3d8eaNWsU2l+/fq1SPoXJUZ3x/7dBgwZh0KBBSE1Nxe+//47Zs2ejQ4cOuHPnDmxtbfPdNz4+Ptc2XV1dhSsevv32WyxcuBBBQUF49+4dMjMzMXLkyELl+2+XLl1CfHw8hgwZIrZt3rwZAwYMEO/fzfHPP/8UOCMJ/P/neNq0aejWrVuuMVWrVs1z/+3bt0NHRweHDh1SKDo/fgRSznf36dOnsLGxybWvf8fkRdXP7r99/HdCTh/x8fEoX7682J6ZmanWL88KYmFhkesCX7l9jtTtF/j070alSpXEv3ebN28OAwMD/PDDD/jll18wefLkfPft3LkzOnfujPT0dFy4cAGBgYHo27cv7Ozs0KRJEzFu+fLl2L59O9q2bYu9e/eKv5BRRYUKFfL8d+H06dOIjY1FeHi4wiMXP14MM4cm/l0AgL59+8LPzw+rVq1C48aNER8fn+/VGURE/yWcySb6D8lZBXbz5s0K7bt370ZqaqrKj93S09NTeVbVyMgILi4u2LNnj8I+2dnZ2Lx5MypUqKDWJektWrQAoHwOly9fxu3bt/M9h6ysLISGhsLBwQFnzpxRek2aNAlxcXE4evSoyvlUrVoV5cuXx9atWxUuP05NTcXu3bvFVZsNDAzg5uaGnTt35jubKZFIlGaprl+/rrTac06MKj+HJk2awMDAQGnMnj59itOnT3/y49aMjIzQtm1bzJgxA+/fv8fNmzcL3GfPnj0KM5WvX7/GwYMH0axZM4VfcFhZWaFnz55YvXo11q5di44dO6JixYqflG9iYiJGjhwJHR0dTJgwQWzPbewPHz6sdAlvXmNftWpVVK5cGdHR0WjYsGGuLxMTkzzzkkgkkEqlCuf/9u1bbNq0SSHOy8sL2traSr+I+bemTZvC1NQUa9euzXVl8px8Vfns5sfd3R0AlJ45vmPHjnwX71KXm5sbXr9+rfTd3L59u0r75/UzK6rvxpQpU+Do6IiFCxeq/AsyPT09uLm5iQu+ffwMa319fezduxcdOnRAp06dsH///kLl9rGcovnjz/6vv/76yX3n92+Fvr4+hg8fjtDQUCxbtgx169YVr7oiIvqv40w20X+Ip6cnWrduDT8/P6SkpMDV1RXXr1/H7NmzUa9ePfTv31+lfmrVqoXw8HAcPHgQVlZWMDExyXeGLjAwEJ6envDw8MDkyZOhq6uL1atX46+//sK2bdvUmhmpWrUqhg8fjl9++UVckfrRo0eYOXMmbGxsFIqmjx09ehSxsbFYtGiRWBz8W82aNbFy5UrI5XJ06NBBpXy0tLSwePFi9OvXDx06dMCIESOQnp6OJUuWIDk5GQsXLhRjly1bhm+++QYuLi6YOnUqHB0d8fz5cxw4cAC//vqreB/9vHnzMHv2bLi5uSEmJgZz586Fvb29QtFiYmICW1tb7N+/Hy1btkTp0qVhaWmp9HggADAzM8PMmTMxffp0DBgwAN7e3khISMCcOXOgr6+P2bNnq3Su/zZs2DAYGBjA1dUVVlZWiI+PR2BgIExNTVVa9VtbWxuenp6YOHEisrOzsWjRIqSkpOS6UvF3330nPsM8Z2VvVd29excXLlxAdnY2EhIScPHiRcjlcqSkpGDjxo2oUaOGGNuhQweEhITAyckJtWvXxp9//oklS5YoXTHh4OAAAwMDbNmyBdWqVYOxsTGsra1hbW2NX3/9FW3btkXr1q3h6+uL8uXLIzExEbdv38bVq1fzXcG+ffv2WLZsGfr27Yvhw4cjISEBS5cuVSp+7OzsMH36dMybNw9v376Ft7c3TE1NcevWLfzzzz+YM2cOjI2N8eOPP2Lo0KFo1aoVhg0bhnLlyuHevXuIjo7GypUr1frs5qVatWrw8fHBihUroKOjg1atWuGvv/7C0qVLNXJJcY6BAwdi+fLl8PHxwfz58+Ho6IijR4/i+PHjAKBwT3luatasCQBYt24dTExMoK+vD3t7e1hYWGj8uwEAOjo6CAgIQK9evfDTTz/hhx9+yDVu1qxZePr0KVq2bIkKFSogOTkZP/30k8I90R/3u23bNgwdOhQ9evTAxo0bP/m+9KZNm8Lc3BwjR47E7NmzoaOjgy1btiA6OvqT+gUK/rdi1KhRWLx4Mf78809s2LDhk49HRFRiFN+aa0SkjpyVmC9fvpxv3Nu3bwU/Pz/B1tZW0NHREaysrIRvv/1WaRVcW1tboX379rn2ERUVJbi6ugqGhoYCAMHNzU0QhLxXFxcEQTh79qzQokULwcjISDAwMBAaN24sHDx4UCFGldXFBeHDqsiLFi0SqlSpIujo6AiWlpaCj4+P8Pfff+d77l26dBF0dXXzXd27T58+glQqFeLj4wVBKHh18Rz79u0TXFxcBH19fcHIyEho2bKl8Mcffyj1f+vWLaFnz56ChYWFoKurK1SsWFHw9fUV3r17JwiCIKSnpwuTJ08WypcvL+jr6wv169cX9u3bl+vKvb/99ptQr149QU9PT2El549XF8+xYcMGoXbt2oKurq5gamoqdO7cWbh586ZCzMCBAwUjIyOlvD/+OYSGhgoeHh5CuXLlBF1dXcHa2lro1auXcP369TzHVhAUVzueM2eOUKFCBUFXV1eoV6+ecPz48Tz3s7OzE6pVq5Zv3/+W83PKeUmlUsHCwkJo0qSJMH36dOHRo0dK+yQlJQlDhgwRypYtKxgaGgrffPONcPbsWcHNzU38jOfYtm2b4OTkJOjo6Ch9RqKjo4VevXoJZcuWFXR0dASZTCa0aNFCXM0+P0FBQULVqlUFPT09oVKlSkJgYKAgl8tz/Xlu3LhRaNSokaCvry8YGxsL9erVU1pl+8iRI4Kbm5tgZGQkGBoaCtWrVxcWLVqkEKPKZzfn5//y5UulnNPT04VJkyYJZcuWFfT19YXGjRsL58+fF2xtbVVaXVyVz5sgfFjxu1u3boKxsbFgYmIidO/eXThy5IgAQNi/f38+o/rBihUrBHt7e0FbW1tpRXJVvhu5KWgVexcXF8Hc3FxcPfzj7/GhQ4eEtm3bCuXLlxd0dXWFsmXLCu3atRPOnj2b7zGys7OFcePGCVpaWsL69evzzC+/v5P/LTIyUmjSpIlgaGgolClTRhg6dKhw9epVpXHK6+eV27kJQt7/Vvybu7u7ULp0aSEtLS3fHImI/kskgpDHdWZERESfwfXr18WViHMWECMCgICAAPzwww948uRJgYsK0pfnxYsXsLW1xdixY7F48eLiToeI6LPh5eJERFQs7t+/j8ePH2P69OmwsrJSeswSfV1WrlwJAHByckJGRgZOnz6Nn3/+GT4+PiywS5inT5/iwYMHWLJkCbS0tPDdd98Vd0pERJ8Vi2wiIioW8+bNw6ZNm1CtWjXs3LmzwEW46L/N0NAQy5cvx6NHj5Ceno6KFSvCz88vz/ud6cu1YcMGzJ07F3Z2dtiyZYvCyvRERF8DXi5OREREREREpCF8hBcRERERERGRhrDIJiIiIiIiItIQFtlEREREREREGsKFzwBkZ2cjNjYWJiYmkEgkxZ0OEREREREVE0EQ8Pr1a1hbW0NLi3OSpD4W2QBiY2NhY2NT3GkQEREREdEX4u+//+YjBKlQWGQDMDExAfDhi1SqVKlizoaIiIiIiIpLSkoKbGxsxBqBSF0ssgHxEvFSpUqxyCYiIiIiIt5GSoXGmwyIiIiIiIiINIRFNhEREREREZGGsMgmIiIiIiIi0hDek01ERERERKSmrKwsZGRkFHca9Bno6OhAW1tb5XgW2URERERERCoSBAHx8fFITk4u7lToMzIzM4NMJlNpQTwW2URERERERCrKKbDLli0LQ0NDrkL+HycIAtLS0vDixQsAgJWVVYH7sMgmIiIiIiJSQVZWllhgW1hYFHc69JkYGBgAAF68eIGyZcsWeOk4Fz4jIiIiIiJSQc492IaGhsWcCX1uOT9zVe7DZ5FNRERERESkBl4i/vVR52fOIpuIiIiIiIhIQ1hkExERERERfaX8/f1Rt25dleMlEgn27dtXZPn8F7DIJiIiIiIi+g+SSCT5vnx9fTF58mScOnWquFP9T+Hq4kRERERERP9BcXFx4p/DwsIwa9YsxMTEiG0GBgYwNjaGsbFxcaQHAHj//j10dXWL7fhFgTPZRERERERE/0EymUx8mZqaQiKRKLXldrl4UFAQatSoAT09PVhZWWHMmDF5HmPu3LkoV64coqKiAACRkZFo3rw5DAwMYGNjg3HjxiE1NVWMt7Ozw/z58+Hr6wtTU1MMGzasKE69WLHIJiIiIiIiIgDAmjVrMHr0aAwfPhw3btzAgQMH4OjoqBQnCAK+++47yOVynDt3DnXr1sWNGzfQunVrdOvWDdevX0dYWBjOnTunVKQvWbIENWvWxJ9//omZM2d+rlP7bIq1yP7999/RsWNHWFtb53oDvSAI8Pf3h7W1NQwMDODu7o6bN28qxKSnp2Ps2LGwtLSEkZEROnXqhKdPn37GsyAiIiIiIvpvmD9/PiZNmoTvvvsOVapUQaNGjTB+/HiFmMzMTAwYMAAnTpzAH3/8gcqVKwP4UDz37dsX48ePR+XKldG0aVP8/PPP2LhxI969eyfu36JFC0yePBmOjo65FvAlXbEW2ampqahTpw5WrlyZ6/bFixdj2bJlWLlyJS5fvgyZTAZPT0+8fv1ajBk/fjz27t2L7du349y5c3jz5g06dOiArKysz3UaREREREREJd6LFy8QGxuLli1b5hs3YcIEnD9/HmfPnkWFChXE9j///BMhISHifd7GxsZo3bo1srOz8fDhQzGuYcOGRXYOX4JiXfisbdu2aNu2ba7bBEHAihUrMGPGDHTr1g0AEBoainLlymHr1q0YMWIEXr16Bblcjk2bNqFVq1YAgM2bN8PGxga//fYbWrdu/dnOhYiIiIiIqCQzMDBQKc7T0xPbtm3D8ePH0a9fP7E9OzsbI0aMwLhx45T2qVixovhnIyOjT0/2C/bFri7+8OFDxMfHw8vLS2zT09ODm5sbIiMjMWLECPz555/IyMhQiLG2tkbNmjURGRmZZ5Gdnp6O9PR08X1KSgoAICMjAxkZGUV0RkRERERE9KX7musBExMT2NnZ4dSpU/Dw8MgzrlOnTujYsSP69u0LbW1t9OnTBwBQv3593Lx58z95Cbg6vtgiOz4+HgBQrlw5hfZy5crh8ePHYoyuri7Mzc2VYnL2z01gYCDmzJmj1H7ixAkYGhp+aupERERERFRCpaWlFXcKxcrf3x8jR45E2bJl0bZtW7x+/Rp//PEHxo4dqxDXtWtXbNq0Cf3794dUKkWPHj3g5+eHxo0bY/To0Rg2bBiMjIxw+/ZtnDx5Er/88ksxndHn98UW2TkkEonCe0EQlNo+VlDMtGnTMHHiRPF9SkoKbGxs4OXlhVKlSn1awgAqn73xyX0UlbvNahV3CnniuKmPY1Y4HDf1ccwKh+OmPo5Z4XDc1McxK5yvYdxyrnL9Wg0cOBDv3r3D8uXLMXnyZFhaWqJHjx65xvbo0QPZ2dno378/tLS00K1bN0RERGDGjBlo1qwZBEGAg4MDevfu/ZnPonh9sUW2TCYD8GG22srKSmx/8eKFOLstk8nw/v17JCUlKcxmv3jxAk2bNs2zbz09Pejp6Sm16+joQEdH55Nzfyf5cp+MponzKyocN/VxzAqH46Y+jlnhcNzUxzErHI6b+jhmhfM1jNuXPP6fwtfXF76+vkrt/v7+8Pf3V2gbMWIERowYkWs/giAovO/Vqxd69eolvm/UqBFOnDiRZx6PHj1SOeeS6ov9ltjb20Mmk+HkyZNi2/v37xERESEW0A0aNICOjo5CTFxcHP766698i2wiIiIiIiKiolCsM9lv3rzBvXv3xPcPHz5EVFQUSpcujYoVK2L8+PEICAhA5cqVUblyZQQEBMDQ0BB9+/YFAJiammLIkCGYNGkSLCwsULp0aUyePBm1atUSVxsnIiIiIiIi+lyKtci+cuWKwqp1OfdJDxw4ECEhIZgyZQrevn2LUaNGISkpCS4uLjhx4gRMTEzEfZYvXw6pVIpevXrh7du3aNmyJUJCQqCtrf3Zz4eIiIiIiIi+bsVaZLu7uytd0/9vEokk13sE/k1fXx+//PLLV7VaHREREREREX2Zvth7somIiIiIiIhKGhbZRERERERERBrCIpuIiIiIiIhIQ1hkExEREREREWkIi2wiIiIiIiIiDWGRTURERERERKQhxfoILyIiIiIiopLOburhz3q8RwvbF2q/yMhINGvWDJ6enjh27Nj/9/foEezt7XPd5/z582jcuDGysrKwePFihIaG4vHjxzAwMECVKlUwYsQIDBo0CADg6+uL0NBQcd/SpUujUaNGWLx4MWrXri22d+rUCVFRUXjx4gXMzc3RqlUrLFq0CNbW1nnm/uDBA8yYMQMRERFITEyEpaUlGjRogCVLlqBKlSoKsVu3bkX//v0xbNgwrF27tlBj9Sk4k01ERERERPQVCAoKwtixY3Hu3Dk8efJEaftvv/2GuLg4hVeDBg0AAP7+/lixYgXmzZuHW7du4cyZMxg2bBiSkpIU+mjTpo2476lTpyCVStGhQweFGA8PD+zYsQMxMTHYvXs37t+/jx49euSZ9/v37+Hp6YmUlBTs2bMHMTExCAsLQ82aNfHq1atcz3PKlCnYvn070tLSCjNUn4Qz2URERERERP9xqamp2LFjBy5fvoz4+HiEhIRg1qxZCjEWFhaQyWS57n/w4EGMGjUKPXv2FNvq1KmjFKenpyf2IZPJ4Ofnh+bNm+Ply5coU6YMAGDChAlivK2tLaZOnYouXbogIyMDOjo6Sn3eunULDx48wOnTp2Frayvu5+rqqhT76NEjREZGYvfu3Thz5gx27dqFAQMGFDQ8GsWZbCIiIiIiov+4sLAwVK1aFVWrVoWPjw+Cg4MhCILK+8tkMpw+fRovX75UeZ83b95gy5YtcHR0hIWFRa4xiYmJ2LJlC5o2bZprgQ0AZcqUgZaWFnbt2oWsrKx8jxkUFIT27dvD1NQUPj4+kMvlKuerKSyyiYiIiIiI/uPkcjl8fHwAfLik+82bNzh16pRCTNOmTWFsbKzwyilqly1bhpcvX0Imk6F27doYOXIkjh49qnScQ4cOifuamJjgwIEDCAsLg5aWYunp5+cHIyMjWFhY4MmTJ9i/f3+euZcvXx4///wzZs2aBXNzc7Ro0QLz5s3DgwcPFOKys7MREhIinmefPn1w/vx53Lt3T/0B+wQssomIiIiIiP7DYmJicOnSJfTp0wcAIJVK0bt3bwQFBSnEhYWFISoqSuGlra0NAKhevTr++usvXLhwAYMGDcLz58/RsWNHDB06VKEPDw8Pcd+LFy/Cy8sLbdu2xePHjxXivv/+e1y7dg0nTpyAtrY2BgwYkO/M+ujRoxEfH4/NmzejSZMm2LlzJ2rUqIGTJ0+KMSdOnEBqairatm0LALC0tISXl5fSeRY13pNNRERERET0HyaXy5GZmYny5cuLbYIgQEdHR2HhMhsbGzg6OubZj5aWFho1aoRGjRphwoQJ2Lx5M/r3748ZM2aIq5MbGRkp9NGgQQOYmppi/fr1mD9/vthuaWkJS0tLVKlSBdWqVYONjQ0uXLiAJk2a5Hl8ExMTdOrUCZ06dcL8+fPRunVrzJ8/H56engA+XCqemJgIQ0NDcZ/s7Gxcu3YN8+bNE39hUNQ4k01ERERERPQflZmZiY0bN+LHH39UmKGOjo6Gra0ttmzZUui+q1evDuDDomp5kUgk0NLSwtu3b/OMyZnBTk9PV/nYEokETk5O4rETEhKwf/9+bN++XWk2/s2bN7le2l5UOJNNRERERET0H3Xo0CEkJSVhyJAhMDU1VdjWo0cPyOVy8RFbCQkJiI+PV4gxMzODvr4+evToAVdXVzRt2hQymQwPHz7EtGnTUKVKFTg5OYnx6enpYh9JSUlYuXIl3rx5g44dOwIALl26hEuXLuGbb76Bubk5Hjx4gFmzZsHBwUFhFtvJyQmBgYHo2rUroqKiMHv2bPTv3x/Vq1eHrq4uIiIiEBQUBD8/PwDApk2bYGFhgZ49eyrd/92hQweF8yxqLLKJiIiIiIg+waOF7Ys7hTzJ5XK0atVKqcAGgO7duyMgIACJiYkAgFatWinFbNu2DX369EHr1q2xbds2BAYG4tWrV5DJZGjRogX8/f0hlf5/WXns2DFYWVkB+HB5t5OTE3bu3Al3d3cAgIGBAfbs2YPZs2cjNTUVVlZWaNOmDbZv3w49PT2xn5iYGPEZ2BUqVICdnR3mzJmDR48eQSKRiO9zHgcWFBSErl27KhXYOefZu3dvPH/+HOXKlSvkSKqORTYREREREdF/1MGDB/PcVr9+ffFS7YIe5zVs2DAMGzYs35iQkBCEhITkG1OrVi2cPn0635iP87G0tMRPP/2Ub/z169fz3NatWzdkZGQUeExN4T3ZRERERERERBrCIpuIiIiIiIhIQ1hkExEREREREWkIi2wiIiIiIiIiDWGRTURERERERKQhLLKJiIiIiIiINIRFNhEREREREZGGsMgmIiIiIiIi0hAW2UREREREREQawiKbiIiIiIiISEOkxZ0AERERERFRieZv+pmP90rtXXx9fREaGiq+L126NBo1aoTFixejdu3aAACJRCJu19bWhrW1NXr06IHAwEDo6ekp9Pf27VtYW1tDIpHg2bNnMDAwUNh+7do1zJw5E5cuXUJKSgpkMhlcXFywatUqWFpaIiEhAf369cP169eRkJCAsmXLonPnzggICECpUqXyPI+C+v23gIAAzJw5EwsWLMDUqVPVHrPC4kw2ERERERHRV6BNmzaIi4tDXFwcTp06BalUig4dOijEBAcHIy4uDg8fPsTq1auxadMmzJ8/X6mv3bt3o2bNmqhevTr27NmjsO3Fixdo1aoVLC0tcfz4cdy+fRtBQUGwsrJCWloaAEBLSwudO3fGgQMHcOfOHYSEhOC3337DyJEj88xflX4/PpcpU6YgKCioMMNVaJzJJiIiIiIi+gro6elBJpMBAGQyGfz8/NC8eXO8fPkSZcqUAQCYmZmJMTY2NujUqROuXr2q1JdcLoePjw8EQYBcLke/fv3EbZGRkUhJScGGDRsglX4oOe3t7dGiRQsxxtzcHN9++6343tbWFqNGjcKSJUvyzF+VfnNERETg7du3mDt3LjZu3Ijff/8dzZs3V3msPgVnsomIiIiIiL4yb968wZYtW+Do6AgLC4tcY+7cuYMzZ87AxcVFof3+/fs4f/48evXqhV69eiEyMhIPHjwQt8tkMmRmZmLv3r0QBEGlfGJjY7Fnzx64ubnlGaNOv3K5HN7e3tDR0YG3tzfkcrlKeWgCi2wiIiIiIqKvwKFDh2BsbAxjY2OYmJjgwIEDCAsLg5bW/5eF3t7eMDY2hr6+PqpWrYoaNWpg2rRpCv0EBQWhbdu2MDc3R+nSpdGmTRuFS7IbN26M6dOno2/fvrC0tETbtm2xZMkSPH/+XCknb29vGBoaonz58ihVqhQ2bNiQZ/6q9puSkoLdu3fDx8cHAODj44Ndu3YhJSWlUOOmLhbZREREREREXwEPDw9ERUUhKioKFy9ehJeXF9q2bYvHjx+LMcuXL0dUVBSio6Nx6NAh3LlzB/379xe3Z2VlITQ0VCxggQ9FbGhoKLKyssS2BQsWID4+HmvXrkX16tWxdu1aODk54caNGwo5LV++HFevXsW+fftw//59TJw4Md9zUKXfrVu3olKlSqhTpw4AoG7duqhUqRK2b99euIFTE4tsIiIiIiKir4CRkREcHR3h6OgIZ2dnyOVypKamYv369WKMTCaDo6Mjqlativbt22POnDkICwvDvXv3AADHjx/Hs2fP0Lt3b0ilUkilUvTp0wdPnz7FiRMnFI5nYWGBnj174scff8Tt27dhbW2NpUuXKsTIZDI4OTmhc+fO+PXXX7FmzRrExcXlex4F9RsUFISbN2+K+UmlUty8efOzXTLOhc+IiIiIiIi+QhKJBFpaWnj79m2eMdra2gAgxsjlcvTp0wczZsxQiFu4cCHkcjnatm2baz+6urpwcHBAampqnsfKuc86PT1d5XP4uN8bN27gypUrCA8PR+nSpcW45ORkNG/eHH/99Rdq1qypcv+FwSKbiIiIiIjoK5Ceno74+HgAQFJSElauXIk3b96gY8eOYkxycjLi4+ORnZ2Nu3fvYu7cuahSpQqqVauGly9f4uDBgzhw4IBSoTpw4EC0b98eL1++xMWLF7F9+3b06dMHVapUgSAIOHjwII4cOYLg4GAAwJEjR/D8+XM0atQIxsbGuHXrFqZMmQJXV1fY2dkBAJ49e4aWLVti48aNcHZ2xqFDhwrsVy6Xw9nZOdeVxJs0aQK5XI7ly5cXxfCKWGQTERERERF9Cv9XxZ2BSo4dOwYrKysAgImJCZycnLBz5064u7uLMYMGDQLwYZZbJpOhefPmCAgIgFQqxcaNG2FkZISWLVsq9e3h4QETExNs2rQJXbp0gaGhISZNmoS///4benp6qFy5MjZs2CDe321gYID169djwoQJSE9Ph42NDbp164apU6eKfWZkZCAmJkZ8Bnb16tXz7ff9+/fYvHkz/Pz8cj3/7t27IzAwEIsWLYKurq5GxjQ3LLKJiIiIiIj+40JCQhASEpJvTEGPxZo0aRImTZqU6zapVIqEhATx/bp16/Lty8PDA5GRkfnG2NnZKeRUqVKlfPvV1dXFP//8k+f2iRMnFriwmiZw4TMiIiIiIiIiDWGRTURERERERKQhLLKJiIiIiIiINIRFNhEREREREZGGsMgmIiIiIiIi0hAW2UREREREREQawiKbiIiIiIiISENYZBMRERERERFpCItsIiIiIiIiIg1hkU1ERERERESkIdLiToCIiIiIiKgkqxVa67Me78bAG2rv4+vri9DQUPF96dKl0ahRIyxevBi1a9cGAEgkEnG7trY2rK2t0aNHDwQGBkJPTw8AEBISgkGDBgEAtLS0UKpUKVSpUgXt27fHd999B1NTU4XjxsfHY8GCBTh8+DCePXuGsmXLom7duhg/fjxatmypECsIAtq1a4djx45h79696NKlS57n8+LFC8ycORNHjx7F8+fPYW5ujjp16sDf3x9NmjRRiI2MjESzZs3g6emJY8eOqT126uJMNhERERER0VegTZs2iIuLQ1xcHE6dOgWpVIoOHTooxAQHByMuLg4PHz7E6tWrsWnTJsyfP18hplSpUoiLi8PTp08RGRmJ4cOHY+PGjahbty5iY2PFuEePHqFBgwY4ffo0Fi9ejBs3buDYsWPw8PDA6NGjlfJbsWKFQqGfn+7duyM6OhqhoaG4c+cODhw4AHd3dyQmJirFBgUFYezYsTh37hyePHmiUv+fgjPZREREREREXwE9PT3IZDIAgEwmg5+fH5o3b46XL1+iTJkyAAAzMzMxxsbGBp06dcLVq1cV+pFIJGKMlZUVqlWrho4dO6JGjRqYMmUKNm/eDAAYNWoUJBIJLl26BCMjI3H/GjVqYPDgwQp9RkdHY9myZbh8+TKsrKzyPY/k5GScO3cO4eHhcHNzAwDY2trC2dlZKTY1NRU7duzA5cuXER8fj5CQEMyaNUvlMSsMzmQTERERERF9Zd68eYMtW7bA0dERFhYWucbcuXMHZ86cgYuLS4H9lS1bFv369cOBAweQlZWFxMREHDt2DKNHj1YosHOYmZmJf05LS4O3tzdWrlwpFu/5MTY2hrGxMfbt24f09PR8Y8PCwlC1alVUrVoVPj4+CA4OhiAIBR7jU7DIJiIiIiIi+gocOnRILFBNTExw4MABhIWFQUvr/8tCb29vGBsbQ19fH1WrVkWNGjUwbdo0lfp3cnLC69evkZCQgHv37kEQBDg5ORW434QJE9C0aVN07txZpeNIpVKEhIQgNDQUZmZmcHV1xfTp03H9+nWlWLlcDh8fHwAfLpd/8+YNTp06pdJxCotFNhERERER0VfAw8MDUVFRiIqKwsWLF+Hl5YW2bdvi8ePHYszy5csRFRWF6OhoHDp0CHfu3EH//v1V6j9nhlgikSj8OT8HDhzA6dOnsWLFCrXOpXv37oiNjcWBAwfQunVrhIeHo379+ggJCRFjYmJicOnSJfTp0wfAh+K8d+/eCAoKUutY6uI92URERERERF8BIyMjODo6iu8bNGgAU1NTrF+/XlzcTCaTiTFVq1bF69ev4e3tjfnz5yvsm5vbt2+jVKlSsLCwgLa2NiQSCW7fvp3vKuGnT5/G/fv3FS4fBz4U0c2aNUN4eHie++rr68PT0xOenp6YNWsWhg4ditmzZ8PX1xfAh1nszMxMlC9fXtxHEATo6OggKSkJ5ubm+Z5PYXEmm4iIiIiI6CskkUigpaWFt2/f5hmjra0NAPnGAB8eqbV161Z06dIFWlpaKF26NFq3bo1Vq1YhNTVVKT45ORkAMHXqVFy/fl2cYY+KigLwYUY9ODhYrfOpXr26eKzMzExs3LgRP/74o0Lf0dHRsLW1xZYtW9TqWx2cySYiIiIiIvoKpKenIz4+HgCQlJSElStX4s2bN+jYsaMYk5ycjPj4eGRnZ+Pu3buYO3cuqlSpgmrVqokxgiAgPj4egiAgOTkZ58+fR0BAAExNTbFw4UIxbvXq1WjatCmcnZ0xd+5c1K5dG5mZmTh58iTWrFmD27dvQyaT5brYWcWKFWFvby++b9myJbp27YoxY8YgISEBPXv2xODBg1G7dm2YmJjgypUrWLx4sXhf96FDh5CUlIQhQ4YoPbu7R48ekMvlGDNmjGYG9iMssomIiIiIiD7BjYE3ijsFlRw7dkx8PJaJiQmcnJywc+dOuLu7izGDBg0C8P+P6WrevDkCAgIglf5/6ZiSkgIrKytIJBKUKlUKVatWxcCBA/Hdd9+hVKlSYpy9vT2uXr2KBQsWYNKkSYiLi0OZMmXQoEEDrFmzRq3c79+/j3/++QfAh9XFXVxcsHz5cty/fx8ZGRmwsbHBsGHDMH36dAAfLhVv1aqVUoENfLgUPSAgAFevXkX9+vXVykMVLLKJiIiIiIj+40JCQhQWBcuNKo+28vX1Fe95VoWVlRVWrlyJlStXqrxPbnk8evRI/LOenh4CAwMRGBiYZx8HDx7Mc1v9+vWL9DFevCebiIiIiIiISENYZBMRERERERFpCItsIiIiIiIiIg1hkU1ERERERESkISyyiYiIiIiIiDSERTYRERERERGRhrDIJiIiIiIiItIQFtlEREREREREGsIim4iIiIiIiEhDWGQTERERERERaYi0uBMgIiIiIiIqyW47Vfusx6v2v9uF2i8+Ph4LFizA4cOH8ezZM5QtWxZ169bF+PHj0bJlS1y7dg0zZ87EpUuXkJKSAplMBhcXF6xatQqWlpZ49OgR7O3toa2tjcePH6N8+fJi33FxcbCxsUFWVhYePnwIOzs7cdvu3buxatUqXLt2Denp6bCxsYGrqyvGjh2LevXqAQDOnTsHPz8//O9//0NaWhpsbW0xYsQITJgwId9z2r17NxYvXoz//e9/yM7ORsWKFdGmTRv8+OOPSrFeXl44deoU/vjjDzRu3LhQY6gKzmQTERERERH9xz169AgNGjTA6dOnsXjxYty4cQPHjh2Dh4cHRo8ejRcvXqBVq1awtLTE8ePHcfv2bQQFBcHKygppaWkKfVlbW2Pjxo0KbaGhoQpFdw4/Pz/07t0bdevWxYEDB3Dz5k2sW7cODg4OmD59uhhnZGSEMWPG4Pfff8ft27fxww8/4IcffsC6devyPKfffvsNffr0QY8ePXDp0iX8+eefWLBgAd6/f68U++TJE5w/fx5jxoyBXC5Xd/jUwplsIiIiIiKi/7hRo0ZBIpHg0qVLMDIyEttr1KiBwYMHIzw8HCkpKdiwYQOk0g9lor29PVq0aKHU18CBAxEcHIxp06aJbSEhIRg4cCDmzZsntl24cAGLFy/GTz/9hHHjxont9vb2cHNzgyAIYlu9evXEWW0AsLOzw549e3D27FkMHz4813M6dOgQvvnmG3z//fdiW5UqVdClSxel2ODgYHTo0AHffvstnJ2dsWLFCoVx0CTOZBMREREREf2HJSYm4tixYxg9enSuhaWZmRlkMhkyMzOxd+9eheI3N506dUJSUhLOnTsH4MOl3omJiejYsaNC3LZt22BsbIxRo0bl2o9EIsnzGNeuXUNkZCTc3NzyjJHJZLh58yb++uuvfPMVBAHBwcHw8fGBk5MTqlSpgh07duS7z6dgkU1ERERERPQfdu/ePQiCACcnpzxjGjdujOnTp6Nv376wtLRE27ZtsWTJEjx//lwpVkdHBz4+PggKCgIABAUFwcfHBzo6Ogpxd+7cQaVKlcSZcQBYtmwZjI2NxderV68U9qlQoQL09PTQsGFDjB49GkOHDs0z57Fjx6JRo0aoVasW7Ozs0KdPHwQFBSE9PV0h7rfffkNaWhpat24NAPDx8SnSS8ZZZBMREREREf2H5cxM5zdzDAALFixAfHw81q5di+rVq2Pt2rVwcnLCjRs3lGKHDBmCnTt3Ij4+Hjt37sTgwYNz7fPjYw4ePBhRUVH49ddfkZqaqjRrfvbsWVy5cgVr167FihUrsG3btjzzNTIywuHDh3Hv3j388MMPMDY2xqRJk+Ds7KxwH7lcLkfv3r3FYt/b2xsXL15ETExMvuNRWCyyiYiIiIiI/sMqV64MiUSC27cLXpXcwsICPXv2xI8//ojbt2/D2toaS5cuVYqrWbMmnJyc4O3tjWrVqqFmzZq5Hvf+/fvIyMgQ28zMzODo6JjrImnAh/u1a9WqhWHDhmHChAnw9/cvMGcHBwcMHToUGzZswNWrV3Hr1i2EhYUB+HCp/L59+7B69WpIpVJIpVKUL18emZmZ4ky8pnHhsyKwRehe3Cnk435xJ5Anjpv6OGaFw3FTH8escDhu6uOYFQ7HTX0cs8LhuJVMpUuXRuvWrbFq1SqMGzdO6b7s5ORkmJmZKe2nq6sLBwcHpKam5trv4MGDMWrUKKxZsybX7d7e3vjll1+wevVqfPfdd2rnLQiC0qXfBbGzs4OhoaGY85YtW1ChQgXs27dPIe7UqVMIDAzEggULFC5n14QveiY7MzMTP/zwA+zt7WFgYIBKlSph7ty5yM7OFmMEQYC/vz+sra1hYGAAd3d33Lx5sxizJiIiIiIi+rKsXr0aWVlZcHZ2xu7du3H37l3cvn0bP//8M5o0aYJDhw7Bx8cHhw4dwp07dxATE4OlS5fiyJEj6Ny5c659Dhs2DC9fvszzvukmTZpg0qRJmDRpEiZOnIhz587h8ePHuHDhAuRyOSQSCbS0PpSkq1atwsGDB3H37l3cvXsXwcHBWLp0KXx8fMT+9u7dq3Bfub+/P6ZMmYLw8HA8fPgQ165dw+DBg5GRkQFPT08AHy4V79GjB2rWrKnwGjx4MJKTk3H48GFNDbHoi57JXrRoEdauXYvQ0FDUqFEDV65cwaBBg2Bqair+JmTx4sVYtmwZQkJCUKVKFcyfPx+enp6IiYmBiYlJMZ8BERERERH911X7X8GXYRc3e3t7XL16FQsWLMCkSZMQFxeHMmXKoEGDBlizZg0qVqwIQ0NDTJo0CX///Tf09PRQuXJlbNiwAf3798+1T6lUCktLy3yPu3TpUjg7O2PNmjUICgpCWloaypUrh+bNm+P8+fMoVaoUACA7OxvTpk3Dw4cPIZVK4eDggIULF2LEiBFiX69evVK4j9rNzQ2rVq3CgAED8Pz5c5ibm6NevXo4ceIEqlatij///BPR0dFYv369Ul4mJibw8vKCXC7P85cIhfVFF9nnz59H586d0b59ewAfpv63bduGK1euAPgwi71ixQrMmDED3bp1A/DhIejlypXD1q1bFX4gREREREREXzMrKyusXLkSK1euzHX7unXr8t3fzs4u38d71a1bN9ftvXr1Qq9evfLte+zYsRg7dmy+Mb6+vvD19RXfe3h4wMPDI8/4Bg0a5JvvgQMH8j1eYX3RRfY333yDtWvX4s6dO6hSpQqio6Nx7tw5rFixAgDw8OFDxMfHw8vLS9xHT08Pbm5uiIyMzLPITk9PV7i2PyUlBQCQkZGhcFN+YQmC3if3UVQ0cX5FheOmPo5Z4XDc1McxKxyOm/o4ZoXDcVMfx6xwvoZx+5LHn0oGiVDQk8aLkSAImD59OhYtWgRtbW1kZWVhwYIFmDZtGgAgMjISrq6uePbsGaytrcX9hg8fjsePH+P48eO59uvv7485c+YotW/duhWGhoZFczJERERERPTFS0tLQ9++ffHq1SvxUuYc7969w8OHD2Fvbw99ff1iypCKgzo/+y96JjssLAybN2/G1q1bUaNGDURFRWH8+PGwtrbGwIEDxbiPn70mCEK+z4CbNm0aJk6cKL5PSUmBjY0NvLy8lL5IhRHxe51P7qOouDWPLu4U8sRxUx/HrHA4burjmBUOx019HLPC4bipj2NWOF/DuOVc5UpUWF90kf39999j6tSp6NOnDwCgVq1aePz4MQIDAzFw4EDIZDIAQHx8PKysrMT9Xrx4gXLlyuXZr56eHvT0lC910dHRgY6OzifnLZGot8z856SJ8ysqHDf1ccwKh+OmPo5Z4XDc1McxKxyOm/o4ZoXzNYzblzz+VDJ80Y/wSktLE5d0z6GtrS0+wsve3h4ymQwnT54Ut79//x4RERFo2rTpZ82ViIiIiIiI6Iueye7YsSMWLFiAihUrokaNGrh27RqWLVuGwYMHA/hwmfj48eMREBCAypUro3LlyggICIChoSH69u1bzNkTERERERHR1+aLLrJ/+eUXzJw5E6NGjcKLFy9gbW2NESNGYNasWWLMlClT8PbtW4waNQpJSUlwcXHBiRMn+IxsIiIiIiIi+uy+6CLbxMQEK1asEB/ZlRuJRAJ/f3/4+/t/tryIiIiIiIiIcvNF35NNREREREREVJJ80TPZREREREREX7pVI09/1uONXtvisx6P1MOZbCIiIiIiov84X19fSCQSpVebNm3EmGvXrqF3796wsrKCnp4ebG1t0aFDBxw8eBCCIAAAHj16BIlEgqioKIX3ub0uXLgAADh37hxcXV1hYWEBAwMDODk5Yfny5QXmvHv3bri4uMDU1BQmJiaoUaMGJk2alGusl5cXtLW1xWMWJ85kExERERERfQXatGmD4OBghTY9PT0AwP79+9GrVy+0atUKoaGhcHBwQEJCAq5fv44ffvgBzZo1g5mZWZ59//bbb6hRo4ZCm4WFBQDAyMgIY8aMQe3atWFkZIRz585hxIgRMDIywvDhw/Psr0+fPggICECnTp0gkUhw69YtnDp1Sin2yZMnOH/+PMaMGQO5XI7GjRurMywaxyK7CJz9vX9xp5Cnll/wlSUcN/VxzAqH46Y+jlnhcNzUxzErHI6b+jhmhcNxK9n09PQgk8mU2lNTUzFkyBC0b98ee/bsEdsdHBzg7OyMoUOHijPZebGwsMi1bwCoV68e6tWrJ763s7PDnj17cPbs2TyL7EOHDuGbb77B999/L7ZVqVIFXbp0UYoNDg5Ghw4d8O2338LZ2RkrVqyAkZFRvvkWJV4uTkRERERE9BU7ceIEEhISMGXKlDxjJBKJxo537do1REZGws3NLc8YmUyGmzdv4q+//sq3L0EQEBwcDB8fHzg5OaFKlSrYsWOHxnItDBbZREREREREX4FDhw7B2NhY4TVv3jzcuXMHAFC1alUx9vLlywpxhw4dyrfvpk2bKvWdlZWlEFOhQgXo6emhYcOGGD16NIYOHZpnf2PHjkWjRo1Qq1Yt2NnZoU+fPggKCkJ6erpC3G+//Ya0tDS0bt0aAODj4wO5XK7WuGgaLxcnIiIiIiL6Cnh4eGDNmjUKbaVLl8b69euVYmvXri0ubla5cmVkZmbm23dYWBiqVaum0Katra3w/uzZs3jz5g0uXLiAqVOnwtHREd7e3rn2Z2RkhMOHD+P+/fs4c+YMLly4gEmTJuGnn37C+fPnYWhoCACQy+Xo3bs3pNIPpa23tze+//57xMTEKPzS4HNikU1ERERERPQVMDIygqOjo1J75cqVAQAxMTHiomF6enq5xubFxsamwHh7e3sAQK1atfD8+XP4+/vnWWTncHBwgIODA4YOHYoZM2agSpUqCAsLw6BBg5CYmIh9+/YhIyND4ZcHWVlZCAoKwqJFi1TOX5N4uTgREREREdFXzMvLC6VLl/6sRakgCEqXfhfEzs4OhoaGSE1NBQBs2bIFFSpUQHR0NKKiosTXihUrEBoaWuDse1HhTDYREREREdFXID09HfHx8QptUqkUlpaW2LBhA3r37o327dtj3LhxqFy5Mt68eYNjx44BUL70+2MJCQlKfZuZmUFfXx+rVq1CxYoV4eTkBODDc7OXLl2KsWPHirF79+7FtGnT8L///Q8A4O/vj7S0NLRr1w62trZITk7Gzz//jIyMDHh6egL4cKl4jx49ULNmTYXj2traws/PD4cPH0bnzp0LMVKfhkU2ERERERHRJxi9tmQ8P+zYsWOwsrJSaKtatSr+97//oWvXroiMjMSiRYswYMAAJCYmwtTUFA0bNsT27dvRoUOHfPtu1aqVUtu2bdvQp08fZGdnY9q0aXj48CGkUikcHBywcOFCjBgxQox99eoVYmJixPdubm5YtWoVBgwYgOfPn8Pc3Bz16tXDiRMnULVqVfz555+Ijo7O9X5yExMTeHl5QS6Xs8gmIiIiIiIizQsJCUFISEi+MQ0bNsTOnTvzjbGzs1N4ZvbH73MzduxYhVnr3Pj6+sLX11d87+HhAQ8PjzzjGzRokO9xDxw4kO/xihLvySYiIiIiIiLSEBbZRERERERERBrCIpuIiIiIiIhIQ1hkExEREREREWkIi2wiIiIiIiIiDWGRTURERERERKQhLLKJiIiIiIiINIRFNhEREREREZGGsMgmIiIiIiIi0hBpcSdARERERERUkv3Yu8NnPd6ksENq7+Pr64vk5GTs378/37iBAwfC398f9vb2uHbtGurWrauwvUuXLjAzM0NISAgAwN3dHREREQAAiUSCMmXKoHnz5li6dClsbW2V+k9ISECdOnXw7NkzJCUlwczMLM9crl27hpkzZ+LSpUtISUmBTCaDi4sLVq1aBUtLS4XYgIAAzJw5EwsWLMDUqVMLHpAixJlsIiIiIiKir0RcXJz4WrFiBUqVKqXQ9tNPP6nd57BhwxAXF4dnz55h//79+Pvvv+Hj45Nr7JAhQ1C7du0C+3zx4gVatWoFS0tLHD9+HLdv30ZQUBCsrKyQlpamFB8cHIwpU6YgKChI7fw1jTPZREREREREXwmZTCb+2dTUFBKJRKENAJKSktTq09DQUOzDysoKo0ePxsiRI5Xi1qxZg+TkZMyaNQtHjx7Nt8/IyEikpKRgw4YNkEo/lK329vZo0aKFUmxERATevn2LuXPnYuPGjfj999/RvHlztc5BkziTTURERERERBqRmJiInTt3wsXFRaH91q1bYhGspVVwGSqTyZCZmYm9e/dCEIR8Y+VyOby9vaGjowNvb2/I5fJPOodPxSKbiIiIiIiICm316tUwNjaGkZERLCwsEBMTo3DZdnp6Ory9vbFkyRJUrFhRpT4bN26M6dOno2/fvrC0tETbtm2xZMkSPH/+XCEuJSUFu3fvFi9P9/Hxwa5du5CSkqK5E1QTi2wiIiIiIiIqtH79+iEqKgrR0dE4d+4cHB0d4eXlhdevXwMApk2bhmrVquV5n3ZeFixYgPj4eKxduxbVq1fH2rVr4eTkhBs3bogxW7duRaVKlVCnTh0AQN26dVGpUiVs375dcyeoJhbZREREREREJDI1NQUAvHr1SmlbcnKyuP3f8Y6OjnB0dISrqyvkcjnu3r2LsLAwAMDp06exc+dOSKVSSKVStGzZEgBgaWmJ2bNn55uLhYUFevbsiR9//BG3b9+GtbU1li5dKm4PCgrCzZs3xb6lUilu3rxZrJeMc+EzIiIiIiIiEpmbm6NMmTK4fPky3NzcxPa3b9/i5s2b6NWrV777a2tri/EAsHv3bvHPAHD58mUMHjwYZ8+ehYODg8p56erqwsHBAampqQCAGzdu4MqVKwgPD0fp0qXFuOTkZDRv3hx//fUXatasqXL/msIim4iIiIiIiBRMnjwZAQEBKFeuHJo2bYqkpCQsWrQIUqlU6bLvtLQ0xMfHAwCeP3+O+fPnQ19fH15eXgCgVEj/888/AIBq1aqJz8l+9uwZWrZsiY0bN8LZ2RmHDh3C9u3b0adPH1SpUgWCIODgwYM4cuQIgoODAXxY8MzZ2TnXlcSbNGkCuVyO5cuXa3RcVMEim4iIiIiIiBRMnjwZxsbGWLp0Ke7fvw8zMzM0btwYZ8+eRalSpRRi169fj/Xr1wP4MAteu3ZtHDlyBFWrVlX5eBkZGYiJiRGfgV29enUYGhpi0qRJ+Pvvv6Gnp4fKlStjw4YN6N+/P96/f4/NmzfDz88v1/66d++OwMBALFq0CLq6uoUchcJhkU1ERERERPQJJoUdKu4UChQSEqLU5uvrC19f31zjtbS0MGrUKIwaNSrffsPDw9XOxd3dXemxXHZ2dgptlSpVwrp16/LsQ1dXV5wRz83EiRMxceJEtXPTBC58RkRERERERKQhLLKJiIiIiIiINIRFNhEREREREZGGsMgmIiIiIiIi0hAW2UREREREREQawiKbiIiIiIiISENYZBMRERERERFpSKGek52dnY179+7hxYsXyM7OVtjWvHlzjSRGREREREREVNKoXWRfuHABffv2xePHj5UeIC6RSJCVlaWx5IiIiIiIiIhKErWL7JEjR6Jhw4Y4fPgwrKysIJFIiiIvIiIiIiIiohJH7SL77t272LVrFxwdHYsiHyIiIiIiohLl6dSzn/V4FRY2U3ufFy9eYObMmTh69CieP38Oc3Nz1KlTB/7+/mjSpIkYFxkZiWbNmsHT0xPHjh1T6OPRo0ewt7dHmTJlcP/+fZiYmIjb6tatiy5dusDf3x8A4O7ujoiICAAfrnguU6YMmjdvjqVLl8LW1lYpv4SEBNSpUwfPnj1DUlISzMzM8jyXa9euYebMmbh06RJSUlIgk8ng4uKCVatWwdLSUiE2ICAAM2fOxIIFCzB16lR1h61Q1F74zMXFBffu3SuKXIiIiIiIiKgIdO/eHdHR0QgNDcWdO3dw4MABuLu7IzExUSEuKCgIY8eOxblz5/DkyZNc+3r9+jWWLl1a4DGHDRuGuLg4PHv2DPv378fff/8NHx+fXGOHDBmC2rVrF9jnixcv0KpVK1haWuL48eO4ffs2goKCYGVlhbS0NKX44OBgTJkyBUFBQQX2rSlqz2SPHTsWkyZNQnx8PGrVqgUdHR2F7aoMDBEREREREX0eycnJOHfuHMLDw+Hm5gYAsLW1hbOzs0JcamoqduzYgcuXLyM+Ph4hISGYNWuWUn9jx47FsmXLMHr0aJQtWzbP4xoaGkImkwEArKysMHr0aIwcOVIpbs2aNUhOTsasWbNw9OjRfM8lMjISKSkp2LBhA6TSD+Wsvb09WrRooRQbERGBt2/fYu7cudi4cSN+//33z7JQt9oz2d27d8ft27cxePBgNGrUCHXr1kW9evXE/xIREREREdGXw9jYGMbGxti3bx/S09PzjAsLC0PVqlVRtWpV+Pj4IDg4WGmxawDw9vaGo6Mj5s6dq3IOiYmJ2LlzJ1xcXBTab926JRbBWloFl6cymQyZmZnYu3dvrrn9m1wuh7e3N3R0dODt7Q25XK5yvp9C7SL74cOHSq8HDx6I/yUiIiIiIqIvh1QqRUhICEJDQ2FmZgZXV1dMnz4d169fV4iTy+Xi5dxt2rTBmzdvcOrUKaX+JBIJFi5ciHXr1uH+/ft5Hnf16tUwNjaGkZERLCwsEBMTo3DZdnp6Ory9vbFkyRJUrFhRpXNp3Lgxpk+fjr59+8LS0hJt27bFkiVL8Pz5c4W4lJQU7N69WzwfHx8f7Nq1CykpKSod51OoXWTb2trm+yIiIiIiIqIvS/fu3REbG4sDBw6gdevWCA8PR/369RESEgIAiImJwaVLl9CnTx8AHwrz3r1753kvc+vWrfHNN99g5syZeR6zX79+iIqKQnR0NM6dOwdHR0d4eXnh9evXAIBp06ahWrVqed6nnZcFCxYgPj4ea9euRfXq1bF27Vo4OTnhxo0bYszWrVtRqVIl1KlTB8CHhdkqVaqE7du3q3WswlD7nmwAuH//PlasWIHbt29DIpGgWrVq+O677+Dg4KDp/Eqkoe9aFncKJRLHTX0cs8LhuKmPY1Y4HDf1ccwKh+OmPo5Z4XDcSjZ9fX14enrC09MTs2bNwtChQzF79mz4+vpCLpcjMzMT5cuXF+MFQYCOjg6SkpJgbm6u1N/ChQvRpEkTfP/997kez9TUVHwqlaOjI+RyOaysrBAWFoahQ4fi9OnTuHHjBnbt2iUeDwAsLS0xY8YMzJkzJ89zsbCwQM+ePdGzZ08EBgaiXr16WLp0KUJDQwF8WMDt5s2b4n3bAJCdnQ25XI7hw4erOXLqUbvIPn78ODp16oS6devC1dUVgiAgMjISNWrUwMGDB+Hp6VkUeRIREREREZEGVa9eHfv27UNmZiY2btyIH3/8EV5eXgox3bt3x5YtWzBmzBil/Z2dndGtWzeVH42lra0NAHj79i0AYPfu3eKfAeDy5csYPHgwzp49q9YErq6uLhwcHJCamgoAuHHjBq5cuYLw8HCULl1ajEtOTkbz5s3x119/oWbNmir3ry61i+ypU6diwoQJWLhwoVK7n58fi2wiIiIiIqIvSEJCAnr27InBgwejdu3aMDExwZUrV7B48WJ07twZhw4dQlJSEoYMGQJTU1OFfXv06AG5XJ5rkQ18uHS7Ro0aCjPGOdLS0hAfHw8AeP78OebPnw99fX2xkP+4kP7nn38AANWqVROfk/3s2TO0bNkSGzduhLOzMw4dOoTt27ejT58+qFKlCgRBwMGDB3HkyBEEBwcD+HBvubOzc64riTdp0gRyuRzLly9XYwTVo/Y92bdv38aQIUOU2gcPHoxbt25pJCkiIiIiIiLSDGNjY7i4uGD58uVo3rw5atasiZkzZ2LYsGFYuXIl5HI5WrVqpVRgAx9msqOionD16tVc+65SpQoGDx6Md+/eKW1bv349rKysYGVlBQ8PD7x8+RJHjhxB1apVVc49IyMDMTEx4jOwq1evDkNDQ0yaNAl169ZF48aNsWPHDmzYsAH9+/fH+/fvsXnzZnTv3j3X/rp3747Nmzfj/fv3KuegLrVnssuUKYOoqChUrlxZoT0qKirfZ6QRERERERH9F1VY2Ky4U8iXnp4eAgMDERgYmOv2gwcP5rlv/fr1FR6Vldtjs3799Vf8+uuvCm3h4eFq5+nu7q7Uv52dnUJbpUqVsG7dujz70NXVFWfEczNx4kRMnDhR7dzUoXaRPWzYMAwfPhwPHjxA06ZNIZFIcO7cOSxatAiTJk0qihyJiIiIiIiISgS1i+yZM2fCxMQEP/74I6ZNmwYAsLa2hr+/P8aNG6fxBImIiIiIiIhKCrWLbIlEggkTJmDChAni881MTEw0nhgRERERERFRSVOo52TnYHFNRERERERE9P9UKrLr16+PU6dOwdzcHPXq1YNEIskzNq9V54iIiIiIiIj+61Qqsjt37gw9PT3xz/kV2URERERERERfK5WK7NmzZ4t/9vf3L6pciIiIiIiIiEo0LXV3qFSpEhISEpTak5OTUalSJY0kRURERERERFQSqV1kP3r0CFlZWUrt6enpePr0qUaSIiIiIiIiIiqJVF5d/MCBA+Kfjx8/DlNTU/F9VlYWTp06BXt7e81mR0RERERERFSCqFxkd+nSBcCH52QPHDhQYZuOjg7s7Ozw448/ajQ5IiIiIiKiL93nXreqMMd78eIFZs6ciaNHj+L58+cwNzdHnTp14O/vjyZNmohxkZGRaNasGTw9PXHs2DGFPh49eqQwsWpmZoZatWph3rx5cHNzAwD4+voiNDQUAKCtrQ1ra2u0b98eAQEBMDc3F/ddt24dtm7diqtXr+L169dISkqCmZmZwvEWLFiAw4cPIyoqCrq6ukhOTi7wPB88eIAZM2YgIiICiYmJsLS0RIMGDbBkyRJUqVJFIXbr1q3o378/hg0bhrVr16o0jqpQ+XLx7OxsZGdno2LFinjx4oX4Pjs7G+np6YiJiUGHDh00lhgRERERERFpRvfu3REdHY3Q0FDcuXMHBw4cgLu7OxITExXigoKCMHbsWJw7dw5PnjzJta/ffvsNcXFxiIiIQKlSpdCuXTs8fPhQ3N6mTRvExcXh0aNH2LBhAw4ePIhRo0Yp9JGWloY2bdpg+vTpeeb8/v179OzZE99++61K5/j+/Xt4enoiJSUFe/bsQUxMDMLCwlCzZk28evVKKT4oKAhTpkzB9u3bkZaWptIxVKHyTHaOfw8eERERERERfdmSk5Nx7tw5hIeHizPOtra2cHZ2VohLTU3Fjh07cPnyZcTHxyMkJASzZs1S6s/CwgIymQwymQy//vorKlSogBMnTmDEiBEAAD09PchkMgBAhQoV0Lt3b4SEhCj0MX78eABAeHh4nnnPmTMHAJT2zcutW7fw4MEDnD59Gra2tuJ5urq6KsU+evQIkZGR2L17N86cOYNdu3ZhwIABKh2nIGoX2cCHwY+IiMCTJ0/w/v17hW3jxo3TSGJERERERET06YyNjWFsbIx9+/ahcePG0NPTyzUuLCwMVatWRdWqVeHj44OxY8di5syZkEgkefZtaGgIAMjIyMh1+4MHD3Ds2DHo6Oh8+okUoEyZMtDS0sKuXbswfvx4aGtr5xkbFBSE9u3bw9TUFD4+PpDL5cVXZF+7dg3t2rVDWloaUlNTUbp0afzzzz8wNDRE2bJlWWQTERERERF9QaRSKUJCQsR7j+vXrw83Nzf06dMHtWvXFuPkcjl8fHwAfLjk+82bNzh16hRatWqVa7+pqamYNm0atLW1xRlyADh06BCMjY2RlZWFd+/eAQCWLVtWhGf4Qfny5fHzzz9jypQpmDNnDho2bAgPDw/069dP4XHT2dnZCAkJwS+//AIA6NOnDyZOnIh79+7B0dHxk/NQ+xFeEyZMQMeOHZGYmAgDAwNcuHABjx8/RoMGDbB06dJPToiIiIiIiIg0q3v37oiNjcWBAwfQunVrhIeHo379+uKl2DExMbh06RL69OkD4ENh3rt3bwQFBSn11bRpUxgbG8PExAQHDx5ESEgIatWqJW738PBAVFQULl68iLFjx6J169YYO3bsZznP0aNHIz4+Hps3b0aTJk2wc+dO1KhRAydPnhRjTpw4gdTUVLRt2xYAYGlpCS8vr1zPtTDULrKjoqIwadIkaGtrQ1tbG+np6bCxscHixYvzvWmdiIiIiIiIio++vj48PT0xa9YsREZGwtfXF7NnzwbwYRY7MzMT5cuXh1QqhVQqxZo1a7Bnzx4kJSUp9BMWFobo6Gi8fPkSz549E2e/cxgZGcHR0RG1a9fGzz//jPT0dPH+6s/BxMQEnTp1woIFCxAdHY1mzZph/vz54vagoCAkJibC0NBQPNcjR44gNDQUWVlZn3x8tYtsHR0d8Zr8cuXKiSvOmZqa5rn6HBEREREREX1ZqlevjtTUVGRmZmLjxo348ccfERUVJb6io6Nha2uLLVu2KOxnY2MDBwcHWFhYqHSc2bNnY+nSpYiNjS2K08iXRCKBk5MTUlNTAQAJCQnYv38/tm/frnCuUVFRePPmDY4ePfrJx1T7nux69erhypUrqFKlCjw8PDBr1iz8888/2LRpk8IlAkRERERERFT8EhIS0LNnTwwePBi1a9eGiYkJrly5gsWLF6Nz5844dOgQkpKSMGTIEJiamirs26NHD8jlcowZM6bQx3d3d0eNGjUQEBCAlStXAgDi4+MRHx+Pe/fuAQBu3LgBExMTVKxYEaVLlwYAPHnyBImJiXjy5AmysrIQFRUFAHB0dISxsTEAwMnJCYGBgejatSuioqIwe/Zs9O/fH9WrV4euri4iIiIQFBQEPz8/AMCmTZtgYWGBnj17QktLcc65Q4cOkMvln/xoarWL7ICAALx+/RoAMG/ePAwcOBDffvstHB0dNXYNOxEREREREWmGsbExXFxcsHz5cty/fx8ZGRmwsbHBsGHDMH36dPTq1QutWrVSKrCBD/dyBwQE4OrVq2LxWxgTJ07EoEGD4OfnBxsbG6xdu1bhEvLmzZsDAIKDg+Hr6wsAmDVrFkJDQ8WYevXqAQDOnDkDd3d3AB/uJc95BnaFChVgZ2eHOXPm4NGjR5BIJOL7CRMmAPhwqXjXrl2VCuycc+3duzeeP3+OcuXKFfpc1S6yGzZsKP65TJkyOHLkSKEPTkREREREVNL5+/sXdwr50tPTQ2BgIAIDA3PdfvDgwTz3rV+/PgRBEN//+8+5yeuZ1n379kXfvn3F9/7+/gWOW0hISIHPyP53PpaWlvjpp5/yjb9+/Xqe27p165bno8jUofY92Q8fPsTdu3eV2u/evYtHjx59ckJEREREREREJZXaRbavry8iIyOV2i9evChO6xMRERERERF9jdQusq9duwZXV1el9saNG4s3omtSzpLwFhYWMDQ0RN26dfHnn3+K2wVBgL+/P6ytrWFgYAB3d3fcvHlT43kQERERERERFUTte7IlEom48Nm/vXr1SiPPFPu3pKQkuLq6wsPDA0ePHkXZsmVx//59mJmZiTGLFy/GsmXLEBISgipVqmD+/Pnw9PRETEwMTExMNJqPqsIeLiqW46piEpoVdwp54ripj2NWOBw39XHMCofjpj6OWeFw3NTHMSscjhtRwdSeyW7WrBkCAwMVCuqsrCwEBgbim2++0WhyixYtgo2NDYKDg+Hs7Aw7Ozu0bNkSDg4OAD7MYq9YsQIzZsxAt27dULNmTYSGhiItLQ1bt27VaC5EREREREREBVF7Jnvx4sVo3rw5qlatimbNPvy26OzZs0hJScHp06c1mtyBAwfQunVr9OzZExEREShfvjxGjRqFYcOGAfiwCFt8fDy8vLzEffT09ODm5obIyEiMGDEi137T09ORnp4uvk9JSQEAZGRkaGQ1OYlU55P7KCqaOL+iwnFTH8escDhu6uOYFQ7HTX0cs8LhuKmPY1Y4X8O4fcnjTyWDRChoDfZcxMbGYuXKlYiOjoaBgQFq166NMWPGfNJz03Kjr68P4MMz1Xr27IlLly5h/Pjx+PXXXzFgwABERkbC1dUVz549g7W1tbjf8OHD8fjxYxw/fjzXfv39/RWeyZZj69atMDQ01Og5EBERERFRyZGWloa+ffvi1atXKFWqlMK2d+/e4eHDh7C3txdrFfo6qPOzV3smGwCsra0REBBQqOTUkZ2djYYNG4rHqlevHm7evIk1a9ZgwIABYpxEIlHYTxAEpbZ/mzZtGiZOnCi+T0lJgY2NDby8vJS+SIXxi2+vT+6jqIwN2VHcKeSJ46Y+jlnhcNzUxzErHI6b+jhmhcNxUx/HrHC+hnHLucqVqLAKVWQnJydDLpfj9u3bkEgkqF69OgYPHgxTU1ONJmdlZYXq1asrtFWrVg27d+8GAMhkMgBAfHw8rKysxJgXL16gXLlyefarp6cHPT09pXYdHR3o6Hz6JTBC5pd7iYkmzq+ocNzUxzErHI6b+jhmhcNxUx/HrHA4burjmBXO1zBuX/L4U8mg9sJnV65cgYODA5YvX47ExET8888/WLZsGRwcHHD16lWNJufq6oqYmBiFtjt37sDW1hYAYG9vD5lMhpMnT4rb379/j4iICDRt2lSjuRAREREREREVRO2Z7AkTJqBTp05Yv349pNIPu2dmZmLo0KEYP348fv/9d40lN2HCBDRt2hQBAQHo1asXLl26hHXr1mHdunUAPlwmPn78eAQEBKBy5cqoXLkyAgICYGhoiL59+2osDyIiIiIiorycOu3wWY/XssV9tfd58eIFZs6ciaNHj+L58+cwNzdHnTp14O/vjyZNmsDOzg6PHz8GAGhpaaFcuXJo27Ytli5dCnNzcwBAamoq5s6di507dyI2NhYmJiaoUaMGJk+ejA4dOgAA3N3dERERAQDQ1dWFra0tfH194efnB21tbcTExGDkyJG4desWXr16BWtra/Tt2xezZ8/O9yqCM2fOYO7cuYiOjsa7d+9Qvnx5NG3aFHK5XKxLcwwfPhxyuRxbtmxBnz591B6rT6V2kX3lyhWFAhsApFIppkyZgoYNG2o0uUaNGmHv3r2YNm0a5s6dC3t7e6xYsQL9+vUTY6ZMmYK3b99i1KhRSEpKgouLC06cOFFsz8gmIiIiIiL60nTv3h0ZGRkIDQ1FpUqV8Pz5c5w6dQqJiYlizNy5czFs2DBkZWXhzp07GD58OMaNG4dNmzYBAEaOHIlLly5h5cqVqF69OhISEhAZGYmEhASFYw0bNgxz587Fu3fvcOjQIYwbNw7a2trw8/ODjo4OBgwYgPr168PMzAzR0dEYNmwYsrOz81z36+bNm2jbti3GjRuHX375BQYGBrh79y527dqF7Oxshdi0tDSEhYXh+++/h1wuLxlFdqlSpfDkyRM4OTkptP/9999FUth26NBB/K1IbiQSCfz9/eHv76/xYxMREREREZV0ycnJOHfuHMLDw+Hm5gYAsLW1hbOzs0KciYmJuO5V+fLlMWDAAGzfvl3cfvDgQfz0009o164dAMDOzg4NGjRQOp6hoaHYz5gxY7B//37s27cPfn5+qFSpEipVqiTG2traIjw8HGfPns0z/5MnT8LKygqLFy8W2xwcHNCmTRul2J07d6J69eqYNm0arKys8OjRI9jZ2RU0RBql9j3ZvXv3xpAhQxAWFoa///4bT58+xfbt2zF06FB4e3sXRY5ERERERERUSMbGxjA2Nsa+ffuQnp6u0j7Pnj3DoUOH4OLiIrbJZDIcOXIEr1+/Vuv4BgYGeT5//N69ezh27JhY/OdGJpMhLi5OpVuT5XI5fHx8YGpqinbt2iE4OFitXDVB7SJ76dKl6NatGwYMGAA7OzvxGvsePXpg0aJFRZEjERERERERFZJUKkVISAhCQ0NhZmYGV1dXTJ8+HdevX1eI8/Pzg7GxMQwMDFChQgVIJBIsW7ZM3L5u3TpERkbCwsICjRo1woQJE/DHH3/kedzs7GwcO3YMx48fR8uWLRW2NW3aFPr6+qhcuTKaNWuGuXPn5tlPz5494e3tDTc3N1hZWaFr165YuXKl0uPW7t69iwsXLqB3794AAB8fHwQHBytdUl7U1C6ydXV18dNPPyEpKQlRUVG4du0aEhMTsXz58lwfi0VERERERETFq3v37oiNjcWBAwfQunVrhIeHo379+ggJCRFjvv/+e0RFReH69es4deoUAKB9+/bIysoCADRv3hwPHjzAqVOn0L17d9y8eRPNmjXDvHnzFI61evVqGBsbQ19fH506dYKPjw9mz56tEBMWFoarV69i69atOHz4MJYuXZpn7tra2ggODsbTp0+xePFiWFtbY8GCBahRowbi4uLEOLlcjtatW8PS0hIA0K5dO6SmpuK33377pLFTl9pFdg5DQ0PUqlULtWvXhqGhoSZzIiIiIiIiIg3T19eHp6cnZs2ahcjISPj6+ioUv5aWlnB0dETlypXRokULrFixApGRkThz5owYo6Ojg2bNmmHq1Kk4ceIE5s6di3nz5uH9+/diTL9+/RAVFYX79+/j7du3kMvlSjWjjY0NqlevDm9vbyxcuBD+/v5iMZ+X8uXLo3///li1ahVu3bqFd+/eYe3atQCArKwsbNy4EYcPH4ZUKoVUKoWhoSESExMhl8s1MXwqU2nhs27duqnc4Z49ewqdDBEREREREX0e1atXx759+/Lcrq2tDQB4+/Ztvn1kZmbi3bt30NXVBQCYmprC0dFR5TwEQUBGRgYEQVB5H3Nzc1hZWSE1NRUAxHvFr127JuYNAP/73//Qr18/JCQkwMLCQuX+P4VKRbapqWlR50FERERERERFICEhAT179sTgwYNRu3ZtmJiY4MqVK1i8eDE6d+4sxr1+/Rrx8fEQBAF///03pkyZAktLSzRt2hTAh2dge3t7o2HDhrCwsMCtW7cwffp0eHh4oFSpUirlsmXLFujo6KBWrVrQ09PDn3/+iWnTpqF3797iY6IvXbqEAQMG4NSpUyhfvjx+/fVXREVFoWvXrnBwcMC7d++wceNG3Lx5E7/88guAD5eKt2/fHnXq1FE4Xo0aNTB+/Hhs3rwZ3333nSaGs0AqFdnFsSIbERERERERfTpjY2O4uLhg+fLluH//PjIyMmBjY4Nhw4Zh+vTpYtysWbMwa9YsAECZMmXQqFEjnDx5UpwBbt26NUJDQzF9+nSkpaXB2toaHTp0EPdRhVQqxaJFi3Dnzh0IggBbW1uMHj0aEyZMEGPS0tIQExMjrkju7OyMc+fOYeTIkYiNjYWxsTFq1KiBffv2wc3NDc+fP8fhw4exdetWpeNJJBJ069YNcrn8yyqyiYiIiIiIKHctW9wv7hTypaenh8DAQAQGBuYZ8+jRowL7mTZtGqZNm5ZvTHh4eL7be/fuLa7+nRd3d3eFS8fr1auHTZs25Rlfrly5PB8RBgA///xzvsfTNJWK7Hr16kEikajU4dWrVz8pISIiIiIiIqKSSqUiu0uXLkWcBhEREREREVHJp1KR/fEzzfKSmZn5SckQERERERERlWSFfk72v926dQuTJk1C+fLlNdEdERERERERUYlU6CL7zZs32LBhA5o0aYLatWvj4sWLmDp1qiZzIyIiIiIiIipR1F5d/Ny5c9iwYQN2794Ne3t73Lp1CxEREXB1dS2K/IiIiIiIiIhKDJWL7MWLFyMoKAhv3ryBt7c3zp07hzp16kBHRwfm5uZFmWOJo28+sbhTKJE4burjmBUOx019HLPC4bipj2NWOBw39XHMCofjRlQwlYvs6dOnw8/PD3PnzoW2tnZR5kRERERERERUIql8T/bcuXOxc+dO2Nvbw8/PD3/99VdR5kVERERERERU4qhcZE+fPh137tzBpk2bEB8fj8aNG6NOnToQBAFJSUlFmSMRERERERFRiaD2wmdubm5wc3PDypUrsWXLFgQHB8PNzQ3Ozs7o0aMHJk7kfRpERERERPT1kJ2J+qzHi/eoq3KsRCLJd/vAgQMREhKiEGdkZAQHBwdMmDABvr6+Ynt4eDg8PDzE95aWlmjYsCEWLlyIOnXqAADc3d1Rt25drFixIt/jpqenw8XFBdHR0bh27Rrq1s37nB48eIAZM2YgIiICiYmJsLS0RIMGDbBkyRJUqVJFIXbr1q3o378/hg0bhrVr1+abQ1Ep9CO8TExMMHLkSFy8eBHXrl2Ds7MzFi5cqMnciIiIiIiI6BPExcWJrxUrVqBUqVIKbT/99JMYGxwcjLi4OERHR6N3794YNGgQjh8/rtRnTEwM4uLicPjwYSQlJaFNmzZ49eqVWnlNmTIF1tbWBca9f/8enp6eSElJwZ49exATE4OwsDDUrFkz12MGBQVhypQp2L59O9LS0tTKSVMKXWT/W61atbBixQo8e/ZME90RERERERGRBshkMvFlamoKiUSi1JbDzMwMMpkMDg4OmD59OkqXLo0TJ04o9Vm2bFnIZDI4Ozvjxx9/RHx8PC5cuKByTkePHsWJEyewdOnSAmNv3bqFBw8eYPXq1WjcuDFsbW3h6uqKBQsWoFGjRgqxjx49QmRkJKZOnQonJyfs2rVL5Zw0SSNFdg4dHR1NdkdERERERESfWVZWFnbs2IHExMQCazwDAwMAQEZGhkp9P3/+HMOGDcOmTZtgaGhYYHyZMmWgpaWFXbt2ISsrK9/YoKAgtG/fHqampvDx8YFcLlcpJ03TaJFNREREREREJZO3tzeMjY2hp6eH3r17o3Tp0hg6dGie8QkJCZgzZw5MTEzg7OxcYP+CIMDX1xcjR45Ew4YNVcqpfPny+PnnnzFr1iyYm5ujRYsWmDdvHh48eKAQl52djZCQEPj4+AAA+vTpg/Pnz+PevXsqHUeTWGQTERERERERli9fjqioKJw8eRJ169bF8uXL4ejoqBRXoUIFGBsbw9LSErdv38bOnTtRtmzZAvv/5ZdfkJKSgmnTpqmV1+jRoxEfH4/NmzejSZMm2LlzJ2rUqIGTJ0+KMSdOnEBqairatm0L4MOibF5eXggKClLrWJrAIpuIiIiIiIggk8ng6OgIDw8P7Ny5E6NHj8atW7eU4s6ePYvo6Gi8evUKd+7cQevWrVXq//Tp07hw4QL09PQglUrFAr5hw4YYOHBgvvuamJigU6dOWLBgAaKjo9GsWTPMnz9f3B4UFITExEQYGhpCKpVCKpXiyJEjCA0NLfAyc00rVJF9//59/PDDD/D29saLFy8AAMeOHcPNmzc1mhwRERERERF9fo6OjujevXuus8729vZwcHBAqVKl1Orz559/RnR0NKKiohAVFYUjR44AAMLCwrBgwQKV+5FIJHByckJqaiqAD5et79+/H9u3bxf7znm9efMGR48eVSvPT6X2c7IjIiLQtm1buLq64vfff8eCBQtQtmxZXL9+HRs2bCi2FdyIiIiIiIhIcyZNmoQ6dergypUrKt9DDQAvX75EVFSUQptMJkPFihUV2oyNjQEADg4OqFChgtju5OSEwMBAdO3aFVFRUZg9ezb69++P6tWrQ1dXFxEREQgKCoKfnx8AYNOmTbCwsEDPnj2hpaU4j9yhQwfI5XJ06NBBnVP/JGrPZE+dOhXz58/HyZMnoaurK7Z7eHjg/PnzGk2OiIiIiIiIiketWrXQqlUrzJo1S639tm7dinr16im81q5dq/L+MTEx4jOwK1SoADs7O8yZMwcuLi6oX78+fvrpJ8yZMwczZswA8OFS8a5duyoV2ADQvXt3HDp0CM+fP1frHD6F2jPZN27cwNatW5Xay5Qpg4SEBI0kRUREREREVFLEe9Qt7hRU4uvrC19f31y3CYKQa/u/n5Pt7u6eZ1yO8PBwlfOxs7PLtb9/t1laWuKnn37Kt5/r16/nua1bt24qP15MU9SeyTYzM0NcXJxS+7Vr11C+fHmNJEVERERERERUEqldZPft2xd+fn6Ij4+HRCJBdnY2/vjjD0yePBkDBgwoihyJiIiIiIiISgS1i+wFCxagYsWKKF++PN68eYPq1aujefPmaNq0KX744YeiyJGIiIiIiIioRFD7nmwdHR1s2bIFc+fOxbVr15CdnY169eqhcuXKRZEfERERERERUYlRqEd4ubm5wcHBAQ4ODkWRExEREREREVGJpPbl4p6enqhYsSKmTp2Kv/76qyhyIiIiIiIi+mJlZ2cXdwr0manzM1d7Jjs2Nhbbt2/Htm3bsHjxYtSsWRM+Pj7o27evwgPEiYiIiIiI/kt0dXWhpaWF2NhYlClTBrq6upBIJMWdFhUhQRDw/v17vHz5ElpaWtDV1S1wH7WLbEtLS4wZMwZjxozBw4cPsXXrVmzcuBHTp09H8+bNcfr06UIlT0RERERE9CXT0tKCvb094uLiEBsbW9zp0GdkaGiIihUrQkur4IvB1S6y/83e3h5Tp05FnTp1MHPmTERERHxKd0RERERERF80XV1dVKxYEZmZmcjKyirudOgz0NbWhlQqVfmqhUIX2X/88Qe2bNmCXbt24d27d+jUqRMCAgIK2x0REREREVGJIJFIoKOjAx0dneJOhb5AahfZ06dPx7Zt2xAbG4tWrVphxYoV6NKlCwwNDYsiPyIiIiIiIqISQ+0iOzw8HJMnT0bv3r1haWlZFDkRERERERERlUhqF9mRkZFFkQcRERERERFRiadSkX3gwAG0bdsWOjo6OHDgQL6xnTp10khiRERERERERCWNSkV2ly5dEB8fj7Jly6JLly55xkkkEq6wR0RERERERF8tlYrs7OzsXP9MRERERERERP+v4Cdpf2Tjxo1IT09Xan///j02btyokaSIiIiIiIiISiK1i+xBgwbh1atXSu2vX7/GoEGDNJIUERERERERUUmkdpEtCAIkEolS+9OnT2FqaqqRpIiIiIiIiIhKIpUf4VWvXj1IJBJIJBK0bNkSUun/75qVlYWHDx+iTZs2RZIkERERERERUUmgcpGds6p4VFQUWrduDWNjY3Gbrq4u7Ozs0L17d40nSERERERERFRSqFxkz549GwBgZ2eH3r17Q19fv8iSIiIiIiIiIiqJVC6ycwwcOLAo8iAiIiIiIiIq8dQusrOysrB8+XLs2LEDT548wfv37xW2JyYmaiw5IiIiIiIiopJE7dXF58yZg2XLlqFXr1549eoVJk6ciG7dukFLSwv+/v5FkCIRERERERFRyaB2kb1lyxasX78ekydPhlQqhbe3NzZs2IBZs2bhwoULRZEjERERERERUYmgdpEdHx+PWrVqAQCMjY3x6tUrAECHDh1w+PBhzWZHREREREREVIKoXWRXqFABcXFxAABHR0ecOHECAHD58mXo6elpNjsiIiIiIiKiEkTtIrtr1644deoUAOC7777DzJkzUblyZQwYMACDBw/WeIJEREREREREJYXaq4svXLhQ/HOPHj1QoUIFREZGwtHREZ06ddJockREREREREQlidpF9scaN26Mxo0bayIXIiIiIiIiohJNpSL7wIEDKnfI2WwiIiIiIiL6WqlUZHfp0kWlziQSCbKysj4lHyIiIiIiIqISS6UiOzs7u6jzICIiIiIiIirx1F5dnIiIiIiIiIhyp/bCZ3Pnzs13+6xZswqdDBEREREREVFJpnaRvXfvXoX3GRkZePjwIaRSKRwcHFhkExERERER0VdL7SL72rVrSm0pKSnw9fVF165dNZIUERERERERUUmkkXuyS5Uqhblz52LmzJma6I6IiIiIiIioRNLYwmfJycl49eqVprojIiIiIiIiKnHUvlz8559/VngvCALi4uKwadMmtGnTRmOJEREREREREZU0ahfZy5cvV3ivpaWFMmXKYODAgZg2bZrGEiMiIiIiIiIqadQush8+fFgUeRARERERERGVeBq7J5uIiIiIiIjoa6f2TPa7d+/wyy+/4MyZM3jx4gWys7MVtl+9elVjyRERERERERGVJGoX2YMHD8bJkyfRo0cPODs7QyKRFEVeRERERERERCWO2kX24cOHceTIEbi6uhZFPkREREREREQlltr3ZJcvXx4mJiZFkQsRERERERFRiaZ2kf3jjz/Cz88Pjx8/Lop88hUYGAiJRILx48eLbYIgwN/fH9bW1jAwMIC7uztu3rz52XMjIiIiIiIiUrvIbtiwId69e4dKlSrBxMQEpUuXVngVlcuXL2PdunWoXbu2QvvixYuxbNkyrFy5EpcvX4ZMJoOnpydev35dZLkQERERERER5Ubte7K9vb3x7NkzBAQEoFy5cp9l4bM3b96gX79+WL9+PebPny+2C4KAFStWYMaMGejWrRsAIDQ0FOXKlcPWrVsxYsSIIs+NiIiIiIiIKIfaRXZkZCTOnz+POnXqFEU+uRo9ejTat2+PVq1aKRTZDx8+RHx8PLy8vMQ2PT09uLm5ITIyMs8iOz09Henp6eL7lJQUAEBGRgYyMjI+OV+JVPjkPoqKJs6vqHDc1McxKxyOm/o4ZoXDcVMfx6xwOG7q45gVztcwbl/y+FPJIBEEQa1vSv369bF69Wo0bty4qHJSsH37dsyfPx9XrlyBvr4+3N3dUbduXaxYsQKRkZFwdXXFs2fPYG1tLe4zfPhwPH78GMePH8+1T39/f8yZM0epfevWrTA0NCyycyEiIiIioi9bWloa+vbti1evXqFUqVLFnQ6VQGrPZC9cuBCTJk3CggULUKtWLejo6Chs1+QH8e+//8Z3332HEydOQF9fP8+4jy9ZFwQh38vYp02bhokTJ4rvU1JSYGNjAy8vL43kv37C75/cR1EZtrx5caeQJ46b+jhmhcNxUx/HrHA4burjmBUOx019HLPC+RrGLecqV6LCUnsmW0vrw1ppeRW2WVlZGktu37596Nq1K7S1tcW2rKwsSCQSaGlpISYmBo6Ojrh69Srq1asnxnTu3BlmZmYIDQ1V6TgpKSkwNTXV2G+rbjtV++Q+ikq1/90u7hTyxHFTH8escDhu6uOYFQ7HTX0cs8LhuKmPY1Y4X8O4abo2oK+P2jPZZ86cKYo8ctWyZUvcuHFDoW3QoEFwcnKCn58fKlWqBJlMhpMnT4pF9vv37xEREYFFixZ9tjyJiIiIiIiIgEIU2W5ubkWRR65MTExQs2ZNhTYjIyNYWFiI7ePHj0dAQAAqV66MypUrIyAgAIaGhujbt+9ny5OIiIiIiIgIKESR/fvv+d+H0bz5572HZMqUKXj79i1GjRqFpKQkuLi44MSJEzAxMfmseRARERERERGpXWS7u7srtf37/mxN3pOdm/DwcKVj+/v7w9/fv0iPS0RERERERFQQLXV3SEpKUni9ePECx44dQ6NGjXDixImiyJGIiIiIiIioRFB7JtvU1FSpzdPTE3p6epgwYQL+/PNPjSRGREREREREVNKoPZOdlzJlyiAmJkZT3RERERERERGVOGrPZF+/fl3hvSAIiIuLw8KFC1GnTh2NJUZERERERERU0qhdZNetWxcSiQSCICi0N27cGEFBQRpLjIiIiIiIiKikUbvIfvjwocJ7LS0tlClTBvr6+hpLioiIiIiIiKgkUrvItrW1LYo8iIiIiIiIiEo8lRc+O336NKpXr46UlBSlba9evUKNGjVw9uxZjSZHREREREREVJKoXGSvWLECw4YNQ6lSpZS2mZqaYsSIEVi2bJlGkyMiIiIiIiIqSVQusqOjo9GmTZs8t3t5efEZ2URERERERPRVU7nIfv78OXR0dPLcLpVK8fLlS40kRURERERERFQSqVxkly9fHjdu3Mhz+/Xr12FlZaWRpIiIiIiIiIhKIpWL7Hbt2mHWrFl49+6d0ra3b99i9uzZ6NChg0aTIyIiIiIiIipJVH6E1w8//IA9e/agSpUqGDNmDKpWrQqJRILbt29j1apVyMrKwowZM4oyVyIiIiIiIqIvmspFdrly5RAZGYlvv/0W06ZNgyAIAACJRILWrVtj9erVKFeuXJElSkRERERERPSlU7nIBgBbW1scOXIESUlJuHfvHgRBQOXKlWFubl5U+RERERERERGVGGoV2TnMzc3RqFEjTedCREREREREVKKpvPAZEREREREREeWPRTYRERERERGRhrDIJiIiIiIiItIQFtlEREREREREGsIim4iIiIiIiEhDWGQTERERERERaQiLbCIiIiIiIiINYZFNREREREREpCEssomIiIiIiIg0hEU2ERERERERkYawyCYiIiIiIiLSEBbZRERERERERBoiLe4E/ot6Tftyh/VGcSeQD46b+jhmhcNxUx/HrHA4burjmBUOx019HLPC4bgRFYwz2UREREREREQawiKbiIiIiIiISENYZBMRERERERFpCItsIiIiIiIiIg1hkU3/197dB1lZnocfv84CIiBrBMsCsiKdKJpIohIlgilgZH0jiclMG6MpatBKjG2UZkzz0hFjxGgrOprEttNxNWlJ0s5obGeCulNAgsRUMYCKUmUUiLASlHeR1/P7oxPqBvDnffvAeXbP5/PfnmfZufbr8YZrz8sCAABQEEs2AAAAFMSSDQAAAAWxZAMAAEBBLNkAAABQEEs2AAAAFMSSDQAAAAWxZAMAAEBBLNkAAABQEEs2AAAAFMSSDQAAAAWxZAMAAEBBLNkAAABQEEs2AAAAFMSSDQAAAAWxZAMAAEBBLNkAAABQEEs2AAAAFMSSDQAAAAWxZAMAAEBBLNkAAABQEEs2AAAAFKR7rQfoip59ZWWtR+iUdEunWR7d0mmWR7d0muXRLZ1meXSD/z+PZAMAAEBBLNkAAABQEEs2AAAAFMSSDQAAAAWxZAMAAEBBLNkAAABQEEs2AAAAFMSSDQAAAAWxZAMAAEBBLNkAAABQEEs2AAAAFMSSDQAAAAWxZAMAAEBBLNkAAABQEEs2AAAAFMSSDQAAAAWxZAMAAEBBLNkAAABQEEs2AAAAFMSSDQAAAAUp9ZJ96623xumnnx59+/aNAQMGxEUXXRTLli3r8DnVajWmTZsWgwcPjl69esW4cePi+eefr9HEAAAA1LNSL9mPP/54fOUrX4knn3wy2traYteuXdHS0hJbt27d+zm33357zJgxI77//e/HU089FQMHDowJEybE5s2bazg5AAAA9ah7rQd4N4888kiHj1tbW2PAgAGxcOHC+JM/+ZOoVqtx1113xbe+9a343Oc+FxERDzzwQDQ1NcXMmTPj6quvrsXYAAAA1KlSL9l/aOPGjRER0a9fv4iIeOWVV6K9vT1aWlr2fk7Pnj1j7NixsWDBggMu2du3b4/t27fv/XjTpk0REbFz587YuXPn+x+04fD3/zUOliK+v4NFt3Sa5dEtnWZ5dEunWR7d0mmWpw66FbIPUNcq1Wq1Wush3otqtRqf+cxnYv369fHLX/4yIiIWLFgQY8aMiddeey0GDx6893P/4i/+IlasWBGPPvrofr/WtGnT4qabbtrn9pkzZ0bv3r0PzjcAAACU3ltvvRWXXHJJbNy4MRobG2s9Dp1Qp3kk+9prr40lS5bE/Pnz97lWqVQ6fFytVve57Z2+8Y1vxNSpU/d+vGnTpmhubo6WlpZC/kc6edr+l/syeG7aubUe4YB0S6dZHt3SaZZHt3Sa5dEtnWZ56qHb75/lCrk6xZL9l3/5l/Ef//EfMW/evBgyZMje2wcOHBgREe3t7TFo0KC9t69duzaampoO+PV69uwZPXv23Of2Hj16RI8ePd73vNt3H3jBr7Uivr+DRbd0muXRLZ1meXRLp1ke3dJplqceupW5P51Dqd9dvFqtxrXXXhsPPvhgzJ49O4YNG9bh+rBhw2LgwIHR1ta297YdO3bE448/HqNHjz7U4wIAAFDnSv1I9le+8pWYOXNmPPzww9G3b99ob2+PiIgjjzwyevXqFZVKJa677rqYPn16HH/88XH88cfH9OnTo3fv3nHJJZfUeHoAAADqTamX7HvvvTciIsaNG9fh9tbW1rj88ssjIuKGG26Ibdu2xTXXXBPr16+PUaNGxWOPPRZ9+/Y9xNMCAABQ70q9ZL+XNz6vVCoxbdq0mDZt2sEfCAAAAN5FqV+TDQAAAJ2JJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRsAAAAKYskGAACAgliyAQAAoCCWbAAAAChIl1myf/jDH8awYcPi8MMPj5EjR8Yvf/nLWo8EAABAnekSS/bPfvazuO666+Jb3/pW/OY3v4lPfOITcf7558fKlStrPRoAAAB1pEss2TNmzIjJkyfHlVdeGSeddFLcdddd0dzcHPfee2+tRwMAAKCOdK/1AO/Xjh07YuHChfE3f/M3HW5vaWmJBQsW7PfPbN++PbZv3773440bN0ZExJtvvhk7d+583zN137X1fX+Ng+WNN96o9QgHpFs6zfLolk6zPLql0yyPbuk0y1MP3TZv3hwREdVqtZCvR/2pVDv5vWf16tVxzDHHxBNPPBGjR4/ee/v06dPjgQceiGXLlu3zZ6ZNmxY33XTToRwTAADoRFatWhVDhgyp9Rh0Qp3+kezfq1QqHT6uVqv73PZ73/jGN2Lq1Kl7P96zZ0+8+eab0b9//wP+mVrZtGlTNDc3x6pVq6KxsbHW43QKmuXRLZ1meXRLp1ke3dJplke3dGVuVq1WY/PmzTF48OBaj0In1emX7KOPPjq6desW7e3tHW5fu3ZtNDU17ffP9OzZM3r27Nnhtg984AMHa8RCNDY2lu4AKjvN8uiWTrM8uqXTLI9u6TTLo1u6sjY78sgjaz0CnVinf+Ozww47LEaOHBltbW0dbm9ra+vw9HEAAAA42Dr9I9kREVOnTo0///M/j4997GNx5plnxj/90z/FypUrY8qUKbUeDQAAgDrSJZbsz3/+8/HGG2/Ed77znVizZk2cfPLJ8Ytf/CKGDh1a69Het549e8aNN964z9PbOTDN8uiWTrM8uqXTLI9u6TTLo1s6zejKOv27iwMAAEBZdPrXZAMAAEBZWLIBAACgIJZsAAAAKIglGwAAAApiyQYAAICCWLIBAACgIJbsTuT111+P73znO7Ueo1PRLI9u6TTLo1s6zfLolk6zPLql04yuxu/J7kQWL14cp512WuzevbvWo3QamuXRLZ1meXRLp1ke3dJplke3dJrR1XSv9QD8nyVLlrzr9WXLlh2iSToPzfLolk6zPLql0yyPbuk0y6NbOs2oNx7JLpGGhoaoVCqxv/8kv7+9Uqn4Kd87aJZHt3Sa5dEtnWZ5dEunWR7d0mlGvfFIdon0798/brvttvjkJz+53+vPP/98fOpTnzrEU5WbZnl0S6dZHt3SaZZHt3Sa5dEtnWbUG0t2iYwcOTJWr14dQ4cO3e/1DRs27PcngPVMszy6pdMsj27pNMujWzrN8uiWTjPqjSW7RK6++urYunXrAa8fe+yx0draeggnKj/N8uiWTrM8uqXTLI9u6TTLo1s6zag3XpMNAAAABfF7sgEAAKAgni5eMr/97W/j3nvvjQULFkR7e3tUKpVoamqK0aNHx5QpU6K5ubnWI5aOZnl0S6dZHt3SaZZHt3Sa5dEtnWbUE08XL5H58+fH+eefH83NzdHS0hJNTU1RrVZj7dq10dbWFqtWrYpZs2bFmDFjaj1qaWiWR7d0muXRLZ1meXRLp1ke3dJpRr2xZJfI6aefHmeddVbceeed+71+/fXXx/z58+Opp546xJOVl2Z5dEunWR7d0mmWR7d0muXRLZ1m1BtLdon06tUrFi1aFMOHD9/v9RdffDFOPfXU2LZt2yGerLw0y6NbOs3y6JZOszy6pdMsj27pNKPeeOOzEhk0aFAsWLDggNd/9atfxaBBgw7hROWnWR7d0mmWR7d0muXRLZ1meXRLpxn1xhuflcjXvva1mDJlSixcuDAmTJgQTU1NUalUor29Pdra2uKf//mf46677qr1mKWiWR7d0mmWR7d0muXRLZ1meXRLpxl1p0qp/PSnP62OGjWq2r1792qlUqlWKpVq9+7dq6NGjar+7Gc/q/V4paRZHt3SaZZHt3Sa5dEtnWZ5dEunGfXEa7JLaufOnbFu3bqIiDj66KOjR48eNZ6o/DTLo1s6zfLolk6zPLql0yyPbuk0ox54TXZJ9ejRIwYNGhRz586NHTt21HqcTkGzPLql0yyPbuk0y6NbOs3y6JZOM+qBR7JLrrGxMRYtWhR//Md/XOtROg3N8uiWTrM8uqXTLI9u6TTLo1s6zejKPJJdcn4Gkk6zPLql0yyPbuk0y6NbOs3y6JZOM7oySzYAAAAUxJJdcrNmzYpjjjmm1mN0Kprl0S3drFmzYvDgwbUeo9NxX0unWR7d0jnX8rivpdOMrsxrsumS5s6dG6NGjYpevXrVehS6oN27d8e6deuiUqlE//79o1u3brUeiTrgXONgcq5RC841uiqPZHciL7zwgjeHeI9aWlri1VdfrfUYpTVixIi4+eabY9WqVbUepVN56KGHYsyYMdG7d+8YPHhwDBo0KHr37h1jxoyJn//857Uer1Nyrr13zrV351zL41wrnnPtvXOu0VV5JLsTWbx4cZx22mmxe/fuWo9SGqeddtp+b1+0aFGceOKJcfjhh0dExDPPPHMoxyq9hoaG6NevX2zYsCHOOeecuOqqq+Izn/lMdO/evdajldY//uM/xl/91V/Fl770pTj33HOjqakpqtVqrF27Nh599NFobW2Ne+65J6666qpaj9qpONf25VzL41xL51w7OJxr+3KuUW/8zVMiU6dOfdfrv/vd7w7RJJ3Hs88+G+ecc058/OMf33tbtVqNxYsXx/jx42PAgAE1nK7clixZEv/93/8d9913X1x88cVx1FFHxaRJk2Ly5Mlx0kkn1Xq80vm7v/u7+OEPfxiTJ0/e59pFF10Up59+etxyyy3+MfoHnGvpnGv5nGtpnGt5nGvpnGvUG49kl0i3bt3ilFNOicbGxv1e37JlSzzzzDN+MvoOTzzxRFx22WVx6aWXxo033hgNDf/7CogePXrE4sWL40Mf+lCNJyynhoaGaG9v3/uXWnt7e7S2tkZra2ssX748Ro0aFVdeeWV86UtfqvGk5dGrV69YtGhRDB8+fL/XX3zxxTj11FNj27Zth3iycnOupXOu5XGupXOu5XGupXOuUXeqlMbw4cOrP/7xjw94/Te/+U21oaHhEE7UOWzcuLF68cUXV88444zqyy+/XK1Wq9Xu3btXn3/++RpPVl4NDQ3V119/fb/X5syZU/3iF79Y7dOnzyGeqtxGjhxZnTp16gGvT506tTpy5MhDOFHn4FzL41xL51xL51zL41zL41yjnni6eImMHDkyFi5cGF/84hf3e71SqUTVEw/20djYGD/5yU+itbU1zjrrrLjpppuiUqnUeqxSe7f70bhx42LcuHGxadOmQzhR+d1xxx1x4YUXxiOPPBItLS3R1NQUlUol2tvbo62tLVasWBG/+MUvaj1m6TjX8jjX0jnX0jnX8jjX8jjXqCeeLl4i7e3tsX379hg6dGitR+m0Xnrppbj00kvj6aefjueee87Tjw7giiuuiLvvvjv69u1b61E6lVdffTXuvffeePLJJ6O9vT0iIgYOHBhnnnlmTJkyJY477rjaDlhCzrX3z7n23jjX8jjX0jnX3j/nGl2dJZsuZ8+ePbF58+ZobGz0E1KgS3CuAV2Nc42uzNPFS2rFihXR3t4elUolmpqa/LT0PfjDZkceeWStR+oU3Nc4VNzX0jnX8rivcai4r6VzrlEXavZqcPZrxowZ1SFDhlQbGhqqlUqlWqlUqg0NDdUhQ4ZU77zzzlqPV0qa5dGtWIsWLfJGNwfgvpZOszy6Fcu5dmDua+k0o554JLtEbr755vj7v//7+OY3vxnnnntuNDU1RbVajbVr18ajjz4a06ZNiy1btsS3v/3tWo9aGprl0e3gqHr1zT7c19Jplke3g8O5ti/3tXSaUW+8JrtEmpub45577omLLrpov9cfeuihuPbaa+O11147tIOVmGZ5dEv3uc997l2vb9y4MebOnev3ov4B97V0muXRLZ1zLY/7WjrNqDceyS6RN954I4YPH37A6yeccEKsX7/+EE5Ufprl0S3df/7nf8aECROiqalpv9f9I3T/3NfSaZZHt3TOtTzua+k0o954JLtExo0bF0OGDIn7778/unfv+POPXbt2xWWXXRavvfZazJ07tzYDlpBmeXRL95GPfCS++tWvxuTJk/d7fdGiRTFy5Ej/KP0D7mvpNMujWzrnWh73tXSaUW8s2SXy7LPPRktLS2zfvj3Gjh0bTU1NUalUor29PebNmxc9e/aMtra2+PCHP1zrUUtDszy6pbviiiuid+/e8YMf/GC/11944YW44IIL4pVXXjnEk5Wb+1o6zfLols65lsd9LZ1m1BtLdsls3rw5/uVf/iWefPLJaG9vj4iIgQMHxplnnhmXXHJJNDY21njC8tEsj25ptm/fHrt3747evXvXepROx30tnWZ5dEvjXMvnvpZOM+qJJRsAAAAK0lDrAXh3F154YaxZs6bWY3QqmuXRLZ1meXRLp1ke3dJplke3dJrRlVmyS27evHmxbdu2Wo/RqWiWR7d0muXRLZ1meXRLp1ke3dJpRldmyQYAAICCWLJLbujQodGjR49aj9GpaJZHt3Sa5dEtnWZ5dEunWR7d0mlGV+aNzwAAAKAgHsnuRLZu3Rrz5s2r9RidimZ5dEunGUB92b17d4ePf/3rX8e8efNi586dNZqo/DSjXliyO5GXX345xo8fX+sxOhXN8uiWTrP927lzZ9xwww3xwQ9+MM4444xobW3tcP3111+Pbt261Wi6ctIsj27pNMuzZs2aOOuss6Jnz54xduzYWL9+fUycODHOPPPMGDduXJx88sneNfsPaEa9sWQDcNDccsst8aMf/SimTJkSLS0tcf3118fVV1/d4XO8aqkjzfLolk6zPF//+tejWq3GQw89FIMGDYqJEyfGpk2bYtWqVbFixYpoamqKW265pdZjlopm1BuvyS6Rfv36vev13bt3x5YtW/Z5qk090yyPbuk0y3P88cfHnXfeGRMnToyIiOXLl8f5558fY8aMifvuuy/Wrl0bgwcP1u0dNMujWzrN8gwePDgefPDB+PjHPx5vvvlmHH300dHW1haf/OQnIyJizpw5ceWVV8by5ctrPGl5aEa9sWSXSJ8+feLLX/5yjBgxYr/XV6xYETfddJO/7N5Bszy6pdMsT+/evWPp0qVx3HHH7b1t9erVcfbZZ8fHPvaxuP3226O5uVm3d9Asj27pNMvTq1ev+J//+Z9obm6OiIgjjjgiFi1aFB/84AcjImLlypVx4oknxltvvVXLMUtFM+pN91oPwP855ZRTorm5OS677LL9Xl+8eHHcdNNNh3iqctMsj27pNMszcODAWL58eYd/xA8ePDhmz54d48ePP2DPeqZZHt3SaZZnwIABsWbNmr0L47XXXtvh2U7r16+PPn361Gq8UtKMeuM12SVy4YUXxoYNGw54vV+/fjFp0qRDN1AnoFke3dJplufss8+OmTNn7nP77/8h/+qrrx76oUpOszy6pdMszymnnBK/+tWv9n78ve99r8PCOH/+/PjIRz5Si9FKSzPqjaeLA3DQrFixIl588cU499xz93t9zZo18dhjj3nE7B00y6NbOs0Ojqeeeip69eoVJ598cq1H6TQ0o6uxZAMAAEBBPF28hPbs2XPA21euXHmIp+kcNMujWzrN8uiWTrM8uqXTLI9u6TSjXliyS2TTpk3xZ3/2Z9GnT59oamqKG2+8scM7ev7ud7+LYcOG1XDC8tEsj27pNMujWzrN8uiWTrM8uqXTjHrj3cVL5G//9m9j8eLF8eMf/zg2bNgQ3/3ud2PhwoXx4IMPxmGHHRYREZ7d35FmeXRLp1ke3dJplke3dJrl0S2dZtSdKqVx7LHHVufMmbP343Xr1lVHjRpVbWlpqb799tvV9vb2akNDQ+0GLCHN8uiWTrM8uqXTLI9u6TTLo1s6zag3ni5eIuvWrYuhQ4fu/bh///7R1tYWmzdvjgsuuCDeeuutGk5XTprl0S2dZnl0S6dZHt3SaZZHt3SaUW8s2SXS3NwcL7zwQofb+vbtG4899lhs27YtPvvZz9ZosvLSLI9u6TTLo1s6zfLolk6zPLql04x6Y8kukZaWlmhtbd3n9iOOOCIeffTROPzww2swVblplke3dJrl0S2dZnl0S6dZHt3SaUa98XuyS2T9+vWxevXq+PCHP7zf61u2bImFCxfG2LFjD/Fk5aVZHt3SaZZHt3Sa5dEtnWZ5dEunGfXGkg0AAAAF8Su8Smbr1q0xc+bMWLBgQbS3t0elUommpqYYM2ZMfOELX4g+ffrUesTS0SyPbuk0y6NbOs3y6JZOszy6pdOMeuKR7BJZunRpTJgwId56660YO3ZsNDU1RbVajbVr18bjjz8effr0icceeyw+9KEP1XrU0tAsj27pNMujWzrN8uiWTrM8uqXTjHpjyS6R8ePHx8CBA+OBBx6Iww47rMO1HTt2xOWXXx5r1qyJOXPm1GjC8tEsj27pNMujWzrN8uiWTrM8uqXTjHpjyS6R3r17x9NPP33An+I999xzccYZZ/hdgu+gWR7d0mmWR7d0muXRLZ1meXRLpxn1xq/wKpGjjjoqXnrppQNef/nll+Ooo446hBOVn2Z5dEunWR7d0mmWR7d0muXRLZ1m1BtvfFYiV111VVx22WXx7W9/OyZMmBBNTU1RqVSivb092traYvr06XHdddfVesxS0SyPbuk0y6NbOs3y6JZOszy6pdOMulOlVL73ve9VBw0aVK1UKtWGhoZqQ0NDtVKpVAcNGlS97bbbaj1eKWmWR7d0muXRLZ1meXRLp1ke3dJpRj3xmuySeuWVV6K9vT0iIgYOHBjDhg2r8UTlp1ke3dJplke3dJrl0S2dZnl0S6cZ9cCSDQAAAAXxxmcls23btpg/f34sXbp0n2tvv/12/OhHP6rBVOWmWR7d0mmWR7d0muXRLZ1meXRLpxl1pbbPVuedli1bVh06dOje16qMHTu2unr16r3X29vbqw0NDTWcsHw0y6NbOs3y6JZOszy6pdMsj27pNKPeeCS7RL7+9a/HiBEjYu3atbFs2bJobGyMMWPGxMqVK2s9Wmlplke3dJrl0S2dZnl0S6dZHt3SaUbdqfWWz/8ZMGBAdcmSJR1uu+aaa6rHHntsdfny5X7Ktx+a5dEtnWZ5dEunWR7d0mmWR7d0mlFv/J7sEtm2bVt0797xP8kPfvCDaGhoiLFjx8bMmTNrNFl5aZZHt3Sa5dEtnWZ5dEunWR7d0mlGvbFkl8iJJ54YTz/9dJx00kkdbr/nnnuiWq3Gpz/96RpNVl6a5dEtnWZ5dEunWR7d0mmWR7d0mlFvvCa7RD772c/GT37yk/1e+/73vx9f+MIXouo3rnWgWR7d0mmWR7d0muXRLZ1meXRLpxn1xu/JBgAAgIJ4JBsAAAAKYskGAACAgliyAQAAoCCWbAAAACiIJRuALuXyyy+PSqUSlUolevToEU1NTTFhwoS47777Ys+ePe/569x///3xgQ984OANCgB0SZZsALqc8847L9asWROvvvpqzJo1K8aPHx9f/epXY+LEibFr165ajwcAdGGWbAC6nJ49e8bAgQPjmGOOidNOOy2++c1vxsMPPxyzZs2K+++/PyIiZsyYESNGjIg+ffpEc3NzXHPNNbFly5aIiJg7d25cccUVsXHjxr2Pik+bNi0iInbs2BE33HBDHHPMMdGnT58YNWpUzJ07tzbfKABQOpZsAOrC2WefHR/96EfjwQcfjIiIhoaGuPvuu+O5556LBx54IGbPnh033HBDRESMHj067rrrrmhsbIw1a9bEmjVr4mtf+1pERFxxxRXxxBNPxE9/+tNYsmRJ/Omf/mmcd9558dJLL9XsewMAyqNSrVartR4CAIpy+eWXx4YNG+LnP//5PtcuvvjiWLJkSSxdunSfa//+7/8eX/7yl2PdunUR8b+vyb7uuutiw4YNez9n+fLlcfzxx8dvf/vbGDx48N7bzznnnDjjjDNi+vTphX8/AEDn0r3WAwDAoVKtVqNSqURExJw5c2L69OmxdOnS2LRpU+zatSvefvvt2Lp1a/Tp02e/f/6ZZ56JarUaJ5xwQofbt2/fHv379z/o8wMA5WfJBqBuvPDCCzFs2LBYsWJFXHDBBTFlypS4+eabo1+/fjF//vyYPHly7Ny584B/fs+ePdGtW7dYuHBhdOvWrcO1I4444mCPDwB0ApZsAOrC7Nmz49lnn43rr78+nn766di1a1fccccd0dDwv29P8m//9m8dPv+www6L3bt3d7jt1FNPjd27d8fatWvjE5/4xCGbHQDoPCzZAHQ527dvj/b29ti9e3e8/vrr8cgjj8Stt94aEydOjEmTJsWzzz4bu3btinvuuSc+9alPxRNPPBH/8A//0OFrHHfccbFly5b4r//6r/joRz8avXv3jhNOOCEuvfTSmDRpUtxxxx1x6qmnxrp162L27NkxYsSIuOCCC2r0HQMAZeHdxQHoch555JEYNGhQHHfccXHeeefFnDlz4u67746HH344unXrFqecckrMmDEjbrvttjj55JPjX//1X+PWW2/t8DVGjx4dU6ZMic9//vPxR3/0R3H77bdHRERra2tMmjQp/vqv/zqGDx8en/70p+PXv/51NDc31+JbBQBKxruLAwAAQEE8kg0AAAAFsWQDAABAQSzZAAAAUBBLNgAAABTEkg0AAAAFsWQDAABAQSzZAAAAUBBLNgAAABTEkg0AAAAFsWQDAABAQSzZAAAAUBBLNgAAABTk/wH8zOkYVI72iwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "backtesting.plot_portfolio_over_time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "2827f5a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "backtesting.plot_returns()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1a2bc1d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AESB3.SA</th>\n",
       "      <th>BBAS3.SA</th>\n",
       "      <th>BBDC4.SA</th>\n",
       "      <th>CSMG3.SA</th>\n",
       "      <th>EGIE3.SA</th>\n",
       "      <th>ITUB4.SA</th>\n",
       "      <th>SANB4.SA</th>\n",
       "      <th>SAPR11.SA</th>\n",
       "      <th>SBSP3.SA</th>\n",
       "      <th>TRPL4.SA</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-12-28</th>\n",
       "      <td>NaN</td>\n",
       "      <td>32.429802</td>\n",
       "      <td>20.035810</td>\n",
       "      <td>13.839205</td>\n",
       "      <td>37.145214</td>\n",
       "      <td>29.081938</td>\n",
       "      <td>19.921694</td>\n",
       "      <td>22.917423</td>\n",
       "      <td>43.135887</td>\n",
       "      <td>23.158205</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-12-29</th>\n",
       "      <td>NaN</td>\n",
       "      <td>32.240250</td>\n",
       "      <td>20.003309</td>\n",
       "      <td>13.864413</td>\n",
       "      <td>36.855274</td>\n",
       "      <td>29.018667</td>\n",
       "      <td>19.830463</td>\n",
       "      <td>22.680319</td>\n",
       "      <td>42.220512</td>\n",
       "      <td>23.472605</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-12-30</th>\n",
       "      <td>NaN</td>\n",
       "      <td>31.976528</td>\n",
       "      <td>19.719933</td>\n",
       "      <td>13.780385</td>\n",
       "      <td>36.399654</td>\n",
       "      <td>28.593777</td>\n",
       "      <td>19.482126</td>\n",
       "      <td>21.396681</td>\n",
       "      <td>41.937405</td>\n",
       "      <td>23.009275</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-04</th>\n",
       "      <td>NaN</td>\n",
       "      <td>30.979326</td>\n",
       "      <td>19.204046</td>\n",
       "      <td>13.721567</td>\n",
       "      <td>36.101437</td>\n",
       "      <td>27.947104</td>\n",
       "      <td>19.407478</td>\n",
       "      <td>21.078608</td>\n",
       "      <td>40.163280</td>\n",
       "      <td>22.951361</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-05</th>\n",
       "      <td>NaN</td>\n",
       "      <td>30.657909</td>\n",
       "      <td>19.086956</td>\n",
       "      <td>13.511500</td>\n",
       "      <td>35.778358</td>\n",
       "      <td>27.766220</td>\n",
       "      <td>18.918144</td>\n",
       "      <td>20.245461</td>\n",
       "      <td>40.068909</td>\n",
       "      <td>22.802433</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-06</th>\n",
       "      <td>NaN</td>\n",
       "      <td>31.358429</td>\n",
       "      <td>19.719553</td>\n",
       "      <td>13.494695</td>\n",
       "      <td>35.488426</td>\n",
       "      <td>28.580214</td>\n",
       "      <td>19.598232</td>\n",
       "      <td>19.995518</td>\n",
       "      <td>39.870731</td>\n",
       "      <td>22.661779</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            AESB3.SA   BBAS3.SA   BBDC4.SA   CSMG3.SA   EGIE3.SA   ITUB4.SA  \\\n",
       "Date                                                                          \n",
       "2020-12-28       NaN  32.429802  20.035810  13.839205  37.145214  29.081938   \n",
       "2020-12-29       NaN  32.240250  20.003309  13.864413  36.855274  29.018667   \n",
       "2020-12-30       NaN  31.976528  19.719933  13.780385  36.399654  28.593777   \n",
       "2021-01-04       NaN  30.979326  19.204046  13.721567  36.101437  27.947104   \n",
       "2021-01-05       NaN  30.657909  19.086956  13.511500  35.778358  27.766220   \n",
       "2021-01-06       NaN  31.358429  19.719553  13.494695  35.488426  28.580214   \n",
       "\n",
       "             SANB4.SA  SAPR11.SA   SBSP3.SA   TRPL4.SA  \n",
       "Date                                                    \n",
       "2020-12-28  19.921694  22.917423  43.135887  23.158205  \n",
       "2020-12-29  19.830463  22.680319  42.220512  23.472605  \n",
       "2020-12-30  19.482126  21.396681  41.937405  23.009275  \n",
       "2021-01-04  19.407478  21.078608  40.163280  22.951361  \n",
       "2021-01-05  18.918144  20.245461  40.068909  22.802433  \n",
       "2021-01-06  19.598232  19.995518  39.870731  22.661779  "
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backtesting.data.loc[backtesting.rebalancing_dates[0] - timedelta(days=5): backtesting.rebalancing_dates[0] + timedelta(days=5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3e6e7a2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9aa428e0",
   "metadata": {},
   "source": [
    "## Pendências\n",
    "1. Na célula anterior fica claro que não há informações sobre a AESB3.SA em janeiro de 2021. Mesmo assim, no gráfico do portfolio ao longo do tempo, a AESB3.SA possui uma posição não nula. Por quê?\n",
    "1. Implementar função que calcula retornos\n",
    "1. Implementar função que plota retornos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adae67f2",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "f94e825b4e950e5d23a935d1c448fa7f8e2bcbc525a9c10d8f025cd3371271c9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}