morebikes-all-stations-training-comparison.ipynb

{"cells":[{"source":"<a href=\"https://www.kaggle.com/desmondrn/morebikes-all-stations-training-comparison?scriptVersionId=86083207\" target=\"_blank\"><img align=\"left\" alt=\"Kaggle\" title=\"Open in Kaggle\" src=\"https://kaggle.com/static/images/open-in-kaggle.svg\"></a>","metadata":{},"cell_type":"markdown","outputs":[],"execution_count":0},{"cell_type":"raw","id":"a8b49699","metadata":{"execution":{"iopub.execute_input":"2022-01-06T20:17:59.100099Z","iopub.status.busy":"2022-01-06T20:17:59.099745Z","iopub.status.idle":"2022-01-06T20:17:59.501619Z","shell.execute_reply":"2022-01-06T20:17:59.500525Z","shell.execute_reply.started":"2022-01-06T20:17:59.100067Z"},"papermill":{"duration":0.020988,"end_time":"2022-01-25T02:34:21.857595","exception":false,"start_time":"2022-01-25T02:34:21.836607","status":"completed"},"tags":[]},"source":["%reset -f"]},{"cell_type":"code","execution_count":1,"id":"ce9c3ac7","metadata":{"_cell_guid":"c8f36b41-d23f-472d-a58e-68c995677b22","_uuid":"87ee53ad-690f-4bf2-8afa-dc013f3be8e8","collapsed":false,"execution":{"iopub.execute_input":"2022-01-25T02:34:21.903923Z","iopub.status.busy":"2022-01-25T02:34:21.902662Z","iopub.status.idle":"2022-01-25T02:34:29.409495Z","shell.execute_reply":"2022-01-25T02:34:29.409998Z","shell.execute_reply.started":"2022-01-25T02:17:20.290301Z"},"jupyter":{"outputs_hidden":false},"papermill":{"duration":7.53061,"end_time":"2022-01-25T02:34:29.410313","exception":false,"start_time":"2022-01-25T02:34:21.879703","status":"completed"},"tags":[]},"outputs":[{"name":"stderr","output_type":"stream","text":["\n","User settings:\n","\n","   KMP_AFFINITY=granularity=fine,verbose,compact,1,0\n","   KMP_BLOCKTIME=0\n","   KMP_DUPLICATE_LIB_OK=True\n","   KMP_INIT_AT_FORK=FALSE\n","   KMP_SETTINGS=1\n","   KMP_WARNINGS=0\n","\n","Effective settings:\n","\n","   KMP_ABORT_DELAY=0\n","   KMP_ADAPTIVE_LOCK_PROPS='1,1024'\n","   KMP_ALIGN_ALLOC=64\n","   KMP_ALL_THREADPRIVATE=128\n","   KMP_ATOMIC_MODE=2\n","   KMP_BLOCKTIME=0\n","   KMP_CPUINFO_FILE: value is not defined\n","   KMP_DETERMINISTIC_REDUCTION=false\n","   KMP_DEVICE_THREAD_LIMIT=2147483647\n","   KMP_DISP_NUM_BUFFERS=7\n","   KMP_DUPLICATE_LIB_OK=true\n","   KMP_ENABLE_TASK_THROTTLING=true\n","   KMP_FORCE_REDUCTION: value is not defined\n","   KMP_FOREIGN_THREADS_THREADPRIVATE=true\n","   KMP_FORKJOIN_BARRIER='2,2'\n","   KMP_FORKJOIN_BARRIER_PATTERN='hyper,hyper'\n","   KMP_GTID_MODE=3\n","   KMP_HANDLE_SIGNALS=false\n","   KMP_HOT_TEAMS_MAX_LEVEL=1\n","   KMP_HOT_TEAMS_MODE=0\n","   KMP_INIT_AT_FORK=true\n","   KMP_LIBRARY=throughput\n","   KMP_LOCK_KIND=queuing\n","   KMP_MALLOC_POOL_INCR=1M\n","   KMP_NUM_LOCKS_IN_BLOCK=1\n","   KMP_PLAIN_BARRIER='2,2'\n","   KMP_PLAIN_BARRIER_PATTERN='hyper,hyper'\n","   KMP_REDUCTION_BARRIER='1,1'\n","   KMP_REDUCTION_BARRIER_PATTERN='hyper,hyper'\n","   KMP_SCHEDULE='static,balanced;guided,iterative'\n","   KMP_SETTINGS=true\n","   KMP_SPIN_BACKOFF_PARAMS='4096,100'\n","   KMP_STACKOFFSET=64\n","   KMP_STACKPAD=0\n","   KMP_STACKSIZE=8M\n","   KMP_STORAGE_MAP=false\n","   KMP_TASKING=2\n","   KMP_TASKLOOP_MIN_TASKS=0\n","   KMP_TASK_STEALING_CONSTRAINT=1\n","   KMP_TEAMS_THREAD_LIMIT=4\n","   KMP_TOPOLOGY_METHOD=all\n","   KMP_USE_YIELD=1\n","   KMP_VERSION=false\n","   KMP_WARNINGS=false\n","   OMP_AFFINITY_FORMAT='OMP: pid %P tid %i thread %n bound to OS proc set {%A}'\n","   OMP_ALLOCATOR=omp_default_mem_alloc\n","   OMP_CANCELLATION=false\n","   OMP_DEFAULT_DEVICE=0\n","   OMP_DISPLAY_AFFINITY=false\n","   OMP_DISPLAY_ENV=false\n","   OMP_DYNAMIC=false\n","   OMP_MAX_ACTIVE_LEVELS=1\n","   OMP_MAX_TASK_PRIORITY=0\n","   OMP_NESTED: deprecated; max-active-levels-var=1\n","   OMP_NUM_THREADS: value is not defined\n","   OMP_PLACES: value is not defined\n","   OMP_PROC_BIND='intel'\n","   OMP_SCHEDULE='static'\n","   OMP_STACKSIZE=8M\n","   OMP_TARGET_OFFLOAD=DEFAULT\n","   OMP_THREAD_LIMIT=2147483647\n","   OMP_WAIT_POLICY=PASSIVE\n","   KMP_AFFINITY='verbose,warnings,respect,granularity=fine,compact,1,0'\n","\n","2022-01-25 02:34:29.353455: I tensorflow/core/common_runtime/process_util.cc:146] Creating new thread pool with default inter op setting: 2. Tune using inter_op_parallelism_threads for best performance.\n"]}],"source":["%%capture\n","\n","import numpy as np \n","import pandas as pd\n","import seaborn as sns\n","import matplotlib.pyplot as plt\n","\n","from sklearn.preprocessing import StandardScaler\n","from sklearn.preprocessing import MinMaxScaler\n","\n","from sklearn.model_selection import train_test_split\n","\n","from sklearn.pipeline import Pipeline\n","from sklearn.preprocessing import PolynomialFeatures\n","from sklearn.linear_model import LinearRegression, Lasso, Ridge\n","from sklearn.neighbors import KNeighborsClassifier\n","from sklearn.linear_model import LogisticRegressionCV\n","from sklearn.tree import DecisionTreeClassifier\n","from sklearn.ensemble import RandomForestClassifier\n","from sklearn.ensemble import GradientBoostingClassifier\n","from sklearn.multiclass import OneVsRestClassifier\n","from sklearn.svm import LinearSVC\n","from sklearn.multiclass import OneVsOneClassifier\n","from sklearn.svm import SVC\n","from sklearn.linear_model import PoissonRegressor\n","\n","import joblib\n","\n","import tensorflow as tf\n","mae = tf.keras.losses.MeanAbsoluteError()\n","_ = mae([1], [2]) \n","\n","import os\n","\n","INPUT_DIR = '/kaggle/input/morebikes2021'\n","\n","FEATURE_SET = 'all'            ## Change features here\n","SHUFFLE_SAMPLES = False                    ## To shuffle the data\n","TRAIN_SIZE = 0.95                          ## To adjust train size"]},{"cell_type":"markdown","id":"30d2891a","metadata":{"papermill":{"duration":0.019408,"end_time":"2022-01-25T02:34:29.450582","exception":false,"start_time":"2022-01-25T02:34:29.431174","status":"completed"},"tags":[]},"source":["# Objective\n","\n","This notebook deals with Phase 1 of the Kaggle competition. First, we will build 75 different models for each station (a), then we will build one model for all stations at once (b). After that,  we will compare these two approaches and discus some variables that affect the learning process in both cases. Unless otherwise specified, the models will be trained using the `short_full_temp` feature set, and the training set will contain 95% of the available data. "]},{"cell_type":"markdown","id":"858cce06","metadata":{"papermill":{"duration":0.019684,"end_time":"2022-01-25T02:34:29.489925","exception":false,"start_time":"2022-01-25T02:34:29.470241","status":"completed"},"tags":[]},"source":["# Build all per-station models\n","\n","We laid out the justification for each envisioned machine learning algorithm in our previous notebook `MoreBikes - Analysis & Per-Station Training`."]},{"cell_type":"code","execution_count":2,"id":"dcaf003e","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:34:29.539889Z","iopub.status.busy":"2022-01-25T02:34:29.538797Z","iopub.status.idle":"2022-01-25T02:34:29.546403Z","shell.execute_reply":"2022-01-25T02:34:29.546998Z","shell.execute_reply.started":"2022-01-25T02:17:28.203101Z"},"papermill":{"duration":0.037614,"end_time":"2022-01-25T02:34:29.547176","exception":false,"start_time":"2022-01-25T02:34:29.509562","status":"completed"},"tags":[]},"outputs":[],"source":["def get_peters_features():\n","    short = ['bikes_3h_ago', 'short_profile_3h_diff_bikes', 'short_profile_bikes']\n","    short_temp = short + ['temperature.C']\n","    full = ['bikes_3h_ago', 'full_profile_3h_diff_bikes', 'full_profile_bikes']\n","    full_temp = full + ['temperature.C']\n","    short_full = ['bikes_3h_ago', 'short_profile_3h_diff_bikes', 'short_profile_bikes', 'full_profile_3h_diff_bikes', 'full_profile_bikes']\n","    short_full_temp = short_full + ['temperature.C']\n","    \n","    if FEATURE_SET=='short':\n","        return short\n","    elif FEATURE_SET=='short_temp':\n","        return short_temp\n","    elif FEATURE_SET=='full':\n","        return full\n","    elif FEATURE_SET=='full_temp':\n","        return full_temp\n","    elif FEATURE_SET=='short_full':\n","        return short_full\n","    elif FEATURE_SET=='short_full_temp':\n","        return short_full_temp\n","    else:\n","        return 'all'\n","\n","def get_train_path(station_id):\n","    return INPUT_DIR+'/Train/Train/station_'+str(station_id)+'_deploy.csv'\n","\n","def preprocess(df):\n","    df = df.drop(['weekday', 'latitude', 'longitude','year', 'month'], axis=1)\n","#     df = df.drop(['numDocks'], axis=1)\n","    df = df.drop(['station'], axis=1)\n","    df['timestamp'] = (df['timestamp'] - 1412114400) / 3600\n","    return df\n","\n","def select_peters_features(df):\n","    features_to_use = get_peters_features()\n","        \n","    if features_to_use == 'all':\n","        return df.dropna()\n","    else:\n","#         features_to_use += ['numDocks']         #### Remember to remove this !\n","        if 'bikes' in list(df.columns):\n","            features_to_use += ['bikes']\n","        return df[features_to_use].dropna()\n","    \n","def make_learning_data(station_id):\n","    df = pd.read_csv(get_train_path(station_id))\n","    \n","    df = preprocess(df)\n","#     df = df.sample(frac=1, random_state=12)\n","\n","    df = select_peters_features(df)\n","\n","    df_y = df['bikes']\n","    df_X = df.drop(['bikes'], axis=1)\n","\n","    return np.array(df_X), np.array(df_y)\n","\n","# df = make_learning_data(201)\n","# df"]},{"cell_type":"code","execution_count":3,"id":"8be04ca2","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:34:29.590833Z","iopub.status.busy":"2022-01-25T02:34:29.59012Z","iopub.status.idle":"2022-01-25T02:34:29.599155Z","shell.execute_reply":"2022-01-25T02:34:29.599776Z","shell.execute_reply.started":"2022-01-25T02:17:28.21881Z"},"papermill":{"duration":0.032904,"end_time":"2022-01-25T02:34:29.599953","exception":false,"start_time":"2022-01-25T02:34:29.567049","status":"completed"},"tags":[]},"outputs":[],"source":["def train_bikes_models(X_train, X_val, y_train, y_val, station_id=0):\n","    \"\"\"\n","    @station_id: id of the station we want to train\n","    returns the best model for this station\n","    \"\"\"\n","\n","    \"\"\" All models that will be trained and their scores \"\"\"\n","    potential_models = []\n","\n","    \"\"\"### Linear Regression\"\"\"\n","    \n","#     degrees = [1, 2, 3]\n","#     degrees = [1]\n","#     for i in range(len(degrees)):\n","#         scaled_features = StandardScaler()\n","#         polynomial_features = PolynomialFeatures(degree=degrees[i], include_bias=False)\n","#         linear_regression = Ridge()\n","#         pipeline = Pipeline(\n","#             [\n","#                 (\"scaled_features\", scaled_features),\n","#                 (\"polynomial_features\", polynomial_features),\n","#                 (\"linear_regression\", linear_regression),\n","#             ]\n","#         )\n","#         pipeline.fit(X_train, y_train)\n","#         y_pred = np.rint(pipeline.predict(X_val))\n","#         potential_models.append(('linear_reg_'+str(degrees[i]), pipeline, mae(y_val, y_pred).numpy()))\n","\n","    \"\"\"### K-Nearest Neighbors\"\"\"\n","\n","#     KNN = KNeighborsClassifier(n_neighbors=2)\n","#     KNN.fit(X_train, y_train)\n","#     y_pred = KNN.predict(X_val)\n","#     potential_models.append(('knn', KNN, mae(y_val, y_pred).numpy()))\n","\n","    \"\"\"### Decision Tree\"\"\"\n","\n","#     DcTree = Pipeline([(\"minmax_scaler\", MinMaxScaler()), (\"decision_tree\", DecisionTreeClassifier(random_state=12))])\n","#     DcTree.fit(X_train, y_train)\n","#     y_pred = DcTree.predict(X_val)\n","#     potential_models.append(('decision_tree', DcTree, mae(y_val, y_pred).numpy()))\n","\n","    \"\"\"### Random Forest\"\"\"\n","\n","#     RdFor = Pipeline([(\"minmax_scaler\", MinMaxScaler()), (\"random_forest\", RandomForestClassifier(n_estimators=1000, max_leaf_nodes=None, n_jobs=-1, random_state=12))])\n","#     RdFor.fit(X_train, y_train)\n","#     y_pred = RdFor.predict(X_val)\n","#     potential_models.append(('random_forest', RdFor, mae(y_val, y_pred).numpy()))\n","\n","    \"\"\"### Gradient Boosting\"\"\"\n","    GdBoost = Pipeline([(\"minmax_scaler\", MinMaxScaler()), (\"grad_boost\", GradientBoostingClassifier(n_estimators=100, random_state=12))])\n","    GdBoost.fit(X_train, y_train)\n","    y_pred = GdBoost.predict(X_val)\n","    potential_models.append(('grad_boost', GdBoost, mae(y_val, y_pred).numpy()))\n","\n","    \"\"\"### SVM - One vs. Rest\"\"\"\n","\n","#     SVM1 = Pipeline([(\"minmax_scaler\", MinMaxScaler()), (\"svm_ovr\", OneVsRestClassifier(LinearSVC(random_state=12)))])\n","#     SVM1.fit(X_train, y_train)\n","#     y_pred = SVM1.predict(X_val)\n","#     potential_models.append(('svm_ovr', SVM1, mae(y_val, y_pred).numpy()))\n","\n","    \"\"\"### SVM - One vs. One\"\"\"\n","\n","#     SVM2 = Pipeline([(\"minmax_scaler\", MinMaxScaler()), (\"svm_ovo\", OneVsOneClassifier(SVC(random_state=12)))])\n","#     SVM2.fit(X_train, y_train)\n","#     y_pred = SVM2.predict(X_val)\n","#     potential_models.append(('svm_ovo', SVM2, mae(y_val, y_pred).numpy()))\n","    \n","    \"\"\"### Poisson Regression \"\"\"\n","\n","#     Poisreg = Pipeline([(\"minmax_scaler\", MinMaxScaler()), (\"pois_reg\", PoissonRegressor())])\n","#     Poisreg.fit(X_train, y_train)\n","#     y_pred = Poisreg.predict(X_val)\n","#     potential_models.append(('pois_reg', Poisreg, mae(y_val, y_pred).numpy()))\n","\n","    \"\"\"## Sort the models and pick the best\"\"\"\n","    potential_models = sorted(potential_models, key=lambda el:el[2])\n","   \n","    return potential_models[0]"]},{"cell_type":"code","execution_count":4,"id":"a5b03e52","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:34:29.643317Z","iopub.status.busy":"2022-01-25T02:34:29.642297Z","iopub.status.idle":"2022-01-25T02:34:29.646176Z","shell.execute_reply":"2022-01-25T02:34:29.646758Z","shell.execute_reply.started":"2022-01-25T02:17:28.246377Z"},"papermill":{"duration":0.027187,"end_time":"2022-01-25T02:34:29.646935","exception":false,"start_time":"2022-01-25T02:34:29.619748","status":"completed"},"tags":[]},"outputs":[],"source":["## All our models will be stored in this dictionnary\n","# per_station_models = {}\n","\n","# for station_id in range(201, 276):\n","#     X, y = make_learning_data(station_id)\n","#     X_train, X_val, y_train, y_val = train_test_split(X, y, shuffle=SHUFFLE_SAMPLES, train_size=TRAIN_SIZE)\n","#     per_station_models[station_id] = train_bikes_models(X_train, X_val, y_train, y_val)[1]\n","    \n","# per_station_models"]},{"cell_type":"markdown","id":"129d45f6","metadata":{"papermill":{"duration":0.01923,"end_time":"2022-01-25T02:34:29.685875","exception":false,"start_time":"2022-01-25T02:34:29.666645","status":"completed"},"tags":[]},"source":["# Train and predict for all stations together\n","\n","Now, we will train a single model for all the stations together. The data for this learning task is collected such that 5% of each station's data is left for validation. If the data is not shuffle before splitting, then this 5% corresponds to the last 2 days of the month. We will see below that shuffling the data (or not) has a huge effect on the results."]},{"cell_type":"code","execution_count":5,"id":"5b6320d9","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:34:29.737832Z","iopub.status.busy":"2022-01-25T02:34:29.737142Z","iopub.status.idle":"2022-01-25T02:34:31.040792Z","shell.execute_reply":"2022-01-25T02:34:31.040156Z","shell.execute_reply.started":"2022-01-25T02:17:28.262872Z"},"papermill":{"duration":1.332297,"end_time":"2022-01-25T02:34:31.040947","exception":false,"start_time":"2022-01-25T02:34:29.70865","status":"completed"},"tags":[]},"outputs":[],"source":["## Collect learning data (and the stations they comme from)\n","\n","X, y = make_learning_data(201) \n","X_train, X_val, y_train, y_val = train_test_split(X, y, shuffle=SHUFFLE_SAMPLES, train_size=TRAIN_SIZE)\n","stations = [201]*len(y_val)\n"," \n","for station_id in range(202, 276):\n","    X_, y_ = make_learning_data(station_id) \n","    X_train_, X_val_, y_train_, y_val_ = train_test_split(X_, y_, shuffle=SHUFFLE_SAMPLES, train_size=TRAIN_SIZE)\n","    \n","    X_train = np.vstack([X_train, X_train_])\n","    X_val = np.vstack([X_val, X_val_])    \n","    y_train = np.concatenate([y_train, y_train_])    \n","    y_val = np.concatenate([y_val, y_val_])\n","    \n","    stations += [station_id]*len(y_val_)"]},{"cell_type":"code","execution_count":6,"id":"64a4097d","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:34:31.086667Z","iopub.status.busy":"2022-01-25T02:34:31.085657Z","iopub.status.idle":"2022-01-25T02:34:31.091881Z","shell.execute_reply":"2022-01-25T02:34:31.092359Z","shell.execute_reply.started":"2022-01-25T02:17:29.893517Z"},"papermill":{"duration":0.030546,"end_time":"2022-01-25T02:34:31.092562","exception":false,"start_time":"2022-01-25T02:34:31.062016","status":"completed"},"tags":[]},"outputs":[],"source":["## Save this data for later testing in Phases 2 and 3\n","np.save('X_val.npy', X_val)\n","np.save('y_val.npy', y_val)\n","np.save('stations_val.npy', np.array(stations))"]},{"cell_type":"code","execution_count":7,"id":"9f2529dd","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:34:31.135802Z","iopub.status.busy":"2022-01-25T02:34:31.134808Z","iopub.status.idle":"2022-01-25T02:34:31.141394Z","shell.execute_reply":"2022-01-25T02:34:31.142249Z","shell.execute_reply.started":"2022-01-25T02:17:29.902989Z"},"papermill":{"duration":0.030177,"end_time":"2022-01-25T02:34:31.142492","exception":false,"start_time":"2022-01-25T02:34:31.112315","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Shape of the data for all stations together:\n"," - train: (40425, 18) (40425,)\n"," - val:   (2175, 18) (2175,)\n"," - stations for each example: 2175\n"]}],"source":["## Shapes\n","print(\"Shape of the data for all stations together:\")\n","print(\" - train:\", X_train.shape, y_train.shape)\n","print(\" - val:  \", X_val.shape, y_val.shape)\n","\n","print(\" - stations for each example:\", len(stations))"]},{"cell_type":"code","execution_count":8,"id":"8f5b1ed6","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:34:31.189996Z","iopub.status.busy":"2022-01-25T02:34:31.189056Z","iopub.status.idle":"2022-01-25T02:42:46.275372Z","shell.execute_reply":"2022-01-25T02:42:46.275916Z","shell.execute_reply.started":"2022-01-25T02:17:29.915542Z"},"papermill":{"duration":495.112548,"end_time":"2022-01-25T02:42:46.276101","exception":false,"start_time":"2022-01-25T02:34:31.163553","status":"completed"},"tags":[]},"outputs":[{"data":{"text/plain":["Pipeline(steps=[('minmax_scaler', MinMaxScaler()),\n","                ('grad_boost', GradientBoostingClassifier(random_state=12))])"]},"execution_count":8,"metadata":{},"output_type":"execute_result"}],"source":["model_name, all_stations_model = train_bikes_models(X_train, X_val, y_train, y_val)[:2]\n","all_stations_model"]},{"cell_type":"code","execution_count":9,"id":"f90c8708","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:42:46.325372Z","iopub.status.busy":"2022-01-25T02:42:46.324705Z","iopub.status.idle":"2022-01-25T02:42:46.716678Z","shell.execute_reply":"2022-01-25T02:42:46.716055Z","shell.execute_reply.started":"2022-01-25T02:25:50.84667Z"},"papermill":{"duration":0.420358,"end_time":"2022-01-25T02:42:46.716815","exception":false,"start_time":"2022-01-25T02:42:46.296457","status":"completed"},"tags":[]},"outputs":[{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAABBwAAAFcCAYAAABr+63OAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAB+UElEQVR4nO3debwcVZ3//9enl4QISCRElJAxgCZcQBJiCEGMIMwQMQgKomJ+SsRlcGa+OosZEVHQAWQmfB2XcWSYUUEGHRAQGEDjwmIEQwhJWC+JLOEbLltYwhq4t2+f3x9V3be7b3V3dXdVd3X3+/l4QO7trq761DmnTlWfW3U+5pxDRERERERERCRKqU4HICIiIiIiIiK9RwMOIiIiIiIiIhI5DTiIiIiIiIiISOQ04CAiIiIiIiIikdOAg4iIiIiIiIhETgMOIiIiIiIiIhI5DTiIiIi0iZktNbM/hFz2QjM7q8b7U83sfjObFF2ENeMJFbuZOTN7aztiqhHDFWZ2VJ1lPmdmT5rZS2Y2JeZ4ysquU2VkZkvM7Nft3q6IiPQvDTiIiEji+V/Y7jazV8zsCTP7gZlN7nRcHXYqcKFzblunA+kkMzvTzP674uV/BmoN1mSBbwFHOud2cM49E2eMUWhksMpffoY/sJEpvOacu8Q5d2Q8EYqIiIynAQcREUk0M/sHvC+Qy4CdgAXAW4DfmNmETsbWKWY2ETgJqPyiHfbzmfpLdS/n3Grg9WY2r8oiuwLbAfc2um7z6PpJREQkBJ0wRUQksczs9cDXgf/jnPuVc27EObcJ+DAwA/j//OXONLPLzOwnZvaimd1b+mXTzHbzb7PfYmYPm9nna2zzQjP7dzP7pX+7/S1m9iYz+7aZPec/xnBAyfIDZnaTmW31t3tMyXtTzOwaM3vBzFYDe1Vsa28z+42ZPWtmG8zswyGL5iBgq3Pu0ZJ17WFmv/f3/7dm9v3CX/5L/tr9KTP7f8AN/us/9+8Yed7/7L5hY6/jfWb2kJk9bWbLC1/QzSxlZqeb2SNm9pRfXzuVbPMYvwy3+mU6UPLel8xsyN+/DWZ2hJm9FzgN+IhfV3eWxHATsLgyMDObCWzwf91qZoWyeKeZ3e6Xxe1m9s6Sz9xkZmeb2S3AK8CeAes91cwe9OO7z8w+2EB5la5nqV92L/ptdYlfDucDB/v7udVfdrGZrfPraLOZnVmyqt+X7ONLZnZw5V0SIfb5n/z2/6KZ/drMdvHf287M/tvMnvHr6nYz27WZ/RURkd6mAQcREUmyd+L9JfrK0hedcy8B1wN/UfLyMcD/AJOBa4B/A+9LLvC/wJ3ANOAI4G/NbFGN7X4YOB3YBXgN+COw1v/9crzb8Qu35v8v8GvgjcD/AS4xs1n+er4PvAq8GTjZ/w//s9sDvwF+6n/2o8C/m9k+Icrl7Yx9aS74KbAamAKcCXw84HOHAgNAYd9/CbzN3/5a4JKSZavGHsIHgXnAXODYks8u9f97D96X9h0Yq6eZwM+AvwWm4tXv/5rZBL88/wY40Dm3ox//Jufcr4BzgEv9RyNml8QwCJT+DoBzbiNQGFiZ7Jw73Mx2Bq4DvotXft8CrrPyuR0+DnwW2BF4JGCfHwQW4t2F83Xgv83szfUKqpTfJr4LHOXv5zuB9c65QeAU4I/+fk72P/Iy8Am8Nr8Y+JyZfcB/790l+7iDc+6PFdsKs88fAz6J1z4mAF/0Xz/J38/p/mdPAfr60R4REQmmAQcREUmyXYCnnXO5gPce998v+INz7nrn3ChwMWNfNg8EpjrnvuGcG3bOPQT8J94X/Gp+4Zy7wzn3KvAL4FXn3E/8dV8KFO5wWID3pflcf903ANcCJ5pZGjge+Jpz7mXn3D3ARSXbOBrvS/OPnXM559w64ArghBDlMhl4sfCLmf2Zv59f8+P4A96gS6Uz/Vi2ATjnfuSce9E59xreIMVsM9spROz1/LNz7lnn3P8Dvg2c6L++BPiWc+4hf9Doy8BHzXvE4yPAdc653zjnRoDzgEl4X7pHgYnAPmaWdc5tcs49WCeGF/1yCmMx8Cfn3MV+XfwMuB94f8kyFzrn7vXfH6lcgXPu5865x5xzeefcpcCfgPkht18qD+xnZpOcc48756o+9uGcu8k5d7e/zbvwBmwODbmdMPv8Y+fcRr+9XAbM8V8fwRtoeKtzbtQ/Vl5obDdFRKQfaMBBRESS7GlgFwuec+DN/vsFT5T8/Aqwnf+5twC7+bd+b/VvRz8N7zn+ap4s+XlbwO87+D/vBmx2zuVL3n8E706KqUAG2FzxXsFbgIMq4loCvKlGXAXP4f2lvWA34Fnn3Cslr21mvOJrZpY2s3P9xwBeADb5b+0SIvZ6Kj+3W0mcj1S8l8Gri7L3/DLdDExzzj2Ad+fDmcBTZvY/ZrYbte0IbA0Zb2VchdimlfweVJ5FZvYJM1tfUpf7UT4gVpdz7mW8gZdTgMfN7Doz27vGNg8ysxvNe1Toef9zYbcZZp8rj6lCu78YWAH8j5k9Zmb/4t/tIyIiUkYDDiIikmR/xHuk4bjSF81sB+Ao4Hch1rEZeNg5N7nkvx2dc++LIL7HgOlWPongnwFDwBYgh3fbeel7pXHdXBHXDs65z4XY7l3AzJLfHwd2NrPXlbw2nfFcyc8fw3vc4c/xbo+f4b9uIWKvp/Jzj/k/P4Y30FL6Xg5vQKfsPTMzfz1DAM65nzrn3uUv4/AmEq3cp1IDeI/RhFEZVyG2oZLfq20HM3sL3l0zfwNM8R95uAevLBvinFvhnPsLvAG1+/31Vtv+T/HuZJnunNsJb54Hq7F8qTD7XC3GEefc151z++DdgXI03qMdIiIiZTTgICIiieWcex7vefjvmdl7zSxrZjPwbu9+FO8vrfWsBl70Jx2c5P9lfz8zOzCCEG/D+8vvP/qxHYZ3S/r/+I9fXAmcaWav8+dmOKnks9cCM83s4/5ns2Z2oJVMlFhnnyab2TQA59wjwBp/WxPM7GDKb40PsiPeYM4zwOvw5kLAX1+92OtZZmZvMLPpwBfwHkMB75b/vzNvgssdGJt/IYdXp4vNmwwyC/yDH9+tZjbLzA43LzvHq3h3mRTuKnkSmGHjM0ccijdHRRjX49XFx8wsY2YfAfbBq6Mwtsf7gr8FwMw+iXeHQ0PMbFczO9afy+E14CXK93N3K8/MsiPenS2vmtl8vEGkgi3+Z8dNcOlrep/N7D1m9nb/0ZsX8B6xyNf5mIiI9CENOIiISKI55/4F7xGI8/C+3NyGd3fAEf7cA/U+P4r3F9g5wMN4j2H8F95f9VuNbRjvi/1R/nr/HfiEc+5+f5G/wbsN/QngQuDHJZ99ETgSby6Jx/xl/hlvroIw270QP0uHbwlwMN4Awll4X/Jrlc9P8G6hHwLuA1ZVvF819hCuBu4A1uNNTPhD//Uf4Q0S/R6vLl7Fm2gT59wGf3++h1eW7wfe7+/rROBc//Un8CYx/LK/zp/7/z5jZmsB/MGkl/z0mHU5557BayP/gFd+/wgc7Zx7uuYHxz5/H/B/8e7IeRJvUs9bwny2Qgr4e7z28CzeoEnhjpcb8NJ4PmFmhbj+CviGmb0IfA1v0KYQ0yvA2cAt/mMeCypibmWf34Q3eeoLeJNz3ky4wT8REekz5ly9O+5EREQkacxsKrASOKAwCWTF+5cC9zvnzmh7cB1mZlcAP3TOXd/pWERERPqZBhxERER6gP9X/Wfx7hw4ErgKONjPfiEiIiLSdkGzfouIiEj3eRPevAtT8Oa3+Fwcgw1mtpAqcyM453YIel1ERET6k+5wEBEREREREZHIadJIEREREREREYmcBhxEREREREREJHIacBAREekTZrbJzIbNbJeK19eZmTOzGRWvn+m/flDF60vNbNTMXqr4b7cIY51pZleb2RYze9bMVpjZrBrLT/OXf9bMHjWzUyref7+Z3ePHeauZ7RNVrCIiIhJMAw4iIiL95WHgxMIvZvZ24HWVC5mZAZ/Ay3zxiYD1/NE5t0PFf49FGOdk4BpgFrArsBq4usby/423b7sCi4FzzOw9AGb2NuAS4BR/vf8LXGNmmjxbREQkRhpwEBER6S8XUz6AcBLwk4DlFgJvBj4PfNTMJrQhtiLn3Grn3A+dc88650aAfwVmmdmUymXNbAfgMOBs59yIc+5O4HLgZH+RRcBK59wfnHM54J+BacCh7dgXERGRfqUBBxERkf6yCni9mQ2YWRr4KN7dAZVOwrsT4DL/9/c3u0Ezu8vMtlb5799DrubdwBPOuWeCNlHxb+Hn/QKWKfxc+b6IiIhETAMOIiIi/adwl8NfAIPAUOmbZvY64ATgp/7dBZcz/rGKBRUDBw9W25hzbn/n3OQq//1VvWDNbHfg+8DfV1n/i8AtwFfNbDszmwscz9ijIr8FDjWzw/w7NU4DJhDwKImIiIhER88uioiI9J+Lgd8DexD8OMUHgRxwvf/7JcBvzWyqc26L/9oq59y74g7UzKYCvwb+3Tn3sxqLLsEblNgMPIR318a+AM65+83sJODf8B4T+W/gPuDRGEMXERHpe7rDQUREpM845x7Bm2DxfcCVAYucBOwA/D8zewL4OZAFPtbM9szs3oCMFoX/zq/xuTfgDTZc45w7u94+OeeOds5Ndc4dBOyCN9Fk4f3LnXP7OeemAGcAM4Dbm9kfERERCUd3OIiIiPSnTwFvcM69XJqtwcymAUcARwF3lSz/t3iPVXyn0Q055/Zt9DNm9npgBXCLc+7UEMsP4N2x8BrwYeBIYKDk/XcA64Gd8e6EuMY5d3+jcYmIiEh4usNBRESkDznnHnTOrQl46+PAeufcr51zTxT+A74L7G9mhYkWDw64W+HACEP8IHAg8MmKbfwZgJktMbN7S5ZfhPcoxXN46S/fW/L4B3gDJVuBDf4yn4kwVhEREQlgzrlOxyAiIiIiIiIiPUZ3OIiIiIiIiIhI5DTgICIiIiIiIiKR04CDiIiIiIiIiEROAw4iIiIiIiIiEjkNOIiIiIiIiIhI5DL1F+m8XXbZxc2YMaPTYYiIiIiIiIhIiTvuuONp59zUoPe6YsBhxowZrFkTlCpcRERERERERDrFzB6p9p4eqRARERERERGRyGnAQUREREREREQipwEHEREREREREYlcV8zhICIiIiIiIlJqZGSERx99lFdffbXTofSF7bbbjt13351sNhv6MxpwEBERERERka7z6KOPsuOOOzJjxgzMrNPh9DTnHM888wyPPvooe+yxR+jP6ZEKERERERER6TqvvvoqU6ZM0WBDG5gZU6ZMafhuEg04iIiIiIiISFfSYEP7NFPWeqRCREQS4ap1QyxfsYHHtm5jt8mTWLZoFh84YFqnwxIREREJ9Mwzz3DEEUcA8MQTT5BOp5k6dSoAq1evZsKECW2P6bDDDuO8885j3rx5bd92EA04iIhIx121bogvX3k320ZGARjauo0vX3k3gAYdREREJJGmTJnC+vXrATjzzDPZYYcd+OIXv1h8P5fLkcn091duPVIhIiIdt3zFhuJgQ8G2kVGWr9jQoYhERESk11y1bohDzr2BPU69jkPOvYGr1g1Fvo2lS5dyyimncNBBB/GP//iPnHnmmZx33nnF9/fbbz82bdoEwH//938zf/585syZw1/+5V8yOlp+LfSrX/2KE044ofj7TTfdxNFHHw3A5z73OebNm8e+++7LGWecERjLDjvsUPz58ssvZ+nSpQBs2bKF448/ngMPPJADDzyQW265BYCbb76ZOXPmMGfOHA444ABefPHFlstDAw4iItJxj23d1tDrIiIiIo0o3E05tHUbjrG7KeMYdHj00Ue59dZb+da3vlV1mcHBQS699FJuueUW1q9fTzqd5pJLLilb5s///M+57bbbePnllwG49NJL+ehHPwrA2WefzZo1a7jrrru4+eabueuuu0LH94UvfIG/+7u/4/bbb+eKK67g05/+NADnnXce3//+91m/fj0rV65k0qRJje76OP19f4eIiCTCbpMnMRQwuLDb5NZPdCIiIiK17qaM+vHNE044gXQ6XXOZ3/3ud9xxxx0ceOCBXizbtvHGN76xbJlMJsN73/te/vd//5cPfehDXHfddfzLv/wLAJdddhkXXHABuVyOxx9/nPvuu4/9998/VHy//e1vue+++4q/v/DCC7z00ksccsgh/P3f/z1LlizhuOOOY/fdd29ktwNpwEFERDpu2aJZZXM4AEzKplm2aFYHoxIREZFe0c67Kbfffvviz5lMhnw+X/y9kFbSOcdJJ53EN7/5zZrr+uhHP8q//du/sfPOOzNv3jx23HFHHn74Yc477zxuv/123vCGN7B06dLAdJWlWSVK38/n86xatYrtttuubPlTTz2VxYsXc/3113PIIYewYsUK9t5778Z2voIeqRARkY77wAHT+OZxb2fa5EkYMG3yJL553Ns1YaSIiIhEotpdk3HfTTljxgzWrl0LwNq1a3n44YcBOOKII7j88st56qmnAHj22Wd55JFHxn3+0EMPZe3atfznf/5n8XGKF154ge23356ddtqJJ598kl/+8peB2951110ZHBwkn8/zi1/8ovj6kUceyfe+973i74WJLx988EHe/va386UvfYkDDzyQ+++/v+X91x0OIiKSCB84YJoGGERERCQWnbqb8vjjj+cnP/kJ++67LwcddBAzZ84EYJ999uGss87iyCOPJJ/Pk81m+f73v89b3vKWss+n02mOPvpoLrzwQi666CIAZs+ezQEHHMDee+/N9OnTOeSQQwK3fe6553L00UczdepU5s2bx0svvQTAd7/7Xf76r/+a/fffn1wux7vf/W7OP/98vv3tb3PjjTeSSqXYd999Oeqoo1ref3POtbySuM2bN8+tWbOm02GIiIiIiIhIQgwODjIwMBB6+avWDbF8xQYe27qN3SZPYtmiWfpjR4OCytzM7nDOzQtaXnc4iIiIiIiISM/T3ZTtpzkcRERERERERCRyGnAQERERERERkchpwEFEREREREREIqcBBxERERERERGJnAYcRERERERERCRyGnAQERERERERaUI6nWbOnDnst99+nHDCCbzyyitNr2vp0qVcfvnlAHz605/mvvvuq7rsTTfdxK233lr8/fzzz+cnP/lJ09uOiwYcRERERERERJowadIk1q9fzz333MOECRM4//zzy97P5XJNrfe//uu/2Geffaq+XzngcMopp/CJT3yiqW3FSQMOIiIiIiIiIi1auHAhDzzwADfddBMLFy7kmGOOYZ999mF0dJRly5Zx4IEHsv/++/Mf//EfADjn+Ju/+RtmzZrFn//5n/PUU08V13XYYYexZs0aAH71q18xd+5cZs+ezRFHHMGmTZs4//zz+dd//VfmzJnDypUrOfPMMznvvPMAWL9+PQsWLGD//ffngx/8IM8991xxnV/60peYP38+M2fOZOXKlQDce++9zJ8/nzlz5rD//vvzpz/9KbIyyUS2JhEREREREZEk27waNq2EGQth+vzIVpvL5fjlL3/Je9/7XgDWrl3LPffcwx577MEFF1zATjvtxO23385rr73GIYccwpFHHsm6devYsGED9913H08++ST77LMPJ598ctl6t2zZwmc+8xl+//vfs8cee/Dss8+y8847c8opp7DDDjvwxS9+EYDf/e53xc984hOf4Hvf+x6HHnooX/va1/j617/Ot7/97WKcq1ev5vrrr+frX/86v/3tbzn//PP5whe+wJIlSxgeHmZ0dDSyctGAg4iIiIiIiPS+zavhomNgdBjSE+Cka1oedNi2bRtz5swBvDscPvWpT3Hrrbcyf/589thjDwB+/etfc9dddxXnZ3j++ef505/+xO9//3tOPPFE0uk0u+22G4cffvi49a9atYp3v/vdxXXtvPPONeN5/vnn2bp1K4ceeigAJ510EieccELx/eOOOw6Ad7zjHWzatAmAgw8+mLPPPptHH32U4447jre97W3NF0gFDTiIiIiIiIhI79u00htscKPev5tWtjzgUJjDodL2229f/Nk5x/e+9z0WLVpUtsz111/f0rabMXHiRMCb7LIwv8THPvYxDjroIK677jre97738R//8R+Bgx/N0BwOIiIiIiIi0vtmLPTubLC09++MhW3Z7KJFi/jBD37AyMgIABs3buTll1/m3e9+N5deeimjo6M8/vjj3HjjjeM+u2DBAn7/+9/z8MMPA/Dss88CsOOOO/Liiy+OW36nnXbiDW94Q3F+hosvvrh4t0M1Dz30EHvuuSef//znOfbYY7nrrrta2t9Ssd3hYGbbAb8HJvrbudw5d4aZ7QH8DzAFuAP4uHNuOK44RERERERERJg+33uMIoY5HGr59Kc/zaZNm5g7dy7OOaZOncpVV13FBz/4QW644Qb22Wcf/uzP/oyDDz543GenTp3KBRdcwHHHHUc+n+eNb3wjv/nNb3j/+9/Phz70Ia6++mq+973vlX3moosu4pRTTuGVV15hzz335Mc//nHN+C677DIuvvhistksb3rTmzjttNMi23dzzkW2srIVmxmwvXPuJTPLAn8AvgD8PXClc+5/zOx84E7n3A9qrWvevHmuMEOniIj0rqvWDbF8xQYe27qN3SZPYtmiWXzggGmdDktEREQSaHBwkIGBgU6H0VeCytzM7nDOzQtaPrZHKpznJf/XrP+fAw4HLvdfvwj4QFwxiIhI97hq3RBfvvJuhrZuwwFDW7fx5Svv5qp1Q50OTURERESaEOscDmaWNrP1wFPAb4AHga3OuZy/yKOA/nQlIiIsX7GBbSPlaZi2jYyyfMWGDkUkIiIiIq2IdcDBOTfqnJsD7A7MB/YO+1kz+6yZrTGzNVu2bIkrRBERSYjHtm5r6HURERERSba2ZKlwzm0FbgQOBiabWWGyyt2BwHtlnXMXOOfmOefmTZ06tR1hiohIB+02eVJDr4uIiIjENSehjNdMWcc24GBmU81ssv/zJOAvgEG8gYcP+YudBFwdVwwiItI9li2axaRsuuy1Sdk0yxbN6lBEIiIikmTbbbcdzzzzjAYd2sA5xzPPPMN2223X0OdiS4sJvBm4yMzSeAMblznnrjWz+4D/MbOzgHXAD2OMQUREukQhG4WyVIiIiEgYu+++O48++ih6BL89tttuO3bfffeGPhPbgINz7i7ggIDXH8Kbz0FERESpMEVERKQp2WyWPfbYo9NhSA1x3uEgIiJSUyEVZiE7RSEVJqBBBxEREZEu15ZJI0VERIIoFaaIiIhI79KAg4iIdIxSYYqIiIj0Lg04iIhIxygVpoiIiEjv0oCDiIh0jFJhioiIiPQuTRopIiIdo1SYIiIiIr1LAw4iItJRHzhgmgYYRERERHqQHqkQERERERERkchpwEFEREREREREIqcBBxERERERERGJnAYcRERERERERCRyGnAQERERERERkchpwEFEREREREREIqcBBxERERERERGJnAYcRERERERERCRyGnAQERERERERkchpwEFEREREREREIqcBBxERERERERGJnAYcRERERERERCRyGnAQERERERERkchpwEFEREREREREIqcBBxERERERERGJXKbTAYiISP+6at0Qy1ds4LGt29ht8iSWLZrFBw6Y1umwRERERCQCGnAQEZGOuGrdEF++8m4GcoN8LrMSXoJLrzwMOF6DDiIiIiI9QAMOIiLSEctXbGAgN8jPJpzFBHIAnMDN/J9fZvjAAX/V4ehEREREpFWaw0FERDrisa3bWJAaJMMoZmAGGUZ568vrOx2aiIiIiERAAw4iItIRu02exKr8ADnSOAfOQY40D2w/p9OhiYiIiEgE9EiFiIh0xLJFs/jylcOcOHw6x6VXAnCdHcZHjjq2s4GJiIiISCRiG3Aws+nAT4BdAQdc4Jz7jpmdCXwG2OIveppz7vq44hARkWQqTAy5fMUEvrp1prJUiIiIiPSYOO9wyAH/4Jxba2Y7AneY2W/89/7VOXdejNsWEZEu8IEDpmmAQUREpAtVS22tlNdSKrYBB+fc48Dj/s8vmtkgoJYmIiIiIiLSxQqprbeNjAIwtHUbX77ybp687/e8vOEmFua2Z+f0S6x6foAvXzkMoEGHPtWWORzMbAZwAHAbcAjwN2b2CWAN3l0Qz7UjDhEREREREWnN8hUbioMNBQO5QT6x8RyyNkI668hjDJNlyfBpLF8xQQMOfSr2LBVmtgNwBfC3zrkXgB8AewFz8O6A+L9VPvdZM1tjZmu2bNkStIiIiIiIiIi02WNbt417bUFqkCw5MuYASJsjS44FqcHA5aU/xDrgYGZZvMGGS5xzVwI45550zo065/LAfwLzgz7rnLvAOTfPOTdv6tSpcYYpIiIiIiIiIe02edK411blBxghQ84ZADlnjJBhVX4gcHnpD3FmqTDgh8Cgc+5bJa+/2Z/fAeCDwD1xxSAiIiIiIiLR8lJb3132WMVgZoCfzPwuL2+4iady27OzvcSq/ACDmQG+uWhWB6OVTopzDodDgI8Dd5vZev+104ATzWwOXqrMTcBfxhiDiIiIiIiIRGgstXVQlop3c0XJ699Uloq+Zs65TsdQ17x589yaNWs6HYaIiIiIiIiIlDCzO5xz84Lea0uWChEREREREeluV60b4sxr7mXrthEA3vC6LGe8f1/dwSBVacBBREREREREarpq3RDLfn4nI/mxO+Sfe2WEZZffCcAHdhmCTSthxkKYHpgXQPqQBhxERERERESkpuUrNpQNNhSMjDqu/+XVfCD/DRgdhvQEOOkaDToIEHNaTBEREREREel+j23dVvW9t7683htscKPev5tWti8wSTQNOIiIiIiIiEhNu02eVPW9B7af493ZYGnv3xkL2xeYJJoeqRAREREREZGali2aNW4OB4Bs2njfUcfCLvM0h4OMowEHERERERERqamQiaJ6loppGmiQccy58RN/JM28efPcmjVrOh2G9Imr1g2xfMUGHtu6jd0mT2LZollK9SPSZjoORUREolU4tw5t3YYBhW+BKYO8g2lNnG9Lz9c7TcpiBltfGdG5u8+Y2R3OuXlB7+kOh6TbvBru/Clg8KbZsO2ZsWeimrllafPqsc/B2Lpnn9jfI5J+OT/09CusffD1fM49BBm48vmFfPnKYYDmO8zSMo+qjAvrnDQFnljPuPbRz3XZqqBjrrScwxwrpevo92OrUlDbLS2jzau599bruPSeKQyN7AXA0NZtfPnKu4EWjkMREZFeV+17w/T5XLVuiC9feTfbRkYBb7Bhrm1kQWqQZ90O7Jx6iVXPD4S77i25br70wf2K5+vCXQ/gnbsvvfIK3rbxGfZ952JdC/Ux3eGQZJtXw4WLvZleCywFqQxgkM81lnZm82q46Bhvfak0OAd5v2NIT4Sl1/ZnZ1BSzg7GhnuBYTKcOHw6T+40m1tOPby5dRfKPKoUQYV15l4D8uXvWcqrS6Uiak7QMVf2NwDqHyuV6+jnY6tStbZbKCOAi44hl3uNEZdhyfBprHUzi4tNmzypueNQRESk11X73uBfFx5yyUsMlWSZmGsbuWTCOWQZIY0jjzFMliXDp9W+7q24bh523rVy6fm6bP2WI5PRtWmvq3WHg7JUJNmmlTA6Uv6ay3uvNZN2ZtPKks+NjA02QH+nrykpZ/NfMvP+yzDKgtRgzTRA9dcdcYqgwjorBxvAbx99XJetCjrmqBiUrVe+letQfYyp1nYLZeS/nyFPlhwLUoNlizV9HIqIiPS6qt8bvHNs5Tl0QWqQLDky5l3npM0Vz701z7cV182Fa+VKxfWja9N+pwGHJJuxENLZ8tcs5b3WTNqZGQtLPpeFVMm6+zl9TUk5F75aOuf9lyPNqvxAzTRA9dcdcYqgwjqDDl9L9XddtiromCsOQ/nqlW/lOlQfY6q13UIZ+e/nSDFChlX5gbLFmj4ORUREel3V7w3eObbyHLoqP8AIGXLOu87JOSuee2uebyuumwvXypWK60fXpv1Oj1QkneZwaI+SZ9EufPD1zHQPAXDl6EIGMwN887i3aw6HfqE5HOIVcg6Hs+6Zwh/9Z0IBJmXTrR2HIiIiva6BORygYg4He4lV+YFw170l181feXC/svN1qYOzD3L6fprDoR/UeqRCAw4iFTQ7vkjn6TgUERGJlrJUSFw04CAiIiIiIiIikVNaTJEm6C+sAl47OPOae4upnt7wuixnvH9ftQURERFJrNK7GdJmjDpX/LeZOxnCbq9w3fyevady4/1byrYfx3Yl+XSHg0iAoOfc9Ax5/7lq3RDLfn4nI/nyfjKbNpZ/aLbaQlxK53monENDc5WIiIjUFHQdWynK+RXCbK9A19O9SXc4iDRo+YoN4zrNbSOjLF+xQR1kH1m+YsO4wQaAkVGnthCXzavhomMg9xpe+szSp0x9JXnFNeggIiJSLug6ttRc28iPUueQHczBn/6j5fNpve2V0vV0/1FaTJEA1fIP18xLLD2nVn2rLcRk00ovXzd5/4WAu/CccnqLiIhUU+8aZUFqkCw5MkRzPm30mkjXUP1FAw4iAarlH66Zl1h6Tq36VluIyYyFXr7u4unJxi9jyuktIiJSTb1rlFX5AUbIkCOa82mj10S6huoveqRCJMCyRbMC53BYtmhWB6OSdlu2aFbVORzUFmIyfb53a6fmcBAREWlK0HVsqbVuJifnvxrZHA71tldK19P9RwMOIgEKz5UpS0V/K9S3slS02fT5GkwQERFpUul1bLUsFR9ZdDz7RnQtE3TdrCwVUqABB5ES3ZYKs9vi7SaVZXvmMRpkEBERkc4rTXkZMLUyACmDvCPUl/woric/cMA0XSdJIA04iPgqU/oMbd3Gl6+8GyCRHWi3xdtNVLYiIiKSRJXXKEGDDeANNkD9a5jK9e36/J089ItLufnZYzj0iMXRBF1Id63HIfuSJo0U8dVKhZlE3RZvN1HZioiISBI1koKyoNY1TOn65tpGLplwDp+3yzho5VJvoKBVhXTXN5zt/RvFOqWraMBBxNdtqTC7Ld5uorIVERGRJGr2WiTMtU0xXablybhcNOmnC+mu3ahSWvcpDTiI+LotFWa3xdtNVLYiIiKSRM1ei4S5timmy3QpcpaJJv10Id21pZXSuk9pwEHEt2zRLCZl02WvJTl1T7fF201UtiIiIpJEQdco9dS6hild31o3kyXDp/Fd92FuW3hhNPMtFNJdH/4V71/N4dB3NGmkiK/bUmF2W7zdRGUrIiIiSVSZ8rLVLBWV1zxP7jSbPRd9mEOjvOZRuuu+Zs5Vm9u0xRWbTQd+AuyKdxxc4Jz7jpntDFwKzAA2AR92zj1Xa13z5s1za9asiSVOEREREREREWmOmd3hnJsX9F6cdzjkgH9wzq01sx2BO8zsN8BS4HfOuXPN7FTgVOBLMcYh0vOuWjfEmdfcy9ZtI+Pee8Prspzx/n3113lJlChyfouIiIhIssU24OCcexx43P/5RTMbBKYBxwKH+YtdBNyEBhxEmnbVuiGW/fxORvLBdys998oIyy6/EwjOvyzSbpU5v+vlCBcRERG8lJKbVnoTL5Y+olDt9cr3J02BJ9YDBrNP1GMO0hZtmcPBzGYABwC3Abv6gxEAT+A9ciEiTVq+YkPVwYaCkVHH8hUb9GVOEiEoh3ghR7jaqIiISIDNq+GiY7zUkukJYxMwVnu98nO514D82OvrLoGl12rQQWIXe5YKM9sBuAL4W+fcC6XvOW8CicBvSmb2WTNbY2ZrtmzZEneYIl0rbD7mZvM2i0QtTC5wERERKbFppTeo4Ea9fzetrP165edKBxsgeFmRGMQ64GBmWbzBhkucc1f6Lz9pZm/2338z8FTQZ51zFzjn5jnn5k2dOjXOMEW6Wth8zM3mbRaJWphc4CIiIlJixkLvDgZLe//OWFj79crPVX7tC1pWJAaxPVJhZgb8EBh0zn2r5K1rgJOAc/1/r44rBpF+sGzRrJpzOABk01Y1/7JIuy1bNKtsDgeonSNcRESk702f7z0uUTlXQ7XXgz6nORykA+JMi/kuYCVwN2P38JyGN4/DZcCfAY/gpcV8tta6lBZTpDZlqZBuoywVIiIiIr2hVlrM2AYcoqQBBxGRcCoHnzTgJBIvDZ51l26qr26KVeJXaA9DW7eRNmPUOaa1sV2oPUottQYc2pKlQkRE4heUIlVpUUXioxSv3aWb6qubYu1b9VJRRqiyPcxmAwvSg6x6foBLr7yHt218hn3fuTi2ONQepRUacBAR6RHVUqQqLapIPJTitbt0U311U6x9qV4qyoiVtoe5tpFLJpxDlhyj/kSQ6cE8/Ok/YotD7VFaEXtaTBERaY9aaSWVclIkekrx2l26qb66Kda+VC8VZcRK631BapAsOTKWJ8Oo9zP5WONQe5RWaMBBRKRH1EorqZSTItFTitfu0k311U2x9qV6qSgjVlrvq/IDjJAh51LkSHs/k4o1DrVHaUXdAQcz+4KZvd48PzSztWZ2ZDuCExGR8JYtmkU2ZeNeV1pUkXgsWzSLSdl02WtK8Zpc3VRf3RRrXyqkmjz8K7E/TgHl7WGtm8mS4dP4Vu4EThw+naX5M9gw8PlY41B7lFaEmcPhZOfcd8xsEfAG4OPAxcCvY41MREQaUniOUlkqRNqjcFxp5vbu0E311U2x9q3p82MfaCgobQ9DW7dxJ7NYOzqzmKVi35jbhdqjtKJuWkwzu8s5t7+ZfQe4yTn3CzNb55w7oD0hKi2miIiIiIiISBK1mhbzDjP7NbAH8GUz2xHIRxmgiEg3UA5qERFpJ513OqtQ/kNbt5E2Y9S54l0FlfUQZ12pHUg3CzPg8ClgDvCQc+4VM5sCfDLWqEREEkY5qEVEpJ103umsyvIf9e8KD6qHOOtK7UC6XZgsFQ7YB/i8//v2wHaxRSQikkC1clCLiIhETeedzgoq/4LKeoizrtQOpNuFGXD4d+Bg4ET/9xeB78cWkYhIAikHtYiItJPOO51Vr5xL34+zrtQOpNuFGXA4yDn318CrAM6554AJsUYlIpIwykEtIiLtpPNOZ9Ur59L346wrtQPpdmEGHEbMLI33aAVmNhVNGikifUY5qEVEpJ103umsoPIvqKyHOOtK7UC6XZhJI78L/AJ4o5mdDXwIOD3WqEREEkY5qEVEpJ103ums0vKvl6UizrpSO5BuZ86fcbXqAmYT8VJiHgEY8DvgSefcs/GH55k3b55bs2ZNuzYn0hWUIklKBbUH0AWKSDtE2R+rbw+nkXSFIrVUO+bCHouly+00KYsZbH1lpOuPX/VF0ggzu8M5Ny/wvRADDtcBH3DOjfi/vxm41jn3jsgjrUIDDtL1Nq+GTSthxkKYPr/l1VWmSALv9rrzDxvl0An3w6Qp8MR6wGD2iZFsU0pEXJ+tCmoP2ZSBwdvzG1iQGmRVfoDBzADfPO7tzV0wFPZ50hTY9kxi9l2k06r1x80ca1Guq2M2r4Y7f0qc55/KcpprG6Pp55IuYeeeUBJ+7qh2zB3/jmlccccQ20ZGi+3rpdTrWbrn8+w5dQd402zY9gw3D+/N+Tc9yGJ3EwD35GewX2oTAFeOLoymPbZSho20mZJlb964hTtuvoY/jOzNWjcTqLjOLF1fN7ZLiVyrAw6fAd6H9yjFdOAa4IvOuV9HHWg1GnCQrrZ5NVx0DIwOQ3oCnHRNyx3yIefewFDF7MRzbSM/nXgO25GjbJqV9ERYeq1OAlGJoT5bFdQewGsTl0w4hyw5RsiwZPg0ntxpNrecenhjGyjsc+41IA+W8tpVAvZdpNOqHX/TJk9q+FiLcl0dsXk1XLjY6x8htvNPaTlF1s8lXQLPPXV1wbmj2jFXuGtmrH2NkMaBN5bvsRSvuRTmHFnGp88cJsOJw6e31h5bKcNG2kzpsqk0w6OOlBstHlNr3cyx60wbHVsfdF+7lFjUGnCoO2mkc+4/gd8CVwH/C5zSzsEGka63aaXXEbtR799NK1teZVAqpAWpQTKuYrABItum+GKoz1ZVS421IDVIlhwZy5Mlx4LUYHNptAr7XGhbLp+YfRfptChT1nV9+rtNK2F0ZOz3mPqJ0vKIrJ9LugSee+rqgnNHtbYy6v9Bdqx9eb9b6UIuT8aNkmEUMzD/zcLPGUZbb4+tlGEjbaZs2REybqTsmIKS68zS9XVju5S2qzrgYGZ/X/gP2A74M2A9sMB/TUTCmLHQG/W1tPfvjIUtrzIoFdKq/AA5yzDusI5om+KLoT5bVS011qr8ACNkyLkUI2RYlR9oLo1WYZ8LbctSidl3kU6LMmVd16e/m7EQ0tmx32PqJ0rLI7J+LukSeO6pqwvOHdXaStofPRhrX97vZfeFW4qcpcmRxjko3DRe+DlHuvX22EoZNtJmypbNkrNs2TEFJdeZpevrxnYpbVf1kQozO6PWB51zX48logB6pEK6nuZw6C0Je15RcziIdI7mcKigORzik7BzTygJP3doDofgZTWHgzSqpTkckkADDiLjafZgKaUsFSKdoywV7acsFRIVZakIpr5IGtHUgIOZfds597dm9r9U3EEE4Jw7Jtowq9OAg4iIiIiIiEjy1BpwyNT43MX+v+dFH5JIsmgUV3qV2rZI++h4kygkqR0lKZaotXpnQ611RBXfmdfcy9Zt3kSsb3hdljPev29Hyr+X24HEr+qAg3PuDv/fm81sArA33p0OG5xzw22KTyR2lc/vDW3dxpevvBuAD+wypOfSpDuUPjf9ptnwxHoeevoVLn1wP4ZG9gIq2rYuFERaV/Js9UN338KrDz/LriPvYleDBS8OcumV+wHHd8fx1i3PYTcaZ+nz7+2a26iFZ+5rXpO0uR0lKZaoVdu3NY88W5y7ofR1GL/PcZbPVeuGWPbzOxnJj91k/twrIyy7/M6x9bfpmO3ldiDtUXcOBzNbDJwPPIiXDWYP4C+dc7+MPzyPHqmQOFXLwXzk6x/hgvw3lFtYkm/zarhwsZ86a4wDhp2XB7ww6RPAtMmTei9HvUi7FfLW514D8t6zpw5GSOMw0uQZIcMXJn6dC077qw4HW0dhX5J+vms0zoo6KkpPhKXXxrOPldu0lLe9kGVa7ZqkE/12kmKJWrV9K8wHUilon+Msn2rrLq5/yQ5tO2Z7uR1IdGo9UlE1LWaJ/wu8xzl3mHPuUOA9wL9GGaBIJ1XLj/zWl9crt7B0h00rYXRk3MvGWB7wUj2Zo16k3Qr55/0vsgaYecdcllwxh/1bX17fySjDKexL0s93jcZZUUdFce5j5TZdvqHtVeufO9FvJymWqFXbh6DBhmrLx1k+tdbx2NZtbT1me7kdSHuEGXB40Tn3QMnvDwEvxhSPSNtVy4/8wPZzlFtYusOMhZDOjnvZMZYHvFRP5qgXabdC/nn/UsoBznnH3AiZYg77B7af08kowynsS9LPd43GWVFHRXHuY+U2LdXQ9qr1z53ot5MUS9Sq7UPaLPTycZZPrXXsNnlSW4/ZXm4H0h5V53Aws+P8H9eY2fXAZXjn0xOA29sQm0hbLFs0KzAH8/uOOhZ2mdcdz7RKf5s+H5ZeN24Oh4effoWvPLgfa91exUUnZdPFlJki0oLp873bmP1n9R+++xZWP/wsl428C4AFqUHWpfbjI0cd2+FAQyjdlySf7xqNs6KO2jKHQ+U2G5zDodo1SSf67STFErVq+3b8O6aVzeFQeD1on+Msn2WLZo2bwwEgmzZv/dOnte2Y7eV2IO1RKy3mj2t8zjnnTq65YrMfAUcDTznn9vNfOxP4DLDFX+w059z19YLUHA4SN82+K71KbVukfXS8SRSS1I6SFEvUlKWisVh6tR1INGrN4VB30sgWNvpu4CXgJxUDDi855xpKtakBB5He060nryTGncSYRKR1cRzbQV9iFu//Zm68f0tP9yHqJ6VVakPdrbLvSxnknTf5ZSt1WdoudpqUxczLKFKYgLTV9XeLWgMOVR+paJVz7vdmNiOu9YtI9+rWFEtJjDuJMYlI6+I4tqul2vvvVf+v+Hsv9iHqJ6VVakPdLajvm8NGjsushJdg7ZV7sv/659lz6g4NPXJV2S4KgxkAs9nAgvQgq54f4NIr7+FtG59h33cuTu4jazGK7Q4HAH/A4dqKOxyWAi8Aa4B/cM49V289usNBpLd0a4qlJMadxJhEpHVxHNu1Uu1FuZ2kUT8prVIb6m6V9TfXNvKzCWcxgdzYQuZlG2okbW61djHXNnLJhHPIkmPUn0A2bXkymfApcrtNq2kxo/QDYC9gDvA4XsrNQGb2WTNbY2ZrtmzZUm0xEelC3ZpiKYlxJzEmEWldHMd2I5/tpT5E/aS0Sm2ou1XW04LUIBlGMfPSGYM/2ACRpLFdkBospkcupkqmsRS5vaTugIOZnV7y88RWNuace9I5N+qcywP/CVQd3nHOXeCcm+ecmzd16tRWNisiCdOtKZaSGHcSYxKR1sVxbDfy2V7qQ9RPSqvUhrpbZT2tyg+QI41zXjpj8FIxApGksV2VHyimRy6mSqaxFLm9pOqAg5l9ycwOBj5U8vIfW9mYmb255NcPAve0sj4R6U7LFs1iUjZd9lo3pFhKYtxJjElEWhfHsb1s0SyyKau7XK/1IeonpVVqQ92tsu9b62Zy4vDpXDJ6BJeMHsEZ+c/w8Fs+DPNODv04RWG9le2isP4lw6fxrdwJnDh8OkvzZ7Bh4PM9+zhFPbUmjbwfOAHY08xW+r9PMbNZzrkN9VZsZj8DDgN2MbNHgTOAw8xsDt4g0ibgL1uKXkS6UmGCpW6b7TmJcScxJhFpXRzHduGz/ZalQv2ktEptqLsF9X3rmcna3MxiFok9m6jLynZRmqXiTmaxdnRs/fv2cVupOmmkmR0K3AbcChwIDADXATcAs5xz72xXkJo0UkRERERERCR5mk2LuQj4Gt4kj98C7gJeds59MvoQpROUT1hEkq4X+6mgnN1bXxnpmf0TiVsv9gtJpzIfc9W6oXF3CZ3x/n0jK48klXWSYola1PvWy2XVqqoDDs650wDM7E7gYmAuMNXM/gA855x7f3tClDgon7CIJF0v9lO1cnb3wv6JxK0X+4WkU5mPuWrdEMt+ficj+bE7xJ97ZYRll98JtF4eSSrrJMUStZr7tsuQl0lixsLQ8y0U1jeQG+RzmZXwElx65WHA8U2tr9eESYu5wjm3xjl3AfCoc+5dgO5y6HLLV2woHmQF20ZGWb6i7vQcIiJt0Yv9VNA+ler2/ROJWy/2C0mnMh+zfMWGssGGgpFRF0l5JKmskxRL1Krt2/W/vBouOgZuONv7d/Pq0OsbyA3yswlnsST9O5akf8eFqa9z/3XfbWp9vabugINz7h9Lfl3qv/Z0XAFJeyifsIgkXS/2U2Fi7+b9E4lbL/YLSacyH1Nrn6MojySVdZJiiVq1fXjry+thdBjcqPfvppWh17cgNUiGUczADDKMcvBrtzS1vl4T5g6HIufcnXEFIu2lfMIiknS92E+Fib2b908kbr3YLySdynxMrX2OojySVNZJiiVq1fbhge3nQHoCWNr7d8bC0OtblR8gRxrnwDnIkeaPEw9pan29pqEBB+kdyicsIknXi/1UtZzdBd2+fyJx68V+IelU5mOWLZpFNmXjXs+mLZLySFJZJymWqFXbt/cddSycdA0c/hXv35BzLixbNIvBzAAnDp/OJaNHcMnoESzNn8Heiz/f1Pp6Ta0sFdLDlE9YRJKuF/upajm7laVCJJxe7BeSTmU+prDPcWWpSFJZJymWqNXet2kNDwyMrW8CX906s+X19RpzbvzEJ0kzb948t2bNmk6HITGplUam0ylmWt1+3KmTulWS61zipzpWGUh4UbWVoPVAb3yZ0PHU+1qp415u+1HrxevWOPqHwjqHtm4jbcaoc0wLWHc/9U1mdodzbl7gexpwiNHm1X2fBqWeyrQ04N3SdP5ho+zy9GrOumcKfxzZq+y9bx739rYcrKUpbhakBlmVH2AwMxB6+0Gpk8C77W75h2Z3psPpVJssbHfSFB66+xZWP/ws63NvYWd7qaxcgbL2MNc2ckL2Dxy05xT23O+dsO0ZmDTF+7dTx1U3HtcJirnaMd+u4zpSjZarv/zNw3tzyk3p3iiDbtKu4yCq7Wxezb23Xsel97zMDvkXWJUfYK2b2VRbqTzu5tpGjk+vBIO7R2cU++KJmTSn7/cM+75z8VjsYfcnaLkIy6JwDqns/2v2KZ1IR1e5zzViD72+O38KGMw+Mb79aKY/qxdXtbJosAxqXSseOuF+r2yfWB8YS9BnsykDg7fnNxSv7wLbfp8Jum6daxs5PrOSg/faZew6LKj+EnSdUSqo/g/OPli/rmvsT9A6C0r755663glBAw6dsHm1l/5kdNibJKSPn9up5ZBzb2CoYqbYubaRn048hww5RlyGJcOnsdbNLL4/bfIkbjn18LbEtuvzd3LJhHPIkmMEL5Ynd5odavtB+1bQrn0o06k2Wdhu7jUgjwPwu508xjDZYrkCxTKbaxv52YSzmEAOvGsDvP87sBSkJ7b/uOrG4zphMVc7LjpyTLSi0XItWf5Vl+Zjr5X3a9CFZdBN2nUcRLUdfz253KuknSvrK9e6mQ23ldLjrqxv9eUxcnjPM6ctTybj968Qbn+C9jvsZ0OWReEcUtn/V+tTjnz9I1yQ/0Z7+77KcnjvufCrU6vGHmp9Fy721gfeZ5deG/1+NNOf1YurWlk0UR+1rhW3Iwfkx96oiKVa+5hrG4vXd6P+lHZlbT/p5/YYVJZV4HVYUBtO2HVGqaB9umTCOWQtV72u6+xPret7GDuX98z1Tki1Bhw0aWRcNq1UGpQQgtLSLEgNknE5MuTJkmNBarDuZ+KKbUFqkCw5MjYWS9jtx506qWGdapOF7foXBIaXLgggba6sXEvLpSy9UPFVf6TC5TtzXHXjcZ2wmHsmzVaj5VqyfMaN79egC8ugm7TrOIhqO/56Mn6fV9pXQuNtpWrfWtIXZxj1zneU9K9h9ydouYjLovilsqL/jzq9XUsq93nw6pqxh1vfyNjvce1HU/1ZnbiqlUUT9VHrWrFssCEglmrto/T6LrDt96HKsgq8Dgtqwwm7zigVtE9167rO/tTrfwvv98z1TgQ04BCXGQuVBiWEoLQ0q/ID5CxDjhQjZFiVH6j7mbhiW5UfYIQMOTcWS9jtx506qWGdapOF7frdjcNLFwSQc1ZWrqXlUpZeqPiqf8qzVGeOq248rhMWc8+k2Wq0XEuWz9n4fg26sAy6SbuOg6i2468n5/d5pX0lNN5WqvatJX1xjrR3vqOkfw27P0HLRVwWxUvWiv4/6vR2Lanc54Fja8Yebn3Zsd/j2o+m+rM6cVUriybqo9a14rivMhXrrtY+Sq/vAtt+H6osq8DrsKA2nLDrjFJB+1S3ruvsT73+t/B+z1zvRECPVMQpoc8zJYnmcGgzzeEQ3b5003GdoJh76plGzeHQXTSHg+ZwaAfN4VB9nZrDIdE0h0MJzeHQMM3hIImW5IwFylIRjyTXucRPdawykPCUpaI+HU+9T1kq2qMXr1uVpaI9NOAgIiIiIiIiIpGrNeCQaXcwItIb4vir206TspjB1ldGyn7u9VHhpOv0CH2nt9+sbo1bwqlWv3HVe7e1p26LN2r9vv9xCPtXZZFG6FiNn+5wEJGG1X2eMuQzfLWeg6vUy8+9JVmnn0Gs+fzlXnt0dj6PGkI9c5zQ2KW+avV7/DumccUdQ5EfL50+DhvVbfFGrd/3Pw5hn5sXaYSO1egoLaaIRGr5ig3jTvoDuUEOWrkUbjjby1+8eXVT66lm28goy1dsaCZcaUFQHbWzLiq3P9c28qPUPzFr8Dtw7RfghrNCt7d2qnmM/O6sRMcu9VU7Ln522+ZYjpdOH4eN6rZ4o9bv+x+HWtcLKltplo7V9tCAg4g0rGZO7AbyMLeSS17ao9N5pKvn0Pbvzms0r32bhMobn9DYpb5q7X+0yl2jrR4vnT4OG9Vt8Uat3/c/DvXKTmUrzdCx2h4acBCRhtXMid1AHuZWcslLe3Q6j3T1HNrmvdBoXvs2CZU3PqGxS33V2n/arKHlW91eUvvEbos3av2+/3GoV3YqW2mGjtX20ICDiDRs2aJZTMqmy14bzAxw28IL4fCvwEnXhHouPWg91UzKpouprKR9guqonXVRuf21biYn57/KhoEvwNHfgcNPD93e2qnmMXLE6YmOXeqrdlyceND0WI6XTh+Hjeq2eKPW7/sfh1rXCypbaZaO1fZQlgoRaVhhIp3KWX0PPWAasLjp9ShLRfJUq+t21UXQ9j+y6Hj2TXhbiOoYkWSqdVzMe8vOkR8vnT4OG9Vt8Uat3/c/DqVlqiwVEhUdq+2hLBVdROmAJErNpgEKSmP53CsjGBSeqidlkHeEbp9KSSRRuWrdEGdecy9bt40A8IbXZTnj/fvGmq6wkdjUzvtHK/Xd7pSbEo9+rq+49z2Ka5h+qxOprpF2oTYUrFaWCg04dAmlA5IoNZsGqJE0lgXFFIbvXBx467hSEklUrlo3xLKf38lIvvy8lk0bHzlweizpCkPZvJp7b72Os+6Zwh9H9hq//V2GvIkjlSKzZ7TSr7U75WbsNq+Op31vXg13/hQwmH1iY+sOiiniOPv23LZ5NQ/99j9Z/fCzXDbyLta6mUBE++7X0c3De3P+TQ9yQP4eVuUHWOtmNn0NE/i50rb1ptntT2Hc6e3HKc7+oMn1NtIuSs/lc20jC1KDrEvtxymH7dVQWvhepAGHHnDIuTcwVGPG1GmTJ3HLqYe3MSLpZtXaU712VK8dVpprG7lkwjlkLUcmMzHwefVmYxGpVKt9Fu4KqxR7O9u8Gi46hlzuNUZchiXDpxUvwAGOfP0jXJD/hpetIj1Bczr0iFb6tWqf7VgbboXf/iNv35tXw4WLvfUCpCfC0mvDrTsoJog8zr48t/n14kaHwcEwGU4cPr3Y57W07yX19pozcJAmzwhj/Wqz1zBln6tsW+BP8Bt8DRO5Tm8/TnH2By2sN3S7KDmXf33k45yRvZgsOUZJYWZMsHxfn8drDTho0sguoXRAEqVm0wA12s7GUhhWT/+nlEQSlVptJq50hXVtWgmjw2TIkyXHgtRg2dtvfXm9d2w0kE5Wkq+Vfq3dKTdj5bf/yNv3ppUwOjL2eyPrDoophjj78tzm14sBZpBhtKzPa2nfS+oo40a9awsr71ebvYYpe72ybUF7Uxh3evtxirU/aH694dvF2Ln8qPTqYhvMMErGjeg8XoMGHLqE0gFJlJpNA9RoOxtLYVg9/Z9SEklUarWZuNIV1jVjIaQnkCPFCBlW5QfK3n5g+znesdFAOllJvlb6tXan3IyV3/4jb98zFkI6O/Z7I+sOiimGOPvy3ObXiwOcgxzpsj6vpX0vqaOcpb1rC1ferzZ7DVP2emXbgvamMO709uMUa3/Q/HrDt4uxc/kvR+cX22CONDnL6jxegx6p6BKaw0GipDkcpBdpDgdJCs3hUEJzOBRf64r6apXmcGhdp7cfJ83h0LM0h0OPUJYKiZKyVEgvUpYKSQplqZB+ri9lqZBuoiwVrevIgIOZ/Qg4GnjKObef/9rOwKXADGAT8GHn3HP11qUBBxEREREREZHkqTXgkIlxuxcC/wb8pOS1U4HfOefONbNT/d+/FGMM0iM0mjgm6rKIo2z11zlJmqA7c7a+MhJ5O6y8w+J12RQTs+lYtiUSpW7on7vhr9pB2wL011ORLhbHHWv9JNZHKsxsBnBtyR0OG4DDnHOPm9mbgZucc7PqrUd3OPS3vn0OMkDUZRFH2fbc88fS9erNPRJVO6w2h0Qc2xKJUjecZ6OceyiufQvaVjZlYDAyOtYvVNt+N9SDSL+JY06eXjymk5QWc1fn3OP+z08Au7Z5+9KFlq/YMO6LwraRUZav2NChiDon6rKIo2yrrfNnt21WPUpHBLXJUlG1w+UrNtQcbIhyWyJR6obzbLMxtnPfgrY1kndlgw21tt8N9SDSb1o5LnVMezqWFtN5t1ZUvTIzs8+a2RozW7Nly5Y2RiZJ05e5rKuIuiziKNueyiEvPSFMG4uiHYZdh9q8JE03nGebjbGd+9bIOoOW7YZ6EOk3rRyXOqY97R5weNJ/lAL/36eqLeicu8A5N885N2/q1KltC1CSpy9zWVcRdVnEUbY9lUNeekKYNhZFOwy7DrV5SZpuOM82G2M7962RdQYt2w31INJvWjkudUx72j3gcA1wkv/zScDVbd6+dKFli2YxKZsue21SNl2ciKmfRF0WcZRttXWeeNB01aN0RFCbLBVVO1y2aJb3vHYNavOSRN1wnm02xnbuW9C2sikjmy7vF6ptvxvqQaTftHJc6pj2xJalwsx+BhwG7GJmjwJnAOcCl5nZp4BHgA/HtX3pHYVJVfp9hleIviziKNta65z3lp1Vj9J2lW0yriwVhXUoS4V0m244zzYbYzv3rdq2wm6/G+pBpN+0clzqmPbEmqUiKspSEb2kpWhJWjyVkh5fWK3uR6Ofb1e59Ur9SG3NtL/SL/9veF2WM96/r9qgJFIvtqHCPg1t3UbajFHnmNYj+xa1evXfi+0jCrXKRWUmUVJ7qq1WlgoNOPShpKVoSVo8lZIeX1it7kejn29XufVK/UhtzbS/oBSVB2b+xJlvf45937kYps/vSGwilXqxDdVKR9vt+xa1evXfi+0jCrXKBei+Mtu8GjathBkLIzs/STQKbW0gN8iC1CCr8gMMZga89rTLkOqNZKXFlARIWoqWpMVTKenxhdXqfjT6+XaVW6/Uj9TWTPurHGyYaxv5SfpsZg1+Fy46xru460BsIpV6sQ3VSkfb7fsWtXr134vtIwq1yqXrymzzau+8dMPZkZ6fJBrLV2xgIDfIJRPO4e8zP+eSCecwkBvk+l9erXoLQQMOfShpKVqSFk+lpMcXVqv70ejn21VuvVI/UlsU7WxBapAsOTLkYXTY+4tEB2ITqdSLbajZdJX9qF7992L7iEKtcum6Mtu00jsvudFIz08Sjce2bhu7hrA8WXIsSA3y1pfXq95C0IBDH0paipakxVMp6fGF1ep+NPr5dpVbr9SP1BZFO1uVH2CEDDlSkJ7g3f7YgdhEKvViG2o2XWU/qlf/vdg+olCrXLquzGYs9M5Llo70/CTR2G3ypLFrCJdihAyr8gM8sP0c1VsIGnDoQ0lL0ZK0eColPb6wWt2PRj/frnLrlfqR2pppf5UpKte6mXxi9CtsGPg8nHRNZM9aqg1Kq3qxDdVKR9vt+xa1evXfi+0jCrXKpevKbPp877x0+FciPT9JNJYtmsVgZoAlw6fxrdwJLBk+jcHMAO876ljVWwixpcWU5EpaipakxVMp6fGF1ep+NPr5dpVbr9SP1NZs+6vMUrHk/Sewr9qgJEwvtqHSfVKWitrq1X8vto8ohCmXriqz6fP1hTWhxtraBH6wdSa7TZ7EN4vtaZrqrQ5lqRARERERERGRptTKUqE7HNpI+Vvru2rdUNlfJFMGeYf+IhKxbmmLnYizW8qmE3qpbHppX5JE5ZpM7awXtYFgSSuXuOJJ2n4mPS5Jlk63k05vPy66w6FNlEO5vqvWDbHs53eWpbKbaxs5Lu3N+LrR9mTpns+z59QdYPaJun2pSTf/7jruuPka/jCyN2vdTCCZbbHhYyaC/NU6TqtLbNmEqfeKZWruS9T5tPsor3pi20ifa2e9dH0biOl4jbTPifFcd/5hoxw64f6m1x26/tvcL1bGNdc28q7s/bzj0GM4dObUsVigb/rrntVC2+p0/9Xp7beq1h0OGnBok0POvYGhgFQ80yZP4pZTD+9ARMlTWUZzbSM/m3AWE8iNLWRgAOmJsPRanRAatXk1r/5wMRmXY4QMS4ZPKw46JK0tNnTMFPJXjw57swQ3OXGPjtPqElk2Yeo9YJlDLnkpcF+OfP0jXJD/RsvtqKH4ekgi24i0tV66ug3EeLxWK5eG+5wYz3VzbSM/nXgO29lo0+sOVf8d6BdL45prG7lkwjlkyTFqKSam05DPQSoNmPdzH/TXPanFttXp/qvT229VrQEHZalok67LB9wBlWWxIDVIhlHMwPzJ5otzzivXbXM2rSTjynMIFyStLTZ0zESUv1rHaXWJLJsw9R6wTLWYI8+n3Wd51RPZRqSt9dLVbSDG4zWyPifGc92C1CAZl2tp3aHqvwP9Yun2F6QGyeJdB2UKMbhRGB3pq/66J7XYtjrdf3V6+3HSgEObdF0+4A6oLItV+QFypHEOCjfiFO/HUa7b5sxYSM7KcwgXJK0tNnTMRJS/WsdpdYksmzD1HrBMtZgjz6fdZ3nVE9lGpK310tVtIMbjNbI+J8Zz3ar8ADnLtLTuUPXfgX6xdPur8gOM4F0H5QoxWBrS2b7qr3tSi22r0/1Xp7cfJz1S0Sbd/lxOO2gOh/bQHA4RbrOPJLZsNIdDYiS2jfQ5zeHQAM3hoDkc+qS/7lmaw6FjNIdDQvTqzKNRUpaK9uiWtqgsFcnSS2XTS/uSJCrXZFKWis5LWrkoS0Uy4pJk6XQ76fT2W6EBhwTpdEPq9Pb7Rb1yblc9hN1OO+JpZRtJbLdJjCkOSd7PKGKrHOR8w+uynPH+fTuyj50u66i2H6b/CypzgOUrNjC0dRvG2CN0nayTpOp0W5FgvV4vjV7bvGfvqdx4/5ay5YFYy6gQw9DWbaTNGHWuq/5o1ettKCph6lll2V4acOiEgFt6On2rTKe33/VC3qZV79bJe2+9jrPumcIfR/Ya/37EJ90w9d2OdtHKNhq6FbVNt2l27bHUYPkkeT+jiC3oMS6AbNpY/qHZ0T9eUamkPq56elr7HvMIEFVd11tPtTJPGaRTxsho8DVJsU6SfHy1SZKPy7ri7KM7/PhSQ/VSiHXSFNj2TFfcwh/m2K58v1I25aUaKz3Oo+znasVwcPZBzt7z7vY+lttD59xItXis1qrnQnkBsTw2FNU+9CINOLRblbQsnU530untd7UGUu3US3+Vy73GiCtPSQnR10PY+m5Hu2hlG6HTib33XPjVqW1JtdWVx1IT6aKSvJ9RxFZtHRBDisxKFfXx2dTX+PULb2l/HL6o6rreemqVeT1JaHdJkOTjsqY40yEmIAVt6HopxJp7DciDpbxU3wlPwxjnsR1VP1cthmKadcu1L7V6j51zIxPBsVqvrU3zJ1mMI/VrVPvQi5QWs92qpGXpdLqTTm+/qzWQaqde+qsM41NS1vpcs8LWdzvaRSvbCJ1ObPDqtqW06spjqYl0UUnezyhiq7Vs5CkyK1XUx1tfXt+ZOHxR1XW99bTSdpLQ7pIgycdlTXGmQ0xACtrQ9VKIlbz3u8t3RRrGOI/tqPq5ajEU06wXXmhHeffYOTcyERyr9crjsa3bYkv9CiSiv+k2GnCIQ5W0LJ1Od9Lp7Xe1BlLt1Et/lWN8Sspan2tW2PpuR7toZRuh04kNHNu2lFZdeSw1kS4qyfsZRWy1lo08RWalivp4YPs5nYnDF1Vd11tPK20nCe0uCZJ8XNYUZzrEBKSgDV0vhVgLl+CW6oo0jHEe21H1c9ViKKZZL7zQjvLusXNuZCI4VuuVx26TJ8WW+hVIRH/TbTTgEIfp873baw7/StltNssWzWJSNl226KRsujiJTtw6vf2uVqVOg1Qr5/cddSycdA0bBj7Pyfmvlj1OEUc9hK3vdrSLVrZRrzyLdTJvaeg6alVXHksNtOGCJO9nFLEtWzTLe6a4QjZt49tX1O2poj7ed9Sx4dp5TO06qrqut55qZZ4yr9yryaYtEe0uCZJ8XNbURB+UiHWHFLpeCrEecToc/R04/PSuuCU7zLFd+X6lbMrGHedR9nPVYljrZrI0fwYPv+XDMO/k+B+ngJ4750YmgmO1VlsrlFfQMoOZAW5beGHr/UQC+ptuozkc2qzTM6Z2evv9Qlkqmo8l6s/GJYkxxSHJ+6ksFcncvrJUxK/TbUWC9Xq9KEtF/Hq9DUVFWSqSR5NGioiIiIiIiEjkag04ZNodTD9o1whvv43cxbW//VKOrdztAPH+RaLX9Eub6oSgv2pMnpTFDLa+MpLY8m60TUTdhjrRJivvZChVeteCjpfuP7+F2U6S6jkp/Ui3/zW+FUlqD90Ql1RXehyV3h2XMsg7Wjqm1B6ioTscItZyHuIGbjHv2Vy9Ablt49rfni7HEmH3M2i5WPNmd2Eu8nr6pU11Qpj+FTpU3jVycjfaJqJuQ51ok1etG2LZz+9kJF/9GiObNj5y4HSuuGOor4+Xbj+/hdlOkvrFyljm2kYWpAZZlR8ozq001zbyruz9vOPQYzj0iMVtiaNUrx8D1drD+YeNcuiE+1u/FqjRHzcTVy/XRUc1WU+lguos6Jg+OPsgp+/3DPu+c3Hobak9NEaPVLRRu3KM92yu3iq5bePa354txwph97OR9tty3uwuzUVeT7+0qU5opH22tbzr5ORutE1E3YY60SbD1lXhr7qV+ul46fbzW5jtJKlfLI1lrm3kkgnnkCXHCBmWDJ8GUHwtZxm2+9R1sZyT6h0jvXwMBO37XNvITyeew3Y22tw1RUGd/rjRuKC366JjWqinUpV1VvOYthyZTPjrTLWHxtQacFCWioi1K8d4z+bqrZLbNq797dlyrBB2PxvZ75bzZndpLvJ6+qVNdUIUfWQs6uTkbrRNRN2GOtEmw647aLChkc/3gm4/v4XZTpL6xdJtLkgNkiVHxvJkybEgNVj2WsblYjsn1dv3Xj4GgvZtQWrQK+9mrykK6vTHjcZV63VpQQv1VKqybmoe0zR2nan2EB0NOESsXTnGezZXb5XctnHtb8+WY4Ww+9nIfrecN7tLc5HX0y9tqhOi6CNjUScnd6NtIuo21Ik2GXbdaQtOhdlPx0u3n9/CbCdJ/WLpNlflBxghQ86lGCHDqvxA2Ws5y8R2Tqq37718DATt26r8gFfezV5TFNTpjxuNq9br0oIW6qlUZd3UPKZp7DpT7SE6GnCIWCt5iBvNH9+TuXqr5LaNa397thwrhN3PoOViy5vdpbnI6+mXNtUJYfpX6EB518nJ3WibiLoNdaJNLls0y5v/pYZs2jjxoOl9f7x0+/ktzHaS1C+WxrLWzWTJ8Gl8K3cCS4ZPY62bWXztu+7D3LbwwtjOSbX6s14/BoL2fTAz4JV3s9cUBXX640bj6vW66JgW6qlUZZ1VO6ZPzn+VDQOfb2hbag/R6cgcDma2CXgRGAVy1Z73KOimORxAWSri0u2zeHeaslS0T7+0qU5IyuzyjVKWinLKUlGu289vylIRXRzKUqG4pDHKUpEMiZs00h9wmOecezrM8t024BAlNXTplKS3vcovM6VfYFpZZ7P73ImBmqTXUTsl6YtVlNvYKcIvQdW+3AQNimsAvLYk7G+1i+xSzVxwx71v7Sy7ZgbaozzmpLYwAy5JONakP6ntNUYDDl0qdDqWCNLKiJRKeiqgain3smlj+Ydmtz11YMPpRCP6y2WS66idgsqimRRYYbczkBssptyamElHup16qT+breOwKUWb2Ua/tcUk7G/Y+pxrGzku7U2Qdp0dximH7VUz7WDc6QrbWXatpIMu1bG23OPXdrXK/eDsg5y9591gxlce3I8/juxVfK+X+xZJjtj6qh4+rpM44PAw8BzegPx/OOcuqLV8vw44hErHElFaGZFSSU8FVCudWCdSB3YiXWPS66idqqbFajAFVpjt7Pr8ncWUW6P+NEhpy0e2nTBtqZk6bjRls9I0V5eE/Q1Tn3NtIz+bcBYTyAEwQhosxQTLV71eiDVdYY244yi7KNNBt70t98G1XbVyL7Zb89rtsMtw4vDprHUzi8v0at8iyRFLX9Xjx3US02K+yzk3FzgK+Gsze3flAmb2WTNbY2ZrtmzZ0v4IEyBUOpaI0sqIlEp6KqBacXQidWAn0jUmvY7aqWparAZTYIXZTlnKPEYj307U7a3ZzyhNc3VJ2N8w21qQGiTDKGZgBhlGybiRmtcLsaYrrBF3HGUXZTrotrflPri2q1amxXYLGF67XZAaDPVZkajE0lf1wXFdTUcGHJxzQ/6/TwG/AMYN7zjnLnDOzXPOzZs6dWq7Q0yEUOlYIkorI1Iq6amAasXRidSBnUjXmPQ6aqeqabEaTIEVZjtlKfNIR76dqNtbs59RmubqkrC/Yba1Kj9AjjTOgXOQI03OsjWvF2JNV1gj7jjKLsp00G1vy31wbVetTIvtFu826BxpVuUHQn1WJCqx9FV9cFxX0/YBBzPb3sx2LPwMHAnc0+44ukGodCwRpZURKZX0VEDVUu5l09aR1IGNpBONqgyTXkftFJQWq5kUWGG2M5gZKKbcOnH4dJbmz4h0O/VSfzZbx2FTijazjX5ri0nY3zD1udbN5MTh07lk9AguGT2Ck/Jn8seFF9W8Xog1XWGV9cdVdq2kg25HfDX1wbVdtXJf62ayNH8GD7/lwzw84yMszZ9R9jhFL/ctkhyx9FV9cFxX0/Y5HMxsT7y7GgAywE+dc2fX+ky/zuEAmiFVOifpbU9ZKpJfR+2kLBXh16ssFa1Lwv4qS0V021KWis5QlgpJMrW9xiRu0shG9eqAQ9Ibchxf6CrX38z+dzqffVTbSHr9Q/JiTFo8jeqm+Lsp1jgEXQhPjumLSJLLujK2KAYnaq2/1vpaOScluYy7VSvHSNBng75wxn0d0klJapOtDrhEsS/VBtCaGTRrRpLqo5d1Qzl3Q4xJpAGHBEpCWq1xSlK13LxxC7ffeDW3jg6U3crWStrBUs3uf6Ofa0c5N5NGrGZcuwy1J2VOaWoeKN/m5tXce+t1nHXPlOB0VO2KsURpmc21jSxIDbIutV/dNG9JUVnnc20j78rezzsOPYZDj1jc4ejKJbJ/alYTKahqpWsrtL1V+QEGMwMtl0m1dvGeA/bmgOwjgMHsExtv282m3ip8btIUHrr7FlY//CyXjbwL8CZze9btwM72Eqvy3rmhlXbRSDrThlPhluz/VU9PS2Z7rlVHcaROi3CdQe22cFxU3v7eaBrKwuf+du/neHHwRp7Ol7e5qK5DOqluHxumrjavhjt/StN9RI1YSrV0PdNCat2CRlO7lgnZ5nvqnJdg3VDObY+xh9JkasAhgZKQVqtMaaqWVJrhUUfKjTJChiXDp0WejqjZ/W/0c+0o52bSiFWL68jXP8IF+W/EnzKnor7BIJ/ztvnec+FXp5LLvcaIG1//bYuxQqHMiikP/bSEZlYzzVtSlNZ56T7kLMN2n7ouUXEnrn9qVpMpqGqlayvUW6FvfHKn2S2VSXC7GCFtjuIMIOmJsPTa8G2k2dRbhc/lXgPy3l8YnZdO0WGkGSWNI48xTLbYN0SVirZWOtOGUuFW7P9nU1/j1y+8pf7n2qlWHcWROi3idVbrz8JcM4RN6Vk8FiJsc0lRs49dskP9utq8Gi5c7C0DjfcRIWIpaPZ6JorUus2kdi1qoM33zDkv4bqhnNsaY4+lyUxiWsy+l4S0WmXKUrWMkHEjZCxPllws6Yia3f9GP9eOcm4mjVi17b/15fXtSZlTUd9l2xy8GkaHyRBc/22LsUKhzCrTEtZL85YUpXVetg8ul7i4E9c/NavJFFS10rUV6q1wbLRaJsHtwpU/kN9o22429Vbhc+QBLyVdIZ1iMS4gba6sb4gqFW2tdKYNpcKt2P+3vrw+3OfaqVYdxZE6LeJ1VuvPwlwzhE3pGUebS4qafWyYutq00jt3F7RQp/XKstnrmShS6zaT2rWogTbfM+e8hOuGcm5rjH2UJlMDDh2ShLRaZcpStWTJWZacSzFCJpZ0RM3uf6Ofa0c5N5NGrNr2H9h+TntS5lTUd9k2B46F9ARyBNd/22KsUCizyrSE9dK8JUVpnZftg2USF3fi+qdmNZmCqla6tkK9FY6NVsskuF0YlCY4abRtN5t6q/A5/9LAMZZOsRgXkHNW1jdElYq2VjrThlLhVuz/A9vPCfe5dqpVR3GkTot4ndX6szDXDGFTesbR5pKiZh8bpq5mLPTO3QUt1Gm9smz2eiaK1LrNpHYtaqDN98w5L+G6oZzbGmMfpcnUIxUdksjnmDSHQ6T7ojkcoqU5HNonkf1TszSHg+Zw0BwOka9Tczi0RnM4hI9Bczj0jm4oZ83h0DzN4ZBQSZ8FVVkqwlOWiv6Mp1HdFH83xRoHZanwKEuFVKMsFa1JUptUlopk1Ucv64Zy7oYYk0gDDiIiIiIiIiISuVoDDpl2B9MvgkbvWxmdjXO0Le6/YCVVlCPyYf8q0I+jplHvcxxl2A/1EtU+trKepJdzI39Nbee+VPvLXzWlcVeLs9Y5CggsB6Dmutpxfup0v5r0NhyHoPPcc6+MRHJtU287zdxNFPW5vV/quVFJutu0F+qrF/ahnn7Yx1r6ef91h0MMaj2L1sxzQNWeXf/Icce3/Cx92Gcpk/R8VRRafkaryhwHpSrX1w3PrkWtoX0ueXacbc/E9qxoSzF2qaj2sZX1JL2cG5kjoJ37EqaPDpJNGx85cDpX3DE0Ls7j3zGNB++4kQPy94x75j6b8r5EVhQDKYN0yhgZdePWFbSNKMoiTDkHnR9fSr2ej+y3vTcPBMQ2b0FQPHV1y/O6/vwADz39Cl95cL+q57mCOPrhZtYf13wCkR3fSaz/oJiqxVmjXTQzn9b5h41y6Lbf0Mo8FHXnR0pimVe4at0Ql155RVmfnKTzYxS6+riKYP1NXQ8nuM0G0SMVbVYvp3GjuVwL66vMdf2d7MmcykUt5W8Nkw+7mZiTrqU8u37e3FzuNUbc+Jzj1dbXDfmHoxZ6nwu5iHOvAXmwlJdXPIZ8303H2MWi2sdW1pP0cq7VF1bG2M59CdtHByn8BbrSvNSfuDh7dvFcUqsPa3YbUZRFmHIef34cIY0jb0Y6nQUM8rlIcpy3XO/dknN982q4cDGMDuOAYZfhxOHT67aROPrhRtcfxbEZ2/GdxPoPigmC4wzRLqqVUVCZzrWN/GziWUwk572QnghLr23pOrb0OjlnGbY7ejn86tRklXmAz57z73zntTPG9clJOT9GoWuPq4jW3/D1cMLbbJBaAw5KixmDerlaG83lWli+Mtf1wa/d0nL+1rCxJClHbhRayrPr583NEJxzvNr6uiH/cNRC73MhFzF573eXjy3fd9MxdrGo9rGV9SS9nGvFUfleO/ellXUGDQQAzLf7ys4ltfqwZrcRRVmEKefx50cvnjQORkcizXHecr13S871TSu9ssPLzpphNFQbiaMfjmqZRmKL7fhOYv0HxVQtzhDtopGyW5AaJONK7miJ4Dq29Do543IweHXyyjzAW19eH9gnJ+X8GIWuPa4iWn/D18MJb7ON0oBDDOrlam00l2th+cpc13+ceEjL+VvDxpKkHLlRaCnPrp83N0dwzvFq6+uG/MNRC73PhVzEhS7JUrHl+246xi4W1T62sp6kl3OtOCrfa+e+tLLOtFng66vdPmXnklp9WLPbiKIswpTz+POjF88oBulspDnOW673bsm5PmOhV3Z484XkSIdqI3H0w1Et00hssR3fSaz/oJiqxRmiXTRSdqvyA+QsPfZCBNexpdfJOcvAwLHJK/MAD2w/J7BPTsr5MQpde1xFtP6Gr4cT3mYbpQGHGCxbNItJ2XTge5Oy6eKkXI2ub62byZLh0/hW7gROzn+VvRd/3rvV5vCvNH3LTa1YW4k56YL2O/R+Tp8PJ13DhoHPc3L+q1VvM61cX0vb7FKh99kvU444HY7+Dhx+emCbjqMM+6FeotrHVtaT9HJetmgW2dT4L8/ZtI2LsZ37EqaPDpJNGyceND0wzr3nH8HJ+a/yrdwJ4x6nyKaMgGIgZd46K9dVbRtRlEWYch5/fvwwZ+Q/w/0DX4Cl13m3aLdwjmw0npoK/VxE8cRm+nyv7OZ9kodnfISl+TPqPk4RRz/czPqjODZjO76TWP9BMVWLs067qFVGQWU6mBlg1cKfwLxPwryTm3qconLdhX7gu+7D3LbwQpi3NHllHuB9Rx07rk9O0vkxCl17XEW0/oavhxPeZhulORxioiwVyacsFe2hLBXJoCwV9SlLhbJURBFPr1GWiv6o50YpS0W0emEf6umHfayl1/dfk0b2iXoNudcaeq39CXoPgi+WG91m2C8kjcQbxT5H8ZlubiPdHHsnVV7kD+dGeWXEm0sjKV+4ky5JZdGLA3L1Bk2a+YLaTL/YzB8Q6sUIrZ+X4tDJOg9T353+gtvKtjo9aFutTVb7OYr96XQf0glhrslLrydTBnlHZAN4Iu2mAYc+UC/dStJT0jWq1v4A497LpgyMcSndGk2VFTZtXiPxxpmqq5HPdHMb6ebYOylMysVs2vivwx2HTri/mKJJ5T0mSWXRi2ljq20/KB1nqWZS9IXtFwsOzj7I6fs946XfDLjttd7xFcV5KQ6drPNG6juqOo4r5qjPs3FdR4TRyv50ug/phDDX5EHXk0HLinQLZanoA8tXbBh3Atk2MsryFRtCvd9tau1P0HsjeVd2UVe6fCPbDDo5jIy6uuuJovybWUcjn+nmNtLNsXdSULlVent+AwetXAo3nO2latq8WuVdIkllEUcsnd6/atv/2W2ba7bdWjG22i+Cl37vR6l/Ytbgd4vHRdjPFkRxXopDJ+u8kfqOqo5b1a7zbFzXEWG0sj+d7kM6Icw1ebXBhsplRXqBBhx6RL10K0lPSdeoWvsTRfqrRpdtNhVq3Km6GvlMN7eRbo69k8KUj5e6LFeWoknlPSZJZdGLaWOrbadaOs4wn42iXyym3yM4hW+tz9bT6eOok3XeaH1HUcetatd5Ns7riGY/GyamTvchndDsNXmYdYh0Iw049Ih66VaSnpKuUbX2J4r0V40u22wq1LhTdTXymW5uI90ceyeFKR8vdVmmLEWTyntMksqiF9PGVttOtXScYT4bRb9YTL9HcArfWp+tp9PHUSfrvNH6jqKOW9Wu82yc1xHNfraR1LVRxpJ0zV6Th1mHSDfSgEOPqJduJekp6RpVa3+C3sumLDClW6OpssKmzWsk3ka23+g6GvlMN7eRbo69k8KkXLw7NctLL1aSoknlPSZJZdGLaWOrbT8oHWflMo2k6GukXwQv/d7J+a+yYeDzVVOX1Tu+ojgvxaGTdd5IfUdVx61q13k2ruuIMFrZn073IZ0Q5po86HoyaFmRXpDpdAASjcLEMtVmxK33frcJsz9RZ6koLNtMloooyr+ZdTTymW5uI90ceydVllu1LBWHHjANWFz1c/1c3kkqizhi6fT+1dr+vLfs3FSWimb7xcosFR9ZdDz7NtD/dkuWik7Wedj6jrKO44w5yrjiuI5oNUtFmJg63Yd0QthrcmWpkH6hLBUiIiIiIiIi0pRaWSp0h0MCVObqfc/eU7nx/i2hcn4H5QefXPFXyjCjpvXyjDeSZ7lWLK/LppiYTYfOlR627JrJj96qqHKFS7TCln+UbadaXvNqx/PkBv4aG2XcYfKvq82O123Hejv6xcoc8mHv9opKmDqp1q47UZ9h4kqibos76jrsdDsPG1fh2uq5V0YwIOhPic38Bb1b+76kxVWQ9Pg6pdFy6YVyrDyGSyWln4mS7nBoh82rvRms/Rz2parlRJ5rG1mQGmRVfoC1biYQLrdxkLm2kePS3gza19lhnHLYXhw64f5iPFetG+LSK6/ggPw9rMoPABS3PTGT5pO7P8qPH92dP47sVVxnFLFcObqQwcyAt55dhuDOnwIGs08MfB62zObV3HvrdVx6z8vskH+hrJwK8Z1/2GjZflZbT7W6qaWwvwO5weL+bLQ9WfzGp3h4y8usz72Fne0lVuUHxvYxqo6jyZhDr6v0NYhuW63GFULYfN+12msrec2DjtvS14Cy9g/esbYutd+44zLs/hXWvy61Hx857viqcdfa58q4D84+yOn7PcO+e+0B255pf/23KsJjpNA/LnY3AWP91vHvmMYVdwyVlWdZuT2xntD9WVQxB/SLQPX+H8JtsyK2m393HbffeDVP53dgv9QmwCuXu1OzWP6h2dH0dZtXj50T3jR7rDzfNJuH7r6F1Q8/y/rcW4rb32h78q7dU+POVVB+jOz1jvdwxR1DDOQGi21+MDPA3+79HC9vuIk/jOxd9ZzbrFrHbeE8m8TjrVrcta4nOils/9/I+pb9/M5x6QsPzPyJM9/+3Pj6ivLc3ERchTb1rNuheP1Rel1UWncbbU8+st/2Ndvczb+7jjtuvmbcMVGt7zt7z7vZc+oO4fu8iEVd/1ELulYIe+7vZaXX06V9crVr+IbrudXjMobjuvQcWnqslp4XIj2ftkmtOxw04BC3zau9HN2jw95M1hWTSx1y7g0MVaS+mWsbuWTCOWTJMUKGJcOnFTv7aZMnccuph1f9bKW5tpGfTTiLCeQAGCENlmKC5YvxfPbiNXzntTPIkmPUn0c0Tb7s58o4oohlmAwnDp/OLjtO5ILRM7wyAkhPhKXX1h4kuOgYcrlXSTtHHmOYbFl8c20jP514DtvZaGC5l66nWt3Ucsi5N7Dr83eW7U+l0rie3Gl2saxa0kLModYFY6+l0oBBPtf6tlqNq4F6CWqHpW211nLVlg+zzaDjFii+NkoKw5HFO0mOkMZhxWPNzMqOy6B9roy7cptfmPh1Ljjtrxoqm8p1fH3k45yRvZisjZDBgaW8Y7Jd9d+qKI8R4LPn/Dvfe+2r4/qtO5lVlqqvWI6Fciuo159FFXNAv5gjPa7NFfv/sMd3ZWzvPZdXr11GxnktuKBQLpH0dZtXw4WLx84JFVzxf+WqnQtK2/fHR75C3rngNl/nnNusWsdt8Txro4k73oLirnc90cmYw/b/raxv3HFeqK/3ngu/OjWyfqfpuPwzS+WxUFl3AHmDNAS3uc2refWHi8m48cdE4a6p0m3/bMJZTLAcBuH6vBhEXf9RC7pWCHvu72WF6+nKPvnMCRcHXsM3VM+tnlsjvp4orNM7tsqP1aDzUGTfHdqk1oCDslTEbdNKr6GW5LAvFZRnt5jf2/JkybEgNRi4fJgcvQtSg2QYxQzMIMMoGTdSFs9bX15f3F6G0cCfK+OIKpYFqUHe+vJ6GC25pahKTvMiv0wLF/Vpc+PiW5AaJONyVcu9dD01l6nisa3bxu0PUPZzaVyR5VNuIeZQ6yp7bSS6bbUaV0hh833Xq49m8poHHbelr2UYHdf+y96rOC7DxFW5zbe+vL7hfapcx1Hp1d7vhW90Lt/e+m9VlMcI8NaX1wf2W6MVg/XFcqz8JhwmhihiDugXg9rcWDsLeXxXxjZ4NRmXI2PedirLJZK+btPK8nNCBaN+n1tQ2b7n233V23ydc26zah23xX4ggcdbUNz1ric6KWz/38r6xh3nhfoavLpt58va143B10VB1yvFHApBbW7TSv84H39MBPV9GUYp5lzoUFuIuv6jFnStkLRjqBMK19OVfXK1a/iG6rnVc2vE1xOFdZaeQwvHatB5KCltNwoacIjbjIXeqFhJDvtSQXl2i/m9XYoRMsXbYiuXD5Ojd1V+gBxpnAPnIEeanGXL4nlg+znF7eVIB/5cGUdUsazKD/DA9nMgnR1bsEpO8yK/TP2xdHLOxsW3Kj9AzjJVy710PTWXqWK3yZPG7Q9Q9nNpXJHlU24h5lDrKnstG922Wo0rpLD5vuvVRzN5zYOO29LXcqTHtf+y9yqOyzBxVW7zge3nNLxPlev45eh87/fC5aOl2lv/rYryGAEe2H5OYL+VNitbrliOlL8eKoYoYg7oF4Pa3Fg7C3l8V8Y2cCw5y5Bz3nYqyyWSvm7GwvJzQgVH/T63oLJ9r3b7VG/zdc65zap13Bb7gQQeb0Fx17ue6KSw/X8r6xt3nBfqa+DYtp0va183Bl8XBV2vFG9ID2pzMxb6x/n4YyKo78uV3u/UobYQdf1HLehaIWnHUCcUrqcr++Rq1/AN1XOr59aIrycK6yw9hxaO1aDzUFLabhT0SEU7aA6HwFg0h0OTNIdDVZrDQXM4AJrDQXM4lK1Kczg0R3M4aA4HzeEQHc3hEExzOGgOh8To+gGHOpSlQlkqJDrKUtF4nN0w+3wndduxriwVylIRlW6LW1kqlKUiiXEVJD2+TlGWinJJ6WcalbgBBzN7L/AdvEfI/ss5d26t5Xt9wAHivUCM6sAMirH0xFZ6Mit8ySrdJhDrhUu1AY96X/7aNUBRK+5qnU6pZi4W+lVpW4jy4qvadpo5thqJsdpx1om4G92HUmrD0g6NDKwB475QLt7/zVx75+PF1+Jot71wwdxvap2rO9m3NTrIrjbXPmGuS/u1HpoZNCvVrV/Ke/k4TNSAg5mlgY3AXwCPArcDJzrn7qv2mZ4YcCjckjNpStmtoTyxnoeefoULH3w9M91DANyTn9Hc7fgBt6A+9PQrfOXB/Wo+DhFmvYXbdCtjfNaN3VJ7T35G1Z/fntoEBlfkFpbdal56a2at28Gbja/yluLKuJou5yhuz5o0hYfuvoU/PvQMd4/OKLs1GSjeGhlJvGEeV6m2X6Vtd9szY/9W3kZa+jo09ohMhCpvga/VLktvx1665/MN3Q4atJ03Zl7mHYcew6FHLC5fuKJsK28JrPbYRb3jrHhb7DsXhy7jwm2yT+W2L66n7NboyvoNUuWYC9MXxPqoUb02V/m4UNAt+7NP9N7rxKNEtdQ4hxR/DlFvVY/xVo/XGo9ANPRzi/1Fvcf7So+1dMqYb/fxTMltrRDc9zbdV1SWy7ZnuHl4b065KR18S/AuQ/X74TaWZ919a+Q4qXX8Fc4tjbTnWttp5ZxX+X7FuTroFujSxxia7tuaOA7r3o7ul2lL14JtelSk11TWTaGNlLYVgHdl7w++buhhpY8FVV7/VB5PUP0a/u3pTRy81y7secSn65/zE9B2az4OUq3v7yJJG3A4GDjTObfI//3LAM65b1b7TNcPOBTSquReA/Lj3g5K8dVwSsUqacQcMOy8dGXVUlqGib2Qaq08xsZnHS2kTgPGpcj8PxP/qWpKv+biG58WrlJT5RxFih2/LQTV/Vi6xNGytHNNx1vaLqqlq6q2X+Parj/uXJkKrPC+pSCV8Walyo/U3mZMKtMYhmY0lNIraDt5jBHLst2nriufE6OibA+55KViWqdxKbIq2mu94yxvRjqzXbi2WJGOqaCY3o5RivVYLTVfjWMujNjSxdZr56X1kEqXt9FSqay3/+1OB1tLnXNIUYh6CzzGw/QR9eKrkcayIS32F7VS3gamo/T72cL5ovS1qsL2FUHlYiledRk+9lp5mmmAI1//CBfkvxGiH25AXP1vo+fCusdfwN80m0kR2uo5r/L9gHP1+DR241NRNty3NXkc1kwpSI5Ce2n6WjCOtIB9orxuCm3EO5+X9zd5cpYpv27ocdVShML4PrnWNTzg9cf1zvkJabvVzk9V+/4uk7S0mNOAzSW/P+q/VsbMPmtma8xszZYtW9oWXCwKaVWqXCgU5vttKaVilTRixli6slKhU61UpForj3F83PV+LsQSlF6rVkq/5uIbnxYuaJnGyzmCFDt+WwhK7zaWLjF4n1pqF42mCB3XdqukAiu87/Le9vIhthmTyjSGELKNNhhv0HbS5rxUThXpxSrLtrTuaqXO9NZZO+40LnwZV6RjGpferqwea7eVoGMuzM/xpYut0+YqU74GDTaA93on0sHWUuccUhSi3oKP8RaP1zppLBvSYpnXalOB6ShLUpPV6nub6iuCysXlybjxaaYBP0V0mH64AXG14UbPhXWPv4ABnmZShLZ6zqt8P+BcPT6N3fhUlA33bU0ehzVTCpa0l6avBeNIC9gnyuum0Ebw/y3tb/Ljrxt6XLUUoUF9ct3rOQhxzk9G2612vFXt+3tIYtNiOucucM7Nc87Nmzp1aqfDaU0hrUqV4i6cZltKqVgljZhjLF1ZqdCpVipSrZXHOD7uej8XYglKr1UrpV9z8Y1PCxe0TOPlHEGKHb8tBKV3G0uXGLxPLbWLRlOEjmu7hV6+IhVY4X1LedtLNZDmNGKVaQwhZBttMN6g7eSceamcKtKLVZZtad3VSp3prbN23KNY+DKuSMc0Lr1dWT3WbitBx1yYn+NLF1unzVWmfE1VSbuY6lA62FrqnEOKQtRb8DHe4vFaJ41lQ1os81ptKjAdZUlqslp9b1N9RVC5WIqcjU8zDfgposP0ww2Iqw03ei6se/zZ+M80kyK01XNe5fsB5+rxaeys7PWm+rYmj8OaKQVL2kvT14JxpAXsE+V1U2gj+P+W9jep8dcNPa5aitCgPrnu9RyEOOcno+1WO96q9v09RI9UtIvmcEBzOFR8XnM4xEJzONSmORw0h4PmcNAcDpHQHA6aw0Gq0hwO1WkOB83h0I5gMniTRh4BDOFNGvkx59y91T7TEwMOdShLhbJUKEtFdJSlIr64G92HUmrD0g7KUiFxUJYKaZSyVFSnLBW9dxwmasABwMzeB3wbLy3mj5xzZ9davh8GHERERERERES6Ta0Bh0y7gwFwzl0PXN+JbYuIiIiIiIhI/BI7aaSIiIiIiIiIdC8NOIiIiIiIiIhI5DTgICIiIiIiIiKR04CDiIiIiIiIiEROAw4iIiIiIiIiEjkNOIiIiIiIiIhI5DTgICIiIiIiIiKRM+dcp2Ooy8y2AI90Oo4m7AI83ekgpGepfUmc1L4kbmpjEie1L4mb2pjEqdva11ucc1OD3uiKAYduZWZrnHPzOh2H9Ca1L4mT2pfETW1M4qT2JXFTG5M49VL70iMVIiIiIiIiIhI5DTiIiIiIiIiISOQ04BCvCzodgPQ0tS+Jk9qXxE1tTOKk9iVxUxuTOPVM+9IcDiIiIiIiIiISOd3hICIiIiIiIiKR04BDDMzsvWa2wcweMLNTOx2PdCcz+5GZPWVm95S8trOZ/cbM/uT/+wb/dTOz7/pt7i4zm9u5yKUbmNl0M7vRzO4zs3vN7Av+62pj0jIz287MVpvZnX77+rr/+h5mdpvfji41swn+6xP93x/w35/R0R2QrmBmaTNbZ2bX+r+rfUlkzGyTmd1tZuvNbI3/ms6REhkzm2xml5vZ/WY2aGYH92Ib04BDxMwsDXwfOArYBzjRzPbpbFTSpS4E3lvx2qnA75xzbwN+5/8OXnt7m//fZ4EftClG6V454B+cc/sAC4C/9vsqtTGJwmvA4c652cAc4L1mtgD4Z+BfnXNvBZ4DPuUv/yngOf/1f/WXE6nnC8Bgye9qXxK19zjn5pSkJ9Q5UqL0HeBXzrm9gdl4/VnPtTENOERvPvCAc+4h59ww8D/AsR2OSbqQc+73wLMVLx8LXOT/fBHwgZLXf+I8q4DJZvbmtgQqXck597hzbq3/84t4J7lpqI1JBPx28pL/a9b/zwGHA5f7r1e2r0K7uxw4wsysPdFKNzKz3YHFwH/5vxtqXxI/nSMlEma2E/Bu4IcAzrlh59xWerCNacAhetOAzSW/P+q/JhKFXZ1zj/s/PwHs6v+sdidN828vPgC4DbUxiYh/u/t64CngN8CDwFbnXM5fpLQNFduX//7zwJS2Bizd5tvAPwJ5//cpqH1JtBzwazO7w8w+67+mc6REZQ9gC/Bj/9Gw/zKz7enBNqYBB5Eu5bwUM0ozIy0xsx2AK4C/dc69UPqe2pi0wjk36pybA+yOd/ff3p2NSHqFmR0NPOWcu6PTsUhPe5dzbi7erex/bWbvLn1T50hpUQaYC/zAOXcA8DJjj08AvdPGNOAQvSFgesnvu/uviUThycLtU/6/T/mvq91Jw8wsizfYcIlz7kr/ZbUxiZR/i+iNwMF4t4Bm/LdK21Cxffnv7wQ8095IpYscAhxjZpvwHl09HO9ZaLUviYxzbsj/9yngF3gDpzpHSlQeBR51zt3m/3453gBEz7UxDThE73bgbf5MyROAjwLXdDgm6R3XACf5P58EXF3y+if8GWwXAM+X3I4lMo7//PIPgUHn3LdK3lIbk5aZ2VQzm+z/PAn4C7x5Qm4EPuQvVtm+Cu3uQ8AN/l92RMZxzn3ZObe7c24G3nXWDc65Jah9SUTMbHsz27HwM3AkcA86R0pEnHNPAJvNbJb/0hHAffRgGzP1t9Ezs/fhPVuYBn7knDu7sxFJNzKznwGHAbsATwJnAFcBlwF/BjwCfNg596z/5fHf8LJavAJ80jm3pgNhS5cws3cBK4G7GXsG+jS8eRzUxqQlZrY/3mRXabw/blzmnPuGme2J9xfpnYF1wP/nnHvNzLYDLsabS+RZ4KPOuYc6E710EzM7DPiic+5otS+Jit+WfuH/mgF+6pw728ymoHOkRMTM5uBNfDsBeAj4JP45kx5qYxpwEBEREREREZHI6ZEKEREREREREYmcBhxEREREREREJHIacBARERERERGRyGnAQUREREREREQipwEHEREREREREYmcBhxERERkHDO7tcnPfcDM9ok6HhEREek+GnAQERGRcZxz72zyox8ANOAgIiIiGnAQERGR8czsJf/fw8zsJjO73MzuN7NLzMz89841s/vM7C4zO8/M3gkcAyw3s/VmtpeZfcbMbjezO83sCjN7nf/ZC83su2Z2q5k9ZGYfKtn2l8zsbv8z5/qv7WVmvzKzO8xspZnt7b9+gpnd4y/7+3aXk4iIiFSX6XQAIiIikngHAPsCjwG3AIeY2SDwQWBv55wzs8nOua1mdg1wrXPucgAz2+qc+0//57OATwHf89f7ZuBdwN7ANcDlZnYUcCxwkHPuFTPb2V/2AuAU59yfzOwg4N+Bw4GvAYucc0NmNjnmchAREZEGaMBBRERE6lntnHsUwMzWAzOAVcCrwA/N7Frg2iqf3c8faJgM7ACsKHnvKudcHrjPzHb1X/tz4MfOuVcAnHPPmtkOwDuBn/s3VwBM9P+9BbjQzC4DrmxxP0VERCRCGnAQERGRel4r+XkUyDjncmY2HzgC+BDwN3h3HFS6EPiAc+5OM1sKHFZlvUZ1KWCrc25O5RvOuVP8Ox4WA3eY2Tucc8/U3SMRERGJneZwEBERkYb5dx3s5Jy7Hvg7YLb/1ovAjiWL7gg8bmZZYEmIVf8G+GTJXA87O+deAB42sxP818zMZvs/7+Wcu8059zVgCzA9gt0TERGRCGjAQURERJqxI3Ctmd0F/AH4e//1/wGWmdk6M9sL+CpwG96jD/fXW6lz7ld48zms8R/f+KL/1hLgU2Z2J3Av3jwP4E1QebeZ3QPcCtwZxc6JiIhI68w51+kYRERERERERKTH6A4HEREREREREYmcBhxEREREREREJHIacBARERERERGRyGnAQUREREREREQipwEHEREREREREYmcBhxEREREREREJHIacBARERERERGRyGnAQUREREREREQi9/8D4sGTDOW87x4AAAAASUVORK5CYII=\n","text/plain":["<Figure size 1296x360 with 1 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["y_pred_all = np.rint(all_stations_model.predict(X_val))\n","\n","def plot_results(y_pred, title):\n","    fig, ax = plt.subplots(1, 1, figsize=(18, 5))\n","\n","    plt.plot(y_val[:600], \"o\", label=\"True values\")\n","    ax.plot(y_pred[:600], \".\", label=\"Predictions\")\n","    ax.set_xlabel(\"instances\")\n","    ax.set_ylabel(\"# bikes\")\n","    ax.legend(loc=\"best\")\n","    ax.set_title(\n","        title+\"\\nMAE = {:.2f}\".format(\n","            mae(y_val, y_pred).numpy()\n","        )\n","    );\n","\n","plot_results(y_pred_all, title=\"One model (\"+model_name+\") for all stations\");"]},{"cell_type":"code","execution_count":10,"id":"16f9700f","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:42:46.957096Z","iopub.status.busy":"2022-01-25T02:42:46.764857Z","iopub.status.idle":"2022-01-25T02:42:47.033393Z","shell.execute_reply":"2022-01-25T02:42:47.032886Z","shell.execute_reply.started":"2022-01-25T02:25:51.263035Z"},"papermill":{"duration":0.294621,"end_time":"2022-01-25T02:42:47.033583","exception":false,"start_time":"2022-01-25T02:42:46.738962","status":"completed"},"tags":[]},"outputs":[{"data":{"text/plain":["['all_stations_model.pkl']"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["## Save the model\n","joblib.dump(all_stations_model, 'all_stations_model.pkl')"]},{"cell_type":"markdown","id":"de1b1dc3","metadata":{"papermill":{"duration":0.023194,"end_time":"2022-01-25T02:42:47.079558","exception":false,"start_time":"2022-01-25T02:42:47.056364","status":"completed"},"tags":[]},"source":["# Predictions with per-station models\n","\n","Using the per-station models we've learned so far, let's make predictions (on the same validation set) and compare the results to the only model for all stations above."]},{"cell_type":"code","execution_count":11,"id":"311f1ff8","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:42:47.131264Z","iopub.status.busy":"2022-01-25T02:42:47.130599Z","iopub.status.idle":"2022-01-25T02:42:47.132955Z","shell.execute_reply":"2022-01-25T02:42:47.13225Z","shell.execute_reply.started":"2022-01-25T02:25:51.498213Z"},"papermill":{"duration":0.029858,"end_time":"2022-01-25T02:42:47.133109","exception":false,"start_time":"2022-01-25T02:42:47.103251","status":"completed"},"tags":[]},"outputs":[],"source":["# y_pred_per = np.zeros_like(y_val)\n","\n","# for i in range(len(y_val)):\n","#     station_id = stations[i]\n","#     y_pred_per[i] = np.rint(per_station_models[station_id].predict([X_val[i]]))\n","    \n","# plot_results(y_pred_per, title=\"One different model per-station\");"]},{"cell_type":"code","execution_count":12,"id":"4b2312c6","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:42:47.182292Z","iopub.status.busy":"2022-01-25T02:42:47.181132Z","iopub.status.idle":"2022-01-25T02:42:47.185229Z","shell.execute_reply":"2022-01-25T02:42:47.18471Z","shell.execute_reply.started":"2022-01-25T02:25:51.502929Z"},"papermill":{"duration":0.029628,"end_time":"2022-01-25T02:42:47.185382","exception":false,"start_time":"2022-01-25T02:42:47.155754","status":"completed"},"tags":[]},"outputs":[],"source":["## Save the models\n","# joblib.dump(per_station_models, 'per_station_models.pkl')"]},{"cell_type":"markdown","id":"0c65d952","metadata":{"papermill":{"duration":0.022166,"end_time":"2022-01-25T02:42:47.230054","exception":false,"start_time":"2022-01-25T02:42:47.207888","status":"completed"},"tags":[]},"source":["# Comparing the two approaches"]},{"cell_type":"markdown","id":"b87bc7c0","metadata":{"papermill":{"duration":0.021897,"end_time":"2022-01-25T02:42:47.274325","exception":false,"start_time":"2022-01-25T02:42:47.252428","status":"completed"},"tags":[]},"source":["## Should we shuffle the data ?\n","For this first comparison, we will restrict the models to a single category, and for each category (or learning algorithm), we will study the effect of shuffling the data. To better illustrate the rift between these two strategies, we used 80% of the available data for training, and the remaining 20% for validating: \n","\n","- **Without shuffling the data**: models are trained on the 25 first days of the month, and validated on the remaining 6 days:\n","\n","| Algorithm      | All-stations | Per-station |\n","| :---        |    :----:   |          :---: |\n","| Linear Regression - 1      | 2.66       |2.63|\n","| Linear Regression - 2   |    2.61     |2.54|\n","| Linear Regression - 3   |    2.54     |2.70|\n","| K-Nearest Neighbors   |    3.21     |3.20|\n","| Decision Tree   |    3.38     |3.40|\n","| Random Forest   |    3.05    |3.17|\n","| SVM - One vs. Rest   |   4.05      |3.48|\n","| SVM - One vs. One   |    2.90     |3.12|\n","| Poisson Regression   |    4.40     |3.56|\n","\n","- **When shuffling the data**: the training data contains some hours of every day of the month, and the same goes for the validation data:\n","\n","| Algorithm      | All-stations | Per-station |\n","| :---        |    :----:   |          :---: |\n","| Linear Regression - 1      | 2.70       |2.53|\n","| Linear Regression - 2   |    2.61     |2.36|\n","| Linear Regression - 3   |    2.60     |2.25|\n","| K-Nearest Neighbors   |    3.26     |1.58|\n","| Decision Tree   |    3.35     |0.57|\n","| Random Forest   |    3.12    |0.50|\n","| SVM - One vs. Rest   |   3.91      |3.02|\n","| SVM - One vs. One   |    2.86     |2.43|\n","| Poisson Regression   |    4.44     |3.31|\n","\n","The conclusion we draw after these comparisons is that training multiple models (one for each station) is almost always better than training a single model for all stations. This is especially true when the training data is representative of the whole dataset (with shuffling). When this is not the case (without shuffling), we observe exceptions with some models (Decision Trees, Random Forest, etc.) that perform better when trained on all stations together. Considering that those are also the most computationally costly models, we opted in the next Phases to use the per-stations models trained on unshuffled data. "]},{"cell_type":"markdown","id":"52e9c6b5","metadata":{"papermill":{"duration":0.022053,"end_time":"2022-01-25T02:42:47.318853","exception":false,"start_time":"2022-01-25T02:42:47.2968","status":"completed"},"tags":[]},"source":["## Linear Regression models with Peter's Features\n","One of the best algorithms for this task is clearly the classic version of linear regression (`Linear Regression - 1` where the features are *not* raised to a power before fitting the algorithm). We've only used the `short_full_temp` feature set so far, and the table below shows that the choice of feature set hardly changes the results.\n","\n","| Features      | All-stations | Per-station |\n","| :---        |    :----:   |          :---: |\n","| short      |   2.57     |2.46|\n","| short_temp   |    2.57     |2.47|\n","| full   |    2.57     |2.46|\n","| full_temp   |   2.57      |2.47|\n","| short_full   |   2.57      |2.45|\n","| short_full_temp   |   2.57     | 2.47 |"]},{"cell_type":"markdown","id":"9b7c4113","metadata":{"papermill":{"duration":0.021883,"end_time":"2022-01-25T02:42:47.363175","exception":false,"start_time":"2022-01-25T02:42:47.341292","status":"completed"},"tags":[]},"source":["## With a wide range of different models\n","\n","Each station is now trained on all 9 possible learning algorithms, and only the best model is kept for that station. The same goes for the model for all stations together. As we see in the table below, shuffling produces better results. However, as we have discussed in the previous notebook, not shuffling the data prepares our models for the competition by taking **data drifting** into account. This is why we did not shuffle the data for our submissions for the competition.\n","\n","|       | **All-stations** | **Per-station**  |\n","| :---        |    :----:   |          :---: |\n","|    Without shuffling   |   2.54     |2.45|\n","|   When shuffling |    2.53    |1.55|"]},{"cell_type":"markdown","id":"4c465aa7","metadata":{"papermill":{"duration":0.021754,"end_time":"2022-01-25T02:42:47.407071","exception":false,"start_time":"2022-01-25T02:42:47.385317","status":"completed"},"tags":[]},"source":["# Predictions for the competition\n","\n","Now, we will generate and save predictions for the Kaggle competition. As we have stated over the course of this notebook, other quantities have been saved and will be needed to run the final phases of the competition in the next notebook."]},{"cell_type":"code","execution_count":13,"id":"e2a8a604","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:42:47.458991Z","iopub.status.busy":"2022-01-25T02:42:47.458124Z","iopub.status.idle":"2022-01-25T02:42:47.494933Z","shell.execute_reply":"2022-01-25T02:42:47.494369Z","shell.execute_reply.started":"2022-01-25T02:25:51.516257Z"},"papermill":{"duration":0.065858,"end_time":"2022-01-25T02:42:47.495092","exception":false,"start_time":"2022-01-25T02:42:47.429234","status":"completed"},"tags":[]},"outputs":[{"data":{"text/plain":["(2250, 18)"]},"execution_count":13,"metadata":{},"output_type":"execute_result"}],"source":["def make_test_data():\n","    df = pd.read_csv(INPUT_DIR+'/test.csv')\n","    \n","    station_ids = df['station']\n","    \n","    df = preprocess(df)\n","    \n","    ids = df['Id']\n","    df = df.drop(['Id'], axis=1)\n","    \n","    df = select_peters_features(df)\n","    \n","    return np.array(df), np.array(ids), np.array(station_ids)\n","    \n","X_test, ids, station_ids = make_test_data()\n","X_test.shape"]},{"cell_type":"code","execution_count":14,"id":"507fbacb","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:42:47.546316Z","iopub.status.busy":"2022-01-25T02:42:47.545174Z","iopub.status.idle":"2022-01-25T02:42:47.549368Z","shell.execute_reply":"2022-01-25T02:42:47.548874Z","shell.execute_reply.started":"2022-01-25T02:25:51.569387Z"},"papermill":{"duration":0.031621,"end_time":"2022-01-25T02:42:47.54953","exception":false,"start_time":"2022-01-25T02:42:47.517909","status":"completed"},"tags":[]},"outputs":[],"source":["## Save this data for later testing in Phases 2 and 3\n","np.save('X_test.npy', X_test)\n","np.save('ids_test.npy', ids)\n","np.save('stations_test.npy', station_ids)"]},{"cell_type":"code","execution_count":15,"id":"21b995fb","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:42:47.601935Z","iopub.status.busy":"2022-01-25T02:42:47.601169Z","iopub.status.idle":"2022-01-25T02:42:47.738951Z","shell.execute_reply":"2022-01-25T02:42:47.73836Z","shell.execute_reply.started":"2022-01-25T02:25:51.577738Z"},"papermill":{"duration":0.166298,"end_time":"2022-01-25T02:42:47.739095","exception":false,"start_time":"2022-01-25T02:42:47.572797","status":"completed"},"tags":[]},"outputs":[{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>Id</th>\n","      <th>bikes</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>1</td>\n","      <td>0.0</td>\n","    </tr>\n","    <tr>\n","      <th>1</th>\n","      <td>2</td>\n","      <td>1.0</td>\n","    </tr>\n","    <tr>\n","      <th>2</th>\n","      <td>3</td>\n","      <td>5.0</td>\n","    </tr>\n","    <tr>\n","      <th>3</th>\n","      <td>4</td>\n","      <td>4.0</td>\n","    </tr>\n","    <tr>\n","      <th>4</th>\n","      <td>5</td>\n","      <td>4.0</td>\n","    </tr>\n","    <tr>\n","      <th>...</th>\n","      <td>...</td>\n","      <td>...</td>\n","    </tr>\n","    <tr>\n","      <th>2245</th>\n","      <td>2246</td>\n","      <td>14.0</td>\n","    </tr>\n","    <tr>\n","      <th>2246</th>\n","      <td>2247</td>\n","      <td>14.0</td>\n","    </tr>\n","    <tr>\n","      <th>2247</th>\n","      <td>2248</td>\n","      <td>6.0</td>\n","    </tr>\n","    <tr>\n","      <th>2248</th>\n","      <td>2249</td>\n","      <td>14.0</td>\n","    </tr>\n","    <tr>\n","      <th>2249</th>\n","      <td>2250</td>\n","      <td>14.0</td>\n","    </tr>\n","  </tbody>\n","</table>\n","<p>2250 rows × 2 columns</p>\n","</div>"],"text/plain":["        Id  bikes\n","0        1    0.0\n","1        2    1.0\n","2        3    5.0\n","3        4    4.0\n","4        5    4.0\n","...    ...    ...\n","2245  2246   14.0\n","2246  2247   14.0\n","2247  2248    6.0\n","2248  2249   14.0\n","2249  2250   14.0\n","\n","[2250 rows x 2 columns]"]},"execution_count":15,"metadata":{},"output_type":"execute_result"}],"source":["\"\"\" If we chose to all stations at once \"\"\"\n","y_pred = all_stations_model.predict(X_test)\n","\n","\"\"\" If we chose one model per-station \"\"\"\n","# y_pred = np.zeros((len(X_test)))\n","# for i in range(len(X_test)):\n","#     station_id = station_ids[i]\n","#     y_pred[i] = per_station_models[station_id].predict([X_test[i]])\n","\n","# np.unique(y_pred)\n","results = pd.DataFrame({'Id':ids, 'bikes':np.rint(y_pred)})\n","results"]},{"cell_type":"code","execution_count":16,"id":"13961390","metadata":{"execution":{"iopub.execute_input":"2022-01-25T02:42:47.793603Z","iopub.status.busy":"2022-01-25T02:42:47.79293Z","iopub.status.idle":"2022-01-25T02:42:47.806546Z","shell.execute_reply":"2022-01-25T02:42:47.807016Z","shell.execute_reply.started":"2022-01-25T02:25:51.728248Z"},"papermill":{"duration":0.04327,"end_time":"2022-01-25T02:42:47.807187","exception":false,"start_time":"2022-01-25T02:42:47.763917","status":"completed"},"tags":[]},"outputs":[{"data":{"text/plain":["['X_test.npy',\n"," 'X_val.npy',\n"," 'ids_test.npy',\n"," '__notebook__.ipynb',\n"," 'stations_val.npy',\n"," 'stations_test.npy',\n"," 'all_stations_model.pkl',\n"," 'roussel_subin_submission.csv',\n"," 'y_val.npy']"]},"execution_count":16,"metadata":{},"output_type":"execute_result"}],"source":["results.to_csv('/kaggle/working/roussel_subin_submission.csv', index=False)\n","\n","## View all assets that will be needed for phases 2 and 3\n","os.listdir('/kaggle/working/')"]}],"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.12"},"papermill":{"default_parameters":{},"duration":516.797763,"end_time":"2022-01-25T02:42:48.943707","environment_variables":{},"exception":null,"input_path":"__notebook__.ipynb","output_path":"__notebook__.ipynb","parameters":{},"start_time":"2022-01-25T02:34:12.145944","version":"2.3.3"}},"nbformat":4,"nbformat_minor":5}