guadaloop_lev_control/RL Testing/lev_PID.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# PID Control Testing for Maglev Pod\n",
        "\n",
        "This notebook provides a feedforward + PID control interface for the `LevPodEnv` simulation environment.\n",
        "\n",
        "## Control Architecture\n",
        "- **Feedforward**: `MaglevPredictor` estimates the equilibrium PWM needed to hover at the current gap height\n",
        "- **Height PID**: Corrects residual gap error → additive PWM correction for all coils\n",
        "- **Roll PID**: Corrects roll angle → differential left/right adjustment\n",
        "- **Pitch PID**: Corrects pitch angle → differential front/back adjustment\n",
        "\n",
        "The outputs combine: `coil_pwm = feedforward + height_correction ± roll_adjustment ± pitch_adjustment`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 91,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Target Gap Height: 11.86 mm\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from lev_pod_env import LevPodEnv, TARGET_GAP\n",
        "from pid_controller import PIDController, DEFAULT_GAINS\n",
        "from pid_simulation import run_pid_simulation, feedforward_pwm, build_feedforward_lut\n",
        "\n",
        "# Set plot style for better aesthetics\n",
        "plt.style.use('seaborn-v0_8-whitegrid')\n",
        "plt.rcParams['figure.facecolor'] = 'white'\n",
        "plt.rcParams['axes.facecolor'] = 'white'\n",
        "plt.rcParams['font.size'] = 11\n",
        "plt.rcParams['axes.titlesize'] = 14\n",
        "plt.rcParams['axes.labelsize'] = 12\n",
        "\n",
        "print(f\"Target Gap Height: {TARGET_GAP * 1000:.2f} mm\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## Load PID gains (JSON or defaults)\n",
        "\n",
        "Try to load `pid_best_params.json` (saved by Optuna in this folder). If missing, use `DEFAULT_GAINS`. You can override any value in the **PID Gains Configuration** cell below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 92,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Loaded PID gains from /Users/adipu/Documents/guadaloop_lev_control/RL Testing/pid_best_params.json\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "import json\n",
        "\n",
        "try:\n",
        "    import optuna_pid_tune as _optuna_tune\n",
        "    _best_path = os.path.join(os.path.dirname(os.path.abspath(_optuna_tune.__file__)), \"pid_best_params.json\")\n",
        "except Exception:\n",
        "    _best_path = \"pid_best_params.json\"\n",
        "\n",
        "if os.path.isfile(_best_path):\n",
        "    with open(_best_path) as f:\n",
        "        _best = json.load(f)\n",
        "    HEIGHT_KP = _best[\"height_kp\"]\n",
        "    HEIGHT_KI = _best[\"height_ki\"]\n",
        "    HEIGHT_KD = _best[\"height_kd\"]\n",
        "    ROLL_KP = _best[\"roll_kp\"]\n",
        "    ROLL_KI = _best[\"roll_ki\"]\n",
        "    ROLL_KD = _best[\"roll_kd\"]\n",
        "    PITCH_KP = _best[\"pitch_kp\"]\n",
        "    PITCH_KI = _best[\"pitch_ki\"]\n",
        "    PITCH_KD = _best[\"pitch_kd\"]\n",
        "    gains = dict(_best)\n",
        "    print(f\"Loaded PID gains from {_best_path}\")\n",
        "else:\n",
        "    HEIGHT_KP = DEFAULT_GAINS[\"height_kp\"]\n",
        "    HEIGHT_KI = DEFAULT_GAINS[\"height_ki\"]\n",
        "    HEIGHT_KD = DEFAULT_GAINS[\"height_kd\"]\n",
        "    ROLL_KP = DEFAULT_GAINS[\"roll_kp\"]\n",
        "    ROLL_KI = DEFAULT_GAINS[\"roll_ki\"]\n",
        "    ROLL_KD = DEFAULT_GAINS[\"roll_kd\"]\n",
        "    PITCH_KP = DEFAULT_GAINS[\"pitch_kp\"]\n",
        "    PITCH_KI = DEFAULT_GAINS[\"pitch_ki\"]\n",
        "    PITCH_KD = DEFAULT_GAINS[\"pitch_kd\"]\n",
        "    gains = dict(DEFAULT_GAINS)\n",
        "    print(\"Using DEFAULT_GAINS (no pid_best_params.json found). Run Optuna to save best params.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## PID Controller Class"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 93,
      "metadata": {},
      "outputs": [],
      "source": [
        "# PID controller and default gains live in pid_controller.py (imported above).\n",
        "# Override gains in the next cell; they are passed to run_pid_simulation via the gains dict."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## PID Gains Configuration (optional overrides)\n",
        "\n",
        "Constants are already set above from `pid_best_params.json` or defaults. To **override**, uncomment and edit a line in the cell below (e.g. `HEIGHT_KP = 50.0`) and re-run that cell; then run the simulation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 94,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "PID Gains (used by simulation):\n",
            "  Height: Kp=100.96239556037482, Ki=0.0, Kd=8.173809263716658\n",
            "  Roll:   Kp=0.600856607986966, Ki=0.0, Kd=-0.1\n",
            "  Pitch:  Kp=50.011470879925824, Ki=0, Kd=1.8990306608320433\n"
          ]
        }
      ],
      "source": [
        "# Optional manual overrides: set any constant below and re-run this cell to use it.\n",
        "# Otherwise the values from the \"Load PID gains\" cell (JSON or DEFAULT_GAINS) are used.\n",
        "# HEIGHT_KP = 50.0\n",
        "# HEIGHT_KI = 5.0\n",
        "# HEIGHT_KD = 10.0\n",
        "# ROLL_KP = 2.0\n",
        "# ROLL_KI = 0.5\n",
        "# ROLL_KD = 0.5\n",
        "# PITCH_KP = 2.0\n",
        "# PITCH_KI = 0.5\n",
        "# PITCH_KD = 0.5\n",
        "\n",
        "# Build gains dict from current constants (used by run_pid_simulation)\n",
        "gains = {\n",
        "    \"height_kp\": HEIGHT_KP, \"height_ki\": HEIGHT_KI, \"height_kd\": HEIGHT_KD,\n",
        "    \"roll_kp\": ROLL_KP, \"roll_ki\": ROLL_KI, \"roll_kd\": ROLL_KD,\n",
        "    \"pitch_kp\": PITCH_KP, \"pitch_ki\": PITCH_KI, \"pitch_kd\": PITCH_KD,\n",
        "}\n",
        "\n",
        "print(\"PID Gains (used by simulation):\")\n",
        "print(f\"  Height: Kp={HEIGHT_KP}, Ki={HEIGHT_KI}, Kd={HEIGHT_KD}\")\n",
        "print(f\"  Roll:   Kp={ROLL_KP}, Ki={ROLL_KI}, Kd={ROLL_KD}\")\n",
        "print(f\"  Pitch:  Kp={PITCH_KP}, Ki={PITCH_KI}, Kd={PITCH_KD}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 95,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Loading maglev model from /Users/adipu/Documents/guadaloop_lev_control/RL Testing/maglev_model.pkl...\n",
            "Model loaded. Degree: 6\n",
            "Force R2: 1.0000\n",
            "Torque R2: 0.9999\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/Users/adipu/Documents/guadaloop_lev_control/.venv/lib/python3.13/site-packages/sklearn/base.py:463: InconsistentVersionWarning: Trying to unpickle estimator PolynomialFeatures from version 1.7.2 when using version 1.8.0. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n",
            "/Users/adipu/Documents/guadaloop_lev_control/.venv/lib/python3.13/site-packages/sklearn/base.py:463: InconsistentVersionWarning: Trying to unpickle estimator LinearRegression from version 1.7.2 when using version 1.8.0. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Feedforward LUT ready. At target gap (11.86 mm): PWM = -0.0006\n"
          ]
        }
      ],
      "source": [
        "# ============================================================\n",
        "#           FEEDFORWARD USING MAGLEV PREDICTOR\n",
        "# ============================================================\n",
        "# Builds gap → equilibrium PWM LUT in pid_simulation (used by run_pid_simulation).\n",
        "build_feedforward_lut()\n",
        "print(f\"Feedforward LUT ready. At target gap ({TARGET_GAP*1000:.2f} mm): PWM = {feedforward_pwm(TARGET_GAP * 1000):.4f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## Simulation Runner"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 96,
      "metadata": {},
      "outputs": [],
      "source": [
        "# run_pid_simulation is imported from pid_simulation (see imports).\n",
        "# It accepts gains=... (dict with height_kp, height_ki, ...), plus initial_gap_mm, max_steps, etc.\n",
        "# The gains dict is built in the \"PID Gains Configuration\" cell above."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## Plotting Functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 97,
      "metadata": {},
      "outputs": [],
      "source": [
        "def plot_results(data: dict, title_suffix: str = \"\"):\n",
        "    \"\"\"\n",
        "    Create aesthetic plots of simulation results.\n",
        "    \n",
        "    Args:\n",
        "        data: Dictionary from run_pid_simulation()\n",
        "        title_suffix: Optional suffix for plot titles\n",
        "    \"\"\"\n",
        "    fig, axes = plt.subplots(2, 2, figsize=(14, 10))\n",
        "    fig.suptitle(f'PID Control Performance{title_suffix}', fontsize=16, fontweight='bold', y=1.02)\n",
        "    \n",
        "    target_gap_mm = TARGET_GAP * 1000\n",
        "    time = data['time']\n",
        "    \n",
        "    # Color palette\n",
        "    colors = {\n",
        "        'primary': '#2563eb',    # Blue\n",
        "        'secondary': '#7c3aed',  # Purple\n",
        "        'accent1': '#059669',    # Green\n",
        "        'accent2': '#dc2626',    # Red\n",
        "        'target': '#f59e0b',     # Orange\n",
        "        'grid': '#e5e7eb'\n",
        "    }\n",
        "    \n",
        "    # ========== Gap Height Plot ==========\n",
        "    ax1 = axes[0, 0]\n",
        "    ax1.plot(time, data['gap_avg'], color=colors['primary'], linewidth=2, label='Average Gap')\n",
        "    ax1.plot(time, data['gap_front'], color=colors['secondary'], linewidth=1, alpha=0.6, label='Front Yoke')\n",
        "    ax1.plot(time, data['gap_back'], color=colors['accent1'], linewidth=1, alpha=0.6, label='Back Yoke')\n",
        "    ax1.axhline(y=target_gap_mm, color=colors['target'], linestyle='--', linewidth=2, label=f'Target ({target_gap_mm:.1f}mm)')\n",
        "    \n",
        "    ax1.set_xlabel('Time (s)')\n",
        "    ax1.set_ylabel('Gap Height (mm)')\n",
        "    ax1.set_title('Gap Height Over Time', fontweight='bold')\n",
        "    ax1.legend(loc='best', framealpha=0.9)\n",
        "    ax1.set_ylim([0, 20])\n",
        "    ax1.grid(True, alpha=0.3)\n",
        "    \n",
        "    # Add settling info\n",
        "    final_error = abs(data['gap_avg'][-1] - target_gap_mm)\n",
        "    ax1.text(0.98, 0.02, f'Final error: {final_error:.2f}mm', \n",
        "             transform=ax1.transAxes, ha='right', va='bottom',\n",
        "             fontsize=10, bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))\n",
        "    \n",
        "    # ========== Roll Angle Plot ==========\n",
        "    ax2 = axes[0, 1]\n",
        "    ax2.plot(time, data['roll_deg'], color=colors['primary'], linewidth=2)\n",
        "    ax2.axhline(y=0, color=colors['target'], linestyle='--', linewidth=1.5, alpha=0.7)\n",
        "    ax2.fill_between(time, data['roll_deg'], 0, alpha=0.2, color=colors['primary'])\n",
        "    \n",
        "    ax2.set_xlabel('Time (s)')\n",
        "    ax2.set_ylabel('Roll Angle (degrees)')\n",
        "    ax2.set_title('Roll Angle Over Time', fontweight='bold')\n",
        "    ax2.grid(True, alpha=0.3)\n",
        "    \n",
        "    ax2.set_ylim([-4, 4])\n",
        "    \n",
        "    # ========== Pitch Angle Plot ==========\n",
        "    ax3 = axes[1, 0]\n",
        "    ax3.plot(time, data['pitch_deg'], color=colors['secondary'], linewidth=2)\n",
        "    ax3.axhline(y=0, color=colors['target'], linestyle='--', linewidth=1.5, alpha=0.7)\n",
        "    ax3.fill_between(time, data['pitch_deg'], 0, alpha=0.2, color=colors['secondary'])\n",
        "    \n",
        "    ax3.set_xlabel('Time (s)')\n",
        "    ax3.set_ylabel('Pitch Angle (degrees)')\n",
        "    ax3.set_title('Pitch Angle Over Time', fontweight='bold')\n",
        "    ax3.grid(True, alpha=0.3)\n",
        "    \n",
        "    ax3.set_ylim([-6, 6])\n",
        "    \n",
        "    # ========== Current Draw Plot ==========\n",
        "    ax4 = axes[1, 1]\n",
        "    ax4.plot(time, data['current_FL'], linewidth=1.5, label='Front Left', alpha=0.8)\n",
        "    ax4.plot(time, data['current_FR'], linewidth=1.5, label='Front Right', alpha=0.8)\n",
        "    ax4.plot(time, data['current_BL'], linewidth=1.5, label='Back Left', alpha=0.8)\n",
        "    ax4.plot(time, data['current_BR'], linewidth=1.5, label='Back Right', alpha=0.8)\n",
        "    ax4.plot(time, data['current_total'], color='black', linewidth=2, label='Total', linestyle='--')\n",
        "    \n",
        "    ax4.set_xlabel('Time (s)')\n",
        "    ax4.set_ylabel('Current (A)')\n",
        "    ax4.set_title('Coil Current Draw Over Time', fontweight='bold')\n",
        "    ax4.legend(loc='best', framealpha=0.9, ncol=2)\n",
        "    ax4.grid(True, alpha=0.3)\n",
        "    \n",
        "    # Add average power info\n",
        "    avg_total_current = np.mean(data['current_total'])\n",
        "    ax4.text(0.98, 0.98, f'Avg total: {avg_total_current:.2f}A', \n",
        "             transform=ax4.transAxes, ha='right', va='top',\n",
        "             fontsize=10, bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))\n",
        "    \n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "    \n",
        "    return fig\n",
        "\n",
        "\n",
        "def show_current_slice(data: dict, t_start: float, t_end: float):\n",
        "    \"\"\"\n",
        "    Plot coil current draw over a time slice (same as bottom-right graph in plot_results()).\n",
        "\n",
        "    Args:\n",
        "        data: Dictionary from run_pid_simulation()\n",
        "        t_start: Start time in seconds (inclusive)\n",
        "        t_end: End time in seconds (inclusive)\n",
        "    \"\"\"\n",
        "    time = np.asarray(data['time'])\n",
        "    mask = (time >= t_start) & (time <= t_end)\n",
        "    if not np.any(mask):\n",
        "        print(f'No data in range [{t_start}, {t_end}] s.')\n",
        "        return\n",
        "    t = time[mask]\n",
        "    fig, ax = plt.subplots(figsize=(10, 4))\n",
        "    ax.plot(t, np.asarray(data['current_FL'])[mask], linewidth=1.5, label='Front Left', alpha=0.8)\n",
        "    ax.plot(t, np.asarray(data['current_FR'])[mask], linewidth=1.5, label='Front Right', alpha=0.8)\n",
        "    ax.plot(t, np.asarray(data['current_BL'])[mask], linewidth=1.5, label='Back Left', alpha=0.8)\n",
        "    ax.plot(t, np.asarray(data['current_BR'])[mask], linewidth=1.5, label='Back Right', alpha=0.8)\n",
        "    ax.plot(t, np.asarray(data['current_total'])[mask], color='black', linewidth=2, label='Total', linestyle='--')\n",
        "    ax.set_xlabel('Time (s)')\n",
        "    ax.set_ylabel('Current (A)')\n",
        "    ax.set_title(f'Coil Current Draw ({t_start}–{t_end} s)', fontweight='bold')\n",
        "    ax.legend(loc='best', framealpha=0.9, ncol=2)\n",
        "    ax.grid(True, alpha=0.3)\n",
        "    avg_total = np.mean(np.asarray(data['current_total'])[mask])\n",
        "    ax.text(0.98, 0.98, f'Avg total: {avg_total:.2f}A', transform=ax.transAxes, ha='right', va='top',\n",
        "             fontsize=10, bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "    return fig"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 98,
      "metadata": {},
      "outputs": [],
      "source": [
        "def plot_control_signals(data: dict):\n",
        "    \"\"\"\n",
        "    Plot the PWM control signals sent to each coil.\n",
        "    \n",
        "    Args:\n",
        "        data: Dictionary from run_pid_simulation()\n",
        "    \"\"\"\n",
        "    fig, ax = plt.subplots(figsize=(12, 5))\n",
        "    \n",
        "    time = data['time']\n",
        "    \n",
        "    ax.plot(time, data['pwm_FL'], label='Front Left', linewidth=1.5, alpha=0.8)\n",
        "    ax.plot(time, data['pwm_FR'], label='Front Right', linewidth=1.5, alpha=0.8)\n",
        "    ax.plot(time, data['pwm_BL'], label='Back Left', linewidth=1.5, alpha=0.8)\n",
        "    ax.plot(time, data['pwm_BR'], label='Back Right', linewidth=1.5, alpha=0.8)\n",
        "    \n",
        "    if 'ff_pwm' in data and len(data.get('ff_pwm', [])) > 0:\n",
        "        ff = data['ff_pwm'] if isinstance(data['ff_pwm'], np.ndarray) else np.array(data['ff_pwm'])\n",
        "        ax.plot(time, ff, label='Feedforward', color='black', linewidth=2, linestyle='-.', alpha=0.7)\n",
        "    \n",
        "    ax.axhline(y=0, color='gray', linestyle='-', linewidth=0.5)\n",
        "    ax.axhline(y=1, color='red', linestyle='--', linewidth=1, alpha=0.5, label='Saturation')\n",
        "    ax.axhline(y=-1, color='red', linestyle='--', linewidth=1, alpha=0.5)\n",
        "    \n",
        "    ax.set_xlabel('Time (s)')\n",
        "    ax.set_ylabel('PWM Duty Cycle')\n",
        "    ax.set_title('Control Signals (PWM)', fontsize=14, fontweight='bold')\n",
        "    ax.legend(loc='best', framealpha=0.9)\n",
        "    ax.set_ylim([-1.2, 1.2])\n",
        "    ax.grid(True, alpha=0.3)\n",
        "    \n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "    \n",
        "    return fig"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## Run Simulation\n",
        "\n",
        "**Configure the simulation parameters below and run the cell.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Loading maglev model from /Users/adipu/Documents/guadaloop_lev_control/RL Testing/maglev_model.pkl...\n",
            "Model loaded. Degree: 6\n",
            "Force R2: 1.0000\n",
            "Torque R2: 0.9999\n",
            "Starting simulation: initial_gap=9.0mm, target=11.86mm\n",
            "  Impulse disturbance: -2N at step 5000\n",
            "  Feedforward: enabled\n",
            "  Applied -2N impulse and 1.00 N·m torque at step 5000\n",
            "Simulation complete: 10000 steps, 41.66s\n",
            "  Final gap: 10.88mm (target: 11.86mm)\n",
            "  Final roll: 0.000°, pitch: 0.003°\n"
          ]
        }
      ],
      "source": [
        "# ============================================================\n",
        "#               SIMULATION PARAMETERS\n",
        "# ============================================================\n",
        "\n",
        "INITIAL_GAP_MM = 9.0     # Starting gap height (mm). Target is ~11.86mm\n",
        "MAX_STEPS = 10000          # Simulation steps (240 steps = 1 second)\n",
        "USE_GUI = False           # PyBullet GUI often hangs in notebooks; keep False. Use recording instead.\n",
        "USE_FEEDFORWARD = True    # Use MaglevPredictor feedforward for base PWM\n",
        "\n",
        "# Recording (headless: no GUI window; files saved to RECORD_DIR)\n",
        "RECORD_VIDEO = False      # Set True to save MP4 of each run (e.g. recordings/sim_YYYYMMDD_HHMMSS.mp4)\n",
        "RECORD_TELEMETRY = False  # Set True to save 4-panel telemetry PNG per run\n",
        "RECORD_DIR = \"recordings\" # Output folder for video and telemetry (created if missing)\n",
        "\n",
        "# Impulse disturbance (one-time force at a specific step)\n",
        "DISTURBANCE_STEP = 5000   # Step at which to apply impulse (e.g., 500). None = disabled\n",
        "DISTURBANCE_FORCE = -2   # Impulse force in Newtons (positive = upward push)\n",
        "\n",
        "# Stochastic disturbance (continuous random noise each step)\n",
        "DISTURBANCE_FORCE_STD = 0  # Std dev of random force noise (Newtons). 0 = disabled\n",
        "\n",
        "# ============================================================\n",
        "\n",
        "# Run simulation (gains from \"PID Gains Configuration\" cell)\n",
        "results = run_pid_simulation(\n",
        "    initial_gap_mm=INITIAL_GAP_MM,\n",
        "    max_steps=MAX_STEPS,\n",
        "    use_gui=USE_GUI,\n",
        "    disturbance_step=DISTURBANCE_STEP,\n",
        "    disturbance_force=DISTURBANCE_FORCE,\n",
        "    disturbance_force_std=DISTURBANCE_FORCE_STD,\n",
        "    use_feedforward=USE_FEEDFORWARD,\n",
        "    record_video=RECORD_VIDEO,\n",
        "    record_telemetry=RECORD_TELEMETRY,\n",
        "    record_dir=RECORD_DIR,\n",
        "    gains=gains,\n",
        "    verbose=True\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 100,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'time': array([0.00000000e+00, 4.16666667e-03, 8.33333333e-03, ...,\n",
            "       4.16541667e+01, 4.16583333e+01, 4.16625000e+01], shape=(10000,)), 'gap_front': array([ 9.        ,  9.02630146,  9.07173494, ..., 10.87328199,\n",
            "       10.88719472, 10.87328123], shape=(10000,)), 'gap_back': array([ 9.        ,  9.02630146,  9.07173494, ..., 10.88719405,\n",
            "       10.87328088, 10.88719392], shape=(10000,)), 'gap_avg': array([ 9.        ,  9.02630146,  9.07173494, ..., 10.88023802,\n",
            "       10.8802378 , 10.88023758], shape=(10000,)), 'roll_deg': array([-0.00000000e+00, -5.27915552e-06, -2.13414205e-05, ...,\n",
            "        1.30520451e-05,  1.30545699e-05,  1.30514835e-05], shape=(10000,)), 'pitch_deg': array([ 0.        ,  0.        ,  0.        , ...,  0.00316562,\n",
            "       -0.00316602,  0.00316576], shape=(10000,)), 'current_FL': array([10.2       ,  9.29838848,  8.99919415, ..., 10.2       ,\n",
            "       -3.9745388 , 10.2       ], shape=(10000,)), 'current_FR': array([10.2       ,  9.29830265,  8.9989996 , ..., 10.2       ,\n",
            "       -3.97454548, 10.2       ], shape=(10000,)), 'current_BL': array([10.2       ,  9.29838848,  8.99919415, ..., -3.97448826,\n",
            "       10.2       , -3.97456455], shape=(10000,)), 'current_BR': array([10.2       ,  9.29830265,  8.9989996 , ..., -3.97449398,\n",
            "       10.2       , -3.97457027], shape=(10000,)), 'current_total': array([40.8       , 37.19338226, 35.99638748, ..., 28.34898376,\n",
            "       28.34908295, 28.34913635], shape=(10000,)), 'pwm_FL': array([0.95018876, 0.8899194 , 0.83739257, ..., 0.4259686 , 0.22627316,\n",
            "       0.42596516], shape=(10000,), dtype=float32), 'pwm_FR': array([0.95018876, 0.8899151 , 0.83737934, ..., 0.4259683 , 0.22627287,\n",
            "       0.42596486], shape=(10000,), dtype=float32), 'pwm_BL': array([0.95018876, 0.8899194 , 0.83739257, ..., 0.22627567, 0.42596382,\n",
            "       0.22627184], shape=(10000,), dtype=float32), 'pwm_BR': array([0.95018876, 0.8899151 , 0.83737934, ..., 0.22627537, 0.42596352,\n",
            "       0.22627154], shape=(10000,), dtype=float32), 'ff_pwm': array([0.66143623, 0.65541619, 0.64500579, ..., 0.22719919, 0.22719919,\n",
            "       0.22719919], shape=(10000,))}\n"
          ]
        }
      ],
      "source": [
        "print(results)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## View Results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 101,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1400x1000 with 4 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x400 with 1 Axes>"
            ]
          },
          "execution_count": 101,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Plot main performance metrics\n",
        "plot_results(results)\n",
        "show_current_slice(results, 20, 25)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 102,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1200x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABKMAAAHmCAYAAACvV01pAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAftZJREFUeJzt3Qd4U2X7x/E76WbvvTeyZG9kuEBQcaKCIKj4d6AgKIogjpfxKjjAwYsgIrhAREUUFUVFBASRjSBL9qYFupv8r/spiUmbls6sfj/XlasZJydPTnLS9Nf7uY/FbrfbBQAAAAAAAPACqzceBAAAAAAAAFCEUQAAAAAAAPAawigAAAAAAAB4DWEUAAAAAAAAvIYwCgAAAAAAAF5DGAUAAAAAAACvIYwCAAAAAACA1xBGAQAAAAAAwGsIowAAAAAAAOA1hFEAAMBNcnKyLFiwQO6++25p27atNG7cWDp16iQPPvig/PLLLz7bWgcOHJDz58/n2/oHDBgg9evXN6esOHXqlEyePFmuu+46ad68udlO3bp1k8cff1w2bdqUbvnu3bubdetPfzR69Gjn8z948GCer3/cuHFm3d9++625PG3aNOfjOU4NGjSQJk2amPfbww8/LDt27HDe//rrr3cuEx0d7bbuqVOnuq3j9OnTbrf/5z//cd7+66+/ypo1a9I99rFjx9zuc/jw4XTL6P3Uiy++aC5//vnneb6dAAAoCAijAACA08mTJ+WOO+6QZ555xvzhffbsWUlKSpITJ07I8uXL5d577zV/iHuTjmHixInSs2dPc94f7N+/X/r06SOzZ8+Wv//+W2JjY8120gBjyZIlcvvtt5ufSKXhnAacFStWlB49emS4Wex2uyQmJpr323fffSd33nmnbNu2zdzWqlUr5zIbN250u9+qVavc1rF27Vq32//880/zMzQ01ASHnvz222+ZXnal+4jFYjFhZNpgDAAAXBphFAAAMDRM0eonR1XPLbfcYgKEpUuXyrPPPivFixc317///vvy2WefeW2r6R/8c+bMMePzF5MmTTKVUSEhIaYS6osvvjDbaezYsRIWFiY2m81sMw2pHD7++GP56aefzM+CRqugdJvceuutZpul9eqrr5pto4HnJ598YirM1IULF+Tll192C6OUaxgVExMjW7dudVufaxil4db27dvN+csuu0wKFSrkcYyugdalwqjatWtLu3btzHvgnXfeueTzBwAA7gijAACAoQGT4498nbKmU5uaNm1q/vDWCpXXXnvNuaU+/fRTr201rXTxN47pWvXq1ZP777/fTNnS7dS/f38TuCidUrh582bnfcqWLSsVKlQwPwuSXbt2yc8//2zOa3WbJ6VKlTLbpkqVKtKsWTMTTpUoUcK5rVNSUqRly5bpKp3U6tWrTdClihQpki6M0qDKEWS6BloOlStX9hg+6XqVjsmTa6+91vzU8CwuLi5L2wIAAKQijAIAAIaj2slqtcr//d//pdsq7du3N1VKOv1Mq6NcafXJrFmzpG/fvmYalJ50qtrChQvThUmO3kw33XST6dPzxBNPmN5UGkJonyrXfkvaX8m1CkuneDl6Li1atMjZy+eHH34wU6e0b1OXLl3MdMPsjis7wsPDzU+tuJkyZYocOXLErfeSBht6cp0SllHPKO1vpP2UOnbsaLbBXXfdZcIWRw8n1+Vd+yydOXPGBIRaRaTPW6cNLl68ON1YN2zYIA888IB07tzZLNemTRuzrTwt64nj/vr6a2VRixYtTOCW1UBSK8ZUrVq1zCkrIiMjpXr16s4eZrqNypcvL1WrVjXXacjneP0cFU1a8aTPS+nUSUffKNcqqtatW6d7LH3vqePHj5vgzHF/nSqodHt5ou9FnaqnU0eXLVuWpecFAABShV78CQAACjD9g99RxVOtWjUpXbq0x+VuvPHGdNfpVCoNmNJOldJARU9aFfPKK6+km56lf8RrMOQa5GgVzD333GPCJce0wKx48sknzXQtVaZMGXPK6biyonfv3s5A7n//+5851a1b10zd6tq1qwlusrLec+fOmQBl3759zuvWrVtnQrmaNWtmel9t8K3LOuzcudNsBw1t9PGVBnsDBw6UhIQE53La4+iPP/4wp4xeUwe9v25D1ymSul31ej3pNtfXKzMrV640PzPq1eSJVho5ton2eXK8F7SySRvZ63PYs2ePqUZzVDTpbRpEzpw50wRV+l7SSixHFZWGrK7VVQ4aAH711VdmG2mwpa+jY50aiuntGnympRVuWlWlzd71OWa2HQEAgDsqowAAgAkVHIFDyZIls7VFtFrKEfjokeX0D/ePPvrIVPoorRrR6qS0Dh06ZKZizZ8/3xyVTI+C5pje5jjimvZXckyHclz21HNJx/7WW2+Z9Tz99NO5GldWaJ+oDh06uF2nVTUaUA0ZMsSEII6wJzManDhCFx2XVmzpGPWIcq5HkvNEH0+ns+nzuOGGG5zXuwYnuq00ZNHtrM3Wv//+exPAaTCjNPTLjG5P3bZadaS9kfT+H3zwgQlsNCT65ptvnFPkPNHH3rJlizmf2VEKtYrp6NGjJmjSgE2DNkdjcD2ynqMSLe1UPQ0yHdtPX4/LL79coqKi3KbqOSqjdMyeAk5dt95POUIox0+93vHYnjieU9qG6QAAIHNURgEAANOTxyE709c0OHJM99L+SS+99JKzImj69Oly9dVXm+lOGtJob6W09Mh8OnVM6dTARx991Jx3TLPT6hNHuKC04slTzyUNrFyns+V2XJeiY3KEOxr+aH8h12blerQ9PfKgTjF0TDfzRBt2O9Y3depUZ58knX6nz8e1oiktnTrn6MGkU/o0OHLddkr7fmm1lAY7OsVNgyW9XXsraQB5qSPBOcaj49DnqOPUoOzDDz+UiIiITIMax1gcYVW5cuUyXO6xxx7zeL0Go/rcPE2zS3tEPa0G0/FoYKWVShoQ6dQ7PcJh2vumpVPxtJJK76PP1REuZTRFz8HxnPS9pPtQTqrsAAAoiKiMAgAApmLEUS2jRwjLSNoqGK1KcQQm2nvH9Y9xraZxVJxoKODo4eOqTp06bk2sXacNZodWveTluLJC+wVdddVVpiJLwwut8NJAzTHFUaezaWiTGa0EUjolzxH8OEK3GjVqZHpfnaLmuu10PJ62nU5nmzt3rtx8880mqOnXr59zSmNmVU1Kp+hpnygNWrQySvtZ6To0wJs3b54J/TLj+l5yNBfPjL5O+vroVFHtKaZ9qVynK+o20W3jqIxy9IvSbe6oUnJUrGnfpx9//NF5X0/Ny9P2jdLXTCu/dPqk6/UZcTwn3Y7awwsAAGQNlVEAAMBUlDRs2NBMa9MeOFrpkbYCSUMODV90Op3+1LBAp2plxrXKyhGWuNKePA6OMCwnihYt6nY5t+PKzPr16810Og2yNNjRbREWFmbCDj3plDnH1MLdu3dnui69n4ZmOWmm7rrtHNvPtcJNvf3222ZaniNYefDBB00PJK2W0ubxl6IBmT7Xn376yQQ7Grpp0OfoOaXTABcsWCDFihW75Loye301LLtU8OOgYZhOTdSwSV8DR1WU43V09MtSrtMwM6uM0m2i2zM+Pl5mzJhhrtPLejTJf/75J0vjutR7DgAA/IvKKAAAYDj6Dmkwor2M0tIqFZ3ypH2G9Ih6jsPeO6Zq6TQn10obnbbmmEpVoUKFbPei8hQWZRTapA0C8nNcOgadmqdTwTRESTsm1/Feqgm74+hwGvBoQ3cHDVn27t0ruaHByhtvvOHsu6Rj1al9GspoBVBW6Bg0iNKG4i+88IIJgbSf0n333ecct96eEddG+Fl9zEtxVDhp8OaoRnINoDRUdbymOl0ybUWVJ659oxzr1Ibrl5qG6Kgw04qu7DTcBwCgoCOMAgAAhlb5OKY6vffeezJ+/HhTKaWNsvVocdp/yHx5sFrloYceck5TclQB6dHcRo0aJdu2bTNTqB555BFTYaX69++f463sGgjoEdwcR/3LTH6OSytzHNMCtVJo5MiRsmHDBhN8aA8oXb+Da/N1T7SxutKwR5ui6/bWBt66jsTERMkN7Q/lWIc2Q//999/Nz6eeeso5ve5S0yGfe+45M/VQn+OcOXNM+KRBmWtVVWYVQdpTyVHB5ejdlFueptu5NpPXMFCPaugqs6ooh7T9oS7VL0o5KrN0ymR2K+wAACjIqCcGAACGNqTWKUpDhw6Vv/76y/Q7StvzSIOoMWPGuB3V7JlnnjEhh4Y+WjHlqJpyuOaaa2Tw4ME53sqOo+ypESNGmCbaGipdSn6NS0OHl19+WQYOHGiqmTytW+k0xiuvvDLTdd15552mykr7OmmllZ6UTnvTaZKO0CynUxc1pNG+StpI3FPw5trs3BMNrvR5arXQxIkTzcmV9pPq0aNHptMQdaqbhnb6OuQFfT9o2OgI1LTqqVKlSm7LaKXU119/naV+UQ5ppwlmJYxyHPFQq6gAAEDWURkFAACcKlasaHoEjR071vyBrX/0a+VL+fLlpXfv3qZHUNpQQ6cn6RS+J554Qho1amQaUGtgpH149Gh5emS43BxlTKcP9unTx0z50vVq03OdgnYp+TkuDUQ0gBoyZIg5Wp+uV4MXDZC6du0qr776arrgxpPChQubRuAaXGl/Jq0i6tixo2mG7jhS26WmimVmypQpcssttziPSlirVi3TN8pR2ab9kDLra6WVcvp+0NdcQx9dh4aW+hrolD89GuGlxueoWtKj8eUFDURdwx/XKXppHzM7lVEamjmquPR56uXMaOP7I0eOmPNXXHFFlscPAABELPacdMwEAABArmkzdJ1KpyGgVve4BjtauaXT4rSXkYaAgUoDG62e0h5P2nPqUkcJDBRLly6V4cOHm6BvxYoVNDAHACAbqIwCAADwYaAxaNAgEzwNGzbMVCnplL3Zs2ebIEo1adIkoF8fDdq6dOlizmtoEyy++eYb8/Pmm28miAIAIJuojAIAAPAR7c112223ZTjtUKdJLl682HnUvUClzeM1tNFpgl999ZUEOm1c3r17dzMVVKu99HUCAABZR2UUAACAj2hPJm0S37NnT6lQoYLpO6UnrSbSXlkLFiwI+CDK0ei8b9++8vfff8svv/wigU77fOnRCnWaHkEUAADZR2UUAAAAAAAAvIbKKAAAAAAAAHhNqPceyn8lJydLdHS0OVSxHi4YAAAAAAAAWWez2SQhIcH0VAwNzTxuIowSMUGU44g1AAAAAAAAyJkaNWpI6dKlM12GMErEVEQ5NlhUVJQEKrvdLufPnzeNNC0Wi6+HAyCH2JeBwMd+DAQH9mUg8LEfe09cXJwp9HFkLJkhjNLGWRen5mkQVahQIQnknUyP7KLPgTAKCFzsy0DgYz8GggP7MhD42I+9Lyvtj2iQBAAAAAAAAK8hjAIAAAAAAIDXEEYBAAAAAADAawijAAAAAAAA4DWEUQAAAAAAAPAawigAAAAAAAB4DWEUAAAAAAAAvIYwCgAAAAAAAF5DGAUAAAAAAACvIYwCAAAAAACA1xBGAQAAAAAAwGsIowAAAAAAAOA1hFEAAAAAAADwGsIoAAAAAAAAeA1hFAAAAAAAALyGMAoAAAAAAABeQxgFAAAAAAAAryGMAgAAAAAAgNcQRgEAAAAAAMBrCKMAAAAAAADgNYRRAAAAAAAA8BrCKAAAAAAAAHgNYRQAAAAAAAC8hjAKAAAAAAAAXkMYBQAAAAAAAK8hjAIAAAAAAIDXEEYBAAAAAADAawIujJoxY4YMGDAg02XOnDkjjz/+uLRu3VratGkjzz33nMTFxXltjAAAAAAAAPAsVALI/Pnz5dVXX5VWrVplutywYcNM+DRnzhyJiYmRMWPGSGxsrEyePNlrYwUAAAAAAECAhlHHjh2TZ599VtasWSM1atTIdNkNGzbI2rVrZenSpVK7dm1z3fPPPy/33nuvjBgxQsqXL++lUQMAAAAAACAgw6itW7dKWFiYfPHFF/LGG2/IoUOHMlx23bp1UrZsWWcQpXSqnsVikfXr10uvXr0yvK/9xAmxh4X9e0VkpEjJkiLJySInTqS/Q8WKqT9PnhRJSnK/rUQJkagokQsXRGJi3G8LDxcpXVrEZtOkLf16y5UTCQkROX1aJCHB/baiRUWKFBHRaYdnz7qPPyRE7OHhYrfbRY4cSb/eMmVE9Pnp/dJOWyxcWKRYsdTH08d1ZbWKOEI8Ha+O21WpUiIREanPU5+vK90Gui10++h2ymgb6vbV7expG54/L3LunPtt+nj6uCkpIsePp1+vjlfHfeqUSGKi+236PPX5etiGZvvodlKetmHZsiKhoToXVCQ+3v02fV309fG0DfX11Nc1o22o7wd9X3jahoUKiRQv7nkbWiwiFSpkvA31/avvY0/b0PH+zmgb6np1/Z62oY5HxxUbKxId7fn9re/Do0czfn972oaO97der7e70u2u21/penX9nt7fOh4dl6f3tz4PfT4Zvb91O+j28PT+1u2n29FVPn1G6OeQPTRU7Bm9Njn8jHDbhnxG8Bmh+IzIt88I87s4MVHsut4A+R7BZ4QLvkek4jPC7Mv25OTUfTlAvkfwGeFhG/K3RoH+W8P8To6JEbvur/p7sID/rSH5+D3CrtsimMKo7t27m1NWq6gqOl6Ui8LDw6VEiRJyxNMfXy4SP/xQQlw2aEqjRpLUp49YzpyRiBkz0i0fP3p06vo//FCshw+7r6t3b7E1biwh69dL2Hffud2WUqOGJPXrZ17YyNdfT7/eRx4xb+iwzz6TkL//drstqXt3SWnTRqzbt0v455+7r7d8eYm97TZzPvKNN8SS5o2eMGSI2MuWldCvv5bQTZvcbktu106Su3YV6z//SPgHH7jdZi9aVBIeesicj5g1SyxpPmgS77xTbNWqSeiKFRK6erX7eps2leRevcRy4oS5r9t6Q0IkYdSo1G04f75Y0+wIiTfcILaGDSVk7VoJ++EH9+dap44k3XKL2bkip01Lvw2HDzc7ddjChRKyb5/7NrzqKklp2VKsW7ZI+JIlbrfZKlWSxLvvTt2GHl6bhKFDxV6ypIR99ZWEbN3q/lw7dTIn6549Ev7JJ+7rLVlSEocOTd2GM2aIJU0YmNC/v9irVJHQ5csl9Pff3dfbvLkkX3ONWI4elYg5c9y3YXi4JIwYkboN33tPrGk+/BJvvllsdetKyKpVEvbzz+7bsH59Serb13w4Rb75ZvptOHKk+UDR56LvC7dt2LOnpDRrJiEbN0rY11+7P9dq1cx7Qj80Pb6/H3zQfFiHff65hPz1l/t6u3SRlA4dxLprl4R/+qn7ekuXlsT77kvdhm+9JZY0v7QSBg0Se4UKErpsmYRu2OC+DVu3luQePcRy8KBEzJvnvg2joiTh0UdTt+GcOWJN84sp8bbbxFarloSuXGlObtswHz8jYvv0MZ8RUXn4GWErX14S77kndRvyGcFnBJ8R+foZoV989XdV9C23iPXs2YD4HsFnhMs25HtE6vuQ7xGp+3LTphLdq5dYDx0KmO8RfEbwt4argv63hu7H1qQkuXDllfytIfn7GXFeX5sssthNTBg4Ro8ebSqj3n//fY+3a3+offv2mf5Srrp27Sq33XabPKhvzjS0n9T27dulQZkyUijAK6Oiw8OlePHi5sMkHSqjUlEZ5Xf/rUj3/i7g/63Qyqjo0FApXrSoWKiMSt0o/EezQP9HMxA/I/TrVUxiohSrXj31n0MB8D2CyigXVEal4jPC7MvRyclSvGpVseh+GgDfI/iM8LAN+R5RoL9HmN/JMTFSrHJlsVAZJfn5GRFbuLDs2LFDGjZsKIX0NSxIYdQLL7wgmzZtkgULFrhd3759exk6dKgMGjQowzAqKxvMn5lfltHRqWGU7tgAAhL7MhD42I+B4MC+DAQ+9mPvyU62YpUgU6FCBTmeJnlNTEyUs2fPSjlHzx4AAAAAAAD4RNCFUa1bt5ajR4/K/v37ndfp0fVUy5YtfTgyAAAAAAAABHwYlZKSIidOnJD4i/NBmzVrJi1atJDhw4eb6XqrV6+WcePGyY033ijlHfO5AQAAAAAA4BMBH0bpEfI6deokS5cuNZe1V9L06dOlSpUqMnDgQHnsscekS5cuMn78eF8PFQAAAAAAoMALDbQtMGnSJLfLGjr9lebw8KVLl5bXPRyiMNj98tmbcnznJrn5ybd9PRQAAAAAAIDgrIzCv07PfluKf/2LbF/3PZsFAAAAAAD4JcKoIBKaZDM/o08c9vVQAAAAAAAAPCKMCiJ2S+pPW1KCr4cCAAAAAADgEWFUELFbUtMomy3F10MBAAAAAADwiDAqGCujkgmjAAAAAACAfyKMCiJ268XKqJREXw8FAAAAAADAI8KoIGS3pTYyBwAAAAAA8DeEUUHYMyolmcooAAAAAADgnwijgvDVtKfQMwoAAAAAAPgnwqggwtH0AAAAAACAvyOMCsKj6dmTk3w9FAAAAAAAAI8Io4LJxZ5RNhvT9AAAAAAAgH8ijArGyqiUZF8PBQAAAAAAwCPCqCCsjLLbbL4eCQAAAAAAgEeEUcHYwJzKKAAAAAAA4KcIo4Lx1UyhZxQAAAAAAPBPhFFBWBllp4E5AAAAAADwU4RRwYSj6QEAAAAAAD9HGBVMrBcPp0cDcwAAAAAA4KcIo4KIXZimBwAAAAAA/BthVBBWRtEzCgAAAAAA+CvCqCDsGcU0PQAAAAAA4K8Io4LwaHq2lBRfDwUAAAAAAMAjwqhgYr34ctLAHAAAAAAA+CnCqGBycZae2G0+HggAAAAAAIBnhFFBWBlFA3MAAAAAAOCvCKOCiP3i0fTEZvf1UAAAAAAAADwijAoiFguVUQAAAAAAwL8RRgUROw3MAQAAAACAnyOMCiIWy8Vpenam6QEAAAAAAP9EGBVE7BfDKLuNo+kBAAAAAAD/RBgVRCwXp+lZCKMAAAAAAICfIowKwp5RVEYBAAAAAAB/RRgVjJVR9IwCAAAAAAB+ijAqmDh6RhFGAQAAAAAAP0UYFUzoGQUAAAAAAPwcYVQQsVhDzE+7naPpAQAAAAAA/0QYFUysqdP0LDa7r0cCAAAAAADgEWFUEFZGCZVRAAAAAADATxFGBRPLxZeTWXoAAAAAAMBPEUYFYQNzKqMAAAAAAIC/IowKItYQxzQ9X48EAAAAAADAM8KoIKyMstiYpwcAAAAAAPwTYVRQNjCnNAoAAAAAAPgnwqggQhgFAAAAAAD8HWFUUE7TozIKAAAAAAD4J8KoIGJ1TtPz9UgAAAAAAAA8I4wKwml6FjsNzAEAAAAAgH8ijAomIVRGAQAAAAAA/xbq6wEgbxw6dEgWLl8vSXuPS9WkonIrGxYAAAAAAPghwqggkZycLH/tPyrWCwkSdSHC18MBAAAAAADwiGl6QaJo0aLaLcqcj0+mZxQAAAAAAPBPhFFBonDhwmKxpL6ciYRRAAAAAADATxFGBYnw8HCxWFMro5JTqIwCAAAAAAD+iTAqSFgsFgm5eDS9FJvd18MBAAAAAADwiDAqyKqjVBKVUQAAAAAAwE8RRgWRsLAw85PKKAAAAAAA4K8Io4JIWHhqGJXMND0AAAAAAOCnCKOCcJpecgo9owAAAAAAgH8ijAoi4eER5meKnTAKAAAAAAD4J8KoIBLhCKNsdrHZbL4eDgAAAAAAQDqEUUEkPDI1jLKISGJioq+HAwAAAAAAkA5hVBCJiIhMPWMnjAIAAAAAAP6JMCoIwygqowAAAAAAgL8ijAoiERen6VEZBQAAAAAA/BVhVBCJiIhyno+Pi/PpWAAAAAAAADwhjAoiEVGFnOcTEhJ8OhYAAAAAAABPQj1ei4A04K5+0nTZxxJisUjVyhV8PRwAAAAAAIB0CKOCSJGixSXcmlrslpTIND0AAAAAAOB/mKYXRELD/52ml5QY79OxAAAAAAAAeEIYFUTCIyKd55MS6RkFAAAAAAD8D9P0gsievfvk+2PRkmy3S/iuXVK55mW+HhIAAAAAAEDgVUbZbDZ5/fXXpXPnznL55ZfLfffdJwcOHMhw+S+++ELq16+f7nTw4EEJZrt375afTsTIryfPyb59+3w9HAAAAAAAgMCsjHrzzTflgw8+kEmTJkmFChXkpZdeknvvvVe+/PJLCQ8PT7f8X3/9JW3atJGpU6e6XV+qVCkJZmFhYWK3iFjsIgnxsb4eDgAAAAAAQOCFUYmJiTJ79mwZOXKkdO3a1Vz3yiuvmCqpb7/9Vnr37p3uPjt37jSVUGXLlpWCpEWLFjKgVlkJt4lcVq+Wr4cDAAAAAAAQeNP0duzYIRcuXJD27ds7rytWrJhcdtll8vvvv3u8j1ZG1a5dWwqa0qVLS63iUVKzcKQUjkpfMQYAAAAAAOBrfl8ZdfToUfOzYsWKbteXK1fOeZur6OhoOXbsmKxbt85M7Ttz5ow0bdpURo0aJTVr1sz0sex2uzkFKh27zZJ6PjkpIaCfC1CQOT6L2IeBwMV+DAQH9mUg8LEfe092/n7x+zAqLi7O/EzbGyoiIsIET2nt2rXLuREmTpwo8fHx8tZbb8mdd95pekyVKVMmw8c6f/68JCUlSUDvZBdr3S5cOOdx+wAIjH05Nja175vFcjFhBhBQ2I+B4MC+DAQ+9mPvSUhICJ4wKjIy0tk7ynHe8SSjoqLSLd+qVSv57bffpGTJks4/4qZPn276TS1atEjuv//+DB+rSJEiUqhQIQlUGqbtjImX0LgUqXj0uBQvXtzXQwKQi/8o6D5MGAUEJvZjIDiwLwOBj/3Yexz/UA+KMMoxPe/48eNSrVo15/V6WZuUe5L2qHkaWlWpUsVM38uM/tEXyH/4HT58WD76+7iEpIh03rBFbgvg5wIUdI7Po0D+TAIKOvZjIDiwLwOBj/3YO7Lzt4vfNzBv0KCBqVhas2aN87qYmBjZtm2btG7dOt3yH3/8sbRt29YtkdOKoX379kmdOnUkmIWFhYlcfO0TEwN3uiEAAAAAAAhefh9Gaa+o/v37y8svvyzLly83R9cbPny4VKhQQa6++mpJSUmREydOmN5QqkuXLmKz2eSJJ54w/aM2b94sjzzyiKmWuummmySYpfbVSk2jkpISfT0cAAAAAACAwAuj1LBhw+SWW26RZ555Ru644w4JCQmRWbNmmUqgI0eOSKdOnWTp0qXOaX1z5swxlVG67KBBg6Ro0aIyd+5c0/Q8mOn2sF+sjEpKJIwCAAAAAAD+x+97RikNn0aNGmVOaWkvqL/++svtukaNGsns2bOloAkN/ffl1IbvAAAAAAAA/iYgKqOQjWl6FxuGJSfRMwoAAAAAAPgfwqhgm6Z38Tw9owAAAAAAgD8ijArSo+klJVAZBQAAAAAA/E9A9IxC1litVrFaLx5NL5kwCgCAgmTqykVyeNN38uBHK83/ps61bij3NLogYZYoWdLkQZGF70rhnjfJX3Uvl71nj0rXao2kaPRJsVitYitdUWKSEyUyJFwirRaxJieJLTRM7NYQsdntEnLxP5g2u03EYhW7xSIWu6MeGwhedrtdUpKTzclysR0GgMASKPtxiEsP6IKgYD3bAiDEql8VUySZMAoAgAKj94ePSsm//5C7vz8lux3fs9dtkUnrUs9ukIdTz/y23vwoojf7aKwAACC9pDt6S68H/isFBdP0gkxISOpLmpyU7OuhAAAALzlxbqcJogAAQGAK+3CJFCSEUcEaRiWn+HooAADAC07HxsmL8/ezrQEAQMAgjAoyISGptfnJyVRGAQBQEExb9amvhwAAAJAthFFBJjREW4xSGQUAQEGxa/UMXw8BAAAgWwijgkzIxTAqJcXm66EAAAAvGPgdvaIAAEBgIYwKMiGhqWGULSXFHMISAAAAAADAnxBGBWkDc7HbJSkpydfDAQAAAAAAcBPqfhGBrknNcmKNTZTYKsXFaiVrBAAAAAAA/oUwKsg0rlVRyhyPkVPVSkloKC8vAAAAAADwL5TOBBlLSFjqGRqYAwAQ9FKSEn09BAAAgGwjjAoylosNzC0pyb4eCgAAyGfJ54+zjQEAQMELoxISEjhqmx9JtlvlQnKKxFxIkORkAikAAILZgV07fD0EAACAbMtRU6E9e/bI66+/LqtWrZLz58/LggULZOHChVKrVi0ZMGBATlaJPPLTpn2yacdhSdoXIt327ZM6deqwbQEACFLRq3/z9RAAAADyvzJq+/btcsstt8jWrVulT58+zqqokJAQmTBhgnz22WfZHwXyTGhEeOoZu12SkpLYsgAABLEjp7f4eggAAAD5Xxk1efJkady4scyePdtcnj9/vvn5zDPPmCl7c+fOlb59+2Z/JMgT5UqXkPpFIyW5aJgULlyYrQoAQBCzntrv6yEAAADkf2XUn3/+KYMGDZLQ0FCxWCxut/Xq1Uv27duX/VEgzzRvVFf6Vy8rN9UtJ9WqVWPLAgAQxEr/ecHXQwAAAMj/MCoiIkLi4+M93nb27FkJD784TQw+ERIWaX5aUmy8AgAABLlYC7/vAQBAAQijOnbsaJqXHz161HmdVkhduHDBTN3r0KFDXo8R2RASEWF+Wm2pvbwAAEDwSrbw+x4AABSAnlGjRo2S22+/Xa699lpp0KCBCaImTZoke/fuNc3Mp06dmj8jRZaEOiqjCKMAAAAAAEAwVEZVrFhRPv/8cxk4cKAJn7QvUWxsrPTu3VsWLVokVatWzZ+RIkv+2ndEXtl5RKZtPCTLly9nqwEAAAAAgMCujFIlS5aU4cOH5/1okGt2a4icTkwWm1XM1EkAAAAAAICAC6MWL16crZXeeOONOR0PcikispD5qcc5TEpKYnsCAAAAAIDAC6NGjx6d5RVqDynCKN+JLFQk9YydMAoAAAAAAARoGEXvoQCsjCKMAgAAAAAAgdrAvHLlym6nlJQU+e2335yX4+PjZf78+aYqSi/Dd6KKFHWej4+L5aUAAAAAAACBfTS9P//800zDmzVrlvO6mJgY+eKLL6Rv376yc+fOvB4jsqFwkRLO83GxNDAHAAAAAAABHkZNmTJFWrRoIZ999pnzuubNm5upfE2bNpX//ve/eT1GZEPhosWc52MvnGfbAQAAAACAwA6jtm7dKkOGDJHIyEi36yMiImTgwIGycePGvBwfsqlQkX/DqLhYwigAAAAAABDgYZSGUMeOHfN425kzZ8RqzfYqkYcKOY6mZyqjzrFtAQAAAACAX8l2ctS5c2d5/fXX5a+//nK7fvfu3TJt2jTp0qVLXo4P2RQWFiZ2S+r5OMIoAAAAAADgZ0Kze4eRI0dKv379TLPyKlWqSKlSpUxF1IEDB8zlJ554In9GiiwJDQ01YZTFzjQ9AAAAAAAQBGFU2bJl5csvv5RFixbJH3/8IWfPnpXy5ctL//795aabbpLChQvnz0iR9cooq0XEZpd4GpgDABC07Dabr4cAAADgnTBqw4YN5uh5Gj7pCf4XRoljml5srK+HAwAA8ok9ISHdddtj4mRT9AWJTkqRFHvW1nNz5VJSLjLMeXnnuThZfjzGnO9Upqg0KV7IeVtMUrLM/+dUrsdet0ikXFm+uNt1c/Ydl7gUuxQNtUr/6mXdbvv6yFnZF5v++WbXwOplpFBoiPPyhjMXZPXp1AO+XFuhuNQs/O8Beg7HJcoXh8/k+jGblSgk7UsXdV5Osdtl5p7j5nzFyDC5oXIpt+UXHjwlJxOSc/WY+n/J+2uVd7tu5ckY2RIdZ87f5OE1/+Hia54bHT28Xz64+H6p4+E1n7vvhMSm5C5ULRoaIndVL+N23TdHz8q+C6nvlwHVy0jhNK/5mouveW5ck8n7JbPXPDcye79c6jXPjczeL5m95rmR2fvlUq95bmT2fsnsNc8NPiP4jEix2+XPsxekZcl/+z8XBNkOo+644w6pUaOG3HzzzXLjjTeaSin4D4vFImGhVrElpUh8HGEUAAAFxY/Ho3MUKCTZ3VOr+BSb+SNLnU9OcbtNAy7HbblROjz9V9Cj8UlyIdkmJcL+/UPQ4XRicp48btrY41xyinO98WnSuwSbTQ7lwWPWKhyR7jrHesM0QUjjRELun6uH1crZxBTn43p6zfPiuXp6vzjWW8rDa34kPlHOJ+cujPL0fjmVkOx8XJs9/WueF881s/dLZq95bmT2frnUa54bmb1fMnvNcyOz98ulXvPcyOz9wmcEnxH5+RlxLqngVTtnO4yaN2+eLF68WGbMmCGvvvqqdOjQwQRTPXr0SK3Kgc+FhYVIQlyKJMTH+3ooAAAgnySk/FsFcDw+SX5ME0R5+uM0ayzO+3o60k3O15v5OqwXH9dqSX9j6vWS53SVma03Px7Tdb2eVm/Ng8fVbZmWbtaM1/vva54bHp+P473k4UZLHjxudt8vl3rNczeWnN2WVZm9X7L/muduJJm+h/PpM8LxfuEzgs+IYPyMsFhEij/9lBQkFrs9TdSdRQkJCfLtt9+aYGr16tVSpEgR6d27t+kb1ahRIwkksbGxsn37dmnYsKEUKvRvmWmg0ZcyOjpabmldT86fjpOQSmXk1817fT0sADncl4sXL26qHQEEHm/sxxfOnZZVvTuZ898ePSu/nDwnhcUiVR+8VxKaFJFZfcdI2N6tYi1RVkLKVRWbzSZWa7YPpAwUaPxOBgIf+7F/ZivZroxyiIiIkD59+pjTnj175Nlnn5X58+fLBx98YB743nvvlV69euV09ciFQpFhYglNFEt4+hJWAAAQfHacS+0LE1mtsrw28lkTghn1WjiXIYgCAAD+IsdhVFxcnKmM+vzzz2Xt2rUSGRkpt99+u3Tt2lVWrFgho0aNki1btsgTTzyRtyPGJd3Rvo6U+euEnG5dh60FAECwOnvQ/Ei02ZwNr+t0ufrfIAoAACBYwqhVq1aZAOq7774zJVitW7eWF198Ua699loTSKlu3bqZkvSPPvqIMMoHLOHh5qc9MfdHlAAAAH4q7rT5EZOUIkVCQ0yj3dq1a/t6VAAAAHkfRg0ePFjKlSsnAwYMMI3Lq1Wr5nE5/TLUqVNqHwN4mTOMyv0RDwAAgH9KuniknjIRYfJEg0rmqFad77zT18MCAADI+zBKj6LXuXPnS/Yd0LBKT/A+a0RqhZolKYnNDwBAkDp4OtbtslZHlSlTxmfjAQAAyKpsHVLl9OnTUrNmzXRB1Ny5c+XEiRPZWRXy0fajMfLJgVOyaP0+OXgwtZ8EAAAIMlt3ul8uXcRXIwEAAMifMGrx4sXSvXt30wfK1dGjR2XChAnSo0cP+frrr7P36MgXJ88nyuboWNl94rwJEAEAQPCxnI12u5zQqr7PxgIAAJDnYdT69evl6aefNs3Kb7jhBrfbKlSoIJ999pm57fHHH5fNmzdnawDIe5GFCpufFrtd4uPj2cQAAAShBFtqb8gvD58xpz9P5fggyQAAAP4XRs2cOVPatWtnftavn/6/bg0bNjS3NW7c2PSUgm+1a9FYRtSrKI+2qCotWrTg5QAAIAjtjztkfm6LiZW1p8/LlgPulVIAAAABHUZt3bpVbr/99sxXZLXKXXfdJVu2bMmrsSGHSpYtJyXDQ6WoWCQ0lP+SAgAQjKxJ58Vut0tcis1cLl6S5uUAACAwZCmpOHfunJQoUeKSy1WsWFHOnj2bF+NCLkQULiZ6fJ2Qi4d8BgAAwSc85h/z85E6FSTeZpdOo57w9ZAAAADyrjJKQ6a9e/decrl9+/ZxSGE/EFm0lPkZkkwYBQBA0LKJWCwWKR0RJpWjwqVOnTq+HhEAAEDehVHdunWT999/XxITUxtlepKQkGCWadu2bdYeGfnGHhplekf8ejhafvvtN7Y0AABBqOTWOF8PAQAAIP/CqEGDBsnp06fNT089obSn1JAhQ+TgwYMyePDgnI0EecYSUdgcVWf50Wj5ecUKtiwAAMEotVUUAABAcPaMKleunEyfPl2GDx8ut956q5QuXVqqVKkiKSkpcuTIETl16pS5TpepXbt2/o8amapYqYbz/MmTR9laAAAEoRSxy6mEJNl9IUEirRZpdPiwVKpUydfDAgAAuKQsH2qtZcuW8uWXX8pnn30mK1eulKNHj0pISIg0adJEOnXqJDfccIMUKVIkq6tDPipTrqJYdLqeiJw+cYxtDQBAEIq12uVQXKKphlb11q8njAIAAMEVRqnixYubqXp6gv8KCw+X8HCrJCTa5OTxI74eDgAAyCdxKf/O1eOfggAAIKh6RiHwRISHmJ/nos/6eigAACCfxNv+PXJu4cKF2c4AACAgEEYFqfDw1KK3C+fPi93+7xdVAAAQnJVRhFEAACBQEEYFqcjI1DAqJSlRLly44OvhAACAfMA0PQAAEIgIo4JURGS4+WlPSZZz5875ejgAACAfxFMZBQAACkIYtWHDhvwZCfJUoaKFUs8kJcmZM6lH2QEAAMEbRtHAHAAABG0Ydccdd8i1114rM2fOlOPHj+fPqJBrJcqWTT2TnCInT55kiwIAEITibalhlNUiEhER4evhAAAA5E8YNW/ePGnVqpXMmDFDunXrJvfdd5988803kpSUlN1VIR+VKpcaRllsNjl16hTbGgCAIBSfknqQkkirVSwWi6+HAwAAkD9hlAZRL774ovz6668yadIksdls8vjjj0unTp3khRdekK1bt2Z3lcgH5SpXNT8tKXbCKAAAgryBeWQIbUABAEDgyPE3Fy0F79Onj8yaNUu+/PJLqVevnsyfP19uueUWuemmm2Tp0qV5O1JkS7W6TcxPa4pdjh05wtYDACCI2GJjxW63O3tGRYaE+HpIAAAAWRYqORQXFyfffvutfP7557J27VqJjIyU22+/Xbp27SorVqyQUaNGyZYtW+SJJ57I6UMgFzpcfYtY5FERu8junVSrAQAQTOzx5yTBZtdf80ZUCFP0AABAEIdRq1atMgHUd999J7GxsdK6dWszbU+bmmsgpbSXlPYt+OijjwijfKRw0WJSNCpUYuKSZe/ff5n/ntJLAgCA4BD961fOKXrKUijH/18EAADwumx/cxk8eLCUK1dOBgwYIDfffLNUq1bN43K1a9c2faTgOyULh5swKubEETl9+rSULl2alwMAgCBwcv165xQ9daR6uE/HAwAAkK9hlB5Fr3PnzmK1em43lZKSIiEhISas0hN8p3ShcNkvsRISfUEOHz5MGAUAQJA4++NPEusSRhWNivDpeAAAAPK1gfnzzz8vO3fu9Hjbpk2bpEOHDtldJfJJvSol5dYqpeXJupWkSZPUhuYAACDwRYvNLYyqG17Sp+MBAADI88qoJUuWSHJysjl/6NAh07h8x44d6Zb77bffJCkpSfKazWaT6dOny4IFC+TcuXOmT9W4ceOkatWqHpc/c+aM6WP1888/mz5J1113neldFRUVJQVJwxv6ivX9Beb80YO7pUKV2r4eEgAAyCOxySnO80UiwtiuAAAguMKozZs3y3vvvWfOa7jz5ptvZrjsPffcI3lNH++DDz6QSZMmSYUKFeSll16Se++9V7788ksJD0/fI2HYsGHmaH9z5syRmJgYGTNmjGm2PnnyZClIrhw0Vn64GEatv+d6ue47jqoHAEAgS0hOkA5zb5JJItK4eCEpER4qx+KTpFC5mr4eGgAAQN6GUY8//rjcfffd5ohsV155palSatiwodsy2ieqSJEi5pSXEhMTZfbs2TJy5Ejp2rWrue6VV14xfau0Qqt3795uy2/YsEHWrl0rS5cuNU3UHVMLNbwaMWKElC9fXgqKkNB/X97wRLv8+vNy6dC5O0fVAwAg0CReEDm4Tjr+OFlCLs7OKxwaIvWLRpnTjgpUPwMAgCALo7T6qHLlyub88uXLzdH0wsK8Uw6u0wEvXLgg7du3d15XrFgxueyyy+T3339PF0atW7dOypYt6wyiVJs2bUwAs379eunVq5cUJOeuuFwifvxDlhw+Kxv63iiNi0fJ7VXLSGxhi8QWCZeUiFDZcyZekiwWkbAwsYeFi4SGiiUsXEJCwyQkNFxEz4eFO68LC4sQa2iYWEJTL4fqKTxCWrVsLpYQPR8uISHhsv/AQTlz9pyEWEOlafMmUrRIMQmxWM3jnD5xSvbs2SMWa4jY9bH1zWi3iM2eLBYJ+Tcws6b+NBctVvcmZxareZ0rVqx4cVGLqYDTQFKVLVtOGjVu7LY9Vq9e7ZxymlM63bNly5bOKaRq+/btZnqoatu2rdv+ceDAAdm/f7/klr7nS5Uq5bx89uxZ2bJlizmvU1arV6/udiABnTabWyVKlJDGabahbl/dJ/UgBml7xP39999y9OjRXD9u8+bNpXDhws7Lx48fd/aqc33NlVZB6r6dW/q5Vq9ePY/vF9fX3GHr1q3O1zw32rVrJ6EuwbG+X/bt2yfnz583n12uR8F0fc1zI7P3S2aveW5c6v2S2WueG5m9XzJ7zXPjUu8XT685nxHB+Rmhr63+k875Oy0HHO+XuMWvyJHpH8ujpUWW1C0i/8QmSLVC/zYtL1uMo+kBAIAgPpqeBkCXcuONN0pecfyh4vrF0vGl0NMfvceOHUu3rIZp+gfWkSNHMn0srfzSU6ByjN/1OfR9br5M+7KWbDib+ofkyYTUP7IKXbBLoQsJWvAvH+86IicuXp9TYVaLVLusitt1nx86LevPpD7ug7XLS8Wof78orz9zXhYfyv0f8tdXKimtS/1bjXcyIUle23Xxj9sSheWmKv+GN2rC9kMS59LwNSdKR4TKo3VT32P654Vu7Xn7T8jOc/HmutENKkmh0BDn8iuOx8gPx6Mlt+6qXsb899th9/l4eW/fCXO+S9licmX54s7bEm02eXHboVw/Zq3CETKoZjm36974+6iZEqKv+dg0r/kXh0/LutO5Cy3Ug3XKS4XIf98vG85ckM8OnTbn+3h4zV+/+JrnxuUe3i8TL75fXF9zB9fXPDcye79k9prnRmbvl8xe89y41Psls9c8NzJ7v2T2mufGpd4vfEbwGZEdjveLibMsIis3nZL9P++T96wWeaZhZWfQVbFYVEB/hwEC6fs1gMDCfuw92fmszHYYNXr0aI/X65chnaqnp7wMo/Q/miptb6iIiAiJjo72uLynPlK6fEKChi8Z++qrryQ+Pvd/XPqSVjjoa+Cq+KPjpPfqlXI8PkmiQqyy3SUUUvVqJ0jVXP7xpVVJ24tEuj9uvSRpkZgach0rHCFnrf/WNSUlpUiL+ETJreTIMNke9u/bONFmlxb1U1/D4mGhsj3SvYKvcc14Scnll4lwq0V2FHZ/rhXqJEqRi41k9xaJlBCX/4KHJSZLi4TcN/Y/FxUuO1xCiwspNmnROPU9HREeJjsi/t0ONrFLi1q5fy8XDrHKDpf/vKvatROkcorNvOY70rzmxVxe89xI+35JdHm/pESGyY4MXvPc0PfLjgzeL5d6zXMjs/dLZq95bmT2fsnsNc+NS71fMnvNcyOz90tmr3lu8BnBZ0R+fkYUr5MoLS6ud0uRSAm9eJvteKLsf//9XD8egKx9vwYQWNiPvSMyMtJtllqehlE6TS8tnRql0+Nmzpwpb7zxhuT1k3H0jnKcVxoseTo6ni6jy6alyxcqVCjTx9Kj7l1qGX9PITWgK168ePopAQMHScyZk7Lg+Xuk8uY9EuqSF9iiYyUmOUX07y9T6WMVsVktkhIiYjfT4yxit+opdWqc3mamz+ljWCxis+jMvhCpWK202PWPST1ZLJIYHStJWglgtUi5qDJSSENCq9U8RnhigpyLiTFT9MxMPGuIhJcsK+FROp1B/zi2mOVSK49Sz+s5/XNYh6F/KlrELrWrlpbyZUqIxa632SUuNkFid+wxS1esUVU6dekhVp0aqCwWiVy5xkyp0OflvoUuXjLj+feR/73t3/NRURHSqV2b1Iv6xcRukz82bJZTp1KrOK64ooOEu0zT27N3v+zes8/zi6Zjs2ftj/zLmzWWsmX+nbKlj/fHn5vN+do1a0idWjXMNhCbXT9t5fufV4ldt97FoZvn7HLePLzZkJZ0yzluK1m6pLRs3lSsZsPra22R31atNVO2LKEh0qNrp39vE7vs2LZTDh4+kvn69f1ht5nX0fHM0y7XrnVLKVI8tZpF13/o2DHZsm2Hue2y+vWkUtWK5nnqH2ExsbHy6+rfc/U89XzFCuWlacMGzuep2/CnX36TxOQk87nQuW1r5/PUMf2xcbOcOH06V89Tdbn4fnFsx7/37pPdu/eZz6w2bVpIudKlzfPUMZ04dUo2bNicq+dp3i/Vq0udOjWdz9OWnCKRv/xqbitdoqS0atnM+TzVr7+vk/PnL+TqeV7q/dKuVQspWayoGZPeduTQUdm6/a9cPU/zfmlYXypVqWSep376xMRdkN9WrzO3VaxYQRo1qu98njaryIqfV0lyYpLb+s22sIaK3Z4iFkuI86fYUsxj6WeMTtl1fO5GFYqSzh3b64ey2FKSJTQkRNZu2CinT5426+3Spb1EhoSZzw+9fd/+A7Jrz16352XWabn42WfTEVz8JNT/zrs+pvXfcbRo1kTKliolthCrWFNscuLMadnw5xZznxq1qkuD2rUkWbdDSKgkJySY19xtnRdfQ9frnOetVvPZaLPbxaLTk3WKtT1FSpcqLW30/WI+elLEagmR1WvWSYy+X6wiV3W7InU/1s91u8iW7dvl8OHj5nNef+ekbmO7WC4Gkea6i9vXuUzay2KX9q1bSInixcw61cHDh2Tb9r/NMg3r15VKlSuK1a6vm9WMJfUzIs3juDx2hpfN89ftbJUK5ctJo0YNnOvVx/7h518lOSlZCunvhQ7tnJ/P+opt2LBRDh05KhERkWY9jvXrhnF7/hcfw2ywi1zH0q1zBwkNC5Mxq2bIgHm/y45Dx+VEQpJULxQhNUoXlaJhF/9AfqCPXNnIvXUBgHz+fg0gILAfe49mQ9pqKSss9jysOZ07d65888035sh3eWXTpk1y6623ynfffSfVqlVzXn/HHXdI/fr1Zfz48W7LayA2b948+emnn5zXaTjVrFkzmTJliseeUbrBtOePNmUP2jAKQMBgXwYCX17vxz3mPijRSftk4tx9UsVulYMW939klJ41U1rU6ZjrxwHgjt/JQOBjP/ae7GQrbv2gc0vDIW3YmZcaNGhgmn+uWbPGeV1MTIxs27ZNWrdunW55vU57Sbk2g9Wj66m0zUUBAAACQZwcNNXEc7qXF621SqtaYfeebAAAAP4sz8IorT5auHCh25Gf8oL2f+rfv7+8/PLLZoqglnwNHz5cKlSoIFdffbWZ+3nixAlnryetgGrRooVZRquq9Eg348aNM32sypcvn6djAwAA8IZu1dtKofAQOd+ktNT8ebOZ4AcAABCost0zqnv37unKzbVvhR6yWnucPPnkk5LXhg0bZvr8PPPMMyZ00uqnWbNmSVhYmBw8eFB69OghEydOlJtuusmMbfr06fLcc8/JwIEDTePya6+9Vp566qk8HxcAAIA3PNNxhGw6sUmal2tuLr81pIM8OCu115vBgb4AAEAAyXbPKD2anqfeBzqVrlu3btKhQwcJNPSMAuBPmNcOBL783o+/371O7IPvdl6+fOFPUrZs2Tx/HKCg43cyEPjYj/0zW8l2ZdSkSZNyMzYAAADkUudqzeVnl8v2iKJsUwAAEDCyHUYdOHBA1q9fLydPnjT/6atYsaJpDE4/JgAAAO+ICAtxv4IWUgAAIBjDKA2hxo8fL6tWrTJlbq6sVquZojd27FjTWBwAAAD5a0K/ivL0R0fkVAmRskUi2NwAACC4wqhjx47J7bffbo5cd99990nHjh2lTJky5rajR4/Kr7/+ao6k169fP/n000/z/Ih6AAAAcBcTESlP311dbGKRfvnQlwoAAMCnYdQbb7whISEhsmDBAqlcubLbbbVr1zbh1N133y133HGHzJw50zQ5BwAAQP6pV7ir7Lywgk0MAAACjjUrC61cuVKGDh2aLohypdPzBg4cKCtW8KUIAAAgv71/y+PStMj1MrL5eDY2AAAIvsoobVZep06dSy7XoEEDOXz4cF6MCwAAAJkIDbHKu7cNZRsBAIDgrIxKTEyUQoUKXXK5qKgoSUpKyotxAQAAAAAAoKCGUQAAAAAAAIDXpumpEydOXHIKni4DAAAAAAAA5DqMevjhhy+5jN1uFwuHFgYAAAAAAEBuwqiJEydmZTEAAAAAAAAg92FU3759s7IYAAAAAAAAkCkamAMAAAAAAMBrCKMAAAAAAADgNYRRAAAAAAAA8BrCKAAAAAAAAHgNYRQAAAAAAAD862h606dPz/IKLRaLPPTQQ7kZEwAAAAAAAAp6GKUhk7Lb7ZkuSxgFAAAAAACAXIVRTZs2lU2bNknDhg2ld+/ect1110mFChWyclcAAAAAAAAgez2jPvnkE1m+fLn07NlTlixZIt27d5e77rpLPvzwQzlz5kxWVgEAAAAAAABkvYF55cqV5f7775fPPvvMBFLt27eXefPmSefOnWXIkCHm+vPnz7NJAQAAAAAAkLdH06tVq5Y8/PDD8tVXX8nChQulcePG8vbbb0vHjh3lkUceyckqAQAAAAAAUADkKIxKG0xpTyk9paSkyI8//pg3IwMAAAAAAEDBbGCeVmJiovz888/yzTffyIoVKyQuLk5atGghTz/9tFx77bV5P0oAAAAAAAAUrDAqbQB14cIFadasmQwbNswEUOXKlcvfkQIAAAAAAKBghFEjR450BlDaH+rBBx80R9arWLFi/o8QAAAAAAAABSuM0qPnhYSESKtWraRKlSqya9cuc/LEYrHIhAkT8nqcAAAAAAAAKChhVKVKlczPQ4cOmVNmNIwCAAAAAAAAchxG/fDDD1lZDAAAAAAAAMiUVbLgrbfeks2bN4vdbs/K4gAAAAAAAEDOK6Nef/11cypWrJi0bdtWOnXqJB06dDD9owAAAAAAAIA8DaNWrVol69atc56ee+45sdlsUrVqVenYsaM5tWvXTooUKZLlBwYAAAAAAEDBk6UwqmTJknLVVVeZk7pw4YKsX7/eefr0009NONW4cWNTNfXwww/n97gBAAAAAAAQrGFUWoULF5YuXbqYU2JioqxZs0YWLlwoy5cvl40bNxJGAQAAAAAAIO/CKG1m/ssvv8hvv/1mwqekpCSpUaOG9OvXTzp37pyTVQIAAAAAAKAAyFIYderUKRM+6Un7R505c0aKFy8u7du3l7Fjx5qpeRUrVsz/0QIAAAAAACD4wyitdgoJCZHLL79cBgwYYMKnJk2aiMViyf8RAgAAAAAAIGhYs7KQNicPDw+XqKgoKVSokDkRRAEAAAAAACBfKqN0at7KlSvNaebMmTJ58mQpX768dOzY0VRN6XQ9nbYHAAAAAAAA5DqMKlWqlFx//fXmpLZu3Wr6R/36668ycuRIsdvt0rhxYzN9T0/NmzfPymoBAAAAAABQwOToaHqNGjUypwceeEDOnz8v69atk2+++Ub+97//yZtvvinbt2/P+5ECAAAAAACgYIZR2kNqx44d8scff5jTn3/+KYcPH5YyZcpI27Zt836UAAAAAAAAKDhhlFY/bdy40Rk+6fm4uDjTyLx169YycOBA6dChg9StWzf/RwwAAAAAAIDgDqPatGlj+kKFhobK5ZdfLvfee69pWt60aVMJCQnJ/1ECAAAAAACg4IRR99xzjwmfWrVqJZGRkfk/KgAAAAAAABTcMGrUqFHm56ZNm+TQoUNSrVo108AcAAAAAAAAyPMwKiYmRoYOHWoalet0PYvFIs2bN5cpU6ZIxYoVs/WAAAAAAAAAKLisWVno1VdflW3btskjjzwi//vf/+TJJ5+UPXv2yLhx4/J/hAAAAAAAAChYlVE//vijjBgxwhw1T3Xp0kXKly8vI0eOlNjYWHNUPQAAAAAAACBPKqNOnDiRrkdU27ZtJSUlRY4cOZKVVQAAAAAAAABZC6OSk5MlPDzc7brixYubnwkJCWxGAAAAAAAA5F0YlRltaA4AAAAAAAB4JYzSI+sBAAAAAAAAedbAXI0fP16KFCmSriJq7NixUrhwYbdw6r333svqagEAAAAAAFCAZCmMat26tccpeZ6uZ9oeAAAAAAAAchVGvf/++1lZDAAAAAAAAMjfnlEAAAAAAABAVhFGAQAAAAAAwGsIowAAAAAAAOA1hFEFyIABA6R+/foeT5MnT87Xx05KSpI5c+ZkePvBgwfNONasWZOrx3nrrbekTZs20rx5c9m8ebPs2rVLVqxYkat1AgAAAAAALzcwR/Do2bOnjBkzJt31UVFR+fq4S5YskYkTJ8qgQYPy7THOnTsnr732mjzwwANy6623Srly5eSaa66Rvn37SteuXfPtcQEAAAAAQNYRRuWQ3W6XhGSb+EpEqFUsFku27xcZGSlly5YVX2yv/BYTE2Mep127dlK5cuV8fzwAAAAAAJB9hFE5oIHHEws3yY6j58RXGlYsKpNvbpqjQOpSU/lq1KghO3bskL1798q4cePk+uuvl8WLF8vs2bNl3759UqZMGbnllltk6NChEhISYqbY9ejRQ15//XV55513ZPv27aYqSW+//fbbZdGiRfLUU0+Z9etUvLlz50rbtm2zPbbExERT+fTFF1/I+fPnpW7dujJs2DDp1KmTmd539913m+UGDhxopuodOnTInKZPny5r166V999/P0+3FQAAAAAAyD7CqBzK4wzIryxYsEBeeuklExxpFZX2epoyZYqMHj1aOnbsKBs3bpTnn39ezpw54zblT6fhjR07VurVqyfvvvuujB8/Xjp06CC9evUyU+gmTJggK1eulOLFi+doXBpo7d69W15++WUpX768/Pjjj2ZKnoZN+jg6bp2eN23aNBNG2Ww2M0VPH1+DMQAAAAAA4HuEUTmg1UhalRSI0/S+/PJLWbZsmdt1LVu2NBVNDg0bNpQ+ffo4q8Bmzpwp/fv3l7vuustcp5VTZ8+eNYGVViY5aD8orZBSw4cPl/nz55vgqnfv3lK0aFFzfU6nCO7fv9/0ndIKLR2fuueee0wF16xZs0xPqFKlSpnrNewqUaKEOa+VW4UKFXJeBgAAAAAAvkUYlUMaBEWGhUig6d69u4wcOTJdHylX1atXd54/ffq0nDx50gRWrrTySI+Qt2fPHildurS5rnbt2s7bHeGTLpMXtm3bZn7eeeedbtfr+osVK5YnjwEAAAAAAPIfYVQBU7hwYbewyRPXcCqjxuM6BU6Fhv77FgoPD8+3xuWO9Wi1lT4HV1arNU8eAwAAAAAA5D/+ikemtFm5ntavX+92/bp16yQsLEyqVauWpS2Y20br2qxcnThxwoRpjpM2R9cTAAAAAAAIDFRG4ZKGDBkir7zyilStWtU0MN+0aZNpGq5HytPpeNHR0Zdch/ZtUlu2bJE6deqkmxrooOtOSEhwu06blWsz9W7dusmzzz5rjvCn4dQ333wjM2bMMI3TM6JVVHoEQJ1qqKEaAAAAAADwLcIoXNLgwYPNFLz33nvPHBGvQoUKct9995mQKqvatWsnzZo1k379+pnG5z179vS4nB4pLy09It6kSZNMIKYnDaM0ANOqrP/85z/m9owMGDBAJk+eLLt27ZIvvviCVxsAAAAAAB+z2POqqU8Ai42Nle3bt5ujtDkqeAKRvpQa0ujR5HI7LQ6A77AvA4GP/RgIDuzLQOBjP/bPbCUgKqN02pZWxui0rPj4eHNEuDFjxkipUqUyvM9bb70lr776arrr//rrr3weLQAAAAAAAAI6jBo/frxpmD1t2jQzXUz7Bg0bNkzmzZuX4X00dLrhhhtk1KhRXh0rAAAAAAAAAjiMOnbsmCxevFjefvttadWqlblu6tSpcu2118qGDRukefPmHu+3c+dOue2226Rs2bJeHjEAAAAAAAACNoxav369swG2Q82aNc0R1n7//XePYVRiYqI5glqtWrWyPZc0kFtoOcYfyM8BAPsyEAz4nQwEB/ZlIPCxH3tPdrKIgKiMKlmypERERLhdX65cOTl69KjH+/z999+SkpIiy5YtM0db055TrVu3NlP29H4ZOX/+vCQlJUkgv/DaMEzRwBwIXOzLQOBjPwaCA/syEPjYj71Hs5eACaMOHjwoPXr0yPD2Rx991PSJSkvDqYyeqE7RU1FRUfLaa6/JqVOnzNS+u+++20z5i4yM9Hi/IkWKBPzR9BRH0wMCG/syEPjYj4HgwL4MBD72Y+9xFMcERBil0+2WLl2a4e0//fSTmXaXlgZRGjZ5cuONN0qXLl3cjrZXt25dc90PP/wgvXr18ng/rSYK9Ioix3MI9OcBFHTsy0DgYz8GggP7MhD42I+9Izs5hM/DqLCwMKldu3amR8U7e/asCaRcK6SOHz9ugqyMuAZRSqfnlShRIsOpfQAAAAAAAMh/VvFzLVu2FJvN5mxkrvbu3Wt6SWkfKE9eeeUVueaaa9yaZ+l0wDNnzkidOnW8Mm4AAAAAAAAEYBil1U/XXXedPPPMM7JmzRrZtGmTjBgxQtq0aSOXX365WUarpk6cOOGcznfVVVfJoUOHZPz48Sa40qPuPfLII9KiRQvp3LmzFFQDBgyQ+vXrezxNnjw5Xx9bG8PPmTMn02U8jatZs2ZmWuXcuXPdgkW9Td8PWaHL6fJ6v8zmts6fPz8bzwgAAAAAAOSEz6fpZcULL7wgEyZMkIcffthc1t5PGk45bNiwwTQn18Cibdu20rhxY5k5c6ZpXn7TTTeZ6X3aJP3JJ58s8L2UevbsKWPGjEm3jTPqv5VXlixZIhMnTpRBgwZlutzTTz/t1tPr9OnT8uGHH5qjIpYpU8bcVrFiRVm5cqVp1J5XZs+eLYsWLZK77rorz9YJAAAAAAACNIzSI9y9+OKL5uSJBlDaW8pV+/btzQnu9EiCZcuW9fpmcZ0ymZmiRYu6jU/PP/vssyZ80kb3GkaFhITk+XPI6vgAAAAAAECQT9PzWxpeJMX57pRP4YlO5Rs7dqzceuut0qpVK/niiy/M9YsXL5brr79emjZtKt27d5c333xTUlJS3KbNLVu2zNxPK9N0mY8//tjcrhVHTz31lDmfnel1rh35tbotNDTU4zQ9HYf2CevUqZOZujls2DBTSaXPJe2RGXv37m3Gp1M/V6xYYa6fNm2aTJ8+3UztvNR0PgAAAAAAUAAqo/yOBkGfPyxybIvvxlChscj10zWpyfNVL1iwQF566SUTzGgFkvZ6mjJliowePVo6duwoGzdulOeff940hHed8qfT8DTIqlevnrz77rumZ1eHDh1MNdO5c+fMVMvsTq/TXk7z5s2T3bt3y6hRozwu8/LLL8tnn31mpnPWqlVLPvjgA3n//ffTNbjXaZw6bj2yot7nsccek19//VUGDx5sHkcrrxYuXJjuSIwAAAAAACDvEEblVN5nQF7x5ZdfmgqmtEcsfOedd5yXGzZsKH369HFOX9P+W/3793f2U6pRo4acPXvWBFZaheSg/aC0N5caPny4aQiuwZVWI+n0O3Wp6XU6JU9DJcdjJyQkSIMGDeTVV1+Vbt26pVs+Li7OhE9aeaWN65X2E9M+Yp76UemUTvXQQw/J999/b0IurfbSqaD5Mf0PAAAAAAC4I4zKCa1G0qqk5HjxmdDIHFVF6fS5kSNHpusj5ap69epuDcRPnjxpAitXejRDPULenj17pHTp0ua62rVrO293hE+6THZouHX11VdLcnKyfP311zJr1iy57bbbTON1TzRMio+Pdx5Z0TGtT8e7Y8cOt2Vr1qzpPF+sWDHzU+8LAAAAAAC8hzAqpzQICsvfI9Dlh8KFC7uFTZ64hlMZNfa22Wzmp6OPk9K+TrltDK7BlmN8jqMn6nQ/ndrnepQ9B8fjZ+VxrNb0LdJoXA4AAAAAgHfRwByZKlOmjDmtX7/e7fp169ZJWFiYVKtWLUtbUKuVcuL//u//TNWTTt87fvx4uts1uNLw7M8//3S7XqcHZkdOxwcAAAAAALKHMAqXNGTIENNEXHsz7d+/3/Sd0qPP3X777c7peJeiPZnUli1bsjU1Tvs46ZHxtDeUo5eUq6ioKHPUvNdff930gNq7d69Mnjw522GUji86OtrcP7tTCwEAAAAAQNYRRuGS9GhzTz75pLz33nty3XXXyWuvvSb33XefaQieVe3atZNmzZpJv3795Mcff8zWVq9Tp4488MAD8u2338p3332X7vZHH31Urr/+etO4/MYbb5QjR46YRuqepg1mRPtUafNyXc+2bduyNT4AAAAAAJB1FjtNcyQ2Nla2b99ujiLnqOAJRPpSanWP9lcqSNPONKDShuWlSpVyC9AqVKggEyZM8OnYgJwoqPsyEEzYj4HgwL4MBD72Y//MVqiMQsDTI+49/vjj5k1/4MABmTNnjqxevdpUOQEAAAAAAP9CGIWA9/LLL5ujBA4aNEh69+5telrpVEKdGggAAAAAAPxLqK8HAORWlSpVTEN1AAAAAADg/6iMAgAAAAAAgNcQRgEAAAAAAMBrCKMAAAAAAADgNYRRAAAAAAAA8BrCKAAAAAAAAHgNYRQAAAAAAAC8hjAKAAAAAAAAXkMYVYB0795d6tev7zw1btxYrrnmGnnnnXfy9HFGjx4tAwYMyLflPTlw4IDcfPPN5jk9+uijkpSUJHPmzMnVOgEAAAAAQN4LzYd1wo8NHjzYnFR8fLxs2rRJnnnmGYmKipK77rpLAtW8efPk6NGj8vnnn0uJEiVkyZIlMnHiRBk0aJCvhwYAAAAAAFwQRhUwhQoVkrJlyzovV61aVdasWSOffvppQIdRMTExUrNmTaldu7a5bLfbfT0kAAAAAADgAdP0ckjDjvjkeJ+d8jJsiYyMdLscHR1tqqU6d+4sjRo1kvbt25vLcXFxzmX2798v//d//yctW7aUtm3byogRI+TUqVMe1/+f//xHWrdubaqwcuqPP/4wYVnTpk2la9eu8txzz8n58+fNbTrFb9GiRfL777+b6Yd6/qmnnjK36WUN2wAAAAAAgH+gMioHNAgat2qc7DyzU3ylfsn68lyH58RiseRqPRoQ6ZS2Rx55xK2H07Fjx2T69OlSunRpEwQ9/fTTUqdOHTPtTauQNBjSoOe9994Tq9Uq48aNk8cee0zef/99t/X/97//NVPn3n33XdPPKSd27Ngh99xzjwm/NNg6efKkWa9ON/z4449l2rRpMn78eDNNT89ruHbu3DmZMGGCrFy5UooXL56rbQQAAAAAAPIOYVQOWSR3IZCvzJgxQ2bPnm3Oa5NvPTVr1kz69OnjXKZjx46mkknDJlWlShXTk2nnztTwbenSpXLhwgWZOnWqM+h58cUX5auvvpLExETnel555RUz/U8biV922WU5HvOsWbPMmB544AFzuUaNGjJlyhS58sorZe3ataYySwOosLAw5xTEokWLmp+uUxIBAAAAAIDvEUblgFYjaVVSQkqC+EpESESOqqL69evnPHJdcnKymW6noZFWOi1YsEDCw8PlzjvvlB9++EE+++wz2bdvn/z9999y8OBBqVWrlrmfhlIaCLlWHDVo0MCcHP78808zba5UqVJSsWLFXD3Xbdu2mXE2b9483W27d+82YRQAAAAAAAgMhFE5pEFQZKh7r6VAoAFS9erVnZe14bdepwHUqlWrpEuXLjJ06FDZtWuX9O7dW3r16mX6Ro0dO9Z5n9DQ0Cw1Sn/77bfl8ccfN1VTWsmUUzabzVRuOSqjXGnYBQAAAAAAAgcNzOFshq6hz/bt2+Xnn3+W1157TUaOHCnXX3+9VKtWTf755x/ncto7SiumtC+Tw9atW02jc+3bpOrVq2cqmbSXk/ak+v7773O8pevWrWuqszREc5y0qmvixIly5MgRj/fJbS8tAAAAAACQP6iMKmBiY2PlxIkT5ryGSxoyaaPvcuXKmTBJm5Nr5dPXX39tqo7Onj1rKpz0Po5+UFql9Oabb8qoUaNM03INhjR00gCqQoUKbo+nlVZaYaW3ax+qjJqJ6+NoCJZWmzZtTKNynUaoR9Dr37+/GaOej4+PN9MFM6rMUlu2bDHhWdojBgIAAAAAAN8gjCpgtHm5o4G5HgWvRIkS0qpVK3n55ZclKirKnCZNmmSOSjd//nzTALxr167mKHraR0rpMtpUXCuTtAeVBj26zJNPPunxMceMGSM9e/Y00/Veeuklj8toH6r77rsv3fXLly+Xyy+/XN555x1TrdW3b18TNGlwpo+nPa48adeunWnMruPTx9THBwAAAAAAvmexO+ZeFfBqIZ2e1rBhQ2dFTSDSlzI6OtpUHzFNDQhc7MtA4GM/BoID+zIQ+NiP/TNboWcUAAAAAAAAvIYwCgAAAAAAAF5DGAUAAAAAAACvIYwCAAAAAACA1xBGAQAAAAAAwGsIowAAAAAAAOA1hFEAAAAAAADwGsIoAAAAAAAAeA1hFAAAAAAAALyGMAoAAAAAAABeE+q9h4Kvde/eXQ4dOuS8HBYWJpUrV5Zbb71V7r333jx7nNGjR5vHef/997O0/LRp02T69Olu14WEhEixYsWkRYsW8tRTT0nVqlVztO4BAwaY5zhp0qQMl1m/fr3Y7XZp1apVltYJAAAAAAByjjCqgBk8eLA5qfj4eNm0aZM888wzEhUVJXfddZfPxlWhQgVZuHCh83JSUpJs375dXnjhBXnggQdkyZIlYrFYZMyYMZKSkpKnj33nnXfKxIkTCaMAAAAAAPACwqgc0koae0KC+IolIsKEM9lVqFAhKVu2rPOyVhytWbNGPv30U5+GUVoJ5TouValSJTl37pw8+eST8tdff0mDBg2kaNGiPhsjAAAAAADIPcKoHAZRR8Y8Iwl//SW+EtGgvlR88cUcBVJpRUZGul2Ojo6Wl156SX766Sc5ffq0mS7Xo0cPU5WkFVRq//79Zurb2rVrJTQ0VDp27GhuL126dLr1/+c//5HFixfLrFmzpGnTptkaW3h4uHNKoadpelu2bDFVTfqzTJky8uijj5pl3n33XWnbtq1Z5sKFC2aq33fffWdeu6uuukrGjRtngrn69eubZfR2fS6ZTecDAAAAAAC5RwPznMp9BuQXdJqeToHTvlEOGuZs27bN9HFatmyZCWo0TPr444/N7TExMaaKKjExUd577z0T/Pzzzz/y2GOPpVv/f//7X/n888/NMtkNorQa6s0335QmTZpIzZo1091+7NgxGThwoOkJpZVdGjC98sor6abxffvtt1KuXDlZtGiRGc/SpUtl5syZ5raVK1ean08//bQJ0wAAAAAAQP6iMioHtBpJq5ICcZrejBkzZPbs2c6+THpq1qyZ9OnTx7mMVjm1bt3aWTVUpUoVmTdvnuzcudNc1jBHq42mTp0qxYsXN9e9+OKL8tVXX5mAykGDIQ2J5syZI5dddlmm4zp8+LA0b97ceVnXU6RIEdN0fdSoUWK1ps9NNRzTaXtaeaWVU3Xq1DH9rx588EG35TQEGz58uDlfrVo18/y0kko5pgbqepgCCAAAAABA/iOMyiENgixpprcFgn79+pkjzKnk5GQz3U5DI610WrBggZkWpw29f/jhB/nss89k37598vfff8vBgwelVq1a5n4aStWoUcMZRCnt56Qnhz///FN+//13KVWqlFSsWPGS49LKJcfUOw2mdLqcTqMbMWKEWYcnWr3VuHFj5xQ+pSFaWjpWVzpu16MKAgAAAAAA72GaXgGjQUz16tXNqXbt2qbyaPz48bJjxw5ZtWqV2Gw2GTp0qKl00l5QvXr1MtVULVq0cK5Dr78UDZI+/PBD049K13Upuk7HuNq3b2/6Sx04cEDuv/9+t2qrtE3PdbyXossBAAAAAAD/QBgF09RbabCzfft2+fnnn+W1116TkSNHyvXXX2+mtmlPKMdyOh1OK6b0SHcOW7duNSHS0aNHzeV69eqZaXcadGlPqu+//z5bW1qbkev0O61+ev311z0uo5VYertONXTYsGEDrygAAAAAAH6MMKqAiY2NlRMnTpjT8ePHZd26dTJhwgQzTU7DJA2BtErp66+/NpVJmzdvNo3JdXlHhZL2l9IKK+3lpBVV2n/p2WefNQFUhQoV3B6vS5cu0rt3bxNK6VH6suOKK64wYZg2P9fQKS2dTqjN1MeOHSu7d+82lV0vvPCCuS07/bS0ikvvf+bMmWyNDwAAAAAAZB9hVAGjzcs7depkThr2PPLII+ZodHpUvKioKClfvrzp16Q9o3SK3qOPPmquGzRokLPpty6n0+i055T2oLr33ntNtdSrr77q8TH1KHVavZSV6Xpp6VHuihUrZhqTpz1KXunSpeWdd94xPa1uuOEGczS9O+64w9zm2kfqUgYPHmwatOtRAwEAAAAAQP6y2B1zrwp4tZBOT2vYsKGpkglU+lJq9ZFWLeXkSHuBRkMofb4tW7Z0XvfHH3+YQGrFihVZapwO+KOCti8DwYj9GAgO7MtA4GM/9s9shcooBCztT3X33XfL4sWLzdHxtF/UxIkTpU2bNgRRAAAAAAD4qUsfFg3wUzrVUKcA6tH+tG9U0aJFzdEBtfE6AAAAAADwT4RRCGjaxFxPAAAAAAAgMDBNDwAAAAAAAF5DGAUAAAAAAACvIYwCAAAAAACA1xBGAQAAAAAAwGsIowAAAAAAAOA1hFEAAAAAAADwGsKoAmTAgAFSv359j6fJkyfn6+OOHj3aefnTTz+VTp06SdOmTeW7776TQJL2uQAAAAAAgOwJzebyCHA9e/aUMWPGpLs+KirKa2PQ4KtHjx7y8MMPS6lSpbz2uAAAAAAAwPcIowqYyMhIKVu2rE/HEB0dLa1atZLKlSv7dBwAAAAAAMD7mKYHJ7vdLjNnzjRVS82aNZMbbrhBvvjiC7cttHv3brnvvvukefPmZqrd448/LidOnHDenpiYKBMmTJD27dtLy5Yt5aWXXhKbzWZuO3jwoJkSqJ5++mnp3r27OX/27Fl57rnn5IorrjBT9/r16ydr1qxxrnPatGnSv39/GT58uLRo0cI53XDr1q3OZR566CHzeCkpKeayPma7du3k888/N5cXLFggffr0Meu//PLL5c4775TNmzc7769j0YqtXr16Sdu2bWXt2rWZPhcAAAAAAJAzVEblwuLFi80ptzTQadKkifOyhiRTpkwx52+88UZzcoiLi5P/+7//S3d9XnjllVdkyZIlMm7cOKlVq5b8/vvvMn78eDl37pzcddddcuzYMRPiaKijfZN0LBoU3X777eZ+hQoVkhdffFF++OEHmTRpklSqVEnefvttWbdunVStWlUqVqwoK1euNCGWhlG6Hg2PBg8eLElJSSbs0Wl7c+fOlSFDhsgHH3xgwiOlY7n77rtNuOS4z6+//iqNGjUylzW8unDhggmo9D6bNm0y4+7atavpS/X888+bsWlFloZnL7zwgjzzzDPOsErNmzdPZsyYIUWLFjVhV2bPBQAAAAAA5AxhVC7ExsbKqVOnJLc0iEl72bFefYy01Ut6W9rrs+rLL7+UZcuWuV2nVT+vv/66zJkzR6ZOnWoCHFWtWjU5dOiQzJo1y4RRH374oVSoUMGEOA6vvvqqqUD65ptv5Oqrr5ZFixbJs88+a6qclFYWrV692pwPCQlxThHUwEeDp59++skESDquevXqmdu0SkoDOX3c1157zflYw4YNM/dzVDJpGHX//feb4CksLMxUPGkopWHUihUrzPMqXry4lChRQv7zn//I9ddfb+6r0wNvueUWE1C50jF36NDBnD9//nymzwUAAAAAAOQMYVQuaCVQ6dKlJbc0SEl72bFefQxXFovF3Jb2+qzSEGfkyJHp+kj9/fffkpCQYKq0rNZ/Z28mJyeb6Wrx8fGybds22bVrl5mi50rvp9P39u7da4I01yqviIgIueyyyzIcz86dO03A5AiiHM9RK5i0ispBn7MjiFLdunWTjz/+2IxLQykNxDRk0rBIpxFqyOWoHGvdurUZ3xtvvCF79uyR/fv3y19//ZVuyl316tWd53PyXAAAAAAAwKURRuVCfkyVUxqAaJWSJ3rUu4xuy4rChQu7hS4OR48edVY66RS9tMLDw519mLRaKC0Nig4fPuys3nIVGprx2yztsq7Xu95PAzNXbdq0MWPS3k6//fab6W+lYdT8+fNNNdf27dvNFEKlVVc6rVCnBWrPKe1JpSFY2soo18fQQCy7zwUAAAAAAFwaDcxhaAClQYsGShpWOU5aYaTT5bRaqm7duqbCSHs/OW7XaXA6fU3DnZo1a5rqoT/++MOtsmrHjh0ZbmXtzaS9nfT+DhoArV+/XurUqZPh/bR6THtPLV++XDZu3OhsMq6PpyGUVlpVqVLFLPu///3PTMvT3k863VArpQ4cOOB8LE9y8lwAAAAAAMClEUbBWdmkFUPao0mbemtYs3DhQtNUvFy5cmYZbV6uwZFO89NQRk96hDvt76Thj1Zd6VHvtP/Ut99+a4IrraLSxucZ0UCpYcOGZnqgVjnpfbRiScOpgQMHXnLKofZ10vFpU3GtbNIphDp+PSKgg4ZnGippb6p//vnHVJZps3KlUxA9yclzAQAAAAAAlxZwc470SG8aIGiVS2YOHjxojpimR2HT/kpaGfPII4+YJtrw7KmnnpKSJUuaQOr48eMmxNGm4ffee6+5XQMfDXH0SH933HGH2ZY67U2PfqfNyJWGSlpRpIGSHt2uZ8+eJjTKiK5j9uzZMnnyZHn44YfNa9u4cWMTGGlD8sxoY3E9kp5OHXTQBuTaxNw1jBo7dqx532i4pFP7GjRoIP/973+dQZr2p/Iku88FAAAAAABcmsWe0TwlP6P9irSf0YwZM6Rv376ZhlHaeLp3795So0YNEyhoNcyYMWPMFC0NV9LSI9NpjyGt0MlpY3B/oC9ldHS0mTrn6HkEIPCwLwOBj/0YCA7sy0DgYz/2nuxkKwFRGaVTpDRM0qOgVapU6ZLLL1u2zPQ++uSTT0wwo1PITp06ZaphHnjgAVMdAwAAAAAAAO8LiJ5Rq1evltq1a8uSJUucTakzs27dOmnUqJEJohx0Ktf58+dNSgcAAAAAAADfCIjKKJ1elx1Hjx6VChUquF3naMJ95MgRadasmcf72U+cEHtY2L9XREaKlCyph1ETOXEi/R0qVkz9efKkzg10v61ECZGoKJELF0RiYtxv08qs0qV17qGIp4bYOlbtbXX6tEhCgvttRYuKFCkiEhcncvas+/hDQsQeHp56hLgjR9Kvt0wZPQxd6v30/q4KFxYpViz18fRxXVmtIuXLp57X8eq4XWm/qIiI1Oepz9eVbgPdFrp9dDtltA11++p29rQNz58XOXfO/TZ9PH3clBSR48fTr1fHq+M+dUq7lLvfps9Tn6+HbWi2j24n5Wkbli0rEhoqcuaMSHy8+236uujr42kb6ut58T3ocRvq+0HfF562oZY3arDqaRvqdEzHe93TNtT3r76PPW1Dx/s7o22o69X1e9qGOh4dV2ysSHS05/e3vg+PHs34/e1pGzre33q93u5Kt7tuf6XrTTvD2PH+1vHouDy9v/V56PPJ6P2t20G3h6f3t24/3Y6u8ukzQj+H7KGhYs/otcnhZ4TbNuQzgs8IxWdEvn1GmN/FiYli1/UGyPcIPiNc8D0iFZ8RZl+2Jyen7ssB8j2CzwgP25C/NQr03xrmd3JMjNh1f9XfgwX8bw3Jx+8Rdt0WgRJGaaNx12bTaf3222/O5thZFR8fL8X0zeBCG1GrhLQb00Xihx9KiMsGTWnUSJL69BHLmTMSMWNG+scZPdr8DP/wQ7EePuy+rt69xda4sYSsXy9h333ndltKjRqS1K+feWEjX389/XofecS8ocM++0xC/v7b7bak7t0lpU0bsW7fLuGff+6+3vLlJfa228z5yDfeEEuaN3rCkCFiL1tWQr/+WkI3bXK7LbldO0nu2lWs//wj4R984HabvWhRSXjoIXM+YtYssaT5oEm8806xVasmoStWSOjq1e7rbdpUknv1EsuJE+a+busNCZGEUaNSt+H8+WJNsyMk3nCD2Bo2lJC1ayXshx/cn2udOpJ0yy1m54qcNi39Nhw+3OzUYQsXSsi+fe7b8KqrJKVlS7Fu2SLhS5a43WarVEkS7747dRt6eG0Shg4Ve8mSEvbVVxKydav7c+3UyZyse/ZI+CefuK+3ZElJHDo0dRvOmCGWNGFgQv/+Yq9SRUKXL5fQ3393X2/z5pJ8zTViOXpUIubMcd+G4eGSMGJE6jZ87z2xpvnwS7z5ZrHVrSshq1ZJ2M8/u2/D+vUlqW9f8+EU+eab6bfhyJHmA0Wfi74v3LZhz56S0qyZhGzcKGFff+3+XKtVM+8J/dD0+P5+8EHzYR32+ecS8tdf7uvt0kVSOnQQ665dEv7pp+7rLV1aEu+7L3UbvvWWWNL80koYNEjsFSpI6LJlErphg/s2bN1aknv0EMvBgxJx8UiKzm0YFSUJjz6aug3nzBFrml9MibfdJrZatSR05UpzctuG+fgZEdunj/mMiMrDzwhb+fKSeM89qduQzwg+I/iMyNfPCP3iq7+rom+5RaxnzwbE9wg+I1y2Id8jUt+HfI9I3ZebNpXoXr3EeuhQwHyP4DOCvzVcFfS/NXQ/tiYlyYUrr+RvDcnfz4jz+toESgNzbTauDcYzok3IXY+AN2DAAKlcuXKmDcy1L1RkZKRpeO4QFxdnjs42ffp0ueqqqzw22WpQpowUCvDKqOjw8NQG5p5SYiqjUlEZ5Xf/rUj3/i7g/63Qyqjo0FApXrSoWKiMSt0o/EezQP9HMxA/I/TrVUxiohSrXj31n0MB8D2CyigXVEal4jMitfFxcrIUr1pVLLqfBsD3CD4jPGxDvkcU6O8R5ndyTIwUq1xZLFRGSX5+RsQWLiw7duzIUgNzn4dR2ZWVMGr8+PGyc+dO+cClwkebn1999dWyYMECadq0qdvyHE0PgD/hiB9A4GM/BoID+zIQ+NiPvSc72UpANDDPrtatW8u2bdtMw3LXJuiFCxeWBg0a+HRsAAAAAAAABVlQhFGJiYly4sQJ81NdeeWVUrZsWXnsscdMidj3338vU6dOlcGDB0u4lqQBAAAAAADAJ4IijNqwYYN06tTJ/HQ0K3/nnXfEZrPJbbfdJs8995zceeed8qA2MwMAAAAAAIDP+Pxoetn1/vvvp7uubdu28leao3JVr15dZs+e7cWRAQAAAAAAoEBURiF7vvjiC1MxpkcXbN68udx8883y0UcfZWsdP/74o/yd5jCP+WHXrl2yYsUK5+X69evLokWL8v1xAQAAAABA/iCMKmAWLlwozz77rAmjPvvsM/n000/lxhtvlBdffFGmT5+epXUcOnRIHnjgATmV9tC2+WDo0KGyefNm5+WVK1dKr1698v1xAQAAAABA/gi4aXrInQ8++MBUQt1yyy3O62rVqiXHjh2TuXPnysMPP5ylQ2P6ijamBwAAAAAAgYvKqNw4d07kyBH305kzqbclJ6e/TU8OJ0+mvy0uLvW2CxfS3+aoQrLZUi/rY+fkBbdaTaP36Ohot+vvv/9++fjjj835w4cPy/Dhw6V9+/bSqFEj6dKli7z00kumIfzBgwelR48eZrm7775bpk2bJmvWrDHT5/Q2h7TXDRgwQMaOHSu33nqrtGrVykwV1KMfTp48Wbp37y6NGzeWNm3ayKOPPiqnT58299HrtQpLK7b0/p6m6S1evFiuv/56adq0qVn+zTfflJSUFHObPrYuv2zZMvO4+hi6jON5AgAAAAAA76MyKjfWrxdx6WdkNG0qctNNIjExIjNmpL/P+PGpPxcv1rTE/Ta9n95/61aRpUvdb6tdWxMdkaSk1PV27Zp6yqZ7773XBE0aMGnjdw2G2rVrJ02aNJFixYqZZf7v//7PVCC9++67UrhwYVm+fLlMnDjR9Jfq1q2bLFiwwIQ7GkR17NhRtmzZkqXH1vtpqKUBka7/v//9r+k9NWnSJKlcubJpQv/UU0/JW2+9JWPGjDFTCvv27Wum5el0vbTmzJkjU6ZMkdGjR5txbNy4UZ5//nk5c+aMub+Djl2DsHr16pnnNH78eOnQoYNUrVo129sPAAAAAADkDmFUbrRsqaU67tdFRqb+1GDHQ4DidOONqcGSqxIlUn82aiSSNigJD0/9GRaWut4iRXI05GuvvVYqVKhgpuT9+uuv8tNPP5nra9SoIRMmTDCVUDfccIP07NlTKlasaG4bNGiQzJw504RFV155pZQqVcpcX7x4cRNWZVXDhg2lT58+zssagOl4NBBTGkhpSLRz505zWR8nJCREChUqJCUc28ZlqqCOqX///nLXXXc5n8PZs2dN4DVs2DDnsjp+RzWXBnHz5883wRVhFAAAAAAA3kcYlRtFi6aePG7ZUJGLYY5HZcpkfJsGPBmFPFZr5uvNAj2Knp502t2OHTtMIDVv3jy577775LvvvjMBzzfffCObNm2S/fv3mxDq5MmTZvncqF69uttlDb1WrVolL7/8suzbt0/27Nkje/fudYZTmdGpfDqmlhoIutCpfklJSWZdpUuXNtfV1qqyi4pefL10GQAAAAAA4H30jCpAjh49Ks8995z56egfddlll5lpeTrl7cKFC/Lzzz9Lv3795O233zbT9nSanDY912qq7HD0bXIV6agau2jcuHGmUkmDIe3lpFPurrvuuiytP6Mm6o7ALFTDwIvCHVVlWbg/AAAAAADIX1RGFSAaymjfJp1+pw3LXTn6RWnD8K1bt5opfGUuVm/p1LdTp045AxyLxeJ23zCdOigi58+fd16nlU6Z0b5O2kj8lVdeMT2hHLSiSaflXYqOTU/r1683Uwcd1q1bZ8ZTrVq1dE3aAQAAAACA71EZVYBoDyZtYP7aa6+ZEGj79u1y4MAB00T84YcfNg3NtbG50qPdaTCl4c6DDz5oqpf06HfKERZpb6dz586ZxuB63f/+9z/5559/5JdffjGNwjNTpEgRM2VOm6M7pgJqk3ENwhyPo7QnlQZbOiUvrSFDhpjphVq5pev48ssvzZH3br/9dud0PAAAAAAA4F+ojCpgHnvsMdPo+5NPPjGNvOPj46VSpUqmYbkesU5DJT2inU7be/XVV6V8+fKmckmrqTZv3mzWUbJkSbn55pvN0fA0BHrmmWdM03Dt/aTLNmjQQJ588kl56KGHMhyHVi9pKKZH0tOm5toMXcOwESNGyIwZMyQuLk6ioqJkwIABMnnyZNm1a5cJyFwNHjzYVHu99957pvm6TiXUvlcaUgEAAAAAAP9ksdM8R2JjY02VkB7tLStTxPyVvpQ6NU2DnbRT6QAEDvZlIPCxHwPBgX0ZCHzsx/6ZrTBNDwAAAAAAAF5DGAUAAAAAAACvIYwCAAAAAACA1xBGAQAAAAAAwGsIowAAAAAAAOA1hFEAAAAAAADwGsIoAAAAAAAAeA1hFAAAAAAAALyGMAoAAAAAAABeQxgFAAAAAAAAryGMAgAAAAAAgNcQRgEAAAAAAMBrCKMAAAAAAADgNYRRAAAAAAAA8JpQ7z2U/7LZbOZnXFycBDK73S4JCQkSGxsrFovF18MBkEPsy0DgYz8GggP7MhD42I+9x5GpODKWzBBGiZgAR+3bty+/XxsAAAAAAICgzliKFCmS6TIWu8aEBVxycrJER0dLRESEWK3MXAQAAAAAAMgOrYjSIKp48eISGpp57RNhFAAAAAAAALyGMiAAAAAAAAB4DWEUAAAAAAAAvIYwKojmZr7++uvSuXNnufzyy+W+++6TAwcO+HpYALJoxowZMmDAALfrtm/fLv379zf7dPfu3WXu3LlsT8DPnD17VsaNGyddunSRFi1ayB133CHr1q1z3v7bb7/JTTfdJM2aNZNrr71WvvrqK5+OF4Bnp06dklGjRkm7du2kefPmcv/998vu3budt/M7GQgse/fuNfvyokWLnNexH/sXwqgg8eabb8oHH3wgL7zwgnz00UcmnLr33nslMTHR10MDcAnz58+XV1991e26M2fOyD333CPVqlWTTz/9VB566CF5+eWXzXkA/mPEiBGyYcMGmTp1qtk/GzZsKEOGDJE9e/aYP2SHDh1q/lGkX4ZvvfVWeeKJJ0xABcC/6O/Z/fv3y//+9z9ZuHChREZGyqBBg8xhyvmdDASWpKQkGTlypMTGxjqvYz/2P5m3N0dA0MBp9uzZZofr2rWrue6VV14xX36//fZb6d27t6+HCMCDY8eOybPPPitr1qyRGjVquN32ySefSFhYmDz//PPmSBS1a9d2fkm++eab2Z6AH9B98tdffzX/DGrZsqW5buzYsfLLL7/Il19+aSot6tevL8OHDze36X68bds2eeedd6R9+/Y+Hj0ABz2qduXKlU14XK9ePXPdgw8+KDfccIPs2rXLBMj8TgYCx7Rp06RIkSJu1/Hd2v9QGRUEduzYIRcuXHD7YlusWDG57LLL5Pfff/fp2ABkbOvWrebL7RdffGGm8LjSaT5t2rRxOySqTh3Yt2+fnDx5ks0K+IGSJUuagLhJkybO6ywWiznFxMSY/Tht6KT78fr168Vut/tgxAA80UOQT5kyxRlEnT59WubMmSMVKlSQOnXq8DsZCCD69+/HH38skyZNcrue79b+hzAqCBw9etT8rFixotv15cqVc94GwP9oHyj9z03VqlXT3ab7rn4JTrtPqyNHjnhtjAAypv/4ueKKKyQ8PNx53bJly0zFlFYnZ7QfO6b9APA/Wt2oIbL2d/vPf/4jhQoV4ncyECD0H0E6Hf6ZZ55J97cx3639D2FUENAvtcr1y7CKiIiQhIQEH40KQG7Ex8d73KcV+zXgn/744w956qmn5OqrrzbT5j3tx47L9HQE/NPAgQNN/zdtc6F9pLSKmd/JQGAYP368aVrep0+fdLexH/sfekYFAW2w6Phi6zjv+IM1KirKhyMDkFO6L6f9Y9URQul/aQH4l++//970btQj6unBBhwBctr92HGZ38+Af9JpeUqrojZu3Cjz5s3jdzIQABYvXmym4mnPRk/4bu1/qIwKAo4SxOPHj7tdr5fLly/vo1EByA2d2uNpn1bs14B/0T9WH3nkEenWrZu8/fbbzipG/f3saT/WQLlo0aI+Gi2AtLRHlE7LS05Odl5ntVpNMKX7LL+TAf+nFY164BCtTNbqKD0pPViQHmWe/dj/EEYFgQYNGpijBegRuVzny+oRe1q3bu3TsQHIGd13tclxSkqK87rVq1dLzZo1pXTp0mxWwE/okfReeOEFueuuu2Tq1Klu0/JatWola9eudVte92OtntI/dAH4Bz0wyIgRI8xR81wPDa/fpfUomPxOBvyfViUvXbrUVEg5TmrYsGGm0pH92P/wTSgI6Bff/v37mx1w+fLl5uh6ehhpTX+1bwWAwHPzzTfL+fPnZcyYMfL333/LokWLzJF99LDTAPzD3r17ZcKECXLVVVeZfVP/oD1x4oQ5nTt3TgYMGCCbNm0yv593794ts2fPlm+++cb8hxaA/9Cj6HXp0kVefPFFcySunTt3yujRo80/dwcNGsTvZCAA6MyB6tWru52U/hNXb+O7tf+x2Dm2cFDQ6gn9j6z+warN2TT5HTdunFSpUsXXQwOQBfql99ChQ/L+++87r9M/YvU/Ofqf2bJly8rgwYNN8AzAP+iUvFdeecXjbX379jWHlf7555/lpZdekn379pnfyTqdr1evXl4fK4DMaYA8ZcoU0/9Nz2tlo/5urlu3rrmd38lA4Klfv75MnDhRbrrpJnOZ/di/EEYBAAAAAADAa5imBwAAAAAAAK8hjAIAAAAAAIDXEEYBAAAAAADAawijAAAAAAAA4DWEUQAAAAAAAPAawigAAAAAAAB4DWEUAAAAAAAAvIYwCgAAAAAAAF5DGAUAAJANo0ePlvr162d6GjBggCxatMicP3jwoE+377Jly+TOO+/M0rKJiYly7bXXyp9//pnv4wIAAAWXxW632309CAAAgEDxzz//yOnTp52X33zzTdm2bZtMnz7deV2RIkWkVKlSZtnLLrtMwsPDfTLWU6dOSZ8+fWTmzJnSqFGjLN3n+++/l5deekk+//xziYyMzPcxAgCAgifU1wMAAAAIJNWqVTMnBw2dNGy6/PLL0y2rt/nSW2+9JU2bNs1yEKWuvPJKefXVV+XDDz+Ue+65J1/HBwAACiam6QEAAOSDtNP0dHrfkCFD5OOPPzaBj4ZE/fr1k71798qPP/5oKpiaNWsmt956q2zfvt1tXevWrZP+/fub29u0aSNPPvmkW3WWJ3r7woULpXfv3m7Xv/fee2YqXpMmTaRz584yfvx4OX/+vNsyOpZ3333XTNsDAADIa4RRAAAAXrJhwwaZN2+eCaYmTpwou3fvlvvvv9+cHzp0qEydOlWOHDkiI0eOdN7n999/l0GDBpkpc1qx9PTTT8vatWvl7rvvlvj4+Awf69tvv5Xk5GTp1q2b87olS5aYKXh33XWXzJo1Sx566CEzHe+FF15wu6+GVceOHTOPAwAAkNeYpgcAAOAlFy5cMIFS7dq1zWUNez766COZM2eOtG/f3ly3f/9+mTx5ssTExEixYsVkypQpUrNmTZkxY4aEhISYZbRC6rrrrpNPP/3UBEuerF692jxO4cKFndfp41WpUsXcx2q1miqrQoUKSXR0tNt9q1evLsWLF5fffvtNOnXqlI9bBAAAFERURgEAAHiJBjyOIEqVKVPGGS45lChRwvzUMCouLk42btwoV1xxhegxZ7TSSU9Vq1Y16/n1118zfKwDBw6Y4MlVu3btzLTAm266yTRc37x5s5mSp0f/S6tSpUo+PxIgAAAITlRGAQAAeIkeZc8TrU7yRAMpm81mjoanp7QiIiIyfCztAxUVFeV2Xa9evcz6PvjgA3MUwGnTpknlypXNtEC9zZXeN20vKQAAgLxAGAUAAOCndIqdxWIxPaN0Wl5aacMmVyVLlpRz586lu14bmutJb1u5cqUJuUaNGiUtW7aU8uXLuwVhWh0FAACQ15imBwAA4MeVVJdddpns2bPHHP3Ocapbt66palqzZk2G99UgSZuhu3rsscdM03JVtGhR6dmzpzz44INm6t/x48edy+mUQG1grlVTAAAAeY0wCgAAwI+NGDHCVDA9/vjj8tNPP8kPP/wg9957r2ku3qhRowzv17FjR9m1a5dbdZT2jPr+++9Ng3S9/7Jly+S1116TGjVqSIMGDZzL7dy509yvc+fO+f78AABAwcM0PQAAAD+mR7ObNWuWaTg+bNgwCQsLMyHUu+++K5dffnmG9+vWrZuEhobKL7/84uwH1a9fP0lKSjJH8NO+UZGRkeYofjpNT9fr8PPPP0vZsmWlRYsWXnmOAACgYLHYtQ4bAAAAQeeFF14w1VFz587N8n30q+E111wjd955p+lVBQAAkNeYpgcAABCkHnjgAdmxY4ds2rQpy/f59ttvJSUlxVRRAQAA5AcqowAAAILY0qVLTWWUTs27lMTEROnTp49MmDDBHF0PAAAgPxBGAQAAAAAAwGuYpgcAAAAAAACvIYwCAAAAAACA1xBGAQAAAAAAwGsIowAAAAAAAOA1hFEAAAAAAADwGsIoAAAAAAAAeA1hFAAAAAAAALyGMAoAAAAAAADiLf8PF80B4m5zbFgAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 1200x500 with 1 Axes>"
            ]
          },
          "execution_count": 102,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Plot control signals (optional)\n",
        "plot_control_signals(results)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## Compare Multiple Initial Conditions\n",
        "\n",
        "Run this cell to test the controller with different starting heights."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 103,
      "metadata": {},
      "outputs": [],
      "source": [
        "def compare_initial_conditions(initial_gaps_mm: list, max_steps: int = 2000):\n",
        "    \"\"\"\n",
        "    Compare PID performance across different initial conditions.\n",
        "    \n",
        "    Args:\n",
        "        initial_gaps_mm: List of starting gap heights to test\n",
        "        max_steps: Maximum steps per simulation\n",
        "    \"\"\"\n",
        "    fig, axes = plt.subplots(2, 2, figsize=(14, 10))\n",
        "    fig.suptitle('PID Performance Comparison: Different Initial Conditions', \n",
        "                 fontsize=16, fontweight='bold', y=1.02)\n",
        "    \n",
        "    target_gap_mm = TARGET_GAP * 1000\n",
        "    colors = plt.cm.viridis(np.linspace(0, 0.8, len(initial_gaps_mm)))\n",
        "    \n",
        "    all_results = []\n",
        "    \n",
        "    for i, gap in enumerate(initial_gaps_mm):\n",
        "        print(f\"Running simulation {i+1}/{len(initial_gaps_mm)}: initial_gap={gap}mm\")\n",
        "        data = run_pid_simulation(initial_gap_mm=gap, max_steps=max_steps, gains=gains, verbose=False)\n",
        "        all_results.append((gap, data))\n",
        "        \n",
        "        label = f'{gap}mm'\n",
        "        \n",
        "        # Gap height\n",
        "        axes[0, 0].plot(data['time'], data['gap_avg'], color=colors[i], \n",
        "                        linewidth=2, label=label)\n",
        "        \n",
        "        # Roll\n",
        "        axes[0, 1].plot(data['time'], data['roll_deg'], color=colors[i], \n",
        "                        linewidth=2, label=label)\n",
        "        \n",
        "        # Pitch\n",
        "        axes[1, 0].plot(data['time'], data['pitch_deg'], color=colors[i], \n",
        "                        linewidth=2, label=label)\n",
        "        \n",
        "        # Total current\n",
        "        axes[1, 1].plot(data['time'], data['current_total'], color=colors[i], \n",
        "                        linewidth=2, label=label)\n",
        "    \n",
        "    # Add target line to gap plot\n",
        "    axes[0, 0].axhline(y=target_gap_mm, color='red', linestyle='--', \n",
        "                       linewidth=2, label=f'Target ({target_gap_mm:.1f}mm)')\n",
        "    \n",
        "    # Configure axes\n",
        "    axes[0, 0].set_xlabel('Time (s)')\n",
        "    axes[0, 0].set_ylabel('Gap Height (mm)')\n",
        "    axes[0, 0].set_title('Average Gap Height', fontweight='bold')\n",
        "    axes[0, 0].legend(loc='best')\n",
        "    axes[0, 0].set_ylim([0, 20])\n",
        "    axes[0, 0].grid(True, alpha=0.3)\n",
        "    \n",
        "    axes[0, 1].axhline(y=0, color='gray', linestyle='--', linewidth=1)\n",
        "    axes[0, 1].set_xlabel('Time (s)')\n",
        "    axes[0, 1].set_ylabel('Roll Angle (degrees)')\n",
        "    axes[0, 1].set_title('Roll Angle', fontweight='bold')\n",
        "    axes[0, 1].legend(loc='best')\n",
        "    axes[0, 1].set_ylim([-4, 4])\n",
        "    axes[0, 1].grid(True, alpha=0.3)\n",
        "    \n",
        "    axes[1, 0].axhline(y=0, color='gray', linestyle='--', linewidth=1)\n",
        "    axes[1, 0].set_xlabel('Time (s)')\n",
        "    axes[1, 0].set_ylabel('Pitch Angle (degrees)')\n",
        "    axes[1, 0].set_title('Pitch Angle', fontweight='bold')\n",
        "    axes[1, 0].legend(loc='best')\n",
        "    axes[1, 0].set_ylim([-6, 6])\n",
        "    axes[1, 0].grid(True, alpha=0.3)\n",
        "    \n",
        "    axes[1, 1].set_xlabel('Time (s)')\n",
        "    axes[1, 1].set_ylabel('Total Current (A)')\n",
        "    axes[1, 1].set_title('Total Current Draw', fontweight='bold')\n",
        "    axes[1, 1].legend(loc='best')\n",
        "    axes[1, 1].grid(True, alpha=0.3)\n",
        "    \n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "    \n",
        "    return all_results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 104,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "============================================================\n",
            "Data structure: results (from run_pid_simulation)\n",
            "============================================================\n",
            "Number of time steps: 10000\n",
            "\n",
            "Key                Shape          Dtype        Min        Max       \n",
            "------------------------------------------------------------\n",
            "current_BL         (10000,)       float64      -9.523     10.2      \n",
            "current_BR         (10000,)       float64      -9.365     10.2      \n",
            "current_FL         (10000,)       float64      -9.56      10.2      \n",
            "current_FR         (10000,)       float64      -9.274     10.2      \n",
            "current_total      (10000,)       float64      0.0007697  40.8      \n",
            "ff_pwm             (10000,)       float64      -0.003987  0.6614    \n",
            "gap_avg            (10000,)       float64      9          11.87     \n",
            "gap_back           (10000,)       float64      9          11.88     \n",
            "gap_front          (10000,)       float64      9          11.87     \n",
            "pitch_deg          (10000,)       float64      -0.004836  0.003869  \n",
            "pwm_BL             (10000,)       float32      -0.06742   0.9502    \n",
            "pwm_BR             (10000,)       float32      -0.05246   0.9502    \n",
            "pwm_FL             (10000,)       float32      -0.06965   0.9502    \n",
            "pwm_FR             (10000,)       float32      -0.05447   0.9502    \n",
            "roll_deg           (10000,)       float64      -0.1823    0.2749    \n",
            "time               (10000,)       float64      0          41.66     \n",
            "------------------------------------------------------------\n",
            "\n",
            "Sample (first and last time steps):\n",
            "\n",
            "  Step 0: t = 0.0000 s\n",
            "    gap_avg=9.000 mm  roll=-0.000°  pitch=0.000°\n",
            "    pwm: FL=0.950 FR=0.950 BL=0.950 BR=0.950\n",
            "    ff_pwm=0.661  current_total=40.800 A\n",
            "\n",
            "  Step 5000: t = 20.8333 s\n",
            "    gap_avg=11.860 mm  roll=0.002°  pitch=0.000°\n",
            "    pwm: FL=-0.001 FR=-0.001 BL=-0.001 BR=-0.001\n",
            "    ff_pwm=-0.001  current_total=0.019 A\n",
            "\n",
            "  Step 9999: t = 41.6625 s\n",
            "    gap_avg=10.880 mm  roll=0.000°  pitch=0.003°\n",
            "    pwm: FL=0.426 FR=0.426 BL=0.226 BR=0.226\n",
            "    ff_pwm=0.227  current_total=28.349 A\n"
          ]
        }
      ],
      "source": [
        "# Show simulation results data structure in a readable format\n",
        "def show_data_structure(data: dict, name: str = \"results\", sample_rows: int = 3):\n",
        "    \"\"\"Print keys, shapes, dtypes, and a small sample of the simulation data dict.\"\"\"\n",
        "    print(\"=\" * 60)\n",
        "    print(f\"Data structure: {name} (from run_pid_simulation)\")\n",
        "    print(\"=\" * 60)\n",
        "    n = len(data[\"time\"]) if \"time\" in data else 0\n",
        "    print(f\"Number of time steps: {n}\\n\")\n",
        "    print(f\"{'Key':<18} {'Shape':<14} {'Dtype':<12} {'Min':<10} {'Max':<10}\")\n",
        "    print(\"-\" * 60)\n",
        "    for key in sorted(data.keys()):\n",
        "        arr = data[key]\n",
        "        if isinstance(arr, np.ndarray):\n",
        "            sh = str(arr.shape)\n",
        "            dt = str(arr.dtype)\n",
        "            mn = f\"{np.min(arr):.4g}\" if arr.size else \"—\"\n",
        "            mx = f\"{np.max(arr):.4g}\" if arr.size else \"—\"\n",
        "        else:\n",
        "            sh, dt, mn, mx = \"—\", \"—\", \"—\", \"—\"\n",
        "        print(f\"{key:<18} {sh:<14} {dt:<12} {mn:<10} {mx:<10}\")\n",
        "    print(\"-\" * 60)\n",
        "    print(\"\\nSample (first and last time steps):\")\n",
        "    if n >= 1:\n",
        "        sample_idx = [0, n // 2, n - 1] if n >= 3 else list(range(n))\n",
        "        for i in sample_idx:\n",
        "            t = data[\"time\"][i]\n",
        "            print(f\"\\n  Step {i}: t = {t:.4f} s\")\n",
        "            print(f\"    gap_avg={data['gap_avg'][i]:.3f} mm  roll={data['roll_deg'][i]:.3f}°  pitch={data['pitch_deg'][i]:.3f}°\")\n",
        "            print(f\"    pwm: FL={data['pwm_FL'][i]:.3f} FR={data['pwm_FR'][i]:.3f} BL={data['pwm_BL'][i]:.3f} BR={data['pwm_BR'][i]:.3f}\")\n",
        "            if \"ff_pwm\" in data:\n",
        "                print(f\"    ff_pwm={data['ff_pwm'][i]:.3f}  current_total={data['current_total'][i]:.3f} A\")\n",
        "\n",
        "show_data_structure(results, \"results\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Compare different starting heights\n",
        "# Uncomment and run to test multiple initial conditions\n",
        "\n",
        "# comparison_results = compare_initial_conditions(\n",
        "#     initial_gaps_mm=[10.0, 14.0, 18.0, 22.0],\n",
        "#     max_steps=2000\n",
        "# )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## PID Tuning with Optuna\n",
        "\n",
        "Bayesian-style optimization (Optuna TPE sampler) tunes all **nine** gains (height, roll, pitch × Kp, Ki, Kd) **jointly** so loop coupling is respected.\n",
        "\n",
        "- **Run optimizer** (script or cell below): saves `pid_best_params.json` in this folder.\n",
        "- **Use new params**: re-run the **Load PID gains** cell at the top, then the **PID Gains** cell and the simulation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 106,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Option A: Run Optuna optimization (slow). Saves pid_best_params.json next to optuna_pid_tune.py.\n",
        "# from optuna_pid_tune import run_optimization\n",
        "# study = run_optimization(n_trials=50, timeout=1800)\n",
        "# print(\"Best:\", study.best_params)\n",
        "\n",
        "# After running Optuna: re-run the \"Load PID gains\" cell at the top of the notebook\n",
        "# to pick up the new pid_best_params.json, then re-run the PID Gains cell and the simulation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## Test Disturbance Rejection\n",
        "\n",
        "Apply a sudden force disturbance and observe recovery."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 107,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Test disturbance rejection\n",
        "# Uncomment and run to test disturbance response\n",
        "\n",
        "# Example 1: Impulse disturbance (one-time force)\n",
        "# disturbance_results = run_pid_simulation(\n",
        "#     initial_gap_mm=11.86,         # Start near target\n",
        "#     max_steps=3000,\n",
        "#     use_gui=False,\n",
        "#     disturbance_step=720,        # Apply at 3 seconds\n",
        "#     disturbance_force=-20.0,     # 20N downward push\n",
        "#     verbose=True\n",
        "# )\n",
        "# plot_results(disturbance_results, title_suffix=' (with 20N impulse at t=3s)')\n",
        "\n",
        "# Example 2: Continuous stochastic noise\n",
        "# noisy_results = run_pid_simulation(\n",
        "#     initial_gap_mm=11.86,\n",
        "#     max_steps=3000,\n",
        "#     use_gui=False,\n",
        "#     disturbance_force_std=2.0,   # 2N standard deviation continuous noise\n",
        "#     verbose=True\n",
        "# )\n",
        "# plot_results(noisy_results, title_suffix=' (with 2N std continuous noise)')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "## Summary Statistics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 108,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "==================================================\n",
            "SIMULATION SUMMARY\n",
            "==================================================\n",
            "Duration: 41.66 seconds (10000 steps)\n",
            "Target gap: 11.86 mm\n",
            "\n",
            "Gap Height:\n",
            "  Initial:  9.00 mm\n",
            "  Final:    10.88 mm\n",
            "  Error:    0.980 mm\n",
            "  Max:      11.87 mm\n",
            "  Min:      9.00 mm\n",
            "  Settling time (2%): 0.179 s\n",
            "\n",
            "Orientation (final):\n",
            "  Roll:  +0.000 degrees\n",
            "  Pitch: +0.003 degrees\n",
            "\n",
            "Current Draw:\n",
            "  Average total: 14.15 A\n",
            "  Peak total:    40.80 A\n",
            "==================================================\n"
          ]
        }
      ],
      "source": [
        "def print_summary(data: dict):\n",
        "    \"\"\"Print summary statistics for a simulation run.\"\"\"\n",
        "    target_gap_mm = TARGET_GAP * 1000\n",
        "    \n",
        "    # Calculate settling time (within 2% of target)\n",
        "    tolerance = 0.02 * target_gap_mm\n",
        "    settled_idx = None\n",
        "    for i in range(len(data['gap_avg'])):\n",
        "        if abs(data['gap_avg'][i] - target_gap_mm) < tolerance:\n",
        "            # Check if it stays settled\n",
        "            if all(abs(data['gap_avg'][j] - target_gap_mm) < tolerance \n",
        "                   for j in range(i, min(i+100, len(data['gap_avg'])))):\n",
        "                settled_idx = i\n",
        "                break\n",
        "    \n",
        "    print(\"=\" * 50)\n",
        "    print(\"SIMULATION SUMMARY\")\n",
        "    print(\"=\" * 50)\n",
        "    print(f\"Duration: {data['time'][-1]:.2f} seconds ({len(data['time'])} steps)\")\n",
        "    print(f\"Target gap: {target_gap_mm:.2f} mm\")\n",
        "    print()\n",
        "    print(\"Gap Height:\")\n",
        "    print(f\"  Initial:  {data['gap_avg'][0]:.2f} mm\")\n",
        "    print(f\"  Final:    {data['gap_avg'][-1]:.2f} mm\")\n",
        "    print(f\"  Error:    {abs(data['gap_avg'][-1] - target_gap_mm):.3f} mm\")\n",
        "    print(f\"  Max:      {max(data['gap_avg']):.2f} mm\")\n",
        "    print(f\"  Min:      {min(data['gap_avg']):.2f} mm\")\n",
        "    if settled_idx:\n",
        "        print(f\"  Settling time (2%): {data['time'][settled_idx]:.3f} s\")\n",
        "    else:\n",
        "        print(f\"  Settling time: Not settled within tolerance\")\n",
        "    print()\n",
        "    print(\"Orientation (final):\")\n",
        "    print(f\"  Roll:  {data['roll_deg'][-1]:+.3f} degrees\")\n",
        "    print(f\"  Pitch: {data['pitch_deg'][-1]:+.3f} degrees\")\n",
        "    print()\n",
        "    print(\"Current Draw:\")\n",
        "    print(f\"  Average total: {np.mean(data['current_total']):.2f} A\")\n",
        "    print(f\"  Peak total:    {max(data['current_total']):.2f} A\")\n",
        "    print(\"=\" * 50)\n",
        "\n",
        "# Print summary for last simulation\n",
        "print_summary(results)"
      ]
    }
  ],
  "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.13.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}