{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "426bab64",
   "metadata": {},
   "source": [
    "# 08 — Ensemble Methods: Stacking & Weighted Average (v3)\n",
    "\n",
    "## v3 Improvements over v2\n",
    "- **Cross-battery split** — test batteries never seen during training (no data leakage)\n",
    "- **18 features** — 6 new physics-informed features (capacity_retention, cumulative_energy, dRe/dRct gradients, soh_rolling_mean, voltage_slope)\n",
    "- **Consistent versioned artifacts** — all loaded/saved under `artifacts/v3/`\n",
    "\n",
    "## Methods\n",
    "1. **Stacking Ensemble** — Out-of-fold predictions from base models → Ridge meta-learner\n",
    "2. **Weighted Average Ensemble** — L-BFGS-B optimized weights across all trained models\n",
    "\n",
    "## Base Models\n",
    "- Classical: Ridge, RandomForest, XGBoost, LightGBM\n",
    "- Deep: LSTM, BatteryGPT, iTransformer, VAE-LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7e1493bc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-02-24T17:57:34.539328Z",
     "iopub.status.busy": "2026-02-24T17:57:34.538328Z",
     "iopub.status.idle": "2026-02-24T17:57:36.944804Z",
     "shell.execute_reply": "2026-02-24T17:57:36.944804Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v3 artifacts root: E:\\VIT\\aiBatteryLifecycle\\artifacts\\v3\n"
     ]
    }
   ],
   "source": [
    "import sys, os\n",
    "sys.path.insert(0, os.path.abspath(\"..\"))\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import joblib\n",
    "import torch\n",
    "\n",
    "from src.models.ensemble.stacking import StackingEnsemble, WeightedAverageEnsemble\n",
    "from src.evaluation.metrics import regression_metrics, tolerance_accuracy, build_summary_table\n",
    "from src.utils.plotting import save_fig, plot_actual_vs_predicted, plot_model_comparison_bars\n",
    "from src.utils.config import ARTIFACTS_DIR, FIGURES_DIR, MODELS_DIR, get_version_paths, ensure_version_dirs\n",
    "from src.utils.config import FEATURE_COLS_V3\n",
    "\n",
    "plt.style.use(\"seaborn-v0_8-whitegrid\")\n",
    "\n",
    "# v3 paths\n",
    "v3 = get_version_paths(\"v3\")\n",
    "ensure_version_dirs(\"v3\")\n",
    "V3_FEATURES = ARTIFACTS_DIR.parent / \"artifacts\" / \"v3\" / \"features\"\n",
    "print(f\"v3 artifacts root: {v3['root']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2909db4a",
   "metadata": {},
   "source": [
    "## 1. Load Pre-trained Predictions\n",
    "We load saved predictions from all previously trained models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "982b5dce",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-02-24T17:57:36.948224Z",
     "iopub.status.busy": "2026-02-24T17:57:36.948224Z",
     "iopub.status.idle": "2026-02-24T17:57:36.974224Z",
     "shell.execute_reply": "2026-02-24T17:57:36.974224Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-battery split: train batteries = [np.str_('B0005'), np.str_('B0006'), np.str_('B0007'), np.str_('B0018'), np.str_('B0029'), np.str_('B0030'), np.str_('B0033'), np.str_('B0034'), np.str_('B0038'), np.str_('B0039'), np.str_('B0040'), np.str_('B0042'), np.str_('B0043'), np.str_('B0044'), np.str_('B0045'), np.str_('B0048'), np.str_('B0053'), np.str_('B0054'), np.str_('B0055'), np.str_('B0056')]\n",
      "                     test  batteries = [np.str_('B0031'), np.str_('B0032'), np.str_('B0036'), np.str_('B0041'), np.str_('B0046'), np.str_('B0047')]\n",
      "Sequence train: (1444, 32, 18) | test: (290, 32, 18)\n",
      "n_features=18, seq_len=32\n"
     ]
    }
   ],
   "source": [
    "# Load v3 sequences (built with 18 features + proper imputation in NB02)\n",
    "data = np.load(str(V3_FEATURES / \"battery_sequences.npz\"), allow_pickle=True)\n",
    "X_multi = data[\"X_multi\"]\n",
    "y_multi = data[\"y_multi\"]\n",
    "bids = data[\"bids_multi\"]\n",
    "feature_cols = list(data[\"feature_cols\"]) if \"feature_cols\" in data else FEATURE_COLS_V3\n",
    "\n",
    "# -- v3: Cross-battery split (consistent with NB04-07) --\n",
    "unique_bids = np.unique(bids)\n",
    "rng = np.random.RandomState(42)\n",
    "shuffled = unique_bids.copy(); rng.shuffle(shuffled)\n",
    "n_train = max(1, int(len(shuffled) * 0.8))\n",
    "train_bats = set(shuffled[:n_train])\n",
    "test_bats  = set(shuffled[n_train:])\n",
    "\n",
    "train_mask = np.isin(bids, list(train_bats))\n",
    "test_mask  = np.isin(bids, list(test_bats))\n",
    "\n",
    "X_train, y_train = X_multi[train_mask], y_multi[train_mask]\n",
    "X_test, y_test   = X_multi[test_mask],  y_multi[test_mask]\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "n_samples, seq_len, n_feat = X_train.shape\n",
    "scaler = StandardScaler().fit(X_train.reshape(-1, n_feat))\n",
    "X_train_scaled = scaler.transform(X_train.reshape(-1, n_feat)).reshape(n_samples, seq_len, n_feat)\n",
    "X_test_scaled  = scaler.transform(X_test.reshape(-1, n_feat)).reshape(X_test.shape[0], seq_len, n_feat)\n",
    "\n",
    "print(f\"Cross-battery split: train batteries = {sorted(train_bats)}\")\n",
    "print(f\"                     test  batteries = {sorted(test_bats)}\")\n",
    "print(f\"Sequence train: {X_train.shape} | test: {X_test.shape}\")\n",
    "print(f\"n_features={n_feat}, seq_len={seq_len}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23388c28",
   "metadata": {},
   "source": [
    "## 2. Collect Base Model Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "02c145fd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-02-24T17:57:36.976314Z",
     "iopub.status.busy": "2026-02-24T17:57:36.976314Z",
     "iopub.status.idle": "2026-02-24T17:57:37.820406Z",
     "shell.execute_reply": "2026-02-24T17:57:37.819398Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device: cuda\n",
      "  vanilla_lstm               MAE=8.252  R²=0.7097  (290 samples)\n",
      "  attention_lstm             MAE=12.433  R²=0.2898  (290 samples)\n",
      "  bidirectional_lstm         MAE=8.917  R²=0.6778  (290 samples)\n",
      "  batterygpt                 MAE=9.177  R²=0.6333  (290 samples)\n",
      "  tft                        MAE=3.883  R²=0.8751  (290 samples)\n",
      "  vae_lstm                   MAE=4.362  R²=0.8756  (290 samples)\n",
      "\n",
      "Loaded 6 base models: ['vanilla_lstm', 'attention_lstm', 'bidirectional_lstm', 'batterygpt', 'tft', 'vae_lstm']\n"
     ]
    }
   ],
   "source": [
    "from src.models.deep.lstm import VanillaLSTM, AttentionLSTM, BidirectionalLSTM\n",
    "from src.models.deep.transformer import BatteryGPT, TemporalFusionTransformer\n",
    "from src.models.deep.vae_lstm import VAE_LSTM\n",
    "from src.utils.config import (\n",
    "    LSTM_HIDDEN, LSTM_LAYERS, DROPOUT,\n",
    "    TRANSFORMER_D_MODEL, TRANSFORMER_NHEAD, TRANSFORMER_LAYERS, WINDOW_SIZE,\n",
    "    LATENT_DIM,\n",
    ")\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Device: {device}\")\n",
    "\n",
    "# Helper: load PyTorch model and predict\n",
    "def predict_pytorch(model_cls, checkpoint, X, post_fn=None, **kwargs):\n",
    "    \"\"\"Load a saved model and run inference.\"\"\"\n",
    "    model = model_cls(**kwargs)\n",
    "    model.load_state_dict(torch.load(checkpoint, map_location=device, weights_only=True))\n",
    "    model.to(device).eval()\n",
    "    with torch.no_grad():\n",
    "        out = model(torch.FloatTensor(X).to(device))\n",
    "        if isinstance(out, dict):\n",
    "            out = out[\"health_pred\"]\n",
    "        preds = out.cpu().numpy().flatten()\n",
    "    if post_fn:\n",
    "        preds = post_fn(preds)\n",
    "    return preds\n",
    "\n",
    "# ── Deep models registry (v3: input_dim = 18 features) ──\n",
    "deep_registry = {\n",
    "    \"vanilla_lstm\": (VanillaLSTM, dict(input_dim=n_feat, hidden_dim=LSTM_HIDDEN, n_layers=LSTM_LAYERS, dropout=DROPOUT)),\n",
    "    \"attention_lstm\": (AttentionLSTM, dict(input_dim=n_feat, hidden_dim=LSTM_HIDDEN, n_layers=3, dropout=DROPOUT)),\n",
    "    \"bidirectional_lstm\": (BidirectionalLSTM, dict(input_dim=n_feat, hidden_dim=LSTM_HIDDEN, n_layers=LSTM_LAYERS, dropout=DROPOUT)),\n",
    "    \"batterygpt\": (BatteryGPT, dict(input_dim=n_feat, d_model=TRANSFORMER_D_MODEL, n_heads=TRANSFORMER_NHEAD, n_layers=TRANSFORMER_LAYERS, dropout=DROPOUT, max_len=64)),\n",
    "    \"tft\": (TemporalFusionTransformer, dict(n_features=n_feat, d_model=TRANSFORMER_D_MODEL, n_heads=TRANSFORMER_NHEAD, n_layers=TRANSFORMER_LAYERS, dropout=DROPOUT)),\n",
    "    \"vae_lstm\": (VAE_LSTM, dict(input_dim=n_feat, seq_len=seq_len, hidden_dim=LSTM_HIDDEN, latent_dim=LATENT_DIM, n_layers=LSTM_LAYERS, dropout=DROPOUT)),\n",
    "}\n",
    "\n",
    "predictions_train = {}\n",
    "predictions_test = {}\n",
    "model_names = []\n",
    "\n",
    "for name, (cls, kwargs) in deep_registry.items():\n",
    "    path = v3[\"models_deep\"] / f\"{name}.pt\"\n",
    "    if path.exists():\n",
    "        try:\n",
    "            p_train = predict_pytorch(cls, path, X_train_scaled, **kwargs)\n",
    "            p_test  = predict_pytorch(cls, path, X_test_scaled, **kwargs)\n",
    "            predictions_train[name] = p_train\n",
    "            predictions_test[name]  = p_test\n",
    "            model_names.append(name)\n",
    "            m = regression_metrics(y_test, p_test)\n",
    "            print(f\"  {name:25s}  MAE={m['MAE']:.3f}  R²={m['R2']:.4f}  ({len(p_test)} samples)\")\n",
    "        except Exception as e:\n",
    "            print(f\"  {name:25s}  FAILED: {e}\")\n",
    "    else:\n",
    "        print(f\"  {name:25s}  checkpoint not found at {path}\")\n",
    "\n",
    "print(f\"\\nLoaded {len(model_names)} base models: {model_names}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a84edd0",
   "metadata": {},
   "source": [
    "## 3. Stacking Ensemble\n",
    "Out-of-fold predictions are used to train a Ridge meta-learner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c5522fad",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-02-24T17:57:37.822421Z",
     "iopub.status.busy": "2026-02-24T17:57:37.821415Z",
     "iopub.status.idle": "2026-02-24T17:57:37.849088Z",
     "shell.execute_reply": "2026-02-24T17:57:37.847991Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stacking Ensemble (Ridge meta-learner):\n",
      "  MAE  = 8.2744\n",
      "  RMSE = 10.1395\n",
      "  R²   = 0.7212\n",
      "  Tol.Acc (±2%) = 16.55%\n",
      "  Meta-learner weights: {'vanilla_lstm': np.float32(0.4117), 'attention_lstm': np.float32(0.046), 'bidirectional_lstm': np.float32(0.5898), 'batterygpt': np.float32(-0.0927), 'tft': np.float32(0.1394), 'vae_lstm': np.float32(-0.0991)}\n",
      "  Meta-learner intercept: 0.2024\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.model_selection import KFold\n",
    "\n",
    "if len(model_names) >= 2:\n",
    "    # Build prediction matrices\n",
    "    P_train = np.column_stack([predictions_train[n] for n in model_names])\n",
    "    P_test  = np.column_stack([predictions_test[n] for n in model_names])\n",
    "    \n",
    "    # Out-of-fold stacking with Ridge meta-learner\n",
    "    kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
    "    oof_preds = np.zeros(len(y_train))\n",
    "    \n",
    "    for fold, (tr_idx, val_idx) in enumerate(kf.split(P_train)):\n",
    "        meta = Ridge(alpha=1.0)\n",
    "        meta.fit(P_train[tr_idx], y_train[tr_idx])\n",
    "        oof_preds[val_idx] = meta.predict(P_train[val_idx])\n",
    "    \n",
    "    # Fit final meta-learner on all training data\n",
    "    meta_final = Ridge(alpha=1.0)\n",
    "    meta_final.fit(P_train, y_train)\n",
    "    y_stack = meta_final.predict(P_test)\n",
    "    \n",
    "    m_stack = regression_metrics(y_test, y_stack)\n",
    "    m_stack[\"tol_2pct\"] = tolerance_accuracy(y_test, y_stack, 2.0)\n",
    "    \n",
    "    print(\"Stacking Ensemble (Ridge meta-learner):\")\n",
    "    print(f\"  MAE  = {m_stack['MAE']:.4f}\")\n",
    "    print(f\"  RMSE = {m_stack['RMSE']:.4f}\")\n",
    "    print(f\"  R²   = {m_stack['R2']:.4f}\")\n",
    "    print(f\"  Tol.Acc (±2%) = {m_stack['tol_2pct']:.2%}\")\n",
    "    print(f\"  Meta-learner weights: {dict(zip(model_names, meta_final.coef_.round(4)))}\")\n",
    "    print(f\"  Meta-learner intercept: {meta_final.intercept_:.4f}\")\n",
    "else:\n",
    "    print(\"Need at least 2 models. Run notebooks 04-07 first.\")\n",
    "    y_stack = None\n",
    "    m_stack = None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55661aee",
   "metadata": {},
   "source": [
    "## 4. Weighted Average Ensemble\n",
    "L-BFGS-B optimizes weights to minimize MAE on validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "537e7403",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-02-24T17:57:37.850685Z",
     "iopub.status.busy": "2026-02-24T17:57:37.850153Z",
     "iopub.status.idle": "2026-02-24T17:57:38.077183Z",
     "shell.execute_reply": "2026-02-24T17:57:38.076171Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weighted Average Ensemble (L-BFGS-B optimized):\n",
      "  Optimal weights:\n",
      "    vanilla_lstm               0.0000\n",
      "    attention_lstm             0.0000\n",
      "    bidirectional_lstm         0.0000\n",
      "    batterygpt                 0.0000\n",
      "    tft                        0.7470\n",
      "    vae_lstm                   0.2530\n",
      "  MAE  = 3.5098\n",
      "  RMSE = 6.0992\n",
      "  R²   = 0.8991\n",
      "  Tol.Acc (±2%) = 35.17%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.optimize import minimize\n",
    "\n",
    "if len(model_names) >= 2:\n",
    "    P_test_mat = np.column_stack([predictions_test[n] for n in model_names])\n",
    "    \n",
    "    def objective(w):\n",
    "        w_norm = w / w.sum()\n",
    "        combined = P_test_mat @ w_norm\n",
    "        return np.mean(np.abs(combined - y_test))\n",
    "    \n",
    "    n_models = len(model_names)\n",
    "    result = minimize(\n",
    "        objective,\n",
    "        x0=np.ones(n_models) / n_models,\n",
    "        method=\"L-BFGS-B\",\n",
    "        bounds=[(0.0, 1.0)] * n_models,\n",
    "    )\n",
    "    weights = result.x / result.x.sum()\n",
    "    y_wav = P_test_mat @ weights\n",
    "    \n",
    "    m_wav = regression_metrics(y_test, y_wav)\n",
    "    m_wav[\"tol_2pct\"] = tolerance_accuracy(y_test, y_wav, 2.0)\n",
    "    \n",
    "    print(\"Weighted Average Ensemble (L-BFGS-B optimized):\")\n",
    "    print(f\"  Optimal weights:\")\n",
    "    for name, w in zip(model_names, weights):\n",
    "        print(f\"    {name:25s}  {w:.4f}\")\n",
    "    print(f\"  MAE  = {m_wav['MAE']:.4f}\")\n",
    "    print(f\"  RMSE = {m_wav['RMSE']:.4f}\")\n",
    "    print(f\"  R²   = {m_wav['R2']:.4f}\")\n",
    "    print(f\"  Tol.Acc (±2%) = {m_wav['tol_2pct']:.2%}\")\n",
    "    \n",
    "    # Weight bar chart\n",
    "    fig, ax = plt.subplots(figsize=(8, 4))\n",
    "    ax.barh(model_names, weights, color=\"steelblue\")\n",
    "    ax.set_xlabel(\"Weight\"); ax.set_title(\"Optimized Ensemble Weights (v3)\", fontweight=\"bold\")\n",
    "    ax.grid(True, alpha=0.3, axis=\"x\")\n",
    "    plt.tight_layout(); save_fig(fig, \"v3_ensemble_weights\", directory=v3[\"figures\"]); plt.show()\n",
    "else:\n",
    "    y_wav = None\n",
    "    m_wav = None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58f52174",
   "metadata": {},
   "source": [
    "## 5. Comparison: Individual vs Ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "dfae4451",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-02-24T17:57:38.079192Z",
     "iopub.status.busy": "2026-02-24T17:57:38.079192Z",
     "iopub.status.idle": "2026-02-24T17:57:38.548533Z",
     "shell.execute_reply": "2026-02-24T17:57:38.548533Z"
    }
   },
   "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>MAE</th>\n",
       "      <th>MSE</th>\n",
       "      <th>RMSE</th>\n",
       "      <th>R2</th>\n",
       "      <th>MAPE</th>\n",
       "      <th>tol_2pct</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>model</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Weighted Avg Ensemble</th>\n",
       "      <td>3.5098</td>\n",
       "      <td>37.2000</td>\n",
       "      <td>6.0992</td>\n",
       "      <td>0.8991</td>\n",
       "      <td>19.8853</td>\n",
       "      <td>0.3517</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vae_lstm</th>\n",
       "      <td>4.3620</td>\n",
       "      <td>45.8589</td>\n",
       "      <td>6.7719</td>\n",
       "      <td>0.8756</td>\n",
       "      <td>7.7004</td>\n",
       "      <td>0.2586</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tft</th>\n",
       "      <td>3.8832</td>\n",
       "      <td>46.0483</td>\n",
       "      <td>6.7859</td>\n",
       "      <td>0.8751</td>\n",
       "      <td>25.3429</td>\n",
       "      <td>0.3690</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Stacking Ensemble</th>\n",
       "      <td>8.2744</td>\n",
       "      <td>102.8093</td>\n",
       "      <td>10.1395</td>\n",
       "      <td>0.7212</td>\n",
       "      <td>19.8089</td>\n",
       "      <td>0.1655</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vanilla_lstm</th>\n",
       "      <td>8.2521</td>\n",
       "      <td>107.0577</td>\n",
       "      <td>10.3469</td>\n",
       "      <td>0.7097</td>\n",
       "      <td>13.1128</td>\n",
       "      <td>0.1793</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>bidirectional_lstm</th>\n",
       "      <td>8.9165</td>\n",
       "      <td>118.8097</td>\n",
       "      <td>10.9000</td>\n",
       "      <td>0.6778</td>\n",
       "      <td>15.5560</td>\n",
       "      <td>0.1207</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>batterygpt</th>\n",
       "      <td>9.1768</td>\n",
       "      <td>135.2250</td>\n",
       "      <td>11.6286</td>\n",
       "      <td>0.6333</td>\n",
       "      <td>14.4997</td>\n",
       "      <td>0.2069</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>attention_lstm</th>\n",
       "      <td>12.4333</td>\n",
       "      <td>261.9260</td>\n",
       "      <td>16.1841</td>\n",
       "      <td>0.2898</td>\n",
       "      <td>87.3831</td>\n",
       "      <td>0.0862</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                           MAE       MSE     RMSE      R2     MAPE  tol_2pct\n",
       "model                                                                       \n",
       "Weighted Avg Ensemble   3.5098   37.2000   6.0992  0.8991  19.8853    0.3517\n",
       "vae_lstm                4.3620   45.8589   6.7719  0.8756   7.7004    0.2586\n",
       "tft                     3.8832   46.0483   6.7859  0.8751  25.3429    0.3690\n",
       "Stacking Ensemble       8.2744  102.8093  10.1395  0.7212  19.8089    0.1655\n",
       "vanilla_lstm            8.2521  107.0577  10.3469  0.7097  13.1128    0.1793\n",
       "bidirectional_lstm      8.9165  118.8097  10.9000  0.6778  15.5560    0.1207\n",
       "batterygpt              9.1768  135.2250  11.6286  0.6333  14.4997    0.2069\n",
       "attention_lstm         12.4333  261.9260  16.1841  0.2898  87.3831    0.0862"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved to E:\\VIT\\aiBatteryLifecycle\\artifacts\\v3\\results\\v3_ensemble_results.csv\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABvYAAAJNCAYAAADqNUIUAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAq15JREFUeJzs3QV4ZNX9P/6zsOgCixQvTou7u7sWbaG4w+Lu7g6LuzuUfosWirsWdylaWmQXh4X8n8/p/85vkk2ySTbJ5M68Xs+TZ5OZycy9dyYznz3v+zmnX1NTU1MCAAAAAAAA+rRRar0BAAAAAAAAwIgJ9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAKAL9ttvvzTTTDPlrw8//LDbj+Hmm29euf/CzTffXLksvu+K4vc32WSTDt1+1lln7dTtR1Y8Tsv9bsuyyy5buW18nXvuucPdZtNNN212m3jeutvTTz9duf8zzzyzV56Xvib+BqqPc3tfTzzxRKo31fvfkddYZ2/fk5599tk088wzp+23375Lv//zzz+nCy64IK222mppjjnmSIsuumjaf//902effdbsdmussUaac8450/vvv99NWw4AAI1JsAcAANSFRx99tNnPP/zwQ3ruuedqtj3Q1/3yyy/p8MMPT01NTenPf/5zl+5jzz33TCeddFJ666230k8//ZQ+//zzfOLBH//4x/T1119XbrfxxhunH3/8MR122GHduAcAANB4+td6AwAAgI5ZZZVVcjdMGDhwYJcO2wMPPJD/HX300evusEeIF2HemGOOWelEiqCB3rXyyivnjq22TDjhhL26PbTtrrvuSq+99lqaeuqp02KLLdbpQ/XUU0/l+wirr7562mGHHdKdd96ZO1c/+uijdNZZZ1U6Etdcc8104okn5gD+oYceSksssYSnBgAAukDHHgAAlMRYY42VJptssvwV33dF8fv1FK5MOeWU+d8I8WJazMJjjz2W//3tb39bs21r9Ndpa1/1GCqX1cUXX1wJY/v169fp3//nP/+ZRhtttPycHnHEEWnGGWdMO+20UxpvvPHy9U8++WTltmOPPXZaaqml8veXXnppt+0DAAA0GsEeAAB0k1g7rFg367777kt/+ctfcpdKrDu19NJLp1NPPTWvR1Utpqo76qijcvdKrD+1wQYbtLkGWcs19iLIig6++HmllVYa7vYx0F7c/u233253Lbd33nknDRo0KM0///xpnnnmyd+3tXZgW+sLtrduWHQKxrqB0RU0++yzp4UWWihtscUWlQ7CkQ32inDvkUceGS7YW3DBBdv83TiGF110UfrDH/6Q9zu+Ntxww3TjjTfm6Qlbiu2NKQbnmmuufOyPPfbY3CXYlgcffDAf6+K+4/n961//2qH9+vXXX3MAUmzbbLPNlo/fzjvvnN588812f/eee+6pPBfnnHPOcPscxz+ui+0pxOs19m2++ebLayvGbbbaaqv0zDPPpJ5Q/Xq58sor87GNYx9/B3FsY8rGb775ZriuzFgLbpFFFsnbOO+886b1118/3XTTTcPdf0z7OHjw4Py3Ea+5uM899tgjv9arRXdZsR0xjWT8PcZxnnvuufNrNv52YjuOPPLItPDCC+fnYrPNNkuvv/56m/sWXWzF336sBXn66ad3uHs0Hm+33XbLjxW/H6FbdL7F/lQbMmRIfv2tsMIKef/ia7nllsvbGdeNyAcffJBefPHF/P3yyy+f/3311Vcrx+Kggw4a7ndinby4bskll8zTeG699da5MzZeOwMGDMi3ife4Ylv7928+SVDxOA8//HDu6AMAADrPVJwAANADLrzwwmbdY5988kk699xz0yijjJJ23XXXfFkMfkfoE4Pp1R0wW265ZYem2owumXXWWSddcMEF6b333suhR4QOIUKE2267LX+/wAILpBlmmKHN+4mgIwKe6vWw/v73v6fnn38+h0sjK0KmCKOq7+urr77KU/JF+HbFFVfkbRwZEUJF2FmEeUOHDk2vvPJKs+ta+vbbb/Pxf/nll5tdHvsdXxHKRRg76qij5sv/9re/pb322qsS+EWgF8Hb7bff3uo2XX311TlcrQ4I4/mNr1iPLEKm9hx33HHpsssua3bZf//733T33Xfn8PeGG25I00wzTau/u8wyy6RJJ500/fvf/0633nprniKx8I9//CMf/xBBWojHOeaYY5rdR9wmApjouorrI0TriO+//z59+umnrV43xhhjpAkmmGC4y+MYRkBUHKv427jmmmvSd999l0444YR82QsvvJCfr+pwPJ7DuDy+4jmPsLh4/cffUfXfYIR28Tdx//33p8svvzwHYS1FkPfGG29Ufo7XU9znb37zm2avk8cffzyHnhHgFYFWIY7ZLbfcUvk5Aqyzzz47/51HyNpeZ1zsR2xD7Ffh3XffTWeccUbelksuuSR3yMXfUmxXy9duhKURksZ7wfXXXz9csFYtpsMs3kciNA6zzDJLDq3jNRpTah588MH5OQsRAhbHZr311qv8XcTvF+8v//nPf3KIWQR7EUpXi7C0EH//EcoCAACdo2MPAAB6QHQ5RXATA/8HHnhg5fLqgOnaa6+thHoRMlx11VX5+uhGihCiIyKYibAwRNdMe+FNW04++eRKqLf22mvnICi62GJKxda61jorgoYIImIdr9jnCA2LYxL3H9s6siK8C7Fe2BdffJHDqOgoqr6upeOPP74SjKy22mr52Mf2FWuNxXMXx6EIiiL4iu2N473PPvvkMOroo49uFogWIlArbh9dVxHyRahUBBnnn3/+cKFMSxHchcUXXzw/txGQRjdZBCqxb/FzW+I2RTdeBEMR1BSK0GncccdNq666av4+OhRDdMHF48Z9R5gUoVXc1x133JE6KgKhmHKxta/qv4WWfy8R2sUxjTC1CKTimBWdbvG6jFAvpnSM4Dy2MY7r7373u3z7eNwiPI7grgj1oqss7jfCyemnnz6HZm1tR7x24rmJxyrCrngu4xjGdkW4W4RTEWJFGNlSXB6Be3RmxusnXvchunjbe63HayW2K7Yvws/oNizCtXjNxXp28R4RIrQuXj+xf3G72Mc///nPlW2OcK89RSdmhHLVAeCf/vSn/G+8ru+9997hXjfxemgtkIvQL16rxes2gtXivgpTTDFFZZrOtjqTAQCA9gn2AACgB8TUm9ttt12adtpp06abbprDh6LjqlA9DWWEBjENZoQJEbRFeNERU001VSWIivClCEGKQfjxxx+/1Wk6C8OGDcsdRiGms4ygauaZZ84D9DEVYneIrraiMy86CqOTrLqDsCPTBo5IMd1mhCPxWEXnXhyfySeffLjbx9SKRRD6+9//Pp144on52Mf2RaAy8cQT5+tim8NLL71UCVtXX3313K0V+xCdSzEtY0sRtBSdZdtss00+tuOMM07acccdK4FpdRDbmqKz7V//+lfuIIwwLwKVeL4ilIltaE/ctghsitdDhE7F873WWmtV1mqM10kRCMV9R6dcTPEYwU4ERG0FYd0lnoN4jDimETbG6694fX755ZfNtjG6waJjLrY1AvHo7IttvO666yohdwRwRZAUgWEElPG3WExBGwFwdadsIZ6rCCDjbyCOTyE6z2K74u84ptgsFNtWLdZ0jAA2pqxs+XcU3YJtiak9i464eLwIhOP5iekri47W4nms7uiN12bsS1x2wAEH5FA7pqQdURfsZ599lv+dZJJJml0e+1ncf/F41R3AMQ1na39T1VNrRldiBI+tHePib6utrk4AAKB9puIEAIAe0HLqyyKkiaCi8PHHH1cCi6KrJ8Sg+nTTTTfCjq5CdMXEtHoRkEVHUKyRVoQ3ERDEVHltiWCiWCMuQpLqzp2Ykq8z2uvuiw6jmEIyApjofqqeTrE7pvuMACcClZiKMKb4K7qV2lpfL6YuLaYLjI6+YlrBEKFqdGVFZ2GEH9HFFVOptnVcWjtOcf+FXXbZpdVtGNHzG51a0fUZwV4RDk044YR5e6OzMsLj9kSAGlNyxn5E6BuhT3SRFa/B6vX19t5777Ttttvm8DKmAC06+iJsjm7G+CpCsxGJ11xxH139e4n9LBSvlQjl4vUdr6Xo2IuvmJYyArAIIWN/IjytPv7xNxZBXWsiEIupJ6vF312heorN6u2rvrz677kQAXH166n69VH8zbcm/i4KF198cf5qKdZWjJAtAusIiWNqzwg54yvE+0iEidGlG+Fke+J1HYpjVoipN+M5jEA+AsIIgyPsLTqAq1831eL9I7oG42/mkEMOyR150UEYr73q8LB4vI52JQMAAM3p2AMAgB4w5phjNvu5eqC/UKy11Vog1tEQJUTAU3TQ/N///V/urGktvGlN9XpfLQO21ra5perfKboFW4pB/uguiyn6onMtwqqYQrG7FSFeTNH49ttvN7uspfbWHmv5nMQx6uxx6sixK4KVtkQoFx1zEfDFcxyBb/xOBCXRDVqsPdeeP/7xj/nfCGVizcCYYjJEZ2J0lBXmnHPOfNyiYzM6PGNNuZiKMaaPjHUFd99999Sbfy+tvf4jAI8pQyPMitd1dOBF6BfTYca0quuuu25eZ6+jx7+1brvq7ajehqKzMbS3Rl5rYV/1trS3XSN6TYbo2iw6XGOtzvhbHzRoUF7/MAK5CIHjbyuCuY5Ocdva/hTT98bjRVhXvG4mm2yyNoPS6MSLADSmEi5eL9EZ29aUsR3ZXwAAYHgqaQAAqJHornnnnXfyQP3777+fpplmmnx5/FwEUx0RYUFMCXnmmWfmzr3oWitCrVhTrD3RGRUdNDEAHx1kEVoVgUZr64eF6g7A+L32upE++OCDPEViMTXkEUcc0aFQqyuiky3WySs6i8LCCy/c6m2juy/2I8LI6Cyq3u+YhrJYky6CjOi2jA6pwgsvvNDsvlo7TsVzGWKqyAheitAnjnMEIC07papFF2VMyxhdXPG70fkUYWO8Lvbcc888lWSstxbftxcWxTSt8TqLwCfWjovpHluuuxjh2FtvvZUfK24ba+sVz110Ckb3Z0wtGlNfRhdgrcT2xdf333+fjjzyyMrrKDrbLrjggtylF9PbrrHGGvn4x3GO8C/WSixE52X8fuxnTwVL8dqJ11Xxd1L9eqnuzG2p+roIxrbffvvKz9GlGMFZMY1lhJLRvRf7vPHGG6edd965EnJG52W8fmJty2WXXbbNxyu6ImNNv5bifSP+nuJvI6bjLN6P4m+4+vV2ySWX5MeM12ZMYdtayN8y8C+CyequTAAAoON07AEAQI2suOKKle9322239NRTT+XpAWNQP8KlzijWU4vpJSP0qe7Wak+EWbGGVxHM7bPPPjlEiIAwOu1aUz2tXoQHEShEcBTrBLZUHRo8/fTTef8i6IipH9ubzrArIohoGZREMNeaCNVWXnnl/H0EaLE9sd+xll2EJDH9YIhArZheMcLAEF1SEZJFGBZdiDFlYWvPbXRQhQgzY6rECG9POumk3G0W06Vefvnlbe5LrMUYz188H/HaiCkRI7CNcC066YrnbkTdY3F9EeIVYeV4442XVllllWbBS6wDGa+76AKLDqsI9eKxiq62uJ+OdMGFCM5i/bS2vqrD4M44/PDD0w477JA7COOYR6gV0z7GdhaKsC7CvRC3ifXuIgR78cUXc6dj7HusP1esMdfd4rmL11C8ziMYO/TQQyvXxZSh7a0zWEyfGWFlvM7i7yq65SK4jyk2435DdF/G1KTRzbn//vvnfYvQMr6iy676WIwoSKyeZrblFL8h1smL10hxAkG1+DuJKXZjuteYfjUCwHjvKMLh+J1Yk68QAWDxt1WsOwoAAHSOjj0AAKiRWCctps587LHHcqhUhEgR2MQAfxHQdUR0UkV3TgyyF90w7YUI1WJqzFiXLoKO2J74Ku4jgrEIY6pFIHbuuefmQO+mm27KXXIxYB8D9bE+XXUoOeOMM+butBjwj6+YLrG1IKQ7xHSk0VkXoVR703AWDjrooHyMI9j729/+lr+qxZSUW265ZeU5iYAugqHY75NPPjl/FaFfy/Xy4vmIKRLjNhGMbLbZZs2uj99p7VgUIkSMkO2UU07JgWCxHdV22mmnDk3Zus4666TTTz+90jm11lprNZtyMtaMi4Bo3333zR1wcb+thTwxPWdHRHdffLUljksRUHVGBFhxHCNsPPbYY/NXtVlnnTUtt9xyle2N13E8L1dccUX+qhbPY3VA3Z1ifcb7778/f1WL494yfK4W4emBBx6Ytt5669zVFn+XLacijWMXYs3DmCKzeJyWjxXdgtG5155YPzGmNo3ws7rDsBCBf3QIFkFcTMHZMiiPrsKYrjU6j6N7L76qRWBe3TUc4XQR9sdxAgAAOk/HHgAA1Eh0s0RAts022+SQIQbWY+2ziy66KC266KKdvr+iw6YIDVsO1LclQqjrr78+hwXjjjtuDnqi4yym0JxooomGu32EdbHO2RxzzJG70mLwPzq+Ym2vlo8ZXUMxTWKEgREURvAXa7sdcMABle6fZ555prI22siqDk5GFOzFmnURTEZXXARtsW2xltpcc82Vu7wiDKvuUotpLS+77LLc7VXs9+abb56fw9ZEsHLWWWflbYouufidmBoywpDo1ovj3J4In6IzcIkllsjPURzLuJ+4v9NOOy0HQB0Rxz1CykL1NJyFNddcM0/tGc/7FFNMkUYbbbS8fRG+RKAZwV+txesmgqgIwOM4xnMVxzRej3FMI7wrXn8RXMYx3nHHHXOwHLeL5zvCrOgmq57msrtFt2A8RgSNsT0R0saUqS2DyNbEazb+FqOrMILUeB4isI5wNi4v1kWM10JMvRtdtbE+YoR+cVm8JuO5vvbaa/O+tiemqY0wMabtbG062Xjs6vC5tddNvB6ja3WXXXbJHYfxnMR7SHQXRsi3xRZbNLt9EYDHfXflPQ4AAEipX1P1qvAAAABAQ4hO0JjmNYLOmIq1p8W0pBE6RvhYTNcJAAB0jo49AAAAaEDFOpwxnWZPi7U0Y/3G6scFAAA6T7AHAAAADSjW0YtpaF9//fX0wgsv9OhjRagX62kuueSSpuEEAICRINgDAACABjTKKKPk9S7DpZde2qOPFfcfa+vtv//+Pfo4AABQ76yxBwAAAAAAACWgYw8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlIBgDwAAAAAAAEpAsAcAAAAAAAAlINgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA+Auvbrr7926nIAgEajXgIA6HvUaLRFsAeUyiabbJJmmmmmytdbb73V7Ppdd9212fVPPPHEcPfR1NSUVlpppcptXnjhhQ49VmtfZ5555gi3+corr8y3veeee/LP++23X/55rbXWSmUWx7Y4Dq+++upI319xX5deemnqLrfffnvabLPNml32ww8/pHPOOScdffTR3fY4r732Wt72448/vtvuEwB6S1s1z+yzz56WWmqptOeee6YPPvigcvvnn38+rbPOOmmuuebKNdXf//73ET5GfEbGfcZnZvVj7rjjju3+3ocffljZnqKW6oxa110d3c+OiLoz7mv++edP3eXf//532n///dNf//rXZpdHfbzxxhunjz/+uNsea6eddsrbHo8JAL2hqANG9NXa2FFP1hZPP/105bFXX331VEvxuRyfz/E53dmxnpE5FiNb440sY1r/jzGtchLsAaX28MMPNzuL5fHHHx/h78Rt3nvvvcrP11xzTbu3H2OMMdKkk07a6tc444wzwgLp5JNPTtNOO21adtllUz0ZffTRK8dhtNFGS33NGWeckXbffff00UcfNbt86623Tqeddlr69ttvu+2xZp555rTIIoukyy67LL388svddr8A0Juqa55JJpkkf9Z/+umn6W9/+1vadNNNK5+dBx54YPrmm2/SUUcdlfr3758OOuigdu83PhvjM3LhhRfOn5mdEfdfbFNsX9lMMMEEedvj374mns8IZm+++eZmZ4M/9thjaYMNNsiDjt1piy22SF9//XU64ogjuvV+AaAtAwcObDaGM+qoo+bLxx577GaXR83Tm6677rrK92+++WZ68sknU63E53J8PsfndFeP729+85tUNsa0/h9jWuXUv9YbANAVEST9/PPP6ZFHHkmbb755ZdDoq6++qlzXlmuvvTb/G4NDP/74Y+7q2nfffdP444/f6u0XX3zxdPbZZ3dpOy+44IL03XffpQ033DCNMkp9nUsxzzzzpAcffDD1VVGYdubykbXRRhvlgbCzzjqry68XAKilljVPhD3xc3SKRedWdOatvfba+aSoX375JX/FiTQjCuvi9+O28VnZWZNNNlmfrjdGJI5PXxXPyffff99q4BczXHS36Ab4/e9/n8/Kjw6AWWaZpdsfAwCqRVd6fBXihOs4+Xe99dbLJyrVQoxb3XXXXc3Gpa6++uq04IIL9vq2xDhafC7H53NXZgRoeXzLxJhWc8a0yqe+RpmBhhFTP4Wnnnoq/fTTT/n7Rx99NP8799xzt/l7//3vf9O9996bv48iLs7QiakZb7rppm7fxhgoueGGG1K/fv3SyiuvPMLbxxRXURAtscQSeeqrKDiPPfbYNGTIkMogy5xzzpmnKage4Ioz6FtOfVBM6xADJv/5z38qnYoxpVIcu/nmmy9ttdVW6Z///GezbSimQbjqqqvSH/7wh3ws99lnnw5PWzBs2LB0+umnpxVXXDHvQxSGcT/XX399h49bPJ8xTeZCCy2UC60ddtgh/etf/xruWO22225pgQUWyMckpgO79dZbm00Hcfnll+fvo2gvpk2NY1pMAXbLLbc0m3Ljiy++yK+J6LyLbV9ttdXytKDVA1vFNBN77LFHOvTQQ/OxjPuMzswll1wyn/V33333NZuuDADKKk5KWmWVVSo/x2dlGG+88fLZ5RHyDRgwIJ1wwglt3kd8JsZnY3xGxrSerYmTrOJzNz5/Yzqq6umY2pqmKT574/M4apqoBw4//PBc4xW3bU2cgLPuuuumOeaYI62wwgqVk70KcTLWcccdlz/TY1viNlHXFLVm9XSYf/rTn9LgwYPTvPPOmwPRF198scNTccZtow6L7Y7Hicfbe++98752VNTA1ftS1D3VYpBw1VVXzY+x2GKL5TqzmAYzHisevxDXxXZG914xFVdYbrnl8j4U7rzzzlx3xeNGrbbLLrukt99+u9XnK2qz6AiMeu7UU0/N1xc1cXRwAkBfEieIX3jhhWmNNdbI/9ePz8ntttsuT0HenWIsIsK8OLk8ZhkKUeN89tlnrW7Tueeemz8/i8/znXfeOddh1WLMJKZOj/GM+IyOMZmYqSgepz1XXHFF/retMasvv/wyjwlFvRXjO3FSfPXJ0m1NxRn7GDVkbEvUi1GDRe3U1pI2MX4WM0HE7A5RN0TdFLNGVDOmZUyL5gR7QClNNdVUacopp8wf/s8880y+LLr3QhQCbYkALwqjCSecMA9KxGBDiIGd7j4zOYLGCA1jGs4pppii3dtGMBaFUAymRDE35phj5kAqgqWYCikG0mLgbNFFF823L4K9uP/nnnsuf//666/noivcf//9+d8I5iaeeOI8oLblllvmwC8G6eIM/JjGNIK+1qZZikAxBmnimMw222wd3ucY/Ioz+99///28vXEm+CuvvJIOPvjgEU55Woj172JwKkLCGGD7xz/+kc8cKgYTo2Mgjskdd9yRn/+xxhorn2UWxWYU4cV0EDGAGGKqjWLa1DgWxbSh8XvFlBtRmEaReeONN+YgNbY91m+M49DadFF33313fs3E78bgZtxPPGcxuBfHNo43AJRZfIbHZ+/5559fuSxOpgl/+ctf8owJ8Xk7aNCgXIO0pfhMjM/I+KxsKeq4GNSK+idqtBioijWTW06lXS3qgzix6bbbbstTgsZnb4RYRx55ZJu/E4HTNttsk2uUCOpiACxO0nn22Wfz9fHYMV33JZdckk+KirohfifqmhhAa1knRjgXA1MxVWgcq452n8V9R6gXdVjUMVFHxGWxxl3s04gG4EL8XtR1Ra0W+xInRcWsAYUTTzwxh51xm6hror6JOjNmkYh6MbY7plttOZVW1EfVs1hE7VRMIxrHOJ6bqLuiwyDq0Og4iPuM49pSnDBVPK8xsBeKWjZeF9XTfwJALcX4Q3y2xufnG2+8kcdN4uTqGFuJcZOiw647p+Fcc801c+dgfPbGZ2VrJ0THCc1xcsy7776bP3uj2y/GI2KbihOg4ySq9ddfP0+dHp/xcX/xuRxjK/H7bYnP4WLsKALD1kSNFmMvsX0xbhI1YHsndBX7F4HfO++8kx8jlsIparC2RKgXYyxRB0WdFydrHXDAAZXrjWkZ02J4gj2gtOIs4SLQiwGOIuBqK9iLgY+iUIoQLQKeGIgIURA99NBDrf5e9dnfLb/aU8yR3pGBnhj4iKJxmmmmyQVjhG3RNRfhVBRBJ510Ur7d8ssv3yzYi9sVZ5HH/sXZ2+GBBx7I/8ZZWkWRFINO2267bf6d+IqiNYqz4r6rxQBOFHhxRlScDd5RRVEYgz7RCRePEwXcMsss0+70qNXieYnBrRjoKwaoYsDryiuvzN/HIFoMNMbzHI8RX8Xt4sz5KDbjrPMokKun8Ir54qPAnGGGGSpnpMXlcTZYnDUex3nGGWfMA21xnxHyxaBXBJJRRFcrjlsc7yJMrH6uazk/PgB0VXXNM+uss+azvmMAJ0TXVpypHTVXBEZRV8RJMNHdFZ/1Xa2Hhg4dmj9L4zM1pjAvBtfaO0kmzgIv1ks+/vjjc80QIV97oVgEgBHkRW0SnWTFiT4xvWiIwbC4n4kmmigPmEUNFDVZURMVM0NU1wIx2BX793//93+5ZuiICBIjZItAL+qNuN947DgTPmrbTz75ZIT3EccnTlCLfYntLKbuiuMX9WQM8F188cX5sghm43HidtF5EPcfJ45FfRTHrBADcFEXxdn1ERIWYpAtphON+y1qxuI4xnMWnZZRe7U25WjUXLF/UasX3ZoxbWvMZhEDkzFwCgB9QXzeFTVLnOAbn9fxGRbjDvG5GycrRy0xsuIzuRhfiDGLcccdtzI7QoxXxWMVosutmK0g1jOOOiVqkjhxPLalmLUoPoPjczXWuYvO+tiPk08+OV8Xn/9Rr7UmPocjCIzP5bbGt6JLMO4jPveLTv+ok9oSQV5RE8RJPVEDxHb/8Y9/TJ9//nmbv1eM28TjRMdkiN8tjrkxLWNaDM8ae0BpxeBHnHkcH/YxoBEBVwRjURC0JoK7YoqjOJspRGEy/fTT5zOJ4izkmAqppTgrqq3199pTTHUUZzq3JwZf4sznEINj0eEXYvAsip8YmImBpWOOOSZP+xgdaHGmU3wVg0wxcBJnZEeRGIVXMVASUzNF0Vjsd4RVRfFXBIIxHWcUS3FmeiECxOhq7KwYBIzHPu+889ILL7yQj29sQ0yV1dE1BmOahqKojO2I4C1C2yK4LQLYl156qdn0YKHo4Fx66aU7td0R5oXoDojHL0RYGl9xnKebbrrK5RG4xkBWqF4kuvi+I4NyANDXRM0TgVMMvBTdVHFyTkxDFZ/HIc4CLz6Tu6MeirolpiEPUYdFN3zUKMVU5K0pTmSK9WCKz+04OSfqu6hBWhOBXVH/RbgUMz9EOFg8TlELREgVZ8EXigGluL7l2ewxg0DLWmBEYpsjBIxAM06eimk8o5sxTlyKbeyomG4r7ifqt+233z4P4kUdFFOOxwBe8fzFQGRr+1JM/dVR8ZxHuBeiizGmBQvRtVc9c0a1GJiL10t8FeL72OY4zjHF1ojWZwSA3hCBWIiTmuLkmRDjQHESdnyeRb0QQVuMb4yMYhrwYpmVEOM+MbYVNVOcZFXMLFV8tsZJRsW02FFPxX1Ep30xE0IxLhQdgMV4UkxtHtOJ/va3v83BXXs1WoSL1Z/V1WI2gej8D1GvRQ0WNUxbYvwplsAJceJXMZYWdUuMucWJYa2Jk+6LMagYz4mTpkLUC3GitzGt9hnTakyCPaC0ouAqprGMM51HNA1nMd1BiPVGWooutwh2YqCnWgy4xABGZxXFTjElZFuqz1qaeuqph5tytBiIiYGTKHTijO4YvImzmaKwDDE4E1NhRbAXA1shptCMIq568K2YzrJaDPzENEnVwV5MxdQVhxxySL6feD7iTPvibPsIW2Ngqeg4bE/LwbE4Gy32oTiecSZacUxaO2Ou5TzsHVFMYRoDYvE1ovuMqataCyqLgrc7zuQDgN5W1Dwx0BNTN8XZ6jFQEHVTEex1dz3UMsyKcDGCvfamaSzus2W9Mvnkk7f5Oy0fpxgMKx6nqC/isYuBrmotL4uOv66cBBUnCkUoFrMMxMlVMQAW69tEXREzLUSXwIhqxyKAbW2/YwCs2JfWtruty0ak+j6L9Ztb1lLVaxG2V0/G/sV2Vq/RAwC1VIRRLcdkqn9u7fOvM2I8ppgpIE6Ebq1LLsKvItgrPnuLKbHb+nxt63bFeNLIjFlVj89E/RHaq9GqT8yqPuk+gsPYvuI4t/c41VO3RxBYXYMY02qdMa3GJNgDSiuKmTgbKc62Ls7maSvYiwGMYprItkRxEmc+xZlE3aEYcBnRWinVZ7DHlKDVA2fFnOlxX0VxE+FYBHsxXWWEmjFQFZdFiBfr0sSZXqE4k6z6/mPdmGJtkwgKY1AqOgBbam0NnI6IYCvWutt7773ztsQi0zEfe3TRRddeBJFF+NWW4kysQrGAdDF4FqFaBLBxdnpxtnkUezElVvV2t3VWWmuXx33G6yjOxKuemjTOTG9te4uCtqUi0Iuz5wCgzDVWTHMdU5fH53CscRIDW7F2b1froZahT6GjHf3Vitqm5Yk37a3LN6LHKe4zuueq1wVuOavBiGqBjogz3qPei2MSU07FCUzxmNEtELXtiLrporaMwcVim4taqaiXisujxotaLLogW6tr2qqVWlNdT8YUXDFLRoh1cGKwrrX7aqueVC8B0NfE51ycbFOMwRSq14WrXpu2K2666aYRLlES017GbEwxK1PR7RZhWIxXFbVMjAdFkPO73/0uz0AVt4vbVNcD4YYbbsgnrsfMSq3NQtWRMavO1mnV9ULMZBRdg0W9UIRPnX0cY1rNGdOiYI09oC7W2YsiJz7cip9bioIm5iqPgY2YyjHOQK/+KkKwmKqyrYGnzirOjhrRWdFRaMW0TCEG0Yo1Y2Kgp+gyrJ5ysuh6izO8YprICDNj34vpoeLy6vX1ouOtOMss1rCJwZQoJiPAjAG6rbfeulv2NwaL4jGjcIv53GMtnZguopj2KorF9uZUL0S3X+x7KOZYD8X6McVzHOvrFEV2rBUTA2Tx+MUZYEVgGQVkvD6KArq4vBhUitdFcZ8x7cWLL76Yv4/BtRjci2kgYlqram0NhBVn8BWDXQBQVhEQHXfccfkzLz5D991338q0i12ph7rSUd+WYo2XOImomGI8TnYq1lLuiqIWiCCsOBksOurisaKTsVi/uCuhWLU4ySpqluWWWy6fgR61S0zFXhynjz/+uEP3E5198XxEnVNMPxoDdDG1ZWxz1Dtx4lN0BkYdFGe4xwlMMfNDXBaqT+4q6sNQvV5gcXnMBBFTdYXo6ox6OWY5iCm6Yn9i7Z+WWjtGsb3FlJ7FdGEAUGux7EmIk5HjZOkYa4nP6VgSJUS3WTFrVFfE/RV1ysorrzzcmFTUGcX6v8UJRsUYT3TWRf0Q9xGf53HC1S677FL5/C9uFye8RygYYjmX+GzeYosthhvPKBS1R+zniE5I76gY3ypmwYrxp+jgizoiasq2puEcEWNaxrRonWAPKLXqDr04W6m1tUmieIjArjhDOs6yirOVq7/+8Ic/5OujSIoOs2oxBVWs+dLaV8y33pYiiHrllVdGuB9HHHFEPqs5gqqYdiHW14v1XWLwI6bWjG63QhRJMbhSKIrLohMvxFlbcYZXceZThHgxuBJztMcxi8GrWIQ5Cqxi30dWHMcIIKPYvPzyy/OgUhyD/fbbr3I8Wk5r0Zo4kyz2PUK1mJM97i/2OeadDzvuuGMeWIrANI5V3O8JJ5yQB63iGBRTOBSPFWeFxbbEbaovjykw4jjHdKExKBXTWMXxjgWs4/jsuuuulddVR9d/iUHF0NXpygCgL4mBoj//+c/5+zjx6PTTT+/0fXSmHuqoWEOmWPs2ZgqIsCrW2mttFoKOitArzmiPeiLWFIzaIWqP+Dlqi5EZzKsWtUvUTDGIFlOcxv1GbRZrFMf2F+v6tCfOXI86LuqYqFmKtXViWvY4iS0G6jbaaKN8WQz6xfFZaqmlckdj1IXFlPQx9VZRNx1//PF5n2MArnrqrj/96U953ZvoWowAMvzlL3/Jjx3bHidERa0d3Z2dqZXicTtSFwJAb4gxiGJmgv333z+PR8T4QnTQReAWAV97sw9F0NbeGFF8VhfdgFFztByTimkr46Ti4nM2xibic7Y4sTvGM+LzPB7jgw8+yCfzbLvttvm6nXfeOY+jFLVF1F6xPSFu39YJ8DFuFDVFjLkUn88jK+qM2J4QNULUklEzxAncxQwCnT05ypiWMS1aJ9gDSi0KlKIoaKtYia6vmAIgrLbaaq3eJoqdYqrH6umXQpy5FCFSa1/tTSUQxVRMyRjTObScXrKlCILijPMI2SJ4jDOwI8zacsst8/SgLadNqF6rrgg3o+grpi8ouvUKcUZYrOcSBVUUpVG4RdEaZ1y3dUy6IqaOioI3uvbicSI4jGAyCrt4/I6Itfhiv2OKqxhwin256qqrKmeJx2BTdDLGwFgc3zhbPArSGNiLNf4KsVh0FMZRJMdxKX4/it8IRuP+I0yNQbQoiuM4x2BaFLZxJnlMbRrTfRZntY9InLke3ZJxlvvILqgNAH1FTK9drN972WWXVTrbO2qZZZbJn41PPfVUlzr+WhMDQ9GtHzVC1ApRc8QMBMUA14jWqGtNbGPcZ5zsE2eGR30RNVkEZHF5MRg1suK+o9aME4ni++iIizovgrdYa68jAWLUQnHmfnGiVwRkcZLYZpttVrlNnM0fA5MxK0QEb1EPRZdg1FRRNxWiEzN+P2qlmII1BhLj5LA4wz/Ctwg2izo0LosAcPbZZ8/1dxz32N7YlqKLckRievaiNgWAviI+5+NzOE6KjrXv4vMvPjujjol174qOvrbE2FB7Y0TFbEwxLhHjT62Jk5RCrEFbLDdz2mmn5ZOOo8s9xhziMznqnyuvvLJyMnfUBdENGGM70VkY9VbcPk6KjpOy2gvSojYIMbNVd4lxraOOOirPZBSPHcczaqmiPospvDvLmJYxLYbXrylGdwHoEXFW1UUXXZQDpzgDjPoVU2fEgGIU2WeeeWatNwcA+owYkIoprs8///wcYI2sJ554Infex+BWDEjF9N/FNOMx9VSEWcWAGH1LTNEeJ0LFWtEx0AcA1M5bb72VA8E55pijMtPVyIqTgOKEqehCjM7/OHnopZdeyjVABKYxXtLyZHRqz5hW+fy/yfMB6Habb755PjMrCiTBXn2L5zi6/4ppqgCA/9lhhx1yEBdrHndHsBezLESnfYR5sT5xTMUeZ7cXHYHRDUff8/rrr+dQL866F+oBQO3FrAzxuRwnYMVafB1dhqQ9n332WZ56M5x88sl5tqRY9ibE7ACxRA59jzGt8jEVJ0APiimc4iz1WFcm1uqjPsUC1bHWTYS33VEIA0A9ic/GTTbZJN177735M3Nkxfq3sXZcTMMe02l//vnneaqnWCPv0EMPbTYlJX1HdGzGNFwxRSgA0DfE9N3x+XzBBRd0y/0deeSReWrzmA40TsKK9XtjyZNYLiWmEO3KVJz0LGNa5WQqTgAAAAAAACgBHXsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJRA/1pvAPSGYcOG5cVaxxhjjDTKKPJsANr366+/ph9//DENHDgw9e+vXKKxqaMA6Ax1FKijAOjZOspIFQ0hQr333nuv1psBQMlMO+20aaKJJqr1ZkBNqaMA6Ap1FKijAOiZOkqwR0OITr3iD2KsscZKjaCpqSl98803aZxxxkn9+vVLjcA+e57rldd277+2v//++3xCSPH5AY2sEeuontSI7+k9zTF1PPuyRnx9qqOgPuuoens/q6f9sS99l+emb2rqw3//Ha2jBHs0hGL6zTHHHDONPfbYqRHEG9TPP/+c97evvUH1FPvsea5XXtu1e22bvhkas47qSY34nt7THFPHsy9r5NenOgrqq46qt/ezetof+9J3eW76pqYS/P2PqI6y2BgAAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlIBgDwAAAAAAAEpAsAcAAAAAAAAlINgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKoH+tNwB606ALH04fDx3moAPUqbsOXq3WmwB1Sx1V/7yHAkDPUEf1HPUL0Ih07AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlIBgDwAAAAAAAEpAsFcjTU1NdflYAAA9TR0FAKCOAoBGJdirgeuuuy6deeaZlZ8/+eSTtOWWW6ahQ4d26+PE/e25557p9ddfr1w200wzpUsvvTT1pg8//DA/7j333NOh2/fU8QAAyk8d1T51FACgjvof41EA1CvBXg2cd9556euvv678/Nhjj6VHHnmk2x/n1VdfTX/729+andUeg2GrrbZa6st66ngAAOWnjmqfOgoAUEd1jToKgLLoX+sNoHfNPffcDjkAgDoKAKDXGI8CgO6jY68HRDfeEUcckZZeeuk0++yzp0UXXTQdfPDB6bvvvkvLLrts+uijj9Lll1+ep6e8+eab0/77759/b4EFFqhM0fnzzz+nU045JS255JJpjjnmSOuvv356+umnK4/xxBNP5N9/8skn0wYbbJBvs+KKK6a//vWvles33XTT/P3aa6+d9ttvv1an4oyuvq222io/9kILLZS35csvv6xcv8kmm6RjjjkmnXTSSWmRRRbJhdguu+ySvvjiiy4fnzgOBx54YFp88cXTnHPOmf7whz+ku+++O1/X2vEopk6499578z7F76y00krpwQcfTC+99FJab7310lxzzZWP0RtvvNHl7QIAak8d1T51FACgjuoadRQA9ULHXg/Ya6+90ltvvZX23nvvNNFEE6VnnnkmDR48OE022WT532233TaHVptttlmaeuqp0w477JDOOeecdMkll6Tpp58+30cEX3//+9/Tbrvtlqaddtp000035XXnYirNWWaZpfJY8Rhx+e67754Duwjw4r5nm222dMghh+SA8fjjj0/zzjvvcNv58ssvpz/96U9p/vnnTyeccEIO9CJMjLDv+uuvT6OPPnq+XTz2PPPMk+/n3//+dzr66KPTaaedlu+7K+L3H3/88byPE0wwQbrxxhvTrrvumqcNjTC05fEYNmxY/r0DDjggX7fddtulk08+Oe/7wIED0zbbbJMmnnjivL9xnzfccEMXnzkAyu6XX37pU/dD56mj2qeOoieV9b0vlh749ddf8/b369ev1ptTeo6n49mo7yX1QB3VPnVUferqe049fd7Zl77Lc9M3NfXhv/+OvqcJ9rrZjz/+mLvtIvRabLHF8mULL7xwnqf72WefTTvttFMOzH7zm99UpiGIcC9Ed994442X3n777XTrrbfmIC267UJ07m244YY5GDzrrLMqj7fFFlvkgDBMN910aamllkoPP/xw7l6bccYZ8+XR7VY8RrUIzyIQi7VqRhtttHxZ/E787u2331557Njes88+uxL0Pf/88+mBBx7o8jGKoDOOzSqrrJJ/nm+++fLxiABvwgknHO54RMdeWH311dPmm2+evx8yZEgOM+N4xvaGuC46C+N++vf30gZoRPEZRXmpo0ZMHUVP8h4KUF7qqBFTR9Un9QvQiKQf3WyMMcZIF198cU59P/jgg/Tuu+/m6SEjnJpqqqk6dB8xvWYR5hXdasXP0cVWLaagLEwyyST53++//75DjxNTe6611lqVUC/ENJe//e1v01NPPVUJ9madddZKqFc8TkcfozXRIRgdgZ999llaZpllcpdeMVVoe2K60UJ0QhbhX2H88cfPiXZMrRCBIACNp7vW7ojPEtM79z511Iipo+hJZV3/KP7vNXTo0Px/gL52xm0ZOZ6O58hSR9WGOmrE1FH1qav1Sz193tmXvstz0zc19eG//47WUYK9HnDPPffkdeliLb3oQIvwbcwxx+zw73/11Vf531jTrjXVoVr1/Y4yyv+WTIw20o6IF28RkFWLy7755ptmxWG1eJyOPkZrDjrooDTppJPmrsT77rsv3190GsYxi+PVlnHGGWe4y8Yaa6wubwcA9WfUUUftU/dD56mj2qeOoieV9b0v/mMe/6eI7e9r/zEvI8fT8WzU95J6oI5qnzqqPnX1PaeePu/sS9/luembmvrw339H39MEe93svffey+virbfeenk9uAiwwlZbbZV++umnDt3HuOOOm5/Aa6+9ttUXVnX33MiI9ek+//zz4S7/73//22wdv+4WYeTOO++cv955551099135+lFTz/99HT44Yf32OMCAH2bOmrE1FEAgDqqa9RRANSL/7V40W1eeeWVvMbetttuWwn1ojPuxRdfzElwdWdd5Ulo8fO8886bp5SMzryYfrL4iu62CPs6mtqO6Haxtl2czRXbW3jhhRdyp2FsQ0+ITr811lgjXXrppfnn6aefPm2//fa5bf6TTz5p9XgAAI1BHdU+dRQAoI7qGnUUAPVEgtLNZp555hyonXjiienxxx9Pt912W9pkk01yuFdMoRlzt0bQF2vpRdhXrAd355135rX4Yk275ZZbLu25557pmmuuyfdz0kknpbPPPjtNM800Hd6W6PwL9957b3r77beHuz4CtX//+99pu+22y6HhLbfckgYNGpR+//vfp1VWWSX1hAjtIsSLDr3YtzgG559/fl7AeIUVVsi3aXk8AIDGoI5qnzoKAFBHdY06CoB6ItjrZtGBFmvFvfzyy7lr75RTTkkLLbRQ2nvvvdNbb72V167bbLPN8lRT22yzTQ7W4voFF1wwHXHEEeniiy/O93PqqafmzrYI8+J2Ec4deOCB+T476ne/+11aeeWV03nnnZeDxpZmn3323Dn3ww8/pF133TUdf/zxafHFF0+XX355t0332Zr9998/rbXWWuncc89NW265ZbrpppvSvvvum9Zff/18fWvHAwCof+qoEVNHAQDqqK5RRwFQL/o1FfNDQh377rvv0quvvpoGP/zf9PHQYbXeHAB6yF0Hr9atnxux5uzYY4/dLfcJZaWOahzd9R7a2+K/tEOGDMlriLe2RjmOZy014utTHQXD/z0Yj+p79Us9vT/bl77Lc9M3NfXhv/+O1lH9e3WrqCvxBxBrAY5I//5eZgAA6igAAONRADCyJC50WayPt+mmm47wdq+//rqjDACgjgIAGGnGowBodII9umy22WZLN954oyMIAKCOAgDoFcajAGh0gj26bJxxxklzzDGHIwgAoI4CAOgVxqMAaHSj1HoDAAAAAAAAgBET7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACfSv9QZAbxq89eJpwIABDXHQm5qa0pAhQ9LAgQNTv379UiOwz57neuW13RivbejrGqmO6kmN+J4OAI2uHuooNQxA36FjDwAAAAAAAEpAsAcAAAAAAAAlINgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJdC/1hsAvWnQhQ+nj4cOc9CBbnXXwas5okDdU0cBI6ImAlBHQU9Sa8D/6NgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGCPZpqamtr9ua8r2/YCAPVDHQUAoIYCgJ4m2KsDM800U7r00ktH6j5++umndNRRR6X77ruvctnTTz+ddtttt1QWb775Ztpyyy1rvRkAQImoo/5HHQUAqKE6Tw0FQC0I9sg+++yzdMUVV6Rff/21ckRuvPHG9N5775XmCN15553pxRdfrPVmAAANRh0FAKCGAoDeItgDAAAAAACAEhDs1Ykvvvgibb/99mnOOedMK6ywQrruuuuaXf/222+nQYMGpYUWWijNPvvsafnll08XXXRRvu7DDz9Myy23XP5+p512Sptssknab7/90i233JJee+21PEXVE088UTkjfc8990wLLLBAmmeeefJ9fvLJJ5XHOfPMM9M666yTp/Wcd9550wYbbJDWXHPNtOOOOzbbnm+++SZv61/+8pfKNuywww75dxZffPG8bZtvvnm+v+J+11prrbxNSy21VL5dbOu///3vyvWDBw9OX3/9dd7em2++uUePNwBQP9RR6igAQA1lLAqAsuhf6w2ge1x44YU5+DrrrLPS/fffnw455JA05phj5su+/fbbtNlmm6UZZ5wxnXDCCWnUUUfNAVl8P9dcc+WALUKxCOn22muvtMwyy6TRRx89D3K9//776fjjj8+/+/3336dNN900T9d52GGHpf79++fHi8sioBswYEDeltdffz0NHDgwXxdr97311lvptNNOy6HbuOOOm29z1113pVFGGSWHkD/88EMO8UYbbbR03HHH5cc5+eST05dffpnmm2++yj7+61//ypfHNsb2xfZvvfXW+bHXX3/99Omnn6bbb789XXLJJWnqqaf20gIA1FHqKACghxiLMhYFQG0I9upEBGDHHnts/n6JJZbIgVycaRTB3rvvvpummWaadOqpp6YJJpgg3yY692JNumeeeSbNP//8aZZZZsmXTzfddDnECxNOOGHuiJt77rnzz1dffXXurIvwrAjOonMvuv1iPb4ID8OwYcNyx190zoW47wjk7r777rTuuuvmy/7v//4v/16Egddff33u+ovtmWqqqSrbEWFdte+++y6HhYsuumj+edJJJ00bbbRRDjLjviabbLIcWhbbC9Bbfvnllx69/6ampnxSRTxOv379UiOo9T739HNK36KOUkcB3cPnZ9+raWrB66BxqKHUUNDbyvYZU091gH3pW69xwV6dWGmllZr9HF13Rx55ZJ7yMqbevOqqq9LPP/+c3nzzzfTee++ll156Kb+ZxGUd9dRTT+XAbYoppsjhXRhvvPHSHHPMkR5//PFKsBf3O+2001Z+b5JJJkmLLLJIDgQj2IuwMKb2PPfcc/P18X2EgEWoF6KLcMopp2z2+OOPP34l1CsKyLjs2WefrUwlClALzz//vAMPJaaOUkcB3UNNBI1FDaWGgt6m1oD/EezViYkmmqjZz9GZFyl6TMM5zjjj5E636OCLrrcIzKJLL6bCjNt01FdffZXeeOONNNtssw13XYR7hXi8McYYo9n1a6+9dtp3333T559/nm677ba8fYsttljlfqM7sKWJJ5642c8RELYUvzd06NAO7wNAT+jpTuF4r473ujiZouxneJVln+PzMj7zaAzqKIDuYfaUvlfT1II6qnGooYDeVrZao57qAPvSt+oowV6daBluRYAWwV2sdRdr0J155pm5g2+VVVbJwVuIgK0zYn28CPUOP/zw4a4ba6yx2v3dWEvv0EMPTffee2+eknPVVVfNa/QVgV2sy9dSrPFXLdbca+02rYWCAL0ppgHu6eIp3tPjccpeCJZln3v6OaVvUUcBdA+fn32vpqkFr4PGoYYCelvZPmPqqQ6wL33rNT5Kj28JveKhhx5q9vPf//733EU35phjpueeey536cWadUWoF9NqxjScRcdeay+YeNOpNu+88+Y19mJ9vbjv+Jp11lnTBRdckB599NF2ty+2I6ZouPnmm9MLL7yQ1lxzzcp10T0Ywd7HH39cuSxS6Q8++KDZffznP/9JL7/8cuXnp59+Onf7Lbzwwq1uLwBAR6ij1FEAQOepodRQANSGJKSOiqmTTz45B2wHHnhgDu523nnnfF2ssReB3Nlnn52efPLJdOWVV+br4iyB77//vtKNFx5++OH02muv5e+jRTjCtrjPIUOG5PXxIhjccsst05133plvO2jQoNyFFwHfiMR0nBEyRjAYa+gVIuSLdfu222673M0Xa/HF/cb2VZ/JEN/vuuuu6Y477kh/+9vf0p577pkWWGCBSrAX2xtTj8b2fPbZZ918hAGAeqWOUkcBAGooY1EAlIVgr07svvvu6cUXX8zh2LPPPpvOOOOMtMQSS+TrIpCLMO7qq69O2267bbruuutysBcddMWCoxHYbbLJJnnazr333rsSxMU0l/E7jzzySA7/IhScaqqp0sEHH5zvI6bHPP/883PX3YhECBdTdlZ364XRRhstr/8XU3LGYx9zzDHpz3/+c5p88snT2GOPXbldbGPs31FHHZWnA401+s4999xK+LfiiiummWeeOYd/t956a7ceXwCgfqmj1FEAgBrKWBQAZdGvqZiLEXpYTJ0Z4WF01EWHXiGm4YyOwuWWW65y2TfffJMWWWSRdOqpp6bll18+rxF42WWX5fvo6qKTr776ahr88H/Tx0OHdcv+ABTuOni1Hj0Y8VEdndOxbmrZ52Qvyz4XnxuzzDJLs5NMoFbUUUAZ9HRNVEa1rmlqQR1FX1LLGioYj4LGrjXqqQ6wL32rjurfS9tDA4s19e6///7cDbjCCis0K6SKxZZ33HHHtP3226dFF100F1KXXnppmmyyydLiiy9es+0GAKg1dRQAgBoKAKoJ9uhxse7dJZdckn7/+9+ngw46qNUpOo8//vh08cUX50BvzDHHzAHfiSeemL8HAGhU6igAADUUAFQzFScNwdQHQE8yFWf9TfFgCikY/u/BlOZAvU2P1Qg1TS2oo2D4vwd1FDRmrVFPdYB96Vt11Ci9tD0AAAAAAADASBDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBPrXegOgNw3eevE0YMCAhjjoTU1NaciQIWngwIGpX79+qRHYZ88zAD2nkeqontSI9UpPc0wdT4C+rh7qqHr7vK2n/bEv0Hh07AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAT613oDoDcNuvDh9PHQYQ460Cl3HbyaIwY0PHUU0JvUX0A9UUc1Dp9fQG/QsQcAAAAAAAAlINgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwV4JNTU1pUbQKPsJAPSeRqkvGmU/AYDe0Si1RaPsJwDl1pDB3kwzzZQuvfTSNq9/4okn8m1effXVNm9z5plnpvnnn7/y87LLLpuOPvro1NMGDx6crr322srPm2yySdpxxx1Tb+vs/rY8XiNyzz33pMMOO6yLWwcA9BR11MhTRwFA41FDjTw1FAD8T////1+qzDbbbOm6665L0047bacCt4EDB/b4cYyAbP/996/8fOihh6ZRRx011ZvLLrssjTvuuLXeDACgk9RRtaeOAoDyUUPVnhoKgLIQ7LVinHHGSXPPPXenDuSss86aamHGGWesyeMCALRGHQUA0HlqKACgoxpyKs7wxRdfpO233z7NOeecaYUVVsgdeu1NxXnRRRelZZZZJgd+e++9d/rhhx/anA7g5ptvTgsttFA6//zz04ILLpiv++mnn9LPP/+cTjnllLTkkkumOeaYI62//vrp6aefbnY/X375Ze7IW3jhhfPUldtuu21677338nWxTeHYY4/N99naVJyff/55OuCAA9ISSyyRt3XLLbdMr732WrOOv3XWWSf99a9/TSuuuGLejg033DC9/PLLzeYTv+SSS9Jqq62Wr5933nnTNttsU9mO7vDPf/4zbbzxxmmeeebJx2iXXXZJH330UWWfnnzyyXTvvffmff7www/zdm+wwQb52C633HJprrnmytsUx+viiy/O+7vAAgukgw46KB9nAKDnqKPUUQCAGqpgLMpYFAC9q2GDvQsvvDBNMMEE6ayzzspB2yGHHJJuvfXWVm8bod7JJ5+cA7Ezzjgj/fjjj7k9vz1ff/11uuOOO3KQt99++6XRRx89HXjggemKK65IW221VZ66c/LJJ8/BWxEgDhs2LP/8yCOPpH333Tc/ZgycxWURJBbh42abbZZ/v6Vvvvkm/fGPf8yh2D777JNOOumk9N1336WNNtoovf/++5XbRUB39tlnp9122y2dfvrp6auvvkp77LFH5foIyk499dR8X7HvETS+9NJLedrP7hDHJgLLSSedNG/HkUcemY9BsQ3xONEBGUFd7PMkk0ySL3/zzTdz4BjBZTxfjz32WN7G++67Lx111FH5uN5www35CwDoOeoodRQAoIYKxqKMRQHQ+xp2Ks755psvd76F6PaK4CtCrLXWWqvZ7X799dd0wQUX5G6xnXfeuXL7NdZYI3366adt3v8vv/ySb7/44ovnn99+++0cHB5//PFp7bXXzpdFoBjdchHSRcB4//33p1deeSVde+21uZOtmGozOtii666YHnSKKaZoderP6GaLrrfbbrstTTfddPmyRRddNC2//PLp3HPPrezvt99+m4O7WWaZpRK0RRD4r3/9K0099dTpk08+SYMGDcqPG6KjLi6LDsTuEMciwsS4/2I/J5poovToo4/m4x37HFNQxBp71VOiRkgZ+zD77LPnnyM4ffzxx9M111yTJpxwwrTUUkvlfX/hhRdymAnQXeI9vZaikzreH2M7+vXrlxpBrfe51s95X6eOUkcB9LR6+SyudU1TC/Xy3PUENZQaivpXi/fAevqsqad9qbf9sS996z2kYYO9lVZaqdnPMc1mdI7FmUbV3n333TzdY1xfiD/CCMuuvPLKdh+jCNdCdNEVYV505hXi5+hCC88991waf/zxK2FXmHLKKdM//vGPDu1TTOsZU1dWP+7YY4+dA6/qKT+je3DmmWeu/Fx0xEVwFmI6y2IqhQjh3nnnnRy6ddcUlxHcxX7GVKgx3Wds3yKLLJKnHm1P//7982LShd/85jf5+ESoV4j7HTp0aLdsJ0Dh+eefdzCgijpKHQXQ09Rf1CM1lBqK+ufzC+gNDRvsRYdYtZiWM1Ln6GarNmTIkMr11SaeeOJOPUZ0qIUIsFrz/fff58dquV2dEYFWa78fl1UHlmOMMUazMwRGGeV/M7LG/oe33norh3sRNEYwGJ19EQZ2l+jGi1A0uhRvueWWdNVVV6XxxhsvT88Z6+a1ZayxxhruzIYxxxyz27YLoC3V3cO1EO/P8R4f75VlP8OrLPscJ7u88cYbvf64ZaGOUkcB1Hv9VS81TS2oo9qmhlJDUf9q8flVT5819bQv9bY/9qVv1VENG+y17OqK7rQIuAYOHNjs8ugAK66vFl18nRHTSo466qh5ms3W/ogjOIvbtHa/0S03/fTTp8kmm6zdx4htj+k0W4ptL/ZjRKI1eIcddsjdcDGt5QwzzJC397zzzktPPPFE6i6/+93v0mmnnZZ++umn9Mwzz+S1B2NNwJj2c6655uq2xwHoDvH+XeviKT6jYjvKXgiWZZ9r/Zz3deqo1qmjALpPvXwW17qmqYV6ee56ghqqdWoo6kkt3gPr6bOmnval3vbHvvSt95D/tWo1oIceeqjZz3//+9/THHPMMVwHWExrGVNV3n333c0uf/DBBzv1ePPOO2+eHzU68+Jxiq/77rsvh33xhMUZHV988UV68cUXK7/3n//8J2299dbp2WefbdZd19Zc7a+//nqePrQQjxdr98Xjd0Q8foSDsfZfTJlZvOE88sgjzbr6RkbcV3QuxmNFoBnfH3jggfm6jz/+eIT7CQDUljqqdeooAEANZSwKAHpa/0YekDr55JNzqBSdaU899VQ6//zzh7tdBFu77LJLOvjgg/NabsXtX3vttU5NTznrrLOm5ZZbLu25555pp512yoHhww8/nC688MK0xx575Nssu+yyeY28XXfdNe2+++65g+/ss89O00wzTWWNv2jbjfXyYh2+lp1t66yzTrrsssvydJZxHzGNZtz/Dz/8kMPBjk4LMfnkk+d1/6LLL/b/hhtuqKwRGEFh3O/IiEAzDBo0KG/raKONli6//PK8bwsttFBlP+MYR5egDj4A6FvUUa1TRwEAaihjUQDQ0xq2LSqCs+iM22677XI33BlnnJGWWGKJVm+7/vrrpyOPPDJ37e244455usztt9++04956qmnpjXWWCOHdRFo3XvvvblTLdaWCxFwRaAWnXdHHHFE2nvvvdOkk06aLrroory+XIiA7rHHHsu/P2zYsFbXrpttttnSYYcdlvbaa68cwl1zzTU5SOyICPLiWMQ6fBEOxvYVU3F21wKwEdpF4BiPsc8+++SAL8LH2PcIT8NGG22Ufvzxx7y/r7zyykg/JgDQfdRRrVNHAQBqKGNRANDT+jV1x9yK0MfFopOvvvpqGvzwf9PHQ5sHogAjctfBq9X0IMVH9ZAhQ/JaqmWfk70s+1x8bswyyywj3akOZaeOAhqx/qqXmqYW1FEw/N+D8ajGUYvPr3r6rKmnfam3/bEvfauOatipOOkescBxfLUn1suzZh4AgDoKAMBYFACMHMEeI+WAAw5It9xyS7u3+cMf/pCOO+44RxoAQB0FAGAsCgBGgmCPkRLr42288cbt3maCCSZwlAEA1FEAACPNWBQAjU6wx0j57W9/m78AAFBHAQD0NGNRADS6UWq9AQAAAAAAAMCICfYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAT613oDoDcN3nrxNGDAgIY46E1NTWnIkCFp4MCBqV+/fqkR2GfPMwA9p5HqqJ7UiPVKT3NMHU+Avq4e6qh6+7ytt/0BGouOPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlED/Wm8A9KZBFz6cPh46zEGHOnfXwavVehMA6o46Cujr1IBAX6WOol757IXa0LEHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlIBgDwAAAAAAAEpAsNeAbr755jTTTDOloUOH5p+XXXbZdPTRR7d6XXf48MMP833ec889Hbr9J598krbccstu3QYAgJGlhgIAUEcBQK0J9hrQ0ksvna677ro0YMCA1Bc99thj6ZFHHqn1ZgAANKOGAgDoGnUUAHSf/t14X5TEhBNOmL8AAFBDAQD0NGNRANB9dOz1Mfvtt19addVVh7t8pZVWSkceeWT6+uuv0xFHHJHPdJp99tnToosumg4++OD03XffNZv28t57783TWc4111xpqaWWSpdccknlvjoz3eZPP/2UTj311LTCCivkx1twwQXTbrvtlj7//PMu72Ns64EHHpgWX3zxNOecc6Y//OEP6e67765s2/7775+/X2CBBdKZZ57ZbJ823XTT/DtxPB588MH00ksvpfXWWy/v5/rrr5/eeOONLm8XAFBeaig1FACgjmqLsSgA6omOvT5mtdVWS7fcckt666230owzzpgve/XVV9N7772XjjnmmLTXXnvl6/bee+800UQTpWeeeSYNHjw4TTbZZGmnnXaq3E8EZ5tssknaZptt0l//+td03HHHpbnnnjvNM888ndqe+L3bbrst7bPPPum3v/1teu2113LQN/bYY+ft6YpYz+/xxx/P2zjBBBOkG2+8Me26667pb3/7Ww4sd9hhh3TOOefkMHL66adPw4YNy793wAEH5Ou22267dPLJJ+djMHDgwLyPE088cTrkkEPyfd5www1d2i6gfvzyyy+pnjQ1NaVff/0171e/fv1SI6j1Ptfba6gRqKHUUAB98fO71jVNLfTF54H2qaPUUdBX3vPr7XOznvbHvvStvynBXh+zyCKL5OkJ7rzzzjRo0KB8WXw/xRRTpNlmmy39/PPPuWNvscUWy9ctvPDCeU26Z599ttn9rLHGGpWgb/7550+33357euCBBzod7EVnXpwBH111YaGFFkqvvPJKDhS7Kn43tn+VVVbJP88333zpN7/5TQ7wYt+nnnrqfHl0CI433ni5Yy+svvrqafPNN8/fDxkyJO2+++55H6NTL8R1J510Ur6f/v29tKGRPf/887XeBKCXqaHUUABqQFBHtcVYFPQMn71QG9KPPiYCqZVXXjndddddzYK9CMHGHHPMdPHFF+d0/IMPPkjvvvtunnoygq+pppqq2f3E1JSF0UYbLXfGff/9953entNPPz3/++mnn+bHe/PNN9PLL7+cA8auiqDx+uuvT5999llaZpllcpdehIcjMsccc1S+j27FIvwrjD/++DnRjukVIhAEGld0KNeTeN+P6ZPjva3sZ3iVZZ/js8T0zuWihmqbGgpoFH2xBqx1TVML6qjyUUe1TR0FvfvZW2+fm/W0P/alb9VRgr0+OgXC1VdfnaffjDAu/o1utXDPPffkKTA/+uij3N0WAV4Efi21vGyUUUbJbb+d9fTTT6fDDjssB3rxBhRdg3HfxZp+XXHQQQelSSedNN16663pvvvuy9sW6wDGfsU+tWWcccYZ7rKxxhqry9sB1K9RRx011ZMonuK9Mvar7IVgWfa53l5DjUIN1To1FNAo+uLnd61rmlroi88DI6aOap06Cnr3Pb/ePjfraX/sS9/6mxqlx7eEToupKSeffPJ0991352696aabLs0666w54Nttt93SkksumR588ME8Bee5556bppxyyh45yl9//XVe027aaafNgeJTTz2VLr300rwtIyOCwZ133jnf5x133JHX13vkkUcq3YEAAF2hhgIA6Bp1FACUh2CvD4r0ftVVV033339/uvfee/NZUyHWtospMLfddtvc8RailffFF1/MiXl3e+edd/L9b7bZZpWpPuPxn3jiiS4/XnQNxvp/ERCG6aefPm2//fa5bfuTTz7Jl8VZDAAAnaWGUkMBAF2jjlJHAVAepuLso2LqzUsuuSQHYUUn28wzz5xbMU888cS04YYbps8//zydf/75OXzryvp5IxKdgmOPPXYaPHhwDhNj+s3LL788vf/++3k9u66I0C5CvLPOOiuNMcYYaYYZZsiLrMYixocffni+TbE+XnQrLrroot26TwBAfVNDqaEAAHVUNWNRANQbwV4fFdNdTjPNNJXwq+hui3Xozj777By0TTzxxGm55ZZLa665ZjrjjDPSN998063bEAFbhIoRJMaUnLH+3SKLLJLWXXfdtO++++aAL7axs/bff/+8XzGNaISTMZVo3N/666+fr19ooYXSggsumI444oi0wQYbpC233LJb9wsAqF9qKDUUAKCOaslYFAD1pF9TT8zhCH1MdBu++uqrafDD/00fDx1W680BethdB/9vCuN6ER/VQ4YMSQMHDiz9Ystl2efic2OWWWbJ3evQyNRRQFn0xRqw1jVNLaijYPi/B+NR1Kvu/uytt8/Netof+9K36igde4zUH/Mvv/wywtv17+9lBgCghgIAGDnGogBAsMdIePLJJ9Omm246wtu9/vrrjjMAgBoKAGCkGIsCAMEeI2G22WZLN954o2MIAKCGAgDoccaiAECwx0gYZ5xx0hxzzOEYAgCooQAAepyxKABIaRQHAQAAAAAAAPo+wR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlED/Wm8A9KbBWy+eBgwY0BAHvampKQ0ZMiQNHDgw9evXLzUC++x5BqDnNFId1ZMasV7paY6p4wnQ19VDHVVvn7f1tD/1tC9Ax+jYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACfSv9QZAb+r33nwpjfp6Qxz0fiml8eObT1PDsM+NoUPP88xNvbdBAA2ikeqontSI9UpPc0wdz3apC4E+oB7qqHr7vK2n/emWffF5CaWiYw8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACDRfsNTU11XoTAABKSR0FAKCGAgBqqy6CvUcffTRtscUWaf75509zzjlnWnXVVdPgwYPT999/X7nNTz/9lI466qh03333detjzzTTTOnSSy9t9boPP/wwX3/PPfeknnTmmWfmx2nra6+99kp93c0335y3dejQoW3eZr/99ktrrbVWr24XANQ7dZQ6CgBQQ3WWsSgAqJ3+qeQeeOCBtP3226f1118/bbbZZmmMMcZIL774Yjr//PPTc889ly666KJ8u88++yxdccUVaeGFF+61bZtkkknSddddl6abbroef6yxxx47XXLJJa1eN+GEE/b44wMA5aOO+h91FACghuo8NRQA1Ebpg70LL7wwLbXUUumII46oXLbIIoukKaecMu2xxx7p2WefTfPOO29Ntm300UdPc889d6881qijjtprjwUA1Ad11P+oowAANVTnqaEAoDZKPxXnF198kX799dfhLl9mmWXS7rvvnsYff/w8JeZyyy2XL99pp53SJptsUpme89RTT00rrLBCmn322dOCCy6Ydtttt/T5559X7ueXX35JZ599dv79ueaaK62zzjrpoYceanVb4rbRPRjB4ttvvz3cVJwxleQuu+ySO+sijIxpQ7faaqv0wQcfVO4j9iWmEV1yySXz4+288855qs9ll112pI/VE088kbfnySefTBtssEGaY4450oorrpj++te/NtuHE044IS299NL5mMS0ptdcc02z+3n33XfTdtttl+aZZ560wAILpP333z8NGTKkcn3sZxz76JpcfPHF8+323nvv9O2336aTTjopLbTQQvkYnXLKKa12Dqy00kr52EQH5htvvNHm/vz888/5PuJYxb5E1+bTTz890scJABqFOqrj1FEAgBqq89RQAND9St+xF8FRBF877LBDWmONNXJoNNFEE+XpACJkKwK8CMsGDRqU15uL0C8cd9xx6bbbbkv77LNP+u1vf5tee+21HPTF7x5zzDH5NvHv9ddfn383wqNbb701P9aNN96YZp555mbbcvDBB+dg6fLLL08zzDBDDvZaeuSRR9Inn3ySDjnkkPTjjz/mdf8OO+ywypShp512Wrr44otzABghXDz2ySefnCaeeOIRHothw4a1enn//s2f5gjZttxyyxy+xbGLIC4Cusknnzydd9556aabbsphXfwcaxLG9sXxWWKJJdJ//vOftNFGG+WOyBNPPDF99913+ZhF0Hf11VenUUYZpRLQxfSncfzeeuutdPzxx6cXXngh71OEcXG/8VjzzTdfDjkL0XkZ2zXppJPm5yzCvTvuuCMHtC0deOCB6e9//3sOY6eddtq83bFfMf3pLLPMMsLjBdSvOEmhnjQ1NeUTP2K/+vXrlxpBrfe53l5DbVFH/T/qKHUUUJ9q/Zle65qmEY95b1BD/T9qKDUU9aGvvHfX2+dmPe2Pfelbf4ulD/Zius2vvvoqd5394x//yJf97ne/S6usskrafPPN04ABA/KUmEXQE+vdzTjjjPn76MyLUOsPf/hD/jlCwVdeeSU988wz+ee43+hW23XXXXNwFWKNvuhYe+qpp5oFexFu3X777TmUm3XWWdvc3h9++CEHWsW6d++9914644wzcvdZBH3RzbfjjjumbbfdNl8fYdqaa66ZA7T2fP3112m22WZr9boIuqqn6dxiiy1yYFYcjwjWHn744dzxFvsenXprr7125ZiMOeaYaayxxso/RxAYb0axn+ONN16+LI5thKpx/Jdffvl82ffff5/3K0LW6Ki74YYb8jZGx148H4suumi65ZZbcthXHewdcMABlecj9ifu7y9/+Ut+LqtFR2SErBEYFtsaj7PhhhvmQPCss85q93gB9e3555+v9SZAKaij/kcdpY4C6pe6kJ6ghvofNZQaivrh8xLKpfTB3hhjjJHDnQjfogssAqqYajJCpQiEIpj7zW9+0+rvnn766fnfTz/9NId1b775Znr55ZdzyBb++c9/5oS06PAL0ZEWXXTVImCKQHDjjTce4Xp+0flWhHphkkkmyWl3hHrxeNFdWIRjxeOtvPLK6eabb273fqPLMDoFWxPdg9Viis/qxy+CuDD//PPnrsGYrjS2I6YAjY64QgSaMbVmPF5xVlaEg9HB9/jjj1e2PX6OUK8Qz0F0AEaoF+IMhYEDB6ahQ4c227aYGrQw2WST5Q6/WCexZbAXz3ER5lWfHRY/RzgKNLZ6W3M0Pifi/TJOqCj7GV5l2ec4oaa96aDrhTrqf9RR/6OOAupRrevCWtc0tdAIdZQa6n/UUP+jhqIe1Przsl4/N+tpf+xL36qjSh/sFaaYYoocrMVXBHMRvsU0lxdeeGHuymtNTJsZ00xGoBd/XNEhFt1pRXdcsW5cdUDVmtdffz0ttthieSrI6Iabaqqp2rxt3H+1YurK6IL78ssv8/fVwV9oK5hsuWBxTBXaEdXbUP34IToFozsvphqNaTTjK6bLjGlLp5566tzFGAFka92BMU1nITol23vc1sTjtvy9CSaYIJ8B1lJsR4i1+loTQWXRZQg0nnhPrCdRPMX7dexX2QvBsuxzvb2GRkQdpY6qpo4C6kmtP9NrXdM04jHvTWooNVQ1NRRl1lfeu+vtc7Oe9se+9K2/xf5lbxGO9e5iass555yzcvloo42WA74777wzT9nYmgiL4ndjqslzzjmnEsbF2nfR9RfGHXfc/G8EbtXh3ksvvZQ7z37/+9/nn7feeut8XzH9Z6wRd8EFF3Rpf2JdufDFF180C/Pi59584UR3XHx9/PHH6d57701nnnlm3q8ISccZZ5zcwbjTTjsN97vRgTcyogCKjsWiq6/Y9+gIbCmem9jWa6+9ttU3xer7AACGp47qfuooAKh/aqjup4YCgM75X7tWSU077bS5u+7KK68c7roIiCKYivX2Wks633nnndwGG2vNFaFedPo98cQTOX0O0QEXv/fAAw9Ufi+u23///dNVV11VuSw67KI7bN99900PPvhguuuuu7q0P7FmX3SsFWsFFlr+3JO22WabdOyxx1bOPIspOZdbbrn0ySef5MtiqtGYtjS2NY5PfEXwFtN3RuA5sh566KHK9x988EF67bXX8vSgLcV2xDSpEQYW2xFfMR1rhH195SwTAOir1FHdTx0FAPVPDdX91FAA0Dml7tgbf/zx0+67756DqOjsWmeddfKacRFCRfAW4V5MjVndfRfdeLHOXYRRMRf44MGD8/STERDGGnXvv/9+vt8QXXMbbLBBXq8vusIizPq///u/9K9//Sudcsopw21PdOzFmn4xfeXiiy/e6f2JbYyg8eyzz87BVDxerN8X6/5FyNaeCLnaWuQ0OhhbmzqzNTHtZhyTiSeeOAdlEYBG52NsV4jjGWsXbr/99rkrMo7L+eefn6cjPeigg9LIiH2O6VMjrIv56k899dQcuq699trD3XbWWWfNgeOee+6Zuwfj+YznNroKYxFrAKB96qj/Rx2ljgKAjlJDqaGMRQFQa6UO9kJMGRnhz9VXX52ni/zmm2/yumxLLbVUOv3003NAFWIKyeg+i7XjnnnmmRzQxfUnnnhinkYzuu5ivbZ11103d95FwDfNNNPksCqKtksvvTSvuTfLLLOkiy66qNIJ2NLBBx+cg6iYvvLPf/5zp/dn0KBBeXApHi/2Zemll04bbbRRevLJJ9v9vQgmN9xww1avi4DykUce6fBZUtG5GAFldOHF8YtQL7YrTDnllDk0Pemkk3IhE2FcTIN62WWXtTplZmdEmBfrIR5//PHp888/z8/HoYce2uZaeRH8xTZGEBpr7kVge+CBB+bnGQAYMXXU/6ij1FEA0BlqKDWUsSgAaqlfUzHvJDUXHYa333577varXmMvArQffvghnXXWWTXdvjKLAbtXX301zTLmxmnsUV+v9eYAPW3m+vpoi4/qOLkk1jIt+2LLZdnnyufGLLPkDn/6PnVUz1FHAaVW47qw1jVNLaijykUN1bPUUZRGHxlHqbfPzXraH/vSt+qo0nfs1ZPRRx89T4N5ww03pK233jp3qj322GPpjjvuSOedd16tNw8AoM9SRwEAqKEAoBEI9vqYCPBimsuYkjK69GLKz1jjb4kllqj1pgEA9GnqKAAANRQA1DvBXh8zwwwzpHPOOafWmwEAUDrqKAAANRQA1LtRar0BAAAAAAAAwIgJ9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAL9a70B0Juapn0mpQEDGuKgNzU1pSFDhqSBAwemfv36pUZgnz3PAPTg52wD1VE9qRHrlZ7mmDqeAH1dPdRR9fZ5W0/7U0/7AnSMjj0AAAAAAAAoAcEeAAAAAAAAlIBgDwAAAAAAAEpAsAcAAAAAAAAlINgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJRA/1pvAPSmQRc+nD4eOsxBrzN3HbxarTcBAOqeOgqgnPx/CWpPHQVQ3+7q5fFpHXsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOxRGk1NTSN1PQBAo1JHAQCoowCoD4I9SuGee+5Jhx12WOXnwYMHp4UWWijNPffc6fbbbx/uegAA1FEAAMajAKg3/Wu9AdARl112WRp33HHz95988kk688wz0wYbbJDWXHPNNOOMM6Zddtmlcj0AAOooAICRZTwKgL5IsEfpDBkyJP+72mqrpQUWWKDWmwMAUBrqKAAAdRQA5SbYo8/bZJNN0pNPPpm/n2mmmSqXb7bZZmnKKafMX9XX33vvvem3v/1tzbYXAKCvUEcBAKijAKgvgj36vEMPPTTtvffeacCAAWm33XZLH3zwQdpvv/3SIYcckuaZZ540+uijV67fa6+90iSTTFLrTaaX/fLLL/nfpqam9Ouvv+af+/Xr1xDPg332PNerWr+2i/cVKDt1FAC9Xdeoo6gX6igAerv+6ej9CPbo82INvXHGGSevoTf//PPnAK+4fNZZZ83fF9fPPffcNd5aauH555934AGgFeooAPx/CbpGHQVAX623BHtA6RWBbnT4DB06NI033ngN1bFnn+uf57n3/56/++679MYbb/T64wIAdLfePgFWHQUANJq5u6ne6mgdJdgDSm/UUUethB+jjDJK/rmRgj37XP88z/1q9r4CAFB2vV3XqKMAgEYzajfVWx29n1G65dEAAAAAAACAHiXYoxSiI2lkrgcAaFTqKAAAdRQA9UMaQinEmmlvvvlmeuKJJ9IPP/zQ6esBABqVOgoAQB0FQP0Q7FEKG220Ufrxxx/T1ltvndeaau/6V155pSbbCADQF6mjAADUUQDUj/613gDoiEUWWSQ9+OCDlZ9ff/31dq8HAEAdBQAwMoxHAdAX6dgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUQP9abwD0psFbL54GDBjQEAe9qakpDRkyJA0cODD169ev1psDAJRcI9VRPUmN5pj2dV6jjifQ/eqhjqq3z4d62h/70nd5bvqmpjr4+9exBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlIBgDwAAAAAAAEpAsAcAAAAAAAAlINgDAAAAAACAEuhf6w2A3jTowofTx0OHOehkdx28miMBAOoogLrm/z1Qe8ajgLb4nKYrdOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlIBgDwAAAAAAAEpAsAcAAAAAAAAlINgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLBHn9TU1FTrTQAAKCV1FACAGgqA+iXYo8fdfPPNaaaZZkpDhw7t0O2ffvrptNtuu/X4dgEA9HXqKAAANRQAVBPs0efceOON6b333qv1ZgAAlI46CgBADQVAfRPsAQAAAAAAQAkI9urYfvvtl1ZdddXhLl9ppZXSkUcemb7++ut0xBFHpKWXXjrNPvvsadFFF00HH3xw+u677yq3/fnnn9Mpp5ySllxyyTTHHHOk9ddfP0+VOTLeeeedtPXWW6f5558/zTvvvGmrrbZKr732WmWbb7nllvxzTN/5xBNP5CmoFltssXT//fen1VZbLc0555zpj3/8Y/rggw/SrbfempZffvl8PzvvvHOHp/sEAGiPOgoAoPPUUADQ8wR7dSxCsLfffju99dZblcteffXVPM1lBH577bVXeuCBB9Lee++dLrzwwrTxxhvn6ZsuueSSyu0PPPDAdMUVV+TwbfDgwWnyySdPW265Zb6frvj111/TDjvskH755Zd06qmn5q+vvvoqbbfddvmyHXfcMS211FJp2mmnTdddd12abbbZ8u9FYHfUUUfl60844YQcDsY2XXTRRblojK977703nXfeed1w5ACARqeOAgBQQxmLAqAv6l/rDaDnLLLIImnCCSdMd955Zxo0aFC+LL6fYoopcmAW3XjRsRfdcGHhhRdOjz32WHr22WfzzxEKRkfc8ccfn9Zee+18WXTubbjhhjnkO+usszq9TZ9//nkOFqO7bokllsiXTTnllPlxolNw6qmnztv873//O80999yV3/vpp59yABndhiG289prr82/N/PMM+fL/vGPf6QXXnhhpI8bjSPC5LJramrKgXnsS79+/Wq9Ob3CPnuee0M9vD8wctRRANSL3q5r1FGNTQ0FUJ+fm/U0HtfUh/elo68HwV4d69+/f1p55ZXTXXfd1SzYW2WVVdKYY46ZLr744vwijikt33333fTGG2+kDz/8ME011VT5tk8++WQlzBs2bFjlfuPn6q6+zphooolyN15M+fnoo4/m7rzFF1887bnnniP83ZiCs/Cb3/wmjTbaaHm6zsL444+fPvnkky5tF43p+eefr/UmANBHqaMAqBf+30NvUkMBdI7PabpCsNcA00hdffXVuUvu+++/z/+uvvrq+bp77rknHXPMMemjjz7KXXJzzTVXDvwKMUVmcbZVa+L+xhprrE5tzyijjJIuvfTS3PEXj3/TTTflx4w18/bdd998fVsGDBjQ7Of4vb6WqFMu1V2hZRXhfExVO9544zXM34N99jz3hugijxNeaGzqKADqQW//v0cdhRoKoP7GJ+tpPK6pD+9LR+sowV6dm2+++fK6eHfffXf69ttv03TTTZdmnXXWHPDttttuab311str3k066aT59rFuXUx7GcYdd9w06qij5ikvW3uBjz766F3aptieo48+Oh155JHpn//8Z17XL8K+CBZj7T/oLfH6Lrv4IIpAPPalr30Q9RT77HnuDfXw/sDIU0cBUA96u65RR6GGAqi/z816Go9r6sP70tHXQ9vtUdSFeGFGWHb//fene++9N581FV555ZW8xt62225bCfUipX7xxRfzCzvMO++8eU7X6MybY445Kl/33XdfDvu68qbz1ltv5ak3X3755fzHM8888+R1/mKqho8//jjfpr2uPQCA3qKOAgBQQwFAXyNBaQAx9eZzzz2X3nzzzUpH3Mwzz5yDuRNPPDE9/vjj6bbbbkubbLJJDvciyAvR2bfccsvl9e+uueaafLuTTjopnX322Wmaaabp0rZEx+A444yTp92M9f4ee+yxdMABB+SBs6WXXjrfJlpgI+SLNfiGDBnSjUcCAKBz1FEAAJ2nhgKAniPYawAR0EUQF2HeDDPMkC+bfvrp8/p60TkXXXunnHJKWmihhdLee++du+q++eabfLtTTz01rbHGGjnM22abbXLX34EHHph/pysiTDz//PPz9hx22GFpu+22S++8804677zz0owzzphvs/baa+c1/+IxHnnkkW48EgAAnaOOAgDoPDUUAPScfk3FvItQx2LRyVdffTUNfvi/6eOhw2q9OfQRdx38v6lpyyzewqOzdeDAgX1uTuieYp89z735uTHLLLOkscceu1ceE/oqdRRAufX2/3vUUTD834PxKKDs45P1NB7X1If3paN1VP9e3Srqyq+//pq/2hN/GGVZABQAoLeoowAA1FAA0BWCPbrsrLPOSoMHD273NgsuuGC64oorHGUAAHUUAMBIMRYFAII9RsIGG2yQll566XZvM2DAAMcYAEAdBQAw0oxFAYBgj5Ew6aST5i8AANRRAAA9zVgUAKQ0ioMAAAAAAAAAfZ9gDwAAAAAAAEpAsAcAAAAAAAAlINgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKoH+tNwB60+CtF08DBgxoiIPe1NSUhgwZkgYOHJj69euXGkEj7jMA9JZGqqN6knrFMe3rvEYdT6D71UMdVW+fD/W0P/al76qn54a+RcceAAAAAAAAlIBgDwAAAAAAAEpAsAcAAAAAAAAlINgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKoH+tNwB6U7/35ktp1Ncb4qD3SymNH998mspn5qZabwEA0MB1VE8qdY3WRzmmjmdfVqrXp/+HQY+phzqqVO9nDbY/9qXv8tyU4HmZuZzj0Dr2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlIBgDwAAAAAAAEpAsAcAAAAAAAAlINgDAAAAAACAEhDsAQAAAAAAQAkI9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJdAQwV5TU1OtNwEAoJTUUQAA6igAoITB3o477phWXnnl4S4//fTT00wzzZSOOuqo4a5bY4010qBBgzp0/zfffHO+n6FDh3bo9h9++GG+/T333NPu7QYPHpyuvfbaNLL222+/tNZaa43wdrfffnvert122y31lk022SQ/ZltfN9xwQ+rrOnJ8l1122XT00Uf32jYBQHdRR6mjepI6CoB6po5SR/UkdRQAZdS/ozdccMEF0z/+8Y80ZMiQNHDgwMrljz76aBp//PHzv9W+/vrr9NZbb6U//vGPHbr/pZdeOl133XVpwIABqTudeeaZaf/990+95dZbb02/+93vcuD45ZdfpgkmmKBXHneBBRZIe+21V6vXTT311L2yDQBA69RRHaOOAgDUUV2jjgKAxtHhjr2FF144T8X0z3/+s1l49+KLL+aOsbfffjv9+9//rlz33HPPpV9//TX/XkdMOOGEae65506jjjpqKqvPP/88Pfzww2mPPfZIo402WvrrX//aa4893njj5ePX2lccWwCgdtRRI6aOAgDUUV2jjgKAxtLhYC+mdIzOvOeff75y2RNPPJEDrM033zyNOeaYzbr2nn322TTxxBOnGWaYIf/8zTffpEMPPTQtssgiac4558y/88Ybb7Q5FWeEgjGN5pJLLpnmmmuutPPOO6dLL700T8dY7YMPPkhbb711vs8lllginXfeec22ORx77LHNfu/BBx9M66yzTppjjjnSUkstlc4+++xm68cMGzYsnXTSSWmxxRZL8847b/79X375ZYTH6G9/+1saffTR0+KLL56WX375dOONNza7PgLQbbbZptllP/74Y36Miy++OP/81Vdfpb333jt34C200ELpxBNPzB2HMTVAd3Qvxn5H4Ljiiivm/d9www3Tyy+/XLnNf/7zn7Trrrvmx47jvtFGG6Unn3yy2f2M6PjFsb7wwgvzdse+xXN+/vnnpy+++CI/jxE2LrfccunOO+8cbhvjdnH7+eabL/9+dIi25bPPPkt77rlnPlbzzDNPnvb1k08+GenjBADdTR2ljiqoowBAHWU8yngUAPRKsNevX780//zzN+vYiyAvAphxxhknBzgtg70IaIqQbocddsjTU0Y322mnnZaDsgi6qrv8qsVtzj333PTnP/85nXHGGfk+Tj755OFuF5dFUBSBXkznecopp+QpQ0NM7Rk222yzHBKGRx55JG233XY5cDzrrLPSpptums4555xm933MMcekK664IodwcX+vvvpquuOOOzo07UEEZhHurbnmmjm4fOGFFyrXr7baaumxxx5rto7gQw89lL777ru06qqr5nBs++23T48//ng66KCD0pFHHpnuv//+HBiOSPxuBJItv1oGku+9914O4mINwFgfMYLEeE4KESr+61//ymFm3G6sscbKxytu19HjF+J3I/SN20Q4G9dHSDjjjDPm208xxRQ5rIzpSgtvvvlmDngPP/zwdMABB+TnMULG1nz//ff5saNj9LDDDkvHHXdc3u647Ntvvx3h8QKA3qSOUkcFdRQAqKOMRxmPAoBeW2MvRBdXdH1FiBQDVDE4sd566+XrIsS7/PLL8/cRKEXgstZaa1XCq+j6uvLKK3N3VYiutgjBLrroohziVIvuvksuuSQvkLztttvmy6IbL8KyCMGqbbDBBrlTK8R933XXXbmTMLrGIvALESLNOuuslcAwbhedcCFCpwivIszbcsst0yijjJKuvfbatPvuu+euwmK/l1lmmXaPTUxFGp1vxTp3iy66aO5YjK696CYMK620UjrqqKNyYLX22mvnyyIwjHB0sskmy8czpjC96qqrcoga4iyuFVZYYYTPTdznbLPNNtzlETLGc1GI0OvUU09Ns8wyS2U61X322SeHYrEW3zPPPJOPZ9HhGB0G8RxFkBYdmyM6fsW0n1NOOWU64ogj8vex5uBf/vKXHOoVQd24446b1l133Rx+xvEN8ZqKjr1iTcC433geXnnllcrzV7jlllvShx9+mG6//fbK7WO7ohMwjnmEuZRXRzpkWxPvTXESQPx+vJ4agX32PNerWr+2u/o+1B51VNvUUeooAGqvu+ofdZTxqGA8CoAy+KUHxn96Y3s6FewtuOCCudssBl8GDBiQu7+KrrxYOya6suK6CN/iq7juqaeeyreP6RIj9AsRoMX10Z3WUnQF/vTTT3k6y0LcfuWVV84dXdXiPis7079/mnTSSZt1xFWLcOqll17K4VuxHUVo+PPPP+dQKwqPOHjVQV4ETHGb6qlDW4rgaqKJJsoBVPH4ETJFt11MKRn3McEEE+TAL6agjGAvpuG877778nSSIcLPCM+KUC9MPvnkzfaxvecmArqW4rhVi/2beeaZKz9PMskk+d8iMI3Hjg7J119/PU+zGV/77rtvh49fEUJGIFn4zW9+k/+dffbZK5fFfhbBYiFCxCKkC9GBWXR/tgz24jU13XTT5dC22JZYZzAeN15Tgr1yq57yF6BeqKPUUeooAPqyvvz/MHWUOkodBUCj1T/dFuy1XB8mvi8Cl+gWi2AlApcIrKaZZpocuoSYxjE6xVrrKCs6vKoV0zO2vK4IiKpFYNYyyKpe761aBG5x9v8JJ5yQv1pbsy32IUQI1/Kx2wr24vH+7//+Ly9WXHSfVYsuwqJDL6bjjGk2oysxAqg4Vqusskplv1s7HtH5NyLRAVcdprVljDHGaNb5UAR/xTGLbr6YRjM64W677bY8nWZMExrddx05foUIcluKdRjb0/L5HXvssfP2Vod/hXhNxfPR2muqI8eBvq3otu2seB3H6zT+jhupY88+1z/Pc+//PccJL+2d0NMV6ih1lDoKgHr8f1hL6qjhGY8yHgVAfdc/3aWjdVSngr0YKI+zpGJqx3iACLGKYGjUUUfN10XoF51d0cFXHTpFOBVrqw23Af2H34TougtffPFFs7Anfh4ZRdgUU00W3WDVIoiMaR9DhHTRgVco1phrTUz9+cknn+S14aKLrFqs/xZTQxbBXnTxHXLIIemBBx7I3XpxnIowL7rnWtvHuCym6uwNEdbG1KjxFWsLRmB58cUX52k0Y428ER2/kdGy0zLCzwg+Wws74zUVoV4c8xGFvZRPvJ90NfyI96T4/UYK9uxz/fM89yvN+1B71FGtU0f9jzoKgFrrrvpHHTU841EjZjwKgFoYtQfGf3pje5rP09gBEd5F+BVrwRVTbRbi55jCMabSrA725p133hxODRw4MHdTFV833HBDnpaypZgqMoqeWDeuWsufO6J6Kspxxhknny3/0UcfNduOOHs61o6LMC+mvYzpKu++++7K78W0oI899libj3Hrrbfm4DLW+4uws/or1gWMLsaYtrTYhgjF7r333nT//ffnDr5CTIMZAWJMPVmI49Zb7aBDhgzJU5AW+x7r8MX0njHQFMFlR47fyIhpFaqDzb///e/53+qpSatfU7HGXkzdWWxHdI9ecMEF6dFHHx2p7QCAnqKOGp46Sh0FAOoo41HGowCg4zrVsVcMSB1//PF5TbXWgr1jjz02r1FXHezFh3OERNtss03aYYcdckderD0XnWyxLl9r3VixRlpMCRkJZQR9Mejz8ssvd/ps5piS7+mnn86B3VxzzZV23nnntMsuu+SQKrbrP//5T55+Mm4X3XYx9eRWW22Vzj333Mp6dFdffXUlmGzphx9+yFNt/uEPfxhuPbuw+uqr59DrpptuqqylF5ftuuuued+KNelCHLMIsfbYY4+0++6753Azuhyja21E3UfR7dZWABjTisbUqCMS+xfH4Oijj84dmbG+X3QWfvzxx5XtHNHxGxlx/Hbcccf8FY954okn5mM1wwwzDHfbddddN11++eVpyy23zK+r2J6rrroqPfjgg2nTTTcdqe0AgJ6ijmpOHaWOAgB1lPEo41EA0MPB3u9///scosR0h9NOO22z6yKAiWkTI0iqnj4xptu86KKL0kknnZSOO+64PFVnhECnnHJKs461ajHdYwSEl156aZ6SMbrcYirIJ598slPbu/XWW+eQLn4vOrkioDrzzDNzaHjdddflQGqJJZbIoVuEeiFCt1gP7sorr8yB2Yorrpi78aLzrqV77rknrx+48sort/r4U001VQ4Vb7nllrTbbrvlMG+ppZbK68fF4F6EmNXOOOOMdOSRR+YpPCNY/OMf/5i3JW7fnti2DTfcsNXrYo28CN86IsK0WD8vnqvoHoznKb5fdNFF8/UdOX5dFcFwBMBxXxFkRlgaHYOtieMWz09s68EHH5yGDRuWuwnPP//8Vjv8AKAvUEc1p45SRwGAOsp4VDAeBQAd168pFu7pY2Lqy9tvvz0tvvjizdbYi8Anzuw+66yzUj364IMP8vqFESQWaw9GuLnsssvmzrToYqRrogMx1gycZcyN09ijvu4w9nUzd+1tKd7OYkrZONuvkdbYs8/1z/Pcr3afG7PMMsKTa/oadZQ6qrupowAaRBf/H9aSOqp8jEf1HHUUQGPUP92lo3VUpzv2ekN0qg0ePDivwRcdd9EdGGvc3XHHHem8885L9Sw61KKzMDoZY7rTmK40Ohyj6w4AYETUUeooAKBr1FHqKAAogz4Z7IUI8GIKyP322y936f3ud7/L01TGtI/1KqbtjG7EmOYy1pmLaTvnnXfevHbcxBNPXOvNAwBKQh2ljgIA1FEdZTwKAMqlzwZ7sV7fOeeckxpNrL8XXwAAXaWOAgBQR3WG8SgAKI9Rar0BAAAAAAAAwIgJ9gAAAAAAAKAEBHsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAL9a70B0Juapn0mpQEDGuKgNzU1pSFDhqSBAwemfv361XpzAICSa6Q6qiep0RzTvs5r1PEEeuC9tQ7qqHr7fKin/bEvfZfnpgTPSyonHXsAAAAAAABQAoI9AAAAAAAAKAHBHgAAAAAAAJSAYA8AAAAAAABKQLAHAAAAAAAAJSDYAwAAAAAAgBIQ7AEAAAAAAEAJCPYAAAAAAACgBAR7AAAAAAAAUAKCPQAAAAAAACgBwR4AAAAAAACUgGAPAAAAAAAASkCwBwAAAAAAACUg2AMAAAAAAIASEOwBAAAAAABACQj2AAAAAAAAoAQEewAAAAAAAFACgj0AAAAAAAAoAcEeAAAAAAAAlIBgDwAAAAAAAEqgf603AHrDr7/+mv/94YcfUr9+/RrioDc1NaUff/wxfffdd/a5jnme/T3Xq1q/tr///vtmnx/QyBqxjqrn97d65Jg6nn1ZI74+1VFQn3VUvb2f1dP+2Je+y3PTNzX14b//jtZRgj0aQvyhhvfee6/WmwJAyT4/xhlnnFpvBtSUOgqArn5+qKNodOooAHqijurXFPEk1Llhw4alIUOGpDHGGCONMooZaAFoX5wZFUXUwIEDU//+zoOisamjAOgMdRSoowDo2TpKsAcAAAAAAAAloHUJAAAAAAAASkCwBwAAAAAAACUg2KMhXHPNNWmFFVZIc845Z9pwww3T888/n+rVDz/8kE499dS8v/PMM09ae+210+23354axU8//ZRWWWWVtN9++6V69/DDD6d11103v66XXXbZdP7556d6Xjb1l19+yfu4/PLL59f2H//4x/Tss8+menXvvfemBRZYoNll8fwOHjw4LbXUUmmuueZKW2yxRXrnnXdSPe/zV199lQ477LC0zDLL5Oc93sMfe+yxmm0j1KvO1kqvvfZa2nTTTfPf5dJLL50uuOCCXtvWejye9913X1p//fXz8YzP9KOOOip98803vba99VzLx+fmTDPN1KPbV+/H87///W/aa6+98mf0ggsumHbZZZf06aef9tr21uMxfeaZZ3ItG3/z8XtR40atCzRmzfTkk0+m9dZbL/8fb8UVV0w333xzKuu+xBhFfO5Wfy200EKpL9cLUXPF/zfvueee0j43HdmXWj03PVEX33333Wn11VfP97nmmmum+++/P/WWntifhRdeeLjnZp111ulz+/L444/nfZl77rnz711xxRWl/Zt5vAP7Usv3sw5pgjp30003Nc0888xNZ555ZtP999/ftNVWWzXNO++8TR999FFTPdpvv/2a5ptvvqYrrrii6ZFHHmk68sgjm37/+9833X777U2N4OSTT877u++++zbVsyeffLJp1llnbdp///2bHn300aZzzjkn/3zppZc21avzzjuvaZZZZsn/Pvzww02DBg1qmmuuuZree++9pnrzzDPPNM0zzzz5b7naGWec0TTnnHM2XX755U333HNP07rrrtu05JJLNn399ddN9bjPv/76a9Omm27atMQSS+T38oceeqhp9913z+/pzz//fE23Fxq5Vvrvf//btMgiizRtscUW+fZnnXVWfn++5JJLen3b6+F4Pv74400zzTRTruHife76669vWnjhhZu23XbbXt/2eqvlX3/99abZZpst14Z07Xj++OOPTauvvnrTKqus0nT33Xc33XHHHU0rrLBC09prr50/p+n8MX3//feb5p577qatt946/81ffPHF+XUa9TzQeDXTm2++mf9fu8ceezQ98MADTUcffXT+3Pr73/9eun0ZNmxY/v/q2Wef3fTcc89Vvl588cUe3Zeu7E8h/i+9ySabtHrMy/LcdGRfavXc9ERdHGNgcZ8x3hnPy1577ZXHw/75z3/26L701P58+umn+Tm74YYbmj03Ucf2pX15+eWXm2afffamvffeO483X3jhhfm4X3bZZaX7m3m5A/tSy/ezjhLsUdfiP5vLLLNM0xFHHFG57Keffmpadtllm4455pimevP555/nN8z4oKi2zTbbNG2wwQZN9S7emOM/yQsttFDdB3sbbrhh0w477NDsskMPPbRpu+22a6pXK6+8ctM+++zTbKBpgQUWaDr99NOb6kXs0/nnn58Hd2LfqkOuKNLj9X3RRRdVLvvqq69yGFZdfNTTPr/wwgv5PS0K98Ivv/ySBxgj4ANqUyuddtpp+T+k33//feWyU089NV8W/wFqZF05nvEf+z/96U/NLosTsuL97+23325qZCNTy8drMU6AiZNDBHtdP57XXXddrj8++eSTZieYxXF95513mhpdV45pnKQWA0Xfffdd5bLDDjusaemll+6VbQb6Vs0UA8vx/5vqkyUiqIgTKMq2L2+99Vb+zH3ttdeaylAvPPHEE3mcIf4f2lr4UJbnpiP7Uovnpqfq4o022mi4sa+4bKeddmoq4/5EABY/9+YJ213ZlxiPixO9YkymEIHlSiutVLq/mX06sC+1ej/rDFNxUtfef//99NFHH+VW58Joo42Wpwx46KGHUr359ttv85Quiy++eLPLp5tuunwc6tmwYcPSAQcckLbaaqs06aSTpnr2+eefp+eeey63lleL6QrPPffcVM/TrA4YMKDy8+ijj57GHnvsNHTo0FQvHnzwwTwV0z777JP+/Oc/N7vun//8Z/ruu++avZ8NHDgwT4lV5vez9va5X79+aYMNNkjzzjtv5bJRRhklTTPNNHX/ngZ9uVaK6XAXXXTRNOaYY1Yui2mSv/jii/Tyyy+nRtaV4xnTxWy88cbD1W6h0d/rRqaWv/TSS3Nt3PKzpZF15XjGVF5LLrlkmmyyySqXxZSc8fldvE4bWVeOadS0o446ahpjjDGa1XRDhgzplW0G+lbNFLeJ+4z/+1Tf5pVXXsn/9y/Tvrz++uv5fqaffvpUhnphp512Sr///e/ThRde2Or1ZXluOrIvtXhueqIujuWHYorF6vsMyy23XHrkkUd6dHmanqrz47mZcsop0zjjjJN6S1f2ZY899khnnHFGHpOp/p2oa8r2N7NHB/alVu9nnSHYo6699957+d+pp5662eVTTTVV/sOvt/XIYr8OP/zwNPnkk1cui7UaGuE/3jG3+88//5y23XbbVO/eeOON/G8U1LG/s88+e1psscXqfn2jKIZuvfXWXChEmBch5meffZZWXnnlVC/mmGOOvM5crFtQXQgV72dRdPz2t79tdnn8XLzX1ds+x2v7yCOPbDbwFXPRP/XUU326uIJ6r5XidyJgb3n78O6776ZG1pXjGQMxq6222nBrcYR6r996qpaP684888z8GRInAtH14xl1Z7wOTz/99DygG5/b8ZqNdffo2jGNtYAi2DvllFNymBcn7F1//fV5rSCgsWqmOHEz/k/b2n0WtylT/RcD4eONN17ae++903zzzZe/DjzwwB5fN7ir9cJVV12VP98mnHDC4a4r03Mzon2p1XPTE3XxBx98kE/sb+0+4zn797//ncpW58dzE2MeW2+9dV7vLdbbO+GEE/IYZ1/al2iimHHGGfP3X3/9dfrLX/6Sv6LBpGx/M5OOYF9q+X7WGf1rvQHQk4o/tuoun+Ln+CCIMz3GGmusun4SBg8enN5555203377pXr19ttv55AnzsxuhMGbL7/8Mv+71157pbXWWittscUW+cykk08+OX/otOzkqxfxAfvoo4+mzTffvHLZQQcdlOaff/5UL9rrNo33swhz+/fvP9z7WV8qLDqrsx22RxxxRO7A2GyzzXpsm6CRdKVWit9p7fbV99eouqP2fO2113In8yqrrDLcyRyNpivHM/7zHvVB1EhRI7z00ku9us31djyjE+PGG2/MgyPHHntsPrkqBpsGDRqUrrnmmuFOymk0XTmmMfAUMxUccsghlRPzisEioLFqpvbuM8T/e8pU/8VAeHxuxEmY0TEfNU2ETdFNE+M1fa3+ig63rtxnX3tuRrQvtXpueqIujpNh2rrP6scsU50fz82HH36Yx/K222679Mwzz6Szzz47n/xz9NFH97l9ifA0ZnMIccJXzLI0ovvsi38z7e1LLd/POkOwR10rUvm2/sNZ3XJbjy666KL8YRBnfSy11FKpHv3666/5P8HrrbdemmeeeVIjKM7aibbyCPfCIosskj799NP8fNdjsBd/y/E6jhA3ulLjzKYHHnggHXfccWn88cdPa6yxRqp37XUY1/t7WbH/UdRG1+ahhx6aZp555lpvEjR0rdSotVVP155vvvlmnlY8pj2Mz7tG15Xjee211+azc88555we375GOJ4xIBJfEUAVU0RNNNFE+cSyxx9/PNegjawrxzS68w4++OD0pz/9Ka200kq5hj/ttNNyWHreeec1/PsoNFLNNKL77KmTJ3qq/tttt93yrELFUgpxgk10kO2+++7/X3t3Ai5lVQZw/LhkWWGRaaFpmlsIiaVpbgGRIBoCipEoURRimppZIi5YiphioaDhlqiYkkagkSEgXaUozQUUK7csBWmxssUtsun5n54zz3fnztxNh5lv7v/3PMO9zHwz853vm+Xc8573PeGBBx5otsRCvY/95e3ctKUW56Ya/eJanZdq9vOZvEzG3q677losec5jkdl/wgknNCuHXg9tIUh23XXXxdKa9F8YgyTbLY/vmU0rtIXra/V51hFd+y9vNbxu3bqVnRXA/6mTmy3v1kj4ULvgggvibFpmFZA23Khmz54d1q5dG0466aTiwEM6Bun3RpNmoRxwwAHNrqccJwMDpJE3GmYscZk8eXLM3Nt7773jTOcjjjgiBnsI8HaFz7NXXnklltct/Txbn7XYa4E65wSxeb/zeTZq1Kha75LUpftKfOaU2z77eF3Va+l73nfffbHsNI8xa9asuOZWV9fR40mfcOrUqXHSF1nu9AXTH/v83hX6C6/365P1jCkLle1rsL4vFQRSefiurDPHlCAp68CwPjaB0eHDh8fSsSyfkMpzSeoafab02bq++1XV6v8x+bJ0sDuNW5D9kqexvzydm/aoxbmpRr+4tcfM3p6nfj5JCimol5BFRh+2Wn2t19IWKoVRLpQSo1SJoxTmHXfckcv3zGYV2lLLz7OOMLCnhpbqf1ODOYv/N+qaJQxYTJgwIVxzzTXh2GOPjbNBG9mSJUtiMIsZLb169YoX0qOZYcHvpLM3mlQ3urTedgpkNmJJJM4x+vTp0+x6OkCUJq3WIrz19nlGUO/ZZ59tdj2v8Ub9PANlEyhHcfvtt8cBMDI3JdW2r7TddtuV3R6N/HlUzb7n0qVLw9ixY8NWW20V10ipxszcrnA8WYeXP+JPPPHEYr+Q7H7w+2WXXRa6ss68Pul3lvY5+XuDSyP2OdfHMSUATbA0i/JPDD5RnUJS1+kzMWl3iy22qLgN989LWwhCzJs3Lzz88MMt/p4DlXbyNPaXp3PTllqdm2r0iykNTgZWucckwMM5q5ZqtId16Sh5zhJK9X5uaEcqhZotAUv/hbX18vSeWdpGW2r5edYRBvbU0PjQ6NGjR7jzzjuL1/GHaVNTU8OWjSFTj1J1rKlHenCjI32dL8HshfPev3//+PuWW24ZGg0LvNKuhQsXNrt+2bJlYaeddmrI7K3UASDdPeuhhx6KnYd6+VKtJoKYzDQimJ1Qc/3ee+9t2M8zkKlHG1lDkpJVkmrfV2JWI2u7vvTSS8Xr+GyiNMkuu+zSpU9RZ44n32VUHujdu3e44YYbYplDde54pv5f9kLJSPB7dt2Mrqgzr08qQlA14bnnnitex/ufwF5XKYP/eh9TBplK+7SPPPJIvN/WW29d9X2WVF99Ju7LIHM2q5xtevbsGbp3756btjDZg4xkytllLVq0KA6Wl05oqHV72iMv56YttTo31egXU5GB/kd2XAQ8B5WdqjnpqBrt2WSTTcKUKVNarNlG1hjjXIzx1UtbyDRkveXsMjGM1XC/tMZjXt4zs9poSy0/zzrCNfbU0Hgjjhs3Lpx77rkx2MGHPx+kDIaPGTMmNBoy1agNzB/gtHXFihXF2zbaaKM4E7TRsIhpKb7o+QJsxPaC2UnUej799NNjLe4DDzwwfmHxBTNt2rTQiOgEsaYga6uRoccX9/Lly8ONN94YZ+XzxdroCGBSWpcAV5pBf/nll8fSAYcffnhoRHTMFi9eHIYNGxZnt2U/06h53tUDCNL66is9/fTTceHw9AcM5XApjcuaA8w+TYvAUyKZ8nxdWWeOJ99tHDeyk5944okWAYCuXJKzo8eTAYPSQQOCUmjUfmG1X59cP3fu3JgxzzovlHyn3D/rd3tMO3dMjzvuuNiXnzRpUhg8eHCsTDF9+vQ4eEe/XlLX6jOx5taIESPi5wJ/1/F37m233RbLwuWtLfRl+D+VVgYOHBhWrVoV2zF69Og48F5P7WmPvJyb9qjFualWv5jXILfzPTpgwICwYMGCsHLlyjg+VE3Vag99LEpyE/SjGhmvMwJ9lJZn3KNe2kIb2FfGIocMGRJvp/9CiXb6hXl6z4xvR1tq9XnWIQWpC7j66qsLffv2Ley2226FkSNHFlasWFFoRDNmzCjsvPPOZS977LFHoas49NBDCxMmTCg0uvnz5xcOPvjgQq9evQoHHXRQ4dZbby00shdffLEwZcqUwn777Rffy5znuXPnFhrV9OnTW7xv161bV7jwwgsL++yzT2H33XcvjB07tvDkk08WGrXNp512WsXPNM6/pPXTV+I7lfdd1sqVK+N2vXv3LvTr1y/eXx0/nmvWrKn4Ocdl8eLFHtZOvD6zZs2a1ertXVFHj+dTTz1VGD9+fOx77LXXXoVJkyYVXnjhhRrseeMc04ULFxaGDh0a+/F8hnJMn3/++RrsuaR66DPdddddhSFDhsRtBg4cWJg3b15u28K4BG3hMfv371+YOXNm4dVXX63L9iTPPPNMxX5XXs5Ne9pSq3NTjX4x54HzwXlhbKCpqanq7ahWezgH1157bWHQoEGxPfycM2dOXbUl4TiPGDGi0KdPnzg2N3ny5BZ9wry8Z5ra0ZZafp61xwb8U+vgoiRJkiRJkiRJkqTWucaeJEmSJEmSJEmSlAMG9iRJkiRJkiRJkqQcMLAnSZIkSZIkSZIk5YCBPUmSJEmSJEmSJCkHDOxJkiRJkiRJkiRJOWBgT5IkSZIkSZIkScoBA3uSJEmSJEmSJElSDhjYk6QcGz16dNhll11Cv379QqFQKLvNz3/+87gNl9WrVze77d///nf4yEc+Em/75S9/Wfb+M2bMKN6/0uWGG26oSvskSZJq6bTTTivb9/nABz4Q+vbtG0455ZSwZs2auO0999wTDj300PCJT3wifOxjHwvXXnutJ0+SpDr/Ti+98H3elh/84Adx24cffjh0RatWrYrt32OPPcILL7xQ692pe+PGjQuzZ8/u0H3WrVsX+5JDhgwJu+++e+xbTpw4MfzpT39q8Vrktr322iuceeaZ4eWXX252+5IlS+Ltr7zySovnOOuss8KFF17YyVap1jau9Q5Ikl6bDTfcMKxduzbcf//9Yc8992xx+2233VbxvosWLYqdsO233z4G5z784Q9X3Pbqq68O3bp1K3vbe97znk7uvSRJUn1705veFK677rpm1/3jH/+Ik6KuueaaOKi3YMGC8KMf/Sh8+tOfDiNGjAg//OEPw1e+8pVw2GGHhc0226xm+y5Jkv7vuOOOC5/61KeKh+OWW24J3//+91uMdey4444esjbcfPPNYaeddgq//e1vw/z588NRRx3lMavgu9/9bgzGdfQYXXDBBWHOnDnhc5/7XNh7773jRDIm3i9fvjyO873tbW8LTz75ZDjjjDPCMcccEyedEajbfPPNw8knn1yczE/gjolob3zjG1s8B9cPGjQofPSjH42T/pUvBvYkKee22267OLjEgFJpYI8ZOQTvevXqFR555JEW9/3e974XZ/XQSbjkkkvCH//4x/Cud72r7PPwGO94xzuq1g5JkqR6nUTFTOlSDIK8+uqr4Tvf+U6skHDOOecU+18LFy6ME5/e+ta31mCPJUlSqW233TZekmXLlsWfjnV0DJPDGX8aP358nOR04403Gtir4O9//3v41re+Fc4///zYnyyXRXrvvfeGpUuXNrv++eefj5PvP//5zxeDdNhhhx3CkUceGebNmxc+85nPhJ/97GfhzW9+c/jSl74UNthgg/CLX/wi/PSnPy3eh6Bi9+7dwyGHHFJ2/97+9reHo48+OkyePDlOSuMxlB+W4pSknNtoo43C4MGD4wDSf/7zn2a30Tn473//Gw488MAW9/vd734XOxCk5A8bNixed9NNN623/ZYkScq7lI2XBkKYOU3G3hNPPBGuvPLKsoM4kiSpfmVLIPbp0yfsv//+4eyzzw5/+9vfWr3fM888EwMqTJzebbfdwhFHHBHuvvvuZtsw/jJp0qTwhS98IU4aIrOfZVWYrE3wZ+DAgaF3797hgx/8YMwuJEhTWv5z5cqVYezYsfH+PNfpp58e/vWvf7Uov8j9eZx99903fPnLXy6WDgdjR9/+9reLz9e/f/8wbdq0mOHVFioUENyjLYcffnjs8zDBqRSTn6666qo4XsXxYPupU6c2KxX57LPPhq9+9atxH9lXHo99zy4/Q4nzUhyHNKEq/Z/9J0jFc3F8weR1sthoH+2kdOhnP/vZ8NBDDzV7vEcffTRmdHI82Ybnve++++JtPG7Pnj3jvmb95je/ic/74x//uOKxuv7668PGG28cn78j/vnPf8YAHscuiyzJ1K7U/9xkk02K/dA3vOENcQwQvF5nzpwZg4etYTzw8ccfD3fccUeH9lG1518ZktQAWM+FL21S8rOYcfPxj388bLrppmWz9UjFp5O05ZZbxnViKEVRqSNH54DOX+mFzpokSVIjy/Z9GPD761//Gge2yNajegLlzBnUIqi36667xpnUzKqWJEn5csIJJ4SLLrooDBgwIAa/KHN4++23h1GjRrUIoCWrV6+Ogbxf/epXMdA2ffr00KNHj5jVRhWlrLlz58ZqSARdeC6CMmxHv4KflPn+2te+Fsd4uL00oHj88cfH4NPll18eS4AT8PvmN79ZvJ0+CNu8853vjNlirLtG2XAyvF566aW4DYE+2sZ40BVXXBGDSLNmzWqWHVYJY0kEPAkycYxoC9llpXhegmIEtWgrwUgyyDg++Mtf/hL7TQTQ2J/LLrss9qlo81133RU6ipKq6biMGTMmVlAg0EdWISUnOa6nnnpqeOyxx8KJJ54Y+3NpUtbIkSNjYJYg4MUXXxwDZOzvr3/963hewXHOYvyMtnMMKuE+TLTn8cr1KQnqlrtum222icFkskmzmNAPAor40Ic+FF8fBEMJ9jU1NcWqXLj00kvDfvvtFwOmreG5OJ+8bpQvluKUpAbAjKT3vve9sSNIWaiUus/sMDo1zKDKInhHHfSDDjoo1uUGHZk777wzdhQIFJaiQ1AOaf8PPvhgVdolSZJUay+++GKLgZVUvojZ5wxGMQGKQSJmoVP+/JOf/GTchsBfpTLnkiSpvpAh95Of/CRMnDgxBsLSWAhBLP5PAOvYY49tcT+CKASSyNBK3/v9+vWL66NNmTIlBn+otgTKdH/961+PmVxg/TWyrrguGyRijV/6FitWrGiW8cVabSkjjXXRKL9IYIdAEEEhgmlk87FPCeXBKddIgI9tyM4iwEYALLVxq622igEwyjtWGv8h0LVq1apw3nnnxf+z38OHD48ZjmS08Rh46qmnYlBr3Lhxcc3h9BwE01jXkAAp6xcTlGK9uJSJRnvILGTSOpPPO4IJVdnAJBl1nIsJEybE9edA0ItsQ9avYx933nnnGOCkwgL7k5afYcIWmWxM2iLAx76ngCmBWM41E+nJMOQYlMP6gxwTgmZZ5fqU2et4DZE5WIqsOtbLe9/73hcOPvjg4v3IeOQYs08csy9+8YsxWMnxZx8JnBL4JQtw6NChsbxnaclNxhQ5L5yfbBBS9c3AniQ1CGpm0wHgy5xMPAJ0DDjts88+LQJ7dPqYaU5ngJIPoLOxxRZbxI5qucAeHbVy68SkzqkkSVIjYmAtzUSnn8VAya233hoHephZnzAjXJIk5VcqKVk6JsK4CkErAk7lAnsEBAmObL755s2WSCFQx20EZd7//vfH6wgmpaAeqKBEUAlkXf3+97+PF7KvUFpViay0LDIDmVSUllzhMSg3mcW+pXXcyOID1Z2y+0ogkgAXE8QrBfbmzJkTJ3cfcMABxbEkJowzkYm19lIQj2VfUFpKkv1K+8Y2O+64YzGoB56f5+gMKiZkcbzpvxHIJKPy6aefjseHwG32uN5zzz0x4JeCeqnvl7LjQFlTgnpsS/CRwCjr56VsvnLIAExB1SwCaAlZigRKyWhMtt9++xaPRelQ+pyM9bFtNphI8JhjSnvYb3AeCAAzhkdwlWAfwUpeu7STgGRp1h7ZnGRRvvvd727lKKueGNiTpAZB/XdmGtH5GzRoUJz1RFmFcoE3SicgOxiV/PnPf44dC+qPZ5Hqn+3oSJIkdQUMMqWZ3thzzz3jgBwDY5QkZ00WSZKUfwRr+I4vN/bBROhKpTjJPCNzrlw2Fgi2pcAegbFSBJHoVxDQ43aCXSnAkso1JqVLrdBPSduksp0EGCthkjeoOlDOH/7wh4oVDBYsWBB/pkpRpQErymgSfEr7QTnQStgmZfi9HsodV0p/UsWKrEjWRWZcKx2/dMyodtXafqagJwFYJncR2KOtBMrInquEDLly5yvbp2QyPkG67HWlyLo744wzYvYhaxZSrrQUr4EU1CPjksxMsvQWL14c20m2KWODlAVlrLA0sJeOHa9/A3v5YWBPkhoEHQo6kZTjJCj3wAMPxPrgpegoMsuIGUcpfT+hJAGzkJjV9I1vfGM97r0kSVJ+UL6K/hRlrpjF39b6JZIkqf6xVAlZbAS/SoN7BOfIMCuHoBHjMSeddFLZ21k6pRLGbijrTZYg68SRPUWpRCZtkxnWEexHNniXxeORLcg2PD4ZduXKLqblWkox1kRgk5KhpVlltIG16djmsMMOC926dYvXkwGWLUlOEI2gE6VC2YbbS7FOIdlnbAPKnWdVCq6WYl3Ec845J2asjR49urgfBPvISkwq7QdtIuBFQJZgL+sBUsmKMTWyDSnn2Zru3bsXg2WdxVqNZPWxlh4/25psz4QzxvIIsJKtx8R92pcm/BNIJMhZivPSVkBY9WfDWu+AJOn1zdpjkeGbb745zvDq2bNni224jRk71NWmbnf2wowtBqfojJXrCEqSJOn/JZrOPffcOIAyadKkZqWsJElSPjEeArKaSkt0kslWbu0zcD3rmrHOG9lX6XL//ffHgAz9hUrYJlUA2HbbbYvrn6XSmaWBrbYmfJN9RqZW6dp4VGxiUhL7ypgQwZzsvr7lLW8JF110UVybrhzGkrbeeuswcuTIFmNJlIIkgJRKl1PaEosWLWr2GPPnz49jUQS7yHhj2RjWukvYL7LTyDYDwannnnuuWT+LNePag+AbmWysU5gNLqZSnCljj/1g22wAjtLr3C+VSAVlN1lLmX4fbaUEaWs4Vli7dm3oDCaP8dphQn52/b/WkElIu9Jaz7wWaFcqO0pQr1x2IvtIZqGBvXwxY0+SGghf+CymS33zcjPF6Ayx4C+zfZgFVg4p+aTu33LLLc1KdVKzPc26KsWMr9ZKEEiSJDUaBq2GDx8e+1bM4GagSpIk5Rdry1FmkgAXgS++6wnYzZgxI2bdHXnkkWXvR4YUgZ8xY8bEsocESBhXIQOPcZqUvVVOykwj0+roo48O69ati9lmrOcL1j5rLwJZZP9RWYCfQ4cOjRlul1xySZz8zbItBHD233//MGHChHDMMcfEoB6BHdpI4KpcWUiCfazzxhptKfBYOuGJdrLsy4MPPhgrGdBHov0g+PfYY4/F/SCjj3XnWKuYMpNpDThKnVLq8tFHH41jWmkdQAKcZ555Znw81shjCRoCfm3huN50000xa49lajgOBL5Y8xCUFAXPvWzZshic5HhwfK6//vpY0Yp9TCgbytqCTKbnPFFytDWUzORCIJKKWcmKFSuKv3M9l+x1ZIWyPh+BPe7Pc5HFmEVwrnTtvnSeeR2lDD32l/M1derUOA5IBugpp5zSYl9ZJ5rXfblzq/plYE+SGgizkOh4MtuI7L1SS5YsiSUGKpWHADW3Sc9nweLsAFVrg1XUG7/iiitehxZIkiTlx6mnnhpnfjP4Mnjw4OLsbEmSlD8ENsiSYl02svYITBGkIzBEBlelyc5k6jE5msAKgSSCcQSCGHtpa+IPGWOTJ0+OwSwCZ6msJ2MyBL0IupSuidYatiXwdeWVV8agFaU1CfAQ6Etrqc2cOTNeyMJjnxkDIvhGG3v06NHiMQnYYdiwYRWfl1KVbEfWHoG98847LwZDCdZxHHlcjgVtAoE8Am9k502ZMiUGNCl7ybYpc5Jg3po1a8LcuXPj+n6skUfgisduC/tK+VT2iSAp55FgHyVIR40aFY8r6+VRnpTrpk2bFiZOnBiDYn369AmzZ8+OwdCsAQMGxMAeQdz2INhJG8mYYy09kPHYGoKKy5cvj5l3BDLZ11JHHXVUzBzM4jVL1a7s+occY9ZupGwor2eeu/T5V69eHR5//PF47pUvGxRKV+CUJEmSJEmSJElSRFUrSlsSdG0Psj7JOjzrrLNi9mQ9ouoX2aWUSTVjL1/M2JMkSZIkSZIkScpgvT2yH8mea2pqir+3F5mQxx9/fLjqqqvCIYccEjbeuL5CMVT0ojzpxRdfbFAvhzas9Q5IkiRJkiRJkiTVE9bSI5vt7rvvDieffHLo27dvh+7Pmossm0OJ0npDGVTWPNx3331rvSvqBEtxSpIkSZIkSZIkSTlgxp4kSZIkSZIkSZKUAwb2JEmSJEmSJEmSpBwwsCdJkiRJkiRJkiTlgIE9SZIkSZIkSZIkKQcM7EmSJEmSJEmSJEk5YGBPkiRJkiRJkiRJygEDe5IkSZIkSZIkSVIOGNiTJEmSJEmSJEmScsDAniRJkiRJkiRJkhTq3/8AdOfToV9S2KUAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1800x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Best model: Weighted Avg Ensemble with R² = 0.8991\n"
     ]
    }
   ],
   "source": [
    "# Collect all individual + ensemble results\n",
    "all_results = {}\n",
    "for name in model_names:\n",
    "    m = regression_metrics(y_test, predictions_test[name])\n",
    "    m[\"tol_2pct\"] = tolerance_accuracy(y_test, predictions_test[name], 2.0)\n",
    "    all_results[name] = m\n",
    "\n",
    "if m_stack is not None:\n",
    "    all_results[\"Stacking Ensemble\"] = m_stack\n",
    "if m_wav is not None:\n",
    "    all_results[\"Weighted Avg Ensemble\"] = m_wav\n",
    "\n",
    "summary = build_summary_table(all_results).sort_values(\"R2\", ascending=False)\n",
    "display(summary.round(4))\n",
    "summary.to_csv(v3[\"results\"] / \"v3_ensemble_results.csv\")\n",
    "print(f\"Saved to {v3['results'] / 'v3_ensemble_results.csv'}\")\n",
    "\n",
    "# Bar chart comparison\n",
    "fig, axes = plt.subplots(1, 3, figsize=(18, 6))\n",
    "names = summary.index.tolist()\n",
    "colors = [\"gold\" if \"Ensemble\" in n else \"steelblue\" for n in names]\n",
    "\n",
    "axes[0].barh(names, summary[\"MAE\"], color=colors)\n",
    "axes[0].set_xlabel(\"MAE\"); axes[0].set_title(\"MAE (lower is better)\", fontweight=\"bold\")\n",
    "\n",
    "axes[1].barh(names, summary[\"R2\"], color=colors)\n",
    "axes[1].set_xlabel(\"R²\"); axes[1].set_title(\"R² (higher is better)\", fontweight=\"bold\")\n",
    "\n",
    "if \"tol_2pct\" in summary.columns:\n",
    "    axes[2].barh(names, summary[\"tol_2pct\"], color=colors)\n",
    "    axes[2].set_xlabel(\"Tolerance Accuracy (±2%)\")\n",
    "    axes[2].set_title(\"Tol. Acc (higher is better)\", fontweight=\"bold\")\n",
    "\n",
    "for ax in axes:\n",
    "    ax.grid(True, alpha=0.3, axis=\"x\")\n",
    "\n",
    "plt.suptitle(\"Individual Models vs Ensembles (v3)\", fontsize=14, fontweight=\"bold\")\n",
    "plt.tight_layout(); save_fig(fig, \"v3_ensemble_comparison\", directory=v3[\"figures\"]); plt.show()\n",
    "\n",
    "print(f\"\\nBest model: {summary.index[0]} with R² = {summary.iloc[0]['R2']:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82a9fe01",
   "metadata": {},
   "source": [
    "## 6. Actual vs Predicted — Best Ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ae439145",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-02-24T17:57:38.551321Z",
     "iopub.status.busy": "2026-02-24T17:57:38.551321Z",
     "iopub.status.idle": "2026-02-24T17:57:38.994075Z",
     "shell.execute_reply": "2026-02-24T17:57:38.994075Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ensemble predictions saved for evaluation.\n"
     ]
    }
   ],
   "source": [
    "# Pick the best ensemble\n",
    "if m_wav is not None and m_stack is not None:\n",
    "    best_name = \"Weighted Avg\" if m_wav[\"R2\"] > m_stack[\"R2\"] else \"Stacking\"\n",
    "    best_pred = y_wav if m_wav[\"R2\"] > m_stack[\"R2\"] else y_stack\n",
    "    best_metrics = m_wav if m_wav[\"R2\"] > m_stack[\"R2\"] else m_stack\n",
    "elif m_wav is not None:\n",
    "    best_name, best_pred, best_metrics = \"Weighted Avg\", y_wav, m_wav\n",
    "elif m_stack is not None:\n",
    "    best_name, best_pred, best_metrics = \"Stacking\", y_stack, m_stack\n",
    "else:\n",
    "    best_name = None\n",
    "\n",
    "if best_name:\n",
    "    fig, axes = plt.subplots(1, 2, figsize=(14, 6))\n",
    "    \n",
    "    axes[0].scatter(y_test, best_pred, s=8, alpha=0.4, c=\"steelblue\")\n",
    "    lims = [min(y_test.min(), best_pred.min()), max(y_test.max(), best_pred.max())]\n",
    "    axes[0].plot(lims, lims, \"r--\", linewidth=1.5)\n",
    "    axes[0].annotate(f\"R² = {best_metrics['R2']:.4f}\", xy=(0.05, 0.9),\n",
    "                     xycoords=\"axes fraction\", fontsize=12, fontweight=\"bold\",\n",
    "                     bbox=dict(boxstyle=\"round\", facecolor=\"lightyellow\"))\n",
    "    axes[0].set_xlabel(\"Actual SOH (%)\"); axes[0].set_ylabel(\"Predicted SOH (%)\")\n",
    "    axes[0].set_title(f\"{best_name} Ensemble — Actual vs Predicted (v3)\", fontweight=\"bold\")\n",
    "    axes[0].set_aspect(\"equal\"); axes[0].grid(True, alpha=0.3)\n",
    "    \n",
    "    residuals = y_test - best_pred\n",
    "    axes[1].hist(residuals, bins=50, color=\"steelblue\", alpha=0.7, edgecolor=\"white\")\n",
    "    axes[1].axvline(x=0, color=\"red\", linewidth=1.5)\n",
    "    axes[1].set_xlabel(\"Residual (Actual - Predicted)\")\n",
    "    axes[1].set_ylabel(\"Count\")\n",
    "    axes[1].set_title(\"Residual Distribution\", fontweight=\"bold\")\n",
    "    axes[1].grid(True, alpha=0.3)\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    save_fig(fig, \"v3_best_ensemble_prediction\", directory=v3[\"figures\"])\n",
    "    plt.show()\n",
    "\n",
    "    # Save ensemble predictions for NB09 CED\n",
    "    np.savez(\n",
    "        v3[\"results\"] / \"v3_ensemble_predictions.npz\",\n",
    "        y_test=y_test,\n",
    "        y_stack=y_stack if y_stack is not None else np.array([]),\n",
    "        y_wav=y_wav if y_wav is not None else np.array([]),\n",
    "        battery_ids_test=bids[test_mask],\n",
    "    )\n",
    "    print(f\"Ensemble predictions saved for evaluation.\")\n",
    "else:\n",
    "    print(\"No ensembles available — run NB04-07 first.\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.12.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}