{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def count_words(text):\n",
    "    \"\"\"\n",
    "    Count the number of words in the provided text.\n",
    "    \n",
    "    :param text: A string containing the text to be analyzed.\n",
    "    :return: The number of words in the text.\n",
    "    \"\"\"\n",
    "    words = re.findall(r'\\b\\w+\\b', text)\n",
    "    return len(words)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading ./books/geb.txt\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import re\n",
    "from typing import Dict, Any\n",
    "pd.set_option('display.max_colwidth', 1000)\n",
    "pd.set_option('display.max_rows', None)\n",
    "\n",
    "def classify_paragraph(text : str, lines_count : int, **kwargs : Dict[str, Any]):\n",
    "    \"\"\"\n",
    "    Classify a paragraph based on its content.\n",
    "\n",
    "    :param text: Text of the paragraph.\n",
    "    :param lines_count: Number of lines in the paragraph.\n",
    "    :return: The category of the paragraph.\n",
    "    \"\"\"\n",
    "    chapter_match = re.search(r'(CHAPTER [IVXLCDMN]+): [^:]+', text, re.IGNORECASE)\n",
    "    dialogue_match = re.search(r'(DIALOGUE [IVXLCDMN]+): [^:]+', text, re.IGNORECASE)\n",
    "    \n",
    "    if chapter_match:\n",
    "        return 'chapter-header', chapter_match.group(1)\n",
    "    elif dialogue_match:\n",
    "        return 'dialogue-header', dialogue_match.group(1)\n",
    "    elif text.startswith('*'):\n",
    "        return 'formula', 'formula'\n",
    "    elif text.startswith('Introduction:') or (lines_count == 1 and not text[-1] in ['.', '!', '?', ';', ')', ':', '}', ',', '-', '\"'] \\\n",
    "        and text[0] == text[0].upper() and text[0].isalpha() and not text.isupper() \\\n",
    "            and not '(' in text):\n",
    "        return 'header', 'header'\n",
    "    elif re.match(r'^[^: ]+:\\s+.+', text):\n",
    "        return 'dialogue', 'dialogue'\n",
    "    else:\n",
    "        return 'text', 'text'\n",
    "\n",
    "def build_paragraphs(text_file_path : str):\n",
    "    \"\"\"\n",
    "    Read a text file and split it into chunks.\n",
    "\n",
    "    :param text_file_path: Path to the text file.\n",
    "    :param chunk_size: Number of lines in each chunk.\n",
    "    :return: List of text chunks.\n",
    "    \"\"\"\n",
    "    current = []\n",
    "    lineno = -1\n",
    "    idx = 0\n",
    "    with open(text_file_path, 'r') as file:\n",
    "        print(f\"Reading {text_file_path}\")\n",
    "        for line in file:\n",
    "            lineno += 1\n",
    "            if line.strip() == '':\n",
    "                if len(current) > 0:\n",
    "                    text = ' '.join(current)\n",
    "                    yield idx, lineno, text, len(text), len(current)\n",
    "                    idx += 1\n",
    "                    current = []\n",
    "            else:\n",
    "                current.append(line.strip())\n",
    "\n",
    "    if len(current) > 0:\n",
    "        text = ' '.join(current)\n",
    "        yield idx, lineno, text, len(text), len(current)\n",
    "\n",
    "def chunks_to_parquet(chunks, output_dir):\n",
    "    \"\"\"\n",
    "    Convert chunks of text to Parquet files.\n",
    "\n",
    "    :param chunks: List of text chunks.\n",
    "    :param output_dir: Directory to save Parquet files.\n",
    "    \"\"\"\n",
    "    if not os.path.exists(output_dir):\n",
    "        os.makedirs(output_dir)\n",
    "\n",
    "    for i, chunk in enumerate(chunks, start=1):\n",
    "        df = pd.DataFrame(chunk, columns=['text'])\n",
    "        parquet_path = os.path.join(output_dir, f'chunk_{i}.parquet')\n",
    "        df.to_parquet(parquet_path, index=False)\n",
    "        \n",
    "def assign_cluster_ids(df):\n",
    "    \"\"\"\n",
    "    Assign cluster IDs to each paragraph based on its type and compute cluster sizes.\n",
    "\n",
    "    :param df: DataFrame with paragraph data and categories.\n",
    "    :return: DataFrame with 'cluster' and 'cluster_size' columns.\n",
    "    \"\"\"\n",
    "    current_clusters = {category: 0 for category in df['category'].unique()}\n",
    "    last_category = None\n",
    "\n",
    "    cluster_ids = []\n",
    "\n",
    "    for _, row in df.iterrows():\n",
    "        category = row['category']\n",
    "\n",
    "        if category != last_category:\n",
    "            current_clusters[category] += 1\n",
    "            last_category = category\n",
    "\n",
    "        cluster_id = f\"{category}_{current_clusters[category]}\"\n",
    "        cluster_ids.append(cluster_id)\n",
    "\n",
    "    df['cluster'] = cluster_ids\n",
    "\n",
    "    # Compute cluster sizes\n",
    "    cluster_sizes = df['cluster'].value_counts()\n",
    "    df['cluster_size'] = df['cluster'].map(cluster_sizes)\n",
    "\n",
    "    return df\n",
    "\n",
    "def fuzz_cluster_edges(df):\n",
    "    \"\"\"\n",
    "    Adjust the clustering by comparing adjacent rows. If the next or previous categories match,\n",
    "    set the fuzz_cluster to the current cluster.\n",
    "\n",
    "    :param df: DataFrame with paragraph data, categories, and initial clusters.\n",
    "    :return: DataFrame with adjusted cluster columns.\n",
    "    \"\"\"\n",
    "\n",
    "    # Initialize fuzz_cluster with current cluster values\n",
    "    df['fuzz_cluster'] = None\n",
    "\n",
    "    # Update fuzz_cluster based on adjacent categories\n",
    "    for idx in df.index:\n",
    "        if idx == 0:\n",
    "            df.at[idx, 'fuzz_cluster'] = df.at[idx, 'cluster']\n",
    "            df.at[idx, 'chapter'] = df.at[idx, 'category_id']\n",
    "        if idx > 0:\n",
    "            if df.at[idx, 'category'] == 'header' or df.at[idx, 'category'] == 'dialogue-header' or df.at[idx, 'category'] == 'chapter-header':\n",
    "                # One excecption, if we are a header and the previous is a header or chapter-header, we are in the same cluster\n",
    "                if df.at[idx - 1, 'category'] == 'header' or df.at[idx - 1, 'category'] == 'chapter-header':\n",
    "                    df.at[idx, 'fuzz_cluster'] = df.at[idx - 1, 'fuzz_cluster']\n",
    "                else:\n",
    "                    df.at[idx, 'fuzz_cluster'] = df.at[idx, 'cluster']\n",
    "            else:\n",
    "                df.at[idx, 'fuzz_cluster'] = df.at[idx - 1, 'fuzz_cluster']\n",
    "            if df.at[idx, 'category'] == 'chapter-header' or df.at[idx, 'category'] == 'dialogue-header':\n",
    "                df.at[idx, 'chapter'] = df.at[idx, 'category_id']\n",
    "            else:\n",
    "                df.at[idx, 'chapter'] = df.at[idx - 1, 'chapter']\n",
    "\n",
    "    # Compute fuzzed cluster sizes\n",
    "    fuzz_cluster_sizes = df['fuzz_cluster'].value_counts()\n",
    "    df['fuzz_cluster_size'] = df['fuzz_cluster'].map(fuzz_cluster_sizes)\n",
    "\n",
    "    return df\n",
    "\n",
    "def extend_dialogue_clusters_full(df):\n",
    "    \"\"\"\n",
    "    Extend dialogue clusters to include the preceding and following headers and any text in between.\n",
    "\n",
    "    :param df: DataFrame with paragraph data, categories, fuzz clusters, and sizes.\n",
    "    :return: DataFrame with fully extended dialogue clusters.\n",
    "    \"\"\"\n",
    "    # Iterate over the DataFrame to find dialogue clusters and extend them\n",
    "    for idx, row in df.iterrows():\n",
    "        if row['category'] == 'dialogue':\n",
    "            current_cluster = row['fuzz_cluster']\n",
    "\n",
    "            # Extend backwards to the previous header\n",
    "            for prev_idx in range(idx - 1, -1, -1):\n",
    "                prev_row = df.iloc[prev_idx]\n",
    "                df.at[prev_idx, 'fuzz_cluster'] = current_cluster\n",
    "                if prev_row['category'] == 'header':\n",
    "                    break\n",
    "\n",
    "            # Extend forwards to the next header\n",
    "            for next_idx in range(idx + 1, len(df)):\n",
    "                next_row = df.iloc[next_idx]\n",
    "                if next_row['category'] == 'header':\n",
    "                    break\n",
    "                df.at[next_idx, 'fuzz_cluster'] = current_cluster\n",
    "\n",
    "    # Recompute fuzzed cluster sizes\n",
    "    fuzz_cluster_sizes = df['fuzz_cluster'].value_counts()\n",
    "    df['fuzz_cluster_size'] = df['fuzz_cluster'].map(fuzz_cluster_sizes)\n",
    "\n",
    "    return df\n",
    "\n",
    "def extend_text_clusters(df):\n",
    "    \"\"\"\n",
    "    Extend text clusters upwards until encountering another text or dialogue cluster.\n",
    "\n",
    "    :param df: DataFrame with paragraph data, categories, fuzz clusters, and sizes.\n",
    "    :return: DataFrame with extended text clusters.\n",
    "    \"\"\"\n",
    "    for idx, row in df.iterrows():\n",
    "        if row['category'] == 'text':\n",
    "            current_cluster = row['fuzz_cluster']\n",
    "\n",
    "            # Extend backwards until another text or dialogue cluster is found\n",
    "            for prev_idx in range(idx - 1, -1, -1):\n",
    "                prev_row = df.iloc[prev_idx]\n",
    "                if prev_row['category'] in ['text', 'dialogue']:\n",
    "                    break\n",
    "                df.at[prev_idx, 'fuzz_cluster'] = current_cluster\n",
    "\n",
    "    # Recompute fuzzed cluster sizes\n",
    "    fuzz_cluster_sizes = df['fuzz_cluster'].value_counts()\n",
    "    df['fuzz_cluster_size'] = df['fuzz_cluster'].map(fuzz_cluster_sizes)\n",
    "\n",
    "    return df\n",
    "\n",
    "# A dataset that had the header and footer hand cleaned\n",
    "text_file_path = '../geb.txt'\n",
    "output_dir = './geb.parquet'\n",
    "chunk_size = 1000  # Number of lines per chunk\n",
    "\n",
    "paragraphs = list(build_paragraphs(text_file_path))\n",
    "#chunks_to_parquet(chunks, output_dir)\n",
    "\n",
    "df = pd.DataFrame(paragraphs, columns=['idx', 'lineno', 'text', 'text_length', 'lines_count'])\n",
    "intro = df[:100]\n",
    "df = df[100:].reset_index(drop=True)\n",
    "df[['category', 'category_id']] = df.apply(lambda row: classify_paragraph(**row), axis=1, result_type='expand')\n",
    "df = assign_cluster_ids(df)\n",
    "df = fuzz_cluster_edges(df)\n",
    "df['word_count'] = df['text'].apply(count_words)\n",
    "df['cumsum_word_count'] = df['word_count'].cumsum()\n",
    "# Apply the function to extend dialogue clusters\n",
    "#df = extend_dialogue_clusters_full(df)\n",
    "#df = extend_text_clusters(df)\n",
    "\n",
    "#df.set_index('idx', inplace=True)\n",
    "#headers = df[df['category'] == 'header']\n",
    "# Read the idx + 1 for each header\n",
    "#nextix = df.loc[(headers.index + 1)[:-2]]\n",
    "#previx = df.loc[(headers.index - 1)[1:]]\n",
    "\n",
    "df.to_parquet('books/geb.parquet', index=False)\n",
    "#df[500:550].agg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We are going to draw from this dataset to create a new dataset\n",
    "import random\n",
    "import pandas as pd \n",
    "from typing import Literal\n",
    "\n",
    "def select_rows_until_max_word_count(df, start_bin, max_word_count):\n",
    "    \"\"\"\n",
    "    Selects rows starting from the specified bin until the cumulative word count \n",
    "    reaches or exceeds the maximum word count.\n",
    "\n",
    "    Parameters:\n",
    "        df (pd.DataFrame): The DataFrame containing the data.\n",
    "        start_bin (int): The index of the starting bin (row).\n",
    "        max_word_count (int): The maximum cumulative word count.\n",
    "\n",
    "    Returns:\n",
    "        int: The index of the last row included in the selection.\n",
    "    \"\"\"\n",
    "\n",
    "    current_sum = 0\n",
    "    for index, row in df.loc[start_bin:].iterrows():\n",
    "        current_sum += row['word_count']\n",
    "        if current_sum >= max_word_count:\n",
    "            return index\n",
    "\n",
    "    # If the end of the DataFrame is reached without exceeding max_word_count\n",
    "    return df.index[-1]['idx']\n",
    "\n",
    "def build_strides(outclass : Literal['chapter', 'dialogue'] = 'chapter', context : int = 8192):\n",
    "    df = pd.read_parquet('geb.parquet')\n",
    "    df['is_chapter'] = df['chapter'].str.startswith('CHAPTER')\n",
    "    df = df[df['is_chapter'] == (outclass == 'chapter')]\n",
    "    # err on the large size, the number of tokens in a word averages to 4:3.  we should use the tokenizer in geb.parquet to get the token counts instead.\n",
    "    word_count = context * 3 / 4\n",
    "    df['cumsum_word_count'] = df['word_count'].cumsum()\n",
    "    # Calculate total word count (last value in cumsum)\n",
    "    last_row = df.iloc[-1]\n",
    "    total_word_count = df['cumsum_word_count'].iloc[-1]\n",
    "    # Now go backwards and find the index of the bin that contains the 8192nd word\n",
    "    selected_bin = df[df['cumsum_word_count'] < total_word_count - word_count - 200].iloc[-1]\n",
    "    total_word_count = selected_bin[\"cumsum_word_count\"]\n",
    "    print(selected_bin, total_word_count, last_row)\n",
    "    samples = []\n",
    "\n",
    "    for i in range(5000):\n",
    "        rand_num = random.uniform(0, total_word_count)\n",
    "        rand_end = rand_num + word_count\n",
    "        if rand_end > total_word_count:\n",
    "            rand_end = total_word_count\n",
    "        selected_bin = df[df['cumsum_word_count'] >= rand_num].iloc[0]['idx'] - 100\n",
    "        end_bin = df[df['cumsum_word_count'] >= rand_end].iloc[0]['idx'] - 100\n",
    "        #print(f\"Random number: {rand_num} {rand_end} {selected_bin} {end_bin}\")\n",
    "        text = []\n",
    "        for i in range(selected_bin, end_bin - 1):\n",
    "            if i not in df.index:\n",
    "                break\n",
    "            text.append(df['text'][i])\n",
    "\n",
    "        samples.append({\n",
    "            \"text\": \"<s>\" + \"</s><s>\".join(text) + \"</s>\",\n",
    "        })\n",
    "\n",
    "    del df['is_chapter']\n",
    "\n",
    "    pd.DataFrame(samples).reset_index().to_parquet(f'./geb-strides-{outclass}-{context}.parquet', index=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "build_strides('chapter', 8192)\n",
    "build_strides('dialogue', 8192)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>chapter</th>\n",
       "      <th>fuzz_cluster</th>\n",
       "      <th>idx</th>\n",
       "      <th>lineno</th>\n",
       "      <th>word_count</th>\n",
       "      <th>text_length</th>\n",
       "      <th>lines_count</th>\n",
       "      <th>category</th>\n",
       "      <th>category_id</th>\n",
       "      <th>cluster_size</th>\n",
       "      <th>fuzz_cluster_size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CHAPTER N</td>\n",
       "      <td>chapter-header_1</td>\n",
       "      <td>100</td>\n",
       "      <td>381</td>\n",
       "      <td>7</td>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "      <td>chapter-header</td>\n",
       "      <td>CHAPTER N</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CHAPTER N</td>\n",
       "      <td>chapter-header_1</td>\n",
       "      <td>101</td>\n",
       "      <td>389</td>\n",
       "      <td>90</td>\n",
       "      <td>552</td>\n",
       "      <td>7</td>\n",
       "      <td>text</td>\n",
       "      <td>text</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>CHAPTER N</td>\n",
       "      <td>chapter-header_1</td>\n",
       "      <td>102</td>\n",
       "      <td>402</td>\n",
       "      <td>167</td>\n",
       "      <td>981</td>\n",
       "      <td>12</td>\n",
       "      <td>text</td>\n",
       "      <td>text</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>CHAPTER N</td>\n",
       "      <td>header_1</td>\n",
       "      <td>103</td>\n",
       "      <td>404</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>header</td>\n",
       "      <td>header</td>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CHAPTER N</td>\n",
       "      <td>header_1</td>\n",
       "      <td>104</td>\n",
       "      <td>412</td>\n",
       "      <td>101</td>\n",
       "      <td>593</td>\n",
       "      <td>7</td>\n",
       "      <td>text</td>\n",
       "      <td>text</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     chapter      fuzz_cluster  idx  lineno  word_count  text_length  \\\n",
       "0  CHAPTER N  chapter-header_1  100     381           7           50   \n",
       "1  CHAPTER N  chapter-header_1  101     389          90          552   \n",
       "2  CHAPTER N  chapter-header_1  102     402         167          981   \n",
       "3  CHAPTER N          header_1  103     404           1            4   \n",
       "4  CHAPTER N          header_1  104     412         101          593   \n",
       "\n",
       "   lines_count        category category_id  cluster_size  fuzz_cluster_size  \n",
       "0            1  chapter-header   CHAPTER N             1                  3  \n",
       "1            7            text        text             2                  3  \n",
       "2           12            text        text             2                  3  \n",
       "3            1          header      header             1                  6  \n",
       "4            7            text        text             5                  6  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def aggregate_by_fuzz_cluster(df):\n",
    "    \"\"\"\n",
    "    Aggregate the DataFrame by fuzz_cluster with custom aggregation for each column.\n",
    "\n",
    "    :param df: DataFrame with various columns.\n",
    "    :return: DataFrame with aggregated data for each fuzz_cluster.\n",
    "    \"\"\"\n",
    "    aggregations = {\n",
    "        'chapter': 'first',\n",
    "        'idx': 'min', \n",
    "        'lineno': 'min', \n",
    "        'word_count': 'sum', \n",
    "        'text_length': 'sum', \n",
    "        'text': lambda x: '\\n\\n'.join(x), \n",
    "        'lines_count': 'sum', \n",
    "        'category': lambda x: ', '.join(sorted(set(x))),\n",
    "        'category_id': 'first',\n",
    "        'cluster': lambda x: ', '.join(sorted(set(x))),\n",
    "        'cluster_size': 'sum', \n",
    "        'fuzz_cluster_size': 'sum'\n",
    "    }\n",
    "\n",
    "    aggregated_df = df.groupby('fuzz_cluster').agg(aggregations)\n",
    "\n",
    "    return aggregated_df\n",
    "\n",
    "aggregated_df = aggregate_by_fuzz_cluster(df)\n",
    "aggregated_df = aggregated_df.reset_index().set_index(['chapter', 'fuzz_cluster'])\n",
    "ndf = aggregated_df.sort_values('idx').reset_index()\n",
    "df[['chapter', 'fuzz_cluster', 'idx', 'lineno', 'word_count', 'text_length','lines_count', 'category', 'category_id', 'cluster_size', 'fuzz_cluster_size']].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+0AAAKgCAYAAADu9pwVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gVVf7H8c+96T2kJyQBQo/0HkCaSEdRUFQUkCYINlwE1IWArtjrorgWYF1ZewMVBIKoC6IiCCIWmqCQUIQEggSSnN8f/Ga8N4UmkEHer+eZJ7l35s6cmTlzZr5zzpxxGWOMAAAAAACA47grOgEAAAAAAKBsBO0AAAAAADgUQTsAAAAAAA5F0A4AAAAAgEMRtAMAAAAA4FAE7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUATtAAA4WNWqVTV48OCKTkaFGDx4sKpWrVrRyQAAoEIRtAMAUAE2btyoG264QWlpaQoMDFR4eLjatGmjJ554Qr///vtZScPBgweVmZmpjz/++Kwsz7Jr1y7dcsstqlOnjoKCghQXF6cWLVpo/PjxOnDgwFlNCwAATudb0QkAAOB88/777+uKK65QQECABg4cqHr16unw4cP67LPPNG7cOK1bt07/+te/zng6Dh48qClTpkiSOnTocMaXJ0m//fabmjVrpry8PA0ZMkR16tTRnj17tGbNGj3zzDMaNWqUQkNDJUnPPfeciouLz0q6AABwKoJ2AADOos2bN+uqq65SlSpVlJWVpcTERHvc6NGjtWHDBr3//vsVmMI/Lz8/XyEhIWWOe+GFF7R161b973//U+vWrb3G5eXlyd/f3/7s5+d3RtMJAMC5gObxAACcRQ8++KAOHDigF154wStgt9SoUUO33HJLub/PzMyUy+Uq9f2sWbPkcrm0ZcsW+7uvvvpKXbt2VUxMjIKCglStWjUNGTJEkrRlyxbFxsZKkqZMmSKXyyWXy6XMzEz7999//7369eunqKgoBQYGqlmzZnrvvffKXO7SpUt14403Ki4uTsnJyeWmf+PGjfLx8VGrVq1KjQsPD1dgYKD9ueQz7R06dLDTWXKYNWuWPd2+fft06623KiUlRQEBAapRo4YeeOCBUrX2r7zyipo2baqwsDCFh4erfv36euKJJ8pNOwAAFYGadgAAzqK5c+cqLS2tVC3z6bZz50516dJFsbGxmjBhgiIjI7Vlyxa99dZbkqTY2Fi7Ofpll12myy+/XJLUoEEDSdK6devUpk0bVa5cWRMmTFBISIhee+019enTR2+++aYuu+wyr+XdeOONio2N1aRJk5Sfn19uuqpUqaKioiK99NJLGjRo0Emt01133aVhw4Z5ffef//xHCxYsUFxcnKSjTf7bt2+vX3/9VTfccINSU1O1bNkyTZw4UTt27NDjjz8uSVq4cKGuvvpqXXTRRXrggQckSevXr9f//ve/Y940AQDgbCNoBwDgLMnLy9Ovv/6qSy+99Iwva9myZdq7d68++ugjNWvWzP7+3nvvlSSFhISoX79+GjVqlBo0aKBrr73W6/e33HKLUlNT9eWXXyogIEDS0cC8bdu2Gj9+fKmgPSoqSosXL5aPj88x0zVkyBA99thjGjx4sO6//3516NBB7dq1U48ePRQREXHM31588cWl1jErK0tDhgxRjx49JEmPPvqoNm7cqFWrVqlmzZqSpBtuuEFJSUl66KGHdPvttyslJUXvv/++wsPDtWDBguOmGQCAikTzeAAAzpK8vDxJUlhY2BlfVmRkpCRp3rx5OnLkyEn99rffflNWVpauvPJK7d+/X7t379bu3bu1Z88ede3aVT/99JN+/fVXr98MHz78hILf+Ph4ffPNNxo5cqT27t2rGTNm6JprrlFcXJzuueceGWNOKI3Z2dnq16+fGjVqpKefftr+/vXXX9eFF16oSpUq2enevXu3OnfurKKiIn3yySeSjm6f/Px8LVy48CS2DAAAZx9BOwAAZ0l4eLgkaf/+/Wd8We3bt1ffvn01ZcoUxcTE6NJLL9XMmTNVUFBw3N9u2LBBxhj9/e9/V2xsrNcwefJkSUeb33uqVq3aCactMTFRzzzzjHbs2KEffvhBTz75pN20/oUXXjju7wsLC3XllVeqqKhIb731lt0SQJJ++uknzZ8/v1S6O3fu7JXuG2+8UbVq1VL37t2VnJysIUOGaP78+Se8DgAAnC00jwcA4CwJDw9XUlKSvv3221OeR1md0ElSUVFRqeneeOMNff7555o7d64WLFigIUOG6JFHHtHnn39uv1atLFaHbX/729/UtWvXMqepUaOG1+egoKCTWQ07jbVq1VKtWrXUs2dP1axZUy+//HKp59ZLGjdunJYvX65FixaV6vSuuLhYF198se64444yf1urVi1JUlxcnFavXq0FCxboww8/1IcffqiZM2dq4MCBmj179kmvCwAAZwpBOwAAZ1GvXr30r3/9S8uXL1dGRsZJ/75SpUqSjvaQbjWBl6Sff/65zOlbtWqlVq1a6R//+IfmzJmjAQMG6JVXXtGwYcPKvQGQlpYm6egr16wa6jMtLS1NlSpV0o4dO4453SuvvKLHH39cjz/+uNq3b19qfPXq1XXgwIETSre/v7969+6t3r17q7i4WDfeeKOeffZZ/f3vfy91UwIAgIpC83gAAM6iO+64QyEhIRo2bJhycnJKjd+4ceMxXztWvXp1SbKfzZaOvhe9ZO3w3r17Sz0f3qhRI0mym8gHBwdLOnoDwFNcXJw6dOigZ599tswgeteuXeWm73hWrFhRZu/yX3zxhfbs2aPatWuX+9tvv/1Ww4YN07XXXltuD+9XXnmlli9frgULFpQat2/fPhUWFkqS9uzZ4zXO7XbbPeefyCMEAACcLdS0AwBwFlWvXl1z5sxR//79VbduXQ0cOFD16tXT4cOHtWzZMr3++usaPHhwub/v0qWLUlNTNXToUI0bN04+Pj568cUXFRsbq61bt9rTzZ49W08//bQuu+wyVa9eXfv379dzzz2n8PBwu6f1oKAgpaen69VXX1WtWrUUFRWlevXqqV69epo+fbratm2r+vXra/jw4UpLS1NOTo6WL1+uX375Rd98880prf9LL72kl19+WZdddpmaNm0qf39/rV+/Xi+++KICAwN15513lvvb66+/XpLUrl07/ec///Ea17p1a6WlpWncuHF677331KtXLw0ePFhNmzZVfn6+1q5dqzfeeENbtmxRTEyMhg0bpt9++02dOnVScnKyfv75Zz311FNq1KiR6tate0rrBgDAGWEAAMBZ9+OPP5rhw4ebqlWrGn9/fxMWFmbatGljnnrqKXPo0CF7uipVqphBgwZ5/XblypWmZcuWxt/f36SmpppHH33UzJw500gymzdvNsYY8/XXX5urr77apKammoCAABMXF2d69eplvvrqK695LVu2zDRt2tT4+/sbSWby5Mn2uI0bN5qBAweahIQE4+fnZypXrmx69epl3njjDXsaa7lffvnlCa33mjVrzLhx40yTJk1MVFSU8fX1NYmJieaKK64wX3/9tde0gwYNMlWqVPHaFpLKHGbOnGlPt3//fjNx4kRTo0YN4+/vb2JiYkzr1q3Nww8/bA4fPmyMMeaNN94wXbp0MXFxcfZ2vOGGG8yOHTtOaD0AADhbXMac4LtVAAAAAADAWcUz7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUATtAAAAAAA4FEE7AAAAAAAO5VvRCXCC4uJibd++XWFhYXK5XBWdHAAAAADAX5wxRvv371dSUpLc7vLr0wnaJW3fvl0pKSkVnQwAAAAAwHlm27ZtSk5OLnd8hQbtzzzzjJ555hlt2bJFknTBBRdo0qRJ6t69uySpQ4cOWrp0qddvbrjhBs2YMcP+vHXrVo0aNUpLlixRaGioBg0apGnTpsnX98RXLSwsTNLRjRUeHv4n1woAAAAAgGPLy8tTSkqKHY+Wp0KD9uTkZN1///2qWbOmjDGaPXu2Lr30Uq1atUoXXHCBJGn48OGaOnWq/Zvg4GD7/6KiIvXs2VMJCQlatmyZduzYoYEDB8rPz0/33XffCafDahIfHh5O0A4AAAAAOGuO94i2yxhjzlJaTkhUVJQeeughDR06VB06dFCjRo30+OOPlznthx9+qF69emn79u2Kj4+XJM2YMUPjx4/Xrl275O/vf0LLzMvLU0REhHJzcwnaAQAAAABn3InGoY7pPb6oqEivvPKK8vPzlZGRYX//8ssvKyYmRvXq1dPEiRN18OBBe9zy5ctVv359O2CXpK5duyovL0/r1q0rd1kFBQXKy8vzGgAAAAAAcJoK74hu7dq1ysjI0KFDhxQaGqq3335b6enpkqRrrrlGVapUUVJSktasWaPx48frhx9+0FtvvSVJys7O9grYJdmfs7Ozy13mtGnTNGXKlDO0RgAAAAAAnB4VHrTXrl1bq1evVm5urt544w0NGjRIS5cuVXp6ukaMGGFPV79+fSUmJuqiiy7Sxo0bVb169VNe5sSJEzV27Fj7s9UBAAAAAAAATlLhzeP9/f1Vo0YNNW3aVNOmTVPDhg31xBNPlDlty5YtJUkbNmyQJCUkJCgnJ8drGutzQkJCucsMCAiwO52j8zkAAAAAgFNVeNBeUnFxsQoKCsoct3r1aklSYmKiJCkjI0Nr167Vzp077WkWLlyo8PBwu4k9AAAAAADnqgptHj9x4kR1795dqamp2r9/v+bMmaOPP/5YCxYs0MaNGzVnzhz16NFD0dHRWrNmjW677Ta1a9dODRo0kCR16dJF6enpuu666/Tggw8qOztbd999t0aPHq2AgICKXDUAAAAAAP60Cg3ad+7cqYEDB2rHjh2KiIhQgwYNtGDBAl188cXatm2bFi1apMcff1z5+flKSUlR3759dffdd9u/9/Hx0bx58zRq1ChlZGQoJCREgwYN8nqvOwAAAAAA5yrHvae9IvCedgAAAADA2XTOvacdAAAAAAB4I2gHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjazzFVJ7xf0UkAAAAAAJwlBO0AAAAAADgUQTsAAAAAAA5F0A4AAAAAgEMRtAMAAAAA4FAE7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUATtAAAAAAA4FEE7AAAAAAAORdAOAAAAAIBDEbQDAAAAAOBQBO0AAAAAADgUQTsAAAAAAA5F0A4AAAAAgEMRtAMAAAAA4FAE7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUATtAAAAAAA4FEE7AAAAAAAORdAOAAAAAIBDEbQDAAAAAOBQBO0AAAAAADgUQTsAAAAAAA5F0A4AAAAAgEMRtJ+rMiMqOgUAAAAAgDOMoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcKgKDdqfeeYZNWjQQOHh4QoPD1dGRoY+/PBDe/yhQ4c0evRoRUdHKzQ0VH379lVOTo7XPLZu3aqePXsqODhYcXFxGjdunAoLC8/2qgAAAAAAcNpVaNCenJys+++/XytXrtRXX32lTp066dJLL9W6deskSbfddpvmzp2r119/XUuXLtX27dt1+eWX278vKipSz549dfjwYS1btkyzZ8/WrFmzNGnSpIpaJQAAAAAAThuXMcZUdCI8RUVF6aGHHlK/fv0UGxurOXPmqF+/fpKk77//XnXr1tXy5cvVqlUrffjhh+rVq5e2b9+u+Ph4SdKMGTM0fvx47dq1S/7+/ie0zLy8PEVERCg3N1fh4eFnbN1Oh6oT3teW+3tKmRFSZm5FJwcAAAAAcApONA51zDPtRUVFeuWVV5Sfn6+MjAytXLlSR44cUefOne1p6tSpo9TUVC1fvlyStHz5ctWvX98O2CWpa9euysvLs2vrAQAAAAA4V/lWdALWrl2rjIwMHTp0SKGhoXr77beVnp6u1atXy9/fX5GRkV7Tx8fHKzs7W5KUnZ3tFbBb461x5SkoKFBBQYH9OS8v7zStDQAAAAAAp0+F17TXrl1bq1ev1ooVKzRq1CgNGjRI33333Rld5rRp0xQREWEPKSkpZ3R5AAAAAACcigoP2v39/VWjRg01bdpU06ZNU8OGDfXEE08oISFBhw8f1r59+7ymz8nJUUJCgiQpISGhVG/y1mdrmrJMnDhRubm59rBt27bTu1IAAAAAAJwGFR60l1RcXKyCggI1bdpUfn5+Wrx4sT3uhx9+0NatW5WRkSFJysjI0Nq1a7Vz5057moULFyo8PFzp6enlLiMgIMB+zZw1AAAAAADgNBX6TPvEiRPVvXt3paamav/+/ZozZ44+/vhjLViwQBERERo6dKjGjh2rqKgohYeH66abblJGRoZatWolSerSpYvS09N13XXX6cEHH1R2drbuvvtujR49WgEBARW5agAAAAAA/GkVGrTv3LlTAwcO1I4dOxQREaEGDRpowYIFuvjiiyVJjz32mNxut/r27auCggJ17dpVTz/9tP17Hx8fzZs3T6NGjVJGRoZCQkI0aNAgTZ06taJWCQAAAACA08Zx72mvCLynHQAAAABwNp1z72kHAAAAAADeCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcKgKDdqnTZum5s2bKywsTHFxcerTp49++OEHr2k6dOggl8vlNYwcOdJrmq1bt6pnz54KDg5WXFycxo0bp8LCwrO5KgAAAAAAnHa+FbnwpUuXavTo0WrevLkKCwt15513qkuXLvruu+8UEhJiTzd8+HBNnTrV/hwcHGz/X1RUpJ49eyohIUHLli3Tjh07NHDgQPn5+em+++47q+sDAAAAAMDpVKFB+/z5870+z5o1S3FxcVq5cqXatWtnfx8cHKyEhIQy5/HRRx/pu+++06JFixQfH69GjRrpnnvu0fjx45WZmSl/f/8zug4AAAAAAJwpjnqmPTc3V5IUFRXl9f3LL7+smJgY1atXTxMnTtTBgwftccuXL1f9+vUVHx9vf9e1a1fl5eVp3bp1ZyfhAAAAAACcARVa0+6puLhYt956q9q0aaN69erZ319zzTWqUqWKkpKStGbNGo0fP14//PCD3nrrLUlSdna2V8Auyf6cnZ1d5rIKCgpUUFBgf87LyzvdqwMAAAAAwJ/mmKB99OjR+vbbb/XZZ595fT9ixAj7//r16ysxMVEXXXSRNm7cqOrVq5/SsqZNm6YpU6b8qfQCAAAAAHCmOaJ5/JgxYzRv3jwtWbJEycnJx5y2ZcuWkqQNGzZIkhISEpSTk+M1jfW5vOfgJ06cqNzcXHvYtm3bn10FAAAAAABOuwoN2o0xGjNmjN5++21lZWWpWrVqx/3N6tWrJUmJiYmSpIyMDK1du1Y7d+60p1m4cKHCw8OVnp5e5jwCAgIUHh7uNQAAAAAA4DQV2jx+9OjRmjNnjt59912FhYXZz6BHREQoKChIGzdu1Jw5c9SjRw9FR0drzZo1uu2229SuXTs1aNBAktSlSxelp6fruuuu04MPPqjs7GzdfffdGj16tAICAipy9QAAAAAA+FMqtKb9mWeeUW5urjp06KDExER7ePXVVyVJ/v7+WrRokbp06aI6dero9ttvV9++fTV37lx7Hj4+Ppo3b558fHyUkZGha6+9VgMHDvR6rzsAAAAAAOeiCq1pN8Ycc3xKSoqWLl163PlUqVJFH3zwwelKFgAAAAAAjuCIjugAAAAAAEBpBO0AAAAAADgUQTsAAAAAAA5F0A4AAAAAgEMRtJ/j6s+uX9FJAAAAAACcIQTtAAAAAAA4FEH7X8D6OnW1vk7dik4GAAAAAOA0I2gHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHqtCgfdq0aWrevLnCwsIUFxenPn366IcffvCa5tChQxo9erSio6MVGhqqvn37Kicnx2uarVu3qmfPngoODlZcXJzGjRunwsLCs7kqAAAAAACcdhUatC9dulSjR4/W559/roULF+rIkSPq0qWL8vPz7Wluu+02zZ07V6+//rqWLl2q7du36/LLL7fHFxUVqWfPnjp8+LCWLVum2bNna9asWZo0aVJFrBIAAAAAAKeNb0UufP78+V6fZ82apbi4OK1cuVLt2rVTbm6uXnjhBc2ZM0edOnWSJM2cOVN169bV559/rlatWumjjz7Sd999p0WLFik+Pl6NGjXSPffco/HjxyszM1P+/v4VsWoAAAAAAPxpjnqmPTc3V5IUFRUlSVq5cqWOHDmizp0729PUqVNHqampWr58uSRp+fLlql+/vuLj4+1punbtqry8PK1bt67M5RQUFCgvL89rAAAAAADAaRwTtBcXF+vWW29VmzZtVK9ePUlSdna2/P39FRkZ6TVtfHy8srOz7Wk8A3ZrvDWuLNOmTVNERIQ9pKSknOa1AQAAAADgz3NM0D569Gh9++23euWVV874siZOnKjc3Fx72LZt2xlfJgAAAAAAJ6tCn2m3jBkzRvPmzdMnn3yi5ORk+/uEhAQdPnxY+/bt86ptz8nJUUJCgj3NF1984TU/q3d5a5qSAgICFBAQcJrXAgAAAACA06tCa9qNMRozZozefvttZWVlqVq1al7jmzZtKj8/Py1evNj+7ocfftDWrVuVkZEhScrIyNDatWu1c+dOe5qFCxcqPDxc6enpZ2dFAAAAAAA4Ayq0pn306NGaM2eO3n33XYWFhdnPoEdERCgoKEgREREaOnSoxo4dq6ioKIWHh+umm25SRkaGWrVqJUnq0qWL0tPTdd111+nBBx9Udna27r77bo0ePZradAAAAADAOa1Cg/ZnnnlGktShQwev72fOnKnBgwdLkh577DG53W717dtXBQUF6tq1q55++ml7Wh8fH82bN0+jRo1SRkaGQkJCNGjQIE2dOvVsrQYAAAAAAGdEhQbtxpjjThMYGKjp06dr+vTp5U5TpUoVffDBB6czaQAAAAAAVDjH9B4PAAAAAAC8EbQDAAAAAOBQBO0AAAAAADgUQTsAAAAAAA5F0A4AAAAAgEMRtAMAAAAA4FAE7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUATtAAAAAAA4FEE7AAAAAAAOdcpB+6effqprr71WGRkZ+vXXXyVJL730kj777LPTljgAAAAAAM5npxS0v/nmm+ratauCgoK0atUqFRQUSJJyc3N13333ndYEAgAAAABwvjqloP3ee+/VjBkz9Nxzz8nPz8/+vk2bNvr6669PW+IAAAAAADifnVLQ/sMPP6hdu3alvo+IiNC+ffv+bJoAAAAAAIBOMWhPSEjQhg0bSn3/2WefKS0t7U8nCgAAAAAAnGLQPnz4cN1yyy1asWKFXC6Xtm/frpdffll/+9vfNGrUqNOdRgAAAAAAzku+p/KjCRMmqLi4WBdddJEOHjyodu3aKSAgQH/729900003ne40AgAAAABwXjqloN3lcumuu+7SuHHjtGHDBh04cEDp6ekKDQ093ekDAAAAAOC8dUrN4//9739r/fr18vf3V3p6ulq0aKHQ0FAdOnRI//73v093GgEAAAAAOC+dUtA+ePBgtWjRQm+++abX97m5ubr++utPS8IAAAAAADjfnVLQLklTpkzRddddp8zMzNOYHAAAAAAAYDnloP3aa69VVlaWnn32WfXr10+///776UwXAAAAAADnvVMK2l0ulySpVatWWrFihTZs2KDWrVtry5YtpzNtOEnTR2Zp+sisik4GAAAAAOA0OaWg3Rhj/5+amqply5apatWquvjii09bwgAAAAAAON+dUtA+efJkr9e7BQcH6+2339Ztt92mdu3anbbEAQAAAABwPjul97RPnjy5zO+nTJnypxIDAAAAAAD+cMJB+3vvvafu3bvLz89P7733XrnTuVwu9e7d+7QkDgAAAACA89kJB+19+vRRdna24uLi1KdPn3Knc7lcKioqOh1pAwAAAADgvHbCQXtxcXGZ/wMAAAAAgDPjpDqiW758uebNm+f13b///W9Vq1ZNcXFxGjFihAoKCk5rAgEAAAAAOF+dVNA+depUrVu3zv68du1aDR06VJ07d9aECRM0d+5cTZs27bQnEgAAAACA89FJBe2rV6/WRRddZH9+5ZVX1LJlSz333HMaO3asnnzySb322munPZEAAAAAAJyPTipo37t3r+Lj4+3PS5cuVffu3e3PzZs317Zt205f6gAAAAAAOI+dVNAeHx+vzZs3S5IOHz6sr7/+Wq1atbLH79+/X35+fqc3hQAAAAAAnKdOKmjv0aOHJkyYoE8//VQTJ05UcHCwLrzwQnv8mjVrVL169dOeSAAAAAAAzkcn/Mo3Sbrnnnt0+eWXq3379goNDdXs2bPl7+9vj3/xxRfVpUuX055IAAAAAADORycVtMfExOiTTz5Rbm6uQkND5ePj4zX+9ddfV2ho6GlNIAAAAAAA56uTCtotERERZX4fFRX1pxIDAAAAAAD+cFLPtAMAAAAAgLOHoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiC9r+gR/r3qugkAAAAAABOA4J2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNr/wn6Z8GlFJwEAAAAA8CcQtAMAAAAA4FAE7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUBUatH/yySfq3bu3kpKS5HK59M4773iNHzx4sFwul9fQrVs3r2l+++03DRgwQOHh4YqMjNTQoUN14MCBs7gWAAAAAACcGRUatOfn56thw4aaPn16udN069ZNO3bssIf//ve/XuMHDBigdevWaeHChZo3b54++eQTjRgx4kwnHQAAAACAM863IhfevXt3de/e/ZjTBAQEKCEhocxx69ev1/z58/Xll1+qWbNmkqSnnnpKPXr00MMPP6ykpKTTnuZzUWZmpjIzMys6GQAAAACAk+T4Z9o//vhjxcXFqXbt2ho1apT27Nljj1u+fLkiIyPtgF2SOnfuLLfbrRUrVpQ7z4KCAuXl5XkNAAAAAAA4jaOD9m7duunf//63Fi9erAceeEBLly5V9+7dVVRUJEnKzs5WXFyc1298fX0VFRWl7Ozscuc7bdo0RURE2ENKSsoZXQ8AAAAAAE5FhTaPP56rrrrK/r9+/fpq0KCBqlevro8//lgXXXTRKc934sSJGjt2rP05Ly+PwB0AAAAA4DiOrmkvKS0tTTExMdqwYYMkKSEhQTt37vSaprCwUL/99lu5z8FLR5+TDw8P9xoAAAAAAHCacypo/+WXX7Rnzx4lJiZKkjIyMrRv3z6tXLnSniYrK0vFxcVq2bJlRSUTAAAAAIDTokKbxx84cMCuNZekzZs3a/Xq1YqKilJUVJSmTJmivn37KiEhQRs3btQdd9yhGjVqqGvXrpKkunXrqlu3bho+fLhmzJihI0eOaMyYMbrqqqvoOR4AAAAAcM6r0Jr2r776So0bN1bjxo0lSWPHjlXjxo01adIk+fj4aM2aNbrkkktUq1YtDR06VE2bNtWnn36qgIAAex4vv/yy6tSpo4suukg9evRQ27Zt9a9//auiVgkAAAAAgNOmQmvaO3ToIGNMueMXLFhw3HlERUVpzpw5pzNZAAAAAAA4wjn1TDsAAAAAAOcTgnYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqD9PLE4q7oWZ1Wv6GQAAAAAAE4CQTsAAAAAAA5F0A4AAAAAgEMRtAMAAAAA4FAE7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUATtAAAAAAA4FEH7eSZhyWolLFld0ckAAAAAAJwAgnYAAAAAAByKoP08VXXC+xWdBAAAAADAcRC0AwAAAADgUATtAAAAAAA4FEE7AAAAAAAORdAOAAAAAIBDEbQDAAAAAOBQBO0AAAAAADgUQTsAAAAAAA5F0A4AAAAAgEMRtAMAAAAA4FAE7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUATtAAAAAAA4FEE7AAAAAAAORdAOAAAAAIBDEbQDAAAAAOBQBO0AAAAAADgUQTsAAAAAAA5F0A4AAAAAgEMRtAMAAAAA4FAE7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUATtAAAAAAA4FEE7AAAAAAAORdAOAAAAAIBDEbQDAAAAAOBQBO0AAAAAADgUQTsAAAAAAA5F0A4AAAAAgENVaND+ySefqHfv3kpKSpLL5dI777zjNd4Yo0mTJikxMVFBQUHq3LmzfvrpJ69pfvvtNw0YMEDh4eGKjIzU0KFDdeDAgbO4FgAAAAAAnBkVGrTn5+erYcOGmj59epnjH3zwQT355JOaMWOGVqxYoZCQEHXt2lWHDh2ypxkwYIDWrVunhQsXat68efrkk080YsSIs7UK577MiIpOAQAAAACgHL4VufDu3bure/fuZY4zxujxxx/X3XffrUsvvVSS9O9//1vx8fF65513dNVVV2n9+vWaP3++vvzySzVr1kyS9NRTT6lHjx56+OGHlZSUdNbWBQAAAACA082xz7Rv3rxZ2dnZ6ty5s/1dRESEWrZsqeXLl0uSli9frsjISDtgl6TOnTvL7XZrxYoVZz3NAAAAAACcThVa034s2dnZkqT4+Hiv7+Pj4+1x2dnZiouL8xrv6+urqKgoe5qyFBQUqKCgwP6cl5d3upINAAAAAMBp49ia9jNp2rRpioiIsIeUlJSKThIAAAAAAKU4NmhPSEiQJOXk5Hh9n5OTY49LSEjQzp07vcYXFhbqt99+s6cpy8SJE5Wbm2sP27ZtO82pBwAAAADgz3Ns0F6tWjUlJCRo8eLF9nd5eXlasWKFMjIyJEkZGRnat2+fVq5caU+TlZWl4uJitWzZstx5BwQEKDw83GsAAAAAAMBpKvSZ9gMHDmjDhg32582bN2v16tWKiopSamqqbr31Vt17772qWbOmqlWrpr///e9KSkpSnz59JEl169ZVt27dNHz4cM2YMUNHjhzRmDFjdNVVV9FzPAAAAADgnFehQftXX32ljh072p/Hjh0rSRo0aJBmzZqlO+64Q/n5+RoxYoT27duntm3bav78+QoMDLR/8/LLL2vMmDG66KKL5Ha71bdvXz355JNnfV0AAAAAADjdKjRo79Chg4wx5Y53uVyaOnWqpk6dWu40UVFRmjNnzplIHgAAAAAAFcqxz7QDAAAAAHC+I2gHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaIckqf7s+lpfp67W16lb0UkBAAAAAPw/gnYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2lHK9JFZmj4yq6KTAQAAAADnPYJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaAQAAAABwKIJ2AAAAAAAciqAdAAAAAACHImgHAAAAAMChCNoBAAAAAHAognYAAAAAAByKoB0AAAAAAIciaAcAAAAAwKEI2gEAAAAAcCiCdgAAAAAAHIqgHQAAAAAAhyJoBwAAAADAoQjaUa5H+veq6CQAAAAAwHmNoB0AAAAAAIciaMdx/TLh04pOAgAAAACclwjaAQAAAABwKIJ2nLDMzMyKTgIAAAAAnFcI2gEAAAAAcCiCdpyUxVnVtTirekUnAwAAAADOCwTtAAAAAAA4FEE7AAAAAAAORdAOAAAAAIBDEbTjlCQsWa2EJatVdcL7R7/IjKjYBAEAAADAXxBBOwAAAAAADkXQDgAAAACAQxG0AwAAAADgUATtAAAAAAA4FEE7AAAAAAAORdAOAAAAAIBDEbQDAAAAAOBQBO0AAAAAADgUQTtOq/qz61d0EgAAAADgL4OgHQAAAAAAhyJoBwAAAADAoRwdtGdmZsrlcnkNderUsccfOnRIo0ePVnR0tEJDQ9W3b1/l5ORUYIoBAAAAADh9HB20S9IFF1ygHTt22MNnn31mj7vttts0d+5cvf7661q6dKm2b9+uyy+/vAJTC0laX6eu1tepW9HJAAAAAIBznm9FJ+B4fH19lZCQUOr73NxcvfDCC5ozZ446deokSZo5c6bq1q2rzz//XK1atTrbSQUAAAAA4LRyfE37Tz/9pKSkJKWlpWnAgAHaunWrJGnlypU6cuSIOnfubE9bp04dpaamavny5cecZ0FBgfLy8rwGAAAAAACcxtFBe8uWLTVr1izNnz9fzzzzjDZv3qwLL7xQ+/fvV3Z2tvz9/RUZGen1m/j4eGVnZx9zvtOmTVNERIQ9pKSknMG1AAAAAADg1Di6eXz37t3t/xs0aKCWLVuqSpUqeu211xQUFHTK8504caLGjh1rf87LyyNwBwAAAAA4jqNr2kuKjIxUrVq1tGHDBiUkJOjw4cPat2+f1zQ5OTllPgPvKSAgQOHh4V4DAAAAAABOc04F7QcOHNDGjRuVmJiopk2bys/PT4sXL7bH//DDD9q6dasyMjIqMJWwTB+Zpekjsyo6GQAAAABwznJ08/i//e1v6t27t6pUqaLt27dr8uTJ8vHx0dVXX62IiAgNHTpUY8eOVVRUlMLDw3XTTTcpIyODnuMBAAAAAH8Jjg7af/nlF1199dXas2ePYmNj1bZtW33++eeKjY2VJD322GNyu93q27evCgoK1LVrVz399NMVnGoAAAAAAE4PRwftr7zyyjHHBwYGavr06Zo+ffpZShFOxSP9e+n2V+dVdDIAAAAA4JxzTj3TDgAAAADA+YSgHWfNLxM+regkAAAAAMA5haAdZ11mZmZFJwEAAAAAzgkE7QAAAAAAOBRBOwAAAAAADkXQDgAAAACAQxG0o0IszqquxVnVKzoZAAAAAOBoBO0AAAAAADgUQTsAAAAAAA5F0I4KlbBktRKWrK7oZAAAAACAIxG0wxGqTni/opMAAAAAAI5D0A5nyYyQJNWfXV/r69TV+jp1NX1klqaPzKrghAEAAADA2UfQDgAAAACAQxG045zxSP9ekqRfJnxawSkBAAAAgLODoB3nrMzMzIpOAgAAAACcUQTtOKctzqquxVnVKzoZAAAAAHBGELQDAAAAAOBQBO0AAAAAADgUQTsAAAAAAA7lW9EJAE6HhCWrJUmBC36VJG0JvEbKzK3AFAEAAADAn0dNO/7S6s+uX9FJAAAAAIBTRtAOAAAAAIBDEbQDAAAAAOBQPNOOv7z1depKkrI6TJckHdr7qCTp9lfnVViaAAAAAOBEELTjvPXLhE+VfP+FyszM1IXtXpIkDXC9KcmjQ7v7e1ZY+gAAAACA5vEAAAAAADgUQTtwLJkRkv7ohX59nbqaPjJL00dmVWSqAAAAAJwnaB4PnKJH+veSJPWvNl7J919YwakBAAAA8FdETTtwmmRmZkqSFmdVV8KS1UpYslpVJ7yvqhPer9iEAQAAADhnUdMOnA2ZEVJmrurPrq+1g9ZqfZ269GYPAAAA4LioaQcAAAAAwKEI2gGH+GXCp5JoZg8AAADgDwTtwLnkGL3ZP9K/lx7p36tU8A8AAADg3MUz7cBf3OKs6hrgelOSFLjgV0nSlsBrpMzcikwWAAAAgBNATTsAAAAAAA5F0A6cx06mmb3nM/YAAAAAzg6CdgAnze4Y7xjP2AMAAAD483imHcAZ8Uj/XpKk/tXGK/n+C5WZmanMzMzyn7GXeM4eAAAAKIGadgAAAAAAHIqadgCOUX92fa0dtFbr69RVVofpkqRDex+VdLTGXpKeD1xs19hf1GmjEpas/qPG/v6eFZNwAAAA4AwhaAfw12E9Y18t1Q7+636/XtNHZtnB/+2vzqvIFAIAAAAnhaAdwHnF6hX/mDX2//+MPcE/AAAAKhrPtAMAAAAA4FDUtAPAKaDGHgAAAGcDQTsAVKDTFfyfUEd9JeYDAAAA5yNoB4Dz1PGCf0m6sN1Lxwz+Jem1aYXlzif5/gvP3goBAAD8BRG0AwDOmMzMTEnewX92x0aqOuH9Ywb/o2d00iP9ex3zJkJ586EVAQAA+CuhIzoAAAAAAByKmnYAwF+KZ7P/P1Njf7pq/q35AAAAnAqCdgAAzoLTEfxLUlaH6cecjyQNcL15UvO5/dV5+mXCp8eez/09pcyIUvPhhgQAAGcWQTsAADhlnjcj/kzwf7puIlTEfAAAOJN4ph0AAAAAAIeiph0AAOBPOF6NvSQd2vvoMWvsJSlwwa8nNZ/k+y9UZmbmMeejzFzVn13/nJkPAKA0gnYAAAA4wtm6iSDpaH8Px5iPJPWvNv6k5rN20Fqtr1P3mPPJzMzU4qzqzp/P/T1PcS8CON3+MkH79OnT9dBDDyk7O1sNGzbUU089pRYtWlR0sgAAAIBzj8fNEUfcRPDoVPNY85GOds55MvOx3hRyrPlYnYU6fT7KzD3ZPY1zwF/imfZXX31VY8eO1eTJk/X111+rYcOG6tq1q3bu3FnRSQMAAAAA4JT9JWraH330UQ0fPlzXX3+9JGnGjBl6//339eKLL2rChAkVnDoAAAAAOPM8WzScjZp/yfu1pWXNRzraP8fJzOdYry215nO816j+lZzzQfvhw4e1cuVKTZw40f7O7Xarc+fOWr58eZm/KSgoUEFBgf05N/doM5K8vLwzm9jToLjg4NF0FhgpL09FvxfpQFGRJOn3w/mSpIIjR5SXl6f9BfnKy8tTQUGB8vOLj/7edeAvPx9JynMdez6STno+eXl5OlBUdMz55OXlKT+/mPmcynyk485Hkgpcf8wnLy9PxfkHjjmfvLw8/X44n/mcwnwkHXc+kk56Pnl5eUeP+WPMJy8vT4eOHGE+JeYj6bjzkY6WZSczH6tsPeZ8/r+MZj4nPx/J+xxW1nwknfR8zqVzs9PmI3GtcE7ORyd/rXAi8zmXzs1Om4/k3GuFc4GVTmPMMadzmeNN4XDbt29X5cqVtWzZMmVkZNjf33HHHVq6dKlWrFhR6jeZmZmaMmXK2UwmAAAAAAClbNu2TcnJyeWO/0s8036yJk6cqNzcXHvYu3evNm7cqH379nl978Rh27Zt9np89913x/x7uqY53fNjGvbb+TqNU9PFNOy3c20ap6brfJ7GqeliGvbbuTaNU9N1Lk6zbdu2Co/djjfs27dP27ZtU1JSko7lnG8eHxMTIx8fH+Xk5Hh9n5OTo4SEhDJ/ExAQoICAAK/vIiMjz1QSz5iwsLBj/j1d05zu+TEN++18ncap6WIa9tu5No1T03U+T+PUdDEN++1cm8ap6ToXpwkPD1d4eLicLiIi4rjTnPM17f7+/mratKkWL15sf1dcXKzFixd7NZcHAAAAAOBcc87XtEvS2LFjNWjQIDVr1kwtWrTQ448/rvz8fLs3eQAAAAAAzkV/iaC9f//+2rVrlyZNmqTs7Gw1atRI8+fPV3x8fEUn7bQLCAjQXXfdJelok4/JkyeX+fd0TXO658c07LfzdRqnpotp2G/n2jROTdf5PI1T08U07LdzbRqnputcnGby5MmlHoc+l53zvccDAAAAAPBXdc4/0w4AAAAAwF8VQTsAAAAAAA5F0A4AAAAAgEMRtAMAAAAA4FAE7QAAAAAAONRf4pVv55OioiL5+PjYn//3v//ps88+09ixY+Xn53fc32dnZ2vAgAHq0qWLIiMjlZCQoJYtWyohIeG0pfHIkSPasmWL4uLiFBERcUrzKCws1Lp165SdnS1JSkhIUHp6+gmtoxMVFhZqyZIl2rp1q6pUqaKOHTt67cfTzRij4uLiM7qM893u3bsVExNT0ck4ra6//nr94x//UFJS0in9Pj8/XytXrtSOHTvkdruVlpamJk2ayOVyneaU4lhycnJUUFCgiIgIrzL0VMtj/PVMmTJFo0eP/suVYeeSI0eOlHtNc+jQIX388cd22Xmmr4FOx3Xbn7Vy5Uo1bdr0T8+n5HXyihUrVFBQoIyMjHP2GtLpioqK9PPPP6tq1apyu90qKCjQu+++q+LiYnXs2PEv+QruisAr384RO3bsUO/evbVq1So1btxYt9xyi+699179+OOPkiS3261hw4Zp8uTJSkpK0s6dO/Xuu+8qPT1dYWFh+uWXXzR69Ght2bJFkhQYGChfX18dPHhQknTNNdcoOTlZzZo10+zZs+V2u+Xn56evv/5agwcP1tdff63Vq1crNjZWI0eO1JAhQyRJDzzwgPr376/q1asrJydHV155pf73v/+psLBQbrdbnTt3VteuXRUdHa3c3Fy1aNFCMTEx2rlzp2bPnq20tDQtXLhQK1eulNvtVnp6upKSkjR//nzl5uZKOhqASlJYWJi6deum2rVra+vWrfLz81NMTIyqVq2qSy65RPHx8SosLLQLioiICIWEhNgF9ZQpU9SvXz9t2LBBK1asUHR0tGrUqGHftDhewHHo0CFt377dq1B6++23JUkdO3aUMUYvvfSScnJy9NVXX6lJkyZKSEjQwoUL9b///U+///67IiIidODAAaWnp+vDDz9UcHCw+vbtqwsvvFCXXXaZGjVqJOmPi+7JkyfbQdS2bdv0xRdfaPXq1dq3b58CAwNVvXp1ffnll9qwYYM6dOigKVOm6KGHHlJmZqYKCwt11VVX6ZlnntH//vc/rxsGxcXF2rJli6KiovTLL7+Ue3Ok5M2Gdu3a6cMPP1Tv3r3122+/KSwszKtgNsZoxYoVXvPzvCl0rJsxhYWF2r59u1JTU0/o5F1yGs95FxUVyRijqKgoNWvWTMXFxV7pjI6O1pIlS7RlyxZVq1ZNn376qa688kp98MEHysnJUVpamipXrqwmTZro0KFD9oWM5/YYMWKE2rVrp+HDh6tv374KCAg4qaDX2seVK1c+oZNdbm6unn/+ef3444+Ki4tT79691bx5c02dOtW++La24cyZM495Qb5mzRoVFhZq165dSkxMtL9v1qyZXnvtNaWkpMjPz08NGjQ47npMmTJFo0aN0pQpU/TCCy/o8OHDXuNTU1P12GOP6bLLLlN2drZWrFihX3/9Vbm5uUpPTy/zpuHKlSvVsGFDOz94Kioq0sqVKxUXF6eqVava2+vpp5/WE088oYYNGx43zSVvuOTk5Cg/P18bN24s98aaZ/70/G7dunXasmWLfvrpJxUXF+vIkSPq1q2bGjRooI8//liffPKJ2rdvX+aNOuvi0so327Zt87q4tPKI5zK3b9+uwsJCpaamav/+/briiiu0evVqXXzxxbrvvvt011136aWXXrKnd7vdMsbI5XKpdu3auv322zV48GA7zw0dOlSTJk3Sl19+WSrPncjN0+zsbC1cuNA+l3ge8yW381133aVmzZrpp59+Um5urhITE9WqVSvt2rVL27dvt7f7rl27tGzZMi1dulR79+5VjRo1NHToUPn6+pbaHtb+s74vLCzUokWLtHr1ajVp0kQXXXSRCgoKNG/ePHv9tmzZojVr1mjAgAEKDg4ucx+X3Paex7aVj59//nl16NDB6zxSMj2e8921a5feffddNWjQQLm5uV75zJomMTFRW7Zs0apVq7Rnzx4VFBQoKCjohG+w79u3Ty+88IJ+/vlnNWjQQJ07d9aNN96oyy+/XFFRUYqPj1ft2rWVlJSkzz77THXq1JF09F3H33zzjZo0aaK77rpLnTp1Un5+vnx9fZWQkKBatWpp+fLl+vXXXxUXF1cqL1h52bp4z8nJ0ZEjR9SkSRPNnTtXa9euVWxsrAICAnTDDTfIx8enzBsHJc85bdu21TfffKM6deqUG0xa+yY2NtYr8MzPz7fPR7/++qvcbreKi4tljFFKSoqKioo0YMCAcm8qegayISEhWrNmjXbt2qW5c+fqyy+/lNvtVsOGDdWkSROlpaWpY8eO2rt3r1q0aKHXX3/dPj+99tpr6tOnj/z9/SVJ999/v5555hn98ssvqlSpkm6++WZNmjRJklRcXKxJkybpySef1P79+73SExgYqJ49e+r5559XZGTkMfNByfXwPGYffPBB3XTTTQoKClJRUZHGjx+vp556yr5uq1q1qhYtWqQqVarY2/fvf/+7ioqK7G17vED4RG4ClDxfut1uhYaG6sYbb9T69es1YMAAde3aVREREcrJydHs2bPtY7igoKDUtVp2drauuOIKff7552rTpo3eeecdXXfddfrggw8kSTVr1tTHH3+s3bt3a8WKFSoqKpIkxcbGKikpSZGRkSooKFD9+vW9zsWFhYWqUqWKMjIyVFRUpMOHD2vatGnatWuXOnfurMsvv1w+Pj666667VKtWLX377bfKzc1VTEyMGjRooICAAOXk5Cg6OvqkbmSXdc6xrlM3bNigL7/8UhdccIFq1KihxMTEUmVzUVGRVq1apSZNmtjr89Zbb9nHVqVKlY55M8hz/+zevVuRkZH6+eefdeTIER04cEBNmjSRMUarVq1Sly5dtG/fPqWmpmrSpEl68MEHtW3bNjuWWLBggVJSUpSTk6Ps7GwdOnRIe/bsUUBAgPz9/cvcLlYeio6O1u23326nZdmyZSosLLTz3rHy4rFujJ2TDBxp1KhRZv/+/cYYYw4ePGhSU1ONpFKDy+Xy+ut2u02jRo2Mn59fmdOXNXTq1MkEBweXO97tdtv/h4aGGn9/f9OlSxdzxRVXGEkmKirKSDKJiYlGkgkKCjL9+/c/4eWXXBdJplu3bmbdunVmzpw5RpIJCQk5oXn4+/uboKAgr3lVr17dPP/882Uuxxrq1KljgoODvca5XC5TuXJl07BhQxMaGuq1jJo1axpfX197Os9tdLwhJibGdOjQwXTo0MFMnjzZa1zXrl1NRESE13cNGza0l1XeEBgYaJKTk83IkSNNaGioue2228yECRNMWFiY/duAgAB7f5a1DazvgoODzcSJE80NN9xg56Pw8HDjdruNj4+PV57w9/c3AQEBJjAw0B7ncrlMRESEiY2NtecZFBRkKleuXGo7uVwuExYWZnr27Gn69etnJJkZM2YYSSYsLMzUrFnTdOjQwbRu3dqMGzfOTJgwwTz44IPmjTfeMC6Xy1SvXt3cc889ZsSIEcbf3/+Y28jtdpuAgAATEhJiKleufFL50eVymQsuuMDExsYat9td5v7o2bOn8fX1NU8//bQZNmyY6dKli+nevbu5+uqrTYsWLUxiYqLp3Lmzefzxx02TJk3s31nbLTY21lx66aUmNjbW3u4ul8s0adLENG/e/JjH5t/+9jezbds2s2DBAq95XnjhheaJJ54wrVu3Nk2aNDG33HKLeffdd084r3bp0sXUqFHDhIaGmoiICNO0aVNz7bXXmmHDhpl7773XLFq0yM7T1m/Cw8ONn5+fnc+sdbHS6nK57H1lfVetWjWTkZFhunbtaiZMmGDnC0mmQYMGJiEhwQwcONA8/PDDXnkoPj7eREZG2nk7ODjYjBkzxtx7773m9ddfN6NHj7bzV6dOnUz16tXtssTX19f07NnTXH/99V7rHBcXZy//yiuvNPPnzzfZ2dlm5MiRRpIZPny4uffee83YsWNPeDta833iiSdM06ZNzcsvv2waNmxo3G63qVq1qnG5XCYwMNCetlKlSqZXr15ex/c111zjVU6HhIR4bYvjlUETJkww1113nfH39zf+/v7G5XKZuLg44+PjY6Kiooyvr6/x9fU1wcHBJi0tzQwfPtxERkaWKisCAgJM+/btzcMPP2yuvPLKMvOjJJOcnGxcLpfJyMgw0dHR5sYbbzyh4y0yMvK429LHx8ekp6ebe++91857LpfLpKenm/j4+HLT5Ovrax8bnkNiYqJJTU21t/kll1zidfw9+eSTxuVymZYtW9r7y5qP57F69dVXm6FDh9qfW7dubS6//HLTsWPHUutaqVIl43K5TJ06dcydd95p5s6dW+76+vv7Gx8fH3sb1atXz7zwwgsmLy/PpKSkmKioKNO0aVN7Hcsqw461zSWZb7/99qTys3Wsh4eHmzZt2tj5yDMfW/uqrOVa+6lBgwbm8ccfN7m5ueaWW26xzxOe51xrqFGjhlm+fLn5+OOPTXh4uFmwYIFJSkoyLpfLLgOsdTre+cAzf9SoUcNUrlzZXHDBBWbo0KFm1apV5vbbb7ePk+PNw8oP9evXNytXrjQul8s+pseNG2fcbrcZMGCAadu2rWnWrJmRjl43DR061GRmZhqXy2XatWtnqlevbhISEkxYWJi54447ykyr9bdbt27ms88+M9OmTTPS0bLQx8fHNG7c2HTr1s306NHD1KpVyysPpaSkmPDwcPs4TkhIMB06dDBhYWFm3LhxRpIZNmyYkWR69OhhXn/9dfPMM8+USoPnvgkODjZ/+9vfzIEDB0x2dra55ZZb7HzoeUy3atXK9OnTx7Rv394MGzbMjB492i7/atWqZbp37+613TzzT3x8vAkKCjLh4eH2fi45pKammo4dOxqXy2UeeOABExAQYJo1a2ZiY2NNQkKC6d27t0lLS/O6vvLz8zMxMTGl9nFgYKAZMmSIqV279nGvvazyw9qvJzIEBASY2rVrmzvuuMPs2rXLvu7ftWuXqVatmlm+fLm54YYbzJ133mmko9eAAQEBJigoqMzjyXNbRUZGmqioKBMdHW0fAy6Xy4wePdre92Xlq4svvtisWrXKvPHGG0Y6ep6Tjl4DjBkzxrhcrhMqm0sOVapUMRkZGeXGMJ5DcnKyeeKJJ8z//ve/Mq/RHnvsMa91iI2NteMOa7+NGDHC/POf/zRt2rQxoaGhxu12m+joaDNlypSKCudOK4J2h3K73SYnJ8c0btzYPrklJyebyMhIr4tOK7N2797dvvDyzOS+vr4mICDAuFwuc/vtt5c60ZzsARgcHGwqVarkVShPnDjR64TieQFfqVIl4+fnZ3x9fU1YWJgJCgoq82QXFRVlfHx8jI+Pj30R1K1bN6/1sAolzwLqVNahZGFl/R8eHm4XciEhIeaf//zncX9f8gaBJDvAio2Ntdc3KirKXHXVVX8qrVahdLx1LuskExAQUGbgZ12oV61atdQ+cblcJjk52V7uiaYxMjLSK7CtUaOG18VPWFiYXYgfK9Ao7+SUkJBgj2vdurVXIHPbbbcdczuc6GDtt7JuMvzZfXi8fXWs4VSXX/JGg3UB4DmNtR1dLpepWbPmKa9TbGysWbJkiX0sHesio+RgBeqS7HLGcx1O57YvOVh5vlOnTl7b27rZ82f2/YncJCpvfx9vva1js7yL2T8z9O7du9T+K+8G6qnsny5dunhdhHmW/55lfrVq1Y45/ypVqnh99vf3L3Vs+fn5eeUvz20nHc3/1atX/1PbKyQkxPj6+prx48ef8G+sdB7rxrk1nec+drvdJjk52bjdbhMUFHRSZcnJHJNl7V+3222Cg4NN9+7d7e1tjfdMx8lUHngOoaGhf6r8toaSx0Tfvn1NUlJSudN7HuOhoaFmxowZ9jnQc93T0tJKBUDx8fGlyixJpcrZYw1RUVH2MW+Vn6NGjbIrRkrOy8fHx95OJY+PktvvZNJxIkPjxo29lnGiNzj+7ODn52fnX19fXxMdHV1qGqsCQPrjuPIMql0ul3nzzTdNenq6ad++/XHzmrVtT/a48fPzO+42CQ4ONtdcc43Zv3+/6dGjR6l8eKz0HGs4Vlp9fX29gt2THVwuV6n8n5SUdMybKp7bxFoHK6A+mRu2ZaWlvHFVq1Y1brfbXHHFFSYkJMQ899xzFR3a/WkE7Q7lcrlMTk6OCQgIsIOg2267zQQEBNg1FuHh4XaGLXnRYtWIe35XsmZmzpw5JjAw0FSqVMmrNtblcplbb73VhIaGegVaJ3rQvPbaa6WmsS5arYC+T58+Xr93u91m8uTJxuVymX//+99eB7f0x8XV7NmzjdvtNvXq1TOSzPTp043L5TKxsbFG+uPE5HK5zJQpU0xQUJB908NKp2dNjHUyjIuLK1UoWoVPo0aNjMvlsm9SdO3a1UgyKSkppdbTc96eNdpWLZC1jY9XsLZt29brc7Vq1Yy/v7+pVKmSfWF57bXXGumPGgVrG0hHA9saNWrYn+vVq2diYmJK1UJJR28GWTX11va3tv2DDz5oJJlLL73UKx9Yd9/j4uK8apqsgvdET95WjaznxbPnySAoKMgrmJRkoqOjzaxZs+x1DwkJMb179y6VF2+88Uavzx06dChVe/7II494BSFvv/22eeGFF0xKSoq9b6waVeuz5z4rqzbIuvlk5XvrQv5Ea36svCPJZGRkeKXZz8/PzneeN8dOdLCOc89akPr163vlo7p169oX5YGBgXYtn5+fn9cF7913323nMR8fHzNnzhzjcrnMNddc41VeeG5fK6+U3G6e01jbzirTJkyYUGpdK1eu7JWXyzqOPFuGeB6PJcsyz/1ibZ+goCCvlgGef0u2NrHyrMvlsmu2rPx8IseBdTMtMDDQ1K5d22ucy+UyQUFB9k21+Pj4ci8Eb7311lLfPfvss17z8vzfsyb/eIPVguNE1qfkucgq7zzLveTkZDs/JScnm6uuusqrtZgk+2bwPffc47WfrLLY83NWVpbXvqlUqZJdhlrza9SoUan9bW3XkjcirPNBkyZNTEJCgte+vvrqq016erodLCQnJ5uAgACv+Vr5wPpdyUDR5XKVG6S73W47T1gtscq6wPbMK9WqVTP//e9/jXT0+K1cubJxuVxm8ODB9rKtwLpFixZe5worHSWDuvj4eBMWFmaPT0tLM48++qiRZJ9/PQfrvGitg1Vja+0Tf39/07hxYyPJPPTQQ+Xmn/vvv9+uNQ4ODjb333+/fXxY29OqLfU8x0kyX331lb2+iYmJxsfHx0yZMsVOU1RUlGnRokWpZZaspbf+9yx3Sp47rfW67rrrTvg4OtGhX79+dlpq1KhhXxOdbFDcoEEDrzzvec2Ynp7uVaZZx4DnNp03b55XGWrtUyst1rlDOlq2R0RE2PvIWpZn3i3rZrjL5TJVq1b1uvlgldWtWrUyF154Yan86dniwNp/nvP0LOOt/FDyBlK9evXsaylr3COPPGIk2TdurWPc5XKZoUOHel0D1KtXzytPeqbHatkZGBhowsPDTZ06dbzSFhgY6HUMWvujrHOL5+B5c8GaxqoMso4Jz3NrySC4ZAsGl8tlrrzySuPv71/q5q/n9rbm6XmzpKw0XnTRRfb/VssNz9YeVhpeeeUV8/DDD5c6rw8ePNhehlWelGzBULICwtfX174muv766+14IiwszIwcOdI8/PDDplGjRubpp582jRs3rujQ7k8jaHcol8tldu7caZo2bWpCQkJMYmKiWbFihYmNjTXr1q2zDy6r0H3nnXeMdDRYszJy69at7QDf82LVOthatmxp2rRpU+rOmMvlMl988YU9rY+Pj/nggw9KndQ9L5pKHlSe85L+qDW3DkjrROz5Wyt9ZV2AWxcOGRkZxu12m48++shIR4P4YxVyJzo0bNjQSH80i/Qcpk+f7vXZahLseeFhFYBWoWWdAD23bdOmTU1QUJDXBVxZJ2GXy2WWL1/u9V1ERIRdq2/t6xUrVngV5J416S1btjSBgYH2sho0aGBcLpdX0zDPi6nyCnZrSEtL89rOX331lf35zTffNJJKNZW11qVOnTqlgpgTufgoGVz92X38xBNPmNDQUK987NnMVZLZuXPnSV0YWSf7koF8yQCvrOEf//iHcblc9o0jz1pda13HjBljJO+LdiuguOSSS7z2ledNJM/l+vr62k27Pae38qq1fOvEbOWZqKgoO2888MADRlKpWmjPbWXNu+R+69u3r/3/Nddc4/WddRHfs2fPcrfTsfaHNc662PK8CCh5M2nWrFkmICCgzNY61u+sgPNkW/H89NNPpkGDBnaQZT1G0b59ezsNl19+udc8u3Tp4rUNXS6XWbNmjZH+KDcqVapk3G633XQ6ODjY3l/W9rZuKlnNtj2XsXTpUnt9PFtXWNvGc1+99957RpL9+IRns/MTaXGSk5NjgoKCTFZWln2jynNdPI81a7t4HjMl52etn7UOntNYj02dSB6x0r5w4UKvdZdkbrjhBiOp1CMSJzMEBgaWaolRskwtqxy4+eabjVT2Oeexxx4zkuzzsNW01AreSg6eNd21atWy0zJ//nx7+1uPBgwfPtwuv62bnpLM1KlTveb50EMP2TeNrHmUrF0r78ZD1apV7WMyPj7ezgtWkDdv3jyvfTd+/Pgy96G/v799fvnPf/5TanzJQMzz/GaVk9b52hqsG1Ce+cbadlZT87JusA4ZMsRrnLUtsrKyymxlUDJ/PvXUU6XyQvXq1c1LL71kz7e8G7sly9TIyMhS12PLli0zkszDDz9sf/fkk08a6Y9rGM8gNDIy0uuYso536/GO8tbjWMeC1aJS+uOaynrczXOwtnNZ+9EK2K1m+F9++aWR5PWIo+dNZ0lm5MiRJ31D44orrvA6NqRjP4bp2VLV39/fXHzxxUaS1yOO1r7Nzs722m9Wk3PPwco/ZaXbmo/V4u3SSy81LpfLDoQ98/r7779vJJnHH3/cSPJqNWndzLSGV155xQQFBXm1BAoMDDSXXXaZnVZrW1iVQpLMTTfd5LWfJk2aZFwuV6nWqJ6tIKyKlLKukazKgJKPgpY1vPXWW3a+kGTatWtX6ri38u7ixYvt/RgVFWWqVatmNm7caEJDQ82GDRtMWFhYRYd2fxqvfHMwq+OP4uJiVa1aVcuXL1fbtm01adIkud1uBQcH2520rV+/Xi6XSxdffLH8/f2Vnp6uvLw87d27V5KUmJhod4JUXFwsSVq3bp3+97//qaCgQC6XS263W76+vjLG6LrrrrOnrVu3rt544w3Vrl1bkuTj46PAwEBde+21kmR3HBEaGipJpTrKCQsL0+7duyVJDRo0kNvt1gMPPCBJCgoKsqe7+OKLFRwcbKczLCzMHnfo0CFJ0qpVqxQTE2N3tHTXXXcpICDAXqeoqChdcsklcrlcio2NlSRVqlRJbvcfWf3TTz+10/zyyy9Lkr777ju5XC7deOONkmR3GCMd7RTL1/ePFy08++yzkqR58+bZ28Pf31+pqan68ssv5XK5dM0118jlcnl1yrVy5UodOnTI7tQpIiLC3n+WZs2ayRijiRMn2t+5XC7l5+crJiZGxhi7U425c+dKOtpZiSQ9/PDD9m++/PJLHTp0SI0bN5Yk/fLLLzLG2B2vJCQk2P9fddVVkqTOnTvL5XLZ21qSvawdO3Z4pbNv376SjuaPvLw8BQYGKisrS5UqVZLL5dIll1yi5ORkGWP0448/yt/fXy6XS8YYud1u3X///QoNDdXNN98sl8ul+vXr2/tk7NixkqQuXbp4LXPcuHH2/9Z6XXbZZZJkd5zVtWtXe5rx48fb/4eHh+u+++5TcXGxWrdubX/fpEkTr06QnnvuOQUHB9t5OSwszN731rwDAwPt6Y8cOWJ3bmTlsYKCAsXGxsrX11cPPvigQkJCJEm+vr4KDQ21O35buXKlJNn7wfx/50g+Pj52vnjxxRcVHBysCy64wJ6/tb+XL1+ua6+9Vr6+vgoMDFRubq69Da15SlJKSooiIyPlcrm85jNq1ChJRzvnsdItSbt27ZLL5VKVKlXs47N+/fqSpAEDBtjHpzFGAQEB9nKsdFnby/q7fv16VapUSZLsju0yMjIkSXXr1pV0tCyy8toNN9wgSbr66qvt5bjdbq/9OXv2bEl/lD1t2rSRJLvjJF9fX02YMMH+vSQlJycrKirKLius6YwxuuaaayRJLVq0kPTHseDr62uXjf369ZMke5tb28RKx2233aYnnnhC0tH8FhwcbOdLY4zWrVunoUOH2tvvq6++UnBwsP71r3/Z01jlhdWB1ZEjR7zylq+vr318dujQQb6+vnaHVNZ6eXZQde2118rPz09FRUV2B0o+Pj7y8fGRn5+fVyeE27dvlyTNnDlTkuxxLpdL48aNk8vlUv/+/SUdzVPR0dGlOlyMiYnRzz//LD8/P9WqVctrH3mWP2vXrpUk1atXz2t9rWndbrd9nM2aNUuS7POUn5+fnVcDAgLkcrns/NWrVy87LVZarW2XlZUll8tl71drGrfbre7du0v6o1yzznXS0TI5KCjIno+fn5/8/f31zjvv2PukXr168vX1ldvtltvtVseOHeVyuZSamiqXy+WV56z17NOnj1wulz7//HNJf5Qrbrdbjz32mCTpwIEDkv4o2++77z5JR89zV155pZ2XDh8+bHdW9dNPP9l5/pprrlFBQYHcbrcSEhLUqlUrvfXWW7rtttskHS3/rM5sp0yZ4pXGkJAQGWPUsGFD+1wcFRUlSRo+fLgkKTo62l4fz86ycnJydPfdd0s6eiwUFxd7dTA1YsQI+/+AgAC9/PLLdpnreU1w5MgRO+8lJSXZ6bCuMTw7EZSkK6+80v6uefPmkv7IB1b58swzz9jTW9vJ+rtz505JR8t9a39bZVzz5s0VHBxsfz9mzBhJR89XzZo185pPScYY3XzzzZL+KJsbNWokX19f+3wUHx8vX19fXX/99fYxbC3ryJEjXvN77rnnNHDgQK/vtm7dKkn64Ycf7G392muvSZLdOad1DEVHR2vfvn3Kz8+3j3Or49+ff/7Za9nSH8flW2+9pZCQEPs6ydrHlsLCQv3++++SZP/1ZB133333nb0MHx8fxcXF2fvWyivW3wcffFCS9Mgjj9jHu5+fn5o3b27v2+eee07GGCUnJ0uSWrZsaS/POmYGDBgg6Y/9+cYbb9jlyCWXXOK1nhbPjkOnT58ut9ut8PBwHT582F72tGnT7HLF2rdTp06V2+22P1v5ynP5l112mdxuty6//HL7e2ubW99Z5+Z69erJ5XJp165ddj62yqy77rpL0h9lqjUPt9vtdU0oHc2rcXFx9nnYx8dHEydO1C+//GJ3gmyVVZ6dIO7Zs0fSH8fmd999J2OMsrKy7GX5+fnpyJEj9jGwYcMGSX/k3cDAQHs7devWTYWFhWrXrp3Xdm/SpIm9TOt/q7Nna5qNGzfa69ipUydJsuOLDz/80N6WeXl52r59u/bs2aPQ0FAdOnTor/EWm7N1dwAnp3379nZnZR06dLCfxdi4cWOp5+5atWpl+vfvb4KCgkzr1q3NiBEjTM2aNY3L5TLVqlUzYWFhpe5MBQQEmEqVKtlNmY9VI5iQkGDfUQ8ICDAtWrQwF154oWnfvr1JSUkxv/76q2ncuLHdjNHzLrrkffc7KCjIfPzxx6VqXj2f+axRo4a5+eab7bugnmk/XicclStXtmunpKN3pEvevfa8G+7Z+sCzWbPn4Ofn5/X8tcvlsp/Tt6axarjKqw22mom98MILZtKkSSY+Pt40aNDA+Pv7281dfXx8SjXhtn7rWUNachnWs2R16tSxxw0ZMuSY28rzbmxYWJhxu90mJCTEfhSjvGWVN8+Sj14EBQV5Pd/n2ZzKx8fHJCQkePUHkJKSYudFq0MlqwbCGjxrm++55x7jcrnMokWLTKVKlUo1k/Qc3G63qV69utc2PJm78p5N28oannvuOa9t5Xa7zQUXXGDcbrdp3bq1XcsZGhpqbrnlFrN69WqvPOfZGmPQoEFeHRx6PuNbVr684oorjNvtNi1btjTr1q0rs6bAz8/PPn49t0HdunXLXaewsDBz4YUX2rVzVtPQiIgIr2aVJ/KsX3x8vPn222+9HkEpma+Cg4NNfHy8XQMkHW1JEhUVZe68806TlJRkgoOD7Zp+a/kDBgzwWr7VSabLdbQ/BuvYiIqKMoMGDbJrwK15WLWdZeWHGjVq2E2xw8PDTVJSkvH19TWhoaEmODjY6/j37Ouj5HFpfU5ISDA5OTnG19fX1KpVy9x9990mPj7erv2ynt2WZHdSZjUFbN++vfHz8zN16tSxpx84cKBp3ry5Wbp0qd30t+QjAcHBwXZtWnBwsBk4cKCJj48v9ciJ56M81v+etXDWulr7xu12ezXnlI62xrHKEkl2x1JW+V9eq6ITPQ6t5daoUcNERETYz6gnJSUd8znlks8ke+a/adOmmaioKHPdddeZkJAQc/fdd5uMjAy7PGnYsKHx8/Pz6gCqZLN7q6bdKitat27tlT99fX3tFiVlDZ7Hu+v/m81b5yWrNrVkZ1nPPvusiYqKMvXr1zdXX321V/lb3jaNj4+3O9yzvsvIyDCXXXZZmdNHR0cbt9ttKleuXKqfgbp163qdV5s2bWov1/P78tLiWU5dc8015pFHHin33FmtWjX7cQ6rw9jyakQ9l2c9dnW8PGbV6LrdbvscY/UfEBAQYO8La99Yec1zvtb/9evXN8HBwSYiIsJre/j5+dmPx1l5q1atWmbEiBHm448/NpJMmzZtTOvWrc3jjz9uioqKzJNPPlmq4zGrQ8OaNWuaXr16lWomXHLdrH1hHYPWuvbu3dtERUWZ5ORks3TpUuPj42OXz9Y5IiYmptQ+ycnJMUOHDjUtW7Y0lSpVMu3atbPna13HWOtdMg97PnLo2elveHi4+e9//+vVasPz/7JaH7hcf3Si6XK5TPv27U1AQIC58MILjcvlssvi8PBw+/i3Wnm1adPG6/iV/jh/nEgfDGXl0xN5dl062gTeysOXXHKJSU5ONldffbWRjtb8W+tq1Rxb59+wsDCv6+GS59+yypOS5+TevXt7PT4qHb2eDw8Pt/uVqlSpkleHwmWtQ1JSkn0esDoi9vPzsx+VtPbJ1KlT7elKdhjnmU+ssiY5OdlUrVrVBAcHez0Ca50TXa6jz9FnZmbaeatkf0meQ1BQkImOjjbt27c3/fr1M88///xfonk8r3w7Bx08eFC33nqrmjdvrlmzZnnVCg8YMEDDhg2TdPTu2DPPPKNFixbpv//9rx566CEdPHhQAwcO9KptPHz4sCZMmKCFCxdq6tSpMsbol19+0ZIlS7Ro0SIdOHBALpdLiYmJmjdvnj788EPl5eXZd4Zvuukme16zZ89WmzZtlJmZqY4dO9rz8/PzU2BgoEaNGqUxY8bo0KFDuuaaa/Ttt98qMjJSzz//vObMmaOuXbvqwgsvlK+vr5599lmNHTtWv//+e6k72IGBgSooKLDvrj799NPKzs5WXl6e/Tqpq666SlOnTtUXX3zhVeMdEhKi1q1bKywsTG3bttWhQ4fUo0cPPfXUU5o1a5aKiopUt25dNW3aVGvXrtXatWtL1ZRYKlWqpHr16umzzz6TdPTVIQMGDNDWrVvldrvVsmVLNW3aVE2bNrXvJH/xxRc6ePCg7rvvPi1btkxRUVGKjIxU9erV7dobf39/jRo1Sv/+97+Vl5cnl8ulsLAwdezYUe+++66KiooUFBSkI0eO6KWXXtKCBQskHb3TeODAAb344ovq0qWLRo8erblz55Z6dYy/v78mTJig1157Td9//72ko3ddR40apZ49eyoxMdG++/zbb7+psLDQvlNZcl/4+fkpKChIoaGh2rVrlwYMGKBNmzbp+++/1549e1RUVGTXRpfch57vUz18+LAaNWokl8tl10IHBgaquLjYriEsKipS1apVdc899yglJUXffPONVq5cqfvvv1/jxo1TTEyM5s2bp927dys4OFiBgYFKSUnRVVddpfXr1+vgwYOqX7++3n//fW3YsEHDhg3T888/r59//tlOn8vlUnh4uFq1aqXPP/9cQUFB8vX11Y4dO3TxxRerefPm2r59u5KSkjRv3jzt2LFDOTk5ioqKsu9Il+Tj46MuXbpo7ty52r59uyZNmqTff/9db7zxhletuKVmzZoKCAjQ999/L2OMAgMDFRkZqYMHD9r7pV+/fsrKytKSJUv01ltvqVq1atq2bZvatGmjbdu2lZmOsnjuU6tGS5J+/fXXMtcjLCxMrVq10uLFi0vVAPn6+qpFixbq0aOHAgMDtWDBAm3atMmuvbFexRcYGGjf/bbKF8985XK57HLt8OHD8vX1VVBQkA4ePKiioiKFhISobdu2qlWrlp566ik1btxY27Zt0+uvv65WrVqpTZs2dh4qySo7mjRpojFjxmjZsmV6//33lZ2drYSEBF188cV666237GOmrDxvta4pKChQSkqK3G63XTt34MABTZkyRdu2bVNxcbHee+89ZWdnKzU1VTt27NCmTZu0Zs0apaena9OmTWrZsqVdU2AdJ6GhoWrevLlWrVqlffv22emIj49XTk6OgoODNXPmTMXGxmrdunX64osvNHr0aPn7+2vy5MmaO3euHn30UY0YMUJ33323/vvf/6qwsFC//fabzNHH4rzWJTAwUPn5+apatap++eUXFRYWKjo6WrVq1dKqVau8Wt/4+vrarSqs9Pr7+9t5ISAgQP/5z3/Ut29fzZ49W/Xr19fbb7+tLVu26IMPPlClSpWUkZGhdevWKTc3V1WrVtW+fftUVFSkiy66SHfffbdGjhypd999V4cPH1Z0dLTy8vJKvUqw5P70zMPm/1tnlFXDHRMTo6FDhyoqKkpt2rSRMUbbtm3TggULVLVqVU2ePFnbt2/XP//5T7Vq1UrPPvus5s+fb7d48Pf3t7eHv7+/hg4dqubNm2vNmjWKjIzUXXfdpY4dO+qzzz7zqtkx///avdDQUF155ZWaN2+edu7cqTp16mjhwoW68cYb9f7778sYo+joaPs8OW3aNA0aNEiRkZFKTk7WHXfcoezsbH366ae6+eab7VZQ1vr7+fmpY8eO8vf314cffmiXL57bpXv37qpUqZJXC7KWLVvKz89P3377rd5++21FREQoOztbdevWVUJCgn788UeFhYXpk08+UadOnZScnKz4+HjNmTNH27dvL7eWuazjxxIaGqovv/xSderUUWZmph5++GEdPHhQkZGR6tq1qzZt2qSvvvpK0tFa/ocfflhffvmljDGKi4tT3759NWbMGB0+fFivvfaakpOT9dFHH2nq1Km64YYb9PHHH8vX11e7d+9Wfn6+1q1bp+3bt3u1SIqNjdWECRO0dOlS+7WA1usuw8LC1KFDBxUXFysyMlLr16/XqlWrtG3bNrVt21ZvvvmmJk6cKF9fX61evVoBAQGaNGmSLrzwQrvm+j//+Y9GjBhhvxLR5XLpuuuu0xNPPKEJEybonXfeUU5Ojp599lnt3r1bR44c0eTJkyUdbeE2e/Zsff/999q0aZNcLpdSUlIUHBys5cuXq3bt2mrSpIn+9a9/2WWsdLSVTH5+vg4cOCBjjHx9fVW3bl1FRUWpadOmMsZo+fLlSkxMVFpamt59913VqlVLV1xxhbZu3ap33nlH7777rj788EP7mu/IkSPKycnR77//rrffflvVqlXT2LFjtWnTJoWEhOiHH37QwIED7dpX6/iwjluXy6WAgAAdOnRIzZs3V3FxsbZt26Zdu3ZJktq3b6/GjRvrtdde0+7du+1acIuPj4+CgoI0cOBA5eXladeuXXaerFWrliIjI/Xqq68qPz9fb731lvr06aOVK1dqxIgRWrVqlbZv364ZM2Zo8uTJ+v7777V8+XLdeuutiouL044dOxQUFKTAwEBlZ2dr/Pjx6tu3r0JDQ9W1a1dFRUVp4sSJCg8P12OPPaa4uDj9+OOPCggIUEhIiBYuXFiqfPLx8VHdunWVm5ur1NRUZWRkqH///vrPf/5jl3uTJ0/W/fffr4ceekgNGjRQfn6+Nm3apNzcXLuMLalSpUrq1q2bvvjiC23dutVuDWa1yCzPunXrVLVqVY0ZM0YLFizQ77//rho1amjjxo3au3evXQ4NGTJEixYtssvO2NhY5ebmasiQIXr88ccVEBCgRx99VFlZWRo7dqw+//xzVatWTQcPHtSPP/5ot0QNDAzUb7/9pv79++vrr7+2W1dYrFYLNWvW1LBhw7xa3/z888/69NNPtXjxYtWuXVsTJ05Uq1atNHnyZHXr1k1r1qxR27Zt7XO01Uq4SZMmevTRRzV16lTNnz9f0tFrqQ8//FDr16+Xn5+fV2vMcxFB+znCs4lkye9/+eUXdevWTcOHD7ebvVlq166t6dOna/v27aWaU+3du1dz587VwIEDvf4v6aefflJBQYHq1Kmjxo0b64MPPlCPHj30wQcfKCUlRenp6WUuu379+pozZ45WrVqlhx56yJ7e06ZNm+Tv7283a/Jcr4YNG2ru3Lm66KKLNHbsWEVFRWnIkCF699131aVLFx06dEiFhYV2s7rybNu2zb448fHx0a5du3TBBReUOe3+/fu1ZMkSOzCSpMWLF+vAgQMKDg7Wb7/9puLiYiUmJio6OloxMTFKTEzUpk2bdPDgQdWpU8frQqg81rs2reZBnttj+/btatWqlT2fxYsX6/fff1dGRoaio6O1Y8cOzZs3TwUFBerUqZPS09Pt3+/du1fbt28vtX6LFy+2m2utX79eo0ePtvPTpk2blJeXp9TUVLv5Y0mFhYXaunWr9uzZo02bNtnvum3SpIkiIiLKTY+nl156Se+//76uu+46XXDBBapatapWrlypr776SkeOHFHTpk0VHh6uCy64wCvP7dq1S/PmzVNubq5iY2N10UUXKSkpqczj4USVzHfGGO3cuVPFxcWKiYnxeizgeOu2cuVKffbZZxo4cKAKCwv1008/af369dq3b59yc3PVqVMnr5s2ls2bN8vPz0+vvvqqPvroI/Xu3VspKSnq1KmTPa3nvrceQ/Bs0nwsb7/9tl577TV17NhRBw8eVEREhC699FK7yXVMTIz27dtn788jR44oLS3N3ibffvutXn75ZR0+fFhPPfWUHnzwQdWoUUOtWrVSTEyM/b70zZs328dEWet58OBBLVq0SN99952GDRtmN8+0zJkzR2FhYWrSpInCw8NljNHKlSu93g3etGlT+fr62o/zWGmQjp7grWbIntasWaP58+dr9erVio+PV0BAgCIiIhQWFqaMjAzVq1fPq3l/SV999ZUCAwNVs2ZNrVmzRu+++64KCgrUtm1bderUST/++KO9363m2Zs3bz7mPnrvvff03nvv6d5777Wb+B48eFBvvPGGJKlHjx6lts/ixYv166+/as+ePfLz81OzZs2UlpamuLi4MpdRWFioX3/9VVWqVPEqZ4qKivT111/b+zsxMVGVK1fWxx9/bF+0XXLJJXrvvff0wQcfaOrUqfYyXn31VS1cuFAtWrRQWFiYEhISVK1aNa1Zs0ZLlizRxIkTtXbtWq9y6nTavXu3Fi1aZDcRTU9PV+3atfXjjz8qOztbv//+u/Ly8jRkyBBJ8so/VoAXEhJip/tk5eXlec0zNjZWderU8Tpv/fLLL3a5ZO2D4OBgr+1dtWpVr/nu2bOn1L4+mW14vGMwLy9PX331lXJyciQdPZamTZum2bNn23m0vHNRfn6+fUPHU1nH265du7Rp0yYdOXJEe/bs0aFDh7zSYx3TP//8s3744QeFhYWpXbt2atOmTanj9s9uk+PxLNObNGniVYFxIsvyPHd4bgvr3Gud17Zu3aqVK1dq4sSJCg0N1cMPP6yNGzfa7/K2vPfee/roo4908cUX69JLL7W/L7lfCgsLdfDgQfn4+JS5vxo1aqSEhARNnDhRbdq00eHDh/XZZ5/p8OHDXuWlxZpXQECA13WDZz62hIaG6r777tNNN91Uan9t3LhRhw4dsq85Fi9erJycHDVs2FDLli1Tbm6udu7cqXbt2ikjI0MHDhywt9nmzZslHX2sxvO84Xk+Dg4O1hdffFGq3Jdk30S65ZZb9Oqrr9rHQ+fOnbV7926lpqbqwIED+vrrr1W9evVS6xUWFqZvvvlGQUFBJ3QNU56S5YN1zgoPDz/ub8s6Z5Qsq40xiomJUVJSUrnXmD179tTf//537du3T35+fjLGqHr16vrtt99KnadKXv+Udcx5nnNOZpuUdc2Un5+vxYsXKz4+vtyy8GS2j8XzOrHkNvn2229VUFCghg0bntA1+bmCoN3h8vLyNGzYMM2dO1fh4eG64YYbNHnyZL3zzjvq3r279u/fr6SkJAUEBKigoKBUrV1YWJheeeUVXXLJJdq9e7fmzp2r3r17a+7cuXK73Ro4cKBuueUWffXVV/rss890xx13KCMjQz179pSfn582btyoF198UVu3blWVKlX02GOPae3atWrYsKG++eYbpaWlKTg42F52VlaWPv30U/3444967bXXNHDgQL344osKCAjQ2LFj1aRJE9WpU0f16tVTp06dNHPmTPs5VGOM1q5dq3vuuUfz5s3ToUOH1LVrVy1ZskSffvqp/UxZQUGBiouLVVBQoHvuuUc//vij+vTpo4yMDOXn52vHjh1KTEy0n5cMCwvTP/7xD1WuXFm5ubnq06ePoqKitH37do0bN06bNm1SVFSUwsPDFRQUpMqVK+vyyy/X7bffbqfv6aefVkpKiqpVq2bP19MXX3yh2bNna82aNdq/f7/8/f0VGRmpxx9/XI8//rh9UR4fH6/33ntPBw8eVOPGjfXMM89o1KhRatOmjV588UWtWrVK8+fP16ZNmyQdfRatbt266tOnj12jEB0dreDgYFWpUkUJCQn69ttv9dZbbykqKkojR460L1yLi4u1a9cuJSUlKSQkRKtXr1ZaWpp9o8d6BtHzhk29evX0xhtvqE6dOpKOPgf62WefaceOHXK73UpLS1OvXr1Uu3Ztvfnmm+revbv9DGFaWpoeeOABde/evdSNlCNHjmjZsmVKTU1VSkqKfH19dfjwYYWFhWnQoEG67rrrdOGFF3r9Zs+ePVqzZo0aNGig6Oho7d69Wy+88IImTZqkuXPn2s+8W2lcvXq1du7cqYKCAvv5KqvWvHLlymrcuLGqVq2qXr162ct/6aWXtGLFCn333XcaPXq09u3bpy1btujQoUP2c2gRERE6ePCgZsyYoeDgYB0+fFhvv/22CgoK9Nxzz+k///mPnYcte/fu1T//+U9lZmbqtdde89pOnkpuw/LGbdq0SY899pgSExN16623qqioSO+9956KiorUo0cP7d27V7NmzbKP06FDh6patWql9vXmzZu1YcMGr+PDyr/Lly/3uujIyMiwn/EODQ3VmjVrVK1aNW3ZssV+9r6goEAvvPCC9u7dq7CwMPXu3VvVqlXTRx99ZD+L1qtXL82YMUPvv/++2rZtW+b28lSyXChLu3bt1KdPH40dO9a+edS/f3/Vq1dPXbp08Wp9VBbrJqhVm2BdyBUXF2vZsmVq0aKFtm/frsLCQq1cuVIFBQXq0aNHqQtfa7vt2LHDrgmvWrWq3QokIyNDWVlZys3N1SeffKI9e/Zo1apVuvrqq9WoUSNdcskl9nOLxhh98803WrVqlfr06aO3335bISEhXsv+4IMPtHjxYnXu3FndunWzt3NRUZF69uypgoIC5efnKysrS++//77d58SmTZv0+++/a/bs2Vq7dq0+/PBDLVmyRAsXLtTWrVsVERGhFi1aqEmTJna+MMbY+9o6Xqx836NHD0VHR2vNmjV69tlnNXr0aF1wwQVau3atnn76aeXm5mrAgAFKT09XXFycnn/+eX355Zdq1aqVgoODVVRUpICAAK/jp6z9/s477+ijjz7S4cOHFRsbq/DwcGVmZuqVV17R1q1bvfJreHi48vLy7O88n3u3pmnVqpVatmypiIgIDRw4UKGhofYNy9q1a6tPnz72sjdv3qwffvhBXbt21bZt2+xjKD8/Xw899JC2bt2qzZs3KygoSHl5efr88881ZMgQRUdHKyEhQb///rtuvvlm+9i28srXX39tt2JJSkqSv7+/fv/9d/Xq1Uv9+vVTbm6uXnjhBRUUFGj69Om69dZb9fTTT0uSHnroIf33v/9VpUqVdPXVV6tp06Z64YUX9Pvvv6t///764IMP1K9fP69zqmfaf/zxR3ufJCcna+TIkWratKkaN26sf/zjH8rKytKiRYv06KOPqm3btho/fry9T7744gsNGDBArVq10ieffKLBgwerV69e+uSTT7yW6Xl8edq8ebPmzp2rdevWKSIiQj4+PkpISFBqaqq++uor/fzzz6pataqGDh2qr7/+2i77rDLMOqZmzZolHx8fdejQQQcPHtRHH32kVatWqaCgQNWqVVODBg103XXXqXbt2po2bZpWr16tL7/8Uj169FDt2rXVsmVLJSUleT2DL0m33HKLIiIi7BYjCQkJdhA7ePBgr1ZhX3zxhZYtW6affvpJYWFhduuhKVOm6JtvvlHjxo310EMPldouJVl5Ys2aNXrxxRf1+OOPKyMjQ82bN9cLL7ygESNG6L333lPHjh31/vvva/ny5fr+++81f/583XrrrWrdurUuvfRS+fv72wFoWlqamjVrpp49e9q1v57leVZWlt544w2tX79elStXVnx8vIqKirR7926FhoZq1qxZ6tevn0JDQ1WtWjUVFBRo8uTJat26tbp166arrrpKv/76q/75z38qOTlZN9xwg4qLizVlyhTt3LlTgwcP1uDBg7Vu3TpNnz5dxcXF6tmzp7p162bfDC95XTl06FBt3rzZ61ojMTFR/v7+uuOOO8rdbrfffrtatmypzz//XH369LFvDFjnLc9zaHh4uL7++mvVqFHDno+1zawWRqGhoZo5c6YGDhyoKVOm6N5779WCBQt06NAh1atXTw0bNpSPj49++uknrVq1SpmZmZozZ44aN25slzc5OTmqXLmy3njjDb377rvaunWrXC6XIiIilJCQoLCwMOXl5SkmJkZut9uuiKlXr5569+6t8PBwr3LWasFl1aj/9NNPmjlzptavX6+6detq+PDhqly5ssLDw/W3v/1Nt956q9d5qqxyJzk5WY0bN1aVKlW0bds2/frrr3K5XNqyZYt27dqlvXv3qlWrVqpevbpq1Kih3bt3q127dkpLS9OiRYv0zjvvqKioSI0aNZK/v79q1aqlpKQkbdiwQe+884727dunatWqqU6dOurRo4d+/fVXNWnSRO3bt7fLk+LiYnXu3FkzZ87U9ddfrxkzZqhatWry8fGxW7guXbpU+/bt08GDB5WTk6OCggKlpqbaN5pq1qwpPz8/paWlKSAgQEOGDCnzWuov5cy0usfpcvPNN5tatWqZ2bNnmyeffNKkpKTYz2yGh4eb/v37ez2/kpuba9577z3TuXNn+znImTNnGumPXlNfffVVr2c/Sr6SQf//zNTcuXONv7+/iYmJMTExMfbzNo0aNTJ+fn7m2WefNWvWrLGfgSrrXcRlvSrO9f+vCvHx8TH33Xef6dixo+nZs6fXayWs3ilL/tYaPv744+P2Jl6zZk1zxRVXlDnO8/Ut1jNCZfVkeeutt9q9NVtDenq6GTZsmBk4cKDp06eP/cyN51DyeaLY2FivZ86s3oo917GsHpTLG9LS0uxn0KwepUeNGmUiIiJMnz59TLNmzUxAQIBX2q3XhVnP1sXHx5tatWrZz1taPZX6+vqWerZdOtrTbck3Bvj6+poGDRp49SpuzXvatGnmX//6l1m/fr357LPP7HGBgYFl9gAaFBRkatWqZW644Qbz+uuvez0XOHnyZJOcnGw/F+Xj42MGDhzo9cqZ8oaS+ch6Nrhq1aqlnpez1jkoKMh06dLFfm7OWuZNN91U6nng2NhY07x5czNmzBhTWFhotm3bZvfka00XGhpqrr76atOjRw9z4YUXmqioKK/nDNPT081NN91k/vnPf5r69evbz99ZaSm5Ptaz7kFBQV7Pm6anp5tGjRqZ4OBgc9lll5mNGzcat9ttVqxYUer1Kj4+PqZKlSr2Nk1OTjYtWrQwzZo1s9MWFhZmH9chISH2M6I1atSw37HqOc+AgAD72PL39y+zTGjatKmZPn26ufPOO82jjz5qoqOjTYsWLczkyZPNu+++a78HuUOHDiYmJsYkJCSYCy64wEyYMMHceeedpnr16va2v+222+xnTD3z67Bhw0xGRoaJi4szMTExJjQ01H4NpnW8e/ZAHBwcbEaOHGk//+j5TKX1nJ6Pj4+JjIw0gYGBpkqVKqV6py/Z47zn649KDhERESYsLMx+48Ty5ctNlSpV7Ok9X2FoPdtesqduz7xa3rtxrd9Yz6mXfL47IiKi1KusrP5OPF/v06NHD5OcnGxCQkJMcHCwiYmJKdUHiPXmkhMdrN/279/f3HnnnUY6+naCDh06mB49epTqIyAkJMTrNUnWa98CAwO90lHyDQFWmVPWvihZNvj6+pqLLrrIa5tY5eKePXvMTz/95PVMeMnB7XabqlWrepVT7du3L/XqJSsflvy9ldes1yyWzNcl0x0YGFhqPlae6tSpk7n33nuNJHPxxRd77R+Xy2USEhJMSEiIfQyX95x4RkZGme/CLpnnrGuF6tWr2++Or1+/vrn++utL9QtilR0lz3k+///ecavMDA0NtV/5dax+C0508DyG7rjjDtO7d2/TqFEjr+uU0NBQU716da9jxTpPREZGmpSUFK9jybO/gpiYGPtVfJ7nyISEBDN9+nSzbds2895775nLL7/c7j3cM29a+8gqGzy3i5+fn2nZsmWpN7n4+/vbPbXHxsZ69ZHh/v/3vVtl//Ge2bauKaKjo8t8i0zJfGb172NNa6WpR48eJiAgwCQmJtp9QNx8883mpZdeso9hl8tlQkJCvPKdVdY1bdrUzhtBQUGmYcOG5oknnjA5OTn2M+llXR9aZXvbtm3NqlWr7OvkQYMG2a+S8/PzM/Xq1TOffvqpCQ0NNfPmzbNfZejZp0FZ6xwdHW2/Rs9zSE1NNXXr1rX7tznRoWT+Dw0NNTVq1PAqZ1u0aGFefvll43a7TZMmTUrtAz8/P68+iqw+kDzf4FGy34yytl9Z27Pk8/Fl9ZvhOW9Jdp9E1ne+vr52melyuUynTp3s1wtLstcpODjYpKenH/OarrxXu3rmIbfbbcLDw8348ePNkSNHKjqEO+0I2h0uNTXVLFmyxC7MPE/gJ9uJz/EG60R5wQUXmEqVKpno6OhyLwbP1ODn5+f1iiDrNWIlD1brJGt1emd1RtGqVSsjHX1dlVVgl9xenvNq3LjxSW1Ha/v7+vp6XUSEhYWZiIgI+533JQt9q0Opk90fJfez1UmH9McJ1nrdz8SJE+1OTazArqxOXI53s6O8dJzoUHKZ/v7+dkFe1kVDyc6DrP9jYmJMv379TipdJTuEiYyMNMnJySYqKqrUhfOx1q1Ro0b2K/ROdr+d6PY81ru8T3SbW535JSQkmOeee85UqVLF9OzZ037H9dq1a732ybHWpU2bNubIkSNm1qxZRjr6apWQkJDT0oFYRQ1l5beSZYm/v7/dEZVnp1Oe0xyrg8ng4GATHh5u4uPjTVBQkN35m9UhoZWOsoJJz4ui5s2bl7pBaF14ey7fsxOnstanrMH6/TPPPOO17OOVBSUv3F0ul6lZs6Z9U8cKEDy3s2des7bPn9mH1vu6PTuV8lynsl5deaxXb5X1ueT3Pj4+drBhXRCmpqaa1q1b20FTVlaW3TGYlR4r/1jBl+f+9HwPddOmTc2QIUNMUFBQqX1+vKG8Y89z/Uu+mq28/HAmj2Ork6qyliuVfoe0dPR8bKW9vAv0svKlZ9DtecPDc/+dyPp6bkPrBoLncj0DFCud5b2m7VT24Zn6rXVjy+rYzOVy2XnXeuVXyfkGBQV5dVBZcv9Z463P1s0Ka3tbx0BERIQJCAjw6oi0rHeuW78NDAw0DRo08Mo7VvDXoEED+6ZQQkJCmeV7UFCQSU1NtTu2nTp1qte+qlmzpj1vz5ux0h+ds55ImVrWULKSKCQkpNTN3bLyy4033ui1HSpXrmyGDh1q0tLSjNvttt/Fbk1jbWNrnp6/tdbNusHueZxZ+8h6RWVwcHCpSoHyrtHKOid6vt72dOTtsvalZ3pLdtxb1uBZsdSlSxeze/fuig7jTiuCdocLCgoymzZtMuHh4eaBBx4wH3/8sfnggw+MJFOvXj27Jut0HCjWHas33njDPimOHDnSXvadd95p3zzw8fExKSkpXoXFzJkzTWRkpH0ntOSQkJBgZs+ebRISEswTTzxhr4PL5TKxsbGmf//+xsfHx3z77bf2b8LDw73eW13ygLWCkqSkJBMSEmIqV65sXC6XVy2z9Vur9tKzpqR69eomMTHRvttttVz4+9//bk9jtWyw3mvt+T70UymorIu+sn73yCOPmNjYWBMfH298fHzMP/7xDyPJ/iv9cUIpWTMSFhZmXyhHR0d71cKeyGDVbFmBWq1atUrVlFarVs2EhIR4tYooWdtjbXvrrrXne4ObNWtmB/DWxbyvr6/dC7jL5fJ6P7TnCc5zGSeyXhMmTDjpY6Csk5Pn8SHJtGjR4pSOLesd4J77X1KpfFpWmkrWOkoqdde9SZMmZuzYsSYtLc2uHbTyjZVXOnToYE9v3RDzvMgaOXKkXSuWlZVVqnbeWgfP/GD973mDJTo62l7Pkr9xuVyltmFZ76o+kcGqabU+e75FIDw83Gtfdu3atdR+tnppb9mypVfNu+e6WN+V1WpIOnpxdOeddxq3222/s9mqjbFugEjH7q2/vKF169YmOjraaz08a989v7du2HnuU+udy1aZ4XkBZx1/Vllj7UvrAik5ObnMwEr642KqZG/E1hswPKe98cYbS+2zkrVVnrVvJY+Dso7HBg0aGLfbbb+j3joWrPeuS0driCMjI+3816VLF+N2u73e992yZUtTuXJlr3cSW9vECtrnz59vby+rN3VJ5oknnihVDlnvP7ZqPq3htttuK1VrlZiYaEJDQ02XLl28jiWrpsy6qeLZYmP48OEmISGhzDda9OzZ00jeLR5uvfXWk85zLpfLdOvWzTRq1Mj+rkmTJmbnzp1ePUtnZGR4vd++ZGAhHS2nrXzq6+tr5xfPtzb4+/vbb54p+ftjDZ43sE9kqF27drlviDldQ1ktEqx1Kvm2GeloeZWRkVFmWq1p/Pz8zPXXX2+3gLOugSZMmFAq//n4+NiVCV26dDHvvvt/7P13fBVV8ziOz+7e3tJ7DyEBEtJICIQWCEhTOkgRBQRBRAURkSaoCKIixQIqiqCCIgIivRcVQar0EoQEEWkPIARIm98feWY4u3dvCOrzeev353m99nWTe8+eM2f6aTNf49ChQ/kdyvPdokUL1pUGgwGbNGnCPEv9ki8ltk+LkN27d3fbJY+IiFDVWbBgAQKU23zCOZ1KIP9Piw+9h+w49eVwONBoNOLOnTt50kh4oDoiXj755BPe2LhXevbo0UN1okH87fXXX3f7XmsjLBYLWq1W7Ny5M4+RZIAW1kmfi9HVKVo82QzSl+Ki1ZtvvqmLNzG7Aek10q8vvfRSpccuLmiKfr/YHi0C6D1kX7p37+4G58iRIzlqPZ0SkCRJdVKhbdu2Kr+f9OOHH36oyv4htkt8XqNGDaa52WzGzp0745o1a/6vp3N/Sfl30v43LwkJCbh8+XLMycnBSZMm8feSJGFGRobqCBYxvrgqLCoqEnxSGlOmTFEpGjq60r9/f3bWXn/9de67tLSU69lsNpwzZ45KYR08eBCtVqtbyreKFAIpIqvViocPH0YAwC+//LLSiuXHH39EANA92v5nnrlz597zO5IkYdu2bVVOgcFgYAPy6quvoizL+Mgjj3hsY+nSpWi1Whn/GzduRIDy4+HUHk2Yt27digBqR/VeHnLyiBZvvPEGAqiN4/r16xHgjpNFz3PPPcd/0/UKGvfcuXM9OkYLFixQ7QIR/6xYseKedn9efPFFrksrsPQ/8cL27dsRoPyoNMCdyfIfTf2mfcQFjaCgIHS5XPjUU0+hJEl83FfkcZpI09FbrXMLcGex6Mknn1S9f/r0abeVehr7Hz02Skf4x40bhwCguzDg6SFcaieTenUJ/9ox3+2RJEm1C1kZWu3YsYP/njdvHtpsNtURcfpNm9YmLCxM5ZRoJ10AgNu2bVO988EHH6jSNQIAPvHEE+jv78/4EfXIO++8o2qvZcuWCAA88fSEA+3/2h0oGtfDDz/MvES7aTRp015rEXmO4Bo+fDhKksR6QZRh0vnaRbyKaCJO1sV6BoMBX3jhBf5eTGsoSRJOmjQJJUlivbZ48WK02+2qhVR6yGmbNGkSApTrBerr448/RpvNxo4qLQyS3QMoP1EjyzJu3rwZAe5MakR++SPOfkUP6XIab0hICDqdToaTjndWlue19KSxANyxj9qd6WeeeYbbpjGLJyIQUaXDKntyAeCOP6HVgSJP0YSFHPZ58+ZxHYKDTlW89957bvBp6aK30EM8P3nyZAS44/8sXbrUI13pihnZ3wkTJrjVMZvNGBoayvpc3EH+/PPPVXUXL16MFotF5Sc98MADqvRdJ06cYJgJn926dePFDkoVC1CuT6jOr7/+qptqTJxsaRf2PD0+Pj58bZJorV0U/l/IAj1PPPEE2246qk58SXZ84cKFKvj8/Px4/OTTLliwAB0Oh+qItsh7drsdx48fj2azWbUgXRkcET9qbQfZc5fL5aYfvby80OFwcFo/8f1FixYhAOD06dNRkqQKrxdp4bNYLHj69Ol7PqUjvk9/P/fccyhJEvt/oh/maRNj+fLlCKA/aafTfySvU6dO9bjJItozm82mSmdNcNHv06dPRwD1pserr76qwuknn3yCBoOBUxGSvGVlZfHVpX96+XfS/jcvTz75JHbq1Anff/99nDZtGn8vyzLm5eWxMTAajbxSV7NmTRw2bBi2bNkSjUYjGo1GrF69OgsB7bAlJydjfHw8OwjPP/88Tpw4ESVJwurVq7MSbdWqFfbs2ROHDBnCfdlsNty8eTMr0MjISOzYsSPGxsaqDBfdOzQajehyuTAyMhItFgsrYLq77nQ6OS93mzZteKcBoNzhJOVE46VPWtmmFVfaXbPb7XxUnh7aCRCFnPJp03vUnmhkX3rpJZRlGd99910EKHdGDAaDyolITU3FsLAwHDZsmNtRJTKcjz32GAKU73aRAdEqsaysLIyIiGDlNWTIENVKcmhoKO8A0SSL7r+OGTMGzWYzxsbG4vLly1VHSfXuPe7bt0/1HbVTpUoVPuI/b948lKQ7udMnTJiAJpMJv/rqK36P7shTu4iILpcL161b54ZLykWq3an7+uuvmca0iku7lLSbv3v3bsY55QbVOnIGg4GdqWHDhvHRN5vNhoGBgZiTk6Na4CEckuH38fFBl8uFgwcPZmMlrk4bjUY2ruJu8ZYtW1CSJD4e9/XXXyPAnby6RqORnSDaWROfjh07IsCd/KzaO+1bt25lvnryySfR6XSi0+lEq9XK7zZu3Jh3i4neIr7oXWqXFtcCAwNZ5gHu7Pi9/vrrvOhEDi/dL6XxiTtLVIfunBPexON6dNS7adOmCHBnx4V2fcSJc9++fXnnUoRTS2/xO9pZliQJU1NTVfLyxBNPuC2oUfuka4gftZMcWZbdJo10fzQgIABnz56NsiyrrqwAqE/DjBo1SnXclnaQVq5cybSlnZFmzZohADCeRJ1FcqI9yk/XYUjuaZfHZDK54Ul86ASRxWJBp9OpmtSS00YT6EaNGqn4lBaM6Nip0WhkGqSmpqLJZMIqVarwQmPXrl1RURTs0KED48JisbCuttlsWL9+fbRarSynJ06cwDZt2mCvXr1U9o5si4hnq9XK/Jueno4+Pj7sSPv4+Kj4S1EU/PTTTzlGAfGYr68v1qpVi3UD4VN0BAHKbRfRh3BrsVgwIiKCvzcajejn58dxYQDunPRyOBzs4NavXx+jo6MxIyMDjUajm+2iJzY2FsPDw9HpdGJcXJzqqgTxEN1/FeWT9EBKSgrKsoybNm3iSV14eDgGBASojvb26tWLT52J+lqUBy8vL3z88cf5u1atWjGMAHdOfvj6+vIuLD1ELzr9QrnpxQUwalu8c0/0btq0KcdyEds1mUx8Uoz8mm+++QYB7kzWiWe7d+/Op+ZIpy9ZsgTNZjMuXrwYAYDv11LO+szMTPTy8kI/Pz/Wl2RvAMAtPsRnn32Gbdq0wZSUFNaDtOtuMBgwIiKCJyOivaZj4m3btsUxY8awf0ITKwD15oY44RN13JIlSxAR+USSzWbDqlWrqhYlCe81atRgu+Hj46M7IXzppZewbt26rK/JpkmSxHJHvEfvi3f+CU5RL5KNqVatGsqyjL169UIAYP5bsWIFWiwWzMjIQF9fX7TZbBgZGYkul0t1Wg+gfPG1efPm6HA42B/WToYnTZqEOTk52LFjR91dboA7mxQvv/wy16FNEhrfO++8g7Is88IhnVAS26ETJu3bt1fRHqD8ZILFYsGZM2cyX5J+ouuexBMkfxkZGSwvY8aMwZo1a7otpJAdttlsvPhE+rdt27YsJ1Tfx8cHo6OjMTc3121hWxuvieB4/vnn+RqKdjOBaEvyFxUVhRaLBR966CFuv1atWm4+aZ8+fVS8S7aL2qWYR9o4TWIbI0aMwODgYFy+fDn6+fmhl5cXx4o5fvw4jhw58v9kHvdXln8n7X/jUlRUhA0aNMDly5e7fQ9QvvPTr18/DA8Px86dO2NUVBTWrl2bj7muWrUKIyIisE6dOjht2jQ8d+4cjhs3Dk+fPs1GSFRCpGS0QWtEgxgYGMhBmxYuXIhWqxUfffRR/PHHH9lZp/boXlF0dDQ2bNgQhw4dimPHjkWz2cwOGR3BMxqNWK9ePYyJicEDBw5gTk4ONmvWDK1WKwfH8vHxwR49emCLFi34OC05rnQUPC4uDhs1asSCqr0vRXXNZjO6XK5K7SBQ0Axy4oxGIzvCpHz12tB7nE4nTp06FZOTk3HJkiUYGBjIisfT3Tg6iUB/050vcgLJoR4wYAAmJydjmzZtsFOnTvj0009jTEwM5ubmqo7UE05ol4Pu4Yv96a3QJycnY8eOHXHZsmW8+0HXF8R6586dw/j4eOzXrx8ClDvC1H5iYiLa7XYOaifLMvr6+uKLL77Iwe+6d++OJpOJj+0qioJJSUk4d+5cdnAoyMq9HnU0mUz4+OOPY8+ePdHf318VcKtBgwb46quv6t6ZUhQF4+PjMTg4mOlN73l5eSEiYmJiItasWRMlSeLda1oEEwOXaQ2NLMv44osvotPpxBo1aqAkSaoANRkZGfjBBx8wPYYPH46NGjXC77//XldOFUXBBx54AOvXr6+SDwB10MmkpCQEANW9XO1DjojBYMAGDRqwQ0DOLjmpZGAtFgs+88wzqskETWRJ/ux2O1atWhUjIyMZhxs2bHDru1OnTvjggw9iWloa1qpVCx955BG+pydJ5dc34uPjVbxLEzQ6Ui4GSQIod2TonnhISAg2atQIg4OD0dfXFwMCAljGtccctTwhxt4gfUGPwWBgZ8vTzlSdOnV4ASU8PJxlv2PHjpiVlYXVqlXDwMBAdo7FYEM0XjGYD0D5YqBeMMvK3nmnu9Z0pJnGBVB+JNHLy4sXYImmVC8wMBDbtm3LR2Ppu27duuFbb72FWVlZCFC+cNG8eXOsXbs2408MMEeB8UTeEHdN/4pHu0OrDWKXk5ODderU4cU14nGDwYBRUVGqhUKtjpRlWQVrWloa83tFu3kGgwEff/xxfOaZZ/C+++5TTYbFvrKzs1Xv2O12XnCgcYSGhmJ0dDQvXhMtfHx8cOzYsdirVy9ctmwZOhwODhbmiUckScLNmzerFma1vxMvEl8SzxLeAgMD0WKxqHakK3q0R//FIGc0WVcUBbOzs92ub3h7e2PLli3RZDKxXhMXtcS6bdu2xZycHPT19eXJOdUVZVtRFJ5Q7tmzBwcMGKCicUWnjUJDQ/Gpp55ivqCJvp+fX4WnVoheixcvxt69e2NmZqZHGuXk5GBoaKiujIj+GG1OaANm1qlTp9InOrp27Yrnzp3DxMRElCRJpZ9EfHl7e7vhSFzcEB+r1Yr+/v5u/ii9n5aWxgstNWrU0A0EJz400aNF6c6dOzNPValSBVu3bo116tRBRVGwbt266HQ6eSKYkJCADoeDr/jUrVuX6TRx4kSMjIxkG+FwOFBRFBw8eDD6+PjoLip7khcap0iLJk2aYExMDCYkJODVq1dx+vTpmJqaipIkeQwKSDCIi+d/VQweb29v1fUaRVHcYmWIi3na0w2k0+vUqYN+fn6M4+TkZIyNjWW8iou32qtglX1IJ1MwOx8fH3Q6nThkyBAsKyv7/8zReMR/J+1/++Lv74/Hjh1z+97HxwePHj2K169fx379+mFSUhI+9thjWKNGDRw1ahQ7kDk5Ofjbb7+p3k1KSsL8/Hy8evUqbtiwAefNm8dRon18fPDYsWNYo0YN9PLywrp167Jiyc7OxpMnT6LNZsM333wTV69ejU6nk+G7ceMGrl69Gl0uF+bm5iIi4qJFi/CTTz7hvuPj49Hb2xtfeuklNJlM7DCQYlq7di0iIr7//vvYvXt3HDx4MB44cABPnjyJZ8+e5XYKCgp4dXf+/Pm4b98+fPfdd/Gjjz5CRMTS0lIcOnQo5uTkYEJCAu800aS3c+fOeP36dVy9ejW+/fbbuGHDBly0aBHWqVMHLRYLpqWlYcOGDVVHxKxWK0+MSQF7e3vjiRMn8Ndff8VJkyZhRkYGZmRk4IYNG/Dq1at4/vx5/OGHH/D777/Hn3/+meGfMWMGLlu2DBERv/76awwPD8f169dj3bp1eTIlKvqQkBDs0aMHLl26FHfu3Ilnz57FGzdu8OkAWZZx5syZOGPGDPz888/xwIED+Pvvv2OXLl147AkJCW7BmtLS0jA3N9fNSRH7DgsLw5EjR+Lly5fxwIEDPIaBAwdinz59sHHjxmy0xcm+y+XCpk2b4rhx4/CFF17AwYMH46pVq3DGjBnYuXNn7Ny5M+8gkOIeMGAAdunSBR999FEcMGAAH38bPHgwtmzZEq9fv44LFizA/Px8HDp0qNsOUG5uLo4ePRq9vLzwiSeewGHDhuGoUaPwww8/ZJpQ2bJlC65cuRK//vpr7N27N/7000/8/cyZM3HevHlYrVo1tNvt2Lx5c7xy5QqflqDHz88PV6xYgYiIzz33HNaqVQtr1arFK+UNGjTAU6dO4eXLlz0GULn//vtx5MiR+MEHH7g595Ik4cGDBxER8d1338WxY8fiiRMnsKCgABERL1++jJ9//jmOHDkSX3jhBZw5cyb26dOHT+Vcu3YNV6xYge3atXObQIaFhWFubi72798fP/74Y3zyyScxICDAzWj6+Pjgs88+y/2Jd9QoGM3atWtZRmfPno3PP/88bt++HbOysrBFixaIiDhnzhwMDQ3lBbMjR44wr0tS+VH4Zs2a8USD4gDs3r0bFy1ahK1atcJ69ephv379cPDgwazXBgwYgC1btsRHHnmEHYWoqCjdnQ9ZlrFevXq4fv16/O677/DNN9/E6dOn44kTJ7Br166qybrBYMDExETs0aMHtm7dWnU3n4LXUeC5+vXroyzL+OGHHzKPjRs3DkeMGIG9evXCBg0aYHp6OjZp0gQfe+wxXL58OT777LOYlJSE48aNw+zsbAwNDcUBAwao5Jb0TmZmJu7btw/HjRuHK1euxK5du2KTJk1w2LBhnLkhIiICfXx8sGXLljhv3jxcunQp65zly5ercE3jEOOF3M3ZpNgmffv25d1Mcia/++471g3bt2/Hxx9/XBW599q1a/j5559jXl4enj17Fk+ePImzZ8/G1q1buznhpHOmTp2KkiThV199hfPmzcNRo0Zhdna22+kaOl1Q0QJsTEwM3nfffRgeHo5eXl5Yq1YtnDdvHs6aNQvff/99fOedd3D58uX46quv8kKYiBcvLy++nlZcXIwLFizA2bNn46pVq3D06NE4e/Zs7NatG/bs2ZPbrV27Np8AIx0XEBCATzzxBCYnJ2NycjLWq1cPmzdvjrNnz0ZExOvXr+PNmzdx2LBhWKdOHXzttdfwjTfewA4dOuCECRPw8uXLePz4cXzkkUd4YcxgMKiCTvXq1Qtfe+01DA0NZZtHckTlyy+/xBdeeAEPHDiAw4cPx4SEBF6sMRgMWL9+fRw/fjxGR0ezXuzbty8mJSVh8+bN3a6jybKMAQEBqngkxGd+fn44depUvH79Onbv3h1DQkKwbt26qowxAOWnzJYtW+Z2ykCSyuOcTJ06FRER8/LyVKfBbDYb9unTBxcvXozFxcX49ttv46OPPoqIiPv378f169fjtGnTcMqUKfj222+rsjSQnHt7e+OSJUvwueeewzZt2mD//v2xY8eO+MMPP+AHH3zANpZ08dWrV3HZsmU4ZswY/PDDD/HVV1/le97U7pAhQ1S2lLJY6PGooihYtWpVTEtLwx49emBYWBh26dIFv/jiC3S5XHjgwAHMzc1VxeNxOp347LPPYsuWLfHdd99FPz8/1UkDktns7Gx8++23UVEU3LFjB65evRo7deqEXbp0webNm+Obb76JEyZMwEaNGuH+/fvx5MmTeOzYMdyxYwf26NEDmzdvzhOsYcOGMQ8999xzGB0djTVq1MDRo0dj//79MSEhAfv3748zZszgeEXt27fHiIgIt7HLsoxNmjTBVatW4Y0bN3DChAn49NNPY1paGp+kASjfKe/evTtu2LABhw8fjjVq1ECz2YwGg4En0K1atUJ/f39cvHgxXr16FR9++GF88803cfPmzfjggw9y37SQm52djYsXL8Zz585h9erV0WQyYWZmJl65coWvc9GixA8//IDjxo3DkydP4qFDh3D79u34zTff4FtvvYWDBw/GHTt2sG/60UcfcZyUMWPG4Pfff4+jR4/GoUOH4ltvvYXz5s3D999/HyVJwhkzZuC8efOwe/fumJqaii1btsQJEybgSy+9xDg+efIkWiwW9h3eeust7Nu3L65fvx67du2KSUlJ+Mgjj+Czzz7rFn+GFv9r1KiBgwYNwlmzZuGwYcOwZ8+e2Lx5c2zcuDHu3bsXY2JieCHbaDRiu3btcPv27disWTO0WCwYGRmJ27ZtU+ElNDQUV6xYgcXFxXjt2jXctGkTf86dO1eV4UW0740aNcKjR49igwYNcPbs2dilSxfd7Eukz0gvnDx5Elu3bs3yRPo8Li4OjUYjdu3aFXv16oW+vr58j/2hhx7C69ev4//Xyr952v/mZciQIWA2m+HVV1+t1PeUdzI5ORm+//57SE5OdmuT6rRt2xZWrFgBrVq1gqysLJg7dy489NBD8M0338DNmzehS5cuEBgYCOPGjYOSkhLOvS32Lf595swZCA0NBZfLBT/++CNUr15dt+/OnTtDYGAg3L59G2RZhubNm8Mnn3wC33zzDTRt2hRq1aoFdrtd9d5TTz3l1lZsbCycO3cODhw4ALGxsRXi8datW6oxaAvBfvbsWQgNDVXlmD158iQUFhZCtWrVwGAwePwOAAARQZIkt3ZlTc5aAICaNWvCihUrICIigmmSkpIC+/btA6fTCSdPnoSysjIICQkBg8Gg205sbCy88sorcP78eXj44YfBx8enwrE7nU5YsmQJICI0bNgQzp8/z+2eOHECAgICwMvLy+P49MZVWFgIiqLArl27ABFBlmV48MEH4ZtvvoGUlJQK6VJYWAjffvstnD17FsaOHQsffPABNG3alMd55swZWL16NXTp0gWcTqcbDDdu3ICLFy/Czp07VeM/c+YMhISEgKIoFdKgIjp5ouWpU6fg8uXLEBcXB97e3vx9WVkZFBYWgs1mg+PHj8OxY8egevXqEBcXB7Isg8PhgCVLlkBISAj89ttvEBgYqMIvtZOXlwdHjx4Fp9MJe/fu9UjXey3EB7/++ivcvn0bqlWrBq+++ipMnjwZcnNzWe7+85//MB6ef/55+O2339xws2/fPvjyyy8hNTUVGjVqBAEBARXiUlvEnMIir507d45xQDDSd7IsAyLCL7/84lFWz5w5A7t27YKmTZuqdMjx48fh9OnTKp6n98+ePQulpaUQEREBkiTB+fPnoaysDPz9/TmvMJVdu3bBhg0boGfPnhAcHKz6LTY2FmbOnAlNmzaFX375BcLCwnRh1CviuGRZhjNnzoCvry+UlpaC1WqFwsJCcLlcurg9deoUICLExMToti2+43A4YO7cuRASEgIhISEQHR0NTqcTNmzYAGVlZXD69Gnw8vKC3NxcKCgoUOVBj4mJgYKCAh7Xrl27oHr16nD48GHG95kzZ6CsrAzCw8Ph7NmzLIN64xVl68KFC5CamgoTJ06Ehg0bQnR0dIW40tIIEeH27dtQXFwMRqMRioqKoLCwEBBRVUfs0xOOAMpzitPYK6vLKoL1zJkzkJSUxDnjK8IFQHkueEVRwGKxeGybdGdRURHUqVMHhg4dCqmpqdC5c2cei8j3JpOpUjCLskl/x8TEqPgToFymbt++DYqiQGlpKeuyCxcuqGxXdHS0R9yLdHM6nUyHS5cuQV5eHiAihISEQFRUlKp/7djFvNRavGr7pnevXbsGiAhWq9VjG1Q86RX6TcSLWFdRFPDz84Nt27ZBcnIyFBQUsL738/OD//znP7q6RqTBI488AqmpqfDCCy/Atm3bIDw8HAwGA/syYl09uM6ePQtlZWWQk5MDixcvhpSUFP5twoQJMHnyZMjOzoakpCQIDQ1V4UrP76K2AwMD4datW+ByuXRxUVJSAr/88gvnqSdZyMvLg4SEBPDz8/OI7/Hjx8Mbb7wBXl5eEBcXB23atHGDi/qKi4uDRYsWQWpqKuun4cOHw6xZs9iu2Ww2+P333wERoaSkBMaOHVuhftLzfyrSHyKv/fLLL5XmFe37VEeE65FHHoHo6GhIT09X6VnRVtDft27dYlnyRDfiiZCQEPj111/B29sbvv76a3A6nZCdnV2hHNzNLxSLnh6gouVZqnvu3DmoWbMmxMbG6o7lbn68dpyiTIp2qTI2+W9b/t+sDfxb/mgZNGgQulwurFWrFj722GM4ZMgQHDJkCOdKT0hIwM6dO/P3RqMR+/Tpg3a7HV9//XXdNh0OB65evRrNZjOuWbMGHQ4H33URdwMpkJ3FYkFfX1/08/PDjh078l3FWrVqYWJiIh+blyQJo6OjUVEUbNWqFbZp0wY/+ugjPHz4MF6+fBn79++PiqJgYGAgH4mko5YUjIiO/LlcLoyOjsbo6GgMCwvD9957D4cMGYIfffQRLl++HAcMGMB3pVJTU3H27NmYn5+P7du3xwEDBmDPnj1x6tSpePDgQczPz8fevXvz+G/evIlz5sxBRMTCwkLcunUrWiwWzMnJQZvNhnl5eXjs2DFs3rw5TpgwgetT3d27d/P7iIiHDh3Ct956C/v3748GgwGXLVuGDz74INavXx/NZjMeOnQIJ06ciH379sVWrVrhyy+/jB999BH3tWfPHj4CbrFYMC8vz60vq9WKGRkZuGfPHly3bh0OHjwYH3roIQwMDMSsrCy8dOmS7rhoZ+DQoUPc56FDh9BkMmHr1q1RlmXeQbLZbNi9e3ds3749Dhs2DJctW6bCd/v27bFVq1acgzUvL4/bPXz4MDocDhw2bJgbXIiI+fn52LNnT1y3bh3OnTuX4RJ5skOHDijLMu7atUv1m9PpxLy8PNV3+fn5zCtffPEFt0fjtlqtfHTNZrPhpEmT8IcffsBRo0bhvHnzMC0tDdu3b4/r16/n/l9//XXGYX5+PsqyjIcOHeI+iQaHDx9Go9GIX331FQceFE+TiDxGsBcWFqLVasVVq1a5jWfPnj346KOPMj8cPnwYDQYD5uTk4IwZM3Dr1q24a9cu3Lp1Ky5dupR57fvvv8f+/ftj+/btMTk5GT/88EPulz6p7cOHDyMi4uHDh3HAgAHYu3dvXL9+PcuY+NAKd1hYGONGxLF2nIqi4DfffMN8YLPZcOjQodixY0ds1aoVjh8/XtUnIrJ+Iv7ZsGED9u7dm3lQrCv2T8fdJ02axLw8ceJEVftaedfyEX06HA6cPHkynz5ZvXo1Llu2DHNycrBt27Y4fPhwN3yJReR9ROQI2HTl55lnnkGLxYLdu3fH3NxcTElJYZ47fPgw64jZs2fzuGjsVqsV8/Ly0GAw4Pjx47kPi8WCWVlZ2L59e1yxYgV++umnaDAYsFOnTrhixQrmkffeew8nTpyIhYWFaDabsUWLFtigQQM0mUw4adIklR6h92l8oh7RFsITFZK3Xbt24ZYtWzjw36RJkzgl1LRp07Bx48bYvn17HDx4MH766aeoKAred999+OCDD2Lv3r1x9uzZ2KBBA3S5XNi9e3d85ZVXcM+ePfjpp59iixYtMCEhAVu0aOERRqPRqJJVve8MBgN+8sknLEuibbDb7Thw4EDWt/n5+di5c2fs3bs3zpgxA1NSUvD7779X8Srxhqgv33jjDWzatKmbvjQajThp0iSVHPbr1w8bNGiABoOB4dTy7rFjx7BVq1a4bt067N27twouwgHxYe/evfmeaUpKCmZlZWG3bt346D0i4sqVKzEiIkKl+4iG33//PY4aNYr1ENmJPn368FHe1q1bY/v27fGBBx5gmSgsLNTlF2p33bp1brqU9BKNnXBJNCJ6jR8/HpctW6bKU163bl1MSUnBpk2bYk5ODqanp2NOTg7zEeFekiR8+umnUVEUfPrpp7FBgwYYHByM6enp+MADD/A4evbsia+99pquXbp8+TI+99xz+OKLL+Jnn32GDRo0YP4hXnE4HDhhwgSV3hWLw+FgfS/q/vXr12P9+vV1dTP5AYjleoVOpD377LM4bdo01WO1WjEnJ6dCW28wGLBWrVqYmZmJy5cvR6vVil988QWGhYWpdu99fHwwKioK/f39MSoqCtetW4cTJkzgsRB/2mw27NKlCx4+fJj9rgcffFDlT2h1J/ED8ZcI66JFi/DRRx9lX4NO09AJPgrO6+vri76+vjht2jT2QWbNmoWSJHFg1dWrV/N98OjoaAwNDUU/Pz++NgJQHhOBrgQtXbpURe9Ro0bh7t278eOPP2aYly5dirIsY5cuXfDgwYMq+V2/fj0ajUaOffTqq6/i0qVL8aOPPsI9e/bg1q1b8auvvsJGjRqhLMs4evRoPHjwoIpXjEYj7tmzh30GUXe9/PLL6HQ6sVatWvjwww9jt27dUFEUjIqKwvj4eNalokxS0dooq9XKY6drR5MmTUKLxYIdO3bEhIQEzMzMZLtEspqTk4NRUVH4yiuv4EcffYQzZszAnJwcbNSoEcbFxWGdOnXc7Fvv3r3ZLxH1wdKlS9FoNGK3bt3ccGk2m3H8+PE4ceJEXR4iucnIyMD27durfP7evXvjRx99pPKtRb1CMqXnT/6Tyr+T9r95ycnJ0X0oeAgpW/Eoe506dTgdip4DK0YzNZvNqqBv2qOS9L+Ye9xut6O3tzfm5OSgt7c3ent7e0yHRMGCtEd3qB2n0+kWjZPGs2bNGmzevDkajUY+3kRKXIwySQ/1IeaWpnuakiQxLs6dO4eyLOPRo0fd0lEBlN8TEu8IUdCWkJAQ1R2x2NhYDAwM9Hi8lL6nKMrivSQa84QJE9zef+SRR1RHG7Xt0thEnBuNRsYJ3T0lGJKSklTB/KZOneqGbwpm5uXlpfqejp+npqa6HT+lu7gUWI8WfOj+KsHlcrnc0pwBlN91ysvL40UT+t5kMmF8fDympqbyUcbExEQVD+/du9dtDLQYpEeLilLEtW7dmsdG8QEoIFhsbCxGRUWpHBtPd64WLFjA8BGPORwOXLdunYrPZFnG1q1bI2K5Ey1eWXjjjTf+1P1dCiD5888/q8ZtNpuxWbNm6Ofnh8HBwVijRg1UFAU7duzIC359+/bFxMREPib78MMPc1AgGnNwcDDGx8djr169MDo6Gjt06MBjokBzenA5HA6sV68eyrKMw4YN4+NvdDdcvENdr149jIiIQEmSVEH7tMe6RV6uX78+X7V5//33UZZlN13qcDiwT58+aDQamd/Fh+RJjIXh7e2tapsWBZo1a8YTJEVRONBQRXpAjx+1v4l5c+mOIPVDx4b1gsppZZP+17tHrJc3PTExERVFwdmzZ3MUej3eACi/ejBkyBDs1auXrv68m7xpHzpqXdl3OnbsyHLat29f1tVeXl6Ynp6Ofn5+bt/p3ckm2yDyFtFj7dq1rH/F60risW+DweB25YVoV61aNd3j+oqiYPPmzVFRFNWd5mbNmuGQIUM4WFN+fj526NCBA2TpwbVlyxbGmzZoGAWgFeH+4IMP3Pht6tSpujSk+CIV0SEtLY35X5IkLCwsxC5dumDHjh0xLi5OdSQZoPyOe3p6OufZpnYiIiLcArOKKQAry0fUZmX5iOpr74oHBATgF198gUePHlUFh/P0PukyWZZZ72v1ztatW7Fz585oMBhw69at2KxZMzfdHBAQwLoGAHjxgiaeAHfSBNICqxjXoiJbT/pZbxxaHO/bt4/jsNBvDRs2xLNnz+LevXtV9S0WC2ef0PoTTqcTvb29+fqLKCsJCQn42WefcYwMsX/akBJp6e/vj9HR0ehyudDlcrGNTExMdEs7Sf34+flx7Byz2YyKoqgCe4qPv78/Nm/e3I3eerqyMr9VhF966BoOXcGkO/9kf6pUqYJDhgypVD9iSj1FUXD+/Plso+42dm0qSvHR5p0H0M9EIo5Vksojx4t+TEJCgq4sSVJ54EnxihTBM3HiRJVMKIqCEydOVPEL8V7Tpk3ZTyc7/tFHH2FAQAA2bdpUFV1eXET7J5Z/J+3/0NKuXTts3bo1XrhwAY8fP46tW7fGmJgYXmGiSfvevXvdjIgsy9iyZUu0WCx8T6VFixZosVgwNjZWFVTJx8dHFXHx+eefx2bNmunCQzl6yZg5nU5s0qSJKmgbGQ66VyhG7fT19cXdu3fj6tWrVbnQ6b4XKTQSSlLOYiARgPIdwtDQULz//vuxWrVq7LCNHTsWJUnCOXPmIEB5UK64uDjdBQA9pSs68uL3JpNJlS6LFBEtopDCaN26NWZmZmJaWhovMBgMBoyLi9OdqNG9Nk/GgsaVkZGBsbGx+Oyzz3KdqlWr4rBhw/D48ePo7e2NXl5eePr0ab5PDFC+mCDeHaKHaETKMTs7G318fDA+Ph6rVKnCEfdlWUabzaZKYQRwJ4J39erV2XmmyUNsbCz27dsXc3Jy2Jho+3/66aexa9eu2K5dO8bRAw88gF9//TU/FOGaaFK9enXd9Df0yLLM6UnIeFDkby3OAcAtmqz4iM4l4SIyMhKtViuePn0aEdWT9mbNmmHr1q1Vzh1AeRq3unXr4uDBg/keFjm6VCcyMpIDH1KfxGvEVyQHDoeDJ0Ba+Cn90qOPPsowUPTy1NRUbNSoEU9OiCaZmZnMp5999plq7HqOsZeXl8oxpOBOqamp6HQ6eUFIG/grJSWFHRhFUTAvLw8lSVIFaUxPT1dF66d7cOSw0f3njh07Ynx8vMdJO42dcKjNq+xwOLBx48Yc0TcmJoZ1KOk+WjAi3RkVFaUKiqgnyxEREYxv0q2RkZGYk5OjgkGPfzMzM1U53vPy8jAjI4P5juhP6SAff/xxdtDotJQ4gbTb7XyHUeyndevWaDQaVVHSU1JSMCcnh6MW0xMeHo4WiwVjYmJ498rTo6W3p8kgjT0iIoJjQpB+q1q1KvO20+nkgGxauPTyytN46X+bzYZms5mzRYh1KR2nOBEgPUQLjzTJrVGjBvdHUa21uoR2qEU9ROMXA64ZDAb09/dn+dI6oDReMYaHuNBOAV7FfiIiIjiAWt++fVFRFPT390dJklRpz5o0aYKtWrVSBbkT7ZYePU0mE4aGhqrstDa+CP0vLnhSIDStA280Gt3e9/R4CrhW0f8ED+0wauvp6bO4uDhVlHWijbe3N1osFg60J/oH4qSdbJXFYlFlnqC/mzVrxjuzAOWBN0mPKYqC1atXx6+//hpHjhzJNnXMmDEoSRK3nZWVxfqkIltPwV99fHw4Y0FERAQaDAbGuzhBJtl6++23GRdeXl4c0Z3wOHToUOZ78c5zRTQTcU4ZfSj9Zdu2bdnnpLvnBoMB69Wrh4jlqY7pJBPJB9kcMbME7bSHh4fjgAED3BYhPKUIpja0ekRPFrSLBKLsiSn9nE6nKs2vl5cXulwu1j2EP714B2KQ0oCAAL4rLknlmZ3ohGx4eDjbp+eff54XeCm+lTh2Txsb9CQlJfG9fPqO7DPBSjJN/pPT6eQ4E9r2HnroIc5A4WnxVG+jCKDcFlAmFYpNJdobggcRsW7dupidnY3NmjXjYNc0d3E4HGg0GrF+/fr/Ttr/Lf9vyvHjx3HVqlVYWFiIiIiBgYH4008/4cyZM3Hs2LG4YMECbNGiBQIAjh8/np2eKVOmuDmwosLRfmofg8GAS5YswZUrV2JhYSHu378fvby88Ouvv1b17XQ60WAw8CdAecoXf39/lUEkBVSvXj0EAFWOaZrYKYqCaWlp7PRro1vfy+r7X/FQSiRSJpQaTXSWN27cyHBZrVbs1q0bRkZGqozVTz/9hC6XC5cvX85XAgDu5J/8ow9FypwzZw7DQMGDEMvTrxEtRGe4R48eKEl3Un3R9+S8UVCPqlWr8gSUJh6VefToRHCVlZXxVYqgoCAVnrZu3erxlIH2IRwGBQWh3W5nJ0u762symdjAvP/++3+Kj0pLS5kvmzVrhg6HA5cvX84nSgYOHIhPP/00AtxxRvv27eu2ou10OtFkMrFB13MmaUdYNFTahQbiRzF6K/VBO8DalC+SJOH06dN58iL2SfIaFxfHkyySV+2JF+IVf39/bNKkiWoM69evR4DyEwiV5RNJkvC9997Dnj17qtIvDhw4UDfvs7YN0YFGvOM4kxNIzgzxGzmL9DidThw4cCCn/DEajTwB7tevH9psNnagR44ciZJUHuSM5MNms6mcL3IolyxZgvv371c5TMePH0dEVKVeTE1NxQsXLqgcwRdffJFTUAGU562mBRCHw8FjoVMJ69evx19//VWFm969e6vGKe6giOkrDQYD867ZbMagoCCeNIh0ot0wSlFWUSRsmgRQbmTxN3L+KG87AODs2bNV8j9lyhQcOXKkapJLdBQnVQDlEx+KaE1PZfTIH3kq0h/0W926dZmP/ldw/BG4xbR+wcHB6Ofnhxs3blTVIb2ifapUqcKTQa0uuhueaGHvtddeU20O+Pr68iRYzIhhNBrx6NGjqnYSEhLc5J0WN0QfQrsgTDJEOlFc5CW5rIxNCAoKwm7duvE74oSOZKdTp06VpkefPn0q3beIU7E+6Tuy9bSILGaN8fPzw6+++gpluTwbzYkTJzgtpCd63QtMpFMoxSbJIS220gknWZaxefPmKEl30vJ99913CAC4c+dONBgM+N1336nw6u3tjUeOHME6deqgj48P9u3bFyVJUl2lOHjwIAIArlq1Cu12O9ssSSoPhkf8RRs/4gRTe3qJdCpN7mnxk34nuw9QnpKOvlcUBR0OBx47dgytVivjdu7cuSpaWa1WTmlLk9YJEya44TwnJ4fxIMsy+8QEz+TJk5m+06dPRy8vL5w+fTrDdvz4cZw4cSIvctPGgN7uvXgiRkwhDXDHzn/44YcIcGfjgBa3vby88KefflKdmKMUzmFhYShJ5elw9RY6Ro4cyZP5P+KTSdKdNMPLly9nX9BgMHDwTQoaS8Eg/520/1v+Z+XixYvsDMuyzMxmMBhUxk2rxMXv9Sbtfn5+fMcDoNyprGg1UZIk7NOnD546deqejVFlH1qtI6W0bds2VoRUh2CmyLkk/LRg4Ql28fvKOE/aHbi7PZSnGaB89e/EiRP4xBNPqPo+dOgQulwu3Lx5M1osFlas4tUBcvK7deuGsiyzwavM7oL4LFy4EM+cOYOI5crsxIkT96wMTSZTpY+A3Q0uakeEKzAwELt27aq6zgBQbgBsNhuv8lfE3xU9xDdkkGnxhQzdkiVL+Cgw0a5+/fooSRLu2bMHAcoN8o4dO1Q8QzI0duxYDAoKQofDwUdV/18sKNE4aHyiQ/Bn6XSvz+zZsxGgfJc2IiJCtUBHOKFPm83Gu5bE519//TUiIuObaHGvsJGeO3XqFKcSRMRKL/780UeWZdyxYwdK0p30cqJDQnz/xRdf4KlTp9BisfDYH330USwqKlLp1LCwMN2sCOIYPOFm3bp1CFA+6SGck2NKx2QJNvFkUmV3OMWHTnUdOnQInU4nHjp0yC3rBMEsLoBoJ4I//fQTGo1G1eSPJmBiqq+/kmaHDh3C0NBQ9PX15QkG9fFH+pIkyQ3myvLO3erQJIvk48033+Tf5s2bhwCAx44dQ4PBwJOAysJMfNStWzeUJAnnzp3LEwqRd/Xeuxc8UZ70yj7vvvuuijfJdpFusdvtDCPhm/AiHgHWwkhpJQlv4qSNeHfatGkYFBTEO8DiSYyvvvqK8RUeHs6T//+lzvfk0yGWxzsym828sCraevI9CD92ux0dDgcvXBgMBty1axdfXxPbf+WVV7gO6ZElS5b8IRuspYMnn2z+/PkIABxr5JFHHnE7IaQoCs6cOZMzEElSeQyloUOHoiyXp00FKM9frz05URHcsixzzACyraQfaVGXeJ5OQYjHzcWFWJq0nzhxAp1OJ3br1k3VHgBwOrm74VKcjHriab0xiu2eOHECERF37Nihgk+Ube0JMUqnTLZdlBla+CB/m3wpo9HIdkz0SyRJwh49eiBAeawB8UqIKIN30ydk2wEAly5dyvSgeQDhSfSt7XY7z5do0k6LFv/kSfs/NHze//+UIUOGgKIokJ2dDWazGR566CE4fvw42Gw2uHz5MgQFBYHFYoHDhw9D48aNoV+/fuDt7Q02mw1kWYbt27dDWVkZHD9+HIqLiyE3NxdCQkIgNjYWSktLAQDAarXC7NmzITExkSOB2mw2AACoUqUKxMXFgdlshvnz58N3330HAABms5kjodarV4+jOZpMJujUqRMAAKxbtw5CQ0PBy8uLo+BSu7Vr13Yba+PGjcFsNnPk0W3btrnVeeSRRyAyMhIWL14M+N/EB5IkwerVqzn6ZkhICNSrVw82b94MMTExsGfPHgAA6NevH48XACA0NBTmzp0LmZmZHFmX4IyLi+M+KarrqFGjAKA88qUsy9wuAECfPn0AEcFgMEB4eDgcP34cpkyZooJ95cqVEB0dDTt27ICQkBAAAIiPj4fk5GSOZHn//feDyWSCli1bQmRkJOzbtw8AAIqKirgdi8UCkiRx/15eXm54mjt3LowYMQIAAKKjo+H48eMQGhoK8fHxjKePPvoIAACmTp0KYWFhjJdx48YBAICPjw8sXrwYAACmTZsGGRkZMGrUKLDZbGAwGMBoNIKfnx+8+eab3K8Il7e3N0dADQsLc4Pr5s2b8MILL0CvXr2YlgDAUdg3bNgAAAAGgwHatm0LZWVlEBoaCkuWLIG9e/cybeT/RhWvVasWpKamAgCALMvM30ajEXx9fZmfRo8eDQDlkcD79u0LTqcTysrKAADg+++/B0SEvLw8Hk9mZibUqFGD4Ttw4AAAlEd4vnLlCty6dQv27t0LiqLA4sWLwW63g91uB1mWwel0QnJyMsydOxcGDRoEAMC8tmTJEvDz81NFmH3sscdUdUaNGgUmkwlefvllrkPjIL4cMGAAAABkZWVxHYq4SnCIvCJJEsiyDJs3bwZFUWDbtm0QEhLCPEh9m0wmyMzMBIvFAt98842qnUaNGgEAwBNPPAEAAA888AC0bt0aSkpKGAaSyZKSErDZbFBaWgoPPvigKhrspUuXGM9U3n33XSgrK4MtW7aAyWQCWZbBYDDAtGnTuM6gQYPAaDSC3W4HSZJg9+7dAACQn58P/v7+zE8hISGwaNEiCA0NBYvFAnl5eeB0OiEpKQkAAAIDA0Esy5YtY/rR73v27AFZlmHLli0qffL2228DAEBmZib88MMPYLFY4NatW8x33t7eIMsyeHl5wcyZMyE/Px9CQkJg5syZYDQa4dSpU5CRkQGbNm3i/t955x24cOEC3Lp1CwwGAyiKAlarFXx8fCAiIgIAAE6cOAGZmZnQr18/iI6OZrldtGgRmEwmyMjIgAceeAAAAAYPHgwAd3i+cePGAABQrVo1FS6J3pIkMc+cOnUKzGYzPPzww1C1alWmkSRJ8MUXX0BpaSkMHToUEhISYOfOnSBJEvOWLMssU6RnrFYrbN++XUVrg8EAu3fvhuzsbP6OdF27du0AAKB9+/ZgtVrhlVdegZCQEJAkie0I/U+RjHNychhW0j2BgYGQlJTE/L1z506oVasW+Pn5sVwTrIRLkkOAOzaBoip37doVAABGjBjBvBwYGAiSJMEbb7wBAOX6UpZlGDhwIJhMJjCZTCxjbdu2BQBQ2S+LxQJjxoxhuSJbdfjwYVVk6SNHjjBc/fv3BwCAvLw8sFgs8NVXXzFOqbz++usAAFC9enXw9vZmfmjTpg0gItuagIAA1iNjxoyB6tWrg6+vL2jLlClTQJZlyM7OBkVRVDrn0KFDgIgsH6SLe/XqxXXmz58PZrOZecVoNMKSJUuguLiYZe7VV1/lMZSWlsLatWtVMCAivPjii2A0GmHgwIEgSRKEhoaqdBhAOU0NBgPIsgxRUVFQWFgIDocDSktLQZIkCAoKYj6RZZn1w9WrVzkrz7Vr17i9w4cPAwBAy5Yt4f7774fly5er6AgAPIYlS5bAAw88AGPGjAGXywWvvPIK1yGd+c477wAAMD+MGjUKAgICQJIkePTRR8Fut0NeXh7ExMQw7xF/AgBHp2/YsCHDQLb+7bffZv0BAIyjHj16AABASUkJXLt2DSRJgpSUFJVMvvTSSzyuNm3aAEC5rQwJCVHZehrnwoULAeCOPpw6dSpIksS+w7vvvguSJIGPjw/8/PPPAACwefNmkCSJ3+nbty9IkgSRkZGwbds22LhxIxiNRpY9Pz8/sFgsULVqVfj1119hxowZzL87d+6EsrIymDlzJgAAXL9+HUpKSsBisYDdbgeLxQInTpwARGS/zmKxsP309/eHdevWsU2kNgDKdS0AgMPhYB2xd+9e6N27N9fVRmoPDQ2F48ePQ7Vq1aBly5bQtWtX+P333/n3AQMGsJ4EANi/f79Kh1GGCUSE4uJitscRERFgNBo5S0iXLl0gJSUFzGYzhIeHs7+7efNmCA0NBYDyDA8AwD4MtUk2CuAOH1Jp0KABAAA888wzDBPpoypVqgBAuZ4FuGNXfHx84OTJkwBQPmeRZZnH2b9/f5BlGbp27QqRkZEAcEffLl26FOx2O/O1yIfdu3cHWZa57/z8fDCZTFBQUABYvuEMc+fOVfE++daSJMGXX37J/VG7pKf/yeXfSfvfvKxZswZef/11OHr0KEiSBEePHgWAcqVbUlICtWvXhtLSUjAajfDTTz9Bx44d4dq1a/DAAw9AWVkZ/PrrrwAAUFxcDC1atIA9e/bAgAEDoGPHjjBkyBAICgqCWbNmwbZt21gAJEmCpk2bAgDA8OHD4ddffwVFUeDmzZuwZcsWnlSHh4dDaWkpjBgxgoVQ7PO3336DWrVqQXp6OgvLI488AgAASUlJbLSpnD59Gk6fPs0CTJNkk8kE6enpAFDuyBkMBrBarWAwGCAqKgpatWoFiqJAUFAQPPzww9CmTRvYtWsXrFy5Epo0aQJxcXEwffp0diLIYb3vvvtg/vz50L59eygtLVUtZHh5eXFKp/vuuw8AACZNmgSSJEH37t1VjpTD4QBfX19ARCgtLYWioiLIz8/nNEOkOJYuXQqPP/447NixA5o0aQLvvfcedO/eHcxmMzvZt27dguTkZJg/fz7MnTuX6SDLMuMqMTERAMoXFtLT06FatWpgNBpVztr58+dhy5YtAADw+OOPQ2lpKdSqVQsefPBBleKUZRnWrl0LLVq04He9vb0BACA5ORmsVivYbDa4ePEidOjQAebPnw+NGzcGRISaNWtClSpV2JEkI0RwJSQk8LhatWoF4eHhKriqVasGO3fuZAeDCk2AV65cyd/9+OOPAABQq1Yt2LVrF8TFxYHBYIDS0lJW2h07dmSnqaysjOmDiNC7d292fCg9WXZ2NqxcuRK6dOnC/bds2RIAAAYOHMg8CVDuaJlMJhg4cCA0bdoUJEmCNWvWQGhoKJSUlMD27dshLCwMdu3aBU2aNIFq1aqxYSE+69u3L8MGUO4IjR8/nh11SZLYSaTJ7/z58yE5ORlWrVrFuKBx0IST/hfTAGVmZgJA+eRa5NWwsDDGF+E3MDAQMjIymH40aUJEaN++PRQXF7ulTmrWrBkAlOsVGtOMGTNUTjPJy9q1a6Fx48YQGhoKixcvhi5dukDv3r0BADjtD8kowJ1FkZUrV0JycjJIkgQJCQkwcuRI7j89PR3MZjNP7Ai+lStXQtOmTWHjxo0qfqlVqxbLNiJCixYtQJIkqF+/PmgL0Q8AOAUStd2kSROGoaysjHFZu3ZtTiNDTlfNmjUBAKBz585w4MABfv/o0aOQmZkJQ4YMgREjRsATTzzBTtyJEydgzpw5jMeysjLIysqCmJgYuHjxIsPYvn17WL9+PeTm5vJ3y5Ytg4yMDBgwYAB0794dAMrlRpZl5gen0wk1atQAl8vFuH/ggQfAZrNBYmIihIeHM+/m5+dDaGgozJkzBx599FEeKyJCZmYmPP/88/DTTz/BmTNn4P3332fH02g0qvRJ69atAeDOJFyU9Z07d0JSUhLUqFGD9Ruld/ryyy8ZZgCAFStWQGBgIERERHA60erVqwMiskw1aNCAYSV4e/fuDadOneI68+fPh2HDhsFjjz0GLVu2hH79+jFNie4tW7aElStXQnZ2NsP1wgsvAEC5TG3atAnuv/9+5o24uDiw2+0QFhYG2dnZcPHiRXjyySdh1apVkJGRwSnRgoKC2J5QCiREhNq1a0N2djaMHDkSBgwYwLZqy5YtsHHjRpYPgqtKlSrQsGFDACif2G7btg327NkDQ4YM4Ymq2WyGHTt2gKIoUFBQADdv3oRdu3bBpk2bYP369QAAbGsGDx7Mi10jRoyAp556CmbOnKla3CFeue++++Do0aMgy7JqMXnnzp0AcMdBJl1cWFjIdQ4dOgRTp06FlJQUtpdVq1YFg8HAC7viwnKrVq1gxIgRjGcfHx8IDAyEnTt3QmZmJhQUFEC7du1gz5490KpVK6hVqxanbqSCiOx3xMbGwjfffANmsxmSkpI4zWVQUBA0btwYIiIiICQkBPLz88HHx4dhIlr069cP5s+fDzNmzODvRX4mfO3atQuGDRsG2dnZ0KhRI7YjAHdsSlBQkIoW9evX54lVYGAg4/bGjRvw7LPPwqZNmxgPAOV+QElJCUiSxPqObD0AqPQjIsKtW7fAaDRCRkYGw1JWVsYTVCrkc0iSBN26dQOAcltZq1YtOHfuHE/KaJwtWrSAIUOGsHytXbsWfHx84OzZswAAUFBQwGnX8vPzQZIkOHv2LPj6+vI7ZAMNBgMkJSXBhQsXoLS0lH/PysoCSZLg5s2bIEkSj2HgwIG8iC3yIsmkODkFuGPfc3Nz2XZFRkZCZmYmjB49mifIhDeaiFJdRISkpCT44IMP2J6LE/LS0lLo2rUrlJaWQvv27WH+/Pkq2w9QvmARERHBMk7+RMeOHXkcxL8ZGRlQVFQEsixD7969QZIk6NOnD8iyDCaTiVOqkS/TpEkTWLlyJW+KieN/6KGHQJIkaNOmDdy+fZu/v379OphMJvYjduzYAf7+/uByuZjXiD5hYWEQHBwML7/8MkiSxL5USkoKrF27lhfQ09PTWZ+sXLkS0tPTwel0Mk/QppUkSSp7S4tLAABpaWkQFBQEqamp3E5GRgYEBQXBypUrYePGjdCiRQte9BZ9a0SEhIQEVbq+kpISqFu3rmqR7R9Z/pL9+n/L/6zQ/ZjBgwej0WjE3r174/Dhw9Fms6GXlxdu2bKFj4wPHjwYH374YZQkCY8dO4b+/v64d+9e7NSpEw4cOBD9/f2xV69eOHz4cI/90NEZOjZP963NZjOaTCYcPnw4ms1mtNlsiFh+THjt2rWcOsjLywuvX7+OM2fORF9fX9yyZQuuXLnSra8tW7bwMdZPP/0UZVnGRx99FH19ffkuFgX+ad68uRu8TzzxBBqNRj7+43A48PPPP8e5c+fiyZMn0Ww244kTJ1BRFNy9ezenpZo6dSrOnTsXS0tLua2CggI8deoUjh8/Hhs2bIjr16/HgoIC3LRpEw4aNAiXLVuGBQUF+NBDD6EkSXjy5ElUFAW3b9+OPXr0wK5du2JpaSkWFBTgkiVL0M/PD7ds2YKlpaXYsWNHfOONN7BTp044efJkLCgowNOnT2NpaSkWFRWhoii4du1aLC0txQkTJmDLli0ZJmqztLQU8/PzccCAAQgAuHz5cv7e5XLh1q1bsWfPnmg0GlFRFJw0aRKnyLl16xYqioL79+9nWmzZsgXnzp2LJSUlnMKjtLQU9+/fj7Is4zfffIMbNmxARMTnnnsOAcqj3Is4y8/Px5KSEly4cCF+9dVXuGDBAjx16hSWlJQgYvlRpY0bNzIcNE6izcmTJ1GSJKxfvz6353K5cMOGDXxUimIZvPnmm2g2m7GoqAhlWcYZM2Yw7pYsWcL0Ki0txevXr+OmTZtw+/btuGDBAu63pKTEDacFBQWMn9WrV6vqfP/99yhJEr7wwgtcl8b3/fffoyzL2KlTJ+zTpw927NgRJ02ahLIs44QJE3DTpk3MY3l5eQzDpUuXUJIkHDt2LE6ZMkUlF1u2bMFRo0YxLg8dOqRK3XL9+nVcuXIlLliwQEUH4hXqc9OmTdi5c2ds0aKFitcOHDiAkiThuHHj+PiboiiYnp6O06dPxy1btqDZbMYxY8bg1KlTMSsrC1NTU5k2Fy9eZN7o27cv3nfffdivXz9s3LgxLlmyBK9fv46IiJ06deJsDT179kRJkphWY8aMYVkivBPvEz9kZmaiLMv8PfW/ceNGnDZtGs6fP595Nz8/n1POLV68GGVZxpUrV7LM03HGV155hfFD79Hn1atX8ZlnnsHHH38cly1bxrQQ5eTSpUsoyzKuWLECFUXB7777zk1OiOe3bNmCp06dQrPZjHv37mX6i7K4b98+lYwTP/Xs2ZPpdvz4cVQUBV988UVctWoVzp07lwMqlZSUsA7av38/HjlyBJs1a8a8SoV0jijjIs+88847+PHHH+OwYcNYxjdt2sR8+cQTT2CfPn3w5MmTHEDt+eefR1mWcf/+/dzW/PnzMSAgAGVZxnXr1uHPP/+MJSUluH37dly0aBHzBo13x44d+MEHH+DYsWOxcePGLF+ky0pLS9Fut3P8hTfffBONRiPDRfRZuHAhvv/++/jFF1/gO++8g5MmTcKVK1fi9evXccGCBWxX9u3bhwUFBfj555/jypUrGQ6t/t+4cSPLLdVZuHAh2mw23Lp1Kx4+fBitVit+++23WFpaisePH0eA8owPpaWlOGPGDFy2bBnzjVZ/Dx8+HLt27YrXrl3DF198kfU4yY+ol65du4YLFizwaCtefvlllhOqY7FY8Pjx45wOs3bt2lhaWoqrVq1Cl8uFDz/8MPNI9+7d8YknnlDxkR5eRLt25MgRPHXqFMvSmDFj0MvLi2038e7hw4dxw4YNrItJtgFAhf+CggKcOXMmj2vKlCn4/PPPY0lJCe7YsYN5h/5+7LHHsE+fPjhhwgRO06Wn059//nls06YNLlq0CDdv3sztiDxPn/QO4ZB4nmRN5HPqj+qSfOXl5aEsy9ivXz9cvnw5Lly4EOfMmcNtb9q0CRcvXowrV67ElJQU7NWrF27atInbJFoUFBTgqlWrOGXaww8/jG+++aaK5+x2O+s5spMEo5ZHCC5ZlpkHRPk6duwY1q5dm4MY2mw25oVBgwZho0aNWDcrioIff/wx8zXpZPqf6nTo0AE/+ugjfOedd3DhwoU4ffp0lb/13HPPqe43b9++XYULGkPNmjVx3LhxaLVa0WKxoKIoHMg1IyMDd+/ejU6nE0tKStDpdOLbb7+NiqJwQNCaNWviI488wpmHvvvuOywtLeVxlZSU4KZNm7Bp06Z43333qej72WefsT574IEHUJIkFT9q5YP09+zZs3HRokV49OhR5hGqQ/ghX0TkEWr7wIEDqCgKzps3j6+qjBgxgo+8Hzx4EO12Ox4/fhy//PJLfOutt9DlcrGNIT+XbCD5gVpbKurmIUOGYIsWLTA/Px9PnTrFML/yyivYuHFjlgNxLIjItl2rM5KSkjAuLs7j2MX29PQlwUdy3LVrV9YnxBvE76JdIttMYxXbof/JLml/+6eVfyftf/PSsmVLHD16NA4aNIjvxlBQG5PJhOnp6SjLMvbp0wdTUlI4DU1KSgqmpaVhRkYGR9v08/NDHx8fzqtes2ZNTE9PxyFDhmB0dDRmZWVhy5Yt0Wg0sqCJQX1CQ0PR5XKhwWBAb29vHDJkCAKUR+6mgEAulwv79euHVatWxbi4OE4XJApHy5Yt0WQyYaNGjRAAcNOmTTyJiIiIQADgQCGyLGP79u25ncGDB+OQIUM4YjwFmiBlJgZkczgcGBERgXv37lVF1qc8jSS0enkb9erQXRin04kRERG4evVq1ftk0J9++mk0mUyYl5eHL7/8MqfPobtnlPanQ4cO6Ofnh0aj0WP/WtjE77/99lsMCAhAm83GtKD0fXRf/umnn0Y/Pz/cu3evRx4T+xDxRGOPjIx0+64iOAsKChguomdISAjabDacMmUKhoeHMw5FuAICAnD37t0cNIUWo9asWYPh4eFYUFDA0bwJVvpbSy8qkZGRzCNaWOlTkiSesIm/RUREuPEM1RF/IxpbrVY0GAw4ZswYngBPmzZNhVMRZq3DqUcPbR0tr4nf6X1qeVakY0xMDE6ePBntdjun0OrVqxc2a9YM7XY7Ll++XAWXHm9oP00mE7pcLuzYsSOaTCYcM2YMvvjii+jn54ePP/64Cl6tTGpllRxVPbxQoXEQr9Hn6tWrMSYmBiVJ4pznlSme8E3tiG1rceHn54c7d+5ERHVuZoo9cjde0/Kyns4ScRESEsK8TTniW7RogcOHD8epU6eyo5uSksK0oNzOlONYry/t2Am+4OBglk/SfVTXbrfjzJkzVU6tFqee+JI+KQI7LRjT31arFYODg3XlRNuOln6SJOHs2bM9ypBW/+vJEMFF9yTpruRnn32GiqKo8k7rjbUi/a0Hlx6eRD7XyjPVURQFX3jhBeY/gpMmKi+99BLzSNOmTTmausViwXr16ql0lid508JIdBfpIMJM4xN5Rhy7Vi+J/Yh19HBYUFBQoe7T4rmyelLPxuv5AaKu8/HxQaPRyLqf7L8WdrIVrVq1wueeew6nTp2KTZo0YVo8++yz+OKLL+LUqVOxVatWaLFY0M/Pjxc9zWYzent782TUZDKxDkBU62j6PywsDPfu3cs2me6Nk2xZLBa02+1osVjQ5XJhnTp10G636+rmivhZW8eTvIn6Wotf4hWz2Yx2ux1DQkLQYDDwvW66p9+zZ0/ezBH9BtLRs2fP5rgHZrOZI4fb7XbW0Xp6qiK+rsjuan0FT/wk6vi71SGbk5KSgt26dcNr166xv4yIqoUV8iv0bKGeLdUrf0aWRPtPOoZsjsizer5iRTKupwNFPUKpYYnuenrEk+2v6Le/c/l30v43L/v378fAwED09fXlYEdihEYK5EArg0ajEYOCgnh3R5LUeWXpPZpEms1mDA8P54iRFHGTAk6Ij8vlQpvNxjnbKbiGGPiCHByj0YhZWVkc/VIUjv3796MkSRztmgKxicFDKHJxZmYm56ZXFAWzsrKwcePG6HA4sEuXLtiuXTssKipiZWaz2TjXtN1ux4kTJ2KrVq1w2rRpqCgK7tq1y01Z6gWm0KtDTpDD4cCJEyfqtudwOLBnz54IUJ46w+l0qgwOjY9WhSng3a5du3T718Imfk84UIScv9SXGNjDx8cHW7VqhZcuXdLlMbGPWbNm8bho7JSaTfyuIjidTifDNX78eAQAHDRoEO989urVi3EowvXoo49iu3bt8L333uMxLF++HNPS0vDpp59Gp9OpemfWrFn8t5ZeVMxmM+bk5KjqaD891dGjMY1Z/I1y5oqLW5JUnnImJiZGhVMRZk+OvRaXerwqGrOKPj3xLOFSURS0Wq3YpUsXlGUZ4+LisEePHvjTTz+5waXHG3oLIOHh4RgdHc1/S5LEAZ1EXIrtifxAsioGktHihYo4jjFjxrh9kq7Typen4gnfJAPaPkRcGI1GbNasGRYVFaHD4cCTJ0/i6dOnMTIyEiVJwl27dlXIa1pe1uJHiwuxLS2+KaUW6RmRLlRXHJ8ebbXwSZKE9erVU+nSinSoFqee+JI+SWccOXIEAcqDkG3duhVlWcZevXrpyom2HS399HRXRfpfT4YILpvNxpMZgis7O5vb9zTWivS3Hhx6eBL5XJQXcdHAarWi3W7HAQMGoMViUU1UbDabijfIhmvtEuksT/J2LzpHpIUWdk96Vuznbjh0Op26fKT9vFc96UlfauuKMkV2nHS/Vr6oiPKnlVPCv0gj8u0AgAO2iunESCbJhopyTP/XrFkTmzVrhg899BDLF+knm82GVatWxcTERMzMzMSQkBAMDQ3FrVu36uonTzpZr44neSMY9XSoyCtLlizB+++/XxUckdKSWq1WnnyLfgMtXDVu3Bjj4+NRkiRMTk5GSZKwbdu2qqw6enrqbvzkye5q+dsTP4k6/m51SHfNmjULAQC7d+/utrBOsk9+BelmrZ3S0k2vVEZOKsILyYTWDnmy/3r6Ug+Wu+lAsvEiP2nbqWi8/7Ty76T9H1CuXLmC48ePx86dO2PLli1x1KhRePbsWY/f0yTX29ubH9EwOJ1O9Pb25no5OTnYuHFjbq9du3ZYtWpVrF69uipnrySVp2ZJSkrC5ORkTglRr149bNSoET7wwAMqOKjoCYfdbsdnnnkGFUVhI1a3bl1OkaUnTFrnau/evdi0aVMeH8FTu3Zt3hGpUaMGOhwOt8iaFFWV8mxXxjkRlSylqKAUatrc5bTAoF1w0CpQOgVhMpkwPj4e09LSMC0tDWVZxsTExLsqs71796KiKDxZ18uTKTpllOKL+klLS1P1IcJD4xLboe9EOPUcX4JLLyoorcaSspUkCePj4zE5ORmdTqcu/GJaMnHBSYw0TmneCD5ERFmW0W63o9lsVtFJpLunOmL+V3Hc2t+Ibp7wRLCbTKZKwXy3SURFjua98KwY6Zquqoi01fKeHm9ocekJdj15EWlK8Gj5hfK70k5UYmKim5xWNl0M9UPtEb7vJvfEIxX1IUZpVv4bXZii6VN0YeJ7PfrTp8iDWvxo5U7kW8pNL9JEjxaexnk32url19XqF5GH70WX0qdWl4mL1Pv379cdw91kgOj2R3hWCxfZUBEuSkNHeqAiGujp779afqtWrYp+fn4cVZkmKhVNgEXaxsTEuNmgysjH3calhV3Ek54uJf7+q3H4Z2AWbbwWLq38aPlATybuBpc4VpvNhl26dMHMzEy3vOB6dl609XeT29q1a/MJmdTUVHQ4HLq2kGRJj0cIXw6Hg+t4kgXClSefTMsPNWrUcMtsRIsXdFJAz2/Q6mZP+uleaPJH+FuLH8Lt3epo6UQ4MJvN6OPjo5JroltFNlBr+7S4+KOy/Udl6V783MroQD1bXxm79E8r/wai+wcULy8vGDVqFCxYsACmT58ODRo0gEuXLsEPP/wAQ4YMgQULFsDy5cth/PjxEBISAh988AE8//zzcPbsWfjPf/4Dly9fBofDAWvWrAGLxQI//PAD/PjjjzB8+HBYsWIFbNy4EdavX8/9LF68GI4dOwaHDh2CzZs3g8lkAqPRCE899RQ89dRT0LhxY0hOToY+ffqAyWSCOXPmwKZNm2Dp0qUMHwUzQw9BHyRJgocffhgsFgssWbIEbDYbzJgxgyMY//7773Dt2jXYs2cPLFq0CG7evOnWntPphLVr13JgmZ49e4LFYoH58+erAmY9++yz0KhRI1AUBWrXrg2KokBKSgooigJNmzZVBZKpbGnWrBmYTCZ4/PHHwWg0cjuKokC/fv3AarXCvHnzYOPGjbBx40awWCwwfvx4MJvNUFZWxoHG2rVrx+10794d2rZtC23btgWDwcABYSoqTqcTrFYrfPDBB2A2myEzM1M1TlmWITQ0FKKjoyE6Ohrq1q0LWVlZ3A9FrqUiwkPjonZq167N34lwVgRXhw4dQFEUiIiI4KjSaWlpoCgKhIaGQsOGDaFRo0bQvXt36NChAwwdOpQDtEiSBNWqVYNGjRpBVlaW6p0RI0ZA3bp1+X2iKeGNxmUwGKBv374wYsQIFZ1EunuqQzwi4oLGnJKS4kY3Gl9mZqaqPsH++OOPVwrm/1Uhnu3Tpw8YDAZITEwEWZZBkiSoWbMmKIoCDRo0gObNm0Pz5s3dZFePN7S4pFJUVKTicz15IbwQX6WkpEDDhg0hOjqaA7OlpaVBVlYWZGVleZQJapt4PiwsDCRJUkX1dTqdEBUVBVFRUdzeveCbAqxp+6BP4pW+ffvCww8/DNOnT4dBgwbBihUrYNiwYTx2RVEgMzPTjf40dpEHtfjRyh31N2LECOjevTsYDAZo3LgxKIoCTZo08UgLvXI32jZr1oyjhRN9aOyhoaGsS/8MD2t1mcFggA8//BBsNhtHi7/XQnSrDM/eDS6LxQIvvPACGI1Ghqt58+YqPSC2XRn9fS9FK0PEcyQnBoMBWrVqBU8++SQ899xzYLfb4c033+SAiFSKiorg6NGjUFJSAogIGRkZYDQawWg0Qps2be7ZBv0R2EXbq6dLib//ahz+GZhFGy/CVVRUBPXr11fxmTg+vTHgf4MnijKJiHDy5Ek3vUsB1l5++WXYsWMHjBgxAkwmEwdnCwsLg+joaIiKigJvb2/+jmw92f7o6GhQFAUSEhIgNjYWoqKiQFEUeP/996G0tBSuXbsGLVu2hCeffJIjh4s0atiwIZhMJo88Qr4W1fEkC6RrSJfSJ9kj+uzTpw906NAB2rRpA3Xr1mVfhnwRGl+dOnVg6NChULNmTWjWrBlER0dDUlIS1K9fX9Ue2TYxI8BfVSriby1+SMffrY7odymKAhkZGWAymWDAgAHw9NNPq+S6Xbt2Kj9XawNJT4u273/pb1TG/v8RHaOnA6X/ZqJwOp3M+2Tr/wq79Lcr/4cLBv8WD2Xfvn1uz+bNm/loEAirSU2bNsWePXti27ZtsUuXLli7dm1exVu/fj2uWrVKlWsSALBGjRr8d7t27XDBggWYk5OD999/P77xxhtuj9FoRKPRiE8//bQKhrfffhvNZjNmZWXhfffdh0lJSdz38uXLcd++fdi7d280Go38/5dffolffvklrzaKcImrhNoVQ1pp69SpEz7zzDN33TkSV+gqqqO3+3C39iq7yrh+/XpVLnBxTO3atcOJEyfioEGD+P5bRf3rfS/2deDAAQ7CAgC4ceNGdDgcaDAYcNiwYRXy273g8m5174ZnT+3owVSZ49GVxdfd4PozdW7cuIF9+vRh2hLue/bsiRMnTvQI+5+F+Y+uehMfirva9DftJNH/lZEL8dNut2Pnzp3d+LBnz57M5xWN717pfy+7A5Upfxbf98Kff4T+nvBz48YNN/m32+1YpUoVpuXGjRsREVU65154vzJ1K4vTP7NDqoeDv4puf6adyuDlr8KBKG82mw337t3LJ6+uXr2KV69eVf1vt9tVNkKWZezcubPqRIPdbr9nnfX/krb/KxzeC4+IdUVdJ15TIH9JD3Y9W0FyCv/dTSV69u7dm/0pAMBly5bh1atX8bHHHkOj0cg090QjT7JIberpfD39r8ffnvihMjziqY6ePyg+4m/E12IRx6Udn3acnnDzv+anyvSFiCyzWtnWk/HKyOhfdTy+MvpIzw/9I/b/z+Bb205F4/2nlXvfYvy3/M9LamqqW4olSn0hFkSE9evXcz0UVmhlWValAwIoT9vx3XffwaFDh/i7JUuWwJIlS/j/ZcuWeYRLzJMMcCe/7/bt293gonQ4K1asgDlz5vD/nsYhftLfMTExcOPGDdXKqMlkgs8++wyKi4vh448/5jQVRUVF8PHHH/P3xcXFnKrnypUrsHDhQrh9+zbMnj0bioqKYNu2bVBWVgYHDhzQPQ1AeNf7n/5GRPjiiy+gqKgIrly5AgDlKTaOHj0KN2/ehKZNm3KKEEVRoLS0lD9r1aoFX3zxBYwbNw7eeecd+OKLL+DatWswbNgwToVy7tw5XThofIjIf/fp0wdKS0vh4Ycfhjlz5sBLL70EhYWFIEkSfPTRR9CgQQM4cuQIHDp0CIYOHQpJSUmwe/duzlWrLV988QXcvn1bNa73339f9d3u3btVuYaJHlpaFBUVwdNPP83w9OzZE0pLS+HcuXMwdepUOH36NBQWFkKTJk3AbrdDQUEB3L59G0pLS+G+++6D8PBwaN68OZSWlsLmzZvh1q1b8P3330NeXh489thjsH79erh16xYcO3YMAMpThpnNZk7Xc+3aNZg1axbTSZIkFd2l/6Za06tTVlbmRmOiDeHpq6++gpKSErBarXDz5k34/PPPoaioCFJTU+GTTz6B++67j9u5du3aXWHWo4cnvhS/8/Sp/fvRRx+F2bNnw4wZM2DQoEFQVFQE1atXh7y8PJg2bRps27YNVq5cyeO9G28QngDK5fDw4cOwadMmzvcKAFCvXj349NNPdeXl/fff5++uXLkCkydPhlu3boEsy/D6669Dly5dID4+nvEeGxtbIVyzZ8+GW7duwYQJE+DWrVuAiNC9e3eIjY2FkSNHQlFREZw/fx5q1qypSulUEb5Jv37xxRdw69YtmD17Nty+fRt69OgBhYWFMG7cOLh9+zZMnDgRIiIi+KQRlaKiIh57QUEBbNiwgelPvEZ8XRF+ANRyR3w7c+ZMKCsrg/nz58ODDz4IFy5cgKKiIiguLobY2FjONwxQnmLo3XffdeMLLW21ckL6ZufOnYyDW7duwfLlywER3eSuIlxSEfW19lPUbx9//LHH9vTGIX5PsqcdF/GsXjuVgYf0HOHt2rVrjKuK9Dd9au1ORfIrFlGGbty4AQDl6ZEQkVOjEgz0f1lZGbz++uvMIz169IDDhw+D1WqFsrIyuH37NsiyDOfPn4c9e/bA888/rytvd9M1Feku0V7SKQetLiUbKEkSlJSUVIjDysIj6vm7waz9jmAWeYdsl6jrWrRowXXLyspUKXBFHI4YMQL27dvHtgIAWE4lSeJ0kURPsVDOdGqX6syYMQMOHjwI3t7eMHLkSCgtLYWXX36ZUxDKsgxr1qyBgoICKCwshC5dugAAwM2bN2H58uVgtVqhTp068OSTTwIAwMaNG2H27Nlw/fp1lbzcunULiouL4fXXX4dXXnlF10+5cuUK19HKgrZodenIkSPhjTfeUKUcJVoQHek7Oo03aNAgCAgIgN9//x169eoFBoMB8vLy4JdffoFTp06x7/Huu+/C/fffD99++y1MmjTJDRZP9K+Ir/V+I/4m31MPPwsXLrxrHUohDKCWbVGm6V0qWj/39u3bbAMBAMaOHQt9+vSB+Ph4+O233yAoKEilq/+MLFGhHXayQ1SnIvt/Nz2pLXp+9+3bt6F79+7MT2fOnIFWrVpVaJcq0lV/6/K/Ww/4t/zRcurUKX4WL16MVapUQZfLhe+88w56e3ujwWDAgIAAlCQJhwwZglarFZcvX44AgJGRkXyHunnz5qgoCnp5eSEAYHp6OgIA9unTR3UvePLkyRzspEePHhgSEoKDBg3Czp07cxAjEHa9KQBdVlYWyrLM7wYHB+OUKVPQbDZjdHQ0Ll68GPPyyiMBUyqkb7/9lgONdevWDSVJwkGDBqEkSTw2SZLQ5XLh3r17OUJvXl55IIrg4GBVsAsKzgIAPE66z0cRsAMCAjiKOQVs69GjBxoMBhw4cCAaDAaPq5WeAtEtX74cJUnCqKgoXlF0Op1oNBoxIiICFUXBb7/9FiVJwoULF6IkSXwPBwDwk08+QafTid988w0CAEZFRangMBqN2K5dO92VQwruQTgQaeNwONxOYwCUB25xOp0oyzK2a9cOERFHjRqFPXv2VPWxb98+t3HZbDYEAL6bSzt2o0aNYpgJLjEglh4c9BgMBmzcuLFqFZ3oKdajJzw8HE0mE0ZFRaHZbMa4uDhUFAV9fX05w0GzZs3Q6XTiwIEDsWfPnoiIaLPZVHVo5Veku9Vq1a3TpUsXpo04bqPRyLDTb5QainAt0rhv377cTmVgFunxVwai0/IsBbgh+tBO0ahRo7B+/fpuAST1eINgJ1wSvyOiqs7777/vhst9+/ap+GrWrFkYEBDA9xMlSWIZpZSGxLtUnE4nj4tiWgQGBrIeEHmIeH/UqFGYlJTE+Na2p4dvoqm2D+JdGgPFlPDx8UEfHx9VPAYau7e3t4r+xGvE157wo5U7Ld9SRHhqV5IkfOuttxif9D6lKhPHp0dbUU7IvoinM0iXRkdHq+jkCad6fEm6QtQZoq6gvyMiIv5QIDqr1VrhuDzt/OjBJdoYgisoKIjbNxgMDE9F+pv61LMxnvAk8rme/AKU3/MMCAjA7OxszMnJQYvFggMGDMCQkBC0WCwYGhrK8WJITh2OO/dnJUnimCuiDdKzi5XROSIttLCLu9KiLhVpcjcc/q8D0enZeBEuUddpZZzkS4vDyMhI3LZtm0omSU5J1u12O86bN4+D27322msIUB6I7Ouvv8bRo0erZFH8pDSpFKQuKCjILU6I9N+7wLQbajKZOPjgvn37MCAggAMRi7aQTkd68lPI16I6WlkgfiBdQ7pU65Pl5OSwrJF/SacTtDF7iAcoiLHoT9Aj+nr169fHRo0aueko0lN/NBCdlldIzvTwQ/q6ojqEEwBgPoiOjkaLxYItW7bExMRElmvCqejn6tlASZJYR5Pvd6+yXRFeSK8QTCL/6Nl/RESTyXRXPXkvOpD4SZZljI+Pr9Au/VN32v+dtP/NS2ZmJi5fvhwdDnUedYpWLcsyulwu/PHHHxEA8P3332eHzt/fnwN1kCMJADh58mQVk69YsQIlqTxFWmZmJn799deoKAomJSXhuHHj0G63Y4sWLTjIGk3MFixYgEajEd98800EAHz33XcR4E5wpWrVqrFhOHLkCOdYzMzMxI8//hgzMjLw448/xpKSErRYLPjOO+8gAOAzzzyDsizjsWPH8OjRowgAqjydAOW54T/55BOsW7cu/6YoCn700UdYv359fPPNNzn427BhwzA3N5eP7VitVvz8889VztePP/6oygGZl5fHdfPy8jA/Px+PHTvGuSCbNGnC7YlBWigg0LJly1RHhCwWiyrQCgWRysrKUrVDMCxYsAABQJV3WhFycK5duxYdDgdOmTIFMzIy0GKx4NatWxkumryTMbv//vvZsQ8NDUVExM2bNzMuKb96bm4u9u3bl2Gn42RNmzZlRSnLMsMTGBjI8FDObKvVynDVqVMH+/fvj02aNFEFkxk9ejRaLBbs3r07RkVF8Vjq1auHiYmJqCgKT3YlSeJ8tUajEV0uFyIiKoqCjz76KGdKEHEbHBzMx0CpDuGXcEiwp6Wl4eDBg1V11q5di7Vq1UKHw4E3b95EAMAlS5agoig4ZcoUtFgsKjxRTnpFUTA0NBTtdjt+/fXX6HK5MCMjgwOUyXJ5Pl9EZKffbi/PvRsSEoKIqMo/LuaoJdiJ17TjITqKeci1PNu/f38sKSlBgDuLeIS7OXPmYElJCX733XcYGhrKjiflR83KynIbs8PhYF5VFAXNZjMePHhQBTOlraE6VqsVjx07hrm5uZwz3mq1Yt26dXHYsGGYkZHB3wEATpo0CQEAp0yZglFRUVhUVMSpE61WK2ZnZzOPGY1GrFu3LgIAxsfHIwBg06ZN2ZkIDQ1lvg8ODuZ2SO6JTqLcl5SUYL169fCxxx7DJk2aMO4oJaXoOFOfJB9Lly7loJ9E/z59+qh4lnjN6XRWiJ9jx44xLcgZl6TyXNIAwAucJGNmsxm/+uor3fetVquKZ3Jzc1W8sXHjRtaBQUFB2KRJE5QkCfv166eiP/UVGBjIOKCx06eWd0X9KPLsJ598wilMxTpJSUk4d+5cdrLEfNSUe1err4mOaWlpquOasiyzvIj6jfQ/wUPtkZ3JyMjAVatWqeRNkiSsWrUqywTp9xUrVuCiRYswKiqK2xH1N/WphZXa1cMT8Tn1RfLSv39/tmU1atTATz/9VKXXb968yXxisVhYTxH98vPz2QZ++OGHKr3yxhtvMD1JTvR0jBZfpHNE+c/OzlbZX+I/rS61Wq3sK1DgRk820Gq18nhE3GlxeDc9mZeXx+MT64g2nuyQLMv4+uuvs3wdO3aMbVG3bt2wpKSEo/iXlJSwbiT9QjQn+0wyM2vWLP6OJj3ET3Xr1kWTycR6KisrC41GIweJpWsOJpMJTSYT6wwAwOzsbIyMjOTI4zSG2bNncx2Suf3792Nubi4HCCZ9vXbtWrYV5HcQjUgn5+fnY05ODkqSxHVoYYZkgfg8KyuL9bXe4kPNmjURAPDw4cPcR25uLrZr184tmKcsy+jt7Y3JycloMpnY1wMojzRvNpvx008/VU3wCJfET0Qbh8NxV37yZHebNGmCffv25ToffPCBSoaoDvm2AICzZ89W8QjVoeuMsixj165deSFGlAWyXZJUnqUgNzeXx042UOQRWuwgW0r0F3FAMqyVE5IPPVmiT/rebDbj5s2bsaSkhAMyr127FmvXru3mL1P9sLAwlkXS7RXpQFGP1K1bF8PCwrBt27bMr9Sun58fhoeH45YtWzAqKsptbkV9/tPKv5P2v3mxWCx46NAhztdOedRJeVmtVlaWfn5+OGDAAF5hozsxtPpJRqBTp04qx+6TTz5BgPLdGeqPcmXSTvCqVatQlmVV36TYmzdvjkFBQThgwADeWQoODuZ7cjSxpnyh1IfFYsF9+/ahopRHkKfV1IULF6IsyzhixAjVTsuKFSvQbi/PJ7p3716MjY3l/JyrVq3CmJgYdr5CQ0MxJiYGHQ4HnjhxgtPVRUREsIKhXXEA4ByX4uQ9JiYGly1bpnLsKR+my+XCLVu2qHKDBgcHszI8duwYR1B94YUXsEGDBrz6bbVa0eFwsDFu0KABtxMeHo6KouDq1atVcImf0dHRrAwJBw0aNMDp06fzOGmFlQzY/Pnzmd6istYuWLhcLjxx4gTGxMSgxWLB8PBwtNlsuGbNGua38PBw3Lt3L0fHJngIP6tWrWK4qD2Ci9L7ffTRRwgAuH79em6XcqrTLsSJEyf4viUAMJ8ajUaGfcOGDQwr8SnBRTlLjx49qqKTCLvII9o6dHKCHPRly5ZhTEwMrlixguETaex0OlULM5IkYXZ2NjqdTt7NAABcs2YNGxYy1hERETwJ1OJS/CQ+CA4OxuXLl6u+IzqKTraWZ8kRIh6MiIjAbt26qRYlaFc1LCxM1YaIJ0pHQ0abcJmeno7Tp09X4XLVqlVoMpmwdu3avNi4YsUKdLlcPMEgeE6cOMHO65w5c1CSJOaVpUuXsgNM+YdXrVrlxmMOh4MdZ5FvSG+RbBHMYWFhqkkbyb3o2Il6hGC12Wy8W0SfBKMor3a7HcPCwpj+Wp4lXjOZTB7xIy7oEe86nU6WReJBsd309HRs0KABL9yKMl63bl0VzzgcDuYNvb5cLhfa7XZeRCXHl/rS06X0qeVdsgNafSvqc7HO3LlzVQ7r/v37WeeITqdIN6Kjw+FgPU36TCv/nuARYdb7bvr06ShJkkp30GIhyZD2HREHWlj16og4FHUz8bdoK2gSeerUKZVeDwoKQpPJhPXr12fZlGUZx44di4jI9Ny1axcCAKalpan0nAiPqGO0+NezAyLsW7ZsYf6eM2eOri4l3gsLC8M5c+ZUaANlWdb9TYtDLf9pxyDqE/F90cYT74SFhTHMpOsIh2vXruUJWVpamoo21Gd6ejpOmTKFdXB4eDgmJSVhgwYNsHnz5ihJEk/4aFfWarWy77J37172GUhPrlu3jqOpAwDrDADg3VFRj5AvRXV69uyJBoOBx3zixAk+USLaQhoH6aeYmBiVTna5XBgREcF1PvzwQ5UsiDIp6tLw8HC0WCwYEhLC+ecBAIcNG8bjE3UhQPmCq6h3ly1bxnzkcrlQkiRs166dyk+lMUdFRbnxA00Q78ZPenZXxFtMTIyur6BXh+yt6OuJNppshbjxJuou2o0X2xZtIM0BAIAXmsiWinBp5daTLtSTJa2O1/K3lmdFvyAsLIwXCrWyWJEOFP1uLX9T25Ty0mw246lTp9BsNv8fzuL+2vLvpP1vXtLS0rBnz564e/duDAwM5DzqNJlVlPLAJbIs86q1oii82wgAnBJNXKUUlTpNStq1a4epqanYs2dPnDlzJrpcLj7S27p1a6xWrRoffRIngBaLBRcuXIgWi4WPUHl7e6Msy+hwODAnJwejoqJw7Nix2KpVK0xOTsaePXtyX9HR0Th16lRUlPKcwjabDV0uF/ejKArWqlUL7XY7OhwOTEhIwGbNmqHVasUdO3aoclS2atUKg4OD0Ww246xZs9BkMuHGjRsxICAArVYr53n08/PDwMBAHDJkCBoMBmzWrBm/HxUVhXv37uV2o6KiWHnQd/7+/rh7925VztGaNWtieno6ms1mHD16NM6aNYtPJ9DqNylfwhEA4Keffqpqx2q14htvvMH51Qku8dNqteLmzZsZB5RX1WKxcGoxkdYvvfQS+vj4qIxTcHAwOp1O1ZgDAgLcxmUymfC1115jRUy5RB9//HG0WCwqeAg/BBe1R/gfOHAgAtxJtffuu+9yuxaLBXfs2IFeXl4oSRLu3r2bU6QBAM6YMQMlScLAwECeAC1dupTxTGMR4SL6i+OpbB2Xy8V9GY1GzMnJwWnTpmHt2rX5tIFIY4vFwtc7aBV83rx56OXlhYGBgbzS/9lnn6kmvnv37sUhQ4agxWLR5TU9+lPuXe1vREfR4Gl5lgyer68vTp8+nfVCSEgIOhwO3mV/66232ICKskR4ovaDg4N5fHXq1EG73Y6NGjVCWZaxUaNGvFBDfE6LSAEBAfjuu++ij48PKoqCPj4+uHv3bnYYly1bhmazGVNSUtDLywtr167N+BLzD9O4iMd8fX35OgjxvjjRnDFjBsuKiEs9uSdcEmzaPmihsUePHggA+Oqrr7rJrZeXF+sjor+WZ4nXKsIP4Zt4xd/fH1944QVs1aoVWiwWxjtdxRGvRVFfderUQZPJxPnWaZw0Pu3CldgX1aEF4IiICDSbzcz7jz/+uJsurQzvEp5FfS7Wyc7ORkmSVI7irFmzWOeI32n1d2Xk3xM8oi4LDQ11k8ns7Gx2OPX0t8irnnCg7asiPGltjo+PD4aFheGMGTPYYX3yySdxzZo1zINRUVGYnZ3NV8UcDgfziNFo5KP/iYmJLKe1atViPefl5eURZq3zLtJEOx4RduLvWbNmuelS4vOxY8e69e/JBv5ZPanVJ57wLdp4Ly8v1nW0UdKtWzc+HTRlyhSMiYnBGTNmqGgxe/ZsdDgcvEiXm5vLctqxY0c0GAx8DNpkMqHNZkMvLy9UFAVzc3NVupQW5pcuXapKJfruu+/yxJeu6YinICdOnMhpccVNmPDwcL6iQwvIoi0kXUWTUqIf8XlAQADrI3HiOmPGDJUsePLJevTogRaLBV0uF3p5ebGvlJCQwKekyO9s0KCBm94lPgoICOBTBzRmOn0KAJiRkaHLD3/G7oq8IkkS61eRh/XqREVFqXhEtNFEWzrm7XK5VLqLTj9t3rzZzc/S2kA66SbaUlG2PMmSqJ88jV38JJkQ+Vtr/7WyRLyh1eOV1YF6/C3LMnp5eWF4eDiuWbMGw8PD/6+ncn9Z+XfS/jcv27dvx8DAQAwICMBGjRphbGwsH8GmyYx4h4eOC9HEAQD4zrk4WRcn35V9xJyftPtJE21qj76v7CPCTosH4qTW6XSyAdG7r1TZtmnsYv5Lvfv6FbVFO6nUlt1urzAPamUfGtsffZ9W2WvUqIFms5nvros0o/uKWvqLfGK329HHxwe9vLxU72nxKb5zN7hIeVIcBL28mmK7FosFvby80Ol0Yps2bdz6pwkJ7eo1btwYq1evrkvzv+ohOdG27Ylu9J2vry82btwYfXx8sEqVKmw4JUliQ0arxeREGwwGNJlMbrx2r+Mi2lI7DoeDr2QQ7gjPlPtUlD9aOAsLC0OXy4U1a9ZkOdTLIWsymRhe0k9343PiD5Ev6Ugd8SO9dze8i+1QfXKGCb8A5U4LLVTSyZe7yWZYWBjvNvv6+qKiKNipUyfVaYnKyum91NHDD93R1tNtldW9nuRXlmXm9aCgIGzcuDHvWNBvhFOAO/cmyQb8FbIm7hhWRBM6yUJ3Xl0ul5tuFnXNX6EXqM3K8KOIZxHf/wv9pG1bz06KulP7vshf9woj8QXpCJo86umAiuzcn7WBf/QhneYp3/O9PmQ369evj2PHjkWXy4V+fn7ocDj4nnd8fDxfiRL9JtohFukQHx+vykEu0pi+8xTHRo9HAIDluaJx3I0WejpI3BQgXNA1Hrvd7mZHXC4XAoBHedd+L75TET8SP5N+p40kPdx54sM/Kq/3quM9wUA2mk7DAdxdz4pjp4Ue0teV8dfuhpM/KxuV8ZdF/N+rHqK/RR1HpzkCAgJ0c9P/E4uE6CGR9r/lb1Nu3LgBn332GRw5cgQAAKpXrw7du3cHAICuXbvCxYsX4aeffoLbt28DAIC3tzcoigKFhYWgKArcunULYmNjISQkhPO5njx5Evbs2QNFRUUQFhYGZrMZSktL4bfffoPr16/D5cuXwWq1QmxsLNy6dQsKCgrgxo0bUFZWBk6nk9suKyuD0tJSsNvtYDabobCwEAwGA5SWlkJmZiacOnUKAADOnj3LUUENBgOYzWYoKSkBWZY5uqUsy2CxWMDhcHBkx4sXL4Isy1BcXAwWiwUURVFFFzUYDByFlYqiKJwHVVEUACiPUumpGAwGkGWZo7sXFxer2hejwQKoo06S+Cj/jQpvNpshKCgIAADOnz8PsiwDIkJAQAB07twZdu3aBQAAp06dgujoaCgpKYGDBw/C1atXGV4RVoPBAIioij5vs9ng999/h7KyMkBEkGXZLSq/th2xSDqRiz0VqmswGNzyPEuSBDabDYqLi91wJv03avPdYNBr927F0zvUpiRJEBERwdGcb9++Dbdv31ZlWVD+m8u0ojomkwlsNptbFHVFUcBsNnOEewDg/y0WC7ejB1tFRY9mkiZyq9FoBJvNBrdu3QKLxeL2KfKFXqkIDuKjiurcbRySJLFesNlsUFRUBKGhoVBWVga///4783lF7XnqQ5RrgpfkoyJe81SoPcKrlodLS0v/EjmxWCxgNpuZNuL4iObEa9euXbsrfgAArFYryLIMhYWF/DvxoJeXF3h5eYEsyxAdHa3SwaWlpVBaWgpWq5XxVVJSopvVQ8QTQMU6lOrJsswRtp1Opxt/AkCFPKuny6xWK5SUlHBe8YqKHr705EqU/4rgIVtFUdq1bRDORXujhydRjom3nE6nW1+kmwjfIg61espkMrEtFMdONAAolxHiR9F+mkwmAADIyMiAOnXqwHvvvQe///47lJSU8JjMZjNYLBZuq7I6Rjtmo9HI+BHll+AjnUl4E2motc2EEwDwiDvRTt6rniR7TTArisL4Fm28iBdvb2/Wb1euXLlnnaEoCkiSBP7+/nD9+nX+nfwab29vkGUZrly5wvDZbDYoLCxU0V+vaHlEr/j6+oLdbme9LeppGrPL5YKioiKODi7iC0A/u1Flxq73vdPpBFmW4fr161BSUgIOhwOuX7/ONBH1a2X8CLEvq9Wq8iGJn7S4vFe7S7JJ+NHjFU91qNzNbxLHERERAYgI58+f58wWerrTUxtaHvYkS9Q2wB17q5VFUbcDlPOr1taQD084FvFD+dxFfpCEjAFGo5H7upsOFAvZ94iICOjRowfrvLFjx1aIo797+XfS/jcuP/30EwAAp4XSK6dPnwYAgB07dgBAuQIGALh06RLXuXLlCjRv3hyioqJ024iPj+e/k5OTdWEAKE81dPz4cSgsLITq1avD+vXrVXWpbyqPP/44/7148WKPY9i0aRPk5OTAuXPnoKSkhBUIAMDBgwchKSkJ/Pz8VO/QxHjs2LFw7NgxXtCoVq0azJ8/362P06dPw2+//Qbnz5+HunXrwuHDhyE0NFQ3fRTBI/5Pji8AQHR0NP995coVCA0NhUaNGkF6ejo0bdqUU9SJqeo8FZfLBQDleP7pp5/g+vXrcPDgQY9prWjML774Ii92AABcvnyZae7n5wcdOnSAAwcOwKFDh8BgMECVKlXAZDKByWSCxYsXQ2hoKOTn5/P72vHRuIqKiiAkJATmzp0Ljz76KKe60eJOizMqFy9ehIsXL0JKSgrcvHkTzp8/D0ajEcLDwxlf2nZdLhdcvHgRLly4AJcuXYLo6GjIz8+HpKQk7nPJkiVw48YNKC0tBUmSICEhgWGtUqWKm2L+9ttvGb/Ur7Z4qqM3bsJ9QUEBpKWlwY0bNyAlJQUaN24MTzzxBJw/fx6OHTsGDoeD0xJSiqaoqCj4+eefISEhAY4cOQJOpxN8fHyYDleuXOGUYSKvAQDk5ORUaHRefPFFpodIU5G21GdUVBSEhoaCoihw9uxZuHbtGly6dAlyc3Phxx9/ZPpp3yfeOHLkCNSvXx9OnjypC0v9+vUBoDzNEZWffvoJJk6cqMIlySbR77HHHoOJEyfyopfL5eK6mzZtYjxoy+nTpyEjIwP279/Pk3D63Lx5MyAiXL16FQIDAxnfIl715B7gjmzQ2G/cuAE3btyA8PBwKCsrg7p166r4WauPSL+K/EWyqOW1b7/91iN+jhw5Ag6HAzp06AAAoOLB8+fPQ/369aFq1aqqVHtUXC4XvPrqq6rvKL2UiFOSq4sXL4LJZAKr1ariwZiYGDh8+DAEBwfDoUOHwNvbW0UfsVTWOSKepUI6AwDA398f3nrrLRVfUyG6aOVFpBeNS+Sx4cOH68q/J3io38LCQigsLISaNWuCv7+/yibl5ua66W8RVrEQj5Eer6jo4VDko4MHD4LBYPCol0UbQYv6YnnmmWf474MHD8KBAwfgxo0bkJ2d7RFHWlqIekZPd4kylZub68bfVEQaebLNIk7+CO48jUFbRBqJ+E5ISIDGjRt7bPeJJ56Abdu2QWlpKdy8eZNT6gEAXL16Fby8vCAyMhJOnToF4eHhqnezs7PdUmoBAE82xDJixAj2Gfbv3w8XLlyA0tJS8Pf3hwcffBAsFovKllksFli0aBH8/PPPYDQaISkpCVJTU1k/FRYWQn5+Pk+AyNfz8vK6q37S4jAmJga+/fZbKC0thRs3bkD16tXdbJFoR8gnE3Uo9bVz5044c+YMxMfHQ506dRiuy5cvu/kRpHcPHTrEvgYAwL59+8DPzw8iIiK4f/IficYvvviiR14AuLvdpXKvfoYnX4/0cFRUFCiKwgsNWv9GKwOinyvLMqSnp6tsoRbHVDzJUkX2FqAcd3p+rtbWUDl37hz89ttvKn/5XmSRihbPIn+XlJRATEyMx7H+08u/k/a/caEV83tdxfwz5bvvvoPdu3fD4cOHOQcoFdGQAIDbSin9rsdSQ4cOhVu3bkHz5s1ZsbZr1w7MZjNs3LgRrl69Cu+9955HuLS72xMmTICtW7dybtJLly7B4sWL4caNG5CUlATnzp2D++67D4KCgmD+/Pnwn//8B1566SXw9fWFzZs3w44dO+Dy5cswbNgwkGUZXnnlFdi1axckJCRAtWrVYO/evdCqVStITEys1PvPPfccXLx4EcLDw+Gtt966Z7xv2LCBYT137hyPITs7G44cOQJ79uyBhIQEuHLlCiiKAlevXoVZs2bxiqSnQrQYPnw4wzp58uQKx+Pr6wu7d+8Gi8UC33//PRw8eBCio6MZp/Hx8XDixAnYsWMHnD17lh1lOtUh0libEz4sLAyuXLkCc+fOhVWrVkF8fDy88MILcOrUKY+5syn/aF5engo+Mc8o1SFYCR5ylES49HDpqc6tW7d0xzxt2jQVX+o5W1TEVfOKxmK3291+I9po8Xz16lUwm81w6NAh8PX1hZo1a8LRo0fB5XKBwWCAjh07qvKx6rW9e/duMBgMMHLkSFi5cqUqHzfx1Y8//qiiG7VBuea/++47mDNnju7pE73/RT6vDA+KsGv5MCgoCGbPng27du2C5OTku/KRtog8ExgYqKtPSkpKGEYtz+m1Q/Bp5Zb4SBz70KFDYf369bBhwwaPdSrSOT4+PqodCT3cUxH5lP4eNWqUStcQn2tz+N6r/BEubTabii9LS0vBy8tLl3dPnToFrVq1guzsbPjtt9/AYrHAunXrYNWqVRAVFaXSC/s1dgAA6R1JREFUyWKd77//XldeRDyRvtPiW5R/T/BUpP9JJrW2Rg+nevqyuLgYDh06BMHBwbo2TKxzL3D99ttv0KlTJygpKYEGDRowj1RmF454ZOrUqW46VMQTwVxUVKSSNz0dURF/E02+++47GDp0KISHh1eKXgRPZXR7ZfVkRTxH+B4/frxuvmrt3wB39D75ceI79+LT0W42nQqismXLFvDy8oKSkhJdHa9n67U69ccff4Rvv/0WDh8+zO1WpCNIr5FtF+lVGV2u5RFPdu7kyZOwY8cO3ozS6rW9e/fCtWvX4MiRI7r+yZEjR2DixImwceNG1bgq4u9bt24xP3jybyrDT6JdIn9y+/btHuuQ7dq/f3+FNqewsBAOHDgAK1asgBMnTkBYWBj88ssvEBwcrIJdLwf73fyjyvhAnsY1f/78CvPYi3i/dOkS8+W5c+cgNjZWZXdJn0RGRrLvqbUnFenAinwpT/b7H1d0jsz/W/4m5dSpU7hlyxasUqXKn75P8n/1iHdsAMrvGd3LvXcfHx+cNGkSpqWl6d5blf6bdke8n053oSjQG/VXp04drFevnupuUMOGDd3utlN+Xrq/Su3UqVMHIyMj+c6eJEnYokULj7nFPT3ae2uSJHFqIrpbR32KAVRoXHSHjQLR+Pr6ck5og8GAgYGB6HK5uD7hLDo6Gs1msyoNXK1atRivkiRhbm4u1q5dG0NDQ1X3l202G0qShHXq1MGQkBDV/Ve6n033zQg/AOX3mGJjY9HHxwedTifHWxDH37x5c6ahyWTCkJAQzjkaGhqqumPmdDo5qm5YWBgmJCRgWFgYmkwmxhP1LQai0fIetaetI97JI5zUr18fExISVPfiCC++vr6q8aSmpmKdOnWYHoGBgRgaGooBAQGYnp7OcEqShE2aNMG0tDSMjIzEoKAgjgirKOXp7jIzM1X0p7gARH+xX6pD48vJycFq1aphXFwcR5mmlI/p6enYtGlTDAoKQoPBgD4+PpiZmcn4Jbq1adMGExISMDAwEDMzM9FoNHKQQIvFwvD4+/tjSkoK1qhRQ0Uro9HolieWcqgSnL6+vlilShUVbqtVq4bJyckYFxfHadCIPi6XCxVFwYiICLc7b1WqVFHFB3C5XOhyuTA0NBRDQ0MxMTERw8LCsEqVKli1alU0Go18L1vUJwkJCap0brGxsZyW0Gw2Y2xsLFavXh2rVq3KkcUJ/yS3ejFHtGOne/Uir2nrxMTEYMOGDVUBo6pUqaKSMZPJxDrI4XBwwD0RN6J8KIqiClZJd2nj4uIwODiYAySFh4czf5OsR0VFYfXq1TEwMBC9vb0xMTGRUyfq3Z+kPul9Pd612+0oSeU5pePj4zk4mVjH6XRynWrVqmGdOnVQURTWRQ888AAOGDCA7weTTjUajQwDBbmqLDxa/d+rVy/MyMhQ8Tjd3dbT35IkYc2aNbFGjRpoMBgY36QvxTu2xHNanaqlIeFU5JEmTZpwkNiK7oFS/0Qv8XuyA/Qd4Yn61OJJkiRMTU3F2rVrY3BwMFarVg0ffvhhtFqtGBISwjFUSJ/QPWrCk6iHybZERERwxhvqm2AmGtJvBI9IT092sjJ6sk6dOm48R7rOx8dHRVu9x+VyYVxcHMbExKDBYMBatWph9erVsV69epiWloYmk4llyWazYdWqVTErKwuDgoJUOG3dujVarVaVXaJ0kJ76Jr1EOCc8iXxKOjU2NpZ1ql6sFsIL8SLVIbxTRG7iI5EP69evzzJH8OTm5mKjRo0wMDAQAwMD2X+imBTkk4m8S32ZzWaOx+Tpob7pk+K0kA6kbDx0l57eo6jz1Bfprnr16mFAQECl7a7Wn6CsAXpyV1Ed0unUdp06ddhG2+12tlN6D7VF8YCIH4KCgtj3EOlNfKyVbT1ZotSMGRkZbvIhxjQRZYvqxMfHsx9E37dv314Vb0RPn/j5+aGiKNy+2CfBTDqefiM/KzAwkPmbfPQxY8bgtGnTdHPT/xPLv5P2v3m5//77sW3btpiWloYWiwVr1qyJr732Gnp7e2P9+vU5D+OgQYNYMUj/DXRF6RDIgfX39+fAYFOmTMGEhAR25on569ev7xawTk8B6Qm/JElYo0YNTExM5KBaFCSMUk6IwaVIqJKSklhZUNuxsbFoMBiwZs2aKkNB7aWmpqqcYlGAK3JcPD0U3V2WZVVeTBF2PUVJ74gTPYJB+W+Uehqzv78/Jicnqyb5ZBD02qV2TCYT56YkR1BUsn/20U6i7/V9ikAswvNnAp/8VQ8ZVOIdvcUibZ3KPn8meFNFT5cuXVTtEf1F55boTzxLBkoMFObn5+fWtjiBrixPaOkoZnTQBsUhPdCsWTOGW7vI9mcf7Rj+LN6Jd1NTU90CNf5VNP0rHj3eFR1arSNJtOjZsyfzCjmq2jZJH/3Z8RKNU1NTWf8RX1JferxL49AuiIm0pveojjiBFfvXo5u4eKn9rSJ46BkzZoxH/Gj1gPZ/kT7UP/GcmE+b6hCeqI6Ig3vVOZGRkdi/f39uh9onuysunN2N77R4EulNcGidd706eo/WlmplnPhI/m+QXREesjkV2cnK6EntQq8W9yKcot6rTOAs+j4qKkqFHzHwHC3+hYeHY40aNTjdHW0o3GuA33t5RLgr4l9PfKdH4z+jS/5f6N3s7GwVP5GPJ47lbnZXDwf06NGrMnX+X+JJK9t6sqTdCBH9ZFrc0Lbz1FNPucEnjl3cfNPKkggf6UBRJj3xZ0WP1WrFmJgY/O6773Tztf/Tyr+T9r958fPzw3379nFKH7PZjIcOHUKXy4UJCQm8SkaRqV999VUEAJw0aRJKksTKyGQyYXx8PEqShDNmzMD09HR+l9KwAJTvbIvG6uWXX1YZpXXr1iFA+a4tKby3334bAYAjx37xxRfsPFFbtWrVQgD3fOFWq5WFnmClXQraFTYYDLzSTO1Nnz5dJfSio0ApksgZJWVCu6WUt1lUHgQXpQoRFSrBTgqLUnWRkgkNDWX4kpKSWOlRXWrrlVdeQVmWVflGR4wYwfBT1HCA8ujNWjzROzQuyq8t4oAWQ2rUqIGyLOOHH37IvxuNRszIyMD4+HgEuLOrSmOnXSWitXYHT5Ik7pPgEnfwxN/I0SAcDRw4UOXIZ2RkMO6joqKwf//+KgeGPmm1nr4LCAhASZIwMTERJUnC5ORkxru4QyHCTvTX8l5l6lBfAHfy30qShD169FA5ahs3bmQ8xcXFuY1Hksp3p729vRnmoKAgTExMZPqYTCY3x4DgIJyK9NeTJapDPEs0MZlMTFuK9jxt2jQEKF8Rt1qt6OfnxyvYlE+Z2iEaJyQksPxRKh3iHYKL2qU81sSXIow0mSD4N2/ezPwQHh6ONpuNFzCIp2VZZkOuxYEkSehyuZivJEnCmJgY9Pf3R7vdjpGRkRgeHo5xcXFcX+RdPX1CuCSaiHrE29ub5Wj48OHcJ02MxXSY1J+4ayHyrMhrFeFHnByZTCaeTI4ePZrfBShPaUT9fvzxx4wnrfOv5X367Natm2rXzmQysSMWExOD3t7evONM0aGNRiPXJ1xWpLtE3iW4tPxN7ciyjLGxsbp1xAmZiD+xXxoX8aOe/OvBQzBXq1ZNVyZlWcacnByP+ls8jSTigP6mPitTR2tzTCYTy5m/v7/qFAXRQUwRSwvj4tjJxpANIrsIAJxGlupr8SROJrX4JjzR4kBF8i/qUoByW+oJZj0dqLVHd+M1T3pSy3OivqT/RRtPfRiNRj7JJEkSpqenM37oXUqFSzxFdCPYAe4snFB6QcIB4XfmzJncFk2uOnbsiBaLheHJyMjgNiVJwsmTJ3NflOddnFARDih1Ie1wEtyUiYbkHgBw8uTJKvmQZZltBbVNdcRTL1RHa0e0PpnRaOS+pkyZggB3bD5AebYY2qmvUaOGSu+SvyGOYezYsey/kt4FUJ9OEPlAy0+VtbvaBSvRV7BYLBXWIbqKdcgmE8zVqlVT2QrK1iLCTGOnXXGTycS+R1JSklt2F61s68mSp7GLsq2Vt88++0zVnij/lLpPlCXSk1q9q7XNFelAm82G3bp1U9nWhIQE9jU//fTT/8/kay+/LPNv+dsWippYvXp1joo9ceJEAAD4+eefobi4GAwGAxw8eBAAgIPDUSTIxMREAACw2+0ctG7lypVw4MABKC4uBkVRwOFwAABw1F+73c73UWw2GyAiB5l79dVXQZIk+PXXXzna8ueffw4Ad6JP2+12vn9VUlICkiTBoUOHAADg+PHjAAB8b8rHx4fbocAhkZGR/G5xcTGEhITwvS6KEGqz2bhP+o1gpki09H3nzp0BAGDYsGGAiPD777/zvTIaO8ElSRIUFRWpIvAS7N26dWPYAe4EiLlw4QL31adPH1W0TS8vLzAYDABQfg+rrKwMDh48yG2//fbbAFAeOZSixAIAjBs3jvsivNI7VCctLY3/VxSFcYOIHBxk8+bNIEkSWCwWKC0thcGDB/NY6c4d/W8wGODKlStgMpkAEcHb25ujgr700kuAiJCWlqbCd1FREQe0InjE8VNZsGABBAQEgMvlgpKSEhg8eDBHzc7Pz4e6dety3cLCQhW9+vXrB6dOnQKLxQKXLl0CRISTJ0+CLMswYcIExvvt27e5T6KhSP/jx4+7wV5RHfm/kXqpL5Ixo9EIn3/+OeNJURR49913GU95eXlQt25dxgNF+LZYLHDlyhWGedy4cXDo0CGOHlxUVMRB3URekzV3Igk+UZaIR6gO8SzRRJIkpm1JSQncunWLg8V069YNbt++DVWqVIHi4mIwmUwcOIjaIRoPGzYMAIAj6RLsorz98MMPXAeFqNHEYwDA9DaZTFBcXMy4BQAoLi6GmzdvQqtWrUCWZYbZZDLBL7/8oosDk8kE165dY/kLCAiAoqIi+M9//gPvvfceFBQUwNtvvw15eXnM0yLvavWJCDPRRNQjV65cgTfffBMAAObOnQsulwsQEV544QXGN9GM+Iii8vbp0wcA7vCsyGuVwY/D4YCioiKYOXMmANwJ+FVcXAyyLMPgwYO5XYKR8CTKJP2tHR/xDOm3oqIiWLhwIQCU33G9cuUKj4HikBQXF7MuJVxWpLtE3hXHL9YhXBiNRvj5559165CciFkEqBBtaVzEj0QfUf714CGYSRaor7KyMubLrVu3cv9a/U31tDgguESa3K0OwWU0GkGSJPD29mb5ffnll5nePj4+/O7ly5dhz549AABw9OhRkCSJM7YEBATAhQsXQJIkePvtt0GWZbaLAOWR5sXIzFo8aXWkCDPhifhfpImWv0mX0rguXLjAMBOPVaQDRZtTGV7zpCepLvEu6UsR36KNp2Iymbi9gIAADkBJQSoJh5IksZ9D+pFsqSRJcPnyZZAkCcxmswoHVqsVEBGuX78OsiyD0+lk275t2za4desWDBw4kOX+yy+/ZP32xhtvMI+MHz8ezpw5A+np6SDLMlitVh5D8+bNAaA8gG1ZWRnTyN/fn8dMNpmyKBDPmkwm9itJR1AdCoBmNpu5jtaOaH2y4uJi7uuXX34BSZL4DrK3tzds2rQJQkJCwG63Q15enkrvku0i/Ht5ecHHH3/MNH/kkUdUdBP5SWsv/6jdpQjwoq9A0eI91SEeEev88ssvcPPmTea1IUOGwO3btzlwcVFREdOZYCa69enTh+Em3nv++ec5awTZUq1s68kSFe3YRdnWyttnn33G7WnxY7FY3Pxl0pPUhlYHivaEcKrVgePHj4cvv/wS+vTpA7Isw/PPPw/Xrl2D4uJiGD16NIwePRqOHTsGAQEB8I8vf37e/2/5X5b69evj4sWLcfv27Wg2m1X3jECzYqoIeYNplZNWrugIvLhSRbtN9L7RaMTk5GTVfSi6BxsYGMgrXfDfVS+Cg/qidsXj37T7TiuitMImSeX3fWnF1eVy8c69v7+/6mhNVFQU90Urn2lpadxOdHQ07/ZIksRH36g9WuUdO3YsWq1W9PLyYjw1bdqUV15pzIRT7T2xl156iWEiXNO9O1opp7vBBLe4EimOSXxoVT8yMpLbee2111TtAJTvQgDcuX9FK9KSJPHKPOFIPJZMMMqyjFlZWUwzWrEnmoi71JIkYZUqVfC+++5DAMCJEydyn1WrVkWAO8eXGjRowL/RGAl38n+vDkiShA8++CC2b98eJUnChg0bqvqMjY3l1Xn67rHHHkObzcbXFcQ7hbSj9NZbbyEAYO3atZm3ibaEp+joaOY9LewV1SF+VhQFIyMj+Y6juNIrSZJqJ4DoL560oL9pzFOnTkWA8h0Joh/lYiVaiLwWFxenusOsl3+ceIT4lehPNBF3TyRJQj8/P+bzQYMGoaIofAKAHto9NRgMDPvo0aMRoPxePL1PcGljSNDOjZbPZVnmXWpa9ae8siLuEhISMDExkekqtkV90WkhkY8AAB988EHmg9mzZyMA4Ny5c5mPCB/Eu1p9Qn+Lp3xI3mj35q233uK27r//fgS4sztEuz8iH9EJIjrxlJWVxb+JdTzhh8ZIOovwn56ezvgwmUy690DFnXDqj/hZO76YmBje1RF3dmjsAHd2gubOncuwN2nSRIVLkS9JVvR4V8yjTKd9JEli2yDaK7EOAOALL7zA7WuvwRDPkmynp6ezDtHKvx48evqf6sTFxbnxo57+FvmJ9DfxnHhHluoQnsQ6on0nuCIjI/n7yZMnM45yc3P5NJooM9pdOu0daV9fXxUvdurUSYV3EU/0nUg3UUcQTURdrMffol6SJAlDQ0PZryD50OpA6k+0gVodqLWTd9OTIj8R74pwEb71bDzVAwDW4QB3TnWQ/BLsIn86HA7ul/oKDg5WtSleYfH29lbpSHFXNjExERs1asT8q+2T+LF69eqYmJjIPh7AnR1y7XWA5ORkvodP8u90Ovk+etWqVRlW0W47nU7mN9Fu6dkR0Scj/UP1Q0ND0d/fn2WVnueeew5r1qyJNpvNTe/SCYfg4GCsU6cO2u12N14X+VvUKVp+uhe7S/Lp7e2Ndrtd5SuIfp+2jqjjxToEM8nJmDFj+Cor1SUbIfqBiqJgfHw83wknGjRq1Ih5nXhDK9t6skT8J9pbGpeoT8R2qA2Hw6G6Mmk2m7Fhw4a6/rKoT+hTa5sr0oHE36IsEN0WL16MZrMZ09LS8Omnn/6/ntL96fLvpP1vXlatWoVfffUVIiLu27ePj7TJsowxMTHYr18/3UB1orKR/3v8RFQMfn5+HORL+y4AVBh0xWw2Y82aNdFisaDFYsHg4GBW1ne7Zy32R4JL34kGQHQ8AACDg4NVDmZlHk93hiioESkBT+9rA7Vola9Y917u2mgnINSXaDzu9TEYDOysk3I2Go2qu7raO8g0HhGnonNVt25dt3tGIuyeeEevD3JIqlat6pGGPj4+aDQaVUaxRo0aKnrR4+3tzcdCZVnmI4qV5b17qUPfiQ6W+Jse3axWK3bo0AEVRWFHNyoqSnV3XuyLFgr0frvXQIdaOmqDvoj4liQJY2NjsVGjRio80/s08SYHQQ8++pviTFSEZ73gRwDqeAj0m5eXF37zzTcqeOip6D6gy+XCqlWrMk+YzWb08/NDLy8vDm5TmXvcWrknXrNYLBgUFIRmsxm9vb1Vx2grejwttlYWP550llhXXCT09GiD7+nxefv27T3yPEC5Q1a/fn10OByqhdh75VO9/tPS0timeKqTmpp61/b+bIwCT/oSQH3Pkup60t+ig3y3PivDR+S46tklLVx6Y9FOzsRFyHuxr/R40hEVwaFHD61d+bP8VJmHxk5xGCrCd2VsMx3/bdOmDdcXj2WL4zQajTyJ1QbDpYfkwGq1Yk5OjhtP0m/Tp0/XtZPa/6tWrYorV67UbUfrm+mNWayjjZtCv9ntdlWATRprRTzidDp1dTy9U6dOHbcNJppU67VH10EzMzPRz88Pvb29KxXT5c/aXU/6+17riLg0GAwYGhqKjRo1qtAvp8dms6HdbkcfHx8O7Giz2f6wb0n4/qPvinyg/dR7UlJS7upHaHUgPQ6HA6dPn66iNW3mNWzYEK9fv/5/PKP78+XflG//wHL58mVO90Nl1apV8NRTT0FBQQHnczx37hwEBgZCQkICGAwGqFatGiQkJAAiws8//wwAANWrV4fo6GhYuXIl/Pzzz5zns2nTpnD58mU4ePAgrFu3Dr744gs4duwYGI1GACg/pt6kSRMoKiqCn376CX7//XcIDQ2Fc+fOQUZGBowbNw5OnDjBOZOvX78O69atg4sXL8KtW7fAy8sLrl27BomJibBq1Sro3r077Nu3D65duwaBgYFw4cIFiImJgQcffBBWrlwJJ0+ehN9//x38/Pzg4sWLEBQUBImJiVBaWgpVqlSBNm3awKxZs2Dnzp18JOnKlStw69Yt/l+v0LEcf39/uHDhAvj6+kJaWhocPXoULl68CLdv3wZfX1+3fNVioWNJpaWlEB4eDsnJyXy8LigoCBRFAYPBANWrV4c6depA06ZNOc/kjh07YNOmTZCfn89HPEtKSsBsNvPfLpcLrl27BkFBQdC2bVsAKD+iuXz5crhw4QIUFxeDv78//Oc//wFfX18oLCyE69evq452UZEkCWRZ5vzm+N9rCuKnXrFYLKqcvwDAR62CgoKgRYsWsGbNGrh48SIUFxeD3W6H69evQ0REBPj5+fFxP20Rjw9S32azWTenMMF/N5UVHh4OzZs3B6PRCCUlJbB69WooKCgARVEYd+Hh4XDfffdVWIeuZZw5c0bVr8FgYBoVFRWp6Ga32+HGjRuVglOvUNt6JSgoCNq3bw8Ad44eUn5eyk1KcnbhwgU3elUWj3a7HUpKSnRpIGmOC9LxOJF/jEYjlJaWQlRUFPTv3x+cTqeKzxVFgdLS0j+EH39/fzCbzXD58mW4ffs2+Pv7w/nz5xkf94p3gjUoKAjS0tLgxx9/hKtXr0JJSQnL/b20GRQUBPfffz9ER0fDihUr4PTp02AwGKC0tBTOnj2rGjvJoshrv/zyy13xQzpL1Esi32ZkZMCYMWOgoKCA9W94eDiUlpbC3Llz4fTp04y7ixcvQkBAAEiSBOfPn/eYiqoivqQi6oPatWvzceyYmBjOEyx+Eu/evHkTDh06BOfPn4eioiIIDw+HX3/9Fby8vLjd+Ph4OHnyJPO1ns6ivwlWOrot6n9FUdzk3xM8pP99fHzg0qVLYLFYQFEUKCwsZB3q7+8PVqsVzpw546a/y8rKVDwp8hrp8bNnz8K2bduY54gmYh2C68aNG3Ds2DG2FWVlZap0kmKJjIyEyZMnw6+//grTp0+HX375xc3uTp48GY4fPw7nzp2DVatWwc6dO0FRFEBElt+cnBxwuVwquhHMV65c4SPfYhFp4uXlBb///jvL7ZkzZ9z42+FwwPXr15nPqH+iH6WkCgkJgVatWoHVaoXi4mK2gWRz9OxkZfWkSCOS/ZSUFMjLy1PZZtHGU92YmBjw9vaGVatWwY8//uhRPmjcNC6TycQ6NiAgAC5dugRRUVEwffp0MBgMMGTIEJbVsLAwOHfuHNStWxf69esHY8eO5WstnooIs17x9/cHRVHAZrNBvXr1IDg4GBwOByxYsAAOHz6sel/UT5ImZZ2vry8f76+snvRUV5IkN10o/ffYvHilQ/tuUFAQ5Obmwo8//shHuPXwUVZWBi6Xy42frl+/DmvWrIFff/3VTQdWxu5eu3ZN148LDAyElJQUqFatmsc6dNxbtDkVlVq1akF2djb8/vvvYDKZ2A/05OPqFa1se5KlgIAAMBgMKntLfnLt2rUhLi5OV7eXlZXBhg0b4Ny5c3Dz5k3w8fHhcWn95erVq8OePXtYn+jpS7In96IDAcr5KT4+Hl5++WW+JvVPL/9O2v8h5cSJE5CXlwcBAQFw/vx5OHHiBFy8eBF+++03uHLlCnTo0AHMZjP4+PjAmjVr4OzZsxAVFQWpqancRlxcHOTn50NRURHk5+ezgGZlZXGdGjVqQF5eHueAbNCgAZw9exZOnDgBoaGhcOrUKcjPz+c70r/++isoigKHDh0Cm80GGRkZEBMTA7dv31YtKrRp0wYAgCer169fh6CgIAgODoawsDDIy8uDmTNnwpo1awAA4OOPP4aePXtCjx49wGQyQUJCApw6dQpu3boFsbGxfHe0oiL2FRgYCL6+vnwnNiwsDKpVqwbnz5/nOunp6dC0aVPd99PT08FiscCiRYtUixuRkZF8j61atWoQHx+vC0thYSHk5+fD1atX4dy5c+zsUH2LxeLWjrZ/ETZPMGZnZ0N+fj4cO3aMc1YjImRlZakmw+LYRcfeZDKByWSCn3/+GZxOJ6SmpjI8x44d4xytN2/eBLvdflec0W/0rhb/FbUbGRkJ69evhzNnzkB4eDjk5uYyzASfyWSCM2fOwPXr1yE2Nha6du2qSwPqoyI6eapT0bjFd6KiosBsNjPu8/LyWA6MRiOYzWbGKdGC2qSJZ3h4uEde06O/p0J02L9/PzsYWp49dOgQXLt2Db755v/H3nXHV1Vk/+99vfckL71CSCD0XqS7YkGwgGLvrqK4Kru4rmXVtaJiWWWtC+IqupZ17QjSuxBAekJNCCGQnrzkJS/z+yOcYe5996UAruAv5/N5nyQvc2fOnPM958yde+ec//Izfd9//z1Gjx6NSy+9FI2NjYiLi5MF5ISEBG5LLeEoOzsbGRkZYQsJEefV1dUoLy8PwxoAjpW8vDzU1NTAbrfjd7/7HZeBGs6UGBOpuLgYDQ0NqKurg81mC5N3a3ZP86uuroZWq4XD4UBWVha/RsRzJBKxorRFJdZako/SZ4k+iDAoyj0QCMDpdPLvNmzYgN27d8PpdMrmvnz5cixYsAD79++HVqtFQkJCmJxEm9Tr9YiJiUFFRUVEf9Aeao+/U/NZ4nei3kT/r5R3e/lpzb+J/avx2lY/3pIMlWMBwKeffop9+/bBbrdj1KhRSEtLQ3p6Ol8gi/2LthkIBHg8EnNZnHfeea3KSDk/0UeQTlqSE+FbDcetxeaTlV1rc1DTUWuxg2J7MBjEvn37uO+vrKxEeXk5v7ETcbl+/XoUFBRAo9FAr9ejtrYW6enpGDNmjMx2N2zYgPLychQUFCAtLQ0JCQlISEiATqfjvrSwsJD7N4qTAMIwooylnTt3Rm1tLe666y7MmTOHzzUtLQ1XX301NBoNLrvsslb9k9JPiv6K2qhhJNKajPi69tpr8dlnnwEAvvrqK6SmpuKxxx6DVqvlORHU/O6uXbuwadMmvPjii1izZg2A5rhmNBrxl7/8BWazGffdd19EOzyVuHuy6wwlhsUYTeubpKQkDB48GGPGjOF2LfItyj7S2e3W4lQkW2qvjZFNrF69Grt370ZtbS2ysrIwYsSIiPJpj79U84HKuNSWmHw2UsdN+xlOx44dw6RJk7Bo0aI2tbdYLKitrT3pJ31KEnfBe/TogZKSEhw6dKjd/cTFxQFo3t1tbGxESUkJSkpKZG3MZjO6dOmCTZs2IScnB3v37uVJVyL1V1VVxRPq2e12aDQaWK1W6HQ6/lYAUUZGBgDwDQ96qtES+Xw+1euJWrq+oaEBZrNZlrQvEtF8lESyJ6JkTyJvSUlJ2LdvHw4fPsyfDBIRBi655BL+HfFP81GSOD/lnJXzVZOhyFdhYSFqamqg1+uh1Wr5ExcxEY5I/fr1w6ZNm3D06FGMGjUKVqsVBw8ehN1uh8vl4u2WLFmiyrPIi1J2ShKxLX4nzkucn4gFkRobG1FaWorDhw/LZE80a9Ys1euUcxg+fDj/rqX5KJ+AU8IWkXci0t/w4cNVx9+0aROCwSAuueQSvP766/jTn/4En8+HLVu24OOPP+YLwEgkYikvLw+NjY04ePAgqqqqVNt3795d9rcSg2oyUNqtSDRXtX7uvvtu2Xcvv/wyn7eIcUAd19SvmuyoHyLq78iRIwgEAmhsbOT+iN6EqaioUB2jJXwp7Y/krKTGxka+SdRWIl1E8gOR5g2oz53moYbTxsZG2UJTiVm6zmKxcPmlpKRAq9UiEAhAp9Nx+fl8vlZ9lygnpW6rq6tRX18v2zghfoiUthQKhVBRUYH6+npER0er8iW2J1Lar3K+SiK+IlFLNr5r1y4UFhaivLwcjDF06dKFJ2/U6/XweDwt2qZIcXFxXE5Ayz5G5AFARNtqzZdGismt+XElKXVLpIY5JSltUsQKEV0fCoVQXl4uG0f0/2p+v7q6Gi+//DKKi4vbNSclSZKE1NRUmM1mZGZmtvm6nTt3oqKiAhaLBXq9HocPH0Z1dTX8fj/279+P6Oho6HQ6BAIBBAIBvtEVyVeJdqbmgwG5r1B+p8QK9bFp0yYcO3YMXbt2xapVq/g65vLLL8d3330Hr9crm3swGORrjc6dO6OyshIbN27EpEmT8M9//hNjxoxBUVERKioqUFhYiOjo6DbLrLW4S/9Ts1vCiogjJf7UbEmUUygUQm5uLk/mp7RrmosY65csWdLieqIlm1L6KLV1kjhvkoXNZlO1CZGU61wlrsQxlUQ8iD7oZGKXcl1wtlHHTfsZTtdeey2OHDmCUCiEH3/8EYMGDcLy5cv5a8Vilkd67ep0q1S5AUB/9+jRA5s2bQJw4tWvUyGTycSzaHbQyRHpxmAwIBQKnbJOfg0SX3Ntamo6q/FAr/cBaPFVxV+aSKZqPkLk79em07XZqNfrYbVa0dDQgMbGRjQ2Np607MnHao5XaWDHs+aezbhsC9Fr+ISX34I9dlAH/S9IEqpHEJ2qXxP7o4czZxvRK8/t9SFmsxmBQECW9bwtdLriyf+alNnb20M059OxJj9bSZSBTqdDfX09rFYroqOjWz1WcqZTR8m3M5y+//57PPPMM9i4cSMMBgO2bt0Kq9UKq9UKAPyn2+2WlVYQiRbldrsdAPgOrV6vh06ng8VigdVqRWZmJnw+HyRJ4q/XPP7442E7iDTG5s2b+XdK50C7YXa7HZIkwWAw8HOXkaiurk7mqCRJkl2j0Wg4L/RaWUJCAi8xo9FooNPp+BlNce7tIVqstofoXJLmeFkWr9fLn25HRUXBZrNBkiRMmTIFANC3b1/Y7XbcddddrY6nfBVKp9NBp9OFlboDTpxtdTqd/Nz66aLW+hLnQW3pbQcqxaKGAWW/hK/GxsaTDlw2mw2pqamIiYnhpfcA8JIper2+1TaR+GsP0bm3U7lpFMlgMCA1NRU+nw9WqxUXXHABJEmK+OYCEclUzUf8Eht9RFarFQ6Hg5enaY3awkck2xbx19DQgPLyctTU1PASkK1RJDskDNIZ5ZZwqdfrkZ6eDgD8zOD48eO5D1Rrf7Kk5JfKdAHg/tbpdHKbs9ls7fJtdIPeXnvUaDRwOBxwOBy44IILYLVaERUVhZSUFI5dwqwkSXA4HLIybyKPJ+OLW+MNkNt/S/xEIlFvJ+sfWhqL3kwiG3c4HLj88svbLQ8x7irjqVarxbx58zhmqG+NRgOTycTjbUpKSsR4czpI2Z/4t/i7iBFlDKTvaV4n6yfFsajMG8lMjPGJiYmQJIkf31MSbeyRb22vfxX7VG6qWq1W1NXVISEhoV39KIn6ffHFF/lbbOPGjeP2CzTPWSOU4TpVovPOLRHFCjFmiOVsgfA1kV6v569Ji/FbLafPyZAankT/5vf7odfrZbZENpyYmChr0xZ+WpORJEl8vaL0CTTnSDGPMAxEtiU1HpW26HA4ZL5dLNHpdrtlfbS29m+JxHhCPpD6i4RvMc+JyWTCgAED0Lt3bzz++OMnzccZQ21IVtdBvyLZbDa2a9cunv3S4XCwxMREXhaBMgE/+OCDDAB79dVX+feSojQDZbF+4IEHZFnAZ8+ezdvZbDZZSaS///3vvOwTAF7uQzpe8gMAe/rpp2X/oyy0Iq9PPPEEA5pLM0iSxD799FPO37hx4xgAXoaDMmT269ePdevWjZeei42N5WVVevXqxcxmM/v888+ZTqfjPMfGxrKXXnqJSZLEYmJimF6vZ7fccgvPIOn1enlZmdTUVGYymZjL5WLz5s1jWq2W9erVi91xxx08g2VsbCx74oknmFarZVarlXk8HjZv3jym1+tZbGws0+v1zGAwsJiYGKbVatnw4cOZ1WplH3zwAZcZZWL1er1Mp9Mxr9fL5d29e3em0+lYfHw8A8BiYmKY0+lkHo+Hud1uNm/ePKbT6XhJiyeeeILFx8czl8vFevTowSRJYp9//jmXuyRJzGw2s4yMDAaAvfnmmwxoLudB444ePZoZjUaWnZ3N+3a73czhcDC/38+SkpJ4qT+j0cji4uJY586d2Q033MDLhbz11ltMkiR26623MpPJxC6//HLWo0cPptVq2bx585gkSRyLWq2WY4XK8fTv358lJibK+gXAYmNjecbq2NhYXt6Dyp0YjUZ2/vnnczxFRUWxqKgoptFomMPhYN27d2cGg4E98MADLD4+nuufMKLVajnvbWkjjjVjxgym0+nY8OHDWVxcnExO//jHP5jBYGA6nY6df/75TKPR8Cz4drudnXPOORzXsbGx7JZbbmEA2O9+9zuWk5PDgOYSd5mZmczn88mwptVqWVZWFtPr9Vz/JGedTif76XK5mNFoZNOmTWM6nY516dKFaTQa1qtXL5aYmMhiY2O5XJOTk5lWq2XdunVjOJ6xdvLkyczj8bC0tDTmcrnYtGnTmMFg4Bin0kcajYZdddVVLCcnh+l0Opaens5iYmKYJEmsX79+zOPxML1ezzGs1+tlOKf5dO7cmfl8Po7diy66iJf8ysrK4ljxer2sX79+LCYmhnXu3JnbG/WdlJTE0tLSZCUxKSN9amoq/2706NG8SgFh1+l0yuye+nW5XMxgMLDU1FRmNBrZ5Zdfzv0IlXOjsppms5kZDAY2evRo5vP5OI6IP61Wy+c+efJkXs3D7XbLsNaSfLRaLcvIyGAmk4k98MADLDs7m0nSifKX//jHP5hOp+N+XJIktnTpUu57nE4n92tGo5HFx8ezqKgolpmZyefn8/k4du12O5cTle+hMjtimSydTsfuvfdeZrFYmN1uZ7169WLR0dEyXGq1WhYbG6uKXZ/Px31ZfHw8l0F2djaLjo5mX375JdPpdKxHjx7Mbrczo9HIYmJieIy54IILmMPhYB6Phz377LNMp9OxlJQUZjAYWHx8PLvlllt4qSOv1xtm/5H4If9vtVqZw+HgeHrhhReYTqdjs2fPZgDYxIkTVf33JZdcwvFE/nvatGnMZDJxu6CxiAetVsuioqJkbYgvg8HA5wI0ZwI3m828Coter2dxcXG89N69997LfZfJZGJ2u5198cUX/PrJkyezlJQUnhl63rx5vJ/U1FQ2fPhw5nK5wvRGPLvdbq4T8hG/+93vmMPh4DYVHR3NY74op6ysLB4vk5OT2eWXX86A5qzff/jDH3j89/l8sthM6wAxBor6U8bJtvhJwhP5SY/Hw3r16sXS0tJk8hZjPNl4fHw8W79+PQOaM32TvCVJYk888QTzeDzM4XCwrKws7ne7devG7rjjDl4mV6PRsL/85S98nXbLLbfwfgwGAzObzdwuCZM6nY517dqV6xEA/19GRgYzGAxMr9fzsmxiCUmyBb1ezxITE9mjjz7KMUKxkNZmMTExzO/38/UnYUTU30UXXcQMBgPPWk5tbDYbu/zyy5nH42EjR44MiyOJiYmyNRlh1uVyMbfbze6//37OM/ldq9XKK9EAkPldKg1MeBarWmi1WtavXz9mMpnYoEGDWGJiogxPTzzxBI+Xoi22Ne7q9XrmdDo5vslHEFYitfF6vbK1nl6vZ3a7nZe7HDduHNcFVRDR6/XsgQceYAkJCcxoNLIePXpwvZF+ac7ks/r37y+LpUrbjmRLOp0uLN6SLZKPF327JEnsiy++YD6fj+NbjIEmkylsvXzDDTfI/IlGo+E+UPQjkXwg4ZvmTPjOzMxkL7zwAhs/fjx77bXX2Pr161lKSsqvfUt3ytRx036G07hx49hf/vIXNnToUGYymVjfvn3Z0KFDuZOUhNIQRqORDR48mOn1ejZ06FDZDaNWq+VlELKzsxmEMgl/+9vfGNBcH33cuHGyciAZGRlMp9Pxmya68XA4HPz3zMxMXg5JI9QC79WrF9NqtSwtLY07qnfffZdpNBp+oyaWohPLOJhMJn6jR6XHiA9JkticOXOYRqPhtZfJ6RuNRhYbG8trVAJgn3zyCZeRJElcDrGxsXwOVMt5zpw5TKfTyfol3ulmlNp+/vnnPChQqZ158+YxjUbDPvvsM76gJZ579Oghkz9tKtDGBgUoAOzDDz+UjUU/Y2NjeVvice7cufzmlngmp3bRRRfJNnMsFgtftFP903fffZdJksTnR/MifiRJYv/9739lpfiIH7/fz8cjfpR1sWlBQAtC2uhR69doNPLfX3/9ddl8SCZxcXFcJ7RBQ9fMmTOHB3Wl/iPx3lIbcSxaSKnJacaMGTwoEn4BsPj4eGaxWHgNYuKZ5izKze/3yxYGov7nzJkTpn8lNuiniFnqm+Ty+eefczzSIo3mTN/TJsK8efNYfHw8r9ctbhApeSe+JKm5frkkSbwsF9WjF3H+5JNPMgDsv//9r0x/JC+xDWFFXCAoZUB8iWV6SAevvvoq/5twpNS/0u6VspQkKcyPiGXjqNYuYVTJnzjWrFmzImKtNfmQz/L7/TLMixgUa85ffvnlMl3Q2DSWcn7iWIRBGkvEPJWWo7Z+v5/Lm7Cmhks17EqSJPO31Oa5557jeBKxJrYRF87imCIeRdsW24g6aYkf2pijm5FnnnmGAeA4JxtR+m81PCmxK47VmpxEPyXim/CcnJzM9Ho9y83NZUDzhib5gYEDB7K+ffuyl156ievPYDDwjXbRTqOjo5nZbObzVfJDPKvpTfRdShyIciJ8U1ual/ggIpIPFPlRyi6SnFvyk2J/xDP9FOUtxnhJkvjG0Jo1axgAXh+cZJiWlsb9wZw5c3gZ1ldeeYXpdDpup4mJicxisbC0tDT+0IL68fv9bNiwYSwtLY3zTNdQLCWbJl1SmUwxDtF39Df14/F4uC1Tf927d+f2YjAYeEwWdSHqT3u8rKayzdNPP810Oh378MMPeRtlHFGuycjXeL3esLK/4lqXbs6Ufpfmp1YajTan58yZw8xmswxPynh5snGX2ijXCpHaSJIUttYT+Zk1a5bswRv99Pv9fIOWeBbjk1L/9GBNjKWnYktK2xZ1S2sywrcy/ivXy+QnI8UB5VhqPpDwLcYln8/HkpOTWW5uLktOTmZr1qxhZrP5176lO2XquGk/w2nLli0sOjqa9enTh+l0OjZ06FC+K6x0Si6XizmdTpaVlcUSEhJkbVJTU/kTcAI23SDT77TbpuyXPvTkS3zKQh9y+FFRUbKajjqdju+oOhwOZjabWZcuXZhOp+OLITEo0s2mz+fjC81nn302rIZ7cnIykySJOZ1O3o9Go+G1SseOHct3JulJGdWlFzcGqE6q0WhkHo+H73DSri0FFY1GwzcczGYz0+v17MMPP+R8mUwm/oRHkpprX9OGiSQ1v5VAwVD5ueeeeziv5ISeeOIJPhbJjdqQU05OTuZPdjp16sQkSZI9aaSPJElsxowZfNEAgA0bNowHedpwUQZkjUbDUlNTGQA2c+ZMriObzcb50Wg0XE/Jycl8EUBP9mg8eopNgZgWZp9++in/v1arZX6/nz85evnll/kcaMeWeCDc3n///Uyj0fDvMjMzucxJd6mpqVwXZrM5TJaR2uh0Ot4vjeHxeFiXLl1kciLbMxqN7LnnnpPJ/m9/+xvzer3MbDbzjbRrrrmGASfeOsjMzORPrymYiVgjXIrzokWQiA0KclRzmOQRExPDcU0LfLLjESNG8IBHuho8eLAsWA4bNozz/tRTT8n4zMzM5H/TRt7NN9/MNBoNS05OVsU5+Qmj0cg+/fRTXpOVFidU/zcuLo5ptVruy0juer2eORwOLgOyRXEO9NQXOHEzS7iijTUldkVdkCyHDRvGf8/KyuJ+hPgjHNKium/fvtwn0FtLkiSxcePG8blHR0ezmJgY2ZsxhLWW5EObAeeccw7fiPV6vVy3UVFRLCYmhr8FQDru0qULnwN94uLi+BNk0mVWVhbXpejvNBoNczqdMvzQZivJQKPRsN69e3NZ0rwIl/Smkhp2JUniN5xer5fLgDYTyD+Rjnr27MnbPPLII2H2QnIizKampnJ508JOtP9I/JD/p7m/9dZb3Nc7nU5+40t4VPpvEU/imIQ5WsCKmKOnY2Ib4oveDqOa3qQb8ovkQ+mptfjJzMxkt99+uyxmiP8X1wrR0dFs2LBhLCUlhQEI0xvxLOpE9BGPPPIIf9Il4pvkJGKVbDorK4vHcUmSuJ+l6z0eDx+L+FHGHLU42RY/SXjS6XQsOTmZ807YIXkrYzy94UN80toFALvqqqv4xodWq+X96XQ69tBDD8nshK758MMPw9Zft99+O3vrrbfC1nsU7yVJYgkJCbK3IclnkF71ej2Ps7RmEtdBqampsgdA9NYKberQmxOkC/IfMTExHCPDhg2TxU8A7O6772YA2OOPPx6GkaeeekrmQ+nGnXyNwWBgXbt2lc2b+CN/YDAYZH6X2hDWxBtJmhe9TTFs2DAZnsR4SXhqT9yVJIn16dOH41uv18swHKkN2S/FPkmS2IgRIzhGExIS2ODBg2XrdNFmRd9JbwWI62iKgfSAhmKp0rYj2RLhXIy3olyUvt1oNDK/3899g8jv888/z/Uv2pK4jiC/K/pAMZ6o+UAR3zqdjuOH/Hdubi4zmUysd+/e7KKLLvq1b+lOmTpu2s8CKi8vZ0888QS7/PLL2bhx49iDDz7IDh06xPbu3ctmzJjBb4AItLTL9eSTT/LFmRiYfT4fe+2111h6enpYcKePeIMlOgun08mSkpL461xarZb179+fvybVr18/vjgSDVbtIzpko9HI+vXrx+655x42atQo2YYC0PyqHN1gn8xH7Et5U9veT1RU1CldTxsercnnVObp8XhYz549eQBtCz/ix+fz8d1+tY+IjbZ8KMBQwFNrYzAYuBMHIFsEqemAFqnp6ekcc7/kR22jLNKHFg2xsbHMZrOxlJQUlpOTo9qH0WhkqampYQvp04E1q9XKnn76aVWZazQadt5557HevXvzIwbKNm63m2VkZLCMjAzZZpzap1+/fqxfv34nxafyphKA7OagvXpKSUnhNzXKjSydTsfMZrOqvFv6pKens0GDBjG73S7bKDoZf9LeOanJR60ftUWu8iPalVobuhFV3rQqx6FFJ4A2+Zm2flqyexFranyp+TLS+enir726a4kvtc/JxoWW+BIX/aIs6LXj9vIofpxOZ5t9xOmY5y/x6devH79JOJUPHb3R6/UsOTmZmc1m1rlzZ9kbQPRxOBzs8ccf5/9Tkx1tjp1zzjlsxIgRsqfOJD+DwcCfap4umbdFj5H6UotZOp2uRYyo2Sf1TxsHdDNKb6QpH/ooPyaTiQ0cOJD7KvEJdGtzO9W4eyof0f/pdDo2Y8YM2QOg1q6nDRbaBBGPu/4aH/IrbfHrQPNm2smuI2jTRy3GjRs3jhUXF//at3OnTB3Z488yonrtYh11i8WCVatW4a677sKGDRt4koZQKITzzjsP7777LvR6PY4dO4ZNmzbh/PPP57XXc3JyUF1djYULF6KwsFBWwxNoLiOzePFi1NXV4bzzzkN8fDxuvvlmrF69Gl26dEFdXR2WLFnCE2w0NDSgT58+ePbZZ1FVVYWCggJIkoSqqirMnTsX27Ztk/E3bNgwvP7667j//vvxzTffQK/XgzGGxsZGdO7cGYMGDcKyZcuwd+9e2f+ysrJw/vnnw2Aw8MyQtbW1sNvtMJlMYWNRf9nZ2di9ezdKS0tRWlqK+vp6Ge9paWk477zzsGTJEmzbtg06nY6PqUbdu3fHiy++iDfeeAOrV6+Gy+XCiBEjYLVaZTVTV61ahZqaGgwePBhmsxmhUAh5eXnYtGkT6urqMGDAACQlJeHpp5/GihUrUFFRwWtCk6yysrJw3XXXwW63h8mTHU98k5ycjEmTJuGmm25CWVkZ3n33XXz77beoqqriJVK0Wi2WLVuGurq6iNlVDQYDGhoaEBMTA6A5ucsll1yCb7/9Frm5ubKkJFlZWbj00kvx6aefhuk3OTkZ55xzDvx+P+Lj47Ft2zYsX76c13a22Wy48sorsWzZMqxYsULGT3JyMh5//HEsXrwYH3/8MWpqatDU1ASdTgdJkngZPUlI1GM2m5Geno7JkyfD6/Xi6NGjPGmP1+vFnDlzsHXrVrhcLlx22WUttjGbzRg9ejQGDBiAf/zjH1ixYgUfjzGG9PR0PPzww+jevTuefvppLFu2DDabDX/729/w5ptv4vvvv5fJlK7zer0wGAyora0NKwPWEmVmZuLGG2/kCSWBE/XHqTYp4WLr1q0R+8nOzobNZsPatWtlfEVHR0OSJNTU1KC6ujoiNiRJQvfu3eF0OrF27dqIOMrOzsaDDz4Im80mw7nNZsPVV1+NoqIiAM2JaxobG+H1eqHRaBAXF4fJkyfjtddew8GDB2V9pqamwmAwYNeuXTzxTUNDA+Lj43HVVVehT58++Pzzz7F27VrU19ejqakJkiTBaDTi0KFDqKurU50P1ZD97rvvsGfPnlbtHmjOaBwVFQWTyYTa2lowxuDz+dCvXz9otVo0NDQgOTkZkiTxuWs0Grz66qvYsWMHoqOjYbPZsGfPHo61c889N6J8oqKiUFlZibq6Opkv7N27N+6++2588MEH2L59OxISEvDXv/4VtbW1KCwsRGNjI7RaLdxuN55//nls2LCBy66xsRGdOnVCQ0MD9u7dC51Oh1AoFDFxVpcuXfDggw/ik08+weLFi1FVVRWW8FL0zYRLNSLsBoNBfPPNNzJ/GwqFkJKSgtGjRyM6Opq32bp1a7syQtM8Q6EQunfvjqioKOzevVtm/63xAzRjjDJ2a49XhAiFQkhPT8eFF16IkSNHhvnvqqoq1coroh/fs2cPPvvsM4450onYhviiUkgUK/7yl79g3bp1CAaDqKiogCRJPIFVt27d8MYbb0CSJEydOlW2LmhsbETfvn3xwgsv4MiRI9i6dStycnIwceJE5ObmYsaMGdiyZQuioqLCZASA85yfn9+iLqTjie+UchLxLR1PihUKhdC7d28899xzePnll/Hdd9+hrq5OJpOuXbvi2muv5f4v0ppClJ1St2p+Um0OaWlpGDVqFKKjo2WxWRnj9Xo9vF4vysrKkJOTg6FDh2LSpElYvHhxi7jUarU8UZ0kSdDpdGhoaEB2djZmz54NvV4v05skSWhsbMR5552HG2+8EYcOHYLJZEJ9fT2WLl2K7du3o7q6GkePHuWyevzxx/Haa69h7dq18Pv9ePrpp/HJJ5/g448/RkNDA/x+PyZOnIj09HSUlJTAZDKhoqICNTU1iI2NRXR0NBYsWIDVq1fL/FN5eTnuu+8+Xl5Wq9VyP0kJzYLBIK/L3hKJa7KKigowxmC32zF69GiMGTMGkiThnXfewcaNGxEVFYXrr78eOp0OmzZt4usI8ruZmZloamqCy+VCTk4Otm7dikWLFqGyspL7TREnIp6qqqrwzjvvYOfOnWE8tiXu0hpCxAqtB8aNG4fMzEzVNuRDqXwk+fScnBxIkoTNmzfL1jd2ux29e/fG1VdfjYaGBhmORZzExsbyCkJarZZXjaGKA7GxsTLbjmRLnTp1giRJYfE2LS0Nl1xyCdLS0lT1WlZWhvfffx/bt2+HXq9HU1MTj1XPPfecbL3cv39/LFq0SNWfkL+keKLmAwnf06ZNw5dffomlS5eioaEBVquVJwJ88sknMXLkyBaxeLZQx037WUDl5eX44Ycf8Mgjj2Dbtm0ATiy0hw4dCpvNxmth79+/H/n5+dBoNHj33XcRExODl156CevXr+e1EHv27Inc3FwAwA033IC33noLN910E8xmMy6++GLs3bsXeXl53NGVlJQgMTERgUAAP/30E7Zv3w7GGP75z39Cq9Vi5syZqKysREVFBUpLSyFJEp599llER0dj8eLFfLEING8C7NixA9XV1airq0NDQwPy8vKwe/du/PDDD6ipqVGVAf3v5ZdfRlJSEt555x0AwMKFC7Fw4UIcOXIkLOPmjBkzsGPHDgDNi03aiBCJ+FFro/wfjVdQUBC2uaFGeXl52Lp1Kz799FPMmzePl9wCgClTpiA7OxuFhYWIj4/HjBkz2sWb2Gb+/PnYsGGDrJbnpZdeCrvdDqvV2mr/hYWFAID4+HhZfdtTlVlZWRl27typqhvSn9pcqCqBGCTpGjWdtCaj00WR5l1bW4u77roLc+bM4e3S0tJw9dVXQ6PRYNCgQQCa5RtJXqIOTgZrkXgtLCzkCwy1Dbn//Oc/eP7551FSUhJWnkiSJPz973+X9dvaHILBIL788kv8+OOPMlncddddYThsK77V2rTl2tbk0tp8qG8ArV5D1JI/UsN8W3hVzlHtezUM+v1+9O3bFzt37uQLLxGXl112WcR+yQ+0Zc4nqwu1ftpq/2o+S82GToUvNV+2e/dulJWVAWiu0OF0OiPqtS1YUxvrVHhtamqC2WyG1WqV4e/gwYMwGAx444038OOPP4Ixxjdam5qacP/99+PZZ59VtdPWxqT5EZ2OONIemZyK7NqjIyVF8vt33XUXDAYDMjIyUFBQwG/s4uPj+Ub0Z599BqAZ0xaLBffeey8KCwuh0Wh4P7fffjuWL1/O11vvvvsu0tPT8cILLyAqKgpXXXUVAOCcc85p83yV/unIkSNYsmSJ6rqLNqZakx0QORa3hJGW5Lx69WpMmTIF+/fvD/OjkiTxTRGae1vmRfFNkiTs2LEjIiZPJe6eLLXm6yPZNdAsg9Ppg08l3ipt4rvvvkNNTQ3eeOMNZGZm8vuAlsY+GVv8/0QdN+1nOP33v//FVVddhaqqKtkTRgqKtAtHT5xp17axsTFs93jMmDH44Ycf+N8mkwl+vx9utxt79uxp81M/2j2XjpdTCAQCYW2MRiMYY8jKyuJPlYLBIKKionD48GGUlpZGLGths9kQCASQkJCA4cOH44MPPsDVV18NrVYLo9GI999/H9nZ2di6dSsqKiqg0+lgNpvR0NAAg8EAg8GAxsZGpKWlIRgMwu1248CBA/B4PHA4HCgvL4ckSRg8eDAqKirQ1NSE/fv3o6CgAC6XC2VlZQgGg/zpY3R0NCorKzFs2DAAzbuSe/bs4bu5JSUlcDgc/GlHcXExSktLeT1RqhldXl6OlJQUFBQUID09HUePHkVcXBx2796N6Oho1NbWIisrCxUVFTAajQgGgwiFQqioqIDb7UZZWRn/GQgEYDabUVpaipqaGuh0Omi1Wni9Xhw+fBiZmZmor69H//798eWXX+Lcc89FSUkJDh8+zMsDZmZmwmKxgDGGPXv2oF+/fggGg6irq8Pu3btRUlKCq666Cnv37sXq1atRUlLCn773798fubm5yM7ORkFBAY4ePcrlFhUVhQMHDqCyshIWiwXR0dG89FZycjKqqqowatQo5OXlobi4mD+tA4AjR44gOzsbMTExOHLkCI4cOQKTyQS73Y6+ffuisrISdrsdhw4dQkVFBebPn4+FCxfi+++/R+fOnVFaWor169ejuroa1dXVCAQCMBqNqKyshNFohMFggM/nw+HDh+H1elttQ7qvr6/Hueeei8LCQng8HhQVFaGmpgalpaU4cuQIdDod4uPjkZeXh169ekGSJK6Lt99+GyaTCStXrsTGjRsRExODVatW4cCBA+jTpw98Ph+Ki4txzz33YN26dThw4ADHDmEtMzMTO3fu5HIOBALQ6/Worq6G0WhEXV0dTCYT6urq+EYNAAwfPhwAcO+99+KLL77Arl27uN307dsXH330EaKjo9GzZ09MnToVq1atwk8//QSDwQCr1cpLLL7wwgsoKCjAhx9+iIULF6KoqAgOhwOBQABVVVU455xzYLPZ8P3336OqqgrDhg3D/Pnz0bdvX/7Et6amRobzQCCA1NRUHD58GJWVlXA4HOjduzdWr16NmpoaeL1e1NbW4v7770deXh42btyIoqIi/gQ9GAzC4XCgoKAAHo8HpaWlvJZvdHQ0Ro0axW1p27Zt8Pv9+POf/4xgMIgjR47A6/Vi3bp1+Pnnn7Fp0yYUFBSgvr6e231FRQViYmK43ZNddOvWDSkpKdi3bx+0Wi2OHj0Kl8uFxYsXY9OmTbBYLPxJO9UVNhgMcLlcqK2tRadOnXDo0CEYDAa43W7U1dXJsNaSfAYPHoyCggI0NTVxP0NvMjQ2NiIxMRH5+fno0aMH9u/fj9raWoRCIf5kLT4+HqWlpSgvL0fPnj1x9OhR+Hw+VFZWIhgMory8HDExMejbty9ee+01bNiwAaFQCOvWrcOuXbv4xqDdbofH40FqairOP/98pKSk4JNPPkFRURHy8vJQUFCA2tpaGS5NJhOvt6zErtVqRXV1NWpqauD3+2E0GmE2m3Hs2DHU19cjGAzC6XSCMcbjQlVVFXr16qVqL+TLqqqqsHPnThw4cAAul4v7aaX9q/FDOKipqcHevXvh9/thtVrR2NiImpoa2Gw2VFdXIyEhAaWlpar+m55a9e7dO8yOS0pKUF1dzX0wYc7tdsPn88naEF9msxl1dXUwGo3IyspCVVUV/19sbCwWL17MMawk4jMhIQG7d++GxWJBQkIC8vLyYLfb0a1bN+zcuRONjY3o1asXDh48iOrqajQ0NITpjXimsmPDhw/nPuKLL77AgQMHcOzYMezZs4f7LK/XK5NTIBBAYmIijhw5wn2p2+3mfoX+V1VVpRr76CfFnEhxsq1+sqqqCikpKViyZAmKi4tRVlaGuro6mbwpxh89ehTHjh3juCwvL0dmZiYSEhKwb98+mEwmbNmyBRs2bEBMTAwYY/jiiy/wzjvv4ODBgxgxYgQ+++wzXH311ZAkCV988QXH1cSJE3H06FH89NNPqKmpwfDhw7Fw4cKIbzUMGTIEhYWF6NGjB7p164Y9e/Zgx44dqKurg8/nQ1VVFbRaLXbv3o3KykpER0cjLS0NxcXF/E1Io9GI+Ph4VFVVwePxoKysDE6nEx6Ph+M5EAigtLQUVVVVyMjIgCRJSE5OxpEjR1BfX49hw4ahrq4OW7ZswcGDB3HxxRdDq9XiyJEjsFgssNlsYXGkuLhYtibr3r07tm/fji1btvASvk1NTaipqVGd+7Rp02R+l95YqK+vh06nQ2xsLF555RVkZGTg559/xpYtW3Do0CHs3btXFksJR4QHNXttDU9msxlmsxm1tbVIS0vD4cOHYTQauQ1FaiOW4qyoqIDX64XP50NFRQVycnKwZcsWbN++HbW1tapr5sTERASDQcTExKC8vBxerxcOhwO9evWCVqtFRUUFNBoNduzYAZfLhWPHjuHIkSNhth3JlmJiYsLiLa2TA4GAzLeXlJQgFArBZrOhoqICWVlZGDRoENasWYOioiL07NkzbL1Mb4eI/qR3797o1auXLDZTPFHzgVqtFsXFxXC73fB4PIiOjobD4YDRaERFRQXHH61lzmo6fW/ad9AvQZ06dWLTpk1j0dHRLDc3l8XExDCz2cxLtVAyLCrpER0dzc+vKDM1UoKp++67T5ZMSu2cDPVBZcLEM0diaRCbzcYGDhzIALCrr76aXXrppQxAi+e0xI+YAfSRRx7h5ZDo/A6dLaKzd1S2rqWPWuZQ5Yfm05azmCQftTP+kf5u7UNyUcqH+mnr+R/lnCi/ASWjEvlS8khJSkR9K8+WqZ3FU/bX0nkp6o/aivkX1D5er5eX+RP5FUt6KPsXk921V2bt/UTSi5r+qZwclfohPpXJZOgMMXACuy1hrS0fUTfUtzILL31PfkB3vBwhJX2hM4RWq1X1jJ84BiWFEftrC39qslU7p60mu9Y+5CvE87zdu3dnvXv3Dqtm0Fo/ynEJa/STbEnNFk5Ff8oxSTeRrlP6PrX5KTGshmkqn0hjqemUkuxRib7TlVeiLXYsxjjlvMXkoKeDH/pQskhxDKW+W/LfbfGXyjm0BSNqeQxIhkqbV/IW6Zxse86mA5D5iEj5F9R4P9m5n65Pe3TSFjumfvR6PRs7dqysig3J3Ww289/JzyvlraZTSpZHfk3NTpTxWo1nSlim9P8tzVkNz0qe1fySzWbj8SFSHFHOWS3Gd+vWjSeIBU6cOW/J71IysjvuuIMNHTpUloj3dOn7l/qoyZvy+ERaO6rJUm29/GvMSxnb28LDyeZVEHEtSRJPQup0OtnIkSN/7Vu6U6aOm/YznCwWC8vPz+f12m02G7NYLMxsNjOLxcLr9v79739nAGSJvJQGTIk73nvvPQ54SZLYXXfdxduaTCY2YsQIHljy8/OZVqvlN+i0gLZYLDwLalJSEgNO1O4EmoOHXq/n9cIpUYrSEKn+r3Q8CybQXAqN/k8Z65WLNAo0Gs2J2qTEM5WNULuJoCypVBue/ie2oQ0QtZv1SI6DEn1ddtllMr4A8AzstIkiSSfK2lC2WMrOSRlOxYWPeMNCY1GSLZEHSlojSRLPOHrllVdyp0nJpcRM/605RRpj/Pjx/DvlDYvaAla8UUpISGA+n49ptVrWvXt3JkkSl5NWq+VZvam98kZBr9fLyse1phO6nnRCtaUlSeI30D6fr9U2lCU8EnbFYETyFucj1olVBpXWFv1twVpqamoYz5QltqUbFuXYNE+DwcDx2JbgSnaiXBiI15C9UQkbJXbFmwb6nUrOqbVRzkG0W6ocQeXoqB8Ru5EWa7RxKOK6LRsFhDVK6kkVD1JTU3nVjLS0NFnmbLHWOW1Gkg5ako9ykU3YE31hfHw8v7kHTmQ8lySJTZkyRXadMomcmJQs0keUyXXXXSf7n9I3i7ikcntq2CW+6Bqlr9fr9eyNN96Q6aY9HzX/r7R/NX5EXCrxQ3KgMokt+e9I9peamhq24ai8iRT5oqzlJEu32x02lpg8NCkpiQ0aNIgBCPOxNHej0chjBm2MAs1lvwhHSr0Rz21J5KjEcVvsn/ytmDxTvHkU5Szas1qcVMqwPX6S/IkSuxS7ALA77riD29PAgQO5vFv6qNmYyEdsbCzvR7npLiZypZgj+hO6USWeaM1HPpB8xA033MAx98477zCNprlSDGWlpw1nwjX5UiVm1eYi2ltbNvKUNkljUWLAQYMGsczMTDZlyhT+wKh79+5Mr9eH+d2kpCReKviaa65hNpuNr1PFRIviBoH2eN3x1nTWEp4o5ijbiD5erU2kzRplGT76UGk9slHt8Zrk4v9FGyBZiustWgeKth3JlpSbHGq+VGkfVHZa9GtijFJbL7fkT8R4ouYDRXwTdsUHEB999BFLTEzk9drPduq4aT/DaeLEiWz+/Pm8Xvu4ceOYXq9n5557Ls/efu6553Lw3nbbbdx4aQFET4ooMIglYbRaLa97qNFo2OjRo9kzzzzD28+fP58BYF9//TWv4W4ymZjRaOQ31AMHDmSSJLE777yT39hTeTkqRUI371QzmUo1ZWVlMZ/PxywWC69f/vrrr7NBgwYxSZL47iI5MQpGAwYM4DegkiTxesaSJLFu3boxo9HI5/vmm2/y+VEZE+WTdmqj1WpZXFycrKwYBQHaVCDZ0oLNYDDwfv75z3/yfokf5c448UUOVKvV8u+on6uvvpo7LNqlprGVeqRyUX/4wx/4NTTmhAkTuIMV+wfAy9DQ3Gku4pNNkjfNi+Ys1vel74gfGp+c7V//+lfOD83jgw8+kDl+UcfUZvTo0Zzn7t27ywIG6YQWNxSsxE0JZZ1uUZbEe1vaEHZJTiRLcSyl3YkbKDQfkiVhmwKnuPihYBYJa6L+iWfCmtVq5RgjnmnThhb3hDnKKguc2OjLyclhsbGxsoBLchZ5p/7i4+P5IlHEFt3Mk72J86cxiS/lk1JxUaJsI9qR0rapHI2ISyXWSM7iQkj0J/Q/wrfyKbroR+hmh/qiuV977bVcNyKO7HZ7GM80LzU8qslHaSckJ+JdLCFH8+vTpw/HNZUDojlQO5of4Un0q0o/MGDAAJn/FmVJ/VEbEZfkC9WwS3zR9XQd2b/NZmPdunVTxZq4gBbrjos3Lkr/35L9i/xQG3p7LDk5WYYxim+iTSr9t+gvSW7EF40pYk70qZFsnNqQ/mksSWoulUY+5K9//Svr2rUrA5rjt1jxAAAbOnSobAOPSj9qtVpmsVhkb6oo5US6Fysz0Fxpk1pp/6KclPimNgaDgfscZSwVcamMgS3Fybb4SdIb+TfSqyhvZYzXaDTM4XBw+4mOjubyTkpKkr2hKPrbjIyMML+flJTE295zzz28n9TUVH4zTjZBN5qkH6U/ETdRCSPEs3ijTm3oxvePf/wj9x8kY/qd+lFiVvQ1SnuTpObNSDV/K8YRsltqQ7/Txsptt93GJElib7/9Nv+/1WrlD69Ev/vAAw9w/nTH65hTfKPr6YGXiCfCAeGpvXFX6d+Ua4WW2ojrFcKDMuaQ3x49ejT/nbLDK22A+hdtT1xviRhpzZYIp2rxVvSlYj833nijqu8j3Kqtl0V/ovSBkeKJGr5Jb+THAbDvv/+eGY1GXq/9bKfmgxQddEbRF198wT8XXHABpk+fjpSUFLzwwgvYsmULGhoasGzZMtTX1yMUCuGnn35CWVkZXC4X3nvvPQDgZ7KbmppQXV3NfweATz75RDbe5MmTAQCMMezfvx+PPfYYGGOor6/HLbfcAgD405/+hMbGRjQ2NqKurg719fXYvn07AGDNmjXQaDR4++23+fn2YDDIz+DExsZi3759AID3338fQHMGyoaGBmzfvh1Hjx5FbW0tT7L3+9//HqtWrQJjDCUlJWhsbORnnulnU1MTz0jJGMNrr70G1rwJhe3bt8NkMvGs8JQ4SMxyShmV6cwhJSxxuVwoKiri59AA8AzW11xzDQDwTJx+v5/Plc7+rl+/nmfEZYzx8080pnQ8kzTxQ2fEiVfqh7J6SsfPsbndbj5/ksGBAwd4vw0NDXjllVc4PzTGN998AwCwWq2y7MIAsHfvXtncY2Ji0NDQAJPJxOVEyaBWr17NeWbHE+oxxqDVavn5RuInFAohEAjwPp555hmeRZbGJzxQpmrCGwDOO8kiGAxi27Zt8Hq9PIcD6eSKK67g/Wo0Gvj9fq5bkimNReO43W7Oe1va0Fg0H4vFAkmSEBMTw7+bO3cub8OOZ79uamqCxWLh59VIlldccQVP9EbzJKzR2Vwl1mJjY7m8iOeCggLOD/FM/BDPQ4YM4WPQueaGhgY0NTVxOVPywi1btqCoqIjrqrGxkfdDvE+cOJHj4NChQzIZkL4IBxqNBg0NDfz/Is5HjRrF5U3yofmRXKgN2ZOYmIz6Iew6nU4uO5Il9bt7927Z33q9no9BfY4cORKMMTgcDs4T8U39kh+hc5NUYUHk+6OPPgIAvPvuu1zH9JN4pgy+hFk1PKrJh+ZFPouy+RLvDQ0NYRnvf/rpJ273DQ0NfN4mk0lmX8AJGyC9WSwW3pfVagUAfr4faPbhGo2G90m8U5ZeEZdkV0rsEt+Uk4X4YYzBYrFwOW3fvl0Va/fddx8YYzyPCdkLjS/qjfy/mrxFWyJ+qB+yE8YYzzNCetEcz3weyX9TRmjSYSgU4nzRmCLmlLwrbdzlcvE2NCb5VL1ej7KyMp775pVXXkF+fj4AYNmyZXxuNPfly5fza3U6Hf7yl78AAHw+HwwGA+x2O8evUk4Oh4Pn1hFjBWMM9913H+eH5E1zV8O3JElwuVxc9zTG+vXrZfIh3y7yk5mZCUA9TrbHT5LeaC3kcrkQDAZl8hZjPNCce6eyshJEx44d42uiBx54gFc60Wg0PNM7xROlbzhw4ADMZjMA4I033uBrITpzTnrbv38/QqEQPB4PH5f8CWHIZrNxm6R50jle+vvGG2/k1xNGnn32WTDGEAgEwBjj54bFWEWy9Pl8su8BcP7JJ/v9fhQVFXE9AOpxRFmhg+yNxvrHP/4Bxhhuuukm/v/Gxka+/hX97lNPPQUAPO7U19dzv3bzzTcDAM97IuKJcEB4am/cVfo30U9JktRiG7Iz0f5JBhS7yHefd9553O/SWkxpA0TBYJD7HZIBrQPVbFvNlpS+RlwnNzQ0qM6L1vjUD8WXmJgYWCyWsPUyIPcnNKYYm0V5q/lAWp8C4Pc6NpsNOp0Oq1atQlRUFADwZNxnNbXp1r6D/qdEO1fKD9C+1wKVrxKqvb78S38sFkuL9eAjfSRJYhdddBEDmp9w0JMTm83Gd+TE9rQrR99brVb+pNNiscjOepE8MzIyeBufz8fMZjPfrRaf7NMrSPTqIb2Wk5iYyPu02+38qQO95iXyRvIWz//6/X5mtVp5DU7qh55wES9Go5HXhhb1RjvBOL5TSU+tRXnceeedfEeZvpOkE7kCNBoN57d///6ynV9Jkni+AvH1KbPZzJ8kJyUlcVmJOFU+hSO90CtqsbGxYXWBaQySOb0uRbu9VH+U2gCQvY6YmJjIX3NzOp28nfjEw2w2cyy0pY346mlsbCx/QqnX62Wvc3Xq1En1LF5SUhKz2+1Mr9fzpyciz6QbjUbDLBYL32EXseZwOLgeaP7Er5j/gXbgxSctCQkJTKvVcvyImKVjKQkJCUySJHb99ddzuUiSxOudmkwm1q1bNwaceHWRPiQDekJuMBjYX/7ylzCb1Gg0MpxnZGSEPYWg/xPOyG9otVrm8/m4bYhtfD6f7MmZOC7xJj5VoCfEOp2OWSwWPi96U0m0T1Hn5MsIK8rXEsWnYaKtizIQbZxw5XQ6ZVhrST7kA+kJP+mU7EhZD9dgMLDY2Niwozb09pXFYlE9p03tCIMWi4XjT3wiJr65QE+vzGYzl6USl2azOQy7ou0r8U1vmyhfGSXdAWAzZswIwxr5D/GNBNFHKe1faUtKWajlP9BqtczlcoUdIxH9t/iav+54zXvxDQcaT8Qc2YnYRrRx0ce0t656VFQUtwXyM4Qn8anp0KFDeU4LNb2J9kH8iD5ixowZsjaEU1FOdKyP9CC+AUBvjpHfoPHJd9HfpBPCkTJOttVPEp4kSWKTJ0/mfkKcH82D+hKfxIpHG2gO33//Pf9fTEwMj7FarZYfm6OYTD4pJyfnpNZl4jEsynVEf6sdJxHfEDIYDPztD+3x/CWEXYobop2IvpW+k6Tm18TJrrxeLwNOvCknPnEV44hyLaPRaNpdH13N74pPYUlH0dHRLDY2lul0Opadnc2sVqsMT3QdPXk/mbgr+o/Y2Fj+5JzeJlBrQ32K8m1LniXxI661yKbIB1MM9Pv9fC1M9tUWWxLnDiBsnazsR/Qbok04HA6ZzYu2JK4tyR8ZDIaw2BzJB4rra5ozrSe6du3KjEYjGzRoEOvduzcbPXr0r317d8rUkT3+LKc9e/aguroaDz/8MMaMGYOff/4Zn3zyCWpra9G7d29s2bIFwWAQKSkpiI2NRa9evaDT6bBnzx4cOXIEMTExuPXWWzFw4EDcfffd+Pzzz9HY2IiePXvigQcewHnnnYdDhw6hf//+KCoq4ruPlAHy0UcfxdSpU3H//ffjP//5D8aPH4+vv/4aHo8HL7zwAl566SWsXbsWRUVFMJvNPNt8XV0dOnXqhJ07d6KpqQl//etfMWPGDNx88834/vvvcdttt+Hjjz/Gzp074fV60a1bN1itVvz0008YPHgwvvnmGzQ0NMDn8/FM9H369MEf/vAH/OEPf+C72lR3VKfT8R0/oHkXUJIkeDwe1NfXo7GxEZMmTcLnn3+OyspKGAwGeDwe1NTUoKamhmd5rqurA2OMZ7inPulJptvtRnR0NKqrq1FcXIxQKAS3241LL70UtbW1WLt2LRISEvDII4/AYDBg9uzZ+Pjjj3mdZ6oK4HA4eKb9+vp6nvm3oaEBXq8Xx44dg8Vi4RnKA4EAOnXqBMYYH1esBiDuwopPHOl3o9HIa7nTmwEAeCUCyoINnKgeYDAYcPXVV+Ozzz7j2UbtdjtKSkoQDAaRnp6Ow4cP83rF4o66/njtTnqqBzQ//aP6rn6/nz8BFikqKgrl5eWyGu00L8rmrNfrkZCQwHenS0pKeEZl4t3j8cDpdLbYxuv1oq6uju8uU0ZonU6Hrl27YtOmTXxsyryq1Wq5nOjpisFg4DVwlTzT7waDAZmZmbzeKmWmZcefOOr1elRWVvK6wFR/XK/Xo76+HtXV1fwJoN1uR3V1NbcB6lc6XlNX5E+sW066Tk9PR0NDA8/GnpCQwJ+YiE91iKged1NTE1JTU5Gfnw+fz4eamhoEg0H069cPUVFR+OabbzjOqT0T3gCi8ZWk0WjQ1NSEmJgYXlIyOjoa5eXlCIVCuPbaa/HOO++0WhNYJJL3zp07+VO1qqoqjgl62jR8+HAsX75cxpdaBl+qiRsVFQWr1cqfUiUmJobNneYjzpmw1pJ8CCs+n4+/qeR0Onk9d8Kb0WjEkCFDMHXqVHz77bdYtGgRamtrUVFRgfT0dCQnJ2Pp0qWor6/HxIkT8e9//5vjnvBAfEmSxLOKS5LEn4aLRE9U9Xo9xo8fjx9++AH19fVwuVwcl06nk8tIid2SkhJotVqeqT0QCGDcuHHYtm0bnE4nYmNj8dVXX/En2yQHnU7HsznT20YOh4NnwG5qakJlZSVvK/p/0f4j8UP+PxQK8WoWTU1N8Pl8CIVCuPDCC/Hxxx+jvLycP20S/Te9CdbY2AiLxYJAIICoqCgEAgHU1tbC5/OhvLycxw6q1XzJJZdwvPh8Ps5XbW0tlyfpW7RfwlVsbCzPDO1wOHDBBRfg8OHDWLduHWpra5GUlIQ9e/bA6XRiyZIlePbZZ/HRRx8hGAzy+ZWUlMBgMMDr9UKv18v0RjyTbAFwH0FPPql2dX19PVJSUlBeXs7bi/imvkXfQk8cPR4PQqEQ6urqkJKSwus4x8bGIhQK8RhIMUctTrbFTwLN/iw+Ph779+/n8Zv+R/IWYzxVgggEAgiFQnA4HDybNjv+lLKsrAySJMHhcCAYDCIQCPC3xY4dOwa9Xo9rr70Wn376KQKBAKZPn45XXnkFdXV1vJZ9cXExvvnmG9TV1WH8+PFYv349vF4vtFot1q1bp+ovRVJiRKTevXtj5syZmD9/PvcRFosFZWVlKC8vR2NjI3+Twuv1oqqqiscknU6HUCjE1w/Dhw9Hbm4uSktLw/BINttaHCFMkGxpLOKBKjpUVVXxa0S/63A4cODAAR7HyU8Qjz179kROTg5++OEHeDwe7Nixg+OJ3ui02+1obGzkFRLaGnfFagUiz06nk/sAtTbBYJC/GVFbWwu9Xg+fz8ef/ItrBYvFgtraWthsNrz55pv44IMPsGDBAlgsFrhcLuzbt6/FEn0AuN6Uth3JlgoLC8PiLa2TKYO+6Nu1x2vCU9Ufmj/QvG6ktztFW6I1EvkHvV6PtLQ05OXl8dhM8aQ1HyiSwWDg/szr9SIzMxMvvPACkpOTW5TRmU4dN+1nEW3duhUHDx7E/v37eR11xhiqq6vRs2dPBINBTJ06FUuXLsWsWbOwe/duxMTEYMqUKTCbzUhPT+clVPbs2cOvHzp0KB/j2muvRUFBAeLi4nDo0CHExcVBo9GgoKAAe/fuxZo1a7Bjxw74fD74fD5eoquhoQELFizA2rVrERUVhSuvvBI+n4/3O3ToUFRXV6N79+6oqanBfffdh5UrV/KasMFgEKNHj0YgEIDb7UZaWho6deqEESNGcAdSX1+PDz74ALt370b//v0jGiBtZIhjLViwAHa7HTk5OXC73Vwet956q4yfTp064Z577oHT6eTX33LLLVi5ciUyMjLwyiuvYObMmXxzIysrCxdeeCEMBgN69+6NMWPGhPHT1NSEvLw8HD58GAcPHkRZWRl3xD169ADQ7NA2bdqE6upqxMbGokePHmGy6tSpE5+z2hxXrFiB2NhY3HrrrSguLkZeXh727t0LrVaLAQMG8HJ4+/fvR3p6OsaMGYOSkhK8++67PGjb7XZ07twZgUAAW7duhcfjwYwZM3DVVVfho48+wqZNm+B0OpGVlYWvvvoqosyUPBcUFGDTpk34+eefodPpkJCQwOUVqV+Px4NOnTrh6NGjMBgMGD16NNfXhAkTsGnTJsTExOCCCy7AihUrkJeXh4yMDMybNy8MFytWrODyjaSnSG1amveUKVNQXFyMyspK+P1+ZGRkYOHChdi9ezcPGMFgEMuXL+ebS1FRURg5ciRfIMTHx2Pbtm1Yvnw5KioqwBhDly5dwrA2ePBgzJ49u8WgQ7iw2WzIzc3FBx98gO3bt6O6upqXN0xNTcXQoUORlJSErKwsvP3221i3bh0OHz6MBx54AJMmTYLNZkNJSQnfdKMFdkNDA1+kDBo0CL169ZLhaPny5aipqYFGo0FCQgLuvPNOfoyEcL5w4UKUlZXhggsuwKBBg3DVVVdh3bp1HGspKSlYuHAhtm7dipiYGERHR2P16tU4cOAA4uLicM899+C8884LwxnpgjDW2NjIf+7Zs4eXsxkyZAiXd21tLYxGI7Kzs1Xtft26dUhPT8ftt9+Ob7/9Ft9//z0qKyv5ps6gQYPgdrtleI5EIr7IFpVYW7FiRUT52Gw2XH/99XjggQdkc/d4PBgzZgx0Oh3HIN3oNzU1obCwEMnJySgoKEAgEEB6ejoCgQA+++wzrFy5UibT9957Dy+++CIOHjyIuLg4dOvWDZs2beJyiomJ4TZZUVEBv9+Pnj17htlFexZHar4skr8jXIo+izZH4uPjsWnTJl4GtHfv3njiiSfw0ksvcf8/btw4jB49ukU9qfGzePFiJCQk4O2334bP54vo30T/LfKqxFpLfrw1GYo4io2N5SWxSktLuZ3Q9aFQSNb/vffei8WLF8Pv9+P3v/89QqEQj0cajQZ5eXkIBAK47LLLIspIqQvRR7Djxx0ojthsNmzZskUmJyW+lTiuqqqKGJtFmZyM7CLNoSUdtRQ7KLbThs6PP/6IDRs2wGAw4Nxzz8XXX3+NpUuXoqGhATabDUajEb169cKFF16IuXPn4uDBg4iNjYXJZMLOnTuRlpaGO++8E01NTbzko8vlwiOPPIKff/5Z5lNpzfDzzz/jyJEjCIVC8Pl8mDx5Msxms4xns9mMTz/9FHv27OFtlPp1OBzIzc1FWlpaxDmr+Sfyk927d8cTTzyBBx54AKtWrYLD4cAdd9yBwYMHtxhHaE2m9KHEw7333os333wT11xzDf9ObR2htA9q849//AMPP/wwHnzwwRb9y44dO5CQkID09HTZA6y2xF0122zLOiPSWs9sNqNfv35ISkoCYwxffvml6vpGaQMUK4xGI8455xxeBo9iYaQ4FcmWWoq3kWyM7ODgwYNIS0tDIBDAa6+9hp9//hmJiYkYM2aMbL3cHluMJGcR342NjUhNTW1TTD4bqeOm/Syh//73vxg/fnzY97QTZzQa0dTUBKPRiJqaGn7+g4KouNul3I0Td7sPHTqEpKQkvPLKK7jrrrvw4IMPorKyErNmzcLIkSOxYMEC/uQVaD43Y7fb+cJBOn5ehpwy7ZpPnToVdXV1+N3vfocdO3Zg27ZtuO+++zB48GDMmzcPV111FTZt2oS0tDTYbDZccsklmD9/Pn9aQDuc9GTkkUcewbJly+ByufDnP/8Zx44dw2effYaamhp069YNhw8fxrnnnouYmBg8+eST2L59O9xuN0pKSlBaWoq6ujqEQiGMGzcOABAXF4effvoJmZmZ6NKlC3Jzc3H++eeja9eu+OCDD1BWVobHHnsMHo8HS5Yswdq1a7Fhwwb4/X4cPXoUW7ZsQSAQgM1mQ3FxMQYOHIhzzz0XK1euxEcffaRay16kKVOmoK6uDvn5+QgEAnC5XAgEAvjb3/6GHTt2YOPGjcjMzER5eTl/g8DpdKKurg6XXnopqqqqcMcdd6CoqEj1SSCd76EarH6/H7169YLRaMR1112HtWvXorS0FNOnT8fGjRvx/vvvo6KigterDYVCKC0tRb9+/WC321FZWYmSkhLU1tbi1ltv5TWr1XRcXFyM999/H3v37kVpaSmqq6t5PWqfzwebzYZOnTqhtrYWHo8HFosFhw4dgsfjwbZt21BVVcWfHLndbnTq1AlxcXEIBAIoKytDUVERfzJC/VVXV2PcuHGoqKhAeXk59uzZA6/Xi7KyMhw7doyfgW6tTUVFBQYNGoSmpiZUVFTwOdtsNqSlpUGj0eDQoUNYuXKl7EmeSDfccAMOHTqE3r174+DBg9i4cSOOHDkCh8MBjUaDrKwsmM1maLVajBw5Evn5+Zg+fboMa4cOHZLVBhfrj3s8HuTk5GDnzp1wOBzQ6XS49NJL0blzZxQXFyMmJgZWqxX//ve/sXDhQvj9flRVVaGkpASVlZX8ifqePXv45l9OTg7ef/99Xmc4Pj4e5eXlePzxx7Fq1SokJiaisLAQxcXF6NatG9xuN6ZOnYqdO3fi7rvvxrFjx6AWWkScB4NBxMbG4ujRo0hISMCRI0dw7NgxmM1mXluVnvaKuh01ahS37XfffRc//fQTXC4XkpOTuawo70Z9fT00Gg2CwSBMJhOA5rN1ANCvXz+MHDkSW7duRXR0tKo/aWxs5HY/e/ZsbN26Ffn5+SgsLMSxY8dQW1uLxsZGmM1m1NfXIzMzU9Vud+zYAY1Gg7q6OuTm5qKiogJ2ux21tbWwWq0yrLUkn/r6euTk5AAA0tLSsHnzZsTFxWHlypXYtm1bq0/eiCRJwoMPPojDhw9zf+nz+bBv3z4cPHgQJpOJn6uur6/HyJEjsXDhQgSDQeTn56OoqEhWD9zn8yE2NhZlZWW4+uqr+RlqEZf0xF0Nu/v27cP555+PwYMHo7i4GCaTCT/88AO+/fZbJCcny3yy2GblypWq9kK+TKPRYOrUqdi+fTsyMjJQWFiIQ4cOhdl/JH5a8v9kk6tXr+a6Vfrvl156CZ07d0ZeXl6YHTc0NGDbtm3w+/2qMUxsQ3ytXLmS58nIz89HWVkZbDYbGhoakJGRwZ+Sbd++HevWrcMnn3yCsrIy3HfffXjjjTfw6quvRqz3LFL//v1RXV0NSZIwaNCgML0Rz8FgEEeOHEFOTg73Ef/+97+Rn5+PW2+9FQsXLsSiRYvCbIDw3bVrVxQVFcFqtSIpKYnX+Rb/l5SUpBr7xBhIMUctTrbVT6ph7uuvv5bJW4zxnTp14rYMIMzf3XDDDfz3F154Af/+97+xdOlSLF26lJ9rV14nPlklEs86i/+75557sHPnTmzevBnV1dU8b4VOp+Ox3m6385wOVVVVsNvt0Gq1Mp9666234vDhw5g1axamTZuGjRs3ynRBeC4pKUGfPn2wf/9+lJWVoVu3brBYLPj5558xbNgwPPbYY9i4cSPeeecd7N69G3V1dcjJyYHRaMTRo0fx+uuvh8URi8UiW5M1NDQgMzMTJSUlPO5+/PHHOO+88/Dtt98iIyMDaWlpKCws5DFf9LvXXXcd9u3bhw0bNqCsrAyNjY3Iy8tDcnIyBg8ejP3796Nfv35hsVRcS0Wy19bwVFRUBJvNhrq6OuzatQtHjx6F0+mE0+lEenp6xDYejwc9e/bErbfeis8++wx79+5FWloaqqqqsG3bNv7WA9Cch6hHjx4IBAJh667U1FTZ3GmNVV9fz98MMBqN0Ov1iI6ODrPtSLZUV1cXFm9pnbxmzRqZb9+9ezeWLFkiy/WgxKzaevmcc86R+ZOkpCSsXLlSFpspnqj5QMI3zZNswWw2Y9y4cTAajZg6dSpfy5zVdEov13fQ/4w6derE9Ho9S05OZtOmTWM1NTWMMcY2bdrEJOlEubTBgwezCRMmtKnUhlinG8fP2+Tn5zODwcD7S05OlpV7cLlcLD4+nk2YMIFNmDCBabVa9uSTTzK32810Oh375JNPmNvt5iWM6PwWna2hzLwajYZNmDCBWSwWdt111/F+KPMknf1ZuHAhKysr43U2qXSUeA5z5MiR/KwO8azValnfvn3DzogpazenpqaGnRWnM74ej4efXQTAbr75ZtavXz/ZmSBlBu2WPnR2Tqw3Spl+6WypMsO8mC1amR2Wru3VqxdzuVwsKyuL60us0y6ecxfnmpWVxUu7kE6GDBnCJElSLScEgJ/RVp5zEvnRHa8lq9FoWEpKCtNoNBxrdK3Yp8PhYOnp6fwcFWUPprmKZ+lI7n6/n/dJ59BEnIpyoo/YD7VtqQ3xGR0dzaKiomR8K8/oi/9zuVwsJSWF/6TyfikpKbLzWF6vlzmdTuZ0OpnNZuP41mq1MqyR/qlskxLDQHiJmBEjRrAuXbqwESNGsKioKGY0GrkNpqamslGjRsnO9tI5RMJdVlYWu+eee9jYsWNZly5d2LXXXivDuHiu2Ol0srS0NH7+j863ORwOfi6a+FLinOYjnksTczmI2ZfpO7Jtpd3SeUi1c8l09pD4pvPppBvxzG1mZqasMsCdd97JevfuLdO78syr8tw1nfFWzl3tHKfIc0vyobEoo7SYlZeud7lcYVnWNcczV1MVESqPSfZDZYuofUpKCnO73SwhIYH7UjFWiGWFDAaD7FyzUu7i2exI2KUz+zExMaxr167smmuukZ0JB5p9OrXp0qULGzhwID8frNFo2EUXXcRuv/12bi9arZZNnjw5DLNKHlviR/T/kiSx999/n/3hD3+Q2SRdH8l/5+TksOzsbH4OWvSX4hlcwhxdr2wj4oh8tXhmnHgmLEiSxFwuFz8ParVauZ769+8v4/WGG26QndlVw7dSTpIksZ49e7L+/fszv9/PfYTZbOZ4MhqN3P5pLKWcxPPVlBNDrFgg4pjaiPyIMSdSnGyLnxw4cKBs/mLfJG+1GE/ydrvdTJIk5vf7WWxsLMvOzmbR0dEsOTmZn+UlWaSnp7Mrr7yS3XTTTSw7O5vnE9Bqteypp55iHo+Hx5Xs7Gx28803szvuuIP97ne/4/oG5KVx1fhSzkev1zOr1corX9D/yMZFudjtdpkfEc/ti7as1Z6ofd6vXz+uU2rTqVMnlpaWxqKiolTjiKgn0U6B5rhLazFqQ7ql3AVKv0uyJL3RWW6n0ymzL1ofiTEMABsyZEhYxaK2xF3iQ+njRZ5bapOamsrPd5PcxCoMYl4EWt/QHMTSiEp+RP3TR5mPoiVbIlyqxVuKnUrfTni4+uqrue+j75KSklTXy6I/8Xq9qrG5JR+oNlfidezYsWzChAnswQcfZNdcc82vfCd36tRx036WEC00zWYzy8/P59+PHj2a6fV69tVXXzHgRM3l888/n+l0OtavXz+m1TbXW+/UqRPT6XTs559/5tcmJSWx6dOnM5vNxqxWK8vPz5eVS8jPz+eLM7PZzD766CNeNkG5YWA2m9ngwYPZwIEDmd/vZ3q9ntdsfO655/jiAWhe1FBpNUoeFhcXxyRJYllZWcxisTC9Xs9GjhzJbzqAE7VJe/bsyRdhBoOBTZkyhTuzr776SpYgZOrUqQxoTozi9/vZlClTZPWDAXkd05EjR8qMn3gXFyx0c0el6vr27csAsFtuuYUvnmhBSzdECxcuZKNHj5bVG6W55eTkMIfDwfuhQCHebNACgZKBkZOl7+fPn88kSWJDhgxhfr+fZWdns+nTpzO/38+MRiMbPHgwmz59OpszZ47M6asl6XO5XMzhcPByKTNnzmRms5knLyO+9Ho9L81C/EhSc6kXKtExZMgQ5vV6mdfrlWGO+vjqq694QhGg+ebL6XSy8ePHM7/fz6ZPn86xRosR0gkF3VtuuYWNHj2aJ7OhxD6i/sePH89LeRHvLbWhTQsaSwxKUVFRsg0dKo04c+ZMtmnTJtl8iOeEhASm0+nY+PHjmVbbXM9dTAwnSRKbNGlSGNYoQFFiHWX9ccIaJesDTiQDEgMZ3fBS6SoaY/HixWz06NEsOjqajR07licWEvuhuYwePZrb34UXXigbg+ztqquu4m38fr9Mljk5OcxqtXK5aTQaNnjwYDZlyhRZMqInnniC3yxJksT9CMmHxhJlYDQa2UMPPcQ0Gg3zer3M7/czp9PJ5s6dyzZt2sSioqK4vClJEGG3Z8+esg0VWuiJeqe/R48ezcxmswyf5Ifz8/OZVqtVxRElX6K6wYTZtspH9J1koyLvRqORGQwGNn36dO5HFi5cyPkhndL8CEckU5of1Wam8SXpRMknmvtDDz3EYmNjWVRUFLdz0TeLPlBctKlhV0yKSW20Wi0vJSrGN8KsmABJXLSJi3aaA9m2iEel/avxQ5+PPvpItoAVfR+VXYrkv0V507WEORpTbENyUrYRExDqj9fPJtukxHXkd8XNGfL14g0o+ZOhQ4cySWpOSpqdnS2LS2RvJB+lnER9iZvCSp3QDRDZthLfND4lZcvOzpbxLOJIozmRdFEZA1uKk23xk4Qnwi7ZoyhvMcbTXKOjo7nsvV4vmzNnTliyLFpj0DpJvEki2Y0ZM4bZbDaWkJAgk0FcXBzT6XTso48+YiaTifNlNBp5nHzooYeYyWRSjfU0v5kzZzLGGFuxYgVvO3LkSCZJElu8eDGPC4QxpR+hTWs1P6JcH4ltCAtqcYR+0pqMsOfz+ZhGo2GvvvoqS05OZhMmTODzjoqKYnPnzmWjR48O87uSJLGpU6cyjUbDevToweLi4hhjjF1++eVMr9fzeEL4FvFEcxAx3Z64S3Mn3zVlyhS+Vhg8eHCLbUSfTm3IJ9OmW35+ftj6hvoVbUCj0bCHHnpIdR1Isopk22q2JG6AiHMnPtR8+8svvyzDt2hPhG/RlpQbDfQRY7O49lPzgTNnzmR+v19mC4wxZrPZ+P3SihUrfhMl3zpu2s8SmjhxIrviiivYhRdeyObPn8+/dzgc7L777mPDhw9nkiRxg/nwww/5gsNsNrP58+czi8XCzj33XH69w+FgNpuN5eXlyW7ap0+fzo2orKyMAc1PmS+88EL26quvMqPRyBhrvukfNmwYKysrY1qtll144YXMbrfzm0eq9WqxWHi9YKoXSVkmb7vtNu4QcnNzGQC2aNEiNnHiRFnwoN1lCngvv/yybIG2ZMkSbuzklJQ1KumaJUuWcOdN/VEbWtSImYKJd3JY4pNAWigRf4sWLZK16dWrF99VfOedd5jD4eC8WiwW5nK5eHZ7w/Ha9uTMxH7EhRDNi2rd0qKBalXGxcUxj8fDdevxeLgu8vLy2JAhQ7icxLnTYofmJdb5XLRoEdNqtbIxaQ70u1h7V7w2Li6OPwEUMUf9DB48WIYDl8vFXC4Xx1FeXh4POCQv0gndLC9atIg5HA7Ou1gxgOYnYo94b0sbGov0Zjabmcvl4mOJsl+0aBEbPXo0ry0r8kx6Ip7ppk180qRcGCixJuqfeBUxQm2IZ9IJZdilhajD4eALlsWLFzOHw8Hmz58ftminfkge5F9efvll3pbmSXz9+c9/VrVRkrckSbyuvdlsZjabTWa/LpeLY4KuIz9C8lHKgOZH/RgMBv7EivAjLlyoP+W8xCd74iJL6Uc0Go0Mnw6Hg1ksFpafn98q1ohHwmxb5UP8EO+0yHr55Zf5Qh4Ay8vL436E6jF/8MEHsptCkR/l/K688kr+RE304+LciZ/p06fzuYttWvNdInaJL+KN2pCdkI8grIltxAU0YY3a0LhK/9+S/Yv8EM9Lly7lYymvpzmr+W+1J8VqfLWljVKW9NYbjUU14wnbOp2O+f1+7uvJf5OP7dq1K1/wulwumQ2K9kbyUcqJsCHqhHgjnZBNKvWvxLfL5eJt4uLiZDy35gOV9d5bw1okP0ltCbtK3kXdEl9kI2KNeeJ9+vTpMn2Q3xX9I/EuSRKP12azWSaDN954g+l0Or6eGzt2LL+RpDhJelOL9YSRRYsWMcYY27dvH29L/mPx4sWqPkv0I9SPmh8hGYprKZINraVaiiOi36Z5AWDz5s1jGo2GLVu2jMvL7XZz3lvyu2SPtE41GAyyNQfpJFK8bG/cVWJOXCuQXiO1IYyIbWiDd+HChVxHDoeDb6qTjjUaTRjP1K9yHSj6aTXbVrOlSHOPZNvAiQ2QSGtF5XqZ/KTS7yqx0pIPXLRoEfN4PDJbYEx+075v3z5+73I2U0ed9jOYqFb7gw8+CL/fj++//x4AcOedd+LKK6/EjBkzUFdXh5UrV2LVqlXQaDR4+umnIUkSnnnmGeh0Orz11luoq6vDLbfcwmsqTp06FVdeeSXPavnf//6X/x4MBtGlSxdeO/XHH3+EVqtFfn4+LrroIjz22GMwGAz45JNPsGzZMsTHx+OZZ56BJElYu3YtQqEQz6pN51EbGxt53dHdu3fL6kBOmjSJ122cNWsWAGDhwoW44IILOD/JycmyDMoAZGf2NRoNz44NAJs3b5ZlRv/4448BgPO1detWAM1n+elsPtXDlCSJ17ek/oj3K6+8EgDAGIPVauWJd0pKSvhY1dXVvHYv0HzulHh/5JFHEAqF8M9//pPLZfTo0bzupsvl4v1ceeWVsuyndKYfOJH9nRJ80Xkiykh/+PBhjB8/HqFQCOvXr8f48eN5HoLKykps3LiRy0mcu+54fV+al8vl4ueAv/jiC4RCIfTq1UuWFZYdz6cAAL169eLyoezNZrMZxcXFOPfcc3ltaDEja2NjIzZv3oxBgwbB4XBAkiRMmjQJ3bp1w5o1a8AYQ2VlJdatWwe9Xo9JkyZxPFmtVqxZs4bLnWqiirgQ9b979+4w3ltqY7Va+ViEMZrf6NGjeRZih8OBRx55BADw5ptvYs2aNUhISADQnEOCeCb+iOcrr7wS69at41mxGWPYs2dPGNYIi0yR/Z/0JmKE2hBmSSfS8WoJdNaLzqkBwIIFC2A0GnnWc71ez22I+iEdb9q0CUCz/dXV1XG+tcdrxgLAv/71LwBASUkJ9wMmk4njHAAGDRoEAByXW7du5bXAJ02ahJ9++gmDBg3i/VPdbJKPUgZkH2+//TavUnHzzTejW7du+Ne//oV169bhtttu4zii/mhedH6bdCHKksYU/QjpkfBpFOrLSpKkiiONRgOLxYK3335bhlllm0jyISLeu3fvDqC5PnQoFOI5FT766CPufx599FEAwOLFi8NwQGMp50eY0ev13JYuuugi2dxpDrfddhufO/lSkmVLvkvELn1PWZQJ74QHxhg2b94sO9sr+kngRD108aw26ZbmRTFDzf7V+CGeKePxlVdeGXY9yUXNf1NOF6UMiC8asy1tKOZQtQuXy8Xt98orr4TJZOJxAGjOYXLs2DH89NNPAIAtW7bIKkcMGDAAx44dA9CcRbyhoQHfffcdxwZhjOajlJP4PcmMeCadkM+iOCBeR/hmjGHSpEmyKh4Un+hMfUs+UIw5bcFaJD9JbQm7ZCeivKnNli1bADT7dqA5rw9V0Pjpp58gSRKGDx+OUCjE67Sz47mFgBP+kfjUarUoLS1FMBiEJEkoLi7GunXrAABPPPEEGhsbsWrVKkiSxPMaNTQ08Dj59ttvQ6PRoLKyEjfffLMs1hNGvvjiCwDArl27eFuj0QitVosFCxZwn0X5EagNzXnSpEmqmGWMcRmSLVAbvV7Pq8FEiiPimoz6mzRpEjQaDb766ivu8202G7KysnDLLbfgX//6F69eIPpdvV6Pjz/+GDabDTExMRxzlMSzsrJSVq1FxJMyXrY37tK86BpxrUBZzCO10el0YW327NkDSZIwZ84cEBmNRkybNo37ZLqGeA6FQrBarXj77bdhtVpRXFyMm2++OSxGRbJtNVsiUs5dtG0iktOLL74IoLnSD61zKf4bjcaw9bJYhUD0u8rY3JIP/OKLL3DzzTfLbEFJu3bt4vXaz2o6qVv9DvqfkPi6zP/qo3xF5XR96EmIWLP1VD70Sr3m+Llpqn1MTxPFM6D0Ec/RkWw7d+7MAPBXCsX/UX/Uj1hfOysriwEnXntUnkU8GfnQ7i8AdtFFF3Hd02t1dPRBrA/e3jHE2pv0ShbtbtIOPrUXny7QExq73c53N6ke5rBhwxjQfC6LeM7IyODtgRM1aelVYGUtT9q5BcDPkoqvXdP/xDP2LpeL826z2ZjX65XZDI1B/dBTb/F/yjb0Ghdw4tU06v9kcUuvytI8iGc6m0xzIfsAwB577DF+fUZGhkxm4mvbSowQHqlf8bybqFutUA+WeKKxNZrwWrSUS4L6aKmebks+S02PynwFNIZ4Dlh8tVG8viWdKP8nvm5PvxN2yZ9IksSPhNDfyn5oDiI+6anl9ddfL3vDQtS/8smkXq8Pw5qafOjNFRqvvfW5I31I3qL9k82Kr3OKdqz8uFwu/vov5aIgWYq4JOyrYZf8rMfjYTqdjrlcLma327m/Fc+VE75JBg8//DDvX4kJZf4TOtJCNtQaP/STfP1jjz3GbYauHzNmDOdR6b+VeCL/TZgTz8hSG5ITtRGfPKWnp/Pf9Xo9l7vX6+XyiI6OZnq9nsXHx4flI2nPp1OnTjIZKI+KiP+jp6rnnHOOTCeibdOxFPFtLmpDsYKOk5EekpKSZPFEjM1ifo7W4mRrflLEk+jXSL6SJMl0256Pcg0i2vipfuhoBv2t0WjCjouI+VksFgszmUzMZDLJ8piIMZDOyZNvouvJBsTYIvohSZLYueeeK2tD7cTz8PQ0VnlWXpQVjSXKivyRmJfE6XRyHYnHUcQ4R/XkTSaTLE/EZZddJsOTmC9EibmW4i75RTEHhJjzCDgRgyO1kSRJdtRRxCeNEx0dzbxeL681L0kS97fiWMp8PGJ+CGUsVdq2mi3R9aRrcZ18MvbgdDplvCQlJYX5E/pJPlC0SdEHkv7obxFnBoOBRUVFMY1Gw2688UZ20003sV69erFp06b92rd1p0wdN+1nON19992sT58+bNmyZfz1dcYYu/DCC5nZbGbffPPNL3KjTc5QzegomQw5yq5duzKz2cyMRiNLTU3liz6160UjozHI6VAQERcq9BkwYEBYQiTl52TkoDaWmhNQ/k8tGLf1I96Qns6P5nhiDlr8tMYj8SC2o+/EQHY65K3VarnDbktb+og37EociYlbTkUfp/NDvIo3mMrzwWrX9ezZU7UfQJ5zoD1YACCTkXJsZYBX+6i9uhtpzpRU6XRuNEay9/aMIeqEfieZniyv4nX/i41V5Xn71vTVEr+RNlzEBbJaIjS19uKmxqn6NLKXXr168aRWkXhU2ssv8SFZisnd1PTR2ieS/bXU9pfEj3LTR/RTJzM+JY6iDfDT9flf2BXNl87Nngqv5PMNBoNswzczM1NVFzabjb3++uscaxS/xbairYobsKeCA4fD0abEua19lGsnkp94s6n83+nANz1waK0v5YZrW/R7qnH3dH9Eu1WTa1vnc6q21NI6ub3zaO3TvXv3FtdKrX2U14qbANXV1b/yHd2pU0fJtzOckpOTMX/+fAwcOBB2ux2bNm2CwWDAgAEDUFpaipqaGjidTrzyyit45plnsHfvXtTX1yM2NpaXzfjmm2/4q4ZUg11zvPZ6XFwcVq1ahXHjxqFXr17YsGEDLzOTkZGBe+65B6+99hp/JbCurg7x8fEoLS3lZbksFgsvs8AYQ//+/fH73/8et99+O2688UbodDrU1NRgwYIFOHr0KC/1QK+/rVixAsOGDYPZbOa1K4uKipCeno4rrrgC//nPf1BQUICqqip4vV4cPXoU0dHRGDBgACRJCqtN+tNPP/Gx6uvr4fP5cPToUV7K7sILL8R3332He+65B/v37+dtSkpK4Ha70bt3b+zcuZNf7/F4cPTo0Yj6efXVV+F2u9tcM3XMmDER642azWasXr0as2bNQklJCS95V1lZiejoaEyYMAGSJCEUCuHrr7/mbbxeL8rLyzFw4ECZvoHwmpahUAj33HMP9u3bh7q6Ov6qkyS8CpaQkIDi4mJkZWXh+uuvx+7duxEKhbBo0SIcPnwYgUBApotx48ZhwYIFYTyLMhdpxYoVvK6mw+HAzz//jD179qCqqgpxcXE4fPiwbC5KfcXGxuLQoUP8tey4uDhenmXkyJEwm82yOt0kY6qPrVbLO1Ibr9eLL774Anv27EFlZSUcDgevUX3HHXdg4MCBMh1nZmbi1Vdfxbp161BRURFWljErKwuTJ0/Gu+++i6KiIl4qkTHGeVGjmJgYTJw4EZIk8XaENapNSnZWUlKCuro61X4SExPh9Xqxb9++MHnfd999mDFjBseGkqg8ZFJSEq6//np8+OGHYTgS2/z+97+HzWaT4TwzMxNPPPEEtm7divr6eo5dwhqV/Xn11Vexfv16md37fD7o9XqUlpaG2e348eNx1VVXqdZlraiowGWXXRamE+I1OjoavXv35v9vbGzkdq+0D9KjiE81e1biSLRxZb32tsinc+fOaGhowMGDB8P8GslZrFur5CcUCmHu3Lkyn6eUaV1dHQwGA+rr6wFAVadkzyRTpY5E30y4VNqZiN1AIIBt27ZxfxsfH4/Dhw8jKysLw4cPx8GDB3kbwrWaz1LaEL1yqSYnNfuPxA9hjF4nrqurk811woQJSE1NDfPfR44c4a88K7FGfrywsBCrVq3imCNexTZKG1fGitmzZ+Pw4cP8aFZTUxMv+QUApaWl/LiE0+lEZWUlsrOz8eKLL2LXrl0txiU1vRHP5eXl/JVvkUSdOJ1OVFVVyeSkxLcyVuj1eu7r6+rqeEkqv9+PCy64gPt2ZQxUi5Nt9ZOijhobG+F2uzFgwABkZGSE2a0Y45U66devHyZMmIDly5eH+XHt8XK74pEfsrOoqCgcO3ZMVQaBQIBfazQa4XK50NDQwH1RUVGRLK4q61dHqhveks9qjx8hP0n2Fh8fj8LCQu4naY6R4gj5EzV+XnzxRX5ETw1n7733Xqt120U/pYzfhKeamhp89913qiVz2xJ3lXXQ1eqGq7X54IMP8NFHH4XZf0JCAjweD/bt28fLFyr1T7bndDrbtQ5Us+1IttRSvCX7UPMRkdaKpG9xvaz0J2r+UhlP1GJpJHyr/e9spo6b9jOcqA5mWloav2mnWsr19fXIz89H165dccMNNyAYDGLnzp1YuXIlAGDIkCH417/+xW9o4uLi4HK5kJubC4PBgOzsbPz973/HN998gw8//BDJycnYv38/GGO8NuW4cePwww8/8LNi11xzDebOnYtQKIT8/Hykp6fj5ZdfhlarxT333MNrgF544YX49NNP0bVrV17POBQKwWAw4OjRo3C73SgvL4dGo8HEiRPx+eef48knn8RDDz2Ec845Bz/++COuu+46NDU1Yd68eRgyZAiKi4vh9/tRXV2No0ePory8nC9GqOaxxWKB1+tFIBBAIBBAVVUVr4FN518OHTqEoqIi9OvXD0VFRdi7dy8OHz6MhoYGOJ1OzmtjYyP0ej2/vkePHti/fz9KSkrQ2NiI/v3785vHoqIiHDt2DAaDQcaX2WxGMBjkNZAvvvhifPbZZ7J6o1TDvba2Fl6vF8eOHYPX60VpaSmqqqoQDAZhsVjQ1NQEi8XCa28ajUbU19fz8/V9+/ZFXFwc/v3vfyM3NxdpaWlYuHAhFi5ciCNHjqCpqYnzGggE0KlTJ5SWlqKgoACBQABpaWn8TCktOMaOHYvc3FwZn4FAgNd/TUxMRH19Pdcx1QQNBoN8Q2fo0KEcz++88w4WLlyIt99+G9u2bUNtbS3/XyAQQEJCAiZOnChzsuIcioqKUFpaisbGRni9Xjz00EPYtGkTcnNzUVVVhYqKClkNbZJTKBSSYUT82VIbn8/H+XO73SgoKIDdbkcwGIROp5PpLRAIcB3b7XYUFxfjggsukC0oAKC8vJzro7i4GKWlpSgrK0NWVhavA6vRaGRYS09PD5Oz5nj9cWXANJlMcDgcfEFVV1eHhIQEviEWGxsLAHzsiRMnIicnB8XFxdixYweOHj3K5VxWVgaNRoMRI0agqKiI88cY4zgivZWVlSEQCCA9PR1GoxELFixARkYGqqurZbIkeZWWliIhIYFjLRgMol+/frJFU3FxMdLT0/Hzzz/zmryibWs0GjQ0NPA5EQ0dOhTvvPNOmD8VFy40H6U/IbsnDPfo0UMmi+uvv14Vn6Kd1NbWquJIxEpaWhr3G+2RD/mssrIyaLVadOvWjesCaD4PSXKnsfLy8uBwOBAdHS2z34aGBsTHx3OZ1tfXIzk5GRqNBtddd51MTkajMUzO77zzDlasWIH58+dzHZEs6+vrwxZ05LOU2DWZTGhsbITVakVycjIAoFOnTvzmWfTJVqsVHo+HY622thaSJHH8BYNB9OzZExqNRlVOJG/R/iPxI/r/c889F8XFxbxP8n0t+e/6+nrU19fD5XIhGAzK/GVFRQWCwaBsLPL18fHxsjYiXxTvSLdDhw6V8dWzZ09ZXAoEAtx3Uf6Yw4cPIyMjA01NTdxnVVVVoaioiN90KX2oKCdRX7TRIvqI2tpaVFZWcow1NTWp4ptwqNVqYbFYuE2IPFMNcorNIj/0U5SdMk621U/SmFVVVaivr+eYE+UtxnjCt8lkQmVlJd8wBoCbbrpJdtOm0+lkvr20tBRr165Ft27dMHz4cPz8888wGo1YuHAhBg4ciIqKClmMXrt2LYYMGYJHHnlEFs9FuuqqqyLGejEGi23JZ5G+GhoauJ5E/0RYI7/m8/lkfoTWR6WlpSgtLUVDQwNGjRrVahwhf0K8EvbIptjx3B12ux3//Oc/ZXNQ87ui/weA2bNnY+/evUhPT8ff//53fP3119i/fz+CwSCCwWBY/Hc4HHwz9WTibkxMDGprazlGRBxGakOypLWex+Pha1UxRvfu3RuSJMnmLPKlXAeK8U8pKzXbjmRLIn8Ub0VbVPp2kmV1dTWio6PhdrtV/ZJyvSz6E5fLhfT0dNV4EskHtmQLyph1NlPHTfsZTueccw4uv/xy3HXXXbDb7di8eTO6d+8Oi8WCkpIS3H333XjppZfQo0cPWK1WbNu2DXV1dbKn7RdffDG+++475ObmokePHvzGv66uDo2NjTyRFD0xJ4Otra2F1WqF1WpFSUkJPB4Phg0bhm+++QbBYBB5eXnIyMjAkCFDkJmZiXfffZfvWtLOoMlk4smtQqEQNyDx77i4OBQVFcHpdKK8vBxAc3KOuLg42dsEohMEmndaybnSDnZTUxPcbjeA5iQXDQ0NMBgM0Gq1iIqKQkVFBSoqKuB2u5GVlYWdO3fyhDxE4o4q7YgTT3V1dfytA7ohb2ho4POkudGNLyWjEZ/27Nmzhzs4t9sNo9GI6upqVFdX835sNhvq6+tVn2TQPCkRDvFHSTYOHTqEnTt34r333sNjjz2Gvn37IjY2Fjt37sSOHTu4fKKiolBYWIiamhpoNBoYDAa+sULzInkTn8FgEFVVVWhoaOA6Fn/S2xaSJHHnGhUVhd69ewMAevbsib/+9a+yRHeSJPHFrc/nw6hRo/hcN27ciM2bN6Nv377Q6XT86RdjDHV1dfD7/SgoKEBZWRnMZjNqa2tlTzSampqg1+vR1NQk+075U62NXq+H1+uFJEkoLy+XPfEgTDU0NPAnM0ajEUePHsXIkSNRW1uLkpISpKen8wXFsWPHUFpaCp/PB4vFgsTERJSUlKC8vBwVFRU84NHGCWFN+VRRmSRGDbsGgwENDQ2qmAUAq9UKl8uFQCAAk8nEE8yQXWzbto3rmJJX1dXV8acnZFdWqxXBYBBWq1U2B2qjlCXh3GazgTEGn8/H528wGOD3+zlWSkpKsGPHDpSWlnLdEtaZkNhJxJrL5QLQnGjrs88+k8lGXLhs2LABxcXFXJ9qdi9JEvR6PUwmE082FQqFEBcXB6B5YUj4jI2NRWFhIdxuNxoaGmRPPZVzF9uI/rEt8nG5XAiFQnzB09TUxBNPeTwefr3oX2gsnU4Hu93O/aKIZfJbTU1NsNvtqKurg91ux7Fjx7je6a0TAFxHU6dOxaOPPooVK1ZwHbVEatgluVMCNIPBgIqKCgAnnk7q9XoA4H6PfAZ9TzglnFOypfr6epmclL6hJX5E/6/VamG32znGlX5Aq9WG+W/CaGNjo8yOW8IckdhG5EuMd+Rz0tPTsWPHDo6JmJgYlJWVcawFAgH+BoXoswhzYlwi/umnmpxEfZHPpw1MZawXfZfJZOJyEuObmi8lntXkIOJIjDltwZpSx+QnCU/0P+JZlLcY46lvalNfX4+oqCgMGTIEJSUlSEpK4htOZEOES/IjNTU1PNYajUbExMTgwIEDACCL0fX19Thw4ACsViuqq6vh8/kwZMgQnrALAHbs2IFdu3apxnqj0YiBAweGtSWfRTwA4GuVY8eOydY1oh/R6/X8rR7SHwCYTCYEAgH+ncvlkmFJGUfIn9CaTByLEukFAgFIkoRRo0bh73//O15++WW+8fXYY4/J/C7FTgDo06cPNm/ejMLCQgDA+PHj8fnnn0Or1cr8AJGaH2lv3KVkhNXV1TKMKLEitlHKkuwkKioKdXV1cLlcqK+vx6hRo7BhwwZs2rSJr8lIXpHWgaNHj8Y777yDv/71rzJZRbJtNVuiGCjG20gkxjuNRoP6+nru2yi2K3Utyp54IH/ZHh+ohm+yBdFOAIStC846Or1v23fQ6aZly5Yxm83Gbr/9dmYymdi0adNkpVuo7NKAAQP4eY7hw4cznU7Hxo4dy39S6QPxp3Q88dXcuXP5OBdffDED5Gcjo6OjGdBcwmHs2LH8LDqVCqIzRjQ+XffXv/6V+f1+NnfuXPboo48yACwtLY0NHTqUl6QBEJaUDGg+wz5hwgSeTEin07HevXszo9HIf58wYQJjjPExxLE0x+s5Ujv6GI3GsDZi371792ZdunSRXd+lSxfZmRmn08liY2NZbGws02g0rHfv3rKa0ERUM5XyENhsNl6XneqNim1pDhMnTpSNT3zRT7FN//792cUXXyybo06nY/n5+bxP5Rg0dzG5mFiD3O/383nRmIyxMLmKfJEs1GROeiIelHKiftXmotQXtSGduN3uMF7pGnH+Sowof6q1Efkj7NIYSv6IbDYbmzZtmky+breby9TpdLIJEyZwjFEbSghDehCxRtepYS0S9qlf+lBSt9jYWD5G//79WVpaGk/oJ0kSS0tLk+WrEHNb6HQ6GeYjzYHaUH4FJQaV2FXKtCWskd5Fu1XDmZKUciFe6fxbS3ZPMiA9ku2L+m8LjtraJpJ8xLnTvEXZiT5H9C/0HeEykkz79+/Pz9+Kehf9XWs6En1pJHtTYldp22r9qOlPLRmhaEOkY1FOanxF4keUM8mIsKLErJr/VsOa0+nk81MbS+ST2rSEI/H6nj17ypK3de3alfsut9vNfavRaGQajYaNHTtWFpda8o+inJS6ELGi1AX5ClFOyvgm+tLevXur+ls1/bUlTrbVT9KZdCXPSltV9if6/fz8fPboo49y+St9J53rdbvdYRgl2xL1RjZxwQUXyM7okt6mTp3KnnrqqTBMqP0tkjifc889l/Xp04d5PB5mMBj4WsXtdrOkpCRVn6XErFosVvpOtTjSkg+lXE4LFizgstNqtWz27NmsZ8+ezGKxsMsvvzziPMVcUHQeOy0tjen1ep5/SelfxPPf7Y27omzb0ybSWlX0yRdccAFP2Ebr5blz5zKLxcKys7Mjrp0irY/VfkayJbV425IvFf2SuG5X2nhL/kQtNivXWW3B92+VOm7azwLKy8tjN998M+vXrx/LyspiPXr0YMuXL2f33XcfMxgMLCcnh2m1WjZo0CC2efNmxhhjTz75JCsrKwu7WRe/pyyiVNOQxqEakS6XiyUmJrL09HTWrVs3lpWVxa666iq2efNmdt999zGz2cxSU1NZeno6b6PValmXLl14HU2Px8Py8vKY3+9nVqs14liS1Fzv3GAwMJPJxIMHZfyl+pxi7WUiGkMca+7cufxvkdTaUH+RrhcdjLJPcWwlX263m2m1WvbDDz+wG264gU2ZMoW53W5ZvVG1fmgBpZyXWhvGGAsGg+yGG25ge/bsYYwxdvvtt7OSkpKIvIpOlnSidHTKMRljYXJpiedIpCanlpyskme1a1qSE41zMm3EsUhOyv+53W522WWXyWQfHR2tGqzVZNkWrKn9VGJWTbeRMCvylZSUxFatWsXr+5Ieo6KimMlkUrUltbHmzp0rk4XH44mIc+WGlRpmImFNzW7bQpHkLfajpgs1PYrUHhy1tU0k+UTSxfbt27n9k9xdLleYLgiXkWTakpxakmlbcNlSGzU7idRGHFN5o9manNrLT1t8nxoOIvHVFsy1xJcajsTrr7vuOn6jAjTXLvb7/cxkMrEuXbpwjLjdbpaamsrWr1/PGGv2WWJ8bU1OkRb/LcUuNXy3FJ+U/rYtMedk/WSkdYCabqmNmt8vKSlRvWmj62NiYtiwYcPYnj17mN/vZ6NGjZLZKWOMGY1GtnbtWlnbu+++m0VFRTG73c7MZjNfG33++eesZ8+eYZhQ+1skcT5xcXEy/099u1wuZrVaW/T7avYbSb5tWZOJ/6O4dPfddzONRsPmz5/PrFYrW7hwIbPb7cxut7OsrKyI86TrGWM8c35eXl7YvE5X3BXn0p42keSitoHhcDiY2Wzm19rtdqbValu9QW1t7dOSLbVkH8qfok0Qvlta50byJ+31gZHm+1uljtfjzzIKBoPYu3cvEhMTcfDgQbz11ltwOByYNWsW1q5di/T0dN4mPT0dzz33HH7/+9/j9ddfx0033YSysjKkp6fjqaeewu7du7Fnzx787ne/w0MPPSQb509/+hNsNlvY9yIPgwcP5mMS3X///fz1KDofZLPZMGvWLFx22WVISEgI69Pr9aK2thZbt27FP/7xD8yaNQvbt29HWloaPwt455138v5WrlyJc889l/dDvIpjrV27Fm+88UbYHKit2Ib6i3T9rFmz0NTUhPXr14f1KY6txtfzzz+Pn376Ceeccw5yc3Mxe/ZsGa9q/bzyyivYsmULH4vaij+pDcne6XQiNzcXqampEXWonHv//v25TkT8qMn0oYcegtfrlclFjR81mStxpZQT9SviKJK+qI14jZJX5c+HHnropNqI/JGc1PT20ksvYfv27Vz2xFv//v1VZSrKktq0hDU1npWYVWK3f//+ETEryo5yZpDdWSwWrF+/Hn369OGv/yptSQ1H1IZk0RLOldhV8zWRsKZmt5GwJlIkeYuyVLN7NT2q4bMtOBLn2VKbSPJR82v0v5kzZ4b5F6UulNcrZZqenh5RTmoyVtNRJFy2hF013xOpjcgXyUnNhiLJqT38iNdHwmNL/lsNa61hriW+1HAk8vWPf/wD3377LQYOHAiDwYA777wTc+fOxdixY/HZZ5/BZDJxjCh9Vmv+UY1nmp+aTlqSU6RYIeJc6W9bioGn6icjrQNaivGifYkx1+v1cr+rhstgMMiPeyl9ZmpqqkwG1HbEiBGYP38+PvvsM9naKC8vD71790ZlZWXEWK9mt+J8XnzxRezYsSNs3XXDDTfggw8+wLRp0yL6faW9ibG4JYxEWpOJcqe4NHLkSJSUlODnn39Gjx498OGHH2LKlCmYPHky5syZg3vuuUd1nmIuKEmScMUVVyA7Oxt79uyRzUvEw6nEXVHu7WkTaa0qxmhKRk36v/7665GQkICDBw/izTffRF5enmpsiiTf9thSS+tktZ+EZRHfrdmSmi22xwdGmm9b1gVnI3XctJ/hRGecAoEAHn74Yfz73/+WnatJT09HQUEBtFotHA4HHA4HP596zTXX4M9//jOeffZZrFmzBjt27EAoFOLZWAHw84F0rsRoNPK+q6ur0blzZ6SkpMBut6OxsRFbtmzBrl27oNFocMUVV8BisWDx4sUwmUw4cOAAKisrAYCfA2XNb3NAo9HwrKlGoxEpKSlobGxEr1698P3336Oqqgrdu3dHRkYGPvroI+Tk5KCwsBClpaWcr2AwyM+5sONZggm+dK6OkmLo9XpYrVaUlpbCZDLxM8SMMWzevBmMMZhMJn42mvoLhUL8TDEl5CC+o6Ki4Pf7sXnzZphMJn5+Xzx7R/2QPAOBAO9Lp9PBYrFwnui8F+mT+qHMxwaDIezsEfVPGyNOpxOJiYnYt28fcnJyUFVVheHDh3OZzJ49Gz6fDz6fDxqNBtu2bePnjux2O0/gRGer4uLiUFBQAMYYSktL4ff7cfToUX6GsaGhAXq9nvPKjp/5Ip5JT2azGRkZGTyjbEFBAYDmzLJbt25FU1MToqOjER0djaKiImg0GsTGxnLeiZqamjBnzhzYbDbEx8dj8ODBAIB//etf/BrSqclkkp1plySJy40y7itlqWxDOKLvXC4XysrKAIBjhvRmsVgAAEePHoXD4UBqaipGjhyJZcuWQa/Xc1nReSuaS/fu3VFdXc0z1Wo0Gvj9fuzdu1d2ttViseDo0aOys12R3LU4HzrfHQwGOWb37t2L7t27o3v37li9ejX0ej3q6+uxc+dO9OvXDz169MBLL72E2NhYfr6Vcj8Qf9u2beNY2rFjBz8DDTRvGjU2NqKkpIRv2JWVlXGd6HQ6ft6c8ORyubhNUt8TJ07EypUrUVhYiOrqalgsFp7F9vDhw9yXEAZJTp06deJYA4Dhw4fjhRde4H//6U9/wrJly9DQ0IDCwkI0NjbK7JCwobR7r9eLhIQEmR6JlixZwnmn3AF0VlY8z0dzra6u5nZDNtxW+WzevJnzEwqFOO9ms5njk/w4ZSyns4QOhwPHjh0L82s0d7PZzG2/sLCQ20haWhr69+/PMdu9e3fu15YsWcLbkizJxhiTZ3WPRCJm6Xc6lynqlnwg9Wc0GtG5c2ds3rwZFouFJ4oj36yUk6gT8q+R+CE8kw8nOZGdtua/6bypTqfjOhaxCkAWK0hvGo1Gdn5TlJ/osyg+i3y5XC74/X5s3LiR28KmTZug0Wj4eXvCHfmtY8eOQafTwel08rFEX6OUkygbjUbDfQxd63Q6ZfJ3Op2q9l9dXY1AIAC9Xi9rY7FYUF1dzdcMJA8xHqrlIhHl2dKZ40iYI1L6E+K5qalJlqeFdCJWKKC8JwkJCdBoNDh06BCSk5O57smGbDYbP89N1/r9fmzatAl2ux0pKSk8RlMWe6/Xi0OHDiE7OxsGgwEbN25E//790b9/f/zwww/YtWsXevbsKfOhYqz3+XyIioqSxWHGGCorK3lVH/IR5HcI95SPJxQKcTsjP2IymWC1WlFZWcnXE126dOF86PV6dO3aFaFQCIWFhVxnkyZNwpw5c2C1WuHz+VBUVMTXGpTckPJ4uN1uFBYWQqvV4tprr8V7772HjIwMXvVo586diI+P5xUwxHkWFxdDkiRcfvnlePHFFxEVFcV9Aflkml9jY6Ms34S4vmlL3BVxCECWr4KwQufBtVotX9cRzkmWlLslIyOD66G+vh4bN26U6Z9yTxkMBgQCAdk6EGiOfUuWLOE/1dZHajZF/IlraXGdLc6LeBftjdY8tJYiuxZjlXK9TPIR5csYk51pJx7ENSb5QL/fL9M7XS+udyhmEYnrgrOROm7az3ASbyZOlcaMGYMffvghrH+dTseThJzp1JbFoLIMEBEZdqTENafKF1Fb+BN/P1XdUmIbSnZis9kQHR0NADwRC41BCTzaQuLChq5vi9xofrQAB04EMpvNBgCyTK/seJITWsTQ9ZSU0OVygTGGQ4cOQa/X86AqbrAo+WsvTpS8U1/KNsqkJvQdBT9KyEQbTLSgEcv7EInlTYCWEyedKpEeaWFBAVCj0fCEdWIgVyO1ubfXjqgPus5gMPDvGhsbYTabeTkj8knipkuk/ghrlGivV69e6NmzJ4ATN9e5ubl8QdoeIplQEiEakxZiVKoSQETbUkuqIy7yCGtEIibU5q7UhaiH9uKoJVvRarVcpiLR3Okmqy329luhlmT/vxhbiRUA/CZXuQEQSS9qMVLp5/4X81Ib+0ynSDxLkiSL52SHyu/b0rdyE0f0A3a7nSeta2pq4jG1LUR+ip5k0s2Ymr4pfomkbKPma1rSqVarlV2jvOGluTQ2NqK6upr3FR8fj4KCAr5xRsniIs1dr9ejpKQEVqsVNTU1rUjll6OTwTf5XEoQTDewWq02LFmiSBRLo6KiUFJSgqioKK5vZXz6X9vb6bRz6kur1UbUP8V+tWsXLVp0yjz8mqT7tRnooJZp48aNAIBx48bhmWeewR//+EccO3YM0dHROHToEDp16oS8vDxkZ2fzsiG0a+fxeFBaWiqrnQgAU6ZMwYcffsjLj7z//vv4wx/+gOLiYrz77rsAmp3m4sWL8eWXX2LIkCFYv349ysvL4XA4cOTIEdTX16Nbt24IhUK89JzBYEBCQgL27t3Ls9rabDasX78ew4YN43Oqrq7Gzp07ZUEpKioKRUVF0Ol0PAOxTqfjGYn79u0Ls9mMQCDA+xMNkEqttES5ubkA1A2a/icSOTolKR1Fr169ZI5g2rRpWLFiBWbNmoVzzjmH1x2mXXsKUEBzPXRJkniZo5Plf/Xq1fz3YDDIn5LExMTI+hfn2dr8evbs2S6ZtcdRtkdfGRkZACALvsrdU3Hs0+GY28IfjUUlAwHIbjRpcU1P5JV1z+nJanV1ddiNm3IRQ6TEmshrbm5uRJ0qg7XT6eQy++mnn/higBaZtEhsjZT80Zs2wIkbab/fz+WjfFotEum7b9++qt+LpIY1pd5JLnv27AHQPGcAXB+AfBErklKOtFgUqW/fvqdtERAJb22d++rVq+H3+2XfFRQUcL2Lb1ABzTh1OBwAIvsBItqIEkmpIyW1Jpf22L9IbdkcIRL9WGt8qfGjNr6yP+qT7CrSNW3pR0nt4RVo3uTcsmWLrKazxWJBRUUFevXqha1bt/K29fX1kCQpLBbRuGQzyjFpfiJmIm1GtTWOiP221IbatSY3oOWY0xYd9ezZs1UM02vxhw8f5n5fvIEV3w5Ru1lRbogT3wBkbzHRRiPJtba2FgUFBdDr9ViyZAn69OnT6nxaovz8fDz99NOymtZ/+tOfkJOTw9soMdeW9RLhQsQY0CwLu90OoGU55+fn45577sHXX3+N6upqaLVaXHHFFThy5AhWrlzZ4txHjhyJQCCAAwcO8A0Qu92OpKQkXruc4mVbNj3U4u7JUlt9PcVosmuv14vDhw9Dr9fL7JpkKVJGRsZJ++BTibfiOlSNBg4c2G5/2RZb/H9FEU+7d9AZRZSAxGw2M4vFwt566y2m1WrZl19+yRwOB8vNzWUA2FtvvcWMRiMzm80sLi6OZ8qEkAX+vffeYwCY2WxmNpuN7d69m1ksFuZwOMLG/fLLL9nw4cPZl19+yTQaDcvPz2dffvkl02q1PGmJOPbw4cOZzWbjv+fm5qr2q0ZqYzF2IjMrjdXW/n4tEpOgiLzv3r2b2e32X5O1DuqgDuqgDvqNUl6ePGktJY7toLOb/j/r9f/z3Ik6ZNBBRB1P2s8S6tu3L7766iv07dsXa9asQVpaGkKhED766CMMGjQIb731FtxuN/bv34/6+np+loTOl5WUlPBz7MuXLwfQ/Ipj3759UVNTg4aGBtnTcKLMzEysW7cOmZmZAICvvvoK48aN469UAZCNvW7dOmg0GqSlpWHdunV46623MGjQoFbnp9VqsXLlyrCxpkyZIntNqq39/ZpUUlLCX08nCgaD2Lp1Kxhj2LlzJ9LT01WfYJ0qiUkIf4n+OygynY2y12q1KCoqCsMrvc3T1qMUSjobZfFbIDW5d+ji/w+lp6fjzTffbLGNiIempqYObJwinYx9tcdO6c25119//bTr6Jfy/6eTLxHTxNe8efPafL1Iv/a8TpbaYtdnEnXEnF+Qfu1dgw5qmSoqKlhFRQX79ttvmc1mY+effz4DwBwOBwPAtFot69OnD7NYLOzxxx9nOp2Of+Li4pgkSbwOutlsDquleuWVV7LExESm0WjY4sWL2cGDB9nBgwfZgQMH2I8//sguvPBClpGRwS655BKWmprKLBYLS01NZQDY7bffzoYNG8bMZjN78MEHmU6nYx6PhxmNRtapUydms9mY1WrlpWWUcxLHkiSJnX/++SwzM5NNnjyZpaenM5vNxq655hoGgE2bNo2NHTtWtb8zjYYNG8ZefvllxhhjVquVXX755TKZa7Vads0117CnnnpKVmv1VKimpobdeOONvJ4pPd0/Xf13UGQ6m2UvSRIrLi4O+76wsJCZTKZ293c2y+JsJjW519TUsKysLKbRaDp08f+ANBqNqi0fPXqUaTQaGUY0Gg27/PLLmVarZZIksenTpzPGOrDRHjoZX9ceO73ttttY3759+ZpN2T/p9VTodPv/00XElxLTxFdrcz9T53Uy1Jpdn0nUEf9/eerYAjnDyeVyyZI4fP311wBOnB0NhULYsGEDJEnCww8/DL/fj9TUVKxevRqVlZVgjCE5ORl5eXk8+RedlfJ6vfjiiy94JstRo0ZFTJaSl5fHk2Ls3bsXADB79mz+/7/97W8AwLO97927F6NGjcLMmTNlZ6PEOSnHorkdOXIE1113HSwWC95//31YLBZ8//336N27N1atWhXW35lGTz75JMaNG4dt27ahrq4OS5Ysgc/nw5EjR/Dkk0/ib3/7G4YMGYLZs2fj0UcfxaOPPooZM2ac0pgPPPAANm3ahMWLF+O8887j348ZM+a09N9BkelslP3LL78MoPlc2ltvvSU71xcKhbB06VJ06dKl3f2ejbL4LZCa3B944AEEg0GkpaWhqKiIt+3QxW+TWIQkT5RpWsTIyJEjsX37dixevBhjx47Fl19+iWeffbYDG+2gk/F17bHTwsJCbN26VVYRROz/2muvlSV7bQ/9Uv7/VEnJF2MMb775Jux2u4wvwnRr158p8zoVas2uzyTqiP+/PHXctJ/h9OOPP8r+1mg0iIqKwqFDh2QJPuh7KhdByUXWrFmDgwcPwuPxwOl0olu3btDpdDh48KAs6QjdbFNiCI1Gw18v8ng8vOyRcuzc3Fz+Cr7YhvhoaU65ubl47LHHAABlZWWIiori2cE///xzGAwGZGZmYv78+RgwYMBplesvSUOHDkVubi6efvppaLVaWCwWHDlyBEajEZMnT8aTTz6JTp06IT8/H127dkV+fv4pj/n5559j/vz5PNEH0enqv4Mi09ko+xdffBFA84Jg9uzZMl9iMBiQkpIi25RrK52NsvgtkJrcP//8c8ycORM33XRThy5+w9TWGxURI6FQCI8++iiGDh0KrVbLS8t2YKPtdDK+rj12unTpUl6OrLGxEf/85z/h8/lQUlKC7du348477zzpG9Bfyv+fKhFfTU1NeO6558AYw8yZM3n5Qo/Hg/POOy/i3M/UeZ0MnY0bEB3x/5enjpv2M5yobjUF1cLCQpSVlYWV4YmPj0dhYSEOHToEoDnj6EMPPcSvEdsoyel08szKyjrZIhEPlM0bOJFBtbCwEPHx8fx74oMoKSkpbE7Dhw/HtGnTADRnnvz000/hdrtlYynHVuvvTCQ6g/T+++9j4cKF6NatmyyABAIBSJKEmpqaNmXpbo3UztEDOG39d1BkOhtlT2/LKO3uVOlslMVvgdTkXlJSAovFElYeqEMXvy1q643KyJEjOUYYY/B6vfx3ymTegY2208n4uvbYaVVVFf+9oaEB7777Li/P29DQgNra2pO+Af2l/P+pEvFlNpvhcDhQUVEBu93OMV1fX49vvvkm4s33mTqvk6GzcQOiI/7/8tRx036G0xdffAEAmDBhQou1Psnht1RmJFLtVfGaBx54gH+/a9cuSJIEnU4Hj8eD1157LexasT9l/XGRxMQfNKc1a9bw7wYPHoznn38eBoMBsbGxuO2221o08jM5kYi4wZCTk4P33nsPOTk5yM3N5ZsZYgLB05FYjxIV3nXXXQBOyP9sSNx3ttPZLHvxTR6y5VMJrmezLM5mUpN737598cwzz2DQoEFYsWJFhy5+o9TWGxURIxqNBosXL8aIESPQ0NDASzF2YKPtdDK+rj12GhsbC4fDAb/fj3Xr1mHp0qVITU3FXXfdhd27d+Pbb7895Tmcbv9/uoiOco4cORKffPIJ3G53u/g6U+fVHjobNyA64v//gP5np+c76KRIkiRZErPWPpIktbkttadr2jNOez7Z2dmstLT0pOaUlJTEli5dytatW8feeOMN1qVLF/bJJ5/8ihppnWh+Go1GVR8ajYbpdDo2YMCA05ZYb9myZcxms7Hbb7+dmUymsypx39lOZ7vs33rrLda1a1dmMBiYwWBgXbt2ZW+++eZJ9XW2y+JsJTW5UxKrSy+9tEMX/8+oqamJNTU1yb4TMWIwGJher2cJCQk8IW0HNtpHJ+Pr2mOnJpOJWSwWWdsxY8Ywi8VyWnV0Ov3/6SQlX9nZ2eyNN9446evPlHmdCqnZ9ZlEHfH/lyfNabr376BfiBYsWIB+/frhhx9+QGVlJSorK/HDDz8gOzsbmZmZuOWWW2A2mzFy5Eh0794dAwcOxCuvvIJ3330XCQkJGDFiBO6//34kJycjNjYWl112GVJSUvD888/jxRdfRKdOnZCZmYkrr7wSVqsVzz77LPr27YsvvvgCjz/+OKxWK2688UZkZWUhISEBAwYMgMFggNPpxKxZs5CYmAiHw4HU1FT0798fH3/8MWbNmgWz2YyxY8fi2Wefxb59+3D//feHzUkca/LkydBoNDjnnHOQlJQEn8+H9PR0FBQU4O6770bfvn1xyy23YObMmfysz5lKGzduxIYNG7BhwwZs3LgRn332GYYOHQqDwQCr1Qq3242kpCRkZGRg1apV6NOnzymPSefoGxsbkZOTg++//x7R0dGnrf8Oikxns+wffvhhTJs2DRdddBE+/vhjfPzxx7jooovwhz/8AQ8//HC7+zubZXE2k5rcMzMz8dVXX8Htdnfo4v8Jvf322+jWrRtMJhNMJhO6deuGt956C4AcIz169EBSUhKMRiO6deuG3NzcDmy0k07G17XHTteuXYvNmzejsbERfr8fs2fPxqJFi9DQ0IDrrruO6/VU6HT7/9NFIl+33nor/H4/du7ciVtvvRXR0dGtzv1MndfJUkt2fSZRR/z/H9CvvWvQQS1T165d2YoVK8K+T01NZSkpKWz37t3MZDIxv9/PLBYLW758OcvOzmaMMbZgwQKWmJjIdu/ezSwWC/vyyy/Z8OHD+U/xe7PZzIxGo2y8rl27stdff51lZ2ez5cuXs+TkZJaYmMj8fj/TarWMMcZSUlKYx+MJG/vFF19kOp2O85eYmBg2J3Esn8/HHnnkkbCxHnjgAVlZC+L5bCSSewd10JlCPp+P/etf/wr7/l//+hfzer2/Akcd1EEddDL00EMPMavVymbMmMH+85//sP/85z9sxowZzGazsYceeujXZq+DTpJ+Sb2eqf6f+FLO/b777mMmk6nVuZ+p8zoZ6rDrDhKp46b9DCeTycS2bNkSVtvcYDAwnU7HJk6cyNLS0phWq2XdunVjK1euZEajkVVUVLDNmzczo9HILrnkEtatWze2YcMGZjKZ2NKlS2Xff/vttwwA69y5Mx+Pxv7kk0+YyWRimzdvZgaDgZlMJl73vby8nBkMBqbRaMLG/uSTTxgANnnyZJaVlcXMZnPYnMSxnE4n++9//xs21n//+18+1vbt29nkyZNZjx49fg1VnBRRjU2NRsNWr17NNxyoxubpqrV5NtXy/K3R2Sx7p9PJdu3aFfb9zp07mdPpbHd/Z7MszmZSk7tGo2Hbt28Pk3uHLn6b1NqNiogR8XcRDx3YaDudjK9rj53S8TqlXqn/03EDerr9/+ki4ks5d+KrtbmfqfM6GTqbNiA64v8vTx2vx5/h1KdPH0yfPh0ulwtutxuJiYlITExEMBhEY2MjPvvsM+zduxeSJGHr1q0YPHgw6uvr4XK50L17d9TX1+PTTz/F1q1b0bt3b9TV1eGcc86RfX/eeedBkiR4PB50794d06dPR0lJCbp3747bbrsN2dnZ+OMf/4hgMIi6ujoEg0EAgNvtRjAYBGNMNrbb7call14KAFi1ahVuv/12JCYmhs1JHOuyyy7D1KlT0aNHD9lYF110EQDA4/EgOzsbq1atwuuvv/6/V0Q7iI4xVFZWgjHGfz711FPo1KkTgBM1Nk9XrU12FtXy/K3R2Sz7a665RtWe3njjDVx11VXt7u9slsXZTGpyZ4whGAyGyb1DF79NamhoQN++fcO+79OnDxobG2UYEX8X8dCBjbbTyfi69tgpYwwGgyFMr9Q/6fVU6HT7/9NFxJdy7sRXa3M/U+d1MtSaXZ9J1BH/f3nqyB5/htPbb7+Niy++GFqtFtHR0aivr0d5eTmcTie0Wi3/XaPRoLS0FHFxcTh48GBYpng1Y6I2sbGxeO655/D4449jz549ACAr23D06FHo9Xo4nU5UV1fDbrcDaC7jYLVaUVVVhVAoBK1WC6/Xi9LSUng8Hlx33XV4+umn8eWXX+Ivf/lL2JzUxtq/fz+cTieys7NRUlKCyspKdOvWDWlpabBYLHC5XGd8FkqXy8V/Z4zxG/XvvvsOAwYMwMSJE5Gfnw+Px3NKtVaBs7OW52+Ffiuyf/vtt/H999/zDNJr1qzBgQMHcO211+Lee+/l7V544YWIffxWZHG2kZrclyxZwv9/xRVXwOv18nYduvjtEt2oKO309ttvR05ODlauXIkbb7wRRqMRAHDjjTdCr9cjPz8fXq8XL774Ygc22kAn4+vaY6dLlixBU1MTGGPweDzIyMjArbfeiokTJ8r6P103oKfD//8S9Pbbb0On02HixIkYOHCgjK8pU6YgJSUF9957b0S+ztR5tZci2fWZtAHREf//dySxSFsjHXTGUFNTE77//nvs2rULAJCZmYmxY8cCgOr3y5YtAwDk5uYCaC7p5nQ6+c10QkICtFotNBoNoqKikJGRAZ1Ox8fZsWMHdu7cCQDo3LkzamtrYbPZIEmS6thNTU2oqakJa0O1X1uaE431xRdfwGKxwGKxwOPxRLxOkiQsWrTo1AT6C9OSJUtwxRVXAAAOHz4MjUaDpqYmaLVaXgJDp9MhOjoaXbp0wWOPPYYBAwac1FipqakAmjc7SK9EVMvzVPrvoMj0W5D9yJEj29SuNbv7LcjibCQ1uRcUFAAAGhsbYTKZ4Ha7+Y1ahy5+u3TXXXdh7ty5SExMlN2obN26FTabDVVVVTz+MMZ4PNLpdHC73bDb7R3YaAOdjK9rj52K38fExKC2thbV1dXQ6XQwm82w2+0wmUwoKSnBtddeC71ez8dp7w3o6fL/p5uIr927d+Pw4cMwGo1wOBwAmuvX19XVwe/3Q5IkXH755QDkcz9T53UyFMmuaQPiVPR/uqgj/v/vqOOm/SwhtdrmQLPTMRgMiIuLw6FDhxAbG4uYmBhZm7Vr1/L65/v27Qu7NjY2Fn6/HyaTCRkZGdwAI/GgJEmSsHHjRtWxJUlqtd/2jnUy/f1aRDU2L7nkkl+01ubZVMvzt0Ydsj9BHbL4dUhN7h26+P9Frd2o5ObmomvXrjAYDGCMdWDjFOlk7Ks9diquHdpCZ8MNaHvpt3TzfbJ0NsmgI+b88tRx034W0JIlSzBixIj/2XgGg4HvwlssFmi1Wuh0OhQWFgI48Vp9S0Q7+tRWkiQMHToUn3/+OdxuN5YsWYKZM2diw4YNKC8vB9B8Rr53796YPn06hg8frjpOpP7OJIq04QBAtuFAMjrdRDL7pfrvoMjUIfsT1CGLX4fU5N6hiw4SScRDBzZOnU5Ghu2x0w4dddDZRh2Y/WWoIxHdGU7z5s3DmDFjMHz4cCQnJ2P8+PFwu92QJAkajQYejwcXXHABYmNj+SuQQPsMRWxrNpsRDAZhNpvh8/lw9OhRNDQ0oKioCGPGjOGvrmu1WlxyySUYM2YMAPBXl6xWK5KSkqDVajFjxgwMGDAAX375JZYuXYpjx47h/vvv53MqKSnB4cOHkZmZic6dO+PQoUNYv349hg8fjk6dOsHpdGLw4MG44IILUFFRgQULFqj2d6bRhAkTMHHiREyYMAETJkzAxRdfzD+/+93vkJ6eDq1Wi6ysrNNaa/NsqeX5W6SzWfbr16/HH//4R1xxxRW45JJLZJ+TobNZFmczqcn9uuuu69BFB3ESMaLX62EymWAwGDqwcZJ0Mr6uPXb6v/Clp9v/nyl8nanz+q1TR/z/hemXSUrfQaeLunTpwl544YWw2ubR0dEsOjqa10Zfvnw50+v1zGazsaioKGYwGNizzz7L+vbty2JiYlhUVBTLzMxkWq2WSZLEEhISWP/+/Zler2fR0dHM5XIxSZKYwWBgmZmZLDExkXXp0oWNHz+edenShT3//PPMYDDIxib+7rrrLmY0GtnUqVNZYmIiS0xMZM8//zzr0qWLat14mhP9ZIyxDz74gGm1Wma1WjmPiYmJzOl0suuvv57LQ62/M41++OEHNmDAAPbDDz+wP/7xj8xqtbKuXbsySZLY4MGD2fDhw5kkSSw6Ovq01drsqOX569HZLPsPPviA6fV6duGFFzKDwcAuvPBC1rlz5zC7ayudzbI4m0lN7oMHD2YA2ODBgzt08f+E1q1bx6ZPn84mT57MJk6cKPuIGJk0aRIzmUxs4MCBzGQysUmTJnVgo510Mr6uPXaq1+uZXq9nM2bMYDNnzmQTJ05kWVlZTKvVsszMzP9r777DorryPoB/p88AI0VQYIUBQYIYNEgsiQVbLLursa0x2axojFl9LLGsqIklZt2UdS1RE6NGor4mRBOJuym+Ync1scWKmAgo2BUEBARp83v/8L3XGWYoMwxyB3+f55nH8ZbT7jn3cu7M3J94XOvC0ed/RzEtl1KppJYtW5JeryelUkmBgYE11l2q9bJXdeNaSvj6X/940i5xarWaUlNTLWKbq1QqUqvVdPbsWTG2OQBSqVTi5FuY4Gs0GlKr1RQcHEwASKlUksFgoObNm5NaraZmzZoRAHF/Hx8f0ul0pFaraffu3aTRaCg1NZUAmOUtlO/7778nAPTDDz+QWq0mnU5HqamppNFoxPIREWVkZIjppqamiv8SEUVGRtKCBQtIo9GQq6srAaCzZ8/SuHHjaP78+WJ7WEtPaoR2J3oUY9Pb25sWLFgg3nCYM2eOw2KtmuZTmRRjeTY2ztz2kZGRtGrVKiIicnNzo/T0dDIajRbjrracuS2cmbV29/b2pkmTJlm0Ox+LxqmmiYppHzF9b9ofuG/Unj3nOlvGqV6vJzc3N4vjGhUVRXK53CETUEef/x1FKFdCQgIBoF69epFarabAwEBq2rRpjXWXar3s4Uw3IPj6X//46/ESFxAQgD179ljENm/SpAn0ej3i4uLE2OYuLi5mYdzS09NRXl4OnU4HV1dX8TfpSqUSN27cQFZWFp555hnxN+UqlQr+/v7IyckR48HHx8cjICAAu3fvhlarFfN2d3cHAPj7+yMuLg5NmjTBzJkzxVjyu3fvFtd16NABwMMngQrp7tmzR/wXANLT06FSqcR47mq1GnFxcYiNjcXatWsBAFlZWVbTk5r09HTx5wJCjE3hXyHM3QsvvACj0eiwWJvOFMuzsXHmtk9PT8cf/vAHAA/H3P379yGTyTBt2jRx3NnCmdvCmVlr97KyMgwcONCi3flYNE7vvfceli1bhu+++w5qtRofffQRfv31V4wYMQKBgYFmfcT0vWl/4L5Re/ac62wZp4LKx3Xx4sVwc3MTj2tdOPr87yhCud577z24uLhg+fLlUKvVWLduHZRKZY11l2q97FHTuJYSvv7XP560S9yMGTMwZcoUBAQE4MyZM/jll1+QlJSEu3fv4u7du0hKSsKJEydw5swZPPXUUygtLQUA3Lx5E0SEHj16iBN8Yd2DBw9QVlYGo9GIS5cuobS0FAqFAkajEXq9HhUVFVAqlVAoFPjyyy9RWFiIyZMnY8CAAThy5Aju3r2LrKwsuLu7IzMzEykpKXB3d0dKSgru3LmDq1evYsKECbh69SoyMjLE37MUFhZi7ty5Yp38/f0xadIk9O7dGxUVFViwYAH8/PxQVFSEgQMH4vLly+jZsydu376N0NBQtGjRwmp6UiPcYMnKyhJjbA4fPhyTJk0Sbzh88skncHd3d1isTSGfyqQUy7Oxcua29/T0REFBAQDgd7/7HZKTkwEAeXl5KCoqsjk9Z24LZ2at3f/yl7/grbfesmh3PhaNU00TFdM+YvretD9w36g9e851tozTkJAQhISEWBzXTZs24dVXX3XIBNTR539HEcqVnp6OgIAAJCcnQ61W486dOyguLq6x7lKtlz2c6QYEX//rn7KhC8CqN2HCBPj6+mLJkiV48OCB+IC4p556CgBw8eJFZGdno6SkBC4uLkhMTMTdu3fx9ttvIzs7G3K5HFeuXAEAMV44ALi4uEAul4ux2w8fPowLFy7grbfegkajEWO/a7Va3L9/HzqdDgcOHEBERAT69OmDa9euYd++faCHP7FAXl4e3NzcAAA+Pj7o3bs3hg8fbhavffDgwWK9hDpptVocPHgQFRUVUKvVMBqNGDlyJHbv3o1BgwYhNzcXvr6+GDt2rEX8d9P0pGT9+vV48cUX0aJFC2i1WhQWFortnpubCy8vL+Tn50Or1WLlypWIiIhAdHQ0YmJiANgfa3P9+vVISkqyGstz+vTp4nYNFcuzMXPWtu/evTt27dqFyMhI/OlPf8Kbb76JvXv3YteuXejdu7ddaTprWzi7yu3+7bffIicnB5cvX8bBgwcBPLyZW1ZWxseiEbI2UYmMjDSbqAh9hIiQmpqKTz75BEajEa1atYK3tzcKCgoQERHBfaOW7DnX1Xac5ufnQyaToby8HC+88IL4t9jXX3+NsWPHYuHChcjJycH06dPtPkb1cf53BKFcnp6e6NOnD958800QEaZNm4bevXvXOPmWar3sUZtxLSV8/a9fHPKtkTIajUhKSsKvv/6K3377DQAQHh6OsLAwEBHS0tIAwGIi3FBycnLw4MED+Pv7w2g04p///Cd++ukntGrVCnPnzpVcWLeaCO0/efJkAA8vwiqVqtp9nnnmGbtjbTpTLM/Gxpnb3tHjzpnbwplZa/fTp09b3faZZ54x+z8fi8bhlVdewbPPPovp06fj73//O1auXIkXX3wRu3btQvv27ZGbmytuW1XfEAh9hPtG1ew519kyTgX379+HQqGAVquFh4cHrl+/Dm9vb+Tk5ECv1yMyMtLuYyTVv7uEcv3tb39DdHQ0ysrKsGHDBly5cgXDhw/HwYMH0b59eyQmJla7v9TqZY+axnVVbdAQ+Ppf/3jS7kRqim3erVs3cZsLFy4AACIiIjBz5kwYjUZxeXFxsfgVeK1WK27TrVu3WpehcvrV5V2bdG3NizHGGGMPNaaJCnvkST6uT3LdBdwGzBRP2iVIiMNuqqSkpMqvwigUClRUVECj0aCkpAQqlQrjx4/H3r17kZ6ejgcPHgCA+EC67OxscR/hwXWOpNPpAEB88MSGDRswceJEyGQy8WaDNUI5hN/fl5eXo3v37nj66acRGhqKQ4cOYfv27diwYQNeeeUVh5bZ0fiGA3MWRqMRaWlpuHPnjvgzDkH37t0bqFSMMcbqm1TP/3Utl1TrxVhd8KRdgjZu3GixbM6cOQgMDMSvv/6K8PBwREZGAnj4MLYDBw4gJiYGX3/9NUaMGAG9Xo/4+HhER0fj+PHjkMvlICIYjUZxYvyXv/wF58+fR0pKCkpKStCyZUtkZ2ejXbt2VZbr+PHjaNu2LTQaDQAgLCwMAHDu3DkcP34cHTp0QGRkJLp27Sruc/fuXaxbtw6zZ88GABw6dMhq2nfu3MG+fftQWFgI4NEEXiaTQSaToaKiAsDD38GsW7dOnAxL0ebNmzFmzBgMHToUXbp0wZUrV/D999/jt99+Q/PmzaFUKsWLiPC7H0d8xenEiRPYunUrrly5Ij50UCClr1A1Rs7a9keOHMErr7yCzMxMi5t3puPOFs7aFs7OWrvn5ubi+vXraN++PR+LJ0BNExXTPnL79m1cv34dRUVFMBqN4rUI4L5RW/ac62wZp7m5uejQoQMyMzORk5ODkpIScd2iRYsA1G0CWh/nf0cwLVflfiyTybB//34AVdddqvWylzPdgODrfz17jOHlWB1Yi21ORGI8dCGOempqKoWHh9PSpUvFf4W46kI89jlz5lB4eLi475IlS6hly5ak0WhqVYbKTPO2tq6mdImI2rVrR3/6058oJSWFcnNzSa1W08mTJykvL4/y8vJsTq8hCe1O9CjGZlRUFAEghUJBMpmMlEolNWnSxGGxNp0plmdj48xtX3ncCeOt8rirLWduC2dmrd19fX0JALVo0YKPxRPg559/puDgYJLL5SSTycxecrncrI8I1yFXV1exj3DfsI095zpbxqlOpyO5XE5dunQhABYv4bjWhaPP/44ilCshIYEMBkOVfbqm/aVWL3vUNK6lhK//9Y8n7U4iJCSEVq5cScHBwbRs2TK6d+8e3bt3j1avXk0tW7akpUuXklKppGXLlllM8H18fMjHx4dUKhUBoHfffZc0Gg2tXr2aQkNDKTU1lZRKJYWGhhIRUXFxMd27d49u375NV69epatXr9Lt27fJYDCY5S1sK+S9ePFiunr1qrheKJ+QrjVCXjqdjg4ePCjuHxwcTJ9++qnF9jWlJwWmNzciIyNp1apVFBkZSWq1mtRqNbm5udFLL71E8+bNo3HjxtH8+fPrnKeQDxGRm5sbpaenk9FodFj6rGrO3PYuLi5Wb7bZy5nbwplZa/fIyEh6/vnnaf78+XwsngA1TVRM+4hcLqd33nmHjEYjqVQqmjx5MvcNG9lzrrNlnHp5edGAAQOoXbt2pFQqaefOnZSTk0OxsbEUFxfnkAmoo8//jiKUy97Jt1TrZQ9nugHB1//6x5N2iSssLKSJEyeSm5ub1butVb1Gjx5NzZo1o27dupFSqSSlUklarZY0Gg3J5XJSqVSkVCpp9OjR1K1bNwJAMTEx5O3tXes89Hp9lXeAZTIZASCNRmMx+RbqVFVewh1FtVpN48ePp02bNtGmTZvor3/9q9X0pCYkJEQso4uLC12+fJlcXFxIp9NRQEAAeXl50fbt28nX15dSUlLI19e3znkK+RAReXl50dmzZ4mIHJY+q5ozt33Pnj1px44dDkvPmdvCmVlrdxcXF9q1axf5+vrysXgC1DRRMe0jAMRx7+7uTk2bNiUi7hu2sOdcZ8s41el05O3tTS4uLuTu7l4v49fR539HEcpl7+RbqvWyhzPdgODrf/3jOO0SFxcXh3379okPXwsMDDT7rYhWq0VpaSkmTpyIZs2aYfny5VAoFNiwYQOUSiUOHTqEp59+GkSE5ORkMV2FQgGlUomEhASUlpaiTZs2uHPnDqKjo5GUlIQJEybg008/BQB07NgRR48exeuvv47CwkJs2bJFjM8OPHxwXr9+/fDVV1+hefPmyM/PR0lJCVq1aoV//vOfePHFF63WKSwsDNnZ2RgxYgS2bdsGIkL79u1x5coVTJ06FVqtFps2bUJCQgIUCgVat26NLVu2WKQnNTNmzMCUKVNw+vRpaDQafPnll5DJZCgqKkLfvn1x7NgxnD59GkVFRQ6LtelssTwbE2dr+7Nnz4rvJ0+ejBkzZuDWrVuIjIy0CEvYtm1bm9J2trZoLKy1u6enJ27duoWioiIYDAY+Fo1cp06dkJaWhtDQUKvrTfuIUqnEmTNn0L9/f3h7e+PGjRsAwH3DBvac62wZp25ubigqKkKnTp1w+fJlh43f+jz/14W1cgUGBmLHjh2IiYmpsVxSrVdd1TSupYSv/49Bw94zYDUJCAigffv2ERGRXq8X77h5eXlRx44dLZZv2rSJBgwYQImJidSlSxdyc3MTP2nX6/UUHh5OrVu3Ji8vL/Ly8qIuXbrQ9u3bxXwCAgJIp9NRamoqyWQyGj9+PA0YMIC0Wi11797dIm+ZTEabN28mIjLbRihHdXWCySfz1v4VPnGX2u92akNof7VaLd4xj4qKIh8fH4qOjia5XE4Gg4EMBgMNGTKkzvm9/PLLtGTJEiIievfdd8nHx4def/11h6XPquZsbS+Mqcq/jzP9nZy9487Z2qKxsNbuISEh5OnpSUOGDOFj0UidOXNGfCUmJlJERAR9/vnndOLECbN1Z86cMesjkZGR5OrqSq+//jq5u7uTWq3mvmEje851tR2nQ4YMIa1WS6GhoZSYmEg+Pj6k1+tp8ODB5OfnR7169RKPq63q8/xfF0KeqOKbnaZ/H1qru1TrZQ9bxrWU8PW//vHT4yXOzc0NKSkpCAwMRIsWLZCYmIiOHTvC1dUVRISioiKz5ZcvX0ZkZKT4FHZb84mIiICbmxv+85//oHPnzlizZg2mTZsGvV6PvLw8FBcXm+Utl8uxfft2DBo0CH5+fuI21ZVDyCs8PByurq747LPP8Ne//hXvvvsupk6diqSkJPTt29fsCfEGg6HObdkQhBibWq0WRUVF2Lx5Mw4fPoy8vDy4ubkhIiLCIbE2OZZnw3G2ts/MzKz1traOO2dri8bCWrvv378fBoMBH3zwAdzd3flYNEJyubzasK3COplMhqysLLGPZGdnY+nSpUhOTkZoaCj0ej1OnTrFfcMG9pzrajtO58yZYxH2F3gUVUeICGTPk9Dr8/xfF0K5goODa92nTesu1XrZw5ZxLaUn4fP1v/7xpF3ChK+aVI6nXtVglslk0Ol0KC4uNltuup81Hh4eyM/Ph06nQ3BwMFQqFXr27Ik1a9aguLgYRqMRMpkMRqMRnp6eyMvLE08YVCk0m7BNSUkJiouL4eHhAeDhYBa0bdsWK1euxOTJk8W8tm/fjsuXL4OIxDp4eHigpKQERAStVmtWZtP0GGP2ef/999G8eXO89tprZsvj4+ORlZWFWbNmNVDJGGM1aUwTFfbI4zquUjz/Z2Zm4uOPP4a3tzdeeukls3VbtmxBTk4OJkyYAKDqukuxXrbgcc2qwpN2Cdu4cSN27tyJjIwMtGnTBtevX0dSUpIYc91gMMBgMCA3Nxfnzp2zOX21Wg3g4e/bysrKMGLECERHRyMtLQ3x8fEoLS2F0WiEXC6H0WiEQqGATCZDeXk5oqOjERUVhUOHDuG3334TJ+zCNhUVFXj55ZfRt29fAEBsbKyY77Jly6BQKFBRUSHm9eDBAwCP7iAL+6anp2P16tX417/+ZVZ20/SkwNPTs8qbIsLxEl4ffviheLOjXbt2ABwTa9OZYnk2Ns7a9kFBQfjyyy/x/PPPmy0/evQoRo4cicuXL9ucprO2hbOz1u5GoxHXr1+HwWDgY9HI1WaiYtpHysvLcf36deTm5oKIxGsRwH2jtuw519kyTo1GI7777juo1WoMGDDALJ20tLQ6T0Dr4/zvCEK5Dhw4YNanhXLNmzev2rpLtV72cLYbEHz9r188aXcymZmZ+OWXXxAaGmr2MI0lS5YgIyMDN27cgJeXl7j84sWLFmmEhYUBALp27Wq23HQiLOTj4uKCoqIihIaGwt3d3WrepmWqapua6tSqVSusXbsWTZo0Mdv30qVLiIiIECf1UrVx40ary9PS0rBmzRpkZWVZXS98Q6GuX3E6cuQIXnnlFWRmZlp8C0NqX6FqbJy57bVaLS5cuIDg4GCz5faOO2duC2dmrd1N27/yDUU+Fo1PTROVhIQEsY9U/mMaeNRHuG/Ujj3nOlvGqbU0Td//9NNPdZ6AOvr87yhCuXr27GnWp4VyHThwoNq6S7Ve9nCmGxB8/a9//PR4J2MwGNC8eXOUlpbizp074lPkx40bBwBo0qQJAODBgwfiOkGTJk3MlgvvhX3y8/PF98Kn+Nbyr5y+p6cn+vTpI+4rlC8/P98s7+rqZDAYoFQqMXToULN1hw8fhq+vr1laNaXXEKr65P+ZZ55Bjx49cPbsWbRu3Rpz5sxB8+bNxQuwu7u7Q/IfP348nn32Wfzwww/w8/Or8lN/5njO3PYBAQE4fPiwxR83hw8fhr+/v83pOXNbODNr7d61a1eEhoZizpw5CAsL42PRyN26dQt+fn4Wy318fHDz5k2zPjJixAixbwjXI0ddi54U9pzrbBmnwvIff/wRx44dQ1BQkFlad+/exc2bN+tUB0ef/x1FKFflPi2US+jTNe0vtXrZo6ZxLSV8/a9/PGmXoBUrVuCNN96AVqvFihUrAAAlJSX49NNPxdAglQm/L+/WrRtOnTolbkMmodmaNm2KnJwcq3fAhN+oR0ZGIjg4GAqFAmlpaWbbBQQEID8/Hz/99JPF7+wBoGXLlrh+/brZzQJh0C5btgxvvPEG1q5di7KyMqhUKhw4cEDcTqvVYuzYsVi2bBkGDhyI0tJSHD16FPv27QMAiwdYOMsdu9TUVHz++efo2rUrEhISEBISUi83HFJTU/HNN984RViQxsaZ237cuHGYOnUqysrK0KtXLwDAnj17EBcXhxkzZticnjO3hTOz1u6XLl3Ct99+y8fiCVHTRMW0j3DfqDt7znW2jFNheXJyMs6dO2f28wUA+M9//lPnCaijz/+OIpTL3d0d//73vzFkyBCzctU0+ZZqvezhTDcg+Pr/GNTHI+lZ3QQFBVF2drb4PigoiPR6PQEgjUZjERbNxcWFFAoFabVaUqlU5OPjQwqFgtzc3KoMn2Ht5ePjQwBIoVCQUqm0uo1KpRLfe3t7W4ToEMJqNG3alDw8PKhFixa0efNmsU5BQUEUEBBAQUFBYig6pVJJCoVCrJPwkslk9NJLL5FOp6P4+Hj6+9//LqYnZYWFhTRx4kSxPU1DldRXuJGePXvSjh076iVtVj1nbnuj0UhxcXGk1WpJLpeL55OFCxfalZ4zt4Uzs9bufCyeLB9++CE1bdqU4uPjKSMjgzIyMmj9+vXUtGlTeu+998z6A/eNurOnDW0Zp8Lymo5rXTj6/O8oQrmEv0NlMhlptVqaNm1areou1XrZoz6Pv6PxeaX+8W/anURgYCA2bdqEUaNGITs7G2fPnkX79u0xf/587N27Fy+//DLeeOMN7NixA19//TU+/fRTdOnSBYcOHYJarUZJSQk0Gg1KSkrg6uqKsrIyEBH8/f1RUVGBP/7xj8jMzMSPP/5YYxl69OiBJk2a4OTJkwgNDcX//M//iHlbW5eQkFBtuqYKCwtx4cIFDBo0CBs3bkTfvn3rlF5DeOmll3D8+HEMGTIEK1asgKenJ1q2bIkTJ05g8ODBGD58OJTKh19yEZ4vUNvf/5s6e/as+D49PR1z587FzJkzERkZCZVKZbatPemzqjW2thfGnU6nQ6tWraDRaGq9b2NrC2dhrd1HjhyJVq1aQalU4urVq1i1ahVGjx6N3//+93wsGjkiwuzZs7FixQrx225qtRpjxozB+PHjsWfPHrE/6HQ6rF69GqNHjxb7i3AtArhvVMWec50t41RYBkBcPnfuXOzfvx9btmxBWVkZgIfHdc6cOZg/f75D6lWX8399KigowMSJE7F161ax7lqtFrNmzapV3aVaL1tYG9e2tEF94+v/48WTdgmaPn26xbJVq1YhLCwMFy5cgFwuR0hICC5duoT+/ftjx44dGDVqFOLj4zF27Fhs3boVGo0GCoUC+fn5ICI8ePAAHh4eyMvLw9SpU7Fy5UqoVCqUlZWhRYsWyM7ORlFREXx8fKos1507d9CmTRtkZWUhOzsbrVq1gqurK0pKSnD+/Hk8/fTTUKvVuHjxIgYOHAg/Pz9MmjQJkZGReOONNwDA7CvxVYmJicGqVauQlpZmEZ/e3jj0j5NMJhOfuF+bbe19QIezxvJsDLjtH+G2aBjW2r26YyD8y8eicTOdqLRt21Y85jX9qVeX2N9PCnvOdbaM06rSFPYxTb82f180Fo1h8l1XUm0Dvv4/Xvybdgk6deqU2f9PnjyJ8vJyXLp0CQBQXl6Oixcvgojwww8/QKFQICkpCQCQkJCAkpIStG3bFseOHYOXlxcqKipQUlIiPjEzNTUVRqNRHGS5ubm4f/8+gIcT8+pcuHBBvFhcvHgRrq6u4r7nz5+Hq6srioqKsG3bNnTp0gXfffcdPDw8xDoJdSgoKKgy1nxaWhrUajUuX76MwMBAhIeHY+vWrejYsaOYnpTpdDrs3r0bRITBgwfjvffeQ0REBG7evIlXX30Ve/bsEbdt0aKF3flI6amhTxpu+0e4LRqGtXa/du2a1W3rcp5hzsXNzQ0dOnQAYN5HquobAu4jNbPnXGfLOLWGj4t5n35SSbUN+Pr/ePEn7RK3dOlS7N+/H506dYJer0dFRQXOnz+P+Ph4cdKrVCphNBrRv39/XLlyBXfv3sWMGTMwc+ZMcRsfHx8UFRWhvLwcZWVl4sRbpVKBiFBeXo42bdpg5MiROHbsGDZu3IiPP/4YH3/8McaMGYOUlBQQEZ577jls3rwZBQUFuH37NsrLy1FRUYEXXngBN2/exOjRo9GyZUsMHz5c/LR56dKlePPNNy3q1LFjRzEvABgzZgyio6Pxyy+/gIjQu3dvTJkyBbt378bAgQNBRCgrK7NIT2ratm2LlStXIiYmBqGhoQgJCUGPHj1w7tw5HDx4ENeuXRNjbPr4+Dgk1qazxfJsTLjtH+G2aBjW2v3999/HxYsXER4ebtbufCyeTKZ9xPS9aX/gvlF79pzrbBmnw4YNg0wmwzfffFPr9BlrSHz9fwzq7+fyzBH8/f0pOTnZYnnTpk1Jr9fTjh07aNu2bXTmzBkiIjp37hzp9Xr66KOPaO7cudSvXz/SaDTiA+SEB8UJy9VqNclkMnJzc6Pk5GSz/Pz9/enbb78lPz8/OnfuHPn5+RERUbNmzcjb25syMjLIy8uLtm3bJuYtbLNz507y8PAQy2WtTpXrJuxvmo4gIyPDrJ5StnTpUvroo4+IiKh58+akVqvFh6ksX76ciIiOHDlCQUFB4r91ZTAY6PDhwxbLHZU+qxq3/SPcFg3DWrsbDAZau3atRbvzsXgymfYR0/em/YH7Ru3Zc66zZZz6+vqSr6+vTekz1pD4+l//+OvxEpefn4+srCyL5UVFRSAi9O/f32x5VlYWiAhTpkwRl2VmZuKXX36Bi4sLioqKEBoairZt24rLQ0ND0aVLF2RlZZnll5+fj8uXL6OgoABZWVkoKCgA8Oir7QaDAaWlpfDy8hLzFrZRqVQoLy+3+uAJIY/KdRP2N01HUFXceCmaNm2a+D4vLw979uxBr169sH37dvz+978H8CjGpqNibTpTLM/Ghtv+EW6LhmGt3W/duoWwsDCLdudj8WQy7SOm7037A/eN2rPnXGfLOM3JybGaBh8jJlV8/a9/PGmXsBUrVmDQoEEYNmwY/vjHPyIkJARHjhxBTk6O+BTJoKAghIWFoWvXrvjxxx+RmpqK1q1bY9iwYXj++eehUqmwfv16BAcHo1evXlYfBBcTEyPuEx0djVGjRmHevHl4+umnMWPGDDz11FOIjY1FSEgIXnvtNfFhEp07d0ZwcDCGDBkifs1b2Obf//43WrduLcaZN72JMGTIEPGr8EJeRIRZs2YhKioKY8eONdvXGtP0pCwgIAAZGRkwGAxmF2EhxqajYm06UyzPxobb/hFui4Zhrd0DAgKQkJBg0e58LJ5Mpn3E9L1pf+C+UXv2nOtsGaeenp5WHzbHx4hJFV//H4OG/aCfVScoKIiuXLkixmiv/Koc1xz/H8fdw8OD5HI56XQ6s7jqwnuZTCbGDJfL5eTl5UWenp6k1+vFr3JXl5ebm1uNMeD1ej0ZDAYKCgqi4OBgs3rdv3+fJkyYYDUvlUpFEyZMEPe19qqcnhR89NFHVFxcLL4XXoMGDSJXV1dq164d6XQ6GjRoEH344Yfk4eFBQ4cOdVisTWeK5dnYcNs/wm3RMKy1+/Dhw0kmk9GwYcP4WDCzPjJ79mzy9PSkMWPGkIeHB82cOZP7ho3sOdfZMk5dXFzIxcWFz6XMafD1v/7xpN1JFBYW0pkzZ+jMmTNUWFhosdzf358yMzMpKCiIAgICKCgoiJRKJQEghUIhvgdASqWSlEql1YmwkN7PP/9MR44coTNnztDt27erzbu6bWpTJ9O8aruv1AQFBVF2drb4XngZDAZq0qSJ1ZsgLi4utHDhQofkbzQaKS4ujrRarXgzxpHps6px2z/CbdEwrLW7TqejLl268LFgRGTeR0xvwgs38Llv2Maec50t4/Sdd97hcylzKnz9r3/89HgJE+K1VxfbXAgdIoQFiYmJsdin8jaVCfvIZDIsWbLEahmsqVwuIZ3KrKVrTXV52ZOelAgxNun/n4Dv7u5eL7E2pRrL80nAbf8It0XDsNbufCyYKdP+4Ofnh0uXLnHfqAN7xpct45THL3M23GfrD0/aJaxnz54AgNOnTwOwHttc+M2TTCaDWq1GWVkZiAgymcxsvTUymQxKpVJ836VLF+zdu9dqGQRCzPinnnoKqampKCoqgkwmg16vh9FoFNcBD+O4KxQKREdHW6RbXX2t5WVPeo9TY77hwBhjjDHGGGs4/CA6Cdu3b5/4vqbY5itWrAAR4d69e3B1dUVhYaHFBN+Ui4sLVCoViouLodFooNFo8Ic//KHGMuj1emzcuBGenp4AgNzcXIwZM0a8OWBtXbdu3eyqb1V51Ta9x+nUqVNm/6/uhgNjjDHGGGOM1RZ/0u4kfve73yEpKQl9+/ZFUlIS2rRpAwBITk4Wl7Vr1w5nz57Fzp07zSb4P//8M4gIvr6++O2339C5c2cMHjwY/fr1Q58+fdC5c2eEhobiyy+/xI0bN2osg5C3IDk5Wczb2rq+fftWm66tedmT3uMk3GCp6obDjBkzGriEjDHGGGOMMWfBn7Q7idrENjcajcjKysKSJUvMJvgdOnQAESErKwsVFRV47bXX8Pbbb6N9+/a4f/8+Fi1ahJiYGDGMXE1lqMw0b2vrKsdct6W+jkrvcRLaX5iwAw/DtyxatAh9+/blSTtjjDHGGGOs1uQNXQBWO5Vjm69btw5r165FbGwsoqOjMXbsWLRs2RJjxoxBTk4OUlJScO/ePXzzzTdQKBRQKpXIy8uDTCbDrFmzkJ2djdjYWPTr1w/btm1Dbm4uhg4dWqsyJCYm4tq1a7h27Rq2bdtmlre1dTWla2te9qT3ODnzDQfGGGOMMcaYtPDX451EUVER/va3v2H9+vVmn4jLZDKoVCqMHTsWCxcuxIIFC7BmzRqzB9B17doVRITDhw+bpSk8rI6IEBYWhpMnT8LV1bXGMsTHx6OsrAwAoFQqzfK2tm7x4sXVpmtrXvak9ziNGjUK//3vf7FkyRJ07NgRAHD06FHMnDkT3bp1E59HwBhjjDHGGGM14Um7k7l//z7S09PFp7brdDqEhISYTWKzsrIwadIkfPvtt+KEVyCTySCTycSH1CkUCowePRrLly+v9URYKAMAi7yrW1eX+joqvcfBmW84MMYYY4wxxqSFJ+2NWFUTfABONxF2Rs54w4ExxhhjjDEmLTxpZ4wxxhhjjDHGJIofRMcYY4wxxhhjjEkUT9oZY4wxxhhjjDGJ4kk7Y4wxxhhjjDEmUTxpZ4wxxpjDBAUFYfny5Q1dDMYYY6zR4Ek7Y4wxJlGjR48WQ3WavtLS0hqkPPn5+Xj77bcRHh4OrVYLX19f9OnTB4mJiaiP59pmZGRAJpPh9OnTDk+bMcYYcxbKhi4AY4wxxqrWv39/fP7552bLfHx8Hns58vLy0LVrV9y7dw+LFi1Chw4doFQqceDAAcTFxaFXr17w8PB47OWqrbKyMqhUqoYuBmOMMWYz/qSdMcYYkzCNRgNfX1+zl0KhwOjRozF48GCzbadOnYoePXoAePQpdeWXsL5Hjx5W12dkZFgtx1tvvYWMjAwcPXoUsbGxiIiIQFhYGMaNG4fTp0/Dzc3NYh9rn5Tn5eVBJpNh//79AIDc3Fz8+c9/ho+PD3Q6HVq1aiXepAgODgYAREVFmZUdAD777DO0bt0aWq0W4eHh+OSTTyzy3bJlC2JiYqDVavHFF1/UvtEZY4wxCeFP2hljjLFGKCAgADdv3hT/f+vWLfTp0wfdu3cHACQmJqK0tFRcP3HiRJw/fx7Nmze3SMtoNOKrr77Cn//8Z/j7+1ustzZhr6158+YhJSUFO3bsgLe3N9LS0lBcXAwAOHbsGDp27Ijdu3ejTZs2UKvVAIAvvvgC8+fPx6pVqxAVFYVTp05h3LhxcHV1RWxsrJj27NmzsWTJEkRFRUGr1dpdRsYYY6wh8aSdMcYYk7Dvv//ebFI8YMAAfP311zXup1Ao4OvrCwB48OABBg8ejOeeew7vvPMOAMDLy0vcdtmyZdi7dy+OHj0KnU5nkVZ2djZyc3MRHh5ex9pYunLlCqKiovDss88CePggO4HwM4CmTZuKdQGABQsWYMmSJRg6dCiAh5/Ip6SkYM2aNWaT9qlTp4rbMMYYY86KJ+2MMcaYhPXs2ROrV68W/+/q6mpzGq+99hoKCgqwa9cuyOXmv4zbsWMHZs+eje+++w5hYWFW96+Ph8wJJkyYgGHDhuHkyZPo27cvBg8ejOeff77K7e/fv4/09HSMHTsW48aNE5eXl5fD3d3dbFvhRgBjjDHmzHjSzhhjjEmYq6srQkNDLZbL5XKLyXRZWZnFdosWLcLOnTtx7Ngx6PV6s3UpKSkYOXIkPvjgA/Tt27fKMvj4+MDDwwO//vqrTWUXbhCYlrNyGQcMGIDMzEz8+OOP2LVrF3r37o2JEyfiX//6l9U0CwsLAQDr1q1Dp06dzNYpFAqz/9tzg4MxxhiTGn4QHWOMMeaEfHx8zH6zDsAiNNq2bdvw7rvvYuvWrQgJCTFbl52djYEDB2LYsGGYNm1atXnJ5XKMHDkSX3zxBW7cuGGxvrCwEOXl5VbLCMCsnNbCt/n4+CA2NhabN2/G8uXLsXbtWgAQf8NeUVEhbtu8eXP4+/vj0qVLCA0NNXsJD65jjDHGGhP+pJ0xxhhzQr169cLixYuxadMmPPfcc9i8eTOSk5MRFRUFAEhOTsaoUaMwa9YstGnTBrdu3QLwcCLs5eWFYcOGwcXFBe+88464Dng4ga78iTUA/OMf/8D+/fvRqVMn/OMf/8Czzz4LlUqF//73v3j//fdx/Phxi5BvOp0OnTt3xgcffIDg4GDcuXMHc+fONdtm/vz5iI6ORps2bVBSUoLvv/8erVu3BgA0a9YMOp0O//u//4sWLVpAq9XC3d0dCxcuxJQpU+Du7o7+/fujpKQEJ06cQG5uLqZPn+7IZmaMMcYaHH/SzhhjjDmhfv36Yd68eYiLi0OHDh1QUFCAUaNGietPnDiBoqIiLFq0CH5+fuJLeDDbwYMHkZycDIPBYLb+6tWrVvPz8vLCkSNH8Oqrr2LRokWIiopCt27dkJCQgMWLF1v8nlwQHx+P8vJyREdHY+rUqVi0aJHZerVajTlz5qBt27bo3r07FAoFvvrqKwCAUqnEihUrsGbNGvj7++PFF18EALz++uv47LPP8PnnnyMyMhIxMTHYsGEDf9LOGGOsUZJRfT5dhjHGGGOMMcYYY3bjT9oZY4wxxhhjjDGJ4kk7Y4wxxhhjjDEmUTxpZ4wxxhhjjDHGJIon7YwxxhhjjDHGmETxpJ0xxhhjjDHGGJMonrQzxhhjjDHGGGMSxZN2xhhjjDHGGGNMonjSzhhjjDHGGGOMSRRP2hljjDHGGGOMMYniSTtjjDHGGGOMMSZRPGlnjDHGGGOMMcYkiiftjDHGGGOMMcaYRP0fYXTqFgZ0XpwAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "\n",
    "def plot_clusters(df):\n",
    "    \"\"\"\n",
    "    Create a high-contrast plot of fuzz_clusters.\n",
    "\n",
    "    :param df: DataFrame with paragraph data and extended dialogue clusters.\n",
    "    \"\"\"\n",
    "    # Get the size of each cluster\n",
    "    cluster_sizes = df['fuzz_cluster'].value_counts()\n",
    "\n",
    "    # Generate a list of unique colors for the clusters\n",
    "    colors = list(mcolors.TABLEAU_COLORS) * (len(cluster_sizes) // len(mcolors.TABLEAU_COLORS) + 1)\n",
    "\n",
    "    # Create the bar plot\n",
    "    plt.figure(figsize=(12, 6))\n",
    "    plt.bar(cluster_sizes.index, cluster_sizes.values, color=colors[:len(cluster_sizes)])\n",
    "\n",
    "    # Set plot title and labels\n",
    "    plt.title('Cluster Sizes')\n",
    "    plt.xlabel('Fuzz Cluster')\n",
    "    plt.ylabel('Size')\n",
    "    plt.xticks(rotation=90)  # Rotate x-axis labels for better readability\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "# Plot the clusters\n",
    "plot_clusters(df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8kAAAE8CAYAAADzDPMaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5A0lEQVR4nO3deXQT9f7/8VfSJF1o05atZSmLIAJ6QRZBRMEfIqiogAuKqKDX9YrAVRS5qOhV3PB68YuI3+v3KgooV0G4qIiiLKIgqGyyyCIgyK7QDeiaz+8PpoHQhSRtkxSej3N6TjPzycx78pnJzCszmdiMMUYAAAAAAED2cBcAAAAAAECkICQDAAAAAGAhJAMAAAAAYCEkAwAAAABgISQDAAAAAGAhJAMAAAAAYCEkAwAAAABgISQDAAAAAGAhJAMAAAAAYCEkAwDKZdCgQWrUqFFY5v3UU0/JZrP5DGvUqJEGDRoUlnr8tW/fPt1www2qUaOGbDabxo0bF+6SQiqc6wwAAKdCSAYAFGOz2fz6W7hwYbhLrZL++te/6vPPP9fIkSM1efJkXXHFFaW2Le21T01NDWHF/snMzNTTTz+t1q1bKz4+XrGxsTrvvPM0YsQI7d69O2R1vP7665o0aVLI5gcAOL04wl0AACDyTJ482efxu+++q3nz5hUb3qJFC7355pvyeDyhLK9MGzdulN0e2Z8Bz58/X71799bw4cP9an/55Zfr9ttv9xkWGxtbGaUFbevWrerevbt27NihG2+8Uffcc49cLpfWrFmjf//735o5c6Y2bdoUklpef/111axZM+KvKAAARCZCMgCgmFtvvdXn8Xfffad58+YVGx6JoqOjw13CKe3fv19JSUl+t2/WrFlEv/YFBQW67rrrtG/fPi1cuFAXX3yxz/gxY8boxRdfDFN1FaOgoEAej0culyvcpQAAKllkf9QOAIh4J3+/dPv27bLZbHr55Zc1YcIEnXXWWYqLi1OPHj20c+dOGWP0zDPPqH79+oqNjVXv3r118ODBYtP97LPPdMkll6hatWpKSEhQr169tG7dulPWc/J3kidNmiSbzaZvv/1WDz30kGrVqqVq1aqpb9++OnDgQIXNVzp2NvXGG29U9erVFRcXpwsvvFCffvppsVqMMZowYYL30unyKO37vSd/X3vQoEGlXrr91FNPSTr22gVzaf2MGTO0evVqjRo1qlhAliS3260xY8aU+vyFCxeWOI+idenES6f37t2rO+64Q/Xr11d0dLTq1Kmj3r17a/v27d5lWLdunRYtWuSt/dJLL/U+Pz09XcOGDVNaWpqio6PVtGlTvfjiiz5XQ5y4Do8bN05NmjRRdHS01q9fL0kaP368zj33XMXFxSk5OVnt27fXe++9V+ryAQCqFs4kAwAqxdSpU5WXl6cHH3xQBw8e1EsvvaR+/fqpW7duWrhwoUaMGKEtW7Zo/PjxGj58uN566y3vcydPnqyBAweqZ8+eevHFF3XkyBFNnDhRF198sVauXBnUTZ8efPBBJScna/To0dq+fbvGjRunwYMH6z//+U+FzHffvn266KKLdOTIEQ0ZMkQ1atTQO++8o2uvvVbTp09X37591aVLF02ePFm33XZbiZdQlyYnJ0e///67z7CEhISAzprfe++96t69u8+wuXPnaurUqapdu7Ykady4ccrOzvZp889//lOrVq1SjRo1Sp327NmzJUm33Xab3/UE6/rrr9e6dev04IMPqlGjRtq/f7/mzZunHTt2qFGjRho3bpwefPBBxcfHa9SoUZKklJQUSdKRI0fUtWtX7dq1S/fee68aNGigJUuWaOTIkdqzZ0+xG6i9/fbbysnJ0T333KPo6GhVr15db775poYMGaIbbrhBQ4cOVU5OjtasWaNly5bplltuqfTlBwCEgAEA4BQeeOABU9ouY+DAgaZhw4bex9u2bTOSTK1atUx6erp3+MiRI40k07p1a5Ofn+8d3r9/f+NyuUxOTo4xxpisrCyTlJRk7r77bp/57N271yQmJvoMHz16dLG6GjZsaAYOHOh9/PbbbxtJpnv37sbj8XiH//WvfzVRUVHeGgOZb0mGDRtmJJnFixd7h2VlZZnGjRubRo0amcLCQu9wSeaBBx4oc3onti3p7+233zbGFH/9i5T02pxo8+bNJjEx0Vx++eWmoKCgxDYffPCBkWT+/ve/l1ljmzZtTGJiol/LU1LNCxYsMJLMggULfNoVrUtFy3ro0CEjyYwdO7bM6Z977rmma9euxYY/88wzplq1ambTpk0+wx977DETFRVlduzY4TNft9tt9u/f79O2d+/e5txzz/VvQQEAVRKXWwMAKsWNN96oxMRE7+OOHTtKOvZ9Z4fD4TM8Ly9Pu3btkiTNmzdP6enp6t+/v37//XfvX1RUlDp27KgFCxYEVc8999zjc/nxJZdcosLCQv36668VMt85c+aoQ4cOPpcbx8fH65577tH27du9l+oGo3fv3po3b57PX8+ePYOe3uHDh9W3b18lJyfr/fffV1RUVLE269ev15133qnevXvr8ccfL3N6mZmZSkhICLoef8XGxsrlcmnhwoU6dOhQwM//8MMPdckllyg5Odmnj7t3767CwkJ9/fXXPu2vv/561apVy2dYUlKSfvvtN33//fflWhYAQOTicmsAQKVo0KCBz+OiwJyWllbi8KLQs3nzZklSt27dSpyu2+2ukHqSk5MrdL6//vqr94OAE7Vo0cI7/rzzzgusaEv9+vWLXSpdHnfffbd++eUXLVmypMTLqDMzM3XdddepXr16evfdd0/5vWm3262tW7dWWH2liY6O1osvvqiHH35YKSkpuvDCC3X11Vfr9ttv9+snsTZv3qw1a9YUC75F9u/f7/O4cePGxdqMGDFCX375pTp06KCmTZuqR48euuWWW9S5c+fgFgoAEHEIyQCASlHS2cmyhhtjJMl7A6XJkyeXGHxOPAtdEfVU9nwrW2kBtrCwsMThr776qt5//31NmTJF559/foltBg0apN27d2v58uV+fSjRvHlzrVy5Ujt37iz2IYg/AlmGYcOG6ZprrtGsWbP0+eef64knntDzzz+v+fPnq02bNmXOx+Px6PLLL9ejjz5a4vhmzZr5PC7pZ7ZatGihjRs36pNPPtHcuXM1Y8YMvf7663ryySf19NNPlzl/AEDVEJl7fADAGatJkyaSpNq1a1fo2dPKnm/Dhg21cePGYsN//vln7/jKkJycrPT09GLDiy4jP9HixYs1fPhwDRs2TAMGDChxei+88IJmzZqljz76SM2bN/erhmuuucYbvEeOHBlQ/dLxs/onL0dJyyAd66uHH35YDz/8sDZv3qzzzz9f//jHPzRlyhRJpYfuJk2aKDs7u9zrVbVq1XTTTTfppptuUl5enq677jqNGTNGI0eOVExMTLmmDQAIP76TDACIKD179pTb7dZzzz2n/Pz8YuNL+tmmSJjvVVddpeXLl2vp0qXeYYcPH9a//vUvNWrUSC1btqzwmqVjwS8jI0Nr1qzxDtuzZ49mzpzp027Pnj3q16+fLr74Yo0dO7bEaX355Zd6/PHHNWrUKPXp08fvGm644Qb96U9/0pgxY3yWv0hWVpb3TtMladiwoaKioop9J/j111/3eXzkyBHl5OT4DGvSpIkSEhKUm5vrHVatWrUSPzjo16+fli5dqs8//7zYuPT0dBUUFJRaY5E//vjD57HL5VLLli1ljClxvQEAVD2cSQYARBS3262JEyfqtttuU9u2bXXzzTerVq1a2rFjhz799FN17txZr732WsTN97HHHtP777+vK6+8UkOGDFH16tX1zjvvaNu2bZoxY4bs9sr5XPrmm2/WiBEj1LdvXw0ZMsT7s1XNmjXTihUrvO2GDBmiAwcO6NFHH9W0adN8ptGqVSu1atVK/fv3V61atXT22Wd7z8oWufzyy70/pXQyp9Opjz76SN27d1eXLl3Ur18/de7cWU6nU+vWrdN7772n5OTkUn8rOTExUTfeeKPGjx8vm82mJk2a6JNPPin2HeFNmzbpsssuU79+/dSyZUs5HA7NnDlT+/bt08033+xt165dO02cOFHPPvusmjZtqtq1a6tbt2565JFHNHv2bF199dUaNGiQ2rVrp8OHD+unn37S9OnTtX37dtWsWbPM17tHjx5KTU1V586dlZKSog0bNui1115Tr169QnLzMgBA5SMkAwAizi233KK6devqhRde0NixY5Wbm6t69erpkksu0R133BGR801JSdGSJUs0YsQIjR8/Xjk5OWrVqpU+/vhj9erVq9JqrlGjhmbOnKmHHnpIjz76qBo3bqznn39emzdv9gnJBw4cUGFhoR566KFi0xg9erRatWrl/S3mgQMHFmuzYMGCUkOyJDVt2lSrVq3SP//5T82cOVOzZs2Sx+NR06ZNddddd2nIkCFlLsf48eOVn5+vN954Q9HR0erXr5/Gjh3rc7OztLQ09e/fX1999ZUmT54sh8Oh5s2b64MPPtD111/vbffkk0/q119/1UsvvaSsrCx17dpV3bp1U1xcnBYtWqTnnntOH374od5991253W41a9ZMTz/9tM/d2Etz7733aurUqXrllVeUnZ2t+vXra8iQIae8AzgAoOqwmaI7lgAAAAAAcIbjO8kAAAAAAFgIyQAAAAAAWAjJAAAAAABYCMkAAAAAAFgIyQAAAAAAWAjJAAAAAABYwvI7yR6PR7t371ZCQoJsNls4SgAAAAAAnEGMMcrKylLdunVlt5d+vjgsIXn37t1KS0sLx6wBAAAAAGewnTt3qn79+qWOD0tITkhIkHSsOLfbHY4SAAAAAABnkMzMTKWlpXnzaGnCEpKLLrF2u92EZAAAAABAyJzqK7/cuAsAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAAALIRkAAAAAAAshGQAAAAAACyEZAAAAAABLUCF5xYoV+umnn7yP//vf/6pPnz7629/+pry8vAorDgAAAACAUAoqJN97773atGmTJGnr1q26+eabFRcXpw8//FCPPvpohRYIAAAAAECoBBWSN23apPPPP1+S9OGHH6pLly567733NGnSJM2YMaMi6wMAAAAAIGSCCsnGGHk8HknSl19+qauuukqSlJaWpt9//73iqgMAAAAAIISCCsnt27fXs88+q8mTJ2vRokXq1auXJGnbtm1KSUmp0AIBAAAAAAiVoELyuHHjtGLFCg0ePFijRo1S06ZNJUnTp0/XRRddVKEFAgAAAAAQKo5An1BYWKj09HR9/fXXSk5O9hk3duxYRUVFVVhxAAAAAACEUsBnkqOiotSjRw+lp6cXGxcTEyOn01kRdQEAAAAAEHJBXW593nnnaevWrRVdCwAAAAAAYRVUSH722Wc1fPhwffLJJ9qzZ48yMzN9/gAAAAAAqIpsxhgT6JPs9uPZ2mazef83xshms6mwsLDM52dmZioxMVEZGRlyu92Bzh4AAAAAgID4m0MDvnGXJC1YsCDowgAAAAAAiFRBheSuXbtWdB0AAAAAAIRdUN9JlqTFixfr1ltv1UUXXaRdu3ZJkiZPnqxvvvmmwooDAAAAACCUggrJM2bMUM+ePRUbG6sVK1YoNzdXkpSRkaHnnnuuQgsEAAAAACBUgr679RtvvKE333zT53eRO3furBUrVlRYcQAAAAAAhFJQIXnjxo3q0qVLseGJiYlKT08vb00AAAAAAIRFUCE5NTVVW7ZsKTb8m2++0VlnnVXuogAAAAAACIegQvLdd9+toUOHatmyZbLZbNq9e7emTp2q4cOH6/7776/oGgEAAAAACImgfgLqsccek8fj0WWXXaYjR46oS5cuio6O1vDhw/Xggw9WdI0AAAAAAISEzRhjgn1yXl6etmzZouzsbLVs2VLx8fF+PS8zM1OJiYnKyMiQ2+0OdvaV6mB2nnq/+pV2Znn8fo5bmfrYOVz1bdmyWefoi07VZ0j6c2otbXS5pKioEp9vL/Co77ce9Vly7NOLE1vlKlrfdhwpuapLUTad6iIAj6dAeRnfSVp+fPqK1hX1blecI1E2u1122Up9frbyNMv5rXJsnlJmlaPmLearevU/ZLNJ9gCuSchUrIbrZR221ZJ06mUJqfx8Ob/ZL1te4FXFKEfjnC+rm229ouylL1mepP91x+tfSYk61Yvnyi7QmLek+odLnl6OYrSk0xOSI8Gv9aIi5Rw9KOVM8j62y6XudW+R21FTtiib7JHUr0E4pKOa4VziuyFWqmx16DhTDkepbxFhlalYPaKXla1ax9bbU/Vvbq6cC3+XXSrjnaa4JKVrrnOoatnyi72PhssuSdem1VWe3R7Ym53F5jFqu6FQQ2ZLLhVfpQLdjnNzM2WOvKtj7yaVzy6nuqbeoBquehGzbeeoQF84f9R+W3YQK0iezmqyVKmpOwLefxUpkEMz1Vuz1FeyldSrJShl/xKnI5rkfFptbTu9tZyqJH+OKYLlyCnQsOlSm53HlurkWvLl1HfnD1Z+QuOQ73fCKS8vW57DUyUdLtd07LKribuNWiV1kd3mkD2YFbAMmcrVdOc38gTdNZG1L8qRS//QUK1XO8lW0hpZhoICOZfvky0rPGupd39mz5fNJv0h6YZ6qToY5ZCigq8oJr1A496QEk0ID1H8ZE9JUaPpHyq6Vq1wl1Iqf3NoUGeS77zzTr366qtKSEhQy5YtvcMPHz6sBx98UG+99VYwk40YFzw7TweyAzv4WOm8S0n2I8eOHU9yVb1U7XQ6VeJIy4D5hbp6mSlxZV900UsqdMaV+fwT5R/5WoW5P/gM65M2RK6oGNn8mMYU59fKseeXemTbuvUcJbj/8LccH3drko4o3u9lCSXn13tlP1oY0AF9kZnOx3W+fespF+uV5ES9nej2a/nfeLVAyUdKDxgLO/9DHkd0WF7LnEPjJB3/AOma+n9RrCPer/WrKnjLOV8euwks3ZVDp07vKcpRGImbhaTAt1vnV7tlLzABv3xrnYNUzZ4XUa9D2wb1lG+3B72dddjo0V8/8pR6IBPodpxz6DWFKhxL0pX17laCMzmitu1ZzuX63Z4V1PbZosUC1aj5W7nWsfd1qz7RtdYBu39K27/Md/5Vje37AqrHn2OKYI2ZVKCme0p/aZdc8KRy4mpH5D68MuUcekPSkXJPp1XypTon8QLZbZUT2d5xLlS+vTDofVek7Yue0PPaqrODWt+cS/fLnpkfqt14MSfvzzql1VV2VFS5t513xhYopiBkhycB8+zbp62XdJE9IV7nfP99uMspl6C20nfeeUdHjx4tNvzo0aN69913y11UOJUnIJfEuzMrw4D5hbp2mSmxM7wB2U9lBWR/eANyKYoCcjC8B9oRqOgAJhhFAflUvAHZD0UBuTTeA+swKC0gny68ATlEig5KIlWg221RQA5U0QFFJPEG5CB12OjRwx95St3RBrodhysgRxJvQA5CUUAuj2MBuY8COXwqbf9SFJAD4c8xRbCKAnJpvAH5DFORAbl5YgfZKineeANykCJtX+QNyEEoCsjhcvL+zBuQy6koIFcFnqxsbbzggnCXUS4BnUnOzMyUMUbGGGVlZSkm5njwKiws1Jw5c1S7dtV9Az2YnRdwQHYr0xuQT/5wKEM6vjMr5ZMje4FHVy87dkB5cotcRR8PyH588uTxFBQLyHZFewPyqc4EZCvveEAusWmONyAH+kFYpmKPH2hHykeURfLzvQcwgVYWoxxvQC5rsfKk4wH5FMvvyj4ekEtqmaOY4wfWIX4tc44e1IkB2S6XNyBH0pmmYB3S0eMBOSSLk+09KInEly/g7TY31xuQA73EuuiAIlJeh13S8YAcRFE2j9Gg2ce2lYrYjnNzMxXKgGyX0xuQI2XbzlHB8YAccEl53oAc7OIUyHHsDHIgEyll/xKnI96A7O+k/DmmCJYj53hALmnK+XIeD8gRsj6EQl5etioiINtl1zmJxwJDZWxPmco9HpCDmnxk7Yty5DoekAMtqKDAG5DDsSgn788OSMcDcjle3Jj04wE5ArrIL56sbOUeOBDRl16XJaCQnJSUJJvNJpvNpmbNmhUbb7PZ9PTTT1dYcaF287+WBPycj52Pl7rOD06tdcoN4ooVJV9iLUk/dBwZ0AZVmLu6+PTr3e73G/Jc549lbnnNWywNevt+Qi9HxjtvCZw/Hgr6DWec8zW/Fus/bv8vVR3zftlvgN93eiJ8r2XO+z4Pu9e9JWIOoCvCbOeykO59OnScE6mbhaTAt1vndweDevnmOh+LuNehX1rdcm1nLXYa1SzjE/9At2Nz5IOgawlG19QbIm7b/tq5Lujt86wmK8u9js1Tz4AusZZK379Mcr4YcD3+HFMEa9gnZb+0q88fHLH78MrkOTKjQqbTxN2m0i6xlqRPnd+Xa98VafuiCRoa9PrmXJMe1hB58v7s1nqpFbLtjHun6oTjE/16081qNv+rcJcRlIBC8oIFC2SMUbdu3TRjxgxVr17dO87lcqlhw4aqW7duhRcZKvuzAv+Uvrqt9Mu+9jpO/fKmHCp9XL4zwEtYTUaxQdFR1fx++lFb2csfG5sdWD0nyFJk3qBNkmw5wV9e1MB2wK92O/1YF4okn+JlLnD4f/l9xfNdR2KjEsJUR+UosIX2UjOHI7IuLz5ZoNutLc//Gx2eKNFW/jM1Fe1wOW+mU/HbcfGvOFWmOEdiSOfnjyxb8K9BbGxwl2ifaJ9SA35OafuXurbAv7bkzzFFsGqXcSwiSbnRkXXZfciY8t2kq0i8o3Jfv1xb+S4tjrR90f4gtrUitiPhvWT85P3ZoQq6+1m13AqZTMgVHjrFm0sEC+gdt2vXrpKkbdu2qUGDBhH3KXN51U5wKf1oYG80B02CElTymptaUKC9p/ju0L4y3jed+dnKdcT6X4yt+EFNbuFhuaL8+85brHEpV6Wf+jh6NF7x8en+13OCBGUqV+EMd6UzMVFSbnAH9ztMLbXUzlO2Syvw/0skh+Ild07p4x0FR5Qf5fJ7ehXLJZ2wvh8tzFJMWEN7xXKYKOUrdDvYggKXoqIid88X6HZrXHYpJ/BtKcPEKVaZAT+vMlXzeJRZjqB86BSfcQa+HcdKCt137I4UZCjeGVlBOcHE6lCQdxY+ejRBUhlfuPVDivYG/JzS9i+7TQ3V18GApuXPMUWw9idLjX4vfXx07iHlxtaolHlHNFs1yZSxQ/ZTdkHlBoVo41RBKcei/oi0fVFt7dVvahTUc01clHQ4fF/cPXl/llxYqKMVEJQPR0vRkfd58ilFJVfdD9iCOgLYsGGDvv32W+/jCRMm6Pzzz9ctt9yiQ1X4E4Np91wU8HOuyX9Wxkgl/ZDWa3sPqNSRlrltbSqUVFKL9sueP+XzTxQV3br49He96/0e+alckd/uWCGlNP15Q6dAyvHxjIYHtCyhlN8uuazFLtOw/MF+LdZNmdl+L/+o/mV2gy5Y+kz4XsuY/j4Pv9z9nt/rV1VwbX7Hsl/8CrZ82VWRullICny7zb+welAv3xX5L0Tc6/DBzt3l2s42pNn0u6PitmNbXL+g6gjWor3TI27b7pJ/btDb59Zf2pR7Hbtcn0umMKCJlLZ/GZQ/IuB6/DmmCNa4q8t+aVuvei1i9+GVyR53fYVM55fMlfIYT6VtT73yLyjXvivS9kUP6NWg17f8Vkmh3I0Xc/L+bMquvRWy7QwbGNLDkwrT8D/Twl1C0IIKyY888ogyM499SvLTTz/poYce0lVXXaVt27bpoYceqtACQ6l6vEu14gM7Q5cpt9I9x860nLz+J0pKy7c++S9l4/A47Pqk47Ez8ie3iFauovKPlPn8E9ntDkVFt/edvnKVV5hjTaLsacTLpRiP9Sl1iU1jlJVZw99yfLh1VHGyrj+MlHfhIk6nPLHHPuULtLIcxWiV56xjzy3jyS5Jd2RYnyyeYvnz4h06ZJ28K6lljHJkL8j1a1oVLSa2uk582/AoT0cLsq1SIqxfg5CsWNk91hUyIVmceBUWWOteBL58AW+30dHyOEp+PytLupJ02OPyezahUE+S02OdAQyiKGO3adK1x7aVitiOo6PdOvZOEhoe5Ssr/9iH3pGybcfIoZoe6yseAZfk0h+/1z/21CAXx6ECXa3ZCmgipexfjihO2zwpAU3Kn2OKYBXEOLSljjXpEsY7la+YI/srZd6RzOWKlyrgKjiPPNqYcezncCpje3IrWk6PdbYyqMlH1r4oRnk6S5uPPQi0IIdDHvexY9lwLMrJ+7NakuILrSvUyvHi5iQ5lGNd/xsBXeQXe0J8lb1plxRkSN62bZv395FnzJiha665Rs8995wmTJigzz77rEILDLXvH7884KDcJv//vEH5ZHN27T2+UyvF1G5Rmt3RppIuUuy65NHjQdkPzrguxYLyrJ3/4w3Kp3JrfpfjQbkEq1df5Q3KgXpTg44fcEeY/C6p3gOZQPXNf9YblMvy0KGM40H5FO4bejwol+TSbx8+foAdYjHJw3TiW8fHv73uDcqngzvzux0PyiGwdOkt3oOTSBTodpt/WV1vUA7EefmTvAcWkWLFjl3Hg3IQlp9j1z+us5f43i4Fvh3HJA9WKIPyZ7ve9AblSNEnv8PxoBygDRv+nzcoB6u/puhqzZJK7dXiStu/dMv/pzco+8ufY4pgjRp0PCiX5KLv/348KJ9BYpLvU0UE5TWHFurnjOUylRRxBuZfejwoByHS9kXPaOTxoByg/E61vUE5HE7eny3duft4UC6HgY8cD8qR7nT4nWSbCeIjrerVq+ubb75Ry5YtdfHFF+v222/XPffco+3bt6tly5Y6cqTsUJeZmanExERlZGTI7Y7MGzodzM5T71e/0s4s/3eEbmXqY+dw1bdlq+gmhkVRIkPSn1NraaPLJZXy3QR7gUd9v/Woz5JjXxY/sVWuovVtx5GSq7oUZdOpPt/weAqUl/GdpOXHp69oXVHvdsU5EmWz22Uv4z552crTLOe3yrF5SplVjpq3mK/q1f+QzSYF8tW9TMVquF7WYVstHbtXX+Xd8TFg+flyfrNftrzAq4pRjsY5X1Y323pF2UtfsjxJ/+uO17+SEnWqF8+VXaAxb0n1D5c8vRzFaEmnJyRHgl/rRUXKOXpQypnkfWyXS93r3iK3o6ZsUTbZI6lfg3BIRzXDuUSl3n6+wmWrQ8eZcjhKfYsIq0zF6hG9rGwV3WH3FP2bmyvnwt9lV+A/BzXXOVS1bPnF3kfDZZeka9PqKs9uD+zNzmLzGLXdUKghs49F3JO7N9DtODc3U+bIuwrVT0LZ5VTX1BtUw1UvYrbtHBXoC+eP2m/LDmIFydNZTZYqNXVHwPuvIgVyaKZ6a5b6SraSerUEpexf4nREk5xPq61tp7eWU5XkzzFFsBw5BRo2XWqz89hSnVxLvpz67vzByk9oHPL9Tjjl5WXLc3iqFOT34ovYZVcTdxu1Suoiu80hezlvEniyTOVquvMbeYLumsjaF+XIpX9oqNarnXV3+QAWqqBAzuX7ZMsKz1rq3Z/Z82WzSX9IuqFeqg5GOaSo4CuKSS/QuDekRBPCQxQ/2VNS1Gj6hxF9BtnfHBpUSL722muVl5enzp0765lnntG2bdtUr149ffHFFxo8eLA2bdpUIcUBAAAAAFAR/M2hQX2M8dprr8nhcGj69OmaOHGi6tWrJ0n67LPPdMUVVwRXMQAAAAAAYRbUmeTy4kwyAAAAACCU/M2hQX39e8eOHWWOb9CgQTCTBQAAAAAgrIIKyY0aNZLNVvqtWAor4A5uAAAAAACEWlAheeXKlT6P8/PztXLlSr3yyisaM2ZMhRQGAAAAAECoBRWSW7duXWxY+/btVbduXY0dO1bXXXdduQsDAAAAACDUKvRnw8455xx9X8V/OBoAAAAAcOYK6kxyZmamz2NjjPbs2aOnnnpKZ599doUUBgAAAABAqAUVkpOSkorduMsYo7S0NE2bNq1CCgMAAAAAINSCCskLFizweWy321WrVi01bdpUDkdQkwQAAAAAIOyCSrRdu3at6DoAAAAAAAg7v0Py7Nmz/Z7otddeG1QxAAAAAACEk98huU+fPn61s9lsKiwsDLYeAAAAAADCxu+Q7PF4KrMOAAAAAADCLqDfSZ4/f75atmxZ7CegJCkjI0PnnnuuFi9eXGHFAQAAAAAQSgGF5HHjxunuu++W2+0uNi4xMVH33nuvXnnllQorDgAAAACAUAooJK9evVpXXHFFqeN79OihH3/8sdxFAQAAAAAQDgGF5H379snpdJY63uFw6MCBA+UuCgAAAACAcAgoJNerV09r164tdfyaNWtUp06dchcFAAAAAEA4BBSSr7rqKj3xxBPKyckpNu7o0aMaPXq0rr766gorDgAAAACAULIZY4y/jfft26e2bdsqKipKgwcP1jnnnCNJ+vnnnzVhwgQVFhZqxYoVSklJKXM6mZmZSkxMVEZGRok3AQMAAAAAoCL5m0P9/p1kSUpJSdGSJUt0//33a+TIkSrK1zabTT179tSECRNOGZABAAAAAIhUAYVkSWrYsKHmzJmjQ4cOacuWLTLG6Oyzz1ZycnJl1AcAAAAAQMgEHJKLJCcn64ILLqjIWgAAAAAACKuAbtwFAAAAAMDpjJAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgIWQDAAAAACAhZAMAAAAAICFkAwAAAAAgMURjpkaYyRJmZmZ4Zg9AAAAAOAMU5Q/i/JoacISkrOysiRJaWlp4Zg9AAAAAOAMlZWVpcTExFLH28ypYnQl8Hg82r17txISEmSz2UI9e79lZmYqLS1NO3fulNvtDnc5KCf68/RDn55e6M/TD316eqE/Tz/06emF/jw1Y4yysrJUt25d2e2lf/M4LGeS7Xa76tevH45ZB8XtdrOinUboz9MPfXp6oT9PP/Tp6YX+PP3Qp6cX+rNsZZ1BLsKNuwAAAAAAsBCSAQAAAACwEJLLEB0drdGjRys6OjrcpaAC0J+nH/r09EJ/nn7o09ML/Xn6oU9PL/RnxQnLjbsAAAAAAIhEnEkGAAAAAMBCSAYAAAAAwEJIBgAAAADAQkgGAAAAAMBCSC7FhAkT1KhRI8XExKhjx45avnx5uEuCpK+//lrXXHON6tatK5vNplmzZvmMN8boySefVJ06dRQbG6vu3btr8+bNPm0OHjyoAQMGyO12KykpSX/+85+VnZ3t02bNmjW65JJLFBMTo7S0NL300kuVvWhnpOeff14XXHCBEhISVLt2bfXp00cbN270aZOTk6MHHnhANWrUUHx8vK6//nrt27fPp82OHTvUq1cvxcXFqXbt2nrkkUdUUFDg02bhwoVq27atoqOj1bRpU02aNKmyF++MNHHiRLVq1Uput1tut1udOnXSZ5995h1Pf1ZtL7zwgmw2m4YNG+YdRp9WLU899ZRsNpvPX/Pmzb3j6c+qZ9euXbr11ltVo0YNxcbG6k9/+pN++OEH73iOjaqWRo0aFdtGbTabHnjgAUlsoyFjUMy0adOMy+Uyb731llm3bp25++67TVJSktm3b1+4SzvjzZkzx4waNcp89NFHRpKZOXOmz/gXXnjBJCYmmlmzZpnVq1eba6+91jRu3NgcPXrU2+aKK64wrVu3Nt99951ZvHixadq0qenfv793fEZGhklJSTEDBgwwa9euNe+//76JjY01//u//xuqxTxj9OzZ07z99ttm7dq1ZtWqVeaqq64yDRo0MNnZ2d429913n0lLSzNfffWV+eGHH8yFF15oLrroIu/4goICc95555nu3bublStXmjlz5piaNWuakSNHetts3brVxMXFmYceesisX7/ejB8/3kRFRZm5c+eGdHnPBLNnzzaffvqp2bRpk9m4caP529/+ZpxOp1m7dq0xhv6sypYvX24aNWpkWrVqZYYOHeodTp9WLaNHjzbnnnuu2bNnj/fvwIED3vH0Z9Vy8OBB07BhQzNo0CCzbNkys3XrVvP555+bLVu2eNtwbFS17N+/32f7nDdvnpFkFixYYIxhGw0VQnIJOnToYB544AHv48LCQlO3bl3z/PPPh7EqnOzkkOzxeExqaqoZO3asd1h6erqJjo4277//vjHGmPXr1xtJ5vvvv/e2+eyzz4zNZjO7du0yxhjz+uuvm+TkZJObm+ttM2LECHPOOedU8hJh//79RpJZtGiRMeZY/zmdTvPhhx9622zYsMFIMkuXLjXGHPvgxG63m71793rbTJw40bjdbm8fPvroo+bcc8/1mddNN91kevbsWdmLBGNMcnKy+b//+z/6swrLysoyZ599tpk3b57p2rWrNyTTp1XP6NGjTevWrUscR39WPSNGjDAXX3xxqeM5Nqr6hg4dapo0aWI8Hg/baAhxufVJ8vLy9OOPP6p79+7eYXa7Xd27d9fSpUvDWBlOZdu2bdq7d69P3yUmJqpjx47evlu6dKmSkpLUvn17b5vu3bvLbrdr2bJl3jZdunSRy+XytunZs6c2btyoQ4cOhWhpzkwZGRmSpOrVq0uSfvzxR+Xn5/v0afPmzdWgQQOfPv3Tn/6klJQUb5uePXsqMzNT69at87Y5cRpFbdimK1dhYaGmTZumw4cPq1OnTvRnFfbAAw+oV69exV53+rRq2rx5s+rWrauzzjpLAwYM0I4dOyTRn1XR7Nmz1b59e914442qXbu22rRpozfffNM7nmOjqi0vL09TpkzRnXfeKZvNxjYaQoTkk/z+++8qLCz0WbEkKSUlRXv37g1TVfBHUf+U1Xd79+5V7dq1fcY7HA5Vr17dp01J0zhxHqh4Ho9Hw4YNU+fOnXXeeedJOvZ6u1wuJSUl+bQ9uU9P1V+ltcnMzNTRo0crY3HOaD/99JPi4+MVHR2t++67TzNnzlTLli3pzypq2rRpWrFihZ5//vli4+jTqqdjx46aNGmS5s6dq4kTJ2rbtm265JJLlJWVRX9WQVu3btXEiRN19tln6/PPP9f999+vIUOG6J133pHEsVFVN2vWLKWnp2vQoEGSeM8NJUe4CwAA6diZqrVr1+qbb74Jdykop3POOUerVq1SRkaGpk+froEDB2rRokXhLgtB2Llzp4YOHap58+YpJiYm3OWgAlx55ZXe/1u1aqWOHTuqYcOG+uCDDxQbGxvGyhAMj8ej9u3b67nnnpMktWnTRmvXrtUbb7yhgQMHhrk6lNe///1vXXnllapbt264SznjcCb5JDVr1lRUVFSxu8Tt27dPqampYaoK/ijqn7L6LjU1Vfv37/cZX1BQoIMHD/q0KWkaJ84DFWvw4MH65JNPtGDBAtWvX987PDU1VXl5eUpPT/dpf3Kfnqq/Smvjdrs5KKwELpdLTZs2Vbt27fT888+rdevWevXVV+nPKujHH3/U/v371bZtWzkcDjkcDi1atEj/8z//I4fDoZSUFPq0iktKSlKzZs20ZcsWttEqqE6dOmrZsqXPsBYtWngvoefYqOr69ddf9eWXX+quu+7yDmMbDR1C8klcLpfatWunr776yjvM4/Hoq6++UqdOncJYGU6lcePGSk1N9em7zMxMLVu2zNt3nTp1Unp6un788Udvm/nz58vj8ahjx47eNl9//bXy8/O9bebNm6dzzjlHycnJIVqaM4MxRoMHD9bMmTM1f/58NW7c2Gd8u3bt5HQ6ffp048aN2rFjh0+f/vTTTz47+Hnz5sntdnsPHDp16uQzjaI2bNOh4fF4lJubS39WQZdddpl++uknrVq1yvvXvn17DRgwwPs/fVq1ZWdn65dfflGdOnXYRqugzp07F/vpxE2bNqlhw4aSODaqyt5++23Vrl1bvXr18g5jGw2hcN85LBJNmzbNREdHm0mTJpn169ebe+65xyQlJfncJQ7hkZWVZVauXGlWrlxpJJlXXnnFrFy50vz666/GmGM/c5CUlGT++9//mjVr1pjevXuX+DMHbdq0McuWLTPffPONOfvss31+5iA9Pd2kpKSY2267zaxdu9ZMmzbNxMXF8TMHleD+++83iYmJZuHChT4/d3DkyBFvm/vuu880aNDAzJ8/3/zwww+mU6dOplOnTt7xRT910KNHD7Nq1Sozd+5cU6tWrRJ/6uCRRx4xGzZsMBMmTOCnDirJY489ZhYtWmS2bdtm1qxZYx577DFjs9nMF198YYyhP08HJ97d2hj6tKp5+OGHzcKFC822bdvMt99+a7p3725q1qxp9u/fb4yhP6ua5cuXG4fDYcaMGWM2b95spk6dauLi4syUKVO8bTg2qnoKCwtNgwYNzIgRI4qNYxsNDUJyKcaPH28aNGhgXC6X6dChg/nuu+/CXRKMMQsWLDCSiv0NHDjQGHPspw6eeOIJk5KSYqKjo81ll11mNm7c6DONP/74w/Tv39/Ex8cbt9tt7rjjDpOVleXTZvXq1ebiiy820dHRpl69euaFF14I1SKeUUrqS0nm7bff9rY5evSo+ctf/mKSk5NNXFyc6du3r9mzZ4/PdLZv326uvPJKExsba2rWrGkefvhhk5+f79NmwYIF5vzzzzcul8ucddZZPvNAxbnzzjtNw4YNjcvlMrVq1TKXXXaZNyAbQ3+eDk4OyfRp1XLTTTeZOnXqGJfLZerVq2duuukmn9/UpT+rno8//ticd955Jjo62jRv3tz861//8hnPsVHV8/nnnxtJxfrJGLbRULEZY0xYTmEDAAAAABBh+E4yAAAAAAAWQjIAAAAAABZCMgAAAAAAFkIyAAAAAAAWQjIAAAAAABZCMgAAAAAAFkIyAAAAAAAWQjIAAAAAABZCMgAAVYjNZtOsWbPCXQYAAKctQjIAACEyaNAg9enTJ9xlAACAMhCSAQAAAACwEJIBAAiDSy+9VEOGDNGjjz6q6tWrKzU1VU899ZRPm82bN6tLly6KiYlRy5YtNW/evGLT2blzp/r166ekpCRVr15dvXv31vbt2yVJP//8s+Li4vTee+9523/wwQeKjY3V+vXrK3PxAACosgjJAACEyTvvvKNq1app2bJleumll/T3v//dG4Q9Ho+uu+46uVwuLVu2TG+88YZGjBjh8/z8/Hz17NlTCQkJWrx4sb799lvFx8friiuuUF5enpo3b66XX35Zf/nLX7Rjxw799ttvuu+++/Tiiy+qZcuW4VhkAAAins0YY8JdBAAAZ4JBgwYpPT1ds2bN0qWXXqrCwkItXrzYO75Dhw7q1q2bXnjhBX3xxRfq1auXfv31V9WtW1eSNHfuXF155ZWaOXOm+vTpoylTpujZZ5/Vhg0bZLPZJEl5eXlKSkrSrFmz1KNHD0nS1VdfrczMTLlcLkVFRWnu3Lne9gAAwJcj3AUAAHCmatWqlc/jOnXqaP/+/ZKkDRs2KC0tzRuQJalTp04+7VevXq0tW7YoISHBZ3hOTo5++eUX7+O33npLzZo1k91u17p16wjIAACUgZAMAECYOJ1On8c2m00ej8fv52dnZ6tdu3aaOnVqsXG1atXy/r969WodPnxYdrtde/bsUZ06dYIvGgCA0xwhGQCACNSiRQvt3LnTJ9R+9913Pm3atm2r//znP6pdu7bcbneJ0zl48KAGDRqkUaNGac+ePRowYIBWrFih2NjYSl8GAACqIm7cBQBABOrevbuaNWumgQMHavXq1Vq8eLFGjRrl02bAgAGqWbOmevfurcWLF2vbtm1auHChhgwZot9++02SdN999yktLU2PP/64XnnlFRUWFmr48OHhWCQAAKoEQjIAABHIbrdr5syZOnr0qDp06KC77rpLY8aM8WkTFxenr7/+Wg0aNNB1112nFi1a6M9//rNycnLkdrv17rvvas6cOZo8ebIcDoeqVaumKVOm6M0339Rnn30WpiUDACCycXdrAAAAAAAsnEkGAAAAAMBCSAYAAAAAwEJIBgAAAADAQkgGAAAAAMBCSAYAAAAAwEJIBgAAAADAQkgGAAAAAMBCSAYAAAAAwEJIBgAAAADAQkgGAAAAAMBCSAYAAAAAwPL/Afx8+idl8eqlAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1200x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "import numpy as np\n",
    "\n",
    "def plot_timeline_clusters(df):\n",
    "    \"\"\"\n",
    "    Create a timeline plot of fuzz_clusters with the DataFrame index on the x-axis.\n",
    "\n",
    "    :param df: DataFrame with paragraph data and extended dialogue clusters.\n",
    "    \"\"\"\n",
    "    # Map clusters to colors\n",
    "    unique_clusters = df['chapter'].unique()\n",
    "    colors = list(mcolors.TABLEAU_COLORS) * (len(unique_clusters) // len(mcolors.TABLEAU_COLORS) + 1)\n",
    "    color_map = {cluster: colors[i] for i, cluster in enumerate(unique_clusters)}\n",
    "\n",
    "    # Create the scatter plot\n",
    "    plt.figure(figsize=(12, 3))\n",
    "    for cluster in unique_clusters:\n",
    "        cluster_indices = df[df['chapter'] == cluster].index\n",
    "        plt.scatter(cluster_indices, np.repeat(1, len(cluster_indices)), color=color_map[cluster], label=cluster, alpha=1)\n",
    "\n",
    "    # Set plot title and labels\n",
    "    plt.title('Timeline of Fuzz Clusters')\n",
    "    plt.xlabel('Index')\n",
    "    plt.ylabel('Clusters')\n",
    "    plt.yticks([])  # Hide y-axis ticks\n",
    "    #plt.legend(title='Chapter', bbox_to_anchor=(1.05, 1), loc='upper left')  # Place legend outside\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "# Plot the timeline of clusters\n",
    "plot_timeline_clusters(df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>chapter</th>\n",
       "      <th>fuzz_cluster</th>\n",
       "      <th>idx</th>\n",
       "      <th>lineno</th>\n",
       "      <th>text_length</th>\n",
       "      <th>lines_count</th>\n",
       "      <th>category</th>\n",
       "      <th>category_id</th>\n",
       "      <th>cluster_size</th>\n",
       "      <th>fuzz_cluster_size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>DIALOGUE XXI</td>\n",
       "      <td>dialogue-header_21</td>\n",
       "      <td>7044</td>\n",
       "      <td>30650</td>\n",
       "      <td>53501</td>\n",
       "      <td>782</td>\n",
       "      <td>dialogue, dialogue-header, text</td>\n",
       "      <td>DIALOGUE XXI</td>\n",
       "      <td>6714</td>\n",
       "      <td>99856</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         chapter        fuzz_cluster   idx  lineno  text_length  lines_count  \\\n",
       "36  DIALOGUE XXI  dialogue-header_21  7044   30650        53501          782   \n",
       "\n",
       "                           category   category_id  cluster_size  \\\n",
       "36  dialogue, dialogue-header, text  DIALOGUE XXI          6714   \n",
       "\n",
       "    fuzz_cluster_size  \n",
       "36              99856  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def aggregate_by_fuzz_cluster(df):\n",
    "    \"\"\"\n",
    "    Aggregate the DataFrame by fuzz_cluster with custom aggregation for each column.\n",
    "\n",
    "    :param df: DataFrame with various columns.\n",
    "    :return: DataFrame with aggregated data for each fuzz_cluster.\n",
    "    \"\"\"\n",
    "    aggregations = {\n",
    "        'chapter': 'first',\n",
    "        'idx': 'min', \n",
    "        'lineno': 'min', \n",
    "        'text_length': 'sum', \n",
    "        'word_count': 'sum', \n",
    "        'text': lambda x: '\\n\\n'.join(x), \n",
    "        'lines_count': 'sum', \n",
    "        'category': lambda x: ', '.join(sorted(set(x))),\n",
    "        'category_id': 'first',\n",
    "        'cluster': lambda x: ', '.join(sorted(set(x))),\n",
    "        'cluster_size': 'sum', \n",
    "        'fuzz_cluster_size': 'sum'\n",
    "    }\n",
    "\n",
    "    aggregated_df = df.groupby('fuzz_cluster').agg(aggregations)\n",
    "\n",
    "    return aggregated_df\n",
    "\n",
    "# Assuming df is your DataFrame with the fuzz_cluster and other columns\n",
    "aggregated_df = aggregate_by_fuzz_cluster(df)\n",
    "aggregated_df = aggregated_df.reset_index().set_index(['chapter', 'fuzz_cluster'])\n",
    "\n",
    "# Display the aggregated DataFrame\n",
    "#aggregated_df.sort_values('lineno', ascending=True)\n",
    "ndf = aggregated_df.reset_index()\n",
    "ndf[ndf['chapter'] == \"DIALOGUE XXI\"][['chapter', 'fuzz_cluster', 'idx', 'lineno', 'text_length','lines_count', 'category', 'category_id', 'cluster_size', 'fuzz_cluster_size']]\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "jupyterenv",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}