{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"authorship_tag":"ABX9TyNOQYN87KhpyppIuNCFYNdH"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["Python实验报告三 Task1"],"metadata":{"id":"Ne1qB9WXXytD"}},{"cell_type":"code","source":["!pip install surprise"],"metadata":{"id":"SZHDb8piaafD"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# 1. 彻底卸载所有可能的冲突库\n","!pip uninstall -y numpy numba tensorflow scikit-surprise surprise jax jaxlib pymc blosc2 thinc treescope dopamine-rl cudf-cu12 dask-cuda librosa umap-learn pynndescent stumpy shap tensorflow-decision-forests\n","\n","# 2. 尝试安装 numpy 1.26.4\n","#    这个版本在 Python 3.11 上应该有轮子，并且是 1.x 系列的最新。\n","!pip install numpy==1.26.4\n","\n","# 3. 立即安装 surprise\n","#    scikit-surprise 1.1.4 依赖 numpy >= 1.19.5，所以 1.26.4 应该满足其要求。\n","!pip install surprise"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"8JhsdA4Ubiwe","executionInfo":{"status":"ok","timestamp":1748848119211,"user_tz":-480,"elapsed":27048,"user":{"displayName":"Yihan Wang","userId":"09841618405917660021"}},"outputId":"196b77bc-b913-4b36-9908-47fd94841001"},"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["Found existing installation: numpy 1.24.4\n","Uninstalling numpy-1.24.4:\n","  Successfully uninstalled numpy-1.24.4\n","\u001b[33mWARNING: Skipping numba as it is not installed.\u001b[0m\u001b[33m\n","\u001b[0m\u001b[33mWARNING: Skipping tensorflow as it is not installed.\u001b[0m\u001b[33m\n","\u001b[0m\u001b[33mWARNING: Skipping scikit-surprise as it is not installed.\u001b[0m\u001b[33m\n","\u001b[0m\u001b[33mWARNING: Skipping surprise as it is not installed.\u001b[0m\u001b[33m\n","\u001b[0mFound existing installation: jax 0.5.2\n","Uninstalling jax-0.5.2:\n","  Successfully uninstalled jax-0.5.2\n","Found existing installation: jaxlib 0.5.1\n","Uninstalling jaxlib-0.5.1:\n","  Successfully uninstalled jaxlib-0.5.1\n","Found existing installation: pymc 5.22.0\n","Uninstalling pymc-5.22.0:\n","  Successfully uninstalled pymc-5.22.0\n","Found existing installation: blosc2 3.3.3\n","Uninstalling blosc2-3.3.3:\n","  Successfully uninstalled blosc2-3.3.3\n","Found existing installation: thinc 8.3.6\n","Uninstalling thinc-8.3.6:\n","  Successfully uninstalled thinc-8.3.6\n","Found existing installation: treescope 0.1.9\n","Uninstalling treescope-0.1.9:\n","  Successfully uninstalled treescope-0.1.9\n","Found existing installation: dopamine_rl 4.1.2\n","Uninstalling dopamine_rl-4.1.2:\n","  Successfully uninstalled dopamine_rl-4.1.2\n","Found existing installation: cudf-cu12 25.2.1\n","Uninstalling cudf-cu12-25.2.1:\n","  Successfully uninstalled cudf-cu12-25.2.1\n","Found existing installation: dask-cuda 25.2.0\n","Uninstalling dask-cuda-25.2.0:\n","  Successfully uninstalled dask-cuda-25.2.0\n","Found existing installation: librosa 0.11.0\n","Uninstalling librosa-0.11.0:\n","  Successfully uninstalled librosa-0.11.0\n","Found existing installation: umap-learn 0.5.7\n","Uninstalling umap-learn-0.5.7:\n","  Successfully uninstalled umap-learn-0.5.7\n","Found existing installation: pynndescent 0.5.13\n","Uninstalling pynndescent-0.5.13:\n","  Successfully uninstalled pynndescent-0.5.13\n","Found existing installation: stumpy 1.13.0\n","Uninstalling stumpy-1.13.0:\n","  Successfully uninstalled stumpy-1.13.0\n","Found existing installation: shap 0.47.2\n","Uninstalling shap-0.47.2:\n","  Successfully uninstalled shap-0.47.2\n","Found existing installation: tensorflow_decision_forests 1.11.0\n","Uninstalling tensorflow_decision_forests-1.11.0:\n","  Successfully uninstalled tensorflow_decision_forests-1.11.0\n","Collecting numpy==1.26.4\n","  Using cached numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (61 kB)\n","Using cached numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (18.3 MB)\n","Installing collected packages: numpy\n","\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n","spacy 3.8.6 requires thinc<8.4.0,>=8.3.4, which is not installed.\n","tables 3.10.2 requires blosc2>=2.3.0, which is not installed.\n","dask-cudf-cu12 25.2.2 requires cudf-cu12==25.2.*, which is not installed.\n","raft-dask-cu12 25.2.0 requires dask-cuda==25.2.*, which is not installed.\n","chex 0.1.89 requires jax>=0.4.27, which is not installed.\n","chex 0.1.89 requires jaxlib>=0.4.27, which is not installed.\n","cuml-cu12 25.2.1 requires cudf-cu12==25.2.*, which is not installed.\n","cuml-cu12 25.2.1 requires dask-cuda==25.2.*, which is not installed.\n","cuml-cu12 25.2.1 requires numba<0.61.0a0,>=0.59.1, which is not installed.\n","orbax-checkpoint 0.11.13 requires jax>=0.5.0, which is not installed.\n","tsfresh 0.21.0 requires stumpy>=1.7.2, which is not installed.\n","optax 0.2.4 requires jax>=0.4.27, which is not installed.\n","optax 0.2.4 requires jaxlib>=0.4.27, which is not installed.\n","flax 0.10.6 requires jax>=0.5.1, which is not installed.\n","flax 0.10.6 requires treescope>=0.1.7, which is not installed.\u001b[0m\u001b[31m\n","\u001b[0mSuccessfully installed numpy-1.26.4\n","Collecting surprise\n","  Using cached surprise-0.1-py2.py3-none-any.whl.metadata (327 bytes)\n","Collecting scikit-surprise (from surprise)\n","  Using cached scikit_surprise-1.1.4-cp311-cp311-linux_x86_64.whl\n","Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from scikit-surprise->surprise) (1.5.1)\n","Requirement already satisfied: numpy>=1.19.5 in /usr/local/lib/python3.11/dist-packages (from scikit-surprise->surprise) (1.26.4)\n","Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from scikit-surprise->surprise) (1.15.3)\n","Using cached surprise-0.1-py2.py3-none-any.whl (1.8 kB)\n","Installing collected packages: scikit-surprise, surprise\n","Successfully installed scikit-surprise-1.1.4 surprise-0.1\n"]}]},{"cell_type":"code","source":["import pandas as pd\n","import numpy as np\n","from sklearn.model_selection import train_test_split\n","from sklearn.preprocessing import LabelEncoder, StandardScaler\n","from sklearn.ensemble import RandomForestClassifier\n","from sklearn.metrics import (\n","    accuracy_score, precision_score, recall_score, f1_score,\n","    roc_auc_score, classification_report, confusion_matrix,\n","    roc_curve, precision_recall_curve, average_precision_score\n",")\n","import matplotlib.pyplot as plt\n","import seaborn as sns\n","import warnings\n","\n","warnings.filterwarnings('ignore') # 忽略警告信息\n","\n","# --- Plotting style settings ---\n","# Reverted to English for plot titles/labels, so no Chinese font settings needed here.\n","try:\n","    plt.style.use('seaborn-v0_8-darkgrid')\n","except:\n","    plt.style.use('seaborn-darkgrid')\n","\n","sns.set_palette('viridis') # 设置默认调色板\n","# --- End plotting style settings ---\n","\n","\n","# --- 数据加载和预处理 ---\n","\n","def load_data(filepath):\n","    \"\"\"加载数据集\"\"\"\n","    df = pd.read_csv(filepath)\n","    print(f\"数据加载成功，原始形状: {df.shape}\")\n","    print(f\"原始数据中 'Status' 列的唯一值及其计数:\\n{df['Status'].value_counts()}\")\n","    print(\"-\" * 50)\n","    return df\n","\n","def preprocess_data(df):\n","    \"\"\"数据预处理，包括缺失值处理、编码和标准化\"\"\"\n","    print(\"------- 进入数据预处理函数 -------\")\n","    # 1. 缺失值处理：使用填充（中位数/众数）而不是删除行\n","    print(\"开始填充缺失值...\")\n","\n","    # 填充数值型列的缺失值（使用中位数）\n","    for col in df.select_dtypes(include=np.number).columns:\n","        if col != 'Status': # 不填充目标变量\n","            if df[col].isnull().any(): # 检查该列是否有缺失值\n","                median_val = df[col].median()\n","                df[col].fillna(median_val, inplace=True)\n","\n","    # 填充对象（类别）型列的缺失值（使用众数）\n","    for col in df.select_dtypes(include='object').columns:\n","        if df[col].isnull().any(): # 检查该列是否有缺失值\n","            mode_val = df[col].mode()[0] # mode() 返回 Series，取第一个值\n","            df[col].fillna(mode_val, inplace=True)\n","\n","    print(f\"处理缺失值后，行数保持不变: {df.shape[0]} 行。\")\n","    print(f\"在填充缺失值之后，'Status' 列的分布:\\n{df['Status'].value_counts()}\")\n","    print(\"-\" * 50)\n","\n","    # 2. 重复值处理：删除完全重复的行\n","    initial_rows_before_duplicates = df.shape[0]\n","    df.drop_duplicates(inplace=True)\n","    rows_dropped_by_duplicates = initial_rows_before_duplicates - df.shape[0]\n","    print(f\"处理重复值后，删除 {rows_dropped_by_duplicates} 行，剩余 {df.shape[0]} 行。\")\n","    print(f\"在 drop_duplicates 之后，'Status' 列的分布:\\n{df['Status'].value_counts()}\")\n","\n","    # 检查 Status 是否仍包含至少两个类别\n","    if len(df['Status'].value_counts()) < 2:\n","        raise ValueError(\n","            \"错误：在数据清洗和预处理后，目标变量 'Status' 列只包含一个类别。 \"\n","            \"这导致无法进行二分类预测。请检查您的数据源或数据清洗逻辑，\"\n","            \"确保至少有两个类别样本存在。\"\n","        )\n","    print(\"-\" * 50)\n","\n","    # 3. 编码类别特征 (排除 'Status' 列)\n","    label_encoders = {}\n","    categorical_cols_to_encode = [col for col in df.select_dtypes(include=['object']).columns if col != 'Status']\n","    for col in categorical_cols_to_encode:\n","        le = LabelEncoder()\n","        df[col] = le.fit_transform(df[col].astype(str)) # 确保转换为字符串再编码\n","        label_encoders[col] = le\n","\n","    # 4. 标准化数值特征 (排除 'Status' 列)\n","    scaler = StandardScaler()\n","    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()\n","    if 'Status' in num_cols:\n","        num_cols.remove('Status') # 移除目标变量\n","\n","    cols_to_scale = [col for col in num_cols if df[col].nunique() > 1]\n","    if cols_to_scale:\n","        df[cols_to_scale] = scaler.fit_transform(df[cols_to_scale])\n","    else:\n","        print(\"没有需要标准化的数值特征或所有数值特征都是常量。\")\n","\n","    # 删除 ID 列，因为 ID 与是否违约没有关系\n","    if 'ID' in df.columns:\n","        df.drop('ID', axis=1, inplace=True)\n","        print(\"已删除 'ID' 列。\")\n","    else:\n","        print(\"数据中不存在 'ID' 列。\")\n","    print(\"-\" * 50)\n","\n","    print(\"数据预处理完成。\")\n","    print(f\"所有预处理完成后，数据形状: {df.shape}，'Status' 列的最终分布:\\n{df['Status'].value_counts()}\")\n","    print(\"-\" * 50)\n","    return df, label_encoders, scaler\n","\n","\n","def train_model(X_train, y_train):\n","    \"\"\"训练随机森林分类器\"\"\"\n","    model = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1, class_weight='balanced')\n","    model.fit(X_train, y_train)\n","    print(\"\\n随机森林模型训练完成。\")\n","    return model\n","\n","# --- 可视化函数 ---\n","\n","def plot_eda(df):\n","    \"\"\"执行数据探索性分析可视化\"\"\"\n","    print(\"\\n------- 数据探索性分析 (EDA) 可视化 -------\")\n","\n","    # 1. Target Variable Distribution\n","    plt.figure(figsize=(6, 5))\n","    sns.countplot(x='Status', data=df, palette='pastel')\n","    plt.title('Loan Default Status Distribution (0: No Default, 1: Default)')\n","    plt.xlabel('Default Status')\n","    plt.ylabel('Count')\n","    plt.xticks([0, 1], ['No Default', 'Default'])\n","    plt.show()\n","    print(\"已显示目标变量 'Status' 的分布。\")\n","\n","    # 2. Numerical Feature Distributions (Histograms/KDE)\n","    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()\n","    if 'Status' in numeric_cols:\n","        numeric_cols.remove('Status')\n","\n","    cols_to_plot = [\n","        'loan_amount', 'interest_rate', 'Upfront_charges', 'Annual_Income',\n","        'credit_score', 'submission_LTV', 'dtir1', 'total_income', 'age'\n","    ]\n","    cols_to_plot = [col for col in cols_to_plot if col in numeric_cols]\n","\n","    if cols_to_plot:\n","        num_plots = len(cols_to_plot)\n","        num_rows = (num_plots + 1) // 2\n","        plt.figure(figsize=(15, 4 * num_rows))\n","        for i, col in enumerate(cols_to_plot):\n","            plt.subplot(num_rows, 2, i + 1)\n","            sns.histplot(df[col], kde=True, bins=30)\n","            plt.title(f'{col} Distribution')\n","            plt.xlabel(col)\n","            plt.ylabel('Density/Count')\n","        plt.tight_layout()\n","        plt.show()\n","        print(f\"已显示部分数值特征的分布 ({', '.join(cols_to_plot)})。\")\n","    else:\n","        print(\"没有合适的数值特征进行分布可视化。\")\n","\n","    # 3. Categorical Feature Distributions (Bar Plots)\n","    encoded_categorical_cols = [\n","        'loan_limit', 'approv_in_adv', 'loan_type', 'loan_purpose',\n","        'Neg_ammortization', 'credit_type', 'submission_of_application', 'Region', 'Security_Status', 'Gender'\n","    ]\n","    encoded_categorical_cols = [col for col in encoded_categorical_cols if col in df.columns]\n","\n","    if encoded_categorical_cols:\n","        num_plots = len(encoded_categorical_cols)\n","        num_rows = (num_plots + 1) // 2\n","        plt.figure(figsize=(15, 4 * num_rows))\n","        for i, col in enumerate(encoded_categorical_cols):\n","            plt.subplot(num_rows, 2, i + 1)\n","            sns.countplot(x=col, data=df, palette='viridis')\n","            plt.title(f'{col} Distribution')\n","            plt.xlabel(col)\n","            plt.ylabel('Count')\n","            plt.xticks(rotation=45, ha='right')\n","        plt.tight_layout()\n","        plt.show()\n","        print(f\"已显示部分编码后类别特征的分布 ({', '.join(encoded_categorical_cols)})。\")\n","    else:\n","        print(\"没有合适的编码后类别特征进行分布可视化。\")\n","\n","    # 4. Numerical Features vs. Target Variable (Box/Violin Plots)\n","    cols_to_plot_with_status = [\n","        'loan_amount', 'interest_rate', 'Upfront_charges', 'Annual_Income',\n","        'credit_score', 'submission_LTV', 'dtir1', 'total_income', 'age'\n","    ]\n","    cols_to_plot_with_status = [col for col in cols_to_plot_with_status if col in numeric_cols]\n","\n","    if cols_to_plot_with_status:\n","        num_plots = len(cols_to_plot_with_status)\n","        num_rows = (num_plots + 1) // 2\n","        plt.figure(figsize=(15, 4 * num_rows))\n","        for i, col in enumerate(cols_to_plot_with_status):\n","            plt.subplot(num_rows, 2, i + 1)\n","            sns.boxplot(x='Status', y=col, data=df, palette='coolwarm')\n","            plt.title(f'{col} by Status')\n","            plt.xlabel('Default Status')\n","            plt.ylabel(col)\n","            plt.xticks([0, 1], ['No Default', 'Default'])\n","        plt.tight_layout()\n","        plt.show()\n","        print(f\"已显示部分数值特征与 'Status' 的关系。\")\n","\n","    # 5. Feature Correlation Heatmap\n","    plt.figure(figsize=(12, 10))\n","    corr_df = df.select_dtypes(include=[np.number]).drop(columns=['ID'], errors='ignore')\n","    sns.heatmap(corr_df.corr(), annot=True, cmap='coolwarm', fmt=\".2f\", linewidths=.5)\n","    plt.title('Feature Correlation Heatmap')\n","    plt.show()\n","    print(\"已显示特征相关性热力图。\")\n","    print(\"-\" * 50)\n","\n","\n","def evaluate_model(model, X_test, y_test):\n","    \"\"\"评估模型性能并可视化结果\"\"\"\n","    print(\"\\n------- 模型评估结果与可视化 -------\")\n","    y_pred = model.predict(X_test)\n","    y_prob = model.predict_proba(X_test)[:, 1] # 获取正类的概率\n","\n","    print('准确率 (Accuracy):', accuracy_score(y_test, y_pred))\n","    print('精确率 (Precision):', precision_score(y_test, y_pred))\n","    print('召回率 (Recall):', recall_score(y_test, y_pred))\n","    print('F1 分数 (F1-Score):', f1_score(y_test, y_pred))\n","    print('AUC:', roc_auc_score(y_test, y_prob))\n","    print('\\n详细分类报告:\\n', classification_report(y_test, y_pred))\n","\n","    # 1. Confusion Matrix Visualization\n","    cm = confusion_matrix(y_test, y_pred)\n","    plt.figure(figsize=(7, 6))\n","    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False,\n","                xticklabels=['Predicted No Default (0)', 'Predicted Default (1)'],\n","                yticklabels=['Actual No Default (0)', 'Actual Default (1)'])\n","    plt.title('Confusion Matrix')\n","    plt.xlabel('Predicted Label')\n","    plt.ylabel('True Label')\n","    plt.show()\n","    print(\"已显示混淆矩阵。\")\n","\n","    # 2. ROC Curve\n","    fpr, tpr, _ = roc_curve(y_test, y_prob)\n","    auc_score = roc_auc_score(y_test, y_prob)\n","    plt.figure(figsize=(7, 6))\n","    plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC Curve (AUC = {auc_score:.2f})')\n","    plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n","    plt.xlim([0.0, 1.0])\n","    plt.ylim([0.0, 1.05])\n","    plt.xlabel('False Positive Rate')\n","    plt.ylabel('True Positive Rate')\n","    plt.title('Receiver Operating Characteristic (ROC) Curve')\n","    plt.legend(loc=\"lower right\")\n","    plt.grid(True)\n","    plt.show()\n","    print(\"已显示 ROC 曲线。\")\n","\n","    # 3. Precision-Recall Curve\n","    precision, recall, _ = precision_recall_curve(y_test, y_prob)\n","    ap_score = average_precision_score(y_test, y_prob)\n","    plt.figure(figsize=(7, 6))\n","    plt.plot(recall, precision, color='purple', lw=2, label=f'P-R Curve (AP = {ap_score:.2f})')\n","    plt.xlabel('Recall')\n","    plt.ylabel('Precision')\n","    plt.title('Precision-Recall Curve')\n","    plt.legend(loc=\"lower left\")\n","    plt.grid(True)\n","    plt.show()\n","    print(\"已显示精确率-召回率曲线。\")\n","    print(\"-\" * 50)\n","\n","\n","def feature_importance_plot(model, feature_names, top_n=15):\n","    \"\"\"可视化特征重要性\"\"\"\n","    print(\"\\n------- 特征重要性可视化 -------\")\n","    importances = model.feature_importances_\n","    feature_importances = pd.DataFrame({'feature': feature_names, 'importance': importances})\n","    feature_importances = feature_importances.sort_values(by='importance', ascending=False)\n","\n","    plt.figure(figsize=(10, 7))\n","    sns.barplot(x='importance', y='feature', data=feature_importances.head(top_n), palette='magma')\n","    plt.title(f'Feature Importance (Top {top_n})')\n","    plt.xlabel('Importance')\n","    plt.ylabel('Feature')\n","    plt.tight_layout()\n","    plt.show()\n","    print(f\"已显示前 {top_n} 个重要特征的条形图。\")\n","    print(\"-\" * 50)\n","\n","\n","def main():\n","    # 数据路径\n","    filepath = '/content/data_task2/Loan_Default.csv'\n","    df = load_data(filepath)\n","\n","    # 数据探索性分析 (在预处理之前进行)\n","    plot_eda(df.copy()) # 传入副本，避免修改原始df\n","\n","    # 预处理\n","    df_processed, label_encoders, scaler = preprocess_data(df.copy())\n","    leaky_features = [\n","        'rate_of_interest',\n","        'Interest_rate_spread',\n","        'Upfront_charges'\n","        # 也可以考虑其他在业务上不应该在贷款审批前知道的特征\n","    ]\n","\n","    # 确保要删除的列确实存在于 df_processed 中\n","    features_to_drop = [col for col in leaky_features if col in df_processed.columns]\n","\n","    if features_to_drop:\n","        df_processed = df_processed.drop(columns=features_to_drop)\n","        print(f\"已移除可能导致数据泄露的特征: {features_to_drop}\")\n","    else:\n","        print(\"没有发现需要移除的潜在泄露特征。\")\n","    # --- 移除泄露特征结束 ---\n","\n","    # 特征与标签\n","    X = df_processed.drop('Status', axis=1)\n","    y = df_processed['Status']\n","\n","    # 划分训练集和测试集\n","    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n","\n","    # 重新进行标准化，避免数据泄露\n","    print(\"\\n------- 训练集和测试集标准化 (避免数据泄露) -------\")\n","    scaler = StandardScaler()\n","\n","    numeric_cols_train = X_train.select_dtypes(include=[np.number]).columns.tolist()\n","    cols_to_scale_train = [col for col in numeric_cols_train if X_train[col].nunique() > 1]\n","\n","    if cols_to_scale_train:\n","        X_train[cols_to_scale_train] = scaler.fit_transform(X_train[cols_to_scale_train])\n","        X_test[cols_to_scale_train] = scaler.transform(X_test[cols_to_scale_train])\n","        print(f\"数值特征 {cols_to_scale_train} 已在训练集上拟合并用于转换训练集和测试集。\")\n","    else:\n","        print(\"没有需要标准化的数值特征或所有数值特征都是常量。\")\n","    print(\"-\" * 50)\n","\n","    # 特征与标签\n","    X = df_processed.drop('Status', axis=1)\n","    y = df_processed['Status']\n","\n","    # 划分训练集和测试集\n","    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n","\n","    print(f\"\\n训练集形状: {X_train.shape}, 测试集形状: {X_test.shape}\")\n","    print(f\"训练集中 'Status' 分布:\\n{y_train.value_counts()}\")\n","    print(f\"测试集中 'Status' 分布:\\n{y_test.value_counts()}\")\n","    print(\"-\" * 50)\n","\n","    # 训练模型\n","    model = train_model(X_train, y_train)\n","\n","    # 评估模型并可视化\n","    evaluate_model(model, X_test, y_test)\n","\n","    # 特征重要性可视化\n","    feature_importance_plot(model, X.columns.tolist())\n","\n","\n","if __name__ == '__main__':\n","    main()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"uVILx7VCX5yQ","executionInfo":{"status":"ok","timestamp":1748864353166,"user_tz":-480,"elapsed":39778,"user":{"displayName":"Yihan Wang","userId":"09841618405917660021"}},"outputId":"95e7ba81-92b8-4e5d-d24a-f2e6b7b2451b"},"execution_count":18,"outputs":[{"output_type":"stream","name":"stdout","text":["数据加载成功，原始形状: (148670, 34)\n","原始数据中 'Status' 列的唯一值及其计数:\n","Status\n","0    112031\n","1     36639\n","Name: count, dtype: int64\n","--------------------------------------------------\n","\n","------- 数据探索性分析 (EDA) 可视化 -------\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 600x500 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示目标变量 'Status' 的分布。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1500x800 with 3 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示部分数值特征的分布 (loan_amount, Upfront_charges, dtir1)。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1500x2000 with 9 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示部分编码后类别特征的分布 (loan_limit, approv_in_adv, loan_type, loan_purpose, Neg_ammortization, credit_type, submission_of_application, Region, Gender)。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1500x800 with 3 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示部分数值特征与 'Status' 的关系。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1200x1000 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示特征相关性热力图。\n","--------------------------------------------------\n","------- 进入数据预处理函数 -------\n","开始填充缺失值...\n","处理缺失值后，行数保持不变: 148670 行。\n","在填充缺失值之后，'Status' 列的分布:\n","Status\n","0    112031\n","1     36639\n","Name: count, dtype: int64\n","--------------------------------------------------\n","处理重复值后，删除 0 行，剩余 148670 行。\n","在 drop_duplicates 之后，'Status' 列的分布:\n","Status\n","0    112031\n","1     36639\n","Name: count, dtype: int64\n","--------------------------------------------------\n","已删除 'ID' 列。\n","--------------------------------------------------\n","数据预处理完成。\n","所有预处理完成后，数据形状: (148670, 33)，'Status' 列的最终分布:\n","Status\n","0    112031\n","1     36639\n","Name: count, dtype: int64\n","--------------------------------------------------\n","已移除可能导致数据泄露的特征: ['rate_of_interest', 'Interest_rate_spread', 'Upfront_charges']\n","\n","------- 训练集和测试集标准化 (避免数据泄露) -------\n","数值特征 ['loan_limit', 'Gender', 'approv_in_adv', 'loan_type', 'loan_purpose', 'Credit_Worthiness', 'open_credit', 'business_or_commercial', 'loan_amount', 'term', 'Neg_ammortization', 'interest_only', 'lump_sum_payment', 'property_value', 'construction_type', 'occupancy_type', 'Secured_by', 'total_units', 'income', 'credit_type', 'Credit_Score', 'co-applicant_credit_type', 'age', 'submission_of_application', 'LTV', 'Region', 'Security_Type', 'dtir1'] 已在训练集上拟合并用于转换训练集和测试集。\n","--------------------------------------------------\n","\n","训练集形状: (118936, 29), 测试集形状: (29734, 29)\n","训练集中 'Status' 分布:\n","Status\n","0    89625\n","1    29311\n","Name: count, dtype: int64\n","测试集中 'Status' 分布:\n","Status\n","0    22406\n","1     7328\n","Name: count, dtype: int64\n","--------------------------------------------------\n","\n","随机森林模型训练完成。\n","\n","------- 模型评估结果与可视化 -------\n","准确率 (Accuracy): 0.8902603080648416\n","精确率 (Precision): 0.9370027950978285\n","召回率 (Recall): 0.5947052401746725\n","F1 分数 (F1-Score): 0.7276066449620169\n","AUC: 0.8885098892773575\n","\n","详细分类报告:\n","               precision    recall  f1-score   support\n","\n","           0       0.88      0.99      0.93     22406\n","           1       0.94      0.59      0.73      7328\n","\n","    accuracy                           0.89     29734\n","   macro avg       0.91      0.79      0.83     29734\n","weighted avg       0.90      0.89      0.88     29734\n","\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 700x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示混淆矩阵。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 700x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示 ROC 曲线。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 700x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示精确率-召回率曲线。\n","--------------------------------------------------\n","\n","------- 特征重要性可视化 -------\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x700 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示前 15 个重要特征的条形图。\n","--------------------------------------------------\n"]}]},{"cell_type":"code","source":["import pandas as pd\n","import numpy as np\n","from sklearn.model_selection import train_test_split\n","from sklearn.preprocessing import LabelEncoder, StandardScaler\n","from sklearn.ensemble import RandomForestClassifier\n","from sklearn.metrics import (\n","    accuracy_score, precision_score, recall_score, f1_score,\n","    roc_auc_score, classification_report, confusion_matrix,\n","    roc_curve, precision_recall_curve, average_precision_score\n",")\n","import matplotlib.pyplot as plt\n","import seaborn as sns\n","import warnings\n","\n","warnings.filterwarnings('ignore') # 忽略警告信息\n","\n","# --- Plotting style settings ---\n","# Reverted to English for plot titles/labels, so no Chinese font settings needed here.\n","try:\n","    plt.style.use('seaborn-v0_8-darkgrid')\n","except:\n","    plt.style.use('seaborn-darkgrid')\n","\n","sns.set_palette('viridis') # 设置默认调色板\n","# --- End plotting style settings ---\n","\n","\n","# --- 数据加载和预处理 ---\n","\n","def load_data(filepath):\n","    \"\"\"加载数据集\"\"\"\n","    df = pd.read_csv(filepath)\n","    print(f\"数据加载成功，原始形状: {df.shape}\")\n","    print(f\"原始数据中 'Status' 列的唯一值及其计数:\\n{df['Status'].value_counts()}\")\n","    print(\"-\" * 50)\n","    return df\n","\n","def preprocess_data(df):\n","    \"\"\"数据预处理，包括缺失值处理、编码和标准化\"\"\"\n","    print(\"------- 进入数据预处理函数 -------\")\n","\n","    # 1. 缺失值处理：使用填充（中位数/众数）而不是删除行\n","    print(\"开始填充缺失值...\")\n","\n","    # 填充数值型列的缺失值（使用中位数）\n","    for col in df.select_dtypes(include=np.number).columns:\n","        if col != 'Status': # 不填充目标变量\n","            if df[col].isnull().any(): # 检查该列是否有缺失值\n","                median_val = df[col].median()\n","                df[col].fillna(median_val, inplace=True)\n","\n","    # 填充对象（类别）型列的缺失值（使用众数）\n","    for col in df.select_dtypes(include='object').columns:\n","        if df[col].isnull().any(): # 检查该列是否有缺失值\n","            mode_val = df[col].mode()[0] # mode() 返回 Series，取第一个值\n","            df[col].fillna(mode_val, inplace=True)\n","\n","    print(f\"处理缺失值后，行数保持不变: {df.shape[0]} 行。\")\n","    print(f\"在填充缺失值之后，'Status' 列的分布:\\n{df['Status'].value_counts()}\")\n","    print(\"-\" * 50)\n","\n","    # 2. 重复值处理：删除完全重复的行\n","    initial_rows_before_duplicates = df.shape[0]\n","    df.drop_duplicates(inplace=True)\n","    rows_dropped_by_duplicates = initial_rows_before_duplicates - df.shape[0]\n","    print(f\"处理重复值后，删除 {rows_dropped_by_duplicates} 行，剩余 {df.shape[0]} 行。\")\n","    print(f\"在 drop_duplicates 之后，'Status' 列的分布:\\n{df['Status'].value_counts()}\")\n","\n","    # 检查 Status 是否仍包含至少两个类别\n","    if len(df['Status'].value_counts()) < 2:\n","        raise ValueError(\n","            \"错误：在数据清洗和预处理后，目标变量 'Status' 列只包含一个类别。 \"\n","            \"这导致无法进行二分类预测。请检查您的数据源或数据清洗逻辑，\"\n","            \"确保至少有两个类别样本存在。\"\n","        )\n","    print(\"-\" * 50)\n","\n","    # 3. 编码类别特征 (排除 'Status' 列)\n","    label_encoders = {}\n","    categorical_cols_to_encode = [col for col in df.select_dtypes(include=['object']).columns if col != 'Status']\n","    for col in categorical_cols_to_encode:\n","        le = LabelEncoder()\n","        df[col] = le.fit_transform(df[col].astype(str)) # 确保转换为字符串再编码\n","        label_encoders[col] = le\n","\n","    # 4. 标准化数值特征 (排除 'Status' 列)\n","    scaler = StandardScaler()\n","    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()\n","    if 'Status' in num_cols:\n","        num_cols.remove('Status') # 移除目标变量\n","\n","    cols_to_scale = [col for col in num_cols if df[col].nunique() > 1]\n","    if cols_to_scale:\n","        df[cols_to_scale] = scaler.fit_transform(df[cols_to_scale])\n","    else:\n","        print(\"没有需要标准化的数值特征或所有数值特征都是常量。\")\n","\n","    print(\"数据预处理完成。\")\n","    print(f\"所有预处理完成后，数据形状: {df.shape}，'Status' 列的最终分布:\\n{df['Status'].value_counts()}\")\n","    print(\"-\" * 50)\n","    return df, label_encoders, scaler\n","\n","\n","def train_model(X_train, y_train):\n","    \"\"\"训练随机森林分类器\"\"\"\n","    model = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1, class_weight='balanced')\n","    model.fit(X_train, y_train)\n","    print(\"\\n随机森林模型训练完成。\")\n","    return model\n","\n","# --- 可视化函数 ---\n","\n","def plot_eda(df):\n","    \"\"\"执行数据探索性分析可视化\"\"\"\n","    print(\"\\n------- 数据探索性分析 (EDA) 可视化 -------\")\n","\n","    # 1. Target Variable Distribution\n","    plt.figure(figsize=(6, 5))\n","    sns.countplot(x='Status', data=df, palette='pastel')\n","    plt.title('Loan Default Status Distribution (0: No Default, 1: Default)')\n","    plt.xlabel('Default Status')\n","    plt.ylabel('Count')\n","    plt.xticks([0, 1], ['No Default', 'Default'])\n","    plt.show()\n","    print(\"已显示目标变量 'Status' 的分布。\")\n","\n","    # 2. Numerical Feature Distributions (Histograms/KDE)\n","    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()\n","    if 'Status' in numeric_cols:\n","        numeric_cols.remove('Status')\n","\n","    cols_to_plot = [\n","        'loan_amount', 'interest_rate', 'Upfront_charges', 'Annual_Income',\n","        'credit_score', 'submission_LTV', 'dtir1', 'total_income', 'age'\n","    ]\n","    cols_to_plot = [col for col in cols_to_plot if col in numeric_cols]\n","\n","    if cols_to_plot:\n","        num_plots = len(cols_to_plot)\n","        num_rows = (num_plots + 1) // 2\n","        plt.figure(figsize=(15, 4 * num_rows))\n","        for i, col in enumerate(cols_to_plot):\n","            plt.subplot(num_rows, 2, i + 1)\n","            sns.histplot(df[col], kde=True, bins=30)\n","            plt.title(f'{col} Distribution')\n","            plt.xlabel(col)\n","            plt.ylabel('Density/Count')\n","        plt.tight_layout()\n","        plt.show()\n","        print(f\"已显示部分数值特征的分布 ({', '.join(cols_to_plot)})。\")\n","    else:\n","        print(\"没有合适的数值特征进行分布可视化。\")\n","\n","    # 3. Categorical Feature Distributions (Bar Plots)\n","    encoded_categorical_cols = [\n","        'loan_limit', 'approv_in_adv', 'loan_type', 'loan_purpose',\n","        'Neg_ammortization', 'credit_type', 'submission_of_application', 'Region', 'Security_Status', 'Gender'\n","    ]\n","    encoded_categorical_cols = [col for col in encoded_categorical_cols if col in df.columns]\n","\n","    if encoded_categorical_cols:\n","        num_plots = len(encoded_categorical_cols)\n","        num_rows = (num_plots + 1) // 2\n","        plt.figure(figsize=(15, 4 * num_rows))\n","        for i, col in enumerate(encoded_categorical_cols):\n","            plt.subplot(num_rows, 2, i + 1)\n","            sns.countplot(x=col, data=df, palette='viridis')\n","            plt.title(f'{col} Distribution')\n","            plt.xlabel(col)\n","            plt.ylabel('Count')\n","            plt.xticks(rotation=45, ha='right')\n","        plt.tight_layout()\n","        plt.show()\n","        print(f\"已显示部分编码后类别特征的分布 ({', '.join(encoded_categorical_cols)})。\")\n","    else:\n","        print(\"没有合适的编码后类别特征进行分布可视化。\")\n","\n","    # 4. Numerical Features vs. Target Variable (Box/Violin Plots)\n","    cols_to_plot_with_status = [\n","        'loan_amount', 'interest_rate', 'Upfront_charges', 'Annual_Income',\n","        'credit_score', 'submission_LTV', 'dtir1', 'total_income', 'age'\n","    ]\n","    cols_to_plot_with_status = [col for col in cols_to_plot_with_status if col in numeric_cols]\n","\n","    if cols_to_plot_with_status:\n","        num_plots = len(cols_to_plot_with_status)\n","        num_rows = (num_plots + 1) // 2\n","        plt.figure(figsize=(15, 4 * num_rows))\n","        for i, col in enumerate(cols_to_plot_with_status):\n","            plt.subplot(num_rows, 2, i + 1)\n","            sns.boxplot(x='Status', y=col, data=df, palette='coolwarm')\n","            plt.title(f'{col} by Status')\n","            plt.xlabel('Default Status')\n","            plt.ylabel(col)\n","            plt.xticks([0, 1], ['No Default', 'Default'])\n","        plt.tight_layout()\n","        plt.show()\n","        print(f\"已显示部分数值特征与 'Status' 的关系。\")\n","\n","    # 5. Feature Correlation Heatmap\n","    plt.figure(figsize=(12, 10))\n","    corr_df = df.select_dtypes(include=[np.number]).drop(columns=['ID'], errors='ignore')\n","    sns.heatmap(corr_df.corr(), annot=True, cmap='coolwarm', fmt=\".2f\", linewidths=.5)\n","    plt.title('Feature Correlation Heatmap')\n","    plt.show()\n","    print(\"已显示特征相关性热力图。\")\n","    print(\"-\" * 50)\n","\n","\n","def evaluate_model(model, X_test, y_test):\n","    \"\"\"评估模型性能并可视化结果\"\"\"\n","    print(\"\\n------- 模型评估结果与可视化 -------\")\n","    y_pred = model.predict(X_test)\n","    y_prob = model.predict_proba(X_test)[:, 1] # 获取正类的概率\n","\n","    print('准确率 (Accuracy):', accuracy_score(y_test, y_pred))\n","    print('精确率 (Precision):', precision_score(y_test, y_pred))\n","    print('召回率 (Recall):', recall_score(y_test, y_pred))\n","    print('F1 分数 (F1-Score):', f1_score(y_test, y_pred))\n","    print('AUC:', roc_auc_score(y_test, y_prob))\n","    print('\\n详细分类报告:\\n', classification_report(y_test, y_pred))\n","\n","    # 1. Confusion Matrix Visualization\n","    cm = confusion_matrix(y_test, y_pred)\n","    plt.figure(figsize=(7, 6))\n","    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False,\n","                xticklabels=['Predicted No Default (0)', 'Predicted Default (1)'],\n","                yticklabels=['Actual No Default (0)', 'Actual Default (1)'])\n","    plt.title('Confusion Matrix')\n","    plt.xlabel('Predicted Label')\n","    plt.ylabel('True Label')\n","    plt.show()\n","    print(\"已显示混淆矩阵。\")\n","\n","    # 2. ROC Curve\n","    fpr, tpr, _ = roc_curve(y_test, y_prob)\n","    auc_score = roc_auc_score(y_test, y_prob)\n","    plt.figure(figsize=(7, 6))\n","    plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC Curve (AUC = {auc_score:.2f})')\n","    plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n","    plt.xlim([0.0, 1.0])\n","    plt.ylim([0.0, 1.05])\n","    plt.xlabel('False Positive Rate')\n","    plt.ylabel('True Positive Rate')\n","    plt.title('Receiver Operating Characteristic (ROC) Curve')\n","    plt.legend(loc=\"lower right\")\n","    plt.grid(True)\n","    plt.show()\n","    print(\"已显示 ROC 曲线。\")\n","\n","    # 3. Precision-Recall Curve\n","    precision, recall, _ = precision_recall_curve(y_test, y_prob)\n","    ap_score = average_precision_score(y_test, y_prob)\n","    plt.figure(figsize=(7, 6))\n","    plt.plot(recall, precision, color='purple', lw=2, label=f'P-R Curve (AP = {ap_score:.2f})')\n","    plt.xlabel('Recall')\n","    plt.ylabel('Precision')\n","    plt.title('Precision-Recall Curve')\n","    plt.legend(loc=\"lower left\")\n","    plt.grid(True)\n","    plt.show()\n","    print(\"已显示精确率-召回率曲线。\")\n","    print(\"-\" * 50)\n","\n","\n","def feature_importance_plot(model, feature_names, top_n=15):\n","    \"\"\"可视化特征重要性\"\"\"\n","    print(\"\\n------- 特征重要性可视化 -------\")\n","    importances = model.feature_importances_\n","    feature_importances = pd.DataFrame({'feature': feature_names, 'importance': importances})\n","    feature_importances = feature_importances.sort_values(by='importance', ascending=False)\n","\n","    plt.figure(figsize=(10, 7))\n","    sns.barplot(x='importance', y='feature', data=feature_importances.head(top_n), palette='magma')\n","    plt.title(f'Feature Importance (Top {top_n})')\n","    plt.xlabel('Importance')\n","    plt.ylabel('Feature')\n","    plt.tight_layout()\n","    plt.show()\n","    print(f\"已显示前 {top_n} 个重要特征的条形图。\")\n","    print(\"-\" * 50)\n","\n","\n","def main():\n","    # 数据路径\n","    filepath = '/content/data_task2/Loan_Default.csv'\n","    df = load_data(filepath)\n","\n","    # 数据探索性分析 (在预处理之前进行)\n","    plot_eda(df.copy()) # 传入副本，避免修改原始df\n","\n","    # 预处理\n","    df_processed, label_encoders, scaler = preprocess_data(df.copy())\n","\n","    # 特征与标签\n","    X = df_processed.drop('Status', axis=1)\n","    y = df_processed['Status']\n","\n","    # 划分训练集和测试集\n","    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n","\n","    print(f\"\\n训练集形状: {X_train.shape}, 测试集形状: {X_test.shape}\")\n","    print(f\"训练集中 'Status' 分布:\\n{y_train.value_counts()}\")\n","    print(f\"测试集中 'Status' 分布:\\n{y_test.value_counts()}\")\n","    print(\"-\" * 50)\n","\n","    # 训练模型\n","    model = train_model(X_train, y_train)\n","\n","    # 评估模型并可视化\n","    evaluate_model(model, X_test, y_test)\n","\n","    # 特征重要性可视化\n","    feature_importance_plot(model, X.columns.tolist())\n","\n","\n","if __name__ == '__main__':\n","    main()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"U4utUXijiSIU","executionInfo":{"status":"ok","timestamp":1748866092662,"user_tz":-480,"elapsed":26756,"user":{"displayName":"Yihan Wang","userId":"09841618405917660021"}},"outputId":"3ea69589-a024-4ac8-a622-c353360678ca"},"execution_count":20,"outputs":[{"output_type":"stream","name":"stdout","text":["数据加载成功，原始形状: (148670, 34)\n","原始数据中 'Status' 列的唯一值及其计数:\n","Status\n","0    112031\n","1     36639\n","Name: count, dtype: int64\n","--------------------------------------------------\n","\n","------- 数据探索性分析 (EDA) 可视化 -------\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 600x500 with 1 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAisAAAHPCAYAAACSk5ohAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAATi9JREFUeJzt3XlYFWX/P/A3oEDKJmJoPCamQrKDIIqmAm6puYUo5sLjlpK4lFsJQYW5UhYparmnj4SaouaGO0JlmT4HBEtEBR5FlHOAw85hfn/4Y74eOShrjPl+XRdXOffMPZ85nBneZ+aeOVqCIAggIiIikijtpi6AiIiI6GkYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWJGbJkiXo1atXU5fxTBMnToS1tbX44+DggP79+2PJkiWQyWR16rO4uBjvvvsunJycMH369AatNyIiAtbW1igpKanVcnK5HF999RWGDRsGFxcX2NnZwdvbG6GhoZDL5Q1aY2OrfA0qf2xtbdG7d2/MnDkTJ06cqDL/xIkT4evr22h1VP4uGms9QNPsT6mpqXB1dcXRo0cBAIIgYOPGjejfv7/4/tm0aVOt+92/fz+sra0xadIkje0RERHw8vKqV+2Pr6fyp2vXrujRowf+/e9/Y9++fVCpVHXqd9euXfDw8IC9vT3u3r1b7zorZWRkwNraGv/5z38apL/4+Hj06tWrXu+bx18/a2trODs7Y/jw4Vi9ejWysrLq1GdqaipGjhwJOzu7Or1/nuZp+2BmZibc3d2xf//+Bl1nbTGsUJ3Z2toiLi4OcXFxOHLkCIKDg1FQUICxY8di27Ztte7v9OnTOHv2LD788EOsWLGi4Qt+zM8///zMA3tpaSkmTJiAn376CYGBgTh06BBiYmLw3nvv4fjx45gyZYp44C4tLYWdnR0yMjJqVUddl6uP06dPIy4uDrGxsVi7di06duyI999/H3PnzkV5ebk4X0RERK0OijV5TQFgypQpiIuLg56eXp3qf5oJEyaoHVSXLl2KQ4cONfh6qlNQUICAgACMHDkSb775JgBg3bp1WLduHWbPno2jR48iMDAQ69atq/MfnN9++00MQo1p165diIuLw9mzZ7Fp0yZ069YNn3/+OSZPnoyCgoJa97d69Wp07doVx44dQ5s2bRqh4v/j6emJX375pVbLqFQqrF27FrNmzYK+vn69a5gwYYJ4fNy3bx+mTJmChIQEvPXWW/j1119r3d/OnTtx48YN/Oc//4Gfn1+963uar7/+GkuWLAEAWFhYYOXKlQgJCcF///vfRl3v0zCsUJ01a9YMbdq0QZs2bdC+fXv07dsXERERmDt3LpYvX46EhIRa9ZeXlwcA6NWrF1q3bt0YJYv++OOPZ86TkJCAGzduIDQ0FIMGDYKFhQVee+01jB49GsuXL4e2tjZu3rwJAJDJZCgrK6t1HXVdrj7MzMzQpk0btGvXDq6urli8eDG2bt2KU6dOYd26deJ8JiYmMDExqXG/NXlNAaBly5aN8seqvLwciYmJatMMDQ1hamra4OuqzubNmyGXyzF37lwAQFFRETZv3gx/f3+MHDkS7du3x8iRIzFp0iRs2rSp1mf6AGDs2LFYtWoViouLG7p8Na1atUKbNm1gbm4OBwcHzJ49Gz/88ANSUlLwySef1Kqv0tJSFBUVwcnJCRYWFmjWrFkjVQ1kZWXhf//7X62XS01NRUxMDL7//nu4ubnVu46XXnpJPD6+9tprGDlyJKKiouDs7IzZs2fX+sxsXl4eXn75Zdjb28PQ0LDe9T3Nk/tyv3794O7ujmXLljXqep+GYeU5debMGfj6+sLBwQFOTk7w8/PDxYsX1eb573//i6lTp8LFxQUODg4YMmQI9uzZozaPl5cXli1bhl27dsHb2xtOTk7w8fGpV4KePn06LC0t1T45lpaW4quvvsLQoUPh4OCAvn37Ys2aNSgtLQXw6HR9SEgIAMDb2xsTJ04EAKSlpSEwMBDdu3eHnZ0dBgwYgMjISFRUVIh9azqF+csvv8Da2hrnz5+vUt+SJUuwdu1aZGZmwtraGhERERq3o/IPSWWNj+vXrx/27duHLl26YP/+/Rg/fnyV2gsKChAWFoY33ngDtra26NOnDz766CPxIFXdcl5eXpg/f77a+ipPzaempgJ4dGp23rx56NWrF+zt7dG/f39ERETU+RS9m5sbRowYgW3btonb++TrevLkSbz99ttwcXGBi4sLxo0bh/j4eACaX9PK0/PR0dEYN24c7OzskJ+fX+0luaNHj2LQoEGws7PD4MGDcebMGbGtumWsra2xZs0aZGRkwNbWFkVFRfjwww9hbW0t1vX46XxBEPDdd9+J6+nevTsCAwNx+/ZttXW5urri+vXrGD9+PJycnNCvX79nnglRKpXYunUrJkyYIP4xuXz5MgoLC9G3b1+1efv06YP8/HxcvnwZQNXf79PMnTsXhYWF2Lhx4zPnrclxojY6deqEKVOmICYmRu1Szvnz5zFhwgR0794dLi4umD59urgtv/zyC+zt7QEA33zzDaytrZGRkYHy8nJ89dVX8Pb2hq2tLXr16oU5c+aonWWs7nXRtI9UrqtPnz4AgEmTJtXqspi5uTn2798v1lqdyvdcXTRv3hwhISHIz89XOxZnZ2dj0aJF8PLygr29PYYOHYq9e/eK7V5eXjhy5EiVY9b58+fh5+cHJycnODs7Y9SoUVUu6Wqq92mXxb28vBAfH48ff/wR1tbW4hmqgIAAXLlyBefOnavTttcXw8pzKD4+HrNmzcLrr7+OvXv3IioqCubm5pgxYwaSkpIAPDpw/vvf/0azZs3www8/4KeffoKfnx9CQkJw+vRptf4uXLiAq1evYsOGDdixYwdyc3OxaNGiOtenra0NT09PXLp0Sbys8Mknn2Dz5s2YPHkyDh8+jMWLFyM6OloMKEuXLsWCBQsAANHR0YiIiIAgCJgxYwbu3r2Lbdu24fjx45g7dy7WrVuHXbt21bm+pUuXwtvbG23btkVcXBymTJmicb5u3bqhZcuWeP/99/Htt9+q/UF73JAhQ6rUDgBhYWE4dOgQVqxYgdjYWISHh+OXX37Bxx9//NTlamLhwoXIycnBt99+i+PHj+ODDz7A9u3bsXnz5hr38SRvb28UFhbi6tWrVdrS0tIwb948DBo0CAcPHkR0dDTs7OzE38/TXtPNmzfDx8cHJ06cQMuWLTWuOzMzE1FRUVi9ejX27dsHCwsLzJkzp8ZjG9q1aye+Jz766CPExcVpnO/rr7/G2rVrMX78eBw+fBjr16/H7du3q1zaKC8vR1hYGN577z3ExMTgjTfeQHh4OK5cuVJtDRcvXkRhYaHaH8i0tDQAwKuvvqo2b+W/K8/MDRkyBHFxcbC0tHzmtpqYmGDu3LnYvHkz0tPTq52vJseJuvD29oYgCOIfsV9//RXvvvsuXn75ZezevRvbt28XL6Hm5OTA2dlZPOZUXgJs164dNmzYgG+//RYLFy5EbGwsIiMjkZmZiTlz5tS5NmdnZ4SHhwN49Af58T/4z2JsbFyjM4lxcXGYNWtWXUvEK6+8gq5du4pnnktLSzF58mT8/vvvCA0NxaFDhzBixAgEBQXhwIEDAIC9e/dW2b/u3LmDgIAAvPbaazhw4AAOHjyI3r17Y968ebh27Vqd69u7dy9MTU3x5ptvIi4uDs7OzgAevbampqaIjY2tc9/1wbDyHNq8eTM6deqETz75BFZWVrC2tsaqVatgYGCA3bt3AwD09fWxb98+rFq1Cp07d8a//vUvTJw4EWZmZrhw4YJaf0qlEmFhYejSpQscHBwwYsQIpKWlQalU1rnGdu3aoaysDAqFAllZWdi/fz+mTZsGX19fvPrqqxgyZAhmzZqFH3/8EVlZWTA0NISBgQEAwNTUVDxobNmyBRs2bICNjQ0sLCwwbNgw2NjYVNmG2jA0NISenh50dHTQpk2bav+Atm7dGps2bYKZmRnWrFmDgQMHok+fPli8eDFOnz4NQRAAPHqtNdU+f/587N27F7169UK7du3g5uYmHgAEQah2uZpISkpC7969YWNjg1deeQVvvvkm9uzZg6FDh9b5dXnllVcAPPqU96Tk5GSUl5dj9OjRaN++PTp16oQPP/wQO3fuhJGR0VNfUysrK/j4+OCVV16BtrbmQ05OTg5WrVoFBwcHWFtbY9myZSgtLcXx48drVLuOjg5atWoF4NHvV9NlptLSUmzfvh0+Pj6YPHkyLC0t4erqis8//xx3795VOwgXFRVhypQp6NWrF1599VXxj9PTzjheunQJLVq0gK2trTitch968j1W+XuvbNfX10ebNm2go6NTo+0dO3YsOnbs+NSxXTU5TtRF5fvk/v37AIBNmzbBwsICq1evRufOnWFvb4/w8HAolUr88MMP0NXVhZmZGQCgRYsW4naOHz8eMTExGDx4MNq1awcHBwf4+PggKSkJOTk5dapNV1cXRkZGAB6Fj8a4BPi0Y0ZNtWvXTtzPYmNjkZqaimXLlqFPnz6wtLTEjBkz4OXlhcjISACPjg9P7l/m5uY4ePAgli5dCktLS7z66quYPXs2VCqVeMazLkxNTaGtrS2+J3V1dQEAWlpa6NatW53G2zSExrtwSI1GJpNh8ODB0NLSEqfp6urCzs5OTNTNmjXDvXv3sGLFCqSkpCA3NxfAo4OwQqFQ68/W1lZ8QwIQd/Dc3FzxoFpblWdUdHR0cPXqVVRUVFQZXd+zZ08IgoBr167B3Ny8Sh9aWlrIy8vDF198gatXr0KhUEAQBBQXFz/zVG1Dqbyr4/Lly0hISMCvv/6KI0eO4MCBA3B3d8e3335b7UBRbW1t7Ny5E+fPn8eDBw+gUqlQVlaGsrIylJaW1muAqbe3N7755hvcv38fffv2hZubGzp37lzn/gCIY2c0/cF0cXGBqakpJkyYgLFjx6Jnz554/fXXxU9dT2NnZ/fMedq3b4+XX35Z/Hfbtm1hYmIinnloCDdv3kRBQQFcXV3VptvY2EBPTw/Xrl3DiBEjxOmOjo7i/1fuE5XjqjS5f/8+zMzM1PbLxqKjo4Pg4GC88847uHjxosY7V2pynKiLyvdJ5biT//73vxg4cKDa+8bMzAxdunR56nr09PQQExODU6dOISsrC2VlZeJxQy6X/61jjf5u5eXl4ut39epVNG/eHN27d1ebp2fPnjh16hQKCgo0hiM9PT3cuHEDn376KVJTU9XODD55jG8obdq0qVcQqg+GleeQUqnUGCJatmwpnhaWyWSYMmUKXF1dsXz5cpibm0NHR0ccF/G4Fi1aqP278uBWeeagLm7fvg0DAwOYmJiInx6nTJmi9sm6sn9Nn+QB4O7du5gwYQI6dOiAjz/+GO3bt0ezZs3ESyd/F21tbbi6uop/5BQKBdauXYv//Oc/+M9//gN/f/8qywiCgKlTp+Lu3btYsmQJ7OzsoKenh507d2Lnzp31rmnlypXYs2cPDh06hF27dkFXVxdDhw7Fhx9+WOfBd5WXuSwsLKq0tW3bFtHR0di8eTO2bduGFStWwMLCArNmzcKYMWOe2m9N6qn8NPy4l156CYWFhTWs/tkq34dP1qOtrY0WLVpUucPl8T8QNdkn8vPzq/Rd+W+lUqm2n1XWomm7a8rV1RVDhw5FWFgYYmJiqrTX5DhRF0++T5RKJQ4cOIAjR46ozVdSUqL2IehJCxYsQFxcHBYsWAB3d3e89NJLOHHiRJ3HgzxPbt26hY4dOwJ49PqVlZWhW7duavNUBrfs7GyNYeXkyZOYM2cOBg8ejLVr14pBeeDAgY1Wt5GREQoKCqBSqWp8FrChMKw8hwwNDTVeolEqleLB8ciRI9DW1sb69evFA1ZFRYV4hqUxlZaW4vTp0+jVqxe0tLRgbGwMAFizZg2srKyqzF/dJ6jY2FgUFhbiiy++wGuvvSZOz8vLE/us9OQfkYb6I5eXl1flD4qJiQlCQkJw9OhRXL9+XeNyf/75p3jXxOjRo8XpmgbravKs7WnevDkmTpyIiRMnQqFQ4OTJk1i9ejXKy8uxatWqGq3jScePH4eZmRlsbGw0tv/rX/9CSEgIQkJC8Ndff2Hnzp0ICgrCv/71L/Ts2bNO66yk6VbYwsJC8SCtKSzU9vbZyt9jfn6+2vSKigoUFBTU+w4LQ0PDKregV75v79y5o3bmqHIsS33Phi1atAhvvvmmxgBck+NEXRw/fhy6urpwd3cH8Oh17d27NwIDA6vMW11YUSqVOHPmDKZPn47JkyeL0x8fOA+g2rNUdbl1WiquX7+OW7duic/LMTIygr6+vjg+5Unt2rXTOD0mJgbm5ub48ssvxQ+BlZfmntRQx8e8vDy0bNnybw8qAMesPJccHR3x+++/q70BS0pKkJiYKF4eKSsrg66urtonq59++gnFxcX1OmNSE1988QVycnIwbdo0AI8uA+jo6OB///sfOnToIP60adMG2tra1R44K083Px5mLl++jFu3bqltg5GRUZVr3E8bCFnpWa/DrFmz4OPjo3HEvFwuR35+fpXLV5V9aqpdqVSKI/WfXHdttkehUODgwYPinT8mJiYYM2YMhg8fjuTk5KduU3VOnTqFkydPYvr06RrHlSQnJ6vdit6lSxd8+umnMDAwQEpKisbtqI3bt2+rPSwrIyMDubm56NKlC4D/O0Px+OuiaSDw02ro2LEjDA0NcenSJbXpiYmJKC0trfelxZdffhkPHjxQ+4PbrVs3GBoaVhnUHhsbCxMTEzg5OdVrnW3btsWMGTOwbt26Kmcoa3KcqC2ZTIZdu3Zh7Nix4hgrJycnpKamqu3bHTp0QHl5ebW3qJeVlUEQBLX9Q6VSVTlDpOn3fvv27Rpd5mjs41xdlJSUIDQ0FC+//DJGjRoF4NHrV1xcjKKiIrXXT19fH0ZGRtUGvrKyMhgbG6vtrz/++COA2h1PqqPp9cvOzm70Z+RUh2FFgioqKpCdnV3lp/J6+bRp03Dz5k2EhoYiNTUVycnJmD9/PkpKSsTLPE5OTigoKMC2bduQkZGB/fv3Y9euXXBycsJff/3VIA8hKy8vF2u7d+8efv75ZwQGBmL79u0IDg6Gg4MDgEfXr318fPDNN9/gwIEDSE9Px9WrVzFnzhxMmDABRUVFGvuvPJBv3LgRGRkZiI2NxaeffgpPT0+kp6cjLS0NFRUVcHBwQEZGBn744Qekp6dj//79z7y9zsjICNnZ2fjtt9+qPSU+Y8YMZGdnY/LkyYiNjUVaWhpu376NEydOYMqUKTA1NRUfzlR5pufcuXO4fv06XnvtNRgbG2PXrl1IS0vDlStXMG3aNPTv3x/Ao1ssi4qKqiwHAA4ODrh8+TJiY2Nx584dbNu2Te3uDUEQEBoaiqCgIKSkpODu3buIj4/H6dOnq1z31uTBgwfIzs7G/fv3kZSUhNWrV2Pu3LkYNmyY2qfcx125cgUBAQHYt28f0tPTkZ6eji1btqCwsFA8fV2T17Q6JiYm+Oijj5CUlISUlBQEBQWhRYsWGDRokPiaAMCGDRtw584dJCQkICIiQi2MV76Wv/76K1JSUqo8h6R58+biU1h37dqF9PR0JCQkYMmSJXjttdfE301dubm5obCwUO13pauri4CAAOzcuRMHDhxAZmYm9u/fjz179mDOnDlo3rw5gEdPb87Ozq7TredTp05Fq1atqjxhtCbHiaeRy+Xi/n39+nVs2LABkyZNgouLCxYuXKi2nuvXryM0NBQpKSm4desWNm3ahLfeeqva/bBVq1awtLTE/v37cf36dSQnJ2PWrFnie+nSpUtQKpWwsbFBs2bNsHnzZnE/CgoK0jjGrVLl++DixYu4du0aBEHAyZMnMXjw4Ke+LwsKCsTtLS4uVjsOP342Ljs7u0ZndoqKisTl09PTcezYMYwdOxY3b95ERESEeFnQ09MTVlZWWLBgAeLj45GZmYlz585hwoQJCA4OrrZ/Jycn3LhxAz/99BPS09OxefNmXL16Fe3atcO1a9fEsywODg44ffo0fv75Z6SlpSE8PPyZA5iNjIxw7do1JCcn48GDBwAeHXd+++23Gh1jGoVAkrJ48WLByspK48+sWbPE+c6cOSO8/fbbgr29veDk5CRMnjxZuHLlitiuUqmEZcuWCT169BCcnZ2FmTNnCvfu3ROOHDkiODs7C97e3oIgCIKnp6cwb948tRp2794tWFlZCenp6dXWOWHCBLXaXn/9dcHDw0OYM2eOcPXq1Srzl5WVCREREYKXl5dgY2MjuLm5CfPnzxfu3Lnz1PVu3LhR6N27t+Dk5CRMnDhRuHHjhnDp0iXB3d1d6N69u5CXlycUFBQIH3zwgeDm5iY4OzsLgYGBwqVLlwQrKyvh3LlzgiAIwtdffy1YWVkJxcXFgiAIQnJysuDl5SXY2toKYWFh1W7n9evXhY8++kjo37+/4OjoKNja2goDBgwQPvnkE+HevXvifEqlUhg3bpxga2srjBo1ShAEQTh37pwwePBgwd7eXhg2bJgQGxsrPHz4UBgyZIjg4OAgxMXFaVwuOztbmDFjhuDi4iK4ubkJQUFBwvHjxwUrKyvhxo0bgiAIwh9//CH4+/sLrq6ugp2dndC/f39h5cqV4vZpUvkaPP7TrVs3YeLEicKRI0c0/o7HjBkj/nvz5s3C4MGDBQcHB6Fbt27C2LFjhePHj4vtT76m6enpgpWVlbB7926NdVTWOmHCBGHSpEnCoUOHhAEDBgi2trbC0KFDhYsXL6otFxkZKfTu3Vuwt7cXfH19BZlMJnh4eAirV68W5wkNDRXs7e2F7t27C//73/+ExYsXCx4eHmJ7RUWF8O233woDBgwQbGxsBHd3d2HBggVCVlZWtfUJgiAUFxcLVlZWwtdff13t65ufny84OTkJX331VZW2rVu3Ct7e3uL75/vvv1dr37dvn9rvV5PKeTQ5efKkYGVlJXh6eqpNf9Zx4mnrefzHyclJ8PX1FXbv3i2UlZVVWebixYvCuHHjBAcHB8HOzk54++23hWPHjontml6/q1evCqNGjRLs7e2F/v37Cz/88INQUlIi7g/R0dGCIAjC3r17BU9PT8HOzk4YNmyYcOHCBWHMmDHicevJ95lKpRJmzZol2NraCj179hTKy8vFbbp582a1261p/6j8Wbx4sTiflZWV2ntOkyeXt7W1Fby9vYXPPvtMuHv3bpX5Hzx4ICxZskTo0aOH0LVrV+GNN94QVqxYIRQWForzzJs3T+33W1BQICxcuFBwdXUV3NzchEWLFgn5+fnCli1bBAcHB2HixImCIAjCzZs3hXfeeUdwcnISevbsKaxZs0b4/vvvq+yDj+/rP/74o+Dq6io4OjoKP/30kyAIgvD7778LVlZWwtmzZ5+67Y1FSxAkeK6MiOg5VDnw+tSpU3W+k44ax9ixYxEZGfmPvsuoMc2YMQNyuRzR0dFNsn5eBiIiaiDTpk2DsbExvvrqq6YuhR6TmpoKLS0tBpU6On/+PBISEhAUFNRkNfDMChFRA0pNTcXYsWMRFhaGwYMHN3U5RPWSmZmJ0aNHY9GiRXj77bebrA6GFSIiIpI0XgYiIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSeN3AzWA7Oz8Z89EREREVbRp8+zvquKZFSIiIpI0hhUiIiKSNIYVIiIikjSGFSIiIpI0hhUiIiKSNIYVIiIikjSGFSIiIpI0hhUiIiKSNIYVIiIikjSGFSIiIpI0hhUiIiKSNIYVIiIikjSGFSIiIpI0hhUiIiKSNIYVIiIikjSGFSIiIpI0hhUiIiKStGZNXQA93bm04qYugajR9e2o39QlEJGE8cwKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUlak4eVCxcuwMPDA/Pnz6/S9tNPP+Gtt96Cs7MzRo8ejbi4OLGtoqICX375Jby9veHm5oapU6ciPT1dbFcoFJg3bx48PDzQu3dvLF26FMXFxWJ7cnIyJkyYgG7dumHgwIHYsmVLjddNREREf58mDSvffvstwsLC0KFDhyptycnJWLx4MRYsWICff/4Z/v7+mD17Nu7duwcA2LVrFw4dOoRNmzbhzJkzsLS0xHvvvQdBEAAAwcHBKCoqwuHDh7Fv3z6kpqZizZo1AIDi4mK8++676NGjBy5cuIAvv/wSGzduxIkTJ2q0biIiIvr7NGlY0dPTw969ezWGlejoaPTt2xd9+/aFnp4ehg8fDisrK8TExAAAoqKi4O/vj06dOsHAwADz589Hamoqrl69igcPHiA2Nhbz58+HqakpzM3NERAQgH379qGsrAxnz55FWVkZZs2ahRYtWsDW1hZjxoxBVFRUjdatiZZW4/wQvQgaa//hD3/4I/2fmmjWuIegp5s0aVK1bUlJSejbt6/aNBsbG8hkMhQXF+PGjRuwsbER2wwMDNChQwfIZDLk5+dDR0cH1tbWYrutrS0KCwtx8+ZNJCUlwdraGjo6Omp9R0dHP3PdmpiatoSOTiPlvpvFz56H6DlnZmbY1CUQkYQ1aVh5GoVCAWNjY7VpxsbGuHHjBnJzcyEIgsZ2uVwOExMTGBgYQOuxyFY5r1wuh0KhgJGRkdqyJiYmUCgUqKioeOq6NcnJKahxOiSiqh48yG/qEoioidTkw4pkwwoAcfxJXdqftawmj4eb2i5fh9UR0f/H/YeInqbJ7waqTqtWraBQKNSmKRQKmJqawsTEBNra2hrbW7duDVNTUyiVSqhUKrU2AGK7XC6vsmxlv09bNxEREf29JBtW7OzskJiYqDZNJpPB0dERenp66NKlC5KSksS2vLw83LlzBw4ODujatSsEQUBKSoraskZGRujYsSPs7Oxw/fp1lJeXV+n7WesmIiKiv5dkw4qvry/i4+Nx9uxZlJSUYO/evbh16xaGDx8OAPDz88OOHTuQmpoKpVKJNWvWoGvXrrC3t4epqSkGDRqEtWvXIicnB/fu3cO6devg4+ODZs2aoW/fvjAwMEBkZCSKiopw9epV7N27F35+fjVaNxEREf19tIS6DO5oIPb29gAgnuFo1uzREJrKu25OnDiB8PBwZGZmonPnzli6dCnc3NwAPBpTEhERgT179qCgoADu7u749NNP0bZtWwBAfn4+QkJCcObMGTRv3hzDhg3DkiVLoKurCwD4888/ERISgsTERJiZmWH69OkYP368WNvT1v2k7OzGGxx4Lo13A9E/X9+O+k1dAhE1kTZtnj3AtknDyj8FwwpR/TCsEL24ahJWJHsZiIiIiAhgWCEiIiKJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSWNYISIiIkljWCEiIiJJY1ghIiIiSZN0WLl27RomTZoEV1dX9OrVCwsWLEBOTg4AICEhAT4+PnBxccHQoUMRExOjtuyOHTswaNAguLi4wM/PD4mJiWJbSUkJPv74Y/Tp0wfu7u6YM2cO5HK52J6ZmYkZM2bA3d0dnp6eWL16NSoqKv6ejSYiIiI1kg0r5eXlmDFjBpycnBAfH4/Dhw8jJycHoaGhuH//PgICAjBu3DgkJCRg6dKlCA4OhkwmAwCcPn0aERERWLVqFeLj4+Hp6YmZM2eisLAQAPDll18iKSkJUVFROH78OARBwIcffiiuOzAwEObm5oiNjcXWrVsRGxuL7du3N8nrQERE9KKTbFjJzs5GdnY2RowYAV1dXbRq1QoDBgxAcnIyDh06BEtLS/j4+EBPTw8eHh7w8vJCdHQ0ACAqKgqjR4+Go6Mj9PX1MW3aNADAmTNnUF5ejr179yIgIADt2rWDiYkJ5s2bh7NnzyIrKwsymQwpKSlYsGABDA0NYWlpCX9/f0RFRTXly0FERPTCatbUBVTH3NwcXbt2RVRUFObOnYvi4mKcOHEC/fr1Q1JSEmxsbNTmt7GxwdGjRwEASUlJGDJkiNimra2Nrl27QiaToWvXrsjPz4etra3Y3qlTJ+jr6yMpKQn379+HhYUFjI2NxXZbW1ukpaVBqVTCwMBAY71aWg259UQvFu4/RPQ0kg0r2traiIiIgL+/v3gJpnv37vjggw8QEBAAc3NztflNTEzEcScKhUItbACAsbEx5HI5FAoFAMDIyEit3cjISGx/sq2yL7lcrjGsmJq2hI5OI52kulncOP0SSYiZmWFTl0BEEibZsFJaWoqZM2di8ODB4niTTz75BAsWLKjR8oIg1Ln9Wcs+KSengJ8MierhwYP8pi6BiJpITT6sSDasJCQkICMjA++//z50dHRgaGiIOXPmYMSIEXjjjTfEMySV5HI5TE1NAQCtWrWq0q5QKNClSxdxHoVCgZYtW4rtubm5aN26NVQqlcZltbS0xGU1qWW+IaLHcP8hoqeR7ABblUqFiooKtbMcpaWlAAAPDw+1W5EBIDExEY6OjgAAOzs7JCUlqfV17do1ODo6on379jA2NlZr//PPP1FaWgo7OzvY2dnh7t274i3SACCTydC5c2e1cENERER/D8mGFWdnZ7Ro0QIREREoKiqCXC5HZGQk3NzcMGLECGRmZiI6OholJSU4d+4czp07B19fXwCAn58fDhw4gCtXrqCoqAiRkZHQ1dVFv379oKOjA19fX2zYsAF3796FXC7HF198gQEDBsDMzAw2Njawt7dHeHg4lEolUlNTsXXrVvj5+TXxK0JERPRi0hJqO0Djb5SYmIiVK1ciJSUFurq66N69O5YsWQJzc3NcunQJYWFhSE1NhYWFBT744AMMHDhQXHb37t3YtGkTHj58CHt7e4SGhsLKygrAozM0y5cvx5EjR1BeXg5PT0+EhobC0PDRdbN79+4hODgYv/76KwwMDDBu3DjMnj0bWtUMTMnObrzr7efSOMCW/vn6dtRv6hKIqIm0afPsMSuSDivPC4YVovphWCF6cdUkrEj2MhARERERwLBCREREEsewQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLGsEJERESSxrBCREREksawQkRERJLW4GFFEISG7pKIiIheYHUKK4MGDdI4PS8vDx4eHvUqiIiIiOhxzWozc0JCAuLj45GZmYkvvviiSntGRgZKS0sbrDgiIiKiWoUVY2NjFBYWQqVS4Y8//qjSrq+vj7CwsAYrjoiIiKhWYcXGxgY2NjbQ0tJCUFBQY9VEREREJNIS6jgiViaTITU1FSUlJVXaxo4dW+/CnifZ2fmN1ve5tOJG65tIKvp21G/qEoioibRpY/jMeWp1ZqXS559/jh07dsDU1BT6+uoHGS0trRcurBAREVHjqVNYOXDgALZu3YqePXs2dD1EREREaup067Kuri5cXV0buhYiIiKiKuoUVvz9/bFly5aGrkWjyMhI9O7dG05OTvD390dGRgaAR7dR+/j4wMXFBUOHDkVMTIzacjt27MCgQYPg4uICPz8/JCYmim0lJSX4+OOP0adPH7i7u2POnDmQy+Vie2ZmJmbMmAF3d3d4enpi9erVqKio+Fu2l4iIiNTVKaxcvnwZW7duRe/eveHr64tx48ap/TSUXbt2ISYmBjt27EBcXBw6d+6Mbdu24f79+wgICMC4ceOQkJCApUuXIjg4GDKZDABw+vRpREREYNWqVYiPj4enpydmzpyJwsJCAMCXX36JpKQkREVF4fjx4xAEAR9++KG43sDAQJibmyM2NhZbt25FbGwstm/f3mDbRURERDVXpzErlbcwN7YtW7Zg8eLFeO211wBAvF168+bNsLS0hI+PDwDAw8MDXl5eiI6Ohr29PaKiojB69Gg4OjoCAKZNm4YdO3bgzJkzGDRoEPbu3YuVK1eiXbt2AIB58+Zh6NChyMrKwv3795GSkoKtW7fC0NAQhoaG8Pf3x/bt2/Hvf/+70beZiIiI1NUprMyePbuh66giKysLGRkZyM3NxZAhQ/Dw4UO4u7sjNDQUSUlJVcKSjY0Njh49CgBISkrCkCFDxDZtbW107doVMpkMXbt2RX5+PmxtbcX2Tp06QV9fH0lJSbh//z4sLCxgbGwsttva2iItLQ1KpRIGBgYa69XSasitJ3qxcP8hoqepU1j55ptvntreEGHm3r17AIBjx45h69atEAQBc+bMQVBQEIqLi2Fubq42v4mJiTjuRKFQqIUN4NHTd+VyORQKBQDAyMhIrd3IyEhsf7Ktsi+5XK4xrJiatoSOTiN9gfVNPmeF/vnMzJ79nAUienHVKaxcuHBB7d8qlQqZmZkQBAEuLi4NUljls+qmTZsmBpPAwEBMnz69Rl+W+Kxn3T2tvbbPycvJKeAnQ6J6ePCg8R6sSETSVpMPK3UKK1FRUVWmVVRUYMOGDdDV1a1Ll1WYmZkBUD8DYmFhAUEQUFZWJp4hqSSXy2FqagoAaNWqVZV2hUKBLl26iPMoFAq0bNlSbM/NzUXr1q2hUqk0LqulpSUuq0ndngNMRAD3HyJ6uga7dqGtrY3p06c32C3Nbdu2hYGBAZKTk8VpmZmZaN68Ofr27at2KzIAJCYmigNq7ezskJSUJLapVCpcu3YNjo6OaN++PYyNjdXa//zzT5SWlsLOzg52dna4e/cucnJyxHaZTIbOnTurhRsiIiL6ezToQItLly6hvLy8Qfpq1qwZfHx8sGHDBty+fRsPHz7EunXr8NZbb2HUqFHIzMxEdHQ0SkpKcO7cOZw7dw6+vr4AAD8/Pxw4cABXrlxBUVERIiMjoauri379+kFHRwe+vr7YsGED7t69C7lcji+++AIDBgyAmZkZbGxsYG9vj/DwcCiVSqSmpmLr1q3w8/NrkO0iIiKi2qnTZaDevXtXmVZcXIyCggL4+/vXtybRBx98gNLSUowZMwZlZWUYNGgQgoKC0LJlS2zcuBFhYWH45JNPYGFhgdWrV+P1118HAPTp0wfvv/8+5s2bh4cPH8Le3h6bNm0Sv8dozpw5KCgowIgRI1BeXg5PT0+EhoaK6/36668RHByMXr16wcDAAOPGjcP48eMbbLuIiIio5ur0rcs//vhjlWl6enro0KGD2i3BLwp+6zJR/fBbl4leXI32rcujRo0CAJSVleH+/fvQ0tKCubk5dHR06tIdERERUbXqFFby8vIQEhKC2NhYcYyKnp4ehg0bhuDgYOjp6TVokURERPTiqlNYCQ0NRXZ2Nr755ht06NABAJCamooNGzZgzZo1WLp0aYMWSURERC+uOo1ZcXNzw/Hjx6s8dyQrKwvjxo3DmTNnGqzA5wHHrBDVD8esEL24ajJmpU63Luvo6OCll16qMt3IyEj8ZmMiIiKihlCnsOLi4oJPP/1U7cFpOTk5+Oyzz2Bvb99gxRERERHVacxKSEgIZs2ahV69eomPw8/NzUWnTp0QGRnZoAUSERHRi63WYaW0tBSlpaXYv38/UlJSkJGRgdLSUrz88stwdnbm7ctERETUoGoVVnJzczF+/Hg4Ojri888/x+uvvy4+NXb06NFo2bIlNm/e3GBfZkhERERUqzEr33zzDUxNTREUFFSlbdeuXRAEAd9++22DFUdERERUq7By5swZLF26FC1atKjS9tJLL2Hp0qU4fPhwgxVHREREVKuw8vDhQ1hbW1fb/vrrr+PevXv1LoqIiIioUq3CSosWLSCXy6ttv3//vsbnrxARERHVVa3CSs+ePbFt27Zq21etWoUePXrUtyYiIiIiUa3uBnrvvffg4+OD9PR0vPPOO+jYsSNUKhVu3LiBLVu24OrVq/jhhx8aq1YiIiJ6AdUqrHTs2BHff/89PvvsM0yYMAFaWloAAEEQ0L17d3z//ffo2LFjoxRKREREL6Y6fZEh8Ojx+unp6dDS0sKrr74KExOTBi7t+cEvMiSqH36RIdGLqyZfZFinx+0DgKmpaZVvXSYiIiJqaHX6IkMiIiKivwvDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSRrDChEREUkawwoRERFJGsMKERERSdpzE1Y+//xzWFtbi/9OSEiAj48PXFxcMHToUMTExKjNv2PHDgwaNAguLi7w8/NDYmKi2FZSUoKPP/4Yffr0gbu7O+bMmQO5XC62Z2ZmYsaMGXB3d4enpydWr16NioqKxt9IIiIiquK5CCvJyck4ePCg+O/79+8jICAA48aNQ0JCApYuXYrg4GDIZDIAwOnTpxEREYFVq1YhPj4enp6emDlzJgoLCwEAX375JZKSkhAVFYXjx49DEAR8+OGHYv+BgYEwNzdHbGwstm7ditjYWGzfvv3v3WgiIiIC8ByElYqKCoSEhMDf31+cdujQIVhaWsLHxwd6enrw8PCAl5cXoqOjAQBRUVEYPXo0HB0doa+vj2nTpgEAzpw5g/LycuzduxcBAQFo164dTExMMG/ePJw9exZZWVmQyWRISUnBggULYGhoCEtLS/j7+yMqKqopNp+IiOiF16ypC3iWPXv2QE9PD2+99RbWrl0LAEhKSoKNjY3afDY2Njh69KjYPmTIELFNW1sbXbt2hUwmQ9euXZGfnw9bW1uxvVOnTtDX10dSUhLu378PCwsLGBsbi+22trZIS0uDUqmEgYGBxjq1tBpqi4lePNx/iOhpJB1WHjx4gIiICOzcuVNtukKhgLm5udo0ExMTcdyJQqFQCxsAYGxsDLlcDoVCAQAwMjJSazcyMhLbn2yr7Esul2sMK6amLaGj00gnqW4WN06/RBJiZmbY1CUQkYRJOqwsX74co0ePRufOnZGRkVGrZQVBqHP7s5Z9Uk5OAT8ZEtXDgwf5TV0CETWRmnxYkWxYSUhIwB9//IHDhw9XaWvVqpV4hqSSXC6Hqalpte0KhQJdunQR51EoFGjZsqXYnpubi9atW0OlUmlcVktLS1xWk1rmGyJ6DPcfInoayQ6wjYmJwcOHD+Hp6Ql3d3eMHj0aAODu7g4rKyu1W5EBIDExEY6OjgAAOzs7JCUliW0qlQrXrl2Do6Mj2rdvD2NjY7X2P//8E6WlpbCzs4OdnR3u3r2LnJwcsV0mk6Fz585q4YaIiIj+HpINK0uWLMHx48dx8OBBHDx4EJs2bQIAHDx4EG+99RYyMzMRHR2NkpISnDt3DufOnYOvry8AwM/PDwcOHMCVK1dQVFSEyMhI6Orqol+/ftDR0YGvry82bNiAu3fvQi6X44svvsCAAQNgZmYGGxsb2NvbIzw8HEqlEqmpqdi6dSv8/Pya8uUgIiJ6YWkJtR2g0UQyMjLg7e2N69evAwAuXbqEsLAwpKamwsLCAh988AEGDhwozr97925s2rQJDx8+hL29PUJDQ2FlZQUAKC0txfLly3HkyBGUl5fD09MToaGhMDR8dN3s3r17CA4Oxq+//goDAwOMGzcOs2fPhlY1A1Oysxvvevu5NA6wpX++vh31m7oEImoibdo8e8zKcxNWpIxhhah+GFaIXlw1CSuSvQxEREREBDCsEBERkcQxrBAREZGkMawQERGRpEn2oXBERM+D5r9va+oSiBpdWTf/Jl0/z6wQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpDGsEBERkaQxrBAREZGkMawQERGRpEk6rGRmZuK9996Du7s7PDw8sGTJEuTl5QEAkpOTMWHCBHTr1g0DBw7Eli1b1Jb96aef8NZbb8HZ2RmjR49GXFyc2FZRUYEvv/wS3t7ecHNzw9SpU5Geni62KxQKzJs3Dx4eHujduzeWLl2K4uLiv2ejiYiISI2kw8rMmTNhZGSE06dPY//+/fjrr7+wcuVKFBcX491330WPHj1w4cIFfPnll9i4cSNOnDgB4FGQWbx4MRYsWICff/4Z/v7+mD17Nu7duwcA2LVrFw4dOoRNmzbhzJkzsLS0xHvvvQdBEAAAwcHBKCoqwuHDh7Fv3z6kpqZizZo1TfY6EBERvcgkG1by8vJgZ2eHDz74AC1btkTbtm0xatQo/Pbbbzh79izKysowa9YstGjRAra2thgzZgyioqIAANHR0ejbty/69u0LPT09DB8+HFZWVoiJiQEAREVFwd/fH506dYKBgQHmz5+P1NRUXL16FQ8ePEBsbCzmz58PU1NTmJubIyAgAPv27UNZWVlTviREREQvpGZNXUB1jIyMsHz5crVpd+/excsvv4ykpCRYW1tDR0dHbLOxsUF0dDQAICkpCX379lVb1sbGBjKZDMXFxbhx4wZsbGzENgMDA3To0AEymQz5+fnQ0dGBtbW12G5ra4vCwkLcvHlTbfrjtLTqvclELyzuP0TS1tT7qGTDypNkMhm+//57REZG4ujRozAyMlJrNzExgUKhQEVFBRQKBYyNjdXajY2NcePGDeTm5kIQBI3tcrkcJiYmMDAwgNZjv5nKeeVyucbaTE1bQkenkU5S3eRYGfrnMzMzbOoS6kzR1AUQ/Q2aeh99LsLK77//jlmzZuGDDz6Ah4cHjh49qnG+xwNG5fiT6jyt/VnLPiknp6DJUyfR8+zBg/ymLqHOnouDKFE9NeY+WpMgJPn97PTp01i4cCGCg4MxcuRIAICpqSlu3bqlNp9CoYCJiQm0tbXRqlUrKBSKKu2mpqbiPJraW7duDVNTUyiVSqhUKvEyU+W8rVu3rrbOWuYbInoM9x8iaWvqfVSyA2wB4PLly1i8eDG++uorMagAgJ2dHa5fv47y8nJxmkwmg6Ojo9iemJio1ldlu56eHrp06YKkpCSxLS8vD3fu3IGDgwO6du0KQRCQkpKitqyRkRE6duzYSFtKRERE1ZFsWCkvL0dQUBAWLFiA3r17q7X17dsXBgYGiIyMRFFREa5evYq9e/fCz88PAODr64v4+HicPXsWJSUl2Lt3L27duoXhw4cDAPz8/LBjxw6kpqZCqVRizZo16Nq1K+zt7WFqaopBgwZh7dq1yMnJwb1797Bu3Tr4+PigWTPJn4giIiL6x9ESajtA42/y22+/4Z133oGurm6VtmPHjqGgoAAhISFITEyEmZkZpk+fjvHjx4vznDhxAuHh4cjMzETnzp2xdOlSuLm5AXg0JiUiIgJ79uxBQUEB3N3d8emnn6Jt27YAgPz8fISEhODMmTNo3rw5hg0bhiVLlmisBQCysxvvWt65NA6wpX++vh31m7qEOmv++7amLoGo0ZV182+0vtu0efaYFcmGlecJwwpR/TCsEElbU4cVyV4GIiIiIgIYVoiIiEjiGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVoiIiEjSGFaIiIhI0hhWiIiISNIYVqqRmZmJGTNmwN3dHZ6enli9ejUqKiqauiwiIqIXTrOmLkCqAgMDYWtri9jYWDx8+BDvvvsuzMzM8O9//7upSyMiInqh8MyKBjKZDCkpKViwYAEMDQ1haWkJf39/REVFNXVpRERELxyeWdEgKSkJFhYWMDY2FqfZ2toiLS0NSqUSBgYGVZbR0vo7KyT6Z+H+QyRtTb2PMqxooFAoYGRkpDatMrjI5fIqYaVNG8NGq8XHrPH6JqIGMDiwqSsg+sfjZaBqCILQ1CUQERERGFY0MjU1hUKhUJumUCigpaUFU1PTpimKiIjoBcWwooGdnR3u3r2LnJwccZpMJkPnzp3RsmXLJqyMiIjoxcOwooGNjQ3s7e0RHh4OpVKJ1NRUbN26FX5+fk1dGhER0QuHYaUaX3/9Ne7fv49evXph0qRJGDlyJMaPH9/UZVETKywsxKRJk+Do6Ijff/+9Xn3t378fvXr1aqDKiP65vvvuO7i6uiI0NLTefVlbW+P8+fP1L4r+VrwbqBpt27bFt99+29RlvJC8vLxQXl6OY8eOoUWLFuL0X375BR9++CFOnz5d6z5/+eUXTJo0Cbq6ugAAHR0dWFpaYvDgwfD394e+vn6N+rl48SL++OMPnDt3rsHHL+3duxdeXl4cF0X/KF5eXsjKyoK29qPPxmZmZnB3d8e0adPQuXPnGvURGRmJefPmYeLEiQ1aW1JSEnJzc+Hh4dGg/VLD45kVkqTS0lKsX7++wfv97bffIJPJcP78eSxevBinT5+Gn58fCgoKarS8UqmEkZFRgwcKlUqFFStWQC6XN2i/RFIQFBQEmUyGy5cv47vvvkOrVq3w9ttvIyEhoUbLK5VKdOjQocHr2rdvH+Lj4xu8X2p4DCskSYGBgdi1axfS0tKqnefevXuYNWsW3N3d0a1bN8yfP7/KXVzVMTIyQs+ePbFt2zYolUps3rxZbPvpp58wYsQIODk5wdvbW3xycXR0NIKCgvDgwQPY29vj0qVLyMnJwZw5c9CzZ0+4urpi+vTpuHv3LgAgIyMD1tbWSE1NFftes2aNxk+H3bt3R35+PkaMGIFvvvmmRttA9Lxp3rw5OnXqhMWLF2PixIkICgqCSqVCZmYmZs6cCXd3d7i5uWHRokVQKpUoLS2Fvb09ACAgIABBQUEAgG3btqF///5wdnbGm2++iRMnTojrmDhxItasWSP+OzU1FdbW1sjIyFCr5bPPPsPu3buxZcsWDBgw4G/YeqoPhhWSpM6dO8PX1xdhYWHVzhMQEABDQ0OcOnUKx48fx/379xESElKr9bRo0QK+vr44duwYgEd3fS1duhQLFy7E77//jpUrV2LFihW4fPkyxowZg88++wxmZmaQyWRwc3PD6tWrUVBQgFOnTuHcuXMAgM8//7zW23vw4EHxv7Nnz6718kTPG39/f2RkZCAxMREBAQFo164dzp49i2PHjiErKwsrV66Erq4uZDIZAGD9+vUICwvDpUuXEB4ejvXr1+Py5cuYPn06FixYoHb3Zk0EBwfDzc0NU6ZMwcmTJxtjE6kBMayQZAUGBuL69esaDyTJyclISkrCwoULYWBgADMzM8yYMQOnTp1CaWlprdbTsWNH8VPX/v370a9fP/Tu3Rs6OjpwdXXFm2++KYaJJ33yySeIiIhAixYt0LJlS/Tv3x+JiYm131iiF4yZmRmMjIzwyy+/4K+//sLChQvx0ksvoXXr1ggMDERMTIzGh3N269YNFy9ehJWVFbS0tDBs2DCUlJTgzz//bIKtoL8LB9iSZBkYGGDBggVYvnw53njjDbW2jIwMGBsbo02bNuK0V199FWVlZcjKykL79u1rvB6VSgUdHR0AwJ07d5CQkCCeegYePc24d+/eGpe9ffs2VqxYgf/+978oLi5GRUUFTExMarGVRC+u8vJymJubQ6VSwd3dXa1NpVJBLpdXGR+mUqmwbt06HDt2TO1sSm0/pNDzhWGFJG3kyJGIiorCxo0b0aNHD3H60w5MWrX8xq1r166hY8eOAAB9fX34+fkhODj4mctVVFTg3XffRbdu3XD8+HGYmpoiOjoaa9eurXYZlUpVq9qI/qlu376NwsJCKBQKtGjRAn/88UeNllu3bh2OHj2KDRs24PXXX4cgCLCxsal2/oqKioYqmZoQLwOR5H388cfYtm0b0tPTxWnt27dHbm4uHjx4IE67efMm9PT0YG5uXuO+c3JysHv3brz11lsAHp2duX79uto89+7d0xgyHjx4gMzMTEycOFH89Hft2jWxXU9PDwBQXFwsTnt8G4heZBEREbCyskLPnj1RWFiotm8olcpq74yTyWTw9vaGjY0NtLW1kZSUpNauq6urts/duXOncTaA/lYMKyR5Xbt2xciRI9XOWNjb26NTp04IDw9HYWEhsrKyEBkZiaFDh6J58+bP7LOiogJ//PGH+KyHd955BwDg4+ODy5cvY9++fSgtLUVycjLGjBmD48ePV+nD1NQULVq0wJUrV1BSUoJDhw4hOTkZSqUSBQUFMDU1haGhIU6cOAGVSoW4uDhcuXJFYz2Vz3m5desWlEpl7V8koudEVlYWli9fjlOnTmHZsmWwsrKCs7Mzli1bhpycHOTl5SEkJASLFi3SuLyFhQVSUlJQVFSEGzdu4LvvvoOhoSGysrIAAJaWlkhISEBubi6ys7OxZ8+eamvR09NDRkYGcnNzG2VbqeEwrNBzYd68eSgvLxf/raWlhfXr1+P+/fvo168ffH194ejoiI8//vip/bi6usLe3h6Ojo5YsmQJPD09sXXrVvFhcZUBqPKJmYGBgZg6dSqGDBlSpa9mzZohNDQUmzZtgoeHBy5duoSIiAi0bdsWAwcOhI6ODkJCQvDjjz/C1dUVBw4cEEPRk8zMzDBo0CDMnTv3qZeRiJ5HYWFhsLe3h52dHYYPH46srCxER0fDwcEBABAeHg5BEODt7Y0BAwaIzx3S5N1334VKpUKPHj2wZMkSBAYGYtSoUQgLC8OpU6cwdepUGBoaok+fPpgyZQomT55cbV2jR4/G+fPnMXDgQF6ilTgtQdNwayIiIiKJ4JkVIiIikjSGFSIiIpI0hhUiIiKSNIYVIiIikjSGFSIiIpI0hhUiIiKSNIYVIiIikjSGFSIiIpI0hhUialKVTwsODQ2td1/W1tY4f/58/YsiIknhty4TUZ14eXkhKysL2tqPPvOYmZnB3d1d/L6lmoqMjMS8efMwceLEBq0vKSkJubm58PDw0NheVlaGyMhIHDlyBFlZWdDS0oKdnR3mzp0LV1fXGvXxpL1798LLy0v8Yksiahg8s0JEdRYUFASZTIbLly/ju+++Q6tWrfD2228jISGhxn0olUp06NChwWvbt28f4uPjq21fsWIFTp8+ja+//hq///47Lly4AA8PD0yZMkX8BuBn9fG4yu+zqe7bgomo7hhWiKjemjdvjk6dOmHx4sWYOHEigoKCxC+Gy8zMxMyZM+Hu7g43NzcsWrQISqUSpaWlsLe3BwAEBAQgKCgIALBt2zb0798fzs7OePPNN3HixAlxPRMnTsSaNWvEf6empsLa2hoZGRlq9Xz22WfYvXs3tmzZggEDBmis+eLFixg6dCisra2ho6MDAwMDzJo1C2FhYdDV1dXYx507dzB16lS4u7vD3d0d77//PvLy8gAA3bt3R35+PkaMGIFvvvkG+/fvR69evdTW6evri4iICABAWloa/P394erqCjc3N8yePZtBh6gaDCtE1KD8/f2RkZGBpKQkCIKAgIAAtGvXDmfPnsWxY8eQlZWFlStXQldXFzKZDACwfv16hIWF4dKlSwgPD8f69etx+fJlTJ8+HQsWLEBOTk6taggODoabmxumTJmCkydPapynY8eO+PHHH5GcnKw2ffjw4TA3N9fYR1BQEF5++WVcuHABR48eRVpaGtavXw8AOHjwoPjf2bNnP7PGzz77DC4uLvj5558RGxuL8vJyREZG1mo7iV4UDCtE1KDMzMxgZGSEjIwMyGQy/PXXX1i4cCFeeukltG7dGoGBgYiJiYGmL3zv1q0bLl68CCsrK2hpaWHYsGEoKSnBn3/+2eB1BgcHw8jICCNHjoSXlxcWLlyIw4cPo7S0tNplNm3ahNDQUOjq6sLU1BRvvPEGEhMT67T+vLw86Ovro1mzZjA2Nsb69evx0Ucf1XVziP7ROMCWiBpceXk5tLW1kZ6eDpVKBXd3d7V2lUoFuVxeZSCqSqXCunXrcOzYMbWzKU8LEHX1yiuvYM+ePbhx4wbi4+Nx6dIlBAUF4auvvsL3338Pc3PzKsskJiYiPDwc169fR1lZGVQqFezs7Oq0/tmzZ2PhwoU4cOAAevfujWHDhsHBwaG+m0X0j8QzK0TUoG7fvo3CwkK89tpr0NPTQ4sWLSCTydR+rl27pvGOmXXr1uHo0aOIjIzE1atXceXKlaeuq6Kiot71du7cGZMmTUJERAROnjyJsrIybN++vcp8ubm5mDFjBlxcXHD+/HnIZDLMmDGjVuuqHMcDAP369cPZs2cxe/ZsPHz4EBMmTMD3339f7+0h+idiWCGiBhUREQErKytYWVnh1VdfRWFhoXh3DfDo7p/qBpLKZDJ4e3vDxsYG2traSEpKUmvX1dVFcXGx+O87d+7UqcZ79+4hNDQUSqVSbXqbNm3w+uuvo6ioqMoyN2/eREFBAaZOnQoDAwMAwLVr16pdh56enlo/KpUKmZmZ4r/lcjlatmyJIUOGIDw8HJ988gmioqLqtD1E/3QMK0TUILKysrB8+XKcOnUKy5YtAwBYWVnB2dkZy5YtQ05ODvLy8hASEoJFixZp7MPCwgIpKSkoKirCjRs38N1338HQ0BBZWVkAAEtLSyQkJCA3NxfZ2dnYs2dPtfXo6ekhIyMDubm5VdpMTU0RHx+PhQsX4ubNm6ioqEBRUREOHz6MhIQEeHl5VenjlVdegba2Nv744w8UFhZi27ZtePDgAR48eIDy8nLo6+sDAG7duiXejl1QUIC4uDiUlpZi48aN4jid4uJiDBo0CAcPHkR5eTmKi4uRlJSEV199te6/AKJ/MIYVIqqzsLAw2Nvbw87ODsOHD0dWVhaio6PVxl6Eh4dDEAR4e3tjwIAB4vNINHn33XehUqnQo0cPLFmyBIGBgRg1ahTCwsJw6tQpTJ06FYaGhujTpw+mTJmCyZMnV1vb6NGjcf78eQwcOFDt8gvw6AzNzp070bp1a0ydOhXOzs7w8PDA7t27ER4ejjfeeKNKH2ZmZnj//ffx0UcfwdPTE7m5uVizZg1KS0sxfvx4mJmZYdCgQZg7dy7Wrl0LOzs7+Pv7Y/78+ejTpw+aNWsGZ2dnAIC+vj6++uorbNu2Da6urujXrx/u3buHjz/+uL6/EqJ/JC1B05B8IiIiIongmRUiIiKSNIYVIiIikjSGFSIiIpI0hhUiIiKSNIYVIiIikjSGFSIiIpI0hhUiIiKSNIYVIiIikjSGFSIiIpI0hhUiIiKSNIYVIiIikrT/B3iHDrSNXj9+AAAAAElFTkSuQmCC\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示目标变量 'Status' 的分布。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1500x800 with 3 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示部分数值特征的分布 (loan_amount, Upfront_charges, dtir1)。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1500x2000 with 9 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示部分编码后类别特征的分布 (loan_limit, approv_in_adv, loan_type, loan_purpose, Neg_ammortization, credit_type, submission_of_application, Region, Gender)。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1500x800 with 3 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAABdEAAAMWCAYAAAAeaM88AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA2DhJREFUeJzs3Xt8z/X///H7+73ZsKMdzMwcxsxhGzmTRhQZEUn4dpCKJAqVJKfPh5ySij7EpxRRItWI+DjUKsqpmOU8h21Oww427PR+//7w2ztv2zIz3jvcrpfLLr3fz+fj9Xo/3u/mvef78X6+nk+D2Ww2CwAAAAAAAAAA5GK0dQIAAAAAAAAAABRXFNEBAAAAAAAAAMgHRXQAAAAAAAAAAPJBER0AAAAAAAAAgHxQRAcAAAAAAAAAIB8U0QEAAAAAAAAAyAdFdAAAAAAAAAAA8kERHQAAAAAAAACAfFBEBwAAAAAAAAAgHxTRAZR4HTp00IgRI2ydBq4zZ84cBQUFKT09vcjPnZ2drS+//FJ9+/ZVq1at1LBhQ917770aOnSoDhw4UOSPBwAAgPw9+eST6tOnT779hRmrm81mvfHGG2rSpInCw8NvN0WbyhkXl1Y3+/9/OxITE/X++++rW7duatKkiYKDg9WxY0dNnDhRiYmJd+QxASA/FNEBALfkt99+U4cOHWz2+OPHj9f06dPVrVs3ffHFF1q/fr3efvttnT59Wk8++aRiY2MtsU888YRWrVp1y49R2OMAAABw+6KiovTNN9/o6aef1qJFi+7KY9p6jAtrGRkZeuKJJ7R27VoNGzZMq1evVkREhIYOHar169dr4MCBys7OtsQGBwcrLi7ulh+jMMcBKJsoogMAbskff/xhs8dOS0uzfKB64oknVKtWLVWrVk3t2rXTwoUL5evrqz179kiSsrKytG/fvlt+jMIeBwAAgKKRnJwsSWrVqpV8fHzuymPacoyL3LZt26YjR45o4sSJ6ty5s/z8/BQQEKBevXpp6tSpMhqNiomJkXTtS5fMzMxbfozCHgegbKKIDqDUuXTpkiZMmKC2bdsqODhY7dq10+TJk3X58mVLTFZWlt5//3117NjRshzI8OHDrWYhrFq1SkFBQTp06JCef/553XPPPWrbtq3efvttmUymW8opLS1NkydP1n333aeGDRsqLCxMb775ptVliHPmzNE999yjvXv36tFHH1VoaKg6d+6sX3/9VQcOHFDfvn3VqFEjhYeH67fffrM6/5YtW9SnTx+FhoaqcePG6tevn3799VdL/++//66goCBFRkZaHXfj5ZdBQUH69NNPNWfOHN13332655579NRTT+n48eOSpDfeeEPvvfee4uPjFRQUpDlz5vzj8z506JD69u2r0NBQtW3bVvPnz7e0BwUF5Tnbu0uXLnrllVfyPF9mZqays7OVkZGRq8/T01MRERHq1q2b4uLi1LBhQ125ckVjxoyxuoT2008/VXh4uIKDg9WyZUs9++yzlmVg8jvujTfe0L333mv1eHFxcQoKCtIXX3wh6dpMlmnTpqlDhw4KCQnRvffeq9GjR3OpKQAAwHU6dOigcePGafHixWrfvr1CQkL06KOPau/evZKujYmfe+45SdJTTz1lmR0eFBSkBQsWaPDgwQoJCdHBgwclSUePHtULL7ygZs2aKTg4WOHh4VqyZInVYxb1GPd6JpNJn3zyiTp16qTQ0FA99NBDWrx4ca642NhYPf3002rUqJFatmypuXPnWvXv3btXzz77rJo0aaLQ0FCFh4fryy+/zPXaTZ48WWPGjFGjRo20efNmSdKuXbvUq1cvhYSE6IEHHtCqVas0fvx4q5n1ZrNZn376qXr06KHGjRurTZs2Gj9+vFJSUiwx8fHxeuWVV3TvvfdazjVnzhzLjO9/sm7dOnXu3FnBwcF66KGHtGXLFknS559/rnr16lldLSpJZ8+eVf369bVs2bI8z5ezLGRe4/727dvr66+/VmBgoFatWqX+/ftLkjp27Kgnn3xS0s0/f+V3XF7LD+V8Ljx69Ohtv04ASi6K6ABKnRdeeEGbN2/WxIkTtW7dOo0ePVoRERF6/fXXLTHz58/XwoUL9dprr2njxo2aN2+e4uPjNXz48Fznmzhxoh577DFFRETo8ccf12effaZ169bdUk6TJ0/W6tWrNW3aNG3cuFGzZs3S77//rvHjx1vFZWVlafbs2Ro7dqxWrFghR0dHvfnmm5oyZYpGjhypFStWyN7eXmPHjrUcs3XrVg0ZMkT16tXTypUrtXz5cvn4+GjQoEGKjo6+xVdP+vLLL3XlyhV99tlnmjdvng4ePKh///vfkqSxY8eqY8eOqlKlin755RcNHDjwps97yJAh+u677/TII49o9uzZWrt2rerWrat77rlH33zzjVX8/v37FRMTo8ceeyzP87m7uys0NFSffPKJJk2apL179+Y5WPX19dXSpUslSW+++aZ++eUXSdK3336rqVOn6v/+7/+0YcMGffbZZzIajRo0aJCuXr2a73EF8Z///Efff/+9pkyZog0bNuj999/XX3/9pddee63A5wAAACgLIiMjtXfvXi1cuFBLly6VyWTS4MGDlZaWpoEDB2rWrFmSrhXUV65caTluxYoVatq0qdatW6datWrpwoUL+r//+z8lJSVpwYIFWrNmjXr06KEpU6bkKmQX5Rj3egsWLNAHH3ygF198UWvWrNFzzz2nadOmWcaUOSZPnqznnntO3377rbp06aI5c+Zo27ZtkqTU1FQ988wzsre311dffaW1a9eqX79+mjBhgqVQnuOnn36Sk5OTVq9erVatWunixYsaNGiQ7OzstHTpUr377rv66quvLOfOMW/ePE2bNk1du3ZVRESEpk2bpl9++UUvvfSSJea1117TxYsXtXDhQq1fv16jRo3SZ599po8//vgfX4P4+HgtX75cM2fO1Ndffy0/Pz8NHz5cp0+fVo8ePVS+fHl9++23VsesW7dOjo6Oevjhh/M8Z9OmTeXk5KSRI0dq4cKFOnHiRJ5x4eHhevXVVyVd+/3I+QLkZp+/8juuIAr7OgEo2SiiAyhV/vjjD+3cuVNjxozRAw88IH9/f4WHh+uFF17Q//73P50+fVqS1L9/f0VEROihhx6Sr6+vQkND1bt3b0VHR+vixYtW5wwPD1enTp3k7++vIUOGqFy5cpaZMgU1YsQIrVy5Uvfee698fX3VvHlzdenSRb/88ovMZrMlLiMjwzIDJSgoSI888ojOnDmjxx57TC1atFDdunX1yCOPKC4uzjJr5OOPP1bt2rU1adIk1a1bV0FBQZoxY4acnZ3zndnxTypWrKjXX39dAQEBatWqlTp06KCoqChJkouLixwdHWVnZydvb285OTn947mefvpptWvXTrVq1dKrr76qGjVqaPXq1ZKkvn37aseOHVazUr7//nv5+fmpTZs2+Z5z7ty5at26tZYtW2Z5XV544QUtX75cV65ckSTZ2dmpUqVKlpy9vb0lXZtZsnr1av3f//2fqlatqnr16unJJ5/U2bNndejQoXyPK4jo6GgFBQWpdevW8vX1VbNmzSxf1AAAAOBvly9f1pQpUxQYGKjQ0FC9/vrrunjxon799Vc5OTnJ1dVVkuTm5iYPDw/LcS4uLho0aJCqVasmBwcHrVy5UsnJyfrggw/UpEkT1axZU4MHD1b79u1zzUYvyjFujoyMDC1atEiPPfaYHnnkEVWvXl29e/fW0KFDlZqaahXbr18/3XfffapVq5aGDRsmSZZlCMuXL6+vv/5aM2bMUJ06dVStWjU9+eST8vLy0s8//2x1nrS0NL355puqXr26KlasqI0bNyo1NVVTpkxRaGioQkND9Z///EdnzpyxHJOZmamPP/5YPXr00KBBg1S9enXLzOzff/9du3fvlnRtPNu2bVs1aNBAVatWVZcuXfTll1+qa9eu//g6XLx4UTNmzFBoaKiCgoI0ZcoUZWRkaP369XJxcVF4eLi++eYbq889a9euVefOneXi4pLnOT09PbVgwQJ5eXnpnXfeUadOnRQWFqbRo0dr8+bNlnOVL19ezs7OkiQPDw+5u7tLuvnnr/yOK4jCvk4ASjZ7Wydwp/38888aPXq0WrZsqdmzZ9/Ssbt379bkyZN15MgRValSRcOGDcv3W1IAxUPOQLhZs2ZW7ffcc48k6a+//pKvr68cHR0VERGhTZs26ezZs8rMzFRWVpaka7vAXz9Yb9SokeW2vb29XF1drS57LAij0aglS5YoMjJS58+fV3Z2tjIzM5WZmamMjAw5OjpaYhs2bGi57ebmJkmqX79+rrZLly7J1dVVUVFReuihh2QwGCwxDg4OCg4O1l9//XVLeUpS48aNre57eHhY1qW8VU2bNrW6n7M8jnRt2ZapU6fqm2++sVwBsHbtWj366KNWz+VGPj4+WrRokWJiYhQZGakdO3Zox44d2rJli+bPn69FixapZs2aeR5boUIFRUZG6o033tCpU6eUnp5umcmelJRUqOeYo2PHjpowYYKGDx+uhx56SC1btlSVKlVUpUqV2zovAABAaRMSEpLn+Dc+Pv4fjwsODra6HxUVperVq6ty5cpW7ffcc4+2bNmi1NRUS6G0KMe4OWJjY5WUlGT1eUGShg4dmiv2+sfP+ayRlpYm6dpnjDNnzmjatGk6cOCAJa8rV67kGqPWr19fRuPf8yFPnjyp8uXLq27dulbnb9SokU6dOiXp2pI3qampuZYnbNWqlaRrn5GaNGmijh07au7cuTp37pzatWun5s2bq06dOjd9Hfz9/a3+H1SpUkXu7u6WNcv79u2rr7/+Wr///rtatWqluLg47dmzx+pK4bw0a9ZM69at0+7du7Vt2zZt375d33//vb799lu1bNlSCxcutPo9ut6tfP66VYV9nQCUbKW6iL5w4UKtXLlSNWrUuOVjz507pxdeeEFvvvmmunTpot9++00zZ87Ufffdd0vfUAK4u3JmfNw4oyFn8JwzUH311Vf1yy+/6NVXX1XLli1VoUIFbdiwQe+8806uc1asWNHqvsFgsJpFcTNms1nPPvusTp8+rTfeeEPBwcFydHTUkiVLcs2QufHxcorJFSpUyNWWk8P1Hw6u5+TklGvtwYLI6/kWVs4sohwVKlSwzBZ3dHRUz5499e2332rYsGHas2ePzpw5o0cffbRA5w4ICFBAQIAGDBigjIwMff3115oyZYpmzJih//znP3keM336dH3++ed68cUX1bFjRzk7O2vPnj1FMlu8b9++8vHx0bJlyzRmzBhlZGSoVatWGjt2LINqAABQahmNxn8cG2dnZ8ve3rr0cONYPWf8ebOJKjeOLVNTU/OcyXz92D/ndlGOcXPk5FuQmev/NJ6PiorSwIED1axZM02dOlU+Pj6ys7OzrNN9vRtfg6SkpFzPTbpWSM8poud8Rnrrrbc0YcKEXLEJCQmSro2Vv/zyS61evVpLly6Vg4ODunbtqjFjxuQ7YzyvnHKeb86eVKGhoWrYsKFWrVqlVq1aae3atapVq1auiU95MRqNatasmSU2KSlJ7733nr744gt98cUXGjBgQK5jbvXz160q7OsEoGQr1UV0R0dHrVy5UlOmTLFsSnG9tWvX6qOPPtKJEyfk6empQYMG6fHHH5ckffXVV2rSpIkeeeQRSVK7du3Url27u5k+gELIGcBdunTJaqB66dIlS39qaqq2bNmi559/Xk8//bQl5lY3Cy2oQ4cO6cCBA5o0aZJ69eplac9rk5zCcHFxyXW5qGT9oeLGgXqOtLS0XB9qilJaWprV/4fLly9bfcjo06ePFi1apF27dmnDhg267777bjpzOzk52TIbP4eDg4P69eunX375xbJJaF5Wr16t8PBwq7Xvc65e+Cd5fXFy/Ua1Oe6//37df//9ysjI0NatWzVr1iwNGjRImzZtKpIPagAAAMWNl5eX/vjjjzz7MjIydPHixVwzxXMmttx4/8Yx3s24urpalmu8Xs7YP6+JJkXJ09NTkm57Rvv3338vo9Go//znP5acTSZTgc7r4OCgq1ev5mq/fnP7nNf1tddeU1hYWK7YnM8M5cqV05NPPqknn3xSSUlJ+t///qeZM2cqKytLM2bMyDeHG/9/SrnH/Y8//rimTZumq1evau3atfnugXS9lJSUXAV6d3d3TZgwQevWrbNsLnuj2/38dbNxf2FfJwAlW6leE/2pp57K91vAqKgojR07Vq+99pp27dql6dOna9q0aZa1wHbt2iV/f3+9+OKLatq0qXr06KFff/31bqYPoBBCQ0MlSTt37rRq37Vrl4xGoxo0aKDMzEyZzWarJVuys7MVERFxR3LKzMyUJKvHS01N1YYNGyTlHqTdqkaNGmnXrl1W50lPT9e+ffsUEhIi6e8vF64fTKekpOjYsWOFesyC5rx9+3arY/766y8FBgZa2gICAtSyZUtFREQUaDD96aefqlWrVnnmbTabFR8fLx8fn3xzzcjIsPr/IMmyuemNz+n6+y4uLkpJSbEs+SP9vYaldO1DzoYNGywf4hwcHNS+fXsNHz5c8fHxt/3BCgAAoLi67777FB8fr99++y1X37Jly5SRkaGOHTtate/du9eq8BsdHS1JqlWr1i09dmhoqGJjY3X27Fmr9l27dql27doFXts8x62Oy319feXi4qIdO3ZYtb///vsaM2ZMgc+TmZkpBwcHq6L/2rVrdfXq1ZvmVKNGDV2+fFlHjhyxtJ09e1Z//vmn5X6tWrXk6uqq2NhY1ahRw/JTrVo1ZWVlycPDQ0lJSfruu+8sSx26u7vrscceU/fu3bV///5/zOHEiRNW/w/i4uKUnJxsNe7v1q2bDAaD/vvf/+rIkSPq2bPnP55zyJAh6t27d54TIhMTE3Xp0qV8x/23+vnr+vuurq659si6/rW8ndcJQMlWqovo/2TVqlVq37692rZtKzs7OzVr1kxdunTRd999J0k6c+aMIiIi9MQTT+jnn3/WQw89pKFDh+b64wygeAkNDVWrVq00bdo0/fjjj4qNjdV3332n+fPn65FHHlHlypVVqVIl1axZU6tWrdLBgwe1f/9+DRkyxLJ+944dO/Kc2V1YAQEBcnNz09KlS3Xs2DH9+eefeu655/TAAw9Ikn7//XfLEieF8dxzzykmJkYTJ07U0aNHtX//fo0YMULp6emWS0CrV69uyeHQoUPav3+/XnvtNXl5ed3y47m6uiohIUE7d+686XIxixcv1i+//KJjx45p+vTpio+PzzVgzlkjUZLat2//j+fr0aOHqlevrmeeeUYrVqzQwYMHFRcXp99//10vv/yyDh8+rBdffFHS3zNutm/frgMHDujq1au65557tGHDBu3Zs0dHjx7VG2+8oWrVqkm6tg9GSkpKnseFhoYqMzNT8+fPV2xsrDZu3KhVq1ZZ8jIajfrvf/+rV155RTt37tTp06cVHR2tL7/8UnXr1mUZMAAAUGo9/PDDatWqlV599VWtWrVKx48f14EDBzR37ly9++676tevn5o0aWJ1jIODg8aOHatDhw5p7969mjFjhipXrpxrze6b6dWrl9zd3TVixAjt3btXx44d0wcffKDIyEgNGjTols51K2PcHOXKldOAAQP07bffasWKFYqPj9e3336rhQsXqkGDBgV+7MaNGystLU2ffvqp4uLitGrVKi1dulSNGzfW4cOHFRcXl++xDzzwgMqVK6d///vfOnDggKKiojRy5EjLGFe6tub6c889py+++EKLFy/W8ePHtX//fo0ZM0aPPfaYzp49K7PZrIkTJ+qtt97SgQMHdPr0aW3dulWbN29WixYt/jF/d3d3vfnmm4qOjtaBAwf01ltvqWLFiurcubMlxsnJSd27d9e8efPUoUOHXBNbbjRo0CAlJCTo6aef1saNG3Xs2DGdOHFCGzZs0MCBA+Xh4aF+/fpJ+nvc/9NPP+ngwYMF/vx143HStc+Tu3fv1saNG3Xy5El9+umnli95JN3W6wSgZCvVy7n8k5MnT2rbtm2WWZrStTfDtm3bWm63a9dObdq0kSQNHjxYy5Yt048//mhZ8gVA8fThhx9qxowZGjt2rJKSkuTj46MnnnhCL730kiVm5syZmjhxoh577DH5+Pho0KBB6tGjhw4fPqzJkyfL3t7easOe21GxYkW98847mjp1qnr06KEaNWrolVde0T333KM//vhDw4cPz3cN74Jo0aKF5s2bp7lz56pnz56ys7NTo0aNtHjxYtWuXduSw8yZMzVt2jQ9+uij8vX11UsvvaQtW7bcdAOnG+UsmzJgwAD169dPY8eOzTPOzs5O48eP18SJE7V//365u7trzJgxuv/++63iHnjgARmNRvXq1eumS8tUqlTJMvhfvHixzpw5o8uXL8vDw0P33HOPli1bZtnYycvLS/3799fXX3+tH3/8Ud9++60mTJigt956S08//bTc3NzUr18/DR48WImJifr4449lb2+vYcOG5TouPDxcf/75p5YtW6b//ve/uueee/Tvf/9bXbt2teT24Ycfavr06Xr55ZeVnJysSpUqqUWLFpo0adItvb4AAAAliZ2dnRYuXKhPPvlEH3/8scaPHy97e3sFBQVp4sSJVstp5GjevLlCQkI0ePBgJSQkKCgoSPPmzbvlZQY9PDy0ZMkSzZgxQ88884zS09MVEBCg6dOnW5ZmLaiCjnFvNHToUDk4OGj+/Pn617/+papVq+r111/Pcz3z/HTt2lVRUVH66KOP9MEHH6hly5Z67733tGvXLr311lsaMGCANm7cmOexfn5+ev/99zVz5kz17t1bNWvW1Msvv6zVq1fr0KFDlrjBgwfLyclJS5cu1YwZM+Tg4KDmzZtr6dKllhndixYt0vvvv68nn3xSV69eVZUqVfTQQw/p5Zdf/sf8AwMD1bNnT40YMUKnTp1SzZo19eGHH8rb29sqLjw8XF988YX69Olz09fknnvu0fLly/XZZ59p+vTpSkhIUFZWlqpWraq2bdtq8ODBlrzbtWunJk2aaNq0aapbt65WrVpVoM9feR03fPhwnT17VqNHj5adnZ06d+6sESNGaNiwYZKufR4p7OsEoGQzmG93HYES4I033lB6erpmz55taRs6dKiqVKmicePG5XnMk08+qaCgIL311luWtscff1z33XefVSEOAHB7NmzYoJEjR2rTpk25LskEAABA6dKhQwc1atTI6vM5bk9SUpIcHR2t9iLq0aOHfHx8tGDBAhtmZm3y5Mn6/ffftXr1alunAgC3rMzORK9evXquzeTOnDkjb29v2dnZqXbt2lbrWZnNZp06dUp+fn53O1UAKJXOnz+vffv2afz48Xr22WcpoAMAAAC3KCkpSR06dFCzZs00cuRIVahQQRERETpw4IBl9rQtZWVlKSEhQf/73/+0dOlSLVy40NYpAUChlNkieu/evfXZZ5/p66+/1sMPP6yjR49q0KBBGjNmjMLDw9WnTx899thj+uabbxQeHq4lS5YoPT3dsoYWAMyfP18fffTRTeO+//57Va1a9S5kVLL0799fycnJeuSRR7jCBwAAAMVGSRrnu7u769NPP9V7772np556SpmZmapZs6ZmzJhRLOoXCQkJ6tixo6pUqaLJkydbltAFgJKmVC/nkrPeeVZWliRZ1lfLmYG+bt06ffDBB4qPj1flypX1xBNPaMCAAZbj169fr3fffVenTp1S7dq19a9//UuhoaF390kAKLaSkpKUnJx80zg/P79bXt8RAAAAgG0wzgcA3KhUF9EBAAAAAAAAALgdRlsnAAAAAAAAAABAcUURHQAAAAAAAACAfFBEBwAAAAAAAAAgH6V2B4yEhEu2TgEAAABlkLe3i61TKJEYvwMAAMAWCjJ+ZyY6AAAAAAAAAAD5oIgOAAAAAAAAAEA+KKIDAAAAAAAAAJAPiugAAAAAAAAAAOSDIjoAAAAAAAAAAPmgiA4AAAAAAAAAQD4oogMAAAAAAAAAkA+K6AAAAAAAAAAA5IMiOgAAAAAAAAAA+aCIDgAASgSTyaTY2BM6cCBasbEnZDKZbJ0SUGLMmzdPbdu2VePGjTVgwADFxcVJkrZt26bevXurSZMm6tq1qyIiIqyOW7x4sTp37qwmTZqoX79+2rdvn6UvPT1d48ePV1hYmFq2bKnhw4crMTHR0h8fH69BgwapZcuWuv/++zVz5kz+3aJE4u8PAACwt3UCAAAAN3P48EFFRm5SSkqypc3V1U1hYR0VGBhkw8yA4m/p0qWKiIjQ4sWLVblyZb333nv69NNPNWjQIL344osaO3asHn74Ye3atUtDhgxRrVq1FBISos2bN2vOnDn673//q6CgIC1evFgvvPCCNmzYoIoVK2r27NmKjo7W8uXLVaFCBY0bN05jxozR/PnzJUnDhg1Tw4YNtXHjRl24cEGDBw+Wl5eXnnnmGRu/IkDB8fcHAABIksFsNpttncSdkJBwydYpAACAInD48EGtWbNKAQF11KJFG3l6euvChQRt375VMTFH1K1bLwoZKFa8vV1snYKVjh07avTo0erUqZNV+8cff6w1a9bom2++sbSNGDFCLi4u+te//qXBgwerZs2aGjNmjKRrs3HDwsI0ZswYde7cWa1atdL06dPVsWNHSdLRo0fVtWtX/fTTTzp37pwef/xxbdu2TW5ubpKkL774Qp999pl++OGHPPNk/I7ihr8/AACUDQUZv7OcCwAAKLZMJpMiIzcpIKCOunfvLV9fPzk4OMjX10/du/dWQEAdRUZu5tJ6IB9nz55VXFyckpOTFR4ebll25eLFi4qOjlaDBg2s4hs0aGBZsuXGfqPRqPr16ysqKkonT57UpUuX1LBhQ0t/7dq1Vb58eUVHRys6Olp+fn6WArokNWzYUMeOHVNqauodftbA7ePvDwAAuB7LuQAAgGIrPj5WKSnJCg/vIYPBYNVnMBjUvHlrLV++RPHxsfL3r2GjLIHi68yZM5KkH374QYsWLZLZbNbw4cP11ltv6erVq/Lx8bGKd3d3t6xrnpSUZFUElyQ3NzclJiYqKSlJkuTq6mrV7+rqaum/sS/nXImJiXJ2ds4z3xv+mQM2c+rU339/jMbcf39atGitL79colOn+PsDAEBZQBEdAAAUW2lp12asenp659nv5eVtFQfAWs7Kjc8995ylYD5s2DA9//zzatOmTYGPL0z/ra4a6eHhJDs7LpRF8RAfny1JCgqqJUdHx1z9Li4BkiSjMVteXsVrCScAAFD0KKIDAIBiy8np2mzVCxcS5Ovrl6v//PkEqzgA1ry8vCRZzxj38/OT2WxWZmamZUZ5jsTERHl4eEiSKlWqlKs/KSlJgYGBlpikpCQ5OTlZ+pOTk+Xp6ans7Ow8jzUYDJZjb3TxYhoz0VFsmEx2kqSDB4+patXcf39OnYqzxJ0/z3r+AACUZAX5QtymRfQDBw5o6tSp2rdvnxwdHdWiRQuNHTtW3t7Ws83mzJmj//znP7K3t053y5Ytlg8GAACg9PHz85erq5u2b9+q7t17Wy3pYjabtWPHNrm6usvPz9+GWQLFV5UqVeTs7Kz9+/db1i+Pj49XuXLl1K5dO3333XdW8fv27VOjRo0kScHBwYqOjlbPnj0lSdnZ2frrr7/Uu3dv+fv7y83NzbL2uSQdOnRIGRkZCg4O1rlz53T69GldvHjRUjSPiopSnTp1rIruN7rFyevAHVO16j///dm+/drfn6pV/fm9BQCgDLDZ9ZIZGRkaOHCgWrRooW3btmnNmjW6cOGCJk6cmGd8jx49FBUVZfVDAR0AgNLNaDQqLKyjYmKOKCJipU6dilNGRrpOnYpTRMRKxcQcUVhYBxmNLAEB5MXe3l69e/fW/PnzdeLECV24cEEffvihHn74YfXs2VPx8fFasWKF0tPT9dNPP+mnn35Snz59JEn9+vXTt99+qz///FNXrlzRvHnz5ODgoPbt28vOzk59+vTR/Pnzdfr0aSUmJurdd9/Vgw8+KC8vLzVo0EAhISGaNWuWUlNTdfToUS1atEj9+vWz8SsCFAx/fwAAwPUM5ltdrLCIJCcna8OGDerZs6dlhvnixYv1+eefa8OGDVaxc+bMUXx8vKZNm1bg8yckcEkdAAClxeHDBxUZuUkpKcmWNldXd4WFdVBgYJANMwNy8/YuXusjZ2RkaOrUqfr++++VmZmpzp07a9y4cXJyctKOHTs0efJkHT16VH5+fho1apQ6depkOXbZsmVasGCBLly4oJCQEE2cOFF169bNdd6srCzdf//9mjhxolxcrj3/M2fOaNy4cdq+fbucnZ3Vt29fvfTSS7k2Cc7B+B3FEX9/AAAo/QoyfrdZEf1GMTExGjVqlMLCwjRixAirvjlz5mjz5s1ydHTUoUOH5OvrqzFjxqht27b5ni8h4RJrKgIAUIqYTCbFx8cqLS1VTk7O8vPzZwYgiiU2GSwciugorvj7AwBA6VaQIrrNNxaNj49X586dlZWVpT59+mj48OG5YqpUqSJ/f3+NGjVKlStX1vLly/XCCy8oIiJCAQEBeZ7Xw8NJdnYMbAAAKE0qV3azdQoAgDLGaDTK37+GrdMAAAA2VCxmopvNZp04cULjx4+Xt7e3Zs2addNjHnvsMd1777165ZVX8uxnJjoAAABsgZnohcNMdAAAANhCiZiJLkkGg0E1a9bUiBEj1LdvX40dO1YeHh7/eIyfn5/OnTv3jzG2/3oAAAAAAAAAAFCS2Wy9k23btqlz584ymUx/J/P/15UrV66cVex//vMfbdu2zart6NGj8vf3v/OJAgAAAAAAAADKLJsV0YODg5WamqqZM2fqypUrunjxoubMmaNmzZrJxcVFDz30kHbu3ClJSkpK0qRJkxQTE6P09HR98sknOnnypHr27Gmr9AEAAAAAAAAAZYDNlnNxcXHRJ598osmTJ6tVq1aqWLGiWrVqpSlTpkiSjh07psuXL0uSRo0aJUkaMGCAkpKSVKdOHX366aeqUqWKrdIHAAAAAAAAAJQBxWJj0TuBjYkAAABgCwXZmAi5MX4HAACALRRk/G6z5VwAAAAAAAAAACjubLacCwAAwK0wmUyKj49VWlqqnJyc5efnb9mUHAAAAACAO4UiOgAAKPYOHz6oyMhNSklJtrS5uropLKyjAgODbJgZAAAAAKC0o4gOAACKtcOHD2rNmlUKCKij8PAe8vT01oULCdq+favWrFmlbt16UUgHAAAAANwxXAMNAACKLZPJpMjITQoIqKPu3XvL19dPDg4O8vX1U/fuvRUQUEeRkZtlMplsnSoAAAAAoJSiiA4AAIqt+PhYpaQkq0WLNjIYDFZ9BoNBzZu3VkpKkuLjY22UIQAAAACgtKOIDgAAiq20tFRJkqend579Xl7eVnEAAAAAABQ1iugAAKDYcnJyliRduJCQZ//58wlWcQAAAAAAFDWK6AAAoNjy8/OXq6ubtm/fKrPZbNVnNpu1Y8c2ubq6y8/P30YZAgAAAABKO4roAACg2DIajQoL66iYmCOKiFipU6filJGRrlOn4hQRsVIxMUcUFtZBRiNDGgAAAADAnWEw3zitq5RISLhk6xQAAEAROXz4oCIjNyklJdnS5urqrrCwDgoMDLJhZkBu3t4utk6hRGL8DgAAAFsoyPjd/i7kAQAAcFsCA4NUu3ag4uNjlZaWKicnZ/n5+TMDHQAAAABwx1FEBwAAJYLRaJS/fw1bpwEAAAAAKGMoogMAAAAAkA+TycSVUAAAlHEU0QEAAAAAyEPee3K4KSysI3tyAABQhlBEBwAAAADgBocPH9SaNasUEFBH4eE95OnprQsXErR9+1atWbNK3br1opAOAEAZwTVoAAAAAABcx2QyKTJykwIC6qh7997y9fWTg4ODfH391L17bwUE1FFk5GaZTCZbpwoAAO4CiugAAAAAAFwnPj5WKSnJatGijQwGg1WfwWBQ8+atlZKSpPj4WBtlCAAA7iaK6AAAAAAAXCctLVWS5OnpnWe/l5e3VRwAACjdKKIDAAAAAHAdJydnSdKFCwl59p8/n2AVBwAASjeK6AAAAAAAXMfPz1+urm7avn2rzGazVZ/ZbNaOHdvk6uouPz9/G2UIAADuJoroAAAAAABcx2g0Kiyso2JijigiYqVOnYpTRka6Tp2KU0TESsXEHFFYWAcZjXykBgCgLDCYb/xavZRISLhk6xQAAABQBnl7u9g6hRKJ8TuKo8OHDyoycpNSUpItba6u7goL66DAwCAbZgYAAIpKQcbv9nchDwAAAAAASpzAwCDVrh2o+PhYpaWlysnJWX5+/sxABwCgjKGIDgAAAABAPoxGo/z9a9g6DQAAYEN8fQ4AAAAAAAAAQD4oogMAAAAAAAAAkA+K6AAAAAAAAAAA5IM10YG7KCsrS3v27FZycqLc3CqpUaMmsrfnnyEAFATvoQAAAAAAWzCYzWazrR78wIEDmjp1qvbt2ydHR0e1aNFCY8eOlbe3d67YxYsXa+nSpUpISFBQUJDGjh2r4ODgfM+dkHDpTqYO3LLIyM3avXu7rv8nZzAY1KRJC4WFdbBhZgBQ/PEeipLE29vF1imUSIzfAQAAYAsFGb/bbDmXjIwMDRw4UC1atNC2bdu0Zs0aXbhwQRMnTswVu3nzZs2ZM0czZszQ1q1bdf/99+uFF17Q5cuX737iQCFERm7Wrl2/q3z58mrSpIXuv7+zmjRpofLly2vXrt8VGbnZ1ikCQLGV8x5aoUIFPfBAFz3//DA98EAXVahQgfdQAAAAAMAdZ7Mi+pUrVzRixAgNHjxYDg4O8vDw0IMPPqjDhw/nil2+fLl69eqlRo0aqXz58nruueckSVu2bLnbaQO3LCsrS7t3b5eDg4PKlXPQ7t3btWXLeu3evV3lyjnIwcFBu3fvUFZWlq1TBYBiJ+c9tGLFinr++WEKCWksZ2dnhYQ01vPPD1PFihV5DwVuIigoSMHBwQoJCbH8/Pvf/5Ykbdu2Tb1791aTJk3UtWtXRUREWB27ePFide7cWU2aNFG/fv20b98+S196errGjx+vsLAwtWzZUsOHD1diYqKlPz4+XoMGDVLLli11//33a+bMmTKZTHfnSQMAAABFyGZFdDc3Nz322GOWtUxjYmL0zTffqEuXLrlio6Oj1aBBA8t9o9Go+vXrKyoq6q7lCxTWnj27ZTablZGRIS8vb/Xt+5SGDh2lvn2fkpeXtzIyMmQ2m7Rnz25bpwoAxU7Oe2ibNu1kNFoPW4xGo1q3DuM9FCiAH374QVFRUZafcePG6dy5c3rxxRfVt29fbdu2TWPHjtW4ceMsY+ybXQ06e/ZsRUdHa/ny5Vq/fr3MZrPGjBljecxhw4bJx8dHGzdu1KJFi7Rx40Z99tlnNnn+AAAAwO2w+W5c8fHx6ty5s7KystSnTx8NHz48V0xSUpLc3Nys2tzc3KxmuuTFYCjSVIFCSU6+KEmqXr2WevToLcP//8WsWtVPPXr01tdff6mTJ48rOfkiv7MAcIOUlGt/6wMC6uT5Hlm7dh1t2nQtjvdQ4NasXr1aNWvWVO/evSVJbdq0UYcOHbRixQqFhIRYXQ0qSc8995wWL16sLVu2qHPnzlq5cqWmT58uX19fSdIrr7yirl276uzZszp37pwOHDigRYsWycXFRS4uLhowYIA+++wzPfPMMzZ7zgAAAEBh2LyI7ufnp6ioKJ04cULjx4/X66+/rlmzZuWKu9X9Tz08nGRnZ7OJ9oBF+fIOkqRatarL29s1V3/NmtV18uRxlS/vIC8vNiIDgOtVrVpFf/4pJSTEqWbN5rn6Y2L2W+J4DwXyN2vWLP3xxx9KTU1Vly5d9MYbb+S62lOSGjRooHXr1km6djVoeHi4pe/6q0Hr16+vS5cuqWHDhpb+2rVrq3z58oqOjta5c+fk5+dnNRGmYcOGOnbsmFJTU+Xs7JxnnnwZBgAAgOLI5kV0STIYDKpZs6ZGjBihvn37auzYsfLw8LD0V6pUSUlJSVbHJCUlKTAwMN9zXryYxiAcxYK7u7ckafv27brnnlZWyxGYTCbt2LHDEnf+/CWb5AgAxVWdOg1lMKzT+vXr5e9fR6dPxystLVVOTs7y9fXThg0bZDAYVadOQ95DUWwUty90GjdurDZt2mj69OmKjY3VK6+8okmTJikpKUk+Pj5Wse7u7parPf/patCcsbmrq/UEAVdXV0v/jX0550pMTMyziM4kGAAAABRXNiuib9u2TRMnTtS6dessRcWc/5YrV84qNjg4WNHR0erZs6ckKTs7W3/99Zfl0tP83OLkdeCOcHG59gHyypUrWrBgjlq3DlNAQB3FxBzRtm2RunLliiWO31kAsGZnZ68mTVpo167fNWfOO1ZXphkMBpnNZjVt2lJ2dva8hwL5WL58ueV27dq19eqrr2rIkCFq2rTpTY+92dWg/9R/q1eSMgkGAAAAtlCQSTA2K6IHBwcrNTVVM2fO1PDhw3XlyhXNmTNHzZo1k4uLix566CFNnjxZzZo1U79+/TRy5Eh169ZNQUFB+vjjj+Xg4KD27dvbKn2gwPz8/OXq6iaDwaDk5CRt2vSDNm3K6TXIzc1dZvO1OABAbr6+fpJyF+Ry7uf0AyiYatWqKTs7W0ajMdfVnomJiZYrQv/patCcmKSkJDk5OVn6k5OT5enpqezs7DyPNRgMVlec3ogvwwAAAFAc2ex6SRcXF33yySfat2+fWrVqpa5du8rFxUXvvvuuJOnYsWO6fPmyJCksLEwjR47UK6+8ohYtWmjr1q1asGCBypcvb6v0gQIzGo0KC+uo5OQk1apVW40bN1NwcCM1btxMtWoFKDk5SWFhHayWeQEAXGMymRQZuUkBAXX00kuvKiysoxo1aqKwsI566aVXFRBQR5GRm2UymWydKlAs/fXXX5o2bZpV29GjR+Xg4KB27dpp3759Vn379u2zbCSaczVojpyrQRs1aiR/f3+5ublZ9R86dEgZGRkKDg5WcHCwTp8+rYsXL1r6o6KiVKdOHauiOwAAAFAS2HRN9KCgIC1ZsiTPvoMHD1rd79+/v/r373830gKKXGBgkLp166XIyE06duyopd3V1V3duvVSYGCQDbMDgOIrPj5WKSnJCg/voXLlyqlp0xZW/c2bt9by5UsUHx8rf/8aNsoSKL48PT21fPlyeXh4aMCAAYqPj9f777+vxx9/XD169NDcuXO1YsUKde/eXb/99pt++ukny/Iv/3Q1qJ2dnfr06aP58+crJCRE5cuX17vvvqsHH3xQXl5e8vLyUkhIiGbNmqUxY8bo7NmzWrRokQYOHGjjVwQAAAC4dcViY1GgLAgMDFLt2oGKj4+1bIrn5+fPDHQA+AdpaamSJE9P7zz7vby8reIAWPPx8dGCBQs0a9YszZs3Tw4ODurZs6dGjBghR0dHffTRR5o8ebImTZokPz8/zZw5U/Xq1ZNkfTXohQsXFBISYnU16PDhw5WWlqYePXooKytL999/vyZOnGh57A8++EDjxo3TvffeK2dnZ/Xt25dJMQAAACiRDOZb3fGnhEhIuGTrFAAAwG2KjT2hlSuXqW/fp/Jc+/zUqTgtX75EvXv3ZyY6ig1v75tvTITcGL8DAADAFgoyfmcKLAAAKLZyNmfevn1rnhuL7tixTa6u7mzODAAAAAC4YyiiAwCAYitnc+aYmCOKiFipU6filJGRrlOn4hQRsVIxMUfYnBkAAAAAcEexnAsAACj2Dh8+qMjITUpJSba0ubq6KyysA5szo9hhOZfCYfwOAAAAWyjI+J2NRQEAQLHH5swAAAAAAFuhiA4AAEoEo9HI5qEAAAAAgLuO6VsAAAAAAAAAAOSDIjoAAAAAAAAAAPmgiA4AAAAAAAAAQD4oogMAAAAAAAAAkA+K6AAAAAAAAAAA5IMiOgAAAAAAAAAA+bC3dQIAAAAFYTKZFB8fq7S0VDk5OcvPz19GI/MBAAAAAAB3FkV0AABQ7B0+fFCRkZuUkpJsaXN1dVNYWEcFBgbZMDMAAAAAQGlHER0AABRrhw8f1Jo1qxQQUEfh4T3k6emtCxcStH37Vq1Zs0rduvWikA4AAAAAuGO4BhoAABRbJpNJkZGbFBBQR92795avr58cHBzk6+un7t17KyCgjiIjN8tkMtk6VQAAAABAKUURHQAAFFvx8bFKSUlWixZtZDAYrPoMBoOaN2+tlJQkxcfH2ihDAAAAAEBpRxEdAAAUW2lpqZIkT0/vPPu9vLyt4gAAAAAAKGqsiQ4AAIotJydnSdKFCwny8fFVfHys0tJS5eTkLD8/f50/n2AVBwAAAABAUaOIDgAAii0/P3+5urppy5YNunLlilJSki19rq5uqlChglxd3eXn52/DLAEAAAAApRlFdAAAUGwZjUYFBtbTrl2/q2LFimrSpLnc3CopOTlRBw5E6+zZZDVt2lJGIyvUAQAAAADuDIroAACg2DKZTDp8+IDc3NyVnJyk3bt3WPW7ubnr8OGDatu2PYV0AAAAAMAdwadNAABQbMXHxyolJVnJyUmyt7f+7t/e3l7JyUlKSUlSfHysjTIEAAAAAJR2zEQHAADFVmrqJcvt6tVrqkWLNvL09NaFCwnavn2rYmKO5IoDAAAAAKAoMRMdAAAUW5cvp0qSvLy81b17b/n6+snBwUG+vn7q3r23vLy8reIAAAAAAChqFNEBAECxdeXKVUlSuXIOefaXK1fOKg4AAAAAgKJGER0AABRbBoNBknT6dLwiIlbq1Kk4ZWSk69SpOEVErNTp06es4gAAAAAAKGqsiQ4AAIotf/8a2r59qypV8tT58wlavnyJpc/V1U2VKnkoMfGi/P1r2DBLAAAAAEBpRhEduIuysrK0Z89uJScnys2tkho1aiJ7e/4ZAkB+qlWrrgoVKiox8YJq1gxQ06YtZG9fTllZmTp27KiOH49RxYoVVa1adVunCgAAAAAopQxms9lsqwePj4/X22+/rZ07d8rOzk5hYWF688035erqahW3atUqvfnmm5Z1T3MsXbpUoaGheZ47IeHSHcsbKIzIyM3avXu7rv8nZzAY1KRJC4WFdbBhZgBQvB0+fFBr1qySvb29srKyLO0597t166XAwCAbZghY8/Z2sXUKJRLjdwAAANhCQcbvNl0T/YUXXpCrq6s2b96sVatW6fDhw5o+fXqesc2bN1dUVJTVT34FdKC4iYzcrF27fleFChX0wANd9Pzzw/TAA11UoUIF7dr1uyIjN9s6RQAotgIDg9StWy9VrOhk1V6xohMFdAAAAADAHWezInpKSoqCg4M1atQoOTk5qUqVKurZs6d27txpq5SAOyIrK0u7d29XxYoV9fzzwxQS0ljOzs4KCWms558fpooVK2r37h1WsysBALndePGcDS+mAwAAAACUITZbjNnV1VVTp061ajt9+rQqV66cZ/zp06f1zDPPaN++fXJ1ddXw4cPVo0ePf3wMg6HI0gUKbe/e3TKbzWrTpp3s7Ky/t7KzM6pNmzBt3PiD9u7draZNW9goSwAovnKWcwkIqKOuXR+Rl5e3zp9P0PbtW7VmzSo9/DCz0QEAAAAAd06x2dEwKipKn3/+uebNm5erz8PDQzVr1tTIkSNVp04d/e9//9Prr7+uypUrq3Xr1nmez8PDKVfBErCF9PQ0SVLz5o3l4pJ7jaVmzRpr48YflJ6eJi8v1lAFgOuZTCb98ssW1atXT0888YSMxmt/26tW9VRwcF19/vnn+uWXLWrZsomlDwAAAACAolQsiui7du3SkCFDNGrUKLVp0yZXf/v27dW+fXvL/a5du+p///ufVq1alW8R/eLFNGaio1hwdLy2hu+OHX8qNLRxrv69e/+0xJ0/z4ZaAHC92NgTSkxMVOfOD+vixbRc/Y0bN9eXXy7Rnj1/yd+/hg0yBHLjS3EAAACgdLF5EX3z5s167bXXNG7cOD3yyCMFPs7Pz0/79u37xxiWSkVxEBraRJGRm7V1609q2DDUaqakyWTS1q2RMhiMCg1twu8sANwgNTVVkuTp6Z3ne6Snp7cljvdQAAAAAMCdYNMi+u7duzV69Gi9//77atu2bb5xX3zxhdzc3BQeHm5pO3r0qPz9/e9GmsBtsbe3V5MmLbRr1+9auHCOWrcOU0BAHcXEHNG2bZG6fPmymjZtKXt7m3+nBQDFjpOTsyTpwoUEeXv7aM+e3UpOTpSbWyU1atRE588nWMUBAAAAAFDUbFa1y8rK0ltvvaVXX301zwL6008/rccff1zh4eHKyMjQv//9b/n7+6tevXpav369IiMj9dVXX9kgc+DWhYV1kCTt3r1dmzb9oE2brrUbDEY1bdrS0g8AsObn5y9XVzetWxehlJRkma+bbv7zz5vl6uomV1d3+fnxxToAAAAA4M6wWRH9zz//1NGjRzV58mRNnjzZqu+HH35QbGyskpOTJUlPPfWU0tLS9PLLLyshIUHVqlXThx9+qODgYFukDhRKWFgHtWkTlmsWJTPQASB/RqNRXl6VFRNzOFef2WxWcnKSAgIC2VQUKKC3335bn332mQ4ePChJ2rZtm2bNmqWYmBj5+vpq8ODB6t69uyV+8eLFWrp0qRISEhQUFKSxY8daxuDp6emaMmWKfvzxR6Wnp6tly5aaNGmSKlWqJEmKj4/XpEmTtGfPHlWsWFHh4eEaNWoU/14BAABQ4hjM5tK5gmhCAhs0AgBQ0mVlZWnu3HdkNptlNBplMpksfTn3DQaDXnrpVb6URLHh7V08Nxbdv3+/BgwYoKSkJB08eFDnzp1T586dNXbsWD388MPatWuXhgwZos8//1whISHavHmzRo8erf/+978KCgrS4sWLtXjxYm3YsEEVK1bUtGnTtGPHDs2dO1cVKlTQuHHjlJmZqfnz50uSevXqpYYNG+r111/XhQsXNHjwYPXt21fPPPNMnvkxfgcAAIAtFGT8zjQQAABQbO3Zs0tms1leXt566aVX1bt3f3Xp0l29e/fXSy+9Ki8vL5nNZu3Zs8vWqQLFmslk0oQJEzRgwABL2+rVq1WzZk317t1bjo6OatOmjTp06KAVK1ZIkpYvX65evXqpUaNGKl++vJ577jlJ0pYtW5SVlaWVK1fqxRdflK+vr9zd3fXKK6/oxx9/1NmzZxUVFaUDBw7o1VdflYuLi2rWrKkBAwZo+fLltnj6AAAAwG1hyhYAACi24uNjJUn33ttOdnZ28vevYdXfunU7rV79teLjY9W0aUtbpAiUCF9++aUcHR318MMP67333pMkRUdHq0GDBlZxDRo00Lp16yz94eHhlj6j0aj69esrKipK9evX16VLl9SwYUNLf+3atVW+fHlFR0fr3Llz8vPzk5ubm6W/YcOGOnbsmFJTU+XsnPdmwAZDUT1jAAAAoOhQRAcAAMVWuXIOkmTZJ+VGly4lW8UBpUl6erq++uorPfnkk5KkTZs2aeXKlapRo4aGDRsmJyenAp3n/PnzmjNnjpYsWWLVnpSUJB8fH6s2d3d3JSYmWvqvL4JLkpubmxITE5WUlCRJcnV1tep3dXW19N/Yl3OuxMTEPIvoHh5OsrPjQlkAAAAUPxTRAQBAsdWgQUMdOBCtbdt+VqNGTaw2JDSZTNq27RdLHFDa/Pvf/9ahQ4f05JNPKiYmRiNHjtTzzz+vQ4cOacqUKXr77bcLdJ6pU6eqV69eqlOnjuLi4m4ph5ttn/RP/be69dLFi2nMRAcAAMBd5+V18zXRKaIDAIBiy9+/lhwcHJSeflULF85R69ZhCgioo5iYI9q2LVLp6Vfl4OAgf/9atk4VKHKbNm3S6tWrJUnfffed2rZtq5deekmXLl1Sly5dCnSObdu26Y8//tCaNWty9VWqVMkyozxHYmKiPDw88u1PSkpSYGCgJSYpKclqRnxycrI8PT2VnZ2d57EGg8FybF5use4OAAAA3BVcLwkAAIoto9GoTp26SZIuX76sTZt+0MKFc7Vp0w+6fPmyJKlTp25WM9SB0iI9PV1eXl6SpF9//VUPPPCAJMnZ2VlpaWkFOkdERIQuXLig+++/Xy1btlSvXr0kSS1btlTdunW1b98+q/h9+/apUaNGkqTg4GBFR0db+rKzs/XXX3+pUaNG8vf3l5ubm1X/oUOHlJGRoeDgYAUHB+v06dO6ePGipT8qKkp16tQp8DI0QHGRlZWlXbu2a/Pm9dq1a7uysrJsnRIAALjLmIkOAACKtcDAIHXr1ks//vg/paZesrQ7O7uqffsHFBgYZMPsgDsnMDBQq1atUvny5XXkyBF16NBBkrR161b5+voW6BxvvPGGXn75Zcv9M2fO6PHHH9d3330nk8mkjz76SCtWrFD37t3122+/6aefftLy5cslSf369dPIkSPVrVs3BQUF6eOPP5aDg4Pat28vOzs79enTR/Pnz1dISIjKly+vd999Vw8++KC8vLzk5eWlkJAQzZo1S2PGjNHZs2e1aNEiDRw4sOhfKOAOiozcrN27t1stT/Tzz5vVpEkLhYV1sGFmAADgbjKYb3WxwhIiIeHSzYMAAECJkZGRoZ9/3qKkpItyd/fQfffdLwcHNhRF8ePtffM1FQti7969eu2113Tp0iWNGDFCjz32mJKSknT//ffr7bffLvCSLteLi4tTx44ddfDgQUnSjh07NHnyZB09elR+fn4aNWqUOnXqZIlftmyZFixYoAsXLigkJEQTJ05U3bp1JV37Nzl16lR9//33ysrK0v3336+JEyfKxeXa8z9z5ozGjRun7du3y9nZWX379tVLL70kQz4LnzN+R3ETGblZu3b9rooVK6pNm3aqVauOjh07oq1bf9Lly5fVtGlLCukAAJQCBRm/U0QHAADFXl4zAQ0GAzMBUSwVVRE9P2fPnpWPj88dfQxbYPyO4iQrK0tz576jChUq6Pnnh+Xa2Hrhwjm6cuWqXnpplOztucAbAICSrCDjdxYQBQAAxVrOTMC87Nr1uyIjN9/ljIC7588//9SkSZP04osvSrpWvPvjjz9snBVQ+u3Zs1tms1lt2rSTJMXGntCBA9GKjT0hSWrdOkxms0l79uy2ZZoAAOAu4StzAABQbGVlZWn37u2SpJo1A9Sy5b3y9PTWhQsJ+v33X3Xs2FHt3r1dbdqEMRMQpc5XX32ladOmqUuXLvr5558lSQkJCXr77bd17tw5PfXUUzbOECi9kpMT//8tgxYtmq+UlGRLn6urm1q0aHNDHAAAKM2YiQ4AAIqtPXt2ymw2y8vLWw8//KiysrIUE3NYWVlZevjhR+Xl5S2z2aw9e3baOlWgyC1cuFALFy7UlClTLOuI+/j46KOPPtLnn39u4+yA0s3NrZIkaePGtfLy8lbfvk9p6NBR6tv3KXl5eWvjxnVWcQAAoHQrdBH922+/zbP9ypUrWrRoUWFPCwAAYBEfHydJqlWrjj799COtXLlM69ZFaOXKZfr0049Us2aAVRxQmpw/f15NmjSRJKvNOOvUqaNz587ZKi2gTAgJaSxJsrOzU7duveTr6ycHBwf5+vqpW7desrOzs4oDAACl2y0X0U0mkzIyMjRhwgRlZmYqIyPD6ufEiROaPXv2ncgVAACUMeXKOUiSduzYpsuX06z6Ll9O086dv1vFAaVJjRo19Ntvv+VqX7NmjapWrWqDjICy4+zZ05Kk7Oxs/fe/c7V37x9KTb2kvXv/0H//O1fZ2dlWcQAAoHS75cVDFy9erOnTp0uSQkND84xp3LjxbSUFAAAgSfXqNdCBA9GSpKpVq6l27bqyt7dXVlaWjh49pJMnj1vigNJm0KBBevHFF9WhQwdlZWVp8uTJOnjwoP744w/NmjXL1ukBpVpaWqokqXHjZtqzZ5c2bfpBmzZd6zMYjGrcuJn+/HOnJQ4AAJRut1xEHzBggLp3766wsDB98sknufrLly+v+vXrF0lyAACgbDMa/75o7uTJ45ai+T/FAaVFeHi4/P399c0336h169Y6c+aMgoODNWnSJAUEBNg6PaBUc3JylnTtS9r77rtfe/bsVnJyotzcKqlRoyY6d+6M/vxzpyUOAACUbrdcRJckDw8P/fTTT/L09CzqfAAAACzi4mILHFejBkVFlD4hISEKCQmxdRpAmePn5y9XVzdt375V3bv3VtOmLSx9ZrNZO3Zsk6uru/z8/G2YJQAAuFsKVUSXpISEBL355ps6evSorl69mqv/l19+ua3EAAAAzGazJMndvZKysrKUmnrJ0ufi4io7OzslJSVa4oDS5Mknn7TaUPR6RqNRPj4+ateuncLDw+9yZkDpZzQaFRbWUWvWrFJExEo1b95aXl7eOn8+QTt2bFNMzBF169aLK6EAACgjCl1Ef+211+Tj46OBAweqQoUKRZkTAACAJKl8+WtjjPT0dF25ctmq79KlFMsYJCcOKE2aN2+upUuXqlatWgoJCZHRaFRUVJROnDih7t27KzExURMmTFBsbKwGDx5s63SBUicwMEjduvVSZOQmLV++xNLu6uqubt16KTAwyIbZAQCAu6nQRfS4uDitXLlSjo6ORZkPAACAhZOTkyTpypXLMhrtVLVqNVWsWFGXL1/WqVNxunLlilUcUJqcPXtWr7/+uh599FGr9q+//lqHDh3StGnTFB0dreHDh1NEB+6QwMAg1a4dqPj4WKWlpcrJyVl+fv7MQAcAoIwp9F/++vXr68yZM0WZCwAAgJWKFStabptM2YqLO6FDh/YrLu6ETKbsPOOA0mLdunXq3r17rvbu3bvr22+/lSQ1aNBAFy9evMuZAWWL0WiUv38N1avXUP7+NSigAwBQBhV6Jvozzzyj0aNHq0ePHvLz88s1kGjbtu1tJwcAAMq28+fPFTiOjUVR2ri5uenLL7/UE088YbU2+qpVq2Rvf20Yv2zZMtWsWdNGGQJlg8lkYiY6AABlXKGL6MOGDZMk/fnnn7n6DAaD9u/fX+ikgNKKATgA3JqkpCTLbaPRToGBQapcuYrOnTujw4cPWmajXx8HlBYTJkzQ8OHD9eGHH8rX11f29vY6ffq0EhMTNWXKFGVmZmr27Nn64IMPbJ0qUGodPnxQkZGblJKSbGlzdXVTWFhH1kQHAKAMMZjNZrOtk7gTEhIu2ToFwMrhwwf1008bdelSiqXNxcVV7do9wAAcAPLx7bdf6dixozIajXJycs71HpqWliqTyaRatWrrkUf62DBT4G/e3i5Fdq6EhAT99ttvSkhIkMlkkqenp5o3b65q1apJkq5cuWLZYLekY/yO4ubw4YNas2aVAgLqqEWLNvL09NaFCwnavn2rYmKOsLkoAAClREHG74WeiQ6g4HIG4DmXXue4cuWy1qxZxQAcAPJx5cplSZKdnZ0GDBis06fjLVfz+Pr6af7892QymSxxQGkyadIkTZgwQQ8//HC+MaWlgA4UNyaTSZGRmxQQUEfdu/e2LKnk6+un7t17KyJipSIjN6t27UCuLAUAoAwodBG9Xr16Vmsz3ojlXIBrTCaTNm36QZJUrVoNubtXUlZWpuztyykpKVHHjx/Vpk0/MAAHgDwYjXaSpMzMTH388Ydq3TpMAQF1FBNzRGvXfqvMzEyrOKA0+fnnnxUbGyt/f39bpwKUOfHxsUpJSVZ4eI9cn3sNBoOaN2+t5cuXKD4+Vv7+NWyUJQAAuFsKXURfuHCh1X2TyaQTJ05ozZo1eu655247MaC0iIs7oStXLsvZ2UXHjx/N1e/s7KzU1FTFxZ1Q9eq1bJAhABRftWvX0alTcTIajbpy5Yo2bfpBmzZd6zMYDDIajTKZTKpdu45tEwXugN69e+vFF19UWFiYqlatmuuKtscff9xGmQGlX1paqiTJ09M7z34vL2+rOAAAULoVuoh+33335dnerl07vfHGG+rUqVOhkwJKk9jYk5Kk1NRLqlixotq0aadatero2LEj2rr1J6WmplriKKIDgLXGjZvr559/lMlkkqOjo6pXr6ly5RyUmZmhkyePKz093RIHlDZfffWVJGndunW5+gwGA0V04A5ycnKWJF24kCBfX79c/efPJ1jFAQCA0q3I10SvUqWKDhw4UNSnBUoss9kkSXJwcNTzzw+zLNkSEtJYDRuGat6895SRkW6JAwD8zd7eXk2bttSuXb8rPT1dhw8fzBXTtGnLXDN0gdJg8+bN+fZduHDhLmYClD1+fv5ydXXT9u1brdZElySz2awdO7bJ1dVdfn4stwQAQFlQ6E+cy5cvz9V25coV/fTTT6pevfptJQWUJunpVyVd2/grOztbf/yxU8nJiXJzq6TQ0HtUoUIFZWSkW+IAANbCwjpIknbv3i6z2WxpNxgMatKkhaUfKK1MJpOysrIs98+ePatHH31U27dvt2FWQOlmNBoVFtZRa9asUkTESjVv3lpeXt46fz5BO3ZsU0zMEXXr1os9jQAAKCMKXUT/6KOPcrU5OjqqRo0amj59eoHOER8fr7fffls7d+6UnZ2dwsLC9Oabb8rV1TVX7Nq1azVv3jzFxcWpVq1aGjlypNq2bVvY9IG76NqsleTkJM2d+45VT2TkplxxAIDc4uJOWhXQpWszAePiTtooI+DOO3z4sEaPHq1Dhw4pOzvbqi80NNRGWQFlR2BgkLp166XIyE1avnyJpd3V1U3duvVSYGCQDbMDAAB3U6GL6P90eWlBvfDCCwoODtbmzZt16dIlDR06VNOnT9eUKVOs4vbv36/Ro0dr7ty5atWqldavX6+XXnpJP/zwg6pUqXLbeQB3kru7R5HGAUBZs2zZpzp79rQkqX79hmrSpKV27/5d+/dH6+zZ01q27FP17z/AtkkCd8CkSZPUsGFDjRw5Ui+88IIWLlyo6Ohobd26VbNnz7Z1ekCZkdeXuAAAoGy5rQVEDx8+rPXr1ys+Pl6SVKNGDXXt2lX+/jdfFy4lJUXBwcEaNWqUnJyc5OTkpJ49e2rJkiW5YlesWKF27dqpXbt2kqTu3bvr888/V0REhAYNGnQ7TwG44xo2DLXMOHdxcdWlSymWPldXN6WkJFviAADWrl69aimgDx06SmfPntbFi+fVsGEjdejwkD78cJbOnj2tq1evqnz58jbOFihaBw4c0Keffip7e3sZjUa1bt1arVu3VlBQkMaPH6/333/f1ikCpdrhwwe1Zs0q1awZoNq16yorK0v29vZKSrqoNWtWMRsdAIAypNBF9LVr1+r1119X/fr1LWugb9iwQf/5z3/0ySefqFmzZv94vKurq6ZOnWrVdvr0aVWuXDlXbHR0tKWAnqNBgwaKior6x8cwsDoGioG//tpruZ2VlakmTZrL3b2SkpIStX//Pqu4pk1b2CJFACi2NmxYI+naBm+LFy+0+iLSxcVVfn7VFB8fpw0b1qhHj962ShO4I8qXL68rV67IxcVFFStW1Llz51S5cmW1bt1ar7zyiq3TA0o1k8mkyMhNcnNz1/HjMZJirPrd3NwVGblZtWsHsi46AABlQKGL6HPnztWMGTMUHh5u1b5q1SrNmDFDX3311S2dLyoqSp9//rnmzZuXqy8pKUlubm5WbW5ubjpy5Ei+5/PwcJKdHYMZ2F56epokqUWLFtq5c6d2795h6TMajWrRooW2b9+u9PQ0eXm52CpNACiWUlOvFc3j42NVrlw5q76rV69YiuqpqSm8h6LUad++vZ544gl98cUXat68ucaMGaM+ffpoz549qlSpkq3TA0q1+PhYyxWjBoMh18bWyclJljh//xq2SBEAANxFhS6inzp1Sp07d87V3r17d7399tu3dK5du3ZpyJAhGjVqlNq0aZNnzK2uO3fxYhoz0VEsODo6SZJcXT31wgsva/36NUpOTpSbWyV17txNhw7tt8SdP3/JlqkCQLHj5OQi6awkyWSyHgtcf9/JyYX3UBQbRfWFzvjx47Vw4UI5Ojrqrbfe0ogRI/Tqq6/Kz89P//rXv4rkMQDk7forn2rWDFDNmrVlb2+vrKwsHT9+VMeOHc0VBwAASq9CF9GrVq2qPXv2qEmTJlbt0dHR8vT0LPB5Nm/erNdee03jxo3TI488kmdMpUqVlJSUZNWWlJQkD49/3oiR/V5QHISGNlFk5Gb9+OP/tGnTD5YvhM6fP695896TnZ2dDAajQkOb8DsLADcIDm6kmJhrV575+fmrTZv75OnprQsXErR16886efKYJY73UJQ2Dg4OGjp0qCTJx8dHy5Yts3FGQNlx6tS1fb8qVnTS+fMJlqK5dG05sYoVnXT5cppOnYpXgwYhtkoTAADcJYUuoj/11FMaNGiQHn74YdWuXVuSFBMTo9WrV2vw4MEFOsfu3bs1evRovf/++2rbtm2+ccHBwdq3b59VW1RUlLp27VrY9IG7xt7eXpUrV7FsjHc9s9msrKws+fj4yt7+tvb5BYBS6fTpU5bbJ08ek9lskr9/DcXGnlBs7AmruNq169oiReCOyc7O1pYtWxQTE6OMjIxc/S+99JINsgLKhrS0VEnS5ctpsrOzs+q7fDlN2dnZVnEAAKB0K3TVrm/fvqpcubK+/vpr7d69WxkZGapevbomTZqUa530vGRlZemtt97Sq6++mmcB/emnn9bjjz+u8PBw9enTR71799aPP/6o1q1ba/Xq1Tp+/Li6d+9e2PSBuyYrK0vnzp35x5hz584oKyuLQjoA3CDnMnlHx/JKT7+aq3ie087l9CiN3nzzTX3//feqXbu2ypcvb9VnMBgoogN3kIPD3/twODo6qk2bdqpVq46OHTuirVt/0uXLl3PFAQCA0uu2KnYdOnRQhw4dCnXsn3/+qaNHj2ry5MmaPHmyVd8PP/yg2NhYJSdf28ilbt26eueddzR16lTFx8erTp06+uijj+Tt7X076QN3xZ49Oy1LuNSoEaBKlTwsBfPExIs6cSJGZrNZe/bsVNOmrWycLQAULy4urpKk9PSrefbntOfEAaXJunXrtGLFCtWvX9/WqQBljpfX3581jUY7bdy4znLf2dklzzgAAFB6FbqIfunSJX399dc6fvy40tPTc/VPnTr1H49v1qyZDh48mG//5s2bre536tRJnTp1KlyygA3FxcVJkipXrqKePfvIcN2Ot2azWcuWfapz584oLi5OTZvaKksAKJ78/f21Y8c2y/169RqqSZOW2r37dx04EG0VB5Q2lStXVq1atWydBlAmpaf/vYRSdnaWAgPrWTYWjYs7kWccAAAovQpdRB86dKiOHTum0NBQOTo6FmVOQKmSmZkp6dqGeNcX0KVrl2JXrVpN586dscQBAP6WlWWy3Lazs9eBA9GW4rmdnb2ys7NyxQGlxRtvvKH3339fL7/8cq7lXADcWdeP269cuaLDhw/cNA4AAJRehS6iR0VFaePGjfL09CzKfIBSx8enimJjj+uvv/aqbdv2On06XmlpqXJycpavr5/274+yxAEArP3xx07L7RvrFNff/+OPnapdO/AuZQXcOTfuFZSWlqbFixerUqVKuWJ/+eWXu5UWUOb4+1fX9u1bJVl/aSvJMiM9Jw4AAJR+hS6iBwUF5bmMCwBrNWrU1M6dvyk9PV1z5sz8xzgAgLX09CuSZNnM7XpZWVmqVau2jh07aokDSrpRo0bZOgUAkqpW/XuZsGrV/GVvX07p6Vfl6FheWVmZOnHimCSDVRwAACi9Cl1Enzlzpl5//XXde++98vHxkdFotOp/5JFHbjc3oFSoVq2GHBwclJGR/3qJDg4Oqlatxl3MCgBKBh+fqjp37qyOHTtiNfNPujYT8Nixo5Y4oDTo2bOn1X2z2az09HTLci7JyclydnaWnZ2dLdIDyozTp+Mtt68VzPNi1unT8fL3ZxwPAEBpV+gi+rx587Rz504dPHgwzzXRKaIDf7Ozs5eUITs7O2VnZ1/Xfu2+vX2h/ykCQKnWtm17RUX9IUmyty+nWrXqWIrpsbEnLEX1tm3b2zBL4M44cOCAXnzxRb366qsKDw+XJH399ddasmSJ5s2bp3r16tk4Q6D0SktLLdI4AABQshW6crd27Vp9/vnnatasWVHmA5Q68fGxunLlsu69t7327t2tS5dSLH0VKzorNLSxfv31J8XHxzKLBQBucO7cGcvtq1fz39jt3Lkzql695l3KCrg7Jk2apEcffVQdOnSwtD3xxBPKysrSv/71Ly1btqxA5zlw4ICmTp2qffv2ydHRUS1atNDYsWPl7e2tbdu2adasWYqJiZGvr68GDx6s7t27W45dvHixli5dqoSEBAUFBWns2LEKDg6WJKWnp2vKlCn68ccflZ6erpYtW2rSpEmW9dvj4+M1adIk7dmzRxUrVlR4eLhGjRqV6wpWoDiqUOHa1R+OjuU1aNCwXPsaLVgwR+npVy1xAACgdCv0CLZq1arMfgEKIGd2SuPGTdW//zPy9fWTs7OLfH391L//ADVu3NQqDgDwt9jYE0UaB5QkBw8e1AsvvGBZykW6tgTcwIEDtX///gKdIyMjQwMHDlSLFi20bds2rVmzRhcuXNDEiRN17tw5vfjii+rbt6+2bdumsWPHaty4cYqKurbp+ebNmzVnzhzNmDFDW7du1f33368XXnhBly9fliTNnj1b0dHRWr58udavXy+z2awxY8ZYHnvYsGHy8fHRxo0btWjRIm3cuFGfffZZEb5CwJ1z/vx5SZKLi4vMZrPOnTurU6fidO7cWZnNZrm4OFvFAQCA0q3QM9FHjx6t8ePHq3fv3nmuiV6rVq3bTg4oDZycrg2wly37VImJFyztqamX9NFH76tSJU+rOADA38xmk6Rry1+VL1/B6gtHJydnXb16RdnZ2ZY4oDSpXLmydu/erebNm1u1//rrr/Lw8CjQOa5cuaIRI0aoZ8+esre3l4eHhx588EF9/vnnWr16tWrWrKnevXtLktq0aaMOHTpoxYoVCgkJ0fLly9WrVy81atRIkvTcc89p8eLF2rJlizp37qyVK1dq+vTp8vX1lSS98sor6tq1q86ePatz587pwIEDWrRokVxcXOTi4qIBAwbos88+0zPPPFOErxJwZyQnJ0mSzp9P0Ny571j1RUZuyhUHAABKt0IX0QcPHizp2rIuOQwGg8xmswwGQ4FnxwClnZ+fv4xGo6WAXrmyj9zcKik5OVHnzp1VYuIFGY1G+fn52zhTACh+rl5NlyRlZ2fLw8NLbm7uunr1qsqXLy87O3vFxh63igNKkyFDhmjQoEFq06aNqlWrJpPJpGPHjmn79u165513bn4CSW5ubnrssccs92NiYvTNN9+oS5cuio6OVoMGDaziGzRooHXr1kmSoqOjLWuxS5LRaFT9+vUVFRWl+vXr69KlS2rYsKGlv3bt2ipfvryio6N17tw5+fn5yc3NzdLfsGFDHTt2TKmpqXJ2ZvIAijc3t0qW2zmfc/O6f30cAAAovQpdRN+0adPNgwAoIyNDJtPfMyTPnTurc+fOWsWYTCZlZGRYXa4NAJCkv4sWOQXzm8UBpUWPHj1Uu3Ztfffddzpx4oQMBoMCAgL06quv3vKyivHx8ercubOysrLUp08fDR8+XM8//7x8fHys4tzd3ZWYmChJSkpKsiqCS9eK8omJiUpKSpIkubq6WvW7urpa+m/syzlXYmJivkV0g+GWnhZwxwQHh1pmnA8Z8oqio/cqOTlRbm6V1LBhqP7zn9mWOH5vAQAo/QpdRPfz88uz3WQyqX///vryyy8LnRRQmqxfv8Zy+59msaxfv0Y9evS+6/kBQHFmMBRs+5aCxgElTXBwsGUjz/w8++yz+vjjj/8xxs/PT1FRUTpx4oTGjx+v119/vUCPf/245Vb7b3bsjTw8nGRnx79lFA+//LLHcnvevPesfp8jIzdbbh8/flBt27a9q7kBAIC7r9BF9NTUVH344Yfat2+fMjMzLe3nz59XRkZGkSQHlAaJiRclSeXKlZODg6PVer4VKzopIyNdmZmZljgAwN+8vLyLNA4ojXbu3FmgOIPBoJo1a2rEiBHq27ev2rVrZ5lRniMxMdGy3nqlSpVy9SclJSkwMNASk5SUJCcnJ0t/cnKyPD09lZ2dneexBoMh3/XcL15MY0Yvio1Tp85Ybt/4hdD190+dOqPz5y/dtbwAAEDR8/JyuWlMoad6TJgwQb///ruaNGmiffv2qXXr1nJzc5Obm5sWL15c2NMCpY7h/38azMzM1NWrV6z6rl69YvkSysCnRgDIZf/+qCKNA8qabdu2qXPnzlZLyxmN1z4ChIaGat++fVbx+/bts2wkGhwcrOjoaEtfdna2/vrrLzVq1Ej+/v5yc3Oz6j906JAyMjIss+dPnz6tixf/niQQFRWlOnXqWBXdb2Q288NP8fhxcXEv0L8xFxd3m+fKDz/88MMPP/zc3k9BFLqI/uuvv+qTTz7RiBEjZDQa9fLLL+ujjz5S9+7dtXr16sKeFih1qla9fumjGwvlhnziAADStSvfijIOKGuCg4OVmpqqmTNn6sqVK7p48aLmzJmjZs2aqV+/foqPj9eKFSuUnp6un376ST/99JP69OkjSerXr5++/fZb/fnnn7py5YrmzZsnBwcHtW/fXnZ2durTp4/mz5+v06dPKzExUe+++64efPBBeXl5qUGDBgoJCdGsWbOUmpqqo0ePatGiRerXr5+NXxGgYDw9vYo0DgAAlGyFLqKbzWa5uFyb6l6uXDldvnxZktSnTx8tW7asaLIDSoHr1+nNzs6y6rv+Puv5AkBuN17Bc7txQFnj4uKiTz75RPv27VOrVq3UtWtXubi46N1335Wnp6c++ugjff7552ratKnefvttzZw507JpaVhYmEaOHKlXXnlFLVq00NatW7VgwQLLRujDhw9Xo0aN1KNHD3Xs2FFOTk6aMmWK5bE/+OADnTt3Tvfee6+eeuopPfLII+rfv79NXgfgVsXFnSzSOAAAULIVek30kJAQTZgwQePHj1dQUJDmz5+vZ555Rn/++afV5aJAWefg4FCkcQBQlhR0TMHYA8hfUFCQlixZkmdf8+bN9d133+V7bP/+/fMtfDs4OGjChAmaMGFCnv1VqlTRwoULbz1hoBg4e/Z0kcYBAICSrdBF9PHjx2vcuHGSpJEjR2rw4MFauHChjEajRo4cWWQJAiVdaurfGw0ZDAY5ODjKbDbJYDAqIyNdORsTXR8HALjmxs3c7Ozs5OrqppSUZGVnZ+cbBwDA7cjIyLDcrl69pjw8vJSVlSV7e3tdvHheJ08ezxUHAABKr0IX0atXr67PPvtMktSsWTNt2bJFMTEx8vX1lY+PjyVu586datas2e1nCpQCZrNZ6elXbZ0GAJQY15a6+nuWeXZ2thITL+YTB5RNfIkEFL3rv6jN2YxXMt9w3zoOAACUXkX2idPV1VWNGze2KqBL0rPPPltUDwGUSIYb9xK9zTgAKFsKWhykiIjSZ+zYsXm2p6amaujQoZb7M2bMuFspAWWGvf3f882OH4/Rn3/u1L59e/Tnnzt1/HhMnnEAAKD0uuN/8ZkZg7LO2dmlSOMAoCyxs7Mv0Cw/OzuKGCg9YmNjdfz4cUVERCg8PDzXePrEiRP65ZdfLPcfeuihu50iUOq5ubnrzJlTBYoDAACl3x3/xGlgei3KuIIu38IyLwCQW7lyDsrISC9QHFBaHDhwQB988IEyMzPzvKrT0dFRffv2tUFmQNlRr14DHTz4V4HiAABA6ce0LeAOS01NK9I4AChLvLy8lJZ2842Xvby87kI2wN3x4IMP6sEHH1SPHj303Xff2TodoEy6ePF8geMCAgLvcDYAAMDWKKIDd1hWVlaRxgFAWVLQDdvY2A2l0Xfffafs7GydO3dOV6/mvmKtVq1aNsgKKBtOnYov0jgAAFCyUUQH7rDKlX0UG3u8QHEAAGuXL18u0jigJFm9erX+9a9/KTU1Nde66AaDQfv377dRZkDpV9BlwlhODACAsoEiOnCHVahQsUjjAKAsSUtLLdI4oCSZOXOmnn76aXXp0kXly5e3dTpAmRIYWE8HDkRLkgYNGq7ffvtFSUkX5e7uoVat2mrBgg8scQAAoPS740X0mjVr3umHAIq1q1evFGkcAAAoG9LS0jRkyBDZ2dnZOhWgzDl+PMZyO6dgLkknTx7X3r27reLq1Kl7V3MDAAB3X6GL6NnZ2frf//6no0ePKj09PVf/yJEjJYnNkFDmnT172nLbYDBYXY59/f3r4wAA1zg7Oys9Pfda0HnFAaVNx44d9fvvv6tNmza2TgUoc5KTE4s0DgAAlGyFLqK/9tpr2rhxo4KCgnJdXmowGG47MaC0yNkw1MnJWQaDQamplyx9Tk7OMpnMunw5lY1FASAPeX1RfztxQElSu3ZtjRkzRvfcc4+qVasmo9Fo1Z8zaQVA0XN1dS/SOAAAULIVuoj+448/atWqVapTp05R5gOUOq6ubjp9Oj7P9XqvL6i7urrdzbQAoERgSSyUZb/88ouqV6+uCxcu6MKFC1Z9TFoB7iw3N/cijQMAACVboYvo7u7uqlat2m0n8PPPP2v06NFq2bKlZs+enW/cG2+8oYiICKs1IR0dHbVz587bzgG4kxo0CNHBg38VKA4AYC0721SkcUBJsmTJElunAJRZKSlJRRoHAABKtkIX0YcPH65Zs2Zp5MiRqlChQqHOsXDhQq1cuVI1atQoUPyQIUM0bNiwQj0WYCvVqlUv0jgAKEscHR109erN10R3dHS4C9kAd9/hw4e1fv16xcfHS5Jq1Kihrl27yt/f38aZAaVbQsK5Io0DAAAlm/HmIXlbtGiRvvnmGzVt2lT33nuv2rZta/VTEI6OjrdURAdKooMH9xdpHACUJeXKFaw4XtA4oCRZu3atevbsqZ9++kkZGRnKyMjQhg0b1LVrV67GBO6wgu5XxL5GAACUDYWeiT5gwIDbfvCnnnrqluJ/++03bdq0SSdOnFDt2rU1ceJEBQcH33YewJ20YcP3BY5r2JAlXQDgepcvpxVpHFCSzJ07VzNmzFB4eLhV+6pVqzRjxgx99dVXNsoMKP1YTgwAAFyv0EX0nj175ts3a9aswp42X/7+/jIajXr55Zfl5OSkuXPnauDAgVq/fr0qVaqU5zHst4TiwVzgOH5nAcDarRQxeA9FaXPq1Cl17tw5V3v37t319ttv2yAjoOy4evVykcYBAICSrdBFdEn68ccftW/fPmVkZFjazp49q//9738aNWrUbSd3vaFDh1rdf+2117RmzRpt3LhRjz32WK54Dw8n2dkVerUawCa8vFxsnQIAFCvlytkrMzOzQHG8h6K0qVq1qvbs2aMmTZpYtUdHR8vT09NGWQFlQ3r6zffjuJU4AABQshW6iD5nzhx98sknCgoK0t69e3XPPffo6NGj8vHx0ZQpU4oyxzzZ2dnJ19dX587lvZHLxYtpzEhDiXP+/CVbpwAAxYqhgH/MDQYD76EoNorqC52nnnpKgwYN0sMPP6zatWtLkmJiYrR69WoNHjy4SB4DQN5MpoJdCVXQOAAAULIVuoi+cuVKffXVVwoMDFRoaKiWLl2q9PR0TZo0Sfb2tzXBPRez2axp06apZ8+eqlevniQpIyNDJ0+elL+//z8cV6RpAIVSrly5As6iLMfvLADc4Pqr3W4Wx3soSpu+ffuqcuXK+vrrr7V7925lZGSoevXqmjRpUq510gEAAADcOYWudl+6dEmBgYGSrs0Kz87OlqOjo0aOHKl+/frpwQcfvK3Ezp49q6effloLFy6Uv7+/4uLiNGnSJL333ntydnbW+++/r3LlyumBBx64rccB7jQ7O7sCFdHt7OzuQjYAAKCk2LNnjzp06KAOHTrYOhUAAACgTCv0ouE1a9bUqlWrZDabVbVqVW3cuFGSlJWVpQsXLhToHCEhIQoJCdF3332nH374wXJfkjIzM3Xs2DHLDLQpU6aoZs2a6tWrl9q0aaP9+/frs88+U8WKFQv7FIC7wmgsWHG8oHEAAKBsePbZZwt8NQYAAACAO6fQM9FHjhyp4cOHq1OnTnr66ac1cuRIBQQE6MyZM7r//vsLdI6oqKh8+6pVq6aDBw9a7ru7u2vq1KmFTRewGZOpYOsLFDQOAACUDcOGDdP06dPVv39/Va1aNddVaw4ODjbKDCj9ypVzUGbmzb/EKleOf4cAAJQFhS6it23bVr/++qsqVKigPn36yN/fX1FRUfLz81Pnzp2LMkegRLt69XKRxgFAWWIwGGQuwGLnBd2AFChJ3nvvPWVlZWnZsmV59u/fv/8uZwSUHbeysTUAACj9bmsH0AoVKig+Pl7x8fGyt7dXjx495OPjU1S5AQCAMq4gBfRbiQNKko8++sjWKQBlVkZGepHGAQCAkq3QRfT4+Hi98sor2rdvn+WDq8FgUKtWrfTee+/Jzc2tyJIEAAAAyoLBgwdbiucfffSRPv74YxtnBAAAAKDQRfR///vfqlq1qqZNm6bq1atLko4ePar33ntPb7/9tqZPn15kSQIlWfnyFXT16pUCxQEAgLJt7969mjlzpqpXr67ff/9dX331Vb5XWjz++ON3OTsAAACgbCp0EX379u36+eef5eTkZGmrV6+epk+frq5duxZJckBpkJWVVaRxAACg9HrzzTf13//+V6mpqcrOztb8+fPzjDMYDBTRAQAAgLuk0EX0ihUrKjMzM88+k8lU6ISA0iYrK+9/J4WNAwAApdfDDz+shx9+WJLUoUMHbd682cYZAQAAADAW9sA2bdpo1KhRioqKUlpamtLS0hQVFaVRo0apWbNmRZkjAAAAUObkFNDPnTunffv2KTo6WhcvXrRxVgAAAEDZU+iZ6G+99ZbGjh2rPn36SJJlrca2bdtq4sSJRZIcAAAAUFYdP35cI0aM0IEDByxjbYPBoODgYM2aNcuyLxEAAACAO+uWiujHjh2zuj9y5EgNHDhQBoNBBoNBmZmZ8vT0VHJysjw8PIo0UQAAAKAsGTlypOrUqaNp06bJz89PZrNZ8fHxWrhwoV5++WV98803tk4RAAAAKBNuqYjepUsXGQwGq5kwNzKbzTIYDNq/f3/RZAgAAMosOzt7ZWfffONlO7tCX1wHFFtHjx7V0qVLVaFCBUtbvXr19K9//Utt2rSxYWYAAABA2XJLnzg3bdp0p/IAAADIxWg0KDu7YHFAaVO3bl2dOXNGtWrVsmq/cOGC6tata6OsAAAAgLLnlorofn5+dyoPAACAXLKybj4L/VbigJKkf//+evnll9WzZ0/VrFlT2dnZio2N1XfffafevXvrl19+scS2bdvWhpkCAAAApRvXPgMAgGIrZwm5oooDSpIxY8ZIkqZPn56rb/LkyZbbLKUIAAAA3FkU0QEAAIBi6MCBA7ZOAQAAAIAko60TAAAAAPC3evXqqX79+rl+GjdurMcff1y7d+++pfPFx8dr6NChatmypdq0aaM33nhDKSkpkqT9+/friSeeUNOmTdWpUyd98sknVseuXbtWDz/8sO655x716tXLagkZk8mk2bNnq2PHjmrevLmeffZZxcbGWvqTkpL0yiuvqE2bNmrbtq3Gjh2rq1ev3sYrAwAAANgGM9EBAACAYmThwoV5tl+6dEl//PGHBg4cqDlz5ui+++4r0PleeOEFBQcHa/Pmzbp06ZKGDh2q6dOna9y4cRo8eLD69OmjBQsW6NixYxo4cKCqVaumTp06af/+/Ro9erTmzp2rVq1aaf369XrppZf0ww8/qEqVKlq6dKlWr16thQsXysfHR7Nnz9bQoUP13XffyWAwaNy4ccrIyNCaNWuUmZmpl19+We+8847eeuutony5AAAAgDuOIjoAAABQjPxTcTw8PFz16tXTggULClRET0lJUXBwsEaNGiUnJyc5OTmpZ8+eWrJkiX788UdlZmZqyJAhsrOzU8OGDfXYY49p+fLl6tSpk1asWKF27dqpXbt2kqTu3bvr888/V0REhAYNGqTly5drwIABql27tiRpxIgRatmypfbs2aNq1app48aN+uabb+Th4SFJevHFF/Xyyy9r9OjRKleuXBG8UgAAAMDdQREdAAAAKEHCw8M1c+bMAsW6urpq6tSpVm2nT59W5cqVFR0draCgINnZ2Vn6GjRooBUrVkiSoqOjLQX06/ujoqJ09epVHTlyRA0aNLD0OTs7q0aNGoqKitKlS5dkZ2enoKAgS3/Dhg11+fJlxcTEWLVfz2Ao0NMCihV+bwEAKP0oogMAAABlRFRUlD7//HPNmzdP69atk6urq1W/u7u7kpKSZDKZlJSUJDc3N6t+Nzc3HTlyRMnJyTKbzXn2JyYmyt3dXc7OzjJcV13MiU1MTMwzNw8PJ9nZsWUTSh4vLxdbpwAAAO4wiugAAABACbJ69Wo1bNjwlo/btWuXhgwZolGjRqlNmzZat25dnnHXF77NZvM/nvOf+m927I0uXkxjRi9KpPPnL9k6BQAAcBsK8oU4RXQAAACgGFm+fHme7VeuXNFff/2lH374QUuWLLmlc27evFmvvfaaxo0bp0ceeUSS5OHhoePHj1vFJSUlyd3dXUajUZUqVVJSUlKufg8PD0tMXv2enp7y8PBQamqqsrOzLcvF5MR6enrmm+ct1t2BYoHfWwAASj+K6AAAAEAx8tFHH+XZXq5cOQUEBOiTTz5Ro0aNCny+3bt3a/To0Xr//ffVtm1bS3twcLC++OILZWVlyd7+2seCqKgoy7mDg4O1b98+q3NFRUWpa9eucnR0VGBgoKKjo9WiRQtJ1zYxPXnypEJDQ+Xn5yez2awDBw5YZs1HRUXJ1dVVtWrVKviLAQAAABQDFNEBAACAYmTz5s1Fdq6srCy99dZbevXVV60K6JLUrl07OTs7a968eXruued06NAhrVy50rJpaZ8+fdS7d2/9+OOPat26tVavXq3jx4+re/fukqR+/fppwYIFCgsLk4+Pj9555x3Vr19fISEhkqTOnTvrvffe0/Tp05WRkaEPP/xQvXv3thTsAQAAgJKCESwAAABQSv355586evSoJk+erMmTJ1v1/fDDD5o/f74mTJigBQsWyMvLSyNGjFD79u0lSXXr1tU777yjqVOnKj4+XnXq1NFHH30kb29vSVLfvn2VkJCgJ598UmlpaWrZsqXmzp1rOf+//vUvTZgwQR07dlS5cuXUrVs3jRgx4q49dwAAAKCoUEQHAAAASqlmzZrp4MGD/xjzxRdf5NvXqVMnderUKc8+g8Gg4cOHa/jw4Xn2u7i46N133y14sgAAAEAxZbR1AgAAAAAAAAAAFFcU0QEAAAAAAAAAyAdFdAAAAAAAAAAA8kERHQAAAAAAAACAfFBEBwAAAAAAAAAgHzYvov/8889q06aNRowY8Y9xJpNJs2fPVseOHdW8eXM9++yzio2NvUtZAgAAAAAAAADKIpsW0RcuXKjJkyerRo0aN41dunSpVq9erQULFmjLli2qWbOmhg4dKrPZfBcyBQAAAAAAAACURTYtojs6OmrlypUFKqIvX75cAwYMUO3ateXs7KwRI0bo6NGj2rNnz13IFAAAAAAAAABQFtm0iP7UU0/JxcXlpnFXr17VkSNH1KBBA0ubs7OzatSooaioqDuZIgAAAAAAAACgDLO3dQIFkZycLLPZLDc3N6t2Nzc3JSYm5nucwXCnMwOKFr+zAFB4vIcCAAAAxYvJZFJ8fKzS0lLl5OQsPz9/GY0236IRuGUlooie41bWP/fwcJKdHf8oUbJ4ed38ygwAQN54DwUAAACKj8OHDyoycpNSUpItba6ubgoL66jAwCAbZgbcuhJRRHd3d5fRaFRSUpJVe1JSkjw9PfM85uLFNGakocQ5f/6SrVMAgBKL91AUF3yhAwAAyrrDhw9qzZpVCgioo/DwHvL09NaFCwnavn2r1qxZpW7delFIR4lSIorojo6OCgwMVHR0tFq0aCFJSklJ0cmTJxUaGprvcbcwcR0oFvidBYDC4z0UAAAAsD2TyaTIyE0KCKij7t17y/D/Z7n6+vqpe/feiohYqcjIzapdO5ClXVBiFNvf1LNnz+qhhx5SbGysJKlfv35avHixjh49qtTUVL3zzjuqX7++QkJCbJwpAAAAAAAAAEmKj49VSkqyWrRoYymg5zAYDGrevLVSUpIUHx9rowyBW2fTmeg5BfCsrCxJ0saNGyVJUVFRyszM1LFjx5SRkSFJ6tu3rxISEvTkk08qLS1NLVu21Ny5c22TOAAAAAAAAIBc0tJSJUment559nt5eVvFASWBTYvoUVFR+fZVq1ZNBw8etNw3GAwaPny4hg8ffjdSAwAAAAAAAHCLnJycJUkXLiTI19cvV//58wlWcUBJUGyXcwEAAAAAAABQsvj5+cvV1U3bt2+V+YaNi8xms3bs2CZXV3f5+fnbKEPg1lFEBwAAAAAAAFAkjEajwsI6KibmiCIiVurUqThlZKTr1Kk4RUSsVEzMEYWFdWBTUZQoNl3OBQAAAAAAAEDpEhgYpG7deikycpOWL19iaXd1dVe3br0UGBhkw+yAW0cRHQAAAAAAAECRCgwMUu3agYqPj1VaWqqcnJzl5+fPDHSUSBTRAQAAAAAAABQ5o9Eof/8atk4DuG189QMAAAAAAAAAQD4oogMAAAAAAAAAkA+K6AAAAAAAAAAA5IM10XHXJCUlKj093dZpFGtnz56xdQo24ejoKHf3SrZOAwAAAAAAFCGTycTGoigVKKLjrrhy5bI+/fQjmc1mW6dSrC1btsjWKdiEwWDQ4MHDVaFCRVunAgAAAAAAisDhwwcVGblJKSnJljZXVzeFhXVUYGCQDTMDbh1FdNwVFSpU1IABg8vkTPRbKYz37//MHcyk+HJ0dKSADgAAAABAKXH48EGtWbNKAQF1FB7eQ56e3rpwIUHbt2/VmjWr1K1bLwrpKFEoouOuKavLdYwYMUazZ08tUBwA5IclsW6OJbEAAAAA2zOZTIqM3KSAgDrq3r23DAaDJMnX10/du/dWRMRKRUZuVu3agSztghKDIjpwF9yskE4BHcA/YUmsgmFJLK7oAQAAgO3Fx8cqJSVZ4eE9LAX0HAaDQc2bt9by5UsUHx8rf/8aNsoSuDUU0YG75FohfYak7Ota7TRixOu2SglACVGWl8Q6fvyotm6NvGlcmzZhqlmz9l3IqPhhSSwAAAAUJ2lpqZIkT0/vPPu9vLyt4oCSgCI6cBeNGPG6zp49o2XLFql//2fk41PF1ikBKCHK6nIdPj5VClREb9ny3ruQDQAAAICbcXJyliRduJAgX1+/XP3nzydYxQElAQsPAQCAYu1mS16xJBYAAABQfPj5+cvV1U3bt2/NtSSl2WzWjh3b5OrqLj8/fxtlCNw6iugAAKDYGzFijDp1Crdq69QpnAI6AAAAUMwYjUaFhXVUTMwRRUSs1KlTccrISNepU3GKiFipmJgjCgvrwKaiKFFYzgUAAJQIDRs2kpeXD0tiAQAAAMVcYGCQunXrpcjITVq+fIml3dXVXd269VJgYJANswNuHUV0AAAAAAAAAEUqMDBItWsHKj4+VmlpqXJycpafnz8z0FEiUUQHAAAAAOSSlJSo9PR0W6dR7J09e8bWKdx1jo6OZXbTcwC3xmg0yt+/hq3TAG4bRXQAAAAAgJUrVy7r008/yrUhHHJbtmyRrVO46wwGgwYPHq4KFSraOhUAAO4KiugAAABAKffzzz9r9OjRatmypWbPnm3Vt3btWs2bN09xcXGqVauWRo4cqbZt20qSTCaT3n//fa1Zs0YpKSkKDQ3VxIkT5e/vL0lKSkrSxIkTtX37dhmNRrVr107jxo1T+fLlJUn79+/XlClTtH//fnl6eqpv374aOHDg3X3yKJQKFSpqwIDBZXYm+q0Uxvv3f+YOZlI8OTo6UkAHAJQpFNEBAACAUmzhwoVauXKlatTIfSn1/v37NXr0aM2dO1etWrXS+vXr9dJLL+mHH35QlSpVtHTpUq1evVoLFy6Uj4+PZs+eraFDh+q7776TwWDQuHHjlJGRoTVr1igzM1Mvv/yy3nnnHb311lu6evWqBg8erD59+mjBggU6duyYBg4cqGrVqqlTp042eCVwq8rych0dOnTS5s0bChTHRtcAAJR+rOQPAAAAlGKOjo75FtFXrFihdu3aqV27dnJ0dFT37t1Vt25dRURESJKWL1+uAQMGqHbt2nJ2dtaIESN09OhR7dmzR+fPn9fGjRs1YsQIeXh4yMfHRy+++KK+/vprZWZm6scff1RmZqaGDBmiihUrqmHDhnrssce0fPnyu/0SALesUaOmRRoHAGWVyWRSbOwJHTgQrdjYEzKZTLZOCSgUZqIDAAAApdhTTz2Vb190dLTatWtn1dagQQNFRUXp6tWrOnLkiBo0aGDpc3Z2Vo0aNRQVFaVLly7Jzs5OQUFBlv6GDRvq8uXLiomJUXR0tIKCgmRnZ2d17hUrVuSbj8FQmGcI3BkjR47Ru+9O/cd+AED+Dh8+qJ9+2qSUlGRLm6urm9q166jAwKB/OBIofiiiAwAAAGVUUlKS3NzcrNrc3Nx05MgRJScny2w259mfmJgod3d3OTs7y3Bd5TsnNjExUUlJSXJ1dbU61t3dXUlJSTKZTDIarS+K9fBwkp0dF8qieHn77be1detWrVmzxtLWrVs3tWnTxoZZAUDxt2/fPq1Z842CgoLUv38/+fj46OzZs/rxxx+1Zs036tevn4KDg22dJlBgFNEBAACAMsxsNhe6/2bH5sWQz3TzixfTmImOYqlu3RD93/95a+nSRfq//3tGPj5VdP78JVunBQDFlslk0po136tWrdrq0uURGQwGXbqUoYoVK6lLl0eUkbFS33+/VpUr++f6Uh2wBS8vl5vGUEQHAAAAyqhKlSopKSnJqi0pKUkeHh5yd3eX0WjMs9/T01MeHh5KTU1Vdna2ZcmWnNic/uPHj+c6Nue8eSlETR64K3J+N81mfk8B4Gbi4mKVkpKs8PAekgw3vG8a1Lx5ay1fvkRxcbHy98+9ZwtQHPF1DwAAAFBGBQcHa9++fVZtUVFRatSokRwdHRUYGKjo6GhLX0pKik6ePKnQ0FDVr19fZrNZBw4csDrW1dVVtWrVUnBwsA4ePKisrKxc5wYAAKVXWlqqJMnT0zvPfi8v7//X3p3HWV3W/eN/DduwDjiOopFbGhiC3iiI4hrkrriklhZKbqRfcck9MTQpMeW2QiGLO8nKW2/MEk1xwZRSMhO1Ac1ySYU7URwGHBhAhvn94e38muAg+xnk+Xw8eBzOZ7k+7w8crrl4netcp9FxsDEQogMAwCbqxBNPzFNPPZXHH388ixcvzt13351//OMfGThwYJLkpJNOyu23355XX301NTU1ufHGG/O5z30uPXv2THl5eQ455JB8//vfT1VVVd5+++3ccsstOf7449OiRYsccMABad++fcaOHZva2tq88MILufvuu3PSSScV+a4BgPWpXbv2SZL33nt3hfvnzHm30XGwMSjqci6zZs3KNddckxdeeCFt27bN4Ycfnosuumi5j3eOHj06Y8aMSYsWjcv93e9+l4qKig1ZMgAAbFR69uyZJA0zwh999NEkH84K79q1a2688cZcd911mTVrVnbaaafceuut2WKLD2eIffnLX867776bQYMGZcGCBenbt29uvvnmhra//e1vZ/jw4RkwYEBatmyZI488MhdeeGGSpFWrVvnRj36U4cOH58c//nEqKipy4YUX5sADD9yAdw8AbGhdumyTsrKO+dOfnsrAgcc3+j6U+vr6PPPM1JSVdUqXLtsUsUpYPUUN0YcOHZpddtkljz76aN57770MGTIkFRUV+drXvrbcsUcffXRGjhxZhCoBAGDjVVlZudL9Bx98cA4++OAV7ispKcl5552X8847b4X7O3TokP/8z/8s2HbXrl3z3//936teLACw0WvWrFn2339A7r//nkyceHf69Nk7FRVbZM6cd/PMM1Pz2muv5Mgjj/OlomxUihaiV1ZW5q9//Wtuu+22dOjQIR06dMjgwYPzs5/9bIUhOgAAAADQ9H32s91y5JHH5fHHH8ldd/28YXv79mU58sjj8tnPditidbD6ihaiz5gxI126dEnHjh0btu2yyy55/fXXU1NTk/btG6+L9PLLL+fLX/5y/va3v2XrrbfOFVdckX333Xel1/iXT4tAk/HR67KkxGsUYHXpQwEAYOPwz3/OWu7LQxcseD///OcsITobnaKF6NXV1SkrK2u07aNAfe7cuY1C9K222irbbLNNLrroomy55Za566678vWvfz0TJ07MZz7zmRW2X17eLs2b+1gITc/ixfOTJJ06tU1FRYciVwOwcdGHAgBA0zdlymN59tmn07Zt2+y8c4907Ngp8+ZV569/nZ5nn306SbL//v2LXCWsuqKuiV5fX79Kx51wwgk54YQTGp4PHjw4v/3tbzNx4sRccMEFKzynqmqBGWo0SdXVCxseS0vfL3I1ABsXfSgbA2/wAACbsqVLl2batD+lVavSNG/eItOm/alhX4cOZWnVqjTTpj2Tfv32T4sWRY0mYZUV7ZVaXl6e6urqRtuqq6tTUlKS8vLyjz2/S5cueeedd1Z6zCpm9LBBffS6rK/3GgVYXfpQAABo2l54YVrq6+uzZMnifPrT2+SII47J5ptvkffeezd/+tNTee21VxqO22OPPYtcLayaoq130qNHj/zzn/9MVVVVw7bKysrstNNOadeuXaNjx4wZk6lTpzba9uqrr2abbbbZILUCAAAAAB+vunpukmTbbbfPwIHHZ+utu6RVq1bZeusuGTjw+Gy77faNjoONQdFmonfv3j09e/bMqFGjcsUVV2T27Nm57bbbctpppyVJDj300IwYMSK9e/dOdXV1rrnmmowZMyZdunTJL3/5y7z55ps59thji1X+Kpk/f15qa2uLXQZNTFXVnEaP8K/atGmTsrKOH38gAAAANGGdO2+Vkn9ba7mkpCRbbtk5b775j+IUBWuoqAsP/fCHP8xVV12VffbZJ+3bt8+Xv/zlnHzyyUmS119/PQsXfrju6UUXXZTkw7XQq6urs9NOO2X8+PHZaqutilb7x5k/f15+9rOfZOnSD4pdCk3UpEn3FbsEmqAWLVrm1FPPFKQDAACwUdp660/lL3+ZlunT/5J+/Q5Is2b//0IYy5Yty4wZlQ3HwcaiqCH6VlttlZ/85Ccr3Pfyyy83/L60tDTf/OY3881vfnNDlbbWamtrs3TpB+nae2DadqgodjnARmDh+3Pytz9PTG1trRA9Ps3Divk0Dyvj0zwAAMXXoUNZkqS2dmF+8pPR2Xvv/fOZz+yU1157JVOnTklt7cJGx8HGwFfgrmdtO1SkfaemO2MeoCn68NM8P87SpUuLXQpNlE/zsCItWrTIqaeeJUgHACiiLl22SVlZx5SUlGT+/HmZPHlSJk/+cF9JSUk6duyU+voPj4ONhRAdgCbnw0/zLM3hu2yT8ralxS4H2AhULVycB2a85dM8AABF1qxZs+y//4Dcf/89adaseerr6xr2lZQ0y7x51TnyyOMaLfMCTZ0QHYAmq7xtaTqXtS12GQAAAKyBZs1KsmxZ4eewsRCiAwAAAADrxLJlyzJlyuR85jM75cgjj8v//u/MLFhQk3bt2udTn/p07r//nkyZ8lh23PGzZqOz0RCiAwAAAMA6VF09N4sXLy52GUUxe/Y/M3/+vOy1176ZM+fdtGpVmlatPlymc86cd7Pjjt3y2muvZPr0F9K589ZFrnbDKy0tTadOmxW7DFaTEB0AAAAA1pHa2oUZP/7W1NfXF7uUonr44d+udP/kyZM2UCVNS0lJSYYMOS9t2li6dGMiRAcAAACAdaRNm7YZPHjIJj0TffLkSTn44CNSUbFlqqrmZNKk+3LooUelvLwi7777Th555LcZMODQTXYmugB94yNEBwAAAIB1aFNermOLLbbMM89MzSuvvJzu3Xs2bC8vr8iWW3bOH//4+5SVdUqPHrtZE52NhhB9PVv4/pxilwBsJPQXAFB88+fPS21tbbHLoImpqprT6BE+0qZNm5SVdSx2GdCkNGvWLPvvPyD3339PJk68Ozvu2C1J8u677+SPf/x9XnvtlRx55HECdDYqQvT17G9/nljsEgAAgFUwf/68/OxnP8nSpR8UuxSaqEmT7it2CTQxLVq0zKmnnilIh3/z2c92y5FHHpcpUybntddeSZI88shvU1bWKUceeVw++9luRa4QVo8QfT3r2ntg2naoKHYZwEZg4ftzvPH2b95bsKjYJQAbCf0F60JtbW2WLv3AGB5YJR+N32tra4XosAKf/Wy37LjjZzN9+guZPHlSBgw41BIubLSE6OtZ2w4Vad9pq2KXAbBRevDFmcUuAYBNkDE8AKwbzZo1a/jy0M6dtxags9ESogPQZB3W/dPZvF3rYpcBbATeW7DIG28AAMB6IUQHoMnavF3rdC5rW+wyAAAAgE2Yz1AAAAAAAEABQnQAAAAAACjAci7r2cL35xS7BGAjob8AAAAAaHqE6OtJmzZt0qJFy/ztzxOLXQqwEWnRomXatGlT7DIAAAAA+D9C9PWkrKxjTj31zNTW1ha7FJqYqqo5mTTpvhx66FEpL68odjk0MW3atElZWcdilwEAAADA/xGir0dlZR2FYRRUXl6Rzp23KnYZ0KRVLVxc7BKAjYT+gnXJEmvAqtBXAGw6hOgANDkfLonVIg/MeKvYpQAbkRYtWlgSi3XCkowAa2b+/Hk+kc9yqqrmNHqEj2xMn8YXogPQ5Hy4JNZZBuAsx5JYrMzGNAinaevae2DadtDHACu38P053nT7F/Pnz8vPfvbjLF26tNil0ERNmnRfsUugiWnRokVOPfWsjWIML0QHoEmyJBYrY0ksYH1q26Ei7TvpYwBWR21tbZYuXZrDd9km5W1Li10O0MRVLVycB2a8ldra2o3i//5CdAAAAADWifK2pelc1rbYZQCsU82KXQAAAAAAADRVQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoABfLAoAAKwXs2bNyjXXXJMXXnghbdu2zeGHH56LLroozZqZywPwSfXegkXFLgHYCGxsfUVRQ/TVGVTffvvt+eUvf5l333033bp1y5VXXpkePXoUoWoAAGBVDB06NLvsskseffTRvPfeexkyZEgqKiryta99rdilrdTC9+cUuwRgI6CvWLEHX5xZ7BIA1rmihuirOqh+7LHHMnr06IwbNy7dunXL7bffnq9//et5+OGH07Zt2yJVDwAAFFJZWZm//vWvue2229KhQ4d06NAhgwcPzs9+9rMmG6K3adMmLVq0zN/+PLHYpQAbiRYtWqZNmzbFLqNJOaz7p7N5u9bFLgNo4t5bsGijetOtaCH66gyq77rrrhx33HHZbbfdkiRnnHFGbr/99vzud7/LEUccUYzyWQPV1XOzePHiYpdRdFVVcxo9kpSWlqZTp82KXQYAsA7NmDEjXbp0SceOHRu27bLLLnn99ddTU1OT9u3bF7G6FSsr65hTTz0ztbW1xS6FJqaqak4mTbovhx56VMrLK4pdDk1ImzZtUlbW8eMP3IRs3q51OpeZ8Ah8shQtRF+dQfWMGTNy+OGHNzxv1qxZPve5z6WyslKIvpGorV2Y8eNvTX19fbFLaTImTbqv2CU0GSUlJRky5Ly0aWOgBYV4I/JD3ohcnjciaaqqq6tTVlbWaNtHY/+5c+euMEQvKdkgpa1Ux44dG/0fZVPmZ8//76PXZklJ03idFpufPazIR/82qhbqN5Lk/UUfZEldXbHLoAlq1bx5OrRuWewyiu6jvmJj+dlatBB9dQbV1dXVyw1kO3bsmLlz5670GhvDX8Cmom3btvna14YYhLNCpaWllmaClfBG5PK8Efn/Kykpyde/7o1ImqbV6bfKy9uleXNfONpULFiwIDfd5GfPv3vwQT9/kg8ntl1xxRVp165dsUuhCWnRoi4tW7bIAzPeKnYpwEaiZcsW6dJli3Tq1KHYpXysoq6JvjoDstUdvBmENz0VFU3/HwRA09QhF110keUFWKE2bdqkvLy82GXAcsrLy1NdXd1oW3V1dUpKSlb4mq2qWmASTBNjEgyFlJaWprZ2WWpr3y92KTQpzXPqqWcZs/6f999/Px98oA9leS1blqZDBxlZ8uH/ZZYubZ45c4r782RVMsuiheirM6jebLPNVnjsZz/72YLtG4QD8MnSMqWlPvLH8pYtS9EHnTRm4sCHevTokX/+85+pqqpqGN9XVlZmp512Kjh71aTnpqVjR8t1UJh/r6xIhw4d06GDJbGSZMsttyp2CbBR2Fh+nhQtRF+dQXWPHj0yY8aMHHvssUmSurq6vPjiizn++ONXeo2N5S8BAAA+abp3756ePXtm1KhRueKKKzJ79uzcdtttOe2004pdGgAArJairXfyr4PqmpqavPrqq7ntttty0kknJUkOPfTQ/PnPf06SnHTSSfnNb36T559/PrW1tRk7dmxatWqVAw88sFjlAwAAH+OHP/xh3nnnneyzzz455ZRTcswxx+Tkk08udlkAALBaSuqL+E0xb7/9dq666qr86U9/Svv27fPlL3855557bkpKStKtW7f85Cc/yf77758kueOOO/LjH/847733Xnr27Jmrr746Xbt2Ldj2u+/6WDMAABveFltYzmVNGL8DAFAMqzJ+L2qIvj4ZhAMAUAxC9DVj/A4AQDGsyvi9aMu5AAAAAABAUydEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAWU1NfX1xe7CAAAAAAAaIrMRAcAAAAAgAKE6AAAAAAAUIAQHQAAAAAAChCiAwAAAABAAUJ0aGIWLlyYU045JbvttlueffbZtWrrnnvuyT777LOOKgMojnHjxqV37965+uqr17qtbt26ZcqUKWtfFAD8C2N4gMaM4fmkaVHsAqAY+vfvn6VLl2bSpElp27Ztw/ann346V1xxRR577LHVbvPpp5/OKaecklatWiVJmjdvnu233z6HHnpoBg8enNatW69SO08++WSee+65PPHEEykvL1/tOlbm7rvvTv/+/dd5uwCF9O/fP7Nnz06zZh++b19RUZG+ffvmjDPOyE477bRKbYwdOzYXXHBBBg0atE5rmzFjRubNm5d+/fqt03YBWD+M4Y3hgQ3DGB6WZyY6m6wlS5ZkzJgx67zdP//5z6msrMyUKVNy2WWX5bHHHstJJ52UBQsWrNL5NTU1KSsrW+eD5Lq6uowcOTJz585dp+0CfJxhw4alsrIy06ZNy7hx47LZZpvli1/8YqZOnbpK59fU1GS77bZb53X96le/ylNPPbXO2wVg/TGGB9gwjOGhMSE6m6yhQ4fml7/8ZV5//fWCx7z99ts5++yz07dv3+yxxx658MILU11dvUrtl5WVZe+998748eNTU1OT//qv/2rY98ADD+Too4/Of/zHf2TAgAG56667kiQTJkzIsGHDMmfOnPTs2TPPPPNMqqqqct5552XvvfdO7969c+aZZ+af//xnkmTmzJnp1q1bXn311Ya2b7zxxhW+07vnnnvm/fffz9FHH52bb755le4BYF1q2bJldtxxx1x22WUZNGhQhg0blrq6usyaNStf//rX07dv3/Tp0yeXXnppampqsmTJkvTs2TNJcs4552TYsGFJkvHjx+cLX/hCevXqlcMOOywPP/xwwzUGDRqUG2+8seH5q6++mm7dumXmzJmNarn22mtzxx135Kc//WkOOuigDXD3AKwLxvAAG5YxPHxIiM4ma6eddsqJJ56YESNGFDzmnHPOSYcOHTJ58uQ89NBDeeeddzJ8+PDVuk7btm1z4oknZtKkSUmSysrKXHnllbnkkkvy7LPP5vrrr8/IkSMzbdq0nHDCCbn22mtTUVGRysrK9OnTJzfccEMWLFiQyZMn54knnkiSfPe7313t+7333nsbHs8999zVPh9gXRo8eHBmzpyZ6dOn55xzzsnWW2+dxx9/PJMmTcrs2bNz/fXXp1WrVqmsrEySjBkzJiNGjMgzzzyTUaNGZcyYMZk2bVrOPPPMXHzxxamqqlqt61911VXp06dPTjvttDzyyCPr4xYBWA+M4QGKxxieTZkQnU3a0KFD8/LLL6+w833ppZcyY8aMXHLJJWnfvn0qKipy1llnZfLkyVmyZMlqXWeHHXZoeAf1nnvuyYEHHph99903zZs3T+/evXPYYYc1DJD/3TXXXJPRo0enbdu2adeuXb7whS9k+vTpq3+zAE1IRUVFysrK8vTTT+fvf/97LrnkkrRp0yabb755hg4dmokTJ6a+vn658/bYY488+eST6dq1a0pKSnLkkUdm8eLF+dvf/laEuwCgGIzhAYrDGJ5NmS8WZZPWvn37XHzxxbnuuuuy3377Ndo3c+bMdOzYMVtssUXDtm233TYffPBBZs+enW222WaVr1NXV5fmzZsnSd58881MnTq14eNNSVJfX5999913hee+8cYbGTlyZP7yl79k0aJFWbZsWTp16rQadwnQNC1dujSdO3dOXV1d+vbt22hfXV1d5s6du9zasnV1dbnlllsyadKkRjNXVjcYAWDjZQwPUDzG8GyqhOhs8o455pjcddddufXWW7PXXns1bF9ZZ15SUrJa13jxxRezww47JElat26dk046KVddddXHnrds2bIMGTIke+yxRx566KGUl5dnwoQJ+f73v1/wnLq6utWqDaAY3njjjSxcuDDV1dVp27ZtnnvuuVU675ZbbsmDDz6YH/3oR9l5551TX1+f7t27Fzx+2bJl66pkAJoQY3iADc8Ynk2Z5Vwgybe+9a2MHz8+b731VsO2bbbZJvPmzcucOXMatr322mspLS1N586dV7ntqqqq3HHHHTnqqKOSfDgT5uWXX250zNtvv73CgfOcOXMya9asDBo0qOGd3BdffLFhf2lpaZJk0aJFDdv+9R4AmqrRo0ena9eu2XvvvbNw4cJGfVdNTU3mzp27wvMqKyszYMCAdO/ePc2aNcuMGTMa7W/VqlWjPvHNN99cPzcAQNEZwwNsWMbwbMqE6JDkc5/7XI455phGs0N69uyZHXfcMaNGjcrChQsze/bsjB07NkcccURatmz5sW0uW7Yszz33XM4444zstNNO+cpXvpIkOf744zNt2rT86le/ypIlS/LSSy/lhBNOyEMPPbRcG+Xl5Wnbtm2ef/75LF68OPfdd19eeuml1NTUZMGCBSkvL0+HDh3y8MMPp66uLn/4wx/y/PPPr7Ce1q1bJ0n+8Y9/pKamZvX/kADWgdmzZ+e6667L5MmT853vfCddu3ZNr1698p3vfCdVVVWZP39+hg8fnksvvXSF53fp0iV//etfU1tbm1deeSXjxo1Lhw4dMnv27CTJ9ttvn6lTp2bevHl59913c+eddxaspbS0NDNnzsy8efPWy70CsH4ZwwNsGMbwIESHBhdccEGWLl3a8LykpCRjxozJO++8kwMPPDAnnnhidtttt3zrW99aaTu9e/dOz549s9tuu+Xyyy/P5z//+dx2221p1apVkjQM6seNG5fevXtn6NChOf3003P44Ycv11aLFi1y9dVX58c//nH69euXZ555JqNHj85WW22Vgw8+OM2bN8/w4cPz61//Or17985vfvObhoH+v6uoqMghhxyS888/f6UfJQVY10aMGJGePXumR48eGThwYGbPnp0JEyZk1113TZKMGjUq9fX1GTBgQA466KDU1dVl5MiRK2xryJAhqaury1577ZXLL788Q4cOzbHHHpsRI0Zk8uTJOf3009OhQ4fsv//+Oe2003LqqacWrOu4447LlClTcvDBB/sYPcBGyhgeYP0whofGSupX9LW5AAAAAACAmegAAAAAAFCIEB0AAAAAAAoQogMAAAAAQAFCdAAAAAAAKECIDgAAAAAABQjRAQAAAACgACE6AAAAAAAUIEQH2MiMGzcuvXv3ztVXX73WbXXr1i1TpkxZ+6IAAIAVMn4H2Pi1KHYBAJuK/v37Z/bs2WnW7MP3LysqKtK3b9+cccYZ2WmnnVa5nbFjx+aCCy7IoEGD1ml9M2bMyLx589KvX78V7v/ggw8yduzY/Pa3v83s2bNTUlKSHj165Pzzz0/v3r1XqY1/d/fdd6d///4pLy9fZ/cBAADrgvH78ozfgU2VmegAG9CwYcNSWVmZadOmZdy4cdlss83yxS9+MVOnTl3lNmpqarLddtut89p+9atf5amnniq4f+TIkXnsscfywx/+MM8++2x+//vfp1+/fjnttNPy1ltvrVIb/6quri4jR47M3Llz10n9AACwrhm///+M34FNmRAdoAhatmyZHXfcMZdddlkGDRqUYcOGpa6uLkkya9asfP3rX0/fvn3Tp0+fXHrppampqcmSJUvSs2fPJMk555yTYcOGJUnGjx+fL3zhC+nVq1cOO+ywPPzwww3XGTRoUG688caG56+++mq6deuWmTNnNqrn2muvzR133JGf/vSnOeigg1ZY85NPPpkjjjgi3bp1S/PmzdO+ffucffbZGTFiRFq1arXCNt58882cfvrp6du3b/r27ZtvfOMbmT9/fpJkzz33zPvvv5+jjz46N998c+65557ss88+ja554oknZvTo0UmS119/PYMHD07v3r3Tp0+fnHvuuQbwAABsEMbvxu/Apk2IDlBkgwcPzsyZMzNjxozU19fnnHPOydZbb53HH388kyZNyuzZs3P99denVatWqaysTJKMGTMmI0aMyDPPPJNRo0ZlzJgxmTZtWs4888xcfPHFqaqqWq0arrrqqvTp0yennXZaHnnkkRUes8MOO+TXv/51XnrppUbbBw4cmM6dO6+wjWHDhmXLLbfM73//+zz44IN5/fXXM2bMmCTJvffe2/B47rnnfmyN1157bXbffff88Y9/zKOPPpqlS5dm7Nixq3WfAACwtozfjd+BTY8QHaDIKioqUlZWlpkzZ6aysjJ///vfc8kll6RNmzbZfPPNM3To0EycODH19fXLnbvHHnvkySefTNeuXVNSUpIjjzwyixcvzt/+9rd1XudVV12VsrKyHHPMMenfv38uueSS3H///VmyZEnBc3784x/n6quvTqtWrVJeXp799tsv06dPX6Prz58/P61bt06LFi3SsWPHjBkzJt/85jfX9HYAAGCNGL+vGuN34JPEF4sCNAFLly5Ns2bN8tZbb6Wuri59+/ZttL+uri5z585d7gt86urqcsstt2TSpEmNZq+sbGC8pj71qU/lzjvvzCuvvJKnnnoqzzzzTIYNG5Yf/OAH+cUvfpHOnTsvd8706dMzatSovPzyy/nggw9SV1eXHj16rNH1zz333FxyySX5zW9+k3333TdHHnlkdt1117W9LQAAWG3G7x/P+B34JDETHaDI3njjjSxcuDCf+cxnUlpamrZt26aysrLRrxdffHG5AXiS3HLLLXnwwQczduzYvPDCC3n++edXeq1ly5atdb077bRTTjnllIwePTqPPPJIPvjgg/zsZz9b7rh58+blrLPOyu67754pU6aksrIyZ5111mpd66N1JpPkwAMPzOOPP55zzz037733Xr761a/mF7/4xVrfDwAArA7j98KM34FPKiE6QJGNHj06Xbt2TdeuXbPttttm4cKFeeuttxr219TUFPwCnsrKygwYMCDdu3dPs2bNMmPGjEb7W7VqlUWLFjU8f/PNN9eoxrfffjtXX311ampqGm3fYostsvPOO6e2tna5c1577bUsWLAgp59+etq3b58kefHFFwteo7S0tFE7dXV1mTVrVsPzuXPnpl27djn88MMzatSoXHPNNbnrrrvW6H4AAGBNGb9/yPgd2JQI0QGKZPbs2bnuuusyefLkfOc730mSdO3aNb169cp3vvOdVFVVZf78+Rk+fHguvfTSFbbRpUuX/PWvf01tbW1eeeWVjBs3Lh06dMjs2bOTJNtvv32mTp2aefPm5d13382dd95ZsJ7S0tLMnDkz8+bNW25feXl5nnrqqVxyySV57bXXsmzZstTW1ub+++/P1KlT079//+Xa+NSnPpVmzZrlueeey8KFCzN+/PjMmTMnc+bMydKlS9O6deskyT/+8Y/U1NRku+22y4IFC/KHP/whS5Ysya233tqwjuSiRYtyyCGH5N57783SpUuzaNGizJgxI9tuu+2a/wUAAMBqMH43fgc2XUJ0gA1oxIgR6dmzZ3r06JGBAwdm9uzZmTBhQqO1AUeNGpX6+voMGDAgBx10UOrq6jJy5MgVtjdkyJDU1dVlr732yuWXX56hQ4fm2GOPzYgRIzJ58uScfvrp6dChQ/bff/+cdtppOfXUUwvWdtxxx2XKlCk5+OCDG30MM/lwRszPf/7zbL755jn99NPTq1ev9OvXL3fccUdGjRqV/fbbb7k2Kioq8o1vfCPf/OY38/nPfz7z5s3LjTfemCVLluTkk09ORUVFDjnkkJx//vn5/ve/nx49emTw4MG58MILs//++6dFixbp1atXkqR169b5wQ9+kPHjx6d379458MAD8/bbb+db3/rW2v6VAABAQcbvxu8ASVJSv6KviwYAAAAAAMxEBwAAAACAQoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdYD2YMmVKunXrlqeffrrgMf3798+FF164Su29+OKLOeSQQ9KtW7csXrz4Y4+//PLLs88++6xyvaujtrY248aNy7HHHps+ffqkR48eOeCAA3LJJZdk1qxZ6+WaAAAAAMUiRAfYAJYsWZIePXpk5syZDdvuvvvufPvb3/7Yc3/5y1/mpJNOSklJyfoscZWdffbZue2223LKKafknnvuyQMPPJArrrgizz//fL761a9m/vz5Dcd+/vOfX+kbCYWs6XkAAAAA65oQHWADqKyszAcffNBoW3l5eTp06LDS8xYsWJAf/vCHufnmm3PEEUeszxJXyauvvpqpU6fmggsuyLHHHpttttkm2267bQ499NCMHj06ZWVlmTFjRpJk9uzZ+d///d/VvsaangcAAACwPgjRAdZSTU1NLr744uy+++7ZY489ctFFFzWajX3PPffk5JNPTpIMGDAggwYNStJ4OZeZM2emW7dumTBhQr785S+nR48eef/999OqVavcc8892W+//daotj/96U85+uij06NHj/Tv3z933313kuR3v/vdCpebWbJkSXr37p0bbrhhhe0tWrSo4bh/t/POO+fee+/N3nvvnaeffjr7779/kuSUU05J//79kyRLly7ND37wgwwYMCC77LJL9tlnn5x33nkNM/QLnTdo0KCceOKJja739NNPp1u3bpkyZUqSZN68ebnyyiuz3377NSwxM2LEiIaaAQAAANaEEB1gLX3729/O5MmTc+211+ZXv/pVdt999/znf/5nw/7DDz88F198cZJkwoQJGT16dMG2/uu//ivHH398Hn744bRr1y4tW7ZMly5d1qiuhQsX5qabbsqwYcNy7733pk+fPhk2bFheeOGF7L///tl6663z61//utE5U6ZMyfvvv58TTjhhhW1+9rOfzdZbb53rrrsuN910U/72t7+lvr5+ueN69eqVUaNGJUlGjx7dEN7/6Ec/yk9+8pNccsklefTRRzN27NjMmjUr55133krPWxUjRozIX/7yl/zwhz/MI488kmuvvTaPPvporrvuulVuAwAAAODfCdEB1kJtbW0eeOCBnHzyyTniiCOy/fbb5ytf+UrDDOokad26ddq3b5/kwyVcOnXqVLC9rl275vjjj8+nPvWpNGu2dl30woULc/nll6dPnz7Zcccd8+1vfztt2rTJfffdl+bNm+eEE07IQw89lAULFjSc89vf/jZ9+vTJ9ttvv8I2W7VqlZ/85Cfp2rVrfvSjH+Woo47K3nvvnfPPPz/33Xdfw5I1rVq1SllZWZKkY8eOKS8vT5KcfPLJmThxYg499NBsvfXW2XXXXXP88cdnxowZqaqqKnjeqpgxY0Z233339OrVK1tvvXX233//3H777fna1762Jn98AAAAAEmE6ABr5R//+Ec++OCD7LLLLo229+rVa43a69Gjx7ooK8mHQXbPnj0bnpeWlmaHHXbI66+/niQ54YQTsmTJkkyaNCnJh6H77373uxx//PErbfezn/1s7rnnntxzzz256KKL0qNHj0yZMiUXX3xxvvjFL6aqqqrguaWlpZk4cWKOOuqo7LnnnunVq1e++93vJknmzp27Vvc7YMCA/M///E+uuOKKPProo3n//fez7bbbFnxDAAAAAGBVCNEB1sJHs7jbtWvXaPu/P19VH/dFo6ujffv2y81mb9OmTRYuXJgk2XLLLdO/f//cc889ST5cJ71ly5Y59NBDV6n9XXbZJWeddVbGjRuXJ598Muedd15efvnljB07tuA5F198ccOSNbfffnt+85vfNCzlsra+8Y1v5LrrrsvMmTNzwQUXZO+9987QoUMze/bsddI+AAAAsGkSogOshTZt2iT5cFmXf/WvXyxaLAsXLlxuvfKFCxc2Cvi/9KUv5dlnn83//u//5oEHHshRRx2V1q1br7TdFd1b27Zt8//+3//L5z73ubz88ssrPK+mpia/+93vMnjw4Jx66qnZeeeds91222XZsmWrdD8rupd/VVJSkmOOOSY///nP8/TTT+d73/tepk+fnm984xur1D4AAADAigjRAdbCdtttlxYtWuSFF15otP3Pf/7zCo9f0Zdwri+LFi3KX/7yl4bntbW1ee211/LZz362Yds+++yTbbbZJnfddVeeeOKJgl8o+pERI0bk85//fKqrq5fbt2TJksyePTudO3dutP2je/7ggw9SX1/faJ3zurq6TJw4cYXX+tc/q7KysuWWiXn++ecb3dtvf/vbhoC/Xbt2Ofzww3PqqafmpZdeWuk9AQAAAKyMEB1gLbRv375hLe6HH344b7zxRn7xi1/kqaeeanRcx44dkyRPPPFEwZnaK7Jo0aK8++67effddxtmXs+ZMyfvvvvuCoPsf9W2bdt873vfy7PPPptXX301w4YNy5IlS3L00Uc3HFNSUpITTzwx48aNS9euXfO5z31upW0OGjQorVu3zle/+tXcf//9efXVV/PWW29lypQpOeOMM7Jo0aKcfvrpje75ySefzIsvvphOnTpl++23zz333JOXX345L730Us4+++zsscceSZJnnnkmNTU1y51XX1+fXXfdNTNnzsz//M//5K233so999yTJ554oqGuFi1a5Hvf+14uvfTS/OUvf8k///nPTJs2LRMnTsyee+65yn/eAAAAAP+uRbELANjYXXPNNRk+fHguu+yylJSU5IADDshVV12Vs846q+GYAw44ILvvvntGjhyZrl27NqxD/nEeeOCBXHHFFY229e/fP0my55575uc//3nBczfffPOce+65ufrqq/P6669nq622yg033JCdd9650XGHH354brzxxnzpS1/62Hq22267/M///E/Gjx+fm2++Oe+8806WLFmSLbfcMnvuuWeGDx+eHXfcMUnSs2fPDBgwILfddlt+9atf5fe//31uuOGGXH311TnhhBPSuXPnnHXWWTn66KPz97//PSNGjEiLFi1y3HHHLXfeoEGD8ve//z033nhjli5dmn333TfDhg3LV77ylSRJy5YtM378+Hzve9/LmWeemQULFmSLLbbIfvvtlwsvvHCV/qwBAAAAVqSkfkOuLQBAk3Pbbbflxz/+cX73u9997HroAAAAAJsaM9EBNlFvv/12/vSnP+Wmm27KsGHDBOgAAAAAK2AmOsAmapdddkl5eXm++tWvZsiQIcUuBwAAAKBJEqIDAAAAAEABzYpdAAAAAAAANFVCdAAAAAAAKECIDgAAAAAABQjRAQAAAACggBbFLmB9effd94tdAgAAm6AttuhQ7BIAAIB1yEx0AAAAAAAoQIgOAAAAAAAFCNEBAAAAAKAAIToAAAAAABQgRAcAAAAAgAKE6AAAAAAAUIAQHQAAAAAAChCiAwAAAABAAUJ0AAAAAAAoQIgOAAAAAAAFCNEBAAAAAKAAIToAAAAAABTQotgFsOmorp6bxYsXF7sMmqDS0tJ06rRZscuAJk0fSiH6UAAAgPVLiM4GUVu7MOPH35r6+vpil0ITVFJSkiFDzkubNm2LXQo0SfpQVkYfCgAAsH6V1Dex/5GPHTs2v/zlL1NTU5P/+I//yIgRI/LpT386U6dOzahRo/Laa69l6623zpAhQzJw4MCC7bz77vsbsGpWhVmUH6qqmpNJk+7LoYcelfLyimKX0ySYRQkfTx/6IX3o8vShTc8WW3QodgkAAMA61KRmov/yl7/MxIkTc/vtt2fLLbfM97///YwfPz5nnXVWzjnnnFx55ZU56qij8uyzz+bss8/ODjvskJ49exa7bFaR/+A3Vl5ekc6dtyp2GcBGQh/amD4UAACADaVJheg//elPc9lll+Uzn/lMkmTYsGFJkv/6r//K9ttvn+OPPz5J0q9fv/Tv3z8TJkwQogMAAAAAsN40mRB99uzZmTlzZubNm5fDDz887733Xvr27Zurr746M2bMSPfu3Rsd37179zz44IMrbbOkZH1WDGvmo9dlSYnXKMDq0ocCAACwoTWZEP3tt99OkkyaNCm33XZb6uvrc95552XYsGFZtGhROnfu3Oj4Tp06Ze7cuQXbKy9vl+bNm63XmmFNLF48P0nSqVPbVFRYMxVgdehDAQAA2NCaTIj+0febnnHGGQ2B+dChQ3PmmWemX79+q91eVdUCM9RokqqrFzY8lpb6AlyA1aEPZWPgDR4AAPhkaTIhekVFRZKkrKysYVuXLl1SX1+fDz74INXV1Y2Onzt3bsrLy1fa5v/l8tCkfPS6rK/3GgVYXfpQAAAANrQms97JVlttlfbt2+ell15q2DZr1qy0bNkyBxxwQKZPn97o+OnTp2e33Xbb0GUCAAAAALAJaTIheosWLXL88cfnRz/6Ud5444289957ueWWW3LUUUfl2GOPzaxZszJhwoQsXrw4TzzxRJ544omceOKJxS4bAAAAAIBPsCaznEuSXHTRRVmyZElOOOGEfPDBBznkkEMybNiwtGvXLrfeemtGjBiRa665Jl26dMkNN9yQnXfeudglAwAAAADwCdakQvRWrVpl+PDhGT58+HL7+vTpk3vvvbcIVQEAAAAAsKlqMsu5AAAAAABAUyNEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFNCi2AX8q27duqVly5YpKSlp2HbiiSfmqquuytSpUzNq1Ki89tpr2XrrrTNkyJAMHDiwiNUCAAAAAPBJ16RC9CSZNGlSPv3pTzfa9s477+Scc87JlVdemaOOOirPPvtszj777Oywww7p2bNnkSoFAAAAAOCTbqNYzuW+++7L9ttvn+OPPz6lpaXp169f+vfvnwkTJhS7NAAAAAAAPsGa3Ez0UaNG5bnnnktNTU0OO+ywXH755ZkxY0a6d+/e6Lju3bvnwQcfXGlb/7IqDDQZH70uS0q8RgFWlz4UAACADa1Jhej/8R//kX79+uX666/PW2+9lQsuuCDXXHNNqqur07lz50bHdurUKXPnzi3YVnl5uzRvvlFMtGcTs3jx/CRJp05tU1HRocjVAGxc9KEAAABsaE0qRL/rrrsafr/jjjvm4osvztlnn5099thjtduqqlpghhpNUnX1wobH0tL3i1wNwMZFH8rGwBs8AADwydKkQvR/9+lPfzp1dXVp1qxZqqurG+2bO3duysvLV3p+ff16LA7W0Eevy/p6r1GA1aUPBQAAYENrMuudvPjiixk5cmSjba+++mpatWqVAw44INOnT2+0b/r06dltt902ZIkAAAAAAGximsxM9M033zx33XVXysvLM3jw4MyaNSs/+MEP8qUvfSlHH310br755kyYMCEDBw7MH//4xzzxxBONln8B4JNl/vx5qa2tLXYZNDFVVXMaPcK/atOmTcrKOha7DAAA4BOmpL6+6XwY+plnnsmoUaPy8ssvp1WrVjn22GNz4YUXprS0NM8880xGjBiRV199NV26dMlFF12Ugw8+uGBb775rnVSaptmz384dd9yWk0/+Wjp33qrY5UCTNH/+vPzsZz/O0qVLi10KsBFp0aJFTj31rKIH6VtsYU10AAD4JGkyM9GTpE+fPrnzzjsL7rv33ns3cEUAFENtbW2WLl2aw3fZJuVtS4tdDrARqFq4OA/MeCu1tbVFD9EBAIBPliYVogPAvypvW5rOZW2LXQYAAACwCWsyXywKAAAAAABNjRAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoIAWxS7gk2z+/Hmpra0tdhk0MVVVcxo9wr9q06ZNyso6FrsMAAAAAP6PEH09mT9/Xn72s59k6dIPil0KTdSkSfcVuwSaoBYtWubUU88UpAMAAAA0EUL09aS2tjZLl36Qrr0Hpm2HimKXA2wEFr4/J3/788TU1tYK0QEAAACaCCH6eta2Q0Xad9qq2GUAAAAAALAGfLEoAAAAAAAUIEQHAAAAAIAChOgAAAAAAFCAEB0AAAAAAAoQogMAAAAAQAFCdAAAAAAAKECIDgAAAAAABbQodgEAUMh7CxYVuwRgI6G/AAAA1hchOgBN1oMvzix2CQAAAMAmTogOQJN1WPdPZ/N2rYtdBrAReG/BIm+8AQAA64UQHYAma/N2rdO5rG2xywAAAAA2Yb5YFAAAAAAAChCiAwAAAABAAU02RP/ud7+bbt26NTyfOnVqjj/++Oy+++454ogjMnHixCJWBwAAAADApqBJron+0ksv5d577214/s477+Scc87JlVdemaOOOirPPvtszj777Oywww7p2bNnESsFAAAAAOCTrMnNRF+2bFmGDx+ewYMHN2y77777sv322+f4449PaWlp+vXrl/79+2fChAnFKxQAAAAAgE+8Jhei33nnnSktLc1RRx3VsG3GjBnp3r17o+O6d++e6dOnb+jyAAAAAADYhDSp5VzmzJmT0aNH5+c//3mj7dXV1encuXOjbZ06dcrcuXNX2l5JyTovcZUV89rAxq2kRB+yqd8/sOb0oQAAwLrWpEL06667Lscdd1x22mmnzJw5c63aKi9vl+bNizfRfvHi+UW7NrBx69SpbSoqOhS7jKLShwJrSh8KAACsa00mRJ86dWqee+653H///cvt22yzzVJdXd1o29y5c1NeXl6wvaqqBUWdhVRdvbB4Fwc2atXVC1Na+n6xyygqfSiwpppCHyrEBwCAT5YmE6JPnDgx7733Xj7/+c8nSerr65Mkffv2zWmnnbZcuD59+vTstttuK23z/5ooimJeG9i41dfrQzb1+wfWnD4UAABY15pMiH755Zfn/PPPb3j+9ttv50tf+lLuvffeLFu2LLfeemsmTJiQgQMH5o9//GOeeOKJ3HXXXUWsGAAAAACAT7omE6J37NgxHTt2bHi+dOnSJMlWW22VJLn11lszYsSIXHPNNenSpUtuuOGG7LzzzkWpFQAAAACATUOTCdH/3ac//em8/PLLDc/79OmTe++9t4gVAQAAAACwqWlW7AIAAAAAAKCpEqIDAAAAAEABQnQAAAAAACigya6J/kmx8P05xS4B2EjoLwAAAACaHiH6eva3P08sdgkAAAAAAKwhIfp61rX3wLTtUFHsMoCNwML353jjDQAAAKCJEaKvZ207VKR9p62KXQYAAAAAAGvAF4sCAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoID1GqL/6Ec/Wp/NAwAAAADAerVeQ/SxY8euz+YBAAAAAGC9arGmJ77++usfe0x9ff2aNg8AAAAAAEW3xiH6YYcdlpKSkhUG5R9tLykpWaviAAAAAACgmNY4RD/yyCPTsmXLnHvuuSvcX19fn8MPP3yNCwMAAAAAgGJb4xD929/+do477ri8/PLL6d+//7qsCQAAAAAAmoQ1DtHbtm2b22+/PVVVVQWPOfvss9e0eQAAAAAAKLpma3PylltumcWLFxfcL0QHAAAAAGBjtlYhepKcfvrpWbJkybqoBQAAAAAAmpS1DtGHDh2a66+/Pq+++mpqa2uzZMmSRr8AAAAAAGBjtcZron/k+9//fpYuXZo77rhjhftfeumltb0EAAAAAAAUxVqH6Lfeeuu6qAMAAAAAAJqctQ7R99xzz3VRBwAAAAAANDlrFKIPGjQoP//5z5MkX/rSl1JSUlLw2DvvvHPNKgMAAAAAgCJboxC9X79+Db/fb7/91lkxAAAAAADQlKxRiH722Wc3/P7Tn/50jjnmmOWOqa2tNQsdgLVStXBxsUsANhL6CwAAYH1Z4zXRly1blqVLl2b48OE54ogjUl9f32j/G2+8kZtuuilf+9rX1rpIADYtbdq0SYsWLfLAjLeKXQqwEWnRokXatGlT7DIAAIBPmDUO0W+//fZcf/31qa+vz6677rrc/vr6+vTq1WutigNg01RW1jGnnnpWamtri10KTUxV1ZxMmnRfDj30qJSXVxS7HJqYNm3apKysY7HLAAAAPmHWOEQfPHhwBg4cmP333z+33XbbcjPRW7dune7du691gQBsmsrKOgrDKKi8vCKdO29V7DIAAADYBKxRiN6/f/+UlJQkSZo3b57LL7+84LGTJ09es8oAAAAAAKDI1ihEP+ussxp+/9577+V//ud/ctBBB2X77bfPsmXL8sorr+Txxx/Paaedts4KBQAAAACADW2NQvQvf/nLDb8//fTTM3r06OXWRf/zn/+cMWPGZPDgwWtV4MZu4ftzil0CsJHQXwAAAAA0PWu8JvpHpk2blp133nm57bvuumuee+651Wrrr3/9a6677rpMnz49paWl2XPPPXPllVdmiy22yNSpUzNq1Ki89tpr2XrrrTNkyJAMHDhwbctfb9q0aZMWLVrmb3+eWOxSgI1IixYt06ZNm2KXAQAAAMD/WesQfdttt83o0aMzZMiQtG/fPklSU1OTcePG5dOf/vQqt7NkyZKcdtpp+cpXvpKf/OQnqampyfnnn5+rr746w4cPzznnnJMrr7wyRx11VJ599tmcffbZ2WGHHdKzZ8+1vYX1oqysY0499czU1tYWuxSamKqqOZk06b4ceuhRKS+vKHY5NDFt2rTxZZoAAAAATchah+jf/va3c/755+enP/1pysrKUldXl5qampSVleWWW25Z5XZqa2tz4YUX5thjj02LFi1SXl6egw46KL/4xS9y3333Zfvtt8/xxx+fJOnXr1/69++fCRMmNNkQPfkwSBeGUUh5eUU6d96q2GUAAAAAACux1iH6brvtlsceeyzTp0/P22+/nSVLlmTLLbfMbrvtltLS0lVup2PHjjnhhBManr/22mv59a9/ncMOOywzZsxI9+7dGx3fvXv3PPjgg2tbPgAAAAAAFLTWIXqSNGvWLLvuuutyXy66JmbNmpVDDjkkS5cuzYknnpjzzjsvZ555Zjp37tzouE6dOmXu3LkrbaukZK3LgXXuo9dlSYnXKMDq0ocCAACwoa2TEH1d6tKlSyorK/PGG2/kW9/6Vi699NI1aqe8vF2aN2+2jquDtbd48fwkSadObVNR0aHI1QBsXPShAAAAbGhNLkRPkpKSkmy//fa58MIL8+UvfzkHHHBAqqurGx0zd+7clJeXF2yjqmqBGWo0SdXVCxseS0vfL3I1ABsXfSgbA2/wAADAJ0uTCdGnTp2aq6++Og8++GCaNftwBvlHj7vuumseeuihRsdPnz49u+2220rbrK9fP7XC2vjodVlf7zUKsLr0oQAAAGxoTWa9kx49eqSmpiY33HBDamtrU1VVldGjR6d379456aSTMmvWrEyYMCGLFy/OE088kSeeeCInnnhiscsGAAAAAOATrMmE6B06dMhPf/rTTJ8+PXvttVeOOOKIdOjQIf/5n/+ZzTffPLfeemt+8YtfZI899sh3v/vd3HDDDdl5552LXTYAAAAAAJ9gTWY5lyTp1q1bfv7zn69wX58+fXLvvfdu4IoAAAAAANiUNZmZ6AAAAAAA0NQI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA4AAAAAAAU0qRB91qxZ+X//7/+lb9++6devXy6//PLMnz8/SfLSSy/lq1/9avbYY48cfPDB+elPf1rkagEAAAAA+KRrUiH617/+9ZSVleWxxx7LPffck7///e+5/vrrs2jRogwZMiR77bVXfv/73+emm27KrbfemocffrjYJQMAAAAA8AnWZEL0+fPnp0ePHrnooovSrl27bLXVVjn22GPz5z//OY8//ng++OCDnH322Wnbtm122WWXnHDCCbnrrruKXTYAAAAAAJ9gLYpdwEfKyspy3XXXNdr2z3/+M1tuuWVmzJiRbt26pXnz5g37unfvngkTJqy0zZKS9VIqrJWPXpclJV6jAKtLHwoAAMCG1mRC9H9XWVmZX/ziFxk7dmwefPDBlJWVNdrfqVOnVFdXZ9myZWnWbPkJ9eXl7dK8eZOZaA8NFi/+cJ3/Tp3apqKiQ5GrAdi46EMBAADY0JpkiP7ss8/m7LPPzkUXXZR+/frlwQcfXOFxJSuZglZVtcAMNZqk6uqFDY+lpe8XuRqAjYs+lI2BN3gAAOCTpcmF6I899lguueSSXHXVVTnmmGOSJOXl5fnHP/7R6Ljq6up06tRphbPQP1Jfvx4LhTX00euyvt5rFGB16UMBAADY0JrUeifTpk3LZZddlh/84AcNAXqS9OjRIy+//HKWLl3asK2ysjK77bZbEaoEAAAAAGBT0WRC9KVLl2bYsGG5+OKLs++++zbad8ABB6R9+/YZO3Zsamtr88ILL+Tuu+/OSSedVKRqAQAAAADYFDSZEP3555/Pq6++mhEjRqRnz56Nfr377rv50Y9+lKeeeip77rlnLrjgglx44YU58MADi102AAAAAACfYE1mTfTevXvn5ZdfXukx//3f/72BqgEAAAAAgCY0Ex0AAAAAAJoaIToAAAAAABQgRAcAAAAAgAKE6AAAAAAAUIAQHQAAAAAAChCiAwAAAABAAUJ0AAAAAAAoQIgOAAAAAAAFCNEBAAAAAKAAIToAAAAAABQgRAcAAAAAgAKE6AAAAAAAUIAQHQAAAAAAChCiAwAAAABAAUJ0AAAAAAAoQIgOAAAAAAAFCNEBAAAAAKAAIToAAAAAABQgRAcAAAAAgAKE6AAAAAAAUIAQHQAAAAAAChCiAwAAAABAAUJ0AAAAAAAoQIgOAAAAAAAFCNEBAAAAAKAAIToAAAAAABQgRAcAAAAAgAKE6AAAAAAAUIAQHQAAAAAAChCiAwAAAABAAUJ0AAAAAAAoQIgOAAAAAAAFCNEBAAAAAKAAIToAAAAAABTQotgFsOmorp6bxYsXF7uMoquqmtPokaS0tDSdOm1W7DIAAAAAYDlCdDaI2tqFGT/+1tTX1xe7lCZj0qT7il1Ck1FSUpIhQ85LmzZti10KAAAAADQiRGeDaNOmbQYPHrJJz0S/447bCu47+eSvbcBKmp7S0lIBOgAAAABNkhCdDWZTXq7jppuuW+n+O+64LRdeeMUGqgYAAAAAWFW+WBTWs38P0C+88IqGXys7DgAAAAAoPiE6bED/HpybfQ4AAAAATZvlXGADMtscAAAAADYuTW4m+u9///v069cvF1544XL7HnjggRx11FHp1atXjjvuuPzhD38oQoUAAAAAAGwqmtRM9J/85Ce5++67s9122y2376WXXspll12Wm2++OXvttVceeuihnHvuuZk0aVK22mqrIlQLAAAAAMAnXZOaiV5aWlowRJ8wYUIOOOCAHHDAASktLc3AgQPTtWvXTJw4sQiVAgAAAACwKWhSM9FPOeWUgvtmzJiRAw44oNG27t27p7KysuA5JSXrrDTYILxmAVbuo36ypESfCQAAwIbRpEL0lamurk7Hjh0bbevYsWNeeeWVFR5fXt4uzZs3qYn28LEqKjoUuwSAJm3x4vlJkk6d2uozAQAA2CA2mhA9Serr61f52KqqBWaosdGZM+f9YpcA0KRVVy9seCwt1WfSNHmDBwAAPlk2mhB9s802S3V1daNt1dXVKS8vL3jOamTu0CR4zQKs3Ef9ZH29PhMAAIANY6NZ76RHjx6ZPn16o22VlZXZbbfdilQRAAAAAACfdBtNiH7iiSfmqaeeyuOPP57Fixfn7rvvzj/+8Y8MHDiw2KUBAAAAAPAJ1aSWc+nZs2eSZOnSpUmSRx99NMmHM867du2aG2+8Mdddd11mzZqVnXbaKbfeemu22GKLotULAAAAAMAnW5MK0SsrK1e6/+CDD87BBx+8gaoBAAAAAGBTt9Es5wIAAAAAABuaEB3WswsvvGKdHgcAAAAAbDhCdFjPbrrpunV6HAAAAACw4QjRAQAAAACgACE6AAAAAAAUIEQHAAAAAIAChOgAAAAAAFCAEB0AAAAAAApoUewCAICPV109N4sXLy52GUVXVTWn0SNJaWlpOnXarNhlAAAAfGIJ0QGgiautXZjx429NfX19sUtpMiZNuq/YJTQZJSUlGTLkvLRp07bYpQAAAHwiCdEBoIlr06ZtBg8esknPRL/jjtsK7jv55K9twEqantLSUgE6AADAeiREB4CNwKa8XMdNN1230v133HFbLrzwig1UDQAAAJsaIToA0GT9a4BeWtox55xzTsPzMWPGZPHieQ3HCdIBAABYH5oVuwAAgFXxrwH6ip4DAADA+mAmOgCwUfi4ZV0AAABgfTATHQAAAAAAChCiAwAAAABAAUJ0AAAAAAAoQIgOAAAAAAAFCNEBAAAAAKCAFsUuADYlF154xXLbbrrpuiJUArDx0YcCAABQDGaiwwb072GP8Adg1Y0ZM2alzwEAAGB9KKmvr68vdhHrw7vvvl/sEqDBqoTlK5phCYA+lI3PFlt0KHYJAADAOmQmOmwAHxfuCH8ACtOHAgAAUExCdNhACoU8wh+Aj6cPBQAAoFgs5wIAAOuQ5VwAAOCTxUx0AAAAAAAoQIgOAAAAAAAFCNEBAAAAAKAAIToAAAAAABQgRAcAAAAAgAKE6AAAAAAAUIAQHQAAAAAAChCiAwAAAABAASX19fX1xS4CAAAAAACaIjPRAQAAAACgACE6AAAAAAAUIEQHAAAAAIAChOjQxCxcuDCnnHJKdttttzz77LNr1dY999yTffbZZx1VBlAc48aNS+/evXP11VevdVvdunXLlClT1r4oAAAANhktil0AFEP//v2zdOnSTJo0KW3btm3Y/vTTT+eKK67IY489ttptPv300znllFPSqlWrJEnz5s2z/fbb59BDD83gwYPTunXrVWrnySefzHPPPZcnnngi5eXlq13Hytx9993p37//Om8XoJD+/ftn9uzZadbsw/ftKyoq0rdv35xxxhnZaaedVqmNsWPH5oILLsigQYPWaW0zZszIvHnz0q9fv3XaLgAAAJ8sZqKzyVqyZEnGjBmzztv985//nMrKykyZMiWXXXZZHnvssZx00klZsGDBKp1fU1OTsrKydR5019XVZeTIkZk7d+46bRfg4wwbNiyVlZWZNm1axo0bl8022yxf/OIXM3Xq1FU6v6amJtttt906r+tXv/pVnnrqqXXeLgAAAJ8sQnQ2WUOHDs0vf/nLvP766wWPefvtt3P22Wenb9++2WOPPXLhhRemurp6ldovKyvL3nvvnfHjx6empib/9V//1bDvgQceyNFHH53/+I//yIABA3LXXXclSSZMmJBhw4Zlzpw56dmzZ5555plUVVXlvPPOy957753evXvnzDPPzD//+c8kycyZM9OtW7e8+uqrDW3feOONK5ytueeee+b999/P0UcfnZtvvnmV7gFgXWrZsmV23HHHXHbZZRk0aFCGDRuWurq6zJo1K1//+tfTt2/f9OnTJ5deemlqamqyZMmS9OzZM0lyzjnnZNiwYUmS8ePH5wtf+EJ69eqVww47LA8//HDDNQYNGpQbb7yx4fmrr76abt26ZebMmY1qufbaa3PHHXfkpz/9aQ466KANcPcAAABsrITobLJ22mmnnHjiiRkxYkTBY84555x06NAhkydPzkMPPZR33nknw4cPX63rtG3bNieeeGImTZqUJKmsrMyVV16ZSy65JM8++2yuv/76jBw5MtOmTcsJJ5yQa6+9NhUVFamsrEyfPn1yww03ZMGCBZk8eXKeeOKJJMl3v/vd1b7fe++9t+Hx3HPPXe3zAdalwYMHZ+bMmZk+fXrOOeecbL311nn88cczadKkzJ49O9dff31atWqVysrKJMmYMWMyYsSIPPPMMxk1alTGjBmTadOm5cwzz8zFF1+cqqqq1br+VVddlT59+uS0007LI488sj5uEQAAgE8IITqbtKFDh+bll19eYYDy0ksvZcaMGbnkkkvSvn37VFRU5KyzzsrkyZOzZMmS1brODjvs0DAL8p577smBBx6YfffdN82bN0/v3r1z2GGHNYTc/+6aa67J6NGj07Zt27Rr1y5f+MIXMn369NW/WYAmpKKiImVlZXn66afz97//PZdccknatGmTzTffPEOHDs3EiRNTX1+/3Hl77LFHnnzyyXTt2jUlJSU58sgjs3jx4vztb38rwl0AAACwKfDFomzS2rdvn4svvjjXXXdd9ttvv0b7Zs6cmY4dO2aLLbZo2Lbtttvmgw8+yOzZs7PNNtus8nXq6urSvHnzJMmbb76ZqVOnNixRkCT19fXZd999V3juG2+8kZEjR+Yvf/lLFi1alGXLlqVTp06rcZcATdPSpUvTuXPn1NXVpW/fvo321dXVZe7cuct9P0RdXV1uueWWTJo0qdHs89V9cxMAAABWlRCdTd4xxxyTu+66K7feemv22muvhu0rC2RKSkpW6xovvvhidthhhyRJ69atc9JJJ+Wqq6762POWLVuWIUOGZI899shDDz2U8vLyTJgwId///vcLnlNXV7datQEUwxtvvJGFCxemuro6bdu2zXPPPbdK591yyy158MEH86Mf/Sg777xz6uvr071794LHL1u2bF2VDAAAwCbKci6Q5Fvf+lbGjx+ft956q2HbNttsk3nz5mXOnDkN21577bWUlpamc+fOq9x2VVVV7rjjjhx11FFJPpzN/vLLLzc65u23315h+D1nzpzMmjUrgwYNapiN+eKLLzbsLy0tTZIsWrSoYdu/3gNAUzV69Oh07do1e++9dxYuXNio76qpqcncuXNXeF5lZWUGDBiQ7t27p1mzZpkxY0aj/a1atWrUJ7755pvr5wYAAADYZAjRIcnnPve5HHPMMY1mePfs2TM77rhjRo0alYULF2b27NkZO3ZsjjjiiLRs2fJj21y2bFmee+65nHHGGdlpp53yla98JUly/PHHZ9q0afnVr36VJUuW5KWXXsoJJ5yQhx56aLk2ysvL07Zt2zz//PNZvHhx7rvvvrz00kupqanJggULUl5eng4dOuThhx9OXV1d/vCHP+T5559fYT2tW7dOkvzjH/9ITU3N6v8hAawDs2fPznXXXZfJkyfnO9/5Trp27ZpevXrlO9/5TqqqqjJ//vwMHz48l1566QrP79KlS/7617+mtrY2r7zySsaNG5cOHTpk9uzZSZLtt98+U6dOzbx58/Luu+/mzjvvLFhLaWlpZs6cmXnz5q2XewUAAOCTQYgO/+eCCy7I0qVLG56XlJRkzJgxeeedd3LggQfmxBNPzG677ZZvfetbK22nd+/e6dmzZ3bbbbdcfvnl+fznP5/bbrstrVq1SpKGYH7cuHHp3bt3hg4dmtNPPz2HH374cm21aNEiV199dX784x+nX79+eeaZZzJ69OhstdVWOfjgg9O8efMMHz48v/71r9O7d+/85je/aQjr/11FRUUOOeSQnH/++StdDgZgXRsxYkR69uyZHj16ZODAgZk9e3YmTJiQXXfdNUkyatSo1NfXZ8CAATnooINSV1eXkSNHrrCtIUOGpK6uLnvttVcuv/zyDB06NMcee2xGjBiRyZMn5/TTT0+HDh2y//7757TTTsupp55asK7jjjsuU6ZMycEHH2wpLAAAAAoqqa+vry92EQAAAAAA0BSZiQ4AAAAAAAUI0QEAAAAAoAAhOgAAAAAAFCBEBwAAAACAAoToAAAAAABQgBAdAAAAAAAKEKIDAAAAAEABQnQAAAAAAChAiA6wkRk3blx69+6dq6++eq3b6tatW6ZMmbL2RQEAAAB8QrUodgEAm4r+/ftn9uzZadbsw/cvKyoq0rdv35xxxhnZaaedVrmdsWPH5oILLsigQYPWaX0zZszIvHnz0q9fvxXu/+CDDzJ27Nj89re/zezZs1NSUpIePXrk/PPPT+/evVepjX939913p3///ikvL19n9wEAAACwLpmJDrABDRs2LJWVlZk2bVrGjRuXzTbbLF/84hczderUVW6jpqYm22233Tqv7Ve/+lWeeuqpgvtHjhyZxx57LD/84Q/z7LPP5ve//3369euX0047LW+99dYqtfGv6urqMnLkyMydO3ed1A8AAACwPgjRAYqgZcuW2XHHHXPZZZdl0KBBGTZsWOrq6pIks2bNyte//vX07ds3ffr0yaWXXpqamposWbIkPXv2TJKcc845GTZsWJJk/Pjx+cIXvpBevXrlsMMOy8MPP9xwnUGDBuXGG29seP7qq6+mW7dumTlzZqN6rr322txxxx356U9/moMOOmiFNT/55JM54ogj0q1btzRv3jzt27fP2WefnREjRqRVq1YrbOPNN9/M6aefnr59+6Zv3775xje+kfnz5ydJ9txzz7z//vs5+uijc/PNN+eee+7JPvvs0+iaJ554YkaPHp0kef311zN48OD07t07ffr0ybnnniuABwAAANY7ITpAkQ0ePDgzZ87MjBkzUl9fn3POOSdbb711Hn/88UyaNCmzZ8/O9ddfn1atWqWysjJJMmbMmIwYMSLPPPNMRo0alTFjxmTatGk588wzc/HFF6eqqmq1arjqqqvSp0+fnHbaaXnkkUdWeMwOO+yQX//613nppZcabR84cGA6d+68wjaGDRuWLbfcMr///e/z4IMP5vXXX8+YMWOSJPfee2/D47nnnvuxNV577bXZfffd88c//jGPPvpoli5dmrFjx67WfQIAAACsLiE6QJFVVFSkrKwsM2fOTGVlZf7+97/nkksuSZs2bbL55ptn6NChmThxYurr65c7d4899siTTz6Zrl27pqSkJEceeWQWL16cv/3tb+u8zquuuiplZWU55phj0r9//1xyySW5//77s2TJkoLn/PjHP87VV1+dVq1apby8PPvtt1+mT5++RtefP39+WrdunRYtWqRjx44ZM2ZMvvnNb67p7QAAAACsEl8sCtAELF26NM2aNctbb72Vurq69O3bt9H+urq6zJ07d7kv4Kyrq8stt9ySSZMmNZp9vrJge0196lOfyp133plXXnklTz31VJ555pkMGzYsP/jBD/KLX/winTt3Xu6c6dOnZ9SoUXn55ZfzwQcfpK6uLj169Fij65977rm55JJL8pvf/Cb77rtvjjzyyOy6665re1sAAAAAK2UmOkCRvfHGG1m4cGE+85nPpLS0NG3btk1lZWWjXy+++OJyAXqS3HLLLXnwwQczduzYvPDCC3n++edXeq1ly5atdb077bRTTjnllIwePTqPPPJIPvjgg/zsZz9b7rh58+blrLPOyu67754pU6aksrIyZ5111mpd66N14pPkwAMPzOOPP55zzz037733Xr761a/mF7/4xVrfDwAAAMDKCNEBimz06NHp2rVrunbtmm233TYLFy7MW2+91bC/pqam4BdoVlZWZsCAAenevXuaNWuWGTNmNNrfqlWrLFq0qOH5m2++uUY1vv3227n66qtTU1PTaPsWW2yRnXfeObW1tcud89prr2XBggU5/fTT0759+yTJiy++WPAapaWljdqpq6vLrFmzGp7PnTs37dq1y+GHH55Ro0blmmuuyV133bVG9wMAAACwqoToAEUye/bsXHfddZk8eXK+853vJEm6du2aXr165Tvf+U6qqqoyf/78DB8+PJdeeukK2+jSpUv++te/pra2Nq+88krGjRuXDh06ZPbs2UmS7bffPlOnTs28efPy7rvv5s477yxYT2lpaWbOnJl58+Ytt6+8vDxPPfVULrnkkrz22mtZtmxZamtrc//992fq1Knp37//cm186lOfSrNmzfLcc89l4cKFGT9+fObMmZM5c+Zk6dKlad26dZLkH//4R2pqarLddttlwYIF+cMf/pAlS5bk1ltvbVgHftGiRTnkkENy7733ZunSpVm0aFFmzJiRbbfdds3/AgAAAABWgRAdYAMaMWJEevbsmR49emTgwIGZPXt2JkyY0Ght71GjRqW+vj4DBgzIQQcdlLq6uowcOXKF7Q0ZMiR1dXXZa6+9cvnll2fo0KE59thjM2LEiEyePDmnn356OnTokP333z+nnXZaTj311IK1HXfccZkyZUoOPvjgRsuoJB/OaP/5z3+ezTffPKeffnp69eqVfv365Y477sioUaOy3377LddGRUVFvvGNb+Sb3/xmPv/5z2fevHm58cYbs2TJkpx88smpqKjIIYcckvPPPz/f//7306NHjwwePDgXXnhh9t9//7Ro0SK9evVKkrRu3To/+MEPMn78+PTu3TsHHnhg3n777XzrW99a278SAAAAgJUqqf9omh8AAAAAANCImegAAAAAAFCAEB0AAAAAAAoQogMAAAAAQAFCdAAAAAAAKECIDgAAAAAABQjRAQAAAACgACE6AAAAAAAUIEQHAAAAAIAChOgAAAAAAFCAEB0AAAAAAAoQogMAAAAAQAFCdAAAAAAAKOD/AwzWVBIz5tOtAAAAAElFTkSuQmCC\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示部分数值特征与 'Status' 的关系。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1200x1000 with 2 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示特征相关性热力图。\n","--------------------------------------------------\n","------- 进入数据预处理函数 -------\n","开始填充缺失值...\n","处理缺失值后，行数保持不变: 148670 行。\n","在填充缺失值之后，'Status' 列的分布:\n","Status\n","0    112031\n","1     36639\n","Name: count, dtype: int64\n","--------------------------------------------------\n","处理重复值后，删除 0 行，剩余 148670 行。\n","在 drop_duplicates 之后，'Status' 列的分布:\n","Status\n","0    112031\n","1     36639\n","Name: count, dtype: int64\n","--------------------------------------------------\n","数据预处理完成。\n","所有预处理完成后，数据形状: (148670, 34)，'Status' 列的最终分布:\n","Status\n","0    112031\n","1     36639\n","Name: count, dtype: int64\n","--------------------------------------------------\n","\n","训练集形状: (118936, 33), 测试集形状: (29734, 33)\n","训练集中 'Status' 分布:\n","Status\n","0    89625\n","1    29311\n","Name: count, dtype: int64\n","测试集中 'Status' 分布:\n","Status\n","0    22406\n","1     7328\n","Name: count, dtype: int64\n","--------------------------------------------------\n","\n","随机森林模型训练完成。\n","\n","------- 模型评估结果与可视化 -------\n","准确率 (Accuracy): 0.9999327369341494\n","精确率 (Precision): 1.0\n","召回率 (Recall): 0.9997270742358079\n","F1 分数 (F1-Score): 0.9998635184932442\n","AUC: 1.0\n","\n","详细分类报告:\n","               precision    recall  f1-score   support\n","\n","           0       1.00      1.00      1.00     22406\n","           1       1.00      1.00      1.00      7328\n","\n","    accuracy                           1.00     29734\n","   macro avg       1.00      1.00      1.00     29734\n","weighted avg       1.00      1.00      1.00     29734\n","\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 700x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示混淆矩阵。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 700x600 with 1 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAmcAAAIcCAYAAACzVwkTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAf9dJREFUeJzt3XlcTfn/B/DXbd+RbEXZJqNIWaOQLEUq+zaWZDf2ncEXw9j3nbHE2BmSXfZ9HWSfEpJEJWlf7vn90a87rsKNW+feej0fD4+Z+7lned/76XZffc7nnCMRBEEAEREREakEDbELICIiIqL/MJwRERERqRCGMyIiIiIVwnBGREREpEIYzoiIiIhUCMMZERERkQphOCMiIiJSIQxnRERERCqE4YyIiIhIhTCcUZ6YMGECqlSpku1f7dq10adPH9y6dUu02qpUqYIFCxaItn8AePfuHebMmQN3d3fY2dnBwcEB7dq1w7p165CUlCRqbYr6+++/UaVKFYSEhOTbPj98+IDFixfDw8MDNWrUQO3atdGmTRusXbsWiYmJ2Wp79epVvtWmClxdXTFy5MjvXv/atWuoUqUKzp8//8O1REdHw8XFBX/++SeA7/+dcOLECfTp0wf16tVDtWrV4OzsjBEjRuDevXtf3PeRI0fg4+ODunXronr16nB1dcXEiRPx5MkT2TLDhg2Dj48P0tPTFX5N9+7dw4gRI+Ds7Ixq1aqhYcOG6N+/P86cOaPwNogUIhDlgfHjxwuOjo7C27dvZf/evHkj3LhxQ+jTp49ga2sr3L17V5Ta3r59K8THx4uyb0EQhAcPHgiOjo5Chw4dhJMnTwovX74Unj17JuzcuVNo1KiR4OnpKURHR4tW35csXbpUGD9+vOxxUlKS8PbtWyE9PT1f9v/ixQuhSZMmQsuWLYVDhw4JL1++FB49eiRs2rRJqFOnjuDp6Sm8f/9eEARB2Ldvn2BtbS2EhYXlS20/wsXFRbh69apSthUdHS3ExcUpvPzevXuF7t27yx6npKQIb9++FVJSUn6ojvT0dKFr167CwIEDZW3f8zth8uTJQvXq1YVFixYJ9+/fF8LDw4UbN24IY8eOFX7++Wdh27ZtcstLpVJh7Nixgp2dnbBs2TLh0aNHwsuXL4XAwEChU6dOQvXq1YXTp08LgiAIHz9+FJo1ayb88ccfCr2mnTt3Cj///LMwbtw44caNG8KrV6+E69evC2PGjBGsra2FxYsX/9B7RvQphjPKE+PHjxcaNGiQ43OJiYlC7dq1hTFjxuRzVeJLSUkRmjZtKnTp0iXHL8CIiAihXr16wpAhQ0So7ut8fHzkwll+69Chg9C8efMcw8f9+/cFGxsbYenSpYIgqE84e/PmjWBtba20cJZbv/32m1w4U5a9e/cKNjY2wosXL2Rtuf2dsHv3bsHa2loWpj63YMECwcbGRnjw4IGsbdu2bYK1tbVw5syZbMunpKQInTt3Fpo1ayakpaUJgiAIhw8fFn7++Wfh6dOnX309jx49EmxsbIQ5c+bk+Pzs2bMFGxsb4dmzZ1/dDpGieFiT8p2+vj6srKzw5s0bWZsgCNi8eTO8vb1hb2+PBg0aYOrUqYiLi5Nb99y5c+jQoQPs7Ozg4uKC33//HfHx8bLn3717h3HjxsHV1RXVq1eHh4cH9u7dK7eNrMOaL1++RJUqVbBr165sNbZs2RKDBg1SuLYJEybA29sbO3bsQN26dTF37twcX/uJEycQFhaGCRMmQEdHJ9vzpUuXRv/+/XHy5EmEhYUBAJYvX45q1arh8ePH6NSpE+zs7NCwYUOsW7dObl1FX/u6deswYMAAVK9eXXaY5/z58+jatSvs7e3h4OCAtm3b4sSJE7L1XF1dcfnyZezfvx9VqlTBtWvXsh3WzHoPrl27hnbt2qFGjRpo3rw59u/fL1dDYGAgWrZsierVq6N169Y4d+4c+vTpgx49euT4ngHAzZs3ce/ePQwdOhTGxsbZnre1tcWxY8cwbNgwufb3799jyJAhcHBwQK1atTBjxgykpqbKng8NDcXQoUNRt25dVKtWDc2bN8fq1ashlUply/To0QODBw/GkiVL4ODggL/++kvhdQFg//798PT0hJ2dHZo1a4alS5ciPT0d165dQ6NGjQAAPXv2hKurq2wdf39/dOzYETVr1kTdunUxcuRIREZGyp5fvnw5ateujcDAQDg7O8te9+eHNXft2gVPT0/Y29ujTp068PX1xYMHD2Sva8+ePbh+/TqqVKmCv//+O8fDmnfv3kWPHj1gb28PZ2dnjBs3Du/evftiXwmCgJUrV6J169awtLT84nKfyul3wp9//omGDRuiSZMmOa4zdOhQGBkZYcuWLbK2jRs3wsnJCS4uLtmW19HRwfLly3Hw4EFoaWkByPycW1lZYeXKlV+tb8uWLdDX18/285Vl+PDhOHfuHCpUqAAg873t1KmT3DKfv7c59WG3bt3QpUuXbNtft24dbG1tER0dDSCzT/r06YMGDRrA3t4ev/zyC27fvv3V10DqheGM8l1qairCwsJgbm4ua1u9ejXmzJkDDw8PHDx4EHPmzMHFixcxZMgQ2TI3b97EwIED4eTkhP3792P27Nk4ceIEfvvtN9l2e/XqhVu3bmHatGkICAiAt7c3Jk+ejAMHDmSrw9LSEjVq1MDx48fl2h8/foxnz57B29tb4dqAzCAQGBiIrVu3YsCAATm+9qtXr6Jo0aKoUaPGF98fFxcXCIKAa9euydrS0tIwY8YMjBw5Ev7+/vDy8sLChQtx5MiRXL/2PXv2oFatWjh69CgqVKiAly9fYvDgwahYsSIOHDgAf39/2byehw8fAgD27t0LU1NTtGzZEhcvXoSDg0OOtcfExGDFihWy/VaqVAlTpkxBREQEAODff//F8OHDYWlpiT179mDy5MlYuHDhN+etXbt2DRKJBI0bN/7iMuXKlcvWNmfOHLRu3RoHDhyAr68vtm3bBn9/fwCZIaJ///6IiIjA5s2bcfz4cQwfPhwrV67Etm3b5Lbz9OlTvHjxAvv27YO3t7fC6wYEBOC3335D+/btERAQgAkTJmDz5s1YtGgRHBwcsHDhQgCZX9RZQdrf3x/jxo2Dvb09/v77b6xatQrPnj2Dj4+PXLDMyMjA1q1bsXr1akybNi3ba79y5QqmTZuG3r174/Dhw9i6dSuKFCkCX19fJCUlYfny5bC1tYWDgwMuXryIVq1aZdvG8+fP4ePjg3LlymH37t1YsWIFHj58KPvDJScPHjxAeHi4XNj8ls9/J0RGRuL58+c5hqwsOjo6cHJywtWrVwEAERERCAsL++rPSIkSJaCvry97LJFI0KRJE5w7d07uvf3c9evXUa9ePbl1P6Wvrw8zM7OvvcQcfd6Hnp6euHPnjlwQBzLn0Dk7O6N48eIIDQ1Fr169kJGRgfXr12PXrl0oXbo0fH1983X+J+UthjPKV1FRUZg6dSri4+PRrVs3AJnBY8OGDfD29kb//v1haWmJRo0aYdKkSbh27ZrsL8I///wT1tbWGDlyJCpVqoT69etj8uTJMDQ0RFpaGgIDAxESEoJZs2ahUaNGKF++PPr37w9XV1esXr06x3o8PT1x7do1vH//XtZ25MgRmJiYwNXVVeHagMwvlPHjx6NKlSooWrRojvt78+aNXCjNSdmyZWXLfqp79+6oX78+KlSogLFjx8Lc3BwHDx4EgFy9dmNjY/Tv3x9ly5aFjo4OSpUqBX9/f/z2228oX748LC0tMWTIEGRkZODy5csAAFNTU2hoaEBPTw8lSpTIcdQPAN6+fYspU6agZs2aqFChAvr06YO0tDRZyDt06BAAYN68efj555/h6OiI+fPny8Lbl0RGRsLY2BgmJiZfXe5zrVq1gru7O6ysrDBo0CAYGBjITSTfuHEj1qxZAxsbG1hYWKB169awsbHBhQsX5Lbz5s0bTJs2DRUrVpSN3Cmy7rp16+Di4gIfHx9YWVmhWbNmGDduHDIyMqCjoyN7PUWKFIGpqSkAYM2aNahTp46sP2rXro05c+bg2bNncn9IJCYmwsfHB9WrV5et+6n79+9DX18fXl5esLCwwM8//4xZs2Zh3bp10NTURNGiRaGlpQVtbW2UKFECenp62baxdetW6OrqYsaMGbC2toa9vb3sfcgaxfncjRs3AAB16tRRqI9y+p2Q9bNfpkyZr65rYWGByMhISKVSWaCxsLBQaL9ZateujcTERNmIYk4iIyNzvV1FfN6H7u7u0NLSwrFjx2TLhIaG4tGjR7I/Fjdv3gwNDQ1ZuK5SpQr++OMPGBoaYvPmzUqvkcShJXYBVHBFR0fLjbBIpVIkJyfD1tYWq1atko0ehYSEID4+Hk5OTnLrOzo6AgAePnyImjVr4t69e2jWrJncMm5ubnBzcwOQOdSvra2NunXryi1Tv359nDp1CgkJCTA0NJR7rlWrVpg9ezYCAwPRsWNHAMDRo0fh7u4OHR0dPH78WKHaAEBXVxfW1tZffU8kEgkyMjK+uowgCLJlP1WrVi25x1WrVpUd+szNa69WrZrcMrq6uggODsaMGTMQEhKChIQE2XOxsbFfrfVzBgYGcu9BVmjIOgT88uVLWFpaokiRIrJlqlSp8s3AKpFIZO9Lbtjb28v+X0NDA0WLFpW9PolEgri4OCxatAh3795FbGwsBEFAcnIyqlevLredsmXLytWsyLrJycl4+vQpWrduLbetrl27frHe+Ph4PHv2DF5eXnLtVatWRdGiRfHw4UN4enrK2j/vy085OTlh5cqV6Ny5Mzp06ABHR0dUqFDhq6O2n7t37x5sbW1lhwGBzDBTu3btL67z9u1baGlpoVixYtmeU/R3QtbP/ueHiD8nCAI0NDQgkUiyfV4UVaJECQD46qHa7/35U8SnfVisWDE4Ozvj+PHj6NWrF4DMPxaNjIxkI5H37t1DjRo15A7v6+rqombNml8NmKReGM4ozxQtWlRuPtf9+/cxatQo9OnTR+7QQ9acscmTJ+N///tftu1k/dKMi4vLFq4+FR8fj7S0tGwhJutU+Xfv3mVbv3jx4qhfvz6OHTuGjh07IigoCC9fvsTs2bNzVRuAHOdCfc7c3By3b9+GIAhf/DLJClyf/6X++aiRgYEBPn78KKtT0df++XZOnjyJYcOGwd3dHUuWLIGZmRkkEglatGjxzdfzOQMDgxzbs77YYmNjc+zDnL7IP2Vubo6PHz8iJiYmx1GiL/l8NOjTL9mIiAh0794dVlZWmDp1KsqVKwctLS2MGTMm23Y+f88UWTcrkH7tZ/ZzWT9vK1euzDanMCkpCW/fvv1qXZ+ysbHBrl27sHHjRixbtgzTpk1D5cqVMWrUKDRt2lSheuLi4r45evW5jx8/wsjIKMefb0V/J2SF9azPwpeEhYWhTJkykEgksjqfP3+eq3qz3sPP57d+qkyZMnjx4kWutpvb/Wfx9PTE6NGjERkZiVKlSuHo0aNwc3OT/SzHx8fjyZMn2aYWpKam5uqzQaqN4YzyjKamJqysrGSPrayscPz4ccyaNQtOTk6yQ39ZIxJjx46VTZD+VFboKV68OD58+PDF/ZmYmEBPTy/H+WXAlw+ReHp64rfffkNsbCyOHDkCCwsLWchRtDZFNWjQADt37sTVq1dRv379HJc5d+4cNDU1sz2fkJAgN+clISFB9ov9e187ABw8eBClSpXC4sWLoaGROdPh8xCgLDo6OkhOTs7W/qXQliXrvThx4kSOE6YB4Pjx46hcuTIqVaqkUC2BgYFITEzEokWLULFiRVl7XFyc3CjZ965brFgxaGhofPVn9nNZP08+Pj6ykdxPfSn8fkmVKlUwd+5cCIKAoKAgrF+/HkOHDsWRI0dQvnz5b67/rc9cToyNjREfH5/jHyCK/k4wMzODtbU1AgMD4evrm+N+UlNTcfXqVbi7uwMASpYsiUqVKuHkyZPo27dvjuu8fPkS9+/fR8uWLWW1ZYWyrwXd+vXrY//+/fjw4UOOPxtpaWnYtWsX2rdvL/uMfj7S9ul1+L7G1dUV+vr6OHHiBBwdHfHvv/9iypQpsudNTExQunRpzJw5M9u6WZ9fUn/sScpXkyZNQlJSkmxkCgAqVKgAExMThIWFwcrKSvavbNmySE9Pl/01aG1tjZs3b8pt7+TJk/jll1+QkJAAe3t7JCcnIykpSW47enp6MDEx+eI8qebNm0NLSwtnz57F8ePH4eXlJfvFrWhtimratCnKly+PefPm5Xix2cjISGzYsAFeXl4oVaqU3HPXr1+Xe/zw4UNZMPje1w5kfrEUKVJE7hd71hmWn3/B/OihHSsrKzx//lzuC//+/fsIDw//6np2dnaoU6cOVqxYkW2yNJD5XowbNw47d+5UuJa0tDQAkOvD27dv4/nz5998nYqsq62tjQoVKsjmYGXZvn07+vfvL9eWtY6hoSGsra0RGhoq149WVlZITU1F8eLFFX59t27dwt27dwFkjhja2dlh5syZyMjIwNOnT7PtOyfW1tYICgqSC9R37txB165d8fLlyxzXKVmyJNLT0xETE6NQnTn9TgAguzBt1jzFz61cuRKJiYno2bOn3Dp37tzBvn37si2fmpqK3377DXPnzpU7dJ81+p11eDMnPXr0QEZGRrYasyxbtgx//PEHgoODAWQGqM9f/507d764/U/p6+ujWbNmCAwMxLFjx2Bubi43XcHe3h6hoaEoU6aM3M+HIAgoWbKkQvsg1cdwRvmqdOnSGDp0KA4cOIBLly4BALS0tNC3b1/s2LEDW7ZswfPnz/Ho0SNMnDgRHTt2lH0Z9+nTB2FhYfj9998RFhaGq1evYvbs2TA1NYWhoSGaNGkCa2trjBkzBpcvX0Z4eDjOnTuH7t27y/3l+TlDQ0O4urrCz88P4eHhsom3ualNUVpaWli6dCnevHmDzp0749ixYwgLC0NoaCj27NmDTp06oWzZsrIzUD/l5+eHixcvIjQ0FPPmzcObN2/Qtm1bAPju1w5k/rIPDg7GkSNHEBYWhg0bNuDu3bsoU6YMHj58KBtFMzExwcOHD/Ho0SNERUXl6nVnadmypezM0+DgYFy/fh3/+9//FJpsPXfuXOjq6qJTp07Yu3cvXrx4geDgYPj5+cHHxwc1a9bM1dXxs+ajrV27Fq9evUJgYCBmzJiBJk2ayPrkS3OeFF23f//+uHLlCtasWYPw8HCcPn0aS5YskYXqrFGYS5cu4eHDhxAEAQMGDMCpU6ewfPlyhISEIDg4GHPnzkXbtm1lJ1Yo4syZMxg8eDBOnDiB8PBwPHv2DGvWrIGenp5sXpyJiQmeP3+OoKCgHE/KyAol48aNQ2hoKO7duye7HElOZ8cC/50I8Hko/ZKcficAQJs2bdC5c2dMmDAB8+bNw/379/H69WvcvHkTEyZMwJ9//omZM2fKjZS2b98e7du3x5QpU/DHH3/g/v37ePXqFc6dO4cePXrg6dOnWLJkCYyMjGTr3LhxAwYGBrC1tf1ijZUqVcL06dNx8OBBDBgwAFeuXEF4eDj++ecfjBs3Dn/++ScmT54se1/t7Ozw6tUr7N69G2FhYfj7779x7tw5hd4PIHM0/9atWzh27Bg8PT3lRiB79uyJhIQEjB49GkFBQQgLC8Pu3bvRpk2bHC8LRGoqvy6oRoXL1y44mZaWJrRu3VpwdXUVEhMTZe1bt24V3N3dBVtbW8HBwUHo37+/8PDhQ7l1T506JbRt21aoVq2a0KhRI2HGjBnCx48fZc9HRUUJEyZMEBwdHYWqVasKDRs2FObMmSO3H2tra2H+/PnZtmttbS20b98+x5q/VdvXXm9OoqKihDlz5ghubm5C9erVBXt7e6Fdu3bCpk2bsl2cdtmyZYK1tbXwzz//CJ07dxaqVasmODk5CX/++We2bX7Pa09ISBDGjh0r1K5dW6hTp44wbtw44ePHj8LGjRsFOzs7oUePHoIgCML+/fuF2rVrCzVq1BCOHDkiu9BrcHDwF9+D4OBgwdraWti3b5+sbffu3UKTJk2E6tWrC+3atRNu3LghtGvXTvD19f3m+xYXFycsXrxYaNWqlWBnZyfUqVNH6Nixo7Bjxw4hNTVVttzntWVp0qSJMGLECNnjtWvXCs7OzoK9vb3Qo0cPITg4WLhx44ZQr149oW7dukJcXJzQvXt3oWPHjtlqUWRdQRCEPXv2CC1bthSqVasmuLq6CkuXLpXVmpGRIQwaNEiwtbUV6tevL7vbwuHDh4U2bdoItra2Qo0aNYTu3bsLV65cke0762ciOTn5i68vNTVVWLRokeDq6ipUq1ZNqFu3rtCrVy/h2rVrsuUvXrwoNGjQQKhWrZqwceNG4erVq4K1tbVw7tw52TK3bt0SunbtKtjZ2QkNGjQQxowZI7x79+6LfSSVSoUmTZoI48aNk2v/nt8JgiAIJ0+eFHx9fYW6desKtra2grOzszBq1Cjh0aNHX6zhyJEjQq9evYQ6deoI1atXF1q0aCH8/vvvQnh4eLZa3dzchOHDh39xW58KCgoSRowYITg5OQm2trZC48aNhaFDhwr//POP3HIJCQnC6NGjhTp16ggODg7C0KFDhRs3bsi9t1/qw6z3o379+oK1tbXw77//5liHr6+vYG9vL9ja2goeHh7C9u3bFXoNpB4kgpBHp6AQkVIsX74cK1aswL1796Crqyt2OT8sJiYGxsbG0NbWBpB50oKTkxNatWqV40kXpH727NmD6dOn4+jRo18cYVMFR48exahRo+Dv7//NM62J8hMPaxJRvgkJCUHDhg0xdepUhISEICQkBDNmzEBcXBw6dOggdnmkJO3atUO1atUwZ84csUv5ovj4eCxevBjdu3dnMCOVw3BGRPmmUqVKWLNmDUJDQ9GxY0d07twZT58+xdq1a78654fUi6amJlasWIEHDx5gw4YNYpeTo0mTJqFMmTIYP3682KUQZcPDmkREREQqhCNnRERERCqE4YyIiIhIhTCcEREREakQhjMiIiIiFVJg762ZkSFFTEzCtxcklWBqasj+UjPsM/XC/lI/7DP1UqJE7u61/DUFduRMU1MDn91zl1SURML+UjfsM/XC/lI/7DP1oux+KrDhjIiIiEgdMZwRERERqRCGMyIiIiIVwnBGREREpEIYzoiIiIhUCMMZERERkQphOCMiIiJSIQxnRERERCqE4YyIiIhIhTCcEREREakQhjMiIiIiFcJwRkRERKRCGM6IiIiIVAjDGREREZEKYTgjIiIiUiEMZ0REREQqRPRwduHCBTRo0AAjR4786nJSqRSLFy9G06ZNUadOHfTp0wdhYWH5VCURERFR/hA1nK1fvx4zZ86ElZXVN5fdtm0bAgICsG7dOpw5cwbly5fHr7/+CkEQ8qFSIiIiovwhajjT1dXF3r17FQpnu3btgo+PDypVqgQjIyOMHDkSISEhuHv3bj5USkRERJRdWloGrlx5pdRtail1a7nUs2dPhZZLTk5GcHAwbGxsZG1GRkawsrJCUFAQ7O3ts6+0qSqKJccpqVLKcxoSFJNyFFStsM/UC/tL/bDPVF5UvC5++bMZLgaXQVrGdKVtV9RwpqgPHz5AEAQUKVJErr1IkSJ4//59zivFPIZmPtRGysP+Uj/sM/XC/lI/7DPVde91KXhv8sLz98WUvm21CGdZvmd+WYaBeR5UQsqmqSFBBv9CVCvsM/XC/lI/7DPVte92BfTe4oLEVG0AQCmTRKVuXy3CWdGiRaGhoYHY2Fi59tjYWBQvXvyL62UYmCOmw+M8ro5+lEQCmJkZ433UR/D8DvXAPlMv7C/1wz5TXTt23MfwP0/IHtvbl4Kfn5dS9yH6pTQUoauri59++gkPHjyQtcXFxeHly5ews7MTsTIiIiIqTJo2rQBzcyMAQIcOVeHv3wnm5sZK3YfKhrPIyEi4u7vLrmXWtWtXbNmyBSEhIYiPj8eCBQtQtWpVVK9eXeRKiYiIqLAoWdIQmzd7YcaMxli50h36+tpK34eohzWzglV6ejoAIDAwEAAQFBSEtLQ0hIaGIjU1FQDQpUsXvHv3Dj169EBCQgLq1auHFStWiFM4ERERFQrnz79E9eolUKyYvqzN3r407O1L59k+JUJBvYrrQgnnnKmJrLkVUZxboTbYZ+qF/aV+2GfiEwQBK1fexMyZF9GokSW2b28LLa2cDzhm9ZeyqOxhTSIiIiIxJCWlYdCgo5gx4wKkUgFnz77A3r2P8m3/anG2JhEREVF+ePUqDj4+B3Hv3ltZ25gxjujUyeYraykXwxkRERERgKtXw+HrG4CoqMzrlhkYaGPFCne0bv1TvtbBcEZERESF3pYt9zBx4mmkpUkBAFZWReDn5wUbmxL5XgvDGRERERVaGRlSTJx4Bps335W1NWpkifXrPeTO0MxPPCGAiIiICi0NDQkSElJljwcMqImdO9uJFswAjpwRERFRISaRSLBgQTOEhcXhl1+qo3Pn/Jv4/yUMZ0RERFSovHuXiBIlDGSP9fW1ceBAJ2hoSESs6j88rElERESFQkaGFDNmnEeDBpvw7Nl7uedUJZgBDGdERERUCHz4kIxffjmAFStu4sOHFPTs6Y/ExDSxy8oRD2sSERFRgfb0aTR69vTHs2exAABNTQl6964BfX3VjEGqWRURERGREhw/HoJBg44iPj7zjExTUz38+WdrODtbilzZlzGcERERUYEjCAKWLLmOOXMuyW4eb2Njhi1bvGFpWUTc4r6B4YyIiIgKlPj4VAwffhwBAf/K2ry8rLF0qRsMDbVFrEwxDGdERERUoNy6FYFDhzKDmUQCTJrkjGHD6kAiUZ0zMr+GZ2sSERFRgdK4sRUmTHCCkZEOtm5tg+HD66pNMAM4ckZERERqTvj/SWWfBrARI+qiY8eqKFvWRKyyvhtHzoiIiEhtpaSkY9Sok9i48Y5cu0QiUctgBnDkjIiIiNRUZGQ8evcOwM2bEdDUlKBKleIqfYkMRTGcERERkdq5fTsCPj4H8eZNAgBAW1sD798ni1yVcjCcERERkVrZufMBxo4NREpKBgDAwsIYfn5esLMrJXJlysFwRkRERGohPV2K6dPPY+3a27I2R0cLbNjgiRIlDESsTLkYzoiIiEjlxcQkoV+/w7hw4aWszcenBmbOdIGOjqaIlSkfwxkRERGpvE+Dmba2BmbPdkXPnnYiV5U3eCkNIiIiUnnTpzeGgYEWzMwMsG9fxwIbzACOnBEREZEaqFatBDZt8oK1dXFYWBiLXU6e4sgZERERqZT4+FTMm3cZaWkZcu1NmpQv8MEM4MgZERERqZBnz97Dx+cgHj+ORkxMEubMaSp2SfmOI2dERESkEs6ceQ43t+14/DgaALBv32NERHwUuar8x3BGREREohIEAatX30LXrvvx4UMKAMDa2hTHj3dDmTIF/zDm53hYk4iIiESTlJSG0aMDsXfvI1mbm1tFrFrVEsbGuiJWJh6GMyIiIhLF69cf4eNzEHfuRMraRo2qh3HjGkBDQyJiZeJiOCMiIqJ89++/MWjTZjfevUsEABgYaGP5cjd4elqLXJn4GM6IiIgo31lZFUH58kXx7l0iLC1N4OfnDVvbEmKXpRJ4QgARERHlOx0dTWzc6In27X/G8eO/MJh9giNnRERElOeiohIRF5eCihWLydpKlTLE6tWtRKxKNXHkjIiIiPJUUNBbtGixDV277kdsbLLY5ag8hjMiIiLKMwcOPEHr1jvx6tVHhIbG4rffzohdksrjYU0iIiJSuowMKWbPvoRly27I2mrVKo0pUxqKWJV6YDgjIiIipYqLS8HAgUcQGBgqa+vSxRbz5jWFnh6jx7fwHSIiIiKl+fffGPTs6Y+QkPcAAE1NCWbMaIy+fR0gkRTeC8vmBsMZERERKcXJk88wcOARfPyYCgAoVkwP69e3RqNGliJXpl4YzoiIiEgp/v03RhbMqlY1g5+fF8qXLypuUWqI4YyIiIiUYtCgWrh//x2Sk9OxbJkbjIx0xC5JLTGcERER0XdJTEyDgYG27LFEIsGSJS2gpaVRqG9c/qN4nTMiIiLKtcuXw1CnzgacPv1crl1HR5PB7AcxnBEREZHCBEHAxo130KHDPrx7l4gBAw7j2bP3YpdVoPCwJhERESkkJSUdEyeexl9/3Ze11axZGqam+iJWVfAwnBEREdE3RUYmwNc3ADduvJa1/fprbUye7AxNTR6IUyaGMyIiIvqqf/55Ax+fg4iIiAcA6OlpYtGiFujQoarIlRVMDGdERET0Rbt3P8To0SeRkpIBADA3N4Kfnzdq1CglcmUFF8MZERER5SgqKhETJpyWBbO6dc2xcaMnSpY0FLmygo0HiYmIiChHZmYGWL26JSQSoEeP6vj7744MZvmAI2dERET0RW5ulXDy5C+oXr0kb1yeTzhyRkRERACAo0eDMXnyGQiCINduZ1eKwSwfceSMiIiokJNKBSxadBXz5l0BAFSoUAx9+tiLW1QhxpEzIiKiQiw+PhW+vgGyYAYAt29HZBs9o/zDkTMiIqJC6vnzWPTq5Y9Hj6IBABIJMHlyQwwZUpuHMUXEcEZERFQInTv3Av37H8b798kAABMTXaxZ0xLNmlUUuTJiOCMiIipEBEHA2rW3MW3aeUilmYcuK1cuhq1b26BSpWIiV0cAwxkREVGhsnr1LUybdl72uHnzCli9uhVMTHRFrIo+xRMCiIiICpHOnW1haWkCABgxoi62bPFmMFMxHDkjIiIqRIoX18fmzd4ICYmBt3cVscuhHHDkjIiIqADbt+8RoqIS5dqqVSvBYKbCGM6IiIgKoLS0DEyadBqDBh1Fv36HkJaWIXZJpCCGMyIiogImOjoJnTv/jT//vAMAuHTpFY4dCxG3KFIY55wREREVIPfvv4OPjz9evowDAGhra2DevKbw9LQWuTJSFMMZERFRAXHw4FMMG3YMiYnpAICSJQ2xaZMn6tQxF7kyyg2GMyIiIjUnlQqYN+8yFi26JmtzcCiFzZu9UKaMsYiV0fdgOCMiIlJjqakZ6NMnAMePP5O1depkgwULmkFPj1/z6oi9RkREpMa0tTVgZmYAANDQkGD69Mbo39+BNy5XYwxnREREakwikWDOHFe8e5eIfv0c0Lixldgl0Q9iOCMiIlIjgiAgNDQWFSv+d5NyXV0t/PVXG/GKIqXidc6IiIjURGJiGgYNOoJmzbbhyZNoscuhPMJwRkREpAZevYqDp+cu/P33E8THp8LH5yBSU3nV/4KIhzWJiIhU3NWrr+DrG4CoqCQAgIGBNiZPdoaOjqbIlVFeYDgjIiJSYZs338WkSWeQni4FAFhZFcGWLd6oWtVM5Moor4h6WDM8PBz9+/dHvXr10KRJE8yfPx9SqTTbclKpFMuWLYOrqyscHBzg6emJI0eOiFAxERFR/khNzcCYMYEYN+6ULJg1bmyFEye6MZgVcKKOnA0dOhS2trYIDAxEdHQ0BgwYADMzM/Tu3VtuuR07dmDPnj3w8/ODlZUVzp8/jyFDhqBixYr4+eefRaqeiIgob7x9m4C2bffi4sWXsraBA2th6tSG0NLidPGCTrQeDgoKwuPHjzFmzBgYGxujfPny8PHxwa5du7It++DBA9SqVQsVK1aEpqYmmjRpgqJFi+LJkyciVE5ERJS3Hj2KwuXLYQAAXV1NrFjhjhkzGjOYFRKijZw9ePAAFhYWKFKkiKzN1tYWoaGhiI+Ph5GRkazdxcUF06ZNw6NHj1CpUiVcuHABSUlJqFu37jf3wwskq76sPmJfqQ/2mXphf6kfFxcrzJ3bDIsWXYGfnxccHEqLXRJ9hbI/W6KFs9jYWJiYmMi1ZQW19+/fy4WzFi1a4NGjR2jTpg0AQF9fH3PnzkWZMmW+ug9NDQnMzHjDV3VRvDj7St2wz9QL+0t1ZWRIoaEhkbvl0ujR9eHr6wBTU30RKyMxiDrnTBAEhZY7cOAADhw4gD179qBKlSq4cuUKRo8ejTJlysDOzu6L62VIBbyP+qiscimPSCSZXxrR0R+h4I8EiYx9pl7YX6otNjYZ/fsfRuPGVvj119oA/uszQUhHFL/HVF5WfymLaOHM1NQUsbGxcm2xsbGQSCQwNTWVa//rr7/QuXNnWRBzcXGBo6MjDh48+NVwBoC/iNSIILC/1A37TL2wv1TPkyfR6NnTH6GhsTh37iV+/tkMrq7lZc+zzwon0WYWVqtWDREREYiJiZG1BQUFoXLlyjA0NJRbViqVIiND/irIqamp+VInERFRXjh+PAQtW+5AaGgsAKBYMT3o6fGisiRiOLOxsUH16tWxcOFCxMfHIyQkBJs2bULXrl0BAO7u7rh58yYAwNXVFXv37sXjx4+Rnp6Oixcv4sqVK2jatKlY5RMREX0XQRCwaNFV9Ozpj/j4zIEGW9sSOH68Gxo0KCdydaQKRJ1ztmzZMkyZMgVOTk4wMjJCly5d0K1bNwBAaGgoEhMTAQADBgxAeno6fv31V8TExMDCwgIzZ85E/fr1xSyfiIgoV+LjUzFs2HEcOvSvrM3b2xpLlrjB0FBbxMpIlUgERWflq5uFEmQYmCOmw2OxK6FvkEgAMzNjREVxsrK6YJ+pF/aXanjx4gN69vTHo0dRADL7ZdIkZwwbVkfuLM2s59hn6iOrv5SF99YkIiLKY4IgYODAI7JgZmysgzVrWqF584oiV0aqiJcaJiIiymMSiQRLlrSAoaE2KlUqhmPHujGY0Rdx5IyIiCgfVKlSHDt3tsPPPxdHkSJ6YpdDKowjZ0REREr25k08xo8/hZSUdLn2evUsGMzomzhyRkREpES3bkXAx+cgIiMTkJaWgYULm2eb8E/0NRw5IyIiUpKdOx/A23s3IiMTAABnz75AdHSSyFWRuuHIGRER0Q9KT5di2rRzWLfuH1lb/foW+PNPT5iZGYhYGakjhjMiIqIfEBOThH79DuHChTBZW+/eNTBzpgu0tXk7Jso9hjMiIqLv9PDhO/TseRAvX34AAGhra2DOHFf06GEncmWkzhjOiIiIvsO9e5Hw8tqNxMQ0AECJEgbYuNET9epZiFwZqTueEEBERPQdqlY1g4NDKQCAvX0pnDz5C4MZKQXDGRER0XfQ1tbE+vWtMXBgLfj7d4K5ufLurUiFGw9rEhERKeDZs/dISclA1apmsjYzMwPMmNFYxKqoIOLIGRER0TecPv0cbm7b0aPHAV63jPIcwxkREdEXCIKAlStvolu3/fjwIQUvX8bhjz8uil0WFXA8rElERJSDpKQ0jBp1Evv2PZa1ubtXwvTpPIxJeYvhjIiI6DPh4R/h43MQd+9GytpGj3bE2LH1oaHB+2RS3mI4IyIi+sTVq+Hw9Q1AVFQiAMDAQBsrVrijdeufRK6MCguGMyIiov/3119BGD/+FNLSpAAAS8si2LLFCzY2JUSujAoThjMiIqL/l5KSIQtmDRtaYv16D5ia6otcFRU2DGdERET/z9e3Bu7ffwsjIx3873+NoKXFixpQ/mM4IyKiQisqKhFmZgayxxKJBAsXNuekfxIV/yQgIqJCaf/+x6hdewOOHw+Ra2cwI7ExnBERUaGSkSHFzJkXMGDAESQmpmHQoKMICXkvdllEMjysSUREhcaHD8kYOPAITp16Lmvz9PwJZcvypuWkOhjOiIioUPj33xj07OkvGyXT1JTg999d0KePPSQSHsok1cFwRkREBd6JE88waNARfPyYCgAwNdXD+vWt0bChpciVEWXHcEZERAWWIAhYuvQ6Zs++BEHIbLOxMYOfnzesrIqIWxzRF/CEACIiKrDevInHypU3ZcHM0/MnHDrUhcGMVBrDGRERFVhlyhhj7VoPaGlpYOJEJ/z5Z2sYGemIXRbRV/GwJhERFSiCIMhN8Hd1LY8rV3pztIzUBkfOiIioQBAEARs23MGIEScgZB3H/H8MZqROOHJGRERqLyUlHRMmnMa2bfcBAD//bIZBg2qJXBXR92E4IyIitRYZGY/evQNw82aErC06OlHEioh+DMMZERGprX/+eQMfn4OIiIgHAOjpaWLx4hZo376qyJURfT+GMyIiUku7dj3EmDEnkZKSAQAwNzeCn583atQoJXJlRD+G4YyIiNRKeroU06efx9q1t2Vt9epZYMOG1ihZ0lDEyoiUg2drEhGRWlmw4IpcMOvVyw779nVgMKMCg+GMiIjUysCBtVChQlFoaWlg3rymmD+/GXR0NMUui0hpeFiTiIjUStGietiyxRvv3yfB0bGs2OUQKR1HzoiISGVJpQJWrryJyMgEufYqVYozmFGBxXBGREQqKT4+Fb17H8T06efh6xuAlJR0sUsiyhcMZ0REpHJCQ2PRqtUOHD0aAgC4efM1Ll16JXJVRPmD4YyIiFTK2bMv4Oa2DY8fRwMATEx0sWNHW7i6lhe3MKJ8whMCiIhIJQiCgLVrb2PatPOQSjNvXP7TT6bYssUblSoVE7k6ovzDcEZERKJLSkrDmDGB2LPnkazNza0iVq1qCWNjXRErI8p/DGdERCSqxMQ0tG27G//8EylrGzWqHsaNawANDYmIlRGJg3POiIhIVAYG2nBwKP3//6+FDRtaY8IEJwYzKrQ4ckZERKL7/XcXxMenYdCgWrC1LSF2OUSiYjgjIqJ8lZaWgYcPo1CjRilZm7a2JlascBexKiLVwcOaRESUb6KiEtGp0z54e+/CgwfvxC6HSCUxnBERUb4ICnoLN7ftuHTpFRIT09Gv3yGkp0vFLotI5TCcERFRnvP3fwJPz50IC4sDAJQsaYilS92gpcWvIaLPcc4ZERHlmYwMKebMuYylS6/L2mrWLI1NmzxRpoyxiJURqS6GMyIiyhNxcSkYNOgITp4MlbV17myD+fObQU+PXz9EX8JPBxERKV1wcAx69vRHcPB7AICmpgTTpjVG//4OkEh4/TKir2E4IyIipXvzJh6hobEAgKJFdbF+fWs0bmwlblFEaoIzMYmISOmcnS3x++8uqFq1OI4f/4XBjCgXviucJScn4+jRo9i0aZOs7c2bN0orioiI1EtycjoEQZBr69PHHseOdUOFCkXFKYpITeU6nN2+fRuNGzfGokWLsHDhQgBAeHg4WrZsiStXrii9QCIiUm2vXsXBw2Mnliy5LtcukUigr68tUlVE6ivX4Wz27NkYNmwYTp48CQ2NzNUtLCwwa9YsLFiwQOkFEhGR6rpy5RVatNiGoKC3mDPnEo4fDxG7JCK1l+tw9u+//6Jz584AIHfGjbu7O549e6a8yoiISGUJgoBNm+6iffu9iIpKAgBYWRWBlVURkSsjUn+5DmclSpRAREREtvagoCAYGRkppSgiIlJdqakZGDMmEOPHn5LdfqlxYyscP94NP/9sJnJ1ROov15fS8PT0RL9+/dC7d29IpVIEBgbi8ePH2LZtG7p165YXNRIRkYp4+zYBvr4BuH79taxt0KBamDKlIW/FRKQkuQ5nQ4cOhbGxMbZu3QqJRIJJkyahXLlyGDVqFDp06JAXNRIRkQq4c+cNfHwO4vXreACArq4mFi1qjo4dbUSujKhgyXU4Cw8PR+/evdG7d2+59tTUVNy9exf29vbKqo2IiFSEIAgYMyZQFszKlDGCn58X7O1Li1wZUcGT6zFoDw+PHNuTkpKyBTYiIioYJBIJ1q71gImJLurUMceJE78wmBHlEYVHzvbs2YO9e/ciLS0NXbp0yfb827dvUbRoUWXWRkREKqRSpWI4cKATfvqpGHR1efc/oryi8KerRYsWMDY2xujRo+Hs7JzteV1dXTRr1kypxRERkTiePInGwoVXsXRpC7kLyVarVkLEqogKB4XDWZEiReDu7g4Asv9+bvv27ahQoYJyKiMiIlEcPRqMwYOPIiEhDdraGlixwl3uupZElLdyPS7t7u6Op0+f4sGDB0hNTZW1R0ZGYtOmTbycBhGRmpJKBSxefA1z516WtT16FIWPH1NhYqIrYmVEhUuuw9mOHTvw+++/o3jx4oiKikKpUqXw9u1bWFhYYPjw4XlRIxER5bH4+FQMG3Ychw79K2tr06YKlixpAQMD3h+TKD/l+mzNDRs2YOPGjbhw4QK0tbVx9uxZnDt3Dra2tqhWrVpe1EhERHno+fNYeHjslAUziQSYPNkZa9e2YjAjEkGuw1l0dDQcHR0zV9bQgCAIKFGiBMaOHYvp06crvUAiIso758+/hJvbdjx6FAUAMDHRxbZtbTBsWF3OMyMSSa7Dmbm5Oa5evQog8z6bN2/eBAAYGxvj1atXyq2OiIjyzNWrr9C58z68f58MAKhcuRiOHeuKZs0qilwZUeGW6zlnAwYMQJ8+fXD16lW0b98egwYNQu3atfHs2TPUqlUrL2okIqI8ULu2ORo2tMTZsy/QvHkFrF7dihP/iVRArsOZl5cXatasCWNjYwwcOBDFixdHUFAQatasia5du+ZFjURElAe0tDSwbp0H/vorCIMG1YKmJm9cTqQKJIIgCMramCAIuZqjEB4ejunTp+Pu3bswMDBAq1atMHr0aGhoZP8FERISgmnTpuHevXsoWrQoevfuDR8fny9vfKEEGQbmiOnw+DteCeUniQQwMzNGVNRHKO+nkfIS+0y9ZPXXsWNPoKWliRo1SoldEn0DP2PqJau/lCVXfyYdOXIEI0eOxMiRI3HmzBm554KDg3O8rdPXDB06FKVKlUJgYCA2bdqEwMBA+Pn5ZVsuOTkZffv2RePGjXH16lUsX74ce/fuRUhISK72R0RUWG3a9A+8vfegVy9/REYmiF0OEX2FwuFsx44d+O2332BoaAgdHR2MHDkShw4dQnp6OpYvX462bduibNmyCu84KCgIjx8/xpgxY2BsbIzy5cvDx8cHu3btyrbs0aNHYWRkhL59+0JfXx92dnY4dOgQKlWqpPD+iIgKo7S0DEyadAa+vgeRmpqB16/jsWLFDbHLIqKvUHjO2fbt27Fs2TI0bNgQAODm5oa5c+di7dq1SE5OxurVq3O85+aXPHjwABYWFihSpIiszdbWFqGhoYiPj4eRkZGs/datW7C2tsbEiRNx8uRJmJmZYfDgwfDy8vrmfngmuOrL6iP2lfpgn6mH6Ogk9O17CBcvhsna+vSxx//+15B9p+L4GVMvyu4nhcPZq1ev4OTkJHvs7OyMIUOGoF+/fhg8eDB0dXN3hk9sbCxMTEzk2rKC2vv37+XC2Zs3b3Dz5k38/vvvmDp1Ko4dO4bx48ejcuXKsLGx+eI+NDUkSj0GTHmreHH2lbphn6mue/ci4e29E8+fxwIAtLU1sGqVB/r2rSluYZQr/IwVTgqHM6lUKjdRX0dHB9ra2hg5cuR371zRcxEEQYCtrS08PT0BAG3btsXOnTtx7Nixr4azDKmA91Efv7s+yh8SSeYvoOhoTnxVF+wz1Xbw4FMMHXoMiYnpAICSJQ2wf38XVKlSFFH8nagW+BlTL1n9pSy5vpSGspiamiI2NlauLTY2FhKJBKampnLtJUqUyLashYUF3r1798398IdafQgC+0vdsM9Uz4IFVzBv3hXZY3v7UvDz84KdnTnP/FND/IwVTgqHM0EQ8Pz5c7nRrpzaKlSooND2qlWrhoiICMTExMjCWFBQECpXrgxDQ0O5ZStVqoQdO3bIXaojPDxcNv+NiIgylSr13+/PDh2qYuHCZrw/JpGaUTicpaamomXLltkORbq7u0MikciC06NHjxTano2NDapXr46FCxdi4sSJiIyMxKZNm+Dr6yvb7syZM1G7dm14eXlh1apVWLNmDXr37o3AwEA8ePAA8+fPz8VLJSIq+Hr0sMPjx9EoW9YEAwfW5P0xidSQwuHs1KlTSt/5smXLMGXKFDg5OcHIyAhdunRBt27dAAChoaFITEwEAJQqVQpr167FrFmzsGrVKpibm2PlypWwtLRUek1EROokNDQWFSoUlWubNauJOMUQkVIo9Q4BKoV3CFAbvBK2+mGfiU8QBKxceROzZl3EunUe8PS0/uKy7C/1wz5TL6LeIYCIiMSXlJSGQYOOYsaMC8jIEDB06HGEhsaKXRYRKYloZ2sSEVHuhYd/RK9e/rh3762sbfDgWrCyKvKVtYhInTCcERGpiatXw+HrG4CoqMz5uAYG2lixwh2tW/8kcmVEpEzffVgzOjoa9+/fV2YtRET0BVu23EP79ntkwczKqgiOHOnCYEZUAOU6nEVGRqJPnz5wcnJCly5dAABv376Fp6cnwsLCvrE2ERHlRmpqBsaODcSYMYFIS5MCABo1ssSJE91gY1NC5OqIKC/kOpzNmDEDpqamOHPmjOx2TqampnB2dsbMmTOVXiARUWH27l0iAgKeyh4PGFATO3e2Q7Fi+iJWRUR5Kddzzq5evYrz58/D0NBQdnFDLS0tDB8+HI0bN1Z6gUREhZmFhTH+/LM1unf3x5w5rujSxVbskogoj+U6nOnr6+d4w/IPHz4gIyNDKUURERVmGRlSaGr+d2DD2dkSt271RfHiHC0jKgxyfVjT0dERkyZNQmhoKAAgLi4O169fx9ChQ+Hi4qLs+oiICo2MDClmzDiPgQOPZPsjmMGMqPDI9cjZlClTMH78eLRs2RIAUK9ePUgkErRq1QpTpkxReoFERIVBbGwyBg48gtOnnwMAbG1LYMSIeuIWRUSiyHU4K1KkCNasWYOYmBiEhYVBV1cXZcuWhZGRUV7UR0RU4D19Go2ePf3x7FksAEBTUwJjYx1xiyIi0eQ6nLVq1QoeHh5o1aoVatSokRc1EREVGsePh2DQoKOIj08FAJia6uHPP1vD2dlS5MqISCy5nnPWqVMnXLlyBR4eHmjTpg3WrVvH65sREeWSIAhYsuQaevb0lwUzGxsznDjxC4MZUSGX65EzHx8f+Pj4IDo6GqdPn8bJkyexYsUKVKlSBR4eHvDx8cmDMomICo6EhDQMH34cBw/+d/0yLy9rLF3qBkNDbRErIyJV8N23bypevDg6duyIdevWwc/PD7q6upg7d64yayMiKpDmzr0sC2YSCTBpkhPWr/dgMCMiAN9543NBEHDr1i0EBgbi1KlTiI6OhouLC5YuXars+oiICpyxYx1x+nQoXr+Ox+rVLeHmVknskohIheQ6nE2cOBHnzp1DUlISXFxcMHbsWDRu3Bi6urp5UR8RUYFjbKyLLVu8kZ4uhbV1cbHLISIVk+twlpycjP/9739wcXFhICMi+oaUlHTMmnUJAwfWhLm5say9YsViIlZFRKpMoXD24sULWFlZAQCGDRsGAHj9+nWOy1aoUEFJpRERqbfIyHj4+ATg1q0IXLv2Cv7+naGn912zSYioEFHot4Snpyfu3bsHAGjZsiUkEoncrUWyHkskEjx69ChvKiUiUiO3b0fAx+cg3rxJAAA8ehSFu3cjUa+ehciVEZGqUyicHTt2TPb/p06dyrNiiIgKgp07H2Ds2ECkpGQAACwsjOHn5wU7u1IiV0ZE6kChS2mYm5vL/n/y5MmwsLDI9q9IkSIYMmRInhVKRKTq0tOlmDLlLIYNOy4LZo6OFjhx4hcGMyJSmMKTHx48eICgoCDcuHEDu3fvljusCQAvX77E8+fPlV0fEZFaiIlJQr9+h3HhwktZm49PDcyc6QIdHU0RKyMidaNwOPv48SPOnj2L9PR0rFmzJtvzenp6GD58uFKLIyJSBx8/psDNbTtevPgAANDW1sDs2a7o2dNO5MqISB0pHM4cHR3h6OiIQYMGYfXq1XlZExGRWjE21kXLlpWxZs0tmJkZYONGTzg6cuI/EX2fXF9KY9y4cQgNDf3isryUBhEVRlOnNoQgCBg4sBYsLIy/vQIR0Rco5VIaWXgpDSIqDOLjU3H3biScnMrJ2rS0NPD77y7iFUVEBQYvpUFElAvPnr2Hj89BPH8ei4CALqhRg2dhEpFy5fpSGhYWFvj48aPsEhoAcPLkSTx9+lT2mIioIDpz5jnc3Lbj8eNoJCdnYNiw45BKsx9FICL6Ebm+j8imTZuwdu1aXL16FbGxsejUqRMqVaqEyMhI/Pvvv+jfv39e1ElEJBpBELBmzW1Mn35eFsasrU2xaZMnNDQkIldHRAWNQiNnn9q6dSs2bNgAANi/fz/Kli2LLVu2YOPGjdizZ4/SCyQiElNSUhp+/fUY/ve/c7Jg5uZWEUePduXNy4koT+R65Oz9+/ewtbUFAFy8eBHu7u4AMg93RkVFKbc6IiIRvX79ET4+B3HnTqSsbdSoehg3rgFHzIgoz+Q6nJUsWRLBwcHQ09PD9evXMW3aNABAaGgojI15+jgRFQzXr79G794H8e5dIgDAwEAby5e7wdPTWuTKiKigy3U4GzBgADp27AhBENC2bVuUK1cOHz9+xKBBg9C+ffu8qJGIKN9JpQJiY5MBAJaWJvDz84atbQmRqyKiwiDX4axdu3ZwcnJCfHw8KlWqBAAwMjLC0KFD4eHhofQCiYjE4OhogTlzXHHgwBOsW9caxYvri10SERUSuQ5nAKCtrY179+7h6NGjAABLS0u4uroqtTAiovwUG5sMExNdublkPXrYoVu3atDUzPW5U0RE3y3X4ezKlSv49ddfoa+vj3LlMq+O/fLlS8yaNQtbt26FtTXnYxCRegkKegsfn4Po2LEqJkxwknuOwYyI8luuw9n8+fMxdOhQ9O7dW9aWkZGB1atXY9asWfDz81NqgUREeenAgScYPvw4kpLSsWjRNdjZlUKrVpXFLouICrFc/0n47Nkz9OjRQ65NU1MT/fv35301iUhtZGRIMWvWRfTvfxhJSekAgFq1SqNmzdIiV0ZEhV2uw1nJkiXx/PnzbO1hYWEwMjJSRk1ERHkqLi4FPXr4Y+nS67K2Ll1ssX9/J5Quzd9jRCSuXB/W9Pb2Rv/+/fHLL7+gYsWKADJH07Zt2ya7IC0RkaoKDo5Bz57+CA5+DwDQ1JRgxozG6NvXARIJLyxLROLLdTgbPHgwTExMsG/fPrx69QqpqamwtLREly5d0KdPn7yokYhIKQIDn2HAgCP4+DEVAFCsmB7Wr2+NRo0sRa6MiOg/uQ5nEokEPXr0yDbvjIhIlWVkSPHHH5dkwaxqVTP4+XmhfPmi4hZGRPSZXIWzO3fuIDAwEJqamnBzc4ONjU1e1UVEpFSamhrYtMkLLVpsg5NTOSxb5gYjIx2xyyIiykbhEwJOnjyJ7t274+HDh7hz5w46d+6Mixcv5mVtRERKZWVVBMePd8OGDa0ZzIhIZSk8crZ27VrMnTtXdoumgIAArFixAs7OznlWHBHR97p8OQyLF1/H5s1eMDTUlrXzMCYRqTqFR85CQ0PRokUL2WM3NzcEBwfnSVFERN9LEARs3HgHHTrsw7lzLzBy5AkIgiB2WUREClN45Cw9PR3a2v/99amjo4O0tLQ8KYqI6HukpKRj4sTT+Ouv+7K22NhkJCWlw8BA+ytrEhGpju+68TkRkaqJjEyAr28Abtx4LWv79dfamDzZmffHJCK1kquRs0WLFn2zbdSoUcqpjIhIQf/88wY+PgcREREPANDT08SiRS3QoUNVkSsjIso9hcNZzZo18c8//3y1jVfXJqL8tnv3Q4wefRIpKRkAAHNzI/j5eaNGjVIiV0ZE9H0UDmdbt27NyzqIiHLt1KlQDBlyTPa4bl1zbNzoiZIlDUWsiojox3AiBhGprSZNyqNFi8x7/PbsaYe//+7IYEZEao8nBBCR2tLQkGDVqpY4fjwEHTvyjiVEVDBw5IyI1MbRo8FyZ2MCgImJLoMZERUoDGdEpPKkUgELFlxBr14H0bt3ACIiPopdEhFRnvmucPbmzRv8+eefmDlzpqzt3r17SiuKiChLfHwqfH0DMG/eFQDA27cJcheZJSIqaHIdzk6dOoUWLVrg4sWL2LVrFwAgIiICvXv3xuHDh5VeIBEVXs+fx8LDYweOHMm8VZxEAkyZ0hBjxjiKXBkRUd7JdThbsmQJFi1ahM2bN8uua1amTBmsXLkSq1evVnqBRFQ4nTv3Am5u2/HoUTSAzLll27a1wdChdXhNRSIq0HJ9tmZYWBhcXV0ByF90tk6dOnj16pXyKiOiQkkQBKxdexvTpp2HVJp5w/LKlYth69Y2qFSpmMjVERHlvVyPnJmbm+PJkyfZ2i9evIjixYsrpSgiKrzGjj2FqVPPyYJZ8+YVcOxYNwYzIio0cj1y1q1bN/Tp0wcdOnRARkYGNm/ejCdPnuDIkSMYN25cXtRIRIVI3brm2LIl8wSjESPqYvz4BrxxOREVKrkOZ927d0fJkiWxb98+lCtXDv7+/ihXrhxWr16NBg0a5EWNRFSIdOpkg+DgGNjYlECbNlXELoeIKN991x0CWrRogRYtWii7FiIqhO7ceQN7+9JybZMmOYtUDRGR+HIdzlasWPHV54cMGfLdxRBR4ZGWloGpU89hw4Y7WL26Jdq3ryp2SUREKiHX4ezChQtyjzMyMhAeHg4AcHBwUE5VRFSgRUcnoW/fAFy6lHmG98iRJ+DoWBYWFsYiV0ZEJL5ch7OsC89+SiqVYs2aNdDR0VFKUURUcN2//w4+Pv54+TIOAKCtrYHZs10ZzIiI/p9SToHS0NBAv379sHHjRmVsjogKqIMHn6J16x2yYFaypCEOHOiEX36pLnJlRESq47tOCMjJjRs3kJ6erqzNEVEBIpUKmDv3MhYvviZrc3Aohc2bvVCmDEfMiIg+letw5uyc/Syq5ORkJCQkwMfHRxk1EVEBEheXgsGDj+LEiWeyto4dq2LhwubQ01Pa34dERAVGrn8zjh49Olubrq4urKysYGtrq5SiiKjgiI9Pxe3bbwAAGhoSTJvWCAMG1OT9MYmIviDX4SwqKgr9+vXLi1qIqAAyNzfGxo2e6NMnACtXtoSLi5XYJRERqbRcnxDg5+eHmJiYvKiFiAoAQRCQnCw//9TR0QI3bvRhMCMiUkCuR8769u2L4cOHo1WrVjA3N4empqbc8znNSSOiwiExMQ2jRp1AYmI6Nm/2gobGf4cuDQy0RayMiEh95DqczZkzB0Dm2Zmfk0gkePTo0Y9XRURq59WrOPTqdRBBQW8BAPPmXcaECU4iV0VEpH4UDmcREREoU6YMHj9+nJf1EJEaunr1FXx9AxAVlQQAMDTUhp1dKZGrIiJSTwrPOXN3d8/LOohITW3efBft2u2VBbPy5Yvg6NGuaNWqssiVERGpJ4XDmSAISt95eHg4+vfvj3r16qFJkyaYP38+pFLpV9eJjIyEg4MDli9frvR6iEhxqakZGDMmEOPGnUJ6eubntnFjKxw/3g0//2wmcnVEROpL4cOaeXFNoqFDh8LW1haBgYGIjo7GgAEDYGZmht69e39xnZkzZ2Y7CYGI8tfbtwlo23YvLl58KWsbOLAWpk5tCC0tpdwVjoio0FI4nKWmpqJLly7fXG7nzp0KbS8oKAiPHz/Gpk2bYGxsDGNjY/j4+MDPz++L4ezcuXMIDg6Gi4uLomUTUR5YsOCqLJjp6mpi4cLm6NTJRuSqiIgKBoXDmYaGhlIvk/HgwQNYWFigSJEisjZbW1uEhoYiPj4eRkZGcssnJydjxowZmDVrFg4cOKDwfngRctWX1UfsK/Xxv/81xM2bEYiKSoSfnxccHEqLXRJ9BT9j6od9pl6U3U8KhzMtLS0MGTJEaTuOjY2FiYmJXFtWUHv//n22cLZy5UrY29vD0dFR4XCmqSGBmRlvqqwuihdnX6kLMzPg4MGu0NXV5I3L1Qg/Y+qHfVY4KRzO8uKEAEW3GRwcjD179iAgICBX28+QCngf9fF7SqN8JJFk/gKKjv6IPPgxox8UG5uMCRNO47ffnFGuXOYfVBIJUL58UURHf0QUP2Mqj58x9cM+Uy9Z/aUsCoezOnXqKG2nAGBqaorY2Fi5ttjYWEgkEpiamsraBEHAtGnTMHToUJQoUSLX++EPtfoQBPaXqnnyJBo9e/ojNDQWT55EIyCgCwwN/7vSP/tMvbC/1A/7rHBSOJxt2LBBqTuuVq0aIiIiEBMTIwtjQUFBqFy5MgwNDWXLvX79Gjdu3MC///6LZcuWAQASExOhoaGB06dPY//+/Uqti4gyHT8egkGDjiI+PhUAEBERj9DQWFSrlvs/koiISHG5vn2TstjY2KB69epYuHAhJk6ciMjISGzatAm+vr4AMi96O3PmTDg4OODcuXNy686ePRulS5dG3759xSidqEATBAGLF1/D3LmXZX+x29qWwJYt3rLDmkRElHdEC2cAsGzZMkyZMgVOTk4wMjJCly5d0K1bNwBAaGgoEhMToampidKl5c8E09fXh5GR0Xcd5iSiL4uPT8Xw4ccREPCvrM3b2xpLlrjJHc4kIqK8IxHyYqa/KlgoQYaBOWI68F6gqk4iAczMjBEVxYmvYnrx4gN69fLHw4dRADL7ZdIkZwwbVifbRajZZ+qF/aV+2GfqJau/lEXUkTMiUg3R0Ulwc9uGmJhkAICxsQ7WrGmF5s0rilwZEVHhw/usEBGKF9dHjx52AIBKlYrh2LFuDGZERCLhyBkRAQAmTGgAfX0t9OljjyJF9MQuh4io0OLIGVEh9OZNPI4dC5Fr09TUwKhRjgxmREQiYzgjKmRu3YpA8+bb0LfvIdy48VrscoiI6DMMZ0SFyM6dD+DtvRuRkQlITc3A1Kln8+TWbERE9P0454yoEEhPl2LatHNYt+4fWZujowU2bPDMdpkMIiISF8MZUQEXE5OEfv0O4cKFMFmbj08NzJzpAh0dTRErIyKinDCcERVgDx++Q8+eB/Hy5QcAgLa2BubMcZVdNoOIiFQPwxlRAXX8eAgGDDiCxMQ0AICZmQE2bfJEvXoWIldGRERfw3BGVECVKGGAjAwpAKBGjVLYvNkLFhbKu70IERHlDYYzogKqZs0yWLCgOc6de4GFC5tBX583LiciUgcMZ0QFxKtXcShTxgiamv9dIadzZxt06lSVZ2QSEakRXueMqAA4ffo5mjTZilmzLmZ7jsGMiEi9MJwRqTFBELBy5U1067YfHz6kYMWKmzhyJFjssoiI6AfwsCaRmkpKSsOoUSexb99jWZu7eyU0bFhOxKqIiOhHMZwRqaHw8I/w8TmIu3cjZW2jRzti7Nj60NDgYUwiInXGcEakZq5dC0fv3gGIikoEABgYaGP5cjd4elqLXBkRESkDwxmRGtm69R4mTDiNtLTM65dZWhbBli1esLEpIXJlRESkLAxnRGoiLS0Dfn73ZMGsYcNyWL++NUxN9UWujIiIlIlnaxKpCW1tTWze7AUzMwMMGFATu3a1ZzAjIiqAOHJGpMKkUkFugn/ZsiY4f74nzMwMRKyKiIjyEkfOiFTU338/hrv7dsTHp8q1M5gRERVsDGdEKiYjQ4rff7+AgQOP4M6dSPz661FIpYLYZRERUT7hYU0iFfLhQzIGDjyCU6eey9qKFtVDeroUOjqa4hVGRET5huGMSEX8+28Mevb0R0jIewCApqYEv//ugj597Hl/TCKiQoThjEgFnDjxDIMGHcHHj5nzy0xN9bB+fWs0bGgpcmVERJTfGM6IRCQIApYuvY7Zsy9B+P9pZTY2ZvDz84aVVRFxiyMiIlHwhAAiER069C/++OO/YObp+RMOHerCYEZEVIgxnBGJyMPjJ3h4VAYATJzohD//bA0jIx2RqyIiIjHxsCaRiDQ0JFi+3B29ekXAxcVK7HKIiEgFcOSMKJ8IgoANG/7B5cthcu1GRjoMZkREJMORM6J8kJKSjgkTTmPbtvswM9PH8eO/oFw5E7HLIiIiFcSRM6I8FhkZj7Zt92DbtvsAgKioJJw4ESJyVUREpKo4ckaUh27fjoCPz0G8eZMAANDT08TixS3Qvn1VkSsjIiJVxXBGlEd27XqIMWNOIiUlAwBgbm4EPz9v1KhRSuTKiIhIlTGcESlZeroU06efx9q1t2Vt9epZYMOG1ihZ0lDEyoiISB0wnBEpkSAI8PUNwLFj/80p69nTDn/80YQ3LiciIoXwhAAiJZJIJGjX7mcAgJaWBubNa4oFC5oxmBERkcI4ckakZG3aVMHLlx9Qt645HB3Lil0OERGpGY6cEf0AqVTA6dOh2dqHDavLYEZERN+F4YzoO8XHp6J374Po0mU/duy4L3Y5RERUQDCcEX2H0NBYtGq1A0ePZk78nzDhNN6+TRC5KiIiKgg454wol86de4F+/Q4hNjYFAGBioot161rxMhlERKQUDGdEChIEAWvX3sa0aechlQoAgJ9+MsWWLd6oVKmYyNUREVFBwXBGpIDk5HSMGROI3bsfytrc3Cpi1aqWMDbWFbEyIiIqaBjOiL7hzZt49Orlj3/+iZS1jRpVD+PGNYCGhkTEyoiIqCBiOCP6BokEiIiIBwAYGGhh2TJ3eHlZi1wVEREVVDxbk+gbSpUywubNXvjpJ1McOtSVwYyIiPIUR86IPpOWloGUlAwYGenI2mrWLIPz53tCU5N/zxARUd7iNw3RJ6KiEtGp0z7063cIGRlSuecYzIiIKD/w24bo/wUFvYWb23ZcuvQKp049x5w5l8UuiYiICiGGMyIA/v5P4Om5E2FhcQCAkiUN0aJFRZGrIiKiwohzzqhQy8iQYs6cy1i69LqsrWbN0ti0yRNlyhiLWBkRERVWDGdUaMXFpWDQoCM4eTJU1ta5sw3mz28GPT1+NIiISBz8BqJCKTg4Bj17+iM4+D0AQFNTgunTG6NfPwdIJLywLBERiYfhjAql1atvyYJZsWJ6WL++NRo1shS5KiIiIoYzKqR+/90Fd+9GIi0tA35+3ihfvqjYJREREQFgOKNCysBAG9u2tYGhoY7cxWaJiIjExktpUIH36lUc2rffi9DQWLn2UqWMGMyIiEjlMJxRgXblyiu0aLENFy68RK9e/oiPTxW7JCIioq9iOKMCSRAEbNp0F+3b70VUVBIAIDk5He/eJYpcGRER0ddxzhkVOKmpGZg48TS2bg2Stbm4WGHt2lYoVkxfxMqIiIi+jeGMCpS3bxPg6xuA69dfy9oGD66FyZMbQkuLA8VERKT6GM6owLhz5w18fA7i9et4AICuriYWLWqOjh1tRK6MiIhIcQxnVCBERsbD23s3kpLSAQDm5kbYvNkL9valRa6MiIgod3ichwqEUqWMMHRoHQBA3brmOH78FwYzIiJSSxw5owJj1ChHlChhiK5dbaGjoyl2OURERN+FI2eklp48ica+fY/k2jQ0JOjVy47BjIiI1BpHzkjtHD0ajMGDjyIlJQPm5saoX7+s2CUREREpDUfOSG1IpQIWLryKXr0OIiEhDenpUixefE3ssoiIiJSKI2ekFuLjUzFs2HEcOvSvrK1NmypYsqSFiFUREREpH8MZqbznz2PRq9dBPHoUBQCQSIDffnPG0KF1IJFIRK6OiIhIuRjOSKWdP/8S/fodwvv3yQAAY2MdrF3bCs2aVRS5MiIiorzBcEYqa8eO+xg16iQyMgQAQOXKxbBlizcqVzYVuTIiIqK8wxMCSGVVq1ZSdlmMZs0q4NixbgxmRERU4HHkjFRW9eolsXSpG+7ff4uJE52gqcm/JYiIqOAT9dsuPDwc/fv3R7169dCkSRPMnz8fUqk0x2V37NgBNzc3ODg4wNvbG4GBgflcLeW1Bw/eIT1dvv/btKmCyZMbMpgREVGhIeo33tChQ1GqVCkEBgZi06ZNCAwMhJ+fX7bljh8/joULF+KPP/7A9evX0b17d4wYMQJhYWEiVE15YdOmf9CixXZMm3ZO7FKIiIhEJVo4CwoKwuPHjzFmzBgYGxujfPny8PHxwa5du7Itm5ycjFGjRqFWrVrQ1tZGx44dYWhoiDt37uR/4aRUaWkZmDTpDHx9DyI1NQPr1v2DEyeeiV0WERGRaESbc/bgwQNYWFigSJEisjZbW1uEhoYiPj4eRkZGsnZvb2+5dePi4pCQkIBSpUp9cz+8DJbqio5OQt++h3Dx4n8joH362MPV1Yr9puKy+of9pB7YX+qHfaZelN1PooWz2NhYmJiYyLVlBbX379/LhbNPCYKAyZMno0aNGqhbt+5X96GpIYGZmbFyCialuncvEt7eO/H8eSwAQFtbA6tWeaBv35riFka5Urw4P1/qhP2lfthnhZOoZ2sKgpCr5dPS0jBhwgQEBwdjy5Yt31w+QyrgfdTH7y2P8sjBg08xdOgxJCamAwBKljTA/v1dUKVKUUSxv9SCRJL5pREd/RG5/BiTCNhf6od9pl6y+ktZRAtnpqamiI2NlWuLjY2FRCKBqWn2a1klJydj8ODBSEpKwrZt21CsWDGF9sMfatUhlQqYN+8yFi3672bl9val4OfnBTs7c0RF8ZeQuhEEfsbUCftL/bDPCifRTgioVq0aIiIiEBMTI2sLCgpC5cqVYWhoKLesIAgYOXIktLS0sHnzZoWDGamWtLQMnDv3Uva4Q4eq8PfvBHNzDtsTERFlES2c2djYoHr16li4cCHi4+MREhKCTZs2oWvXrgAAd3d33Lx5EwAQEBCA4OBgLF26FLq6umKVTD9IV1cLmzZ5wsLCGNOnN8bKle7Q19cWuywiIiKVIuqcs2XLlmHKlClwcnKCkZERunTpgm7dugEAQkNDkZiYCADYt28fwsPDs50A4O3tjZkzZ+Z73aS4lJR06Or+92NWurQRLl70gaEhQxkREVFOJEJuZ+Wri4USZBiYI6bDY7ErKZQEQcDKlTexc+cDHD7cBUWK6H1xWYkEMDMz5pwzNcI+Uy/sL/XDPlMvWf2lLLwnDildUlIaBg06ihkzLuDp0xgMHHgEGRk535aLiIiI5PHG56RUr17FwcfnIO7deytrq1mzDCS8kiIREZFCGM5Iaa5efQVf30OIisqcK2hgoI2VK93h4fGTyJURERGpD4YzUgo/v3uYOPE00tMzD19aWRXBli3eqFrVTOTKiIiI1AvDGf2Q1NQM/PbbGfj53ZO1NWpkifXrPVCsmL6IlREREaknnhBAP8Tf/4lcMBswoCZ27mzHYEZERPSdGM7oh3ToUBXt2lWBrq4mli1zw++/u0BLiz9WRERE34uHNemHSCQSLFrUAoMH14adXSmxyyEiIlJ7HOIghWVkSPH77xdw9uwLuXYDA20GMyIiIiVhOCOFxMYm45dfDmD58hvo3/8QQkNjxS6JiIioQGI4o296+jQa7u7bcfr0cwDAx4+p+OefN+IWRUREVEBxzhl91fHjIRg06Cji41MBAKametiwwRNOTuVEroyIiKhgYjijHAmCgKVLr2P27Euym+7a2JhhyxZvWFoWEbc4IiKiAozhjLJJSEjD8OHHcfDgU1mbl5c1li51g6GhtoiVERERFXwMZyRHEAR06fI3rl0LBwBIJMDEiU4YPrwub15ORESUD3hCAMmRSCQYNKgWAMDISAdbt7bBiBH1GMyIiIjyCUfOKJtWrSpjzhxXODuXg7V1cbHLISIiKlQ4clbIpaSkY8+eh9nafX3tGcyIiIhEwJGzQiwyMh4+PgG4dSsCCQlp8PGpIXZJREREhR5Hzgqp27cj0Lz5Nty6FQEA+P33C4iNTRa5KiIiImI4K4R27XoIb+/dePMmAQBgYWGM/fs7omhRPZErIyIiIh7WLETS06WYPv081q69LWtzdLTAhg2eKFHCQMTKiIiIKAvDWSERE5OEfv0O48KFl7K2Xr3sMGtWE+joaIpYGREREX2K4awQCA6OQdeu+/HixQcAgJaWBmbPdkWvXnYiV0ZERESfYzgrBIoU0UNGhhQAYGZmgI0bPeHoaCFyVURERJQTnhBQCJQoYQA/P2/Uq2eBkyd/YTAjIiJSYRw5K4Di41ORlpaBYsX0ZW3Vq5fEwYOdeBsmIiIiFceRswLm2bP3aNlyB/r2PYT0dKnccwxmREREqo/hrAA5c+Y53Ny248mTaFy4EIY5cy6JXRIRERHlEsNZASAIAlatuomuXffjw4cUAIC1tSm6dasmcmVERESUW5xzpuaSktIwenQg9u59JGtzc6uIVatawthYV8TKiIiI6HswnKmx168/wsfnIO7ciZS1jRpVD+PGNYCGBueXERERqSOGMzV17Vo4fH0D8O5dIgDAwEALy5e7w9PTWuTKiIiI6EcwnKmp3bsfyoKZpaUJ/Py8YWtbQuSqiIiI6EcxnKmpWbOa4OHDdzAw0Ma6da1RvLj+t1ciIiIilcdwpiakUkFuHpmenha2bWsLExNdaGnxpFsiIqKCgt/qaiAo6C1cXbfi339j5NpNTfUZzIiIiAoYfrOruAMHnqB16514+DAKPXv648OHZLFLIiIiojzEw5oqKiNDitmzL2HZshuytiJFdJGcnIEiRUQsjIiIiPIUw5kKiotLwcCBRxAYGCpr69zZBvPnN4OeHruMiIioIOM3vYoJDo5Bz57+CA5+DwDQ1JRg+vTG6NfPgTcuJyIiKgQYzlRIYOAzDBhwBB8/pgIAihXTw/r1rdGokaXIlREREVF+YThTES9ffkDPngeRni4FAFStagY/Py+UL19U3MKIiIgoX/FsTRVhaVkEEyY0AAC0bv0TDh/uwmBGRERUCHHkTIUMHVoHFSoURevWP3F+GRERUSHFkTORXLnyClu23JNrk0gk8PS0ZjAjIiIqxDhyls8EQcDmzffw229nIAgCrKyKoHFjK7HLIiIiIhXBkbN8lJqagTFjAjF+/Cmkp0uRkSFg+/b7YpdFREREKoQjZ/kkMjIBvr4BuHHjtaxt8OBamDy5oYhVERERkaphOMsHd+68Qa9eBxEREQ8A0NPTxKJFLdChQ1WRKyMiIiJVw3CWx3bvfojRo08iJSUDAGBubgQ/P2/UqFFK5MqIiIhIFTGc5aEVK25gxowLssd165pj40ZPlCxpKGJVREREpMp4QkAeatq0AgwMtAEAPXpUx99/d2QwIyIioq/iyFkeqlrVDCtXuuPdu0T4+NQQuxwiIiJSAwxnSnTx4kvUrWsBHR1NWZuHx08iVkRERETqhoc1lUAqFbBgwRW0a7cXv/12RuxyiIiIAACPHj1A27atEBMTLXYpKu3lyxfw9GyBsLCXYpcCgCNnPyw+PhVDhhzDkSPBAAA/v3vw8PgJLi686j8RkTJ16OCJd+/eQlPzv6MTpqbF0bhxE/TpMxAGBgay9sePH2HLlo24d+8fJCUloXhxM7i4uKJHD18YGxvLbff69avYtm0LHj9+AKlUgLm5OVq2bI1OnbpBQ+PLYxgnTx7Dvn27ERISDA0NCSwtrdCmTQd4eHgp/8V/h5SUZEydOglDh46CqWlxuecGDvTFo0cP8Pffh1G8uJmsPSLiNTp29MK2bXthZVVebp3Vq5fjwYMgrFixTtb28OF9bNmyEXfv3kFaWipKlCgJV9fm6NnTF7q6ukp5Henp6VizZgV27dqG+fOXwtGxwReXffMmAgsXzsGDB/ehr6+Ppk1bYODAIbJ+vHXrBtasWY4XL16gZMlS6NmzN1q0aAlLSyt0794L06b9hvXr/b7a7/mBI2c/4PnzWHh47JAFM4kEmDKlIRo3thS5MiKigmnkyLE4ffoyTp++jFOnLmHevCW4fv0qVqxYLFvmxo2rGDKkH2xsbLF9+z4EBl7EvHlLEBr6DIMG9UFiYoJs2YCAA/jtt3Fwc2sJf//jOHToJAYPHo7du3fgjz+mf7GO9etXY9myRejWrSeOHDmFAweOoUuX7li+fBE2bFibp++BogICDkBXVwdNmjSVaw8NfYbQ0BDUreuIo0cPfff2r169jKFDB8DOzgG7d/vj2LGzmDhxKi5ePIcxY4ZBEIQffQlISkrCoEF9EBf3QaHtTZo0FmZmJbF7tz+WLFmF8+fPYvfu7QCAqKgoTJgwCt7e7REQcALDh4/G3Lkz8fjxQwBAmzYd8PZtJC5cOPvDdf8ohrPvdO7cC7i5bcejR5lDxSYmuti+vS2GDq3DG5cTEeUDiUSCihUroXt3H5w/fxYAIJVKMX/+bLRr1wndu/vAxKQIJBIJypevgD/+WIDk5CRs2bIJAPDx40csW7YIAwcOQatWntDT04Ouri7q1auPmTPnwtDQEKmpqdn2+/LlC2zZshETJ05Fo0Yu0NbWlo3STJ48QxYiNmxYi/79feTW9fJyw5EjAQCAWbOmYc6c3zFkSH/06NEJU6dOzBYId+7chl9+6QAAiIv7gBkzpsDb2w3NmzfChAmj8O7d2y++PwcO7EPr1t7ZvpMOHfKHk1MjNG/uLqsltzIyMrBgQeb73K1bDxgbG0NLSwt2dvaYO3cxLCzK4sOHD9nWmzt3JlxdG+T4782biGzLJyUlwsPDC5Mm/e+bNT1+/BAhIf9i0KChMDIyQrlylujSpRsOHtwPADhx4ijKlbNE69be0NXVRZ069eDs3AgBAQcAALq6unB398CBA/u+6z1RJh7WzCVBELBu3T/43//OQSrN/AD+9JMptmzxRqVKxUSujojo++g83w/Du7MgSYvPt30K2kZIsJ+MVKs2P7SdtLQ02f8/ffoYr1+Ho2PHLtmW09bWRps27XHokD8GDhyC69evIiMjHV5ebbMta2NTDTY21XLc34ULZ1G6tDkaNHDO9pyzcyM4OzdSuPaLF89h4sT/oUEDZ5w9ewoLF85BRkYGtLQyD92eP38Wrq7NAWSGOU1NLWzdugeamhpYsGAO/vhjOhYvXpltu1FRUXj+PBS1atWRa09LS8Px40cwefJ01KjhgPnzZ+Pu3TuoUcNe4ZoB4MmTR3jzJgLt23fK9lzp0mUwYcKUHNcbP34yxo+frPB+TE2Lo02b9got+/jxI5QuXQYmJiayNmvrn/Hy5QskJibgyZNHsLb+WW4da+ufcerUSdljB4da2L9/D9LS0qCtra1wncrGcJYLycnpGDs2ELt2PZS1NW9eAatXt4KJiXKOrRMRicHgwVJofXgqyn6/N5xJpVKEhPyLbdv80KKFOwAgPPwV9PT0UKJEyRzXsbQsj4iI1xAEAa9fh6N06TK5/hJ+/Toc5copZ/pK6dLmcHLKvMdygwbO+OOPFNy7dwc1a9ZCdHQ0goLuYuzYSXj/PgaXLl3Atm17ZeFj4MAhaN++NaKjo+TmjQFAaGgIAKBChUpy7RcvnoOmpgbq1KkHTU1NNG7cBIcP++c6nL1+HQ5dXV2UKlX6O1+58sXFfYCxsYlcm4lJEQBAbGws4uI+oGTJUtme//AhVva4YsVKSE5OxuvX4dnm3OUnhrNc0NCQ4MWL/4ZpR4yoi/HjG0BTk0eHiUi9JVYbAcM7M/N95CzRdniu1lm8eD6WLVsEIPPQmr6+Pjp06AIfn76yZaRSKQRByHGKyafzliSSzGVzSyKRQCrNyPV6OSld+r9wo6urh/r1nXHhwlnUrFkLp0+fRsWKlVC+fAXcvx8EAOjdu5vc+pqamnj7NjJbOIuL+wBDQ0Noacl/zQcE+KNZMzfZSRVubq0wadIYjBgxVu6Eim+RSCQQBOGL77NYvjUv7VvPFylSFAAQG/ue4Uxd6OhoYsMGT7RtuxvjxjWAl5e12CURESlFqlWbHz68mB9GjhyLNm0y52Bdv34VEyeOhptbK1kIsbS0QmpqKl6/DoeFRdls6798+QLlyllBIpGgXDlLRES8RlJSEvT19RWuoWzZcrh06cJ3BZPPQ92nZ54CgKtrM6xcuQzDh4/GiRMnZIc0s8583L//iCxAfMvntb158wY3b17DnTu3ZPOwgMxJ96dPn0Dr1m1ko4jJycnZtpeQEA9dXT0AQNmylkhNTcWrV2GwtFT86gRz587E8eNHcnxu+/Z9KF26jMLb+lzRosUQFyc/z+3Dhw+QSCQoWrTYF56PRbFiprLHWe+ZMk5m+BEc8vmGDx/kf0BLlDDA2bM9GcyIiERWt64jnJ0bY+7cmbIv08qVrVGunCX27NmZbfn09HQEBOxH06aZgadOnXrQ09PDnj07si377FkwunfviI8fP2Z7rmFDF8TEROPkyePZnrt+/Sr69/dBeno6dHR0kZLy33dIfHx8jpPkP1W/vhNiY2MQFHQXV69eRdOmLQAAZcqYQ0NDAyEhwXKvJyrqXY7bMTEpgvj4eKSnp8vajhw5CCur8tiyZRc2bdou+9emTXscPnwQAFCsmCmMjU3w9Oljue0JgoCHD++jUqXMw6Q//WQNc3ML7NjxV7Z9R0dHoXv3jnj1Kizbc+PHT5adbfv5vx8JZgDw889VERn5BrGxsbK2x48foHz5CjAwMMDPP1fFkyeP5NZ5/PghbGxsZY9jY98DyAx6YmI4+4K0tAxMnHgazZptQ0xMktxzWlp824iIVMHw4aMRHPwv/P3/BpA58jFmzEQcPLgfq1cvR2xsLARBwIsXzzFixGAYGRmha9ceAAADA0MMGzYaGzasxdatm5CQEI/U1FRcuXIJY8YMR4MGDbNdEw0ALCzKolevPpg3byYCAg4gJSUZycnJOHnyGKZOnQh3dw9oaWmhXLlyePHiOZ49C0ZKSjLWr1/1zUOHurp6aNDAGatXr4C1tTXKls0c/TMyMkLTpi2wevUyvH0biZSUZKxZswIjRvya4yhP1lyz0NBnADIP3x45EgAPDy+ULVtO7l+7dp0QFHQPL148h6amJrp164k//1yNmzevIz09He/fx2DZskWIjo5Gt269AAAaGhoYO3Yijh07hGXLFuL9+/dIT0/H3bt3MGLEYFSqVBlly5b7zl5V3L59u/C//00EkDm5/+efbbBmzXIkJMTjxYvn2Llzu2yktUWLloiIiPj/PkvBlSsXceXKJXh5tZNtLzQ0BLq6ujmOuuYnHtbMQXR0Evr2DcClS68AAP36HcaePe2hoaE6x9WJiCjzbL6BA3/F6tXL4OTUECVKlEStWnWwatV6bNq0Ht26tUdycjJKlCiBJk2aoWfP3tDT05Ot7+HhheLFzfDXX5uxdetmSCRAuXJW6N9/MNzdPb64X1/f/rCwKIu9e3dh2bKF0NLSRqVKlTF16u+yszidnRvDxaUpBg7sA0NDQ/TvPxh37tz+5mtq0qQZJk8ej/Hjx8u1jxw5FosWzUOPHp0gkWigWrXqmDNnYY6HVs3MzFC+fAXcvn0DP/1kjZs3ryMq6h3c3LK/pooVK6FqVVscPuyPwYOHo0cPH5QoUQKrVi3Dq1dhMDAwgI1NNSxbtgZFixaVrVenjiNWrFiPzZvXo2vXdsjISEeZMubw9GyLDh06f/N1KuLYscOYN2+W7PGECaOgoaEBN7dWGD9+MmJjYxER8d8lOGbOnIt582bBy8sNhoZG8PZuh3btOgLIHBWcN28xlixZgEWL5qJ06TKYOvV3VK78320W//nnFuzs7EU9UxMAJILYB1bzykIJMgzMEdPh8beX/cT9++/g4+OPly/jAADa2hqYN68pfvmlel5USciclGtmZoyoqI8ooD+NBQ77TL2wv9SPMvps796d8Pf/G1u37lZucQVUamoqOnTwxOjR49G4sWuu1s3qL2Xh8blPHDz4FK1b75AFs5IlDXHgQCcGMyIiUjuenm2QnJyCs2dPiV2KWjhwYB/MzEqgYUMXsUthOAMyb1w+e/Yl9O17CImJmZMnHRxK4eTJbqhTx1zk6oiIiHJPV1cPM2b8gaVLF/LG598QFvYSW7duwvTpf4h+X02Ac84QF5eCwYOP4sSJZ7K2Tp1ssGBBM+jpFfq3h4iI1FjVqrbYvz/nS1fQf8qVs0RAwAmxy5Ap9Onj8OF/ZcFMQ0OC6dMbo39/B5W6qB4REREVHoU+nHXpYosrV8Jx7Fgw1q9vjcaNFb+YHhEREZGyFfpwJpFIMG9eU4we7QgrqyJil0NERESFnPiz3vJRYmIaBg8+isDAZ3LtenpaDGZERESkEgpNOHv1Kg6enruwd+8jDBhwBMHBMWKXRERERJRNoQhnV6++QosW2xAU9BZA5qUzsq5lRkRERKRKCvycs82b72LSpDNIT5cCAKysimDLFm9UrWomcmVERERE2Yk6chYeHo7+/fujXr16aNKkCebPnw+pVJrjslu2bIGbmxtq1qyJrl274v79+1/ddmq6JgZvd8a4cadkwaxxYyucONGNwYyIiIhUlqjhbOjQoShVqhQCAwOxadMmBAYGws/PL9typ0+fxvLlyzFv3jxcvnwZTZo0wcCBA5GYmPjFbTdd2xPrLtrIHg8cWAs7drRFsWL6efJaiIiIiJRBtHAWFBSEx48fY8yYMTA2Nkb58uXh4+ODXbt2ZVt2165daNeuHWrUqAE9PT307dsXAHDmzJkvbv9iaOb1ynR1NbF8uTtmzGgMLa1CMcWOiIiI1Jhoc84ePHgACwsLFCny3yUsbG1tERoaivj4eBgZGckt26pVK9ljDQ0NVK1aFUFBQfDw8Mhx+xKJgDImidi8px8cHErn3QuhH5Z1MwbelEF9sM/UC/tL/bDP1Iuy+0m0cBYbGwsTExO5tqyg9v79e7lwFhsbKxfispZ9//79F7cvlU5TXrGUL4oXNxa7BMol9pl6YX+pH/ZZ4STqcT5BEPJkWSIiIiJ1JVo4MzU1RWxsrFxbbGwsJBIJTE1N5dqLFSuW47KfL0dERESk7kQLZ9WqVUNERARiYv67Un9QUBAqV64MQ0PDbMs+ePBA9jgjIwMPHz5EjRo18q1eIiIiovwgWjizsbFB9erVsXDhQsTHxyMkJASbNm1C165dAQDu7u64efMmAKBr1644cOAA7ty5g6SkJKxevRo6OjpwcXERq3wiIiKiPCHqHQKWLVuGKVOmwMnJCUZGRujSpQu6desGAAgNDZVdx6xRo0YYNWoURowYgejoaFSvXh3r1q2Dnp6emOUTERERKZ1EUNOZ9uHh4Zg+fTru3r0LAwMDtGrVCqNHj4aGRvbBwC1btmDbtm149+4dqlSpgt9++w3VqlUToerCKzf9tWPHDmzevBlv376FpaUlhg4dimbNmolQdeGWmz7LEhkZCXd3d/j6+mLo0KH5WC3lpr9CQkIwbdo03Lt3D0WLFkXv3r3h4+OT/0UXcor2mVQqxYoVK3DgwAG8f/8eZcuWxaBBg+QuMUX548KFCxg/fjzq1auHxYsXf3E5qVSKpUuX4tChQ4iLi4OdnR2mTZuGcuXKKbYjQU21bdtWmDx5shAXFyeEhoYKLVq0EDZu3JhtuVOnTgm1a9cW7ty5IyQlJQlr164VnJychISEBBGqLrwU7a9jx44JtWrVEm7evCmkpqYKu3fvFmxtbYWXL1+KUHXhpmiffWrIkCFCrVq1hGXLluVTlZRF0f5KSkoSXFxchPXr1wuJiYnC3bt3BQ8PDyE4OFiEqgs3Rfvsr7/+EpydnYWQkBAhPT1dOH36tGBjYyM8evRIhKoLr3Xr1gktWrQQunTpIowYMeKry27ZskVo0qSJEBwcLHz8+FGYMWOG4OnpKUilUoX2pZaXzM/ruwuQcuWmv5KTkzFq1CjUqlUL2tra6NixIwwNDXHnzp38L7wQy02fZTl37hyCg4M5F1QEuemvo0ePwsjICH379oW+vj7s7Oxw6NAhVKpUSYTKC6/c9NmDBw9Qq1YtVKxYEZqammjSpAmKFi2KJ0+eiFB54aWrq4u9e/fCysrqm8vu2rULPj4+qFSpEoyMjDBy5EiEhITg7t27Cu1LLcPZt+4u8PmyNjb/3WPz07sLUP7ITX95e3vL5h0CQFxcHBISElCqVKl8q5dy12dAZqieMWMG/ve//0FLS9SprIVSbvrr1q1bsLa2xsSJE1G7dm24u7vj4MGD+V1yoZebPnNxccH169fx6NEjpKam4tSpU0hKSkLdunXzu+xCrWfPnjA2/vZFgZOTkxEcHCyXPYyMjGBlZaVw9lDLcPatuwt8vmxu7y5AypWb/vqUIAiYPHkyatSowV9C+Sy3fbZy5UrY29vD0dExX+ojebnprzdv3uDUqVNo0KABLly4gAEDBmD8+PF4+PBhvtVLueuzFi1aoHPnzmjTpg2qV6+O0aNHY/bs2ShTpky+1UuK+/DhAwRB+KHsobZ/4gq8u4BayW0fpKWlYcKECQgODsaWLVvyqCr6GkX7LDg4GHv27EFAQEAeV0Rfo2h/CYIAW1tbeHp6AgDatm2LnTt34tixY3J/6VPeU7TPDhw4gAMHDmDPnj2oUqUKrly5gtGjR6NMmTKws7PL4yrpe/1I9lDLkTPeXUC95Ka/gMwh4QEDBuD169fYtm0bzMzM8qlSyqJonwmCgGnTpmHo0KEoUaJEPldJWXLzGStRokS2QzMWFhZ49+5dXpdJn8hNn/3111/o3Lkz7OzsoKurCxcXFzg6OvJwtIoqWrQoNDQ0cuzf4sWLK7QNtQxnvLuAeslNfwmCgJEjR0JLSwubN29GsWLF8rtcguJ99vr1a9y4cQPLli1DvXr1UK9ePRw+fBh//vkn2rZtK0bphVJuPmOVKlXC06dP5f6qDw8Ph4WFRb7VS7nrM6lUioyMDLm21NTUfKmTck9XVxc//fSTXPaIi4vDy5cvFR7pVMtwxrsLqJfc9FdAQACCg4OxdOlS6Orqill2oaZon5UuXRrnzp2Dv7+/7J+rqyu6dOmCdevWifwqCo/cfMa8vLzw/v17rFmzBsnJyTh06BAePHgALy8vMV9CoZObPnN1dcXevXvx+PFjpKen4+LFi7hy5QqaNm0q5kugT2Rd4zEsLAxAZvbYsmULQkJCEB8fjwULFqBq1aqoXr26QttT2zlnvLuAelG0v/bt24fw8PBsJwB4e3tj5syZ+V53YaZIn2lqaqJ06dJy6+nr68PIyIiHOfOZop+xUqVKYe3atZg1axZWrVoFc3NzrFy5EpaWlmKWXygp2mcDBgxAeno6fv31V8TExMDCwgIzZ85E/fr1xSy/0MkKVunp6QCAwMBAAJkjnmlpaQgNDZWNaHbp0gXv3r1Djx49kJCQgHr16mHFihUK70tt7xBAREREVBCp5WFNIiIiooKK4YyIiIhIhTCcEREREakQhjMiIiIiFcJwRkRERKRCGM6IiIiIVAjDGREREZEKYTgjIiIiUiEMZ0SU51xdXbFjxw6xy8iVAwcOwNXVNdfPERH9KN4hgIi+ydXVFZGRkdDQkP97rnTp0jh58qRC6/fr109230BlqVKlCrS1tSGRSAAABgYGqFatGsaOHYuff/5Zqfvau3cvXF1dYWpqqtTtfurvv//GxIkToaOjI2vT0dGBtbU1hg0bpvDteh48eIAPHz6gQYMGeVUqEeUhtb23JhHlr8mTJys9XCnDqlWr0KhRIwDAx48fsWLFCvTp0wfHjh2DsbGxUvaRkZGBOXPmwMHBIU/DGQCYmZnh0qVLssdJSUn466+/MHDgQAQEBCh0D8x9+/bBwMCA4YxITfGwJhH9MEEQsGDBAjRu3BgODg5o27Ytbty4keOyd+/eRadOneDg4IB69erht99+Q3JyMgAgOTkZM2bMgIuLC+zt7dGjRw8EBwcrXIexsTHGjRuHuLg43L59GwDw4cMHjBs3Ds7OznBwcED//v3x6tUrAIBUKsWcOXPg7OwMe3t7eHl54cKFCwAyR7GcnJwAAHXr1sXHjx/h7e2NFStWyJ6TSqVwdnbG/v375eoYNGgQpk6dCgB4/PgxevXqhdq1a8PR0REzZ85EWlqawq9JX18f/fr1Q8mSJWW1fe39/v3337F9+3Zs3LgRzZs3BwDExsZizJgxsvdg0KBBiIyMVLgGIspfDGdE9MP8/f1x4MAB7Nq1Czdv3kTTpk0xbNgwZGRkZFt23Lhx6NixI27duoWAgAA8efIEu3btAgAsWLAADx8+xK5du3D16lVUr14dQ4YMQW5mX0ilUgiCIDsEO3nyZLx79w4HDx7EhQsXoKenhxEjRgAADh8+jMuXL+PgwYO4desWevXqhfHjx2cLT/7+/rL/DhkyRNauoaGBFi1aIDAwUNaWmJiIS5cuwcPDA0lJSejbty8aNGiAy5cvY8+ePbh27Ro2bNig8OvJkp6eLlfPl97vKVOmoE6dOvD19ZUdcp4wYQKSk5Nx+PBhXLhwAQYGBpg4cWKuayCi/MFwRkQ/zNPTE0ePHkXp0qWhqakJDw8PxMTE4PXr19mWjYuLg4GBATQ0NFCyZEns3r0bvXr1glQqxd9//43BgwejVKlSshD1+vVr3Lt3T6E64uLiMH/+fBQvXhwODg6IjY3FyZMnMWLECJiamsLIyAjDhg1DUFAQwsLCEBcXBy0tLejr60NTUxPt27fHxYsXoa2trfBrb9myJS5duiQb/btw4QJMTExQp04dnD17FoIgYMCAAdDR0UG5cuXQp08fWdhTRHx8PFauXInY2Fg0a9YMQO7e7+joaJw5cwYjR45EkSJFYGRkhDFjxuDSpUt49+6dwnUQUf7hnDMiUsjMmTPxxx9/yLU5Ojpi/fr1SEpKwh9//IHz58/jw4cPsudTU1OzbWfUqFGYNGkSNmzYAGdnZ3h7e6NSpUqIjo5GQkICBg8eLJvgD2SOhEVERKBGjRo51vXp8kZGRqhRowY2btwIIyMjPHz4EIIgoFKlSrLls+ZshYeHw8PDA/7+/mjUqBGcnJzg4uICDw+PbCc+fE2tWrVgZGSEixcvolmzZjh58iTc3d2hoaGBsLAwREdHo3r16rLlBUGQm/D/uaioKLnlU1NTUbduXWzevBmlSpUCgFy932FhYQCANm3ayLVramoiIiICJUqUUPi1ElH+YDgjIoV87YSA6dOn48mTJ9i2bRusrKwQFhYmm+/0uY4dO6JZs2Y4ffo0Tp06hTZt2mDx4sWoV68eAGDnzp2oVq2awnV9ekLA53IKK1kkEgmKFi2K3bt34/bt2zhz5gyWLVuGHTt2YNu2bQrvX0NDA25ubjh16hQaN26Ms2fPYt26dQAAXV1d/PTTTwgICFB4e5+eECAIArp27QpLS0u5cJqb91tPTw8AcP78eRQrVkzhOohIPDysSUQ/7N69e/Dy8kL58uUhkUjw4MGDLy77/v17FCtWDO3bt8eqVaswYMAA7N27F8bGxihatCiePHkit3zW5P3vUa5cOQDAs2fPZG1Z/29paYmUlBQkJSWhZs2aGD16NA4dOoSnT5/i8ePHudqPu7s7zp49i8uXL8PY2BgODg6yfYSFhSEhIUG27Pv37xEfH6/QdiUSCWbMmAF/f39cuXJF1p6b99vCwgIaGhpy72taWhpPCCBSYQxnRPTDypYti6CgIKSmpuLOnTs4fPgwAODt27dyy7158waurq64ePEipFIpPn78iKdPn8oONXbp0gWrV69GSEgI0tLSsHnzZnTo0AFJSUnfVVfx4sXh7OyMpUuXIjY2Fh8+fMCSJUtQr149lClTBrNmzcL48eMRExMDQRDw4MEDSKVSmJuby20na/Tp+fPnOQarWrVqQVNTE+vWrYO7u7vsMKuzszNMTU0xd+5cxMfH4927dxg+fDgWLFig8GuwtrZG7969MXXqVNn78K33W1dXF69evcKHDx9gbGyMVq1aYcGCBXjz5g2Sk5OxaNEi+Pr65upECyLKPwxnRPTDRo8ejZCQENStWxeLFy/GlClT0Lx5cwwePFhuVKd06dKYNWsWZs2aBQcHB7i7u8PQ0BDDhg0DkDl/rGHDhujWrRvq1auHkydPYv369dDX1//u2ubOnQsDAwO0bNkSrVq1gpGREZYuXSqrO+uwZM2aNTFr1iwsXLgw27XMzMzM4ObmhuHDh2PJkiXZ9pG1jZs3b8LDw0PWrq2tjVWrVuHZs2dwcnJCmzZtUL58eYwfPz5Xr+HXX3+FVCqVq/tr73e7du1w/vx5tGjRQnYGp5WVFTw8PNCwYUMEBwdj1apVcnP7iEh18A4BRERERCqEI2dEREREKoThjIiIiEiFMJwRERERqRCGMyIiIiIVwnBGREREpEIYzoiIiIhUCMMZERERkQphOCMiIiJSIQxnRERERCqE4YyIiIhIhTCcEREREamQ/wMDSddpXNMrrgAAAABJRU5ErkJggg==\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示 ROC 曲线。\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 700x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示精确率-召回率曲线。\n","--------------------------------------------------\n","\n","------- 特征重要性可视化 -------\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x700 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["已显示前 15 个重要特征的条形图。\n","--------------------------------------------------\n"]}]}]}