diff --git a/python-snippet/bubble_chart_optbinning.ipynb b/python-snippet/bubble_chart_optbinning.ipynb new file mode 100644 index 0000000..e9c6efb --- /dev/null +++ b/python-snippet/bubble_chart_optbinning.ipynb @@ -0,0 +1,432 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import roc_auc_score\n", + "\n", + "# Tải dữ liệu German Credit\n", + "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/statlog/german/german.data\"\n", + "column_names = [\"existing_account\", \"duration_month\", \"credit_history\", \"purpose\", \"credit_amount\",\n", + " \"savings_account\", \"employment_since\", \"installment_rate\", \"personal_status_sex\", \"other_debtors\",\n", + " \"present_residence\", \"property\", \"age\", \"other_installment_plans\", \"housing\", \"existing_credits\",\n", + " \"job\", \"people_liable\", \"telephone\", \"foreign_worker\", \"credit_risk\"]\n", + "\n", + "df = pd.read_csv(url, sep=\" \", header=None, names=column_names)\n", + "\n", + "# Chuyển đổi target thành nhị phân\n", + "df['credit_risk'] = df['credit_risk'].map({1: 0, 2: 1})\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.base import TransformerMixin, BaseEstimator\n", + "import logging\n", + "from optbinning import BinningProcess\n", + "import matplotlib.pyplot as plt\n", + "\n", + "class InformationValues(BaseEstimator, TransformerMixin):\n", + " def __init__(self, monotonic_trend='auto_asc_desc', max_n_bins=5, prebinning_method='cart', min_event_rate_diff=0.0002): \n", + " self.monotonic_trend = monotonic_trend \n", + " self.max_n_bins = max_n_bins\n", + " self.prebinning_method = prebinning_method\n", + " self.min_event_rate_diff = min_event_rate_diff\n", + " self.binning_process = None \n", + " self.t_iv = None\n", + " self.t_woe = None \n", + "\n", + " def fit(self, X, y): \n", + " self.feats = X.columns.tolist()\n", + " self.cat_feats = X.select_dtypes(include=['object']).columns.tolist() \n", + " # self.num_feats = list(set(self.feats) - set(self.cat_feats))\n", + " self.num_feats = [item for item in self.feats if item not in self.cat_feats]\n", + " logging.info('Processing Information Value, Total features {}. Categorical features {}. Numeric features {}'.format(len(self.feats), len(self.cat_feats), len(self.num_feats)))\n", + " # Set the binning fit parameters for each feature\n", + " _binning_fit_params = {}\n", + " for fs in self.feats:\n", + " _binning_fit_params[fs] = {'monotonic_trend':self.monotonic_trend,\n", + " 'max_n_bins': self.max_n_bins,\n", + " 'prebinning_method':self.prebinning_method,\n", + " 'min_event_rate_diff':self.min_event_rate_diff}\n", + " \n", + " # Initialize the BinningProcess with the specified variables and fit parameters \n", + " _binning_process = BinningProcess(variable_names = self.feats\n", + " ,categorical_variables = self.cat_feats \n", + " , binning_fit_params=_binning_fit_params)\n", + " \n", + " # Transform the training data using the BinningProcess\n", + " _binning_process.fit(X, y) \n", + " self.binning_process = _binning_process\n", + " \n", + " # Create a list to store woe tables and iv tables\n", + " t_iv, t_woe = [], []\n", + " for fs in self.binning_process.summary().name: \n", + " binning_table = self.binning_process.get_binned_variable(fs).binning_table \n", + " tbl = binning_table.build().assign(variable = fs)\n", + " # Get woe table\n", + " t_woe.append(tbl)\n", + " # Get iv table\n", + " tbl_iv = tbl[tbl.index == 'Totals'][['variable', 'IV']] \n", + " t_iv.append(tbl_iv)\n", + " \n", + " # Concatenate the list of woe tables and iv tables\n", + " self.t_woe = pd.concat(t_woe, axis=0)\n", + " self.t_iv = pd.concat(t_iv, axis=0) \n", + "\n", + " return self \n", + " \n", + " def transform(self, X):\n", + " X_woe = self.binning_process.transform(X)\n", + " return X_woe\n", + " \n", + " def get_feature_names_in(self):\n", + " return self.feats\n", + "\n", + " def get_feature_names_out(self):\n", + " return self.feats\n", + " \n", + " def get_table_woe(self):\n", + " return self.t_woe\n", + " \n", + " def get_table_iv(self):\n", + " return self.t_iv\n", + " \n", + " # New method to retrieve binning table for a specific feature\n", + " def get_binning_table(self, feature_name):\n", + " if feature_name in self.feats:\n", + " binning_table = self.binning_process.get_binned_variable(feature_name).binning_table\n", + " return binning_table.build()\n", + " else:\n", + " raise ValueError(f\"Feature '{feature_name}' not found in the data.\")\n", + "\n", + " def plot_bubble_feature(self, feature_name):\n", + " if feature_name not in self.feats:\n", + " raise ValueError(f\"Feature '{feature_name}' not found in the data.\")\n", + " \n", + " binning_table = self.get_binning_table(feature_name)\n", + " \n", + " # Extract necessary data for plotting\n", + " plot_data = binning_table[['Bin', 'Count', 'Event rate']].copy()\n", + " # Handle non-numeric and special bins correctly\n", + " def calculate_midpoint(bin_range):\n", + " try:\n", + " bounds = bin_range.strip('[]()').split(', ')\n", + " if bounds[0] == '-inf':\n", + " lower = float('-inf')\n", + " else:\n", + " lower = float(bounds[0])\n", + " if bounds[1] == 'inf':\n", + " upper = float('inf')\n", + " else:\n", + " upper = float(bounds[1])\n", + " return (lower + upper) / 2 if lower != float('-inf') and upper != float('inf') else lower if upper == float('inf') else upper\n", + " except:\n", + " return None # Return None for 'Special' or 'Missing' categories\n", + "\n", + " plot_data['MidPoint'] = plot_data['Bin'].apply(calculate_midpoint)\n", + " plot_data = plot_data.dropna(subset=['MidPoint']) # Remove rows where midpoint is None\n", + " plot_data['BubbleSize'] = plot_data['Count'] / plot_data['Count'].max() * 1000\n", + "\n", + " plt.figure(figsize=(10, 6))\n", + " plt.scatter(plot_data['MidPoint'], plot_data['Event rate'], s=plot_data['BubbleSize'], alpha=0.5, color='pink')\n", + " \n", + " for index, row in plot_data.iterrows():\n", + " plt.text(row['MidPoint'], row['Event rate'], f\"{row['Event rate'] * 100:.2f}%\", ha='center', va='center')\n", + "\n", + " plt.xlabel('Bin Mid-Point')\n", + " plt.ylabel('Event Rate')\n", + " plt.title(f'Bubble Plot of Event Rate by Bin for {feature_name}')\n", + " plt.grid(True)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROC AUC Score: 0.8022\n", + "Information Value Table\n", + " variable IV\n", + "Totals existing_account 0.587325\n", + "Totals duration_month 0.257173\n", + "Totals credit_history 0.368192\n", + "Totals purpose 0.229094\n", + "Totals credit_amount 0.182718\n", + "Totals savings_account 0.162927\n", + "Totals employment_since 0.066179\n", + "Totals installment_rate 0.011137\n", + "Totals personal_status_sex 0.045733\n", + "Totals other_debtors 0.008107\n", + "Totals present_residence 0.007464\n", + "Totals property 0.145759\n", + "Totals age 0.157060\n", + "Totals other_installment_plans 0.034371\n", + "Totals housing 0.110042\n", + "Totals existing_credits 0.016714\n", + "Totals job 0.009923\n", + "Totals people_liable 0.000045\n", + "Totals telephone 0.006171\n", + "Totals foreign_worker 0.000000\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "from optbinning import BinningProcess\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import roc_auc_score\n", + "\n", + "# Assuming you already have the 'df' data loaded\n", + "\n", + "# Initialize the custom transformer\n", + "iv_transformer = InformationValues(monotonic_trend='auto_asc_desc', max_n_bins=5, prebinning_method='cart')\n", + "\n", + "# Split the data\n", + "X = df.drop('credit_risk', axis=1)\n", + "y = df['credit_risk']\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n", + "\n", + "# Fit the transformer on the training data\n", + "iv_transformer.fit(X_train, y_train)\n", + "\n", + "# Transform both training and test data using WoE\n", + "X_train_woe = iv_transformer.transform(X_train)\n", + "X_test_woe = iv_transformer.transform(X_test)\n", + "\n", + "# Fit the logistic regression model\n", + "logreg = LogisticRegression(solver='liblinear')\n", + "logreg.fit(X_train_woe, y_train)\n", + "\n", + "# Predict and evaluate the model\n", + "y_pred_prob = logreg.predict_proba(X_test_woe)[:, 1]\n", + "roc_auc = roc_auc_score(y_test, y_pred_prob)\n", + "print(f\"ROC AUC Score: {roc_auc:.4f}\")\n", + "\n", + "# Get WoE and IV tables\n", + "woe_table = iv_transformer.get_table_woe()\n", + "iv_table = iv_transformer.get_table_iv()\n", + "\n", + "print(\"Information Value Table\")\n", + "print(iv_table)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "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", + "
BinCountCount (%)Non-eventEventEvent rateWoEIVJS
0(-inf, 735.50)360.0514292970.1944440.5672760.0145050.001789
1[735.50, 3913.50)4730.6757143521210.2558140.2137310.0294860.003679
2[3913.50, 7839.50)1290.18428683460.356589-0.2639110.0134730.001679
3[7839.50, inf)620.08857127350.564516-1.1136210.1252540.014895
4Special00.000000000.0000000.00.0000000.000000
5Missing00.000000000.0000000.00.0000000.000000
Totals7001.0000004912090.2985710.1827180.022042
\n", + "
" + ], + "text/plain": [ + " Bin Count Count (%) Non-event Event Event rate \\\n", + "0 (-inf, 735.50) 36 0.051429 29 7 0.194444 \n", + "1 [735.50, 3913.50) 473 0.675714 352 121 0.255814 \n", + "2 [3913.50, 7839.50) 129 0.184286 83 46 0.356589 \n", + "3 [7839.50, inf) 62 0.088571 27 35 0.564516 \n", + "4 Special 0 0.000000 0 0 0.000000 \n", + "5 Missing 0 0.000000 0 0 0.000000 \n", + "Totals 700 1.000000 491 209 0.298571 \n", + "\n", + " WoE IV JS \n", + "0 0.567276 0.014505 0.001789 \n", + "1 0.213731 0.029486 0.003679 \n", + "2 -0.263911 0.013473 0.001679 \n", + "3 -1.113621 0.125254 0.014895 \n", + "4 0.0 0.000000 0.000000 \n", + "5 0.0 0.000000 0.000000 \n", + "Totals 0.182718 0.022042 " + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "iv_transformer.get_binning_table('credit_amount')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1YAAAIjCAYAAAAAxIqtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB4rklEQVR4nO3dd3gU1dvG8XvTG4GQkEYLBKQKQZCISFFKABWwgiAlKioSEVAQLHRFURELRfFHUUCKCjYEIRIUiaBABCxIFRFIaKmQQnbeP/bNypIEEjYkC/l+rmsv3ZkzZ87ssxtyZ2bOmgzDMAQAAAAAuGxOZT0AAAAAALjaEawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAUy8CBA+Xj43PJdgcPHpTJZNLrr79+ybbjx4+XyWQqieEVS1xcnEwmk+Li4kp93xfz0UcfqX79+nJ1dVWlSpXKejgoRN779sSJE2U9FKv58+fLZDLp4MGDJdZnenq6HnnkEQUHB8tkMmnYsGEl1rejyfu5NX/+fOuysvr5BODqQ7ACrlF5v2Cd/wgMDNStt96qb775pqyHd0VdeOweHh667rrrFBMTo8TExBLZx6pVqzR+/PgS6et8f/75pwYOHKjw8HDNmTNH77//fqFt837hK+xx7NixEh9fcRX3dWrfvr3NMXh6eqpJkyaaPn26zGbzZY1h06ZNGj9+vJKTky9r+7J24Wvi5uamWrVq6dFHH9U///xzxff/8ssva/78+Ro8eLA++ugj9evX74rv09G9/PLLWrlyZVkPw2FdqZ+PgKNzKesBALiyJk6cqFq1askwDCUmJmr+/Pnq1q2bvvzyS91xxx1lPbwrKu/YMzMztXHjRs2aNUurVq3Srl275OXlZVffq1at0owZM0r8l4e4uDiZzWa99dZbqlOnTpG2mTVrVoFnER3hbNflvE7VqlXTlClTJEknTpzQ4sWLNXz4cB0/flwvvfRSscewadMmTZgwQQMHDnSI1+RynP+aZGdn6/fff9fs2bO1Zs0a/fHHH9b3c79+/dS7d2+5u7uX2L6/++473XTTTRo3blyJ9Xk1eeGFFzR69GibZS+//LLuvfde9ezZs2wG5eCu1M9HwNERrIBrXNeuXdWiRQvr84cfflhBQUH6+OOPr/lgdf6xP/LII/L399e0adP0+eef64EHHijj0RUsKSlJUvFC0b333quAgIArNKLSV7FiRT344IPW548//rjq16+vd955RxMnTpSzs3MZjq5sXPiaSFKtWrUUExOjH3/8UZ06dZIkOTs7l/jrk5SUpIYNG5ZYf+fOnZPZbJabm1uJ9WkYhjIzM+Xp6VlifeZxcXGRiwu/LgG4NC4FBMqZSpUqydPT0+YXhcLuNSrofoM8+/fvV1RUlLy9vRUaGqqJEyfKMIwC9/nmm2+qZs2a8vT0VLt27bRr164ijXXhwoVq3ry5PD09VblyZfXu3duuS59uu+02SdKBAwcu2m758uXW/QYEBOjBBx/Uv//+a10/cOBAzZgxQ5JsLtG6lJkzZ6pRo0Zyd3dXaGiohgwZYnN5WlhYmPWsQJUqVWQymez+i29iYqJcXFw0YcKEfOt2794tk8mkd99917osOTlZw4YNU/Xq1eXu7q46dero1VdftbkM7/z7595//32Fh4fL3d1dN954o37++Wdru8t9nS7k4eGhG2+8UWlpadbgKUk7duzQwIEDVbt2bXl4eCg4OFgPPfSQTp48aW0zfvx4jRw5UpIliOSN4fx7kOx9n504cUL333+/fH195e/vr6eeekqZmZnW9e3atVPTpk0L3LZevXqKiooq8r7OFxwcLEk2n+WC7rEKCwvTHXfcoY0bN6ply5by8PBQ7dq19eGHH160/7yfCwcOHNDXX3+d77VLSkqy/qHGw8NDTZs21YIFC2z6OP+9Mn36dOt75ffff7/ovhcuXKiWLVvKy8tLfn5+atu2rb799tt8x7RmzRq1aNFCnp6eeu+99yQV7T2c127gwIGqWLGiKlWqpAEDBhR4ueiF91iZTCZlZGRowYIF1tdk4MCBFz2e873++uu6+eab5e/vL09PTzVv3lyffPJJvnYmk0kxMTFavny5GjZsKE9PT7Vq1Uo7d+6UJL333nuqU6eOPDw81L59+wLvq7vUzzLJcqlp+/bt8207cOBAhYWFWZ+X9uceuBrxJxjgGpeSkqITJ07IMAwlJSXpnXfeUXp6er6/fhdHbm6uunTpoptuuklTp07V6tWrNW7cOJ07d04TJ060afvhhx8qLS1NQ4YMUWZmpt566y3ddttt2rlzp4KCggrdx0svvaQXX3xR999/vx555BEdP35c77zzjtq2bavt27df1iVd+/btkyT5+/sX2mb+/PmKjo7WjTfeqClTpigxMVFvvfWWfvzxR+t+H3vsMR05ckRr167VRx99VKR9jx8/XhMmTFDHjh01ePBg7d69W7NmzdLPP/+sH3/8Ua6urpo+fbo+/PBDrVixwnp5X5MmTS7Z96lTp/Itc3FxUaVKlRQUFKR27dpp2bJl+S7lWrp0qZydnXXfffdJks6cOaN27drp33//1WOPPaYaNWpo06ZNGjNmjI4eParp06fbbL948WKlpaXpsccek8lk0tSpU3X33Xdr//79cnV1vazXqTB5v9SdX/e1a9dq//79io6OVnBwsH777Te9//77+u233/TTTz/JZDLp7rvv1l9//aWPP/5Yb775pvXMXpUqVSSVzPvs/vvvV1hYmKZMmaKffvpJb7/9tk6fPm0NLv369dOgQYO0a9cuNW7c2Lrdzz//rL/++ksvvPDCJfeRm5trnSQjJydHf/zxh8aNG6c6deqodevWl9x+7969uvfee/Xwww9rwIABmjt3rgYOHKjmzZurUaNGBW7ToEEDffTRRxo+fLiqVaump59+WpLltTt79qzat2+vvXv3KiYmRrVq1dLy5cs1cOBAJScn66mnnrLpa968ecrMzNSjjz4qd3d3Va5cudCxTpgwQePHj9fNN9+siRMnys3NTZs3b9Z3332nzp07W9vt3r1bDzzwgB577DENGjRI9erVK/J72DAM9ejRQxs3btTjjz+uBg0aaMWKFRowYMAlX8uPPvpIjzzyiFq2bKlHH31UkhQeHn7J7fK89dZb6t69u/r27avs7GwtWbJE9913n7766ivdfvvtNm1/+OEHffHFFxoyZIgkacqUKbrjjjs0atQozZw5U0888YROnz6tqVOn6qGHHtJ3331n3bYoP8suR2l+7oGrjgHgmjRv3jxDUr6Hu7u7MX/+fJu269evNyQZ69evt1l+4MABQ5Ixb94867IBAwYYkownn3zSusxsNhu333674ebmZhw/ftxmW09PT+Pw4cPWtps3bzYkGcOHD7cuGzdunHH+j6ODBw8azs7OxksvvWQznp07dxouLi75lhd27OvWrTOOHz9u/PPPP8aSJUsMf39/m/FceNzZ2dlGYGCg0bhxY+Ps2bPW/r766itDkjF27FjrsiFDhhhF/RGalJRkuLm5GZ07dzZyc3Oty999911DkjF37tx8r0Xe63gxeW0LetSrV8/a7r333jMkGTt37rTZvmHDhsZtt91mfT5p0iTD29vb+Ouvv2zajR492nB2djYOHTpkGMZ/tfX39zdOnTplbff5558bkowvv/zSuqw4r5NhGEa7du2M+vXrG8ePHzeOHz9u/Pnnn8bIkSMNScbtt99u0/bMmTP5tv/4448NScb3339vXfbaa68ZkowDBw7YtLX3fZb3+nfv3t1m+RNPPGFIMn799VfDMAwjOTnZ8PDwMJ599lmbdkOHDjW8vb2N9PT0i+6nXbt2Bda4QYMGxv79+23a5r33zz/WmjVr5ntNkpKSDHd3d+Ppp5++6L7ztr/wtZ8+fbohyVi4cKF1WXZ2ttGqVSvDx8fHSE1NNQzjv/eKr6+vkZSUdMl97dmzx3BycjLuuusum8+KYVh+zlx4TKtXr7ZpU9T38MqVKw1JxtSpU61tzp07Z7Rp0ybfz7wLfz4ZhmF4e3sbAwYMuOTxFOTC9212drbRuHFjm8+iYRjWn9fn1zLvsxwcHGx9jQ3DMMaMGWNT9+L8LGvXrp3Rrl27fOMcMGCAUbNmTevzK/m5B64VXAoIXONmzJihtWvXau3atVq4cKFuvfVWPfLII/rss8/s6jcmJsb6/3mXrGRnZ2vdunU27Xr27KmqVatan7ds2VKRkZFatWpVoX1/9tlnMpvNuv/++3XixAnrIzg4WHXr1tX69euLNMaOHTuqSpUqql69unr37i0fHx+tWLHCZjzn++WXX5SUlKQnnnhCHh4e1uW333676tevr6+//rpI+73QunXrlJ2drWHDhsnJ6b8fu4MGDZKvr+9l95vn008/tdY47zFv3jzr+rvvvlsuLi5aunSpddmuXbv0+++/q1evXtZly5cvV5s2beTn52fzunfs2FG5ubn6/vvvbfbbq1cv+fn5WZ+3adNGkuUyUXv8+eefqlKliqpUqaL69evrtddeU/fu3fNdknr+/TSZmZk6ceKEbrrpJknStm3bLrmfknqf5Z1NyPPkk09KkvU9XrFiRfXo0UMff/yx9XLZ3NxcLV26VD179pS3t/cl9xEWFmat7TfffKPp06crJSVFXbt21fHjxy+5fcOGDa31kSxnnerVq3fZtVq1apWCg4Nt7lV0dXXV0KFDlZ6erg0bNti0v+eee6xnCS9m5cqVMpvNGjt2rM1nRVK+y8lq1aqV7zLKor6HV61aJRcXFw0ePNi6rbOzs7V2V9L579vTp08rJSVFbdq0KfA926FDB5vL8SIjIyVZXs8KFSrkW55Xzyv1s0y6cp974FrApYDANa5ly5Y2k1c88MADatasmWJiYnTHHXdc1g3kTk5Oql27ts2y6667TpLyXedft27dfNtfd911WrZsWaH979mzR4ZhFLitZPkFrihmzJih6667Ti4uLgoKClK9evXy/bJ2vr///luS5b6XC9WvX18bN24s0n6L2q+bm5tq165tXX+52rZte9HJKwICAtShQwctW7ZMkyZNkmS5DNDFxUV33323td2ePXu0Y8eOQn8BPv/+JkmqUaOGzfO8X7ZOnz59WceRJywsTHPmzJHZbNa+ffv00ksv6fjx4za/IEqWSyAnTJigJUuW5BtbSkrKJfdTUu+zC7cPDw+Xk5OTzWehf//+Wrp0qX744Qe1bdtW69atU2JiYpGnLvf29lbHjh2tz7t06aJbbrlFLVq00CuvvKI33njjottfWCvJUq/LrdXff/+tunXr5vs8NWjQwLr+fLVq1SpSv/v27ZOTk1ORJssoqM+ivof//vtvhYSE5JtNs6DPfkn76quvNHnyZCUkJCgrK8u6vKD7kC6sW8WKFSVJ1atXL3B5Xj2v1M+ygsZUUp974FpAsALKGScnJ91666166623tGfPHjVq1KjQG4tzc3NLeXQWZrNZJpNJ33zzTYEznBXlC4ql/KGyPOvdu7eio6OVkJCgiIgILVu2TB06dLAJZGazWZ06ddKoUaMK7CMvPOcpbPY5o5BJTIrqwhDRunVr3XDDDXruuef09ttvW5fff//92rRpk0aOHKmIiAj5+PjIbDarS5cuRfrOq5J6n12ooM9TVFSUgoKCtHDhQrVt21YLFy5UcHCwzXEWV/PmzVWxYsV8ZxILcqVqVVRXYra+gvos7nu4tP3www/q3r272rZtq5kzZyokJESurq6aN2+eFi9enK99YXUryXqaTKYCtyvs539Zv5cAR0awAsqhc+fOSZLS09Ml/fcXxwtnxCrsTIrZbNb+/fttfkn566+/JMnmshXJ8hfkC/3111/52p0vPDxchmGoVq1apfqLUM2aNSVZborPm0Ewz+7du63rpYJ/eS5Kv+ef6cvOztaBAwfs+uW6qHr27KnHHnvMejngX3/9pTFjxti0CQ8PV3p6eomOpyRmA2vSpIkefPBBvffee3rmmWdUo0YNnT59WrGxsZowYYLGjh1rbVvQ+62wMZTU+2zPnj02Z0/27t0rs9ls8x53dnZWnz59NH/+fL366qtauXKlBg0aZPfU6Lm5udbPcWmqWbOmduzYIbPZbHPW6s8//7Suvxzh4eEym836/fffFRERcVnbF+U9XLNmTcXGxio9Pd0mQO/evbtI+7nc9/Wnn34qDw8PrVmzxua7xs6/dLckFOdnmZ+fX4GX8dlzJp1ZAFFecY8VUM7k5OTo22+/lZubm/WynZo1a8rZ2TnfX75nzpxZaD/nT9FtGIbeffddubq6qkOHDjbtVq5caTO975YtW7R582Z17dq10L7vvvtuOTs7a8KECfn+CmoYhs102iWpRYsWCgwM1OzZs20u0fnmm2/0xx9/2MzYlXdfTEHTM1+oY8eOcnNz09tvv21zPP/73/+UkpKSbyawK6FSpUqKiorSsmXLtGTJErm5ueX7ctP7779f8fHxWrNmTb7tk5OTrYG8OIrzOl3MqFGjlJOTo2nTpkn676/mF74/Lpy58GJjKKn3Wd7U0nneeecdScr3Hu/Xr59Onz6txx57zO6ZOSVp/fr1Sk9PL3Qq9yupW7duOnbsmM19e+fOndM777wjHx8ftWvX7rL67dmzp5ycnDRx4sR8Zx2LckakqO/hbt266dy5c5o1a5Z1fW5urrV2l+Lt7X1Z72lnZ2eZTCabs0EHDx7UypUri93XxRTnZ1l4eLj+/PNPm3v1fv31V/3444+Xvf+S+twDVxvOWAHXuG+++cb6V+SkpCQtXrxYe/bs0ejRo+Xr6yvJcn3+fffdp3feeUcmk0nh4eH66quv8t23ksfDw0OrV6/WgAEDFBkZqW+++UZff/21nnvuuXz3NtSpU0e33HKLBg8erKysLE2fPl3+/v6FXqojWf6hnzx5ssaMGaODBw+qZ8+eqlChgg4cOKAVK1bo0Ucf1TPPPFNCr9B/XF1d9eqrryo6Olrt2rXTAw88YJ2iOCwsTMOHD7e2bd68uSRp6NChioqKkrOzs3r37l1gv1WqVNGYMWM0YcIEdenSRd27d9fu3bs1c+ZM3XjjjXb/gv3JJ58UeNlap06dbKa079Wrlx588EHNnDlTUVFR+aZbHjlypL744gvdcccd1qm4MzIytHPnTn3yySc6ePBgsb+IuDiv08U0bNhQ3bp10wcffKAXX3xR/v7+atu2raZOnaqcnBxVrVpV3377bYHfUZY3hueff169e/eWq6ur7rzzzhJ7nx04cEDdu3dXly5dFB8fr4ULF6pPnz75Ak+zZs3UuHFjLV++XA0aNNANN9xQ5ONPSUnRwoULJVkCTN50/Z6enho9enSR+ykpjz76qN577z0NHDhQW7duVVhYmD755BP9+OOPmj59us3ECsVRp04dPf/885o0aZLatGmju+++W+7u7vr5558VGhqqKVOmXHT7or6H77zzTrVu3VqjR4/WwYMH1bBhQ3322WdFujdPsryn1q1bp2nTpik0NFS1atWyTiBxMbfffrumTZumLl26qE+fPkpKStKMGTNUp04d7dixo0j7Lori/Cx76KGHNG3aNEVFRenhhx9WUlKSZs+erUaNGik1NfWy9l9Sn3vgqlPa0xACKB0FTbfu4eFhREREGLNmzbKZutgwDOP48ePGPffcY3h5eRl+fn7GY489ZuzatavA6da9vb2Nffv2GZ07dza8vLyMoKAgY9y4cTbTI+dNzfvaa68Zb7zxhlG9enXD3d3daNOmjXUa6jwFTWdsGIbx6aefGrfccovh7e1teHt7G/Xr1zeGDBli7N69u0jH/vPPP1+0XWHTzC9dutRo1qyZ4e7ublSuXNno27evzZTxhmGZmvnJJ580qlSpYphMpiJNLfzuu+8a9evXN1xdXY2goCBj8ODBxunTp23alNR06wUdV2pqquHp6ZlvmuzzpaWlGWPGjDHq1KljuLm5GQEBAcbNN99svP7660Z2drZhGLa1vZAkY9y4cdbnxX2d2rVrZzRq1KjAdXFxcTb9Hz582LjrrruMSpUqGRUrVjTuu+8+48iRI/nGYBiWabirVq1qODk55ZuO/HLfZ3mv/++//27ce++9RoUKFQw/Pz8jJibGZorr802dOtWQZLz88ssX7fvC1+T8uppMJqNy5cpG9+7dja1bt9q0LWy69QunS8/rt6Bpti9U2PaJiYlGdHS0ERAQYLi5uRnXX3+9zc8Kw7j4e+Vi5s6da/0M+vn5Ge3atTPWrl17yTEZRtHew4ZhGCdPnjT69etn+Pr6GhUrVjT69etnbN++vUjTrf/5559G27ZtrZ+n4ky9/r///c+oW7eu4e7ubtSvX9+YN29egfuQZAwZMsRmWWGvZ97PsuXLl9ssL8rPMsMwjIULFxq1a9c23NzcjIiICGPNmjWFTrd+JT73wLXCZBjcbQgAQGl46623NHz4cB08eLDAmfoAAFcvghUAAKXAMAw1bdpU/v7+Rf6OLADA1YN7rAAAuIIyMjL0xRdfaP369dq5c6c+//zzsh4SSlhubu4lv6jZx8fnsqfwB3B14IwVAABX0MGDB1WrVi1VqlRJTzzxhF566aWyHhJKWF6NL2bcuHEaP3586QwIQJkgWAEAANghMzNTGzduvGib2rVr23yPHYBrD8EKAAAAAOzEFwQDAAAAgJ2YvKIAZrNZR44cUYUKFWQymcp6OAAAAADKiGEYSktLU2hoqJycCj8vRbAqwJEjR1S9evWyHgYAAAAAB/HPP/+oWrVqha4nWBWgQoUKkiwvnq+vbxmPpnTk5OTo22+/VefOneXq6lrWwyn3qIfjoBaOg1o4DmrhOKiF46AWjqUk65Gamqrq1atbM0JhCFYFyLv8z9fXt1wFKy8vL/n6+vLDwAFQD8dBLRwHtXAc1MJxUAvHQS0cy5Wox6VuEWLyCgAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALCTS1kPAAAAAEA5ZxhSdo6UmiGdzZRycyUnJ8nNVargLXl7SiZTWY/yoghWAAAAAMpOZpZ0IllKPyOdy5WcTZYQZciy7HSq5OkuVa4o+fo4bMAiWAEAAAAoGxlnpaPHpcxsyd3V8rgwOOWaLeHr3yTLWa0AP4cMV9xjBQAAAKDIxo8fL5PJZPOoX7++TZv4+Hjddttt8vb2lq+vr9q2bauzZ8/adpSZZQlVWTmSt4fk6iKZTHpl1rsy1aqmYRPHWdo5O0meHmof3VemQH+ZnJys+3388cet3Z06dUp33nmnfHx8dOONN2r//v02uxsyZIjeeOONK/KaSAQrAAAAAMXUqFEjHT161PrYuHGjdV18fLy6dOmizp07a8uWLfr5558VExMjJ6fzoodhSCdOW85Ueblbz0D9/GuC3lu8SE3qN8i/U5NJg+7rraM/bNHRvw/p6NGjmjp1qnX1Sy+9pLS0NG3btk3t2rXTjBkzrOt++uknbd68WcOGDSvx1yIPlwICAAAAKBYXFxcFBwcXuG748OEaOnSoRo8ebV1Wr14920ZZ2VL6WZtL/9IzMtR32JOaM2WqJr/7VoF9e3l7K7iSn+RdQfKvZLPujz/+UO/evXXdddfp4Ycf1nvvvSdJysnJ0eOPP64PPvhAzs7Ol3nEl8YZKwAAAADFsmfPHoWGhqp27drq27evDh06JElKSkrS5s2bFRgYqJtvvllBQUFq166dzRktSZbZ/87lSi7/BZ0hY5/X7bd1UMdb2hS630VfrFBAm5Zq3CpSY0aP1pkzZ6zrmjZtqu+++07nzp3T2rVrFRYWJkmaOnWq2rdvrxYtWpTcC1AAzlgBAAAAKLLIyEjNnz9f9erV09GjRzVhwgS1adNGu3btst7XNH78eL3++uuKiIjQhx9+qA4dOmjXrl2qW7eupZMzZy33Tv3/2aolX36ubb/t1M+ff13ofvt076maVasptEoV7dj1m5596w3t/usvffbZZ5Kk0aNHa/DgwQoPD1fNmjUVExOjPXv2aMGCBYqPj9fjjz+ub7/9Vi1atNCcOXNUsWLFEn1dCFYAAAAAiqxr167W/2/SpIkiIyNVs2ZNLVu2TA0aWO6NeuyxxxQdHS1JatasmWJjYzV37lxNmTLFsmGuWXKyhKp/jhzRUxPGae1Hi+Xh7lHofh/t86Dlf8xmXR8WrpDGDdTh9q7at2+fwsPDVbFiRS1evFiS5fK/VatWaciQIXrttde0aNEi7d+/X7t379agQYM0ceLEEp/IgksBAQAAAFy2SpUq6brrrtPevXsVEhIiSWrYsKFNmwYNGlgvF5T03/dUSdq6a4eSTp7QDXd2lUudmnKpU1MbNv+kt+fPlUudmsrNzS1gryZFtrxRkrR3794CxxUbG6uKFSuqR48eiouLU8+ePeXq6qr77rtPcXFx9h52PpyxAgAAAHDZ0tPTtW/fPvXr109hYWEKDQ3V7t27bdr89ddfNme65OYqnc2SJHW4+RbtXL3Opn30qKdVv3a4nn38ifwTTvz/lwgn/LZLkqxh7nzHjx/X0qVLtXnzZklSbm6ucnJyJFnOZhUc1uxDsAIAAABQZM8884zuvPNO1axZU0eOHNG4cePk7OysBx54QCaTSSNHjtS4cePUtGlTRUREaMGCBfrzzz/1ySefWPvo0LeX7rqlnWIefkQVfHzUuJ7t92B5e3rK38/Punzf3we1+POV6nbrbfJ399SOI4c0fNIEtW3bVk2aNMk3xqefflo9evRQ1apVJUmtW7fWRx99pM6dO+v9999X69atS/x1IVgBAAAAKLLDhw/rgQce0MmTJ1WlShXdcsst+umnn1SlShVJ0rBhw5SZmanhw4fr1KlTatq0qdauXavw8HBrH/v+PqgTTZtJ2TmSh/sl9+nm6qZ1P/6g6fM+UMaZM6pevbruuecevfDCC/narlmzRvv27dOYMWOsy2JiYvTLL78oMjJSLVu21Lhx40rglbBFsAIAAABQZEuWLLlkm9GjR9t8j9WFDh48KJ1KkY6ekHLOSa62sSRuySc2z6uHhmrDx59IZzIlX2+perB1RsELRUVF6bbbbtOqVausy7y8vLRs2bJLjtseTF4BAAAAoPT5+Ur+vpazVtk5kmEU3jbXbAlVXh5SSEChoaosccYKAAAAQOkzmaSgAMnJ2XL26kym5QuDXV3+f9ZAwxKosnMsz329pOAqkqtrWY+8QAQrAAAAAGXDZJKq+Fku70vNkFLSpMxsy1TsJklOTlLFClJFH8nb0/LcQRGsAAAAAJQdk8kygYWHu+RfUcrKkcxmy3JXl//OYDk4ghUAAAAAx+DsLHk5X7qdA3Lcc2kAAAAAcJUgWAEAAACAnco8WM2YMUNhYWHy8PBQZGSktmzZUmjb+fPny2Qy2Tw8PDxs2gwcODBfmy5dulzpwwAAAABQjpXpPVZLly7ViBEjNHv2bEVGRmr69OmKiorS7t27FRgYWOA2vr6+2r17t/W5qYAb2bp06aJ58+ZZn7u7X/rbnAEAAADgcpXpGatp06Zp0KBBio6OVsOGDTV79mx5eXlp7ty5hW5jMpkUHBxsfQQFBeVr4+7ubtPGz8/vSh4GAAAAgHKuzM5YZWdna+vWrRozZox1mZOTkzp27Kj4+PhCt0tPT1fNmjVlNpt1ww036OWXX1ajRo1s2sTFxSkwMFB+fn667bbbNHnyZPn7+xfaZ1ZWlrKysqzPU1NTJUk5OTnKycm53EO8quQdZ3k5XkdHPRwHtXAc1MJxUAvHQS0cB7VwLCVZj6L2YTIMw7B7b5fhyJEjqlq1qjZt2qRWrVpZl48aNUobNmzQ5s2b820THx+vPXv2qEmTJkpJSdHrr7+u77//Xr/99puqVasmSVqyZIm8vLxUq1Yt7du3T88995x8fHwUHx8vZ+eCp24cP368JkyYkG/54sWL5eXlVUJHDAAAAOBqc+bMGfXp00cpKSny9fUttN1VFawulJOTowYNGuiBBx7QpEmTCmyzf/9+hYeHa926derQoUOBbQo6Y1W9enWdOHHioi/etSQnJ0dr165Vp06d5OrqWtbDKfeoh+OgFo6DWjgOauE4qIXjoBaOpSTrkZqaqoCAgEsGqzK7FDAgIEDOzs5KTEy0WZ6YmKjg4OAi9eHq6qpmzZpp7969hbapXbu2AgICtHfv3kKDlbu7e4ETXLi6upa7D0Z5PGZHRj0cB7VwHNTCcVALx0EtHAe1cCwlUY+ibl9mk1e4ubmpefPmio2NtS4zm82KjY21OYN1Mbm5udq5c6dCQkIKbXP48GGdPHnyom0AAAAAwB5lOivgiBEjNGfOHC1YsEB//PGHBg8erIyMDEVHR0uS+vfvbzO5xcSJE/Xtt99q//792rZtmx588EH9/fffeuSRRyRZJrYYOXKkfvrpJx08eFCxsbHq0aOH6tSpo6ioqDI5RgAAAADXvjL9HqtevXrp+PHjGjt2rI4dO6aIiAitXr3aOoX6oUOH5OT0X/Y7ffq0Bg0apGPHjsnPz0/NmzfXpk2b1LBhQ0mSs7OzduzYoQULFig5OVmhoaHq3LmzJk2axHdZAQAAALhiyjRYSVJMTIxiYmIKXBcXF2fz/M0339Sbb75ZaF+enp5as2ZNSQ4PAAAAAC6pTC8FBAAAAIBrAcEKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7FTmwWrGjBkKCwuTh4eHIiMjtWXLlkLbzp8/XyaTyebh4eFh08YwDI0dO1YhISHy9PRUx44dtWfPnit9GAAAAADKsTINVkuXLtWIESM0btw4bdu2TU2bNlVUVJSSkpIK3cbX11dHjx61Pv7++2+b9VOnTtXbb7+t2bNna/PmzfL29lZUVJQyMzOv9OEAAAAAKKfKNFhNmzZNgwYNUnR0tBo2bKjZs2fLy8tLc+fOLXQbk8mk4OBg6yMoKMi6zjAMTZ8+XS+88IJ69OihJk2a6MMPP9SRI0e0cuXKUjgiAAAAAOWRS1ntODs7W1u3btWYMWOsy5ycnNSxY0fFx8cXul16erpq1qwps9msG264QS+//LIaNWokSTpw4ICOHTumjh07WttXrFhRkZGRio+PV+/evQvsMysrS1lZWdbnqampkqScnBzl5OTYdZxXi7zjLC/H6+ioh+OgFo6DWjgOauE4qIXjoBaOpSTrUdQ+yixYnThxQrm5uTZnnCQpKChIf/75Z4Hb1KtXT3PnzlWTJk2UkpKi119/XTfffLN+++03VatWTceOHbP2cWGfeesKMmXKFE2YMCHf8m+//VZeXl7FPbSr2tq1a8t6CDgP9XAc1MJxUAvHQS0cB7VwHNTCsZREPc6cOVOkdmUWrC5Hq1at1KpVK+vzm2++WQ0aNNB7772nSZMmXXa/Y8aM0YgRI6zPU1NTVb16dXXu3Fm+vr52jflqkZOTo7Vr16pTp05ydXUt6+GUe9TDcVALx0EtHAe1cBzUwnFQC8dSkvXIu5rtUsosWAUEBMjZ2VmJiYk2yxMTExUcHFykPlxdXdWsWTPt3btXkqzbJSYmKiQkxKbPiIiIQvtxd3eXu7t7gf2Xtw9GeTxmR0Y9HAe1cBzUwnFQC8dBLRwHtXAsJVGPom5fZpNXuLm5qXnz5oqNjbUuM5vNio2NtTkrdTG5ubnauXOnNUTVqlVLwcHBNn2mpqZq8+bNRe4TAAAAAIqrTC8FHDFihAYMGKAWLVqoZcuWmj59ujIyMhQdHS1J6t+/v6pWraopU6ZIkiZOnKibbrpJderUUXJysl577TX9/fffeuSRRyRZZgwcNmyYJk+erLp166pWrVp68cUXFRoaqp49e5bVYQIAAAC4xpVpsOrVq5eOHz+usWPH6tixY4qIiNDq1autk08cOnRITk7/nVQ7ffq0Bg0apGPHjsnPz0/NmzfXpk2b1LBhQ2ubUaNGKSMjQ48++qiSk5N1yy23aPXq1fm+SBgAAAAASkqZT14RExOjmJiYAtfFxcXZPH/zzTf15ptvXrQ/k8mkiRMnauLEiSU1RAAAAAC4qDL9gmAAAAAAuBYQrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOZR6sZsyYobCwMHl4eCgyMlJbtmwp0nZLliyRyWRSz549bZYPHDhQJpPJ5tGlS5crMHIAAAAAsCjTYLV06VKNGDFC48aN07Zt29S0aVNFRUUpKSnpotsdPHhQzzzzjNq0aVPg+i5duujo0aPWx8cff3wlhg8AAAAAkso4WE2bNk2DBg1SdHS0GjZsqNmzZ8vLy0tz584tdJvc3Fz17dtXEyZMUO3atQts4+7uruDgYOvDz8/vSh0CAAAAAMilrHacnZ2trVu3asyYMdZlTk5O6tixo+Lj4wvdbuLEiQoMDNTDDz+sH374ocA2cXFxCgwMlJ+fn2677TZNnjxZ/v7+hfaZlZWlrKws6/PU1FRJUk5OjnJycop7aFelvOMsL8fr6KiH46AWjoNaOA5q4TioheOgFo6lJOtR1D5MhmEYdu/tMhw5ckRVq1bVpk2b1KpVK+vyUaNGacOGDdq8eXO+bTZu3KjevXsrISFBAQEBGjhwoJKTk7Vy5UprmyVLlsjLy0u1atXSvn379Nxzz8nHx0fx8fFydnYucCzjx4/XhAkT8i1fvHixvLy87D9YAAAAAFelM2fOqE+fPkpJSZGvr2+h7crsjFVxpaWlqV+/fpozZ44CAgIKbde7d2/r/19//fVq0qSJwsPDFRcXpw4dOhS4zZgxYzRixAjr89TUVFWvXl2dO3e+6It3LcnJydHatWvVqVMnubq6lvVwyj3q4TioheOgFo6DWjgOauE4qIVjKcl65F3NdillFqwCAgLk7OysxMREm+WJiYkKDg7O137fvn06ePCg7rzzTusys9ksSXJxcdHu3bsVHh6eb7vatWsrICBAe/fuLTRYubu7y93dPd9yV1fXcvfBKI/H7Mioh+OgFo6DWjgOauE4qIXjoBaOpSTqUdTty2zyCjc3NzVv3lyxsbHWZWazWbGxsTaXBuapX7++du7cqYSEBOuje/fuuvXWW5WQkKDq1asXuJ/Dhw/r5MmTCgkJuWLHAgAAAKB8K9NLAUeMGKEBAwaoRYsWatmypaZPn66MjAxFR0dLkvr376+qVatqypQp8vDwUOPGjW22r1SpkiRZl6enp2vChAm65557FBwcrH379mnUqFGqU6eOoqKiSvXYAAAAAJQfZRqsevXqpePHj2vs2LE6duyYIiIitHr1agUFBUmSDh06JCenop9Uc3Z21o4dO7RgwQIlJycrNDRUnTt31qRJkwq81A8AAAAASkKZT14RExOjmJiYAtfFxcVddNv58+fbPPf09NSaNWtKaGQAAAAAUDRl+gXBAAAAAHAtIFgBAAAAgJ0IVgAAAABgJ4IVAAAAANiJYAUAAAAAdiJYAQAAAICdCFYAAAAAYCeCFQAAAADYiWAFAAAAAHYiWAEAAACAnQhWAAAAAGAnghUAAAAA2IlgBQAAAAB2IlgBAAAAgJ0IVgAAAABgJ4IVAAAAANiJYAUAAAAAdiJYAQAAAICdCFYAAAAAYCeCFQAAAADYiWAFAAAAAHYiWAEAAACAnQhWAAAAAGAnghUAAAAA2IlgBQAAAAB2IlgBAAAAgJ0IVgAAAABgJ4IVAAAAANiJYAUAAAAAdiJYAQAAAICdCFYAAAAAYCeCFQAAAADYiWAFAAAAAHYiWAEAAACAnQhWAAAAAGAnghUAAAAA2OmygtW5c+e0bt06vffee0pLS5MkHTlyROnp6SU6OAAAAAC4GrgUd4O///5bXbp00aFDh5SVlaVOnTqpQoUKevXVV5WVlaXZs2dfiXECAAAAgMMq9hmrp556Si1atNDp06fl6elpXX7XXXcpNja2RAcHAAAAAFeDYp+x+uGHH7Rp0ya5ubnZLA8LC9O///5bYgMDAAAAgKtFsc9Ymc1m5ebm5lt++PBhVahQoUQGBQAAAABXk2IHq86dO2v69OnW5yaTSenp6Ro3bpy6detWkmMDAAAAgKtCsS8FfOONNxQVFaWGDRsqMzNTffr00Z49exQQEKCPP/74SowRAAAAABxasYNVtWrV9Ouvv2rp0qX69ddflZ6erocfflh9+/a1mcwCAAAAAMqLYger77//XjfffLP69u2rvn37WpefO3dO33//vdq2bVuiAwQAAAAAR1fse6xuvfVWnTp1Kt/ylJQU3XrrrSUyKAAAAAC4mhQ7WBmGIZPJlG/5yZMn5e3tXewBzJgxQ2FhYfLw8FBkZKS2bNlSpO2WLFkik8mknj175hvf2LFjFRISIk9PT3Xs2FF79uwp9rgAAAAAoKiKfCng3XffLckyC+DAgQPl7u5uXZebm6sdO3bo5ptvLtbOly5dqhEjRmj27NmKjIzU9OnTFRUVpd27dyswMLDQ7Q4ePKhnnnlGbdq0ybdu6tSpevvtt7VgwQLVqlVLL774oqKiovT777/Lw8OjWOMDAAAAgKIocrCqWLGiJMsZoQoVKthMVOHm5qabbrpJgwYNKtbOp02bpkGDBik6OlqSNHv2bH399deaO3euRo8eXeA2ubm56tu3ryZMmKAffvhBycnJ1nWGYWj69Ol64YUX1KNHD0nShx9+qKCgIK1cuVK9e/cusM+srCxlZWVZn6empkqScnJylJOTU6xjulrlHWd5OV5HRz0cB7VwHNTCcVALx0EtHAe1cCwlWY+i9mEyDMMoTscTJkzQM888c1mX/Z0vOztbXl5e+uSTT2wu5xswYICSk5P1+eefF7jduHHjtGPHDq1YsUIDBw5UcnKyVq5cKUnav3+/wsPDtX37dkVERFi3adeunSIiIvTWW28V2Of48eM1YcKEfMsXL14sLy+vyz5GAAAAAFe3M2fOqE+fPkpJSZGvr2+h7Yo9K+C4cePsGlieEydOKDc3V0FBQTbLg4KC9Oeffxa4zcaNG/W///1PCQkJBa4/duyYtY8L+8xbV5AxY8ZoxIgR1uepqamqXr26OnfufNEX71qSk5OjtWvXqlOnTnJ1dS3r4ZR71MNxUAvHQS0cB7VwHNTCcVALx1KS9ci7mu1Sih2sJOmTTz7RsmXLdOjQIWVnZ9us27Zt2+V0eUlpaWnq16+f5syZo4CAgBLt293d3eaesTyurq7l7oNRHo/ZkVEPx0EtHAe1cBzUwnFQC8dBLRxLSdSjqNsXe1bAt99+W9HR0QoKCtL27dvVsmVL+fv7a//+/eratWuR+wkICJCzs7MSExNtlicmJio4ODhf+3379ungwYO688475eLiIhcXF3344Yf64osv5OLion379lm3K2qfAAAAAFASih2sZs6cqffff1/vvPOO3NzcNGrUKK1du1ZDhw5VSkpKkftxc3NT8+bNFRsba11mNpsVGxurVq1a5Wtfv3597dy5UwkJCdZH9+7ddeuttyohIUHVq1dXrVq1FBwcbNNnamqqNm/eXGCfAAAAAFASin0p4KFDh6zTqnt6eiotLU2S1K9fP91000169913i9zXiBEjNGDAALVo0UItW7bU9OnTlZGRYZ0lsH///qpataqmTJkiDw8PNW7c2Gb7SpUqSZLN8mHDhmny5MmqW7eudbr10NDQfN93BQAAAAAlpdjBKjg4WKdOnVLNmjVVo0YN/fTTT2ratKkOHDigYk4wqF69eun48eMaO3asjh07poiICK1evdo6+cShQ4fk5FS8k2qjRo1SRkaGHn30USUnJ+uWW27R6tWr+Q4rAAAAAFdMsYPVbbfdpi+++ELNmjVTdHS0hg8frk8++US//PKL9UuEiyMmJkYxMTEFrouLi7votvPnz8+3zGQyaeLEiZo4cWKxxwIAAAAAl6PYwer999+X2WyWJA0ZMkT+/v7atGmTunfvrscee6zEBwgAAAAAjq7YwcrJycnm8rzevXurd+/ekqR///1XVatWLbnRAQAAAMBVoNizAhbk2LFjevLJJ1W3bt2S6A4AAAAAripFDlanT5/WAw88oICAAIWGhurtt9+W2WzW2LFjVbt2bf3888+aN2/elRwrAAAAADikIl8KOHr0aG3atEkDBw7UmjVrNHz4cK1evVpOTk767rvvdNNNN13JcQIAAACAwyryGatvvvlG8+bN0+uvv64vv/xShmEoIiJCX331FaEKAAAAQLlW5GB15MgRNWjQQJIUFhYmDw8PPfjgg1dsYAAAAABwtShysDIMQy4u/1056OzsLE9PzysyKAAAAAC4mhT5HivDMNShQwdruDp79qzuvPNOubm52bTbtm1byY4QAAAAABxckYPVuHHjbJ736NGjxAcDAAAAAFejyw5WAAAAAACLEvmCYAAAAAAozwhWAAAAAGAnghUAAAAA2IlgBQAAAAB2Knaw+vDDD5WVlZVveXZ2tj788MMSGRQAAAAAXE2KHayio6OVkpKSb3laWpqio6NLZFAAAAAAcDUpdrAyDEMmkynf8sOHD6tixYolMigAAAAAuJoU+XusmjVrJpPJJJPJpA4dOsjF5b9Nc3NzdeDAAXXp0uWKDBIAAAAAHFmRg1XPnj0lSQkJCYqKipKPj491nZubm8LCwnTPPfeU+AABAAAAwNEVOViNGzdOkhQWFqZevXrJw8Pjig0KAAAAAK4mRQ5WeQYMGCDJMgtgUlKSzGazzfoaNWqUzMgAAAAA4CpR7GC1Z88ePfTQQ9q0aZPN8rxJLXJzc0tscAAAAABwNSh2sBo4cKBcXFz01VdfKSQkpMAZAgEAAACgPCl2sEpISNDWrVtVv379KzEeAAAAALjqFPt7rBo2bKgTJ05cibEAAAAAwFWp2MHq1Vdf1ahRoxQXF6eTJ08qNTXV5gEAAAAA5U2xLwXs2LGjJKlDhw42y5m8AgAAAEB5VexgtX79+isxDgAAAAC4ahU7WLVr1+5KjAMAAKB8Mgwp55yUnSPl/v/3gzo7SW6ukquLxAzMwFWh2MFKkn744Qe999572r9/v5YvX66qVavqo48+Uq1atXTLLbeU9BgBAACuPTk5UuoZKSXt/0PVBbdTODtbwlWlClIFb0vIAuCwij15xaeffqqoqCh5enpq27ZtysrKkiSlpKTo5ZdfLvEBAgAAXFPMZulUinTgiHTsuJSVLbk4SV4ekren5eHlYTlrlZUtHTkuHfjXso1hlPXoARSi2MFq8uTJmj17tubMmSNXV1fr8tatW2vbtm0lOjgAAIBryrlz0r9J0tHjloDl5SF5uksuF1zyZzJZzlB5ukveHpa2R49L/yZa+gDgcIp9Tnn37t1q27ZtvuUVK1ZUcnJySYwJAADg2nMu1xKq0s5Inm6WS/2KwmSSPNwslwomp0tmQwoNlFyKuD2AUlHsM1bBwcHau3dvvuUbN25U7dq1S2RQAAAA1xTDkJJOWkKVl3vRQ9X5nJ0t26ZmSEmnuCwQcDDFDlaDBg3SU089pc2bN8tkMunIkSNatGiRnnnmGQ0ePPhKjBEAAODqlpohJadZzjw5FfvXr/84OUkerlJyqpSWUXLjA2C3Yn+yR48erT59+qhDhw5KT09X27Zt9cgjj+ixxx7Tk08+eSXGCAAA4BBmzZqlJk2ayNfXV76+vmrVqpW++eYb6/r27dvLZDLZPB5/7DHpZLJkUqGX7/2xd4+6PxKtik0ayLthXd3Y43Yd+vdfmzbx27bqtj73y7tJA/m2bKq2HTvobIYlXGVlZalfv37y9fXVddddp3Xr1tls+9prr/F7GnCFFfseK5PJpOeff14jR47U3r17lZ6eroYNG8rHx+dKjA8AAMBhVKtWTa+88orq1q0rwzC0YMEC9ejRQ9u3b1ejRo0kWa7umThxonUbr1xDSjljOVtVgH1/H9Qt992lh+/vrQnDn5avj49+++svebi7W9vEb9uqLgMf1JjBQ/TO+ElyMTnp15075JSZI0n64IMPtHXrVsXHx+ubb75Rnz59lJiYKJPJpAMHDmjOnDn65ZdfruArA6DYwWrhwoW6++675eXlpYYNG16JMQEAADikO++80+b5Sy+9pFmzZumnn36yBisvLy8FBwf/1+joccv9UIVcAvj861PVrf1tmjrmBeuy8JphNm2GTxqvoQMe0ujBMdZl9UKrKeec5buv/vzzT3Xv3l2NGjVS7dq1NXLkSJ04cUJVqlTR4MGD9eqrr8rX19eeQwdwCcW+FHD48OEKDAxUnz59tGrVKuVe+GV2AAAA5UBubq6WLFmijIwMtWrVyrp80aJFCggIUOPGjTVm9GidOZVs+U6qApjNZn29PlbX1aqtqP59FdiiqSJ73qGV3662tkk6cUKbE7Yr0N9fN9/TQ0EtItSu1z3amLBNyrR8n2iTJk20ceNGnT17VmvWrFFISIgCAgK0aNEieXh46K677rqirwWAywhWR48e1ZIlS2QymXT//fcrJCREQ4YM0aZNm67E+AAAABzKzp075ePjI3d3dz3++ONasWKF9SqePn36aOHChVq/fr3GjBmjjxYu1IPDnyx0FsCkkyeUnpGhV2bPUJd27fXth4t1V1QX3f34IG34KV6StP+fvyVJ49+apkG9+2j1goW6ofH16hDdT3v2WGZqHjhwoJo2baqGDRvqpZde0rJly3T69GmNHTtW77zzjl544QXVqVNHUVFR+veCe7cAlIxiXwro4uKiO+64Q3fccYfOnDmjFStWaPHixbr11ltVrVo17du370qMEwAAwCHUq1dPCQkJSklJ0SeffKIBAwZow4YNatiwoR599FFru+uvv14hAVXUoUuU9h06pPDw/F9LYzabJUk9OnXW8IcHSZIiGjbSpq1bNXvxQrW7qZXMZsu06o/1eVDR9/WSJDVr1FixP27U/E+Xq/WdXeXq6qoZM2bY9B0dHa2hQ4dq+/btWrlypX799VdNnTpVQ4cO1aeffnpFXhugPLNjvk/LNcRRUVHq2rWr6tatq4MHD5bQsAAAAByTm5ub6tSpo+bNm2vKlClq2rSp3nrrrQLbRkZGSpL2HjpQ4PoAv8pycXFRwzrX2SxvUKeODh2xnFkKCQyUJDWsU9e2Te1w/XPsSIH9rl+/Xr/99ptiYmIUFxenbt26ydvbW/fff7/i4uKKfKwAiu6ygtWZM2e0aNEidevWTVWrVtX06dN111136bfffivp8QEAADg0s9msrKysAtcl7NwhSQrxDyhwvZubm25s0lS799te8fPXgf2qWbWqJCmsWnWFBgVp9/79tm0OHlCNqtXy9ZmZmakhQ4bovffek7Ozs3Jzc5WTY5k9MCcnh/vjgSuk2JcC9u7dW1999ZW8vLx0//3368UXX7S5YRMAAOBaNWbMGHXt2lU1atRQWlqaFi9erLi4OK1Zs0b79u3T4sWL1a1bN/n7+2vHjh0aPny42kbepCZ16ln7qN+hnaaMGq27orpKkkY++rh6PfmE2raM1K2tbtbqDXH6Mnad4j5eLsnyVTcjHx2scdPfUNMGDRTRsJEWfPqJ/ty/Tx/Pfl+7T5+wGeOkSZPUrVs3NWvWTJLUunVrjRw5UtHR0Xr33XfVunXrUnq1gPKl2GesnJ2dtWzZMh09elTvvvuu3aFqxowZCgsLk4eHhyIjI7Vly5ZC23722Wdq0aKFKlWqJG9vb0VEROijjz6yaTNw4MB8X8zXpUsXu8YIAAAgSUlJSerfv7/q1aunDh066Oeff9aaNWvUqVMnubm5ad26dercubPq16+vp59+Wvfcc4++XLJMMhuWKdcl7d6/TylpadY+74rqqtmTp2jq+7N0fZeO+mDpx/p05vu65caW1jbDHnpEYwYP0fDJE9S0W2fFbtqote/PV3j9+jbj27Vrl5YtW6YJEyZYl9177726/fbb1aZNG+3YsaPQyxYB2KfYZ6wWLVpUYjtfunSpRowYodmzZysyMlLTp09XVFSUdu/ercD/v574fJUrV9bzzz+v+vXry83NTV999ZWio6MVGBioqKgoa7suXbpo3rx51ufu533BHgAAwOX63//+V+i66tWra8OGDflX5ORI+/+Vcs5Jbq4yDhzO1+Sh+3vroft7X3TfowfH/Pc9Vtn/f2mfj5dNm8aNG2vPnj02y5ycnDRz5kzNnDnzov0DsE+Rz1h169ZNKSkp1uevvPKKkpOTrc9PnjxZ7C8MnjZtmgYNGqTo6Gg1bNhQs2fPlpeXl+bOnVtg+/bt2+uuu+5SgwYNFB4erqeeesr6vQ3nc3d3V3BwsPXh5+dXrHEBAACUGFdXqVIFKfuc9ayVXcyGpa+KFSTXYv+NHMAVUuRP45o1a2xuzHz55Zd1//33q1KlSpKkc+fOaffu3UXecXZ2trZu3aoxY8ZYlzk5Oaljx46Kj4+/5PaGYei7777T7t279eqrr9qsi4uLU2BgoPz8/HTbbbdp8uTJ8vf3L7SvrKwsm2NLTU2VZLnBM+9mz2vd+Te1ouxRD8dBLRwHtXAc1OIy+HpJKelS+hnJ010ymS6vH8OQzmZJHu6Srze1cCDUwrGUZD2K2ofJMIr2pxMnJycdO3bMeolehQoV9Ouvv6p2bct3MiQmJio0NLTIM80cOXJEVatW1aZNm2zu0xo1apQ2bNigzZs3F7hdSkqKqlatqqysLDk7O2vmzJl66KGHrOuXLFkiLy8v1apVS/v27dNzzz0nHx8fxcfHy7mQL+cbP368zbXIeRYvXiwvL68CtgAAAABQHpw5c0Z9+vRRSkqKfH19C2131Z0/rlChghISEpSenq7Y2FiNGDFCtWvXVvv27SVZZi3Mc/3116tJkyYKDw9XXFycOnToUGCfY8aM0YgRI6zPU1NTVb16dXXu3PmiL961JCcnR2vXrlWnTp3k6upa1sMp96iH46AWjoNaOA5qYYf0M9Kxk9K5HMtZJ6ci3pVhNkuZWZKLqxTsL/3/vVXUwnFQC8dSkvXIu5rtUoocrPJm2Ltw2eUKCAiQs7OzEhMTbZYnJiYqODi40O2cnJxUp04dSVJERIT++OMPTZkyxRqsLlS7dm0FBARo7969hQYrd3f3Aie4cHV1LXcfjPJ4zI6MejgOauE4qIXjoBaXwa+iJVAlnbKELCcnyc1Vci4kYOWaLRNVmM2SbwUpsLLk6ZGvGbVwHNTCsZREPYq6fZGDlWEYGjhwoDWAZGZm6vHHH5e3t7ckFfrFeIVxc3NT8+bNFRsbq549e0qyfMFebGysYmJiitzPxb6UT5IOHz6skydPKiQkpFjjAwAAuCI8PaTqwVJymuWRmfXfpBZ5Z7DMhiTDci+Wh7tl8otKFYp+hgtAqStysBowYIDN8wcffDBfm/79+xdr5yNGjNCAAQPUokULtWzZUtOnT1dGRoaio6Ot/VWtWlVTpkyRJE2ZMkUtWrRQeHi4srKytGrVKn300UeaNWuWJCk9PV0TJkzQPffco+DgYO3bt0+jRo1SnTp1bKZjBwAAKFNOTlLlipawdCZTysqRsrKkc+cs611cJHd3ycPNMtkFgQpweEUOVud/L1RJ6dWrl44fP66xY8fq2LFjioiI0OrVqxUUFCRJOnTokJzO+0GSkZGhJ554QocPH5anp6fq16+vhQsXqlevXpIsX168Y8cOLViwQMnJyQoNDVXnzp01adIkvssKAAA4Hicny/1SPmU9EAD2KvPJK2JiYgq99C8uLs7m+eTJkzV58uRC+/L09NSaNWtKcngAAAAAcEmcVwYAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE5lHqxmzJihsLAweXh4KDIyUlu2bCm07WeffaYWLVqoUqVK8vb2VkREhD766CObNoZhaOzYsQoJCZGnp6c6duyoPXv2XOnDAAAAAFCOlWmwWrp0qUaMGKFx48Zp27Ztatq0qaKiopSUlFRg+8qVK+v5559XfHy8duzYoejoaEVHR2vNmjXWNlOnTtXbb7+t2bNna/PmzfL29lZUVJQyMzNL67AAAAAAlDNlGqymTZumQYMGKTo6Wg0bNtTs2bPl5eWluXPnFti+ffv2uuuuu9SgQQOFh4frqaeeUpMmTbRx40ZJlrNV06dP1wsvvKAePXqoSZMm+vDDD3XkyBGtXLmyFI8MAAAAQHniUlY7zs7O1tatWzVmzBjrMicnJ3Xs2FHx8fGX3N4wDH333XfavXu3Xn31VUnSgQMHdOzYMXXs2NHarmLFioqMjFR8fLx69+5dYF9ZWVnKysqyPk9NTZUk5eTkKCcn57KO72qTd5zl5XgdHfVwHNTCcVALx0EtHAe1cBzUwrGUZD2K2keZBasTJ04oNzdXQUFBNsuDgoL0559/FrpdSkqKqlatqqysLDk7O2vmzJnq1KmTJOnYsWPWPi7sM29dQaZMmaIJEybkW/7tt9/Ky8uryMd0LVi7dm1ZDwHnoR6Og1o4DmrhOKiF46AWjoNaOJaSqMeZM2eK1K7MgtXlqlChghISEpSenq7Y2FiNGDFCtWvXVvv27S+7zzFjxmjEiBHW56mpqapevbo6d+4sX1/fEhi148vJydHatWvVqVMnubq6lvVwyj3q4TioheOgFo6DWjgOauE4qIVjKcl65F3NdillFqwCAgLk7OysxMREm+WJiYkKDg4udDsnJyfVqVNHkhQREaE//vhDU6ZMUfv27a3bJSYmKiQkxKbPiIiIQvt0d3eXu7t7vuWurq7l7oNRHo/ZkVEPx0EtHAe1cBzUwnFQC8dBLRxLSdSjqNuX2eQVbm5uat68uWJjY63LzGazYmNj1apVqyL3YzabrfdH1apVS8HBwTZ9pqamavPmzcXqEwAAAACKo0wvBRwxYoQGDBigFi1aqGXLlpo+fboyMjIUHR0tSerfv7+qVq2qKVOmSLLcC9WiRQuFh4crKytLq1at0kcffaRZs2ZJkkwmk4YNG6bJkyerbt26qlWrll588UWFhoaqZ8+eZXWYAAAAAK5xZRqsevXqpePHj2vs2LE6duyYIiIitHr1auvkE4cOHZKT038n1TIyMvTEE0/o8OHD8vT0VP369bVw4UL16tXL2mbUqFHKyMjQo48+quTkZN1yyy1avXq1PDw8Sv34AAAAAJQPZT55RUxMjGJiYgpcFxcXZ/N88uTJmjx58kX7M5lMmjhxoiZOnFhSQwQAAACAiyrTLwgGAAAAgGsBwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOLmU9AABlzDCk3FwpK0fKOSeZzZZlJpPl4eIsublaHiZTWY8WAADAIRGsgPLIbJYyzloeZzOl7HOWcGUY/9/AJMn4r72zk+TsInm6S14eUgUvydW1LEYOAADgkAhWQHmSc05Ky5CS06TMLEuQcnaSnJ0lVzfJqYCrgw1DyjVbgldqupSSJh13kXy9JV8fS9DiTBYAACjnCFZAeWA2S6dSLI/sc5Yw5e5m+e+l5F0O6OJseW4YloB2KkU6nSr5eEuBfpKH+5U9BgAAAAdGsAKudWezpKSTUvoZSzjytvMMk8n03z1X53KltHTL2a+ASlKlCgWf9QIAALjGEayAa5VhWM4qnThtCUAe7kU7Q1UcLs6Ss4dl4oujx6X0s1KwvyV0AQAAlCMEK+BaZBhS0inpZLIlTF3J+6BMJsnDzXIfVmq6dO6cVDXQcqkhAABAOcE1O8C1Ji9UnTgtubpYAk5pTC7h7GS5zPBspnQ4UcrKvvL7BAAAcBAEK+BaYhiWQHUi2XI5nmspn5Q2mSxnxzKzpH+TpJyc0t0/AABAGSFYAdeS9LOWUOXqXPqhKk9euDqTKSWeOu+7sQAAAK5dBCvgWnEuVzr+/0GmrCePyLvvKjVdSkkv27EAAACUAoIVcC3IuwTwTKbjfJ+Ui7MlYJ04JWVzSSAAALi2EayAa8GZTMuX9bq7Sk6lMFFFUXm4SZk5ltAHAABwDSNYAdeClDTLdOdldV9VYUwmS9hLzWCWQAAAcE0jWAFXu+wcKS1DcnOwUJXHxdly/1dqRlmPBAAA4IohWAFXu7QMKSfX8c5W5TGZLOEq76waAADANYhgBVzNDENKTpNcnErnS4Avl5uLlJUjZZwt65EAAABcEQQr4GqWnSPlnJNcHPRsVR4nJ0kG91kBAIBrFsEKuMpMmTJFN954oypUqKDAalXVc8ij2v33AZs27XvfK1OtajaPx58ffdF+Bz4zPN82XQb0tWnz1/796jHoIQXccL18r6+vW+67S+vjf7SuP5V8Wnc+PFA+ja5Ts9ujtP23Xf9tbDJpyDPD9cYbb9j/IgAAADgYghVwldmwYYOGDBmin376SWuXf6acnBx17t9XGWfO2LQb1LuPjm7ZZn1MHf38Jfvu0q69zTYfvz3DZv0dDw/Qudxz+m7RUm39YpWa1m+oOx4eqGPHkyRJL737jtIy0rXty9Vqf1MrDRozyrrtT7t2aPO2bRo2dGgJvAoAAACOxcGvHwJwodWrV//35N9EzX95qgLbRGrrzh1qG3mTdZWXp6eCqwQWq293N/dCtzlx6pT2HDyg/736upo0aChJeuXZMZq5cIF27d6t4CqB+mPfHvW+s4euq11bjz7QV+9/vEiSlJOTo8fHv6APJrwk51yz5FrMgwYAAHBwnLECrmY5uUrJSJckVa5UyWbVos9XKOCG69U4qoPGTJ2iM2cvPXFE3E/xCmzRVPVua6vBL4zRydP/fbGvv5+f6tUO14effaKMM2d07tw5vbd4oQL9A9T8+uslSU0bNNR3m37UuXPntOb7DWpSv4Ekaep7s9Q+spVaNLqemQEBAMA1iTNWwFXMfO6chk2ZrNYtblTjevWty/t076maVaspNChIO/78Q8+++rJ279+nz2Z/UGhfXdq1191RXVWrenXtO/S3nnvtVXUd+KDiP/tCzs7OMplMWrfwY/V87BFVaFxPTk5OCvQP0OoFC+VXsZIkafTjQzT4xTEKb9daYdWq6X+vvq49B/ZrwafLFf/p53p8/Av69uef1OLGGzVnzhxVrFjxSr9EAAAApYJgBVzFhox7Xrv2/KWNn6ywWf5onwet/399/QYKCQxSh769tO/vgwqvGVZgX73v7GGzTZP6DRTerrXifopXh9a3yDAMDRn7ggL9/fXDss/k6eGhD5Z+rDsfGaifP/9aIYFBqujrq8Vv2d6XdVuf+/XamBe06PMV2n/4H+3elqBBw5/SxIkTmcgCAABcM7gUELhKxcTE6Kv1sVq/YJGqhYRetG1kRDNJ0t6DB4vcf+0aNRVQubL2/m3Z5rtNP+qr79Zpydsz1brFjbqh8fWaOelleXp4aMGnywvsY97ypark66senaMU91O8enboJFc3N913332Ki4sr8lgAAAAcHWesgKuMYRh68skntWLFCsUt+US1AoIuuU3C779JkkICiz6ZxeGjR3Ty9GmF/P9kFnn3aDk52f49xsnkJLPZyLf98ZMnNfHt6dq4/DNJUm5urnJyz0lOTsrJyVFubm6RxwIAAODoyvyM1YwZMxQWFiYPDw9FRkZqy5YthbadM2eO2rRpIz8/P/n5+aljx4752g8cOFAmk8nm0aVLlyt9GECpGTJkiBYuXKjFixergn9lHUtK0rHjSTqbaQk++/4+qElvT9fWnTt08PA/+mLtt+r/9DC1bRlpnc1Pkup3aKcVa76RJKVnZGjky5P00/atOnj4H8X+uFE9Hn1YdWqGKaptO0lSqxuay69iRQ14Zph+/f13/bV/v0a+PEkHDv+j22/tkG+cwyaN09OPPKqqwSGSpNbNbtBHX3yuP/bt1fvvv6/WrVtf6ZcKAACg1JRpsFq6dKlGjBihcePGadu2bWratKmioqKUlJRUYPu4uDg98MADWr9+veLj41W9enV17txZ//77r027Ll266OjRo9bHxx9/XBqHA5SKWbNmKSUlRe3bt1dI4wYKufVmhbS8QUu/+lKS5ObqpnU//qDO/fuofof2evrlibqnS1d9+cF8m35279+nlLQ0SZKzs5N2/Pmnug96SNfd1lYPP/uMmje+Xj8s+0zu7u6SpIDKlbV6/kKlZ5zRbX3vV4se3bTxl5/1+fv/U9OGDW36XrMhTnsPHtQT/QZYl8U80E+1w2oq8uZWys7O1rhx467gqwQAAFC6yvRSwGnTpmnQoEGKjo6WJM2ePVtff/215s6dq9GjR+drv2jRIpvnH3zwgT799FPFxsaqf//+1uXu7u4KDg6+soMHyohhnHfZXWa2dOCw5OoiuThLkqqHhmrD0k8v3c+Bw9b/9/Tw1JoPF12ktUWLJk2L1C6qXXtFtWtvs8zLzV3L5s6XAv0vuT0AAMDVpsyCVXZ2trZu3aoxY8ZYlzk5Oaljx46Kj48vUh9nzpxRTk6OKleubLM8Li5OgYGB8vPz02233abJkyfL37/wX+aysrKUlZVlfZ6amirJ8qWmOTk5xTmsq1becZaX43V0Ra6HyZCcTFJWtmRyK4WRXSbDkAyz5OwkXWXvMT4bjoNaOA5q4TioheOgFo6lJOtR1D5Mhs2fv0vPkSNHVLVqVW3atEmtWrWyLh81apQ2bNigzZs3X7KPJ554QmvWrNFvv/0mDw8PSdKSJUvk5eWlWrVqad++fXruuefk4+Oj+Ph4OTs7F9jP+PHjNWHChHzLFy9eLC8vr8s8QgAAAABXuzNnzqhPnz5KSUmRr69voe2u2lkBX3nlFS1ZskRxcXHWUCVJvXv3tv7/9ddfryZNmig8PFxxcXHq0CH/DfaSNGbMGI0YMcL6PDU11Xr/1sVevGtJTk6O1q5dq06dOsnV1bWsh1PuFaseWdnS30ctZ4NcHfAjbRjSmUzJv5IUWPmSzR0Nnw3HQS0cB7VwHNTCcVALx1KS9ci7mu1Syuy3sICAADk7OysxMdFmeWJi4iXvj3r99df1yiuvaN26dWrSpMlF29auXVsBAQHau3dvocHK3d3deoP++VxdXcvdB6M8HrMjK1I9XFykij5SSobkUfBZ2TJ17pzk6ipVrmT571WKz4bjoBaOg1o4DmrhOKiFYymJehR1+zKbFdDNzU3NmzdXbGysdZnZbFZsbKzNpYEXmjp1qiZNmqTVq1erRYsWl9zP4cOHdfLkSYWEhJTIuAGHYzJJFStIJknnHOy7oQxDysyRfLwkDwe+BwwAAMBOZTrd+ogRIzRnzhwtWLBAf/zxhwYPHqyMjAzrLIH9+/e3mdzi1Vdf1Ysvvqi5c+cqLCxMx44d07Fjx5Seni5JSk9P18iRI/XTTz/p4MGDio2NVY8ePVSnTh1FRUWVyTECpcLHyxKuMrMtYcZRZOdYLk+s4mcJgAAAANeoMr0ho1evXjp+/LjGjh2rY8eOKSIiQqtXr1ZQUJAk6dChQ3Jy+i/7zZo1S9nZ2br33ntt+hk3bpzGjx8vZ2dn7dixQwsWLFBycrJCQ0PVuXNnTZo0qcBL/YBrhslkCS9nMy3hytMB3u+5ZssZtOAAycMBxgMAAHAFlfmd7jExMYqJiSlwXVxcnM3zgwcPXrQvT09PrVmzpoRGBlxl3FylAD/pSJLlviaXMvx4G4Z0Nkvy9Zb8yscEMAAAoHwr00sBAZSwij6WIJOVI+WW0f1WhiGdybLcUxVYWXLixwwAALj28RsPcC0xmaQg///utyrtySzyQpWrixRahUsAAQBAuVHmlwICKGFOTlJIgCVkJadKhmvpfL+V2bDc4+XmKoUGSl6eV36fAAAADoJgBVyLnJ0t4crZJJ1Kk3JyJU+3KzczX845y+WHXh6W/Xp6XHobAACAawjBCrhWOTlJQQGSt5eUdErKyJTcXSUX55ILWGZDysz6b1ZC/0qW/gEAAMoZghVwLTOZpArelunXj5+WktMsZ5ZcXSQ3l8sPWOdyLd9RZRiWs1OBlSVvT76rCgAAlFsEK6A8cHGxfJ9UxQpSWoaUki6dybQEIRdnydnJcoarsGBkNiyzDOZ9N5WzkyVIVapg+XJiZ85SAQCA8o1gBZQXJpPlHigvD8m/opR2xhKyMrOk7HOS2XyxjSUXJ8uZLj/f/86CcYYKAABAEsEKKJ9c/j8g+flaAlVWjpSdbQlYhmFZZjL9d0bLzVVydyvZ+7MAAACuIQQroLxzcrKcffLkO6cAAAAuF18QDAAAAAB2IlgBAAAAgJ0IVgAAAABgJ4IVAAAAANiJYAUAAAAAdiJYAQAAAICdCFYAAAAAYCeCFQAAAADYiWAFAAAAAHYiWAEAAACAnQhWAAAAAGAnghUAAAAA2IlgBQAAAAB2IlgBAAAAgJ0IVgAAAABgJ4IVAAAAANiJYAUAAAAAdiJYAQAAAICdCFYAAAAAYCeCFQAAAADYiWAFAAAAAHYiWAEAAACAnQhWAAAAAGAnghUAAAAA2IlgBQAAAAB2IlgBAAAAgJ0IVgAAAABgJ4IVAAAAANiJYAUAAAAAdiJYAQAAAICdCFYAAAAAYCeCFQAAAADYiWAFAAAAAHYiWAEAAACAnQhWAAAAAGAnghUAAAAA2KnMg9WMGTMUFhYmDw8PRUZGasuWLYW2nTNnjtq0aSM/Pz/5+fmpY8eO+dobhqGxY8cqJCREnp6e6tixo/bs2XOlDwMAAABAOVamwWrp0qUaMWKExo0bp23btqlp06aKiopSUlJSge3j4uL0wAMPaP369YqPj1f16tXVuXNn/fvvv9Y2U6dO1dtvv63Zs2dr8+bN8vb2VlRUlDIzM0vrsAAAAACUMy5lufNp06Zp0KBBio6OliTNnj1bX3/9tebOnavRo0fna79o0SKb5x988IE+/fRTxcbGqn///jIMQ9OnT9cLL7ygHj16SJI+/PBDBQUFaeXKlerdu3eB48jKylJWVpb1eWpqqiQpJydHOTk5JXKsl80wLP81ma7obvKOs8yPF5KohyOhFo6DWjgOauE4qIXjoBaOpSTrUdQ+TIaR95t76crOzpaXl5c++eQT9ezZ07p8wIABSk5O1ueff37JPtLS0hQYGKjly5frjjvu0P79+xUeHq7t27crIiLC2q5du3aKiIjQW2+9VWA/48eP14QJE/ItX7x4sby8vIp9bAAAAACuDWfOnFGfPn2UkpIiX1/fQtuV2RmrEydOKDc3V0FBQTbLg4KC9Oeffxapj2effVahoaHq2LGjJOnYsWPWPi7sM29dQcaMGaMRI0ZYn6emplovM7zYiydJP/zwg9544w1t375dR48e1fLly61nyyQpMTFRzz33nNatW6fk5GS1adNGb775purWrVtwh1nZ0rGT0lnLpYtL16xSv5HDdeetHfTpWzMkVzcpsLJU4b/AN2TIEM2ZM0evv/66hg4daukmK0uPPfaYvvzySwUFBemdd95Rhw4drNu88cYb+ueffzR9+nRJliS+du1aderUSa6urhc9Zlx51MNxUAvHQS0cB7VwHNTCcVALx1KS9ci7mu1SyvRSQHu88sorWrJkieLi4uTh4WFXX+7u7nJ3d8+33NXV9ZKFyMrKUrNmzfTII4/o7rvvlouLi3UbwzB03333ydXVVZ9//rl8fX01bdo0de3aVb///ru8vb1tO8vOkRJPWcKVt6cOHvlXo994VW1ujJSTi4tcfbylzCwp6ZTk6iJV8NaKFSu0ZcsWhYaGytnZ2brv2bNna/v27YqPj9c333yj/v37KzExUSaTSQcOHNDcuXP1yy+/5Du+ohwzSg/1cBzUwnFQC8dBLRwHtXAc1MKxlEQ9irp9mU1eERAQIGdnZyUmJtosT0xMVHBw8EW3ff311/XKK6/o22+/VZMmTazL87a7nD4vV9euXTV58mTddddd+dbt2bNHP/30k2bNmqUbb7xR9erV06xZs3T27Fl9/PHH+Ts7cdpypsrLQ7mGob7DntSEYU+rdo0alvUmk+ThLpkNKemU/v3nHz355JNatGhRvoL/8ccf6t69uxo1aqQhQ4bo+PHjOnHihCRp8ODBevXVVy95Ng4AAABA0ZRZsHJzc1Pz5s0VGxtrXWY2mxUbG6tWrVoVut3UqVM1adIkrV69Wi1atLBZV6tWLQUHB9v0mZqaqs2bN1+0zyslb0KM88+oOTk5yd3dXRs3brRtnJ0jpWVIbq6SyaSJb7+pQH9/PdzrAdt2JpPk4SrzmUz16/ugRo4cqUaNGuXbd9OmTbVx40adPXtWa9asUUhIiAICArRo0SJ5eHgUGAQBAAAAXJ4yvRRwxIgRGjBggFq0aKGWLVtq+vTpysjIsM4S2L9/f1WtWlVTpkyRJL366qsaO3asFi9erLCwMOt9Uz4+PvLx8ZHJZNKwYcM0efJk1a1bV7Vq1dKLL76o0NBQmwkySkv9+vVVo0YNjRkzRu+99568vb315ptv6vDhwzp69Kht44yz0rlcyctDG3/eov8tW6KEr78tuGMnJ736v/fkYjJZ76m60EMPPaQdO3aoYcOGCggI0LJly3T69GmNHTtWcXFxeuGFF7RkyRKFh4dr7ty5CgwMLOGjBwAAAMqPMg1WvXr10vHjxzV27FgdO3ZMERERWr16tXXyiUOHDsnJ6b+TarNmzVJ2drbuvfdem37GjRun8ePHS5JGjRqljIwMPfroo0pOTtYtt9yi1atX230f1uVwdXXVZ599pocffliVK1eWs7OzOnbsqK5duyrfZIy5ZklSWkaG+o14SnOmTFVA5coF9rt15w69tXCBtq1aI1Mh07C7urpqxowZNsuio6M1dOhQbd++XStXrtSvv/6qqVOnaujQoVqyZIn9BwwAAACUU2U+eUVMTIxiYmIKXBcXF2fz/ODBg5fsz2QyaeLEiZo4cWIJjM5+zZs3V0JCglJSUpSdna0qVaooMjIy32WM+v98tO/Q3zp4+B/d+Ui0dZXZbAldLnVqanfsBv3w8xYlnTqpGje3tLbJzc3V008/renTpxf4Oq1fv16//fabPvjgA40cOVLdunWTt7e37r//fr377rslftwAAABAeVLmwaq8qFixoiTLhBa//PKLJk2aZNvA3U0ymVQ/rJZ2rl5ns+qFN15TWka63ho7QdVDQtWv593q2OxGyb+iVNnSb1RUlPr162e9jPJ8mZmZGjJkiBYtWiRnZ2fl5uZaz5jl5OQoNzf3ChwxAAAAUH4QrOyUnp6uvXv3Wp8fOHBACQkJqly5smrUqKHly5erSpUqqlGjhnbu3KmnnnpKPXv2VOfOna3b9O/fX1VDQzXlsRh5ZGapcb36Nvuo9P+z9+Ut969QQf4NGki1qloCmSyX/gUHB6tevXr5xjhp0iR169ZNzZo1kyS1bt1aI0eOVHR0tN599121bt26ZF8UAAAAoJwhWNnpl19+0a233mp9nvdFwwMGDND8+fN19OhRjRgxQomJiQoJCVH//v314osv2vRhvZesckXp3yTLDIFuhcyXn5srZZ2znK36/1B1Mbt27dKyZcuUkJBgXXbvvfcqLi5Obdq0Ub169bR48eLiHzgAAAAAK4KVndq3b59/IorzDB06tNCZ+/JY7yUzDCnnnHT8tJSRKbm7Ss5Omv/6m5bJLc5mSWazVKmCFOhv00dh9581btxYe/bssVnm5OSkmTNnaubMmdZlOTk5Fx0jAAAAgMIRrByJyST5V5Lc3KTkVMsU7Fnm/9Z5uFtCVaUKklOZfQUZAAAAgAsQrByNyST5eksVvKTMbCknRzIkuThLnu4EKgAAAMABEawclclkCVKe7mU9EgAAAACXwOkPAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE4EKwAAAACwE8EKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATi5lPQBHZBiGJCk1NbWMR1J6cnJydObMGaWmpsrV1bWsh1PuUQ/HQS0cB7VwHNTCcVALx0EtHEtJ1iMvE+RlhMIQrAqQlpYmSapevXoZjwQAAACAI0hLS1PFihULXW8yLhW9yiGz2awjR46oQoUKMplMZT2cUpGamqrq1avrn3/+ka+vb1kPp9yjHo6DWjgOauE4qIXjoBaOg1o4lpKsh2EYSktLU2hoqJycCr+TijNWBXByclK1atXKehhlwtfXlx8GDoR6OA5q4TioheOgFo6DWjgOauFYSqoeFztTlYfJKwAAAADATgQrAAAAALATwQqSJHd3d40bN07u7u5lPRSIejgSauE4qIXjoBaOg1o4DmrhWMqiHkxeAQAAAAB24owVAAAAANiJYAUAAAAAdiJYAQAAAICdCFYAAAAAYCeC1TXk+++/15133qnQ0FCZTCatXLnSZr1hGBo7dqxCQkLk6empjh07as+ePTZtTp06pb59+8rX11eVKlXSww8/rPT0dJs2O3bsUJs2beTh4aHq1atr6tSpV/rQrjpTpkzRjTfeqAoVKigwMFA9e/bU7t27bdpkZmZqyJAh8vf3l4+Pj+655x4lJibatDl06JBuv/12eXl5KTAwUCNHjtS5c+ds2sTFxemGG26Qu7u76tSpo/nz51/pw7uqzJo1S02aNLF+QWCrVq30zTffWNdTh7LzyiuvyGQyadiwYdZl1KP0jB8/XiaTyeZRv35963pqUbr+/fdfPfjgg/L395enp6euv/56/fLLL9b1/BteOsLCwvJ9Lkwmk4YMGSKJz0Vpys3N1YsvvqhatWrJ09NT4eHhmjRpks6fd8/hPhcGrhmrVq0ynn/+eeOzzz4zJBkrVqywWf/KK68YFStWNFauXGn8+uuvRvfu3Y1atWoZZ8+etbbp0qWL0bRpU+Onn34yfvjhB6NOnTrGAw88YF2fkpJiBAUFGX379jV27dplfPzxx4anp6fx3nvvldZhXhWioqKMefPmGbt27TISEhKMbt26GTVq1DDS09OtbR5//HGjevXqRmxsrPHLL78YN910k3HzzTdb1587d85o3Lix0bFjR2P79u3GqlWrjICAAGPMmDHWNvv37ze8vLyMESNGGL///rvxzjvvGM7Ozsbq1atL9Xgd2RdffGF8/fXXxl9//WXs3r3beO655wxXV1dj165dhmFQh7KyZcsWIywszGjSpInx1FNPWZdTj9Izbtw4o1GjRsbRo0etj+PHj1vXU4vSc+rUKaNmzZrGwIEDjc2bNxv79+831qxZY+zdu9fahn/DS0dSUpLNZ2Lt2rWGJGP9+vWGYfC5KE0vvfSS4e/vb3z11VfGgQMHjOXLlxs+Pj7GW2+9ZW3jaJ8LgtU16sJgZTabjeDgYOO1116zLktOTjbc3d2Njz/+2DAMw/j9998NScbPP/9sbfPNN98YJpPJ+Pfffw3DMIyZM2cafn5+RlZWlrXNs88+a9SrV+8KH9HVLSkpyZBkbNiwwTAMy2vv6upqLF++3Nrmjz/+MCQZ8fHxhmFYgrKTk5Nx7Ngxa5tZs2YZvr6+1td/1KhRRqNGjWz21atXLyMqKupKH9JVzc/Pz/jggw+oQxlJS0sz6tata6xdu9Zo166dNVhRj9I1btw4o2nTpgWuoxal69lnnzVuueWWQtfzb3jZeeqpp4zw8HDDbDbzuShlt99+u/HQQw/ZLLv77ruNvn37GobhmJ8LLgUsJw4cOKBjx46pY8eO1mUVK1ZUZGSk4uPjJUnx8fGqVKmSWrRoYW3TsWNHOTk5afPmzdY2bdu2lZubm7VNVFSUdu/erdOnT5fS0Vx9UlJSJEmVK1eWJG3dulU5OTk29ahfv75q1KhhU4/rr79eQUFB1jZRUVFKTU3Vb7/9Zm1zfh95bfL6gK3c3FwtWbJEGRkZatWqFXUoI0OGDNHtt9+e7zWjHqVvz549Cg0NVe3atdW3b18dOnRIErUobV988YVatGih++67T4GBgWrWrJnmzJljXc+/4WUjOztbCxcu1EMPPSSTycTnopTdfPPNio2N1V9//SVJ+vXXX7Vx40Z17dpVkmN+LghW5cSxY8ckyeaDnvc8b92xY8cUGBhos97FxUWVK1e2aVNQH+fvA7bMZrOGDRum1q1bq3HjxpIsr5Wbm5sqVapk0/bCelzqtS6sTWpqqs6ePXslDueqtHPnTvn4+Mjd3V2PP/64VqxYoYYNG1KHMrBkyRJt27ZNU6ZMybeOepSuyMhIzZ8/X6tXr9asWbN04MABtWnTRmlpadSilO3fv1+zZs1S3bp1tWbNGg0ePFhDhw7VggULJPFveFlZuXKlkpOTNXDgQEn8jCpto0ePVu/evVW/fn25urqqWbNmGjZsmPr27SvJMT8XLsVqDaDYhgwZol27dmnjxo1lPZRyq169ekpISFBKSoo++eQTDRgwQBs2bCjrYZU7//zzj5566imtXbtWHh4eZT2cci/vr76S1KRJE0VGRqpmzZpatmyZPD09y3Bk5Y/ZbFaLFi308ssvS5KaNWumXbt2afbs2RowYEAZj678+t///qeuXbsqNDS0rIdSLi1btkyLFi3S4sWL1ahRIyUkJGjYsGEKDQ112M8FZ6zKieDgYEnKN3NNYmKidV1wcLCSkpJs1p87d06nTp2yaVNQH+fvA/+JiYnRV199pfXr16tatWrW5cHBwcrOzlZycrJN+wvrcanXurA2vr6+/GJ0Hjc3N9WpU0fNmzfXlClT1LRpU7311lvUoZRt3bpVSUlJuuGGG+Ti4iIXFxdt2LBBb7/9tlxcXBQUFEQ9ylClSpV03XXXae/evXw2SllISIgaNmxos6xBgwbWSzP5N7z0/f3331q3bp0eeeQR6zI+F6Vr5MiR1rNW119/vfr166fhw4dbr3hwxM8FwaqcqFWrloKDgxUbG2tdlpqaqs2bN6tVq1aSpFatWik5OVlbt261tvnuu+9kNpsVGRlpbfP9998rJyfH2mbt2rWqV6+e/Pz8SuloHJ9hGIqJidGKFSv03XffqVatWjbrmzdvLldXV5t67N69W4cOHbKpx86dO21+IKxdu1a+vr7Wf4BbtWpl00dem7w+UDCz2aysrCzqUMo6dOignTt3KiEhwfpo0aKF+vbta/1/6lF20tPTtW/fPoWEhPDZKGWtW7fO95Ucf/31l2rWrCmJf8PLwrx58xQYGKjbb7/duozPRek6c+aMnJxso4qzs7PMZrMkB/1cFHu6CzistLQ0Y/v27cb27dsNSca0adOM7du3G3///bdhGJYpKStVqmR8/vnnxo4dO4wePXoUOCVls2bNjM2bNxsbN2406tatazMlZXJyshEUFGT069fP2LVrl7FkyRLDy8uLqVovMHjwYKNixYpGXFyczbStZ86csbZ5/PHHjRo1ahjfffed8csvvxitWrUyWrVqZV2fN2Vr586djYSEBGP16tVGlSpVCpyydeTIkcYff/xhzJgxgylbLzB69Ghjw4YNxoEDB4wdO3YYo0ePNkwmk/Htt98ahkEdytr5swIaBvUoTU8//bQRFxdnHDhwwPjxxx+Njh07GgEBAUZSUpJhGNSiNG3ZssVwcXExXnrpJWPPnj3GokWLDC8vL2PhwoXWNvwbXnpyc3ONGjVqGM8++2y+dXwuSs+AAQOMqlWrWqdb/+yzz4yAgABj1KhR1jaO9rkgWF1D1q9fb0jK9xgwYIBhGJZpKV988UUjKCjIcHd3Nzp06GDs3r3bpo+TJ08aDzzwgOHj42P4+voa0dHRRlpamk2bX3/91bjlllsMd3d3o2rVqsYrr7xSWod41SioDpKMefPmWducPXvWeOKJJww/Pz/Dy8vLuOuuu4yjR4/a9HPw4EGja9euhqenpxEQEGA8/fTTRk5Ojk2b9evXGxEREYabm5tRu3Ztm33AMB566CGjZs2ahpubm1GlShWjQ4cO1lBlGNShrF0YrKhH6enVq5cREhJiuLm5GVWrVjV69epl871J1KJ0ffnll0bjxo0Nd3d3o379+sb7779vs55/w0vPmjVrDEn5Xl/D4HNRmlJTU42nnnrKqFGjhuHh4WHUrl3beP75522mRXe0z4XJMM77+mIAAAAAQLFxjxUAAAAA2IlgBQAAAAB2IlgBAAAAgJ0IVgAAAABgJ4IVAAAAANiJYAUAAAAAdiJYAQAAAICdCFYAAAAAYCeCFQDAoRw8eFAmk0kJCQkOtc+4uDiZTCYlJyeX6TgAAI6JYAUAKDUDBw6UyWSyPvz9/dWlSxft2LHD2qZ69eo6evSoGjdubNe+8vbx008/2SzPysqSv7+/TCaT4uLiSnSf8+fPt+7XyclJ1apVU3R0tJKSkoq0/eWMY/z48YqIiLjMEQMASgrBCgBQqrp06aKjR4/q6NGjio2NlYuLi+644w7remdnZwUHB8vFxcXufVWvXl3z5s2zWbZixQr5+PjYLCvJffr6+uro0aM6fPiw5syZo2+++Ub9+vUr0rYlOQ4AQOkiWAEASpW7u7uCg4MVHBysiIgIjR49Wv/884+OHz8uKf/lcHmX4MXGxqpFixby8vLSzTffrN27d19yXwMGDNCSJUt09uxZ67K5c+dqwIABNu0KugRv1apVuu666+Tp6albb71VBw8eLNLxmUwmBQcHKzQ0VF27dtXQoUO1bt06nT17VmazWRMnTlS1atXk7u6uiIgIrV69utBxXOrY58+frwkTJujXX3+1nimbP39+kcYJAChZBCsAQJlJT0/XwoULVadOHfn7+1+07fPPP6833nhDv/zyi1xcXPTQQw9dsv/mzZsrLCxMn376qSTp0KFD+v777y95Bumff/7R3XffrTvvvFMJCQl65JFHNHr06KIf2Hk8PT1lNpt17tw5vfXWW3rjjTf0+uuva8eOHYqKilL37t21Z8+ei/ZR2LH36tVLTz/9tBo1amQ9C9irV6/LGicAwD4EKwBAqfrqq6/k4+MjHx8fVahQQV988YWWLl0qJ6eL/5P00ksvqV27dmrYsKFGjx6tTZs2KTMz85L7e+ihhzR37lxJljM83bp1U5UqVS66zaxZsxQeHq433nhD9erVU9++fTVw4MAiH2OePXv2aPbs2WrRooUqVKig119/Xc8++6x69+6tevXq6dVXX1VERISmT59+0X4KO3ZPT0/5+PjIxcXFehbQ09Oz2OMEANiPYAUAKFW33nqrEhISlJCQoC1btigqKkpdu3bV33//fdHtmjRpYv3/kJAQSSrSpBAPPvig4uPjtX//fs2fP79IZ7r++OMPRUZG2ixr1aqVzfO8cOjj46PHH3/cujwlJUU+Pj7y8vJSvXr1FBQUpEWLFik1NVVHjhxR69atbfpp3bq1/vjjj4uO53KPHQBQerg7FgBQqry9vVWnTh3r8w8++EAVK1bUnDlzNHny5EK3c3V1tf6/yWSSJJnN5kvuz9/fX3fccYcefvhhZWZmqmvXrkpLS7PjCCzOvx/L19fX+v8VKlTQtm3b5OTkpJCQEOsZpNTU1Mve1+UeOwCg9BCsAABlKm9q8vMnmChpDz30kLp166Znn31Wzs7Ol2zfoEEDffHFFzbLLpy2/fxweD4nJ6cC1/n6+io0NFQ//vij2rVrZ13+448/qmXLlkU5jAK5ubkpNzf3srcHAJQMghUAoFRlZWXp2LFjkqTTp0/r3XffVXp6uu68884rts8uXbro+PHjNmeWLubxxx/XG2+8oZEjR+qRRx7R1q1bS2S2vZEjR2rcuHEKDw9XRESE5s2bp4SEBC1atOiy+wwLC9OBAweUkJCgatWqqUKFCnJ3d7d7rACA4uEeKwBAqVq9erVCQkIUEhKiyMhI/fzzz1q+fLnat29/xfZpMpkUEBAgNze3IrWvUaOGPv30U61cuVJNmzbV7Nmz9fLLL9s9jqFDh2rEiBF6+umndf3112v16tX64osvVLdu3cvu85577lGXLl106623qkqVKvr444/tHicAoPhMhmEYZT0IAAAAALiaccYKAAAAAOxEsAIAAAAAOxGsAAAAAMBOBCsAAAAAsBPBCgAAAADsRLACAAAAADsRrAAAAADATgQrAAAAALATwQoAAAAA7ESwAgAAAAA7EawAAAAAwE7/B+Z6hcFg5R0NAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "iv_transformer.plot_bubble_feature('credit_amount')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "rdm", + "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.10.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "b0fc7d2c5e3b32912b68ef575c1bdd2ee7ee3f28f2d636d660b71751dc8fb34a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}