{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spotify Playlist Generation Project - Model Code\n",
    "AC209a Project Group 21 - Project D \n",
    "Team Members: Matthew Finney, Kaivalya Rawal, Royce Yap, David Zheng"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height:2pt\">\n",
    "\n",
    "## 1. Exploratory Data Analyis\n",
    "\n",
    "See the submitted EDA notebook here: https://github.com/not-a-hot-dog/spotify_project/blob/master/eda/Exploratory_Data_Analysis.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height:2pt\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Code used in Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Import and Defined Functions Used Across Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import time\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.sparse import coo_matrix\n",
    "from scipy.sparse import save_npz\n",
    "from scipy.sparse import load_npz\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "from sklearn.model_selection import train_test_split\n",
    "from scipy.sparse import csr_matrix\n",
    "from collections import Counter\n",
    "from IPython.display import Image\n",
    "\n",
    "np.random.seed(21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to get tracks for a pid\n",
    "def get_tracks(pid, playlist_df):\n",
    "    tracks = list(playlist_df.loc[playlist_df['pid'] == pid, 'track_uri'])\n",
    "    return tracks\n",
    "\n",
    "# Helper function to get tracks for a pid list\n",
    "def select_playlists(df, pid_list, playlistfile = 'data/playlists.csv'):\n",
    "    output = df[df['pid'].isin(pid_list)]    \n",
    "    return output\n",
    "\n",
    "# Helper function to get summary of track features from an array of tracks (e.g., get_tracks output)\n",
    "def get_summary_features(track_uri_array, track_df):\n",
    "    subset_track_df = track_df.loc[track_uri_array, :]\n",
    "    features_mean = subset_track_df.describe().loc[['std'], :].reset_index(drop=True)\n",
    "    features_mean.columns = [str(col) + '_mean' for col in features_mean.columns]\n",
    "    features_std = subset_track_df.describe().loc[['std'], :].reset_index(drop=True)\n",
    "    features_std.columns = [str(col) + '_std' for col in features_std.columns]\n",
    "    artist_uri_freq = subset_track_df.artist_uri.value_counts(normalize=True)[0]\n",
    "    if artist_uri_freq > 0.3:  # If the top artist doesn't have 30% of track in the playlist, ignore\n",
    "        top_artist = pd.DataFrame([{'artist_uri_top': subset_track_df.artist_uri.value_counts(normalize=True).index[0],\n",
    "                                    'artist_uri_freq': artist_uri_freq\n",
    "                                    }]).reset_index(drop=True)\n",
    "    else:\n",
    "        top_artist = pd.DataFrame([{'artist_uri_top': np.NaN, 'artist_uri_freq': 0}])\n",
    "\n",
    "    features = pd.concat([features_mean, features_std, top_artist], axis=1, sort=False)\n",
    "    return features\n",
    "\n",
    "# Helper function to get summary of track features, including artists\n",
    "def val_test_features(track_uri_array, track_df, top_artists, pid=None):\n",
    "    # Load list of dominating artists\n",
    "    top_playlist_defining_artists = top_artists\n",
    "\n",
    "    # Get summary features\n",
    "    stub_playlist_features = get_summary_features(track_uri_array, track_df)\n",
    "\n",
    "    artists_to_keep = stub_playlist_features.artist_uri_top.isin(top_playlist_defining_artists)\n",
    "    stub_playlist_features.artist_uri_top = stub_playlist_features.artist_uri_top[artists_to_keep]\n",
    "    stub_playlist_features.artist_uri_freq = stub_playlist_features.artist_uri_freq[artists_to_keep]\n",
    "    stub_playlist_features.artist_uri_freq.fillna(0, inplace=True)\n",
    "    stub_artist_dummies = pd.get_dummies(stub_playlist_features.artist_uri_top)\n",
    "    top_artist_dummies = pd.DataFrame(columns=top_playlist_defining_artists)\n",
    "    top_artist_dummies = pd.concat([top_artist_dummies, stub_artist_dummies], axis=0, sort=False)\n",
    "    top_artist_dummies.fillna(0, inplace=True)\n",
    "    stub_playlist_features = pd.concat([stub_playlist_features, top_artist_dummies], axis=1)\n",
    "    stub_playlist_features.drop(['artist_uri_top'], axis=1, inplace=True)\n",
    "    if pid:\n",
    "        stub_playlist_features.index = [pid]\n",
    "\n",
    "    return stub_playlist_features\n",
    "\n",
    "\n",
    "def build_playlist_features(pid_list, playlist_df, track_df):\n",
    "    output = pd.DataFrame()\n",
    "    for pid in pid_list:\n",
    "        output = output.append(get_summary_features(get_tracks(pid, playlist_df), track_df))\n",
    "    output = output.set_index(pd.Index(pid_list))\n",
    "    return output\n",
    "\n",
    "\n",
    "def stub_withhold_split(pid: int, playlist_df: pd.DataFrame=None):\n",
    "    if playlist_df is None: playlist_df = pd.read_csv('data/playlists.csv')\n",
    "    tracks = get_tracks(pid, playlist_df)\n",
    "    stub_tracks, withhold_tracks = train_test_split(tracks, random_state=21, test_size=0.3)\n",
    "    return stub_tracks, withhold_tracks\n",
    "\n",
    "def add_playlist(model, tracks):\n",
    "    tracks = [track_to_index[j] for _, j in tracks.items()]\n",
    "    for i, track1 in enumerate(tracks):\n",
    "        for j in range(0,i):\n",
    "            model[track1, tracks[j]] += 1\n",
    "            \n",
    "def test_on_playlist(model, tracks, n=5):\n",
    "    tracks = [track_to_index[j] for _, j in tracks.items()]\n",
    "    temp = np.zeros(num_unique_tracks) + 1\n",
    "    ground_truth = []\n",
    "    for i, track in enumerate(tracks):\n",
    "        if i in selected_indices:\n",
    "            temp += model[track]\n",
    "        else:\n",
    "            ground_truth.append(track)\n",
    "    total = sum(temp)\n",
    "    raw = sorted(list(enumerate(temp)), key= lambda x: x[1], reverse=True)\n",
    "    tally = 0\n",
    "    if n == '30%':\n",
    "        n = len(ground_truth)\n",
    "    elif n == '70%':\n",
    "        n = int(len(ground_truth) * 7 / 3)\n",
    "    for i in range(n):\n",
    "        if raw[i][0] in ground_truth:\n",
    "            tally += 1\n",
    "    return tally / n\n",
    "\n",
    "def get_ndcg_score(model, tracks, n=''):\n",
    "    tracks = [track_to_index[j] for _, j in tracks.items()]\n",
    "    temp = np.zeros(num_unique_tracks) + 1\n",
    "    ground_truth = []\n",
    "    for i, track in enumerate(tracks):\n",
    "        if i in selected_indices:\n",
    "            temp += model[track]\n",
    "        else:\n",
    "            ground_truth.append(track)\n",
    "    total = sum(temp)\n",
    "    raw = sorted(list(enumerate(temp)), key= lambda x: x[1], reverse=True)\n",
    "    if n == '30%':\n",
    "        n = len(ground_truth)\n",
    "    elif n == '70%':\n",
    "        n = int(len(ground_truth) * 7 / 3)\n",
    "    preds = []\n",
    "    for pred in raw[:n]:\n",
    "        preds.append(pred[0])\n",
    "    return ndcg(ground_truth, preds)\n",
    "\n",
    "def make_recommendation(withheld_df, model_knn, playlist_id, n_neighbors, n_recommendations):\n",
    "    \n",
    "    no_withheld_songs = len(withheld_df[withheld_df.pid == pid].track_uri)\n",
    "    \n",
    "    #Get the indices and list of playlists of the k nearest neighbors to the playlist\n",
    "    dist, indice = model_knn.kneighbors(np.array(co_mat.loc[playlist_id]).reshape(1, -1), n_neighbors = n_neighbors)\n",
    "    rec_playlists = co_mat.index[indice[0]]\n",
    "    \n",
    "    #For all songs in the playlist, assign a frequency rating to them\n",
    "    song_freq_dict = {}\n",
    "    \n",
    "    for playlist in rec_playlists:\n",
    "        playlist_songs = combined_df[combined_df['pid']==playlist][\"track_uri\"]\n",
    "\n",
    "        for song in playlist_songs:\n",
    "            if song_freq_dict.get(song) is None:\n",
    "                song_freq_dict[song] = 1\n",
    "            else:\n",
    "                song_freq_dict[song] += 1\n",
    "    \n",
    "       \n",
    "    #Select the top n number of songs in the list of songs across recommended playlists\n",
    "    k = Counter(song_freq_dict) \n",
    "\n",
    "    # Finding n highest values and returning song titles\n",
    "    top_songs = [i[0] for i in k.most_common(n_recommendations)]    \n",
    "    \n",
    "    return top_songs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Model Evaluation Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model Evaluation Metrics, adapted from https://recsys-challenge.spotify.com/rules\n",
    "def r_precision(predicted_tracks: np.ndarray, withhold_tracks: np.ndarray):\n",
    "    mask = np.isin(withhold_tracks, predicted_tracks) # Give credit for predicting a track that's in withhold twice!\n",
    "    r_precision_score = np.sum(mask)/len(withhold_tracks)\n",
    "    return r_precision_score\n",
    "\n",
    "\n",
    "def hit_rate(predicted_tracks: np.ndarray, withhold_tracks: np.ndarray):\n",
    "    mask = np.isin(predicted_tracks, withhold_tracks)\n",
    "    hit_rate_score = np.sum(mask)/len(predicted_tracks)\n",
    "    return hit_rate_score\n",
    "\n",
    "\n",
    "def dcg(withhold_tracks, predicted_tracks):\n",
    "    try:\n",
    "        mask = np.isin(predicted_tracks, withhold_tracks)\n",
    "        score = np.sum(mask[0]) + np.sum(mask[1:] / np.log2(np.arange(2, mask.size + 1)))\n",
    "    except Exception:\n",
    "        score = np.NaN\n",
    "    return score\n",
    "\n",
    "\n",
    "def idcg(withhold_tracks):\n",
    "    n_withheld = len(withhold_tracks)\n",
    "    ones = np.ones(n_withheld-1)\n",
    "    score = 1 + np.sum(ones / np.log2(np.arange(2, n_withheld + 1)))\n",
    "    return max(score, 1)\n",
    "\n",
    "\n",
    "def ndcg(withhold_tracks, predicted_tracks):\n",
    "    dcg_score = dcg(withhold_tracks=withhold_tracks, predicted_tracks=predicted_tracks)\n",
    "    idcg_score = idcg(withhold_tracks)\n",
    "    ndcg_score = dcg_score/idcg_score\n",
    "    return ndcg_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height:2pt\">\n",
    "\n",
    "## 2.3 Naive Bayes Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.1 Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "playlists = pd.read_csv('./data/playlists.csv')\n",
    "train_pids = pd.read_csv('./data/train_pids.csv').to_numpy().reshape(1,-1)[0]\n",
    "val_pids = pd.read_csv('./data/val_pids.csv').to_numpy().reshape(1,-1)[0]\n",
    "test_pids = pd.read_csv('./data/test_pids.csv').to_numpy().reshape(1,-1)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "index_to_track = {}\n",
    "track_to_index = {}\n",
    "for index, track in enumerate(np.unique(playlists.track_uri)):\n",
    "    index_to_track[index] = track\n",
    "    track_to_index[track] = index\n",
    "num_unique_tracks = len(track_to_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_indices = []\n",
    "unselected_indices = []\n",
    "max_tracks_in_playlist = 10000\n",
    "for i, j in enumerate(np.random.random(max_tracks_in_playlist)):\n",
    "    if j < 0.7:\n",
    "        selected_indices.append(i)\n",
    "    else:\n",
    "        unselected_indices.append(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.2 Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 1\n",
      ".................................................\n",
      " 1001\n",
      ".................................................\n",
      " 2001\n",
      ".................................................\n",
      " 3001\n",
      ".................................................\n",
      " 4001\n",
      ".................................................\n",
      " 5001\n",
      ".................................................\n",
      " 6001\n",
      ".................................................\n",
      " 7001\n",
      ".................................................\n",
      " 8001\n",
      ".................................................\n",
      " 9001\n",
      ".................................................\n",
      " 10001\n",
      ".................................................\n",
      " 11001\n",
      ".................................................\n",
      " 12001\n",
      ".................................................\n",
      " 13001\n",
      "...."
     ]
    }
   ],
   "source": [
    "model = np.zeros((num_unique_tracks,num_unique_tracks))\n",
    "for i, pid in enumerate(train_pids):\n",
    "    add_playlist(model, playlists.loc[playlists['pid'] == pid]['track_uri'])\n",
    "#     print(i)\n",
    "    if i % 1000 == 1:\n",
    "        print('\\n', i)\n",
    "    elif i % 20 == 1:\n",
    "        print('.', end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open('naive-model.npy', 'wb') as f:\n",
    "#     np.save(f, model)\n",
    "\n",
    "# # with open('naive-model.npz', 'wb') as f:\n",
    "# #     save_npz(f, coo_matrix(model))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.3 Evaluating Model Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = []\n",
    "for i, pid in enumerate(test_pids):\n",
    "    result.append(test_on_playlist(model, playlists.loc[playlists['pid'] == pid]['track_uri'], n=10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "ndcg_30pc = []\n",
    "for i, pid in enumerate(test_pids):\n",
    "    ndcg_30pc.append(get_ndcg_score(model, playlists.loc[playlists['pid'] == pid]['track_uri'], n='30%'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "ndcg_70pc = []\n",
    "for i, pid in enumerate(test_pids):\n",
    "    ndcg_70pc.append(get_ndcg_score(model, playlists.loc[playlists['pid'] == pid]['track_uri'], n='70%'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_30pc = []\n",
    "for i, pid in enumerate(test_pids):\n",
    "    result_30pc.append(test_on_playlist(model, playlists.loc[playlists['pid'] == pid]['track_uri'], n='30%'))\n",
    "\n",
    "result_70pc = []\n",
    "for i, pid in enumerate(test_pids):\n",
    "    result_70pc.append(test_on_playlist(model, playlists.loc[playlists['pid'] == pid]['track_uri'], n='70%'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_scores = np.vstack([result, result_30pc, result_70pc, ndcg_30pc, ndcg_70pc]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x1800 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "score_names = ['Hit Rate (10 Predictions)','R-Precision (# of Withheld Tracks)','R-Precision (# of Calibration Tracks)','NDCG (# of Withheld Tracks)','NDCG (# of Calibration Tracks)']\n",
    "model_name = 'Naive Bayes'\n",
    "set_name = 'Test'\n",
    "\n",
    "# Plot each score\n",
    "fig, ax = plt.subplots(5,1, figsize=(7,25))\n",
    "for i in range(plot_scores.shape[1]):\n",
    "    scores = plot_scores[:,i]\n",
    "    sns.distplot(scores, kde=False, rug=False, hist_kws={'rwidth':1,'edgecolor':'white', 'alpha': 1}, ax=ax[i], color=\"#2C5E92\")\n",
    "    ax[i].axvline(np.mean(scores), label='Mean = {}'.format(round(np.mean(scores), 3)), color='k')\n",
    "    ax[i].legend()\n",
    "    ax[i].set_title(f'{score_names[i]} on the {set_name} Set, {model_name}')\n",
    "fig.tight_layout(rect=[0, 0.03, 1, 0.97])\n",
    "fig.suptitle(f'{model_name} Model Evaluation Metrics on the {set_name} Set', size='xx-large')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height:2pt\">\n",
    "\n",
    "## 2.4 K Means Clustering / K Centroid Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.1 Data Pre-Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Reading data into memory')\n",
    "pid_list = np.genfromtxt('data/train_pids.csv', skip_header=1, dtype=int)\n",
    "playlistfile = 'data/playlists.csv'\n",
    "playlist_df = pd.read_csv(playlistfile)\n",
    "trackfile = 'data/songs_100000_feat_cleaned.csv'\n",
    "track_df = pd.read_csv(trackfile, index_col='track_uri')\n",
    "\n",
    "print('Finding playlist features')\n",
    "playlist_features = build_playlist_features(pid_list, playlist_df, track_df)\n",
    "playlist_features.to_csv('data/playlist_features_train.csv')\n",
    "\n",
    "print('Finding top artists')\n",
    "# Find the top artists who dominate playlists\n",
    "top_playlist_defining_artists = playlist_features.artist_uri_top.value_counts(normalize=False)\n",
    "top_playlist_defining_artists.to_csv('data/top_playlist_defining_artists_train_all.csv', header=True)\n",
    "top_playlist_defining_artists = playlist_features.artist_uri_top.value_counts().index.values[:50]\n",
    "np.savetxt('data/top_playlist_defining_artists_train.csv', top_playlist_defining_artists, delimiter=',', fmt=\"%s\")\n",
    "\n",
    "# Keep only those artists who dominate playlists and one hot encode\n",
    "artists_to_keep = playlist_features.artist_uri_top.isin(top_playlist_defining_artists)\n",
    "playlist_features.artist_uri_top = playlist_features.artist_uri_top[artists_to_keep]\n",
    "playlist_features.artist_uri_freq = playlist_features.artist_uri_freq[artists_to_keep]\n",
    "playlist_features.artist_uri_freq.fillna(0, inplace=True)\n",
    "\n",
    "top_artist_dummies = pd.get_dummies(playlist_features.artist_uri_top)\n",
    "playlist_features = pd.concat([playlist_features, top_artist_dummies], axis=1)\n",
    "playlist_features.drop(['artist_uri_top'], axis=1, inplace=True)\n",
    "playlist_features.to_csv('data/playlist_features_with_artists_train.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.2 K-Means Clustering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Making clusters\n",
      "Saving clusters\n"
     ]
    }
   ],
   "source": [
    "# Get the train features dataframe\n",
    "playlist_features = pd.read_csv('data/playlist_features_with_artists_train.csv', index_col=0, header=0)\n",
    "playlist_list = playlist_features.index.values\n",
    "\n",
    "# Set desired number of clusters\n",
    "n_clusters = int(np.sqrt(len(playlist_features)))\n",
    "\n",
    "print('Making clusters')\n",
    "# Make clusters\n",
    "kmeans = KMeans(n_clusters=n_clusters, verbose=0, algorithm='auto')\n",
    "kmeans.fit(playlist_features)\n",
    "\n",
    "\n",
    "print('Saving clusters')\n",
    "# Saving the clusters\n",
    "pickle.dump(kmeans, open('model/kmeans_cluster_train.pkl', 'wb'))\n",
    "cluster_centers = kmeans.cluster_centers_\n",
    "np.savetxt('model/kmeans_cluster_centers_train.csv', cluster_centers, delimiter=',')\n",
    "\n",
    "# Saving the cluster label for each playlist in train (e.g., for track frequency table by cluster)\n",
    "cluster_labels = kmeans.labels_\n",
    "playlist_cluster_labels = np.column_stack((playlist_list, cluster_labels))\n",
    "np.savetxt('model/playlist_cluster_labels_train.csv', playlist_cluster_labels, delimiter=',', fmt='%i')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.3 Specification of the Nearest Centroid Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "cluster_centers = np.genfromtxt('model/kmeans_cluster_centers_train.csv', skip_header=0, delimiter=',')\n",
    "\n",
    "# Fit the neighbors classifier\n",
    "nearest_cluster = NearestNeighbors(n_neighbors=1)\n",
    "nearest_cluster.fit(cluster_centers)\n",
    "pickle.dump(nearest_cluster, open('model/nearest_cluster_train.pkl', 'wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.4 Development of Track Frequency Tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read in cluster labels\n",
      "Read in the playlist dataframe\n",
      "Loop through the clusters and return the frequency each track for each cluster\n"
     ]
    }
   ],
   "source": [
    "print('Read in cluster labels')\n",
    "playlist_cluster_labels = pd.read_csv('model/playlist_cluster_labels_train.csv', header=None, delimiter=',', dtype=int,\n",
    "                                      names=['pid', 'cluster_id'])\n",
    "clusters = np.unique(playlist_cluster_labels.cluster_id)\n",
    "\n",
    "print('Read in the playlist dataframe')\n",
    "playlistfile = 'data/playlists.csv'\n",
    "playlist_df = pd.read_csv(playlistfile, header=0, usecols=('pid', 'track_uri'))\n",
    "\n",
    "frequency_dict = {}\n",
    "\n",
    "print('Loop through the clusters and return the frequency each track for each cluster')\n",
    "for cluster in clusters:\n",
    "    cluster_pids = playlist_cluster_labels.pid[playlist_cluster_labels.cluster_id == cluster]\n",
    "    tracks = playlist_df.track_uri[playlist_df.pid.isin(cluster_pids)]\n",
    "    track_frequencies = tracks.value_counts(normalize=True)\n",
    "    frequency_dict[cluster] = track_frequencies\n",
    "\n",
    "pickle.dump(frequency_dict, open('model/cluster_track_frequencies.pkl', 'wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.5 Functions that Apply the K-Centroid Model to Return Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_cluster(model, track_uri_array=None, track_df=None, top_artists=None, pid: int = None,\n",
    "                    features_df: pd.DataFrame = None, return_features=False):\n",
    "    \"\"\"\n",
    "    :return: the predicted cluster id for the array of tracks provided\n",
    "    \"\"\"\n",
    "    # Load nearest cluster model\n",
    "    nearest_cluster = model\n",
    "\n",
    "    if pid:\n",
    "        stub_playlist_features = np.array(features_df.loc[pid, :]).reshape(1, -1)\n",
    "        dist, cluster_id = nearest_cluster.kneighbors(stub_playlist_features)\n",
    "        if return_features:\n",
    "            return int(cluster_id), stub_playlist_features\n",
    "        else:\n",
    "            return int(cluster_id)\n",
    "\n",
    "    else:\n",
    "\n",
    "        # Load list of dominating artists\n",
    "        top_playlist_defining_artists = top_artists\n",
    "\n",
    "        # Get summary features\n",
    "        stub_playlist_features = get_summary_features(track_uri_array, track_df)\n",
    "\n",
    "        artists_to_keep = stub_playlist_features.artist_uri_top.isin(top_playlist_defining_artists)\n",
    "        stub_playlist_features.artist_uri_top = stub_playlist_features.artist_uri_top[artists_to_keep]\n",
    "        stub_playlist_features.artist_uri_freq = stub_playlist_features.artist_uri_freq[artists_to_keep]\n",
    "        stub_playlist_features.artist_uri_freq.fillna(0, inplace=True)\n",
    "        stub_artist_dummies = pd.get_dummies(stub_playlist_features.artist_uri_top)\n",
    "        top_artist_dummies = pd.DataFrame(columns=top_playlist_defining_artists)\n",
    "        top_artist_dummies = pd.concat([top_artist_dummies, stub_artist_dummies], axis=0, sort=False)\n",
    "        top_artist_dummies.fillna(0, inplace=True)\n",
    "        stub_playlist_features = pd.concat([stub_playlist_features, top_artist_dummies], axis=1)\n",
    "        stub_playlist_features.drop(['artist_uri_top'], axis=1, inplace=True)\n",
    "\n",
    "        dist, cluster_id = nearest_cluster.kneighbors(stub_playlist_features)\n",
    "        if return_features:\n",
    "            return int(cluster_id), stub_playlist_features\n",
    "        else:\n",
    "            return int(cluster_id)\n",
    "\n",
    "\n",
    "def predict_tracks(track_uri_array=None, n_tracks='max', frequency_dict: dict = None, pid: int = None,\n",
    "                   features_df: pd.DataFrame = None,\n",
    "                   playlist_df: pd.DataFrame = None, track_df: pd.DataFrame = None, model=None,\n",
    "                   top_artists: np.ndarray = None, return_features=False):\n",
    "    \"\"\"\n",
    "    :param features_df:\n",
    "    :param return_features:\n",
    "    :param top_artists:\n",
    "    :param model:\n",
    "    :param track_df:\n",
    "    :param playlist_df:\n",
    "    :param frequency_dict:\n",
    "    :param track_uri_array: an array of tracks\n",
    "    :param n_tracks: The number of tracks to predict\n",
    "    :return: an array of predicted tracks and probabilities of length n_songs\n",
    "    \"\"\"\n",
    "\n",
    "    # Load nearest cluster model\n",
    "    if model is None: model = pickle.load(open('model/nearest_cluster_train.pkl', 'rb'))\n",
    "    if playlist_df is None: playlist_df = pd.read_csv('data/playlists.csv')\n",
    "    if track_df is None: track_df = pd.read_csv('data/songs_100000_feat_cleaned.csv', index_col='track_uri')\n",
    "    if top_artists is None: top_artists = np.genfromtxt('data/top_playlist_defining_artists_train.csv', usecols=0,\n",
    "                                                        skip_header=0, delimiter=',', dtype=str)\n",
    "    if frequency_dict is None: frequency_dict = pickle.load(open('model/cluster_track_frequencies.pkl', 'rb'))\n",
    "\n",
    "    # Predict the cluster given the provided track_uris\n",
    "    if return_features:\n",
    "        predicted_cluster, features = predict_cluster(track_uri_array=track_uri_array, track_df=track_df, model=model,\n",
    "                                                      top_artists=top_artists,\n",
    "                                                      return_features=return_features, pid=pid, features_df=features_df)\n",
    "    else:\n",
    "        predicted_cluster = predict_cluster(track_uri_array=track_uri_array, track_df=track_df, model=model,\n",
    "                                            top_artists=top_artists, pid=pid, features_df=features_df)\n",
    "\n",
    "    # Find the frequency with which tracks appear in that cluster\n",
    "    track_frequencies = frequency_dict[predicted_cluster]\n",
    "\n",
    "    # Exclude tracks which are already in the input track_uri_array\n",
    "    excluded_recommendations = track_frequencies.index.isin(track_uri_array)\n",
    "    track_frequencies = track_frequencies[~excluded_recommendations]\n",
    "\n",
    "    # Return n_tracks predictions\n",
    "    track_predictions = track_frequencies.reset_index()\n",
    "    track_predictions.columns = ['track_uri', 'probability']\n",
    "    if n_tracks == 'max':\n",
    "        n_tracks = len(track_predictions)\n",
    "    track_predictions = track_predictions.nlargest(n_tracks, 'probability')\n",
    "\n",
    "    if return_features:\n",
    "        return predicted_cluster, track_predictions, features\n",
    "    else:\n",
    "        return predicted_cluster, track_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.6 Model Performance - Evaluation on the Test Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_time = time.time(), time.ctime()\n",
    "print(f'Start time: {start_time[1]}')\n",
    "\n",
    "# Build df of playlists to classify in clusters\n",
    "test_pids = np.genfromtxt('data/test_pids.csv', skip_header=1, dtype=int)\n",
    "\n",
    "# Import data to memory so it is not loaded from disk for every loop iteration\n",
    "playlist_df = pd.read_csv('data/playlists.csv')\n",
    "track_df = pd.read_csv('data/songs_100000_feat_cleaned.csv', index_col='track_uri')\n",
    "top_artists = np.genfromtxt('data/top_playlist_defining_artists_train.csv', usecols=0,\n",
    "                            skip_header=0, delimiter=',', dtype=str)\n",
    "\n",
    "# Create output vessels\n",
    "test_stub_feat_dfs = [None] * len(test_pids)\n",
    "errors = 0\n",
    "\n",
    "# Loop through pids and make features\n",
    "for idx, pid in enumerate(test_pids):\n",
    "    try:\n",
    "        stub_tracks, withhold_tracks = stub_withhold_split(pid)\n",
    "        stub_playlist_feats = val_test_features(stub_tracks, track_df=track_df, top_artists=top_artists, pid=pid)\n",
    "        test_stub_feat_dfs[idx] = stub_playlist_feats\n",
    "    except Exception as e:\n",
    "        print(f'Error for pid {pid}: \\n{e}')\n",
    "        errors += 1\n",
    "\n",
    "    if (idx + 1) % 100 == 0:\n",
    "        print(f'[{time.ctime()}] Progress {idx + 1} playlists and {errors} errors')\n",
    "\n",
    "playlist_features_test = pd.concat(test_stub_feat_dfs, axis=0)\n",
    "\n",
    "end_time = time.time(), time.ctime()\n",
    "time_elapsed = end_time[0] - start_time[0]\n",
    "time_elapsed = time.strftime('%H:%M:%S', time.gmtime(time_elapsed))\n",
    "print(f'End time: {end_time[1]}, Time elapsed: {time_elapsed}')\n",
    "\n",
    "# Save output\n",
    "playlist_features_test.to_csv('data/playlist_features_with_artists_test.csv', sep=',', index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start time: Sun Dec  8 21:00:13 2019\n",
      "[Sun Dec  8 21:02:55 2019] Progress 100 playlists and 0 errors\n",
      "[Sun Dec  8 21:05:33 2019] Progress 200 playlists and 0 errors\n",
      "[Sun Dec  8 21:08:11 2019] Progress 300 playlists and 0 errors\n",
      "[Sun Dec  8 21:10:49 2019] Progress 400 playlists and 0 errors\n",
      "[Sun Dec  8 21:13:29 2019] Progress 500 playlists and 0 errors\n",
      "[Sun Dec  8 21:16:08 2019] Progress 600 playlists and 0 errors\n",
      "[Sun Dec  8 21:18:47 2019] Progress 700 playlists and 0 errors\n",
      "[Sun Dec  8 21:21:26 2019] Progress 800 playlists and 0 errors\n",
      "[Sun Dec  8 21:24:09 2019] Progress 900 playlists and 0 errors\n",
      "[Sun Dec  8 21:26:53 2019] Progress 1000 playlists and 0 errors\n",
      "[Sun Dec  8 21:29:36 2019] Progress 1100 playlists and 0 errors\n",
      "[Sun Dec  8 21:32:21 2019] Progress 1200 playlists and 0 errors\n",
      "[Sun Dec  8 21:35:12 2019] Progress 1300 playlists and 0 errors\n",
      "[Sun Dec  8 21:37:51 2019] Progress 1400 playlists and 0 errors\n",
      "[Sun Dec  8 21:40:30 2019] Progress 1500 playlists and 0 errors\n",
      "[Sun Dec  8 21:43:09 2019] Progress 1600 playlists and 0 errors\n",
      "End time: Sun Dec  8 21:44:07 2019, Time elapsed: 00:43:54\n"
     ]
    }
   ],
   "source": [
    "# Make predictions\n",
    "start_time = time.time(), time.ctime()\n",
    "print(f'Start time: {start_time[1]}')\n",
    "\n",
    "# Build df of playlists to classify in clusters\n",
    "\n",
    "# Import data to memory so it is not loaded from disk for every loop iteration\n",
    "model = pickle.load(open('model/nearest_cluster_train.pkl', 'rb'))\n",
    "playlist_df = pd.read_csv('data/playlists.csv')\n",
    "track_df = pd.read_csv('data/songs_100000_feat_cleaned.csv', index_col='track_uri')\n",
    "top_artists = np.genfromtxt('data/top_playlist_defining_artists_train.csv', usecols=0,\n",
    "                            skip_header=0, delimiter=',', dtype=str)\n",
    "frequency_dict = pickle.load(open('model/cluster_track_frequencies.pkl', 'rb'))\n",
    "features_df = pd.read_csv('data/playlist_features_with_artists_test.csv', index_col=0)\n",
    "\n",
    "# Create output vessels\n",
    "test_clusters = pd.DataFrame(index=pd.Index(test_pids), columns=['cluster_id', 'n_predictions'])\n",
    "test_predictions = {}\n",
    "test_withheld = {}\n",
    "errors = 0\n",
    "\n",
    "# Loop through pids and make predictions\n",
    "for idx, pid in enumerate(test_pids):\n",
    "    try:\n",
    "        stub_tracks, withhold_tracks = stub_withhold_split(pid)\n",
    "        cluster, predictions = predict_tracks(track_uri_array=stub_tracks, n_tracks=len(stub_tracks),\n",
    "                                              frequency_dict=frequency_dict,\n",
    "                                              playlist_df=playlist_df, track_df=track_df, model=model,\n",
    "                                              top_artists=top_artists, pid=pid, features_df=features_df)\n",
    "        test_predictions[pid] = predictions\n",
    "        test_withheld[pid] = withhold_tracks\n",
    "        test_clusters.at[pid, :] = cluster, predictions.shape[0]\n",
    "    except Exception as e:\n",
    "        print(f'Error for pid {pid}: \\n{e}')\n",
    "        test_clusters.at[pid, :] = np.NaN, np.NaN\n",
    "        errors += 1\n",
    "\n",
    "    if (idx + 1) % 100 == 0:\n",
    "        print(f'[{time.ctime()}] Progress {idx + 1} playlists and {errors} errors')\n",
    "\n",
    "end_time = time.time(), time.ctime()\n",
    "time_elapsed = end_time[0] - start_time[0]\n",
    "time_elapsed = time.strftime('%H:%M:%S', time.gmtime(time_elapsed))\n",
    "print(f'End time: {end_time[1]}, Time elapsed: {time_elapsed}')\n",
    "\n",
    "# Save output\n",
    "test_clusters.to_csv('model/k_means_clusters_test.csv', sep=',', index=True)\n",
    "pickle.dump(test_predictions, open('model/k_means_predictions_test.pkl', 'wb'))\n",
    "pickle.dump(test_withheld, open('model/k_means_withheld_test.pkl', 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load predictions for the test set and evaluate\n",
    "test_clusters = np.genfromtxt('model/k_means_clusters_test.csv', skip_header=1, dtype=int, delimiter=',', usecols=[0, 1])\n",
    "test_predictions = pickle.load(open('model/k_means_predictions_test.pkl', 'rb'))\n",
    "test_withheld = pickle.load(open('model/k_means_withheld_test.pkl', 'rb'))\n",
    "\n",
    "# Create output vessel\n",
    "test_scores = np.zeros((test_clusters.shape[0], 7))\n",
    "\n",
    "for idx, (pid, cluster_id) in enumerate(test_clusters):\n",
    "    # Load list of withheld tracks\n",
    "    withhold_tracks = test_withheld[pid]\n",
    "\n",
    "    # Load list of predicted tracks\n",
    "    predictions = test_predictions[pid].track_uri\n",
    "\n",
    "    # Figure out how many tracks to use in the scoring (and don't score for more than predicted)\n",
    "    n_predictions = len(predictions)\n",
    "    n_10 = min(n_predictions, 10)\n",
    "    n_withheld = min(n_predictions, len(withhold_tracks))\n",
    "    n_7withheld_over_3 = min(n_predictions, int(n_withheld * 7 / 3))\n",
    "\n",
    "    predictions_10 = predictions[:n_10]\n",
    "    predictions_n_withheld = predictions[:n_withheld]\n",
    "    predictions_7withheld_over_3 = predictions[:n_7withheld_over_3]\n",
    "\n",
    "    # Score the predictions!\n",
    "    hit_rate_10 = hit_rate(withhold_tracks=withhold_tracks, predicted_tracks=predictions_10)\n",
    "    rps_withheld = r_precision(withhold_tracks=withhold_tracks, predicted_tracks=predictions_n_withheld)\n",
    "    rps_7withheld_over_3 = r_precision(withhold_tracks=withhold_tracks, predicted_tracks=predictions_7withheld_over_3)\n",
    "    ndcg_withheld = ndcg(withhold_tracks=withhold_tracks, predicted_tracks=predictions_n_withheld)\n",
    "    ndcg_7withheld_over_3 = ndcg(withhold_tracks=withhold_tracks, predicted_tracks=predictions_7withheld_over_3)\n",
    "\n",
    "    # Write to array\n",
    "    test_scores[\n",
    "        idx] = pid, cluster_id, hit_rate_10, rps_withheld, rps_7withheld_over_3, ndcg_withheld, ndcg_7withheld_over_3\n",
    "\n",
    "np.savetxt(\"model/k9_scores_test.csv\", test_scores, delimiter=\",\",\n",
    "           header='pid,cluster_id,hit_rate_10,rps_withheld,rps_7withheld_over_3,ndcg_withheld,ndcg_7withheld_over_3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.7 Evaluation Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAaxCAYAAABYD9qhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdefwVVf3H8debRTFFEUSTRbHEfUFEM03j576lVlqaJe6WWVnpL/ulRWVlmWm2maWJSLjlgksGaZS5JeYuLmQoiAoqIKIo6Of3xzkXh8v9fu/9bnwZeT8fj/u49545M3PmzPKZc2bmXkUEZmZmVi5dOrsAZmZm1nIO4GZmZiXkAG5mZlZCDuBmZmYl5ABuZmZWQg7gZmZmJeQAvhyRdKSkkDSoPfN2praWM487sl0L1QGWh3JKmirpks4sw/JK0khJK+Qzs5ImSpre2eWw9tfhAVzS8HxwO7bGsG/lYddI6t7AtDaU9BtJUyS9Iek1SfdL+oGk93fMEiyed5d8EDioI+fTEXIdh6Sbmxi+bSHPyGVcvHYh6ZLCMtR67d7ZZWwPkj6xvK6jfAIRkh5tYvg6khbmPJe0ch675v2wV5sK+x7T2fVSOM438jqyA+a/fV7+AS0Yp6+ksyU9Kmm+pDmSHpN0kaRtW1mOPXM5VmvN+C3VbVnMpBZJ3wW+DVwBfDYiFtXJfwgwGpgPXAY8CnQFtgG+CBwCbNSBRe4CfAcYBVzXQfMYDVwOvNkB014A7ClpnYh4sWrYEXl4jw6Y77I2AninRvojy7ogHeQTwOHAyBrDNqb2si9LC4DNJG0bEfdVDfsMsIi2HXd2Bb4FXALMacF4ZwJntWG+y7vW1kt7mQx8rirtW8A6wJer0u/sgPlvTzo+3wLU7W2QtBbwb6A3cCnwC2AV0j50EPAUUL39NmJP4OvABcBrrRi/RTolgEs6C/gGKWAdFRFv18k/hBS0HwL2joiXq4Z/Azitg4rbKpK6Al0j4q1Gx8n10GxdtMFfgd2Bw4DzKomSugGHAuOAT3XQvJelP9Y7GXyvioiOOPFrqfuB9UgH8+oD4OdYxtuZpPdFxOt5m1ght4tlITcKLium5V7XnhFxWe2xOtUXgAHAvhHx5+IASScBfTqlVC20zK+BS/oZKXhfBBxZL3hn3yOdbBxWHbwBImJ2RHyjaj4bSLpU0ouS3pT0hKRTJXWpyheSLpP0UUn35K75ZyR9qZBnELAwfx1R6AqamIdXuo+Ok3SKpP+QWtE75uGS9NXcPfNmLtMlkvpVlaXm9eLcLXOfpAW5m/JUQA3UW9Fc0sGz+ix5b2Bt0snUUiT1knS+pOm57P+R9D1JK9fI23A5G10/7U3pkkvN1riki/P6Xz1/31nSHyX9Ny/TS5KullS3p6epdZmHLXGpQlJvST/OZZubyzBJ0meqxptIan0XL4ssnodqXAOXtLKk7+f19qakaXl9rlGVb2Se1paSzpU0U9Lrkv4saf16y1vwDjAGOCyfHFamvzmpt6zmdpbzHCfp33n550i6XtJmheGXkFp1AP8tLP/wSv3k7XRjSTdLehW4ubh8Nea5paQr8/IukPS0pAsl9SzkOUHSg0qX7OZKelipB7EuSTtIGi/pVaVu2jsk7VMjX93jUDPzaLZeCvnWk3SdpHmSXpF0QRP78daSrpX0cq6ThyQd1cjytpSkT0m6K9fNvFxX21flWV3SOXndLJA0S9I/JX08Dz+L1IIGuKuw/Ic2M+sP5ve/VQ+IiEXVvZRKviDpgbxuZitd+t2okOdyUusb4PlCOXZoWa00blm2wCXpl6Tu7l8DJ0UDP8QuaRVgL+D2iJjS4Iw2BO4idWH8ApgFDAd+AgzKZSjaCrgK+B2pi/ww4HxJj0XErXn8EXnY7cCFebzqruivkOr0QuB14Pmc/os8zwmkZR8EnAT8j6ShtU5KCsvyUeAmUrfQd4EATqR13WSjgRskbRYRj+W0I4BJwOM15r0ycCvpwHsRqXW1C3BGTvtYa8rZivXTEn0kLXVSGBEv5Y9jgLMlbR0RD1Yt6yeAGyPi1Zz8KaAfab0/B6wPHA/cLmmLiJjVhnIWfYDUvfwn0jZYKcsYSd0jYlTO9wOgO+nEsHgi1lw5rgb2J23f5wBbk7a9nSTtWKPVfjEwm3TSvC7wNVLLaucWLM9o4H9J3YmV+y5GAC+Q9oGlSDoP+BLpEtLvgTVI28Gdkoblff+3QC/gQOCrQGWdTi5M6n2k3qa/AKfQTI+WpJ1zvjdI9f40qVX2CVILbF4OXBcA1+d3SN2sH61XCZJ2Iu0/LwFn5/kcBdwk6dCIuLJqlHrHoaY0Ui+r5LL8HTgV+DBwAmnbOaNQ5h1J6+g/pP1xHmk/v1jSWhFxdr3lbpSk04Afker2G6RLeMcD/5C0c0Tcm7P+jtSt/SvSpdNepOPPh4BrSdvMuqRj2chcdkjHmKb8N78fx7vBvzm/AY4F/kiq7z6k7fOufAx/Bvgl0BPYl7SPzc3jNhS3WiUiOvRFOjAHqcICOLeF42+Zx/t5C8a5mbQzrl6V/jNSC2FwIS1IO/nQQloPYCZwZSGtW857STPL+CKwRtWwzfOw6wEV0g/M6T8tpB2Z0wYV0u4lbQjvL6S9P6ctkbeZ+gjSQbhbXq6zcvoapIPKl4ANc76RhfFOzGlfr5reuTl9/9aUsxXrZ2QDy3hJzlvzVcjXP6/vH1eN/4mc96BC2qo15rMRqXfltBp1XKy7pdZlM3lXJl1uKeYR6YD7eFX6ZcXlqRo2tbh9kg4kAfyiKt9XcvpJhbSROe3aqrxfy+mbNbAOpgL/zJ//DVyeP3chndidQ439iHQgXqI8OX0A8CpwWSHtzGbqdWIedlqNYSOrtoMuwJPAK8DAGvmV368FHq237E3Ux79I9+ysV0hbA3iGdHLfvWqbqHscamZejdTLyVXp44CZVdvco6TA160q7zV5WdaoV5aq+U5vYtgHSJc0zqxKXyPXzV8LZZoPnFNnXiflZdyhwbKtk+s2SMei35NOaAbXyLtLzndsVfqgXLbfF9J+mvO+v5FytPW1LLvQK3eJP9HC8VbP7682mytTugtzb1JrZiVJa1VepLNtkW74KLonIv5d+RIRC0gb8QdpmTERMbcqrdJKPTvyGs7zuJ5UFwc0syzrAMNIB8IXCuO+QGpJtkik64BjgcOVuqo/RTqgXt7EKAeQNtBfVaX/pDC8ReVs5fppib2APWq8KmV6jtQKOVRSsXv/M6TegpsLeecXyr2apD6kA/4TwHZtKOMSIuLNyJeSJK0kqTfpDP+vwMbF7twWqmxbP65Kv4C0P9Xa9n5T9b3SxdjSfWE0cIDS5YjdSCdOTXWffxp4C7i2antYQDox3K2F865ehlqGAIOBX0XEtOqBhX11LtC/pd2geZ/YDhgbEc8WpjuXVP/vZ+ltqL2OQ7W8Q2o5Fv0N6FvYvrYENiO1MntVrYubSb0b7dUdfDDpJuSxVfPpTgr8u+TepyD1AnxYVZcc2yJSF/lQUqu5O3AMab08KekmSX0L2Q8lNXRurCrra6ReyZZun+1mWXahn0G6fvdrSQsi4pIGx6sE7tWbzfWujUhB4JT8qmXtqu/P1Mgzm9Sl1RL/rZE2KL9PrjFsMrBfM9PbIL/XOulp6YlQxWjSXaHDSV1Ot0TELFVdE80GAf/NB5LFIuJ5SXMK5WtJOVuzflritqh/E9sfSd1yHyF1h69OWg+jo3DToaR1SXcufwxYs2oaL9FO8onEV4DP8279FK1JOoi11CDgtYhY4q7ciHhT0tO8u96KqveF2fm9dwvn/UdSt/HBwP8Aj0TEAypcFy/YBFiJpu8ebsmd9a/UOImuZXB+f6hOvrNIJ5R3SfovKbhcB9xQPCGvoVK3tfb7xwp5indkt9dxqJaZEfFGjWlDWrfzSOsB4Pz8qqUt+2ZRZV7NPR3Si9TF/3VSC3mapPtJPVOXR8T9bSlA3i++BHxJ0kBSS/sEUs/VqPxeKesqvHtJtNrrbSlHWyzLAD6H1BKaCFwk6Y2IuKKB8aaQzs63bnA+lV6FC0itvFqervre1HWylt4oVr2DFNXa2etNvzK87r0CjYqISZImA6cDO5HOLpsdpZmyReFzc3mLWrN+2tvVpDPvz5DuafgEqbvyj5UMuYdiPKnleC6pa/E1UjA5j/o3gNasC6WnE6qdQurVGEO6zj2L1L24L+maZlt6yhpZf0Xtsi9ExIuSJpAOiJuTrqk3pQvpIHhgS+bRhOb2wVqa3WYj4nFJG5N6dvbM70cB4yXtG/Vvwm1uv68e1l7HoVqaK2dl+pXtbCRwRxN5az7j3wqVee1P04/NzgWIiDGSbiWdSO9Oum59qqTTIuInTYzbIrkXZoyksaRej30k9Y10n0sXUvw6pInRO+rJobqW6WNkEfGS0g9q/AO4TNKbEdHsM9UR8Yak8cC+kjaM+jey/Yd3r3v+tX1KnorSyvGm5vfNgH9WDdukMLyWpwv5qm3cyvJAaoX/kHfvTG/KVNLNTj2KrXClH81Zg3fL3pJydtT6aVhEzFH6UZtDJH2ZFMink7bLii2BLUiPOV5SHD93cddrgVdaN2uy5Dr+QI28nwH+HhGfrZpPra65lmyHU4G9JA0otsIlrURq/d3Tgmm1xqWkk6LKnelNmUIKjA/H0r9RUK29Tmafyu9bkU7omp5harleB1yXe0t+RLrpajfSSV4tU/P7ZjWGbVKVpz20R71Ujq1vLIN9szKvaRFRrxekcjnud8DvJK1KutHu+5LOjYiFtNN2ERHvSJpEeq68P+lkegqpdX5vA7077dbYasQyf4wsr4jdSAfMK1TjkYoaRpLOcsbm65BLUHrU6aw8/VmkLpYR+W7n6ryrq8ajEw2U+23SNbnqrtR6bsjvXy9ec5X0MVJwu6HmWCy+TnMf6Xrt+wvjvp/8OFErXUK6U/wL1d3jVW4AViM9M1l0amF4i8rZUeunFcaQrjN/jtRFOjYiil21lbPq6scOR5DueK2nEiCqr+efXCPv2zXm05d0Xa7aa3l4I9thZds6tSr9BNIlqSa3vXZyHWnfPSnfe9CUsfm9Ziu96npk5ccxWrofVnuAtI6+KKl/jXkqvy9xvMnd5g/kr01eVsjHuUmkfWLxr4Pl680nkO7Iv7eJ0VujPerl36RLXl/J13iXULUe2upK0ondd2v1SklaO793z5e4Fsv3pjxJuuyyak5u0fJL2lE1fi1N0vtI++xbvHs3+1hSL8Wy3D4b0ik/5BIR0yTtSuq+vEbSfhFxWzP575N0BOm6xBOSir/EtjXpJphZvPtjLl8gdQHdL+n3pOtQa5BaVJ/M71NbUfR7gd0lnUI6AZnZXLlz2R+V9GvSHd23SLqB9DjSScCzpJZwc04lnW3eJekC0oZ0AqnVO6QVy0BEPE/tX/Kq9nvgaOAcSZuQDlw7kx5vuTG/WlPOjlo/AJ+RVOua6b8i4snC9xtJPRDnkbaj6hbi4/l1jtJz0DNId0sfRANd/BExWdLfgTNzEJhO6oJdKliQ7nQ+U+k50ttIJwgnANOA6oPmvaRr5b+U9GdSV/sNxRvuCm4mPdr35XxT1T9IPQvHkw7WF9YYp93klmvd56Uj4g6l34f4mtJz3zeQuizXB/YhXac+MmevBL0f5u7Ot0j3PcxsYdnekXQc6Ze7HpRUeYysH+mSyoGkbXCCpFmk7fU5YCDp8aFZNPFIXMFXSTci3i3pN6QGwFF5uQ7NLcf20uZ6yXVyFKlX4TFJF5HqZC3SY1sHkp6YaLOIeFLpMbKfAP+S9CdSnQ4kBdB5pHXfB5iShz9M2i62JZ143xwRlcdUK8t/et7WFwB3Fm8grHI08ClJ4/K480j75uGkhtXIiJiXy3prPoZ/WdJWpP3qVdJ63I/U5f75qnL8RNKVpN8PmRDNPCrcJh11e3vlxbuPWB1bY9jGpDPR14CdGpjWxqQ7Kf9DWkHzSXcBfg9Yuypvf9LdqM+SNuYXSScMpwI9CvmCwmMqhfRLgKlVaZuT7mCen8ebWG8Z8/AupMdxJpOu98wknYz0r8p3JDUeBSHdtf3vPO4zpGdsj6qVt4n511zGqjxLPUaW03uRnpN8Ltfj08D3gZVrTKPhcrZw/YxsYBkvoZnHyKh6RCmPc1EeVvMxIdLdv+NId57PIx2wh5Du45hYo46r624gKRjNJ3WpX0o6IFU/RtaNFOimkrbryaQTvKW2B9Ids7/K9fVOcThVj5HltJXz+vpvrufn8vrsVZVvZJ7WhlXpg3L6kQ2sg6nkx8iaydPc45iHkS4zzct19hTwB6oeDcplnU7quQhgeE6fSNOPLY2kxuN3pMB0LfByrvv/kO7PWC0PP450UjWTtF0/m7e1D9arjzz+Dnm7mUe6zn8H6de/GtpHqXEcamZeLaqXWttXTt+E9Lji84VtZgJwYiPlKEynyfVRyLMf6SRnLun+hadJl112y8NXId0MeT8peL9OOrH+DlWPeZJuBH2adFIbpJOkpua7NenpjH/ldbswbwO3Ap9uYpwjSDcdvpa3zydIjZxhVfl+mOussh4aerStNa/Ks45mZmZWIv47UTMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB/D3EEmPShre2eVoCUl3SNqms8vRUpImSjo2fz5c0vhWTufPkka0b+mWmP46kiZLWrmj5lFn/oMkhaRunTF/61ySdpf0YDPDL5d0+rIs03uJA3hJSJoqafeqtCMl/bPyPSI2j4iJedhISZc1MM03JL0m6QVJl0harcHytPnALOljwLyIuD9/30LSXyS9JGmpP6qX1FvStZLmS3pG0meamfZISQvzss2RdKekD7e2rM2JiDERsWe9fLXWSUTsExGjOqJcefovAn8Dju+oeRTV2k7babqH53X5Wt5m3yl8f60N091E0qI6efpIulTSi5JelfS4pK82OP0WBShJe0uaUvi+sqQbJf2tqX1T0o6SxkuaK+llSXdLOrzReTZaltaIiL9GxNZtLYvV5gBuH4uI1YAhwDbAN5fhvD8PjC58XwhcCRzTRP5fAW8B6wCHA7+RtHkz078iL1tf4J/ANZJUnWkFaB2OAU7o7EK0RT5JWi2vz32AGZXvOa0j/RIQsBHQC/gEMLWD54mkVYAbgO7AvhGx1IlK7nEbD9wCbACsBXwZ2K+jy5fn/17fd5ZvEeFXCV6kA8buVWlHAv+szgPsTQp0C4HXgAcbmSbwE+Cmwvf9gPuBV4FpwMjCsGeByNN/DfhwTj8amAzMBv4CrN/EvFcC3gAG1Bi2Ydo0l0hbNS/TRoW00cBZTUx/JHBZ4fvmubxr5Xq7AzgXeAU4s17ZgT2Ax4G5pAP634Fjm1gPmwMT8rRfBP6vqXUCTCxMpwtwOvAMMBO4FFgjDxuUyz8i1/1LwLcK89wemJTX1YvAzwrDugGvN7Mu1sjzmpXnfTrQpbhswE9zvfwX2KeJ6YwG3snr9TXgfxsodxfgNOA/wMukE7jedfaF4cD0GukDgevzPJ4GPl8YthPvbssvAD/K6TNZcjvepsZ0pwB7N1OeLYDbcv1MBg7K6V/O6/vNPO2rGtjP987zWy1vGzcAKzeTfxJwTp1pfhx4CJgD3A5sVhj2AvBV4BHStj2GtG/2yevxnULd9AHOAv4IXAHMAz4LrEI6uX4emA6cDXQvLk/VdvpgHvcy4Brg9EaOgX7VWLedXQC/GlxRLQjg+fNICgGs3jSBAcDDwM8Lw4cDW+aD7FakwFA5OA3KB75uhfwH5YPPpqSgcTpwZxPz3hyY38SwWgF8G+CNqrRTgBuamMbi5QdWzgeVaYV6WwR8KZdzlebKTgr6rwIHk1pDX83jLxXAgZ75QPZ1oEf+/qGm1glLBvCjcxk+QDqAXwOMrqrv3+Xybk0KDJvm4XcBn8ufVwN2qJrPQ8ABTdTVpaTA1zPP50ngmMKyLQSOA7oCXwBmAGpkO22g3CcDd5O2v5WB3wJj62y3w6kK4LlsDwPfIAWgjUgnDB/Nw+8HDimso8o62QRYVGd+l5GCzghgw6phq+f1fXguw3akE7cN8/DLaUGAIgW854A7gavJgbCJvL1y3X64mTw75PJtm8t3fF6/3fLwF0gns+uQeqqmAEcWyjKlanpn5fW3L+m4sArpxP920n6yDnAv+SStOA3S/jADOJG0Hx1O2o8cwFv5chd6uVyXr+fOkTQH+HU7TXMeqYU9E/hOZUBETIyIhyPinYh4CBgLfLSZaZ1AatlMjohFwA+BIZLWr5G3F+ksvFGrkVoIRXNJB+OmfCrX0zTSAeygwrAZEfGLiFgUEW/UKfu+wGMRcXVELATOIx34atkfeCEizomIBRExLyLuaXAZDye1nJ+O1F36TeDQqm7K70bEGxHxICmoVK4vLgQ2lLRWRLwWEXdXTXseqc6XIKkr8Gngm7msU4FzgM8Vsj0TEb+LiLeBUcC6pAN1SzRV7hNIB/vpEfEm6STn4FZ0zX4E6BERP46ItyLiSeAPwKF5+EJgI0l9WrhOKmX8E+nE7XFJTxSu838ceCRSF//bEXEvqdX8yRaWv2hN0onAH/L21pQ++f35OmX/ZUTcl8t3IelEadtCnnMj4sWImAXcTLqc1py/R8TN+bjwBmm7/U5EvBTpnoszWXL7qdgFeDMifh0RCyNiDOnE0lrJAbxcDoqIXpUX6Uy2PabZk9Sq2YR0Fg2ApA/lm2dmSZpLuma9Vu3JALA+8PPCCcYrpGuH/WvknU3zwbfaa6TWTtHqNH8ScGWuq7UjYteIuK8wbFoLyt6vmD8iosb4FQNJ3cGt0Y/UhV3xDKk3oBgsiycOr5NObCDdN7ARKcDcK2n/qmn3JHWhVluL1GKtnm9xnS2eZ0S8nj+29LpzU+VeH7i2UO+Tgbdp+QnC+sCgqhPcrwHvz8NHkHqRnpR0j6S9Gp1wRMyPiO9FxBBS0LwB+JOknnm+u1TN95Okk5zWmgEcAVwhaddm8r2c35ub1/rA/1WVry9NrF+WXDdNWbzt53tK3k/z209FP1IXO1V5rZUcwN+7lrqLu9nMEX8HLiFd66z4IzAOGBgRawAXkIJaU9OfBpxQPMmIiFUi4s4aeZ8i7f+1dvRangS6SRpcSNsaeLTB8atVl7+5sj9PCszA4oPWQGqbBnywwXlWm0E64FasR+pifLHOeETEUxFxGLA28GPgakmr5vJ2I12WqPU4z0uk1mn1fJ+rN8+mitLC/NNI19SL9d4jIlo6/2nA41XT6RkRHwfIPSufJtXP+aQbGldqaXkjYi6pG3l1Uj1NA8ZXzXe1iDi5MkoLl6Myn7HAF0k9ZDs1kWcOcB/Nt/anAd+uKt/7IuKaRopRLz2fzL5AY9vP86RLJVTltVZyAH/vepHUImnJOj4P2ENSpQutJ/BKRCyQtD1QfGxrFukGlw8U0i4Avlm5M1zSGpIOqTWj3DX4Vwpd8kp6kFqESOqh/PxyRMwnXRP+nqRV80HtQJa8i70tmiv7TcDmkj6Rg+GXebdlV+1G4P2STs6PAPWU9KE8rN46GQt8VdIG+ZGhH5LupG/2Madc3s9K6hsR7/BuS/vt/L49MDUilmrt5G7xK4Ef5LKuT2q5NvsIYjNeZMltop4L8rzXz8vRV9KBrZjvP/P4J+ftppukrSQNzelH5O7zt0mXXoK0/c4EukpqMpAoPf43VFL3fGf4l0knPlOA64BtJH06D19J0g6SNsqjL1Uf+dGyC+otUKTHC08Bbsr7Xy2nAJ/Py90770Pb6t3HFS8EviRpWB62mqQDJL2v3vxz2ddW/UdLxwLfUXrcbm3gW9Tefv4B9JD0+bx+DiP1ilgrOYC/d12V31+W9O9GRsjXwC4FzshJJ5IC5jzg26QDfSXv68APgDty19wOEXEtqfV3uaRXSXe27tPMLH/LktfK1ifd+VppVb8BPFEYfiLpppmZpIPGFyKitS3wJTRX9oh4CTiE1PJ6GRhMuvGn1nTmke5Y/xipZfIU8D95cL11cjHphOQfpLu9F5ButGvE3sCjSs9E/xw4NCIW5GGHkwJlU74EzCfduf1PUs/LxQ3Ot9qPgNPzNnFKA/l/TurlGZ+3s7uBDzU/ytLyCeG+wI6kbtlZwG94tzt4f+CJPI8fAZ/K9z/MJt2EdV8uc63rv11IAekVUhfwTqTHut7M4+8FHEVqYc4gXQPunse9ENguT/vynDaQJrafGst1IWl/vEU1fvAo0u8+7JmXfSrpxOKXpJNOIuIO0gnHb0kndk+STsQb6Rl4kLRunsnl791Evm8Dj5H22wfysv2kRlnfIN0zcCLpEtp+pMsR1kpKPSBmnUPph2i+FPnHXKx95RbR30mPRy2ol986Vm753gtslXsDzFrNAdzMzKyE3IVuZmZWQg7gZmZmJeQAbmZmVkLLxQ/Rr7XWWjFo0KDOLoYVPPFEuvl744037uSSmJmt2O67776XIqJvdfpyEcAHDRrEpEmTOrsYVjB8+HAAJk6c2KnlMDNb0Umq+Yt17kI3MzMrIQdwMzOzEnIANzMzK6Hl4hq4mZl1nIULFzJ9+nQWLPCP8S3PevTowYABA+jevXv9zDQYwCX1An4PbEH6Dd2jSb9RfQUwiPQbvJ+KiNn5n5p+Tvpt3tdJfw7f0G9xm5lZ+5s+fTo9e/Zk0KBBpEO0LW8igpdffpnp06ezwQYbNDROo13oPwduiYhNSH/hOBk4Dbg1IgYDt+bvkP4AYnB+HU/6QwEzM+skCxYsoE+fPg7eyzFJ9OnTp0W9JHUDuKTVgV2AiwAi4q38P7QHAqNytlHAQfnzgcClkdwN9JLUlj+3NzOzNnLwXv61dB010gL/AOmv+f4g6X5Jv5e0KrBORDwPkN/Xzvn7k/5EvmJ6TjMzM7N20kgA7wYMBX4TEduQ/jf4tGby1zqFWOovzyQdL2mSpEmzZs1qqLBmZlZOkvjc5z63+PuiRYvo27cv+++/fyeWammjRo1i8ODBDB48mFGjRtXMc9VVV7H55pvTpUuXJX6E7K233uKoo45iyy23ZOutt9MQs60AACAASURBVF7ih7CGDx/OxhtvzJAhQxgyZAgzZ85sc1kbuYltOjA9Iu7J368mBfAXJa0bEc/nLvKZhfwDC+MPIP3J/RLyH9VfCDBs2DD/p6mZ2XvYqquuyiOPPMIbb7zBKquswoQJE+jff/nqnH3llVf47ne/y6RJk5DEtttuywEHHMCaa665RL4tttiCa665hhNOOGGJ9N/97ncAPPzww8ycOZN99tmHe++9ly5dUlt5zJgxDBs2rN3KW7cFHhEvANMkVX4UezfgMWAcMCKnjQCuz5/HAUco2QGYW+lqNzOzFdc+++zDTTfdBMDYsWM57LDDFg+bP38+Rx99NNtttx3bbLMN11+fQsrUqVPZeeedGTp0KEOHDuXOO+8E0s88Dx8+nIMPPphNNtmEww8/nIi2tQX/8pe/sMcee9C7d2/WXHNN9thjD2655Zal8m266aY1/yfiscceY7fddgNg7bXXplevXh36M+GNPgf+JWCMpJWAp4GjSMH/SknHAM8Ch+S8N5MeIZtCeozsqHYtsZmZtdrJJ5/MAw880K7THDJkCOedd17dfIceeijf+9732H///XnooYc4+uijuf322wH4wQ9+wK677srFF1/MnDlz2H777dl9991Ze+21mTBhAj169OCpp57isMMOWxwU77//fh599FH69evHTjvtxB133MFHPvKRJeZ59tlnM2bMmKXKsssuu3D++ecvkfbcc88xcOC7HcgDBgzgueeea7gett56a66//noOPfRQpk2bxn333ce0adPYfvvtATjqqKPo2rUrn/zkJzn99NPbfGNhQwE8Ih4AarX7d6uRN4AvtqlU7WDB22/Ro+tKnV2MZpWhjGZm7WWrrbZi6tSpjB07ln333XeJYePHj2fcuHH89Kc/BdKjb88++yz9+vXjpJNO4oEHHqBr1648+eSTi8fZfvvtGTBgAJBOIqZOnbpUAD/11FM59dRTGypfrRZ8S4Ls0UcfzeTJkxk2bBjrr78+O+64I926pTA7ZswY+vfvz7x58/jkJz/J6NGjOeKIIxqedi3v2V9i69F1JdYbf0j9jJ3o2T2v6uwimNkKppGWckc64IADOOWUU5g4cSIvv/zy4vSI4E9/+tNSXdMjR45knXXW4cEHH+Sdd96hR48ei4etvPLKiz937dqVRYsWLTW/lrTABwwYsMSNZ9OnT1/8z4yN6NatG+eee+7i7zvuuCODBw8GWHy9v2fPnnzmM5/hX//6V5sDuH8L3czMlpmjjz6ab3/722y55ZZLpO+111784he/WNwKvv/++wGYO3cu6667Ll26dGH06NG8/fbbLZrfqaeeygMPPLDUqzp4V8owfvx4Zs+ezezZsxk/fjx77bVXw/N6/fXXmT9/PgATJkygW7dubLbZZixatIiXXnoJSD9re+ONN7LFFlu0aDlqcQA3M7NlZsCAAXzlK19ZKv2MM85g4cKFbLXVVmyxxRacccYZAJx44omMGjWKHXbYgSeffJJVV121w8rWu3dvzjjjDLbbbju22247vv3tb9O7d28Ajj322MXX3q+99loGDBjAXXfdxX777bc4yM+cOZOhQ4ey6aab8uMf/5jRo0cD8Oabb7LXXnux1VZbMWTIEPr3789xxx3X5vKqrXfttYdhw4ZFR9yp5y701qt0GxW7k8ysnCZPnsymm27a2cWwBtRaV5Lui4il7kNzC9zMzKyEHMDNzMxKyAHczGwFsDxcLrXmtXQdOYCbmb3H9ejRg5dfftlBfDlW+T/w4mNy9bxnnwM3M7NkwIABTJ8+Hf9x1PKtR48ei3+YphEO4GZm73Hdu3dngw026OxiWDtzF7qZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlVBDAVzSVEkPS3pA0qSc1lvSBElP5fc1c7oknS9piqSHJA3tyAUwMzNbEbWkBf4/ETEkIobl76cBt0bEYODW/B1gH2Bwfh0P/Ka9CmtmZmZJW7rQDwRG5c+jgIMK6ZdGcjfQS9K6bZiPmZmZVWk0gAcwXtJ9ko7PaetExPMA+X3tnN4fmFYYd3pOMzMzs3bSrcF8O0XEDElrAxMkPd5MXtVIi6UypROB4wHWW2+9BothZmZm0GALPCJm5PeZwLXA9sCLla7x/D4zZ58ODCyMPgCYUWOaF0bEsIgY1rdv39YvgZmZ2QqobgCXtKqknpXPwJ7AI8A4YETONgK4Pn8eBxyR70bfAZhb6Wo3MzOz9tFIF/o6wLWSKvn/GBG3SLoXuFLSMcCzwCE5/83AvsAU4HXgqHYvtZmZ2QqubgCPiKeBrWukvwzsViM9gC+2S+nMzMysJv8Sm5mZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gFtdC95+q7OLUFcZymhm1p66dXYBbPnXo+tKrDf+kM4uRrOe3fOqzi6Cmdky1XALXFJXSfdLujF/30DSPZKeknSFpJVy+sr5+5Q8fFDHFN3MzGzF1ZIu9K8AkwvffwycGxGDgdnAMTn9GGB2RGwInJvzmZmZWTtqKIBLGgDsB/w+fxewK3B1zjIKOCh/PjB/Jw/fLec3MzOzdtJoC/w84H+Bd/L3PsCciFiUv08H+ufP/YFpAHn43Jx/CZKOlzRJ0qRZs2a1svhmZmYrproBXNL+wMyIuK+YXCNrNDDs3YSICyNiWEQM69u3b0OFNTMzs6SRu9B3Ag6QtC/QA1id1CLvJalbbmUPAGbk/NOBgcB0Sd2ANYBX2r3kZmZmK7C6LfCI+GZEDIiIQcChwG0RcTjwN+DgnG0EcH3+PC5/Jw+/LSKWaoGbmZlZ67Xlh1y+AXxN0hTSNe6LcvpFQJ+c/jXgtLYV0czMzKq16IdcImIiMDF/fhrYvkaeBcDy/asfZmZmJeefUjUzMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MSqhvAJfWQ9C9JD0p6VNJ3c/oGku6R9JSkKyStlNNXzt+n5OGDOnYRzMzMVjyNtMDfBHaNiK2BIcDeknYAfgycGxGDgdnAMTn/McDsiNgQODfnMzMzs3ZUN4BH8lr+2j2/AtgVuDqnjwIOyp8PzN/Jw3eTpHYrsZmZmTV2DVxSV0kPADOBCcB/gDkRsShnmQ70z5/7A9MA8vC5QJ8a0zxe0iRJk2bNmtW2pTAzM1vBNBTAI+LtiBgCDAC2BzatlS2/12ptx1IJERdGxLCIGNa3b99Gy2tmZma08C70iJgDTAR2AHpJ6pYHDQBm5M/TgYEAefgawCvtUVgzMzNLGrkLva+kXvnzKsDuwGTgb8DBOdsI4Pr8eVz+Th5+W0Qs1QI3MzOz1utWPwvrAqMkdSUF/Csj4kZJjwGXSzoTuB+4KOe/CBgtaQqp5X1oB5TbzMxshVY3gEfEQ8A2NdKfJl0Pr05fABzSLqUzMzOzmvxLbGZmZiXkAG5mZlZCDuBmZmYl5ABuZmZWQg7gZmZmJeQAbmZmVkIO4J1owdtvdXYRzMyspBr5IRfrID26rsR645fPR+Znzn4UgPXGH8Kze17VyaUxM7NqboGbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJOYCbmZmVkAO4mZlZCTmAm5mZlZADuJmZWQk5gJuZmZWQA7iZmVkJ1Q3gkgZK+pukyZIelfSVnN5b0gRJT+X3NXO6JJ0vaYqkhyQN7eiFMDMzW9E00gJfBHw9IjYFdgC+KGkz4DTg1ogYDNyavwPsAwzOr+OB37R7qc3MzFZwdQN4RDwfEf/On+cBk4H+wIHAqJxtFHBQ/nwgcGkkdwO9JK3b7iU3MzNbgbXoGrikQcA2wD3AOhHxPKQgD6yds/UHphVGm57Tqqd1vKRJkibNmjWr5SU3MzNbgTUcwCWtBvwJODkiXm0ua420WCoh4sKIGBYRw/r27dtoMczMzIwGA7ik7qTgPSYirsnJL1a6xvP7zJw+HRhYGH0AMKN9imtmZmbQ2F3oAi4CJkfEzwqDxgEj8ucRwPWF9CPy3eg7AHMrXe1mZmbWPro1kGcn4HPAw5IeyGn/B5wFXCnpGOBZ4JA87GZgX2AK8DpwVLuW2MzMzOoH8Ij4J7WvawPsViN/AF9sY7nMzMysGf4lNjMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADezJSx4+63OLkJDylJOs47SrbMLYLYiWfD2W/ToulJnF6NZPbquxHrjD+nsYtT17J5XdXYRzDqVA7jZMlSG4OjAaFYO7kI3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxKqG8AlXSxppqRHCmm9JU2Q9FR+XzOnS9L5kqZIekjS0I4svJmZ2YqqkRb4JcDeVWmnAbdGxGDg1vwdYB9gcH4dD/ymfYppZmZmRXUDeET8A3ilKvlAYFT+PAo4qJB+aSR3A70krdtehTUzM7OktdfA14mI5wHy+9o5vT8wrZBvek4zMzOzdtTeN7GpRlrUzCgdL2mSpEmzZs1q52KYmZm9t7U2gL9Y6RrP7zNz+nRgYCHfAGBGrQlExIURMSwihvXt27eVxTAzM1sxtTaAjwNG5M8jgOsL6Ufku9F3AOZWutrNzMys/XSrl0HSWGA4sJak6cB3gLOAKyUdAzwLHJKz3wzsC0wBXgeO6oAym5mZrfDqBvCIOKyJQbvVyBvAF9taKDMzM2uef4nNzMyshBzAzczMSsgB3MzMrIQcwM3MzErIAdzMzKyEHMDNzMxKyAHczMyshBzAzczMSsgB3MzMrIQcwM3MzErIAdzMzKyEHMDNzMxKyAHczMyshBzAzczMSsgB3MzMrIQcwM3MzErIAdzMzKyEHMDNzMxKyAHczMyshBzAzczMSsgB3MzMrIQcwM3MzErIAdzMzKyEHMDNzMxKyAHczMyshBzAzczMSsgB3MzMrIQcwM3MzErIAdzMSmnB2291dhHqKkMZrby6dXYBzMxao0fXlVhv/CGdXYxmPbvnVZ1dBHsPcwvczMyshBzAzcxsuVeWyxHLspzuQjczs+VeGS6ZwLK9bOIWuJmZWQk5gJuZmZWQA7iZ2QquLNeXbUm+Bm5mtoIrw/VlP5K3NLfAzczMSqjDArikvSU9IWmKpNM6aj5mZmYrog4J4JK6Ar8C9gE2Aw6TtFlHzMvMzGxF1FEt8O2BKRHxdES8BVwOHNhB8zIzM1vhdFQA7w9MK3yfntPMzMysHXTUXeiqkRZLZJCOB47PX1+T9EQ7l2Et4KV2nma7Us1qWr5M2+tqhFyX7cd12U68XbYr12U76aDtcv1aiR0VwKcDAwvfBwAzihki4kLgwg6aP5ImRcSwjpr+isR12X5cl+3Hddl+XJftZ1nWZUd1od8LDJa0gaSVgEOBcR00LzMzsxVOh7TAI2KRpJOAvwBdgYsj4tGOmJeZmdmKqMN+iS0ibgZu7qjpN6DDuudXQK7L9uO6bD+uy/bjumw/y6wuFRH1c5mZmdlyxT+lamZmVkKlD+D1frJV0sqSrsjD75E0aNmXshwaqMuvSXpM0kOSbpVU89EGa/ynhCUdLCkk+Q7gJjRSl5I+lbfNRyX9cVmXsSwa2MfXk/Q3Sffn/Xzfzijn8k7SxZJmSnqkieGSdH6u54ckDe2QgkREaV+kG+T+A3wAWAl4ENisKs+JwAX586HAFZ1d7uXx1WBd/g/wvvz5C67L1tdlztcT+AdwNzCss8u9PL4a3C4HA/cDa+bva3d2uZfHV4N1eSHwhfx5M2BqZ5d7eXwBuwBDgUeaGL4v8GfSb6LsANzTEeUoewu8kZ9sPRAYlT9fDewmqRy/CLBs1a3LiPhbRLyev95Ner7fltboTwl/H/gJsGBZFq5kGqnL44BfRcRsgIiYuYzLWBaN1GUAq+fPa1D1+x2WRMQ/gFeayXIgcGkkdwO9JK3b3uUoewBv5CdbF+eJiEXAXKDPMildubT052+PIZ1h2tLq1qWkbYCBEXHjsixYCTWyXW4EbCTpDkl3S9p7mZWuXBqpy5HAZyVNJz1F9KVlU7T3nGXyc+Id9hjZMlL3J1sbzGMtqCdJnwWGAR/t0BKVV7N1KakLcC5w5LIqUIk1sl12I3WjDyf1Ct0uaYuImNPBZSubRuryMOCSiDhH0oeB0bku3+n44r2nLJO4U/YWeN2fbC3mkdSN1C3UXNfHiqqRukTS7sC3gAMi4s1lVLayqVeXPYEtgImSppKukY3zjWw1NbqPXx8RCyPiv8ATpIBuS2qkLo8BrgSIiLuAHqTfSbeWaeh42lZlD+CN/GTrOGBE/nwwcFvkuwxsCXXrMnf7/pYUvH2dsWnN1mVEzI2ItSJiUEQMIt1PcEBETOqc4i7XGtnHryPdYImktUhd6k8v01KWQyN1+SywG4CkTUkBfNYyLeV7wzjgiHw3+g7A3Ih4vr1nUuou9GjiJ1slfQ+YFBHjgItI3UBTSC3vQzuvxMuvBuvybGA14Kp8H+CzEXFApxV6OdVgXVoDGqzLvwB7SnoMeBs4NSJe7rxSL58arMuvA7+T9FVSl++RbvAsTdJY0iWbtfL9At8BugNExAWk+wf2BaYArwNHdUg5vG7MzMzKp+xd6GZmZiskB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyADczMyshB3AzM7MScgA3MzMrIQdwMzOzEnIANzMzKyEHcDMzsxJyAH+PkLSzpCcayPd/kn7fQWXoK+kJST06Yvp5HqtIukHSXElXtcP0LpB0RjPDR0q6rJnhU/N/pLdm3k2OK2l4/pejTiXpMkkjWzjOUEm3d1CRGpn/7vl/1m0FJOl4Sdc2M3ySpPfEv1I6gLdQPui+Iek1SS9IukTSas3kHy7pnZx/Xg5w7f7XchFxe0Rs3EC+H0bEse09/+w04A8RsaB6gKQrJe0haWVJL7RhHgcD6wB9IuKQqnmsKykkrVNI+1YTabcARMTnI+L7OX25CJrNkbRe3pYqr5A0v/B9584uY0T8G3hD0j4dPS9J3XIdDOqAaZ9RqNcFkt4ufH+wDdPdX9LjdfJ8QNI4SS/nk9UHGw06LQ1Qkk6q7A/5ex9J9+WTt65NjHOApDtyXcyUdKukvRqdZ6NlaY2IuDAiPt7WspSBA3jrfCwiVgOGANsA36yTf0bOvzrwDdL/7W5WnUlSaf+fXdLKwAigqdbqtsC/ga2AR9owq/WBJyNiUfWAiHie9P+7uxSSdwEer5H2jzaUodNExLMRsVrllZO3LqQt1fJt6iDcwcYAJ3TCfNtNRHy/UM8nAbcX6nnrDp79FaT9ZACwFnAs8FIHzxNJawN/A+4HjoiIt2vkGQFcClwArJtfZwEHLoPyqZO25+WSA3gbRMQLwF9IgbyR/BER1wGzgc0kDcqth2MkPQvcBiBpB0l3SpqTz7yHV6YhqbekP0iaIWm2pOty+hKtR0nfkPRcodW/W05foks4n0k/muc1UdKmhWFTJZ0i6aHcCrhCTXePfwiYExFLtWAlrUn67/mXgWGkQN4kSZvmsszJZTsgp38X+Dbw6Xzmf0yN0f9BDtZ5R98G+HlV2odzPnIPypmSVgX+DPQrtLL65WmuJOnSXJePShpWNc8hTdVRbm09kJflTklbNbHMq+SyzJb0GLBdc3XUnNxy+pWkWyTNB3bO6/mBvAzPquqygaRdJN2dl2GapM/VmO7qkv4h6dx8IN1f0uQ8zemSvlrIPhHYQ1L3Jso4QNKNkl6R9JSkowvDzpQ0Ni/HPEmPSBraxOJWTsQezevsk4Xp/K+kWXlfOaKQ3kPSz/Jyvijp181s182StJWkv1XWm6SPFYZ9Iu978/K8vqgUIK8CNipsZ2tUTbMrMBS4OCLeiIiFEXFvRPy1kOejkv6Vt6v7JH04p59H2uYvydP+cQuWpR9pvd0OHBcR79TI0x04G/hmRIyOiHkR8XZETIiIEwv5TszL/kpez/1y+mpKx7xjJT2dh/80D9sOOAfYPZd9ek6/WtJ5kv4KzAe2U+oluFzSS3k6Xy/Mu7pH4QBJU3Jdnd1ofZRCRPjVghcwFdg9fx4APAz8vJn8w4Hp+XMX4OPAQmBjYBAQpLPZVYFVgP7Ay8C+Of8e+XvfPI2bSGfnawLdgY/WmM/GwDSgX/4+CPhg/jwSuCx/3oi0Q+yRp/W/pBbsSoVl/RfQD+gNTAY+38RyfhG4qSptN2AO8BrwVv78Vp7nnErZq8bpnsvwf8BKwK7APGDj6vI3UY4RwIP58zDSAX5wVdobhWW8BDizug4L0xsJLMjroyvwI+Duqu2hZh2RDsIzSSc3XXPZpgIr19iWziIdOHsDA0mtr+lNLWdh/gFsWJV2Gekk8cOkbWjlXI9b5O9bk1pz++f8G+Q6/hTQjdTiG1KY1sicNgkYWZjPLGDH/Lk3MLSqHK8DmzVR7juAXwA9cj29xLvb8pl5He2V6+1s4J9NTKdbroNBhbTdgUXAd/L2dABpm1s9D/8lcC1pH1oduBn4fp16PhaYWJXWC3gBODSXcwfglVyfIm3j2+a8xTrdH3i8zvzuJrWEDwH6Vw37IOmYsGtenwfk7WyNPHwScGgLjmknAQ8ATwHn1Mk7LNd332byfBZ4FNgw1/+PgAl52Gp5/KuAnnlZXgU+UijLLVXTuzpvH9vx7vZ8DTCWdNzcCHgG+HT1NEjH0/nAfrksp+dto+H6WZ5fboG3znWS5pGC5EzSgaI5/STNIW2E3wE+FxHFG85GRsT8iHiDtPHfHBE3R8Q7ETGBtEPuK2ldYB9SgJgd6cz87zXm9zZpI99MUveImBoR/6mR79OkoDshIhYCPyWdROxYyHN+RMyIiFeAG2i6t6EXKQgsFhG3RkQv4DrygYgUtPpGRK8myr4DaSc/KyLeiojbgBuBw5qYb7W/A1sotfp3JnV7PgWsVUi7OyLeanB6kILHzZG6E0eTAmBRU3V0HPDbiLgnUitlFPBmXsZqnwJ+EBGvRMQ04PwWlK+WayPirrwNvRkRt0XEI/n7g8DlwEdz3s+SDnhXRsSiiHgpIh4oTKs/qV7HRMTIQvpC0jbWM5e7umdlHmm7WIKkDYDtgdMiYkEe7w9AsdX/94j4S6HOG+rlKlhAOjFbGBHjSPW+kaQupGB8ct6HXiUFmNbc1PRJ4P6IuDyv37tJvTifyMMXAZtLWq1GndbzMVJP1feBabm1XdnujgSuzOv0nbx8T5FOXFrrA6QTx0vr5OsDLIqIWc3kOQH4XkRMyceVkcCukvoU8vwgUuv9P8A/qb9+r4zUC/EO6WTpIOAb+bj5JGl/WarXiNStf1dE3JTLchYwt868SsMBvHUOioiepBbbJqSz66VuMCrkn5EDVu+IGBIRl1dNb1rh8/rAIbm7Z04O/B8hXWcaCLwSEbObK1xETAFOJu04M3NXU78aWfuRzlwr472Ty9K/kKd4w9nrpOBay2zSGfViuVt1Din4jiKd7KwPzJD0syam0w+YFkt23z1TVaYmRcRUYDqpznYhtWoB7iqktfT6d3Ud9NCS9ys0VUfrA1+vWpcDSctYrR9LbgfP1MjTEsVpIenDSpclZkmaSwpia+XBA4FaJ3gVB5BaL7+rSv94HvZsnvaHqob3JLVCq/UDXoqI+YW06nVcXaerNlO+Wl6KJa/fVtbL+0kntw8W1smNwNotnD6k9btr1fo9EFg3IiJ//jQpAN/azGWApUTErIj4ekRsQtr3/0tqiVbme2TVfIdQe7tq1J3A94AJqnF/TsHLQDdJfZvJsz7w+0LZXiT1vA0o5Gn0uFJR3J7XJbXiq/eXWseIJfarSPfOzKgzr9JwAG+DcvpmowAAIABJREFU3IK8hNRyJWrfYNTQpAqfpwGjc8CvvFaNiLPysN6SlmrV1CjbHyPiI6SdKYBa18Jm5OFAukGEdDB/rgVlr3iI1JVVLMMAYG/gr7klfiHwxbxMX2tiOjOAgbmlVLFeC8t0OylQf5h0YCqmfYSmA3g0kd5a00gtjeK6fF9EjK2R93lS3Ves18Z5Vy/L5cCfgIERsQbwe1I3b6WcH2xmWheQunNvkvS+xTNIPQsHkILfjXkeAEiqbFdP1ZjeDFKPSDEot3QdLy5GC/NXgsnGhXWyRq6TlppG6i0rrt/VIuIUgIi4IyL2Iz01cRvpxr4WlzkiXgTOBTbM1+qnwf+zd+9hdpX13f/fX5KQ4SRJIFDIBEMlyEkIGEJa0EYgnOQgv0KFB5EKFq3QBx4VRfpDgYqHeoAHWrBYKFERBNGSKiKI4LFCg4RICIcIAQYihEAQ1EASvs8f656wM5nDnsxMMivzfl3XXLP2ve691r3XPnzW4V5r8ZVOfiMuXZPpN8znM1Tv9e0RMbGLavdRHTr56y7GU9r3ng7t26js+emxGU2UL6T67Hb8vnT2+Vnle1X6F/RlRWdQMcD77mKqzjq93cXXlW8AR0TEwRExrHS4mRYRrVn1sv4BcFlEjI6IERHx9o4TiIg3R8T+UfUMX0p1PHG13qTA9cA7I+KA0jnlI1S7Gn/ZSd2e3A2MioiOa8Htvc+hOtY5q4fp3EV1zOpj5fVNo9qd2HGvRXd+CryXas/H70vZz0vZ5lRb4515BtiiY6eiPvgq8MGI2Ccqm0TEOyNis07qXg98oryvrcA/9FMb2m1GtfdmaURMZdVdxt8ADomIv47qtKwtG3bXQvXj+UHgUWBm+UxuFBH/KyLeUHZNvsSqn7G/olpxW9axIZn5GNXn4DNRnVY4CXgfrwdc08pW9mKqXcDN1v934OKorlsQUXWoO6i386ZaIZoSEceU5bZh2dOxQ0RsFhF/U97rZVT9QNqXzzPA1h1WYFYq3/t/jqoz57Cywv4BYHZWp2heDRwfEe+IiA3Ke3FgvH6q5DMdl0dUp5Z9tKcXlJmfpNqNfns51NFx/DLgLOCz5f3ftLTxHRHxL6XaV4BPRsSOZd6jI+L/6zitLjwDbBfdnJGTmX8EZpY2bBIRO1B9Xzo7A+Ym4C8i4tDyG/dxqt+A9YIB3kflWNDXgC4vBtLL6T1JtevtHKo13SepvjDt79WJVD8ID1Ltkj6zk8mMpDrW8xzVrqqtyvQ6zushquOfl5a6R1CdIteb48Pt03qV6oflPR1GvRX4ddm634mqc0tP0zmS6lj/c8BlVKezdHvebAc/oXrNP28om011fP+e8gPQ2bwfpOoY82jZ/denNfXMnEV1HPxfqA4xzKc6ftmZ86l2Az4G3Ep13Lc//T3VD95LVJ+F6xva+RjVe/9xqk5Yvwbe0vjkskv4FKrP3HepOhieBDweEb8v4xqPQZ5A9UPelXdTdS78HdWu4XMy8441fG2fAr5Z3rNmguIjVMv6bqrjobeWtvRKVn0eDqZ6j39HtWfhAqrDDQCnUn1/l1CtMLVf/+Ee4BaqQw9LOllhfI2qg933SvsepupLcGyZ7yNl+NNUKy8LqAKsfY/Kl4BTyrQ/W8paaXLFPDM/TrVy8uOIGN/J+BlUn+PTqQJ3IfCPVGFJZn6d6r3/z/LZmE3VobUZN1NtSS+KiO4OI/0d1XJ+AvgRcDlV596ObW2j+iz+C9Xv6ZjSnvVCVN9Lqe/KcbGfAXtm1SFPQ1BE7AlcWg7haB2LiJ2o3o/p67ot6l8GuCRJNeQudEmSasgAlySphgxwSZJqyACXJKmGBsXdr7bccsucMGHCum5GLTz0UHUF1je/ucc7h0qS1gP33HPPc5m52tXvBkWAT5gwgVmzerq+hwCmTZsGwJ133rlO2yFJWju6OifeXeiSJNWQAS5JUg0Z4JIk1dCgOAYuSRo4y5Yto62tjaVLl67rpqgbLS0ttLa2MmLEiJ4rY4BL0nqvra2NzTbbjAkTJlDdV0iDTWayePFi2tra2H771W4E1yl3oUvSem7p0qVsscUWhvcgFhFsscUWvdpLYoBL0hBgeA9+vX2PDHBJ0oCLCE488fVbxi9fvpyxY8dy+OGHr8NWrW7GjBlMnDiRiRMnMmPGjE7r3HDDDey6665ssMEGq1zD5O6772bSpElMmjSJPfbYg+9+97tAtQdkypQp7LHHHuy666586lOf6pe2egxckjTgNtlkE+6//37+9Kc/sdFGG3Hbbbcxbty4dd2sVTz//POcf/75zJo1i4jgrW99K0ceeSSjR49epd5uu+3Gd77zHT7wgQ+sVj5r1iyGDx/OwoUL2WOPPTjiiCMYOXIkP/7xj9l0001ZtmwZ++23H4ceeihTp07tU3vdApckrRWHHnoo3//+9wG49tprOf7441eO+8Mf/sDJJ5/M3nvvzZ577slNN90EwIIFC3jb297GXnvtxV577cUvf/lLoLoa5bRp0zjmmGPYaaedOOGEE8jMPrXvhz/8IdOnT2fMmDGMHj2a6dOnc8stt6xWb+edd+70ctYbb7wxw4dX28VLly5duUs8Ith0002B6oyAZcuW9cshDbfAJWkIOfPMM5k9e3a/TnPSpElcfPHFPdY77rjjuOCCCzj88MOZM2cOJ598Mj/72c8AuPDCC9l///256qqrWLJkCVOmTOHAAw9kq6224rbbbqOlpYVHHnmE448/fuVu63vvvZe5c+ey7bbbsu+++/KLX/yC/fbbb5V5fuELX+Caa65ZrS1vf/vbueSSS1Ype+qppxg/fvzKx62trTz11FO9WhZ33XUXJ598Mo8//jhf//rXVwb6ihUreOtb38r8+fM57bTT2GeffXo13c4Y4JKktWL33XdnwYIFXHvttRx22GGrjLv11luZOXMmX/ziF4FqC/aJJ55g22235fTTT2f27NkMGzaMhx9+eOVzpkyZQmtrK1CtRCxYsGC1AD/rrLM466yzmmpfZ1vwvd1S3meffZg7dy7z5s3jpJNO4tBDD6WlpYVhw4Yxe/ZslixZwtFHH83999/Pbrvt1qtpd7TeBvjSFa/SMmzDAasvSXXUzJbyQDryyCP56Ec/yp133snixYtXlmcmN95442q7ps877zy23npr7rvvPl577TVaWlpWjhs5cuTK4WHDhrF8+fLV5tebLfDW1tZVbhTV1ta28gZSvbXzzjuvPO4/efLkleWjRo1i2rRp3HLLLQZ4V1qGbch2tx7bdP0nDrphAFsjSQI4+eST2XzzzXnLW96ySlgefPDBXHrppVx66aVEBPfeey977rknL774Iq2trWywwQbMmDGDFStW9Gp+vdkCP/jggznnnHN44YUXgGqvwGc/+9mm5/XYY48xfvx4hg8fzuOPP85DDz3EhAkTWLRoESNGjGDUqFH86U9/4kc/+hEf//jHe/U6OmMnNknSWtPa2soZZ5yxWvm5557LsmXL2H333dltt90499xzAfjQhz7EjBkzmDp1Kg8//DCbbLLJgLVtzJgxnHvuuey9997svffefPKTn2TMmDEAvP/971957P273/0ura2t/Pd//zfvfOc7OfjggwH4+c9/zh577MGkSZM4+uijueyyy9hyyy1ZuHAh73jHO9h9993Ze++9mT59er+cPhd97bXXHyZPnpwDcT/w9XEL3PuBS+qtefPmsfPOO6/rZqgJnb1XEXFPZk7uWNctcEmSasgAlySphgxwSZJqyACXpCFgMPR3Uvd6+x4Z4JK0nmtpaWHx4sWG+CDWfj/wxvPce7LengcuSaq0trbS1tbGokWL1nVT1I2WlpaVV5ZrhgEuSeu5ESNGsP3226/rZqifuQtdkqQaMsAlSaqhpgM8IoZFxL0R8b3yePuIuCsiHomIb0XEhqV8ZHk8v4yfMDBNlyRp6OrNFvgZwLyGx58HLsrMicALwCml/BTghczcAbio1JMkSf2oqQCPiFbgncC/l8cB7A98u1SZAbyrDB9VHlPGHxC9vaGqJEnqVrNb4BcDHwNeK4+3AJZkZvvNV9uAcWV4HPAkQBn/YqkvSZL6SY8BHhGHA89m5j2NxZ1UzSbGNU731IiYFRGzPDdRkqTeaWYLfF/gyIhYAFxHtev8YmBURLSfR94KPF2G24DxAGX85sDzHSeamVdk5uTMnDx27Ng+vQhJkoaaHgM8Mz+Rma2ZOQE4DvhxZp4A3AEcU6qdBNxUhmeWx5TxP06v3ydJUr/qy3ngHwc+HBHzqY5xX1nKrwS2KOUfBs7uWxMlSVJHvbqUambeCdxZhh8FpnRSZylwbD+0TZIkdcErsUmSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTXUY4BHREtE3B0R90XE3Ig4v5RfHRGPRcTs8jeplEdEXBIR8yNiTkTsNdAvQpKkoWZ4E3VeAfbPzJcjYgTw84j4QRl3VmZ+u0P9Q4GJ5W8f4PLyX5Ik9ZMet8Cz8nJ5OKL8ZTdPOQr4Wnner4BREbFN35sqSZLaNXUMPCKGRcRs4Fngtsy8q4y6sOwmvygiRpayccCTDU9vK2Udp3lqRMyKiFmLFi3qw0uQJGnoaSrAM3NFZk4CWoEpEbEb8AlgJ2BvYAzw8VI9OptEJ9O8IjMnZ+bksWPHrlHjJUkaqnrVCz0zlwB3Aodk5sKym/wV4D+AKaVaGzC+4WmtwNP90FZJklQ00wt9bESMKsMbAQcCD7Yf146IAN4F3F+eMhN4b+mNPhV4MTMXDkjrJUkaoprphb4NMCMihlEF/vWZ+b2I+HFEjKXaZT4b+GCpfzNwGDAf+CPwvv5vtiRJQ1uPAZ6Zc4A9Oynfv4v6CZzW96ZJkqSueCU2SZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphnoM8IhoiYi7I+K+iJgbEeeX8u0j4q6IeCQivhURG5bykeXx/DJ+wsC+BEmShp5mtsBfAfbPzD2AScAhETEV+DxwUWZOBF4ATin1TwFeyMwdgItKPUmS1I96DPCsvFwejih/CewPfLuUzwDeVYaPKo8p4w+IiOi3FkuSpOaOgUfEsIiYDTwL3Ab8FliSmctLlTZgXBkeBzwJUMa/CGzRyTRPjYhZETFr0aJFfXsVkiQNMU0FeGauyMxJQCswBdi5s2rlf2db27laQeYVmTk5MyePHTu22fZKkiR62Qs9M5cAdwJTgVERMbyMagWeLsNtwHiAMn5z4Pn+aKwkSao00wt9bESMKsMbAQcC84A7gGNKtZOAm8rwzPKYMv7HmbnaFrgkSVpzw3uuwjbAjIgYRhX412fm9yLiAeC6iPg0cC9wZal/JfD1iJhPteV93AC0W5KkIa3HAM/MOcCenZQ/SnU8vGP5UuDYfmmdJEnqlFdikySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYZ6DPCIGB8Rd0TEvIiYGxFnlPLzIuKpiJhd/g5reM4nImJ+RDwUEQcP5AuQJGkoGt5EneXARzLz1xGxGXBPRNxWxl2UmV9srBwRuwDHAbsC2wI/iogdM3NFfzZckqShrMct8MxcmJm/LsMvAfOAcd085Sjgusx8JTMfA+YDU/qjsZIkqdKrY+ARMQHYE7irFJ0eEXMi4qqIGF3KxgFPNjytje4DX5Ik9VLTAR4RmwI3Amdm5u+By4E3AZOAhcCX2qt28vTsZHqnRsSsiJi1aNGiXjdckqShrKkAj4gRVOF9TWZ+ByAzn8nMFZn5GvBVXt9N3gaMb3h6K/B0x2lm5hWZOTkzJ48dO7Yvr0GSpCGnmV7oAVwJzMvMLzeUb9NQ7Wjg/jI8EzguIkZGxPbARODu/muyJElqphf6vsCJwG8iYnYpOwc4PiImUe0eXwB8ACAz50bE9cADVD3YT7MHuiRJ/avHAM/Mn9P5ce2bu3nOhcCFfWiXJEnqhldikySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSaqjHAI+I8RFxR0TMi4i5EXFGKR8TEbdFxCPl/+hSHhFxSUTMj4g5EbHXQL8ISZKGmma2wJcDH8nMnYGpwGkRsQtwNnB7Zk4Ebi+PAQ4FJpa/U4HL+73VkiQNcT0GeGYuzMxfl+GXgHnAOOAoYEapNgN4Vxk+CvhaVn4FjIqIbfq95ZIkDWG9OgYeEROAPYG7gK0zcyFUIQ9sVaqNA55seFpbKes4rVMjYlZEzFq0aFHvWy5J0hDWdIBHxKbAjcCZmfn77qp2UparFWRekZmTM3Py2LFjm22GJEmiyQCPiBFU4X1NZn6nFD/Tvmu8/H+2lLcB4xue3go83T/NlSRJ0Fwv9ACuBOZl5pcbRs0ETirDJwE3NZS/t/RGnwq82L6rXZIk9Y/hTdTZFzgR+E1EzC5l5wCfA66PiFOAJ4Bjy7ibgcOA+cAfgff1a4slSVLPAZ6ZP6fz49oAB3RSP4HT+tguSZLUDa/EJklSDRngkiTVkAEuSVINGeCSJNWQAS5JUg0Z4JIk1ZABLklSDRngkiTVkAEuSVINGeCSJNWQAS5JUg0Z4JIk1ZABLklSDRngkiTVkAEuSVINGeCSJNWQAS5JUg0Z4JIk1ZABLklSDRnga8nSFa8OSF1J0tA0fF03YKhoGbYh2916bFN1nzjohgFujSSp7twClySphgxwSZJqyACXJKmGegzwiLgqIp6NiPsbys6LiKciYnb5O6xh3CciYn5EPBQRBw9UwyVJGsqa2QK/Gjikk/KLMnNS+bsZICJ2AY4Ddi3PuSwihvVXYyVJUqXHAM/MnwLPNzm9o4DrMvOVzHwMmA9M6UP7JElSJ/pyDPz0iJhTdrGPLmXjgCcb6rSVstVExKkRMSsiZi1atKgPzZAkaehZ0wC/HHgTMAlYCHyplEcndbOzCWTmFZk5OTMnjx07dg2bIUnS0LRGAZ6Zz2Tmisx8Dfgqr+8mbwPGN1RtBZ7uWxMlSVJHaxTgEbFNw8OjgfYe6jOB4yJiZERsD0wE7u5bEwcnL3cqSVqXeryUakRcC0wDtoyINuBTwLSImES1e3wB8AGAzJwbEdcDDwDLgdMyc8XANH3d6s2lUcHLo0qS+lePAZ6Zx3dSfGU39S8ELuxLoyRJUve8EpskSTVkgBce05Yk1Ym3Ey08pi1JqhO3wCVJqiEDXJKkGjLAJUmqIQN8EOpthzo74EnS0GMntkGouw51z74wF2CV8Xaok6Shxy1wSZJqyACXJKmGDHBJkmrIAJckqYYM8PWAvdYlaeixF/p6wMvAStLQ4xa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTXUY4BHxFUR8WxE3N9QNiYibouIR8r/0aU8IuKSiJgfEXMiYq+BbLwkSUNVM1vgVwOHdCg7G7g9MycCt5fHAIcCE8vfqcDl/dNMSZLUqMcAz8yfAs93KD4KmFGGZwDvaij/WlZ+BYyKiG36q7GSJKmypsfAt87MhQDl/1alfBzwZEO9tlImSZL6UX93YotOyrLTihGnRsSsiJi1aNGifm6G+pO3K5WkwWdNbyf6TERsk5kLyy7yZ0t5GzC+oV4r8HRnE8jMK4ArACZPntxpyGtw8HalkjT4rOkW+EzgpDJ8EnBTQ/l7S2/0qcCL7bvaJUlS/+lxCzwirgWmAVtGRBvwKeBzwPURcQrwBNC+eXYzcBgwH/gj8L4BaLMkSUNejwGemcd3MeqATuomcFpfG6WBtXTFq7QM23BdN0OS1AdregxcNeYxbUmqPy+lKklSDRngkiTVkAEuSVINGeCSJNWQAS5JUg0Z4JIk1ZABLklSDRngkiTVkAGufufdyyRp4HklNvU7r/QmSQPPLXBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmqoT3cji4gFwEvACmB5Zk6OiDHAt4AJwALgbzLzhb41U5IkNeqPLfB3ZOakzJxcHp8N3J6ZE4Hby2NJktSPBmIX+lHAjDI8A3jXAMxDkqQhra8BnsCtEXFPRJxayrbOzIUA5f9WnT0xIk6NiFkRMWvRokV9bIaGiqUrXh3Q+pJUF306Bg7sm5lPR8RWwG0R8WCzT8zMK4ArACZPnpx9bIeGiJZhG7Ldrcc2Xf+Jg24YwNZI0rrTpy3wzHy6/H8W+C4wBXgmIrYBKP+f7WsjtX5zK1mSem+Nt8AjYhNgg8x8qQwfBFwAzAROAj5X/t/UHw3V+qs3W9VuUUtSpS+70LcGvhsR7dP5ZmbeEhH/A1wfEacATwDN7++UJElNWeMAz8xHgT06KV8MHNCXRkmSpO55JTZJkmrIAJckqYYMcK3XPG9c0vqqr+eBS4Oa541LWl+5BS5JUg0Z4JIk1ZABLklSDRngkiTVkAEuSVINGeBSA087k1QXnkYmNfC0M0l14Ra4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS2uRp6lJ6i+eRib1wdIVr9IybMOm63uamqT+YoBLfWAgS1pX3IUuSVINGeCSJNWQAS5JUg0Z4JIk1ZABLklSDQ1YgEfEIRHxUETMj4izB2o+0vpsIM8bH+hz0j2HXeuDwfy5H5DTyCJiGPCvwHSgDfifiJiZmQ8MxPyk9dWanKbWbP3e1F3T+r3R23Pqe1tfXXPZd20wnyo6UOeBTwHmZ+ajABFxHXAUYIBL6lRvfygfPuCaXk1/IENqoANwoOsPpmU/2JbNYDZQAT4OeLLhcRuwT2OFiDgVOLU8fDkiHurnNmwJPNds5SB6NfGBrN9M3ScP/vZaaUupP2iW5WB6n9awvsuyn2zEt3u1LNWtXi3Ljfh2z5WGqN5+x5v0xs4KByrAO/vm5ioPMq8Arhig+RMRszJz8kBNfyhxWfYfl2X/cVn2H5dl/1mby3KgOrG1AeMbHrcCTw/QvCRJGnIGKsD/B5gYEdtHxIbAccDMAZqXJElDzoDsQs/M5RFxOvBDYBhwVWbOHYh5dWPAds8PQS7L/uOy7D8uy/7jsuw/a21ZRmb2XEuSJA0qXolNkqQaMsAlSaqh2gd4T5dsjYiREfGtMv6uiJiw9ltZD00syw9HxAMRMScibo+ITs9NVPOXEo6IYyIiI8JTeLrQzLKMiL8pn825EfHNtd3GumjiO75dRNwREfeW7/lh66Kdg11EXBURz0bE/V2Mj4i4pCznORGx14A0JDNr+0fVQe63wJ8DGwL3Abt0qPMh4Ctl+DjgW+u63YPxr8ll+Q5g4zL89y7LNV+Wpd5mwE+BXwGT13W7B+Nfk5/LicC9wOjyeKt13e7B+NfksrwC+PsyvAuwYF23ezD+AW8H9gLu72L8YcAPqK6JMhW4ayDaUfct8JWXbM3MV4H2S7Y2OgqYUYa/DRwQEQN7iah66nFZZuYdmfnH8vBXVOf3a3XNfC4B/gn4Z2Dp2mxczTSzLP8O+NfMfAEgM59dy22si2aWZQJvKMOb4/U7OpWZPwWe76bKUcDXsvIrYFREbNPf7ah7gHd2ydZxXdXJzOXAi8AWa6V19dLMsmx0CtUaplbX47KMiD2B8Zn5vbXZsBpq5nO5I7BjRPwiIn4VEYestdbVSzPL8jzgPRHRBtwM/MPaadp6p7e/p2tkoC6lurb0eMnWJuuoF8spIt4DTAb+akBbVF/dLsuI2AC4CPjbtdWgGmvmczmcajf6NKq9Qj+LiN0yc8kAt61umlmWxwNXZ+aXIuIvgK+XZfnawDdvvbJWcqfuW+DNXLJ1ZZ2IGE61W6i7XR9DVVOXv42IA4F/BI7MzFfWUtvqpqdluRmwG3BnRCygOkY2045snWr2O35TZi7LzMeAh6gCXatqZlmeAlwPkJn/DbRQ3ehEvbNWLide9wBv5pKtM4GTyvAxwI+z9DLQKnpclmW3779RhbfHGbvW7bLMzBczc8vMnJCZE6j6ExyZmbPWTXMHtWa+4/9J1cGSiNiSapf6o2u1lfXQzLJ8AjgAICJ2pgrwRWu1leuHmcB7S2/0qcCLmbmwv2dS613o2cUlWyPiAmBWZs4ErqTaDTSfasv7uHXX4sGryWX5BWBT4IbSD/CJzDxynTV6kGpyWaoJTS7LHwIHRcQDwArgrMxcvO5aPTg1uSw/Anw1Iv4P1S7fv3WDZ3URcS3VIZstS3+BTwEjADLzK1T9Bw4D5gN/BN43IO3wvZEkqX7qvgtdkqQhyQCXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAr5mIeFtEPNREvXMi4t8HqA1jI+KhiGgZiOmXeWwUEf8VES9GxA0DMP2rI+LTZXiVZRoRC8ptUwdMRLwcEX8+kPMYSBHx6Yi4upfP2SbzzEjpAAAgAElEQVQiHih3wlrrImKHiPDmD0NURBwSEfd0M/7bEXH22mxTXxngXSg/4n8qP7S/Kz/4m3ZTf1pEvFbqv1QCrt/vQJOZP8vMNzdR7zOZ+f7+nn9xNvAfmbm044iIuD4ipkfEyIj4XR/mcQywNbBFZh7bWYWI2DEiboiI50rQz4mID0fEsN7MqNlluqYi4s6IWOW9yMxNM7Nfb3lZPnvtf681fH5fjogT+nNea6LcTvHnVPecHnAR0RYR0wZguic1LNc/NXzvX46IJX2Y7m4Rsdp3qkOdLSPiGxHxTET8PiLmRcT/bnL6vQqoiDg8Ih5seNwSET+IiB9FxMZdPGe/iLittG1xRPx3RBzf7DybbcuayMxbMvOtfW3LYGKAd++IzNwUmATsCXyih/pPl/pvAD5OdVu+XTpWioja3sY1IkZS3V/9G11UeSvwa2B34P4+zOqNwMOZubyLdrwJuAt4EnhLZm4OHAtMBjbrw3x7ZTC9l2WlYNPyGXyC8vktf9d0rL+O2n4N8IF1MN9+k5kzGpbzEVS31W1fzqMGePaXA8up7nk+mmpF94kBnicRsQnwfapbjB6emX/spM4BwC2l3gRgS+D/AIcPdPvK/AfNd3GtyUz/OvkDFgAHNjz+Z+D73dSfBrR1KFtE9QWbQPXBP4Xqy/bTMn4q8EtgCXAfMK3huWOA/wCeBl4A/rOz+VCtKDwFvAQ8BBxQys8DvtFQ70hgbpnXncDOHV7rR4E5wIvAt4CWLl7n24H5XYwbDTxahv8e+OcelvHOpS1LStuOLOXnA68Cy4CXgVM6ee43uns/Sp0bgN+V1/RTYNeGcVcDn+5imS6gWll7oCz7/2hfHu11y3L/HfD18rq/V97vF8pwa6l/IdU9qpeW1/IvpTyBHcrw5sDXyvMfB/5/YIMy7m+ptlq/WKb9GHBobz+/pezT5b29tnxe/hb4C+BX5T1YCFwCjGh4zluAHwHPl9f7sYZpXV2GNwSuL38jqD7XvwZ+DzwDfKFhehuWZTGui3aPKu/toob3of22x+8HfgJcVNr7KHBQF9O5FngN+FNZ7h8GdijL/b3lPVwEnN3wnA2Ac4DfAs8B1wGje1jOBwILOil/I/BfZTq/Bf6uYdzbgNll+Szk9c/h86V9L5e/tzTzvnYYvztwR/msPEC1Ekd5/cuBV8q0r23iM3Q48CDVCvHPgO8CG3ZTfzbw+R6m+dfAb8r79xNgp4ZxzwFnlHa/SPWdGAFsVd7H1xqWzeZU34mvU33PXwKOAzamWsn5XXmPP0/5PLe/nob5TaX6zXupzOumxs9DHf7WeQMG61/jFwVoLR+6/9tN/WmUECg/BEdTBdCbeT3AvwZsAmwEjAMWU930fQNgenk8tkzj+1Q/tqPLh/ivOpnPm6m2QLctjycAbyrD51ECnGpt/Q9lHiOAj1HdaH7Dhtd6N7At1YrDPOCDXbzO0+gQnMAB5Qv5MlXwLin//1CG/6qT6YwobTiH6kd9//JFenPH9nfRjt8B7+vhPTyZ6sdnJHAxMLth3NV0H+D3A+PL8vhFh7rLqX4YRpb3cguqH6aNy/xuoKxwlefcCby/Q9saA7z9x2Oz8h4+TFlpoQrZZcDfAcOoVoyepoRaM5/fhrJPl/flCKrP3EbA3sA+wHDgz8u8Ty/1N6cK4DPKa30DMKVhWleX1/wD4EpeX+n4H+D4MrwZsE+HdjwAHNZFu78JfKc878/LZ+SkMu79ZVmcXJbFPwBPdrMM2lh1pbg9wL8CtAB7UQXaxDL+o+W9HlfGXwl8vYflvFqAl2X5APARqs/5TqUt+5XxvwGOLsONy3Q3YGkP87sOuJdqJeRNHcaNovpeHFeWz1SqlYLty/hv04uAogq8J6lW8L4FDO+m7pZl2e7dTZ39ymd3r9K+D1H91gwr45+jWtEeSxXajwHvaWjLgx2m90WqlcFDgKD6PH+Z6vu2BbAN1YrkxztOo3xunwFOLe/RSVTfawN8ffij+gF8mSpUErgdGNVN/WlUa4hLypdmNnBcGTehTOPPG+p/vOOPA/DD8kHapkxrtbV/Vg3wHYBny4/IiA71zuP1AD8XuL5h3AZUW+3TGl7rexrG/zPwlS5e5z8C13Ux7hvAUVQrKQ8DG3ezvN5G9WOzQUPZtcB5HdvfxfOXAYf04v0cVd6Dzcvjq+k+wD/Y8Pgw4LcNdV+liz0Upc4k4IWGx3fSRYBT/ZC9AuzSMO4DwJ1l+G9p2ONB9cOTwJ818fntLMB/3MPzPgrcUIZPBGZ1Ue/TVFtkP6PaIo6Gcb8EPknVf6Gz594F/K9OykdQdg83lJ0G/KgMv59Vt6DeUJbFll3Mp6sA/7OGsl8Dx5ThR2hY2aRagXul8TPayTw6C/ADgHkdyi4ELm2Y58eBMR3qNBPgm1J9N+4ry+pB4B1l3CnADzrUvwb4SBlekwD/Y5lPt981qo2JpOx56qLO1ylh2lD2FPDWMvwc8K6GcZcBX2xoS2cBfnOHsmeAtzc8/mvg/o7ToPpOz+/w3Dm9WT6D4c9j4N17V2ZuRvWjvRPVWiYRsV1jh6GG+k9n5qjMHJOZkzLzug7Te7Jh+I3AsRGxpP2Pag11G6ofjucz84XuGpeZ84Ezqb7Qz0bEdRGxbSdVt6XaNdv+vNdKW8Y11GnscPZHqh+KzrxAh2PMpbPQEuB4YAbVSsUbgacj4stdTGdbqq2n1xrKHu/Qpu4splpWnYqIYRHxuYj4bUT8nirQoLyHTWh8rx4v7W23KBs68EXExhHxbxHxeJnXT4FRTXam25JqD8TjDWUdl8PK9yZfP/bYZYfKHjS+LiJip4j4fumo+XvgAl5fRuOptoC7si+wK9Vu02wofx+wC/BQRNwdEYd1eN5mVCu6HW1FtULT1LKg+pxCL5dFZnb1Wd8O+K+G7+NvqEJpq95Mn+qzv0OH7/b/Bv6sjD+Rqq/GIxHxq4iY3ou2v5yZ52XmHlTv0y3Ad8sx6jcC+3eY71F08z1pwhNUK5E3RMTbu6m3uPzvbl5vBD7ZoX2jWbPfoXYrP8/lGPhWdP/5abctHb4LHZ5XCwZ4EzLzJ1RbbF8sjxs7rfTmx6PxR+5Jqi3wUQ1/m2Tm58q4MRHRY4eYzPxmZu5H9eVIql27HT1dxgMQEUH14/xUL9rebg7VLvnGNrRS7cb6UVadeK4ATiuv6cNdTOdpYHxENH4Gt+tFm35EtXbdlf9F9eN1INWu4AmlPJqc/vgO7Xq64XF2qPsRqi2QfTLzDVT9BBrn1bF+o+eo9ia8saGsN8uhtzq25d+oDhfsUNr+SV5v95PAm7qZ1s1U34nbI2LsyhlkPpSZx1H9mH4JuDHKKYdRnUL251RbkB09S9VfoL+WRXfLvTNtwPQO38mWDoHfjCeptvoap7NZlrMpMnNuGd6K6njtd0r49Kq9mbkE+BzV57u1zPfmDvPdNDM/2v6UXr6O9vl8g2pD4b8i4i+6qPMc1Xva3XfySeCcDu3bODNnNtOMnsqz6vDavvHQrqvPz0KqZUaHurVigDfvYmB6REzqp+l9AzgiIg4uW4st5VS01qxOt/kBcFlEjI6IEZ2t/UbEmyNi/9IzfClVR48VnczreuCdEXFARIygCpxXqHZ19tbdVFuXHddq23ufQ3WMa1YP07mL6hj5x8rrm0Z1bLbjXouufAr4y4j4QkT8Gaw8z/cbZcVnM6rXuJhqt/Nnmpxuu9MiojUixlAdp/9WN3U3o1r2S0r9T3UY/wxVaK0mM1dQvT8XRsRmEfFGqg5HXfXy72+bUXUY+kNE7MyqPcRnAttFxOkRsWFEvCEipnRo/2eods3+KCK2AIiIEyNiy7J35UWqH9n2PS1Tqc4uWO1HNTOXlWl9JiI2jYjtqXoxr+my6HK5d+ErZd7bldexVUQcuQbz/Qkwsiy3kRExPCL2aP/tiIj3RsSY8t6/SLVskip8Rnby3VopIi6IiL3Kd2Yjqn4Az1J16LsRmBIRx5R5bhgRfxERO5Snr7Y8ojq17F96ekGZeSVVh8KbI6KrU7E+QvW9+YfyuxURMTkivl7G/xtwZml/lM/7u6K560k8A2xd9jR051rgvIgYU34XzqHzz88dwOYR8f6yrN5DtTepVgzwJmXmIqrORuf20/SepNpCPIeqN+yTwFm8/p6cSLVl9iDVF/TMTiYzkmoN/DmqXU9blel1nNdDwHuAS0vdI6h6p766Bu1+lWpvxHs6jHor8Ouydb8TVa/ynqZzJHBoadNlwHszs6lzPTPzt1Q9qCcAcyPiRaofsFm83qv0caq17weoOuL0xjeBW6l+GB+lOubblYupOtA8V+ZzS4fx/xc4JiJeiIhLOnn+P1CtzDxK1eP8m8BVvWzvmvoIVb+Ll6h+YFeuqGTmi1QdH/+a6jP4MPBXHSeQmZ+iWuG8raw8HQbMi4iXqLbQ393wWTuBKii78iGqPgaPUQXhDKr3ck18Bji/7K7t7PvT0Zep3rvbS9t/SdXJr1fKaz2U6tDbE1TL7l95fXfwUcDDZR7nUy2fFeU35kvAfaXNb+lk8sOojms/T7XHYApVh8Blmfk8cDBVh8ffUe01uoCqbwFUy/0vy+ew/bTC8VQd95p5XZeV9t4aEbt3Mv52qvf+KKrv3nNUZzV8r4z/KdUK2b9THUJ5CHg3ze0ZuIfqvXmiLJvNu6j3j1R9GeaV59xBtUw7tvWPVB2Nz6Q6LHgQVcfhWmk/PUNqWtld+jNgz8z807puj+ohIrah6gw6aU1WHtW/orow1a+A3Tv0RVFNGOCSJNWQu9AlSaohA1ySpBoywCVJqiEDXJKkGhoUd2/Zcsstc8KECeu6GVoDDz1U3Ub7zW8esLtxStKQds899zyXmWM7lg+KAJ8wYQKzZvV03Q8NRtOmTQPgzjvvXKftkKT1VUR0epnXHnehlyuE3R0R90XE3Ig4v5RfHRGPRcTs8td+laGIiEsiYn5EzImIvfr3pUiSpGa2wF8B9s/Ml8tlOH8eET8o487KzG93qH8oMLH87UN1rd99+qvBkiSpiS3wrLTfcWtE+evu6i9HAV8rz/sV1XWz+3I3HEmS1EFTx8Cjui3iPVT30/3XzLwrIv6e6gYMn6S6POLZmfkK1a3bGm/T1lbKFvZryyVJTVm2bBltbW0sXbq058paZ1paWmhtbWXEiBE9V6bJAC93zZlUblTw3YjYjerONL+jupfxFVQ3qL+Azm/XuNoWe0ScCpwKsN12tbuLmyTVRltbG5ttthkTJkygut+QBpvMZPHixbS1tbH99ts39ZxenQde7j97J3BIZi4su8lfAf6D6q44UG1xN95LuZVV76XcPq0rMnNyZk4eO3a13vGSpH6ydOlStthiC8N7EIsItthii17tJWmmF/rYsuVNuf/sgcCD7ce1y+0j3wXcX54yE3hv6Y0+FXix3N9akrSOGN6DX2/fo2a2wLcB7oiIOcD/ALdl5veAayLiN8BvgC15/X7JN1Pd13g+8FWq+/tKkoawiODEE09c+Xj58uWMHTuWww8/fB22anUzZsxg4sSJTJw4kRkzZnRa56yzzmKnnXZi99135+ijj2bJkiUALF68mHe84x1suummnH766as851vf+ha77747u+66Kx/72Mf6pa3N9EKfk5l7ZubumblbZl5QyvfPzLeUsve091Qvu9VPy8w3lfFeoUWShrhNNtmE+++/nz/96U8A3HbbbYwbN24dt2pVzz//POeffz533XUXd999N+effz4vvPDCavWmT5/O/fffz5w5c9hxxx357Gc/C1Sd0P7pn/6JL37xi6vUX7x4MWeddRa33347c+fO5ZlnnuH222/vc3u9Frokaa049NBD+f73vw/Atddey/HHH79y3B/+8AdOPvlk9t57b/bcc09uuukmABYsWMDb3vY29tprL/baay9++ctfAtXVH6dNm8YxxxzDTjvtxAknnEBmd2c49+yHP/wh06dPZ8yYMYwePZrp06dzyy23rFbvoIMOYvjwqg/41KlTaWtrA6qVlP3224+WlpZV6j/66KPsuOOOtPf3OvDAA7nxxhv71FYYJJdSlSStHWeeeSazZ8/u12lOmjSJiy++uMd6xx13HBdccAGHH344c+bM4eSTT+ZnP/sZABdeeCH7778/V111FUuWLGHKlCkceOCBbLXVVtx22220tLTwyCOPcPzxx6+89Pa9997L3Llz2Xbbbdl33335xS9+wX777bfKPL/whS9wzTXXrNaWt7/97VxyySWrlD311FOMH/96H+zW1laeeuqpbl/TVVddxbvf/e5u6+ywww48+OCDLFiwgNbWVv7zP/+TV199tdvnNMMAlyStFbvvvjsLFizg2muv5bDDDltl3K233srMmTNX7n5eunQpTzzxBNtuuy2nn346s2fPZtiwYTz88MMrnzNlyhRaW1uBaiViwYIFqwX4WWedxVlnndVU+zrbgu+uY9mFF17I8OHDOeGEE7qd7ujRo7n88st597vfzQYbbMBf/uVf8uijjzbVpu6stwG+dMWrtAzbcNBNS5LWpWa2lAfSkUceyUc/+lHuvPNOFi9evLI8M7nxxhtXu7Pheeedx9Zbb819993Ha6+9tsru6ZEjR64cHjZsGMuXL19tfr3ZAm9tbV3lxkxtbW0rb9jU0YwZM/je977H7bff3lTv8SOOOIIjjjgCgCuuuIJhw4b1+JyerLcB3jJsQ7a79dh+mdYTB93QL9ORpKHu5JNPZvPNN+ctb3nLKmF58MEHc+mll3LppZcSEdx7773sueeevPjii7S2trLBBhswY8YMVqxY0av59WYL/OCDD+acc85Z2XHt1ltvXdlBrdEtt9zC5z//eX7yk5+w8cYbNzXtZ599lq222ooXXniByy67jOuvv775F9EFO7FJktaa1tZWzjjjjNXKzz33XJYtW8buu+/ObrvtxrnnngvAhz70IWbMmMHUqVN5+OGH2WSTTQasbWPGjOHcc89l7733Zu+99+aTn/wkY8aMAeD973//ymPvp59+Oi+99BLTp09n0qRJfPCDH1w5jQkTJvDhD3+Yq6++mtbWVh544AEAzjjjDHbZZRf23Xdfzj77bHbcccc+tzf62muvP0yePDkH4n7gboEPPO8HLg1+8+bNY+edd17XzVATOnuvIuKezJzcsa5b4JIk1ZABLklSDRngkiTVkAEuSUPAYOjvpO719j0ywCVpPdfS0sLixYsN8UGs/X7gHS/D2p319jxwSVKltbWVtrY2Fi1atK6bom60tLSsvLJcMwxwSVrPjRgxgu23335dN0P9zF3okiTVkAEuSVINGeCSJNWQAS5JUg0Z4JIk1ZABLklSDRngkiTVkAEuSVINGeCSJNWQAS5JUg0Z4JIk1ZABLklSDRngkiTVkAEuSVINGeCSJNWQAS5JUg0Z4JIk1ZABLklSDfUY4BHREhF3R8R9ETE3Is4v5dtHxF0R8UhEfCsiNizlI8vj+WX8hIF9CZIkDT3NbIG/AuyfmXsAk4BDImIq8HngosycCLwAnFLqnwK8kJk7ABeVepIkqR/1GOBZebk8HFH+Etgf+HYpnwG8qwwfVR5Txh8QEdFvLZYkSc0dA4+IYRExG3gWuA34LbAkM5eXKm3AuDI8DngSoIx/EdiiPxstSdJQ11SAZ+aKzJwEtAJTgJ07q1b+d7a1nR0LIuLUiJgVEbMWLVrUbHslSRK97IWemUuAO4GpwKiIGF5GtQJPl+E2YDxAGb858Hwn07oiMydn5uSxY8euWeslSRqimumFPjYiRpXhjYADgXnAHcAxpdpJwE1leGZ5TBn/48xcbQtckiStueE9V2EbYEZEDKMK/Osz83sR8QBwXUR8GrgXuLLUvxL4ekTMp9ryPm4A2i1J0pDWY4Bn5hxgz07KH6U6Ht6xfClwbL+0TpIkdcorsUmSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNdRjgEfE+Ii4IyLmRcTciDijlJ8XEU9FxOzyd1jDcz4REfMj4qGIOHggX4AkSUPR8CbqLAc+kpm/jojNgHsi4rYy7qLM/GJj5YjYBTgO2BXYFvhRROyYmSv6s+GSJA1lPW6BZ+bCzPx1GX4JmAeM6+YpRwHXZeYrmfkYMB+Y0h+NlSRJlV4dA4+ICcCewF2l6PSImBMRV0XE6FI2Dniy4WltdB/4kiSpl5oO8IjYFLgRODMzfw9cDrwJmAQsBL7UXrWTp2cn0zs1ImZFxKxFixb1uuGSJA1lTQV4RIygCu9rMvM7AJn5TGauyMzXgK/y+m7yNmB8w9Nbgac7TjMzr8jMyZk5eezYsX15DZIkDTnN9EIP4EpgXmZ+uaF8m4ZqRwP3l+GZwHERMTIitgcmAnf3X5MlSVIzvdD3BU4EfhMRs0vZOcDxETGJavf4AuADAJk5NyKuBx6g6sF+mj3QJUnqXz0GeGb+nM6Pa9/czXMuBC7sQ7skSVI3vBKbJEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDBrgkSTVkgEuSVEMGuCRJNWSAS5JUQwa4JEk1ZIBLklRDPQZ4RIyPiDsiYl5EzI2IM0r5mIi4LSIeKf9Hl/KIiEsiYn5EzImIvQb6RUiSNNQ0swW+HPhIZu4MTAVOi4hdgLOB2zNzInB7eQxwKDCx/J0KXN7vrZYkaYjrMcAzc2Fm/roMvwTMA8YBRwEzSrUZwLvK8FHA17LyK2BURGzT7y2XJGkI69Ux8IiYAOwJ3AVsnZkLoQp5YKtSbRzwZMPT2kpZx2mdGhGzImLWokWLet9ySZKGsKYDPCI2BW4EzszM33dXtZOyXK0g84rMnJyZk8eOHdtsMyRJEk0GeESMoArvazLzO6X4mfZd4+X/s6W8DRjf8PRW4On+aa4kSYLmeqEHcCUwLzO/3DBqJnBSGT4JuKmh/L2lN/pU4MX2Xe2SJKl/DG+izr7AicBvImJ2KTsH+BxwfUScAjwBHFvG3QwcBswH/gi8r19bLEmSeg7wzPw5nR/XBjigk/oJnNbHdkmSpG54JTZJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcEmSasgAlySphgxwSZJqyACXJKmGDHBJkmrIAK+xpSteHVTTkSStPcN7qhARVwGHA89m5m6l7Dzg74BFpdo5mXlzGfcJ4BRgBfC/M/OHA9BuAS3DNmS7W4/t83SeOOiGfmiNJGltamYL/GrgkE7KL8rMSeWvPbx3AY4Ddi3PuSwihvVXYyVJUqXHAM/MnwLPNzm9o4DrMvOVzHwMmA9M6UP7JElSJ/pyDPz0iJgTEVdFxOhSNg54sqFOWylbTUScGhGzImLWokWLOqsyaPTnMWKPN0uS+kOPx8C7cDnwT0CW/18CTgaik7rZ2QQy8wrgCoDJkyd3Wmew6K9jzVAdb+7PaUmShqY12gLPzGcyc0VmvgZ8ldd3k7cB4xuqtgJP962JkiSpozUK8IjYpuHh0cD9ZXgmcFxEjIyI7YGJwN19a6IkSeqomdPIrgWmAVtGRBvwKWBaREyi2j2+APgAQGbOjYjrgQeA5cBpmbliYJouSdLQ1WOAZ+bxnRRf2U39C4EL+9IorV1LV7xKy7ANB920JEldW9NObFqP9KWT3rMvzAVY+Xw71knS2uGlVCVJqiEDXJKkGjLAJUmqIQNckqQaMsAlSaohA1ySpBoywCVJqiEDXJKkGjLAJUmqIQNckqQaMsAlSaohA1ySpBoywNWvlq54dVBOS5LWN96NTP2qL3c268g7m0lS19wClySphgxwSZJqyACXJKmGDHBJkmrIAJckqYYMcA1anpImSV3zNDINWp6SJkldcwtckqQaMsAlSaohA1ySpBoywCVJqiEDXJKkGjLAJUmqIQNckqQaMsAlSaohA1yS/h97dx5nR1Xn///1JitCIGQBIR0IS1gUIYQQ4wAaWQUzgD+Dwg+RVRwFFUWUcWQdFB0REHVEFIaAGFmEISrDIhDZZAmySEAgYkwakISQhDWShM/3j3M63HRu972dXk/6/Xw8+tF1q05Vfe65detTdepUXbMCOYGbmZkVqGYCl3SppHmSHq8YN0TSrZKeyf83yOMl6UJJsyQ9JmlsZwZvZmbWW9VzBn4Z8JFm404BbouI0cBt+TXAfsDo/Hcc8JOOCdOsffzDKGa2pqn5YyYRcaekUc1GHwhMzMNTgOnA1/P4yyMigPskDZa0cUS80FEBm60O/zCKma1pVvca+EZNSTn/3zCPHwHMrSjXmMetQtJxkmZImjF//vzVDMPMzKx36uhObKoyLqoVjIiLI2JcRIwbPnx4B4dhZma2ZlvdBP6ipI0B8v95eXwjMLKiXAPw/OqHZ2ZmZtWsbgKfBhyRh48AbqgY/+ncG30CsNjXv83MzDpezU5skqaSOqwNk9QInA58B7ha0jHAHKCpd9CNwP7ALOAN4KhOiNnMzKzXq6cX+qEtTJ2co4AAACAASURBVNqzStkAjm9vUGZmZtY6P4nNzMysQE7gZmZmBXICNzMzK5ATuFkb+bGsZtYT1OzEZmYr82NZzawn8Bm4mZlZgZzAzczMCuQEbmZmViAncDMzswI5gZuZmRXICdzMzKxATuBmZmYFcgI3MzMrkBO4WTfyU93MbHX5SWxm3chPdTOz1eUzcDMzswI5gZuZmRXICdzMzKxATuBmZmYFcgI3MzMrkBO4mZlZgZzAzczMCuQEbmZmViAncDMzswI5gZuZmRXICdzMzKxATuBmZmYFcgI3MzMrkBO4mZlZgZzAzczMCuQEbmZmViAncDMzswL1bc/MkmYDrwLLgWURMU7SEOAqYBQwG/hERCxsX5hmZmZWqSPOwD8cEWMiYlx+fQpwW0SMBm7Lr83MzKwDdUYT+oHAlDw8BTioE9ZhZmbWq7U3gQdwi6SHJB2Xx20UES8A5P8bVptR0nGSZkiaMX/+/HaGYWZm1ru06xo4sGtEPC9pQ+BWSX+pd8aIuBi4GGDcuHHRzjjMzMx6lXadgUfE8/n/POB6YDzwoqSNAfL/ee0N0szMzFa22glc0jqSBjUNA/sAjwPTgCNysSOAG9obpJnVtmT5Wz1qOR29LDNbWXua0DcCrpfUtJxfRsRNkh4ErpZ0DDAHOLj9YZpZLQP79GfTW9r/dZuzzzUdspymZZlZ51jtBB4RzwI7Vhm/ANizPUGZmZlZ6/wkNjMzswI5gZuZmRXICdzMzKxATuBmZmYFcgI3MzMrkBO4mZlZgZzAzazT+KEwZp2nvc9CNzNrUUc9XAb8UBiz5nwGbmZmViAncDMzswI5gZuZmRXICdzMzKxATuBmZmYFcgI3MzMrkBO4mZlZgZzAzczMCuQEbmZmViAncDMzswI5gZuZmRXICdzMzKxATuBmZmYFcgI3MzMrkBO4mZlZgZzAzawIS5a/1SOXZdZd+nZ3AGZm9RjYpz+b3nJwhyxrzj7XdMhyzLqTz8DNzMwK5ARuZmZWICdwMzOzAjmBm5mZFcgJ3Mx6HfdotzWBe6GbWa/jHu1WacnytxjYp3+PW1YtTuBmZtaiUpNbW5R6QNdpCVzSR4AfAH2An0fEdzprXWZma4KemCxLTW69QackcEl9gB8DewONwIOSpkXEE52xPjOz7tKRSbcjk+XTe17ZIcvpSD3xAKVknXUGPh6YFRHPAkj6FXAg4ARuZmuUnnqG2lFx9cSYoGceoHS1zkrgI4C5Fa8bgfdXFpB0HHBcfvmapKc6OIZhwEsdsSChjlhMj11WHcupWZdz9722Q2Nag5e1Ul32oLg6fDldsKzV/o4X9B67alkt1mVPfX9rc22HLasjCXVY7qmwWbWRnZXAq31KsdKLiIuBiztp/UiaERHjOmv5vYnrsuO4LjuO67LjuC47TlfWZWfdB94IjKx43QA830nrMjMz63U6K4E/CIyWtLmk/sAhwLROWpeZmVmv0ylN6BGxTNIJwM2k28gujYiZnbGuVnRa83wv5LrsOK7LjuO67Diuy47TZXWpiKhdyszMzHoUPwvdzMysQE7gZmZmBSo+gUv6iKSnJM2SdEqV6QMkXZWn3y9pVNdHWYY66vIrkp6Q9Jik2yRVvTfRatdlRbnJkkKSb+FpQT11KekTeducKemXXR1jKer4jm8q6Q5JD+fv+f7dEWdPJ+lSSfMkPd7CdEm6MNfzY5LGdkogEVHsH6mD3F+BLYD+wKPAe5qV+TxwUR4+BLiqu+PuiX911uWHgXfl4c+5Lle/LnO5QcCdwH3AuO6Ouyf+1bldjgYeBjbIrzfs7rh74l+ddXkx8Lk8/B5gdnfH3RP/gA8CY4HHW5i+P/B/pGeiTADu74w4Sj8DX/HI1oh4C2h6ZGulA4EpefhaYE9JHfc4oDVHzbqMiDsi4o388j7S/f22qnq2S4D/BP4LWNKVwRWmnrr8DPDjiFgIEBHzujjGUtRTlwGsl4fXx8/vqCoi7gRebqXIgcDlkdwHDJa0cUfHUXoCr/bI1hEtlYmIZcBiYGiXRFeWeuqy0jGkI0xbVc26lLQTMDIiftuVgRWonu1ya2BrSfdIui//EqKtqp66PAP4lKRG4EbgC10T2hqnrfvT1VL674HXfGRrnWWsDfUk6VPAOOBDnRpRuVqtS0lrAecDR3ZVQAWrZ7vsS2pGn0hqFbpL0vYRsaiTYytNPXV5KHBZRHxf0geAK3Jdvt354a1RuiTvlH4GXs8jW1eUkdSX1CzUWtNHb1XX428l7QX8B3BARPyzi2IrTa26HARsD0yXNJt0jWyaO7JVVe93/IaIWBoRfwOeIiV0W1k9dXkMcDVARPwRGEj6oRNrmy55nHjpCbyeR7ZOA47Iw5OB2yP3MrCV1KzL3Oz7U1Ly9nXGlrValxGxOCKGRcSoiBhF6k9wQETM6J5we7R6vuP/S+pgiaRhpCb1Z7s0yjLUU5dzgD0BJG1HSuDzuzTKNcM04NO5N/oEYHFEvNDRKym6CT1aeGSrpLOAGRExDbiE1Aw0i3TmfUj3Rdxz1VmX3wPWBa7J/QDnRMQB3RZ0D1VnXVod6qzLm4F9JD0BLAdOjogF3Rd1z1RnXZ4E/EzSl0lNvkf6hGdVkqaSLtkMy/0FTgf6AUTERaT+A/sDs4A3gKM6JQ5/NmZmZuUpvQndzMysV3ICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG4rkTRA0hOS3t2J65Ck/5G0UNIDHbC8b0j6eSvTj5R0dyvTp0s6djXX3eK8kkZJivw79N1G0tmSLmvjPBvn7aB/J4VVa/1bSfIvLfVSkj4i6aFWpl8r6ZSujKkncgLvYpJmS3pR0joV446VNL3idUh6XdJrkhZIuk3SJ6ssa19Jd0p6VdJ8SX+QdEDF9I0l/UzS83lZz0q6TNK2rYR4HHBnRPyjyvr+S9Jn8vDfJa2/mtWwG7A30BAR45uto2+OdXzFuMNynTQf9xeAiPh2RBybx/eIpFlLfo9Nf29LerPi9WHdHV/+7eK7gWO6Yn2SGiVN7ITlHlFRr2/mum56vagdy91e0pIaZYZJ+kX+vr8i6UlJX6xz+W1KUJImNX0f8uuBkv5P0u8lvauFeXaTdGuObYGkP0o6tN511hvL6oiImyJi5/bGsqZzAu8efYEv1SizY0SsC2wDXAb8SNLpTRMlTQauAS4HGoCNgNOAf83ThwL3Au8CdgcGAWOBP5CSZ0s+C1zRwrSdgYckDQfeiojFNd5DSzYDZkfE680nRMQy4I/AhypGfxD4S5Vxd67m+rtdRKzb9AfMAf61YtyVzct30wHJlaTtoVgRMaWinv+V9Bv2TfU8uJNX/xNgGbA1sAEwmfRZd6p8cvA70u95T4qIN6qU2RO4KZcbBQwDvgxM6uz48vp79AF2MSLCf134B8wGTgFeBgbncccC0yvKBLBVs/kmA0uAoYBIO4KTW1nP2cCjwFptiG1T4E2gb5VpAv4B9Af2A66usaxNgGn5fc4CPpPHH5Pfx3LgNeDMKvOeCvym4vUTwJFVxn0qD58B/CIPz8n191r++0Ce927gXGAh8Ddgv4plTQf+E7gHeBW4BRhWMX0C6WBoUa7Tic3mPTYP98nreAl4Fjg+x7JKfVbZJvaq8vldBUzNMR2Z38t9OY4XgAuBfhXzvA/4fa7zfwBfq1jWZXm4P3B1/uuX39ufgFeAF4HvVSyvf/6sRrQQ92DgF8D8/B7+HVDFNv0H4Pwc77PAPi0sZyrwNmnbew34CrBVrrtPA415HadUzLMW8A3gr7m+fwVsUKOe9yIdODYfvxnwm7ycv5K31Txtd+CRXD8vAGfn8S83287eV8/n2mz6DsAdpG3yCdJBHPn9LwP+mZc9tY7v7iTSQe4g4C7geqB/K+UfAb5bY5kfB/6cP78/ANtWTHuJdBLyBLCYdCLRD9gwf45vV9TN+qTvxRWkk45XgUNIJxc/ydtqI/Bd8vbc9H6afQcfy/NeDtxQuT301r9uD6C3/TV9qYHrKnYG9STwfvlLvR+wbS6zeSvruQ84o42xfRSY2Wzc6PwFfiWvfxFpp/5mHj68hWX9AfhvYCAwhrQD3jNPOxK4u5U4PpR3kGuRzgz+nr/sL1aMexvYNJc/g3cS+CiaJc28vqXAZ0hJ9nPA87yTbKaTdtxbA2vn19/J00YAC4D987r3zq+HV8zblMD/jbQTHQkMIe2c25PA3yKdNa6V49oFeD+pBWcL4GnghFx+/Vw/XwIGAOsB4yuWdVmuw/8DLiEf2AEPAofm4UHA+5vF8QSwfwtx/5K0HQ/K8cwCjqjYppcCR+c6/wIwt5U6aGTlA6OmBH5R3obGkhLa6Dz9q6QDrhF5+iXAFTXqeZUEnuvyCeAk0nds2xzLbnn6n4GP5eHKOt0eWFJjfb8CHiYdhGzZbNpgUuI6JNfPBNI2v3mefi1tSFCkhDeX9L2/qrVtjvT9CWCXVsrsRvqOjM3xfR54EuiTp79EagEbTkraf+OdA+qVkm8edy5pv/ER0snA2sB5pO/PUGBj0oHk15svg3e++8flz+gI0r6o1ydwN6F3n9OAL+Tm6JoiYinpSzOEtMFDOiNoyTDSDgIASQdIWpSvl9/SwjyDSUe4let9JlJT44WkndwGpMSxVUQMjohVmtsljSTtAL4eEUsi4hHg58DhdbxVgPtJX9r3kc6A7o7UDPi3inF/j4i2NEf+PSJ+FhHLgSmkHcZGFdP/JyKejog3SWenY/L4TwE3RsSNEfF2RNwKzCAl9OY+AVwQEXMj4mXgnDbEV83dEfGbvN43I+LBiLg/IpZFxLPAxbxzWeEAUoL8QUT8MyJeiYjKDoLrAzeTDjCOjYi38/ilwGhJQyPi1Yi4v1kMr5K2i5VI6pff7yl5vmdJZ9uVn/FfI+LSijpvkDSsjXVwRt6G/gTMBHbM4z8LfCMinouIJaSDuE9Iaus+7UOkA7nvR8TSiPhLjrWpz8lSYGtJQ6rUaS3Hks4UTwKekvQXSR/O0z4OPBwRv4qI5RFxH+ng6v9rY/yVhgLjSNvyshrloPX9x2eBH0TEn3J8/006gBlTUea8iJgfEfNy7GOqLajC7ZGubUf+nh0GnBYRCyL1ufgW1fcRE4FXI+Li/BlNIR109XpO4N0kIh4HfktqTq8p7zCHk47SF+TRG7cyy4LK6RExLSfiL5OaRqtZSDqbqlzvvbmzz78DZ5HOxLcDZkq6toXlbAK8HBGVBwN/J50t1ZR3yA+QrnN/kNQkCKkZvGlcW69/rziYiXeuCa5bbTrwRsW0zYCD88HPolwXu1G97jchnQU1+XsbY2yucllI2lbS7yT9Q9IrpM+jKSGOJJ0Bt2RX4L2kZtPK3t1HAe8hJZgHJDU/MBlEamlpbkPSmVnle2z+GTevU1i5zmuKlTtTVn4umwK/qfhM/kw6q9ywLcsnfb5bNft8vwg03YVxOCkpPiPpPkmt9R9pHvtrEXFGROxI+pxuAq7P16g3A/Zott4Daf07XcscUmvTNZI+2Eq5evYfmwGnNYtvA1r/fGt9tiu253wNfENa336aNP9eNZXt9ZzAu9fppGbdehLbgaRmoweAp0gb9MdbKX8bcFAbz0geA7ao7GASEf9C6kj3TESsD3yTlAQGR8TkFpbzPDBEUuXBwKbAc22I5U5Sot6ddxL4XRXjWkrgHX3r0VxS0+zgir91IuI7Vcq+QEqkTTZt57qbv5efAo+TWj/WI7XiqCLOLVtZ1o2kZszbKlt9IuKpiDiEtDP9PvBrSQMBlG4h24J03b+5eaR+DJtVjGvrZ1yprZ9bI7B3s89lYFS5e6KGucDjzZYzKCIOBoiImXl4Q9L12uvy96NN8UbEIuA7pJaQhrzeG5utd92I+GrTLG18H03r+QVwIung5gMtlHmJ9Jm2tv+YS2rhqIzvXRExrZ4wao3PLQTzqG/7eYFUZzQr2+s5gXejiJhFul7V4q0lkobk24p+TEqcC/IZ1FeAUyUdJWk9SWvl20IuzrOeRzpivkLSlkoG0UozV0Q0As8A45tNGke6lgfpmtiMGu9rLqnT1zn5dpYdSJ3XVuld3Yo7gQ+TEmJTc9ndpOa0MbScwOeTro9v0YZ1teYXwL8q3bLXJ7+fiZKa71AgNb1/UVKDpA2os3WlDQaROgy9Lmk7Vu4hPg3YVNIJkvrnbWKlzzEivk26tvr7fJcCkg6XNCw3qS8m7WSbmtcnAE9HxCo71XxJ51rg25LWlbQ5qXXnF6v53l6kbZ/ZRXndm+b3saEqbqFsgz8AA3K9DVC6jXFHSWPycj+dm8+Xk+rnbVIdzcvztXjwLeksSWMl9ZO0NqkfwDxSh75fA+MlTc7r7C/pA5K2yrOvUh/51rIf1XpDEXEJqcXsRkkt3Yp1EnC8pC9I2iDvH8ZJarok9lPgxBy/JA2SdFDTwV0NLwIbqeJW2RZMBc7I+7h3kzolVtt+7gDWV7rdtq+kT5Fak3o9J/DudxZQbUN/VNJrpGbRY4EvR8RpTRMj4lrSdbqjSWe8L5I6K92Qp79E2gEvISW+V0k9TweROnG15Keseh1qZ1IHE0gJvMUHLFQ4lNSh7HlSj9jT8/Xjet1LOlu5v6nJNyIWkBL0vIh4ptpMuXn8W8A9uelvQhvWWW15c0mtH9/I654LnEz1787PSNeZHyXV13XtWXcVJ5E68LxK+pyuqohzMamD3cdJSeJpVr7trqnc6aTrlbdKGky6lv+kpFdJZ+ifjIi3cvHDSImyJZ8ndbT7GykRTiH1EF4d3wbOzJ/ZiXWUP4/UJH1bjv1eUie/NsnvdT/SgeEcUt39mHeagw8Ens7rOJNUP8sjYj6pxeLRHPP7qiy+D+mg9WVSi8F4UofApZH6SOxLaoH7B+l7chapkxakev8XpYcdNR34jiR13Kvnff13jveWfADdfPptpM/+QFJz9Eukfi6/zdPvJB2Q/Zx0CeUp0v6mnpaBh0ifzZxcNy09L+I/SCcMT+Z57iDVafNY3wA+RmpZWAjsQ7r9rddr6oVrBqQnsZHOtvfMHUusF5K0MekyzJiKhG7dRNK6pB7mO1R0QLRezgnczMysQG5CNzMzK5ATuJmZWYGcwM3MzArUIx4oP2zYsBg1alR3h7HGeOqppwDYZpttujkSMzNrr4ceeuiliFjlqZ09IoGPGjWKGTNavbXY2mDixIkATJ8+vVvjMDOz9pNU9clzbkI3MzMrkBO4mZlZgZzAzczMCtQjroGbmVnnWbp0KY2NjSxZsqS7Q7FWDBw4kIaGBvr161e7MHUmcEmzSc9fXg4si4hxkoaQnsU8CpgNfCIiFkoS8APSc3bfAI7Mv+VrZmbdoLGxkUGDBjFq1CjSLtp6mohgwYIFNDY2svnmm9c1T1ua0D8cEWMiYlx+fQpwW0SMJj0zuemXl/YDRue/40g/wWdmZt1kyZIlDB061Mm7B5PE0KFD29RK0p5r4AeSfn2I/P+givGXR3IfMDj/MIKZmXUTJ++er62fUb0JPEg/S/eQpOPyuI2afq0q/98wjx9B+snFJo15nJmZmXWQehP4rhExltQ8frykD7ZSttohxCo/eSbpOEkzJM2YP39+nWGYmVmJJHH44YeveL1s2TKGDx/OpEmTujGqVU2ZMoXRo0czevRopkyZUrXMNddcw3vf+17WWmutlR5CNnv2bNZee23GjBnDmDFj+Ld/+7dV5j3ggAPYfvvtOyTWujqxRcTz+f88SdeTfpj+RUkbR8QLuYl8Xi7eSPrh+SYNpB+rb77Mi4GLAcaNG+ffNDUzW4Ots846PP7447z55pusvfba3HrrrYwY0bMaZ19++WXOPPNMZsyYgSR23nlnDjjgADbYYIOVym2//fZcd911fPazn11lGVtuuSWPPPJI1eVfd911rLvuuh0Wb80zcEnrSBrUNAzsAzwOTAOOyMWOAG7Iw9OATyuZACxuamo3M7Pea7/99uN3v/sdAFOnTuXQQw9dMe3111/n6KOPZpdddmGnnXbihhtSSpk9eza77747Y8eOZezYsdx7771AelT0xIkTmTx5Mttuuy2HHXYYEe07F7z55pvZe++9GTJkCBtssAF77703N9100yrltttuuzb/1sRrr73Geeedxze/+c12xVipnjPwjYDr88X1vsAvI+ImSQ8CV0s6BpgDHJzL30i6hWwW6TayozosWjMza5cTTzyxxTPE1TVmzBguuOCCmuUOOeQQzjrrLCZNmsRjjz3G0UcfzV133QXAt771LfbYYw8uvfRSFi1axPjx49lrr73YcMMNufXWWxk4cCDPPPMMhx566Ipm64cffpiZM2eyySabsOuuu3LPPfew2267rbTO733ve1x55ZWrxPLBD36QCy+8cKVxzz33HCNHvtOA3NDQwHPPPdemuvjb3/7GTjvtxHrrrcfZZ5/N7rvvDsCpp57KSSedxLve9a42La81NRN4RDwL7Fhl/AJgzyrjAzi+Q6JrhyXL32Jgn/5dPq+ZmVW3ww47MHv2bKZOncr++++/0rRbbrmFadOmce655wLp1rc5c+awySabcMIJJ/DII4/Qp08fnn766RXzjB8/noaGBiAdRMyePXuVBH7yySdz8skn1xVftTP4tvQM33jjjZkzZw5Dhw7loYce4qCDDmLmzJk8++yzzJo1i/PPP5/Zs2fXvbxa1tgnsQ3s059Nbzm4dsEq5uxzTQdHY2bWM9RzptyZDjjgAL761a8yffp0FixYsGJ8RPDrX/96labpM844g4022ohHH32Ut99+m4EDB66YNmDAgBXDffr0YdmyZausry1n4A0NDSv9imNjY+OKX3esx4ABA1bEtPPOO7Plllvy9NNP8+CDD/LQQw8xatQoli1bxrx585g4cWK7fzFyjU3gZmbW8xx99NGsv/76vO9971spge2777788Ic/5Ic//CGSePjhh9lpp51YvHgxDQ0NrLXWWkyZMoXly5e3aX1tOQPfd999+cY3vsHChQuB1Cpwzjnn1L2u+fPnM2TIEPr06cOzzz7LM888wxZbbMG4ceP43Oc+B6Rr+pMmTeqQn3v2j5mYmVmXaWho4Etf+tIq40899VSWLl3KDjvswPbbb8+pp54KwOc//3mmTJnChAkTePrpp1lnnXU6LbYhQ4Zw6qmnsssuu7DLLrtw2mmnMWTIEACOPfbYFdfer7/+ehoaGvjjH//IRz/6Ufbdd18A7rzzTnbYYQd23HFHJk+ezEUXXbRi/s6g9vba6wjjxo2LynvpOkpvbUJvavLpiCM8Myvfk08+yXbbbdfdYVgdqn1Wkh6qeIz5Cj4DNzMzK5ATuJmZWYGcwM3MeoGecLnUWtfWz8gJ3MxsDTdw4EAWLFjgJN6DNf0eeOVtcrX4NjIzszVcQ0MDjY2N+IejeraBAweueDBNPZzAzczWcP369WPzzTfv7jCsg7kJ3czMrEBO4GZmZgVyAjczMyuQE7iZmVmBnMDNzMwK5ARuZmZWICdwMzOzAjmBm5mZFcgJ3MzMrEBO4GZmZgVyAjczMyuQE7iZmVmBnMDNzMwK5ARuZmZWICdwMzOzAjmBm5mZFcgJ3MzMrEBO4GZmZgVyAjczMyuQE7iZmVmBnMDNzMwK5ARuZmZWICdwMzOzAjmBm5mZFcgJ3MzMrEBO4GZmZgVyAjczMyuQE7iZmVmBnMDNzMwK5ARuZmZWICdwMzOzAjmBm5mZFcgJ3MzMrEBO4GZmZgVyAjczMyuQE7iZmVmBnMDNzMwK5ARuZmZWoLoTuKQ+kh6W9Nv8enNJ90t6RtJVkvrn8QPy61l5+qjOCd3MzKz3assZ+JeAJytefxc4PyJGAwuBY/L4Y4CFEbEVcH4uZ2ZmZh2orgQuqQH4KPDz/FrAHsC1ucgU4KA8fGB+TZ6+Zy5vZmZmHaTeM/ALgK8Bb+fXQ4FFEbEsv24ERuThEcBcgDx9cS6/EknHSZohacb8+fNXM3wzM7PeqWYClzQJmBcRD1WOrlI06pj2zoiIiyNiXESMGz58eF3BmpmZWdK3jjK7AgdI2h8YCKxHOiMfLKlvPstuAJ7P5RuBkUCjpL7A+sDLHR65mZlZL1bzDDwi/j0iGiJiFHAIcHtEHAbcAUzOxY4AbsjD0/Jr8vTbI2KVM3AzMzNbfe25D/zrwFckzSJd474kj78EGJrHfwU4pX0hmpmZWXP1NKGvEBHTgel5+FlgfJUyS4CDOyA2MzMza4GfxGZmZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYFqJnBJAyU9IOlRSTMlnZnHby7pfknPSLpKUv88fkB+PStPH9W5b8HMzKz3qecM/J/AHhGxIzAG+IikCcB3gfMjYjSwEDgmlz8GWBgRWwHn53JmZmbWgWom8Eheyy/75b8A9gCuzeOnAAfl4QPza/L0PSWpwyI2MzOz+q6BS+oj6RFgHnAr8FdgUUQsy0UagRF5eAQwFyBPXwwM7cigzczMeru6EnhELI+IMUADMB7Yrlqx/L/a2XY0HyHpOEkzJM2YP39+vfGamZkZbeyFHhGLgOnAEmaAjwAAIABJREFUBGCwpL55UgPwfB5uBEYC5OnrAy9XWdbFETEuIsYNHz589aI3MzPrperphT5c0uA8vDawF/AkcAcwORc7ArghD0/Lr8nTb4+IVc7AzczMbPX1rV2EjYEpkvqQEv7VEfFbSU8Av5J0NvAwcEkufwlwhaRZpDPvQzohbjMzs16tZgKPiMeAnaqMf5Z0Pbz5+CXAwR0SnZmZmVXlJ7GZmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ3AzM7MC1UzgkkZKukPSk5JmSvpSHj9E0q2Snsn/N8jjJelCSbMkPSZpbGe/CTMzs96mnjPwZcBJEbEdMAE4XtJ7gFOA2yJiNHBbfg2wHzA6/x0H/KTDozYzM+vlaibwiHghIv6Uh18FngRGAAcCU3KxKcBBefhA4PJI7gMGS9q4wyM3MzPrxdp0DVzSKGAn4H5go4h4AVKSBzbMxUYAcytma8zjmi/rOEkzJM2YP39+2yM3MzPrxepO4JLWBX4NnBgRr7RWtMq4WGVExMURMS4ixg0fPrzeMMzMzIw6E7ikfqTkfWVEXJdHv9jUNJ7/z8vjG4GRFbM3AM93TLhmZmYG9fVCF3AJ8GREnFcxaRpwRB4+ArihYvync2/0CcDipqZ2MzMz6xh96yizK3A48GdJj+Rx3wC+A1wt6RhgDnBwnnYjsD8wC3gDOKpDIzYzM7PaCTwi7qb6dW2APauUD+D4dsZlZmZmrfCT2MzMzArkBG5mZlYgJ3AzM7MCOYGbmZkVyAnczMysQE7gZmZmBXICNzMzK5ATuJmZWYGcwM3MzArkBG5mZlYgJ/Aqlix/q1vnNzMzq6WeHzPpdQb26c+mtxxcu2AL5uxzTQdGY2ZmtiqfgZuZmRXICdzMzKxATuBmZmYFcgI3MzMrkBO4mZlZgZzAzczMCuQEbmZmViAncDMzswI5gZuZmRXICdzMzKxATuBmZmYFcgLvYdrzQyj+ERUzs97DP2bSw7Tnh1T8IypmZr2Hz8DNzMwK5ARuZmZWICdwMzOzAjmBm5mZFcgJ3MzMrEBO4GZmZgVyAjczMyuQE7iZmVmBnMDNzMwK5ATeCfxIUzMz62x+lGon8ONQzcyss/kM3MzMrEBO4GuQ9jbdu+nfzKwcbkJfgzQ13c9bOBOgzc34br43MyuHz8DNzMwK5ARuZmZWICdwMzOzAjmBm5mZFcgJ3MzMrEBO4GZmZgVyAjczMyuQE7iZmVmBnMBthfY8ic1PcTMz61o1n8Qm6VJgEjAvIrbP44YAVwGjgNnAJyJioSQBPwD2B94AjoyIP3VO6NbR/CMsZmblqOcM/DLgI83GnQLcFhGjgdvya4D9gNH57zjgJx0TpvV0fg67mVnXqnkGHhF3ShrVbPSBwMQ8PAWYDnw9j788IgK4T9JgSRtHxAsdFbD1TO05ewefwZuZtdXqXgPfqCkp5/8b5vEjgLkV5RrzuFVIOk7SDEkz5s+fv5phmJmZ9U4d3YlNVcZFtYIRcXFEjIuIccOHD+/gMMzMzNZsq5vAX5S0MUD+Py+PbwRGVpRrAJ5f/fDMzMysmtVN4NOAI/LwEcANFeM/rWQCsNjXv83MzDpePbeRTSV1WBsmqRE4HfgOcLWkY4A5QFPvpRtJt5DNIt1GdlQnxGxmZtbr1dML/dAWJu1ZpWwAx7c3KDMzM2udn8RmZmZWICdwMzOzAjmBm5mZFcgJ3MzMrEBO4GZmZgVyArcewT9lambWNjVvIzPrCv4pUzOztvEZuJmZWYGcwM3MzArkBG5mZlYgJ3Dr1drbAc4d6Mysu7gTm/Vq7ek8B+5AZ2bdx2fgVjyfBZtZb+QzcCueb0Ezs97IZ+BmZmYFcgI3MzMrkBO4mZlZgZzAzczMCuQEbmZmViAncDMzswI5gZuZmRXICdzMzKxATuBmZmYFcgI3MzMrkBO4mZlZgZzAzczMCuQEbmZmViAncDMzswI5gZuZmRXICdzMzKxATuBmZmYFcgI3MzMrkBO4mZlZgZzAzczMCuQEbmZmViAncLN2WLL8reLm7Yj5zaz79e3uAMxKNrBPfza95eDVmnfOPtd0y7xN85tZ2XwGbmZmViAncDMzswI5gZuZmRXICdzMzKxATuBmZmYFcgI364W68xY2M+sYvo3MrBdq7+1vZtb9fAZuZmZWICdwMzOzAjmBm5mZFajTErikj0h6StIsSad01nrMrGu5A5xZz9Apndgk9QF+DOwNNAIPSpoWEU90xvrMrOu0pwPc03te2a51L1n+FgP79O/yebt73dZ1unM7aavO6oU+HpgVEc8CSPoVcCDgBG7Wi7Un+UP7fsSlvQcP3XXgUuqBR6lxd8Q22lU6K4GPAOZWvG4E3t9J6zIzq6k7d8zdedteyb+Y111xl6KzEriqjIuVCkjHAcfll69JeqqDYxgGvLQ6M6pq+F0zf0fOO3ffaztq3TXrck2psy6Yf0VdFhZ3t89bZf42fcd7a53VqWpd9qDPuoh58/yrnXtasVm1kZ2VwBuBkRWvG4DnKwtExMXAxZ20fiTNiIhxnbX83sR12XFclx3HddlxXJcdpyvrsrN6oT8IjJa0uaT+wCHAtE5al5mZWa/TKWfgEbFM0gnAzUAf4NKImNkZ6zIzM+uNOu1Z6BFxI3BjZy2/Dp3WPN8LuS47juuy47guO47rsuN0WV0qImqXMjMzsx7Fj1I1MzMrUPEJvNYjWyUNkHRVnn6/pFFdH2UZ6qjLr0h6QtJjkm6TVPXWBqv/UcKSJksKSe4B3IJ66lLSJ/K2OVPSL7s6xlLU8R3fVNIdkh7O3/P9uyPOnk7SpZLmSXq8hemSdGGu58ckje2UQCKi2D9SB7m/AlsA/YFHgfc0K/N54KI8fAhwVXfH3RP/6qzLDwPvysOfc12ufl3mcoOAO4H7gHHdHXdP/KtzuxwNPAxskF9v2N1x98S/OuvyYuBzefg9wOzujrsn/gEfBMYCj7cwfX/g/0jPRJkA3N8ZcZR+Br7ika0R8RbQ9MjWSgcCU/LwtcCekrrkyQiFqVmXEXFHRLyRX95Hur/fVlXPdgnwn8B/AUu6MrjC1FOXnwF+HBELASJiXhfHWIp66jKA9fLw+jR7foclEXEn8HIrRQ4ELo/kPmCwpI07Oo7SE3i1R7aOaKlMRCwDFgNDuyS6stRTl5WOIR1h2qpq1qWknYCREfHbrgysQPVsl1sDW0u6R9J9kj7SZdGVpZ66PAP4lKRG0l1EX+ia0NY4bd2frpZOu42si9R8ZGudZawN9STpU8A44EOdGlG5Wq1LSWsB5wNHdlVABatnu+xLakafSGoVukvS9hGxqJNjK009dXkocFlEfF/SB4Arcl2+3fnhrVG6JO+UfgZe85GtlWUk9SU1C7XW9NFb1VOXSNoL+A/ggIj4ZxfFVppadTkI2B6YLmk26RrZNHdkq6re7/gNEbE0Iv4GPEVK6LayeuryGOBqgIj4IzCQ9Jx0a5u69qftVXoCr+eRrdOAI/LwZOD2yL0MbCU16zI3+/6UlLx9nbFlrdZlRCyOiGERMSoiRpH6ExwQETO6J9werZ7v+P+SOlgiaRipSf3ZLo2yDPXU5RxgTwBJ25ES+PwujXLNMA34dO6NPgFYHBEvdPRKim5CjxYe2SrpLGBGREwDLiE1A80inXkf0n0R91x11uX3gHWBa3I/wDkRcUC3Bd1D1VmXVoc66/JmYB9JTwDLgZMjYkH3Rd0z1VmXJwE/k/RlUpPvkT7hWZWkqaRLNsNyf4HTgX4AEXERqf/A/sAs4A3gqE6Jw5+NmZlZeUpvQjczM+uVnMDNzMwK5ARuZmZWICdwMzOzAjmBm5mZFcgJ3MzMrEBO4GZmZgVyAjczMyuQE7iZmVmBnMDNzMwK5ARuZmZWICdwMzOzAjmB91KSBkh6QtK7O3EdkvQ/khZKeqATln+GpF/k4U0lvSapT349XdKxHb3OZuufKWliZ66jM0k6VtL0Ns6ztqSnJA3tpLBqrb+vpJA0qjvWb91L0naSXmpl+rmSLurKmLqTE3gnkTRb0ouS1qkYt9IOM++IXs+JZ4Gk2yR9ssqy9pV0p6RXJc2X9AdJB1RM31jSzyQ9n5f1rKTLJG3bSojHAXdGxD+qrO+/JH0mD/9d0vqrWQ27AXsDDRExvlqBHPslkl7I7+8vks6srLd6RMSciFg3IpavZqytyvV5drN1vjcipnfwembmz/A1ScslLal4/Y2OXNfqiIg3gSnA17pifZLulnRkJyx3YkW9vp6/i69V/G2ymstdNy+rxQPjfBD0I0nP5W3+r5K+Xefy25SgJG0vaUnF67UkXSrpUUnDW5nnekkvS1ok6eH8M6Tt0jyW1RERT0bEsPbGsqZwAu9cfYEv1SizY0SsC2wDXAb8SNLpTRMlTQauAS4HGoCNgNOAf83ThwL3Au8CdgcGAWOBP5CSZ0s+C1zRwrSdgYfyF/ytiFhc4z20ZDNgdkS8Xm2ipCHAH4G1gQ9ExKAc82Bgy9VcZ5tJ6ttV66olHxSsm7eJu4ATml5HxCo7+W6K/UrgKEn9umHdHSIiplfU84553LoVf8934urPAkYDOwHrAfsAj3fi+gDIrVOXAzsAH46I+VXKvJe0P3kCeE9EDAY+BezRFdtaT/ouFiEi/NcJf8Bs4BTgZWBwHncsML2iTABbNZtvMrAEGAoImAOc3Mp6zgYeBdZqQ2ybAm8CfatME/APoD+wH3B1jWVtAkzL73MW8Jk8/pj8PpYDrwFnthD7n1uLHfgBMBd4BXgI2L1i2hnAL/LwqFyfffPr6cA5wAPAYuAGYEizssfk+r0zj78mv/fFwJ3Ae/P444ClwFv5vfym4jPeKw8PAC4Ans9/FwAD8rSJQCNwEjAPeAE4qo7PaTpwbLNxx+bYLsx1fgYpGdwBLABeIh2YrV8xz2bA/wLz8/QfNN8e8+d+PunAbz1g67yexXmeXzaL42/Ari3EPTDH9wLwHHAe0D9P2yvX29dyPM8Dn25hOd/N28+SXO8XkA6Kg3QAOgtYCFxYpY7+kqf9HzCyRj1vBUSV8UOBX+RtYg7wTUB52nuBe3L9zAf+J4//U47v9RzzpHo+12bTNwN+k+v9r7zznfp43gaX5mXfW8c2tH2uv36k7fveym2jSvn/Ba6qscwPkb5Xi0jfyQ9UTJsBnJqnvwL8tml9eXuNHPtrwPuAE4BbgYvy53UK0Ie0b5ib6/7nwLqV76difVuTTgJeBX6Xy15U776w9L9uD2BN/cs7qb2A64Cz87h6Eng/YBkpeW6by2zeynruA85oY2wfBWY2Gzc6fyFfyetflL/4b+bhw1tY1h+A/ybttMfkndmeedqRwN01Yl8lsTcr8ynSjrQvKQH+AxiYp51B6wn8ufyFXwf4dZWyl+dpa+fxR5NaMJqS8SMVcVzW9Dk2/4zz8Fn5/WwIDCftKP8zT5uY6/Ss/PnuD7wBbFDjvU+negJfBnyOtKNbO+/E9iQddG1ISizn5vJ9SWd35za9V3Libdoe83IuBW6sqItrgK+TWukG0ixZ57KfbyHub+f3PzzHcz9wep62V47/9FwXB5CS3XotLOtu4MiK100J/AZg/fxZvlzxOUwGniK1aPXN28hdNeq5pQR+K+mgZm3SgepjwGF52m+AE0kHPpV1um6O792trO87pMT8WdJZLs3e3xOkbb0faR/QCOyWp59LGxIUafv/J+kg+w/kRNhK+deAg1uZviXpQHGPvG0cQDoobUrSM4Angc1zXdwPfLMiliXNlndC3h6O5p3t+YvATNKJxvqkg7CfNF9GrvvHSMm+P6n17s221E/pf90ewJr6xzsJfHvSUfpw6kjgefw/gMOAXXOZga2sZxbwbxWvDyAl3FeBW1qY5zDgvhamnU1q9m/6coxoZd0jSWdIgyrGnQNcloePpPUE/kxl7HXW60LSZQeoncC/UzHfe0hnL30qym7RynoG5zJNO6bLaD2B/xXYv2LavqTLB5AS+EotHqSd3oQa73U61RP4szXmmww8mId3z9tTnyrljiUl2muBq4F+FdN+Cfykpc8fuAr4RgvT/g7sU/H6o8CsPLwXKUn0qZj+MjCuhWW1lMAnVIy7DvhqHr4VOKJZ+X/W2I5XSeCkRPVKs8/sM7zT+nIdqXXo3c3mqyeB9wO+TDrge4t0pvmJPG1P4Mlm5b8F/DAPr04CX046SPpsjbIDcuy7tVLmP8nJtGLcPcDH8/AM4MSKaV8Drq2IpVoCf6LZuPupaJUhXdJ7tfkySN/p18mtO3nctLbUT+l/vgbeySLicVIz0in1lM/XFYeTdmoL8uiNW5llQeX0iJgW6brVl0lHpdUsJJ1pVq73XkmLgH8nnSm+AmwHzJR0bQvL2QR4OSJerRj3d2BEK/G2GHs1kk6S9KSkxTm+9YF6O7HMbRZXv2bzrpguqY+k7+QORa+QkjNtWNcmeR2V66vsCLUgIpZVvH6DtLNfHZXvC0nvlnR17hT1CulgoynukaQDiZY6921DSrBnRcTSivFNZ4AzJP1Z0hHN5htEOlCsZmNWrYvKbeKlZvGsTl1Udr6snH8z4Me589UiUjP026T+I22xGanF4qWKZX2f1AcF0kHuesAjuUPYofUuOCKWRsT5ETEB2IB0ueHK3LN+M2CrpnXm9X4RaM/dIktJB/bfl3RIK3H9k5QQW/tObgYc2Sy+May8rbf02bRkbrPX1b5L61bpTLsJMC8i3mpWttdwAu8ap5OO3utJbAeSmpQeIDUFziVd+2rJbcBBktryWT4GbFHZYSQi/oW0M38mItYnXe/7bkQMjojJLSzneWCIpMqDgU1JTdf1+D3wsZZil7Q7qRn3E6Tm5sGk1gzVufyRzeJaStqhN4mK4f+fVPd78U7TLBXrqixbzfOknVvl+jqrI1TzWL5LOst8X0SsR2r5aIp7LrBZ7sBUzZ9J1/hvkjR6xQoiXoiIYyNiY+B44GJJm1fMtx2p70U1L7BqXdS7TTRXq96bmwsck7fbpr+1I+L+1VjOYvJ2l//Wi3w3RUTMjYijSMnuK8Dlued6m+KNiNcj4nuk7/w2eb2PN4t/UEQc3DRLG99H03puI7XM/FzSQa0U/T2t72/mks5wK+NbJyJ+WE8YdY6v9l16LVbtTPsCsKGk/s3K9hpO4F0gImaRmhy/2FIZSUMkHQb8mJQ4F0RqE/oKcKqkoyStl28D2U3SxXnW80hH8VdI2lLJINJRcUvxNJKar5vf2jUOeDgPjyU1h7X2vuaSmmDPkTRQ0g6kjmFXtjZfhfNIZzFTJG2W62GEpPPysgaRdmzzgb6STsvl6/UpSe+R9C5Sq8K1rZyJDiIlwQWkHv3Ne3y/CGzRyrqmAt+UNFzSMNKdAr9oQ6ztMYh05rRY0kjgqxXT/kh6T9+W9K58C9OulTNHxBWkg8zfNyVpSZ+Q1HTAuYi0k12ep21KOqt6sIV4pgKnSRqW72Q4ldWvi1r13txFwH9I2i7HOjjfydEmEfEMqUPat/OtYWtJ2rqp7iQdImnj/B1dUT+R7rh4rbWYJZ2cv8MDJfWT9Lk8/2Ok69QDJJ2g9KyGvpJ2lNT0fX4R2FySKpZ3rqTf1vGebiIdqP5C0v4tFPsPYH9JZ0naMC9/W0nX5AP+y4BDJX0418nakvaStFELy6s0L7+3WicyU4GTJTVIWo/UbF9tn/IE8Czpe9dP0p60fufNGscJvOucRWqSa+5RSa+RrmUfC3w5Ik5rmhgR1wKfJHXyeJ70BT6b1ImHiHgJmEDqcHY36dr3I6Sd+udaieenwOHNxu1M2mlBSuAP1fG+DiWdrT4PXE/qrHRrHfMRES8D/0I6M75f0qukFoXFpPq4mdSB5WlS09gSVm1ua80VpB3OP0gdsVo8gCJ1aPs76UzxCdL1yUqXAO/JzYb/W2X+s0kHPI+Rzmr/lMd1hdNJB2OLSdcAf900ITfbTyKdMc8l9aZeJaFFxCWkzlW35wT9fuBBSa+TrvceHxFzcvHDSL2u32q+nOxM0tn5n0n1cT+pb8TquICUMBZJOq9W4Yi4hnRgeE2+nPAYqT/C6vgkqcn8KdIlramky1uQ+qf8KX93p5LO+l/M004Drs8xf7TKct8CfkT6Ls8jfQ8PzK0eb5E6sE4kfVbzSAf1Tc3QvyT1z3hZ0l153EjSdeiaImIaqYXmKkl7VZk+k/Sd3AF4KjeR/xK4IyKW5QObg0nb9gLSpaYvUEerWKTb1r5P2uctkvS+For+iNRJ8H7SicaLwMlVlhc5ln1IlwW/kmPtNZpuibBeRtIA0tn2nhHxQnfHY2WQtDbpAHHXfPBo3UzSTFKnvldrFrY1ihO4mZlZgdyEbmZmViAncDMzswI5gZuZmRWoRzw4ftiwYTFq1KjuDsNa8NRTTwGwzTbbdHMkZma9z0MPPfRSRKzy63E9IoGPGjWKGTNaveXYutHEiRMBmD59erfGYWbWG0mq+oQ5N6GbmZkVyAnczMysQE7gZmZmBeoR18DNzKzzLF26lMbGRpYsWdLdoVgrBg4cSENDA/369aurfN0JPP+a0QzguYiYlH/04FfAENJznw+PiLfyIzovJz1XewHwyYiY3ba3YWZmHaWxsZFBgwYxatQoKn4HxXqQiGDBggU0Njay+eab156BtjWhfwl4suL1d4HzI2I06UHyx+TxxwALI2Ir4PxczszMusmSJUsYOnSok3cPJomhQ4e2qZWkrgQuqQH4KPDz/FrAHsC1ucgUoOk3Zg/Mr8nT95S3GjOzbuXdcM/X1s+o3jPwC4CvAW/n10OBRfmnCgEagabfeB1B/snHPH1xLt880OMkzZA0Y/78+W0K2szMrLermcAlTQLmRUTlb0NXO0yIOqa9MyLi4ogYFxHjhg9f5QEzZma2BpHE4YcfvuL1smXLGD58OJMmTerGqFY1ZcoURo8ezejRo5kyZUrVMieffDLbbrstO+ywAx/72MdYtGjRimnnnHMOW221Fdtssw0333wzkC5hjB8/nh133JH3vve9nH766R0Saz1n4LsCB0iaTeq0tgfpjHywpKZOcA3A83m4kfQD8+Tp6wMvd0i0ZmZWpHXWWYfHH3+cN998E4Bbb72VESNG1Jira7388suceeaZ3H///TzwwAOceeaZLFy4cJVye++9N48//jiPPfYYW2+9Neeccw4ATzzxBL/61a+YOXMmN910E5///OdZvnw5AwYM4Pbbb+fRRx/lkUce4aabbuK+++5rd7w1E3hE/HtENETEKOAQ4PaIOAy4A5icix0B3JCHp+XX5Om3h3903Mys19tvv/343e9+B8DUqVM59NBDV0x7/fXXOfroo9lll13YaaeduOGGlFJmz57N7rvvztixYxk7diz33nsvkB7tPHHiRCZPnsy2227LYYcdRntTzc0338zee+/NkCFD2GCDDdh777256aabVim3zz770LdvOn+dMGECjY2NANxwww0ccsghDBgwgM0335ytttqKBx54AEmsu+66QLqlb+nSpR3SJ6E994F/HfiVpLOBh4FL8vhLgCskzSKdeR/SvhDNzKyjnHjiiTzyyCMduswxY8ZwwQUX1Cx3yCGHcNZZZzFp0iQee+wxjj76aO666y4AvvWtb7HHHntw6aWXsmjRIsaPH89ee+3FhhtuyK233srAgQN55plnOPTQQ1f8dsbDDz/MzJkz2WSTTdh1112555572G233VZa5/e+9z2uvPLKVWL54Ac/yIUXXrjSuOeee46RI0eueN3Q0MBzzz3X6nu69NJL+eQnP7li/gkTJlSdf/ny5ey8887MmjWL448/nve///0166uWNiXwiJgOTM/DzwLjq5RZAhzc7sjaacnytxjYp3+PWY6ZWW+3ww47MHv2bKZOncr++++/0rRbbrmFadOmce655wLpuvGcOXPYZJNNOOGEE3jkkUfo0+f/tXf/QXaV9R3H3183CVt/1BhZmJgNhbZxBCINziam40wLIj9kOgnMCINjFRWbqtDSVjOinSD9wYy2tUy1lDYO1MBY+SFtyTAUgxHG2inoKgETohAlk2yTIVsMEQcJZvn2j3uSbjY3e+/uvXd3n9z3a+bOPfc5zzn3e59s8sn5cZ/t4cknnzy0zbJly+jv7wdq/4nYvn37EQG+evVqVq9e3VR99Y7gxztSvv7665k1axbvec97Gm7f09PDpk2beO6557j44ovZvHkzixcvbqquozlmZ2Lr7ZnDSRta/3/EjvPuakM1kjQzNHOk3EkrVqzg4x//OA899BDPPvvsofbM5O677z7i1xZfd911nHjiiTz22GO8/PLL9Pb2Hlp33HHHHVru6enhwIEDjDWRI/D+/v7Dfuvi0NDQod/GONa6deu499572bhx46GQ7u/vZ+fOnYdt/4Y3vOGw7ebOnctZZ53F/fff33KAOxe6JGnKfPCDH+Taa6/lzW9+82Ht559/Pl/4whcOHcU++uijAOzbt4/58+fzile8gttuu42RkZEJvd/q1avZtGnTEY+x4X2whg0bNrB371727t3Lhg0bOP/884/od//99/PZz36W9evX88pXvvJQ+4oVK7j99tvZv38/Tz/9NE88CtwDAAAUbUlEQVQ99RTLli1jeHj40J3qP//5z/n617/Om970pgl9jnoMcEnSlOnv7+fqq68+on3NmjX84he/4IwzzmDx4sWsWbMGgI9+9KOsW7eO5cuX8+STT/KqV72qY7XNmzePNWvWsHTpUpYuXcq1117LvHnzAPjQhz506Nr7VVddxfPPP8+5557LkiVL+PCHPwzA6aefzqWXXsppp53GBRdcwI033khPTw+7d+/m7LPP5owzzmDp0qWce+65bfn6XMyEG8QHBgby4MC0k6fQ2+PgKaTRp5YklWPr1q2ceuqp012GmlDvzyoivpuZA2P7egQuSVKBDHBJkgpkgEtSF5gJl0s1von+GRngknSM6+3t5dlnnzXEZ7CDvw989NfkGjlmvwcuSarp7+9naGgIf/PjzNbb23toYppmGOCSdIybPXs2p5xyynSXoTbzFLokSQUywCVJKpABLklSgQxwSZIKZIBLklQgA1ySpAIZ4JIkFcgAlySpQAa4JEkFMsAlSSqQAS5JUoEMcEmSCmSAS5JUIANckqQCGeCSJBXIAJckqUANAzwieiPi2xHxWERsiYg/q9q/FBFPR8Sm6rGkao+I+HxEbIuIxyPiLZ3+EJIkdZtZTfTZD7w9M38WEbOBb0XEf1TrVmfmV8f0fyewqHq8FbipepYkSW3S8Ag8a35WvZxdPXKcTVYCt1bbPQzMjYj5rZcqSZIOauoaeET0RMQmYA/wQGY+Uq26vjpNfkNEHFe1LQB2jtp8qGqTJElt0lSAZ+ZIZi4B+oFlEbEY+CTwJmApMA/4RNU96u1ibENErIqIwYgYHB4enlTxkiR1qwndhZ6ZzwEPARdk5u7qNPl+4J+BZVW3IWDhqM36gV119rU2Mwcyc6Cvr29SxUuS1K2auQu9LyLmVsu/BLwD+MHB69oREcBFwOZqk/XA+6q70ZcD+zJzd0eqlySpSzVzF/p8YF1E9FAL/Dsz896I+EZE9FE7Zb4J+HDV/z7gQmAb8ALwgfaXLUlSd2sY4Jn5OHBmnfa3H6V/Ale2XpokSToaZ2KTJKlABrgkSQUywCVJKpABLklSgQxwSZIKZIBLklQgA1ySpAIZ4JIkFcgAlySpQAa4JEkFMsAlSSqQAS5JUoEMcEmSCmSAS5JUIANckqQCGeCSJBXIAJckqUAGuCRJBTLAJUkqkAEuSVKBDHBJkgpkgEuSVCADXJKkAhngkiQVyACXJKlABrgkSQUywCVJKlDDAI+I3oj4dkQ8FhFbIuLPqvZTIuKRiHgqIu6IiDlV+3HV623V+pM7+xEkSeo+zRyB7wfenpm/ASwBLoiI5cBngRsycxGwF7ii6n8FsDczfx24oeonSZLaqGGAZ83Pqpezq0cCbwe+WrWvAy6qlldWr6nWnxMR0baKJUlSc9fAI6InIjYBe4AHgB8Bz2XmgarLELCgWl4A7ASo1u8DXl9nn6siYjAiBoeHh1v7FJIkdZmmAjwzRzJzCdAPLANOrdeteq53tJ1HNGSuzcyBzBzo6+trtl5JksQE70LPzOeAh4DlwNyImFWt6gd2VctDwEKAav1rgZ+0o1hJklTTzF3ofRExt1r+JeAdwFbgQeBdVbfLgXuq5fXVa6r138jMI47AJUnS5M1q3IX5wLqI6KEW+Hdm5r0R8QRwe0T8JfAocHPV/2bgtojYRu3I+7IO1C1JUldrGOCZ+ThwZp32H1O7Hj62/UXgkrZUJ0mS6nImNkmSCmSAS5JUIANckqQCGeCSJBXIAJckqUAGuCRJBTLAJUkqkAEuSVKBDHBJkgpkgEuSVCADXJKkAhngkiQVyACXJKlABrgkSQUywCVJKpABLklSgQxwSZIKZIBLklQgA1ySpAIZ4JIkFcgAlySpQAa4JEkFMsAlSSqQAS5JUoEMcEmSCmSAS5JUoIYBHhELI+LBiNgaEVsi4uqq/bqI+J+I2FQ9Lhy1zScjYltE/DAizu/kB5AkqRvNaqLPAeBjmfm9iHgN8N2IeKBad0Nm/s3ozhFxGnAZcDrwBuDrEfHGzBxpZ+GSJHWzhkfgmbk7M79XLT8PbAUWjLPJSuD2zNyfmU8D24Bl7ShWkiTVTOgaeEScDJwJPFI1XRURj0fELRHxuqptAbBz1GZDjB/4kiRpgpoO8Ih4NXA38EeZ+VPgJuDXgCXAbuBzB7vW2Tzr7G9VRAxGxODw8PCEC5ckqZs1FeARMZtaeH85M/8VIDOfycyRzHwZ+CL/f5p8CFg4avN+YNfYfWbm2swcyMyBvr6+Vj6DJEldp5m70AO4GdiamX87qn3+qG4XA5ur5fXAZRFxXEScAiwCvt2+kiVJUjN3ob8NeC/w/YjYVLV9Cnh3RCyhdnp8O/D7AJm5JSLuBJ6gdgf7ld6BLklSezUM8Mz8FvWva983zjbXA9e3UJckSRqHM7FJklQgA1ySpAIZ4JIkFcgAlySpQAa4JEkFMsAlSSqQAS5JUoEMcEmSCmSAS5JUIANckqQCGeCSJBXIAJckqUAGuCRJBTLAJUkqkAEuSVKBDHBJkgpkgEuSVCADXJKkAhngkiQVyACXJKlABrgkSQUywCVJKpABLklSgQxwSZIKZIBLklQgA1ySpAIZ4JIkFahhgEfEwoh4MCK2RsSWiLi6ap8XEQ9ExFPV8+uq9oiIz0fEtoh4PCLe0ukPIUlSt2nmCPwA8LHMPBVYDlwZEacB1wAbM3MRsLF6DfBOYFH1WAXc1PaqJUnqcg0DPDN3Z+b3quXnga3AAmAlsK7qtg64qFpeCdyaNQ8DcyNiftsrlySpi03oGnhEnAycCTwCnJiZu6EW8sAJVbcFwM5Rmw1VbWP3tSoiBiNicHh4eOKVS5LUxZoO8Ih4NXA38EeZ+dPxutZpyyMaMtdm5kBmDvT19TVbhiRJoskAj4jZ1ML7y5n5r1XzMwdPjVfPe6r2IWDhqM37gV3tKVeSJEFzd6EHcDOwNTP/dtSq9cDl1fLlwD2j2t9X3Y2+HNh38FS7JElqj1lN9Hkb8F7g+xGxqWr7FPAZ4M6IuALYAVxSrbsPuBDYBrwAfKCtFUuSpMYBnpnfov51bYBz6vRP4MoW65IkSeNwJjZJkgpkgEuSVCADXJKkAhngkiQVyACXJKlABrgkSQUywCVJKpABLklSgQxwSZIKZIBLklQgA1ySpAIZ4JIkFcgAlySpQAa4JEkFMsAlSSqQAS5JUoEMcEmSCmSAS5JUIANckqQCGeCSJBXIAG/gxZGXZtR+JEkCmDXdBcx0vT1zOGnDJS3vZ8d5d7WhGkmSajwClySpQAa4JEkFMsAlSSqQAT5FvBlOktRODW9ii4hbgN8B9mTm4qrtOuD3gOGq26cy875q3SeBK4AR4A8z82sdqLs43gwnSWqnZo7AvwRcUKf9hsxcUj0OhvdpwGXA6dU2/xARPe0qVpIk1TQM8Mz8JvCTJve3Erg9M/dn5tPANmBZC/VJkqQ6WrkGflVEPB4Rt0TE66q2BcDOUX2GqrYjRMSqiBiMiMHh4eF6XSRJ0lFMNsBvAn4NWALsBj5XtUedvllvB5m5NjMHMnOgr69vkmVIktSdJhXgmflMZo5k5svAF/n/0+RDwMJRXfuBXa2VKEmSxppUgEfE/FEvLwY2V8vrgcsi4riIOAVYBHy7tRIlSdJYzXyN7CvAWcDxETEEfBo4KyKWUDs9vh34fYDM3BIRdwJPAAeAKzNzpDOlS5LUvRoGeGa+u07zzeP0vx64vpWiJEnS+JyJTZKkAhngkiQVyACXJKlABrgkSQUywCVJKpABLklSgQxwSZIKZIAX5sWRl47J/UiSJqbhRC6aWXp75nDShkta3s+O8+5qej979m4BqNt/x3l3tVyLJGniPAKXJKlABrgkSQUywCVJKpABLklSgQxwSZIKZIBLklQgA1ySpAIZ4JIkFcgAlySpQAa4JEkFMsDVEudUl6Tp4Vzoakk752aXJDXPI3BJkgpkgEuSVCADXJKkAhngkiQVyACXJKlABriOKX6tTVK3aPg1soi4BfgdYE9mLq7a5gF3ACcD24FLM3NvRATwd8CFwAvA+zPze50pXceSF0deordnTsv78WttkrpFM98D/xLw98Cto9quATZm5mci4prq9SeAdwKLqsdbgZuqZ2lcBq8kTUzDU+iZ+U3gJ2OaVwLrquV1wEWj2m/NmoeBuRExv13FSpKkmsleAz8xM3cDVM8nVO0LgJ2j+g1VbUeIiFURMRgRg8PDw5MsQ5Kk7tTum9iiTlvW65iZazNzIDMH+vr62lyGJEnHtskG+DMHT41Xz3uq9iFg4ah+/cCuyZcnSZLqmWyArwcur5YvB+4Z1f6+qFkO7Dt4ql2SJLVPM18j+wpwFnB8RAwBnwY+A9wZEVcAO4CDtw/fR+0rZNuofY3sAx2oWZKkrtcwwDPz3UdZdU6dvglc2WpRkiRpfM7EJklSgQxwSZIKZIBLklQgA1ySpAIZ4JIkFcgAlySpQAa4JEkFMsAlSSqQAS5JUoEMcEmSCmSAS3W8OPLSjNqPJI3VcC50qRv19szhpA2XNO7YwI7z7mpDNZJ0JI/AJUkqkAEuSVKBDHBJkgpkgEuSVCADXJKkAhngkiQVyACXJKlABrgkSQUywCVJKpABLnWQU7JK6hSnUpU6qF1Tsj55zpfbUE3tPwK9PXPasi9J08sAlwrg3OySxvIUuiRJBTLAJUkqUEun0CNiO/A8MAIcyMyBiJgH3AGcDGwHLs3Mva2VKUmSRmvHEfjZmbkkMweq19cAGzNzEbCxei1JktqoE6fQVwLrquV1wEUdeA9JkrpaqwGewIaI+G5ErKraTszM3QDV8wn1NoyIVRExGBGDw8PDLZYhSVJ3afVrZG/LzF0RcQLwQET8oNkNM3MtsBZgYGAgW6xDkqSu0tIReGbuqp73AP8GLAOeiYj5ANXznlaLlCRJh5t0gEfEqyLiNQeXgfOAzcB64PKq2+XAPa0WKUmSDtfKKfQTgX+LiIP7+ZfMvD8ivgPcGRFXADuA1qePkiRJh5l0gGfmj4HfqNP+LHBOK0VJkqTxORObJEkFMsAlSSqQAS5JUoEMcEmSCmSAS5JUIANckqQCGeBSF3lx5KVjcj9SN2p1LnRJBentmcNJG1qfW2nHeXe1bT+SJscjcEmSCmSAS5JUIANckqQCGeCSpo03w0mT501skqZNO2+qk7qNR+CSJBXIAJckqUAGuCRJBTLAJUkqkAEuSVKBDHBJkgpkgEuSVCADXJKkAhngkiQVyACXJKlABrik4rVzLnTnVVcpnAtdUvHaNac6OK+6yuERuCRJBepYgEfEBRHxw4jYFhHXdOp9JKmd/BWnU2OmjfNM208zOnIKPSJ6gBuBc4Eh4DsRsT4zn+jE+0lSu7TrdPyT53y5DdXUAqG3Z84xt5+ZNs4l/mrbTl0DXwZsy8wfA0TE7cBKwACX1BWO1YBqVz3tUmLwtkunAnwBsHPU6yHgrR16L0k6Zs20gJpp9XSzTgV41GnLwzpErAJWVS9/FhE/bHMNxwP/2+pOou5H6br9HA/8787zvzpT6il5P5P6uSzgc03Hfg6NZbvqaee+CttP0z+XhX2u6dhPW7JnjF+p19ipAB8CFo563Q/sGt0hM9cCazv0/kTEYGYOdGr/3cSxbB/Hsn0cy/ZxLNtnKseyU3ehfwdYFBGnRMQc4DJgfYfeS5KkrtORI/DMPBARVwFfA3qAWzJzSyfeS5KkbtSxmdgy8z7gvk7tvwkdOz3fhRzL9nEs28exbB/Hsn2mbCwjMxv3kiRJM4pTqUqSVKDiA7zRlK0RcVxE3FGtfyQiTp76KsvQxFj+SUQ8ERGPR8TGiKj71QY1P5VwRLwrIjIivAP4KJoZy4i4tPrZ3BIR/zLVNZaiib/jJ0XEgxHxaPX3/MLpqHOmi4hbImJPRGw+yvqIiM9X4/x4RLylI4VkZrEPajfI/Qj4VWAO8Bhw2pg+HwX+sVq+DLhjuuueiY8mx/Js4JXV8kccy8mPZdXvNcA3gYeBgemueyY+mvy5XAQ8Cryuen3CdNc9Ex9NjuVa4CPV8mnA9umueyY+gN8C3gJsPsr6C4H/oDYnynLgkU7UUfoR+KEpWzPzJeDglK2jrQTWVctfBc6JiPbN+nDsaDiWmflgZr5QvXyY2vf7daRmfi4B/gL4K+DFqSyuMM2M5e8BN2bmXoDM3DPFNZaimbFM4Jer5dcyZv4O1WTmN4GfjNNlJXBr1jwMzI2I+e2uo/QArzdl64Kj9cnMA8A+4PVTUl1ZmhnL0a6g9j9MHanhWEbEmcDCzLx3KgsrUDM/l28E3hgR/xURD0fEBVNWXVmaGcvrgN+NiCFq3yL6g6kp7Zgz0X9PJ6VjXyObIg2nbG2yjyYwThHxu8AA8Nsdrahc445lRLwCuAF4/1QVVLBmfi5nUTuNfha1s0L/GRGLM/O5DtdWmmbG8t3AlzLzcxHxm8Bt1Vi+3PnyjilTkjulH4E3nLJ1dJ+ImEXttNB4pz66VTNjSUS8A/hTYEVm7p+i2krTaCxfAywGHoqI7dSuka33Rra6mv07fk9m/iIznwZ+SC3QdbhmxvIK4E6AzPxvoJfaPOmamKb+PW1V6QHezJSt64HLq+V3Ad/I6i4DHabhWFanff+JWnh7nfHoxh3LzNyXmcdn5smZeTK1+wlWZObg9JQ7ozXzd/zfqd1gSUQcT+2U+o+ntMoyNDOWO4BzACLiVGoBPjylVR4b1gPvq+5GXw7sy8zd7X6Tok+h51GmbI2IPwcGM3M9cDO100DbqB15XzZ9Fc9cTY7lXwOvBu6q7gPckZkrpq3oGarJsVQTmhzLrwHnRcQTwAiwOjOfnb6qZ6Ymx/JjwBcj4o+pnfJ9vwc8R4qIr1C7ZHN8db/Ap4HZAJn5j9TuH7gQ2Aa8AHygI3X4ZyNJUnlKP4UuSVJXMsAlSSqQAS5JUoEMcEmSCmSAS5JUIANckqQCGeCSJBXIAJckqUD/BxgZOEKKaE0XAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 504x1800 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load score data\n",
    "test_scores = np.genfromtxt('model/k9_scores_test.csv', skip_header=0, delimiter=',', dtype=float)\n",
    "plot_scores = test_scores[:,2:]\n",
    "score_names = ['Hit Rate (10 Predictions)','R-Precision (# of Withheld Tracks)','R-Precision (# of Calibration Tracks)','NDCG (# of Withheld Tracks)','NDCG (# of Calibration Tracks)']\n",
    "model_name = 'K Centroid'\n",
    "set_name = 'Test'\n",
    "\n",
    "# Plot each score\n",
    "fig, ax = plt.subplots(5,1, figsize=(7,25))\n",
    "for i in range(plot_scores.shape[1]):\n",
    "    scores = plot_scores[:,i]\n",
    "    if i == 0:\n",
    "        bins = 10\n",
    "    else:\n",
    "        bins = None\n",
    "    sns.distplot(scores, kde=False, rug=False, hist_kws={'rwidth':1,'edgecolor':'white', 'alpha': 1}, bins=bins, ax=ax[i], color=\"#1db954\")\n",
    "    ax[i].axvline(np.mean(scores), label='Mean = {}'.format(round(np.mean(scores), 3)), color='k')\n",
    "    ax[i].legend()\n",
    "    ax[i].set_title(f'{score_names[i]} on the {set_name} Set, {model_name}')\n",
    "fig.tight_layout(rect=[0, 0.03, 1, 0.97])\n",
    "fig.suptitle(f'{model_name} Model Evaluation Metrics on the {set_name} Set', size='xx-large')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height:2pt\">\n",
    "\n",
    "## 2.5 k-NN User-Based Collaborative Filtering model "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.1 Preparation of Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Songs in withheld playlist that is in train_set: 66915\n",
      "Total songs in withheld playlist: 67463\n",
      "Percentage of coverage of songs: 0.99187702888991\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\royce\\Anaconda3\\envs\\cs109a\\lib\\site-packages\\ipykernel_launcher.py:34: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n"
     ]
    }
   ],
   "source": [
    "#Storing playlist file as dataframe (done in earlier section)\n",
    "# playlistfile = 'playlists.csv'\n",
    "# playlists = pd.read_csv(playlistfile)\n",
    "\n",
    "#Retrieving information on track features\n",
    "trackfile = 'data/songs_100000_feat_cleaned.csv'\n",
    "track_features = pd.read_csv(trackfile)\n",
    "\n",
    "track_features = track_features[['track_uri', 'track_name','artist_name']] \n",
    "\n",
    "#Obtain train set\n",
    "train_pids = np.genfromtxt('data/train_pids.csv', skip_header=1, dtype=int)\n",
    "train_set = select_playlists(playlists, train_pids)\n",
    "\n",
    "# Obtain test set and split into calibration and withheld\n",
    "test_pids = np.genfromtxt('data/test_pids.csv', skip_header=1, dtype=int)\n",
    "test_set = select_playlists(playlists, test_pids)\n",
    "calibration, withheld = train_test_split(test_set, test_size=0.3, random_state=21, stratify = test_set['pid'])\n",
    "\n",
    "# Checking to ensure that a significant proportion of songs in withheld list is in train set\n",
    "intersection = withheld[withheld['track_uri'].isin(train_set.track_uri)]\n",
    "print(\"Songs in withheld playlist that is in train_set:\", len(intersection))\n",
    "print (\"Total songs in withheld playlist:\", len(list(withheld.track_uri)))\n",
    "print (\"Percentage of coverage of songs:\", len(intersection)/len(list(withheld.track_uri)))\n",
    "\n",
    "#Appending calibration set to the train set, so that playlists in calibration set are part of the matrix\n",
    "combined_df = train_set.append(calibration)\n",
    "\n",
    "#Filtering the playlist information to only keep track_uri and pid information\n",
    "df_matrix = combined_df[['track_uri','pid']]\n",
    "\n",
    "#Count the number of times a track appears within a playlist and keep only the tracks that appear less than 10 times\n",
    "# I.e. If a song appears more than 10 times, the playlist would not be defined as a well-curated playlist \n",
    "df_matrix['Count']=df_matrix.groupby(['pid','track_uri'])['track_uri'].transform('count')\n",
    "df_matrix = df_matrix.drop_duplicates()\n",
    "df_matrix=df_matrix[df_matrix['Count']<=10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.2 Training the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NearestNeighbors(algorithm='auto', leaf_size=30, metric='cosine',\n",
       "                 metric_params=None, n_jobs=-1, n_neighbors=20, p=2,\n",
       "                 radius=1.0)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create Binary Sparse Matrix\n",
    "co_mat = pd.crosstab(df_matrix.pid, df_matrix.track_uri)\n",
    "co_mat = co_mat.clip(upper=1)\n",
    "co_mat_sparse = csr_matrix(co_mat)\n",
    "\n",
    "# Train kNN model\n",
    "model_knn = NearestNeighbors(metric='cosine', algorithm='auto', n_neighbors=20, n_jobs=-1)\n",
    "\n",
    "# Fit the sparse covariance matrix\n",
    "model_knn.fit(co_mat_sparse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "##Example of running make_recommendations on given playlist\n",
    "n_neighbors = 50\n",
    "pid = 176769\n",
    "withheld_set = withheld[withheld.pid == pid].track_uri\n",
    "\n",
    "pred_songs = make_recommendation(withheld, model_knn, pid, n_neighbors, 50)\n",
    "track_features[track_features['track_uri'].isin(pred_songs)]['track_name']\n",
    "df = pd.DataFrame(track_features[track_features['track_uri'].isin(pred_songs)]['track_name'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.3 Evaluating the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predicting songs based on n_neighbors, n_recommendations values \n",
    "n_neighbors = 50\n",
    "recc_no_k = [1, 7/3]\n",
    "rps_list = []\n",
    "ndcgs_list = []\n",
    "all_values = {}\n",
    "\n",
    "for recc_no in recc_no_k: \n",
    "    r_precision_scores = []\n",
    "    ndcgs = []\n",
    "    total_withheld = withheld['pid'].nunique()\n",
    "\n",
    "    #Loop through all unique playlists in test set to identify predicted songs\n",
    "    for index, pid in enumerate(withheld['pid'].drop_duplicates()): \n",
    "#         print (round(recc_no,2) , \"Playlist No: \", index + 1, \"/\", total_withheld)\n",
    "        withheld_set = withheld[withheld.pid == pid].track_uri\n",
    "        no_recommendations = int(len(withheld_set) * recc_no)\n",
    "        pred_songs = make_recommendation(withheld, model_knn, pid, n_neighbors, no_recommendations)\n",
    "        \n",
    "#         print(\"Predicted songs\\n\", track_features[track_features['track_uri'].isin(pred_songs)]['track_name'])\n",
    "#         print(\"Withheld songs\\n\", track_features[track_features['track_uri'].isin(withheld_set)]['track_name'])\n",
    "#         print(\"Overlapping songs\\n\", track_features[track_features['track_uri'].isin(withheld_set)&track_features['track_uri'].isin(pred_songs)]['track_name'])\n",
    "\n",
    "        #Calculate R precision score for playlist and append it to r_precision_scores list\n",
    "        rps = r_precision(list(pred_songs), withheld_set)\n",
    "        r_precision_scores.append(rps)\n",
    "\n",
    "        #Calculate NDCG for playlist and append it to ndcgs list\n",
    "        ndcg_playlist = ndcg(withheld_set, pred_songs)\n",
    "        ndcgs.append(ndcg_playlist)\n",
    "\n",
    "#         print(f'Playlist {pid}: The R precision score is {rps}')\n",
    "#         print(f'Playlist {pid}: The NDCGS metric is {ndcg_playlist}')\n",
    "    \n",
    "    all_values[f'RPS for {str(recc_no)} x k predictions'] = r_precision_scores\n",
    "    all_values[f'NDCGS for {str(recc_no)} x k predictions'] = ndcgs\n",
    "    rps_list.append(np.mean(r_precision_scores))\n",
    "    ndcgs_list.append(np.mean(ndcgs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predicting 10 songs using hit rate\n",
    "# Predicting songs based on n_neighbors, n_recommendations values \n",
    "#Loop through all unique playlists in test set to identify predicted songs\n",
    "\n",
    "hit_rate_tracking = []\n",
    "\n",
    "for index, pid in enumerate(withheld['pid'].drop_duplicates()): \n",
    "#     print (\"[Hit Rate] Playlist No: \", index + 1, \"/\", total_withheld)\n",
    "    withheld_set = withheld[withheld.pid == pid].track_uri\n",
    "    no_recommendations = len(withheld_set) * recc_no\n",
    "    pred_songs = make_recommendation(withheld, model_knn, pid, n_neighbors, 10)\n",
    "\n",
    "#     print(\"Predicted songs\\n\", track_features[track_features['track_uri'].isin(pred_songs)]['track_name'])\n",
    "#     print(\"Withheld songs\\n\", track_features[track_features['track_uri'].isin(withheld_set)]['track_name'])\n",
    "#     print(\"Overlapping songs\\n\", track_features[track_features['track_uri'].isin(withheld_set)&track_features['track_uri'].isin(pred_songs)]['track_name'])\n",
    "\n",
    "    #Calculate R precision score for playlist and append it to r_precision_scores list\n",
    "    hits = hit_rate(list(pred_songs), withheld_set)\n",
    "    hit_rate_tracking.append(hits)\n",
    "\n",
    "#     print(f'Playlist {pid}: The hit rate is {hits}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "rps_1k = all_values['RPS for 1 x k predictions']\n",
    "rps_2k = all_values['RPS for 2.3333333333333335 x k predictions']\n",
    "ncdgs_1k = all_values['NDCGS for 1 x k predictions']\n",
    "ncdgs_2k = all_values['NDCGS for 2.3333333333333335 x k predictions']\n",
    "plot_scores = np.c_[hit_rate_tracking, rps_1k, rps_2k, ncdgs_1k, ncdgs_2k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x1800 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load score data\n",
    "score_names = ['Hit Rate (10 Predictions)','R-Precision (# of Withheld Tracks)','R-Precision (# of Calibration Tracks)','NDCG (# of Withheld Tracks)','NDCG (# of Calibration Tracks)']\n",
    "model_name = 'k-NN Collaborative Filtering'\n",
    "set_name = 'Test'# Plot each score\n",
    "fig, ax = plt.subplots(5,1, figsize=(7,25))\n",
    "for i in range(plot_scores.shape[1]):\n",
    "    scores = plot_scores[:,i]\n",
    "    sns.distplot(scores, kde=False, rug=False, hist_kws={'rwidth':1,'edgecolor':'white', 'alpha': 1}, ax=ax[i], color=\"#F037A5\")\n",
    "    ax[i].axvline(np.mean(scores), label='Mean = {}'.format(round(np.mean(scores), 3)), color='k')\n",
    "    ax[i].legend()\n",
    "    ax[i].set_title(f'{score_names[i]} on the {set_name} Set, {model_name}')\n",
    "fig.tight_layout(rect=[0, 0.03, 1, 0.97])\n",
    "fig.suptitle(f'{model_name} Model Evaluation Metrics on the {set_name} Set', size='x-large')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}