logistic_regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tabular Data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import itertools\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import polars as pl\n",
    "\n",
    "\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "from imblearn.under_sampling import RandomUnderSampler\n",
    "from imblearn.pipeline import Pipeline\n",
    "\n",
    "from sklearn.metrics import roc_auc_score\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read Data and Feature Engineering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/dengwenxi/Desktop/Statistical Machine Learning/Assignment/assignment3/Project\n"
     ]
    }
   ],
   "source": [
    "root = os.getcwd()\n",
    "data_root = \"\"\n",
    "print(root)\n",
    "if root.startswith(\"/kaggle\"):\n",
    "    print(\"True\")\n",
    "    # Running on kaggle notebook\n",
    "    data_root  = \"/kaggle/input/isic-2024-challenge/\"\n",
    "else:\n",
    "    data_root = \"isic-2024-challenge/\"\n",
    "\n",
    "train_path = data_root + 'train-metadata.csv'\n",
    "test_path = data_root + 'test-metadata.csv'\n",
    "subm_path = data_root + 'sample_submission.csv'\n",
    "\n",
    "# inspiration from https://www.kaggle.com/code/greysky/isic-2024-only-tabular-data/notebook \n",
    "id_col = 'isic_id'\n",
    "target_col = 'target'\n",
    "group_col = 'patient_id'\n",
    "\n",
    "err = 1e-5\n",
    "seed = 42\n",
    "\n",
    "num_cols = [\n",
    "    'age_approx',                        # Approximate age of patient at time of imaging.\n",
    "    'clin_size_long_diam_mm',            # Maximum diameter of the lesion (mm).+\n",
    "    'tbp_lv_A',                          # A inside  lesion.+\n",
    "    'tbp_lv_Aext',                       # A outside lesion.+\n",
    "    'tbp_lv_B',                          # B inside  lesion.+\n",
    "    'tbp_lv_Bext',                       # B outside lesion.+ \n",
    "    'tbp_lv_C',                          # Chroma inside  lesion.+\n",
    "    'tbp_lv_Cext',                       # Chroma outside lesion.+\n",
    "    'tbp_lv_H',                          # Hue inside the lesion; calculated as the angle of A* and B* in LAB* color space. Typical values range from 25 (red) to 75 (brown).+\n",
    "    'tbp_lv_Hext',                       # Hue outside lesion.+\n",
    "    'tbp_lv_L',                          # L inside lesion.+\n",
    "    'tbp_lv_Lext',                       # L outside lesion.+\n",
    "    'tbp_lv_areaMM2',                    # Area of lesion (mm^2).+\n",
    "    'tbp_lv_area_perim_ratio',           # Border jaggedness, the ratio between lesions perimeter and area. Circular lesions will have low values; irregular shaped lesions will have higher values. Values range 0-10.+\n",
    "    'tbp_lv_color_std_mean',             # Color irregularity, calculated as the variance of colors within the lesion's boundary.\n",
    "    'tbp_lv_deltaA',                     # Average A contrast (inside vs. outside lesion).+\n",
    "    'tbp_lv_deltaB',                     # Average B contrast (inside vs. outside lesion).+\n",
    "    'tbp_lv_deltaL',                     # Average L contrast (inside vs. outside lesion).+\n",
    "    'tbp_lv_deltaLB',                    #\n",
    "    'tbp_lv_deltaLBnorm',                # Contrast between the lesion and its immediate surrounding skin. Low contrast lesions tend to be faintly visible such as freckles; high contrast lesions tend to be those with darker pigment. Calculated as the average delta LB of the lesion relative to its immediate background in LAB* color space. Typical values range from 5.5 to 25.+\n",
    "    'tbp_lv_eccentricity',               # Eccentricity.+\n",
    "    'tbp_lv_minorAxisMM',                # Smallest lesion diameter (mm).+\n",
    "    'tbp_lv_nevi_confidence',            # Nevus confidence score (0-100 scale) is a convolutional neural network classifier estimated probability that the lesion is a nevus. The neural network was trained on approximately 57,000 lesions that were classified and labeled by a dermatologist.+,++\n",
    "    'tbp_lv_norm_border',                # Border irregularity (0-10 scale); the normalized average of border jaggedness and asymmetry.+\n",
    "    'tbp_lv_norm_color',                 # Color variation (0-10 scale); the normalized average of color asymmetry and color irregularity.+\n",
    "    'tbp_lv_perimeterMM',                # Perimeter of lesion (mm).+\n",
    "    'tbp_lv_radial_color_std_max',       # Color asymmetry, a measure of asymmetry of the spatial distribution of color within the lesion. This score is calculated by looking at the average standard deviation in LAB* color space within concentric rings originating from the lesion center. Values range 0-10.+\n",
    "    'tbp_lv_stdL',                       # Standard deviation of L inside  lesion.+\n",
    "    'tbp_lv_stdLExt',                    # Standard deviation of L outside lesion.+\n",
    "    'tbp_lv_symm_2axis',                 # Border asymmetry; a measure of asymmetry of the lesion's contour about an axis perpendicular to the lesion's most symmetric axis. Lesions with two axes of symmetry will therefore have low scores (more symmetric), while lesions with only one or zero axes of symmetry will have higher scores (less symmetric). This score is calculated by comparing opposite halves of the lesion contour over many degrees of rotation. The angle where the halves are most similar identifies the principal axis of symmetry, while the second axis of symmetry is perpendicular to the principal axis. Border asymmetry is reported as the asymmetry value about this second axis. Values range 0-10.+\n",
    "    'tbp_lv_symm_2axis_angle',           # Lesion border asymmetry angle.+\n",
    "    'tbp_lv_x',                          # X-coordinate of the lesion on 3D TBP.+\n",
    "    'tbp_lv_y',                          # Y-coordinate of the lesion on 3D TBP.+\n",
    "    'tbp_lv_z',                          # Z-coordinate of the lesion on 3D TBP.+\n",
    "]\n",
    "\n",
    "new_num_cols = []\n",
    "# categorical features\n",
    "cat_cols = ['sex', 'anatom_site_general', 'tbp_tile_type', 'tbp_lv_location', 'tbp_lv_location_simple', 'attribution']\n",
    "# normalisation for categorical features\n",
    "norm_cols = [f'{col}_patient_norm' for col in num_cols]\n",
    "# # special columns\n",
    "special_cols = ['count_per_patient'] + [f'{col}_count' for col in cat_cols] + [(f'{num_col}_{cat_col}') for num_col, cat_col in itertools.product(num_cols, cat_cols)]\n",
    "# combine all features\n",
    "feature_cols = num_cols + cat_cols + norm_cols + special_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_data(path):\n",
    "    return (\n",
    "        pl.read_csv(path)\n",
    "        .with_columns(\n",
    "            pl.col('age_approx').cast(pl.String).replace('NA', np.nan).cast(pl.Float64),\n",
    "        )\n",
    "        .with_columns(\n",
    "            pl.col(pl.Float64).fill_nan(pl.col(pl.Float64).mean()), # You may want to impute test data with train\n",
    "        )\n",
    "        .with_columns(\n",
    "            # Standardisation\n",
    "            ((pl.col(col) - pl.col(col).mean().over('patient_id')) / (pl.col(col).std().over('patient_id') + err)).alias(f'{col}_patient_norm') for col in (num_cols + new_num_cols)\n",
    "        )\n",
    "        # Feature engineering\n",
    "        .with_columns(\n",
    "            # Generates all interaction features between numerical and categorical features\n",
    "            ((pl.col(num_col) - pl.col(num_col).mean().over('patient_id', cat_col)) / (pl.col(num_col).std().over('patient_id', cat_col) + err)).alias(f'{num_col}_{cat_col}') for num_col, cat_col in itertools.product(num_cols, cat_cols)\n",
    "        )\n",
    "        .with_columns(\n",
    "            # Calculate the number of occurrences of each categorical feature per patient\n",
    "            pl.col(col).count().over('patient_id', col).alias(f'{col}_count') for col in cat_cols\n",
    "        )\n",
    "        .with_columns(\n",
    "            # Calculate the number of samples per patient\n",
    "            count_per_patient = pl.col('isic_id').count().over('patient_id'),\n",
    "        )\n",
    "        .with_columns(\n",
    "            pl.col(cat_cols).cast(pl.Categorical),\n",
    "        )\n",
    "        .to_pandas()\n",
    "        .set_index(id_col)\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Preprocessing and Analysis\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def analyse_missing_values(df_train, df_test):\n",
    "    # Find the number of columns with missing values in df_train and df_test \n",
    "    missing_train = df_train.isnull().sum()\n",
    "    missing_test = df_test.isnull().sum()\n",
    "\n",
    "    # Find out the columns with missing values\n",
    "    missing_train = missing_train[missing_train > 0]\n",
    "    missing_test = missing_test[missing_test > 0]\n",
    "    \n",
    "    print(\"Number of columns with missing values in df_train: \", len(missing_train))\n",
    "\n",
    "    print(\"\\nNumber of columns with missing values in df_test: \", len(missing_test))\n",
    "\n",
    "    # find out the common columns with missing values in df_train and df_test\n",
    "    common_missing = set(missing_train.index).intersection(set(missing_test.index))\n",
    "    print(\"\\nNumber of common columns with missing values in both df_train and df_test: \", len(common_missing))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess(df_train, df_test):\n",
    "    global cat_cols\n",
    "\n",
    "    # drop the columns that in df_train but not in df_test\n",
    "    columns_to_drop = [col for col in df_train.columns if col not in df_test.columns and col != 'target']\n",
    "    df_train = df_train.drop(columns=columns_to_drop)\n",
    "    \n",
    "    # Handling missing values for numerical features\n",
    "    for col in num_cols + norm_cols + special_cols:\n",
    "        if col in df_train.columns:\n",
    "            mean_value = df_train[col].mean() \n",
    "            df_train[col].fillna(mean_value, inplace=True)\n",
    "            df_test[col].fillna(mean_value, inplace=True)\n",
    "    \n",
    "    # One-hot encode categorical features\n",
    "    encoder = OneHotEncoder(sparse_output=False, dtype=np.int32, handle_unknown='ignore')\n",
    "    encoder.fit(df_train[cat_cols])\n",
    "    \n",
    "    new_cat_cols = [f'onehot_{i}' for i in range(len(encoder.get_feature_names_out()))]\n",
    "\n",
    "    df_train[new_cat_cols] = encoder.transform(df_train[cat_cols])\n",
    "    df_train[new_cat_cols] = df_train[new_cat_cols].astype('category')\n",
    "\n",
    "    df_test[new_cat_cols] = encoder.transform(df_test[cat_cols])\n",
    "    df_test[new_cat_cols] = df_test[new_cat_cols].astype('category')\n",
    "\n",
    "    for col in cat_cols:\n",
    "        feature_cols.remove(col)\n",
    "\n",
    "    feature_cols.extend(new_cat_cols)\n",
    "    cat_cols = new_cat_cols\n",
    "\n",
    "    return df_train, df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(401059, 299) (3, 288)\n",
      "Number of columns with missing values in df_train:  239\n",
      "\n",
      "Number of columns with missing values in df_test:  238\n",
      "\n",
      "Number of common columns with missing values in both df_train and df_test:  238\n"
     ]
    }
   ],
   "source": [
    "df_train = read_data(train_path)\n",
    "df_test = read_data(test_path)\n",
    "df_subm = pd.read_csv(subm_path, index_col=id_col)\n",
    "print(df_train.shape, df_test.shape)\n",
    "analyse_missing_values(df_train, df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(401059, 336) (3, 335)\n",
      "Number of columns with missing values in df_train:  0\n",
      "\n",
      "Number of columns with missing values in df_test:  0\n",
      "\n",
      "Number of common columns with missing values in both df_train and df_test:  0\n"
     ]
    }
   ],
   "source": [
    "# Preprocess the data\n",
    "df_train, df_test = preprocess(df_train, df_test)\n",
    "\n",
    "# Ensure that the columns are the same in both df_train and df_test after preprocessing\n",
    "print(df_train.shape, df_test.shape)\n",
    "\n",
    "# Ensure that there is no missing value in df_train and df_test after preprocessing\n",
    "analyse_missing_values(df_train, df_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# partial area under the ROC curve (pAUC) above 80% true positive rate (TPR)\n",
    "# inspiration from https://www.kaggle.com/code/greysky/isic-2024-only-tabular-data/notebook \n",
    "def pAUC(estimator, X, y_true):\n",
    "    y_hat = estimator.predict_proba(X)[:, 1]\n",
    "    min_tpr = 0.80\n",
    "    max_fpr = abs(1 - min_tpr)\n",
    "    \n",
    "    v_gt = abs(y_true - 1)\n",
    "    v_pred = np.array([1.0 - x for x in y_hat])\n",
    "    \n",
    "    partial_auc_scaled = roc_auc_score(v_gt, v_pred, max_fpr=max_fpr)\n",
    "    partial_auc = 0.5 * max_fpr**2 + (max_fpr - 0.5 * max_fpr**2) / (1.0 - 0.5) * (partial_auc_scaled - 0.5)\n",
    "    \n",
    "    return partial_auc\n",
    "\n",
    "def calculate_pAUC(estimator, X_test, y_test, scoring=None):\n",
    "    if scoring:\n",
    "        return scoring(estimator, X_test, y_test)\n",
    "    else:\n",
    "        return estimator.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Recall = TP / (TP + FN)\n",
    "# Recall represents the proportion of actual diseased cases correctly identified by the model\n",
    "def calculate_recall(y_true, y_pred):\n",
    "    tp = np.sum((y_true == 1) & (y_pred == 1))\n",
    "    fn = np.sum((y_true == 1) & (y_pred == 0))\n",
    "    recall = tp / (tp + fn)\n",
    "    return recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_precision(y_true, y_pred):\n",
    "    tp = np.sum((y_true == 1) & (y_pred == 1))\n",
    "    fp = np.sum((y_true == 0) & (y_pred == 1))\n",
    "    precision = tp / (tp + fp) if (tp + fp) > 0 else 0\n",
    "    return precision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tune Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pAUC_scorer = make_scorer(pAUC, needs_proba=True)\n",
    "\n",
    "# # Define the parameter grid\n",
    "# param_grid = {\n",
    "#     'logreg1__classifier__C': [0.01, 0.001, 0.0001],\n",
    "#     'logreg1__classifier__solver': ['saga', 'liblinear'],\n",
    "#     'logreg1__classifier__max_iter': [1000, 1500, 2000],\n",
    "#     'logreg1__sampler__sampling_strategy': [0.01, 0.1]\n",
    "# }\n",
    "\n",
    "# # Create a pipeline with scaling and logistic regression\n",
    "# pipeline = Pipeline([\n",
    "#     ('sampler', RandomUnderSampler(random_state=12)),\n",
    "#     ('scaler', StandardScaler()),\n",
    "#     ('classifier', LogisticRegression(class_weight='balanced', random_state=12))\n",
    "# ])\n",
    "\n",
    "# # Create a VotingClassifier with the pipeline\n",
    "# estimator = VotingClassifier([\n",
    "#     ('logreg1', pipeline),\n",
    "#     ('logreg2', pipeline),\n",
    "#     ('logreg3', pipeline),\n",
    "#     ('logreg4', pipeline)\n",
    "# ], voting='soft')\n",
    "\n",
    "# # Initialize GridSearchCV\n",
    "# grid_search = GridSearchCV(estimator=estimator, param_grid=param_grid, cv=2, scoring=pAUC_scorer, n_jobs=-1)\n",
    "\n",
    "# X = df_train[feature_cols]\n",
    "# y = df_train[target_col]\n",
    "# # Fit the model\n",
    "# grid_search.fit(X, y)\n",
    "\n",
    "# # Print the best parameters and score\n",
    "# print(\"Best parameters:\", grid_search.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Best parameters\n",
    "C = 0.001\n",
    "sampling_ratio = 0.01\n",
    "max_iter = 1000\n",
    "solver = 'saga'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deine the model with best parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Logistic Regression parameters\n",
    "log_reg_params = {\n",
    "    'C': C, \n",
    "    'solver': solver,  \n",
    "    'max_iter': max_iter,\n",
    "    'class_weight': 'balanced' \n",
    "}\n",
    "\n",
    "# Create a pipeline with scaling and logistic regression\n",
    "estimator = VotingClassifier([\n",
    "    ('logreg1', Pipeline([\n",
    "        ('sampler', RandomUnderSampler(sampling_strategy=sampling_ratio, random_state=12)),\n",
    "        ('scaler', StandardScaler()),\n",
    "        ('classifier', LogisticRegression(**log_reg_params, random_state=12))\n",
    "    ])),\n",
    "    ('logreg2', Pipeline([\n",
    "        ('sampler', RandomUnderSampler(sampling_strategy=sampling_ratio, random_state=22)),\n",
    "        ('scaler', StandardScaler()),\n",
    "        ('classifier', LogisticRegression(**log_reg_params, random_state=22))\n",
    "    ])),\n",
    "    ('logreg3', Pipeline([\n",
    "        ('sampler', RandomUnderSampler(sampling_strategy=sampling_ratio, random_state=32)),\n",
    "        ('scaler', StandardScaler()),\n",
    "        ('classifier', LogisticRegression(**log_reg_params, random_state=32))\n",
    "    ])),\n",
    "    ('logreg4', Pipeline([\n",
    "        ('sampler', RandomUnderSampler(sampling_strategy=sampling_ratio, random_state=42)),\n",
    "        ('scaler', StandardScaler()),\n",
    "        ('classifier', LogisticRegression(**log_reg_params, random_state=42))\n",
    "    ])),\n",
    "], voting='soft')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stratified K-Fold Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stratified_k_fold_validation(X, y, estimator, k, n_repeats, scoring=None):\n",
    "    scores = []\n",
    "    recalls = []\n",
    "    precisions = []\n",
    "    n_samples = len(y)\n",
    "    unique_classes, y_indices = np.unique(y, return_inverse=True)\n",
    "    class_counts = np.bincount(y_indices)\n",
    "    \n",
    "    # Initialise fold sizes for each class\n",
    "    fold_sizes = np.zeros((len(unique_classes), k), dtype=int)\n",
    "    for class_index, count in enumerate(class_counts):\n",
    "        fold_sizes[class_index, :] = count // k\n",
    "        fold_sizes[class_index, :count % k] += 1\n",
    "\n",
    "    for repeat in range(n_repeats):\n",
    "        indices = np.arange(n_samples)\n",
    "        np.random.shuffle(indices)\n",
    "        current = np.zeros(len(unique_classes), dtype=int)\n",
    "        \n",
    "        for fold in range(k):\n",
    "            test_mask = np.zeros(n_samples, dtype=bool)\n",
    "            for class_index, _ in enumerate(class_counts):\n",
    "                class_indices = indices[y_indices == class_index]\n",
    "                start = current[class_index]\n",
    "                stop = start + fold_sizes[class_index, fold]\n",
    "                test_mask[class_indices[start:stop]] = True\n",
    "                current[class_index] += fold_sizes[class_index, fold]\n",
    "            \n",
    "            train_idx = ~test_mask\n",
    "            test_idx = test_mask\n",
    "            \n",
    "            X_train, X_test = X[train_idx], X[test_idx]\n",
    "            y_train, y_test = y[train_idx], y[test_idx]\n",
    "            \n",
    "            estimator.fit(X_train, y_train)\n",
    "            y_pred = estimator.predict(X_test)\n",
    "            \n",
    "            # Calculate the pAUC\n",
    "            score = calculate_pAUC(estimator, X_test, y_test, scoring)\n",
    "            scores.append(score)\n",
    "            \n",
    "            # Calculate recall\n",
    "            recall = calculate_recall(y_test, y_pred)\n",
    "            recalls.append(recall)\n",
    "\n",
    "            # Calculate precision\n",
    "            precision = calculate_precision(y_test, y_pred)\n",
    "            precisions.append(precision)\n",
    "\n",
    "    return np.mean(scores), scores, np.mean(recalls), recalls, np.mean(precisions), precisions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df_train[feature_cols]\n",
    "y = df_train[target_col]\n",
    "\n",
    "mean_score, all_scores, mean_recall, all_recalls, mean_precision, all_precisions = stratified_k_fold_validation(\n",
    "    X=X, y=y, \n",
    "    estimator=estimator, \n",
    "    k=5, n_repeats=20, \n",
    "    scoring=pAUC\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.14657608792636503\n",
      "[0.1381649325273503, 0.1401888379998676, 0.1591359467694265, 0.15041478795269647, 0.1416241012137833, 0.1732068220467042, 0.1304515961945668, 0.14107382502196636, 0.14273387062435489, 0.15761893025171278, 0.1422776684061846, 0.1381194119041903, 0.14146424248474482, 0.140282773478835, 0.16006093303071847, 0.14743933420052843, 0.14090770180540302, 0.1593834747525164, 0.1466389230727973, 0.1330982487236778, 0.14801335227897394, 0.1477849180600615, 0.14590240235812066, 0.14502079862310618, 0.14923990148429517, 0.15903490808892654, 0.11781763215694102, 0.166349650116905, 0.14807536856691939, 0.14618112770148056, 0.1562993066537351, 0.14071864508318455, 0.13564574082680345, 0.14375487867607806, 0.14930937526243063, 0.16679794404713502, 0.12009079885227274, 0.13500523062137834, 0.1526234710877161, 0.15070115999771974, 0.1354958536929148, 0.14619092875600395, 0.1650701342784405, 0.14749382973577063, 0.1291297302789547, 0.13872245583536924, 0.1397942721354858, 0.14736342602575114, 0.15570876635467895, 0.14906775148913512, 0.1533536831107302, 0.15474882938838969, 0.13770738412581573, 0.14638451970822586, 0.13936662583678827, 0.15820956575948314, 0.13986746283644444, 0.1482367708501443, 0.15572775243111078, 0.12732142152509773, 0.12690542013050143, 0.1467823778523878, 0.1455378788554055, 0.16349037636105107, 0.14821056459418844, 0.1674837940677019, 0.14337054638693164, 0.15012990366676085, 0.13949846677033523, 0.14747230872607228, 0.14324810003369398, 0.13575474758565612, 0.15223615828326198, 0.14808363846760836, 0.1451742567724747, 0.1435894560156042, 0.1345488356683504, 0.14385750656093108, 0.15097388511666684, 0.14827510878335876, 0.12806801983191823, 0.1482268319772375, 0.15333365874170893, 0.17023972930366818, 0.1448710588607252, 0.14148509443713583, 0.1565902665625657, 0.14686695096078628, 0.14512425453598982, 0.14646747423712894, 0.14041099163534343, 0.16096626175239373, 0.16081453906097373, 0.13701315716763485, 0.15286333265817367, 0.1407895311544557, 0.15686429608908486, 0.13557146435732031, 0.16275723502764225, 0.14004717642472955]\n",
      "0.8086076565151941\n",
      "[0.8111111111111111, 0.8135593220338984, 0.8414634146341463, 0.8214285714285714, 0.7692307692307693, 0.8795180722891566, 0.7586206896551724, 0.7816091954022989, 0.7529411764705882, 0.825, 0.704225352112676, 0.8, 0.8133333333333334, 0.8205128205128205, 0.8809523809523809, 0.797752808988764, 0.746268656716418, 0.8333333333333334, 0.7761194029850746, 0.8061224489795918, 0.8095238095238095, 0.8611111111111112, 0.8181818181818182, 0.7956989247311828, 0.8205128205128205, 0.863013698630137, 0.75, 0.8777777777777778, 0.7831325301204819, 0.7910447761194029, 0.7976190476190477, 0.8202247191011236, 0.7702702702702703, 0.7916666666666666, 0.8648648648648649, 0.881578947368421, 0.7441860465116279, 0.7402597402597403, 0.8493150684931506, 0.8518518518518519, 0.8470588235294118, 0.7702702702702703, 0.9, 0.7857142857142857, 0.8, 0.788235294117647, 0.8656716417910447, 0.8481012658227848, 0.7586206896551724, 0.8, 0.7972972972972973, 0.821917808219178, 0.8023255813953488, 0.8192771084337349, 0.7662337662337663, 0.8032786885245902, 0.8045977011494253, 0.8160919540229885, 0.7976190476190477, 0.8108108108108109, 0.7628865979381443, 0.8289473684210527, 0.7012987012987013, 0.8767123287671232, 0.8428571428571429, 0.8536585365853658, 0.75, 0.8115942028985508, 0.7974683544303798, 0.8160919540229885, 0.7375, 0.7878787878787878, 0.8837209302325582, 0.8192771084337349, 0.8076923076923077, 0.8481012658227848, 0.8181818181818182, 0.75, 0.821917808219178, 0.782608695652174, 0.7692307692307693, 0.75, 0.8354430379746836, 0.9305555555555556, 0.8095238095238095, 0.8, 0.8, 0.8414634146341463, 0.7792207792207793, 0.810126582278481, 0.7439024390243902, 0.8450704225352113, 0.8695652173913043, 0.8142857142857143, 0.8461538461538461, 0.725, 0.8620689655172413, 0.7846153846153846, 0.875, 0.7530864197530864]\n",
      "0.007571352998866076\n",
      "[0.008631902565921721, 0.005729974931359676, 0.00781869688385269, 0.008098591549295774, 0.007660878447395302, 0.008247655632131963, 0.005437469105289174, 0.00805782675672473, 0.007928642220019821, 0.007630939993062782, 0.006235969069593414, 0.008055917545314536, 0.00730626422326027, 0.007689535023429052, 0.008533210332103322, 0.008523409363745498, 0.005999520038396928, 0.007047216349541931, 0.006247747206536105, 0.009445241511238642, 0.008060692271218587, 0.007330338141404587, 0.006543868153174988, 0.00882423086095874, 0.007615421227986673, 0.007333255732743569, 0.007597821957705458, 0.00896098003629764, 0.008060515873015874, 0.006159209761766415, 0.007960080788879649, 0.008664688427299703, 0.006770400285069486, 0.006823078764663634, 0.0075955376216472826, 0.007768115942028985, 0.008073672259366721, 0.006883226663446444, 0.007303569325008835, 0.00803633822501747, 0.00851063829787234, 0.006893215624622083, 0.007985803016858917, 0.00784873349982162, 0.0071156289707750954, 0.008265482358746608, 0.006616472735569244, 0.007830762038335671, 0.008169327887114742, 0.007140307033202428, 0.006842959870099745, 0.007139457401237506, 0.008147360963513992, 0.00821851583272903, 0.007253503811163019, 0.005889423076923077, 0.008325404376784015, 0.00848571770049002, 0.007815233873789806, 0.007244626901714562, 0.00903761602344895, 0.00771586037966932, 0.006642066420664207, 0.007129330511306673, 0.006914332591116841, 0.007887323943661971, 0.006985294117647059, 0.006799417192812044, 0.007576668671076368, 0.008453387308012858, 0.00696658401228008, 0.006310679611650485, 0.008930669800235018, 0.007835906890988707, 0.007780659503519822, 0.008010521281683405, 0.008745293331713835, 0.00760043431053203, 0.007088846880907372, 0.006370929683813119, 0.007229786721291722, 0.007681474843169889, 0.00781712661376288, 0.007669413919413919, 0.007964394471773249, 0.008042578356002365, 0.0066374303662439255, 0.00805886475122635, 0.007136909718092066, 0.007650926479378362, 0.007724452323667215, 0.006868131868131868, 0.009244280101687081, 0.006893215624622083, 0.007818978793981756, 0.0071596099247006545, 0.00887679015268079, 0.0062126933853088075, 0.00791765637371338, 0.007318536292741451]\n"
     ]
    }
   ],
   "source": [
    "print(mean_score)\n",
    "print(all_scores)\n",
    "print(mean_recall)\n",
    "print(all_recalls)\n",
    "print(mean_precision)\n",
    "print(all_precisions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analysis on validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/IAAAIhCAYAAADtv4ENAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd5wU5f3HP7P99nq/o/d6ghQpgj20Q2IssUskttjF+BNbBNTEqIkt1thQsSZWFBEioiggCJxKR3q5g4Pj+m1/fn/sPrOzfWZ3tvJ9v14k3u7s7OyU53m+7fMVGGMMBEEQBEEQBEEQBEGkBZpkHwBBEARBEARBEARBEPIhQ54gCIIgCIIgCIIg0ggy5AmCIAiCIAiCIAgijSBDniAIgiAIgiAIgiDSCDLkCYIgCIIgCIIgCCKNIEOeIAiCIAiCIAiCINIIMuQJgiAIgiAIgiAIIo0gQ54gCIIgCIIgCIIg0ggy5AmCIAiCIAiCIAgijSBDniAIgkhLhg8fDkEQ8I9//CPo+3PmzIEgCDhy5EjQ96uqqnD66acHvH7o0CHcddddOOGEE5CTkwOTyYS+ffvi1ltvxfbt29X8CRnD7bffDkEQcPbZZyf7UOJGjx49IAiC+C87OxvDhw/HM888A8ZYsg9PMW+//TaefPLJZB8GQRAEESVkyBMEQRBpR01NDdavXw8AeOWVV1Tb7+rVq3HCCSfglVdewQUXXIAPP/wQixYtwh133IF169Zh1KhRqn1XpmC32zF//nwAwKJFi3DgwIEkH1H8GDduHFauXImVK1fizTffhNlsxs0334yHH3442YemGDLkCYIg0hsy5AmCIIi04+WXXwYATJ06FVu2bMGKFSti3mdzczPOOeccmEwmrF+/HrNnz8bEiRNx+umn47rrrsPy5cvx0ksvxfw98aajoyOhEeJPPvkE9fX1mDp1KpxOJ15//XXV9p3o3xKJgoICjBkzBmPGjMF5552HhQsXIj8/Hy+++GKyD40gCII4ziBDniAIgkgqPAV+/fr1OO+885CXl4f8/HxcfvnlqK+vD9jeYrHg7bffxogRI/DEE08AAF599dWYj+Oll15CXV0dHn30UXTp0iXoNhdccEHYfbS3t+OOO+5Az549YTKZUFRUhJEjR+Kdd97x2e6HH37AtGnTUFxcDJPJhN69e+O2227z2ea7777DWWedhdzcXJjNZpx88sn4/PPPfbaZN28eBEHA4sWL8cc//hGlpaUwm82wWq0AgPfeew9jx45FdnY2cnJyMGnSJDGTgbNz505cfPHF6NSpE4xGI8rLy3HWWWehpqZGxllzZ0QYDAa89tpr6Nq1K1577bWgxveWLVtwySWXoLy8HEajEd26dcP06dPFYw33W1wuFx599FEMGDAARqMRZWVlmD59Ovbv3+/zHevXr8fZZ5+NsrIyGI1GdOrUCVOnTvXZ7j//+Q9Gjx6N/Px8mM1m9OrVC3/84x9l/VZ/8vLy0K9fPxw6dMjndZvNhoceekg83tLSUsyYMSPgfu7RowfOPvtsfPTRRxgyZAhMJhN69eqFp59+OuC7mpubxXvLYDCgc+fOuO2229DW1uaz3bPPPotTTz0VZWVlyM7OxgknnIBHH30Udrtd3Ob000/H559/jj179viUC3Cef/55DB06FDk5OcjNzcWAAQNwzz33RHWOCIIgiPigS/YBEARBEAQAnHvuubjwwgvxpz/9CRs3bsRf/vIXbNq0CT/88AP0er243Ycffohjx47hj3/8I/r27Yvx48fjvffew5NPPomcnJyov3/x4sXQarWYNm1a1Pu4/fbb8eabb+Khhx7CsGHD0NbWhg0bNuDo0aPiNl9++SWmTZuGgQMH4vHHH0e3bt2we/duLF68WNzmm2++wYQJEzBkyBC88sorMBqNeO655zBt2jS88847uOiii3y+949//COmTp2KN998E21tbdDr9fjb3/6G++67DzNmzMB9990Hm82Gxx57DKeccgpWr16NQYMGAQCqq6vhdDrx6KOPolu3bjhy5AhWrFiBxsbGiL93//79WLx4Mc4//3yUlpbiD3/4Ax566CF8++23OO2008TtfvrpJ4wfPx4lJSV44IEH0LdvX9TW1uLTTz+FzWaD0WgM+1uuv/56/Pvf/8ZNN92Es88+G7t378Zf/vIXLFu2DOvWrUNJSQna2towYcIE9OzZE88++yzKy8tRV1eHr7/+Gi0tLQCAlStX4qKLLsJFF12EOXPmwGQyYc+ePVi6dGlU19vhcGDfvn3o16+f+JrL5cI555yD5cuX484778TJJ5+MPXv2YPbs2Tj99NPx448/IisrS9y+pqYGt912G+bMmYOKigq89dZbuPXWW2Gz2XDHHXcAcDuITjvtNOzfvx/33HMPhgwZgo0bN+L+++/HL7/8gv/973+iIb5jxw5ceumlosH/008/4a9//Su2bNkiOryee+45XHvttdixYwc++ugjn9/07rvv4oYbbsDNN9+Mf/zjH9BoNPj111+xadOmqM4RQRAEEScYQRAEQSSR2bNnMwBs5syZPq+/9dZbDACbP3++z+tnnnkmM5lM7NixY4wxxl577TUGgL3yyitB91tfXx/0ewcPHsxOO+008e8BAwawioqKmH5LVVUV+93vfhd2m969e7PevXuzjo6OkNuMGTOGlZWVsZaWFvE1h8PBqqqqWJcuXZjL5WKMeX/79OnTfT6/d+9eptPp2M033+zzektLC6uoqGAXXnghY4yxI0eOMADsySefVPQ7OQ888AADwBYtWsQYY2znzp1MEAR2xRVX+Gx35plnsoKCAnb48OGQ+wr1WzZv3swAsBtuuMHn9R9++IEBYPfccw9jjLEff/yRAWAff/xxyO/4xz/+wQCwxsZGRb+TMca6d+/Oqqurmd1uZ3a7ne3Zs4ddc801TK/Xs88++0zc7p133mEA2AcffODz+TVr1jAA7LnnnvPZpyAIrKamxmfbCRMmsLy8PNbW1sYYY+zhhx9mGo2GrVmzxme7//73vwwAW7hwYdBjdjqdzG63szfeeINptVrW0NAgvjd16lTWvXv3gM/cdNNNrKCgQN5JIQiCIJIGpdYTBEEQKcFll13m8/eFF14InU6Hr7/+Wnxt165d+Prrr3HeeeehoKAAAPD73/8eubm5qqTXx8qoUaPwxRdf4K677sKyZcvQ0dHh8/62bduwY8cOXHXVVTCZTEH30dbWhh9++AEXXHCBT4aBVqvFFVdcgf3792Pr1q0+nzn//PN9/v7yyy/hcDgwffp0OBwO8Z/JZMJpp52GZcuWAQCKiorQu3dvPPbYY3j88cexfv16uFwuWb+VMSam00+YMAEA0LNnT5x++un44IMP0NzcDMAdTf7mm29w4YUXorS0NOJ+/X8Lv/5XXnmlz+ujRo3CwIED8dVXXwEA+vTpg8LCQsyaNQsvvPBC0AjySSedBMB9b73//vuKhfkWLlwIvV4PvV6P7t2746WXXsK//vUvTJ06Vdzms88+Q0FBAaZNm+Zz7k888URUVFSI554zePBgDB061Oe1Sy+9FM3NzVi3bp24z6qqKpx44ok++5w0aRIEQfDZ5/r16/Hb3/4WxcXF0Gq10Ov1mD59OpxOJ7Zt2xbxN44aNQqNjY245JJL8Mknn4Ts+kAQBEEkFzLkCYIgiJSgoqLC52+dTofi4mKftPRXX30VjDFccMEFaGxsRGNjI+x2O37729/i+++/x5YtW3w+DwBOpzPo9zkcDp+U/W7duqG+vj6g5lgJTz/9NGbNmoWPP/4YZ5xxBoqKivC73/1ObFvHa6RD1eADwLFjx8AYQ2VlZcB7nTp1AgCfcwIgYFtes33SSSeJhif/995774nGmSAI+OqrrzBp0iQ8+uijGD58OEpLS3HLLbeI6eihWLp0KXbt2oXf//73aG5uFq/HhRdeiPb2dlEX4NixY3A6nWF/c7jfwn9rqPPB38/Pz8c333yDE088Effccw8GDx6MTp06Yfbs2WJ9+KmnnoqPP/5YdHJ06dIFVVVVARoGoRg/fjzWrFmDVatW4c0330SPHj1w00034bvvvhO3OXToEBobG2EwGALOfV1dXYBh7H/fS1/jv+3QoUP4+eefA/aXm5sLxpi4z7179+KUU07BgQMH8NRTT2H58uVYs2YNnn32WQAIcCwF44orrsCrr76KPXv24Pzzz0dZWRlGjx6NJUuWyDpHBEEQRGKgGnmCIAgiJairq0Pnzp3Fvx0OB44ePYri4mIA7trjefPmAQDOO++8oPt49dVX8eijjwIAysvLAQAHDhwQ/5vDGENtbS1GjhwpvjZp0iQsXrwYCxYswMUXXxzVb8jOzsbcuXMxd+5cHDp0SIzOT5s2DVu2bBEj0v4ibVIKCwuh0WhQW1sb8N7BgwcBACUlJT6vS4XKpO//97//Rffu3cMec/fu3cUWftu2bcP777+POXPmwGaz4YUXXgj5Of6Zxx9/HI8//njQ96+77joUFRVBq9WG/c3hfgu//rW1tQHOgIMHD/qcixNOOAHvvvsuGGP4+eefMW/ePDzwwAPIysrCXXfdBQA455xzcM4558BqtWLVqlV4+OGHcemll6JHjx4YO3Zs2GPLz88X75nRo0dj9OjRGDp0KG644QbU1NRAo9GgpKQExcXFWLRoUdB95Obm+vxdV1cXsA1/jf/2kpISZGVlhcw64efg448/RltbGz788EOf6y5XuJAzY8YMzJgxA21tbfj2228xe/ZsnH322di2bVvE+4kgCIJIEMnM6ycIgiCISDXyb775JmOMsYULFzIA7MYbb2Rff/11wL/Bgwez8vJyZrfbGWOM/frrr0wQBHbnnXcGfCff12uvvSa+1tjYyCoqKljXrl3Z/v37gx6rf92zHG677TYGQKx37t27N+vTpw+zWCwhPzN27FhWUVHB2tvbxdecTic74YQTgtbI+9dO79q1i+l0OvbII48oPl7GGDvxxBPZSSedFPL9hoYGZjKZ2Lhx44Jei8suu4wBYL/88gtjzF0jX1hYGFKvINxv2bJlCwPAbrnlFp/XV69ezQCwe++9N+xvKSgoYL///e9Dvl9TU8MAsGeffTbsfrp3786mTp0a8Dq/f99++23GGGPz589nANiqVavC7o/vM1SNfG5urnjPPPTQQ8xsNrOdO3eG3d/TTz/NALDa2lrxNZfLxUaNGsUAsK+//lp8/bzzzmNlZWURj5Exxj7++GMGgH3++eeyticIgiDiD0XkCYIgiJTgww8/hE6nw4QJE0TV+qFDh+LCCy8E4I7w6nQ63HPPPWKKuZTrrrsOt9xyCz7//HOcc8456N27N2666SY89thjaGxsRHV1NbKysrBmzRr8/e9/x8iRI3HppZeKn8/Pz8cnn3yCs88+G8OGDcNNN92EsWPHwmAwYPv27Zg/fz5++umnkNkAgDtKe/bZZ2PIkCEoLCzE5s2b8eabb2Ls2LEwm80A3O3Bpk2bhjFjxmDmzJno1q0b9u7diy+//BJvvfUWAODhhx/GhAkTcMYZZ+COO+6AwWDAc889hw0bNuCdd94JiFr706NHDzzwwAO49957sXPnTkyePBmFhYU4dOgQVq9eLWYO/Pzzz7jpppvw+9//Hn379oXBYMDSpUvx888/ixHsYLz11luwWCy45ZZbcPrppwe8X1xcjLfeeguvvPIKnnjiCTz++OMYP348Ro8ejbvuugt9+vTBoUOH8Omnn+LFF18MiFJL6d+/P6699lr861//gkajwZQpU0TV+q5du2LmzJkA3HXkzz33HH73u9+hV69eYIzhww8/RGNjo1jDf//992P//v0466yz0KVLFzQ2NuKpp56CXq/3UdlXwh133IEXXngBc+fOxYUXXoiLL74Yb731Fqqrq3Hrrbdi1KhR0Ov12L9/P77++mucc845OPfcc8XPd+rUCb/97W8xZ84cVFZWYv78+ViyZAkeeeQR8Z657bbb8MEHH+DUU0/FzJkzMWTIELhcLuzduxeLFy/Gn//8Z4wePRoTJkyAwWDAJZdcgjvvvBMWiwXPP/88jh07FnDcJ5xwAj788EM8//zzGDFiBDQaDUaOHIlrrrkGWVlZGDduHCorK1FXV4eHH34Y+fn5osYAQRAEkQIk25NAEARBHN/wiObatWvZtGnTWE5ODsvNzWWXXHIJO3ToEGOMsfr6emYwGMIqwh87doxlZWWxadOmia+5XC72/PPPs5EjRzKz2cwMBgPr27cvmzVrlo8ivJS6ujo2a9YsNnjwYGY2m5nRaGR9+vRh1113nRhhDsVdd93FRo4cyQoLC5nRaGS9evViM2fOZEeOHPHZbuXKlWzKlCksPz+fGY1G1rt374CMhOXLl7MzzzyTZWdns6ysLDZmzBi2YMECn21CRbE5H3/8MTvjjDNYXl4eMxqNrHv37uyCCy5g//vf/xhjjB06dIhdeeWVbMCAASw7O5vl5OSwIUOGsCeeeII5HI6Qv/PEE09kZWVlzGq1htxmzJgxrKSkRNxm06ZN7Pe//z0rLi5mBoOBdevWjV155ZViZkK43+J0OtkjjzzC+vXrx/R6PSspKWGXX34527dvn7jNli1b2CWXXMJ69+7NsrKyWH5+Phs1ahSbN2+euM1nn33GpkyZwjp37swMBgMrKytj1dXVbPny5SF/BydURJ4xxp599lkGgL3++uuMMcbsdjv7xz/+wYYOHcpMJhPLyclhAwYMYNdddx3bvn17wD7/+9//ssGDBzODwcB69OjBHn/88YDvaG1tZffddx/r378/MxgMLD8/n51wwgls5syZrK6uTtxuwYIF4vd27tyZ/d///R/74osvAiLyDQ0N7IILLmAFBQVMEATGl4Svv/46O+OMM1h5eTkzGAysU6dO7MILL2Q///xzxHNEEARBJA6BMcaS6UggCIIgjm/mzJmDuXPnor6+PqD2myAymR49eqCqqgqfffZZsg+FIAiCSDNItZ4gCIIgCIIgCIIg0ggy5AmCIAiCIAiCIAgijaDUeoIgCIIgCIIgCIJIIygiTxAEQRAEQRAEQRBpBBnyBEEQBEEQBEEQBJFGkCFPEARBEARBEARBEGmELtkHkIq4XC4cPHgQubm5EAQh2YdDEARBEARBEARBZDiMMbS0tKBTp07QaMLH3MmQD8LBgwfRtWvXZB8GQRAEQRAEQRAEcZyxb98+dOnSJew2ZMgHITc3F4D7BObl5SX5aMJjt9uxePFiTJw4EXq9PtmHQxBBofuUSBfoXiXSBbpXiXSB7lUiXUiFe7W5uRldu3YV7dFwkCEfBJ5On5eXlxaGvNlsRl5eHg2ORMpC9ymRLtC9SqQLdK8S6QLdq0S6kEr3qpzybhK7IwiCIAiCIAiCIIg0ggx5giAIgiAIgiAIgkgjyJAnCIIgCIIgCIIgiDSCauQJgiAIgiAIgkgqjDE4HA44nc5kHwpxnGK326HT6WCxWOJ6H+r1emi12pj3Q4Y8QRAEQRAEQRBJw2azoba2Fu3t7ck+FOI4hjGGiooK7Nu3T5bYXLQIgoAuXbogJycnpv2QIU8QBEEQBEEQRFJwuVzYtWsXtFotOnXqBIPBEFcjiiBC4XK50NraipycHGg08alAZ4yhvr4e+/fvR9++fWOKzJMhTxAEQRAEQRBEUrDZbHC5XOjatSvMZnOyD4c4jnG5XLDZbDCZTHEz5AGgtLQUu3fvht1uj8mQJ7E7giAIgiAIgiCSSjwNJ4JIJdTKOKEnhiAIgiAIgiAIgiDSCDLkCYIgCIIgCIIgCCKNoBp5giAIgiAIgiDSHqeLYfWuBhxusaAs14RRPYug1ZBwHpGZUESeIAiCIAiCIIi0ZtGGWox/ZCkueWkVbn23Bpe8tArjH1mKRRtq4/adhw8fxnXXXYdu3brBaDSioqICkyZNwsqVK+P2nZnA6aefDkEQIAgCDAYDevfujbvvvhtWqzXZhxbAsmXLIAgCGhsbk30oAVBEniAIgiAIgiCItGXRhlpcP38dmN/rdU0WXD9/HZ6/fDgmV1Wq/r3nn38+7HY7Xn/9dfTq1QuHDh3CV199hYaGBtW/i2Oz2WAwGOK2fzWx2+3Q6/VB37vmmmvwwAMPwGazYc2aNZgxYwYA4OGHH07kIaY1FJHPYJwuhpU7juKTmgNYueMonC7/4Y0gCIIgCIIgUgvGGNptDln/Wix2zP50Y4ARD0B8bc6nm9BiscvaH2Py1suNjY347rvv8Mgjj+CMM85A9+7dMWrUKNx9992YOnWqz3bXXnstysvLYTKZUFVVhc8++0x8/4MPPsDgwYNhNBrRo0cP/POf//T5nh49euChhx7ClVdeifz8fFxzzTUAgBUrVuDUU09FVlYWunbtiltuuQVtbW3i55577jn07dsXJpMJ5eXluOCCC0L+lnnz5qGgoAAff/wx+vXrB5PJhAkTJmDfvn0+2y1YsAAjRoyAyWRCr169MHfuXDgcDvF9QRDwwgsv4JxzzkF2djYeeuihkN9pNptRUVGBbt264fzzz8eECROwePFi8X3GGB599FH06tULWVlZGDp0KP773/+K7/NI+eeff46hQ4fCZDJh9OjR+OWXX3y+J9J5mj9/PkaOHInc3Fx06tQJV199NQ4fPgwA2L17N8444wwAQGFhIQRBwJVXXhnyNyUaishnKIs21GLugk2obbKIr1XmmzB72qC4eCQJgiAIgiAIQg067E4Muv9LVfbFANQ1W3DCnMURtwWATQ9MgtkQ2UTKyclBTk4OPv74Y4wZMwZGozFgG5fLhSlTpqClpQXz589H7969sWnTJrF3+Nq1a3HhhRdizpw5uOiii7BixQrccMMNKC4u9jEYH3vsMfzlL3/BfffdBwD45ZdfMGnSJDz44IN45ZVXUF9fj5tuugk33XQTXnvtNfz444+45ZZb8Oabb+Lkk09GQ0MDli9fHvb3tLe3469//Stef/11GAwG3HDDDbj44ovx/fffAwC+/PJLXH755Xj66adxyimnYMeOHbj22msBALNnzxb3M3v2bDz88MN44oknZPdI/+mnn/D999+jR48e4mv33XcfPvzwQzz//PPo27cvvv32W1x++eUoLS3FaaedJm73f//3f3jqqadQUVGBe+65B7/97W+xbds26PX6iOcJcGc4PPjgg+jfvz/q6upw2223YcaMGfjiiy/QtWtXfPDBBzj//POxdetW5OXlISsrS9ZvSgQCk+t2Oo5obm5Gfn4+mpqakJeXl+zDCYvdbsfChQtRXV0tpq6ESi/iUh/xSi8iiFAEu08JIhWhe5VIF+heJdKFSPeqxWLBrl270LNnT5hMJgBAu82hmiGvFLmGPOCOpl9zzTXo6OjA8OHDcdppp+Hiiy/GkCFDAACLFy/GlClTsHnzZvTr1y/g85dddhnq6+t9ItF33nknPv/8c2zcuBGAOyI/bNgwfPTRR+I206dPR1ZWFl588UXxte+++w6nnXYa2trasHDhQsyYMQP79+9Hbm5uxN8xb948zJgxA6tWrcLo0aMBAFu2bMHAgQPxww8/YNSoUTj11FMxZcoU3H333eLn5s+fjzvvvBMHDx4E4I7I33bbbXjiiSfCft/pp5+OFStWwGAwwG63w2azQaPR4P3338f555+PtrY2lJSUYOnSpRg7dqz4uauvvhrt7e14++23sWzZMpxxxhl49913cdFFFwEAGhoa0KVLF8ybNw8XXnhhxPPE7zeOy+XCsmXLcNZZZ6GlpQU5OTni9xw7dgwFBQURz6Ucgt3zHCV2KEXkMwyni2Hugk0h04sEAHMXbMKEQRWk4kkQBEEQBEGkHFl6LTY9MEnWtqt3NeDK19ZE3G7ejJMwqmeRrO+Wy/nnn4+pU6di+fLlWLlyJRYtWoRHH30UL7/8Mq688krU1NSgS5cuQY14ANi8eTPOOeccn9fGjRuHJ598Ek6nU4xojxw50mebtWvX4tdff8Vbb70lvsYYg8vlwq5duzBhwgR0794dvXr1wuTJkzF58mSce+65MJvNIX+LTqfz+Z4BAwagoKAAmzdvxqhRo7B27VqsWbMGf/3rX8VtnE4nLBYL2tvbxX37H2soLrvsMtx7771obm7GI488gry8PJx//vkAgE2bNsFisWDChAk+n7HZbBg2bJjPa1JDv6ioCP3798fmzZtlnaeBAwdi/fr1mDNnDmpqatDQ0ACXywUA2Lt3LwYNGiTrtyQLMuQzjNW7GnzS6f1hAGqbLFi9qwFjexcn7sAIgiAIgiAIQgaCIMiOip/StxSV+SbUNVmCBrIEABX5JpzStzQuQSxeTz5hwgTcf//9uPrqqzF79mxceeWVEdOwGWMQBCHgNX+ys7N9/na5XLjuuutwyy23BGzbrVs3GAwGrFu3DsuWLcPixYtx//33Y86cOVizZk3YqLL/sUhfc7lcmDt3Ls4777yAbaRRZf9jDUV+fj769OkDwB3ZHzx4MF555RVcddVVojH9+eefo3Pnzj6fC1bCEO6Yw52ntrY2TJw4ERMnTsT8+fNRXFyMLVu24Pzzz4fNZpP1O5IJGfIZxuGW0EZ8NNsRBEEQBEEQRKqi1QiYPW0Qrp+/DgLgY8xzs3T2tEEJy0QdNGgQPv74YwDAkCFDsH//fmzbti1oVH7QoEH47rvvfF5bsWIF+vXrF7a+fPjw4di4caNoCAdDp9PhN7/5DX7zm99g9uzZKCgowNKlS4Ma4gDgcDjw448/YtSoUQCArVu3orGxEQMGDBC/c+vWrWG/M1r0ej3uuece3H333bjkkkswaNAgGI1G7N2716cePhirVq1Ct27dAADHjh3Dtm3bfI453Hn65ZdfcOTIEfz9739H165d4XK5ArQEeIcAp9MZ689UHVKtzzDKck2RN1KwHUEQBEEQBEGkMpOrKvH85cNRke+7vq3IN8VNG+ro0aM488wzMX/+fPz888/YtWsX/vOf/+DRRx8V0+VPO+00nHrqqTj//POxZMkS7Nq1C1988QUWLVoEAPjzn/+Mr776Cg8++CC2bduG119/Hc888wzuuOOOsN89a9YsrFy5EjfeeCNqamqwfft2fPrpp7j55psBAJ999hmefvpp1NTUYM+ePXjjjTfgcrnQv3//kPvU6/W4+eab8cMPP2DdunWYMWMGxowZIxr2999/P9544w3MmTMHGzduxObNm/Hee++JAnyxcumll0IQBDz33HPIzc3FHXfcgZkzZ+L111/Hjh07sH79ejz77LN4/fXXfT73wAMP4KuvvsKGDRtw5ZVXoqSkBL/73e9knSeevfCvf/0LO3fuxKeffop//OMfPvvv3r07BEHAZ599hvr6erS2tqrye9WADPkMY1TPIlTmmxDK5yjArV4vp0aIIAiCIAiCINKByVWV+G7WmXjnmjF46uIT8c41Y/DdrDPjJvCck5OD0aNH44knnsCpp56Kqqoq/OUvf8E111yDZ555Rtzugw8+wEknnSRGmu+8804xujt8+HC8//77ePfdd1FVVYX7778fDzzwQMQWZ0OGDME333yD7du345RTTsGwYcPwl7/8BZWV7t9aUFCADz/8EGeeeSYGDhyIF154Ae+88w4GDx4ccp9msxmzZs3CpZdeirFjxyIrKwvvvvuu+P6kSZPw2WefYcmSJTjppJMwZswYPP744+jevXsMZ9GLwWDATTfdhEcffRStra148MEHcf/99+Phhx/GwIEDMWnSJCxYsAA9e/b0+dzf//533HrrrRgxYgRqa2vx6aefilH0SOeptLQU8+bNw3/+8x8MGjQIjz76KB544AGf/Xfu3Blz587FXXfdhfLyctx0002q/F41INX6IJBqPUGoC6krE+kC3atEukD3KpEuRKNaTySWefPm4bbbbkNjY2OyD0U28VCTd7lcaG5uRl5eHjSa+MW71VKtp4h8BsLTi0pyDD6vxzO9iCAIgiAIgiAIgkgMJHaXoUyuqkR5ngnnPrcCADBhYDleuGIEtZwjCIIgCIIgCIJIcygin8FY7C7xvw16DRnxBEEQBEEQBEH4cOWVV6ZVWj0AnH766WCMqZZWn46QIZ/BdNgd4n8fa0v9XogEQRAEQRAEQRBEZMiQz2Dabd5+hw1kyBMEQRAEQRAEQWQEZMhnMFJD/lg7GfIEQRAEQRAEQRCZABnyGUyH1JBvs4M6DRIEQRAEQRAEQaQ/STfkn3vuObGH3ogRI7B8+fKQ29bW1uLSSy9F//79odFocNtttwVsc/rpp0MQhIB/U6dOjeOvSE2kEXmb04U2yd8EQRAEQRAEQRBEepJUQ/69997DbbfdhnvvvRfr16/HKaecgilTpmDv3r1Bt7darSgtLcW9996LoUOHBt3mww8/RG1trfhvw4YN0Gq1+P3vfx/Pn5KSdNgcPn+T4B1BEARBEARBEET6k1RD/vHHH8dVV12Fq6++GgMHDsSTTz6Jrl274vnnnw+6fY8ePfDUU09h+vTpyM/PD7pNUVERKioqxH9LliyB2Ww+Lg35dr8IPAneEQRBEARBEARBpD+6ZH2xzWbD2rVrcdddd/m8PnHiRKxYsUK173nllVdw8cUXIzs7O+Q2VqsVVqtV/Lu5uRkAYLfbYbfbVTuWeMCPL9hxtlp9X6tvbofdHvo8EES8CHefEpmN08Xw455jONxiRVmuESO7F0KrEZJ9WCGhe5VIF+heJdKFSPeq3e7WcXK5XHC5XIk8tJiZMWMG3njjDVx77bUBgcgbb7wRL7zwAqZPn47XXnstSUfoxul04rHHHsMbb7yBPXv2ICsrC/369cM111yDGTNmJPXY5PLBBx9g9uzZ2LFjB3r37o0HH3wQ5557bsjtLRYLrr/+eqxbtw6bN2/G1KlT8dFHH4Xc/vvvv8cZZ5yBgQMHoqamxudebGxsxH333YePPvoIx44dQ8+ePfHYY4+huroaAPD888/jxRdfxO7duwEAgwcPxn333YcpU6YE/S6XywXGGOx2O7Rarc97Ssb0pBnyR44cgdPpRHl5uc/r5eXlqKurU+U7Vq9ejQ0bNuCVV14Ju93DDz+MuXPnBry+ePFimM1mVY4l3ixZsiTgtV93aSBNuli28ke0/UqCd0TyCHafEpnLT0cFfLhbg0ab13AvMDCc18OFocWpPRbRvUqkC3SvEulCqHtVp9OhoqICra2tsNnSK3vUbrejc+fOePfddzFnzhxkZWUBcBuR77zzDrp06QK73S4GCZPFX//6V7z++ut49NFHMWzYMDQ3N6OmpgZ1dXVxOzabzQaDwaDKvlavXo1LLrkE99xzD84++2x89tlnuPjii/HFF19g5MiRQT/T1tYGrVaLq6++GgsWLIDD4Qj5W5uamjB9+nScdtppOHz4MFpaWnx+x+TJk1FSUoLXXnsNnTp1woEDB5CTkyPur6ioCPfddx969eoFAHjnnXdw7rnn4ptvvsHAgQMDvs9ms6GjowPffvstHA7fUuj29nbZ5yVphjxHEHwjM4yxgNei5ZVXXkFVVRVGjRoVdru7774bt99+u/h3c3MzunbtiokTJyIvL0+VY4kXdrsdS5YswYQJE6DX633e++ztGuDIYfHvbn0Hofrk7gk+QoIIf58SmcmXGw/htZU/wd9cb7IJeG2bFv+6eCgmDS4P+tlkQvcqkS7QvUqkC5HuVYvFgn379iEnJwcmk8n3zba20DvWagHp9uG21WgAj5EddtswGbzB0Ov1GDFiBHbt2oX//e9/uOyyywAAn332Gbp164aePXtCr9eL9gRjDP/4xz/w4osvora2Fv369cO9996LCy64AIA7cn7dddfh66+/Rl1dHbp164brr78et9xyi/idM2bMQGNjI8aPH4/HH38cNpsNF110EZ544omQY8GSJUtwww03YPr06eJr48aN89nG5XLhH//4B15++WXs27cP5eXluPbaa3HPPfcAAH755RfMnDkTK1euhNlsxnnnnYd//vOfyMnJ8Tmu0aNH45lnnoHBYMDOnTtx4MAB/PnPf8aSJUug0Wgwbtw4PPnkk+jRo4fs8/zyyy/jN7/5DebMmQMAGDlyJH744Qe8/PLLOPPMM4N+Ji8vDy+//DIAYN26dWhsbAxp11133XW47LLLoNFo8NFHHyE3N1e0R1944QU0NTVh5cqV4vmtqqry+fxFF13k8/fw4cPx2muvYcOGDRg9enTA91ksFmRlZeHUU08NuOeVOFaSZsiXlJRAq9UGRN8PHz4cEKWPhvb2drz77rt44IEHIm5rNBphNBoDXtfr9WkzOQY7VovDnRKSZ9Kh2eJAk8WRNr+HyEzS6ZkiosfpYvjrF1sDjHgAYAAEAH/9YiumDOmcsmn2dK8S6QLdq0S6EOpedTqdEAQBGo0GGo2ffFe4gFp1NfD5596/KyqAUNHM004Dli3z/t2rF3DkSOB2Cls18+5YM2bMwOuvv44rrrgCADBv3jz88Y9/xLJly8TfBgD33nsvPvzwQzz//PPo27cvvv32W0yfPh3l5eU47bTT4HQ60bVrV7z//vsoKSnBihUrcO2116JTp0648MILxe9ctmwZOnXqhK+//hq//vorLrroIgwbNgzXXHNN0OOsqKjA119/jRtvvBGlpaVBt7n77rvx0ksv4YknnsD48eNRW1uLLVu2QKPRoL29HdXV1RgzZgzWrFmDw4cP4+qrr8Ytt9yCefPmice1dOlS5OfnY8mSJWCMwWKx4KyzzsIpp5yCb7/9FjqdDg899BCqq6vx888/w2AwYNmyZTjjjDOwa9eukMb9qlWrMHPmTJ/7Y/LkyXjyyScD75kw1ynYtq+99hp27tyJt956Cw8++KC4Pd/2s88+w9ixY3HzzTfjk08+QWlpKS699FLMmjUrIC0ecN/P//nPf9DW1oZx48YF/U6NRgNBEII+E0rG86QZ8gaDASNGjMCSJUt86huWLFmCc845J+b9v//++7Barbj88stj3le6wsXuOhea0VzbjIY2qqMjCCL+rN7VgNomS8j3GYDaJgtW72rA2N7FiTswgiAIgogDV1xxBe6++27s3r0bgiDg+++/x7vvvotlEudBW1sbHn/8cSxduhRjx44FAPTq1QvfffcdXnzxRZx22mnQ6/U+5b49e/bEihUr8P7774uGPAAUFhbimWeegVarxYABAzB16lR89dVXIQ35xx9/HBdccAEqKiowePBgnHzyyTjnnHPEGu6WlhY89dRTeOaZZ/CHP/wBANC7d2+MHz8eAPDWW2+ho6MDb7zxhqg79swzz2DatGl45JFHxCBsdnY2Xn75ZTGl/tVXX4VGo8HLL78sRrhfe+01FBQUYNmyZZg4cSLMZjP69+8f1oCtq6uLSzn29u3bcdddd2H58uXQ6YKbxTt37sTSpUtx2WWXYeHChdi+fTtuvPFGOBwO3H///eJ2v/zyC8aOHQuLxYKcnBx89NFHGDRoUEzHF4mkptbffvvtuOKKKzBy5EiMHTsW//73v7F371786U9/AuD2DB04cABvvPGG+JmamhoAQGtrK+rr61FTUwODwRBwol555RX87ne/Q3Hx8btIFA35gixsrm2m9nMEQSSEwy2hjfhotiMIgiCOU1pbQ7/nHw09fDj4doA7tV6KR5RMLUpKSjB16lS8/vrrYIxh6tSpKCkp8dlm06ZNsFgsmDBhgs/rNpsNw4YNE/9+4YUX8PLLL2PPnj3o6OiAzWbDiSee6POZwYMH+0SDKysr8csvv4Q8vkGDBmHDhg1Yu3YtvvvuO3z77beYNm0arrzySrz88svYvHkzrFYrzjrrrKCf37x5M4YOHeojHj5u3Di4XC5s3bpVNLJPOOEEn7r4tWvX4tdff0Vubq7P/iwWC3bs2AEAGDVqFLZs2RLy2Dlql2M7nU5ceumlmDt3Lvr16xdyO5fLhbKyMvz73/+GVqvFiBEjcPDgQTz22GM+hnz//v1RU1ODxsZGfPDBB/jDH/6Ab775Jq7GfFIN+YsuughHjx7FAw88gNraWlRVVWHhwoXo3t1dx11bWxvQU156o69duxZvv/02unfvLqoEAsC2bdvw3XffYfHixQn5HakK7yPfpdBdE9TQToY8QRDxpyzXFHkjBdsRBEEQxylKatbjta1M/vjHP+Kmm24CADz77LMB73MV9M8//xydO3f2eY+X+L7//vuYOXMm/vnPf2Ls2LHIzc3FY489hh9++MFne//otSAIERX/NRoNTjrpJJx00kmYOXMm5s+fjyuuuAL33nuvKNIXinBGs/R1/y5hLpcLI0aMwFtvvRXwuVAp/sGoqKhQvRy7paUFP/74I9avXy9eN64mbzAYsHjxYpx55pmorKyEXq/3cZwMHDgQdXV1PoJ+BoMBffr0AeCu4V+zZg2eeuopvPjii1EfYySSLnZ3ww034IYbbgj6Hq+5kMJk1K7069dP1naZjjQiD4Ai8gRBKMLpYli9qwGHWywoyzVhVM8iWTXto3oWoTLfhLomS9A6eQFARb57fwRBEASRCUyePFlU3Z80aVLA+4MGDYLRaMTevXtx2mmnBd3H8uXLcfLJJ/vYRjxyrTY8UtzW1oa+ffsiKysLX331Fa6++uqg277++utoa2sTjfXvv/8eGo0mbDR7+PDheO+991BWVhaTgPjYsWOxZMkSzJw5U3xt8eLFOPnkk6PeZ15eXkAWw7PPPouvvvoK//3vf9G7d28A7syDt99+Gy6XS6x337ZtGyorK8Oq8jPGfNqbx4OkG/JE/OgQa+Q9hjxF5AmCkMmiDbWYu2CTT617Zb4Js6cNwuSqyrCf1WoEzJ42CNfPXwcB8DHmuRtg9rRBKSt0RxAEQRBK0Wq12Lx5s/jf/uTm5uKOO+7AzJkz4XK5MH78eDQ3N2PFihXIycnBH/7wB/Tp0wdvvPEGvvzyS/Ts2RNvvvkm1qxZg549e8Z0bBdccAHGjRuHk08+GRUVFdi1axfuvvtu9OvXDwMGDIBOp8OsWbNw5513wmAwYNy4caivr8fGjRtx1VVX4bLLLsPs2bPxhz/8AXPmzEF9fT1uvvlmXHHFFWGj4pdddhkee+wxnHPOOXjggQfQpUsX7N27Fx9++CH+7//+D126dMHq1asxffp0fPXVVwGZCpxbb70Vp556Kh555BGcc845+OSTT/C///0P3333nbjNM888g48++ghfffWV+NqmTZtgs9nQ0NCAlpYWsUT7xBNPhEajCVCfLysrg9FoRFVVlWi0X3/99fjXv/6FW2+9FTfffDO2b9+Ov/3tbz6dBO655x5MmTIFXbt2RUtLi6iPsGjRIsXXSglkyGcojDG02/0i8u12uFwMGlo8EwQRhkUbanH9/HUB0fS6Jguun78Oz18+PKIxP7mqEs9fPjzAGVAh0xlAEARBEOlGpKjzgw8+iLKyMjz88MPYuXMnCgoKMHz4cLHF25/+9CfU1NTgoosugiAIuOSSS3DDDTfgiy++iOm4Jk2ahHfeeQcPP/wwmpqaUFFRgTPPPBNz5swRRd7+8pe/QKfT4f7778fBgwdRWVkp6paZzWZ8+eWXuPXWW3HSSSfBbDbj/PPPx+OPPx72e81mM7799lvMmjUL5513HlpaWtC5c2ecddZZ4rlqb2/H1q1bYbeHFuU++eST8e677+K+++7DX/7yF/Tu3RvvvfeeT2u3I0eOBGQvVFdXY8+ePeLfvERbSeZ2165dsXjxYsycORNDhgxB586dceutt2LWrFniNocOHcIVV1yB2tpa5OfnY8iQIVi0aFGAHoLaCIxy0ANobm5Gfn4+mpqa0qKP/MKFC1FdXe1TL2N1ONH/PrcX6Mf7foORD/0PAPDT/RORb6Y2NURiCXWfEqmH08Uw/pGlIVXneVr8d7POlBVRd7oYBs9eBIvdhdE9C/H2NWNTOhJP9yqRLtC9SqQLke5Vi8WCXbt2oWfPnoF95AkigbhcLjQ3NyMvL09WW7toCXfPK7FD43eERFLhafUAUJClR7bBneJDgncEQYRDSes4OTDGYLG7BXiyjfqUNuIJgiAIgiDSBTLkMxQudGfQaqDTalCY7RZjaCDBO4IgwqB267hWq0P8b6vDGWZLgiAIgiAIQi5kyGco3JDP8kTiizyGPCnXEwQRDrVbx7VYJIa8PXxrHIIgCIIgCEIeZMhnKDy13uwx5AvNnog8pdYTBBEG3jouVAK8ALd6vdzWcU0dXvEaC0XkCYIgCIIgVIEM+Qyl3eaOglFEniAIJfDWcQACjPloWsc1W7yGPEXkCYIgiFCQ/jZxvKDWvU6GfIbSHiIif6w9dGsHgiAIwNs6riLfN32+It8kq/WclOYOaY08GfIEQRCEL1zJvr29PclHQhCJwWZzB1a1Wm1M+6E+8hmKaMjr3Ze4KNs9SFJEniAIOUyuqsSEQRUY//elqG22oH95Dhbeeqpi1XlpRN5ip9R6giAIwhetVouCggIcPnwYgLv3uCBQhxMi8bhcLthsNlgslri1n3O5XKivr4fZbIZOF5spToZ8huKfWi+q1lONPEEQMtFqBPC1FPP8rZRmSY08ReQJgiCIYFRUVACAaMwTRDJgjKGjowNZWVlxdSZpNBp069Yt5u8gQz5D6bD7ptYXmalGniAI5XDjW5oir4RmC7WfIwiCIMIjCAIqKytRVlYGu53KQInkYLfb8e233+LUU08VSz7igcFgUCXiT4Z8huKtkXdfYorIEwQRDdyQl6rPK0EakbfYXWCMUcokQRAEERStVhtz3TBBRItWq4XD4YDJZIqrIa8WJHaXofiL3ZFqPUEQ0cDr2jvsTtiiSI2X1sgDgM1J6fUEQRAEQRCxQoZ8htLhqZH3V61v7LDD6aL2HgRBRMbhdMEhGS+iicr7p+RTnTxBEARBEETskCGfofCIPBe7KzC700MYiz5FliCI9MHpYli54yg+qTmAlTuORuXA84+eR2XI+0XkSbmeIAiCIAgidqhGPkPp8Eut12s1yDPp0GxxoKHNJqbaEwSReSzaUIu5CzahtskivlaZb8LsaYMU9YC32lUw5P0+479PgiAIgiAIQjkUkc9QvBF5r69GrJMnwTuCyFgWbajF9fPX+RjxAFDXZMH189dh0YZa2fuy+KnM+xvlcmixUGo9QRAEQRCE2pAhn6G08/Zzeq/yp6hcT4J3BJGROF0McxdsQrAkev7a3AWbZKfZ+0fP/dPk5RAQkacWdARBEARBEDFDhnyG4i92B1AveYLIdFbvagiIxEthAGqbLFi9q0HW/vyj50pT650uhhareyzKMbqzgyyUWk8QBEEQBBEzVCOfobRZfcXuAOolTxCZzuGW0EZ8NNv5C9M1tSsz5FslafWluUa0Wh0UkSeIBOB0Maze1YDDLRaU5ZowqmcRtBoh2YdFEARBqAgZ8hlKB0+tD1YjTxF5gshIynJNqm4Xa0Sep+Jn6bViRJ5q5AkivqgldkkQBEGkNpRan6G0B0mt573kG9qo/RxBZCKjehahMt+EUHE3Ae4F/aieRbL25x89V2rI8+3zsnQw6tzTjZXazxFE3FBT7JIgCIJIbciQz1D8+8gDQKGnlzyp1hNEZqLVCJg9bRAABBjz/O/Z0wbJTrH1r2ePNiKfZ9LDqPcY8lFG5J0uhpU7juKTmgNYueOobME+gjheUFvskiBo3CWI1IZS6zMU/z7yAKnWE8TxwOSqSjx/+fCA1NqKaPrI+7efU6ha39zhzgzKNelg0rnHomj6yFOqMEFERonY5djexYk7MCItoXGXIFIfishnIDaHCw6P1zRojTxF5Akio5lcVYnvZp2JLE8UfNpQ999KF1/c6OYR/KYOR7jNAxAj8lneiLx/b/pIUKowQchDbbFL4viFxl2CSA/IkM9AeDQeCFUjT4Y8QWQ6Wo0ApycLsjjbGJViNTe6S3OMAAJ7wkeCb59n0sMYRUSeUoUJQj5qi10Sxyc07hJE+kCGfAbSbndHzfRaAXqt9xLziHyLxQG7k5SjCSKTYYzB5qlHj7blGze6S3PdhrzyGnn3WJSXpYNJrJGXfyxKUoUJ4nhHbbFL4viExl2CSB/IkM9ARKE7vdbn9fwsPQTPDE/p9QSR2dgkzjp/0Tq5cGG6Mo8h32p1wKHACRgsIq/kWChVmCDko7bYJXF8QuMuQaQPZMhnIF6hO18tQ61GQEGWR7meWtARREYjVYe3RNnyjX+OR+QBb5RdDi1iRF7vbT+nICJPqcIEoQwudlmR7/tMVOSb8Pzlw0mkjIgIjbsEkT6QIZ+BtAdRrOeQcj1BHB9Ia9GjNeS5MyDbqEOO0e0YVJJe79t+TuuzTzlQqjBBKIeLXfYoMQMASrINUYldEscnNO4SRPpAhnwG0m5zR8GyghjyRWZSrieI4wFp5Dv61Hr3Pow6DfI92TxKBO/E1PosnRiRV+JUkKYK+0OpwgQRGq1GgMZTS2d1uOgZIWRD4y5BpA9kyGcgwXrIcygif/zgdDGs3HEUn9QcwModR0lh9jjDJol8Ryt2xx0ARp0WeR5DXllE3pNab5Km1itzKvBUYS6Wx6FUYYIIj8WzFmi1OeCi8Z9QAB93/bWWaNwliNRCF3kTIt1o42J3hsDLyyPyjRSRz2gWbajF3AWbfJRnK/NNmD1tEE3Axwm+NfKxReRNeg3ys6JIre/w9pE36ZW3n+NMrqrE2DX78PXWenQvMuPv5w/BqJ5FFBGKEaeLYfWuBhxusaAs10TnNMNo92S/MOY25vNM+iQfEZFOTK6qxIfr9mPxpsMAgL+dW4WLTupGYwRBpBBkyGcgHZ7UerM+XESexO4ylUUbanH9/HUBPWDrmiy4fv468qYfJ/gY8tG2n3PwiLxGNAKiq5GXpNbHmB2QZdBibO/iqPaRCNLFOCZnX+bDs/MAt/AkGfKEUlqt3nuosiArJccyIr1JlzkzVSFDPgMJJ3ZXlO1RraeIfEbidDHMXbApwIgH3L1fBQBzF2zChEEVNFBmOFZJLXo0UXDpPox6rVgjL9eQd7kYWq0S1foYIvKA1wHQbovOEZAI0sU4Jmdf5uN0MR9nXovFDiAreQdEpCV8DAeA+hZrEo+EyETSZc5MZahGPgMR+8gHq5E3U418JrN6V4PPgOgPA1DbZMHqXQ2JOygiKajRfo7vw51ar0zsrsXqAPNYirkmHUxRtJ+TwiPyqWrIc+PY//njxvGiDbVJOjJfIjn7ALezjzQ10hv/Z75FQdtIguC0Su6bI61kyBPqkS5zZqpDhnwG0mEPF5En1fpM5nBLaCM+mu2I9MWmhiEvEbsTDXmLPEOeG/wmvQZGnVaMyEdbr89/Q7S/JZ6kk3FMzr7jA3+HV4vM55YgpDRLDfkWWjcS6pBOc2aqQ4Z8BsLbz5mDiN2Ran1mU5ZrUnU7In3xrZGPLZ3dqNMg36wstV7aQ57vw31c0UbkeWq9A4yl1uSeTsYxOfuOD/wdXs0dFJEnlNNq9Y73FJEn1CKd5sxUhwz5DCRsjTzvI0+GfEYyqmcRKvNNCFX9LsBdfzSqZ1EiD4tIAlKD2elicDiVG/M8Im+KokaeGw68bZ2oWh+lU4FnGrkYYIvit8STdDKOydl3fNARkFpPEXlCGXanyyeDigx5Qi3Sac5MdciQz0Dk9JFvszlTMkWViA2tRsDsaYOCvseN+9nTBpHQ3XGAv8EcTVTeKonIK1WtlyrW830AsafWA75q3KlAOhnH5Ow7PvBPrW+mGnlCIa1+9wyJ3RFqkU5zZqpDhnwG0h6mj3yeSScacY3t5KHPRCZXVeL5y4cj28+RU5FvIjXq4wibvyEfhePOIqmRz1Mckff2kHfvI/rUesaYjwPAP9qYbNLJOObOvmDFCeTsyxz8nV0kdkcoRapYD1BEnlCPdJozUx0y5DOQcBF5QRBIuf44YHJVJU6W9No+b3hnfDfrTDLijyP8DeZoDHm+D6lqfZNMByCPAPJIfiyp9f6fSTXl+nTLhJlcVYlLR3UNeJ2cfZlDh93XCKPUekIp3Pmj17rHrWPtdthTrKyJSE+kc6b/rJiKc2YqQ4Z8BtLumcCDtZ8DqJf88cKuo+3ifxeaDTQgHmf492uPJqWdG9BS1foWqwMuGUqy3oi8b2q9zeGS9Xkp/tHFVEutB7yZMKU5Bp/XU9U4bvITP/vD2O7k7MsgOmy+zztF5AmlcOdPp4Iscf1AASBCLficWZHvmz6fqnNmqkKGfAYiit3pgxvyFJHPfBxOF/YcbRP/brPSIu54I6BGPqqIvMeQl0TkGXMb85HgNfK5XLVeMh4pFauz+GUXpFpqPWdyVSWeu3yE+Hd1VUVKGscuF8PKnUcBAAMqcgEA+Vl6cvZlELx7DYci8oRSeGp9fpZebF1MdfKEmkyuqsR3s85Eief+Ks8zpuScmcqQIZ+BtFt5an1gjTxAveSPBw40dsDu9EY9/WvdiMzHP7VeaUq73ekSe7iadFoYdBpkeYzxZhl18qJqPU+t13mnG/9sgUj4R+BTLbVeivRZyzenpnG8pa4FDW02ZOm1OHNAGQCggeaDjII77vj9R2J3hFL4WJZr0qEkxwgAqKc6eUJltBpB1GzpsDlTcs5MZciQz0C4Jz5Uaj31ks98dta3+fxNEfnjD3+xO6vCKLbU8Dfq3VOFkhZ0omq9J7Vep9WIE7RSwTv/soBUTK3nSJ0cbdbUPM4VO44AcAsOlee50xppPsgsuLOrxFPqQRF5Qinc+ZNj1In30RGKyBNxgDsemy0OMYBAyIMM+QyEp50GE7sDqJf88cCO+lYAXpGaVDUoiPgR2H5OoSEvMfwNWvdUwY1yWYY8r5H3ROSB6FvQBabWp65jSnpu/NObU4Xvf3Ub8uP6FJNjN0Ph6wDuqKEaeUIpvP1crkmPUk9E/kgrjROEujDGfMrl5HbGIdyQIZ9h2J0uMaU6lCFfYHYvrBuo/VzGsvOIOyI/oCIPAKXWH48E1sgrNZ7d2xt0Gmg8kXRlEXlPan1WoCGvOCIfIHaXusrJ0raeqfjc2Z0urN7VAAA4uXcJinmpVRvNB5kEz1rhfZjJkCeU0mp1jwk5Rh1Kc7khTxF5Ql3sTgZpEL6RyrwUQYZ8hiGtHQ2tWk8R+Uxnpycif0KXfABAW4pGBon4EWv7OR6RN0pq2xUZ8mJE3qvVEW0LOv+IfKpGugH/iHzqZcL8vL8RbTYnCsx6DKrM84qf0uIpo+ARrrI8twHWaqWUVUIZLZYgNfIpmlrvdDGs3HEUn9QcwModR+leTyP85/djFGRURHA1NCJt4V54rUYQ02H9oVTKzIfXyA/pnI+3QTXyxyP+NfJKI/LS1nMcHl2XJXYn1sgHS61XZuD6R+CjUeBPFE0+NfKp99x9/6tbrX5sr2JoNIKPY5cxBkEgoaFMoF2MyBvF11qtDtEZRxCRaJUa8rmeGvkUjMgv2lCLuQs2obbJIr5WmW/C7GmDSP08DE4Xw+pdDTjcYkFZrgmjehYlRWjOP+OuqYNsEyWQIZ9h8EiV2aANuSATa+QpApORtFodOOzxmld1zhdfI44v/KPeygXm3Nub9Moj8i4XE+853xr5KCPydv+IfHoY8ql4nFzo7uTexQCAwmz39XG4GJotZOhlCjwiX5Clh0Gngc3hQovFTteXkA1vM5pj1IsR+VQz5BdtqMX189fBP/5e12TB9fPXUT/yEKSS88M/yNBIEXlFUGp9hiH2kA+RVg94U+sbPBEYIrPY5YnGl+QY0KkgC4B7oHQo7N1NpDe8xVu2ZyyIPiKv3JBvsTrAh5Zcn9T66Grk/fvGp6KBzJGem1RzoHXYnFi3pxEAcHKfEgBu50qO0X2NqNwqc+DZeVkGrVjewltCEoQceKeDHElqfSqJ3TldDHMXbAow4gGIr81dsInS7P3gzg+pEQ94nR+LNtQm9HgotT42yJDPMLyK9aGTLXhqvdXhClggE+nPziPu+vheJTnINnodOm0pbPwQ6sONZW58K66RD5Zab5JnyPPUe6NOI9bFS/elWHjPHlu9fyJpaveNyKeSs/THPQ2wOV2oyDOhV0m2+DqPylOdfObgNeR1yPU8t9SCjlCCtI88F7s71m6DPUWCAqt3NQQYo1IYgNomiyjuSaSm88N/Pm+ieUgRSTfkn3vuOfTs2RMmkwkjRozA8uXLQ25bW1uLSy+9FP3794dGo8Ftt90WdLvGxkbceOONqKyshMlkwsCBA7Fw4cI4/YLUgkeqsvShI/LZBq1YP0918skhnsIsOzwR+V6l2TDqtJIWdBSNOZ7ghjivUVfafo5PrsYoUutbgijWS/cVbZo/J10i8k4XU1xGEE9W7HDXx5/cp9in9IqXWzWkULSNiI12u3ctwCPypFxPKEEUuzPqUGg2QCMAjKXOuvFwS2gjPprtjgdS0fnRYaOIfCwktUb+vffew2233YbnnnsO48aNw4svvogpU6Zg06ZN6NatW8D2VqsVpaWluPfee/HEE08E3afNZsOECRNQVlaG//73v+jSpQv27duH3NzceP+clKBDUiMfCkEQUJitx6FmK4612dGlMFFHRwDxr03iivU9PRG3bKMOje12MuSPM2x+hrw1ytR6kyQiny9T7E4UujP5TjFijbziiLy3FZ4txTOJ/J0c7TanT1ZCMlnxK6+PL/F5XRRApUhIxmCRlNmJEXkrLZAJ+XCxuxyTDlqNgKJsI460WlHfYkV5ninJR+dtrajWdscDqej8sPg5uxupj7wikhqRf/zxx3HVVVfh6quvxsCBA/Hkk0+ia9eueP7554Nu36NHDzz11FOYPn068vPzg27z6quvoqGhAR9//DHGjRuH7t27Y/z48Rg6dGg8f0rK0C6piwsHtRxKDomoTdopRuRzAADZnjKLVKvXJeILN8SjTq0PFpE3K0utDxWRV6xa79meR479PfipQjAnQ6o40Jo67PjlQBMAYFyfYp/3qCVp5tFud993Jr1W1KmIJiJPbb2OX1rE1Hr3OF6Sk1rK9aN6FqEy34RQOusC3EGSUT2LEnlYKU0qOj/81wPUR14ZSYvI22w2rF27FnfddZfP6xMnTsSKFSui3u+nn36KsWPH4sYbb8Qnn3yC0tJSXHrppZg1axa02uDGrdVqhdXqHZiam5sBAHa7HXZ7anuG+PHx/2/2tG0w6TRhj73QsyA/0tyR8r8xU3C6GOZ8ujFkbZIAYO6CjTi9b3HULUAYY9jlqZHvVmCE3W4Xxc6a261Ju9b+9ykRf/jkmOvRSeiwORSd/zZP9E6vEcTPZevc92VTR/ix8VibRfxu6XYGj0+g3aZsbG33HEuBWY+6ZgvaFf4WJcRyrx6VLHALzXoca7ejqc2CitzkK4Wv2H4YLgb0LDajxKzz+X0FHkPvSIuFntE0Ity9yp1dBg0T54DGNmVzwJcbD+GhhVtQ1+y9ryvyjLivegAmDS6P5dCJFMfqcIlZXSYNg91uFw35Q03tiseJeK0B7p3SHze/+xMEwGdtJUjedzkdcKWm7zfhDOuSi4o8Iw41W4OuRQFAIwBmnftaOV0MP+45hsMtVpTlGjGye6HqLepa/drNHWuzJXUeSoX1qpLvTpohf+TIETidTpSX+04G5eXlqKuri3q/O3fuxNKlS3HZZZdh4cKF2L59O2688UY4HA7cf//9QT/z8MMPY+7cuQGvL168GGazOepjSSRLliwBAKw/KADQ4lh9XVhdAEuTBoAG3/9YA92B9Yk5yOOc7U0C6ppDZ0q4a5OseOa9ReibH13Uo9EKdNh10AgMG3/4Bls0gK1dC0DAtytXo3FrcqMp/D4l4k+bxX3dj9btB6DB7n0HsHDhPtmfr/GMJQ2SsaTJBgA6NLXb8PnnCxGq5fiqWvdnWxvqfcahQ7XucWfDpi1Y2LxZ9rHs2O3+nKujCYAGh44ci7vuSTT3al07AOiQpWXQOG0ABPzvm+XYkQKVXR/scp/DTrrWgHN3+ID7ev28dScWOn9NyvER0RPsXm3xjPs/fL8cRw65r33Npm1Y2LZF1j5/Oirg1W08G8f7oNc1W3DTuzX4Yz8XhhZTdD5TabUD3ET4dukSaATA2sjXjT/DVPtTVPuNxxpgRj8BH+7WoNHmvU/zDQzn9XDBuWctFu5R/SvTmuoKAa82Bz7b3BXiYgIu+vdKnFHpwsrDvue1wHNe1Xz21xxyzz/ZOoY2h4CDR5tSQtcsmevV9vZ22dsmvY+8f69zxljI/udycLlcKCsrw7///W9otVqMGDECBw8exGOPPRbSkL/77rtx++23i383Nzeja9eumDhxIvLy8qI+lkRgt9uxZMkSTJgwAXq9HjuW7gD27ECfnt1QXT0o5OdWOzdj/dF9qOzRF9Vn9UngER+/LPi5Ftj0S8Tteg0+EdVDoquVX7HjKLBuLboXZWPa2eMBAP+pX4vdvx7FgKqhqD6xU1T7jRX/+5SIP3esXgKAYeiAvvimdgcKSspQXT1c9uf3frMT2PMrenbriurqwQDcUf77134FFwSc9puJYtsyf3Ys3QHs3oH+vXzHoXULt2DFob3o1rMPqif0lX0si979Cag/hL5dO2FbUx10pmxUV4+X/XklxHKvrtvbCPy0GsV5ZuQYtDh6qBVDR4zGeL9U9mTwr6e/B9CGi04/EVOqKnzea/lxPz7buwnZReWorh6WnAMkFBPqXmWMYeYq9yJ0ysSz0LxmP5bV7kBpp/DrAo7TxfDwP78FECyFWoAA4ItDZtx52amqR+fCHVO8I4OElz0N7cCP3yHboMXZUycCAH5etBVrjuxBcZdeqJ7SX9H+4rkGqAZwp4th5N+WotXqRK8SMxbePI7ujxBUAxi+8RAeXLgFhyTZNpX5Jsw8qy/eX7sfP+5pxBf7AwNPTTYBr23T4l8XD1UtK+foqr3Azi3oWpKHLXUtsEGP6upJquw7GlJhvcozw+WQNEO+pKQEWq02IPp++PDhgCi9EiorK6HX633S6AcOHIi6ujrYbDYYDIaAzxiNRhiNxoDX9Xp92hgd/FitTreXLMcY/tiLPfUvTRZH2vzGdKeyIDvyRp7tor0me4+5U5p7l+WI+8gxctVylvRrnU7PVDrDGIPdMxYUevr/2hRef65Hl2XQiZ/T6XQwaDWwOV1odwCFOcH312pzf7gg2+jznVkGvbhvJcdi8/yWYk8LJIvDGff7KJp7tc1z0grMelEk0OpM/nN3uMWCXz3aGaf0Kw84ntK8LABukaFkHyuhHP971WJ3gpey55qNyM92PzdtNnnPzY87jvqk0/vDs8fW72/B2N7xd1LFWyCWCITLKeSYvON/eb57nGhoj36ciNcaQA+Ic56TASZj4Fqf8HL2iV0wpncpRv71fwCA+VeNwtjeJdBqBEwd2hkjHloStE0sLwP96xdbMWVIZ1WcJZ7lAirzTdhS1+LWc9Joodcmt7FaMterSr43aWfJYDBgxIgRAakLS5Yswcknnxz1fseNG4dff/0VLpf3Bty2bRsqKyuDGvGZRrtEqTYcRZ4a+WNtVA+ZKBIhzMJbz/WU9IjONnKxOyoSO16QtjzLj7L9nKhaLxG7EwRBFLBrCtMixqta7zsZmaJsP8cF5LhIZ6q2n+MigPlZepg9z11bCjx3Kz1t5wZV5okK9VK42F2qtJUiYkMqHhVN+7lUUrZOhEAsEQi/V6RZVyUep3CqiN1JcThd4pxFop3ysDo93WC0GozvWyoa5T/vbwpqxHPUblHHxytpJ4RIgrqEl6S6O26//Xa8/PLLePXVV7F582bMnDkTe/fuxZ/+9CcA7pT36dOn+3ympqYGNTU1aG1tRX19PWpqarBp0ybx/euvvx5Hjx7Frbfeim3btuHzzz/H3/72N9x4440J/W3JwqtaHz7ZopAWbglHqxEwe1rwtEZu3M+eNigmD+fOI76K9QCQ4xE7SxX1bCL+BDXko2w/Z9T5OgXzs9xjS7iJ1qtaH7z9nNJj4RM9NziVqt4nCu7cKMgyiAJj7bbkP3ffe9rO+avVc8QuJjQfZAR8HaDXCtBrNd72cxZ5i+NUUbZ2uhjmLtgUUiAWAOYu2ERK+nGg1U+xHgBKPRlRR1pSb5xol8wJzRYHHE5lc8zxCG9X7d/lKtGOPL4eyDbqxA4bjdRLXjZJrZG/6KKLcPToUTzwwAOora1FVVUVFi5ciO7duwMAamtrsXfvXp/PDBvmrd9bu3Yt3n77bXTv3h27d+8GAHTt2hWLFy/GzJkzMWTIEHTu3Bm33norZs2albDflUw6PC1nso0RIvK83RC1eUgok6sq8fQlJ+Lmd2p8Xq9QKU2QK9b3ChqRT75BQSQGacSbR1SsCo1fbiwbdb7+XrGXfBijIFREnu/L6lC2yOrwTPTcAWl3MtidrqSn3vnTKGm7xxWf21Ige2CFJyJ/cp+SoO/z+aDZ4kjJ80oog2ewZOnd6wClEXmePVbXZAlqRAtwz1nxbuu1eldDQCReijQymIgU/+MJ7vThhhWQ2hH5dr/Mp2aLQxzXiOCEyuBNtCOPrzVMeg0KzQa0WBzUgk4BSRe7u+GGG3DDDTcEfW/evHkBrzEW2fM6duxYrFq1KtZDS0vEiLxeZh/5FInAOF0Mq3c14HCLBWW57gVCpgqVDO1SKP53SY4B/7pkuCq/12J3Yv+xDgC+EflsMcWXDPnjBZsYTdfA5BkLlBrP3tR6/4h85F7yzR08muM7xYjHEmVPe95HHnAbK6lmcEpT63m0oz3Jz93eo+3Yf6wDOo2AUT2CG175WXpoBMDF3JEQHnkj0pMOMTPP/bx5I/Ly7kWePXb9/HUB76mVPSaHVErxP97gjv9gqfUN7TY4nC7oUmj89c98OtZuI0M+Au1+4wQn0Y48i8TxWGDWY28DReSVkHRDnlAXr4ct/KWVRuRj7RQQK8ebkM3+RmlbCUG1SMKeo+1gzG088X6vgHcibkuBFF8iMViDGPJK09F5VN+oDxGRD2fIW7yRaSk8Im9RHJF3evanEw3ODpszIOKfbKSGPB9Sk6VNwZ2jH9ccAAAM7ZIvOvX80WoEFJgNaGizoaHNRoZ8msOfF74O4A61cFk0/kyuqsTzlw/HjW+th1MSQFEre0wOqZLifzzCnT5SZ2xRtkEcfxvabCjLS53z7q+bQhHdyHSEiMgn2pHnjchrUWCmbGGlpI47jVCFUA+mPzwib3eypKZcH49CNgcbvb+1Q0Xjeme9J62+NMfHMUNid8cfVk8qulGvFQXmlBryvG7NP7U+T1ZEPkRqPRe7izLNP0uvFY2TVBS8a5YY8smskV+0oRbjH1mKS15ahffW7AMAbD3UGnY8LfQIoKZKlhYRPXwdwJ143BhrtzkV1Q5PrqpElueZ1WsFvHPNGHw368yEOdgTIRBLBMcrducdw7UaQQwC1adYer1/xiEJOUdGDPzpAx283JEnDQoBbkfe85cPV3UMsEjWKwUy1heEL2TIZxjtIcQr/MkyaMX0+2QNeMerkM3Bxg7xv9vtTlnlInIQhe5KfNvckdjd8YcYTZdG5BWn1vsaA5xIqfUuF0OL517zF7sTW7JFGZE36bXi8XSkoCHPz0mBWS86HBJdIx/KOdpqdYR1jhZ7WpRRJCT98a99lQqWKXHc2xwutHr2ZXcyjEhw7/ZECMQSwWm1BtbIA9I6+dQaJwIi8mQIRiSSvTC5qhLvXjsWgHstES9HnlTTgzuUaR6SDxnyGYbciDwgaTmUpAdGiZBNJiE15BlTruAdip31wQ15qpE//uCGskGnEY1np8stECd7HyEi8pEM+VabA9w3FSoiryQ7gDEmPiMmvVYc27iwZyrB6/rys/RiSUsia+TDOUc5oZyjhdkUkc8ULH5idwadRszMkVsnDwQupuWq3qsJjwya/Ep84hEZJLy0BkmtB6TK9SkWkffLfKLU+sh4S3BC2wv8uWMAxvYujovTTCp2l+/JFqYaefmQIZ9htMt4MDl84ZasnpvHq5DNAYkhD6hXu77ziDe1Xgqp1h9/2CSt46Q17koMaIsY1fcdSyKl1vP0coMkG4DD92VTEJGXRu9Neo3XkLelXnsh3z7y7uNM5HMXi3OUeslnDsFErHhUXkmdvP+9oMQJoCaTqypxkp9Q41MXDyMjPo4E6yMPeCPyqZZa769aTxHdyIQSu5Ni8DjybQ6Xatmj/vBsQZPOG5GnjAr5kCGfYfDBLFIfeSD5yvXHq5DNQT9DXo0UYcaYNyJf6p9aTxH54w2p2J00oq4kpd1bZ69M7I4r1gcTouPefSXHIXU+SFPrU6E/uz9NPjXyia/lj8U5muz5gFAP//ZzgDeyqigi73cvKHECqA0fb7j2xJrdmZWpl2q0BOkjD0CsmU61iLz/fEAR3ciEaj8nxSDpTOCIU5mr1UfszmPIkyNGNmTIZxAOpws2T+qsOUL7OSD5veSPRyEbxpiP2B2gTkS+oc2Gpg47BAHoGTK1PvVqion4IK2RFwTBqxavICJvlUT1pURKrfcq1gc6E41ijbyCzACPQ0GnEaDXSiLyCgXz4o3F7hTPWV6WXjzORHaLiMU5muz5gFAPLqLqa8gra0EHBJbdJSsiD3gjdGcMKAMArNp5NGnHcjzAU+tzQtbIp5Yh769FkkxD3uliWLnjKD6pOYCVO46mrM4THyfCdbkySAIBSjLpFB0HdzwaNKJqPTli5EPt5zKIdsnCNpLYHZD8CEyq9KpNJI3tdnHQKs8z4lCzVZWIHRe665SfFZDOnOMZpG1OF2wOl8/ATGQmPJrOr7VJr4XV4VKkxyB1BkjxGvLBF/WhFOul+1JyHP7RxawUFbvjv1sjALlGnehA80/5jCex9P+l1PrMwbsw9s4FebwFnYKU1YCIfBLTXfnCfkpVJT77uRY/7j5G81kcafGI3fmn1os18ikndueejwrNehxrtyfNIZlO7ZTF1PowgT+9JCKvRGNHCTzAYNRpUZDlXu+TIS8fGgEzCL6w1QiBi+9gFKZAv8bJVZW4p3pgwOuZKmTD6+NLcozi+Vdjoe9tPZcd8F620TtIU3p9eNLFkx4JnpnDI+DRtKCTCsxJyZOk1germWu2OHy2kyK2n1MUkef97D2GvNjWLbUMeR4xzMvSQ6MRkiIyKVX59nd/RnKOFsbRkM+U5ypdCF4jz1Pr5S+Qj6ZIjbzTxcRMn5N6FKIo24AOuxO/HGhMyvEcD/CIfF66ROQ966hOBVkAgGNJMATTrZ2yHHFsnUYA72Ycr4i8dK3hjcinlqMolaGIfAbhrXfR+fQRD0VRiqgU55t9F/yzJvXHtaf1zqhIPIfXx3cuMEHj+X1q1PqGaj0HADqtu07a6nCh1eoQF+yEL+nkSY+EVTR+vRF5QJkBHSkib3O6I/z+2T/eiHzg9MIV9O1OBqeLyXrGpWl3gCQin2Kp9dL6eMBby9tmc4AxJmtMVgOu8u1/L1dEuJeLuGNX5fkgk56rdIE7v6QldnlRpNanSo18i8UudsIoMBswumcRvthQh1U7GzCie2qV3jldDKt3NeBwiwVlue7sl3RbyzDGvGJ3IQz5+hStke9ckIWNB5vRlGBDMFI7ZQHujiETBlWkzP0gp0ZeENwlbTaHt3RXbaQZRN5500kZNzKhM5RByO0hz+EGXbL6yHM2Hmjy+bssz5QyA53acEO+U0GWqmJYXqG7nKDvi62wUiyKmSqkmyc9ElKxO8BrQMtNaWeMeffhJ3aXbdCKz2ewOnlvjXzoiLz7GOXdi2JrGs9v8KrWp9a93NTua8ibPc+ciykT91ODyVWV+G7WmSjxjPEPnjM4Yv/feLQjzbTnKl0IG5FXkCHS4LmnuQ+qOUkReZ5mm23QwqDTYGzvYgDAyh2pVSe/aEMtxj+yFJe8tAq3vluDS15ahfGPLE27+9zqcInCZgGq9bneccIRJ8MuGniNfOfC5ETk07GdcrtoQIeP6Rq1XuV6tXG5mLhfk06DXJNeHG8aOygqLwcy5DMIvrDNlmnI8whMsvrIc37xGPLc6Eh2hkA8OegZ6DsVZKmaIhwutR6gFnThiORJB0L33k5V/IXqlKa025wuMQLmn1ovCIJXuT5IhC6car1UOM8q06lg8av35YuOVI/IS6OhyShp0WoE8DM8qmfk/r/ckLfYXapkCWXic5UudIRpP6cktZ5H5CvyTIo/qya8bIWn3Y7p5Tbkf9zTELd0X6VkktOKR+MFAWLAgVNkNkAQAMaSv3aU0m71RuQB9/ygpJQsVtKxnbJX7C68zaD3rM3tTvXHat/2su4gAZ9DqU5eHmTIZxBeL7y8iglvRD55g7HTxbCpthkAMNozOfvX5WUSB3wi8uq00XI4Xdjb0A4gdEReVNAmQz6AdPSkR8I/LV5pRF46uQbT2winXB9OtV6rEaDXCgHfEQ6xfk7nK3aXatkl/oa8RiNInrvkHGu7zIUa38agojM1E5+rdCFc+zklUXV+H3QvNrs/G0LgMt7weln+bPUty0FxtgEWuws/729MyjFJyTSnFXfY5Bh0YgkgR6fVoDibt6BLnbUanw/K80zghxyqs0o8SMd2ynL6yAPeFnTxcJp1+LWXBYACMuQVQYZ8BiGn3kWKtN2QK0kTzM76VljsLpgNWozsXug+ngw25KU18lkqpdbvO9YBu5PBpNegMi/4JEG95EOTjp70SNj8UuuNCsXupNFyaR9ZDk+bbwoy0fJFYLCIvPuYuFNBWWo9/w18fEtktEUOjX6GPOBt65PIFnQcp4uJThA5c4IgCJI6+dgXUJn4XKULwUSsomk/x4VwexRnez6bnIV1kxiRd/8GQRDEqHwqpNdnmtOKZ+7518dzxDr5FBK84+uoHKNOzNxIpJBzOrZTFseJCO2quYM3HjXyfB43aDVi1hgJ3imDDPkMosMuP/oCeCdFF0ueiA1Pqx/cKU+cHJIZkY+3uvKBY9yQN/uIYcUCT6vvUZwd4D3nUGp9aNLRkx6JgBp5vbKIvLcdjCaoSBsXsgsake8IrVovPSa5EXn/6KJJpUwWtWkOYsjzjhHJOFZppCNcn2ApatbJZ+JzlS5wo8YULCIvM0rJGBPn4m48Ip+s1Pp2X0MeAMb0chtEq3Yl35DPNKcVV6zPjWDIH0khwbs2SfYRv08Sqf/EO4aEavsJpF47ZT5HRJofeBZdPCLy/o56wPucU0ReHqRan0HI6QkpxajTIseoQ6vVgYY2m+gFSyQbDrjT6gd3yhdV9DO1/6fV4cRhz8TXqcCkmmjXLo9ife8QafUAReTDEUvv7VSFR9R5yzavIS8zIu/wtoMJhqzU+hCLQKUK+v5t8MxpkloPSCLySUit584DQfC2H4yEt5d87Av0THyu0gVLkAW60vZz7R7VaEAakU+u2F1+lneNItbJ7z4Gq8Ppo7+RaDLNacXLL/yF7jglOZ7U+lSKyHvG2GyjTpKandi15OSqSlx8Ule8u2afz+uROoYkC9mp9WK3mXgY8oFrDd6aWW2xu0zoKBEMMuQzCDk9If0pzNaj1epImvG84aA7Il/VOR9F2W4vbzLE7rhQjf+CkwvVqNHT/lCTe9Iz6jQoyjaIqtaxLvJ3iIr1wYXuAG9ksC3FjJ9UgHvSr5+/LuC9VPWkRyKwRt6TWi/TeA7Veo4jr0Y+fEReaXZAll8f+VRLrfdP/wWAHP7cJcGB1iFx7MptfeftJR97JCTcc8VJt+cqXQjm1Ffafo7PwwadBuWi2F2SDHnPgl76bPUpy0FJjgFHWm34aV9TUh1C3GkVKr0+3ZxW3tT64GN4KvaSl0bkvYZg4iO6zG8R+cYfT8K4PqUpOc4FE8UMhiGOEflgeh58faFm54FMboNKqfUZBDcI5YrdAUCh54FZtKEuLqnk4XC5GDYddEfkT+jsjcgfTfDkkCihmgNifXwWBMErhMVLIqIlkmI9QKn1keC9t/0N14p8kypOnETDa9kMfqn18pXig7ee44Q15MOo1kuPSXH7Oc+xqNntQU3CRuSTcKxKNVMAoEhMSVXHmcqfK53fIlavFdLyuUoXOuyBC3Slhjx37heZDcjP4kJ5SU6tlzxbgiCIArmrdiY3vV6rEXDrWX2DvpeOzuBWz3UOlVpfmssN+dSoYWaMieNddpJq5Dk8OMXpW56bktfd4fT2hZdbIx+PiLzVb34HJBF5lQz5TOooEQwy5DOIdoU18os21GLrIbcR+NLyXQnvebr7aBtarQ4YdRr0Ls0WI/LNFkdcBoxQJEqoRtpDHvB6IGONyO/0pNb3KqHU+liYXFWJzgXe1MeqTnkRe2+nKmJqPRe7izIibwqRrhqq/ZzLxbxid0FU6wHlTgUeNeC18XzRkWrt53gaZ16K1MjLTZuUImZFqbgAnlxViVJPKu7Vp/SETiPA7mQoCyHMScRO8PZz3raNcuZXHpEvyjb4COUx/5BjAuDPljQiDwBjU0jwboXnGHg9MScdncHc2ZMbMrXeI3Yns0be6WL4YVcD1h4R8MOuBtUDRlaHS9ynOyKfnBprq8OJbYdaAHjvg6Mp4uzwp10yf0aaI/TaOIrd8bWGxJngrZGP/dxlWkeJYJAhn0EoSa3nHip/walEeqg2eKLxAyvzoNNqkJ+lF9uGJNKTmiihGq8h717A8ih5LDXyLRa7OJn2pIh8TNidLuxt6BD/brE6UtKTLgf/PvJKjWfx8xEi8v7CWW02B/h8GFq1XplTweLnVMhSSVtCbZo8mQipUiPvVSSWn6HFs6IaVF588prby0Z3x++GdQYAvPLdLlW/g3ATKtImVSBvlRGVlxry/Fl2ulhSMmG8HSF8dXx4nfy6vceSWmqzaudRfPrTQQgC8N8/nYwHzhkMwF1Lno7OYDG1PpQhnys/tX7RhlqMf2QpLn/1R7yxXYvLX/1R9YCRdC4wG3SqGoJK2H6oFXYnQ4FZL2oWpWo7ZX7ONELoEjqOqFofj9R6W2CNvJpid5nWUSIYZMhnEHIjMKniodp4gNfH5wFwp6cVqNj+SC6JEqo52OQXkVdBtX6npz6+JMcY0nACvIY8ReRDs+doGxwuBl5OXNtoSVpbxlgJqJFX3H6Of16Z2B032AxaTUihPKPiiLx7O/68eEtSUseQZ4wFVa1PZiYMH1eUROQLVVSt59idLrG0oCBLjz+O6wnAXc61/1i7at9DuOkIEWnTazViFpic9HpuyBdmG2DSa8TyiGTUyfM2l4V+EfnepdkozTXC6nDhp32NCT8uwH1/z/5kIwDgstHdMLRrAcb3KQHgHuPS0RncYuWq9aFq5OWJ3SUqpZmPdUadxncdmeCI/Aa+pu2Uj+Ic9YRD44G39EoXUUMlrhF5e7CIvHqlEZnWUSIYZMhnEHJ7QqaKh4rXEp3QOV98jasmH03g4Jeo/p8HGt3nnBvy2YbYI/JcsT5cfTwgFd1KHeMn1fj1sLvMZGBFHrQaATanK6X65CqBR9T9a+SVq9YHnyLyQhnyHeHT6gGv8J7c9nPeiLzvb0mlGnmL3RsFlXb/MKvUYjIaOsSaUSWp9dyRqp4hL83ayMvSY1CnPIzrUwyni+H1FbtV+x7CDTfkhSCRNrEFnYxad2+NvB6CICj6rNo0ikKSvhF5n37ySaqTf2PlHmw91IJCsx53TOwPwHucLdbElgmqBXfWhOojX5rjFSYOFfBJZMBIWh8PSGusExsN52vawZ3zUOwpU0rZ1HoFjl6xRj4e7ef85nfAq4URTINHKZnWUSIYZMhnEO2iamf4VMpU8FAxxnxaz3G87Y8SN/hxdeVgqClUc1Aidgeos8jnQne9Ixjy3GlAqfWh4er//StyUeGp303XiKHNL7XeqLCPvLfGXmFEnhvyYbJDjAqdCha/nth8fLNJ6iKTDT8PWo2AbMnCiC8s25PSfo6rAStJrVdfJIqfm1yjThxDrxrvjsq/u3ofjUkqE65bQV4IbYtg8M4FPEuDf1Zu+zq1cLlYyBp5QNJPPgmG/OEWC55csg0AcOfkAaIBL2296V9+lA5EErsryjZAEAAXC71WS2TAiGc88TWV2Ec+4RF595q2qlO+JCgVn7Ws08WwcsdRfFJzICqhaiWluIY4RuQ7bIEReTXF7hIVqEsmZMhnEHJT61PBQ7X/WAeaOuwwaDXoV54rvl5kVj8iJAeuruzf+7osz6iKUA1jLEDszhyj+rbTxbB6t3sS1ApC2IGcxO4iwyPyfcpy0LnQfY32H+sI95GUxb/GXWn7OUuU7ed4an1uiNZz0n0qjcjzcU3apiZV0ut5e6z8LL2P8ZTMiHy7TZn4KSAZf9vtqpWVNIlZGt574vR+ZehVmo0WqwPv+/VcJmKjwx56ge7tJR/5fuRzcLHHIPFG5BN7L7dKdDfyg4wr3jr5xoTUyUsNqD+/9xNarA4M7ZKPi0Z2FbfRaTXi+UpGC7RY4c61UGJ3Oq1GHCtCCd4lMmAkRuQ9Tl41a6zl4nC6sLnWY8h3zhefG7X1RgCv7sAlL63Cre/WRCVUHaxFZSi4IW93qu845+sAn/ZznuvXYXfG/EwnKlCXTMiQzyD4BB4plTIVPFS8lqh/Ra6YtgMARTnx9WKGY3JVJWZ46jc591YPVEWopqnDLg6clfluBwmPLLbbnIqVgPlAvmqn25Cf/8PesAM51chHhhvyvUtz0MVjyPOWgemGt8bdo1qvVOzOHihAI4UbZRa7y6eNnDciHya1Xq+0/Zy/cJ9G1DFIhhp8MHgNr7+hIUbkk1AGoCTiwuERRaeLqZZCHawtn0YjiLXyr63YlTKZFZlAe5AIFydXQQs6aY084M2ySXSEmT9bJn1w3Y1eJdkoyzXC5nBh/d7GuB6LvwG1/NcjAIApVZXQ+BkC3JhUIz040URKrQci95JPZMBIjMh71r7S1PpEdVnYUd8Gq8OFHKMO3YvMKPacH7XXsmrpDihpT6rXue9tuc53Jfi3lwXc6wduWKvx/PBAnb9jKh07SgSDDPkMQm4qZSp4qHgtERe64yQrIs/hgwY3FH5QSSeAG4QlOUZvirBn0nG6mKKUpWgGclKtD4/LxbCj3huR71KQIRF5bvxG2X4uVEQ+16gTnxHeNx7wpuzmhY3IK0vz92+lJQiC6L232FKj/jRY1BlIbklLe5Be4pEw6LyRRLXKm4IZ8gBw/vAuKDDrsa+hA0s21anyXYS3FCV8RF5Gar2kj7zvZxN7L3t7yBuCvi+tk49nen2oeRcAHlm0JWDeFbOWEpzerQZi+7kwJVIlueEF7xIZMPKPyHND3uFiCRt7eXBqUKc8aDRCXPSe1NQd6LDLK8UFAIPWPZbEQ+8hmNidIAji86NWmdfkqkqcN8LdMeU3A8vwzjVj0rKjRDDIkM8glERguIeKDzacRHmofglSHw8g7nVFkeCDxknd1a27O+gRupP2KZeKEsqtoY12IBdT66OI/h8P1DVb0G5zQqcR0L3YLKbWH0hzQz5Q7E5mOrtfH3p/NBpBjNBJPebcqA9bI69TGJEPIobDDfl2u7qLtGj7HfNzUOBnrJqT2Ec+mog8oL5OSTA1f8DtYLhsdDcAwMvLqRWdWvDMvGAps3lRpNYHROQTXCPPy1aC1cdz4m3Ih5t3Of7zLnc88ONPJyK1nwMiR+R5wCjYOVM7YORfVmrSa8S5L1Hp9WJwyrOm9arWq3f91dQdkFuKC3gj8nFpPxfEkAfiUx7BhQdP7l2Csb2L0zqdXgoZ8hmE0prIyVWVePGKEQDc/YMT5aFijElaz/ka8vEY/JTAxVEmVVVAENzpUoebY6/hOuARTeP18YC7zoxPNu0y64CiHcizJdH/eKRHpTs8rb57sRl6rQZdCs0A0je13it252vIW2Wr1odOz+VwZXofQ16MyIdLrfcci9wa+SALjnj0ko+l33GoqDOPECVH7E5+xEUKj2bFOyIPANPH9oBeK+DHPcfw5qo9UQs3EV7CLdBzZabHu1zMq1ov1sjLT8tXk8YQZStSxvZ2G/Lr41QnH828m5+EOm01YMwbxQ4ldgd4leuPhKkBn1xViT+M7R7wutoBIz7WZUuytgoTfP43isEpd5ZpURxq5NXUHVDi6DWKNfLxiMgHL+PjTnE1Ow9wPYfSXKNq+0wFyJDPIJR42Djc46oRNAnzUNU1W3C0zQatRsCAilyf99ReRCqFRyF6FJsxsMI9IKvR1uZgk2/rOY4oeCcz/SvagTxbspinOvlApEJ3gLezwP5j7WmXweCSlGpE3UfeET4iD3gX1s0+EXkZqvU6ZcdicQRO9DzaqJYhH2vdYUhDnrd9TEJEvi3GiLxaKY3iuQkSUS3PM2F4t0IAwF8+3hC1cBPhJVxEnteIRjLGmy12UWCu0C+1PtE18t7Wc6HHlB7FZpTlGmBzuvDM0u2qO4OimXe9hkh6GfIddqd47sIZ8iUeYyiU2B2Hj0MGrXttOb5PseoBI95W1yzJIChUsRd5JFwuho0HfYNTJZ72cy1Wh+zss0ioqTugqEaeq9YnqEYeUFe5nsPbCZMhT6Qk0kirkgiM0v7SavDLfveA17csJ8ALl4z2c1L4oF+YbRC9/FxQLhYO+CnWc7INysSwoh3INRrBq6BNveQD+LXe15Cv9JRAWOyuuNyLsbaOCYdUb4GL3InPudwoOBfLCxORD6ZcL69GXplqfUcQdV1+L6uhWq9G3WGkiHwynrnYU+vjJ3bHWbShNqgOiVLhJsKL97oHrgPEFnLW8NeWl7blGnVi1pi3/VxinVJNvPVciBp5APhyY52opv/M1ztUdwZFM++mq9hdq+c8aoTwiuaRUus5vNzh3GGdALgdQWoHjPwj8gBUr7EOx+6jbWizOWHUacRWwHlZOug8v1OtNYSaugNK2pPyMSC+hrzvvZYfhxaCFJEnUhqpIahk4ZaVBEN+w0Fviw5/pNGgZERCufev0GzAWBXr7rw95H0XBFkK21PFMpCbqZd8SHZIFOsBtyBbeZ57sFc7vV6N1jHhkCrT87YxovEch4h88Bp5Gan1Mur1GWPeVngSjz3fhxpq8GrUHYYyVs2SiHyixzO+uM1SmFrvNeTVEWkKJQTIHSjBUCrcRHgJVXMKyBes86+Pl3424TXy7eEj8jybxl//Q01nUDTzrlgjnwBDUk24QyTHqPNppelPSU749nMAsK+hHfuPdUCrEfD7EV0AADuOtKk+FrYFKSPiEd1EOFL4mnZgZR50njlXEATx+TmqUnq9mkLVHQpKcfVx7CPPn1t/p5EYkVdJY8Jid4rjHndCZQpkyGcIfPIWhPCLb3/4w+NwsbjUvwSD18efEMaQtzsZWhJscNocLtHILTIbcFLPImgEYNeRNtSFWejLwb+HPCdbYa1vLAN5ThLTfFOdHX4ReUCaXq+eIa9W65hwWJ3esUDvSWdUGpHnRraciHyz0oi8gvZzVocLfM0XNCKvgiGvRt1hqPRxHpFnTL7QoFqIkVkZfYKleMub1FkAh6pxVlO4ifDiLbELXAeINfIRDHn/1nOAt1wm4TXyYUoz1FTxDkc0824wR2c64K2PDz2GA9KIfGhDi2fbDOmSj4EVudCAoc3qRJ0KukNSuAaJtPVyYbYnoqvSOBaOjSG6MBXHQbyZC1X7CxEq1R1QUoqbmIi873hVoHLXB+5wMug0YQMN6QgZ8hmCdNEWzovqjzTKpUaaqhxCtZ4D3AYHN27VFAmRA/ecawR39CE/Sy+q6scSlbc5XDjsGUT8DXlvRF7+uecDub8HM9JATi3ogtPYbhMXIzwiDwCdueCdSoZ8ohadVoniPB8LTDqv2KEch50lQvs5wGusB02tD1sjLz8iL93Gp0ZexdR6NeoOQ0Xkpc9ooh1oSmogpRRlq5uSGurcqCncRHjhC+NgqfVy28+JQncS4zlPQes6NQnXfi6RziA+7/p3pgg174pid2lmyPPrG64+HgDKPOnJDW3WkHPWyh3uddPYXsUw6DQo9Sx/uCaNWrQHKScpSGCNPBe6q/LrwuQVb1avBR3gvhenDvHebxeO6KJYd6DdLn9+MMRR7K4jRBlfgVndeUisj88xKrKR0gEy5DMEr3dNmafJvdh3/3ci0usPt1hwqNkKQXCnIQWDRwEaEpySxr+vwGyAxuNZ53XyfEKKhkPNFjDm9gQW+7X74xG7DoWL/MlVlTi1bwkA4PcjusjqOMANeRK784UvKjrlm8RzBABdeAs6lVLrE7Xo9O8hD/g67OQ859YQSrJSwqXW54dVrZcfkeeTvFYjiOl9gLeuT43UejXqDptCRJ01GkF0TCb6uYtG/BQAirL5Aj2+7efUFG4ivPCSilhS63k2Br8XAK/jjj/jiaIpTPu5RDuDJldV4s+T+gEATuicF3beVTuimChaJan14SjKNkAQABcLPVbwAAhvD1ie5Tb4tx9S15BvC5ImHg/V82AwxiTBKf92yu7nR63UeikHJeuSwmyDYt0BJRoqYkQ+jn3k/QNTBSqL3WVqfTxAhnzG0KHAuyZFEARvnbwt/qmf3HPZuzQnpChfcRzadsiBp2AVShYMvE4+FuX6A2J9fFaAJzArBgE6HsU/uU+xrI4DOWTIB4Wn1feWpNUDvsr1apCoRac1SDTd12EnIxIuJyLv10fe5WJiNEdWRF5Gml6oSV5NsTs16g7DCbqZxecusYJ3HWEis+HgEXm128/5RzLVFG4ivHTYuOhtsD7y8trPeVvPea+Z3Gi+2ngj8oHPVjKcQdzJ2acsN+y8Kxoi6RaRl9F6DnC3z+VlOMEE7/Y1tONAYwd0GgEjurs7U5TziHx9/CPyhQk6/wcaO9DYbodeK6Bvue8aojiO4s3SAEM0WZZKNFS4E93uUF+vJGT7OZXbB5IhT6Q80aZRAt4HKBGp9RvC1MdzCpOkXC8q1pu9UfORPQqh1QjY65mUosFbHx+4mBAj8lGcez7h5hjD17KJ3yWm1pNqvZRf/YTuOJ0L1a2RT9SikxvIBokRLgiCorZv0YjdtdkcYssqOar1co7DIvaz9z0Obx95dZxSPG3W3xCXU3fIGPMaq0Gihjwi357w1Hr5YkZSxLZNKoy/dqdLdDj6n1upA8XfFFIq3ER46bB7FuhhIvJWhytsvSuPIPqK3bmvX5vNCUeC9HSA8DXyyXAGcYdcpEwXryFigyuNBBt5tkZOhBp5wCt4F8yQ59H4IV3yxbUHj8irnVrPgxPSGvmCOKieB2ODJzjVrzzXJwsOkNTIqxyUYoz5lPxFY8gr0VDhawlrHJ57a4g5Xm2xOzLkiZSnI8o0SiCxyvU8BWlwp+Bp9YBENTnBqfXS1nOcXJNeTJdaFWV6vWjI52cFvJcVQ9ptqycyEikFjiOK3VFE3gf/HvKcriqn1idq0WkLYYRHEwlXklrPBbQMWk1YB4CS4+Djmv9xZMXB+Ti5qhJXje8h/l2aY5BVd9huc8LhWagHjcjzFnQq9byXg9PFxEhHtO3nWqyOmMWNpJHfYM4d7kCpyPd1XikVbiK8hFsLSOeKcJF1b418oGo9kDidFcaYmJpeYA6skU+GM6jd4yiJZADxscDFgNY0EpiVm1oPhG9Bx7MYeXkiAFR4DPkdCaiR5+u4eKfWi0J3nYKIN+eoL3YHuAUGpfNnNGs6ZX3k3c+PPQ5id8HaywLS9oF2VbocSGvkMw0y5DMELlyRrTCNEvDWzyYmIh+69RwnnulI4fC2nvNdcMaaXn+g0Z0qzSO8UrgHOZpa31aZKXDidxkotT4Y/j3kOVyYsMXiUEV5WM3WMeEIViMPeD3eakfkeQSnWWwzFr5tkbdGXo5DIXjaXZYh+ucmHIclrZQaO+whnS5S+L2h1wpBo6DJKGmRjuVKU+vzTHrxHoxVaIifm1yjLuR9PbmqEt/NOhMzxvUAAJzUo1CxcBPhpT3Ewhhwp0PzDJFwdfLBVOv1Wo24z0TVybfbnGJdbrDUeiDxziAxkhnB0DXpteJYl0518q1WXh4Vedzg0U3/FnSMMfyw0631wuvjAaDMswQ62mZTdX0n9pGXRuSz1E3NDgXPMg0m3lyscitPjn+5XzSdJKJSrY9Hjbwj+BzPxx6bw6VKxxeKyBMpjxoR+Xgb8g1tNjG6OShMRD5ZqfXBFi8AMKaXO0IareBdqNZzgHeRHU3arRLPOUCq9cGw2J1i6ry/IW826MTopFrK9d6OA75Dr5qLTquoAuv7HWL/dplt34BAZ4AU/4g8X0yEq4+X7lNWan2kGnmVDfm6Ju+Cy+5kPoZ9KKTt1YI5MMxJyITh44kgBKYsRkKjEURnZqxjcKge8v5oNQJG93Qv+B0uRun0MWCJoJeTK6ONHHfg+Iuz5mUltpc8T6s3aDVhI4fcGXTFmO4AgJN7F8fNGcRT6+VEMtOxBV1LVBF533Fi/7EOHGjsgF7rrY8HAKMW6OwpMVQzvZ5fk+wgqvXNFnvMnWDCwXvIDw4SnCr2nB+1I/L+WYLRdERRoqESL9V6u9MlXhuT31oj26CFTiWHMkCGPJEGRCt2B3gXydY4G/I8BalnSXbYxX6yIvLBauQB4KQeRdBpBBxo7MC+BuXCZwclYnf+mKOMLDpdTEzVlRuRJ7G7QHbWt4Ex94LLf9EKqK9cD7gXnSf3LhH//vt5J6i66AwVTTeJBrSS1PrIEflWqwMOp0uMyOdGMNqMiiLywY8jXroedc2+11mO0GEkYzVbdNYlLrVemq4YTasdterkw4kA+lOW515gHW5WN3p1vBEuIg/IE60L5dSW4wRQE54WnW8O7iSTotUIOKGL25gy6jRxcwZxDQI5ay3eMi/eUWE1EbV3ZKwrREPez+HJsxeHdikIMBR7l2YDUM+Qd7mYOA9IA1m8Rp6x+DlSDjdbUN9ihUYABlYEBqeK4iTczIMPfH3SGlVEXv59HK8+8tL52z/wIAiCqsr1ZMgTKU86iN3xtPpw9fGAdxGpthczEnzR6p9an23UYYhngaA0vZ4xFiEiH50hL/XAyplwARK7C4Y0rT7YQlFt5XpOi8SZUlmQpeqi0yaK3amQWh+mDlTqQGq2OCQ95COknEp62kcSzeoIUasf7XMTCR6Rz9K6owRyHDihVNk5/FgT2Uc+lvkAUE+nRIkhX57njtQdbrGoUhN5vBLMqJHCn9vmEIt/m8MlGupFfk7tPFNiI/JNYRTrg5Ens71eLHgj8pHnXW8v+cSuZWKBG4W5CsTu6v1q5LmekDStnsNFZdUy5KXrVmlEXq/ViMGLePWS55pPvUtzgj5vxRK9ETmZcHLhGYIDKnIBKF/TuSQaKnKyePVxisjztYggBC/jK1Dp+WGMUY08kfqIrST0ymvkTXr5kbpY8NYSha6PB4DiHPVUk5VwTKyRD4zMcsEWpYJ3TR12MXJemR+oRh5tan2rj7CYvMV6NondBSAK3fkp1nO4Ia9Waj1HutD0j2bESqiIvFHmc84YCymYJ0UnWSg1ddi9NfKRUuulPe0jePhD1chzA1VNgU6bw4WjnlrGnrluQ1JOx4JQfdI52UnIhIm2hzynSKWsqEjnRgpfYNmdLO5K05lMpDI7bqCFMsZ5FFwjBGaZJDwiH6YbRDDyIvw2NVDSfztRddpq0qJARLckNzC1njEW0D9eSh9PRH774ZaYjxXwOkiDlRGp3cLMn0iaT3kmvZgermaGKQ8s9BcNeWW/zyJxKiiJyMvJolMCb+Vo0gXPHCtU6fo1W7zCrRSRJ1IWJZOLP1lxqjflOF0MK3ccxQ+73IP74MrwEfmibPeDlnixu+DphIB3Qlq186iiaBGP6JXkGIIqgEcbWWxVkP7GEVPr00hBN97sCCF0x4lHaj3gq+btH82IlVA94I3iZBz+XpNO1uEMecC3BpRH+HgdbSh4vR0QuZwnVESe/61mRN4dCXaL1nV1rzVlGfKRos5eB1riU+vNUTh2AfV0SpRE5A06jehAONRsiel7j2fEMrsQ1z4vK7wxzrMwCsyGgEwhMZqfoJpvr/5E4JwcjEQ4GtqVpNab069Gnq8tZInd5QSK3e1r6MDBJktAfTyHp9arpVzfLqmP9zcGxRZm8YrIHwjfhUmjEcSxVM0WdHw90q/cbchb7C5FLSGl86Z/bXow4lUjH6mEL1+l0hR+f+aadGE78aQrZMhnCO0R0unCYdLFT7V+0YZajH9kKS55aZXotb3jvz9h0YbakJ/h6XytKqcjRUKsCwwSkR/ZvQh6rYCDTRbsVVAnf9CjWB8srR6QRuSV/U4lgjQcErsLhC8mepdlB32/c6EZgHq95DnSiJG/4m+shFatlxeRt0rejzTp5UkNeZkReY1GkO3h94rd+U5V/LlR0/nIjcfyPBOKTDwiL79GPpSxGougZbRwZ53ZGGVEXqUaedEQkxlRLfNES+SIDBKBMOatFzYZgi/vItXI83mwKIhDO5ITQG14Sq3ciHxuAlLr2xWk1hfE2ZCMB6KIrgLV+oY2qyhaxqPxJ3YtCLoe5an1B5ssqmQptYWp9Y53L/mNBxPfhYkxJq5HBkjq8pU4ir1tXTXQyCjri3eNfCg9j0Lx+sV27jK5Ph4gQz5jUCMir7bY3aINtbh+/jrUNvlGVw43W3H9/HUhjfm8LG+romNtifFkO5wuMaLoXyMPuM/RiV0LAChTrw/XQx6QROQVTmhiRF6BIZ8ssTuni+GHXQ1Ye0TAD7sa4qogqwSni2HnkTYAQJ/S3KDbiKn1KkbkXS7m40wJ1oM3FrghbvAXu9PLS0fnzjONADEtMBT5Wd4InVgjLyP6yiP9kY4lVD/7eHTa4ONURZ4RhZ75Xs5158ZGyIi8WCOfhIh8zDXysY2/SiLyAFDmqZOniHx0WB0u8ISxUIZmJGOXz7n+9fHSz6ZsjbxEgDNe84wS/YlMV63n44SLeY2tlWHS6gG3cc1r63lGXCzw65Ed5Hjj6UiR24WpWOwlr848f6zdLv7m7sVmMVreqsBR7L2H5a0f+Xe4GFR9rkKVznHUymjJ5Pp4gAz5jCHVxO6cLoa5CzYh2CPPX5u7YFPQQUEQBIngXWIiM42SgSLUonNMFP3kwwndAZI+8grPvRKvufe7uCGfOIOCZ2Rc/uqPeGO7Fpe/+iPGP7I0bEZGotjX0A6bwwWjToPOhcGvD3+9oc2mWkS1xeqAtDpD7Yi8zRk8tZ5n3lgiZLnwydUYom5Nik9qfYf8lEyeLSA/Ih9K7E49p1Sdx5AvzzWh2OgRuzvWEbGUpsnzu/ODGD5Akmvko0ytL1Kp/7Hc9nOcch6RJ0M+KqSZXaGiXHli+nmoiLz7mhdmB16zSJ9VG57RoTQiD0Sn5C2HcBFgf/LTrEbe5WKiQShH7E6v1YiBjyOt1oj18RxeyqaG4B0fV4NdD7VqrIPBuzD1KDaHzULjpaJqpdZzvZ7SXCNMeq24BlRyv3s1teTZC3rJWkLNqDyf30OJ6haolBlGEXkiLfAq1UYvdqemIb96V0NAJF4KgzsCtnpXQ9D3eTpSoiLyYpubLD102uCPxdgo6uQPiIZ8oNAd4L1e7QqNay5ukqsotd6rnp0IVehQGRl1TZawGRmJgkcDepXmhFSNz8/Si4tDtQTv/OtLVU+t54Z4iJZtEVPrHZFbz3F8a+TlG20mmS3oRKdCiBp5i90Fl0oRAh4Frsg3osDgFk+yOlwBPZL9iVwjH90zHgtKWgsFw1sjn+iIPKXWxwKfww1h2q9Fisjzax40tT4BqetSxGyXEE4yf/RajTi2xCtroENBNNOrup0ehny73Sk6meW2tfW2oLNhb0M7apssMGg1GN4tsD6eww357SoY8uGyj0RDMA4RebELUyTxZpVT63m5F9fv4es6JSWTSjO2pLo2NhXr5Dsi1Mir9fyQIU+kBV5xo+j7yKupWn+4RV5EJdR2fBGRqIg8X7wES6vnDO9eCINWg0PNVuzypGRHIlwPecCbdmtzKhMraYkmIu9ZeDAW/1aDsWRkJAoeDeDiO6EQW9CplF7vvwhWPbU+ZI28x3iOmFof/PPBEFWipYa8jEiO3NT6UDV00gVIpAwDuXCHU3meCTqNt147Unp95Br5xLefizm1Pgl95AFvC7p0Tq3n4q6f1BzAyh1HEzrGdciItEVMrW8PrRXDnXSJSq1vVJhaD0RW5Y8Fm8MFh+d6ytGf4H3km6KICCfjPuKZFjqNEFHolMONo/pWS8T6eE4fFVvQtYVxrMSzawCPyFd1Cm/Iq9UBhHPAb02ZY/SWk8hFaQavXut1CsYjIh9qvCrIUqc0ItMN+ejy7oiUI7bUevXF7spyg0eg5W5XlK3OQlIux8Io1nNMei2Gds3Hmt3H8MI3O3DusC4Y1bMobA9wLnYXKnVbOtm1253IC5EN4E80NfJmgxaC4DbkW60O2fVR0aAkI4O39ks0Yuu5EIr1nC6FZmypa1EvIm/xRrwa2mw41m6HzeEKqGmPllCq9XJr5L3pbgoj8jy1PoJqvfvYlKXW+3vspRN/h82pyr0sRuTzjGCN7oXSoWYr9h9rF/UxgiG3/ZzaPe/DEYv4KQAU5Xj7yDPGIpZYhIKfG7mGGJ8P0jUiv2hDLeYu2OQz9lXmmzB72iBMrqqM+/d32NzPU7h1QK4xvKEbTuwuEWJyUpoUtp8D3FkD9S3WuByjtJRHTtAk2j7YybqPvD3kAxXgQyGNyHPjdkyvorCf6VPm1qRRQ7meX5PsII4VXh4Sax/yYHiF7sJ3YeI18pEyu+TChe66eIR4c6JoK6x0fhAEAQatBjanS1XlemuEGnm1SiOoRp5ICzpiWLjxRbGaYnejehahMt+EUFOBAPfENKpn8AFfbS9mJBrDRCE4izbUYnOtu/fp+z/uxyUvrQpb7213unCoJbxqvUGrEQXFlKTeRlMjLwiCGJWPd518rBkZieDXCK3nODyFTS3lem7cdC0yi04gNTNPQvWAN8pUiufvy2lLk28OklovIyIvNzsglMdeI4kYqWUg10lU6wGgs6ccJpIDR1qWEwzvM5d+EXmbwxWTSF/UqfXN6WfIp0IpkZza10jK89ypHdyQ92bgJAJvRF5eaj0Q3xZ0fKwxaDUhS/CkRFMjn8z7qCWKtraiId9qxaqd7lLJcPXxgHfO3dPQHnNnorYwXQS8Ndbq3q8tFruYlTk4QkS+WCW9EQ5fh/DgEA/mKKmR7xBLr+RfZx6VVzMiHym1Pp9S62VBhnyGEE65MxJiH3kVDXmtRsDsaYOCvseN+9nTBoWMZntT6xNjyPPU+lCefz65+qcvhZtc65rcfakNOo04mPsjCIJ4/pUId/HjUFIjD0h7WsfXqIg1IyPeMMbEaEAkQ15t5XreHSE/y6vee6RFvfvcGsKQV6parzwir0S13nMsMmvkg3nsuZEa6ffIgTGGQ03uyb7cY0yKJRVhDHnGmHg9Q40diXrmpLRHsVCTkmXQiouraLOi7E6vE0Bpav3hFktCdDzUIlVKieQ49OW2nwuWnZaXgD7tUpS2nwPi2+u+XWFbR37cVodL1jiV7PvIq1gv/3yX5Lrvkx/3HENds6c+Pkj/eCnleUbkGnVwuhh2H5HfzjcYYkQ+qNid+qr1ThfDf37cBwAoyTZEHNu42F38auSVtxUWxVAVOHp5xqCaEflQXWk40usXy3xAhjyRFkTqxxgOvqhWsyczAEyuqsTzlw8PSKusyDfh+cuHh00RE1PrE9R/lQ/0wVruRDu5Suvjw6WpZUfRS74litR6IHG95Id0yQ9bYxcpIyPe1Lda0WxxQCMAPYrD18jzCfOAjJ7icvD2W9f51BeqRagad6NMLQyvan3k6YEb7bVNFvDbX1aNvMyIfEeYiZ6PdWpE5BvabLA5XRAEb/qdHAeOtM1VxD7ydqdqwnyRaIsxIg94x8JoF6BSQ0quaj0/93Yni1vv53gQq7irWnTYIq8DvC3kQondhZ4Lpe3n4u1osdid4liUryS1Xsw4iIchr0yLKMfobaUrp4VWsu8jaWq9XPgzu3bPMQDAid0KQhpmHEEQ0Fsl5XoxIh+s/VyWOhFdDu/C88BnmwEAR9psEbvwiO3n1FKt98xHXTzzE79WUdXIK7AX9Fp5GX1KkNt+zu5kUc/zThcTsyHIkCdSFhfzPhCx9JFXU+yOM7mqEn84uQcAYEzPIrxzzRh8N+vMiHVeYkRepcEvEuGiENFOrgebwivWc7yttKJJrZe/wAHi00veX5SnucOOa9/8MeSALycjI97wxUPXInPERUdnlVPredQjL0svpiWqqVwfKqIut/2cV7Vefnslnn6u1wqy1O5NMdbIA5BkssRuyPPnuzjbKEYe5KTW88W5QacJeb54RJ4x9YT5IhFraj0gqZOP0pDn5yZXYsxEwqDTiGN/OgnepUopkbyIvPuZtTlcAWnNjLGwNfLcSLY7maoL+mDw+0erERRlnsVTWV80gGQejyAIitLrk30fceeHkvPtf5/Idc6r1YJOzJIIMv7yiG67zRlzCn+0JQ88G7PF6oj5GJo67OJ9zdcl0ZRuRTM/xCUiz9caIcr4svRa8XujDeodbbPCxQCN4J7fMxESu8sApPZ3NKmUWTJTbqOFG0Cn9CuVLWyW6Ig8j/4Eq5GPdnLlQned8oPXx3PMkrZwcolG7A7wDvpqReSDifLotQLsTgazQYtrT+mF937c5/N+RQLFn0IhptWXhk+rB7yR2cMtVlgdTllq7uGQ1pLbc9wPr1pCOICk/Vy0qfVKIvLcKPBM7nkmvSyRJO5kkKtaHzQir2JqvbT1HKeTmFrfHlLwTU4NeJbeKzLZZlVHmC8SYq10DN9VGGNEXmkPeU5ZrhENbTYcbrFiYPKGCEWkSimRnMw86ZzRYnHAmCMRjrQ7RQM9mFM726CFRnAHD5o77LKcfdHCDd/8LHljCieeqvXRtHUsyNKjoc0mK7072fdRq8Ia+UUbanHfxxt8Xnv7h72o6pQXcX4XDfn6WA350M6VXJNOvF8b2+0oz4vufo2UlSnAnZU5YVBFgNMyz6SHViPA6WI41mZHRX70zwx3KhdlG8R5JCeGiLyS+YG3oFO1Rl48juBrDUEQUJClx+EWKxrb7egSvmIjKLxssSjbmLTAUbyhiHwGwHXLBEFe72d/4qFaL2VfgzsluWuRWfZnkid2F7jojHZy5Q6MUEJ3HLPePZgqKW2IJgUO8KbWqyF2F8pDbXe6p7ubzuiD2yb0w3ezzsSsSf0AuKOccjIy4s2OerdQTaT6eMB9L/KFMXfOxIK3llySWq9iRJ4b1f4q+HL7yIuq9XLE7vyMNLlGm2zhPc+xBjNM+HOjRkS+TlSs9z6rPCLfZnOGTIttktEey1dkMjG1xbG0I+XE6kxVKnTHKUvDFnSxiruqRYeM2letRhCNef+oNZ9vDTpN0JpjQRAkhnJ872U+JytpPQckJiKvpIRRiWBXsu+jFgXrCj7/+zuhj7XZZInycSf69kMtUR6tm3A18hqNoEov+VhKHjQaQRxLY201618fD0jE7pRE5O3KHVLeiLx6JTXWCBF5QFonH51jjivWcz2iTCTphvxzzz2Hnj17wmQyYcSIEVi+fHnIbWtra3HppZeif//+0Gg0uO222wK2mTdvHgRBCPhnsaTPokApno4znsiPco9TvCPyez2GfDcFhnyxuIi0J6SutCFM+7lIkysQfHKN1EOeY45CDCvaiHw0rUqCEc5DzXlz1R44XQxajYBxnkwMi92VEl5RsYe8DENeEAQxjU2NFnQ8UpRr0sfFkPdG1P1q5BWq1isRu+PkyXQscadCpGORE5FXwwFZ1xQYkTfpteLkH6qsQq6xmuhe8rG0I+WoFZFXasiX53Ll+sTP2dH27o5V3FUt5KbM5oUQhOPq3kVmQ8i1RCSxPLXghq+S+nggzqr1VuWiwtwRIaeXfLLvI7lid2qI8vUtd8+9O4+0xSTeF65GHlCnl3ysJQ/FKgWm/HvIA9GVS0YzP/AaeZtTPTshUo08IHWERXfuMl3oDkiyIf/ee+/htttuw7333ov169fjlFNOwZQpU7B3796g21utVpSWluLee+/F0KFDQ+43Ly8PtbW1Pv9MpuSoYycCHlyNdtHGH6J4ROQtdqcY7equwJDnXlSni8UlRc6fxjCp9dLJNdT0eU/1gIDJlRvyESPyURgkfBGlpE0MoJ7YXSQPNeDroS7K9kYlEiX4FQ7RkJeRWg9Ihc9iF7wT+62bdN4a+Rg99VIi9ZGPJDAXSiwvGAadxic6pTwiH137OelrHSoYx9yQr/Qrg+ns6dUbqyGf6F7y0agS+xPr4jP6iLzHkE9wL3kuZHXJS6tw67s1EduL+jO5qhL3nR1ohJXLEHdVi/YIKtCcUMYub4MZzKHt/9lUjchLBfnUxluyoiC1nkcUZRoik6sq8eylwwNelyMSHCutVu5kDr+uUEOUr0uhGQadBjaHS4w0R0O4iDzgFUyLRbk+1pIHtTJMvT3kvfNUdojsmnDEolpvc6i3fuOOx3CZxPz5j1b8lAz5OPP444/jqquuwtVXX42BAwfiySefRNeuXfH8888H3b5Hjx546qmnMH36dOTnh+7dKAgCKioqfP5lMmJEPkZD3mJ3qa5EywfoXKNOUQsZg04jTibxbkHncrGwqfWAV4G/It93oOa2O0/V5jDGJIZ8JLE7ZenujLGo28+pJXan1EOdaMdMOFosdtG5JCe1HlC3l7xYI5/ljcgfUVXsLrghbpJZl+5NrZc3PUgNNTmK9dJjs4ZJ82eMhRW7i8YBFgr/HvKcLpI6+WAojsgnKrXeHrq3slwKYzXk26OMyCchtV6t3t38+g7vWiDes6/+4aSElRLJjciHiqp7e8iHvmZ5iYrIh3GuhyOejgbuKAllNAYjml7yI3t4i4FzTTrZIsGxIq4rIhjyaojyaTUCepW4O8bEInjn7dAR/JgLzd7szmiJteRBrdR6nhHoE5H3XCsl2V7RiN2JfeTjIXYXxvHIr19TlI6Y48GQT5rYnc1mw9q1a3HXXXf5vD5x4kSsWLEipn23traie/fucDqdOPHEE/Hggw9i2LBhIbe3Wq2wWr0PWHNzMwDAbrfDbk/tFjh2ux02p/sBy9JpozpeneB9MFs7rKoK2Ow87K5/6lKYBYdD2cRaaNajxeJAfVM7uhXE7yFsbLeLrbOy9ULIc3hW/xKc3vcU/LjnGA63WFGWa0R9sxUz//sLnv36V0waWCoahk0ddnGCKc3Whb0uJp37+rVabLKuX7vNIR6vUcsUXXP+XS0yvysUxWZ5Q0ex2f3bNcwJk5bB4hRwqLEd2XplqYFOF/M57yO7F0adXrittgkAUJpjgFkHWeeh0hMl3He0LeYxgaezZusE5Jvcz9rhFqtqYw03fjVw+uxT50l67LA7w34Xj3AbtPLOTZ5Jhzr3kIkco0bWZ7hd3mELPcZaHS7xPtcJroDtDPy56Yh9nK71ON1KJM+q3W5HpSfVfl9D8Ot+zBPBzDGGH3v5gqm5Xb3rHA4epdJrAs+bXPKM7ovU0BbdMXvPjbx7gsPHlromS0LOldPFMOfTjRGErDbi9L7FEcecL35xG/y/H9kZb6924ZcDzdh5uBl9S8NnZUWL9F4FgDZPRNWgCT2PAd5OCsf8rm29x3lSYNKH/DwvzzrWGt97ucFj9OSalK1ruC++pSO2OS4YLZ6oulEn/57O9TxH/uc6HAcavIEBq8OFkd3y4HI64IpzQg93vmXpwt8/Sud/IPBeBYDeJdnYUteCrXVNOLVPdHX/3HkWai2U55ljj7bENp7cO6U/bn73p4DXBcn7oa4RDxAdifEY9h1z3xcVeQZxP56fh5YOh+x9e8cJeXM8AOg9Y5/Fqp5d1CHOU6GPI9fzAxuiHG8ONbvn9mJz6DHNn2D3aqJR8t1JM+SPHDkCp9OJ8vJyn9fLy8tRV1cX9X4HDBiAefPm4YQTTkBzczOeeuopjBs3Dj/99BP69u0b9DMPP/ww5s6dG/D64sWLYTbLTwdPFjaX+wGztrdg4cKFij/v1q5w3woLFn6JMM54xXxbKwDQQm9rUnxsGpsWgIAly1fh0Mb4pWMf7gAAHYxahv8tXiTrM1oARwEIDBhUoMGmRg1umvc9bhrshEYADrS595mjZ1i65Muw+6rdpwGgwcatv2KhdVvE726yufctgOHrJYuhRBZhr+d6bN+1DwsX7pH/QT9cDCgwaNFoA4IXHDAUGID6Tauw0N1yFTk6LSxO4POvvkHvPPnf9dNRAR/u1qDR5v2eAgPDeT1cGFqs/L5YXe8+BwUai+x78vAR92d+2XkQCxfuU/ydUo62uO/r9atXIM8AADq0Wh34eMFCxJAJLdJude9/5XfL8avEfjhicX9Xm8UW9ndv2+m+H/fu2omFC3+N+H3ODvf3AUD9QXn31c6D7vO5c3fo7dsd7uMFgK//twT+CQJ1+93HuWHrdiy0bI34neE40OD+DdtqfkCTZ1dLlixBY537ONdt2Y2F2BnwuZ895+rw/l1YuDDwfU5bo3u7lT+uB9sb39ISdztS93lb+e0y/BLleP5rEwDosO/wsajmlY2/un9z3d6dWLhwh+zP7W5xf+/ew41RfW84XAzY0Syg2Q7k6YHeeQw7mgXUNYd+8NxpwlY8894i9M0Pfe2OWoDNdTpowODa9xMMVvfv/3LFOjj3xPeaL1myBACwY7f7O3fv2IqF7VtCbt9y1L3d6vU/I/uQ1zj5ca/79eYjB7Fw4f6gn232fHZNzS/Iq/9ZvR/hxy87PM/WvvDPlj987j3S1Kb6/bPJc35r9+6WfUwHPHPulp17sXDhblmf2dDg/gzgVgn/5LOFiELHWDH7D7nHwa0bfsLCgzUht4tm/ufwexUAXI3u37ls3VZ0bvbbUCZNre5jXrPye+wLslw/dsh9zdZt3IqFrdF9B2dGPwFvbtfAzry/Od+zFnHuWYtQU9/RA+7f+dOWHVho3x719+8+7P6tu375Efz24/d7Q4v8+/3QUfd+NtSsg2O3vLHpmOe5X1vzE4y1NcoPPgh19Z7j+Gk9hH3Bj+OQ59xt2L4LC5n8eYSzdY/7uPf/ugkLGzcq+qz0Xk007e3yy02S3n7OX1AlVJsfuYwZMwZjxowR/x43bhyGDx+Of/3rX3j66aeDfubuu+/G7bffLv7d3NyMrl27YuLEicjLU2BxJAG73Y4f3/4fAKBTWTGqq0dGtZ9Za5bA7mQYf/qZqMxXT09g3cItwO69GDWoF6o9yuVy+aRhPXZvrUfPASegemQX1Y7Jn/V7G4Ga1SjNM6O6+hTFnz9xXAemPP09drS40FY+BBeN7IKvthwGfq5Bz7J8VFePCfv5nV/vwFcHd6C8czdUVwcXuvHZvr4NWPs9ck16TJ06SdGxtq3dj492b0JecRmqqwPr8JSg73EIN7/7U0AkS/D870PnDcWkwW5Hnd1uxxO/LMURK9B/yAhMHFQOOXy58RBeWxn4HU02Aa9t0+JfF3u/Qy6bFm8Hft2FkwbIO98AULm3EW9sX40OTRaqq09V9H1SGGOYuco9OUydeCbKco2Yvf4r2BwujBx/hk/tW7TcsXoJAIaJv/F9lg+3WPHg+m/gYAKmTJkScpz95sMNwKGDqBrYH9Wn9oz4fZ80rMeOrfUAgBMH9UP1ab0ifqbhh734ZM8WFJdXoro6uN7JoWYLsOZbaDUCpk0NPN6t//sVy2p3olPX7qiuHhjxO0PRZnWgY+VSAMDvz54Io4ZhyZIlmDBhArJ2NuK/u9bDYcxHdfXYgM9++d5PwKFDGDlkEKrHdg/5HV+2/IRNjYfQZ8BgVI/pFvWxyqHV6gBWuX/PtCmToi652n6oFf/atAI2wYDq6jMUf/6zt2uA+sM46cQqVI/qKvtzBxs78MSG5Wh1ajBlysSY1gNSvtx4CA8v3IK6Zm/2XUWeEZMGlQGI7JzrNfhEVA8Jndr86ve7AWzDqJ5FuPCck1C39Fes/XonjCXdUF09OPYfEAS73S7eq3q9Hp8eWw8crcfwISeg+qTQc+YqxyasO7ofXXv1RfWZfcTXV366CTiwH8MG9kX1mb2DfvbHz7dgTf1edO7RB9UTggdH1OCLd38CDh/CSUOVPTP7j3Xg0Z+Xw8q0qK5WNj9G4vuPNwK1B3DCwH6oPj3yOAcA9pqD+HD3BmQVlMhenzWv2Q9s3ST+Pfa0s1CWgNTgp3/9Hmhtw+njRmN0BGV8Pv8D8Jmfg83/QOC9CgDChjp88d7PsBoLUV09Oqpj5vPdlAnB1667l+3EstpfUVTRNebnsBrAD8+txMbaFlx1cnecMaBUVnZg4+p9WLhvM7KLylFdHTo7OBxtVgfaPPPURdMmiuUP+46149Gfv4Md8u/3f25dDrR34LRxYzCiu7yebl80/4QNxw5hwKDBqB6tzhz23M4VQGsrxo8dJQoi+9Py434s2LsJOVGeu6e2fw+gDRPGj8aYXvKyPoLdq4mGZ4bLIWmGfElJCbRabUD0/fDhwwFR+ljQaDQ46aSTsH17aC+Y0WiE0Rg4SOr1+qRdRCXwGvlsoy7q4zXptbA7HXAwQdXffMDTrqtHSY7i/RZ7hMCaLM64XocWzwksyjZE9T09SvX488T+eOjzzXj0y22YWFWJw63utJjOBeaI+8zNctcAWRwuWd/f4UndyjUpvz/zzO5z2m6X913hOPvELtDptPi///yMFkntb6g+8dl6d6Jqs1XedztdDH/9YmvYlNe/frEVU4Z0VpRmv/Oo29PZrzxP9jnoXpoLADjUYoWg0UKnjS480mr1lkUU55phMGhRmmPEgcYOHLM40TPGa+J0MbE9TE6W0ef35XjWOC4GCFqdqELrDy9bNxvl3V8FEmGsgmyjrM9kG92fsTtZyO2dcKexmnQaGAyBdbI5ntpTiyP0PuRwtJGngOtQmJMlprTp9Xp0L3Ff94NNlqDf0eLRtSjKMYU9hhyTOscqB7vFfUyCAOSajVEbwqX57vBWY4cdGq1OcSkLr1EujnBu/KksdDse7E6GVnv4em25LNpQG9TpWNdsxeur5GXYVBZkh/0d/9vidmZNrqqEXq9Hn3J3EGBvQ0fcrzlfq1g9QlS5WeHnsnzPPNBq8x2LG91pMCjJC33NeM1qmwpzSDjE+ydX2f1T5H5kYXW4wARtQBvOWLA4+Ngqf61QnOt2zjZbHLI/c6TNN622IwHjBuCtkS/IjnzO+fw/d8EmH22JUPM/R7qu7l9ZAMAdnNDpdIrHKpvDJc53+ebgx1zsEaBrUnD+w3HA81svOKkbBlbKC/SVe0RUG9rtUR/D4Qb39+Zn6VGU63X4F2a7/9tid8lem3R4Jvlcs7z5GgCMnpJbp4o2AtfzyTGFfp5KYrx+XJegsjDyWtyfZNqASr43aYa8wWDAiBEjsGTJEpx77rni60uWLME555yj2vcwxlBTU4MTTjhBtX2mGl6xu+gvp0mvRYvFobpyfTSt5zhFOYnpJc/3X6BQVEfKlSf3wCc1B/HLgSbM/XQjNJ5FryBAbMEWCi7SIlfRulVsEaP8emerJHbHmVxViZp9jXjhm504tW8Jrj+9D0b1LAr6e3M8hyv3eipRxh0bwpvrj9PFsOGAu0be5mQRrw2nNMcIg1YDm9OFumYLuhRGV3LD6+P1WkEUwyrJdRvyarSgs0naufmL1UnbyVnszpCGPFe1l9N+DohS7E4fuRVeuNZzgLdHeqxj1iGx9VxgNIe3HWzqsKPFYheFtDhKVesTIXbXIel1HUs0m4uTMub+nUVhlMyDEa1qvUGnQVG2AQ1tNhxqtij+Xn/ktMoMhwD3vRGud3d9ixU/7jkGAJg42C2u26PYLeS180hbyM+pDddGiKRzk5cVoo+8KPoaWbU+Hu3dpDRGKZYonRdbLHYxIKAGfI5WJHYnqqbLr3n1F4lrktGDXg1aFfSRB9zz/4RBFVi9qwGHWywoyzWFnP+D0aPEDI0AtFgdONxiDRAbjUSHZM0UKvOIj2Ny2v9FosViF69jVwVr2qJs9z0Yy1qWC676tzOWtkJsszqRb5ZhyEcQCAyGQWw/p6LYnZz2c1m8j7zyc2exO0WHYGmOepnGqUZSVetvv/12vPzyy3j11VexefNmzJw5E3v37sWf/vQnAO6U9+nTp/t8pqamBjU1NWhtbUV9fT1qamqwaZM3BWnu3Ln48ssvsXPnTtTU1OCqq65CTU2NuM9MhI9lSiYXf7IkyvVqwRiLzZCPsY+xXPjAXKSwX60UnVaDh887ARoB+PyXOiz4yS169MWGuogtjLjwULtM1VHeIkZp6zlAPdV6KXxxM7RrAcb2Di0IleM5vUdb5V1PNZRxpSzaUItxf18qOgf+tnCz7PZSGo0gdh+IRbmeL37zTHrRyCr1LDRjVbQFfA15/0iUUacR9RTCPedK2s8BfoZ8lrx7kjsZwinoR5rkxT7yMbZ04/dDRZBFZI6k2wbv4StFtiGv0FkXC2r0kAfcfYP574pmDG6O0pAHIKYRq6FcL6dVJieU+RGpd/eSTYfAGDC0S77YbrSHR5H7SKs17grvHB5pi6xaz41x/z7yXLU+nCEfvAe92vBnS6mDXasRxHlObeX6qNrPKegjzznU7DsXJMKQd7qYKNCrJEig1QgY27sY55zYOez8HwyjTovuHofX9kPKlevbRGFWTcjMC69qfezrSD73F5r1is4Rf55i6cB0IEjrOcA9z/Pf3ipjDckYE+9jRar1Yvs59WyEjjBdaTiF2codYRy+pjJoNbLXJulIUg35iy66CE8++SQeeOABnHjiifj222+xcOFCdO/urjWsra0N6Ck/bNgwDBs2DGvXrsXbb7+NYcOGobq6Wny/sbER1157LQYOHIiJEyfiwIED+PbbbzFq1KiE/rZEYvWI3cXSM1huayol1LdYYbG7oBG8kS0lqNV7MxI8ChFLRB5we0yDtUiP1MKIO1HkLvJbFHrNpYhtsFQ0KHg6XqSJLUfvPjkNbfIM1lh7t0rh7aXq/AwDJe2l+D18IAZDXtp6jsPboqgRked92TUCoPNbUAmCINOAjjy5SpHeh3uPtsMZ7CHwQ2w/Fy4iH6HHLM9AitWQD9V6jsMjIPsbAq87X1xEaq1pNiau/ZwaPeQ5sYzB0UbkAaDMcy3U6CUv19H3x3E9gmZlnDu8c8S2X4s2uksEJ1V5W93mZ+lR7Dl/u49E3ydbCR0yDU1vCznf+9Hbfi70XMjHrvhH5KPrIw/Er0VeexSRTH7/t1gdcMiMZnIHFne8NnfEf9xolYxN0QQJooV3+vnV0+FICaJBagx9v/OxOZb2c5x9nsCU0oy8Ek92aYvFIc7RSuFOhGBrab72apXxTEq7wSjqI69V35C3RMi6A4ACHpHvsCtujy1tPaeW1koqklRDHgBuuOEG7N69G1arFWvXrsWpp3qFpObNm4dly5b5bM8YC/i3e/du8f0nnngCe/bsgdVqxeHDh/Hll19i7NhAkaJMgq9jY4nAeCPy6hl4PBrfqSArZBpvOIoTlFrfKGPxEgmevhkMPvTMXbApqJHDU6PaZfaRl2s4ByMeEXkx1T/C5J/NU+tlTqix9m7lhEutjXRtpHCDLlhkVi48ipUnOVelnvtcHUPeG00PNnHxCTPcYkJJRH7Rhlo8/ZVX2X7Ogk2yshy8qfVhHAqO8Aap6ACLNbXes2gOJfLJIyD+193lYkEdM8FIZEReTJvUx74Y522TlI7BdqdLdBZGY8iXe5xbh1WIyMt1CE4YVIHvZp2Jd64Zg6cuPhHXeoQeV+44CnsYA6zZYsfKHUcAAJMGV/i819MTld91NDHp9TzClRUhtT43iCHvcjHR2JEVkY9jloHN4b1/IjnJghGv9H9uOEbTRx6QnyHAI/LdPZmMiYjI83WFQaeRnY2lBqIhXx9FRN7KSx1Cj3U8QNPUYVNsCPqzz2NMdy1SFpjKM+nFTIVjbdFdy/1iRD7QiSAa8jLWdVLHt1lBq2ke9Q83FirB5WLiWiOsIe95/p0u5qPFJAe+pirJ4B7yQAoY8kTsWEVDPrYaeSD2elMpsaTVA96UqHgb8nxgLYwhtV5JPbc/3FBpt8tMrY8hIi86DWxOuGRETmUdj+yIvPv/5UbktRoBs6e5VeWjTXkFYrs2UvgEymvVooEvfqW11jwir0ZqPTeMQ9W3m3SRS2i8hnz46YFnOfgvMuVkORhlHIeFR+RDLCrNYmp9bIt1fm+UhzDkOxcEv+4tVgf4ulBujbychVastMmIUsmFG3RK01KladeRnBzBKMvzGPIqOLeUOASlacK3T+iPkhwDapssWPhL6Hv56y2HYXcy9CnLQe/SHJ/3eHr9rvrEGPJyszGCpdY3W+yiMzOc8ZyXgBp5PqYIAgJ0KeQQr/T/aLJddFoNcj3Pv5w6X7vThaOeObJPmVu5L95lDIBkXRFFgCAW+pTyiLxyQ17O9eDrOruTxZyJyOeArgoj8hqNIK5nj8pc/wR8t8eR7F8jDyibX/ga36DVKBLtVTsiL83GC2fIm/RaMStPqc5BvWdNVaqiTkYqQoZ8BiCK3SnwrvkjGvIqRoxiNeSLVRAIkYMaqfWx1HOL0boERuQB74I/VtrkGvI6T2q9zBp5wC2m8/zlw8WFPafIrMfzlw+PmPIKqFdrr05E3lMjL6nXUjO1nhvGoYxwOZFwUewujCEfa5YD33csEXm1nI9iRD5Ean2oiDxfXJv0kSNYPIInVwcjFjpUqpEHok+t54ZYrlG52j3gLXNQo0Ze6hD0hx9ZMIegSa/F9LE9AAAvLd8ZMpq3aIM7rX6yXzQe8EbkdycoIs8z6iLXyAdG5Pk1zjHqwt7PiaiRb+pwH4s0kqmEeKX/82crW+HcKwreyThnR1qtYMxdGtWzJHERee7USWRaPSBNrY/GkI+cIZGl93YuOBbjWnJfQ/A6dTnwMhu5GkH+HDjG0/qDpdbLL92KtvRKL4rdqRMAkmb/miIEDbgTRGmdvDS1PpMhQz4D4Ia8Kqn1Kta/7PW0+epWHGVE3iNy0WF3qupg8EeN1PpY6rnN4iJfZo28aDgrj1QYdRpxYdQm03Eg/3hkRuQVRvcmV1Xi7avH+Lw2Y3xPWUY8oF6tvSo18mJqfZAaeTXE7jxpb6GEf5RE5MN5yWPNcvCm+IeJyNvDp/ib1Ra7CxWRD3HdldSAm8WSlsSJ3WWpkVofoyEfTTQe8D6L/qJf0cIdgnqtr1FYkW8K6xC8bHQ3GHUabDjQjB+C3MsWuxPLtrrbzvmn1QNeQz4RyvV2p7cVV+TUevd1abZ460551kVhhHZ//Jq22hyqZXX5I1d7IhTxSv/nzm+lQRMlyun8ni/LNYrBhXiWMXD4PB5Npl8s9PYY8kdabYqVydtkaBYIgiBG5aMRTJPCI/JdoghOxVIqarE7ccTjAAhuyMuvkY/W0WtQWeyOO+r1WiFiZgCfY5VmhpEhT6QNfB0bi7gR/6wlhSLyOUadmM6j1PhTQkNbbIsGILZ6btEgsctLd5dbkx70OARB9F6rlebLjydSlIKvDy12l+LIpP/1V6Jwq1atPZ9ADzZaol7A8sWS1MAp4ar1LbHX8FkjGL9yRC0jpecDsWc5yBHd64gQOVDDkLc7XWJJQyixO37d/bsViMZGVmQHYCIj8tEoEoeCdw5RGslqjEHoDvCm1quRpcKZXFUpquHf9pu+eOeaMfhu1plhHYLFOUacP6ILAODl5TsD3v92Wz067E50LshCVefAntJijXx9a8zPdiSkmSlyxe7sTm+dKp8HeausUHBDjzF5KtnR4H22YjXk1Ts+p4uJzkWlz5ZXsCvyc8SzUMryTOI8kZAa+Rja2sZCjlGHTh4nqtKofLuVrz3CXw8l5z8UjDFxDlCaWg/EplzPvzfHqAs6pipJrW+P0hnFnaBq1ch3RCidk1KgIKNFChnyRNpg86jWx1Yj774VUqlGXhAEb2pnlOlIkWCMqRKRD1fPHS59E/C9bnLOPx+so61lU1vwrlWmJ9+o8Xp1laaX8QGZ67dtrZOvcMuvTbBldKRrI6UizwStRoDN6Yo6eh5M7I4b8h12Z8w1fKIRHjK1XkZtegRnABB7loO0j3woA4d77EOl3UnF7qI1kupb3Gmseq0gpj7608VTI3+0zebjNFASkfcutBIodqeCIS9G5KOskY/WkC8XVestqhnAjDHUt7h/xwX/z96bx8lR1/n/r+q7e+4jyUxCSMIVCAECCZeC4BEMcdH12EWRZVVwV/CnAuKCi4qwuggq4orgV1ZlkcVjPRc2RqKAgByBhAA5uHIfM5lkzp7pu7t+f1R/PlXdXVVdx6f6mHk/Hw8eZHpququ7qz6fz/vzfr1f7+VHWG6Vdfk5iundn7YNYXuZIdcftxwEAFxw4hxdc0nWS34ilRPimm0G+959klrPakRLKKA6ohezvbz1XJUN7XBAlSp7Ja/nG0EOy92M2uu5QTs325bWR61nhId4F40wnydqI613rvRzy9EO5fVWMvKAGOf6sUSWr3XcSOutegRp2a+pj9cbZ9jay1Ign3UmrQ+Lzsiz9rIWzkOV1ttcN1KNPNEsqGZ37mvkRbnWJzN5blTkNJAHnC8krTKZziFXzK52uWw/x+Sb5RLdavLNSFDt722lbt1NRh5QFyEiAvl8QeZS3mo7+ZKkLhLtystYIH/SvA4AwPZDk7YmlFVL+/F3xcyalmrfjZaA38d7jTvtJa9ndtcSDvCMrdsMZDWjOiv3OdsMMGs/51blwM5DlsHlwOWkqmTk2eOybC7RN4PJ6me3ReAzCOraowF+be8fUw3v7MjHVdf6GmTkHS7U9OhxKa13GsizhVc2LwsLgMcSWV56YidDc/SsVrzrhNkAgB89tZM/ns0X8KdtSiCvJ6sHlO+AdUPY6bG8PqkJaqq1WvJpeq2zAG6ES+urz4NeG965aT0HeHN+7N6VpOpGoOWwGnkrATmT1s9pj/D7pzbt5yo3mWvFUbOUDa+1WwbxzPZhSy1MAesZeaeBoJa9RVn9rLawadmZET3FMc1Jjfw+k/p4QJ1frKzp3ErrRWXkUxbWGYxOh6URMyUjX/s7lhAON7sTUCMvKiPPBr32SMCViZybXUwrMMf6aNDvaHAuZ9XSfqxc0of1O0cwFE9hdpvqhmyEJEmIBf2YyljzArBak26ESAdt7caDlSxFd0sIgxNp2xszbEA+5YhO7Dw0hXg6h52Hp7C4r83yc7C1wQdPm4e3HTfL0ndTzryuKPaPJbFvNIHlC7psvQdA3+wOUNqjTA0ncHgyzeW4TmCbG8Y18kVJu4HJXL4g88DaLCPPVA5XPrARElCidrCictAuhFO5vO75pqrU6mulgclM3tH9y2SsRvXxgHJ/HtEVxauDcewbTXInaXs18qoPRqEgG24aiMCTjLzdQD7hLpAPBXzobglhZCqDgxMpV2opxsFimUd3S8h2e60rzj0Kf9o2hF9v2IfPrzwOPa1hrN85gvFkFj0tIZy+0LgsZ2FPCwbGU9h5eMrRmGEVtqFq9T5ojwQRT+XUQJ5n5K0E8gEcnkx7lpFn95brGnmB58eN7ixslJTTaSMjf5Bn5NVAvqYZ+RoH8ms3D+C3G/cDAB5/7RAef+0Q+jsiuOmiJVU32Kcs+oEw3wenrd8AaGT19rPxgDtp/X6THvKA+p1Zac+mmt3Z+55VsztRGXk70nr73VMUBZbqNzGdoYz8NEBEH/mIBcmtHdwa3TG6XDp9VoMb/Liojy9H28LIqnzTjhkW2zl3OuFyab2A7CBTBwT9kqUsBW8p6FBaP7stjOOKwfurgxO2nmPLgXEASvbMznej5QiXzvW873hZSyWWgRSXkTd3eje6z7Uu8tW+T6cKFECR/rK1cNrgXNQaOv3zCPh9XELstJf8YBWjOwbrWKBVYtgJNlpsls+4Qa2Rd78gd1ojzzc5XIyrbPElwrleeR7ni7ozF3XjpHkdSOcKeODZPQBUt/p3nTDHdBxZVMw27vI6I2/RsZ6hOtcr3xUL5K1k5Ns8coVniKqRF3l+bG52kjDptJOR18x1TO1TE7O7OtTIsxam5V4GVlqYAmrr0WoZ+Q4BNfJ7R1hW3GkXJudmd2oPeYNA3obKkn1mdnrIAx6Y3WWtbzyyccBO+7l4OsfXQ73TXFpPGflpAHetd+FSHBUsrXdbH8/ocdjH2CoiWs+JQDW8sy6td1ojzyY9EfW62tZzVrIU3S0OpfWTqkRqcV8bNuwetVUnn87lef3diUV5vhOOcOlczxZL5XJsUS3oqtbIV2n7pg2qrWzMOFGgAEqWOxzwIZUtGJ4Ln+hNFs6RoA+ZfMGx4d0gy8gbGN0x9FrQsRZZVrLOkaAPPklRhUxlcrZrbO0wJTAj3110Wp7K5JHKWlc9uJXWA4rZ16uDcSG95IHSTKddJEnCFecuwud+vgn3P7MTy47swO9fUrKIFyyZY/q3i4p18rWS1ls1sSoPdtlmjZFXhJZ2j1zhGW5r5Hn7ubTIGnnnJpLcbM3COmZIJyMfT+WQL8iOWvFZRfW6qU2NfLUWphKUFqYrl/QZvm+rNfIiXOuZynR+t7OMvCqtd1Mjr7+etuNan3A4P4jPyCvPY2W86nKQkWdrqbZwQEiZWSNDGfkmp1CQudmdm4uVm90Jcq1ngfx8l4G80z7GVhFhdCeCWMhaRl6WZbWPfAPUyMdtnotTeRkblHtbwzi+mJG3E8i/PjiJXEFGZyzIHXKdMM/Awdwqeu3nAI1zvcsWdNy13mByrJ6RVx4P+Kq3hGE4UaAAqmrA6FySFqR37L5xHMgXM/L91TLyOhs4doJVpVtEbVrQiZTWt4UDCBS/TzuLKBGB/Jzi5taQoIy81kTMCatP6kdnLIjhqSz+8cfP8zKZG3/3imnmkDvX1ygjb3UdwMYgNiY1Yo28U6Uc32gQWFvO7lsnShc7feS1G07aecJKkOaGWveRd9vCFND0kbdYI+8mIeTGsR5w61pfpUbelmu9M2WJ8Br5bPXuOAw79w9jptTHAxTINz3aWtdqg5kZfIFvkB2zCwvkF3Q7r/cFnNdoWkVE6zkRWO0ln86pvYKdSuBEutbz1nMWFzdOpbqHtRn5OUxabz2QZ7L6E+e2265v1MJ2xJ1I62VZVqX1ZTXy4jLy1czuihl5A+UNn1xtmjk5oZo6gO/Ymyw4tK0bncAC+WpZWianZAsqwH6wyurkRXWLMIK3FxIgrS/I6iLx8deGLJtQCQnkuXO9qIy8eZvBavx520HdjN7BibSpDHhhMZDfNTzlaQs6u22ljDLyVja1y2X5onHfR168a73TTCZgXRqczuW5ueOc9jBCAR//Pr2uk3fbDccubluYAtY3VzpEZOQFSevjqZwteXo6pxpHV6uRtxLI2y3BYbAyNlHS+qQNaT3biLEjrefJHwrkiUZHm4myYhphBFssi87Ii5LWT/+MvLU+09qB2mrwXI5QszuLrecYzHTGzq50oSCXBvLFjPz+saTlhdqWA0o9/YlzncvqgVJpvd1FeSqrbsKUyxdFBfJVze6qlNCkqxjMiYS9hpHjvFpDZzxNsedw6gY/aMHsDlBr5Eul9faCVdW5vkYZeZff4drNAzjntkf5+/zibzbjnNserVq3CoiS1ouukVf7c9uFyYD1YKPAzQ9t1d3oOLI7Bp+kfO+iNiX0SNnMyJcHu2xMttK9xYs+7VrGeNmKQ2m9RjEgavPEjbTeakZxqLjZFAr4+L1TK8M7XrJXo4y82xamgCYjX+U7cetaX9JD3qG0viMa5Go1O+vZgbEUZFmZB43KXuwkZ5xu9KoZeTH3kx1pvdo+0L60njLyRMOjunb6XDkhRwLmC3w7FAoy3710G8i7kSNZYbTBauSrLfInNYY0Tr9vkRl5uw76LCNvpwvBeDLLJ4+e1hA6YyEuj339oLWsvDYj74b+TmVRkczm8eBze2y1ymHZeJ9UufAQJq2vUiNv1eyulhl5ozGHByYmEz27b5yMW7Is266RPziR5p+RXUM3npH3uAWdm8whg5lQlUtfrZpQue0jD6gLeJZJdwszEZvjYGHnRgYcCvh4Fs9Leb1dyaw2GM/mCzwzb2VTu92DjLcW9xl55b3lCrIwA181++u8Rn48mTXdWGDZ5zntYa4cY+otrw3vam1257aFKaD5Tqqcc5fLPvKHJtNI5wrwSUB/h7NA3ueT+IbCsI31T7Ue8oCmRt5C2ZbrGnnhZnfW28+NJ7MoWFxvzZQe8gAF8k1P0mG9SznRkPkC3w5s0PP7JB74OIUtKuxKsa3C2pGIdK13gtU+05MuW88pr8Ukvu43bbi03mog70BhwQbkzliQ11Uv7lMCcivy+nxBxrYB5Ti3gfxjrw6B7Z/c+LvN+Mi9z1rOUvL6+GiwYkIWL63XHw/CVdrPparU2IuE1cYZZuTZpoLJuUQtboDpMZrI8kVJNbl1d0uILzgGxpTF9pjNFmt2ev26wWkNJKOaCRVgnH1miMzIu70nGEMuzO7cyoBrUSeftLDxpaVNk7VmG9o+ydp31uZBDTojp9lUcOpaHwv5efZTVACctGispgcLRPIF2VQJx8s/NFnoWmXk7frduIW1MAVQEcxbaWEKaDt0mF/zLFEzkcpa3njXsndECab72iOGajcrOFGYqvXxxkkxNZCvfo047iMv2OwubUNaz+6Bgmzdl4My8kTTwNouuZVRsptJRGuk3cXWc/M6o3wXzyks8BtLOhuAqzHaINJ6qwGJiF6vIqX1kzal9Y4C+Xjlzqodw7udh6eQzOYRDfqxqLfV8uuWw7KU5Zeh5Swlc6zXcQVmk83hyYwrKWhV13omZ2+AjDxTAVVrP2cWmERdjFusPr6nJVR1cSZJUkkLunxB5vei5UC+eN8lvDa7yzoPOAD3JlTZfIErxcTUyKdcy6MLBZnL2p0E8m5lwCyQ97IFXcrmAl1b5z7KvWJClswqvWyLppXrO71+JEniwY0o1cCUxaBRj0jQz8dUszptvc4K5aaEXjFpMj95hZsWpoD17DK7jmTZ2efIg2lRClMb7Xer9ZAH1EA+lS0gVyXQTtjsbsEIBZRxoR418uGAn3/HVlsI6q0bpyvUfs6MqSnAr3OR+f1AJFJ6nBE+HxCNOjs2kVBGHj0kCYjF+GK3E1nj5y4ey0kmgULpzRjNJhHNpICpsptU59gSWjRmdqkUkM9j//7DiGZSOLalpfScdI41JBYDJAmd0SBCuSz8hTzGDo3yFh56xwIA0mkgZxKgRqPK5wwAmQymRsYRzaTQrff5lR2LrMkEEImo14qdY7NZIJNBp5xBNJNCdiJeeh7hMBAI8GMTo8r59iBceb7aY3M55bPQoSOfQSCfUzODJscCAEIhIFic3PN55bsrkhmfQDSTQpecUc4nGFSOLz82m4U/pRwXzaSQzQDZZArBaPE+KhSUa02HkaFRBPNZdWe1UMCSdj+imRR27h6q/BwCAeWzAABZxqvbBxDNpHDKnA74kwnTY5Eo+32RfEHGrb/ZVJKljGbUz0ECcNuvN2DlgvOVhbDOGDE5MoZoJoVZvmDpOfvU2rdMvoCJw+PGcu0qY4Q8OYVoJoVYNqX8TnvfJxJoyaYQzaRQmJosPYfiGMGC6jY5Zz5Wae9lB2MEALQX0ohmUsjF48BUW8WxhURKfS965xKL8Q2w9GTC/Hx1xohDg8OIZlJY0FP2fQQ006LmXj4qJuFAJoXBgcOIdyrXXyoYUoONKvd9S/FppzI5R2OEIWVjRCE+iWiugJZsCpjyGR9rcN8PD40o96g/gJxfOdZfyCOUy1Ych77iNa4ZIyYmU/zeaC9kgKmy92k0RpQxSyogmM8iiyBGE1l0RwOGY0TF85aNJ8PxNEKpJCQJ6JWyQFqydN8DAAIBLgMeHEsikq38zCQAczrCOKO/bKFfvK6ObZEQzaSwb/9h9VoTsY4ojquYmkJ2Io5oJoW2QtnnbbCO6JQziGRTiKdyfGO1L5C3tI5oiwQRzqaRHo8bH+9wjBgfUeaUtnAAgZTO921xHTHbn8W4LKsbA9XWBlXWEbni59tRSCvvxeraoLiO6IwFMTI6iYnhMSCsv64bKgaMs9vD/HlnSTlEMylMjYyXftYuxojyY7P5AjA1hSiAVu2S187aoNqxWhWa5r5ftagdK/+/M/GDx7fjrsfexNGzYvj9NefAHwlXHFuOPDmFYF5W/YIM1hEhALOkHMZyMkYTGcVE2WTNAaBkbbBvJIFoJoWjo5L+9W5xHdEfyCOcy5SWiprd935/aQ95g2NbcgXlfgyGMZXOoyPmMzy2EJ9EOJsu3ei1EGuEiteaP2Uy11qINRj5uNIOmAfyVcaIrlgIiUwSo4ksFrRUiR9aWnggPyck214baMdVfn0bHWuEnfhB71izcy5HJioYHx+XAcjjyqVd+d/q1aV/EIvpHwfI8nnnlR7b22t87IoVpccuWGB87JIlsizL8h9e2icvuP5heXffQuNjFywofd4VKwyPHY51lB573nnGzxuLlR67erXxseWX2oc+ZH7s5CQ/9PfLVpofOzSkPu9VV5kfu3Oneux115kfu3mzeuxNN5kfu369euztt5sf+9hj6rF33WV+7MMPq8f+5Cfmx/7yl+qxv/yl6bGfX321vOrOJ5RjH37Y/Hnvukt93sceMz/29tvVY9evNz128oYb1WM3bzY99gdnfED+zIMblWN37jQ/h6uuUp93aMj82H/8R/XYyUnTYx9e/FZ5wfUP8/9Mn9fBGHHSTWvlBdc/LOd6eoyPdTBGcJYsMT62OEY89NJ+ecH1D8tvLDje+Nje3tLn9WiMWHfiuebHTk7KN/z6JXnB9Q/LWy54v/mxNsaIzOuvy7/73e/kTCZTdYy46J9/oD5vlTHiP279b3nB9Q/Ldz36hmdjRP5HPzY/1uYYwa71j33I/L1px4h9v11jfqyNMeIH518qL7j+YXnrgfGqY4R83XXq83owRvzhlQPyCdf8yvzYD32o9Ho3O9ajdcTAcUtLjzUZI17rOVJe/d0n5IdfOiAvuP5heU//QuNz0Kwjnt1+WN7Ud6zxsS7GiLG3V5nvtVRZRxx/za/kx149qBz7j/9o/rweryMuuOMv8nfe+hHTY+/4+gPygusflu95/M26rSOyP/+5emyVMUL+yU/UY6usI3Lf/a46rgpcR3znrR+RD04klWMtrCNe2DWiHGtjjLjlR1XO1+Y64va129TjzZ539Wr5737wtLzg+ofl3724z3SMePbIk+QF1z8s7xtNKM9rMkZs6jtWfnTbQfUcLKwjDowl5AXXPyy/3nuk8bE2Yo14W5e84PqH5e8/9oZybJUx4sI7n5AXXP+wcj9bWEes+No6ecH1D8tj73mf+bGaWKPeY4Qsy3wdMQ7IAOTx8XG5GiStb3KYtN5FR61SZFnQE4nDTU2SGXIDvtda4nWtbjXs1jVP91on9v7MEldewzLyPmEDinOslNJEgwHLx3qBHYdnph4QUdJihKj6RTeIHFdYOYIo53o3rFraj+9+eFm9T6Mqdu/deCrHe8j7Lf5tedcNkeQEuWIzvOp1bxcrZQLMBJaZudaDgK/5wgI7HXzGLUqztewft99u1gw7pYX7eUbeXNbPSmImLV7vtvvIF8tkRS2b5aK+0Wq3LdbxyEoLwXxBxnDRW6kWZYL1RpIdRDM//elP8YMf/AA7d+7EM888gwULFuDOO+/EokWL8L73vc+L86wpExMT6OjowPiBA2hv1zHHaiBp/X8/sxM3/n4r3r2wFf/vH1aYHsvRkbCMTmXwlm88CgB45ZvvR4DVtjuQzX7kh89g095x3HnxMrx7aZ/psYZoJCwf/o/H8dKuYXz34mW4QPt8OsfakbskJhNY/pU/AABe+NK7Kg3baiit/9n6Pbjloa1YuWQO/uMjp6rHlknifvinbfjOujfw/lPn4d8/cFLp81qU1r92cALvuWc9Otpj2PDlla6k9Vc+sAGPv3YI//a3J+JDy+cbymaz2Sz++Mc/4t3vfjc+cM+zePPQFH58xdk4e8lc5VgTmdsNv3oZv958EJ//m5PwqfOO5se+57tPYMfhBP7fP5yGtx03W/0DjcxNLhTwlq88jLFEFr/81Fk4aV5n6ZNblMQ9t2MYl/3XBqQDqpeCVlrPuO/jp+PMo3p0x4j/95ftuPNPOt9d8b7/8A+fwbM7RvD9v12M95xkUBtYZYz455++gCdeP4yvvX8pPrh8foW0/q9vDOGK/9qA4+a04vf/3znq74pjxIPP7cG//vYVrD6mA3drr8NyBEjrr//Vy/jflw7g+lWL8bG3Lio5VpZlnPAvv4OUL+DxL5yvX9cci+Gbj7yG7z+2HZefPhdfXnWc8TnojBE3/vYV/Gbjfnz2Hcfgyrcfww/NBgJYs3YtVq9ejaAs83v54ZcP4Av/8zJWLOzCP7/tKHzy/g1YeEQP/nDt+cofVrnv73hiN/7jLzvxj2cvwM0XHueJtH5oJI7zvvYIJAnYcvO7K12OLY4R67YM4qr/2YycPwAZqrSePdt3P7wMK0/UjMWaMeKxrQO46j+fxvF9bfjtp99a+eQWpfUA8PH/3oTHdozh9g+djL8/bZ5jaf0vX9iLm36/BecvnoV7Ll1u+b4HUHFsfnIKL+wawaHJNGa1hrFiYbdaV26wNsgXZJx2yzpk8gWsu+ZtSq2tgHWEdly97leb8cjWg/jye0/EJecfrx5rsI5442AcF33/r4h2tOHjb12EO9a9jstO6cUt712qfw6adcTekQTe9fW1iPolbLrpAv3jHY4Rv3/2Tdzwy5fwlqN78KOPnW7+vCbriE8/uBH/9+Y4/v0DJ+OSM490La3/3M9exCNbD+Irf3MCPnL+8bZls5+8/wU8/so+3LJ6MT5yxpG6h15wz3N4/XASD15xJt5yZDuQzeK/nt6Fb/zhVaw+qR/f/vtT1IMFSuu3DUzgA3c/jZ7WEJ76yoWWxggAtqT1WUnCmnXrlHHV56u47+OpLM74+p8BABtuuRCx1uLcZTBGHJ5M49zbHkPO78drt71P6eJjso644r+ex192juEbH16BDy4/wpa0/rzbH8XQ4Cju/8TpOH1Rj+mxZuPJz9bvwVf/71W87eT5uPey4nrd5L7PQcLirz+OfEHGc//6TszxG6+Z33Xnk3gznsevr3wLli/oMnzet3/rMRyYyOB/rnkHTj6iU3nQQqwxkcri5K8+gkg2hU1fXqlf225DWn/Vf2/Emh0TuPUDJyn3Q5Ux4tO/ew3/98oAvnrREnxseb9p/HCoEMDpX/8TJAl4/UtvR1DXurWIzn2vHVeDdZLWT0xMoGPuXIyPj+vHoRps18jfc889+MpXvoKrr74aX//615EvfpidnZ248847p0Ugz2lpKZ00zI6z85xWiZnvwAFqRj7Q2mr9ubULAvZQKIJkSFlUpHIFtLJAXudYQ4qLkjemgGQognlH9BqfU0RnYW5Ae2crkqEpDMmB6u8xHFYH1CqM5iQkQxGE/D7EutrNZQ2hkLpIrIadY4NBIBhEuKMNyVAEo1LQ+D0GgxiTQkiGIgh3tpl/FoFAaa2vhlinhJw/oGYGTY6twO8ved1hBJEMRRDt7Kg8H+2x2SzykQjQ0oJodweS43kc1o5rPp/h+9mf8yHrD6qmJcVjFy6Ygy0TA9g2UcDbDP52YCKNgZwf/kgAxy7qA8yMVSTJ8BxWnBhDd88bGBxP8SmB3S+AUiPb1xHBihPnA3pmUS0tGC1+d9Gudt3XYS3oBnN+6/dy2RgR94eRDEUQaGutHD9iMYQ62pEMRTDhD+u+BmsJ44vFXI0nhmjue6m1BclQBJOBynPJ5mWk/CHAD0Q62wGDbBar85uUbXxmxTFib8aHZCiCnr7u0r/VTriae7l/bi+SoQh2JMC/y/aWsO6xekSjyrFTmbyjMcIKSVl5T7GQH1JrFWNHk/t+5RlH43uxGG5+aCsGxlPI+/xIhvzobQ3ha3+7FCtNTKgmMgUkQxHle6v2nfjNv7ferlYAY4rjvMkYUUHZsQeyyufSOaur8jlM7vsKJAn+tlaceZJF08zi8/oBzOrvxptDk9iRBI7Qez0n6wjNuDrmU67JYGvZ8xisI1p7fEgFI8hpauRbu3TGcR3ao0Gkg2GkAaTDEcMuGRwbY8RI3q9cPwbjZAkm64hwRxsgTaiGfDbWBnrHjhY/31BHu7roBizfy53RILL+IEZgPMcPTCrnOrs9wp831qWM2YfN1j82xgi9Y+P+tPLe2ltKxwQ7a4Nqx2rHVZ37vjUmoxCLIZ0rYDgDxEyOBYBESuJjHW/FazJGRLs6kN0zpfYitzie5AsyDoynkA1FMPeIWUBLlWvZZDzp7O1EOhAqzcibnMPASAL5goyQ36esf0yMKIOtLUB8Ql3XGTzvCEJIB6VSg0ALsQbLyKeCEWQjUUSsqHJM7vu4X7lnePu5KmME6/wwlsxWjR8OD0wAUNodB1tsGBSy+14zrhreV3bGEyfxg1miswzbmoPvfe97uPfee3HjjTfCrzGCW7FiBV555RW7T0e4RFT7Oa38JOmglRMjkcnxXtjzXTp8MrxqQceerzNW2Q6s1rBBtdpnz13iXbSfYw6n6Vx1h9NqqO3nrF9/dluwGLURWWzBuX7LAWVAP3Z2qyV3VCO0rXLKsdoqhy0ojVyBRbSgy/D2cwau9cXH0wYu76wVnJvPyirsNfTaz2ld6M36zLLnSDhwrT9YdGbv77C2qch6yQ9OpPi1a8dVm90j1VpMukFED3nGqqX9eOr6d+BnnzwLR89SFoX/euEJVZ2kRbSeY6jO9e5a0PG2XnWULC/sKTrXD3vjXG+3WwGTx+cKMg4Ue1Vb7d6ibX8qWrrOe8i7vH5E97pPunCtB0p7YeuRyOT4Zzlbc53Wov0ca1tWq9ZzekiSxDez2RrSDLtdBFiLYSvSbC2DEylk8zKCfgl9DjpeaLHbtYf3kO+KqpsVBrA1YbXSJjVmsPddhzQdqEQ417PzsCqt77Tx/c2k1nOAg0B+586dOPXUSsllOBzGlB2XPUIIogJ5SZL4gjnlogUd67fZEQ0KWcgBmpYdogP5Bmk9B6iLr6lqgbzA9nOA+17ydtvPAfa/z2qBvFkv+S0HxgEAS1z2jwc0rXLKggGrrXLUPvL6n5WIQL5aH3kW+KYMJuJatp/jmwo658I2GnxS6QKiHKsbYHoMjKu9ga0wqzWMkN+HfEHGaweVa85WIM/UAx62n3PbQ74cv0/C2Uf34PSF3QCAPaMmEvQi4wlxgTwLaNzWyLvpIS+Ko4qbITsOeRTI8+/e2r3bEvLzBN+eEeV77YpZmwv9PokHDqIDeRawdhp17rBIe0Ts+fFNMoeb6KyX+VhCf94bKm42RYP+ko16L1v9MXhbWxcJAhH0tiqf0WEL7dnUTUtr58w2hqy2L2PsK94bczujllozmtHD35+1OZ451rPWp2awjWKzGvlcvsB9VOy2rPb5JASK7z8rwMciVVxrRCzOVWw+2bx/DM9sHzb1xaFAvgqLFi3Cpk2bKh7/wx/+gCVL9DNWhHeI6iMPqH0l3QTyu4vZhgU9YrLxgLPe41YYTYhZMIhADUjMFx3xNJtwnZ9zKODjwdGky+zglIPz6bGhsMjmC9yIqXxQZr3k3zw0aagsYBn5E+d2WD4/M1Yt7cdfb3gnosVNr2///Sl46vp3VA3iAbU/spFRlJ1shBHVAnG2+210j6ey5hsBImHnqHcu2h6zZmoZtY+8ves4mcnz72OOxYy8zydhbqdyLLuu7IwdPCPvodkdC+ZiQbEL8gUsm2yhDzrPyAsYV1lfdpZRd8rBOAvkp39GPmrxu9f2Wt89rAQrdja12eat6P7mLNDtjLrbYG8T3H/drdqFBSJGGUW1h3y4ZMxjf+dlH/l4yv6GvBew9sLDFubAhM2MPNtIGbWZkd+rbf/mkp5iKVY8lbOU1eb96y28dmvxejczU9Uq15xs9gaL60YRGXm21rCSkV+7eQDff2w7AOCF3WP4yL3P4pzbHsXazQO6xx+anDk95AEHgfwXvvAFfPrTn8YvfvELyLKM9evX4+tf/zr+9V//FV/4whe8OEfChKRAKSXP1mWd36RsZ1+UrB7QSOsNdrKdwgLJmZaRB9Sgwq3DNNtYsCOt77KxMTMylYEsKxmg8mzR/K4YYiE/MrkCdg3rZwq38kDefUae4fdJ6C/ukM/tsL5LzzPyBt+d0Iy8gRxdq7rR8zllGwFmcnZRhJm0Xme8YWNQtMoGJVuM2O2AMFhcNLeE/LbKVOYVF1SvFmvw7GSdrd7jbuByUxv3oxUWFjdmje4zLSKl9Swj7+aeANSNALYxUA8W9SqB/E4LmyFOcKLOY9letgnQZWMuZH8rXFovaCOoTXhGXnmeamOSESU1vjocLF7js8tUIzwjn8x51mlnUkCCQAS9NjLWTE1YYVJsgOp6bm8duZetaau4xluhIxrk6wUr69n9NjLyrSwjb7KmY2OET3KmumMdpER0R0llra011m4ewJUPbKwoLRkcT+HKBzbqBvMzLSNvOxr4+Mc/jlwuh3/5l39BIpHAJZdcgnnz5uG73/0uPvzhD3txjoQJIqWUanbLjbReGfSO9CCQH7Ygt7IDG0g7LcoJvcR2jbzrQD6A0UTWVSusTK7Ad2bbbCwAVGl99cmaDcjdLaGKgNnnk3DsnDa8tHcMrw3GcczsUgOq0akMrzETIa3XMqs1jB2HpvjOrxV4jbxBgMN2j+08ZznpKhl1FjwXZEUeFwqUfqbVpPkiUaX1ldd8SpORN8OptJ7J6ud0RGz5YxzRGQMwzD+nRquRF7mxq2VhMQjdbSGb7E2NfAqyLDvyMsnlCzwwqKe0ngXy+0aTyOQKwtuqqjXy1r97JWutOnf3OMnIC5Z8C6uRF7zRkLAZOJbDa90NMsJG5R/s7zL5AlLZgrCyGS3MR6BRMvLWpPXOMvJ2a+T3CczI+3wSumJBHJ7M4PBkuup4xF+720ogX71GXluO4GQsFZuRrz7H5wsybn5oq67nvAzFn+jmh7Zi5ZK+kvXhTAvkbc0kuVwO//Vf/4WLLroIu3fvxtDQEAYHB7F3715cfvnlXp0jYYJIc6OIgEB+j4eBvHBpffH5uhpBWs8y5BnzXXc+4bqsZbMy6FdD+7f2zO6UwdXK91lNInX8HGZ4N1Hxu63FrOmR3TFDgzmnsKyJnUwhW1BWM7sbmco47ovOdsqNggTt7ndKJ4DmGwE1zMjrKYCSFnfrnW4+MhmrVaM7xryyxZzRpoweLQLuuWrwjV3h0nplPB9NZA0DEYbIQJ7d99m8bFsSyzg8qap67ASqopnTHkY06Ee+IGOvBa8BuzjJGJcHbnYy8m2CzeQYao28W2m9uI0GWZbVMkanZnfFUgEj0zourS8LPlpCfh6keGV4N9kg0np7ZnfFjRW7NfK2pfViVaZW1z/5gozthyYBKOdcbU3A5pe4aSBfHCMcXsNs8z0rJCNfXXW3fucIBsaN/VFkAAPjKazfOVLyOAXyJgQCAVx55ZVIF3tF9vb2Yvbs2VX+ivAStS5ORCDv3uxudzGQX+BFIJ/ICJWWsYWhVYMfL2GyW1nWN/9icAmcgIw84C6oYOcSDfoRMDEkK0fdmHHvPmpmeMeM7kTK6hkswBiKWzfhqmZ2190SgiQpE7jTMhJmEmckmwv5fWobVD1Je13M7pxn5KOOM/LOzM/KszJ2gg224HRrMGmG3SyVVWKhAGYX78FqNd4iA/lQwMfHC6eGd+zvZreFqzo/e4kkSVzZYMVrwA6FgqwujO1I6zXzSMjvQ4uDvxXvWq92k3GDutHg/vwy+QIPpNy61huZramdFUrHJEmS+GftleGd6r1T70DeuvqSeY1Yd613VqLJzO6OECCtB6wlptZuHsBbv/Eo79Zx80NbTWvCAWvJmZTLzaigXxk/xUrrjc/F6vqq/Diqka/CmWeeiRdffNGLcyEcIDIjzxYATgP5QkHGvqJrvcgaebaDmckVhNaXsgG9EQJ57UaM2UAsyl2WBfJuHLTjvPWcvXPReh4UquwyVwvkmeEdcxHXssWD+niG3Xr2VDbPN2iMzO6Cfh+6i9ei05rgatJ4SZJMTeZYcF/v9nOWA/mgs0CetZ6z206ovFbRXo28qh5wqriohlfSesC6WduEwEAeAN9AcB3I11FWzzjKozp5rbrGXkZe/Y66Wuy1YRVtJgcoawiekXd5/YjMyCc086RVl/RyWM1/KlvQHXvV67RyrvO6BV1ckPeOW9haz0pGXu0iYC+QT2TyupvHemRyBe6nMl+AtB4Auqs487Oa8MGy8c6sJhxQ14RmrvWqYsvZ/MCUflmX0vpsvoBccQ40U91Z9TQpP26mZeRt37VXXXUVPv/5z2Pfvn1Yvnw5WlpaSn5/8sknCzs5ojqi2s8Bqnuk0z7yB+MpZPIFBHySbcmqGdGQH5GgD6lsAaNTGWG7xo3Ufs7vk/h7TGTy6NE5JpMrqMGgS1OaVgFmd8xYy64cj5nO5AsyJlJZ06ym1Yz8npEEEplcySJLtGO9ltk2A3m2UJIk87KI3tYwhqcyjpzr8wWZT45mGfVI0I9UtqC7mKlH+zm9Ra1Vszv2fduV1g86lNYfUbZBaa9GXv3ek9m8J9kvJv/1oo52YW8M63eNcIdzI0Rm5AElAH91MO64lzwzESuXLNeDhb3K9SM6kE9q1DVOpfV2N7SZsmhCYEY+nsqB7XG5Nbtr17h4FwqyKzUGu69CAZ/jFmRt4QD8Pgn54mZF+SYlm0v0VELtHjvXT1bpqFIretust6Zl6iOr0vq2SAA+SfGHGU9kMbu9+n0yMJ5EQVbmKlFBYS/PyFeOZ05rwgFtcsZKjbzTjHxRRecyI6+d8802689Y1I3+jggGx1O6n4kEpf3vGYu6+WPpXJ7PQTMlkLe9Wrv44ouxc+dOfPazn8Vb3/pWLFu2DKeeeir/P1FbRLafi7jMyO8pLvDmdUVtSa2twHZqRfaSH51qnPZzgBqUGDlwO61J10Ptae1CWu9QHRAOqE7h1b7PahKpntYwelvDkGXg9YOT/PFkJo8dxfqyRsjIs6xQazhguqB041yvNaAxM9JSW9Dp9W+vh9md+xr5XEG2ZcAz6FBaP6ctXLKAshOshjVBgFd18l5m5K20oMvmVdWUqECeBeBDDjPyjdBDnrGoVzHkFB7IZ9QNODsBq9avg/W4tgrPyAuUezPZeSzkdz0GsU0KWXbfZpXJuO2UHpQjSZJpC7qDJtep5xn5tBjvHbewdd5oImPYUpYxpTFus4LPp37+Vv029o6oRndOzOH06DapkXdaEw6oagorrvVON3pFZeTZ2kOq4p7v90m46SKlrbnRp3/TRUtK5mSmdAj6JWFzUKNjO9rauXNnxX87duzg/ydqi8iMvGoc5ewm3e2B0R2DZXH1djGd0kjSekBdfBu5WjutSddDRI28k9ZzDCYvq9ZL3opEanGfsjjWGt5tG5xAQVYy3F5Iau22xapmdMdwE8hrM+zmGXkTaX0N288JkdZrxj07SiKWke+zmZEP+H3o00hftx4YtyyTlySJ3+NeBfJqjbz4BbkVab020LBjBGgGC2yc9pLX9ueuN4uKGXnRNfJOHOsBlxl5GzXo+YKMZ7YP4/eb9uOZ7cOG94wox3pAGTtCxXnSbZ18wmbQaIQayJfOe5PpHA9MZ+vMde0elDGUvH6DSOuZT4wsK55IZiSctL61WSev9nEX6Plk4gPgtCYcsOda79QMlbvWC8rIhwO+qhskq5b2455LT9Odq7/xwZOwaml/yWN8zdgaFrb50ujY/jYXLFjgxXkQDkkKlFKyxbtT13ovWs8x1F1MMRNZKpvng5odp14vUQN5/c9fZB2bCNd6NSNvf9HV3RLC7uFE1Yz8YSuB/Jx2/PXN4RLDOy/r4wFVITA8lUE2X+ATnBGq0Z21QN6JtJ4FxH6fZLrREzFxi69H+zm9DYWkxUA+FPAh4JOQK8hIZvPoQPVrMZcv8MnebiC/dvNAySbLpT9aj/6OCG66aEnFgkKPllAA8VTOdt97q0x5WSNfDELNpPUskGcyYhGwTTM7xpJaeA/5BsrIHxhPIZnJCyuBSDqsfdVKqe2WmPEa9CrB5drNA7j5oa0lmUaje0btIS9mTm6PBnB4MlN01nde4yzKi4gH8mWfGdtsagsHdD1n2nlG3psNQFFtbd3i90nojoUwPJXB8GTGtEbabkYe0BgOWs3Ic8d6MfXxgNriUW/t47QmHNDUyFtwrXd6HbM52237Oasb9YxVS/uxckkf1u8cwVA8he8/9iZePzjJ2/NpmWn18YCDjDwAbN++HZ/5zGfwrne9CytXrsRnP/tZbN++XfS5EVWQZVndiRcgrWeLgLRTab2HgXyPSV2RE9hA7vdJJc699aSatJ5PtgLkbyLM7qZcTP7M1K1aCxYmre81cR/lhneaQH6rh471gLKzHygGKlYcdnkP+SqfFXPtdZSR57J482HdvDa9uFNei/ZzAbOMvLUaee0xVvuzH5pMoyADAZ+E3hbrkz0zIcrkS7OJ1UyItMQEeFOYUQtp/fBUxlBOPW5xw8oObNHqPiNf/0C+KxbkY8DuEXFZeacb+m4y8m0WXOvZPVMuFza6Z7hjvaDrRzXkc5uRF9MNggWS5RJ5M6M7wHtp/YQgE10RWG1Bx2vkbWTk1V7y1jLyTFo/X2BGvsfEtZ7VhBshQdkE09aEM6wE8m7nB5awcNt+zs78zvD7JJx9dA/et2wernnXcQCAB57dXaHEo0DeAn/84x+xZMkSrF+/HieffDKWLl2K5557DieeeCLWrVvnxTkSBqSyBbBubGKl9Y0XyHfxwE/MRKbK6u059XpJdWl9sc5awMYDm/ysBj96uJLWW2jBksrm+SLRXFpfGch7aXQHKPV2vTZa0LGFZDUzIS6td5SRt2ZUFzaRtLPHIjXIyDMFkN7GYcpijTygaUFncdzS1sdbrSeuZkIEKCZE1WT2bLHlVUZe7RMsfkHeGg7wa373Yf2svGijO8B+GUs5Q9xErP4LO0mSsGhWsU7+kHEgb1WKznAayGtrvseT1XtVa2GbNay+uhwn94zaQ15UIM82G9ytGxKCShjZBsV4WUZ4yKD1HEM1FhQfyKdzeZ5hdWuiK4Ieiy3oWBtPO8Egu66s1sh7Ia1X31/leOb3SfjkuUfp/h2bqcprwhlsbkllC4b+Am7NUFmpiuuMfM5eRr6cC07sw/zuKEYTWfzmxX0lv6NA3gI33HADrrnmGjz33HO444478J3vfAfPPfccrr76alx//fVenCNhgDYIE9FHPswlt+7M7kS2nmOwwU9URn6U96ptDFk9UD0jL6r1HCDa7M6BtL61eiDPBuRQwGeayT5uThskSckUHoqnkc0XuMzeq4w8YK+enWfkDXrI8+dsVRZyh+P2TR1ZEG5mdAdopfV6NfLFrH4tMvLsPExq5C1l5G32klcDeesTvRsTIi1ss87NfWcGz7h41D6Q13gb1MmLbj0HqMHNUDxVtV1lOelcno8xcyzKVr1mUU/Rud7gM1y7eQDn3PYoPnLvs/jczzfhI/c+W7WHtPq9W58b1m4ewBd+9TL/+b6nd1V9HS28t7lBttvJPcNr5AUF8nbq+M2w65BuBM8Il/WSr6Ya8TIjP6VR5dW7Rh6wnpFn17yd9rdddjPyo6ydsjhpPSsTnUjldAPiTXvHAACRsnm8ryOCey49zbCES/s5TBkoLd1m5NnaolyVZhetOacT/D4JH3/LIgDAj57aWTIvHJpU7qWZ0kMecBDIb9u2DZdffnnF45/4xCewdetWISdFWIMFfEGfLKQe0Y3Z3WQ6x2t+juzxMiMvxrWeOdZ3N1Qgby67ZYt/IYG8gBp5N9J6M3kZQ+tYb6aaiIb8WFDcPHptMI7thyaRyRXQGg54og5h2GlBx2vkq2TkWfsdZxl5a/XtbIGQ0mk/pzWh8RptvZ0sly4MVIm/dWm95Yy8A6M7NyZEWlr4Zp1XZnfeSesBVV6/2yAI9SIjzxZk2bxs2aSKwTKdIb+vYbqTsDp5PcM7u1J0BveUsPi9s9cpr9O1UyaiBsnZivsXcHbPsEC+IypmXhbVS15URt7ItV71cdAPPrw0u2NqhVjIL8zXwg09VfqsM6YclDuwzaeX9o5VVbqksnk+t4uU1ndGg2Afc/l4tv3QJB56+QAA4JefOhs/++RZ+O6Hl+FnnzwLT13/DlMfllDAxwNtI5WMWzPUoKiMvABvr78/fT7awgHsODSFx18f4o9TRt4Cs2bNwqZNmyoe37RpE2bPni3inAiLsMk7JGjNzTJ1TvrIM6M7pQZQ/ILJihTbDmpGvjEWd4AqUTf6/EU6y6pmd84lvm42FtjGjJnZnZ0BmcnrXx2cwJb9iqx+SX+7q97B1WDnZaW/NXetr2Z216q2prFbh2ZVWm/F7M6p5M0O2tcol/mzzUQr5xGtYhJZDg/k261nWdyYEGmJCbjvzBAVcBixkGWTjaT1gjOqgLJAZeO/3V7yLEic3d44DsZGveTdlG8kec1p9cWAqDIRViZUkFXjMS1O7hmWqRYvrRfjWu82I29odle8To1UI15m5OMp5xvyXsAy8nrScy0Jmxn5tZsH8KOndgIAnt05UlXpwozUWkJ+oeOZzyfx8ay8fOD7j70JWQZWLpmDk4/o5DXhZx/dY2mTpdq6LuHQFJPB28+5rZEXUMLXGg7gI2ceCQD4zyd38sfZutHMV2m6YTsE/OQnP4l/+qd/wm233YYnn3wSTz31FL7xjW/gn//5n/FP//RPXpwjYQDLiLpsKc6JhlhfZ/uLTC/r4wGttF5URr6xWs8BaksQvUURINrszr3EV62Rd5CRt1AqYS+QVyT0rw3GeX38Eg9l9drzsiWtr7JY6oqF+IRt91q3Kos3aj+Xyxf44r2WGXlANepj2JHWxxxK6/s6rE/0zITIaCllZkKkpaWKD4Zb1DZk3izK65GRB1T1y0GbveQPVqk9rgdH8V7ypZshbso3kjYcvEWViUSCPgT9yh2hV4Pu5J4ZF9h+DhDX6171nhBkdldRI29NWu92Q0IPkUo/EfTyjLz5vMrWv1Yy8kyBMlH2+ZkpUFTH+pjwTUAeyGvWP7uHp/D7TUo2/rPvONbR81YzvHMtrS/e764z8hkxbW7/8S0L4fdJeHr7MLYUDY65kpMy8sZ8+ctfxle+8hV873vfw3nnnYe3ve1tuOuuu/DVr34VN954oxfnSBjAbkpRGfmoi4y8l/XxgAfS+uJE2iit5wBtRl5/EPak/ZyLgGLKxQKA1YmNmpgX2gnkuXP9wTg2e+xYz5jNM/JWzO6sSet9PomXHdg198pYldYbdKfQ1qrXov1cwCdxiWH55qEts7viBpgTszur+H0SbrpoCQBUBCbVTIi0iOgWYYadxa0TFvWyXvLmZnciXesBtXWc3Yx8I/WQZ7CM/OHJdEkA7KZ8w2q7Rrevo0WSJFNXeHbPmOX1y++ZMcFmd+3CXOvFlKzw9mcVNfLmhoztNcjIt3qgpHRCT4va2tWIXL7AN66rqSScKlD2jYg3umP0tKjKO8bdj21HviDj7Ytn4aQjnJn0tlQJ5N0qtsRl5MUox+Z1RvGek5Rygx89tROyLJO03gqSJOGaa67Bvn37MD4+jvHxcezbtw+f+9znGka6NlNgUutsAXhu54gtx1k9wi5c61lGfoEH9fGAukM/kcrhqTcOuX6vYxrX+kaBDWrVMvJOzOXKEVEjP+lCktejsyNdjrZGvhpMWv/6wTi2eexYz7CXkWfS+uqflZ3n1cLN7qr0tGeZ8HI5uzawr0VGXpIkdVMh5zwjb1daz4K7/g57BkarlvbjnktPq6itr2ZCpMXLjHy+IPPP0atAnvmflAehDK8y8nPYppnDjLxVmXctaIsE+fj3X0/v5rW6bso37GTaRJWJANVd4Vct7cf7ls2teDzol3D3RyvvGTYvi66Rd+1an7ZvrKYHe1/agFyWZctmd5PpnKEjuVNYN5xGacPbW7zXD5vMfwnNXFUtGHSqQGHS+iO6xBndMbrLnPn3jiTw642K+/pn3uksGw+oak2jdV3CpWKL1cjrdbyxA9+oF5AwuOJcxfTuoZcOYPuhKV4yOJOk9ba/zZ07dyKXy+HYY49FW1sbf/yNN95AMBjEwoULRZ4fYcDazQO44devAACG0xIu/fEL6O+I4KaLllhaUOoRdehany/IeHnfGABlpy5fEGO+x1i7eQBf/V/VSPHSH613/V5HWCDfSBn54uBaixp5tiDJ5mWkc3lHGdhJF9J69rmnsgUkMjndiYVN5L0WdlYX9rQgHPAhlS0ghQJCfh+OndNq+7zsMKu40LViTGc1I688r7MWdGluEOfMtV67EeClt4CWcMCHRCZfcS52MowxG+NWLl/A/uICbWAsaXusWrW0HyuX9GH9zhEMxVOY3aZIg60+h5c18toNWK+k9e3FIHR4KoPdwwksnVe6WeZZIN/urJd8NclyPVi7eYBLvb/1yGsAgL72CE6Zb64gkqBsGumVb9jZ+GKS98HxlG6W0ux1yrHiCs/GvsvOWoDFfW346v9uQTYv68693rWfc5mRt/H5msEz8hpp/UQyx8deoyyidrM8nsoJXbdMNlAPeUDd5D88lYEsy7oJQrax4vdJVTednSpQtNJ60ZQnMn7wl+3IFWSce2wvTjuyy/Hz8pJJg+s96cAgUIuojHwyw8oA3QfyJx/RiTMWdmP9rhH862+ULhyRgK8mPj+Ngu20y8c+9jE8/fTTFY8/99xz+NjHPibinIgqsHqfcsMUO46zekRNTLDMzuWc2x7FS/sUOfMPn9hpq4WNlee/8oGN3KCK4fa9cml9I9XI84y8uWu9kBp5zUDuNKhgWQ4nC4CWkJ9PCkb9Yu1k5P0+CcfMbuE/z+2KwOexQohL6yfSuq7NWqya3QHqTrLTjLxTs7taOtYz2AZSZUbeidmd+WJ97eYBvPW2R5Etqnk+94tNjsYqv0+ybULE8DIjz55TktzXHpqxsJfVyVfK6z2rkW+3XsaihZuINYi0ns1n2bL2TYMTKfxxi+q8bLd8g5vdWVigiyoTAaq7whcKMl7YPQoA+LsV8/HRsxbg70+fDwC494kdJcfKsiy+/VxUTI08C4BaXBoSdWpq3VlmnV2jnbGg4XgX9Pv42CFaXj/RYIE8m/8yuQL34SknoQlIqymBnSpQ9o4UW895kZHXmDcPjCfxPy8Us/EOa+MZrDzCK2m9MNd63kdezDx16oJOAMD6XaPF5y8IjUMaHduf4osvvoi3vvWtFY+fddZZum72hFhEOc7qYdZfWg+nrXKs4uV7Vc3uGkda31Ktj7xAU5qA38cHUSfyelmWeQmAE2m9JKm14EYtpezUOq3dPIAdh9TAYtfhhOcDOTuvtMmCg6Ga3dnIyDsO5M0n6bBB+znVLK92O9nsGiyvkU/aMMNR+8gbLy7YWFWe0RU1VlmlWg2jG5IaR2Ivy9xY+ZReL3nvzO6cZeQbyezObD5jdMWCuPuSyvKNOe3m5RtJm27UIspEAE0NukEG8LWDccRTObSE/DihX1FwXn7OIkgS8OdXh/Dm0CQ/diqTR644l3cKl9a7u9/YZndUkGs9oH5mXFZfJeAUtSlRDk8QNEiNfDTk55sWRpv8droIODUq3TfqYY08d+bP4P/9ZQcy+QLOOqrbkgrGjNYqJsZuze7ComrkBSlcAGVu/+FfdlQ8Xuu5vZ44qpGPx+MVj4+PjyOf98bAh1AR5Tirh51+zF4G2Qwv3+toA0rrY1WydZMsAy6olq2aw6kZqazqcO60blB1bq2crLWmJbOrBPIsSCu/br0eyCNBP18oDpkEGNl8gS88LNXIFyf5aq695bBd8pDljLxBIF+PjHyZOiBtwwxHHbf0r+NajFVWiVXZrHOD1z3kGQuLzvV6fdC9zsjb3dxqJLO7avMZoCjFulpCeOr6d+BnnzwTkeK9eN/HTzcNrtVuBda/+1VL+4uvY71XdTk8I2+QJX5hlzI3n7agC4FiNu+oWa141wlzAAA/ekpdgLP6+FDAJyxTp+117wZeW+wy8Aj4fXzeZe+3Wg95hlct6ESW7ImC18kbzIHc1NOCQsJMgcIoV6BMpnNctTm/W3xGvqv4Xb64dwwPPLsbAPBZF7XxjNZqNfJsjgi67CPvOpAX0+a2keb2emJ7tDz33HNx6623lgTt+Xwet956K8455xyhJ0dUIspxVo9I0f4+mc1XlQp7GWQzvHqv2XyB79A3krQ+VsW0S3SbGDeGd/GiQY4kOV/ccHmZzq57PK3WDZqZltR7ILeSPddmg6x8d72OM/Lu+sinLNbYi4S9Vrk6gGfkLXg3VLtvajFWWYVJc92YTBrhdQ95BsvIl0vrtRtWXtXID8VTKFi8lxOZHL/3ZjdARt7OfKaUb/Ti6NmKz8f+saTp37BA3u5376ZMBFCzxEYZ7+eLUtcVC0ozjf/0tqMAAL/euJ+Pc2Oa1nOiFCXCXOttBI7VKO8lX83ojsEz8i7fSzlsk0NEyZ4oeA25QSBvJyMPGCtQAOC9y+ZWbF7tLZo3d8aCwpUKazcP4Cv/uwWAMsfnCjKCfqmiJaET2JpOTyFYKMiOxwkGSxJkcu7WU3a60pjRSHN7PbF9595+++1429vehsWLF+Pcc88FADz55JOYmJjAo48+KvwEiVJEOs6Wwxb4sqzsuJlJdL3cUGB49V7ZgkGSxC843cCzdQY1625c4vVgk6CTjDyTGraGAo6N0bR1YuWwxV1bOGA66dgZyM8+usfReZoxuy2MHYemTI3pWLaqJeTnWSkzWEbettmdTWl9uZyd/b0IJ1mrRAwy8qwVnqWMfJU+8rUYq6ziZUY+aXNx6xS1BV1pRl6bKRTdfo7dE9m8jNFEhktTzWAqmWjQ3xBBipP57MjuGLYcmOBdYYxICpSq2sGsRl6WZTxfzMifvqjUwGvFgi4sm9+JTXvH8NNnd+PalccJN7rTnl8ym0c2X+AZRbuoahf311FnLIj9Y0keuA1ZVI2wTQmRGfl8QebX1lA8Jdyo2Cm9XJWmL62fcmDaVm5U+sbBOO56bDv+vG0IhyfTJQkDrxzrmXqwPAzO5mVc9d8bbZW16GGWkdduljtVbYnLyIsZrxppbq8ntke1JUuW4OWXX8bf//3fY2hoCPF4HJdddhleffVVLF261ItzJDQ4rfexgvamSpnUmwLebigwvHqvaoubYENMWgy2268nrc8X1Jp0URn5VhcO2iLkeDyQ16mRt1ofX++BnDnXm7XF4vXxFoObWRba7+jBgmHrrvX67efqkZHXmt2xzheAtU2FaiVBtRirrFJN+ugGtrj1PCPfrQTyQ/F0yftgAUZbOCB8XA0FfNzP5Jcv7OUt28zQyuoboTWuk/nsyG599UM5yRqpMcppM3Gt3z+WxMB4CgGfhGXzO0t+J0kSz8r/9JldSGbyGqM7cSo57fxk5ORtBTa2tAj4fNlGxTjPyFvzcRAtrWdGxRv3jAEA7n1SrFGxG3qqlJexZIfdgFSrQLl25WIsndeOyXQO3/vzGyXHsYz8fIH18VY8MtyqB3m5pM61rt08dhpAc9d6Qe3n3PrxNNLcXk8crdjmzp2Lf//3f8f//d//4Ve/+hW+8pWvoLvbnUkDYQ2RjrPlBP0+/nfV6uS93FBgePVeWQa4u4Fk9YC5RFjrZC+qls2NzJdJ69301e0xkdazCbxaL9B6D+RWsufcsd6iRI8F8hOpnK1WkJm8VWl9Uc5e9typutTIV56LduyxsqkQq5KRr8VYZRV2rkadKdzg1sjIKh2xIA+qtQEmCzBEZ+MBJehg99Fta1/DR+59tmrQcZB5bDSArB5wNp+x1ld7LWbkvf7uy2k3qZF/oSirP3Feh24m+90n9mF+dxSjiSx+tXEfxpLKPNAp8PoJ+n38M3FjeMfmSBEbJczIj9fIFzeZq81RzF9FhNmd10bFbukt67NeDs/Iu1h/+HwS/nX1CQCA/35uD3YcUo0XvWg9VwsZOFsb6qkstQayTlWUIb/yd24z8nbay5rRSHN7PbG8YhsZGcG+fftKHtuyZQs+/vGP4+///u/x4IMPCj85Qh9RjrN6WO0lr12UlON2Q0GL0Xvtbg05fq+jglvciIItdnIFuaK9B9thDfl9jnq+6+HGQZtL611MpF0mZndWM/L1Hsi5CZeJ2R3vIW/B6A5QFsehooTNjuEdy8hbNbsrb/mWFjS52iGscy5s7JEka5sK7HyN5Oq1GquswO45rVmkKHiNvEMjIzuoLehUeb1XRncs6MiVfV7Vgo5G7CFvd+5mGfmq0vpM7e9dQJuRrwwu1zNZ/QL9vth+n4TL37oIAPDjp3byDV3R83K1FnnVyBdkPj6JkNZ3xEpr5Id4Rr42Znf19pWxQm+1jHxGjELiLUf34u2LZyFXkPHNP77GH/dCWl8L9aDZmk5EeYioPvLc7M5l0sDLxGYzYflT/PSnP4077riD/zw0NIRzzz0Xzz//PNLpND72sY/hpz/9qScnSVTCHGcf+MQKXHZsHg98YoVtx1k9Ijac69mipHyXWsSGQvnrMHfdJcUWNp99xzGOn5871jdoRh6olNerLWLELdLdyHwnixl5N+fDM/JTlZO11UC+3gO5lYw8W0BaNc2RJEmV1xtkJPSwWiPP5OqN4VpfWa/PynoiAWtt1NjCxGzzcdXSfnzjAydVPC56rKqG2T3uloSDulGncOd6TUZ+woNA3k3QwaT1fQ3gWK/Fjlu8NpA3M6BlfeRFBJp2YJuTetnuF3h9vPEm6t+tmI+OaBA7D0/hwef2AFACDpFBZBtvkecsANbepyLuLW52l8iiUJB54FbV7I4b97kL5JvBIKynSkZeHevcX+83XHgCfBLwh82D2LBbUZF4Ia2vhXqwzWRNxz4zN3XpwvrIuzTd0+JlYrNZsHwXPPvss/jJT37Cf77//vvR3d2NTZs2IRAI4Fvf+ha+//3v4x/+4R88OVGiEr9PwpmLujG8TcaZi7qFBCtGslsjVi3tx/9uOoA1mwfxodOOwAeXH4EzBJ2LFlbbdP7i2dg6EMerg5PV/8iARmw9ByiDZMjvQ6bo/typmUPiHrSIYZPgpIOAgikE3BhrdbcoC+xRHbdWOz3k2UB+80NbSxYofR0R3HTREk8HcittsZjLcLuN7663LYz9Y0lbzvXWXesNpPWsbq2GZndhvqmgycjbaD0HqAuTagZyLIs8uy2MG99zAma3RTwZq8wIB3wI+CTkCjKm0nmhjsi1ktYDml7yhysz8iIzqm7MLBuph3w5bD6rxryuKHySssl2KJ7WLROQ5fqZ3bUbBMljiQxeP6jM0SsMMvKAkkE8++hurN18EAPFjZeHXx7Aht2jwsZut73k2X3ls6gQqkanJrM+msggm1c2LarNdaIy8vX2lbFCtYw8UwS2COgisLivDX+3fD5+8cJe/PuabfjVp87mGXmRreeYenBwPKW7MSlBWbO4UQ+aZeRFzA8hQWZ33FhX0HhVbmRYj7m9nlheWQ4ODmLRokX850cffRTvf//7EQgoT/He974Xt956q/gzJGqKnV7yDNbq4q3H9njiDK7lhP52AMC2gQnHz8FMdboaTFoPKMFLJlkwzMiLMrpTnqsYADkwu2PfuQizO70WMyzDPcuCOzVQv4GcLb6GzAJ5m2Z3ADCrmJGwF8hby6jz3u3l0no+udYuIx8JVmbk1dZz1s4jyr0lzBfqzGX9+P52vG/ZPNvnKgJJkhAL+TGRygmvk08IzHJUQ83IawL5hPiMvJugg2XkG6VG3glBvw9zO6PYN5rEnpGE7nvJy+AZ7Fqb3bUbmN2x+vijZrWYdhhYu3kAazcfrHiclU2IyKi5zWRrW52JME1kG11jiQzfbOptDVV11Gf31YSLWn+g/r4yVmA18sbSenEZeQC49oLj8PuX9mPD7lHc+odtfL3V1y4ukGfqwSsf2AgJKAnmRakHWy1J611k5ANiMvJ22staxerm6HTE8oqtvb0dY2Nj/Of169fjrLPO4j9LkoR02p7LMtF4sIWAHZOtCe5W7H1gzAL51wbjjuV3zOyu0TLygFrzVZ5d5C7xAgN5N33kpwRsLLBAfiKVq6i5spORZ7jtiewEttEwMpUxrBuza3YHWOtPXw6bXKvXyKsZea1c16o0XyRhnfZzvMesxQVHLFSZ1ddj52FFLrmoR5xc0gnsvnOygWZGLTPyao18pdmdyEDeTdDBNtfm2BhDGpFqdfLaBjP1aj+XyORLxr/ndyuy7DMWGmcXWdmEHiJrtd1m5EV3g+gomt2NJ7OWje4AbR95dxn5evvKWIFl5CdSOd2gcUpQjTxjTnsEb188GwDwwyd28sdXfucvQo3/vJaBt2o8WHJl6xG3PeQBNSPvukaeq+5qlzSYzlj+FM844wz8x3/8BwqFAn71q18hHo/jHe94B//966+/jvnz53tykkTtiOhIXavBdoi9cCsuZ1FvCyJBH5LZfEUfY6uMNWiNPKAOsuUt4UTUpJfjxuxOxMZCZzQIFmuPlhneOQnk60FXLIRA8U0YZQ/smt0B6gaBLbM7q33ki4v9ggwu61T+3po0XyTctV6bkc/a261nwUsmX7l40cJk4CwIrRdeOdeLzlKZsbC4GTI4keIbCF641jsNOmRZ1rSfa96MPFC9BR3b8w34pKqbeKIxau/GMvIrTAL5WtVqm7XIs4LoDbJOjdmd1R7ygDhpfSOZfxrRHgnyeXVYx0MnkRY71inKkMGKx71w8bfjkWEXbReh8jVkUqDZnaga+VomDaYzlkf9f/u3f8Pvf/97RKNRXHzxxfiXf/kXdHWptU8///nPcd5559k+gbvvvhuLFi1CJBLB8uXL8eSTTxoeOzAwgEsuuQSLFy+Gz+fD1VdfbfrcP//5zyFJEv72b//W9nnNVFgWzKiVkx7xlP1AxSl+n4TFfe7k9Twj34DSejYQJ7Oli464Bxl5bnbnIKAQIa33+SS+maLtJV8oyNzJvtEDeZ9P4tkDo+y5XbM7QKmRN3tOPXggXrWPvPp7bQBttQ+9SHgf+ZKMvPJvyzXymuPMSoLYxh+ThdcLr3rJT9UwI98ZC/HAYveI8rmOeZCRd2pmOZnOcVXT7AYzu7NLtRZ0LCNf62w8UNrejY1zqWweL+8bAwCcvtC4Pr5Wtdpu27ZNCQiAtPA+8omsLR8H/j6SWVPjQyuwzHB5q79GMQjz+SRTwzv+nQioka+Hi79X6sFQwMeDbdYimJEQoCxRM/LOPwtZllXX+jqMWdMRyyu2ZcuWYdu2bfjlL3+Jp59+Gv/2b/9W8vsPf/jDuP766229+C9+8QtcffXVuPHGG/Hiiy/i3HPPxYUXXog9e/boHp9OpzFr1izceOONOOWUU0yfe/fu3bjuuutw7rnn2jqnmQ6rS7VaIy/LssbMqzaBMXOudxrIqzXyDZiRD+pn5L0wu1Mz8vYlviKk9YAqr9f2kh9NZPik2d2A5Q/lVDO8c3J/WHHDL4cH4lWyciG/D6zUU1tCwzYCRNatVSOiU6/Pz8PihkI4oL4fow3IQkFWA/m6Z+TZBlrzSusB9XPcVSxZ8Kr9nBM5KguQ2iKBmju5i8aqtL7W9fGMcun6S3vHkM3LmN0W5ueuR61qtdtNWuRZISm4GwTvI5/MYtCGjwO7r3IFuaqxpxVWLe3H5951LABg2fwOoZlhEfS0GM+BSY1vgVuawcXfDupGcek1wjxUYm5c6wVk5LVzfb3GrOmGrdTLrFmz8L73vQ9nnnlmxe/e8573lJjhWeGOO+7A5ZdfjiuuuAInnHAC7rzzTsyfPx/33HOP7vELFy7Ed7/7XVx22WXo6OgwfN58Po+PfvSjuPnmm3HUUUfZOqeZjt0a+XSuwB0sayGtetSLJwAAdW1JREFUB7SGd3FHfz/SoK71gCYjX14jzwNncZ8xc3x11n5OTDs8vV7ybOLubqluANQIsKDbyPBuwoFihW1g7B6ewjPbhy1lA9h9WE2uJkmSGkBrMuH1zMhrxxu7RjiSJPHFidEG5MF4CqlsAX6fJLQ3sBNauMmkN9L6aI0CVyavZ73kvWg/x2By1HsvW84z8f/zqbMNg45G7CHvFNYhwDCQL17y9VoUlzvXv1Bs4XX6wm5Tc7ha1Wq7rZHnJmGC1HDs/sgXZOw4pDj7W5HWR4N+BP3Kp+VUXVAOK2lbOq+jZr4yVjHPyIvbXGkGF387qIZ3pdcIm1dFZOQz+YJjVYh2rnfbR55QqNtWdSaTwYYNG3DDDTeUPH7BBRfg6aefdvXct9xyC2bNmoXLL7/cVKrPSKfTJUZ9ExNKpjebzSKbFTNgegU7P1HnGS5OFFMpa+99uBi8+CQgJBVq8nkdO0tZ2Gw9MG779fIFmWeO2kJSw32/kUBxok6mS85tIqlMZrGguHOOFMfzSYvftZZ48TMM+61de0bXaVcxuD00keS/GxhVFqy9LaGG+3706GlRFmaDYwnd82XXWyxg7bv745aD+OrD2wAofeQ/cu+z6GsP40urj8e7T5xj+HdsgvSj+n0YDig+E/FkGtmscv4sEAxI4saTagQkZTGQyub4a04VFyBhi58XoEj0pjJ5TCTSyLZXbtBtP6iM6Ud0RoFCHtmC8Ual6DG14lyLi5eJZEboa7CNgZBPrsn3N79TCZJ3HIojm81y75EWgWNUOecf24OTj+jAS/vG8cRrQ/i75frdBw6MKpsLs1ubYwwxo79NuZ6H4mlMTKVKFuLZbBaZgjJnRAO+urxX1v1kdDKFbDaL9TuGAQCnzm+vej43XrgYn/n5S4Yu3jdeuBiFfA4mt2tVYsXNwvGEs/uNzb0RG+ORGX7ICAV8yOQKeG1QSUb0xAKWnrstEsDIVBbDE0n0xtwv3w8Vg9POiLXXd4PdcbWnWIJwcLxyXmXJB6vrD/PXsfY5Wv2O6g3b3BifKl1DTqbYms35dSzJ6o2YSGUceXJMJJSYIeCTIFeZi+uF12sAO+dghboF8ocPH0Y+n8ecOaUL0zlz5mBwsNJ0wip//etf8aMf/QibNm2y/De33norbr755orHH3nkEcRi9XU4tsq6deuEPM/gfh8AH7a8+jrWJF6tfnwCAAKI+GT84Q9/EHIO1VA21gMYnEjjf36/Bi02EkBTWUCWlcv+mcf/jEZL+A4fVD7/TZu3YtboFv74G7uUx3e/+RrWTFX/XqxwMAkAAYxPpbBmzRp7fzviByBhy4svIL3D+t+VX6eTw8r7Wv/SVvSMbAYAPH9IAuAH0hO2z6sejA8q7+GFLW9gTfK1it+PTiqf1cbn/op9L5s/10vDEn78Orso1ezI4EQK/9/PN+ETxxVwSo/+TvhkQnmd555+CrurDFtyXjn20cefwButymN7Dyjv4/VtW7Cm+F14zbbDynd94OAh/l1v2q88dvjgANas2W/tiXLK+/nzX57EjrbKXz99UHnOWGHS8jUlakwtZ0Rzj68Z21L1eKsMFe/JV17cgPQOcfWcRowV79ONr+/FmjW7MVK8zl+0cJ27oQ8+vAQf/ufJV9By8CXdY54oXkPZicNNMYaYIctA1O9HMi/hZ//7R/SV3dsskE9NxevyXlNx5Xr+6/qNyOyU8dwO5TpI7d2CNaPVr++PHyfhN7t8GMuo411HSMYHFhaQ370Ba3a7O7/XRpVrYe/BYUefz4sHlL8fHRoU9vlGJD8ykDBaLPN782Vr82igOG4/8viT2N7u/jy2ble+u8Hdb2DNmtfdP6EFrI6r40PFefWV13BEfFvJ7yamlM/h+Weewm6XAquCDHSG/BjLAJVOHAAgozMEHNr6LNZs0/l1g5EtfjZPPPs84m+o88Brxe96367tWLPmTUfPrST1lfXz//1hLZxYFAwV151+qdDwY7NXawArJBL6Ciw96l48Vi69kmXZca/OeDyOSy+9FPfeey96e3st/90Xv/hFXHvttfzniYkJzJ8/HxdccAHa2wWMlh6SzWaxbt06rFy5EsGge0njlkdexxODuzBvwSKsvnBx1eNf3DMGvLQe3e0xrF5dOz+Cu958EntHkzjipDNx9lHWe0fuODQFvPBXtIYDuOhvLvDwDJ3xwv+9iucO7cH8hcdg9cpj+eO/OrQBGB7GmaedgtWnzhXyWgcnUvj3TU8gXZBw4YUX2rrv/n3zXwCk8c7zzsGJc6vfI0bX6et/fhN/PbgDPXMXYPXqEwAA+5/aCbz5Bk5YOA+rV59k+33VmtHn9uCP+19FrLsPq1cvK/ldviDjc88ok8FFq96FHpNyjnxBxq3ffgKAnkRfggTgDwdj+JePvk1XAvnFDX8GkMe73nG+aW0qANzx2lMYH0lgxZlnY/kCxZDqF0MvAKMjWHHaMqw+pTZ1kuFtQ7jvjU1oae/C6tVKydabj74J7NmBYxYdidWr9d2Vy/n+9qcxPDSJU1ecibfo9JJ95Y+vAzt24fTjF2L16uNNn0v0mFrOS394DU8P7ca8BUdj9buPE/a8t297AkimcP45Z2PZ/E5hz2tE/94xPPDmekxKMax89znIPPMnAMB7L3yXp/4jfXvG8Md712NHIoR3r3q77r2wcc2rwJ49OPWEo7D6AnGfcb344e5nsHUgjgVLV+Cdx8/mj2ezWbzwoPK598/uwerVK2p+bo9MvoxtY4NYeNwSHL2oG6lnn0FL2I/LP/guBCzslK8G8C8FGS/sHsVQPI3ZbWGsWNAlTOY9a9co7n31efgjLVi9+hzbf//mo28Cu3fg2KOsj0fVuGv7XzExpHbdef+F78RsC8auP9r7LIb2TWDJKSvwzhNmVz2+Gj89sB4YGcO5p5+K1Sf1uX4+M+yOq/uf2onHBt5A++zSdYAsy7j2uT8BkLFq5TvQJ6B8JrjwID7zc2VTsFIZIuFrHzjFVA3XSPxmeCO2xw/juCUnY7VGsfTn/3kFGBrAKUtPwOq3LnT03Ll8AV9Yr4w357/T2Tj/6mAc2PQM2qJhrF59vqPz8Bqv1wBWYMpwK9QtkO/t7YXf76/Ivg8NDVVk6a2yfft27Nq1CxdddBF/rFBQ6j4DgQBee+01HH300RV/Fw6HEQ5XDqLBYLBuX6JdRJ1rS1i5MdN52dLzTeWUYa8jWtvPasncduwdTeL1oQTettj6BDRZrAPubgk15HfLnM1TZZ8/M8bqaAkLO+/OVmWaKshAHn5brsesRr6zJWLrfMqv096ikdFYMscfH5lSnntOR7Qhv6Ny+joV06/hqUzF+SYSqjyquzXKzWL0eGH7MAYnjM3tFNOdNF7cF8fZOsEqM5FpjVa/Rpg8Nyf7+LGZ4r3cEq7dvRyLKONNRnO9s5rfWMj6eUSLdYGZgqT7N3tGkgCAo2e3WX5Or8b/1qLZVSpnbYy1SrI4tnXYvCedcswcxadmYDyF0ZTqtdDTFvO01nb5wh60RQIYT+bw6lBCd9Pi8KRy3/V3xppiDKnGgp4WbB2I48B45RjDzO5awoG6vNeO4mI+kS1g035l8XnakV2IRqx3CwgCOOc4bwKlrlZljomnco4+H+YZ1hoRt2boioUBKIG8T1LmECv3TGdM+Uwns2LGDqYImFXDudbquDq7XdmMHklkS45PZfPcM0bUWPc3y45AIODHzQ9tLTG+6+uI4KaLljSMAaAV2ovzS7Jsfkmx9YGL6zgYVK7XggxA8jt6npysXOeRoLO/ryX1jAHtvK5lYfGBAwdw3XXX6e4SjI+P4wtf+AIOHjxo+YVDoRCWL19eIV1Yt24d3vKWt1h+Hi3HH388XnnlFWzatIn/9973vhdvf/vbsWnTJupzb4GIjvmUGcxAplaO9Qwnhnf5goxntiv1e0GfJLSdiChYfVOioo980VxOYPs5rXupnV7yhYLMNxbcuuh3c7M7NYBlZnfMRK7RYS3y9MzumClRJOirWk/mxnQnly/w69lKH3jWS77Utb72LWHYa6U1bfDYOdkx5almdtcojvUA0OJRH3lWN1qrNmRdsSA3Enul2G6sLRzw3DAr4PfhrUcrirsnXj+ke8x06SHPMHOuZ4F8vVo5cbO7ZI47e59u0j++1jATXudmd2Jd6wGgQ9P6trc1bPmeaY+oLehEwExmextwru01MLvTGgG7cWAvx8v+7rWk1cDEmM2Nbq9jto5JO3SuZ+dBrefEYTmQv+OOOzAxMaErNe/o6EA8Hscdd9xh68WvvfZa/Od//id+/OMfY9u2bbjmmmuwZ88efOpTnwKgSN4vu+yykr9hAfrk5CQOHTqETZs2YevWrQCASCSCpUuXlvzX2dmJtrY2LF26FKFQ47mUNxp2XevZhFKLHvJaWCC/1WILurWbB3DObY/iW48odWDbD0/hnNsexdrNA56doxNYq6RE2ec/6UH7OZ9PUoMKG4G8NgBx236OtZgZnVIXJodZIN/gPeQZszU938udXJnRnZWNLjftmJhjPQBLBjTMcK2kjzzrQ19DJ1n2Wlr3fCcTPRu3kjrBcaEgY/ewEgAxp/V6wtyvyzfr3JAvyHxhVav2c5IkYVFxY+SlfeMAate55G3HzQJgEsjHWSDfHGNINY7sMe4lrypY6t1+LovndzVeIM/OL5MvWF7XaGH3qdBAXnOf2NlsYn83LiCQz+ULvBVvI7Z5ZZsLh8vaz7H1Rzjgs1S6YQev+rvXErX9XOlcmBDUnjTIe8k7C+TZXF+rDeeZgOW7YO3atRVBtZbLLrsMDz/8sK0Xv/jii3HnnXfilltuwbJly/DEE09gzZo1WLBgAQBgYGCgoqf8qaeeilNPPRUbNmzAgw8+iFNPPRWrV6+29bqEMWzxbNSPuRzeWqvGGfklxUD+zaF41Z6WazcP4MoHNlb0Ch0cT+HKBzY2VDCvZuRLB+G4oL7t5ai95K0H8uzYgE9yHfR167WfK2a2GzFLoAfbcEjnCpgoy/pwxYqFAMdNOyZtIByysLiJ8Iy8+nepOrafK83I21cGqIF85bg1MJFCOldAwCdhXmd9W88BmoyJwIy8VolQy77pC3qUQP7lYkbei9Zzepx7rJKRf3HvWEUrLlmWeR95tz3IGwWzjHyWudbXKyNf/M63DU7g4EQaAZ9UE48Gq7SGAmD2L07atiV42y5x91VnSSBvfZ5j95eI9nNMVi9J8NTTwils/h+ZyqCgUU+y76NF8FpousA+l7hBIO/2OmZrvozDQD7FN+obzGm6ibH8Se7cuRNHHnmk4e+POOII7Nq1y/YJXHXVVdi1axfS6TQ2bNiAt73tbfx39913Hx5//PGS42VZrvjP7HXvu+8+/O53v7N9XjMVvQW+GRNJ1k+8toH8EV1RtEUCyOZlbC/2YtUjX5Bx80NboSeiZ4/d/NDWhpHZ82ydJiCRZVntIy8wIw8Y796aoVUHODWmZLBAfjShTtYskG+WjHwk6OdZn0Nl8np1o6v69+b3SbjpIsVMqfxTZT/fdNES3SwBy8YGfJKlLAXPhOtm5GsordfpZ590MNGzIKZcyQIAuw8rsvoju2PCMzhOYIG2nXuuGkz+K0m1XSAxhcPLxYx8Z6w288D87hiO6m1BviDj6TeHS343nszyzd3Z0yUjrwnky1U/6eKtIzLQtAMb2zYX6+OXzuuoW097PXw+ic9zTuT1bMOtReB70t4ns21k5NsFZuRZOVtXLNSQmWe2NshpWgYD6rhZLwVKo2O0pksKKhHhGfmcszUzSevFY3nGj0ajpgHzrl27EI3WP9tBuCNapda0HB6o1FhaL0kSTuhjdfLG8vr1O0cqMvFaFAOxFK/tqzes5iuhydYlMnmwtVtbWOxCme3e2skOTgpUB3QVewfmCzImUsoCnBvwNEkgD5TK67Ww0hOrG12rlvbjnktPQ19H6eKuryOCey49zbBez64sXm/DTq2Rr31GPqVTIx+xsaHAFicpnYz8zgaqjweAllDlZp1bmBIhGvS73lyzw8JiRp4FSLXKyAMaef0bpfJ6lo3vigVruinlJXM7o/BJyj1aPsawqbpuGfmysU1PMVRv2Dk6CeSTgiTJWto090kmW7CcSOAZ+aT7TcCRYu15I8rqAaVEjG0SaT10eEa+ThtXjQ5bl02mDDLyLseJEM/IO5u/uPJvmozNjYDlFduZZ56Jn/70p4a/v//++3HGGWcIOSmiftg1u5uwUQMsmhP6lYbRWw8YB/JuDMTqQSzMAnn182eBs98nCQ+yWoqvN2mjXldkIB8O+LmB38hUhk/YAZ9UIj9sdFTDu9LraMKGtJ7BTHf+6W2LAACnzu+sarrDMpBW6uMB/fuc/buWEyx7rWxe5otZXkNnY+HMM/I6wfGuYkaeBZ31JuaBtF5U/aNdFvaWeg7UNpBXDe+0WerpZnQHKFmwucWykN1l8nqWka9XhrL8dU9rIFk9Q1vHbxfR0vq1mwfwnUfUnu2/2rjPsl+PaiwoIiOvBPJmLVHrTS/fIFdL77ipJ2XkdWGqzfJySVEbUiwj79TszomZLWGO5ajguuuuw09+8hNcd911Je70Bw8exOc//3ncd999uO666zw5SaJ2RHXcrM2wUwMsGu5cP2gcyLsxEKsHMZ1sHfuMW8PupezltDiQ+U6mxAXyANBddKcdmcqU1Mf7GlDuZwS7fowy8lak9Vr8PgkrFiiZLbn4sxlsUrUahHO3+OJ9LsuqWVota+S1G1NsM8KRtJ55S+iMWzsPK4HPot76G90BWumjuIy8GmzUdnG0oGxzpJaB/FlH9SDol7BvNIldw2pwywJ5O5LlZoDL64dLA3kmqonUYWG8dvMAPv3gxpLHvvK/WxrKdwYodda3S0KgtJ759YyVBeJW/XpEmt0NF03kelobOJAvmuHqZuTDFAjqoed7JMsynxvdeqiEuNmdS2l9DU11pzuWP8m3v/3t+P73v4+77roLc+fORVdXF7q7uzF37lx8//vfx/e+9z284x3v8PJciRoQcSqtF1y7bYUlc9UWdOV1gww3BmL1gC0WtNJ6kRnwitdzUiMvuF6fGe0MawL5ZpLVA+r5GtbIOwhw2AJrNJGpcqRGWm8x+OXS+mLwnM3LvHyjlhl5rTEfew8pBzV0ZtL6Rmo9B6jnKrJGPlknuWlPS6hkXKrlhm4sFOCbXVr3etYGck6TjSHVWNCjb3jHXetrLK1nQenhsvZgh+LphjORFZORd/f5ivDrYSWMIszuRqYaW1oPAL1tyrkdjlcG8rU09Wwm2nTWdBlNe1q313GQSesdZuTTVCMvHFtbIv/8z/+M7du341vf+hYuueQSfPjDH8a3v/1tvPnmm7jyyiu9Okeihtg3u3MeqLjluDlt8EnKhKTXwxsoNRArp5qBWD1gg+yUVlqfYoaCXgby9ZHWA6q0b2QaBvJcseKg9IRtcIxMWQjked2ZxUA+UCqt19ao17L9XMDvQ6B477Exx1H7OQNpfb4g8wxmo0jrWbCdzhWQc+j8Ww6T6dc6Iy9JUom8vpYZeUC/Dd10lNYDisEfUNmCLsNc62v43TebiawayDvJyIvZJBPh1yMyI3+YS+sbd67t4Rl5dQ4UqZCYjuhl5LXdXNxK68Mu28+x5AFJ68Vhe2SaN28errnmGi/OhWgAeBsnyxl574LMakSCfhw1qxVvDk1i68CE4cJt1dJ+/PN5R+EHf9lR8nhfRwQ3XbTEtPa41rDFQqa4yA/4fZhMK5O2Fxn5WEgZlF/aN4Zntg/jjEXdVTc1hEvrNYE8U1bMapLWcwxudjdpIK13YAbJPpd4KodsvsBr0/RI5+1J68NcWl8o+b/yHLWVvEWCfkymc5qMvP0+s6x+tXzcOjCWRCZfQEhTY1xvYhpJaCKbR7vO95ovyFi/cwRD8RRmt0Wq3pdeGHJZ5cjuGHcsH5pIIV+Qa7Yx+rbjenHbWuCZHcPI5AoIBXyaQL65xpBqGLWgy3DX+tp993aC0rOP7qnZeRnR7rBtmyzLPHB0e2+J8OthgXwik686J1SDmd01tLSe95LX1sgXxzpqP6dLq04gzzajgn7J1TUDAMGAMrY7zcinSFovHMt3wv3336/7eEdHBxYvXozjjz9e2EkR9YMtnjO5gqUFWT3N7gClTv7NoUlsPTCBty+ebXjc3tEkAOA9J/XhghP7LC2O64F2McYW+fGUWCk7Y+3mAfzi+X0AgEdfHcKjrw6h38LmhuiMvLZGnmUomaSuWeBmdxP60non7RnbI0H4JKAgA6NTGdOaXxaIWzW7Y8E6y8RrXe9r6XrOXnMyrdb5O5HW824bZRn53cVs/PzuaMPc6+GAH0G/hGxexlQ6VzF2rt08gJsf2loSKFW7L1VH4toubtduHsBfNNnw/3j0TfzPhn012yA9oa8dva1hHJ5MY8PuUZx9dI/aQ36aZeQNA/k6uNY3m4ms04x8OlcAExW43SgR4dejnUcmkln0uNjwbgZpPdtkODypldZTRt4Mti5LZdVkkCjHekAth3PaR57N0WGS1gvD8qz/uc99TvfxyclJFAoFrF69Gg8++CDa2tqEnRxRe7QGU+lc3rQOKZ3L88V3PaT1ALCkvx0PvXTAtAXdZDqHP21VDBqvPP8YLJ3XUavTs0044IPfJyFfkJHM5NEeCXpSI8/qG8uFj8x0x6zVmega+W6NhJwFlM2XkS+a3VVk5Jm03v5n5fNJ6IqFMDyVwUiiSiDvuP1caRa81tl47Wuq52J/0REzUBKx1nOLGqQ+nhELBTCezFaUtDi9L0VlDe3gZgwRhc8n4dxje/HbF/fjiTcO4eyjezA0TaX1LJAfiqeRzOR5YJmpg2t9s5nIsgDYbkY+USJJdjffMb+ewfGUbkmCBEUlaObX4/dJaAsHEE/nMJHKuQrkDxcN5BpZWs8y8sOaeXWKj3WUkdejRbNOnErn0RHzaRRb7j8zltF3nJHP2VfcEeZYXrWNjo7q/pdOp/Hss89iz549uPnmm708V6IGaHs3l2e3ymG725KkGmzUGtaCziyQf2TLINK5Ao7qbcGJRYO8RkWSJG5axMxKRNfIu61vFJ6Rb9Ezu2uMBaBVWEZ+ZCpTUjvmxuwOALparNXJq671zvrIs42AehjQcAf9XAHZfAG54nVnx7U+wmvkSzNujdZ6jqFnaunmvqy1tL6RaqS1begKBVk1u5tm0vqOaJDPAXtH1aw8l9bX8N5tNhNZ9rnZda1n9yfbYHeD1q+n/Jns+PW0C6qTZ3NKY0vrWUZeUyOfrl8ZUTMQCvi4Mi9eLMsUudHLnttxjTyZ3QnHdfrF5/Ph9NNPx7e//W089NBDIs6JqCM+n8Rv1FSVHTcmq28NB+rWKmxJsQXdzsNThhsPv990AADw3mVzay4bdkJ5L3nRgbNb0x3RNfLcnb2Jze46o0Fu2qaVAboxuwNUtcLolPmizX77udIseD1azzHYeJPOFkraXjpxrS8fA3gg32gZeR2TSTf3ZaLGvXlFGHeJ4pxjFMO7LQcm8MbQJHIFGZKkZvOmC5Ikqc71mhZ07JapZY28qKC0VrDx165rvdrqTMxct2ppP+659DT0dZRuVPd1RCwrWEQE8rl8AWMJ5e8buo+8WUaeauQNaSubX0TODyG3GXkH7WUJc4TdCccccwz27dsn6umIOhIN+pHJFapm5CdcBikimNUWRk+LIj9+7WAcy+Z3lvx+eDKNp948DAB47ylz63CG9lHkT2m+iIinWUZezOfstr5RuLS+Rc1mjxVbrTVbIO/zSZjVFsbAeAqH4mn0d0RRKMh84ejE7A4AulqU73ykSgu6jM1AnClvUmV16bVsPccIa2T+TBovSfZk/s0mrddr++jmvqx1+7lGqpGe1RbGkv52bB2YwK83KmuQnpawa1OnRoQZC7I6+XxBRlYuutbXOMPFgtJyP4dGNJF1WiMvsraYsWppP1Yu6bNlZqmlnasLnAfybD6RJKAz1riBPNvkn8rkeTmJ2kWAMrpGtIQDGJ7KcKNkkYotysg3HsJm/e3bt+OII44Q9XREHYkG/RhPZkuyY3qwiaQejvUMSZJwQn87nnrzMLYNTFQE8mteGUC+IOPkIzpw1KzW+pykTWJlslvRGXC39Y3CpfXFhcTBiRSXVTdbIA+AB/LM8G4qk+NGSY4z8i2qWsEMJo0PWQxeWMCfLsvI12OXnLnXpnOFkjZ6dtQzEZ32c7l8gbfqarSMfAtvM6kGFm7uS7YhUKusbKPVSL/tuFnYOjCB32zcD2D6yeoZ88sM77RzdD1qht0GpbXCeY28N94Tfp/k2M1fRAs6JqvvioUa7rvS0hoOIBTwIZMr4PBkGvO7Y9RH3gKqc30xI882pBqhRt5BVxrCHNerNlmWsXHjRnz+85/HRRddJOKciDpTLrs1wm39ryiWFOve9erkuay+SbLxgDaQL5PWC9owcVvf6JVrPQvio0F/U+62l7egY4qVkN/n2ESu22qNfNZmRl5Tl17y93XMyKdzeUdGd4B6z6RzBRSK19GBsRSyeRmhgA/9DWZ8xhah2o2HMxZ1Y5ZJvarZfcmkk7WqG220GmlWJ8/KWkJ+X8P0MBfJkWW95LUKlHoYVQJqUPq+ZfNw9tE9DRkYdkQdZuQbsNVZh8NWelqGWeu5BpbVA0qihhnfsl7ybNOyJdx8a4RawQP54vWeZBtSIlzrA8y13tn4ysasepTxTVcsf5JdXV3o7u6u+C8cDuP000/HvHnz8NWvftXDUyVqBVvkV+slrzpy1zeQNzK82zuSwAu7RyFJwEVNFciXLvK52Z2gxYTb+sYpwRsLLSF/Sdu03rZQU3gZlMNUBKzOX9tD3un76WI18lWk9bZr5AOqnF35e3uu9yJRXesLfMyxK7vTZqLZczBZ/YLuWN08PIxgi1CttD6bLxi2D6x2X9ba7K7RaqSHJ9Ml5/Hi3jGcc9ujWLt5oCavXytYIL+7LJCPBn0Nd403Em2aGnlZth6A8A2yBsoeiqiRH26C1nMM3oKuOK9SRr46bG3G5pekwI1e9xl5ktaLxvKdcOedd+o+3t7ejuOPPx4nnHCCqHMi6kzUwDiqHLf1v6I4oZ9l5OMoFGS+oHnoZSUbf9ainqZqRVQurY8LDpwBd/WNccFSf0mS0NMS4ufRbK3nGOy8WV0wD+RdbHRZzchnbLvWl5nd1bH9XKQkI+9MdlfSbSObR0s4gN3DjWl0B2hr5NUx9paHt2L/WAqt4QBiIT93XweUVmpffa9ZH3kmra/dWNwoNdJrNw/gsz/bVNc2eLVCm5EvFFuUArQorgYr/yvISr211bkr0YDZX56Rt+nAr2WkqFxpZMd6Bje8m2KBfO1bbTYbbH5ha0dVWt8INfIkrReN5Vn/H//xH6sec+jQIcyaNcvVCRH1p9wIywgura9zRv7oWa0I+X2YTOewbzSJI4vOvv9blNW/b1nzZOMBnYx8Wu0OIBJW3/ihe57Gi3vH8MlzF+GGC08wzaJlcgWe/RV5Pl0xTSDfhPXxADCruFnEMvJsw6PNRemJ9fZzxRr5Jmw/F9bUyKuyO3vn4fNJiAR9Sla/eN/sPNyYRndAZfu5h146gAef2wMAuPujp+Gtx/Ri/c4RfOK+55HM5vHjj53OS4j04Bn5Ohie1bNGulobPAlKG7yVS/oaUvJtl7mdUfh9EtK5Ag5NppEs3r8U1JgTDfoR8EnIFQ1ILQfyAmuLRSHC7I5l5Bu5hzyDyf9ZCzq2+VkrY89mpLVM8SXU7M6vjKNOM/JpysgLR0iN/Jo1a/CBD3yAzO6mCWzXLlXNtZ5L6+s7oAb9PhwzWzGy21qU1782GMerg3EE/RIubLJsDM/Ie9RHXovfJ/EAIRr0V13saqXAolryAKWZgaYN5HlGntXIs40u55+T2n5OrLSe1aelcnnIsswD+vpK67U18vbPo3wDrFF7yAPqImbzgXH8duM+3PDrlwEAV51/NN523Cxed3zsHGVc0/YN1yNRY2m9lnrWSDdSG7xaEPT7MLdT2TDcM5KgjLxFJEly5FyfbEBpfUdsZknre4vrgcOTaUWFwr6TBlJJNBqq2V15Rt79ms1tRj5J7eeE4/iT3LFjB770pS/hyCOPxEc/+lHEYjH8/Oc/F3luRJ1gN1jVGvkGMbsDKg3v/vclxb34/MWz+cTXLGj7yMuyrDGX8+Z99Bd72h4wWRAz2LlEgj6h7Z20C4pZrc1TBqFldrtBjbwIab3lGnmLrvXFgF+WgUy+oKmRr0dGXjWqc1M/Fy3z9tg1zBzrYyJOUxhrNw/gvqd3AQD++uYwrvnlS5jK5HH0rBZcu/K4kmMXFDchWJmAESKlk81EI7XBqxVMXr9nOCG09nW6w53rbQTAbOO6kYJGEWZ3I8zsrgmk9dqMvHZNShl5Y1qMAnkBG1Js3Zd2EMjn8gVuahypw1pjumJrJZ5KpfDAAw/g/PPPx5IlS/DSSy9hYGAATz75JB544AG8//3v9+o8iRqiym6ttZ+rt7Qe0NbJT0CWZe5W32yyegCIBYv1s5k80rkCskV3UJE18lr6O6IAgIHxZNVjRTvWMzo1my3xVLYpHadZRv5QPA1ZlrlrvRsPCSat10rG9UjbdILV7oanNeUSdWk/x1vhFRy71gNqEJvI5EpazzWStH7t5gFc+cBG3azg9kNT+NO2gyWPLSyWCe0eNs/IswWuSJVMM9BobfBqwZGaFnSUkbeOk4x8PZUuRrD1lruMfLFGvgmk9UyhNzyZ5u06JYkyumZUuNZnxfkK8Iy8A2m9tlx3pm06e4nlO+Gqq67C3Llz8f3vfx9/93d/h/379+Ohhx6CJEnw+eiGmk6UZ7aMEBGoiII5128dmMDGPWPYN5pES8iPdx4/p85nZh9mrJPM5HjgLEneyfv6i1LNgTHrGXmRgfzazQP49Yb9/Of/fGpnUzpOswVHOlfARConZKOrJeTnveHNsvKZvD1pfcjvAzPST2Xzaka/LjXyzJMj7yowYYuUVDaPfaNJ5AoyIkEf5jRIEGdWzw2o9dzaTSw1I28eyPM+8jMsoGu0Nni1YL7G8C7pohRlptHuoJe8aqxW/zUOQzW7mxnSerbZcHgyzdsBtoScd4KZCbRyM1XxZnfctd5BRl6bjKhXu8zpiOVP8oc//CGuvPJKPPLII/j0pz+Nnp4eL8+LqCPlRlhGxBvE7A4AlhQz8vtGk/jGmm0AgAuWzGnKXT92zlOZvOoQHwp41l5objEjf2A8WbU1j+ie9ixDOZkuzZIwx+lmCuYjQT+vhz8UT/Pvzk3piSRJ6GpR/t6sTp65zls1u5MkiUvbtJnwutTIazPyfEPB/nmwcSuRyWtaz7U0TFsuJ/XcC4oZ+V0m0vp8QeYbMY2UOawFjdYGrxYs6C5u7pQE8jPre3fCtMnIc2l9zlYrPS2sj3xvM0jri+c4PJnhGflG+j4aEbY+K3etF/G5hV3UyGvXGbQRIw7Lq6X7778f69evR39/Py6++GI8/PDDyOWct78gGpeoZWm9+0BFFM/uGAZbqz2/exQA8Pjrh5oqEGSw2q9kJs+lUV7J6gGlXRSgbNyMJcx3+ScFtp6r5jgNVGYoGx2WlR+Kp4SY3QFqL3kz53onfeC1LejYRkA9JLoR7lqvZuSdBCYxTdvM3czoroHq453Uc7NA/sBY0tAlWKucaqTMYa1gbfDYOMbo64hMq9ZzjBJpPQXylmlzkJEX6fYtCpaRzxdkTFUxJNYjmy9wWX4zZORZ+7mRRIZvwjTS99GItJRl5EVex276yLN1SjMm2BoZy7P+JZdcgksuuQS7du3CT37yE3z6059GIpFAoVDA1q1bsWTJEi/Pk6ghVvvIswnRCzd1O7Csbnm4N5bINmUfYTUjn0Pco9ZzWiJBP3paQhieymBgPMXrsvUQKa23k6E8++jmUADNbotg+6EpHIqnNfeHu40ulpEYNZHW2zW7A1jQnkUqW3C0ESCKsEYBlHLRBk9bEqQa3TVOfbyTeu5ZrWHEQn4kMnnsG03gqFmtFccnqG607m3wagkL5A/F0xiZUsYYWhhXh5UA2snITzWgtD4c8CHk9yFTDMjtzsVsHpEkoDPW+IF8VywISVKMWfePKj4+jfR9NCJtFWZ3rPRKgGs9l9bbT7AwlS8Z3YnF9qy/cOFC3Hzzzdi1axd++tOf4oMf/CAuvfRSHHHEEfjsZz/rxTkSNYa3g8oZB/LZfIHLdeoprZ+OWd1aZ+QBTZ18FcO7KYGB/HR0nGYZ+UPxtEax4n1GPmOz/ZxyrHqfN0L7uXROVQa4M7vLqz3kG6j1nJN6bkmSeOBmVCevVTHMZLliPdvg1ZKOWJCrfN4YmgRAGXkrsA3VeJNn5CVJ4irI8SoKOj2YrL47FmqKeyTg9/E2rHuKBqYtDdRFoBHxNCMfcJ6Rp9Zz3uD405QkCatWrcIvf/lL7N+/H9dddx3+8pe/iDw3ok5Yychrd7XrmZGfjn2EtRl5r1ziy+nndfLmQXNc4MbCdHScLgnkBXlIMPmjaY28g9pylvVOazPy9ZDWs/PIFTRmd076yKvjFqspb6SMvNN67oXFzQijOvlGrOMlvOXIYsnF6weLgTx991Vhmx9sg9UKU/zeaqwMcEdxc9hJC7qRJjK6YzBVGgvkG+37aDQq+sgLbFPJMvJuauSpy4ZYXG2LyLIMWZbR09ODq6++Gi+99JKo8yLqiBXXeuaY2hLyIyCwn7hdpmNWV3Wtz/OB2OvNEtZLfmDMPCPPzkdEm6vp6Dg9uyQjXwzkXXpIsIz8sIUa+ZCNezGs8cJwIs0XBc/IZ/NCpPUTqSz2FSWYjdR6DnBWz72g1zwjn2jQYIPwDqbSYJvYlJGvTvs0ycgD6pzipAVdMznWM1idPGXkrcEC+VS2gJxGPStiwy/kIiOfqqMXz3TG0cz/ox/9CN/5znfwxhtvAACOPfZYXH311bjiiiuEnhxRH7SZOiNEOHKLYDpmdXkf+bTGtb5GGXkzdQOgmt21CTgflqG88oGNkICS8ohmdZxWze40rvWiMvIWauTtZLIjJdJ6ViNfv/ZzpRl5J9L6otz44CTyBRmxkJ9vrDQSduu5F/IWdPoZ+UYNNgjvOLK7dIOKMvLVceZa35jmam5a0A1PKj3kWXDcDPQUz5VtZtKmpTnaRMtEKseDbhGfm5uMPEnrvcH2t/rlL38Z3/nOd/CZz3wGZ599NgDgmWeewTXXXINdu3bha1/7mvCTJGqLpYx8g7SeY1ndwfGUbp28BCXb1UxZ3VhY/fzZ59wa9vZznluskT9QLSOfEbuxwDKUNz+0tWQToa8jgpsuWtJUJoWAumG0e2QKuaIvg+sa+RYLrvVZ+zXy2jaTTjYCRMFeM51T2885qpEv/s22gQkASg/2Rq0ZZ/XcVlhQpUaeGXJRMDdzYBl5BvWRr44T13ourfd4I90ubN3lJCPfjNJ61ibvcHETotE2VhqNUMCHUMCHTK6AQ/E0f1yItN5VRp6k9V5ge3S65557cO+99+IjH/kIf+y9730vTj75ZHzmM5+hQH4aENa0pTKC7QTX27F+OmZ1tYMtG4Q9N7uzmZFvFbiBM50cp1lGnkm7/T7JteyVGf2MThkv2jJ5J671mvZzDszyRMEz8tk8Ui4y8uy+YdLRhT2N03rODQuK5QF7RxPIF+SK+4Iy8jOPykCevvtq2HWtz+ULaiazwT7fDk0vebs0s7SeQRn56rSFAxjOZXhZqSSJKZ0L+pX5J+MgI5+mdpmeYPtbzefzWLFiRcXjy5cvp77y0wRbGfkG6CE/3foIRwJ+sEQiC+RFSNnNYDXyg+MpFEwc/lXzPbED8XRxnGaBvFz8CNsjAddZ4a4W5R4bMZDW5/IF3pUhZLv9nBLIc2l9HTJ7fOMwp7afi4bsn0f54qCRjO7c0N8eQSjgQzYv6ypmeP2jgNZCRHNAgbx9VNd6a+vUhGb9E2uwmmy2KeFOWt9MgXzpubbQpmVVmLyerSFjgrqauMnIJykj7wm2Z/5LL70U99xzD+64446Sx3/4wx/iox/9qLATI+oHk2iaZ+RZ/W9jLB6nU1bXV8ziJjJ5HJxQdlO9zsj3dUQgScou60giY1g/p7afq/8GTiPSGQ0i6JeQzTNZvfvPSetaL8tyxWSc1kyoTtrPpXMaaX0dMvIRTUae18g7OI9yaXkjtZ5zg88nYX5XFNsPTWH3cALzy4K4Rq3jJbyjvzMCv0/iG3hUVlEdph6cTOd0lS3lsLHI75NsmYjWgg4XZneqtL6JauTLzrXRSh0aEVb+OFQM5KOCVAzuXOvrV8I3nXFsdvfII4/grLPOAgA8++yz2Lt3Ly677DJce+21/LjyYJ9oDtgiOmVidtdIGXmGnbrTRicWCiCRyfNB2Guzu6Dfh1mtYQzF0xgYSxkG8iLbz01HfD4Jva1hXqIgwkOCudbnCjLi6VzFc2oDeScZ+XQ2zyVv9czIpzUZeSdt8MoD2emSkQcUw7vth6awa3gK5xzbW/I7ktbPPIJ+H+Z2RrB3RFFoUEa+OtoywMlUDh0x87GZd4MQlMkUiTuzOyWQ72mijHz5uVJGvjqt5Rl5QZ8ZW2MUZEUNaKdrFdXIe4Pt1fjmzZtx2mmnAQC2b98OAJg1axZmzZqFzZs38+MabeAjrMP7yGfzuhlAAMIcuQl92KA7liia3dUgcO7vjGIonsaB8SROOqJD9xivpPXTidltmkDepdEdoEx6LSE/pjJ5jE5ldAJ5ZXIM+iVbChQurdeYzNWz/VyuIHMPBjdmd4yFvdOjRh5QjPsAfed6JgGmrOzM4siuGA/k3zw0ieWLeptSgVYrwgE/wgEf0rkCJlLZqoE8U581mqwecGd2x2rke5q5Rp4y8lVha8YhwYF8UBO4Z/My7IjnqP2cN9i+Gx577DEvzoNoINhNli/IyOZlhAKViwO1RzYNqF5QPuh6XSMPKLW4L8G4l7wsyyStt8AsTcuzNkGfU1dLCFOZJEamMjyoY2QcGtWx9nPJTJ4/Rz0mWO1rMvMmJ9I7bSDbEvJjVhO1V6rGQpNe8iwj30IGUDOGtZsHsHHvGP/5X3+3Fd97bEdTdvqoJW2RINKTaUvO9ayetxGN1VSzO3uBfDZf4MF/M5vdUUa+OmqNvJJUELXRq1X9ZXIFW8/La+TrUMI3naFCBaIC7SKaSV3LYRNIG2XkPaE8kK9NRl4xvDNyrk/nCrylGknrjdEG8qI2urpNWtAxab0dWT2gyte1i8F6ZOS19aduan61739WWxgmno1Nx5EmLejY5hpl5GcGazcP4MoHNvINHMbgeApXPrARazcP1OnMGp92G73keUa+Ae+rdoc18qPF+cMnAZ2x5gnkoyF/SfBOY111ymvkRV3HAY3qJ5039tHSI0195D2BPk2igpDfB3avpjIGgXySpPVe0lKWga/FhsncYgu6AwaBvHbx02jteBqJWW1q9wRR9werk9cN5LPOZPEsE65dDNaj/ZxPx0zK7o792s0D+NiPn+c/7xpO4JzbHp02Qc1CJq0fmaroKpHIUo38TCFfkHHzQ1uht0fFHrv5oa18Q4wopS1q3bm+kb0n1Bp5e52imKy+KxZqujKMHk1WntRH1WHlj6xGXlRXE0mS+KY5M/W1itqVpvHuqWaGAnmiAkmSNK2p9A3vVLM7GlC9oLze12uzO0CTkTeQ1qv18QH4mmwRUEtKM/JiAnnuXK/Tgo7VyNsN5NnxLJD3SWqP2FpTbrJnZ6JnGcpDxbZKjOmUoZzXFYXfJyGVLfAMC6ORAw5CLOt3jhgqpgAlmB8YT2H9zpHanVQTwTLyVkzieFvHBgwa2QZxMpu31QZspAl7yDO0LehaGtC3oNFg5Y9s00rk/MA23u22oHPTlYYwhgJ5QpdqveR5jTxl5D2hPCNfk0C+mJE3WihOaQJ5wphezSJpeDItJDumZuQrF6COa+TLMvLhQP3cmcvP3eqmxEzJUAb9PszrVO7PcsM71n6uEQMOQixDceMg3slxM402Lq23Esgr91Uj1mO3RQJgQ7Udef3h4mZnMznWM7QZ+Ub0LWg0yjc7hAbyPCNvL5BnicF6dMeZztCnSegSqRLIc9f6Bmo/N53QZiRjIX9NZHBzixn5gxMp3cCHWs9VZ+3mAXzpd2r3jv96ZrcQiXd3i3KfjQqskWd1amxTrp6TqzZwjwR9ljcUZlKGckGPfp18UtMmi5jezNaU7Yg4bqbBEg9WpPVqRr7x7iufT+IGuHYM70a4Y33zGYFqVQRbD0w0/eas17SVrdNEXsdMuWc3I8+l9TRXCYUCeUIXtshP6QTy+WI/a0CVqhFi0WYBapUBn90Wgd8nIVeQ+c69FiatL1cLEApM4j1cFmyLkHh3MbM7gdJ6Jm9jLQ7rKXfTmt/Ycc6fSRlKVie/qyIjT9L6mcIZi7rR3xGB0TaXBKC/I4IzFnXX8rSaBp6RT1swu2vwbhBODO+asYc8oMyt//fyAf7zFfe/MK08ULygfJ3mRUY+YzMjz6X1FMgLhQJ5QhdtL/lyJjW72eRa7w1amWytMuB+n4Q5xfruAzp18kxaX4tWeM2G1xLv7qK03iwjbzejziZT1omgvhl5dWK3s6EwkzKURhl5HsjTfTnt8fsk3HTREgCoCObZzzddtKTpjMxqBQtuXtk3hme2D5uOx8lM47rWA1rDOxuBfBPWyLMN8sk0dWmwQ2UgL25+CDqskU/Xsc3tdIYCeUIXJn3Rc61nUq5I0GdbzktYQ5uRr2Xg3N9pXCcfpxp5Q7yWeHebZeSzTmvkS+/derSe46+tORc7EsCZlKFcoHGu15Ik1/oZxaql/bjn0tPQ11G6OdXXEcE9l55GfeQNWLt5AD9+aicA4JkdI/jIvc+aZnUbWVoPqGUCdjLyI1PFGvkmCeRnigeKF5SvG0XK2ZnZnf0aeZLWewFFYYQu3LVep4/8OBndeY52UV7LmnS2ONTLyDMlBknrK/Fa4s1d6/Uy8nln7ecqDebqKK3XvLad9zGTMpQLWUb+cAKyrC5ceR95WhzNGFYt7cdT178DD3xiBS47No8HPrECT13/DgriDWBZ3Ymy2nizrG6iwaX1PCNvod6foUrrm6NGfiZ5oIimJtJ6uzXy1EfeE+jTJHThZneZyhtVbT1HgbxXlEjraxg4zy0G8nqTJ5fWky9CBV5LvFmN/FgyW5F9SBcnR6dmd0Y/1xKnGXlg5mQo53fHIEmKMoaZVuULMpcrUkZ+ZuH3SThzUTeW98o4c1H3tNis8gKnWV21G0Rj3ldOpPXN1n5uJnmgiKZ83SjyOnaakU9mqUbeC2hFTujCpfU6NfITSTK685pSs7vabZioLeh0MvIkrTeESbwHx1O6C0YJSmDpVOLdWVy0yTIwlsiUZFR4jbztQL5xMvIlrvUOzmPV0n6sXNKH9TtHMBRPYXab8llPp+AmEvSjrz2CgfEUdo8k0NMaLvEwoZZMBFGJnazu2Uf38Md5Rr5Be5a3R5X73ZbZHXetb45AfiZ5oIimIpAXGDyzGvm0jYy8LMvUfs4j6NMkdGHZOT2zuzhl5D1Hu3tayww4a0F3YEynRp6k9YZ4LfEO+H08AzNaViefdthHvnwyrWuNvObcnWYO/D4JZx/dg/ctm4ezj+6ZVkE8QzW8U+rkWdZQkkiuSBB6OM3q8hr5YGPOd3Yz8tl8gQf9zSKtn0keKKLx0uxO7SNv3ZtAG/RTGZhYaOYndDHNyKeYxJoCea/QDsK1zICzjPygTgZjMq0sAqiPvD5eS7y54d1U6cItIygjX0+5W2n7OZqWjOAt6A4rzvXJjGoeJEnTb+OCINziNKvb6G0d7bafY/4qPklVeDU6M8kDRTShQKkZtdg+8vZr5LWxBEnrxUIrckKXiKm0npnd0eXjFdody1oGzv3FjPxQPIVcvoCAX50IportX6j9nDFeSry7YkHshFrnyOB95O22n6swu2uMjDxN8sZw53qekW/sYIMg6o3TsiemdmlUab1qdmctkD9cNLrrioXga6LAl22Q3/zQ1pISib6OCG66aMm08UDxgrZwAMM55XsXOUeEA/Zr5Jms3u+T+EYAIQZakRO6cLM73Yw8Seu9RhvMDE2kkC/INdl17m0JI+iXkM3LOBhPY16xHR1A7eeswiTeouHO9QbS+pDf3kQd9EuQJKXuHqh3H3ltRr4xF86NAJfWjygZeTWQp3uSIPRgWd0rH9gICSgJ5s2yuo0urW8t3vO7hxN4Zvtw1Q1jtgHc09oc9fFaZoIHihe0hAPcF0FkIB/0K5+7k4w8yerFQ9sihC5MhqPrWs/N7iiQ94K1mwdwyb3P8p9//Nddpv1uReLzSVwaPlDWgm6yuIFDNfL1oSvGpPVlgbxDAxlJksravtVTWq+pkaeJ3hC1Rr5UWk8ZeYIwxknZUyLduBn5tZsH8C+/fhkAsG80iY/c+2zVNcJwsYd8szjWlzMTPFBEo026CHWtZ+3nbGTkk9R6zjPoEyV0iRRvVL0+8mpGngI60bB+t0PxdMnjZv1uRdPfrmThD5TVyXNpPZVU1AWjXvJcWu9AGq+dVBsnI0/TkhFMWj8ylcF4MoupBm+RRRCNwqql/Xjq+nfgPz6yDIBSK/7nz5+nG8TLsowEyyA22L3F1gjDZfNAtTVCs/WQJ9yjDeRFqrbc1MjXM2EwXaEVE6ELm7xSGRPXesrIC8Vpv1vRsDr5iow8SevrCje7K5PWZxy61gOlmfC6tp/Tmt3RRG9IaziA3qI0ds9wgjLyBGEDv0/CRSfPRWcsiIIMbB+a0j0unSvwkqNGKltxs0YYabLWc4R7tP5KIpVuIRc18rRRLx76RAlduNmdXkY+yVzrG2eCmw7Y6XfrJWovefVcCgWZB/Ikra8PXYYZ+WKNvKOMvNZkrn7TQYm0noJSU7jh3chUw9fxEkSjIUkSTpzbDgDYcmBc95ip4lwHNFapj5s1AsvgN6u0nrAPW6uFAz6hpQghJxn5XGMqXKYDFMgTunCzO52MPJndeYPTfreiUXvJqxn5hMb0kDZw6kO3UY28C2m99m/qmpHXnkcDLZwbEW2dPHPWpow8QVhn6dwOAMBmg0CebZBFgmIDILe4WSMMTyrleiStnzmweSHgk/DM9mFhak5HGXl2T5HiTjh1D+TvvvtuLFq0CJFIBMuXL8eTTz5peOzAwAAuueQSLF68GD6fD1dffXXFMb/5zW+wYsUKdHZ2oqWlBcuWLcNPf/pTD9/B9CTKXev1zO5IWu8FTvvdiob3kp9QFwOTKSVgCPikurYpm8l0GUjr0w77yAPl0vrGaD/XSBmwRkTtJT9F0nqCcMASnpGf0P09C+RbGkhWD7hbI5C0fmaxdvMAHn7pAABgKpO3ZIhoFZ6RtxPI59jmGM1VoqnrivwXv/gFrr76atx444148cUXce655+LCCy/Enj17dI9Pp9OYNWsWbrzxRpxyyim6x3R3d+PGG2/EM888g5dffhkf//jH8fGPfxx//OMfvXwr0w52s6XL2s8VCjJvQ0Zmd2Jh/W6N9v8lAP06/W5F09/BMvKaQD6tOtZLUuNkKGYSqtldad9gXiPvYIJslLZvWlk/1dCZo21Bx5QyjVTHSxCNztJ5SkZ+28CEbpYy0aAmkm7WCCStnzkwQ8SpMkWtKNPkIHOtz1nP8Ks18o11T00H6rpiuuOOO3D55ZfjiiuuwAknnIA777wT8+fPxz333KN7/MKFC/Hd734Xl112GTo6OnSPOf/88/H+978fJ5xwAo4++mh87nOfw8knn4ynnnrKy7cy7Yga9JGfzOS4CQxl5MXC+t0CqJiozfrdimZusXf84ck0l23HU2R0V2+YtH4ynePfC0AZ+ZkGr5Efpow8QThhUU8LYiE/UtkCdhyarPh9o95XbtYITFrf24R95Anr1MI02UlGPpmh9nNeUbdVeSaTwYYNG3DDDTeUPH7BBRfg6aefFvIasizj0UcfxWuvvYbbbrvN8Lh0Oo10Wm33NTGhyK2y2Syy2azRnzUE7PxEn2dAUm7QZCZf8tyjcaVuOhTwwY8CsjrSe8I571zci+99+BR8bc2rGJxQr8m+jjBuvPB4vHNxr+fXZGtQCerSuQL2DU/iyO4YxhPKubSG/Y5e36vrdCYR8cvw+yTkCzIOjScwp11RTrC2Lj4UbH++Ib+64AtIct2+H7+kjiP1PA+g8a/Vee3KQvzgRBqHiuUvYX/jni/hHY1+rTYyJ/S1YcOeMby0dxQLu0ul6BPF+S4adDbfeYnRGqErFsQt712iu0bI5AqYKG7Gt4V8dXlPdK3WhucsGiI+8+YQznSo7vRJyiZAOpuz/H0miqrOkF9q+GugEa5VO69dt0D+8OHDyOfzmDNnTsnjc+bMweDgoKvnHh8fx7x585BOp+H3+3H33Xdj5cqVhsffeuutuPnmmysef+SRRxCLxVydS61Yt26d0OcbTgFAAFPpDNasWcMf3z+lPB6S8iWPE2K5fgmwfULCRBZoDwJHt08hv3sD1uyuzeu3BfxI5yT87o+P45gO4KVhCYAfmUTc1fcu+jqdaUT9fkwWJPzvHx/FPCUxi4lJPwAJzz/7NAZesfd8I4d8YMKsl1/cgMxOb1sbGrEzDrDp6MUXnsPYa3U5jRIa+VqN+v1I5iVs2D4AQMLON1/DmqlX631aRJ1o5Gu1UYlllLHv4b++hOD+F0t+t+GwMt8lJkYbdp3D1ghr9krYEffhtM604RphPAMAAUiQ8fTjf0I9/fvoWvUWdu1W45Enn8PwNmfz/WtDymvsOzBo+f54Za9yvw0d2Ic1a/TLpxuNel6riUTC8rF118mW19vKsuy6BretrQ2bNm3C5OQk/vznP+Paa6/FUUcdhfPPP1/3+C9+8Yu49tpr+c8TExOYP38+LrjgArS3t7s6F6/JZrNYt24dVq5ciWBQnNR9eDKNW178C7IFCRdeeCH/TtbvGgFefgGz2luwevU5wl6PaCx+Nvg8Du8cxYITlmH1srlIbtwPvL4F8/t6sXr1ctvP59V1OtP43pt/xZuHprB0+Zk4+6geAMBXNj0KZHN45/nn4ehZLbae76nfbcGGw/sBAOe85UycsdBb/wUjXt43jjs3PwcA6D36JLz7tCPq5hbdDNfqf+55Fq/sn8ChtA+AjBXLTsLq5UfU+7SIGtMM12qjkti4H0/+dgtSkR6sXn16ye/iL+wD3tiKI+fOwerVp9bpDK0xb+N+fPG3WzAS6Mbq1WfoHrNtIA5seAbdLWH8zXvOr+0JFqFrtTb07BzB/W+8UPW4C84903FGPrvpAH62fTO6emZZXg++8sfXgX27sPiYRVi9arGj160VjXCtMmW4FeoWyPf29sLv91dk34eGhiqy9Hbx+Xw45phjAADLli3Dtm3bcOuttxoG8uFwGOFwZUuOYDDYNAOO6HNti6mL6ILk57W0iaLaoz0WaprPhrDP3K4YsHMUByezCAaDSBVNTdqi7r73ZrqnGpHu1jBwaAoT6QL/HJnhTEvE/nejNUlriYTr8t2s3TyAL/1uM//5S7/fhu8/vhM3XbQEq5b21/x8GI18rS7sbcUr+1WjrtZofb47ojFo5Gu1UTl5fhcAYOtAHIFAqYlrumhB0hJu/M/1nGNnA9iCl/eNI1OQeO9wLRNppXSpp7X+6za6Vr3l7GNmo78jgsHxlG6dvASgryOCs4+Z7XizPBpWyruyBdnyd5nJK2cTa4J7ilHPa9XO69bNdSAUCmH58uUV0oV169bhLW95i9DXkmW5pAaeqI7WBEvbS15tPVd3MQfhIXOLLegGxhVPhMlip4I2MrurKz3cuV5xIJZlWe0j78BERut0Xw8TGuaue3iytKWeKHfd6crCntKSrxgZBBKELY6d3YagX8JEKod9o8mS3yWLrvWNZnanx/zuGOZ1RpEryHhh96juMcNTxR7yLdRDfrpTC9PkYNFbx1Yf+Sy1n/OKutoHXnvttfjP//xP/PjHP8a2bdtwzTXXYM+ePfjUpz4FQJG8X3bZZSV/s2nTJi6bP3ToEDZt2oStW7fy3996661Yt24dduzYgVdffRV33HEH7r//flx66aU1fW/Njt8ncWdKrXP9RKoYyEebY0eNcEZ/p2L+M1g0TWEtB/V2+4nawXvJF1vQ5QoymPls2G9/goxonOq1zvG1oBbuutOVI7vLAvkmCDgIopEIBXxY3NcGANi8f7zkd1OZ5mrrePbRSpnVszuGdX8/XNwo7SbH+hnBqqX9uOfS09DXUWri2NcRwT2XnuZa6Rbi7efsBPLUfs4r6jpKXXzxxRgeHsYtt9yCgYEBLF26FGvWrMGCBQsAAAMDAxU95U89Va1X2rBhAx588EEsWLAAu3btAgBMTU3hqquuwr59+xCNRnH88cfjgQcewMUXX1yz9zVdiAR9yOQLfCcNUNuQUeu56Q3LyLNe8lNpaj/XCLAWdCPFDEtaM5G6zcjXuv3ceovuuut3jvCFKqGwsLfUCyFG9yVB2ObE/g5s3j+BLQcmcOFJanDTqO3njDj7qB78asM+PLPdIJDnGXkK5GcKq5b2Y+WSPqzfOYKheAqz2yI4Y1G3EO8ZluSzk5FPZqn9nFfUffa/6qqrcNVVV+n+7r777qt4TJbNszNf+9rX8LWvfU3Eqc14IkE/JlK50ow8SetnBCwjz6X1rHUNfe91hWfki2YVac29ySZXO0RKpPW1XbQOxY2DeCfHzSQWlEvrmyTgIIhGYum8dvziBWDzgbKMfHHjOhZujvvqrOJG5yv7xzGZzlVsuI8US7FIWj+z8PskTzbBnWXki4F8jZV/MwHaGiEMiRYXhymS1s84+osZ+dFEFslMntfIk7S+vnS3KPcdq5HPFHfEQ34ffA522rW747XOyM9ui1Q/yMZxM4lZreGS4D1KckWCsM2SuR0AgC0HSh2iE8U1T7N4T8zrjOLI7hjyBRnP7xqp+D1J6wmRBHlG3nrZW7oorY/SprNwKJAnDGE7Z6y2BQAmkkxaTwHddKY9EkBLccAdGE/ykgqS1teXLi6tVxZmbHIMOQzCtVn8F/eM1rQe/YxF3ejviFQY8jAkAP0dihyQKEWSJMzvivKftx4YJy8BgrDJCf1t8EnAoXgaQxOq8ifZZDXyAHDWUco4qVcnP8wz8hTIE+5h6420jYw8Seu9gz5RwpBIMZArca2njPyMQJIkbpQyMJ7CVNHFt5U2cOpKN3OtTxQD+eJE6iSbvnbzAL6+Zhv/+dIfrcc5tz1aM6f4WrjrTlfWbh7AruEE//mfH9hY0++OIKYDsVAAR81qBVCalW82aT2gMbzTqZMfoUCeEEjQQY08Seu9gwJ5wpBocecsldMJ5Mnsbtozt5MZ3iXVGnnKyNcVbUa+pPWczUCetX0bK9baM2rd9s1rd93pCPvuyrMh1LKPIOyzdG47gFLnepY9bCbvibOOUuvk46nScX14smh2R9J6QgBhJzXyvE1u89xTzQKtyglDmPmVNiMfJ9OzGUO/JiNPNfKNAcvIp3MFJLN5PpHamRyrtX2ToLR9W7mkrybZcC/ddacbjfbdEUSzc+LcDvxu0wH9jHwTSev7O6JY2BPDruEEnt81gnccPweAEmxNFNdtZHZHiIBl5DO2MvLFGnkK5IVDGXnCEHbDpfRc60laP+1hhnfaQJ5q5OtLLOTnu+EjUxlH0no7bd9qBXPXfd+yeTj76B4KQg1oxO+OIJqZE+cVM/Ia5/pmaz/HYPJ6bRs6Vobl90nooHUbIQBWI58vyJa9WVIZqpH3CvpECUPUQF4JFmRZ5ju7JK2f/swttqDbN5rg1wApMeqLJElqnfxUlkvr7ZjdUdu35oW+O4IQy4n9inP9vtEkxoulRokmlNYDqrz+2R3qRt7hoqy+KxZ01NmEIMoJ+tXryGqdPJPW17rN7UyAAnnCECbXZfViiUye7761Rymgm+6wjPwbByf5YyStrz+sTn54Ks1d6+1k5KntW/NC3x1BiKUjFsT8bmWu2zKgZOUT6eZzrQfUQH7LgXGMF9WT1EOeEI02cWBFXp/LF3irOpLWi4cCecKQaFkgz4zuAj6JbsYZAMvIDxbb8oQDPl4bRdQPrXO9Kq23fj9S27fmhb47ghAPy8pv2T+BbL7Ag5Nmy8jPaY/gqN4WFGTg+WJ5DQvku8mxnhBE0KcJ5C0Y3k1pfLZe3jdGrVIFQ6tywhBWy8Jq5HkP+WgQkkQSrelOX0e05GeS1TcGXS3MuT6rmt3ZyMhT27fmhb47ghDPiUXn+i0HxpHQBB3NlpEHgLNYnXyxn/zhyWIgT471hCB8PonL66tJ69duHsDKO/7Cf/7HnzxPrVIFQ4E8YUi52R1raUIB3cygNRwo+a5JVt8YdMcUf4rRqYzafs6mgQy1fWte6LsjCLEsnadk5DcfmOBGdwGfZMt7pFE4m9fJK4H8yJRSI99LGXlCINy53iQjz1qlDsXTJY9Tq1Sx0MqcMCQaKm0/Rz3kZx5zO6J4LRUHQI71jQLPyCcy6CwG9SEHJQ/U9q15oe+OIMTBMvI7Dk1yc7hok8nqGWcepZTVbB2YwFgio5HWU408IY5QwIdEJm+YkadWqbWDVuaEIeEy13pVWk+XzUyhvzOC1w5SIN9IqK71GaQ7lfIHOzXyWljbN6L5oO+OIMQwuz2CWW1hHIqn8eKeUQBASxPK6gHF6PKY2a14c2gS63eOkLSe8ASWkU8bZOTttEqlecwdzacbImqGkdkdZeRnDv2aOnkqqWgMmGt9SR956s1KEAThGJaVX79LCeSbzehOy1nFrPwzO4Z5Rp6k9YRImAqQudGXQ61Sawet/ghDymvkJ5IUyM805mrqcKlGvjEoda0v1sg3YS0nQRBEo7B0rlInv36nUlseCzdvIH/2Ub0AlH7yw8VSAXKtJ0TC/COMauSpVWrtoNUfYUiFa32KpPUzjf5ONSNP0vrGoFvjWs/6yDejKRNBEESjwDLyByeUwDcWbN75jtXJbxuYwIGivLmnlWrkCXGoGXn9QJ5apdYOWv0RhpRL61XXesrIzxT62tTJfyKVpf6fDYA2I8822ZzWyBMEQRCqcz2jWc3uAKC3NYzj5rQCUDOmPZSRJwRSLSOvbZVaDrVKFQsF8oQhkZCB2R3VSs8I1m4ewDW/fIn//NBLA9T/swFgTvX5gswdlklaTxAE4ZwjuqIla5uWJpbWA2obOgCQJCU7TxvxhChYH/mMSR951iq1pWxTjFqlioVWf4QhkYCB2V2UMvLTHdb/89Ak9f9sNMIBPy9zGJxIFR+joZwgCMIpkiThxLlqVj7axNJ6oHROkGXgkv98jjbiCWFUy8gzVi3tx9+cogTsq5f24WefPAtPXf8OCuIFQqs/whAmLUtlyOxuJlGt/yeg9P+k3f360dWi3IODxfpH1iqSIAiCcMYJ/W383/EmLiVbu3kA9z65s+Jx2ognRBGsUiOvhal5zzq6B2cf3UNyesFQIE8Yws3ucuVmdxTIT2fs9P8k6kN3sQUd6xHMjGcIgiAI+6zdPIDfbNzPf35k68GmzGDTRjxRC8IWM/IAMJZQkoAdFDt4Aq3+CEOY2V02LyOXL6gZeXKtn9ZQ/8/Gp6vMuIj6yBMEQTiDlZKNFdc4jGbMYNNGPFEL7GTkx5MUyHsJrf4IQyIauW4ym0e8mJEn1/rpDfX/bHxYRp5BrvUEQRD2mW4ZbNqIJ2oBq5FPW8jIs0C+M0adE7yAAnnCkHDAB6lYyjKWyHJ3SnKtn95Q/8/GpyIjT2Z3BEEQtpluGWzaiCdqgZqRr77BNZZQSgApI+8NtPojDJEkiTvXs91bnwS0hCiQn85o+3+WB/PU/7Mx6C4L5EMUyBMEQdhmumWwaSOeqAVWXeuz+QKmiobZnRTIewKt/ghTmHP90ITShqwtEoSPArhpD+v/2ddRumtP/T8bg/JAnjLyBEEQ9pluGWzaiCdqQchijfy4xneCjLK9gVKrhCmRYoBwsNivmozuZg6rlvZj5ZI+rN85gqF4CrPblF18WgDUny6qkScIgnANy2APjqd06+QlKBvYzZTBZhvxNz+0taRsoK8jgpsuWkIb8YRreEbeYiDfFgnQ2tEjKCojTIkUM/IH40pGnnrIzyz8PglnH91T79MgyqjIyJNrPUEQhG1YBvvKBzZCAkqC+WbOYNNGPOElQb9yHVWT1rPWc50xih28ggJ5whReI8+l9XTJEES96W4pnRRJWk8QBOGM6ZrBpo14witCfiU2qJ6RJ6M7r6GojDCF18gXjV4oI08Q9adcWk9mdwRBEM6hDDZBWCcYUO6LbJWMPG89F6XWc15BgTxhSrTYS/4Qk9bTrhpB1J2OaBCSBMhFHSjVyBMEQbiDMtgEYQ1mdlctI8+k9R0krfcMSuMQpkSCZWZ3lJEniLoT8PtKpGokrScIgiAIohYwFWA113oeyFMS0DNo9UeYEilm5EeLNyO51hNEY9CtkddTIE8QBEEQRC3gGXnL0noK5L2CVn+EKUxaz6CMPEE0Bl1F5/pQwAdJojpOgiAIgiC8J8il9XpNG1V4IE/Ses+gQJ4wJVIWyJNrPUE0Bl3FidEH4Jntw8gXzCdUgiAIgiAIt/A+8rm86XEskCdpvXdQIE+YwlzrGWR2RxD1Z+3mAfz1zWEAQCpXwEfufRbn3PYo1m4eqPOZEQRBEAQxnWEZ+WyVjPxYgrWfI9d6r6BAnjClPCNP0nqCqC9rNw/gygc2Ipkt3QkfHE/hygc2UjBPEARBEIRnhAPWauTHKCPvORTIE6Yw13oGmd0RRP3IF2Tc/NBW6O2Bs8dufmgryewJgiAIgvAENSNvHshPUI2851AgT5hCZncE0Tis3zmCgfGU4e9lAAPjKazfOVK7kyIIgiAIYsYQspCRl2WZt5+jQN47KJAnTKmQ1pM8hiDqxlDcOIh3chxBEARBEIQdgn6lU07aJJBPZPLIFdWBJK33DgrkCVPKM/KtYZLWE0S9mN0WEXocQRAEQRCEHVhG3kxaz+rjQ35fRSxBiIMCecIUbUa+LRyA30f9qgmiXpyxqBv9HREY3YUSgP6OCM5Y1F3L0yIIgiAIYoYQ4n3kTQJ55lgfC0KSKHbwCgrkCVO0ZnckqyeI+uL3SbjpoiUAUBHMs59vumgJbbgRBEEQBOEJPCNvIq2nHvK1gQJ5whStHKYtQrJ6gqg3q5b2455LT0NfR6l8vq8jgnsuPQ2rlvbX6cwIgiAIgpjuBC1k5MeZ0R0F8p5CkRlhSjSkBvKUkSeIxmDV0n6sXNKH9TtHMBRPYXabIqenTDxBEARBEF6i1sjLkGVZVzo/Rq3nagIF8oQp2hp5aj1HEI2D3yfh7KN76n0aBEEQBEHMIFggDyhZ+XCg0syOSespCegtJK0nTImWBPK070MQBEEQBEEQMxVmdgcoWXk9eA/5aKgm5zRToUCeMCVMZncEQRAEQRAEQUCtkQeAjIHhHZnd1QYK5AlTtLtuE8kM8gX9nTeCIAiCIAiCIKY3fp/EPXmMesmPJ5X2c1Qj7y0UyBOGrN08gFV3Psl//s2LB3DObY9i7eaBOp4VQRAEQRAEQRD1gveSN8jIc2k9BfKeQoE8ocvazQO48oGNGJxIlTw+OJ7ClQ9spGCeIAiCIAiCIGYgQb+SkTdqQUdmd7WBAnmignxBxs0PbYWeiJ49dvNDW0lmTxAEQRAEQRAzjFDRqb5qRp4CeU+hQJ6oYP3OEQyMpwx/LwMYGE9h/c6R2p0UQRAEQRAEQRB1J+SvViPPpPXkWu8lFMgTFQzFjYN4J8cRBEEQBEEQBDE9YL3k9TLy2XwBk+kcAHKt9xoK5IkKZrdFhB5HEARBEARBEMT0gLWg06uRnyhm4wGgPRKo2TnNROoeyN99991YtGgRIpEIli9fjieffNLw2IGBAVxyySVYvHgxfD4frr766opj7r33Xpx77rno6upCV1cX3vWud2H9+vUevoPpxxmLutHfEYFk8HsJQH9HBGcs6q7laREEQRAEQRAEUWfMMvJMVt8WDiDgr3uoOa2p66f7i1/8AldffTVuvPFGvPjiizj33HNx4YUXYs+ePbrHp9NpzJo1CzfeeCNOOeUU3WMef/xxfOQjH8Fjjz2GZ555BkceeSQuuOAC7N+/38u3Mq3w+yTcdNESAKgI5tnPN120hPeQJAiCIAiCIAhiZsAy8tl8pfH1WDGQ76DWc55T10D+jjvuwOWXX44rrrgCJ5xwAu68807Mnz8f99xzj+7xCxcuxHe/+11cdtll6Ojo0D3mv//7v3HVVVdh2bJlOP7443HvvfeiUCjgz3/+s5dvZdqxamk/7rn0NPR1lMrn+zoiuOfS07BqaX+dzowgCIIgCIIgiHphmpGnHvI1o26FC5lMBhs2bMANN9xQ8vgFF1yAp59+WtjrJBIJZLNZdHcby8DT6TTS6TT/eWJiAgCQzWaRzWaN/qwhYOfnxXm+c3Evzj/2XLywexRD8TRmt4WxYkEX/D6p4T8XorHw8jolCJHQtUo0C3StEs0CXavTj2Icj2SmMlYanlTMsNvDgab7zhvhWrXz2nUL5A8fPox8Po85c+aUPD5nzhwMDg4Ke50bbrgB8+bNw7ve9S7DY2699VbcfPPNFY8/8sgjiMViws7FS9atW+fp8/sBDAP44zZPX4aY5nh9nRKEKOhaJZoFulaJZoGu1enD2LAPgA8bXtyE4P4XS373zIAEwI/E+GGsWbOmLufnlnpeq4lEwvKxdbcSlKTSOmtZlisec8rtt9+On/3sZ3j88ccRiRg7rH/xi1/Etddey3+emJjA/PnzccEFF6C9vV3IuXhFNpvFunXrsHLlSgSDJGEhGhO6Tolmga5Volmga5VoFuhanX48PLYJW8eGcPySpVh9xvyS321/dDuwazuOP+pIrF69pE5n6IxGuFaZMtwKdQvke3t74ff7K7LvQ0NDFVl6J3zrW9/Cv//7v+NPf/oTTj75ZNNjw+EwwuFwxePBYLBpBpxmOldi5kLXKdEs0LVKNAt0rRLNAl2r04dISAkh87JU8Z3GM3kAQFdLuGm/73peq3Zet25md6FQCMuXL6+QLqxbtw5vectbXD33N7/5Tfzbv/0b1q5dixUrVrh6LoIgCIIgCIIgCEIh6FfU01mdPvLc7C7anEF8M1FXaf21116Lf/iHf8CKFStw9tln44c//CH27NmDT33qUwAUyfv+/ftx//3387/ZtGkTAGBychKHDh3Cpk2bEAqFsGSJIt24/fbb8eUvfxkPPvggFi5cyDP+ra2taG1tre0bJAiCIAiCIAiCmEaELfSR76BA3nPqGshffPHFGB4exi233IKBgQEsXboUa9aswYIFCwAAAwMDFT3lTz31VP7vDRs24MEHH8SCBQuwa9cuAMDdd9+NTCaDD33oQyV/d9NNN+GrX/2qp++HIAiCIAiCIAhiOqP2ka8M5FkfeWo/5z11N7u76qqrcNVVV+n+7r777qt4TJZl0+djAT1BEARBEARBEAQhllAxkE/rBfKJDACgIxqq6TnNROpWI08QBEEQBEEQBEE0F8GitD6bq0ywjidzAEhaXwsokCcIgiAIgiAIgiAswTLymXy+5HFZljGeVDLyJK33HgrkCYIgCIIgCIIgCEuEDDLyyWwe2bzyGAXy3kOBPEEQBEEQBEEQBGEJNSNfWiM/Vmw9F/RLiAb9NT+vmQYF8gRBEARBEARBEIQlWB95o0C+IxqCJEk1P6+ZBgXyBEEQBEEQBEEQhCVCASXbXt5HXu0hX/fGaDMCCuQJgiAIgiAIgiAIS/CMfEUgz4zuqPVcLaBAniAIgiAIgiAIgrAEN7szkNZ3Uuu5mkCBPEEQBEEQBEEQBGGJcDGQN5bWUyBfCyiQJwiCIAiCIAiCICwR9Btk5FkgT63nagIF8gRBEARBEARBEIQlmLQ+bZCR74xSjXwtoECeIAiCIAiCIAiCsIRRRn48Qa71tYQCeYIgCIIgCIIgCMISLCNf0UeeXOtrCgXyBEEQBEEQBEEQhCVCLCOfk0seJ7O72kKBPEEQBEEQBEEQBGEJw4x8gszuagkF8gRBEARBEARBEIQleI18udkd9ZGvKRTIEwRBEARBEARBEJbgrvWajHwuX0A8nQNA0vpaQYE8QRAEQRAEQRAEYYmgXwKguNbLslInP5HK8d9TIF8bKJAnCIIgCIIgCIIgLBH2+wEAsgzkCkogz4zu2sIBBPwUYtYC+pQJgiAIgiAIgiAISwQDEv836yU/llBaz7VTNr5mUCBPEARBEARBEARBWCKkybhnioZ3Y8WMfCc51tcMCuQJgiAIgiAIgiAIS/h9EqRiUp61oJugHvI1hwJ5giAIgiAIgiAIwhKSJPGsPM/IJygjX2sokCcIgiAIgiAIgiAswwL5bL7U7K4jGqrbOc00KJAnCIIgCIIgCIIgLMN6yZdn5ElaXzsokCcIgiAIgiAIgiAsE+QZeWZ2p7jWk7S+dlAgTxAEQRAEQRAEQViGZeTTuVKzu07KyNcMCuQJgiAIgiAIgiAIywT9im292keepPW1hgJ5giAIgiAIgiAIwjKhgB9AZR/5DpLW1wwK5AmCIAiCIAiCIAjLhMoy8uPUR77mUCBPEARBEARBEARBWEbrWi/LMsZ5H3lqP1crKJAnCIIgCIIgCIIgLMNc6zP5AlLZAjLFzDyZ3dUOCuQJgiAIgiAIgiAIy2gz8qz1XMAnIRby1/O0ZhQUyBMEQRAEQRAEQRCWUfvIy9yxvjMWhCRJ9TytGQUF8gRBEARBEARBEIRl1Ix8nozu6gQF8gRBEARBEARBEIRlQjoZeQrkawsF8gRBEARBEARBEIRlQhqzu/FijTw51tcWCuQJgiAIgiAIgiAIy2jN7khaXx8C9T4BgiAIgiAIgiAIonnQtp/LJpTWcxTI1xYK5AmCIAiCIAiCIAjLsIx8NldAMpsHoLjWE7WDpPUEQRAEQRAEQRCEZUJ+pc1cJl/AGEnr6wIF8gRBEARBEARBEIRlSmrkNX3kidpBgTxBEARBEARBEARhmWCJa30xkI+Sa30toUCeIAiCIAiCIAiCsIw2Iz9WbD/XTtL6mkKBPEEQBEEQBEEQBGEZlpHP5klaXy8okCcIgiAIgiAIgiAswzLyyWwBE6kcADK7qzUUyBMEQRAEQRAEQRCWCRUz8sOTaf4YBfK1hQJ5giAIgiAIgiAIwjIsI38orgTyreEAl9sTtYE+bYIgCIIgCIIgCMIyLGgfnlKM7igbX3sokCcIgiAIgiAIgiAswzLy+YIMgAL5ekCBPEEQBEEQBEEQBGGZoF8q+Zkc62sPBfIEQRAEQRAEQRCEZcKB0jCSMvK1hwJ5giAIgiAIgiAIwjLlxnaUka89FMgTBEEQBEEQBEEQlgmVZeTbKSNfc+oeyN99991YtGgRIpEIli9fjieffNLw2IGBAVxyySVYvHgxfD4frr766opjtmzZgg9+8INYuHAhJEnCnXfe6d3JEwRBEARBEARBzDAqMvLRUJ3OZOZS10D+F7/4Ba6++mrceOONePHFF3HuuefiwgsvxJ49e3SPT6fTmDVrFm688UaccsopusckEgkcddRR+MY3voG+vj4vT58gCIIgCIIgCGLGESJpfd2payB/xx134PLLL8cVV1yBE044AXfeeSfmz5+Pe+65R/f4hQsX4rvf/S4uu+wydHR06B5z+umn45vf/CY+/OEPIxwOe3n6BEEQBEEQBEEQM45yaT2Z3dWeQL1eOJPJYMOGDbjhhhtKHr/gggvw9NNP1/Rc0uk00uk0/3liYgIAkM1mkc1ma3oudmHn1+jnScxs6DolmgW6Volmga5Volmga3V6Isn5kp9bQ1LTf8eNcK3aee26BfKHDx9GPp/HnDlzSh6fM2cOBgcHa3out956K26++eaKxx955BHEYrGanotT1q1bV+9TIIiq0HVKNAt0rRLNAl2rRLNA1+r0IpUHtKHkKxuew+irdTsdodTzWk0kEpaPrVsgz5AkqeRnWZYrHvOaL37xi7j22mv5zxMTE5g/fz4uuOACtLe31/Rc7JLNZrFu3TqsXLkSwSBJWojGhK5Tolmga5VoFuhaJZoFulanJ5lcAdev/xP/+T0r3455ndE6npF7GuFaZcpwK9QtkO/t7YXf76/Ivg8NDVVk6b0mHA7r1tMHg8GmGXCa6VyJmQtdp0SzQNcq0SzQtUo0C3StTi8CAbnk5972GILBuueIhVDPa9XO69bN7C4UCmH58uUV0oV169bhLW95S53OiiAIgiAIgiAIgjBDkiTuXB/wSWgJ+et8RjOPum6bXHvttfiHf/gHrFixAmeffTZ++MMfYs+ePfjUpz4FQJG879+/H/fffz//m02bNgEAJicncejQIWzatAmhUAhLliwBoJjobd26lf97//792LRpE1pbW3HMMcfU9g0SBEEQBEEQBEFMQ4J+CZm84lhf69Joos6B/MUXX4zh4WHccsstGBgYwNKlS7FmzRosWLAAADAwMFDRU/7UU0/l/96wYQMefPBBLFiwALt27QIAHDhwoOSYb33rW/jWt76F8847D48//rjn74kgCIIgCIIgCGK6Ewr4MJXJo4N6yNeFuhcyXHXVVbjqqqt0f3ffffdVPCbLcuWBGhYuXFj1GIIgCIIgCIIgCMI5rJc89ZCvD3WrkScIgiAIgiAIgiCak2CxRr6TAvm6QIE8QRAEQRAEQRAEYZl8QUa+oKigs3n130TtoECeIAiCIAiCIAiCsMTazQM457ZHMTCeAgA89eZhnHPbo1i7eaDOZzazoECeIAiCIAiCIAiCqMrazQO48oGNPIhnDI6ncOUDGymYryEUyBMEQRAEQRAEQRCm5Asybn5oK/RE9Oyxmx/aSjL7GkGBPEEQBEEQBEEQBGHK+p0jFZl4LTKAgfEU1u8cqd1JzWAokCcIgiAIgiAIgiBMGYobB/FOjiPcQYE8QRAEQRAEQRAEYcrstojQ4wh3UCBPEARBEARBEARBmHLGom70d0QgGfxeAtDfEcEZi7preVozFgrkCYIgCIIgCIIgCFP8Pgk3XbQEACqCefbzTRctgd9nFOoTIqFAniAIgiAIgiAIgqjKqqX9uOfS09DXUSqf7+uI4J5LT8Oqpf11OrOZR6DeJ0AQBEEQBEEQBEE0B6uW9mPlkj6s3zmCoXgKs9sUOT1l4msLBfIEQRAEQRAEQRCEZfw+CWcf3VPv05jRkLSeIAiCIAiCIAiCIJoICuQJgiAIgiAIgiAIoomgQJ4gCIIgCIIgCIIgmggK5AmCIAiCIAiCIAiiiaBAniAIgiAIgiAIgiCaCArkCYIgCIIgCIIgCKKJoECeIAiCIAiCIAiCIJoICuQJgiAIgiAIgiAIoomgQJ4gCIIgCIIgCIIgmggK5AmCIAiCIAiCIAiiiaBAniAIgiAIgiAIgiCaCArkCYIgCIIgCIIgCKKJoECeIAiCIAiCIAiCIJqIQL1PoBGRZRkAMDExUeczqU42m0UikcDExASCwWC9T4cgdKHrlGgW6FolmgW6Volmga5VollohGuVxZ8sHjWDAnkd4vE4AGD+/Pl1PhOCIAiCIAiCIAhiJhGPx9HR0WF6jCRbCfdnGIVCAQcOHEBbWxskSar36ZgyMTGB+fPnY+/evWhvb6/36RCELnSdEs0CXatEs0DXKtEs0LVKNAuNcK3Ksox4PI65c+fC5zOvgqeMvA4+nw9HHHFEvU/DFu3t7TQ4Eg0PXadEs0DXKtEs0LVKNAt0rRLNQr2v1WqZeAaZ3REEQRAEQRAEQRBEE0GBPEEQBEEQBEEQBEE0ERTINznhcBg33XQTwuFwvU+FIAyh65RoFuhaJZoFulaJZoGuVaJZaLZrlczuCIIgCIIgCIIgCKKJoIw8QRAEQRAEQRAEQTQRFMgTBEEQBEEQBEEQRBNBgTxBEARBEARBEARBNBEUyBMEQRAEQRAEQRBEE0GBfBNz9913Y9GiRYhEIli+fDmefPLJep8SMYO59dZbcfrpp6OtrQ2zZ8/G3/7t3+K1114rOUaWZXz1q1/F3LlzEY1Gcf7552PLli11OmOCULj11lshSRKuvvpq/hhdq0SjsH//flx66aXo6elBLBbDsmXLsGHDBv57ulaJRiCXy+FLX/oSFi1ahGg0iqOOOgq33HILCoUCP4auVaIePPHEE7joooswd+5cSJKE3/3udyW/t3JdptNpfOYzn0Fvby9aWlrw3ve+F/v27avhu9CHAvkm5Re/+AWuvvpq3HjjjXjxxRdx7rnn4sILL8SePXvqfWrEDOUvf/kLPv3pT+PZZ5/FunXrkMvlcMEFF2Bqaoofc/vtt+OOO+7AXXfdheeffx59fX1YuXIl4vF4Hc+cmMk8//zz+OEPf4iTTz655HG6VolGYHR0FG9961sRDAbxhz/8AVu3bsW3v/1tdHZ28mPoWiUagdtuuw0/+MEPcNddd2Hbtm24/fbb8c1vfhPf+973+DF0rRL1YGpqCqeccgruuusu3d9buS6vvvpq/Pa3v8XPf/5zPPXUU5icnMTf/M3fIJ/P1+pt6CMTTckZZ5whf+pTnyp57Pjjj5dvuOGGOp0RQZQyNDQkA5D/8pe/yLIsy4VCQe7r65O/8Y1v8GNSqZTc0dEh/+AHP6jXaRIzmHg8Lh977LHyunXr5PPOO0/+3Oc+J8syXatE43D99dfL55xzjuHv6VolGoX3vOc98ic+8YmSxz7wgQ/Il156qSzLdK0SjQEA+be//S3/2cp1OTY2JgeD/397dxvbVNnHcfzXtbSdc0w6YS3IYES0Y0OBVcyAgApZcJNkMVHQCSzMEsLG03yACBHeUH2xGELQxRldIkrwMYJmKgTKkmWRueqwGnCZPE1wqSY6s0gc0HO/ue1tU7jdFNce9v0k58W5zrVe/y2/NPufnp4zwti7d29szrlz54y0tDTjk08+GbLar4RP5E2ov79foVBIJSUlceMlJSVqbW1NUlVAvN7eXkmSy+WSJJ06dUo9PT1xuXU4HJo3bx65RVJUV1errKxMCxYsiBsnq0gV+/fvl8/n00MPPaQxY8Zo+vTpeuWVV2LHySpSxZw5c3To0CF1dnZKko4dO6aWlhaVlpZKIqtITQPJZSgU0sWLF+PmjB07VoWFhUnPri2pq+Nv+emnn3T58mXl5OTEjefk5KinpydJVQH/YxiGamtrNWfOHBUWFkpSLJtXyu2ZM2eGvEYMb3v37tUXX3yhzz//POEYWUWqOHnypOrr61VbW6tnnnlGbW1tWrt2rRwOh5YtW0ZWkTI2btyo3t5eeb1eWa1WXb58Wdu3b9cjjzwiifdVpKaB5LKnp0d2u12jRo1KmJPsvotG3sQsFkvcvmEYCWNAMtTU1Oirr75SS0tLwjFyi2Tr7u7WunXrdODAATmdzqvOI6tItmg0Kp/Pp0AgIEmaPn26vvnmG9XX12vZsmWxeWQVyfbWW2/pjTfe0J49e1RQUKCOjg6tX79eY8eO1fLly2PzyCpS0d/JZSpkl0vrTejmm2+W1WpNOAsUiUQSzigBQ23NmjXav3+/gsGgbrnllti42+2WJHKLpAuFQopEIioqKpLNZpPNZlNzc7N27twpm80WyyNZRbJ5PB5NmTIlbiw/Pz92Y1veV5EqnnrqKW3atElLlizR1KlTtXTpUm3YsEHPPfecJLKK1DSQXLrdbvX39+vnn3++6pxkoZE3IbvdrqKiIh08eDBu/ODBg5o1a1aSqsJwZxiGampq9P777+vw4cPKy8uLO56Xlye32x2X2/7+fjU3N5NbDKn58+crHA6ro6Mjtvl8PlVUVKijo0OTJk0iq0gJs2fPTniMZ2dnpyZMmCCJ91Wkjt9++01pafFthdVqjT1+jqwiFQ0kl0VFRRoxYkTcnB9++EFff/110rPLpfUmVVtbq6VLl8rn86m4uFgNDQ06e/asVq1alezSMExVV1drz5492rdvnzIzM2NnN7OyspSenh57TncgENDkyZM1efJkBQIB3XDDDXr00UeTXD2Gk8zMzNi9G/6QkZGh7Ozs2DhZRSrYsGGDZs2apUAgoIcfflhtbW1qaGhQQ0ODJPG+ipSxaNEibd++Xbm5uSooKNCXX36pF154QStWrJBEVpE8fX196urqiu2fOnVKHR0dcrlcys3N/ctcZmVlqaqqSk888YSys7Plcrn05JNPaurUqQk3yx1ySbtfPv6xF1980ZgwYYJht9uNGTNmxB7zBSSDpCtujY2NsTnRaNTYunWr4Xa7DYfDYcydO9cIh8PJKxr4rz8/fs4wyCpSx4cffmgUFhYaDofD8Hq9RkNDQ9xxsopU8Ouvvxrr1q0zcnNzDafTaUyaNMnYvHmz8fvvv8fmkFUkQzAYvOL/p8uXLzcMY2C5vHDhglFTU2O4XC4jPT3deOCBB4yzZ88m4beJZzEMw0jSOQQAAAAAADBIfEceAAAAAAAToZEHAAAAAMBEaOQBAAAAADARGnkAAAAAAEyERh4AAAAAABOhkQcAAAAAwERo5AEAAAAAMBEaeQAAAAAATIRGHgAASJLuuecerV+//v/OmThxonbs2PGv1zJU6wAAYEY08gAAXCcqKytlsVgStq6uriGrYdu2bZo2bdqQrQcAwHBkS3YBAADg2lm4cKEaGxvjxkaPHp2kagAAwL+BT+QBALiOOBwOud3uuM1qtUqSmpubNXPmTDkcDnk8Hm3atEmXLl266mtFIhEtWrRI6enpysvL05tvvjnoeiorK1VeXq66ujp5PB5lZ2erurpaFy9eHNQ6vb29WrlypcaMGaORI0fqvvvu07FjxyRJP/74o9xutwKBQGz+0aNHZbfbdeDAgUHXDABAquMTeQAAhoFz586ptLRUlZWVev3113XixAn5/X45nU5t27btij9TWVmp7u5uHT58WHa7XWvXrlUkEhn02sFgUB6PR8FgUF1dXVq8eLGmTZsmv98/oHUMw1BZWZlcLpeampqUlZWll19+WfPnz1dnZ6dGjx6t1157TeXl5SopKZHX69Vjjz2m1atXq6Sk5G/9vQAASGU08gAAXEc++ugj3XjjjbH9+++/X++8845eeukljR8/Xrt27ZLFYpHX69X58+e1ceNGPfvss0pLi79Ir7OzUx9//LE+++wz3X333ZKkV199Vfn5+YOuadSoUdq1a5esVqu8Xq/Kysp06NAh+f3+Aa0TDAYVDocViUTkcDgkSXV1dfrggw/07rvvauXKlSotLZXf71dFRYXuuusuOZ1OPf/884OuFQAAM6CRBwDgOnLvvfeqvr4+tp+RkSFJOn78uIqLi2WxWGLHZs+erb6+Pn3//ffKzc2Ne53jx4/LZrPJ5/PFxrxer2666aZB11RQUBC7vF+SPB6PwuHwgNcJhULq6+tTdnZ23OteuHBB3333XWy/rq5OhYWFevvtt9Xe3i6n0znoWgEAMAMaeQAAriMZGRm69dZbE8YNw4hr4v8Yk5Qw/lfHBmvEiBFx+xaLRdFodMDrRKNReTweHTlyJOHYnxv+kydP6vz584pGozpz5ozuuOOOf1w7AACpiEYeAIBhYMqUKXrvvffiGvrW1lZlZmZq3LhxCfPz8/N16dIltbe3a+bMmZKkb7/9Vr/88ss1rWsg68yYMUM9PT2y2WyaOHHiFV+nv79fFRUVWrx4sbxer6qqqhQOh5WTk3NN6wUAIBVw13oAAIaB1atXq7u7W2vWrNGJEye0b98+bd26VbW1tQnfj5ek22+/XQsXLpTf79fRo0cVCoX0+OOPKz09/ZrWNZB1FixYoOLiYpWXl+vTTz/V6dOn1draqi1btqi9vV2StHnzZvX29mrnzp16+umnlZ+fr6qqqmtaKwAAqYJGHgCAYWDcuHFqampSW1ub7rzzTq1atUpVVVXasmXLVX+msbFR48eP17x58/Tggw/GHv92rf3VOhaLRU1NTZo7d65WrFih2267TUuWLNHp06eVk5OjI0eOaMeOHdq9e7dGjhyptLQ07d69Wy0tLXH3CwAA4HphMf74choAAAAAAEh5fCIPAAAAAICJ0MgDAAAAAGAiNPIAAAAAAJgIjTwAAAAAACZCIw8AAAAAgInQyAMAAAAAYCI08gAAAAAAmAiNPAAAAAAAJkIjDwAAAACAidDIAwAAAABgIjTyAAAAAACYyH8AkC0XjZQHNhwAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# For pAUC (partial area under the ROC curve)\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(all_scores, label='Scores per Repeat', marker='o')\n",
    "plt.axhline(y=mean_score, color='r', linestyle='--', label=f'Mean Score: {mean_score:.4f}')\n",
    "plt.title('pAUC scores Across Repeats')\n",
    "plt.xlabel('Fold Index')\n",
    "plt.ylabel('pAUC Score')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('pAUC.png')\n",
    "plt.show()\n",
    "\n",
    "# For recall\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(all_recalls, label='Recall per Repeat', marker='o')\n",
    "plt.axhline(y=mean_recall, color='r', linestyle='--', label=f'Mean Recall: {mean_recall:.4f}')\n",
    "plt.title('Recall Across Repeats')\n",
    "plt.xlabel('Fold Index')\n",
    "plt.ylabel('Recall')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('recall.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>VotingClassifier(estimators=[(&#x27;logreg1&#x27;,\n",
       "                              Pipeline(steps=[(&#x27;sampler&#x27;,\n",
       "                                               RandomUnderSampler(random_state=12,\n",
       "                                                                  sampling_strategy=0.01)),\n",
       "                                              (&#x27;scaler&#x27;, StandardScaler()),\n",
       "                                              (&#x27;classifier&#x27;,\n",
       "                                               LogisticRegression(C=0.001,\n",
       "                                                                  class_weight=&#x27;balanced&#x27;,\n",
       "                                                                  max_iter=1000,\n",
       "                                                                  random_state=12,\n",
       "                                                                  solver=&#x27;saga&#x27;))])),\n",
       "                             (&#x27;logreg2&#x27;,\n",
       "                              Pipeline(steps=[(&#x27;sampler&#x27;,\n",
       "                                               RandomUnderSampler(random_state=22,\n",
       "                                                                  sampling...\n",
       "                                               LogisticRegression(C=0.001,\n",
       "                                                                  class_weight=&#x27;balanced&#x27;,\n",
       "                                                                  max_iter=1000,\n",
       "                                                                  random_state=32,\n",
       "                                                                  solver=&#x27;saga&#x27;))])),\n",
       "                             (&#x27;logreg4&#x27;,\n",
       "                              Pipeline(steps=[(&#x27;sampler&#x27;,\n",
       "                                               RandomUnderSampler(random_state=42,\n",
       "                                                                  sampling_strategy=0.01)),\n",
       "                                              (&#x27;scaler&#x27;, StandardScaler()),\n",
       "                                              (&#x27;classifier&#x27;,\n",
       "                                               LogisticRegression(C=0.001,\n",
       "                                                                  class_weight=&#x27;balanced&#x27;,\n",
       "                                                                  max_iter=1000,\n",
       "                                                                  random_state=42,\n",
       "                                                                  solver=&#x27;saga&#x27;))]))],\n",
       "                 voting=&#x27;soft&#x27;)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">VotingClassifier</label><div class=\"sk-toggleable__content\"><pre>VotingClassifier(estimators=[(&#x27;logreg1&#x27;,\n",
       "                              Pipeline(steps=[(&#x27;sampler&#x27;,\n",
       "                                               RandomUnderSampler(random_state=12,\n",
       "                                                                  sampling_strategy=0.01)),\n",
       "                                              (&#x27;scaler&#x27;, StandardScaler()),\n",
       "                                              (&#x27;classifier&#x27;,\n",
       "                                               LogisticRegression(C=0.001,\n",
       "                                                                  class_weight=&#x27;balanced&#x27;,\n",
       "                                                                  max_iter=1000,\n",
       "                                                                  random_state=12,\n",
       "                                                                  solver=&#x27;saga&#x27;))])),\n",
       "                             (&#x27;logreg2&#x27;,\n",
       "                              Pipeline(steps=[(&#x27;sampler&#x27;,\n",
       "                                               RandomUnderSampler(random_state=22,\n",
       "                                                                  sampling...\n",
       "                                               LogisticRegression(C=0.001,\n",
       "                                                                  class_weight=&#x27;balanced&#x27;,\n",
       "                                                                  max_iter=1000,\n",
       "                                                                  random_state=32,\n",
       "                                                                  solver=&#x27;saga&#x27;))])),\n",
       "                             (&#x27;logreg4&#x27;,\n",
       "                              Pipeline(steps=[(&#x27;sampler&#x27;,\n",
       "                                               RandomUnderSampler(random_state=42,\n",
       "                                                                  sampling_strategy=0.01)),\n",
       "                                              (&#x27;scaler&#x27;, StandardScaler()),\n",
       "                                              (&#x27;classifier&#x27;,\n",
       "                                               LogisticRegression(C=0.001,\n",
       "                                                                  class_weight=&#x27;balanced&#x27;,\n",
       "                                                                  max_iter=1000,\n",
       "                                                                  random_state=42,\n",
       "                                                                  solver=&#x27;saga&#x27;))]))],\n",
       "                 voting=&#x27;soft&#x27;)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><label>logreg1</label></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RandomUnderSampler</label><div class=\"sk-toggleable__content\"><pre>RandomUnderSampler(random_state=12, sampling_strategy=0.01)</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">StandardScaler</label><div class=\"sk-toggleable__content\"><pre>StandardScaler()</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(C=0.001, class_weight=&#x27;balanced&#x27;, max_iter=1000,\n",
       "                   random_state=12, solver=&#x27;saga&#x27;)</pre></div></div></div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><label>logreg2</label></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-5\" type=\"checkbox\" ><label for=\"sk-estimator-id-5\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RandomUnderSampler</label><div class=\"sk-toggleable__content\"><pre>RandomUnderSampler(random_state=22, sampling_strategy=0.01)</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-6\" type=\"checkbox\" ><label for=\"sk-estimator-id-6\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">StandardScaler</label><div class=\"sk-toggleable__content\"><pre>StandardScaler()</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-7\" type=\"checkbox\" ><label for=\"sk-estimator-id-7\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(C=0.001, class_weight=&#x27;balanced&#x27;, max_iter=1000,\n",
       "                   random_state=22, solver=&#x27;saga&#x27;)</pre></div></div></div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><label>logreg3</label></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-8\" type=\"checkbox\" ><label for=\"sk-estimator-id-8\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RandomUnderSampler</label><div class=\"sk-toggleable__content\"><pre>RandomUnderSampler(random_state=32, sampling_strategy=0.01)</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-9\" type=\"checkbox\" ><label for=\"sk-estimator-id-9\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">StandardScaler</label><div class=\"sk-toggleable__content\"><pre>StandardScaler()</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-10\" type=\"checkbox\" ><label for=\"sk-estimator-id-10\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(C=0.001, class_weight=&#x27;balanced&#x27;, max_iter=1000,\n",
       "                   random_state=32, solver=&#x27;saga&#x27;)</pre></div></div></div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><label>logreg4</label></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-11\" type=\"checkbox\" ><label for=\"sk-estimator-id-11\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RandomUnderSampler</label><div class=\"sk-toggleable__content\"><pre>RandomUnderSampler(random_state=42, sampling_strategy=0.01)</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-12\" type=\"checkbox\" ><label for=\"sk-estimator-id-12\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">StandardScaler</label><div class=\"sk-toggleable__content\"><pre>StandardScaler()</pre></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-13\" type=\"checkbox\" ><label for=\"sk-estimator-id-13\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LogisticRegression</label><div class=\"sk-toggleable__content\"><pre>LogisticRegression(C=0.001, class_weight=&#x27;balanced&#x27;, max_iter=1000,\n",
       "                   random_state=42, solver=&#x27;saga&#x27;)</pre></div></div></div></div></div></div></div></div></div></div></div></div>"
      ],
      "text/plain": [
       "VotingClassifier(estimators=[('logreg1',\n",
       "                              Pipeline(steps=[('sampler',\n",
       "                                               RandomUnderSampler(random_state=12,\n",
       "                                                                  sampling_strategy=0.01)),\n",
       "                                              ('scaler', StandardScaler()),\n",
       "                                              ('classifier',\n",
       "                                               LogisticRegression(C=0.001,\n",
       "                                                                  class_weight='balanced',\n",
       "                                                                  max_iter=1000,\n",
       "                                                                  random_state=12,\n",
       "                                                                  solver='saga'))])),\n",
       "                             ('logreg2',\n",
       "                              Pipeline(steps=[('sampler',\n",
       "                                               RandomUnderSampler(random_state=22,\n",
       "                                                                  sampling...\n",
       "                                               LogisticRegression(C=0.001,\n",
       "                                                                  class_weight='balanced',\n",
       "                                                                  max_iter=1000,\n",
       "                                                                  random_state=32,\n",
       "                                                                  solver='saga'))])),\n",
       "                             ('logreg4',\n",
       "                              Pipeline(steps=[('sampler',\n",
       "                                               RandomUnderSampler(random_state=42,\n",
       "                                                                  sampling_strategy=0.01)),\n",
       "                                              ('scaler', StandardScaler()),\n",
       "                                              ('classifier',\n",
       "                                               LogisticRegression(C=0.001,\n",
       "                                                                  class_weight='balanced',\n",
       "                                                                  max_iter=1000,\n",
       "                                                                  random_state=42,\n",
       "                                                                  solver='saga'))]))],\n",
       "                 voting='soft')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# X, y = df_train[feature_cols], df_train[target_col]\n",
    "\n",
    "# estimator.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>isic_id</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ISIC_0015657</th>\n",
       "      <td>0.152777</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ISIC_0015729</th>\n",
       "      <td>0.105351</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ISIC_0015740</th>\n",
       "      <td>0.177142</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                target\n",
       "isic_id               \n",
       "ISIC_0015657  0.152777\n",
       "ISIC_0015729  0.105351\n",
       "ISIC_0015740  0.177142"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# df_subm['target'] = estimator.predict_proba(df_test[feature_cols])[:, 1]\n",
    "\n",
    "# df_subm.to_csv('submission.csv')\n",
    "# df_subm.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SML",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}