{ "cells": [ { "cell_type": "markdown", "id": "549e3431", "metadata": {}, "source": [ "# Feature Selection With Noisy Iris Data\n", "\n", "This notebook keeps the original goal of the Iris feature-selection tutorial: use `GAFeatureSelectionCV` to find a compact subset of useful features. The example now adds synthetic noise features so the selection problem is more realistic.\n", "\n", "## Menu\n", "\n", "1. [Problem Setup](#problem-setup)\n", "2. [Baseline With All Features](#baseline-with-all-features)\n", "3. [Configure GAFeatureSelectionCV](#configure-gafeatureselectioncv)\n", "4. [Inspect Selected Features](#inspect-selected-features)\n", "5. [Read Fit Statistics and Telemetry](#read-fit-statistics-and-telemetry)\n", "6. [Compare Baseline and Selected-Feature Model](#compare-baseline-and-selected-feature-model)\n", "7. [Practical Notes](#practical-notes)" ] }, { "cell_type": "markdown", "id": "a0942c60", "metadata": {}, "source": [ "## Problem Setup\n", "\n", "The original Iris dataset has only four informative features. To make feature selection visible, we add random noise columns. A useful selector should keep a small subset of original measurements and avoid most noise columns.\n", "\n", "We use a `Pipeline` with `StandardScaler` and `SVC` because SVMs are sensitive to feature scale." ] }, { "cell_type": "code", "id": "1c33efe1", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:28:48.362687Z", "iopub.status.busy": "2026-06-20T05:28:48.362367Z", "iopub.status.idle": "2026-06-20T05:28:57.091218Z", "shell.execute_reply": "2026-06-20T05:28:57.090083Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:47.421150800Z", "start_time": "2026-06-20T18:45:43.335662700Z" } }, "source": [ "import warnings\n", "\n", "import numpy as np\n", "import pandas as pd\n", "from sklearn.datasets import load_iris\n", "from sklearn.metrics import accuracy_score, balanced_accuracy_score, classification_report\n", "from sklearn.model_selection import StratifiedKFold, train_test_split\n", "from sklearn.pipeline import Pipeline\n", "from sklearn.preprocessing import StandardScaler\n", "from sklearn.svm import SVC\n", "\n", "from sklearn_genetic import (\n", " EvolutionConfig,\n", " GAFeatureSelectionCV,\n", " OptimizationConfig,\n", " PopulationConfig,\n", " RuntimeConfig,\n", ")\n", "from sklearn_genetic.callbacks import ConsecutiveStopping, DeltaThreshold, TimerStopping\n", "from sklearn_genetic.schedules import ExponentialAdapter, InverseAdapter\n", "\n", "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", "\n", "RANDOM_STATE = 42\n", "rng = np.random.default_rng(RANDOM_STATE)" ], "outputs": [], "execution_count": 1 }, { "cell_type": "code", "id": "e5ade676", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:28:57.094385Z", "iopub.status.busy": "2026-06-20T05:28:57.093785Z", "iopub.status.idle": "2026-06-20T05:28:57.136489Z", "shell.execute_reply": "2026-06-20T05:28:57.135688Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:47.519807400Z", "start_time": "2026-06-20T18:45:47.422147300Z" } }, "source": [ "iris = load_iris(as_frame=True)\n", "X_original = iris.data\n", "y = iris.target\n", "\n", "noise = pd.DataFrame(\n", " rng.normal(size=(X_original.shape[0], 12)),\n", " columns=[f\"noise_{index:02d}\" for index in range(12)],\n", ")\n", "X = pd.concat([X_original, noise], axis=1)\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(\n", " X,\n", " y,\n", " test_size=0.30,\n", " stratify=y,\n", " random_state=RANDOM_STATE,\n", ")\n", "\n", "cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=RANDOM_STATE)\n", "\n", "print(f\"Original features: {X_original.shape[1]}\")\n", "print(f\"Noise features: {noise.shape[1]}\")\n", "print(f\"Total features: {X.shape[1]}\")" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original features: 4\n", "Noise features: 12\n", "Total features: 16\n" ] } ], "execution_count": 2 }, { "cell_type": "markdown", "id": "d35277f9", "metadata": {}, "source": [ "## Baseline With All Features\n", "\n", "The baseline trains on all original and noise columns. This gives us a reference for whether feature selection preserves model quality while reducing the feature set." ] }, { "cell_type": "code", "id": "9cddb4b1", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:28:57.139180Z", "iopub.status.busy": "2026-06-20T05:28:57.138929Z", "iopub.status.idle": "2026-06-20T05:28:57.163316Z", "shell.execute_reply": "2026-06-20T05:28:57.161875Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:47.650623500Z", "start_time": "2026-06-20T18:45:47.519807400Z" } }, "source": [ "def make_svc_pipeline():\n", " return Pipeline(\n", " [\n", " (\"scaler\", StandardScaler()),\n", " (\n", " \"svc\",\n", " SVC(\n", " kernel=\"rbf\",\n", " C=2.0,\n", " gamma=\"scale\",\n", " random_state=RANDOM_STATE,\n", " ),\n", " ),\n", " ]\n", " )\n", "\n", "\n", "def evaluate(estimator, X_eval, y_eval):\n", " predictions = estimator.predict(X_eval)\n", " return {\n", " \"accuracy\": accuracy_score(y_eval, predictions),\n", " \"balanced_accuracy\": balanced_accuracy_score(y_eval, predictions),\n", " }\n", "\n", "\n", "baseline = make_svc_pipeline()\n", "baseline.fit(X_train, y_train)\n", "baseline_metrics = evaluate(baseline, X_test, y_test)\n", "baseline_metrics" ], "outputs": [ { "data": { "text/plain": [ "{'accuracy': 0.8222222222222222, 'balanced_accuracy': 0.8222222222222223}" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "execution_count": 3 }, { "cell_type": "markdown", "id": "266aa77f", "metadata": {}, "source": [ "## Configure GAFeatureSelectionCV\n", "\n", "`GAFeatureSelectionCV` searches over binary masks. A value of `1` means the feature is selected; a value of `0` means it is excluded.\n", "\n", "This configuration uses several optimizer controls:\n", "\n", "- `PopulationConfig(initializer=\"smart\")` starts from diverse masks instead of purely random masks.\n", "- `max_features=6` asks the optimizer to find a compact subset.\n", "- `OptimizationConfig(diversity_control=True)` boosts exploration when the population collapses or stalls.\n", "- `OptimizationConfig(fitness_sharing=True)` reduces pressure for many similar masks to dominate too early.\n", "- `OptimizationConfig(local_search=True)` performs a small final neighborhood search around strong masks.\n", "- adaptive schedules gradually change crossover and mutation behavior during the run." ] }, { "cell_type": "code", "id": "ad1f1a4f", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:28:57.166503Z", "iopub.status.busy": "2026-06-20T05:28:57.166115Z", "iopub.status.idle": "2026-06-20T05:28:59.871435Z", "shell.execute_reply": "2026-06-20T05:28:59.870357Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:51.044830100Z", "start_time": "2026-06-20T18:45:47.652129300Z" } }, "source": [ "selector = GAFeatureSelectionCV(\n", " estimator=make_svc_pipeline(),\n", " cv=cv,\n", " scoring=\"balanced_accuracy\",\n", " max_features=6,\n", " evolution_config=EvolutionConfig(\n", " population_size=20,\n", " generations=15,\n", " crossover_probability=ExponentialAdapter(initial_value=0.8, end_value=0.4, adaptive_rate=0.15),\n", " mutation_probability=InverseAdapter(initial_value=0.30, end_value=0.08, adaptive_rate=0.25),\n", " tournament_size=3,\n", " elitism=True,\n", " keep_top_k=3,\n", " ),\n", " population_config=PopulationConfig(initializer=\"smart\"),\n", " runtime_config=RuntimeConfig(n_jobs=-1, parallel_backend=\"auto\", use_cache=True, verbose=True),\n", " optimization_config=OptimizationConfig(\n", " local_search=True,\n", " local_search_top_k=2,\n", " local_search_steps=1,\n", " local_search_radius=0.15,\n", " diversity_control=True,\n", " diversity_threshold=0.30,\n", " diversity_stagnation_generations=3,\n", " diversity_mutation_boost=1.8,\n", " random_immigrants_fraction=0.10,\n", " fitness_sharing=True,\n", " sharing_radius=0.40,\n", " ),\n", ")\n", "\n", "callbacks = [\n", " DeltaThreshold(threshold=0.001, generations=5, metric=\"fitness_best\"),\n", " ConsecutiveStopping(generations=7, metric=\"fitness_best\"),\n", " TimerStopping(total_seconds=90),\n", "]\n", "\n", "selector.fit(X_train, y_train, callbacks=callbacks)" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " gen evals avg best div unique stag mut sel events\n", "---- ----- ------------- ------------- ------- ------- ----- ------- ----- ------------------\n", " 0 20 0.58725 0.96128 0.053 1.000 0 - - - \n", " 1 40 0.75526 0.96128 0.053 0.750 1 0.200 3 div,imm=4,dup=15,s\n", " 2 40 0.84625 0.96128 0.053 0.750 2 0.256 3 div,imm=4,dup=10,s\n", " 3 40 0.85387 0.96128 0.053 0.650 3 0.304 3 div,imm=4,dup=10,s\n", " 4 40 0.86208 0.96128 0.053 0.650 4 0.345 3 div,imm=4,dup=6,sh\n", "INFO: DeltaThreshold callback met its criteria\n", "INFO: Stopping the algorithm\n" ] }, { "data": { "text/plain": [ "GAFeatureSelectionCV(crossover_probability=,\n", " cv=StratifiedKFold(n_splits=3, random_state=42, shuffle=True),\n", " diversity_control=True, diversity_mutation_boost=1.8,\n", " diversity_stagnation_generations=3,\n", " diversity_threshold=0.3,\n", " estimator=Pipeline(steps=[('scaler', StandardScaler()...\n", " final_selection_top_k=3,\n", " final_selection_cv=None),\n", " population_config=PopulationConfig(initializer='smart',\n", " warm_start_configs=[]),\n", " population_size=20,\n", " runtime_config=RuntimeConfig(n_jobs=-1,\n", " pre_dispatch='2*n_jobs',\n", " error_score=nan,\n", " return_train_score=False,\n", " use_cache=True,\n", " parallel_backend='auto',\n", " verbose=True),\n", " scoring='balanced_accuracy', sharing_radius=0.4)" ], "text/html": [ "
GAFeatureSelectionCV(crossover_probability=<sklearn_genetic.schedules.schedulers.ExponentialAdapter object at 0x00000226B432D7F0>,\n",
       "                     cv=StratifiedKFold(n_splits=3, random_state=42, shuffle=True),\n",
       "                     diversity_control=True, diversity_mutation_boost=1.8,\n",
       "                     diversity_stagnation_generations=3,\n",
       "                     diversity_threshold=0.3,\n",
       "                     estimator=Pipeline(steps=[('scaler', StandardScaler()...\n",
       "                                                            final_selection_top_k=3,\n",
       "                                                            final_selection_cv=None),\n",
       "                     population_config=PopulationConfig(initializer='smart',\n",
       "                                                        warm_start_configs=[]),\n",
       "                     population_size=20,\n",
       "                     runtime_config=RuntimeConfig(n_jobs=-1,\n",
       "                                                  pre_dispatch='2*n_jobs',\n",
       "                                                  error_score=nan,\n",
       "                                                  return_train_score=False,\n",
       "                                                  use_cache=True,\n",
       "                                                  parallel_backend='auto',\n",
       "                                                  verbose=True),\n",
       "                     scoring='balanced_accuracy', sharing_radius=0.4)
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.
" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "execution_count": 4 }, { "cell_type": "markdown", "id": "fe5f8352", "metadata": {}, "source": [ "## Inspect Selected Features\n", "\n", "The fitted selector exposes `support_`, just like many sklearn feature selectors. Because our input is a pandas `DataFrame`, we can recover the selected column names directly." ] }, { "cell_type": "code", "id": "39564a0e", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:28:59.874258Z", "iopub.status.busy": "2026-06-20T05:28:59.873982Z", "iopub.status.idle": "2026-06-20T05:28:59.888028Z", "shell.execute_reply": "2026-06-20T05:28:59.887042Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:51.165577Z", "start_time": "2026-06-20T18:45:51.046829100Z" } }, "source": [ "selected_features = X_train.columns[selector.support_]\n", "selected_summary = pd.DataFrame(\n", " {\n", " \"feature\": X_train.columns,\n", " \"selected\": selector.support_,\n", " \"kind\": [\"original\" if column in X_original.columns else \"noise\" for column in X_train.columns],\n", " }\n", ")\n", "\n", "print(f\"Selected {len(selected_features)} of {X_train.shape[1]} features\")\n", "selected_summary[selected_summary[\"selected\"]]" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Selected 1 of 16 features\n" ] }, { "data": { "text/plain": [ " feature selected kind\n", "3 petal width (cm) True original" ], "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
featureselectedkind
3petal width (cm)Trueoriginal
\n", "
" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "execution_count": 5 }, { "cell_type": "markdown", "id": "c4f5a817", "metadata": {}, "source": [ "## Read Fit Statistics and Telemetry\n", "\n", "`fit_stats_` summarizes search cost. `history` stores per-generation optimizer telemetry. These are useful when feature selection is slow or when the search converges too early." ] }, { "cell_type": "code", "id": "bbfd6b62", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:28:59.891524Z", "iopub.status.busy": "2026-06-20T05:28:59.891161Z", "iopub.status.idle": "2026-06-20T05:28:59.896569Z", "shell.execute_reply": "2026-06-20T05:28:59.895553Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:51.175095700Z", "start_time": "2026-06-20T18:45:51.166574Z" } }, "source": [ "selector.fit_stats_" ], "outputs": [ { "data": { "text/plain": [ "{'evaluated_candidates': 182,\n", " 'unique_candidates': 182,\n", " 'cross_validate_calls': 182,\n", " 'cache_hits': 0,\n", " 'duplicate_candidates': 0,\n", " 'skipped_invalid_candidates': 0,\n", " 'population_parallel_batches': 6,\n", " 'population_serial_batches': 0,\n", " 'random_immigrants': 16,\n", " 'local_refinement_candidates': 2}" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "execution_count": 6 }, { "cell_type": "code", "id": "53ae276d", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:28:59.899475Z", "iopub.status.busy": "2026-06-20T05:28:59.899079Z", "iopub.status.idle": "2026-06-20T05:28:59.911829Z", "shell.execute_reply": "2026-06-20T05:28:59.910848Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:51.259371100Z", "start_time": "2026-06-20T18:45:51.176096300Z" } }, "source": [ "history = pd.DataFrame(selector.history)\n", "telemetry_columns = [\n", " \"gen\",\n", " \"fitness\",\n", " \"fitness_max\",\n", " \"fitness_std\",\n", " \"unique_individual_ratio\",\n", " \"genotype_diversity\",\n", " \"stagnation_generations\",\n", " \"random_immigrants\",\n", " \"local_refinement_candidates\",\n", "]\n", "history[[column for column in telemetry_columns if column in history.columns]].tail()" ], "outputs": [ { "data": { "text/plain": [ " gen fitness fitness_max fitness_std unique_individual_ratio \\\n", "0 0 0.587247 0.961279 0.273261 1.00 \n", "1 1 0.755261 0.944444 0.199663 0.75 \n", "2 2 0.846254 0.934343 0.108298 0.75 \n", "3 3 0.853872 0.933502 0.080829 0.65 \n", "4 4 0.889310 0.922559 0.025854 0.70 \n", "\n", " genotype_diversity stagnation_generations random_immigrants \n", "0 0.052632 0 0 \n", "1 0.052632 1 4 \n", "2 0.052632 2 4 \n", "3 0.052632 3 4 \n", "4 0.052632 5 4 " ], "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", "
genfitnessfitness_maxfitness_stdunique_individual_ratiogenotype_diversitystagnation_generationsrandom_immigrants
000.5872470.9612790.2732611.000.05263200
110.7552610.9444440.1996630.750.05263214
220.8462540.9343430.1082980.750.05263224
330.8538720.9335020.0808290.650.05263234
440.8893100.9225590.0258540.700.05263254
\n", "
" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "execution_count": 7 }, { "cell_type": "code", "id": "d6eed2e5", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:28:59.915746Z", "iopub.status.busy": "2026-06-20T05:28:59.915334Z", "iopub.status.idle": "2026-06-20T05:29:00.226553Z", "shell.execute_reply": "2026-06-20T05:29:00.225041Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:51.709803900Z", "start_time": "2026-06-20T18:45:51.260373400Z" } }, "source": [ "ax = history.plot(x=\"gen\", y=[\"fitness_best\", \"fitness_max\", \"fitness\"], marker=\"o\", figsize=(8, 4))\n", "ax.set_title(\"Feature-selection fitness over generations\")\n", "ax.set_xlabel(\"Generation\")\n", "ax.set_ylabel(\"Balanced accuracy\")" ], "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Balanced accuracy')" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAAArgAAAGGCAYAAACQWPJvAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgLBJREFUeJzt3QV4U1cbB/C37i2ltEhxd4YPhsuH23AfDBhuQwZs6HDYBmPABgx3HwzYcHd3LV6jQt3v97ynJEvatEkq0f/vee6TXMm9NycnyZuTc95rQUQSAQAAAACYCEt9nwAAAAAAQFZCgAsAAAAAJgUBLgAAAACYFAS4AAAAAGBSEOACAAAAgElBgAsAAAAAJgUBLgAAAACYFAS4AAAAAGBSrPV9AgDmJEeOHGRnZ5fm+oiICIqMjMzSY9rY2FB8fDyZity5c1N4eDhFRUVl+b5TlpWXl5d4PbL6NUmPq6urOIfo6GiVxze11xNMq/4CGBK+khkmlAHqgA7qwOHDh6WEhATJ19dX5fTtt99m6fF69Ogh7d+/32ReWysrK4lNnDgxy/etqqzevHkjTZgwQSfPrUSJEtKDBw+kmJgYKTQ0VPLy8kp1fFN7PTGZTv3FhDIgAysDtOAC6Jivry8VKFBAJ8fq3bs3OTs76+RYxk5VWenqdWLDhg2j/PnzU548eSg0NFTl8fF6gqHWXwBDgz64AEbQrcHKykrtNvb29krLcubMSba2tuJvS/5bn28Z33d0dFTalh/Lyy0tkz8S+L6sK4WTk1OGz0sVBwcHjYLujOxfk8dwF4CU0ior/os3refP+1F1LH6MrOz41sXFRe15e3p6iuN++PBBPEZWPorHT+8ctTmeujLS5PXR9DXUtNxy5cpFbm5uqbbl58PPVdX5pvU8NKm7KXG9l70neJ/aHjOrXgNN33eavtezu/5mph4A6ILem5ExoQzMqYsC/22oyV/xs2fPlj58+CCFh4dLERER0oYNGyQ3Nzf5Nq6urtKqVaukkJAQKTg4WHR9uH79ulSrVi2x/ujRo+Lv7tjYWNH9oUGDBmn+xd+3b1+xvFChQmKerVmzRnr37p0UHR0t/fbbbxqfV1pTu3btpEePHonHhIWFSa9fv5bGjRun1fNWdf6anJONjY00d+5c+TYfP36UFi5cKB6bVlnx8vj4eGnWrFny/Tg6Okpz5syRAgICxHGioqKkrVu3Sp6envJt+DGTJk2Sjhw5Ip4n7/PWrVtSjRo10iybZ8+eiX3xY/n4/HxSHj+9c1R3PE3KSJPXR5NtVE3qym3nzp1iXykft3jxYlG37ezsNH4eadVdVZOLi4u0ceNGUWa8L35uXLdY1apVNT5mVr0GaZ17Rt7r2Vl/M1oPMKEMSLdlgAJHGaAO6DLA5S+v3Llzp5r4y1a23dq1a8UXR8uWLcV8wYIFxZfMxYsXJUtLS7HswIED0s2bN6W8efOK+Zw5c4ovpSdPnkgWFhby4509e1bpS1bTAJe//MqXLy85OzuL/qGanpeqiR/PX5SjR49W6jPIX8Y1a9bU+HmrOn9NzokDCX9/f6lu3bpivly5clJgYKA0b948pddGsaxUBQhcvm/fvpU+//xzMV+yZEnpzp07ou+sg4OD/DFcdt27dxevAwcwvN/Hjx+nWzf4eTx9+jTd46d1juqOp66MNHl9NH0NVU3qyq1Vq1bidZW9Pjzxc+H3yooVK7R6rdOqu6qmf/75R/y4KFOmjJj/8ssvxWMVA1xNjpkVr0F6556R93p21d/M1ANMKANCgItKgA8C8xtktmjRIrFNqVKlxBfdDz/8oPTYevXqieVt27YVAfH79+/FF7LiNgMHDhTb8JdnZgPc3bt3K22jyXml9bzbtGkjtmnSpEma22iy/5Tnr8lj+DmxESNGKG3DLU78xS4LLtQFCHXq1BH74S9zxW2qVasmlg8ePFj+mF27dilt89VXX4ltihQpki0BbnrH06SMNHl9NNlG1aRJufHr6ufnpxTM8nGYrJVS0/qnqu6qmrhFknFrpOLyn376SR7ganrMrHgN0jr3jL7Xs6v+ZrQeYEIZkI7LAH1wAfQwyCxv3ryppnHjxon19erVE7c3btwQ/elk04sXLyghIUGs9/f3p3z58lFgYCD98MMPtHHjRrp+/TotW7ZMPDZlH72MeP78udK8JufF/fEU1/HETp8+Ta9fv6b9+/fT+vXrqVOnTqIvobb7T0mTx9SuXVtsc/bsWaXHLlq0iMqWLUtJSUkalUedOnXE7bFjx5SWX7t2TQwKq1u3rnzZo0ePlLYJCQmR91nMDukdT5My0uT10WSbjJZbYmIibd68WezT2jp57HPPnj3p6dOndPHiRa3rR8q6q0qDBg3E7alTp5SWK56nNsfM7GuQ1rln1Xs9q+pvRusBgK4hiwKAgXF3dxe3a9as4SYdpXU8CIkDAAsLC9qxYwe1a9eOjh8/TpcuXaJNmzaJUfirV68W6zPr48ePWp/X+PHjadCgQUrrvL29KSwsjCpXrkzffPMNtWnThrZs2SLW7du3TyzjL1BN9p+SJo+RbRMcHEyZIRucFhQUlGodH0txME9aeWqz4nVRJb3jaVJGmrw+mmyTmXLjYGns2LHUrFkzUae//PJLWrBggXxbbepHyrqrCu+PA+uU2/K+MnLMzL4GaZ17Vr3Xs6r+ZrQeAOgaAlwAAyP7gm3cuDHdv38/1QhnvsBB165dRcvJV199JQIDmREjRqS7b1lrZcrR05qMhNbkvPhCFdOmTVP5eA4w586dKyZu8enevTstWbJEtFDxeWuy/4ycU6tWreTz3PIkwyPNefQ5f+FzK5o63ILGuLX97du3Suu4he3kyZNkiDQtV3Wvj6bbZLTc7ty5Q7du3RJ1WzY6n1srtX0emnr16pV4H/BjAwIC5Mv5PLP6mJnZT0bf69lZfzNSDwB0DV0UAAzMiRMnRMtSx44dlZZ//vnn4gukdevW4guJXbhwQWkbbv1SDGBTBm7cesQtRLKuAzI1a9bMkvNKCwcrnApKhv8SXbFiBfn4+MifS0b2r8lj+C9VbpFq2bKl0jbc0vzy5Ut5eih1Qe7Ro0fFbZcuXZSWt23bVuxDtj47aRKIZ6SMNHl9NNkms+XGARz/IOHuCbK/wrV5Htrgv+q5PLkVUhG3lGb1MTOzn4y+17Or/ma0HgDoAzp/owxQBwwsTRiP7uc0QWPHjpWKFy8uNWrUSAxAOnXqlGRtbS1VqFBBiouLk7Zv3y5GQnNWgF9++UUMYGOy0cw8cImPx6PEZQPIZOmGWrRoIQaN8IAtTj2UcpDZlClTtD6vtJ4Pj5JPTEyUxowZIx5XtGhRcVxe1rp1a433r2qQnCbnxANtOKURD8zhY7dv315kUZgxY4Z8P6rKKuUgL07bxPvhATl8rM6dO4vsDJymSXFE/bRp05SePw9kYvw6ZWaQWVrnqO546spIk9dH09dQ1aRJufHE6aq4XjMe+JiR+pdW3VU1LV++XKTt6tq1q8gOwM9HdvzPPvtM42NmxWuQ1rln5r2eHfU3M/UAE8qAdFsGKHCUAeqArurA5s2bRf5KTbbt3bu3dPLkSenly5fS1atXpenTp4vUQbL1zZo1E+tfvHghXbhwQWRh4PRCnFpp6NChYpuyZctK586dk169eiXS/vAy3sfPP/8s0v5wmiEeud68eXORySF//vxiG74/atSoDJ1XWhN/SR46dEgc18fHR9zn42qzf/4S5nMbNmyY1ufEAROPMudt+LZfv35K61WVlapLnXKQLNvu8uXL0vjx45WCe35Myksu82vF580BSlrlw0ELv46Ky1IeP61z1OR46spIk9dH09dQ1aSu3BTfI3yOTk5OGap/6dXdlBP/YOKcr5yui5/TunXrpOHDh4tgjoM3TY+ZVa9BWuee0fd6dtXfzNQDTCgD0lEZWHy6AwAAYDZkfbC5fyx3H5D59ttvafr06WJgWEa6hACAYUAfXAAAMDvcD/3Nmzf0xx9/iHRxBQsWFP1TJ02aRPPmzUNwC2Dk0IILAABmifPPjhw5ksqVKyfyyXIOWk69tW3bNn2fGgBkEgJcAAAAADAp6KIAAAAAACYFAS4AAAAAmBQEuAAAAABgUnCp3k/4Cizh4eH6fTUAAAAAIE0uLi70/v17UgcB7qfg9t27d2oLCwAAAAD0y9vbW22QiwCXSN5yywWmq1Zc/gXCQbUuj2kMUC4oF9QZvJfwOYPPX0OD7ybDKBfZ8TQ5FgJcBVxgug429XFMY4ByQbmgzuC9hM8ZfP4aGnw3GU+5YJAZAAAAAJgUBLgAAAAAYFIQ4AIAAACASUGACwAAAAAmBQEuAAAAAJgUBLgAAAAAYFIQ4OqBlbU1derXmt5FPhK3PA+QFgtLSypcuSI9Cv0gbnkeID2oM6At1BkwtTpjQUQSmTlOHBwWFkaurq7Znsdt9LQBNO27tuRmz0Wf7GOMRDPm/UW/zFhN5k6Xr4UxqNC4PrX/bgzlyJNbvizUz5/2zfuZ7h4/rddzMxSoM8pQZ1BntIU6gzpjLHVGm897wwq3TRwHt4untSNXu/+CW8bzvJzXAyh+gPT9aS65eXkqFQrP83JeD6AIdQa0hToDplpn0IKroxYg7obwIXyPCGYtlONbQZKIwmIlyufVnRITEslcOTu7kJ+fL+XJk5ciIsy3BZf/6pmwfyu5eXqShWXqCiMlJdHHgEBa0L6HuG/OUGeSoc6gzmgLdQZ1JjvqTKh/AM1u3jFbvpu0idcQ4OoowO0+qANt/r2/2u3O+jnS6whbikqwoKhES0qSVETDAAAAAAZqeb+h9PzaTb3GaxjdpCOFiubTaLu6eaKIiKdkMQkWFJlgSVGJFhTFt0rTf8t4m0QEwwAAAKBnrp659H0KCHB15dWL9xpt9/JNMNlaE3l5upG1tRXZW0tkb51IHho8NiwsigICPorJPyD00/1Q8g/4SIGBHynAn5cnL4uIiCFDhL+bkxWpUokGrfxFbXn9MXg0+dy4TeYMdSYZ6gzqjLZQZ1BnsqvOhAV+IH1DC66O7PjzAC1f0i/dPricTaFE0a8pMSGBLCwsKGdOF8qdOwd5ebmJW8XJK7e70rydnQ25ujqKqXjxvGrPJyoqlvz9Q8nfP0TcBoj7yUFx8nLZFEKhoZGkK/HWNmRjaUXxMTEUF22YQbguPLl4VYxI5U77qlKvyPo58Xbm3gcXdSYZ6gzqjLZQZ1BnsqvOvDCAhhe9Brienp5UokQJevHiBfn5+andPl++fFSwYEF6/PgxhYSEKK0rVaoU5c+fX2nZo0eP6N27d2QIOGjlVGCcLYGDWcUgl+fZzPl/ie2Sl0kUFBQmpgcP1O/fzc1JRSCcHAR7pQiOnZzsydHRjooUyS0mdWJj45NbgmVBcKpAODlI5ikoKFycO2QOf0hwuhUekcr3FT9IkgNaC9o//xezD24BdQbwOQO6IxnRd5PeBpmNHj2apk+fTk+ePKEyZcrQ7Nmzad68eSq3tbKyoj///JM6duxId+/epSJFitBPP/1ECxYskG/z999/U+HChen9+/+6Avz666/0119/GXwe3NBoSQS3usqDy8FtyiD4v5bhT7efguUcOZy12ndCQqLoDqHYGhyQIgiWTbxdYqLymwA5TdXnGgzx9RMfIMiDizqjCuqMevicQZ3RFuqMYXzOaPs6SLqeypUrJ8XGxkqVK1cW8xUqVJAiIyOlKlWqqNx+9OjRUkBAgFS4cGEx7+XlJb1580Zq0qSJfJv3799LjRo1ytD5uLi4SIxvdfH8raytpX4ju0tvIx6KW57Xx+ugyWRnZyMVKOApVatWQmrVqrrUv39TadKkztIvvwyUtmwdLx07/qN0995vUkDgZilJOqDVlJC4X/IP2CQez/vZvGWctOy3oVKS9FQaMqS11LJlNalq1eJS/vy5JFtbwy2j7J4sLC2lCvW+kB6GBIpbntf3ORnSpOv3rzFMqDOoM6gz+JwhE/yc0ebzXi8tuDNnzqRatWpR06ZN5ct27doluipMmDAh1fb79u2jN2/e0IgRI+TLli1bRs7OzvTVV19Rnjx5RFcE7qJQoEAB8vf3p1evXhn0LzNT/DXIg+I8PVX0F/ZK3U3C09NVtMxrIzQ0QqkFWNZvWGnZp64U3MfYlJhifckqKBuUC+oM3kv4nDGPz18XQ08TVrZsWXr48KHSMu6qUKlSJZXbBwcHU968ygOnOJDlPrysSpUqlJCQQKdPn6bAwECqUKECHTlyhHr16kVxcXHZ+EwgZfcEX99gMaljaWlJHh4uqQLhAgW8aMzYofTvvwfJw8NZ3l3C1tZGdJfgqVQp5b7WqkRERKcbDCv2KebsEwAAAGA69BLgcuTNA8UUcSTOy1Xh1toLFy7Q4sWL6dSpU1SnTh0qXbo0xcYmt9I5OTmJVt4hQ4aIYJgHo12+fJkmTpxIs2bN0uqXga7IjqXLYxqamJgkevUqWEwyXB5jx/5B/fu1Uvp15u7uJFqHOdjl1l9Pr+T7nE5Ndl+23sHBlpydHcRUrJj6jBIxMXGiv3BgYFjy7adUawGBH+nDp2Wy+ZDgCNI1S0sLatKkCkn0jv73v6p07NgNSkrS+R8vBgvvJZQL6gzeS/icMY/PXxctjqOXLgqHDh0Sg8U4AJWZOnUq1a1bV6nbgiJu3R02bBh5eXmJgWO5c+emNm3aUO3atVVuP2PGDGrRogXVqFFD4yZvMH6SqM6ciYJ//MR9uo1NY54nbS+LzG8ZWyKySzGpXmYhts/M8/ElovschisstSeicmRB6oN3AAAAU2OwXRS4vyz3m1XE876+/GWu2u3bt2nQoEHy+fXr15OPj488+I2OjhbdHGQiIiLIzo6DDM15e3vrtA8ul4Muj2kMdF0u3NorbxGWtRCraB3m+zncnT79HpQFx+njDBGcNk3WKhz4IXULsew+tx5zFw9FbdpUpw0bR8tbcWWSkrhLxTXq0/sXOnDgKpk7vJdQLqgzeC/hc8Y8Pn9dPh1PE3oJcM+ePSsGmvEgo8TE5C/1hg0bii4IqhQtWlR0Q+BWX5YzZ07ResupxlifPn1ESy4PXJNp1qyZ6NagDX5xdB1s6uOYxkBX5cKHCAgISm4kVcPGxlptrmHZ+ly5eBCdZXJw7OWm0blwzmNZejXuI9yiRTWRL5kv+pGy/3JSUhLNmduLtm07Je4D3ktp13F8xqBstIM6g7IxhTqjlwB3x44dNHnyZNqzZw9t2LCBunbtKpZv2rRJ3HLg26BBAxHQBgQEiOwI3C2Bux1wpoXvvvtOtNZu3rxZbL9kyRLq378/rVy5kg4fPkzt27cXA8369u2rj6cHJio+PoHevQsSkzoc3HKQm1auYcVAmQfXcQYKDw9XMZUtq/5cOMgtWNCTQj9uo5CQCAoLixaD5cLDP90q3E+eolPMK6+Pi0u+wAgAAIAp0EuAGxMTQ/Xr1xd9cPv16ycyKgwfPlwsZ9y1gIPYH3/8UQS4Z86coU6dOomWWn7c/v37xUUcZK2/r1+/ps8++0y06A4YMICeP39O1atXN5irmIH54e4JsiwNRC/T3VbxssyyqXmLqtSnTyO1x5ENpsssvlpdWgFweIrgOSyd4Jlv0aIMAABmeyUzQ4I8uIYDOU2T1a9fnk6emqu2vHr3WkwPH74hV1dH+eTi4vDpfvKts3xecf2ndVkQHKtK0fZfAJzxlmVNcxmjzqBctIU6g3JBnckayIMLAFo5e/YBvXkTSN7eHqI7QkrcSvr2bRBt3XomUy2mvG9nZ/s0g+P/5h1TBMvK693cHEWuYsVW5bx5c2bqVed/aNIKgDlQlq2LjU0kiV5Rx461KCAgWGXwzN1LzAm/rnXqlBGp5fj2n3+uoWUdAMyKXrooAED6OGgdPWoV7dw1SdxXDHKTA1oLGjN6VaaDFn68LCDMLFtba3Jx+S/4TR0gOyitd0mxXrFlmZ8v98V3d3cWk3p36c+1/13pUFWuY+WuFdEpgmXNWpYjImIMPlDs0KEW/bJkIBUowBfCuUl/H/pB/Fji+rR370V9nx4YKPwoAlODLgroomBQ8NdhesFKstevA0Vwa8rBipOTfbrBsWLwnNPDlbp160RnTp8gRydbpfW8n6wWHh6lUctyWgP6ZOujo2Ozpb7wj6LUqeWSfxR17jTXpOuNpvA5o/5zBj+KUGeMvYsCAlwEuAYFXzyqW1aaNatGfx/aQ61afom/m7WoM5zNQhYIp+xuoao7hksaLc98y2nishLnPU4dACffRmgwoE9xPe+L64nPy9Xk7Z1LKbhN2a2laJEBBt8Knd3wOfMf/ChCnTHVABddFAAMHAcj5849JAvyFrfmHpxom80iNDRSTJllZ2eT6b7KsolxajjOnsFTZnFrcHR0XLr7kqWWO/j3VPL1DSGSJJIkSVz2mW8liRcp3+e6pmq58uPSWq74uOT5zO0v9Tmm3p/iuaf1OIns7OxJovfUtm11ioqKTrG/tMpCcX+aPWdDL1tu41qyNPkCSil/FMnybf/8y0Dav/8yPnfA6CDABQDQMJVaIF99LvBjpsqL08Jx14m0+yqnyHSRzjoHh+SrNfKt7L46zZtXxest3KCNm8agLNIh+1F0/sIC8vHxp7CPUfTxY6T45+Djp/uqbnl9yiszAugaAlwAAB3iljNOpcbT+/fBmdoXtwLLguNGjSrSmj9HqX3MH78fEcGK7Cp5PHHrXfL9/5bJ5jnIUV6u6nEpHyt7XOrlio+jdPeZ1efy3zJra2uqU+cLcbXL5EGc+nn+qo6p+lxkj0v/XFRlXMkKNWuWEpM2OM2fqgBYmyCZf1QCZBQCXAAAI8WtZHwlO57Wrz9B02f0UJtabujQFWb/d7OsH1+L5s0N7vKiWSX9ID15ed165ejw4Rlq9zVv3i7y8w0mNzcneVpAVzcncZs8ye47yQd2OjraiSkz6QI5wE0zABZBcnSa62VBtKb5tMH0IMAFADABukotB8bhv362yX3RVTn67y2N8m1/P2WjxvWGB3YmB8H/Bb0pb7mLjbhNc72jvN87X8qcp4ziHNhptRaHa9CKzPc5PSAYHwS4AAAmglOAcSqwlCmfOEgx9dRyYBg/ijiYlv2rkFHcwsxdb9IKkmWtyGkFybL1nEubs594eLiKKXP5wqNJouN0/sI8CgkJlwfA3JKsSZDMjze1H5eWBn5BGaQJQ5owg4L0PSgX1JnMQ2o5fM5ow1TzbXN3ibQDZIUW4zRamBWv0JhVObSTg1/lADi9IDllNwxDGbzXQU+5k5EHNxsLLKsgkEO5oL7gvYTPGP3A529q+FGkmr29rQh08+Xzous3LlH7dq3IxsZCZTcM1zSCZE0znGR08J62QXJsJgfv6TN3MvLgAgAAgMaQbzvty3zzFBWVSBbkTidP3tO6IYy7SajqZ6yydVlFNwy+dXZ2yLbBe2HyvsiqA2XFPsx8YRljyZ2MPrgAAAAA2YQHun34ECamjEo5eC+tAFnW5cJVRQsz92vmIDQrBu+py51ct25ZOn36HukTAlwAAAAAA5Ydg/dcMxAk58jhpFG+5cy0MGcVBLgAAAAAJk6SpOT+umFR9OZNxvZRv355OnlqrtrtfH0zdxGbrJA9lz0BAAAAAJNy9uwDkS0hrf61vJwzcPB2+oYAFwAAAAA0zp3M2RJSBrmGdkEZBLgAAAAAoNUFZd69C1JazheUyc4UYdpCH1wAAAAA0BgHsZwKrFmzavT3oT3UquWXBnclM7TgAgAAAIBJ5U5GgAsAAAAAJgUBLgAAAACYFAS4AAAAAGBSEOACAAAAgElBgAsAAAAAJkVvAW6RIkVo48aNdOPGDdq+fTuVKFEi3e1r1apFe/bsoWvXrtGaNWuocOHCmdofAAAAAJgmvQS4jo6OdPLkSQoNDaXBgweTr6+vmHdxcVG5fY0aNej06dN07949+uabb+jhw4d04cIF8vLyytD+AAAAAMC0SbqeBg4cKD19+lRp2Y0bN6Thw4er3H7t2rXS/v37lZbt3LlTmjlzZob2l3JycXGRGN/qqgz0cUxjmFAuKBfUGbyX8DmDz199fxfhu4kMsly0OZ5eWnBr165N586dU1rG81988YXK7XPkyEEvX75UWhYYGCj2k5H9AQAAAIDp0sulerlrwd27d1MFrBUqVFC5/fHjx2nKlCn066+/0rNnz6ho0aLUrl07CggIyND+0qLLLg2yY6EbBcoF9QXvJXzG6BY+f1EuqDPG+V7S5jh6CXBtbW0pMTFRaRnPW1qqblBevnw5lSlTRvTB9ff3Jz8/P9q6dSs1bNgwQ/tLy7t370jX9HFMY4ByQbmgzuC9hM8ZfP4aGnw3GU+56CXADQkJITc3N6VlPM+DxFTh6xsPGzaMxo0bRx4eHvT27VtauHChaKXNyP7S4u3tTeHh4aSrXyFcIXR5TGOAckG5oM7gvYTPGXz+Ghp8NxlGuciOZ7ABLncnaNSokdKysmXL0u3bt9N9XHR0tAhuWePGjengwYOZ2l9K/OLoOtjUxzGNAcoF5YI6g/cSPmfw+Wto8N1kPOWil0Fm27ZtE3ltW7ZsKeYbNGhATZo0oU2bNqncvlu3bvT333+Tk5OTmB85cqTossD5cDOyPwAAAADIOO4GWr5cVfL3CxO32nYL1QW9pNzo16+f9PHjR8nX11cKCQmR+vTpI1/n7OwsPXz4UGrRooWYt7e3l/bs2SPFxMRIb9++lV6/fi01b95c4/0ZWpoLfR3TGCaUC8oFdQbvJXzO4PNX399F+G6idMujbp2m0vYtp6STRx/LJ57n5YbyOlh8uqMXdnZ2lDdvXtGfIj4+Xr7cwsKCSpYsKZZHREQo9auV9b+QJEnj/anD+wwLCyNXV1ed9sHV9TGNAcoF5YI6g/cSPmfw+Wto8N30n7p1mtKMqUvFfQsLS6XxUhYWRNNmjqSz546Svl8HvbYnx8bGivy2KYNRDl4fP36sFNyyjx8/ij64qoLb9PYHAAAAAJnD3RCGD52SKriVrePwbNiQyQbRXUH/ZwAAAAAABq9mjfrk5Zk3VXArw4Ftbq98VKF8NdI3vWRRAAAAAADDlTu3NxUvVpqKFytDJYqXpWLFSlOe3N4aPdbDw5P0DQEuAAAAgJmytrahQgWLikC2mAhmy4j7zs6uGd5nUFDydQr0CQEuAAAAgBlwcnQWLbEcwBb/FMgWLlScbGxsU20bHx9HPi+f0vPnj+jZ84di8vF5Qqv/+ItyeeRW2c+WB5oFfvCju/eukb4hwAUAAAAwMZ6eeZIDWYVgNl/eAiq3DQ//SM8+BbLPPwWzr16/oISE1IP2ly2fLbIocDCrGOTKsij8tmKOuK9vCHABAAAAjJSlpRUV/NTFQNZntnixMuTm5q5yez//d/TsWXIQmzw9In9/zS5/yzgFGKcC42wKPOBMhltuObjNrhRh2kKACwAAAGAEHBycqFjRUiKQTe4vW5aKFC5BtrZ2qbZNTEygl6+e07NnD+SB7PMXj0RrbWZxEHv+wnGqWaMe7d27nzp0aEeXr5wxiJZbGQS4AAAAAAbGw8NLqUWWuxnk9y6sctvIyAgRvCYHs8ldDV6+eib60WYXDmbv3b9OufO4iltDCm4ZAlwAAAAAPeF+rPnzF/4vkP3UOpvTPZfK7QMD/UQA+/TZf/1lff3SvgiWuUKACwAAAKAD9vYOVKRISaVgtmiRUmJ5SomJifTmzQvRIvv0UzcDbqX9+DEEr5UGEOACAAAAZDH3HB6iWwG3xsq6GnAXAysrq1TbRkdHieBVlpKLW2d9Xj6huLhYvC4ZhAAXAAAAIIMsLCzIO1+hT/1kk7sX8P1cHl4qtw8KClBKycXB7Hvf1wbXh9XYIcAFAAAA0ABnKyhVkvvLlpbnluWsBpzdICUOWN++famUjotvQ0I+oKx1AAEuAAAAQAquru7yrgVlSlegKxdf0vbNp8nKKnXoFBsbQy9ePFYKZF/4PKaYmGiUq54gwAUAAACz7mKQJ7e3yCmr2F/Wy+u/ixiwqMg4EdyGhgbT0+cP6Pmz/y5h++btS0pKStTbc4DUEOACAACAWbCxsaFCBYuLYFaWjqtYsdLk7OSicvu377iLwSORzWDBwh+parVK9OrVC52fN2gPAS4AAACYHGdnVypWtDSV+NRXlqdChYqRtbVNqm3j4uJE1gJ5f9lnj+iFzyOKiooU611cXGjN2l8oODhQD88EMgIBLgAAABi13F755Ff7kuWXzZMnv8ptw8JClQd+PXtIr9+8EJe2BdOBABcAAACMAveBLVSw2KcsBmXlwayLi5vK7X193yb3l/008IuD2YBAX52fN+geAlwAAAAwOE6OzlS0aCkRxCYPACtNhQuVIFtb21TbJiTE08tXz8QVv+TB7PNHFBkZrpdzB/1DgAsAAAB6lStXbnk/We4zy4O/vPMVVLltRGS4/AIJsq4Gr18/p/j4eJ2fNxguBLgAAACgE5aWVlSwQJEU/WXLkJubu8rt/QPef+on+0DeKuvn9xavFqiFABcAAACynL29o7jKl2IwW7RISXE1sJR4gNer188VgtlHoqtBWHgoXhnIEAS4AAAAZs7S0pLKl6tK/n5h4vbylTPiUrOaypnTUz7gSxbQeucrJPabEqfeev7iv0FffOvz8inFx8dl8bMCc4YAFwAAwIzVrdOUhg+dQl6eeenhPT+aM+t3kWlg2fLZdPbcUaVtOWD19i78XyD7KZjN6Z5L5b4DP/iL/rLPFPrM+vq+IUmSdPTswFzpNcCtVq0alS1blp4+fUoXL15Uu/3nn39OxYsXJx8fHzp//rzSurp164p9KTp79iw9ePAgy88bAADAVILbGVOXplqeyyO3WL5qzWKKiAgXg7548FfRIqXI3t4h1faJiYn05q3Pp2D2UXI2gxePxGVtAcwqwF26dCl16tSJTp06RfPmzaO///6bBg4cmOb227Ztozp16tCJEyfE7b1796hdu3byX4HTpk0TvywfP34sf8yjR4908lwAAAAMGX8/2tk5kL2dPdnZO4gg1cHekcaMmkFEFmRhYZFqe/5+HTRgfKp9RUdH0Qufx5/6ySa3yr7weUKxsTE6fEYAWRzgjhw5ko4ePUoPHz6kjKpduzZ9/fXXVLp0aXrz5g3lzZuX7t+/T1u2bKGTJ0+m2p4D2i+//JIKFixIfn5+5O7uTq9evaJWrVrRwYMHxTaVK1emNm3a0IULFzJ8XgAAAPpgx4GnHQedDmRnb0/2HIzyfXFrLwZsieDU7tN9++TteRv5tikfJ7ZNnlc1sEsdWdD78NEdunnrkjyLwbt3L7XqnwtgFAEudxNYsGABPXnyhLZv3y6mZ8+eabWP9u3bi5ZYDm6Zr68vHT58mDp06KAywOVrQPPfH2FhYWKeb6OiokSgywoVKkSurq4UEhJCPXr0IH9/f9EyzI8BADA3mR0wBMpsbGyUgkkOJLn1UwSbaQWXCkFpymXJj/vvvoODo06LnFtgY2KiiePXHDk81G6/a886OnHyb52cG4DeAlwOIDngbNmypQhUx48fT8+fPxeB7o4dO+jly5dq91GiRIlUQfGLFy+oevXqKrfnFmOeOAjet28fNW3aVLQg7969W6yvUqWKuN26dSvdvn1b9McNDAwU28mCYgAAc6DNgCFTyauq3MLpQPYOnwJRDh5F8OmgFFC6urjRk0f+NHL4VLK2sknVeiq//yko5cvD6kpcXCxFx0RRbEwMxcTGUAzf/3QbExPz3/1Yvh9N0THRFMtTbEzy/dhoEbzGKC7j+U+P4/3LVKpYg35ZvFHtOQUFBWbzswbIehl614aHh8tbb/mX7aBBg0Sr7vz580UXgT/++IM2btyYZouBs7OzaIFVxPNOTk4qt7ezsxOBaqlSpURXhGLFitHNmzfl6Uf4sXz8GTNmUFxcHDk6OtLVq1fF/JgxYzR+Xhy464rsWLo8pjFAuaBcUGcyrlbNhvTdhPlpDhiat2AiXbyc+l+y7MJ/cfNf46IF0zb573U7hfvJLZv2Yj75L/fk+2KbT62jycGn8qS43MYm9WVbNfH+7Udq0qitVo9JSEigmNjkwDGOA8ZP90XQ+elWBJtxskD0v/uyIJTn5YFqbLTYj/x+XGy2trTb2dmKSeblq8f04YO/SPGlKp0Xn0tQUIDYzty/q/DdZBjlos1xMvyztHDhwtS1a1fq0qWLaEHlQV8c8HLfWB4sxgPIuE+sKrGxsamuJc1BbMqgV+aHH36gihUriokfy0H1mTNnxOC04cOH0z///CMmGd7P5s2bqXPnzlo9p3fv3pGu6eOYxgDlgnJBndEODwi6dM6HYmMTUq2TBS/Tp/5Mn9cpIgJP3j4pSaKkRIkSk5KSbxOTKFEsSxL3ZesSE2XLPt0mJW+b8rH/7SP5Pu9fl6ysLMjSypKsLD/d8rwl3366r7TMQiy3tPx0+2le9bLkx/ByUxMYEE737/iqXMfPuUHjyhQaiostyOC7yXjKResAd/DgwfTVV19RzZo1RT9c7pbQu3dvpXRc3FWA+8NyH1m+TYm7MeTPn19pGc/L+uSmxK22//77rwhuGV9vmrsqyALYZs2aiaCW04Kl/LWtDW9vb9E6ratfIVwhdHlMY4ByQbmgzmQM97Xl7gjp4eD37/3XyNLKWrSUWllZka7IWjplrZX/zaduBeWWzzgVraCyv93FfIzy/rS5SAA+Z1K3/A/8ehzlypVbviww0I9W/7lYpy3+hgx1xjDKRXa8bAlwe/bsSadPn6ahQ4fSjRs3VG7DgeW4ceNUBreMB5itWLFCdEmIjIwUrbfcX3bChAkqt+d0X5x5gX9Nyv6+4f66spRgX3zxhRigVqlSJbGet+OsC8eOHdPqufGLo+tgUx/HNAYoF5QL6ox2HBxUd/FKydnZLdUyDg5Fv02lPp//9ePkAFLcl28TrXJZcv9P5T6isn0YYmJ/fM4k+/fYX3TsxEGqWaMe7d27nzp0aIeBiagzRv9e4v9btP7UqVevnghuIyIi5Mu4W8K6detE66o6HIBykMx9ZbkFmAer8eMaNGggAlTugtC/f38xsIwHn+XJk0f0qeVUYkeOHBHBbsOGDalWrVpisBq3FF+/fl1cMIJbetu2bUu5c+cWGR80+WuFfxFwH1/OxKDLFlxdH9MYoFxQLqgzGQtuBw8cT23bdFe77fyFk+jO3asKwWwsJSZq92+XscPnDMoFdcY430vaHC91r3I1uM8tdw9I2YeWl/PFGzTBQSy32K5Zs0bkwOXAmOdlrbP8t9lnn30mTwPGuW/5KmV//fWX6Mpw7tw5MeBMlomBW4q5f65s/c6dO8VV0tBvCABMmZOTC/XuOZS2bjouD27Tainlz1f/gPf077F99N73DQUHB1JUVKTZBbcAYB4ydKEHbq0NDg5OlT7s9evXNGzYMI1GgfLfWMuXL09z3ZAhQ5SWcaSe1vaMW5N/++03jZ8HAICxcnNzp84dv6L2bXuRk5OzWMaXSb12/Ty1b9tDDO5SHBXPn8mc8/S3FXOQDxcAzILWAa6Xl5fKq5hx3llO0cWtrkFBQVl1fgAA8ImHhxd17dSfWrfqKr84AF8yddOWlXT6zBERvPIVp2R5cOWfzx/8RHBrinlwAQCyJMC9deuWyHs7evRopeWc0YAHjCG4BQDIWrlze1P3rgOpRbOO8u5hj5/co42bl9OFiyeUuiVwEHv+wnEMGAIAs6Z1gPv999/T+fPnRWqua9euiVZb7g9btWpV6tWrV/acJQCAGcrvXZh6dB9ETRu3JWtrG7Hs7r3rIrC9eu1cmo/jltx7969T7jyu4haX6QUAc6N1gMu5b0uXLk19+/YVabk44wFnO+D0YXyRBwAAyJyiRUpRz+7fUIP6LeR9abl/7aYtK+j2nasoXgCA7LiSGXdD+OmnnzLyUAAASEOpkhWoV4/BVOeLJvJl5y+eoM1bVtDDR3dQbgAA2RXg8vXCBwwYQEWKFJG3LPBlH3l5hQoVxCV6fX1VX/YPAABSq1C+KvXuOYSqV6sr5rlLAQ8a27x1JT1/kXxBGwAAyMYAd+HChdSvXz86efIk1a9fny5dukQ5cuQQVxbjNF5pXb0MAACUVa1SWwS2lSrWEPOck/bY8QO0edsf9ObNCxQXAICuAtxGjRpR7969ae/evbR7927atWsXbd26VVxml68cxjlsAQAgbbVrNaJePYZQmdIV5ZfKPfzPHtq2fRX5+r1F0QEA6DrAtba2FqnC2L1798QVwzjAXbx4seiawN0WMGIXAEAZfzbWq9NM9LEtVqy0WBYTE00HD+2g7TvX0IcP/igyAAB9Bbg+Pj4iiwLf8gUfxo4dK5ZzbkYnJydxneCPHz9m1fkBABg1KytratKoNfXo9g0VLFhULONL5O7dv4l27VlHoaHKV4UEAAA9BLgbNmygLVu2UPHixenQoUOi3+2RI0fEFcyePXuG4BYAgEikUGzerCN17zKQ8ubNL8okLCyUdu/dIILb8HA0BAAAGEyAy8Ett97GxsZSRESE6JM7ZswYev/+Pc2aNSt7zhIAwEjY2dlT65ZdqWuXr8kzV26xLDjkA+3ctZb2H9hK0dGR+j5FAACTp3WA26dPH5FBgYNbxv1x+aIPAADmzNHRidq16UGdO/Yjd3cPsSww0I+27VhNfx/eSbGxGIALAGCwAe53331H169fz56zAQAwMi4ubtSxQx/6sn1vcZ+9931DW7f9Qf8c3Uvx8fH6PkUAALOjdYB76tQp6t+/v+iOEBoamj1nBQBg4NxzeFDnTv1Eqy233rJXr5/T5q2/0/ETBykpKVHfpwgAYLa0DnALFChALVu2FNkTOFtCdHS00vrKlSuTn59fVp4jAIDB8PTMQ906f02tWnYR/W3Zs+cPadOWlXT23L9IkwgAYIwBLmdNWLduXZrr0aoLAKYoX94C1L3rQGr2vw5kY2Mrlj14eIs2bl5Bly6f0vfpAQBAZgLcw4cPa/sQAACjVahgMerR/Rtq3LA1WVlZiWU3b12mTVuW042bl/R9egAAkBUB7pQpUyhHjhxprue+uWFhYdruFgDAoPDVxvhyuvXq/E9chYxdvnJGdEW4dx8DbQEATCrALVy4MOXKlUs+zx/8efPmpapVq9LGjRuz+vwAAHSqbJnPxOV0a33eUL7szLl/afOWlfTk6X28GgAAphjgDhw4UOXyDh060PDhw9F6CwBGqVLFGtS75xCqWqW2mE9MTKRTpw/Rpq2/08uXT/V9egAAkJ0Bblr27t1Lq1evJjc3N1yuFwCMRo3q9URgW75cFTGfkBBP/x7dT1u2/0Hv3r3S9+kBAIA+A1y+ZK+Dg4O4hC8AgCGzsLCgL2o3pt49hlDJkuXFsri4WDp0ZBdt276a/APe6/sUAQBAlwHulStXRJ9bRfb29qJf7o8//kgxMbgcJQAYJktLK2pYvwX17P4NFSlSUiyLjo6ivw5upR271lJwcKC+TxEAAPQR4HKWBEdHR6VlfCnK27dv0/Pnz7PinAAAspS1tQ39r0k76t5tIOX3LiyWRUSG0959m2jXnvUUFhaCEgcAMOcA98CBA1SvXj26ceMGRUREKA0+e/36Na67DgAGw9bWjlo270jdug6k3F75xLKPH0No5551tG//ZoqMDNf3KQIAQDZITu6ohS5dutC+ffvI1tY21fKlS5dqvJ+aNWvSxYsXRdaF69evU506ddLdvmnTpnTt2jVxpbSbN29S69atM7U/ADBd9vaO1KVTf9qy4RiNGjFNBLdBQQG0/Pd51K1XI5HyC8EtAIBpk7SZzp07J3Xs2DHVck9PTyk6OlqytLRUu4+cOXNKwcHB0pgxY8T94cOHSx8/fpTy5Mmjcvv8+fNLkZGR0tChQyVXV1epd+/eUkxMjFS6dOkM7S/l5OLiIjG+1bY8Mjrp45jGMKFcUC6ZqTNOTi5Srx5DpH27L0knjz4W09ZNJ6R2bXpINja2eq/feC/pv1zwOYNyQZ0ho30vaXk87Xb+5MkTqWzZsirXcVDp4eGhdh+jR4+Wbt26pbTs9OnT0sSJE1Vu3759eyk8PFxp2cuXL6X+/ftnaH/6foHwAYtyQX3J2vdSbGy8NOSbidKBfdfkge3Gdf9ILZp1lKytbXT2vjakCT8WUTaoM3g/kYl9zmhzPK27KNy6dYsGDRqUannnzp0pMjKSgoKC1O6jWrVqIhuDIu5+UKNGDZXbc5cDTuvz1VdfkY2NDbVr1448PT3p8uXLGdofAJiGnDk9qf9Xo+nSOR/RJcHZyYV8fJ7QrDljqW//lnT4n90iry0AAJgXrQeZff/993T+/Hlq1qyZCCLj4uKoVKlS4lK9vXr10mgfnFKM+9EqCgkJEftQ5c2bNzR69GhxIYm1a9eKZWPHjqX79+9naH9pcXFxIV2RHUuXxzQGKBeUiyY8PfPQl+37UNPG7cRAsqQkiV74PKZtO1bR5SunSZIkcnJSzvZibvBeQtmgzuD9ZGqfM9ocR+sA98mTJ1S6dGnq27cvVapUSbSoHj16lHr27EmvXml21R9ujeUvIEU8n3KZTNu2bennn3+mTp060YkTJ0QWh02bNonAd9euXVrvLy3v3r0jXdPHMY0BygXlokpUZBy9fhlM/n5hJHt7u7rZU6EiHlS/cQnqP7CNLqupUcB7CWWDOoP3kzl+zmToSmblypWjP/74I1WasHXr1mmUJoy7Mbi7uyst4/ng4GCV23/99de0efNmkb2BHTx4kFauXEkjR44UAa62+0uLt7c3hYeH6+xXCFcIXR7TGKBcUC6qFCpYjDp37E9f1G5CVlZWYtmt25dpx64/6dXrJ3gv4b2Ezxl8/uK7yQy+s10+HS9bAlxOB8bBZfHixVMtr1KlCg0ZMkTtPrhPLW+viB97/Phxldvz5X9TpiXjQDohISFD+0sLvzi6Djb1cUxjgHJBuTC+jG6v7oOpbp2m8gK5cPEEbdq6kh4+vK30lxXqDOoMPmfw+YvvJv0IN9BYRudpwvLlyyeyIowYMUJycnKSvv76azHv7e2tcvs2bdpIUVFRIpuCtbW1VK9ePSkoKEjq169fhvan71GAGOGMckF9Sf/9Ub5cVWne7FXyjAjH/3koTfv+F6lYseTUgHgv4TMGn7/4XtLV9zW+s8lgysXg04Tx1KRJE+nBgwdSfHy8dPfuXalhw4bydZzrlpd37txZvoxz3/L2nP+Wz2HYsGEa788QKy5S+KBcUF9S14EqlWtJPy/aIA9sjx25L02aMF8qWLAo3kv4jMHnL76XdPYdje9sMshy0eZ41hlNE8ZZDTKaJowdO3aMypYtq3IdX43M3t6eEhMT5cs2btwopozsDwAMW63PG1KvHoOpbJnPxHx8fBwd+WcPbd2+inz93ur79AAAwMjoJU2YJhSDWwAwPZaWllS3zv9EYFu8WBmxLDY2hg4e2kHbd66hwEA/fZ8iAAAYKb2kCQMA82VlZU2NG7aint0HU8GCRcWyqKhI2n9gC+3ctZZCQjX7FwgAACBL04RxN4SffvopIw8FADPFP4abNe1A3bsNonx5C4hl4eEfaffeDbRn30ZxHwAAQC8BLveNHTBgABUpUkT8xcj4Qgu8vEKFCuJiDL6+vllycgBg/Ozs7Kl1yy7UtfPX4gpkLCQkiHbsXkt/HdgiWm8BAAD0GuAuXLiQ+vXrRydPnqT69evTpUuXKEeOHFS9enVavny5uEQuAICjoxO1bdODunTsR+7uHqJAAj/40/Ydq0U/W+5vCwAAYBABbqNGjah37960d+9e2r17t7iS2NatW2nChAn0+eefU0wMvrQAzJmLixt92b63mFxdc4hlvr5vaev2P+jIv3s0utohAACATgNca2trkSqM3bt3j6pVqyYC3MWLF4uuCdxtISkpKVMnBQDGJ0eOnNS5Yz9q37anaL1lr1+/oM1bV9Lxk39TYmLylQcBAAAMLsD18fERWRT49uHDhzR27FixnC+l6+TkJC6b+fEjBosAmItcuXJTty4DqFWLzmRv7yCWPX/+iDZtWUlnzv2DH7wAAGD4Ae6GDRtoy5YtVLx4cTp06JDod3vkyBFyd3enZ8+eIbgFMBN58+Sn7l0HUvNmX5KNja1Y9vDhbdq4ZQVdvHRS36cHAABmTOsAl4Nbbr2NjY2liIgI0Sd3zJgx9P79e5o1a1b2nCUAGAzOXduz2zfUuFFrkdOW3bp9mTZuXkE3bl7U9+kBAABkLA/uxYv/fYlxf1y+6AMAmLZixUpTr+6DqV7dZvIUgVeunqVNW1bQ3XvX9X16AAAAmQtwAcB8lCldkXr1GEK1azWSLzt77iht2rqSnjy5p9dzAwAAUAUBLgCoVKlidRHYVqv6hZhPTEykU2cO0+Ytv5PPyycoNQAAMFgIcAFASfVqdal3zyFUoXxVMZ+QEE9Hj/1FW7b9QW/fvURpAQCAwUOACwDictvcBaF3z6FUqmR5USJxcXF0+Mgu2rpjNfn7v0MpAQCA6QW4U6ZMEZfkVYczKYSFhWX2vABAB3iwWIP6LcTgsSJFSopl0dFRdODvbbRj11oKCgrA6wAAAKYb4BYuXJhy5colrmTWsmVLkSrsypUrFBUVRaVKlaI6deqIvLjcEgQAho3TezVt0pZ6dBtEBfIXEcsiIsNp3/5NtGvPevr4MUTfpwgAAJD9Ae7AgQPF7cKFC0VwO2rUKJIkSb6+Y8eONG3aNFzoAcCA8QUZWjbvRN26DqA8ub3Fso9hIbRr93rau38TRUaG6/sUAQAAdN8Ht127dtS+fXul4Jbt3r2b1q5dSzlz5qTg4ODMnxkAZBm+hG6bVl2pa+evycPDSywLDg6k7Tv/pL8ObqOYmCiUNgAAmG+A++rVKxHgPnjwIFXgGx0dTSEh+GsTwFA4OTpT+/a9qPOXX5Gbm7tY5h/wnrZtX0WHjuymuLhYfZ8iAACA/gPcH374gY4dO0atWrWi69evU3x8PJUrV44aNmxIvXv3TtWyCwC65+rqTp2+7Esd2vUkZ2dXsezdu1ci1de/x/aL1F8AAACmSusA99KlSyKgHTBgAFWqVEkMOnv48CGNGzeO7t3DVY0A9ClnTk/q0qkftW3dnRwcHMWyly+f0qYtK+nk6cOUlJSIFwgAAExehvLgcjcFbskFAN2k8ipfrir5+4WJ28tXzlBSUpLSNl6eecXAsVYtOpOtrZ1YxpfR5cvpnjt/DP+sAACAWclQgMtpwr777jsqXbo0ffbZZ/T+/Xtav349TZgwgfz9/bP+LAHMVN06TWn40CkigH14z4/mzPqdAgJ9adny2XT23FHy9i5EPboOov81bUfW1jbiMffu36CNm1fQlatn9H36AAAAxhHgct9bDmYXLVpEZcuWVcp7++eff4r1AJA1we2MqUtTLc/lkZtmTP2V7ty9RuXLVSErKyux/MbNiyKwvXX7MoofAADMmtYB7pgxY2jw4MG0a9cuGjZsmHz5yJEj6cOHD2RjYyMGngFA5rolcMsts7CwTLWOVapYXdxevHRS9LF98PAWihwAACAjAW6hQoXo7t27qZbz5Xk5TZirqysFBQWp3Q9/SXfu3FkMWHv69Clt3bqVEhISVG7L2RkqVqyYarmvry/99NNP4j7vq0aNGkrr9+7dSxcuXNDi2QEYhgrlq4luCeos/Ol7OnR4p07OCQAAwFgoNw1p4ObNm9SvX79Uy7/99luRA1eT4Jbt27ePJk+eLH8sX+Y3LbxfPz8/+cQtxUOGDBF9gBVbkL29vZW2i4yM1PbpARgEDw9PjbbDBRoAAACyoAWXg9IzZ85QgwYNyN3dXfTF5VbYkiVLUrdu3TTaR4sWLahOnTpUuHBh0fI7f/58evLkibiABAe+KR08eFBMMrNmzaIXL17QiBEjxDz3A+aUZaNHjxa5eQGMXVBQYJZuBwAAYE60bsF99uwZlShRgrZv3047d+4UA1w4+CxTpozK4FSV5s2b04kTJ0Rwy7il9Z9//hHZGdQpVaoUjR8/XrTgxsYmX4WJz8fW1lZcJnjq1Kn0zTffkJubm7ZPDcBg3L13jcLCP6aZ3ovThPEVyXg7AAAAyII0YVWrVqVVq1ZRRESEfNnAgQNp3bp1Gg0w45Zb7ner6M2bN1S7dm21j509ezYdOXKEzp8/L19WpUoVsrOzEwPgLl68SL169RItzbVq1RIpzDTl4uJCuiI7li6PaQxQLsm6dRlIri7JP9I4yFXMVsLBLc/+ufZncnJyInOHOoNyQZ3BewmfM+bx+euixXH4W1Ora+t26dKFVq5cScWLF6fg4GD58qNHj4rWXW5ZVYcv9Xv58mWaMiV5lDibNGmSaMGtW7dumo8rWrSo6MrA23AgK1OzZk2Rsmzt2rXJT8rCgs6ePSu27d+/v0YFJmtNBtCnpCSJnj4OIN93H8V8Lk9nCguLobjY/wZg2tlZU/FSnuTphR9HAABgflxdXSk8PDxrW3B5MBe31ioGt6xHjx70+vVrkTos5VWWUuIuCfb29krLHBwclFqEVenZs6do+VUMbhkHyzzJcIvX/v37qW/fvlo8MxKD1NQVWFbhoPrdu3c6PaYxMOdy4SuQjf92LtWsXo8SExPpj9UL6PA/u0XGkWpVa9PmzduoZ89udO36BbXvMXNiznUmPSgXlA3qDN5PpvY5IzueJrQOcL28vOjhw4eplgcGBlJcXJwYeKYuk8Lz58+pSJEiSst4ngeOpadt27Yi/25Kffr0ESnKuE+wjKOjo9atsvzi6PoLUh/HNAbmVi6uru40c9pvVLbMZxQbG0Oz5oyl8xeOy9dfuXqOcudxFbfmVC7aMLc6oymUC8oGdQbvJ3P8nNF6kNmtW7do0KBBqZZzHlpumdUkTRinBGvcuDHlzZuc59PDw0MMPFPMlJASt/hypoQbN26kWpc7d25asGCBaAVm3C+Rc+dqOugNQJ/y5MlPy5ZsFcFtWFgojZvYTym4BQAAAO1o3YL7/fffiwFezZo1o2vXrolWW85swAPPeHCXJrgPLge5V65cEQPGONjlPryHDx8W63nA2I8//kibNm2i27dvyzMl8FXSHjx4kGp/S5cupXbt2okUYadPn6YmTZqI7hJLlizR9ukB6FTxYmVo/pxVlDOnJ/n5v6OJkwfQ69fp/5MBAAAAWRzg8sAtvsAC92/lFlUOOjk45f6xr1690ng/3bt3p//9738if+62bdvo+PHjSn1o+UIN3O1Ahvv8jhs3TgxkS4nThfHAM94fD37j/recdiytFEsAhqBqldo0c9oycnR0oufPH9HEKQMpKChA36cFAABgEiRzn1xcXCTGt6Z8TGOYzKVcmjRuKx09fE86efSxtHjBesnJ0RnlgjqD9xI+Z/D5awCfz+b83UQGXi7aHC9DeXC//PJLqlevnri4gmJ+Tvbdd9/Rx4/JKY4AILVuXQbQNwPHi/vHTxyg+YsmaZQ/GgAAADSjdYDLVwrjnLX//vuvyiwFKQNeAEjG6b6GDZ5EX3boI+a371xDv69aiK40AAAA+g5weTAXDybbvXt3Vp8LgMmysbGlyd8tpAb1mov531bMoV171uv7tAAAAEyS1gGutbW1GGgGAJpxdnalH2f8RpUq1hBZR+YtmEAnTydnDAEAAAADyIO7fv16mjNnDuXJkycbTgfAtHh65qGlP20WwW1EZLhIA4bgFgAAwMBacDlnLefA9fX1FVet4BRdiipUqCBSfAGYu8KFS9CCOatFkBv4wZ++mzyQXvg81vdpAQAAmDytA1y+eMIff/yR5vqQkJDMnhOA0atUsTr9OGO56J7w8tUzmjhpAAUE+ur7tAAAAMyC1gEuZ08AgLTVr9ecJk9cKNLo3b13naZMHULh4UidBwAAYLABrr29PQ0YMICKFCki0h7JUoPxcu6e0KlTJ9F9AcAcdWjXi4YPnSLeG2fO/Uuz546juDjlbjwAAABgYAHuwoULqV+/fnTy5EmqX78+Xbp0iXLkyEHVq1en5cuXo4sCmCX+kTfw62+pe9eBYn7fX5vp199+pKSkJH2fGgAAgNnROotCo0aNqHfv3tSmTRs6evQorV27lmrUqEETJ06kvHnzUkxMTPacKYCBsra2oUkTFsiD21VrFtOSX2ciuAUAADCWAJfz4N66dUvcv3fvHlWrVk3cX7x4MdWpU0febQHAHDg6OtHcH3+npk3aUkJCPM1bMJG2bEt7ECYAAABkP62jUR8fHypdurS4//DhQ6pbt664zwNqnJycyMXFJevPEsAAubvnol8Wb6JqVb+g6OhImvzDEPrn6D59nxYAAIDZ0zrA3bBhA23ZsoU8PDzo0KFDVLx4cTpy5AidOnWKnj17Rh8/YrQ4mL4C+YvQb0u2U4niZSk45AONHteHrl47q+/TAgAAgIy04HJw27JlS3GBh7CwMNEn19/fn+7fv0/t27dHoYLJK1OmEv36y1bKmzc/vX33kkaM6kZPntzT92kBAABARrMosIsXL8rvc3/cvn37ZmQ3AEandq1G9MPkn8je3oEePrpDk3/4hkJDg/V9WgAAAJCRAPfKlSsiS4I6POiMW3QBTE3rll1o9MjpZGVlRZcun6IZP46mmJhofZ8WAAAAZDTAnTVrFjk6OqrdDn1wwRR91WcE9e09XNw/dHgXLf5lKiUlJer7tAAAACAzAe6BAwc03RTAZFhaWtHY0TOoVYvOYn7Dpt9o7fql+j4tAAAASAcu1QuQBu5nO3XKz1Tr84aUmJhIS36dQQf+3o7yAgAAMHC4VC+ACm5u7jR31u8iY0JsbAzNmj2Wzl88jrICAAAwArhUL0AKefPkF2nAOLj9GBZCY8f3RXALAABgRHCpXgAFJUuUo2VLt4sLOfj5vaURo7rTg4fJl6YGAAAA44BL9QJ8wpfc/XnRRsrpnouePX9Iw0Z1ozdvfVA+AAAARgaX6gUgov81aUdzf/ydHB2d6PqNCzRqbE8KDg5E2QAAAJjDIDO+VK+Pj4+4VG9ERIS4VO+YMWPo/fv3IleutnLmzEmhoaGUlJSU5jbu7u4qc/DGx8dTQECA1vsDUNS960AaNGCcuH/s+AGav2gSJSTEo5AAAADMpQVXdqleDm45mCxYsCBt3ryZhg4dKgJfTbVt21YExS9fviRfX1/q1KlTmtvOnTuXLl26pDS9ePFCKTevNvsDYJaWljRy+A/y4Hbb9tU0Z/54BLcAAAAmQNJkcnZ2ljZu3CjdunVL6tixo9SoUSMpPDxckvH19ZWqVq2q0b7y588vRUVFSR06dBDzrVu3FvNFixbV6PE1a9aUwsLCpOrVq2fJ/lxcXMRz4FtNyyOzkz6OaQyTrsrF1tZOmjF1qXTy6GPp+D8PpY4d+uj9uRtCuRjjhLJBuaDO4L2Ezxnz+Px10eJ4Grfgzpw5k+rWrUt//fWXaK39888/RUtu4cKFKW/evLR9+3ZaulSzKzz17t2bbt26RXv37hXzBw8epNOnT1OfPn3UPtbGxoY2bNhAixYtoqtXr2Z6f2B+nJ1daeG8P6le3WYUFxcnctzu3rtB36cFAAAAuu6Dy31t+/fvTydOnCA3Nzfy9/enLl260KtXr8T6CRMmUFBQEDk5OVFkZGS6+6pUqZIISBXdvXuXPvvsM7XnMWrUKLKzs6P58+dnyf7AvHh55qX5c1ZR4cIlKCIijL6fNoxu37mi79MCAAAAfQS4PNDr2bNn4v7Hjx9FMMt9XWW4JYwHd7m6uqoNcHlf3IdWEe+Tl6fH1taWxo4dK/rk8iC3zO4vJRcXF9IV2bF0eUxjkJ3lUqhgMZr2w1LK5ZGbPgT504xZI+nV6+dG8RqgvqBsUGfwfsLnDD6Dzf27yUWL41hrMyAnMTFRPs9ZClRlKuDt1JEkiSwsLJSW8XxCQkK6j+vQoYN4cmvWrMmS/aX07t070jV9HNMYZHW5hARH0b3b7ykxMYkcnWypdZ3PqVPXm2RsUF9QNqgzeD/hcwafwYbmnQHGMlqlCcufPz9ZWyc/xMrKSmletkwT3L0hV65cSst4PjAw/byjnBmBMydERUVlyf5S8vb2pvDwcNIFDtS5QujymMYgO8qlzhdNaczIGWRjY0v379+gH+d9S5GRxlXmqC8oG9QZvJ/wOYPPYHP/bnL5dLwsD3A5PVd685q6fPmyGKimqFatWrRt27Z0H9ewYUOaOHFilu0vJX5xdB1s6uOYxiCryqVjh740fOhkcf/0mSM0e954io+PI2OF+oKyQZ3B+wmfM/gMNjThBhjLaBzgtmzZUvSBVYdbU9XZunUrTZ8+nRYvXiyyMXTr1o2KFClC69evl2/Dvwa4n29MTIyY53y7Hh4e9ODBgwztD8wLd1EZNGA8devytZjfu38TLVs+GxcAAQAAMAMaB7iclSCrhISEUOPGjUUmhP3799PDhw9Flobg4GB5EzS3DnOrrOxiDtzl4O3btyoDXHX7A/NibW1DE8fNpSaN24j531cvom3bV+n7tAAAAMBQL9WbVThg5lZhVbiZu0CBAkrLbty4kWqZpvsD8+Ho6EQzpy2jqlVqiyuSLVg8hY4e26/v0wIAAABzCHABspqHhxfNm/0HFS9WhqKiImnazBF07fp5FDQAAICZQYALJqFAgaK0YM4qypMnPwWHfKDvJg+kp89Sd2cBAAAA06fxpXoBDFW5spXp11+2iOD2zVsfGj6yK4JbAAAAM4YAF4zaF7Ua0+IF68jN1Z0ePrxNI0Z3J1+/t/o+LQAAANAjdFEAo9WmVVcaNWKauMDIhYsnaNacsRQTE63v0wIAAAA9Q4ALRqlf31HUp1fyxT0OHtpBPy+ZTklJ/11KGgAAAMwXAlwwKlZW1jR21Axq2aKTmF+7filt2PSbvk8LAAAADAgCXDAa9vYONO37X+jzmg0oMTGRfl4yjf4+vFPfpwUAAAAGBgEuGIUcOXLSnFm/U5nSFUU/25mzx9DFSyf1fVoAAABggBDggsHLl7cAzZ+7mvJ7F6aPH0No0g/fiIwJAAAAAKogwAWDVrJkeZr34x/k7u5Bvr5vaeLkASLXLQAAAEBakAcXDFb1anXpl0UbRHD75Ol9GjaqK4JbAAAAUAstuGCQGjVoRcOHfk/W1jZ09fo5mjZjJEVHR+r7tAAAAMAIIMAFg/PKJ4hGj5wh7v97bD8tXDyFEhLi9X1aAAAAYCQQ4ILBsLS0pG8GTiCf50Fifsu2P2j1nz+RJEn6PjUAAAAwIghwwSDY2trR95MWU906TcX876sX0rbtq/V9WgAAAGCEEOCC3rm4uNHsmSuoQvmqFBcXS59VLUx/H9qu79MCAAAAI4UsCqBXXp55aenPW0RwGxERRtNmDiev3C54VQAAACDD0IILelO0SCmaN2cVeebKTQEBvjRxykAKCvLDKwIAAACZggAX9KLyZ5/TzOnLyNnJhXx8nojgNjDQj1xc0HoLAADKHB0dKVeuXGRhYaGXonFycqKYmBgqUKAARUYiZWV2lUtSUhL5+vpSQkJCpveFABd0rmGDljRpwnyysbGl23eu0JSpQykyMhyvBAAAKOGAtl+/ftSgQQO9Z/m5cuUKTZ48WQRhkH3lwgHzlClTKDAwMFP7QYALOtW541c0dPAkcf/U6cM0Z/4Eio+Pw6sAAACpcHBbv3592r59Oz169ChLWvYyGsiVKVOGHj58iAA3G8vFzs6OBg8eTAMHDqS5c+dmKk0oAlzQ2a/wwYMmUJdO/cX87r0b6LcVc5DjFgAA0vz7m1tuObj9+++/9R7I5cyZk169eoUAN5vLZceOHTR06FByc3Oj0NDQDO8HAS5kOxsbG5o4fh41bthazK/8YwFt37kGJQ8AAGny8PAQt9xyC+YjICBA3Lq6uiLABcPl5OhMM6f/RlUqfy4utzt/0WQ6dvwvfZ8WAAAYONmAMn11SwD9SExMFLeZHVCIPLiQbTw8vGjJT5tFcBsVFUnfTRmE4BYAAMymBTpv3rxka2tLxYoVky+vUaMGlSpVigz9n9diCuec1XRRBnoLcLnpmUfJbdmyhWbMmEE5cuRQW9jDhg0T269YsUJ0Olc0cuRI2rt3r9LUokWLbH4WkJaCBYvSsiXbqFix0hQUFECjxvak6zcuoMAAAEDnLCwtqVi1ylS5RVNxy/PZ6ddff6W3b9/S+fPnqV69enTkyBFycHAQ644dO0b58+cnQ1a2bFl69uyZGPSVHXRRBnrpg2tlZSWe3IcPH2jbtm3UtWtXOnPmDFWtWpXi4+NVPmb//v1UuHBhMaqOfxEdOnSIvvzyS/rnn3/E+l69eol9nD17Vv4YHtUHule+XBVx6V1X1xz0+o0PTZw8gPz83uKlAAAAnavQuD61/24M5ciTW74s1M+f9s37me4eP53lxytatKiIT2bOnEnr168X6a6aN29O0dHRIl8sD8zKly8fubu7U0REBHl7e9PLly9FHnhnZ2eRB1YVjn2CgoIoLi515iEOnnlQHsdV2qzTBD+e8xDzsVXh/MTcSs3pvTQ5dsoyCAkJoewi6Xrq2rWr9P79e8nGxkbMW1paSk+fPpX69OmjcvvWrVtLMTExUsGCBeXLatSoIVWoUEHct7KykqKioqRy5cpl6HxcXFwkxre6KgN9HFMX0xe1G0tHDt6WTh59LC1bsk1ydXVHuaC+4L2kh/eiqX7GoGzMp1wKFSokbdiwQdxmdB8VGteXFt2+IC26fV5afPeifOJ5Xs7rNdkPxylVq1YVt+q2ffjwoRQfHy/inE2bNonYhDk5OUnHjh2TEhMTpbdv30ojRoyQKlWqJAUFBUmrVq0St9HR0dKNGzekvHnzyvf3xRdfiBgpICBACg8Pl9atWyf2JTsvng8LC5PevHkj+fr6Sj169FC7Tt3E58V+/fVXKTg4WMRYO3fulB9X8bx4vTbnlbIMtHndtamjeumi0LBhQzp58qS8tZZTSxw/fpwaNWqkcvvWrVvT4cOH6fXr1/JlnFj47t278qZ0/jVQu3Zt2rBhAy1cuFD8ggLdatu6O82Y+ivZ2dnT+Ysn6NsJX1FYWPb9MgMAAPNk62CvdrJzcqT2k8aK7VN2SUiel0TLLm+nbl/a4Lywfn5+NGLECPHvsqImTZpQVFQU9e3bV3RjYJxmi//Z9vLyoty5c4tuAaNHjxbruEV39+7dNH/+fLGeWz0LFSpEc+bMEes7duwoYh9u3eWWUU6vNW7cOBETpbdOU3w8Pie+LV68uOhSqnheHG81bdpUdDfQ9LxUlYHJdFHg5viU3Qfev3+fql+tDBcqdz1o3769aPbn5uxVq1bRvXv3xPoqVaqIClGpUiURCHPf21u3blHNmjW16qagy8vEyo5lKpem7dVjqDzH7T//7qEVf8wnW1sbMZlzuWQVlAvKBnUG7ydz+5zhv7Y5IJJNMsPWraDClStmev8c5HK3hTmXjqvd9uXNO3RhyR8iENVUynNXdV82v2jRIpEXnrsscBfMcuXKiXXdunUTweDp06epRIkSYlsei8QB75gxY0SuWP6bv3LlynThwgXRnZMnlt46dUGubP3EiRNFVoOwsDBasGCBCEgnTJggPy/uGsqDxfgyvZqel6rySHlsnvj1T1kXtambeglw7e3tU/W15XkeSKYKP0nup8sttVxA3Ff36tWrIiDmltxLly6JTtyy/rdbt26lAwcOiF8aXbp00fi83r17R7qmj2NmpaQkiZ489Cc/3zAxX7ioB82ZP5HmLvjOrMslu6BcUDaoM3g/mcvnDPfp5O94bhHlVk4ZRycnnZ+L7JgVK2oWWHM8U6RIERHgybIRcCMc98Pl4I0b7oKDg6lkyZLyfqy8LePAkAfe83ydOnVECyr/y62IA2Fe9+DBA7pz546Ifzh/LN9yoPnq1at016nD5xUbGysCVdl5cdouzgxRt25d+Xn9+++/Wp8XUyyDlHi/3Op7/fp1ES9mlF4CXC4ADloVcXM3/0JQRVYhOMhlXEhcAcaPH0+dO3emx48fi0kRd4HgS71p27IcHh5OusC/QvhDRJfHzGr29g40cdw8qlrlC0pMTKDlv8+lo8eSf6GZc7lkB5QLygZ1Bu8nc/uc4SBn8uTJ4p9YxaDsZuc+ZKNBt4EiVSrRwOU/qd1u1dCx5HPjdrrbJMXFi+CWgzZZntb0cKOdj48P3bx5Uz4o7Pbt26Klk7tlcoYCXie7+hff53WMuzfwX/68jDMx8C034qWFuwhw94CWLVtSz549ac2aNfTZZ5/Rmzdv0l2X7vNNShJxFx9bccAY5yS+ePGi2C+v4y6naZVLesdWLIOU+DG8zZAhQ1Kdp6yOGmyAy5WVf8ko4qb3lEGqDF/FhANaRS9evBCjEtm3334rCn3JkiXy9Z6enuTv76/VefEbWtdvan0cMyvkyJGTZk5bTqVLVaCYmGia8eNounT5FJl7uWQ3lAvKBnUG7ydz+ZyRBYOySVFsZJTaxz8+f1lkS3Dz8lSZFkxKSqJQ/wCxHd9Pj+yvdA7iNL0kbcpzV5xPa504L0kSE89zUMx/+XPLKWdjYNyqyX1iOQ7ifrl8ThxM//bbbyKNKr92FStWFI2Daa1T14rLx+ZWaN6Wu3wy7lPL8RsH7LLzkrWs83E4k4Im5yW7rK+q11WxLPj1z0w91Msgsz179ogBZRUqVJAHt9xvdteuXSq351RiHMxynxTZrwjuwMx9UhgXAOfU5WZtxr8++/fvT5s2bdLZczIn+fIVpGW/bBPBbWhoMI0d3ydLg1sAAIDM4qCVU4ERWaQKYJPnLWj//F/UBrdZjf+trl69umipVIcHcnFL586dO6lWrVpigBaPNZINzuKxSdxlk1tLuSsHD+TiBr/Lly+nu04THKCuXLlSXJSB/0Hn1nROfaZ4Xtu3bxdBqzbnpW0ZZIZe0n/Mnj1bpI84efKkFBISIs2aNUu+ztHRUdq7d69IQSFbNmXKFCk0NFT6559/RGqJ48ePi+14nYWFhbRx40bpw4cP0tGjR8X+1qxZI5Zrci5IE6b561a6VAVpz44LIg3Y5g3HpPzehU06TY2hTCgXlA3qDN5P5vY5kxVpwnjiVGA/HN2nlCbs+3/3apwiTNs0YTydOXNGatasmbhfvHhxkU7LwcFBzPfu3Vu6c+eO9P3330ulS5dWWsfT6NGjRQwjm/fy8pJWrFghHnP58mVp7ty5Sum6Ro4cKY537949ETtVqVJFo3XpTXxet27dkrp06SKOefHiRXHeitvwea1cuVKcv7bnpVgG2rzuWtZR/VXeYsWKSc2bN5eKFCmitNza2lpq166dlC9fPqXlPM/bc342VfvjSsQVim+1OQ8EuJqVU43q9aRDf90Uwe3vv+2W3HN4mPwHrKFMKBeUDeoM3k/m9jmTVQEuTxaWllKxapWlyi2ailue1+bx2ga45jJZZkO5ZFWAq5c+uDLPnz8XU0rcjC1LJ5EylRhPaeHmcp4g6zVv9iWNGzOLrKys6eq1szRt5iiKjk7uEA8AAGDIuBvC82upBzSZI0dHR5GfNi2cPYEHtxk7vQa4YBx69RhCX/dLTjr979F9tPCn7ykhQfUllQEAAMBw1a1bl5YtW5bm+idPnlCrVq3I2CHAhXRHjY4cPpXateku5jdvXUmr/+QO+wAAAGCM/vnnH/lFI0wZAlxQiS+3+/2kxVTniyYiXcevy3+kffs3o7QAAADA4CHAhVRcXXLQ7FkrqHy5KhQXF0s/zv2Wzp47ipICAAAAo4AAF5Tk9spH8+eupkIFi1F4+EeaMnUI3b13HaUEAAAARgMBLsgVK1aa5s1eRbk8vCggwJcmTh5AL18hKwUAAAAYF71cyQwMT5XKn9OSxZtFcPvC5zENG9UVwS0AAAAYJQS4QI0bthYtt05OznTz1mUaOaYnffjgj5IBAADIBnZ2dijXbIYA18x17tSPvp+8mGxsbOnkqUM0cfLXFBkZru/TAgAAyNK0l/Xrl6du3eqJW57PTpUrV6ZVq1bR+vXrqUaNGrRz5055UHv48GGqU6dOth4fEOCaLQsLCxr6zXdiYjt3r6NZc8ZSfDwu4AAAAKajQ4da5PNyNZ08NZe2bB0vbnmel2eXrVu3kpubG/3999/08uVL2rZtm/z7FcGtbqAF1wzZ2NjQD5N/Eq23bMXv82n5yrkkSXz5ZgAAANPAQezOXZPI2zuX0nJvbw+xPDuCXA5mCxQoQPnz56eyZcuSra0tdevWTXz3Ll26lOzt7Wnq1KnUuXNnKlSoEK1Zs4YqVKhAS5YsES2+Xbp0UdqflZUVDRgwQKybP38+VaxYMVVr8c8//0yrV6+mUaNGicBak3XpkZ1X0aJFxTn/+eef1LBhQ3JwcKDJkyfTunXr6KuvvlJ6DD/fCRMmiGOtXbuWBg4cKM6d8f2VK1fKt3V2dhY/Aho0aEDZBQGumXFycqH5c9ZQwwYtKT4+jn6c8y3t2PWnvk8LAABAY46OdmonZ2cHWrJ0kNje0tJC6fHJXRQk+mXJILGdun1pY/v27RQdHU3nz5+nEydOiKCyU6dOZG1tLVp0uSX35MmTdO/ePcqRIwf17NmTdu/eTU+fPqXnz5/T5s2bRUAss2XLFvrmm2/o9OnTFBUVJW6bNm0q1pUuXVocw9/fX+yzZcuWdOjQIbXr1OHz6t69O+3YsUOcJx+Xr4B27NgxEbDfuXOHVqxYQV27dhXbe3l50c2bN8nb25uOHz9OL168oF9++YW+/fZbebeMHj16UNu2bcU8Ly9XrhydO3eOsgvShJkRzpAwb85qKla0FEVGRtDUGcPoxs1L+j4tAAAAjZ09N5+++KJspkuMg9wCBXJRWPgOtdueP/eARo9Wvx3bu3evaPW8dOkSnTlzRgRyMhwkJiYm0tmzZ+nhw4dUqVIl0Td3zJgxIvhlhQsXpi+//FK0BHN3hv/9739i2cePH8X64OBgWrRokXhs48aNycfHh+bNmyfWHThwgJo0aSKeW3rr+Aql6shaa//991/RrbF379507do1mj59ulhfpUoV0QL75MkT0Trdt29fpQCaz7l69eri/tu3b8W++LEPHnBZjqbmzZtTQkICZRe04JoJvnDDsqXbRXAbFBRAo77tieAWAACMjin2puPAUeb9+/fiL3zGAS4Ho/y3Pw9U44mDXw6auSWVW0BLlSolAukRI0ZQzpw5ac+ePeIx6a3T1I0bN8Qtd2HkwPrWrVvydSEhIfIuD+/evRPBbd68eUUQzcerVq2aaLWW+e2330TLNgf2GzZsoMuXL1N2QguuGShfrirNmbWCXFzc6PXrFzRh8gDy93+n79MCAADQWr26EzXqNlC3bjk6fGSG2u1aNJ9GZ8/eT3ebmJh40Z81u0RERMjvczDJLaayv/5fv34tWnMVLVu2TNzevn2batWqRYMHD6Zx48aJlmPuH/v111+nu07TIJcDUkVxcXEqt+N+xdyntlmzZqJLw/Xr18nPz09pG35eV69epdq1aysFytkFAa6Jq1unKX0/aTHZ2trRvfs3aMoPQygsPFTfpwUAAJBhUVGxarc5evQWvXkTKAaUqUoLxkHe27dBYjt1AV92pxVLy6tXr0QrKffRTQv3hx06dKi4zwPBuEvB5s2bRX/Z9NZlpSFDhlDVqlXF4DTu88t4YJq7u7t8G+7SMGzYMNGizIPl/vrrLwoKCqLsgi4KJqx92x40/YelIrg9f+E4jZvYD8EtAACYBQ5aR49axYkxUwWwyfMWNGb0Kq3+ss8K3Aqq+Nd9ejgIzJcvn+jfKtOxY0cxwIv16tVL9G2V4dZT7uMbGRmZ7rqsljt3bvrw4YM8uC1TpozoSsHdKBhnU+BuFhyo82A3brFevHgxZScEuCZqQP8xNGrENPGr86+D22jqjBEUGxuj79MCAADQmb17L1LnTnPp3TvllkJuueXlvF7Xrly5IjIM8EArdXiQGKf34oCWsydwX10OFGWDuThTw6BBg0SXgP3799Pdu3dFC+3FixfTXZfVOC0YZ1DgbhFHjhwRLcScTaFIkSJiPXeRKFiwII0cOVIE2Jw2jAetcatydkEXBRNjZWVN48f+SM3+10HMr1n7C23akvxLDwAAwNxwELt//2WqW7cs5c2bk3x9g+ns2QfZ2nLLgSUHe4z70HKaMFl/Vr5fv359sTzlOsZ9WTlIlPn999/F4DDOSMDbcT9WWZ9dDoCLFy8urpbGg8g4D+3jx4/VrlOHH5vyvLgbwv37//VV5kCbMy0w3m+xYsXEsTiA5T62jo6O4nlyf2IOrnnwWUBAgNieg1/ur8vpx7KTZO6Ti4uLxPjWmI/p4OAkzZ+zWjp59LF07Mh9qUWzjnovW0MoF1OYUC4oG9QZvJ/M7XOmUKFC0oYNG8Stvs/F0tJSqlq1qrjV97kY0mSZDeWS3uuuTR1FC66JcM/hQXNn/0GlSpan6OgomvHjKLp85Yy+TwsAAAAMSM2aNUWXgbRwq7LsAg3GDAGuCfD2LkQL5q6hfHkLUGhoME36fhA9enxX36cFAAAABubNmzep0o4pkl1QwtghwDVypUtVoLk//kE5cuSkd+9f04RJX9P796/1fVoAAABggN6/f59u2jFTgSwKRuzzGvXpp4UbRHDLLbYjRnVDcAsAAABmDy24Rqpl8040dvQMkTXhytWzNG3mSIqJyd7RiAAAAADGQK8tuJy2glNKeHp6arQ9p6Pg7fnaylmxP2PVp9cwGv/tbBHcHvl3D03+YTCCWwAAAAB9B7jDhw+nFy9e0MqVK8VteiP6WOfOncnX11ckO+YEwpzsWDGQ1XZ/xsjS0orGjppB/fqOFPOc33b+wkmUmJig71MDAAAAMO8At2zZsuISbZz0l69NXKdOHZoxYwZ99tlnKrcvXLgwrV+/nsaPHy+/1jFfX5kv95aR/RkjOzt7mjl9GbVp3U0kp/5l6QxxEQcAAAAAMIAAt2vXrnT27FnRCstkl3br3r27yu35cm7Pnz+nVatWya8h3b9/fxH0ZmR/xsbV1Z0WL1hHX9RqJC63O23mCNp/YIu+TwsAAADSwI1xJUqUICcnJ6pUqZK4ohfjy9NywxyYaAvuw4cPlZbxZd7Kly+vcntuteVuCZaWlqKFVnZt44zuz5jkzu1Nv/68hcqVrUxhYaE0bmI/Onf+mL5PCwAAwGhw/FCpYg1q1LCVuOX57LRmzRrxTzOn4+JL7K5bt47s7OzEuv3791PevHmz9figpzy4bm5u9OTJE6VlfF1lV1dXldtzX9sPHz6IysLXLebrHV++fJk6duworpOs7f7S4uLiQroiO1Z6xyxapBRN/X4J5XTPRYGBfjR91gh689ZHp+epa5qUizlCuaBsUGfwfjK3zxlu+eRAVDZlVJ0vmtKwIZPIy/O/oDIg0Jd+WzGXzp0/qtE+rKyslG7TU7FiRdGF8ueff6bNmzfT27dvxb/O8fHxokGO98Etuw8ePBAXVeCY5v79++Tl5SXimadPn6baJz9/3s7f35/CwsJSrffw8BCv26tXr0iS+Eq1mq3LLG3KRVOy15tf/5R1UZu6qZcANzExkaytlQ/N8zExMWk+pl27dvT555+LrgpcAbhLwg8//ECTJ0/O0P5UeffuHelaWscMDoqk+3d8KTExiZycbalWnVrUufttMhf6eC2MAcoFZYM6g/eTuXzO8Hf4lStXqEyZMiJLUkaUL1ed+vYanWq5Z67cNP2HJbR+0y907/5VjffHwas6GzZsEEHlgAEDRNeErVu30vbt26lu3bo0e/Zs0ZLLsUvBggXp7t27YnD8pUuXxD/U9vb2FBQURMOGDSM/Pz/5pXWnTZsmAmSOf7hMeJxRZGSkCCznzp0rHhsaGiqOu2TJEtq3b1+667KaJuWiqdy5c1OBAgXo+vXrojwySi8BLv+a4SegiOdlL2ZKnD2Bf3lwcMv4F8+OHTvof//7X4b2lxZvb28KDw8nXeBfIfwhouqY9es1p1HDp4sg/c7dqzRn/jiKiookc5BeuZgzlAvKBnUG7ydz+5zhIIcDQe6CyDGAIns7B7WP51bAieN+IiKJLCyUW4B5nsfztGrenXbv3izupyc+IU4EcfxPMjeqpadChQrifMeOHSu6KJQrV04+Poj733IM8/XXX9Px48dFAMz/NnP2J2715eD34sWL1LhxY5ENigNaHlM0atQocXldTpe6Z88e6tGjBw0dOpS6detG+fLlE10e4uLiqFmzZjRlyhQRAHfp0iXNdeqer6Y4iNa0XLTpu8yXEx4yZIi4VVVHDTbAPXfunPg1wpVPVsgNGjQQvyxUOXPmDH311Veig7aseZ374XJTfUb2lxZ+Q+v6TZ3ymF07f02DB00Q94+fPEjzF34nfrWZG328FsYA5YKyQZ3B+8lcPme4hZK/02WTzK+/bKXy5apkev8cM3h65qED+5IHqKfn7r3rtH7TYhHEaRocpjx3Vfdl89ydgffN3TA5oOWuDLyuU6dO4rXgLgwcOMv68M6ZM4cGDx5Mtra2okGvXr16YqzS4cOHxcTSW5fVtCkXdWTlwq9/ZuqhXgaZcVN9QkIC7dq1S3Q92LJlC9nY2NDGjRvlvwjq168vz3PLnbUdHR3F9i1atKCpU6eKDAmLFi3SaH/GgIP3YUMmy4PbHbv+pNlzx5llcAsAAJCWrO5Hagj4n2oZbm2VdbssXrw4ubu7i0FqsmngwIHk45M8Hof7+P7111906NAhCgwMFHGPrLvA5nTWmQNrffWr4QB20qRJogma/37gXxg8YIxxn4vp06fTzJkz6eTJkyKKr127tsiDy830XBG4Lwv3z9Bkf4aGfzWWL1eV/P3CxO2Nm5fou/HzqEH9FmL98pVzaefudfo+TQAAAIMzckwPsrdX30WhQvlqtGDuarXbTZg0gO7eS78VNy4ulipXrkzZJa3WT45vOKbhGCgt/A83x0fcAMhpVc+fPy8CWQ6C01tn6vQS4DIOUkeOTL4iV0oc0HI/FUXBwcEigM3I/gxJ3TpNafjQKWI058N7fjRn1u/ijWNra0fx8XE0d8FEOnnqkL5PEwAAwGDFxKhvwLp+47zIlpDLI7fKLAwcVAZ+8BPbqft7PSvTimnzV/6tW7dowoQJoh+trJXX2dmZihYtKvq9cj9l7h7w/v17MbiNW2n5b/3y5cuLf7bTWmcOAa7eLtVrjji4nTF1qRi9qYiDW/7LZdOWlQhuAQAAsiiQXLZ8NvH1FVIGlTzPy39bMSfL+o5qijMa8L/MJUuWVLstZzzgTAt79+6lpk2bUvv27eno0aNi3BFr1KiRyMDQoUMHkW+XB5DFxsbShQsX0l1nDvTWgmtu+Ncft9yylKM5mUQStWzRiTZtWaHzNxsAAIApOnvuKE2bOVL+z6kMt9xycMvrswMPCuNAlnF3SW6JlWUZ4OwK3377rfi3mgNYxXWMW2plWaO48YuzH3A2CQ5QeV8HDx6Uj0HiK7ryuCXul8up1DiHLnfhDAoKSnedOUCAqyPcF0jxzZWSpYUl5fbKJ7a7feeKrk4LAADApHEQe/7CcfH96uHhSUFBgaLPbXY2JjVv3lx+n1OAKfbf5dRhPMmk7Nu7fPlypfmQkBDRjzYtf/75p5i0XWfqEODqCL+psnI7AAAA0AwHs2g8Mi/og6sj/IsxK7cDAAAAANUQ4OoI/x3CoznT+kuEl/sHvFebqgQAAAAA0ocA18xHcwIAAACYGgS4ehjN+SEo+RLDiqM5eXl2jeYEAAAAMCcYZKan0Zw1a9SjvXv3U4cO7ejylTNouQUAAFAg+0fTzs4O5WJGrD9dpjizl2RGgKunN+29+9cpdx5XcYtuCQAAAMo4Hyxfqnbw4MG0Y8cOCggIUMoXq+tc9rlz56ZChQrhOzsby4WDW74wRXx8PAUGZm7QPQJcAAAAMDh8qdkpU6aICxUMHTpU74EcXxb3zZs3CHCzuVw4uP3555/FRS0yAwEuAAAAGCRuxZs7dy65ubmRq6srWfCIbD1wcnKi69ev05AhQ8QVyCB7yoW7JfBrntngliHABQAAAIPFQQ9f9lZ26Vt9cHFxIXt7e9FSGR4errfzMDQuBlwuyKIAAAAAACYFAS4AAAAAmBQEuAAAAABgUtAHN0VfEl0fS5fHNAYoF5QL6gzeS/icweevocF3k2GUizbH4eGImcukawLy5ctH79690/dpAAAAAIAa3t7e9P79+3S3QYCrEOQa2ghAAAAAAFBuxVUX3DIEuAAAAABgUjDIDAAAAABMCgJcAAAAADApCHABAAAAwKQgwAUAAAAAk4IAFwAAAABMCgJcAAAAADApCHABAAAAwKQgwM0mderUobNnz4pkxEeOHKFSpUpl6fbGyt7enn777Td6+fIlPXr0iEaNGpXu9k2bNqWQkBCl6d9//yVTNmDAANq6dava7Vq2bElXrlwRdWbPnj2UP39+MmVubm704MEDKl68eLrb9erVK1Wd2bRpE5kaCwsLGjNmDN26dYvevHlDBw8epPLly6f7mO7du4vt+cqNGzduJA8PDzJFFSpUoAMHDtDr16/F8+Vy4vJKy9ixY1PVmcWLF5Mp4rK4f/8+vXr1ipYtW6b20qdDhw4V23MdW7FiBTk5OZEpKlOmDB0+fFi8N/i7uGHDhuluP3/+/FR1ZuLEiWTKOnbsKOqBOpMnT6YnT56IOrZgwQKysbEhfeFL9WLKwjIoWLCgFBYWJg0ZMkQqVKiQtHDhQunVq1eSg4NDlmxvzNPatWuls2fPSiVLlpQaNmwo+fr6Sn379k1z+ylTpkgHDhyQ3Nzc5JOTk5Pen0d2TVwWcXFx4jmnt91nn30mRURESD169JCKFCki/fnnn9KtW7ckS0tLvT+H7Jjy5csnXblyRWKlSpVKd9tff/1VWr16tVKdcXR01PtzyOppzJgxko+Pj1S3bl0pf/780k8//SQFBARIuXLlUrl9kyZNpNDQUKl169ZSsWLFpH379klHjx7V+/PI6ilnzpySv7+/NH36dMnb21tq3Lix+JwZN25cmo/ZuXOnNGfOHKU6Y29vr/fnktXToEGDpGfPnklVq1YV76Nz585JW7ZsSXN7/nzx8/OTGjRoILY/ffq0tHHjRr0/j6yeXF1dpTdv3kgTJkwQnzXDhg2ToqKipKJFi6b5GP4eGzVqlFKdsbOz0/tzyc73lZ+fnxQeHp7udt9++630/PlzqXr16lLFihXF9xLHNHo6b/0XnKlNP/74o3Ts2DGlZfyh0qtXryzZ3lgnDw8PKSEhQQRnsmUc1PMbIK3H7Nq1S5o8ebLez10X019//SU+QE6cOKE2wOUAbtOmTfJ5W1tbKTg4WAQx+n4eWT21bdtWPLdt27ZpFODyl3b//v31ft7ZPd2+fVsaPHiw0jIOcLt27apy+4MHD0qLFi2Sz7u7u0vx8fFS+fLl9f5csnLq3bu3+PxUXDZx4kTp6tWraT6Gt2/ZsqXezz27pzt37kj9+vVTKiv+MZDW9teuXVP6YVCiRAnxGe7l5aX355KVU58+faT79+8rLeNy4fJJ6zHcKFWlShW9n7uupo0bN4rPHHUB7tu3b5ViF/4Bzo/RR/CPLgrZoGbNmnTp0iWlZfxXMi/Piu2NVbVq1SguLk78ZShz+fJl8Xeig4ODysdUqVKFqlevTvfu3aNnz57Rzz//nOa2xu7atWtUunRpUSbqpKwzsnI1tTrD+O+tNm3a0LBhw9Ruy39DV6pUiZo1a0aPHz8W3WBmzpxJ1tbWZGrq1q1Lq1evls/b2dmJ90ZYWJhGdYb/Un369KnJ1Znt27eLOqAoR44caZaLq6srFSlShHr06EHPnz+nu3fv0rfffptulwZjxV3h1q9fL+57enpSnz59RJc4VWxtbUU5KtYZri9cjvyZbGp1Rvac+HXnbk78Xjp37pzK7UuWLCm6dowcOVJ0t7t586boWmaqWrZsKerO1KlT093O29tbTIp1hmMZZ2dntd2nsgMC3GyQK1cuCgwMVFoWHBwsPlCyYntjxc8zKCgo1fO0tLRU2ReQ+1zyFw/3iWrevDn17NmTmjRpQmvXriVTxIFYaGioRtuaS51hu3fvpvPnz2u0LX/x8IcpB7fch27IkCHUu3dvWrRoEZkaDjQSEhLk8xMmTBBB66lTp1RunzNnTrOoM/xjLzIyUj6fL18++uabb9Lsh125cmWSJImuX79OX3zxBX333XeiL6Up9qfkOpOUlERLliwRfSm5cSGtvsbu7u7ih6E51JnY2FiKioqiEiVKiPcQ909fuXIl+fj4pFln+DH8Xvv8889p3rx59NNPP9FXX32l83PPbi4uLqIsBg0aRBEREWq/l5hineFy4vejPuoMAtxsYGVlJT4wFaWcz8z2xkrb58kfxhzkDh8+nN6+fStaNjlg6dq1K+XOnZvMmbnUGW1xKz+3yHFLAw++O3nyJI0fP17UG1NsxZXhH388UKpTp04UHR2daj3/iOTJ3OoM/3DmgUM8CDOtH8b844lbePnfIT8/P/r777/Fj011A2CNfaAZ/xBctWoVnTlzhvLkyaPyM4aZU53hzw+uCxUrVhTvqR9++EHldnv37hU/GNetWyfqDLcAL1261CTrzOLFi8XA7qNHj6rd1tDqDALcbMCtlPwmUcTz/Ms3K7Y3Vmk9T8a/mlPiN0XKvxX5L2dWoEABMmfmUme0lZiYSOHh4anqDP/dqupL3BQMHjxYtFD/73//E38HqsKtdvzvgDnVGf6rlIO306dP08CBA9PcjlvBU7ZMcZ3h+qLP0d/ZiesDP28O4Ph+69atU23Dn8m8zpzqjCwQ424qy5cvF0FuWv8ScItvyjpjat9LDRs2FN0TuMuOJmT/0CrWGX4POTo66qXOIMDNBtwX8rPPPlNaxn2ZFPueZmZ7Y8XPh//uKFq0qNLz5H5din8pyjRo0IACAgLEm0OmbNmyIoh58eIFmbOUdYb7jfHfjaZWZ7TFrftcNxT7T3Kd4QCGW3RNDQco/OXD/XGvXr2qVZ3h9xWnXDPFOsNdVbhllvubcj/J9FqQRowYkarfO9cZ7lsZHx9PpoIDDX4PcF9KGf5Xg5d//Pgx1fb8TwCnelKsM/yjgf+GNrU6M23aNNEKq4jfH6rKhf34448iDV3KOsPfZaakd+/e4vXm9wL/4Nm3b59o+ef7HPimxGnBOJBVrDP8vcTf2TyORh/0PjrP1KZKlSpJ0dHRUrt27SQrKytp+PDhYhR4jhw5smR7Y57++ecfaf/+/ZKLi4tUuHBh6fHjx2mm7+E0aZwGadmyZZKNjY1UoEABMap31apVen8e2TnNnTtXbRaFpk2bilG89evXl6ytraWZM2eK1HKcTUHf55+dWTjUZVHgFFkfPnyQpk2bJlKm8bZPnjyRZs2apffzz+pp0qRJ4jXPkyePRtvLRsxXrlxZjGhesWKFdPPmTb0/j6ye+HPi/fv30siRIzXanlOmRUZGiowuFhYWYmQ8P55TRen7uWT1xOkEOb0Vv5c4Ddry5ctFHeI0Waq2Hz9+vEj5xNkTOD0jp1M7cuSI3p9HVk+y7+A2bdqI+S+++EIKCQmRBgwYoHL7atWqSbGxsVKnTp3EPH8Of/z4UerYsaPen0tWTg4ODkpp0DijDWdE4Pv8vaPqMYsXLxaZkTjdGmdqOX78uLRu3Tp9PQf9F6IpTpx2hFM+cU7TBw8eiDeMbF3x4sXFm0dxWXrbm9LEX8ace5OfJ+dx5TcDf6nI1m/dulVMsvly5cqJtE+ck5CnNWvWmGR+YHUBruwDl+uObNno0aPFDyEuy+vXr0sVKlTQ+7nrI8DltGpLliyRz3/++eeiPPgLiz+MOT8s/3DU9/lndU5Kft35OXK9UJxkqcM6dOgg5hWDFw70uUz4y5kDHf6Rqe/nktXTH3/8IepJynK5d++efBu+r5h+8H//+5/43I2JiRHvqalTp+r9eWTH5OzsLIJc/nHMn7+cnlLx/cR1h3MGy+b5fcMNDPzZy2Vz+PBhydPTU+/PIzum9u3bi3Rx/Dw5Jy43NCmuDwwMVAp4u3TpIr148UK8l/iHY8rtTXFq3LhxqjRh/F7h9GGyef7hxCnFuBz582nHjh16y11v8ekOZBNO3cOjCBXx36c8EIb/NuWme3XbmyLuE8n9mFKSdUdI2b+J/0rjsjLlAQ6KdYA76yuWAc/zX0PcJzllGaRVlqaIBx2mLAO+shLXjZiYGKVt+a9XU/qLWdVniCr81zLXB37PcNmk/JuVH8vrTLVs+DNEVd9Z7k8q65/NXaW4jFJ+1prTe4k/U1J+//Dz56tNphz7IBukqJi1w1Txe0PV8+T3G7+3Ur5vzK3OODk5KdUP/r7iMkg59kE24CxlHdMlBLgAAAAAYFIwyAwAAAAATAoCXAAAAAAwKQhwAQAAAMCkIMAFAAAAAJOCABcAAAAATAoCXAAAAAAwKQhwAQBAibu7O+XJkwelAgBGCwEuAEA2BYnTp0+ny5cv05s3b+jBgwe0fPlyKlSokMGX9+3bt6lcuXLifqlSpSgwMFB+ERYAAGOAABcAIIsVKFCAbt68SXXr1qVx48ZRjRo1qGfPnuIqQNeuXRPrDT04l3n69CmVLl061dUFAQAMnd6vb4wJZYA6gDpgSnXg4MGD0vHjx1WuO3XqlPTrr7/K5/Plyydt2rRJevXqlXT58mVp8ODB8nXlypWTHj16JA0YMEBc7523Wb58ubjeuyaPr1ixonT//n1p9uzZ0vPnz6UpU6aI5a1atZIOHTokPXv2TPLx8ZE2b94seXp6inW8DxYaGiqNHz9eKlWqlBQYGCg5OjqK9QULFhTH4/3xOY0YMUKr88WEMkAdQB0g3ZQBChplgDqAOoA6kFV1wNvbW0pMTJQaNmyocn3evHnlAZ+lpaV0584d6ffff5eKFi0q1a9fXwSdo0aNEusrVaok9nXmzBmpfPnyUr169aSAgAAReGry+KpVq4pglQPSwoULi204CI2OjpY6dOggzqVu3brS69evpZ9//lk8JkeOHFJ4eLhY7+DgILZnTk5Okpubm/T27Vvpzz//lEqUKCG1aNFC8vPzk4YPH67R+WJCGaAOoA6Q7soAhY0yQB1AHUAdyKo6wEEfc3Z2Vrttx44dRXBpYWEhX9alSxfpzZs38oCRVa9eXb5+yZIl0r59+zR6vCzA5ZZc2XpbW1sRqCqeB7co7969Wz7PAW7jxo3FfcUAd+jQoWLf1tbW8m0HDhwo+fv7a3S+mFAGqAOoA6SjMrDWd/8IAABTYmtrK24TEhLky9q3b0+rVq2Sz/v7+1P58uWpYsWKIltBQECAfJ21tTXlyJGDnJ2d5cuePXsmvx8WFiY/hqaPf/Xqlfx+XFyc2KZ79+5iIFmZMmWoYcOGdPr0abXPjY/HfYgVn9uFCxfIy8uLPD091Z4vAICuIMAFAMhCPChLln2AsxGwv//+WwzUYr169aLvvvtO3Le3t6dLly5Rhw4dUu0nIiJCKShVZGFhodXjY2Ji5PcLFixIFy9eFEH2iRMnaNeuXfTx40elgWVp4cBWMbhlSUlJ4lYxiE3rfAEAdAUBLgBAFuJ0YJxBYfjw4TRw4ECxLD4+noKCglIFnhwM9+/fnyIjI5WCUE1l5PEDBgwQ51K1alWSJNFNjTp16qQUhMqWp/TkyRNq2rSp0rJKlSpReHi4CJhz5cql9XMAAMgOSBMGAJDFvvrqKxE0Ll26VJ4SjFtbu3btSpMmTSIfHx+xbPv27ZSYmEiLFy8WLaAuLi60ZMkSjboLZPTxsbGxogsDB6Mc1Pbr14/atWtHDg4O8m2io6PFNlZWVkqP3bRpk+iKMGXKFLGuaNGiItfvunXrUrXsAgDoEwJcAIAsdufOHdGyyXlvuTWX+6HyNGHCBPrll1+ofv36Yjtu+eTgsnbt2uI+t6xyP1duldVERh7/66+/0qNHj+jt27f04cMH6tKlC82cOZMqVKgg32bjxo20detWEaArCg4OFv2Je/ToIVqNuQvG4cOHRa5fAABDwv9Jqf4vCgAAsgRfBYxbTrm1VZttLC0tRd9YWfcGxi2tPEiMA1p1j+dWVm6JVXy8DLf4ctcJ7o6gajven6zbQ8pzYBy888UfFLszaHO+AADZCQEuAAAAAJgUdFEAAAAAAJOCABcAAAAATAoCXAAAAAAwKQhwAQAAAMCkIMAFAAAAAJOCABcAAAAATAoCXAAAAAAwKQhwAQAAAMCkIMAFAAAAAJOCABcAAAAATAoCXAAAAAAgU/J/DrmE1FBwuqIAAAAASUVORK5CYII=" }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } } ], "execution_count": 8 }, { "cell_type": "markdown", "id": "9446038a", "metadata": {}, "source": [ "## Compare Baseline and Selected-Feature Model\n", "\n", "The selected-feature estimator supports the usual sklearn prediction API, so it can be evaluated just like the baseline pipeline." ] }, { "cell_type": "code", "id": "295c928e", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:00.229259Z", "iopub.status.busy": "2026-06-20T05:29:00.229007Z", "iopub.status.idle": "2026-06-20T05:29:00.241349Z", "shell.execute_reply": "2026-06-20T05:29:00.240002Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:51.731988200Z", "start_time": "2026-06-20T18:45:51.711805200Z" } }, "source": [ "selector_metrics = evaluate(selector, X_test, y_test)\n", "pd.DataFrame([baseline_metrics, selector_metrics], index=[\"all_features\", \"selected_features\"])" ], "outputs": [ { "data": { "text/plain": [ " accuracy balanced_accuracy\n", "all_features 0.822222 0.822222\n", "selected_features 0.933333 0.933333" ], "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
accuracybalanced_accuracy
all_features0.8222220.822222
selected_features0.9333330.933333
\n", "
" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "execution_count": 9 }, { "cell_type": "code", "id": "b12462c5", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:00.244306Z", "iopub.status.busy": "2026-06-20T05:29:00.243846Z", "iopub.status.idle": "2026-06-20T05:29:00.276826Z", "shell.execute_reply": "2026-06-20T05:29:00.275585Z" }, "ExecuteTime": { "end_time": "2026-06-20T18:45:51.820447100Z", "start_time": "2026-06-20T18:45:51.732985500Z" } }, "source": [ "print(classification_report(y_test, selector.predict(X_test), target_names=iris.target_names))" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " setosa 1.00 1.00 1.00 15\n", " versicolor 0.88 0.93 0.90 15\n", " virginica 0.93 0.87 0.90 15\n", "\n", " accuracy 0.93 45\n", " macro avg 0.93 0.93 0.93 45\n", "weighted avg 0.93 0.93 0.93 45\n", "\n" ] } ], "execution_count": 10 }, { "cell_type": "markdown", "id": "8ffd2a1b", "metadata": {}, "source": [ "## Practical Notes\n", "\n", "- `max_features` is a useful way to make feature selection prefer compact solutions.\n", "- If many candidates are skipped as invalid, increase `max_features` or reduce mutation strength.\n", "- If diversity drops quickly, use `diversity_control`, `random_immigrants_fraction`, and `fitness_sharing` before simply increasing generations.\n", "- Always compare with an all-feature baseline. A smaller selected subset is only useful if quality remains acceptable." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.14" } }, "nbformat": 4, "nbformat_minor": 5 }