{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import logging\n",
    "import mlflow\n",
    "import pandas as pd\n",
    "import time\n",
    "# Those should be i nsome other module, but :shrug:\n",
    "from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.decomposition import PCA\n",
    "logging.getLogger().setLevel(logging.INFO)\n",
    "%run ./scikit_knn.ipynb\n",
    "%run ./scikit_dbscan.ipynb\n",
    "%run ./scikit_medoids.ipynb\n",
    "%run ./utils.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_clusters(client_id, df, cols, collection_id, modelling_config):\n",
    "    \n",
    "    feature_vector = df\n",
    "    \n",
    "    original_feature_vector = feature_vector.copy() # This is from legacy, could probably save memory from here\n",
    "    original_cols = cols\n",
    "\n",
    "    \"\"\" Do PCA dimensionality reduction \"\"\"\n",
    "    pca_components =  modelling_config.get('pca_components', False)\n",
    "\n",
    "    modelling_type = modelling_config.get('modelling_type')\n",
    "    logging.info(f\"{modelling_type} with PCA {pca_components} components\")\n",
    "\n",
    "    # TODO! add PCA 4 and extra dimension as \"size\" in plots\n",
    "\n",
    "    if modelling_config.get('pca_components'):\n",
    "        # TODO! Add PCA evaluation metrics\n",
    "        reduced_data = PCA(n_components=pca_components).fit_transform(feature_vector[cols])\n",
    "        reduced_data = pd.DataFrame(reduced_data)\n",
    "        # Our columns are changing\n",
    "        column_names = {x: f\"PCA_{x}\" for x in reduced_data.columns}\n",
    "        reduced_data = reduced_data.rename(columns=column_names)\n",
    "        #reduced_data = reduced_data.rename(columns={0: 'PCA0', 1: 'PCA1', 2: 'PCA2'})\n",
    "        cols = reduced_data.columns.tolist()\n",
    "\n",
    "        # Attach fan_id to the feature vector so we could map output back later \"\"\"\n",
    "        feature_vector = reduced_data.join(feature_vector['fan_id'])\n",
    "\n",
    "    mlflow.tracking.set_tracking_uri('https://mlflow.fansifter.cloud')\n",
    "    try:\n",
    "        \"\"\" Even though 'set_experiment' creates new when not exists,\n",
    "            we explicitly create it to have control over artifact_location\n",
    "            (set_experiment) doesn't expose this option \"\"\"\n",
    "        mlflow.create_experiment(client_id)\n",
    "        mlflow.set_experiment(client_id)\n",
    "        logging.info(\"Created new experiment {}\".format(client_id))\n",
    "    except Exception as e:\n",
    "        logging.info(\"Using existing experiment {}\".format(client_id))\n",
    "        mlflow.set_experiment(client_id)  # Creates a new one if doesn't exist with same name\n",
    "\n",
    "    \"\"\" Add more algorithms here \"\"\"\n",
    "    algorithms = [\n",
    "        # TODO! add affinity propagation algorithm\n",
    "        # TODO! add t-SNE\n",
    "        # {'name': 'KMedoids (PAM)', 'func': run_kmedoids_algo, 'db_friendly_name': 'kmedoids'},\n",
    "        {'name': 'KMeans', 'func': run_knn_algo, 'db_friendly_name': 'kmeans'},\n",
    "        # {'name': 'DBSCAN', 'func': run_dbscan_algo, 'db_friendly_name': 'dbscan'},\n",
    "        ]\n",
    "    mlflow.set_experiment(client_id)\n",
    "    # TODO! Add parallelism, dask, multiprocessing\n",
    "\n",
    "    for algorithm in algorithms:\n",
    "        \"\"\" We make a copy of the dataframe, otherwise we keep operating on the same df.\n",
    "            If we don't do this, then every iteration in loop will add another \"cluster\"\n",
    "            column to dataframe. \n",
    "            \n",
    "        \"\"\"\n",
    "        # print(\"=========BEFORE COPY\")\n",
    "        # print(df[['fan_id']])\n",
    "        df = feature_vector.copy()\n",
    "        # print(\"=========AFTER COPY\")\n",
    "        # print(df[['fan_id']])\n",
    "        algo_name = algorithm['name']\n",
    "\n",
    "        if pca_components:\n",
    "            algo_name = algorithm['name'] + f' PCA {pca_components}'\n",
    "\n",
    "        algo_func = algorithm['func']\n",
    "        logging.info(f\"Running algorithm {algo_name} ...\")\n",
    "\n",
    "        with mlflow.start_run(run_name=f\"{collection_id} - {algo_name} - {modelling_type}\"):\n",
    "            mlflow.set_tag('model_name', algo_name)\n",
    "            mlflow.set_tag('modelling_type', modelling_type)\n",
    "            start_time = time.time()\n",
    "            \n",
    "            model, eval_metrics, hyperparams, cluster_output, graph_locations = algo_func(client_id, df, cols, modelling_config)\n",
    "            elapsed_minutes = str(round(((time.time() - start_time) / 60), 2))\n",
    "            logging.info(f\"Model run took {elapsed_minutes} minutes\")\n",
    "\n",
    "            logging.info(\"Logging model run parameters and artifacts ... \")\n",
    "\n",
    "            if modelling_config.get('importance'):\n",
    "                \"\"\" Add feature importance. We calculate feature importance by running random forest, \n",
    "                    and targeting the cluster label we get from clustering model \"\"\"\n",
    "                # Our output index should match with input index\n",
    "                df['cluster'] = cluster_output['cluster']\n",
    "                original_feature_vector['cluster'] = cluster_output['cluster']\n",
    "                target = 'cluster'\n",
    "                feature_importance_plot_location, feature_importance = run_random_forest(client_id, original_feature_vector, original_cols, target, algo_name)\n",
    "                mlflow.log_artifact(feature_importance_plot_location)\n",
    "                mlflow.log_param('feature_importance', feature_importance.tolist())\n",
    "\n",
    "            # ALTER TABLE params ALTER COLUMN value SET DATA TYPE varchar;\n",
    "            mlflow.log_param('collection_id', collection_id)\n",
    "\n",
    "            mlflow.log_param('data_params', {\n",
    "                \"data_shape\": df[cols].shape,\n",
    "                \"original_data_shape\": original_feature_vector[original_cols].shape,\n",
    "                \"features\": cols  # make sure this is always a list\n",
    "            })\n",
    "            mlflow.log_param('original_features', original_cols)\n",
    "            mlflow.log_param('model_params', {\n",
    "                'algorithm': algo_name,\n",
    "                'hyperparams': hyperparams\n",
    "            })\n",
    "\n",
    "            mlflow.log_metrics(eval_metrics)\n",
    "\n",
    "            for location in graph_locations:\n",
    "                mlflow.log_artifact(location)\n",
    "                # delete file from local container, we don't need to retain it\n",
    "                os.remove(location)\n",
    "\n",
    "            if modelling_config.get('save_model'):\n",
    "                logging.info(\"Saving model object ... \")\n",
    "                mlflow.sklearn.log_model(model, client_id)\n",
    "\n",
    "            \"\"\" Get cluster output to csv \"\"\"\n",
    "            #current_path = os.path.abspath('')\n",
    "            logging.info(\"Storing cluster output to csv ... \")\n",
    "            file_location = f'collection_{collection_id}_clusters_output_{algo_name}.csv'\n",
    "            cluster_output.to_csv(file_location, sep=',', encoding='utf-8')\n",
    "            mlflow.log_artifact(file_location)\n",
    "            # delete file from local container, we don't need to retain it\n",
    "            os.remove(file_location)\n",
    "\n",
    "            #if not 'RFM' in modelling_type:\n",
    "            if modelling_config.get('clusters_to_rds'):\n",
    "                logging.info(\"Load clustering output to rds ... \")\n",
    "                db_friendly_name = algorithm['db_friendly_name']\n",
    "                engine = get_rds_engine()\n",
    "                \"\"\" Load cluster output csv to RDS\"\"\"\n",
    "                # TODO! load to collection table with parent = collection_id\n",
    "                cluster_output.to_sql(f'collection_{collection_id}_{db_friendly_name}',\n",
    "                                      engine,\n",
    "                                      schema=client_id,\n",
    "                                      if_exists='replace',\n",
    "                                      index_label='row_id',\n",
    "                                      # index=False\n",
    "                                      )\n",
    "\n",
    "            logging.info(f\"Successfully completed training process for {algo_name}\")\n",
    "\n",
    "    logging.info(\"Done modelling!\")\n",
    "    return cluster_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ocean alley\n",
    "schema = 'a441ffb172866cb4928c84a73de403ca15da4a54cc535e704413ab621' # unique customer schema id\n",
    "df1 = prepare_rfm_dataset(schema, 'fan_purchase')\n",
    "# print(df1.shape)\n",
    "df2 = prepare_fan_purchase(schema)\n",
    "# print(df2.shape)\n",
    "df3 = prepare_fan_demographics(schema)\n",
    "# print(df3.shape)\n",
    "df4 = prepare_fan_event_distance(schema)\n",
    "# print(df4.shape)\n",
    "\n",
    "\n",
    "df = pd.merge(df3, df2, how='inner', on=['fan_id'])\n",
    "df = pd.merge(df, df1, how='inner', on=['fan_id'])\n",
    "df = pd.merge(df, df4, how='left', on=['fan_id'])\n",
    "\n",
    "print(df.dtypes)\n",
    "print(df.shape)\n",
    "cols = df.columns\n",
    "\n",
    "print(df.index.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IHW\n",
    "schema = 'bd345f915775993a4d3de1dae65b93b067ad69dde4286a1e1639e5cd2' # unique customer schema id\n",
    "df1 = prepare_fan_demographics(schema)\n",
    "# print(df1.shape)\n",
    "\n",
    "f2 = prepare_fan_merch_purchase_ihw(schema)\n",
    "df2 = df2[(df2['total_items_per_fan']>0) &(df2['total_merch_value_per_fan']>0)]\n",
    "print(df2.shape)\n",
    "\n",
    "df3 = prepare_fan_event_purchase_ihw(schema)\n",
    "print(df3.shape)\n",
    "df4 = prepare_rfm_dataset_ihw(schema)\n",
    "\n",
    "df5=prepare_fan_event_distance_ihw()\n",
    "\n",
    "df = pd.merge(df1, df2, how='inner', on=['fan_id'])\n",
    "df = pd.merge(df, df3, how='inner', on=['fan_id'])\n",
    "df = pd.merge(df, df4, how='left', on=['fan_id'])\n",
    "df = pd.merge(df, df5, how='left', on=['fan_id'])\n",
    "print(df.dtypes)\n",
    "print(df.shape)\n",
    "cols = df.columns\n",
    "print(pd.DataFrame(df1.columns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages/sqlalchemy/engine/strategies.py:95: SADeprecationWarning: The psycopg2 use_batch_mode flag is superseded by executemany_mode='batch'\n",
      "  dialect = dialect_cls(**dialect_args)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "preparing Pixies RFM dataset ...\n",
      "fan_id                     object\n",
      "rfm_segment                object\n",
      "rfm_recency                 int64\n",
      "rfm_frequency               int64\n",
      "rfm_monetary                int64\n",
      "recency_value      datetime64[ns]\n",
      "frequency_value             int64\n",
      "monetary_value            float64\n",
      "date_diff                 float64\n",
      "dtype: object\n",
      "(7724, 9)\n",
      "fan_id             7724\n",
      "rfm_segment        7724\n",
      "rfm_recency        7724\n",
      "rfm_frequency      7724\n",
      "rfm_monetary       7724\n",
      "recency_value      7724\n",
      "frequency_value    7724\n",
      "monetary_value     7724\n",
      "date_diff          7724\n",
      "dtype: int64\n",
      "(363187, 4)\n"
     ]
    }
   ],
   "source": [
    "# Pixies\n",
    "schema = 'ace3c2bb4abd9fcaf9807975e6ab940131386dc9ecddb2b7e31288ff8' # unique customer schema id\n",
    "df = prepare_rfm_dataset_pixies(schema)\n",
    "df['date_diff'] = (calculate_diff(df['recency_value'], pd.to_datetime('today'))) / pd.Timedelta(1, unit='d')\n",
    "# df = df[df['monetary_value']<750]\n",
    "df2 = prepare_optin_dataset_pixies(schema)\n",
    "print(df.dtypes)\n",
    "print(df.shape)\n",
    "print(df.count())\n",
    "# print(df2.dtypes)\n",
    "print(df2.shape)\n",
    "# print(df2.count())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "customer = \"Janis\"\n",
    "schema = 'af65a0ef98e7420800afdea2beb81059bde2bc59d797cc0851412ac41'\n",
    "\n",
    "df = prepare_rfm_dataset_jj(schema)\n",
    "df['date_diff'] = (calculate_diff(df['recency_value'], pd.to_datetime('today'))) / pd.Timedelta(1, unit='d')\n",
    "# df = df[df['monetary_value']<750]\n",
    "df2 = prepare_optin_dataset_pixies(schema) # we can use pixies function for janis also\n",
    "df3 = prepare_fan_demographics(schema)\n",
    "print(df.dtypes)\n",
    "print(df.shape)\n",
    "print(df.count())\n",
    "print(df2.dtypes)\n",
    "print(df2.shape)\n",
    "print(df2.count())\n",
    "print(df3.dtypes)\n",
    "print(df3.shape)\n",
    "print(df3.count())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(24673, 16)\n",
      "fan_id             24673\n",
      "gender             10781\n",
      "age                  254\n",
      "male               24673\n",
      "female             24673\n",
      "optin_count        17080\n",
      "optin_rating       17080\n",
      "optin_recency      17080\n",
      "rfm_segment          855\n",
      "rfm_recency          855\n",
      "rfm_frequency        855\n",
      "rfm_monetary         855\n",
      "recency_value        855\n",
      "frequency_value      855\n",
      "monetary_value       855\n",
      "date_diff            855\n",
      "dtype: int64\n",
      "                                              fan_id  gender   age  male  \\\n",
      "0  002b57bac80b751a42a9e5c6bcd6c01ee0e6f8573cc648...    male  45.0     1   \n",
      "1  00026865b6fbea642c49c2877e0f1c12075ce0f859029c...  female   NaN     0   \n",
      "2  001507a19e27a5164cecf4c15a5061edb32de402e531d2...  female  39.0     0   \n",
      "3  000a0ced2347433ec22b88ff1c98d9e67361236a553771...  female   NaN     0   \n",
      "4  001407bbcbe0a5b082b901ba9867e537322de8d70923fa...  female   NaN     0   \n",
      "\n",
      "   female  optin_count  optin_rating  optin_recency rfm_segment  rfm_recency  \\\n",
      "0       0          1.0           3.0          762.0         NaN          NaN   \n",
      "1       1          NaN           NaN            NaN         NaN          NaN   \n",
      "2       1          1.0           2.0          762.0         NaN          NaN   \n",
      "3       1          1.0           1.0         2121.0         NaN          NaN   \n",
      "4       1          1.0           4.0         2539.0         NaN          NaN   \n",
      "\n",
      "   rfm_frequency  rfm_monetary recency_value  frequency_value  monetary_value  \\\n",
      "0            NaN           NaN           NaT              NaN             NaN   \n",
      "1            NaN           NaN           NaT              NaN             NaN   \n",
      "2            NaN           NaN           NaT              NaN             NaN   \n",
      "3            NaN           NaN           NaT              NaN             NaN   \n",
      "4            NaN           NaN           NaT              NaN             NaN   \n",
      "\n",
      "   date_diff  \n",
      "0        NaN  \n",
      "1        NaN  \n",
      "2        NaN  \n",
      "3        NaN  \n",
      "4        NaN  \n"
     ]
    }
   ],
   "source": [
    "joined = pd.merge(df3,df2, how='left', on=['fan_id'])\n",
    "joined = pd.merge(joined,df, how='left', on=['fan_id'])\n",
    "print(joined.shape)\n",
    "print(joined.count())\n",
    "print(joined.head(5))\n",
    "df=joined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find limit for extreme values\n",
    "# ax =sns.boxplot(y=\"total_tickets_per_fan\", data=df, showfliers = True)\n",
    "# print(df[\"total_tickets_per_fan\"].quantile(0.99))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# apply rules to remove extreme values\n",
    "df = df.fillna(-1000)\n",
    "# df=df[df[\"time_in_seconds_to_venue\"] < 14510]\n",
    "# df=df[df[\"date_diff\"] < 1701]\n",
    "# df=df[df[\"monetary_value\"] < 254]\n",
    "# remove rows missing important numerical data e.g being only in master mailing list\n",
    "# df = df[(df[\"total_merch_value_per_fan\"]!=-1000.0) | (df[\"total_tickets_per_fan\"]!=-1000.0) | (df[\"unique_events\"]!=-1000.0)]\n",
    "# df = df[(df[\"days_from_event\"]>0) & (df[\"unique_events\"]>0)]\n",
    "print(df.shape)\n",
    "print(df.count())\n",
    "# df.to_csv('clusters_input.csv', sep=';')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(363187, 4)\n"
     ]
    }
   ],
   "source": [
    "# apply rules to remove extreme values\n",
    "df = df.fillna(-1000)\n",
    "# df = df[(df[\"total_merch_value_per_fan\"]>0) & (df[\"total_items_per_fan\"]>0)]\n",
    "print(df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Configure options for various model runs \"\"\"\n",
    "modelling_config = {\n",
    "        'plot_2d': True,\n",
    "        'plot_3d': True,\n",
    "        'importance': True,  # Calcualte feature importance (rf targeting cluster values)\n",
    "        'boxplot': False,  # Draw boxplot\n",
    "        'save_model': False,  # Whether to store model object.\n",
    "        'modelling_type': 'Pixies- rfm input',  # Just a name description\n",
    "        # 'pca_components': 3, # 'se this if you want to use PCATODO! add PCA 4 and an extra dimension as \"size\" in plots\n",
    "        'clusters_to_rds': True,\n",
    "        \"collection_id\": 'rfm_modelling'\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Low-cardinality categorical/oject features are also useful for hues. Drop _id fields. Drop recency_value as this is date and should be calculated to datediff\n",
    "input_vector = df[df.columns.drop(list(df.filter(regex='_id|recency_value')))]\n",
    "# Draw pairplot. This can take 20+sec\n",
    "#sns.pairplot(feature_vector,\n",
    "#             plot_kws={'alpha': 0.6, 's': 80, 'edgecolor': 'k'},\n",
    "#             #dropna = True,\n",
    "#             diag_kind='kde',\n",
    "#             hue='rfm_segment'\n",
    "#             )\n",
    "# print(input_vector.index.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "optin_count      float64\n",
       "optin_rating     float64\n",
       "optin_recency    float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_vector = df[df.columns.drop(list(df.filter(regex='_id|rfm_|recency_value')))]\n",
    "input_vector = df[df.columns.drop(list(df.filter(regex='_id|rfm_|recency_value|gender')))]\n",
    "# feature_vector = feature_vector.drop('cluster', axis=1)\n",
    "input_vector.dtypes\n",
    "#print(df[['fan_id']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:root:Pixies- rfm input with PCA False components\n",
      "INFO:root:Using existing experiment ace3c2bb4abd9fcaf9807975e6ab940131386dc9ecddb2b7e31288ff8\n",
      "INFO:root:Running algorithm KMeans ...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Executing model run with feature vector column names Index(['optin_count', 'optin_rating', 'optin_recency'], dtype='object')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:root:Drawing 2d plot\n",
      "INFO:root:Drawing 3d plot\n",
      "INFO:root:Model run took 26.2 minutes\n",
      "INFO:root:Logging model run parameters and artifacts ... \n",
      "INFO:root:Running random forest to calculate feature importance ...\n",
      "INFO:root:Drawing feature importance...\n",
      "INFO:root:Storing cluster output to csv ... \n",
      "INFO:root:Load clustering output to rds ... \n",
      "/home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages/sqlalchemy/engine/strategies.py:95: SADeprecationWarning: The psycopg2 use_batch_mode flag is superseded by executemany_mode='batch'\n",
      "  dialect = dialect_cls(**dialect_args)\n",
      "INFO:root:Successfully completed training process for KMeans\n",
      "INFO:root:Done modelling!\n"
     ]
    },
    {
     "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>fan_id</th>\n",
       "      <th>cluster</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0000bb7fb257e961fd6844f68eff305b6e36f3415438e9...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0000d0cf9809aca3d87fe042c789922adcfd5d0a1b724f...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0000d524b4bf92037ed11366d520e4a4b89bbc5bd594f0...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0000e343e6f53e4674e82fa3313cecfe70310f7e35dec7...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>000102f59261d379735929ea34dbc67fecc122fd31e7fe...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>363182</th>\n",
       "      <td>fffebc75e075367b52ab39320da2b48c7a5e80e02da2b4...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>363183</th>\n",
       "      <td>fffee33edc302ae60c1f1e6b8d5856f337c8d9b417a6c5...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>363184</th>\n",
       "      <td>fffef8a2f1c6a7b0306ec9fa7e9631b8ce64099079919a...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>363185</th>\n",
       "      <td>ffff2431422be00addd7b75e93862b1f8742369a061a14...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>363186</th>\n",
       "      <td>ffff5550bed5d108e703b4a168016d62566c92e7d3f829...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>363187 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                   fan_id  cluster\n",
       "0       0000bb7fb257e961fd6844f68eff305b6e36f3415438e9...        0\n",
       "1       0000d0cf9809aca3d87fe042c789922adcfd5d0a1b724f...        0\n",
       "2       0000d524b4bf92037ed11366d520e4a4b89bbc5bd594f0...        0\n",
       "3       0000e343e6f53e4674e82fa3313cecfe70310f7e35dec7...        0\n",
       "4       000102f59261d379735929ea34dbc67fecc122fd31e7fe...        0\n",
       "...                                                   ...      ...\n",
       "363182  fffebc75e075367b52ab39320da2b48c7a5e80e02da2b4...        0\n",
       "363183  fffee33edc302ae60c1f1e6b8d5856f337c8d9b417a6c5...        0\n",
       "363184  fffef8a2f1c6a7b0306ec9fa7e9631b8ce64099079919a...        0\n",
       "363185  ffff2431422be00addd7b75e93862b1f8742369a061a14...        0\n",
       "363186  ffff5550bed5d108e703b4a168016d62566c92e7d3f829...        0\n",
       "\n",
       "[363187 rows x 2 columns]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAFCCAYAAAB1po8RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAACr3ElEQVR4nOy9eZgcdbn+/amqXmemZ9+TSTJZCUJC9rAlQADZd0V2EURUUOAcEBH1wOGnuIEcERFQFEHEo+ArCHhkDSKrhJ2QdfZ9pve9lvePnqp093TPdPf09ExC39cVQma6qr5VXXXXs96PoGmaRhFFFFFEERlBnO4FFFFEEUXsTSiSZhFFFFFEFiiSZhFFFFFEFiiSZhFFFFFEFiiSZhFFFFFEFiiSZhFFFFFEFiiSZgZ48803+fSnPz3dy0iJ1157jQ0bNkz3MgBYsmQJ7e3t03LsXbt2ceqpp7JixQoeeOCBjLebSdeviL0D+zRpHnXUUSxbtowVK1YYf26++eYJt0t++FevXs3f//73KVnj9ddfz+233z4l+/4k4b777mPdunVs2bKFCy+8sODHP+qoo/jXv/5V8OMm46KLLmLJkiXIsjzdS9lnYZruBUw17r77bg455JDpXkYRWUCWZUym7G7Nnp4eTjzxxCla0dRC0zQ0TUMUJ2fD/PWvfy2SZQGwT1ua46G9vZ3zzz+fVatWsW7dOq666ioAzjvvPADD1XvyySfHuHBHHXUU9913HyeffDIHHXQQN9xwA0NDQ1x66aWsWLGCz3/+87jdbuPzX/va1zj00ENZtWoV5513Htu3bwfgkUce4fHHH+dXv/oVK1as4PLLLwegv7+fK6+8kvXr13PUUUcluJuhUIjrr7+eNWvWcMIJJ/Dee++Ne55Llizh4Ycf5thjj2X16tXcdNNN6E1gP/vZz/jP//xP47NdXV0JVsoFF1zA7bffzuc+9zljfU6nk//4j/9g5cqVnHnmmXR1dSUc78UXX2TTpk2sW7eOH/zgB6iqavzuT3/6E8cffzxr1qzhkksuobu7O2GdDz30EMceeyzHHntsynN59tlnOfHEE1m9ejUXXHABO3fuBODCCy/ktdde4+abb2bFihXs3r17zLYul4tvfvObHHbYYaxZs4avfOUraa9XvJcR7wmMjIzwpS99idWrV7N27VrOPfdcVFXl2muvpaenh8svv5wVK1Zw7733AvD222/zuc99jtWrV3PKKafw2muvGfuNv7bLly+ns7OTRx99lE2bNrFixQqOOuoo/vrXv6ZcYyp4vV5+/vOfc+2112a8TRE5QtuHceSRR2ovv/xyyt9dffXV2l133aUpiqKFQiHtjTfeMH63ePFira2tzfj3q6++qh1++OEJ+/3MZz6jDQ4Oan19fdr69eu10047Tfvggw+0UCikXXDBBdrPfvYz4/P/+7//q3m9Xi0cDmu33HKLdsoppxi/+8Y3vqHddtttxr8VRdFOP/107Wc/+5kWDoe1jo4O7aijjtI2b96saZqm/ehHP9LOOecczel0aj09PdqJJ56YsLZkLF68WLvssss0t9utdXd3a+vWrdNefPFFTdM07X/+53+0//iP/zA+29nZqS1evFiLRqOapmna+eefrx199NFae3u75vF4tOOPP1479thjtZdfflmLRqPatddeq11//fUJxzr//PM1p9OpdXd3a8cee6z2xz/+UdM0TfvHP/6hHX300dqOHTu0aDSq/fznP9fOPvvshG0///nPa06nUwsGg2POY9euXdry5cu1f/7zn1okEtHuuece7eijj9bC4bCxVv1YqfDFL35R+/rXv665XC4tEolor732WsrvNvm7j/9+fvzjH2vf/va3tUgkokUiEe2NN97QVFXVNG3svdbX16etXbtWe+GFFzRFUbR//vOf2tq1a7Xh4WFjvRs3btS2bdumRaNRzePxaCtWrNB27typaZqm9ff3a9u2bdM0TdO6u7u1VatWad3d3WnP77/+67+0+++/f8x3WET+sc9bml/96ldZvXq18eePf/wjACaTiZ6eHgYGBrBaraxevTqr/Z5//vnU1tbS0NDA6tWrWbZsGfvvvz9Wq5VjjjmGDz/80PjsWWedRVlZGRaLhSuvvJKtW7fi9XpT7ve9995jZGSEK664AovFQktLC5/97Gd58sknAXjqqae4/PLLqayspKmpiQsuuGDCtX7xi1+kvLyc5uZm1q1bx9atWzM+zzPOOIM5c+bgcDjYsGEDLS0tHHLIIZhMJo477riE89SPVVlZSXNzMxdeeCFPPPEEAH/4wx+47LLLWLBgASaTicsvv5yPPvoowdq87LLLqKysxGazjVnHk08+ycaNGzn00EMxm81ccsklhEIhtmzZMuE5DAwMsHnzZm666SYqKiowm82sXbs242ugw2QyMTg4SE9PD2azmdWrVyMIQsrP/n//3//Hhg0b2LhxI6Iocuihh3LAAQfw4osvGp85/fTTWbRoESaTCUmSEEWR7du3EwqFqK+vZ9GiRQA0Nzfz5ptv0tzcnPJY7733Hm+99Rbnn39+1udURPbY52OaP//5z1PGNK+99lruuOMOzjrrLCoqKrj44os566yzMt5vbW2t8f9WqzXh3zabjUAgAICiKNx+++08/fTTjIyMGHErp9OJw+EYs9/u7m4GBgYSSFxRFOPfAwMDNDU1Gb9L9yDFo66uzvh/u92O3+/P9DQzPk8d8WubNWsWAwMDQCzm+L3vfY8f/OAHxu81TaO/v59Zs2aN2TYZAwMDCecqiiJNTU309/dPeA59fX1UVFRQUVEx4WfHwyWXXMKdd97JF77wBQDOPvtsLrvsspSf7enp4emnn+b55583fibLMuvWrTP+HX++JSUl3H777fz617/mW9/6FitXruQb3/gGCxYsGHdNqqpy00038a1vfSvrOHARueETe5Xr6uq45ZZbgFhJ0cUXX8yaNWuYO3duXo/z+OOP8+yzz3L//fcze/ZsvF4va9asMeKKyZZKU1MTs2fP5v/+7//Srru3t9ewQnp7e3Nem91uJxQKGf8eGhrKeV864tfW09NDfX09EDuvyy+/nFNOOSXttumsNoD6+nq2bdtm/FvTNHp7e2loaJhwTY2NjbjdbjweD+Xl5eN+1m63EwwGjX8PDg4axygrK+P666/n+uuvZ9u2bVx00UUceOCBHHzwwWP209TUxKmnnmrcY6mQfL6HH344hx9+OKFQiJ/+9Kd8+9vf5ve///246/X5fLz//vtcffXVQOwFC7Bx40buuOOOrD2oIibGPu+ep8NTTz1FX18fABUVFQiCYFiBtbW1dHZ25uU4fr8fi8VCVVUVwWCQ2267LeH3NTU1CcmUZcuWUVpayj333EMoFEJRFLZt28a7774LwPHHH88999yD2+2mr6+P3/3udzmvbenSpbzxxhv09PTg9Xr55S9/mfO+dPzqV7/C7XbT29vLAw88wAknnADA5z73Oe655x4jCeb1ennqqacy3u/xxx/Piy++yCuvvEI0GuXXv/41FouFFStWTLhtfX09GzZs4KabbsLtdhONRnnjjTdSfna//fbjiSeeQFEUNm/enPC5559/nvb2djRNw+FwIEmSQXzJ98wpp5zC888/z0svvYSiKITDYV577TXjnkvG0NAQzzzzDIFAAIvFQklJSUbZdIfDwUsvvcRf/vIX/vKXv3DPPfcA8Oijj7Js2bIJty8ie+zzpKlnNPU/X/3qV4FYHOgzn/kMK1as4Mtf/jLf+ta3aGlpAeCKK67g+uuvZ/Xq1UYsMVecdtppNDc3c/jhh3PiiSdy0EEHJfz+rLPOYseOHaxevZqvfOUrSJLE3XffzdatW9m0aRPr16/nxhtvxOfzGWtrbm5m06ZNfOELX+DUU0/NeW2HHnooJ5xwAqeccgpnnHEGRx555GROFYBNmzZxxhlncNppp3HEEUcYIY9jjjmGSy+9lGuuuYaVK1dy0kknsXnz5oz3O3/+fH70ox/x3//936xfv57nn3+eu+++G4vFktH2P/zhDzGZTBx//PEccsgh/Pa3v035uW9961s8//zzrF69mscff5yjjz7a+F17ezsXX3wxK1as4Oyzz+acc85h/fr1QCwe+4tf/ILVq1fzq1/9iqamJu666y5++ctfcvDBB7Nx40Z+9atfJVQTxENVVX7zm99w+OGHs3btWt544w3+67/+C4hZ7CtWrKCnp2fMdoIgUFdXZ/yprq4GYi/jTK9NEdlB0LSiCHERRRRRRKbY5y3NIoooooh8okiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEiaRRRRRBFZoEianxCoqoqmadO9jCKK2Othmu4FFDG10DQNRVEIhULIsowkSZhMJsxmM5IkIQjCdC+xiCL2Kgha0fzYZ6FpGtFoFFVVURQFRVGMn2uahiAIiKJYJNEiisgCRdLcR6EoCtFoFABBEJBlGUVRxpCiTqA6iiRaRBHjo0ia+xg0TTMIEjBIT1EUZFmekARTkajZbMZkMhVJtIgiKJLmPgVN03A6ndjtdgRBSCC4dJZmJvtMdueLJFrEJxnFRNA+AlmWkWWZ3t5eFi5cmLf9JpOvpmmEQiHjd6IoYrFYMJlMiKJYJNEi9nkUSXMvh+6OZ+J65wOCICBJUsLx29raqKysxGazIUmSYYkWSbSIfRFF0tyLoaqqkR1PtggLBd3alCQJURRRVZVgMGispUiiRexrKJLmXgi99jIajRqkNVOQbIkWSbSIfQ1F0tzLoNde6kmdmU468SSqaVqRRIvY61Ekzb0I8bWX2VqXU01GmRRhxBOlvk0qErVYLIa7XyTRImYaiqS5FyDZHd9XiCQdiQYCAeP3eqG9yWTap869iL0XRdKc4dA0jUgkYtRJZkIa+mf3NqQiUVmWx1jXFosFi8VSJNEipgVF0pzBSG6FzATpPrc3kkuqGtGBgQFKS0ux2+1Gy6f+ZyYlxIrYd1EkzRmI5NrLbAhPEIS91tKcCPq10Euc9KRYJBIxflck0SKmGkXSnGHIR+1luqTMVJFpoQlaP14qS7RIokVMNYqkOUOgaRrhcBiv14vD4cj5Ad8XLcxMkSmJ6gpORRItIhcUSXMGQH+4Q6EQLpeL8vLySe8vk5/lE4XSfcnmOOORKCQqOOnZ+SKKmAhF0pxmqKpqZMfjO2lyRfHBT49UJBqJRAiHwwBFVfsiMkKRNKcJqVoh9STOZJCPfXxSMB6J6t+JqqqUlpYWSbQIA0XSnAakq73MF+El70OWZbq6uohGo9jtdux2OyUlJXmxbKcDU0VeySSqqiqdnZ20tLQARVX7ImIokmaBMVHtZT4szXj4/X56e3upra3FYrEQiUQIBAI4nU4Ag0D1useZjkJa0fElTvqxI5FIyphokUQ/OSiSZoGQbgxFPPJpaWqaxtDQEF6vlzlz5iBJEtFolJKSEkpKSoAYgQeDQfx+P0NDQ4iiaPzeZrN94kkg+btI5c6Hw2FCoVBR1f4ThCJpFgC6hTJR7WW+Ypq6grvNZqO1tRVBEFBVdcxnJUmirKyMsrIyIObGB4NBPB4PAwMDSJJkkKjVap0x3UaFPN54x8qERIuq9vseiqQ5xdA7e2BiZaJ8PFSKotDd3U1TUxMOhyOrbU0mEw6Hw9guGo0arnw4HMZisRgkajab93kSyLYZIBWJBoNB43dFGbx9A0XSnCLkons5GUtTd8eDwSCzZ8/OmjBTwWw2U1FRQUVFhXE+gUCAoaEhIpEIVquVkpKSlFbsvoB8WP2pBJnjf1ck0b0PRdKcAsTXXhYiuaJnx202Gw6HA5Mp/1+rIAiGulBlZaXhigYCAQKBAMFg0LBC7Xb7lKwBCpsIgvyGAjJRtdf1RIskOnNRJM08YjrGUOjZ8YaGBhwOB93d3QUhFkEQsNls2Gw2ZFmmtLQUURQJBAK4XC5UVU3IzO+N5U1TfR1Tqdrv3r2bOXPmAEVV+5mKImnmCZqm4fV6C6bzqGkag4OD+Hw+5s6di9lsBiZOXEwVBEEwakBramoMKyoQCDAyMgKQkJmfzAulUORRSLWo+FpdURSLo0FmMIqkmQfo1mVnZ2deZ46nQ7w7rmfHdcyUjiBRFCktLaW0tBSIXaNAIIDX62VwcNDIzNvt9hld3lTIdcV/b5mMBimq2k8PiqQ5CSTXXhYCye54unUlY6qtzIkgSVJCZl6WZQKBAG63m/7+fsxms2GJ6tZ6KhTyhVDol894lm0mqvbxlmiRRKcORdLMEZnWXubzeIODg/j9/gR3PBl7y4NiMpkoLy+nvLw8ITM/MjJCOBzGarUaMdHpLG8qtKWZjUJ/cnmTXt6mJyCLWqJTgyJp5oBsai/zdTzdHZ83b96ED1ahRYgni1SZeb3dc3BwkGg0is1mM8qbChnTLCQm8/2kk8GLb9ktkmh+UCTNLJDJGIp8E5PP56Ovr29cdzwe05UIyicEQcBqtWK1WqmqqkLTNEKhEIFAgHA4THd3d0J501Rl5gv9ksnn8Yqq9lOHImlmiEzGUOTzAcvUHU+1hulIBE3lMeMz86FQiNraWiOxpGfmp0p4ZG8lzWSkI9GRkREEQTDqe4uq9hOjSJoTIJvaS73He7KWTzQapbu7G7vdnpE7nmrN+zJEUTS6kWDqhEf2Jvc8W+gkGn+/FlXtM0ORNMdBtq2Q+bDyVFWlra2NxsbGnFohPwk3d/I55kt4JJNjTSWmI+asqmrKbHtR1T49iqSZBvG6l5m6KnpRci7Q3XFZlpk/fz42my2n/YxH3DM1EZRv5Et4ZG+OaU72mOORqO5xfVJJtEiaSUh2x7O1SnIhTVmW6ezsNNzJTOOX6ZBuDVMZLysUcrm+mQqP6CQ6mWNNBtNFmpkYBelINN6d/6SQaJE045BuDEWmyIU0k7PjbW1tk3pY9+WbNR8YT3ikv78fRVGmpbwJps89z+WYn2QSLZLmKCYaQ5EJsiHNdNnxfMRF9/VEUL6Vh3ThkerqakMDMxAI4PP5UBQFRVEMS3Qqs8oz2dKcCOORqN/vR1VVZs+ePenjzAR84klT0zSjJ7qysnJSN22mhBeNRunq6qKkpGRMdnyypDldb/R9hagFQUho59QL6/XyJr38KR/CI8mYSTHNySKeRHXvbV/BJ5o09drLSCSCz+ejqqpqUvvLhPB0d7yxsdHI9iajaGmmR6HPrZDCI3uTe54NCqUrWyh8IkkzOdkjSVJeHka97i3dMQcGBggEAhP2jk/W0ky1vaIo+P3+vVbbcjqQ6jrmS3gk3fH2Vvd8PKiqisVimdJjFBKfONJMVXs5mVKheKQjrPHc8Uz3MZk1hEIhurq6sFqtCS5maWnpjJZlS4dCrneiY6UTHhkeHk7IzNvt9gmJo2hp7h34RJFmujEU+Wo9TEW+mbjj8cjHDRy/BpfLxdDQELNmzTKEa3UXUy/+NplMOVtH+zKyvSeyER4pKSkZMxJkOsilEEStqmqRNPc2TNQKKYpiXoaDxZNvpu74ePvIdQ0Qu1H7+vpQFIXW1lZEUTSqA5JdTP3B1q2j8R7sTxImS2LjCY/09vaOGQkyXc0HRUszO+zzT4TuMk0ktJFP9zwbdzzfaxGE2NzztrY2KioqqK6unnCf6eoWkx/sdCU3M724fTLId3lT8kgQnURHRkaQZRmr1YokSXkXHplO5EOPYSZhnybNTGsv80mawWCQoaGhjN3xfK8lGAzicrmYO3euIWiR7fHj6xaTZ/3El+TsjfHQbDDVBB0vLAIwMDCAKIp5Fx6ZbhRJcy9A8hiKQtxsmhYbrBaJRGhtbZ1UK2QuD6seDtDrTXMhzFRILrlJlS3WP1co93ImJYLyfSw9QQf5FR6ZTmiaViTNmYxCj6GAPdlxURSpqqqaFGHmYmnqyu52u536+noCgUDOx58IqbLFg4ODeDwe3G73lMdDC+meT7dgR76ER8Y7XiFQtDRnMAo9hgLA6/XS399PY2NjwqCrXJEtaQYCAXp6eozedZ/Pl/az+SYBPVtss9mwWCyUlZUlJDo0TZsyceBCYKYJdiQLj+gJvImER8ZDIV4Kxez5DES2upf5OqaeHZ83bx4mkwmPxzPpBy3TtWuaxsjICC6Xizlz5iTUAE5XR1CqREcgEDBidHujezlTBTtSZebTCY+UlJSktPQKJUhSdM9nGNLVXk4ldHe8tLQ0ITuej4RSJvtQVZXu7m5EUTTKieK3H2/fhYQoimPEgQOBAC6Xi1AolOBeZtMxUqjzmGmW5ngYT3jE5XKhqqph8etVEIV4ZjRNK1qaMwV6sqe/v5/a2tpJfyk6WU1008a748nZ8UKQZjgcpquri+rq6pS98vmqBMgGmT7oyfHQ+MJvWZYntIwKjemOaU4G8VUOQMoqCIvFgqIoU0pq+jkVSXOaEe+Ou91u6urqJr3PiUhTd8eDwaDhjqfbRz7WkQput5vBwUFmz549rrL73iDYka7w2+/343K5jHio3uo5XQ/d3kqayUglPOLxeAgEAnR2duZVeCQe01WwP5XY60gzlzEUmUDvCkq1z3h3fO7cuWlvgnxZecn70DSNvr4+otEora2t41phe+sNGh8PhT3D0nw+X4KakKqqBXsQ9yb3PFvoBfSRSISGhgai0SjBYDAvwiPxUBRln7IyYS8izamuvUxHeLo73tTUZLylx9vHZNsxk/cRjUbp7OykvLycxsbGCc97OtxzyD/BJA9L08ttFEWhvb09p0xxLthXLM1UiE8Emc1mzGbzhMIj2V7vfS2eCXsJaRai9jKZrDRNo7+/n1AolNYdT7WPfLrnuthHJoQdj3Rr2JtdJb3cRq8W0OOh8Zni0tLSvErf7c0xzUyPl64tNp3wyMDAwITCI5kcY2/GjCfNqXLHkxGvUJSpO56MfJGmqqoMDAyMGYWR6fbpfr63EmYykuOhyT3cgPFA2+32nM97X3bPIfOSo2yFR+JfWplYmlu2bOHWW281QgI//vGPkWWZ6667Dr/fzyGHHMKVV14JwPPPP8/dd9+NIAjccMMNLFu2DFVVuemmm9i+fTv19fXceuutOU9zzQQzljR1d1yW5Qkf+HzcbDrhZeOOJyMfupyapuF2uykvL89a7CN+H58kJPdwJ6urT0b6rtAvmplgaU6EiYRHAOx2uzFjaaKW3ubmZn7zm99gt9t5+OGHeeihh/B4PJx55pkcf/zxXHbZZezYsYPW1lbuuOMOHnzwQfx+P1dddRUPP/wwmzdvRhRFfv/733Pffffx5z//mfPOOy+na5IJZiRp6mMoMnHH89XzLAgCQ0NDKIqSsTueah+TFdvo7+/HbrfT2NiY0z72FWtyMkiWvtPjcyMjI4TD4Yzjc/v6yydflm2ql1YwGOSJJ57ggQcewOFwsGHDBtavX8+xxx47JnzS0NBg/L8+vfKtt97i61//OgBHHHEEb7zxBoIgMG/ePCPWLcsy4XCYN998kyOOOAKAI488kjvvvPOTQ5oT6V6mgu7OTsZ1j0QieDweysrKsnLHU60lV7ENp9OJ0+mkvr6ecDic0/Hj91dIzHSiTm4/TO6cSSd9tzfHgDPBVCVp9CTexRdfzCmnnML27dvp6urib3/7G/vttx+tra0pt3M6nYa1+Pjjjxsudnl5OV1dXYYHpqO8vByXy4Xb7aaiogIAh8OB2+3O+znFY8aQZq6tkJMVENbd8dLSUsrLyyf1kORCmqqq0tPTA0BrayuBQIBQKFTQNXySkI303b5+HQuVpFm0aBHHHHMMF198cdrPBINBvv71r3PjjTdSXV2N3W43vAKv12u89Lxer7GNruhVXl6Ox+MxfqYT6FRhRqS1FEUhHA4bb75siCvXOKJe+zg8PMy8efOw2WwFaYGMRzgcZvfu3ZSUlCSMo8iHcnsRmUEv+q6rq2POnDk0NzdjsVjweDxGuMTpdO5zY2hh5swHkmWZq6++mgsuuICVK1cCsGrVKl588UUANm/ezOrVq5k7dy5tbW1GF5kkSVitVtasWcPmzZsTPjsRXnrpJXp7e3M6p2m1NJPd8Vy+wFwszUgkQldXFw6Hw3DH81VjmemDpWskzpo1yyjoznYf6bCvPdyFRHw8NBKJUFtbSygUMpSE9qVRIIWwNDOZRPnEE0/w5ptv4vf7eeCBB9i4cSNf/OIXue6667j//vtZv349ixYtAuCKK67g4osvRhAEvvnNbwKwYcMGnnvuOc4991zq6uq49dZbJ1zXgw8+yMKFC1mzZg2LFi2ioaEh4+9T0KbpCdNrv/TD5/rG6+npoaKiIuNMd7rsuJ71q66uzmkdOnbs2MHChQvT/l6v/wyHw8yePXtMUDwYDDI8PMzs2bNzOr6iKHR0dKSMGwWDwawt+UzgdDoRRXHK3SKA9vZ25s6dO+XHAejs7KS5udn4jvR4qN/vJxAIGCIY+ZK+K+S5QUwp3uFwJLy0842+vj7KyspoamqasmPkimeeeYYnnniCUCjE2rVrOeGEE6irq5uwzndaXpWRSIRoNIokSZN+gDN1zycqVs+HpTkR4us/58yZk/Lc8+Gep2rDHBoawul0AhjWUmlp6YwQxpipSE4ExcdD9VIbPR462fEU02G7FMo9n6n32GGHHcaKFSt46aWXuPXWW7nnnns49thj+dKXvsSsWbPSbldQ0tRrLwcHBxFFcdJWHWTmnqdyx1PtRxcwngr4/X56e3snnB2Uj5s4/gFUFIXu7m7MZrNhxeg1dT09PWialpdC8H0VE5W7jTcKJBtl9enI1BfKPZ9ppBkMBnnqqafo6OjgnXfeoaKigjvuuIN169bx2GOPceWVV/Loo4+m3b5gpBlfeylJktFDPllMRJp67HCiYvWpyjprmsbw8DAejyej7p58JoJ0GbmamhoqKyuJRCIACYXJek1dfCF4aWlpziMU9iVk+z2kGgXi9/sN6Tur1Wpc22QimQ7SnCmJoELD4/HwwgsvcNJJJ/G1r30tYX0bN25kaGho3O2nnDT1ZE/8GApJkiY9FkJHOrc6PnaYSbH6VLjn8VZea2trxi1r+UgEpUo0pdp3sjBGLhqX+zKxTqZmV+/fTm49jJe+m86Z559US7O8vJwbbrjBaCDRvxtZlqmuruaLX/ziuNtPKWmmq72cbG1lPFLtK94dTxc7TLWffFqaoVCIrq4u6urqskqQ5IM0o9EoIyMjOXU2JQs16DE7p9OZUMO4N4+UnQ6kaj2MHwUiCAKKohAKhQo2CqQQRD2TVI708/33v//N3XffzYMPPkgkEsFisfDqq6/y6KOP8rOf/WzCNU8ZacYrEyUvIN+kGR+LzNQdT0Y+3XOn08nIyAgtLS1Yrdast891HYqi0NXVBTCpziYd8SSp7z85ZldaWoqiKHt9+U2hkTwKRLfukydNlpaWTpn03SctEaSTZjgcpqamBsAoh9I0LeH/x8OU3enxVmUy8kmaulutF6tHIpGcLKx8rEmP23q9XubNm5fTzZIreeuWbX19vVH3mm/E1zDGy4V5vV5UVSUcDqdsRyxiYkiShMVioampaYwU21SOAvkkWZr6uTY0NGC32/nb3/7G0qVLCYVCvPHGG8ybNy+j/UypeZCOADIlKLfbzdDQELW1tWldXN3S3L17Nw6HIyOh3mzWmin0kIAoigm1fYVYR/IYjIGBgZyOnQ3i5cL0NVssFkO4Vs8s702TJ6cT8a5yKim2+CFp8RUP0zkKJBOoqjpjvBD9+h5wwAGcdNJJ3H///USjUXw+HyeccAKXXnopwMys05yINN1uN7+5+1cEBz0QlMFuwl7r4KLLL6GysjLhs8Fg0MhMTyRBNR4mkwjSC+abm5vp7+/PeQ36OjJFfLJrojEYUw1BEFKW3+juZnzmeKY8RDMJ48UXU4VJ4ise9FEgpaWlkxpNkW9omjYjs+cQq9Fct24dgUAg4Z7N5N7M6e7VRzAEg+MLS4xnMcmyzPbtO1Jthcfl4bANh0MkjsQsIju376S8shyI3RSKohg3W3d3Tw5nknhcWVaMNdlsVpqamiZUpU4etjbZhFKmlqYsy3R1dVFSUpJxsktfcyEequTyG11ZSBet1R/ymW4pFQrZfC/pRoFkK3031dDPaaaQuI7e3l6ee+45du/eDcSup9fr5eSTT+bggw+e8LvIiTQ7Ozsxmaw0NdVPWLCb7vnXv9xkeDxuhKgZPFGEuF9rAKVmbPZSKioqiEQiSJKEJIlEo3JWc7PTrJZwODYLRdM0/H4Pvb29tLS0pPy0Tlp2uz0h6VIIlaFgMEh3dzcNDQ2GZmQmmK6e9FTKQoFAIGFomm6FziRLqZCYzMssWfouEong9/undBRIJtCrZmYKFEVBkiR++9vf0tbWxjnnnIMgCMiyjM/nM1o9J1pzTqQZDIYmJMyJkfoBDgQCEFFJ3rMAaBGVUDCI3W7DbLbEWXX5IIPEdrnS0nL6+lxp19jT05OStKaaNCeTmZ+qtWW73+TMsV4Erg/x0h/ymTL/vBDIlwcQHw/VX1DpRoFMNWaaa65f34qKCs466yw2btyY035yDi5N2RtEI71g3ejPY2ShW3b5Pjij+x27Y03TGBkZwe12M2fOnJTW7VR2FvX29qIoCq2trTPqZpwszGYzlZWVRm1ochF4vCu/r2KqwibpRoF4PB4ikQjd3d15GdWbCjMpcx4Pu93OY489htvtZtGiRdhsNqzWWDguE4915kXkBcAsoQkKQhz3aAJgFuM+FPe7AnidiqLQ09ODJEnMmzcv7c0wFaSpC304HA5qampmlMuTbyQXgcc/5P39/ciyjMvlMh7yfQWFijXrZWN2ux1Zlqmvr0+w8vOZsJtppKlfX1279x//+Ad/+MMfjM69u+66i1WrVk1NTDMX3HffL+nq6uS//uuWiT8sAQ4zWkgBRQNJAJsU+3uMK57qZ/mFXgNZW1s7JnufjHy3Y+qhgImEPjLBVD6UUxWSSK4NbWtrQ9O0hDbP6YjX5RuFbqPUXedkK19P2PX19Y07CiSbY8wU6F1XX/rSl1AUBb/fnzA+I/5z4yHvpPn3vz/Fww8/SHt7GyUlJSxatISLLvpCik/qZJdmgSYBSk17PiIIDAz0cflXLmXz5tcKVrbicrkYGhoyaiAnQr4sTX1ukD7ne1+yqnKFIMTmRlVVVY2pX0weVTHZNs9CJ80KTZqpuoFSJewmc30VRZlRpAmxl/C///1vXnjhBf7v//6Pe+65h8rKSh599FFOPfXUjJTX8so8v//9g/zud/dz3XU3sH79IZhMJl555V+89NKL2GyJQqcZ3R+i/iEtLz54pnVY+jEVRcHj8WRVA5mvMb66bNt4oYBPOpLrF1NJs8UrNuWy/0Kh0FZZJsdLJX0XDAaN66vPKddbPZOv10yzNPVwwU9/+lOuvPJKXn/9dTRNo6Kigscff5xNmzZlRJp5OyOfz8u99/6C//zP6znyyE3Y7XZMJjOHHbaBK664KuGzb731JmeddWoCD55xxkm88cZrVFRUsH37Nq697mrOO/8zXPyF87n/1/cBcON3rgfg058+gk2bDuO9994F4Mknn+Ccc87k058+gquu+mrC7I9DDlnFn//8Rz772dM4++zT0TSNO+74CSeccDRHH72B88//LDt3JtaLxtyUCIIALS0tWbl9+egs0jPI+tygImKYsCd4tDa0sbGRuXPnGjHR/v5+2tvbGRgYwO/3ZxQ+mQ53eaYfz2QyGV13c+fOpa6uDkGIjb5ub2+nr68Pj8djaEFkqnAUjUb53Oc+x+rVq3n66acB+NnPfsaJJ57IBRdcwNVXX2189vnnn+fss8/mc5/7HO+++65xnO9+97uce+65XHXVVWkHE+rn6/f7Wbt2LTabjdraWmBPwiyj65DRpzLAe++9SyQSYePGIzP6fGz9ie65LMu43W5+9et7OPHEkzliw1EEQ0E6OtoBuOXmW7n8K5fy97+/YFiMmze/wEMPPcCPf3wHs2e38Lvf/YbvfvcG7rnnfmO/mze/wH33/Rar1cprr73C22+/xSOPPEZZWRnt7W1xsUIBVY3NLDKbzYhi9srykyFNXajYbDYbggK5opAP4UxMTKUqvYlXWZ+oi+aT6J5ng3jpu+Sqh97eXn77298yNDTEmjVrOOWUU2hubk67L5PJxP/8z//wyCOPJPz8yiuv5LjjjjP+rSgKd9xxBw8++CB+v5+rrrqKhx9+mM2bNyOKojH+989//nPKuef6+R588ME8+eSTdHR0sGvXLkONLFOBn7yZMbHZw5VZxRr1+1Jvt9JPymQy0dfRjcftwl5iZ8mS/cAnQ3iscPFf/vJnzj33AubNa8VkMnHRRV9g+/aPE6zNCy74POXlFVitNkwmE4FAgPb2tlH3t5Xa2jpjHbpYrCgWrndcH0fR39/P3Llz89JVtK8i13OLnzo5d+5cGhsbkSSJkZER2tvb6e3tTbCSJnOsXDBdiaB8Qa96qKmpoaWlhcsuu4yDDjqILVu2cMYZZ3DiiSfi8/nSbltfXz/m57/4xS8499xzeeKJJwBoa2tj3rx5lJWV0dDQgCzLhMNh3nzzTY444ggAjjzySN58881x13rttdfy1ltv0dDQwM0338yf/vQnbr755oxnJeXN0qyoqMDtduUUN5TlmCqPbsp/5ctf4w8PP8iVV32F+pp6zj7ls6xesw7MY4msr6+XO++8g7vvvjO2Ry12Q2zf+hEmIXZT6CY4wOrVaznzzM/yk5/cSl9fLxs3HsWVV34dszmWaIn9XbjZ56qq0t3dnVDKpO9jMgK40yFquzfBZDIldNHoA9N6e3vRNA2r1YqiKAUrm9nbLM2JUF9fzwknnMAZZ5xBU1OTMRsrU5x//vlceeWVeL1eLrroIlatWoXb7U7IdpeXl+NyuUYNtpigj8PhwO12j7vv7du3c+ONNyb8LBgMZry2vN0NBx64DLPZzObNL0z4WZvNTigURpZlFCVGsi6X0/h9c1Mz11xzHfff+ztOP/0sfnT3jwkRTZk9qq9v4D/+4zr+7/9e4PHH/85Dv32E//31n1g6ezF4Y+rwHpcnYbzGZz97Dvff/xAPPfQnOjvbeeCB+0f7xvPTkZFpyVEkEmH37t2UlZXR3NxsPJz5yMBPV8vkVGKqzknPGutWkl4poSgKnZ2ddHd3T/ns870hppkt9BeOKIpZ6SMAVFVVATESXL9+Pdu2baOiogKv12t8xuv1UllZSXl5OR6Px/jZeKLfwWCQ73//+wSDQcOr6Ovr4zvf+U7Ga8sbaZaVOfjiF7/Mj350Ky+++DyhUBBFifLKKy/z85/fkfDZlpY5RCJhXnnlX4iiyG9+8+uE8RcvvvQ8brfbcKkgxpcVFeWIokhPT5fx2dNPP5OHHvodO3fuwOv24h9y88+XN6MpKpoSIy8tFMXvj7kGH374AR988B6yHMViMWMyxf7E3PHJ13xmSnher5eOjg6am5uNGyR+H5NdQyqEQiFjTlC+sS+RtJ4UsFqtzJ07l/r6+jEJD6/Xm7c5V7D3u+fpjpFr7axOjrIs8/bbbzNnzhzmzp1LW1ubIdgsSRJWq5U1a9awefNmADZv3szq1avT7lef2RRLVMc84tLSUnbs2GGseSLkteTovPMuoKamhvvvv4/vfvdblJSUsmTJfnz+85fw2muvArFgrsVi5uqrr+VHP/o+P/iByvnnX0hdXSymUVJSypa33+L+3/yKSDhMXV0d11x1LVa7DQQ484zPcvnllyDLMrfddicbNx6F1+vlO9+5gb6+XkpsJRy0/3IOXX2osS4tqhIOhKC8gkDAzx13/ISenm4sFgvr1h3MeeddBOSnJXOiqZZ6/NLn86UVS863pam3f7pcLkRRHBNwB7jmmmsmdbxCoVDEEk9iqdo8/X6/MRI5vs0z1/VNh3s+1bXO2cwH+vrXv877779PSUkJ7777Lm63m507d6IoCieddBKtra0AXHHFFVx88cUIgsA3v/lNADZs2MBzzz3HueeeS11dHbfeemva44iiSEtLC88//zyLFi3CbDbz3nvvZTUZV9ByeDo/+OBDmpszG2qvqvruY/OCNA0sFvOorBtjvjhN0+jv05M4STeRpoEgUFNbY8QgAaLRCJoGzoEhBO9YwtJEEMot1Dc1omkqkUgUk0lCkkxxu1YJ+APIsoyAgMVmYWSkn8WLF2V0njo8Hg+hUChlYDt+0Np4Ysnt7e00NzfnLOvV1tbG7NmzMZlMqKpqxOnq6+u57bbbcLk8BAIhorJCid1GeXnMqvrqV7+aU/+xnkDJx0jm8aDHf9MpT+UTkUiE4eFhQ/kmHfQ2z0AgQDAYzHlMRW9vL9XV1TmNR8kFw8PDWK3WSXeZjYfOzk6amprGeFLTjVdeeYV7772XJUuW0NPTg9Pp5Oabb54Zyu06dKKSJAmzOXbImDU1NvYnCEKaRiFt1HtOJTcnxOKRooAmCQhK0gfMIoIoGEmnGDHscU00TcXr9iAHIghqzOIMBiOEgkGCwWDGWbU95zX2PZQ8TjeXfWS7BlmW6ejooKKigurqan7wgx8wOOjkny9v4cOPdqKqGvX11Rx5xBpmz6rn5z//OWeccUZC69xMak0sZAgg02Mlt3nqik3xYyr0Avvx3OF9LREEM2s+UDwOPvhgGhsb2blzJ2eddRYLFizIavspJ02dqHQpt3ikvS9TdlgKo5YmacgWJJMJxa6hhRQEObZzzSyAVRqdtS4nKCTpCAZDyP4ISjhqxEEFSUSNyHz4zvusWr8m4/NNRXj6sLdMWzFh8gQRDAYZGBhI6FkPBsO8/e5W3v9gTzH/wMAIz/zjFT7zmWMpKYlpg8a7n7oi+ydtbEUuJBZfu1hVVWXIsvn9/oQ2xNLS0jHXcl9OBM0k+P1+XnnlFZ5++mkWLVrE0UcfzWuvvYaqqhx88MEZ7WPKSVNV1ZRENW7SRf+xmvR7AVDHxrUEYbROrMROSNFQSvYQlyjESnisdhsWS2rXJxQIIgcjaLKKMLqdpmgoEYUP3nmXletWZ3yDxZNmKmX3bPeRC2RZNmo+43vWfb4Au3d2j/n8sNOD0+mhuroiQWVI31cgEOCuu+4CPfERi6sYcdBCPux707GSZdn0a+lyuYxRvfrv98VE0Eyaea5f3zfffJMnn3yS+fPn8/HHHwOx7Pnzzz/PwQcfbAgVj4cpJ02LxZzSopzw/tCNSTHu36PWpyzLSQQYIxl7SQlyVEYMRxHU2IVSBTCXWCkpSV8jJkflBMKMmbOAqjHcPzTuiFo9ydK2YzchfwBHTSXlFeXGOF2bzZb1ON1cSVPTYjODotHoGMKM7RekFLWuELPSU8FkMnHf3XdTq4SYFXJjU2W6bRU4VSu3/fCHXHTJJVmvc2/AVIQCkkeAxCusB4NBhoeHKSsrw263F4TQPknuuU6a/f39zJ8/n02bNhnzvFRVzWoCwjTqaQrp3XMt7n+U2GfR/9IgEomSqk1UFEXKK8sJhyOEgyFAo6zEnsbSjTucpsXEQZJioYIAiiwTiURSkqamaXzw7nt8+PLbSANhJE2gy6yi1FvZf+1y5s+fn1J6aiLkcjPrNYV6PDLVPioqyli633x6egYTft7S0khFeeqXym233casqI9jhj6mQomVKylueKViHh+W1fLb3/6Wz3zmM0bP/L40PG0qSSW5zbO9vZ2SkhL8fn9GbZ6TxSfN0tSv39y5c3G5XDz22GOEw2FGRkb46KOPskouTtudvaf3PAVEAaJqbLCaRYx9Th41Pa3SmCJ0QdgTH43JhwmUlGWevRREAc0qQkjbExIQQTOJmCzmtMXqw8PDfPjPLZT3aYjErDrRHcQ9PExXVTvLly/P6Phj1pOlpRkOh+ns7KSuro6Kigq6urpSfk4QBJbu14osK3zw4Q6CgRDzWmexds0BVFSUpXwwS6IhDvT2GoQJMbnT1Z4OOuyVBM1QWVlJOBymrKzM6D1OVlzPx0M/ExNB+URZWZlh8SQPS4ufe56PF9JUW5p6a/RMiWnq57p06VLa29vZvHkzJpOJL33pSxxyyCFcMuoxZULy02oOpLsvRVFElTSwijHyVImptkt63VyytmQs2BnL0kcwmcxZveEsFjORiIJmkwweFwQBIQoVNVVp27/aduzCNBgxCDMQCKAoCiWCmeCAG6fTmVMZTjakqY8PTk4ypdu+tNTGurWfYul+raPtgmZstlHCT3GDWzSV2ujYnmGbplKuhBlUSow1x2sx3nbbbSDL2LUoZk0lIJiQRRNI0qRqQqejTrNQiD9e8rC05DZPnUDtdntO65zq89P3P1MSh3pS6oknnqC1tZUHH3yQ/v5+Ghoast7XtLrn6SxNq9VKUA7E/qGPuIgLNyYToiCAoqgoijqmnCgTlDrKiEaiEFYQ4ixNTCJrjzg47Rcf9AaQ1FjbpN/vx2QyUVpaSiDgR4ioOXffZEKa4xXJj3ej7hHy3RPDGa/tU0XALdmoiSbKbUUR8EkWSPFy8nq9mOUIzREvS/yDlMoR+qwOPi6tY0S18Mtf/pIzzjjDUFyfKQ9WMmbKuuJfSLrcXfzcc5PJNK6uZSpMtRU4EwWIIVbJ8vrrr7Ny5UqqqqqMZzQbke8ZGXiSTKOK7dJoQkYftqaBoCUTSqweURdZyEVsw2y2UF5Vic/jQY0qIAiIJhGbYGPp/kvTblfbXE+P6WOi7gB2e0zoVlVVVE1DKzPlFM80zmoc0kwW+UilwD3e9nusDCHBTUvVFugRzXzoaGJW2I01bp8fOBrxS6nDH/feey9zI16OH/zI2GZO2E1D2MfzNfNx+/3Y7faEh14Xux0vpLKvu+eZInnueSQSMVoLo9FoRnW2hbA0ZyJpNjQ08Mgjj+D1elmyZAkmkwlZljn00EPHla+Lx4wkTVEvcA+MPsQCsVijJIB5j2yanoGMKQONrYjv6Gjnv//7u3g8bsrLK/jOd26mpWVOymNarVZM1VVEo1EkyYTJJBHpC4x7Y1VWVxGpM1MWETALZmOtfofGfksX5DwmdTzSi0QidHZ2UlVVlbXrPzbOpCEIsa6ttKepqXRYyvlb3adYGBjCosp02SrpsFfiSyNdYI+GWOIbTCBZgDlhFzXRIG7JZjz08QXh+pzuP//5z8Y2F1xwAXV1dVmdZz6wN6lEpdK1jK+zzdcIkGxQiOx8NtDv+erqao455hgjcSrLMkNDQxx44IE0Nzdn9L1PK2m+/fZ7PPqXJ+no6GLOnNmc/dnTWbliGRoa6C7jaBxTTw5pUixIbrGYR8WCLQijZUjJ+OEPv8eZZ36W4447gaeffpIf/OD/ceedv0y7npg8nWnCBJKqqsbgqeM/cwqvvfAy7j43QlhBdZioa5ifVUF8qnWkIk09ptXU1DSuzFa67ZNrSPWbQ69zTbM3ZE2l01JGj8WBGYUQEmgqel1Y8rYWTaVUHRuaEIBSOfHn8QXh999/P8gRKtUoIhoaAr/79a/AbOGKK66Y1hjj3oLkOlu9zTN+BIheFzqVmImF7QAbN24cd975E088wdFHHz1uF2ABSDN17PKtLe/yk9vuoqKigqbGBkaGnfzwh3dw3XVfZ37rHBAEBEVBC8esIE1lNJPOaGGwxXDHNU0dk1QaGRlh27atHHPMXQAcc8ynue22H+B0OsfphZ1Y5SjVON0TzjyFkZERIpEIDoeDvr6+SWU4Uz2sIyMjOJ3OjIesjfdQxMeb9Jt7vGfIBJjUKDIiiiBg1qJIgkCU0YqwJPgkM/0WB3NC7oSfRxEYtJSmjIMCWKJh5oXdLPd0UxfxM2Qp5V1HE21Uceedd3LGGWegaRo+ny+n6YjZYCa759kguc1Td+VlWaa9vX1S0ybHw0wqN4qH7m1B4nOmr/fxxx/nyCOPHHcf0/YqeOSPj+FwOKiocCCKIhUV5TgcDh7542OoqgKqhmYWwW5Cs0ixyZSSEPu5oowWt+snPZbsBgb6qaurN744SZKora1jYKAv7ZomMixiiu/t1NXVUVtbG2epCdTU1NDU1JQXAYRki7Cnpwe/309ra2tGhJnOQortMxbL1B8Q/fqMd+7C6LWVBDATc7tivQbCni6hOCiSmY9L6+i07tE1jCLwZkULHlPqrqzbbruNGiXEUcPbaI74MKPRFPFx1PAOauUAyDLNzc1IkkQwGKSzs5Ouri6jJGcqSG5vtDTHg14bWlVVhdlspqWlhbKyMuN6dnZ2MjIyQigUmvT1nGnuuQ49EaqLfcf/AdLWZMdj2tzzjo4uGuoTY1UORxkdHV2xB9okgl+OuekCECFG8aWmsZPP8/jdpLpXNK2w43TjBTc6OzspKyujqakpp1bOsT9XEUXBiGPGk3MqmDWFiCBhRcCkKQgaCCLIiKhJ8nM6KioqGB6K8GzNQmqjAUqVMAOWMjySlYAmUm5PTZytgZExcVAzGvMDI3SVx15GJpPJiHHqtYzDw8P84Q9/SNhuslJ3+3LSyWgxTtPm6XQ6CYfDRptnaWlp1p7TTLU0gZSWpo5IJDL9bZTpMGfObIaHhqms3GONeL0+5syZHTspAbBLsaJ2RQOLAJIYUzJK7klnLNnV1zcwODhg9JIqisLQ0CD19Y3jrGrsRVRVlZ6eHoCCjdMVBIFIJEJbWxsNDQ1ZtXjpSPUgxhOkJO05D0WJEWmqbaKiRJkcISCIhEWz4ZtYlQg2QcCfYptIOEyFGsYtSLjN5bHvTpMp1VTqlAheJXU8VkpDHqKmGi5RqlrG+++5h2o5RKUcQBVE3JKN235wK+sP38DKlStzEhopZCJopvSdJ7d5hsNho1lBVdWE2tCJnoOZmj2H1GSpr1WW5QnXPW2kefZnT+fWH9yOIAg4HA68Xh9er5cvf/kLe+obxVi2HBOjXuVoVn2srTnmZ9XV1SxatIR//OPvHHfcCfzjH39n8eIl42r7JXcpaZpGW1ubIa1WqBs7GAwa9Ze56CumW2ey2x/7G2KlRxomU6qbRQBRpCEaQhHFWJ2sqhIVRdxiasWmUMCHJJhYEPVRHgmiiiIWVcFlttFvdRAKp65fbbNXsczbnXBTqkBbSTVqmhv5th/+kHkRNxuHd1KphAHot5TyYtV8Xv3nZlpbW42OGr3FM1MLaF8mzYmOl9ysoKoqgUAgoc1Tv56p2jxnap0mwEcffWSMydbVu3T923PPPXfmWporVyzjP//jCv7858fp6OxmzpzZfPnLX2DlimX09/ftaWfco2Ec+48KmDK7wa699pvccst3uf/+e3E4HHz72zdnvD5VVVAUmdmzZ+VcOpQtdFWkQCBAVVXVpARp07l88cSpu+uCMP5D5BMkVLMNCyqiphE0WwggoiCmjI2IqopFlRkx2fFKViRNRRUEIoIU+15TFNMfccQRvPqPp/lnVSsrPN1UKBE8koV3HLMYNKdOHg0ODlKhRljnbDcIE6Ah4melp4fNVfPo7+9n+fLlxnjZTMtw9mVLM5d4oyiKCbWh8aGReAIqLS1FkiQ0TZvQpY9Go1xwwQXs2LGDW265heOOO46RkRGuu+46/H4/hxxyCFdeeSUQm3d+9913IwgCN9xwA8uWLUNVVW666Sa2b99OfX09t95664TSiw899BBbtmzB5/MRDsfmlEWjUX7/+98jiiKnnXbahNdiWkuOVhy0jNWrDhozLtdms8U6goJKLPsgjTaXh1SwSTELNAPMm9fKffc9kNWa9FiirmxUKMLUVd0tFgu1tbXjjsyYCJlYERl/XtNA0wgIJgIQu/aaLjmlpQwCq6NyfA45hCKIaIKApKiYBQWXyZaSAMvKygipUT4oaaDDXoVVVYiIEj7BRCTio260pjMef//737GpMvVR/5jAyuyQE7M2l+eee46DDjrIKMPRO2oCgQCPP/44Xe3txjYLFi/m1FNPzey65BEzxT3PBsltnvpLqaenh7vuugtFUTjkkEM48cQT09YTp5p3fu+993LmmWdy/PHHc9lll7Fjxw5aW1snNe9chyzL/OIXv+CRRx6hubkZVVVRFIVoNJrV9Zhy+3ncrOyY32lEo5FYokUkRpCqBkEZwqOEaRLGeud5RKwkQcVqndwo32ygxy/Ly8tpbGzMy9zzdNsnB8H1zKGmpRErEAQQNAxtvj3KKLF/p+gv1iQTQdFEVJQokSNURwLYVJmIKMWszRRQFIVKROaFXXzK001fYJgRTw+Lg8O0AL5AYMw2dXV1KIKAkuJ7CkhmtNHPJEOSJO699158uz5maWCQdZ5O5oVdDHz0PrfddhtDQ0NTOnkyGXuDpTke9NpQfZrnFVdcwcKFC3nuuec45phjuOCCC9ImJpPHwrz11ltGyc8RRxzBG2+8kbd559FolBUrVmAymQgGgyiKYoQhssE0dwQlxtgSMlcKMeK0S6CN/kxktJ46/zezfnwQUgiC5La/TG5Mn89HX18fs2bNMgpqJytCrB8/FdK5oqqqAOmK+oXYpdfUWOocFQEBDTF1uYEsEwXcogW/zYqIiiyIRBGJIIA61op+8cUXsWsqGhpDlnIO0mQ0yUwEAW005pq8/iOOOIL73/43H5fWc4C/36BOFfi4tAGvZOJrF1ww5lh//etfqY742DS0g1kRr7HNe2UNvFnewssvv8xBBx2E3+/H7/cbsbtcZzZNhJkY05wMZs2axcknn8wFF1xAZWUl3d3dGR8vEAgYJFZeXk5XV1fe5p3rL4tvf/vbHHbYYVitViRJoqKigmOOOSbj85tW0tSvo6oqRndPbJrj6DjfoAJWyeg7JzIqF1eSatm53wT68S0WS15G3OqkN96NoosXu91u5s6dm/BATvaGTkeM+t/JCSFNS61wNLolEHO5RUFDBGSkPaSc4lgmFEqVCF7JTokWBS1mDUYFkUo1jEscG/IIBoOUoGFXoiiiBJqAJox+9QIIjI2DWiwWAmYbb1bMxm+yMDc4goLIzpJadpTWIKepCd3x8ces8w8bhAmx4xzo62dXSQ07t23jsMMOMzqV4ls89bhdPoVG9kb3fCLoJUcWi8WYJJkJ7Ha7Ue6kzzDPx7xzHYcccgiSJOF0OnG73fj9fhwOB8ccc0zG38O0957rIhHxYhuGey4K4I7AqIeoCUCZeZyY5tj+84kgy9FxRnLkhoksRb2MSRCElGVM+bY09T7b0b0b7vie46WX6YtdExEQUAUB1ZjVlLhR/PFkJEwCtETcWOUoqhgLqSiixJClFFI8sGVlZYgBF1HJjF2JYFNlFEHEJ0loCCiCNOaaCILAGWecwaN/fJDXy2axtbQeFfCIFhAVzj777JRnVKJGqUshdycC9WEf7dZK4wGKFwpWVZXdu3fz4IMPYomEYu9xk4UjjjySlStXpruAE2Jvd8/THSOXOs1Vq1bx4osvcuyxx7J582auueaahHnnfr9/zLzzDRs2jDvvXG8/XrBgAYceeqgh7Gw2mxFF0UhYZXpNppE0tdFkhzAmSyyKUuzBsgAmc6znXBgtPxJjc3+Skf09oBGJREd7n/M7NnW8mGQ0GqWzs3PCMqbJxjR16ALFeuwoJgO3pyMolufRjJfXyMhIklq4LjMFiSHw2H5SQhLxaRZKhCgRkxlJU4lKIkHBQgBTyi9rw4YNvPTY/2KLeIiIJjQEZEFEUhXCFhNRU+qQyTuvv8p+IT8OLWp0KZlRGTCX8ObLLzHrs58bs01ElPBI1pSvWLc5lqhKRWS7du3imUf/yPywj7mBYTRBZGdJDa//42na2to47LDDDCs0G0tuX7U0MzlG8rzzL37xi1x33XXcf//9rF+/nkWLYiO0JzPv3Ol08uGHH1JfX8/dd9+N3W43rnkkEmHhwoVceOGFM8vSTLZkVFUlGo2Mliak3kYcbdWLZc9H31gasTZKIW5g0J6jGAbQREg3+1yWowT9QQJeP4IoEI1EDFchu/NNbSnq2cX4CZHZbJ/N8VVVTYiX6nEiUYxZmrIsIwgiqqpiMknG21aSJIaHh4lGo6PbCIA6KsunYkIlijh66VOv0W4yE4xG6TOXUaLKiGhEBZGgYEKGlLWyO3fuJKQItNtraA65sClRwpKJLmsFw4KF0tE4aPxNHY1G8Xbs5mR/D2UohAQJAbBpCl2mEl7ocoyGfRJjkbPmL+TjjwMsCAxTrkSMu6jdWkG/xcGyZcvGHAvgqUf/xDLfIIe42pBGz36pr58Xqxfw0Y5tlH7602PqGDPRuNwXLc1YA8XEluYdd9wx5mf33XffmJ9t2rSJTZs2JfxMFEVuvnniMsKqqirWrVtHJBJh/fr1NDc3EwqFUFUVr9dr3I8z1tLUy3ksFuuohZO6tEaVVQgpe0SIdYQUtBJhtNMnefkTu+fx8ct4seJoNILP5UULy5hECQ2NaDDMi39/jiOPPzqrJEAq0nO5XAwPD2fUhpkP99zv9xvxUkmSkGUZk8lkxGwlSUIQRGN0iH68+DKSYDCorwiEmO5QVA8wa/rPxx7barOghrwICPhEEyY0opqIhIpZI2WH044dO2jWgiwe7uTZuk9hRiWKwDz/AE3A1tKxWfBQKIRViVKqybEMrranD75aCSMosflOyd/dmWeeyU9/tIsn65ayKDCEQw4zYCllV0kNbksJRx99NAMDAwnbRKNRHGqE5d5udCoQAAsay7w9dNvK2blzp0G4utzd4ODghPPP97VEEMysNkr95fXRRx/h8Xg4+eSTjd/t3LmTt956C8j8uhSQNHV3mLhynvGIQQNZRQgrsfZJNJBjpqSG/qXs+XQm90D6+KVGwOdHjGqo2mgpDiBqAq6Peuj8VAfzsxgon5xo6e/vJxKJMG/evIxupMmQpqZpuN1uZFlm/vz5hustCAJr167ln//8p+Ge6R6Angw66qijiEajRhmSzWaLeeQKoClICJhQCQt6GUMsjJJ8o5XaStC0IcrDPoYsDhRRxIpMVciPx1o6pswEYnHXiCAyWFLLqUMfURMNEBRNdNir2GWvQmXsNbHZbMgWG25NpCQSMtwZQRQZsZcjmC0pJb40TWP5sgPZ+u4b/Ku8BRsqASTKTDLrV69K+B50uN1uzKqKQ4mO2V9VNIgIxnRDiNUxVlZWGhqXmzdv5oN/v4ElGkYWJOx1DZx6+unGC6rQpDnVhDaT2ihdLhfbt2/n0Ucfpbu7m1WrVuH1emlpaeGZZ56hq6uLz3zmMxkTfUFIU1W1UfUQKck6TD+RMjbsTIKAvGeoGsTm+KS8v/SMdarf7RErThW/VBQFVVaRGLtrq1+j7eNdWZOmXjjb2dlJSUkJLS0tGT8YuZKmfjxRFI3+Yd0VEwSBjRs38vrrrxONRkev+55jWK0WVq1aFVOeH/2jKAqIJlAioy8rAQUxpp6v21uqytDQEKIoGq6wo6aacE8bQbOdKjWMRVEIiyaCZjsipCx2rq6uJhLyoiEwYCmjy1aBqKkEJTNBwYSSIo5tNpsx1zfzvrOHVZFubJqCBgRVkXdsddQuWprywe3r68P1/lucPbwTm6ogoKEgEDZbeW6LGdey5WOuf1lZGRFRwinZqFYSR38MWkpRiCUxUuGxxx7D9/H7rPQPUBfx45WsbI0GeOi+X7LppFMNQYxMZm7nA7GQzNQ++jPJ0oxGo2zbto1t27YRiUT41a9+RTAYxO12I4oiF154ITDD3HNFkbFYzCTP7hHGiYtJkgnZpKGVxhJBgDFcTRCFlHOCkvGzn93OCy88R29vDw888DALFy7ObMFxXr6gz0DPAoIgEA6H6e7upr6+PuuxF7lYHeFwmK6uLmpraw3XOp4wdVx77bW8+uqrvPTSS0bX0zHHHMNBBx0EYMhmQezGt9ttKJEQsgaaKI3qZ2qIoxfFUuKgoqICj8djlOU47DacZjOVQW8szigIWDQFOwpBW2XK0pCDDz6Y5x7rxiNZ8JosWFWZsBgrUI9KEpWj1zD+XFRVxdvXjWIp44WaBTSGPWiCSLutEp9oxjI0OOY4AB+99x4tnn4cakwXFGJxbikaotE7xI4dO5g9e3bCsWw2Gz6LjbcqZnH4yC4so+cfEkTeLp+FW7SmfBl4vV7c2z7kmOEdNMeVOM0PjPC3+v14e8sWNh19tHG/CIJguPG5CI1kgqm2AnXNypliadbV1XHeeeexatUqwuEwBxxwAD09PVRXVyeIeWe63oKQptlsTmlR9r+/m4/+8jL+fiflzbUsPvlgGg6I1XSVOkrxjLhjde1xiSBBi5UkJbdewtiymcMO28Bpp53B17/+1TGEHQ9JkhAkETUiG/OGIGa5+S1R9l80L6vzjUajDAwMMGfOnKy7DSB7S1MvqdATPqFQCJfLRVtbGyUlJZSVlSXE0tavX8/69esn3K8oiqxds5Z/Pft/lKkKqqIiCDFvXdIgLEqsW7cOSZKw2WzU1dWhqirhUAhl50cMA6ocxaTKREwWSmw2ymtqqaysHHOswcFBUGQGLaWUqbGS9pAo4TVZY6W55rG3aldXF6UhP6cMfMCAxcGukmoE4FDnbqKCxDNjYt4xuEeGqVPlWORBVUZfkgIWAUxylOBo91EyYZ1/8aU8fO/djJhLmBt0oooi7bYqRiQrF42OgE3GM888Q2PYQ1McYQKUaVEWB4Z4rasjZjGPuvPJ8mzJPd35QCHG9ya/rGcCFi9ezEsvvcSdd96JpmlUVlZyyCGHsHhxhsbUKKat5Kj//d288YvHMdmtlNZXEXT5eOMXf2XNl0+h4YBW7PYSIqURwoEgmqzFOvkkAdFioqKqMsUeE2Ok0WiUT33qQCyWTBI4Ala7DW/QBYqKMFpNo6LhskapqavN6Jw0LTYhMhwO09jYmBNhxu8rEzidTpxOp5HwURTFEJhVVdVQTBoYGMBsNhuiC5kmtpYfdBDvvvIy/kAQqyYjaSqaIBIWJUpKy1i2bBkulwtN04we3nmtrfTtmMdqaweSquCLKpSoCoOiiWDjrNGXaGIcLxKJMEf2Y1ZkesyldFgrsCoyC30D+C0lBFRlzDUZHBxE0hTMwOyIl9lxxDRktiOMWjzJD6/VYqHLWsEi/6AhR6cBEUGkx1rO4qqqlNff6/VSa7WgyUHeqJiNhkBNNEi93RqXNEtEMBikVgmnjCiVyRFMqpxglcXLs8myzN/+9jcGt3+EJEeJSiYqW1o57oQTcDgcOZPSVMdQZ5rCkR72ePDBB3nxxRc57LDDaG1t5eWXX+b73/8+V199NcuWLZuJiaBEbHv8FSxldkwlMRfE6igxfq5bmxWVlURK7ISCMSVpi9WCzZa6E2PPj/bEL7Nph5QjUURNQLHoOuUCRKBkRGHXtp2sWpe6cFaHPiHSZDJRUVExqZsmE0tT0zT6+vqIRqPMmzcvIeGjXx9RFI3MIcSIyefz0dvbi6IolJaWUlZWNm53i9Vq5fQLLuLZ/+8x3AP9MStFkpjV3Mxxp5+F2+1GURQaGhoSYqjLD9vIR2++QXSwhxKbSp9kpnLeAj61aAkul4tQKJSQUS4vL2dIsrDaP4gNDVkOoAlQp0Zo1+zYasZmz+vq6njPZGPEZKdGTiStDlslEcmU8rzq6uvZts3Oe6WNHODvx6qpBASJLY4mPGYbc+fOxe/3j9n23X++yCpvN61CFCJO4+fbvD7efulFZp8zVixi4cKFtO/6KGadJ/2u31KGbC9L+7A+/OtfUTLQyaG+firkEEPmUj6IhPjjAwMcefyJhgVaUlKSVYxyql3nmTof6MMPP+Siiy5iw4YNQKwN99vf/ja7du3aO0jT0zNEaX1VwsxtS5kdT89QwucsFmvGxeeqqiHL4dFK/8xdGU3TiITDaGEFUdmTTBJk8O8YZNt7H41LmvqEyOrqaqqqqhgYGJgywQ2IvTm7urqw2WzMnj0bIGX8MhkWi4Xq6mqqq6tjoQe/H5fLRV9fH1arlbKyspQq3TU1NXzm4ksYGBjA7/dTWRmLS/b29mK1Wmlubh4TazSbzaw54ki8Xi/hcHhMuY2ujKNPTYxGowQtJXTZylk5qqkpI/BxSS1DVgfL5swxro2OpqYmQhYbL1fN42BXOzXRACoCu+3VfFjWSMWslpTXQbLaqDQLDJVW8kRJNTYlSlAyYxEEyu22hBCNjmg0SmBwgBZi+gTxmKeFeGeoP2UiZ9WqVbz74nNsKZ/FCk+sXEkFdtsq2Vlaw4ajNqV8WD/88EPMQz0cO/QxpaOlVI1RP7PCbv4mLsXlcjFr1ixDJFjTNINEJ5o6WQj3fCaSZnV1NU8//TR2u53q6mrC4TB+vz+j9st4FIg0x5YXlTfXEnT5MJXsIcSIL0h5c2aucDJi2V41x+C5FovXpVCEF0MqXld6IQA9ntjc3GzIyOWjOD3d9jpB19TUUFFRgaIoOcWQJEkao9Lt8/no6uoCMNx4/XoKgkBDQwOAMYZDL6lJRvz8oZqaGiMTr/+t789qtRolQaqqolaV0iE20GGrokwJE5QsRE1W5lY6qK6pGXMcs9nMqkMO463NL/D32iXYlQiyIBGSTMi2Uk467viU527SFOodDgJ+P7PDHlRJIGRSiZSUU+KwGa72mOs5mhOMyjJKNEaeJosZVUzfhidJEidfeDF/feA37LZXUxfx4THZGLKU0nLQag444ACGhobGbLvljddZ4h8yCFNHlRJmdsjFe1veYtWqVYZIsC53pyfkLBZLWqGRT5qlqa9l3rx5/OUvf+EXv/gFZWVlfPzxxzQ2NvLkk0/yu9/9jm9+85tGB9J4mDZLc/HJB/PGL/6KqqjYKkqJ+IJEfEGWX5C52kgMsViaqmqjBdvZv0EFIVakrUkCgpxIVlq5GdGcuq1uZGQEl8uVUnAj3oLOZT2pSDOeoO12u0GYk71B9ZpMm81maHn6/X6Gh4cJh8PY7XbDCo1Go3R3d9PQ0DDuGOF4JGfk9VCC/gdiVuPu6iaOtw8SUBS6gzIlgkalKvO2PRZCiEbH1kjOX7SY9vfeIeBxEpJFNAEkk5U5S/ZLSegA9opKLDYLS0rN9IXLiKoqs8wm6swC/xZi0xkDgcSZ92azmbKGJrYN7mJuwIVJU9GAUEhiV1kd5c0tab+HhoYGvnjtN3j33XfZtm0bFRUVnHTkkYZFn+re0qIRbOrY8wUoUaKoSQPt4qdOqqrK7p07+fjN1wh43JjtpTQv3o/W+fMpKSmZcktzpsU09XPduHEjgiAY4anDDjuMxYsXY7VaCQQCNDc3Z7S/aSPNhgNaWfPlU/joL/80sufLLzjGiGdmgng5ObNZQFESieq2237Iiy8+z8jIMF//+leoqKjgoYf+N8WeBEwmE7JFi1XsKaPJARGEOQ4qqyoTbjJN04wLPxWCG6luaKfTycjISELCBzIvk8gGelw2vjNITyZFo1Gqq6tzlklLnoIZb30uXnsw//7XZpplF802AZ8gsc1eyYFrD8FqteJ2u0drTDXDDd36xqtssCnYSypwyyqSIFBtgneHe+nr60v5IMyeM5d/vV1OycBuSnyxJJa5pIQuRw3MbaSyshK/3z9mO6msnPdK6jEpMvNCLjQEOizlvGerZWHTrAnPfdmyZUbHUDxSkWbz/IX0dG1nv8DQmI7/LlsFs1vnpz3Oh++8Q/CDf7OcMGWSgDfg4+MtTt73uGmc3UI0GsXj8WSVEMwGM80916/vCy+8wDPPPMOcOXMoKyvjD3/4A0cffTSXXnppVsMSp1XlqOGAVqoWN48uOLs3n96/rscvY5ZdIlFdc811XHPNdRntz1ZiJxhVUa0C2qgYhShLlDvKWbLsU8bndNc0fu55MvKpUhTfUdTa2mokW/TjTDUEITYaQn85NTc3EwwG6evrQ5ZlI5lUUlKS03rirdDZLS1UnXQane1t9Luc2B0VrGhpweFwjCb2zAQCAUpKSvD7/bS3txPu68YhRDBLFkqte+KJLXKI7l07UpKmIAhEJTPvKCZaJBulSoT2qEhvWGTd4qXG9xd/Poqi4GnbyXrFzTZHA+86mkAQqEJhhexi985tcMghOVzh1KR52GGH8dBbr/NBxMdS/wAmNMKIbClvxmVzcMoRR6Tcl8fjwfnx+6yXIkijZXZVZonVmswrXW3UHrQiVt4FDAwMIMsydrs9J6GRdJhp7rl+fe+77z4ee+wxQ/fh6quv5uSTT+aUU04xcgOZYNql4bIR2tAR37+u32yT5Q+b3UY0GkUORBDU0VnIokD98nks2X8/IFY+orum402IzId7DrknfPIJTdMYHByMlQTNmYMoikYgXVVV/H5/QhxNj4Xm0nEiiiIOh4P9DzjQcOPju5P0BI3+kJtMJrwWE0QFgsEgmhbrdDGZzJhFASUSTnmc9l27mBcYprW+nP5oGRENFooCi9DY+dEHtLTEEkjx19jj8SBFw8wTosxTncbrWQBCaHzkSR/3ngipSNNisXDceRfx90ce5qNAPQ45jMtsJ2x3cPI556W1jAb6+2gIe5CsiaRlEgTqQ14GBwcRBIGqqiqqqqqMsrR4oRF94qTVas2J/GYaaeprWbhwIc888wyrV6/GbDYTjUaN0FM2mHbS3NMVlAkJaEZca+w4ivQtmZmtQ6S8opygJUg0Eqs3tCg2jvj0JkwmE263m8HBQVpaWiZUPYoJKec+4wdiD1JbW5uR8NHJo5CEqaoqvb29mEwmZs2aNea4Osk5HI6EZFJ3d7fhQpeVlU2YzU2FZDc+HA7jcrmMGT+qqmKz2QhYShAIUWq1gqYRHR2U1RkBzVaK2+0eUxEw1LaLAyUNsygwO8461TSNj13DowSceDNZrVYUyYwXEUdMVdSAEzMm29ge90yRrtSlqamJz191DV1dXQwMDLCyqYmmpqbx96VqiGkeBFFTx7Q3xpelaZrGru3b2frGK4S9HjBZqJ+/kMVL9zes/Uwwk1oo4/GFL3yBX//612zfvh2r1crrr7/OySefnHXH3rSTJpCRpanHL8f2ryd8apIrEUbFSS0xK8Y3giRJ9Pf3EwqFaG1tnXLBDYhJyOnueD4TPtlAlmW6u7spLy8fd+yxjuRkkqIo+Hw+RkZGjM4WPZmU7QOltxg2NjYaiQz9ejTt9ynefesVPiVGsEkiJkliWJNwNTSy4lOfQlGUMSU5mpaZFxBPZCUlJThmtfBe0MXaqBPT6L0WRuB9WzWzD1ye1TnFY6L6wNmzZ2fsPtbW1/Oh1UGrllhnqmoaAzYHy2trcTqdKbfd+v57+N55nTVCGIdFJKiE2LZ1C2+73cxdsp8xaDBRbzX1+cxE0lyzZg0HHHAA27ZtIxwOc95551GToipjIkyLnmbSb5mI7JLHYaQ7Rn4ggDFaQaOjowOr1cqcOXOmXHAD9kjIWSwWgzBhahI+6RCJROju7qauri5r10WHPnslOZk0PDycMA52vIcPYi8QXRNUt/DjrdD9ly3nY5OJ1z94F1skSEQQMTfVs3z1OsM6ii/JcbvdUFpOe3eYxTYRU5zWpVPWkOqqDZHaZKw7chMveFz8Y8RKczSAKkCXuQxzy3yWH7Qip+sEE5Om7mVkUh1SWVmJfe5C3t/5PvOFCFYggsh2zYxjvyWUl5enJM1gMEj/h+9xiBTBNBoLtUsiy0SNN4d7KS1dRVVVlVFVoY/tTTVLPhf3/KCDDuLAAw8E4Itf/CJr167l+uuvZ2BggEWLFvHd734XURR59913+d73voemaVx++eXGELZMYbfbWb489xcczABLcyIeShW/TLOnSbnn8euJyaWpyLJCXV1F2tKV9PvInjQ1LTbzPBQKMW/ePHbt2jUqFFzYHl6dpJqbmyfVBhoPPZmk17FGo9GEbHyq/niIxRFHRkZoaWlJm+UVBIH9PnUAC5fsh8/nQxRFwxqNL2mKL8mpqKjgVfcI5oF2GsJ+JMAlSOwsqWHpQSvj4uSJ172qqopjzvoc2z78gN723YiixJL9P8WChYsmlYVOR5qRSITtH35I19YP0OQoJVXVtC5bMUZMJPl6LDzgQP410M/HnW2YFBnFYqP5gANYv3J12vtyaGiI2ogPk1kYs7+GiJ+hvh7q6urGjO3VmxP073h4eBiTyTRuzD8VZs+eze9+9zvj3w899BAHHHAAl156KTfddBMvvfQSGzdu5Pvf/z533HEHZWVlnHfeeWzYsKHgVu20k6Yu6TYWqfQ3J0IeWJM9ZTCSJGVNmJA9aaqqSldXFxaLxUhClJWV0dbWZnTqlJWVTfnN4Xa7cTqd45JUPmA2mxMSEYFAYEx/vCzLBINBWlpaMtM4NJlSflepCustFgtrNh3Lrq0f8lbbLlRFwVZZTdPcVkKhEH19fQbhJh+7rKyMlWvXwdp1+bocKUlTlmX++X9PY9u6haVhN1ZNxdlp4eOuNiJHfpoFi5ek3Fc4HGbLi8+x1NNLY40VDRshVWNr507adzUzb8GC9BUfaZ6x2J08tqxOnyWvrzcQCHDPPffw6quvcsABB3D00Udz1FFHMXfu3AmvQW9vL+eddx6NjY3ceOONvPnmm1xxxRXAnlG+69evN1p2IVas3tbWxoIsZBvzgWknzVQvzHTjKAoBRVFRVQ2bLXdZrmyy59FolI6ODqqrq6msrDRcsbq6Ourq6giHw3i9Xjo7OxEEIWO3NhtomsbwcCwBomfIC4V4V11PJvX39xMOx9phh4eHJ+yPn2j/8YX1+h+r1crS5SvYb9lBCIJgvCTiLah4qbaJ4niTQSrS3L1rF9rWt1keHMQuxpovqpUAZQO7eOvll5jTOj/li62zvY06Zx8tlj3foUUUWKaGeO29t5mV5vutqalhh7WMqOzCHDe4UNM0+sxlLJ6g8FsXGvnxj3/M9u3b6ejoYMuWLfzP//wPP/nJTya8Bv/4xz+orq7mT3/6E7fffnvC2N7y8nLcbjculyvBgtV/XmgUjJHGi2vG/zzdOIqph2aI80pSbPpirsjU0tRnBjU1NVFSUpIy4aMnV+rq6pBlOcGtnWyNJOwp1BdFcVy3r1AYHh7GbrczZ84co6QpuT8+V6s7mUABw6LUqzJEUcRqtWIymZgzZ05Cd1QkEjHKnVKNrcgVKUnzg3eZH3LFCHMUkiDQgIzN2cfg4GDKGtSRrk4WiArJlqFNFCgNx0agpPqO7XY7zQccxNtvvcpCNUilJOBXYacqYV24OKVWaDrYbDaOOOIITjvttIy30fd/4okn8sgjjzBr1iw8Hg91dXXjjvLNtm88H5gBlqZgZDPzOU7X7XZx883fobu7C5PJREvLHK677lspM8HxnUUmk0g0OrlyofGmUeqInxlkNpszSvjoLqhukQYCAbxer1Ej6XA4UgpupIOiKHR3d1NWVkZVVdW0Emb8WvQHKLk/PhQK4fP5DKtbf2nkojegX2e9aD7eCo215cb+TpXQ0kk0fnhaNh0lqZC8/rDPhzlVL7sgIKlaWik6yWRCTnPrKYI4box80dKl7LJYeGPLm4R9XuyOcuYvX8H8BQuzur7ZlhwFAgGsViuSJPH6668zd+5cVqxYwebNm1mwYAGbN2/msMMOw2azIUkSAwMDlJWV0d7enpHrn29ML2l2bEN641mk4X7UqnpYdQSW+fvnZdeCIHDeeReycmVMnejOO3/KL37xM2644TsJn0vuLJpsJ49+7HT7SU74CIJgEGY2N2Yqt1YX3NAJxeFwpHUp9Qx5bW1t1kH7fEPvZ6+urk5bMxcfQ4u3uoeGhgwLUC9pysUC1K1QWZYZGBigpqYGSZL2jP0Y/YwuCqyvO354mr4Gm802aSu0tKaO7t5SZkcjCeZDQBMYsZSwKk2pTH3rAro6tlOrRRO+d5esIldV4nA4cLlcKbdt27WTzrdeZ27IjRmZ4YiJwc52WubMzWoia7YlR7t27eLGG280wk633HILVVVVXH/99Zx33nksWLDAkHO7/vrr+drXvoamaXz1q1+d8rEdqSBoObDEBx98SHNzdgyvD+8y0LEN8enfo1lLUC02xEgIIRxAPe5cmJOdkrKO8cbtPv/8szz22J/4n//5hfEzRZGRZSWBWGJiuhEsFiu9ve0sWrQw63VEo1F6enrGvAXjEz719fUJ+pP5tPJ0QvH5fEQikTHZ6WAwSG9vL01NTSkHjxUSyTWYuUDTNCOZFAgEkCQpIfabKaLRKF1dXWNKreKTSfrjIgjCGHdft0KDwSAmkylhhO94SGUxdXV18eZf/8R87wCtsh87KiOCmfeslcjzP8Wxp52R8p5RFIV///MlLO0fM1eUsYoCg7JKm62a/Y88hrKyMjwej5FM0TE8PMxH//c3Vmk+rHETSndGwb/oIFYcnHmL6K5du1iyZEneqi9mGqbN0hTeeA7NVoJqjT20QmkZiELs5zmSZrruIlVVeeyxP3HYYRuMn+nCD8mZ+XxwVypLMxqN0tnZSVVVVULCZypKiuLdeJ1QvF4vAwMDCEJs5vmsWbOmnTBT1WDmgvhkDewRW9az4PEvjXTXejzyTqXSFN/eqROoHu/UVez9fr8xN0lfX6bdUbNmzaJ/1Tq63ttCt98bi3uazGj1zRy26Zi0+5AkiZWHHkbH7BY+2vExciRMeX0Ty0dVnwKBQEoruHPHduZGPFjjOqQEQaDVrPFy526CB63I+H6ZqR1B+cL0uefD/ajlVYiiiKrrWNpKEJwDkyocStVddNttP8Rut3PWWWeTibL7ZD305Oy53rOenPApRA2mTih6DZ3P56OyspLBwUE0TRujm1koeL1ehoaGpqS8KV5sOZP+eN3yzqQ2NZ1KU7zknSiKmEymMWVV+hqsVuuEiuuCILBy7Xr657bSt3sXcjhEZdMsZs+dO+EaTSYT8xcsSDlBNZ0sXMjtwiGljqGWqDKhUChj0pypHUH5wjSQZoy0LNV1SEE/mEoxOnBCAbSqsTOxM8fYL/1nP7udzs4OfvSjnyIIGKUs6ZXdJ+5QmnAVcZam2+1maGgoq4RPvqErJamqyty5c42HJpVupsPhyGtmOBWcTicej4c5c+ZM+cOVrj9eF1u2WCwEAoGMNAXS7X8irdD4cIGedNS1UTVNQ5ZjpJT84hIEgcbGRhobG/NwJWJIV0hvr6zC06eRHFFWNI2AZMqKMKd6BtF0o6CkGau/jCVdWHs0PP372C/MVgj6IehH23hqzvtPds/vvvtOPv74I3784zswmaQYWReglEm3NAcGBggEAkbCZzo6fBRFoaenB7vdPkbKLlk3M1WReT41F+MVk1pa0ov2ThWS++NdLhdDQ0PYbDa6u7sn1R8P41uh8Yr1ZrM5YexIe3t7yrlJU/FCSadh0LJwER/s+pha1YctLqa5KypQOX9+xvFJvYWySJp5QKwWTt5DWnMWox53LsIbzyEM96HVNMYIM8d4pg7dPd+1aycPPHA/c+bM5bLLLkbTYnGiW2+duNB2stBjWoqiMGfOHMP6KDRh6lnpqqqqCevZkuOCukXW09MzacUi2FMPKklSSsWkQsPlcuF2uw0RluT+eL2cSA9d5IJ0hfXxVqgoikiSRGNjo2EJx7cm5ruwPp17Xl1dTcu6w3jtzdeoD7qxqDLD1jKEOXNYsWLVpPe/L6GAxe3i2HbIOYvR5iwmHA5hteYj07bHtZ4/fwH/+tebo62YwpS2BcZDT/iIokhjY+O0SLoBhEIhenp6cs5KW61WrFarIcUWr1iUbXmPXjVQWlqak6pMvjE8PGy45Pr6c+2PzxTpkkn61Et9/LHFYsFms1FTU2O0JsZf98kW1o8Xb5zXOp/Gpmb6+/uJRqMsrKxMK7SdDjNNS3MqUDDSzKTge7KI/24zk5LLL/SET2NjI319fcbDUWjC9Pl8DA4OMnv27EkXXUN6xaKhoSFMJtO4brwsy3R1dWVk7U419PBANBqdsPspk/74XEMXOqmEw2FGRkaYNWtWQk2oft+kK+5PLqw3xyk1ZXINxvuszWabVMF4kTT3QmhaZlJy+YbH42FgYICWlhYsFotRxO5wOApar6YnWVpaWqak8DfZIkuepa6Tic1mM8ID9fX1GQ9hmypoWmxOvCAIY0YOT4TkRgL9nHt6elBV1WgkyCZ0ob/YkqsH4pNJyYX18dM7UxXWZzKy4pM6vjef2MdIU0BVFVRVy0BKLj/QrZdAIEBra6uR8JkzZw6BQACn02mUa0ymYyWTdegzXwqZZEk1S93pdBIIBFAUhdra2mmvB1VVlZ6eHsPtncx9IQjCmNCFfs56ImeiZFJ8uVXyi228ZJL+/3ocNL6lNn5kxXiF9VNNajNtEuVUYIaQph6LnBzJ6W/lzKXkJlrP+FBVle7ubiRJYu7cuQlZUl31RXetgsEgXm9sRovZbMbhcOQ8SyfVOnp6erBarVlbUfmE7k4KgkAoFKK+vp5QKER7e7tRduNwOAoWX4Y9Pe0OhyMjBfpskc6FHhkZSalKpWuEZlpula6kKbmwPrm4P76wXldbt9vtRUszD5gRpDn57zDmMsVuIIHJkm8m65FlmY6ODioqKqiurh63JTLZpU2epaOTSS4ZUj1mqFsd0w09K62PGtZ7yZPdeD0znavkWybQr814Pe35RLr+eL3MSh+9nKlGaDImKmnSP5OqsF7vCFPV2PA5s9k8JeGbYkyzYMh+IqWO+NpPXXF9qhGf8CktLU0Q3MiEAOLdu+QHKxu5N731r6GhYUbEDIeGhgiHwynDA6m6dHTJt8nWR6ZCuj7yQiK+nXV4eBiPx0NJSQmdnZ15qYPNpbC+u7vbGJgXPzcp11KyZOzrLZQwQ/Q00/WMTwR9rKte+6mqSl5GXow3OiM54ZOLQlE8Usm9xbfb6XJvyTei7n5Ntm87H4hPsmRSg5ncpZOcFc5FbCMe+RABySd0gee5c+caJJdvyztTK1QQBCorK43uNH1uUnx752ReXkVLs4DI1tLco72ZGL/MX1VT4o50S8rn8xkJn8kSZjKSs7SpyMThcBhW2pw5c6ZFGiseelw3VcdRJkh2afX6yP7+fmRZjk2BdDgyJpNs+sinGvo9E4lExrxMUlnebrc7QWw5G23UZKQqrI9Go0QiEaP5In5uUnxhfXxDQ2lpaVa6BKqqFjRmPR2YIaSZTb/3HsENiyXRwop9sfnQw0z8t55oEUWRefPmjWmLmwqkIhOv10t7ezuKolBVVWXc+NOV+JmKeGpyfWQqMkmn3O73+xkYGMhbfepkoFczKIoyYXJuov74yYqqxERxVPr6+qivr8disSRk4/XPxBfWx1cF6COYM2nvLCaCCoRM74M9s4NMab+4eEvzG9+4ht7eHgRBpKTEztVXX8fiNAOp0u0nm4TPVEKSJILBIA6Hg5qamjGdIoUQ2ohHPsb8ToR0bnzyvCSr1YrH42F4eHjK6lOzgS6QAtDU1JTVfZLcH59KVCXb0jVZluns7Ez4rpLd+PisfLrC+kzaOz8JMc2CiRADeyTgRiFqEcyEEdQoKhKyaEcVUlsImcwO0t0O3crw+byUlcVUyTdvfoFf//oefvOb30+4zpgFJ9LX14koCjQ0NFBWVlZQSbd4yLJMd3c35eXlY8pm4oU2/H5/SumzfGMmiBjrbrzP5yMUCgHQ2NhIWVnZtPY+6z32JpOJurq6vK4lvhvL7/dnFP9NRZjpEJ9M0tWKYE8sVCdpncj9fn/C3CSLxcLQ0BDV1dXU1dVN6lz/+Mc/8uijj2I2m/ne975nTGmdCSjoKzk+GSRqEaz40RDQBBERFSt+whpjiFOWZVRVmXB20J6EUgw6YQL4/b6M38yCoL+BZebOnW8kfKbD9ZjIoot/68d3q3R3dwOJrl0+kO8WzVyhu/H6g15ZWWmsLR8xwVygZ6d1KzHfSNcfr/eKJ1deZEOYkHlhvSiKKecmff7zn0dVVTZu3MinP/1pVqxYkdP1d7lc/O///i8PP/wwH374IT/+8Y+54447st7PVGHa/Bgz4dE5yyKgoWoCoqBhJkwY/WHUjCmBsQd04rd2st38/e/fzOuvv4qmwW23/SyjtekPoslkSsiQF5owdWXzTJMayd0qqcqZskmqJMPlcuFyuWaMC6y3ELa0tCAIguFKJs9Lmoqxx8nQE2KlpaVZTW6cDFL1x+uD9kwmE+Fw2PCSckGmJU06kT/yyCM899xzbN++ne9///s0NTXx85//POvjvvvuu6xduxaTycSyZcvYvXt3TuufKkzbnS+iJA2nj5UcicS+jNwEN8Y+EN/8ZmyQ2lNP/Y2f//wOfvKT/xln+z1jfHVSyHeGPFO43W6cTueklM1TlTPpSZVsaiOncy56uvXoMnPJMcNUMcH4F4eejZ/M2ONk6CpOU9V1lAniKy+i0SgdHR2UlZXhdDoZGRmZtLRfplqhixcv5phjjuEb3/hGzgI9brc7QdxlqoV+ssW0kaaKhIACScSpIo2ZEJkdUl/g448/kR/84P/hdruoqKhMuV0sKy8hSYn7KCRhThVBZVrOlKpXub+/H03TZsRc9Gz7yCcaezzZ+K+iKEYFwXSrOMGeiga98QLIqT9+IqSyQoPBoNH5BLk/N+Xl5Xz88ccJx5pJmDbSjGIdjWmqgIAwaneGVBNROTpGcCMUCuL1+gCMDOJ4iD0cHhoaYqMC/vnPzaPZwLE3dnxXkShKo0XzURRFNW6yQol/9Pb2IorilBJUunKmZKUii8VCb28vVquV2traaSfMyfaRp1Ir8nq9Ce2s2ZT2KIpCZ2dnwdo0J4LeBZWsKjWexFz8Nck1fCGKIuFwmN7eXmbNmjXphoLly5dz1113oSgKW7dunZbZ5uNh+ixNwUJYi8U2RUFGVgWCsgVZk7BazeyxQGOxK1EQsFvNIAhEwiEGAn5qa2vTWqKhUJAbb/wGwWBwtIi3nB/96PYxN8XYrLxm1IAKgpCgUjSVZT06IegxsUISVPL4Bb3ExefzGeQ63XNf8t1HHh//jS/t0YvRJxIdzjbJMtXQCbOhoWFc0kr1wtQl5jI571SIRCJ0dnbS0NAwZjRwLqisrOS0007jvPPOw2Qy8f/+3/+b9D7ziYKWHI2ZfW78XCUcDmMymTCZEt3D4eEhJFGgoqwUUYp9iZqq4fEHCIWj1NcnDmLLRgVez8rvSTIlLq63t5358+enLOvRVYryUZOmZ8hra2txOBwTbzDF0B/AmpoaJEkqaDnTeOspFEElf9/JqlTpLLrpQqaEORF0ibn4856oPz4SidDR0UFdXR1NTU05H3tvwrQXt+uucUxObewXo6oqjtI9hAkgiAJlJXYikSiqquQQ94RoNAIQVzaT/t2RXNYTDofxer10dHRMWvJsJtQ8xkMfkxG/nvhyJq/XOyYrPZW973ofeSGvz3hlXHo7Yn19/Yzoa88XYQIpJebG64/XE041NTWfGMKEaSbNeNc4Eomm/IwAmE1jSVGSYoHoUChESUlp0hbjiX/sSfiYUux3IsRnZ5PjgaqqZhUX07tYprvmUYcuApJqPanc2fgZOpMtZ0oF/YUynaIk8eddVlZmjO7w+/2MjIxMubj0eNDnUU2VMEm6/vjHH3+cv/3tbyxfvpwjjzySAw88MO/HnsmYNtLcI7ihF6yntvQ0QJZVLJbEG1JVVNS4rgUd4z2vyQkf0HKWpNORHA/UZ+eMVxepaRojIyP4/f6CzP7OBHqJU6YiIMlZ6fgecT07W1ZWljORzKQ+cthjgc+aNcuomY0Xl85kXlI+MdWEmYz4ltaTTz4ZgPfff58bb7wRURT5xS9+wZIlmbUo7+3IOabZ1DQna4tC17tMNSEyXSyyr68Xu81KRVkpgjGPGXyBIIFgaDRwvScOGImEMZvHZgFTJXzGI8yY3Fkn8+e3ZnWOe463p7wlGAxis9mMRNLAwACapmXdlzxVGB4exu/3M3v27ElbS3p21uv1Gq1+ejwwUyLR1c1nz5497UX0sMfinYjAdXfW6/UmeB35rr7QCXM6Qjq6FkN5ebnR2rhr166El8m+jpxIc9euXUiSFYejIqubQVVVwuHUBevjkaYoiphNElarBQGBcCQaK0IHLBZrgsJOzJI0JfSny7KMoihxMnLjn7Kmafh8HqLRILNmzcr4/MbbXzAYxOPx4Ha7MZlMVFdX43A4ppUU4pV4porAdSLx+XwJQ8jShS905ffZs2fPCAtc78rKtslAr0LQe+Pz5cZPN2F2dnZSVlbGnDnZG037CnIiTf2LCwZDWW2nqjFV9VQXW5ajKRNBHo8HQdArOfcsVUCIZePREmovFUVGFPfIpcU6erQ4ks7kdAWsVgsNDQ15IzV9MmNVVRU2mw2v14vP5zMSKvq4i0JBV+82m815F5ZIBz184fP5CIfDY8pb9Hnks2bNmhEFzfF99pNxt9MJbWSbPIxEInR1dU0LYSqKQkdHByUlJcybN+8TS5iQI2nmCj3zmAo7duxgwYIFY76M237yYxyOUuLF3TVVw2634vb48PqDXH/99cbne3p6qKysxGq10tnZSWlpKTU1NdMm6QZ74mGp4k+66ILX6zUylNmOg80WehdLKtWkQiG5rEefXTNTXHKv12sk6fK9nnjrO9PvfLoJs7OzE5vNZghwf5Ix/XfnKERRTFlAHYnKRCNRbFYrs5tqsdusdPcP4fb6EFJkyAVBIBwO09PTQ3V1NS+++CI9XV1owKLFiznqqKMK+qVPpAoUL7qgu3S6TuZU9EnrJSrTXROql/WUlJTQ09MDxGYnxZczFdr61qHHVHMdgDYR0o09TtfiON2E2dXVhdVqLRLmKGYUaaabL6KqGg5HKYMjLlQVykptmE0mXB7XmM/KsszAwAClpaX84aEHaW6s5fC1B6IoKtt3d/HLu+/ikksvK8jD6HQ68Xg8GasCJbe7xfdJjzcvKFPMtNk5qfrI48uZ9JEXhZhcqUOPqU4VYSYjVYujbuVKkoTdbsfj8dDc3DwthNnd3Y3ZbC4SZhwKrKc5vuS/HvNMRiQaYXdHt9EV5PZ6iSoqFouZcHiPuz8yMkIgEKCuro6HHvody5fM5/C1yw0iXrbffP7+0hv8+te/5vLLL8/vycVBT7DosmW5xOfSFdTrD1O2GWk9oTETBrHB+H3kU13OlA4jIyP4fL6cv7PJIr7FEWLfmU5afX19BX156C80SZKYP3/+jIgxzxTMOEszFSJRhbISGxaLeTQDDlFvgLAsA3umIcqyTE1NDV6vF7vVwooDliR82SaTiZWfWkRX78C4a1EUhb6+PnxeL1arlabm5oyJRr/ZrFbrhLNhMkVyQb0eE9MHYE00Nz1+FMRMGHqVTR95qpEXk3l5pIOuLJWPsqt8IBKJGFl7m82Wcl7SZD2PdNC1QQVBKBJmCuwVpAngC4TwBVJn69vb2ykpKaGxsRGn08nOnTuxmMyUl411QasrKtKOy4BYAuCtf7+JhIJZhIissGvXDvbf/wAaJ2gVm4pBY6kQHxObSGhYt55mShH9ZPrIky2x5JfHROVMqTDexMjpgh5GiRefTjcvaWRkJK8xYP2lD7BgwYIZcc/MNOwV7vlEqKqqory83Cgonj17Nju3b2XE5aW6MjHZ0Tc4Ysj3J79BNU3j1X+9TJkF6mursFosRGUZj9fP5hef56RTTksbC9Rv9IaGhoKKOKRyZV0uF319fUDsuhYqPjcR8t1HnpxQ0eXO4suZSktL0953ehhFVdW8eQWTRSrCTMZ4Y49Tjb3IFLo0oaqqLFq0aEbcMzMRe42lOR50wtRn+MyZMwevN8Brb3/A0YeuMly3QCjEm+9vxemOdaskZ4+Hh4dxDQ+ybN1BNNRVYZIkNE3D5fEx7HTzxuuvs/GII8YcX+/Znu54oW6NlJWVGTOCzGYz7e3teVdmyhZT3UcuSVLC3Bo9iTYwMJDy3PWQjiAINDY27jWEmQqpxh57PB4jgTje2GMdOmHKsszixYuLhDkOCk6agiCklK+fDGkmj6SQJAlZkdm2q5OhETfzWppQFIXdnb04XV4kATo6OmhqakooMP7Xv/5FVaWDpvpqwwoVBIGqCgcNtdU898qWMaSpz83JtGd7qqEnWMrKyoxZNfEKRfr4W93VK0SMs9B95KmSaMmjfwOBAFartWCF/RNBJ8zJvlTSzVBPHnscH//WXyCRSKRImBlg+p/yUUyGNCHR9RdFEbPZjNksMTjspKd/CAQBq8VMWakdf3BP33t8MmX37t0snJu6nTAiR5HERNENPY44E+bmwJ6uo+QES7JCke7OxSu1ZxsLzBTxNY/T8VJJnhmkd7NpmoY8mkgsVEY6HfJFmMmYaF7S4OAgnZ2dHHDAAdhsNhYvXjxl39FMHsmbLWYUaeo3cbZIdbNrmoqmQXVVBTarOTZKIxLFHwiBECsvWbx4cUIyBcDt8dPVO0hL8x5xY7fXR2fPAOpoC6begmgymRKSB1u2bOHjrR+iRKNIJjMLFy9h5cqVBSHUbGKqyQX1ybHAfBXUx9epzgTrRVVV+vr6qKysTJA702PAuqhKIWXepoowUyE5/u1yuXjmmWe4/fbbWTza+HHeeeflXeh5po/kzRb7hHueCpIU08v0+QMEQ3sm6FnMJhRVZcGCBcZn9ZtpxYoVfPzRB7y/bRc9/UNUVzrwB0MMDDnxB8KEwxFkWaa7u3tMC+JTTz1FyOdi7YGLqa2uZNjl5p0Pd9DX28tJo1JaU4VsR/3GIzkWGB8Pm0xN5NDQEMFgcNpqHpORamJkunKmQsm8xcvNFToWrs+huu6665g3bx5btmzhpZdeore3l0WLFuX1WDN9JG+2mFGWZj5Js6q6llDAR3N9DZGojCAIWMwmXF4fcjBMXV3dmG3q6+t57bXX6BscwW614nSDLCu4fX6GXC7MokRbWxsNDQ0JSaT+/n6cQ/2cefwRlJbEssLVleXMaqjj0adfpLOzc8rcEf0hz0cNZnzMK7kmUieRiZSZ4pWTZsL0SshsYuRE5UzZDl2bCNNJmACDg4P4fD4WL16MxWLh8MMP5/DDD5+SY830kbzZYkaTptPpzHl/Z599Nvfc80v6hpzY7TZEAZweH4FQiHPPPT/lNtFolLrqCkZcXjxeHzabDUVR8PoDNNZW4QvEJL4GBwfxeDyGK7dlyxYWzG02CFNDQ0CgxG5j0bxZvPP221NCmrr7OxU1mKlIJH5yo26hxSd2xptHPl3IdWLkROVMkwlhTDdhDg0N4fF4WLJkSUESczN9JG+2mBb3PBXiSVOftR2JRHI+jslk4vLLv8y///1v3nnnHVRFYd68VjZs3JjWhY2p7Wgcsf4g3F4fw04PNpuFBXNn8fHODtzemGxZclujy+WioaIBVVFQVQ1dfk4QRSxmM9EJYrWqqrJt2zY8Hg/l5eUsXrx43BsrPglVKPfXYrFQU1NDTU1Nyt7w0tJSY/xDJvPIC4F8TYxMV86UTUmPDp0wp0uRXr9fC0WYMPNH8maLGWdp6q6UzWajpaUFq9VKOBzOeZ9r1qxhzZo1GX2+srISRVH4cHs781oaWb1sCcFQhG07O/H4gujJ8+S2xqGhIdratnPQ0oVIJglBiD08iiyzu7OH5tnp1d97e3vZ/P/9mQr3EFVykDaTnXcqatlw6pkph1XFz0afrg6W5ISCx+Mx2u5MJhN+v3/KRh1niqmaGDlROZNeD5qKkKabMEdGRnA6nSxevLigFu5MH8mbLWYUacqyTFtbGzU1NcZbfdOmTTz55JMFWcPChQt5/rlnsFnNuNxeBoZGEASRErsVj88PYurLtXTpUt7Z8m9ee+cj1hy4H1arhVAkzFvvb2NgxMWBK+tTy95FIrz42J9YPbSTuYxa1YqX9gEXmx/7E6df+qWEh0tPZkzHbPR00LOwjY2NOBwOQyMzXVF5IaBLqU21mlOqcqZkC1zXyQyFQhmNzJgqOJ1OhoeHWbJkybSMpTjnnHM455xzCn7cqcCMIc1QKEQwGKS1tRW73W60Ou6///4FI81oNIokiQy73NRXV2E2mdCAEZcHXyBAiS1165/L5eLAA/Zn1+42drZ1U1ZqxxcIIogia1csp7urM0FYQxeb3bp1K3WegT2EOYq5RGjzDLJ161aWLVsG7Olrr6qqSpvMKDRS9ZFP1ajjTDEdI391pOrMcTqdBAIBFEWhvr5+WmpVnU4nQ0NDLF68+BMzx2cqMSNimk6nk5GRESwWC3a7HUVRjJZIiFmAO3bsSLm/gw8+OG9rU1UVu83G8iUL+fcHW9E0QFMptds54chDefZf/057TnablfM+cyp9/UMMjoxQW11FY30tHV29iDaZefPmJYjNlpSUMNDfR13En3KfdREfzuFhYI/lVOi+9vEwETnlc9RxppjuBEs89HImk8lEMBikqamJUChEe3t7xpUI+YDL5WJoaIhFixYV/CWyr2JaLc34hE9rayu7du0yWiLj42Gnn346Tz/9NO+9917C9ocffjjr16/P23qi0ShyVMFut/CFz56IIIgIgKIq/Pu9baha6pKo2tpaPv7oQ8LhCI0NtTQ21Brn1903wPxFS8fUBAYCAUTJhFMwI0d9iKKYcM5uk41Sh8Po2U5VgxkKhejqaMc7NITN4WDW3HlZZYhzRS595LmMOs5lTTNl5C/sWVNLSwsWi8X4bpIrEabiBQKxbqyBgQEWL148I0Sn9xUUdEYQxEpA9OmQ3d3dWK1W6uvrUVWVzs5OVFVN2xcdmxK5ZxhZPuHxeBgaGuJfL79EeamN+XOaaaqvQVU1Onv66eobxB+SOefc81Juv3PHDvp7u9hv4TyqKivwBwLs2NWBIppYuXJ1yochEAjw13t/wQbnbqq1SKx6QBBximZeqprPUedcYIzWTb4Ww8PDvPPCMzR4h6lCwY9Al7WceesOpXX+gjHHyhfi+8jz4WanG3WcTVdOIBCgv78/b2vKB+IJc7w1ybKM3+/H6/USiUTy1pHl8Xjo6+tj4cKFeX9WPukoOGnqsR69dq6yshJN01AUBUEQkGUZr9eL1+sFYn3B5eXlU/YwaJrGyMgIfr+fWbNm8cRf/0rQ76WpoQaLOWaIh6NR+gZGKCl1cOLJp6RMamiaRm9PD+3tbfh9XqxWG82zZjOvtXXcJMjWrVt55+knmOMfpFKO4JQstJXUMGvVOhobG6mtrR1z/qqq8uLjf+FAVzdV5j3EElI1XpcqWHPy6VPyoEz1PPLkmekmk8lIJKU7Xr4mRuYTmRJmMvQXiM/nMwRFsiln0qGHQRYsWDCtc6D2VRScNP1+P21tbcbMEz3hk2pKZDyB6nGw8vLyvLlfurqLpmlGMfYz//d35s9p5L0Pt6Eqcmy2usnMyoM+xdadnRy24Yi8u39ut5v3330H/8gwpVXVNM2OuXN1dXWGFRJfUO50Omn/x+OsEseWYu0Ma6jrjmS//T+V1zXqhfSFnEeul/N4vd6UQrtTOTEyV+Q6Jz0Z8Yk0v98/YTmTDr2Laf78+QUJ1XwSUXDSjEajhEIhzGbzmITPeFAUxSBQWZYnrcyjhwdKSkoSirHfeP115jRW0dhQh9cXS9I4ykpxujy8v62NQw87fMpKfeI1HhsaGhKOoxeU61aE9M6rHGCLFV7Hr6YnouD81HqWrVk77rF0q1GSJOrr69PGJjVNM0ZBTOc88vgXqKIomM1mQ2FqXyPMVMhk1LPf76e7uzvvhHnZZZfh8XhQVZWvfe1rHHbYYQD87Gc/41//+helpaX88Ic/pLq6mpGREa677jr8fj+HHHIIV155Zd7WMVNQcNLU36DJGpjZQE8k6HGg5FKeiaCXylRXV48p3xkeHub9d7ew8sD9qCiPuTZ+f4C33tvKvPmLmDV7dtbrzQT6XJZMOmqGh4d552+PsSo0gqopmExmzGYzJpOJD2UJx2HH0jp/fsptFUXhnddfw7N7G3URP7IgMWRzMH/1eloXJMZC4/vIZ0pbJOwp0rZarXmNA04GhYyrqqpqzE0PhUI89NBDtLS0sN9++7Fq1aq8l6S1tbUxb948nE4nF110EX/961/Zvn07P/rRj7jnnnt46qmneO+997juuuv4wQ9+wLJlyzj++OO57LLLuO6661i4cGFe1zPdKPgr2u1243K5jGxpLohva9NvIH1W+ESZWL0sJV3hc01NDYuX7M9b723FYpYQBYFAOMKCBVNHmNnOFqqurqZ0znz6dgeZbwFFVmJlSb4AXVWzOXi0TjCVVfjxB+8hfPwOh5oVRIsAKISiTv796mbKyssNIZOZ2EcOeyZGtra2IorilIw6zhaFTkSJopgw9nfVqlU8+eST3H///bS0tHD66adzwQUX5O148+bNA2Jz6fV76s033+SIUUHuI488kt/85jcAvPXWW3z9618H4IgjjuCNN94okuZkoZfNdHV1JZThZGolJiP+BkrWR0y2QOKTBuPFhZqam2lobMTj8aBpGuXl5VP2AEYiEbq7u7PqjxYEgYMOPpR3BIF/dbdTKYbx28uJNtaycvVaIpEIbW1tBoHo0m6yLNP78VYOMSmIcdfaJgrMj3hp3/ohdXUbs7J6C4lUEyPzPeo4W+S7miBbhEIhFi5cyE9+8hPKysp466236OzsnJJj/fjHP+aiiy4CMGbDQ+yZDgQCQOwFoj/j5eXldHV1TclaphPTQprz5s0zyodGRkaMeTY6geZar5eqFlLXhtR1PDONN4miOKUTJWFPljWX7hWr1crajUfidrtjZUlWa0JrZTKBmEymmKJ9NIRFHHttKyWRnc4Ro/c/WS90OpHpxMjJjjrOFtNNmMFg0JAd1L+rdevWsW7duqz35XK5uOyyy8b8/Ctf+QpHHHEE999/P6IocvrppwMxQvR4PACG8hOA3W4nHA5jtVrxer0zpnstn5i2CHr8nBqd4IaHh42OEf13ucapdAukpKSE/v5+44vs7OzEarVSXl5eUIXuZGRq9U4EPUyRjFQEMjIygjsi4wz7sFvMWMxm4/x9qoaltDQnGbWpxGQmRmYz6jhb6IQ5XWM8QqEQnZ2dzJo1i5qamknvr7Kykj/+8Y8pf/fXv/6Vt99+m9tvv9342Zo1a7jttts455xzePHFF1m5ciUAq1at4sUXX+TYY49l8+bNXHPNNZNe20xDwRNBE0HTNILBIMPDw7jdbmOGTXl5edYEqs9w1mfj6NamXgvo8/mMTo1CxsDcbjdOp3NaSmXeef01TO+/zlxiKvRoGoLJxLuSA/sBq1i6dOmMadUcr5pgMtDDOF6vl1AoppGqj/vN5CU63YQZDoeNwYD19fUTbzAJKIrC8uXL2X///Y2Y5m9/+1sA7rjjDl599dW02fP169cb8c19CTOONJMRCARiFpLbTTQaNQh0vHnWkFlyJd6F9fl8RjG1w+GYEgKdCeU7kUiENze/gNjXQUMkQAToEO2ITS3MXbCQ8vLyScWY8wU9EWUymaZ0YqT+ktbrISdSZpophNnY2EhDQ0PBj1/EXkCa8QgGg4yMjOByuQwCTdVyl82QsXjEE2h8fDQfD4feZ69p2rTP2VZVlcHBQYb7+1E0FUSJxYsXYzabE0pZpquUR9M0uru7Dcm1Qh5X7wvX23XjW3p19366CDMSidDR0UF9fT2NjY0FP34RMexVpBmPUChkEGg4HDYI9B//+AfBYJDPfOYzk1K60R8evRtlMnPCU4UJZgLGa0HUh6xNpic8F+iZe10zdDoRX1AejUaNuOp01IPqhFlXV5dSnLqIwmGvJc14hMNhRkZGuOuuu3j++ee56aab2H///fMmfqvLmiW3M2aSwJmJ2WjIro9cjwN7PJ6MXNhckWpi5EyALqpcVVVFIBDI+6jjiRCNRmlvb6e2tpbm5uYpPVYRE2OfIE2AW265hXfffZc77rgDURRxOp0Eg0Hj5h5P9CEbJLfz6QSayqrVO49qa2tnlHDCZPrIk+PAei3kZMMYmUyMnA6kcsl1K1wX1pjMqOOJEI1G6ejooKqqitlT1FxRRHbYZ0hzy5YtLF26NEFzMhqN4nQ6DfVsu92e1zjleP3w4XCYnp6eaVEQT4epSETFxwCBMaIamUBP2s2kUifITBAklTJTvgSGZVmmvb2dysrKKRsBXUT22GdIcyJEo1FcLhdOpxO/32+UmeRr/IKiKPj9fjweD6FQCFVVaWhooLy8fEbEMAvRR55shWciqpKviZH5hk6YLS0tWVnj+XiJQOy6dHR0UF5eTktLy4y4h4qI4RNDmvGQZdkgUJ/PZ7hX+dDtdLvdjIyMGPEvPQtdXl4+KWXyySC+j7y+vr4ga0gWVUlVTD5VEyMni1wJMxnxylTJg9YmKpfr7OykrKyMOXPmFAlzhuETSZrxUBTFIFCv12v0a+diHQwPDxtK67rrm5yFttvtORXq5wo9G61L4E0HUhWT2+12hoeHaWpqmlGjGPJFmMlIdQ30RFJ8mERRFDo6OigpKWHevHl5v0cUReGkk07irLPO4pJLLgE+uRJvuWJmCBFOIyRJoqamhpqaGhRFMbLKu3fvNrLE6RI9OuJd32RXShfPLSsrG6PIM9VlPDMlc5+sCeB2uxkYGECSJJxOpxEPns456bCnoiDfhAmpdRHiRx1v377dSDbZ7fYpIUyARx99NCE+un37dt577z0efvhhnnrqKe677z6uu+467r33Xs4880xD4m3Hjh37nFpRrvjEk2Y8JEkyRrDqSZ6RkRFjgqDD4aC8vDyBQFVVpbe3F7PZPGGsMFmRR+9EGRwcHKNINFnM1OSKXh42d+5cLBaLkUTRRUWmsiNrPEwlYSYjlTLTH//4R26++WbKy8s57rjjOO644/jUp/Krvh8Oh3n22Wf59Kc/jcvlAqZG4k3TNARBoK2tjd27d3P44YfPGKHofGDfOZM8Q5IkowVT0zTjoYofwer1ernrrru44YYbsnZ9BUGgpKSEkpKShAzs0NDQpOsgdbm5mRYrTDUxUnfVYU9HVmdn56QbCrKBx+PB6XQWhDCTIQgCZrOZM888k89+9rP4/X6ee+45fvSjH/GrX/0qr+t58MEHOfvss3E6ncbP8i3xphPm66+/zr333kswGMRisbBmzZoZMyV0siiSZgYQBMFQE9I0Da/Xy5tvvsmNN97ISSedhKIoRtdMropMOnnoikQej4eOjo6MhovFY6J55NMFXah3PGk+q9VqdE3pDQXJsm75nmeuE2YhZx/FQ485m0wmFixYgCiKrFixIuf9pZN4u+yyy3j99de55JJLePTRR42f51viTRAE3n33XW688Ua+8Y1v8Mwzz7B582ZCoRCHH374PkGcRdLMEoIgMDg4yLe+9S1uvPFGNmzYkFdNUEEQsFqt1NXVJRBosmhzKgLNZR55IZDLxMj4Oel6FnpgYCCrLPREmCmEKYqiQZiTRTqJt3feeYeRkREuueQSBgYGiEaj7L///nmVeNOtzJ07d7Jp0yY2bdrEhg0b+P3vf8/vf/97JEnikEMO2euJ8xOfPc8FujL8fvvtZ/wsXhPU5XIZ7Zb5LDWKb+cEEtzXmTjKFvI/MVIfb+L1eifVzqiPXZlOwtSt6IULFxZ0DY8++ihOp9PInk9W4i15tMqWLVv43ve+xw033GBYzRdddBGLFy/mwgsv3OsL9YukOQXQCVSXtJuMJmg6pBKTmDVr1owq35lqSy5XURGdMFtaWqYlY69pGj09PSiKwqJFi6aFtPMF3brcunUrzzzzDIceeihLlizhiSeeYPfu3axZs4Z58+Zx4403Ul1dzcKFC7nqqqume9mTQpE0CwCdQF0ul1Fek4kmaCbQ+8gdDgc+ny+BoPM11iEXuFwuI8lQCGLKVBdzJhBmb28v0WiUxYsX79WEqSgKkiTR2dnJf/7nf7J06VI+/vhjzj33XJqbmxkcHOQ3v/kNFouFG264gb6+Pl555RWuvfbavTqbXiTNAiNTTdCJoPeRh0IhmpubjW0nO944H9AnRsYX+RcS6URFdNd+Ogmzr6+PSCTCokWL9lrikGXZWPvIyAhXXnklp59+OmeddRYvv/wyTzzxBGvWrOHYY4/FbDajqirvvvsu3/3ud/npT3+aENbaG1EkzWlEOk3QiUZvZNpHnhz/m+xcnEygC4LEE/l0IxKJMDAwgN/vn1TH12Sgi1CHQiEWL1681xImwH//939z/PHHs3r1aoLBIFdccQVOp5M//vGPmEwmXn/9dR5++GFWrFjB5z73OQB+85vfsHHjRpYsWTLNq588iqQ5Q6AXfbtcLkKhkEFwye5lrn3kyW18+daDjJ8Yme0AtKmGy+UypPBUVc1aVGSy0F9ygUDAUMjfmyHLMrIsc9ddd3HNNdegKArf+c538Hq9/PCHP8Rms/H6668jSRKrVq0CxiaL9mbsVaS5ZcsWbr31VsxmMyUlJfz4xz+eUd0u+UIkEjEk7eI1QcPhML/97W+55JJLJtVHnqofXrdwcyGO+ImR0z3KIxnxhJn80BYqlDEwMIDP52PJkiV7NWH29/fT0NBgKDidc845rFy5kptuuglZlrn11lvp6Ojg9ttvT2iq0JNF+wr2KtLs7+83SngefvhhXC4XX/7yl6d7WVMKXRN027ZtfPvb3+aQQw7hK1/5Sl5nFwWDQTwej9EFkk2MdaomRuYDughLJrHVqbLEBwcH8Xq9LF68eK+uT+zt7eUf//gHJSUl3H333dx+++3sv//+fP7zn2f27Nl8//vfR9M0vv3tb3PMMcewcePG6V7ylGGvIs14/OlPf2JkZCRl98O+hp6eHs477zzOO+88Tj311CnTBE011qK8vDxtP3yhJkbmgmwIMxnxwiqTUWYfGhrC7XazZMmSvZowdfzv//4v3/ve9zjuuOP4/ve/D8Su1aWXXkpFRQW33XbbNK+wMNgrSVMvzL3vvvumffhWIdDZ2cn27ds56qijjJ+l0gTNZ6+2noHWCdRkMhkEKknStE2MzAT6NcmHOn2yMrvZbM5IF2B4eBin08mSJUtmVHdWttDLiiCWKf/Tn/5EV1cXhx56KMuXLzemYl500UVceOGFbNq0aTqXWxDsdaQZDAb50pe+xFVXXWW0fH3SIcsybrc7L5qg6aCX8Hi9XiRJQpZlysvL92nCTIVUY57LysoSXlRTSZh+v59bbrnF6CZ64IEHgKnRxNQJMxAI8Oyzz7Jw4UKWLl3Kv/71Lx599FGOO+44Zs2axXPPPccXv/jFfcKazgR7Vd2DLMtcffXVXHDBBUXCjIPJZJpQE1Qvds8VuphGdXU1HR0dWCwWfD4ffr+/YGpEE2FkZAS/3z9lhAnpRUUGBwd59tlnWb16NbNnz2bp0qVTYmHeeeednHXWWUZWGqZOE1OSJEKhEF/+8pdZuHAhr7/+OuXl5Vx++eWYTCb+9re/8fHHH3PAAQcY99a+lvRJhb3K0vzLX/7CLbfcwtKlSwHYuHEjl1566TSvauZCJ1C9a8hsNhvdQrk80KkmRk5mvHE+UQjCHA8+n4+7776bl19+GbfbzVFHHcU555zDgQcemNfjfO5zn2P//fdn27ZtHHvssVx44YU8/PDDaJrGueeeSygU4qKLLuKRRx7h7LPP5re//S02m43f//73CILAOeecM+Ex9PIgTdO48847qays5LTTTuMzn/kMK1aswGq1cs0111BSUkJvb6/RS/5JIEzYyyzN0047jdNOO226l7HXIF5UWVdMdzqdCaLKeonNREgnapysRuT1eunr60NV1SmTc0uGTpizZ8+etodWlmVOPfVU/vM//5Ph4WGeffZZtm/fnnfSfP/997nqqqu44YYb+MIXvsAhhxySV01MnTBVVeXpp59mw4YNLFy4kCuuuIILL7yQww8/nK9//et85zvf4Tvf+Y5x3H2pDnMi7FWkWUTuEAQhQVRZV6Xv7OxMkJxLVaOY6cRIk8k0Rvlel3ObqiLykZERAoHAtBKmPr5j8eLFhrD05z//+Zz3l04T8ytf+Qo1NTWsX78egPXr17Nt27a8aWJqmmYQ3w033MDSpUs54YQT8Hg8tLS0cO655wLQ2trK8ccfn5CE/aQQJhRJc0K8+eabnHfeebzyyiv7TKZeEATKy8spLy9H0zR8Pt8YTdDy8nJsNhttbW1GUiMbFfh45Xu9iFzvGMpXEXn8DPfpIkyPx0N/fz8LFy7Mm8JUOk1MgBUrVrB161b2228/3n//fTZs2MCiRYvyoompX8N7770Xt9vN8ccfD8S+y+3bt/Pf//3ffPjh/9/euQdFeZ1//MPNLEgWoYhmgQABEozEKBhjvCREciNqTINp1TaNrZLpMKjjGKm2tbYmxqDMKIi3UEGnRrlo2mLVmIRQ0QAmmlRQEq8gt4iw3K/L7r6/P/i9bwBRQW6LnM8MM7LCnvPuvvvlOec8z/fJZezYsbzwwgvA0FmSt0WI5l3Yu3cvvr6+Az2NPqNtWwm5UkgW0IsXL7Jp0ybWrVvXI0GwsLBQnO/leviKiooe1cObgmDKWxGenp791rN9xYoVrFmzhqamJvz9/ZV708fHh/nz5yun5wAhISGEh4cTHx/P5MmT8fb27tIY1tbW6HQ6MjMzCQwMxNbWlp07d5KamsrYsWN54403gKEpmDDIDoL6m7S0NK5fv05qaipRUVH3TaTZFU6fPs2yZctYsWIFPj4+yh5lb3qCGo1GGhoaqKmpUdraduX5TUEw6+rqKCkpwdPTkwcffHBA5tDbtBXBgwcP8r///Y8XX3yRCRMm3FKu3DZ/c6ghIs3bYDQa2b9/PzExMaSmpg70dPqdw4cPs3nzZp555hngJ0/Q0tJS9Hq9Ep32xBPU3Nz8lvbG8nJXpVIpAtp2v6y8vJzm5uYBFcz6+npKSkp45JFH7hvBhNZVh3ygM3fuXACOHz9OU1MTAQEB7Q70hqpgghDN23L48GFmzJgxqKs5esL777/f7nv5gMPFxUXxBC0rK6OkpOSePUHbcrv2xjdv3lSS9ZubmwfcRam+vp7i4mI8PDwGtVnM7ZbWcqqRmZkZc+fOpbm5mfLy8iH7OegMsTy/DZs2beLChQtYWFiQk5ODr68vcXFxAz0tk+NePUG7ilzGWFpa2m4P9F7bG/eEhoYGioqKcHd3Z8SIEf06dm/SNj2orXi2XXIP1f3KriBEswu89dZbQ25P817ozBNUbuvRE4ErKytDp9Px0EMPodPplDLGtrmmfS2gjY2NFBYW4ubmhr29fZ+O1Ze0Fcy//OUvWFhYoFKpWLp0KdbW1u2Es+2/y8rKGDly5IDN25QQoinoE27nCdrV/u0yZWVltLS0dOpQ31kdeG9Z5rVFFkxXV9ce+ZiaEgcPHuTLL7/k97//PYcPH6a4uJiNGzdia2uLwWDA3Nxceb33799PS0sLb7/99gDP2jQQoinoc2RP0MrKShoaGrCxsVGW8bcTONkJ/naC2RE5Aq2trW2XRtXTevimpiYKCgpwdnYe1JHWuXPnUKvVeHh4cOTIEVJSUnjttdeYOXMmLS0tbNmyhWvXrvHBBx+0i6STkpL48ssv2bZt25A+/GmLEE0TIjs7my1bttDS0nLf1tW3tLQolnayJ2jHCLG7gtnZGL1RD9/c3ExBQQEajWZQC2ZtbS0nTpzghRdeoKWlhfr6eqKiorCzs+Ott97C2dkZg8HA+vXrsbKyYvXq1QAkJiaSlpZGTEzMoO5p1NsI0TQRdDodYWFhREVFYW1tPdDT6Rc68wS1trZmy5YtTJo0iTlz5vT4MEKuh5d7AskCerfTYFkwR48ezahRo3o0B1NAkiSuXr1KXFwcixYtQq1Ws2XLFtzc3AgKCsLV1RVJkpRSysLCQvbs2cMf/vCHIWP51lWEaJoIX3/9Nfv27aOxsRGDwUB4ePigb3XaHfR6PVqtljVr1lBZWcnq1asZOXJkrzomyeWcNTU16PV65aCqYz28Tqfj+vXrjBo1SjHZ7U3S09OJiorCysoKPz8/wsPDgdal8CeffIKVlRUffPABrq6uNDU1sWrVKm7evIm3tzdr167tclpXRUUF3333HYGBgfz3v/+ltrYWrVbLjz/+yC9+8QvUajUxMTHY2dmxYMGCdteq0+mwtLQcUjXlXUW8IibCzZs3uXLlClFRUfzpT3/ib3/720BPqV+xtLRkx44dGAwG9uzZg7u7Ozqdjry8PPLy8pS69Z4gl3O6urri5uaGSqVCq9WSl5dHSUkJJ0+epLq6moKCApycnPpEMAG2b99OTEwMCQkJXLhwgcLCQqqqqkhOTmbfvn2sXLmSyMhIAA4dOoSvry/79+/H3NyckydPdnkclUpFRkYGr732Gnv37mX27NkEBgbi7OzMgQMHqKysZMmSJQwbNuyWzJBhw4YJwbwN4lUxEdRqNX5+ftjY2ODp6al0/BtKBAcHs337doYPH46DgwOenp6MGzcOjUaDXq8nPz+fvLw8ysrKaG5u7tFY5ubmqNVqnJ2dcXd3x9zcnLi4OIKCgti6dStnz57ts/fA29tbiXbliDc7O5tJkyZhaWnJuHHjyMvLA1oNY55//nkAAgIC+Oabb+76/PLi0cbGhieeeILq6mpFFF1dXXnuuefw8PAgPj6eqqoqwsLCGDZsGGLR2TXE7q6J8OSTT7Jr1y6MRiNarXZI7iN15j3Zm56gt8Pc3Jyf/exn/PnPf8bCwoLc3FxSUlI4duwY27Zt68kldcqrr77K4sWLeeCBBwgMDMTBwYHq6up21m2ygFVXVyuVR2q1murq6js+d9ukdL1eT2BgIH5+fuzZs4d3332XyMhI3NzcKC4uxt7eHo1Go/yuSGbvGkI0TQQ7Ozt+/vOf8+tf/xq9Xs+qVasGekomR0dPUNmVviueoHdCr9dTUFDAiBEjcHV15fHHH1dqr++VO3liRkREcOjQIRwdHVmxYgVnz55FrVZz8eJF5efkpbHslTly5Mi7emK2FcyEhAQyMjJwcXEhMDCQkJAQYmNjWb58ORMnTqSoqEhJaBfVP91DiGYHjEYjkiQNSE7a3Llze/xhHSqYmZkpdnNtTZWLioqUPE3ZE/ROgiALpp2dHS4uLr02vzt5YkZGRvLggw8qWwQ1NTVMmDCB7du3YzAY+OGHH3BzcwPgqaeeIj09HU9PT9LT05k2bdptx5SvMzU1lSNHjrBy5UpSU1M5deoUXl5erFy5kujoaE6ePMnatWuVLA0hmN1DnJ63obO/uEPJxv9+QDZVrqyspKqqCkCxtOvo2Sk70tva2vLwww/3m3gcPXqU+Ph4LC0t0Wg0REREYGlpyYEDB/j3v/+NpaUl69evx83NjcbGRlatWkV5eTmenp789a9/veP9WFhYyLvvvsvkyZNZvnw5jY2NfP7552RkZLBhwwbMzMxoampCpVINaXu3niBE8//59NNPOXbsGHV1dYSFhTFhwoR2/280GjEzMxN/lQcRst2cXA9vNBrb5WkWFhZiY2ODu7v7ffG+VlRU8OOPP3Lu3Dn27dvHe++9p3StXLhwIcuXL+fJJ58c4FkOfsTynNYcyY8//pjQ0FDKy8v55z//ia2tLbm5uTg6OuLn59cu4bywsBCDwYC7u/vATbqXWLduHbm5uRiNRlasWMHTTz890FPqNdrazbm6urbzBNXpdNjZ2d03gvmvf/2L5ORkdDodjz/+OIGBgcTGxlJYWIiTkxNarbbPUqiGGkN+3anX68nKyiI4OJhnnnmG2bNnc+rUKYqLi4mIiCAhIYHg4GA++ugj5eeTkpKUfjo3btxQ2rYONvLz87l69SoJCQlERUURHR090FPqU2Q/UF9fX8aMGYOHh8d9IZjFxcUkJiby4Ycf8tFHH2FlZUVdXR1TpkwhKiqKv//97+zatYtRo0ZhMBgGerqDniEvmrIbj2xSkJ2djZ+fHzk5OTz22GNs3bqV+Ph4Tp48SUNDA++99x4HDhwgJycHo9GIo6Mj1tbWSjfAwXRTOjo6olKp0Ov11NTUDCnrO2tr6/tqr1reZbO3t2fp0qV8//33tLS0EB4ejoODg9K+V+xh9pwhvzy3sbGhsrJSuZkOHjyIvb09RUVFBAcHA1BZWYmzszO1tbVMnz6d8+fPU1lZyf79+3F3d2f06NFK/+e2Jq5g2ieTw4cPR6PR8Morr9DU1ERMTMxAT0lwDzg7OzNt2jTS09N59tlncXV15Y033sDMzIypU6dSV1fHZ599xoQJE3rs+iQQkSYAQUFBbNiwgd/97neUlZUxbdo0MjMzGTt2LABFRUWMHj2ampoazp49S3BwMKtXr+bZZ58lIyOD7777jvLycjZv3szp06cpLS0dFIdGX331FVVVVXz22Wd88sknrFu3bqCnJLhHgoKCKCsrY9OmTcTGxrJt2za8vLxQq9UEBQURHh4uBLOXGPKRJsDLL7/MSy+9RG5uLg899BBZWVnY29vz9ddfYzAY2Lt3L/PmzcPe3p7z588rLUyLi4vR6XRMnTqV7OxsMjMzqaurIy0tjTlz5rBs2bIBvrI7YzQasbOzUxqcNTQ0DPSUBPeIp6cnv/nNbzhz5gz5+flERUUxfvx4JEnqt/bCQwUhmvyUizl27FjKy8vJzs4mKCiIa9eu8Z///IcXX3yRmTNn8s033yBJktI/uri4GJVKhUajIS4ujoCAAEJDQ3n77beJjY3tUouAji7Z/cnUqVM5fPgwCxYsoLm5mdDQ0H6fg6D3cHBw4KWXXlK+F5U+fYMQTWh3ICD3s168eDGOjo7AT4c7tbW1lJeX88UXX/Dwww9TUlLCmDFj0Gq1VFdX8/rrrwOtJrh5eXl3LHmTa407bsz3541uYWHBpk2b+mUsQf8jBLNvEKLZAXd3dzZu3KicKltaWirCNmPGDEaMGEFeXh4FBQWUl5cze/ZsTp8+jaOjoxJVZmVl4eLiwrBhwzqtKPr0009JSUmhqqqK8ePHExoaqiyh5BtdRAmmx86dO0lMTOTRRx9l165dyuNbt24lIyOD4cOHs3HjRhwcHKioqCA8PJz6+nqmTJnCkiVLAEhLS2Pnzp2YmZnxxz/+kXHjxg3U5QjuFUlwz9y4cUOSJEmKjo6WPv74Y6mpqUmSJElaunSpdPz4cUmSJMlgMEiSJEl6vV6SJEn64osvpF/96ldSTk6OdOXKFWnHjh1SZWWlpNfrpZSUFCk7O/uWcYxGY39cTp+h0+mkX/7yl5K/v7907NgxSZIkSavVSosWLZLmzZsnRUdHD/AMu8bNmzel69evS++8847y2KVLl6SQkBBJkiTp6NGjUkREhCRJkvThhx9KR48elSRJkkJCQqTLly9Ler1emjNnjlRbWyvduHFDmjdvXv9fhKDHiEizm0htIkC5DcKSJUtoamrigQceoLi4mCtXrjBlyhSAW6LMgwcPMmvWLHx9fYHWDfzvv/+e3bt3c+3aNcrLy3nkkUfYsGGDMlbbiHMw1gtbWloSHR1NYmKi8lhsbCzBwcEEBQXxzjvvcOXKFby8vAZwlndn5MiRSr6jzJkzZwgICADg+eefZ8+ePQB8++23ykGg7INpZmaGu7s7tra22NraotfraW5uvmvrDYFpIVKOusntlsyyn6OzszNxcXFKK1QZWei0Wi0TJ04EUE6rU1JSsLa2JiIigsTERIxGI5cuXeKHH34gOjqay5cv3/I80HqAZTQae/cC+wAzMzOcnJzaPfbtt99221zXFGnrg6lSqZT3tKGhQbknZB/Mtt6Y8uOyqYhg8CAizT5AjkAtLCwUqzn5hHzWrFmkpaXh5eWFjY0NOp2OwsJCwsLClI5/OTk5mJubU1RURHNzsyLUkZGRjBkzhpkzZwK3RrEweFyZOopKxwhuoLiTD6YcUbZFtnaD1mZsNjY2QGvFkRxFyj6YdnZ21NbWKr9bW1vLiBEj+uQ6BH2H6X+6BiGnTp3iyJEj1NXVYW5ujoWFhSJ8kyZNIisri5dffpnk5GSqqqoYPXo0FRUVqFQqrl69SktLC15eXpw/fx6NRqN4Kx49ehQ3NzcuXLjA+vXr2bFjB6mpqcq4BoOBM2fOtDOzNVVkUQHuaq7bn8g+mB2/OhNM+MnvEuDEiRP4+fkB4O/vz4kTJ4DWRmoTJ07Ezc2N/Px8GhoaKCsrw8LCQizNByFCNPuAJ554gtLSUhYvXkxoaCiHDh1SBMLHx4fdu3cTFxeHv78/Tk5OaDQaEhISOH78OPHx8cycOZP6+nrq6upwcXHBysqKy5cvY2Vlha+vL7m5uXz11Veo1Wp2795NfHw80PqhPXToUI9aP/QXnYmKqZOcnMzKlSs5d+4cCxcupKKiAm9vb3x8fJg/fz5JSUmEhIQAEBISQlJSEvPnz8fHxwdvb28sLS0JCwvjt7/9LUuWLBHu/IMU4afZx5SWlpKZmYmTkxNTpkxBr9e3izyhNTc0JSWF9PR05s+fj7+/P42NjURGRrJs2TI0Gg3vv/8+kiSxZs0aNm/ejFqtZtGiReTm5rJ27VqSk5MJCQnh3LlzTJ06laVLl+Lh4TGAV96eZcuWcf78eWxsbJg+fTqLFy9WUnImT55s8tVTAoGMEE0TZuHChajVambMmEFERATx8fGYm5uTlJTErFmzGD9+PBEREeh0OtasWcM//vEPSktLefrpp7GzsxM5gAJBHyCW5yZCZ5ZyMTExvPLKK9TX16NWq/Hx8eHs2bNYWVnh4+MDQGZmJrNnz0ar1XLhwgUCAgKYPn26EEyBoI8Qp+cmQme5l7a2trz66qsAvPnmm0DrAYqLiwsqlYpLly7R2NjI+PHjycrKorm5WRFTgUDQNwjRNHEkSUKSJKUP+uuvv654dV68eJGnnnoKaDUPkZOmBQJB3yH2NAcZcpWQ1KE2/fPPP2fDhg28+eabLFiwwGRSeASC+w0hmoOYjiWVkiSRn5+Ps7OzEpkKBILeRYjmfcJgrEkXCAYjQjQFAoGgG4iUI4FAIOgGQjQFAoGgGwjRFAgEgm4gRFMgEAi6gRBNgUAg6AZCNAUCgaAb/B/axFdqwm+5ywAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\" Execute this to train model \"\"\"\n",
    "# drop _ids and rfm_ for training\n",
    "# feature_vector = df[df.columns.drop(list(df.filter(regex='_id|rfm_segment|rfm_recency|gender|recency_value|age')))]\n",
    "\n",
    "print(f\"Executing model run with feature vector column names {input_vector.columns}\")\n",
    "\n",
    "# We should use preprocessing and use other interpolation methods too\n",
    "df = df.fillna(-1000)\n",
    "\n",
    "collection_id = modelling_config['collection_id']\n",
    "# Initiate training\n",
    "train_clusters(schema, df, input_vector.columns.tolist(), collection_id, modelling_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ec2-user/anaconda3/envs/python3/lib/python3.6/site-packages/sqlalchemy/engine/strategies.py:95: SADeprecationWarning: The psycopg2 use_batch_mode flag is superseded by executemany_mode='batch'\n",
      "  dialect = dialect_cls(**dialect_args)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fan_id     object\n",
      "cluster     int64\n",
      "dtype: object\n",
      "fan_id     363187\n",
      "cluster    363187\n",
      "dtype: int64\n",
      "(363187, 2)\n",
      "   cluster  fan_id\n",
      "0        0  356901\n",
      "1        1     364\n",
      "2        2    4187\n",
      "3        3    1735\n",
      "(363187, 5)\n"
     ]
    }
   ],
   "source": [
    "algo = 'kmeans'\n",
    "# algo = 'kmedoids'\n",
    "# algo ='dbscan'\n",
    "clusters = prepare_clustering_output(schema, collection_id, algo)\n",
    "print(clusters.dtypes)\n",
    "print(clusters.count())\n",
    "print(clusters.shape)\n",
    "print(clusters.groupby(\"cluster\",as_index=False)[\"fan_id\"].count().head(10))\n",
    "clustersAndInput = pd.merge(df, clusters, how='inner', on=['fan_id'])\n",
    "print(clustersAndInput.shape)\n",
    "# clustersAndInput.to_csv('cluster_output.csv', sep=';')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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>cluster</th>\n",
       "      <th>optin_count</th>\n",
       "      <th>optin_rating</th>\n",
       "      <th>optin_recency</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>2.283056</td>\n",
       "      <td>558.239882</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1.049451</td>\n",
       "      <td>-1000.000000</td>\n",
       "      <td>2053.260989</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2.678529</td>\n",
       "      <td>2.166468</td>\n",
       "      <td>511.073561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>1.046686</td>\n",
       "      <td>-1000.000000</td>\n",
       "      <td>300.892219</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   cluster  optin_count  optin_rating  optin_recency\n",
       "0        0     1.000000      2.283056     558.239882\n",
       "1        1     1.049451  -1000.000000    2053.260989\n",
       "2        2     2.678529      2.166468     511.073561\n",
       "3        3     1.046686  -1000.000000     300.892219"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# show avg values for each cluster\n",
    "# input_columns = [\"date_diff\",\"monetary_value\",\"frequency_value\"]\n",
    "# input_columns = [\"date_diff\",\"monetary_value\",\"frequency_value\",\"optin_rating\",\"optin_recency\"]\n",
    "input_columns = [\"optin_count\",\"optin_rating\",\"optin_recency\"]\n",
    "# input_columns = [\"optin_count\",\"optin_rating\",\"optin_recency\",\"date_diff\",\"monetary_value\",\"frequency_value\",\"age\",\"female\",\"male\"]\n",
    "clustersAndInput.groupby(\"cluster\",as_index=False)[input_columns].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write final cluster selection into RDS table  merch_clusters\n",
    "engine = get_rds_engine()\n",
    "clusters.to_sql(f'optin_clusters',\n",
    "              engine,\n",
    "              schema=schema,\n",
    "              if_exists='replace',\n",
    "              #index_label='fan_id',\n",
    "              index=False\n",
    "              )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Get cluster output and plot pairplot \"\"\"\n",
    "schema = 'a441ffb172866cb4928c84a73de403ca15da4a54cc535e704413ab621' # unique customer schema id\n",
    "algo = 'kmeans'\n",
    "\n",
    "clusters = prepare_clustering_output(schema, algo)\n",
    "print(clusters.shape)\n",
    "print(clusters.head(5))\n",
    "clusters.to_csv('clusters.csv', sep=',')\n",
    "# TODO! this is training data.. modularize it to somwhere\n",
    "df1 = prepare_rfm_dataset(schema, 'fan_purchase')\n",
    "df2 = prepare_fan_purchase(schema)\n",
    "df3 = prepare_fan_demographics(schema)\n",
    "df4 = prepare_fan_event_distance(schema)\n",
    "df = pd.merge(df3, df2, how='inner', on=['fan_id'])\n",
    "df = pd.merge(df, df1, how='inner', on=['fan_id'])\n",
    "# df = pd.merge(df, df4, how='inner', on=['fan_id'])\n",
    "print(df.shape)\n",
    "# join with clusters\n",
    "df = pd.merge(df, clusters, how='inner', on=['fan_id'])\n",
    "\n",
    "# Try to convert some strings to numbers\n",
    "print(df.dtypes)\n",
    "cols = df.columns.tolist()\n",
    "df = df.apply(pd.to_numeric, errors='ignore')\n",
    "\n",
    "\n",
    "df.to_csv('cluster_output.csv', sep=',')\n",
    "\n",
    "# Drop _id fields\n",
    "df = df[df.columns.drop(list(df.filter(regex='_id')))]\n",
    "\n",
    "# Only pick fields we want (from feature importance)\n",
    "df = df[['max_transcaction_value','date_diff','monetary_value','cluster']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clustersAndInput=clustersAndInput[['unique_events','days_from_event','monetary_value','total_merch_value_per_fan',\n",
    "                                   'total_tickets_per_fan','cluster']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Draw pairplot. This can take 20+sec. It should automatically remove _id fields.\n",
    "sns.pairplot(clustersAndInput,\n",
    "             plot_kws={'alpha': 0.6, 's': 80, 'edgecolor': 'k'},\n",
    "             #dropna = True,\n",
    "             #diag_kind='kde',\n",
    "             hue='cluster'\n",
    "             )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_python3",
   "language": "python",
   "name": "conda_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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}