{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "6c309f75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device: cuda\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import cv2\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from pathlib import Path\n",
    "from tqdm.auto import tqdm\n",
    "import timm\n",
    "import random\n",
    "from collections import defaultdict\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "print(f\"Device: {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "aaedc169",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Constants\n",
    "TARGET_HEIGHT, TARGET_WIDTH = 1696, 4352\n",
    "ZERO_MV = np.array([703.5, 987.5, 1271.5, 1531.5])\n",
    "MV_TO_PIXEL = 78.5\n",
    "T0, T1 = 235, 4161\n",
    "X0, X1 = 0, 2176\n",
    "Y0, Y1 = 0, 1696\n",
    "OUTPUT_WIDTH = T1 - T0\n",
    "SOFT_ARGMAX_TEMP = 100.0\n",
    "ECG_MV_MIN, ECG_MV_MAX = -7.0, 7.0\n",
    "\n",
    "# Paths\n",
    "STAGE1_DATA_DIR = Path('/data/ecg-digitization/stage1_data/train')\n",
    "CHECKPOINT_PATH = '/data/ecg-digitization/checkpoints/v10_1_efficientnet_b4_latest_remote.pth'\n",
    "\n",
    "# Variants\n",
    "VARIANTS = ['0001', '0003', '0004', '0005', '0006', '0009', '0010', '0011', '0012']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "984f17a5",
   "metadata": {},
   "source": [
    "## V10 Model Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "0225c126",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CoordDecoderBlock(nn.Module):\n",
    "    def __init__(self, in_ch, skip_ch, out_ch, scale=2):\n",
    "        super().__init__()\n",
    "        self.scale = scale\n",
    "        self.conv = nn.Sequential(\n",
    "            nn.Conv2d(in_ch + skip_ch + 2, out_ch, 3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(out_ch),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(out_ch, out_ch, 3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(out_ch),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "\n",
    "    def forward(self, x, skip=None):\n",
    "        x = F.interpolate(x, scale_factor=self.scale, mode='nearest')\n",
    "        if skip is not None:\n",
    "            x = torch.cat([x, skip], dim=1)\n",
    "        b, c, h, w = x.shape\n",
    "        cy, cx = torch.meshgrid(\n",
    "            torch.linspace(-1, 1, h, device=x.device, dtype=x.dtype),\n",
    "            torch.linspace(-1, 1, w, device=x.device, dtype=x.dtype),\n",
    "            indexing='ij'\n",
    "        )\n",
    "        coord = torch.stack([cx, cy]).unsqueeze(0).expand(b, -1, -1, -1)\n",
    "        x = torch.cat([x, coord], dim=1)\n",
    "        return self.conv(x)\n",
    "\n",
    "\n",
    "class ECGNetV10(nn.Module):\n",
    "    def __init__(self, decoder_dims=[256, 128, 64, 32, 16]):\n",
    "        super().__init__()\n",
    "        self.encoder = timm.create_model(\n",
    "            'efficientnet_b4.ra2_in1k', pretrained=False, \n",
    "            features_only=True, out_indices=(0, 1, 2, 3, 4)\n",
    "        )\n",
    "        enc_dims = [24, 32, 56, 160, 448]\n",
    "        \n",
    "        self.dec_blocks = nn.ModuleList()\n",
    "        in_ch = enc_dims[-1]\n",
    "        skip_chs = enc_dims[:-1][::-1] + [0]\n",
    "        while len(decoder_dims) < len(skip_chs):\n",
    "            decoder_dims.append(decoder_dims[-1])\n",
    "        decoder_dims = decoder_dims[:len(skip_chs)]\n",
    "        \n",
    "        for skip_ch, out_ch in zip(skip_chs, decoder_dims):\n",
    "            self.dec_blocks.append(CoordDecoderBlock(in_ch, skip_ch, out_ch))\n",
    "            in_ch = out_ch\n",
    "        \n",
    "        self.seg_head = nn.Conv2d(decoder_dims[-1], 4, 1)\n",
    "        self.reg_head = nn.Sequential(\n",
    "            nn.Conv2d(decoder_dims[-1], 64, 3, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.AdaptiveAvgPool2d((1, None)),\n",
    "        )\n",
    "        self.reg_out = nn.Sequential(\n",
    "            nn.Conv1d(64, 32, 3, padding=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv1d(32, 4, 1),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "    \n",
    "    def forward(self, x):\n",
    "        input_size = x.shape[2:]\n",
    "        enc = self.encoder(x)\n",
    "        d = enc[-1]\n",
    "        skips = enc[:-1][::-1] + [None]\n",
    "        for block, skip in zip(self.dec_blocks, skips):\n",
    "            d = block(d, skip)\n",
    "        if d.shape[2:] != input_size:\n",
    "            d = F.interpolate(d, size=input_size, mode='bilinear', align_corners=False)\n",
    "        seg_logits = self.seg_head(d)\n",
    "        reg_feat = self.reg_head(d).squeeze(2)\n",
    "        reg_coords = self.reg_out(reg_feat)\n",
    "        return seg_logits, reg_coords"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2502fccf",
   "metadata": {},
   "source": [
    "## Load Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "20fed09d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading V10.1 model...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded epoch 67, Training Holdout SNR: 37.32 dB\n"
     ]
    }
   ],
   "source": [
    "print(\"Loading V10.1 model...\")\n",
    "model = ECGNetV10()\n",
    "checkpoint = torch.load(CHECKPOINT_PATH, map_location='cpu', weights_only=False)\n",
    "\n",
    "state_dict = checkpoint['model']\n",
    "if list(state_dict.keys())[0].startswith('module.'):\n",
    "    state_dict = {k[7:]: v for k, v in state_dict.items()}\n",
    "model.load_state_dict(state_dict)\n",
    "model.to(device).eval()\n",
    "\n",
    "epoch = checkpoint.get('epoch', '?')\n",
    "snr = checkpoint.get('holdout_snr_soft', checkpoint.get('snr_soft', 0))\n",
    "print(f\"Loaded epoch {epoch}, Training Holdout SNR: {snr:.2f} dB\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a9bb70f",
   "metadata": {},
   "source": [
    "## Inference Functions\n",
    "\n",
    "**IMPORTANT FINDING**: Training computes SNR over the full 4352-pixel width, including padding regions (0-235 and 4161-4352) where GT is 0.5 (baseline). This inflates SNR to ~24 dB. The actual signal region (T0:T1 = 235:4161) only achieves ~4-5 dB SNR on average."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "6f815693",
   "metadata": {},
   "outputs": [],
   "source": [
    "def soft_argmax(heatmap, temperature=SOFT_ARGMAX_TEMP):\n",
    "    \"\"\"Extract sub-pixel coordinates using soft-argmax.\"\"\"\n",
    "    B, C, H, W = heatmap.shape\n",
    "    y_coords = torch.arange(H, device=heatmap.device, dtype=heatmap.dtype).view(1, 1, H, 1)\n",
    "    weights = F.softmax(heatmap * temperature, dim=2)\n",
    "    return (weights * y_coords).sum(dim=2)\n",
    "\n",
    "\n",
    "def interpolate_nan(signal_1d):\n",
    "    \"\"\"Interpolate NaN values from valid neighbors. Falls back to 0 if all NaN.\"\"\"\n",
    "    valid_mask = np.isfinite(signal_1d)\n",
    "    if valid_mask.all():\n",
    "        return signal_1d\n",
    "    if not valid_mask.any():\n",
    "        return np.zeros_like(signal_1d)\n",
    "    x = np.arange(len(signal_1d))\n",
    "    signal_1d[~valid_mask] = np.interp(x[~valid_mask], x[valid_mask], signal_1d[valid_mask])\n",
    "    return signal_1d\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def process_stage1_image(image_bgr):\n",
    "    \"\"\"Process already-rectified stage1 image.\n",
    "    \n",
    "    Stage1 images are already rectified, so we just need to:\n",
    "    1. Crop to [Y0:Y1, X0:X1] = [0:1696, 0:2176]\n",
    "    2. Resize to TARGET_WIDTH x TARGET_HEIGHT = 4352 x 1696\n",
    "    3. Run model\n",
    "    \"\"\"\n",
    "    h, w = image_bgr.shape[:2]\n",
    "    \n",
    "    # Crop to left region\n",
    "    crop_h = min(h, Y1)\n",
    "    crop_w = min(w, X1)\n",
    "    image_cropped = image_bgr[:crop_h, :crop_w]\n",
    "    \n",
    "    # Resize to model input size\n",
    "    image_resized = cv2.resize(image_cropped, (TARGET_WIDTH, TARGET_HEIGHT), interpolation=cv2.INTER_LINEAR)\n",
    "    \n",
    "    # Normalize to [0, 1]\n",
    "    image_tensor = torch.from_numpy(image_resized.astype(np.float32) / 255.0).permute(2, 0, 1).unsqueeze(0)\n",
    "    image_tensor = image_tensor.to(device)\n",
    "    \n",
    "    with torch.amp.autocast('cuda', dtype=torch.float32):\n",
    "        seg_logits, reg_coords = model(image_tensor)\n",
    "    \n",
    "    # Handle NaN/Inf in model output\n",
    "    seg_has_nan = torch.isnan(seg_logits).any() or torch.isinf(seg_logits).any()\n",
    "    if seg_has_nan:\n",
    "        seg_logits = torch.nan_to_num(seg_logits, nan=0.0, posinf=0.0, neginf=0.0)\n",
    "    \n",
    "    seg_probs = torch.sigmoid(seg_logits.float())\n",
    "    signal_full = soft_argmax(seg_probs).cpu().numpy()[0]  # [4, 4352]\n",
    "    \n",
    "    # Handle NaN in soft_argmax output\n",
    "    for row_idx in range(4):\n",
    "        if not np.isfinite(signal_full[row_idx]).all():\n",
    "            # Try regression head as fallback\n",
    "            reg_signal = reg_coords.float().cpu().numpy()[0] * (TARGET_HEIGHT - 1)\n",
    "            nan_mask = ~np.isfinite(signal_full[row_idx])\n",
    "            if np.isfinite(reg_signal[row_idx]).all():\n",
    "                signal_full[row_idx, nan_mask] = reg_signal[row_idx, nan_mask]\n",
    "            else:\n",
    "                # Interpolate from neighbors\n",
    "                signal_full[row_idx] = interpolate_nan(signal_full[row_idx].copy())\n",
    "                remaining_nan = ~np.isfinite(signal_full[row_idx])\n",
    "                if remaining_nan.any():\n",
    "                    signal_full[row_idx, remaining_nan] = ZERO_MV[row_idx]\n",
    "    \n",
    "    # Extract signal region T0:T1\n",
    "    signal_pixel = signal_full[:, T0:T1]  # [4, OUTPUT_WIDTH]\n",
    "    \n",
    "    # Convert to mV\n",
    "    signal_mv = np.zeros_like(signal_pixel)\n",
    "    for row_idx in range(4):\n",
    "        signal_mv[row_idx] = (ZERO_MV[row_idx] - signal_pixel[row_idx]) / MV_TO_PIXEL\n",
    "    signal_mv = np.clip(signal_mv, ECG_MV_MIN, ECG_MV_MAX)\n",
    "    \n",
    "    return signal_mv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad2e958b",
   "metadata": {},
   "source": [
    "## SNR Calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "3f48abb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_snr(pred_mv, gt_mv):\n",
    "    \"\"\"Compute SNR in dB between prediction and ground truth.\n",
    "    \n",
    "    SNR = 10 * log10(sum(gt^2) / sum((gt - pred)^2))\n",
    "    \"\"\"\n",
    "    # Ensure same length\n",
    "    min_len = min(len(pred_mv), len(gt_mv))\n",
    "    pred = pred_mv[:min_len]\n",
    "    gt = gt_mv[:min_len]\n",
    "    \n",
    "    sig_power = np.sum(gt ** 2)\n",
    "    noise_power = np.sum((gt - pred) ** 2)\n",
    "    \n",
    "    if noise_power < 1e-10:\n",
    "        return 50.0  # Perfect match\n",
    "    if sig_power < 1e-10:\n",
    "        return 0.0  # No signal\n",
    "    \n",
    "    snr = 10 * np.log10(sig_power / noise_power)\n",
    "    return np.clip(snr, -20, 50)\n",
    "\n",
    "\n",
    "# Match Kaggle's lead extraction (from series_to_leads in inference notebook)\n",
    "ROW_LAYOUT = [\n",
    "    ['I', 'aVR', 'V1', 'V4'],\n",
    "    ['II_short', 'aVL', 'V2', 'V5'],  # II_short not used, we use rhythm strip for II\n",
    "    ['III', 'aVF', 'V3', 'V6'],\n",
    "]\n",
    "\n",
    "\n",
    "def extract_leads_from_prediction(pred_mv):\n",
    "    \"\"\"Extract 12 leads from 4-row prediction - matches Kaggle inference exactly.\"\"\"\n",
    "    segment_width = pred_mv.shape[1] // 4\n",
    "    leads = {}\n",
    "    \n",
    "    # Rows 0-2: short leads (4 segments each)\n",
    "    for row_idx in range(3):\n",
    "        for seg_idx, lead_name in enumerate(ROW_LAYOUT[row_idx]):\n",
    "            if lead_name == 'II_short':\n",
    "                continue  # Skip, we use rhythm strip for II\n",
    "            start = seg_idx * segment_width\n",
    "            end = (seg_idx + 1) * segment_width\n",
    "            leads[lead_name] = pred_mv[row_idx, start:end]\n",
    "    \n",
    "    # Row 3: Full rhythm strip (lead II) - THIS IS WHAT KAGGLE USES FOR II\n",
    "    leads['II'] = pred_mv[3]\n",
    "    \n",
    "    return leads\n",
    "\n",
    "\n",
    "def extract_leads_from_gt(csv_path):\n",
    "    \"\"\"Extract 12 leads from ground truth CSV - matches Kaggle format.\"\"\"\n",
    "    df = pd.read_csv(csv_path)\n",
    "    leads = {}\n",
    "    \n",
    "    # All 12 standard leads\n",
    "    for lead in ['I', 'II', 'III', 'aVR', 'aVL', 'aVF', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']:\n",
    "        if lead in df.columns:\n",
    "            leads[lead] = df[lead].dropna().values\n",
    "    \n",
    "    return leads\n",
    "\n",
    "\n",
    "def resample_signal(signal, target_length):\n",
    "    \"\"\"Resample signal to target length.\"\"\"\n",
    "    if len(signal) == target_length:\n",
    "        return signal\n",
    "    x_old = np.linspace(0, 1, len(signal))\n",
    "    x_new = np.linspace(0, 1, target_length)\n",
    "    return np.interp(x_new, x_old, signal)\n",
    "\n",
    "\n",
    "def compute_sample_snr(pred_mv, csv_path):\n",
    "    \"\"\"Compute per-lead SNR and return average - matches Kaggle evaluation.\n",
    "    \n",
    "    Kaggle computes SNR for each lead separately, then averages.\n",
    "    Lead II uses the RHYTHM STRIP (row 3), not the short segment.\n",
    "    \"\"\"\n",
    "    pred_leads = extract_leads_from_prediction(pred_mv)\n",
    "    gt_leads = extract_leads_from_gt(csv_path)\n",
    "    \n",
    "    lead_snrs = []\n",
    "    for lead in ['I', 'II', 'III', 'aVR', 'aVL', 'aVF', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']:\n",
    "        if lead not in pred_leads or lead not in gt_leads:\n",
    "            continue\n",
    "        \n",
    "        pred = pred_leads[lead]\n",
    "        gt = gt_leads[lead]\n",
    "        \n",
    "        # Resample GT to match prediction length\n",
    "        gt_resampled = resample_signal(gt, len(pred))\n",
    "        \n",
    "        snr = compute_snr(pred, gt_resampled)\n",
    "        if np.isfinite(snr):\n",
    "            lead_snrs.append(snr)\n",
    "    \n",
    "    if lead_snrs:\n",
    "        return np.mean(lead_snrs)\n",
    "    return np.nan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fda03ed",
   "metadata": {},
   "source": [
    "## Collect Samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "99e8b88f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total samples available: 977\n",
      "Total variant samples: 8793\n",
      "\n",
      "Samples per variant:\n",
      "  0001: 977\n",
      "  0003: 977\n",
      "  0004: 977\n",
      "  0005: 977\n",
      "  0006: 977\n",
      "  0009: 977\n",
      "  0010: 977\n",
      "  0011: 977\n",
      "  0012: 977\n"
     ]
    }
   ],
   "source": [
    "# Collect all sample directories\n",
    "sample_dirs = sorted([d for d in STAGE1_DATA_DIR.iterdir() if d.is_dir()])\n",
    "print(f\"Total samples available: {len(sample_dirs)}\")\n",
    "\n",
    "# Build list of (image_path, csv_path, variant) tuples\n",
    "all_samples = []\n",
    "for sample_dir in sample_dirs:\n",
    "    csv_path = sample_dir / f\"{sample_dir.name}.csv\"\n",
    "    if not csv_path.exists():\n",
    "        continue\n",
    "    \n",
    "    for variant in VARIANTS:\n",
    "        img_path = sample_dir / f\"{sample_dir.name}-{variant}.png\"\n",
    "        if img_path.exists():\n",
    "            all_samples.append((img_path, csv_path, variant))\n",
    "\n",
    "print(f\"Total variant samples: {len(all_samples)}\")\n",
    "\n",
    "# Count per variant\n",
    "variant_counts = defaultdict(int)\n",
    "for _, _, v in all_samples:\n",
    "    variant_counts[v] += 1\n",
    "print(\"\\nSamples per variant:\")\n",
    "for v in VARIANTS:\n",
    "    print(f\"  {v}: {variant_counts[v]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "56d984c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selected 198 samples for validation\n"
     ]
    }
   ],
   "source": [
    "# Random sample 200 total, stratified by variant\n",
    "N_TOTAL = 200\n",
    "N_PER_VARIANT = N_TOTAL // len(VARIANTS)\n",
    "\n",
    "random.seed(42)\n",
    "selected_samples = []\n",
    "\n",
    "for variant in VARIANTS:\n",
    "    variant_samples = [(p, c, v) for p, c, v in all_samples if v == variant]\n",
    "    n_select = min(N_PER_VARIANT, len(variant_samples))\n",
    "    selected_samples.extend(random.sample(variant_samples, n_select))\n",
    "\n",
    "# Shuffle\n",
    "random.shuffle(selected_samples)\n",
    "print(f\"Selected {len(selected_samples)} samples for validation\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfdc029d",
   "metadata": {},
   "source": [
    "## Run Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "14e73d02",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e574c5fb64f342ca9d8826628fdb78ae",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/198 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Completed with 0 errors\n"
     ]
    }
   ],
   "source": [
    "# Validation loop - compute per-LEAD SNR like Kaggle does\n",
    "results = defaultdict(list)\n",
    "errors = []\n",
    "\n",
    "for img_path, csv_path, variant in tqdm(selected_samples, desc=\"Validating\"):\n",
    "    try:\n",
    "        # Load image (BGR)\n",
    "        image_bgr = cv2.imread(str(img_path))\n",
    "        if image_bgr is None:\n",
    "            errors.append((str(img_path), \"Failed to load image\"))\n",
    "            continue\n",
    "        \n",
    "        # Get prediction (4 rows x OUTPUT_WIDTH)\n",
    "        pred_mv = process_stage1_image(image_bgr)\n",
    "        \n",
    "        # Compute per-lead SNR (matches Kaggle evaluation)\n",
    "        avg_snr = compute_sample_snr(pred_mv, csv_path)\n",
    "        \n",
    "        if np.isfinite(avg_snr):\n",
    "            results[variant].append(avg_snr)\n",
    "            results['all'].append(avg_snr)\n",
    "        \n",
    "    except Exception as e:\n",
    "        errors.append((str(img_path), str(e)))\n",
    "\n",
    "print(f\"\\nCompleted with {len(errors)} errors\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "b1738435",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print errors if any\n",
    "if errors:\n",
    "    print(\"\\nErrors encountered:\")\n",
    "    for path, err in errors[:10]:  # Show first 10\n",
    "        print(f\"  {Path(path).name}: {err}\")\n",
    "    if len(errors) > 10:\n",
    "        print(f\"  ... and {len(errors) - 10} more\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d7fe782",
   "metadata": {},
   "source": [
    "## Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "56c3ee43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================================================\n",
      "V10.1 Validation Results by Variant\n",
      "============================================================\n",
      "Variant    Count    Mean SNR     Std        Min        Max       \n",
      "------------------------------------------------------------\n",
      "0001       22          23.06 dB    2.93     17.61     29.78\n",
      "0003       22          21.56 dB    2.50     16.69     26.80\n",
      "0004       22          19.59 dB    2.19     14.05     23.55\n",
      "0005       22          22.39 dB    2.66     18.22     28.83\n",
      "0006       22          17.85 dB    2.31     14.42     21.80\n",
      "0009       22          19.44 dB    2.34     15.00     23.55\n",
      "0010       22          21.61 dB    1.95     17.02     24.77\n",
      "0011       22          22.30 dB    2.67     14.97     27.40\n",
      "0012       22          18.98 dB    2.46      9.58     21.09\n",
      "------------------------------------------------------------\n",
      "OVERALL    198         20.75 dB    3.00      9.58     29.78\n",
      "============================================================\n"
     ]
    }
   ],
   "source": [
    "print(\"=\"*60)\n",
    "print(\"V10.1 Validation Results by Variant\")\n",
    "print(\"=\"*60)\n",
    "print(f\"{'Variant':<10} {'Count':<8} {'Mean SNR':<12} {'Std':<10} {'Min':<10} {'Max':<10}\")\n",
    "print(\"-\"*60)\n",
    "\n",
    "for variant in VARIANTS:\n",
    "    if variant in results and len(results[variant]) > 0:\n",
    "        snrs = results[variant]\n",
    "        print(f\"{variant:<10} {len(snrs):<8} {np.mean(snrs):>8.2f} dB  {np.std(snrs):>6.2f}    {np.min(snrs):>6.2f}    {np.max(snrs):>6.2f}\")\n",
    "    else:\n",
    "        print(f\"{variant:<10} {'N/A':<8}\")\n",
    "\n",
    "print(\"-\"*60)\n",
    "if 'all' in results and len(results['all']) > 0:\n",
    "    all_snrs = results['all']\n",
    "    print(f\"{'OVERALL':<10} {len(all_snrs):<8} {np.mean(all_snrs):>8.2f} dB  {np.std(all_snrs):>6.2f}    {np.min(all_snrs):>6.2f}    {np.max(all_snrs):>6.2f}\")\n",
    "print(\"=\"*60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "2aa1026a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAB8QAAAMWCAYAAACHgzxRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xl4E+X6//FPutNCkaULW6EKguyLoq0eQUUWOQgu6PGoIAd3UBAVD64HPVo3BL9HBFwAlcNXRQX8uiGyioBahJ+giLIWgUIVaGlL18zvD0jaQrc0bSaZeb+ua65OJs9k7kkzuZ87TzLjMAzDEAAAAAAAAAAAAAAAFhNkdgAAAAAAAAAAAAAAANQFBsQBAAAAAAAAAAAAAJbEgDgAAAAAAAAAAAAAwJIYEAcAAAAAAAAAAAAAWBID4gAAAAAAAAAAAAAAS2JAHAAAAAAAAAAAAABgSQyIAwAAAAAAAAAAAAAsiQFxAAAAAAAAAAAAAIAlMSAOAAAAAAAAAAAAALAkBsSBWrB3715FRETom2++MTsUr/z555+KiorSZ599ZnYoAGBp5A0AgCe+++47hYWFac+ePWaH4pWff/5ZISEh2rJli9mhAIClkTcAAJ4gb8AOGBCHX8jPz9dDDz2k5s2bq169ejr//PO1dOnSctuuXbtWF110kSIjIxUfH697771X2dnZNX7ML7/8UqNHj1bnzp0VHBysNm3aeBz/k08+qfPPP18XXnihx+vW1C+//KKJEyeqe/fuatCggZo1a6bBgwcrNTX1tLYfffSRrr/+ep155pmKjIxU+/btdf/99+vo0aNl2jVp0kS33nqrHnvsMR/tBQDUjJl545lnntEFF1ygmJgYRUREqF27dho/frwyMjKqHT95AwB8y8y8UdrRo0cVGxsrh8OhDz74oNrxP/LII7rhhhvUunXraq/jre+//15jx45Vp06dFBUVpYSEBF133XX69ddfy7RzOp2aO3eurrzySrVq1UpRUVHq3Lmz/v3vfysvL69M244dO2rw4MF6/PHHfbYfAFATZuaNvn37yuFwnDYNHDiw2vGTNwDAt8yuNwoKCvTMM8+oQ4cOioiIUFxcnAYPHqzff/+9WvGTN2ALBuAH/va3vxkhISHGAw88YMyaNctISkoyQkJCjK+//rpMu40bNxoRERFGjx49jBkzZhiPPPKIER4ebgwcOLDGjzly5EgjIiLCSE5ONlq2bGm0bt3ao9gPHTpkhIaGGvPnz/d4v71x//33G2eccYYxevRoY9asWcbzzz9vnHXWWUZwcLCxdOnSMm2bNGlidOnSxXjssceM119/3bj33nuNsLAwo0OHDkZubm6Ztj///LMhyVi2bJkvdwcAPGJm3rj66quNO+64w5g6darxxhtvGPfff78RHR1ttG3b1sjOzq4ydvIGAPiemXmjtHvuuceIiooyJBkLFiyoVuwbN240JBlr1671bKe9dM011xjx8fHGPffcY7z++uvGU089ZcTFxRlRUVHG5s2b3e2OHTtmSDIuuOAC49///rfx2muvGaNGjTKCgoKMvn37Gk6ns8zjfvbZZ4YkY/v27T7dHwDwhJl5o0+fPkbLli2Nd955p8xU3f42eQMAfM/MvFFQUGD069fPiIyMNMaNG2e8+eabxosvvmgMHz7c2LJlS5WxkzdgFwyIw3TffvutIcl44YUX3MuOHz9unHXWWUZSUlKZtoMGDTKaNWtmZGZmupe9/vrrhiRjyZIlNXrMffv2GQUFBYZhGMbgwYM9HhB/6aWXjHr16hnHjh3zaD1vpaamnrbNP/74w4iJiTEuvPDCMstXrFhx2vpvvfWWIcl4/fXXT7uvc+fOxs0331yr8QJAbTE7b5Tngw8+MCQZ//u//1tlW/IGAPiWv+SNzZs3GyEhIcaTTz7p0YD4vffeayQkJJz2QU9d++abb4z8/Pwyy3799VcjPDzcuPHGG93L8vPzjW+++ea09SdPnmxIOu1LVwUFBUajRo2Mxx57rG4CBwAvmZ03+vTpY3Tq1KnG8ZM3AMC3zM4bzz33nBEaGmp8++23NYqfvAG74JTpMN0HH3yg4OBg3X777e5lERERGj16tNatW6e9e/dKkrKysrR06VLddNNNio6OdrcdMWKE6tevr/fff9/jx5Sk5s2bKzQ0tMbxL1q0SOeff77q169fZnnfvn3VuXNn/fzzz7rkkksUGRmpFi1a6Pnnn6/xtkrr1avXadts0qSJ/vKXv2jr1q2nxXKqq666SpJOaytJl19+uf7v//5PhmHUSqwAUJvMzhvlcV1u49RTipeHvAEAvuUveWPcuHG66qqr9Je//MWj+BctWqRLL71UDoejzPI2bdror3/9q9asWaPevXsrIiJCZ555pt5++22PHr8iycnJCgsLK7OsXbt26tSpU5lcEBYWpuTk5NPWryhvhIaGqm/fvlq8eHGtxAkAtc1f8kZRUVG5p9CtCnkDAHzLzLzhdDr18ssv66qrrlLv3r1VVFSk3Nxcj+Inb8AuGBCH6TZu3Kizzz67TBKQpN69e0uSNm3aJEnavHmzioqKdO6555ZpFxYWpu7du2vjxo0eP6a3CgsL9f3336tnz57l3n/kyBENHDhQ3bp105QpU9ShQwc99NBD+vzzz8u0++OPP6o15efnVxlTenq6mjZtWq12kspt26tXLx09elQ//fRTlY8DAL7mD3nDMAz98ccfSk9P19dff617771XwcHB5Q4kl0beAADf84e8sWDBAq1du9bjLznt27dPaWlpFeaN7du369prr9Xll1+uKVOmqFGjRrrlllvKvB87nc5q543CwsJK4zEMQwcPHqyVvLFlyxZlZWVV+TgA4Gv+kDd+/fVXRUVFqUGDBoqPj9djjz1W5Xu0RN4AADOYmTd+/vln7d+/X127dtXtt9+uqKgoRUVFqWvXrlqxYkWVsZM3YCchZgcAHDhwQM2aNTttuWvZ/v373e1KLz+17ddff+3xY3orLS1Nx48fV2JiYrn379+/X2+//bZuvvlmSdLo0aPVunVrvfnmmxo0aJC7XUxMTLW2N2fOHN1yyy0V3v/1119r3bp1evTRR6t8rOeee07BwcG69tprT7vvzDPPlHQioXbu3LlasQGAr/hD3jh48GCZ9i1bttT8+fPVoUOHSmMnbwCA75mdN44fP64HHnhA9913n9q0aaPdu3dXO/ZffvlFkirMG9u2bdPq1avdvzq/7rrr1KpVK82ZM0cvvviipBO5p6L1T7VixYpKv9z13//+V/v27dOTTz5Z5WM9//zzio6OLpO/XM4880w5nU798ssv7g/1AMBfmJ03zjrrLF1yySXq0qWLcnJy9MEHH+jf//63fv31V7333nuVxk7eAADfMzNv/Pbbb5KkqVOnqnHjxpo1a5Yk6ZlnntHAgQP1/fffq2vXrhXGTt6AnTAgDtMdP35c4eHhpy2PiIhw31/6b0VtXfd78pje+vPPPyVJjRo1Kvf++vXr66abbnLfDgsLU+/evbVz584y7ZYuXVqt7XXq1KnC+w4dOqS///3vSkxM1MSJEyt9nPnz5+vNN9/UxIkT1a5du9Pud+3PH3/8Ua24AMCX/CFvNG7cWEuXLlVeXp42btyojz76qFqnMyRvAIDvmZ03nn32WRUWFurhhx/2OPaq8kbHjh3LnII9JiZG7du3L5M34uPjq503unXrVuF9v/zyi8aMGaOkpCSNHDmy0sd55pln9NVXX+nVV1/VGWeccdr95A0A/szsvPHmm2+WaXPzzTfr9ttv1+uvv6777rtPF1xwQYWxkzcAwPfMzBuuz6KOHTumjRs3qlWrVpKkSy+9VG3bttXzzz+vefPmVRg7eQN2woA4TFevXr1yT+mal5fnvr/034rauu735DFrS0XXTG3ZsuVp195o1KiRfvzxxzLL+vXr59X2c3Jy9Ne//lXHjh3TmjVrTrtGbGlff/21Ro8erQEDBujpp58ut41rf06NHQD8gT/kjbCwMPd791//+ldddtlluvDCCxUbG6u//vWvVe4DeQMAfMfMvLF792698MILmj59eqXvtVWpKG8kJCSctqxRo0Y6cuSI+3ZERITXeSM9PV2DBw9Ww4YN3dczrMh7772nRx99VKNHj9Zdd91VbhvyBgB/5g/1xqnuv/9+vf766/rqq68qHRB3IW8AgO+YmTdcfy+88EL3YLh04v3+oosu0tq1a6u1D+QN2AED4jBds2bNtG/fvtOWu04h0rx5c3e70stPbetq58ljeqtJkyaSVCYBlFbRG/epCcZ1vYuqNGzY8LQiqaCgQFdffbV+/PFHLVmypNJT1f6///f/dOWVV6pz58764IMPFBJS/luAa3+qc60OAPA1f8wbycnJatasmf773/9WOiBO3gAA3zMzbzz++ONq0aKF+vbt6z5Vuus9PCMjQ7t371ZCQoKCgoLKjb028kZxcbEyMjLKbXeqxo0bKywsrMyyzMxMDRo0SEePHtXXX39daU5cunSpRowYocGDB2vmzJkVtiNvAPBn/lhvuAY5Dh8+XGk78gYA+J6ZecP1Ny4u7rS2sbGxZa5LXh7yBuyk/Kob8KHu3bvr119/VVZWVpnl3377rft+SercubNCQkKUmppapl1BQYE2bdrkbufJY3orISFB9erV065du7x6nGbNmlVrOvVaUU6nUyNGjNCyZcs0f/589enTp8Jt7NixQwMHDlRsbKw+++yzSn+h4tqfc845x6v9AoC64K95Iy8vT5mZmZW2IW8AgO+ZmTfS0tK0fft2nXnmmUpMTFRiYqJuuOEGSdLdd9+txMTE0x6jtA4dOkiSV3lj79691c4bp/6CJC8vT0OGDNGvv/6qTz75RB07dqxwO99++62uuuoqnXvuuXr//fcr/BKVa3+CgoJ09tln13i/AKCu+GO94To1bUxMTKXtyBsA4Htm5o0uXbooNDS03MHz/fv3kzfIGyiFX4jDdNdee61efPFFvfbaa3rggQcknThtyJw5c3T++ee7vwXbsGFD9evXT/PmzdNjjz2mBg0aSJLeeecdZWdna/jw4R4/prdCQ0N17rnnnpbEPFXTa8Hec889eu+99zRr1ixdffXVFa6Xnp6u/v37KygoSEuWLKkyEW7YsEENGzas9NqzAGAWM/NGTk6OHA6HIiMjy8T04Ycf6siRIzr33HMrjZ28AQC+Z2be+Pe//33adeu2bNmixx57TBMnTlRSUpKioqIqjL1FixZq1aqVV3mjptf0Ky4u1vXXX69169Zp8eLFSkpKqnC9rVu3avDgwWrTpo0++eSTKk/9u2HDBnXq1EkNGzas3k4AgA+ZmTeysrIUHh5e5rqxhmHo3//+tyRpwIABlcZO3gAA3zMzbzRo0EBXXHGFPvnkE/3yyy/uAe6tW7dq7dq1uuOOOyqNnbwBO2FAHKY7//zzNXz4cE2aNEmHDh1S27Zt9dZbb2n37t168803y7R9+umnlZycrD59+uj222/X77//rilTpqh///4aOHBgjR7zxx9/1McffyxJ2r59uzIzM92FRrdu3TRkyJBK4x86dKgeeeQRZWVlKTo6ukbPQU2usTFt2jS9+uqrSkpKUmRkpObNm1fm/quuusr94drAgQO1c+dOTZw4UWvWrNGaNWvc7eLi4nT55ZeXWXfp0qUaMmQI19gA4JfMzBu//fab+vXrp+uvv14dOnRQUFCQUlNTNW/ePLVp00bjxo2rMn7yBgD4lpl546KLLjotnjPOOEOSdN5552nYsGFVxj906FAtXLhQhmHU6H22ptf0u//++/Xxxx9ryJAhOnz48Gl546abbpIkHTt2TAMGDNCRI0f04IMP6tNPPy3T7qyzzirz4VZhYaFWrVqlu+++2+OYAMAXzMwbP/zwg2644QbdcMMNatu2rY4fP66FCxfqm2++0e23366ePXtWGT95AwB8y+zxjWeeeUbLli3TpZdeqnvvvVeS9D//8z9q3LixHn744SrjJ2/ANgzADxw/ftx44IEHjPj4eCM8PNw477zzjC+++KLctl9//bWRnJxsREREGDExMcaYMWOMrKysGj/mnDlzDEnlTiNHjqwy9oMHDxohISHGO++8U2Z5nz59jE6dOp3WfuTIkUbr1q2rfNyqjBw5ssK4JRm7du1yt62sXZ8+fco87tatWw1JxldffeV1jABQV8zKGxkZGcbtt99udOjQwYiKijLCwsKMdu3aGePHjzcyMjKqFTt5AwB8z8x641QrVqwwJBkLFiyoVuw//PCDIcn4+uuvyyxv3bq1MXjw4NPa9+nT57T36pro06dPpfnAZdeuXZW2O7Wm+vzzzw1Jxm+//eZ1jABQV8zKGzt37jSGDx9utGnTxoiIiDAiIyONXr16GTNnzjScTme1YidvAIDvmV1vbNiwwejXr58RFRVlNGjQwBg6dKjx66+/Vit28gbswmEYhuHRCDqA04wePVq//vqrvv76a7ND8dr48eO1evVqbdiwgV/6AUAdIW8AADxx2WWXqXnz5nrnnXfMDsVrw4YNk8Ph0MKFC80OBQAsi7wBAPAEeQN2wIA4UAvS0tJ09tlna9myZbrwwgvNDqfG/vzzT7Vu3Vrvv/++rrjiCrPDAQDLIm8AADzx7bff6i9/+Yt+++03tW7d2uxwamzr1q3q0qWLNm3apM6dO5sdDgBYFnkDAOAJ8gbsgAFxAAAAAAAAAAAAAIAlBZkdAAAAAAAAAAAAAAAAdYEBcQAAAAAAAAAAAACAJTEgDgAAAAAAAAAAAACwJAbEAQAAAAAAAAAAAACWFGJ2ANXhdDq1f/9+NWjQQA6Hw+xwAMASDMPQsWPH1Lx5cwUFWev7UeQNAKh95A0AgCfIGwAAT5A3AACe8DRvBMSA+P79+9WqVSuzwwAAS9q7d69atmxpdhi1irwBAHWHvAEA8AR5AwDgCfIGAMAT1c0bATEg3qBBA0kndio6OtrkaGBZOTlS8+Yn5vfvl6KizI0HqGNZWVlq1aqV+z3WSsgb8DvkGFgAeQOwCXIWagl5A7bGeyngMfIGUAfIR7AwT/NGQAyIu04jEh0dTcJA3QkJkTp2PDHfsKEUGWluPICPWPFUTeQN+B1yDCyEvAFYHDkLtYy8AVvivRSoMfIGUIvIR7CB6uaNgBgQB3wiMlL66SezowAAWBE5BgAQKMhZAOA93ksBAP6AfAS4VX2VcQAAAAAAAAAAAAAAAhAD4gAAAAAAAAAAAAAAS+KU6YBLbq503nkn5r//3pLX0yguLlZhYaHZYcBHQkNDFRwcbHYYAKSAzTHkDXshb1TO6XSqoKDA7DDgQ7Y9JgI0ZwGAX+G9tFqoN+zFtn0rwEwWy0fkDXup7bzBgDjgYhjSzz+XzFuIYRhKT0/X0aNHzQ4FPnbGGWcoPj5eDofD7FAAewuwHEPesC/yRvkKCgq0a9cuOZ1Os0OBj9nymAiwnAUAfon30kpRb9iXLftWgJksko/IG/ZVm3mDAXHABlzJIjY2VpGRkXQ6bcAwDOXm5urQoUOSpGbNmpkcEYBAQt6wH/JGxQzD0IEDBxQcHKxWrVopKIirTtkBxwQAAHWHesN+6FsB8AZ5w37qIm8wIA5YXHFxsTtZNGnSxOxw4EP16tWTJB06dEixsbGclgpAtZA37Iu8Ub6ioiLl5uaqefPmigzw08vBMxwTAADUPuoN+6JvBaAmyBv2Vdt5g583ABbnuqYGH+Dak+v/zrVVAFQXecPeyBunKy4uliSFhYWZHAnMwDEBAEDtot6wN/pWADxF3rC32swbHg2Iz5gxQ127dlV0dLSio6OVlJSkzz//vNJ1FixYoA4dOigiIkJdunTRZ5995lXAAGqG04jYk7/935999lk5HA6NHz++0nbkDsB8/vb+Ad8w+//uz/WG2c8NzMH/HQgs1BtA4CDH2pPZ/3d/rjcAVM7s9w+Yozb/7x4NiLds2VLPPvusNmzYoNTUVF166aUaOnSofvrpp3Lbr127VjfccINGjx6tjRs3atiwYRo2bJi2bNlSK8EDAALH999/r1mzZqlr166VtiN3AIB9UW8AAGqKegMAUBXqDQCwL48GxIcMGaIrrrhC7dq109lnn62nn35a9evX1/r168tt//LLL2vgwIF68MEHdc455+ipp55Sz5499corr9RK8ECtcjik1q1PTHzbCKhV2dnZuvHGG/X666+rUaNGlbYld8CSyDFAtVBvAH6AnIUARL0Bv8N7KeCXqDdgO+QjwK3G1xAvLi7Wu+++q5ycHCUlJZXbZt26derXr1+ZZQMGDNC6desqfez8/HxlZWWVmQBPZGRkaMeOHZ5NBw5ox7Jl2rFsmbbu2eP5+ienjIwMs3ffMm655RY5HA7deeedp903ZswYORwO3XLLLb4PrAqFhYV66KGH1KVLF0VFRal58+YaMWKE9u/fX6bdlVdeqYSEBEVERKhZs2a6+eabT2tzqtdee019+/ZVdHS0HA6Hjh49Wod7UnvGjBmjwYMHn5YTylOT3EHegN+LjJR27z4xnXLNoxrlLPJOuayeN55++mklJycrMjJSZ5xxRrUff+vWrbryyivVsGFDRUVF6bzzzlNaWlot70Xto97wTqAeD5L00UcfqX///mrSpIkcDoc2bdp0WpsdO3boqquuUkxMjKKjo3Xdddfp4MGDVT72vn37dNNNN6lJkyaqV6+eunTpotTU1DrYi8p5897v7ft+ldsuVRftOHDAt9sm56GGqDfgdyrp/9eEmXkDJQK1f1WdemP37t0aPXq0EhMTVa9ePZ111ll64oknVFBQUK1tGIahQYMGyeFwaNGiRXW0J7WLeiMw8P7npVrOR/BMoOYNqeq6fPfu3XI4HOVO//3vf5WXl1futGfPHt18881q1qyZIiMjNWDAAP32228+2acQT1fYvHmzkpKSlJeXp/r162vhwoXq2LFjuW3T09MVFxdXZllcXJzS09Mr3UZKSoomT57saWiApBNJ8qZRt+rwsdwarV9YUKB9aXvUsnWiQkI9PkTUuEGk5s15QzExMTXaPspq1aqV3n33XU2dOlX16tWTJOXl5Wn+/PlKSEgwObry5ebm6ocfftBjjz2mbt266ciRIxo3bpyuvPLKMh+4XnLJJXr44YfVrFkz7du3Tw888ICuvfZarV27ttLHHjhwoAYOHKhJkyb5Yne89u677+qHH37Q999/X632Nckd5A0EKm9zlkTeOZWV80ZBQYGGDx+upKQkvfnmm9V67B07duiiiy7S6NGjNXnyZEVHR+unn35SREREXe2O16g3ak8gHg+SlJOTo4suukjXXXedbrvttnLv79+/v7p166bly5dLkh577DENGTJE69evV1BQ+d/7PnLkiC688EJdcskl+vzzzxUTE6Pffvutyl+T1jZv3/u9ed8P5G17u31YF/UGrM7M926cLhD7V9WpN3755Rc5nU7NmjVLbdu21ZYtW3TbbbcpJydHL774YpXbmDZtWsBc35d6I3Dw/gcrCMS8IVVdl7dq1UoHDhxQYWGh0vb+rqJipxa8/57mzH5TZ3foqJ27T/8hhmEYuvGGvykkJETT/uc/ql+/vt55a6769eunn3/+WVFRUXW6Tx6P9rVv316bNm1SZmamPvjgA40cOVKrVq2qMGnUxKRJkzRhwgT37aysLLVq1arWHh/WlpWVpcPHchWTdI2iGsdVvcIpDu3Yop27Z6tR76Fq0ry1R+vmHD6ojHUfKisri0RbS3r27KkdO3boo48+0o033ijpxLeTEhISlJiYWKat0+nUc889p9dee03p6ek6++yz9dhjj+naa6+VdOKbn7fffruWL1+u9PR0JSQk6O6779a4cePcj3HLLbfo6NGjuuiiizRlyhQVFBTob3/7m6ZNm6bQ0NBqxdywYUMtXbq0zLJXXnlFvXv3VlpamjvR3Xfffe77W7durX/+858aNmyYCgsLK9zW+PHjJUkrV66sVixm27t3r8aNG6elS5fW6eALeQOBytucRd45nZXzhusDlblz51b7+XjkkUd0xRVX6Pnnn3cvO+uss6q9vhmoN2pPIB4PknTzzTdLOvGN8/J888032r17tzZu3Kjo6GhJ0ltvvaVGjRpp+fLlFf5C9LnnnlOrVq00Z84c97JTnwdf8Oa939v3/UDddm1sH9ZEvQE7MPO9G6cLxP5VdeoN148vXM4880xt27ZNM2bMqHJAfNOmTZoyZYpSU1PVrFmzasVkJuqNwMH7H6wgEPOGVHVdHhwcrPj4eOXl5elYznGF1j9Dy1eu1BVDr1LjFm3KXWfXju36f/9vkz5b+Y3Obn+OnEWFevTxNrq078X63//9X916663Vjq8mPB4QDwsLU9u2bSVJvXr10vfff6+XX35Zs2bNOq1tfHz8aaetO3jwoOLj4yvdRnh4uMLDwz0NDSgjqnGcomNbVrt9aEGeHkq5Q4V5ObrIkCIbxXi0vktAnYglJ6fi+4KDpdIfKFTWNihIOvntpkrb1vAbPv/4xz80Z84cd8KYPXu2Ro0addqgcEpKiubNm6eZM2eqXbt2Wr16tW666SbFxMSoT58+cjqdatmypRYsWKAmTZpo7dq1uv3229WsWTNdd9117sdZsWKFmjVrphUrVmj79u26/vrr1b17d/c3of71r39p7ty5FSaD8mRmZsrhcFR4itvDhw/rv//9r5KTkz1KTP5uw4YNOnTokHr27OleVlxcrNWrV+uVV15Rfn6+goODy6xTk9xB3oDfO35cuvjiE/OrV5d9z5TnOas0n+YdX+YNL74Vaoe8UR1Op1OffvqpJk6cqAEDBmjjxo1KTEzUpEmTNGzYsBo/bl0LmHqDfpTPjodT5efny+FwlPkfRkREKCgoSGvWrKlwQPzjjz/WgAEDNHz4cK1atUotWrTQ3XffXe633X2hpu/9tfG+X9m2XXWRJD03aZYKw0pey3W97aoEVK0Fn6DegN+qov9fE2bmDZ+hf+VX9UZmZqYaN25c6ePk5ubq73//u6ZPn15lH9xfBEy9ATdbvP/VlTrIR36FvGFaXX6qn3/6SVu3bNZTz01VcEhYuW2Kip2SpMjIBu42QUFBCgsL05o1a+p8QLzG1xB3cTqdys/PL/e+pKQkLVu2rMyypUuXVnhNDsBMDsNQ4u6tOjs9TUGG2dH4SP36FU/XXFO2bWxsxW0HDSrbtk2b8tvV0E033aQ1a9Zoz5492rNnj7755hvddNNNZdrk5+frmWee0ezZszVgwACdeeaZuuWWW3TTTTe5O7ShoaGaPHmyzj33XCUmJurGG2/UqFGj9P7775d5rEaNGumVV15Rhw4d9Ne//lWDBw8u817WtGlTj35dl5eXp4ceekg33HCD+1dMLg899JCioqLUpEkTpaWlafHixZ4+PX7tsssu0+bNm7Vp0yb3dO655+rGG2/Upk2bTvtwSiJ3wKKcTik19cTkdJodTc35Mm94wcp5wxOHDh1Sdna2nn32WQ0cOFBffvmlrrrqKl199dVatWpVjR/X1/y23qAf5ZPjoTwXXHCBoqKi9NBDDyk3N1c5OTl64IEHVFxcrAMHDlS43s6dOzVjxgy1a9dOS5Ys0V133aV7771Xb731llfxWI2rLkrcvVUOwy6FEQIV9Qb8llX6/75G/8pv6o3t27frP//5j+64445KH+u+++5TcnKyhg4dWu3t+xu/rTeA2mD1fETeMK0uP9X7/ztPbc9ur169L6iwzVnt2qt5y1Z6/t9PKPPoERUUFOiN11/Tvn37Kq3la4tHvxCfNGmSBg0apISEBB07dkzz58/XypUrtWTJEknSiBEj1KJFC6WkpEiSxo0bpz59+mjKlCkaPHiw3n33XaWmpuq1116r/T0BYFkxMTEaPHiw5s6dK8MwNHjwYDVt2rRMm+3btys3N1eXX355meUFBQXq0aOH+/b06dM1e/ZspaWl6fjx4yooKFD37t3LrNOpU6cyH5w0a9ZMmzdvdt8eO3asxo4dW63YCwsLdd1118kwDM2YMeO0+x988EGNHj1ae/bs0eTJkzVixAh98sknAXPdpao0aNBAnTt3LrPM9QUA13JyB4DaZuW84QnnyWJ36NCh7st0dO/eXWvXrtXMmTPVp08frx6/LlBv1L5APh4q26cFCxborrvu0v/8z/8oKChIN9xwg3r27Fnh9cOlE8fEueeeq2eeeUaS1KNHD23ZskUzZ87UyJEjvYoJgDmoNwCYIZD7V9WpN/bt26eBAwdq+PDhlZ5J5+OPP9by5cu1cePGam3bH1BvADBDIOeN6sjLy9P/LfxA99z/z0rbhYaGaubc+Xpo3N3q3q6VgoODdUFSkgYMGOCT8RCPBsQPHTqkESNG6MCBA2rYsKG6du2qJUuWuP9BaWlpZT6ASE5O1vz58/Xoo4/q4YcfVrt27bRo0aLTihUAJsnOrvi+U79Jf+hQxW1P/eCxFk+14fKPf/zD/SY9ffr00+7PPrkvn376qVq0aFHmPtcpit5991098MADmjJlipKSktSgQQO98MIL+vbbb8u0P/WU5Q6Hwz2o4AlXkbFnzx4tX7683G/dNm3aVE2bNtXZZ5+tc845R61atdL69ett9U1TcgcQQMgbpucNTzRt2lQhISGnXQvvnHPO0Zo1a7x67LoSUPUGx0OdHg9V6d+/v3bs2KE//vhDISEhOuOMMxQfH68zzzyzwnWaNWtW7vHw4Ycf1np8APyHX+UOAJWjf2V6vbF//35dcsklSk5OrnLQd/ny5dqxY8dpp12/5ppr9Je//OW0UwH7g4CqNwBUjbxhal3u8uWSL5R3/Liuvu6GKtt26dZDn61cp6ysTOXl5qh+iKGRN9+o3r1711l8Lh4NiL/55puV3l9ekhs+fLiGDx/uUVAAfMSTa17UVdtqGjhwoAoKCuRwODRgwIDT7u/YsaPCw8OVlpZW4S/evvnmGyUnJ+vuu+92L9uxY0etxyqVFBm//fabVqxYoSZNmlS5jispVXSaJqs4NVeQO4AAQt7wq7xRlbCwMJ133nnatm1bmeW//vqrWrdu7fXj14WAqjc4HursePCE61v1y5cv16FDh3TllVdW2PbCCy8MqOMBQM1QbwABjP6VqfXGvn37dMkll6hXr16aM2dOpWfekaR//vOfp13vtUuXLpo6daqGDBlSq/HXloCqNwBUjbzhF3X5Rx9+qEv7D1STpjHVXic6uqGiIuvp103f64cfftDTTz9dhxGe4NGAOACYJTg4WFu3bnXPn6pBgwZ64IEHdN9998npdOqiiy5SZmamvvnmG0VHR2vkyJFq166d3n77bS1ZskSJiYl655139P333ysxMdGjWF555RUtXLjwtGsIuRQWFuraa6/VDz/8oE8++UTFxcVKT0+XJDVu3FhhYWH69ttv9f333+uiiy5So0aNtGPHDj322GM666yz3L8O37dvny677DK9/fbb7m9IpaenKz09Xdu3b5ckbd68WQ0aNFBCQoIaN27s0X4AgJVZLW9IJ36tcPjwYaWlpam4uFibNm2SJLVt21b1T17LqkOHDkpJSdFVV10l6cSlOa6//npdfPHFuuSSS/TFF1/o//7v//zy1xqoO4F0PEhyv873798vSe5B7Pj4eMXHx0uS5syZo3POOUcxMTFat26dxo0bp/vuu0/t27d3P85ll12mq666yv0tfNc1Lp955hldd911+u677/Taa69xyksAAOCxQOpfVafe2Ldvn/r27avWrVvrxRdfVEZGhnt9V//r1M+pSvfNSktISPB4HwDA6gIpb0jVq8ulEwPyqanf641575X7OJcl9dDERydrwOATX17/dPFHatK0qZq3aKWft/w/PfXIQxoyZIj69+/v0T7UBAPiAAJGVaeOfeqppxQTE6OUlBTt3LlTZ5xxhnr27KmHH35YknTHHXdo48aNuv766+VwOHTDDTfo7rvv1ueff+5RHH/88Uel37zat2+fPv74Y0k67fodK1asUN++fRUZGamPPvpITzzxhHJyctSsWTMNHDhQjz76qPsUKIWFhdq2bZtyc3Pd68+cOVOTJ09237744oslnfhQ+JZbbvFoPwDA6qyUNyTp8ccf11tvveW+z3UNqdJttm3bpszMTHebq666SjNnzlRKSoruvfdetW/fXh9++KEuuugij/YBgS9QjgfpxPUoR40a5b79t7/9TZL0xBNP6F//+pekE6/1SZMm6fDhw2rTpo0eeeQR3XfffWUex3VKdZfzzjtPCxcu1KRJk/Tkk08qMTFR06ZN04033ujRPgAAAEiB07+qTr2xdOlSbd++Xdu3b1fLli3LtDEMQ1L5n1MBAKovUPKGVL26XJLeeustxcXH6y99Ly33cXZu/03HsrLctw8dTNfTj0/SHxmHFBMbpyFXXqnnn3vWo/hrymG4Mpofy8rKUsOGDZWZmen1tRRhfTt27NDf/nGn2gy+W9GxLate4aSw/ON6/oGhchYXqX2Dxjr37mcU1/psj7addeh37f70Vb07e6bOOussT0OvE3l5edq1a5cSExMVERFhdjjwscr+/1Z+b7XyviFA5eRIbdqcmN+9233qpZrmLJe6yDvkDXsjb5y+bxwT9lYX/39v3vu9fd+vzrZddZEkTXxxsQrC6/ls25Xxx1oLlbNr3gAkVdj/rwkz80ZdoG9lb9Qb1tu3umS19z9T1GI+Mgt5w7/l5eVp5+40hZ8Ro+CQMI/WLS4qUP7RDJ3ZJqHC/21t5g1+IQ6cVBBeT+P/86X2b01V7tvPmx0OAMBKoqKkUqecAwDAX7nqIgCAF+j/AwD8AfkIcAsyOwAAAAAAAAAAAAAAAOoCA+IAAAAAAAAAAAAAAEvilOnASaEFeRr/0ngV5B5TP8NpdjgAACs5flwaNOjE/OefS/XqmRsPAAAVcNVFkjRtwjQVhnGdPgDwGP1/AIA/IB8BbgyIAyc5DEMdtv0gSQqKTTA5GgCApTid0qpVJfMAAPip0nWRwzBMjgYAAhT9fwCAPyAfAW6cMh2wCScJz5b4vwOoKd4/7In/e8UMBgZtiWMCAIC6QY61J/7vAGqK9w97qs3/O78QBywuLCxMQUFB2r9/v2JiYhQWFiaHw2F2WKhjhmGooKBAGRkZCgoKUlhYmNkhAQgQ5A17Im9ULDQ0VA6HQxkZGYqJieF4sAmOCQAA6gb1hj3RtwJQU+QN/5afny+ns1jFhQWShz8kKC4qlNNZrPz8/NPuq4u8wYA4YHFBQUFKTEzUgQMHtH//frPDgY9FRkYqISFBQUGcEARA9ZA37I28cbrg4GC1bNlSv//+u3bv3m12OPAxjgkAAGoX9Ya90bcC4Cnyhn8rLCzUH38eVkhWroKCgz1a11lcrKLjx+QsKlRoaGi5bWozbzAgDthAWFiYEhISVFRUpOLiYrPDgY8EBwcrJCSEb8wB8Bh5w57IGxWrX7++2rVrp8LCQrNDgQ9xTAAAUDeoN+yJvhWAmiJv+K+0tDS99OpratHnBtVvEu/Rutl/pmvfqv/VS0//SwkJCafdX9t5gwFxwCYcDodCQ0Mr/KYNAAClkTeAsoKDgxXs4bedAQAAUD7qDQCAJ8gb/ik4OFgHD2WoXm6Riup7tm5WbpEOHspQcHCwIiIi6ibAUhgQB0rJD4uQYTjNDgMAYEWRkWZHAABAteSH1f2HEQBgefT/AQD+gHwESGJAHHArCK+nu2et1v6tqcp9+3mzwwEAWElUlJSTY3YUAABUyVUXAQC8QP8fAOAPyEeAm/dXIQcAAAAAAAAAAAAAwA8xIA4AAAAAAAAAAAAAsCROmQ6cFFKYrzGv/FN52Uc1mOuIAwBqU16edM01J+Y//FCK4NqsAAD/5KqLJGn62GdVFBpuckQAEIDo/wMA/AH5CHBjQBw4KcjpVNcfv5EkBccmmBwNAMBSioulzz4rmQcAwE+VrouCnHxRGABqhP4/AMAfkI8AN06ZDgAAAAAAAAAAAACwJAbEAQAAAAAAAAAAAACWxIA4AAAAAAAAAAAAAMCSGBAHAAAAAAAAAAAAAFgSA+IAAAAAAAAAAAAAAEtiQBwAAAAAAAAAAAAAYEkhZgcA+IuC8HoaPec77d+aqty3nzc7HACAlURFSYZhdhQAAFTJVRcBALxA/x8A4A/IR4AbvxAHANSZGTNmqGvXroqOjlZ0dLSSkpL0+eefV9h+7ty5cjgcZaaIiAgfRgwAAAAgUFBvAAAAAKgOfiEOAKgzLVu21LPPPqt27drJMAy99dZbGjp0qDZu3KhOnTqVu050dLS2bdvmvu1wOHwVLgAAAIAAQr0BAAAAoDoYEAdOCinM122vPaHjx47oasNpdjiAJQwZMqTM7aefflozZszQ+vXrK/yAyuFwKD4+3hfhAb6TlyfdfPOJ+XfekfglEgDAT7nqIkl6/fbJKgoNNzkioGLUG/Bb9P8BAP6AfAS4ccp04KQgp1Pnpi7XX7ZtVDCX1QBqXXFxsd59913l5OQoKSmpwnbZ2dlq3bq1WrVqpaFDh+qnn36q8rHz8/OVlZVVZgL8SnGx9MEHJ6biYrOjAQCgQq666NzU5Qpy8kVhBA7qDfgV+v8AAH9APgLcGBAHANSpzZs3q379+goPD9edd96phQsXqmPHjuW2bd++vWbPnq3Fixdr3rx5cjqdSk5O1u+//17pNlJSUtSwYUP31KpVq7rYFQAAAAB+hnoDAAAAQFUYEAcA1Kn27dtr06ZN+vbbb3XXXXdp5MiR+vnnn8ttm5SUpBEjRqh79+7q06ePPvroI8XExGjWrFmVbmPSpEnKzMx0T3v37q2LXQEAAADgZ6g3AAAAAFSFa4gDAOpUWFiY2rZtK0nq1auXvv/+e7388stVfugkSaGhoerRo4e2b99eabvw8HCFh3N9SwAAAMBuqDcAAAAAVIVfiAMAfMrpdCo/P79abYuLi7V582Y1a9asjqMCAAAAYAXUGwAAAABOxS/EAQB1ZtKkSRo0aJASEhJ07NgxzZ8/XytXrtSSJUskSSNGjFCLFi2UkpIiSXryySd1wQUXqG3btjp69KheeOEF7dmzR7feequZuwEAAADAD1FvAAAAAKgOBsQBAHXm0KFDGjFihA4cOKCGDRuqa9euWrJkiS6//HJJUlpamoKCSk5WcuTIEd12221KT09Xo0aN1KtXL61du1YdO3Y0axcAAAAA+CnqDQAAAADVwYA4cFJBWITumrlKB375Qbn/O83scABLePPNNyu9f+XKlWVuT506VVOnTq3DiACTREZK2dkl8wAA+ClXXeSaB/wZ9Qb8Fv1/AIA/IB8BbgyIAy4OhwrC6yk/LFxyOMyOBgBgJQ6HFBVldhQAAFTtZF0EAPAC/X8AgD8gHwFuQVU3KZGSkqLzzjtPDRo0UGxsrIYNG6Zt27ZVus7cuXPlcDjKTBERfMscAAAAQFnUGwAAAADqCvUGANiXRwPiq1at0pgxY7R+/XotXbpUhYWF6t+/v3JycipdLzo6WgcOHHBPe/bs8SpooC6EFBboH29M1oTP3laYYZgdDgDASvLzpVtuOTHl55sdDeC3qDcA87nqon+8MVkhhQVmhwMAgYn+P+CXqDdgO+QjwM2jU6Z/8cUXZW7PnTtXsbGx2rBhgy6++OIK13M4HIqPj69ZhICPBDmLdeE3n0qSQmITTI4GAGApRUXSW2+dmJ8+XQoPNzcewE9RbwDmK10Xzbt5osnRAECAov8P+CXqDdgO+Qhw8+gX4qfKzMyUJDVu3LjSdtnZ2WrdurVatWqloUOH6qeffvJmswAAAABsgHoDAAAAQF2h3gAA+6jxgLjT6dT48eN14YUXqnPnzhW2a9++vWbPnq3Fixdr3rx5cjqdSk5O1u+//17hOvn5+crKyiozAQAAALAP6g0AAAAAdYV6AwDsxaNTppc2ZswYbdmyRWvWrKm0XVJSkpKSkty3k5OTdc4552jWrFl66qmnyl0nJSVFkydPrmloAAAAAAIc9QYAAACAukK9AQD2UqNfiI8dO1affPKJVqxYoZYtW3q0bmhoqHr06KHt27dX2GbSpEnKzMx0T3v37q1JmAAAAAACEPUGAAAAgLpCvQEA9uPRL8QNw9A999yjhQsXauXKlUpMTPR4g8XFxdq8ebOuuOKKCtuEh4crPDzc48cGAAAAELioNwAAAADUFeoNALAvjwbEx4wZo/nz52vx4sVq0KCB0tPTJUkNGzZUvXr1JEkjRoxQixYtlJKSIkl68skndcEFF6ht27Y6evSoXnjhBe3Zs0e33nprLe8KAAAAgEBGvQEAAACgrlBvAIB9eTQgPmPGDElS3759yyyfM2eObrnlFklSWlqagoJKzsR+5MgR3XbbbUpPT1ejRo3Uq1cvrV27Vh07dvQucqCWFYRFaNzLS3Twt03KXfCq2eEAAKwkMlI6dKhkHkC5qDcA87nqItc8AKAG6P8Dfol6A7ZDPgLcPD5lelVWrlxZ5vbUqVM1depUj4ICTOFwKDu6kTIjG0gOh9nRAACsxOGQYmLMjgLwe9QbgB84WRcBALxA/x/wS9QbsB3yEeAWVHUTAAAAAAAAAAAAAAACj0e/EAesLKSwQNe/O005Rw7p+2p8WxAAgGrLz5cmTDgx/9JLUni4ufEAAFABV10kSe/9bbyKQsPMDQgAAhH9fwCAPyAfAW78Qhw4KchZrEuXf6AhG1crhAFxAEBtKiqSXn31xFRUZHY0AABUyFUXXbr8AwU5i80OBwACE/1/AIA/IB8BbgyIAwAAAAAAAAAAAAAsiQFxAAAAAAAAAAAAAIAlMSAOAAAAAAAAAAAAALAkBsQBAAAAAAAAAAAAAJbEgDgAAAAAAAAAAAAAwJIYEAcAAAAAAAAAAAAAWFKI2QEA/qIwNFwTX1ikg9s36/iiN8wOBwBgJfXqSbt2lcwDAOCnXHWRax4AUAP0/wEA/oB8BLgxIA6cZAQF6c+mzXUoY78Mh8PscAAAVhIUJLVpY3YUAABUyVUXAQC8QP8fAOAPyEeAG6dMBwAAAAAAAAAAAABYEr8QB04KLirU1R/OUPaf6frOMMwOBwBgJQUF0iOPnJh/+mkpLMzceAAAqICrLpKkj665S8UhoSZHBAABiP4/AMAfkI8AN34hDpwUXFykgV/M07Xff6VQBsQBALWpsFB68cUTU2Gh2dEAAFAhV1008It5Ci4uMjscAAhM9P8BAP6AfAS4MSAOAKgzM2bMUNeuXRUdHa3o6GglJSXp888/r3SdBQsWqEOHDoqIiFCXLl302Wef+ShaAAAAAIGEegMAAABAdTAgDgCoMy1bttSzzz6rDRs2KDU1VZdeeqmGDh2qn376qdz2a9eu1Q033KDRo0dr48aNGjZsmIYNG6YtW7b4OHIAAAAA/o56AwAAAEB1MCAOAKgzQ4YM0RVXXKF27drp7LPP1tNPP6369etr/fr15bZ/+eWXNXDgQD344IM655xz9NRTT6lnz5565ZVXfBw5AAAAAH9HvQEAAACgOkLMDgAAYA/FxcVasGCBcnJylJSUVG6bdevWacKECWWWDRgwQIsWLar0sfPz85Wfn+++nZWV5XW8QKAoLCjQnj17arRudHS0YmJiajkiAAAA36PeCAwZGRk1fv7ou9qPN68XidcMAAAowYA4AKBObd68WUlJScrLy1P9+vW1cOFCdezYsdy26enpiouLK7MsLi5O6enplW4jJSVFkydPrrWYgUCRn52p3bt2avzD/1J4eLjH6zduEKl5c97gQyIAABCwqDcCR0ZGhm4adasOH8ut0fr0Xe3F29eLxGsGAACUYEAcAFCn2rdvr02bNikzM1MffPCBRo4cqVWrVlX4IVVNTJo0qcwvPbKystSqVatae3zAXxXmH5fTEaKmF1ytJs1be7RuzuGDylj3obKysviACAAABCzqjcCRlZWlw8dyFZN0jaIax1W9Qin0Xe3Hm9eLxGsGAACUxYA4cFJhaLge+/f/6tDOn3T803fMDgewjLCwMLVt21aS1KtXL33//fd6+eWXNWvWrNPaxsfH6+DBg2WWHTx4UPHx8ZVuIzw8vEa/jgV8pl49acuWkvlaFtkoRtGxLT1eL6PWIwEABDpXXeSaB/wd9UbgiWocZ/2+ax33/+2kpq8XKcBeMwBQF8hHgFuQ2QEA/sIICtL+FmcprWlzGQ6H2eEAluV0Ostcf6+0pKQkLVu2rMyypUuXVngNQCBgBAVJnTqdmILofgEA/JerLtrf4iwZ5CwEIOoN+AX6/wAAf0A+Atz4hTgAoM5MmjRJgwYNUkJCgo4dO6b58+dr5cqVWrJkiSRpxIgRatGihVJSUiRJ48aNU58+fTRlyhQNHjxY7777rlJTU/Xaa6+ZuRsAAAAA/BD1BgAAAIDqYEAcOCm4qFCDP5mjYxn79Z1hmB0OYAmHDh3SiBEjdODAATVs2FBdu3bVkiVLdPnll0uS0tLSFFTq24nJycmaP3++Hn30UT388MNq166dFi1apM6dO5u1C0DtKCiQnnnmxPzDD0thYebGAwBABVx1kSR9+tdRKg4JNTkioGLUG/Bb9P8BAP6AfAS4MSAOnBRcXKShi9+QJD0Qm2ByNIA1vPnmm5Xev3LlytOWDR8+XMOHD6+jiACTFBZKkyefmH/wQQoQAIDfKl0XfTHoZgbE4deoN+C36P8DAPwB+Qhw46IBAAAAAAAAAAAAAABLYkAcAAAAAAAAAAAAAGBJDIgDAAAAAAAAAAAAACyJAXEAAAAAAAAAAAAAgCUxIA4AAAAAAAAAAAAAsCQGxAEAAAAAAAAAAAAAlhRidgCAvygMDdNTj83VH7t/Vt6X75kdDgDASiIipO++K5kHAMBPueoi1zwAoAbo/wMA/AH5CHBjQBw4yQgK1u4zO2p/fq6cDofZ4QAArCQ4WDrvPLOjAACgSq66CADgBfr/AAB/QD4C3DhlOgAAAAAAAAAAAADAkviFOHBScFGh+i19V1kHf9d3hmF2OAAAKykokF5++cT8uHFSGKegBQD4J1ddJElfXf43FYeEmhwRAAQg+v8AAH9APgLcGBAHTgouLtJ17/9HkvRobILJ0QAALKWwUJo48cT83XdTgAAA/FbpumjFpdcyIA4ANUH/HwDgD8hHgBunTAcAAAAAAAAAAAAAWBID4gAAAAAAAAAAAAAAS2JAHAAAAAAAAAAAAABgSR4NiKekpOi8885TgwYNFBsbq2HDhmnbtm1VrrdgwQJ16NBBERER6tKliz777LMaBwwAAADAmqg3AAAAANQV6g0AsC+PBsRXrVqlMWPGaP369Vq6dKkKCwvVv39/5eTkVLjO2rVrdcMNN2j06NHauHGjhg0bpmHDhmnLli1eBw8AAADAOqg3AAAAANQV6g0AsK8QTxp/8cUXZW7PnTtXsbGx2rBhgy6++OJy13n55Zc1cOBAPfjgg5Kkp556SkuXLtUrr7yimTNn1jBsAAAAAFZDvQEAAACgrlBvAIB9eTQgfqrMzExJUuPGjStss27dOk2YMKHMsgEDBmjRokUVrpOfn6/8/Hz37aysLG/CVEZGhlePER0drZiYGK9iCER2e94KQ8P0/EMz9MeebcpbsbDmj1NQoD179tR4/YKCAoWFhdVo3UB7zgHANiIipBUrSuYBVEug1BsITN7UO1bud7vqItc8TuD1AsAj9P+BgBAo9YbdPqeH99yvmeJiRcybJ0nK27dPCg6ucl1vXy/0m+Gvajwg7nQ6NX78eF144YXq3Llzhe3S09MVFxdXZllcXJzS09MrXCclJUWTJ0+uaWhlZGRk6KZRt+rwsdwaP0bjBpGaN+cNWx2IdnzejKBgbevQS/sNQ06Ho0aPkZ+dqd27dmr8w/9SeHi4x+sXFhRoX9oetWydqJBQzw/PQHvOAcA2goOlvn3NjgIIKIFSbyAweVvvWLnf7aqLUILXCwCP0f8H/F6g1Bt2/Jwe3qnwNfPa3Gqt783rhX4z/FmNB8THjBmjLVu2aM2aNbUZjyRp0qRJZb51lZWVpVatWtXosbKysnT4WK5ikq5RVOO4qlc4Rc7hg8pY96GysrJsdRDyvNVMYf5xOR0hanrB1WrSvLXH6x/asUU7d89Wo95DPV7frs85AACwpkCpNxCYvKl36HfbD68XAACsJ1DqDT6nh6fM7LvSb4Y/q9GA+NixY/XJJ59o9erVatmyZaVt4+PjdfDgwTLLDh48qPj4+ArXCQ8Pr9GvaysT1ThO0bGVx1qRjFqNJLDY6XkLLirSxasWKjM9Td8ahlePFdkopkbPW/af6V6tH2jPOQDYRmGh9NprJ+Zvv10KDTU3HsDPBWK9gcBU03rHyv1uV10kSav7XKXiEK+utGYpvF4AVBv9f8CvBWK9YafP6VE7ohrHqVHjeI/79rXxeqHfDH8U5EljwzA0duxYLVy4UMuXL1diYmKV6yQlJWnZsmVlli1dulRJSUmeRQrUseDiQt007wWN+eo9hXk5IA4AQBkFBdLYsSemggKzowH8FvUGYD5XXXTTvBcUXFxodjgAEJjo/wN+iXoDdkPfHijh0Ve9x4wZo/nz52vx4sVq0KCB+zoZDRs2VL169SRJI0aMUIsWLZSSkiJJGjdunPr06aMpU6Zo8ODBevfdd5WamqrXXN+SBAAAAABRbwAAAACoO9QbAGBfHv1CfMaMGcrMzFTfvn3VrFkz9/Tee++526SlpenAgQPu28nJyZo/f75ee+01devWTR988IEWLVqkzp07195eAAAAAAh41BsAAAAA6gr1BgDYl0e/EDeqcRrplStXnrZs+PDhGj58uCebAgAAAGAz1BsAAAAA6gr1BgDYl0e/EAcAAAAAAAAAAAAAIFAwIA4AqDMpKSk677zz1KBBA8XGxmrYsGHatm1bpevMnTtXDoejzBQREeGjiAEAAAAECuoNAAAAANXBgDgAoM6sWrVKY8aM0fr167V06VIVFhaqf//+ysnJqXS96OhoHThwwD3t2bPHRxEDAAAACBTUGwAAAACqw6NriANWVhQSqpfHv6Q/9/6m/DWfmR0OYAlffPFFmdtz585VbGysNmzYoIsvvrjC9RwOh+Lj4+s6PMB3wsOlTz4pmQcAwE+56iLXPODPqDfgt+j/AwD8AH17oAQD4sBJzuAQ/djtIu0Pi1DxN5+bHQ5gSZmZmZKkxo0bV9ouOztbrVu3ltPpVM+ePfXMM8+oU6dOvggRqBshIdLgwWZHAQBAlVx1ERCIqDfgN+j/AwD8AH17oASnTAcA+ITT6dT48eN14YUXqnPnzhW2a9++vWbPnq3Fixdr3rx5cjqdSk5O1u+//17hOvn5+crKyiozAQAAALAP6g0AAAAAFeEX4sBJwUVFumD9Fzqyf5e+NQyzwwEsZ8yYMdqyZYvWrFlTabukpCQlJSW5bycnJ+ucc87RrFmz9NRTT5W7TkpKiiZPnlyr8QK1qrBQ+u9/T8zfeKMUymmqAAD+yVUXSdL6CwaqOISPDRAYqDfgV+j/AwD8AH17oAS/EAdOCi4u1D/efFL3f/6OwhgQB2rV2LFj9cknn2jFihVq2bKlR+uGhoaqR48e2r59e4VtJk2apMzMTPe0d+9eb0MGaldBgTRq1ImpoMDsaAAAqJCrLvrHm08quLjQ7HCAaqHegN+h/w8A8AP07YESfB0EAFBnDMPQPffco4ULF2rlypVKTEz0+DGKi4u1efNmXXHFFRW2CQ8PV3h4uDehAgAAAAgw1BsAAAAAqoMBcQBAnRkzZozmz5+vxYsXq0GDBkpPT5ckNWzYUPXq1ZMkjRgxQi1atFBKSook6cknn9QFF1ygtm3b6ujRo3rhhRe0Z88e3XrrrabtBwAAAAD/Q70BAAAAoDoYEAcA1JkZM2ZIkvr27Vtm+Zw5c3TLLbdIktLS0hQUVHIFjyNHjui2225Tenq6GjVqpF69emnt2rXq2LGjr8IGAAAAEACoNwAAAABUBwPiAIA6YxhGlW1WrlxZ5vbUqVM1derUOooIAAAAgFVQbwAAAACojqCqmwAAAAAAAAAAAAAAEHgYEAcAAAAAAAAAAAAAWBKnTAdOKgoJ1Yy7n9Hh33cq/9ulZocDALCS8HDp/fdL5gEA8FOuusg1DwCoAfr/AAA/QN8eKMGAOHCSMzhEqef10/76qSr+7iuzwwEAWElIiDR8uNlRAABQJVddBADwAv1/AIAfoG8PlOCU6QAAAAAAAAAAAAAAS+IX4sBJQcVF6vnDSh3+fafWG4bZ4QAArKSoSFq48MT8VVed+MUIAAB+yFUXSdIPPfvKGUzOAgCP0f8HAPgB+vZACV79wEkhRYW669WHJUn/iU0wORoAgKXk50vXXXdiPjubD8QAAH6rdF1018xVKuBDMwDwHP1/AIAfoG8PlOCU6QAAAAAAAAAAAAAAS2JAHAAAAAAAAAAAAABgSQyIAwAAAAAAAAAAAAAsiQFxAAAAAAAAAAAAAIAlMSAOAAAAAAAAAAAAALAkBsQBAAAAAAAAAAAAAJYUYnYAgL8oDg7V7NGP68j+XSr4YbXZ4QAArCQsTJozp2QeAAA/5aqLXPMAgBqg/w8A8AP07YESDIgDJxWHhOibi/6q/VtTVbTxa7PDAQBYSWiodMstZkcBAECVXHURAMAL9P8BAH6Avj1QglOmAwAAAAAAAAAAAAAsiV+IAycFFRep85b1arH3N603DLPDAQBYSVGRtGTJifkBA6QQumAAAP/kqoskaUvnC+QMJmcBgMfo/wMA/AB9e6AEr37gpJCiQo2bNkGS9FpsgsnRAAAsJT9f+uvJU1RlZ/OBGADAb5Wui+6auUoFfGgGAJ6j/w8A8AP07YESnDIdAAAAAAAAAAAAAGBJDIgDAAAAAAAAAAAAACyJAXEAAAAAAAAAAAAAgCUxIA4AAAAAAAAAAAAAsCQGxAEAAAAAAAAAAAAAlsSAOAAAAAAAAAAAAADAkkLMDgDwF8XBoZp304PKTE9Tweb1ZocDALCSsDDplVdK5gEA8FOuusg1DwCoAfr/AAA/QN8eKMGAOHBScUiIVlw2XPu3pqpoy7dmhwMAsJLQUGnMGLOjAACgSq66CADgBfr/AAA/QN8eKOHxKdNXr16tIUOGqHnz5nI4HFq0aFGl7VeuXCmHw3HalJ6eXtOYAQABIiUlReedd54aNGig2NhYDRs2TNu2batyvQULFqhDhw6KiIhQly5d9Nlnn/kgWgCAP6DeAABUF/UGAMBT1BsAYE8eD4jn5OSoW7dumj59ukfrbdu2TQcOHHBPsbGxnm4aqFMOZ7Ha/7JBXdJ+VZBhmB0OYAmrVq3SmDFjtH79ei1dulSFhYXq37+/cnJyKlxn7dq1uuGGGzR69Ght3LhRw4YN07Bhw7RlyxYfRg7UsuJiaeXKE1NxsdnRAH6NegMwl6suav/LBjmc5Cz4N+oN+C36/4Dfot6AndC3B0p4fMr0QYMGadCgQR5vKDY2VmeccYbH6wG+ElpYoInP3SVJejs2weRoAGv44osvytyeO3euYmNjtWHDBl188cXlrvPyyy9r4MCBevDBE9e3eeqpp7R06VK98sormjlzZp3HDNSJvDzpkktOzGdnS1FR5sYD+DHqDcBcpeuiu2auUkF4PZMjAipGvQG/Rf8f8FvUG7AT+vZACY9/IV5T3bt3V7NmzXT55Zfrm2++8dVmAQB+JDMzU5LUuHHjCtusW7dO/fr1K7NswIABWrduXZ3GBgAIbNQbAADqDQBAXaHeAIDA5vEvxD3VrFkzzZw5U+eee67y8/P1xhtvqG/fvvr222/Vs2fPctfJz89Xfn6++3ZWVlZdhwkAqGNOp1Pjx4/XhRdeqM6dO1fYLj09XXFxcWWWxcXFVXptJvJG7cnIyKjx8xcdHa2YmJhajqj6Ajl2ADVHvQEAkOxVb3jT75W86/t6s+09e/aoqLCoRutKUmFBgfbs2VPj9c3s85v5vAHwDvUGAFhDnQ+It2/fXu3bt3ffTk5O1o4dOzR16lS988475a6TkpKiyZMn13VoAAAfGjNmjLZs2aI1a9bU+mOTN2pHRkaGbhp1qw4fy63R+o0bRGrenDdM+ZApkGMH4B3qDQCAZJ96w9t+r1Tzvq+32847nqvf9x1QQmGhx+vmZ2dq966dGv/wvxQeHl6j7ZvV58/IyNBNY8eZ8rwB8B71BgBYQ50PiJend+/elRYokyZN0oQJE9y3s7Ky1KpVK1+EBgCoA2PHjtUnn3yi1atXq2XLlpW2jY+P18GDB8ssO3jwoOLj4ytch7xRO7KysnT4WK5ikq5RVOO4qlcoJefwQWWs+1BZWVmmDCoHcuwAah/1BgDYi53qDW/6vZJ3fV9vt31oxxbt2TtbxUWeD+wW5h+X0xGiphdcrSbNW3u8vpl9/mPHjpn2vAGoG9QbABB4TBkQ37Rpk5o1a1bh/eHh4TX+ticAwH8YhqF77rlHCxcu1MqVK5WYmFjlOklJSVq2bJnGjx/vXrZ06VIlJSVVuA55o3ZFNY5TdGzlHySWJ6MOYvFUIMcOoPZQbwCAPdi53qhpv1fyvu9b021n/1nxaemrK7JRjGn77S0znzcAtYt6AwACj8cD4tnZ2dq+fbv79q5du7Rp0yY1btxYCQkJmjRpkvbt26e3335bkjRt2jQlJiaqU6dOysvL0xtvvKHly5fryy+/rL29AAD4pTFjxmj+/PlavHixGjRo4L4uX8OGDVWvXj1J0ogRI9SiRQulpKRIksaNG6c+ffpoypQpGjx4sN59912lpqbqtddeM20/AAC+Q70BAKgu6g0AgKeoNwDAnjweEE9NTdUll1zivu069cfIkSM1d+5cHThwQGlpae77CwoKdP/992vfvn2KjIxU165d9dVXX5V5DMAfFAeH6P3r7lHWwd9V+MsPZocDWMKMGTMkSX379i2zfM6cObrlllskSWlpaQoKCnLfl5ycrPnz5+vRRx/Vww8/rHbt2mnRokXq3Lmzr8IGal9oqPT88yXzACpEvQGYy1UXueYBf0a9Ab9Vqv9vhPBeCvgT6g3YCX17oITHR0Dfvn1lGEaF98+dO7fM7YkTJ2rixIkeBwb4WnFIqJYMuln7t6aqcNtGs8MBLKGyfOGycuXK05YNHz5cw4cPr4OIAJOEhUkPPmh2FEBAoN4AzOWqi4BAQL0Bv1W6/79jh7mxACiDegN2Qt8eKBFUdRMAAAAAAAAAAAAAAAIP50gATnI4i9V69zbVP7Bb66rxLXMAAKqtuFj64eTlOHr2lIKDzY0HAIAKuOoiSdrTpr2MIHIWAHisdP+/YUNzYwEA2BZ9e6AEA+LASaGFBXrsqVskSe/FJpgbDADAWvLypN69T8xnZ0tRUebGAwBABUrXRXfNXKWC8HrmBgQAgahU/9/x448mBwMAsCv69kAJTpkOAAAAAAAAAAAAALAkBsQBAAAAAAAAAAAAAJbEgDgAAAAAAAAAAAAAwJIYEAcAAAAAAAAAAAAAWBID4gAAAAAAAAAAAAAAS2JAHAAAAAAAAAAAAABgSSFmBwD4i+LgEC0eequOZexX4Y6fzA4HAGAloaHSE0+UzAMA4KdcdZFrHgBQA6X6/0YI76UAAHPQtwdKcAQAJxWHhOrjYbdr/9ZUFe782exwAABWEhYm/etfZkcBAECVXHURAMALpfv/O3aYGgoAwL7o2wMlOGU6AAAAAAAAAAAAAMCS+IU4cJLD6VSzA7sU8sd+rTUMs8MBAFiJ0ylt3Xpi/pxzpCC+kwgA8E+uukiSDjRLlEHOAgDPle7/h4WZGwsAwLbo2wMlGBAHTgotzNdTj94gSVocm2ByNAAASzl+XOrc+cR8drYUFWVuPAAAVKB0XXTXzFUqCK9nckQAEIBK9f8dP/5ocjAAALuibw+U4OsgAAAAAAAAAAAAAABLYkAcAAAAAAAAAAAAAGBJDIgDAAAAAAAAAAAAACyJAXEAAAAAAAAAAAAAgCUxIA4AAAAAAAAAAAAAsCQGxAEAAAAAAAAAAAAAlhRidgCAvygODtEXA29S9p/pKkz7zexwAABWEhoqPfBAyTwAAH7KVRe55gEANVCq/2+E8F4KADAHfXugBEcAcFJxSKgWXH+v9m9NVeHbz5sdDgDASsLCpBdeMDsKAACq5KqLAABeKN3/37HD3FgAALZF3x4owSnTAQAAAAAAAAAAAACWxC/EgZMcTqcaH05XUeafchiG2eEAAKzE6ZTS0k7MJyRIQXwnEQDgn1x1kSQdbhwvg5wFAJ4r3f93Os2NBQBgW/TtgRIMiAMnhRbm6/kHh0mS4mMTzA0GAGAtx49LiYkn5rOzpagoc+MBAKACpeuiu2auUkF4PXMDAoBAVKr/7/jxR5ODAQDYFX17oARfBwEAAAAAAAAAAAAAWBID4gCAOrV69WoNGTJEzZs3l8Ph0KJFiyptv3LlSjkcjtOm9PR03wQMAAAAIGBQbwAAAACoCgPiAIA6lZOTo27dumn69Okerbdt2zYdOHDAPcXGxtZRhAAAAAACFfUGAAAAgKpwDXEAQJ0aNGiQBg0a5PF6sbGxOuOMM2o/IAAAAACWQb0BAAAAoCr8QhwA4Je6d++uZs2a6fLLL9c333xjdjgAAAAALIR6AwAAALAPfiEOAPArzZo108yZM3XuuecqPz9fb7zxhvr27atvv/1WPXv2LHed/Px85efnu29nZWX5KlwAAAAAAYR6AwAAALAfBsSBk5xBwVp+6bXKOXJIRfv3mB0OYFvt27dX+/bt3beTk5O1Y8cOTZ06Ve+8806566SkpGjy5Mm+ChHwXEiIdPfdJfMAAPgpV13kmgeshnoDPlGq/28E814KADAHfXugBJ/IAicVhYbpvzdP1P6tqSp4+3mzwwFQSu/evbVmzZoK7580aZImTJjgvp2VlaVWrVr5IjSgesLDpenTzY4CAIAqueoiwE6oN1DrSvf/d+wwNxYAgG3RtwdKMCAOAPB7mzZtUrNmzSq8Pzw8XOHh4T6MCAAAAIBVUG8AAAAA1saAOOBiGKp/7Kga5h6TDMPsaADLyM7O1vbt2923d+3apU2bNqlx48ZKSEjQpEmTtG/fPr399tuSpGnTpikxMVGdOnVSXl6e3njjDS1fvlxffvmlWbsAeM8wpD/+ODHftKnkcJgbDwAAFTlZF0lSdoMzyFnwe9Qb8Eul+/98xgQAMAt9e8CNAXHgpLCCPL08boAkKT42weRoAOtITU3VJZdc4r7tOtXgyJEjNXfuXB04cEBpaWnu+wsKCnT//fdr3759ioyMVNeuXfXVV1+VeQwg4OTmSrGxJ+azs6WoKHPjAQCgAqXrortmrlJBeD2TIwIqR70Bv1Sq/+/48UeTgwEA2BV9e6AEA+IAgDrVt29fGZV8I37u3Lllbk+cOFETJ3JtGwAAAABVo94AAAAAUJUgswMAAAAAAAAAAAAAAKAuMCAOAAAAAAAAAAAAALAkjwfEV69erSFDhqh58+ZyOBxatGhRleusXLlSPXv2VHh4uNq2bXva6aoAAAAAQKLeAAAAAFB3qDcAwJ48HhDPyclRt27dNH369Gq137VrlwYPHqxLLrlEmzZt0vjx43XrrbdqyZIlHgcLAAAAwNqoNwAAAADUFeoNALCnEE9XGDRokAYNGlTt9jNnzlRiYqKmTJkiSTrnnHO0Zs0aTZ06VQMGDPB08wAAAAAsjHoDAAAAQF2h3gAAe/J4QNxT69atU79+/cosGzBggMaPH1/hOvn5+crPz3ffzsrKqqvw/F5GRoZX+19QUKCwsDCP19uzZ4+KCotqvF1JKiwo0J49e2q0bk3jlmoeuzMoWN9cOFi5mX+qKONAjbZtNm+ec0mKjo5WTExMLUZUfd6+1gM5dm9e72buNwAPhIRII0eWzAOoNf5Qb9i5H2PXvog3/W5va6263rarLnLN+3LbVfFm+2a+Vr2t07ypF7xd367HOOC1Uv1/Izi4isYA/Jk/1BveMrMvYsbn/C5mf1buTa1VW32wyvr2FQnUWkfyvt/szfNuZm1NXV89df6JbHp6uuLi4sosi4uLU1ZWlo4fP6569eqdtk5KSoomT55c16H5vYyMDN006lYdPpZbo/ULCwq0L22PWrZOVEioZ//qvOO5+n3fASUUFtZo2/nZmdq9a6fGP/wvhYeHe7SuN3FLNY+9KDRMs299Qvu3pqrg7ec93q7ZvHnOXRo3iNS8OW/4/M3P29e6FLixe/t6N2u/AXgoPFziGmNAnTC73rBzP0ayZ1/E2363N7WWL7btqovM2HZlvN2+Wa9Vb+P2tl6g3gBMUrr/v2OHqaEA8I7Z9Ya3zOyLmPU5v2T+Z+Xe1lq11QerqG9fkUCudbx9vUk1f97NrK2p66vPL3+iNGnSJE2YMMF9OysrS61atTIxInNkZWXp8LFcxSRdo6jGcVWvcIpDO7Zo5+7ZatR7qJo0b+3xunv2zlZxUc0+rCjMPy6nI0RNL7i6Rtuuadyu9b2JPVB585xLUs7hg8pY96GysrJ8/sbn7Ws9kGP35vVu5n4DABDIarPesHM/xq59EW/73d7UK3bdtrfbN/O1WhvPm7f1MfUGAAC+5U/jG2b2Rcz8nN/sz8q9qbUCve9qZr3hzevNm+fdzNqaur766nxAPD4+XgcPHiyz7ODBg4qOji7321OSFB4eXuNv7VhRVOM4Rce29Hi97D/TJUmRjWI8Xt+1rre82XZN1i29vscMQ2EFeQovyJcMo2aP4Qdq+rxJUkYtx+Kpmr7WpcCN3dvXu9n7DaCaDEPKPflNzchIyeEwNx7AQvyl3rBjP0YyP3Yz+bxe8dW2T9ZFklQQFnFazjJzv73ZvtmvVW+fN7PWN/t5AwJW6f5/AH/GBMB/6g1vmdGXMO1z/lLM/qy8prVWrfXBqujbVyQQ/2fevt4k7593M2tr6vqq1fmAeFJSkj777LMyy5YuXaqkpKS63jTgkbCCPM24s48kKT42weRoAACWkpsr1a9/Yj47W4qKMjcewEKoN4DaVbouumvmKhWEl/9BLwCgEqX6/44ffzQ5GADeoN5AIKNvD5QI8nSF7Oxsbdq0SZs2bZIk7dq1S5s2bVJaWpqkE6cDGTFihLv9nXfeqZ07d2rixIn65Zdf9Oqrr+r999/XfffdVzt7AAAAAMAyqDcAAAAA1BXqDQCwJ48HxFNTU9WjRw/16NFDkjRhwgT16NFDjz/+uCTpwIED7uQhSYmJifr000+1dOlSdevWTVOmTNEbb7yhAQMG1NIuAAAAALAK6g0AAAAAdYV6AwDsyeNTpvft21dGJde+mTt3brnrbNy40dNNAQAAALAZ6g0AAAAAdYV6AwDsyeNfiAMAAAAAAAAAAAAAEAgYEAcAAAAAAAAAAAAAWBID4gAAAAAAAAAAAAAAS/L4GuKAVTmDgpR67qU6fuyIio/+aXY4AAArCQ6Wrr22ZB4AAD/lqotc8wCAGqD/DwDwA/TtgRIMiAMnFYWGa8aYZ7V/a6ry337e7HAAAFYSESEtWGB2FAAAVMlVFwEAvFCq/2/s2GFyMAAAu6JvD5TgKyEAAAAAAAAAAAAAAEtiQBwAAAAAAAAAAAAAYEkMiAMnheUf15ujeuvz5+9WpNNpdjgAACvJyZEcjhNTTo7Z0QAAUCFXXfTmqN4Kyz9udjgAEJhK9f8dublmRwMAsCn69kAJBsQBAAAAAAAAAAAAAJbEgDgAAAAAAAAAAAAAwJIYEAcAAAAAAAAAAAAAWBID4gAAAAAAAAAAAAAAS2JAHAAAAAAAAAAAAABgSQyIAwDq1OrVqzVkyBA1b95cDodDixYtqnKdlStXqmfPngoPD1fbtm01d+7cOo8TAAAAQOCh3gAAAABQFQbEgZOcQUH6seuF+u7MTip2mB0NYB05OTnq1q2bpk+fXq32u3bt0uDBg3XJJZdo06ZNGj9+vG699VYtWbKkjiMF6lBwsHTFFSem4GCzowEAoEKuuujHrhfKGcRHBvB/1BvwS/T/AQB+gL49UCLE7AAAf1EUGq6X75uq/VtTlf/282aHA1jGoEGDNGjQoGq3nzlzphITEzVlyhRJ0jnnnKM1a9Zo6tSpGjBgQF2FCdStiAjp00/NjgIAgCq56iIgUFBvwC+V6v8bO3aYHAwAwK7o2wMl+EoIAMCvrFu3Tv369SuzbMCAAVq3bp1JEQEAAACwCuoNAAAAwH74hTgAwK+kp6crLi6uzLK4uDhlZWXp+PHjqlev3mnr5OfnKz8/3307KyvLqxgyMjK8eozo6GjFxMSYsv2CggKFhYXVaN09e/aoqLCoRutKUmFBgfbs2VPj9c2M3Vs1/Z+ZHbe3/zNvX+ve8PY49eb1ZuYxLpkbOwAAgS7Q6w2z+4+BLJD7vvA9sz8XMJM3+x7I+w0AsDYGxIGTwvKPa9q9A2QYTrVpFG92OAA8kJKSosmTJ9fKY2VkZOimUbfq8LHcGj9G4waRmjfnjRoVgd5sv7CgQPvS9qhl60SFhHqe4vOO5+r3fQeUUFjo8br52ZnavWunxj/8L4WHh3u8vpmxe6s6/7OI4mJ9uW6VJKl/Uh/lnbyOoJlxe/s/k7x7rXvD2+PU29ebWce4ZG7sAOzBVRdJ0vj/WaKC8NMHBwG78ad6w8z+YyDzed83J0eKjZUkOdavr9H2YB6zPxcwk7f7Hqj7DVgVfXugBAPiQCnhBXlmhwDYXnx8vA4ePFhm2cGDBxUdHV3urzUkadKkSZowYYL7dlZWllq1alWj7WdlZenwsVzFJF2jqMZxVa9wipzDB5Wx7kNlZWXVqAD0ZvuHdmzRzt2z1aj3UDVp3trjbR/asUV79s5WcZHnH64V5h+X0xGiphdcXeNtmxW7t6rzPwsvyFO9b1ZIkloPvE35YRGSzI3b2/+Zt691b3h7nHrzejPzGJfMjR2AfVAXwcoCvd4ws/8YyEzp++bWfDAV5jL7cwEzebPvgbzfgJXRtwdOYEAcAOBXkpKS9Nlnn5VZtnTpUiUlJVW4Tnh4eI2/5V+RqMZxio5tWaN1M0zafvaf6ZKkyEYxNYrdtb43vN22mbF7q7L/WVj+cfd8g5gWCj/5jVx/iLumz7lUO691b9T0OPX29WbWMS75R+wAAASyQK83/KH/GMgCue8L3zP7cwEz1XTfA32/AQDWFWR2AAAAa8vOztamTZu0adMmSdKuXbu0adMmpaWlSTrxa4sRI0a42995553auXOnJk6cqF9++UWvvvqq3n//fd13331mhA8AAADAj1FvAAAAAKgKA+IAgDqVmpqqHj16qEePHpKkCRMmqEePHnr88cclSQcOHHB/WCVJiYmJ+vTTT7V06VJ169ZNU6ZM0RtvvKEBAwaYEj8AAAAA/0W9AQAAAKAqnDIdAFCn+vbtK8MwKrx/7ty55a6zcePGOowKAAAAgBVQbwAAAACoCr8QBwAAAAAAAAAAAABYEr8QB04yHA790r6nCnKPyVmQb3Y4AAALceUY1zwAAP6KnAUAtSAoSOrTp2QeAAAT0LcHSjAgDpxUGBahF/45U/u3pirv7efNDgcAYCGuHAMAgL8jZwFALahXT1q5UpJk7NhhbiwAANuibw+U4CuKAAAAAAAAAAAAAABLYkAcAAAAAAAAAAAAAGBJnDIdOCks/7ief2ConMVFat+gsdnhAAAsxJVjJGnii4tVEF7P5IgAACgfOQsAakFOjtSmjSTJsXy5ubEAAGyLvj1QggFxoJQG2UdPzjAgDgCoXe4cAwCAnyNnAUAt+OMPsyMAAIC+PXASp0wHAAAAAAAAAAAAAFgSA+IAAAAAAAAAAAAAAEtiQBwAAAAAAAAAAAAAYEkMiAMAAAAAAAAAAAAALIkBcQAAAAAAAAAAAACAJYWYHQDgLwyHQ7vanKPCvBw5DbOjAQBYiSvHuOYBAPBX5CwAqAVBQdK555bMAwBgAvr2QAkGxIGTCsMi9O8n3tL+ranKe/t5s8MBAFiIK8cAAODvyFkAUAvq1ZO+/16SZOzYYXIwAAC7om8PlKjRVxSnT5+uNm3aKCIiQueff76+++67CtvOnTtXDoejzBQREVHjgAEAAABYG/UGAAAAgLpCvQEA9uPxgPh7772nCRMm6IknntAPP/ygbt26acCAATp06FCF60RHR+vAgQPuac+ePV4FDQAAAMCaqDcAAAAA1BXqDQCwJ48HxF966SXddtttGjVqlDp27KiZM2cqMjJSs2fPrnAdh8Oh+Ph49xQXF+dV0EBdCMvP03MPDNXcmY+qnuE0OxwAgIW4csxzDwxVWH6e2eEAfo16AzAXOQsAakFurtSmjdSmjRzHj5sdDYBSqDdgJ/TtgRIeDYgXFBRow4YN6tevX8kDBAWpX79+WrduXYXrZWdnq3Xr1mrVqpWGDh2qn376qeYRA3XGUNM/Dygu67AchtmxAACs5USOafrnAUkkGaAi1BuAPyBnAYDXDEPas+fEZPBeCvgL6g3YD317wMWjAfE//vhDxcXFp30DKi4uTunp6eWu0759e82ePVuLFy/WvHnz5HQ6lZycrN9//73C7eTn5ysrK6vMBAAAAMDaqDcAAAAA1BXqDQCwL49Pme6ppKQkjRgxQt27d1efPn300UcfKSYmRrNmzapwnZSUFDVs2NA9tWrVqq7DBAAAABCAqDcAAAAA1BXqDQCwBo8GxJs2barg4GAdPHiwzPKDBw8qPj6+Wo8RGhqqHj16aPv27RW2mTRpkjIzM93T3r17PQkTAAAAQACi3gAAAABQV6g3AMC+PBoQDwsLU69evbRs2TL3MqfTqWXLlikpKalaj1FcXKzNmzerWbNmFbYJDw9XdHR0mQkAAACAtVFvAAAAAKgr1BsAYF8hnq4wYcIEjRw5Uueee6569+6tadOmKScnR6NGjZIkjRgxQi1atFBKSook6cknn9QFF1ygtm3b6ujRo3rhhRe0Z88e3XrrrbW7JwAAAAACHvUGAAAAgLpCvQEA9uTxgPj111+vjIwMPf7440pPT1f37t31xRdfKC4uTpKUlpamoKCSH54fOXJEt912m9LT09WoUSP16tVLa9euVceOHWtvL4Ba4dC+5okqys+T4TA7FgCAtZzIMa55ABWj3gDMRs4CAK85HJKrL+LgvRTwJ9QbsBf69oCLxwPikjR27FiNHTu23PtWrlxZ5vbUqVM1derUmmwG8KmC8Ag9/vR72r81Vcffft7scAAAFuLKMQCqh3oDMA85CwBqQWSk9NNPkiRjxw6TgwFwKuoN2AV9e6CER9cQBwAAAAAAAAAAAAAgUDAgDgAAAAAAAAAAAACwJAbEgZPC8vP05CPXa+abT6me4TQ7HMBSpk+frjZt2igiIkLnn3++vvvuuwrbzp07Vw6Ho8wUERHhw2iB2ufKMU8+cr3C8vPMDgcAgAqRsxCIqDfgd3JzpU6dpE6d5Dh+3OxoAAA2Rd8eKFGja4gD1mSoxf5dkiRHbILJsQDW8d5772nChAmaOXOmzj//fE2bNk0DBgzQtm3bFBsbW+460dHR2rZtm/u2w+HwVbhAHSnJMZJhaiQAAFSOnIXAQr0Bv2QY0s8/l8wDAGAK+vaAC78QBwDUqZdeekm33XabRo0apY4dO2rmzJmKjIzU7NmzK1zH4XAoPj7ePcXFxfkwYgAAAACBgnoDAAAAQFUYEAcA1JmCggJt2LBB/fr1cy8LCgpSv379tG7dugrXy87OVuvWrdWqVSsNHTpUP/30U6Xbyc/PV1ZWVpkJAAAAgLVRbwAAAACoDgbEAQB15o8//lBxcfFpv7iIi4tTenp6ueu0b99es2fP1uLFizVv3jw5nU4lJyfr999/r3A7KSkpatiwoXtq1apVre4HAAAAAP9DvQEAAACgOhgQBwD4laSkJI0YMULdu3dXnz599NFHHykmJkazZs2qcJ1JkyYpMzPTPe3du9eHEQMAAAAIFNQbAAAAgP2EmB0AAMC6mjZtquDgYB08eLDM8oMHDyo+Pr5ajxEaGqoePXpo+/btFbYJDw9XeHi4V7ECAAAACCzUGwAAAACqg1+IA24O/dGkmQ5GN5bhMDsWwBrCwsLUq1cvLVu2zL3M6XRq2bJlSkpKqtZjFBcXa/PmzWrWrFldhQn4wIkc80eTZpJIMgAAf0bOQuCg3oDfcjik1q1PTA7eSwEAZqFvD7jwC3HgpILwCD304mLt35qq428/b3Y4gGVMmDBBI0eO1LnnnqvevXtr2rRpysnJ0ahRoyRJI0aMUIsWLZSSkiJJevLJJ3XBBReobdu2Onr0qF544QXt2bNHt956q5m7AXjFlWMAAPB35CwEGuoN+KXISGn3bkmSsWOHubEAAGyLvj1QggFxAECduv7665WRkaHHH39c6enp6t69u7744gvFxcVJktLS0hQUVHLCkiNHjui2225Tenq6GjVqpF69emnt2rXq2LGjWbsAAAAAwE9RbwAAAACoCgPiAIA6N3bsWI0dO7bc+1auXFnm9tSpUzV16lQfRAUAAADACqg3AAAAAFSGAXHgpNCCPD2UcocK83J0kWF2NAAAK3HlGEl6btIsFYZFmBwRAADlI2cBQC04fly6+GJJkmPuXHNjAQDYFn17oAQD4sBJDsNQ4u6tkqSg2ASTowEAWEnpHOMw+NYVAMB/kbMAoBY4nVJqask8AAAmoG8PlAiqugkAAAAAAAAAAAAAAIGHAXEAAAAAAAAAAAAAgCUxIA4AAAAAAAAAAAAAsCQGxAEAAAAAAAAAAAAAlsSAOAAAAAAAAAAAAADAkkLMDgDwJ8fqnyFncZHZYQAALOhY/TPMDgEAgGohZwFALWja1OwIAACgbw+cxIA4cFJBeD2N/8+X2r81VblvP292OAAAC3HlGAAA/B05CwBqQVSUlJEhSTJ27DA5GACAXdG3B0pwynQAAAAAAAAAAAAAgCUxIA4AAAAAAAAAAAAAsCROmQ6cFFqQp/EvjVdB7jH1M5xmhwMAsBBXjpGkaROmqTAswtyAAACoADkLAGrB8ePSoEGSJMf06SYHAwCwK/r2QAkGxIGTHIahDtt+kCQFxSaYHA0AwEpK5xiHYZgcDQAAFSNnAUAtcDqlVatK5gEAMAF9e6AEp0wHAAAAAAAAAAAAAFgSA+IAAAAAAAAAAAAAAEtiQBwAAAAAAAAAAAAAYEkMiAMAAAAAAAAAAAAALIkBcQAAAAAAAAAAAACAJYWYHQDgT/LDImQYTrPDAABYUH5YhNkhAABQLeQsAKgFkZFmRwAAAH174CQGxIGTCsLr6e5Zq7V/a6py337e7HAAABbiyjEAAPg7chYA1IKoKCknR5Jk7NhhcjAAALuibw+U4JTpAAAAAAAAAAAAAABLYkAcAAAAAAAAAAAAAGBJnDIdOCmkMF9jXvmn8rKPajDXEQcA1CJXjpGk6WOfVVFouMkRAQBQPnIWANSCvDzpmmskSY4XXjA5GACAXdG3B0owIA6cFOR0quuP30iSgmMTTI4GAGAlpXNMkJMvXQEA/Bc5CwBqQXGx9NlnJ+affdbcWAAAtkXfHijBKdMBAAAAAAAAAAAAAJbEgDgAAAAAAAAAAAAAwJJqNCA+ffp0tWnTRhERETr//PP13XffVdp+wYIF6tChgyIiItSlSxd95jplEADAFsgbAABPkDcAAJ4gbwAAPEHeAAD78XhA/L333tOECRP0xBNP6IcfflC3bt00YMAAHTp0qNz2a9eu1Q033KDRo0dr48aNGjZsmIYNG6YtW7Z4HTwAwP+RNwAAniBvAAA8Qd4AAHiCvAEA9uTxgPhLL72k2267TaNGjVLHjh01c+ZMRUZGavbs2eW2f/nllzVw4EA9+OCDOuecc/TUU0+pZ8+eeuWVV7wOHgDg/8gbAABPkDcAAJ4gbwAAPEHeAAB7CvGkcUFBgTZs2KBJkya5lwUFBalfv35at25dueusW7dOEyZMKLNswIABWrRoUYXbyc/PV35+vvt2ZmamJCkrK8uTcCVJx44dU3FRkY4e2K3CvFyP1885ckj5x4/r559/1rFjxzxe3xt79+5VQV5ejWPPOvS7DKdTWel7FeLw3bqBuu3wgjy5XmHOAIu9NrYdyK/1QI7dm/9bzpFDKi4q0rFjx2r0/uhaxzAMj9etLvKG569Hb15TgfweZOb6vviflc4xh/f+pvywCK/j9nZ9O+cNf3+9VIa8cTq75w1vBHIfzFvk24rX98ec5e36du2febs+eaOEP+UNM/twdv2cSvL8eXMcP67Ek/Nbf/klYPuuZjKzn0IfqWb7Tt4oYaW8Eajv3WZ/5uHtsVRb2w7KOlxu374igfw/C+Q+UqBu29vt+zxvGB7Yt2+fIclYu3ZtmeUPPvig0bt373LXCQ0NNebPn19m2fTp043Y2NgKt/PEE08YkpiYmJiYfDDt3bvXk1TgEfIGExMTk/Um8gYTExMTkycTeYOJiYmJyZOJvMHExMTE5MlU3bzh0S/EfWXSpEllvnXldDp1+PBhNWnSRA5HDb7aUQ1ZWVlq1aqV9u7dq+jo6DrZhi9ZaX/YF/9kpX2RrLU/1d0XwzB07NgxNW/e3IfR1Q0z8oaZrPR6rS477rPEfrPf/oW8cTp//5/5As/BCTwPJ/A88By4uJ6Hn3/+2bZ5w06vBbvsq132U2Jfrcrf95V6A1Xx99dwIOI5rV08n7WvsufU07zh0YB406ZNFRwcrIMHD5ZZfvDgQcXHx5e7Tnx8vEftJSk8PFzh4eFllp1xxhmehFpj0dHRlnqhWml/2Bf/ZKV9kay1P9XZl4YNG9ZpDHbIG2ay0uu1uuy4zxL7bTf+vN/kjfL58//MV3gOTuB5OIHngefApUWLFgoKCqqzxw+EvGGn14Jd9tUu+ymxr1blz/tKvYHq8OfXcKDiOa1dPJ+1r6Ln1JO84VFVEhYWpl69emnZsmXuZU6nU8uWLVNSUlK56yQlJZVpL0lLly6tsD0AwDrIGwAAT5A3AACeIG8AADxB3gAA+/L4lOkTJkzQyJEjde6556p3796aNm2acnJyNGrUKEnSiBEj1KJFC6WkpEiSxo0bpz59+mjKlCkaPHiw3n33XaWmpuq1116r3T0BAPgl8gYAwBPkDQCAJ8gbAABPkDcAwJ48HhC//vrrlZGRoccff1zp6enq3r27vvjiC8XFxUmS0tLSypwOKzk5WfPnz9ejjz6qhx9+WO3atdOiRYvUuXPn2tuLWhAeHq4nnnjitFOZBCor7Q/74p+stC+StfbH3/bFqnnDTP72P/YFO+6zxH6z3/YUSHmD/xnPgQvPwwk8DzwHLr58Hvw1b9jptWCXfbXLfkrsq1XZaV8r4695A1XjNVz7eE5rF89n7avN59RhGIZRCzEBAAAAAAAAAAAAAOBXPLqGOAAAAAAAAAAAAAAAgYIBcQAAAAAAAAAAAACAJTEgDgAAAAAAAAAAAACwJAbEAQAAAAAAAAAAAACWZLsB8dWrV2vIkCFq3ry5HA6HFi1aVOb+7OxsjR07Vi1btlS9evXUsWNHzZw505xgq5CSkqLzzjtPDRo0UGxsrIYNG6Zt27aVaZOXl6cxY8aoSZMmql+/vq655hodPHjQpIgrVtW+HD58WPfcc4/at2+vevXqKSEhQffee68yMzNNjLp81fm/uBiGoUGDBpX7WvQX1d2fdevW6dJLL1VUVJSio6N18cUX6/jx4yZEXLHq7Et6erpuvvlmxcfHKyoqSj179tSHH35oUsQVmzFjhrp27aro6GhFR0crKSlJn3/+ufv+QDn2UTEr5StPWCm3VZeVcqAnrJYvq8tKedUuqno/Lu3OO++Uw+HQtGnTfBafr1Tnedi6dauuvPJKNWzYUFFRUTrvvPOUlpbm+2DrkF3zc2l2zNXlsWv+Ls2uubw0O70n2OnYt8vxbadj2E59cCt99gX7ovaoXXbqr/iCnfpEvuKrvpftBsRzcnLUrVs3TZ8+vdz7J0yYoC+++ELz5s3T1q1bNX78eI0dO1Yff/yxjyOt2qpVqzRmzBitX79eS5cuVWFhofr376+cnBx3m/vuu0//93//pwULFmjVqlXav3+/rr76ahOjLl9V+7J//37t379fL774orZs2aK5c+fqiy++0OjRo02O/HTV+b+4TJs2TQ6Hw4Qoq686+7Nu3ToNHDhQ/fv313fffafvv/9eY8eOVVCQf73FVGdfRowYoW3btunjjz/W5s2bdfXVV+u6667Txo0bTYz8dC1bttSzzz6rDRs2KDU1VZdeeqmGDh2qn376SVLgHPuomJXylSeslNuqy0o50BNWy5fVZaW8ahdVvR+7LFy4UOvXr1fz5s19FJlvVfU87NixQxdddJE6dOiglStX6scff9Rjjz2miIgIH0dat+yan0uzY64uj13zd2l2zeWl2ek9wU7Hvl2Obzsdw3bqg1vpsy/YF7VH7bJTf8UX7NQn8hWf9b0MG5NkLFy4sMyyTp06GU8++WSZZT179jQeeeQRH0ZWM4cOHTIkGatWrTIMwzCOHj1qhIaGGgsWLHC32bp1qyHJWLdunVlhVsup+1Ke999/3wgLCzMKCwt9GJnnKtqXjRs3Gi1atDAOHDhQ7mvRX5W3P+eff77x6KOPmhhVzZS3L1FRUcbbb79dpl3jxo2N119/3dfheaxRo0bGG2+8EdDHPspntXzlCSvltuqyUg70hNXyZXVZKa/aQUWvwd9//91o0aKFsWXLFqN169bG1KlTfR6bL5X3PFx//fXGTTfdZE5AJrFzfi7Njrm6PHbN36XZNZe72O09wU7Hvl2Obzsdw3bqg1vtsy/YD7VH7bJbf8UX7NQn8pW66nsF1lfcfCA5OVkff/yx9u3bJ8MwtGLFCv3666/q37+/2aFVyXV6gMaNG0uSNmzYoMLCQvXr18/dpkOHDkpISNC6detMibG6Tt2XitpER0crJCTEV2HVSHn7kpubq7///e+aPn264uPjzQqtRk7dn0OHDunbb79VbGyskpOTFRcXpz59+mjNmjVmhlkt5f1vkpOT9d577+nw4cNyOp169913lZeXp759+5oUZdWKi4v17rvvKicnR0lJSQF97KP6AjlfecJKua26rJQDPWG1fFldVsqrduV0OnXzzTfrwQcfVKdOncwOxxROp1Offvqpzj77bA0YMECxsbE6//zzA/KUqt6yS34uzY65ujx2zd+l2TWXV8bK7wl2Ovbtcnzb6Ri2Ux/cKp99AS7UHrXPyv0VX7BTn8hX6qrvxYD4Kf7zn/+oY8eOatmypcLCwjRw4EBNnz5dF198sdmhVcrpdGr8+PG68MIL1blzZ0knrgcTFhamM844o0zbuLg4paenmxBl9ZS3L6f6448/9NRTT+n222/3cXSeqWhf7rvvPiUnJ2vo0KEmRue58vZn586dkqR//etfuu222/TFF1+oZ8+euuyyy/Tbb7+ZGW6lKvrfvP/++yosLFSTJk0UHh6uO+64QwsXLlTbtm1NjLZ8mzdvVv369RUeHq4777xTCxcuVMeOHQP22IdnAjVfecJKua26rJQDPWG1fFldVsqrdvbcc88pJCRE9957r9mhmObQoUPKzs7Ws88+q4EDB+rLL7/UVVddpauvvlqrVq0yOzyfskN+Ls2Oubo8ds3fpdk1l1fFqu8Jdjr27XJ82+kYtlMf3AqffQGnovaofVbtr/iCnfpEvlKXfa/A/dpiHfnPf/6j9evX6+OPP1br1q21evVqjRkzRs2bNy/zjQ5/M2bMGG3ZssUS31ysal+ysrI0ePBgdezYUf/61798G5yHytuXjz/+WMuXLw/I6/KUtz9Op1OSdMcdd2jUqFGSpB49emjZsmWaPXu2UlJSTIm1KhW9zh577DEdPXpUX331lZo2bapFixbpuuuu09dff60uXbqYFG352rdvr02bNikzM1MffPCBRo4cScfPRgI1X3nCSrmtuqyUAz1htXxZXVbKq3a1YcMGvfzyy/rhhx8C+rqa3nK9bocOHar77rtPktS9e3etXbtWM2fOVJ8+fcwMz6fskJ9Ls2OuLo9d83dpds3lVbHqe4Kdjn27HN92Oobt1Ae3wmdfwKmoPWqfVfsrvmCnPpGv1Gnfy8tTuQc0nXK9hNzcXCM0NNT45JNPyrQbPXq0MWDAAB9HV31jxowxWrZsaezcubPM8mXLlhmSjCNHjpRZnpCQYLz00ks+jLD6KtoXl6ysLCMpKcm47LLLjOPHj/s4Os9UtC/jxo0zHA6HERwc7J4kGUFBQUafPn3MCbYaKtqfnTt3GpKMd955p8zy6667zvj73//uyxCrraJ92b59uyHJ2LJlS5nll112mXHHHXf4MsQaueyyy4zbb789II99VM4q+coTVspt1WWlHOgJq+XL6rJSXrWTU9+Pp06dWuHrtHXr1qbFWddOfR7y8/ONkJAQ46mnnirTbuLEiUZycrKPo/MdO+bn0uyYq8tj1/xdml1z+ans8p5gp2PfLse3nY5hO/XBrfrZF+yH2qN22aW/4gt26hP5Sl33vThleimFhYUqLCxUUFDZpyU4ONj9zSN/YhiGxo4dq4ULF2r58uVKTEwsc3+vXr0UGhqqZcuWuZdt27ZNaWlpSkpK8nW4lapqX6QT3/zo37+/wsLC9PHHHysiIsKESKtW1b7885//1I8//qhNmza5J0maOnWq5syZY0LElatqf9q0aaPmzZtr27ZtZZb/+uuvat26tS9DrVJV+5KbmytJAfMecCqn06n8/PyAOvZRM4GWrzxhpdxWXVbKgZ6wWr6sLivlVUg333zzaa/T5s2b68EHH9SSJUvMDs9nwsLCdN5559n+dWvl/FyaHXN1eeyav0uzay6vLqu9J9jp2LfL8W2nY9hOfXCrf/YFUHvULqv1V3zBTn0iX/FZ38vjIfQAd+zYMWPjxo3Gxo0bDUnGSy+9ZGzcuNHYs2ePYRiG0adPH6NTp07GihUrjJ07dxpz5swxIiIijFdffdXkyE931113GQ0bNjRWrlxpHDhwwD3l5ua629x5551GQkKCsXz5ciM1NdVISkoykpKSTIy6fFXtS2ZmpnH++ecbXbp0MbZv316mTVFRkcnRl1Wd/8updMo3s/xJdfZn6tSpRnR0tLFgwQLjt99+Mx599FEjIiLC2L59u4mRn66qfSkoKDDatm1r/OUvfzG+/fZbY/v27caLL75oOBwO49NPPzU5+rL++c9/GqtWrTJ27dpl/Pjjj8Y///lPw+FwGF9++aVhGIFz7KNiVspXnrBSbqsuK+VAT1gtX1aXlfKqXVT1fnyq1q1bG1OnTvVtkD5Q1fPw0UcfGaGhocZrr71m/Pbbb8Z//vMfIzg42Pj6669Njrx22TU/l2bHXF0eu+bv0uyay0uz03uCnY59uxzfdjqG7dQHt9JnX7Avao/aZaf+ii/YqU/kK77qe9luQHzFihWGpNOmkSNHGoZhGAcOHDBuueUWo3nz5kZERITRvn17Y8qUKYbT6TQ38HKUtx+SjDlz5rjbHD9+3Lj77ruNRo0aGZGRkcZVV11lHDhwwLygK1DVvlT0f5Nk7Nq1y9TYT1Wd/0t56/hrQVHd/UlJSTFatmxpREZGGklJSX7ZAanOvvz666/G1VdfbcTGxhqRkZFG165djbffftu8oCvwj3/8w2jdurURFhZmxMTEGJdddpl7MNwwAufYR8WslK88YaXcVl1WyoGesFq+rC4r5VW7qOr9+FRWHRCvzvPw5ptvGm3btjUiIiKMbt26GYsWLTIv4Dpi1/xcmh1zdXnsmr9Ls2suL81O7wl2Ovbtcnzb6Ri2Ux/cSp99wb6oPWqXnforvmCnPpGv+Krv5Ti5MQAAAAAAAAAAAAAALIVriAMAAAAAAAAAAAAALIkBcQAAAAAAAAAAAACAJTEgDgAAAAAAAAAAAACwJAbEAQAAAAAAAAAAAACWxIA4AAAAAAAAAAAAAMCSGBAHAAAAAAAAAAAAAFgSA+IAAADA/2fvzuNsrPs/jr/P7JsZhlnIYCwRshYNhUqWVJSobrIk7kSFSqlUkqZNdKdQYSq5tdImfihbKOstFd2GZoRhyjJmmPVcvz/cTnOaxZyZOXOd5fV8PObhnOt8r+v6XObM9T7X93uu6wIAAAAAAADgkRgQBwAAAAAAAAAAAAB4JAbEASfLzc1V48aNtXHjxhLb/Pbbb7JYLNq5c6dDy3700Ud13333VbBCAIArITcAAI4gNwAAjiA3AACOIDfgKRgQh8dKT0/X6NGjVa9ePQUGBio2NlY9e/bUd999Z2vToEEDWSwWbd682W7ecePGqVu3brbnTz/9tCwWiywWi3x9fRUXF6dRo0bp+PHjF6xjzpw5io+PV6dOncpc+/kAOf8TEBCgxo0b69lnn5VhGLZ2Dz30kN555x3t37+/zMsGABSP3AAAOILcAAA4gtwAADiC3AAqFwPi8Fj9+/fXjh079M477+jXX3/V559/rm7duunPP/+0axcUFKRHHnnkgstr0aKFjhw5otTUVC1YsEDLly/X6NGjS53HMAzNmjVLI0aMKNc2rFq1SkeOHNF///tfTZkyRdOmTdP8+fNtr9eqVUs9e/bU7Nmzy7V8AMBfyA0AgCPIDQCAI8gNAIAjyA2gcjEgDo908uRJrV+/Xi+88IKuvvpq1a9fXx06dNCkSZN000032bUdNWqUNm/erGXLlpW6TD8/P8XGxuqiiy5S9+7dNWDAAK1cubLUebZt26bk5GT16dPHbvoPP/ygtm3bKigoSJdddpl27NhR7Pw1a9ZUbGys6tevr0GDBqlz587avn27XZsbb7xRixcvLrUOAEDpyA0AgCPIDQCAI8gNAIAjyA2g8jEgDo8UFhamsLAwLV26VDk5OaW2jY+P1z333KNJkybJarWWafm//fabVqxYoYCAgFLbrV+/XhdffLGqVatmm5aZmakbbrhBzZs317Zt2/T000/roYceuuA6t27dqm3btqljx4520zt06KDff/9dv/32W5lqBwAURW4AABxBbgAAHEFuAAAcQW4AlY8BcXgkPz8/JSUl6Z133lH16tXVuXNnPfbYY9q1a1ex7Z944gkdOHBA77//fonL/PHHHxUWFqbg4GDFx8frp59+uuClSFJSUlSnTh27aYsWLZLVatW8efPUokUL3XDDDXr44YeLnb9Tp04KCwtTQECALr/8cg0cOFBDhgyxa3N++SkpKaXWAgAoGbkBAHAEuQEAcAS5AQBwBLkBVD4GxOGx+vfvr8OHD+vzzz9Xr169tGbNGrVr105JSUlF2kZFRemhhx7Sk08+qdzc3GKX17RpU+3cuVNbtmzRI488op49e+q+++4rtYazZ88qKCjIbtovv/yiVq1a2U1PSEgodv4PPvhAO3fu1H/+8x99+OGH+uyzz/Too4/atQkODpYknTlzptRaAAClIzcAAI4gNwAAjiA3AACOIDeAysWAODxaUFCQrrvuOk2ePFkbN27UsGHD9NRTTxXbdsKECTp79qzeeOONYl8PCAhQ48aN1bJlSz3//PPy9fXVlClTSl1/rVq1dOLEiXLXHxcXp8aNG+uSSy7RgAEDNG7cOE2fPl3Z2dm2NsePH5d0LvQAABVDbgAAHEFuAAAcQW4AABxBbgCVhwFxeJXmzZsrKyur2NfCwsI0efJkTZs2TadPn77gsp544gm9/PLLOnz4cIlt2rZtqz179sgwDNu0Sy65RLt27bLb6W/evLlM9fv6+io/P9/uW167d++Wv7+/WrRoUaZlAADKjtwAADiC3AAAOILcAAA4gtwAyo8BcXikP//8U9dcc40WLlyoXbt26cCBA/roo4/04osvqm/fviXON2rUKEVERGjRokUXXEdCQoJatWql5557rsQ2V199tTIzM/XTTz/Zpv3jH/+QxWLRyJEj9fPPP2vZsmV6+eWXS9yOtLQ0/f777/r666/16quv6uqrr1Z4eLitzfr163XVVVfZLi0CAHAcuQEAcAS5AQBwBLkBAHAEuQFUPgbE4ZHCwsLUsWNHzZgxQ126dFHLli01efJkjRw5UrNmzSpxPn9/f02dOtXu202lGT9+vN5++20dPHiw2Ndr1qypm2++We+//75dbV988YV+/PFHtW3bVo8//rheeOGFYufv3r27ateurQYNGmjUqFG6/vrr9cEHH9i1Wbx4sUaOHFmmegEAxSM3AACOIDcAAI4gNwAAjiA3gMpnMQpf6wBApdu1a5euu+46JScnKywsrFKX/fXXX+vBBx/Url275OfnV6nLBgCYg9wAADiC3AAAOILcAAA4gtyAp+AMccDJWrVqpRdeeEEHDhyo9GVnZWVpwYIFhAUAeBByAwDgCHIDAOAIcgMA4AhyA56CM8QBAAAAAAAAAAAAAB6JM8QBAAAAAAAAAAAAAB6JAXEAAAAAAAAAAAAAgEdiQBwAAAAAAAAAAAAA4JEYEAcAAAAAAAAAAAAAeCQGxAEAAAAAAAAAAAAAHokBcQAAAAAAAAAAAACAR2JAHAAAAAAAAAAAAADgkRgQBwAAAAAAAAAAAAB4JAbEAQAAAAAAAAAAAAAeiQFxAAAAAAAAAAAAAIBHYkAcAAAAAAAAAAAAAOCRGBAHAAAAAAAAAAAAAHgkBsQBAAAAAAAAAAAAAB6JAXEAAAAAAAAAAAAAgEdiQByoBD/88IMCAgKUkpJidikV8vPPP8vPz0+7d+82uxQA8GgHDx5UUFCQvvvuO7NLqZA///xToaGhWrZsmdmlAIBHy8zMVHR0tN5//32zS6mQvLw8xcXF6Y033jC7FADwaOQGALiXNWvWyGKxaM2aNbZpw4YNU4MGDco0v9VqVcuWLTVt2jTnFOiC5syZo3r16iknJ8fsUuAmGBCHS8jJydEjjzyiOnXqKDg4WB07dtTKlSuLbbtx40ZdeeWVCgkJUWxsrO6//35lZmaWe5l5eXmaMmWKGjZsqMDAQDVs2FDPPvus8vPzy1z/448/rjvuuEP169cv+0ZX0JYtWzR27Fi1aNFCoaGhqlevngYOHKhff/3Vrp3ValVSUpJuuukmxcXFKTQ0VC1bttSzzz6r7Oxsu7bNmzdXnz599OSTT1bZdgBAeVR2bmRmZuqpp55Sr169FBkZKYvFoqSkpBLX/8svv6hXr14KCwtTZGSk7rzzTqWnp5e5/meeeUYdO3ZU586dyzxPRe3Zs0cTJ05UmzZtVK1aNdWuXVt9+vTR1q1bi7T99NNPddttt6lhw4YKCQlR06ZN9eCDD+rkyZN27WrWrKm7775bkydPrqKtAIDyMTM3fvjhB917771q3769/P39ZbFYHK7/1VdfVbVq1XT77bc7PG95HTx4UFOmTFGHDh1Uo0YN1apVS926ddOqVauKtF29erXuuusuXXzxxQoJCVHDhg11991368iRI3bt/P39NWHCBE2bNq3IsQgAuBKzcsORPpzSkBsA4F3+/e9/6+DBgxo7dmyVrveDDz7Q4MGD1aRJE1ksFnXr1q3Ettu2bVOvXr0UHh6uatWqqUePHtq5c2eRdlarVXPmzFGbNm0UFhammJgY9e7dWxs3brRrN2zYMOXm5mru3LmVvFXwWAbgAm6//XbDz8/PeOihh4y5c+caCQkJhp+fn7F+/Xq7djt27DCCgoKMtm3bGrNnzzYef/xxIzAw0OjVq1e5lzlw4EDDYrEYI0aMMGbPnm0MHTrUkGSMHDmyTLXv2LHDkGRs3Lix/P8B5dC/f38jNjbWuO+++4y33nrLmDp1qhETE2OEhoYaP/74o63d6dOnDUnGFVdcYTz77LPGm2++aQwfPtzw8fExunXrZlitVrvlLlu2zJBk7Nu3r0q3BwAcUdm5ceDAAUOSUa9ePaNbt26GJGPBggXFrvvgwYNGrVq1jEaNGhmvvvqqMW3aNKNGjRpG69atjZycnAvWfuzYMcPf399YtGhRube/PB588EGjevXqxogRI4y5c+caL774otGoUSPD19fXWLlypV3bmjVrGpdeeqkxefJk46233jLuv/9+IyAgwGjWrJlx5swZu7Y///yzIclYvXp1VW4OADjEzNx46qmnDH9/f6N9+/bGxRdfbDh6GJ6bm2tERUUZzz33nEPzVdRrr71mBAcHG3fccYcxa9YsY+bMmUa7du0MScb8+fPt2rZv396Ij483Jk6caLz11lvGpEmTjGrVqhkxMTHGkSNH7NqeOHHCCAgIMObNm1eVmwMADjErNxztwykOuQEA7ufbb781JBnffvutbdrQoUON+vXrl2n+1q1bG6NGjXJOcaXo2rWrERYWZlx99dVGjRo1jK5duxbbbtu2bUZQUJDRpEkT4+WXXzZefPFFo0GDBkZ4eLixZ88eu7YTJkwwJBmDBw825s6da7zwwgtGw4YNDT8/P+P777+3aztx4kSjfv36ZcpHgAFxmO777783JBkvvfSSbdrZs2eNRo0aGQkJCXZte/fubdSuXds4deqUbdpbb71lSDJWrFjh8DJ/+OEHQ5IxefJku/U8+OCDhsViMf7zn/9csP7777/fqFevXpXvdL/77rsiAy+//vqrERgYaAwaNMg2LScnx/juu++KzD9lyhRDUpFBkNzcXKNGjRpF/k8AwFU4Izeys7NtHS9btmwpdWBj9OjRRnBwsJGSkmKbtnLlSkOSMXfu3AvW/8orrxjBwcHG6dOny7S9lWXr1q1F1vnHH38YUVFRRufOne2mFz4AO++dd94xJBlvvfVWkddatmxp3HnnnZVaLwBUFrNzIy0tzfZlojFjxjg8IP7pp5+a8oXV3bt3G+np6XbTsrOzjWbNmhl169a1m7527VqjoKCgyDRJxuOPP15k2TfccINx1VVXVX7RAFAJzMwNR/twikNuAID7qciA+Pbt2w1JxqpVq5xXYAlSU1Nt+/MWLVqUOCB+/fXXGzVq1DD++OMP27TDhw8bYWFhxi233GKblpeXZwQHBxu33nqr3fz79+83JBn333+/3fStW7dykgbKjEumw3Qff/yxfH19NWrUKNu0oKAgjRgxQps2bdLBgwclSRkZGVq5cqUGDx6s8PBwW9shQ4YoLCxMH374ocPLXL9+vSQVuYTU7bffLsMw9MEHH1yw/qVLl+qaa64pcunDBg0a6IYbbtCGDRvUoUMHBQUFqWHDhnr33XfL+l9Tqk6dOikgIMBuWpMmTdSiRQv98ssvtmkBAQHq1KlTkflvvvlmSbJrK527HFW3bt302WefVUqdAFDZnJEbgYGBio2NLdP6P/nkE91www2qV6+ebVr37t118cUX2y2zJEuXLlXHjh0VFhZmN71bt25q2bKlfv75Z1199dUKCQnRRRddpBdffLFMdV1I+/bti6yzZs2auuqqq4pkQXGXuCopNyTpuuuu0xdffCHDMCqlVgCoTGbnRkxMjIKDg8td/9KlS9WgQQM1atTIbvqwYcMUFhamQ4cOqV+/fgoLC1NUVJQeeughFRQUlHt957Vo0UK1atWymxYYGKjrr79ev//+u06fPm2b3qVLF/n42HcvdOnSRZGRkSXmxoYNG3T8+PEK1wkAlc3M3HC0D6c45AYAuI6UlBTde++9atq0qYKDg1WzZk0NGDBAv/32W6WtY+nSpQoICFCXLl3spj/99NOyWCzat2+fhg0bpurVqysiIkLDhw/XmTNnKmXdcXFxRfbnxVm/fr26d++umjVr2qbVrl1bXbt21Zdffmm71UheXp7Onj2rmJgYu/mjo6Pl4+NT5Liqffv2ioyMZCwDZcKAOEy3Y8cOXXzxxXYHD5LUoUMHSbLdR+LHH39Ufn6+LrvsMrt2AQEBatOmjXbs2OHwMnNyciSpyI40JCRE0rn7WpTm0KFDSk1NVbt27Yp9fd++fbr11lt13XXXafr06apRo4aGDRumn376ydbGarXqjz/+KNNPXl5eqfUYhqGjR48WOQApTlpamiQV27Z9+/bavXu3MjIyLrgcAKhqzsiNsjp06JCOHTtWZJnn13+hZebl5WnLli0l5saJEyfUq1cvtW7dWtOnT1ezZs30yCOP6Ouvv7ZrV9bcOJ9zpUlLS6uU3Dh58qRdvgGAqzAzNyrDxo0bS8yNgoIC9ezZUzVr1tTLL7+srl27avr06XrzzTft2p04caJMuVGWjrG0tDSFhITYjplKkpmZqczMzBJzwzCMIvcBBABX4Iq5Udpn8b8jNwDAdWzZskUbN27U7bffrn/961+65557tHr1anXr1q3SBqU3btyoli1byt/fv9jXBw4cqNOnTysxMVEDBw5UUlKSpkyZYtfm1KlTZdrvnx+4dlROTk6xXxIOCQlRbm6udu/eLencOE3Hjh2VlJSk999/X6mpqdq1a5eGDRumGjVq2H1Z7bx27drpu+++K1dd8C4MiMN0R44cUe3atYtMPz/t8OHDtnaFp/+97fl2jiyzadOmklRkh3n+zPFDhw6VWvuePXskSfHx8cW+vnfvXn300UeaNm2axowZo+XLlysgIEALFiywtUlNTVVUVFSZfi60Y3///fd16NAh3XbbbaW2k6QXX3xR4eHh6t27d5HXGjZsKKvVats+AHAlzsgNR9Zd2jKPHz9e6iB0amqqzp49W2JuHD58WNOmTdPMmTM1evRoff3114qNjdW8efPs2pU1N/7973+Xuj3r16/Xpk2bypQbL7zwgnx9fXXrrbcWea1hw4aSpJ9//vmCywGAqmZmblRUfn6+kpOTS8yN7Oxs3XbbbZo3b57uueceffzxx2rbtm2R3Gjbtm2ZcuNCVyXZt2+fPv30U/Xv31++vr6ltp05c6Zyc3OLzRhyA4Arc8XcKK0PpzByAwBcS58+fbRz505NmTJFI0eO1LRp07Rs2TKlpKTok08+qZR17Nmzp8T9vnRun/7JJ59o9OjReuutt3TzzTcX2e/37du3TPv9sWPHlqvGpk2bavPmzXZXJMnNzdX3338vyX4cZuHChWratKkGDx6s+vXrq3Xr1tq+fbu+++47Wx4U1rBhQ/IBZeJndgHA2bNnFRgYWGR6UFCQ7fXC/5bU9vzrjizz+uuvV/369fXQQw8pJCRE7du31/fff6/HH39cfn5+dssszp9//ilJqlGjRrGvN2/eXFdddZXteVRUlJo2bar9+/fbpsXGxmrlypWlrue81q1bl/janj17NGbMGCUkJGjo0KGlLue5557TqlWr9MYbb6h69epFXj+/PX/88UeZ6gKAquSM3HBk3aUts7T6pAvnRlhYmAYPHmx7HhAQoA4dOtjlhqQy50aLFi1KfO3YsWP6xz/+ofj4eE2cOLHU5SxatEjz5s3TxIkT1aRJkyKvkxsAXJmZuVFRx48fl2EYJeaGJN1zzz12z6+66iq99957dtPef//9MtVfXAfTeWfOnNGAAQMUHBys559/vtTlrFu3TlOmTNHAgQN1zTXXFHmd3ADgylwtNy7Uh1MYuQEArqXwWdF5eXnKyMhQ48aNVb16dW3fvl133nlnhdfx559/OrzfX7JkiTIyMmxXQ5k+fbpOnDhxwXXVqVOnXDXee++9Gj16tEaMGKGJEyfKarXq2WeftX25rHDmVKtWTS1atFBCQoKuvfZapaWl6fnnn1e/fv20fv36IlcSqVGjhs6ePaszZ85c8Gok8G4MiMN0wcHBxZ5Nl52dbXu98L8ltS0cLmVdZlBQkL766isNHDhQ/fv3l3TuQObFF1/UtGnTitxrtSQl3TO18P1lz6tRo4ZduAQFBal79+5lWk9J0tLS1KdPH0VERNjudVWSDz74QE888YRGjBih0aNHF9vm/Pb8/b7oAOAKnJEbjqy7tGUWblOaknKjbt26Rfa9NWrU0K5du+ymVTQ3srKydMMNN+j06dPasGFDqXm3fv16jRgxQj179tS0adOKbUNuAHBlZuZGZSkpN4KCghQVFWU37e/HG5LUuXPnCq2/oKBAt99+u37++Wd9/fXXpXaE7dmzRzfffLNatmypt99+u9g25AYAV+ZKuVGWPpzikBsA4BrOnj2rxMRELViwQIcOHbLbP586darS1lPSfl8qOkZxfvD8xIkTtgHx9u3bV1otxbnnnnt08OBBvfTSS3rnnXckSZdddpkmTpxoNw6Tn5+v7t27q1u3bnrttdds83fv3l0tWrTQSy+9pBdeeMFu2WQEyooBcZiudu3axV6a/Py3g85/aD5/Carz0//etvCH67IuUzp39tzu3bv1888/68SJE2revLmCg4M1fvx4de3atdTaa9asKUklfnuqpIHpwgFVUFCg9PT0UtdzXmRkpAICAuymnTp1Sr1799bJkye1fv36Ug8yVq5cqSFDhqhPnz6aM2dOie3Ob09Z7k0FAFXNGbnhyLpLW2ZkZGSJZ4dLlZMb0l/3ELyQiIiIIh1xubm5uuWWW7Rr1y6tWLFCLVu2LHH+//znP7rpppvUsmVLffzxx/LzK/6jI7kBwJWZmRsVFRkZKYvF4nBu/F16errd5QlLEhYWVuyXpEaOHKkvv/xS77//frFn7p138OBB9ejRQxEREVq2bJmqVatWbDtyA4Arc5XcKGsfTmHkBgC4lvvuu08LFizQuHHjlJCQoIiICFksFt1+++2yWq2Vso6aNWuWenZ3Wfqajh8/rtzc3AuuKzg4WBEREY4XKWnatGl66KGH9NNPPykiIkKXXnqpHnvsMUnSxRdfLOncFUN2796tV155xW7eJk2a6JJLLin2lrInTpxQSEiIqV9ghntgQByma9Omjb799lu7S3RIst0/ok2bNpKkli1bys/PT1u3btXAgQNt7XJzc7Vz5067aWVd5nkWi8XusrLLli2T1Wq94Bl4zZo1kyQdOHDAgS22d/DgwVLv8VHYt99+q27dutmeZ2dn68Ybb9Svv/6qVatWqXnz5iXO+/333+vmm2/WZZddpg8//LDEQQ3p3Pb4+PjYgggAXIkzcqOsLrroIkVFRWnr1q1FXvvhhx+K5Mvf1atXT8HBwRXKDan4+xQWZ8GCBRo2bJjtudVq1ZAhQ7R69Wp9+OGHpX7xKzk5Wb169VJ0dLSWLVtW6lnk57fnkksuKdsGAEAVMjM3KsrPz0+NGjWqcG5cfvnlSklJuWC7p556Sk8//bTdtIcfflgLFizQzJkzdccdd5Q4759//qkePXooJydHq1evLjWryA0ArswVcsORPpzCyA0AcC0ff/yxhg4dqunTp9umZWdn6+TJk5W2jmbNmlV4v3/LLbdo7dq1F2w3dOhQJSUllXs9NWrU0JVXXml7vmrVKtWtW9c2znL06FFJKvZLWXl5ecrPzy8y/cCBA+QDyoQBcZju1ltv1csvv6w333xTDz30kKRzl5tasGCBOnbsqLi4OEnnznLr3r27Fi5cqMmTJ9u+Nfree+8pMzNTAwYMcHiZxTl79qwmT56s2rVrl/rBXTo3MBIXF1fswEhZlfce4gUFBbrtttu0adMmffbZZ0pISChxvl9++UV9+vRRgwYN9OWXX17w21Lbtm1TixYtyv1tLwBwJmfkhiP69++vd955RwcPHrSta/Xq1fr11181fvz4Uuf19/fXZZddVqHckMp/D/H77rtPH3zwgebOnatbbrmlxPnS0tLUo0cP+fj4aMWKFUUuq/h327ZtU0RERKn3LAcAs5idGxWVkJCgNWvWVGgZ5b0X7EsvvaSXX35Zjz32mB544IES58vKytL111+vQ4cO6dtvv1WTJk1KXc+2bdtksVhKPYYBALOYnRuO9uH8HbkBAK7D19e3yFX/XnvttTJdhaOsEhIS9PzzzysnJ6fUqxaWxtn3EC/OBx98oC1btujll1+Wj4+PpL/OFF+8eLF69epla7t9+3bt3btXo0aNKrKc7du3a9CgQZVWFzwXA+IwXceOHTVgwABNmjRJx44dU+PGjfXOO+/ot99+07x58+zaTps2TZ06dVLXrl01atQo/f7775o+fbp69Ohht4N0ZJkDBw5UnTp11Lx5c2VkZGj+/Pnav3+/vvrqqxIv1VRY3759tWTJEhmGUa77VJT3HuIPPvigPv/8c9144406fvy4Fi5caPf64MGDJUmnT59Wz549deLECT388MP66quv7No1atTI7oAiLy9Pa9eu1b333utwTQBQFZyRG5I0a9YsnTx5UocPH5YkffHFF/r9998lnRtIPv8loccee0wfffSRrr76aj3wwAPKzMzUSy+9pEsvvVTDhw+/YP19+/bV448/XuSME0eUJzdmzpypN954QwkJCQoJCSmSGzfffLNCQ0MlSb169dL+/fs1ceJEbdiwQRs2bLC1i4mJ0XXXXWc378qVK3XjjTdyvyYALsns3EhJSdF7770nSbYvRD377LOSpPr16+vOO+8stf6+ffvqvffe06+//lruKziV516wS5Ys0cSJE22XJ/x7blx33XWKiYmRJA0aNEg//PCD7rrrLv3yyy/65ZdfbO3CwsLUr18/u3lXrlypzp07224lAgCuxMzccLQPpzjkBgC4jhtuuEHvvfeeIiIi1Lx5c23atEmrVq2q1P1Z3759NXXqVK1du1Y9evQo1zLKew/xdevWad26dZLO3W4jKyvLdqzTpUsXdenSxdbumWeeUY8ePVSzZk1t3rxZCxYsUK9evey+QNW+fXtdd911euedd5SRkaEePXroyJEjeu211xQcHKxx48bZrX/btm06fvy4+vbtW6764WUMwAWcPXvWeOihh4zY2FgjMDDQuPzyy43ly5cX23b9+vVGp06djKCgICMqKsoYM2aMkZGRUe5lvvDCC0azZs2MoKAgo0aNGsZNN91k7Nixo8y1b9++3ZBkrF+/3m56/fr1jT59+hRp37VrV6Nr165lXn5Junbtakgq8ee8AwcOlNpu6NChdsv9+uuvDUnGf//73wrXCADO4ozcqF+/fon7ygMHDti13b17t9GjRw8jJCTEqF69ujFo0CAjLS2tTLUfPXrU8PPzM9577z276V27djVatGhRpP3QoUON+vXrl2nZpRk6dGipeVB4G0tr9/cM++WXXwxJxqpVqypcIwA4i5m58e2335Z5n1qcnJwco1atWsbUqVPtpg8dOtQIDQ0t0v6pp56yOx4or/PLKenn22+/tbUt7f/i7xl28uRJIyAgwHj77bcrXCMAOItZueFoH05xyA0AcB0nTpwwhg8fbtSqVcsICwszevbsaezZs8eoX7++3T79/DFD4X2lI/1BrVq1MkaMGGE37fx+OT093W76ggULiu3rKo/S9v1PPfWUrd2+ffuMHj16GLVq1TICAwONZs2aGYmJiUZOTk6RZZ45c8Z45plnjObNmxvBwcFGRESEccMNNxQ7ZvPII48Y9erVM6xWa4W3BZ7PYhh/u14DAIdde+21qlOnju3MD3fWr18/WSwWLVmyxOxSAMBjjRgxQr/++qvWr19vdikVNm7cOK1bt852GUMAQOWbOnWqFixYoP/+97/y9fU1u5wKmTlzpl588UUlJyc7fBlgAEDZkBsA4F3ee+89jRkzRqmpqapevbrZ5VSJnJwcNWjQQI8++mipt+kAzvMxuwDAEzz33HP64IMPlJKSYnYpFfLLL7/oyy+/1NSpU80uBQA82lNPPaUtW7bou+++M7uUCvnzzz/19ttv69lnn2UwHACcaPz48crMzNTixYvNLqVC8vLy9Morr+iJJ55gUAMAnIjcAADvMmjQINWrV0+vv/662aVUmQULFsjf31/33HOP2aXATXCGOAAAAAAAAAAAAADAI3GGOAAAAAAAAAAAAADAIzEgDgAAAAAAAAAAAADwSAyIAwAAAAAAAAAAAAA8EgPiAAAAAAAAAAAAAACPxIA4AAAAAAAAAAAAAMAj+ZldQFlYrVYdPnxY1apVk8ViMbscAPAIhmHo9OnTqlOnjnx8POv7UeQGAFQ+cgMA4AhyAwDgCHIDAOAIR3PDLQbEDx8+rLi4OLPLAACPdPDgQdWtW9fsMioVuQEAzkNuAAAcQW4AABxBbgAAHFHW3HCLAfFq1apJOrdR4eHhJlcDOCgrS6pT59zjw4el0FBz6wH+JyMjQ3FxcbZ9rCchN4ASkEmoAHID8DJkBiqI3ACA/yFTy4TcADwA+ztUIUdzwy0GxM9fRiQ8PJzAgPvx85OaNz/3OCJCCgkxtx7gbzzxUk3kBlACMgmVgNwAvASZgUpCbgDwemSqQ8gNwI2xv4MJypobbjEgDri1kBDpp5/MrgIAADIJAFB2ZAYAAJWDTAXgLdjfwYVd+C7jAAAAAAAAAAAAAAC4IQbEAQAAAAAAAAAAAAAeiUumA8525ox0+eXnHm/ZYup9MwoKCpSXl2fa+lG1/P395evra3YZLstqtSo3N9fsMlCFAgIC5OPj5d8FdKFMAtwNueFd+BwlMgOoIHLD+3C8gRKRqSgDcsP7eGRusL+DC2NAHHA2w5B+/vmvx6aUYCgtLU0nT540Zf0wT/Xq1RUbGyuLxWJ2KS4lNzdXBw4ckNVqNbsUVCEfHx/Fx8crICDA7FLM4wKZBLgjcsM7ef3nKDIDKDdywztxvIESkam4AHLDO3lkbrC/gwtjQBzwAucHw6OjoxUSEuK9nXpexDAMnTlzRseOHZMk1a5d2+SKXIdhGDpy5Ih8fX0VFxfned/ERLGsVqsOHz6sI0eOqF69euwHAZQZueF9+BwFoCLIDe/E8QaA8iI3vBO5AVQ9BsQBD1dQUGAbDK9Zs6bZ5aAKBQcHS5KOHTum6OhoLvv5P/n5+Tpz5ozq1KmjEC7b41WioqJ0+PBh5efny9/f3+xyALgJcsM78TkKQHmRG96L4w0A5UFueC9yA6haDn3daPbs2WrVqpXCw8MVHh6uhIQEff3116XO89FHH6lZs2YKCgrSpZdeqmXLllWoYACOOX/PcD5Qeafzv3ez7h3virlRUFAgSZ51OSKUyfnf+fn3AADX9/zzz8tisWjcuHGltnNmdpAb3svsz1EAnKOgoECTJ09WfHy8goOD1ahRI02dOlVGJV3Wk9zwXhxvAO7pQn1X2dnZGjNmjGrWrKmwsDD1799fR48erbT1kxvei9wAqpZDA+J169bV888/r23btmnr1q265ppr1LdvX/3000/Ftt+4caPuuOMOjRgxQjt27FC/fv3Ur18/7d69u1KKB1B2XHbFO5n9e3fl3DD7/wZVj9854F62bNmiuXPnqlWrVqW2q6rsYB/iffidA57phRde0OzZszVr1iz98ssveuGFF/Tiiy/qtddeq9T1sA/xPvzOAfd0ob6r8ePH64svvtBHH32ktWvX6vDhw7rlllsqvQ72Id6H3zlQtRwaEL/xxht1/fXXq0mTJrr44os1bdo0hYWFafPmzcW2f/XVV9WrVy89/PDDuuSSSzR16lS1a9dOs2bNqpTiAQCujdwAAJRHZmamBg0apLfeeks1atQotS3ZAQBwxMaNG9W3b1/16dNHDRo00K233qoePXrohx9+MLs0AIAJSuu7OnXqlObNm6dXXnlF11xzjdq3b68FCxZo48aNJfZtAQBck0MD4oUVFBRo8eLFysrKUkJCQrFtNm3apO7du9tN69mzpzZt2lTe1QLux2KR6tc/98O3vhwybNgwWSwW3XPPPUVeGzNmjCwWi4YNG1b1hZXBp59+qh49eqhmzZqyWCzauXNnkTbJycm6+eabFRUVpfDwcA0cONChSy6V9TKyroLcqBh3/XvIy8vTI488oksvvVShoaGqU6eOhgwZosOHD9u1mzZtmjp16qSQkBBVr169zMv/5ZdfdNNNNykiIkKhoaG6/PLLlZqaWslb4UHIJLiJMWPGqE+fPkUyoThkR/E8OTd+++03jRgxwu5yx0899ZRyc3NLXfY///lPNWrUSMHBwYqKilLfvn21Z88eZ2+S+yIz4KE6deqk1atX69dff5Uk/ec//9GGDRvUu3dvkyszl7vmhuTc4+/XX39dDRo0UFBQkDp27MgXJ1A+ZKrb+Hvf1bZt25SXl2d3vNGsWTPVq1eP4w03zY2y9lMdP35cgwYNUnh4uKpXr64RI0YoMzOz1GWnpaXpzjvvVGxsrEJDQ9WuXTt98sknztwc18P+Di7Mz9EZfvzxRyUkJCg7O1thYWFasmSJmjdvXmzbtLQ0xcTE2E2LiYlRWlpaqevIyclRTk6O7XlGRoajZcLNpaenV+j3Hh4erqioqEqsqAJCQqTffjO7CrcVFxenxYsXa8aMGQoODpZ07t49ixYtUr169Wzt8vLyyn2/FV9fX/n7+1dKvedlZWXpyiuv1MCBAzVy5MhiX+/Ro4dat26tb775RpI0efJk3Xjjjdq8ebN8fEr/vlJZLyPrCsiNylPWvwdXcubMGW3fvl2TJ09W69atdeLECT3wwAO66aabtHXrVlu73NxcDRgwQAkJCZo3b16Zlp2cnKwrr7xSI0aM0JQpUxQeHq6ffvpJQUFBztoc9/e3TPKovHVQRbbdnbfbHSxevFjbt2/Xli1bytS+PNlBbrh3buzZs0dWq1Vz585V48aNtXv3bo0cOVJZWVl6+eWXS1x2+/btNWjQINWrV0/Hjx/X008/rR49eujAgQPy9fWtqk10H044jvHm3IHrePTRR5WRkaFmzZrJ19dXBQUFmjZtmgYNGlTiPOSG6+aG5Lzj7w8++EATJkzQnDlz1LFjR82cOVM9e/bU3r17FR0d7dRtgodxs75BbzxWKqnvaufOnQoICCjyxX2ON85xx9woaz/VoEGDdOTIEa1cuVJ5eXkaPny4Ro0apUWLFpW47CFDhujkyZP6/PPPVatWLS1atEgDBw7U1q1b1bZt26rYPPNVcH/H8QKcyeEB8aZNm2rnzp06deqUPv74Yw0dOlRr164tcXCjPBITEzVlypRKWx7cS3p6ugYPv1vHT58p9zIiq4Vo4YK32fl5gHbt2ik5OVmffvqprYPi008/Vb169RQfHy/p3GD4gd9SlJuXr3lvv6WPPvxAf/zxh+o3aKB7Rt+rnj17STr3Lc+nn5ys77/frD/++EO1a9fW7Xf8Q8OHD1d8g/ry9/fXsGHDdPLkSV155ZWaPn26cnNzdfvtt2vmzJkODZrfeeedks6dwVSc7777Tr/99pt27Nih8PBwSdI777yjGjVq6Jtvvin1jLjCl5F99tlny1yTWciNylOWv4fzrFarXnjhBb355ptKS0vTxRdfrMmTJ+vWW2+VdO7vYdSoUfrmm2+UlpamevXq6d5779UDDzxgW0Zl/D1ERERo5cqVdtNmzZqlDh06KDU11XaAdP73l5SUVOb/j8cff1zXX3+9XnzxRdu0Ro0alXl+b+fNeVvRbXfX7XYHBw8e1AMPPKCVK1c69cst5IZ750avXr3Uq1cv2+sNGzbU3r17NXv27FIHxEeNGmV73KBBAz377LNq3bq1fvvtN/KjCnhz7sC1fPjhh3r//fe1aNEitWjRQjt37tS4ceNUp04dDR06tNh5yA3XzQ3Jecffr7zyikaOHKnhw4dLkubMmaOvvvpK8+fP16OPPlrm+gB34q3HSiX1XZUXueG6uVGW441ffvlFy5cv15YtW3TZZZdJkl577TVdf/31evnll1WnTp1il71x40bNnj1bHTp0kCQ98cQTmjFjhrZt2+Y9A+IVwPECnM3hAfGAgAA1btxY0rlv2G/ZskWvvvqq5s6dW6RtbGxskcsPHT16VLGxsaWuY9KkSZowYYLteUZGhuLi4hwtFW4qIyNDx0+fUVRCf4VGxlx4hr/JOn5U6Zs+UUZGBju+C8nKKvk1X1+pcEd0aW19fKT/fQuwxLahoY7X9z933XWXFixYYPtgNX/+fA0fPlxr1qyRdO4DU36BVfOT3tEXX3yhqS/NVIOGjbRl80Y9+siDiolrqI6dOisvL091GjTUrJH3qnpkpLZv+UFPPDxOUVFRunf0PbYPTt9++61q166tb7/9Vvv27dNtt92mNm3a2L5p/vTTTyspKanEg+2yyMnJkcViUWBgoG1aUFCQfHx8tGHDhlIHxAtfRtYdBsTdJjeq8u9BKvffxIX+Hs5LTEzUwoULNWfOHDVp0kTr1q3T4MGDFRUVpa5du8pqtapu3br66KOPVLNmTW3cuFGjRo1S7dq1NXDgQNtynPH3cOrUKVksFocujf53VqtVX331lSZOnKiePXtqx44dio+P16RJk9SvX79yL9ebeHPeVmTb3Xm73cG2bdt07NgxtWvXzjatoKBA69at06xZs5STk1PkTN7yZAe54Xm5cerUKUVGRpZ5mVlZWVqwYIHi4+M51qwi3pw7cC0PP/ywHn30Ud1+++2SpEsvvVQpKSlKTEwscUCc3HCv3Pi78hx/5+bmatu2bZo0aZJtmo+Pj7p37+71l0mGZ/PWY6WS+q5uu+025ebm6uTJk3afRTne+Isn5Mbfjzc2bdqk6tWr2wbDJal79+7y8fHR999/r5tvvrnY5XTq1EkffPCB+vTpo+rVq+vDDz9Udna2unXrVuZavBnHC3A2hwfE/85qtdpd/qOwhIQErV692u7+titXrizx3rHnBQYG2n1IhXcKjYxReHTdcs2bXsm1VMjZs1KXLucer1tn/wHEbGFhJb92/fXSV1/99Tw6WjpTwrezunaVCn/IadBA+uMP+zaGUd4qNXjwYE2aNEkpKSmSzn27e/HixXYfrHJzczVn1r+08JMv1O7yjpKk+EYXa9uWLfrg/XfVqcvV8vUL0IOTnvqrzIZNtGPbFi1fvlz3jv7rfjc1atTQrFmz5Ovrq2bNmqlPnz5avXq17YNVrVq1KnwW0RVXXKHQ0FA98sgjeu6552QYhh599FEVFBToyJEjJc7n6GVkXZHL5kZV/j1I5f6bKMvfQ05Ojp577jmtWrXK9n/XsGFDbdiwQXPnzlXXrl3l7+9v923l+Ph4bdq0SR9++KHdgUZl/z1kZ2frkUce0R133GE7O6M8jh07pszMTD3//PN69tln9cILL2j58uW65ZZb9O2336pr167lXrZHK5RJlv+dje8xeVsO5d12d99uV3bttdfqxx9/tJs2fPhwNWvWTI888kixl7UuT3aQG56VG/v27dNrr71W6tnh573xxhuaOHGisrKy1LRpU61cuVIBAQFlrserOOk4xptzB67hzJkzRS6R7evrK6vVWuI85Ib75EZxynP8/ccff6igoKDY27Ls2bOnQvXAC7ly32AJvP1Y6XzfVfv27eXv76/Vq1erf//+kqS9e/cqNTWV443/cffcKO54Iy0trcitMfz8/BQZGVnqpfI//PBD3XbbbapZs6b8/PwUEhKiJUuW2L5s4RUqYX/H8QKcxaEB8UmTJql3796qV6+eTp8+rUWLFmnNmjVasWKFpHP3SLjooouUmJgoSXrggQfUtWtXTZ8+XX369NHixYu1detWvfnmm5W/JYCrslql8/cfKeUAGyWLiopSnz59lJSUJMMw1KdPH9WqVcuuTWpKis6ePaM7b73JbnpeXq6aX9ra9vzdeXP10aL3dPjQQWWfzVZeXq6aNmtmN0+LFi3sOtxr165t1zk/duxYjR07tsLb9NFHH2n06NH617/+JR8fH91xxx1q165difcvq6rLyFYmcqPyleXvYd++fTpz5oyuu+46u+m5ubl2l2h6/fXXNX/+fKWmpurs2bPKzc1VmzZt7OapzL+HvLw8DRw4UIZhaPbs2WXd5GKd77Ds27evxo8fL0lq06aNNm7cqDlz5jAgXhIyCS6uWrVqatmypd200NBQ1axZ0zad7HCMp+fGoUOH1KtXLw0YMKDY+8b+3aBBg3TdddfpyJEjevnllzVw4EB99913bvPZqkqRGfBQN954o6ZNm6Z69eqpRYsW2rFjh1555RXdddddZpfmEtw5N0rbJkePv4FKRaa6tNL6riIiIjRixAhNmDBBkZGRCg8P13333aeEhARdccUVZpfuEtw5Nyqzn0qSJk+erJMnT2rVqlWqVauWli5dqoEDB2r9+vW69NJLK7x8t8D+Di7MoQHxY8eOaciQITpy5IgiIiLUqlUrrVixwrYjS01Ntfsg2alTJy1atEhPPPGEHnvsMTVp0kRLly4t0skFwCSZmSW/9vczsI4dK7nt3w8gK3Aps5Lcddddtg8zr7/+epHXz/zvW5DzFn2s2Nr293EJ+N83Mr9Y8pGee/pxPT7lObW7rKNCw8I097VXtGPr93bt/37PGYvFUurZAuXVo0cPJScn648//pCfn5+qV6+u2NhYNWzYsNj25bmMrNncKjc86O8h83/b8tVXX+miiy6ye+38N5QXL16shx56SNOnT1dCQoKqVauml156Sd9/75y/h/MHGSkpKfrmm28qdHa4dO4bv35+fkXuRX/JJZdow4YNFVo2ANfmMtlBbpieG4cPH9bVV1+tTp06lfkLEBEREYqIiFCTJk10xRVXqEaNGlqyZInuuOMOh2sE4J5ee+01TZ48Wffee6+OHTumOnXq6J///KeefPJJ566Y3HBqblyIo8fftWrVkq+vb7lu6QXAvVyo72rGjBny8fFR//79lZOTo549e+qNN95wfmHkhmnHG7GxsTr2t//T/Px8HT9+vMQMSE5O1qxZs7R79261aNFCktS6dWutX79er7/+uubMmeNwjQAql0MD4vPmzSv19b/fF0KSBgwYoAEDBjhUFIAq4si9YZzVtox69eql3NxcWSwW9ezZs8jrjRo3UkBgoA4f+l1XdL6q2GVs/X6z2l/eUXfeNco2LTXlt0qv1VHnvzX5zTff6NixY7rpppuKbVeey8iaza1yw4P+Hpo3b67AwEClpqaWeKb0d999p06dOunee++1TUtOTq70WqW/DjL++9//6ttvv1XNmjUrvMyAgABdfvnl2rt3r930X3/9VfXr16/w8gG4jr9nhctkB7lham4cOnRIV199tdq3b68FCxaU6ww/wzBkGEaJt3IB4JmqVaummTNnaubMmVW7YnLDabnhiLIefwcEBKh9+/ZavXq1+vXrJ+ncVapWr15d4TPWAbiWC/VdBQUF6fXXXy92oNepyA3TjjcSEhJ08uRJbdu2Te3bt5d0LjesVqs6duxY7DLPn6zl6G1ZAFSdCt9DHACqgq+vr3755Rfb478LDQ3T3feM1bOTH5Fhteqyjgk6nZGhrT9sUrVq4ep/+yA1aNhISz78t9Z+s0px9etryYf/1q6d24t8M/FCZs2apSVLlmj16tUltjl+/LhSU1N1+PBhSbIN2sXGxtq+SbhgwQJdcsklioqK0qZNm/TAAw9o/Pjxatq0qW051157rW6++WaNHTu2TJeRhXe40N9DtWrV9NBDD2n8+PGyWq268sorderUKX333XcKDw/X0KFD1aRJE7377rtasWKF4uPj9d5772nLli2Kj493qJYL/T3k5eXp1ltv1fbt2/Xll1+qoKDAdr+lyMhI231bU1NTbX83BQUF2rlzpySpcePGCvvffbOaNWumxMRE3XzzzZKkhx9+WLfddpu6dOmiq6++WsuXL9cXX3xR7GAZAHgzT8uNQ4cOqVu3bqpfv75efvllpaf/dae485+zDh06pGuvvVbvvvuuOnTooP379+uDDz5Qjx49FBUVpd9//13PP/+8goODdf311zu0DQDg6dwpNyTnHH9L0oQJEzR06FBddtll6tChg2bOnKmsrCwNHz7coW0AAE/nTrlRluONSy65RL169dLIkSM1Z84c5eXlaezYsbr99ttVp865K5P+/XijWbNmaty4sf75z3/q5ZdfVs2aNbV06VKtXLlSX375pUPbAMA5GBAH4DYudInl8Y88plpR0Xrj1Zd1MOU3hUdEqMWlbXTvuIckSf8YOkI//7hL940cKovFoptuuVWDho7QmlXLHarjjz/+uOA3FD///HO7g+Tbb79dkvTUU0/p6aeflnTuIH3SpEk6fvy4GjRooMcff9x2L+Tzzl/SDfi7C/09TJ06VVFRUUpMTNT+/ftVvXp1tWvXTo899pgk6Z///Kd27Nih2267TRaLRXfccYfuvfdeff311w7VcaG/h0OHDunzzz+XpCL3ffr222/VrVs3SdKTTz6pd955x/ba+XtIFW6zd+9enTp1ytbm5ptv1pw5c5SYmKj7779fTZs21SeffKIrr7zSoW0AAG/gSbmxcuVK7du3T/v27VPdunXt2hiGIelcR9fevXttZ2oEBQVp/fr1mjlzpk6cOKGYmBh16dJFGzduVHR0tEPbAADewF1yQ3Le8fdtt92m9PR0Pfnkk0pLS1ObNm20fPlyxcTEOLQNAOAN3CU3ytpP9f7772vs2LG69tprbZfM/9e//mVr+/fjDX9/fy1btkyPPvqobrzxRmVmZqpx48Z65513+AIu4CIsxvkeAxeWkZGhiIgInTp1qsL3HIXrS05O1u133aMGfe5VeHTdC8/wNxnHftdvX72hxfPnqFGjRk6o0EFZWdL/zm5UZqZTLktTmuzsbB04cEDx8fEKCgqq0nVXlezsbO3/LVWB1aPk6xfg0LwF+bnKOZmuhg3qeeT/T2m/f0/et5a2bd7wN4Hi8buXXSbt37VLt42d4Dl564CKfNZw5+2uKHLDi/cdXsrrf/eVfBzjccd5uCByw0v3HV6M3z1KZHLfoCPMPFYiN9h3eBuP/N1XYH/H8QIc5WhucIY4UBX+d48qAABMRyYBAMqKzAAAoHKQqQC8Bfs7uCgGxAFnCw2VCt3XEAAA0xTKJOMCl54EAHg5jmMAAKgcZCoAb8H+Di7Mx+wCAAAAAAAAAAAAAABwBgbEAQAAAAAAAAAAAAAeiQFxwNnOnpW6dTv3c/as2dUAALxZoUyyZGebXQ0AwJVxHAMAQOUgUwF4C/Z3cGHcQxxwNqtVWrv2r8cmMQzDtHXDPPzeS8b/jffhdy6XySTAHbEP8T5e/zsnM4AK8fp9iBfid44SkakoA/Yh3scjf+fs7+DCOEMc8HD+/v6SpDNnzphcCcxw/vd+/n0AydfXV5KUm5trciWoaud/5+ffAwBQFuSG9+JzFIDyIDe8F8cbAMqD3PBe5AZQtThDHPBwvr6+ql69uo4dOyZJCgkJkcViMbmqypWTkyOrtUAFebmSg9+sK8jPk9VaoJycHCdVZw7DMHTmzBkdO3ZM1atX54NVIX5+fgoJCVF6err8/f3l48N3w7yB1WpVenq6QkJC5OfHxx8AZUdueB8+RwGoCHLDO3G8AaC8yA3vRG4AVY+/NMALxMbGSpJtUNzT5OXl6Y8/j8sv44x8HOywtBYUKP/saVnz8zzy7J/q1avbfv84x2KxqHbt2jpw4IBSUlLMLgdVyMfHR/Xq1fO4LwUBcC5yw3vxOQpAeZAb3ovjDQDlQW54L3IDqFoMiANe4PwHq+joaOXl5ZldTqVLTU3VK2+8qYu63qGwmo51Wmb+maZDa/+tV6Y9rXr16jmpQnP4+/tzRlMJAgIC1KRJEy5H5WUCAgL4pjWAciE3vA+fowBUBLnhnTjeAFBe5IZ3IjeAqsWAOOBFfH19PbJjz9fXV0ePpSv4TL7ywxybN+NMvo4eS5evr6+CgoKcUyBcko+PD79zAECZkRsAAEeQGwAAR5AbAOBcDIgDVSEkxOwKAAA4h0wCAJQVmQEAQOUgUwF4C/Z3cFEMiAPOFhoqZWWZXQUAAHaZZCQnm1wMAMClcRwDAEDlIFMBeAv2d3Bh3KAAAAAAAAAAAAAAAOCRGBAHAAAAAAAAAAAAAHgkBsQBZ8vOlvr0OfeTnW12NQAAb1Yokyw5OWZXAwBwZRzHAABQOchUAN6C/R1cGPcQB5ytoEBatuyvxwAAmKVwJj3/vLm1AABcG8cxAABUDjIVgLdgfwcXxhniAAAAAAAAAAAAAACPxIA4AAAAAAAAAAAAAMAjccl0AAAAAAAAAAAAAJVi//79MkJCytw+JSVF+Xn5TqwI3o4BcQAAAAAAAAAAAADllp6erqj/PR46+gFl+/qWed7ss2f0+6EjqpeX55zi4PUYEAcAAAAAAAAAAABQbqdPn7YNiNfvNVI5AUFlnvdY8m6lHJyvgnwGxOEcDIgDAAAAAAAAAAAAqBTVoi5SYGBwmdtn/pnmxGoAycfsAgCPFxoqGca5n9BQs6sBAHizQpnkyH2cgKoye/ZstWrVSuHh4QoPD1dCQoK+/vrrEtsnJSXJYrHY/QQFlf0b6ABKwXEMPFSDBg2KZIfFYtGYMWPMLg2ApyJTAXgJIyREl3fprgEvfKpcBwbDgarAGeIAAAAAXELdunX1/PPPq0mTJjIMQ++884769u2rHTt2qEWLFsXOEx4err1799qeWyyWqioXAOCGtmzZooKCAtvz3bt367rrrtOAAQNMrAoAAACAMzEgDgAAAMAl3HjjjXbPp02bptmzZ2vz5s0lDohbLBbFxsZWRXkAAA8QFRVl9/z5559Xo0aN1LVrV5MqAgAAAOBsXDIdcLbsbGnAgHM/2dlmVwMA8GaFMsmSk2N2NUCpCgoKtHjxYmVlZSkhIaHEdpmZmapfv77i4uLUt29f/fTTT1VYJeDBOI6BF8jNzdXChQt11113cYURAM5DpgLwEpacHCX+vEsTFr4kvzz6neBaOEMccLaCAunjj889TkoytRQAgJcrnElPPmluLUAJfvzxRyUkJCg7O1thYWFasmSJmjdvXmzbpk2bav78+WrVqpVOnTqll19+WZ06ddJPP/2kunXrlriOnJwc5RT6UkhGRkalbwfg9jiOgRdYunSpTp48qWHDhpXajtwAUCFkKgBvUVCg7n8ck/44pnetVrOrAexwhjgAAAAAl9G0aVPt3LlT33//vUaPHq2hQ4fq559/LrZtQkKChgwZojZt2qhr16769NNPFRUVpblz55a6jsTEREVERNh+4uLinLEpAAAXN2/ePPXu3Vt16tQptR25AQAAALg3zhAHAAAA4DICAgLUuHFjSVL79u21ZcsWvfrqqxcc5JYkf39/tW3bVvv27Su13aRJkzRhwgTb84yMDAY3AMDLpKSkaNWqVfr0008v2JbcAAAA3iI9Pb3cV8M5mJqqhpVcD1BZGBAHAAAA4LKsVqvdZWpLU1BQoB9//FHXX399qe0CAwMVGBhYGeUBANzUggULFB0drT59+lywLbkBAAC8QXp6ugYPv1vHT58p1/yWzNP6oZJrAioLA+IAAAAAXMKkSZPUu3dv1atXT6dPn9aiRYu0Zs0arVixQpI0ZMgQXXTRRUpMTJQkPfPMM7riiivUuHFjnTx5Ui+99JJSUlJ09913m7kZAAAXZ7VatWDBAg0dOlR+fnSNAQAASOeugnP89BlFJfRXaGSM4/Pv2S5t/94JlQEVx6d+AAAAAC7h2LFjGjJkiI4cOaKIiAi1atVKK1as0HXXXSdJSk1NlY+Pj639iRMnNHLkSKWlpalGjRpq3769Nm7cqObNm5u1CQAAN7Bq1SqlpqbqrrvuMrsUAAAAlxMaGaPw6LoOz5d3JMUJ1QCVgwFxAAAAAC5h3rx5pb6+Zs0au+czZszQjBkznFgRAMAT9ejRQ4ZhmF0GAAAAgCrCgDjgbCEhUmbmX48BADBLoUwyjhwxuRgAgEvjOAYAgMpBpgLwEjn+AYqNrqfOdz+p6gFBZpcD2GFAHHA2i0UKDTW7CgAA7DPJYjG3FgCAa+M4BgCAykGmAvAWFovO+PgoJyCIfie4HJ8LN/lLYmKiLr/8clWrVk3R0dHq16+f9u7dW+o8SUlJslgsdj9BQXwzBAC8AbkBAAAAAAAAV1WWvqtu3boV6au65557TKoYAFAeDg2Ir127VmPGjNHmzZu1cuVK5eXlqUePHsrKyip1vvDwcB05csT2k5KSUqGiAbeSkyMNG3buJyfH7GqAKkVuAC6GTAIAlBWZAQBA5SBTXVpZ+65Gjhxp11f14osvmlQx4Lr88/M0+2S6xi2ZK7+8XLPLAew4dMn05cuX2z1PSkpSdHS0tm3bpi5dupQ4n8ViUWxsbPkqBNxdfr70zjvnHr/+uhQYaG49QBUiNwAXUyiTLA8+aHIxAACXxnEMAACVg0x1aWXtuwoJCaGvCrgAH6tVg7KzpP+s1yfWArPLAew4dIb43506dUqSFBkZWWq7zMxM1a9fX3Fxcerbt69++umnUtvn5OQoIyPD7gcA4P7IDQAAAAAAALiqkvqu3n//fdWqVUstW7bUpEmTdObMmRKXQT8VALiecg+IW61WjRs3Tp07d1bLli1LbNe0aVPNnz9fn332mRYuXCir1apOnTrp999/L3GexMRERURE2H7i4uLKWyYAwEWQGwAAAAAAAHBVJfVd/eMf/9DChQv17bffatKkSXrvvfc0ePDgEpdDPxUAuB6HLple2JgxY7R7925t2LCh1HYJCQlKSEiwPe/UqZMuueQSzZ07V1OnTi12nkmTJmnChAm25xkZGYQGALg5cgMAAAAAAACuqqS+q1GjRtkeX3rppapdu7auvfZaJScnq1GjRkWWQz8VALiecg2Ijx07Vl9++aXWrVununXrOjSvv7+/2rZtq3379pXYJjAwUIHcSwUAPAa5AQAAAAAAAFflSN9Vx44dJUn79u0rdkCcfioAcD0OXTLdMAyNHTtWS5Ys0TfffKP4+HiHV1hQUKAff/xRtWvXdnheAIB7ITcAAAAAAADgqsrTd7Vz505Joq8KANyIQ2eIjxkzRosWLdJnn32matWqKS0tTZIUERGh4OBgSdKQIUN00UUXKTExUZL0zDPP6IorrlDjxo118uRJvfTSS0pJSdHdd99dyZsCAHA15AYAAAAAAABc1YX6rpKTk7Vo0SJdf/31qlmzpnbt2qXx48erS5cuatWqlcnVAwDKyqEB8dmzZ0uSunXrZjd9wYIFGjZsmCQpNTVVPj5/nXh+4sQJjRw5UmlpaapRo4bat2+vjRs3qnnz5hWrHHAXISHSsWN/PQa8CLkBuJhCmWScOmVyMQAAl8ZxDAAAlYNMdWkX6rsKCAjQqlWrNHPmTGVlZSkuLk79+/fXE088YUK1gGvL8Q9QfHScEoZOUnBAkNnlAHYcGhA3DOOCbdasWWP3fMaMGZoxY4ZDRQEexWKRoqLMrgIwBbkBuJjCmZSRYW4tAADXxnEMAACVg0x1aRfqu4qLi9PatWurqBrAzVks+tPHVxmh4Qq2WMyuBrDj0D3EAQAAAAAAAAAAAABwFwyIA86WkyONGXPuJyfH7GoAAN6MTAIAlBWZAQBA5SBTAXgJ//w8Tc/4U/d8lSS/vFyzywHsMCAOOFt+vvTGG+d+8vPNrgYA4M0KZZKloMDsagAArozjGAAAKgeZCsBL+FitGnnmtG7Ysko+Vvqd4FoYEAcAAAAAAAAAAAAAeCQGxAEAAAAAAAAAAAAAHokBcQAAAAAAAAAAAACAR2JAHAAAAAAAAAAAAADgkRgQBwAAAAAAAAAAAAB4JAbEAQAAAAAAAAAAAAAeyc/sAgCPFxwsHTjw12MAAMxSKJOMvDyTiwEAuDSOYwAAqBxkKgAvkevvr5a1LlKHQQ/Jxz/Q7HIAOwyIA87m4yM1aGB2FQAA2GdScrKppQAAXBzHMQAAVA4yFYCXMCw+SvXzV4MaUYrx4QLVcC28IwEAAAAAAAAAAAAAHokBccDZcnOlhx8+95Oba3Y1AABvRiYBAMqKzAAAoHKQqQC8hF9BvqZmHNfw/1sk33xu1QfXwoA44Gx5edLLL5/74X6tAAAzFcokS36+2dUARcyePVutWrVSeHi4wsPDlZCQoK+//rrUeT766CM1a9ZMQUFBuvTSS7Vs2bIqqhbwcBzHwIMdOnRIgwcPVs2aNRUcHKxLL71UW7duNbssAJ6KTAXgJXwLCvTAmQz137hMvgX0O8G1MCAOAAAAwCXUrVtXzz//vLZt26atW7fqmmuuUd++ffXTTz8V237jxo264447NGLECO3YsUP9+vVTv379tHv37iquHADgLk6cOKHOnTvL399fX3/9tX7++WdNnz5dNWrUMLs0AAAAAE7iZ3YBAAAAACBJN954o93zadOmafbs2dq8ebNatGhRpP2rr76qXr166eGHH5YkTZ06VStXrtSsWbM0Z86cKqkZAOBeXnjhBcXFxWnBggW2afHx8SZWBAAAAMDZOEMcAAAAgMspKCjQ4sWLlZWVpYSEhGLbbNq0Sd27d7eb1rNnT23atKkqSgQAuKHPP/9cl112mQYMGKDo6Gi1bdtWb731ltllAQAAAHAizhAHAAAA4DJ+/PFHJSQkKDs7W2FhYVqyZImaN29ebNu0tDTFxMTYTYuJiVFaWlqp68jJyVFOTo7teUZGRsULB6pIenp6hd6zubm5CggIuGA7y5kzavi/x/v375cREqLw8HBFRUWVe92AK9i/f79mz56tCRMm6LHHHtOWLVt0//33KyAgQEOHDi12HnIDAAAAcG8MiAMAAABwGU2bNtXOnTt16tQpffzxxxo6dKjWrl1b4qB4eSQmJmrKlCmVtjygqqSnp2vw8Lt1/PSZcs2fl5urQ6kpqls/Xn7+pXcHBBUUaP3/Hg8d/YCyfX0VWS1ECxe8zaA43JrVatVll12m5557TpLUtm1b7d69W3PmzClxQJzcAAAAANwbA+IAAAAAXEZAQIAaN24sSWrfvr22bNmiV199VXPnzi3SNjY2VkePHrWbdvToUcXGxpa6jkmTJmnChAm25xkZGYqLi6uE6gHnysjI0PHTZxSV0F+hkTEXnuFvjiXv1v7f5qtGh76qWad+qW0Dc7Ol776VJNXvNVLHM08pfdMnysjIYEAcbq127dpFvmR1ySWX6JNPPilxHnIDAAAAcG8MiAPOFhws7d7912MAAMxSKJOMMlwuF3AFVqvV7jK1hSUkJGj16tUaN26cbdrKlStLvOf4eYGBgQoMDKzMMoEqFRoZo/Doug7Pl/nnudsJhNSIuuD8FqtVk5/9tyQpqHa8Qv84rHTHSwVcTufOnbV37167ab/++qvq1y/5SyLkBoAKoW8QgJfI9fdXh5p1dNlt9yvPn89OcC0MiAPO5uMjtWhhdhUAANhnUnKyubUAxZg0aZJ69+6tevXq6fTp01q0aJHWrFmjFStWSJKGDBmiiy66SImJiZKkBx54QF27dtX06dPVp08fLV68WFu3btWbb75p5mYAHsHw8dHhixqZXQZQ6caPH69OnTrpueee08CBA/XDDz/ozTffJDsAOA99gwC8hGHx0R7/AEVH11WMj4/Z5QB2GBAHAAAA4BKOHTumIUOG6MiRI4qIiFCrVq20YsUKXXfddZKk1NRU+RQ6qO7UqZMWLVqkJ554Qo899piaNGmipUuXqmXLlmZtAgDAxV1++eVasmSJJk2apGeeeUbx8fGaOXOmBg0aZHZpAAAAkqT09HRlZGSUe/7c3FwFlOPKgCkpKcrPyy/3egFXxoA44Gy5udJzz517/NhjEpeoBQCYpXAm3XabubUAxZg3b16pr69Zs6bItAEDBmjAgAFOqgjwXr75eerz5QJJ0lc3DDe5GqBy3XDDDbrhhhvMLgOAt6BvEIAD0tPTNXj43Tp++ky55s/LzdWh1BTVrR8vP3/HhgCzz57R74eOqF5eXrnW7VeQr0mnT6j+t59ozeCHVODnX67lAM7AgDjgbHl50pQp5x4//DAfegEA5imUSZb+/U0uBgDgynwL8tX3s7clSct732lyNQAAuDH6BgE4ICMjQ8dPn1FUQn+FRsY4PP+x5N3a/9t81ejQVzXr1Hd43pSD81WQX74Bcd+CAk3KOiWtXaL1d4xjQBwuhQFxAAAAAAAAAAAAwEWERsYoPLquw/Nl/pkmSQqpEeXw/OfnBTwRd7UHAAAAAAAAAAAAAHgkBsQBAAAAAAAAAAAAAB6JAXEAAAAAAAAAAAAAgEdiQBwAAAAAAAAAAAAA4JEYEAcAAAAAAAAAAAAAeCQ/swsAPF5QkPTDD389BgDALIUyyQgMNLkYAIAry/MP0NTJSbbHAACgnOgbBOAl8vz81a1mbbW95R6OIeByGBAHnM3XV7r8crOrAADAPpOSk82tBQDg0gwfX/3WsLnZZQAA4P7oGwTgJaw+PtruH6iwixopxsfX7HIAO1wyHQAAAAAAAAAAAADgkThDHHC23Fzp1VfPPX7gASmAS4UAAExSOJNuuMHcWgAALs03P0/dVy6WJK267naTqwEAwI3RNwjAS/gV5Ov+rFNq+N2X2nzRfSrw8ze7JMCGAXHA2fLypIkTzz2+914+9AIAzFMokyy9eplcDADAlfkW5Gvgh69Jkr695laTqwEAwI3RNwjAS/gWFOjZ0yeklYu1pf9oBsThUrhkOgAAAAAAAAAAAADAIzEgDgAAAAAAAAAAAADwSA4NiCcmJuryyy9XtWrVFB0drX79+mnv3r0XnO+jjz5Ss2bNFBQUpEsvvVTLli0rd8EAAPdBbgAAAAAAAMBVlaXvKjs7W2PGjFHNmjUVFham/v376+jRoyZVDAAoD4cGxNeuXasxY8Zo8+bNWrlypfLy8tSjRw9lZWWVOM/GjRt1xx13aMSIEdqxY4f69eunfv36affu3RUuHgDg2sgNAAAAAAAAuKqy9F2NHz9eX3zxhT766COtXbtWhw8f1i233GJi1QAAR/k50nj58uV2z5OSkhQdHa1t27apS5cuxc7z6quvqlevXnr44YclSVOnTtXKlSs1a9YszZkzp5xlAwDcAbkBAAAAAAAAV3WhvqtTp05p3rx5WrRoka655hpJ0oIFC3TJJZdo8+bNuuKKK8woGwDgoArdQ/zUqVOSpMjIyBLbbNq0Sd27d7eb1rNnT23atKkiqwYAuCFyAwAAAAAAAK7q731X27ZtU15enl1fVbNmzVSvXj36qgDAjTh0hnhhVqtV48aNU+fOndWyZcsS26WlpSkmJsZuWkxMjNLS0kqcJycnRzk5ObbnGRkZ5S3T7aWnp1do+8PDwxUVFVWJFZVdeWtPSUlRfl5+hdadl5urlJSUcs9fqf9vQUHSt9/+9RjFqsh7vTLeM3A+cgMX4o2ZJ0m5ubkKCAgo97od2u5CmWQEBpZ7nee5VN4CACpVnn+AXnxktu0xAAAoJ/oG3UZxfVdpaWkKCAhQ9erV7dqW1ldFPxW8VZ6fv66vEaPWN40w5RiCfiqUptwD4mPGjNHu3bu1YcOGyqxHkpSYmKgpU6ZU+nLdTXp6ugYPv1vHT58p9zIiq4Vo4YK3q/yPuCK1Z589o98PHVG9vLxyrTsn85R+O7Bf4x57WoHl7Oyv1P83X1+pW7eKL8eDVfS9XtH3DKoGuYHSeGvm5eXm6lBqiurWj5eff/k+ljm03YUzKTm5XOs7z+XyFgBQqQwfX+1t1t7sMgAAcH/0DbqNyuq7op8K3srq46PvAoPlE99cMT6+Vbpu+qlwIeXqeR07dqy+/PJLrVu3TnXr1i21bWxsrI4ePWo37ejRo4qNjS1xnkmTJmnChAm25xkZGYqLiytPqW4tIyNDx0+fUVRCf4VGxlx4hr/JOn5U6Zs+UUZGRpX/AVek9mPJu5VycL4K8ss3uJmXc1ZWi59qXXGLatap7/D8Zv6/eauKvtcr+p6B85EbuBBvzrz9v81XjQ593S6zyFsAAAAAgKcoqe8qNjZWubm5OnnypN1Z4qX1VdFPBVQ9+qlwIQ4NiBuGofvuu09LlizRmjVrFB8ff8F5EhIStHr1ao0bN842beXKlUpISChxnsDAwHJ/g8MThUbGKDy69AGkkqRXci2OKk/tmX+WfFlkR4TUiHKN/7e8POnNN889HjVK8vevzKV7lPK+1yvrPYPKR27AUd6aeVWWWYUz6dpry7W+v3OZvAUAVCrf/Hx1WbtEkrSu680mVwMAgBujb9ClXajvqn379vL399fq1avVv39/SdLevXuVmppaYl8V/VTwVr4FBRqZlaHGP6zUjosaqsCv3BepLjf6qVASh96NY8aM0aJFi/TZZ5+pWrVqtntkREREKDg4WJI0ZMgQXXTRRUpMTJQkPfDAA+rataumT5+uPn36aPHixdq6davePP8hAPB0ubnS2LHnHg8bxodeeBVyA3AxhTLJsmuXycUAAFyZb0GeBi98SZL03ZU3mFwNAABujL5Bl3ahvquIiAiNGDFCEyZMUGRkpMLDw3XfffcpISFBV1xxhcnVA67FryBf008fl5a9o9E33WXKgDhQEh9HGs+ePVunTp1St27dVLt2bdvPBx98YGuTmpqqI0eO2J536tRJixYt0ptvvqnWrVvr448/1tKlS9WyZcvK2woAgEsiNwAAAAAAAOCqytJ3NWPGDN1www3q37+/unTpotjYWH366acmVg0AcJTDl0y/kDVr1hSZNmDAAA0YMMCRVQEAPAC5AQAAAAAAAFdVlr6roKAgvf7663r99deroCIAgDM4dIY4AAAAAAAAAAAAAADuggFxAAAAAAAAAAAAAIBHYkAcAAAAgEtITEzU5ZdfrmrVqik6Olr9+vXT3r17S50nKSlJFovF7icoKKiKKgYAuJunn366SG40a9bM7LIAAAAAOJFD9xAHAAAAAGdZu3atxowZo8svv1z5+fl67LHH1KNHD/38888KDQ0tcb7w8HC7gXOLxVIV5QIA3FSLFi20atUq23M/P7rHAAAAAE/GJ37A2QIDpS+//OsxAABmKZRJRkCAycUARS1fvtzueVJSkqKjo7Vt2zZ16dKlxPksFotiY2OdXR7gVfL9/PXquFdsjwFP4ufnR24AqDr0DQLwEnl+fhpQPVotrr+TYwi4HAbEAWfz85P69DG7CgAA7DMpOdncWoAyOHXqlCQpMjKy1HaZmZmqX7++rFar2rVrp+eee04tWrQosX1OTo5ycnJszzMyMiqnYMCDWH39tKv1lWaXATjFf//7X9WpU0dBQUFKSEhQYmKi6tWrV2J7cgNAhdA3CMBLWH18tSIoRGcvbqsYX4Yf4Vq4hzgAAAAAl2O1WjVu3Dh17txZLVu2LLFd06ZNNX/+fH322WdauHChrFarOnXqpN9//73EeRITExUREWH7iYuLc8YmAABcUMeOHZWUlKTly5dr9uzZOnDggK666iqdPn26xHnIDQAAAMC9MSAOOFtenpSUdO4nL8/sagAA3oxMghsZM2aMdu/ercWLF5faLiEhQUOGDFGbNm3UtWtXffrpp4qKitLcuXNLnGfSpEk6deqU7efgwYOVXT7g9nzz89V5w5fqvOFL+ebnm10OUGl69+6tAQMGqFWrVurZs6eWLVumkydP6sMPPyxxHnIDQIVwHAbAS/gWFOgfZ07r2h3rOIaAy+GaBYCz5eZKw4efezxggOTPvTMAACYplEmWXbtMLgYo2dixY/Xll19q3bp1qlu3rkPz+vv7q23bttq3b1+JbQIDAxXI/RuBUvkW5Omuec9IkrZcfq3J1QDOU716dV188cXkBgDnoW8QgJfwK8jXnIw/pc/e1Ojeg1TgxxAkXAdniAMAAABwCYZhaOzYsVqyZIm++eYbxcfHO7yMgoIC/fjjj6pdu7YTKgQAeJrMzEwlJyeTGwAAAIAHY0AcAAAAgEsYM2aMFi5cqEWLFqlatWpKS0tTWlqazp49a2szZMgQTZo0yfb8mWee0f/93/9p//792r59uwYPHqyUlBTdfffdZmwCAMDFPfTQQ1q7dq1+++03bdy4UTfffLN8fX11xx13mF0aAAAAACfhegUAAAAAXMLs2bMlSd26dbObvmDBAg0bNkySlJqaKh+fv77Xe+LECY0cOVJpaWmqUaOG2rdvr40bN6p58+ZVVTYAwI38/vvvuuOOO/Tnn38qKipKV155pTZv3qyoqCizSwMAAADgJAyIAwAAAHAJhmFcsM2aNWvsns+YMUMzZsxwUkUAAE+zePFis0sAAAAAUMW4ZDoAAAAAAAAAAAAAwCMxIA4AAAAAAAAAAAAA8EhcMh1wtsBA6cMP/3oMAIBZCmWSERBgcjEAAFeW7+ev2fc+Z3sMAADKib5BAF4iz89PQ6pH6ZLrbucYAi6HAXHA2fz8pAEDzK4CAAD7TEpONrcWAIBLs/r6aevl3c0uAwAA90ffIAAvYfXx1dKgUB1v0VExvgw/wrVwyXQAAAAAAAAAAAAAgEfiKxqAs+XnS0uWnHt8883nvhUKAIAZCmdSq1bm1gIAcGk+Bflqt32NJGl7u26m1gIAgFujbxCAl/CxFqhfdpYu+el77a/bUFbOEocL4d0IOFtOjjRw4LnHmZl86AUAmKdQJll27TK5GACAK/PLz9PoNx6TJI2es9bkagAAcGP0DQLwEv75+Xr3ZLr00Wsafe2tymVAHC6ES6YDAAAAAAAAAAAAADwSA+IAAAAAAAAAAAAAAI/EgDgAAAAAAAAAAAAAwCMxIA4AAAAAAAAAAAAA8EgMiAMAAAAAAAAAAAAAPBID4gAAAAAAAAAAAAAAj+RndgGAxwsIkBYs+OsxAABmKZRJhr+/ycUAAFxZga+/5o940vYYAACUE32DALxEvq+f7gmvqaZX9+cYAi6HAXHA2fz9pWHDzK4CAAD7TEpONrUUAIBrK/Dz03dX3mB2GQAAuD/6BgF4iQJfXy0KqaYubbsoxo/hR7gWLpkOAAAAAAAAAAAAAPBIfEUDcLb8fGnFinOPe/aU+GYUAMAshTOpcWNzawEAuDSfgny13L1ZkrS75RUmVwMAgBujbxCAl/CxFqhn9hm1+HWHDtVtKKsv+zu4Dt6NgLPl5Eg3/O9Sg5mZfOgFAJinUCZZdu0yuRgAgCvzy8/TAzMnSJJGz1lrcjUAALgx+gYBeAn//Hx9dPKYtGi6Rne5SbkMiMOFcMl0AAAAAAAAAAAAAIBHYkAcAAAAAAAAAAAAAOCRGBAHAAAAAAAAAAAAAHgkBsQBAAAAAAAAAAAAAB6JAXEAAAAAAAAAAAAAgEdiQBwAAAAAAAAAAAAA4JH8zC4A8HgBAdKsWX89BgDALIUyyfD3N7kYAIArK/D118LBD9seAwCAcqJvEICXyPf104PVItX4qhs5hoDLYUAccDZ/f2nMGLOrAADAPpOSk82tBQDg0gr8/PTttQPMLgMAAPdH3yAAL1Hg66u3QsPVpcN1ivFj+BGuxeFLpq9bt0433nij6tSpI4vFoqVLl5bafs2aNbJYLEV+0tLSylszAMCNkBsAgLJKTEzU5ZdfrmrVqik6Olr9+vXT3r17LzjfRx99pGbNmikoKEiXXnqpli1bVgXVAgA8wfPPPy+LxaJx48aZXQoAwAQX6rcaNmxYkT6qXr16mVMsAKDcHB4Qz8rKUuvWrfX66687NN/evXt15MgR2090dLSjqwbcU0GBtGbNuZ+CArOrAaocuQG4EDIJLm7t2rUaM2aMNm/erJUrVyovL089evRQVlZWifNs3LhRd9xxh0aMGKEdO3aoX79+6tevn3bv3l2FlQOex2ItUNM929R0zzZZrGQGPNOWLVs0d+5ctWrVyuxSAHgyjsNcWln6rXr16mXXR/Xvf/+7CisE3IeP1aorc87q0gM/cwwBl+PwNQt69+6t3r17O7yi6OhoVa9e3eH5ALeXnS1dffW5x5mZUmioufUAVYzcAFxIoUyy7NplcjFAUcuXL7d7npSUpOjoaG3btk1dunQpdp5XX31VvXr10sMPn7vX8dSpU7Vy5UrNmjVLc+bMcXrNgKfyz8vVxBdGS5JGz1lrcjVA5cvMzNSgQYP01ltv6dlnnzW7HACejL5Bl1aWfqvAwEDFxsZWUUWA+/LPz9PSE0eld57T6ISeyg0MNrskwKbKLuLfpk0b5eTkqGXLlnr66afVuXPnEtvm5OQoJyfH9jwjI6MqSgQAuBByAwBw6tQpSVJkZGSJbTZt2qQJEybYTevZs2ept+ggNyBJ6enp5f7dh4eHKyoqqsrXnZKSovy8/HKvF+Vn5vuloty5dmcaM2aM+vTpo+7du19wQJzcALxPRfadkmfvP73RmjVrFB0drRo1auiaa67Rs88+q5o1a5bYntwAANfj9AHx2rVra86cObrsssuUk5Ojt99+W926ddP333+vdu3aFTtPYmKipkyZ4uzSAAAuiNwAAEiS1WrVuHHj1LlzZ7Vs2bLEdmlpaYqJibGbFhMTo7S0tBLnITeQnp6uwcPv1vHTZ8o1f2S1EC1c8Ha5Ororsu7ss2f0+6EjqpeX5/C8KD8z3y8V5c61O9PixYu1fft2bdmypUztyQ3Au1R03yl57v7TG/Xq1Uu33HKL4uPjlZycrMcee0y9e/fWpk2b5OvrW+w85AYAuB6nD4g3bdpUTZs2tT3v1KmTkpOTNWPGDL333nvFzjNp0iS7szwyMjIUFxfn7FIBAC6A3AAASOfO3Nu9e7c2bNhQ6csmN5CRkaHjp88oKqG/QiNjLjxDIVnHjyp90yfKyMgoVyd3RdZ9LHm3Ug7OV0E+A+JVycz3S0W5c+3OcvDgQT3wwANauXKlgoKCyjQPuQF4l4rsOyXP3X96q9tvv932+NJLL1WrVq3UqFEjrVmzRtdee22x85AbAOB6quyS6YV16NCh1I6twMBABQYGVmFFAABXRm4AgHcZO3asvvzyS61bt05169YttW1sbKyOHj1qN+3o0aOl3uOP3MB5oZExCo8u/T1WnHST1p35Z8lXPoDzmfl+qSh3rr2ybdu2TceOHbO7+lRBQYHWrVunWbNmKScnp8gZf+QG4J3Ku++UPHP/iXMaNmyoWrVqad++fSUOiJMbAOB6fMxY6c6dO1W7dm0zVg0AcEPkBgB4B8MwNHbsWC1ZskTffPON4uPjLzhPQkKCVq9ebTdt5cqVSkhIcFaZAAA3du211+rHH3/Uzp07bT+XXXaZBg0apJ07d5Z4+VsAACTp999/159//kk/FQC4GYfPEM/MzNS+fftszw8cOKCdO3cqMjJS9erV06RJk3To0CG9++67kqSZM2cqPj5eLVq0UHZ2tt5++2198803+r//+7/K2woAgMsiNwAAZTVmzBgtWrRIn332mapVq2a7D3hERISCg4MlSUOGDNFFF12kxMRESdIDDzygrl27avr06erTp48WL16srVu36s033zRtOwAArqtatWpq2bKl3bTQ0FDVrFmzyHQAgOcrrd8qMjJSU6ZMUf/+/RUbG6vk5GRNnDhRjRs3Vs+ePU2sGgDgKIcHxLdu3aqrr77a9vz8vTCGDh2qpKQkHTlyRKmpqbbXc3Nz9eCDD+rQoUMKCQlRq1attGrVKrtlAB7N31968cW/HgNehtwAXEihTDL8TLlzDlCq2bNnS5K6detmN33BggUaNmyYJCk1NVU+Pn9d6KpTp05atGiRnnjiCT322GNq0qSJli5dyqAGUEEFvn76cOB9tscAAKCc6Bt0aaX1W82ePVu7du3SO++8o5MnT6pOnTrq0aOHpk6dyiXRgWIU+PrqiWo11PCKnhxDwOU4/I7s1q2bDMMo8fWkpCS75xMnTtTEiRMdLgzwGAEB0sMPm10FYBpyA3AhhTMpOdncWoBilJYX561Zs6bItAEDBmjAgAFOqAjwXgV+/lrR+06zywCqRHHZAgCVhr5Bl3ahfqsVK1ZUYTWAe8v39dO/QiPUpfMNivHjC0BwLabcQxwAAAAAAAAAAAAAAGfjmgWAsxUUSNu3n3vcrp3k62tuPQAA71U4kyIizK0FAODSLNYC1f9tryQppUFTk6sBAMCN0TcIwEv4WK1ql5ejJoeSdTqukQwf9ndwHQyIA86WnS116HDucWamFBpqbj0AAO9VKJMsu3aZXAwAwJX55+Vq8tRhkqTRc9aaWwwAAO6MvkEAXsI/P09r/jwivfWURrfvptzAYLNLAmy4ZDoAAAAAAAAAAAAAwCMxIA4AAAAAAAAAAAAA8EgMiAMAAAAAAAAAAAAAPBID4gAAAAAAAAAAAAAAj8SAOAAAAAAAAAAAAADAIzEgDgAAAAAAAAAAAADwSH5mFwB4PH9/6amn/noMAIBZCmWS4cfHQABAyQp8/fRZ37ttjwEAQDnRNwjASxT4+ioxNEL1L7uGYwi4HN6RgLMFBEhPP212FQAA2GdScrKppQAAXFuBn78+7zfK7DIAAHB/9A0C8BL5vn5KrFZDXa7urxg/vgAE18Il0wEAAAAAAAAAAAAAHokzxAFns1qlX3459/iSSyQfvocCADBJ4UwKCDC3FgCAS7NYrap95IAk6UjteJOrAQDAjdE3CMBLWAyrmuXlqt6x35Ub11gG+zu4EAbEAWc7e1Zq2fLc48xMKTTU3HoAAN6rUCZZdu0yuRgAgCvzz8vR1CfukCSNnrPW5GoAAHBj9A0C8BIBeXn64c/D0huPavSctcoNDDa7JMCGr2cAAAAAAAAAAAAAADwSA+IAAAAAAAAAAAAAAI/EgDgAAAAAAAAAAAAAwCMxIA4AAAAAAAAAAAAA8EgMiAMAAAAAAAAAAAAAPBID4gAAAAAAAAAAAAAAj+RndgGAx/P3lx566K/HAACYpVAmGX58DAQAlKzA10/Lew22PQYAAOVE3yAAL1Hg66tXQ8JVt82VHEPA5fCOBJwtIEB66SWzqwAAwD6TkpPNrQUA4NIK/Pz10W33m10GAADuj75BAF4i39dPk8Mj1aXHPxTjxxeA4Fq4ZDoAAAAAAAAAAAAAwCNxhjjgbFarlJp67nG9epIP30MBAJikcCZZrebWAgBwaRarVZHH0yRJxyNjTa4GAAA3Rt8gAC9hMayql5+n6BPpssQ1lsH+Di6EdyPgbGfPSvHx537OnjW7GgCANyuUSZbsbLOrAQC4MP+8HL34cD+9+HA/+eflmF0OAADui75BAF4iIC9Pu/84pPmvjucYAi6HAXEAAAAAAAAAAAAAgEdiQBwAAACAy1i3bp1uvPFG1alTRxaLRUuXLi21/Zo1a2SxWIr8pKWlVU3BAAC3Mnv2bLVq1Urh4eEKDw9XQkKCvv76a7PLAgAAAOBEDIgDAAAAcBlZWVlq3bq1Xn/9dYfm27t3r44cOWL7iY6OdlKFAAB3VrduXT3//PPatm2btm7dqmuuuUZ9+/bVTz/9ZHZpAAAAAJzEz+wCAAAAAOC83r17q3fv3g7PFx0drerVq1d+QQAAj3LjjTfaPZ82bZpmz56tzZs3q0WLFiZVBQAAAMCZGBAHAAAA4PbatGmjnJwctWzZUk8//bQ6d+5cYtucnBzl5OTYnmdkZFRFiQAAF1NQUKCPPvpIWVlZSkhIKLEduQGYIz09vUJ/b+Hh4YqKiqrEigAAgLtiQBwAAACA26pdu7bmzJmjyy67TDk5OXr77bfVrVs3ff/992rXrl2x8yQmJmrKlClVXCkAwFX8+OOPSkhIUHZ2tsLCwrRkyRI1b968xPbkBlD10tPTNXj43Tp++ky5lxFZLUQLF7zNoDgAAGBAHHA6Pz/p3nv/egwAgFkKZZLh62tyMUDlaNq0qZo2bWp73qlTJyUnJ2vGjBl67733ip1n0qRJmjBhgu15RkaG4uLinF4r4E6sPr765ppbbY8BT9K0aVPt3LlTp06d0scff6yhQ4dq7dq1JQ6KkxtA1cvIyNDx02cUldBfoZExDs+fdfyo0jd9ooyMDPMHxOkbBOAlrD4+eiukmmq36MgxBFwOCQw4W2Cg9PrrZlcBAIB9JiUnm1sL4EQdOnTQhg0bSnw9MDBQgYGBVVgR4H7y/QP0/p0TzS4DcIqAgAA1btxYktS+fXtt2bJFr776qubOnVtse3IDME9oZIzCo+uWa970Sq6l3OgbBOAl8vz89WB4TXXpM0wx/gFmlwPY8TG7AAAAAACoTDt37lTt2rXNLgMA4CasVqvdPcIBAAAAeBbOEAeczTCkP/4497hWLcliMbceAID3KpxJhmFuLUAJMjMztW/fPtvzAwcOaOfOnYqMjFS9evU0adIkHTp0SO+++64kaebMmYqPj1eLFi2UnZ2tt99+W998843+7//+z6xNADyDYSjs9ElJUma16qaWAlSmSZMmqXfv3qpXr55Onz6tRYsWac2aNVqxYoXZpQHwVPQNAvAWhqGa1gKFZ2Wc2/exv4MLYUAccLYzZ6To6HOPMzOl0FBz6wEAeK9CmWTZtcvkYoDibd26VVdffbXt+fl7tg4dOlRJSUk6cuSIUlNTba/n5ubqwQcf1KFDhxQSEqJWrVpp1apVdssA4LiA3Gy9+kBPSdLoOWtNrgaoPMeOHdOQIUN05MgRRUREqFWrVlqxYoWuu+46s0sD4KnoGwTgJQLzcnXg2EHppXs1es5a5QYGm10SYMOAOAAAAACX0a1bNxmlXMEgKSnJ7vnEiRM1cSL3OQYAlM28efPMLgEAAABAFeMe4gAAAAAAAAAAAAAAj+TwgPi6det04403qk6dOrJYLFq6dOkF51mzZo3atWunwMBANW7cuMhZHQAAz0VuAAAAAAAAwBVdqN/KMAw9+eSTql27toKDg9W9e3f997//NadYAEC5OTwgnpWVpdatW+v1118vU/sDBw6oT58+uvrqq7Vz506NGzdOd999t1asWOFwsQAA90NuAAAAAAAAwBVdqN/qxRdf1L/+9S/NmTNH33//vUJDQ9WzZ09lZ2dXcaUAgIpw+B7ivXv3Vu/evcvcfs6cOYqPj9f06dMlSZdccok2bNigGTNmqGfPno6uHgDgZsgNAAAAAAAAuKLS+q0Mw9DMmTP1xBNPqG/fvpKkd999VzExMVq6dKluv/32qiwVAFABTr+H+KZNm9S9e3e7aT179tSmTZucvWoAgBsiNwAAAAAAAGC2AwcOKC0tza6fKiIiQh07dqSfCgDcjMNniDsqLS1NMTExdtNiYmKUkZGhs2fPKjg4uMg8OTk5ysnJsT3PyMioUA3p6ekVWkZubq4CAgLKPX94eLiioqLKPT/cS5H3W06Oom655dxrKSlSYGCp81fk/VbR96q3vtfzcnOVkpJS7vkrut0V2Ue56/95aTwhN9z591KRba/IPiQlJUX5efnlmtfbObQPK5RJKYcOufX/eUXeqxV9v1U0N8zMa3fePwGoWlYfX33XuY/tMQAAKCc/P2no0L8ew22kpaVJUrH9VOdfK05l91PBPZW338Kd+8isPj56PyhUMU3bcQwBl+OSCZyYmKgpU6ZUyrLS09M1ePjdOn76TLnmz8vN1aHUFNWtHy8///L9d0VWC9HCBW/T+egFLvh+G/1AqfNX5P1W0feqt77XczJP6bcD+zXusacVeIEvK5SkIttd0X2UO/6fO4Mr5Ybkvr+Ximx7Rfch2WfP6PdDR1QvL8/heb1ZRfZh2U9Oddv/84r+nVbk/VbR3DA7r911/wSg6uX7B2j+3U+ZXQYAAO4vMFBKSjK7ClShyuyngnuqSL+FO/eR5fn5a3T1KHW5+Z+K8S//iQCAMzh9QDw2NlZHjx61m3b06FGFh4cXe5afJE2aNEkTJkywPc/IyFBcXFy51p+RkaHjp88oKqG/QiNjLjzD3xxL3q39v81XjQ59VbNOfYfnzzp+VOmbPlFGRgYdj17AzPdbRd+r3vpez8s5K6vFT7WuuMWU7a7Ie8Zd/88vxN1zw51/LxXZ9srYB6UcnK+CfPf7sG+miuzD3Pn/vDLytrzbXtHcMDOv3Xn/BAAAAABVLTY2VtK5fqnatWvbph89elRt2rQpcb7K7KeCe6poH5u79tcArszpA+IJCQlatmyZ3bSVK1cqISGhxHkCAwPLfaZmSUIjYxQeXdfh+TL/PHfpk5AaUeWaX5LSyzUX3Jnd+80wFJCbLUnKDQiSLJYS56vI+62i71Vvf6+bvd3l3Ue58/95Sdw9NyT3/72UZ9srax+E8inz/3uhTMqMqOnkqpyvop/vKsKsvK3o/O6+fwJQhf5+HAMAAMrHMKQz/ztLNCSk1L5BuJb4+HjFxsZq9erVtgHwjIwMff/99xo9enSJ8zmjnwruqSJ9bG7JMBRitSowN/vcvo/9HVyIj6MzZGZmaufOndq5c6ck6cCBA9q5c6dSU1Mlnfv205AhQ2zt77nnHu3fv18TJ07Unj179MYbb+jDDz/U+PHjK2cLABcXkJut2fd01ex7uto6lABvQm4ArqNwJgXm5ZpdDgDAhXEcAwBAJTlzRgoLO/dzpvy3Z4NzlNZvZbFYNG7cOD377LP6/PPP9eOPP2rIkCGqU6eO+vXrZ2rdgCsKzMtV2rFUffLc3RxDwOU4fIb41q1bdfXVV9uen7/0x9ChQ5WUlKQjR47YBjmkc9+i+uqrrzR+/Hi9+uqrqlu3rt5++2317NmzEsoHALg6cgMAAAAAAACu6EL9VhMnTlRWVpZGjRqlkydP6sorr9Ty5csVFMQVdADAnTg8IN6tWzcZhlHi60lJScXOs2PHDkdXBQDwAOQGAAAAAAAAXNGF+q0sFoueeeYZPfPMM1VYFQCgsjl8yXQAAAAAAAAAAAAAANwBA+IAAAAAAAAAAAAAAI/EgDgAAAAAAAAAAAAAwCMxIA4AAAAAAAAAAAAA8Eh+ZhcAeDqrj4+2XnaN7TEAAGYhkwAAZUVmAABQSXx9pVtv/esxAHgoq4+PlgSGKKpRS44h4HIYEAecLN8/ULPHPG92GQAA2GVS3i9bTa4GAODKOI4BAKCSBAVJH31kdhUA4HR5fv4aWiNaXQberxj/QLPLAezwFQ0AAAAAAAAAAAAAgEdiQBwAAAAAAAAAAAAA4JEYEAecLCDnrOYN76B5wzsoIOes2eUAALxY4UwKzM0xuxwAgAvjOAYAgEqSlSVZLOd+srLMrgYAnCYwN0cZab/py6cHcwwBl8OAOAAAAAAAAAAAAADAIzEgDgAAAAAAAAAAAADwSAyIAwAAAAAAAAAAAAA8EgPiAAAAAAAAAAAAAACP5Gd2AQAAAAAAAAAAAICrSE9PV0ZGRrnmTUlJUX5efiVXBGfLy81VSkpKuebNzc1VQEBAudcdHh6uqKiocs+PC2NAHAAAAIDLWLdunV566SVt27ZNR44c0ZIlS9SvX79S51mzZo0mTJign376SXFxcXriiSc0bNiwKqkXAOBeEhMT9emnn2rPnj0KDg5Wp06d9MILL6hp06ZmlwYAAFxEenq6Bg+/W8dPnynX/Nlnz+j3Q0dULy+vkiuDs+RkntJvB/Zr3GNPKzAw0KF583JzdSg1RXXrx8vPv3zDrpHVQrRwwdsMijsRA+KAk1l9fLSrVWfbYwAAzEImwR1kZWWpdevWuuuuu3TLLbdcsP2BAwfUp08f3XPPPXr//fe1evVq3X333apdu7Z69uxZBRUDnonMgKdau3atxowZo8svv1z5+fl67LHH1KNHD/38888KDQ01uzwAnsjXV7r++r8eA3B5GRkZOn76jKIS+is0Msbh+Y8l71bKwfkqyPeuAXGrj49WBAYrst7FbncMkZdzVlaLn2pdcYtq1qnv0LzHkndr/2/zVaNDX4fnlaSs40eVvukTZWRkMCDuRAyIA06W7x+oV8fPMLsMAADsMinvl60mVwMUr3fv3urdu3eZ28+ZM0fx8fGaPn26JOmSSy7Rhg0bNGPGDAbEgQrgOAaeavny5XbPk5KSFB0drW3btqlLly4mVQXAowUFSV99ZXYVAMohNDJG4dF1HZ4v8880J1Tj+vL8/DWgRoy6DHpYMf6OnWXtKkJqRDn8Oz//+y7PvOell2suOIIBcQAAAABua9OmTerevbvdtJ49e2rcuHElzpOTk6OcnBzb8/LeF+68itxbTuJeYeXFPf2qXkXuqVcZ/+cVWT9/ZyjJqVOnJEmRkZEltqns3ADg+bgPLQAAroUBcQAAAABuKy0tTTEx9pewi4mJUUZGhs6ePavg4OAi8yQmJmrKlCmVsv6K3ltO4l5h5cE9/apeRe6pJ1X8/7yi6+fvDMWxWq0aN26cOnfurJYtW5bYrjJzA4Dn4z60AAC4HgbEAScLyDmrmfefu1znuH+tUG5g0U5ZAACqQuFMuu3eRJOrAcwzadIkTZgwwfY8IyNDcXFx5VpWRe8tx73Cyod7+jnf349jKnJPPani/+cVWT9/ZyjJmDFjtHv3bm3YsKHUdpWZGwA8398zKzA3W28/M1ySdPeTC5QTEFTivNyHFoA7C8zN0ZGjKfKdNkLjX/s/xkLgUhgQB6pAYG622SUAACCJTILniY2N1dGjR+2mHT16VOHh4cWeHS5JgYGB5TrDtDTlvbecxL3CKoJ7+jlXcZlR3vviVdb/eXnXz98Z/m7s2LH68ssvtW7dOtWtW/p7yhm5AcDznc+sgJyzCso7d9uFalEXKbCUASLuQwvA3YUahpSXc+GGQBXzMbsAAAAAACivhIQErV692m7aypUrlZCQYFJFAABXZhiGxo4dqyVLluibb75RfHy82SUBAAAAcDIGxAEAAAC4jMzMTO3cuVM7d+6UJB04cEA7d+5UamqqpHOXrR0yZIit/T333KP9+/dr4sSJ2rNnj9544w19+OGHGj9+vBnlAwBc3JgxY7Rw4UItWrRI1apVU1pamtLS0nT27FmzSwMAAADgJAyIAwAAAHAZW7duVdu2bdW2bVtJ0oQJE9S2bVs9+eSTkqQjR47YBsclKT4+Xl999ZVWrlyp1q1ba/r06Xr77bfVs2dPU+oHALi22bNn69SpU+rWrZtq165t+/nggw/MLg0AAACAk3APcQAAAAAuo1u3bjIMo8TXk5KSip1nx44dTqwKAOApSssYAAAAAJ6JM8QBAAAAAAAAAAAAAB6JM8QBJzMsFu1p2s72GAAAs5BJAICyIjMAAKgcZCoAb2FYLFrvH6jqdeLZ38HlMCAOOFleQJBeenSO2WUAAGCXSbm/bDW5GgCAK+M4BgCAykGmAvAWuf4B6lOztroMf0IxAUFmlwPY4ZLpAAAAAAAAAAAAAACPxIA4AAAAAAAAAAAAAMAjMSAOOFlAzlnNvK+HZt7XQwE5Z80uBwDgxQpnUmBujtnlAABcGMcxAABUDjIVgLcIzM3R/qOpev/F0ezv4HK4hzhQBaplnjS7BAAAJJFJAICyIzMAAKgcZCoAb1HLsEpnTptdBlAEZ4gDAAAAAAAAAAAAADwSA+IAAAAAAAAAAAAAAI/EgDgAAAAAAAAAAAAAwCMxIA4AAAAAAAAAAAAA8EgMiAMAAAAAAAAAAAAAPJKf2QUAns6wWHSgwSW2xwAAmIVMAgCUFZkBAEDlIFMBeAvDYtF2vwCFRV/E/g4uhwFxwMnyAoL07FPvmF0GAAB2mZT7y1aTqwEAuDKOYwAAqBxkKgBvkesfoG616qjLqKmKCQgyuxzATrkumf7666+rQYMGCgoKUseOHfXDDz+U2DYpKUkWi8XuJyiIPwQA8CbkBgAAAAAAANzN008/XaSfqlmzZmaXBQBwkMNniH/wwQeaMGGC5syZo44dO2rmzJnq2bOn9u7dq+jo6GLnCQ8P1969e23PLVwqAQC8BrkBAAAAAAAAd9WiRQutWrXK9tzPjwvvAoC7cfgM8VdeeUUjR47U8OHD1bx5c82ZM0chISGaP39+ifNYLBbFxsbafmJiYipUNOBOAnKy9cJDffXCQ30VkJNtdjlAlSM3ANdROJMC83LNLgcA4MI4jgEAoHKQqe7Pz8/Prp+qVq1aZpcEuKTAvFz9eOyg5s0Yx/4OLsehAfHc3Fxt27ZN3bt3/2sBPj7q3r27Nm3aVOJ8mZmZql+/vuLi4tS3b1/99NNPpa4nJydHGRkZdj+A+zJU688jqvXnEUmG2cUAVYrcAFxNoUwyyCQAQGk4jgEAoHKQqe7uv//9r+rUqaOGDRtq0KBBSk1NLbU9/VTwWoah+tYCxZz6Q+zv4GocGhD/448/VFBQUORMvZiYGKWlpRU7T9OmTTV//nx99tlnWsLOC6sAACjTSURBVLhwoaxWqzp16qTff/+9xPUkJiYqIiLC9hMXF+dImQAAF0FuAAAAAAAAwF117NhRSUlJWr58uWbPnq0DBw7oqquu0unTp0uch34qAHA9Dl8y3VEJCQkaMmSI2rRpo65du+rTTz9VVNT/t3fvcVXV+f7H31tgg4qYCIJoojNMJireSsNmvKQjWlOajnnqlOYUZiNNysQxG2/dxixLO+nJ5jReOmZaM0ezm10ozDNq5m3UMktC1BQkTUFUQFm/P+YnuYnb2hfW3ovX8/FYjwcs1tr78/2y9ve9Ft+9F9F66aWXqt1n2rRpOn36dMVy+PBhX5cJAPAT5AYAAAAAAAD8wbBhwzR69GglJSUpJSVF7777rk6dOqXXX3+92n34OxUA+J9gMxtHRUUpKChI+fn5Luvz8/MVGxtbp8cICQlRjx49dODAgWq3CQ0NVWhoqJnSAAB+iNwAAAAAAACAXVxxxRW66qqr+DsVAAQYU58Qdzqd6tWrlzIzMyvWlZeXKzMzU8nJyXV6jIsXL2rPnj1q3bq1uUoBAAGH3AAAAAAAAIBdnDlzRtnZ2fydCgACjKlPiEtSenq6xo0bp2uuuUa9e/fWggULVFxcrPHjx0uSxo4dqzZt2mjOnDmSpMcee0zXXXedEhISdOrUKT3zzDPKzc3Vvffe692WAAD8ErkBAAAAAACAQPTQQw/p5ptvVnx8vI4ePapZs2YpKChIt99+u9WlAQBMMD0hPmbMGBUUFGjmzJnKy8tT9+7dtX79esXExEiSDh06pEaNfvzg+Q8//KDU1FTl5eWpRYsW6tWrlzZt2qTExETvtQLwaw59F9eh4mugoSE3AH9yWSY5yCQAQE24jgEAwDvI1EB25MgR3X777Tpx4oSio6P1y1/+Ulu2bFF0dLTVpQH+x+HQvuAQNWnRSox38DemJ8QlKS0tTWlpaVX+LCsry+X7+fPna/78+e48DWALpaFhmvnkaqvLACxFbgD+4fJMKtm3zeJqAAD+jOsYAAC8g0wNbKtWrbK6BCBglIQ41SeqjfpNfEIxoWFWlwO4MPU/xAEAAAAAAAAAAAAACBRMiAMAAADwK4sWLVL79u0VFhamPn36aOvWrdVuu2zZMjkcDpclLIx3ogMAqvfpp5/q5ptvVlxcnBwOh9auXWt1SQAAAAB8yK1bpgOoO2fJeU1/bJwk6YmZy1XKrUIAABa5PJMmjXnQ4mqAqq1evVrp6elavHix+vTpowULFiglJUX79+9Xq1atqtwnIiJC+/fvr/je4eB/lQGeqnwdA9hJcXGxunXrpt/97ncaOXKk1eUAsDn+NghYo6CgQIWFhW7tm5ubqwtlF7xckf2FlpXqs++/U5NFU/XU468x3sGvMCEO+JyhNkdzKr4GAMA6l2WSQSbBPz333HNKTU3V+PHjJUmLFy/WO++8oyVLlujhhx+uch+Hw6HY2Nj6LBNoALiOgX0NGzZMw4YNs7oMAA0GmQrUt4KCAt05/l6dLDrr1v7nz53Vke+OqV1ZmZcrsznDUKcLZVLBd2K8g79hQhwAAACAXygtLdX27ds1bdq0inWNGjXS4MGDtXnz5mr3O3PmjOLj41VeXq6ePXvqz3/+szp37lwfJQMAAAAA/ExhYaFOFp1VdPIoNY2MMb3/8ey9yj28RBcvMCEO2AUT4gAAAAD8wvfff6+LFy8qJsb1DxYxMTH66quvqtynY8eOWrJkiZKSknT69GnNmzdPffv21RdffKG2bdtWuU9JSYlKSkoqvnf3NnoAgIbB27nhyS1cpX/9q5Do6GiPagDqA7crtkZZaalyc3Pd2pd+h900jYxRRKuqrwtrcuZEng+qAWAlJsQBAAAABKzk5GQlJydXfN+3b1916tRJL730kh5//PEq95kzZ44effTR+ioRABDgvJkbnt7CVZIimzXRiqUvMykOv8btiq1Rcua0DuZ8q8mPzFZoaKjp/el3AIBdMSEOAAAAwC9ERUUpKChI+fn5Luvz8/Pr/D/CQ0JC1KNHDx04cKDabaZNm6b09PSK7wsLC3XllVe6VzQAwPa8mRue3sK1+GS+Cjb/XYWFhUyIw69xu2JrlJWcU7kjWFHXjVTLuHjT+9PvAAC7YkIcAAAAgF9wOp3q1auXMjMzNWLECElSeXm5MjMzlZaWVqfHuHjxovbs2aMbb7yx2m1CQ0Pd+sQMAKBh8kVuuHsLV0kq8GolgG9xu2JrNGkRTb8DAHAZJsQBn3Po+5atK74GAMA6l2WSg0yCf0pPT9e4ceN0zTXXqHfv3lqwYIGKi4s1fvx4SdLYsWPVpk0bzZkzR5L02GOP6brrrlNCQoJOnTqlZ555Rrm5ubr33nutbAZgA1zHwL7OnDnjcieRnJwc7dq1S5GRkWrXrp2FlQGwJzIVQAPhcCi3UZDCmrUQ4x38DRPigI+VhoZp6rw3rS4DAACXTCrZt83iaoCqjRkzRgUFBZo5c6by8vLUvXt3rV+/XjEx/7rV5qFDh9SoUaOK7X/44QelpqYqLy9PLVq0UK9evbRp0yYlJiZa1QTAFriOgZ1t27ZNAwcOrPj+0u3Qx40bp2XLlllUFQC7IlMBNBQlIU51bXWl+k18QjGhYVaXA7hgQhwAAACAX0lLS6v2FulZWVku38+fP1/z58+vh6oAAHYxYMAAGYZhdRkAAAAA6gkT4gAAAAAAAAAAAPArBQUFKiwsNL1fbm6uLpRd8EFFgG+UlZYqNzfXrX1LS0vldDrdfu6IiAhFR0e7vb+7r1NvPLcZTIgDPhZSel5T59wnSZo77SWVOblVCADAGpdn0uRb77O4GgCAP6t8HQMAANzD3wYB9xQUFOjO8ffqZNFZ0/ueP3dWR747pnZlZT6oDNVxlpUq6/ujCv/LDD03aznjXR2VnDmtgznfavIjsxUaGmpq37LSUn13KFdt4zsoOMS9Kd/IZk20YunLbk1Me/I69fS5zWJCHPAxh2Gow8F9FV8DAGAVMgkAUFdkBgAA3kGmAu4pLCzUyaKzik4epaaRMab2PZ69V7mHl+jiBSbE65PDMNTzQql0NIfxzoSyknMqdwQr6rqRahkXb2rf49l79e3BJWrRe7jpfSWp+GS+Cjb/XYWFhW5NSnvyOvX0uc1iQhwAAAAAAAAAAAB+p2lkjCJatTW1z5kTeT6qBvCdJi2i3T7W3dn3kgK39nLlzuvUW89dV43q8bkAAAAAAAAAAAAAAKg3TIgDAAAAAAAAAAAAAGyJCXEAAAAAAAAAAAAAgC0xIQ4AAAAAAAAAAAAAsKVgqwsAGoKi8CusLgEAAElkEgCg7sgMAAC8g0wF0FB872ikkMZNrS4D+AkmxAEfKw1trMkvfGB1GQAAuGRSyb5tFlcDAPBnXMcAAOAdZCqAhqLEGaqfxbRTv4lPKCa0sdXlAC64ZToAAAAAAAAAAAAAwJaYEAcAAAAAAAAAAAAA2BIT4oCPhZSeV8ZTE5Xx1ESFlJ63uhwAQAN2eSY5y0qtLgcA4Me4jgEAwDvIVAANhbOsVO+cOKY5S59gvIPf4X+IAz7mMAxdvX9HxdcAAFjFJZOG3WVxNQAAf8Z1DAAA3kGmAmgoHIahX5WVSLlfMd7B7/AJcQAAAAAAAAAAAACALTEhDgAAAAAAAAAAAACwJSbEAQAAAAAAAAAAAAC2xIQ4AAAAAAAAAAAAAMCWmBAHAAAAAAAAAAAAANhSsNUFAA1BiTPM6hIAAJBEJgEA6o7MAADAO8hUAA1FscOhoGCn1WUAP8GEOOBjpaGN9fuXPrW6DAAAXDKpZN82i6sBAPgzrmMAAPAOMhWeKigoUGFhodv7R0REKDo62osVAVUrcYaqdUy8+k18QjGhja0uB3DBhDgAAAAAAAAAAICfKSgo0J3j79XJorNuP0ZksyZasfRlJsUBNGhMiAMAAAAAAAAAAPiZwsJCnSw6q+jkUWoaGWN6/+KT+SrY/HcVFhYyIQ6gQWNCHPCx4LISTVr4sCRpUdpTuhASanFFAICG6vJMmj74NourAQD4s8rXMQAAwD38bRDe0DQyRhGt2rq1b4GXawGqE3KhTG/8kK/IV5/RyxkLGe/gV5gQB3ysUXm5knb/o+JrAACs4pJJN/zW4moAAP6M6xgAALyDTAXQUDQqL1dKyTnpm39qCeMd/EwjqwsAAAAAAAAAAAAAAMAX3JoQX7Rokdq3b6+wsDD16dNHW7durXH7N954Q1dffbXCwsLUtWtXvfvuu24VCwAITOQGAMAMcgMA4GtmswYA0LCRGwAQ2ExPiK9evVrp6emaNWuWduzYoW7duiklJUXHjx+vcvtNmzbp9ttv1z333KOdO3dqxIgRGjFihPbu3etx8QAA/0duAADMIDcAAL5mNmsAAA0buQEAgc/0hPhzzz2n1NRUjR8/XomJiVq8eLGaNGmiJUuWVLn9888/r6FDhyojI0OdOnXS448/rp49e2rhwoUeFw8A8H/kBgDADHIDAOBrZrMGANCwkRsAEPhMTYiXlpZq+/btGjx48I8P0KiRBg8erM2bN1e5z+bNm122l6SUlJRqtwcA2Ae5AQAwg9wAAPiaO1kDAGi4yA0AsIdgMxt///33unjxomJiYlzWx8TE6Kuvvqpyn7y8vCq3z8vLq/Z5SkpKVFJSUvH96dOnJUmFhYVmypUkFRUV6eKFCzp17KDKzp81vX/h8SMyystVmHdYwQ7Tu6v4h+MqOXdOX375pYqKikzte/jwYZWeP+927Z48t6c8qd3TPve331lo6XldOnJPHv5GJc4wn9Rut34zw8p+8/R15knbi384rosXLqioqMit8fHSPoZhmN63rhpiblg59nqqoY7dngqkfrs8k4oKjgbs7yyQc8PK/cmNH5Ebgc/KccDK87/6HEMqX8cE+vhn5Tm7la9xu19vuMOdrCE3APOszGrJv6436utvg1bvT278iNzwjkA5b/b2/oH83EUFR+s83nn7uQO535jfqKfcMEz47rvvDEnGpk2bXNZnZGQYvXv3rnKfkJAQY+XKlS7rFi1aZLRq1ara55k1a5YhiYWFhYWlHpbDhw+biQJTyA0WFhYW+y3kBgsLCwuLmcWXueEOd7KG3GBhYWGpv4XcYGFhYWExs9Q1N0x9QjwqKkpBQUHKz893WZ+fn6/Y2Ngq94mNjTW1vSRNmzZN6enpFd+Xl5fr5MmTatmypRwON97i4GcKCwt15ZVX6vDhw4qIiLC6HL9EH9WOPqodfVQzwzBUVFSkuLg4nz0HueF9HNeeof88Rx96JpD7j9ywViAfO5ezSzsk+7SFdvgXu7Xjyy+/9GluuMOdrLEyN+xyTFRGuwKLXdsl2bdtgdiu+rjecIc/50Yg/p6tRp+ZR5+ZR5+5x2y/mc0NUxPiTqdTvXr1UmZmpkaMGCHpX4N5Zmam0tLSqtwnOTlZmZmZmjx5csW6Dz/8UMnJydU+T2hoqEJDQ13WXXHFFWZKDQgRERG8GGpBH9WOPqodfVS95s2b+/TxyQ3f4bj2DP3nOfrQM4Haf+SG9QL12KnMLu2Q7NMW2uFf7NKONm3aqFGjRlaX4cKdrPGH3LDLMVEZ7Qosdm2XZN+2BVq7fH294Y5AyI1A+z37A/rMPPrMPPrMPWb6zUxumJoQl6T09HSNGzdO11xzjXr37q0FCxaouLhY48ePlySNHTtWbdq00Zw5cyRJDz74oPr3769nn31WN910k1atWqVt27bpL3/5i9mnBgAEIHIDAGAGuQEA8LXasgYAgMuRGwAQ+ExPiI8ZM0YFBQWaOXOm8vLy1L17d61fv14xMTGSpEOHDrm8+7dv375auXKlpk+frkceeUS/+MUvtHbtWnXp0sV7rQAA+C1yAwBgBrkBAPC12rIGAIDLkRsAEPhMT4hLUlpaWrW3A8nKyvrJutGjR2v06NHuPJUthYaGatasWT+5bQp+RB/Vjj6qHX3kP8gN7+G49gz95zn60DP0X92QGz9ll2PHLu2Q7NMW2uFfaEf9qSlr/Ekg9KU7aFdgsWu7JPu2za7tspI/5ga/Z/PoM/PoM/PoM/f4ut8chmEYPnlkAAAAAAAAAAAAAAAs1Kj2TQAAAAAAAAAAAAAACDxMiAMAAAAAAAAAAAAAbIkJcQAAAAAAAAAAAACALTEh7iOffvqpbr75ZsXFxcnhcGjt2rU/2Wbfvn265ZZb1Lx5czVt2lTXXnutDh06VP/FWqS2Pjpz5ozS0tLUtm1bNW7cWImJiVq8eLE1xVpkzpw5uvbaa9WsWTO1atVKI0aM0P79+122OX/+vCZNmqSWLVsqPDxco0aNUn5+vkUV17/a+ujkyZN64IEH1LFjRzVu3Fjt2rXTH/7wB50+fdrCqoGaMT56jvHTM4ytnqnL8XeJYRgaNmxYteeLaHjsch1hlyyzS57YZVy3y/ha13Zs3rxZN9xwg5o2baqIiAj169dP586ds6DiqtWlHXl5ebrrrrsUGxurpk2bqmfPnvr73/9uUcX+rbZx0zAMzZw5U61bt1bjxo01ePBgffPNN9YUa0JN7SorK9PUqVPVtWtXNW3aVHFxcRo7dqyOHj1qXcF1VJe8vmTixIlyOBxasGBBvdXnLruch1Rml/OSyuxynoLa2TUjfKm2Prv77rvlcDhclqFDh1pTrJ9gTDGvLn02YMCAnxxrEydOtKhi67344otKSkpSRESEIiIilJycrPfee6/i5748xpgQ95Hi4mJ169ZNixYtqvLn2dnZ+uUvf6mrr75aWVlZ2r17t2bMmKGwsLB6rtQ6tfVRenq61q9frxUrVmjfvn2aPHmy0tLStG7dunqu1DobNmzQpEmTtGXLFn344YcqKyvTkCFDVFxcXLHNlClT9NZbb+mNN97Qhg0bdPToUY0cOdLCqutXbX109OhRHT16VPPmzdPevXu1bNkyrV+/Xvfcc4/FlQPVY3z0HOOnZxhbPVOX4++SBQsWyOFwWFAl/JVdriPskmV2yRO7jOt2GV/r0o7Nmzdr6NChGjJkiLZu3arPP/9caWlpatTIf/6MU5d2jB07Vvv379e6deu0Z88ejRw5Urfddpt27txpYeX+qbZx8+mnn9Z//ud/avHixfrss8/UtGlTpaSk6Pz58/VcqTk1tevs2bPasWOHZsyYoR07duh///d/tX//ft1yyy0WVGpObb+vS9asWaMtW7YoLi6unirzjF3OQyqzy3lJZXY5T0Ht7JoRvlSXcXro0KE6duxYxfLaa6/VY4X+hzHFvLpen6Smproca08//bRFFVuvbdu2euqpp7R9+3Zt27ZNN9xwg4YPH64vvvhCko+PMQM+J8lYs2aNy7oxY8YYd955pzUF+aGq+qhz587GY4895rKuZ8+exp/+9Kd6rMy/HD9+3JBkbNiwwTAMwzh16pQREhJivPHGGxXb7Nu3z5BkbN682aoyLVW5j6ry+uuvG06n0ygrK6vHygD3MD56B+OnZxhbPVNd/+3cudNo06aNcezYsSpf64BdriPslGV2yRO7jOt2GV+rakefPn2M6dOnW1iVeVW1o2nTpsYrr7zisl1kZKTx3//93/VdXkCpfNyWl5cbsbGxxjPPPFOx7tSpU0ZoaKjx2muvWVChe+ryety6dashycjNza2forygunYdOXLEaNOmjbF3714jPj7emD9/fr3X5gm7nIdUZqfzksrscp6Cmtk1I3ypqtf9uHHjjOHDh1tST6BgTDGvqvPh/v37Gw8++KB1RQWAFi1aGC+//LLPjzH/eWtxA1JeXq533nlHV111lVJSUtSqVSv16dPH727jZrW+fftq3bp1+u6772QYhj755BN9/fXXGjJkiNWlWebSLQsjIyMlSdu3b1dZWZkGDx5csc3VV1+tdu3aafPmzZbUaLXKfVTdNhEREQoODq6vsgCvYnw0j/HTM4ytnqmq/86ePas77rhDixYtUmxsrFWlIcDY6ToiULPMLnlil3HdLuNr5XYcP35cn332mVq1aqW+ffsqJiZG/fv31//93/9ZWWatqvp99O3bV6tXr9bJkydVXl6uVatW6fz58xowYIBFVQamnJwc5eXluYw1zZs3V58+ffx6rHHH6dOn5XA4dMUVV1hdikfKy8t11113KSMjQ507d7a6HK+w03lIZYF6XlKZXc5TYE5Dyghvy8rKUqtWrdSxY0fdf//9OnHihNUl+RXGFPOqu8569dVXFRUVpS5dumjatGk6e/asFeX5nYsXL2rVqlUqLi5WcnKyz48xJsQtcPz4cZ05c0ZPPfWUhg4dqg8++EC33nqrRo4cqQ0bNlhdnt944YUXlJiYqLZt28rpdGro0KFatGiR+vXrZ3VpligvL9fkyZN1/fXXq0uXLpL+9f/YnE7nTy4UY2JilJeXZ0GV1qqqjyr7/vvv9fjjj2vChAn1XB3gPYyP5jB+eoax1TPV9d+UKVPUt29fDR8+3MLqEGjsdB0RiFlmlzyxy7hul/G1qnZ8++23kqTZs2crNTVV69evV8+ePTVo0CC//X+g1f0+Xn/9dZWVlally5YKDQ3VfffdpzVr1ighIcHCagPPpfEkJibGZb0/jzXuOH/+vKZOnarbb79dERERVpfjkblz5yo4OFh/+MMfrC7Fa+x0HlJZIJ6XVGaX8xSY11AywtuGDh2qV155RZmZmZo7d642bNigYcOG6eLFi1aX5hcYU8yr7nz4jjvu0IoVK/TJJ59o2rRp+p//+R/deeedFlZqvT179ig8PFyhoaGaOHGi1qxZo8TERJ8fY/77Vm8bKy8vlyQNHz5cU6ZMkSR1795dmzZt0uLFi9W/f38ry/MbL7zwgrZs2aJ169YpPj5en376qSZNmqS4uDiXd4g0FJMmTdLevXv9/lMBVqqtjwoLC3XTTTcpMTFRs2fPrt/iAC9ifDSH8dMzjK2eqar/1q1bp48//pj/nwrT7HQdEYhZZpc8scu4bpfxtap2XHqt33fffRo/frwkqUePHsrMzNSSJUs0Z84cS2qtSXXH1YwZM3Tq1Cl99NFHioqK0tq1a3Xbbbdp48aN6tq1q0XVwh+VlZXptttuk2EYevHFF60uxyPbt2/X888/rx07dsjhcFhdjtfY6TykskA8L6nMLucpQH35t3/7t4qvu3btqqSkJP385z9XVlaWBg0aZGFl/oExxbzq+uzyNxl37dpVrVu31qBBg5Sdna2f//zn9V2mX+jYsaN27dql06dP629/+5vGjRtXL2+uY0LcAlFRUQoODlZiYqLL+k6dOjHA/H/nzp3TI488ojVr1uimm26SJCUlJWnXrl2aN29ewJyMektaWprefvttffrpp2rbtm3F+tjYWJWWlurUqVMu75rJz88PmNsDekt1fXRJUVGRhg4dqmbNmmnNmjUKCQmxoErAc4yP5jB+eoax1TPV9d/HH3+s7Ozsn7zjddSoUfrVr36lrKys+i0UAcMu1xGBmGV2yRO7jOt2GV+ra0fr1q0lqcrX+qFDh+q1xrqorh3Z2dlauHCh9u7dW3HL6G7dumnjxo1atGiRFi9ebFXJAefSeJKfn19xfFz6vnv37hZV5T2XJsNzc3P18ccfB/ynwzdu3Kjjx4+rXbt2FesuXryoP/7xj1qwYIEOHjxoXXEesMt5SGWBeF5SmV3OU+Aeu2dEffnZz36mqKgoHThwoMFPiDOmmFfbddbl+vTpI0k6cOBAg50QdzqdFXeM6tWrlz7//HM9//zzGjNmjE+PMW6ZbgGn06lrr71W+/fvd1n/9ddfKz4+3qKq/EtZWZnKysrUqJHrIRoUFFTxjtSGwDAMpaWlac2aNfr444/VoUMHl5/36tVLISEhyszMrFi3f/9+HTp0SMnJyfVdriVq6yPpX59yGTJkiJxOp9atW6ewsDALKgW8g/Gxbhg/PcPY6pna+u/hhx/W7t27tWvXropFkubPn6+lS5daUDEChV2uIwIpy+ySJ3YZ1+0yvtbWjvbt2ysuLs7vX+u1tePS/0YMhNe6v+vQoYNiY2NdxprCwkJ99tlnfjXWuOPSZPg333yjjz76SC1btrS6JI/dddddPxmL4uLilJGRoffff9/q8txml/OQygLpvKQyu5ynwDN2zoj6dOTIEZ04ccLlTQUNDWOKeXW5zqrs0jVKQz7WKisvL1dJSYnPjzE+Ie4jZ86c0YEDByq+z8nJ0a5duxQZGal27dopIyNDY8aMUb9+/TRw4ECtX79eb731lt+9Y92Xauuj/v37KyMjQ40bN1Z8fLw2bNigV155Rc8995yFVdevSZMmaeXKlXrzzTfVrFmziv+T0Lx5czVu3FjNmzfXPffco/T0dEVGRioiIkIPPPCAkpOTdd1111lcff2orY8u/WHv7NmzWrFihQoLC1VYWChJio6OVlBQkJXlA1VifPQc46dnGFs9U1v/xcbGVvnO1nbt2tXp4gn2ZpfrCLtkmV3yxC7jul3G19ra4XA4lJGRoVmzZqlbt27q3r27li9frq+++kp/+9vfLK7+R7W14+qrr1ZCQoLuu+8+zZs3Ty1bttTatWv14Ycf6u2337a4ev9T27g5efJkPfHEE/rFL36hDh06aMaMGYqLi9OIESOsK7oOampX69at9dvf/lY7duzQ22+/rYsXL1YcR5GRkXI6nVaVXavafl+VJ/ZDQkIUGxurjh071nepptjlPKQyu5yXVGaX8xTUzq4Z4Us19VlkZKQeffRRjRo1SrGxscrOztZ//Md/KCEhQSkpKRZWbS3GFPNq67Ps7GytXLlSN954o1q2bKndu3drypQp6tevn5KSkiyu3hrTpk3TsGHD1K5dOxUVFWnlypXKysrS+++/7/tjzIBPfPLJJ4aknyzjxo2r2Oavf/2rkZCQYISFhRndunUz1q5da13BFqitj44dO2bcfffdRlxcnBEWFmZ07NjRePbZZ43y8nJrC69HVfWPJGPp0qUV25w7d874/e9/b7Ro0cJo0qSJceuttxrHjh2zruh6VlsfVXecSTJycnIsrR2oDuOj5xg/PcPY6pm6HH9V7bNmzZp6qxH+yy7XEXbJMrvkiV3GdbuMr3Vtx5w5c4y2bdsaTZo0MZKTk42NGzdaU3A16tKOr7/+2hg5cqTRqlUro0mTJkZSUpLxyiuvWFe0H6tt3CwvLzdmzJhhxMTEGKGhocagQYOM/fv3W1t0HdTUrpycnGqPo08++cTq0mtUl7y+XHx8vDF//vx6rdEddjkPqcwu5yWV2eU8BbWza0b4Uk19dvbsWWPIkCFGdHS0ERISYsTHxxupqalGXl6e1WVbijHFvNr67NChQ0a/fv2MyMhIIzQ01EhISDAyMjKM06dPW1u4hX73u98Z8fHxhtPpNKKjo41BgwYZH3zwQcXPfXmMOQzDMAQAAAAAAAAAAAAAgM3wP8QBAAAAAAAAAAAAALbEhDgAAAAAAAAAAAAAwJaYEAcAAAAAAAAAAAAA2BIT4gAAAAAAAAAAAAAAW2JCHAAAAAAAAAAAAABgS0yIAwAAAAAAAAAAAABsiQlxAAAAAAAAAAAAAIAtMSEOAAAAAAAAAAAAALAlJsQBHystLVVCQoI2bdpU7TYHDx6Uw+HQrl27TD32ww8/rAceeMDDCgEA/oTcAACYQW4AAMwgNwAAZpAbsAsmxGFbBQUFuv/++9WuXTuFhoYqNjZWKSkp+sc//lGxTfv27eVwOLRlyxaXfSdPnqwBAwZUfD979mw5HA45HA4FBQXpyiuv1IQJE3Ty5Mla61i8eLE6dOigvn371rn2SwFyaXE6nUpISNATTzwhwzAqtnvooYe0fPlyffvtt3V+bABA1cgNAIAZ5AYAwAxyAwBgBrkBeBcT4rCtUaNGaefOnVq+fLm+/vprrVu3TgMGDNCJEydctgsLC9PUqVNrfbzOnTvr2LFjOnTokJYuXar169fr/vvvr3EfwzC0cOFC3XPPPW614aOPPtKxY8f0zTff6NFHH9WTTz6pJUuWVPw8KipKKSkpevHFF916fADAj8gNAIAZ5AYAwAxyAwBgBrkBeBcT4rClU6dOaePGjZo7d64GDhyo+Ph49e7dW9OmTdMtt9zisu2ECRO0ZcsWvfvuuzU+ZnBwsGJjY9WmTRsNHjxYo0eP1ocffljjPtu3b1d2drZuuukml/Vbt25Vjx49FBYWpmuuuUY7d+6scv+WLVsqNjZW8fHx+vd//3ddf/312rFjh8s2N998s1atWlVjHQCAmpEbAAAzyA0AgBnkBgDADHID8D4mxGFL4eHhCg8P19q1a1VSUlLjth06dNDEiRM1bdo0lZeX1+nxDx48qPfff19Op7PG7TZu3KirrrpKzZo1q1h35swZ/eY3v1FiYqK2b9+u2bNn66GHHqr1Obdt26bt27erT58+Lut79+6tI0eO6ODBg3WqHQDwU+QGAMAMcgMAYAa5AQAwg9wAvI8JcdhScHCwli1bpuXLl+uKK67Q9ddfr0ceeUS7d++ucvvp06crJydHr776arWPuWfPHoWHh6tx48bq0KGDvvjii1pvRZKbm6u4uDiXdStXrlR5ebn++te/qnPnzvrNb36jjIyMKvfv27evwsPD5XQ6de211+q2227T2LFjXba59Pi5ubk11gIAqB65AQAwg9wAAJhBbgAAzCA3AO9jQhy2NWrUKB09elTr1q3T0KFDlZWVpZ49e2rZsmU/2TY6OloPPfSQZs6cqdLS0iofr2PHjtq1a5c+//xzTZ06VSkpKXrggQdqrOHcuXMKCwtzWbdv3z4lJSW5rE9OTq5y/9WrV2vXrl365z//qddff11vvvmmHn74YZdtGjduLEk6e/ZsjbUAAGpGbgAAzCA3AABmkBsAADPIDcC7mBCHrYWFhenXv/61ZsyYoU2bNunuu+/WrFmzqtw2PT1d586d03/9139V+XOn06mEhAR16dJFTz31lIKCgvToo4/W+PxRUVH64Ycf3K7/yiuvVEJCgjp16qTRo0dr8uTJevbZZ3X+/PmKbU6ePCnpX6EHAPAMuQEAMIPcAACYQW4AAMwgNwDvYUIcDUpiYqKKi4ur/Fl4eLhmzJihJ598UkVFRbU+1vTp0zVv3jwdPXq02m169Oihr776SoZhVKzr1KmTdu/e7TLob9mypU71BwUF6cKFCy7v8tq7d69CQkLUuXPnOj0GAKDuyA0AgBnkBgDADHIDAGAGuQG4jwlx2NKJEyd0ww03aMWKFdq9e7dycnL0xhtv6Omnn9bw4cOr3W/ChAlq3ry5Vq5cWetzJCcnKykpSX/+85+r3WbgwIE6c+aMvvjii4p1d9xxhxwOh1JTU/Xll1/q3Xff1bx586ptR15eno4cOaL33ntPzz//vAYOHKiIiIiKbTZu3Khf/epXFbcWAQCYR24AAMwgNwAAZpAbAAAzyA3A+5gQhy2Fh4erT58+mj9/vvr166cuXbpoxowZSk1N1cKFC6vdLyQkRI8//rjLu5tqMmXKFL388ss6fPhwlT9v2bKlbr31Vr366qsutb311lvas2ePevTooT/96U+aO3dulfsPHjxYrVu3Vvv27TVhwgTdeOONWr16tcs2q1atUmpqap3qBQBUjdwAAJhBbgAAzCA3AABmkBuA9zmMy+91AMDrdu/erV//+tfKzs5WeHi4Vx/7vffe0x//+Eft3r1bwcHBXn1sAIA1yA0AgBnkBgDADHIDAGAGuQG74BPigI8lJSVp7ty5ysnJ8fpjFxcXa+nSpYQFANgIuQEAMIPcAACYQW4AAMwgN2AXfEIcAAAAAAAAAAAAAGBLfEIcAAAAAAAAAAAAAGBLTIgDAAAAAAAAAAAAAGyJCXEAAAAAAAAAAAAAgC0xIQ4AAAAAAAAAAAAAsCUmxAEAAAAAAAAAAAAAtsSEOAAAAAAAAAAAAADAlpgQBwAAAAAAAAAAAADYEhPiAAAAAAAAAAAAAABbYkIcAAAAAAAAAAAAAGBLTIgDAAAAAAAAAAAAAGzp/wHZ8Jmba+mfUgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 2000x800 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved to /tmp/v10_validation_results.png\n"
     ]
    }
   ],
   "source": [
    "# Histogram of SNR distribution\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, axes = plt.subplots(2, 5, figsize=(20, 8))\n",
    "axes = axes.flatten()\n",
    "\n",
    "for i, variant in enumerate(VARIANTS + ['all']):\n",
    "    ax = axes[i]\n",
    "    if variant in results and len(results[variant]) > 0:\n",
    "        snrs = results[variant]\n",
    "        ax.hist(snrs, bins=20, edgecolor='black', alpha=0.7)\n",
    "        ax.axvline(np.mean(snrs), color='red', linestyle='--', label=f'Mean: {np.mean(snrs):.1f}')\n",
    "        ax.set_title(f'{variant} (n={len(snrs)})')\n",
    "        ax.set_xlabel('SNR (dB)')\n",
    "        ax.legend()\n",
    "    else:\n",
    "        ax.set_title(f'{variant} (no data)')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('/tmp/v10_validation_results.png', dpi=150)\n",
    "plt.show()\n",
    "print(\"Saved to /tmp/v10_validation_results.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "725a3d06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "========================================\n",
      "SUMMARY\n",
      "========================================\n",
      "Model: V10.1 (epoch 67)\n",
      "Training Holdout SNR: 37.32 dB\n",
      "Validation Overall SNR: 20.75 dB\n",
      "Samples validated: 198\n",
      "Errors: 0\n",
      "\n",
      "Best variant: 0001 (23.06 dB)\n",
      "Worst variant: 0006 (17.85 dB)\n"
     ]
    }
   ],
   "source": [
    "# Summary for quick reference\n",
    "print(\"\\n\" + \"=\"*40)\n",
    "print(\"SUMMARY\")\n",
    "print(\"=\"*40)\n",
    "print(f\"Model: V10.1 (epoch {epoch})\")\n",
    "print(f\"Training Holdout SNR: {snr:.2f} dB\")\n",
    "print(f\"Validation Overall SNR: {np.mean(results['all']):.2f} dB\" if results['all'] else \"N/A\")\n",
    "print(f\"Samples validated: {len(results['all'])}\")\n",
    "print(f\"Errors: {len(errors)}\")\n",
    "\n",
    "# Best/worst variants\n",
    "variant_means = {v: np.mean(results[v]) for v in VARIANTS if v in results and len(results[v]) > 0}\n",
    "if variant_means:\n",
    "    best = max(variant_means, key=variant_means.get)\n",
    "    worst = min(variant_means, key=variant_means.get)\n",
    "    print(f\"\\nBest variant: {best} ({variant_means[best]:.2f} dB)\")\n",
    "    print(f\"Worst variant: {worst} ({variant_means[worst]:.2f} dB)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0780c61c",
   "metadata": {},
   "source": [
    "## Multi-checkpoint comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "37f981dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "============================================================\n",
      "Testing: v10-1-b4 V1 (epoch 71)\n",
      "============================================================\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f07e36d8a9de44a9989c1e7386ee15a4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating v10-1-b4 V1:   0%|          | 0/198 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Holdout SNR: 38.60 dB\n",
      "Validation SNR: 21.07 dB\n",
      "0001 (clean): 23.32 dB\n",
      "Errors: 0\n",
      "\n",
      "============================================================\n",
      "Testing: pytorch V4 (epoch 60)\n",
      "============================================================\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fba4e34833124d24a8f6b5ef3d552187",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating pytorch V4:   0%|          | 0/198 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Holdout SNR: 38.32 dB\n",
      "Validation SNR: 21.22 dB\n",
      "0001 (clean): 23.64 dB\n",
      "Errors: 0\n",
      "\n",
      "============================================================\n",
      "Testing: pytorch V3 (epoch 54)\n",
      "============================================================\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "19407a3fffbf48f080c44112bf65793e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating pytorch V3:   0%|          | 0/198 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Holdout SNR: 37.50 dB\n",
      "Validation SNR: 20.59 dB\n",
      "0001 (clean): 22.34 dB\n",
      "Errors: 0\n",
      "\n",
      "============================================================\n",
      "Testing: pytorch V2 (epoch 48)\n",
      "============================================================\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "13a5f2db5de040909eefd8cc9b4d1f02",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating pytorch V2:   0%|          | 0/198 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Holdout SNR: 35.08 dB\n",
      "Validation SNR: 19.81 dB\n",
      "0001 (clean): 22.38 dB\n",
      "Errors: 0\n",
      "\n",
      "============================================================\n",
      "Testing: pytorch V1 (epoch 41)\n",
      "============================================================\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ebf08eb4aae74a86933ac000d8aadf2e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating pytorch V1:   0%|          | 0/198 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Holdout SNR: 31.06 dB\n",
      "Validation SNR: 21.01 dB\n",
      "0001 (clean): 22.41 dB\n",
      "Errors: 0\n"
     ]
    }
   ],
   "source": [
    "# Validate all Kaggle-uploaded checkpoints\n",
    "KAGGLE_CHECKPOINTS = [\n",
    "    (\"/tmp/kaggle_models/v10_1_b4_v1/v10_1_efficientnet_b4_latest.pth\", \"v10-1-b4 V1\", 71),\n",
    "    (\"/tmp/kaggle_models/pytorch_v4/ecg_v10_best.pth\", \"pytorch V4\", 60),\n",
    "    (\"/tmp/kaggle_models/pytorch_v3/ecg_v10_best.pth\", \"pytorch V3\", 54),\n",
    "    (\"/tmp/kaggle_models/pytorch_v2/ecg_v10_best.pth\", \"pytorch V2\", 48),\n",
    "    (\"/tmp/kaggle_models/pytorch_v1/v10_best_soft.pth\", \"pytorch V1\", 41),\n",
    "]\n",
    "\n",
    "all_checkpoint_results = {}\n",
    "\n",
    "for ckpt_path, ckpt_name, ckpt_epoch in KAGGLE_CHECKPOINTS:\n",
    "    print(f\"\\n{'='*60}\")\n",
    "    print(f\"Testing: {ckpt_name} (epoch {ckpt_epoch})\")\n",
    "    print('='*60)\n",
    "    \n",
    "    # Load checkpoint\n",
    "    checkpoint = torch.load(ckpt_path, map_location='cpu', weights_only=False)\n",
    "    state_dict = checkpoint['model']\n",
    "    if list(state_dict.keys())[0].startswith('module.'):\n",
    "        state_dict = {k[7:]: v for k, v in state_dict.items()}\n",
    "    model.load_state_dict(state_dict)\n",
    "    model.to(device).eval()\n",
    "    \n",
    "    holdout_snr = checkpoint.get('holdout_snr_soft', checkpoint.get('snr_soft', 0))\n",
    "    \n",
    "    # Run validation\n",
    "    ckpt_results = defaultdict(list)\n",
    "    errors = []\n",
    "    \n",
    "    # selected_samples is list of (img_path, csv_path, variant) tuples\n",
    "    for img_path, csv_path, variant in tqdm(selected_samples, desc=f\"Validating {ckpt_name}\"):\n",
    "        try:\n",
    "            # Load image (BGR)\n",
    "            image_bgr = cv2.imread(str(img_path))\n",
    "            if image_bgr is None:\n",
    "                errors.append(f\"{img_path}: Failed to load\")\n",
    "                continue\n",
    "            \n",
    "            # Process image\n",
    "            pred_mv = process_stage1_image(image_bgr)\n",
    "            \n",
    "            # Compute per-lead SNR\n",
    "            snr = compute_sample_snr(pred_mv, csv_path)\n",
    "            \n",
    "            if np.isfinite(snr):\n",
    "                ckpt_results[variant].append(snr)\n",
    "                ckpt_results['all'].append(snr)\n",
    "        except Exception as e:\n",
    "            errors.append(f\"{img_path}: {e}\")\n",
    "    \n",
    "    # Compute stats\n",
    "    overall_snr = np.mean(ckpt_results['all']) if ckpt_results['all'] else 0\n",
    "    all_checkpoint_results[ckpt_name] = {\n",
    "        'epoch': ckpt_epoch,\n",
    "        'holdout_snr': holdout_snr,\n",
    "        'val_snr': overall_snr,\n",
    "        'variant_snrs': {v: np.mean(ckpt_results[v]) for v in VARIANTS if ckpt_results[v]}\n",
    "    }\n",
    "    \n",
    "    print(f\"Holdout SNR: {holdout_snr:.2f} dB\")\n",
    "    print(f\"Validation SNR: {overall_snr:.2f} dB\")\n",
    "    print(f\"0001 (clean): {np.mean(ckpt_results['0001']):.2f} dB\")\n",
    "    print(f\"Errors: {len(errors)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c929bc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "CHECKPOINT COMPARISON SUMMARY\n",
      "================================================================================\n",
      "Checkpoint            Epoch  Holdout SNR    Val SNR     0001     0006\n",
      "--------------------------------------------------------------------------------\n",
      "v10-1-b4 V1              71        38.60      21.07    23.32    17.97\n",
      "pytorch V4               60        38.32      21.22    23.64    18.49\n",
      "pytorch V3               54        37.50      20.59    22.34    18.21\n",
      "pytorch V2               48        35.08      19.81    22.38    17.05\n",
      "pytorch V1               41        31.06      21.01    22.41    18.25\n",
      "================================================================================\n",
      "\n",
      "Best by validation SNR: pytorch V4\n"
     ]
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
      "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
      "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
      "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "# Summary comparison table\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"CHECKPOINT COMPARISON SUMMARY\")\n",
    "print(\"=\"*80)\n",
    "print(f\"{'Checkpoint':<20} {'Epoch':>6} {'Holdout SNR':>12} {'Val SNR':>10} {'0001':>8} {'0006':>8}\")\n",
    "print(\"-\"*80)\n",
    "\n",
    "for name, data in all_checkpoint_results.items():\n",
    "    v0001 = data['variant_snrs'].get('0001', 0)\n",
    "    v0006 = data['variant_snrs'].get('0006', 0)\n",
    "    print(f\"{name:<20} {data['epoch']:>6} {data['holdout_snr']:>12.2f} {data['val_snr']:>10.2f} {v0001:>8.2f} {v0006:>8.2f}\")\n",
    "\n",
    "print(\"=\"*80)\n",
    "print(\"\\nBest by validation SNR:\", max(all_checkpoint_results.items(), key=lambda x: x[1]['val_snr'])[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f68a76b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py38_default",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}