scarping_tweets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "04dca157",
   "metadata": {},
   "source": [
    "# Parsing data from twitter\n",
    "\n",
    "- Getting counts within time ranges.\n",
    "- Creating a time_ranges_with_timeperiod dataframe, that contains rows labeled with timeperiod based on tweet count thresholds.\n",
    "- Collecting tweets within detected time ranges.\n",
    "- Retreiving information on users whose tweets are collected.\n",
    "- Merging tweets and infirmation on users and saving into file balenciaga_scarped.pkl."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25c7fb96",
   "metadata": {},
   "source": [
    "# Libraries to import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "efadf096",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/deryadurmush/.pyenv/versions/migration1/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import tweepy\n",
    "import json\n",
    "import pandas as pd\n",
    "from tqdm.auto import tqdm\n",
    "import time\n",
    "import requests\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "037cbb4e",
   "metadata": {},
   "source": [
    "# Twitter tokens\n",
    "Hided tokens for security measures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0f0f2749",
   "metadata": {},
   "outputs": [],
   "source": [
    "at = ''\n",
    "ats = ''\n",
    "bt = ''\n",
    "\n",
    "api_key = ''\n",
    "api_secret_key = ''\n",
    "access_token = ''\n",
    "access_token_secret = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "125b1f12",
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_client():\n",
    "    return tweepy.Client(bearer_token=bt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfc2cf3b",
   "metadata": {},
   "source": [
    "# Scarping time ranges for tweets parsing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2b90a1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_tweet_counts(client, search_query, pairs_arr, granularity='minute', wait_time=900):\n",
    "    \"\"\"\n",
    "    Fetches tweet counts for a single search query within specified time ranges.\n",
    "\n",
    "    Parameters:\n",
    "        client (tweepy.Client): Authenticated Tweepy client instance.\n",
    "        search_query (str): The search query (string).\n",
    "        pairs_arr (pd.DataFrame): DataFrame with 'start' and 'end' columns for time ranges.\n",
    "        granularity (str): Granularity for tweet counts ('minute', 'hour', 'day').\n",
    "        wait_time (int): Time to wait (in seconds) before retrying after an API rate limit error.\n",
    "\n",
    "    Returns:\n",
    "        pd.DataFrame: Combined DataFrame with tweet counts for the search query and time ranges.\n",
    "    \"\"\"\n",
    "    total_tweet_count = 0\n",
    "    dataframes = []\n",
    "\n",
    "    for i in range(pairs_arr.shape[0]):\n",
    "        start_time = pairs_arr['start'][i]\n",
    "        end_time = pairs_arr['end'][i]\n",
    "\n",
    "        try:\n",
    "            tweets = client.get_all_tweets_count(\n",
    "                query=search_query,\n",
    "                start_time=start_time,\n",
    "                end_time=end_time,\n",
    "                granularity=granularity\n",
    "            )\n",
    "\n",
    "            df = pd.DataFrame(tweets.data)\n",
    "            df['search_query'] = search_query\n",
    "\n",
    "            print(f\"{search_query}: {df['tweet_count'].sum()} tweets\")\n",
    "            total_tweet_count += df['tweet_count'].sum()\n",
    "            dataframes.append(df)\n",
    "\n",
    "        except Exception as e:\n",
    "            print(f\"Error: {e}. Entering waiting mode...\")\n",
    "            time.sleep(wait_time)\n",
    "            tweets = client.get_all_tweets_count(\n",
    "                query=search_query,\n",
    "                start_time=start_time,\n",
    "                end_time=end_time,\n",
    "                granularity=granularity\n",
    "            )\n",
    "            df = pd.DataFrame(tweets.data)\n",
    "            total_tweet_count += df['tweet_count'].sum()\n",
    "            dataframes.append(df)\n",
    "    result_df = pd.concat(dataframes, axis=0)\n",
    "    \n",
    "    return result_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7eb937cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "client = initialize_client()\n",
    "\n",
    "search_query = 'balenciaga'\n",
    "dates = [str(i)[:-9] + 'T00:00:00Z' for i in pd.date_range(start='11/01/2022', periods=163)]\n",
    "pairs_arr = pd.DataFrame({'start':dates[:-1], 'end':dates[1:]})\n",
    "\n",
    "time_ranges = fetch_tweet_counts(client, search_query, pairs_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4dbc6964",
   "metadata": {},
   "outputs": [],
   "source": [
    "dates = [str(i)[:-9] + 'T00:00:00Z' for i in pd.date_range(start='11/01/2022', periods=163)]\n",
    "pairs_arr = pd.DataFrame({'start':dates[:-1], 'end':dates[1:]})\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adc39353",
   "metadata": {},
   "source": [
    "Creating time_ranges_with_timeperiod dataframe, that contains rows labeled with timeperiod based on tweet count thresholds.\n",
    "\n",
    "- timeperiod = 1: Marks rows with cumulative tweet counts exceeding 450 or adjacent to rows exceeding the threshold.\n",
    "- timeperiod = 2: Marks rows with isolated large jumps in cumulative counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddda93d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_local = time_ranges.copy().reset_index(drop=True)\n",
    "\n",
    "counter = 0\n",
    "counter2 = 0\n",
    "\n",
    "for i in tqdm(range(1, df_local.shape[0]), desc=\"Assigning time periods\"):\n",
    "    counter2 += df_local['tweet_count'][i]\n",
    "\n",
    "    if df_local['tweet_count'][i] >= 450:\n",
    "        if df_local['tweet_count'][i - 1] < 450:\n",
    "            df_local.at[i - 1, 'timeperiod'] = 1\n",
    "        df_local.at[i, 'timeperiod'] = 1\n",
    "        counter = 0\n",
    "        counter2 = 0\n",
    "    elif counter2 >= 450 and 0 < counter < 450:\n",
    "        df_local.at[i - 1, 'timeperiod'] = 1\n",
    "        counter = df_local['tweet_count'][i]\n",
    "        counter2 = df_local['tweet_count'][i]\n",
    "    elif counter2 < 450 and counter < 450:\n",
    "        counter += df_local['tweet_count'][i]\n",
    "    elif counter == 0 and counter2 > 450:\n",
    "        df_local.at[i, 'timeperiod'] = 2\n",
    "        counter = 0\n",
    "        counter2 = 0\n",
    "\n",
    "time_ranges_with_timeperiod = df_local.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "659a39ec",
   "metadata": {},
   "source": [
    "No rows have timeperiod = 2, indicating there were no isolated spikes or non-contiguous periods where cumulative tweet counts exceeded 450."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "29bfaf90",
   "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>end</th>\n",
       "      <th>start</th>\n",
       "      <th>tweet_count</th>\n",
       "      <th>search_query</th>\n",
       "      <th>timeperiod</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [end, start, tweet_count, search_query, timeperiod]\n",
       "Index: []"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time_ranges_with_timeperiod[time_ranges_with_timeperiod['timeperiod'] == 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70c64164",
   "metadata": {},
   "source": [
    "Retrieves tweets within time periods scarped "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19fdbbc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_geo(geo_data):\n",
    "    try:\n",
    "        return geo_data['place_id']\n",
    "    except (TypeError, KeyError):\n",
    "        return None\n",
    "\n",
    "\n",
    "def fetch_tweets(client, query, start_time, end_time):\n",
    "    return client.search_all_tweets(\n",
    "        query=query,\n",
    "        start_time=start_time,\n",
    "        end_time=end_time,\n",
    "        tweet_fields=[\"created_at\", \"text\", \"source\", 'author_id', 'public_metrics', 'geo', 'entities', 'lang'],\n",
    "        user_fields=[\"name\", \"username\", \"location\", \"verified\", \"description\"],\n",
    "        place_fields=['full_name', 'id', 'country', 'country_code', 'geo', 'name', 'place_type'],\n",
    "        max_results=500,\n",
    "        expansions=['author_id', 'geo.place_id']\n",
    "    )\n",
    "\n",
    "\n",
    "def process_tweets(tweets, search_query):\n",
    "    tweet_data = []\n",
    "    for tweet in tweets.data:\n",
    "        tweet_data.append([\n",
    "            tweet.id, tweet.text, tweet.author_id, extract_geo(tweet.geo), tweet.created_at,\n",
    "            tweet.lang, tweet.public_metrics.get('retweet_count', 0), tweet.public_metrics.get('reply_count', 0),\n",
    "            tweet.public_metrics.get('like_count', 0), tweet.public_metrics.get('quote_count', 0)\n",
    "        ])\n",
    "    df = pd.DataFrame(tweet_data, columns=[\n",
    "        'tweet_id', 'text', 'author_id', 'geo', 'created_at', 'lang',\n",
    "        'retweet_count', 'reply_count', 'like_count', 'quote_count'\n",
    "    ])\n",
    "    df['author_location'] = '-1'\n",
    "    df['country'] = 'No Country'\n",
    "    df['query'] = search_query\n",
    "    return df\n",
    "\n",
    "\n",
    "def fetch_all_tweets(time_ranges):\n",
    "    tweets_list = []\n",
    "    client = initialize_client()\n",
    "    request_counter = 0\n",
    "\n",
    "    for i in tqdm(range(time_ranges.shape[0]), desc=\"Fetching tweets\"):\n",
    "        query = time_ranges['search_query'][i]\n",
    "        start_time = time_ranges['start'][i]\n",
    "        end_time = time_ranges['end'][i]\n",
    "\n",
    "        try:\n",
    "            tweets = fetch_tweets(client, query, start_time, end_time)\n",
    "        except Exception:\n",
    "            time.sleep(5)\n",
    "            tweets = fetch_tweets(client, query, start_time, end_time)\n",
    "\n",
    "        request_counter += 1\n",
    "        if request_counter == 290:\n",
    "            time.sleep(900)\n",
    "            request_counter = 0\n",
    "\n",
    "        if tweets.meta['result_count'] > 0:\n",
    "            print(f\"Found {tweets.meta['result_count']} tweets for query '{query}'\")\n",
    "            df = process_tweets(tweets, query)\n",
    "            tweets_list.append(df)\n",
    "\n",
    "        time.sleep(1)\n",
    "\n",
    "    return pd.concat(tweets_list, axis=0) if tweets_list else pd.DataFrame()\n",
    "\n",
    "time_ranges = pd.DataFrame({\n",
    "    'search_query': ['balenciaga'], \n",
    "    'start': [pairs_arr['start'].min()], \n",
    "    'end': [pairs_arr['end'].max()]\n",
    "})\n",
    "\n",
    "tweets = fetch_all_tweets(time_ranges)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dee67c3e",
   "metadata": {},
   "source": [
    "Retriving user's information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "17ee36ac",
   "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>author_id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1123166102995865600</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1950852385</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>50073553</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1388702657792159746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>49987009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>58067</th>\n",
       "      <td>198146259</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>58068</th>\n",
       "      <td>704059993</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>58069</th>\n",
       "      <td>1526758613775155200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>58070</th>\n",
       "      <td>1235772718043316226</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>58071</th>\n",
       "      <td>1304480104446177280</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>58072 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                 author_id\n",
       "0      1123166102995865600\n",
       "1               1950852385\n",
       "2                 50073553\n",
       "3      1388702657792159746\n",
       "4                 49987009\n",
       "...                    ...\n",
       "58067            198146259\n",
       "58068            704059993\n",
       "58069  1526758613775155200\n",
       "58070  1235772718043316226\n",
       "58071  1304480104446177280\n",
       "\n",
       "[58072 rows x 1 columns]"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "users_from_tweets = tweets['author_id'].unique()\n",
    "users = pd.DataFrame({'author_id':users_from_tweets})\n",
    "users"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a4328be",
   "metadata": {},
   "outputs": [],
   "source": [
    "headers = {\n",
    "    'Authorization': f\"Bearer {bt}\",\n",
    "}\n",
    "\n",
    "profile_arr = []\n",
    "counter = 0\n",
    "\n",
    "for i in tqdm(range(users.shape[0] // 100 + 1)):\n",
    "    if counter == 295:\n",
    "        time.sleep(900)\n",
    "        counter = 0\n",
    "        \n",
    "    author_ids = ','.join([str(i) for i in users.iloc[i * 100:(i+1)*100, :]['author_id'].tolist()])\n",
    "    s = f\"https://api.twitter.com/2/users?ids={author_ids}&user.fields=location,name\"\n",
    "    response = requests.get(s, headers=headers)\n",
    "    r = json.loads(response.text)['data']\n",
    "    profile_arr.append(pd.DataFrame(r))\n",
    "    counter += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "24112b56",
   "metadata": {},
   "outputs": [],
   "source": [
    "users = pd.concat(profile_arr, axis = 0).reset_index(drop=True)\n",
    "users = users.drop(columns = ['withheld']).drop_duplicates().reset_index(drop=True)\n",
    "users['loc1'] = users['location'].str.lower().fillna('no country')\n",
    "users['country'] = 'no country'\n",
    "users['id'] = users['id'].apply(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d572a02",
   "metadata": {},
   "source": [
    "Merging user's information and tweets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e713dd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "combined_df = tweets.merge(users.rename(columns = {\"id\":'author_id'}), how = 'left', on = 'author_id')\n",
    "combined_df.to_pickle('balenciaga_scarped.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "638f6f03",
   "metadata": {},
   "source": [
    "Check of data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "3c79b863",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2408492, 19)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_pickle('/Users/deryadurmush/Desktop/Jobs /balenciaga/balenciaga_scarped.pkl')\n",
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "387f72e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAJOCAYAAACqS2TfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACWL0lEQVR4nOzdeXyTZb7//3eSpitdKNCFvQIqlU1UFhdGESigjCjjgoobo0dGPCrnp46OsumMR8+4i/hVR3EE1FlVFpEKgjIUUBDZRAWLiLSAQFva0i3J7482adM2aZJmLa/n4zHn2OTOnYv0yt2887kWg81mswkAAAAAAPidMdQNAAAAAACgrSJ0AwAAAAAQIIRuAAAAAAAChNANAAAAAECAELoBAAAAAAgQQjcAAAAAAAFC6AYAAAAAIEAI3QAAAAAABAihGwAAAACAACF0AwDQRi1YsEAGg0H79u1z3HbxxRfr4osvDlmbfLVmzRoZDAatWbPG68dG6r8ZANA2ELoBAAghezC2/y82NladO3dWTk6OXnjhBZ04cSLUTfRIUVGRYmNjZTAY9M033/h8npdfflkLFizwX8OacfDgQc2ePVtbt24N6PMAACARugEACAtz587V22+/rfnz5+vuu++WJN17773q37+/tm3b5tM5p0yZopMnT6pHjx7+bGqz/v73v8tgMCgjI0OLFi3y+TyuQveIESN08uRJjRgxwutzrly5UitXrnT8fPDgQc2ZM4fQDQAIiqhQNwAAAEjjxo3Tueee6/j5oYce0urVq3X55Zfr17/+tb755hvFxcV5dU6TySSTyeTvpjZr4cKFGj9+vHr06KHFixfr8ccf9+v5jUajYmNjfXpsdHS0X9sCAIA3qHQDABCmRo4cqUcffVQ//vijFi5c6Lh927ZtuuWWW3TaaacpNjZWGRkZuu2223T06FGnxzc3p7uh0tJSJSQk6J577mly34EDB2QymfTEE0+02M79+/fr888/13XXXafrrrtO+fn5Wr9+fbPHLly4UEOGDFF8fLzat2+vESNGOKrQPXv21M6dO7V27VrHcHv7XOzGc7qnT5+udu3aqby8vMlzTJ48WRkZGbJYLJKc53SvWbNG5513niTp1ltvdTzPggULNGvWLJnNZh05cqTJOe+44w6lpKSooqKixdcDAICGCN0AAISxKVOmSJLT8Ojc3Fz98MMPuvXWW/Xiiy/quuuu07vvvqvx48fLZrN5fO527drpyiuv1HvvvecIqHbvvPOObDabbrjhhhbP88477yghIUGXX365hgwZol69ejU7xHzOnDmaMmWKzGaz5s6dqzlz5qhbt25avXq1JOm5555T165ddeaZZ+rtt9/W22+/rT/84Q/NPue1116rsrIyLVu2zOn28vJyLVmyRL/5zW+arfL37dtXc+fOlVQbpO3PM2LECE2ZMkU1NTV67733nB5TVVWlf/zjH5o0aZLP1XYAwKmL4eUAAISxrl27Kjk5WXv37nXc9rvf/U7/8z//43TcsGHDNHnyZK1bt04XXXSRx+e/6aabtGjRIuXm5mrs2LGO2xcuXKgRI0aoe/fuLZ5j0aJFuuKKKxzD36+99lq9+uqrev755xUVVftRY8+ePZo7d66uvPJK/eMf/5DRWP+9v/2LgokTJ+qRRx5Rx44ddeONN7p9zgsvvFBdunTRe++9p6uvvtpx+7Jly1RWVqZrr7222celp6dr3LhxmjlzpoYPH97keYYPH66FCxdq+vTpTuc8fvy44wsQAAC8QaUbAIAw165dO6dVzBvO7a6oqNAvv/yiYcOGSZK2bNni1blHjRqlzp07O1Wmd+zYoW3btrUYfKXaoe7bt2/X5MmTHbdNnjxZv/zyiz7++GPHbe+//76sVqtmzpzpFLglyWAweNVm+2OuvvpqLV++XKWlpY7b33vvPXXp0kUXXnih1+eUar+E2Lhxo9OXHIsWLVK3bt30q1/9yqdzAgBObYRuAADCXGlpqRITEx0/Hzt2TPfcc4/S09MVFxenTp06KSsrS5JUXFzs1bmNRqNuuOEGvf/++4750YsWLVJsbKxTBdmVhQsXKiEhQaeddpr27NmjPXv2KDY2Vj179nQK8nv37pXRaFR2drZX7XPn2muv1cmTJ/Xhhx9Kqn2dli9frquvvtqnIG8/Z0xMjKPtxcXFWrp0qW644QafzwkAOLURugEACGMHDhxQcXGxevfu7bjtmmuu0WuvvaY777xT//rXv7Ry5UqtWLFCkmS1Wr1+jptuukmlpaV6//33ZbPZtHjxYl1++eVKTk52+zibzaZ33nlHZWVlys7OVp8+fRz/27dvnz744AOnKrS/DRs2TD179tTf/vY3SdKSJUt08uRJl0PLPdG+fXtdfvnljtD9j3/8Q5WVlR5V/QEAaA5zugEACGNvv/22JCknJ0eSdPz4ca1atUpz5szRzJkzHcd9//33Pj9Hv379dPbZZ2vRokXq2rWr9u/frxdffLHFx61du1YHDhzQ3Llz1bdvX6f7jh8/rjvuuEPvv/++brzxRvXq1UtWq1W7du3SoEGDXJ7T22ryNddco+eff14lJSV677331LNnT8dQe1+f46abbtIVV1yhL774QosWLdLZZ5+ts846y6t2AQBgR6UbAIAwtXr1aj322GPKyspyrCJuX5G78Srlzz33XKuea8qUKVq5cqWee+45dejQQePGjWvxMfah5ffff79+85vfOP3v9ttvV58+fRwV44kTJ8poNGru3LlNqvEN/y0JCQkqKiryuN3XXnutKisr9dZbb2nFihW65pprWnxMQkKCJLl8nnHjxqljx4568skntXbtWqrcAIBWodINAEAY+Oijj7R7927V1NTo0KFDWr16tXJzc9WjRw99+OGHjq2qkpKSNGLECD311FOqrq5Wly5dtHLlSuXn57fq+a+//no98MAD+ve//61p06bJbDa7Pb6yslL//Oc/NXr0aJfbaP3617/W888/r8OHD6t37976wx/+oMcee0wXXXSRrrrqKsXExOiLL75Q586dHfuBn3POOZo/f74ef/xx9e7dW2lpaRo5cqTLdgwePNhx7srKSo+Glvfq1UspKSl65ZVXlJiYqISEBA0dOtQxL95sNuu6667TSy+9JJPJ5LRIHAAA3qLSDQBAGJg5c6amTJmi//qv/9Jzzz0nm82m5557Ttu2bVO/fv2cjl28eLFycnI0b948PfTQQzKbzfroo49a9fzp6ekaM2aMJHm0NdayZctUVFSkCRMmuDxmwoQJqqmp0bvvvitJmjt3rt544w2dPHlSf/jDHzRz5kz9+OOPuvTSSx2PmTlzpsaPH6+nnnpKkydPduyp7c61116rEydOqHfv3ho8eHCLx5vNZr311lsymUy68847NXnyZK1du9bpmJtuukmSdOmllyozM7PFcwIA4IrB1nh8GgAAOCVdeeWV2r59u/bs2RPqpoTc119/rUGDBumvf/0r+3MDAFqFSjcAAFBBQYGWLVtGwKzz2muvqV27drrqqqtC3RQAQIRjTjcAAKew/Px8/ec//9Hrr78us9ms//qv/wp1k0JqyZIl2rVrl1599VVNnz7dsegaAAC+InQDAHAKW7t2rW699VZ1795db731ljIyMkLdpJC6++67dejQIY0fP15z5swJdXMAAG0Ac7oBAAAAAAgQ5nQDAAAAABAghG4AAAAAAAKEOd1BZLVadfDgQSUmJspgMIS6OQAAAAAAH9lsNp04cUKdO3eW0ei6nk3oDqKDBw+qW7duoW4GAAAAAMBPfvrpJ3Xt2tXl/YTuIEpMTJRU+0tJSkoKcWuaqq6u1sqVKzVmzBiZzeZQNwdtCH0LwUJfQzDR3+AN+guChb4WPCUlJerWrZsj57lC6A4i+5DypKSksA3d8fHxSkpK4g0Kv6JvIVjoawgm+hu8QX9BsNDXgq+lqcMspAYAAAAAQIAQugEAAAAACBBCNwAAAAAAAcKcbgAAAACnNIvFourq6lA3wy+qq6sVFRWliooKWSyWUDcnopnNZplMplafh9ANAAAA4JRks9lUWFiooqKiUDfFb2w2mzIyMvTTTz+1uMAXWpaSkqKMjIxWvZaEbgAAAACnJHvgTktLU3x8fJsIqVarVaWlpWrXrp2MRmYT+8pms6m8vFyHDx+WJGVmZvp8LkI3AAAAgFOOxWJxBO4OHTqEujl+Y7VaVVVVpdjYWEJ3K8XFxUmSDh8+rLS0NJ+HmvNbAAAAAHDKsc/hjo+PD3FLEM7s/aM1c/4J3QAAAABOWW1hSDkCxx/9g9ANAAAAAECAELoBAAAA4BS0YMECpaSkOH6ePXu2Bg0aFLL2tFWEbgAAAADwkcVqU97eo/pg68/K23tUFqstoM93yy23yGAwyGAwyGw2Kz09XaNHj9Ybb7whq9Xq1bmuvfZafffdd35v41dffaWrr75a6enpio2NVZ8+fXT77bcH5LncWbNmjQwGQ8i3hCN0AwAAAIAPVuwo0IVPrtbk1zbonne3avJrG3Thk6u1YkdBQJ937NixKigo0L59+/TRRx/pkksu0T333KPLL79cNTU1Hp8nLi5OaWlpfm3b0qVLNWzYMFVWVmrRokX65ptvtHDhQiUnJ+vRRx/163NFCkI3AAAAAHhpxY4CTVu4RQXFFU63FxZXaNrCLQEN3jExMcrIyFCXLl00ePBgPfzww/rggw/00UcfacGCBY7jnnnmGfXv318JCQnq1q2bfve736m0tNRxf+Ph5Q199tlnMpvNKiwsdLr93nvv1UUXXdTsY8rLy3Xrrbdq/Pjx+vDDDzVq1ChlZWVp6NCh+vOf/6z/9//+n+PYtWvXasiQIYqJiVFmZqZ+//vfO31h0LNnTz333HNO5x80aJBmz57t+NlgMOj111/XlVdeqfj4ePXp00cffvihJGnfvn265JJLJEnt27eXwWDQLbfcIkn6xz/+of79+ysuLk4dOnTQqFGjVFZW1uy/yR8I3QBaFOxhUwAAAMFms9lUXlXj0f9OVFRr1oc71dwnIvttsz/cpRMV1R6dz2Zr/WerkSNHauDAgfr3v//tuM1oNOqFF17Qzp079dZbb2n16tV64IEHPDrfiBEjdNppp+ntt9923FZdXa1Fixbptttua/YxH3/8sX755ReXz2EP+D///LPGjx+v8847T19//bXmz5+vv/zlL3r88cc9/NfWmzNnjq655hpt27ZN48eP1w033KBjx46pW7du+uc//ylJ+vbbb1VQUKDnn39eBQUFmjx5sm677TZ98803WrNmja666iq//A5ciQrYmQG0CSt2FGjOkl1O3+JmJsdq1oRsje2XGcKWAQAA+M/JaouyZ37sl3PZJBWWVKj/7JUeHb9rbo7io1sfzc4880xt27bN8fO9997r+O+ePXvq8ccf15133qmXX37Zo/NNnTpVb775pu6//35J0pIlS1RRUaFrrrmm2eO///57Rzvcefnll9WtWze99NJLMhgMOvPMM3Xw4EE9+OCDmjlzpoxGz2vDt9xyiyZPnixJ+tOf/qQXXnhBmzZt0tixY5WamipJSktLcwT+vXv3qqamRldddZV69OghSerfv7/Hz+cLKt0AXArlsCkAAAB4x2azOe0r/cknn+jSSy9Vly5dlJiYqClTpujo0aMqLy/36Hy33HKL9uzZow0bNkiqHY5+zTXXKCEhweXze+Kbb77R8OHDndp6wQUXqLS0VAcOHPDoHHYDBgxw/HdCQoKSkpJ0+PBhl8cPHDhQl156qfr376+rr75ar732mo4fP+7Vc3qLSjeAZlmsNs1ZssvlsCmDpDlLdml0doZMRkMzRwEAAESOOLNJu+bmeHTspvxjuuXNL1o8bsGt52lIVqpHz+0P33zzjXr27Cmpdk7z5ZdfrmnTpumPf/yjUlNTtW7dOk2dOlVVVVWKj49v8XxpaWmaMGGC3nzzTWVlZemjjz7SmjVrXB5/+umnS5J2796t4cOHt+rfYjQam4T46urqJseZzWannw0Gg9tV3E0mk3Jzc7V+/XqtXLlSL774ov7whz9o48aNysrKalWbXaHSDaBZm/KPNalwN2STVFBcoU35x4LXKAAAgAAxGAyKj47y6H8X9emkzORYuSo7GFQ7He+iPp08Ol/Diq+vVq9ere3bt+uqq66SJG3evFlWq1VPP/20hg0bptNPP10HDx70+ry//e1v9d577+nVV19Vr169dMEFF7g8dsyYMerYsaOeeuqpZu+3b93Vt29f5eXlOYXq//znP0pMTFTXrl0lSZ06dVJBQf2oypKSEuXn53vV9ujoaEmSxWJxut1gMOiCCy7QnDlz9NVXXyk6OtppLry/EboBNOvwCdeB25fjAAAA2gqT0aBZE7IlqUnwtv88a0J2wEYDVlZWqrCwUD///LO2bNmiP/3pT7riiit0+eWX66abbpIk9e7dW9XV1XrxxRf1ww8/6O2339Yrr7zi9XPl5OQoKSlJjz/+uG699Va3xyYkJOj111/XsmXL9Otf/1qffPKJ9u3bpy+//FIPPPCA7rzzTknS7373O/3000+6++67tXv3bn3wwQeaNWuWZsyY4ZjPPXLkSL399tv6/PPPtX37dt18880ymbwbEdCjRw8ZDAYtXbpUR44cUWlpqTZu3Kg//elP+vLLL7V//37961//0pEjR9S3b1+vXxtPEboBNCstMdavxwEAALQlY/tlav6Ng5WR7PxZKCM5VvNvHBzQBWdXrFihzMxM9ezZU2PHjtWnn36qF154QR988IEjmA4cOFDPPPOMnnzySfXr10+LFi3SE0884fVzGY1G3XLLLbJYLI5A784VV1yh9evXy2w26/rrr9eZZ56pyZMnq7i42LE6eZcuXbR8+XJt2rRJAwcO1J133qmpU6fqkUcecZznoYce0q9+9StdfvnluuyyyzRx4kT16tXLq7Z36dJFc+bM0e9//3ulp6dr+vTpSkpK0meffabx48fr9NNP1yOPPKKnn35a48aN8+6F8YLBFsi10eGkpKREycnJKi4uVlJSUqib00R1dbWWL1+u8ePHN5kbgVOPxWrThU+uVmFxRbPzug2q/aOy7sGRLX6LS99CsNDXEEz0N3iD/hJ+KioqlJ+fr6ysLMXG+l5EsFht2pR/TIdPVCgtMVZDslJDut6N1WpVSUmJkpKSvFoF3J2pU6fqyJEjjj2wTyXu+omn+Y6F1AA0yz5satrCLU3uC8awKQAAgEhgMho0vFeHUDcjIIqLi7V9+3YtXrz4lAzc/sLwcgAu2YdNJcY6fz8XjGFTAAAACK0rrrhCY8aM0Z133qnRo0eHujkRi0o3ALfG9svU3iNl+r+Pv5Uk/e9V/XX1ud2ocAMAALRx7rYHg+eodANoUcOlH7q2jydwAwAAAB4idANokcVa/9/HyqtC1xAAAAAgwhC6AbTIYq1P3cdKK0PYEgAAAP+yNvicAzTmj/7BnG4ALaqx1g8vP1ZeHcKWAAAA+Ed0dLSMRqMOHjyoTp06KTo6WgZD5E+hs1qtqqqqUkVFhd+2DDsV2Ww2VVVV6ciRIzIajYqOjvb5XIRuAC2yNAzdZVS6AQBA5DMajcrKylJBQYEOHjwY6ub4jc1m08mTJxUXF9cmvkQItfj4eHXv3r1VX2AQugG0qGHoPl5GpRsAALQN0dHR6t69u2pqamSxWELdHL+orq7WZ599phEjRshsNoe6ORHNZDIpKiqq1V9eELoBtKjh8PKjVLoBAEAbYjAYZDab20xANZlMqqmpUWxsbJv5N0U6BvkDaBGVbgAAAMA3hG4ALXJeSI0twwAAAABPEboBtMjqVOmuks1mc3M0AAAAADtCN4AWNax011htKqmoCWFrAAAAgMhB6AbQIovV6vTzsTKGmAMAAACeIHQDaFHDSrdE6AYAAAA8RegG0CKrjdANAAAA+ILQDaBFNRbn0H2c0A0AAAB4hNANoEWWRsPLjxK6AQAAAI8QugG0yD6nOzUhWpJ0nL26AQAAAI8QugG0yD6nu1O7GEnS0VJCNwAAAOAJQjeAFtnndHdKrA3dVLoBAAAAzxC6AbTIPqfbHrqZ0w0AAAB4htANoEU1VqukBpVuQjcAAADgEUI3gBbZdwyzz+lmn24AAADAM4RuAC2yNKp0l1bWqLLGEsomAQAAABGB0A2gRfaF1NonRMtkNEiSisqrQ9kkAAAAICIQugG0yL6QmtlkUPt4syS2DQMAAAA8QegG0CJL3T7dJoNBqQnRktg2DAAAAPAEoRtAi+yV7iiTQe3ja0M324YBAAAALSN0A2iRfU63yWhUh3Z1lW5CNwAAANAiQjeAFjkq3UYq3QAAAIA3CN0AWmSf021sOKeb0A0AAAC0KKSh+4knntB5552nxMREpaWlaeLEifr222+djrn44otlMBic/nfnnXc6HbN//35ddtllio+PV1pamu6//37V1NQ4HbNmzRoNHjxYMTEx6t27txYsWNCkPfPmzVPPnj0VGxuroUOHatOmTU73V1RU6K677lKHDh3Url07TZo0SYcOHfLPiwGEsYZzuu2h+xihGwAAAGhRSEP32rVrddddd2nDhg3Kzc1VdXW1xowZo7KyMqfjbr/9dhUUFDj+99RTTznus1gsuuyyy1RVVaX169frrbfe0oIFCzRz5kzHMfn5+brssst0ySWXaOvWrbr33nv129/+Vh9//LHjmPfee08zZszQrFmztGXLFg0cOFA5OTk6fPiw45j77rtPS5Ys0d///netXbtWBw8e1FVXXRXAVwgIDzUWqyTJZCR0AwAAAN6ICuWTr1ixwunnBQsWKC0tTZs3b9aIESMct8fHxysjI6PZc6xcuVK7du3SJ598ovT0dA0aNEiPPfaYHnzwQc2ePVvR0dF65ZVXlJWVpaefflqS1LdvX61bt07PPvuscnJyJEnPPPOMbr/9dt16662SpFdeeUXLli3TG2+8od///vcqLi7WX/7yFy1evFgjR46UJL355pvq27evNmzYoGHDhvn99QHCRcM53YRuAAAAwHNhNae7uLhYkpSamup0+6JFi9SxY0f169dPDz30kMrLyx335eXlqX///kpPT3fclpOTo5KSEu3cudNxzKhRo5zOmZOTo7y8PElSVVWVNm/e7HSM0WjUqFGjHMds3rxZ1dXVTseceeaZ6t69u+MYoK1qOKfbvpDaMfbpBgAAAFoU0kp3Q1arVffee68uuOAC9evXz3H79ddfrx49eqhz587atm2bHnzwQX377bf617/+JUkqLCx0CtySHD8XFha6PaakpEQnT57U8ePHZbFYmj1m9+7djnNER0crJSWlyTH252mssrJSlZWVjp9LSkokSdXV1aqurvbodQkme5vCsW0ILXul22a1KCmm9ru642VVqqqqksFgaPHx9C0EC30NwUR/gzfoLwgW+lrwePoah03ovuuuu7Rjxw6tW7fO6fY77rjD8d/9+/dXZmamLr30Uu3du1e9evUKdjO98sQTT2jOnDlNbl+5cqXi4+ND0CLP5ObmhroJCDM1FpMkg9Z+ulpxUZIUpRqrTf9c8pHivbiK0LcQLPQ1BBP9Dd6gvyBY6GuB13AEtjthEbqnT5+upUuX6rPPPlPXrl3dHjt06FBJ0p49e9SrVy9lZGQ0WWXcvqK4fR54RkZGk1XGDx06pKSkJMXFxclkMslkMjV7TMNzVFVVqaioyKna3fCYxh566CHNmDHD8XNJSYm6deumMWPGKCkpye2/MxSqq6uVm5ur0aNHy2w2h7o5CBNWq022vNqL9pjRo5SaEK1ZX61SWZVF511wsXp0aPkLJPoWgoW+hmCiv8Eb9BcEC30teOwjmVsS0tBts9l0991369///rfWrFmjrKysFh+zdetWSVJmZqYkafjw4frjH/+ow4cPKy0tTVLttzpJSUnKzs52HLN8+XKn8+Tm5mr48OGSpOjoaJ1zzjlatWqVJk6cKKl2uPuqVas0ffp0SdI555wjs9msVatWadKkSZKkb7/9Vvv373ecp7GYmBjFxMQ0ud1sNof1GyDc24fgqq5buVySYqOjZTab1T4hWmVVJ1VcafWqr9C3ECz0NQQT/Q3eoL8gWOhrgefp6xvS0H3XXXdp8eLF+uCDD5SYmOiYG52cnKy4uDjt3btXixcv1vjx49WhQwdt27ZN9913n0aMGKEBAwZIksaMGaPs7GxNmTJFTz31lAoLC/XII4/orrvucgTeO++8Uy+99JIeeOAB3XbbbVq9erX+9re/admyZY62zJgxQzfffLPOPfdcDRkyRM8995zKysocq5knJydr6tSpmjFjhlJTU5WUlKS7775bw4cPZ+VytGn2+dySZDLVzt/ukBCtA8dP6jgrmAMAAABuhTR0z58/X5J08cUXO93+5ptv6pZbblF0dLQ++eQTRwDu1q2bJk2apEceecRxrMlk0tKlSzVt2jQNHz5cCQkJuvnmmzV37lzHMVlZWVq2bJnuu+8+Pf/88+ratatef/11x3ZhknTttdfqyJEjmjlzpgoLCzVo0CCtWLHCaXG1Z599VkajUZMmTVJlZaVycnL08ssvB+jVAcJDTYPQHWWsDd3t2TYMAAAA8EjIh5e7061bN61du7bF8/To0aPJ8PHGLr74Yn311Vduj5k+fbpjOHlzYmNjNW/ePM2bN6/FNgFthcXSoNJdF7pT2TYMAAAA8EhY7dMNIPxYGnw5ZqrbHiyVSjcAAADgEUI3ALdqrLULqRkMkpHh5QAAAIBXCN0A3LIvpGafzy3VLqQmEboBAACAlhC6AbhVUzen29QgdFPpBgAAADxD6AbglrVuTrd9PrdEpRsAAADwFKEbgFv2LcOaq3SzTzcAAADgHqEbgFuOOd2m+suFvdJ9orJGlTWWkLQLAAAAiASEbgBuNTenOynW7Pi5qLw6JO0CAAAAIgGhG4Bbzc3pNhoNah9vliQdLWWIOQAAAOAKoRuAW83N6Zak9vF187rLCd0AAACAK1GhbgCA8GaxWiVJUSbn0J1SV+leubNQRoNBQ7JSmwRzAAAA4FRH6AbgVnNzulfsKND2A8WSpLfyftRbeT8qMzlWsyZka2y/zJC0EwAAAAhHDC8H4Jal0ZzuFTsKNG3hFlXUWJ2OKyyu0LSFW7RiR0HQ2wgAAACEK0I3ALcsDeZ0W6w2zVmyS7ZmjrPfNmfJLsdjAAAAgFMdoRuAWzWOfboN2pR/TAXFFS6PtUkqKK7QpvxjQWodAAAAEN4I3QDcsjjmdBt1+ITrwN2Qp8cBAAAAbR2hG4Bb9XO6pbTEWI8e4+lxAAAAQFtH6Abgln1+dpTRqCFZqcpMjpWrjcEMkjKTYzUkKzVo7QMAAADCGaEbgFs1DRZSMxkNmjUhu9nj7EF81oRs9usGAAAA6hC6AbhlsdZuDRZlqg3SY/tlav6Ng9WxXbTTcRnJsZp/42D26QYAAAAaiAp1AwCEN0vddtxGQ331emy/TGV3TtaIpz6VyWjQwqlDNSQrlQo3AAAA0AiVbgBuOSrdjQJ1UmxU3f02nduzPYEbAAAAaAahG4BbDed0NxQfXT9QprzKEtQ2AQAAAJGC0A3ALcfq5Sbn0B0dZZS57rayypqgtwsAAACIBIRuAG7ZQ3fDOd129mp3eRWhGwAAAGgOoRuAW/X7dDcN3QnRJklSWSXDywEAAIDmELoBuFU/p7vp5SI+prbSXUalGwAAAGgWoRuAW55UusupdAMAAADNInQDcMsxp7u50E2lGwAAAHCL0A3ArRo3le76hdSodAMAAADNIXQDcMtitUpquk+3JCXE2BdSo9INAAAANIfQDcAtTyrdrF4OAAAANI/QDcAtq2P1cjcLqTGnGwAAAGgWoRuAWzVuQjdbhgEAAADuEboBuMWWYQAAAIDvCN0A3KqvdDe9XFDpBgAAANwjdANwq35Od9P72sXY53RT6QYAAACaQ+gG4JbbSrdj9XIq3QAAAEBzCN0A3HI/p7s2dFPpBgAAAJpH6AbglvvVy2uHlzOnGwAAAGgeoRuAW+736bYPL6fSDQAAADSH0A3ArRqrVZKLSnfdlmHM6QYAAACaR+gG4JbbOd11W4ZV1lhVY7EGtV0AAABAJCB0A3DL3ZzuhLo53ZJUXs0QcwAAAKAxQjcAtyxuQne0yeiogJczrxsAAABogtANwC13odtgMNTP62YFcwAAAKAJQjcAt2occ7qbv1zY53VT6QYAAACaInQDcMtdpVsSlW4AAADADUI3ALdaCt32SjfbhgEAAABNEboBuOVuyzCpYaWb4eUAAABAY4RuAG652zJMkhKi7XO6qXQDAAAAjRG6AbhlsVolua50O4aXU+kGAAAAmiB0A3Cr5TndtcPLqXQDAAAATRG6AbjV8urlVLoBAAAAVwjdANxqeU53XaWbLcMAAACAJgjdANyqX728+ctFvGPLMCrdAAAAQGOEbgButTin275lGHO6AQAAgCYI3QDc8nxON6EbAAAAaIzQDcCtFud021cvZyE1AAAAoAlCNwC36ud0t7BPN8PLAQAAgCYI3QDc8nR4OZVuAAAAoClCNwC3WlxILYYtwwAAAABXCN0A3KqxWiW5GV4ezZZhAAAAgCuEbgAu2Ww21RW63Qwvr610n6y2OKriAAAAAGoRugG41DBERxmbv1zYF1KTGGIOAAAANEboBuBSTYPQ7SJzKybKKHsRnMXUAAAAAGchDd1PPPGEzjvvPCUmJiotLU0TJ07Ut99+63RMRUWF7rrrLnXo0EHt2rXTpEmTdOjQIadj9u/fr8suu0zx8fFKS0vT/fffr5oa54rbmjVrNHjwYMXExKh3795asGBBk/bMmzdPPXv2VGxsrIYOHapNmzZ53RagLfGk0m0wGBrM66bSDQAAADQU0tC9du1a3XXXXdqwYYNyc3NVXV2tMWPGqKyszHHMfffdpyVLlujvf/+71q5dq4MHD+qqq65y3G+xWHTZZZepqqpK69ev11tvvaUFCxZo5syZjmPy8/N12WWX6ZJLLtHWrVt177336re//a0+/vhjxzHvvfeeZsyYoVmzZmnLli0aOHCgcnJydPjwYY/bArQ1DSvdruZ0S/VDzKl0AwAAAM6iWj4kcFasWOH084IFC5SWlqbNmzdrxIgRKi4u1l/+8hctXrxYI0eOlCS9+eab6tu3rzZs2KBhw4Zp5cqV2rVrlz755BOlp6dr0KBBeuyxx/Tggw9q9uzZio6O1iuvvKKsrCw9/fTTkqS+fftq3bp1evbZZ5WTkyNJeuaZZ3T77bfr1ltvlSS98sorWrZsmd544w39/ve/96gtQFtjdap0uw7d8XXbhlHpBgAAAJyF1Zzu4uJiSVJqaqokafPmzaqurtaoUaMcx5x55pnq3r278vLyJEl5eXnq37+/0tPTHcfk5OSopKREO3fudBzT8Bz2Y+znqKqq0ubNm52OMRqNGjVqlOMYT9oCtDXOc7rdVLqjqXQDAAAAzQlppbshq9Wqe++9VxdccIH69esnSSosLFR0dLRSUlKcjk1PT1dhYaHjmIaB236//T53x5SUlOjkyZM6fvy4LBZLs8fs3r3b47Y0VllZqcrKSsfPJSUlkqTq6mpVV1e7fT1Cwd6mcGwbQqOiqkpSbZXbXb+IM9d+f1dSXtnscfQtBAt9DcFEf4M36C8IFvpa8Hj6GodN6L7rrru0Y8cOrVu3LtRN8ZsnnnhCc+bMaXL7ypUrFR8fH4IWeSY3NzfUTUCYOFYpSVEy2Kxavny5y+NKi4ySjNqw+SvpJ9d7ddO3ECz0NQQT/Q3eoL8gWOhrgVdeXu7RcWERuqdPn66lS5fqs88+U9euXR23Z2RkqKqqSkVFRU4V5kOHDikjI8NxTONVxu0rijc8pvEq44cOHVJSUpLi4uJkMplkMpmaPabhOVpqS2MPPfSQZsyY4fi5pKRE3bp105gxY5SUlOTJSxNU1dXVys3N1ejRo2U2m0PdHISB/cfKpS3rFG2O0vjxOS6PW3lim3YVFeq0M7I1fniPJvfTtxAs9DUEE/0N3qC/IFjoa8FjH8nckpCGbpvNprvvvlv//ve/tWbNGmVlZTndf84558hsNmvVqlWaNGmSJOnbb7/V/v37NXz4cEnS8OHD9cc//lGHDx9WWlqapNpvdZKSkpSdne04pnGVLjc313GO6OhonXPOOVq1apUmTpwoqXa4+6pVqzR9+nSP29JYTEyMYmJimtxuNpvD+g0Q7u1D8BiMtQukGY0Gt32iXWztfZU1NrfH0bcQLPQ1BBP9Dd6gvyBY6GuB5+nrG9LQfdddd2nx4sX64IMPlJiY6JgbnZycrLi4OCUnJ2vq1KmaMWOGUlNTlZSUpLvvvlvDhw93rBY+ZswYZWdna8qUKXrqqadUWFioRx55RHfddZcj8N5555166aWX9MADD+i2227T6tWr9be//U3Lli1ztGXGjBm6+eabde6552rIkCF67rnnVFZW5ljN3JO2AG2NfZ9udyuXS/VbhpWxkBoAAADgJKShe/78+ZKkiy++2On2N998U7fccosk6dlnn5XRaNSkSZNUWVmpnJwcvfzyy45jTSaTli5dqmnTpmn48OFKSEjQzTffrLlz5zqOycrK0rJly3Tffffp+eefV9euXfX66687tguTpGuvvVZHjhzRzJkzVVhYqEGDBmnFihVOi6u11BagrbGvXm4yut/oIKFuy7BytgwDAAAAnIR8eHlLYmNjNW/ePM2bN8/lMT169HC7yJNUG+y/+uort8dMnz7dMZzc17YAbYmnle74aCrdAAAAQHPCap9uAOHF4qh0tzS8vK7SXUWlGwAAAGiI0A3ApRoPQ7ej0l1JpRsAAABoiNANwCWPF1KLptINAAAANIfQDcClGqtVkgeV7rrVy0updAMAAABOCN0AXKrL3C3P6abSDQAAADSL0A3AJU8r3Y59uql0AwAAAE4I3QBc8nxOd23optINAAAAOCN0A3DJ49XLHVuGWWStewwAAAAAQjcAN6ye7tNdV+mWpJPVDDEHAAAA7AjdAFzytNIdazbKUHdIGUPMAQAAAAdCNwCX6ud0u79UGAyG+nndLKYGAAAAOBC6AbjkaaVbkuLrtg0rraTSDQAAANgRugG45Omcbql+27DyKirdAAAAgB2hG4BL3lS6E+pWMGdONwAAAFCP0A3AJYvVKqnlfbolKZ453QAAAEAThG4ALnlV6Y6m0g0AAAA0RugG4JLFm4XU7HO6WUgNAAAAcCB0A3DJm9BdX+lmeDkAAABgR+gG4FKNY59uL+Z0M7wcAAAAcCB0A3CpvtLd8qXCsXo5C6kBAAAADoRuAC7Vh+6Wj7Xv013GnG4AAADAgdANwCWLY3i5B5Vux/ByKt0AAACAHaEbgEvebBkWz5ZhAAAAQBOEbgAuWaxWSZ4tpJbg2DKMSjcAAABgR+gG4JKlNnPLSKUbAAAA8AmhG4BLPlW6mdMNAAAAOBC6Abjk05xuVi8HAAAAHAjdAFyqX73cg0o3q5cDAAAATRC6AbhkD92ezOl27NNdVSObzRbQdgEAAACRgtANwCWvKt0xtcPLbTbpZDXVbgAAAEAidANwo35Od8uXitgokwx12byMbcMAAAAASYRuAG54U+k2Gg2KN9dWu8vZNgwAAACQROgG4IY3c7olKd4+r5tKNwAAACCJ0A3AjRovKt2SlBBNpRsAAABoiNANwCWL1SrJs326JSk+2r6COZVuAAAAQJKiQt0AAK1jsdq0Kf+YDp+oUFpirIZkpXocklvidaW7bgXz8koq3QAAAIBE6AYi2oodBZqzZJcKiisct2Umx2rWhGyN7ZfZ6vNbbfbVyz0N3bWXlFJCNwAAACCJ4eVAxFqxo0DTFm5xCtySVFhcoWkLt2jFjoJWP0eNxcvQXTe8vJzh5QAAAIAkQjcQkSxWm+Ys2SVbM/fZb5uzZJdj9fHWPI/k+fDy+LqF1MpYSA0AAACQROgGItKm/GNNKtwN2SQVFFdoU/6xVj2PfU63yejZpSKuLnRv3V+kvL1HWx36AQAAgEjHnG4gAh0+4Tpw+3KcK/Vzuls+dsWOAv1zywFJ0spdh7Ry1yHH/PJLz+jYqnYAAAAAkYpKNxCB0hJj/XqcK/Vzut1fKuzzy8sqnedy2+eXf7zzUKvaAQAAAEQqQjcQgYZkpSozOVauZlobVLuK+ZCs1FY9jydzuj2ZX/7Hj3aLkeYAAAA4FRG6gQhkMho0a0J2s/fZ4/GsCdmt3q+7xmp1PJ8rns0vr9TeEv/sHQ4AAABEEkI3EKHG9svU/BsHO1YMt8tIjtX8Gwf7aZ/u2v/vLnR7Om+8pLrVzQEAAAAiDgupARFsbL9MrfrmsP6+uXYBs7/edp4u6N2p1RVuO08q3Z7OG08y+6VJAAAAQESh0g1EuJoGk6XPzEzyW+CWJIul5Tndns0vj1GvJCZ1AwAA4NRD6AYiXFWN1fHfxeX+HcNdv0+369DdcH5546PsP/9h3Jny43cBAAAAQMQgdAMRrrJB6C466d/QXb9Pt/vEbJ9fnpHsPNTcPr8856x0v7YLAAAAiBSEbiDCVVkahO4AVbrdDS+3G9svU+seHKkx2bUB+9cDO2vdgyP9sqAbAAAAEKkI3UCEq6qxOP672M+VbvucbpPRs0uFyWjQsNM61LXL6tf55QAAAEAkInQDEa7hnO6i8iq/ntubSrddVqcESVL+L2V+bQsAAAAQiQjdQIRrOLzc75XuujndRm9Cd4fa0L3vaJmsVlYsBwAAwKmN0A1EOOdKt59Dtw+V7q7t4xRlNKiyxqqCkgq/tgcAAACINIRuIMI5bRnmx0q3zWZzhG5v5mZHmYzq3iFekrSPIeYAAAA4xRG6gQhXFaAtwywNhoZ7U+mW6oeY/0DoBgAAwCmO0A1EOKc53X5cSM0+n1vybk63JGV1rFtM7QihGwAAAKc2QjcQ4SrDsdLdqX4xNQAAAOBURugGIlygFlKraRC6vd1v2z68nG3DAAAAcKojdAMRzGazOQ0vL6mo9ts2XRZLw0q3d5cKe6X7p2Plqm7QPgAAAOBUQ+gGIliN1aYGU69ls0knKmr8cm6nOd3eFbqVnhirWLNRNVabDhw/6Zf2AAAAAJGI0A1EsIZDy+3BuOikfxZTa7hdmMHgXeo2Gg3q6RhiXuqX9gAAAACRiNANRLCGobtjuxhJ/pvXXePDHt0NndbJHrrL/dIeAAAAIBIRuoEIZp/PbTIalJoQLUkq9tMK5vY53d6uXG5HpRsAAAAgdAMRzV7pjjYZlRJvluS/bcPsc7pNXg4tt3Ps1c0K5gAAADiFEbqBCGbfozs6yqiUuLpKd7m/5nTXVdFNrQvd+xheDgAAgFMYoRuIYFUNQndyXF2l289zun0dXm4P3T8XnVRFtcUvbQIAAAAiTUhD92effaYJEyaoc+fOMhgMev/9953uv+WWW2QwGJz+N3bsWKdjjh07phtuuEFJSUlKSUnR1KlTVVrqPId027ZtuuiiixQbG6tu3brpqaeeatKWv//97zrzzDMVGxur/v37a/ny5U7322w2zZw5U5mZmYqLi9OoUaP0/fff++eFAHxkn9PdcHi5v+Z011hat5BaakK0kmKjJEn7j1HtBgAAwKkppKG7rKxMAwcO1Lx581weM3bsWBUUFDj+98477zjdf8MNN2jnzp3Kzc3V0qVL9dlnn+mOO+5w3F9SUqIxY8aoR48e2rx5s/7v//5Ps2fP1quvvuo4Zv369Zo8ebKmTp2qr776ShMnTtTEiRO1Y8cOxzFPPfWUXnjhBb3yyivauHGjEhISlJOTo4qKCj++IoB37JXumCijkv08p9tqs1e6fbtMGAyGBvO6Cd0AAAA4NUWF8snHjRuncePGuT0mJiZGGRkZzd73zTffaMWKFfriiy907rnnSpJefPFFjR8/Xn/+85/VuXNnLVq0SFVVVXrjjTcUHR2ts846S1u3btUzzzzjCOfPP/+8xo4dq/vvv1+S9Nhjjyk3N1cvvfSSXnnlFdlsNj333HN65JFHdMUVV0iS/vrXvyo9PV3vv/++rrvuOn+9JIBXqpqZ0+3v4eU+Zm5JtUPMvz5QrH1Hy9Wtwe0Wq02b8o/p8IkKpSXGakhWqs8VdQAAACCc+RS6TzvtNH3xxRfq0KGD0+1FRUUaPHiwfvjhB780TpLWrFmjtLQ0tW/fXiNHjtTjjz/ueN68vDylpKQ4ArckjRo1SkajURs3btSVV16pvLw8jRgxQtHR0Y5jcnJy9OSTT+r48eNq37698vLyNGPGDKfnzcnJcQx3z8/PV2FhoUaNGuW4Pzk5WUOHDlVeXp7L0F1ZWanKykrHzyUlJZKk6upqVVf7Jxj5k71N4dg2NK+8snbRNLPJoHbRtaG1qLzSL7/Dyqrac5gMBp/P1z01TpL0w5FSdYur7Vsf7zykx5fvVmFJ/XsjIylGj4w/Uzlnpbe63Ti1cR1DMNHf4A36C4KFvhY8nr7GPoXuffv2yWJpujBSZWWlfv75Z19O2ayxY8fqqquuUlZWlvbu3auHH35Y48aNU15enkwmkwoLC5WWlub0mKioKKWmpqqwsFCSVFhYqKysLKdj0tPTHfe1b99ehYWFjtsaHtPwHA0f19wxzXniiSc0Z86cJrevXLlS8fHxnrwEIZGbmxvqJsBDXx81SDKptKRYu7d/JcmkA4ePN1mTwBffF9ee+2R5mc/nK/ql9hxb9x7Ur/pJf373E73xnb10Xl/ZLiyp0PR3t+q2060a2MHW6rYDXMcQTPQ3eIP+gmChrwVeeblnUyi9Ct0ffvih478//vhjJScnO362WCxatWqVevbs6c0p3WpYQe7fv78GDBigXr16ac2aNbr00kv99jyB8tBDDzlV0EtKStStWzeNGTNGSUlJIWxZ86qrq5Wbm6vRo0fLbDaHujnwgGVbgfTddmV06qAxvzpdL+/aIGtUrMaP/1Wrz71+71Fp12alJCVq/PjzfTpH959L9NfvN6jYGiOrrVzLCuMlVTZzpEEGSR8ditcDN4xgqDl8xnUMwUR/gzfoLwgW+lrw2Ecyt8Sr0D1x4kRJtQsk3XzzzU73mc1m9ezZU08//bQ3p/TKaaedpo4dO2rPnj269NJLlZGRocOHDzsdU1NTo2PHjjnmgWdkZOjQoUNOx9h/bumYhvfbb8vMzHQ6ZtCgQS7bGxMTo5iYmCa3m83msH4DhHv7UM9iqw2nMWaTOibVDuUuOlmtqKgoGQytDK5GkyTJZDT63B96Z9R+uXS0rEof/mjQoZLmAnctm6SC4kp9deCEhvfq4PI4wBNcxxBM9Dd4g/6CYKGvBZ6nr69XSyRZrVZZrVZ1795dhw8fdvxstVpVWVmpb7/9VpdffrlPDfbEgQMHdPToUUfwHT58uIqKirR582bHMatXr5bVatXQoUMdx3z22WdO4+1zc3N1xhlnqH379o5jVq1a5fRcubm5Gj58uCQpKytLGRkZTseUlJRo48aNjmOAUHDeMqx23YKqGqsqqq2tPrfFWnuOKJPv4f0/e36RvWj9aYHJo8ccPsGOAAAAAGg7fFqXOD8/Xx07dmz1k5eWlmrr1q3aunWr47xbt27V/v37VVpaqvvvv18bNmzQvn37tGrVKl1xxRXq3bu3cnJyJEl9+/bV2LFjdfvtt2vTpk36z3/+o+nTp+u6665T586dJUnXX3+9oqOjNXXqVO3cuVPvvfeenn/+eadh3/fcc49WrFihp59+Wrt379bs2bP15Zdfavr06ZJqK/v33nuvHn/8cX344Yfavn27brrpJnXu3NlR/QdCoeHq5QnRJkXVJdyik1WtPndr9+lesaNA0xZukdXLKdppibE+PR8AAAAQjnzeMmzVqlVatWqVo+Ld0BtvvOHROb788ktdcskljp/tQfjmm2/W/PnztW3bNr311lsqKipS586dNWbMGD322GNOQ7YXLVqk6dOn69JLL5XRaNSkSZP0wgsvOO5PTk7WypUrddddd+mcc85Rx44dNXPmTKe9vM8//3wtXrxYjzzyiB5++GH16dNH77//vvr16+c45oEHHlBZWZnuuOMOFRUV6cILL9SKFSsUG0tAQOg0DN0Gg0HJcWYdLatS8clqZSbHterc9ft0ex+6LVab5izZJW/ytkFSRnLt9mEAAABAW+FT6J4zZ47mzp2rc889V5mZmT7PHb344otls7n+WP7xxx+3eI7U1FQtXrzY7TEDBgzQ559/7vaYq6++WldffbXL+w0Gg+bOnau5c+e22CYgWOyhOyaqdtBKcnxt6PbHXt2Ofbp9eH9vyj+mgmLPh4nbn2HWhGwWUQMAAECb4lPofuWVV7RgwQJNmTLF3+0B4IWGc7olKSWudjEHf4RuS13o9mVOt7fzsjOSYzVrQrbG9sts+WAAAAAggvgUuquqqnT++b5tIQTAfxoOL5fkWEyt2K9zur1f+sGbednzrh+ssf0yqHADAACgTfJpIbXf/va3LQ7pBhB4lY1Cd3Jdpbv4pB8q3a2Y0z0kK1WZybFy9UiDJPuo9dPT2xG4AQAA0Gb5VOmuqKjQq6++qk8++UQDBgxosj/ZM88845fGAXCvfnh57XZcyQEYXu7LnG6T0aBZE7I1beEWGSSnBdXsZ0tNiNbR0iqVVNS0uq0AAABAuPIpdG/btk2DBg2SJO3YscPpPl8XVQPgvabDy+tCtx8q3faF1HypdEvS2H6Zmn/jYM1ZsstpUTX7/O3nV+3R0dIqlVYSugEAANB2+RS6P/30U3+3A4APGg8vty+kVuyPSnddFd3kw0JqdmP7ZWp0doby9hzWys83asxFQzW8d5pMRoPe+M8+SdKJita3FQAAAAhXPu/TDSD0qmoskpoupFbkh4XU6tZR87nSbWcyGjQ0K1VHv7FpaFaqY/52Ykzt5aeU4eUAAABow3wK3ZdcconbYeSrV6/2uUEAPOfYp9sUgIXUrHWV7gBNGUmMrb38nCB0AwAAoA3zKXTb53PbVVdXa+vWrdqxY4duvvlmf7QLgAccC6nZVy+P999CavY53YFaWbydPXQzpxsAAABtmE+h+9lnn2329tmzZ6u0tLRVDQLguSYLqfl1TnfdQmqtmNPtTmJsbVuZ0w0AAIC2zKd9ul258cYb9cYbb/jzlADccIRuk/Oc7hOVNaqpq4L7yr5Pd8Aq3czpBgAAwCnAr6E7Ly9PsbGx/jwlADcar16eFFs/eKW1+1/b9+kO1JzuJOZ0AwAA4BTg0/Dyq666yulnm82mgoICffnll3r00Uf90jAALWs8pzvKZFRiTJROVNaoqLxKqQnRPp+7fk63X7+bc3AML69keDkAAADaLp9Cd3JystPPRqNRZ5xxhubOnasxY8b4pWEAWtZ4TrdUu5jaicoaFbVyBXN7pTtQc7oZXg4AAIBTgU+h+8033/R3OwD4oPGcbklKiTfrwPGTrV5MzRLg1cvZMgwAAACnAp9Ct93mzZv1zTffSJLOOussnX322X5pFADP2IeXxzSodKfE1Q4pb+1e3YGe082WYQAAADgV+BS6Dx8+rOuuu05r1qxRSkqKJKmoqEiXXHKJ3n33XXXq1MmfbQTgQrPDy+Pse3VXtercNdbacweq0p3ElmEAAAA4Bfi0QtLdd9+tEydOaOfOnTp27JiOHTumHTt2qKSkRP/93//t7zYCcMHVnG5J/pvTHeAtwyqqrapu5fZmAAAAQLjyqdK9YsUKffLJJ+rbt6/jtuzsbM2bN4+F1IAgsVptjhXGneZ0OyrdfhpeHqiF1Bpsb1ZaUaP2rVhpHQAAAAhXPlW6rVarzGZzk9vNZrOsVipWQDBUNagON6x0p9RVuls7p7smwHO6zSaj4swmSVIp87oBAADQRvkUukeOHKl77rlHBw8edNz2888/67777tOll17qt8YBcK2yxkXo9vdCagEaXi7VV7tLmNcNAACANsqn0P3SSy+ppKREPXv2VK9evdSrVy9lZWWppKREL774or/bCKAZVQ1Dd4Ph5Ul+W0gtsHO6pfptw9irGwAAAG2VT3O6u3Xrpi1btuiTTz7R7t27JUl9+/bVqFGj/No4AK7Zh5dHm4wyNBgCnuKnhdSsjjndPn0355HEGPbqBgAAQNvm1afp1atXKzs7WyUlJTIYDBo9erTuvvtu3X333TrvvPN01lln6fPPPw9UWwE00NzK5VKDOd2tXEgt0HO6JSnRvm1YJcPLAQAA0DZ5Fbqfe+453X777UpKSmpyX3Jysv7rv/5LzzzzjN8aB8A1l6G7wZxum83m8/kDvWWYVL9tGMPLAQAA0FZ5Fbq//vprjR071uX9Y8aM0ebNm1vdKAAtc4TuRsO/k+vmdNdYbSqrsvh8/pogLKSW6FhIjdANAACAtsmr0H3o0KFmtwqzi4qK0pEjR1rdKAAtq7LUBurGle5Ys9FxW2sWU7PP6Y4K0D7dUv3q5WwZBgAAgLbKq9DdpUsX7dixw+X927ZtU2ZmZqsbBaBllS6GlxsMBqU4VjD3fa50jbX2/MZgzOlmyzAAAAC0UV6F7vHjx+vRRx9VRUVFk/tOnjypWbNm6fLLL/db4wC45mp4uVS/mFpJK1YwD8ac7iS2DAMAAEAb59WWYY888oj+9a9/6fTTT9f06dN1xhlnSJJ2796tefPmyWKx6A9/+ENAGgrAmauF1CQpua6CnPvNIRkMBg3JSvV6bnYw5nS3Y8swAAAAtHFehe709HStX79e06ZN00MPPeRYGdlgMCgnJ0fz5s1Tenp6QBoKwJl9n+6YRqF7xY4Cbfu5WJL05n/26c3/7FNmcqxmTcjW2H6eT/8Ixpzu+i3DCN0AAABom7wK3ZLUo0cPLV++XMePH9eePXtks9nUp08ftW/fPhDtA+BCc5XuFTsKNG3hFjXeKKywuELTFm7R/BsHexy87ZXuQM7pti+kRqUbAAAAbZXXoduuffv2Ou+88/zZFgBesIdue6XbYrVpzpJdTQK3JNkkGSTNWbJLo7MzPBoyXj+n26ulH7yS6AjdLKQGAACAtilwn6YBBJR9eLm90r0p/5gKipsucmhnk1RQXKFN+cc8On9Q9umOYcswAAAAtG2EbiBCNV69/PAJ14G7IU+PC+qc7ooaxxoRAAAAQFtC6AYiVON9utMSYz16nKfHBWNOt314ucVqU0W1NWDPAwAAAIQKoRuIUI0XUhuSlarM5Fi5isgGSZnJsRqSlerR+YOxT3d8tEn20zOvGwAAAG0RoRuIUI453SaTpNq517MmZDd7rD02z5qQ7fEc7Rqr1XHeQDEYDPV7dTOvGwAAAG0QoRuIUM1tGTa2X6bm3zhYHdpFOx2bkRzr1XZhklSX6QM6p1tyntcNAAAAtDU+bxkGILSaC91SbfDu1amdRj/7mWLNRr15yxANyUr1umJtsVe6AzinW6qf111K6AYAAEAbROgGIlTjfbobSo4zO44ZdlqqDD4E52BsGSapfng5c7oBAADQBjG8HIhQ9XO6m76N29VVj6026WS1xafz1y+kFtjLhL3SzfByAAAAtEWEbiBCuRpeLklx5vpVwX0dtm0P3aZgzelmITUAAAC0QYRuIEI13qe7IYPBoIS6YdulPoZZR+gO8JzudrEMLwcAAEDbRegGIpS74eWSlNiK0G2z2YI2p5uF1AAAANCWEbqBCFVVUztXu7lKt6RWVbrr8rYkKSrQoTuGOd0AAABouwjdQIRyN7xcqh+27UsF2dIgdQdrTrevw+ABAACAcEboBiKUu4XUpPqtuHwJs06hO9BzuuvaWcKcbgAAALRBhG4gQjn26XYxp9seZst8CN01Vqvjv4M2p5tKNwAAANogQjcQoRwLqbVQ6fZlK66Gle5Az+luxz7dAAAAaMMI3UCEanF4ub/mdAc4dCfZ9+lmeDkAAADaIEI3EKE8ndPty/Bye+g2Gmr3/A4ktgwDAABAW0boBiKUI3S3MKfbl+Hl9j26o4yBv0Q4vhyosjhV2AEAAIC2gNANRKjKluZ0+2F4eaCHlkv17ZRYTA0AAABtD6EbiEA2m83z4eVVvofuQC+iJkkxUSbHv4F53QAAAGhrCN1ABKq21A/DjjGZmj3GsU+3D5Vu+/ByYxBCtyQlsW0YAAAA2ihCNxCB7NuFSYHdMiwYlW6pQVtZTA0AAABtDKEbiED2oeWS69Cd0IrVy2ustecPxpxuSUqs2zaMFcwBAADQ1hC6gQhkD90mo8FlMG7NVlx1mTtolW57W0uY0w0AAIA2htANRKCWtguTGlS6qyyyerkVl73SHaw53QwvBwAAQFtF6AYiUJXFIsn10HKpPshK3q9gHuw53Y7h5SykBgAAgDaG0A1EoMoWtguTpJgoo8ym2tDsbZitCeI+3VL98HK2DAMAAEBbQ+gGIpAnw8sNBoPPi6lZHZXu4FwiWjP/HAAAAAhnhG4gAtlDd4ybSrfk+1zpYO/TzZxuAAAAtFWEbiAC2ffpdje8XKoPs94OLw/VnG5f9hQHAAAAwhmhG4hAVR7M6ZbqQ7e3w8uDPae7HXO6AQAA0EaFNHR/9tlnmjBhgjp37iyDwaD333/f6X6bzaaZM2cqMzNTcXFxGjVqlL7//nunY44dO6YbbrhBSUlJSklJ0dSpU1VaWup0zLZt23TRRRcpNjZW3bp101NPPdWkLX//+9915plnKjY2Vv3799fy5cu9bgsQLJ7M6ZYahtlwr3T7VpEHAAAAwl1IQ3dZWZkGDhyoefPmNXv/U089pRdeeEGvvPKKNm7cqISEBOXk5KiiosJxzA033KCdO3cqNzdXS5cu1WeffaY77rjDcX9JSYnGjBmjHj16aPPmzfq///s/zZ49W6+++qrjmPXr12vy5MmaOnWqvvrqK02cOFETJ07Ujh07vGoLECzBGl4erDndST5+OQAAAACEu6iWDwmccePGady4cc3eZ7PZ9Nxzz+mRRx7RFVdcIUn661//qvT0dL3//vu67rrr9M0332jFihX64osvdO6550qSXnzxRY0fP15//vOf1blzZy1atEhVVVV64403FB0drbPOOktbt27VM8884wjnzz//vMaOHav7779fkvTYY48pNzdXL730kl555RWP2gIEkydbhkmtGV5ee/5gVbrbxdTt003oBgAAQBsT0tDtTn5+vgoLCzVq1CjHbcnJyRo6dKjy8vJ03XXXKS8vTykpKY7ALUmjRo2S0WjUxo0bdeWVVyovL08jRoxQdHS045icnBw9+eSTOn78uNq3b6+8vDzNmDHD6flzcnIcw909aUtzKisrVVlZ6fi5pKREklRdXa3q6vCbu2pvUzi2Dc5OVtb+jsxGg9vfV7y5NpQXl1d59Xutqq4Nv0aDf/pDS30rru5KVFIRnu8NRA6uYwgm+hu8QX9BsNDXgsfT1zhsQ3dhYaEkKT093en29PR0x32FhYVKS0tzuj8qKkqpqalOx2RlZTU5h/2+9u3bq7CwsMXnaaktzXniiSc0Z86cJrevXLlS8fHxLh8Xarm5uaFuAlqwtcAgyaRfDhc2WX+goYM/1R636/sftNyyx+Pzf3W49nHHfjni9vzectW3TtZIUpSqLTZ9sHS5zCzxiFbiOoZgor/BG/QXBAt9LfDKy8s9Oi5sQ3db8NBDDzlV0EtKStStWzeNGTNGSUlJIWxZ86qrq5Wbm6vRo0fLbDaHujlw48Dn+dK+79WzWxeNH9/f5XGF/9mnFQe+U4d098c1VvrlAWnvLmWkp2v8+LNb3d6W+pbVatPvv6j9w3DhxZeqQ7uYVj8nTk1cxxBM9Dd4g/6CYKGvBY99JHNLwjZ0Z2RkSJIOHTqkzMxMx+2HDh3SoEGDHMccPnzY6XE1NTU6duyY4/EZGRk6dOiQ0zH2n1s6puH9LbWlOTExMYqJaRoezGZzWL8Bwr19kCy22rnWsdFRbn9XyfG1/a+82uLV79RmqC01m6OMfu0L7vpWu5golVbW6KTFQP9Dq3EdQzDR3+AN+guChb4WeJ6+vmE7iDMrK0sZGRlatWqV47aSkhJt3LhRw4cPlyQNHz5cRUVF2rx5s+OY1atXy2q1aujQoY5jPvvsM6fx9rm5uTrjjDPUvn17xzENn8d+jP15PGkLEEzB2zIseJcIx7ZhLKYGAACANiSkobu0tFRbt27V1q1bJdUuWLZ161bt379fBoNB9957rx5//HF9+OGH2r59u2666SZ17txZEydOlCT17dtXY8eO1e23365NmzbpP//5j6ZPn67rrrtOnTt3liRdf/31io6O1tSpU7Vz50699957ev75552Gfd9zzz1asWKFnn76ae3evVuzZ8/Wl19+qenTp0uSR20BgsnTLcMS7KuXV/kWuk1BWr1cqg/dJypY9AMAAABtR0iHl3/55Ze65JJLHD/bg/DNN9+sBQsW6IEHHlBZWZnuuOMOFRUV6cILL9SKFSsUGxvreMyiRYs0ffp0XXrppTIajZo0aZJeeOEFx/3JyclauXKl7rrrLp1zzjnq2LGjZs6c6bSX9/nnn6/FixfrkUce0cMPP6w+ffro/fffV79+/RzHeNIWIFiqPNwyLDHGt+pxKEK3fXuzE15ubwYAAACEs5CG7osvvlg2m83l/QaDQXPnztXcuXNdHpOamqrFixe7fZ4BAwbo888/d3vM1VdfrauvvrpVbQGCxb5Pd0yUye1x9uHlpZUWr85fE5JKd+2cGG+HwgMAAADhLGzndANwzdNKd0K0PXR7N2TbYq09f1QwK92OOd0MLwcAAEDbQegGIpBjTncLC6nZ50lXVFtVU/cYT9gPDWalO8nHRd8AAACAcEboBiJQVU3tcHFPF1KTpDIvhpjbK93BDN3x0bVD5b/6qUh5e4865pUDAAAAkSxs9+kG4Jqnw8vNJqNiooyqrLHqRGW1kuM920sw2HO6V+wo0HtfHJAkrd59WKt3H1ZmcqxmTcjW2H6ZQWkDAAAAEAhUuoEIZB9eHtNC6JYa7H/txarg9ft0Bz50r9hRoGkLtzRpX2FxhaYt3KIVOwoC3gYAAAAgUAjdQARyVLpbmNMtNdir24fQbTIG9hJhsdo0Z8kuNTeQ3H7bnCW7GGoOAACAiEXoBiKQp8PLpQb7X3uxQFn98HIfGueFTfnHVFBc4fJ+m6SC4gptyj8W2IYAAAAAAULoBiJQpQ+h25fh5YGudB8+4Tpw+3IcAAAAEG4I3UAE8nTLMKk+dHszvLwmSHO60xJj/XocAAAAEG4I3UAE8mp4uQ/7X1uDtHr5kKxUZSbHytWzGCRlJsdqSFZqQNsBAAAABAqhG4hAgR5eHqxKt8lo0KwJ2ZLUJHjbf541ITuo+4UDAAAA/kToBiKQvdLtyZZhvgwvt1hrzx+MsDu2X6bm3zhYGcnOQ8gzkmM1/8bB7NMNAACAiEboBiJQ/ZZhphaPbU2lO1gV5rH9MrXuwZEacXpHSdK153XTugdHErgBAAAQ8QjdQARyLKTmxZzu0kqLx+e32oIzvLwhk9GgQd3aO/6bIeUAAABoCwjdQISxWG2OLb08Cd0J9kp3RbXHz1FjCc6WYY11TYmTJP18/GRQnxcAAAAIFEI3EGHsQ8slz0J3Yqv26fayca3UuS50HywidAMAAKBtIHQDEcYpdHuyT7cPw8vr53QH9xLRpX1dpbvopGx1Q9wBAACASEboBiJMpaU+PJtNLc97dgwvr/R8eHko5nRLtXtyS1J5lUVF5Z63FwAAAAhXhG4gwlQ12KPbYGg5FDuGl1d4sXq5Jbirl9vFmk3q2C5GUm21GwAAAIh0hG4gwjj26PZwwnWCY59uz4eXW4K8ZVhDXVJqq92EbgAAALQFhG4gwnizXZhUP6e7ymJVZY1nwbvGWvscIQnd7VlMDQAAAG0HoRuIMA2Hl3siITrK8d+eDjGvG10e9DndktQ5mW3DAAAA0HYQuoEI423oNhkNio82SfJ8iLklHCrdxYRuAAAARD5CNxBhHKHbi02029XN6z7h4QrmoVpITarfq5tKNwAAANoCQjcQYSq9nNMtNdir29Ph5SFdSM2+V3dF0J8bAAAA8DdCNxBhvB1eLtVXusuqPJ3Tbd+nO/iXCHvo/qW0UhXVnq+4DgAAAIQjQjcQYVo1vDwCKt0p8WbHHPSCYqrdAAAAiGyEbiDCtKbSXVrpWegO5Zxug8HAvG4AAAC0GYRuIMLY9+mO8WV4uYeh217pDsWWYVL9EHP26gYAAECkI3QDEcanSre3C6nZQlfpluq3DTtA6AYAAECEI3QDEaY1c7pLPd6nOzwq3QwvBwAAQKQjdAMRpsqHLcMSHKHb0326a5/DyPByAAAAoFUI3UCEqfRheHlirHcLqYW60u1YSI3QDQAAgAhH6AYiTP3wcpPHj/F6eHmYzOkuKD4pa90XAAAAAEAkInQDEcaXhdQcw8srPBteXl/pDs0lIj0xRiajQdUWm46UVoakDQAAAIA/ELqBCFNlqa1WezW83Nt9uutCd4gyt6JMRmUkxUpiiDkAAAAiG6EbiDD2SrdX+3TH2vfpbnl4udVqU93o8pBVuiWpc0pd6GYFcwAAAEQwQjcQYXzZMsw+vPyEB8PLaxrMoQ7VnG6JFcwBAADQNhC6gQjjy5ZhDYeX22zuFyazNrg/VKuXS6xgDgAAgLaB0A1EmNYspGa1SRXVVrfHhk2luz2VbgAAAEQ+QjcQYSp9GF4eH22SoS4/n6h0P8TcYgmP0G2vdB9gTjcAAAAiGKEbiDC+VLoNBkP9Xt0V7lcwr7HWV8JNhtCF7q7M6QYAAEAbQOgGIowvc7olOUJ3SyuYW+rmdBsNkjEMKt0lFTUeLQAHAAAAhCNCNxBhfKl0S/Whu8Xh5XVzukM5tFyqnYeeEm+WxGJqAAAAiFyEbiDCOPbp9mJOt+T5Xt01lvAI3ZKUmVS7V/e/thxQ3t6jji8EAAAAgEhB6AYijH14eYzZt0p3qYeV7ihjaC8PK3YU6IdfyiRJr36Wr8mvbdCFT67Wih0FIW0XAAAA4A1CNxBhHMPLTSavHpcQXXv8+j1H3VaN7XO6Q1npXrGjQNMWbnGs1G5XWFyhaQu3ELwBAAAQMQjdQITxZU73ih0FWvvdL5Kkv28+4LZqHOo53RarTXOW7FJzXwnYb5uzZBdDzQEAABARCN1AhPE2dNurxiernedyu6oah3pO96b8YyoornB5v01SQXGFNuUfC16jAAAAAB8RuoEIU+nFlmG+VI3r53SHJnQfPuE6cPtyHAAAABBKhG4ggthstgZzult++/pSNQ71nO60xFi/HgcAAACEEqEbiCD2lcslzyrdvlSNLdba5whV6B6SlarM5Fi5enaDpMzkWA3JSg1mswAAAACfELqBCFLVYDXvGA9Cty9V41DP6TYZDZo1IVuSmgRv+8+zJmSHxT7iAAAAQEsI3UAEaRi6PRle7kvVONRzuiVpbL9Mzb9xsDKSnb80yEiO1fwbB2tsv8wQtQwAAADwDqEbiCD24eVRRoOMHoRiX6rG9XO6Q3t5GNsvU+seHKnnrx0kqfbfvPp/LiZwAwAAIKIQuoEI4sse3d5WjWsc+3S3srF+YDIa9OtBnZUSb1aN1abvD58IdZMAAAAAr4TBx2oAnvIldEv1VeNu7eMkSQ+NO1PrHhzZbNXYYgmPSredwWBQ/y7JkqSvDxSHuDUAAACAd8LjUzUAj1R6sV1YYyajQb3S2kmSUuLNLhciqwmDOd2NDeyaIkna9lNRSNsBAAAAeIvQDUQQ+5xubyvddpnJtZXun4tcbyVWU/ccReVVytt71LGwWigN6Fpb6d7+M5VuAAAARBZCNxBBfB1ebtclpXZed0HRyWbvX7GjQI+8v0OStPdImSa/tkEXPrlaK3YU+PR8/jKwW4ok6btDJ1ReVRPStgAAAADeIHQDEaSqFcPLpfpKd0Fx00r3ih0FmrZwi4pOVjvdXlhcoWkLt4Q0eKcnxSotMUZWm7TzYEnI2gEAAAB4i9ANRBB76I7xdXh5XaX7YLFzpdtitWnOkl1qbiC5/bY5S3aFdKj5gLp53V8zrxsAAAARhNANRJDWzunubK90F1XIZqsP0JvyjzVb/bazqbY6vin/mE/P6w8DmdcNAACACEToBiJIRZVFklR8stqnRc7se3WfrLaoqLx+GPnhE64Dd0OeHhcIA+rmdW9j2zAAAABEEEI3ECFW7CjQnKW7JEnfHSr1aZGzWLNJHRKiJTkPMU9LjPXo8Z4eFwj2vbrzfylTcaN55wAAAEC4InQDEcC+yFnjsOnLImedU+qHmNsNyUpVZnKsXO3MbZCUmRyrIVmp3jbdb1ITotUttbbt26l2AwAAIEKEdeiePXu2DAaD0//OPPNMx/0VFRW666671KFDB7Vr106TJk3SoUOHnM6xf/9+XXbZZYqPj1daWpruv/9+1dQ4bzm0Zs0aDR48WDExMerdu7cWLFjQpC3z5s1Tz549FRsbq6FDh2rTpk0B+TcDjfl7kbPMuiHmBQ0q3SajQbMmZDd7vD2Iz5qQLZPRVSwPDvtiatt+LgppOwAAAABPhXXolqSzzjpLBQUFjv+tW7fOcd99992nJUuW6O9//7vWrl2rgwcP6qqrrnLcb7FYdNlll6mqqkrr16/XW2+9pQULFmjmzJmOY/Lz83XZZZfpkksu0datW3Xvvffqt7/9rT7++GPHMe+9955mzJihWbNmacuWLRo4cKBycnJ0+PDh4LwIOKX5e5Eze6X7YKNzju2XqVm/bhq8M5JjNf/GwRrbL9PzRgeIfTG1bT9R6QYAAEBkiAp1A1oSFRWljIyMJrcXFxfrL3/5ixYvXqyRI0dKkt5880317dtXGzZs0LBhw7Ry5Urt2rVLn3zyidLT0zVo0CA99thjevDBBzV79mxFR0frlVdeUVZWlp5++mlJUt++fbVu3To9++yzysnJkSQ988wzuv3223XrrbdKkl555RUtW7ZMb7zxhn7/+98H6ZXAqcrfi5w5Kt1FJ5vc1zUlXpLUs0O87ht9utISa4eUh7rCbWevdH+x76g+2Ppz2LUPAAAAaCzsK93ff/+9OnfurNNOO0033HCD9u/fL0navHmzqqurNWrUKMexZ555prp37668vDxJUl5envr376/09HTHMTk5OSopKdHOnTsdxzQ8h/0Y+zmqqqq0efNmp2OMRqNGjRrlOAYIJH8vcpZpr3QXNQ3pe4+USpL6d03RFYO6aHivDmEVaO0V/6Nl1brn3a0+LSYHAAAABFNYV7qHDh2qBQsW6IwzzlBBQYHmzJmjiy66SDt27FBhYaGio6OVkpLi9Jj09HQVFhZKkgoLC50Ct/1++33ujikpKdHJkyd1/PhxWSyWZo/ZvXu32/ZXVlaqsrLS8XNJSYkkqbq6WtXV4bf6sr1N4di2U9nZXROVkRSjQyWVzc7rNkjKSI7R2V0TPfrdpSXUvu0PFpU3OX7P4ROSpKzUOL/2A3/0rY93HtKM975ucrt9MbkXrxuonLPSm3kkTiVcxxBM9Dd4g/6CYKGvBY+nr3FYh+5x48Y5/nvAgAEaOnSoevToob/97W+Ki4sLYcs888QTT2jOnDlNbl+5cqXi4+ND0CLP5ObmhroJaGR8hkFvlBilJuuL22STNC69XB+v+Mijcx2rlKQoFRSf1NJly9WwkP3ldyZJBhUf+E7Ll3/rl7Y35GvfstqkOVtMdV86OL8Gtrr/+8i/tqp6n0VhVJhHCHEdQzDR3+AN+guChb4WeOXl5R4dF9ahu7GUlBSdfvrp2rNnj0aPHq2qqioVFRU5VbsPHTrkmAOekZHRZJVx++rmDY9pvOL5oUOHlJSUpLi4OJlMJplMpmaPaW6ueUMPPfSQZsyY4fi5pKRE3bp105gxY5SUlOTdPz4IqqurlZubq9GjR8tsNoe6OWhgvCTTx9/ptXX7nG7PTI7VH8ad6VWFt8Zi1WNffSKLzaAhIy5VWmKM477ZX38qqVpXjrpAZ3X2Xx9tbd/amH9MRRu+dHOEQUVVUqfsYRoawm3NEHpcxxBM9Dd4g/6CYKGvBY99JHNLIip0l5aWau/evZoyZYrOOeccmc1mrVq1SpMmTZIkffvtt9q/f7+GDx8uSRo+fLj++Mc/6vDhw0pLS5NU+41PUlKSsrOzHccsX77c6Xlyc3Md54iOjtY555yjVatWaeLEiZIkq9WqVatWafr06W7bGxMTo5iYmCa3m83msH4DhHv7TlXJ8dGSpAt7d9TV53b1eRExs1lKT4pVQXGFjpTVqEtqO0nS8bIqHS+vHSJzemayzGb/Xx587VtHy2taPqjuOPouJK5jCC76G7xBf0Gw0NcCz9PXN6wXUvv//r//T2vXrtW+ffu0fv16XXnllTKZTJo8ebKSk5M1depUzZgxQ59++qk2b96sW2+9VcOHD9ewYcMkSWPGjFF2dramTJmir7/+Wh9//LEeeeQR3XXXXY4wfOedd+qHH37QAw88oN27d+vll1/W3/72N913332OdsyYMUOvvfaa3nrrLX3zzTeaNm2aysrKHKuZA8Hw3aHaRc4u6N2x1Yuc2VcwP9hgBfMffqk9f+fkWMVHh9f3cf5eTA4AAAAIlvD6ZN3IgQMHNHnyZB09elSdOnXShRdeqA0bNqhTp06SpGeffVZGo1GTJk1SZWWlcnJy9PLLLzsebzKZtHTpUk2bNk3Dhw9XQkKCbr75Zs2dO9dxTFZWlpYtW6b77rtPzz//vLp27arXX3/dsV2YJF177bU6cuSIZs6cqcLCQg0aNEgrVqxosrgaEEjfHapd5Oz09HatPldmSpy0v8gpdO89UiZJ6pXW+vP725CsVGUmx6qwuMLNYnK1lX8AAAAgnIR16H733Xfd3h8bG6t58+Zp3rx5Lo/p0aNHk+HjjV188cX66quv3B4zffr0FoeTA4FSbbHqh7pQfHp6YqvP19m+V3dx/bZh9u3CTuuY0Orz+5vJaNCsCdmatnCLDJJT8LbX+mdNyA6r7c0AAAAAKcyHlwOo9ePRMlVZrIqPNqlLSutX7s9Mrj1HQXGD4eVhXOmWpLH9MjX/xsHKSHYeQp6RHKv5Nw7W2H6ZIWoZAAAA4FpYV7oB1LLP5+6TniijH6q5neuC+8Gi5ird4Rm6pdrgPTo7Q3l7f9HUt75UZY1Vr9x4jgZ2Swl10wAAAIBmUekGIsC3hXXzuf1Uhe6cYh9eXlvprrZYtf9o7T6DvdLCb3h5QyajQRf26aQLeneUJH2x71iIWwQAAAC4RugGIsD3h2tD9xkZrZ/PLdUPLz98olJVNVbtP1auGqtN8dEmZSRFxgrgw06rXTRtww9HQ9wSAAAAwDVCNxAB7JXuPn5YRE2SOiREK9pklM0mHSqpcMznzuqYIIMhMhYjG3ZaB0nSxvxjslibW9McAAAACD1CNxDmKmss2lc39PsMP4Vuo9HgWJCsoLjCMZ+7V6fwnc/dWHZmkhJjonSiokbfFJSEujkAAABAswjdQJjL/6VMFqtNibFRSk+K8dt5M5Pr53X/YF9ErVN4z+duKMpk1HlZDDEHAABAeCN0A2HOsYhaeqJfh343XMF8r327sAiqdEvS8Loh5nl7Cd0AAAAIT4RuIMx9X7dd2Ol+GlpuZ1/B/GBRZFa6pfp53ZuY1w0AAIAwRegGwty3h+yVbv9Woe0rmO8qKNHx8mpJ4b1Hd3OyO9fN666s0a6DzOsGAABA+CF0A2Hu+7rQ7a9F1Ozsle6tPxVJkrqkxCku2uTX5wg0k9GgIczrBgAAQBgjdANh7GSVRT8eq1253F/bhdnZK932YdmRNrTczj7E/KPtBfpg68/K23uUoeYAAAAIG1GhbgAA1/YeKZXNJqUmRKtju2i/nrtzXei2i7RF1OxsttqAveWnIm15d6uk2pXZZ03I1th+mSFsGQAAAEClGwhr9pXL+6S18+vK5ZKUFBelOHP9JcBgUMRViFfsKNATH+1ucnthcYWmLdyiFTsKQtAqAAAAoB6hGwhj3x2um8+d4d+h5ZL08c5CVVnqQ/ab/9mnC59cHTFB1WK1ac6SXWruawL7bXOW7Iq4LxIAAADQthC6gTBlsdq06YdjkqQoo8Gv4XHFjgJNW7ilyTkjqUK8Kf+YCoorXN5vk1RQXKFN+ceC1ygAAACgEUI3EIZW7CjQhU+u1ld1K4u/4ccqdFupEB8+4Tpw+3IcAAAAEAiEbiDM2KvQjau4/qpCt5UKcVpirF+PAwAAAAKB0A2EkWBUodtKhXhIVqoyk2Plank5g2pXMbfv4w0AAACEAqEbCCPBqEK3lQqxyWjQrAnZktQkeNt/njUhWyajf1d9BwAAALxB6AbCSDCq0G2pQjy2X6bm3zhYGcnOXxBkJMdq/o2D2acbAAAAIUfoBsJIMKrQba1CPLZfptY9OFKLfjvUse/4S9cTuAEAABAeCN1AGAlWFbqtVYhNRoMu6N1RF/bpJEn6Yl94LwIHAACAU0dUqBsAoJ69Cj1t4ZYm9/m7Cj22X6ZGZ2doU/4xHT5RobTE2jAfKRXu5gw7rYNydx3Shh+O6s5f9Qp1cwAAAABCNxBuxvbL1P9O6q8H/7nd6faM5FjNmpDt1yq0yWjQ8F4d/Ha+UBt2Wu0IgC/yj6nGYlWUicE8AAAACC1CNxCGTuvUTpLUsV20Hr08u01UoYOhb0aSkuPMKj5ZrR0HSzSoW0qomwQAAIBTHGUgIAzt+6VMknRmRpKuGNRFw3t1IHB7wGg0OOa75+09GuLWAAAAAIRuICztP1YuSerRIT7ELYk8w0+rHS6/4QdCNwAAAEKP4eVAAFmsNp8WKtt3lNDtq2F1ofvLfcdUbbHKzLxuAAAAhBChGwiQFTsKNGfJLhUUVzhuy/RwMbQfj9YOL+/RISGgbWyLzsxIrJ/X/XOxzu7ePtRNAgAAwCmMEhAQACt2FGjawi1OgVuSCosrNG3hFq3YUeD28T/WVbp7Erq9ZjQaNLRuXveGH9ivGwAAAKFF6Ab8zGK1ac6SXbI1c5/9tjlLdslibe4Iqai8SsUnqyVJ3VMZXu4L+xDzj3YU6IOtPytv71GXrzcAAAAQSAwvB/xsU/6xJhXuhmySCoortCn/WLN7ZNvnc6cnxSgu2hSoZrZpVlttwN52oFj3vLtVkudD+wEAAAB/otIN+NnhE64DtyfHMZ+7dVbsKNAfl33T5HZPh/YDAAAA/kToBvwsLTG2VcfVz+dmaLm3Wju0HwAAAPA3QjfgZ0OyUpWZHCtXG4MZVDvUeUjdYl+N7aPS7TNvhvYDAAAAwUDoBvzMZDRo1oTsZqut9iA+a0K2y/26f2SPbp+1dmg/AAAA4G+EbiAAxvbL1F2X9Gpye0ZyrObfONjtYl5sF+a71g7tBwAAAPyN0A0ESEpctCTJVPcuy85M0roHR7oN3KWVNfqltFKS1J1Kt9daGtovSakJZhWWVLCNGAAAAIKC0A0EyPeHT0iSRvfNkCTtP1buNgxK9SuXpyZEKynWHMjmtUn2of2SXL7Wx8qqdd97WzX5tQ268MnVrGYOAACAgCJ0AwHy3aFSSdK4/hmKNRtVWlmjH34pdfuY/cznbrWx/TI1/8bBykhueQg524gBAAAg0AjdgBsWq015e4/qg60/ezUc2Wazac/h2oDdNzNJ/bskS5K+/qnY7eP22UN3KqG7Ncb2y9S6B0fqnduH6dlrBio1IbrZ49hGDAAAAIEWFeoGAOFqxY4CzVmyy2kLqszkWM2akO12XrYkFZZUqLSyRiajQT07JGhA1xR9se+4vj5QpEnndHX5uB/ZLsxvTEaDhvfqoLy9R3WsrMrlcQ23ERveq0PwGggAAIBTApVuoBkrdhRo2sItTfZ89nQ48vd1Q8t7dohXdJRRA7ulSJK+PuC+0u1YubwjlW5/YRsxAAAAhBKhG2jEYrVpzpJdze6z7elw5O/rhpafnp4oSRrYtXZ4+TcHS1RZY3H5OHulu3sqlW5/YRsxAAAAhBKhG2hkU/6xJhXuhhoOR3bl+0O1K5f3SWsnSeqeGq+UeLOqLFbtLjjR7GMqqi0qKKl93p4spOY3LW0jZlDttIEhWanBbBYAAABOEYRuoBF/DEe2V7p711W6DQaDBnZNkSRtO1DU7GMOHC+XzSYlxkS5XPgL3vNkG7FZE7JlMra0oRsAAADgPUI30EhrhyPbbLYmlW6pfoj5VhcrmO/7pXY+d/cO8TIYCID+5G4bsf++tE+LC+MBAAAAvmL1cqAR+3DkwuKKZud1GyRluBmOfOREpUoqamQ0SFkd6+dm2xdTc1Xp3lc3n7snK5cHxNh+mRqdnaFN+cd0+ESFlm8v0Mc7D2nDD78ob28HHT5RobTE2t8rVW8AQChYrDbH3yn+JgFtB6EbaMQ+HHnawi0uj3E3HNk+tLxHhwTFmk2O2wfUDS/fc6RUpZU1ahfj/Pbbf6xuj27mcweMfRsxSTqvZ6pydx3SxvzjmvzaBscxnm4L5w0+RAEAWtKarUoBhDeGlwPNGNsvU/8z5vQmtxsN0rzrB7v94/ddM0PLJalTYoy6pMTJZpO2N7N12L6jhO5g2nagSM0tQO/ptnCeWrGjQBc+uVqTX9uge97dqsmvbdCFT6722/kBAJGvtVuVAghvVLoBF34uqv3DN6JPR008u4v+8O/tOlltVXpyjNvH2SvdfdLbNblvQNdk/Vx0Ul8fKHJUXKXaSui3hSWSpNLKGlmsNiqhAWTfFq459hz+cN3vOyPJu8p0w6r2vl/K9dwn3zWZplBYXKE7F27RfaP6qGfHBKrfYYoRCgCCoaWtSg2q3ap0dHYG1yAgQhG6gWZUVFu0bNtBSdJ//aqXLujdUWu+PaIPvz6olbsO6ZwerreX2nOoLnSnJTa5b2C3FH20o1CrvzmkzORYpSXG6nhZleYu3aVDJZWSpMeWfqPXP89nOFkAtbQtnCQdK6vWfe9tleR6eF/jUHa8rEqPLdvV4rntH6ye/eR7x20MIQwvDPMEECzebFXa8At7AJGD0A0049Pdh1VSUaPM5FgNO632D9zo7HR9+PVB5e46pIfG9W32cTabTd8drh1e3jutaaW7stoqSdq077g27Tvu8vntw8nm3+h+KDt84+m2cHbN/T6aC2Wt4c3vnApsYNmHeTY3QoH3JQB/88dWpQDCG6EbaMa/vvpZknTFoC6OMHPxGZ1kNhn0w5Ey7T1Sql6dmobqo2VVKiqvlsGgJvev2FGg5z75zqPnZzhZYHm6LZxd4yHn+482P2y8NTz9nVOBDSyGeQIIttZuVYrA4Utu+AuhG21Kay6O9sfm/1Kq1bsPSZKuGtzFcX9irFnDTuugz7//Rbm7DqnXr5qGbvsiat3axysuun7lcncf5F1hOFngtLQtnCsNh5wHQku/81O1AhuMDz325/jPniMM8wQQVK3dqjRQTvXAyZfc8CdCN7wSzhfg1lwcm3tslNGgH46U6vT0+rnZY7LTHaH7zl/1anKePXWLqJ3eaBE1T+YQu8JwMv9ruC2cQfJrxdofPqpbpbbh+yvSK7C+XjuC8aHHl6kCgXxfBvNLhnC8lgOnGvvfpDt93Ko0EE71wHmqfsmNwCF0w2PhfAFuzcXR1WNrrLYmjx2Vna5HP9ipzT8e18INP6pXp3ZOH1a/r1tErXejRdRa8wGd4WSBMbZfpubfONiv87L95a95P+qveT86vb8ieaEdV9eORy/rq/YJMS6DXzA+9Lh6jpYE6n0Zqi8ZwuVajvDFFzWBNbZfpi4fkKml25y3BjNIevqagUF9b57qgTOQX3JH6vsoUtsdTgjd8EigLsD+eBO3dHGUXG//5Mmw74YX1q9/KpLZaFC11aZH3t8hqf7D6ujsDH354zFJtRfkhtt++fIBPVTDyU4lY/tlanR2hjblH1Nh8Uk9tuwbHS+rCpvKd8OtxY6WVXn0mOaq5C1p7n0oyS9/YF1dOwqKK/S7xV853dYw+AWjsu/LtA97OwPxvgzllwynyofptiAUH375oiY47KPl7hxxmvpmJumpj3fr56IKlVbWBK0NkT6qyh8C9SV3pL6PIrXd4YbQjRYF6gLsrzdxa7Z/8ubCWnyyyuWH1TsXblFKvFlF5dWSpPlr9+r9rT87nsfbOcT2VzHYw8lORSajwfFHMy7a5Pch5/Zz2ffktu/dLQ+eo7mtxVrSXJXcnebehynxZkly9GfJs8q0nT0U2L/I8PS1bPglQ7XFGrDKvqfzt1257rxuWrrtoF8DTzAqK+5+H23tw3RbrcqE4sMvX9QER/4vZdpdeEJRRoPuvLiXUuKjdby8SrOX7NKiDfs1ZVgPGQz+6cPuvmj1dF2LZ3O/0wW9O/r1S9pw4enoxIZfckvuX4NIfR952+62eu31B0I3XPJ2YaGGF2B3H8QPn6hwBA9XAdYeUNxV3ey32S96nmp4oaissXr4mJN66uNv3VbTGwaUxs8ztl+mV3OIM/gGMSQCMeS8ud/lGRntAj6s3ZM/iK7eh437stRyZdquNVup+fIlg7eVfX9s9RaI/dWDWVlp6Tl8+TAdrA9anozKOF5WpceWeT+dIdyF4kM7Vc/gsV/LhvfqoJT4aEnSlYO76n9X7Na3h07orfX71D4h2qPPRe76uKdftLbkpU/36KVP97j8kjacPsN4O5rL09GJ9i+5W/qiuqUvPCXXIzJ9+be19hrt6xe1vk4lO1UYbDZbuIykbPNKSkqUnJys4uJiJSUlhbo5TVRXV2v58uUaP368Vn37i88fTJt7gzX3IchTzV3MfPkD0VhqglmTh3TXvE/3tnjso5f11WPLvvH6OexDxNc9OPKUviA17FtmsznUzWlR4z84ng4596Ua/NGOAv0170f//yPqpCaY9ejlZykjqXXvw+a4quKH4o+K/UPepWd0dNnXfJ2/Pf2S3jKbjHq2mS3/7L/Z1k6x8bQf3DS8h8bVjZ6R3H/obu3vw9MRD65CbnMfun354OfueVrzt6C1wcBitSlvz2Gt/Hyjxlw0VMN7pwVswTv7teiYi2kmjf/WtHQ+T//W5O09qsmvbWixne/cPszxZRCVLtfc/S389UvrtO1Asf54ZT/dMLSH4/brX9ug9XuPOh3r6eeixn3c12ugt1xdF8NlakRLr5XFatMFT65WYYjWe/H0+unu2tvwb2Fzn+kbTo1s6Zwtsf+N9PTvjavPSlJkjpjwNN8RuoMoUkK3qcc5uvvdr8NmXmso2T/IPDD2zFZtFXWqfyCJtNDdkP1DiuQ8QqFx4PT1d+nph1q4Z3/VX7xuoCw/bnb0NU9Di6tzZiTHau39l+hX//ep2w8hDb/c8LQKFY5fRvpLc+8PbyrQubsKAz4apDVfmHjzBark2wdJX0ZluPtb48uXI55+GfT8dYN0xaAuYffFsqcVzuZuC0T7XP0tPHC8XBc++amMBmnjw6PUKTFGUm0fcLeieUsavg+7p8Z7fQ1sDU+LDp5+8eXL2iPefMnQ+JqVu+tQk0XtgsXT66e7x/73Jb1UdOA7te92ul5YvbfJa2A/ruHUyFBq7bS2UCJ0h6FwDt32b+xXfLZRyw/G6lgYvAFDreEHsuS46FYFI/sHklNVJIduKbDzKC1Wmy6s+0bd24vxRX066vPvf2nV87c1qQlmXZZZoZwRQ1VSYfU51Lbm/R/ugTjcBftDoLdfmHgzgsDXD5K+ViTtIyG8/YDuy4f7hgJZ6fL1Nk9HRnjzO/K0La5GNzUeGWF/7Htf7Nf7Ww9qSM/2+tud5zuOv/DJ1WG3u4a33PUNV19eS779Lpsb0t3aLxlio4yq8HAqIgIv3KYuSITusBSuodsfcxzbosZDjXwNRpJz9eFUFOmhWwrsCAVX1fSW+DrtAS1r+P7/YOvPuufdraFuEoIgVF+YBCIsRBpPX/tQ/Y5aE9g9DY1JsVF66jcDNLZf5ik7Ciocv6C07yASyKlg8Exrp3QFAqE7DIVj6A7W/J5gu3FYdy3fXujT9k/TL+nd7IJwvgQjT+fZtXVtIXQHmjdffjUe9uzrl0GRZkx2ulbuOhTQ52ju/X+qfvgFEHwGybHQa7h82TdxUGe9v/VgqJsREva/t3++eqBueH1jqJsDhd9na0/znTGIbWoT5s2bp549eyo2NlZDhw7Vpk2bQt0kn/m6R61UewEOZ5f176w/XdlPUv23Yp7qk95Ow3t1aPJGtq9snZHsvKql/VvZxs/Dtl/wxth+mVr34Ei9c/swPX/dIN036nQZ5L5fRUcZNWtCttPt4Sw1waxnrx2kd24fppevH6zMRu8lVwyqrR7dfH7PgLXN/hz3jT69yfvfvuVfsF/ji/p0DOj5UxPMuuuSXgF9DgDem7Nklzq2iwl1MxzXxad+MzAk18BwYN/VQTadsq9BuGm4m0ckIXR74b333tOMGTM0a9YsbdmyRQMHDlROTo4OHz4c6qb5xJP9rRsL9wuwvX1DslJdhuSWuNsqonEweuf2Ydr8yGi90szzZCTHhtXwF4Q/+57hVwzqontG9Wm2/zbuV772c3dS4s2OL5P8wf7lwZ+u7K8rz+6i4b06aPwA779kGHZah4Bcd1r6gsxkNITky42LT+8UkPM2/H3MGH1GWF7LEb7GZKeHugltWriEvEj+gjcQfimr9NtrkJpg1tNXD1RqQnREvZ7h9kWtp/uphwuGl3th6NChOu+88/TSSy9JkqxWq7p166a7775bv//971t8fLgNL/d2nmLjeRS+zkNteL7mthtqzfkats/O0+2fWjtc5VRcldxTDC/3nbd7cHq7zVlrFrLxlKcLn3iyYF1rrzv+bl8gBHr6QDBeUwRWaoJZl/XvrLc3BH+O6fRLeuulT/cE/XlPNc9fN0gxUcagvDc93WvbX3t8RyL72jyteQ38/Tk6WBq2e3R2RqvWOPKncFkviTndflZVVaX4+Hj94x//0MSJEx2333zzzSoqKtIHH3zQ4jnCLXR7O0/R0wuwv8/n636UzXG3/ZMUXgsztCWE7uDy5g+5r1u2uPqSrLVbqXnyJYM/wm/jFau9bZ+3X254KtBfbnrzmkbCh+nWLGQVify5q4Yvz83c1uDxNuR5+371ZNV+d1/wNreC+3/2HNFLn+717R8cRN68Vs0VZDzZvszTLfpCtZixfZcI+98Idzz9otZfuyG0JFLndBO6PXTw4EF16dJF69ev1/Dhwx23P/DAA1q7dq02bmz6B6iyslKVlZWOn0tKStStWzf98ssvYRG6LVabLn76Mx0qqXT5hktNMOvhcWcoIylW5/Zo7/IC/OWPx3X4RKXSEmN0rKxKf/roWxWW1P/bM5Nj9FDOGUptF+04ztPzndujvSR5dJsnb76Pdx7S48t3N2nfH8adqZyzGDYXCNXV1crNzdXo0aMJ3UHiqp97+j5szXME471kv04UllToT8u/1fHyao8r+1Ltft6tbePHOw/p7ne/luTPqnvT16+51zklPkqyGVR0strtbd78Pjy59npyff/xaLleWF37wbs1XxSkxJmb/Fua67+N29jS3xZv+0w4afj79ORvuL80fN+M6psWtOc9FdUGihh9OmOEU8jz9nORq/ehP6+BjQWzT3qr8edZKfCvVXO/t5Y+93pz/fT02ttw7+6eHeMdbfnkm8M+f07w5u+/Jzmhub9fzQlk//VVSUmJOnbsSOj2F19C9+zZszVnzpwmty9evFjx8fEBba+nvj5q0Bvf2af2N3xD1XaL2063amAH77uI1SbtLTGopFpKMku9kmwKgy+jHMK9fYA/BKOfh8N7qaXrWMPbUqJtuqqnb9c1V8/9r31GFVXVP0d8VO25y2vc35YSbdPEHla1M6vF16+511ny7LZQ/M6be12a+/eW1Uj/bua4q3pa1T/VFrB/izd9xt1t47pa1SnO9b+lud+76/M194+zKSFKuqqnVcnRTV8Db/t+w9f/yEnpowO+vW9aet6WXhdvX2d/3ebpe7P1z9v879LT8/n62asxV+9Df14Dm3tOT/qGN/3P099la17TULxW3rbFk78X3v47WvM33N+PlZxvc/f3Idi/E3fKy8t1/fXXE7r9xZfh5eFe6baj8otAo9KNQAtGZd+VQI/OiVS+VHmC+br4YwTByNNTna5tvo4WaI6nFZ3W9P1APNafla7W3ObNyIjGt7WmfZ5q7cgUT4Xi/eVp3/D0Pejp79LVSJzWjPYJ1TW6NW2xWG3asPeIVudt1sjh52hYr04R+7cmnH4nrlDpDoChQ4dqyJAhevHFFyXVLqTWvXt3TZ8+PSIXUmvIYrUpb89hrfx8o8ZcNFTDe6eFXadG5GJON4KB6xi85cncTHfzXX29tjV+Xk/nf3rz7/DnOgrBeqzk2Wvv6W2tef/72j5Xv8tHL+urpFiT0/XJ320OJ94uAuqv3yWL2tbic1fweJrvooLYpog3Y8YM3XzzzTr33HM1ZMgQPffccyorK9Ott94a6qa1mslo0NCsVB39xqahp+gFCkBk4zoGb9m36WvM09v8+bw5/TJ8Dguu/h2R+Fh/3+ar1rTP1e+yurq6yfUpHFZfDgRP+4Y3r7M/nxcINkK3F6699lodOXJEM2fOVGFhoQYNGqQVK1YoPZ0h2AAAwHeEhbaD3yWAxgjdXpo+fbqmT58e6mYAAAAAACKAseVDAAAAAACALwjdAAAAAAAECKEbAAAAAIAAIXQDAAAAABAghG4AAAAAAAKE0A0AAAAAQIAQugEAAAAACBBCNwAAAAAAAULoBgAAAAAgQAjdAAAAAAAECKEbAAAAAIAAIXQDAAAAABAgUaFuwKnEZrNJkkpKSkLckuZVV1ervLxcJSUlMpvNoW4O2hD6FoKFvoZgor/BG/QXBAt9LXjsuc6e81whdAfRiRMnJEndunULcUsAAAAAAP5w4sQJJScnu7zfYGsplsNvrFarDh48qMTERBkMhlA3p4mSkhJ169ZNP/30k5KSkkLdHLQh9C0EC30NwUR/gzfoLwgW+lrw2Gw2nThxQp07d5bR6HrmNpXuIDIajeratWuom9GipKQk3qAICPoWgoW+hmCiv8Eb9BcEC30tONxVuO1YSA0AAAAAgAAhdAMAAAAAECCEbjjExMRo1qxZiomJCXVT0MbQtxAs9DUEE/0N3qC/IFjoa+GHhdQAAAAAAAgQKt0AAAAAAAQIoRsAAAAAgAAhdAMAAAAAECCEbgAAAAAAAoTQDQAAAABAgBC64TcshA8g0lmt1lA3AQCAkKmsrAx1E9oktgxDqx07dkypqamSaoO3wWAIcYvQFvz0009avXq1jh8/rgEDBmjkyJGhbhLasOLiYiUnJ0uqDd5GI99JIzAOHjyoL774QhUVFerTp48GDx4c6iYhzOXn5+v999/XkSNHNHz4cE2YMCHUTUIbtWvXLt1+++168skndeGFF4a6OW0KnyrQKrt27VJ6erruvfdeSZLBYKDijVbbvn27LrroIr366qt69dVXNXbsWC1evDjUzUIbtWvXLvXo0UN/+tOfJElGo5GKNwJi+/btGjFihB5//HE98MADuvLKK7Vs2bJQNwthbNu2bRoxYoSWLl2qtWvX6oorrtCHH34Y6mahjfrzn/+svLw83XLLLcrLywt1c9oUQjd8dvDgQd16660aMGCAXn/9dd13332SCN5onfz8fE2YMEHXXXedVq1apbVr1+qhhx7S008/rUOHDtG34FcHDhzQjTfeqPT0dD399NP63//9X0kEb/jf3r17NW7cOP3mN79Rbm6uli5dqvHjx+vNN99UWVkZ1zY08d133+myyy7TlClT9NFHH2np0qUaN26cDhw4EOqmoY266KKL9MADD+jiiy/WhAkT9Pnnn4e6SW1GVKgbgMhks9n06aefqkePHrr33nv1448/6tZbb5XBYNAzzzzjCN4MNYc3ampq9MYbb+jss8/WrFmzFBsbq9jYWJ1//vl67bXXJIk+Bb+xWq365z//qaysLE2fPl2bNm1yVLt///vfO4I3Q83RWlVVVZo3b57OP/98PfbYYzKbzUpJSdF5552nRx99VFarlWsbnFRVVWnOnDm69NJL9dhjj8lkMik6OlpxcXHasGGDNm/erLPPPls33HCD2rdvH+rmoo2Ij4/X559/rk8++USHDh3Sb37zG61Zs0aLFy9Wv379dO2114a6iRGL0A2fGAwGjRgxQomJiTr//PN1/vnny2az6bbbbpPNZtOzzz5L8IbXoqKiNGDAAMXFxSkuLs5x+9ChQxUVFaVffvlF6enpIWwh2hKj0ajx48crLS1Nl1xyiQYNGiSbzaYnnnhCEsEb/mM0GtW7d29lZWXJbDY7/jaOHDlSc+fOVXFxsRITE0PdTISR6OhoPfzwwzp48KBMJpMk6U9/+pP+/e9/a/LkyYqNjdV///d/69tvv9WLL74Y4tairRg8eLDjy50lS5bouuuu09lnn6127dox3LyVCN3wWbdu3dStWzfHz9dee60MBoNTxdtisei9997TwIED1a9fvxC2FpFiwoQJio2NlVS/MF9UVO2lqrq62nHcF198ofPOOy8kbUTb0adPH/Xu3VuS1L59e/32t7+VwWBwqnjbbDYtWbJEw4cPV8eOHUPZXESoqKgoXXnllcrMzHS6PTo6WpJksVgc17vdu3frzDPPDEUzEWbOOussnXXWWZJq1wP49NNPtXTpUo0dO9bxpc11112n6dOn64wzzghxa9EW9OnTR8ePH9d3332n008/XSaTSVFRUbJarSouLg518yIaoRseq66ultlsdnm/yWTS1VdfLUm69dZbJdV+kJg/f7727NkTlDYi8jTuV/bALdWOqKipqVFpaalqamoUHx8vSXrooYf05JNP6vDhw4QgeOXgwYP6+eefdfToUY0aNUpGo1FGo1E1NTWKiopSx44dddttt0mqrSrZbDYdPXpUzz//vPbv3x/i1iOS2PvaL7/8opycHMcoHXtfs1qtKikpUXl5uaKjo2UwGBzXtuPHjyspKYmRYqcYV9cnSerfv7/++te/On1xYzQalZ2dzd9BeK1hXxs9erQMBoOMRqNOnjyp9u3b68SJE/rv//5vrVmzRqtXr9bTTz+tYcOGaf369RoyZEiomx+RCN3wyM6dO/Xwww/riSeeUHZ2tsvjoqKidM0118hiseimm25SSkqK1q9fr+7duwextYgUnvQrk8kks9ksg8GgmJgYzZ07Vy+99JI2btzIBw14Zdu2bbr88suVmJio7777Tv3799cdd9yhG2+8Ue3atZPFYpHJZFKnTp00depU2Ww2Pfzww0pJSVFeXl6TKiXgSnN97fbbb9eUKVPUrl07x5SF6OhoRUVFKS4uTnPmzNG8efO0YcMGx/Z1OHW0dH2SpIyMDKfH5OXlqWvXro4RE4AnXPW166+/XklJSTrnnHN00UUXqX379lqyZIkGDx6st99+W9HR0UpJSQl18yOXDWhBfn6+7bTTTrMZDAbboEGDbN9++63b4y0Wi23q1Km2pKQk265du4LUSkQab/pVeXm5rV+/frYxY8bYoqOjbV9++WUQW4q24MiRI7a+ffvaHnzwQVt+fr7t8OHDtsmTJ9uGDh1qu/fee20lJSU2m632+mU3ZcoUW1JSkm3nzp2hajYikKd9zWaz2Q4dOmQbMGCA7eqrr+badgrzps/YbDbbwYMHbY888ogtJSXFtn379hC1GpHIXV+75557bOXl5bYPPvjAdtlll9m++uqrUDe3TWFlGLhVWVmpt956SwMHDtSmTZsUHR2tiRMn6rvvvnP5mI8//lirV6/WqlWr1Ldv3yC2FpHCm35ls9l05MgR7dy5U2vXrtUXX3yhc845JwStRiQrLCzUyZMndf3116tnz57q1KmTFixYoJycHK1fv15PPvmkKioqZDQaZbPZtHDhQq1cuVKffvqp29E9QGOe9jVJOnLkiLZv366lS5dq06ZNXNtOUd70mc2bN+uBBx7QokWL9Omnn7JeDrzirq/95z//0f/93//p17/+td59910NGjQo1M1tUwjdcMtsNqt///66/vrrde655+rjjz9WYmKi2+A9cOBArV+/Xueee26QW4tI4U2/MhgM6t69u5566ilt2bJFAwYMCFGrEcnsc2bt87JramoUHR2tRx99VL/61a+0bNkyffHFF5Jq+9wFF1ygjRs3avDgwaFsNiKQN32tS5cu+p//+R9t3rxZAwcODGWzEULe9JmMjAxdc801WrVqFaEIXnPX1y655BL985//1Lp169SuXTvZbLYQt7ZtMdh4RdEC+zxHu6NHj2r8+PE6ceKEPvjgA/Xp00c1NTXatGmTBg8e7LQQFuCKN/3qvPPOU1RUFIsKwWeVlZW68MILlZGRoffff18mk8mxoJXNZtPAgQN19tln66233mKrQ7SKN33NfnxMTEyIW41Q8qTPDBo0SH/9619D3VREOG+vT/AfKt1okT0Y2b+f6dChg5YtW6bExERdccUV2rlzp+6++27dd999KisrC2VTEUE87Vf33HOPTpw4QQiCz6xWq2JiYvTmm2/qs88+07Rp0yTJ8SHDYDDo17/+tQ4fPixJ9DX4zJu+Zr/2EbhPbZ72mSNHjoS4pYh03v4thH8RutEi+wcD+wdRm82mjh07avny5UpJSdGAAQP01ltvad68eerQoUMom4oI4mm/mj9/vlJTU0PZVEQ4o9Eoi8Wifv366a233tI777yjm266SYcOHXIck5+fr/bt28tisYSwpYh03vQ1q9UawpYiXHB9QrDQ10KL4eVwyz4EuKSkRFartclWAbfddps+/PBDffbZZyw2BI/RrxBIjYeH24fOlZaWqrKyUlu3btX111+vHj16KDU1VR06dNAHH3ygvLw89e/fP4QtR6Shr8Fb9BkEC30tvFDphks1NTUymUzat2+f+vbtq7y8PMd9NptNL774ohYsWKDc3FyCETxGv0Kg2L+Zt3+XbLPZHB8y9u3bp9NPP11ffPGFLr30Uu3cuVPjx49Xly5dlJaWpk2bNvEhAx6jr8Fb9BkEC30tPFHphvLz8/Xxxx/ru+++07hx43T22WerY8eOkqSffvpJgwcP1sSJE/Xqq686DQVeu3atunbtqt69e4ey+QhT9CsE03fffaf58+dr//79GjhwoKZMmaKsrCxJ9f3tiiuu0GuvvSar1SqTyeSoAlitVhmNfAcNz9DX4C36DIKFvha+eGVPcdu3b9eFF16oDz/8UEuXLtXdd9+tN954QxaLRdXV1frwww81ZcoUp2Ak1c7DvfjiiwlGaBb9CsG0fft2nX/++Tp+/LisVqs++ugjvfPOO7LZbKqurtYHH3ygG2+8Ua+99poMBoPTqvkSC6fBc/Q1eIs+g2Chr4U3Kt2nsB9//FGjR4/W1VdfrdmzZ8tsNuuhhx7SP/7xD23fvl2xsbEqLi5WcnJyqJuKCEK/QjD98MMPGjlypG688UY9/vjjkqTf/va3SkhI0PPPP+84rvEWdYC36GvwFn0GwUJfC39Uuk9RFotFH3zwgc4++2zdfffdjuEk9957r6qqqvTdd99JEsEIXqFfIZgsFotyc3N16aWX6n/+538c89fi4uK0Y8cO/epXv9JNN92k9evXO4bQAb6gr8Fb9BkEC30tMhC6T1Emk0nJycm64IILlJGR4fjWy2AwqKSkRMeOHWvyGN6kaAn9CsFkMpk0ZswYzZgxQ+3bt5fBYNDcuXP1+uuva9SoUbr44otVVVWlKVOmKD8/n6Fz8Bl9Dd6izyBY6GuRISrUDUDo3HzzzY7/ti+ikJSUpIyMDMXHxzvu+/DDD3X22WerW7duoWgmIgz9CsGUlZXl+OKmsrJSGzdu1D/+8Q9ddtllkqR169Zp0qRJ2rNnj2MxGcAX9DV4iz6DYKGvhT9C9ynk4MGD2rJli6qqqtS9e3ede+65kpzndxiNRhmNRse3YA8//LDefPNNbdy4MWTtRnijXyGYGva3Hj166JxzzpHBYJDFYlFMTIyWLFkio9HoWIU1NTVV6enpSk1NDXXTEWHoa/AWfQbBQl+LPITuU8T27ds1ceJEdezYUT/88IN69uypBx98UL/5zW+cFlQoLy/XkSNHVF1drccff1zPPvusPv/8c3Xv3j2ErUe4ol8hmDzpb/YvduzrCbz99tuKjY1Vjx49QtZuRB76GrxFn0Gw0NciE3O6TwF79+7V+PHj9Zvf/EYrV67UihUrdNZZZ+mjjz6SxWJxmlMbFRWlrl276g9/+IP++Mc/at26dY7KJdAQ/QrB5Gl/s3/Q2L9/vx544AH9v//3//T666879ogHWkJfg7foMwgW+loEs6FNq6ystM2YMcN2zTXX2CorKx23/+Uvf7F16NDB9ssvvzgdX1RUZOvRo4ctNTXVtnXr1mA3FxGCfoVg8ra/ffHFF7bf/e53toEDB9Lf4BX6GrxFn0Gw0NciG8PL2zir1aquXbuqb9++io6Odixsdf7556tdu3aqrq52Oj45OVm33367Jk2apDPPPDNErUa4o18hmLztb+eee65O/v/t3X9oTfEfx/HXvbMf3JEfiVk08mOTmc1QatPkx8qsJZoftcg/LIWIQuOPMRZi/kDkRxFJ4g9thVF+xkaNjUJJaXYxsx9sdu/O9w+5tUzf7/nmfK57PR9/np3dPqf7PH+8z73n3G/ftG3bNsXFxQVp1QhFtAa7aAam0FpoY+gOczExMcrLy/vlSYX9+/dXZGRktxO0qqpK6enp2rp1q+llIsTQFUyy01t1dbUmT56sjIwM08tEGKA12EUzMIXWQhv3dIeh+vp6PXz4UBUVFerq6gqcnH6/P3CPx5cvX/T58+fA/xQVFWnOnDn69OkTv5uMHtEVTPp/e5s9eza9wRZag100A1NoLXzwSXeYqampUW5urqKjo9XQ0KC4uDgVFRVp7ty5GjhwYOCrKC6XS263W7GxsSouLtbevXt1+/ZtDRo0KNiHgL8QXcEkeoMptAa7aAam0FqYMX0TOZzj9XqtxMREa8uWLdbr16+td+/eWfn5+VZSUpK1fft2y+v1BvZtaGiwUlNTrfz8fCsqKsqqqqoK4srxN6MrmERvMIXWYBfNwBRaCz8M3WGktrbWSkhI+OVk27x5s5WcnGyVlpZabW1tlmVZVl1dneVyuazevXtbT548CcJqESroCibRG0yhNdhFMzCF1sIP93SHkc7OTvl8Pn39+lWS9O3bN0nS7t27lZWVpcOHD+vVq1eSpAEDBqiwsFCPHz/WpEmTgrVkhAC6gkn0BlNoDXbRDEyhtfDjsizusA8nU6dOVWxsrCorKyVJHR0dio6OliRNmTJFo0eP1rlz5yRJ7e3tiomJCdpaETroCibRG0yhNdhFMzCF1sILn3SHsLa2NrW0tKi5uTmw7ejRo6qtrdXSpUslSdHR0fL5fJKkzMxMtbW1Bfbl5ERP6Aom0RtMoTXYRTMwhdbCH0N3iKqrq9OCBQs0Y8YMJSUl6ezZs5KkpKQkHTx4UNeuXdOiRYvU2dkpt/vH2+z1euXxeOTz+fgJAfSIrmASvcEUWoNdNANTaO3fwE+GhaC6ujplZmaqoKBA6enpqq6u1ooVKzR+/HilpqYqNzdXHo9HhYWFmjhxohITExUVFaWrV6/qwYMH6tWLtx2/oiuYRG8whdZgF83AFFr7d3BPd4hpbGzUkiVLlJiYqIMHDwa2Z2VlKTk5WWVlZYFtLS0tKi4uVmNjo2JiYrR69WqNHz8+GMvGX46uYBK9wRRag100A1No7d/C5ZEQ09nZqaamJi1cuFCS1NXVJbfbrZEjR6qxsVGSZP34KTj17dtXe/bs6bYf0BO6gkn0BlNoDXbRDEyhtX8L71iIGTJkiM6cOaOMjAxJkt/vlyTFx8cHTkCXyyW3293tYQwul8v8YhEy6Aom0RtMoTXYRTMwhdb+LQzdIWjMmDGSflzpioyMlPTjSpjX6w3sU1JSouPHjweecsgJiv+GrmASvcEUWoNdNANTaO3fwdfLQ5jb7ZZlWYGT7+dVsaKiIhUXF+vJkyc8YAG20RVMojeYQmuwi2ZgCq2FPz7pDnE/n4PXq1cvDR8+XHv37lVpaamqqqqUkpIS5NUhVNEVTKI3mEJrsItmYAqthTcumYS4n1fCIiMjdezYMfXr10937txRWlpakFeGUEZXMIneYAqtwS6agSm0Ft74pDtMzJ07V5J07949paenB3k1CBd0BZPoDabQGuyiGZhCa+GJ3+kOI21tbfJ4PMFeBsIMXcEkeoMptAa7aAam0Fr4YegGAAAAAMAhfL0cAAAAAACHMHQDAAAAAOAQhm4AAAAAABzC0A0AAAAAgEMYugEAAAAAcAhDNwAAAAAADmHoBgAAAADAIQzdAACgR8uXL5fL5ZLL5VJkZKSGDBmi2bNn68SJE+rq6vqfX+fUqVPq37+/cwsFAOAvxtANAAB+Kzs7W/X19Xrz5o3Ky8uVlZWltWvXKicnRz6fL9jLAwDgr8fQDQAAfis6OlpDhw5VfHy80tLStGXLFl25ckXl5eU6deqUJGn//v1KTk6Wx+PR8OHDVVhYqNbWVknSrVu3tGLFCn358iXwqfmOHTskSR0dHdq4caPi4+Pl8Xg0bdo03bp1KzgHCgCAQxi6AQCALTNnzlRKSoouXbokSXK73SorK1Ntba1Onz6tyspKbdq0SZI0ffp0HThwQP369VN9fb3q6+u1ceNGSdKaNWt0//59nT9/XjU1NVq0aJGys7P18uXLoB0bAAB/msuyLCvYiwAAAH+f5cuXq6mpSZcvX/7lb4sXL1ZNTY3q6up++dvFixe1atUqffz4UdKPe7rXrVunpqamwD5v377VqFGj9PbtWw0bNiywfdasWZo6dap27dr1x48HAIBg6BXsBQAAgNBjWZZcLpck6fr16yopKdGLFy/U3Nwsn8+n9vZ2ff36VX369Onx/58+fSq/36+xY8d2297R0aFBgwY5vn4AAExh6AYAALY9f/5cI0eO1Js3b5STk6PVq1dr586dGjhwoO7cuaOVK1fq+/fvvx26W1tbFRERoerqakVERHT7W2xsrIlDAADACIZuAABgS2VlpZ4+far169erurpaXV1d2rdvn9zuH4+KuXDhQrf9o6Ki5Pf7u21LTU2V3++X1+tVRkaGsbUDAGAaQzcAAPitjo4OvX//Xn6/Xw0NDaqoqFBJSYlycnJUUFCgZ8+eqbOzU4cOHdL8+fN19+5dHTlypNtrJCQkqLW1VTdu3FBKSor69OmjsWPHatmyZSooKNC+ffuUmpqqDx8+6MaNG5o4caLmzZsXpCMGAODP4unlAADgtyoqKhQXF6eEhARlZ2fr5s2bKisr05UrVxQREaGUlBTt379fe/bs0YQJE3T27FmVlJR0e43p06dr1apVys/P1+DBg1VaWipJOnnypAoKCrRhwwaNGzdOeXl5evTokUaMGBGMQwUAwBE8vRwAAAAAAIfwSTcAAAAAAA5h6AYAAAAAwCEM3QAAAAAAOIShGwAAAAAAhzB0AwAAAADgEIZuAAAAAAAcwtANAAAAAIBDGLoBAAAAAHAIQzcAAAAAAA5h6AYAAAAAwCEM3QAAAAAAOIShGwAAAAAAh/wHFP7B5w3O5hYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df['timestamp'] = pd.to_datetime(df['created_at']).dt.tz_localize(None)\n",
    "\n",
    "df['date'] = df['timestamp'].dt.date\n",
    "daily_counts = df['date'].value_counts().sort_index()\n",
    "\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(daily_counts.index, daily_counts.values, marker='o', linestyle='-', label='Daily Counts')\n",
    "plt.title('Daily Activity')\n",
    "plt.xlabel('Date')\n",
    "plt.ylabel('Count')\n",
    "plt.xticks(rotation=45)\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}