{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "6b9d75fc", "metadata": {}, "outputs": [], "source": [ "import xgboost as xgb\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import mean_absolute_error as MAE" ] }, { "cell_type": "code", "execution_count": 2, "id": "cc5beb78", "metadata": {}, "outputs": [], "source": [ "N = 10794\n", "\n", "filenames = ['minDist200m_approx.parquet',\n", " 'minDist500m_approx.parquet',\n", " 'minDist1km_approx.parquet',\n", " 'minDist3km_approx.parquet',\n", " 'minDist5km_approx.parquet',\n", " 'minDist7km_approx.parquet',\n", " 'minDist10km_approx.parquet',\n", " 'minDist15km_approx.parquet',\n", " 'minDist20km_approx.parquet',\n", " 'minDist30km_approx.parquet',\n", " 'minDist35km_approx.parquet']\n", "\n", "# filenames = ['minDist3km_approx.parquet']" ] }, { "cell_type": "code", "execution_count": 3, "id": "49a139c4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "processing file: minDist200m_approx.parquet\n", "processing file: minDist500m_approx.parquet\n", "processing file: minDist1km_approx.parquet\n", "processing file: minDist3km_approx.parquet\n", "processing file: minDist5km_approx.parquet\n", "processing file: minDist7km_approx.parquet\n", "processing file: minDist10km_approx.parquet\n", "processing file: minDist15km_approx.parquet\n", "processing file: minDist20km_approx.parquet\n", "processing file: minDist30km_approx.parquet\n", "processing file: minDist35km_approx.parquet\n" ] } ], "source": [ "inputs = ['vx', 'vy', 'v', 'smb', 'z', 's', 'temp']\n", "\n", "MEANS = []\n", "INTERVALS = []\n", "N_samp = 4\n", "from scipy.stats import t\n", "t_value = t.ppf(0.975, df=N_samp-1)\n", "\n", "for filename in filenames:\n", " print('processing file:', filename)\n", " mean_maes = []\n", " for i in range(N_samp):\n", " data = pd.read_parquet(filename, columns = ['THICK', 'vx', 'vy', 'v', 'smb', 'z', 's', 'temp'])\n", " data = data.sample(N)\n", " target = data['THICK']\n", "\n", " mu = np.mean(target)\n", "\n", " target = (target - mu) / 1000\n", "\n", " Xtrain, Xtest, ytrain, ytest = train_test_split(data[inputs], target, test_size=0.2, random_state=42)\n", "\n", " model = xgb.XGBRegressor()\n", " model.fit(Xtrain, ytrain)\n", "\n", " ytest_meters = np.array(ytest * 1000 + mu)\n", " preds = model.predict(Xtest) * 1000 + mu\n", "\n", " # mae = MAE(ytest_meters, preds)\n", "\n", " n_bootstrap = 10000\n", " n_test_samples = len(ytest)\n", "\n", " maes = []\n", "\n", " for _ in range(n_bootstrap):\n", " # Create a bootstrap sample of indices from the test set\n", " bootstrap_indices = np.random.choice(n_test_samples, n_test_samples, replace=True)\n", "\n", " # Get the true and predicted values for this bootstrap sample\n", " y_true_bootstrap = ytest_meters[bootstrap_indices]\n", " y_pred_bootstrap = preds[bootstrap_indices]\n", "\n", " # Calculate MAPE for this bootstrap sample\n", " # Handle potential division by zero for MAPE if y_true_bootstrap can contain zeros\n", " # For robustness, you might want to add a small epsilon or use a different metric if zeros are common.\n", " # For now, assuming non-zero y_true for MAPE.\n", " current_mae = MAE(y_true_bootstrap, y_pred_bootstrap)\n", " maes.append(current_mae)\n", "\n", " # 3. Analyze the distribution of MAPEs\n", " mean_bootstrapped_mape = np.mean(maes)\n", " std_dev_bootstrapped_mape = np.std(maes)\n", "\n", " mean_maes.append(mean_bootstrapped_mape)\n", "\n", " std = np.std(mean_maes)\n", " mean = np.mean(mean_maes)\n", "\n", " lower = mean - t_value * std / np.sqrt(N_samp)\n", " upper = mean + t_value * std / np.sqrt(N_samp)\n", "\n", " MEANS.append(mean)\n", " INTERVALS.append((lower, upper))\n", "\n", " " ] }, { "cell_type": "code", "execution_count": 4, "id": "64c1f084", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "([np.float64(219.71600702690554),\n", " np.float64(221.95568110229394),\n", " np.float64(225.20711659724563),\n", " np.float64(234.09904722749985),\n", " np.float64(242.73952189110307),\n", " np.float64(244.78165238152948),\n", " np.float64(246.92594497216655),\n", " np.float64(256.9065720582111),\n", " np.float64(259.7788585419548),\n", " np.float64(261.78795878637084),\n", " np.float64(265.17033243487754)],\n", " [(np.float64(212.8349177211931), np.float64(226.59709633261798)),\n", " (np.float64(209.89354325783856), np.float64(234.01781894674932)),\n", " (np.float64(217.46373647116374), np.float64(232.95049672332752)),\n", " (np.float64(221.72703010535272), np.float64(246.47106434964698)),\n", " (np.float64(237.0747433035595), np.float64(248.40430047864663)),\n", " (np.float64(234.63312391501947), np.float64(254.9301808480395)),\n", " (np.float64(238.90972359624917), np.float64(254.94216634808393)),\n", " (np.float64(251.54701006842788), np.float64(262.26613404799434)),\n", " (np.float64(254.3588026929518), np.float64(265.1989143909578)),\n", " (np.float64(248.75349557277002), np.float64(274.82242199997165)),\n", " (np.float64(255.76308557956034), np.float64(274.57757929019476))])" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "MEANS, INTERVALS" ] }, { "cell_type": "code", "execution_count": 65, "id": "e25426df", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "48349\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
THICKvxvyvsmbzstemp
272293386.2500000.865702-2.4774222.62432051.5098723496.1077520.002632224.609177
163361685.3760003.717804-417.919596417.936132487.795838703.4456600.001437252.450467
440132358.1000003.1440335.8805386.668259151.4655011960.3676840.004441246.175460
321462548.690000-11.739543-6.70574613.51976020.8928462498.7189210.004913230.215486
13551723.000000289.773342-129.406338317.35562186.020222115.2465880.001939250.895980
...........................
465831608.644600-1.419614-0.5470951.52138725.0678293708.3518330.012573222.767952
45481626.380000-3.206802-16.71192417.016815113.9836332079.8878500.004253239.707678
5850823.3700000.181005-4.6592794.662794460.924433822.6781500.014722254.373908
24659592.726167-71.054724327.782682335.395677509.96545062.6710140.000863256.296374
375272969.210000-0.112218-2.2838752.28663043.8580043583.8830060.002459223.518175
\n", "

10794 rows × 8 columns

\n", "
" ], "text/plain": [ " THICK vx vy v smb \\\n", "27229 3386.250000 0.865702 -2.477422 2.624320 51.509872 \n", "16336 1685.376000 3.717804 -417.919596 417.936132 487.795838 \n", "44013 2358.100000 3.144033 5.880538 6.668259 151.465501 \n", "32146 2548.690000 -11.739543 -6.705746 13.519760 20.892846 \n", "13551 723.000000 289.773342 -129.406338 317.355621 86.020222 \n", "... ... ... ... ... ... \n", "46583 1608.644600 -1.419614 -0.547095 1.521387 25.067829 \n", "4548 1626.380000 -3.206802 -16.711924 17.016815 113.983633 \n", "5850 823.370000 0.181005 -4.659279 4.662794 460.924433 \n", "24659 592.726167 -71.054724 327.782682 335.395677 509.965450 \n", "37527 2969.210000 -0.112218 -2.283875 2.286630 43.858004 \n", "\n", " z s temp \n", "27229 3496.107752 0.002632 224.609177 \n", "16336 703.445660 0.001437 252.450467 \n", "44013 1960.367684 0.004441 246.175460 \n", "32146 2498.718921 0.004913 230.215486 \n", "13551 115.246588 0.001939 250.895980 \n", "... ... ... ... \n", "46583 3708.351833 0.012573 222.767952 \n", "4548 2079.887850 0.004253 239.707678 \n", "5850 822.678150 0.014722 254.373908 \n", "24659 62.671014 0.000863 256.296374 \n", "37527 3583.883006 0.002459 223.518175 \n", "\n", "[10794 rows x 8 columns]" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data = pd.read_parquet('minDist15km_approx.parquet', columns = ['THICK', 'vx', 'vy', 'v', 'smb', 'z', 's', 'temp'])\n", "print(len(data))\n", "data = data.sample(N)\n", "data" ] }, { "cell_type": "code", "execution_count": 66, "id": "604e836c", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
XGBRegressor(base_score=None, booster=None, callbacks=None,\n",
       "             colsample_bylevel=None, colsample_bynode=None,\n",
       "             colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
       "             enable_categorical=False, eval_metric=None, feature_types=None,\n",
       "             feature_weights=None, gamma=None, grow_policy=None,\n",
       "             importance_type=None, interaction_constraints=None,\n",
       "             learning_rate=None, max_bin=None, max_cat_threshold=None,\n",
       "             max_cat_to_onehot=None, max_delta_step=None, max_depth=None,\n",
       "             max_leaves=None, min_child_weight=None, missing=nan,\n",
       "             monotone_constraints=None, multi_strategy=None, n_estimators=None,\n",
       "             n_jobs=None, num_parallel_tree=None, ...)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "XGBRegressor(base_score=None, booster=None, callbacks=None,\n", " colsample_bylevel=None, colsample_bynode=None,\n", " colsample_bytree=None, device=None, early_stopping_rounds=None,\n", " enable_categorical=False, eval_metric=None, feature_types=None,\n", " feature_weights=None, gamma=None, grow_policy=None,\n", " importance_type=None, interaction_constraints=None,\n", " learning_rate=None, max_bin=None, max_cat_threshold=None,\n", " max_cat_to_onehot=None, max_delta_step=None, max_depth=None,\n", " max_leaves=None, min_child_weight=None, missing=nan,\n", " monotone_constraints=None, multi_strategy=None, n_estimators=None,\n", " n_jobs=None, num_parallel_tree=None, ...)" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "target = data['THICK']\n", "inputs = ['vx', 'vy', 'v', 'smb', 'z', 's', 'temp']\n", "\n", "mu = np.mean(target)\n", "\n", "target = (target - mu) / 1000\n", "\n", "Xtrain, Xtest, ytrain, ytest = train_test_split(data[inputs], target, test_size=0.2, random_state=42)\n", "\n", "model = xgb.XGBRegressor()\n", "model.fit(Xtrain, ytrain)" ] }, { "cell_type": "code", "execution_count": 67, "id": "b47529ef", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Mean bootstrapped MAPE: 253.4516\n", "Standard deviation of bootstrapped MAPEs: 5.7180\n", "95% Confidence Interval for MAPE: [242.4204, 264.7047]\n" ] } ], "source": [ "ytest_meters = np.array(ytest * 1000 + mu)\n", "preds = model.predict(Xtest) * 1000 + mu\n", "\n", "# mae = MAE(ytest_meters, preds)\n", "\n", "n_bootstrap = 10000\n", "n_test_samples = len(ytest)\n", "\n", "maes = []\n", "\n", "for _ in range(n_bootstrap):\n", " # Create a bootstrap sample of indices from the test set\n", " bootstrap_indices = np.random.choice(n_test_samples, n_test_samples, replace=True)\n", "\n", " # Get the true and predicted values for this bootstrap sample\n", " y_true_bootstrap = ytest_meters[bootstrap_indices]\n", " y_pred_bootstrap = preds[bootstrap_indices]\n", "\n", " # Calculate MAPE for this bootstrap sample\n", " # Handle potential division by zero for MAPE if y_true_bootstrap can contain zeros\n", " # For robustness, you might want to add a small epsilon or use a different metric if zeros are common.\n", " # For now, assuming non-zero y_true for MAPE.\n", " current_mape = MAE(y_true_bootstrap, y_pred_bootstrap)\n", " maes.append(current_mape)\n", "\n", "# 3. Analyze the distribution of MAPEs\n", "mean_bootstrapped_mape = np.mean(maes)\n", "std_dev_bootstrapped_mape = np.std(maes)\n", "\n", "# Calculate a 95% confidence interval using percentiles\n", "lower_bound_mape = np.percentile(maes, 2.5)\n", "upper_bound_mape = np.percentile(maes, 97.5)\n", "\n", "print(f\"\\nMean bootstrapped MAPE: {mean_bootstrapped_mape:.4f}\")\n", "print(f\"Standard deviation of bootstrapped MAPEs: {std_dev_bootstrapped_mape:.4f}\")\n", "print(f\"95% Confidence Interval for MAPE: [{lower_bound_mape:.4f}, {upper_bound_mape:.4f}]\")" ] }, { "cell_type": "code", "execution_count": 8, "id": "062b8752", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[Text(0.5, 1.0, 'True vs Predicted THICK'),\n", " Text(0, 0.5, 'True THICK (meters)'),\n", " Text(0.5, 0, 'Predicted THICK (meters)')]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots()\n", "\n", "ax.plot(preds, ytest_meters, 'o', alpha = 0.2, label='Linear Regression')\n", "ax.plot([np.min(preds), np.max(preds)], [np.min(preds), np.max(preds)], 'r--', label='Linear Regression')\n", "ax.set(title = \"True vs Predicted THICK\", ylabel = \"True THICK (meters)\", xlabel = \"Predicted THICK (meters)\")#, yscale = 'log', xscale = 'log')" ] }, { "cell_type": "code", "execution_count": null, "id": "22d3f462", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "| iter | target | boosti... | colsam... | learni... | max_depth | n_esti... | subsample |\n", "-------------------------------------------------------------------------------------------------\n" ] }, { "ename": "KeyboardInterrupt", "evalue": "", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 42\u001b[39m\n\u001b[32m 40\u001b[39m \u001b[38;5;66;03m# Run Bayesian optimization\u001b[39;00m\n\u001b[32m 41\u001b[39m optimizer = BayesianOptimization(f=lgb_evaluate, pbounds=pbounds, random_state=\u001b[32m1\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m42\u001b[39m \u001b[43moptimizer\u001b[49m\u001b[43m.\u001b[49m\u001b[43mmaximize\u001b[49m\u001b[43m(\u001b[49m\u001b[43minit_points\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_iter\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m25\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 44\u001b[39m \u001b[38;5;66;03m# Get best parameters\u001b[39;00m\n\u001b[32m 45\u001b[39m best_params = optimizer.max[\u001b[33m'\u001b[39m\u001b[33mparams\u001b[39m\u001b[33m'\u001b[39m]\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\bayes_opt\\bayesian_optimization.py:338\u001b[39m, in \u001b[36mBayesianOptimization.maximize\u001b[39m\u001b[34m(self, init_points, n_iter)\u001b[39m\n\u001b[32m 336\u001b[39m x_probe = \u001b[38;5;28mself\u001b[39m.suggest()\n\u001b[32m 337\u001b[39m iteration += \u001b[32m1\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m338\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mprobe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx_probe\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlazy\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m 340\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._bounds_transformer \u001b[38;5;129;01mand\u001b[39;00m iteration > \u001b[32m0\u001b[39m:\n\u001b[32m 341\u001b[39m \u001b[38;5;66;03m# The bounds transformer should only modify the bounds after\u001b[39;00m\n\u001b[32m 342\u001b[39m \u001b[38;5;66;03m# the init_points points (only for the true iterations)\u001b[39;00m\n\u001b[32m 343\u001b[39m \u001b[38;5;28mself\u001b[39m.set_bounds(\u001b[38;5;28mself\u001b[39m._bounds_transformer.transform(\u001b[38;5;28mself\u001b[39m._space))\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\bayes_opt\\bayesian_optimization.py:270\u001b[39m, in \u001b[36mBayesianOptimization.probe\u001b[39m\u001b[34m(self, params, lazy)\u001b[39m\n\u001b[32m 268\u001b[39m \u001b[38;5;28mself\u001b[39m._queue.append(params)\n\u001b[32m 269\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m270\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_space\u001b[49m\u001b[43m.\u001b[49m\u001b[43mprobe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 271\u001b[39m \u001b[38;5;28mself\u001b[39m.dispatch(Events.OPTIMIZATION_STEP)\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\bayes_opt\\target_space.py:418\u001b[39m, in \u001b[36mTargetSpace.probe\u001b[39m\u001b[34m(self, params)\u001b[39m\n\u001b[32m 416\u001b[39m error_msg = \u001b[33m\"\u001b[39m\u001b[33mNo target function has been provided.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 417\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(error_msg)\n\u001b[32m--> \u001b[39m\u001b[32m418\u001b[39m target = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtarget_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mdict_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 420\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._constraint \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 421\u001b[39m \u001b[38;5;28mself\u001b[39m.register(x, target)\n", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 27\u001b[39m, in \u001b[36mlgb_evaluate\u001b[39m\u001b[34m(n_estimators, max_depth, learning_rate, subsample, colsample_bytree, boosting_type_idx)\u001b[39m\n\u001b[32m 17\u001b[39m params = {\n\u001b[32m 18\u001b[39m \u001b[33m'\u001b[39m\u001b[33mn_estimators\u001b[39m\u001b[33m'\u001b[39m: \u001b[38;5;28mint\u001b[39m(n_estimators),\n\u001b[32m 19\u001b[39m \u001b[33m'\u001b[39m\u001b[33mmax_depth\u001b[39m\u001b[33m'\u001b[39m: \u001b[38;5;28mint\u001b[39m(max_depth),\n\u001b[32m (...)\u001b[39m\u001b[32m 24\u001b[39m \u001b[33m'\u001b[39m\u001b[33mbooster\u001b[39m\u001b[33m'\u001b[39m: boosting_type, \u001b[38;5;66;03m# Use string value\u001b[39;00m\n\u001b[32m 25\u001b[39m }\n\u001b[32m 26\u001b[39m model = xgb.XGBRegressor(**params)\n\u001b[32m---> \u001b[39m\u001b[32m27\u001b[39m scores = \u001b[43mcross_val_score\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mXtrain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mytrain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcv\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscoring\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mneg_mean_absolute_error\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 28\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m np.mean(scores)\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\sklearn\\utils\\_param_validation.py:216\u001b[39m, in \u001b[36mvalidate_params..decorator..wrapper\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 210\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m 211\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[32m 212\u001b[39m skip_parameter_validation=(\n\u001b[32m 213\u001b[39m prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[32m 214\u001b[39m )\n\u001b[32m 215\u001b[39m ):\n\u001b[32m--> \u001b[39m\u001b[32m216\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 217\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m InvalidParameterError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m 218\u001b[39m \u001b[38;5;66;03m# When the function is just a wrapper around an estimator, we allow\u001b[39;00m\n\u001b[32m 219\u001b[39m \u001b[38;5;66;03m# the function to delegate validation to the estimator, but we replace\u001b[39;00m\n\u001b[32m 220\u001b[39m \u001b[38;5;66;03m# the name of the estimator by the name of the function in the error\u001b[39;00m\n\u001b[32m 221\u001b[39m \u001b[38;5;66;03m# message to avoid confusion.\u001b[39;00m\n\u001b[32m 222\u001b[39m msg = re.sub(\n\u001b[32m 223\u001b[39m \u001b[33mr\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mparameter of \u001b[39m\u001b[33m\\\u001b[39m\u001b[33mw+ must be\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 224\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mparameter of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc.\u001b[34m__qualname__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m must be\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 225\u001b[39m \u001b[38;5;28mstr\u001b[39m(e),\n\u001b[32m 226\u001b[39m )\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\sklearn\\model_selection\\_validation.py:684\u001b[39m, in \u001b[36mcross_val_score\u001b[39m\u001b[34m(estimator, X, y, groups, scoring, cv, n_jobs, verbose, params, pre_dispatch, error_score)\u001b[39m\n\u001b[32m 681\u001b[39m \u001b[38;5;66;03m# To ensure multimetric format is not supported\u001b[39;00m\n\u001b[32m 682\u001b[39m scorer = check_scoring(estimator, scoring=scoring)\n\u001b[32m--> \u001b[39m\u001b[32m684\u001b[39m cv_results = \u001b[43mcross_validate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 685\u001b[39m \u001b[43m \u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m=\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 686\u001b[39m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m=\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 687\u001b[39m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m=\u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 688\u001b[39m \u001b[43m \u001b[49m\u001b[43mgroups\u001b[49m\u001b[43m=\u001b[49m\u001b[43mgroups\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 689\u001b[39m \u001b[43m \u001b[49m\u001b[43mscoring\u001b[49m\u001b[43m=\u001b[49m\u001b[43m{\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mscore\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mscorer\u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 690\u001b[39m \u001b[43m \u001b[49m\u001b[43mcv\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcv\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 691\u001b[39m \u001b[43m \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 692\u001b[39m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m=\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 693\u001b[39m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 694\u001b[39m \u001b[43m \u001b[49m\u001b[43mpre_dispatch\u001b[49m\u001b[43m=\u001b[49m\u001b[43mpre_dispatch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 695\u001b[39m \u001b[43m \u001b[49m\u001b[43merror_score\u001b[49m\u001b[43m=\u001b[49m\u001b[43merror_score\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 696\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 697\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m cv_results[\u001b[33m\"\u001b[39m\u001b[33mtest_score\u001b[39m\u001b[33m\"\u001b[39m]\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\sklearn\\utils\\_param_validation.py:216\u001b[39m, in \u001b[36mvalidate_params..decorator..wrapper\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 210\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m 211\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[32m 212\u001b[39m skip_parameter_validation=(\n\u001b[32m 213\u001b[39m prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[32m 214\u001b[39m )\n\u001b[32m 215\u001b[39m ):\n\u001b[32m--> \u001b[39m\u001b[32m216\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 217\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m InvalidParameterError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m 218\u001b[39m \u001b[38;5;66;03m# When the function is just a wrapper around an estimator, we allow\u001b[39;00m\n\u001b[32m 219\u001b[39m \u001b[38;5;66;03m# the function to delegate validation to the estimator, but we replace\u001b[39;00m\n\u001b[32m 220\u001b[39m \u001b[38;5;66;03m# the name of the estimator by the name of the function in the error\u001b[39;00m\n\u001b[32m 221\u001b[39m \u001b[38;5;66;03m# message to avoid confusion.\u001b[39;00m\n\u001b[32m 222\u001b[39m msg = re.sub(\n\u001b[32m 223\u001b[39m \u001b[33mr\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mparameter of \u001b[39m\u001b[33m\\\u001b[39m\u001b[33mw+ must be\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 224\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mparameter of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc.\u001b[34m__qualname__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m must be\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 225\u001b[39m \u001b[38;5;28mstr\u001b[39m(e),\n\u001b[32m 226\u001b[39m )\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\sklearn\\model_selection\\_validation.py:411\u001b[39m, in \u001b[36mcross_validate\u001b[39m\u001b[34m(estimator, X, y, groups, scoring, cv, n_jobs, verbose, params, pre_dispatch, return_train_score, return_estimator, return_indices, error_score)\u001b[39m\n\u001b[32m 408\u001b[39m \u001b[38;5;66;03m# We clone the estimator to make sure that all the folds are\u001b[39;00m\n\u001b[32m 409\u001b[39m \u001b[38;5;66;03m# independent, and that it is pickle-able.\u001b[39;00m\n\u001b[32m 410\u001b[39m parallel = Parallel(n_jobs=n_jobs, verbose=verbose, pre_dispatch=pre_dispatch)\n\u001b[32m--> \u001b[39m\u001b[32m411\u001b[39m results = \u001b[43mparallel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 412\u001b[39m \u001b[43m \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_fit_and_score\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 413\u001b[39m \u001b[43m \u001b[49m\u001b[43mclone\u001b[49m\u001b[43m(\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 414\u001b[39m \u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 415\u001b[39m \u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 416\u001b[39m \u001b[43m \u001b[49m\u001b[43mscorer\u001b[49m\u001b[43m=\u001b[49m\u001b[43mscorers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 417\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 418\u001b[39m \u001b[43m \u001b[49m\u001b[43mtest\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 419\u001b[39m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m=\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 420\u001b[39m \u001b[43m \u001b[49m\u001b[43mparameters\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 421\u001b[39m \u001b[43m \u001b[49m\u001b[43mfit_params\u001b[49m\u001b[43m=\u001b[49m\u001b[43mrouted_params\u001b[49m\u001b[43m.\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 422\u001b[39m \u001b[43m \u001b[49m\u001b[43mscore_params\u001b[49m\u001b[43m=\u001b[49m\u001b[43mrouted_params\u001b[49m\u001b[43m.\u001b[49m\u001b[43mscorer\u001b[49m\u001b[43m.\u001b[49m\u001b[43mscore\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 423\u001b[39m \u001b[43m \u001b[49m\u001b[43mreturn_train_score\u001b[49m\u001b[43m=\u001b[49m\u001b[43mreturn_train_score\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 424\u001b[39m \u001b[43m \u001b[49m\u001b[43mreturn_times\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 425\u001b[39m \u001b[43m \u001b[49m\u001b[43mreturn_estimator\u001b[49m\u001b[43m=\u001b[49m\u001b[43mreturn_estimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 426\u001b[39m \u001b[43m \u001b[49m\u001b[43merror_score\u001b[49m\u001b[43m=\u001b[49m\u001b[43merror_score\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 427\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 428\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mindices\u001b[49m\n\u001b[32m 429\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 431\u001b[39m _warn_or_raise_about_fit_failures(results, error_score)\n\u001b[32m 433\u001b[39m \u001b[38;5;66;03m# For callable scoring, the return type is only know after calling. If the\u001b[39;00m\n\u001b[32m 434\u001b[39m \u001b[38;5;66;03m# return type is a dictionary, the error scores can now be inserted with\u001b[39;00m\n\u001b[32m 435\u001b[39m \u001b[38;5;66;03m# the correct key.\u001b[39;00m\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\sklearn\\utils\\parallel.py:77\u001b[39m, in \u001b[36mParallel.__call__\u001b[39m\u001b[34m(self, iterable)\u001b[39m\n\u001b[32m 72\u001b[39m config = get_config()\n\u001b[32m 73\u001b[39m iterable_with_config = (\n\u001b[32m 74\u001b[39m (_with_config(delayed_func, config), args, kwargs)\n\u001b[32m 75\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[32m 76\u001b[39m )\n\u001b[32m---> \u001b[39m\u001b[32m77\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[34;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\joblib\\parallel.py:1918\u001b[39m, in \u001b[36mParallel.__call__\u001b[39m\u001b[34m(self, iterable)\u001b[39m\n\u001b[32m 1916\u001b[39m output = \u001b[38;5;28mself\u001b[39m._get_sequential_output(iterable)\n\u001b[32m 1917\u001b[39m \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[32m-> \u001b[39m\u001b[32m1918\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.return_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1920\u001b[39m \u001b[38;5;66;03m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[32m 1921\u001b[39m \u001b[38;5;66;03m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[32m 1922\u001b[39m \u001b[38;5;66;03m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[32m 1923\u001b[39m \u001b[38;5;66;03m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[32m 1924\u001b[39m \u001b[38;5;66;03m# callback.\u001b[39;00m\n\u001b[32m 1925\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m._lock:\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\joblib\\parallel.py:1847\u001b[39m, in \u001b[36mParallel._get_sequential_output\u001b[39m\u001b[34m(self, iterable)\u001b[39m\n\u001b[32m 1845\u001b[39m \u001b[38;5;28mself\u001b[39m.n_dispatched_batches += \u001b[32m1\u001b[39m\n\u001b[32m 1846\u001b[39m \u001b[38;5;28mself\u001b[39m.n_dispatched_tasks += \u001b[32m1\u001b[39m\n\u001b[32m-> \u001b[39m\u001b[32m1847\u001b[39m res = \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1848\u001b[39m \u001b[38;5;28mself\u001b[39m.n_completed_tasks += \u001b[32m1\u001b[39m\n\u001b[32m 1849\u001b[39m \u001b[38;5;28mself\u001b[39m.print_progress()\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\sklearn\\utils\\parallel.py:139\u001b[39m, in \u001b[36m_FuncWrapper.__call__\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 137\u001b[39m config = {}\n\u001b[32m 138\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m config_context(**config):\n\u001b[32m--> \u001b[39m\u001b[32m139\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\sklearn\\model_selection\\_validation.py:866\u001b[39m, in \u001b[36m_fit_and_score\u001b[39m\u001b[34m(estimator, X, y, scorer, train, test, verbose, parameters, fit_params, score_params, return_train_score, return_parameters, return_n_test_samples, return_times, return_estimator, split_progress, candidate_progress, error_score)\u001b[39m\n\u001b[32m 864\u001b[39m estimator.fit(X_train, **fit_params)\n\u001b[32m 865\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m866\u001b[39m \u001b[43mestimator\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mfit_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 868\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[32m 869\u001b[39m \u001b[38;5;66;03m# Note fit time as time until error\u001b[39;00m\n\u001b[32m 870\u001b[39m fit_time = time.time() - start_time\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\xgboost\\core.py:729\u001b[39m, in \u001b[36mrequire_keyword_args..throw_if..inner_f\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 727\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m k, arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(sig.parameters, args):\n\u001b[32m 728\u001b[39m kwargs[k] = arg\n\u001b[32m--> \u001b[39m\u001b[32m729\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\xgboost\\sklearn.py:1247\u001b[39m, in \u001b[36mXGBModel.fit\u001b[39m\u001b[34m(self, X, y, sample_weight, base_margin, eval_set, verbose, xgb_model, sample_weight_eval_set, base_margin_eval_set, feature_weights)\u001b[39m\n\u001b[32m 1244\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 1245\u001b[39m obj = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1247\u001b[39m \u001b[38;5;28mself\u001b[39m._Booster = \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1248\u001b[39m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1249\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_dmatrix\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1250\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mget_num_boosting_rounds\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1251\u001b[39m \u001b[43m \u001b[49m\u001b[43mevals\u001b[49m\u001b[43m=\u001b[49m\u001b[43mevals\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1252\u001b[39m \u001b[43m \u001b[49m\u001b[43mearly_stopping_rounds\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mearly_stopping_rounds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1253\u001b[39m \u001b[43m \u001b[49m\u001b[43mevals_result\u001b[49m\u001b[43m=\u001b[49m\u001b[43mevals_result\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1254\u001b[39m \u001b[43m \u001b[49m\u001b[43mobj\u001b[49m\u001b[43m=\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1255\u001b[39m \u001b[43m \u001b[49m\u001b[43mcustom_metric\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1256\u001b[39m \u001b[43m \u001b[49m\u001b[43mverbose_eval\u001b[49m\u001b[43m=\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1257\u001b[39m \u001b[43m \u001b[49m\u001b[43mxgb_model\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1258\u001b[39m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1259\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1261\u001b[39m \u001b[38;5;28mself\u001b[39m._set_evaluation_result(evals_result)\n\u001b[32m 1262\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\xgboost\\core.py:729\u001b[39m, in \u001b[36mrequire_keyword_args..throw_if..inner_f\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 727\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m k, arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(sig.parameters, args):\n\u001b[32m 728\u001b[39m kwargs[k] = arg\n\u001b[32m--> \u001b[39m\u001b[32m729\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\xgboost\\training.py:183\u001b[39m, in \u001b[36mtrain\u001b[39m\u001b[34m(params, dtrain, num_boost_round, evals, obj, maximize, early_stopping_rounds, evals_result, verbose_eval, xgb_model, callbacks, custom_metric)\u001b[39m\n\u001b[32m 181\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m cb_container.before_iteration(bst, i, dtrain, evals):\n\u001b[32m 182\u001b[39m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m183\u001b[39m \u001b[43mbst\u001b[49m\u001b[43m.\u001b[49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdtrain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miteration\u001b[49m\u001b[43m=\u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfobj\u001b[49m\u001b[43m=\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 184\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m cb_container.after_iteration(bst, i, dtrain, evals):\n\u001b[32m 185\u001b[39m \u001b[38;5;28;01mbreak\u001b[39;00m\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\xgboost\\core.py:2247\u001b[39m, in \u001b[36mBooster.update\u001b[39m\u001b[34m(self, dtrain, iteration, fobj)\u001b[39m\n\u001b[32m 2243\u001b[39m \u001b[38;5;28mself\u001b[39m._assign_dmatrix_features(dtrain)\n\u001b[32m 2245\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m fobj \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 2246\u001b[39m _check_call(\n\u001b[32m-> \u001b[39m\u001b[32m2247\u001b[39m \u001b[43m_LIB\u001b[49m\u001b[43m.\u001b[49m\u001b[43mXGBoosterUpdateOneIter\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2248\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mctypes\u001b[49m\u001b[43m.\u001b[49m\u001b[43mc_int\u001b[49m\u001b[43m(\u001b[49m\u001b[43miteration\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtrain\u001b[49m\u001b[43m.\u001b[49m\u001b[43mhandle\u001b[49m\n\u001b[32m 2249\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2250\u001b[39m )\n\u001b[32m 2251\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 2252\u001b[39m pred = \u001b[38;5;28mself\u001b[39m.predict(dtrain, output_margin=\u001b[38;5;28;01mTrue\u001b[39;00m, training=\u001b[38;5;28;01mTrue\u001b[39;00m)\n", "\u001b[31mKeyboardInterrupt\u001b[39m: " ] } ], "source": [ "# from bayes_opt import BayesianOptimization\n", "# from sklearn.model_selection import cross_val_score\n", "\n", "# # Define the objective function\n", "# def lgb_evaluate(\n", "# n_estimators,\n", "# max_depth,\n", "# learning_rate,\n", "# subsample,\n", "# colsample_bytree,\n", "# boosting_type_idx # Numerical proxy for boosting_type\n", "# ):\n", "# # Map boosting_type_idx to string\n", "# boosting_types = ['gbtree', 'dart', 'gblinear']\n", "# boosting_type = boosting_types[int(boosting_type_idx)] # Convert to index\n", "\n", "# params = {\n", "# 'n_estimators': int(n_estimators),\n", "# 'max_depth': int(max_depth),\n", "# 'learning_rate': learning_rate,\n", "# 'subsample': subsample,\n", "# 'colsample_bytree': colsample_bytree,\n", "# 'eval_metric': 'mae',\n", "# 'booster': boosting_type, # Use string value\n", "# }\n", "# model = xgb.XGBRegressor(**params)\n", "# scores = cross_val_score(model, Xtrain, ytrain, cv=5, scoring='neg_mean_absolute_error')\n", "# return np.mean(scores)\n", "\n", "# # Define parameter bounds, including boosting_type_idx\n", "# pbounds = {\n", "# 'n_estimators': (50, 100),\n", "# 'max_depth': (5,8),\n", "# 'learning_rate': (0.01, 0.3),\n", "# 'subsample': (0.6, 1.0),\n", "# 'colsample_bytree': (0.6, 1.0),\n", "# 'boosting_type_idx': (0, 2) # Maps to indices [0, 1, 2] for ['gbdt', 'dart', 'goss']\n", "# }\n", "\n", "# # Run Bayesian optimization\n", "# optimizer = BayesianOptimization(f=lgb_evaluate, pbounds=pbounds, random_state=1)\n", "# optimizer.maximize(init_points=5, n_iter=25)\n", "\n", "# # Get best parameters\n", "# best_params = optimizer.max['params']\n", "# best_params['n_estimators'] = int(best_params['n_estimators'])\n", "# best_params['max_leaves'] = int(best_params['max_leaves'])\n", "# best_params['max_depth'] = int(best_params['max_depth'])\n", "# best_params['min_child_weight'] = int(best_params['min_child_weight'])\n", "# best_params['boosting_type'] = ['gbtree', 'dart', 'gblinear'][int(best_params['boosting_type_idx'])]\n", "# del best_params['boosting_type_idx'] # Remove proxy parameter\n", "# print(\"Best parameters:\", best_params)\n", "# print(\"Best cross-validated neg RMSE:\", optimizer.max['target'])\n" ] }, { "cell_type": "code", "execution_count": null, "id": "b6d623c6", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "c:\\Users\\Cap\\Documents\\Python_Scripts\\AppML\\.appMLvenv\\Lib\\site-packages\\xgboost\\training.py:183: UserWarning: [15:46:14] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n", "Parameters: { \"boosting_type\" } are not used.\n", "\n", " bst.update(dtrain, iteration=i, fobj=obj)\n" ] }, { "data": { "text/html": [ "
XGBRegressor(base_score=None, booster=None, boosting_type='gbtree',\n",
       "             callbacks=None, colsample_bylevel=None, colsample_bynode=None,\n",
       "             colsample_bytree=np.float64(0.8155266936013428), device=None,\n",
       "             early_stopping_rounds=None, enable_categorical=False,\n",
       "             eval_metric=None, feature_types=None, feature_weights=None,\n",
       "             gamma=None, grow_policy=None, importance_type=None,\n",
       "             interaction_constraints=None,\n",
       "             learning_rate=np.float64(0.13156640917695547), max_bin=None,\n",
       "             max_cat_threshold=None, max_cat_to_onehot=None,\n",
       "             max_delta_step=None, max_depth=11, max_leaves=36,\n",
       "             min_child_weight=44, missing=nan, monotone_constraints=None,\n",
       "             multi_strategy=None, n_estimators=110, n_jobs=None, ...)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "XGBRegressor(base_score=None, booster=None, boosting_type='gbtree',\n", " callbacks=None, colsample_bylevel=None, colsample_bynode=None,\n", " colsample_bytree=np.float64(0.8155266936013428), device=None,\n", " early_stopping_rounds=None, enable_categorical=False,\n", " eval_metric=None, feature_types=None, feature_weights=None,\n", " gamma=None, grow_policy=None, importance_type=None,\n", " interaction_constraints=None,\n", " learning_rate=np.float64(0.13156640917695547), max_bin=None,\n", " max_cat_threshold=None, max_cat_to_onehot=None,\n", " max_delta_step=None, max_depth=11, max_leaves=36,\n", " min_child_weight=44, missing=nan, monotone_constraints=None,\n", " multi_strategy=None, n_estimators=110, n_jobs=None, ...)" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Train final model\n", "# final_model = xgb.XGBRegressor(**best_params)\n", "# final_model.fit(Xtrain, ytrain)" ] }, { "cell_type": "code", "execution_count": 68, "id": "51b1d4d7", "metadata": {}, "outputs": [], "source": [ "with open('losses_10k_95conf.txt', 'r') as f:\n", " losses = [line.split(',')[:-1] for line in f.readlines()]" ] }, { "cell_type": "code", "execution_count": 69, "id": "82ffc8af", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0.000000e+00, 1.914079e+02, 1.833116e+02, 1.996380e+02],\n", " [2.000000e-01, 2.129963e+02, 2.040288e+02, 2.219416e+02],\n", " [5.000000e-01, 2.161030e+02, 2.070822e+02, 2.251494e+02],\n", " [1.000000e+00, 2.250632e+02, 2.155843e+02, 2.346855e+02],\n", " [3.000000e+00, 2.376028e+02, 2.273755e+02, 2.483994e+02],\n", " [5.000000e+00, 2.393102e+02, 2.293818e+02, 2.492367e+02],\n", " [7.000000e+00, 2.411827e+02, 2.312521e+02, 2.513231e+02],\n", " [1.000000e+01, 2.561017e+02, 2.444900e+02, 2.677119e+02],\n", " [1.500000e+01, 2.534516e+02, 2.424204e+02, 2.647047e+02],\n", " [2.000000e+01, 2.553722e+02, 2.448788e+02, 2.663524e+02],\n", " [3.000000e+01, 2.617552e+02, 2.508718e+02, 2.730132e+02],\n", " [3.500000e+01, 2.530737e+02, 2.423683e+02, 2.638330e+02]])" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "losses = np.array(losses).astype(float)\n", "losses" ] }, { "cell_type": "code", "execution_count": 10, "id": "0a9504a7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([226.59709633, 234.01781895, 232.95049672, 246.47106435,\n", " 248.40430048, 254.93018085, 254.94216635, 262.26613405,\n", " 265.19891439, 274.822422 , 274.57757929])" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.array(INTERVALS)[:,1]" ] }, { "cell_type": "code", "execution_count": 13, "id": "d26ef2e1", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "mindists = [0.2, 0.5, 1, 3, 5, 7, 10, 15, 20, 30, 35]\n", "\n", "plt.plot(mindists, MEANS, '--', color = 'k', label = \"Mean MAE\")\n", "plt.fill_between(mindists, np.array(INTERVALS)[:,0], np.array(INTERVALS)[:,1], label = \"95% Conf.\", alpha = 0.5)\n", "plt.text(15, 215, r'XGBoost default params', fontsize=15)\n", "\n", "plt.xlabel('minDist [km]', fontsize = 12)\n", "plt.ylabel('Loss (MAE) [m]', fontsize = 12)\n", "plt.title('Loss as a function of decorrelation', fontsize = 15)\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 69, "id": "98b11e08", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAHQCAYAAACx9C4fAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgMRJREFUeJzt3Qd8k+X2B/BD915009JS9t5TFBRkiALqRXDDVVSuel1XkftXcXPd96ooiqLgApWhojIEBEFm2XsVulu690z+n/Mkb0xpm6Ztknfk9/18QtPkbfqmIW/Oe57znKeNXq/XEwAAAAA0yKXhmwEAAACAIVgCAAAAsADBEgAAAIAFCJYAAAAALECwBAAAAGABgiUAAAAACxAsAQAAAFiAYAkAAADAAgRLAAAAABYgWAIAAACwAMESAGjS559/Tm3atBGXCxcu2P33VVVVUefOncXv+/7770mpHnzwQbGPd999t9y7AqAaCJYAAGzgf//7H509e5Z69epFN998MynV3LlzycPDg7744gtKTEyUe3cAVAHBEgBAKxUXF9Nrr70mrj/zzDMicyOHsrIycnNzE79/wYIFDW7Tvn17kVXiNdSfffZZh+8jgBohWAIAWeh0OhozZgxt2rTJLo8/c+ZMERDwJT4+nuzpww8/pNzcXBGITJs2jeTCmaLa2lpxffDgwY1u98QTT4ivv/76K7JLAFZAsAQAsnj33Xdp8+bNlJeXR2rGwcn7778vrt96663k4iLfYXXPnj3iK2eWBg0a1Oh2Xbt2pQEDBojr7733nsP2D0CtECwBgMMlJSWJ4SppCEvNNm7cSCkpKeL67bffLuu+SMFSp06dKCgoyOK20r5+9913qn8NAOwNwRIAONx9991HpaWl4npTH9Tp6en09NNPi0xIYGAgubu7U0REBPXu3VtkcnjWW1FRUbNmwz3//POm+1hFRQW98cYb4nf4+/uLy5AhQ0TGqKamxuL+ffvtt+Irz4TjfWpKdXU19ezZU/zuPn36mIbNmsKPzT8TFxdX776wsDBxn7QvZ86cMT0/6XJ5ICcVoXOd0w8//GDVPgA4Kze5dwAAnMuSJUto27Ztpu9LSkoa3faPP/6g66+/vl4wlJ2dLS5Hjx6l5cuXU2hoqNiuJbKysmjChAl08ODBOrfv3btXXDZs2EBr1qxpdHhty5Yt4uuwYcOs+n1vvvkmHT9+3DQU6erqatXPDRw4UDzf5ORkSk1NpZiYGFMwmZOT0+TP8yw9cxx0RUZGUmZmpqhduuOOO6zaDwBnhMwSADgMfzBzluiFF14w3dZYZqmyspJmzJghAiXO9Dz11FOmguSdO3fS119/TQ899BC1a9euVft00003ieDln//8pxhS48fnx+7evbu4/6effqLFixc3+LMctEhZK0sF1ebP/+WXXxbXJ02aRKNHj7Z6PzkbJTEvyg4ODqYjR47U6e3EQRjfZn6ZM2dOvcfk7BnbunWr1fsB4IyQWQIAhzZEfOCBB+oECY0FSzt27BBZE8bBy+WZI87k8DDcO++8I4aSWkrKHpnvEw/HjR8/nnr06CEyTx988AHdf//99X72zz//NF3v379/k7/r1VdfNe3rc88916z9lDJJ7Ny5c6br3t7eImtknhm77rrrqGPHjlZlq3788UdKS0sTz5OHNwGgPmSWAMAhVq5cKT7kubePr69vk8ESZ2EkV111VaOPy32FAgICWrxfDz/8cIMZnpCQEJo1a5a4zpmZwsLCBjNLkvDwcIu/h1sLfPzxx+L6yJEjTVkda/FQoyQjI6Pe/VKwxH+LhIQEqx7TfJ/Pnz/frP0BcCYIlgDA7vLz8+nxxx+npUuXigJt82CpsZqlqKgo0/XPPvvMbvtmaQYbZ14Y92riGXyXu3TpUp3hMEu44JyHFtnf//73VuyxoUi8sWCJi8atbYrJAWFDwSkA1IVgCQDsjgOl2bNnU9++fcX31mSWOPsiZUgeffRRkYnhrtQ8PMfrsNlKt27drAomGtpP8x5RTQVL0kw1Lui+8cYbGxwO5BotLrTm4Oxy0uxB5uPjU+/+Q4cOWT0c2NA+mz8+ANSFYAkA7IqLpo8dOyYKuyXWBEucgeLiaqnQmoOJf//73yKI4h5CPIONa5msnXrfmIYCD4n5DLiGfo+Xl5fpenl5eaOPw0XqUlE2BzMN9UBat24drVixQjzPhjJDPAtOwp3CzXHNkTQjrl+/fmQt833mvzcANAzBEgDYDWcreJYZD0FxbVFDAYql1gFcYM31QqtXrxZDV9xsUfqQX79+vRhCGzp0qGgjIAfubySx1Imcg0Up2Gos88MZM9alS5cG7zcv4JaGBxu6rznBkvk+N9XEEsCZIVgCALv5v//7P1EkzUHP5RkbnsVlTVNKHraaOnUqffrpp6LZIs+Q415NUsDAGZuGZqo5OljiuqzGnD171nS9oVlq3BSTe0qxxlohSNP7/fz86gVcUrDE2aHL+ylZYr7Pl2erAOAvCJYAwC527dolOmB/8cUX9bpJ80UaAmruUhtc+M0BGPdaktY3W7t2rcVhMHsx79h9+vTpRrczn0nXUAaH919qKWA+RGlejyTNVrvhhhvqZOmk+xkPWXp4eFi9/9I+e3p6mrJ2AFAfgiUAsMvw28yZM8XwGTeS5LXTLr9Is90sDcNZwlmUUaNGieu8JElBQQE5Gi9WK9Utca2RNRp6vhxUSnVKDd1vvtit1M7A3KlTp5osVm+ItM+cqULNEkDjECwBgM1xndLVV18tsiDcTLGhC6/zJk2DbyhA4GEp8+Gry/GMOPOhKfMhMUfhLA7XTJkvYtuQ2NhY03XzpV6kWXL8PLhwvaGgi/8OXPMlNeK89tpr6z2+tBxMQy0FGsNtDA4fPiyujxs3zuqfA3BGCJYAoMV4mZDp06eLleslr732mpgB9/rrr1v8WfM+Sg01RNy0aRN17dpVNIzkRW65oHv//v2iEJr7Ll155ZXie3bPPffUG5pylClTppiCpcaGFDkDxkNdjGf48XIvHBRxxogzcBx08XPk7NKBAwdM93N3cu7GzcXhXOPFdVsNkVos8HAeZ6m4jovXkeNLY/vEQZsUXDXUygAAzOgBAFpo8uTJ3BBI7+3trf/qq6/099xzj75Nmzb6DRs2NPmzDz74oPhZvsydO1fc9vPPP+t/+eUXcX3+/Pmm+y1dpkyZoi8rK6v3+J999plpm6SkpDr3mT+2JVu2bDFtx9cbkpOTo/f09BTbLF26tNHHev755xt9Dh9//LHY5tprr23wfn9/f/1vv/3W6GP/9NNP4u/e0M8mJiY2+DMzZ84U9/fs2dPi3wAA9HoESwDQYlOnTq334fzvf//bqp/lgMr858LCwvTt2rXTX7p0SdxfXFysX7lypX7OnDn6YcOG6du3b6/38vISl/j4eP0tt9yiX7t2baOP76hgid16661im/Hjx1t8vMWLF+sHDBig9/Hx0fv6+upHjx5dJ7DMysrST58+XR8UFCQCsE6dOukfeeQRfVpamr4p69atE8FWcHCwKXByd3fXV1ZW1tu2vLxcHxAQILZZuHBhk48N4Oza8D/mmSYAAGvxjDSuoeGCbh5CeuKJJ8Twm7XLbTzzzDNi2IhbCYwdO1YMRcXFxZHa7N69W9QTcZsDXv9O6c/hyy+/pDvvvJPatm1LFy5cEDVfANA4BEsA0Co8s43riHjaurSciTO6+eabadWqVaLn06JFi0ipdDqd6MV04sQJ+s9//kNz586Ve5cAFA/BEgCADfD0fQ5COEvG2SWe8adEvKQKr0HHTShPnjxpag4KAI2TZ/oIAIDG8Mw97izOgRKv46bUYIln1s2fP5+uueYaBEoAVkJmCQAAAMAC9FkCAAAAsADBEgAAAIAFqFmy0ewSXgnd39/f6inTAAAAIC+uROIu99HR0WJyRmMQLNkAB0rmaz8BAACAulqgWJqUgWDJBjijJP2xAwIC5N4dAAAAsAIvQs3JDulzvDEIlmxAGnrjQAnBEgAAgLo0VUKDAm8AAAAACxAsAQAAAFiAYAkAAADAAgRLAAAAABYgWAIAAACwAMESAAAAgAUIlgAAAAAsQLAEAAAAYAGCJQAAAAALECwBAAAAaCVY2rZtG91www1idWBuTb5mzZomf+b333+nAQMGkKenJ3Xq1Ik+//zzetssXLiQ4uPjycvLi4YOHUp79uyx0zMAAAAAtVFVsFRaWkp9+/YVwY01kpKSaNKkSXT11VfTwYMH6dFHH6V7772X1q9fb9pmxYoV9Pjjj9P8+fNp//794vHHjx9P2dnZdnwmAAAAoBZt9Hq9nlSIM0urV6+mqVOnNrrN3Llz6eeff6ajR4+abpsxYwYVFBTQunXrxPecSRo8eDC9//774nudTidWIH744Yfp6aeftnrV4sDAQCosLMRCus3A//Xyy6rJy92FfDywpjOAXKprdZRfVkVtfT3J1cXygqIAWmLt57emP6F27txJY8eOrXMbZ404w8SqqqooMTGR5s2bZ7rfxcVF/Az/bGMqKyvFxfyPDdYpq6qhlYmptOpAGp3NLqHiihpxe2SAF/WOCaQ7hsXRVZ1Dm1wBGgBa52x2MX3+5wXacTaXUvLKqEanJw83F4pv60PXdIugu4bHUXSQt9y7CaAImg6WMjMzKSIios5t/D0HN+Xl5ZSfn0+1tbUNbnPy5MlGH3fBggX0wgsv2G2/tUin09OSHUn07qYzVGQMkMxlFlVQ5vEK2ng8izqH+9ErN/amIR1CZNlXAC3LLKygZ9Ycod9O1C81qKrR0emsEnFZ/Md5uql/O3r2hh4U4OUuy74CKIWmgyV74UwU1zlJOPjioTto2KXiSnriu0O07fQl8X1cWx+aOSKeRnQMFdfLq2rpfE4JrT2cQd/uTaEz2SU04+Od9M8xnemhqzuRm6uqSusAFGvTiSz613eHxPA3J2+v7R5Btw5pT10j/SnM35MyCiroSFohfbnrIu08n0vfJabSrqRcendGf+rfPlju3QeQjaaDpcjISMrKyqpzG3/P45Le3t7k6uoqLg1twz/bGJ5Zxxdo2sXcUprx8S7KKKwgTzcXevb6HuLgbF4X4eXuSgN9Q2hgXAg9dm0XeuHH47Ryfyr997czdDStiD64fYAYHgCAlvt0exK9tPa4uN4zOoD+N6MfdQr3r7NN+7Y+4jKpTxTtu5BHj644SCl55TRt0U56/7b+NKFXlEx7DyAvTX8CDR8+nDZt2lTnto0bN4rbmYeHBw0cOLDONlzgzd9L20DLcR3ErcZAKSHMl356eKSoSbJUQMrp/rdu6UvvTO8rgqvfTmTRw9/sFwWoANAyn+/4K1C6e3gcrfrHiHqB0uUGxYfQz/+8ksb3jBD1TA99fYA2HMt00B4DKIuqgqWSkhLRAoAvUmsAvp6cnGwaHrvrrrtM2z/wwAN0/vx5euqpp0QN0gcffEDffvstPfbYY6ZteDht8eLFtHTpUjpx4gTNmTNHtCiYNWuWDM9QO7KLK0RGKd0YKC2/bxh1ibB8cDZ3Y/8Y+viuQeTh6kLrj2XRYysOitlzANA8K/Ym0/M/GQKlB6/uSM9P7kmebq5W/Wygtzt9cPtAmtw3WgRMD369n/44YxhOB3AmqgqW9u3bR/379xcXKdDh688995z4PiMjwxQ4sQ4dOojWAZxN4v5Jb731Fn3yySdiRpxk+vTp9Oabb4rH6Nevnwi+uK3A5UXfYL2aWp04C00rKBcza76ZPYzC/b2a/TijuoTRR3cOJHfXNqKeiQtOAcB6h1IK6Nk1x8T1+69KoH+N69rsmaacCX77lr5iaK66Vk8Pf2N4bwM4E9X2WVIS9Fmqa8GvJ+ijrefJz9ONfnjoCuoY5teqx/ti10V6ds1RcdD++t6hNDShrc32FUCr8kur6Pr3tovAhofSFt0xsFUtOSprakXt0uHUQuobG0Tf3j/M6gwVgNo/v1WVWQJ1zLbhQIm9/rc+rQ6U2B1D29PUftFUy3UT3xyg3JK/elwBQH18DswzUKXs7hvT+ra6dxkHRgtvGyCG5jhjteCXxturAGgNgiWwmeKKavr36iPi+qwr4um63raZOcMH+Vdv6i36L3Ebgld+PmGTxwXQqjUH02jzyWwxi5RrjmzVJyk2xEdMvmDc0JJnzAE4AwRLYDNvrD9FWUWV4kx27oRuNn1sXg6FM1V8cszdv1FkCtCwvNIqemmt4YTikTGdqUe0bUsDuLv3tIEx4vq8VUdEI0sArUOwBDaReDFf1BaxV2/sLXon2Ro3xbt7eLy4/n+rj4pmlgBQF2deOWDqGuFPs69MsMvv+L9J3amtr4doIPvR1nN2+R0ASoJgCWyylAkXYPNUgb8NjKERnULt9rv+Nb4rRQd6UXJeGX2IgzRAHXsv5ImGrpyBXXBzb7s1cw3y8aDnbughrr+3+Syl5pfZ5fcAKAWCJWi1Hw6l0fGMIvL3cqN/X9fdrr+LZ9hxF3D2yR/nRT8nADAUdS/4xTD8Nn1QLA2w8/Ik3HtpRMe2VFWro7c3nLbr7wKQG4IlaBWeTvzmesOBcs7ojhTi62H33zmhVyT1iw2isqpasTAvABBtOJ5F+5MLyMvdRSwbZG888eLpiYbaxNUH0+h4epHdfyeAXBAsQat8uStZTE+OCPCkWSM6OOR3mh+kv9mTQucvlTjk9wIouRHs6+sMU/nvGdmBIgKa3wS2JfrEBNH1faLEEPzr69FKALQLwRK0WEllDb2/2ZDZeWxsF/L2cFyDumEJbemabuGi99JbGzEEAM5t1f40OneplIJ93On+UR0d+ru5K7ibSxv6/dQl2nU+16G/G8BRECxBi32zO5nyy6qpQ6ivKOx2tCfHdxVffzmSgewSOC0+YZAmO/xjdCeb9VSyVnyoL00fHCuuL9xy1qG/G8BRECxBi2uVpLXaHhiVQG6ujv+v1D0qgMZ0CxdDAFLXcABn8+vRDErKKaUgH3e6bWh7WfbhgVEdxXJEf5zJoSOphbLsA4A9IViCFlmZmEbZxZUUFehFN/Z3fFZJ8o+rDUMOqw6kUkYhFvcE55sB98EWQ1aJe5D5errJsh/c2Ztnx7EPfkd2CbQHwRK0qJj0o22GA/S9VybYrZeLNQbGhdCQDiFiNfRP/kiSbT8A5LD19CXRtsPHw5VmjjA0bJULz4Zl645l0tlsDIuDtiBYghZNUb6YWyaKSW8dYqhVkNM/jAfpb/YkU2F5tdy7A+AwH28zDD/fOqQ9BTugbYclXSL8aWz3CDEszj3QALQEwRI0Gy+gye4YFifWbJPbqC5hYmkH7rv0fWKq3LsD4BCns4rpz3O55NKG6O8jHdO2oyn3XZVgWsi3sAwnLqAdCJagWU5mFtGepDxRzHn70DhSAu67dOdww758ueuiWH4FQOu+2GlYi/HaHhHULsiblGBwfDB1i/SnimodfZeYIvfuANgMgiVolmXGA/T4nhEUGeiYxnfWuLF/O/L3dBOzgv44myP37gDYVVFFtVgDjkmLSyvlxOVuY+0UHytw4gJagWAJrMb1QKv3p4nrdynoAM14FtDfBhlm5S0zDhMCaNWqxFQx7Nwp3I+Gd2xLSjKlXzQFeLmJxa65AB1ACxAsgdW4Hqi8ulbUBw3tEEJKc+cww1Dc5lPZlJyLVdBBm7hdwLJdhgzv3cPjRDZHSbiO8ZZBhokfS3fixAW0AcESWH2AXr4nWVy/Q4EHaJYQ5kdXdg4Vs3FQLwFatfdCPp2/VEq+Hq504wD5epxZwpM/GGeW0gvQ/wzUD8ESWOVQaiGdyS4hTzcXkWZXKmnZBc6C8TIQAFrz7T7DicD1faLJT6YmlNYsgTIsIUScuKzEDFXQAARL0KwD9MRekQ5fe6o5eGYQL/uQUVhB21HoDRpcvPrnwxni+jRjjZ5STRtoOHH5LjEVhd6gegiWoEnlVbX008F0cV2qRVAqTzdXmtqvnbj+nTHAA9CKXw5niLrBhFBfGhgXTEo2sXekyHxxofeeC3ly7w5AqyBYgiatP5ZJxZU1FBPsTcMSlDXzpiHSGfeGY1lUUFYl9+4A2DzDO21QrCLrBi8v9L6hb1Sd/QZQKwRLYP0BemAsuXC7YIXrGR1IPaMDqKpWRz8YM2IAanf+Ugntu5gvGsLePMCQPVU6DurYL0cyqLgCHb1BvRAsgUWZhRW083yuuH6TSg7Q7G8DY0zLLgBowRpj4M8zPsMDlNMQ1pL+sUGUEOYrOnpzphdArRAsgUVrD6eLGS2D4oIpNsSH1GJSnyixZtaB5AL0XAJNtO740Rj4SzV5asBDhVP6Gvb3h0PI8oJ6IVgCi340HuCU3C6gIeH+XjSiY6i4/uMhZJdA3Q6nFtKF3DLycncRMz7VZLLx2LHjbA7llFTKvTsALYJgCRrF66zxQZprJK7rbSjUVONBmuuW+MwcQO0nLWO7R4ilfdSkQ6gv9YkJFH3PuHYJQI0QLEGjfjTWSIzsFEpt/TxJbcb3jCQPVxfRTPNkZrHcuwPQIhxk/GTK8KpnCM7c5L7RdY4pAGqDYAkaxJmYH4zDV2obgpMEervT1d3CxHXMigO12n0+l7KLK8X/51FdDP+f1eaGvtHEnQ54Nl9KHmoIQX1UFywtXLiQ4uPjycvLi4YOHUp79uxpdNvRo0eLAsPLL5MmTTJtM3PmzHr3T5gwgZzdiYxisf4UL28yrmckqdVkY3GpoVAdQ3GgPj8ZO3Zz93wPN9UdsoWIAC8a1sHQo+1nDMWBCqnqnbdixQp6/PHHaf78+bR//37q27cvjR8/nrKzsxvcftWqVZSRkWG6HD16lFxdXWnatGl1tuPgyHy7b775hpzdr0cNBzQ+k1Xq+lPWuKZbOHm7u1JqfjkdTSuSe3cAmj0Et+FYpmmGp5pdZ9z/X48ang+AmqgqWHr77bdp9uzZNGvWLOrRowctWrSIfHx8aMmSJQ1uHxISQpGRkabLxo0bxfaXB0uenp51tgsOVvYyAo4gHdB4yQI18/ZwpdFdw+oEgABqsScpj3JLq8QQnBq651syvmeEGIo7lFJA6QXlcu8OgDaDpaqqKkpMTKSxY8eabnNxcRHf79y506rH+PTTT2nGjBnk6+tb5/bff/+dwsPDqWvXrjRnzhzKzTU0YWxMZWUlFRUV1bloydnsYjqbXULurm3omm7qmqbckAm9DAHfuqOZGIoDVVlnDPC5XYC7q2oO14228+B+bdJ7EUBNVPPuy8nJodraWoqIqPvhzd9nZjb9xuPaJh6Gu/fee+sNwS1btow2bdpEr732Gm3dupUmTpwofldjFixYQIGBgaZLbKyyF5dtrl+PZJpmwfEZrdrxUBzPijufU0qns0rk3h0Aq+h0elpnHILjeiUtmNjLMBSHYAnURjXBUmtxVql37940ZMiQOrdzpmny5MnivqlTp9LatWtp7969ItvUmHnz5lFhYaHpkpKSos0hOOOBTe38vdzFEhEMQ3GgFgdSCiirqFLUDI40/v/VSpZ378U8yi6ukHt3ALQXLIWGhori7KysuusL8fdcZ2RJaWkpLV++nO65554mf09CQoL4XWfPnm10G65xCggIqHPRCl4a5HhGkWhEqbZOwdYOxQGoaQiOM6Oebq6kBdFB3tQ3NkgsoYS14kBNVBMseXh40MCBA8VwmUSn04nvhw8fbvFnv/vuO1FndMcddzT5e1JTU0XNUlSUNrIqzbXemPYf2iGEgn09SCs48HNzaSOaU17IKZV7dwAs4tq6DcezNDUEJ5Gej3SsAVAD1QRLjNsGLF68mJYuXUonTpwQxdicNeLZceyuu+4SQ2QNDcHxEFvbtnVnk5SUlNCTTz5Ju3btogsXLojAa8qUKdSpUyfRksAZbTxhOECP01BWiQX5eNCQDiHi+m/G5wigVDzB4mJumeirdJVKG1E2RspY7zqfS8UV1XLvDoD2gqXp06fTm2++Sc899xz169ePDh48SOvWrTMVfScnJ4s+SeZOnTpF27dvb3AIjof1Dh8+LGqWunTpIrbh7NUff/whhtqcTX5pFe27kCeuj+murWBJWleLIVgCtZy0XNGxrerWgmtKxzA/Sgj1pepaPW07nSP37gBYRXXvwoceekhcGtJQUTa3A2hsuri3tzetX7/e5vuoVltOZZNOT9Qt0p9iQ3xIi8HSi2uP094L+VRYVk2BPuqf6Qfa9JtxCE6LJy1sbI8I+njbedp0Ikv1zTbBOagqswT2telEdp0MjNa0b+tDXSL8RFfk30833PUdQG45JZViJhwb0z2ctGhMN8Pz2nwqm2pqdXLvDkCTECyBUFlTS1tPXzKd9WmVFAhuNJ65AyjN5pPZYrZY73aBFBXoTVo0MC6YgnzcqaCsmhIv5su9OwBNQrAEwu7zeVRSWUNh/p7Up10gaZU0rMGBYVUNzmhByUNw2swqMTdXF7qmq+H5bTqJLC8oH4IlELh2QEqPu7i0Ia3qFxtEoX4eVFxRQ3uNxewASlFRXUt/nMnR9HC4RMpgS8EhgJIhWALhd+MQ3NXGWgKt4mabo41ntFtwRgsKwwF8eXUtRQR4Us9o7TS7bQh31efeZ7wM0cVc9D4DZUOwBKJJI/d04QPXiI7qXtncGqO7htUJEAGUYpvx/+RVncOoTRvtZnilZYgGxRsW1v39FN6LoGwIloC2nblkKrrkA5jWXdkpTGSYuPFfSl6Z3LsDYCJNshhlDOi17mopy3sKWV5QNgRL8NfZrMY6BTeG+ysNaB8kriO7BEqRUVhOp7NKiEsGR3bSxsK5TZGGxHeeyxX1WgBKhWDJyfGMsD/P5Yrro5wkWDI/SG/FGS0o7KSlT0yQWJ7HGXDfs6hAL6qs0YnlTwCUCsGSk9t3MY/KqmrFDLEeUdouKG2obokDRe4xBSA3aekPZzpp4bos6cQFdUugZAiWnJx0gL6yc5imWwZcjgPDcH9PESjuTUJTPJAXd7HefjbHqYbD6024QJYXFAzBkpOTUv/OdDYrndFKzxnFpSC3Q6mFVFheTYHe7tQ3RrtNYRtyRadQcndtQxdyy8TMXAAlQrDkxLKLK+h4RpG4PrKzcxSUmpNmHO0wntEDyH3SwoXd3N3amfh5uomZuEzKrgEojXO9K6GOP4xDcLwGVaifJzmbER0NAeLJzGIROALI3b7D2TK8Emn2H05cQKkQLDkx6QB9VRfnyyqxEF8PU5dknroMIIeCsio6lFIgrl/ppO9FHoqTJlzU6vRy7w5APQiWnJROpzetQcXdgp2VdEa73fi3AHA0Hnri+MAwjd6bnBFnt/293ETd1rH0Qrl3B6AeBEtO6mh6IeWVVol6gQHGegFnPqPl9L9ejzNacLytp5x7CI5xndawBMNSS6hbAiVCsOTkBaW8Fpy7kxWUmhscH0Ieri6UXlhBSZiJAw7GAfpfw+HOGywx1C2Bkjnvp6STc7Y1qBrj7eFqmomDgzQ4Gi9vklVUSV7uLiJwd2ZSlnfvhXwsfQKKg2DJCRVVVNP+ZENBqTPXK0mktglI/4OjbT1t6PHFQ1Be7q7kzDqG+VJkgJdYgmnfBTSKBWVBsOSEdp/PEzNOOoT6UmyIDzk7zMQBuWw/m2vqoO/suFGs9F7EiQsoDYIlJyRNkx/e0VBQ6eykmTjFFTV0JA0zccAxqms5g5Jnqh0EzvIa/g4YEgelQbDkhHYaV/cebpx94uxcXdqYPqxwkAZHOZxaINYmDPZxp64R/nLvjiJcYWwUy7N180ur5N4dABMES06GD0AnjEucSFN1Af2WQL4ML78PnWkRa0vCA7xEvynu4iGd1AEoAYIlJ7M7yXAA6hzuR2H+zrfESWOkWonEi/lUXoWZOODADC+G4OpA3RIoEYIlJ4N6pYZxsXt0oBdV1epor7GOBMBeKmtqTTO+MBxeF/otgRIhWHIyPOOLoaC08Zk4OEiDvR1MLqDKGp1YwLpTuJ/cu6MoQxPaijrCi7lllJJXJvfuAAgIlpzIpeJKOpNdQm3aEA3tgGDpcui3BI4eghuWECICdfgLL8HUPzZIXMeJCygFgiUnsst4gO4WGUDBvh5y747ijDDOxDmWXiTWzQOwFwyHW4a6JVAaBEtOBC0DLOOCdy58Z3uMhfAAtsZLeRwwdtDHe7FhUhC563weFrgGRUCw5ER24Wy2SUMTDOtz7U5CkTfYB8+45IkEvLQHTyyA+vrFBpGHmwvllFRigWtQBNUFSwsXLqT4+Hjy8vKioUOH0p49exrd9vPPPxf1AOYX/jlzfNby3HPPUVRUFHl7e9PYsWPpzJkzpDWZhRV0PqeUuJ3LkA7OvWCnJVItFy8JA2DvITjUKzWM18njgInhxAWUQFXB0ooVK+jxxx+n+fPn0/79+6lv3740fvx4ys42LEbZkICAAMrIyDBdLl68WOf+119/nd59911atGgR7d69m3x9fcVjVlRUkJbsPG8Y++8ZHUiB3u5y745iDTUGkicyi6iwrFru3QENwnC4dYYZ34u70ZwSFEBVwdLbb79Ns2fPplmzZlGPHj1EgOPj40NLlixp9Gf4zC0yMtJ0iYiIqJNV+u9//0vPPPMMTZkyhfr06UPLli2j9PR0WrNmDWkJCkqt7yDMQyNcJoF+S2BrpZU1dCjFWK+E96JFQ6QsbxLqlkB+qgmWqqqqKDExUQyTSVxcXMT3O3fubPTnSkpKKC4ujmJjY0VAdOzYMdN9SUlJlJmZWecxAwMDxfCepcesrKykoqKiOhelQ7fg5meX9iBYAhvbdzGfanR6ahfkTbEhPnLvjqINiAsiN5c2lFFYQan55XLvDjg51QRLOTk5VFtbWyczxPh7Dnga0rVrV5F1+uGHH+jLL78knU5HI0aMoNTUVHG/9HPNeUy2YMECEVRJFw7ElCw1n5u7lYtGb4PjUa9kdZE30v9gY8jwWs/Hw436xATWaXsCIBfVBEstMXz4cLrrrruoX79+NGrUKFq1ahWFhYXRRx991KrHnTdvHhUWFpouKSkppIYDNB94uOEbWFfkfTS9iEoqa+TeHdAQ1Cs1v5s3Q5E3yE01wVJoaCi5urpSVlZWndv5e65Fsoa7uzv179+fzp49K76Xfq65j+np6SkKx80vSoYDdPNEB3lTTLA31er0Ypo3gC0UV1TT0bRCcR2ZJetIM3f3IFgCmakmWPLw8KCBAwfSpk2bTLfxsBp/zxkka/Aw3pEjR0SbANahQwcRFJk/Jtcf8aw4ax9TDaQDzTAESy1oIYD0P9gGB94cgLcP8REBOTRtUFywaHeSnFdGGYWoWwL5qCZYYtw2YPHixbR06VI6ceIEzZkzh0pLS8XsOMZDbjxEJnnxxRdpw4YNdP78edFq4I477hCtA+69917TTLlHH32UXn75Zfrxxx9FIMWPER0dTVOnTiUt4AMMF0fyAWdAXLDcu6MaaE4JtibNrkTdoPX8vdypVztD3RJ6n4GcVFXAMn36dLp06ZJoIskF2FyLtG7dOlOBdnJyspghJ8nPzxetBnjb4OBgkZn6888/RdsByVNPPSUCrvvuu48KCgpo5MiR4jEvb16p9qwS91dCvZL1hhkzS4dTC6i8qpa8PVzl3iVQub1JhiHdIR1w0tLc2amHUwtpd1IuTe3fTu7dASfVRo8GFq3GQ3c8K46LvZVWv/TsmqP0xa6LNOuKeJp/Q0+5d0c1+G0xfMFmyiyqoK/vHUojjAt7ArREZU0t9X5+A1XV6GjTE6OoY5hhDUJo2sbjWTR72T5KCPOlzU+Mlnt3wEk/v1U1DActT/0PQeq/WXiIVhqK24WhOGilI6mFIlAK9fOgBKwH1yx87OJVYc5fKqXsYm2trADqgWBJw3i5jlNZxeL6IARLzYYib7AVqcHpoDj+4Md6cM0R6ONO3SINZ/yYFQdyQbCkYfsu8jIBJM5kw/w95d4d1ZEySwdSCqiiulbu3QEV22v8kB+MRaxb1VUfRd4gFwRLznA2G4+C0pbgIDPUz1MMn3CBKUBLcLsAXuaEYTi8lUsQIbMEMkGwpGH7LhgO0Jiq3DKibgkrn0Mrnc4qpuKKGvL1cKXuUf5y746qm1NyWUFeaZXcuwNOCMGSRvGwEU97Nz/QQMuH4rCoLrR2kgX3OXNzxSG3Jdr6eVLncL86f08AR8I7V6MOphRQda2ewv09RcdgaJmBxkaeB5ILxHAKQHNJQ0fI8LaOVE6AJYhADgiWtF5QKqbdYvZNS/EsHG7myQvqnswsknt3QIX9utC52zZ4JiHbh8wSyADBkkbtNZ59DUZxd6u4urSh/u2DxHWc0UJz8VJDWUWV5O761/8jaF1m6WhaEWangsMhWNIgHi7aLwVLqFey4RktgiVo2RBc73aB5OWOJXNag8sJxOzUWh0dScPsVHAsBEsadCKjSAwb+Xu6mZq5QcuhVgJaCkNwtsPlBIOMNYQ4cQFHQ7Ck4bNZnn3Dw0jQOv1ig8TfMa2gnNILyuXeHVARaRYlgiXbnrigbgkcDcGSRjt3M7QMsA1fTzdTfxypuSBAU3JLKsV6ZgyNYW07OzUxOZ90mJ0KDoRgSYOzb/YkoRmlveqWEnFGC1baaxwq6hrhT0E+HnLvjib0jObaLxcqKKum8zklcu8OOBEESxpzIbeMckoqycPVhfrEBMq9O5o7o0VmCZpdr9QBWSVb8XBzob4xhlmFqFsCR0KwpDHSWH7vGMy+sSVpGEUqngdoihRYS1lJsHHdEk5cwIEQLGnM/mTDEifSrBGwjahAb2oX5E1cJnHQ+DcGaAz3ATqeXlgnKwk2HhJHsAQOhGBJY6T+SjwTDux1Rou6JbCM+wBJyw3FBHvLvTuaMqC94X2YlFMqSg4AHAHBkoYUllfT6eziOgcUsB30eAFrSVkPziphuSHbCvRxpy4RhkV18V4ER0GwpLHFc/V6ori2PhTm7yn37mjOQGP6/0ByPtXU6uTeHVBBsISTFvsYZJzpm4gsLzgIgiUtDsHhAG0XXSP9RVf00qpaOplpyOABNNS+A8PhDsryom4JHATBkobsT8YB2p64i3c/LKoLTbiYW0a5pVWifUevdlhuyJ5F3kfTCrGoLjgEgiUNLZ57wDhLayAyS/ZfVBfBEjRx0sLtOzzd0L7DHmJDvEWpARfRH07ForpgfwiWNOJ0VrHo/+Pr4SqGi8DOi+qikzdYUdwNDlhUF3VL4AAIljR2gO7fHovnOmJR3fTCCrGwLkDjxd2GIVuwc1d9zIgDB0CwpBGoV3L8oro8Kw7AXHFFNZ3KQvsOR86I4/chF9UD2BOCJY2QZt8g9W9//WMNf+P9F9HJGxpu38E1NeEBXnLvjqb1iAoQa8Xll1WLNTEB7AnBkgZwF1vpYMHDRGBfA+IMf+MDKcgsQSP1Ssgq2R0HSr3bGRYLR5YX7A3BkoayStzVNtDbXe7dcZrM0rG0IqqswbRlqL82IzK8jtHfeHIolSEA2AuCJQ1INB4ocIB2DO6QHuLrQVW1OjqWXiT37oBC6Lh9h9lEC7A/qUZTapsCYC8IljTggLF2BgWljpu2LJ3R4iANkjPZJVRcWUM+Hq7UDe07HKK/ccYhd9Qvq6qRe3dAw1QXLC1cuJDi4+PJy8uLhg4dSnv27Gl028WLF9OVV15JwcHB4jJ27Nh628+cOVN8+JlfJkyYQGpRVaOjQ6lI/ct1kEb6Hy6vV+K6QTdX1R1aVSkq0JsiA7xEU140pwR7UtU7esWKFfT444/T/Pnzaf/+/dS3b18aP348ZWdnN7j977//Trfeeitt2bKFdu7cSbGxsTRu3DhKS0ursx0HRxkZGabLN998Q2pxPIPrZnQU7ONOHUJ95d4dpyFl8Q4iswRGaEYp84QLvBfBjtys2ejdd99t9gPPmjWL/P1tm4p+++23afbs2eKx2aJFi+jnn3+mJUuW0NNPP11v+6+++qrO95988gmtXLmSNm3aRHfddZfpdk9PT4qMjCS1r27OWTFwjD6xQcS9P7kxZVZRBUVgmrjTM/U6w3C4wydc/HIkE1lekD9YevTRRykmJoZcXa1b5yglJYWuv/56mwZLVVVVlJiYSPPmzTPd5uLiIobWOGtkjbKyMqqurqaQEEMzM/MMVHh4uBiqu+aaa+jll1+mtm3bNvo4lZWV4iIpKpKvyBfNKOXh5+lGXSL8Ra0ET1ue0CtK7l0CGeWVVlFSTmmdIVpwfGaJm1PipBFkC5bYvn37REBhDVtnlFhOTg7V1tZSREREndv5+5MnT1r1GHPnzqXo6GgRYJkPwd10003UoUMHOnfuHP373/+miRMnigCsseBwwYIF9MILL5ASSLNvcDbreDzjyRAsFSBYcnJSn5+OYb4U5OMh9+44lZ7RgeTu2kb0m0vNL6fYEB+5dwmctWaJa4T8/PysflAOOC7P3sjtP//5Dy1fvpxWr14tisMlM2bMoMmTJ1Pv3r1p6tSptHbtWtq7d6/INjWGs1uFhYWmC2fS5MDDP7xGGQ8H9YkxNGcDx5EyCKiVAO7czdAywPG83F1FN2+GoTiQPVjy8bE+WudgIijItqno0NBQkenJysqqczt/31S90ZtvvimCpQ0bNlCfPn0sbpuQkCB+19mzZxvdhmucAgIC6lzkIH1Id40MEGuWgWNJ2bzDaQVUXauTe3dARtJ7ER305SEFqThxAdlnww0aNEgUVMtVn+Ph4UEDBw4UxdkSnU4nvh8+fHijP/f666/TSy+9ROvWrRPPoSmpqamUm5tLUVHKH1aRltvAAVoeCaG+FODlRhXVOjqZYVg8FZyzGeUhU2YJ70V5s7zILIHMwRJP03/qqadEEHHnnXdaHKayF24bwL2Tli5dSidOnKA5c+ZQaWmpaXYcz3AzLwB/7bXX6NlnnxWz5bg3U2ZmpriUlJSI+/nrk08+Sbt27aILFy6IwGvKlCnUqVMn0ZJA6aRp6zhAy8PFpY3pjBbpf+d17pKhGaW3uyt1jUAzSjmzvNxRv6IaSxCBjMHSp59+KgINbgrJNTpjxowRQcWrr75ar2+RvUyfPl0MqT333HPUr18/OnjwoMgYSUXfycnJok+S5MMPPxSz6P72t7+JIE+68GMwHtY7fPiwqFnq0qUL3XPPPSJ79ccff4ihNiWrqdWZmrBJ3aTB8XBGCweMWSVe1BXNKOURE+xNoX6eVKPT09E0NKcE22tWoQvXLXHHa77wzLHPPvuMPvroI1HTxM0eOdjgmWX29NBDD4lLQy7PdnG2yBJvb29av349qdHprBIqr64lf0836hhmffE92KlWwviBCc5c3I2TFlmXIGofRBuPZ4m6pUHxyppgBOrX4tOgjh07in5EHJBwx2seypo2bZpt9w6arFfqy80ReTocyEKqF7uYWyamLoPzQXG3sobipGMjgC21KmfMmRwp08Q9kLi7NjgG6pWUIdDbnTqFGzJ7WPrE+fDiracyDZNe0DZAIes1GhcWB5A1WOLZYpxR4nol7nbNmaUPPvhA1ArxbDlwDGnYB2ez8hsg1S3hjNbpcN2gTk9iMdfIQCx5IyfuNefq0oYyiyooo7Bc7t0BZw2Wvv32W9Htmjtdc+H0LbfcQqdPn6atW7eKWWhc/wOOUVheTWezDTP6ECzJzzQjDme0TluvhPeh/Hw83KhbpGE2It6LIFuwdMcdd4iAiDtg82w4ngXH2SVwvMOphgNB+xAfauun7Fl7zpT+P5RaQLWcZgCngeFwZcHsVJB9NhwPv1m7NhzYFw7QytI53F8srFtSyfUrxdQjWp6O7uB4aAyrvCLvL3clY3YqyBcsmQdK6enptH37dsrOzhZdtM3985//tO0eQj2oV1IWrpPoGxtIO87mig9PBEvOgetisooqxevfG2szKmpI/EhaIVXV6MjDDX2vwDaavaDY559/Tvfff79YfqRt27aiv4WEryNYsi+9Xm9KMWP2jbLOaEWwlFxAtw+Nk3t3wJFrM0b4i3oZkF98Wx8K9nGn/LJqOp5RhBNKsJlmh928fAh30C4sLBQz4ZKSkkyX8+fP227PoEHJeWXiQODh6kLdo7C0guKmLaNWwvmKuzEcrrDmlNKEC7wXQcZgqaysjGbMmEEuLkhvynk227NdAHm6ucq9O2DUL9ZwgD5/qZQKyqrk3h1wZO0gsheKIr0eqFsCW2p2xMNLmnz33Xc23QlowdIKxg9nUIYQXw/qEOpb5zUC7armtRnTMNFCiQbEGTt5I8sLNtTsgfYFCxbQ9ddfLxaw7d27N7m7u9e5/+2337bl/sFlpAMAUv/KPKNNyiml/ckFNLorZo5qGc96rKjWkb+XGyWEYm1GpTWn5FLa1Pxyyi6uoHB/NAsFmYIlXny2a9eu4vvLC7zBfiqqa0XRIkPqX3n6xwXTqgNpOKN1shmpWJtRWfy93EXR/cnMYlG2ML5npNy7BM4YLL311lu0ZMkSsR4cONax9CKqrtVTqJ8HxQSjY7rSSAEsD8PpdHp8iDpBvRJmWykTD41ysMQTLhAsgSw1S56ennTFFVfY5JdDS5dWCEYWT4F4qQVvd1cqrqih8zmG5WhAmw4am1GiXkmZpJpOLG4NsgVLjzzyCL333ns22wGw3l/9lXCAViI3Vxfq3c7QnJDrlkCbCsuq6dylUnG9bwzei0ok1XTyQsc1tXUbJwM4ZBhuz549tHnzZlq7di317NmzXoH3qlWrWrQj0JyZcDhAKxUHsnsu5InX6pZBsXLvDtgBrwHIsDajcnUK8yN/Tzcqrqyh01kl6KoPjg+WgoKC6Kabbmr9b4ZmuVRcKWZ38OgbllZQLqmGBel/7fc6Q4ZXubhesI9xCSI+cUGwBA4Plj777LNW/1JoeVapS7i/mO0ByiR1Dz6ZWURlVTVYBkPD9Uoo7lY2fn0MSxDl021D28u9O6ByaMOttv5KOEArWmSgF0UGeJFOT3QktVDu3QE7rM1oGg7H2ozqKPJGk1hwVLA0YMAAys+3vnfMyJEjKS0trTX7BZdB6l89pIAWyy1oz8VcrM2otiLvs5dKqKiiWu7dAZWzaozg4MGDdOjQIQoJCSFrt6+srGztvoFRrU5Ph41FpejcrXwc0K47lom6JQ2SshRcA4O1GZUt1M+TYkO8KSWvnA6nFNLIzqFy7xKomNUFFWPGjBEpaGugB5BtnckuptKqWvL1cKXO4TibVU2RNzJLmvPXEBxOWtSAe9JxsMR1ZgiWwO7BUlJSUrMfOCYmpiX7Aw2QMhR9YoLIFV2hFY9nK/LrlFlUQRmF5RQViG7rWoHaQXXh1+mnQ+mmMgYAuwZLcXFxLf4F0HqoV1IXngHHa1PxOn4c6Eb1RrCktbUZB6C4WxWkYyZnBHlkBKMe0FKYDaeqZU4QLKmFVFuGIm/trc3Y1hdrM6pFj6gAcndtQ7mlVaJPHUBLIVhSuOKKajqdXSyuo7hbhYvqIv2vyZMWZCjUwcvdVQRMjBfVBWgpBEsKx716uK6+XZA3hft7yb070Mz0/+G0AqxNpREo7lYnqR8WJlxAayBYUjhpGAcHaHVJCPUjfy83qqjW0clMQ2YQtFLcjXolVfY9Q5YXHB0sFRQU0CeffELz5s2jvLw8cdv+/fvRiNIOpDc46pXUtzYVWghoc21GXnMM1EM60TyeXkSVNbVy7w44S7B0+PBh6tKlC7322mv05ptvisCJrVq1SgRPYOulFQxns1haQX1wRqsdUsDLq9kHYG1GVWkf4kMhvh5UVaujExnI8oKDgqXHH3+cZs6cSWfOnCEvr79qaK677jratm0b2dvChQspPj5e/O6hQ4fSnj17LG7/3XffUbdu3cT2vXv3pl9++aVeQPLcc89RVFQUeXt709ixY8VzUwI+k80pqRKzOXpi1WwVT1tGYanaYfFc9eJi/L4xgXWGUgHsHizt3buX7r///nq3t2vXjjIzM8meVqxYIYK1+fPni2G/vn370vjx4yk7O7vB7f/880+69dZb6Z577qEDBw7Q1KlTxeXo0aOmbV5//XV69913adGiRbR7927y9fUVj1lRUUFKqVfi2Rw8qwPUpW+M4YP13KVSKizH2lRqhsVz1Q1F3uDwYMnT05OKigyN2cydPn2awsLCyJ7efvttmj17Ns2aNYt69OghAhwfHx9asmRJg9v/73//owkTJtCTTz5J3bt3p5deekksCvz++++bskr//e9/6ZlnnqEpU6ZQnz59aNmyZZSenk5r1qwhuUlnQThAq1NbP08xBMAO4SCt6rUZD6UUiuvILKkThsTB4cHS5MmT6cUXX6Tq6mpTijM5OZnmzp1LN998M9lLVVUVJSYmimEyiYuLi/h+586dDf4M326+PeOskbQ9L+PC2TDzbQIDA8XwXmOPyXiRYA4YzS/2gGaU2uogDOp07lIJlVTWkLe7K3WJ8JN7d6AF+hqPocl5ZZRbgkXewQHB0ltvvUUlJSUUHh5O5eXlNGrUKOrUqRP5+/vTK6+8QvaSk5NDtbW1FBERUed2/r6x4T++3dL20tfmPCZbsGCBCKqkS2xsLNkaZ72qagz9edA2QAtntKiVUCvptesTE0hurui2okaB3u7UMcxXXD+UihMXsNPacOY4ONi4cSNt375dzIzjwImHti7P4GgZz/rj2ikJZ5ZsHTBxxu7nf14pal0CvJr9MoECayWwNpU6mTK8OGlRNe6PxfWDPBR3Tbe6J8gATWnxp/DIkSPFxVFCQ0PJ1dWVsrKy6tzO30dGRjb4M3y7pe2lr3wbz4Yz36Zfv34W67b44qgzIlCv7lH+5OHqQvll1WIIIK6t4ewWVLiQNZpRqhpn6FfuT8WQODgmWOKZYw3hM2aens9DcldddZUIbGzJw8ODBg4cSJs2bRIz2phOpxPfP/TQQw3+zPDhw8X9jz76qOk2zorx7axDhw4iYOJtpOCIs0Q8K27OnDk23X9wTp5urtQjOkAcoPlDF8GSupRW1tDpLENvHgyHq5t5k1idTi8axwLYLVh655136NKlS1RWVkbBwYYzrfz8fDErzc/PT0zjT0hIoC1btth8aIqHvu6++24aNGgQDRkyRMxkKy0tFbPj2F133SVaGHBNEXvkkUdETRXXWU2aNImWL19O+/bto48//tgU4HEg9fLLL1Pnzp1F8PTss89SdHS0KSADaC3+kOUDNF+m9m8n9+5AMxxOLSSdnigq0IsiArA2o5p1i/QnL3cXKq6oofM5JdQp3F/uXQIVaXa14quvvkqDBw8WjRtzc3PFhdsG8AwynqrPM+M4W/PYY4/ZfGenT58uuoZzE0nOBB08eJDWrVtnKtDm352RkWHafsSIEfT111+L4Ih7Mn3//feiJUCvXr1M2zz11FP08MMP03333SeeF9dg8WOaN9wEaA0UeavXAVMHfWSV1I6L8/u0QwsBaJk2eq46bYaOHTvSypUr69X0cNNHbh1w/vx50QySr5sHLlrGQ3dc+F5YWEgBAei0DXWl5JXRla9vEZ3Yjzw/Hg1GVeS+Zftow/Es+vd13ei+qzrKvTvQSq/+coI+3naebhvanl69sbfcuwMq+vxudmaJA6Campp6t/Nt0nR7HsYqLsYaPAAsJtib2vp6UHWtno5n2KcnF9gen0dKXfR5JhWoX3+pbgmZJWimZgdLV199tVjuhDNJEr7OBdHXXHON+P7IkSOi/gcADLVx6CCsPumFFXSpuJJcXdpQ73aGtcVA3aT2D6eyiqmsqv5JP4DNgqVPP/2UQkJCxMw0aQo9F1zzbXwf40JvLqoGAAN08lYfKfvAhcHeHhg61YKoQG+KCPAUS9gcSTUsYQPqGD59a8MpSisoV89sOC7e5un3J0+eFIXdrGvXruJinn0CgL9Iwzgo8laPv9ZmRHG3lnC/rHXHMsWJy9CEtnLvDjShplZHX+y8SOXVtTS5bzSprillt27dxAUAmtYnNpC4eXdqfjnllFRSqJ9jmpqCLdZmRL2S1obiOFjCkLg6nM4qEYGSv6cbdQzzU1ewlJqaSj/++KOYqs8L3Jp7++23bbVvAJoR4OVOncL86Ex2iRjeGdsDyy0oWXWtjo6kGYZpsJC1Rou8MSSuCgeNrxOfcMrZSLTZwRJ3u548ebJoPMlDcdyz6MKFC2LmCK8RBwAN4w9dDpa4dw+CJWU7mVFMlTU6sS5jQii6rmtJ75hAUbSfWVRBGYXloo4JlOugsdeZ3CctLi1ZRPZf//qXmPHGjRu551JKSorolD1t2jT77CWAxhbVBXUcoPvGBmFZDI3x8XCjLhGG7t1oIaB8B5KVMRze7GDpxIkTYlkR5ubmRuXl5WL224svvkivvfaaPfYRQBOkM6NDKYViNg6oYPFcY4AL2oLZqepQXFFNZy+VqDOz5Ovra6pTioqKonPnzpnuy8nJse3eAWhIlwg/8vFwpZLKGjpnPACAMkkfolJ9C2iLqe8ZgiXFr82o1xsa+4b5e6orWBo2bBht375dXL/uuuvoiSeeoFdeeYX+/ve/i/sAoPG1qaTmhkj/K1dBWRWdzyk1DcOB9khBMPda4qnpoPQZqUFy70rzgyWe7caL5rIXXniBxowZQytWrKD4+HhTU0oAsNxBWFqgFZR7gI5v60Mhvh5y7w7YAU9B56noPCWdu3mD0uuVguTelebPhuNZcOZDcosWLbL1PgFouiEeQ48X5VLS2SzYBxftc9Zw+9kc8V7sGY3lbJRGr9f/NRzeXoWZJQ6WcnNz691eUFBQJ5ACgPqkN/3prGIqrcTaVEqkpLNZsB8UeStbqrGBr7trG0UEs80OlrinUm1tbb3bKysrKS0tzVb7BaBJEQFeFB3oRTwZjosXQVl0OvOzWcyE0zIpGEawpEwHjK9L96gA8nJ3Vc8wHHfslqxfv54CA/+K9Dh44maVXLcEAE3XLaUfMaxNNbwj1qZSkqTcUiosryZPNxdxkAbtB0tns0vEax7o7S73LkEDazMOUMhJi9XB0tSpU8XXNm3a0N13313nPnd3dxEovfXWW7bfQwANHqR/OcJrU6HIW6lDcDxr0cOt2Yl3UJG2fp7UPsSHkvPK6HBqAV3ZOUzuXYIGe50FqStY0ukM0ys7dOhAe/fupdDQUHvuF4BmScM7nGbmIkY+AQFl2G8MYJVygAb7n7hwsMQfzAiWlKOiupaOpRfWmRQjt2afOiUlJSFQAmiFXtGGtakuFVdSemGF3LsDDZzNKiX1D/aFuiVlOpZeRNW1egr186DYEG/1ZJbeffddqx/wn//8Z2v2B0DzvD1cqXuUPx1NKxLNKdsFKeNg4Ox4duKpzCJxHcXdzjcjDlle5ThgzPDyenBKeU2sCpbeeecdqx6MnxSCJQDrzmhFsJSST5P6RMm9O8Br9qUWiFmKPFsxMtBL7t0BB+gRHUAeri6UV1olhuPi2vrKvUtAZhneOOUMh7tZO/QGALbDZ0xf7kpGc0oFweK5zsfTzVUETJxZ4guCJWVllvorpF6JtWq6B6ct+QIALUv/H0krpGqsTaUISpt9Aw5eVBcnLoqQWVghajld2hD1iZG/GWWrgqVly5ZR7969ydvbW1z69OlDX3zxhe33DkCjOrT1pQAvN6qs0dHJDKxNJTc+6TOdzSKz5FSk4FhqggjyOmB8H3aLDCBfz2avyKashXTnzJlD1113HX377bfiMmHCBHrggQesrm0CcHa8NlU/44cy1y2BvFLyyim3tMq4tAKaUToTaajnRHoRVdbUX50CHEup7TuaHba999579OGHH9Jdd91lum3y5MnUs2dPev755+mxxx6z9T4CaDb9v+30JXFGe+dwuffGuUkHaF6DSglLK4Dj8NT0EF8PUeTNU9bRNkJeBxTavqPZmaWMjAwaMWJEvdv5Nr4PAKzTX+rxgloJ2R1Q6Nks2B/P4sZ7URmqanSijlOJ78VmB0udOnUSQ2+XW7FiBXXu3NlW+wXgNIWl53NKqaCsSu7dcWpSvYrSzmbBMdCcUhlOZPBQqI6CfNypQ6ivuofhXnjhBZo+fTpt27aNrrjiCnHbjh07xEK6DQVRANCwYF8Pim/rQxdyy8RBenTXcLl3yWmXVjieXqTIs1lw3OLW7ADqBxXSMiBIMc0om51ZOnr0qPh688030+7du8WSJ2vWrBEXvr5nzx668cYb7bmvAJojzbzCGa18OO1fo9NTmL8nuqk7qb7iw9lQ6J9TUin37jit/QrudWZ1ZonbAwwePJjuvfdemjFjBn355Zf23TMAJ0n/rz6QhmBJAWezA9or72wWHCPAy506hvnR2ewSUbc0tkeE3LvklA4YM3tKHA63OrO0detWMePtiSeeoKioKJo5cyb98ccf5Ch5eXl0++23U0BAAAUFBdE999xDJSUlFrd/+OGHqWvXrqIXVPv27cVSLIWFhuIxCR8cL78sX77cAc8IoG6tBBq8ymP/ReWezYLjoG5JXpeKK0Vmj89X+sYqpxlls4OlK6+8kpYsWSJmvHH7AF4CZdSoUdSlSxd67bXXKDMz0647yoHSsWPHaOPGjbR27VpRM3Xfffc1un16erq4vPnmm2II8fPPP6d169aJIOtyn332mXhe0mXq1Kl2fS4Aku5RAeTh5kIFZdWidgkciwNUqW2AEs9mQZ5FdUG+DG+XcH/y93InpWn2bDhfX1+aNWuWyDSdPn2apk2bRgsXLhSZG+63ZA8nTpwQgc4nn3xCQ4cOpZEjR4qAjTNAHBA1pFevXrRy5Uq64YYbqGPHjnTNNdfQK6+8Qj/99BPV1NTU2ZYzVZGRkaaLlxcW0QTH4ECpl7EJonSwAMfJKKyg7OJKcnVpQ73bKe9sFhyfWTqUUkA6XlEZZJmR2l+hkyxatTYctxH497//Tc888wz5+/vTzz//TPawc+dOEdAMGjTIdNvYsWPJxcVFFJtbi4fgeBjPza1uqdaDDz4oitSHDBkismdNDYdUVlZSUVFRnQtAS0nDP1ibyvGkrFL3KH/y9kAzSmfWNcKfvN1dqbiyhs5earzEA+xj/8V8bQZLPAzGdUuciXnyySfppptuEi0E7IGH+MLD606r5oAnJCTE6uG/nJwceumll+oN3b344oui5QEP7/FMv3/84x8ia2XJggULKDAw0HSJjY1twbMCoDrDP9IHNziOUrsFg+O5ubqYamWkD25wjJpaHR1OLVT0e7FZwRIPeb366quiTmn06NF09uxZevfdd8XtixcvpmHDhjXrlz/99NMNFlibX06ePEmtxZmfSZMmUY8ePcSSLOaeffZZ0S+qf//+NHfuXHrqqafojTfesPh48+bNE1kq6ZKSktLqfQTnNSAuyNSQrbSy7hAxOOc6VCAP6YM6EcGSQ53KKqby6lry93ITsxKVyOrWARMnTqTffvtNDFfxunB///vfxUyz1uCZdZydsiQhIUFkr7Kzs+vcznVHPOON77OkuLhYLPTLw4SrV68md3fLhWNcE8UZKB5q8/T0bHAbvr2x+wCaKyrQm6IDvSi9sIIOpRbQiI6hcu+SU+BFU4+lFSn6bBYca2Acsrxy9lfqFxskFhlXdbDEQcb3339P119/Pbm62mZsPywsTFyaMnz4cCooKKDExEQaOHCguG3z5s2k0+lEcGMpozR+/HgR2Pz4449WFW4fPHiQgoODEQyBQw2IC6b0wxki/Y9gyTG4a3dVrU4soto+xEfu3QEF1Q+eu1RK+aVVoss+2N9fazMq96TF6mE4DjamTJlis0CpObp37y6yQ7Nnzxadwrk26qGHHhLNMaOjo8U2aWlp1K1bN3G/FCiNGzeOSktL6dNPPxXfc30TX2pra8U2PDOOZ9hxawEeUvzwww/FMCP3ZwKQ44wW6X8ZugUrcGkFkAcHzglhhjXJsPSJ42sH+yt4OLzZa8PJ5auvvhIB0pgxY8QsOC7G5nopSXV1NZ06dYrKygy9avbv32+aKcez9sxxj6j4+HiRLeO2B4899piYAcfbvf322yIoA5An/W+YtqzUVLQmO3cb//YAbGD7YDp/qVScuFzTDZ287S2/tIqSckpNJy5KpZpgiWe+ff31143ez8GP+ZR/LkBvqgUAZ6v4AqCE5pRe7i5UWF5N53NKqFO4v9y75Dxnswo+QIM8Jy7fJaYiy+sgB439lTijF+Sj3GHPVvVZAgDbcHd1oT4xQXWW3wD7yS6qoLSCcuIEXh8ES2BGyjQeSimk6lqd3LujeftV0kEfwRKAQqBuyfH1Sl0i/MnPUzUJdnCATmF+Ygo7T2U/mVEs9+5o3gEV1CsxBEsACqqVYImYtmx3aph9A/LgekE0inWMWp1eLC/D+scq+72IYAlAYen/s9klVFBWJffuaNo+Y/ZOyuYBmEOW1zFOZRaL5WU4u9s1Utl1mgiWAJQ0bTlUmraMuiV7qaiupSPGpRUGIViCBiBYcozEi3mmIThezFrJECwBKDC7hLWp7OdoWqFoRhnq50FxbdGMEurry52k25CYBJBZWCH37mjWPhVleBEsASgI1qZy7AEazSihIYZhoQBxHXVL9rPvguFvOyguhJQOwRKAgkhnWNx7hFfiBuc+QIN8BhoXuMaJi31wxk5q39FP4TPhGIIlAAXpHO5H/p5uVFZVSyczMW3Z1rhRrVQnMTBe+al/kA8W1bWvfcb3ITfkVUP7DgRLAAqbttzfeJCWpreD7YgFUsuqydPNhXpFB8q9O6BgA9uHmGrceFIA2CvDq46TFgRLAErtt4T0v81JWSUu4PVww+EPGhcb4k2hfp5UXasXARPYlnR8GxivjuFwHC0AFGaAVCuBzBI5+9ksyIeL/wcYa2lw4mJbpZU1dDyjSFXvRQRLAArTLzaIeJJWSl65WMMMbEf60BuEeiVoRt2SNIMSbIMnsHD37nZB3hQd5E1qgGAJQGH8vdypm3Ha8l5jJgRaL7ekks7nlKpi0U5QBimo5iCbJweAbTO8auivJEGwBKBAQ4wH6b0XDDU20HpSdoBnHAb5eMi9O6ACvdsFickAeaVVYnIA2HYmnJoyvAiWABRocAdD0SOCJdvBEBw0F08C4GFxhveibfDw24Fkw3JOyCwBQKsMNs4QOZFRRMUV1XLvjibsM37YoRklNMcQ6cQlCcGSrRbPLTEuniuVG6gBgiUABYoI8KL2IT6k02Mmji1wn5yjacbZN8gsQTMMMp647EFmyekWzzWHYAlA4dklqRgSWu6IafFcTxGEAliL2wfwZ3pqfjllFJbLvTuqt1eFxd0MwRKAQg3pYDiY4IzWtv2VsHguNHd2ao9ozE61ee2gyobDESwBKDz9zz1JKmuw3IJN6pUwBAetyPKibql1ODOnpsVzzSFYAlCohFBfCvXzoKoaHR1JxXILLaXT6U3d0NWW+gdlGCIFS8jy2iTDq5bFc80hWAJQKB4uklLVSP+33LlLJVRQVk1e7i7UE4vnQiuyvKeyiqmwDLNTWz8jVX0nLQiWABQM/ZZab5dx6IS7dmPxXGiJMH9P6hDqS9zEOzEZ78WW2m18Lw5NaEtqgyMHgIINNtbY8BkZDydB8+0xHqClfjkArXkv7klClrclCsqq6GRmcZ0aMDVBsASgYD2iAsjXw5WKKmrEEAA0D6/ntft8rrg+tIP6zmZBgUXeyPK26qSlY5ivyNSpDYIlAAVzc3WhAdLK5zhIN9uF3DLKLq4kD1cX0QQPoLXB0uHUAtHkFJxnCI4hWAJQOKnIew+KvJtNyirx+l5e7q5y7w6oWFxbH5ERqa7V06EUw9pmYL3dSVKGV31DcAzBEoDCDTY2p+QeLzysBNZDvRLYcnYqWgi0TFFFNR1PL1L1cDiCJQCF6x8bTO6ubSizqEIsuQAtSf0jWAIbFnkjy9ssiRfyxTqXnJ2LDPQiNUKwBKBw3h6u1KudoT8Qzmitl5JXJroFu7m0QTNKsGkrj/0X86kWs1OttkvlQ3CqCpby8vLo9ttvp4CAAAoKCqJ77rmHSkpKLP7M6NGjRerU/PLAAw/U2SY5OZkmTZpEPj4+FB4eTk8++STV1NTY+dkAtKy4VBpWAuuzSr1jAsnHQ13dgkGZukUGkL+nG5VU1tCJDMOwEjRt9/k8VQ/BqSpY4kDp2LFjtHHjRlq7di1t27aN7rvvviZ/bvbs2ZSRkWG6vP7666b7amtrRaBUVVVFf/75Jy1dupQ+//xzeu655+z8bACaRzoj22UsWIam7TGezaJeCWzF1aWNaX1BvBetU1pZQ0fTClU/HK6KYOnEiRO0bt06+uSTT2jo0KE0cuRIeu+992j58uWUnp5u8Wc5YxQZGWm6cGZKsmHDBjp+/Dh9+eWX1K9fP5o4cSK99NJLtHDhQhFAASgp/c+LT/JUeF6MEqzPLA1T8dksKM/wjob/TzvPIViyxv7kfKrR6aldkDfFBPuQWqkiWNq5c6cYehs0aJDptrFjx5KLiwvt3r3b4s9+9dVXFBoaSr169aJ58+ZRWVlZncft3bs3RUREmG4bP348FRUViSxWYyorK8U25hcAewrwcqfexrolHKSblllYQRdzy0SAKWUCAGxheEKoaUi8plYn9+6oaAguhNRMFcFSZmamqCcy5+bmRiEhIeK+xtx2220ia7RlyxYRKH3xxRd0xx131Hlc80CJSd9betwFCxZQYGCg6RIbG9uKZwdgnWE4o212TxdeONffy13u3QEN6REdQAFeblRcWUPHjNPhwYr+SioegpM9WHr66afrFWBffjl58mSLH59rmjhTxNkjrnlatmwZrV69ms6dO9eq/ebAq7Cw0HRJSUlp1eMBWGO4sfPtTtRKWD0Eh3olsEfd0hDj0C7ei5Zxp/NDKcZ6JZUPh8s6ReSJJ56gmTNnWtwmISFB1BplZ2fXuZ1nrPEMOb7PWlzvxM6ePUsdO3YUP7tnz54622RlZYmvlh7X09NTXAAcPSOOp8FzryWeFh8bot7xf3v7az04BEtgn7ql305k0Z/ncumBUR3l3h3FOpBcQFW1OooI8BQ9ltRM1mApLCxMXJoyfPhwKigooMTERBo4cKC4bfPmzaTT6UwBkDUOHjwovkZFRZke95VXXhGBmDTMx7PtuAi8R48eLXxWAPbh6+lGfWODKPFivhiKQ7DUsEvFlXTuUim1aYPMEtg3y8vrNVbX6sjdVRUVLTIucdJWjBSpmSpe4e7du9OECRNEGwDOBO3YsYMeeughmjFjBkVHR4tt0tLSqFu3bqZMEQ+18cw2DrAuXLhAP/74I91111101VVXUZ8+fcQ248aNE0HRnXfeSYcOHaL169fTM888Qw8++CAyR6BIGIprmtSLqmuEPwX5eMi9O6BB3SL9KdjHncqqasXCumC5uFsLJy2qCJakWW0cDI0ZM4auu+460T7g448/Nt1fXV1Np06dMs128/DwoN9++00ERPxzPOR38803008//WT6GVdXV9Gzib9ylomLvzmgevHFF2V5jgDNmbaMdeK0uWAnKJ+LSxsaJp24YMJFgyprakXbADZM5cXdTDVtbXnm29dff93o/fHx8XU+PHiG2tatW5t83Li4OPrll19stp8A9sTLdni4uoh14rjnUodQX7l3SXG4joRJH2YA9jpx+fVopsjyPnRNZ7l3R5H1SpU1Ogr186SOYX6kdqrJLAEAkZe7K/VrHySu44y24f5KZ7NLRL3SiI6GfjgA9q1byhdZFKhrx9kc8XVkJ/XXKzEESwAqM0IaikPdUqMH6D7tAinQB/2VwH46hfuJrAlnTw4mo27pctuN78UrOmnjpAXBEoBai7xRt9RosKSVAzQoF2dLpFocaegXDIoqqulQSoGm3osIlgBUhofhPN1cKKekUgw5gQEHjtLZ7EiNHKBB2UwTLpDlrWPXuVzS6YkSwnwpOsibtADBEoDKeLq5mtY7w0H6Lxw4ZhdXikByQBzWgwPHZXl5GI67VcPl9UraOWlBsASg8qE4MJCyStzThQvhAeyNZ6Nyd2ruUs3NYkGb9UoMwRKAitP/u87nko7z3YB6JZClbgknLnVlFJaLDvoubbTVvgPBEoAK9YkJIh8PV8ovq6YTmVj5nJec2GXsFqyl1D8on9SiYsc5Q7Du7HaczTUdowK9tTMjFcESgArxWlTSWdsfZ3CQ5iUnSiprKMjHnXpEBci9O+BEruhsCJZ49ldhWTU5ux2mDK92skoMwRKASo3qYliEeuupS+Tstp/JNfWg4qUoABylXZC36LnEo+HOnl3Sm81I1dpwOIIlAJW6yhgs7buYR6WVNeTMUK8EcrqqM05c2JnsErpUXEle7i40oL22ZqQiWAJQqfi2PhQb4k3VtXpR6O2sOFCUFuxEvRLI4aouhv93285ccupGsduNJQGD47U3IxXBEoCKZ+KYhuJOO+8Z7Z6kPKrR6Skm2Jvah/jIvTvghLh+kPt7ZRjXJnRWOzTYX0mCYAlAA+n/bU4cLJl37dbCgp2gPpxF4f5eznziUi1mpOZqdjgcwRKAio3oFEpuLm3oQm4ZXcwtJWeEeiVQAmfP8h5KKaDSqloK1uiMVARLACrm5+lGA41LezhjdomLSU9mFptmwgHIHSzxsLAzLn2y3XjSwidwWpyRimAJQCOz4raedr5py1KA2DM6gNr6ecq9O+DEuH1AVKAXVdb8NRzlTLYa34tXajTDi2AJQCNntDvP5VBVjY6cye/GA/Toroa/AYASJlxsc7ITl7zSKjqYUiCuj9LoexHBEoDKcX1AqJ+HqBdwpsU8a3V6+uOMIVi6umu43LsDYMrycgsBZ/KHaJlA1C3Sn6ICvUmLECwBqBzXB1zZ2fkO0nwmW1BWTQFebtQvNkju3QGgKzqGigVkuX1AWkE5OYvfjc04tZpVYgiWADTAGZc++f1Utvh6ZZcwcnPFoQzkF+jjTv3bO9eEC51Ob3quWs7w4ggDoAEjjYt5Hs8oouziCnKms1ktH6BBfZyt99mRtELKLa0if7OZuVqEYAlAA0L9PKl3u0Bx/Q8nKC7llgF8kDbPqgEogTQUxVPpa2q1P+FiizHDy33O3DWc4dXuMwNw0vWpnKEpnnTW3qtdAIX5o2UAKAeftAT5uFNxRQ0dMM4Qc4YM72gN1ysxBEsAGjHaOBzFwZLWz2g3ncwSXzEEB0rj6tLGNBS36YQh66JV2cUVdCi1oM7xR6sQLAFoxID2wWKpgcLyatqn4RYClTW1pkL2a3tEyL07APWMNf6//O2EIajXqi0ns0XLgD4xgRQZ6EVahmAJQENntNd0Mx6kj2v3IL3rfJ7oKRXu70m9og11WgBKwnV0vGYjtxC4kKPdNRs3HjdkzsZ21/5JC4IlAA0Z2z3cdEar51M+DdpkPFsf0z1Ck2tQgfoFervT0IQQTWeXKqpraftZQ4YXwRIAqAr3HPJwdaELuWV07pL2zmg5AJSyZtf20HaNBKjbGCnLq9FgacfZHKqo1lF0oBd1j/InrUOwBKAhfp5uNLxjW80epLmPVHphBXm5u9CIjtpcsBO0Qcq27L2QTwVlVaQ1vxmPL1yfxeviaR2CJQCtDsVpsG7pN2ONBC/v4uXuKvfuADSqfVsf6hrhL9YwlKbXa6lr92/GmX7OMASnqmApLy+Pbr/9dgoICKCgoCC65557qKSkpNHtL1y4IKLdhi7fffedabuG7l++fLmDnhWA7XEtD0tMzhfNG7Vkw/HMOgEhgJKNNQ4VS/9vteJgaoE4tnAmW6rN0jrVBEscKB07dow2btxIa9eupW3bttF9993X6PaxsbGUkZFR5/LCCy+Qn58fTZw4sc62n332WZ3tpk6d6oBnBGAf0UHe1DcmUEzp1dJBOjm3jI6lF4lZf9f2iJR7dwCaNKFnlPi65eQlKq+qJa1Yd9RwXLmmWzh5ujlHhlcVwdKJEydo3bp19Mknn9DQoUNp5MiR9N5774kMUHp6eoM/4+rqSpGRkXUuq1evpltuuUUETOY4U2W+nZeXtvtFgPZN6BVV56CmBeuOZYivQzuEUIivh9y7A9Ak7jAfE+xN5dW1mumsr9fr6dejhvfixF7Oc9KiimBp586dIqAZNGiQ6baxY8eSi4sL7d6926rHSExMpIMHD4rhu8s9+OCDFBoaSkOGDKElS5Y0OeW6srKSioqK6lwAlEQ6iP15LpfyS7VRXPqrMfBzpgM0qBuXdUzoafj/us4YYKjdsfQiSskrF5MspHXwnIEqgqXMzEwKD69bo+Dm5kYhISHiPmt8+umn1L17dxoxYkSd21988UX69ttvxfDezTffTP/4xz9E1sqSBQsWUGBgoOnCQ34AShIf6kvdIg3FpRs1MCsuo7CcDiQXEE+6GW/88AFQg4m9I01Ln3D3ebVbZzxpGd0lnHw83MhZyBosPf30040WYUuXkydPtvr3lJeX09dff91gVunZZ5+lK664gvr3709z586lp556it544w2Ljzdv3jwqLCw0XVJSUlq9jwC2NlFDQ3Hrjc9hYPtgCg/AMDmoR//YYIoI8KTiyhr682wuqd2v0hCcMQh0FrIGS0888YSoR7J0SUhIEHVE2dl1FySsqakRM+T4vqZ8//33VFZWRnfddVeT23JNVGpqqhhqa4ynp6eYlWd+AVAa6WC2/UwOFVVUkxaG4CZgCA5UhrvMS9lQKdBQqzNZxaLZLTe+5eJuZyJrDi0sLExcmjJ8+HAqKCgQdUcDBw4Ut23evJl0Op0IbqwZgps8ebJVv4vrmoKDg0VABKBmncP9qGOYrzi4bTyWRTcPjCE1yi6qoD0X8sR1BEug1izvsp0Xaf2xLHp5qo483FRRAVPP2sOGYG9k51Dy93InZ6KKV4xrjSZMmECzZ8+mPXv20I4dO+ihhx6iGTNmUHR0tNgmLS2NunXrJu43d/bsWdFm4N577633uD/99JOYYXf06FGx3YcffkivvvoqPfzwww57bgD2wsPYN/Q1vD9+PNTwrFE1+OlwhmiDMDAumGKCfeTeHYBmG9IhRCz8XFheTdtUOitOr9ebjiOTjccVZ6KKYIl99dVXIhgaM2YMXXfddaJ9wMcff2y6v7q6mk6dOiWG28zx7LaYmBgaN25cvcd0d3enhQsXisxVv3796KOPPqK3336b5s+f75DnBGBv0kFt+9kcyi1RZ4PKHw+mOe0BGrSBe4Nd38fw//cHlZ64HEkrpKScUjEL7toeztG121wbvVaXJncgbh3As+K42Bv1S6A0N7y3XRzoXprSk+4cHk9qciGnlEa/+bv4sNk1bwyF+WN4HNTpUEoBTVm4g7zdXWnfM2PJ11NdM8leXnucPtmeRNf3iaL3bxtAzvb5rZrMEgC0zJR+6h2Kk/b5ik6hCJRA1frEBFJ8Wx/RoFJti1zX6vT002HDe3FKv3bkjBAsAWgcp/+5PxGvfp5WUE5qwUnvHzAEBxqqIZT+H/9wUF0nLruTcimrqJICvNzoqi6h5IwQLAFoXGSgl1gihEnBh1o6BYtpym4uNL6n89VIgPZMNmZ5uchbTTWEPxqDu+t6RznNWnCXQ7AE4ARu7G9InX+fmNrkcj5KwfvKuJjU2aYpgzZ1Cven3u0CqUanV012qayqxtQyYKrxOOKMECwBOIFJfaJFYen5S6W0PzmflK6iupZWHzBkwW4ZhOWEQDtuGWTod/btvhRVnLj8eiSTSiprKK6tjylD7YwQLAE4AT9PN5rUx7D8ybd7DRkbJeMCWO5JExXoRSM7OWeNBGjT5L7txNDyycxiOpqm/EXYOahj0wbGiLorZ4VgCcBJSBmatYfTRWpdyb7dZwjo/jYwRrQNANCKQB93mmBc/kQKRJTqYm4p7U7KExNE1LoCgK0gWAJwEoPjg8XU5dKqWvrliHIX100vKKc/zlwyBUsAWjPNOBTHEy54yFnpdYNXdg6jqEBvcmYIlgCcBKfQpxmzS8v3JJNSGYrQSdRHxLX1lXt3AGxuRMdQahfkTUUVNbTOuEi00tTU6ug7Y4b3FmNw58wQLAE4Ec7UuLm0oX0X8+l4uvLqJaprdfT1bkMgd+uQ9nLvDoBd8NDy9MGGE5cvdl0kpdYNZhZVUFtfD6dc3uRyCJYAnEhEgBdN6GWol1i28wIpzcbjhgN0qJ+n6OkCoFUzhsSSu2sbSryYT0fTCklplv550XTS4umkvZXMIVgCcDJ3jzCsD7fmYBoVlFWRkiz90xDA3TokVswYAtCqcH8vmtgrSpEnLqezimnn+VziuRW3DUWGl+FoBOBkBsUFU/eoAKqo/qsmQQlOZhaJmTc8RIEDNDiDu0fEia/coDK/VDknLlLwNq5HJEUHOXdhtwTBEoATFnrfPdxwkF6264JYJFNJaX9e2sTZZ96AcxjQPph6RgdQZY2OViikjQD3N1u139AQ9i5jMAcIlgCcEq8cHuTjTil55fTrUcNSBnLKLq6glfsNWa67hxuGCQGc4sTFOCz+2Y4kqqyRv43Al7suUllVLXWJ8KPhCW3l3h3FQLAE4IS8PVxNQckHW87JvuzCku0XqKpGR/3bB9EQJ15SAZzP1H7tKDLAi7KKKk0ZHblwzycO2tgDozo6dcfuyyFYAnBSM0fEk4+HKx3PKKKtpw1NIOVK+/PZLPvH6E44QINT4YkM917ZQVz/aOs5WYfFuaN4TkmV6AF1Q99o2fZDiRAsATipYF8PUy+jD34/J9t+fLHzglios2uEP43pFi7bfgDIhd+HPCx+IbeMfjmSIVuPs4+2nhfXHxiVQO6uCA/M4a8B4MT4jJZ7vexJyhMXRyutrKHPdhhm3swZ3ZFcsA4cOCFfTzeR6WULt5wlnQzZpTUH0iitoJxC/TxMnf7hLwiWVIKHJpoanvj888/FNjNnzmz173v++efFY/FjmuPH5tt///33Vv8OLeG/R0v+9vHx8Y2+rpbusxWedfa3gYYD4+vrTjq8dumTP5Iot7SK4tr60PV90IQSnBcHS/6ebnQys5h+PJTu8Fql//52RlyffWUCebmjCeXlECwBOLlHx3YmL3cXsQQKd9B2lJySSvp4m2H478nxXckNaX9wYkE+HvTA6I7i+psbTjl0ZtwXOy+KrBIXmkuz86AuHJ0AnBwvgXLPSEOB6evrT4kFNB3hvU1nqLSqlvrGBNIkLG0CQH+/ogOF+3tSan45fbkr2WETLN7fclZcf/zaLsgqNQLBEgDQ/aM6igLTs9kl9K0Dunon5ZTSV8YFc+dO7IYZcADGlh6PXdtFXH9/8xkqLKu2++/84PezImDqHO5HNw1oZ/ffp1YIlpzIunXraNKkSRQWFkaenp6UkJBAjz/+OOXm5trk8VNSUuj++++nuLg48fjh4eF000030d69e23y+KNHjxYfqhcu1F1H6b///a+4nX9nWVlZnfv+9a9/ifu+//77Orfzc37yySepc+fO5OXlRSEhITRhwgTasGFDg7+bH4NriKqqqujFF1+kbt26id83derUJve7vLyc/u///o86dOggflfHjh1p/vz54rGUIsDLnf55TWdx/bV1J8UQmb1wXdT/rT5CNTo9je4aRiM6htrtdwGozbSBMdQp3I/yy6rpP+tO2H2JoU//MPRVmjuhG4bCLcBfxkk8/fTTNHHiRPrtt9+oa9euNHnyZHJzc6N33nmHhg4dSllZratVOXLkCA0YMIA+/vhj8vb2FkESByKrV6+mESNG0Hfffdfq5zBq1Cjx9fLi8i1btoivHHz8+eef9e7jQEf6WZaWlkZDhgyhN998U/wMBzz9+/cXf5vx48eLv0lDdDqd2Pb1118XAc+UKVMoKsry8BE/Pj/mq6++SoWFhSJY7d69O73xxhv0t7/9TfZmkObuGh5HPaICxFnmiz8dt9vv+T4xlf48lyvqpF6c3MtuvwdAjThgeWWq4X3xzZ4U2n3eNiezl+N+Tk+vNJy0jOsRQWN7RNjl92gFgiUnwIHKa6+9Rr169aJjx47R9u3bxW2nTp2i5557js6dO0ePPPJIix+fP/Bvv/12ysnJoaeeeopOnDhB33zzDe3YsUNkdDjI+Pvf/04ZGRmtzixdHizxY//xxx/Us2fPevdxcHLw4EHq0aOHyKZJHnjgATp//jzddtttdObMGVq+fDlt2rRJ/KyPj4/IOPHPNZQ54+357/bzzz/Tt99+Sx9++KHFfebAi/ePgzH+2ZUrV9LatWvp8OHDlJiYSMnJjqlLsPYg/Z+be4uVxnk2zpZT2Tb/HZyxeuUXw9nyo2O7UPu2Pjb/HQBqNzShLd06xDBLdd7qI3Yp9v5q90U6mFJAfp5u9OIUnLQ0BcGSSlsINHSZNWtWgz/zyiuviK8cwHTq1KnOY3GLgH79+omghoOdluAggzNL7du3p5dffrlO/cnNN98ssjElJSW0ZMkSao3hw4eLoS/zgOjQoUOUn59Pd911lxj+M79v27ZtIpgyzypxkMTBip+fH7333nvk4eFhum/kyJEikKqtraWFCxc2uA8LFiygdu2sH9f/4IMPxNe33nqL2rb9a50lfh2effZZUpo+MUE06wpDsfe8lUdsOhzHvWOeXnmYCsqqqXtUgKmoHADqe3pCdwr186Tzl0rptV9P2fSxz2YX039+PSmuz53QlSIDvWz6+FqEYEll7r777kYvV1xxRb3ts7OzRUDBQ2KcWbocBzb8cxwgcKajJThzwm655RZyd3evd/+dd95ZZ7uW4nofHj67ePGiqW5JCo4468QXro+S6pbM75NwVo1xfRLXKTVnX/lvdcMNN1i9v5w14gvXbl199dX17r/11ltJiZ4Y14USwnwps6iCHll+wGbLLyzado5+O5FNHq4u9Mbf+qBDMIAFgT7utOCm3uL6kh1J9PPhDJs1gn3gy/1isVxeKPf2oXE2eVytc5N7B6B5Lm8Sefl9PPRlTgoqeAioqRlHLc0spacbGqhxAXRDpNu5Vqi1OPDhQIYDIW4AyV8DAgJo4MCB4r6lS5eKuqWxY8eagiXzzFJr9pWDHs5sWUv6XZzxakhgYCAFBQVRQUEBKYmPhxstumMgTXl/B+04m0v//e00PTGua6se889zOfTmesPZ8fOTe1KvdoE22lsA7bq2RwTdf1UCfbTtPD31/SHqFuVPHcP8WlUyMW/VETHrlVsUvHtrf3TNtxKCJY3jYSgWGRkpCo0taexDvbVsOS2cA6KXXnpJBEI89MaBEw+fubq61qlpGjx4sKg74mJqDnJssa+c2XIWXSL8xVntoysO0nubz4o0fUvPQI+mFdIDXyQSJ6h4arJUiwEATeOGrQdSCsRyRDM/20PL7xsuFrptSaD0n3UnRT2iq0sbev+2ARTmb/3Jn7NDsKRxMTEx4mtoaKjFrFRrREcbVqfm4bGGSNmt5tT6WKpb4jojDoikeiUpSOKskFS3xDP8OFA0H4Jz9L5KM+Ua+11FRUUWs0qXt0hwtKn929GJzCKxuOb/rT5Kbi5taPpgw8K71jqeXkR3fLqbiipqaED7IHplam/0VAJo5sSL92/rT7cs2ikW2r1t8S5acd/wZtUZcaDEXcGlhXJfnNKThnSoX4YAjVNN0QAXKfMUdJ6txEMX1v4H4dle/KHF09l5aIaHo8zl5eWJmVw8lMOPe88994hiZC0FS9wT6Pjx43T69Gm7/I4rr7xSfOUZdlz7dLkvv/yyznatwa+jVLckBX/m9UBS3dIvv/xi+t4cZ6GknlMNBSq23FcO3GJjY0Xd2NatW+vdz7PwlO7pCd1o1hWGocmnVx2hdzaetrrD92/Hs+i2T3aJgu5+sUG09O9DRNM9AGiecH8v+ua+YdQ+xIcu5pbRzR/+SfuT86362fKqWvr36iO0cIthaaHnb+iBOiUtB0vcr2batGk0Z84cq3+G++G8++67tGjRItq9ezf5+vqKoaiKigrTNhwo8XT6jRs3illSPIPqvvvuIy3hWVecZeGZaQ1NiecGjYsXL27x43NA0rt3b5EJ4eDUvHcQ91latWqVmH3G7QMaWqy3uYvPSgEQ93Tiuh+elm9+H/9fkQIp83olxo04uddRcXGxaJdQXf1Xh9ydO3eKVgA8pPfggw+SLUj/X5944gkRmJvPyuPmlpZwkMsXW9R6tRS/Ps9d30METPyy/m/TGbpt8W4xm6Yx+aVVNP+Ho3Tvsn11AiV/r/rF/wBg/aLXHDDxotO8jtu0RTvFkkFlVTWN/kzixXy64f3tol8TJ3T5vTzTONsVNDoM98ILL4iv1g4l8Qc2d3Z+5plnRPNAtmzZMoqIiKA1a9bQjBkzRD8gzjBwJmLQoEFiG55Oft1114mGhdKQjdpxPyEOCLkxIhdCc6sAbqrIfyPuscQ9fziYmT17dos/UL/66iuR4eHfwQES/w6eCcYF59z88tNPP63XwFGqp2poBp0lHABxiwIOeseMGSOCm8sDKb6PAw1+vS/30UcficwR/3/gjA8P7V26dEkM33FmjKf58/7bAgdJ3JOJ/w7cLuCaa66hyspK0ddJ2vfGei1xPydmHtDJgV/f+Tf0pL4xQfTMmqO050IejX17m+i+zWu68cw5Xk/qQk4Z7TiXQ6v2p1JFteG1vXdkB3pyQlfydENGCaC1uFbpp4dHimHxnw6l01sbT9Mn25NoxuBYGhAXLAIpPkE5d6mEViam0v5kQ/aci7nfmd6PruiEbvmaD5aaKykpiTIzM8XQm4SzEFzLwhkEDpb4Kw+9SYES4+1dXFxEJurGG29s8LH5w44v5rUnahjG5Kza+++/Lz64uS8SDz1ybQ5nPzhr1xqcWdq/f78IYjgA5b5N/PfmHkvz5s0TQ2eX45ojxoXazcHDsVy3xBmky4fZpLolHqa7/D4JP2cOkLlnEgfOnPni4V0OXji4GTduHNkK7ycvocJ/Fw4of/rpJxGEP/bYY2LJky5dDOtAqQHXMPVvH0Qv/3yCfjuRRb+fuiQuDeFO4E9N6Eqju1pfXA8A1i1N9O6MfnR11zCR6eVhOZ4t1xBu0zG5XzTNm9iN2vqhmLs12uiVtN6CFTiz9OijjzY53Zqnj3P/IJ6+bZ7R4F5AfKa8YsUKkQXhqebSGbyEZ09xJquxIT8ePpIyXea4YzQHINA0zipxk0YOVHkIFNTlYm4pfb07mY6mF1LSpVKqqNFRfFsfsabVTQNiaGiHEBRyA9gZ90DbfDKb1h5OF4tTc+DEC2LHt/WlAe2D6dahsaLeCRrHyQ4+sW/q89tN7vXKeBkOS3iojIdTlIQzJbwArfkfmwt5wXoHDhwQAW9TdTugTHFtfWnedd3l3g0Ap8YtALgXE1/AvmQNlnjIo6niXi7IbQnuK8R4gVjzzBJ/L9Wj8DY8U8lcTU2NKMSVfr4h3JiwOc0JoT6unVJZUhMAAJyUrMESL25qvsCpLXXo0EEEPFxIKwVHnAHiWiRpeI0Lezm7wct88Ic327x5sxgi4tomAAAAANW0DuAZQzztnb/yjCW+zhfznkg8XMczsRjXS3BtExfW/vjjj6KgmQuJubiWi44Zd3fmNcJ4FtiePXtE4fNDDz0kir+1MhMOAAAAnGQ2HPfv4WJsidRbZ8uWLaZZT1yozUVakqeeeopKS0tF3yTOIHFDQp6pZb5sBc9Q4gCJZ0LxLDjuRcS9mQAAAABUORtOzdX0AAAAoL7Pb9UMwwEAAADIAcESAAAAgAUIlgAAAAAsQLAEAAAAYAGCJQAAAAALECwBAAAAWIBgCQAAAMACBEsAAAAAFiBYAgAAANDCcidKJjVB506gAAAAoA7S53ZTi5kgWLKB4uJi8TU2NlbuXQEAAIAWfI7zsieNwdpwNqDT6Sg9PZ38/f2pTZs2No14OQBLSUnR7JpzWn+OWn9+DM9R/bT+/Bieo/oV2eH5cQjEgVJ0dDS5uDRemYTMkg3wHzgmJsZuj8//KbT4H9+ZnqPWnx/Dc1Q/rT8/hueofgE2fn6WMkoSFHgDAAAAWIBgCQAAAMACBEsK5unpSfPnzxdftUrrz1Hrz4/hOaqf1p8fw3NUP08Znx8KvAEAAAAsQGYJAAAAwAIESwAAAAAWIFgCAAAAsADBEgAAAIAFCJYcbOHChRQfH09eXl40dOhQ2rNnj8Xtv/vuO+rWrZvYvnfv3vTLL7/UuZ/r85977jmKiooib29vGjt2LJ05c4bU8PwWL15MV155JQUHB4sL7/vl28+cOVN0RTe/TJgwgeTUnOf4+eef19t//jklv4bNfY6jR4+u9xz5MmnSJEW+jtu2baMbbrhBdOzl/VizZk2TP/P777/TgAEDxCycTp06ide1te9tJT3HVatW0bXXXkthYWGi2d/w4cNp/fr1dbZ5/vnn672GfGxSw/Pj16+h/6OZmZmaeQ0beo/xpWfPnop8DRcsWECDBw8WK1+Eh4fT1KlT6dSpU03+nFyfiQiWHGjFihX0+OOPi6mP+/fvp759+9L48eMpOzu7we3//PNPuvXWW+mee+6hAwcOiP9MfDl69Khpm9dff53effddWrRoEe3evZt8fX3FY1ZUVJDSnx8fwPj5bdmyhXbu3Cna2I8bN47S0tLqbMcfqhkZGabLN998Q3Jp7nNk/OFjvv8XL16sc7+SXsOWPEf+oDV/fvz/09XVlaZNm6bI17G0tFQ8J/5gtEZSUpII/K6++mo6ePAgPfroo3TvvffWCSZa8v9CSc+RP5g5WOIPnsTERPFc+YOajzvm+IPX/DXcvn07qeH5SfjD2Hz/+UNaK6/h//73vzrPjZcECQkJqfc+VMpruHXrVnrwwQdp165dtHHjRqqurhbHf37ejZH1M5FbB4BjDBkyRP/ggw+avq+trdVHR0frFyxY0OD2t9xyi37SpEl1bhs6dKj+/vvvF9d1Op0+MjJS/8Ybb5juLygo0Ht6euq/+eYbvdKf3+Vqamr0/v7++qVLl5puu/vuu/VTpkzRK0Vzn+Nnn32mDwwMbPTxlPYa2uJ1fOedd8TrWFJSotjXUcKHwNWrV1vc5qmnntL37Nmzzm3Tp0/Xjx8/3mZ/M7mfY0N69Oihf+GFF0zfz58/X9+3b1+90ljz/LZs2SK2y8/Pb3Qbrb2GvH2bNm30Fy5cUPxryLKzs8Xz3Lp1q74xcn4mIrPkIFVVVeKMjVOC5mvK8fecVWkI326+PeMIWdqez3g5jWy+Da9xw+njxh5TSc/vcmVlZeLsgs+GLs9A8Rlg165dac6cOZSbm0tyaOlzLCkpobi4OJE5mzJlCh07dsx0n5JeQ1u9jp9++inNmDFDnNEp8XVsrqbeh7b4mylxcXBeXPTy9yIPZ/CwUEJCAt1+++2UnJxMatKvXz8xPMNZtB07dphu1+JryO9D3n8+9qjhNSwsLBRfL/8/p5TPRARLDpKTk0O1tbUUERFR53b+/vJxcwnfbml76WtzHlNJz+9yc+fOFW9i8//oPHSzbNky2rRpE7322msidTtx4kTxuxytJc+RA4MlS5bQDz/8QF9++aX4EBoxYgSlpqYq7jW0xevINR6cEudhKnNKeh2bq7H3Ia+AXl5ebpP/+0rz5ptviiD/lltuMd3GHzhcq7Vu3Tr68MMPxQcT1xxyUKV0HCDxsMzKlSvFhU9cuNaOh9uY1l7D9PR0+vXXX+u9D5X6Gup0OjG8fcUVV1CvXr0a3U7Oz0S3Vv00gI385z//oeXLl4vsg3kBNGcoJFzM16dPH+rYsaPYbsyYMaR0XCjLFwkHSt27d6ePPvqIXnrpJdIaPpvl12nIkCF1blf76+hMvv76a3rhhRdEgG9e08PBrYRfP/7g5azFt99+K2pIlIxPWvhi/j48d+4cvfPOO/TFF1+Q1ixdupSCgoJEPY85pb6GDz74oDjJkqt+yhrILDlIaGioKHrNysqqczt/HxkZ2eDP8O2Wtpe+NucxlfT8zM9iOVjasGGDeANbwqlj/l1nz54lR2vNc5S4u7tT//79TfuvpNewtc+RCzM54LXmoCvn69hcjb0PuXCfZ9vY4v+FUvDrx9kI/vC8fLjjcvxh3KVLF1W8hg3hgF7ady29hlzixNnsO++8kzw8PBT/Gj700EO0du1aMdEnJibG4rZyfiYiWHIQ/k87cOBAMQxhnnrk780zD+b4dvPtGc8akLbv0KGD+A9gvg0PDfAMgMYeU0nPT5q5wBkWTgsPGjSoyd/Dw1dc68JpdUdr6XM0x6n+I0eOmPZfSa9ha58jT+mtrKykO+64Q9GvY3M19T60xf8LJeDZibNmzRJfzds+NIaH6Tg7o4bXsCE8s1Had628hoyHuDn4seakRc7XUK/Xi0Bp9erVtHnzZnEsbIqsn4mtKg+HZlm+fLmoyv/888/1x48f19933336oKAgfWZmprj/zjvv1D/99NOm7Xfs2KF3c3PTv/nmm/oTJ06ImQzu7u76I0eOmLb5z3/+Ix7jhx9+0B8+fFjMOOrQoYO+vLxc8c+P993Dw0P//fff6zMyMkyX4uJicT9//de//qXfuXOnPikpSf/bb7/pBwwYoO/cubO+oqLC4c+vJc+RZxOtX79ef+7cOX1iYqJ+xowZei8vL/2xY8cU+Rq25DlKRo4cKWaJXU5pryPvz4EDB8SFD4Fvv/22uH7x4kVxPz83fo6S8+fP6318fPRPPvmkeB8uXLhQ7+rqql+3bp3VfzOlP8evvvpKHGv4uZm/F3kmkeSJJ57Q//777+I15GPT2LFj9aGhoWIWk9KfH8/QXLNmjf7MmTPi+PnII4/oXVxcxP9FrbyGkjvuuEPMEGuIkl7DOXPmiJnCvD/m/+fKyspM2yjpMxHBkoO99957+vbt24sggaeq7tq1y3TfqFGjxBRrc99++62+S5cuYnuevvzzzz/XuZ+nSj777LP6iIgI8UYfM2aM/tSpU3o1PL+4uDhxELj8wm8Axm+acePG6cPCwsQbgrefPXu2bAevljzHRx991LQtv0bXXXedfv/+/Yp+DVvy//TkyZPitduwYUO9x1La6yhNI7/8Ij0n/srP8fKf6devn/h7JCQkiJYQzfmbKf058nVL2zMOhKOiosTza9eunfj+7Nmzqnh+r732mr5jx47iRCUkJEQ/evRo/ebNmzX1GjIObr29vfUff/xxg4+ppNeQGnhufDF/bynpM7GNcacBAAAAoAGoWQIAAACwAMESAAAAgAUIlgAAAAAsQLAEAAAAYAGCJQAAAAALECwBAAAAWIBgCQAAAMACBEsAoDkzZ86st4ioI/CK7m3atBEXXkXd2n2VfmbNmjV230cAaD63FvwMAIBsOKiwZP78+fS///1PrD0lB15g99SpU+Tr62vV9ryvvJC0WtdYA3AGCJYAQFUyMjJM11esWEHPPfecCE4kfn5+4iJnMNecFc4DAwPFBQCUC8NwAKAqHIhIFw4ypOBEunCgdPkw3OjRo+nhhx8WQ2PBwcEUERFBixcvptLSUpo1axb5+/tTp06d6Ndff63zu44ePUoTJ04Uj8k/c+edd1JOTk6z9/mDDz6gzp07k5eXl3icv/3tbzb5WwCAYyBYAgCnsHTpUgoNDaU9e/aIwGnOnDk0bdo0GjFiBO3fv5/GjRsngqGysjKxfUFBAV1zzTXUv39/2rdvH61bt46ysrLolltuadbv5Z/95z//SS+++KLIgPHjXHXVVXZ6lgBgDxiGAwCn0LdvX3rmmWfE9Xnz5ok6IQ6eZs+eLW7j4bwPP/yQDh8+TMOGDaP3339fBEqvvvqq6TGWLFlCsbGxdPr0aerSpYtVvzc5OVnUL11//fUigxUXFyceFwDUA5klAHAKffr0MV13dXWltm3bUu/evU238fAYy87OFl8PHTpEW7ZsMdVA8aVbt27ivnPnzln9e6+99loRICUkJIjM1VdffWXKXgGAOiBYAgCn4O7uXud7rnUyv02aZafT6cTXkpISuuGGG+jgwYN1LmfOnGnWMBpnk3iY75tvvhEz3jiDxVkuHuYDAHXAMBwAQAMGDBhAK1eupPj4eHJza92hkn9+7Nix4sKtDYKCgmjz5s1000032Wx/AcB+kFkCAGjAgw8+SHl5eXTrrbfS3r17xdDb+vXrxey52tpaqx9n7dq19O6774qs1MWLF2nZsmUie9W1a1e77j8A2A6CJQCABkRHR9OOHTtEYMQz5bi+iVsPcFbIxcX6Qydvv2rVKjGzrnv37rRo0SIxJNezZ0+77j8A2E4bvVxtbgEANIaXO+GAqiX1SFwztXr1almWaQEAy5BZAgCwocLCQjFzbu7cuVZt/8ADD8jacRwAmobMEgCAjRQXF4vGldLwG/dxagq3KigqKhLXebactWvKAYDjIFgCAAAAsADDcAAAAAAWIFgCAAAAsADBEgAAAIAFCJYAAAAALECwBAAAAGABgiUAAAAACxAsAQAAAFiAYAkAAADAAgRLAAAAANS4/weOZN7rTnaS5AAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "t = np.arange(0.0, 2.0, 0.01)\n", "s = np.sin(2*np.pi*t)\n", "\n", "plt.plot(t, s)\n", "plt.text(0, -1, r'Hello, world!', fontsize=15)\n", "plt.title(r'$\\mathcal{A}\\sin(\\omega t)$', fontsize=20)\n", "plt.xlabel('Time [s]')\n", "plt.ylabel('Voltage [mV]')\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": ".appMLvenv", "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.11.3" } }, "nbformat": 4, "nbformat_minor": 5 }