conditonal_mia_aug_dp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import json\n",
    "import logging\n",
    "import numpy as np\n",
    "from utils.load_dataset import load_dataset\n",
    "\n",
    "with open(\"./config.json\") as f:\n",
    "    config = json.load(f)\n",
    "\n",
    "logger = logging.getLogger(\"\")\n",
    "dataset_name = 'cifar100'\n",
    "arch = 'resnet18'\n",
    "num_augs = 2\n",
    "\n",
    "dataset = load_dataset(\n",
    "    dataset=dataset_name,\n",
    "    train_batch_size=128,\n",
    "    test_batch_size=128,\n",
    "    val_split=0.0,\n",
    "    augment=False,\n",
    "    shuffle=False,\n",
    "    root_path=config['data_dir'],\n",
    "    random_seed=0,\n",
    "    mean=[0, 0, 0],\n",
    "    std=[1, 1, 1],\n",
    "    logger=logger,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_scores_and_masks(seeds, dataset, method, num_augs, eps=None):\n",
    "    h = 0.001\n",
    "    num_seeds = len(seeds)\n",
    "\n",
    "    if eps:\n",
    "        aug_scores_file_name = {\n",
    "            'curv_zo' : \"curvature_scores_zo_{}_resnet18_eps_{}_seed_{}_{}_tid{}.pt\",\n",
    "            'curv' : \"curvature_scores_{}_{}_{}_tid{}.pt\",\n",
    "            'prob' : \"prob_{}_resnet18_eps_{}_seed_{}_{}_tid{}.pt\",\n",
    "            'loss' : \"losses_{}_{}_{}_tid{}.pt\",\n",
    "            'mentr' : \"m_entropy_{}_{}_{}_tid{}.pt\",\n",
    "            'loss_g' : \"loss_g_{}_{}_{}_tid{}.pt\",\n",
    "        }    \n",
    "    else:\n",
    "        aug_scores_file_name = {\n",
    "            'curv_zo' : \"curvature_scores_zo_{}_{}_{}_{}_tid{}.pt\",\n",
    "            'curv' : \"curvature_scores_{}_{}_{}_{}_tid{}.pt\",\n",
    "            'prob' : \"prob_{}_{}_{}_tid{}.pt\",\n",
    "            'loss' : \"losses_{}_{}_{}_tid{}.pt\",\n",
    "            'mentr' : \"m_entropy_{}_{}_{}_tid{}.pt\",\n",
    "            'loss_g' : \"loss_g_{}_{}_{}_tid{}.pt\",\n",
    "        }\n",
    "\n",
    "    score_seeds_v_seed = np.zeros((num_augs, dataset.train_length, num_seeds))\n",
    "    mask_seeds_v_seed = np.zeros((dataset.train_length, num_seeds))\n",
    "    start_seed = seeds[0]\n",
    "    for exp_idx in seeds:\n",
    "        array_idx = exp_idx - start_seed\n",
    "        augs = 1 if method == 'mentr' else num_augs\n",
    "        for aug_idx in range(augs):\n",
    "            if eps:\n",
    "                file_name = aug_scores_file_name[method].format(dataset.name, eps, exp_idx, h, aug_idx)\n",
    "                absolute_file_name = os.path.join(\n",
    "                    config['precomputed_scores_dir'], \n",
    "                    f'{dataset.name}_dp', \n",
    "                    file_name)\n",
    "                scores = np.load(absolute_file_name)['data']\n",
    "            else:\n",
    "                if 'curv' in aug_scores_file_name[method]:\n",
    "                    file_name = aug_scores_file_name[method].format(dataset.name, arch, exp_idx, h, aug_idx)\n",
    "                else:\n",
    "                    file_name = aug_scores_file_name[method].format(dataset.name, arch, exp_idx, aug_idx)\n",
    "                absolute_file_name = os.path.join(\n",
    "                    config['precomputed_scores_dir'], \n",
    "                    dataset.name,\n",
    "                    file_name)\n",
    "                scores = np.load(absolute_file_name)['data']\n",
    "\n",
    "            score_seeds_v_seed[aug_idx, :, array_idx] = scores\n",
    "\n",
    "        if dataset == 'imagenet':\n",
    "            array = np.load(f'/path/imagenet-resnet50/{0.7}/{exp_idx}/aux_arrays.npz')\n",
    "            mask_idxs = array['subsample_idx']\n",
    "            mask_seeds_v_seed[mask_idxs, array_idx] = 1\n",
    "        else:\n",
    "            mask_idxs = np.load(os.path.join(config['subset_idxs_dir'], f\"{exp_idx}.npy\"))\n",
    "            mask_seeds_v_seed[mask_idxs, array_idx] = 1\n",
    "\n",
    "    return score_seeds_v_seed, mask_seeds_v_seed\n",
    "\n",
    "def get_score_dist_params(scores, masks, num_augs):\n",
    "    means_in = []\n",
    "    means_out = []\n",
    "    var_in = []\n",
    "    var_out = []\n",
    "    for aug in range(num_augs):\n",
    "        in_scores = np.where(masks == 1, scores[aug], np.NaN)\n",
    "        out_scores = np.where(masks == 0, scores[aug], np.NaN)\n",
    "        means_in.append(np.nanmean(in_scores, axis=1))\n",
    "        means_out.append(np.nanmean(out_scores, axis=1))\n",
    "        var_in.append(np.nanvar(in_scores, axis=1))\n",
    "        var_out.append(np.nanvar(out_scores, axis=1))\n",
    "\n",
    "    return {\n",
    "        'means_in': np.row_stack(means_in),\n",
    "        'means_out': np.row_stack(means_out),\n",
    "        'var_in': np.row_stack(var_in),\n",
    "        'var_out': np.row_stack(var_out)\n",
    "    }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores = {}\n",
    "masks = {}\n",
    "dist_params = {}\n",
    "train_end_seed = 64\n",
    "train_seeds = list(range(train_end_seed))\n",
    "test_seeds = [0]\n",
    "eps = 1e-22"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_err(x):\n",
    "    return np.log(x + eps)\n",
    "\n",
    "def logit_scale(x):\n",
    "    x = x / (1 - x + eps)\n",
    "    return log_err(x)\n",
    "\n",
    "def nll(curv_score, mean, var):\n",
    "    ll = - ( ( (curv_score - mean)**2) / (2 * (var ** 2) ) ) -0.5 * np.log(var ** 2) - 0.5 * np.log(2 * np.pi)\n",
    "    return -ll\n",
    "\n",
    "def likelihood(curv_score, mean, var):\n",
    "    nll = - ( ( (curv_score - mean)**2) / (2 * (var ** 2) ) ) - 0.5 * np.log(var ** 2) - 0.5 * np.log(2 * np.pi)\n",
    "    likelihood_val = np.exp(nll)\n",
    "    return likelihood_val\n",
    "\n",
    "def get_likelihood_ratio(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    in_likelihood = np.zeros((test_scores.shape[1]))\n",
    "    out_likelihood = np.zeros_like(in_likelihood)\n",
    "    for aug in range(num_augs):\n",
    "        test_score_aug = test_scores[aug, :, 0]\n",
    "        in_likelihood += likelihood(\n",
    "            test_score_aug, \n",
    "            dist_params['means_in'][aug], \n",
    "            dist_params['var_in'][aug] + eps)\n",
    "\n",
    "        out_likelihood += likelihood(\n",
    "            test_score_aug, \n",
    "            dist_params['means_out'][aug], \n",
    "            dist_params['var_out'][aug] + eps)\n",
    "\n",
    "    likelihood_ratio = in_likelihood / (out_likelihood + eps)\n",
    "    return likelihood_ratio\n",
    "\n",
    "def get_likelihood_ratio_cnst(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    in_likelihood = np.zeros((test_scores.shape[1]))\n",
    "    out_likelihood = np.zeros_like(in_likelihood)\n",
    "    for aug in range(num_augs):\n",
    "        test_score_aug = test_scores[aug, :, 0]\n",
    "        in_likelihood += likelihood(\n",
    "            test_score_aug, \n",
    "            dist_params['means_in'][aug], \n",
    "            1)\n",
    "\n",
    "        out_likelihood += likelihood(\n",
    "            test_score_aug, \n",
    "            dist_params['means_out'][aug], \n",
    "            1)\n",
    "\n",
    "    likelihood_ratio = in_likelihood / (out_likelihood + eps)\n",
    "    return likelihood_ratio\n",
    "\n",
    "def get_nll_ratio(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    in_likelihood = np.zeros((test_scores.shape[1]))\n",
    "    out_likelihood = np.zeros_like(in_likelihood)\n",
    "    for aug in range(num_augs):\n",
    "        test_score_aug = test_scores[aug, :, 0]\n",
    "        in_likelihood += nll(\n",
    "            test_score_aug, \n",
    "            dist_params['means_in'][aug], \n",
    "            dist_params['var_in'][aug] + 1e-32)\n",
    "\n",
    "        out_likelihood += nll(\n",
    "            test_score_aug, \n",
    "            dist_params['means_out'][aug], \n",
    "            dist_params['var_in'][aug] + 1e-32)\n",
    "\n",
    "    likelihood_ratio = in_likelihood - out_likelihood\n",
    "    return -likelihood_ratio\n",
    "\n",
    "def get_nll_ratio_c(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    in_likelihood = np.zeros((test_scores.shape[1]))\n",
    "    out_likelihood = np.zeros_like(in_likelihood)\n",
    "    for aug in range(num_augs):\n",
    "        test_score_aug = test_scores[aug, :, 0]\n",
    "        in_likelihood += nll(\n",
    "            test_score_aug, \n",
    "            dist_params['means_in'][aug], \n",
    "            0.5)\n",
    "\n",
    "        out_likelihood += nll(\n",
    "            test_score_aug, \n",
    "            dist_params['means_out'][aug], \n",
    "            0.5)\n",
    "\n",
    "    likelihood_ratio = in_likelihood - out_likelihood\n",
    "    return -likelihood_ratio\n",
    "\n",
    "def get_identity(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    return test_scores[0]\n",
    "\n",
    "def get_mast(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    aug = 0\n",
    "    threshold = (dist_params['means_in'][aug] +  dist_params['means_out'][aug]) / 2 \n",
    "    return -(test_scores[aug, :, 0] - threshold)\n",
    "\n",
    "def get_mast_offline(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    aug = 0\n",
    "    threshold = dist_params['means_in'][aug]\n",
    "    return -(test_scores[aug, :, 0] - threshold)\n",
    "\n",
    "def get_ye_et_el_attack_r(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    aug = 0\n",
    "    alpha = 1e-4\n",
    "    out_scores = np.where(train_masks == 0, train_scores[aug], np.NaN)\n",
    "    threshold = np.nanpercentile(out_scores, alpha * 100, axis=1)\n",
    "    return -(test_scores[aug, :, 0] - threshold)\n",
    "\n",
    "def get_class_based(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    # This is handled during roc calculations\n",
    "    return -test_scores[0, :, 0]\n",
    "\n",
    "def get_loss_count(test_scores, dist_params, num_augs, train_scores, train_masks):\n",
    "    in_scores = np.where(train_masks == 1, train_scores[0], np.NaN)\n",
    "    threshold = np.nanmean(in_scores)\n",
    "    pred = (test_scores[:, :, 0] < threshold).sum(0) / num_augs\n",
    "    return pred\n",
    "\n",
    "methods = [\n",
    "    ('curv_zo', log_err, get_likelihood_ratio, 'Curv ZO LR', num_augs, train_seeds), \n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "for info_type, score_func, _, method_name, augs, seeds in methods:\n",
    "    if method_name in scores:\n",
    "        continue\n",
    "    \n",
    "    score, mask = get_scores_and_masks(\n",
    "        seeds=seeds, \n",
    "        dataset=dataset,\n",
    "        method=info_type,\n",
    "        num_augs=augs)\n",
    "\n",
    "    score = score_func(score)\n",
    "    params = get_score_dist_params(score, mask, augs)\n",
    "    scores[method_name] = score\n",
    "    masks[method_name] = mask\n",
    "    dist_params[method_name] = params\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "test_scores = {}\n",
    "test_masks = {}\n",
    "epsilons = [1.0, 2.0, 3.0, 4.0, 5.0, 10.0, 15.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0]\n",
    "for eps in epsilons:\n",
    "    for info_type, score_func, _, method_name, augs, _ in methods:\n",
    "        test_score, test_mask = get_scores_and_masks(\n",
    "            seeds=test_seeds, \n",
    "            dataset=dataset,\n",
    "            method=info_type,\n",
    "            num_augs=augs,\n",
    "            eps=eps)\n",
    "\n",
    "        score_for_seed = score_func(test_score)\n",
    "        mask_for_seed = test_mask\n",
    "        if method_name in test_scores:\n",
    "            test_scores[method_name] = np.concatenate([test_scores[method_name], score_for_seed], axis=2)\n",
    "            test_masks[method_name] = np.concatenate([test_masks[method_name], mask_for_seed], axis=1)\n",
    "        else:\n",
    "            test_scores[method_name] = score_for_seed\n",
    "            test_masks[method_name] = mask_for_seed\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_auc_score, roc_curve, balanced_accuracy_score\n",
    "\n",
    "aucs = {}\n",
    "accs = {}\n",
    "for e_idx, eps in enumerate(epsilons):\n",
    "    for idx, (info_type, _, pred_func, method_name, augs, _) in enumerate(methods):\n",
    "        y_pred = pred_func(\n",
    "            test_scores[method_name][:, :, e_idx, np.newaxis],\n",
    "            dist_params[method_name],\n",
    "            augs,\n",
    "            scores[method_name],\n",
    "            masks[method_name])\n",
    "\n",
    "        y_true = test_masks[method_name][:, e_idx, np.newaxis]\n",
    "        \n",
    "        fpr, tpr, thr = roc_curve(y_true, -y_pred, pos_label=1)\n",
    "        auc = roc_auc_score(y_true, -y_pred)\n",
    "\n",
    "        # Find the optimal threshold: where the sum of FPR and TPR is closest to 1\n",
    "        # \"Balanced accuracy is symmetric. That is, the metric\n",
    "        # assigns equal cost to false-positives and to false-negatives.\"\n",
    "        # - LiRA https://arxiv.org/pdf/2112.03570.pdf\n",
    "        optimal_idx = np.argmin(np.abs(fpr + tpr - 1))\n",
    "        optimal_threshold = thr[optimal_idx]\n",
    "\n",
    "        # Binarize predictions based on the optimal threshold\n",
    "        y_pred_binarized = (y_pred >= optimal_threshold).astype(int)\n",
    "\n",
    "        # Calculate Balanced Accuracy\n",
    "        balanced_accuracy = balanced_accuracy_score(y_true, y_pred_binarized)\n",
    "\n",
    "        if method_name in accs:\n",
    "            accs[method_name] += [balanced_accuracy]\n",
    "            aucs[method_name] += [auc]\n",
    "        else:\n",
    "            accs[method_name] = [balanced_accuracy]\n",
    "            aucs[method_name] = [auc]\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABYMAAAQZCAYAAACXeBUSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAFxGAABcRgEUlENBAAEAAElEQVR4nOzdfXRb933n+Q8IinpgYoEUKdtRnIigndq0HVugFNltkzoRqHHjdraNCCq7O926TUQ2TudMphmRVtpp0jNtFdJNT7rrdU0qyWZ3TqeWSE+2OWcysQnFbtrxQyVCXlem7dgElSiubZEmIcWknghi/7gBiQtcgHi+F8D7dQ6PiB/u/d0vL6R7oS+/+P5csVgsJgAAAAAAAABAVauzOwAAAAAAAAAAQOmRDAYAAAAAAACAGkAyGAAAAAAAAABqAMlgAAAAAAAAAKgBJIMBAAAAAAAAoAaQDAYAAAAAAACAGkAyGAAAAAAAAABqAMlgAAAAAAAAAKgBJIMBAAAAAAAAoAaQDAYAAAAAAACAGkAyGAAAAAAAAABqAMlgAAAAAAAAAKgBJIMBAAAAAAAAoAaQDAYAAAAAAACAGkAyGAAAAAAAAABqAMlgAAAAAAAAAKgBJIMBAAAAAAAAoAaQDAYAAAAAAACAGkAyGAAAAAAAAABqAMlgAAAAAAAAAKgBJIMBAAAAAAAAoAaQDAYAAAAAAACAGkAyGAAAAAAAAABqAMlgAAAAAAAAAKgBJIMBAAAAAAAAoAaQDAYAAAAAAACAGkAyGAAAAAAAAABqAMlgYA1DQ0N2h+AInAcAAAAAAIDKRjIYloLBoPr6+tTZ2ammpia5XC41NTWps7NTgUBAY2NjdodYcqFQSIFAQOPj43aHYivOAwAAAAAAQHVwxWKxmN1BwDlGRkY0MDCgSCSyMubxeOT1ehUOh1PGDx06pP7+/vIHmqWuri4Fg8GC5hgfH5ff719zu6amJtP5KTafz6eJiYm89i3neQAAAAAAAIAzkQyGJCkSiSgQCJgShn6/X4ODg/L5fKbtBgYGNDIyYtpudHRUHo+nnCGvKRwOq729vaA5vF6vpqam1txubGxMgUCgoGOtpbu7W6OjoznvV87zUGpLS0t67bXXTGPNzc2qq+NDDgAAAAAAwPmWl5c1NzdnGrvppptUX19fluOX5yhwtHA4rM7OTlNVa39/vwYHB1O29Xg8Gh4eVldX10ryMxgMqq2tTRMTE/J6veUKe01W8eeqr68vq+0OHz5c8LHWsn///rz2K+d5KLXXXntNHR0ddocBAAAAAABQNJOTk7rlllvKciwqg2tcJBJRZ2enwuHwyli2FagDAwOmRcU8Ho+mp6cdUSEciUTU1NRU8Dzz8/Nr/jzFqLzNRj7/VMt5Hsrh5ZdfJhkMAAAAAACqSjmTwVQG17hAIGBKBEvSkSNHstp3cHBQY2NjK/vHW004YaGxYlTq9vb2ZpUAHR4eTvtcvgnU5N7D3d3dec1TzvMAAAAAAAAAZyMZXMNGRkZSFhXr7+/PKfE3ODho6pUbDAY1NDRk+6Jy8Z7GXq83rz67kky9krM5lmT0Tx4YGNDOnTsLSqAGAgGNjY2tPM63RUQ5zwMAAAAAAACcjTYRNaypqSmlAjWfdgDFmqdYhoaGNDAwIMmo2u3t7S3ZsRIXjhsdHc27gjeZy+UyPc7nfJbzPJTL22+/reuuu840Njk5qZaWlpId8yc/+Yl27txpGjt58qQ+8IEPlOyYSG92djalVUip/w4gPV4PZ+H1cBbuH87Cvw9n4fVwFl4PZ+H+4Tz8G3GWang9rH6Gt956S9dee21Zjk9lcI0aGxtLSeD6/f68Erg9PT2m6ljJaE9QjIXL8hFvjeDxeEqeAI0fa3h4uGiJ4ORq7Xxfl3Keh3Kpq6tLGWtpaVFra2vJjrmwsJAytmXLlpIeE7kp9d8B5IbXw1l4PezD/cP5+PfhLLwezsLrYR/uH5WBfyPOUg2vh1W+o2THKtuR4ChWvWQT2z3kwmq/oaGhlGRzOSQmuUudjA6HwwqFQuru7i5qsjW5B3E+r0s5zwMAAAAAAAAqA8ngGhQKhRQKhVLG/X5/XvOl2y+5WrgcylkNOzw8LI/Hk/WCe9lKrgzu6enJeY5qrAoGAAAAAABAYUgG1yCrqmDJWGQsX1b7Hj16NO/58hEMBleS3IcOHSr58QYHBzUxMVHU3sjBYNBUUe3z+XKev9znAQAAAAAAAJWBZHANSq48lYykYyGs9g+FQmVtFZHYDmFgYEDt7e0KBAIaGRmxrIQuhkIS6FZGR0dNj/v6+nKew47zAAAAAAAAAOcjGVxjwuGwZYI2ebXSXO3atcty/NixYwXNm61QKJSS5A6HwxobG1NfX586OzvV1NSkQCCgsbGxssSUj+TzlWuLiGo5DwAAAAAAACg+ksE1xqoqWJLa29sLmjddZfH4+HhB82YrXeuLRJFIRGNjYwoEAnK5XAoEAgqHw2WILjvFaBFRDefBaRobG7MaAwAgEfcPAEA+uH8AKDWSwTUmXXK20HYHzc3NluPlaEsQT27mamxsTO3t7err6ytrO4t0kltE7N+/P6f9q+U8AAAAAAAAoDRIBteYdMnZQhdBS5dMLkfFaTbVsJmMjIyora0tbdV0uSS3iOju7s5p/2o5DwAAAAAAACgNksE1Jl1yttDK4EzJ5FInhNvb2+X3+/NqqxAXiUTU1dWlkZGR4gaXpeTF9rxeb86vSTWcBwAAAAAAAJROvd0BoHwytQBI1+YhFx6Px/IYoVCo4GRzJr29vert7U05ZjAY1Pj4eE6Vrn19fWpubs65KrdQw8PDpsf5HL8azgOwltbWVsViMbvDwM/xejgLrweQHv8+nIXXw1l4PYDM+DfiLLwehaMyuIbMzc2lfa7QNhFO4/P51N/fr/HxccViMY2Ojsrv92e1byAQKEuv40TJLSJy7RecTqWdBwAAAAAAAJQOyeAaUo7+vVYyJaHLpbu7W+Pj45qamsqq2nXPnj1lW0wtuUWEx+ORz+crybGcfB6camlpKasxAAAScf8AAOSD+weAUqNNRA0pdVKvubnZ8hhOSiZ6vV6Njo4qHA6rq6srbYI8Eono8OHDGhwcLHlMR48eNT1ObvVQCk48D/n6yU9+ooWFhZz2aWho0Lp16yyfW1xcXPnISWtrq+bn51O2mZ+f1zXXXJMyvm7dOjU0NFjOe/HiRS0vL+cUZ1x9fb3Wr19v+dylS5cUjUbzmtftdmvDhg1lnffy5ct5v5mtq6vTxo0bLZ+7cuWKrl69mte8LpdLmzZtsnzu6tWrunLlSl7zSlJjY6Pl+NLSki5fvpz3vJs2bZLL5UoZj0ajunTpUt7zbty4UXV1qb8nXl5e1sWLF/Oed8OGDXK73SnjsVhMi4uLec+7fv161ddbv5XJ9bqQKNtrRK64Rqw9bzVdI7K5f3CNMHCNMHCNWHvearpGZINrhKHWrhHp7h9btmzhGrHGvFwjDFwjDMW4Rlj9e5QKv0acP38+7/2LgWRwDbGrQvedd96x5biZeL1eTU1Nqa+vL+1iaUNDQzp06FDJW2gkH79YLSKy4aTzkK+dO3eWbO4vf/nLlr/MGBkZsTwf99xzj+655x7Lub71rW9pZmYmrzh27dql++67z/K5xx57TGfOnMlr3o6ODvX09Fg+993vfleTk5N5zbt9+3bdf//9ls8Fg0GdOHEir3lbW1v1+c9/3vK5Z555Rk8//XRe827atEn9/f2Wz506dUrf+9738ppXkr7yla9Yjr/66qsaHR3Ne96DBw9avvk7e/asvv3tb+c97wMPPKCtW7emjM/OzuqRRx7Je977779f27dvTxlfXFzUQw89lPe8gUBAt956q+Vzhcz7yU9+Uh/5yEcsn3v44YfzflPJNcJQK9eIbO4fXCMMXCMMXCMMtXKNyAbXCEOtXSPS3T9+4zd+g2uEuEYk4hphKOU14rbbbst7fyejTUQNKcYicZk4NVmYyfDwcNoLs5SaqC22craIyMTu8wAAAAAAAIDSIxlcQ0qdrE3XDmLLli0lPW6hBgcH0y6qNj4+XtJjJ7eISPeb03Kw8zwAAAAAAACg9EgG15BSVwanUwkVw6Ojo5ZxBoPBkh53bGzM9DgQCJT0eGux6zwAAAAAAACg9FyxfFc4QMUJh8Nqb2+3fK4Yfw2amposq4PHx8fTVpw6ydDQkAYGBlLGp6am5PV6i368UCikzs7Olccejydtc/JyKvd5yMXMzExKj6GTJ0/mXH2eywJyP/7xj1N6ib300kv64Ac/mLIvC7+sPS+LOhhY1MFQrQu/pMM1Yu15q+kakc39g2uEgWuEgWvE2vNW0zUiG1wjDLV2jUh3/7jxxhu5RqwxL9cIA9cIg9MXkOvo6DCNnzt3Tq2trXnPmwsWkKshmSqDI5FIySp47apIzlVvb69lEjRd+4tCJbeIcErCvNznoVAf+MAHSnrBtLpxb9q0Ke2NN510bywKle6NkFPnXb9+fdo3m4VoaGhI++a4EOvWrUv7Zr4Q9fX1af/zUQi3253z381s1NXVlWRel8tVknml9G+OC5XuzXyhuEYYqukaUcj9g2uEgWvEKq4Rhmq6RhSCa4ShWq8R6e4fmf6Oco0wcI0wcI0wFOMakS7XUGgOohSvey5oE1FD7OoZXAltIqT0i7fNzc2V5HjJLSL2799fkuPkqtznAQAAAAAAAOVBMrjGWCX5JKOFRCEyVY3a3VogF+Wqzg2HwynnvLu7uyzHzoZTqpQBAAAAAABQPLSJqDF+v1+hUChlvNCqz3T7p0s+O5VVT+VStLkYHh42PXZSIlgq33moBK2trfryl7+cMgYAQCbcPwAA+eD+AaDUqAyuMbt27bIcL7QyON3+lVZhapXwLEWbC6e2iIgr13kAAAAAAABA+VAZXGPSJWenpqYKmjddm4iurq6C5nWCYre5cHqLiHQqqd0HAAAAAACoQgsL0vS0NDMjXbkiNTRIra1SW5tUosUfqw3J4Brj8Xjk8XhSkrdWrSNyceLECcvxnTt3FjRvuSW3uyhFm4vkqmAnVk+X4zwAAAAAAABk5Y03pGeflV5+WYpGU593u6VbbpHuvlvatq388VUQksE1qLe3V0NDQ6axkydPFjSnVTLZ5/NVXGuB5ArpUiRqk/sFBwKBoh+jUOU4DwAAAAAAOB6VqPZaXpaeeEJ6/vnM20Wj0unT0ksvSbt3S3v3SnV0x7VCMrgG9fX1pSSDI5GIIpFI3slbq2Sy0/rgZiM5qV3sNhdWLSJ6enqKeoxiKPV5AAAAAADA0ahEtd/ysnTsmPTKK9nvE4tJzz0nRSJSTw8JYQuuWCwWszsIlF9nZ2dKwm90dDSv3rXhcFjt7e0p4/Pz8xVXGexyuVa+93q9BfdSTjY0NKSBgYGVxz6fTxMTE0U9RjGU+jzka2ZmRlu3bjWNnTt3rqSr68ZiMS0uLprGNm3aZDpHAAAk4/4BAMgH9w8HyLYSNc7lohK1VL7/fSOxmywalebnpaUlqb5eamoykvPJ7rpLuvfe0seZIztyG4moDK5RfX196uvrM40dPXo0r2Rwcg9cyWhFUWmJ4JGREdPjwcHBoh/j6NGjpsfJr4ETlOM8VBKXy6VGPvoDAMgR9w8AQD5ci4tqpCWBfahEdY433khNBEej0pkz0ptvGonguPp66frrpe3bzUnh55+Xbr+dyu0kVAbXsKamppSF5PL569De3p7S+mBqakperzfrOQYGBjQyMqJIJCK/36/h4eGc9i+GxJ+jFBW7VhXUTqyeLvV5KITdvz0DAAAAgJKgJYEzVGklakUaGzN6AMdFo9KLL0rnz6ffZ/Nm6Y47zAn522+X9u0rXZx5sDu3QWVwDTt06JCpZYFkVIX29vZmPUcoFEpJBPf39+eUyO3r6zNVowaDQXV2dmp6enrNRGkwGNT4+Lgko69tvgudDQ0NrfwcHo9Hx48fz2ueTJIrqIu5wF4lnQcAAAAAwM+xOJZzUInqHAsLxi9GEp05kzkRLBnPT09LiYV4k5NGgp7K+hVUBte45N7BHo9H8/Pzee+fa3/ZSCSipqYmy+f6+/sztihI7r8bP/7g4GBO7S6CwaBpgbSJiQn5fL6s989W8rkaHBxUf39/wfNW2nkohN2/PQMAAACAosmnJUHczTfTkqDYqrgSteKcPm28HnHRqFE5n5iQl4zzvrxsHquvNyroE5P03d3SbbeVLt4c2Z3b4KpR40ZHR03VqZFIJCWxmM7IyEjKInTx6tRsJVcVZ/ucJA0PD1vuEwgE1NXVldICw0piAjSeyC5FAjQSiaScq3z6M1uppPMAAAAAAPi5J5+0TgRHo9LsrPTWW8afVm0jXnnF2B/FUWglaqLJSWM+5G9mxvw43qIj0W23SR/7WGqSd2nJ2D7TfDWOZHCN83q9mpiYMCWEh4aGUhYRSxYMBlMWPxsfH8+5z2+m7deaK1OLhWAwqLa2trQ/RyQSUV9f30oC1O/3a2JiomR9ipPj8Hq9RTtWJZ2HShSNRnXmzBnTV9TqzRgAAAm4fwCoGAsLRhXeU08Z7Qqeesp4TDKrtNK0JFh+7TVdfOopXTp5UpdeeEGXTp5U7JlnpKmp1KTw888b86Bw09Pm8xuNGq0hkllVYr/5Zuq+yQli5ObKFfNjq4rglhbj+5aW1Nclefvk+WocPYOxkhAOBAIr1at9fX0aHx/X4OCgKTEYrxxOTC56vd68EsGSkcjs7e1NSVZ6PB4dOnQo476HDh1SIBBI+3w80TkwMCC/369du3ZpampKJ0+eXPk5vV6vBgYGcuqTnI+jR4+aHherKliqrPNQiS5duqRvf/vbprGDBw+yQjwAICPuHwAcjwXL7PXss+bHP29JEJub09s//anpqRtuuEHus2elCxfMLQliMSOhTEuCwmVbidrSYlRrJ7aTiFeixpOTVvMhNw0N5sf1SenL5WXjdYi/HlatIjLNV+PoGQyTkZERDQwMmFoLeDweeb1eRSIRy8XiMvX1zdbQ0JCGh4c1NzennTt3anh4OKvk8tjYmA4cOJBVK4REPp9PfX19ZUl+WvVFLnY/3ko4D8VgR1+dhYUFPfTQQ6Yx/jMPx3rjDenSJenqVeNracn8Z/z7pSXjDVM0uvp1001SuuvSd75jzL28bHzFYqvfxx+n++roMHp0Wfnbv119Ix1/O5L8Z7oxr1f6vd+znve//lfpf/yP1H2yce21Urp2Sd//vvGVj8ZG6c/+zPq5f/xHc0+0XH3969bjL7wgJSUjc/Kf/pP03vemjr/+uvTww/nPOzBgLLiS7K23pK9+Nf95f//3pRtvTB1/913pj/4o/3l/+7elHTusn/vCF9LudvXqVU1MTJjGOjs7tW7dOuPBvn3SRz9qvfMf/ZERdz7uvTf9KuZf/apxnvPxS78kpfvl88MPG38v8nHHHdLv/I71c9/+tvH3OB833mj8nbAyNmb8u8vHtddK6QoWuEYYuEasynCNWFMprxF791ovWPaP/5h+3uuukz74Qcnlsn6ea4Qh22vE1atSKGR+n3L+vPSzn2k5FtO7P/uZadf3bN6suviCWDfcYF4c66c/ldavl+L3l1xxjTDccYf04x+b53vlldUqX5fL/EuRN94wv35NTeYFyq6/3vg3U4nXCCe8j3jnHem111Yfx2JGBXZi0tfjkbZupWdwHkgGw1IwGNTo6KhOnjypcDisSCQij8ej5uZm+Xw+7d+/X36/P2OLgnJKjDcxaR2POd6Woaurq+xxj4yMmFpq5LpIXy6cfB6KgWQwqkI0Kp04YfwG++dv+vXuu5n/vHhRunzZSPQeOiR9/vPWc994o/ERwnz8238r/e//u/VzH/uY9A//kN+8gYCxMIqV7m7p8cfzm/dXfkV6+mnr5z7/eemRR/Kb95ZbjD5vVr7yFelP/iS/eVta0leIPPJI+tc0G+neyo2OGgvL5Ovtt4032Mmeflr6+Mfzn/f0aenWW1PHJyetx7P11FPSPfekjs/MWP8c2Tp6NP15TJcUycbDD6d/3bduzb+i6MtfNv6uWrn11vR/v9fyuc+l/3d1zz3S3/99fvN2dxt/V6309KR/bi1cI1ZxjTBwjTD88R8bf4+t+tQ+8kj+83KNMJToGhGrr5frl37JeJCc6DpxQvre9/Ka15ica4Qk6S//0twfOF79e+VKahV3LirtGlFJ7yPe/37zL0bikn9h4nZLf/AH5mS9zexOBtMmApb8fr/8fr/dYWTNyfH29vaWrfLWyecBqFqxmPFmMRw2qgbCYeM35v/b/ybt3Gm9/d1353+8ubn0z+VbESJZfzw0rpBVqjP9zrmQN8AAACB3U1PW999oNPUj8XAmq5YEKJzHY04GNzUZiXd6zVaWzZultjbzWEeHoxLBTkAyGACAtcRiRqL31VeNZG/yl9XHsO64wzoZXF8vNTdnTupmcvly+ueSe2PlIlMyuJCkLR9AAgDAOX76U3O7jGhUOnPG+Ph1pvcYsFfyezES98V33XXGv4/4e2K322j1kO+n7lBe9fXG69XWZi5kcbmku+6yLy6HIhkMoKLNzs5mvW25PnKBKjE/L/2f/6exKMfzzxvVv7nI9NGslpb8k8GXLqV/LrkyeN261a/6+tU/6+uNN0lu9+qXVe+1uDvvNP50uYz9Er9crtSvxPFMb75++ZeNmOL/wUn3p9XYL/xC+nnvvttorZG8bybxbTKdB59P+uxn157Lynvek/65W25Ze958EvJtbdKBA7nvF7dhg/X49dcXNm9SH/0VHk9h86Z77TZsKGzeTGsYZJj36tWrevHFF01jH/7wh1d7Bnd0pJ/3t37LaBGTj87O9M91d1uvjJ6N+MeTrfzar0kf+lB+82aKd88e4+9FPjLF80u/ZPTrzEema0RnZ/5/1zJdIzo6Cvs7nA7XCINN14g1leIaEQ5Lie+Hf75g2Uo1ZGtrahVkQ4PxS+zE+1Bzc2rlHdcIQ7bXiH/5F/P1+NIl472npOXlZS0sLOjixo1aqq9X/dKSWtatk+mdQGIBQGurdN990vvel1/M6dTaNcLrlRYWzAvDbd9uvGfP9Lqu9W+kkq4RkvPeR5w9K507lzoeixntMLZvN/49NDWZewTH7d5d9gUwZ7Jo0ZFLHqMU6BkMoGJY9dXJRT6XO3oG17Cf/cz4mFG+t8k/+APpa1+zfs7vN6qMm5qMhTXe8x7zn8ljmzYZb6jXrzfeUKZ7s7S4aCRi162zfjMEoGy4fwAZLCwYn7iZmTGSjw0NRkKrrY2P8pbKwoLREzXxk0BTU0aiZS0V0H+z4pw+bV4YMho1+tIuLSkajersz1+XZZdLdbGYbrjhBrnj7+0qYHGsivXGG9I3vmF+/59YPZ9YkZ2pEvWzny17ArJqLS8b649Y9Tlfy803G/2aC2l5lwdXnp+qpGcwAACltLxsLIj2N39jrEhstfDAe99rvKn+53/Obs76emPFYK/X+E/T7t3ptw0G84t7LZs2lWZeAACK4Y03jITXyy9btydyu41PS9x9N4mUYpueNp/zaNS6wq+uzniflOjNN43qu3jyMRo15iP5mL+2NuN8JrckSErO11kVJVx/vTkR7HanVmojP9u2Ge/hn3tudcztNv6vsH27Ub29tOS4StSqVldnJHSffNL8umTichmvw969ZU8EVwqSwQCA2vHii0YC+G//dvXN9g03SP/xP1pvv3u3ORnc3CzddJOR8PV6jTfe8e+3bSusZy8AANVqeVl64gmj7VIm0ahRMfnSS/xHvtiSP7YcT2oluu02o5XV7Kz5o/JWC5Zl8TFoZNDYaPziI7klwYULmVuJsThW6e3dK0UiqZWobvfai/bdfLOxP4qrrk66917p9tuNhPDkZPpfKHZ0GG3qSMhnxP9aAQDV7cc/lv7LfzG+Et9wx/3N30h/9EfWPVn/p//JaNOwe7fxpuKDHyxsMTUAAGpNPh/xjcWM//BHIrZ8xLcqJfcCTk4E19WtJrpaWlIrhJO3T54Pubv7buMXH/HqX7db+vCHtfz664q+8Ybciee/vl56//tZHKscqER1rm3bpH37jMQwrYYKQjIYQEWbnJxUy1q/oUXtWVqS/p//R/q//i/pH/8x87avviqFQtaLJfzarxlfAAAgP08+aZ0IjkbX/sj1K68Y+997b3lirWYNDebHyZ9mWl42KoLjlcHJrSKSt0+eD7lL05Ig1tamn77xhjZcuiT38rKidXV63+7dclstyEZLgtKgEtXZGhsd3abmnNWCd0lmZ2fVkWkRwBIjGQygorW0tJStyToqxPHj0r/7d0alxVpuu036X/9Xo9ICAAAU1xtvpFbWrbUYU2JvWsloLXH77SRaCpX8frmpyTjnia/B6dPWPYPjyfpM8yE/aVoSxOrqdDFxLQiralNaEpQelajIQyXkJ0gGAwCqw/S09MUvSt/5Tubt3v9+6X/5X4wk8Ic/XJ7YAACoRc8+a34cjRr9+8+fT912acno53/hgnTHHavJr3jLiH37Sh9vNctywbKURLDEgmWlREuCyuDwSlQgVySDAQCV7+RJ6Zd/Wbp82fp5j0cKBIwE8Ec/yhtnAABKbWFBevll89iZM9aJ4ETnzxu/4G1vXx2bnDQq86jAy1+mBcsyvSYsWFZ6yS0JXnjBejtaEgAoEpLBAIDKt2OH8eb41Cnz+J13Sn/8x9InPymtX29LaAAA1KTpaXOPzWjUaA2RzKotwZtvmttFRKPGfFTmFSbNgmUZ23awYFn5/LwlwdWPflST77yjTQsLckejirrd+shv/IYabr2VJDyAoiAZDAAZbNy4UQ888EDKGBzG7Zb+6q+kj33MeNzSIv3Zn0mf+UzqYjQAUAbcP1DzZmbMj+OLxSW67bbVBcsSK1aXloztExcJTp4PuUuzYJna243k+1oL+kksWFYGG1ta1P2Vr5jGNrS08Mk2AEVDMhgAMqirq9PWrVvtDgPZ+OhHpd/6Lam5Wfryl1MXOgGAMuL+4TALCyz+U25XrpgfJyeC6+pWk73xRFdihXDy9snzIT9pFiyT221OvlthwbKy4P4BoNRIBgMAKsOFC9Kf/In0n/6TlLi6cqL/+/82Pr4IAIAkvfGGsYjZyy+bWxbEud1GH9W776basdgaGsyP65P+67m8bFQExyuDk1tFJG+fPB/yw4JlAFDzSAYDAJxvbs5YWOPECaPX3d/9nXUPYBLBAADJSCw+8YT0/POZt4tGjfYEL71EsqvYWlvNj5uajARvYsXv6dPWPYPjbQoyzYf8JS9YNjmZ/pclLFgGAFWHZDAAwNneflvq6pL++Z+Nx088IX3609KxY9K6dfbGBgBwnuVl4x6R/DH4TGIxIykWiRhVkySEC9fWZiQT40lGt9tYkOzsWfN2yYlgydgusV+t223Mh+L6+YJluvde2qgAQA0hGQwAcK6f/lTas0f60Y/M4888Y/xn0uu1Jy4AgHM9+aR1IjgaXXuBrFdeMfa/997yxFrNGhuNFhyJC8Nt3260fTp/Pv1+mzenJn47OkhKllJjo7GYHwCgJpAMBoAMlpeXNTs7axpraWlRHRVDpRcOG4ngM2fM4+9/vxQMkggG4GjcP2zyxhupfVCjUeNe8uab5hYF9fVGBer27eak8PPPGx+f52Pxhbv7bqMFRyxmPHa7pQ9/OPPr0dZmrsx2uYw2BUCN4P4BoNRIBgNABhcvXtQjjzxiGjt48KAaqU4prVdeMRLB//Iv5nGvVzp+3PiPOwA4GPcPmzz7rPlxNCq9+KJ1JerSkvEpkwsXpDvuWE1AxltG7NtX+nir3bZtRi/mxAS92y21txv38rUqtSVjfxLzqCHcPwCUGr9aAgA4ywsvSB/7WGoi+OabpR/+kEQwAMDawoL08svmsTNnMrckkIznp6fNY5OTxnwo3N69xj08mdsttbRI111n/GmVCL75ZmN/AABQNCSDAQDO8fzz0sc/bixgkujOO6W//3sqgwAA6U1Pry5WJhnfv/lm6nZWH7V+883UfZMTxMhPXZ2xKF8urR7irSFYzA8AgKKjTQQAwBmeflr69V+X3n3XPL57t/Tf/7vx8VEAANJJ/kVivAVBottuM6pQZ2fNC5stLRnbt7Sknw/5q6szFuW7/XajZcTkpDn5Hud2G4vF3XUXvwAGAKBESAYDAOx38qT0q78qXbpkHr/nHum735Xe+15bwgIAVJArV8yPkxPBdXWryd6WFuPx8nL67ZPnQ+G2bTN6Md97r1F5PTNjnOeGBqm11Vg8jr6oAACUFMlgAIC9rlyRfud3UhPBv/qr0uOPSxs32hMXAKCyNDSYH9cn/VdnedmoCI5XBicmgq22T54PxdPYaFRpAwCAsiMZDACw15NPmj+qK0mf+pT0X/6LtH69PTEBACpPa6v5cVOTkeBNrPg9fTq1IlgytktuR5Q8HwAAQBWgGz8AwF6/9mvSD34g3Xij8fjOO6XHHiMRDADITVub0XM2zu2Wrr8+dbvkRLBkbJe8b1tb8WMEAACwGclgAID9Pv5x6cUXpQcflL7xDWndOrsjAgBUmsZG6ZZbzGPbt0ubN2feb/Pm1MRvRwe9awEAQFUiGQwAcIaNG6XDh6XOTrsjAQBUqrvvllyu1cdut/ThD0s33JDaE7i+3hi/4w6jdUScyyXddVd54gUAACgzegYDqGizs7NZb9tK7z8AAKrbtm3S7t3Sc8+tjrndUnu7USU8P2/0EI73CE5sDRG3e7cxDwAAQI5mZmbW3CaXPEYpkAwGUNE6Ojqy3jYWi5UwEgAA4Ah790qRiPTKK+Zxt1tqacm87803G/sDAADkYevWrXaHsCbaRAAAyuvv/k4aHrZewAcAgELV1Uk9Pbm1eoi3hujpMbeMAAAAqDJUBgMAymd+Xurrk95+W/qbv5GOHJF+4RfsjgoAUG3q6qR775Vuv91oGTE5KUWjqdu53cZicXfdRWsIAABQE0gGAwDK5+BBIxEsSf/wD8aiPadOpa7+DgBAMWzbJu3bZySGp6elmRnpyhWpoUFqbZXa2qTGRrujBAAAKBtXjCaaACrEzMxMSv+dyclJtazV/+/n8llALhqN6uzZs6axG264QW6rBWeQ2Q9+IO3ZYx77tV+Tvvtd88rvAFAFuH8AAPLB/QOobNkuIJe8/tG5c+fKtug9yWAAFcMqGVzOCyYKcPGi8VHdqanVsfe8x/jY7g032BcXAAAAAABlZHdug9URAACl9yd/Yk4ES9JXv0oiGAAAAACAMiIZDAAorVOnpL/4C/PY3XdLn/ucPfEAAAAAAFCjSAYDAEpnaUn67GfNK7ivWyd94xvGSu8AAAAAAKBs+J84AKB0/vN/lkIh89gf/qGU1CwfAAAAAACUXr3dAQCAk8ViMS0uLprGNm3aJJfLZVNEFWZ42Pz41lulQ4fsiQUAyoj7BwAgH9w/AJQayWAAyGBxcVEPPfSQaezgwYNqbGy0KaIK8s//LD3/vHnsz/9camiwJx4AKCPuHwCAfHD/AFBqtIkAAJTGN75hfnz99dInP2lPLAAAAAAAgGQwAKAELl0y+gUn+p3fker5QAoAAAAAAHYhGQwAKL7vfEeanzePfeYz9sQCAAAAAAAkkQwGAJTCL/+y9Md/LL3//cbjPXskr9femAAAAAAAqHF8XhcAUHw33CD9yZ8YCeEnn5Te8x67IwIAAAAAoOaRDAYAlI7bLf3qr9odBQAAAAAAEG0iAAAAAAAAAKAmkAwGAAAAAAAAgBpAMhgAAAAAAAAAagDJYABAcfz0p9If/ZEUDtsdCQAAAAAAsEAyGABQHN/+tvRnfya1t0tdXdL/+//aHREAAAAAAEhAMhgAULjlZemb31x9HAxK3/ueffEAAAAAAIAUJIMBAIU7flw6c8Y89tnP2hIKAAAAAACwRjIYAFC4b3zD/Pj226Vdu+yJBQAAAAAAWKq3OwAAKMTs7GzW27a2tuY8//r16xUIBFLGkGB2VvrOd8xjBw5ILpc98QCAA3D/AADkg/sHUNlmZmbW3CaXPEYpuGKxWMzWCAAgSzMzM9q6dWve+3O5K5G//Evpi19cfbx+vfQv/yI1N9sXEwAAAAAAZebKsyjq3LlzeRWw5YM2EQCA/MViqS0i9u0jEQwAAAAAgAORDAYA5O/ZZ6WXXzaPHThgTywAAAAAACAjegYDAPJ35Ij58Y03Sr/yK/bEAtS6hQVpelqamZGuXJEaGqTWVqmtTWpstDs6AAAAAA5AMhhARZucnFRLS4vdYdSm8+elY8fMY5/5DAvHAeX2xhurVfrRaOrzbrd0yy3S3XdL27aVPz4AAACgRpw7d27NbWZnZ9XR0VGGaKyRDAZQ0VpaWsrWZB1JHntMWlxcfex2S/ffb1s4QM1ZXpaeeEJ6/vnM20Wj0unT0ksvSbt3S3v3SnV0CgMAAACKrRLyEySDASCDhYUFPfTQQ6axgwcPqpGPXKe2iPj1X5euu86eWIBas7xsVOa/8kr2+8Ri0nPPSZGI1NNDQrjEuH8AAPLB/QNAqfG/AABA7v6//0+amDCPffaz9sQC1KInn7ROBEej0uys9NZbxp9WbSNeecXYHwAAAEDNoTIYAJC7//bfzI+3bZPuvdeeWIBa88YbRoVvomhUOnNGevNNaWlpdby+Xrr+emn7dqOVS9zzz0u3304PYQAAAKDGkAwGAOTuP/wH6ROfkP7hH6Qf/lC6805zoglA6Tz7rPlxNCq9+KKxqGOypSXp7FnpwgXpjjtWW0PEW0bs21f6eAEAAAA4BslgAEDuGhqku+4yvg4etDsaoHYsLEgvv2weO3PGOhGc6Px5aXpaam9fHZucNCr66UEIAAAA1Ax6BgMAAFSK6WlzH+Bo1GgNkcxqcbg330zdd3q6+DECAAAAcCwqgwEAACrFzIz58fy8uUewJN12m9TSYiwgd/r06vjSkrF9S0v6+QAAAABUNSqDAQAAKsWVK+bHyYngurrVZG9LS2qFcPL2yfMBAAAAqGokgwEAACpFQ4P5cX3Sh7yWl42KYMn4c3k58/bJ8wEAAACoarSJAABk7yc/kf7bf5M+9jHpllus+5ICKJ3WVvPjpiYjwZtY8Xv6tPFv0yoR3NSUeT4AAAAAVY3/xQMAsvf970sPPGD0JG1tlX7v9+yOCKgtbW2S27362O2Wrr8+dbvkRLBkbJe8b1tb8WMEAAAA4FgkgwEA2fvhD1e/n5uTLlywLxagFjU2GlX5ibZvlzZvzrzf5s2pid+ODmM+AAAAADWDZDAAIHv/8A/mxx/7mD1xALXs7rsll2v1sdstffjD0g03pPYErq83xu+4w9zWxeWS7rqrPPECAAAAcAx6BgMAsvPjHxs9gxN99KP2xALUsm3bpN27peeeWx1zu6X2dqNKeH7e6CEc7xGc2BoibvduYx4AAAAANYVkMAAgO8lVwVu2pH5cHUB57N0rRSLSK6+Yx91uqaUl874332zsDwAAAKDmkAwGgAwaGhr0yU9+MmWsJiX2C5akX/5l88fOAZRPXZ3U0yM9+aS5QjgTl8uoCN67l3+7ZcD9AwCQD+4fAEqNZDAAZLBu3Tp95CMfsTsMZ6BfMOAsdXXSvfdKt99uJIQnJ6VoNHU7t9tYLO6uu2gNUUbcPwAA+eD+AaDUSAYDANZ27lzqx9HpFww4w7Zt0r59RmJ4elqamZGuXJEaGqTWVqmtTWpstDtKAAAAAA5AMhgAsLZ//Efz48ZGaccOe2IBYK2xUbrtNrujAAAAAOBgNIwDAKwtuV/wL/6iVM/vEwEAAAAAqCT8Tx5ARZudnc1629bW1hJGUuXoFwwAAAAAQEYzMzNrbpNLHqMUSAYDqGgdHR1ZbxuLxUoYSRW7cEF64QXzGP2CAQAAAAAw2bp1q90hrIlkMABksLi4qIcfftg09vu///vatGmTTRHZ4JlnpOXl1ccNDRIrHANARtw/AAD54P4BoNRIBgNABrFYTIuLiyljNSW5X/CuXdLGjfbEAgAVgvsHACAf3D8AlBoLyAEAMrvlFqmrS2psNB7TLxgAAAAAgIpEZTCAijY5OamWlha7w6huv/VbxtfVq0bv4C1b7I4IAAAAAADHOXfu3JrbzM7O5rT+UbGRDAbWMDQ0pP7+/pqPwalaWlrU2tpqdxi1Yd06o0UEAAAAAABIUQn5CdpEwFIwGFRfX586OzvV1NQkl8ulpqYmdXZ2KhAIaGxszO4QSy4UCikQCGh8fLwqYuA1BQAAAAAAqG1UBsNkZGREAwMDikQiK2Mej0c+n0/hcFihUEihUEhjY2PyeDw6dOiQoytWu7q6FAwGC5qj0ESs3TFU22sKAAAAAACA/FAZDElSJBJRV1eX+vr6VpKGfr9fExMTmp+fX/lzfn5evb29K/sMDAyoq6vLlGh0inA4XHAS1uv1yu/3V2QM1fiaAgAAAAAAIH8kg6FwOKy2tjZT0rK/v1/j4+Py+XymbT0ej4aHhzU6OroyFgwG1dbWpnA4XLaYszE4OFjwHH19fRUZQ7W+piizq1elWMzuKAAAAAAAQJGQDK5x8erRxCrQ7u7uNZOY3d3dplYCkUhEnZ2djqkmjUQiGhkZKXieeMVsJcVQra8pbPB//B/Stm3S/v3Sww9Lr7xid0QAAAAAAKAAJINrXCAQSKn+PHLkSFb7Dg4Oyuv1rjyORCIKBAJFjS9fhw8fLniO3t5eeTyeiouhWl9T2OCHP5TefFM6dkz6t/9W+su/tDsiAAAAAABQABaQq2EjIyMp/Wz7+/tzSj4ODg6akoXBYFBDQ0O2L0AWr8j1er2m9ge5SG6nUAkxVPNrijJbXpb+8R/NYx/7mD2xAAAAAACAoiAZXMMGBgZSxg4dOpTTHN3d3fJ4PKZWAgMDAwVX1RZiaGhoJZ6BgYGCk7qVFEO1vqawwcsvS++8Yx776EftiQUAAAAAABQFbSJq1NjYWEovWL/fn1eyr6enJ2WsGC0S8hU/tsfjKajnb6XFUM2vKWzwD/9gfvyBD0gf/KA9sQAAAAAAgKIgGVyjrBJ7+faGtdovsTK2nBITomstmFZtMVTrawqb/PCH5sdUBQMAAAAAUPFoE1GDQqGQQqFQyrjf789rvnT7jYyMlL3PbK1WBVfza2q3devW6Z577kkZq2qxWGoymH7BAJCTmrx/AAAKxv0DQKmRDK5B6T7u7/V6857T6/UqHA6bxo4ePVrWxGEwGFxJiObaJ7fSY6jW19QJGhoaUt6MVb0zZ6Q33jCPURkMADmpyfsHAKBg3D8AlBptImpQMBhMGSt0gTOr/UOhUFnbCiS2ZBgYGFB7e7sCgYBGRkYsq2arKYZqfU1hk+R+wS0t0s032xMLnG1hQTp9WnrqKemJJ4w/T582xgEAAAAAjkNlcI0Jh8OWybydO3cWNO+uXbs0NjaWMn7s2LGytEoIhUIpCdFwOKxwOLwSl8fjkd/v1/79+9Xd3V01MVTrawobWfULdrnsiQXO9MYb0rPPSi+/LEWjqc+73dItt0h33y1t21b++AAAAAAAlqgMrjFWFaSS1N7eXtC86apQx8fHC5o3W+naJCSKRCIaGxtTIBCQy+VSIBBIaYNQiTFU62sKGyVXBtMiAnHLy9J//+/SkSNGBbBVIlgyxk+flr7xDen73zf2AwAAAADYjmRwjUmXyCukt6wkNTc3W46Xoz1DPMGaq7GxMbW3t6uvr6/g1gd2xlCNryls9NZb0o9+ZB5j8ThIRkL32DHp+eez3ycWk557ztiPhDAAAAAA2I5kcI1Jl8jzeDwFzZsu8VjMytt0sqnIzWRkZERtbW1pK2ydHkM1vqaw0T/9k/nxe94j3XGHPbHAWZ58UnrlldTxaFSanTV+kTA7a10t/Morxv4AAAAAAFvRM7jGpEvkFVpFminxGA6HC54/k/b2dvn9fs3NzaXtn7uWSCSirq4uDQ8P59UP184YqvE1dZKLFy/qW9/6lmnsd3/3d7Vx40abIiqxV181P77zTqmeW0XNe+MNo8I3UTQqnTkjvfmmtLS0Ol5fL11/vbR9u9E7OO7556Xbb6eHMGpGzd0/AABFwf0DQKnxP/wakilBma4lQC48Ho/lMUKhUEkTh729vSnJ0/hibuPj4zlV2/b19am5uTnnxd3siqFaX1MnWV5e1szMTMpY1UpuEfELv2BPHHCWZ581P45GpRdflM6fT912aUk6e1a6cMGoKq/7+YeQ4i0j9u0rfbyAA9Tc/QMAUBTcPwCUGm0iasjc3Fza5wptKeA0Pp9P/f39Gh8fVywW0+joqPx+f1b7BgKBovTFLUcMtfSaokz+8A+lv/s76aGHpAMHpCz/zqKKLSxIL79sHjtzxjoRnOj8eWl62jw2OWnMBwAAAACwBZXBNcSuXq+ZEpbl0t3dre7uboXDYQ0MDKy52NuePXs0PT1d1IRqKWKo5dc07ic/+YkWckwuNTQ0aN26dZbPLS4uKhaLSZJaW1u1sLCgK1eumLZJd7x169apoaHB8rmLFy/m/Rv9+vp6rV+/3vK5S5cuKWrVozULbrdbGzZsMA9u3y5t326eN8fzaznvz12+fFlLiS0FclBXV5f243FXrlzR1atX85rX5XJp06ZNls9dvXo15fXPRWNjo+X40tKSLl++nPe8mzZtksvlShmPRqO6dOlS3vNu3LhRdXVJvyeenlZsaWn1/C4vy/3Tn6b0Bo7V1cmV/Hf8pz9VdNs21Tc0GPNGo0aC+LbbjH1iMS0uLuYd7/r161Wfpo1JrteFRNleI3JVFdeIEs9bTdeIbO4fVXGNkFGxdvHixbzn3bBhg9yJbWV+jmvEKq4Rhmq6RmSDa4Sh1q4R6e4fXCPWnpdrhIFrhKEY14j5+XnL5wq9Rpxfq7CmxEgG15B8+tjmorm52fIYpT5uLrxer0ZHRxUOh9XV1ZU2mRqJRHT48GENDg46OgZeU2nnzp0lm/vLX/6yrly5omeeeSblOas3Yvfcc4/uuecey7m+9a1vpXzcK1u7du3SfffdZ/ncY489pjNnzuQ1b0dHh3p6eiyf++53v6vJycm85t2+fbvuv/9+y+eCwaBOnDiR17ytra36/Oc/b/ncM888o6effjqveTdt2qT+/n7L506dOqXvfe97ec0rSV/5ylcsx1999VWNjo7mPe/Bgwct3/ydPXtW3/72t/Oe94EHHtDWrVvNgzMzWlxcXHndNi4u6tpz50ybnNu6VYubNmnT5cvamvTc2wsL+oVf/MXVX2wl/DtYXFzUQw89lHe8gUBAt956q+Vzhcz7yU9+Uh/5yEcsn3v44YfzflPJNcJQK9eIbO4fVXGNkDQ7O6tHHnkk73nvv/9+bd++PWWca8QqrhGGarpGZINrhKHWrhHp7h979+7lGiGuEYm4RhhKeY247edFLNWGNhE1xK5qznfeeceW42bi9Xo1NTWVcaG2oaGhkiY9ixEDrymAkkuqVnAnVZ0su1xa/Hm1w+KmTVpOqiJI3j55PgAAAABA+ZAMriHFWFAsk0rsUTs8PJz2t3SSNDIy4ugYeE0BlFxSFXw06aNddbGYNv28wmXT4qLqkj76mLx98nwAAAAAgPIhGVxDSp3YS1fBumXLlpIet1CDg4NpF3YbHx93dAy8pgBKrrXV9PDShg0pCd6t587pAz/+cUqLiGhdnS4l93RLmg8AAAAAUD6uWL4rHKDihEIhdXZ2Wj5XjL8G7e3tlv1vh4eHM7ZCcIJIJKK2tjbL5Ge5/onkE0OtvaYzMzMpPYZOnjyZc3I61wXkvv71r5u2+cIXvmDZQ6niF3V45RXpmmuk66/XpcuXWdRBLOogSVpY0PLXvqalhHnrpqfl+ulP15xv+f3vV6ytTfX19ca8brf0B38g/fy8VOvCL+lU/DWiDPNW0zUim/tHVVwj5OyFX7hGcI2Ic9o1IhtcIwy1do1Id//weDxcI9aYl2uEgWuEwekLyHV0dJjGz507p9YyFc6wgFwNKXUVabr+tV6vt6THLQaPx6NDhw5pYGAg5blwOFyWnyGfGHhNpQ984AMlv2Amv+lqbGxMe+NNJ90bi0KleyOUl9/+bemf/klqbNSGm26S/vzPpV/91eLNL+OGmu7NZiEaGhrSvjkuxLp169K+mS9EfX192v98FMLtduf8d3NNjY2q6+hQw+nTq2M33igtLkqZVsHdvFnum26SEt/wdXSsJIIl481x0eP9uVLNm+7NfKEq4hpRhnmr7RqR7/2joq4RMv4DXYp5uUas4hphqLZrRL64Rhiq+Rphdf/I9HeUa4SBa4SBa4ShGNeIdLmGQnMQpXjdc0GbiBqSqb9sKRdKK3Vf22JJV+laynNTaAy8piiaWEz60Y+M7xcWpBdekCx+G4wadffd5r8Pbrf04Q9LN9wgJb/RrK83xu+4w5wIdrmku+4qT7wAAAAAAEskg2uIXf1lK2URMo/HI5/PlzKerjrWCTHwmqJoZmel5Nf7Qx+yJRQ40LZt0u7d5jG3W2pvNxLFt90m3Xyz8efddxvjyR8B273bmAcAAAAAYBuSwTXGKtEoybIvbC4yVaE6qaXAWtIt4ubkGHhNURTxquC4deukD37QnljgTHv3GgnfZG631NIiXXed8adFvy7dfLOxPwAAAADAViSDa0y6RGOh1a/p9k+XqHSq9vb2lLFyt0TINQZeUxTFa6+ZH994o3VSD7Wrrk7q6cmt1UO8NURPT2qlMAAAAACg7FhArsbs2rXLcrzQKtJ0+zuh0jYXVknXcrdEyDUGXlMURXJlMC0iYKWuTrr3Xun226XnnpMmJyWrlaDdbmOxuLvuojUEAAAAADgIyeAaky6RNzU1VdC86VoKdHV1FTSvEzihJUKmGHhNS6u+vj4l4V6KlVltRzIYudi2Tdq3z0gMT09LMzPSlStSQ4PU2iq1tUklWoUbqBQ1c/8AABQV9w8ApcYVpcZ4PB55PJ6URF8oFCpo3hMnTliO79y5s6B5yy25NYIdLRFyjYHXtLTWr1+v++67z+4wSi85GXzTTfbEgcrS2GgsGgcgRc3cPwAARcX9A0Cp0cCvBvX29qaMnTx5sqA5rRKPPp+v7C0WCpVcTWtHS4R8YuA1RUGWl1N7BlMZDAAAAABA1SEZXIP6+vpSxiKRSNq2ANmwSjzu378/7/nskpwAtaMlQj4x8JqiID/9qXTpknmMZDAAAAAAAFWHZHAN8nq9lq0HgsFgXvOFw2HLpKNVtarTJZ4Dr9drS2VwPjHwmqIgyS0i3vMe6brr7IkFAAAAAACUDMngGmVVSXr06NG85hobG0sZ6+3trbh2AiMjI6bHg4ODFRUDrynyZrV4nMtlTywAAAAAAKBkXLFYLGZ3ELBHU1NTSvVnPn8d2tvbFQ6HTWNTU1Pyer1ZzzEwMKCRkRFFIhH5/X4NDw/ntH8xJP4cPp9PExMTZT1+MWJw0mtaCjMzM9q6datp7Ny5c2ptbbUpoirxhS9If/VXq48//Wnpb//WtnAAAAAAAKhWduc26styFDjSoUOHNDAwYBobGRnJqRVAKBRKSRr29/fnlDTs6+szVcQGg0F1dnZqenp6zUrUYDCo8fFxSUZv3XzbOgwNDa38HB6PR8ePH896XyfEEOeU17SaXLp0SY899php7NOf/rQ2bNhgU0QlkFwZfNNN9sQBAFWkJu4fAICi4/4BoNSoDK5xnZ2dpgXLPB6P5ufn897f6/Vqamoq6/0jkYiamposn+vv78/YJmFoaCgl8en1ejU4OKju7u6sYwgGg6ZF2iYmJiz77zo1hmR2v6alZMdvzxYWFvTQQw+Zxg4ePKjGxsaSHbPsbrpJev311cf/+T9L/+bf2BcPAFSBmrh/AACKjvsHUP3srgymZ3CNGx0dNVXfRiKRlORmOiMjI6akoaSVCtlsJVegZvucJA0PD1vuEwgE1NXVZbkAWrLEJGw86ZlLEtYJMSSz+zVFBTp1yvg6dkz60z+V7rrL7ogAAAAAAEAJkAyucV6vVxMTE6bk4dDQUMpCZsmCwWDKgmXj4+M5txLItP1ac2VqIREMBtXW1pb254hEIurr61tJwvr9fk1MTOQcvxNiSGb3a4oK9J73SHfeKQUC0h/+oXTjjXZHBAAAAAAASoBkMFaSh4nVqH19fQoEAinVuckJzPj+U1NTefXK9Xg8lv1sPR6PDh06lHHftZ6Px9rU1KRAIKChoSH19fWps7NTTU1NGhkZkdfr1fDwsMbHx9fsT+zUGKzY+ZoCAAAAAADAmegZDJORkRENDAyY2ht4PB55vV5FIhHLhcUy9fXN1tDQkIaHhzU3N6edO3dqeHg4q4rUsbExHThwIKt2DIl8Pp/6+vpyWljNyTFkYtdrWgr0DAYAVAruHwCAfHD/AKqf3T2DSQbDUjAY1OjoqE6ePKlwOKxIJCKPx6Pm5mb5fD7t379ffr+/aJWshUqMNzHBGY/Z6/XK6/Wqq6urZHE7IYZs46uE19QKyWAAQKXg/gEAyAf3D6D62Z0Mri/LUVBx/H5/RbUIcEK8ToghE6fHBwAAAAAAgNIiGQygos3Ozma9bbl+y1ZRHntM+sAHpA99SNqyRXK57I4IAAAAAICKNDMzs+Y2ueQxSoFkMICK1tHRkfW2dMVJ8u670v/8P68+bmqSTpyQ2tvtiwkAAAAAgAqV3P7BiersDgAAYJPXXzc/np+X3vc+e2IBAAAAAAAlRzIYAGrVa6+ZH3/gA9LGjfbEAgAAAAAASo5kMADUqh/9yPz4Qx+yJw4AAAAAAFAW9AwGUNEmJyfV0tJidxiViWQwAAAAAABFc+7cuTW3mZ2dzWn9o2IjGQygorW0tKi1tdXuMCoTyWAAAAAAAIqmEvITJIMBIAO3253yGzu3221TNEVGMhgASqaq7x8AgJLh/gGg1FyxWCxmdxAAkI2ZmRlt3brVNHbu3LmK+M2b47zzjpTcXuO116Qbb7QnHgAAAAAAaoDduQ0WkAOAWvTaa+bH9fXS9u22hAIAAAAAAMqDZDAA1KLkFhHt7UZCGAAAAAAAVC2SwQBQi+gXDAAAAABAzSEZDAC1iGQwAAAAAAA1h2QwANQiksEAAAAAANQcGkQCQAaXLl3Sd7/7XdPYv/7X/1obNmywKaIiiMVSF5C76SZ7YgGAKlWV9w8AQMlx/wBQaiSDASCDaDSqyclJ09h9991nUzRF8s47UmOjtLi4OkZlMAAUVVXePwAAJcf9A0CpkQwGgFrT0iKdOyfNzxsVwj/6kfS+99kdFQAAAAAAKDGSwQBQq5qapI98xPgCAAAAAABVjwXkAAAAAAAAAKAGkAwGAAAAAAAAgBpAMhgAAAAAAAAAagDJYAAAAAAAAACoASwgBwC15F/+RfrGN6QPfcj4uukm6b3vtTsqAAAAAABQBiSDAaCWnDolffnLq4+3bJFmZ+2LBwAAAAAAlA1tIgCglrz2mvnxhz5kTxwAAAAAAKDsSAYDQC350Y/Mj0kGAwAAAABQM0gGA0AtIRkMAAAAAEDNomcwgIo2m0O/29bW1hJGUiFIBgMAAAAAUBIzMzNrbpNLHqMUSAYDqGgdHR1ZbxuLxUoYSQVYXJTOnjWPkQwGAAAAAKAotm7dancIayIZDAAZuN1ubd++PWWsIr3+eurYjTeWPw4AqAFVdf8AAJQN9w8ApeaK1XypHIBKMTMzU9Bv2Wr+cvf441J39+rj978/tVIYAAAAAADkxeVy5bXfuXPnytbakgXkAKBW0C8YAAAAAICaRpsIABVtcnJSLS0tdodRGUgGAwAAAABQMufOnVtzm9nZ2ZzWPyo2ksEAKlpLS0vZPkpR8UgGAwAAAABQMpWQn6BNBADUCpLBAAAAAADUNJLBAFAL5uel2VnzGMlgAAAAAABqCm0iACCDy5cvKxgMmsb8fr/Wr19vU0R5mpoyP3a7pe3bbQkFAGpB1dw/AABlxf0DQKmRDAaADJaWlnTixAnT2D333FN5b8YuXZLa2qS33pIuXpTe9z5p3Tq7o8rdwoI0PS3NzEhXrkgNDVJrq/GzNTbaHR0ArKia+wcAoKy4fwAoNZLBAFALfvmXpXBYisWkd9+VIhG7I8rNG29Izz4rvfyyFI2mPu92S7fcIt19t7RtW/njAwAAAACgApAMBoBa4nJJ732v8VUJlpelJ56Qnn8+83bRqHT6tPTSS9Lu3dLevVIdbfEBAAAAAEjE/5QBAM60vCwdO7Z2IjhRLCY995yx3/Jy6WIDAAAAAKACkQwGADjTk09Kr7ySOh6NSrOzRv/j2VnrthGvvGLsDwAAAAAAVtAmAgDgPG+8YVT4JopGpTNnpDfflJaWVsfr66Xrr5e2bzd6B8c9/7x0++30EAYAAAAA4OeoDAYAOM+zz5ofR6PSiy9KZ8+aE8GS8fjsWeP5xNYQ8ZYRAAAAAABAEpXBAFAb/uN/lJqbpWuvNb7uuktqbLQ7KmsLC9LLL5vHzpyRzp/PvN/589L0tNTevjo2OSnde69zf1YAAAAAAMqIZDAAVLuLF6U//VPz2MsvSzffbE88a5meNvcBjkaN1hDJ6upSF4l7801zu4ho1JjvtttKFi4AAAAAAJWCZDAAVLu3304du+668seRrZkZ8+P5+dTWELfdJrW0GAvInT69Or60ZGzf0pJ+PgAAAAAAahQ9gwGg2r31lvlxQ4O0ebM9sWTjyhXz4+REcF3darK3pcV4nGn75PkAAAAAAKhRJIMBoNolVwZfd53kctkTSzYaGsyP65M+xLK8bFQES8afya0ikrdPng8AAAAAgBpFmwgAqHbJyeBrr7Unjmy1tpofNzUZCd7Eit/Tp617BtfXG9tnmg8AAAAAgBpFZTAAVLvkNhFO7hcsSW1tqwvAScb311+ful1yIlgytkvet62t+DECAAAAAFCBqAwGgAzq6urUmlRZWpfco9bpKq0yuLFRuuUW88Jw27dLFy5I58+n32/z5tTEb0eHMR8AlFlV3D8AAGXH/QNAqZEMBoAMNm7cqM9//vN2h1GYSqsMlqS775ZeekmKxYzHbrf04Q9LZ85Ib75pbhlRX29UBLe1mReTc7mku+4qa9gAEFcV9w8AQNlx/wBQaiSDAaDaVVplsCRt2ybt3i0999zqmNsttbcbVcLz80ZCON4jOLE1RNzu3cY8AAAAAABAEslgABVudnY2622TP25VMyoxGSxJe/dKkYj0yivmcbdbamnJvO/NNxv7AwAAAABQJjMzM2tuk0seoxRIBgOoaB0dHVlvG4u3HKg1ldgmQjJaPvT0SE8+aa4QzsTlMiqC9+41t4wAAAAAAKDEtm7dancIayIZDADVbHFRevdd81ilVAZLRkL33nul2283EsKTk1I0mrqd220sFnfXXbSGAAAAAAAgDZLBAFDNkltESJVTGZxo2zZp3z4jMTw9Lc3MSFeuSA0NUmursXhcY6PdUQIAAAAA4GgkgwEggytXruiZZ54xjf3iL/6iGhoabIooR8ktIjZskN77XntiKYbGRum22+yOAgDWVPH3DwCALbh/ACg1ksEAKtrk5KRa1lpMrABXr17V008/bRrbtWtX5bwZu3pVuvFGIyn87rtGVbDLZXdUAFD1Kv7+AQCwBfcPoLKdO3duzW1mZ2dzWv+o2EgGA6hoLS0tam1ttTsM5/rYx6TXXjO+X1iQIhFbwwEAAAAAoFpVQn6CZDAA1IrGRvrqAgAAAABQw+rsDgAAAAAAAAAAUHokgwEAAAAAAACgBpAMBgAAAAAAAIAaQDIYAAAAAAAAAGoAC8gBQDX70pekLVuka6+VrrtOuvtuFpEDAAAAAKBGkQwGgGr17rvS4cPmsddfl9rb7YkHAAAAAADYijYRAFCt3nordezaa8sfBwAAAAAAcASSwQBQrd5+2/y4sVF6z3vsiQUAAAAAANiOZDAAVKvkZDBVwQAAAAAA1DSSwQBQrZLbRJAMBgAAAACgppEMBoBqlVwZfN119sQBAAAAAAAcod7uAADAyVwulzZt2pQyVhGoDAYA21T0/QMAYBvuHwBKjWQwAGSwadMm9ff32x1GfqgMBgDbVPT9AwBgG+4fAEqNNhEAUK2oDAYAAAAAAAlIBgNAtaIyGAAAAAAAJCAZDADVKBajMhgAAAAAAJiQDAaAavSzn0mXLpnHqAwGAAAAAKCmkQwGgGqU3CJCojIYAAAAAIAaV293AADgZFevXtWpU6dMYzt27NC6detsiihLyS0i3vMeadMme2IBgBpUsfcPAICtuH8AKDWSwQAq2uzsbNbbtra25jz/lStX9L3vfc80duuttzr/zdjSknTTTUaF8IULtIgAgDKr2PsHAMBW3D+AyjYzM7PmNrnkMUqBZDCAitbR0ZH1trFYrISROMzHPy796EfG9xcvSufP2xsPAAAAAABVbuvWrXaHsCaSwQBQ7TZuNL4AAAAAAEBNYwE5AAAAAAAAAKgBJIMBAAAAAAAAoAbQJgJARZucnFRLS4vdYQAAAAAAgBp37ty5NbeZnZ3Naf2jYiMZDKxhaGhI/f39dodhO6eeh5aWFrW2ttodBtJZWJCmp6WZGenKFamhQWptldrapMZGu6MDAAAAAKBoKiE/QTIYloLBoEZHR3Xy5EmFw2FFIhF5PB55vV55vV7t379f3d3ddodZUqFQSIcPH1YkEikoCRoKhXT06FEFg0FFIhGFw2F5PB41NzfL6/UqEAjI7/fL6/UWMfriKdZ5QBnFYtKDD0otLdJ110nXXiv90i+VN/n6xhvSs89KL78sRaOpz7vd0i23SHffLW3bVr64AAAAAACoYSSDYTIyMqKBgQFFIpGVMY/HI5/Pp3A4rFAopFAopLGxMXk8Hh06dMjRCcKuri4Fg8GC5hgfH89rv2AwqL6+PoXD4ZTnIpHISmI4Hl93d7cGBwdLkhS28zzABhcuSEND5rHp6fIkg5eXpSeekJ5/PvN20ah0+rT00kvS7t3S3r1SHW3sAQAAAAAoJf7nDUlGcrKrq0t9fX0riWC/36+JiQnNz8+v/Dk/P6/e3t6VfQYGBtTV1WVKHjtFYqI1X16vV36/P6d94ueyq6vLMhGcztjYmNrb2zWUnMQrkF3nATZ6663UsWuvLf1xl5elY8fWTgQnisWk554z9lteLl1sAAAAAACAZDCMZGFbW5spYdjf36/x8XH5fD7Tth6PR8PDwxodHV0ZCwaDamtryynxWQ6Dg4MFz9HX15fT9uFwWJ2dnQUlXwcGBhQIBPLeP5kd5wE2e/tt8+NrrpE2biz9cZ98UnrlldTxaFSanTWS1LOz1m0jXnnF2B8AAAAAAJQMyeAaF69iTazsjbcryKS7u9vUHiISiaizs9MxFcKRSEQjIyMFzxOvgs72mJ2dnUVJio+NjWlgYKDgeew4D3CA5MrgclQFv/GGUeGbKBqVpqaM3sGnTxsJ39OnjcdTU6lJ4eefN+YBAAAAAAAlQTK4xgUCgZTk5ZEjR7LaN7m/bSQSKWpFayEOHz5c8By9vb3yeDxZb79nzx5TMry3t1fj4+OamppSLBZb+ZqYmFB/f/+acw8NDRXc3sGO8wAHSK4Mvu660h/z2WfNj6NR6cUXpbNnpaUl83NLS8b4iy+aW0PEW0YAAAAAAICSYAG5GjYyMpKSbMwmSZlocHDQlAAOBoMaGhqyfVG5eDWs1+s1tbTIRXKLjEyGhoYUCoVW9hsdHU27EJzP55PP59Pg4KCGhoYyVgAPDAxoYmIit8ATlPs8wCGSk8GlrgxeWJBeftk8duaMdP585v3OnzcWtmtvXx2bnJTuvbc8i90BAAAAAFBjSAbXMKsk5KFDh3Kao7u7Wx6Px1QROzAwYGs16dDQ0Eo8AwMDJU9mxhfSk4yk6/Hjx7P+2fv7++Xz+dTV1WX5fCgUUjAYzGvxtnKfBzhIcpuIUlcGT0+bWz5Eo9Kbb6ZuV1eXukjcm29K27dLbvfqvtPT0m23lSxcAAAAAABqFcngGjU2NpbS39fv9+eVwO3p6UnpS3v48OGiLFyWj3hrBI/HU5Zet4k/+/j4eM7n0O/3a3h4OO0ibaOjo3klg8t9HqpVY2OjvvKVr9gdRm7KXRk8M2N+PD+f2hrittuklhZjAbnTp1fHl5aM7Vta0s8HABWoIu8fAADbcf8AUGr0DK5RVr1k8+33a7VfYlVqOSUmucuVjB4eHl75M11riLX09vamrdw9duxYzvPZcR7gIOVeQO7KFfPj5ERwXd1qsrelxXicafvk+QAAAAAAQFGQDK5BoVBopb9tonyqTzPtl1wtXA7lroYNhUIKh8Pyer0FHy9d0jafpDpVwTWu3AvINTSYH9cnfehkedmoCJaMP5NbRSRvnzwfAAAAAAAoCpLBNciqKlhS3lWt6fY9evRo3vPlIxgMriS5c+19XMgxpeJU32ZKxueSELbjPMBBYrHyt4lobTU/bmpKTfCePi398IfmFhGSsV1TU+b5AAAAAABAUZAMrkHxBGaiQhcXs9o/FAqVtVVEYkJ2YGBA7e3tCgQCGhkZsayELoajR4/K4/Gou7u7KPOlSwjn0ofYjvMAB4lEUtsslLoyuK1tdQE4yfj++utTt0uuCJaM7ZL3bWsrfowAAAAAAIBkcK0Jh8OWCdqdO3cWNO+uXbssx/Ppd5uPUCiUkuQOh8MaGxtTX1+fOjs71dTUpEAgoLGxsaId99ChQxodHS3afFZJ31wSwXadBzhIcr9gSdq6tbTHbGyUbrnFPLZ9u7R5c+b9Nm9OTfx2dBjzAQAAAACAoiMZXGOsqoIlqb29vaB501UWj4+PFzRvttK1vkgUiUQ0NjamQCAgl8ulQCCgcDhc0HG7u7vz7rVspbm5OWUsl/Yddp2Hara0tKSXXnrJ9LWUvOCZkyS3iPB4pA0bSn/cu++WXK7Vx2639OEPSzfckNoyor7eGL/jDvNici6XdNddpY8VAMqg4u4fAABH4P4BoNTq194E1SRdcraQfsGSdRJTUlnaEsSTm7kaGxvT2NiYent7NTg4mFMFbqnMzc2ljGX72lTTeXCSy5cvp1R/Hzx4UPXJCU6niEalX/gFIykciZS+X3Dctm3S7t3Sc8+tjrndUnu7USU8Py8tLa32CE5sDRG3e7cxDwBUgYq7fwAAHIH7B4BSozK4xqRLzhaaAEyXsCxHxWk21bCZjIyMqK2tLW3VdDlZna/9+/dntW81nQcUYM8e6ZVXjOTrxYvGom3lsnevdPPNqeNut9TSYvQubmmxTgTffLOxPwAAAAAAKBmSwTUmXXK20MrgTMnkUieE29vb5ff75fP58k5qRyIRdXV1aWRkpLjB5cgqWZ9tG4pqOg8okg0bSt8vOFFdndTTk1urh3hriJ4ec8sIAAAAAABQdHzOoIZYLRwXl67NQy48Ho/lMUKhUMHJ5kx6e3vV29ubcsxgMKjx8fGcKl37+vrU3Nys7u7uYoe5JqtEcG9vb9aJ3Wo5D6hwdXXSvfdKt99utIyYnDRaVyRzu43F4u66i9YQAAAAAACUCcngGmLVjzau2vrE+nw++Xw+9ff3SzL64g4PD2eVEA0EApqYmEi7KF6pHD16NGVsYGCgoDkr8TygSmzbJu3bZySGp6elmRnpyhWpoUFqbZXa2qTGRrujBAAAAACgppAMriHl6N9rJVMSuly6u7vV3d2tcDisgYGBNRda27Nnj6anp8uaJE+Oqbe3t+gV1ZVwHnL1k5/8RAsLCznt09DQoHXr1lk+t7i4qFgsJklqbW3VwsKCrly5Ytom3fHWrVunhoYGy+cuXryo5eXlnOKMq6+v1/r16y2fu3TpkqJWlbdZcLvd2rBhQ2nnbWyUbrtt5bnLly+vroac4+tWV1enjRs3Wj535coVXb16Na94XS6XNm3aZPnc1atXU17/XDSmSXgvLS3p8uXLec+7adMmuVyulPFoNKpLly7lPe/GjRtVZ9GuY3l5WRcvXsx73g0bNsht0Ss6FotpcXEx73nXr1+fdjGVXK8LibK9RuSKa8Ta85quETly2jUim/sH1wgD1wgD14i1562ma0Q2uEYYau0ake7+wTVi7Xm5Rhi4RhiKcY2Yn5+3fK7Qa8T58+fz3r8YSAbXkExtIoqhubnZ8hilPm4uvF6vRkdHFQ6H1dXVlTZBHolEdPjwYQ0ODpYlrmAwaIrF4/GU9NhOPQ/52LlzZ8nm/vKXv6wrV67omWeeSXnO6o3YPffco3vuucdyrm9961uamZnJK45du3bpvvvus3zuscce05kzZ/Kat6OjQz09PZbPffe739Xk5GRe827fvl3333+/5XPBYFAnTpzIa97W1lZ9/vOft3zumWee0dNPP53XvJs2bVqpnk926tQpfe9738trXkn6yle+Yjn+6quvpqwSnYuDBw9avvk7e/asvv3tb+c97wMPPKCtFn2mZ2dn9cgjj+Q97/3336/t27enjC8uLuqhhx7Ke95AIKBbb73V8rlC5v3kJz+pj3zkI5bPPfzww3m/qeQaYaiVa0Q29w+uEQauEQauEYZauUZkg2uEodauEenuH3v37uUaIa4RibhGGEp5jbgtobCpmrBaTw2xq0L3nXfeseW4mXi9Xk1NTaX02E00NDRUtkR2crL1yJEjZanGddp5QGFcsZj2PvGEful//A/d8cILuvH117Uuz99gAwAAAACA6kMyuIYUY5G4TJzcSiCd4eHhtL+lk6SRkZGSxxBf5C0u3sqhnJxwHlC4DRcv6hefe05dwaB+8+/+Tv/mb/5GGwv4WAwAAAAAAKguJINrSKmTtemqR7ds2VLS4xZqcHBQfr/f8rnx8fGSH//AgQMr38fbN9jB7vOAwr3n3XdTxhZYpA0AAAAAAPycK5bvCgeoOKFQSJ2dnZbPFeOvQXt7u2Xv2eHh4YxtCJwgEomora3NMqFdyn8iIyMj6uvrk2Qk6ycmJoq+aFwu7DoP2ZqZmUnpMXTy5Mmcf+GQ6wJyX//6103bfOELX7DsoWT3og51Tz+tjb/2ayvPxZqatHj2bNp5WdTBwKIOqypxUQcnLvySjt3XiFxxjTAUsoDcWvcPrhEGrhEGrhFrz1tN14hscI0w1No1It39w+PxcI1YY16uEQauEQanLyDX0dFhGj937pxaW1vznjcXFbOA3IULFyRJ11xzTdHnPn/+vHp6ejQyMqIPfvCDRZ/fKUpdGZyuJ7Gdyc1seTweHTp0SAMDAynPhcPhkvwMkUhkJREsScePH7f9XNlxHgr1gQ98oOQXzOQ3XY2NjWlvvOmke2NRKNMboaQVSV3XXptznJbzFtH69evTvtksRENDQ9o3x4VYt25d2jfzhaivr0/7n49CuN3uvF/zTOrq6koyr8vlKsm8Uvo3x4VK92a+UGW5RlTAvNV2jcj3/sE1wsA1YhXXCEO1XSPyxTXCUM3XCKv7R6a/o1wjDFwjDFwjDMW4RqTLNRSagyjF654LW5LBhw4dUiQSWUkeJn8vGYnF5OpEl8uV9295MgkGgxofH1dnZ6cmJiaqNiGcqWdwJBIpWbK41L2Ki6W3t9cyCVqqxdP27Nmz8v3o6Kh8Pl9JjpOrcp8HFNHbb5sfX3edPXEAAAAAAABHsiUZPDg4mFJyvtZHJTwej3p6ekoSz759+/TVr35VDz74oDo7O3X8+HHdcccdJTmWnezqGVwpC8t5PB75fD6FQiHTeLqK50L09fWtHGd4eLjsC8ZlUs7zgCJLTgZfe609cQAAAAAAAEeyZQG5ubk53XnnnYrFYitfcS6Xy5Qo7u7u1sTEhObm5vToo4+WLKb+/n7t27dPc3Nz6uzs1I9//OOSHctO6apPrXr95iJT1agTWwukk24BtWIaGRnRyMiIJOf2Uy7HeUAJvPWW+TGVwQAAAAAAIIEtlcEej0fHjx9Xc3OzZVPqWCym3t5eDQ4OavPmzWWLa3R0VJ2dnTp16pQCgYD+6Z/+qWzHLhe/359S8SkVXvWZbn+ntD7IVnt7e8pYMdtcBIPBlT7Bg4ODjkwES6U/D5Vk06ZNOnjwYMqYI1EZDACOUVH3DwCAY3D/AFBqtlQGS0ZCOLliNBaLafPmzRofH9ejjz5a1kRw3JEjRyRJExMT+uY3v1n245farl27LMcLrQxOt3+lVZhaJTyL1eYiHA4rEAhIMirR+/v7izJvKZTyPFSaeNP5xC+rX2I5Aj2DAcAxKur+AQBwDO4fAErNtmSwZK4mjcViampq0sTEhGlhrXLz+Xw6cOCAYrGY+vv7deHCBdtiKYV0ydmpqamC5k3XJqKrq6ugeZ2gGG0uIpGIOjs7FYlEVqreK00ltfuoWcltIqgMBgAAAAAACWxLBk9PT68kEGOxmFwulyYmJtTW1mZXSCuGhobk8XhWEnfVxOPxWFZ4WrWOyMWJEycsx3fu3FnQvOWW3O6iGG0uEhPB3d3dGh4eLnjOUivFeUCJLS9L586Zx0gGAwAAAACABLYlg8fGxiStJoKPHTum7du32xWOyebNm/Xggw8qFotpdHS06qqDrRLcJ0+eLGhOq2Syz+eruNYCyRXShba5iCeCw+Gwuru7NTo6WtB85VLs84AyeOcdKRo1j9EmAgAAAAAAJLAtGTw+Pi7J6IfT3d2tffv22RWKpXhvV2m1j3C1iC9gligSiaRt9ZANq2Ty/v37857PLslJ7ULbXOzZs0fhcFh+v78oieBQKFTQ65TLcRJVQ7uPqpfcL1iStm4tfxwAAAAAAMCxXLFYLGbHgevqjDy0y+XS1NSUY6qCE+3cuVOhUEjt7e167bXX7A6nqDo7O1MSfqOjo+ru7s55rnA4rPb29pTx+fn5iqsMTmzM7/V6C+ql3NXVpWAwKL/fv/LLj0JEIhG1tbVpdHS05JW6xTwPxTQzM6OtSQnOc+fOqbW1tWTHjEajOnv2rGnshhtukNvtLtkx83L8uJT492LLFml21r54AKDGVcz9AwDgKNw/gOpnR24jUX1ZjpLk1KlTklargp2YCJaMytZQKKRwOKwLFy7ommuusTukounr60upED569GheyeB4y49Evb29FZcIHhkZMT0uZJG3eCLY5/MVJREsSQcOHFBzc3PJE8HFPA/V4NKlS/r2t79tGjt48KAaGxvtCSidWEy65RZjEbn5efoFA4DNKub+AQBwFO4fAErNljYRwWBw5XsntxJITLodO3bMxkiKzypZa5XUzYbVgmgDAwM5zTEwMKCmpia5XC51dXUpHA7nFUshEpOePp8vr8S4ZLQYCQaD8nq9On78eFFi6+vr09jYmGWLj2Ir1nlAmfn90uSkNDcnXb4s/f3f2x0RAAAAAABwGFuSwSdOnFj5/lOf+pQdIWQlMVk6MTFhXyAlcujQoZSx5KrQtcQrpxP19/fL6/VmPUdfX5+GhoZWeuEGg0F1dnZm1Rs3GAxqYGBAAwMDpl8y5GpoaGjl5/B4PHknceNJW6/Xq4mJiYKqoyORiILBoLq6ulZeF6vF/yTnnQfYrKFBammxOwoAAAAAAOAwtiSD40m+XBKGdmhra1v53o5K1VLr7++Xz+czjeVa0XvgwAHTY6/Xm1NbgUgkYpmAjkQiOnz4cMZ9h4aG1NXVpaGhoZXv29vbc65wjidS444fP55XEndgYGDlZwmHwyuVzvl+NTU1rbSbkKTu7m7LuJx2HgAAAAAAAOBMtiSD5+bmJKmiEk3VmAyWjEXjEl+HSCSSdUJ4ZGQkZRG6XPvjZjqva51zq/YU4XBYgUBAXV1dWVcWd3V1SVpdKC05QZ6NeCK2lNK1iHDSeQAAAAAAAIBz2ZIMDofDcrlcjq8MThRPYFcbq3YGQ0NDa7aLCAaDKcnJ8fHxnF/TTNuvNVemXyYEg0G1tbWl/TkikYj6+vpWEqB+v18TExN5/Z0cGRnJuaI6V16vN+3CcU45DwAAAAAAAHA2W9tEZFOx6ASxWKxiYs1HPCGcWAna19enQCCQUp2bnDyM7z81NZU2WZmJx+Ox7IPr8XgsexonWuv5eKxNTU0KBAIaGhpSX1+fOjs71dTUpJGREXm9Xg0PD2t8fDyvSvVyLeqW6RhOOA8AAAAAAABwvno7D+701gvnz5+3O4SyiSeE41WukUhEY2NjGhsbk8fjkdfrVSQSsVwsLpcewVaGh4fV3t6u4eFhzc3NaefOnRoeHl4zKdnd3a3R0VEdOHAgY7I+8WeJ8/l86uvrS7sgW7YCgUBB+2crU5xOOA+wWTQqffGL0rXXStddZ3z9yq9ImzbZHRkAAAAAAHAQW5LBXq9X4XDY8cngkydPSlLFtbQoRG9vr3p7exUMBjU6OqqTJ08qHA4rFAqtJIV9Pp/2798vv99ftCrS/v5+9ff357xfd3e3uru7TfEmJq09Ho+am5vl9Xrl9XrV1dVV1LhjsVhR5imU3ecBNpudlf7qr8xj//IvJIMBAAAAAICJLcngxATUmTNntH37djvCWFPiYmi1ljTz+/15tX2wS6XFWyqchxr19tvmxy6X1NpqTywAAAAAAMCxbKsMDoVCkqTHH39cX/ziF+0IY03BYHDl+1qpDAYqzezsbNbbtlZrgjQ5GdzSItXb2gUIAAAAAICaMzMzs+Y2ueQxSsGWbMGuXbtW+pY++uijjkwGnzp1SqFQSC6XS5LU3Nxsc0QArHR0dGS9rVPaehTdW2+ZH197rT1xAAAAAABQw7Zu3Wp3CGuqs+Og8Y+xx2IxhcNhPfXUU3aEkdHhw4clrSaPOjs77QwHANJLrgy+7jp74gAAAAAAAI5mSzJ4x44d8ng8crlcisVi6uvrsyOMtKanpzU2NrZSFSxJPT09NkYEABlQGQwAAAAAALJgSzJYkvbs2bNSdTs1NaUvfelLdoWSoqury/TY5/PpmmuusSkaAFgDlcEAAAAAACALtq0wdOjQIT3++OMr1cGDg4Nqb2/XZz7zGbtCkiR97nOfUzgcXonL5XJp//79tsYEIL3JyUm1tLSUbP6NGzfqgQceSBlzlORkMJXBAGC7irh/AAAch/sHUNnOnTu35jazs7M5rX9UbLYlg30+n3bs2KEXXnhhJfHa29srSbYlhPfv35/SHkKSuru7bYkHwNpaWlrU2tpasvnr6uqc3wA+uU0ElcEAYLuKuH8AAByH+wdQ2UqZnygW29pESNLg4OBKq4jEhHDyb8FK7cKFC9q1a5fGxsZW4olXBXd3d2v79u1ljQcAckJlMAAAAAAAyIKtyWC/368dO3asPI4nhIeHh9XS0qKnnnqq5DH8xV/8hdra2hQKhVYSwImOHDlS8hgAIG/RqDQ7ax6jMhgAAAAAAFiwNRksSaOjoynVuLFYTHNzc/L7/dq1a5e++c1vFvWYFy5c0KFDh7RlyxYNDAxofn7elAiOf9/f38/CcQCcbWZGWl42j1EZDAAAAAAALLhi8UysjcbGxtTT02NatE2SqYWEZPTu7erq0s6dO3XnnXdmPf+FCxcUDAY1Pj6ukydPKhQKWc4fF4vF1NTUpOnpaZLBgIPMzMyk9M86d+5cRfTkKZmXX5aSG89fuSKtW2dPPAAAAAAAIC27cxuOSAZLUl9fn44cOZI2ISylJm29Xq+8Xq88Ho+am5tXxufm5hQOhxWJRDQ3N6dIJLLyXLr5EquSXS6Xpqam6BUMOIwdF8zl5WXNJrVhaGlpUV2d7R+sMDz/vHTXXauPN22SFhbsiwcAIKkC7h8AAEfi/gFUP7uTwfVlOUoWhoeHNTc3p8cff3wlKSulJmwTTU1NKRwOW86XKcdtNWdiIvjJJ58kEQxAknTx4kU98sgjprGDBw+qsbHRpoiSLC9L27dL588bX3yaAQAcwfH3DwCAI3H/AFBqjvrV0ujoqA4ePLiSlI0naONf8bHEr8TnE78kWW6fvE98u/j3jz76qPbs2WPbOQCAnNx9tzQ9Lc3NSUtL0tSU3REBAAAAAACHckxlcNzg4KC2bNmiBx98cCV5K8mUvI1LfD6TdFXCiXN7PB6Njo6SCAZQuVwuo00EAAAAAACABUdVBsf19/fr5MmTuvPOOy2rfOPSVQVbVQnHWVUId3d3a3p6mkQwAAAAAAAAgKrlyGSwJPl8Pk1MTKz0712r/YOVdNvF5/L7/RofH9exY8e0efPmsv1sAAAAAAAAAFBujk0Gx/n9fk1NTenYsWPq7u7W5s2bLat+MyWIE7ffvHmzent7NTU1pSeffJJqYAAAAAAAAAA1wXE9g9Pp7u5Wd3e3JOnUqVM6evSoQqGQwuGw5ubmFIlEUvbxeDxqbm6Wz+dTV1eX/H6/2trayhw5AAAAAAAAANivYpLBiXbs2KEdO3akjJ8/f15zc3Nqbm6m7QOA2vDYY9JPfypt3mx8+XzSjTfaHRUAAAAAAHCgikwGp7N582aSwABqyze+IR0/vvr4L/9S+vf/3r54AAAAAACAYzm+ZzAAIIMLF8yPr7nGnjgAAAAAAIDjkQwGgEp2/rz5MZ+OAAAAAAAAaVR0m4gf/OAHikQimpub09TU1Moich6PR1u2bJHX65XH49HOnTt1DdVyAKpRcjKYax0AAAAAAEijopLBP/jBDzQ+Pq5gMKhQKJTTvl6vV36/X4FAQJ/4xCdKFCEAlFlymwgqgwEAAAAAQBqOTwZfuHBBIyMjOnz48ErlbywWy3meqakphcNhjYyMSJIGBgb04IMPUjEMoHJdvSpdvGgeIxkMAAAAAADScHTP4EOHDqmpqUkDAwOan59XLBZbSQS7XK6cv+L7x2IxDQ4OqqmpSV/60pd0IbmyDgAqgdW1i19wAQAAAACANFyxfMpsS+yFF15QIBBQOBw2JX8T5Rp2uv1dLpeampp0/Phx3XHHHQVEDaDUZmZmtHXrVtPY5OSkWlpastq/tbU152NGo1GdPXvWNHbDDTfI7XbnPFfRhcNSe7t57N13pcZGe+IBAKxw9P0DAOBY3D+AyjYzM7PmNrOzs+ro6DCNnTt3Lq+cRT4clwx+6KGH9OCDD0oyEraJSdxihhqfNzEpPDIyos985jNFOwaA4rJKBufCYZe7wp06Jfl8q4/dbqN1RNIvvwAAAAAAQOklF6Nmq5zJYEe1iTh06JAefPBBU4I2sbVDfKyQr7j4nIktJHp7e/XAAw/Y8rMDQM6S20Rccw2JYAAAAAAAkJZjksFHjhzR4OCgqRo4MVlr1fc3ny+r+aTVxPPw8LC+9rWv2XkqACA758+bH7N4HAAAAAAAyKDe7gAk6fHHH1dfX59lEjj+OM7n88nv92vXrl3yer3yeDxqbm7WZoskyPnz53Xy5EmFw2FNTU0pGAwqFAqtPJ98jHhCuL+/X16vV7/5m79Zyh8bAApjVRkMAAAAAACQhu3J4OnpaQUCAVMLh8QErcfjUW9vr/bv368dO3bkNPfmzZu1Z88e7dmzxzR+6tQpPfbYYzpy5IgikYjpmPGEcHd3t0KhEIvKAQ6XywJyVYfKYAAAAAAAHOPcuXNrbmO1gFw52Z4M7uvrSxmLxWLyer0aGBjQgQMHin7MHTt2aMeOHRocHFQwGNTAwIBOnTqVkhA+cOCA/umf/qnoxwdQPC0tLSVtsh6LxbS4uGga27RpU95N4YuKZDAAOJaj7x8AAMfi/gFUtnItAlcIW5PBx48fVzAYTKkEPnLkiPbt21eWGPx+vyYmJhQMBtXT06PzCcmViYkJPfXUU/r4xz9ellgAOM/i4qIeeugh09jBgwfV2NhoU0QJXC7J4zHaRSwv0yYCABzE0fcPAIBjcf8AUGq2LiCX3CfY5/Npenq6bIngRH6/XydPntT27dtN/YMHBgbKHgsAZOXQIWl+XlpaMhLCjzxid0QAAAAAAMDBbEsGP/744wqHwyuPOzs7dfLkScuF4MrF6/VqamrK1Jt4YmJC3/nOd2yLCQDW5HJJ730vbSIAAAAAAEBGtiWDjx49Kmm1NcTx48ftCiXF8ePHdc0116xULT/22GM2RwQAAAAAAAAAhbEtGRwMBiUZi7UdOXJE1zio12U8OR2LxRSLxVZiBQAAAAAAAIBKZUsy+Pjx44pEInK5XPL5fPrUpz5lRxgZ+Xw+7dmzR5IUiUT0wgsv2BsQAAAAAAAAABTAlmTw+Pj4yveDg4N2hJCVxNioDgYAAAAAAABQyertOGjiwnGf+MQn7AghKz6fTx6PR+fPn9eJEyfsDgcAzB5+WNqwwVg4bvNm6a67JAe13AEAAAAAAM5iSzI4EolIkvx+vx2Hz4nf79fY2NhKzADgCLGY9O/+nbS8vDr2wgvSHXfYFhIAAAAAAHA2W9pEhMPhlX7BTuf1eiWZq5kBwHbvvmtOBEtGdTAAAAAAAEAatiWDJWnLli12HD4n7e3tkqS5uTmbIwGABBcupI7RIgIAAAAAAGRgSzK4EtEmAoCjnD+fOkYyGAAAAAAAZGBLMjjeeuGdd96x4/A5iSeBPR6PrXEAgElyMrixUaq3pQ08AAAAAACoELYkg+OJ1Urow3vixAlJqwlsAHCE5DYRVAUDAAAAAIA12FYZHIvFFAwG7Th8ToLBoFwuF8lgAM6SXBnM4nEAAAAAAGANtnymOJ5YjUQi+sEPfqBPfOITdoSxplOnTikSicjlcqm5udnucADYYP369QoEAiljtiMZDACO5tj7BwDA0bh/ACg1W5LBXV1dGhoakiSNjIw4Nhl8+PDhle+7urpsjASAXerr63XrrbfaHUaq5GQwbSIAwFEce/8AADga9w8ApWZLm4g9e/asfD86OqqnnnrKjjAyOnXqlMbGxlYef+pTn7IxGgBIktwzmMpgAAAAAACwBluSwZLU3d2tWCymWCymvr4+u8JIK/6xDJfLpe7ubpujAYAktIkAAAAAAAA5si0ZvH//fklGsnVqakr33nuvXaGk2L9/v8LhsOkxADgKbSIAAAAAAECObOkZLEn79u2T1+vV9PS0YrGYxsfHde+99+r73/++XSFJMhK/o6OjcrlcisVi8ng8tIgAHGx2djbrbVtbW0sYSZnRJgIAAAAAAEeZmZlZc5tc8hilYFsyWJK++tWvqqenZyXxOj4+rg996EMaHR3VHXfcUdZYXnjhBQUCAYXD4ZV4XC6Xjhw5UtY4AOSmo6Mj621jsVgJIykz2kQAAAAAAOAoW7dutTuENdmaDO7u7taOHTv0wgsvrCRgX3/9dfl8PgUCAT344IO68847SxrDmTNnNDAwoLGxsZVEkcvlksvlks/noyoYqHELCwt66KGHTGMHDx5UY2OjTRH9XDQquVxSPMFNmwgAcBTH3j8AAI7G/QNAqdnWMzjuyJEjKUnYWCym0dFRdXZ26qabbtLXvvY1nTlzpmjHPHPmjL7xjW9o165dam9vX0kEJx4/HhsAONLTT0tLS0aF8NmzEgtdAgAAAACANdhaGSxJPp9Pjz76qH7v935PLpdLkkwJ2ampKfX396u/v18ej0c7d+5UV1eXfD6fdu7cqWvWqIY7c+aMIpGITp48qfHxcQWDQUUiEUnmj4zHjx1PCn/1q18teVUyABSkrs6oCKYqGAAAAAAAZMH2ZLAk9fb2ampqSg899JCpX29cPGk7Pz+vYDCoYDCYMofH41Fzc7MkaW5ubiXhmyy5Z2jycVwul3p7e3Xw4MFCfywAZTA5OamWlha7wwAAAAAAADXu3Llza24zOzub0/pHxeaIZLAkDQ4OKhKJ6MiRIylVulaJ4WTz8/Oan59f8ziJcyUeI87v9+uv//qv8/kRANigpaVFra2tdodRPRYWpOlpaWZGunJFamiQWlultjaJPmUAAAAAAKRVCfkJxySDJWl4eFidnZ0rLSMS20VISkkM5ytde4i+vj4SwQBq0xtvSM8+K738srE4XTK3W7rlFunuu6Vt28ofHwAAAAAAKJijksGS0TJi586d2rNnj86fP29K1qarCpasK34zSZzX4/FodHRUe/bsKTB6AKgwy8vSE09Izz+febtoVDp9WnrpJWn3bmnvXqNnMQAAAAAAqBiO/J+8z+fTmTNndPDgwZUkcLwqOF11cHy7dEnj5P3j23V3d2t6eppEMIDK8fbb0je/KY2NSePj0okT+c2zvCwdO7Z2IjhRLCY995yx3/JyfscFAAAAAAC2cGQyWJI2b96swcFBzc/Pm5LC8URvcnJ3rS/JnDDu7e3V/Py8jh07ps2bN9v5owJAbl5+WfrsZ6VAwKjQvffe/OZ58knplVdSx6NRaXZWeust40+rthGvvGLsDwAAAAAAKobj2kQkiyeFv/SlLykYDGp8fFzHjh1TJBLJaR6PxyO/36+uri719PSQAAZQuc6fNz/O53r2xhtGhW+iaFQ6c0Z6801paWl1vL5euv56aft2o3dw3PPPS7ffTg9hAAAAAAAqhOOTwXGbN2/Wvn37tG/fPj366KOanp5WKBRSOBzWO++8o0gkonA4LMlI/Hq9Xm3ZskVer1c+n09tbW15HffUqVN68MEH9cQTTxTzxwGA/BUjGfzss+bH0aj04oupc0tGYvjsWenCBemOO1Z7BcdbRuzbl/vxAQAAAABA2VVMMjhZW1tb3gneXJw8eVLBYLDkxwGArF24YH58zTW57b+wYLSaSHTmjHUiONH589L0tNTevjo2OWm0qWhszC0GAAAAAABQdo7tGewUo6OjdocAAGaFVgZPT5v7AEejRmuIZHUWt4g330zdd3o6t+MDAAAAAABbVGxlcDlMT08rGAyuLEAHAI5QaDJ4Zsb8eH7e3CNYkm67TWppMRaQO316dXxpydi+pSX9fAAAAAAAwJGoDM4gEAjYHQIApCq0TcSVK+bHyYngurrVZG9LS2qFcPL2yfMBAAAAAABHojI4jV27dunUqVN2hwHAZg0NDfrkJz+ZMmarQiuDk+OvT7oVLC8bFcHxyuDl5czb230+AMCBHHn/AAA4HvcPAKVGMjjJhQsXtGfPHk1MTNAeAoDWrVunj3zkI3aHYVZoMri11fy4qclI8CZW/J4+bVQEWyWCm5oyzwcAcOb9AwDgeNw/AJSao5PBFy5cUDgc1tzcnJqbm+X1enVNrh+HzsELL7ygPXv2KBKJlOwYAFCw5GRwrtfFtjbJ7V5dCM7tlq6/Xjp71rxdciJYMrZzu1cfu93GfAAAAAAAwPEc1zP4woULOnTokG666SY1NTWps7NTXV1d6uzsVFNTk7Zs2aIHHnhAZ86cKepxjxw5os7OTs3PzysWi1EVDMC5knsG51oZ3Ngo3XKLeWz79rXn2bw5NfHb0WHMBwAAAAAAHM9RyeCHHnpITU1NGhoa0tTUlGKxWMrX/Py8hoeH1d7eri996UtFOe7nPvc5/d7v/d5KEtjlcikWixVlbgAoukLbREjS3XdLib/0crulD39YuuGG1J7A9fXG+B13mBeTc7mku+7K/dgAAAAAAMAWjmkT8a/+1b9SMBhcScJmqsyNbzM4OKhQKKTvf//7eR0z3h84FAqZqoFJBANwtELbREjStm3S7t3Sc8+tjrndUnu7USU8P2/0EI73CE5sDRG3e7cxDwAAAAAAqAiOqAz+3Oc+p/HxcVNlriTLymBJpurd8fFxffrTn875mC+88ILa2tpMieDkY8S/P3bsWJF+UgAo0PKy9LOfmcfyqQyWpL17pZtvTh13u6WWFum664w/rRLBN99s7A8AAAAAACqG7ZXBp06d0vDwcNZVuYnPxxO2o6Oj2r9/v37zN38zq2M+/vjj6unpsUz8Jsbh9Xo1Pj6uNhZHAmrW4uKiHn74YdPY7//+72vTpk32BLSwICVfJ/NNBtfVST090pNPmiuEM3G5jIrgvXvNLSMAACaOu38AACoC9w8ApWZ7MnhgYGDl+2xaRFhtG4vFdODAgaySwYcOHdLQ0JBlW4jEx4FAQEePHs3thwFQdWKxmBYXF1PGbPPe90rRqFEdfP68sZjc+96X/3x1ddK990q3324khCcnjfmTud3GYnF33UVrCADIguPuHwCAisD9A0Cp2ZoMnp6eVjAYXEno5tKzNzlhPD8/r29+85v6zGc+Y7n9hQsXFAgEVvoSWyWC498PDw/rwIEDef9cAFBSdXVGNXC+FcFWtm2T9u0zEsPT09LMjHTlitTQILW2Sm1tUmNj8Y4HAAAAAADKztZk8ODg4Mr3iclZv9+vQCAgv99vatEQTx4PDw8rFAqlJISPHTtmmQw+c+aMurq6FA6HTf2Bk4/r8Xh0/Phx7dixo+g/K4DSmJ2dzXrb1tbWEkZSJRobpdtuszsKAAAAAAAqzszMzJrb5JLHKAVbk8HHjh1LScaOjo5qz549ltu3tbXpwIEDOnDggILBoHp6enT+/PmV5G4wGNSFCxd0zTXXrOxz/Phx7f35IkeZEsF+v1+jo6PaXMxKOwAl19HRkfW2fLwKAAAAAACUytatW+0OYU22rf5z/vx5RSIRSUaCpqmpSRMTE2kTwcn8fr/C4XBK8vbkyZMr3z/00EPau3dv2oXiYrGYYrGYBgYG9OSTT5IIBgAAAAAAAFC1bEsGB4NBSavVukeOHDG1hMiGx+PRsWPHTD2A4/P29PTowQcfTOkP7HK5VhLBHo9H4+PjOnz4cBF/MgAAAAAAAABwHtvaRJw4cUKSUaHr8/n0qU99Kq95/H6/9uzZo+PHj8vlcml0dFTj4+OamJhYmd+qLYTP59Po6GjOCWgAsNXp09Krr64uIHfdddINN9gdFQAAAAAAqAC2JYNDodDK9319fQXNNTg4qJ07d0rSyiJxUvpEcF9fn/76r/+6oGMCcIbJyUm1tLTYHUb5HD0q/emfrj4OBKRjx+yLBwAAAAAASJLOnTu35jazs7M5rX9UbLYlg+fm5la+7+npKWgun88nr9er6enplTGr/sCSNDo6qn379hV0PNSWoaEh9ff32x0G0mhpaVFra6vdYZTPhQvmx/Q6BwAAAADAESohP2Fbz+D44nEej0fXXHNNwfP5/f6U5G9if2Cv16upqSkSwVkKBoPq6+tTZ2enmpqa5HK51NTUpM7OTgUCAY2NjdkdYsmFQiEFAgGNj48XPJcTzqcTYkARnD9vfkwyGAAAAAAAZMm2ZPDc3JxcLtdKe4dCdXV1rXyfvGhcIBDQ66+/Tn/gLIyMjKipqUldXV0aGRlZaefh8/kkGQnSsbExBQIBNTU1aWhoyM5w19TV1bXyS4Fcvzo7OzU2NqaBgYG8j++E8+mEGFBEycngIvwyDQAAAAAA1AbbK4O9Xm9R5kucJ14NHIvFNDg4qKNHj+Y97/T0tP7iL/6iGCE6WiQSUVdXl/r6+lZeG7/fr4mJCc3Pz6/8OT8/r97e3pV9BgYG1NXVtbKPk4TDYQWDwYLm8Hq98vv9Oe/nhPPphBhQArSJAAAAAAAAebItGRzn8XiKMk9iMjgWi8nj8WhiYkIHDx4saN5QKFRQZWglCIfDamtrMyVO+/v7NT4+vlI9GufxeDQ8PKzR0dGVsWAwqLa2NoXD4bLFnI3BwcGC58hncUMnnE8nxIASoU0EAAAAAADIk+3J4C1bthRlns0JCZHOzk5NT09rx44dBc9b7cmwePVoYhVod3f3monU7u5u06JqkUhEnZ2djqkmjUQiGhkZKXieeMVsLse1+3w6IQaUEG0iAAAAAABAnurtDqCYPB6Pzp8/L7/fb0oOF+LEiRNFmcepAoFASsL7yJEjWe07ODiosbGxlf0jkUjRFlwr1OHDhwueo7e3N+fKdSecTyfEUE3WrVune+65J2XMNrSJAICK4Lj7BwCgInD/AFBqtieDp6amij5nMSsZx8bGVhajqzYjIyMpPXX7+/tzSoAODg4qEAisPA4GgxoaGjJVmNohXhXs9XpN7Q9ykdxOIZtj2n0+nRBDtWloaEh5M2YrKoMBoCI47v4BAKgI3D8AlJorFovF7DhwXV2dXC6XvF6vXnvttaLMeeONN2p6elrd3d0FLRonSRcuXFipiHS5XIpGo0WJ0UmamppSEufz8/M5V8MWa55iGRoaWunzPDw8nHOrh3w54Xw6IYZSmpmZ0datW01j586dU2trq00Rldnly9KGDeaxV1+VPvQhe+IBAAAAAAA5sTu3YXtlcDgc1k033SS/319womlubk6SsejboUOH8pojEokoHA6nVFdWm7GxsZRkX76vQU9PT0p/3sOHDxdlAbd8xFtEeDyesiWCnXA+nRADSiy5KliiTQQAAAAAAMia7ZXB8cMXqxVDLBYrylzxeeJ/VltlcGdnp0KhkGks3yraYDCorq6ulHE7KknHxsZWWhyUsyrYCefTCTGUmt2/PbPd669LN91kHltclDZutCceAAAAAACQE7tzG3VlOUoGLpdrJelajC9JRZmnWvsES0bldHLSUDKqSPORbr/kytJysKMq2Ann0wkxoAySK4PXrUttGwEAAAAAAJCG7cngxMrgYnwVay6bCqbLIp4wTeb1evOe02rfQvs25yoYDK4kRPNtE5IPJ5xPJ8SAMkhOBm/eLFXxL64AAAAAAEBx2d4zWFLRE6/VnMgtBqt+yD6fr6A5fT6fwuGwaSwUCikSiZStrUBiP9uBgQENDw/L5/Opq6tLO3fuLPhnTMcJ59MJMVSrixcv6lvf+pZp7Hd/93e10Y7WDBcumB9fc035YwAAZMVR9w8AQMXg/gGg1GyvDJaKVxVc7K9qFA6HUxYZk6SdO3cWNO+uXbssx48dO1bQvNkKhUIpCdFwOKyxsTH19fWps7NTTU1NCgQCGhsbK9pxnXA+nRBDNVteXtbMzIzpa3l52Z5gfv3Xpfl56cwZ6cUXpSL+XQYAFJej7h8AgIrB/QNAqdmeDC5mv+Bif1UjqwpSSWpvby9o3nRVqOPj4wXNm610bRISRSKRlQXmXC6XAoFASuVrrpxwPp0QA8rE7ZY8HumDH5Ruv13ascPuiAAAAAAAQAWxvU1ELBaT3+9XIBBY6VHa3NxsSyxzc3OKRCIKh8M6evSo5YJclS5dIq+Q3rJS+tesHOcwnuTN1djYmMbGxtTb26vBwcG8Wh844Xw6IQYAAAAAAAA4n+3J4MHBQR08eNDuMFIcPHhQQ0NDevDBB+0OpajSJfIK7QGbLvFYaOVtNrKpCs5kZGREx44d0+joqPx+f077OuF8OiEGAAAAAAAAOJ+tbSI8Ho8jE8Fx/f39amtrszuMokqXyCu0ijRT4rHUycP29nb5/X75fL68E6CRSERdXV0aGRnJaT8nnE8nxAAAAAAAAADnszUZnGsVph0qIcZsWS0yFleM1hzpkoelbivQ29ur8fFxTUxMaH5+XrFYTBMTExocHMz59evr68u65YQTzqcTYgAAAAAAAEBlsDUZvGvXLjsPn5WdO3faHULRzM3NpX2u0JYCTuPz+dTf36/x8XHFYrGcWkAEAoGskp1OOJ9OiAFl9Mwz0vHj0smT0o9+JL37rt0RAQAAAACACmJbz2Cv1yufz2fX4bPm9XqrplWEXR/tz5SwLJfu7m51d3crHA5rYGBgzerfPXv2aHp62pGtEhLPpxNisNtPfvITLSws5LRPQ0OD1q1bZ/nc4uKiYrGYJKm1tVULCwu6cuWKaZt0x1u3bp0aGhosn7t48aKWl5dzijOuvr5e69evl/7Df5CefXb1iUcf1aXf/m1Fo9G85nW73dqwYYPlc5cuXSrJvJcvX9bS0lJe89bV1Wnjxo2Wz125ckVXr17Na16Xy6VNmzZZPnf16tWU1z8XjY2NluNLS0u6fPly3vNu2rRJLpcrZTwajerSpUt5z7tx40bV1aX+nnh5eVkXL17Me94NGzbI7XanjMdiMS0uLuY97/r161Vfb/1WJtfrQqJsrxG5Kvk1wkKp/i1zjTBkukZkc//gGmHgGmHgGrH2vNV0jcgG1whDrV0j0t0/uEasPS/XCAPXCEMxrhHz8/OWzxV6jTh//nze+xeDbcng119/3a5D52TPnj0VE+taMrUUKIbm5mbLY5T6uLnwer0aHR1VOBxWV1dX2mRqJBLR4cOHNTg4mHYuJ5xPJ8Rgt1JW73/5y1/WlStX9Mwzz6Q8Z/VG7J577tE999xjOde3vvUtzczM5BXHrl27dN9990nJN4xrrtFjjz2mM2fO5DVvR0eHenp6LJ/77ne/q8nJybzm3b59u+6//37L54LBoE6cOJHXvK2trfr85z9v+dwzzzyjp59+Oq95N23apP7+fsvnTp06pe9973t5zStJX/nKVyzHX331VY2OjuY978GDBy3f/J09e1bf/va38573gQce0NatW1PGZ2dn9cgjj+Q97/3336/t27enjC8uLuqhhx7Ke95AIKBbb73V8rlC5v3kJz+pj3zkI5bPPfzww3m/qSz5NcIC1wiDHdeIbO4fXCMMXCMMXCMMtXKNyAbXCEOtXSPS3T/27t3LNUJcIxJxjTCU8hpx22235b2/k9naJgLlZVc15zvvvGPLcTPxer2amppSb29v2m2GhoYyJj2dcD6dEAPK6MIF8+PNm+2JAwAAAAAAVCTbksG7du3SD37wA7sOX5OKsaBYJpXYo3Z4eDjtb+kkaWRkJO1zTjifTogBZZRcGUwyGAAAAAAA5MC2ZPDExERWi3SheEqd2EtXRbtly5aSHrdQg4ODaReXGx8fT7ufE86nE2JAmSwvSz/7mXnsmmvsiQUAAAAAAFQkVyzfFQ4KVFdXp56eHj322GN2HL4mhUIhdXZ2Wj5XjL8G7e3tlj14h4eHM7ZjcIJIJKK2tjbL5Ge6c+OE8+mEGMppZmYmpcfQyZMnc05O57qA3Ne//nXTNl/4whcseyiVdFGHS5ek5OT/j3+sS1u3sqiDWNQhrhYXdXDiwi/psPDL2vNW0zUim/sH1wgD1wgD14i1562ma0Q2uEYYau0ake7+4fF4uEasMS/XCAPXCIPTF5Dr6OgwjZ87d06tra15z5sL2xaQkzJXXaL4Sl1Fmq5/rdfrLelxi8Hj8ejQoUMaGBhIeS4cDlv+DE44n06IwW4f+MAHSn7BTH7T1djYmPbGm066NxZZe/vt1LHNm9O+ESpUqeZdv3592jebhWhoaEj75rgQ69atS/tmvhD19fVp//NRCLfbnfPfzWzU1dWVZF6Xy1WSeaX0b44Lle7NfKEKvkakwTXCYNc1It/7B9cIA9eIVVwjDNV2jcgX1whDNV8jrO4fmf6Oco0wcI0wcI0wFOMakS7XUGgOohSvey5sTQZHIhF97Wtf0xe/+EU7w6gZmfrLRiKRkiUWS93Xtlh6e3stk8HpWiU44Xw6IYZqV19fr127dqWMlV3y4nGS9J73lD8OAEBWHHP/AABUFO4fAErN9itKfPEuEsKlZ1d/2UpZhMzj8cjn86X0sk5XHeuE8+mEGKrd+vXrdd9999kdRurice99r2TxURgAgDM45v4BAKgo3D8AlJrtyeBYLKb+/n719/fL5/PJ6/Wqubm56MmmeE9Rj8cjr9crr9er7du3F/UYlcAq2SkZrRB8Pl/e86ZLGkrOaimwFr/fn9PChk44n06IAWWQXBnM4nEAAAAAACBHtieDXS7XSgP1UCiUUyKuGHw+n/bv36/u7u6aSA6nS3amq37NVrr9C0lG2qG9vT1lLFNLBCecTyfEgDJIrgzevNmeOAAAAAAAQMVKXcavzGKxmFwu10pSuNxfoVBIAwMDam9v16c//WmdOXPG7lNSUsm9h+LC4XBB86bb3+/3FzRvuVklfjNVqTvhfDohBpQByWAAAAAAAFAgx1QGezwe+f1+eb1ebdmyZSUBV4yFqhIrHCORiN555x2Fw2GFw2FTReXo6KjGx8c1Njamj3/84wUf14nSJfKmpqYKmjddS4Gurq6C5nWCTC0RnHA+nRADyoA2EQAAAAAAoEC2J4NjsZiGh4d14MAB22IYGxvTV7/6VYVCIc3Pz8vv92toaKgqF7XzeDzyeDwpib5C23OcOHHCcnznzp0FzVtuya0R1mqJ4ITz6YQYUAZUBgMAAAAAgALZngweHR3Vvn37bI2hu7tb3d3dGhoa0oMPPriyqJ2kqkwI9/b2amhoyDR28uTJgua0Sjz6fL6iLwRYasnVtNm0RHDC+XRCDNXq0qVLeuyxx0xjn/70p7Vhw4byBpKcDKYyGAAczTH3DwBAReH+AaDUbO0Z7PV6bU8EJ+rv79eTTz4pSSsJ4R//+Mc2R1V8fX19KWORSCRtW4BsWCUe9+/fn/d8dklOgGbTEsEJ59MJMVSraDSqM2fOmL6i0Wj5A/nzP5emp6UXXpB++EPp3//78scAAMiaY+4fAICKwv0DQKnZmgx24kJUfr9fX/3qV1ceWyXZKp3X67VsfxAMBvOaLxwOWyYde3t785rPTonnwOv1ZvV31Ann0wkxoMTe+15p+3bpjjukj35U6uiwOyIAAAAAAFBhbE0Gd3Z22nn4tPr7+7Vjxw7FYjGNj4/rv/7X/2p3SEVnleQ+evRoXnONjY2ljPX29lZcO4GRkRHT48HBwaz3dcL5dEIMAAAAAAAAcC7bksG9vb2OXogqMRGYb0LNyawSe1YJwGwMDw+njA0MDOQ0x8DAgJqamuRyudTV1aVwOJxXLIVIfM19Pp+6u7uz3tcJ59MJMQAAAAAAAMC5bEsGP/roo7rzzjvtOvya/H6/PB6PYrFY3gk1pzt06FDKWHJ17FpCoVBK4ra/v19erzfrOfr6+jQ0NLTSliAYDKqzszOrfrfBYFADAwMaGBjIuyWCJA0NDa38HB6PR8ePH895DiecTyfEAAAAAAAAAGeytU2E0/X09Kx8/4Mf/MDGSEqjv78/pc9srtWfBw4cMD32er05tVeIRCKWycpIJKLDhw9n3HdoaEhdXV0aGhpa+b69vT3n5H08oRx3/PjxvNohOOF8OiEGAAAAAAAAOBPJ4AwCgcDK9+Pj4zZGUjqjo6OmxGckEsk6eTgyMqJQKGQay/U8ZWoHsVarCKtWBuFwWIFAQF1dXVlXFnd1dUkykp5TU1OWC7Fly+7z6ZQYUGSxmPTUU9LEhPT669K5cxIrCgMAAAAAgByRDM4g8WPxdvSwLQev16uJiQlT8nBoaGjN1gLBYDBlwbLx8fGcWwlk2n6tuTJV7waDQbW1taX9OSKRiPr6+lYSwX6/XxMTEwW3QrD7fDolBhTZ5cvSJz4h7dwp3XSTdO21UpVekwAAAAAAQOmQDM6gra1t5ftsqkwrVTx5mFgR29fXp0AgkJIET06ixvefmpqS3+/P+dgej0e9vb2W41b9bxOt9Xw81qamJgUCAQ0NDamvr0+dnZ1qamrSyMiIvF6vhoeHNT4+nldrCCt2nk8nxYAiOn8+dWzz5vLHAQAAAAAAKhrJ4CxVa2VwXDx5ODw8vJIUHRsbU3t7u5qamtTZ2bnyfWKFaf//397/x7qV33d+/4u6V79tzbmae+V6JxOMDuMk1ng3NinlF7qtE5GOmyzSFialoMUXddOIROxFixYdMgpQxNsuVia9W/QPr2FSieECRdcSudmtUXgTk8q63V3H6ejSbtYr213fM7Oedd1Id3TPyB5pRtIVv38wpPjjHP48h4fkeT6AC4mH5Icf/jof8sXPeX9yOe3s7Mw0e7RUKqlQKMg0TRmG0ZmlOyqcTaVSAyURnNi2rWq1qnw+3ymDEIvFVCqVtLOz4xhGzyrIx3OR+gCPOIXBJ07Mvx8AAAAAAGCpRZrNZjPoTiyyAwcOKBKJyDAMvf7660F3Z27q9boqlYpu3rwpy7Jk27YMw9DJkycVi8V08eJFJRIJz2bTzqq7v7Ztd8L7dp9N05Rpmkomk4H0exEez0Xow6zu3LmjU6dO9Wy7ffu2tra2fLvNN998U5/61Kd6tr300ks6fvy4b7c54OZN6dy5p6cPHWqVjgAALKyFGD8AAEuH8QNYfUFkG93W53IrS67ZbK50mQgniURiqUoELHp/F6F/i9AHTKl/ZjAlIgAAAAAAwBQIg4d45ZVXOv9f5NmSQJjt7u6Ofdl5/crmOcJgAAAAAAAW3p07d0ZeZpIcww+EwUO0Sw1EIhGdPHky4N4AcHLmzJmxL7u0VXHu3es9Tb1gAAAAAAAWTn/5h0VEGDxEqVTq/J+ZwUA4ra2tDQTOa2tr8+0EM4MBYOksxPgBAFg6jB8A/BZYGPwrv/IrKhQKev/73x9UF0aqVquKRCKSxMxgIKSOHDmiCxcuBNsJwmAAWDoLMX4AAJYO4wcAvx0I6oZrtZpu3rwZ1M2PdPnyZUlPDytPJpNBdgdAmFEmAgAAAAAAeCDQMhE7OztB3ryrr3/96yoUCopEIp0wOBaLBdwrAE5u3bqlzc3NoLvhL2YGAwAAAACw8G7fvj3yMru7uxOtf+S1QMPgGzduBHnzjr7xjW8okUgMbP/lX/7lAHoDYJTNzU1tbW0F3Q1/EQYDAAAAALDwliGfCKxMhCRtb2/r3/ybfxNkF3p86lOfUjwe197eXmdWcCQSUSqVCrprAMKsPwymTAQAAAAAAJhCoGGwJKXT6UAD4W984xu6fPmynn32Wf3O7/xOJwDu1q4fDACB6K8ZzMxgAAAAAAAwhUDLREjSzZs3ZZpm588wDF9vz7Zt3b17V5ZlybbtzvZ2beB2ENwOhROJhN7//vf72icAi+utt97SF7/4xZ5tv/7rv64jR47MrxOUiQCApbMQ4wcAYOkwfgDwW+BhsNQKXnd2dmRZ1txur1//bGBJMgxDlUplHl0CsKD29/d169atnm2/9mu/Nt9O/NEfSXfvtkLhe/ckFrQEgIW3EOMHAGDpMH4A8FvgYXB3COsU0s7jdrtvv7tWcKVS0QlqcwII2o//eOsPAAAAAABgBoGHwd3lGZwC2nncdvftN5vNzozgX/7lX55rfwAAAAAAAADAL4GHwW1BzAp2mpUci8V048YNPUNNTgAAAAAAAAAr5EDQHZCezsqd15/UCn+7/1KplLa3t3Xz5k2CYAAAAAAAAAArJ/CZwe3SDPNkGIZM01QikdC5c+eUSCQIgAEAAAAAAACstMDD4GazqUwmo3Q6LdM0JUknT5705bYIfAEsnTfekHZ2pGeekU6caP176FDQvQIAAAAAAEso8DC4UqnoIx/5SNDdAIDF9M//ufQ3/sbT0z/2Y9JrrwXXHwAAAAAAsLQCrRlsmiZBMAAMc+9e72mOcAAAAAAAAFMKNAxOJBJB3jwALL433ug9TRgMAAAAAACmFGgYHI/Hg7z5sdy4cUPvec97gu4GgLDqD4NPnAimHwAAAAAAYOkFGgb7tVCclxqNhizLCrobAMKKMhEAAAAAAMAjgS0gt7e3p2eWINQolUpBdwFAmFEmAgAAAAAAeCSwmcHLEARfvnyZWcEAgkUYDAAAAAAAPBLYzOBF9uqrryqbzaperwfdFQABW1tb0wsvvDCwbW76y0RQMxgAlkLg4wcAYCkxfgDwG2Fwl1dffVWFQkHlclmS1Gw2A+4RgKAdOXJEH/3oR4PrADODAWApBT5+AACWEuMHAL8RBkv6xje+oStXrqharUp6GgJHIhECYQDBIgwGAAAAAAAeCXUY/Id/+Ie6cuWKGo2GpN4QGMBy2N3dHfuyW1tbPvbEJ5SJAAAAAABgKdy5c2fkZSbJMfwQujD43r17KpfLunLlimzb7pn52w6BCYWB5XHmzJmxL7uUM/2ZGQwAAAAAwFI4depU0F0YKTRh8LB6wP0hMAAshGaTMBgAAAAAAHhm5cPgP/mTP1GhUFC9XpfkPOvXKRgGgMA9eCA9fty7jTIRAAAAAABgSisbBv/+7/++CoWCLMuSNDwE7g+AmSEMoO3tt9/u/JjUlkgkdPjwYf9vvL9esMTMYABYEoGOHwCApcX4AcBvKxUGT1oKwikYNk1TiURC0WhUtVptYCcMYLHcunVLm5ubvrX/+PFjvfzyyz3bPvjBD87nw9jJk1Kj0SoVce9e61/D8P92AQAzC3T8AAAsLcYPYLndvn175GV2d3cnWv/IaysRBk9bCqK9zTAMZTIZZbNZnT59unO5l156SfF4XN/4xjf8vgsAprS5uamtra2gu+GPQ4ekD3wg6F4AAAAAAIAxLEM+sdRh8CSlILq3t7fFYjFdvnxZH/nIR1xv4+LFi4TBAAAAAAAAAJbe0oXB9+7d05UrV1Qul2Xb9tCwNxKJKBKJqNlsdv6VpFQqpcuXL+sDY8y4i0ajPtwLAAAAAAAAAJivpQmDv/GNb+jKlSuqVquSxl8QrjsIjkajunnzpp6ZYAEmwzBYUA4AAAAAAADA0jsQdAdG+cM//EOdO3dO8Xhc1WpVzWazE/B2zwTu3tY+/cwzzyiXy3XOM01zoiBYks6fP6+9vT0/7hoAAAAAAAAAzM1ChsH37t3T3/27f1fPPvus0um0tre3XUNgSQMhcCwWU6lU0t27d/XJT35y5v5MGiADgCf+4i8ky5Jef1169Cjo3gAAAAAAgCW3UGHwq6++qt/+7d/WxsaG8vm89vb2XAPf9jbp6czgVCql7e1t3bx5U5cuXQrsfgCAJ4pFKRqVNjelQ4ek3/qtoHsEAAAAAACW2ELUDP6TP/kTFQoF1et1ScNr//bPCjYMQ5cvX1Ymk2EGL4DV8sYbvaePHQumHwAAAAAAYCUEGgb//u//vgqFgizLkjRZCJxIJJTP53X+/Pk59xoA5uTevd7T/OAFAAAAAABmEEgYfPnyZRWLRUlPw11JQ2sBS61ZwJlMRtlsVqdPn55zrwFgzvpnBhMGAwAAAACAGQQSBhcKBUnqmfErDQbD7dOxWEzZbJY6wADChTAYAAAAAAB4KJAF5NoLvHUvBicNhsPpdJoF4QCEV3+ZiBMngukHAAAAAABYCYGEwbFYTKVSSXt7e/rkJz+p06dP9wTDkUhEhmHINE1tbGwE0UUACB4zgwEAAAAAgIcCCYPbnnnmGeVyOX33u9/Vl7/8ZZ0/f74TCtu2rWKxqGg0qg9/+MP6p//0nwbZVQAhdeDAAW1tbfX8HTgwp10nC8gBwNIKdPwAACwtxg8Afos0u+s0LIBXXnlFn/3sZ3X16lXZti3p6cJyhmHod3/3d3Xp0iWdmOBw6QMHDigSiSiRSOiP//iP/eg2gDm4c+eOTp061bPt9u3b2traCqhHPtrfl9b7yrp/85vSiy8G0x8AAAAAADCzoLONhft56fTp0yoUCrp7964++9nPKhaL9cwWzuVy2tjY0G/8xm/oG9/4RtDdBQB/PHgwuO0d75h/PwAAAAAAwMpYuDC4WyaT0c2bN7W9va2PfOQjnVC42WyqUqkoHo/rPe95j/7gD/4g6K4CgLfu3x/cdvTo/PsBAAAAAABWxkKHwW0f+MAHVKlUOgvOGYbRCYUty1Imk9Ha2po+9rGP6dVXXw26uwAwO6eZwceOzb8fAAAAAABgZSxFGNzWXnDu7t27un79uhKJRM9s4VKppGg0qnPnzukf/aN/FHR3AWB6zAwGAAAAAAAeW6owuFsqldKXv/xl7ezs6NKlS5LUCYUbjYZSqZQ2Nzd1+fLlmW/r3r17M7cBABPpnxl88KC0thZMXwAAAAAAwEqINJvNZtCd8Eq5XFaxWJRlWZ1tkUhE7bsYj8f18ssvT9TmjRs39KEPfUj7+/ue9hXA5IJYcfPhw4f66le/2rPtF3/xF3Xo0CHfblOS9M//ufTX//rT0888I9m2v7cJAPBMYOMHAGCpMX4Aqy+IbKPb+lxuZU4ymYwymYxu3Lihz372s/qH//AfqtlsKhKJSJIajYaeffZZ/e7v/q4uXbqkEydOjGyzO1gGsHh2d3fHvuw0O9ZHjx7pK1/5Ss+2c+fO+f9h7MUXpX/yT1ozhJ1KRgAAFlpg4wcAYKkxfgDL7c6dOyMvM0mO4YeVCoPbzp8/r/Pnz+uNN97Q3/k7f0dXr16V/Zcz6vb29pTL5ZTL5ZRMJpXP5/VLv/RLrm1tb2/PqdcApnHmzJmxL7tUB0JsbEgf/nDQvQAAAAAAAGPqn/G7iJa2ZvA4nnnmGRUKhc6Cc7FYTNLT2sK1Wk2JRKIzW/jVV1/tuf6rr76qcrkcQM8BAAAAAAAAwFsrHQZ3S6VSunnzpra3twcWnNvb21OhUFA0GtV73vMeXbx4Ub/yK7+iaDQacK8BAAAAAAAAwBuhCYPbPvCBD6hUKmlvb0+f/OQnZRiGpKfB8M7OjqrVqur1+nIdUg4AAAAAAAAAQ6xkzeBxPPPMM53aweVyWcViUZZldRabay88RyAMLLZbt25pc3Mz6G4AAAAAAICQu3379sjL7O7uTrT+kddCGwZ3y2QyymQyqlar+p3f+Z2eUBjAYtvc3NTW1lbQ3fDe/fvSkyfS0aPS2lrQvQEAAAAAACMsQz4RujIRw6RSKX33u9/VZz/7WT3zzDNBdwdAmP3tvy29853S+rp06JD0X/wXQfcIAAAAAAAsOcJgB5lMRpZl6f3vf3/QXQEQVvfvP/3/o0cSRysAAAAAAIAZEQa7MAxDN27c6CwwBwBz9eBB7+mjR4PpBwAAAAAAWBmEwUMYhqFLly4F3Q0AYUQYDAAAAAAAPEYYPMK5c+fUbDaD7gaAsOkuEyFJx44F0w8AAAAAALAyCINHSKVSevLkSdDdABA2zAwGAAAAAAAeIwwGgEVEGAwAAAAAADy2HnQHAGCRRSIRHesr0RCJRPy/YcpEAMBSC2z8AAAsNcYPAH6LNCmIC2BJ3LlzR6dOnerZdvv2bW1tbQXUIx/9zM9If/7nT0//L/+L9J/+p8H1BwAAAAAAzCzobIMyEQCwiCgTAQAAAAAAPEYYDACLiDIRAAAAAADAY4TBALCImBkMAAAAAAA8RhgMAIuIMBgAAAAAAHiMMBgAFk2zORgGUyYCAAAAAADMaD3oDgDAInv06JG+/vWv92z7wAc+oIMHD/p3o2+9NbiNmcEAsFQCGT8AAEuP8QOA3wiDAWCIhw8f6ktf+lLPthdffNHfD2Pr69I/+Aet2cH377f+3dry7/YAAJ4LZPwAACw9xg8AfiMMBoBFc/Cg9Bu/EXQvAAAAAADAiqFmMAAAAAAAAACEAGEwAAAAAAAAAIQAYTAAAAAAAAAAhAA1gwEstd3d3bEvu8UibAAAAAAAwCd37twZeZlJcgw/EAYDWGpnzpwZ+7LNZtPHnnio3c9IJNh+AAAAAACAsZ06dSroLoxEmQgAWDT/8B9K6+vSO94hbW1Jv/zLQfcIAAAAAACsAGYGA8CiefBAevJEevPN1t/eXtA9AgAAAAAAK4CZwQCwaB486D199Ggw/QAAAAAAACuFmcEAltqtW7e0ubkZdDe8df9+7+ljx4LpBwAAAAAAGNvt27dHXmZ3d3ei9Y+8RhgMYCzFYlG5XC7obgzY3NzU1tZW0N3wFjODAQAAAABYOsuQT1AmAo7q9bqy2azi8bg2NjYUiUS0sbGheDyudDqtarUadBc9lUwmFYlEFIlElM/ng+7OQmk0Gkqn06rVakF3JTwIgwEAAAAAgA+YGYwe5XJZ+Xxetm13thmGoVgsJsuy1Gg01Gg0VK1WZRiGLl++vJCzRSdRLpdVr9dnbmdjY6PncfNaLBbT9vb2VNdNJpMz30fC4DmiTAQAAAAAAPABM4MhSbJtW8lkUtlsthNoJhIJbW9va29vr/Pv3t6eMplM5zr5fF7JZNLXENRPlmUpm83O3E61WvX9MTBNc6rrWZY1cxBsmqYSicRMbWACzAwGAAAAAAA+YGYwZFmW4vF4T5iZy+VUKBQGLmsYhkqlkpLJpNLptKRWSYnTp09re3t76sAyKO37MKsrV6540s4wFy9enOp6Ts/jpLwIzJfV8ePH9YlPfGK+N0oYDABLL5DxAwCw9Bg/APiNmcEh154R3B0Ep1KpkQFiKpXqKQ9h2/ZAoLzo8vm8Go3GzO20y2f4LZVKTXwd27ZVLpdnvu32bHDMCWUiAAAAAACAD5gZHHLpdFqWZfVsu3r16ljXLRQKqlarnevbtr00C401Gg0Vi0VP2iqVSq7nGYYxVZv9ofo0QbDkzYzlTCYz9f3AlJgZDAAAAAAAfEAYHGJOC6flcrmJgr9CodBTaqFer6tYLC78onJelYeQ1DPzNpFIKJ/P6+zZszMFqOl0WtVqtXN62hIR7b6ZpqlKpTJVG7FYbKrrYQaEwQAAAAAAwAeEwSGWz+cHtl2+fHmiNlKplAzD6JnJms/nF3o2aXs2tGmaisViPaHrpLoXjqtUKlPP4HVqt9s0i7cVi8VO3/L5PKHuMqFMBAAAAAAA8AE1g0OqO8RsSyQSUwW4Fy5cGNg2jwXVplGtVjtBa6VS0cmTJ2dqr30/S6WSZ0Fw/2ztaZ+Xdt8Mw6Dm77JhZjAAAAAAAPABM4NDyimsnbZ0QjqdHlikrFgs6vLlyws1O9i2bV26dElSqxzGrDNl2wvHpVIpT8PW/hrE0zwv3WH/qMUAMdzjx4/1ne98p2fbT/3UT2l93cfdZ//MYMJgAFg6gYwfAIClx/gBwG/sTUKo0Wio0WgMbJ+mFMGw65XL5YWqHZxOp2XbtmKxmCcBaalUkmEYYy+4N67+mcFOM69HYVawd95+++2BessvvfSSvx/G/rv/TvqLv2jNEH7wQHrxRf9uCwDgi0DGDwDA0mP8AOA39iYh5FbCwTTNqds0TVOWZfVsu3bt2sKEwd2L5U27kFq/QqGgbDbr6ezner3eU74jFotN3H69Xu+E/ZPWgMaC+E/+k6B7AAAAAAAAVhA1g0Oof+appJlLJjhdv9FoDNQlDoJlWcpms5Jas3lnCb37edmWNBhUt/s9ie5Zz/l8XtFotFPKw2lGOAAAAAAAAMKBMDhkLMtyDGjPnj07U7vnzp1z3H79+vWZ2vVCu+ZuIpFY+JIJ/Y/XpCUiGo3GQNhvWZaq1aqy2azi8bg2NjaUTqc7C+kBAAAAAAAgHAiDQ8ZpVrAkRaPRmdp1m1lcq9VmandW+XxejUZDhmF4Vh7CL16UiHArAdLNtm1Vq1Wl02lFIhGl0+mBEh8AAAAAAABYPYTBIeMWzs5a7uDkyZOO24MsS9BoNFQsFiVJV69e9bS2rx/6w+qLFy9OdP12yDuparWqaDSqbDa7EGU9AAAAAAAA4A/C4JBxC2dnDUrdwuQgZ5y2y0OkUimlUqnA+jGu/hIRk/Z5nFnBw5TLZZ0+fdp19jgAAAAAAACWG2FwyLiFs7PODB4WJgcRCLdLHxiGoatXr8799ifVv9ieaZoTPyfRaFSJRGKq8hJttm0rmUyqXC5PdX144N/8G+nZZ6Uf+zHpJ39S+pmfkd56K+heAQAAAACAFbAedAcwP8NKALiVeZiEYRiOt9FoNGYOmydRrVY75RIqlcrCl4eQpFKp1HN6mpnMmUxmYIG89oJytVptohm/2WxWJ0+eXIoZ1SvnzTelu3d7tx06FExfAAAAAADASmFmcIjc7Q+YuixDYDoO27Z16dIlSa1wNJFIBNyj8fSXiJi0XrCbWCymXC6nWq2mZrOpSqUy9mOSTqcDrfkcWvfv954+fFg6wK4aAAAAAADMjpnBIRJU/d5hIbTX0um0bNuWaZoDs20XVX+JCMMwFIvFfLmtdv1ky7KUz+dHLjh3/vx5vfLKKwv9Y8H3vvc9vfnmmxNd59ChQzp48KDjeffv31ez2ZQkbW1t6c0339TDhw97LuN2ewcPHtQhl1m8Dx480JMnT0b27cDduzradbp59Kgevv22Dh8+7Hj5t956S/v7+yPbdbK2tqYjR47Mtd23335bjx8/nqrdAwcO6OjRo47nPXz4UI8ePZqq3UgkomPHjjme9+jRo4HnfxLHjx933P748WO9/fbbU7d77NgxRSKRge37+/t6a4ayIkePHtUBhx8fnjx5ogcPHkzd7pEjR7S2tjawvdls6n7/DyATOHz4sNbXnT/KTLpf6DbuPmJSXuwjnKyvr7OP0OLtI8YZP9hHtLCPaGEfMbrdVdpHjIN9REvY9hFu4wf7iNHtso9oYR/R4sU+Ym9vz/G8WfcRb7zxxtTX9wJhcIgMKxPhhZMnTzreht+321YulzulECqVylxu0wvXrl3rOd1f6sEPpmmqUqnIsiwlk0nXHwps29aVK1dUKBR879O0zp4961vbv/d7v6eHDx/qq1/96sB5Th/EPvjBD+qDH/ygY1uf+9zndOfOnZG3Gd3Z0f+v6/SPHj/W/1mv69d+7dccL/+FL3xBr7766sh2nZw5c0YXLlxwPO+LX/yibt26NVW7L7zwgj760Y86nlev1/Xyyy9P1e7W1pY+/vGPO5731a9+VV/5ylemavfYsWPK5XKO533961/Xl770panalaRPfOITjtu/853vzLSfeumllxw//L322mv6/Oc/P3W7H/vYx3Tq1KmB7bu7u/rMZz4zdbsf/ehH9cILLwxsv3//vj71qU9N3W46ndaLL77oeN4s7f7qr/6qfvZnf9bxvE9/+tNTf6j0Yh/h5Ny5c+wjtHj7iHHGD/YRLewjWthHtIRlHzEO9hEtYdtHuI0fH/rQh9hHiH1EN/YRLX7uI973vvdNff1FxrHHITLPGbrdXn/9dd9vw7IsZbNZSVKhUPBtZq0f+hdr86pExDhM09TOzs7QALpYLM4t0Id0sO8X50cuswoAAAAAAAAmRRgcIl4sEjdMkKUE0um0pKc1cpfFPEtEDFMqlYY+bv2BNfyzThgMAAAAAAB8QhgcIn6HtW6zR5999llfbzefz3cWOlum8hDSYIkIt8No5qFQKLguLler1ebcm/A62Ffj6rFLHTMAAAAAAIBJRZrTrnCApdNoNBSPxx3P8+JlEI1GHWvPlkol3+rgdt+naW4nm80OzHrN5XJzq5Hb/5jVajXXQHYebNvW6dOnHYP9RdhV3LlzZ6DG0M2bNyf+wWGSBeScis67FdT3YlGH9c9+Vof/2/+2c3r/3/139bheZ1EHsahDNxZ1aFnUhV/csPDL6HZXaR8xzvjBPqKFfUQL+4jR7a7SPmIc7CNawraPcBs/Dh06xD5iRLvsI1rYR7Qs+gJyZ86c6dl++/ZtbW1tTd3uJJhyFiJ+zwx2q0lsmqZvt3n+/HlJUiKRmMvCa15qNBo9QbBhGIEGwe0+XL58Wfl8fuA8y7J8fS6n9eM//uO+7zDf8Y53zNyG2weLAX0f4tbe8Q6tuXw4k+T6QWhWfrV7+PBh1w+bsxj24XgWBw8edP0wP4v19XXXLx+zWFtbc/1QOIsDBw740m4kEvGlXcn9w/Gs3D7Mz2rsfcSE2Ee0BLWPmHb8YB/Rwj7iKfYRLau2j5gW+4iWVd5HTDp+sI9oYR/Rwj6ixYt9hFvWMGsG4cfzPgnKRITIsJrBfi4Q5let4nQ6Ldu2ZRjG0pWHkAZLRAQdBLe5heosIjcn/b+I+vTBDgAAAAAAhA9hcIgEVTPYj9utVquqVquSpKtXrwa6eN202v1vu3jxYkA96eW2iJ3bzG94rP8wFp9mGAEAAAAAgPChTETIxGKxzmJr3SzLcgwAxzVs1qjXpQVs29alS5ckte6PaZqO92kcTjWOLctybc80TU+CZ8uyBm47lUrN3K5XEonE1I8pZsTMYAAAAAAA4BPC4JBxC/lmnfXpdv1ZAmY3lmV1wudhi+JNq3vWcT+vFngrlUo9pxcpCJZaC9v186vcB/oQBgMAAAAAAJ8QBofMuXPnHLc7zZCdhNv1F6UO7qJZ1BIRbU7B7zKW4vDC/v6+XnvttZ5tzz//vONqpZ6gTAQArIS5jx8AgJXA+AHAb4TBIeMWzu7s7MzUrluZiGQyOVO7q2jRS0S48brcx7J466239PnPf75n20svveTbCsP6yEekaLQ1Q/j+fekXf9Gf2wEA+Gru4wcAYCUwfgDwG2FwyBiGIcMwBsLbWevDvvzyy47bz549O1O7q6h/VvAizp7uL/vhR7kPuPiP/+PWHwAAAAAAgMcOBN0BzF8mkxnYdvPmzZnadAqTY7GYL6UFYrGYms2mJ3+5XG6g/Vwu53p5P+oFp9Ppmdv0Wv9M8UUMrPGX3nxT+uY3pX/6T6U//uPWv9/8Zms7AAAAAABAF2YGh1A2m1WxWOzZZtu2bNueOrx1CpMXrQ7uInAqEXHhwoWAeuOuP9yn3McC+v73pT/9U+lb35L29wfPX1uT3vte6Rd+QXruufn3DwAAAAAALBxmBoeQaZqOh/3X6/Wp2rMsy7FmsNMM5LDrLxHh1+zpWXW/FkzTZGbwInnyRPon/0S6erU1A9gpCJZa27/5Ten3f1/6oz9qXQ8AAAAAAIQaYXBIZbPZgW3Xrl2bqq3+gFNqBcGLGHIGrf8xdnoeglYul3tOFwqFgHqCAU+eSNevS3/2Z+Nfp9mUvva11vUIhAEAAAAACDXC4JByCmudQt1x9NfAlaR8Pj9RG/l8XhsbG4pEIkomkwOlFFaBZVkD5RcWsUREd/gbi8WUSqUC7A16fPnL0re/Pbh9f1/a3ZX+v/+v9a/TbOFvf7t1fQAAAAAAEFqEwSF2+fLlgW39s0JHaTQaA8FtLpeTaZpjt9GuYdwuNVGv1xWPxx1LTywzP0tE1Ot15fN55fP5qct9SFKxWOw8n4Zh6MaNG570DxP4wAekF1+Uzp2T/r1/r1XqQWrVCP7a13ovu78v7ey0agd/85utwPeb32yd3tkZDIX/7M9a7QAAAAAAgFAiDA6xXC43UDt40hm9ly5d6jltmuZEZQVs23YMoG3b1pUrVybqy6LrLxHh1QJ7xWJRyWRSxWKx8/9oNDrxTO92oNx248YNSn0E4dat1t/Nm9I/+2fS22+3tv/pn/Zebn9f+vM/l157TXr8uPe8x49b2//8z3tLQ7RLRgAAAAAAgFAiDA65SqXSE/jZtj12IFwulwfKHtRqtYluf1g5iFUqFWHb9sBj5VX5BacyHZZlKZ1OK5lMjjXDul6vK5lMSmoF+js7O46LDMJn+/vSw4e9244eld58U/rWt3q3v/qq9MYbw9t74w3plVd6t9261WoPAAAAAACEDmFwyJmmqe3t7Z5AuFgsjiwXUa/XBxY/q9VqE5WHaN/+NOctm/7H0zRNz+7fsNm79Xpdp0+fdn0+bdtWNpvtBMGJRELb29sr9dgvlbfeGtx29Ggr0O0u+bC/L/3gB4OXPeCwS//BDwav2x8QAwAAAACAUCAMRicQ7p4Jms1mlU6nB2bn9oeH7evv7OwokUhMfNuGYSiTyThud6ppvKz6S0R4uSjbqMep/ZxtbGwonU6rWCwqm80qHo9rY2ND5XJZpmmqVCqpVqtRGiJI9+8Pbjt2TLpzp3fb3t5gaYj3va9VY/h97+vd/vhx6/Ld+tsDAAAAAAChsB50B7AY2oFwuVxWPp+XbduqVquqVqsyDEOmacq2bcfF4iapEeykVCopGo2qVCrp7t27Onv2rEql0sqEkk4lIryqFyy1guVKpaJLly4NLQnR/Zy2xWIxZbNZx0AeAXjwYHDb0aODpSP6g+ADB6TNzdb/Nzdbp7trBfdfvr89AAAAAAAQCoTB6JHJZJTJZFSv11WpVHTz5k1ZlqVGo9EJhWOxmC5evKhEIuFZYJvL5ZTL5TxpaxKFQmHmMHuU69ev95w2DMPzerypVEqpVKrneesO7w3D0MmTJzvlKZLJpKfPHzziFgYfOtS7bb1v1/3kibS72wqCd3d7g2Cny/e3BwAAAAAAQoEwGI4SicRUZR8wqB2wzwPP25LrD4PX16WDB6Wtrd7tGxut87pn/H7zm4MzgtttbGz0butvDwAAAAAAhAJhMICltru7O/Zlt6YIQY8ePaqPfexjA9t80V8zuH07p09La2tPF4JbW5Pe/W7ptdd6L98fBEuty62tPT29ttZqDwDgq7mOHwCAlcH4ASy3O2Os0TNJjuEHwmAAS+3MmTNjX7bZbE7c/oEDB3Tq1KmJrzeV/pnB7Q99x49L731va/Zv2wsvSPfuSW+84d7eM88MBr9nzrTaAwD4aq7jBwBgZTB+AMttGd6/B4LuAADgL/WHwceOPf3/L/yCFIk8Pb22Jv21vyY9//xgTeD19db2n/mZVumItkhE+vmf977fAAAAAABgKTAzGAAWhdvMYEl67jnp535O+trXnm5bW5Oi0dYs4b29Vg3hdo3g7tIQbT/3c612AAAAAABAKBEGA8CicKsZ3PahD0m2LX37273b19akzc3hbf/0T7euDwAAAAAAQoswGMBSu3XrljZHBaHLYliZCKlV8uHCBenLX+6dITxMJNKaEfyhD/WWjAAAAAAAAJ66ffv2yMvs7u5OtP6R1wiDASy1zc1NbW1t+db+kydPBlb63Nzc1AE/gtVhZSLaDhyQPvxh6a/+1VYgfOuWtL8/eLm1tdZicT//85SGAIAAzHX8AACsDMYPYLn5mU94hTAYAIZ48OCBPvOZz/Rse+mll3T8+HHvb+z975f+q/+qFQrfvy+9733ul33uOekjH2kFw6+8It25Iz18KB06JG1tSadPS370EQAwlrmOHwCAlcH4AcBvhMEAsCh+6Zdaf5M4fnx4aAwAAAAAAPCXOM4AAAAAAAAAAEKAMBgAAAAAAAAAQoAwGAAAAAAAAABCgDAYAAAAAAAAAEKAMBgAAAAAAAAAQmA96A4AAP7Sb/+29C//pXT0aOvvt39b+g/+g6B7BQAAAAAAVgRhMAAsiv/7/5b+9E+fnv4bfyO4vgAAAAAAgJVDmQgAWBQPHvSePno0mH4AAAAAAICVRBgMAIvi/v3e08eOBdMPAAAAAACwkgiDAWBRMDMYAAAAAAD4iDAYABYFYTAAAAAAAPARYTAALArKRAAAAAAAAB8RBgPAImg2mRkMAAAAAAB8tR50BwBgkR05ckQf/ehHB7Z57uHDViDcjTAYAJbW3MYPAMBKYfwA4DfCYAAYYm1tTS+88IL/N9RfIkKiTAQALLG5jR8AgJXC+AHAb5SJAIBF0F8iQmJmMAAAAAAA8BRhMAAsAqeZwYTBAAAAAADAQ4TBALAInGYGUxsMAAAAAAB4iJrBAJba7u7u2Jfd2trysScz6g+Djx6VIpFg+gIAAAAAACZ2586dkZeZJMfwA2EwgKV25syZsS/bbDYnbr/ZbOp+XwmHY8eOKeJ1UNtfJoISEQCw1OY2fgAAVgrjB7DcTp06FXQXRiIMBoAh7t+/r0996lM921566SUdP37c2xva2pL+s/+sFQo/eCB53T4AYK7mNn4AAFYK4wcAvxEGA8AiePFF6fOfD7oXAAAAAABghbGAHAAAAAAAAACEADODASy1W7duaXNzM+huAAAAAACAkLt9+/bIy+zu7k60/pHXCIMBLLXNzU1tbW0F3Q0AAAAAABByy5BPUCYCAAAAAAAAAEKAMBgAAAAAAAAAQoAyEQCwCMpl6X/736SjR6Vjx6Rf+iXpP//Pg+4VAAAAAABYIYTBALAI/uW/lL70paenjx4lDAYAAAAAAJ6iTAQALIL793tPHzsWTD8AAAAAAMDKIgwGgEXw4EHv6aNHg+kHAAAAAABYWYTBALAICIMBAAAAAIDPCIMBYBFQJgIAAAAAAPiMMBgAFgEzgwEAAAAAgM8IgwFgEfTPDCYMBgAAAAAAHlsPugMAsMgOHz6sdDo9sM1z/TODKRMBAEttbuMHAGClMH4A8BthMAAMsb6+rhdffNH/G6JMBACslLmNHwCAlcL4AcBvlIkAgEVAmQgAAAAAAOAzwmAAWASUiQAAAAAAAD4jDAaARUCZCAAAAAAA4DPCYAAI2uPH0qNHvduYGQwAAAAAADxGGAwAQeufFSwxMxgAAAAAAHhuPegOAMAie/PNN/WpT32qZ9tLL72k48ePe3cjzab0H/6HrVD4/v3Wv+94h3ftAwDmbi7jBwBg5TB+APAbYTAABO3ECekf/+OgewEAAAAAAFYcZSIAAAAAAAAAIASYGQxgqe3u7o592a2tLR97AgAAAAAAwuzOnTsjLzNJjuEHwmAAS+3MmTNjX7bZbPrYEwAAAAAAEGanTp0KugsjUSYCAAAAAAAAAEKAMBgAAAAAAAAAQoAyEQAQtH/xL6TPfEY6elQ6dkw6fVr6r//roHsFAAAAAABWDGEwgKV269YtbW5uBt2N2fw//4/0v/6vT0+fPUsYDAAAAADAkrl9+/bIy+zu7k60/pHXCIMBLLXNzU1tbW0F3Y3ZPHjQe/ro0WD6AQAAAAAAprYM+QQ1gwEgaITBAAAAAABgDgiDASBo9+/3nj52LJh+AAAAAACAlUYYDABBY2YwAAAAAACYA8JgAAha/8xgwmAAAAAAAOADwmAACFr/zGDKRAAAAAAAAB+sB90BAFhkhw4d0q/+6q8ObPMUZSIAYOXMZfwAAKwcxg8AfiMMBoAhDh48qJ/92Z/190YoEwEAK2cu4wcAYOUwfgDwG2EwAASNMhEAAGDBNZtNPX78WPv7+2o2m0F3BwCAjkgkorW1Na2vrysSiQTdnYVHGAwAQaNMBAAAWCDNZlNvvfWW7t27p3v37unNN9/U/v5+0N0CAGCktbU1HT9+XCdOnNAzzzyjw4cPExD3IQwGgKD1l4lgZjAAAAjA48eP9YMf/EC2bevhw4dBdwcAgInt7+93fsz8t//23+rQoUMyDEPvfve7tb5ODCoRBgNA8JgZDAAAAtRsNrW7u6vvf//7zAAGAKyUhw8f6vbt23r99df13HPPaXNzM/QzhQmDASBohMEAACAg+/v72tnZ0Q9/+MOguwIAgG/29/f1ve99T3t7e4pGo1pbWwu6S4EhDAaAIe7fv69Pf/rTPdv+5t/8mzrmZSmH979f2thohcL377f+DwBYanMZP4AZ7e/v67vf/a5+9KMfBd0VAADm4oc//KG++93v6id+4idCGwgTBgPAEM1mU/f7avp6voL29evetgcACNxcxg9gBs1mUzs7OwTBAIDQ+dGPfqSdnR295z3vCWXJiANBdwAAAAAAMF+7u7uUhgAAhNYPf/hD7e7uBt2NQBAGAwAAAECIPH78WN///veD7gYAAIH6/ve/r8ePHwfdjbmjTAQAAAAAhMgPfvAD7e/vj3XZtbU1nThxQidOnNDBgwe1vr6uAweYUwQAWBxPnjzR48eP9ejRI927d0/37t0ba5zb39/XD37wAz3//PNz6OXiIAwGAAAAgJBoNpuybXvk5Q4ePKjnn39ehmGEsp4iAGA5bW5udsa61157TY8ePRp6edu29WM/9mOhGuv4SRcAAAAAQuKtt97Sw4cPh17m4MGD+qmf+iltbGyE6ssxAGA1RCIRbWxs6Kd+6qd08ODBoZd9+PCh3n777Tn1bDEwMxgAgvQXfyH99/+9dOyYdPRo6y+Xk9bWgu4ZAABYQffu3Rt5meeff16HDx+eQ28AAPDP4cOH9fzzz8uyrKGXe+ONN3TkyJE59Sp4hMEAltokq39ubW352JMp/cVfSJ/5zNPTkYj0O78TXH8AAMBKGxUGr62tyTCM+XQGAACfGYahtbW1oTWE7927p3e9612e3N6dO3dGXmaSHMMPhMEAltqZM2fGvmyz2fSxJ1N68KD39NGjrUAYAADAB2+++ebQ80+cOEFpCADAyohEIjpx4oT29vZcLzNqbJzEqVOnPGvLL9QMBoAg3b/fe/rYsWD6AQAAVl6z2Ry5uvqJEyfm1BsAAOZj1Ni2v7+/mJPHfEIYDABBcpoZDAAA4IPHjx+PvMyohXYAAFg244xto34sXSWEwQAQpP6ZwYTBAADAJ+N80V1fp5IgAGC1jDO2jfOD6apgpAew1G7duqXNzc2guzG9/pnBlIkAAAA+GecQ2AMHmC8EAFgt44xtXpWJuH379sjL7O7uTrT+kdcIg4ElUCwWlcvlgu7GQtrc3NTW1lbQ3ZgeZSIAAAAAAFgJy5BPEAbDUb1eV6VS0c2bN2VZlmzblmEYMk1Tpmnq4sWLSqVSQXfTM8lkUvV6XZKUy+VUKBQC7lFLo9HQlStXZNv2zGFw2J5Trxw8eFAf/OAHB7Z5hjIRALCSfB8/AAAAgCkQBqNHuVxWPp+XbdudbYZhKBaLybIsNRoNNRoNVatVGYahy5cvL/2M1XK53AmC/dAdNE+rVqtNfd0wPqdeOnTo0MCXeU9RJgIAVpLv4wcAAAAwBQpCQZJk27aSyaSy2WwnNEwkEtre3tbe3l7n3729PWUymc518vm8kslkT9C4TCzLUjab9bX9WYNg0zSVSCQmvl5Yn9OlQ5kIAAAAAAAwJ4TBkGVZOn36dE9omcvlVKvVFIvFei5rGIZKpZIqlUpnW71e1+nTp2VZ1tz67JV0Ou1r+16Um5gmrA7zc7p0+stEMDMYAAAAAAD4hDA45NqzR7tngaZSqZEhZiqV6iklYNu24vH4Us0mzefzajQavrVv27bK5fLM7bRn7U5yu2F9TpcSM4MBAAAAAMCcEAaHXDqdHpj9efXq1bGuWygUZJpm57Rt277PtPVKo9FQsVj09TauXLkycxuZTEaGYUx0nbA+p0uLMBgAAAAAAMwJC8iFmNPCablcbqLwsVAo9ISF9XpdxWJx4Rcgm0fA2Z4VbJpmTwmGSfSXdBjnNsP6nC4tykQAAAAAAIA5IQwOsXw+P7Dt8uXLE7WRSqVkGEZPKYF8Pj/VjNZ5ac+cNU1TsVhM1WrV89soFoudxySfz08c6k4rrM+pnx48eKDPfe5zPdt+8zd/U0e9msH77/w70k/+ZGuG8P370jPPeNMuACBQvo8fAAAAwBQoExFS1Wp1oBZsIpGYKuy7cOHCwDYvSiT4oVqtdsLfSqWikydP+nI77ftvGMbENX+nFdbn1G9PnjzRnTt3ev6ePHni3Q38T/+T9J3vSN/7nrS7K730kndtAwAC4/v4AQAAAEyBMDiknIK9aUsnOF2ve2bsorBtW5cuXZLUKp3g12zd7lB21KJtXgrjcwoAAAAAAIDxEQaHUKPRUKPRGNieSCSmas/teu2auYsinU7Ltm3FYjFfQ9ogZgWH9TkFAAAAAADA+AiDQ8jtcH/TNKdu0+m6165dm7o9r3UvrDbtYm7jqNfrnVB20lq9swjjcwoAAAAAAIDJEAaHUDsU7TZryQSn6zcajYUoK2BZlrLZrCSpVCrNFJCO0j3jOJ/PKxqNKp1Oq1wuO87c9UrYnlMAAAAAAABMjjA4ZCzLcgzzzp49O1O7586dc9x+/fr1mdr1Qrv+bSKR8LVsQ6PRGAhlLctStVpVNptVPB7XxsaG0ul0ZxE7L4TxOQUAAAAAAN5qNBqKx+OKRCKKx+OOE8+w/AiDQ8btjRyNRmdq120Waq1Wm6ndWeXzeTUaDRmG4Wt5CMm9VEM327ZVrVaVTqcViUSUTqdlWdZMtxu253Tl/K2/Jf3tvy39vb8nfeYz0u3bQfcIAAAAwJSi0agikYhnfxsbG4pGo4pGo0omk8rn874feQpvNRoNT18Ts/4N62c8Hu+8thqNhpLJJIHwCloPugOYL7cgb9bSCSdPnnTcHuQA1Wg0VCwWJUlXr16VYRi+3VY75J1UtVpVtVpVJpNRoVCYqo9hek5X0v/wP0j7+09P/8IvSKdOBdcfAAAAAFMrlUqyLEs7OzudI0VnYdt250hQy7J6gjnDMHThwgVls9mZywTCP7FYTJVKRZZl6eWXX/b0SGEvuU1wy+fz2t7ennNv4CfC4JBxC/JmDUrdgsdZZ73Ool0eIpVKKZVK+Xpb48wKHqZcLuv69euqVCpKJBITXTdMz+nKefSoNwiWpGPHgukLAAAAgJn1f5+zbVvpdHrk7MpMJtNzdOfrr78u27Z19+5dNRoNx+9htm2rXC6rXC4rkUioUCgQCi+o/kxinBm3qVRqokle7deLbdu6efOm63o/tm075gVu3/XJAFYPYXDIuL2JZ51FOix4tCzL10XbnLTLLxiGoatXr/p+e9FoVIlEQnfv3nWt4TuKbdtKJpMqlUoT1TYOy3O6kh48GNx29Oj8+wEAAADAF4ZhqFarDT08f9zvgNVqVaVSyTFErNfrisfjKhQKyuVyM/UZ/qtUKtrY2HA934vn0bIsFQoFlcvlsS5/9uxZx8lms65HhMVDzeAQGRZQupUEmIRbeDjvsgLt0gtSawfrZ3mItkwmo1qtpu3tbe3t7anZbGp7e1uFQmHimb7ZbHbsw0bC8pyurPv3B7cRBgMAAAArZ9j3wnEn2qRSKdVqNdVqNdfvavl8XtlsdpouYo4Mwxh6BLMXk69M01SpVBp7/SS30pWlUmnmvmCxEAaHyN27d13Pm0dgOg+2bevSpUuSWgHtpEGsl2KxmHK5nGq1mprN5kQlINLp9FiBaxie05XmNDOYMhEAAADAyvHyyMpEIqFXXnnFtc1yubywdWkXSdCTnOZ1tG1/6Uy3HMEwDL3yyiudLCWTyWhnZ2fmfgb9OGMQZSJCJKg6L8MCS6+l02nZtt35BWyRtHfAlmUpn8+PHJzPnz+vV155ZWS5hiDM8zkd5Xvf+57efPPNia5z6NAhHTx40PG8+/fvq9lsSpK2trb05ptv6uHDhz2Xcbu9gwcP6tChQ47nPXjwQE+ePOnZFnn9dfVHv28+eSL1tb++vq7Dhw87tvvWW29pv7/u8JjW1tZ05MiRubb79ttv6/Hjx1O1e+DAAR11mTn98OFDPXr0aKp2I5GIjrmE8I8ePRp4/idx/Phxx+2PHz/W22+/PXW7x44dczzUcH9/X2+99dbU7R49elQHDgz+TvzkyRM9cPrxYkxHjhzR2trawPZms6n7TjPkx3T48GGtrzt/lJl0v9Bt3H3EpCbdR4yLfUTLou0jxhk/2Ee0sI9oCWIfAWB+vJ6s0y4/0V1nuFs6nZ56fxQGtm3r/PnzunHjRmB1lp999tm53dbly5fH+oHAMAxPs5RFeJzH1T/WHj58WHt7e46XnfVzxBtvvDH19b1AGBwi09SxncTJkycdb8Pv220rl8ud2knjHgYRBNM0OyuJJpNJ10DXtm1duXJFhULBta1Vf07H4Wf9ot/7vd/Tw4cP9dWvfnXgPKcvax/84Af1wQ9+0LGtz33uc7pz507Ptr/y//6/6q4M9nhtTZ/6e39v4Lrnzp3Tr/3arzm2+4UvfEGvvvqq630Y5syZM7pw4YLjeV/84hd169atqdp94YUX9NGPftTxvHq9rpdffnmqdre2tvTxj3/c8byvfvWr+spXvjJVu8eOHXOtx/X1r39dX/rSl6ZqV5I+8YlPOG7/zne+M9N+6qWXXnIMkV577TV9/vOfn7rdj33sYzp16tTA9t3dXX3mM5+Zut2PfvSjeuGFFwa2379/X5/61KembjedTuvFF190PG+Wdn/1V39VP/uzP+t43qc//empw6lJ9xHjYh/Rsmj7iHHGD/YRLewjWoLYRwBYbqZpKpfLqVgsOp5fLpcnWo8mTNoTycIiFovJMIy53+dlepw/97nP6Uc/+lHndDqd1vve974Ae+QfykSESFCzOV9//XXfb8OyrE5dpGVZQdU0Te3s7AwdnIvF4tAd5yo/p4viwIED+it/5a/0/DnNiprGet8stUcus4wAAMvHz/EDAIC2YfWBF3mSVJCKxaLjInzzNu/Sju2ylfMKZxflccYgZgaHiBcLig0TZI3adDot6Wmd3mVSKpVkGMbQX3Pd7tMqP6eLYn19XT/5kz/pS9sH+w6FfuxyKCsAYPn4OX4AANBmmqbrjM+bN2/Ov0MLrtFoKJ/PB92NQFy+fFnJZHIutYrD/DgvA6YnhIjfwZ7br0t+18HJ5/OdguTL+stnoVBwXVyuVqu5Xm9Vn9OwOMjMYAAAAAAzcgv3luXw/Hlp168Nq1gspkwmM5ccIcyP8zKINKkoHhqNRkPxeNzxPC9eBtFo1LH+balU8q1OUfd9muZ2stmsyuVyz7ZcLje0Tq9fbNvW6dOnHQdst+dnFZ/TYe7cuTNQq/DmzZsTh9OTLCA3iUkXflm7fl1HfvM3O6efnDmjB//X/zVwXRaHalm0xaHGweJQLSwO1cICcqPbZR/Rwj6ihX3EU17tIx48eDCy3veZM2dc30sAppfP512PBq3Vaq6Tg8aRTCZdD8ff29vjiM+/FI/HOxPJ2ra3twMrM1kul13LfFQqFaVSqTn3yBuL9jhL441/p0+f7vlM7fcCcmfOnOnZfvv27YkziGlxTHKI+D0AuNWv9fMQhPavTYlEYukL4xuGocuXLzseSmFZluPjuIrP6aR+/Md/fG47zFk4fqnq+7J44Phx12DAjVugMiu/2j18+LAvK5ofOnTI9Qv0LA4ePOj6hX8W6+vrrgHFLNbW1iZ+DY3jwIEDvrQbiUR8aVdyD9lm5RYKzsqv4IV9RAv7iBb2EU+xjwCwSoatJUMQ3JJMJgcCSnhvmR/no0ePDoy3blnDrBmEH58fJ0GZiBAZVl/Wz8NH/Kpr216V0jCMpS0P0c8t0HZ7flbtOQ2d/tlOPn2BBAAAALC6nI7mlLydxFOtVpXNZhWNRrWxsaFIJKKNjQ3F43Fls1nPFgprNBqutzNqgXU3w2ZOr7J4PK5kMjn19S3LUjabdT0auV9YH+dlRBgcIkHVl/XjdqvVqqrVqiTp6tWrK/Nrp2EYjodOuP3Su0rPaSj1H1LLrB8AAAAAE7Asy/V726xlBmzbVj6f18bGhtLptMrlcs/t2batRqOhcrmsZDKpaDQ6dRhoWZbi8bji8XinlGMikVAul1MikXDsSzqd7iwm76TRaIzsUzweVyQSGfjb2NiY6n4skkajMXTWuJtyuax4PK5oNKpyuTwygA/747yMKBMRMrFYzHHKvmVZM9VvGbZz8LqkgG3bunTpkqTW/TFNc+rDEJx+QbUsy7W99kqtfkokEhPdn1V4ThfZW2+9pS984Qs9237jN37Dm0OkDx+W3vWu1gzhBw8IgwFghfg6fgAA8JeGrXfjVo92HPV6vXM0rtT63nn27FnF43Ht7OzIsizV6/We742WZSmZTCqVSk109G7/Wjhua9RYlqV0Ot0zOWxY4D3ujNZVNGko32g0VCqVBtZUGkeYH+dlRRgcMm5B4zS/Fo1zfT8KhHf/EjlsAbVpdQ8s/WYt7D+OaDQ6sG1YWYZVeE4X2f7+vl599dWBbZ74L//L1l/blAvDAAAWj6/jBwAAagV+buFdKpWaehJPsVjsrGUTi8VUqVRc23JalL1arSqdTo8VCFuW1VkLSBq+WLlpmtre3u5ZoGzYJKbuxb/K5bLj+jyVSsX37/hBGOext21b5XJZpVLJtdTIOML8OC8rwuCQOXfunOP2Wd74w67Pm31yTsHvsNnIPKcrxGGFdgAAAADoV6/XXevBtgPcaVSr1U6Yl0gkVKvVhl6+VCrp7t27AxOqqtWqisWicrnc0Ovn8/lOoGua5lgLw1cqFcdJVP26v0e7hdnzOPp33tqlO0a5dOmS6vW6TNOUaZpTZwhhfZyXGWFwyLgFeTs7OzO16/Zr3CzFyvHUsF90eU4BAACw8O7cmf6673iHezmt3V2p2Zyu3WPHpOPHnc+7e1eadjb/kSPSO9/pfJ5tS48eTdfuoUPSM884n/fGG9LDh9O1e/Cg5BbS/PCH0ltvTdfu2prkdoTjm2+2SqVtbU3XdohZlqVCoeAa9mUyGZVKpanabjQaPTV4xw2Ur1696nh0bT6fHzpD2bbtnuuNO/GoHRqXy+WZj4hdNW4zc530P7/lcnmm0iJYHoTBIWMYhgzDGAj6pq252/byyy87bj979uxM7YZR/2A2qiwDzykAAAAW3qlT01/305+WPv5x5/Pe+95WIDyN3/s96ROfcD7vr/916dat6dr92Mekv//3nc/7j/4j6f/4P6ZrN5WS3MK53/otyaXU3Uj//r8vfeUrzuf9zu9In/nMdO2eOSP9q3/lfN6nPiX9rb81fZC/Yty+u7W/4929e1fb29uq1+uuszdjsZiuXr06U1m/7iC4UCiMPZPTMAwlEgnHOrWFQsE1nL5+/fpAO+PK5/NT1bddFleuXBk71L97965s25756OBMJtMzUxurizA4hDKZjIrFYs+2mzdvztSm0+AVi8V8OQwgFoup6dGHhnw+P/BY5HK5oUX4/dY/o3ecX0eX/TkFAAAAgLAadyZnv1gsposXL85UH7itWq32hInDFmZzkk6nHcPgdk1aJ/3ffSeZ0GSapmKx2MoGl7NO7pqWaZqB3TbmhwKVIeQ07d+27Zl2ok7B48WLF6duL8z6d7zjlGXgOQUAAACAcGk0GqrVaqrX6zOHot2BdLuG7CSGTWIaNfO5bdjMZyd8P/XesMXrsToIg0Oo/QtaP6df8cZhWZbjwDNO4XcM6n4eTNMca2Ywz+mS+sIXWoc9/sEfSP/gH0gzHtYDAAAAYPnkcjlVKhVVKhWVSiWVSiUVCgXlcjllMpmhR2jW63Vls1ltbGwomUxONauz0Wj0hLDTlJoYFh67fS91WgSuu1TFKKu8uHmlUlGz2Rz7b2dnR5VKZaUfE3iHMhEhlc1mB2aTXrt2beJDQSQ5ForPZDKUE5hCf82jScpV8Jwuof/xf5S6azP/wR9IMx7eBQAAsJBu357+uu94h/t53/rWbAvIufln/2y2BeTc/ON/PNsCcm5+//enr+178KD7eZ/8pHtd5VHW1tzPe+kl9zrQIZRMJscK8SzLUrVaValUcpxBW6/XFY/HlUqldPXq1bG/v/WHtdVqVZFIZKzrjsNtcXOn0LnRaCgajapWq42cnRyLxWZeOH1VtGdzp1IpFYvFqUuPIBwIg0PKqTC4UwA4Dqf6P5PueNrF323bViKRUKlUmrnm0TLqDn9jsdhEQe6iPacYw4MHvafdVskGAABYdltb/rS7uelPu34dKu3X5IpnnvGn3Xe+s/XntePHW3+YiGmayuVyyuVyKhaLunLliuMRndVqtVNCYpzv1deuXfOht0+5rWfjtji5ZVmKRqOBr+ezrHK5nK5du0btX7iiTESIXb58eWDbpKtx9h9OIrV2PJMEudlsVsVisTOItX/NXJZC8PV6Xfl8Xvl8fuqyDJJULBY7j6VhGLpx48bEbSzKc4oxEQYDAAAAmEIul9Mrr7ziOvvXsiwlk8mxvlf3h4a5XE57e3ue/bl9tzUMQ7lczrVfxWJR0Wh0pu/ZYeW0rhDQRhgcYrlcbuCwjElnf166dKnntGmaE/1yZ9u2Y1hp27auXLkyUV+CUCwWlUwmVSwWO/+PRqMTz8htB8ptN27cmKokwyI8p5jA/fu9p4cdqggAAAAAXQzD0Pb29tBAeFQNXrew2DAMT//cFAqFoTWK26F2Op1emglji+DChQtBdwELjDA45CqVSs+O2bbtscPDcrk88AtirVab6PaHrRQ6ySqiQXEqp9AecMf9FbZeryuZTEpqBa87OztTFexvC/o5xQSYGQwAAABgBqMm79Tr9aEza+/evetHtyZy48aNkUeiVqtVbWxsqFgszqlXy21UCI9wIwwOOdM0B35JLBaLI0sLtFcs7TZuPaL+25/mvEUxbOdar9d1+vRp18fStm1ls9lOEJxIJLS9vT3z/Q76OcUE+sNgZgYDAAAAmNCoxb6dJjG1OU3CmvfErPYM53EmReXzeUWj0aWYPBa0q1evOpaSBAiD0QkPu3e82WxW6XR6YAfbH2C2r7+zszPW6qf9DMNQJpNx3L4MO61RfWw/XhsbG0qn0yoWi8pms4rH49rY2FC5XJZpmiqVSqrVap79chfkc4ox7e9Lb7/du42ZwQAAAACmMKwswLAyhk5HswYRtLYD4WE1hNvaC8xNuj5O2KRSqYkWpUd4EAZD0tPwsFQqdQLJarWqaDSqjY0NxePxzv+7d7i5XE47OzszzR4tlUoqFAoyTVOGYXRmyC7DIQ2pVGqgLIMT27ZVrVaVz+c7pRhisZhKpZJ2dnYcA/FZBfmcrpK1tTWdOXOm529tbW32ht96a3AbYTAArAzfxg8AABxEo9Gh57sFvE7fZftLB85ToVAY+4jZbDY78Ro5AKT1oDuAxZLJZJTJZFSv11WpVHTz5k1ZlqVGoyHDMGSapmKxmC5evKhEIuFZYJvL5cb6BdBrhUJh5sXR2r+2dT9mtm13BlvDMHTy5EmZpinTNJVMJj197EYJ6jldFUeOHPGn+H5/iQiJMhEAsEJ8Gz8AAHAwKjy1LMvxMidPnnS8fL1eD+xI0Vgspp2dHRWLxZFhb7FY1LPPPhtIngAsK8JgOEokEpQImNCiP2aL3r/QcQqDmRkMAAAAYI7cJgNVKpXAvz/mcjllMpnOEbZu8vn8yLrJAJ6iTASApba7u6s7d+6M9bdQ7t8f3EYYDAAAAGAKd+/eHXq+2wxgtxnF169fn7lPbY1Go2eNmkkYhqFSqTSydMSVK1em7R7gqXGyid3d3UD7yMxgAEvtzJkzY1+22Wz62JMJ9c8MXl+XDh4Mpi8AAAAAltrOzs7Q87sXF3c6r79OsG3bnpWKSKfTjkFuPp+XZVmqVCoj22iXjshms46zhKvV6swlIAEvnDp1KugujMTMYAAIQn8YzKxgAAAAAFOqVquu540KdM+ePeu4PZvNztSndhuWZbnW/p10sbpSqaRUKjWw3W2BvEVm23bQXUBIEQYDQBAIgwEAAAB4oNFoDA1D0+n00Ou7nT8sxB1HtVpVuVxWLBZzDaQty5o4yL169erUfeo3qrwGvMHjvFgoEwEAQ7z11lv64he/2LPt13/913XkyJHZGn70SDp8WHr77dbpY8dmaw8AsFB8Gz8AAOgzLOw1TVOZTGbo9ROJhAzDcJypWiwWde7cOcfZuMPU6/VOv0aFt9VqVblcbuy2DcNQIpFQvV6fqE9OmJ07mhdBLo/zYmFmMIClduvWLd2+fXusv2ns7+/r1q1bPX/7+/uzd/xXfkV66y3p8WPpRz+StrdnbxMAsDB8Gz8AAEvJrzAsnU4PnVlbKpXGamdYYJxOpx3r9Lopl8udBeNSqdTQesWSdO3atbHbbuuvQTyqFIZhGI7bX3755Ylv2yuvv/6663nLOpN2ER/neRsnm7h161agfSQMBrDUNjc3tbW1NdbfQlpbk44fl1xW9wUAAACw/IYFttMExZZlKR6PD60VXCqVxl4ArlAoOC7y1pbNZpVMJofOxq1Wq4pGo51aw6ZpjrU4XKPRmHiWb//jOaoUhltd5GGPX3uBO78Mq5c8akFAvzjd30len4v4OM/bONnE5uZmoH0kDAYAAAAAAPDRsLBz3Nm77XbS6bSi0ejQMLFUKo0sDzFpP+r1upLJpDY2NhSPx5XNZpVOpxWPxxWJRHpmKRuGoVqtNvZtT7pY3c2bNzv/H6cUhmEYjrNWLctynPWcTqdVLBYn6tOkRgXrQXALZccNaxfxccYgagYDAAAAAAD4ZNSs1Xq9ro2NDV24cEGGYejZZ5+V1CojYNu27t69O3KRuLZYLKZKpTJ0lq+bRCKhUqk0Mpi1bVuNRsM1jDYMQ9vb2xP1wbIsJZPJsQLkfD7fM1t1nNnHknThwgXHQDKbzapSqSiZTOr1119XuVyWbdtTP47jGPWasCxL2Wx2oh8KZjWsFEipVFKhUBirnUV6nOGMMBgAAAAAAMAD7dD27t272t7e1vXr18c6zN627Ynq8vbLZDLKZrMj6/OO0440+UzdtkQioUql4lo7dph6va54PK6rV6+63o98Pt+ZSWoYhiqVytj3uVAouD7G9Xq9Z6ZuqVSaeNG8YarV6sSviXK5rOvXr+vChQuKx+M6efJkZ7E/r9i2rZs3b6pSqQx9/RWLxU5Affbs2aF9CPJxxngIgwEAAAAAADwwakG3WRiGoZMnT8owDJmmqXPnzimRSMwcAPfLZDJKJBLKZrNj1/I1TVOFQmGqYM80zc7M0Js3byoej8s0TSUSCUWjUb3++uuyLEv1er0TorZnMU8yo7QdHg+bldu+zLi1lsfRaDRGzgR20/8jQaVS8Sw8jUQiE12+Wq12ylfEYjFtuyyCHtTjjPERBgNAEL72Nelf/2vp6FHp2DHJNKWf/umgewUAAABgBkEt/OU10zRVq9VkWZaq1Wrn/901gduBbTKZnCrUO3funGO42X2b7Vm07SD8woULM82ATqVS2tnZUT6f74TLhmHo7NmzSqfTE9dZHkcsFlOz2fS83Vn52acgHmeMjzAYAILwP//P0mc/+/T0xz4m/f2/H1x/AAAAAKCPaZrK5XLK5XKet+02w9XP22y3P26dYUyPx3lxHQi6AwAQSvfv954+ejSYfgAAAAAAgNAgDAaAIDx40Hv62LFg+gEAAAAAAEKDMBgAgtAfBjMzGAAAAAAA+IyawQAwT2++Kb3yivT97/duX1sLpj8AAAAAACA0CIMBYB6+/33pT/9U+ta3pP196c6d3vP/xb+QqlXpF35Beu65YPoIAAAAAABWGmEwAPjpyRPpj/9Y+rM/693++HHv6QMHpG9+U/pX/0r6uZ+TPvSh1jYAAAAAAACPEAYDwBBra2t64YUXBraN5ckT6fp16dvfHjzv0aPe0wcPtv5tNqWvfU2ybenCBQJhAFhSM40fAAAAgE8IgwFgiCNHjuijH/3odFf+8pedg+D9fentt3u3tcPgtm9/u3X9D394utsGAARqpvEDAAAA8AlTzgDAD9//fmuGb7f9fWlnp1U7uD8Mvn27dX63P/uzwYXmAAAAAAAApkQYDAB++NM/7T29vy/9+Z9Lr73WqhfcH/y+/nrr/CdPnm5rl4wAAAAAAADwAGEwAHjtzTelb32rd9urr0pvvNH6f7PZG/pKrdrAb7whvfJK7/Zbt1rtAQAAAAAAzIgwGAC89sorvTN/9/elH/zg6elmc/A67YXifvCDwev2B8QAAAAAAABTIAwGAK/dudN7em+vVRqirb9EhCS1V5h//Lh1+WHtAQAAAAAATGE96A4AwCJ7++23Va/Xe7YlEgkdPnzY/UoPH/ae7g6C3Rzo+m2u//L97QEAFt5U4wcAAADgM8JgAEttd3d37MtubW1N3P7jx4/18ssv92z74Ac/OPzL/KFDvafX1wdPZ7PSM89It2+36gJ3X6b/8v3tAQAW3lTjBwAAAJbanTGO7J0kx/ADYTCApXbmzJmxL9t0qtXrh/7QeWOjFfC2Z/xGItK3v92aDfzkiXT06NPLrq+3Lj+sPQAAAAAAsHBOnToVdBdGomYwAHjt9OmnNYCl1v/f/e7Byz15Mrjt3e8evO7p0973EQAAAAAAhA5hMAB47fhx6b3v7d32wgutshDDPPPMYPB75kyrPQAAAAAAgBkRBgOAH37hF1rlINrW1qS/9tek5593riH8/PPSz/xM70JykYj08z8/n/4CAAAAAICVR81gAEvt1q1b2tzcDLobg557Tvq5n5O+9rWn29bWpGi0NUt4b69VQ7hdI7i7NETbz/1cqx0AAAAAALDwbt++PfIyu7u7E61/5DXCYABLbXNzU1uLusDahz4k2XZrsbhuP/yh9Prr0sGDrT9J6g+0f/qnW9cHAAAAAABLYWHziS6EwQDglwMHpAsXpC9/uXeG8M6O9L//709PP/ec9Fu/1fp/JNKaEfyhD/WWjAAAAAAAAJgRYTAA+OnAAenDH5b+6l9tBcK3brXKQ3Q7eLBVJuLMmVaNYEpDAAAAAAAAHxAGA8A8PPec9JGPtILhu3elP/qjp+c9/7z03/w30vHjwfUPAAAAAACsPI5BBoB5On5cOnGid9u73kUQDAAAAAAAfEcYDADz9uBB7+mjR4PpBwAAAAAACBXCYACYN8JgAAAQgEgkMvIyT548mUNPAACYn3HGtnHGyFVBGAwA83b/fu/pY8eC6QcAAAiVtbW1kZd53L/QLQAAS26csW19PTzLqoXnngLAFA4cOKCtra2BbTNhZjAArDxfxg9gRuN80X306NEcegIAwPyMM7aN84PpqiAMBoAhjh49qo9//OPeNkoYDAArz5fxA5hRJBLR2tqa9vf3XS9z7949bW5uzrFXAAD46969e0PPX1tbo0wEAMBHlIkAAAABOX78+NDz7927p2azOafeAADgr2azOTIMHjU2rhrCYACYN2YGAwCAgJw4cWLo+fv7+7Jtez6dAQDAZ7ZtDz0iRho9Nq4awmAAmDfCYAAAEJBxvvC+9tprevvtt+fQGwAA/PP222/rtddeG3m5Z555Zg69WRyEwQAwb5SJAAAAATly5IgOHTo09DKPHj3Sd77zHe3t7VEyAgCwdJrNpvb29vSd73xn5OJxhw4d0uHDh+fUs8XAAnIAMG/MDAYAAAGJRCIyDEO3b98eerlHjx7Jsiytra3pxIkTOnHihA4ePKj19XUdOMCcIgDA4njy5IkeP36sR48e6d69e7p3797I0hBthmGEavE4iTAYAIZ6+PChvvrVr/Zs+8Vf/MWRM2qGIgwGgJXny/gBeOTd7363Xn/99bG+KO/v72tvb097e3tz6BkAAPOztramd7/73UF3Y+4IgwFgiEePHukrX/lKz7Zz587N9mX+G99olYq4f78VDL/nPTP1EQCweHwZPwCPrK+v67nnntP3vve9oLsCAEBgnnvuOa2vhy8aDd89BoCgvetdQfcAAACE3Obmpvb29vTDH/4w6K4AADB373znO7W5uRl0NwJBsScAAAAACJlIJKJoNKp3vOMdQXcFAIC5esc73qFoNBq6WsFthMEAAAAAEEJra2v6iZ/4Cb3zne8MuisAAMzFO9/5Tv3ET/yE1tbWgu5KYCgTAQAAAAAhtba2pve85z3a3d3V97///bFXXwcAYJmsra3pueee0+bmZmhnBLcRBgMAAABAiEUiEW1tbWljY0M/+MEPZNu2Hj58GHS3AACY2aFDh2QYht797neHcrE4JzwKAJba7u7u2Jfd2trysScAAADLbX19Xc8//7x+7Md+TG+//bbeeOMN3bt3T2+++SYzhgEAS2FtbU3Hjx/XiRMn9Mwzz+jw4cNznQl8586dkZeZJMfwA2EwgKV25syZsS/bbDZ97AkAAMBqiEQiOnLkiI4cOaJ3vetdklqfo/b39/X48WM+UwE+evDggT73uc/1bPvN3/xNHT16NKAeAYsvEolofX1da2trgZeAOHXqVKC3Pw7CYAAAAADAUO0v2hxiC/jryZMn+tGPftSz7fDhw4TBADxzIOgOAAAAAAAAAAD8RxgMAAAAAAAAACHAMT4AltqtW7e0ubkZdDcAAAAAAEDI3b59e+Rldnd3J1r/yGuRJtX/ASyJO3fuDBRjv337tra2tny7zVdffVWnT5/u2fbKK6/ohRde8O02AQDLj/EDADANxg9g9QWRbXSjTAQAAAAAAAAAhABhMAAMEYlExtoGAEA3xg8AwDQYPwD4jTAYAIY4duzYWNsAAOjG+AEAmAbjBwC/EQYDAAAAAAAAQAgQBgMAAAAAAABACBAGAwAAAAAAAEAIEAYDAAAAAAAAQAgQBgMAAAAAAABACBAGA8AQjx49GmsbAADdGD8AANNg/ADgN8JgABji4cOHY20DAKAb4wcAYBqMHwD8RhgMAAAAAAAAACFAGAwAAAAAAAAAIUAYDABYGnfu3FEkEun5u3PnTtDdCi2ej8XC8wG44/2xWHg+FgvPBzAc75HFwvMxO8JgAAAAAAAAAAgBwmAAAAAAAAAACAHCYAAAAAAAAAAIAcJgAAAAAAAAAAgBwmAAAAAAAAAACAHCYAAAAAAAAAAIAcJgAAAAAAAAAAiB9aA7AACz2N3dHfuyW1tbPvYEAAAAAACE2Z07d0ZeZpIcww+EwQCWxpMnTwa2nTlzZuzr3759e+LbfP311x23HT9+fOK2MDunQTPogTTMeD4WC8/HYmH8WCy8PxYLz8di4flYLIwfi4f3yGJZ9Ofj1KlTU13PKe/wS6TZbDbndmsAMINvfetbE4W/AAAAAAAAi+7WrVt673vfO5fbomYwAAAAAAAAAIQAYTAAAAAAAAAAhABhMAAAAAAAAACEADWDASyNx48f61//63/ds+3kyZM6cIDftQAAAAAAwOJ78uSJ7t6927PtPe95j9bX1+dy+4TBAAAAAAAAABACTKcDAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAf1el3ZbFbxeFwbGxuKRCLa2NhQPB5XOp1WtVoNuosAAA81Gg3l83nF43FFo9HOfj8ajSqZTKpcLsuyLN/7wfgDAKsrmUwqEokoEokon8973j5jCIBxRJrNZjPoTgDAoiiXy8rn87Jtu7PNMAyZpinLsga2X758Wblcbv4dBQB4ov3FedygN5VKqVAoyDRNT/vB+AMAq61cLiubzXZO53I5FQoFz9pmDAEwLmYGA4Ak27aVTCaVzWY7H5YSiYS2t7e1t7fX+Xdvb0+ZTKZznXw+r2Qy2fMBCwCw+Nr7/WQyOdGM32q1qmg0qmKx6Gk/GH8AYHVZltUTBHuFMQTANJgZDCD0LMtSPB7v+TA06pf6arWqdDrdOW0Yhra3tz2fKQYA8J5lWROHwE5SqZQqlcpM/WD8AYDVF4/H1Wg0erbNOjOYMQTAtJgZDCDU2r+md3+Iah8CPEwqleo5tMq27YEPYwCAxdPeX3tR/7darU5d85HxBwDCIZ/PDwTBs2IMATALZgYDCLVkMql6vd6zbW9vT4ZhjHX9aDTaEygkEgnVajUvuwgA8FD/7KxMJqN0Oi3TNHtmRjUaDV27dk3lcnnkl+RaraZEIjFRPxh/AGD1NRoNxeNxx/NmmRnMGAJgFswMBhBa5XJ54ENULpcb+0OUpIEPcPV63bM6kgAAbxWLxU4QHIvFtLOzo1KppEQiMXCIbCwWU6FQ0N7e3sgv65PODmb8AYBw6C7J4BXGEACzYmYwgNDa2NgYmO01yS/qXrcDAPCPbdva2NiQJJmmqe3t7Yn20/V6Xclk0vX8SWYHM/4AwOpLp9OqVqsyTVOxWEzVarXn/GlnBjOGAJgVM4MBhFK1Wh348JNIJKb68HPhwoWBbVeuXJmyZwAAP5TL5c7/a7XaxPv7RCKhUqnkev64C8kx/gDA6qtWq53wt1Kp6OTJk561yxgCYFaEwQBCyemDzrSHcTldr1gsshADACyQdpBbKpWmXjU9k8koFos5nnf9+vWx2mD8AYDVZtu2Ll26JKk1+9dt3JgGYwgALxAGAwidRqPhuKLvpIv/jLpe9yw0AEBwGo2GLMuSaZrKZDIzteV2SO84X54ZfwBg9aXTadm23ak97xXGEABeIQwGEDpuhz9NO1PM7brXrl2buj0AgHfaC+148aV82JfuUYEw4w8ArLbuxd3GLR80LsYQAF4hDAYQOv2r70qa+fAtp+s3Gg0OswKABXDt2jUZhqFUKuVJe26B8KiajYw/ALC6LMtSNpuVNFtJIjeMIQC8QhgMIFQsy3L8cHP27NmZ2j137pzj9nFrSAIA/HP58mVPZ2g5hb6jgmDGHwBYbe0avIlEYuaSRP0YQwB4iTAYQKg4/aIuSdFodKZ23X6Vr9VqM7ULAJhdKpWauqaiE6dV4UfNAGP8AYDVlc/n1Wg0ZBiG5+UhJMYQAN4iDAYQKm4fbGY9jMspGJDkuMgDAGC53b17d2DbqHGE8QcAVlOj0VCxWJQkXb16deSRItNgDAHgJcJgAKHi9sFm1g9tbh/ELMuaqV0AwOJx2rdfvHhx6HUYfwBgNbXLQ6RSKc9q0/djDAHgJcJgAKHi9sFm1l/Vh30Q48MUAKwWpy/lo8pQMP4AwOpJp9OyLEuGYejq1au+3Q5jCAAvEQYDCI1hq+K6HSI1CbcPUxxmBQCrw2mfnslkhn6hZvwBgNVTrVZVrVYlSZVKxZfyEBJjCADvEQYDCA2nGo9tfn14AwCslmvXrg1sy+fzQ6/D+AMAq8W2bV26dElS6wdBLxcp7ccYAsBrhMEAQiOoQ52GfYADACyX9iywtkwmM/IwXcYfAFgt6XRatm3LNE2VSiVfb4sxBIDXCIMBhMawQ6y84HaYlt+3CwCYj3q93vOl3DAMFQqFkddj/AGA1VEul1Wv1yW1ykP4jTEEgNcIgwGERlC/br/++uuB3C4AwFv9we/Vq1fHOkSX8QcAVoNlWcpms5JaY0IsFvP9NhlDAHiNMBhAaHixwMIw1OwCgNXVaDQ6M8EkKZVKKZVKjXVdxh8AWA3pdFqSFIvFlMvl5nKbjCEAvEYYDCA0/P6g43Yo1bPPPuvr7QIA/NdeKEiSTNOc6NBgxh8AWH75fF6NRkPSfMpDtDGGAPAaYTCA0PD7V3U3/NoOAMutXC53AgDDMFSr1Sa6PuMPACy3RqOhYrEoSSqVSiMXDvUSYwgArxEGAwgNvz/QuNXzmueHRQCAt2zb7tSHlKQbN25MvF9n/AGA5Xb+/HlJUiKRUCaTmettM4YA8BphMIDQGParup+r5Qb1az4AYHbtAEBqHRY8zWJBjD8AsLzS6bRs25ZhGHMtD9HGGALAa4TBAEIjqHpbHGIFAMspm812ykOUSqWxF4zrx/gDAMupWq2qWq1Kkq5evRrIfpUxBIDX1oPuAADMUywW63yx72ZZ1lSzvdqG/SrPIVYAsHzK5bLK5bKkVhA862HBjD8AsFxs2+4sHhqLxWSapuN+fByWZTluc2vPNM2eMJYxBICXCIMBhEoikXD8IOVWK2tcbtef5cMZACAY9Xq9Uye4UCh4Uh+S8QcAlotlWZ2wtNFoKB6Pe9p+96zjfrVaTYlEonOaMQSAlygTASBUzp0757jd6df6Sbhdv/tDHABg8VmWpXQ6LUnK5XLK5XKetMv4AwCYFmMIAC8RBgMIFbcPNjs7OzO163aIVTKZnKldAMD82LateDwu27aVyWRUKBQ8a5vxBwAwLcYQAF4iDAYQKoZhOC6GMG39r7aXX37ZcfvZs2dnahcAMB/dQXAqlVKpVPK0fcYfAMC0GEMAeIkwGEDoONV+vHnz5kxtOn0Qi8VirMILAEugHQRblqVUKqVKpeLL7TD+AMDyiMViajabnvw5lRzK5XKul3eaCcwYAsArhMEAQqe9KFA327aHrqY7itMHsYsXL07dHgBgfs6fPy/LspRIJDwJghuNhuOYwvgDAJgWYwgArxAGAwgd0zQdV8it1+tTtde90nA3L1afBwD4K5lMqtFoKJFIqFarzdyebds6f/684xdsxh8AwLQYQwB4hTAYQCg5/bJ+7dq1qdqqVqsD2zKZDIdXAcCCSyaTqtfrisVingTBknTp0iWdPHnSdbEfxh8AwLQYQwB4IdJsNptBdwIAgrCxsTHwa/g0u8RoNCrLsnq27ezsyDTNWboHAPBROp1WtVqVaZra3t725MtvNptVuVxWoVBwrA/ZxvgDAOGSz+dVLBZ7tuVyORUKhYnbYgwBMCtmBgMIrcuXLw9sK5fLE7XRaDQGPkTlcjk+RAHAAstms54FwbZtq16vK5lMdsaQUYfYMv4AAKbFGAJgVswMBhBq8Xi8ZxVdwzC0t7c39fVN09TOzo6nfQQAeMdpdpaXUqnUWIvQMf4AQHh4OTNYYgwBMBtmBgMItUql0jMjzLZt5fP5sa5bLpd7PkRJ8qzmJADAe8Vi0dcgWHKu5+iE8QcAMC3GEACzIAwGEGpOhwgXi8WRh1rV6/WBL/y1Wo1DqwBgQZXL5bG/KE/LNE3XheOcLsv4AwCYBmMIgFkQBgMIvfaHqVgs1tmWzWaVTqcHamnZtq1sNqtkMtlz/Z2dnbEDAADAfFWr1bFn7M5i0ttg/AEATIsxBMC0qBkMAF3aM8e6V+g1DEOmacq2bceFFqat9QUAmI9IJDKX29nb25t6MTrGHwBYXV7XDO7HGAJgEoTBAOCgXq+rUqno5s2bsixLtm3LMAydPHlSsVhMFy9eVCKRmGkFegAA+jH+AACmxRgCYByEwQAAAAAAAAAQAtQMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAAAAAAgBAgDAYAAAAAAACAECAMBgAAAAAAAIAQIAwGAAAIqUajoXg8rkgkong8rnq9HnSXAAAAAPgo0mw2m0F3AgAAIAiRSMSTdgzD0MmTJzv/mqapZDKpRCIhwzA8uQ2vtYPgfrVaTYlEIoAeYZWE+b0FAACwyAiDAQBAaFWrVVmWpZdffln1el22bXt+G6ZpKpFIKJ/PyzRNz9ufVjqdVrVaHdgei8W0vb0dQI+wSsL83gIAAFhkhMEAAAB/KZvNqlwuD71MKpXSuXPn9Prrr0uSbNuWZVm6efPmyMCrHVwtwszbeDyuRqMxsN0wDO3t7QXQI6yyML23AAAAFhlhMAAAQJdoNCrLshzPy2QyKpVKrte1bVvXr19XqVRyDFrbUqmUKpXKzH2dhVs4l0gkVKvVAugRVl1Y3lsAAACLjAXkAAAAuqRSKdfznGrsdjMMQ5lMRtvb26rVaq6HrlerVcXjcV8OnR9XoVBwrLk6LJADZhGW9xYAAMAiIwwGAADoEo1GPWknkUhoe3tbsVjM8fxGo6F0Ou3JbU3DMAy98sorymQySiQSymQy2tnZofYqfBOW9xYwjWEz3gEA8BJhMAAAgE8Mw9CNGzccZ+BKUr1eV7FYnG+nuhiGoVKppFqtplKpRBCMpbHo7y1gErZt6/z58wTCAIC5IAwGAADwkWEYunr1quv5V65cmWNvgNXBewurIp1OU9oEADA3hMEAAABdTp486XmbqVTKdQajbduqVque3yawaHhvAYOKxaLq9XrQ3QAAhAhhMAAAwBwkEgnX865duzbHngCrhfcWllWj0VA+nw+6GwCAkCEMBgAAmINz5865nkedSGB6vLewjNp1ghEsy7JULpeVTqcVj8e1sbGhSCSiSCSiaDSqeDyudDqtfD7P/gTAylgPugMAAABhMGxxtrt3786xJ8Bq4b2FZXT+/HnqBAeoXC6rVCoNDXgty5L09EelYrEowzBUKBSUyWTm0k8A8ANhMAAAwBy41TUFMBveW1g2yWSSWaYBqdfrymaznaC3zTAMXbhwQfF4XJK0s7Ojcrk8ENjbtq1sNqtaraZKpTKvbgOApygTAQAAMAfDZoANm9nYrV6vK51OK5vNOrafzWYVjUY7h7dOUovSsixls9nOF+FlY9u2yuVy5zHoP9Q3mUyqWCwOBABe3nY6ne657Y2NDcXjcWWzWRaI8pEX7615v378fC8HcV+y2aw2NjZcL2NZlvL5fM9h+NFoVOl0eqL3RrVaHTicPxqNKpvN+hKuVqvVgcdx1vd1Mpmc2/7Aj/478fP17KVsNqtkMjnw2s9kMtrb21OpVFImk1Emk1GhUNDe3p5isZhjW9VqlXrPAJZXEwAAAB2VSqUpyfGvVCpN3W6hUHBtN5VKuV5vb2+vWSgUmqZpdi6fyWTG7nP/ZfuVSqVmLBbrXN40TcfLJRIJ19tw+6vVakNvO5PJjGxj2GPTbDabOzs7zVQq1XOdWCzWTKVSzVQq1fO4dbe5t7c3tN1x7OzsjHUfuvtVqVRc29vb25v4MR73OR7VRi6Xm/nxGGXR3lvN5nxfP36/l+d5X7a3t5uZTKZpGEZPe073eZz3SCKRGHp7uVxurPeCF6/jvb29Zi6XG7hvbn+maY7c1zWbrcfM6TkY588wjMD773Q7fr6eveY2ho267zs7O548LwCwSAiDAQAAuvgVWPWHNMPa3dvbGwhp3b5ED+uvW0DTDnLcggE329vbI0Nh0zSblUpl7IDJrS+GYYz8kt4fciYSiebOzo7jbfSHMIZhOF52XP0BZCqVatZqtZ77vb297fgcxmIx18dnZ2enWSgURgY5mUxm4PaG2dvba9ZqtYHHYdogaBqL8N7qNo/Xj9/v5Xndl729vWalUmmmUqmhr83+Po0bSLbfQ+P0d9RfoVAY9bS4qtVqPX2OxWLNTCbTLJVKzVwuN/T+j/rhYZL74LQ/DLr/zeb8Xs9ec9tHjPtaGfYa9OKHRQCYN8JgAACALn4FVsNCkfaXyVqtNtYM3PYX7lqtNlaQsLOz4ziLy+lvWBjc5hYESKNnWbnp/7I+KpzqnykYi8WGXt5p1u0499Wpne7nyDTN5vb29tDLOz33pmkODRG2t7dneo7c9L++ZwnEZ73teb63+vn9+vHzvTzv+9JsPp1VOSrcbbfffd8Nw2imUqlmLpdr5nK5ofuP7tdBd8Dd3UahUHCd6TzL67r7B55YLDa0Dbcf00Yd5dH+c5vN3v4hzekvyP7P8/XsNbcjI0bNRu/m9ngxMxjAsiIMBgAA6OJHYDXsMP3+mVSZTKZZKBSGHlqdyWQ6h64ahtEsFArNSqXiGo7s7e11ZoTFYrGhIco4QeOww2anDYO7A61Rh3o7PUfDyi+0OQUwk84i7C+pMU5I43aI+6iZeG6B0SxhcHeb8ygN0S3I99aofnj9+vHzvTzv+9JsNgdmvA97/7cD40Qi4fpDidtrof3abvfPMIyh92fa99aw/owbEs4y29Tt/g/7YSnI/s/r9ewHtx8wJhmr3MLtWWahA0CQCIMBAAC6eB1Yuc0Mbf8NmxnlFgamUqlOqNt//f4v+G6hiFuINm7Q6BYkTBswds86GxUQOAUL49bsnPb+NpuTz14edrvjtDGshvC0IUp3mD3PWcHN5uK8t4J4/fj1Xg7qvTAsEDQMY6xQ0y3Ibe8LhpVTGacv4+p/LCYpvTLN+7rZ9DYMDqL/fo5NXnILcaeZ0dvf/3n/mAYAXiIMBgAA6OJ1YDVLSYVhM3CHfemv1WrNXC43sr9u5QvG4da3aWetjhsQuN3uOM+NW/gx6SHY0uQzwtyew1GzON2CrmlmpHU/dqNKCfhhEd5bQb1+/HgvB3Vfmk33H5MMwxi7jWGPybiz7ptN9x9bxp352R2oT/q+ciudMGpxNC/D4CD67/fY5BWvZo63bW9vT1QTHwAW1QEBAADAc/V6XdFoVI1Gw/H8QqGgRCIxtA3TNF3PK5VKMgzD8bxEIqFCoaBMJjN1+6OYpunYf8uyVK/XJ2qrXC53/n/58uWhl7Usy3H7zs7OyNtxe7zc2ux25cqVntO5HvU62gAAEE9JREFUXG7kdbq5PRdufWorFApj9Wcc1Wq18/9sNjvx9RfFLO+toF4/fryXg7ovknTy5EnH7VevXh35mm4zTdP1calUKmO3E4vFHLe7vT66VavVnvucSqXGus22dDrtuL17n+anoPrv99i0qGKxmFKp1NivTQBYVITBAAAAHrFtW+VyWfF4XMlk0jVYqVQqE4eJ3QzD8OTLtFugMy63oLJUKk3UTvvypmm6BjttZ8+eddx+7ty5iW6z26gALJ/Py7btzulpHvtCoTAQILgF6t0Mw3AMeNqvtUl0Py/LFsZ49d4K4vUzzCzv5SDvi1sYNmlI5hYqjtoPjNPOOKF4Pp/vaWPSH8iGvX/HCaNntWj992ps8sqzzz4bdBcAYCERBgMAAIwpn893wqh0Oq10Oq1kMql4PK6NjQ1tbGwom826fomOxWLa2dmZePZWv1EB4rzEYjHH0KZarfaEp8NYltV5vLqDDTeGYQyEfYlEYubHdJhisdhzOplMTtyGYRja3t5WIpGQaZrKZDLa3t4e67pus6XdwngnlmV1gj4/H6tpzeu9FcTrZ5hZ3suLdl+mMcvRCd2cQuhRwXaj0ei5zKQBtDS8/5MeITGpRez/ooxNbW798fu5AYBFtx50BwAAAJaFbdtTzZZKpVK6fPnyVF/Wncw6o9dLly9fdjzUuFwujzX7uXu26oULF8a6zUKhoGQyqVqtpnPnzs0cft29e9f1PKfQYNrAwzRN1Wq1ia8Xi8WUSCQG+tIuyTFOf7of50UsETHP99Y8Xz+jeDE7f1HuyzS8Otze6XEcdV/630/ValWRSMST/kjjzUyexSL2f5HGJsl932nbtorF4kxH6ADAMiMMBgAAGFM7uHCa9WoYhk6ePCnDMHT27FlFo9HOF9FV1q6f2P+YlEqlsb5ot0sdTFqHMZFITPzYdtfMHVelUuk5bRhGIPUi8/m8YzA9Tu1p6el9NwxjIV+T835vzev1Mw+rdF+8NOrohGvXrvl6+zdv3vS1/WXv/7xUKhXF4/GBmeL5fF47OzuOJXyk1uvn7t27nX0PAKwSwmAAAIAxLfPCN37KZDIDpRTa5R+Gzdis1+udwGbUwnHTateavXLlytilK7r1B7BBzXxLJBKKxWIDs2fr9bosyxp6uHf34eSL+vpd1PfWrK+fRbJK98UL/e+lXC7n237ID8ve/3kxDEM7OzsqFosDpYjK5bLK5bIMw5BpmrJt27G8SCKRmOqoDgBYVITBAAAAmEk2mx0IgyXpypUrAzNru02ycNykGo2Grly50jMD0ilMHaU/GAhyhphbSY58Pj/W4ywtZomIReTV62cRrNJ98YpbGL4sM0CXvf9ByOVySqVSjgtQjipTsyqzpAGgjQXkAAAAMBPTNB0PUx+1kFw7nPIyoKxWq4rH44rH4532c7mcdnZ2xl6wrW3UAlTzlkqlHGcAj3qcr1+/LqkVAHq1YNeq8vL1E7RVui9em3dtZK8te//nzbIspdNpRaPRqfbrw35sA4BlRBgMAACAmfUfftvWDiL7tWsFS96ULiiXy4pGo0qn02o0GjIMQ4VCQc1mU4VCYaoQ1ClgDfrwerfH+cqVK47bu0txMCvYnR+vn6Cs0n3xi1MguGg//gyz7P2fp3w+r2g06lgnO5fLqVaraW9vT81mUzs7O6rVaioUCsrlcqpUKmo2mwtZZx0AZkGZCAAAAMwskUjINM2BQMKtFmy7dMGkC8f1q9frymazPbeby+VUKBSmbrPNafZd0IFLJpNRPp8fCKWLxaLjfe6e0baINXmD5ufrZ95W6b74zelHnaDf25NY9v7Pg23bOn/+vGP5h1gspkqlMvDDiGmarke6AMAqYWYwAAAAPOE087S9kJzbtllmq+bz+Z76j6Zpant72/fwK+jQxS3Udarb3J6BnUqlfO3TMgrq9eOHVbov8+D0A9Qy1VBe9v7PQ3tmfD/DMHTjxg1myAMINcJgAAAAeMItpOxewKz79CwzsJLJZE/42Q6/vFyI7uTJk47bgw5dLl++7Li9v1RE92HRlIjoNY/Xz7ys0n2ZF7f3dr1en3NPprPs/fdbPp93fSxu3LjBQnsAQo8wGAAAAJ4wDMNxBmp3feDu09MGlMlkcuCLfqVS8fwLvlt7tVrN09uZlGEYjsG7bds9AfC1a9c6l+ew56fm9fqZh1W6L/Pk9vgsy0Jhy95/P1mW5XiUhNQqD8GPJABAGAwAAAAPuc1abQfA3QuaTVPDtlwuD4RfiUTCly/4bocR94fbQRhnIbl2MEyt4Kfm+frx2yrdl3lze2+7LXg5jUajoWQy6Vl73Za9/34aVhrl4sWLc+wJACwuwmAAAAB4xm3mVbs0xKwLxzl90U+n0xO3My63YM2LQNiyLG1sbExVg9itxEaj0VCj0aBEhIt5v378tEr3JQhO723btj0rteD3c7Hs/ffLsECc2ukA0EIYDAAAAE85hY+NRkP1er0TUk4TUDYaDcfg1M+FgNzKK+Tz+c4M52ml0+nO6vXTcJsBl8/nO6F7LBZjoaS/FMTrxy+rdF+CcvbsWcftXvx4ks1mZVmW6wx+Lyx7//1g2/bQ/bJX749Z9/0AEDTCYAAAgC53794NugtLz60sQXum2bQ1bG/evOm43c8v5m6HFdu2rUuXLk3dbjabVaPR0NWrV6duIxaLOT6O9Xq9MztwkWYFB/3eCuL145dVui9BcZv5OmsIWq1WVS6XXd+fw0zyHlnE/odBtVrVxsZGz9EXALBsCIMBAADQ4VVg57bAmeReV3iUnZ0dx+0vv/zyWNefJigbtuBQtVqdKmzNZrMql8tKpVIz13dtzwB2Q73gp4J4/fhlle6Lk3n0L5FIuJaqKRaLU4V99Xq9E9JO80PPJPd7Efu/6BqNxkzX7/4RkKAcwDIjDAYAAOgy7Mv4ogQoQc+wHMewmWnTBpTPPvus4/ZxQw+3Or+jntdh4XW5XFY6nR77tZFOpzv98CJsMU3TtQ7motXHDPq9FdTrZ5hp38tB35dF2RfOati+qPu9Oo5yudxZcG3UDz1uIe64YX5bUP13E/TYZBjG0FIQ3QtsTuPSpUuybVuZTGaqmvcAsCgIgwEAALq4zbgbdd48TbPg2LjteBXyuC1wNmw22zhtOrEsa2Tokc/nXQPqUc9rKpUaGqxWq1WdPn1a+Xze9TEtFos9hxaXSiXPwgS32sGLVCJCCv69FdTrZ5hp38tB3xevQj+3/c2k7Ttdfpw2CoXC0PAwm80qmUwOXZStWq0qGo123m+maapSqQy9Xbd6v8PCfKf9S1D9d+PV2DSLYfu9arU6dQmNZDKparUq0zRHHpEBAAuvCQAAgA7TNJuSHP8Mw5hrX7a3t33th9v93NnZ8aT9SqUy0HatVpu6vb29Pdc+S2rmcrnm3t5e5/Lb29vNXC7XOT+VSjk+v4Zh9Fwvl8s1K5XKwG0bhjH09rv/TNN0fS2lUqmpHwM3iUQi0NfqOIJ+bwX5+vH6vRzkfWlvd7rdUqk00f3of91O247be3MctVptrPe0YRjNWCzWzGQyzVQq1YzFYo6XGXf/6dZnp/ueSqVc981B9N/vsWlWw/Y1kpqJRGLssahSqfS0t7297XPvAcB/hMEAAAB/yS3g6P7LZDJz649bUNIOe2ZRKpV8a7tbd+DhRVAwznPkFLK0A5Z2qOL01/2F3yko2NnZmSgQdvrzIwhuNgeDdy+fQy8synsrqNePH+/lIN8Lbu+DRCIxdv93dnaG3v64nH506r+vowzbH477N0kQ3Gw2m5lMxrWtRCLRLBQKzVwu13msnUL5oPrv59jkhXH31aZpNlOpVLNQKDRLpVKzUqk0S6VSM5fLNVOp1EAbBMEAVgVhMAAACK1ardYslUrNTCYzUchnGEYzk8l0vjx6NZO22WzNuCoUCiNnNklqxmKxiW5/b2+vWavVhoYQ7b9UKtWs1Wo9swSn0R1YFQqFmdpqG+ex6f6y3/0FfpzQZFiYsbOzM9Htd/95df+d9M8U9fI1OY1FfG+1zev14+d7ed73pdlsvfb7Z0k6/bVnXbrtO3Z2dpqFQmHk68I0TdfHZG9vr7m9vT3WvqxQKIz1uM4SqCYSiYn3laNmd3f/jRNq+93/ebyevbS3tzc0tJ7kLxaLBb5PBQAvEQYDAIDQ8uJLouTdbM9hM/XG+Rs2a2nWL8LT6p79N2uw3Dbul3y38HVYmDHuTMJCoTBR0OL3jLLux3mW58sri/be6jaP14+f7+V535dmc/rns/+1OG073TOFJwlRJ31/7+zsTBQgtgPraQ2b1Sy1fhyZpLSOX/2f1+vZD5VKxbEkxriv31meXwBYVJFms9kUAAAA4JNsNqtoNKpcLudpu9VqVaVSSTdv3pRt2zJNU6ZpKp1OK5PJuF7Ptm1dunRJjUZDlmXJMAxduHBB+Xx+6GJMbn24du2aGo2G7t69K9u2OyvaJxIJXbx4UbFYbNa7OlK5XO4snFQqlYbef7QswuvHK6t0XxaBZVmqVquq1WqyLKuzMFr3ezuZTDoukjnNbeXzedXr9c7+4+zZsyOfu0Xp/7KwLEv1el3b29u6efOmLMvqWcCw/dicPXtW8XhciUQi1O8BAKuNMBgAAABYcvF4XI1GQ5LEx3sAAAC4ORB0BwAAAABMz7btThDMjGAAAAAMQxgMAAAALLErV650/t8uFQEAAAA4oUwEAAAAsMQ2NjZk27ZisZi2t7eD7g4AAAAWGDODAQAAgCVVLpc7iyBdvnw52M4AAABg4TEzGAAAAFhCtm3r9OnTsm1bpmlqZ2cn6C4BAABgwTEzGAAAAFhAtm13Zv06SafTnfPz+fx8OgUAAIClRhgMAAAALBDbthWPx7WxsaGNjQ1FIhElk8lOSQjLspRMJlWv1yVJpmkqk8kE3GsAAAAsA8pEAAAAAAsknU6rWq2OfflaraZEIuFjjwAAALAqCIMBAACABRKJRMa+bCaTUalU8rE3AAAAWCWEwQAAAMACiUajsixr5OVisZi2t7fn0CMAAACsCmoGAwAAAAtknMXgCIIBAAAwDcJgAAAAYIFkMhkVCgXX83O5HEEwAAAApkKZCAAAAGAB2bater2ul19+WZJ07tw5JRIJGYYRbMcAAACwtAiDAQAAAAAAACAEKBMBAAAAAAAAACFAGAwAAAAAAAAAIUAYDAAAAAAAAAAhQBgMAAAAAAAAACFAGAwAAAAAAAAAIUAYDAAAAAAAAAAhQBgMAAAAAAAAACFAGAwAAAAAAAAAIUAYDAAAAAAAAAAhQBgMAAAAAAAAACFAGAwAAAAAAAAAIUAYDAAAAAAAAAAhQBgMAAAAAAAAACFAGAwAAAAAAAAAIUAYDAAAAAAAAAAhQBgMAAAAAAAAACFAGAwAAAAAAAAAIUAYDAAAAAAAAAAhQBgMAAAAAAAAACFAGAwAAAAAAAAAIUAYDAAAAAAAAAAhQBgMAAAAAAAAACFAGAwAAAAAAAAAIUAYDAAAAAAAAAAhQBgMAAAAAAAAACFAGAwAAAAAAAAAIUAYDAAAAAAAAAAhQBgMAAAAAAAAACFAGAwAAAAAAAAAIfD/B1uFFvToREOpAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1391.52x1043.64 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import scienceplots\n",
    "from scipy.optimize import curve_fit\n",
    "plt.style.use(['ieee', 'science', 'grid'])\n",
    "\n",
    "textwidth = 3.31314\n",
    "aspect_ratio = 6/8\n",
    "scale = 0.7\n",
    "width = textwidth * scale\n",
    "height = width * aspect_ratio\n",
    "fig = plt.figure(figsize=(width, height))\n",
    "\n",
    "def model(x, l, m, c, s):\n",
    "    return s * (l * m * (1 - np.exp(-x )) + l + c) **2\n",
    "\n",
    "colors = plt.cm.tab10(np.linspace(0, 1, 10))\n",
    "\n",
    "colors = ['red', 'green', 'blue', 'orange']\n",
    "for c_idx, (key, val) in enumerate(accs.items()):\n",
    "    popt, _ = curve_fit(model, epsilons, aucs[key])#\n",
    "    l = popt[0]\n",
    "    m = popt[1]\n",
    "    c = popt[2]\n",
    "    s = popt[3]\n",
    "    epsilons_fine = np.linspace(1.0, 50, 100)\n",
    "\n",
    "    # The theorem predicts and upper bound so add offset\n",
    "    fitted_vals = model(epsilons_fine, l, m, c, s) + 0.015\n",
    "\n",
    "    # Plot the original data points\n",
    "    plt.scatter(epsilons, aucs[key], color=colors[c_idx], alpha=0.5, s=2)\n",
    "    \n",
    "    # Plot the fitted curve\n",
    "    # The theorem predicts and upper bound so \n",
    "    plt.plot(epsilons_fine, fitted_vals, label='Best Fit', color=colors[c_idx], lw=0.5, ls='dashed')\n",
    "    \n",
    "\n",
    "plt.xlabel('Privacy Parameter $\\epsilon$')\n",
    "plt.ylabel('AUROC')\n",
    "plt.legend()\n",
    "plt.savefig(\"./plots/eps_vs_acc.png\")\n",
    "plt.savefig(\"./plots/eps_vs_acc.svg\")\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py3.11_tf",
   "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.11.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}